math-engine 0.3.0__tar.gz → 0.3.2__tar.gz

{math_engine-0.3.0 → math_engine-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: math-engine
-Version: 0.3.0
+Version: 0.3.2
 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
@@ -12,18 +12,18 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 
-# Math Engine 0.3.0
+
+# Math Engine 0.3.2
 
 [![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)
 [![Python Versions](https://img.shields.io/pypi/pyversions/math-engine.svg)](https://pypi.org/project/math-engine/)
 
-A fast, safe, configurable expression parser and calculator for Python
+A fast, safe, configurable expression parser and calculator for Python.
 
-**math_engine** is a powerful expression evaluation library designed for developers who need a **safe**, **configurable**, and **extendable** alternative to Python’s built-in `eval()` or other ad-hoc parsers.
+**math_engine** is a powerful expression evaluation library designed for developers who need a **safe**, **configurable**, and **extendable** alternative to Python’s built-in `eval()` or other ad-hoc parsers.  
 It provides a complete pipeline:
 
-
 * Tokenizer
 * AST (Abstract Syntax Tree) parser
 * Evaluator (numeric + equation solver)
@@ -33,7 +33,7 @@ It provides a complete pipeline:
 * Scientific functions
 * Strict error codes for reliable debugging and automated testing
 
-**Version 0.2.1** adds extensive non-decimal number support (hex, binary, octal), prefix-based type casting, improved settings management, and expanded error reporting.
+**Version _0.3.2_** adds extensive non-decimal number support (hex, binary, octal), prefix-based type casting, improved settings management, expanded error reporting, and an optional programmer mode with bitwise operations and word-size simulation.
 
 This library is ideal for:
 
@@ -58,12 +58,11 @@ This library is ideal for:
 * Strong error handling with unique codes
 * Settings system with presets
 * Optional strict modes:
-
   * `only_hex`
   * `only_binary`
   * `only_octal`
 
-### Non-Decimal Support (0.2.1)
+### Non-Decimal Support (≥ 0.2.1)
 
 * Read binary `0b1101`
 * Read octal `0o755`
@@ -76,9 +75,9 @@ This library is ideal for:
 
 # Installation
 
-```
+```bash
 pip install math-engine
-```
+````
 
 ---
 
@@ -109,11 +108,27 @@ math_engine.evaluate("octal: 64")
 ## Automatic Format Correction
 
 ```python
-math_engine.load_preset({"correct_output_format": True})
-math_engine.evaluate("boolean: 3+3=6")
+import math_engine
+
+settings = math_engine.load_all_settings()
+settings["correct_output_format"] = True
+math_engine.load_preset(settings)
+
+math_engine.evaluate("bool: 3+3=6")
 # True
 ```
 
+## Reset all Settings to Default
+
+```python
+import math_engine
+
+reset_settings()
+```
+
+
+If a requested output type does not match the actual result, `correct_output_format=True` allows math_engine to fall back to a compatible type instead of raising an error.
+
 ---
 
 # Prefix System (Casting Syntax)
@@ -145,14 +160,21 @@ math_engine.evaluate("hex: 3 + 3")
 ```python
 vars = {
     "A": 10,
-    "B": 5
+    "B": 5,
 }
 
-math_engine.evaluate("A + B", custom_variables=vars)
+math_engine.evaluate("A + B", variables=vars)
+# Decimal('15')
+```
+
+Alternatively, you can pass variables as keyword arguments:
+
+```python
+math_engine.evaluate("A + B", A=10, B=5)
 # Decimal('15')
 ```
 
-Variables must be single characters (to enforce safety and keep parsing simple).
+Variables are mapped internally to a safe internal representation and are designed to be simple and predictable.
 
 ---
 
@@ -166,7 +188,7 @@ math_engine.evaluate("√(16)")
 math_engine.evaluate("pi * 2")
 ```
 
-All functions are processed by the internal ScientificEngine.
+All functions are processed by the internal `ScientificEngine`, honoring your settings (for example, `use_degrees`).
 
 ---
 
@@ -195,58 +217,64 @@ math_engine.evaluate("0b1010 * 3")
 # Decimal('30')
 ```
 
-# Bitwise Operations & Developer Mode (v0.3.0)
+Non-decimal parsing respects the setting `allow_non_decimal`. If it is set to `False`, using `0b`, `0o`, or `0x` will raise a conversion error.
+
+---
+
+# Bitwise Operations & Developer Mode (v0.3.x)
 
-Math Engine now acts as a fully functional **Programmer's Calculator**. It supports standard Python operator precedence and bitwise logic.
+Math Engine can act as a **programmer's calculator**. It supports standard operator precedence and bitwise logic.
 
 ### New Operators
 
-| Operator | Description | Example | Result |
-| :--- | :--- | :--- | :--- |
-| `&` | Bitwise AND | `3 & 1` | `1` |
-| `\|` | Bitwise OR | `1 \| 2` | `3` |
-| `^` | Bitwise XOR | `3 ^ 1` | `2` |
-| `<<` | Left Shift | `1 << 2` | `4` |
-| `>>` | Right Shift | `8 >> 2` | `2` |
-| `**` | Power | `2 ** 3` | `8` |
+| Operator | Description | Example  | Result |
+| :------- | :---------- | :------- | :----- |
+| `&`      | Bitwise AND | `3 & 1`  | `1`    |
+| `\|`     | Bitwise OR  | `1 \| 2` | `3`    |
+| `^`      | Bitwise XOR | `3 ^ 1`  | `2`    |
+| `<<`     | Left Shift  | `1 << 2` | `4`    |
+| `>>`     | Right Shift | `8 >> 2` | `2`    |
+| `**`     | Power       | `2 ** 3` | `8`    |
 
-> **Note:** Since `^` is now used for **XOR**, use `**` for exponentiation (power).
+> Note: Since `^` is used for **XOR**, use `**` for exponentiation (power).
 
 ### Word Size & Overflow Simulation
 
 You can simulate hardware constraints (like C++ `int8`, `uint16`, etc.) by setting a `word_size`.
 
-* **`word_size: 0` (Default):** Python mode (Arbitrary precision, no overflow).
-* **`word_size: 8/16/32/64`:** Enforces bit limits. Numbers will wrap around (overflow).
+* **`word_size: 0` (Default):** Python mode (arbitrary precision, no overflow).
+* **`word_size: 8/16/32/64`:** Enforces bit limits. Numbers will wrap around (overflow) accordingly.
 
 ### Signed vs. Unsigned Mode
 
-When `word_size > 0`, you can toggle how binary data is interpreted using `signed_mode`.
+When `word_size > 0`, you can control how values are interpreted via `signed_mode`:
 
-* **`True` (Default):** Uses **Two's Complement**. The highest bit indicates a negative number.
-* **`False`:** Strictly positive numbers (Unsigned).
+* **`True` (Default):** Use **Two's Complement** for negative values.
+* **`False`:** Treat all values as unsigned.
 
-**Example: 8-Bit Simulation**
+**Example: 8-bit Simulation**
 
 ```python
-# Setup: 8-Bit Signed Mode
-settings = {
-    "word_size": 8,
-    "signed_mode": True
-}
+import math_engine
+
+settings = math_engine.load_all_settings()
+settings["word_size"] = 8
+settings["signed_mode"] = True
 math_engine.load_preset(settings)
 
-# Calculation: 127 + 1
-# Mathematically 128, but in 8-bit signed this overflows to -128.
 math_engine.evaluate("127 + 1")
+# In 8-bit signed arithmetic this overflows to -128
 # Decimal('-128')
+```
 
-# Calculation: -1 in Hex
-# In 8-bit two's complement, -1 is represented as FF.
+Hex output respects the current word size and signedness:
+
+```python
 math_engine.evaluate("hex: -1")
-# '-0x1' (Value is masked internally to 255)
+# Hex representation consistent with word_size / signed_mode configuration
 ```
-### Force-only-hex mode
+
+### Force-only-hex Mode
 
 ```python
 settings = math_engine.load_all_settings()
@@ -257,39 +285,58 @@ math_engine.evaluate("FF + 3")
 # Decimal('258')
 ```
 
-Input validation ensures safety.
+Input validation ensures safety and prevents mixing incompatible formats in strict modes.
 
 ---
 
 # Settings System
 
-You may load presets:
+You can inspect and modify settings programmatically.
+
+### Load Current Settings
+
+```python
+import math_engine
+
+settings = math_engine.load_all_settings()
+print(settings)
+```
+
+### Apply a Full Preset
+
+This is a plain Python `dict` (not JSON):
 
 ```python
 preset = {
     "decimal_places": 2,
-    "use_degrees": false,
-    "allow_augmented_assignment": true,
-    "fractions": false,
-    "allow_non_decimal": true,
-    "debug": false,
-    "correct_output_format": true,
+    "use_degrees": False,
+    "allow_augmented_assignment": True,
+    "fractions": False,
+    "allow_non_decimal": True,
+    "debug": False,
+    "correct_output_format": True,
     "default_output_format": "decimal:",
-    "only_hex": false,
-    "only_binary": false,
-    "only_octal": false,
-    # New in v0.3.0
-    "word_size": 0,       # 0 = Unlimited, or 8, 16, 32, 64
-    "signed_mode": true,  # True = Two's Complement, False = Unsigned
+    "only_hex": False,
+    "only_binary": False,
+    "only_octal": False,
+    # New in 0.3.0
+    "word_size": 0,        # 0 = unlimited, or 8, 16, 32, 64
+    "signed_mode": True,   # True = Two's Complement, False = Unsigned
 }
 
 math_engine.load_preset(preset)
 ```
 
-Or modify single settings:
+### Change a Single Setting
 
 ```python
-math_engine.save_setting("decimal_places", 10)
+math_engine.change_setting("decimal_places", 10)
+```
+
+You can also read a single setting:
+
+```python
+decimal_places = math_engine.load_one_setting("decimal_places")
 ```
 
 ---
@@ -306,10 +353,15 @@ Every error is a custom exception with:
 Example:
 
 ```python
+import math_engine
+from math_engine import error as E
+
 try:
     math_engine.evaluate("1/0")
-except math_engine.error.CalculationError as e:
-    print(e.code)  # 3003
+except E.CalculationError as e:
+    print(e.code)      # 3003
+    print(e.message)   # "Division by zero"
+    print(e.equation)  # "1/0"
 ```
 
 ### Example Error Codes
@@ -323,6 +375,9 @@ except math_engine.error.CalculationError as e:
 | 8000 | Conversion to int failed    |
 | 8006 | Output conversion error     |
 
+For a complete list of all error codes and their meanings, please see the **[Error Codes Reference](https://github.com/JanTeske06/math_engine/blob/master/ERRORS.md)**.
+
+---
 ---
 
 # Testing and Reliability
@@ -334,18 +389,21 @@ math_engine is designed with testing in mind:
 * Unit-test friendly behavior
 * No reliance on Python’s runtime execution
 
-You can easily test error codes:
+Example with `pytest`:
 
 ```python
 import pytest
+import math_engine
 from math_engine import error as E
 
-def test_div_zero():
+def test_division_by_zero_error_code():
     with pytest.raises(E.CalculationError) as exc:
         math_engine.evaluate("1/0")
     assert exc.value.code == "3003"
 ```
 
+You can also test more advanced behavior (non-decimal, strict modes, bitwise operations, etc.) in the same way.
+
 ---
 
 # Performance
@@ -367,7 +425,7 @@ Future updates focus on:
 
 ### Calculator Applications
 
-Build full scientific calculators, both GUI and command line.
+Build full scientific or programmer calculators, both GUI and command line.
 
 ### Education
 
@@ -377,7 +435,7 @@ Great for learning about lexers, parsers, ASTs, and expression evaluation.
 
 Safe math evaluation inside larger apps.
 
-### Security-sensitive Input
+### Security-Sensitive Input
 
 Rejects arbitrary Python code and ensures controlled evaluation.
 
@@ -392,7 +450,6 @@ Conversion between hex/bin/decimal is easy and reliable.
 * Non-decimal output formatting upgrades
 * Strict type-matching modes
 * Function overloading
-* Bitwise operators (`&`, `|`, `^`, `<<`, `>>`)
 * Memory/register system
 * Speed optimization via caching
 * User-defined functions
@@ -412,9 +469,6 @@ MIT License
 Contributions are welcome.
 Feel free to submit issues or PRs on GitHub:
 
-```
+```text
 https://github.com/JanTeske06/math_engine
 ```
-
----
-

{math_engine-0.3.0 → math_engine-0.3.2}/README.md

@@ -1,15 +1,15 @@
-# Math Engine 0.3.0
+
+# Math Engine 0.3.2
 
 [![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)
 [![Python Versions](https://img.shields.io/pypi/pyversions/math-engine.svg)](https://pypi.org/project/math-engine/)
 
-A fast, safe, configurable expression parser and calculator for Python
+A fast, safe, configurable expression parser and calculator for Python.
 
-**math_engine** is a powerful expression evaluation library designed for developers who need a **safe**, **configurable**, and **extendable** alternative to Python’s built-in `eval()` or other ad-hoc parsers.
+**math_engine** is a powerful expression evaluation library designed for developers who need a **safe**, **configurable**, and **extendable** alternative to Python’s built-in `eval()` or other ad-hoc parsers.  
 It provides a complete pipeline:
 
-
 * Tokenizer
 * AST (Abstract Syntax Tree) parser
 * Evaluator (numeric + equation solver)
@@ -19,7 +19,7 @@ It provides a complete pipeline:
 * Scientific functions
 * Strict error codes for reliable debugging and automated testing
 
-**Version 0.2.1** adds extensive non-decimal number support (hex, binary, octal), prefix-based type casting, improved settings management, and expanded error reporting.
+**Version _0.3.2_** adds extensive non-decimal number support (hex, binary, octal), prefix-based type casting, improved settings management, expanded error reporting, and an optional programmer mode with bitwise operations and word-size simulation.
 
 This library is ideal for:
 
@@ -44,12 +44,11 @@ This library is ideal for:
 * Strong error handling with unique codes
 * Settings system with presets
 * Optional strict modes:
-
   * `only_hex`
   * `only_binary`
   * `only_octal`
 
-### Non-Decimal Support (0.2.1)
+### Non-Decimal Support (≥ 0.2.1)
 
 * Read binary `0b1101`
 * Read octal `0o755`
@@ -62,9 +61,9 @@ This library is ideal for:
 
 # Installation
 
-```
+```bash
 pip install math-engine
-```
+````
 
 ---
 
@@ -95,11 +94,27 @@ math_engine.evaluate("octal: 64")
 ## Automatic Format Correction
 
 ```python
-math_engine.load_preset({"correct_output_format": True})
-math_engine.evaluate("boolean: 3+3=6")
+import math_engine
+
+settings = math_engine.load_all_settings()
+settings["correct_output_format"] = True
+math_engine.load_preset(settings)
+
+math_engine.evaluate("bool: 3+3=6")
 # True
 ```
 
+## Reset all Settings to Default
+
+```python
+import math_engine
+
+reset_settings()
+```
+
+
+If a requested output type does not match the actual result, `correct_output_format=True` allows math_engine to fall back to a compatible type instead of raising an error.
+
 ---
 
 # Prefix System (Casting Syntax)
@@ -131,14 +146,21 @@ math_engine.evaluate("hex: 3 + 3")
 ```python
 vars = {
     "A": 10,
-    "B": 5
+    "B": 5,
 }
 
-math_engine.evaluate("A + B", custom_variables=vars)
+math_engine.evaluate("A + B", variables=vars)
+# Decimal('15')
+```
+
+Alternatively, you can pass variables as keyword arguments:
+
+```python
+math_engine.evaluate("A + B", A=10, B=5)
 # Decimal('15')
 ```
 
-Variables must be single characters (to enforce safety and keep parsing simple).
+Variables are mapped internally to a safe internal representation and are designed to be simple and predictable.
 
 ---
 
@@ -152,7 +174,7 @@ math_engine.evaluate("√(16)")
 math_engine.evaluate("pi * 2")
 ```
 
-All functions are processed by the internal ScientificEngine.
+All functions are processed by the internal `ScientificEngine`, honoring your settings (for example, `use_degrees`).
 
 ---
 
@@ -181,58 +203,64 @@ math_engine.evaluate("0b1010 * 3")
 # Decimal('30')
 ```
 
-# Bitwise Operations & Developer Mode (v0.3.0)
+Non-decimal parsing respects the setting `allow_non_decimal`. If it is set to `False`, using `0b`, `0o`, or `0x` will raise a conversion error.
+
+---
+
+# Bitwise Operations & Developer Mode (v0.3.x)
 
-Math Engine now acts as a fully functional **Programmer's Calculator**. It supports standard Python operator precedence and bitwise logic.
+Math Engine can act as a **programmer's calculator**. It supports standard operator precedence and bitwise logic.
 
 ### New Operators
 
-| Operator | Description | Example | Result |
-| :--- | :--- | :--- | :--- |
-| `&` | Bitwise AND | `3 & 1` | `1` |
-| `\|` | Bitwise OR | `1 \| 2` | `3` |
-| `^` | Bitwise XOR | `3 ^ 1` | `2` |
-| `<<` | Left Shift | `1 << 2` | `4` |
-| `>>` | Right Shift | `8 >> 2` | `2` |
-| `**` | Power | `2 ** 3` | `8` |
+| Operator | Description | Example  | Result |
+| :------- | :---------- | :------- | :----- |
+| `&`      | Bitwise AND | `3 & 1`  | `1`    |
+| `\|`     | Bitwise OR  | `1 \| 2` | `3`    |
+| `^`      | Bitwise XOR | `3 ^ 1`  | `2`    |
+| `<<`     | Left Shift  | `1 << 2` | `4`    |
+| `>>`     | Right Shift | `8 >> 2` | `2`    |
+| `**`     | Power       | `2 ** 3` | `8`    |
 
-> **Note:** Since `^` is now used for **XOR**, use `**` for exponentiation (power).
+> Note: Since `^` is used for **XOR**, use `**` for exponentiation (power).
 
 ### Word Size & Overflow Simulation
 
 You can simulate hardware constraints (like C++ `int8`, `uint16`, etc.) by setting a `word_size`.
 
-* **`word_size: 0` (Default):** Python mode (Arbitrary precision, no overflow).
-* **`word_size: 8/16/32/64`:** Enforces bit limits. Numbers will wrap around (overflow).
+* **`word_size: 0` (Default):** Python mode (arbitrary precision, no overflow).
+* **`word_size: 8/16/32/64`:** Enforces bit limits. Numbers will wrap around (overflow) accordingly.
 
 ### Signed vs. Unsigned Mode
 
-When `word_size > 0`, you can toggle how binary data is interpreted using `signed_mode`.
+When `word_size > 0`, you can control how values are interpreted via `signed_mode`:
 
-* **`True` (Default):** Uses **Two's Complement**. The highest bit indicates a negative number.
-* **`False`:** Strictly positive numbers (Unsigned).
+* **`True` (Default):** Use **Two's Complement** for negative values.
+* **`False`:** Treat all values as unsigned.
 
-**Example: 8-Bit Simulation**
+**Example: 8-bit Simulation**
 
 ```python
-# Setup: 8-Bit Signed Mode
-settings = {
-    "word_size": 8,
-    "signed_mode": True
-}
+import math_engine
+
+settings = math_engine.load_all_settings()
+settings["word_size"] = 8
+settings["signed_mode"] = True
 math_engine.load_preset(settings)
 
-# Calculation: 127 + 1
-# Mathematically 128, but in 8-bit signed this overflows to -128.
 math_engine.evaluate("127 + 1")
+# In 8-bit signed arithmetic this overflows to -128
 # Decimal('-128')
+```
 
-# Calculation: -1 in Hex
-# In 8-bit two's complement, -1 is represented as FF.
+Hex output respects the current word size and signedness:
+
+```python
 math_engine.evaluate("hex: -1")
-# '-0x1' (Value is masked internally to 255)
+# Hex representation consistent with word_size / signed_mode configuration
 ```
-### Force-only-hex mode
+
+### Force-only-hex Mode
 
 ```python
 settings = math_engine.load_all_settings()
@@ -243,39 +271,58 @@ math_engine.evaluate("FF + 3")
 # Decimal('258')
 ```
 
-Input validation ensures safety.
+Input validation ensures safety and prevents mixing incompatible formats in strict modes.
 
 ---
 
 # Settings System
 
-You may load presets:
+You can inspect and modify settings programmatically.
+
+### Load Current Settings
+
+```python
+import math_engine
+
+settings = math_engine.load_all_settings()
+print(settings)
+```
+
+### Apply a Full Preset
+
+This is a plain Python `dict` (not JSON):
 
 ```python
 preset = {
     "decimal_places": 2,
-    "use_degrees": false,
-    "allow_augmented_assignment": true,
-    "fractions": false,
-    "allow_non_decimal": true,
-    "debug": false,
-    "correct_output_format": true,
+    "use_degrees": False,
+    "allow_augmented_assignment": True,
+    "fractions": False,
+    "allow_non_decimal": True,
+    "debug": False,
+    "correct_output_format": True,
     "default_output_format": "decimal:",
-    "only_hex": false,
-    "only_binary": false,
-    "only_octal": false,
-    # New in v0.3.0
-    "word_size": 0,       # 0 = Unlimited, or 8, 16, 32, 64
-    "signed_mode": true,  # True = Two's Complement, False = Unsigned
+    "only_hex": False,
+    "only_binary": False,
+    "only_octal": False,
+    # New in 0.3.0
+    "word_size": 0,        # 0 = unlimited, or 8, 16, 32, 64
+    "signed_mode": True,   # True = Two's Complement, False = Unsigned
 }
 
 math_engine.load_preset(preset)
 ```
 
-Or modify single settings:
+### Change a Single Setting
 
 ```python
-math_engine.save_setting("decimal_places", 10)
+math_engine.change_setting("decimal_places", 10)
+```
+
+You can also read a single setting:
+
+```python
+decimal_places = math_engine.load_one_setting("decimal_places")
 ```
 
 ---
@@ -292,10 +339,15 @@ Every error is a custom exception with:
 Example:
 
 ```python
+import math_engine
+from math_engine import error as E
+
 try:
     math_engine.evaluate("1/0")
-except math_engine.error.CalculationError as e:
-    print(e.code)  # 3003
+except E.CalculationError as e:
+    print(e.code)      # 3003
+    print(e.message)   # "Division by zero"
+    print(e.equation)  # "1/0"
 ```
 
 ### Example Error Codes
@@ -309,6 +361,9 @@ except math_engine.error.CalculationError as e:
 | 8000 | Conversion to int failed    |
 | 8006 | Output conversion error     |
 
+For a complete list of all error codes and their meanings, please see the **[Error Codes Reference](https://github.com/JanTeske06/math_engine/blob/master/ERRORS.md)**.
+
+---
 ---
 
 # Testing and Reliability
@@ -320,18 +375,21 @@ math_engine is designed with testing in mind:
 * Unit-test friendly behavior
 * No reliance on Python’s runtime execution
 
-You can easily test error codes:
+Example with `pytest`:
 
 ```python
 import pytest
+import math_engine
 from math_engine import error as E
 
-def test_div_zero():
+def test_division_by_zero_error_code():
     with pytest.raises(E.CalculationError) as exc:
         math_engine.evaluate("1/0")
     assert exc.value.code == "3003"
 ```
 
+You can also test more advanced behavior (non-decimal, strict modes, bitwise operations, etc.) in the same way.
+
 ---
 
 # Performance
@@ -353,7 +411,7 @@ Future updates focus on:
 
 ### Calculator Applications
 
-Build full scientific calculators, both GUI and command line.
+Build full scientific or programmer calculators, both GUI and command line.
 
 ### Education
 
@@ -363,7 +421,7 @@ Great for learning about lexers, parsers, ASTs, and expression evaluation.
 
 Safe math evaluation inside larger apps.
 
-### Security-sensitive Input
+### Security-Sensitive Input
 
 Rejects arbitrary Python code and ensures controlled evaluation.
 
@@ -378,7 +436,6 @@ Conversion between hex/bin/decimal is easy and reliable.
 * Non-decimal output formatting upgrades
 * Strict type-matching modes
 * Function overloading
-* Bitwise operators (`&`, `|`, `^`, `<<`, `>>`)
 * Memory/register system
 * Speed optimization via caching
 * User-defined functions
@@ -398,9 +455,6 @@ MIT License
 Contributions are welcome.
 Feel free to submit issues or PRs on GitHub:
 
-```
+```text
 https://github.com/JanTeske06/math_engine
 ```
-
----
-

{math_engine-0.3.0 → math_engine-0.3.2}/math_engine/__init__.py

@@ -116,7 +116,8 @@ def validate(expr: str,
             print(Equation + str(e.equation))
 
 
-
+def reset_settings():
+    config_manager.reset_settings()
 #
 # if __name__ == '__main__':
 #     #problem = ("x+1", x=5)

{math_engine-0.3.0 → math_engine-0.3.2}/math_engine.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: math-engine
-Version: 0.3.0
+Version: 0.3.2
 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
@@ -12,18 +12,18 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 
-# Math Engine 0.3.0
+
+# Math Engine 0.3.2
 
 [![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)
 [![Python Versions](https://img.shields.io/pypi/pyversions/math-engine.svg)](https://pypi.org/project/math-engine/)
 
-A fast, safe, configurable expression parser and calculator for Python
+A fast, safe, configurable expression parser and calculator for Python.
 
-**math_engine** is a powerful expression evaluation library designed for developers who need a **safe**, **configurable**, and **extendable** alternative to Python’s built-in `eval()` or other ad-hoc parsers.
+**math_engine** is a powerful expression evaluation library designed for developers who need a **safe**, **configurable**, and **extendable** alternative to Python’s built-in `eval()` or other ad-hoc parsers.  
 It provides a complete pipeline:
 
-
 * Tokenizer
 * AST (Abstract Syntax Tree) parser
 * Evaluator (numeric + equation solver)
@@ -33,7 +33,7 @@ It provides a complete pipeline:
 * Scientific functions
 * Strict error codes for reliable debugging and automated testing
 
-**Version 0.2.1** adds extensive non-decimal number support (hex, binary, octal), prefix-based type casting, improved settings management, and expanded error reporting.
+**Version _0.3.2_** adds extensive non-decimal number support (hex, binary, octal), prefix-based type casting, improved settings management, expanded error reporting, and an optional programmer mode with bitwise operations and word-size simulation.
 
 This library is ideal for:
 
@@ -58,12 +58,11 @@ This library is ideal for:
 * Strong error handling with unique codes
 * Settings system with presets
 * Optional strict modes:
-
   * `only_hex`
   * `only_binary`
   * `only_octal`
 
-### Non-Decimal Support (0.2.1)
+### Non-Decimal Support (≥ 0.2.1)
 
 * Read binary `0b1101`
 * Read octal `0o755`
@@ -76,9 +75,9 @@ This library is ideal for:
 
 # Installation
 
-```
+```bash
 pip install math-engine
-```
+````
 
 ---
 
@@ -109,11 +108,27 @@ math_engine.evaluate("octal: 64")
 ## Automatic Format Correction
 
 ```python
-math_engine.load_preset({"correct_output_format": True})
-math_engine.evaluate("boolean: 3+3=6")
+import math_engine
+
+settings = math_engine.load_all_settings()
+settings["correct_output_format"] = True
+math_engine.load_preset(settings)
+
+math_engine.evaluate("bool: 3+3=6")
 # True
 ```
 
+## Reset all Settings to Default
+
+```python
+import math_engine
+
+reset_settings()
+```
+
+
+If a requested output type does not match the actual result, `correct_output_format=True` allows math_engine to fall back to a compatible type instead of raising an error.
+
 ---
 
 # Prefix System (Casting Syntax)
@@ -145,14 +160,21 @@ math_engine.evaluate("hex: 3 + 3")
 ```python
 vars = {
     "A": 10,
-    "B": 5
+    "B": 5,
 }
 
-math_engine.evaluate("A + B", custom_variables=vars)
+math_engine.evaluate("A + B", variables=vars)
+# Decimal('15')
+```
+
+Alternatively, you can pass variables as keyword arguments:
+
+```python
+math_engine.evaluate("A + B", A=10, B=5)
 # Decimal('15')
 ```
 
-Variables must be single characters (to enforce safety and keep parsing simple).
+Variables are mapped internally to a safe internal representation and are designed to be simple and predictable.
 
 ---
 
@@ -166,7 +188,7 @@ math_engine.evaluate("√(16)")
 math_engine.evaluate("pi * 2")
 ```
 
-All functions are processed by the internal ScientificEngine.
+All functions are processed by the internal `ScientificEngine`, honoring your settings (for example, `use_degrees`).
 
 ---
 
@@ -195,58 +217,64 @@ math_engine.evaluate("0b1010 * 3")
 # Decimal('30')
 ```
 
-# Bitwise Operations & Developer Mode (v0.3.0)
+Non-decimal parsing respects the setting `allow_non_decimal`. If it is set to `False`, using `0b`, `0o`, or `0x` will raise a conversion error.
+
+---
+
+# Bitwise Operations & Developer Mode (v0.3.x)
 
-Math Engine now acts as a fully functional **Programmer's Calculator**. It supports standard Python operator precedence and bitwise logic.
+Math Engine can act as a **programmer's calculator**. It supports standard operator precedence and bitwise logic.
 
 ### New Operators
 
-| Operator | Description | Example | Result |
-| :--- | :--- | :--- | :--- |
-| `&` | Bitwise AND | `3 & 1` | `1` |
-| `\|` | Bitwise OR | `1 \| 2` | `3` |
-| `^` | Bitwise XOR | `3 ^ 1` | `2` |
-| `<<` | Left Shift | `1 << 2` | `4` |
-| `>>` | Right Shift | `8 >> 2` | `2` |
-| `**` | Power | `2 ** 3` | `8` |
+| Operator | Description | Example  | Result |
+| :------- | :---------- | :------- | :----- |
+| `&`      | Bitwise AND | `3 & 1`  | `1`    |
+| `\|`     | Bitwise OR  | `1 \| 2` | `3`    |
+| `^`      | Bitwise XOR | `3 ^ 1`  | `2`    |
+| `<<`     | Left Shift  | `1 << 2` | `4`    |
+| `>>`     | Right Shift | `8 >> 2` | `2`    |
+| `**`     | Power       | `2 ** 3` | `8`    |
 
-> **Note:** Since `^` is now used for **XOR**, use `**` for exponentiation (power).
+> Note: Since `^` is used for **XOR**, use `**` for exponentiation (power).
 
 ### Word Size & Overflow Simulation
 
 You can simulate hardware constraints (like C++ `int8`, `uint16`, etc.) by setting a `word_size`.
 
-* **`word_size: 0` (Default):** Python mode (Arbitrary precision, no overflow).
-* **`word_size: 8/16/32/64`:** Enforces bit limits. Numbers will wrap around (overflow).
+* **`word_size: 0` (Default):** Python mode (arbitrary precision, no overflow).
+* **`word_size: 8/16/32/64`:** Enforces bit limits. Numbers will wrap around (overflow) accordingly.
 
 ### Signed vs. Unsigned Mode
 
-When `word_size > 0`, you can toggle how binary data is interpreted using `signed_mode`.
+When `word_size > 0`, you can control how values are interpreted via `signed_mode`:
 
-* **`True` (Default):** Uses **Two's Complement**. The highest bit indicates a negative number.
-* **`False`:** Strictly positive numbers (Unsigned).
+* **`True` (Default):** Use **Two's Complement** for negative values.
+* **`False`:** Treat all values as unsigned.
 
-**Example: 8-Bit Simulation**
+**Example: 8-bit Simulation**
 
 ```python
-# Setup: 8-Bit Signed Mode
-settings = {
-    "word_size": 8,
-    "signed_mode": True
-}
+import math_engine
+
+settings = math_engine.load_all_settings()
+settings["word_size"] = 8
+settings["signed_mode"] = True
 math_engine.load_preset(settings)
 
-# Calculation: 127 + 1
-# Mathematically 128, but in 8-bit signed this overflows to -128.
 math_engine.evaluate("127 + 1")
+# In 8-bit signed arithmetic this overflows to -128
 # Decimal('-128')
+```
 
-# Calculation: -1 in Hex
-# In 8-bit two's complement, -1 is represented as FF.
+Hex output respects the current word size and signedness:
+
+```python
 math_engine.evaluate("hex: -1")
-# '-0x1' (Value is masked internally to 255)
+# Hex representation consistent with word_size / signed_mode configuration
 ```
-### Force-only-hex mode
+
+### Force-only-hex Mode
 
 ```python
 settings = math_engine.load_all_settings()
@@ -257,39 +285,58 @@ math_engine.evaluate("FF + 3")
 # Decimal('258')
 ```
 
-Input validation ensures safety.
+Input validation ensures safety and prevents mixing incompatible formats in strict modes.
 
 ---
 
 # Settings System
 
-You may load presets:
+You can inspect and modify settings programmatically.
+
+### Load Current Settings
+
+```python
+import math_engine
+
+settings = math_engine.load_all_settings()
+print(settings)
+```
+
+### Apply a Full Preset
+
+This is a plain Python `dict` (not JSON):
 
 ```python
 preset = {
     "decimal_places": 2,
-    "use_degrees": false,
-    "allow_augmented_assignment": true,
-    "fractions": false,
-    "allow_non_decimal": true,
-    "debug": false,
-    "correct_output_format": true,
+    "use_degrees": False,
+    "allow_augmented_assignment": True,
+    "fractions": False,
+    "allow_non_decimal": True,
+    "debug": False,
+    "correct_output_format": True,
     "default_output_format": "decimal:",
-    "only_hex": false,
-    "only_binary": false,
-    "only_octal": false,
-    # New in v0.3.0
-    "word_size": 0,       # 0 = Unlimited, or 8, 16, 32, 64
-    "signed_mode": true,  # True = Two's Complement, False = Unsigned
+    "only_hex": False,
+    "only_binary": False,
+    "only_octal": False,
+    # New in 0.3.0
+    "word_size": 0,        # 0 = unlimited, or 8, 16, 32, 64
+    "signed_mode": True,   # True = Two's Complement, False = Unsigned
 }
 
 math_engine.load_preset(preset)
 ```
 
-Or modify single settings:
+### Change a Single Setting
 
 ```python
-math_engine.save_setting("decimal_places", 10)
+math_engine.change_setting("decimal_places", 10)
+```
+
+You can also read a single setting:
+
+```python
+decimal_places = math_engine.load_one_setting("decimal_places")
 ```
 
 ---
@@ -306,10 +353,15 @@ Every error is a custom exception with:
 Example:
 
 ```python
+import math_engine
+from math_engine import error as E
+
 try:
     math_engine.evaluate("1/0")
-except math_engine.error.CalculationError as e:
-    print(e.code)  # 3003
+except E.CalculationError as e:
+    print(e.code)      # 3003
+    print(e.message)   # "Division by zero"
+    print(e.equation)  # "1/0"
 ```
 
 ### Example Error Codes
@@ -323,6 +375,9 @@ except math_engine.error.CalculationError as e:
 | 8000 | Conversion to int failed    |
 | 8006 | Output conversion error     |
 
+For a complete list of all error codes and their meanings, please see the **[Error Codes Reference](https://github.com/JanTeske06/math_engine/blob/master/ERRORS.md)**.
+
+---
 ---
 
 # Testing and Reliability
@@ -334,18 +389,21 @@ math_engine is designed with testing in mind:
 * Unit-test friendly behavior
 * No reliance on Python’s runtime execution
 
-You can easily test error codes:
+Example with `pytest`:
 
 ```python
 import pytest
+import math_engine
 from math_engine import error as E
 
-def test_div_zero():
+def test_division_by_zero_error_code():
     with pytest.raises(E.CalculationError) as exc:
         math_engine.evaluate("1/0")
     assert exc.value.code == "3003"
 ```
 
+You can also test more advanced behavior (non-decimal, strict modes, bitwise operations, etc.) in the same way.
+
 ---
 
 # Performance
@@ -367,7 +425,7 @@ Future updates focus on:
 
 ### Calculator Applications
 
-Build full scientific calculators, both GUI and command line.
+Build full scientific or programmer calculators, both GUI and command line.
 
 ### Education
 
@@ -377,7 +435,7 @@ Great for learning about lexers, parsers, ASTs, and expression evaluation.
 
 Safe math evaluation inside larger apps.
 
-### Security-sensitive Input
+### Security-Sensitive Input
 
 Rejects arbitrary Python code and ensures controlled evaluation.
 
@@ -392,7 +450,6 @@ Conversion between hex/bin/decimal is easy and reliable.
 * Non-decimal output formatting upgrades
 * Strict type-matching modes
 * Function overloading
-* Bitwise operators (`&`, `|`, `^`, `<<`, `>>`)
 * Memory/register system
 * Speed optimization via caching
 * User-defined functions
@@ -412,9 +469,6 @@ MIT License
 Contributions are welcome.
 Feel free to submit issues or PRs on GitHub:
 
-```
+```text
 https://github.com/JanTeske06/math_engine
 ```
-
----
-

{math_engine-0.3.0 → math_engine-0.3.2}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "math-engine"
-version = "0.3.0"
+version = "0.3.2"
 authors = [
   { name="Jan Teske", email="jan.teske.06@gmail.com" },
 ]