ncube 2.4.1

Generalized Hypercube Visualizer
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
124
125
126
127
128
129
130
131

use bevy::prelude::Vec3;

#[derive(Debug)]
pub struct SphericalCoordinate {
    pub r: f32,
    pub theta: f32,
    pub phi: f32,
}

impl SphericalCoordinate {
    /// Generates a new `SphericalCoordinate`.
    /// Keep in mind `theta` and `phi` are in radians.
    pub fn new(r: f32, theta: f32, phi: f32) -> Self {
        Self { r, theta, phi }
    }
}

// NOTE: In bevy, ^y is "UP" by default
pub trait SphericalCoordinateSystem {
    fn from_spherical(spherical_coordinate: SphericalCoordinate) -> Self;
    fn to_spherical(&self) -> SphericalCoordinate;
}

impl SphericalCoordinateSystem for Vec3 {
    /// Generates a `Vec3` from the given `SphericalCoordinate`.
    fn from_spherical(sc: SphericalCoordinate) -> Self {
        Self {
            x: sc.r * sc.theta.sin() * sc.phi.sin(),
            y: sc.r * sc.theta.cos(),
            z: sc.r * sc.theta.sin() * sc.phi.cos(),
        }
    }
    /// Converts a cartesian coordinate to spherical.
    fn to_spherical(&self) -> SphericalCoordinate {
        let r = self.length();
        let theta = (self.y / r).acos();
        let phi = (self.x).atan2(self.z);
        SphericalCoordinate { r, theta, phi }
    }
}

pub trait TriangleNormal {
    fn normal(&self, b: &Self, c: &Self) -> Self;
}

impl TriangleNormal for Vec3 {
    /// Computes the normal for a triangle based on its vertices
    fn normal(&self, b: &Self, c: &Self) -> Self {
        let a = self;
        (*b - *a).cross(*c - *b).normalize()
    }
}

pub trait MathOps {
    // Computes the dot product between 2 vectors
    fn dot(&self, b: &Self) -> f64;
    // Computes the hadamard product between 2 vectors
    fn hadamard(&self, b: &Self) -> Self;
    /// Checks how many dimensions are shared across a group of `points` (equal in value)
    /// Useful for checking whether the points lie within an n dimensional slice.
    fn shared_dimensions(points: &[&Self]) -> Vec<usize>;
    /// Computes the distance between 2 vectors
    fn distance(&self, b: &Self) -> f64;
    /// Computes the magnitude of a vector
    fn magnitude(&self) -> f64;
    /// Normalizes vector
    fn normalize(&self) -> Self;
    /// Scales vector
    fn scale(&self, a: f64) -> Self;
}

impl MathOps for Vec<f64> {
    fn dot(&self, b: &Self) -> f64 {
        let len = self.len();
        assert_eq!(len, b.len());
        (0..len).map(|d| self[d] * b[d]).sum()
    }

    fn hadamard(&self, b: &Self) -> Self {
        let len = self.len();
        assert_eq!(len, b.len());
        (0..len).map(|d| self[d] * b[d]).collect()
    }

    fn shared_dimensions(points: &[&Self]) -> Vec<usize> {
        let mut common_d = Vec::new();
        for d in 0..points[0].len() {
            if points.iter().all(|p| p[d] == points[0][d]) {
                common_d.push(d);
            }
        }
        common_d
    }

    fn distance(&self, b: &Self) -> f64 {
        let d = self.len();
        assert_eq!(d, b.len());
        self.iter()
            .enumerate()
            .map(|(i, x)| (b[i] - x).powi(2))
            .sum::<f64>()
            .sqrt()
    }

    fn magnitude(&self) -> f64 {
        self.iter().map(|x| x.powi(2)).sum::<f64>().sqrt()
    }

    fn normalize(&self) -> Self {
        let l = self.magnitude();
        self.iter().map(|x| x / l).collect()
    }

    fn scale(&self, a: f64) -> Self {
        self.iter().map(|x| a * x).collect()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn spherical_coordinates() {
        let a = Vec3::new(3.0, -2.5, 9.0);
        let a_spherical = a.to_spherical();
        let a_prime = Vec3::from_spherical(a_spherical);
        let precision = 0.00001;
        println!("Comparing {a:?} with {a_prime:?} +- {precision}");
        assert!(a.cmpgt(a_prime - precision).all() && a.cmplt(a_prime + precision).all());
    }
}