path-traits 0.1.0

Tower-like generic traits for parametric paths, segments, and geometric queries
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

//! Scalar type alias for arc-length and parameter computations.
//!
//! This module defines the [`Scalar`] trait, a numeric trait with additional bounds
//! (`Debug`, `Copy`, `'static`) required for arc-length and parameter computations
//! throughout the crate. The supertraits vary by feature configuration.

#[cfg(all(feature = "num-traits", feature = "std"))]
mod inner {
    use num_traits::Float;

    /// A scalar type suitable for arc-length, parameter, and distance computations.
    ///
    /// Requires `Float` from `num-traits` (with `std`) plus `Debug`, `Copy`, and `'static` bounds.
    /// Implementations are provided automatically for any type satisfying those bounds
    /// (e.g. `f32`, `f64`).
    pub trait Scalar: Float + core::fmt::Debug + Copy + 'static {
        /// Returns the additive identity (0.0).
        fn zero() -> Self;
        /// Returns the multiplicative identity (1.0).
        fn one() -> Self;
        /// Cast a `usize` value to this scalar type.
        fn from_usize(n: usize) -> Self;
    }

    impl<T: Float + core::fmt::Debug + Copy + 'static> Scalar for T {
        fn zero() -> Self {
            T::zero()
        }
        fn one() -> Self {
            T::one()
        }
        fn from_usize(n: usize) -> Self {
            num_traits::NumCast::from(n).unwrap_or(Self::one())
        }
    }
}

#[cfg(all(feature = "num-traits", not(feature = "std")))]
mod inner {
    use num_traits::float::FloatCore;

    /// A scalar type suitable for arc-length, parameter, and distance computations.
    ///
    /// Requires `FloatCore` from `num-traits` plus `Debug`, `Copy`, and `'static` bounds.
    /// Implementations are provided automatically for any type satisfying those bounds
    /// (e.g. `f32`, `f64`).
    pub trait Scalar: FloatCore + core::fmt::Debug + Copy + 'static {
        /// Returns the additive identity (0.0).
        fn zero() -> Self;
        /// Returns the multiplicative identity (1.0).
        fn one() -> Self;
        /// Cast a `usize` value to this scalar type.
        fn from_usize(n: usize) -> Self;
    }

    impl<T: FloatCore + core::fmt::Debug + Copy + 'static> Scalar for T {
        fn zero() -> Self {
            T::zero()
        }
        fn one() -> Self {
            T::one()
        }
        fn from_usize(n: usize) -> Self {
            num_traits::NumCast::from(n).unwrap_or(Self::one())
        }
    }
}

#[cfg(not(feature = "num-traits"))]
mod inner {
    /// A scalar type suitable for arc-length, parameter, and distance computations.
    ///
    /// Requires arithmetic operations (`Add`, `Sub`, `Mul`, `Div`, `Neg`),
    /// `PartialOrd`, `Debug`, `Copy`, and `'static` bounds.
    /// Manual implementations are provided for `f32` and `f64`.
    pub trait Scalar:
        core::ops::Add<Output = Self>
        + core::ops::Sub<Output = Self>
        + core::ops::Mul<Output = Self>
        + core::ops::Div<Output = Self>
        + core::ops::Neg<Output = Self>
        + PartialOrd
        + core::fmt::Debug
        + Copy
        + 'static
    {
        /// Returns the additive identity (0.0).
        fn zero() -> Self;
        /// Returns the multiplicative identity (1.0).
        fn one() -> Self;
        /// Cast a `usize` value to this scalar type.
        fn from_usize(n: usize) -> Self;
    }

    macro_rules! impl_scalar {
        ($($t:ty),+) => {
            $(
                impl Scalar for $t {
                    fn zero() -> Self { 0.0 }
                    fn one() -> Self { 1.0 }
                    fn from_usize(n: usize) -> Self { n as $t }
                }
            )+
        };
    }

    impl_scalar!(f32, f64);
}

pub use inner::Scalar;