Xavier Morel
ace4ee39e8
In Python 3 round:
* rounds half to even (banker's rounding) rather than up
* returns an int if not given a precision (or given a precision of
None)
* discards the negative sign when rounding to 0
Add a compatibility shim which implements P2 behaviour and at least
allows passing float_utils's tests.
Implementing float_round on top of Decimal was attempted but did not
work: although Decimal.quantize takes a non-integral
Decimal (e.g. ``d.quantize(D('0.001'))``) it only supports integral
powers of 10 and does not support quantizing to e.g. 0.05: while that
will not fail it will just use the exponent for quantization and 0.05
is thus equivalent to 0.01, which is not what we want if e.g. need to
round a value to 5 cents.
This is hinted at but maybe not clearly spelled out by the official
documentation:
> Return a value equal to the first operand after rounding
> and **having the exponent of** the second operand.
Also convert a bunch of hand-rolled currency rounding to just using
the round() method on res.currency.
218 lines
10 KiB
Python
218 lines
10 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
|
|
from __future__ import print_function
|
|
import math
|
|
|
|
from odoo.tools import pycompat
|
|
|
|
|
|
def _float_check_precision(precision_digits=None, precision_rounding=None):
|
|
assert (precision_digits is not None or precision_rounding is not None) and \
|
|
not (precision_digits and precision_rounding),\
|
|
"exactly one of precision_digits and precision_rounding must be specified"
|
|
if precision_digits is not None:
|
|
return 10 ** -precision_digits
|
|
return precision_rounding
|
|
|
|
def float_round(value, precision_digits=None, precision_rounding=None, rounding_method='HALF-UP'):
|
|
"""Return ``value`` rounded to ``precision_digits`` decimal digits,
|
|
minimizing IEEE-754 floating point representation errors, and applying
|
|
the tie-breaking rule selected with ``rounding_method``, by default
|
|
HALF-UP (away from zero).
|
|
Precision must be given by ``precision_digits`` or ``precision_rounding``,
|
|
not both!
|
|
|
|
:param float value: the value to round
|
|
:param int precision_digits: number of fractional digits to round to.
|
|
:param float precision_rounding: decimal number representing the minimum
|
|
non-zero value at the desired precision (for example, 0.01 for a
|
|
2-digit precision).
|
|
:param rounding_method: the rounding method used: 'HALF-UP' or 'UP', the first
|
|
one rounding up to the closest number with the rule that number>=0.5 is
|
|
rounded up to 1, and the latest one always rounding up.
|
|
:return: rounded float
|
|
"""
|
|
rounding_factor = _float_check_precision(precision_digits=precision_digits,
|
|
precision_rounding=precision_rounding)
|
|
if rounding_factor == 0 or value == 0: return 0.0
|
|
|
|
# NORMALIZE - ROUND - DENORMALIZE
|
|
# In order to easily support rounding to arbitrary 'steps' (e.g. coin values),
|
|
# we normalize the value before rounding it as an integer, and de-normalize
|
|
# after rounding: e.g. float_round(1.3, precision_rounding=.5) == 1.5
|
|
|
|
# TIE-BREAKING: HALF-UP (for normal rounding)
|
|
# We want to apply HALF-UP tie-breaking rules, i.e. 0.5 rounds away from 0.
|
|
# Due to IEE754 float/double representation limits, the approximation of the
|
|
# real value may be slightly below the tie limit, resulting in an error of
|
|
# 1 unit in the last place (ulp) after rounding.
|
|
# For example 2.675 == 2.6749999999999998.
|
|
# To correct this, we add a very small epsilon value, scaled to the
|
|
# the order of magnitude of the value, to tip the tie-break in the right
|
|
# direction.
|
|
# Credit: discussion with OpenERP community members on bug 882036
|
|
|
|
normalized_value = value / rounding_factor # normalize
|
|
epsilon_magnitude = math.log(abs(normalized_value), 2)
|
|
epsilon = 2**(epsilon_magnitude-53)
|
|
if rounding_method == 'HALF-UP':
|
|
normalized_value += math.copysign(epsilon, normalized_value)
|
|
rounded_value = pycompat.round(normalized_value) # round to integer
|
|
|
|
# TIE-BREAKING: UP (for ceiling operations)
|
|
# When rounding the value up, we instead subtract the epsilon value
|
|
# as the the approximation of the real value may be slightly *above* the
|
|
# tie limit, this would result in incorrectly rounding up to the next number
|
|
# The math.ceil operation is applied on the absolute value in order to
|
|
# round "away from zero" and not "towards infinity", then the sign is
|
|
# restored.
|
|
|
|
elif rounding_method == 'UP':
|
|
sign = math.copysign(1.0, normalized_value)
|
|
normalized_value -= sign*epsilon
|
|
rounded_value = math.ceil(abs(normalized_value))*sign # ceil to integer
|
|
|
|
result = rounded_value * rounding_factor # de-normalize
|
|
return result
|
|
|
|
def float_is_zero(value, precision_digits=None, precision_rounding=None):
|
|
"""Returns true if ``value`` is small enough to be treated as
|
|
zero at the given precision (smaller than the corresponding *epsilon*).
|
|
The precision (``10**-precision_digits`` or ``precision_rounding``)
|
|
is used as the zero *epsilon*: values less than that are considered
|
|
to be zero.
|
|
Precision must be given by ``precision_digits`` or ``precision_rounding``,
|
|
not both!
|
|
|
|
Warning: ``float_is_zero(value1-value2)`` is not equivalent to
|
|
``float_compare(value1,value2) == 0``, as the former will round after
|
|
computing the difference, while the latter will round before, giving
|
|
different results for e.g. 0.006 and 0.002 at 2 digits precision.
|
|
|
|
:param int precision_digits: number of fractional digits to round to.
|
|
:param float precision_rounding: decimal number representing the minimum
|
|
non-zero value at the desired precision (for example, 0.01 for a
|
|
2-digit precision).
|
|
:param float value: value to compare with the precision's zero
|
|
:return: True if ``value`` is considered zero
|
|
"""
|
|
epsilon = _float_check_precision(precision_digits=precision_digits,
|
|
precision_rounding=precision_rounding)
|
|
return abs(float_round(value, precision_rounding=epsilon)) < epsilon
|
|
|
|
def float_compare(value1, value2, precision_digits=None, precision_rounding=None):
|
|
"""Compare ``value1`` and ``value2`` after rounding them according to the
|
|
given precision. A value is considered lower/greater than another value
|
|
if their rounded value is different. This is not the same as having a
|
|
non-zero difference!
|
|
Precision must be given by ``precision_digits`` or ``precision_rounding``,
|
|
not both!
|
|
|
|
Example: 1.432 and 1.431 are equal at 2 digits precision,
|
|
so this method would return 0
|
|
However 0.006 and 0.002 are considered different (this method returns 1)
|
|
because they respectively round to 0.01 and 0.0, even though
|
|
0.006-0.002 = 0.004 which would be considered zero at 2 digits precision.
|
|
|
|
Warning: ``float_is_zero(value1-value2)`` is not equivalent to
|
|
``float_compare(value1,value2) == 0``, as the former will round after
|
|
computing the difference, while the latter will round before, giving
|
|
different results for e.g. 0.006 and 0.002 at 2 digits precision.
|
|
|
|
:param int precision_digits: number of fractional digits to round to.
|
|
:param float precision_rounding: decimal number representing the minimum
|
|
non-zero value at the desired precision (for example, 0.01 for a
|
|
2-digit precision).
|
|
:param float value1: first value to compare
|
|
:param float value2: second value to compare
|
|
:return: (resp.) -1, 0 or 1, if ``value1`` is (resp.) lower than,
|
|
equal to, or greater than ``value2``, at the given precision.
|
|
"""
|
|
rounding_factor = _float_check_precision(precision_digits=precision_digits,
|
|
precision_rounding=precision_rounding)
|
|
value1 = float_round(value1, precision_rounding=rounding_factor)
|
|
value2 = float_round(value2, precision_rounding=rounding_factor)
|
|
delta = value1 - value2
|
|
if float_is_zero(delta, precision_rounding=rounding_factor): return 0
|
|
return -1 if delta < 0.0 else 1
|
|
|
|
def float_repr(value, precision_digits):
|
|
"""Returns a string representation of a float with the
|
|
the given number of fractional digits. This should not be
|
|
used to perform a rounding operation (this is done via
|
|
:meth:`~.float_round`), but only to produce a suitable
|
|
string representation for a float.
|
|
|
|
:param int precision_digits: number of fractional digits to
|
|
include in the output
|
|
"""
|
|
# Can't use str() here because it seems to have an intrisic
|
|
# rounding to 12 significant digits, which causes a loss of
|
|
# precision. e.g. str(123456789.1234) == str(123456789.123)!!
|
|
return ("%%.%sf" % precision_digits) % value
|
|
|
|
_float_repr = float_repr
|
|
|
|
def float_split_str(value, precision_digits):
|
|
""" Splits the given float 'value' in its unitary and decimal parts. The value
|
|
is first rounded thanks to the ``precision_digits`` argument given.
|
|
|
|
Example: 1.432 would return (1, 43) for a digits precision of 2.
|
|
|
|
:param float value: value to split.
|
|
:param int precision_digits: number of fractional digits to round to.
|
|
:return: returns the tuple(<unitary part>, <decimal part>) of the given value
|
|
:rtype: tuple(str, str)
|
|
"""
|
|
value = float_round(value, precision_digits=precision_digits)
|
|
value_repr = float_repr(value, precision_digits)
|
|
units, cents = value_repr.split('.')
|
|
return units, cents
|
|
|
|
def float_split(value, precision_digits):
|
|
""" same as float_split_str() except that it returns the unitary and decimal
|
|
parts as integers instead of strings.
|
|
|
|
:rtype: tuple(int, int)
|
|
"""
|
|
units, cents = float_split_str(value, precision_digits)
|
|
return int(units), int(cents)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
|
|
import time
|
|
start = time.time()
|
|
count = 0
|
|
errors = 0
|
|
|
|
def try_round(amount, expected, precision_digits=3):
|
|
global count, errors; count += 1
|
|
result = float_repr(float_round(amount, precision_digits=precision_digits),
|
|
precision_digits=precision_digits)
|
|
if result != expected:
|
|
errors += 1
|
|
print('###!!! Rounding error: got %s , expected %s' % (result, expected))
|
|
|
|
# Extended float range test, inspired by Cloves Almeida's test on bug #882036.
|
|
fractions = [.0, .015, .01499, .675, .67499, .4555, .4555, .45555]
|
|
expecteds = ['.00', '.02', '.01', '.68', '.67', '.46', '.456', '.4556']
|
|
precisions = [2, 2, 2, 2, 2, 2, 3, 4]
|
|
for magnitude in range(7):
|
|
for frac, exp, prec in pycompat.izip(fractions, expecteds, precisions):
|
|
for sign in [-1,1]:
|
|
for x in range(0, 10000, 97):
|
|
n = x * 10**magnitude
|
|
f = sign * (n + frac)
|
|
f_exp = ('-' if f != 0 and sign == -1 else '') + str(n) + exp
|
|
try_round(f, f_exp, precision_digits=prec)
|
|
|
|
stop = time.time()
|
|
|
|
# Micro-bench results:
|
|
# 47130 round calls in 0.422306060791 secs, with Python 2.6.7 on Core i3 x64
|
|
# with decimal:
|
|
# 47130 round calls in 6.612248100021 secs, with Python 2.6.7 on Core i3 x64
|
|
print(count, " round calls, ", errors, "errors, done in ", (stop-start), 'secs')
|