• What is a Compound Number?
  • A compound number is a quantity/measure that is expressed in more than one unit
• Examples:
  • Heights/lengths measured in miles, yards, feet and inches
  • Weights measured in tons, pounds and ounces
  • Times measured in hours, minutes and seconds
  • Volumes measured in gallons, quarts, pints, ounces

• Individual Components:
  • Are commonly integers (because parts of a whole are usually denominated in different units)
• Arithmetic Operations:
  • Often involve arithmetic on a circle with "carry"

• The Approach:
  • Have an attribute for each of the individual units (e.g., an int for pounds and an int for ounces)
• Why it Seems Clever:
  • Because we know about the integer division and remainder operators and how to use them for arithmetic on a circle and divisibility checks
• A Continuing Example:
  • We have 3lbs,12oz of french fries and someone gives us more or takes some away

• An Example of the Easiest Case:
  • We have 3lbs,12oz of french fries and someone gives us 2oz more
• Processing this Specific Example:
  • ounces = ounces + 2;
• Processing this Kind of Example:
  • ounces = ounces + deltaounces;

• An More Difficult Example:
  • We have 3lbs,12oz of french fries and someone gives us 8oz more
• Processing:
  • pounds = pounds + (ounces + deltaounces) / 16;
ounces = (ounces + deltaounces) % 16;
    
• A Word of Caution:
  • The following code, while similar, is incorrect!
    ounces = (ounces + deltaounces) % 16;
pounds = pounds + (ounces + deltaounces) / 16;
    

• Increasing the Difficulty Further:
  • We have 3lbs,12oz of french fries and someone gives us 5lbs,8oz more
• Processing:
  • pounds = (pounds + deltapounds) + (ounces + deltaounces) / 16;
ounces = (ounces + deltaounces) % 16;
    

• Increasing the Difficulty Further:
  • We have 1ton,1999lbs,12oz of french fries and someone gives us 8oz more
• Processing:
  • tons = (tons + deltatons) + (pounds + deltapounds + (ounces + deltaounces) / 16) / 2000;
pounds = (pounds + deltapounds) + (ounces + deltaounces) / 16;
ounces = (ounces + deltaounces) % 16;
    

• Increasing the Difficulty Further:
  • We have 1ton,1999lbs,12oz of french fries and someone gives us 1ton,200lbs,8oz more
• Increasing the Difficulty Further:
  • We have 2tons,1999lbs,12oz of french fries and someone changes the amount by -1ton,353lbs,-15oz
• Other Complications:
  • Multiplication/division by a constant
  • Ratios
  • Sign (should all components have the same sign?)
  • Comparisons (e.g., equals(), compareTo())

• A Conclusion:
  • It is possible to use the obvious implementation but there are many ways/places that defects can be introduced
• A Hope:
  • This situation has arisen frequently in the past and people have developed a solution

• The Idea:
  • Use a single attribute denominated in the "smallest" units and convert when necessary
• The Continuing Example Revisited:
  • Create a Weight class that has only one attribute measured in ounces, but accessors that can return tons, pounds and ounces and mutators that can be passed tons, pounds, and ounces

javaexamples/compoundnumbers/Weight.java

import java.util.*;


/**
 * A weight class that uses the compound number programming pattern.
 *
 * Note: This class also uses: information hiding, static attributes,
 * overloaded methods, and overloaded constructors.
 *
 * @author  Prof. David Bernstein, James Madison University
 */
public class Weight
{
    private static final int OUNCES_PER_POUND =   16;
    private static final int POUNDS_PER_TON   = 2000;
    private static final int OUNCES_PER_TON   = OUNCES_PER_POUND*POUNDS_PER_TON;
    

    private int      value;

    /**
     * Construct a Weight of 0.
     */
    public Weight()
    {
        value = 0;
    }

    /**
     * Construct a Weight.
     * Note: The signs of the parameters do not have to agree.
     *
     * @param tons       The number of tons
     * @param pounds     The number of pounds
     * @param ounces     The number of ounces
     */
    public Weight(int tons, int pounds, int ounces)
    {
        value = 0;
        changeBy(tons, pounds, ounces);
    }

    /**
     * Change this Weight by a given amount.
     * Note: The signs of the parameters do not have to agree.
     *
     * @param tons       The number of tons
     * @param pounds     The number of pounds
     * @param ounces     The number of ounces
     */
    public void changeBy(int tons, int pounds, int ounces)
    {
        value += tons * OUNCES_PER_TON + pounds * OUNCES_PER_POUND + ounces;
    }

    /**
     * Change this Weight by a given amount.
     *
     * @param other      The Weight to change by
     */
    public void changeBy(Weight other)
    {
        value += other.value;
    }

    /**
     * Check to see if this Weight is equal to 
     * a given Weight.
     *
     * @param other   The other Weight to use in the comparison
     * @return        true if the two are equal and false otherwise
     */
    public boolean equals(Weight other)
    {
        return this.value == other.value;
    }

    /**
     * Multiply this Weight by a scalar.
     * Note: This method truncates the ounces if necessary.
     *
     * @param m   The scalar multiple
     */
    public void multiplyBy(double m)
    {
        value = (int)(value * m);
    }
    
    /**
     * Get a String representation of this Weight.
     *
     * @return  The String
     */ 
    public String toString()
    {
        int        ounces, pounds, tons, unsigned;
        String     s;
        
        unsigned = Math.abs(value);        
        tons   = (unsigned / OUNCES_PER_TON);
        pounds = (unsigned % OUNCES_PER_TON) / OUNCES_PER_POUND;
        ounces = (unsigned % OUNCES_PER_TON) % OUNCES_PER_POUND;

        s = new String();
        if (value < 0) s += "Negative";

        if      (tons > 1) s += " " + tons + "tons";
        else if (tons > 0) s += " " + tons + "ton";
        
        if      (pounds > 1) s += " " + pounds + "pounds";
        else if (pounds > 0) s += " " + pounds + "pound";

        if      (ounces > 1) s += " " + ounces + "ounces";
        else                 s += " " + ounces + "ounce";
        
        return s;
    }
}
        

• A Common Misconception:
  • The shortcomings of the obvious implementation arise only if the objects are mutable
• The Reality:
  • The shortcomings exist whenever operations are performed on compound numbers (regardless of whether the object is mutable or a new immutable object is created)