dimensions greater than 3

[mxfactorial]

you need to install cargo but try https://crates.io/crates/geonum

you can work with high dimensional multivectors:

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);
}

plenty other domains covered in the tests directory

run them all and output their explanations:

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

welcome to help extend those cases