Java Language: Using Objects
Assignment I: Simple Calculator
In this assignment we shall look at a possible representation of a calculator in Java using
objects. We shall explore a way of representing a simple calculator using Java objects. We
shall restrict ourselves to operations that require two operands. Thus, for each calculator
object, we shall represent/store the first and second operands as floating point numbers.
We shall also require to represent/store the result as a floating point number.
We shall declare a new type, simpleCalc, to represent our calculator. We can now define
operations on data of this kind. In particular we need to implement some arithmetic
operations. We shall limit ourselves to the operations of addition, multiplication, and
exponentiation. (Note that subtraction is really addition in disguise and is no more
complicated. The same can be said for division vis a vis multiplication).
Your first task will be to implement the following constructors and methods:
simpleCalc(double op1, double op2);
double add(double op1, double op2);
double mult(double op1, double op2);
double exp(double op1, double op2);
void show(int dp);
The methods should do the following: The constructors, simpleCalc, should initialize
the calculator with the operands (if provided – otherwise, it initializes to 0 and 1
respectively); add should perform the addition operation on the operands (provided), store
and return the result; mult should perform the multiplication operation on the operands
(provided), store and return the result; exp should perform the operation of exponentiation
on the operands (op1op2), store and also return the result; show should print out the current
result in the calculator correct to the given number of decimal places (default: 2dp).
The next part of the assignment requires you to compute a close approximation to the
mathematical constant π, which is often approximated to 3.14…
In early history, π was approximated to 25/8 (about 0.5% below the exact value), later on
339/108 (correct to 2dp when rounded, or 0.09% below the exact value) later on between
223/71 and 22/7 (0.02% and 0.04% off respectively), later on 377/120 (correct to the
equivalent of 3dp), and later on between 3.141024 and 3.142708 the average of which gives
an error of less than 0.01%. Contemporary mathematicians noted the possibility of
concluding that π was an irrational number.
In the middle ages, Indian mathematician and astronomer Madhava of Sangamagrama,
discovered the infinite series for π, known as the Madhava-Leibniz series. We shall use
this series to approximate π:
3 ∙ 3
5 ∙ 3
7 ∙ 3 ⋯
Compute this series as far as it will go without giving you overflow problems. In short,
implement a method:
This method should compute and return π using the arithmetic methods you wrote above.
I have written for you a demo class, simpleCalcDemo, which you can use to test your
calculator. The main() method should work without any modifications. Try not to create
more bugs than you already have to deal with. As you may notice this code will not compile
until the simpleCalc class is defined and its methods implemented. You may choose to
define your simpleCalc class in this same file but it is smarter to create another file,
simpleClass.java for it.
Challenge for the bored:
In the 20th century (1910) the Indian mathematician Srinivasa Ramanujan found several
rapidly converging infinite series of π, including
4! 1103 26390
which computes a further eight decimal places of π with each term in the series. Modify
your π method to instead use the series above.
This assignment is due 2 weeks from the 5th of March, 2015.