Thunderdome's Calculator

Basic.java

@@ -0,0 +1,52 @@
+
+
+/**
+ * Basic class to perform basic functions for our Graphing Calculator
+ * (+, -, *, /)
+ * Lauren Green
+ * 10/19/18
+ */
+public class Basic
+{
+    double input1 = 0;
+    double input2 = 0;
+    String operation = "";
+    double answer;
+    
+    public void Basic()
+    {
+        Console.println("Basic Calculator Options" 
+                         + "\n1: Addition"
+                         + "\n2: Subtraction"
+                         + "\n3: Multiplication"
+                         + "\n4: Division"
+                         + "\n5: Cancel - returns to Main Menu");        
+
+    }
+
+    //addition method
+    public double getSum(double x, double y) {
+        answer = x + y;
+        return answer;
+    }
+    
+    //subtraction method
+    public double getDiff(double x, double y) {
+        answer = x - y;
+        return answer;
+    }
+    
+    //multiplication method
+    public double getProduct(double x, double y) {
+        answer = x * y;
+        return answer;
+    }
+    
+    //division method
+    public double getQuotient(double x, double y) {
+        answer = x / y;
+        return answer;
+    }
+}
+
+        

BasicTest.java

@@ -0,0 +1,139 @@
+
+
+import static org.junit.Assert.*;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * The test class BasicTest.
+ *
+ * @author  (your name)
+ * @version (a version number or a date)
+ */
+public class BasicTest
+{
+    /**
+     * Default constructor for test class BasicTest
+     */
+    public BasicTest()
+    {
+    }
+
+    /**
+     * 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 testAdd()
+    {
+        Basic basic1 = new Basic();
+        assertEquals(14, basic1.getSum(4, 10), 0.1);
+    }
+
+    @Test
+    public void testAddDec()
+    {
+        Basic basic1 = new Basic();
+        assertEquals(13.27, basic1.getSum(13.2, 0.07), 0.1);
+    }
+
+    @Test
+    public void testAddNeg()
+    {
+        Basic basic1 = new Basic();
+        basic1.Basic();
+        assertEquals(6, basic1.getSum(-3, 9), 0.1);
+    }
+
+    @Test
+    public void testSub()
+    {
+        Basic basic1 = new Basic();
+        assertEquals(5, basic1.getDiff(10, 5), 0.1);
+    }
+
+    @Test
+    public void testSubDec()
+    {
+        Basic basic1 = new Basic();
+        assertEquals(4.65, basic1.getDiff(13.2, 8.55), 0.1);
+    }
+
+    @Test
+    public void testSubNeg()
+    {
+        Basic basic1 = new Basic();
+        assertEquals(18, basic1.getDiff(6, -12), 0.1);
+    }
+
+    @Test
+    public void testMul()
+    {
+        Basic basic1 = new Basic();
+        assertEquals(15, basic1.getProduct(3, 5), 0.1);
+    }
+
+    @Test
+    public void testMulDec()
+    {
+        Basic basic1 = new Basic();
+        assertEquals(6.8, basic1.getProduct(3.4, 2), 0.1);
+    }
+
+    @Test
+    public void testMulNeg()
+    {
+        Basic basic1 = new Basic();
+        assertEquals(10, basic1.getProduct(-2, -5), 0.1);
+    }
+
+    @Test
+    public void testDiv()
+    {
+        Basic basic1 = new Basic();
+        assertEquals(4, basic1.getQuotient(12, 3), 0.1);
+    }
+
+    @Test
+    public void testDivDec()
+    {
+        Basic basic1 = new Basic();
+        assertEquals(7.4, basic1.getQuotient(14.8, 2), 0.1);
+    }
+
+    @Test
+    public void testDivNeg()
+    {
+        Basic basic1 = new Basic();
+        assertEquals(-3, basic1.getQuotient(-12, 4), 0.1);
+    }
+}
+
+
+
+
+
+
+
+
+
+
+
+

MainMenu.java

@@ -0,0 +1,32 @@
+
+/**
+ * Scientific Calculator Lab
+ * 
+ * This class will create the instance of the "Main Menu"
+ * 
+ * This serves to display the options the user can take to use the calculator
+ * 
+ * 1: Basic Menu - 4 basic functions + - * /
+ * 2: Advanced Menu - Exponents & inverse
+ * 3: Scientific Menu - Base Conversions, Memory Functions, Trig Options
+ * 
+ * The point of this method is for the MAIN Application while loop.
+ * Whenever the user opens the calculator OR completes an action
+ * in the submenus, the calculator will return to this main menu.
+ */
+public class MainMenu
+{
+    /**
+     * Method to display the main menu
+     */
+    
+    public void mainMenuDisplay()
+    {
+        Console.println("\nCalculator Options:"
+                         + "\n1: Basic Calculator (+ - * /)"
+                         + "\n2: Advanced Calculator (Exponential Functions)"
+                         + "\n3: Scientific Functions (Base Conversion, Memory, Trigonometry)"
+                         + "\n4: Exit the calculator");
+        
+    }
+}

MemoryFunc.java

@@ -0,0 +1,75 @@
+
+/**
+
+ */
+public class MemoryFunc {
+    public Double memory;
+    public Boolean memoryChanged;
+    public static final Double DEFAULT_MEMORY_VALUE = new Double(0);
+
+    public MemoryFunc() {
+        this.memory = DEFAULT_MEMORY_VALUE;
+        this.memoryChanged = false;
+    }
+    
+    /**
+     * Menu
+     * Clear
+     * Print
+     * Update
+     */
+    
+    public void memoryMenu() {
+        
+        Console.println("Memory Menu"
+                         + "\n1: M+ - Update stored memory value"
+                         + "\n2: MC - Clear to default memory value"
+                         + "\n3: MCR - Display stored memory value"
+                         + "\n4: Cancel - Returns to Main Menu");
+                         
+        String memoryOpt = "";
+        
+        while (!memoryOpt.equals("4")) {
+            
+            memoryOpt = Console.getStringInput("Select option by typing the key. (ie. 1 for M+)");
+            
+            if (memoryOpt.equals("1")) {
+                
+                Double newMemory = Console.getDoubleInput("Enter the value to store");
+                this.memory = updateMemory(newMemory);
+                this.memoryChanged = true;
+                break;
+                
+            } else if (memoryOpt.equals("2")) {
+                
+                clearMemory();
+                Console.println("Memory cleared.");
+                this.memoryChanged = false;
+                break;
+                
+            } else if (memoryOpt.equals("3")) {
+                
+                Console.println("Stored Value: " + displayMemory());
+                break;
+                
+            } else {
+                
+                Console.println("Invalid Option");
+                
+            }
+        }
+    }
+    
+    public Double updateMemory(Double memoryInput) {
+        return this.memory = memoryInput;
+    }
+    
+    public Double clearMemory() {
+        return this.memory = DEFAULT_MEMORY_VALUE;
+    }
+    
+    public Double displayMemory() {
+        return this.memory;
+    }
+    
+}

RealAdvanced.java

@@ -0,0 +1,57 @@
+
+/**
+ * Method for the RealAdvanced class
+ *
+ * @Michelle DiMarino
+ * @10.21.18
+ */
+
+import java.util.*;
+
+public class RealAdvanced
+{
+
+    public void realAdvanced()
+    {
+        Console.println("Please Select one of the following Calculations: " +"\n"+
+            "1: x^2" + "\n"+
+            "2: x^y" + "\n"+
+            "3: 1/x" + "\n"+
+            "4: Switch Sign of x" + "\n"+
+            "5: Absolute Value of x" + "\n"+
+            "6: Square Root of x" + "\n"+
+            "7: Factorial x!"+"\n"+
+            "8: Return to Main Menu");
+
+    }
+    // method to find x^2
+    public double squared(double x){
+        return Math.pow(x,2);
+    }
+    // method to find x^y
+    public double exponent(double x, double y){
+        return Math.pow(x,y);
+    }
+    // method to find the inverse of x
+    public double inverse(double x){
+        return 1/x;
+    }
+    // method to switch sign of x
+    public double opposite(double x){
+        double opposite1 = -1 * x;
+        return opposite1;
+    }
+    public double absoluteValue(double x){
+        return Math.abs(x);
+    }
+public double sqrt(double x){
+    return Math.sqrt(x);
+}
+public double factorial(double x){
+    double answer = 1;
+    for (double i = x; i >0; i--){
+        answer = answer * i;
+    }
+    return answer;
+}
+}

RealAdvancedTest.java

@@ -0,0 +1,98 @@
+
+
+import static org.junit.Assert.*;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * The test class RealAdvancedTest.
+ *
+ * @author  (your name)
+ * @version (a version number or a date)
+ */
+public class RealAdvancedTest
+{
+    /**
+     * Default constructor for test class RealAdvancedTest
+     */
+    public RealAdvancedTest()
+    {
+    }
+
+    /**
+     * 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 squaredTest()
+    {
+        RealAdvanced realAdva1 = new RealAdvanced();
+        assertEquals(9.0, realAdva1.squared(3), 0.1);
+    }
+
+    @Test
+    public void exponentTest()
+    {
+        RealAdvanced realAdva1 = new RealAdvanced();
+        assertEquals(8.0, realAdva1.exponent(2, 3), 0.1);
+    }
+
+    @Test
+    public void oppositeTest()
+    {
+        RealAdvanced realAdva1 = new RealAdvanced();
+        assertEquals(2.0, realAdva1.opposite(-2), 0.1);
+    }
+
+    @Test
+    public void inverseTest()
+    {
+        RealAdvanced realAdva1 = new RealAdvanced();
+        assertEquals(0.5, realAdva1.inverse(2), 0.1);
+    }
+
+    @Test
+    public void absoluteTest()
+    {
+        RealAdvanced realAdva1 = new RealAdvanced();
+        assertEquals(4.0, realAdva1.absoluteValue(-4), 0.1);
+    }
+
+    @Test
+    public void squareRootTest()
+    {
+        RealAdvanced realAdva1 = new RealAdvanced();
+        assertEquals(5.0, realAdva1.sqrt(25), 0.1);
+    }
+
+    @Test
+    public void factorialTest()
+    {
+        RealAdvanced realAdva1 = new RealAdvanced();
+        assertEquals(120.0, realAdva1.factorial(5), 0.1);
+    }
+}
+
+
+
+
+
+
+

SciCalc.java

@@ -0,0 +1,19 @@
+
+/**
+* 4.2 Scientific Calculator Group Project
+* Trinh Tong, Lauren Green, Michelle Dimarino
+* Advanced Calculator Menu
+*/
+public class SciCalc 
+{
+
+
+    public void toSciMenu() {
+        Console.println("Scientific Calculator Functions:"
+                         + "\n1: Base Conversion - Converts input to selected base"
+                         + "\n2: Memory - Memory functions"
+                         + "\n3: Trigonometry "
+                         + "\n4: Return to Main Menu");        
+        
+    }
+}

SwitchDisplay.java

@@ -0,0 +1,71 @@
+
+/**
+ * Write a description of class SwitchDisplay here.
+ *
+ * Scientific Calculator Lab
+ * 
+ * Brings up the switch display menu
+ * Binary
+ * Octal
+ * Decimal
+ * Hexadecimal
+ * 
+ * Changes the mode for EVERYTHING
+ * 
+ * Find a way to store the input and the input as a diff base
+ * then whenever the base is changed, display the base.
+ * pass the input into the methods to return the string.
+ * EVERY TIME AN INPUT IS PLACED, IT WILL BE DISPLAYED AS AN OCTAL
+ * boolean baseChange == true; 
+ *      display the changed display
+ */
+public class SwitchDisplay
+{
+    // instance variables - replace the example below with your own
+
+    /**
+     * Switch Display Mode method 
+     * -> binary, octal, decimal, hexadecimal
+     * switchDisplayMode() rotates through the options
+     * switchDisplayMode(String mode) sets the display to the mode given
+     */
+    
+    public void switchDisplay()
+    {
+            Console.println("Display Options" 
+                             + "\n1: Binary"
+                             + "\n2: Octal"
+                             + "\n3: Decimal"
+                             + "\n4: Hexadecimal"
+                             + "\n5: Cancel - returns to Main Menu");
+                         
+    }
+
+    /**
+     * Converts the user input into corresponding base types
+     */
+    
+    public String toBinary(double userInput) {
+        
+        return Integer.toBinaryString((int)userInput);
+        
+    }
+    
+    public String toOctal(double userInput) {
+        
+        return Integer.toOctalString((int)userInput);
+        
+    }
+    
+    public String toDecimal(int userInput) {
+        
+        return Integer.toString(userInput);
+        
+    }
+    
+    public String toHexa(int userInput) {
+    
+        return Integer.toHexString((int)userInput);
+    
+    }
+}

SwitchDisplayTest.java

@@ -0,0 +1,74 @@
+
+
+import static org.junit.Assert.*;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * The test class SwitchDisplayTest.
+ *
+ * @author  (your name)
+ * @version (a version number or a date)
+ */
+public class SwitchDisplayTest
+{
+    /**
+     * Default constructor for test class SwitchDisplayTest
+     */
+    public SwitchDisplayTest()
+    {
+    }
+
+    /**
+     * 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 toBinary()
+    {
+        SwitchDisplay switchDi1 = new SwitchDisplay();
+        assertEquals("101101", switchDi1.toBinary(45));
+    }
+
+    @Test
+    public void toOctal()
+    {
+        SwitchDisplay switchDi1 = new SwitchDisplay();
+        assertEquals("55", switchDi1.toOctal(45));
+    }
+
+    @Test
+    public void toHexa()
+    {
+        SwitchDisplay switchDi1 = new SwitchDisplay();
+        assertEquals("2d", switchDi1.toHexa(45));
+    }
+
+    @Test
+    public void toDecimal()
+    {
+        SwitchDisplay switchDi1 = new SwitchDisplay();
+        assertEquals("45", switchDi1.toDecimal(45));
+    }
+}
+
+
+
+

Trig.java

@@ -0,0 +1,82 @@
+
+/**
+ * Trig class to perform trig function for our Graphing Calculator
+ * (sin, cos, tan, inverses, degree to radian)
+ * Lauren Green
+ * 10/19/18
+ */
+public class Trig
+{
+    double input = 0.0;
+    double answer;
+    String operation = "";
+
+    public void trigFunctions()
+    {
+        Console.println("Trigonometry Calculator Options" 
+            + "\n1: sin"
+            + "\n2: cosin"
+            + "\n3: tan"
+            + "\n4: arcsin"
+            + "\n5: arccosin"
+            + "\n6: arctan"
+            + "\n7: log"
+            + "\n8: Cancel - returns to Main Menu");   
+
+        
+    }
+
+    //Sin method
+    public double calcSin(double x) {
+        answer = Math.sin(x);
+        return answer;
+    }
+
+    //Cos method
+    public double calcCos(double x) {
+        answer = Math.cos(x);
+        return answer;
+    }
+
+    //Tan method
+    public double calcTan(double x) {
+        answer = Math.tan(x);
+        return answer;
+    }
+
+    //Arcsin method
+    public double calcArcsin(double x) {
+        answer = Math.asin(x);
+        return answer;
+    }
+
+    //Arccos method
+    public double calcArccos(double x) {
+        answer = Math.acos(x);
+        return answer;
+    }
+
+    //Arctan method
+    public double calcArctan(double x) {
+        answer = Math.atan(x);
+        return answer;
+    }
+
+    //Log Method
+    public double calcLog(double x) {
+        answer = Math.log10(x);
+        return answer;
+    }
+    
+    //Converting from Radians to Degrees
+    public double toDegrees(double answer) 
+    {
+        double conversion = Math.toDegrees(answer);
+        answer = conversion;
+        return answer;
+
+    }
+    
+    
+}
+

TrigTest.java

@@ -0,0 +1,106 @@
+
+
+import static org.junit.Assert.*;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * The test class TrigTest.
+ *
+ * @author  (your name)
+ * @version (a version number or a date)
+ */
+public class TrigTest
+{
+    /**
+     * Default constructor for test class TrigTest
+     */
+    public TrigTest()
+    {
+    }
+
+    /**
+     * 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 testSIN()
+    {
+        Trig trig1 = new Trig();
+        assertEquals(-0.54402111088, trig1.calcSin(10), 0.1);
+    }
+
+    @Test
+    public void testCOS()
+    {
+        Trig trig1 = new Trig();
+        assertEquals(-0.83907152907, trig1.calcCos(10), 0.1);
+    }
+
+    @Test
+    public void testTAN()
+    {
+        Trig trig1 = new Trig();
+        assertEquals(0.64836082745, trig1.calcTan(10), 0.1);
+    }
+
+    @Test
+    public void testRadtoDeg()
+    {
+        Trig trig1 = new Trig();
+        assertEquals(37.14833901458697, trig1.toDegrees(0.64836082745), 0.1);
+    }
+
+    @Test
+    public void testArcSin()
+    {
+        Trig trig2 = new Trig();
+        assertEquals(0.523598776, trig2.calcArcsin(0.5), 0.1);
+    }
+
+    @Test
+    public void testArcTan()
+    {
+        Trig trig1 = new Trig();
+        assertEquals(0.463647609, trig1.calcArctan(0.5), 0.1);
+    }
+
+    @Test
+    public void testArcCos()
+    {
+        Trig trig1 = new Trig();
+        assertEquals(1.04719755, trig1.calcArccos(0.5), 0.1);
+    }
+
+    @Test
+    public void testLog()
+    {
+        Trig trig1 = new Trig();
+        assertEquals(1, trig1.calcLog(10), 0.1);
+    }
+}
+
+
+
+
+
+
+
+

package.bluej

@@ -56,17 +56,17 @@ dependency8.type=UsesDependency
 dependency9.from=MainApplication
 dependency9.to=Console
 dependency9.type=UsesDependency
-editor.fx.0.height=673
-editor.fx.0.width=1081
-editor.fx.0.x=296
-editor.fx.0.y=175
+editor.fx.0.height=0
+editor.fx.0.width=0
+editor.fx.0.x=0
+editor.fx.0.y=0
 objectbench.height=214
 objectbench.width=595
 package.divider.horizontal=0.6
 package.divider.vertical=0.6847360912981455
 package.editor.height=473
 package.editor.width=493
-package.editor.x=39
+package.editor.x=38
 package.editor.y=27
 package.frame.height=759
 package.frame.width=619
@@ -138,19 +138,19 @@ target4.width=140
 target4.x=100
 target4.y=230
 target5.height=50
-target5.name=MainMenu
+target5.name=SwitchDisplayTest
 target5.showInterface=false
-target5.type=ClassTarget
-target5.width=90
-target5.x=70
-target5.y=10
+target5.type=UnitTestTargetJunit4
+target5.width=110
+target5.x=110
+target5.y=320
 target6.height=50
-target6.name=SwitchDisplayTest
+target6.name=MainMenu
 target6.showInterface=false
-target6.type=UnitTestTargetJunit4
-target6.width=110
-target6.x=110
-target6.y=320
+target6.type=ClassTarget
+target6.width=90
+target6.x=70
+target6.y=10
 target7.height=50
 target7.name=SciCalc
 target7.showInterface=false