munum 0.2.0

Micro 3D Math Library
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

//! Scalar type helpers.

use num::Num;

/// Returns negative one of type T.
///
/// # Examples
/// ```
/// assert_eq!(munum::scalar::neg::<f32>(), -1.);
/// ```
#[inline]
pub fn neg<T: Num>() -> T {
    T::zero() - T::one()
}

/// Returns the sign of a.
///
/// # Examples
/// ```
/// assert_eq!(munum::scalar::sign(-2), -1);
/// assert_eq!(munum::scalar::sign(0), 0);
/// assert_eq!(munum::scalar::sign(5), 1);
/// ```
#[inline]
pub fn sign<T: Copy + Num + PartialOrd>(a: T) -> T {
    let zero = T::zero();
    if a < zero {
        neg()
    } else if a == zero {
        zero
    } else {
        T::one()
    }
}

/// Returns the maximum of a and b.
///
/// # Examples
/// ```
/// assert_eq!(munum::scalar::max(-2, 0), 0);
/// assert_eq!(munum::scalar::max(3.2, 4.5), 4.5);
/// ```
#[inline]
pub fn max<T: Copy + PartialOrd>(a: T, b: T) -> T {
    if a < b {
        b
    } else {
        a
    }
}

/// Composes a number from the magnitude of a and the sign of b,
/// i.e. copysign(a, b) = sgn(b)|a|.
///
/// # Examples
/// ```
/// assert_eq!(munum::scalar::copysign(-2, 0), 0);
/// assert_eq!(munum::scalar::copysign(3, 4), 3);
/// assert_eq!(munum::scalar::copysign(4, -5), -4);
/// assert_eq!(munum::scalar::copysign(-3, 4), 3);
/// assert_eq!(munum::scalar::copysign(-4, -5), -4);
/// ```
#[inline]
pub fn copysign<T: Copy + Num + PartialOrd>(a: T, b: T) -> T {
    sign(b) * (if a < T::zero() { a * neg() } else { a })
}

/// Linear interpolates between 2 numbers.
///
/// # Examples
/// ```
/// assert_eq!(munum::scalar::lerp(3., 5., 0.5), 4.);
/// ```
#[inline]
pub fn lerp<T: Copy + Num>(a: T, b: T, t: T) -> T {
    a - a * t + b * t
}