formatting changes

Calculator.java

 import java.util.*;
+
 public class Calculator{
-public static double memory = 0;
+
+
+    /**
+     * Write a description of class Calculator here.
+     *
+     * @author (your name)
+     * @version (a version number or a date)
+     */
+
+    public static double lastAns = 0;
+
     public static void main(String args[]){
-        
         String toDo;                //what the user wants to do
         double num1 = 0;                //The user's first input
         double num2 = 0;            //The user's second input
         while (off == false){
             Scanner input1 = new Scanner(System.in);
             System.out.println("What do you want to do?");
-            toDo = input1.nextLine();
+            toDo = input1.next();
 
-            if (toDo.equals("quit")){
+            if (toDo.equalsIgnoreCase("quit")){
                 off = true;
                 System.out.println("Goodbye!! \n \n");
 
             } else {
                 switch (toDo) {
-                //System.out.println("toDO is: " + toDo);
+                    //System.out.println("toDO is: " + toDo);
                     case "add":
                     case "subtract":
                     case "multiply":
                     case "inverse sine" :
                     case "degree to radian" :
                     case "radian to degree" :
-                System.out.println(toDo + " -- Enter first number:");
-                num1 = input1.nextDouble();
-                //System.out.println("num1 is: " + num1);
-            }
+                    case "square" :
+                    case "tangent" :
+                    case "inverse tangent" :
+                    case "inverse" :
+                    case "M+" :
+                    System.out.println(toDo + " -- Enter first number:");
+                    num1 = input1.nextDouble();
+                    //System.out.println("num1 is: " + num1);
+                }
                 switch (toDo){
                     case "add":
                     case "subtract":
                 switch (toDo) {        
                     case "add":
                     result = calc.add(num1, num2);
-                    memory = result;
+                    lastAns = result;
                     calc.printAns(String.valueOf(result));
                     break;
 
                     case "subtract":
                     result = calc.subtract(num1, num2);
-                    memory = result;
+                    lastAns = result;
                     calc.printAns(String.valueOf(result));
                     break;
 
                     case "multiply":
                     result = calc.multiply(num1, num2);
-                    memory = result;
+                    lastAns = result;
                     calc.printAns(String.valueOf(result));
                     break;
 
                     case "divide":
                     result = calc.divide(num1, num2);
-                    memory = result;
+                    lastAns = result;
                     calc.printAns(String.valueOf(result));
                     break;
 
                     case "exponent":
                     result = calc.exponent(num1, num2);
-                    memory = result;
+                    lastAns = result;
                     calc.printAns(String.valueOf(result));
                     break;
 
                     case "cosine":
                     result = calc.cosine(num1);
-                    memory = result;
+                    lastAns = result;
                     calc.printAns(String.valueOf(result));
                     break;
 
                     case "inverse cosine":
                     result = calc.invCosine(num1);
-                    memory = result;
+                    lastAns = result;
                     calc.printAns(String.valueOf(result));
                     break;
 
                     case "square root":
                     result = calc.squareRoot(num1);
-                    memory = result;
+                    lastAns = result;
                     calc.printAns(String.valueOf(result));
                     break;
 
                     case "invert":
                     result = calc.invert(num1);
-                    memory = result;
+                    lastAns = result;
                     calc.printAns(String.valueOf(result));
                     break;
 
                     case "sine":
                     result = calc.sin(num1);
-                    memory = result;
+                    lastAns = result;
                     calc.printAns(String.valueOf(result));
                     break;
 
                     case "inverse sine":
                     result = calc.iSin(num1);
-                    memory = result;
+                    lastAns = result;
                     calc.printAns(String.valueOf(result));
                     break;
 
                     case "degree to radian":
                     result = calc.degToRad(num1);
-                    memory = result;
+                    lastAns = result;
                     calc.printAns(String.valueOf(result));
                     break;
 
                     case "radian to degree":
                     result = calc.radToDeg(num1);
-                    memory = result;
+                    lastAns = result;
                     calc.printAns(String.valueOf(result));
                     break;
 
                     break;
 
                     case "display mode decimal":
-                    calc.printAns(String.valueOf(memory));
+                    calc.printAns(String.valueOf(lastAns));
                     break;
-                    
+
                     case "display mode hexadecimal":
                     calc.printAns(calc.switchDisplayMode("hexadecimal"));
-                    
+
                     case "display mode octal":
                     calc.printAns(calc.switchDisplayMode("octal"));
                     break;
-                    
+
                     case "display mode binary":
                     calc.printAns(calc.switchDisplayMode("binary"));
                     break;
-                    
+
                     case "display mode" :
                     calc.printAns(calc.switchDisplayMode());
                     break;
-                    
+
                     case "random number":
                     result = calc.randomNumber();
-                    memory = result;
+                    lastAns = result;
+                    calc.printAns(String.valueOf(result));
+                    break;      
+
+                    case "square":
+                    result = calc.square(num1);
+                    lastAns = result;
+                    calc.printAns(String.valueOf(result));
+                    break;
+
+                    case "inverse":
+                    result = calc.inverse(num1);
+                    lastAns = result;
+                    calc.printAns(String.valueOf(result));
+                    break;
+
+                    case "tangent":
+                    result = calc.tangent(num1);
+                    lastAns = result;
                     calc.printAns(String.valueOf(result));
                     break;
 
-                    
+                    case "inverse tangent":
+                    result = calc.iTan(num1);
+                    lastAns = result;
+                    calc.printAns(String.valueOf(result));
+                    break; 
+
+                    case "MR" :
+                    result = Memory.memRead();
+                    Memory.printAns(String.valueOf(result));
+                    break;
+
+                    case "M+" :
+                    System.out.println("Enter number:");
+                    num1 = input1.nextDouble();
+                    result = Memory.memUpdate(num1);
+                    Memory.printAns(String.valueOf(result));
+                    break;
+
+                    case "MC" :
+                    result = Memory.memClear();
+                    Memory.printAns(String.valueOf(result));
+                    break;
 
                 }
             }
-
         }
     }
+
 }
+

MathMethods.java

         return wiseWords[arrIndex];
     }
 
+    public static double square(double n1) {
+        return Math.pow(n1, 2);}
+
     public static String switchDisplayMode(String mode){
-        Calculator display = new Calculator();
 
+        Calculator display = new Calculator();
         String answer = "";
         switch (mode) {
             case "binary":
-            answer = "0b " + Integer.toBinaryString((int)display.memory);
+            answer = "0b " + Integer.toBinaryString((int)display.lastAns);
             break;
 
             case "octal":
-            answer = "0 " + Integer.toOctalString((int)display.memory);
+            answer = "0 " + Integer.toOctalString((int)display.lastAns);
             break;
 
             case "decimal":
-            answer = String.valueOf(display.memory);
+            answer = String.valueOf(display.lastAns);
             break;
 
             case "hexadecimal":
-            answer = "0x " + Integer.toHexString((int)display.memory);
+            answer = "0x " + Integer.toHexString((int)display.lastAns);
             break;
 
         }
     }
 
     public String switchDisplayMode(){
-
         String answer = "";
-
         if (displayModeCounter%4 == 0){ 
             answer = switchDisplayMode("binary");
             displayModeCounter++;
 
     public static void printAns(String printAnswer){
         System.out.println("ANSWER: " + printAnswer + "\n \n");
+    }
 
+    public static double inverse(double n1) {
+        return 1 / n1;
+    }
+
+    public static double tangent(double n1) {
+        return Math.tan(n1);
+    }
+
+    public static double iTan(double n1) {
+        return Math.atan(n1);
+    }
+
+    public static double state() {
+        Calculator display = new Calculator();
+        return (display.lastAns);
     }
 
 }

MathMethodsTest.java

 
-
 import static org.junit.Assert.*;
 import org.junit.After;
 import org.junit.Before;
     }
 
     @Test
+
     public void testSquareRoot()
     {
         assertEquals(16.0, MathMethods.squareRoot(256), 0.1);
         assertEquals(57.2957791308232, MathMethods.radToDeg(1), 0.1);
     }
 
-    
-
     // @Test
     // public void testOctalDisplay()
     // {
-        // MathMethods mathMethods1 = new MathMethods();
-        // mathMethods1.memory = 20;
-        
-        // assertEquals("0 24", MathMethods.switchDisplayMode("octal"));
+    // MathMethods mathMethods1 = new MathMethods();
+    // mathMethods1.memory = 20;
+
+    // assertEquals("0 24", MathMethods.switchDisplayMode("octal"));
     // }
 
     @Test
     {
         assertEquals(1.5707963267948966, MathMethods.iSin(1), 0.1);
     }
-}
-
-
 
+    public void squareTest()
+    {
+        assertEquals(16, MathMethods.square(4), 0.1);
+    }
 
+    @Test
+    public void tangentTest()
+    {
+        assertEquals(-3.380515005246586, MathMethods.tangent(5), 0.1);
+    }
 
+    @Test
+    public void inverseTangentTest()
+    {
+        assertEquals(1.550798992821746, MathMethods.iTan(50), 0.1);
+    }
 
+    @Test
+    public void inverseTest()
+    {
+        assertEquals(.1, MathMethods.inverse(10), 0.1);
 
+    }
+}
 
 

Memory.java

+
+/**
+ * Write a description of class Memory here.
+ *
+ * @author (your name)
+ * @version (a version number or a date)
+ */
+public class Memory
+{
+    private static double mem;
+    
+    public Memory()
+    {
+        // initialise instance variables
+        mem = 0;
+    }
+
+    public static double memRead() 
+    {
+        return mem;    
+    }
+    
+    public static double memUpdate(double n1) 
+    {
+        return n1;
+    }
+    
+    public static double memClear()
+    {
+        return mem = 0;
+    }
+    
+    public static void printAns(String printAnswer){
+        System.out.println(printAnswer);       
+    }
+}

MemoryTest.java

+
+
+import static org.junit.Assert.*;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * The test class MemoryTest.
+ *
+ * @author  (your name)
+ * @version (a version number or a date)
+ */
+public class MemoryTest
+{
+    /**
+     * Default constructor for test class MemoryTest
+     */
+    public MemoryTest()
+    {
+    }
+
+    /**
+     * Sets up the test fixture.
+     *
+     * Called before every test case method.
+     */
+    @Before
+    public void setUp()
+    {
+    }
+
+    /**
+     * Tears down the test fixture.
+     *
+     * Called after every test case method.
+     */
+    @After
+    public void tearDown()
+    {
+    }
+
+    @Test
+    public void memTest()
+    {
+        assertEquals(0, Memory.memRead(), 0.1);
+    }
+
+    @Test
+    public void memUpdateTest()
+    {
+        assertEquals(10, Memory.memUpdate(10), 0.1);
+    }
+
+
+
+    @Test
+    public void memClearTest()
+    {
+        assertEquals(0, Memory.memClear(), 0.1);
+    }
+}
+
+
+
+

package.bluej

 #BlueJ package file
+<<<<<<< HEAD
 dependency1.from=Calculator
 dependency1.to=MathMethods
 dependency1.type=UsesDependency
 package.frame.width=832
 package.numDependencies=3
 package.numTargets=3
+=======
+dependency1.from=MathMethodsTest
+dependency1.to=MathMethods
+dependency1.type=UsesDependency
+dependency2.from=MemoryTest
+dependency2.to=Memory
+dependency2.type=UsesDependency
+dependency3.from=Calculator
+dependency3.to=MathMethods
+dependency3.type=UsesDependency
+dependency4.from=Calculator
+dependency4.to=Memory
+dependency4.type=UsesDependency
+editor.fx.0.height=814
+editor.fx.0.width=1191
+editor.fx.0.x=201
+editor.fx.0.y=-974
+objectbench.height=80
+objectbench.width=595
+package.divider.horizontal=0.5993322203672788
+package.divider.vertical=0.8465608465608465
+package.editor.height=473
+package.editor.width=493
+package.editor.x=-188
+package.editor.y=-610
+package.frame.height=625
+package.frame.width=619
+package.numDependencies=4
+package.numTargets=5
+>>>>>>> 2a9a289e4239250cd6e2f776f8cc64f1130c5a52
 package.showExtends=true
 package.showUses=true
 project.charset=UTF-8
 readme.x=10
 readme.y=10
 target1.height=50
-target1.name=Calculator
+target1.name=MemoryTest
 target1.showInterface=false
+<<<<<<< HEAD
 target1.type=ClassTarget
 target1.width=140
 target1.x=80
 target3.width=110
 target3.x=240
 target3.y=340
+=======
+target1.type=UnitTestTargetJunit4
+target1.width=80
+target1.x=400
+target1.y=140
+target2.association=MemoryTest
+target2.height=50
+target2.name=Memory
+target2.showInterface=false
+target2.type=ClassTarget
+target2.width=80
+target2.x=370
+target2.y=170
+target3.height=50
+target3.name=Calculator
+target3.showInterface=false
+target3.type=ClassTarget
+target3.width=90
+target3.x=220
+target3.y=80
+target4.height=50
+target4.name=MathMethodsTest
+target4.showInterface=false
+target4.type=UnitTestTargetJunit4
+target4.width=110
+target4.x=90
+target4.y=250
+target5.association=MathMethodsTest
+target5.height=50
+target5.name=MathMethods
+target5.showInterface=false
+target5.type=ClassTarget
+target5.width=110
+target5.x=60
+target5.y=280
+>>>>>>> 2a9a289e4239250cd6e2f776f8cc64f1130c5a52