symtropy-math 0.2.1

N-dimensional geometric algebra: const-generic points, bivectors, rotors, and collision shapes (2D/3D/4D+). Stack-allocated, zero-heap physics primitives.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

// Copyright (C) 2024-2026 Tristan Stoltz / Luminous Dynamics
// SPDX-License-Identifier: Apache-2.0 OR MIT
// Commercial licensing: see COMMERCIAL_LICENSE.md at repository root
use crate::point::Point;
use nalgebra::SVector;

/// D-dimensional hyperplane: { x : normal ยท x = offset }.
/// Used for BSP partitioning and 4D cross-section slicing.
#[derive(Clone, Copy, Debug)]
pub struct Hyperplane<const D: usize> {
    pub normal: SVector<f64, D>,
    pub offset: f64,
}

impl<const D: usize> Hyperplane<D> {
    pub fn from_normal_and_point(normal: SVector<f64, D>, point: &Point<D>) -> Self {
        let n = normal.normalize();
        Self {
            normal: n,
            offset: n.dot(&point.0),
        }
    }

    pub fn new(normal: SVector<f64, D>, offset: f64) -> Self {
        Self { normal, offset }
    }

    #[inline]
    pub fn signed_distance(&self, point: &Point<D>) -> f64 {
        self.normal.dot(&point.0) - self.offset
    }

    #[inline]
    pub fn classify(&self, point: &Point<D>) -> Side {
        let d = self.signed_distance(point);
        if d > 1e-10 {
            Side::Front
        } else if d < -1e-10 {
            Side::Back
        } else {
            Side::On
        }
    }

    pub fn project(&self, point: &Point<D>) -> Point<D> {
        let d = self.signed_distance(point);
        Point(point.0 - self.normal * d)
    }

    pub fn intersect_segment(&self, a: &Point<D>, b: &Point<D>) -> Option<f64> {
        let da = self.signed_distance(a);
        let db = self.signed_distance(b);
        if da * db > 0.0 {
            return None;
        }
        let denom = da - db;
        if denom.abs() < 1e-15 {
            return None;
        }
        Some(da / denom)
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Side {
    Front,
    Back,
    On,
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn classify_3d() {
        let hp = Hyperplane::new(SVector::from([0.0, 1.0, 0.0]), 0.0);
        assert_eq!(hp.classify(&Point::new([0.0, 1.0, 0.0])), Side::Front);
        assert_eq!(hp.classify(&Point::new([0.0, -1.0, 0.0])), Side::Back);
        assert_eq!(hp.classify(&Point::new([5.0, 0.0, 3.0])), Side::On);
    }

    #[test]
    fn signed_distance() {
        let hp = Hyperplane::new(SVector::from([1.0, 0.0]), 5.0);
        let p = Point::new([8.0, 3.0]);
        assert!((hp.signed_distance(&p) - 3.0).abs() < 1e-12);
    }

    #[test]
    fn project() {
        let hp = Hyperplane::new(SVector::from([0.0, 1.0, 0.0]), 0.0);
        let p = Point::new([3.0, 7.0, 2.0]);
        let proj = hp.project(&p);
        assert!((proj.coord(0) - 3.0).abs() < 1e-12);
        assert!(proj.coord(1).abs() < 1e-12);
    }

    #[test]
    fn segment_intersection() {
        let hp = Hyperplane::new(SVector::from([0.0, 1.0, 0.0]), 0.0);
        let a = Point::new([0.0, -1.0, 0.0]);
        let b = Point::new([0.0, 1.0, 0.0]);
        let t = hp.intersect_segment(&a, &b).unwrap();
        assert!((t - 0.5).abs() < 1e-12);
    }

    #[test]
    fn no_intersection_same_side() {
        let hp = Hyperplane::new(SVector::from([0.0, 1.0]), 0.0);
        assert!(hp
            .intersect_segment(&Point::new([0.0, 1.0]), &Point::new([0.0, 2.0]))
            .is_none());
    }

    #[test]
    fn hyperplane_4d_slicing() {
        let hp = Hyperplane::new(SVector::from([0.0, 0.0, 0.0, 1.0]), 0.5);
        assert_eq!(hp.classify(&Point::new([1.0, 2.0, 3.0, 0.5])), Side::On);
        assert_eq!(hp.classify(&Point::new([1.0, 2.0, 3.0, 1.0])), Side::Front);
        assert_eq!(hp.classify(&Point::new([1.0, 2.0, 3.0, 0.0])), Side::Back);
    }
}