siderust-js 0.1.0

package/qtty-js/qtty/qtty-core/src/units/area.rs

@@ -0,0 +1,243 @@
+//! Area units.
+//!
+//! The canonical scaling unit for this dimension is the **square metre** (`SquareMeter::RATIO == 1.0`).
+//! All other area units are expressed as exact ratios to square metres.
+//!
+//! This module provides:
+//!
+//! - **Metric squares**: square millimetre, square centimetre, square metre, square kilometre.
+//! - **Land measurement**: hectare, are.
+//! - **Imperial/US**: square inch, square foot, square yard, square mile, acre.
+//!
+//! Area units can also arise *automatically* from multiplying two length quantities:
+//!
+//! ```rust
+//! use qtty_core::length::{Meter, Meters};
+//! use qtty_core::area::{SquareMeters, SquareMeter};
+//! use qtty_core::Prod;
+//!
+//! let side = Meters::new(5.0);
+//! let area_prod = side * side;                     // Quantity<Prod<Meter, Meter>>
+//! let area: SquareMeters = area_prod.to();          // Convert to named area unit
+//! assert!((area.value() - 25.0).abs() < 1e-12);
+//! ```
+//!
+//! ## All area units
+//!
+//! ```rust
+//! use qtty_core::area::*;
+//!
+//! macro_rules! touch {
+//!     ($T:ty, $v:expr) => {{ let q = <$T>::new($v); let _c = q; assert!(q == q); }};
+//! }
+//!
+//! touch!(SquareMeters, 1.0);     touch!(SquareKilometers, 1.0);
+//! touch!(SquareCentimeters, 1.0);touch!(SquareMillimeters, 1.0);
+//! touch!(Hectares, 1.0);         touch!(Ares, 1.0);
+//! touch!(SquareInches, 1.0);     touch!(SquareFeet, 1.0);
+//! touch!(SquareYards, 1.0);      touch!(SquareMiles, 1.0);
+//! touch!(Acres, 1.0);
+//! ```
+
+use crate::{Quantity, Unit};
+use qtty_derive::Unit;
+
+/// Re-export the area dimension from the dimension module.
+pub use crate::dimension::Area;
+
+/// Marker trait for any [`Unit`] whose dimension is [`Area`].
+pub trait AreaUnit: Unit<Dim = Area> {}
+impl<T: Unit<Dim = Area>> AreaUnit for T {}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// SI / metric area units
+// ─────────────────────────────────────────────────────────────────────────────
+
+/// Square metre (SI derived unit of area).
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Unit)]
+#[unit(symbol = "m²", dimension = Area, ratio = 1.0)]
+pub struct SquareMeter;
+/// A quantity measured in square metres.
+pub type SquareMeters = Quantity<SquareMeter>;
+
+/// Square kilometre (`1e6 m²`).
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Unit)]
+#[unit(symbol = "km²", dimension = Area, ratio = 1e6)]
+pub struct SquareKilometer;
+/// A quantity measured in square kilometres.
+pub type SquareKilometers = Quantity<SquareKilometer>;
+
+/// Square centimetre (`1e-4 m²`).
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Unit)]
+#[unit(symbol = "cm²", dimension = Area, ratio = 1e-4)]
+pub struct SquareCentimeter;
+/// A quantity measured in square centimetres.
+pub type SquareCentimeters = Quantity<SquareCentimeter>;
+
+/// Square millimetre (`1e-6 m²`).
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Unit)]
+#[unit(symbol = "mm²", dimension = Area, ratio = 1e-6)]
+pub struct SquareMillimeter;
+/// A quantity measured in square millimetres.
+pub type SquareMillimeters = Quantity<SquareMillimeter>;
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Land measurement
+// ─────────────────────────────────────────────────────────────────────────────
+
+/// Hectare (`10 000 m²`).
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Unit)]
+#[unit(symbol = "ha", dimension = Area, ratio = 1e4)]
+pub struct Hectare;
+/// A quantity measured in hectares.
+pub type Hectares = Quantity<Hectare>;
+
+/// Are (`100 m²`).
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Unit)]
+#[unit(symbol = "a", dimension = Area, ratio = 100.0)]
+pub struct Are;
+/// A quantity measured in ares.
+pub type Ares = Quantity<Are>;
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Imperial / US customary area units
+// ─────────────────────────────────────────────────────────────────────────────
+
+/// Square inch (`6.4516e-4 m²`, exact: `0.0254² m²`).
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Unit)]
+#[unit(symbol = "in²", dimension = Area, ratio = 6.4516e-4)]
+pub struct SquareInch;
+/// A quantity measured in square inches.
+pub type SquareInches = Quantity<SquareInch>;
+
+/// Square foot (`0.09290304 m²`, exact: `0.3048² m²`).
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Unit)]
+#[unit(symbol = "ft²", dimension = Area, ratio = 0.09290304)]
+pub struct SquareFoot;
+/// A quantity measured in square feet.
+pub type SquareFeet = Quantity<SquareFoot>;
+
+/// Square yard (`0.83612736 m²`, exact: `0.9144² m²`).
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Unit)]
+#[unit(symbol = "yd²", dimension = Area, ratio = 0.83612736)]
+pub struct SquareYard;
+/// A quantity measured in square yards.
+pub type SquareYards = Quantity<SquareYard>;
+
+/// Square mile (`2_589_988.110336 m²`, exact: `1609.344² m²`).
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Unit)]
+#[unit(symbol = "mi²", dimension = Area, ratio = 2_589_988.110_336)]
+pub struct SquareMile;
+/// A quantity measured in square miles.
+pub type SquareMiles = Quantity<SquareMile>;
+
+/// Acre (exactly `4046.8564224 m²`).
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Unit)]
+#[unit(symbol = "ac", dimension = Area, ratio = 4_046.856_422_4)]
+pub struct Acre;
+/// A quantity measured in acres.
+pub type Acres = Quantity<Acre>;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use approx::assert_abs_diff_eq;
+
+    #[test]
+    fn sqm_to_sqkm() {
+        let a = SquareMeters::new(1_000_000.0);
+        let b: SquareKilometers = a.to();
+        assert_abs_diff_eq!(b.value(), 1.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn hectare_to_sqm() {
+        let a = Hectares::new(1.0);
+        let b: SquareMeters = a.to();
+        assert_abs_diff_eq!(b.value(), 10_000.0, epsilon = 1e-9);
+    }
+
+    #[test]
+    fn acre_to_hectare() {
+        let a = Acres::new(1.0);
+        let b: Hectares = a.to();
+        assert_abs_diff_eq!(b.value(), 0.404_685_642_24, epsilon = 1e-9);
+    }
+
+    #[test]
+    fn sqft_to_sqm() {
+        let a = SquareFeet::new(1.0);
+        let b: SquareMeters = a.to();
+        assert_abs_diff_eq!(b.value(), 0.092_903_04, epsilon = 1e-9);
+    }
+
+    #[test]
+    fn length_product_to_area() {
+        use crate::length::{Meter, Meters};
+        use crate::Prod;
+
+        let side = Meters::new(5.0);
+        let area_prod: Quantity<Prod<Meter, Meter>> = side * side;
+        let area: SquareMeters = area_prod.to();
+        assert_abs_diff_eq!(area.value(), 25.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn sqmile_to_sqkm() {
+        let a = SquareMiles::new(1.0);
+        let b: SquareKilometers = a.to();
+        assert_abs_diff_eq!(b.value(), 2.589_988_110_336, epsilon = 1e-6);
+    }
+
+    #[test]
+    fn sqcm_to_sqm() {
+        let a = SquareCentimeters::new(10_000.0);
+        let b: SquareMeters = a.to();
+        assert_abs_diff_eq!(b.value(), 1.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn sqmm_to_sqcm() {
+        let a = SquareMillimeters::new(100.0);
+        let b: SquareCentimeters = a.to();
+        assert_abs_diff_eq!(b.value(), 1.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn are_to_sqm() {
+        let a = Ares::new(1.0);
+        let b: SquareMeters = a.to();
+        assert_abs_diff_eq!(b.value(), 100.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn sqinch_to_sqcm() {
+        let a = SquareInches::new(1.0);
+        let b: SquareCentimeters = a.to();
+        // 1 in² = 6.4516 cm²
+        assert_abs_diff_eq!(b.value(), 6.4516, epsilon = 1e-9);
+    }
+
+    #[test]
+    fn sqyard_to_sqm() {
+        let a = SquareYards::new(1.0);
+        let b: SquareMeters = a.to();
+        assert_abs_diff_eq!(b.value(), 0.836_127_36, epsilon = 1e-9);
+    }
+
+    #[test]
+    fn roundtrip_sqcm_sqm() {
+        let original = SquareCentimeters::new(250.0);
+        let converted = original.to::<SquareMeter>();
+        let back = converted.to::<SquareCentimeter>();
+        assert_abs_diff_eq!(back.value(), original.value(), epsilon = 1e-10);
+    }
+
+    #[test]
+    fn symbols_are_correct() {
+        assert_eq!(SquareMeter::SYMBOL, "m²");
+        assert_eq!(Hectare::SYMBOL, "ha");
+        assert_eq!(Acre::SYMBOL, "ac");
+        assert_eq!(SquareInch::SYMBOL, "in²");
+    }
+}

package/qtty-js/qtty/qtty-core/src/units/frequency.rs

@@ -0,0 +1,179 @@
+//! Angular frequency unit aliases (`Angular / Time`).
+//!
+//! This module provides a **dimension alias** [`Frequency`].
+//!
+//! ```rust
+//! use qtty_core::angular::{Degree, Radian};
+//! use qtty_core::time::Day;
+//! use qtty_core::frequency::Frequency;
+//!
+//! let f: Frequency<Degree, Day> = Frequency::new(180.0);
+//! let f_rad: Frequency<Radian, Day> = f.to();
+//! assert!((f_rad.value() - core::f64::consts::PI).abs() < 1e-12);
+//! ```
+
+use crate::{Per, Quantity, Unit};
+
+/// Re-export the frequency dimension from the dimension module.
+pub use crate::dimension::FrequencyDim;
+
+/// Marker trait for any unit with frequency dimension (`Angular / Time`).
+pub trait FrequencyUnit: Unit<Dim = FrequencyDim> {}
+impl<T: Unit<Dim = FrequencyDim>> FrequencyUnit for T {}
+
+/// A frequency quantity parameterized by angular and time units.
+///
+/// # Examples
+///
+/// ```rust
+/// use qtty_core::angular::{Degree, Radian};
+/// use qtty_core::time::{Second, Day};
+/// use qtty_core::frequency::Frequency;
+///
+/// let f1: Frequency<Degree, Second> = Frequency::new(360.0);
+/// let f2: Frequency<Radian, Day> = Frequency::new(6.28);
+/// ```
+pub type Frequency<N, D> = Quantity<Per<N, D>>;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::units::angular::{Degree, Degrees, MilliArcsecond, Radian};
+    use crate::units::time::{Day, Days, Year};
+    use crate::Per;
+    use approx::{assert_abs_diff_eq, assert_relative_eq};
+    use proptest::prelude::*;
+    use std::f64::consts::PI;
+
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Basic frequency conversions
+    // ─────────────────────────────────────────────────────────────────────────────
+
+    #[test]
+    fn deg_per_day_to_rad_per_day() {
+        let f: Frequency<Degree, Day> = Frequency::new(180.0);
+        let f_rad: Frequency<Radian, Day> = f.to();
+        // 180 deg = π rad
+        assert_abs_diff_eq!(f_rad.value(), PI, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn rad_per_day_to_deg_per_day() {
+        let f: Frequency<Radian, Day> = Frequency::new(PI);
+        let f_deg: Frequency<Degree, Day> = f.to();
+        assert_abs_diff_eq!(f_deg.value(), 180.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn deg_per_day_to_deg_per_year() {
+        let f: Frequency<Degree, Day> = Frequency::new(1.0);
+        let f_year: Frequency<Degree, Year> = f.to();
+        // 1 deg/day = 365.2425 deg/year (tropical year)
+        assert_relative_eq!(f_year.value(), 365.2425, max_relative = 1e-6);
+    }
+
+    #[test]
+    fn deg_per_year_to_deg_per_day() {
+        let f: Frequency<Degree, Year> = Frequency::new(365.2425);
+        let f_day: Frequency<Degree, Day> = f.to();
+        assert_relative_eq!(f_day.value(), 1.0, max_relative = 1e-6);
+    }
+
+    #[test]
+    fn mas_per_day_to_deg_per_day() {
+        let f: Frequency<MilliArcsecond, Day> = Frequency::new(3_600_000.0);
+        let f_deg: Frequency<Degree, Day> = f.to();
+        // 3,600,000 mas = 1 deg
+        assert_abs_diff_eq!(f_deg.value(), 1.0, epsilon = 1e-9);
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Per ratio behavior
+    // ─────────────────────────────────────────────────────────────────────────────
+
+    #[test]
+    fn per_ratio_deg_day() {
+        // Degree::RATIO = 1.0, Day::RATIO = 86400.0
+        // So Per<Degree, Day>::RATIO = 1.0 / 86400.0
+        let ratio = <Per<Degree, Day>>::RATIO;
+        assert_abs_diff_eq!(ratio, 1.0 / 86400.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn per_ratio_rad_day() {
+        // Radian::RATIO = 180/π, Day::RATIO = 86400.0
+        let ratio = <Per<Radian, Day>>::RATIO;
+        assert_relative_eq!(ratio, (180.0 / PI) / 86400.0, max_relative = 1e-12);
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Frequency * Time = Angle
+    // ─────────────────────────────────────────────────────────────────────────────
+
+    #[test]
+    fn frequency_times_time() {
+        let f: Frequency<Degree, Day> = Frequency::new(360.0);
+        let t: Days = Days::new(0.5);
+        let angle: Degrees = (f * t).to();
+        assert_abs_diff_eq!(angle.value(), 180.0, epsilon = 1e-9);
+    }
+
+    #[test]
+    fn time_times_frequency() {
+        let f: Frequency<Degree, Day> = Frequency::new(360.0);
+        let t: Days = Days::new(0.5);
+        let angle: Degrees = (t * f).to();
+        assert_abs_diff_eq!(angle.value(), 180.0, epsilon = 1e-9);
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Angle / Time = Frequency
+    // ─────────────────────────────────────────────────────────────────────────────
+
+    #[test]
+    fn angle_div_time() {
+        let angle: Degrees = Degrees::new(360.0);
+        let t: Days = Days::new(1.0);
+        let f: Frequency<Degree, Day> = angle / t;
+        assert_abs_diff_eq!(f.value(), 360.0, epsilon = 1e-9);
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Roundtrip conversions
+    // ─────────────────────────────────────────────────────────────────────────────
+
+    #[test]
+    fn roundtrip_deg_rad_per_day() {
+        let original: Frequency<Degree, Day> = Frequency::new(90.0);
+        let converted: Frequency<Radian, Day> = original.to();
+        let back: Frequency<Degree, Day> = converted.to();
+        assert_abs_diff_eq!(back.value(), original.value(), epsilon = 1e-9);
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Property-based tests
+    // ─────────────────────────────────────────────────────────────────────────────
+
+    proptest! {
+        #[test]
+        fn prop_roundtrip_deg_rad_per_day(f in 1e-6..1e6f64) {
+            let original: Frequency<Degree, Day> = Frequency::new(f);
+            let converted: Frequency<Radian, Day> = original.to();
+            let back: Frequency<Degree, Day> = converted.to();
+            prop_assert!((back.value() - original.value()).abs() < 1e-9 * f.abs().max(1.0));
+        }
+
+        #[test]
+        fn prop_frequency_time_roundtrip(
+            f_val in 1e-3..1e3f64,
+            t_val in 1e-3..1e3f64
+        ) {
+            let f: Frequency<Degree, Day> = Frequency::new(f_val);
+            let t: Days = Days::new(t_val);
+            let angle: Degrees = (f * t).to();
+            // angle / t should give back f
+            let f_back: Frequency<Degree, Day> = angle / t;
+            prop_assert!((f_back.value() - f.value()).abs() / f.value() < 1e-12);
+        }
+    }
+}