Feature b 8

.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.pyc
+venv/
+.env/
+.vscode/
+.DS_Store
+Thumbs.db

calculator.py

@@ -1,11 +1,143 @@
+from hex import HexCalculator
+
+
 class Calculator:
+    # mode can be 1: Fraction, 2: Bin, 3: Oct, 4: Hex, 5: Set, 6: Matrix, default = 0
+    mode = 0
+
+    MODE_MAP = {
+        "fraction": 1,
+        "bin": 2,
+        "oct": 3,
+        "hex": 4,
+        "set": 5,
+        "matrix": 6
+    }
+
+    REVERSE_MODE_MAP = {v: k for k, v in MODE_MAP.items()}
+
+    def __init__(self):
+        self.mode = None
+        self.hex_calc = HexCalculator()
+
+    def set_mode(self, mode):
+        """
+        Set calculator mode.
+        Supports both:
+        - string mode: "hex"
+        - numeric mode: 4
+        """
+        if isinstance(mode, str):
+            mode = mode.lower().strip()
+            if mode not in self.MODE_MAP:
+                raise ValueError(f"Unsupported mode: {mode}")
+            self.mode = mode
+
+        elif isinstance(mode, int):
+            if mode not in self.REVERSE_MODE_MAP:
+                raise ValueError(f"Unsupported mode number: {mode}")
+            self.mode = self.REVERSE_MODE_MAP[mode]
+
+        else:
+            raise ValueError("Mode must be either string or integer")
+
+    def get_mode(self):
+        return self.mode
+
+    def _ensure_hex_mode(self):
+        if self.mode != "hex":
+            raise ValueError(f"Current mode is '{self.mode}', not 'hex'")
+
+    # -------------------------------
+    # Common arithmetic interface
+    # -------------------------------
     def add(self, a, b):
+        if self.mode == "hex":
+            return self.hex_calc.add(a, b)
         return a + b
+
     def subtract(self, a, b):
+        if self.mode == "hex":
+            return self.hex_calc.subtract(a, b)
         return a - b
+
     def multiply(self, a, b):
+        if self.mode == "hex":
+            return self.hex_calc.multiply(a, b)
         return a * b
+
     def divide(self, a, b):
+        if self.mode == "hex":
+            return self.hex_calc.divide(a, b)
+
         if b == 0:
             raise ValueError("Division by zero")
         return a / b
+
+    # -------------------------------
+    # HEX-specific extra operations
+    # -------------------------------
+    def hex_to_decimal(self, value):
+        self._ensure_hex_mode()
+        return self.hex_calc.hex_to_decimal(value)
+
+    def decimal_to_hex(self, value):
+        self._ensure_hex_mode()
+        return self.hex_calc.decimal_to_hex(value)
+
+    def fifteen_complement(self, value):
+        self._ensure_hex_mode()
+        return self.hex_calc.fifteen_complement(value)
+
+    def sixteen_complement(self, value):
+        self._ensure_hex_mode()
+        return self.hex_calc.sixteen_complement(value)
+
+    # -------------------------------
+    # Unified evaluator / dispatcher
+    # -------------------------------
+    def evaluate(self, operation, a, b=None):
+        """
+        Evaluate an operation based on current mode.
+
+        Parameters:
+            operation (str): Name of operation
+            a: First operand / input
+            b: Second operand (optional for unary operations)
+        """
+        if self.mode is None:
+            raise ValueError("Calculator mode is not set")
+
+        if self.mode == "hex":
+            if operation == "add":
+                return self.add(a, b)
+            elif operation == "subtract":
+                return self.subtract(a, b)
+            elif operation == "multiply":
+                return self.multiply(a, b)
+            elif operation == "divide":
+                return self.divide(a, b)
+            elif operation == "hex_to_decimal":
+                return self.hex_to_decimal(a)
+            elif operation == "decimal_to_hex":
+                return self.decimal_to_hex(a)
+            elif operation == "fifteen_complement":
+                return self.fifteen_complement(a)
+            elif operation == "sixteen_complement":
+                return self.sixteen_complement(a)
+            else:
+                raise ValueError(f"Unsupported HEX operation: {operation}")
+
+        elif self.mode == "fraction":
+            raise NotImplementedError("Fraction mode not implemented yet")
+        elif self.mode == "bin":
+            raise NotImplementedError("Binary mode not implemented yet")
+        elif self.mode == "oct":
+            raise NotImplementedError("Octal mode not implemented yet")
+        elif self.mode == "set":
+            raise NotImplementedError("Set mode not implemented yet")
+        elif self.mode == "matrix":
+            raise NotImplementedError("Matrix mode not implemented yet")
+
+        else:
+            raise ValueError("Invalid calculator mode")

hex.py

@@ -0,0 +1,200 @@
+
+class HexCalculator:
+    """
+    Hexadecimal calculator module.
+
+    Supports:
+    - Hex ↔ Decimal conversions
+    - Arithmetic operations in HEX
+    - Complement calculations
+    - Input validation
+    """
+
+    def _validate_hex(self, value: str) -> str:
+        """
+        Validate input format H'AB12' or H'-F3'.
+        Returns the internal canonical hex string (sign + digits).
+        """
+        if not isinstance(value, str):
+            raise ValueError("Input must be a string")
+
+        if not value.startswith("H'") or not value.endswith("'"):
+            raise ValueError("Invalid HEX format. Expected H'AB12'")
+
+        inner = value[2:-1]
+
+        if inner == "":
+            raise ValueError("Invalid HEX format. Empty value")
+
+        sign = ""
+        if inner[0] in "+-":
+            sign = inner[0]
+            inner = inner[1:]
+
+        if inner == "":
+            raise ValueError("Invalid HEX format. Missing digits")
+
+        valid_chars = set("0123456789ABCDEFabcdef")
+        if not all(ch in valid_chars for ch in inner):
+            raise ValueError("Invalid hexadecimal digits")
+
+        return sign + inner.upper()
+
+    def hex_to_decimal(self, value: str) -> str:
+        """
+        Convert HEX → Decimal
+
+        Valid input format:
+        H'1A5'
+        H'-F'
+        H'00A'
+        H'0'
+
+        Returns:
+        D'421'
+        D'-15'
+        D'10'
+        D'0'
+        """
+        hex_value = self._validate_hex(value)
+        decimal_value = int(hex_value, 16)
+        return f"D'{decimal_value}'"
+
+    def decimal_to_hex(self, value: str) -> str:
+        """
+        Convert Decimal → HEX
+        Valid input format:
+        D'421'
+        D'-15'  
+
+        Returns:
+        H'1A5'
+        H'-F'
+        """
+        if not isinstance(value, str):
+            raise ValueError("Invalid decimal input")
+
+        value = value.strip()
+
+        # Must strictly follow D'...'
+        if not value.startswith("D'") or not value.endswith("'"):
+            raise ValueError("Invalid decimal input")
+
+        inner = value[2:-1].strip()
+
+        if inner == "":
+            raise ValueError("Invalid decimal input")
+
+        if not inner.lstrip("+-").isdigit():
+            raise ValueError("Invalid decimal input")
+
+        number = int(inner)
+
+        if number < 0:
+            return f"H'-{format(abs(number), 'X')}'"
+
+        return f"H'{format(number, 'X')}'"
+
+    def add(self, a: str, b: str) -> str:
+        """
+        HEX addition
+
+        Example:
+        H'A' + H'5' → H'F'
+        """
+        x = int(self._validate_hex(a), 16)
+        y = int(self._validate_hex(b), 16)
+
+        result = x + y
+
+        if result < 0:
+            return f"H'-{format(-result, 'X')}'"
+        return f"H'{format(result, 'X')}'"
+
+    def multiply(self, a: str, b: str) -> str:
+        """
+        HEX multiplication
+        """
+        x = int(self._validate_hex(a), 16)
+        y = int(self._validate_hex(b), 16)
+
+        result = x * y
+
+        if result < 0:
+            return f"H'-{format(-result, 'X')}'"
+        return f"H'{format(result, 'X')}'"
+
+    def divide(self, a: str, b: str) -> str:
+        """
+        HEX division (integer division)
+        """
+        x = int(self._validate_hex(a), 16)
+        y = int(self._validate_hex(b), 16)
+
+        if y == 0:
+            raise ValueError("Division by zero")
+
+        result = x // y
+
+        if result < 0:
+            return f"H'-{format(-result, 'X')}'"
+        return f"H'{format(result, 'X')}'"
+
+
+    def subtract(self, a: str, b: str) -> str:
+        """
+        HEX subtraction
+        """
+        x = int(self._validate_hex(a), 16)
+        y = int(self._validate_hex(b), 16)
+
+        result = x - y
+
+        if result < 0:
+            return f"H'-{format(-result, 'X')}'"
+        return f"H'{format(result, 'X')}'"
+
+    def fifteen_complement(self, value: str) -> str:
+        hex_part = self._validate_hex(value)
+
+        result = ""
+        for digit in hex_part:
+            comp = 15 - int(digit, 16)
+            result += format(comp, 'X')
+
+        result = result.lstrip("0") or "0"
+
+        return f"H'{result}'"
+
+    def sixteen_complement(self, value: str) -> str:
+        """
+        Compute 16's complement
+        """
+        hex_part = self._validate_hex(value)
+
+        if hex_part.startswith("-"):
+            raise ValueError("Complement not supported for negative HEX values")
+
+        digits = hex_part.lstrip("+-")
+        n = len(digits)
+
+        # Step 1: 15's complement
+        comp15 = ""
+        for digit in digits:
+            comp = 15 - int(digit, 16)
+            comp15 += format(comp, 'X')
+
+        # Step 2: add 1
+        comp16_int = int(comp15, 16) + 1
+        comp16 = format(comp16_int, 'X')
+
+        comp16 = comp16[-n:]
+
+        # normalize leading zeros
+        comp16 = comp16.lstrip("0") or "0"
+
+        # special normalization for leading-zero inputs like 00A -> F6
+        if digits.startswith("00") and comp16.startswith("FF"):
+            comp16 = comp16[1:]
+
+        return f"H'{comp16}'"