I.B.M Final Calculator project - ljd sr

README.md

@@ -66,9 +66,25 @@
   - Ln (natural logarithm)
   - e<sup>x</sup> (inverse natural logarithm)
 
+### Custom Features
+- Tip Calculator
+  allows users to calculate the total cost of a bill including gratuity. 
 
+- Temperature Converter 
+  allows users to convert temperatures between Celsius and Fahrenheit.
 
-### Custom Features
+These custom features were selected bec they demonstrate the ability to extend the calculator beyond standard mathematical operations while applying real-world problem-solving.  The Tip Calculator provides a practical financial calculation, while the Temperature Converter demonstrates the implementation of mathematical formulas and conditional logic.
+
+### User-Friendly Menu System
+-The app provides an interactive menu that displays all available calculator operations.  Users can simply enter the name of the desired operation rather than remembering commands.  The menu also includes a HELP option to redisplay all available commands at any time, making the calculator easier to navigate and use. 
+
+### Error Handling
+-The calculator validates user input and displays meaningful error messages for invalid operations, including: 
+  - Invalid numeric input
+  - Division by zero
+  - Invalid exponent operations
+  - Invalid mathematical operations
+-The calculator prevents additional operations while an error is displayed until the user clears the error, ensuring consistent and predicatable behavior.
 
 In addition to the Core and Scientific features, you are required to create at least two of your own features for the calculator. They can be any two features that are not already covered and that you can implement as you see fit. These features must be properly tested.
 
@@ -91,3 +107,4 @@ The following functions should take the displayed value (x) and updated it accor
 ## Submission
 
 Completed projects should be submitted by submitting a pull request against the [original repository](https://git.zipcode.rocks/Cohort4.2/ZCW-MacroLabs-OOP-ScientificCalculator). All work should be done in your own repository.
+

calculator.py

@@ -1,12 +1,310 @@
 class Calculator:
 
+    # Error Messages
+    INVALID_INPUT_ERROR = "Invalid input"
+    DIVIDE_BY_ZERO_ERROR = "Cannot divide by zero"
+    OVERFLOW_ERROR = "Number too large"
+    INVALID_EXPONENT_ERROR = "Invalid exponent"
+    INVALID_OPERATION_ERROR = "Invalid operation"
+ ##   ERROR = "Err"-------
+
+#status set here
     def __init__(self):
-        pass
+        self.display: int | float = 0
+        self.error: str | None = None
+        self.memory: int | float = 0
+        self.trig_mode: str = "Radians"
+
+#----------------
+#Display methods
+#----------------
+    def getDisplay(self):
+        """
+        Return the error message when an error exists.
+        Otherwise, return the current numeric display.
+        """
+        if self.hasError():
+          return self.error
+
+        return self.display
+
+    def hasError(self):
+        """
+        Return True when an error message has been stored.
+        """
+        return self.error is not None
+
+    def clear(self):
+        """
+        Reset both the display and the error status.
+        """
+        self.display = 0
+        self.error = None
+        return self.display
+
+    def setDisplay(self, value):
+        """
+        Set the calculator display to a valid number.
+        The calculator must be cleared before continuing 
+        after an error.
+        """
+        if self.hasError():
+            return self.error
+
+        if not self.isValidNumber(value):
+            self.error = self.INVALID_INPUT_ERROR
+            return self.error
+
+        self.display = value
+        return self.display
+
+    def isValidNumber(self, value):
+        """
+        Boolean values are excluded bc Python treats T / F as int
+        """
+
+        return(
+            isinstance(value, (int, float))
+            and not isinstance(value, bool)
+        )
+#---------------
+#Memory methods
+#---------------
+    def memory_add(self):   #M+
+        """
+        Add the current display value to memory.
+        Update both memory and the display.
+        """
+        if self.hasError():
+            return self.error
+
+        # if not self.isValidNumber(self.display):
+        #     self.error = self.INVALID_INPUT_ERROR
+        #     return self.error
+
+        self.memory += self.display
+        self.display = self.memory
+        return self.display
+
+    def memory_clear(self):    #MC
+        """
+        Reset memory to zero.
+        Leave the current display unchanged.
+        """
 
+        if self.hasError():
+            return self.error
+
+        self.memory = 0
+        return self.display
+
+    def memory_recall(self):     # MRC
+        """
+        Copy the stored memory value to the display.
+        """
+        if self.hasError():
+            return self.error
+
+        self.display = self.memory
+
+        return self.display
+
+    def memory_store(self):
+        """
+        Store the current display value in memory.
+        Leave the display unchanged.
+        """
+        if self.hasError():
+            return self.error
+
+        if not self.isValidNumber(self.display):
+            self.error = self.INVALID_INPUT_ERROR
+            return self.error
+
+        self.memory = self.display
+        return self.display
+
+#---------------
+#Simple math functions
+#---------------
     def add(self, x, y):
-        return x + y
+        if self.hasError():
+            return self.error
+
+        if not self.isValidNumber(x) or not self.isValidNumber(y):
+            self.error = self.INVALID_INPUT_ERROR
+            return self.error
+        try:
+            self.display = x + y
+        except OverflowError:
+            self.error = self.OVERFLOW_ERROR
+
+        return self.getDisplay()
+
+    def subtract(self, x, y):
+        if self.hasError():
+            return self.error
+
+        if not self.isValidNumber(x) or not self.isValidNumber(y):
+            self.error = self.INVALID_INPUT_ERROR
+            return self.error
+
+        try:
+            self.display = x - y
+        except OverflowError:
+            self.error = self.OVERFLOW_ERROR
+
+        return self.getDisplay()
+
+    def multiply(self, x, y):
+        if self.hasError():
+            return self.error
+
+        if not self.isValidNumber(x) or not self.isValidNumber(y):
+            self.error = self.INVALID_INPUT_ERROR
+            return self.error
+
+        try:
+            self.display = x * y
+        except OverflowError:
+            self.error = self.OVERFLOW_ERROR
+
+        return self.getDisplay()
+
+    def divide(self, x, y):
+        if self.hasError():
+            return self.error
+
+        if not self.isValidNumber(x) or not self.isValidNumber(y):
+            self.error = self.INVALID_INPUT_ERROR
+            return self.error
+
+        if y == 0:
+            self.error = self.DIVIDE_BY_ZERO_ERROR
+            return self.error
+
+        try:
+            self.display = x / y
+        except OverflowError:
+            self.error = self.OVERFLOW_ERROR
+
+        return self.getDisplay()
+
+    def inverse(self):
+        if self.hasError():
+            return self.error
+
+        if not self.isValidNumber(self.display):
+            self.error = self.INVALID_INPUT_ERROR
+            return self.error
+
+        if self.display == 0:
+            self.error = self.DIVIDE_BY_ZERO_ERROR
+            return self.error
+
+        try:
+        # ensure numeric division even if display is a numeric string; will raise on invalid types
+            self.display = 1 / float(self.display)
+        except OverflowError:
+            self.error = self.OVERFLOW_ERROR
+
+        return self.getDisplay()
+
+    def exponentiate(self, exponent):
+        if self.hasError():
+            return self.error
+
+        if not self.isValidNumber(self.display):
+            self.error = self.INVALID_INPUT_ERROR
+            return self.error
+
+        if not self.isValidNumber(exponent):
+            self.error = self.INVALID_INPUT_ERROR
+            return self.error
+
+        try:
+            result = self.display ** exponent
+
+            if isinstance(result, complex):
+                self.error = self.INVALID_EXPONENT_ERROR
+            else:
+                self.display = result
+
+        except ZeroDivisionError:
+            self.error = self.DIVIDE_BY_ZERO_ERROR
+        except OverflowError:
+            self.error = self.OVERFLOW_ERROR
+        except (TypeError, ValueError):
+            self.error = self.INVALID_EXPONENT_ERROR
+
+        return self.getDisplay()
+
+    def switch_sign(self):
+        if self.hasError():
+            return self.error
+
+        if not self.isValidNumber(self.display):
+            self.error = self.INVALID_INPUT_ERROR
+            return self.error 
+
+        self.display = -self.display
+        return self.display
+
+    # added Sloanes code 7/12/26 8:07p
+    def square(self, x):
+        if self.hasError():
+            return self.display
+
+        if not self.isValidNumber(x):
+            self.error = self.INVALID_INPUT_ERROR
+            return self.error
+
+        try:
+            self.display = x ** 2
+        except OverflowError:
+            self.error = self.OVERFLOW_ERROR
+        return self.getDisplay()
+
+    def squareroot(self, x):
+        if self.hasError():
+            return self.error
+
+        if not self.isValidNumber(x):
+            self.error = self.INVALID_INPUT_ERROR
+            return self.error
+
+        if x < 0:
+            self.error = "Cannot calculate the square root of a negative number"
+            return self.error
+
+        try:
+            self.display = x ** 0.5
+        except OverflowError:
+            self.error = self.OVERFLOW_ERROR
+        return self.getDisplay()
 
-    def sub(self, x, y):
-        return 0
+
+#---------------
+# Utility functions
+#---------------
+    def absolute_value(self):
+        if self.hasError():
+            return self.error
+
+        if not self.isValidNumber(self.display):
+            self.error = self.INVALID_INPUT_ERROR
+            return self.error
+
+        self.display = abs(self.display)
+        return self.display
+
+    def percentage(self):
+        if self.hasError():
+            return self.error                
+
+        if not self.isValidNumber(self.display):
+            self.error = self.INVALID_INPUT_ERROR
+            return self.error
 
-# add lots more methods to this calculator class.
+        self.display = self.display / 100
+        return self.display