Programming Assignment 4.9
Design and implement a class called Building that represents a drawing of a building.
The parameters to the constructor should be the building’s width and height.
Each building should be colored black and have a few random windows colored yellow.
Create an application with StdDraw that draws a random skyline of buildings.

StdDraw library from PU

Project includes: HugeInteger_YI.java and HugeIntegerDriver_YI.java

Huge Integer Class: Create a class HugeInteger which uses a 40-element array of digits to store integers as large as 40 digit long. Provide methods parse, toString, add and subtract to manipulate objects of HugeInteger. Method parse should receive a String, extract each digit using method charAt or substring and place the integer equivalent of each digit into the integer array and return a HugeInteger object. For comparing HugeInteger objects, provide the following methods:

isEqualTo, isGreaterThan, isLessThan, isGreaterThanOrEqualTo and isLessThanOrEqualTo

Each of these is a predicate method that returns true if the relationship holds between the two HugeInteger objects and returns false if the relationship does not hold. Provide a predicate method isZero.
The driver should look like this:

…
// 40-digit input
HugeInteger hi1 = new HugeInteger(?); // where the ? means any implementation you choose
HugeInteger hi2 = new HugeInteger(?); // where the ? means any implementation you choose
…
Addition implementations could be as follows:

HugeInteger hi3 = hi2.subtract(hi1);

or

hi2.subtract(hi1)

Things to know:
* Your driver should accept input BUT for testing purposes ONLY, you should hard code the test data.
* Do not use more than 10 digits as test data.
* Assume the string contains only integers.

Make sure you test your code properly:
– add numbers that require carryover
– subtract numbers that require borrowing
– a HugeInteger can be negative
– print the numbers before and after the operations

**** NOTE: This assignment is about object-oriented design. Therefore, the operands are objects of HugeInteger.

Before you start on this assignment, read it carefully and turn your paper for approval:
1. Simple example in paper and pencil: choose two smaller than 40-digit numbers and using your design add and subtract them. Use a diagram representing how the digits are placed in the array.
2. Address the details you need to implement to handle any issues like a “carry-over” and “borrowing” that might arise: re-design.
3. Re-do the example after you make the changes to your design.
NOTE: If you have any questions, I will not answer them unless you have your example on paper.

.

.

.
BE AWARE that
25% of the grade is based on documentation. Indicate with a comment the code that handles each operation and how it does it.
25% of the grade is based on thorough testing.
25% of the grade is based on well-organized and readable code
25% of the grade is based on the working code.

Extra credit: provide methods multiply, divide and remainder. Limit these last 3 operations by a data type int.

//********************************************************************
//  Rational.java       Author: Lewis/Loftus/Cocking
//
//  Represents one rational number with a numerator and denominator.
//********************************************************************

public class Rational
{
   private int numerator, denominator;

   //-----------------------------------------------------------------
   //  Sets up the rational number by ensuring a nonzero denominator
   //  and making only the numerator signed.
   //-----------------------------------------------------------------
   public Rational (int numer, int denom)
   {
      if (denom == 0)
         denom = 1;

      // Make the numerator "store" the sign
      if (denom < 0)
      {
         numer = numer * -1;
         denom = denom * -1;
      }

      numerator = numer;
      denominator = denom;

      reduce();
   }

   //-----------------------------------------------------------------
   //  Returns the numerator of this rational number.
   //-----------------------------------------------------------------
   public int getNumerator ()
   {
      return numerator;
   }

   //-----------------------------------------------------------------
   //  Returns the denominator of this rational number.
   //-----------------------------------------------------------------
   public int getDenominator ()
   {
      return denominator;
   }

   //-----------------------------------------------------------------
   //  Returns the reciprocal of this rational number.
   //-----------------------------------------------------------------
   public Rational reciprocal ()
   {
      return new Rational (denominator, numerator);
   }

   //-----------------------------------------------------------------
   //  Adds this rational number to the one passed as a parameter.
   //  A common denominator is found by multiplying the individual
   //  denominators.
   //-----------------------------------------------------------------
   public Rational add (Rational op2)
   {
      int commonDenominator = denominator * op2.getDenominator();
      int numerator1 = numerator * op2.getDenominator();
      int numerator2 = op2.getNumerator() * denominator;
      int sum = numerator1 + numerator2;

      return new Rational (sum, commonDenominator);
   }

   //-----------------------------------------------------------------
   //  Subtracts the rational number passed as a parameter from this
   //  rational number.
   //-----------------------------------------------------------------
   public Rational subtract (Rational op2)
   {
      int commonDenominator = denominator * op2.getDenominator();
      int numerator1 = numerator * op2.getDenominator();
      int numerator2 = op2.getNumerator() * denominator;
      int difference = numerator1 - numerator2;

      return new Rational (difference, commonDenominator);
   }

   //-----------------------------------------------------------------
   //  Multiplies this rational number by the one passed as a
   //  parameter.
   //-----------------------------------------------------------------
   public Rational multiply (Rational op2)
   {
      int numer = numerator * op2.getNumerator();
      int denom = denominator * op2.getDenominator();

      return new Rational (numer, denom);
   }

   //-----------------------------------------------------------------
   //  Divides this rational number by the one passed as a parameter
   //  by multiplying by the reciprocal of the second rational.
   //-----------------------------------------------------------------
   public Rational divide (Rational op2)
   {
      return multiply (op2.reciprocal());
   }

   //-----------------------------------------------------------------
   //  Determines if this rational number is equal to the one passed
   //  as a parameter.  Assumes they are both reduced.
   //-----------------------------------------------------------------
   public boolean equals (Rational op2)
   {
      return ( numerator == op2.getNumerator() &&
               denominator == op2.getDenominator() );
   }

   //-----------------------------------------------------------------
   //  Returns this rational number as a string.
   //-----------------------------------------------------------------
   public String toString ()
   {
      String result;

      if (numerator == 0)
         result = "0";
      else
         if (denominator == 1)
            result = numerator + "";
         else
            result = numerator + "/" + denominator;

      return result;
   }

   //-----------------------------------------------------------------
   //  Reduces this rational number by dividing both the numerator
   //  and the denominator by their greatest common divisor.
   //-----------------------------------------------------------------
   private void reduce ()
   {
      if (numerator != 0)
      {
         int common = gcd (Math.abs(numerator), denominator);

         numerator = numerator / common;
         denominator = denominator / common;
      }
   }

   //-----------------------------------------------------------------
   //  Computes and returns the greatest common divisor of the two
   //  positive parameters. Uses Euclid's algorithm.
   //-----------------------------------------------------------------
   private int gcd (int num1, int num2)
   {
      while (num1 != num2)
         if (num1 > num2)
            num1 = num1 - num2;
         else
            num2 = num2 - num1;

      return num1;
   }
}