Merge branch 'master' of roympanju_1/ZCW-MacroLabs-OOP-ScientificCalculator into master

Console.java

         print(output + "\n", args);
     }
 
-    public static void printResult(Double result) {
+    public static void printResult(double result) {
         System.out.println("Result = " + result);
     }
 
         return firstNumber;
     }
 
-    public static Double getDoubleInput(String prompt) {
+    public static double getDoubleInput(String prompt) {
         Scanner scanner = new Scanner(System.in);
         println(prompt);
-        Double userInput = scanner.nextDouble();
+        double userInput = scanner.nextDouble();
         return userInput;
     }
 

Operations.java

      */
     public static void printHelp(){
         System.out.println("\n? | + | - | * | / |");
-        System.out.println("^ | sqrt | exp | inverse |");
+        System.out.println("^ | sqrt | inverse |");
         System.out.println("cos | sine | tan | cos-1 | sin-1 | m+ | m- | MRC");
         System.out.println("log | ln | ex |");
+        System.out.println("To exit the program enter exit");
         System.out.println("to clear display enter clrDisplay\n");
     }
 
-    public static Double runCommand()
+    public static double runCommand()
     {
         // put your code here
 
         Scanner input = new Scanner(System.in);
-        Double result = 0.0;
+        double result = 0.0;
         //String userInput = scanner.nextLine();
         scienticFunctions ScientificFunctions = new scienticFunctions();
         Memory memory = new Memory();
         DiplayMode displayMode = new DiplayMode();
         bonusFunctions bonusFunctions = new bonusFunctions();
+        calculatorCoreFunctions calculatorCoreFunctions = new calculatorCoreFunctions();
         // Calculator calc = new ....
         while (true) {
             System.out.print("Enter a command: ");
                 System.out.print("Thanks for calculating with us!");
                 break;
             }
+            else if (command.equalsIgnoreCase("+")){
+                if (result != 0){
+                    double numInput = Console.getDoubleInput("Enter number");
+                    result = calculatorCoreFunctions.add(result, numInput);
+                }
+                else{
+                    double firstNumber = Console.getDoubleInput("Enter first number");
+                    double secondNumber = Console.getDoubleInput("Enter second number");
+                    result = calculatorCoreFunctions.add(firstNumber, secondNumber);
+                }
+                Console.printResult(result);
+                
+            }
+            else if (command.equalsIgnoreCase("-")){
+                if (result != 0){
+                    double numInput = Console.getDoubleInput("Enter number");
+                    result = calculatorCoreFunctions.subtract(result, numInput);
+                }
+                else{
+                    double firstNumber = Console.getDoubleInput("Enter first number");
+                    double secondNumber = Console.getDoubleInput("Enter second number");
+                    result = calculatorCoreFunctions.subtract(firstNumber, secondNumber);;
+                }
+                Console.printResult(result);
+            }
+            else if (command.equalsIgnoreCase("*")){
+                if (result != 0){
+                    double numInput = Console.getDoubleInput("Enter number");
+                    result = calculatorCoreFunctions.multiply(result, numInput);
+                }
+                else{
+                    double firstNumber = Console.getDoubleInput("Enter first number");
+                    double secondNumber = Console.getDoubleInput("Enter second number");
+                    result = calculatorCoreFunctions.multiply(firstNumber, secondNumber);;
+                }
+                Console.printResult(result);
+            }
+            else if (command.equalsIgnoreCase("/")){
+                if (result != 0){
+                    double numInput = Console.getDoubleInput("Enter number");
+                    result = calculatorCoreFunctions.divide(result, numInput);
+                }
+                else{
+                    double firstNumber = Console.getDoubleInput("Enter first number");
+                    double secondNumber = Console.getDoubleInput("Enter second number");
+                    result = calculatorCoreFunctions.divide(firstNumber, secondNumber);;
+                }
+                Console.printResult(result);
+            }
+            else if (command.equalsIgnoreCase("^")){
+                if (result != 0){
+                    double numInput = Console.getDoubleInput("Enter number");
+                    result = calculatorCoreFunctions.exponent(result, numInput);
+                }
+                else{
+                    double firstNumber = Console.getDoubleInput("Enter first number");
+                    double secondNumber = Console.getDoubleInput("Enter second number");
+                    result = calculatorCoreFunctions.exponent(firstNumber, secondNumber);;
+                }
+                Console.printResult(result);
+            }
+            else if (command.equalsIgnoreCase("sqrt"))  {
+                if (result != 0){
+                    result = calculatorCoreFunctions.sqrt(result);
+                }
+                else{
+                    result = calculatorCoreFunctions.sqrt(Console.getDoubleInput("Enter number"));
+                }
+                Console.printResult(result);
+            }
+            else if (command.equalsIgnoreCase("inverse"))  {
+                if (result != 0){
+                    result = calculatorCoreFunctions.inverse(result);
+                }
+                else{
+                    result = calculatorCoreFunctions.inverse(Console.getDoubleInput("Enter number"));
+                }
+                Console.printResult(result);
+            }
             else if (command.equalsIgnoreCase("sine"))  {
                 if (result != 0){
                     result = ScientificFunctions.sine(result);

bonusFunctions.java

      * @param  y  a sample parameter for a method
      * @return    the sum of x and y
      */
-    public Double naturalLogLn(Double x)
+    public double naturalLogLn(double x)
     {
         // put your code here
         return Math.log(x);
     }
     
-    public Double LogBaseTenOfAnumber(Double x)
+    public double LogBaseTenOfAnumber(double x)
     {
         // put your code here
         return Math.log10(x);
     }
     
-    public Double exponential(Double x)
+    public double exponential(double x)
     {
         // put your code here
         return Math.exp(x);

bonusFunctionsTest.java

         Double actual = bonusFunctions.exponential(1.0);
 
         // :Then
-        Assert.assertEquals(expected, actual);
+        Assert.assertEquals(expected, actual, 0.10);
     }
     
 }

calculatorCoreFunctions.java

  * @author (your name)
  * @version (a version number or a date)
  */
+import java.lang.*;
+import java.util.*;
 public class calculatorCoreFunctions
 {
     // instance variables - replace the example below with your own
-    private int x;
-    
 
     /**
-     * Constructor for objects of class calculatorCoreFunctions
+     * Write a description of class calculatorCoreFunctions here.
+     *
+     * @author (your name)
+     * @version (a version number or a date)
      */
+
     public calculatorCoreFunctions()
     {
         // initialise instance variables
-        x = 5;
-        //y= 0;
+        double x = 0;
+        double y = 0;
     }
 
     /**
      * @param  y  a sample parameter for a method
      * @return    the sum of x and y
      */
-    public int add(int y)
+    public double add(double x, double y)
     {
         // put your code here
         return x + y;
     }
+
+    public double subtract(double x, double y)
+    {
+        return x - y;
+    }
+
+    public double multiply(double x, double y)
+    {
+        return x * y;
+    }
+
+    public double divide(double x, double y)
+    {
+        if (y == 0)
+        {
+            System.out.println("Invalid input");
+            return 0;
+        }
+        return x / y;
+    }
+
+    public double sqrt(double x)
+    {
+        return Math.sqrt(x);
+    }
+
+    public double exponent(double x, double y)
+    {
+        return Math.pow(x, y);
+    }
+
+    public double inverse(double x)
+    {
+        if (x ==0){
+            return 0;
+        }
+        return 1 / x;
+    }
 }
+

calculatorCoreFunctionsTest.java

+
+
+import static org.junit.Assert.*;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * The test class calculatorCoreFunctionsTest.
+ *
+ * @author  (your name)
+ * @version (a version number or a date)
+ */
+import static org.junit.Assert.*;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+* The test class calculatorCoreFunctionsTest.
+*
+* @author  (your name)
+* @version (a version number or a date)
+*/
+public class calculatorCoreFunctionsTest
+{
+   public calculatorCoreFunctions coreFunctions;
+   
+ 
+   @Before
+   public void setUp()
+   {
+     coreFunctions = new calculatorCoreFunctions();
+   }
+   
+   @After
+   public void tearDown()
+   {
+   }
+   
+   @Test
+   public void addTest()
+   {
+       double expected = 9.0;
+       double actual = coreFunctions.add(8,1);
+       assertEquals(expected, actual, 0.1);
+     
+   }
+
+   @Test
+   public void subtractTest()
+   {
+       double expected = 5.0;
+       double actual = coreFunctions.subtract(7,2);
+       assertEquals(expected, actual, 0.1);
+   }
+   
+   @Test
+   public void multiplyTest()
+   {
+       double expected = 12.0;
+       double actual = coreFunctions.multiply(3,4);
+       assertEquals(expected, actual, 0.1);
+   }
+   
+   @Test
+   public void divideTest()
+   {
+       double expected = 7.0;
+       double actual = coreFunctions.divide(21,3);
+       assertEquals(expected, actual, 0.1);
+   }
+   
+   @Test
+   public void expTest()
+   {
+       double expected = 4.0;
+       double actual = coreFunctions.exponent(2,2);
+       assertEquals(expected, actual, 0.1);
+   }
+   
+   @Test
+   public void sqrtTest()
+   {
+       double expected = 5.0;
+       double actual = coreFunctions.sqrt(25.0);
+       assertEquals(expected, actual, 0.1);
+   }
+   
+   @Test
+   public void invertTest()
+   {
+       double expected = 0.2;
+       double actual = coreFunctions.inverse(5.0);
+       assertEquals(expected, actual, 0.1);
+   }
+}

package.bluej

 dependency1.from=bonusFunctionsTest
 dependency1.to=bonusFunctions
 dependency1.type=UsesDependency
-dependency10.from=Operations
-dependency10.to=Console
+dependency10.from=MainApplication
+dependency10.to=Operations
 dependency10.type=UsesDependency
-dependency11.from=ConsoleTest
-dependency11.to=Console
-dependency11.type=UsesDependency
-dependency12.from=MainApplication
-dependency12.to=Console
-dependency12.type=UsesDependency
-dependency13.from=MainApplication
-dependency13.to=Operations
-dependency13.type=UsesDependency
 dependency2.from=scienticFunctionsTest
 dependency2.to=scienticFunctions
 dependency2.type=UsesDependency
 dependency3.from=DiplayMode
 dependency3.to=Console
 dependency3.type=UsesDependency
-dependency4.from=Calculator
-dependency4.to=CoreFunctions
+dependency4.from=Operations
+dependency4.to=scienticFunctions
 dependency4.type=UsesDependency
-dependency5.from=Calculator
-dependency5.to=Operations
+dependency5.from=Operations
+dependency5.to=Memory
 dependency5.type=UsesDependency
 dependency6.from=Operations
-dependency6.to=scienticFunctions
+dependency6.to=DiplayMode
 dependency6.type=UsesDependency
 dependency7.from=Operations
-dependency7.to=Memory
+dependency7.to=bonusFunctions
 dependency7.type=UsesDependency
 dependency8.from=Operations
-dependency8.to=DiplayMode
+dependency8.to=Console
 dependency8.type=UsesDependency
-dependency9.from=Operations
-dependency9.to=bonusFunctions
+dependency9.from=MainApplication
+dependency9.to=Console
 dependency9.type=UsesDependency
 editor.fx.0.height=717
 editor.fx.0.width=800
-editor.fx.0.x=371
+editor.fx.0.x=480
 editor.fx.0.y=23
 objectbench.height=200
 objectbench.width=552
 package.divider.vertical=0.6854103343465046
 package.editor.height=444
 package.editor.width=825
-package.editor.x=35
-package.editor.y=23
+package.editor.x=105
+package.editor.y=32
 package.frame.height=716
 package.frame.width=951
-package.numDependencies=13
-package.numTargets=17
+package.numDependencies=10
+package.numTargets=10
 package.showExtends=true
 package.showUses=true
 project.charset=UTF-8
 readme.x=10
 readme.y=10
 target1.height=50
-target1.name=CoreFunctionsCo
+target1.name=DiplayMode
 target1.showInterface=false
 target1.type=ClassTarget
-target1.width=130
-target1.x=10
-target1.y=120
+target1.width=100
+target1.x=50
+target1.y=360
 target10.height=50
-target10.name=CoreFunctionsTest
+target10.name=MainApplication
 target10.showInterface=false
 target10.type=ClassTarget
-target10.width=140
-target10.x=10
-target10.y=240
-target11.height=50
-target11.name=Calculator
-target11.showInterface=false
-target11.type=ClassTarget
-target11.width=90
-target11.x=160
-target11.y=260
-target12.height=50
-target12.name=Console
-target12.showInterface=false
-target12.type=ClassTarget
-target12.width=80
-target12.x=240
-target12.y=200
-target13.association=bonusFunctionsTest
-target13.height=50
-target13.name=bonusFunctions
-target13.showInterface=false
-target13.type=ClassTarget
-target13.width=120
-target13.x=500
-target13.y=330
-target14.height=50
-target14.name=Operations
-target14.showInterface=false
-target14.type=ClassTarget
-target14.width=90
-target14.x=380
-target14.y=370
-target15.height=50
-target15.name=ConsoleTest
-target15.showInterface=false
-target15.type=ClassTarget
-target15.width=100
-target15.x=10
-target15.y=300
-target16.height=50
-target16.name=MainApplication
-target16.showInterface=false
-target16.type=ClassTarget
-target16.width=120
-target16.x=140
-target16.y=60
-target17.height=50
-target17.name=Display
-target17.showInterface=false
-target17.type=ClassTarget
-target17.width=80
-target17.x=160
-target17.y=320
+target10.width=120
+target10.x=140
+target10.y=60
 target2.height=50
-target2.name=CoreFunctionsCoTest
+target2.name=Memory
 target2.showInterface=false
 target2.type=ClassTarget
-target2.width=160
-target2.x=10
-target2.y=180
+target2.width=80
+target2.x=640
+target2.y=370
 target3.height=50
-target3.name=Memory
+target3.name=bonusFunctionsTest
 target3.showInterface=false
-target3.type=ClassTarget
-target3.width=80
-target3.x=640
-target3.y=370
+target3.type=UnitTestTargetJunit4
+target3.width=120
+target3.x=530
+target3.y=300
+target4.association=scienticFunctionsTest
 target4.height=50
-target4.name=bonusFunctionsTest
+target4.name=scienticFunctions
 target4.showInterface=false
-target4.type=UnitTestTargetJunit4
-target4.width=120
-target4.x=530
-target4.y=300
-target5.association=scienticFunctionsTest
+target4.type=ClassTarget
+target4.width=130
+target4.x=500
+target4.y=230
 target5.height=50
-target5.name=scienticFunctions
+target5.name=Console
 target5.showInterface=false
 target5.type=ClassTarget
-target5.width=130
-target5.x=500
-target5.y=230
+target5.width=80
+target5.x=30
+target5.y=160
 target6.height=50
 target6.name=scienticFunctionsTest
 target6.showInterface=false
 target7.width=180
 target7.x=460
 target7.y=150
+target8.association=bonusFunctionsTest
 target8.height=50
-target8.name=CoreFunctions
+target8.name=bonusFunctions
 target8.showInterface=false
 target8.type=ClassTarget
 target8.width=120
-target8.x=150
-target8.y=120
+target8.x=500
+target8.y=330
 target9.height=50
-target9.name=DiplayMode
+target9.name=Operations
 target9.showInterface=false
 target9.type=ClassTarget
-target9.width=100
-target9.x=50
-target9.y=360
+target9.width=90
+target9.x=380
+target9.y=370