Feature A_5

bitwise.py

@@ -0,0 +1,44 @@
+def perform_and(a, b):
+    return int(a) & int(b)
+
+def perform_or(a, b):
+    return int(a) | int(b)
+
+def perform_xor(a, b):
+    return int(a) ^ int(b)
+
+def perform_not(a):
+    return ~int(a)
+
+def perform_left_shift(a, b):
+    shift_count = int(b)
+    if shift_count < 0:
+        raise ValueError("Negative shift count")
+    return int(a) << int(b)
+
+def perform_right_shift(a, b):
+    shift_count = int(b)
+    if shift_count < 0:
+        raise ValueError("Negative shift count")
+    return int(a) >> shift_count
+
+def perform_bit_masking(val, mask):
+    return int(val) & int(mask)
+
+def perform_bit_counting(a):
+    val = int(a)
+    if val < 0:
+        return bin(val & 0xFFFFFFFF).count('1')
+    return bin(val).count('1')
+
+def perform_bit_rotation_left(val, shift, bit_size=32):
+    v = int(val)
+    s = int(shift) % bit_size
+    mask = (1 << bit_size) - 1
+    return ((v << s) & mask) | ((v >> (bit_size - s)) & mask)
+
+def perform_bit_rotation_right(val, shift, bit_size=32):
+    v = int(val)
+    s = int(shift) % bit_size
+    mask = (1 << bit_size) - 1
+    return ((v >> s) & mask) | ((v << (bit_size - s)) & mask)

calculator.py

@@ -1,11 +1,71 @@
+import ast
+import bitwise
+
 class Calculator:
     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:
             raise ValueError("Division by zero")
         return a / b
+
+    def calculate(self, expression: str):
+        try:
+            node = ast.parse(expression, mode='eval').body
+            return self._evaluate_node(node)
+        except Exception as e:
+            return f"Error: {str(e)}"
+
+    def _evaluate_node(self, node):
+        if isinstance(node, ast.Constant):
+            return node.value
+        elif isinstance(node, ast.BinOp):
+            left = self._evaluate_node(node.left)
+            right = self._evaluate_node(node.right)
+            op_type = type(node.op)
+            if op_type == ast.Add:
+                return self.add(left, right)
+            elif op_type == ast.Sub:
+                return self.subtract(left, right)
+            elif op_type == ast.Mult:
+                return self.multiply(left, right)
+            elif op_type == ast.Div:
+                return self.divide(left, right)
+            elif op_type == ast.BitAnd:
+                return bitwise.perform_and(left, right)
+            elif op_type == ast.BitOr:
+                return bitwise.perform_or(left, right)
+            elif op_type == ast.BitXor:
+                return bitwise.perform_xor(left, right)
+            elif op_type == ast.LShift:
+                return bitwise.perform_left_shift(left, right)
+            elif op_type == ast.RShift:
+                return bitwise.perform_right_shift(left, right)
+        elif isinstance(node, ast.UnaryOp):
+            operand = self._evaluate_node(node.operand)
+            op_type = type(node.op)
+            if op_type == ast.Invert:
+                return bitwise.perform_not(operand)
+            elif op_type == ast.USub:
+                return -operand
+        elif isinstance(node, ast.Call):
+            func_name = node.func.id
+            args = [self._evaluate_node(arg) for arg in node.args]
+            if func_name == "mask":
+                return bitwise.perform_bit_masking(args[0], args[1])
+            elif func_name == "count_bits":
+                return bitwise.perform_bit_counting(args[0])
+            elif func_name == "rotate_left":
+                size = args[2] if len(args) > 2 else 32
+                return bitwise.perform_bit_rotation_left(args[0], args[1], size)
+            elif func_name == "rotate_right":
+                size = args[2] if len(args) > 2 else 32
+                return bitwise.perform_bit_rotation_right(args[0], args[1], size)
+        raise ValueError("Unsupported Operation")

main.py

@@ -0,0 +1,6 @@
+from calculator import Calculator
+
+calc = Calculator()
+expression = input("Enter expression : ")
+result = calc.calculate(expression)
+print(f"Result: {result}")

test_bitwise.py

@@ -0,0 +1,58 @@
+import unittest
+from calculator import Calculator
+
+class TestBitwise(unittest.TestCase):
+    def setUp(self):
+        self.calc = Calculator()
+
+    def test_bitwise_and(self):
+        self.assertEqual(self.calc.calculate("12 & 10"), 8)
+
+    def test_bitwise_or(self):
+        self.assertEqual(self.calc.calculate("12 | 10"), 14)
+
+    def test_bitwise_xor(self):
+        self.assertEqual(self.calc.calculate("12 ^ 10"), 6)
+
+    def test_bitwise_lshift(self):
+        self.assertEqual(self.calc.calculate("3 << 2"), 12)
+
+    def test_bitwise_rshift(self):
+        self.assertEqual(self.calc.calculate("3 >> 1"), 1)
+
+    def test_bitwise_rshift_2(self):
+        self.assertEqual(self.calc.calculate("3 >> 2"), 0)
+
+    def test_bitwise_not(self):
+        self.assertEqual(self.calc.calculate("~0"), -1)
+
+    def test_mixed_expression(self):
+        self.assertEqual(self.calc.calculate("2 + (1 << 3)"), 10)
+
+    def test_bitwise_not_2(self):
+        self.assertNotEqual(self.calc.calculate("~0"), 0)
+
+    def test_bit_masking(self):
+        self.assertEqual(self.calc.calculate("mask(15, 8)"), 8)
+
+    def test_bit_counting(self):
+        self.assertEqual(self.calc.calculate("count_bits(7)"), 3)
+        self.assertEqual(self.calc.calculate("count_bits(255)"), 8)
+
+    def test_bit_rotation_left(self):
+        self.assertEqual(self.calc.calculate("rotate_left(1, 2)"), 4)
+        self.assertEqual(self.calc.calculate("rotate_left(128, 1, 8)"), 1)
+
+    def test_bit_rotation_right(self):
+        self.assertEqual(self.calc.calculate("rotate_right(4, 2)"), 1)
+        self.assertEqual(self.calc.calculate("rotate_right(1, 1, 8)"), 128)
+
+    def test_mixed_expression_2(self):
+        self.assertEqual(self.calc.calculate("count_bits((2 + 2) << 1)"), 1)
+
+    def test_negative_shift_error(self):
+        result = self.calc.calculate("8 >> -1")
+        self.assertTrue("Error" in str(result))
+
+if __name__ == "__main__":
+    unittest.main()

test_calculator.py

@@ -18,7 +18,7 @@ def test_multiply(self):
     def test_divide(self):
         self.assertEqual(self.calc.divide(2, 4), 0.5)
 
-    def test_divide(self):
+    def test_divide2(self):
         self.assertEqual(self.calc.divide(4, -2), -2)
 
     def test_divide_fail(self): # this will fail