Add files via upload

Author: hoangsonww

ArbitraryFloatingPointNumbers.java

@@ -0,0 +1,208 @@
+/**
+ * A class that represents Arbitrary Whole Numbers
+ * @author David Nguyen
+ * @since  11/14/2022
+ */
+public class ArbitraryWholeNumbers extends ArbitraryFloatingPointNumbers {
+
+    // A boolean field that indicates whether the number is less than 0 or not
+    private boolean isNegative;
+    // An array that stores the digits of the floating point number
+    private int[] digits;
+
+    /**
+     * Creates an Arbitrary Whole Number.
+     * Assigns the class's fields the values that the constructor got when a Arbitrary Whole Number object is created.
+     * Passes the fields to the superclass (Arbitrary Floating Point Number).
+     * @param isNegative A boolean indicating whether the current number is negative or not
+     * @param digits     An array that represents the digits of an arbitrary floating point number
+     */
+    public ArbitraryWholeNumbers(boolean isNegative, int[] digits) {
+        super(isNegative, digits);
+        this.isNegative = isNegative;
+        this.digits = digits;
+    }
+
+    /**
+     * Determines whether the current arbitrary whole number is negative or not.
+     * Returns true if the current number is negative.
+     * Returns false if the current number is NOT negative.
+     * @return A boolean that indicates whether the current number is negative.
+     */
+    public boolean isNegativeNumber() {
+        if (isNegative)
+            return true;
+        else
+            return false;
+    }
+
+    /**
+     * An overridden toString method that creates the string representation of an arbitrary whole number given.
+     * @return A string that is the proper string representation of an arbitrary whole number given
+     */
+    public String toString() {
+        StringBuilder result = new StringBuilder();
+        // Append '-' sign to the beginning of the number if the number is negative
+        if (this.isNegative == true) {
+            result.append('-');
+        }
+        // A new array that is same as digits but has all leading zeros removed.
+        int[] array = removeLeadingZero(digits);
+        // Append every element of the array that has all leading zeros removed to the resulting string
+        for (int i = (array.length - 1); i >= 0; i--) {
+            result.append(array[i]);
+        }
+        return result.toString();
+    }
+
+    /**
+     * A helper method to remove leading zeros.
+     * @param  array Any given int array that needs its leading zeros removed
+     * @return An array that has all its leading zeros removed
+     */
+    public int[] removeLeadingZero(int[] array) {
+        // A variable that stores the numbers of leading zeros
+        int numLeadingZero = 0;
+        // A variable that stores whether the current digit in the array is a non-zero
+        boolean isNonZero = false;
+        // A variable storing the index for the following 'while' loop
+        int i = array.length - 1;
+        /* A loop that determines the number of leading zeros.
+         * The nonZero variable will also be set when the first non-zero is met to indicates the end of loop
+         * Condition: The index must be more than or equal to 0 and the isNonZero variable must be FALSE
+         */
+        while (i >= 0 && !isNonZero) {
+            if (array[i] == 0) {
+                numLeadingZero++;
+                isNonZero = false;
+                i--;
+            }
+            else
+                isNonZero = true;
+        }
+        // A variable that stores the length of the new array
+        int newLength = array.length - numLeadingZero;
+        // An array of type int that stores the new array
+        int[] newArray = new int[newLength];
+        // A variable storing the index of the old (given) array
+        int index1 = array.length - numLeadingZero - 1;
+        // A variable storing the index of the new array
+        int index2 = newArray.length - 1;
+        /* A loop that copies every element from old, original array to the new array
+         * Condition: index of both arrays must be more than or equal to 0
+         */
+        while (index1 >= 0 && index2 >= 0) {
+            newArray[index2] = array[index1];
+            index1--;
+            index2--;
+        }
+        return newArray;
+    }
+
+    /**
+     * A helper method that converts all arrays to strings.
+     * @param  array Any given arrays of type int
+     * @return A String that is the string representation of the given array
+     */
+    public String arrayToString(int[] array) {
+        // A variable of type StringBuilder that stores the output string
+        StringBuilder output = new StringBuilder();
+        /* A loop that appends every element of the given array into the output string
+         * Condition: index must be less than length of array */
+        for (int i = 0; i < array.length; i++) {
+            if (array[i] != 0)
+                output.append(array[i]);
+        }
+        return output.toString();
+    }
+
+    /**
+     * An overridden equals method that determines if two whole numbers are equal to each other
+     * This can be done by comparing the contents of the two string representations of the two numbers
+     * @param o Any given object
+     * @return Returning true or false depending on these numbers' equality
+     */
+    public boolean equals(Object o) {
+        if (o instanceof ArbitraryWholeNumbers) {
+            ArbitraryWholeNumbers number = (ArbitraryWholeNumbers) o;
+            // A variable storing this number's digits with leading zeros removed
+            int[] newArray1 = removeLeadingZero(this.digits);
+            // A variable storing input, given number's digits with leading zeros removed
+            int[] newArray2 = removeLeadingZero(number.digits);
+            // A variable storing the string representation of this ArbitraryWholeNumbers
+            String s1 = arrayToString(newArray1);
+            // A variable storing the string representation of the given ArbitraryWholeNumbers
+            String s2 = arrayToString(newArray2);
+            return (this.isNegativeNumber() == number.isNegativeNumber() && s1.equals(s2));
+        }
+        return false;
+    }
+
+    /**
+     * A method to add two arbitrary whole numbers and return the string representation of the result
+     * @param     value1                        Any given value of type ArbitraryWholeNumbers
+     * @param     value2                        Any given value of type ArbitraryWholeNumbers
+     * @exception UnsupportedOperationException Throw this exception when given input numbers have different signs
+     * @return    A new object of type ArbitraryWholeNumbers that has all the numbers added up
+     */
+    public ArbitraryWholeNumbers add (ArbitraryWholeNumbers value1, ArbitraryWholeNumbers value2) {
+        // A variable to keep track of the carry
+        int carry = 0;
+        // A variable to set the length of the array
+        int length = 0;
+        // Remove Leading Zeros of both input values
+        // Array1 is a new array of type int that is the digits of value1 that has been removed all leading zeros
+        int[] newArray1 = removeLeadingZero(value1.digits);
+        // Array2 is a new array of type int that is the digits of value2 that has been removed all leading zeros
+        int[] newArray2 = removeLeadingZero(value2.digits);
+        /* Setting length of resulting array to the maximum length between the two newArrays.
+         */
+        if (newArray1.length > newArray2.length)
+            length = newArray1.length + 1;
+        else
+            length = newArray2.length + 1;
+        // An array of type int storing a new array with the same length as the result array for input value2's digits
+        int[] array1 = new int[length];
+        // Copying all digits from value1's original digits array (with leading 0's removed) to this array (array1)
+        for (int i = 0; i < newArray1.length; i++) {
+            array1[i] = newArray1[i];
+        }
+        // An array of type int storing a new array with the same length as the result array for input value2's digits
+        int[] array2 = new int[length];
+        // Copying all digits from value1's original digits array (with leading 0's removed) to this array (array1)
+        for (int i = 0; i < newArray2.length; i++) {
+            array2[i] = newArray2[i];
+        }
+        // An array storing the resulting array from adding
+        int[] result = new int[length];
+        // A variable storing index of result's digits array
+        int i = 0;
+        // A temporary variable storing the sum of the addition of each corresponding pair of digits
+        int s = 0;
+        // If the values for adding have different signs, throw an UnsupportedOperationException
+        if (value1.isNegativeNumber() == value2.isNegativeNumber()) {
+            /* A loop that adds every corresponding pair of digits from the two arrays and stores them in the result array
+             * Condition: index must be less than or equal to the result array's length */
+            while (i < result.length) {
+                s = array1[i] + array2[i] + carry;
+                if (s >= 10) {
+                    carry = 1;
+                    result[i] = s - 10;
+                }
+                else {
+                    carry = 0;
+                    result[i] = s;
+                }
+                i++;
+            }
+        }
+        else
+            throw new UnsupportedOperationException("Invalid inputs");
+        // A whole number object storing the output of the addition, which will also be returned
+        ArbitraryWholeNumbers output = new ArbitraryWholeNumbers(false, result);
+        // If the inputs are negative, the result must also have isNegative set to true
+        if (value1.isNegativeNumber())
+            output.isNegative = true;
+        return output;
+    }
+}

ArbitraryWholeNumbers.java

@@ -0,0 +1,31 @@
+//David Nguyen - The class Bid represents a bid that a contractor makes for a contract//
+public class Bid{
+  //The contract field represents the contract name for the bid
+  Contract contract;
+  //The contractor field represents the contractor's name
+  Contractor contractor;
+  //The value field represents the value of the bid
+  Double value;
+  
+  //A constructor that creates a bid//
+  public Bid (Contract contract, Contractor contractor, double value) {
+    this.contract = contract;
+    this.contractor = contractor;
+    this.value = value; 
+  }
+  
+  //A method that returns the contract for the bid
+  public Contract contract() {
+    return contract;
+  }
+  
+  //A method that returns the contractor for the bid
+  public Contractor contractor() {
+    return this.contractor;
+  }
+  
+  //A method that returns the value of the bid//
+  public double value() {
+    return this.value;
+  } 
+}

Bid.java

@@ -0,0 +1,75 @@
+/**
+ * A class that represents Complex Numbers
+ * @author David Nguyen
+ * @since  11/14/2022
+ */
+public class ComplexNumber implements ComplexNumberInterface{
+
+    // A field representing the real part
+    private ArbitraryFloatingPointNumbers real;
+    // A field representing the imaginary part
+    private ArbitraryFloatingPointNumbers imaginary;
+
+    /**
+     * Creates a Complex Number.
+     * Assigns the class's fields the values that the constructor got when a ComplexNumber object is created.
+     * @param real      An ArbitraryFloatingPointNumbers that represents a real part
+     * @param imaginary An ArbitraryFloatingPointNumbers that represents an imaginary part
+     */
+    public ComplexNumber (ArbitraryFloatingPointNumbers real, ArbitraryFloatingPointNumbers imaginary) {
+        this.real = real;
+        this.imaginary = imaginary;
+    }
+
+    /**
+     * A method that retrieves the real part of the complex number.
+     * @return A floating point number that represents the real part of a complex number
+     */
+    public ArbitraryFloatingPointNumbers getRealPart() {
+        return real;
+    }
+
+    /**
+     * A method that retrieves the imaginary part of the complex number.
+     * @return ArbitraryFloatingPointNumbers A floating point number that represents the imaginary part of a complex number
+     */
+    public ArbitraryFloatingPointNumbers getImaginaryPart() {
+        return imaginary;
+    }
+
+    /**
+     * A method that retrieves the imaginary part of the complex number.
+     * @param  number Any ComplexNumber object that is given as input
+     * @return A Complex Number that is the result of the addition between this ComplexNumber and the input number
+     */
+    public ComplexNumber add(ComplexNumberInterface number) {
+        ArbitraryFloatingPointNumbers newReal = this.getRealPart().add(this.getRealPart(), number.getRealPart());
+        ArbitraryFloatingPointNumbers newImaginary = this.getImaginaryPart().add(this.getImaginaryPart(), number.getImaginaryPart());
+        ComplexNumber result = new ComplexNumber (newReal, newImaginary);
+        return result;
+    }
+
+    /**
+     * A method that compares any two complex numbers.
+     * @param value1 Any ComplexNumber object that is given as input
+     * @param value2 Any ComplexNumber object that is given as input
+     * @return A boolean (true or false) depending on equality of these two numbers
+     */
+    public boolean equals(ComplexNumber value1, ComplexNumber value2) {
+        return (value1.getRealPart().equals(value2.getRealPart())) && (value1.getImaginaryPart().equals(getImaginaryPart()));
+    }
+
+    /**
+     * A method that returns the string representation of this complex number.
+     * @return A String that is the proper string representation of the complex number
+     */
+    public String toString() {
+        String output = new String();
+        if (!getImaginaryPart().isNegativeNumber()) {
+            output = (getRealPart() + " + " + getImaginaryPart() + "i");
+        }
+        else
+            output = (getRealPart() + " " + getImaginaryPart() + "i");
+        return output;
+    }
+}

ComplexNumber.java

@@ -0,0 +1,19 @@
+/**
+ * An interface that represents Complex Numbers
+ * @author David Nguyen
+ * @since  11/14/2022
+ */
+public interface ComplexNumberInterface {
+
+    /**
+     * An abstract method that retrieves the real part of the complex number.
+     * @return A floating point number that represents the real part of the complex number
+     */
+    ArbitraryFloatingPointNumbers getRealPart();
+
+    /**
+     * An abstract method that retrieves the imaginary part of the complex number
+     * @return A floating point number that represents the imaginary part of the complex number
+     */
+    ArbitraryFloatingPointNumbers getImaginaryPart();
+}