Truncation in python

How can we truncate (not round) the cube root of a given number after the 10th decimal place in python?

For Example:

If number is 8 the required output is 2.000开发者_StackOverflow0000000 and for 33076161 it is 321.0000000000

---

Scale - truncate - unscale:

n = 10.0
cube_root = 1e-10 * int(1e10 * n**(1.0/3.0))

---

You should only do such truncations (unless you have a serious reason otherwise) while printing out results. There is no exact binary representation in floating point format, for a whole host of everyday decimal values:

print 33076161**(1.0/3.0)

A calculator gives you a different answer than Python gives you. Even Windows calculator does a passable job on cuberoot(33076161), whereas the answer given by python will be minutely incorrect unless you use rounding.

So, the question you ask is fundamentally unanswerable since it assumes capabilities that do not exist in floating point math.

Wrong Answer #1: This actually rounds instead of truncating, but for the cases you specified, it provides the correct output, probably due to rounding compensating for the inherent floating point precision problem you will hit in case #2:

print "%3.10f" % 10**(1.0/3.0)

Wrong Answer #2: But you could truncate (as a string) an 11-digit rounded value, which, as has been pointed out to me, would fail for values very near rollover, and in other strange ways, so DON'T do this:

print ("%3.11f" % 10**(1.0/3.0))[:-1]

Reasonably Close Answer #3: I wrote a little function that is for display only:

import math
def str_truncate(f,d):
    s = f*(10.0**(d))
    str = `math.trunc(s)`.rstrip('L')
    n = len(str)-d
    w = str[0:n]
    if w=='':
        w='0'
    ad =str[n:d+n]
    return w+'.'+ad



d =  8**(1.0/3.0)
t=str_truncate(d,10)
print 'case 1',t

d =  33076161**(1.0/3.0)
t=str_truncate(d,10)
print 'case 2',t

d =  10000**(1.0/3.0)
t=str_truncate(d,10)
print 'case 3',t

d = 0.1**(1.0/3.0)
t=str_truncate(d,10)
print 'case 4',t

Note that Python fails to perform exactly as per your expectations in case #2 due to your friendly neighborhood floating point precision being non-infinite.

You should maybe know about this document too:

What Every Computer Scientist Should Know About Floating Point

And you might be interested to know that Python has add-ons that provide arbitary precision features that will allow you to calculate the cube root of something to any number of decimals you might want. Using packages like mpmath, you can free yourself from the accuracy limitations of conventional floating point math, but at a considerable cost in performance (speed).

It is interesting to me that the built-in decimal unit does not solve this problem, since 1/3 is a rational (repeating) but non-terminating number in decimal, thus it can't be accurately represented either in decimal notation, nor floating point:

 import decimal
 third = decimal.Decimal(1)/decimal.Decimal(3)
 print  decimal.Decimal(33076161)**third  # cuberoot using decimal

output: 320.9999999999999999999999998

Update: Sven provided this cool use of Logs which works for this particular case, it outputs the desired 321 value, instead of 320.99999...: Nifty. I love Log(). However this works for 321 cubed, but fails in the case of 320 cubed:

 exp(log(33076161)/3)

It seems that fractions doesn't solve this problem, but I wish it did:

import fractions

third = fractions.Fraction(1,3)

def cuberoot(n):
    return n ** third

print '%.14f'%cuberoot(33076161)

---

num = 17**(1.0/3.0)
num = int(num * 100000000000)/100000000000.0
print "%.10f" % num

---

What about this code .. I have created it for my personal use. although it is so simple, it is working well.

def truncation_machine(original,edge):
'''
Function of the function :) :
    it performs truncation operation on long decimal numbers.
Input:
    a) the number that needs to undergo truncation.
    b) the no. of decimals that we want to KEEP.
Output:
    A clean truncated number.
Example: original=1.123456789
         edge=4
         output=1.1234
'''
import math
g=original*(10**edge)
h=math.trunc(g)
T=h/(10**edge)
print('The original number ('+str(original)+') underwent a '+str(edge)+'-digit truncation to be in the form: '+str(T))
return T