experimenting with multivectors

[mxfactorial]

you have a multivector calc in here: https://github.com/peeterjoot/physicsplay/blob/master/programming/sym/gasym.cpp

try recently published https://crates.io/crates/geonum

git clone https://github.com/mxfactorial/geonum.git && cd geonum && cargo test --test '*' -- --show-output

example test: https://github.com/mxfactorial/geonum/blob/e7daaded850089778ab4111056f38770716435d4/tests/lib_test.rs#L408-L678

[mxfactorial]

peter not many people are familiar with multivectors and how much more work they can perform for apps currently choking on tensor math, eg https://github.com/psc-g/psc-g.github.io/pull/4/files

while people can learn about multivectors by running geonum tests

you can put your ga hobby to greater use by helping explain why multivectors as a workhorse unlocks unprecedented compute for important apps (more like tensorclog)

[mxfactorial]

git clone https://github.com/mxfactorial/geonum && cd geonum && cargo test --test multivector_test it_operates_on_high_dimensional_multivectors

running 1 test
test it_operates_on_high_dimensional_multivectors ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 2 filtered out; finished in 0.00s

https://github.com/mxfactorial/geonum/blob/develop/tests/multivector_test.rs

use geonum::*;
use std::f64::consts::PI;
use std::f64::consts::TAU;

#[test]
fn it_operates_on_high_dimensional_multivectors() {
    let space = Dimensions::new(1_000);

    // basis vectors with distinct angles to avoid wedge collapse
    let e1 = Geonum {
        length: 1.0,
        angle: space.base_angle(0),
        blade: 1,
    }; // angle 0, grade 1
    let e2 = Geonum {
        length: 1.0,
        angle: space.base_angle(1),
        blade: 1,
    }; // angle π/2, grade 1
    let e3 = Geonum {
        length: 1.0,
        angle: space.base_angle(3),
        blade: 1,
    }; // angle 3π/2, grade 1

    // step 1: construct bivector B = e1 ∧ e2
    let b12 = e1.wedge(&e2);
    let b12_mv = Multivector(vec![b12]);

    // assert bivector lives in grade 2
    let g2 = b12_mv.grade_range([2, 2]);
    assert!(g2.0.iter().any(|g| g.length > 0.0));

    // step 2: trivector T = (e1 ∧ e2) ∧ e3
    // create e3 as multivector
    let e3_mv = Multivector(vec![e3]);

    // ensure e3 has a different angle from the bivector to prevent wedge collapse
    let e3_rotated = Geonum {
        length: 1.0,
        angle: PI / 4.0,
        blade: 1,
    };

    // create trivector directly using wedge product between b12 and e3_rotated
    let t123 = b12.wedge(&e3_rotated);
    let t123_mv = Multivector(vec![t123]);

    // assert trivector has a nonzero component in grade 3
    let g3 = t123_mv.grade_range([3, 3]);
    assert!(g3.0.iter().any(|g| g.length > 0.0));

    // step 3: reflect e3 across bivector plane
    let reflected = e3_mv.reflect(&b12_mv);
    assert!(!reflected.0.is_empty());

    // step 4: compute dual of trivector and test result
    let pseudo = Multivector(vec![Geonum {
        length: 1.0,
        angle: PI / 2.0,
        blade: 1000,
    }]); // dummy pseudoscalar with high dimension
    let dual = t123_mv.dual(&pseudo);
    assert!(dual.0.iter().any(|g| g.length > 0.0));

    // step 5: rotate a vector using bivector rotor
    let v = Geonum {
        length: 1.0,
        angle: PI / 4.0,
        blade: 1,
    };
    let v_mv = Multivector(vec![v]);
    let rotated = v_mv.rotate(&b12_mv);
    assert!(rotated.0.iter().any(|g| g.length > 0.0));

    // step 6: project and reject vector from e3
    let proj = v_mv.project(&e3_mv);
    let rej = v_mv.reject(&e3_mv);
    assert!(proj.0.len() > 0 || proj.0.is_empty()); // test execution
    assert!(rej.0.len() > 0 || rej.0.is_empty());

    // step 7: confirm mean angle is finite and within expected bounds
    let mean = t123_mv.weighted_circular_mean_angle();
    assert!(mean >= 0.0 && mean <= TAU);
}

GitHub

geonum/tests/multivector_test.rs at develop · mxfactorial/geonum

geometric number library supporting unlimited dimensions with O(1) complexity - mxfactorial/geonum