qualia_core_db/solvers/geometric_algebra/
mod.rs1use crate::q_hash;
7
8pub mod simd_kernel;
9
10pub use simd_kernel::{
12 apply_rotor, apply_translator, geometric_product, is_simd_available, outer_product,
13 rotor_from_angle_axis, translator_from_displacement, Grade, Multivector, Rotor, Translator,
14};
15
16pub mod constants {
18 pub const GA_EPSILON: f32 = 1e-6;
20
21 pub const MAX_DIMENSION: usize = 4;
23
24 pub const GA3D_COMPONENTS: usize = 8;
26
27 pub const GA4D_COMPONENTS: usize = 16;
29}
30
31pub mod utils {
33 use super::*;
34
35 pub fn deg_to_rad(degrees: f32) -> f32 {
37 degrees * std::f32::consts::PI / 180.0
38 }
39
40 pub fn rad_to_deg(radians: f32) -> f32 {
42 radians * 180.0 / std::f32::consts::PI
43 }
44
45 pub fn normalize_vector(v: &[f32; 3]) -> [f32; 3] {
47 let mag = (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]).sqrt();
48 if mag > constants::GA_EPSILON {
49 [v[0] / mag, v[1] / mag, v[2] / mag]
50 } else {
51 *v
52 }
53 }
54
55 pub fn cross_product(a: &[f32; 3], b: &[f32; 3]) -> [f32; 3] {
57 [
58 a[1] * b[2] - a[2] * b[1],
59 a[2] * b[0] - a[0] * b[2],
60 a[0] * b[1] - a[1] * b[0],
61 ]
62 }
63
64 pub fn dot_product(a: &[f32; 3], b: &[f32; 3]) -> f32 {
66 a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
67 }
68
69 pub fn angle_between_vectors(a: &[f32; 3], b: &[f32; 3]) -> f32 {
71 let mag_a = (a[0] * a[0] + a[1] * a[1] + a[2] * a[2]).sqrt();
72 let mag_b = (b[0] * b[0] + b[1] * b[1] + b[2] * b[2]).sqrt();
73
74 if mag_a > constants::GA_EPSILON && mag_b > constants::GA_EPSILON {
75 let cos_angle = dot_product(a, b) / (mag_a * mag_b);
76 cos_angle.clamp(-1.0, 1.0).acos()
77 } else {
78 0.0
79 }
80 }
81}
82
83pub mod qualia_integration {
85 use super::*;
86 use crate::NQuin;
87
88 pub fn multivector_to_quin(mv: &Multivector, context: u64) -> NQuin {
90 let scalar_bytes = mv.get_scalar().to_le_bytes();
94 let scalar_hex = format!(
95 "{:02x}{:02x}{:02x}{:02x}",
96 scalar_bytes[0], scalar_bytes[1], scalar_bytes[2], scalar_bytes[3]
97 );
98 let scalar_hash = q_hash(&scalar_hex);
99 let vector_bytes: Vec<u8> = mv
100 .to_vector()
101 .iter()
102 .flat_map(|f| f.to_le_bytes().to_vec())
103 .collect();
104 let vector_hex: String = vector_bytes.iter().map(|b| format!("{:02x}", b)).collect();
105 let vector_hash = q_hash(&vector_hex);
106
107 let combined_hash = scalar_hash ^ vector_hash;
109 let scalar_bits = mv.get_scalar().to_bits() as u64;
110 let parity = combined_hash ^ q_hash("q42:multivector") ^ scalar_bits ^ context;
111
112 NQuin {
113 subject: combined_hash,
114 predicate: q_hash("q42:multivector"),
115 object: scalar_bits,
116 context,
117 metadata: mv.grade_mask() as u64,
118 parity,
119 }
120 }
121
122 pub fn quin_to_multivector(quin: &NQuin) -> Option<Multivector> {
124 if quin.predicate == q_hash("q42:multivector") {
125 let scalar = f32::from_bits((quin.object & 0xFFFF_FFFF) as u32);
126 Some(Multivector::scalar(scalar))
127 } else {
128 None
129 }
130 }
131
132 pub fn geometric_operation_quin(
134 operation: &str,
135 operand_a: u64,
136 operand_b: u64,
137 context: u64,
138 ) -> NQuin {
139 NQuin {
140 subject: operand_a,
141 predicate: q_hash(&format!("q42:ga:{}", operation)),
142 object: operand_b,
143 context,
144 metadata: q_hash("geometric_operation"),
145 parity: 0,
146 }
147 }
148}
149
150pub mod benchmarks {
152 use super::*;
153 use std::time::Instant;
154
155 pub fn benchmark_geometric_product(iterations: usize) -> (f64, bool) {
157 let a = Multivector::vector(1.0, 2.0, 3.0);
158 let b = Multivector::vector(4.0, 5.0, 6.0);
159
160 let start = Instant::now();
161
162 for _ in 0..iterations {
163 let _result = geometric_product(&a, &b);
164 }
165
166 let duration = start.elapsed();
167 let ops_per_second = iterations as f64 / duration.as_secs_f64();
168
169 (ops_per_second, is_simd_available())
170 }
171
172 pub fn benchmark_rotor_application(iterations: usize) -> (f64, bool) {
174 let rotor = rotor_from_angle_axis(std::f32::consts::PI / 4.0, [0.0, 0.0, 1.0]);
175 let vector = [1.0, 0.0, 0.0];
176
177 let start = Instant::now();
178
179 for _ in 0..iterations {
180 let _result = apply_rotor(&rotor, &vector);
181 }
182
183 let duration = start.elapsed();
184 let ops_per_second = iterations as f64 / duration.as_secs_f64();
185
186 (ops_per_second, is_simd_available())
187 }
188
189 pub fn run_benchmarks() {
191 const ITERATIONS: usize = 1_000_000;
192
193 println!("Geometric Algebra Performance Benchmarks");
194 println!("==========================================");
195
196 let (gp_ops, simd_enabled) = benchmark_geometric_product(ITERATIONS);
197 println!(
198 "Geometric Product: {:.2} ops/sec (SIMD: {})",
199 gp_ops, simd_enabled
200 );
201
202 let (rotor_ops, _) = benchmark_rotor_application(ITERATIONS);
203 println!("Rotor Application: {:.2} ops/sec", rotor_ops);
204
205 println!("SIMD Available: {}", is_simd_available());
206 }
207}
208
209#[cfg(test)]
210mod integration_tests {
211 use super::utils::*;
212 use super::*;
213
214 #[test]
215 fn test_utility_functions() {
216 let v1 = [1.0, 0.0, 0.0];
217 let v2 = [0.0, 1.0, 0.0];
218
219 let cross = cross_product(&v1, &v2);
220 assert_eq!(cross, [0.0, 0.0, 1.0]);
221
222 let dot = dot_product(&v1, &v2);
223 assert_eq!(dot, 0.0);
224
225 let angle = angle_between_vectors(&v1, &v2);
226 assert!((angle - std::f32::consts::PI / 2.0).abs() < constants::GA_EPSILON);
227 }
228
229 #[test]
230 fn test_degree_radian_conversion() {
231 let deg = 180.0;
232 let rad = deg_to_rad(deg);
233 assert!((rad - std::f32::consts::PI).abs() < constants::GA_EPSILON);
234
235 let back_to_deg = rad_to_deg(rad);
236 assert!((back_to_deg - deg).abs() < constants::GA_EPSILON);
237 }
238
239 #[test]
240 fn test_vector_normalization() {
241 let v = [3.0, 4.0, 0.0];
242 let normalized = normalize_vector(&v);
243 let mag = (normalized[0].powi(2) + normalized[1].powi(2) + normalized[2].powi(2)).sqrt();
244 assert!((mag - 1.0).abs() < constants::GA_EPSILON);
245 }
246
247 #[test]
248 fn test_qualia_integration() {
249 let mv = Multivector::vector(1.0, 2.0, 3.0);
250 let context = q_hash("test_context");
251
252 let quin = qualia_integration::multivector_to_quin(&mv, context);
253 assert_eq!(quin.context, context);
254 assert_eq!(quin.predicate, q_hash("q42:multivector"));
255 }
256
257 #[test]
258 fn test_comprehensive_operations() {
259 let rotor1 = rotor_from_angle_axis(deg_to_rad(45.0), [0.0, 0.0, 1.0]);
263 let rotor2 = rotor_from_angle_axis(deg_to_rad(30.0), [0.0, 1.0, 0.0]);
264
265 let vector = [1.0, 0.0, 0.0];
266 let rotated1 = apply_rotor(&rotor1, &vector);
267 let rotated2 = apply_rotor(&rotor2, &rotated1);
268
269 let mag = (rotated2[0].powi(2) + rotated2[1].powi(2) + rotated2[2].powi(2)).sqrt();
271 assert!((mag - 1.0).abs() < constants::GA_EPSILON);
272
273 let trans1 = translator_from_displacement([1.0, 2.0, 3.0]);
275 let trans2 = translator_from_displacement([4.0, 5.0, 6.0]);
276
277 let origin = [0.0, 0.0, 0.0];
278 let translated1 = apply_translator(&trans1, &origin);
279 let translated2 = apply_translator(&trans2, &translated1);
280
281 assert_eq!(translated2, [5.0, 7.0, 9.0]);
282 }
283}