hypercomplex-engine 0.0.4.1__tar.gz → 0.4.1__tar.gz

{hypercomplex_engine-0.0.4.1/hypercomplex_engine.egg-info → hypercomplex_engine-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypercomplex-engine
-Version: 0.0.4.1
+Version: 0.4.1
 Summary: Fast O(1)/O(n) multiplication engine and table generator for ordinary, split, and dual Cayley-Dickson algebras.
 Author-email: Maher Ben Abdessalem <ba.maher94@gmail.com>
 License: MIT License

{hypercomplex_engine-0.0.4.1 → hypercomplex_engine-0.4.1}/hypercomplex/core/fast/fast_dual.py

@@ -125,18 +125,24 @@ class FastDual:
             (final_sign, local_index, eps_flag)
         """
         dim = Validation.dimension(dim)
+        Validation.basis_tuple(t1, allow_zero=True, allow_eps=True)
+        Validation.basis_tuple(t2, allow_zero=True, allow_eps=True)
 
-        s1, i = self._extract_global(t1, dim)
-        s2, j = self._extract_global(t2, dim)
+        
+
+        s1, i = int(t1[0]), int(t1[1])
+        s2, j = int(t2[0]), int(t2[1])
+        i_eps_flag = int(t1[2]) if len(t1) == 3 else 0
+        j_eps_flag = int(t2[2]) if len(t2) == 3 else 0
 
         if s1 == 0 or s2 == 0:
             return (0, 0, 0)
 
-        sign, idx, eps = self.multiply_indices(i, j, dim)
+        sign, idx, eps = self.multiply_indices(i, j,dim,i_eps_flag,j_eps_flag)
 
         return (s1 * s2 * sign, idx, eps)
 
-    def multiply_indices(self, i: int, j: int, dim: int) -> tuple:
+    def multiply_indices(self, i: int, j: int,dim:int, i_eps_flag=0 ,j_eps_flag=0) -> tuple:
         """
         Core dual O(1) multiplication using global indices.
 
@@ -156,8 +162,8 @@ class FastDual:
         if j < 0 or j >= total:
             raise ValueError(f"index must be in [0, {total - 1}] for dual dim={dim}, got {j}")
 
-        i_eps = i >= half
-        j_eps = j >= half
+        i_eps = i >= half or i_eps_flag
+        j_eps = j >= half or j_eps_flag
 
         i_loc = i & (half - 1)
         j_loc = j & (half - 1)

{hypercomplex_engine-0.0.4.1 → hypercomplex_engine-0.4.1}/hypercomplex/core/fast/fast_split.py

@@ -31,8 +31,8 @@ class FastSplit:
         t2 = (sign2, index2)
 
         dim:
-            Algebra exponent.
-            If None, it is inferred from the indices.
+            Algebra exponent (required; the result depends on it,
+            e.g. e2*e2 is +1 at dim=2 but -1 at dim>=3).
 
         Returns:
             (final_sign, index1 XOR index2)

{hypercomplex_engine-0.0.4.1 → hypercomplex_engine-0.4.1}/hypercomplex/core/fast/fast_standard.py

@@ -28,8 +28,8 @@ class FastStandard:
         Returns:
             (final_sign, index1 XOR index2)
         """
-        Validation.basis_tuple(t1, allow_zero=True, allow_eps=False)
-        Validation.basis_tuple(t2, allow_zero=True, allow_eps=False)
+        Validation.basis_tuple(t1, allow_zero=False, allow_eps=False)
+        Validation.basis_tuple(t2, allow_zero=False, allow_eps=False)
 
         s1, i = int(t1[0]), int(t1[1])
         s2, j = int(t2[0]), int(t2[1])

{hypercomplex_engine-0.0.4.1 → hypercomplex_engine-0.4.1}/hypercomplex/core/holographic/dual.py

@@ -48,7 +48,8 @@ class DualHolographic:
 
         s1, i = int(t1[0]), int(t1[1])
         s2, j = int(t2[0]), int(t2[1])
-
+        i_eps_flag = int(t1[2]) if len(t1) == 3 else 0
+        j_eps_flag = int(t2[2]) if len(t2) == 3 else 0
         # Zero propagates.
         if s1 == 0 or s2 == 0:
             return (0, 0, 0)
@@ -63,8 +64,8 @@ class DualHolographic:
 
         half = 1 << dim
 
-        i_eps = i >= half
-        j_eps = j >= half
+        i_eps = i >= half or i_eps_flag
+        j_eps = j >= half or j_eps_flag
 
         i_loc = i & (half - 1)
         j_loc = j & (half - 1)

{hypercomplex_engine-0.0.4.1 → hypercomplex_engine-0.4.1}/hypercomplex/core/validation.py

@@ -59,6 +59,7 @@ class Validation:
 
         if len(data) == 3 and not allow_eps:
             raise ValueError("3-tuple epsilon form is not allowed here")
+        
 
         sign = data[0]
         index = data[1]

{hypercomplex_engine-0.0.4.1 → hypercomplex_engine-0.4.1}/hypercomplex/facade.py

@@ -89,7 +89,6 @@ def _normalize_engine(engine: str) -> str:
     aliases = {
         "fast": "fast",
         "constant": "fast",
-        "fast": "fast",
         "bitwise": "fast",
         "o1":"fast",
 
@@ -254,12 +253,23 @@ def multiply(
         "holographic" O(n) descent, useful for verification
 
     dim:
-        Required for dual and dual_split.
-        Optional for split.
+        Required for split, dual and dual_split.
+        Not used for standard.
     """
     kind = _normalize_kind(kind)
     engine = _normalize_engine(engine)
 
+    # dim is part of the algebra's identity for split/dual kinds (e.g. e2*e2 is
+    # +e0 in split dim=2 but -e0 for every larger split algebra), so it is
+    # required, never inferred. Validate before anything else.
+    if kind in ("split", "dual", "dual_split") and dim is None:
+        raise ValueError(f"dim is required for {kind} multiplication")
+        # Validate inputs before any early return, so malformed data always
+        # raises ValidationError instead of leaking TypeError/IndexError.
+    allow_eps = kind in ("dual", "dual_split")
+    Validation.basis_tuple(a, allow_zero=True, allow_eps=allow_eps)
+    Validation.basis_tuple(b, allow_zero=True, allow_eps=allow_eps)
+
     # Zero propagation
     if int(a[0]) == 0 or int(b[0]) == 0:
         if kind in ("dual", "dual_split"):
@@ -267,10 +277,7 @@ def multiply(
         return (0, 0)
 
     # Dual inputs may be local 3-tuples: (sign, local_index, eps)
-    if kind in ("split","dual", "dual_split"):
-        if dim is None:
-            raise ValueError("dim is required for dual multiplication")
-
+    if kind in ("dual", "dual_split"):
         a = _as_dual_global(a, dim)
         b = _as_dual_global(b, dim)
 
@@ -298,8 +305,6 @@ def multiply(
             return _standard_holo.multiply(a, b)
 
         if kind == "split":
-            if dim is None:
-                dim = max(int(a[1]), int(b[1])).bit_length()
             return _split_holo.multiply(a, b, dim)
 
         if kind == "dual":

{hypercomplex_engine-0.0.4.1 → hypercomplex_engine-0.4.1/hypercomplex_engine.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypercomplex-engine
-Version: 0.0.4.1
+Version: 0.4.1
 Summary: Fast O(1)/O(n) multiplication engine and table generator for ordinary, split, and dual Cayley-Dickson algebras.
 Author-email: Maher Ben Abdessalem <ba.maher94@gmail.com>
 License: MIT License

{hypercomplex_engine-0.0.4.1 → hypercomplex_engine-0.4.1}/hypercomplex_engine.egg-info/SOURCES.txt

@@ -29,6 +29,8 @@ hypercomplex_engine.egg-info/SOURCES.txt
 hypercomplex_engine.egg-info/dependency_links.txt
 hypercomplex_engine.egg-info/requires.txt
 hypercomplex_engine.egg-info/top_level.txt
+tests/test_dual_tuple_regression.py
 tests/test_fast_mode.py
 tests/test_fixes_0_4.py
-tests/test_mega_mother.py
+tests/test_mega_mother.py
+tests/test_split_dim.py

{hypercomplex_engine-0.0.4.1 → hypercomplex_engine-0.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hypercomplex-engine" 
-version = "0.0.4.1"
+version = "0.4.1"
 authors = [
   { name="Maher Ben Abdessalem", email="ba.maher94@gmail.com" },
 ]

hypercomplex_engine-0.4.1/tests/test_dual_tuple_regression.py

@@ -0,0 +1,90 @@
+"""Regression tests for dual-engine tuple normalization and facade zero handling.
+
+History:
+- 0.4.0: DualHolographic ignored the eps flag while FastDual promoted it
+  (engines diverged on identical 3-tuple input).
+- 0.4.0 hotfix attempt: DualHolographic read t[2] unconditionally, crashing
+  with IndexError on documented 2-tuple input and breaking the facade's
+  engine="holographic" dual path (which normalizes to 2-tuples).
+- 0.4.1: both fixed; facade validates before zero-propagation.
+"""
+
+import pytest
+
+# Adjust these imports to whatever hypercomplex/__init__.py exports.
+from hypercomplex import multiply, FastDual, DualHolographic
+from hypercomplex.core.validation import Validation
+
+
+# ---------- tuple normalization: engines must agree on identical input ----------
+
+def _all_global_pairs(dim):
+    half = 1 << dim
+    for i in range(half << 1):
+        for j in range(half << 1):
+            yield (1, i, 1 if i >= half else 0), (1, j, 1 if j >= half else 0)
+
+
+@pytest.mark.parametrize("dim", [0, 1, 2, 3])
+def test_engines_agree_global_3tuples(dim):
+    fast, holo = FastDual(), DualHolographic()
+    for a, b in _all_global_pairs(dim):
+        assert fast.multiply(a, b, dim) == holo.multiply(a, b, dim)
+
+
+@pytest.mark.parametrize("dim", [1, 2, 3])
+def test_engines_agree_on_2tuples(dim):
+    """2-tuples are documented input; must not raise (the 0.4.0 regression)."""
+    fast, holo = FastDual(), DualHolographic()
+    for a, b in _all_global_pairs(dim):
+        a2, b2 = a[:2], b[:2]                      # strip the eps flag
+        assert fast.multiply(a2, b2, dim) == holo.multiply(a2, b2, dim)
+
+
+@pytest.mark.parametrize("dim", [1, 2, 3])
+def test_local_3tuple_matches_promoted_global(dim):
+    """(sign, local_index, eps=1) must equal (sign, local_index + half)."""
+    fast, holo = FastDual(), DualHolographic()
+    half = 1 << dim
+    for loc in range(half):
+        for j in range(half << 1):
+            for engine in (fast, holo):
+                assert engine.multiply((1, loc, 1), (1, j), dim) == \
+                       engine.multiply((1, loc + half), (1, j), dim)
+
+
+# ---------- facade routes, including the path that crashed ----------
+
+@pytest.mark.parametrize("engine", ["fast", "holographic"])
+def test_facade_dual_both_engines(engine):
+    assert multiply("dual", (1, 3), (1, 5), dim=3, engine=engine) == \
+           multiply("dual", (1, 3), (1, 5), dim=3, engine="fast")
+
+
+def test_facade_dual_3tuple_promotion():
+    half = 1 << 3
+    for engine in ("fast", "holographic"):
+        assert multiply("dual", (1, 2, 1), (1, 1), dim=3, engine=engine) == \
+               multiply("dual", (1, 2 + half), (1, 1), dim=3, engine=engine)
+
+
+# ---------- zero handling: validated, shape-correct, convention documented ----------
+
+def test_facade_zero_shapes():
+    assert multiply("dual", (0, 2), (1, 3), dim=2) == (0, 0, 0)
+    assert multiply("dual_split", (1, 2), (0, 3), dim=2) == (0, 0, 0)
+    assert multiply("standard", (0, 2), (1, 3), dim=2) == (0, 0)   # formal zero
+    assert multiply("split", (0, 2), (1, 3), dim=2) == (0, 0)
+
+
+def test_facade_malformed_raises_validation_error():
+    with pytest.raises((TypeError, ValueError)):
+        multiply("dual", 5, (1, 1), dim=2)              # not a tuple
+    with pytest.raises((TypeError, ValueError)):
+        multiply("standard", (1, 2, 3, 4), (1, 1))      # wrong arity
+
+# ---------- nilpotency still intact ----------
+
+@pytest.mark.parametrize("engine", ["fast", "holographic"])
+def test_nilpotency(engine):
+    assert multiply("dual", (1, 1), (1, 1), dim=0, engine=engine) == (0, 0, 0)

hypercomplex_engine-0.4.1/tests/test_split_dim.py

@@ -0,0 +1,33 @@
+"""split/dual require an explicit dim; split rejects epsilon 3-tuples."""
+import pytest
+from hypercomplex import multiply
+
+
+@pytest.mark.parametrize("engine", ["fast", "holographic"])
+@pytest.mark.parametrize("kind", ["split", "dual", "dual_split"])
+def test_dim_is_required_and_message_names_the_kind(kind, engine):
+    with pytest.raises(ValueError, match=f"dim is required for {kind}"):
+        multiply(kind, (1, 1), (1, 1), engine=engine)
+
+
+@pytest.mark.parametrize("kind", ["split", "dual", "dual_split"])
+def test_missing_dim_is_reported_even_for_zero_elements(kind):
+    with pytest.raises(ValueError, match="dim is required"):
+        multiply(kind, (0, 1), (1, 2))
+
+
+@pytest.mark.parametrize("engine", ["fast", "holographic"])
+def test_split_result_depends_on_dim(engine):
+    assert multiply("split", (1, 2), (1, 2), dim=2, engine=engine) == (1, 0)
+    for dim in (3, 4, 8):
+        assert multiply("split", (1, 2), (1, 2), dim=dim, engine=engine) == (-1, 0)
+
+
+@pytest.mark.parametrize("eps", [0, 1])
+def test_split_rejects_epsilon_three_tuples_with_clear_message(eps):
+    with pytest.raises(ValueError, match="3-tuple"):
+        multiply("split", (1, 1, eps), (1, 2), dim=2)
+
+
+def test_standard_needs_no_dim():
+    assert multiply("standard", (1, 1), (1, 2)) == (1, 3)