vector-traits 0.6.2

Rust traits for 2D and 3D vector types.
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

// SPDX-License-Identifier: MIT OR Apache-2.0
// Copyright (c) 2023, 2025 lacklustr@protonmail.com https://github.com/eadf

// This file is part of vector-traits.

use num_traits::{AsPrimitive, Float, FromPrimitive, Signed, ToPrimitive, float::FloatCore};
use std::{
    fmt::{Debug, Display, LowerExp},
    hash::Hash,
    ops::{AddAssign, DivAssign, MulAssign, Neg, SubAssign},
};

/// A trait meant to represent f32 or f64
pub trait GenericScalar
where
    Self: Display
        + Debug
        + Float
        + FloatCore
        + FromPrimitive
        + ToPrimitive
        + MulAssign
        + DivAssign
        + AddAssign
        + SubAssign
        + Default
        + std::str::FromStr
        + Sync
        + Send
        + Into<f64>
        + From<f32>
        + From<u16>
        + From<i16>
        + From<i8>
        + From<u8>
        + Neg<Output = Self>
        + Signed
        + LowerExp
        + AsPrimitive<f64>
        + AsPrimitive<f32>
        + AsPrimitive<usize>
        + AsPrimitive<isize>
        + AsPrimitive<u64>
        + AsPrimitive<i64>
        + AsPrimitive<u32>
        + AsPrimitive<i32>
        + AsPrimitive<u16>
        + AsPrimitive<i16>
        + AsPrimitive<u8>
        + AsPrimitive<i8>
        + approx::UlpsEq<Epsilon = Self>,
{
    /// The type of the to_bits() and from_bits() methods
    type BitsType: Hash + Eq + Ord + Display + Debug;
    const ZERO: Self;
    const ONE: Self;
    const TWO: Self;
    const THREE: Self;
    const FOUR: Self;
    const INFINITY: Self;
    const NEG_INFINITY: Self;
    const EPSILON: Self;
    const MAX: Self;
    const MIN: Self;
    fn to_bits(self) -> Self::BitsType;
    fn from_bits(bits: Self::BitsType) -> Self;
}

macro_rules! impl_generic_scalar {
    ($type:ty, $bits_type:ty) => {
        impl GenericScalar for $type {
            type BitsType = $bits_type;
            const ZERO: Self = 0.0;
            const ONE: Self = 1.0;
            const TWO: Self = 2.0;
            const THREE: Self = 3.0;
            const FOUR: Self = 4.0;
            const INFINITY: Self = <$type>::INFINITY;
            const NEG_INFINITY: Self = <$type>::NEG_INFINITY;
            const EPSILON: Self = <$type>::EPSILON;
            const MAX: Self = <$type>::MAX;
            const MIN: Self = <$type>::MIN;
            #[inline(always)]
            fn to_bits(self) -> Self::BitsType {
                <$type>::to_bits(self)
            }
            #[inline(always)]
            fn from_bits(bits: Self::BitsType) -> Self {
                <$type>::from_bits(bits)
            }
        }
    };
}

impl_generic_scalar!(f32, u32);
impl_generic_scalar!(f64, u64);