Merge branch 'master' into add_electrical_mobility

src/si/acceleration.rs

@@ -63,6 +63,8 @@ quantity! {
             "inches per second squared";
         @millimeter_per_minute_squared: 2.777_777_777_777_777_8_E-7; "mm/min²",
             "millimeter per minute squared", "millimeters per minute squared";
+        @standard_gravity: 9.806_65_E0; "g₀", "standard acceleration of gravity",
+            "standard accelerations of gravity";
     }
 }
 

src/si/areal_mass_density.rs

@@ -0,0 +1,58 @@
+//! Areal mass density (base unit kilogram per square meter, m⁻² · kg).
+
+quantity! {
+    /// Areal mass density (base unit kilogram per square meter, m⁻² · kg).
+    quantity: ArealMassDensity; "areal mass density";
+    /// Dimension of areal mass density, L⁻²M (base unit kilogram per square meter, m⁻² · kg).
+    dimension: ISQ<
+        N2,     // length
+        P1,     // mass
+        Z0,     // time
+        Z0,     // electric current
+        Z0,     // thermodynamic temperature
+        Z0,     // amount of substance
+        Z0>;    // luminous intensity
+    units {
+        @kilogram_per_square_meter: prefix!(none); "kg/m²", "kilogram per square meter",
+            "kilograms per square meter";
+        @gram_per_square_meter: prefix!(milli); "g/m²", "gram per square meter",
+            "grams per square meter";
+        @gram_per_square_centimeter: prefix!(milli) / prefix!(centi) / prefix!(centi); "g/cm²",
+            "gram per square centimeter", "grams per square centimeter";
+
+        @ounce_per_square_foot: 2.834_952_E-2 / 9.290_304_E-2; "oz/ft²", "ounce per square foot",
+            "ounces per square foot";
+    }
+}
+
+#[cfg(test)]
+mod test {
+    storage_types! {
+        use crate::num::One;
+        use crate::si::mass as m;
+        use crate::si::areal_mass_density as d;
+        use crate::si::quantities::*;
+        use crate::si::area as a;
+        use crate::tests::Test;
+
+        #[test]
+        fn check_dimension() {
+            let _: ArealMassDensity<V> = Mass::new::<m::kilogram>(V::one())
+                / Area::new::<a::square_meter>(V::one());
+        }
+
+        #[test]
+        fn check_units() {
+            test::<m::kilogram, a::square_meter, d::kilogram_per_square_meter>();
+            test::<m::gram, a::square_meter, d::gram_per_square_meter>();
+            test::<m::gram, a::square_centimeter, d::gram_per_square_centimeter>();
+
+            test::<m::ounce, a::square_foot, d::ounce_per_square_foot>();
+
+            fn test<M: m::Conversion<V>, A: a::Conversion<V>, D: d::Conversion<V>>() {
+                Test::assert_approx_eq(&ArealMassDensity::new::<D>(V::one()),
+                    &(Mass::new::<M>(V::one()) / Area::new::<A>(V::one())));
+            }
+        }
+    }
+}

src/si/areal_number_density.rs

@@ -0,0 +1,85 @@
+//! Areal number density (base unit 1 per square meter, m⁻²).
+
+quantity! {
+    /// Areal number density (base unit 1 per square meter, m⁻²).
+    quantity: ArealNumberDensity; "areal number density";
+    /// Dimension of areal number density, L⁻² (base unit 1 per square meter, m⁻²).
+    dimension: ISQ<
+        N2,     // length
+        Z0,     // mass
+        Z0,     // time
+        Z0,     // electric current
+        Z0,     // thermodynamic temperature
+        Z0,     // amount of substance
+        Z0>;    // luminous intensity
+    kind: dyn (crate::si::marker::ConstituentConcentrationKind);
+    units {
+        @per_square_kilometer: prefix!(none) / prefix!(kilo) / prefix!(kilo); "km⁻²",
+            "per square kilometer", "per square kilometer";
+        @per_square_meter: prefix!(none); "m⁻²", "per square meter", "per square meter";
+        @per_square_decimeter: prefix!(none) / prefix!(deci) / prefix!(deci); "dm⁻²",
+            "per square decimeter", "per square decimeter";
+        @per_square_centimeter: prefix!(none) / prefix!(centi) / prefix!(centi); "cm⁻²",
+            "per square centimeter", "per square centimeter";
+        @per_square_millimeter: prefix!(none) / prefix!(milli) / prefix!(milli); "mm⁻²",
+            "per square millimeter", "per square millimeter";
+        @per_square_micrometer: prefix!(none) / prefix!(micro) / prefix!(micro); "µm⁻²",
+            "per square micrometer", "per square micrometer";
+
+        @per_acre: prefix!(none) / 4.046_873_E3; "ac⁻²", "per acre", "per acre";
+        @per_are: prefix!(none) / 1.0_E2; "a⁻²", "per are", "per are";
+        @per_barn: prefix!(none) / 1.0_E-28; "b⁻²", "per barn", "per barn";
+        @per_circular_mil: prefix!(none) / 5.067_075_E-10; "cmil⁻²", "per circular mil",
+            "per circular mil";
+        @per_hectare: prefix!(none) / 1.0_E4; "ha⁻²", "per hectare", "per hectare";
+        @per_square_foot: prefix!(none) / 9.290_304_E-2; "ft⁻²", "per square foot",
+            "per square foot";
+        @per_square_inch: prefix!(none) / 6.451_6_E-4; "in⁻²", "per square inch", "per square inch";
+        @per_square_mile: prefix!(none) / 2.589_988_E6; "mi⁻²", "per square mile",
+            "per square mile";
+        @per_square_yard: prefix!(none) / 8.361_274_E-1; "yd⁻²", "per square yard",
+            "per square yard";
+    }
+}
+
+#[cfg(test)]
+mod test {
+    storage_types! {
+        use crate::num::One;
+        use crate::si::area as a;
+        use crate::si::areal_number_density as n;
+        use crate::si::quantities::*;
+        use crate::tests::Test;
+
+        #[test]
+        fn check_dimension() {
+            let _: ArealNumberDensity<V> = (V::one()
+                / Area::new::<a::square_meter>(V::one())).into();
+        }
+
+        #[test]
+        fn check_units() {
+            test::<n::per_square_kilometer, a::square_kilometer>();
+            test::<n::per_square_meter, a::square_meter>();
+            test::<n::per_square_decimeter, a::square_decimeter>();
+            test::<n::per_square_centimeter, a::square_centimeter>();
+            test::<n::per_square_millimeter, a::square_millimeter>();
+            test::<n::per_square_micrometer, a::square_micrometer>();
+
+            test::<n::per_acre, a::acre>();
+            test::<n::per_are, a::are>();
+            test::<n::per_barn, a::barn>();
+            test::<n::per_circular_mil, a::circular_mil>();
+            test::<n::per_hectare, a::hectare>();
+            test::<n::per_square_foot, a::square_foot>();
+            test::<n::per_square_inch, a::square_inch>();
+            test::<n::per_square_mile, a::square_mile>();
+            test::<n::per_square_yard, a::square_yard>();
+
+            fn test<N: n::Conversion<V>, A: a::Conversion<V>>() {
+                Test::assert_approx_eq(&ArealNumberDensity::new::<N>(V::one()),
+                    &(V::one() / Area::new::<A>(V::one())).into());
+            }
+        }
+    }
+}

src/si/areal_number_rate.rs

@@ -0,0 +1,82 @@
+//! Areal number rate (base unit 1 per square meter second, m⁻² · s⁻¹).
+
+quantity! {
+    /// Areal number rate (base unit 1 per square meter second, m⁻² · s⁻¹).
+    quantity: ArealNumberRate; "areal number rate";
+    /// Dimension of areal number rate, L⁻²T⁻¹ (base unit 1 per square meter second, m⁻² · s⁻¹).
+    dimension: ISQ<
+        N2,     // length
+        Z0,     // mass
+        N1,     // time
+        Z0,     // electric current
+        Z0,     // thermodynamic temperature
+        Z0,     // amount of substance
+        Z0>;    // luminous intensity
+    kind: dyn (crate::si::marker::ConstituentConcentrationKind);
+    units {
+        @per_square_meter_second: prefix!(none); "m⁻² · s⁻¹", "per square meter second",
+            "per square meter second";
+        @per_square_centimeter_second: prefix!(none) / prefix!(centi) / prefix!(centi);
+            "cm⁻² · s⁻¹", "per square centimeter second", "per square centimeter second";
+
+        @per_acre_second: prefix!(none) / 4.046_873_E3; "ac⁻¹ · s⁻¹", "per acre second",
+            "per acre second";
+        @per_are_second: prefix!(none) / 1.0_E2; "a⁻¹ · s⁻¹", "per are second", "per are second";
+        @per_barn_second: prefix!(none) / 1.0_E-28; "b⁻¹ · s⁻¹", "per barn second",
+            "per barn second";
+        @per_circular_mil_second: prefix!(none) / 5.067_075_E-10; "cmil⁻¹ · s⁻¹",
+            "per circular mil second", "per circular mil second";
+        @per_hectare_second: prefix!(none) / 1.0_E4; "ha⁻¹ · s⁻¹", "per hectare second",
+            "per hectare second";
+        @per_square_foot_second: prefix!(none) / 9.290_304_E-2; "ft⁻² · s⁻¹",
+            "per square foot second", "per square foot second";
+        @per_square_inch_second: prefix!(none) / 6.451_6_E-4; "in⁻² · s⁻¹",
+            "per square inch second", "per square inch second";
+        @per_square_mile_second: prefix!(none) / 2.589_988_E6; "mi⁻² · s⁻¹",
+            "per square mile second", "per square mile second";
+        @per_square_yard_second: prefix!(none) / 8.361_274_E-1; "yd⁻² · s⁻¹",
+            "per square yard second", "per square yard second";
+    }
+}
+
+#[cfg(test)]
+mod test {
+    storage_types! {
+        use crate::num::One;
+        use crate::si::areal_number_rate as anr;
+        use crate::si::quantities::*;
+        use crate::si::time as t;
+        use crate::si::area as a;
+        use crate::tests::Test;
+
+        #[test]
+        fn check_dimension() {
+            let _: ArealNumberRate<V> = (V::one()
+                / Time::new::<t::second>(V::one())
+                / Area::new::<a::square_meter>(V::one())).into();
+        }
+
+        #[test]
+        fn check_units() {
+            test::<anr::per_square_meter_second, a::square_meter, t::second>();
+            test::<anr::per_square_centimeter_second, a::square_centimeter, t::second>();
+
+            test::<anr::per_acre_second, a::acre, t::second>();
+            test::<anr::per_are_second, a::are, t::second>();
+            test::<anr::per_barn_second, a::barn, t::second>();
+            test::<anr::per_circular_mil_second, a::circular_mil, t::second>();
+            test::<anr::per_hectare_second, a::hectare, t::second>();
+            test::<anr::per_square_foot_second, a::square_foot, t::second>();
+            test::<anr::per_square_inch_second, a::square_inch, t::second>();
+            test::<anr::per_square_mile_second, a::square_mile, t::second>();
+            test::<anr::per_square_yard_second, a::square_yard, t::second>();
+
+            fn test<ANR: anr::Conversion<V>, A: a::Conversion<V>, T: t::Conversion<V>>() {
+                Test::assert_approx_eq(&ArealNumberRate::new::<ANR>(V::one()),
+                    &(V::one()
+                        / Time::new::<T>(V::one())
+                        / Area::new::<A>(V::one())).into());
+            }
+        }
+    }
+}

src/si/electric_charge_areal_density.rs

@@ -0,0 +1,52 @@
+//! Electric charge areal density (base unit coulomb per square meter, m⁻² · A · s).
+
+quantity! {
+    ///Electric charge areal density (base unit coulomb per square meter, m⁻² · A · s).
+    quantity: ElectricChargeArealDensity; "electric charge areal density";
+    /// Dimension of electric charge areal density, L⁻²TI (base unit coulomb per square meter,
+    /// m⁻² · A · s).
+    dimension: ISQ<
+        N2,     // length
+        Z0,     // mass
+        P1,     // time
+        P1,     // electric current
+        Z0,     // thermodynamic temperature
+        Z0,     // amount of substance
+        Z0>;    // luminous intensity
+        kind: dyn (crate::si::marker::ConstituentConcentrationKind);
+    units {
+        @coulomb_per_square_meter: prefix!(none); "C/m²", "coulomb per square meter",
+            "coulombs per square meter";
+        @coulomb_per_square_centimeter: prefix!(none) / prefix!(centi) / prefix!(centi); "C/cm²",
+            "coulomb per square centimeter", "coulombs per square centimeter";
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    storage_types! {
+        use crate::num::One;
+        use crate::si::electric_charge as q;
+        use crate::si::electric_charge_areal_density as ecad;
+        use crate::si::quantities::*;
+        use crate::si::area as a;
+        use crate::tests::Test;
+
+        #[test]
+        fn check_dimension() {
+            let _: ElectricChargeArealDensity<V> = (ElectricCharge::new::<q::coulomb>(V::one())
+                / Area::new::<a::square_meter>(V::one())).into();
+        }
+
+        #[test]
+        fn check_units() {
+            test::<q::coulomb, a::square_meter, ecad::coulomb_per_square_meter>();
+            test::<q::coulomb, a::square_centimeter, ecad::coulomb_per_square_centimeter>();
+
+            fn test<Q: q::Conversion<V>, A: a::Conversion<V>, ECAD: ecad::Conversion<V>>() {
+                Test::assert_approx_eq(&ElectricChargeArealDensity::new::<ECAD>(V::one()),
+                    &(ElectricCharge::new::<Q>(V::one()) / Area::new::<A>(V::one())).into());
+            }
+        }
+    }
+}

src/si/electric_charge_linear_density.rs

@@ -0,0 +1,51 @@
+//! Electric charge linear density (base unit coulomb per meter, m⁻¹ · A · s).
+
+quantity! {
+    ///Electric charge linear density (base unit coulomb per meter, m⁻¹ · A · s).
+    quantity: ElectricChargeLinearDensity; "electric charge linear density";
+    /// Dimension of electric charge linear density, L⁻¹TI (base unit coulomb per meter,
+    /// m⁻¹ · A · s).
+    dimension: ISQ<
+        N1,     // length
+        Z0,     // mass
+        P1,     // time
+        P1,     // electric current
+        Z0,     // thermodynamic temperature
+        Z0,     // amount of substance
+        Z0>;    // luminous intensity
+        kind: dyn (crate::si::marker::ConstituentConcentrationKind);
+    units {
+        @coulomb_per_meter: prefix!(none); "C/m", "coulomb per meter", "coulombs per meter";
+        @coulomb_per_centimeter: prefix!(none) / prefix!(centi); "C/cm", "coulomb per centimeter",
+            "coulombs per centimeter";
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    storage_types! {
+        use crate::num::One;
+        use crate::si::electric_charge as q;
+        use crate::si::electric_charge_linear_density as ecld;
+        use crate::si::quantities::*;
+        use crate::si::length as l;
+        use crate::tests::Test;
+
+        #[test]
+        fn check_dimension() {
+            let _: ElectricChargeLinearDensity<V> = (ElectricCharge::new::<q::coulomb>(V::one())
+                / Length::new::<l::meter>(V::one())).into();
+        }
+
+        #[test]
+        fn check_units() {
+            test::<q::coulomb, l::meter, ecld::coulomb_per_meter>();
+            test::<q::coulomb, l::centimeter, ecld::coulomb_per_centimeter>();
+
+            fn test<Q: q::Conversion<V>, L: l::Conversion<V>, ECLD: ecld::Conversion<V>>() {
+                Test::assert_approx_eq(&ElectricChargeLinearDensity::new::<ECLD>(V::one()),
+                    &(ElectricCharge::new::<Q>(V::one()) / Length::new::<L>(V::one())).into());
+            }
+        }
+    }
+}

src/si/electric_charge_volumetric_density.rs

@@ -0,0 +1,53 @@
+//! Electric charge volumetric density (base unit coulomb per cubic meter, m⁻³ · A · s).
+
+quantity! {
+    ///Electric charge volumetric density (base unit coulomb per cubic meter, m⁻³ · A · s).
+    quantity: ElectricChargeVolumetricDensity; "electric charge volumetric density";
+    /// Dimension of electric charge volumetric density, TIL⁻³ (base unit coulomb per cubic meter,
+    /// m⁻³ · A · s).
+    dimension: ISQ<
+        N3,     // length
+        Z0,     // mass
+        P1,     // time
+        P1,     // electric current
+        Z0,     // thermodynamic temperature
+        Z0,     // amount of substance
+        Z0>;    // luminous intensity
+        kind: dyn (crate::si::marker::ConstituentConcentrationKind);
+    units {
+        @coulomb_per_cubic_meter: prefix!(none); "C/m³", "coulomb per cubic meter",
+            "coulombs per cubic meter";
+        @coulomb_per_cubic_centimeter:
+            prefix!(none) / prefix!(centi) / prefix!(centi) / prefix!(centi); "C/cm³",
+            "coulomb per cubic centimeter", "coulombs per cubic centimeter";
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    storage_types! {
+        use crate::num::One;
+        use crate::si::electric_charge as q;
+        use crate::si::electric_charge_volumetric_density as ecvd;
+        use crate::si::quantities::*;
+        use crate::si::volume as v;
+        use crate::tests::Test;
+
+        #[test]
+        fn check_dimension() {
+            let _: ElectricChargeVolumetricDensity<V> = (ElectricCharge::new::<q::coulomb>(V::one())
+                / Volume::new::<v::cubic_meter>(V::one())).into();
+        }
+
+        #[test]
+        fn check_units() {
+            test::<q::coulomb, v::cubic_meter, ecvd::coulomb_per_cubic_meter>();
+            test::<q::coulomb, v::cubic_centimeter, ecvd::coulomb_per_cubic_centimeter>();
+
+            fn test<Q: q::Conversion<V>, VOL: v::Conversion<V>, ECVD: ecvd::Conversion<V>>() {
+                Test::assert_approx_eq(&ElectricChargeVolumetricDensity::new::<ECVD>(V::one()),
+                    &(ElectricCharge::new::<Q>(V::one()) / Volume::new::<VOL>(V::one())).into());
+            }
+        }
+    }
+}