fisica 0.2.0

A physics 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
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

// fisica::units::acceleration
//
//!
//

#[allow(unused_imports)]
use crate::units::{Force, Length, Mass, Speed, Time, Velocity};
use crate::{Direction, Magnitude};

/// The rate at which the [`Velocity`] of a body changes in [`Time`],
/// in [`m`][Length]/[`s`][Time]².
#[derive(Clone, Copy, Debug)]
pub struct Acceleration {
    pub d: Direction,
}

impl Acceleration {
    /// New Acceleration.
    #[inline]
    pub const fn new(d: Direction) -> Self {
        Self { d }
    }

    /// Returns the magnitude, derived from the length of its direction.
    pub fn m(&self) -> Magnitude {
        self.d.magnitude()
    }
}

/// # `Acceleration` Formulas
impl Acceleration {
    /// Derives `Acceleration` from the given change in [`Velocity`] and [`Time`] taken
    /// (`a = v / t`).
    #[inline]
    pub fn from_velocity_time(v: Velocity, t: Time) -> Self {
        Self::new(v.d / t.m())
    }

    /// (Alias of [from_velocity_time][Acceleration::from_velocity_time]).
    #[inline]
    pub fn from_time_velocity(t: Time, v: Velocity) -> Self {
        Self::from_velocity_time(v, t)
    }

    pub fn from_velocities_time(v_initial: Velocity, v_final: Velocity, t: Time) -> Self {
        Self::new((v_final.d - v_initial.d) / t.m()) // CHECK
    }

    /// (Alias of [from_velocities_time][Acceleration::from_velocities_time]).
    pub fn from_time_velocities(t: Time, v_initial: Velocity, v_final: Velocity) -> Self {
        Self::from_velocities_time(v_initial, v_final, t)
    }

    /// Derives `Acceleration` from the given [`Mass`] and [`Force`] (`a = F / m`).
    #[inline]
    pub fn from_mass_force(m: Mass, f: Force) -> Self {
        Self::new(f.d / m.m())
    }

    /// (Alias of [from_mass_force][Acceleration::from_mass_force]).
    #[inline]
    pub fn from_force_mass(f: Force, m: Mass) -> Self {
        Self::from_mass_force(m, f)
    }

    /// Calculates the [`Mass`] given the [`Force`] (`m = F / a`).
    #[inline]
    pub fn calc_mass(&self, f: Force) -> Mass {
        Mass::new(f.m() / self.m())
    }

    /// Calculates the [`Force`] given the [`Mass`] (`F = m × a`).
    #[inline]
    pub fn calc_force(&self, m: Mass) -> Force {
        Force::new(self.d * m.m())
    }
}

impl_vector_methods_2units![
    Acceleration,
    q1a = m,
    q2a = s2,
    Q1a = metres,
    Q2a = second_squared,
    Ja = per,
    q1u = "m",
    q2u = "s²",
    Q1u = "metres",
    Q2u = "second squared"
];

#[cfg(test)]
mod tests {
    use {super::*, float_eq::assert_float_eq};

    /// Checks the formulas behave as expected.
    #[test]
    fn acceleration_formulas() {
        // Force, Acceleration & Mass
        let acceleration =
            Acceleration::from_mass_force(Mass::new(5.), Force::new(Direction::new(10., 0., 0.)));
        assert_float_eq!(2., acceleration.m(), r2nd <= Magnitude::EPSILON);
        assert_float_eq!(
            5.,
            acceleration
                .calc_mass(Force::new(Direction::new(10., 0., 0.)))
                .m(),
            r2nd <= Magnitude::EPSILON
        );
        assert_float_eq!(
            10.,
            acceleration.calc_force(Mass::new(5.)).m(),
            r2nd <= Magnitude::EPSILON
        );
    }
}