How to store currency values and format their output in julia-lang?
At the moment I am storing currency amounts in type ::Float64
, funds amount in billions to hundreds of millions in different currency units. In other use cases I also have the fact that currency values are needed to store in tens of thousands of units of currency, for example 0.7564
However, given the rounding errors associated with double precision numbers, should all be converted to fixed point integers to store currency units?
Second, how do you format the string output for the currency unit and allow the corresponding currency symbol to be displayed?
Second, are there any packages that provide a "currency" data type that will be safe to use?
source to share
Here's a really basic starting point for storing currency and displaying it:
immutable Currency
symbol::Symbol
amount::Int
end
function Base.show(io::IO, c::Currency)
print(io, c.symbol, c.amount/100)
end
Currency(:£, 1275) #=> £12.75
This keeps the currency as an exact value in kopecks, so there is no rounding error, but displays it in the usual way. Of course, you can easily determine the number of decimal places to store. I can't answer if fixed point numbers like this should be used, but they will certainly be more accurate for addition, subtraction and multiplication.
As far as the prior art, a quick google for "currency.jl" came up with this - it looks outdated, but might be useful as a reference.
source to share
You definitely shouldn't use floating point numbers for currencies - you should define your own fixed point numeric type and use that. Julia's guide has a good guide on defining a new number type in the chapter on conversions and promotions.
Suppose you only need two digits after the decimal point - no matter how many pounds, shillings or pence. Your new type will look something like
immutable Monetary <: Number
hundredths :: Int64
end
Monetary(ones :: Int64, hundredths :: Int64) = Monetary(hundredths + 100 * ones)
Obviously, you want to display monetary settings:
Base.show(io :: IO, x :: Monetary) =
@printf(io, "%lld.%02lld", fld(x.hundredths, 100), mod(x.hundredths, 100))
you will also want to add and subtract them:
+(x :: Monetary, y :: Monetary) = Monetary(x.hundredths + y.hundredths)
-(x :: Monetary, y :: Monetary) = Monetary(x.hundredths - y.hundredths)
On the other hand, you never want to multiply them, but multiplying a sum of money by an integer is fine:
*(x :: Bool, y :: Monetary) = ifelse(x, y, Monetary(0))
*(x :: Monetary, y :: Bool) = ifelse(y, x, Monetary(0))
*(x :: Integer, y :: Monetary) = Monetary(x * y.hundredths)
*(x :: Monetary, y :: Integer) = Monetary(x.hundredths * y)
Finally, if you mix integers with monetary values in an expression, it's fine to convert everything to monetary values:
Base.convert(::Type{Monetary}, x :: Int64) = Monetary(x, 0)
Base.promote_rule(::Type{Monetary}, ::Type{Int64}) = Monetary
This is convenient enough to perform useful calculations:
julia> Scrooge.Monetary(30,5) * 3 + 12
102.15
but to reliably catch the wrong operations:
julia> Scrooge.Monetary(30,5) * 3.5
ERROR: no promotion exists for Monetary and Float64
in * at ./promotion.jl:159
source to share
Currencies.jl provides an interface for working with currencies:
using Currencies
@usingcurrencies USD
format(1.23USD + 4.56USD, styles=[:us, :brief]) # $5.79
It supports type arithmetic, currency conversion, and flexible printing.
Disclaimer: I am the custodian of Currencies.jl.
source to share