# Python decimal.ROUND_HALF_EVEN() Examples

The following are code examples for showing how to use decimal.ROUND_HALF_EVEN(). They are extracted from open source Python projects. You can vote up the examples you like or vote down the ones you don't like. You can also save this page to your account.

Example 1
 Project: pythonVSCode   Author: DonJayamanne   File: pie_slice.py    (license) View Source Project 6 votes
```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) ```
Example 2
 Project: lddmm-ot   Author: jeanfeydy   File: tools.py    (license) View Source Project 6 votes
```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]) ```
Example 3
```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) ```
Example 4
 Project: health-mosconi   Author: GNUHealth-Mosconi   File: currency.py    (license) View Source Project 5 votes
```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 ```
Example 5
```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 ```
Example 6
```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 ```
Example 7
```def round_price(self, price: str) -> Decimal:
return Decimal(price).quantize(self.quote_increment, rounding=ROUND_HALF_EVEN) ```
Example 8
```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) ```
Example 9
 Project: gnuhealth-live   Author: kret0s   File: currency.py    (license) View Source Project 5 votes
```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 ```
Example 10
 Project: QualquerMerdaAPI   Author: tiagovizoto   File: utils.py    (license) View Source Project 5 votes
```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)) ```
Example 11
 Project: locust-demo   Author: bmd   File: fields.py    (license) View Source Project 5 votes
```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)) ```
Example 12
 Project: go2mapillary   Author: enricofer   File: encoder.py    (license) View Source Project 5 votes
```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) ```
Example 13
 Project: noobotkit   Author: nazroll   File: fields.py    (license) View Source Project 5 votes
```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)) ```
Example 14
 Project: Chorus   Author: DonaldBough   File: fields.py    (license) View Source Project 5 votes
```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)) ```
Example 15
 Project: otRebuilder   Author: Pal3love   File: py23.py    (MIT License) View Source Project 4 votes
```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)

Example 16
```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: ```
Example 17
 Project: packaging   Author: blockstack   File: newround.py    (license) View Source Project 4 votes
```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: ```
Example 18
 Project: islam-buddy   Author: hamir   File: newround.py    (license) View Source Project 4 votes
```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: ```
Example 19
 Project: performance   Author: python   File: bm_telco.py    (license) View Source Project 4 votes
```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:

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):
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 ```
Example 20
 Project: gnuhealth-live   Author: kret0s   File: stock.py    (license) View Source Project 4 votes
```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) ```
Example 21
 Project: FightstickDisplay   Author: calexil   File: newround.py    (license) View Source Project 4 votes
```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: ```
Example 22
 Project: cryptogram   Author: xinmingzhang   File: newround.py    (license) View Source Project 4 votes
```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: ```
Example 23
 Project: Repobot   Author: Desgard   File: newround.py    (license) View Source Project 4 votes
```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: ```
Example 24
 Project: UMOG   Author: hsab   File: newround.py    (license) View Source Project 4 votes
```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: ```
Example 25
 Project: blackmamba   Author: zrzka   File: newround.py    (license) View Source Project 4 votes
```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: ```
Example 26
 Project: beepboop   Author: nicolehe   File: newround.py    (license) View Source Project 4 votes
```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: ```
Example 27
 Project: hackathon   Author: vertica   File: newround.py    (license) View Source Project 4 votes
```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: ```
Example 28
```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: ```