frclib-core 0.2.4

A collection of utilities to be used across the FRC in rust ecosystem
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

use crate::units::linear_velocity::{FeetPerSecond, MetersPerSecond};
use crate::units::time::Second;
use crate::{unit, unit_conversion, unit_dim_analysis};

unit!(Meter: float);
unit!(Foot: float);
unit!(Inch: float);
unit!(Centimeter: float);

unit_conversion!(Meter(float) <-> Foot(float) ~ meter_to_foot);
unit_conversion!(Meter(float) <-> Inch(float) ~ meter_to_inch);
unit_conversion!(Foot(float) <-> Inch(float) ~ foot_to_inch);
unit_conversion!(Meter(float) <-> Centimeter(float) ~ meter_to_centimeter);
unit_conversion!(Centimeter(float) <-> Foot(float) ~ centimeter_to_foot);
unit_conversion!(Centimeter(float) <-> Inch(float) ~ centimeter_to_inch);

unit_dim_analysis!(MetersPerSecond * Second = Meter);
unit_dim_analysis!(FeetPerSecond * Second = Foot);

//manually written `unit_family!` because of how plural of imperial units are weird
#[doc = "A family of units. "]
#[doc = "The standard unit is `Meter`."]
#[doc = "The other units are `Inch`, `Foot`, `Centimeter`."]
pub trait Distance: Into<Meter> + From<Meter> + Copy {
    #[doc = "Converts this unit to the standard unit of the family."]
    #[inline]
    fn standard(self) -> Meter {
        self.into()
    }
    #[doc = "Converts this unit to `Inch`."]
    #[inline]
    fn to_inches(self) -> Inch {
        Inch::from(self.standard())
    }
    #[doc = "Converts this unit to `Foot`."]
    #[inline]
    fn to_feet(self) -> Foot {
        Foot::from(self.standard())
    }
    #[doc = "Converts this unit to `Centimeter`."]
    #[inline]
    fn to_centimeters(self) -> Centimeter {
        Centimeter::from(self.standard())
    }
    #[doc = "Converts this unit to `Meter`."]
    #[doc = "This is the same as [`standard`](#method.standard)."]
    #[inline]
    fn to_meters(self) -> Meter {
        self.standard()
    }
}
impl<T> Distance for T where T: Into<Meter> + From<Meter> + Copy {}

fn meter_to_foot(meter: f64) -> f64 {
    meter * 3.28084
}

fn meter_to_inch(meter: f64) -> f64 {
    meter * 3.28084 * 12.0
}

fn foot_to_inch(foot: f64) -> f64 {
    foot * 12.0
}

fn meter_to_centimeter(meter: f64) -> f64 {
    meter * 100.0
}

fn centimeter_to_foot(centimeter: f64) -> f64 {
    meter_to_foot(centimeter / 100.0)
}

fn centimeter_to_inch(centimeter: f64) -> f64 {
    meter_to_inch(centimeter / 100.0)
}