siderust-js 0.1.0

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

@@ -0,0 +1,212 @@
+//! Dimensionless helpers.
+//!
+//! This module contains small adapters for working with dimensionless values.
+//!
+//! The provided conversion from a dimensioned quantity to a unitless quantity is *lossy*: it drops the unit type
+//! without performing any normalization. The numeric value is preserved as-is.
+//!
+//! ```rust
+//! use qtty_core::time::Seconds;
+//! use qtty_core::{Quantity, Unitless};
+//!
+//! let t = Seconds::new(3.0);
+//! let u: Quantity<Unitless> = t.into();
+//! assert_eq!(u.value(), 3.0);
+//! ```
+
+use crate::dimension::{
+    Acceleration, AmountOfSubstance, Angular, Area, Current, Energy, Force, FrequencyDim, Length,
+    LuminousIntensity, Mass, Power, Temperature, Time, VelocityDim, Volume,
+};
+use crate::scalar::Scalar;
+use crate::{Quantity, Unit, Unitless};
+
+trait SupportedDimension {}
+impl SupportedDimension for Length {}
+impl SupportedDimension for Time {}
+impl SupportedDimension for Mass {}
+impl SupportedDimension for Temperature {}
+impl SupportedDimension for Current {}
+impl SupportedDimension for AmountOfSubstance {}
+impl SupportedDimension for LuminousIntensity {}
+impl SupportedDimension for Angular {}
+impl SupportedDimension for Area {}
+impl SupportedDimension for Volume {}
+impl SupportedDimension for VelocityDim {}
+impl SupportedDimension for Acceleration {}
+impl SupportedDimension for Force {}
+impl SupportedDimension for Energy {}
+impl SupportedDimension for Power {}
+impl SupportedDimension for FrequencyDim {}
+
+trait DimensionedUnit: Unit {}
+impl<U: Unit> DimensionedUnit for U where U::Dim: SupportedDimension {}
+
+impl<U: DimensionedUnit, S: Scalar> From<Quantity<U, S>> for Quantity<Unitless, S> {
+    #[inline]
+    fn from(quantity: Quantity<U, S>) -> Self {
+        Self::new(quantity.value())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::units::angular::Degrees;
+    use crate::units::length::Meters;
+    use crate::units::mass::Kilogram;
+    use crate::units::mass::Kilograms;
+    use crate::units::time::Seconds;
+    use crate::Unit;
+    use approx::assert_abs_diff_eq;
+    use proptest::prelude::*;
+
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Basic Unitless behavior
+    // ─────────────────────────────────────────────────────────────────────────────
+
+    #[test]
+    fn unitless_new_and_value() {
+        let u: Quantity<Unitless> = Quantity::new(42.0);
+        assert_eq!(u.value(), 42.0);
+    }
+
+    #[test]
+    fn unitless_from_f64() {
+        let u: Quantity<Unitless> = 1.23456.into();
+        assert_abs_diff_eq!(u.value(), 1.23456, epsilon = 1e-12);
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Display formatting
+    // ─────────────────────────────────────────────────────────────────────────────
+
+    #[test]
+    fn display_unitless() {
+        let u: Quantity<Unitless> = Quantity::new(123.456);
+        let s = format!("{}", u);
+        assert_eq!(s, "123.456");
+    }
+
+    #[test]
+    fn display_unitless_integer() {
+        let u: Quantity<Unitless> = Quantity::new(42.0);
+        let s = format!("{}", u);
+        assert_eq!(s, "42");
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Conversion from dimensioned quantities
+    // ─────────────────────────────────────────────────────────────────────────────
+
+    #[test]
+    fn from_length() {
+        let m = Meters::new(42.0);
+        let u: Quantity<Unitless> = m.into();
+        assert_eq!(u.value(), 42.0);
+    }
+
+    #[test]
+    fn from_time() {
+        let t = Seconds::new(5.0);
+        let u: Quantity<Unitless> = t.into();
+        assert_eq!(u.value(), 5.0);
+    }
+
+    #[test]
+    fn from_mass() {
+        let m = Kilograms::new(2.5);
+        let u: Quantity<Unitless> = m.into();
+        assert_eq!(u.value(), 2.5);
+    }
+
+    #[test]
+    fn from_angular() {
+        let a = Degrees::new(90.0);
+        let u: Quantity<Unitless> = a.into();
+        assert_eq!(u.value(), 90.0);
+    }
+
+    #[test]
+    fn from_mass_preserves_non_default_scalar_type() {
+        let m: Quantity<Kilogram, i32> = Quantity::new(7);
+        let u: Quantity<Unitless, i32> = m.into();
+        assert_eq!(u.value(), 7);
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Arithmetic operations
+    // ─────────────────────────────────────────────────────────────────────────────
+
+    #[test]
+    fn unitless_addition() {
+        let a: Quantity<Unitless> = Quantity::new(3.0);
+        let b: Quantity<Unitless> = Quantity::new(4.0);
+        assert_eq!((a + b).value(), 7.0);
+    }
+
+    #[test]
+    fn unitless_subtraction() {
+        let a: Quantity<Unitless> = Quantity::new(10.0);
+        let b: Quantity<Unitless> = Quantity::new(3.0);
+        assert_eq!((a - b).value(), 7.0);
+    }
+
+    #[test]
+    fn unitless_multiplication() {
+        let a: Quantity<Unitless> = Quantity::new(3.0);
+        assert_eq!((a * 4.0).value(), 12.0);
+    }
+
+    #[test]
+    fn unitless_division() {
+        let a: Quantity<Unitless> = Quantity::new(12.0);
+        assert_eq!((a / 4.0).value(), 3.0);
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Unit trait implementation
+    // ─────────────────────────────────────────────────────────────────────────────
+
+    #[test]
+    fn unitless_ratio() {
+        assert_eq!(Unitless::RATIO, 1.0);
+    }
+
+    #[test]
+    fn unitless_symbol() {
+        assert_eq!(Unitless::SYMBOL, "");
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Property-based tests
+    // ─────────────────────────────────────────────────────────────────────────────
+
+    proptest! {
+        #[test]
+        fn prop_unitless_arithmetic(a in -1e6..1e6f64, b in -1e6..1e6f64) {
+            let qa: Quantity<Unitless> = Quantity::new(a);
+            let qb: Quantity<Unitless> = Quantity::new(b);
+
+            // Addition is commutative
+            prop_assert!((((qa + qb).value() - (qb + qa).value()).abs() < 1e-9));
+
+            // Value is preserved
+            prop_assert!(((qa + qb).value() - (a + b)).abs() < 1e-9);
+        }
+
+        #[test]
+        fn prop_from_length_preserves_value(v in -1e6..1e6f64) {
+            let m = Meters::new(v);
+            let u: Quantity<Unitless> = m.into();
+            prop_assert!((u.value() - v).abs() < 1e-12);
+        }
+
+        #[test]
+        fn prop_from_time_preserves_value(v in -1e6..1e6f64) {
+            let t = Seconds::new(v);
+            let u: Quantity<Unitless> = t.into();
+            prop_assert!((u.value() - v).abs() < 1e-12);
+        }
+    }
+}

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

@@ -0,0 +1,210 @@
+//! Velocity unit aliases (`Length / Time`).
+//!
+//! This module defines velocity units as *pure type aliases* over [`Per`] using
+//! length and time units already defined elsewhere in the crate.
+//!
+//! No standalone velocity units are introduced: every velocity is represented as
+//! `Length / Time` at the type level.
+//!
+//! ## Design notes
+//!
+//! - The velocity *dimension* is [`Velocity`] = [`Length`] / [`Time`].
+//! - All velocity units are zero-cost type aliases.
+//! - Conversions are handled automatically via the underlying length and time units.
+//! - No assumptions are made about reference frames, relativistic effects, or media.
+//!
+//! ## Examples
+//!
+//! ```rust
+//! use qtty_core::length::{Kilometer, Kilometers};
+//! use qtty_core::time::{Second, Seconds};
+//! use qtty_core::velocity::Velocity;
+//!
+//! let d = Kilometers::new(42.0);
+//! let t = Seconds::new(2.0);
+//! let v: Velocity<Kilometer, Second> = d / t;
+//! assert!((v.value() - 21.0).abs() < 1e-12);
+//! ```
+//!
+//! ```rust
+//! use qtty_core::length::{Meter, Meters};
+//! use qtty_core::time::{Hour, Hours};
+//! use qtty_core::velocity::Velocity;
+//!
+//! let v: Velocity<Meter, Hour> = Meters::new(3_600.0) / Hours::new(1.0);
+//! assert!((v.value() - 3_600.0).abs() < 1e-12);
+//! ```
+
+use crate::{Per, Quantity, Unit};
+
+/// Re-export the velocity dimension from the dimension module.
+pub use crate::dimension::VelocityDim;
+
+/// Marker trait for any unit whose dimension is [`VelocityDim`].
+pub trait VelocityUnit: Unit<Dim = VelocityDim> {}
+impl<T: Unit<Dim = VelocityDim>> VelocityUnit for T {}
+
+/// A velocity quantity parameterized by length and time units.
+///
+/// # Examples
+///
+/// ```rust
+/// use qtty_core::length::{Kilometer, Meter};
+/// use qtty_core::time::{Second, Hour};
+/// use qtty_core::velocity::Velocity;
+///
+/// let v1: Velocity<Meter, Second> = Velocity::new(10.0);
+/// let v2: Velocity<Kilometer, Hour> = Velocity::new(36.0);
+/// ```
+pub type Velocity<N, D> = Quantity<Per<N, D>>;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::units::length::{Au, Kilometer, Kilometers, Meter};
+    use crate::units::time::{Day, Hour, Second, Seconds};
+    use crate::Per;
+    use approx::{assert_abs_diff_eq, assert_relative_eq};
+    use proptest::prelude::*;
+
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Basic velocity conversions
+    // ─────────────────────────────────────────────────────────────────────────────
+
+    #[test]
+    fn km_per_s_to_m_per_s() {
+        let v: Velocity<Kilometer, Second> = Velocity::new(1.0);
+        let v_mps: Velocity<Meter, Second> = v.to();
+        assert_abs_diff_eq!(v_mps.value(), 1000.0, epsilon = 1e-9);
+    }
+
+    #[test]
+    fn m_per_s_to_km_per_s() {
+        let v: Velocity<Meter, Second> = Velocity::new(1000.0);
+        let v_kps: Velocity<Kilometer, Second> = v.to();
+        assert_abs_diff_eq!(v_kps.value(), 1.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn km_per_h_to_m_per_s() {
+        let v: Velocity<Kilometer, Hour> = Velocity::new(3.6);
+        let v_mps: Velocity<Meter, Second> = v.to();
+        // 3.6 km/h = 1 m/s
+        assert_abs_diff_eq!(v_mps.value(), 1.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn km_per_h_to_km_per_s() {
+        let v: Velocity<Kilometer, Hour> = Velocity::new(3600.0);
+        let v_kps: Velocity<Kilometer, Second> = v.to();
+        // 3600 km/h = 1 km/s
+        assert_abs_diff_eq!(v_kps.value(), 1.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn au_per_day_to_km_per_s() {
+        let v: Velocity<Au, Day> = Velocity::new(1.0);
+        let v_kps: Velocity<Kilometer, Second> = v.to();
+        // 1 AU/day = 149,597,870.7 km / 86400 s ≈ 1731.5 km/s
+        assert_relative_eq!(v_kps.value(), 1731.5, max_relative = 1e-3);
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Per ratio behavior
+    // ─────────────────────────────────────────────────────────────────────────────
+
+    #[test]
+    fn per_ratio_km_s() {
+        // Per<Kilometer, Second> should have RATIO = 1000 / 1 = 1000
+        let ratio = <Per<Kilometer, Second>>::RATIO;
+        // Kilometer::RATIO = 1000, Second::RATIO = 1.0
+        // So Per ratio = 1000 / 1.0 = 1000
+        assert_relative_eq!(ratio, 1000.0, max_relative = 1e-12);
+    }
+
+    #[test]
+    fn per_ratio_m_s() {
+        // Per<Meter, Second> has RATIO = 1 / 1 = 1
+        let ratio = <Per<Meter, Second>>::RATIO;
+        assert_relative_eq!(ratio, 1.0, max_relative = 1e-12);
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Velocity * Time = Length
+    // ─────────────────────────────────────────────────────────────────────────────
+
+    #[test]
+    fn velocity_times_time() {
+        let v: Velocity<Kilometer, Second> = Velocity::new(10.0);
+        let t: Seconds = Seconds::new(5.0);
+        let d: Kilometers = (v * t).to();
+        assert_abs_diff_eq!(d.value(), 50.0, epsilon = 1e-9);
+    }
+
+    #[test]
+    fn time_times_velocity() {
+        let v: Velocity<Kilometer, Second> = Velocity::new(10.0);
+        let t: Seconds = Seconds::new(5.0);
+        let d: Kilometers = (t * v).to();
+        assert_abs_diff_eq!(d.value(), 50.0, epsilon = 1e-9);
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Length / Time = Velocity
+    // ─────────────────────────────────────────────────────────────────────────────
+
+    #[test]
+    fn length_div_time() {
+        let d: Kilometers = Kilometers::new(100.0);
+        let t: Seconds = Seconds::new(10.0);
+        let v: Velocity<Kilometer, Second> = d / t;
+        assert_abs_diff_eq!(v.value(), 10.0, epsilon = 1e-9);
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Roundtrip conversions
+    // ─────────────────────────────────────────────────────────────────────────────
+
+    #[test]
+    fn roundtrip_mps_kps() {
+        let original: Velocity<Meter, Second> = Velocity::new(500.0);
+        let converted: Velocity<Kilometer, Second> = original.to();
+        let back: Velocity<Meter, Second> = converted.to();
+        assert_abs_diff_eq!(back.value(), original.value(), epsilon = 1e-9);
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Property-based tests
+    // ─────────────────────────────────────────────────────────────────────────────
+
+    proptest! {
+        #[test]
+        fn prop_roundtrip_mps_kps(v in 1e-6..1e6f64) {
+            let original: Velocity<Meter, Second> = Velocity::new(v);
+            let converted: Velocity<Kilometer, Second> = original.to();
+            let back: Velocity<Meter, Second> = converted.to();
+            prop_assert!((back.value() - original.value()).abs() < 1e-9 * v.abs().max(1.0));
+        }
+
+        #[test]
+        fn prop_mps_kps_ratio(v in 1e-6..1e6f64) {
+            let mps: Velocity<Meter, Second> = Velocity::new(v);
+            let kps: Velocity<Kilometer, Second> = mps.to();
+            // 1000 m/s = 1 km/s
+            prop_assert!((mps.value() / kps.value() - 1000.0).abs() < 1e-9);
+        }
+
+        #[test]
+        fn prop_velocity_time_roundtrip(
+            v_val in 1e-3..1e3f64,
+            t_val in 1e-3..1e3f64
+        ) {
+            let v: Velocity<Kilometer, Second> = Velocity::new(v_val);
+            let t: Seconds = Seconds::new(t_val);
+            let d: Kilometers = (v * t).to();
+            // d / t should give back v
+            let v_back: Velocity<Kilometer, Second> = d / t;
+            prop_assert!((v_back.value() - v.value()).abs() / v.value() < 1e-12);
+        }
+    }
+}

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

@@ -0,0 +1,269 @@
+//! Volume units.
+//!
+//! The canonical scaling unit for this dimension is the **cubic metre** (`CubicMeter::RATIO == 1.0`).
+//! All other volume units are expressed as exact ratios to cubic metres.
+//!
+//! This module provides:
+//!
+//! - **Metric cubes**: cubic millimetre, cubic centimetre, cubic metre, cubic kilometre.
+//! - **Litre family**: microlitre, millilitre, centilitre, decilitre, litre.
+//! - **Imperial/US**: cubic inch, cubic foot, US gallon, US fluid ounce.
+//!
+//! Volume units can also arise *automatically* from multiplying length × area quantities:
+//!
+//! ```rust
+//! use qtty_core::length::{Meter, Meters};
+//! use qtty_core::area::{SquareMeter, SquareMeters};
+//! use qtty_core::volume::{CubicMeters, CubicMeter};
+//! use qtty_core::Prod;
+//!
+//! let side = Meters::new(3.0);
+//! let face: SquareMeters = (side * side).to();
+//! let vol_prod = face * side;                       // Quantity<Prod<SquareMeter, Meter>>
+//! let vol: CubicMeters = vol_prod.to();
+//! assert!((vol.value() - 27.0).abs() < 1e-12);
+//! ```
+//!
+//! ## All volume units
+//!
+//! ```rust
+//! use qtty_core::volume::*;
+//!
+//! macro_rules! touch {
+//!     ($T:ty, $v:expr) => {{ let q = <$T>::new($v); let _c = q; assert!(q == q); }};
+//! }
+//!
+//! touch!(CubicMeters, 1.0);    touch!(CubicKilometers, 1.0);
+//! touch!(CubicCentimeters, 1.0); touch!(CubicMillimeters, 1.0);
+//! touch!(Liters, 1.0);         touch!(Milliliters, 1.0);
+//! touch!(Microliters, 1.0);    touch!(Centiliters, 1.0);
+//! touch!(Deciliters, 1.0);     touch!(CubicInches, 1.0);
+//! touch!(CubicFeet, 1.0);      touch!(UsGallons, 1.0);
+//! touch!(UsFluidOunces, 1.0);
+//! ```
+
+use crate::{Quantity, Unit};
+use qtty_derive::Unit;
+
+/// Re-export the volume dimension from the dimension module.
+pub use crate::dimension::Volume;
+
+/// Marker trait for any [`Unit`] whose dimension is [`Volume`].
+pub trait VolumeUnit: Unit<Dim = Volume> {}
+impl<T: Unit<Dim = Volume>> VolumeUnit for T {}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// SI / metric volume units
+// ─────────────────────────────────────────────────────────────────────────────
+
+/// Cubic metre (SI derived unit of volume).
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Unit)]
+#[unit(symbol = "m³", dimension = Volume, ratio = 1.0)]
+pub struct CubicMeter;
+/// A quantity measured in cubic metres.
+pub type CubicMeters = Quantity<CubicMeter>;
+
+/// Cubic kilometre (`1e9 m³`).
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Unit)]
+#[unit(symbol = "km³", dimension = Volume, ratio = 1e9)]
+pub struct CubicKilometer;
+/// A quantity measured in cubic kilometres.
+pub type CubicKilometers = Quantity<CubicKilometer>;
+
+/// Cubic centimetre (`1e-6 m³`).
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Unit)]
+#[unit(symbol = "cm³", dimension = Volume, ratio = 1e-6)]
+pub struct CubicCentimeter;
+/// A quantity measured in cubic centimetres.
+pub type CubicCentimeters = Quantity<CubicCentimeter>;
+
+/// Cubic millimetre (`1e-9 m³`).
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Unit)]
+#[unit(symbol = "mm³", dimension = Volume, ratio = 1e-9)]
+pub struct CubicMillimeter;
+/// A quantity measured in cubic millimetres.
+pub type CubicMillimeters = Quantity<CubicMillimeter>;
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Litre family
+// ─────────────────────────────────────────────────────────────────────────────
+
+/// Litre (`1e-3 m³`, exact).
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Unit)]
+#[unit(symbol = "L", dimension = Volume, ratio = 1e-3)]
+pub struct Liter;
+/// A quantity measured in litres.
+pub type Liters = Quantity<Liter>;
+
+/// Millilitre (`1e-6 m³`, exact).
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Unit)]
+#[unit(symbol = "mL", dimension = Volume, ratio = 1e-6)]
+pub struct Milliliter;
+/// A quantity measured in millilitres.
+pub type Milliliters = Quantity<Milliliter>;
+
+/// Microlitre (`1e-9 m³`, exact).
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Unit)]
+#[unit(symbol = "µL", dimension = Volume, ratio = 1e-9)]
+pub struct Microliter;
+/// A quantity measured in microlitres.
+pub type Microliters = Quantity<Microliter>;
+
+/// Centilitre (`1e-5 m³`, exact).
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Unit)]
+#[unit(symbol = "cL", dimension = Volume, ratio = 1e-5)]
+pub struct Centiliter;
+/// A quantity measured in centilitres.
+pub type Centiliters = Quantity<Centiliter>;
+
+/// Decilitre (`1e-4 m³`, exact).
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Unit)]
+#[unit(symbol = "dL", dimension = Volume, ratio = 1e-4)]
+pub struct Deciliter;
+/// A quantity measured in decilitres.
+pub type Deciliters = Quantity<Deciliter>;
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Imperial / US customary volume units
+// ─────────────────────────────────────────────────────────────────────────────
+
+/// Cubic inch (`1.6387064e-5 m³`, exact: `0.0254³ m³`).
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Unit)]
+#[unit(symbol = "in³", dimension = Volume, ratio = 1.638_706_4e-5)]
+pub struct CubicInch;
+/// A quantity measured in cubic inches.
+pub type CubicInches = Quantity<CubicInch>;
+
+/// Cubic foot (`0.028316846592 m³`, exact: `0.3048³ m³`).
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Unit)]
+#[unit(symbol = "ft³", dimension = Volume, ratio = 0.028_316_846_592)]
+pub struct CubicFoot;
+/// A quantity measured in cubic feet.
+pub type CubicFeet = Quantity<CubicFoot>;
+
+/// US liquid gallon (`0.003785411784 m³`, exact: `231 in³`).
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Unit)]
+#[unit(symbol = "gal", dimension = Volume, ratio = 0.003_785_411_784)]
+pub struct UsGallon;
+/// A quantity measured in US gallons.
+pub type UsGallons = Quantity<UsGallon>;
+
+/// US fluid ounce (`2.95735295625e-5 m³`, exact: `gal / 128`).
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Unit)]
+#[unit(symbol = "fl oz", dimension = Volume, ratio = 2.957_352_956_25e-5)]
+pub struct UsFluidOunce;
+/// A quantity measured in US fluid ounces.
+pub type UsFluidOunces = Quantity<UsFluidOunce>;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use approx::assert_abs_diff_eq;
+
+    #[test]
+    fn liter_to_cubic_meter() {
+        let l = Liters::new(1.0);
+        let m: CubicMeters = l.to();
+        assert_abs_diff_eq!(m.value(), 0.001, epsilon = 1e-15);
+    }
+
+    #[test]
+    fn milliliter_to_liter() {
+        let ml = Milliliters::new(1000.0);
+        let l: Liters = ml.to();
+        assert_abs_diff_eq!(l.value(), 1.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn cubic_cm_to_ml() {
+        let cc = CubicCentimeters::new(1.0);
+        let ml: Milliliters = cc.to();
+        assert_abs_diff_eq!(ml.value(), 1.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn us_gallon_to_liter() {
+        let g = UsGallons::new(1.0);
+        let l: Liters = g.to();
+        assert_abs_diff_eq!(l.value(), 3.785_411_784, epsilon = 1e-6);
+    }
+
+    #[test]
+    fn cubic_foot_to_liter() {
+        let cf = CubicFeet::new(1.0);
+        let l: Liters = cf.to();
+        assert_abs_diff_eq!(l.value(), 28.316_846_592, epsilon = 1e-6);
+    }
+
+    #[test]
+    fn length_times_area_to_volume() {
+        use crate::area::{SquareMeter, SquareMeters};
+        use crate::length::{Meter, Meters};
+        use crate::Prod;
+
+        let side = Meters::new(3.0);
+        let face: SquareMeters = (side * side).to();
+        let vol_prod: Quantity<Prod<SquareMeter, Meter>> = face * side;
+        let vol: CubicMeters = vol_prod.to();
+        assert_abs_diff_eq!(vol.value(), 27.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn cubic_km_to_liter() {
+        let ckm = CubicKilometers::new(1.0);
+        let l: Liters = ckm.to();
+        assert_abs_diff_eq!(l.value(), 1e12, epsilon = 1e3);
+    }
+
+    #[test]
+    fn cubic_mm_to_cubic_cm() {
+        let mm3 = CubicMillimeters::new(1000.0);
+        let cm3: CubicCentimeters = mm3.to();
+        assert_abs_diff_eq!(cm3.value(), 1.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn microliter_to_milliliter() {
+        let ul = Microliters::new(1000.0);
+        let ml: Milliliters = ul.to();
+        assert_abs_diff_eq!(ml.value(), 1.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn centiliter_to_liter() {
+        let cl = Centiliters::new(100.0);
+        let l: Liters = cl.to();
+        assert_abs_diff_eq!(l.value(), 1.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn deciliter_to_liter() {
+        let dl = Deciliters::new(10.0);
+        let l: Liters = dl.to();
+        assert_abs_diff_eq!(l.value(), 1.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn cubic_inch_to_cubic_cm() {
+        let cin = CubicInches::new(1.0);
+        let cc: CubicCentimeters = cin.to();
+        // 1 in³ = 16.387064 cm³
+        assert_abs_diff_eq!(cc.value(), 16.387_064, epsilon = 1e-4);
+    }
+
+    #[test]
+    fn us_fluid_ounce_to_milliliter() {
+        let floz = UsFluidOunces::new(1.0);
+        let ml: Milliliters = floz.to();
+        // 1 US fl oz ≈ 29.5735 mL
+        assert_abs_diff_eq!(ml.value(), 29.573_529_562_5, epsilon = 1e-6);
+    }
+
+    #[test]
+    fn symbols_are_correct() {
+        assert_eq!(CubicMeter::SYMBOL, "m³");
+        assert_eq!(Liter::SYMBOL, "L");
+        assert_eq!(Milliliter::SYMBOL, "mL");
+        assert_eq!(UsGallon::SYMBOL, "gal");
+    }
+}