Full Calculator first merge

calctests.py

@@ -19,7 +19,68 @@ def test_add3(self):
     def test_sub(self):
         c = Calculator()
         self.assertEqual(c.sub(9, 3), 6)
-
+    def test_sub2(self):
+        c = Calculator()
+        self.assertEqual(c.sub(12, -10), 22)
+    def test_sub3(self):
+        c = Calculator()
+        self.assertEqual(c.sub(5, 8), -3)
+    def test_multiply(self):
+        c = Calculator()
+        self.assertEqual(c.multiply(3, 4), 12)
+    def test_multiply2(self):
+        c = Calculator()
+        self.assertEqual(c.multiply(5, -2), -10)
+    def test_multiply3(self):
+        c = Calculator()
+        self.assertEqual(c.multiply(7, 6), 42)
+    def test_divide(self):
+        c = Calculator()
+        self.assertEqual(c.divide(10, 2), 5)
+    def test_divide2(self):
+        c = Calculator()
+        self.assertEqual(c.divide(9, -3), -3)
+    def test_divide3(self):
+        c = Calculator()
+        self.assertEqual(c.divide(7, 7), 1)
+    def test_square(self):
+        c = Calculator()
+        self.assertEqual(c.square(5), 25)
+    def test_square2(self):
+        c = Calculator()
+        self.assertEqual(c.square(9), 81)
+    def test_square3(self):
+        c = Calculator()
+        self.assertEqual(c.square(0), 0)
+    def test_square_root(self):
+        c = Calculator()
+        self.assertEqual(c.square_root(25), 5)
+        self.assertEqual(c.square_root(0), 0)
+    def test_variable_exponentiation(self):
+        c = Calculator()
+        self.assertEqual(c.variable_exponentiation(2, 3), 8)
+        self.assertEqual(c.variable_exponentiation(5, 0), 1)
+    def test_inverse(self):
+        c = Calculator()
+        self.assertEqual(c.inverse(2), 0.5)
+        self.assertEqual(c.inverse(4), 0.25)
+    def test_invert_sign(self):
+        c = Calculator()
+        self.assertEqual(c.invert_sign(5), -5)
+        self.assertEqual(c.invert_sign(-3), 3)
+    def test_degrees_to_radians(self):
+        c = Calculator()
+        self.assertAlmostEqual(c.degrees_to_radians(180), 3.141592653589793)
+        self.assertAlmostEqual(c.degrees_to_radians(90), 1.5707963267948966)
+    def test_radians_to_degrees(self):
+        c = Calculator()
+        self.assertAlmostEqual(c.radians_to_degrees(3.141592653589793), 180)
+        self.assertAlmostEqual(c.radians_to_degrees(1.5707963267948966), 90)
+    def test_percent(self):
+        c = Calculator()
+        self.assertEqual(c.percent(50), 0.5)
+        self.assertEqual(c.percent(25), 0.25)
+        self.assertEqual(c.percent(100), 1)
 
 if __name__ == '__main__':
     unittest.main()

calculator.py

@@ -1,12 +1,60 @@
+
 class Calculator:
 
     def __init__(self):
-        pass
+        # single-entry memory and last result tracking
+        self.memory = None
+        self.last_result = None
 
+    def _store_last(self, result):
+        self.last_result = result
+        return result
+
     def add(self, x, y):
-        return x + y
+        return self._store_last(x + y)
 
     def sub(self, x, y):
-        return 0
+        return self._store_last(x - y)
+
+    def multiply(self, x, y):
+        return self._store_last(x * y)
+
+    def divide(self, x, y):
+        if y == 0:
+            raise ValueError("Cannot divide by zero")
+        return self._store_last(x / y)
+
+    def square(self, x):
+        return self._store_last(x * x)
+
+    def square_root(self, x):
+        return self._store_last(x ** 0.5)
+
+    def variable_exponentiation(self, x, y):
+        return self._store_last(x ** y)
+
+    def inverse(self, x):
+        return self._store_last(1 / x)
+
+    def invert_sign(self, x):
+        return self._store_last(-x)
+
+    def degrees_to_radians(self, x):
+        return self._store_last(x * (3.141592653589793 / 180))
+
+    def radians_to_degrees(self, x):
+        return self._store_last(x * (180 / 3.141592653589793))
+
+    def percent(self, x):
+        return self._store_last(x / 100)
+
+    def memory_test(self):
+        self.memory = 0
+        self.memory += 5
+        print(self.memory)  # should print 5
+        self.memory *= 2
+        print(self.memory)  # should print 10
 
-# add lots more methods to this calculator class.
+    def memory_clear(self):
+        self.memory = 0
+        print(self.memory)  # should print 0

core_calc.py

@@ -0,0 +1,17 @@
+class CoreCalculator:
+    def add(self, a, b):
+        return a + b
+
+    def subtract(self, a, b):
+        return a - b
+
+    def multiply(self, a, b):
+        return a * b
+
+    def divide(self, a, b):
+        if b == 0:
+            return "Error: cannot divide by zero"
+        return a / b
+
+    def power(self, a, b):
+        return a ** b

helpers.py

@@ -0,0 +1,47 @@
+def getOneNumber():
+    return float(input("Enter a number: "))
+
+
+def getTwoNumbers():
+    a = float(input("Enter first number: "))
+    b = float(input("Enter second number: "))
+    return a, b
+
+
+def displayResult(calc, result):
+    print("Result:", calc.formatResult(result))
+
+
+def printTitle():
+    print("\n========================================")
+    print("        SCIENTIFIC CALCULATOR")
+    print("========================================")
+    print(" Core + Scientific + Memory System")
+    print(" Display Modes | Angle Modes | Help Menu")
+    print("========================================\n")
+
+    print("Welcome! This calculator supports core and scientific functions.")
+    print("Display modes: binary, octal, decimal, hexadecimal")
+    print("Angle modes: degree, radian")
+    print("Type 'help' for full command list.\n")
+
+def printMenu(calc):
+    print(f"\nDisplay Mode: {calc.display_mode}")
+    print(f"Angle Mode: {calc.angle_mode}")
+    print(f"Memory: {calc.formatResult(calc.memoryRecall())}")
+    print("Commands:")
+    print("add sub mul div pow")
+    print("sqrt sin cos tan log ln fact percent")
+    print("mode setmode angle setangle")
+    print("ms mr mc m+ m-")
+    print("help q")
+
+
+def printHelp():
+    print("\n===== HELP =====")
+    print("Core: add, sub, mul, div, pow")
+    print("Scientific: sqrt, sin, cos, tan, log, ln, fact, percent")
+    print("Display: mode, setmode")
+    print("Angle: angle, setangle")
+    print("Memory: ms, mr, mc, m+, m-")
+    print("Other: help, q\n")

main-app.py

@@ -1,3 +1,4 @@
+
 from calculator import Calculator
 
 
@@ -19,9 +20,41 @@ def performCalcLoop(calc):
         elif choice == 'add':
             a, b = getTwoNumbers()
             displayResult(calc.add(a, b))
+        elif choice == 'subtract':
+            a, b = getTwoNumbers()
+            displayResult(calc.subtract(a, b))
+        elif choice == 'multiply':
+            a, b = getTwoNumbers()
+            displayResult(calc.multiply(a, b))
+        elif choice == 'square':
+            a, b = getTwoNumbers()
+            displayResult(calc.square(a, b))
+        elif choice == 'inverse':
+            a, b = getTwoNumbers()
+            displayResult(calc.inverse(a, b))
+        elif choice == 'invert_sign':
+            a, b = getTwoNumbers()
+            displayResult(calc.invert_sign(a, b))
+        elif choice == 'degrees_to_radians':
+            a, b = getTwoNumbers()
+            displayResult(calc.degrees_to_radians(a, b))
+        elif choice == 'radians_to_degrees':
+            a, b = getTwoNumbers()
+            displayResult(calc.radians_to_degrees(a, b))
+        elif choice == 'percent':
+            a, b = getTwoNumbers()
+            displayResult(calc.percent(a, b))
+        elif choice == 'memory_test':
+            calc.memory_test()
+        elif choice == 'memory_clear':
+            calc.memory_clear()
         else:
             print("That is not a valid input.")
 
+
+def memoryClear(calc):
+    calc.memory = 0
+    print(calc.memory)  # should print 0
 
 # main start
 def main():

main.py

@@ -0,0 +1,66 @@
+from core_calc import CoreCalculator
+from scientific_calc import ScientificCalculator
+from helpers import *
+
+
+def runCalculator():
+    core = CoreCalculator()
+    sci = ScientificCalculator()
+
+    printTitle()
+
+    while True:
+        printMenu(sci)
+        op = input("Operation: ").lower()
+
+        if op == "help":
+            printHelp()
+
+        elif op == "q":
+            print("Thank you for using Niciah's and Shocka's Scientific Calculator, Goodbye!")
+            break
+
+        elif op == "mode":
+            sci.switchDisplayMode()
+
+        elif op == "setmode":
+            sci.switchDisplayMode(input("Enter mode: "))
+
+        elif op == "angle":
+            sci.switchAngleMode()
+
+        elif op == "setangle":
+            sci.switchAngleMode(input("Enter angle mode: "))
+
+        elif op == "ms":
+            sci.memoryStore(sci.last_result)
+
+        elif op == "mr":
+            print("Memory:", sci.formatResult(sci.memoryRecall()))
+
+        elif op == "mc":
+            sci.memoryClear()
+
+        elif op == "m+":
+            sci.memoryAdd(sci.last_result)
+
+        elif op == "m-":
+            sci.memorySubtract(sci.last_result)
+
+        elif op in ["add", "sub", "mul", "div", "pow"]:
+            a, b = getTwoNumbers()
+            result = getattr(core, {"add":"add","sub":"subtract","mul":"multiply","div":"divide","pow":"power"}[op])(a,b)
+            sci.setLastResult(result)
+            displayResult(sci, result)
+
+        elif op in ["sqrt","sin","cos","tan","log","ln","fact","percent"]:
+            x = getOneNumber()
+            result = getattr(sci, {"fact":"factorial"}.get(op, op))(x)
+            sci.setLastResult(result)
+            displayResult(sci, result)
+
+        else:
+            print("Invalid operation")
+
+
+runCalculator()