CSC/ECE 517 Fall 2011/ch7 7a or

Wiki Chapter: CSC/ECE 517 Fall 2011/ch7 7a or

7a. Representing money. Skrien Chapter 6 gives an example of a class that can be used to represent money. But how is it done in real programs? Investigate, and report on the advantages and disadvantages of other approaches vs. Skrien's.

Introduction

Money is very important to people worldwide and is something that often must be represented in computer programs. This raises the question of how money should be represented, which can vary from program to program. There is much to be considered such as string formatting, the way money is used, and the variety of different currencies in the world. In Chapter 6 of Skrien's Object-Oriented Design Using Java, he suggests an implementation that represents money as a class, but there are other approaches that can be taken, each with their respective advantages and disadvantages.

Properties of Money

Money has certain properties and uses that must be considered in implementation.

Responsibilities/Using Money

The following are ways in which a representation of money should be able to be used: <ref name="lec20">http://courses.ncsu.edu/csc517/common/lectures/notes/lec20.pdf</ref>

• To represent a positive or negative amount of money.
• Possibly representing multiple components of a currency - i.e. dollars and cents.
• Possibly representing amounts of multiple currencies - i.e. a mix of US Dollars, euros, and yen.'
• To have a string formatting potentially including currency symbols like the dollar sign ($) and/or commas and/or decimal points.
• Addition, subtraction, multiplication, and division.

The degree to which of the above must be met will depend on the depth of the implementing project.

Different Currencies

Some applications may only handle only one currency such as the US Dollar, but more generally applied applications, such as banking, must be able to handle different kinds of currencies.

There are currently over 180 currencies in use around the world.<ref>http://en.wikipedia.org/wiki/List_of_circulating_currencies</ref>

Implementation must be aware of how to specifically represent each currency used. Some currencies use decimal points, such as how the US has 100 cents to a dollar, while others have no decimal, such as yen. Each currency also has a different sign symbol used such as $, €, or ¥. Different currencies also have different rules about how rounding values is handled.

Special consideration must be taken when using different currencies in conjunction with each other. Foreign exchange rates can be used to convert between different currencies, but the exchange rate often change, so attention must be paid to that. In some cases, it is also important to keep track of how much money the user has of more than one currency at a time, so that must be handled somehow. <ref>http://www.xencraft.com/resources/multi-currency.html</ref><ref name="lec20" />

Immutable vs. Mutable

Money values can be either mutable, meaning changeable, or immutable, meaning unchanging. Mutable money values are useful in that a new value does not need to be created for every change. However, mutable values cause problems for use in hash maps or with concurrency. The issue with concurrency is a read and write issue in a system with multiple users. With changing values, money not be what the user expects and lead to unpredictable behavior. Skrien feels this is a significant enough disadvantage to prefer an immutable representation for money.<ref name="lec20" />

Possible Representations

There are several possible ways to represent money in code.

Floating Point Number

Floating point numbers seem like an appealing option since they already include a fractional component, which lends itself straightforward to currencies like the US dollar which also have a fractional component. However, floating point numbers come with a drawback due to the way floats are formatted. Since floats are based on binary representation rather than a decimal representation, a value that would be exact in decimal notation can only be stored approximately in a floats point number. For instance, 9.48 is stored as 9.479999542236328125. Performing calculations with these approximated values can lead to inaccurate results. <ref name="dobbs">http://drdobbs.com/java/184405653</ref>

Another deficiency of floating point numbers is that they lose precision as the number gets larger. This is less of a problem when dealing with small amounts of currency, but when dealing with large amounts, on the order of the United States federal debt, the number of significant figures to the right of the decimal point decreases, again leading to possibly inaccurate results.<ref>Skrien, Dale. Object-Oriented Design Using Java. McGraw Hill, 2009, p. 174.</ref>

Two Integers

For currencies with a fractional component, using two integers to represent one amount of money is an option. One integer to represent the main component and one to represent the fractional part. For US currency, this would mean an integer for dollars and an integer for cents. This representation makes displaying monetary values simple, as each component is already split out and accurate. Also, by using integers, calculations with money work out as they should, avoiding the loss of accuracy floating points have. However, code will need to be implemented to handle when the fraction component carries over. In the case of dollars and cents, if the cents exceed 100, the cents value should be decreased by 100 and the dollars increased by 1. This handling of carries adds overhead to calculations. Some drawbacks of this implementation are the added overhead and storage required<ref name="lec20" />. Another significant drawback is that such a system cannot represent fractions of a fundamental unit of currencty. For example, in the United States, gasoline prices are typically represented with a precision of tenths of a cent per gallon. Another example is the stock market, where until early in the 21st century, stocks were traded in units of sixteenths of a dollar (6.25 cents.)<ref>http://www.infoplease.com/spot/stockdecimal1.html</ref>

One Integer, Implied Decimal Point

One integer can be used to represent money, even including the fractional component. The location of the decimal place is simply implied based on the currency. For instance, a single integer representation of $12.34 would be 1234. When dealing with US currency, this exploits the fact that the fundamental unit of currency in the US is actually the cent, not the dollar <ref name="dobbs"/>. A specialized print method would have to be constructed to display the monetary amount properly to the user, but all calculations work out properly. This approach has the same advantage that using two integers of maintaining accuracy, but does not have the added overhead or storage. In Object-Oriented Design Using Java, Skrien considers this to be the best use of the primitive types for representing money.<ref name="lec20" />. This method shares the same deficiency of two integers in that it cannot represent fractions of a fundamental unit of money.

BigDecimal

Java offers a BigDecimal class, which many people use for representing money. BigDecimal is capable of storing any size number since it stores each digit as an entry in an array, which grows as necessary. It also allows for specification of both the rounding method and the scale, the number of digits past the decimal place, for proper monetary calculations. <ref>http://www.javaranch.com/journal/2003/07/MoneyInJava.html</ref> On the downside, this specification for rounding and scale is required, which adds code to the implementation<ref name="dobbs" />. BigDecimal values are also immutable, which avoids read/write and write/write conflicts in applications. <ref>http://www.opentaps.org/docs/index.php/How_to_Use_Java_BigDecimal:_A_Tutorial</ref> While there are a lot of nice things about BigDecimal, there are some more issues with BigDecimal which can cause problems in representing money. BigDecimal cannot represent numbers with infinite digits such as 1/9 (.11111...) and throws an ArithmeticException on any calculation that would produce such number. To deal with this, hacks such as the following must be implemented:

BigDecimal bd1 = BigDecimal(1);
BigDecimal bd2 = BigDecimal(9);
try {
    return bd1.divide(bd2);
} catch(ArithmaticException ae) {
    return new BigDecimal(bd1.doubleValue() / bd2.doubleValue());
}

Also, since there isn't a BigDecimal equivalent for SQL databases, so storing BigDecimal values either requires conversion to a different format, which can affect accuracy and/or precision, or the value must be stored as a BLOB, which is cumbersome and inefficient. In general use, calculations with BigDecimal are significantly slower than with integers, and also take up more storage space. <ref>http://lemnik.wordpress.com/2011/03/25/bigdecimal-and-your-money/</ref>

Class

In Object-Oriented Design Using Java, recommends using a class to represent money, rather than just using a long integer alone. He gives two reasons for using a class. The first is encapsulation - by encapsulating money into a class, all the operations specific to working with money can be implemented to work as desired in all cases, which also avoids code duplication. The second reason is that the compiler is better able to detect coding errors, such as adding money to something that isn't money. <ref name="lec20" /> Implementing Money as a class is a generally good idea, but there are multiple ways to go about it.

Abstract Class

If multiple kinds of currencies are needed to be represented, one implementation is to create an abstract Money class and have each possible currency be a subclass of the abstract class. Since there are over 180 different currencies worldwide, it can be a challenge to implement subclasses for each one required.

The following is the abstract class proposed by Skrien in Object-Oriented Design Using Java:

public abstract class Money implements Comparable<Money> {
  public long getAmount()
  public String toString()
  public int compareTo(Money m)
  public boolean equals(Object o)
  public int hashCode()
  public Money plus(Money)
  public Money minus(Money)
  public Money times(double factor)
  public Money dividedBy(double divisor)
  public Money negate()
}

<ref name="lec20" />

Single Class

Rather than implementing a variety of subclasses for each currency, a single class can be used to represent money, with currency specified within. This is a good idea, since currencies basically operate the same calculation-wise, but have variations in decimal locations and the symbols used to present them. Java has a Currency class which holds the information for a given currency.

The following is the Single Class implementation given by Skrien in Object-Oriented Design Using Java:

public class Money implements Comparable<Money> {
  private long amount;
  private Currency currency;
  public Money(long amount, Currency currency) {
    this.amount = amount;
    this.currency = currency;
  }
  public long getAmount() { return amount; }
  public Currency getCurrency() { 
    return currency; }
  public String toString() { ...above... }
  public int compareTo(Money o) { ... }
  public boolean equals(Object o) { ... }
  public int hashCode() { ... }
  public Money plus(Money) { ... }
  public Money minus(Money) { ... }
  public Money times(double factor) { ... }
  public Money dividedBy(double divisor) { ... }
  public Money negate() { ... }
}

<ref name="lec20" />

Mixed Money

When dealing with multiple currencies it might be necessary to keep track of money consisting of multiple currencies. Simply converting into one common currency is not a good approach, since exchange rates vary over time, so the amount of each currency should be kept track of. Skrien suggests using a MixedMoney class, which acts as a sort of wallet holding amounts of different currencies.

The following is Skrien's implementation of MixedMoney:

public class MixedMoney implements Money {
  public MixedMoney() { ... }
  public String toString() { ... }
  public boolean equals(Object o) { ... }
  public int hashCode() { ... }
  public int compareTo(Money o) { ... }
  public Money plus(Money) { ... }
  public Money minus(Money) { ... }
  public Money times(double factor) { ... }
  public Money dividedBy(double divisor) { ... }
  public Money negate() { ... }
  public Collection getCurrencies() { ... }
  public long getAmount(Currency currency) { ... }
}

Since it uses a lot of the same methods as the regular Money class, Skrien renamed Money to SimpleMoney and created a common Money interface that is as follows:

public interface Money extends Comparable<Money> {
  public int compareTo(Money o);
  public Money plus(Money money);
  public Money minus(Money money);
  public Money times(double factor);
  public Money dividedBy(double divisor);
  public Money negate();
} 

The money within MixedMoney is suggested to be represented by either a hash map, a collection, or a tree structure. The hash map implementation is rejected for storage and calculation time issues. The tree structure is deemed the best approach as it is elegant and avoids checking classes. <ref name="lec20" />

Money Implementations in Practice

In practice, many decide similarly to Skrien to encapsulate Money as a class. The choice of underlying representation does vary, though, between types like int, double, or BigDecimal. I did not find any sources that used floats or two integers, which Skrien rejected. <ref name="dobbs" /><ref name="Representing Money">http://www.javapractices.com/topic/TopicAction.do?Id=13</ref> <ref name="C++">http://www.di-mare.com/adolfo/p/money.htm</ref> I found one source that addressed the issue of mixed money, which implemented a MoneyBag class that holds an array of Money. <ref name="testing">http://junit.sourceforge.net/doc/testinfected/testing.htm</ref>

There are also existing projects which seek to provide programmers with a library of classes to use for Money such as Time and Money and Joda-Money.

References

<references />