Alternative to Decimal type

[Frank Millman]

Hi all

I have a standard requirement for a 'decimal' type, to instantiate and
manipulate numeric data that is stored in a database. I came up with a
solution long before the introduction of the Decimal type, which has
been working well for me. I know the 'scale' (number of decimal
places) of the number in advance. When I read the number in from the
database I scale it up to an integer. When I write it back I scale it
down again. All arithmetic is done using integers, so I do not lose
accuracy.

There is one inconvenience with this approach. For example, if I have
a product quantity with a scale of 4, and a price with a scale of 2,
and I want to multiply them to get a value with a scale of 2, I have
to remember to scale the result down by 4. This is a minor chore, and
errors are quickly picked up by testing, but it does make the code a
bit messy, so it would be nice to find a solution.

I am now doing some refactoring, and decided to take a look at the
Decimal type. My initial impressions are that it is quite awkward to
use, that I do not need its advanced features, and that it does not
help solve the one problem I have mentioned above.

I therefore spent a bit of time experimenting with a Number type that
suits my particular requirements. I have come up with something that
seems to work, which I show below.

I have two questions.

1. Are there any obvious problems in what I have done?

2. Am I reinventing the wheel unnecessarily? i.e. can I do the
equivalent quite easily using the Decimal type?

--------------------
from __future__ import division

class Number(object):
def __init__(self,v alue,scale):
self.factor = 10.0**scale
if isinstance(valu e,Number):
value = value.value / value.factor
self.value = long(round(valu e * self.factor))
self.scale = scale

def __add__(self,ot her):
if isinstance(othe r,Number):
other = other.value / other.factor
return Number((self.va lue/self.factor)+ot her,self.scale)

def __sub__(self,ot her):
if isinstance(othe r,Number):
other = other.value / other.factor
return Number((self.va lue/self.factor)-other,self.scal e)

def __mul__(self,ot her):
if isinstance(othe r,Number):
other = other.value / other.factor
return Number((self.va lue/self.factor)*ot her,self.scale)

def __truediv__(sel f,other):
if isinstance(othe r,Number):
other = other.value / other.factor
return Number((self.va lue/self.factor)/other,self.scal e)

def __radd__(self,o ther):
return self.__add__(ot her)

def __rsub__(self,o ther):
return Number(other-(self.value/self.factor),se lf.scale)

def __rmul__(self,o ther):
return self.__mul__(ot her)

def __rtruediv__(se lf,other):
return Number(other/(self.value/self.factor),se lf.scale)

def __cmp__(self,ot her):
if isinstance(othe r,Number):
other = other.value / other.factor
this = self.value / self.factor
if this < other:
return -1
elif this other:
return 1
else:
return 0

def __str__(self):
s = str(self.value)
if s[0] == '-':
minus = '-'
s = s[1:].zfill(self.sca le+1)
else:
minus = ''
s = s.zfill(self.sc ale+1)
return '%s%s.%s' % (minus, s[:-self.scale], s[-self.scale:])
--------------------

Example usage -

>>>qty = Number(12.5,4)
price = Number(123.45,2 )

>>>print price * qty

1543.13 [scale is taken from left-hand operand]

>>>print qty * price

1543.1250 [scale is taken from left-hand operand]

>>>print Number(qty * price,2)

1543.13 [scale is taken from Number instance]
--------------------

At this stage I have not built in any rounding options, but this can
be done later if I find that I need it.

Any comments will be welcome.

Thanks

Frank Millman

[Aahz]

In article <f7************ *************** *******@25g2000 hsx.googlegroup s.com>,
Frank Millman <fr***@chagford .comwrote:

>
My approach is based on expressing a decimal number as a combination
of an integer and a scale, where scale means the number of digits to
the right of the decimal point.

You should probably use one written by an expert:

http://www.pythoncraft.com/FixedPoint.py
--
Aahz (aa**@pythoncra ft.com) <* http://www.pythoncraft.com/

"as long as we like the same operating system, things are cool." --piranha

[Frank Millman]

On Jun 11, 11:48*am, Frank Millman <fr...@chagford .comwrote:

Thanks to all for the various replies. They have all helped me to
refine my ideas on the subject. These are my latest thoughts.

[snip]

>
My main concern is that my approach may be naive, and that I will run
into situations that I have not catered for, resulting in errors. If
this is the case, I will drop this like a hot potato and stick to the
Decimal type. Can anyone point out any pitfalls I might be unaware of?

I will be happy to show the code for the new Number class if anyone is
interested.

Thanks again for all the really useful replies.

I will have a look at gmpy, and I will study FixedPoint.py closely.

Frank

[Grant Edwards]

On 2008-06-12, Dennis Lee Bieber <wl*****@ix.net com.comwrote:

If you were to follow the footsteps of COBOL, you'd be using
BCD internally, with a special code to represent the decimal
point (and maybe, to save space, the sign too)

Old mainframes had instructions to work with packed BCD as a
register format (the Xerox Sigma series used four 32-bit
registers to represent a 31 digit packed BCD number). Okay, I
think even the Pentium's still have a BCD operation set,

IIRC, most general purpose microprocessors I've used had
special instructions to make packed BCD operations easier, and
back in the day (when Pascal was much more popular than C)
compilers for microprocessors usually offered a BCD floating
point data type.

--
Grant Edwards grante Yow! The SAME WAVE keeps
at coming in and COLLAPSING
visi.com like a rayon MUU-MUU ...