affn 0.8.0

Affine geometry primitives: strongly-typed coordinate systems, reference frames, and centers for scientific computing.
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

//! Interpolation abscissa types.

use super::InterpolationError;
use qtty::{Quantity, Unit};
use std::cmp::Ordering;

mod sealed {
    pub trait Sealed {}
    impl Sealed for f64 {}
    impl<U: qtty::Unit> Sealed for qtty::Quantity<U> {}
}

/// Difference between two interpolation abscissae.
pub trait AbscissaDelta: Copy {
    /// Scales this delta by a dimensionless Hermite basis coefficient.
    fn scale(self, factor: f64) -> Self;

    /// Raw value used only for diagnostics and scalar-only formulas.
    fn diagnostic_raw(self) -> f64;
}

impl AbscissaDelta for f64 {
    #[inline]
    fn scale(self, factor: f64) -> Self {
        self * factor
    }

    #[inline]
    fn diagnostic_raw(self) -> f64 {
        self
    }
}

impl<U: Unit> AbscissaDelta for Quantity<U> {
    #[inline]
    fn scale(self, factor: f64) -> Self {
        self * factor
    }

    #[inline]
    fn diagnostic_raw(self) -> f64 {
        self.value()
    }
}

/// An ordered interpolation abscissa.
///
/// Physical domains should use typed [`qtty::Quantity`] abscissae. The raw
/// `f64` implementation is intended for explicitly scalar, dimensionless
/// interpolation such as `CubicHermiteTable<f64, f64>`.
pub trait InterpolationAbscissa: sealed::Sealed + Copy {
    /// Difference between two abscissae.
    type Delta: AbscissaDelta;

    /// Returns whether this abscissa is finite.
    fn is_finite(self) -> bool;

    /// Compares two abscissae for table ordering.
    fn cmp_abscissa(self, other: Self) -> Ordering;

    /// Returns `self - origin` as a typed delta.
    fn delta_since(self, origin: Self) -> Self::Delta;

    /// Returns the normalized segment coordinate in `[0, 1]`.
    fn normalize_between(self, start: Self, end: Self) -> Result<f64, InterpolationError>;

    /// Raw value used only for diagnostics.
    fn diagnostic_raw(self) -> f64;
}

impl InterpolationAbscissa for f64 {
    type Delta = f64;

    #[inline]
    fn is_finite(self) -> bool {
        self.is_finite()
    }

    #[inline]
    fn cmp_abscissa(self, other: Self) -> Ordering {
        self.total_cmp(&other)
    }

    #[inline]
    fn delta_since(self, origin: Self) -> Self::Delta {
        self - origin
    }

    #[inline]
    fn normalize_between(self, start: Self, end: Self) -> Result<f64, InterpolationError> {
        Ok((self - start) / (end - start))
    }

    #[inline]
    fn diagnostic_raw(self) -> f64 {
        self
    }
}

impl<U: Unit> InterpolationAbscissa for Quantity<U> {
    type Delta = Quantity<U>;

    #[inline]
    fn is_finite(self) -> bool {
        self.value().is_finite()
    }

    #[inline]
    fn cmp_abscissa(self, other: Self) -> Ordering {
        self.value().total_cmp(&other.value())
    }

    #[inline]
    fn delta_since(self, origin: Self) -> Self::Delta {
        self - origin
    }

    #[inline]
    fn normalize_between(self, start: Self, end: Self) -> Result<f64, InterpolationError> {
        let offset = self - start;
        let width = end - start;
        Ok(offset.value() / width.value())
    }

    #[inline]
    fn diagnostic_raw(self) -> f64 {
        self.value()
    }
}