Homework 7, A Fractional Calculator

Goals

• Implement several classes.
• Design a test plan for a given class.
• Test a class using a test plan.
• Build an application based on several classes.
• Build a UML diagram for the classes in an application.

Formal Description

The expression 3 4 + is equivalent to 3 + 4. This expression would be evaluated parsing left to right as follows:

 Start with an empty stack.
 Read the number 3
    Push it on the stack
 Read the number 4
    Push it on the stack
 Read the operator +
    o2 = Pop()
    o1 = Pop()
    Push (o1+o2)

Note that the expression 3 6 / produces 1/2, and 3 6 - produces -3.

You are to implement a RPN calculator which performs calculations on rational numbers.

The algorithm for evaluating an expression in RPN is

for each token in the expression
   if the token (op)  is an operator (+,-,*,/)
      arg2 = Pop()
      arg1 = Pop()
      result =  arg1 op arg2
      Push(result)
   else if the token is a rational number
      Push(token)
   else
      Print error
      Exit algorithm

Prompt

• The number of items on the stack in parenthesis
• The percent sign.
• A space.

(0) % 

(1) % 

Commands

• off : exit the program.
• print : print the rational number at the top of the stack as a rational number.
• fprint : print the rational number at the top of the stack as a double.
• clear : remove all values from the stack.
• dump : print all values on the stack from bottom to top.
  • You may find the following algorithm useful

    PrintStack(stack s) 
       if not s.IsEmpty()
           r = s.Pop();
           PrintStack(s)
           print r
    

The following is an example session using the calculator

[bennett@mirkwood hw7]$ Calculator
(0) % 3 6 /

(1) % print

1/2
(1) % fprint

0.5
(1) % 3 6 -

(2) % print

-3
(2) % 15 7 1 1 + - / 3 * 2 1 1 + + -

(3) % print

5
(3) % dump

1/2 -3 5
(3) % clear

(0) % off

[bennett@mirkwood hw7]$

Errors

• An operation is attempted on a stack with less than two items
  • Print the following: Error: Insufficient Stack for Xxxxx." where Xxxxx is the name of the operation attempted (Add, Subtract, Multiply, Divide).
  • Abandon the remaining computation.
• An attempt to add data to a full stack
  • Print Error: Stack Overflow.
  • Abandon the remaining computation.
• Any time invalid input is received:
  • Print Error: Invalid Input xxx.
  • xxx is the value that caused the stack error
  • Abandon the remaining computation.

[bennett@mirkwood hw7]$ Calculator
(0) % 3 +

Error: Insufficient Stack for Add.
(1) % 1 2 3 4 5 6 7 8 9 10

Error: Stack Overflow.
(10) % bob

Error: Invalid Input bob.
(10) % 1a/b

Error: Invalid Input 1a/b.
(10) %

Required Classes

• RationalT a rational number class
  • Place this definition/implementation in rational.[h,C/cpp]
  • Domain
    • Rational numbers (ie fractions)
    • Please observe the following restrictions
      • Zero is the default and is represented as 0/1
      • If the rational number is negative, the sign is kept with the numerator.
        • -(3/2) has numerator -3 and denominator 2.
      • The rational number is always kept as a reduced fraction
        • 4/16 is stored as 1/4
  • Operations
    • Constructors:
      • The default constructor creates 0/1
      • A single parameter constructor taking an integer n and creating the rational number n/1
      • A two parameter constructor taking the integers n and d and creating the equivalent rational number n/d .
        • If d is zero, the default value is created.
    • RationalT Add(const RationalT & other) const
      • Return this number + other.
    • RationalT Sub(const RationalT & other) const
      • Return this number - other.
    • RationalT Mul(const RationalT & other) const
      • Return this number * other.
    • RationalT Div(const RationalT & other) const
      • Return this number / other.
    • int Num(void) const
      • Return the numerator of the number.
    • int Denom(void) const
      • Return the denominator of the number.
    • double Value(void) const
      • Return the double equivalent of the number.
• StackT a stack class
  • Place this definition/implementation in stack.[h,C/cpp]
  • The domain consists of
    • 0 to STACK_MAX (10) ItemT
  • Please provide the following functions. You must implement these functions as given, you may not add any functions to this list.
    • Constructors
      • Create an empty stack
    • void Push(ItemT i);
      • Add an item to the stack if possible.
      • If the stack is full, silently fail.
    • ItemT Pop(void);
      • Remove the top item from the stack and remove it.
      • If the stack is empty silently fail and return a default ItemT.
    • ItemT Top(void) const;
      • Return the top item on the stack.
      • DO NOT remove the top item.
      • If the stack is empty silently fail and return a default ItemT.
    • int Size(void) const;
      • Return the size of the stack.
    • bool IsEmpty(void) const;
      • Return true if the stack is empty, false otherwise.
    • bool IsFull(void) const;
      • Return true if the stack is full, false otherwise.
  • You must consider creating a program which tests this type.

When implementing the rational number class, the Euclidean Algorithm might be useful. This algorithm will compute the greatest common divisor (GCD) of any two integers very efficiently. The proof of this algorithm is given in Discrete Math, but you can use it right now

GCD (a,b)
   if a < b 
      return GCD(b,a)
   if b is 0
      return a
   else
      return GCD(b, a%b)

Testing

• I will be producing my own test driver.
• Please follow the naming convention.
• To assist you, make sure the program in BasicTests.C can be built. I will replace this file with my own which has MUCH MORE EXTENSIVE tests.
• To assist you, I have provided a basic Makefile.
• You may also want to test your calculator. The following files may be useful
  • example.in
  • example.out
  • error.in
  • error.out
  Using these files you can test your final calculator

  Calculator < example.in | diff - example.out
  Calculator < error.in | diff - error.out
  

  Neither of these will produce output for correct programs.

Discussion

• Your code must compile without warnings with the following flags

        -g -O3 -Wall -Wextra -Wuninitialized -pedantic -Wshadow -std=c++14
  

• When printing a rational number
  • If the numerator is 0, only print 0
  • If the denominator is 1, only print the numerator.
  • Otherwise print the number in the form (-)numerator/denominator
    • 1 2 / should print as 1/2
    • 0 1 2 / - should print at -1/2
  • When reading in rational numbers, you do not need to deal with a sign.
    • -1/2 is not a valid number.
    • You could deal with this otherwise, but it is not needed for our program.
• When reading in rational numbers, you should check for non digit characters in both the numerator and denominator. The following are all errors:
  • a/1
  • 12bc
  • 3a/4a
  • 1/b
• I did not handle input or output in the rational number class. I have a set of auxiliary functions
  • void FractionPrint(RationalT r);
  • void MakeRational(string arg, RationalT & r, bool & valid)
    • Checks for valid numerator and possibly denominator
    • Sets r to an appropriate value if they are good
    • Sets r to the default if not.
    • Sets valid to indicate if the input produced a valid rational number.
• If you need help with fractions, please ask.
• You will be modifying your rational number class and stack class for the last homework.
• Please note:
  • You will be modifying both the RationalT and StackT classes for the last assignment.
  • The test plan and the UML diagram will not be graded unless RationalT and StackT are implemented.
  • The test plan will not be graded unless working RatTest and StatTest routines are present. These routines must implement the test plan.

Required Files

• All source code required to build all programs in this project.
• A Makefile capable of building the programs required for this project. It should not contain executable or object files.
• A test plan using the Test Plan Document described here. Please call this document TestPlan.docx
• A UML diagram detailing the classes used in this project and their relationship. Please create this using UMLet or UMLetino Please call this Design.uml.

Submission