我们从Python开源项目中，提取了以下28个代码示例，用于说明如何使用decimal.ROUND_HALF_EVEN。
def round(number, ndigits=None): return_int = False if ndigits is None: return_int = True ndigits = 0 if hasattr(number, '__round__'): return number.__round__(ndigits) if ndigits < 0: raise NotImplementedError('negative ndigits not supported yet') exponent = Decimal('10') ** (-ndigits) d = Decimal.from_float(number).quantize(exponent, rounding=ROUND_HALF_EVEN) if return_int: return int(d) else: return float(d)
def _convert_to_RGB_255(colors): """ Multiplies each element of a triplet by 255 Each coordinate of the color tuple is rounded to the nearest float and then is turned into an integer. If a number is of the form x.5, then if x is odd, the number rounds up to (x+1). Otherwise, it rounds down to just x. This is the way rounding works in Python 3 and in current statistical analysis to avoid rounding bias """ rgb_components = [] for component in colors: rounded_num = decimal.Decimal(str(component*255.0)).quantize( decimal.Decimal('1'), rounding=decimal.ROUND_HALF_EVEN ) # convert rounded number to an integer from 'Decimal' form rounded_num = int(rounded_num) rgb_components.append(rounded_num) return (rgb_components[0], rgb_components[1], rgb_components[2])
def __init__(self, min_value=None, max_value=None, force_string=False, precision=2, rounding=decimal.ROUND_HALF_UP, **kwargs): """ :param min_value: Validation rule for the minimum acceptable value. :param max_value: Validation rule for the maximum acceptable value. :param force_string: Store as a string. :param precision: Number of decimal places to store. :param rounding: The rounding rule from the python decimal library: - decimal.ROUND_CEILING (towards Infinity) - decimal.ROUND_DOWN (towards zero) - decimal.ROUND_FLOOR (towards -Infinity) - decimal.ROUND_HALF_DOWN (to nearest with ties going towards zero) - decimal.ROUND_HALF_EVEN (to nearest with ties going to nearest even integer) - decimal.ROUND_HALF_UP (to nearest with ties going away from zero) - decimal.ROUND_UP (away from zero) - decimal.ROUND_05UP (away from zero if last digit after rounding towards zero would have been 0 or 5; otherwise towards zero) Defaults to: ``decimal.ROUND_HALF_UP`` """ self.min_value = min_value self.max_value = max_value self.force_string = force_string self.precision = precision self.rounding = rounding super(DecimalField, self).__init__(**kwargs)
def round(self, amount, rounding=ROUND_HALF_EVEN): 'Round the amount depending of the currency' return (amount / self.rounding).quantize(Decimal('1.'), rounding=rounding) * self.rounding
def get_lower_price(self, price: str) -> Decimal: lower_price = Decimal(price).quantize(self.quote_increment, rounding=ROUND_HALF_EVEN) - self.quote_increment return lower_price
def get_higher_price(self, price: str) -> Decimal: higher_price = Decimal(price).quantize(self.quote_increment, rounding=ROUND_HALF_EVEN) + self.quote_increment return higher_price # Note that this rounds down
def round_price(self, price: str) -> Decimal: return Decimal(price).quantize(self.quote_increment, rounding=ROUND_HALF_EVEN)
def _round(self, val): # Prefer provided round function. if self.round_fn: return self.round_fn(val) # round() has different behavior in python 2/3 # For consistency between 2 and 3 we use quantize, however # it is slower than the built in round function. d = decimal.Decimal(val) rounded = d.quantize(1, rounding=decimal.ROUND_HALF_EVEN) return float(rounded)
def decimal_to_fixed(value, precision): """Convert a `Decimal` to a fixed-precision number as a string.""" return text_type(value.quantize(precision, rounding=ROUND_HALF_EVEN))
def format(self, value): dvalue = MyDecimal(value) if not dvalue.is_normal() and dvalue != ZERO: raise MarshallingException('Invalid Fixed precision number.') return six.text_type(dvalue.quantize(self.precision, rounding=ROUND_HALF_EVEN))
def _round_quantize(self, val): # round() has different behavior in python 2/3 # For consistency between 2 and 3 we use quantize, however # it is slower than the built in round function. d = decimal.Decimal(val) rounded = d.quantize(1, rounding=decimal.ROUND_HALF_EVEN) return float(rounded)
def round3(number, ndigits=None): """ Implementation of Python 3 built-in round() function. Rounds a number to a given precision in decimal digits (default 0 digits). This returns an int when ndigits is omitted or is None, otherwise the same type as the number. Values are rounded to the closest multiple of 10 to the power minus ndigits; if two multiples are equally close, rounding is done toward the even choice (aka "Banker's Rounding"). For example, both round(0.5) and round(-0.5) are 0, and round(1.5) is 2. ndigits may be negative. See Python 3 documentation: https://docs.python.org/3/library/functions.html?highlight=round#round Derived from python-future: https://github.com/PythonCharmers/python-future/blob/master/src/future/builtins/newround.py """ if ndigits is None: ndigits = 0 # return an int when called with one argument totype = int # shortcut if already an integer, or a float with no decimal digits inumber = totype(number) if inumber == number: return inumber else: # return the same type as the number, when called with two arguments totype = type(number) m = number * (10 ** ndigits) # if number is half-way between two multiples, and the mutliple that is # closer to zero is even, we use the (slow) pure-Python implementation if isclose(m % 1, .5) and int(m) % 2 == 0: if ndigits < 0: exponent = 10 ** (-ndigits) quotient, remainder = divmod(number, exponent) half = exponent//2 if remainder > half or (remainder == half and quotient % 2 != 0): quotient += 1 d = quotient * exponent else: exponent = _decimal.Decimal('10') ** (-ndigits) if ndigits != 0 else 1 d = _decimal.Decimal.from_float(number).quantize( exponent, rounding=_decimal.ROUND_HALF_EVEN) else: # else we use the built-in round() as it produces the same results d = round2(number, ndigits) return totype(d)
def newround(number, ndigits=None): """ See Python 3 documentation: uses Banker's Rounding. Delegates to the __round__ method if for some reason this exists. If not, rounds a number to a given precision in decimal digits (default 0 digits). This returns an int when called with one argument, otherwise the same type as the number. ndigits may be negative. See the test_round method in future/tests/test_builtins.py for examples. """ return_int = False if ndigits is None: return_int = True ndigits = 0 if hasattr(number, '__round__'): return number.__round__(ndigits) if ndigits < 0: raise NotImplementedError('negative ndigits not supported yet') exponent = Decimal('10') ** (-ndigits) if PYPY: # Work around issue #24: round() breaks on PyPy with NumPy's types if 'numpy' in repr(type(number)): number = float(number) if not PY26: d = Decimal.from_float(number).quantize(exponent, rounding=ROUND_HALF_EVEN) else: d = from_float_26(number).quantize(exponent, rounding=ROUND_HALF_EVEN) if return_int: return int(d) else: return float(d) ### From Python 2.7's decimal.py. Only needed to support Py2.6:
def bench_telco(loops, filename): getcontext().rounding = ROUND_DOWN rates = list(map(Decimal, ('0.0013', '0.00894'))) twodig = Decimal('0.01') Banker = Context(rounding=ROUND_HALF_EVEN) basictax = Decimal("0.0675") disttax = Decimal("0.0341") with open(filename, "rb") as infil: data = infil.read() infil = io.BytesIO(data) outfil = six.StringIO() start = perf.perf_counter() for _ in range(loops): infil.seek(0) sumT = Decimal("0") # sum of total prices sumB = Decimal("0") # sum of basic tax sumD = Decimal("0") # sum of 'distance' tax for i in xrange(5000): datum = infil.read(8) if datum == '': break n, = unpack('>Q', datum) calltype = n & 1 r = rates[calltype] p = Banker.quantize(r * n, twodig) b = p * basictax b = b.quantize(twodig) sumB += b t = p + b if calltype: d = p * disttax d = d.quantize(twodig) sumD += d t += d sumT += t print(t, file=outfil) outfil.seek(0) outfil.truncate() return perf.perf_counter() - start
def allocate_cost_by_value(self): pool = Pool() Currency = pool.get('currency.currency') Move = pool.get('stock.move') if not self.cost: return cost = Currency.compute(self.cost_currency, self.cost, self.company.currency, round=False) moves = [m for m in self.incoming_moves if m.state not in ('done', 'cancel')] sum_value = 0 unit_prices = {} for move in moves: unit_price = Currency.compute(move.currency, move.unit_price, self.company.currency, round=False) unit_prices[move.id] = unit_price sum_value += unit_price * Decimal(str(move.quantity)) costs = [] digit = Move.unit_price.digits[1] exp = Decimal(str(10.0 ** -digit)) difference = cost for move in moves: quantity = Decimal(str(move.quantity)) if not sum_value: move_cost = cost / Decimal(len(moves)) else: move_cost = cost * quantity * unit_prices[move.id] / sum_value unit_shipment_cost = (move_cost / quantity).quantize(exp, rounding=ROUND_DOWN) costs.append({ 'unit_shipment_cost': unit_shipment_cost, 'difference': move_cost - (unit_shipment_cost * quantity), 'move': move, }) difference -= unit_shipment_cost * quantity costs.sort(key=itemgetter('difference')) for cost in costs: move = cost['move'] quantity = Decimal(str(move.quantity)) if exp * quantity < difference: cost['unit_shipment_cost'] += exp difference -= exp * quantity if difference < exp: break for cost in costs: move = cost['move'] unit_shipment_cost = Currency.compute( self.company.currency, cost['unit_shipment_cost'], move.currency, round=False) unit_shipment_cost = unit_shipment_cost.quantize( exp, rounding=ROUND_HALF_EVEN) move.unit_price += unit_shipment_cost move.unit_shipment_cost = unit_shipment_cost Move.save(moves)
