math-engine 0.4.0__tar.gz → 0.5.0__tar.gz

{math_engine-0.4.0 → math_engine-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: math-engine
-Version: 0.4.0
+Version: 0.5.0
 Summary: A fast and secure mathematical expression evaluator.
 Author-email: Jan Teske <jan.teske.06@gmail.com>
 Project-URL: Homepage, https://github.com/JanTeske06/math_engine
@@ -14,7 +14,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 
 
-# Math Engine 0.4.0
+# Math Engine 0.5.0
 
 [![PyPI Version](https://img.shields.io/pypi/v/math-engine.svg)](https://pypi.org/project/math-engine/)
 [![License: MIT](https://img.shields.io/pypi/l/math-engine.svg)](https://opensource.org/licenses/MIT)
@@ -34,7 +34,7 @@ It provides a complete pipeline:
 * Scientific functions
 * Strict error codes for reliable debugging and automated testing
 
-**Version 0.4.0** introduces a powerful **Command Line Interface (CLI)**
+
 
 This library is ideal for:
 
@@ -263,7 +263,7 @@ Non-decimal parsing respects the setting `allow_non_decimal`. If it is set to `F
 
 -----
 
-# Bitwise Operations & Developer Mode (v0.4.0)
+# Bitwise Operations & Developer Mode (v0.5.0)
 
 Math Engine can act as a **programmer's calculator**. It supports standard operator precedence and bitwise logic.
 
@@ -326,9 +326,38 @@ math_engine.load_preset(settings)
 math_engine.evaluate("FF + 3")
 # Decimal('258')
 ```
-
 Input validation ensures safety and prevents mixing incompatible formats in strict modes.
 
+---
+## Bitwise & Low-Level Operations
+
+Math Engine now includes a rich collection of low-level bit manipulation functions commonly used in systems programming, embedded development, cryptography, and hardware-oriented tools.
+
+**Bitwise functions:**
+- `bitand(x, y)` — bitwise AND  
+- `bitor(x, y)` — bitwise OR  
+- `bitxor(x, y)` — bitwise XOR  
+- `bitnot(x)` — bitwise NOT  
+
+**Bit manipulation utilities:**
+- `setbit(x, n)` — sets bit *n*  
+- `clrbit(x, n)` — clears bit *n*  
+- `togbit(x, n)` — toggles bit *n*  
+- `testbit(x, n)` — returns 1 if bit *n* is set, else 0  
+
+**Shift operations:**
+- `shl(x, n)` — logical left shift  
+- `shr(x, n)` — logical right shift  
+
+All bitwise functions:
+- respect `word_size` and `signed_mode`  
+- support overflow/wrap-around behavior  
+- fully support binary, hex, decimal, and octal inputs  
+- participate in the AST just like standard operators  
+- support underscores in non-decimal literals (`0b1111_0000`)  
+
+This makes Math Engine behave like a full-featured programmer’s calculator with CPU-like precision control.
+
 -----
 
 # Settings System

{math_engine-0.4.0 → math_engine-0.5.0}/README.md

@@ -1,5 +1,5 @@
 
-# Math Engine 0.4.0
+# Math Engine 0.5.0
 
 [![PyPI Version](https://img.shields.io/pypi/v/math-engine.svg)](https://pypi.org/project/math-engine/)
 [![License: MIT](https://img.shields.io/pypi/l/math-engine.svg)](https://opensource.org/licenses/MIT)
@@ -19,7 +19,7 @@ It provides a complete pipeline:
 * Scientific functions
 * Strict error codes for reliable debugging and automated testing
 
-**Version 0.4.0** introduces a powerful **Command Line Interface (CLI)**
+
 
 This library is ideal for:
 
@@ -248,7 +248,7 @@ Non-decimal parsing respects the setting `allow_non_decimal`. If it is set to `F
 
 -----
 
-# Bitwise Operations & Developer Mode (v0.4.0)
+# Bitwise Operations & Developer Mode (v0.5.0)
 
 Math Engine can act as a **programmer's calculator**. It supports standard operator precedence and bitwise logic.
 
@@ -311,9 +311,38 @@ math_engine.load_preset(settings)
 math_engine.evaluate("FF + 3")
 # Decimal('258')
 ```
-
 Input validation ensures safety and prevents mixing incompatible formats in strict modes.
 
+---
+## Bitwise & Low-Level Operations
+
+Math Engine now includes a rich collection of low-level bit manipulation functions commonly used in systems programming, embedded development, cryptography, and hardware-oriented tools.
+
+**Bitwise functions:**
+- `bitand(x, y)` — bitwise AND  
+- `bitor(x, y)` — bitwise OR  
+- `bitxor(x, y)` — bitwise XOR  
+- `bitnot(x)` — bitwise NOT  
+
+**Bit manipulation utilities:**
+- `setbit(x, n)` — sets bit *n*  
+- `clrbit(x, n)` — clears bit *n*  
+- `togbit(x, n)` — toggles bit *n*  
+- `testbit(x, n)` — returns 1 if bit *n* is set, else 0  
+
+**Shift operations:**
+- `shl(x, n)` — logical left shift  
+- `shr(x, n)` — logical right shift  
+
+All bitwise functions:
+- respect `word_size` and `signed_mode`  
+- support overflow/wrap-around behavior  
+- fully support binary, hex, decimal, and octal inputs  
+- participate in the AST just like standard operators  
+- support underscores in non-decimal literals (`0b1111_0000`)  
+
+This makes Math Engine behave like a full-featured programmer’s calculator with CPU-like precision control.
+
 -----
 
 # Settings System

math_engine-0.5.0/math_engine/AST_Node_Types.py

@@ -0,0 +1,184 @@
+from decimal import Decimal, getcontext, Overflow
+from . import error as E
+
+# -----------------------------
+# AST node types
+# -----------------------------
+
+class Number:
+    """AST node for numeric literal backed by Decimal."""
+
+    def __init__(self, value):
+        # Always normalize input to Decimal via string to avoid float artifacts
+        if not isinstance(value, Decimal):
+            value = str(value)
+        self.value = Decimal(value)
+
+    def evaluate(self):
+        """Return Decimal value for this literal."""
+        return self.value
+
+    def collect_term(self, var_name):
+        """Return (factor_of_var, constant) for linear collection."""
+        return (0, self.value)
+
+    def __repr__(self):
+        # Helpful for debugging/printing the AST
+        try:
+            display_value = self.value.to_normal_string()
+        except AttributeError:
+            # Fallback for older Decimal versions
+            display_value = str(self.value)
+        return f"Number({display_value})"
+
+
+class Variable:
+    """AST node representing a single symbolic variable (e.g. 'var0')."""
+
+    def __init__(self, name):
+        self.name = name
+
+    def evaluate(self):
+        """Variables cannot be directly evaluated without solving."""
+        raise E.SolverError(f"Non linear problem.", code="3005")
+
+    def collect_term(self, var_name):
+        """Return (1, 0) if this variable matches var_name; else error."""
+        if self.name == var_name:
+            return (1, 0)
+        else:
+            # Only one variable supported in the linear solver
+            raise E.SolverError(f"Multiple variables found: {self.name}", code="3002")
+            return (0, 0)
+
+    def __repr__(self):
+        return f"Variable('{self.name}')"
+
+
+class BinOp:
+    """AST node for a binary operation: left <operator> right."""
+
+    def __init__(self, left, operator, right):
+        self.left = left
+        self.operator = operator
+        self.right = right
+
+    def evaluate(self):
+        """Evaluate numeric subtree and apply the binary operator."""
+        left_value = self.left.evaluate()
+        right_value = self.right.evaluate()
+
+        if self.operator == '+':
+            return left_value + right_value
+
+        elif self.operator == '-':
+            return left_value - right_value
+
+        elif self.operator == '&':
+            if left_value % 1 != 0 or right_value % 1 != 0:
+                raise E.CalculationError("Bitwise AND requires integers.", code="3042")
+            return Decimal(int(left_value) & int(right_value))
+
+        elif self.operator == '|':
+            if left_value % 1 != 0 or right_value % 1 != 0:
+                raise E.CalculationError("Bitwise OR requires integers.", code="3042")
+            return Decimal(int(left_value) | int(right_value))
+
+        elif self.operator == '^':
+            if left_value % 1 != 0 or right_value % 1 != 0:
+                raise E.CalculationError("XOR requires integers.", code="3042")
+            return Decimal(int(left_value) ^ int(right_value))
+
+        elif self.operator == '<<':
+            if left_value % 1 != 0 or right_value % 1 != 0:
+                raise E.CalculationError("Bitshift requires integers.", code="3041")
+            return Decimal(int(left_value) << int(right_value))
+
+        elif self.operator == '>>':
+            if left_value % 1 != 0 or right_value % 1 != 0:
+                raise E.CalculationError("Bitshift requires integers.", code="3041")
+            return Decimal(int(left_value) >> int(right_value))
+
+        elif self.operator == '*':
+            return left_value * right_value
+
+        elif self.operator == '**':
+            return left_value ** right_value
+
+        elif self.operator == '/':
+            if right_value == 0:
+                raise E.CalculationError("Division by zero", code="3003")
+            return left_value / right_value
+
+        elif self.operator == '=':
+            # Equality is evaluated to a boolean (used for "= True/False" responses)
+            return left_value == right_value
+        else:
+            raise E.CalculationError(f"Unknown operator: {self.operator}", code="3004")
+
+    def collect_term(self, var_name):
+        """Collect linear terms on this subtree into (factor_of_var, constant).
+
+        Only linear combinations are allowed; non-linear forms raise Solver/Syntax errors.
+        """
+        (left_factor, left_constant) = self.left.collect_term(var_name)
+        (right_factor, right_constant) = self.right.collect_term(var_name)
+
+        if self.operator == '+':
+            result_factor = left_factor + right_factor
+            result_constant = left_constant + right_constant
+            return (result_factor, result_constant)
+
+        elif self.operator == '-':
+            result_factor = left_factor - right_factor
+            result_constant = left_constant - right_constant
+            return (result_factor, result_constant)
+
+        elif self.operator == '*':
+            # Only constant * (A*x + B) is allowed. (A*x + B)*(C*x + D) would be non-linear.
+            if left_factor != 0 and right_factor != 0:
+                raise E.SyntaxError("x^x Error.", code="3005")
+
+            elif left_factor == 0:
+                # B * (C*x + D) = (B*C)*x + (B*D)
+                result_factor = left_constant * right_factor
+                result_constant = left_constant * right_constant
+                return (result_factor, result_constant)
+
+            elif right_factor == 0:
+                # (A*x + B) * D = (A*D)*x + (B*D)
+                result_factor = right_constant * left_factor
+                result_constant = right_constant * left_constant
+                return (result_factor, result_constant)
+
+            elif left_factor == 0 and right_factor == 0:
+                # Pure constant multiplication
+                result_factor = 0
+                result_constant = right_constant * left_constant
+                return (result_factor, result_constant)
+
+        elif self.operator == '/':
+            # (A*x + B) / D is allowed; division by (C*x + D) is non-linear
+            if right_factor != 0:
+                raise E.SolverError("Non-linear equation. (Division by x)", code="3006")
+            elif right_constant == 0:
+                raise E.SolverError("Solver: Division by zero", code="3003")
+            else:
+                # (A*x + B) / D = (A/D)*x + (B/D)
+                result_factor = left_factor / right_constant
+                result_constant = left_constant / right_constant
+                return (result_factor, result_constant)
+
+        elif self.operator == '**':
+            # Powers generate non-linear terms (e.g., x^2)
+            raise E.SolverError("Powers are not supported by the linear solver.", code="3007")
+
+        elif self.operator == '=':
+            # '=' only belongs at the root for solving; not inside collection
+            raise E.SolverError("Should not happen: '=' inside collect_terms", code="3720")
+
+        else:
+            raise E.CalculationError(f"Unknown operator: {self.operator}", code="3004")
+
+    def __repr__(self):
+        return f"BinOp({self.operator!r}, left={self.left}, right={self.right})"

{math_engine-0.4.0 → math_engine-0.5.0}/math_engine/__init__.py

@@ -8,7 +8,7 @@ from . import error as E
 from typing import Any, Mapping, Optional
 from typing import Union
 from typing import Any, Mapping
-__version__ = "0.4.0"
+__version__ = "0.5.0"
 memory = {}
 
 def set_memory(key_value: str, value:str):
@@ -119,7 +119,10 @@ def validate(expr: str,
 def reset_settings():
     config_manager.reset_settings()
 #
-if __name__ == '__main__':
-    #problem = ("x+1", x=5)
-    print(math_engine.evaluate("x += 5", x=10))
-    config_manager.reset_settings()
+# if __name__ == '__main__':
+#     #problem = ("x+1", x=5)
+#     print(math_engine.evaluate("bitxor(shr(shl(bitnot(7), 2), 4), 3) + 100"))
+#     print(evaluate("int:(bitand(0b1101,0b1011)+ bitor(0b0011,0b0101)+ bitxor(0xF0,0b1010)+ shl(3,4)+ shr(0b100000,3)+ setbit(0b0001,2)+ clrbit(0b1111,1)+ togbit(0b1010,1))"))
+#     print(evaluate("bool:testbit(0b1010, 3)"))
+#     #print(math_engine.evaluate("bitor(bitand(0b101110110, bitnot(4096)),160) * 3"))
+#     config_manager.reset_settings()