Question

In my program, decimal accuracy is very important.
A lot of my calculations must be accurate to many decimal places (such as 50).

Because I am using python, I have been using the decimal module (with context().prec = 99. ie; Set to have 99 decimal places of accuracy when instantiating a decimal object)
as pythonic floats don t allow anywhere near such accuracy.

Since I wish for the User to specify the decimal places of accuracy of the calculations, I ve had to implement several round() functions in my code.
Unfortuneately, the inbuilt round function and the decimal object do not interact well.

round(decimal.Decimal( 2.000000000000000000001 ),50)

# Number is 1e-21.   There are 21 decimal places, much less than 50.

Yet the result is 2.0 instead of 2.000000000000000000001
The round function is not rounding to 50. Much less!

Yes, I have made sure that the over-rounding does not occur on instantiation of the Decimal object, but after calling round.
I always pass strings representing floats to the Decimal constructor, never pythonic floats.

Why is the round function doing this to me?
(I realise that it was probably originally designed for pythonic floats which can never have so many decimal places, but the documentation claims that the Decimal object integrates perfectly into python code and is compatible with the inbuilt python functions!)

Thanks profusely!
(This has me quite unnerved, since this problem undermines the use of the entire program)

Specs:
python 2.7.1
Windows 7
decimal module (inbuilt)

Answer 1

正如我可以确定的那样,问题在于:round(>>正在回归一个float的类型,而不是一个Decimal的类型。因此,你在<代码>decimal模块上设定了何种精确性,因为一旦你打电话round(),你不再有<>Decimal。

为了围绕这一点开展工作,你或许必须找到一种替代方法,以取代不依赖<条码>的编号。如雷蒙德的建议。

http://ideone.com/xgPL9>。

Answer 2

自round(/em> <http://docs.python.org/library/decimal.html#decimal.Decimal.quantize” rel=“noreferer”>quantize(>>>>>>>>。方法:

>>> from decimal import Decimal >>> d = Decimal( 2.000000000000000000001 ) >>> d.quantize(Decimal(10) ** -20) # Round to twenty decimal places Decimal( 2.00000000000000000000 )

To chop-off the trailing zeros, apply normalize() to the rounded result:

>>> d = Decimal( 2.000000000000000000001 ) >>> d.quantize(Decimal(10) ** -20).normalize() Decimal( 2 )

Answer 3

引言如下......

from decimal import Decimal, ROUND_HALF_UP, getcontext

getcontext().prec = 51

def round_as_decimal(num, decimal_places=2):
    """Round a number to a given precision and return as a Decimal

    Arguments:
    :param num: number
    :type num: int, float, decimal, or str
    :returns: Rounded Decimal
    :rtype: decimal.Decimal
    """
    precision =  1.{places} .format(places= 0  * decimal_places)
    return Decimal(str(num)).quantize(Decimal(precision), rounding=ROUND_HALF_UP)

round_as_decimal( 2.000000000000000000001 , decimal_places=50)

希望帮助!

Answer 4

<round(> for any purpose has problems:

(1) 在Aval 2.7, 圆(Decimal(39.142))产生39.14,即浮动;3.2 产生 Dec。

>>> import decimal; round(decimal.Decimal( 2.000000000000000000001 ),50)
2.0   <<<=== ***float***

(2) round() has only one rounding mode; Decimal.quantize has many.

(3) For all input types, the single rounding mode changed: Python 2.7 rounds away from 0 (expected in most business applications) whereas Python 3.2 rounds to the nearest even multiple of 10**-n (less expected in business).

Use Decimal.quantize()

Answer 5

As stated above, round() returns a float if provided with a Decimal. For exact calculations, I suggest to do them with not rounded down Decimals, and for rounding the final result, use a function:

    def dround(decimal_number, decimal_places):
        return decimal_number.quantize(Decimal(10) ** -decimal_places)

友情链接