hypercomplex-engine 0.4.2.7__py3-none-any.whl → 0.6.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- hypercomplex_engine/__init__.py +5 -0
- hypercomplex_engine/core/__init__.py +6 -0
- hypercomplex_engine/core/fast/bit_utils.py +3 -1
- hypercomplex_engine/core/fast/fast_dual.py +23 -151
- hypercomplex_engine/core/holographic/dual.py +17 -57
- hypercomplex_engine/core/validation.py +6 -6
- hypercomplex_engine/core/vectorized/__init__.py +6 -0
- hypercomplex_engine/core/vectorized/vectorized_standard.py +118 -0
- hypercomplex_engine/facade.py +3 -32
- {hypercomplex_engine-0.4.2.7.dist-info → hypercomplex_engine-0.6.0.dist-info}/METADATA +3 -1
- {hypercomplex_engine-0.4.2.7.dist-info → hypercomplex_engine-0.6.0.dist-info}/RECORD +15 -13
- {hypercomplex_engine-0.4.2.7.dist-info → hypercomplex_engine-0.6.0.dist-info}/WHEEL +0 -0
- {hypercomplex_engine-0.4.2.7.dist-info → hypercomplex_engine-0.6.0.dist-info}/licenses/LICENSE +0 -0
- {hypercomplex_engine-0.4.2.7.dist-info → hypercomplex_engine-0.6.0.dist-info}/licenses/NOTICE +0 -0
- {hypercomplex_engine-0.4.2.7.dist-info → hypercomplex_engine-0.6.0.dist-info}/top_level.txt +0 -0
hypercomplex_engine/__init__.py
CHANGED
|
@@ -29,6 +29,8 @@ from .core import (
|
|
|
29
29
|
FastStandard,
|
|
30
30
|
FastSplit,
|
|
31
31
|
FastDual,
|
|
32
|
+
|
|
33
|
+
VectorizedStandard
|
|
32
34
|
)
|
|
33
35
|
|
|
34
36
|
from .printer import (
|
|
@@ -65,6 +67,9 @@ __all__ = [
|
|
|
65
67
|
"FastSplit",
|
|
66
68
|
"FastDual",
|
|
67
69
|
|
|
70
|
+
#VectorizedStandard
|
|
71
|
+
"VectorizedStandard"
|
|
72
|
+
|
|
68
73
|
# Printer / formatter
|
|
69
74
|
"CDFormat",
|
|
70
75
|
"CDTablePrinter",
|
|
@@ -20,6 +20,10 @@ from .fast import (
|
|
|
20
20
|
FastDual,
|
|
21
21
|
)
|
|
22
22
|
|
|
23
|
+
from .vectorized import (
|
|
24
|
+
VectorizedStandard
|
|
25
|
+
)
|
|
26
|
+
|
|
23
27
|
__all__ = [
|
|
24
28
|
"BasisElement",
|
|
25
29
|
"BasisNotation",
|
|
@@ -36,4 +40,6 @@ __all__ = [
|
|
|
36
40
|
"FastStandard",
|
|
37
41
|
"FastSplit",
|
|
38
42
|
"FastDual",
|
|
43
|
+
|
|
44
|
+
"VectorizedStandard",
|
|
39
45
|
]
|
|
@@ -2,26 +2,15 @@ from ..validation import Validation
|
|
|
2
2
|
from .fast_standard import FastStandard
|
|
3
3
|
from .fast_split import FastSplit
|
|
4
4
|
|
|
5
|
-
|
|
6
5
|
class FastDual:
|
|
7
6
|
"""
|
|
8
7
|
Dual Cayley-Dickson O(1) multiplier.
|
|
9
8
|
|
|
10
|
-
|
|
11
|
-
Total dual dimension is 2^(dim + 1).
|
|
12
|
-
Bit `dim` marks the epsilon component.
|
|
13
|
-
|
|
14
|
-
lower half: base elements
|
|
15
|
-
upper half: epsilon * base elements
|
|
16
|
-
|
|
17
|
-
Output:
|
|
9
|
+
STRICT 3-TUPLE INPUT:
|
|
18
10
|
(sign, local_index, eps_flag)
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
Zero products are normalized to:
|
|
24
|
-
(0, 0, 0)
|
|
11
|
+
|
|
12
|
+
local_index must be strictly < 2^dim.
|
|
13
|
+
eps_flag must be 0 or 1.
|
|
25
14
|
"""
|
|
26
15
|
|
|
27
16
|
def __init__(self, split: bool = False):
|
|
@@ -29,160 +18,43 @@ class FastDual:
|
|
|
29
18
|
self._standard = FastStandard()
|
|
30
19
|
self._split = FastSplit() if self._split_mode else None
|
|
31
20
|
|
|
32
|
-
# ==================================================================
|
|
33
|
-
# Index helpers
|
|
34
|
-
# ==================================================================
|
|
35
|
-
|
|
36
|
-
@staticmethod
|
|
37
|
-
def local_to_global(index: int, eps: int, dim: int) -> int:
|
|
38
|
-
"""
|
|
39
|
-
Convert local dual representation to global index.
|
|
40
|
-
|
|
41
|
-
local:
|
|
42
|
-
index in [0, 2^dim - 1]
|
|
43
|
-
eps = 0 or 1
|
|
44
|
-
|
|
45
|
-
global:
|
|
46
|
-
index in [0, 2^(dim+1) - 1]
|
|
47
|
-
"""
|
|
48
|
-
dim = Validation.dimension(dim)
|
|
49
|
-
index = int(index)
|
|
50
|
-
eps = int(eps)
|
|
51
|
-
|
|
52
|
-
half = 1 << dim
|
|
53
|
-
|
|
54
|
-
if index < 0 or index >= half:
|
|
55
|
-
raise ValueError(f"local index must be in [0, {half - 1}], got {index}")
|
|
56
|
-
|
|
57
|
-
if eps:
|
|
58
|
-
return index + half
|
|
59
|
-
|
|
60
|
-
return index
|
|
61
|
-
|
|
62
|
-
@staticmethod
|
|
63
|
-
def global_to_local(global_index: int, dim: int) -> tuple:
|
|
64
|
-
"""
|
|
65
|
-
Convert global dual index to:
|
|
66
|
-
(local_index, eps_flag)
|
|
67
|
-
"""
|
|
68
|
-
dim = Validation.dimension(dim)
|
|
69
|
-
global_index = int(global_index)
|
|
70
|
-
|
|
71
|
-
half = 1 << dim
|
|
72
|
-
total = half << 1
|
|
73
|
-
|
|
74
|
-
if global_index < 0 or global_index >= total:
|
|
75
|
-
raise ValueError(f"global index must be in [0, {total - 1}], got {global_index}")
|
|
76
|
-
|
|
77
|
-
return (global_index & (half - 1), 1 if global_index >= half else 0)
|
|
78
|
-
|
|
79
|
-
# ==================================================================
|
|
80
|
-
# Tuple input helper
|
|
81
|
-
# ==================================================================
|
|
82
|
-
|
|
83
|
-
def _extract_global(self, t: tuple, dim: int) -> tuple:
|
|
84
|
-
"""
|
|
85
|
-
Accepts:
|
|
86
|
-
(sign, global_index)
|
|
87
|
-
(sign, local_index, eps_flag)
|
|
88
|
-
|
|
89
|
-
Returns:
|
|
90
|
-
(sign, global_index)
|
|
91
|
-
"""
|
|
92
|
-
Validation.basis_tuple(t, allow_zero=True, allow_eps=True)
|
|
93
|
-
|
|
94
|
-
sign = int(t[0])
|
|
95
|
-
idx = int(t[1])
|
|
96
|
-
|
|
97
|
-
if sign == 0:
|
|
98
|
-
return (0, 0)
|
|
99
|
-
|
|
100
|
-
half = 1 << Validation.dimension(dim)
|
|
101
|
-
|
|
102
|
-
if len(t) >= 3:
|
|
103
|
-
eps = int(t[2])
|
|
104
|
-
|
|
105
|
-
# If the tuple carries an epsilon flag and the index is still
|
|
106
|
-
# local, promote it to the global upper half.
|
|
107
|
-
if eps == 1 and idx < half:
|
|
108
|
-
idx += half
|
|
109
|
-
|
|
110
|
-
return (sign, idx)
|
|
111
|
-
|
|
112
|
-
# ==================================================================
|
|
113
|
-
# Public API
|
|
114
|
-
# ==================================================================
|
|
115
|
-
|
|
116
21
|
def multiply(self, t1: tuple, t2: tuple, dim: int) -> tuple:
|
|
117
|
-
"""
|
|
118
|
-
Multiply two dual basis element tuples.
|
|
119
|
-
|
|
120
|
-
Accepted inputs:
|
|
121
|
-
(sign, global_index)
|
|
122
|
-
(sign, local_index, eps_flag)
|
|
123
|
-
|
|
124
|
-
Returns:
|
|
125
|
-
(final_sign, local_index, eps_flag)
|
|
126
|
-
"""
|
|
127
22
|
dim = Validation.dimension(dim)
|
|
128
23
|
Validation.basis_tuple(t1, allow_zero=True, allow_eps=True)
|
|
129
24
|
Validation.basis_tuple(t2, allow_zero=True, allow_eps=True)
|
|
130
25
|
|
|
131
|
-
|
|
132
|
-
|
|
133
|
-
|
|
134
|
-
s2, j = int(t2[0]), int(t2[1])
|
|
135
|
-
i_eps_flag = int(t1[2]) if len(t1) == 3 else 0
|
|
136
|
-
j_eps_flag = int(t2[2]) if len(t2) == 3 else 0
|
|
26
|
+
# STRICT 3-TUPLE UNPACKING
|
|
27
|
+
s1, i, i_eps = int(t1[0]), int(t1[1]), int(t1[2])
|
|
28
|
+
s2, j, j_eps = int(t2[0]), int(t2[1]), int(t2[2])
|
|
137
29
|
|
|
138
30
|
if s1 == 0 or s2 == 0:
|
|
139
31
|
return (0, 0, 0)
|
|
140
32
|
|
|
141
|
-
sign, idx, eps = self.multiply_indices(i, j,dim,
|
|
142
|
-
|
|
33
|
+
sign, idx, eps = self.multiply_indices(i, j, dim, i_eps, j_eps)
|
|
143
34
|
return (s1 * s2 * sign, idx, eps)
|
|
144
35
|
|
|
145
|
-
def multiply_indices(self, i: int, j: int,dim:int, i_eps_flag=0
|
|
146
|
-
"""
|
|
147
|
-
Core dual O(1) multiplication using global indices.
|
|
148
|
-
|
|
149
|
-
Returns:
|
|
150
|
-
(sign, local_index, eps_flag)
|
|
151
|
-
"""
|
|
152
|
-
i = int(i)
|
|
153
|
-
j = int(j)
|
|
36
|
+
def multiply_indices(self, i: int, j: int, dim: int, i_eps_flag: int = 0, j_eps_flag: int = 0) -> tuple:
|
|
154
37
|
dim = Validation.dimension(dim)
|
|
155
|
-
|
|
156
38
|
half = 1 << dim
|
|
157
|
-
|
|
158
|
-
|
|
159
|
-
if i < 0 or i >=
|
|
160
|
-
raise ValueError(f"index must be in [0, {
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
|
|
165
|
-
|
|
166
|
-
|
|
167
|
-
|
|
168
|
-
i_loc = i & (half - 1)
|
|
169
|
-
j_loc = j & (half - 1)
|
|
170
|
-
|
|
171
|
-
# --------------------------------------------------------------
|
|
172
|
-
# Epsilon nilpotency:
|
|
173
|
-
# (epsilon e_i)(epsilon e_j) = 0
|
|
174
|
-
# --------------------------------------------------------------
|
|
39
|
+
|
|
40
|
+
# STRICT LOCAL ENFORCEMENT: No more global overflow!
|
|
41
|
+
if i < 0 or i >= half:
|
|
42
|
+
raise ValueError(f"local index must be in [0, {half - 1}] for dual dim={dim}, got {i}")
|
|
43
|
+
if j < 0 or j >= half:
|
|
44
|
+
raise ValueError(f"local index must be in [0, {half - 1}] for dual dim={dim}, got {j}")
|
|
45
|
+
|
|
46
|
+
i_eps = bool(i_eps_flag)
|
|
47
|
+
j_eps = bool(j_eps_flag)
|
|
48
|
+
|
|
49
|
+
# Nilpotency: eps^2 = 0
|
|
175
50
|
if i_eps and j_eps:
|
|
176
51
|
return (0, 0, 0)
|
|
177
52
|
|
|
178
|
-
#
|
|
179
|
-
# Base multiplication
|
|
180
|
-
# --------------------------------------------------------------
|
|
53
|
+
# Base multiplication (parent algebra)
|
|
181
54
|
if self._split_mode:
|
|
182
|
-
base_sign, local_idx = self._split.multiply_indices(
|
|
55
|
+
base_sign, local_idx = self._split.multiply_indices(i, j, dim)
|
|
183
56
|
else:
|
|
184
|
-
base_sign, local_idx = self._standard.multiply_indices(
|
|
57
|
+
base_sign, local_idx = self._standard.multiply_indices(i, j)
|
|
185
58
|
|
|
186
59
|
eps_flag = 1 if (i_eps or j_eps) else 0
|
|
187
|
-
|
|
188
60
|
return (base_sign, local_idx, eps_flag)
|
|
@@ -2,25 +2,10 @@ from ..validation import Validation
|
|
|
2
2
|
from .standard import StandardHolographic
|
|
3
3
|
from .split import SplitHolographic
|
|
4
4
|
|
|
5
|
-
|
|
6
5
|
class DualHolographic:
|
|
7
6
|
"""
|
|
8
7
|
Dual Cayley-Dickson holographic multiplier.
|
|
9
|
-
|
|
10
|
-
Input index convention:
|
|
11
|
-
The total dual dimension is 2^(dim + 1).
|
|
12
|
-
Bit `dim` marks the epsilon component.
|
|
13
|
-
|
|
14
|
-
lower half: 0 ... 2^dim - 1
|
|
15
|
-
upper half: epsilon times lower half
|
|
16
|
-
|
|
17
|
-
Output:
|
|
18
|
-
(sign, local_index, eps_flag)
|
|
19
|
-
|
|
20
|
-
Nilpotency:
|
|
21
|
-
(epsilon e_i) * (epsilon e_j) = 0
|
|
22
|
-
returned as the canonical zero (0, 0, 0), matching FastDual
|
|
23
|
-
and DualTableBuilder
|
|
8
|
+
STRICT 3-TUPLE INPUT: (sign, local_index, eps_flag)
|
|
24
9
|
"""
|
|
25
10
|
|
|
26
11
|
def __init__(self, split: bool = False):
|
|
@@ -29,62 +14,37 @@ class DualHolographic:
|
|
|
29
14
|
self._split = SplitHolographic() if self._split_mode else None
|
|
30
15
|
|
|
31
16
|
def multiply(self, t1: tuple, t2: tuple, dim: int) -> tuple:
|
|
32
|
-
"""
|
|
33
|
-
Multiply two dual basis elements.
|
|
34
|
-
|
|
35
|
-
t1, t2 may be:
|
|
36
|
-
(sign, global_index)
|
|
37
|
-
(sign, global_index, eps_flag)
|
|
38
|
-
|
|
39
|
-
The epsilon component is determined by bit `dim` of global_index.
|
|
40
|
-
|
|
41
|
-
Returns:
|
|
42
|
-
(final_sign, local_index, eps_flag)
|
|
43
|
-
"""
|
|
44
17
|
Validation.basis_tuple(t1, allow_zero=True, allow_eps=True)
|
|
45
18
|
Validation.basis_tuple(t2, allow_zero=True, allow_eps=True)
|
|
46
|
-
|
|
47
19
|
dim = Validation.dimension(dim)
|
|
48
20
|
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
|
|
53
|
-
# Zero propagates.
|
|
21
|
+
# STRICT 3-TUPLE UNPACKING
|
|
22
|
+
s1, i, i_eps_flag = int(t1[0]), int(t1[1]), int(t1[2])
|
|
23
|
+
s2, j, j_eps_flag = int(t2[0]), int(t2[1]), int(t2[2])
|
|
24
|
+
|
|
54
25
|
if s1 == 0 or s2 == 0:
|
|
55
26
|
return (0, 0, 0)
|
|
56
27
|
|
|
57
|
-
total_size = 1 << (dim + 1)
|
|
58
|
-
|
|
59
|
-
if i < 0 or i >= total_size:
|
|
60
|
-
raise ValueError(f"index must be in [0, {total_size - 1}] for dual dim={dim}, got {i}")
|
|
61
|
-
|
|
62
|
-
if j < 0 or j >= total_size:
|
|
63
|
-
raise ValueError(f"index must be in [0, {total_size - 1}] for dual dim={dim}, got {j}")
|
|
64
|
-
|
|
65
28
|
half = 1 << dim
|
|
29
|
+
|
|
30
|
+
# STRICT LOCAL ENFORCEMENT
|
|
31
|
+
if i < 0 or i >= half:
|
|
32
|
+
raise ValueError(f"local index must be in [0, {half - 1}] for dual dim={dim}, got {i}")
|
|
33
|
+
if j < 0 or j >= half:
|
|
34
|
+
raise ValueError(f"local index must be in [0, {half - 1}] for dual dim={dim}, got {j}")
|
|
66
35
|
|
|
67
|
-
i_eps =
|
|
68
|
-
j_eps =
|
|
69
|
-
|
|
70
|
-
i_loc = i & (half - 1)
|
|
71
|
-
j_loc = j & (half - 1)
|
|
36
|
+
i_eps = bool(i_eps_flag)
|
|
37
|
+
j_eps = bool(j_eps_flag)
|
|
72
38
|
|
|
73
|
-
#
|
|
74
|
-
# Epsilon nilpotency:
|
|
75
|
-
# (epsilon e_i) * (epsilon e_j) = 0
|
|
76
|
-
# --------------------------------------------------------------
|
|
39
|
+
# Nilpotency
|
|
77
40
|
if i_eps and j_eps:
|
|
78
41
|
return (0, 0, 0)
|
|
79
42
|
|
|
80
|
-
#
|
|
81
|
-
# Base multiplication.
|
|
82
|
-
# --------------------------------------------------------------
|
|
43
|
+
# Base multiplication
|
|
83
44
|
if self._split_mode:
|
|
84
|
-
base_sign, local_idx = self._split.multiply_indices(
|
|
45
|
+
base_sign, local_idx = self._split.multiply_indices(i, j, dim)
|
|
85
46
|
else:
|
|
86
|
-
base_sign, local_idx = self._standard.multiply_indices(
|
|
47
|
+
base_sign, local_idx = self._standard.multiply_indices(i, j)
|
|
87
48
|
|
|
88
49
|
eps_flag = 1 if (i_eps or j_eps) else 0
|
|
89
|
-
|
|
90
50
|
return (s1 * s2 * base_sign, local_idx, eps_flag)
|
|
@@ -54,12 +54,12 @@ class Validation:
|
|
|
54
54
|
if not isinstance(data, tuple):
|
|
55
55
|
raise TypeError(f"Expected tuple, got {type(data).__name__}")
|
|
56
56
|
|
|
57
|
-
if
|
|
58
|
-
|
|
59
|
-
|
|
60
|
-
|
|
61
|
-
|
|
62
|
-
|
|
57
|
+
if allow_eps:
|
|
58
|
+
if len(data) != 3:
|
|
59
|
+
raise ValueError(f"Dual basis tuple must have length 3 (sign, index, eps), got {len(data)}")
|
|
60
|
+
else:
|
|
61
|
+
if len(data) != 2:
|
|
62
|
+
raise ValueError(f"Standard/Split basis tuple must have length 2 (sign, index), got {len(data)}")
|
|
63
63
|
|
|
64
64
|
sign = data[0]
|
|
65
65
|
index = data[1]
|
|
@@ -0,0 +1,118 @@
|
|
|
1
|
+
import numpy as np
|
|
2
|
+
from ..validation import Validation
|
|
3
|
+
|
|
4
|
+
class VectorizedStandard:
|
|
5
|
+
"""
|
|
6
|
+
SIMD-Accelerated O(1) Vectorized Multiplier for Standard Cayley-Dickson Algebras.
|
|
7
|
+
Replaces nested Python loops with C-Level Twisted Convolution via Scatter-Add.
|
|
8
|
+
"""
|
|
9
|
+
|
|
10
|
+
@staticmethod
|
|
11
|
+
def _get_np_popcount():
|
|
12
|
+
"""Hardware-accelerated popcount for NumPy arrays."""
|
|
13
|
+
try:
|
|
14
|
+
return np.bitwise_count
|
|
15
|
+
except AttributeError:
|
|
16
|
+
def popcount_vec(x):
|
|
17
|
+
x = np.asarray(x, dtype=np.uint64)
|
|
18
|
+
x = x - ((x >> 1) & np.uint64(0x5555555555555555))
|
|
19
|
+
x = (x & np.uint64(0x3333333333333333)) + ((x >> 2) & np.uint64(0x3333333333333333))
|
|
20
|
+
x = (x + (x >> 4)) & np.uint64(0x0F0F0F0F0F0F0F0F)
|
|
21
|
+
return ((x * np.uint64(0x0101010101010101)) >> np.uint64(56)).astype(np.uint8)
|
|
22
|
+
return popcount_vec
|
|
23
|
+
|
|
24
|
+
def multiply_indices_vec(self, i_arr: np.ndarray, j_arr: np.ndarray) -> tuple:
|
|
25
|
+
"""
|
|
26
|
+
Vectorized Core O(1) multiplication for arrays of indices.
|
|
27
|
+
Returns: (signs_array, indices_array)
|
|
28
|
+
"""
|
|
29
|
+
_popcount = self._get_np_popcount()
|
|
30
|
+
i = np.asarray(i_arr, dtype=np.uint64)
|
|
31
|
+
j = np.asarray(j_arr, dtype=np.uint64)
|
|
32
|
+
|
|
33
|
+
# Target index is always XOR
|
|
34
|
+
idx = i ^ j
|
|
35
|
+
|
|
36
|
+
# Masks for structural cases
|
|
37
|
+
mask_zero = (i == 0) | (j == 0)
|
|
38
|
+
mask_diag = (i == j) & ~mask_zero
|
|
39
|
+
|
|
40
|
+
# Safe guards for nu2 (avoid log2(0) or popcount(-1) issues)
|
|
41
|
+
i_safe = np.where(i == 0, 1, i)
|
|
42
|
+
j_safe = np.where(j == 0, 1, j)
|
|
43
|
+
ij_safe = np.where((i ^ j) == 0, 1, i ^ j)
|
|
44
|
+
|
|
45
|
+
# Vectorized nu2: popcount((x & -x) - 1)
|
|
46
|
+
t = _popcount((ij_safe & -ij_safe) - np.uint64(1)).astype(np.uint64)
|
|
47
|
+
ti = _popcount((i_safe & -i_safe) - np.uint64(1)).astype(np.uint64)
|
|
48
|
+
tj = _popcount((j_safe & -j_safe) - np.uint64(1)).astype(np.uint64)
|
|
49
|
+
|
|
50
|
+
# Branch 1: Diagonal break (t >= ti and t >= tj)
|
|
51
|
+
cond1 = (t >= ti) & (t >= tj)
|
|
52
|
+
s1 = 2 * ((i >> t) & np.uint64(1)).astype(np.int8) - 1
|
|
53
|
+
|
|
54
|
+
# Branch 2: i-axis break (ti > t and ti >= tj)
|
|
55
|
+
cond2 = (~cond1) & (ti >= tj)
|
|
56
|
+
b = (j >> ti) & np.uint64(1)
|
|
57
|
+
j_loc = j & ((np.uint64(1) << ti) - np.uint64(1))
|
|
58
|
+
delta = np.where(j_loc == 0, 1, -1).astype(np.int8)
|
|
59
|
+
s2 = np.where(b == 0, delta, -delta)
|
|
60
|
+
|
|
61
|
+
# Branch 3: j-axis break (tj > t and tj > ti)
|
|
62
|
+
cond3 = ~cond1 & ~cond2
|
|
63
|
+
s3 = 1 - 2 * ((i >> tj) & np.uint64(1)).astype(np.int8)
|
|
64
|
+
|
|
65
|
+
# Combine branches
|
|
66
|
+
s = np.where(cond1, s1, np.where(cond2, s2, s3))
|
|
67
|
+
|
|
68
|
+
# Higher-bit parity correction
|
|
69
|
+
k = np.maximum(np.maximum(t, ti), tj) + np.uint64(1)
|
|
70
|
+
parity = _popcount((i | j) >> k) & np.uint8(1)
|
|
71
|
+
s = np.where(parity == 1, -s, s)
|
|
72
|
+
|
|
73
|
+
# Apply structural overrides
|
|
74
|
+
s = np.where(mask_zero, 1, s)
|
|
75
|
+
s = np.where(mask_diag, -1, s)
|
|
76
|
+
|
|
77
|
+
return s.astype(np.int8), idx
|
|
78
|
+
|
|
79
|
+
def multiply_arrays(self, arr1: np.ndarray, arr2: np.ndarray) -> np.ndarray:
|
|
80
|
+
"""
|
|
81
|
+
Full polynomial multiplication using Twisted Convolution via C-Level Scatter-Add.
|
|
82
|
+
Automatically handles sparsity to prevent RAM explosion on high dimensions.
|
|
83
|
+
"""
|
|
84
|
+
size1 = len(arr1)
|
|
85
|
+
size2 = len(arr2)
|
|
86
|
+
max_size = max(size1, size2)
|
|
87
|
+
|
|
88
|
+
if max_size <= 1:
|
|
89
|
+
return np.array([arr1[0] * arr2[0]], dtype=np.float64) if size1 > 0 and size2 > 0 else np.zeros(1, dtype=np.float64)
|
|
90
|
+
|
|
91
|
+
# Calculate required power-of-two dimension
|
|
92
|
+
# Equivalent to 1 << math.ceil(math.log2(max_size))
|
|
93
|
+
dim = 1 << (max_size - 1).bit_length()
|
|
94
|
+
|
|
95
|
+
# 1. SPARSE OPTIMIZATION: Isolate non-zero elements
|
|
96
|
+
nz_A = np.nonzero(arr1)[0]
|
|
97
|
+
nz_B = np.nonzero(arr2)[0]
|
|
98
|
+
|
|
99
|
+
if len(nz_A) == 0 or len(nz_B) == 0:
|
|
100
|
+
return np.zeros(dim, dtype=np.float64)
|
|
101
|
+
|
|
102
|
+
# 2. Create the 2D Grid of ONLY the active indices
|
|
103
|
+
I, J = np.meshgrid(nz_A, nz_B, indexing='ij')
|
|
104
|
+
|
|
105
|
+
# 3. Calculate the entire Sign and Index Matrix in one C-level SIMD sweep
|
|
106
|
+
S, V = self.multiply_indices_vec(I, J)
|
|
107
|
+
|
|
108
|
+
# 4. Calculate the Outer Product of ONLY the active coefficients
|
|
109
|
+
M = np.outer(arr1[nz_A], arr2[nz_B])
|
|
110
|
+
|
|
111
|
+
# 5. Apply Signs to the Coefficients
|
|
112
|
+
weighted_M = S.astype(np.float64) * M
|
|
113
|
+
|
|
114
|
+
# 6. C-Level Scatter-Add into the Result Array
|
|
115
|
+
result = np.zeros(dim, dtype=np.float64)
|
|
116
|
+
np.add.at(result, V.ravel(), weighted_M.ravel())
|
|
117
|
+
|
|
118
|
+
return result
|
hypercomplex_engine/facade.py
CHANGED
|
@@ -126,33 +126,6 @@ def _unpack_table(table):
|
|
|
126
126
|
)
|
|
127
127
|
|
|
128
128
|
|
|
129
|
-
def _as_dual_global(t: tuple, dim: int) -> tuple:
|
|
130
|
-
"""
|
|
131
|
-
Converts a dual input tuple into a global 2-tuple.
|
|
132
|
-
|
|
133
|
-
Accepts:
|
|
134
|
-
(sign, global_index)
|
|
135
|
-
(sign, local_index, eps_flag)
|
|
136
|
-
|
|
137
|
-
Returns:
|
|
138
|
-
(sign, global_index)
|
|
139
|
-
"""
|
|
140
|
-
sign = int(t[0])
|
|
141
|
-
idx = int(t[1])
|
|
142
|
-
|
|
143
|
-
if sign == 0:
|
|
144
|
-
return (0, 0)
|
|
145
|
-
|
|
146
|
-
half = 1 << Validation.dimension(dim)
|
|
147
|
-
|
|
148
|
-
if len(t) >= 3:
|
|
149
|
-
eps = int(t[2])
|
|
150
|
-
|
|
151
|
-
if eps == 1 and idx < half:
|
|
152
|
-
idx += half
|
|
153
|
-
|
|
154
|
-
return (sign, idx)
|
|
155
|
-
|
|
156
129
|
|
|
157
130
|
# ----------------------------------------------------------------------
|
|
158
131
|
# Public simple API
|
|
@@ -280,11 +253,9 @@ def multiply(
|
|
|
280
253
|
return (0, 0, 0)
|
|
281
254
|
return (0, 0)
|
|
282
255
|
|
|
283
|
-
# Dual inputs
|
|
284
|
-
|
|
285
|
-
|
|
286
|
-
b = _as_dual_global(b, dim)
|
|
287
|
-
|
|
256
|
+
# Dual inputs are strictly local 3-tuples: (sign, local_index, eps_flag).
|
|
257
|
+
# We pass them directly to the engines. No global overflow conversion needed.
|
|
258
|
+
|
|
288
259
|
# ------------------------------------------------------------------
|
|
289
260
|
# O(1) engine
|
|
290
261
|
# ------------------------------------------------------------------
|
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
Metadata-Version: 2.4
|
|
2
2
|
Name: hypercomplex-engine
|
|
3
|
-
Version: 0.
|
|
3
|
+
Version: 0.6.0
|
|
4
4
|
Summary: Fast O(1)/O(n) multiplication engine for arbitrary dimensions and table generator for ordinary, split, and dual Cayley-Dickson algebras.
|
|
5
5
|
Author-email: Maher Ben Abdessalem <ba.maher94@gmail.com>
|
|
6
6
|
License-Expression: Apache-2.0
|
|
@@ -18,6 +18,7 @@ Classifier: Programming Language :: Python :: 3.11
|
|
|
18
18
|
Classifier: Programming Language :: Python :: 3.12
|
|
19
19
|
Classifier: Programming Language :: Python :: 3.13
|
|
20
20
|
Classifier: Programming Language :: Python :: 3.14
|
|
21
|
+
Classifier: Programming Language :: Python :: 3.15
|
|
21
22
|
Classifier: Operating System :: OS Independent
|
|
22
23
|
Requires-Python: >=3.10
|
|
23
24
|
Description-Content-Type: text/markdown
|
|
@@ -1123,6 +1124,7 @@ doi = "10.6084/m9.figshare.33705022.v8"
|
|
|
1123
1124
|
|
|
1124
1125
|
```
|
|
1125
1126
|
|
|
1127
|
+
|
|
1126
1128
|
### Acknowledgments
|
|
1127
1129
|
|
|
1128
1130
|
The author gratefully acknowledges **Prof. Derek Abbott**, **Dr. James M. Chappell**, and PhD candidate **Greg P. Wilmot** from the University of Adelaide, Australia, for the opportunity of collaboration and a deeper study of hypercomplex numbers. Special thanks go to **Greg P. Wilmot** for his work on the structure of Cayley-Dickson algebras and for acknowledging the author's contribution to his paper, *"Structure of the Cayley-Dickson algebras"* ([arXiv:2505.11747](https://arxiv.org)).
|
|
@@ -1,16 +1,16 @@
|
|
|
1
|
-
hypercomplex_engine/__init__.py,sha256=
|
|
2
|
-
hypercomplex_engine/facade.py,sha256
|
|
3
|
-
hypercomplex_engine/core/__init__.py,sha256=
|
|
1
|
+
hypercomplex_engine/__init__.py,sha256=DWb_oW6Qvr3Js-1wvdTW7ox7aJP1ci_LPDZ5vK95VNM,1321
|
|
2
|
+
hypercomplex_engine/facade.py,sha256=Rw0GyrZJMs1fkdZzLwwjIdZAvid4XmDGJEM-G7fOG_k,9192
|
|
3
|
+
hypercomplex_engine/core/__init__.py,sha256=VMszCgYLjMFSzcsdTPGnkJusM12iVow4aeazsPklWjU,747
|
|
4
4
|
hypercomplex_engine/core/basis_element.py,sha256=TnPb1xLICv0TK0AfTW_I8_8T2TavktKTq4MEPLWnyU8,1402
|
|
5
5
|
hypercomplex_engine/core/basis_notation.py,sha256=K17IUXEio7KmY3pvpFdDFI2MsLs11-E5Z5Cp10CS84Y,4887
|
|
6
|
-
hypercomplex_engine/core/validation.py,sha256=
|
|
6
|
+
hypercomplex_engine/core/validation.py,sha256=VThGdXzESoiOO1y6Ios-GcEyHGdbi8V9_fMmEEExkqw,3245
|
|
7
7
|
hypercomplex_engine/core/fast/__init__.py,sha256=6KsWo1dhNlT69jT_Bi8-khOrNFX9cDs98987TGTXo4w,173
|
|
8
|
-
hypercomplex_engine/core/fast/bit_utils.py,sha256=
|
|
9
|
-
hypercomplex_engine/core/fast/fast_dual.py,sha256=
|
|
8
|
+
hypercomplex_engine/core/fast/bit_utils.py,sha256=U8jmGRKB8tymSyyhCMMwEL5Ap2vUfrZTDyrTutVrB8k,448
|
|
9
|
+
hypercomplex_engine/core/fast/fast_dual.py,sha256=zQSMvXCNQgI_ZhmNEkds0_VbpNzFxS0476NfH2Qyfro,2098
|
|
10
10
|
hypercomplex_engine/core/fast/fast_split.py,sha256=Wdr9pd9zXA_mFzlMxVv8LpPwDZJFP-XPVa0uQIEs3jA,3037
|
|
11
11
|
hypercomplex_engine/core/fast/fast_standard.py,sha256=JQ7Mxb4qQTH6EuWQjpTtbxwb4rVI0Iu-jggHiwmEj1I,3250
|
|
12
12
|
hypercomplex_engine/core/holographic/__init__.py,sha256=TGMyPs6dyeaQ9I--rFooBOrKzkex73IbwzQtL7Q0i04,200
|
|
13
|
-
hypercomplex_engine/core/holographic/dual.py,sha256=
|
|
13
|
+
hypercomplex_engine/core/holographic/dual.py,sha256=LyxA4zpr6fUlD-ZckLYQGH_FAu9Xf8FOGyYo6c_5kyk,1731
|
|
14
14
|
hypercomplex_engine/core/holographic/split.py,sha256=kJXPXvw3rT8YieENor0hNTko4qBoXaKKb9n07UWhfQY,2864
|
|
15
15
|
hypercomplex_engine/core/holographic/standard.py,sha256=nNgM0QxvWXVMlTenHdxKd63RvLOkF_xu1cB0f00EumA,3935
|
|
16
16
|
hypercomplex_engine/core/table_builder/__init__.py,sha256=qkKJQ1S44hlSeNdW-Cc9REvbCeU2K646pkCalV9Sft4,206
|
|
@@ -18,12 +18,14 @@ hypercomplex_engine/core/table_builder/common.py,sha256=PEY_Vd0_tYrDJt5IOqEvrex3
|
|
|
18
18
|
hypercomplex_engine/core/table_builder/dual.py,sha256=9flbYGsCnZeKMirS3JlDg__EqSv_LBA1M_JhWPQEWxw,2888
|
|
19
19
|
hypercomplex_engine/core/table_builder/split.py,sha256=OUBNKT_-L6BMlCxiSYWzAOGSOdYGJZzLOR0Zo6R5Ubw,2923
|
|
20
20
|
hypercomplex_engine/core/table_builder/standard.py,sha256=3kyg4TLCG_LKhC8lT95hZBFmOee0Wg39T7CDIhayVUs,2820
|
|
21
|
+
hypercomplex_engine/core/vectorized/__init__.py,sha256=NfwXNqe9n8acZaMTquuXH5BLB-fbmCUDvKAB5rcWrOE,92
|
|
22
|
+
hypercomplex_engine/core/vectorized/vectorized_standard.py,sha256=yCV48LvwrMZxg8Rc4UYLejg7uZxhoyjfknWxqfL3rwo,4656
|
|
21
23
|
hypercomplex_engine/printer/__init__.py,sha256=6EZOUBYb9TDgfqrFpnIfPS1bbPFZ0dMX6RCPDZepL6M,129
|
|
22
24
|
hypercomplex_engine/printer/cd_format.py,sha256=X_cotGumJlRMuJO5cbsnI8FA9Py12TGYftPlUdx-9xg,5731
|
|
23
25
|
hypercomplex_engine/printer/cd_table_printer.py,sha256=Ny1g5osDwttI5I8-KV4DzhVhWp_7fP-R5lYyC9sEhKE,4973
|
|
24
|
-
hypercomplex_engine-0.
|
|
25
|
-
hypercomplex_engine-0.
|
|
26
|
-
hypercomplex_engine-0.
|
|
27
|
-
hypercomplex_engine-0.
|
|
28
|
-
hypercomplex_engine-0.
|
|
29
|
-
hypercomplex_engine-0.
|
|
26
|
+
hypercomplex_engine-0.6.0.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
|
|
27
|
+
hypercomplex_engine-0.6.0.dist-info/licenses/NOTICE,sha256=WRgJ9Hv74Vke3ByFbvR6sqdlinPx4rCWDc0-7Iyh9VI,745
|
|
28
|
+
hypercomplex_engine-0.6.0.dist-info/METADATA,sha256=-xOkrkRP_H__kmTQ3BLBl_t8SghUkReStNVHtcweCaY,26289
|
|
29
|
+
hypercomplex_engine-0.6.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
|
|
30
|
+
hypercomplex_engine-0.6.0.dist-info/top_level.txt,sha256=654ACRoo9vk38vKW7kVBfgD-IjIADgVmh75smmXBZ88,20
|
|
31
|
+
hypercomplex_engine-0.6.0.dist-info/RECORD,,
|
|
File without changes
|
{hypercomplex_engine-0.4.2.7.dist-info → hypercomplex_engine-0.6.0.dist-info}/licenses/LICENSE
RENAMED
|
File without changes
|
{hypercomplex_engine-0.4.2.7.dist-info → hypercomplex_engine-0.6.0.dist-info}/licenses/NOTICE
RENAMED
|
File without changes
|
|
File without changes
|