rinia 0.0.18

Stable numeric foundations for graphics, animation, and simulation.
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
132
133
134

macro_rules! _impl_tuple_wrapper_finite {
	([$($impl_generics:tt)*], $outer:ty, item: $item:ty, len: $len:expr $(,)?) => {
		// IsFinite inherent
        impl<$($impl_generics)*> $outer
		where
			$item: $crate::numeric::IsFinite + Copy,
		{
            /// Returns `true` if all elements are finite, `false` otherwise.
			#[inline]
			pub fn is_finite(self) -> bool {
				self.into_tuple().is_finite()
			}
		}

        // IsFinite trait
		impl<$($impl_generics)*> $crate::numeric::IsFinite for $outer
		where
			$item: $crate::numeric::IsFinite + Copy,
		{
			#[inline]
			fn is_finite(self) -> bool {
				<$outer>::is_finite(self)
			}
		}
	};
}

macro_rules! _impl_tuple_wrapper_infinite {
	([$($impl_generics:tt)*], $outer:ty, item: $item:ty, len: $len:expr $(,)?) => {
		// Infinite inherent
        impl<$($impl_generics)*> $outer
		where
			$item: $crate::numeric::Infinite + Copy,
		{
            /// Returns a new wrapper with all elements set to positive infinity.
			pub const INFINITY: Self =
				Self::from_tuple($crate::tuple::Tuple::<$item, $len>::INFINITY);

            /// Returns a new wrapper with all elements set to negative infinity.
			pub const NEG_INFINITY: Self =
				Self::from_tuple($crate::tuple::Tuple::<$item, $len>::NEG_INFINITY);
		}

        // Infinite trait
		impl<$($impl_generics)*> $crate::numeric::Infinite for $outer
		where
			$item: $crate::numeric::Infinite + Copy,
		{
			const INFINITY: Self = <$outer>::INFINITY;
			const NEG_INFINITY: Self = <$outer>::NEG_INFINITY;
		}

        // IsInfinite inherent
        impl<$($impl_generics)*> $outer
		where
			$item: $crate::numeric::IsInfinite + Copy,
		{
            /// Returns `true` if any element is infinite, `false` otherwise.
			#[inline]
			pub fn is_infinite(self) -> bool {
				self.into_tuple().is_infinite()
			}
		}

        // IsInfinite trait
        impl<$($impl_generics)*> $crate::numeric::IsInfinite for $outer
		where
			$item: $crate::numeric::IsInfinite + Copy,
		{
			#[inline]
			fn is_infinite(self) -> bool {
				<$outer>::is_infinite(self)
			}
		}
	};
}

macro_rules! _impl_tuple_wrapper_nan {
	([$($impl_generics:tt)*], $outer:ty, item: $item:ty, len: $len:expr $(,)?) => {
		// Nan inherent
        impl<$($impl_generics)*> $outer
		where
			$item: $crate::numeric::Nan + Copy,
		{
            /// Returns a new wrapper with all elements set to NaN.
			pub const NAN: Self = Self::from_tuple($crate::tuple::Tuple::<$item, $len>::NAN);

		}

        // Nan trait
		impl<$($impl_generics)*> $crate::numeric::Nan for $outer
		where
			$item: $crate::numeric::Nan + Copy,
		{
			const NAN: Self = <$outer>::NAN;
		}

        // IsNan inherent
        impl<$($impl_generics)*> $outer
		where
			$item: $crate::numeric::IsNan + Copy,
		{
            /// Returns `true` if any element is NaN, `false` otherwise.
			#[inline]
			pub fn is_nan(self) -> bool {
				self.into_tuple().is_nan()
			}
		}

        // IsNan trait
        impl<$($impl_generics)*> $crate::numeric::IsNan for $outer
		where
			$item: $crate::numeric::IsNan + Copy,
		{
			#[inline]
			fn is_nan(self) -> bool {
				<$outer>::is_nan(self)
			}
		}
	};
}

macro_rules! _impl_tuple_wrapper_numeric_predicates {
	([$($impl_generics:tt)*], $outer:ty, item: $item:ty, len: $len:expr $(,)?) => {
		$crate::common::_impl_tuple_wrapper_finite!([$($impl_generics)*], $outer, item: $item, len: $len);
		$crate::common::_impl_tuple_wrapper_infinite!([$($impl_generics)*], $outer, item: $item, len: $len);
		$crate::common::_impl_tuple_wrapper_nan!([$($impl_generics)*], $outer, item: $item, len: $len);
	};
}

pub(crate) use _impl_tuple_wrapper_finite;
pub(crate) use _impl_tuple_wrapper_infinite;
pub(crate) use _impl_tuple_wrapper_nan;
pub(crate) use _impl_tuple_wrapper_numeric_predicates;