Raphael Collet
1ba91042d6
Add a class for float objects that carry their precision digits, use it for the value of monetary fields in record cache, and serialize them as expected for the database.
207 lines
9.9 KiB
Python
207 lines
9.9 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
|
|
import math
|
|
|
|
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 += cmp(normalized_value,0) * epsilon
|
|
rounded_value = 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 = cmp(normalized_value, 0)
|
|
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
|
|
|
|
class float_precision(float):
|
|
""" A class for float values that carry precision digits. This is a thin
|
|
layer on top of ``float``, and the precision digits are not propagated
|
|
to the result of arithmetic operations. This class is used when
|
|
converting monetary values to cache, and for serializing them to the
|
|
database.
|
|
"""
|
|
__slots__ = ['precision_digits']
|
|
|
|
def __new__(cls, value, precision_digits):
|
|
obj = super(float_precision, cls).__new__(cls, value)
|
|
obj.precision_digits = precision_digits
|
|
return obj
|
|
|
|
def float_repr(self):
|
|
return _float_repr(self, self.precision_digits)
|
|
|
|
|
|
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 i in xrange(len(fractions)):
|
|
frac, exp, prec = fractions[i], expecteds[i], precisions[i]
|
|
for sign in [-1,1]:
|
|
for x in xrange(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'
|