CIT 591 Assignment 7: Balanced Ternary
Fall 2008, David Matuszek

Purposes of this assignment

Give you more practice with TDD and JUnit.

General idea of the assignment

Modern computers use the binary number system. However, an early Russian computer, the Setun, used a different number system, balanced ternary.

Your assignment is to write a BalancedTernary API for Java. There are a lot of required methods, but only a couple of them require much work.

About balanced ternary

The decimal number system uses ten digits, 0 through 9, and a system in which each position in a number is worth ten times the value of the position to its immediate right. Thus, for example, the number 7204 indicates "seven thousands, two hundreds, no tens, and four":

10³ = 1000	10² = 100	10¹ = 10	10⁰ = 1
`7` (times 10³ is 7000)	`2` (times 10² is 200)	`0` (times 10¹ is 0)	`4` (times 10⁰ is 4)
`7`10³ + `2`10² + `0`10¹ + `4`10⁰ = `7204`

Similarly, the ternary system uses three digits, usually 0, 1, and 2, and a system in which each position in a number is worth three times the value of the position to its immediate right.

This assignment, however, is to implement a balanced ternary system, in which the three digits have the values 0, 1, and -1. To avoid the awkwardness of using two characters, '-' and 1, to represent a single digit, we will instead use N to stand for the digit -1. Similar to the above example, then, the number 10N1 indicates "one 27, no 9s, negative one 3s, and 1:

3³ = 27	3² = 9	3¹ = 3	3⁰ = 1
`1` (times 3³ is 27)	`0` (times 3² is 0)	`N` (times 3¹ is 0)	`1` (times 3⁰ is 4)
`1`3³ + `0`3² + `(-1)`3¹ + `1`3⁰ = `10N1` (or, in decimal, 27 + 0 - 3 + 1 = 25)

In balanced ternary, as in more familiar number systems, there is exactly one way to represent any (integer) number. Unlike familiar number systems, there is no need for an additional symbol to indicate that a number is negative; for example, -5 is represented as N11

Here are some more examples:

Balanced ternary	`N11`	`NN`	`N0`	`N1`	`N`	`0`	`1`	`1N`	`10`	`11`	`1NN`
Decimal equivalent	`-5`	`-4`	`-3`	`-2`	`-1`	`0`	`1`	`2`	`3`	`4`	`5`

It will take some time to get used to balanced ternary. Fortunately, you do not have to be comfortable with the number system before you start writing the program.

Details

Create a project named BalancedTernary.

Within the project, create a package named balancedTernary.

Within the package, create the class BalancedTernary extends Number implements Comparable.

Constructors

Implement the following constructors for balanced ternary numbers.

public BalancedTernary(String s) throws NumberFormatException: Constructs a BalancedTernary number from the String s, which may contain the characters N, 0, 1, and commas. Throws a NumberFormatException if the input string does not have this form.
public BalancedTernary(int n): Constructs a BalancedTernary number equivalent to the decimal integer n.

Note 1: You can keep the balanced ternary number as a String, or as an int, or both.

Note 2: You should be able to represent any int value, from Integer.MIN_VALUE to Integer.MAX_VALUE, as a balanced ternary number. Since the conversion between int and balanced ternary may involve using numbers outside this range, you should use long numbers to do the conversions.

Methods

Implement the following methods for doing arithmetic with balanced ternary numbers.

public String value(): Returns the value of this balanced ternary number as a String consisting of digits (N, 0, and 1) only.
public String toString(): Returns the value of this balanced ternary number as a String consisting of digits (N, 0, and 1), with commas to separate groups of three digits, as in decimal. For example, 1N,N00,1N1. The String contains no spaces or other characters.
public BalancedTernary add(BalancedTernary number): Returns the sum this + number.
public BalancedTernary subtract(BalancedTernary number): Returns the difference this - number.
public BalancedTernary multiply(BalancedTernary number): Returns the product this * number.
public BalancedTernary divide(BalancedTernary number): Returns the quotient this / number. Integer division rules apply; that is, any remainder is discarded.
public BalancedTernary remainder(BalancedTernary number): Returns the remainder this % number.
public boolean equals(BalancedTernary number): Returns true if this and number are equal, false otherwise .
public BalancedTernary abs(): Returns the absolute value of this.
public int signum(): Returns -1 if this is negative, 0 if this is zero, or 1 if this is positive.

Because this class extends Number, it should also override the methods intValue(), byteValue(), shortValue(), longValue(), floatValue(), and doubleValue(). For example,

@Override public int intValue(): Returns the value of this balanced ternary number as a int.

If you have the basic int <--> BalancedTernary conversions working, the rest of these are one-line methods.

Because this class implements Comparable, it must also provide the following method.

public int compareTo(BalancedTernary number): Returns a negative number if number is less than this, zero if they are equal, and a positive number if number is greater than this.

JUnit tests

Test all the above methods, and the constructors. (For the constructor that takes an int, test whether you can get the correct value back as a String. For the constructor that takes a String, test whether you can get the correct value back as an int.)

Again, I strongly recommend (1) writing the tests first, and (2) whoever writes the test for a method should also write that method.

Due date:

Before midnight, Thursday October 30. Submit to Blackboard one copy of your project directory, properly zipped. Both your names should be in Javadoc comments in the classes. In addition, whichever of you turns the program in, should put your partner's name in the comments field in Blackboard.