geoit 0.0.2

Exact geometric algebra with governed multivectors
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
124
125
126
127
128
129
130
131

use crate::scalar::Scalar;

/// Predicate: the result of checking an Mv against a GeomClass.
///
/// Contains the residuals of each equation (should be zero)
/// and the values of each inequality (should be nonzero).
#[derive(Clone, Debug)]
pub struct Predicate {
    pub class_index: usize,
    /// Residual of each equation polynomial (each should be zero).
    /// Only available with the `diagnostics` feature.
    #[cfg(feature = "diagnostics")]
    pub equation_residuals: Vec<Scalar>,
    /// Value of each inequality polynomial (each should be nonzero).
    /// Only available with the `diagnostics` feature.
    #[cfg(feature = "diagnostics")]
    pub inequality_values: Vec<Scalar>,
    /// Whether each equation is satisfied.
    pub equations_satisfied: Vec<bool>,
    /// Whether each inequality is satisfied.
    pub inequalities_satisfied: Vec<bool>,
    /// True if any residual or value uses BigRat (i128 overflow occurred).
    /// This is informational — the result is still exact.
    pub overflow_promoted: bool,
}

impl Predicate {
    /// Construct a Predicate. Residual vectors are only stored when the
    /// `diagnostics` feature is enabled.
    #[allow(unused_variables)]
    pub fn new(
        class_index: usize,
        eq_residuals: &[Scalar],
        ineq_values: &[Scalar],
        equations_satisfied: Vec<bool>,
        inequalities_satisfied: Vec<bool>,
        overflow_promoted: bool,
    ) -> Self {
        Predicate {
            class_index,
            #[cfg(feature = "diagnostics")]
            equation_residuals: eq_residuals.to_vec(),
            #[cfg(feature = "diagnostics")]
            inequality_values: ineq_values.to_vec(),
            equations_satisfied,
            inequalities_satisfied,
            overflow_promoted,
        }
    }

    pub fn is_satisfied(&self) -> bool {
        self.equations_satisfied.iter().all(|&s| s)
            && self.inequalities_satisfied.iter().all(|&s| s)
    }

    /// True if any computation was promoted to BigRat due to overflow.
    pub fn has_overflow(&self) -> bool {
        self.overflow_promoted
    }

    pub fn failing_indices(&self) -> Vec<usize> {
        let mut failing = Vec::new();
        for (i, &s) in self.equations_satisfied.iter().enumerate() {
            if !s {
                failing.push(i);
            }
        }
        for (i, &s) in self.inequalities_satisfied.iter().enumerate() {
            if !s {
                failing.push(self.equations_satisfied.len() + i);
            }
        }
        failing
    }

    /// Total residuals (equations then inequalities).
    /// Only available with the `diagnostics` feature.
    #[cfg(feature = "diagnostics")]
    pub fn residuals(&self) -> Vec<&Scalar> {
        self.equation_residuals
            .iter()
            .chain(self.inequality_values.iter())
            .collect()
    }
}

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

    #[test]
    fn satisfied_predicate() {
        let p = Predicate::new(
            0,
            &[Scalar::from(0i64)],
            &[Scalar::from(5i64)],
            vec![true],
            vec![true],
            false,
        );
        assert!(p.is_satisfied());
        assert!(p.failing_indices().is_empty());
    }

    #[test]
    fn failed_equation() {
        let p = Predicate::new(0, &[Scalar::from(3i64)], &[], vec![false], vec![], false);
        assert!(!p.is_satisfied());
        assert_eq!(p.failing_indices(), vec![0]);
    }

    #[test]
    fn failed_inequality() {
        let p = Predicate::new(
            0,
            &[Scalar::from(0i64)],
            &[Scalar::from(0i64)],
            vec![true],
            vec![false],
            false,
        );
        assert!(!p.is_satisfied());
    }

    #[test]
    fn overflow_tracking() {
        let p = Predicate::new(0, &[Scalar::from(0i64)], &[], vec![true], vec![], true);
        assert!(p.is_satisfied());
        assert!(p.has_overflow());
    }
}