The program: Big Number
Due Feb 21st, 2017, 11:59pm
Files
- Source code: bigcalc.7z Δ
- In addition to the test example shown in this page, here is another one
Change logs
- Feb 18, 9:30am, Another test case posted
- Feb 7, 11:10am, Source files released.
Description
You will write a Number class which will allow you to do arithmetic with unlimited digits and accuracy. As an example, this class was used to compute 1000! as:
40238726007709377354370243392300398571937486421071463254379991042993851239862902 05920442084869694048004799886101971960586316668729948085589013238296699445909974 24504087073759918823627727188732519779505950995276120874975462497043601418278094 64649629105639388743788648733711918104582578364784997701247663288983595573543251 31853239584630755574091142624174743493475534286465766116677973966688202912073791 43853719588249808126867838374559731746136085379534524221586593201928090878297308 43139284440328123155861103697680135730421616874760967587134831202547858932076716 91324484262361314125087802080002616831510273418279777047846358681701643650241536 91398281264810213092761244896359928705114964975419909342221566832572080821333186 11681155361583654698404670897560290095053761647584772842188967964624494516076535 34081989013854424879849599533191017233555566021394503997362807501378376153071277 61926849034352625200015888535147331611702103968175921510907788019393178114194545 25722386554146106289218796022383897147608850627686296714667469756291123408243920 81601537808898939645182632436716167621791689097799119037540312746222899880051954 44414282012187361745992642956581746628302955570299024324153181617210465832036786 90611726015878352075151628422554026517048330422614397428693306169089796848259012 54583271682264580665267699586526822728070757813918581788896522081643483448259932 66043367660176999612831860788386150279465955131156552036093988180612138558600301 43569452722420634463179746059468257310379008402443243846565724501440282188525247 09351906209290231364932734975655139587205596542287497740114133469627154228458623 77387538230483865688976461927383814900140767310446640259899490222221765904339901 88601856652648506179970235619389701786004081188972991831102117122984590164192106 88843871218556461249607987229085192968193723886426148396573822911231250241866493 53143970137428531926649875337218940694281434118520158014123344828015051399694290 15348307764456909907315243327828826986460278986432113908350621709500259738986355 42771967428222487575867657523442202075736305694988250879689281627538488633969099 59826280956121450994871701244516461260379029309120889086942028510640182154399457 15680594187274899809425474217358240106367740459574178516082923013535808184009699 63725242305608559037006242712434169090041536901059339838357779394109700277534720 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000
You will write a (rather feeble) calculator with only a few operations which will do basic arithmetic with these numbers. Running the calculator may give a display like:
enter a value: e add: a subtract: s multiply: m reverse sign: r clear: c quit: q -> e value: 3.14159265358979323846264338327950288419716939937511 3.14159265358979323846264338327950288419716939937511 enter a value: e add: a subtract: s multiply: m reverse sign: r clear: c quit: q -> m value: -20000 -62831.85307179586476925286766559005768394338798750220000 enter a value: e add: a subtract: s multiply: m reverse sign: r clear: c quit: q -> a value: .853071 -62831.0000007958647692528676655900576839433879875022 enter a value: e add: a subtract: s multiply: m reverse sign: r clear: c quit: q -> c 0 enter a value: e add: a subtract: s multiply: m reverse sign: r clear: c quit: q -> e value: .0000000000000000000000001 .0000000000000000000000001 enter a value: e add: a subtract: s multiply: m reverse sign: r clear: c quit: q -> r -.0000000000000000000000001 enter a value: e add: a subtract: s multiply: m reverse sign: r clear: c quit: q -> m value: 200000 -.0000000000000000000200000 enter a value: e add: a subtract: s multiply: m reverse sign: r clear: c quit: q -> s value: -1 .99999999999999999998 enter a value: e add: a subtract: s multiply: m reverse sign: r clear: c quit: q -> q
You will note that your program will not do division. You can be thankful for this.
The Number class
Numbers will be stored in doubly-linked lists (do not use generics here). Each node will have an int value field which will hold one digit (0 through 9) and two pointer fields, prev and next. The Number class will have five fields:
private Node low, high; private int digitCount = 0; private int decimalPlaces = 0; private boolean negative = false;
high points to the high-order digit's node, low points to the low-order digit's node, digitCount is the number of digits stored in the list, decimalPlaces is the number of digits (nodes) after the decimal place and negative gives the sign. For example, the number 3.1416 would be represented as:
A number of operations will be provided by public methods:
public Number(). A constructor which makes an "empty" Number (with no digits). public Number(String str). A constructor which takes a String representation of a number (e.g. "-21.507"). Calls accept. public void accept(String str). Builds a list representation of the number represented by the string. public Number add(Number n). Returns a Number which represents "this + n". public Number subtract(Number n). Returns a Number which represents "this - n". public Number multiply(Number n). Returns a Number which represents "this * n". public void reverseSign(). Reverses the value of negative. public String toString(). This returns a String representation of the number. It allows you to display a Number using System.out.print().
There will be no other public methods, but you may provide any private methods you wish.
The list
You will write methods to manipulate the doubly linked list. Very little is needed here. You will need private void insertLow(int digit) and private void insertHigh(int digit) to create and insert new nodes at each end of the list.
Implementing the operations
You will write (private) Number addAbsolute(Number n), Number subtractAbsolute(Number n) and int compareToAbsolute(Number n) methods which will perform operations disregarding signs (i.e. the negative field). These can then be called by the public Number add(Number n) and public Number subtract(Number n) methods. The trickiest part of these methods is aligning the decimal points.
private Number addAbsolute(Number n)
If this.digitCount and n.digitCount were equal and this.decimalPlaces and n.decimalPlaces were equal (which, of course, they generally are not) the following pseudo-code would work:
create a new (empty) Number sum int carry = 0 thisPtr = low nPtr = n.low while (thisPtr != null) add the values stored in the pointed to nodes plus the carry to get int newDigit store newDigit % 10 in a new node inserted at the head of sum sum.digitCount++ store newDigit / 10 in carry thisPtr = thisPtr.getPrev() nPtr = nPtr.getPrev() if (carry != 0) store carry (1) in new node at the head of sum sum.digitCount++ set appropriate value for decimalPlaces in sum
This must be adjusted to align the decimal points and to account for differing digit counts. If, for example, the numbers as written on paper would look like:
xxxxxx.xxx xxx.xxxxxx
you would have to start and end the traversals of the two lists at different times and treat non-existent nodes as holding 0.
private Number subtractAbsolute(Number n)
Subtraction is also done much as it is done with paper and pencil. You must first determine which of the two values has largest magnitude (use your int compareToAbsolute(Number n) method) then subtract the smaller magnitude value from the larger magnitude value. If this has the largest magnitude and if the digitCounts and decimalPlaces match the following pseudo-code would work:
create a new (empty) Number difference int borrow = 0; thisPtr = low nPtr = n.low while (thisPtr != null) subtract the pointed to digits and subtract borrow from the result to get int newDigit if (newDigit < 0) newDigit += 10 borrow = 1 else borrow = 0 store newDigit in a new node inserted at the head of difference difference.digitCount++ set appropriate value for decimalPlaces in difference
This code must be adjusted to align decimal points and account for different digit counts.
public Number multiply(Number n) optional
Multiplication is done in a slightly different way from pencil and paper. We read the first Number to be multiplied from-right-to-left and the second from-left-to-right using "Horner's method."
create an empty Number product
let d be the high-order digit of n
do
multiply (all of) this by d in a right-to-left manner (with a carry)
similar to addAbsolute() to get a Number partialProduct
multiply product by 10 (just append a new low-order digit 0)
use addAbsolute() to add partialProduct to product
let d be the next digit to the right in n
until you have used all digits of n
decimalPlaces for product will be the sum of decimalPlaces for this and n
set product.negative to get the appropriate sign
No issues with decimal point alignment or differing digit counts occur here.
Finishing the arithmetic operations
public Number add(Number n) and public Number Subtract(Number n) are now easily implemented using private Number addAbsolute(Number n), private Number subtractAbsolute(Number n), and private int compareToAbsolute(Number n) and carefully observing signs. (private int compareToAbsolute(Number n) presents digit and decimal point alignment issues.)
All arithmetic operations must be finished by trimming the result. Here you will remove all extra leading 0s which precede the decimal point and all extra trailing 0s which follow the decimal point.
Input validation
All user input must be validated. In the Number class you should write a validate() method which assures that the strings passed to accept() or the constructor represent valid numbers. If input fails this validation your program will throw an exception. (You make up the exception.) Your calculator should put all user input which is destined for the Number class in try/catch blocks. The action of the catch block need only be a message (and perhaps a beep: System.out.print((char)7)) and allow the program to continue.
To hand in
You will submit on blackboard.
- Your submission should include your (well organized and well commented) source cod
- Complete README.txt
- You should include both source code and a binary called "310pa1.jar".
- A terminal session showing you running your program with sample input that will be posted on this website
- Your should zip all the files in a file called "PA1.Firstname.Lastname.zip"
- Your TAs should be able to run your program by typing: "java -jar 310pa1.jar"
Rubrics
- private boolean validate(String str) 5%
- public void accept(String str) 5%
- public Number add(Number n) 10%
- public Number subtract(Number n) 10%
- public Number multiply(Number n) 15% (optional)
- public Number compareToAbsolute(Number n) 5%
- private Number addAbsolute(Number n) 20%
- private Number subtractAbsolute(Number n) 20%
- private void insertHigh(int digit) 5%
- private void insertLow(int digit) 5%
- private void trim() 5%
- README.txt 5%
- Code organization/comments 5%
- Total point: 100 + 15 optional