siderust-js 0.1.0

package/qtty-js/qtty/qtty-core/tests/scalar_decimal.rs

@@ -0,0 +1,258 @@
+#![cfg(feature = "scalar-decimal")]
+
+use qtty_core::length::Meter;
+use qtty_core::scalar::{Exact, Real, Scalar};
+use qtty_core::Quantity;
+use rust_decimal::Decimal;
+
+#[test]
+fn test_decimal_scalar_basic() {
+    assert_eq!(Decimal::ZERO, Decimal::from(0));
+    assert_eq!(Decimal::ONE, Decimal::from(1));
+}
+
+#[test]
+fn test_decimal_abs() {
+    let val = Decimal::from(-5);
+    assert_eq!(Scalar::abs(val), Decimal::from(5));
+}
+
+#[test]
+fn test_decimal_min_max() {
+    let a = Decimal::from(3);
+    let b = Decimal::from(7);
+    assert_eq!(Scalar::min(a, b), Decimal::from(3));
+    assert_eq!(Scalar::max(a, b), Decimal::from(7));
+}
+
+#[test]
+fn test_decimal_rem_euclid() {
+    let val = Decimal::from(17);
+    let modulus = Decimal::from(5);
+    assert_eq!(Scalar::rem_euclid(val, modulus), Decimal::from(2));
+}
+
+#[test]
+fn test_decimal_real_constants() {
+    let pi = Decimal::PI;
+    assert!(pi.to_f64() > 3.14);
+    assert!(pi.to_f64() < 3.15);
+}
+
+#[test]
+fn test_decimal_from_to_f64() {
+    let val = Decimal::from_f64(42.5);
+    assert!((val.to_f64() - 42.5).abs() < 0.01);
+}
+
+#[test]
+fn test_decimal_is_nan_infinite() {
+    let val = Decimal::from(100);
+    assert!(!val.is_nan());
+    assert!(!val.is_infinite());
+    assert!(val.is_finite());
+}
+
+#[test]
+fn test_decimal_exact_conversion() {
+    let val = Decimal::from(1000);
+    let f64_val = Exact::to_f64_approx(val);
+    assert_eq!(f64_val, 1000.0);
+    let back: Decimal = Exact::from_f64_approx(f64_val);
+    assert_eq!(back, Decimal::from(1000));
+}
+
+#[test]
+fn test_decimal_quantity() {
+    let m = Quantity::<Meter, Decimal>::new(Decimal::from(100));
+    assert_eq!(m.value(), Decimal::from(100));
+}
+
+#[test]
+fn test_decimal_quantity_arithmetic() {
+    let a = Quantity::<Meter, Decimal>::new(Decimal::from(10));
+    let b = Quantity::<Meter, Decimal>::new(Decimal::from(5));
+    let sum = a + b;
+    assert_eq!(sum.value(), Decimal::from(15));
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Decimal Real methods (coverage for scalar.rs decimal_impl)
+// ─────────────────────────────────────────────────────────────────────────────
+
+#[test]
+fn test_decimal_signum_positive() {
+    let val = Decimal::from(42);
+    assert_eq!(Real::signum(val), Decimal::ONE);
+}
+
+#[test]
+fn test_decimal_signum_negative() {
+    let val = Decimal::from(-42);
+    assert_eq!(Real::signum(val), Decimal::NEGATIVE_ONE);
+}
+
+#[test]
+fn test_decimal_signum_zero() {
+    assert_eq!(Real::signum(Decimal::ZERO), Decimal::ZERO);
+}
+
+#[test]
+fn test_decimal_mul_add() {
+    let result = Real::mul_add(Decimal::from(2), Decimal::from(3), Decimal::from(4));
+    assert_eq!(result, Decimal::from(10));
+}
+
+#[test]
+fn test_decimal_floor() {
+    let val = Decimal::try_from(3.7).unwrap();
+    assert_eq!(Real::floor(val), Decimal::from(3));
+    let val = Decimal::try_from(-3.7).unwrap();
+    assert_eq!(Real::floor(val), Decimal::from(-4));
+}
+
+#[test]
+fn test_decimal_ceil() {
+    let val = Decimal::try_from(3.2).unwrap();
+    assert_eq!(Real::ceil(val), Decimal::from(4));
+    let val = Decimal::try_from(-3.2).unwrap();
+    assert_eq!(Real::ceil(val), Decimal::from(-3));
+}
+
+#[test]
+fn test_decimal_round() {
+    let val = Decimal::try_from(3.5).unwrap();
+    assert_eq!(Real::round(val), Decimal::from(4));
+    let val = Decimal::try_from(3.4).unwrap();
+    assert_eq!(Real::round(val), Decimal::from(3));
+}
+
+#[test]
+fn test_decimal_trunc() {
+    let val = Decimal::try_from(3.9).unwrap();
+    assert_eq!(Real::trunc(val), Decimal::from(3));
+    let val = Decimal::try_from(-3.9).unwrap();
+    assert_eq!(Real::trunc(val), Decimal::from(-3));
+}
+
+#[test]
+fn test_decimal_fract() {
+    let val = Decimal::try_from(3.75).unwrap();
+    let frac = Real::fract(val);
+    assert!((Exact::to_f64_approx(frac) - 0.75).abs() < 0.01);
+}
+
+#[test]
+fn test_decimal_powf() {
+    let result = Real::powf(Decimal::from(2), Decimal::from(10));
+    assert!((Exact::to_f64_approx(result) - 1024.0).abs() < 1.0);
+}
+
+#[test]
+fn test_decimal_powi() {
+    let result = Real::powi(Decimal::from(3), 4);
+    assert_eq!(result, Decimal::from(81));
+}
+
+#[test]
+fn test_decimal_sqrt() {
+    let result = Real::sqrt(Decimal::from(16));
+    assert_eq!(result, Decimal::from(4));
+}
+
+#[test]
+fn test_decimal_cbrt() {
+    let result = Real::cbrt(Decimal::from(27));
+    assert!((Exact::to_f64_approx(result) - 3.0).abs() < 0.01);
+}
+
+#[test]
+fn test_decimal_ln() {
+    let result = Real::ln(Decimal::ONE);
+    assert!((Exact::to_f64_approx(result)).abs() < 0.01);
+}
+
+#[test]
+fn test_decimal_log10() {
+    let result = Real::log10(Decimal::from(100));
+    assert!((Exact::to_f64_approx(result) - 2.0).abs() < 0.01);
+}
+
+#[test]
+fn test_decimal_log2() {
+    let result = Real::log2(Decimal::from(8));
+    assert!((Exact::to_f64_approx(result) - 3.0).abs() < 0.01);
+}
+
+#[test]
+fn test_decimal_log_base() {
+    let result = Real::log(Decimal::from(1000), Decimal::from(10));
+    assert!((Exact::to_f64_approx(result) - 3.0).abs() < 0.01);
+}
+
+#[test]
+fn test_decimal_exp() {
+    let result = Real::exp(Decimal::ZERO);
+    assert!((Exact::to_f64_approx(result) - 1.0).abs() < 0.01);
+}
+
+#[test]
+fn test_decimal_exp2() {
+    let result = Real::exp2(Decimal::from(10));
+    assert!((Exact::to_f64_approx(result) - 1024.0).abs() < 1.0);
+}
+
+#[test]
+fn test_decimal_hypot() {
+    let result = Real::hypot(Decimal::from(3), Decimal::from(4));
+    assert!((Exact::to_f64_approx(result) - 5.0).abs() < 0.01);
+}
+
+#[test]
+fn test_decimal_rem_euclid_negative() {
+    // Test negative remainder path
+    let val = Decimal::from(-10);
+    let modulus = Decimal::from(3);
+    let result = Scalar::rem_euclid(val, modulus);
+    assert!((Exact::to_f64_approx(result) - 2.0).abs() < 0.01);
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Commutative multiplication: Decimal * Quantity
+// ─────────────────────────────────────────────────────────────────────────────
+
+#[test]
+fn test_decimal_commutative_mul() {
+    let q = Quantity::<Meter, Decimal>::new(Decimal::from(5));
+    let result = Decimal::from(3) * q;
+    assert_eq!(result.value(), Decimal::from(15));
+    let result2 = q * Decimal::from(3);
+    assert_eq!(result2.value(), Decimal::from(15));
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Decimal Quantity: to_lossy, Display, to, cast
+// ─────────────────────────────────────────────────────────────────────────────
+
+#[test]
+fn test_decimal_quantity_to() {
+    use qtty_core::length::Kilometer;
+    let km = Quantity::<Kilometer, Decimal>::new(Decimal::from(1));
+    let m: Quantity<Meter, Decimal> = km.to();
+    assert_eq!(m.value(), Decimal::from(1000));
+}
+
+#[test]
+fn test_decimal_quantity_display() {
+    let m = Quantity::<Meter, Decimal>::new(Decimal::from(42));
+    assert_eq!(format!("{}", m), "42 m");
+}
+
+#[test]
+fn test_decimal_to_lossy() {
+    use qtty_core::length::Kilometer;
+    let m = Quantity::<Meter, Decimal>::new(Decimal::from(1500));
+    let km: Quantity<Kilometer, Decimal> = m.to_lossy();
+    // 1500/1000 = 1.5, to_f64_approx and back should give close to 1.5
+    assert!((Exact::to_f64_approx(km.value()) - 1.5).abs() < 0.01);
+}

package/qtty-js/qtty/qtty-core/tests/scalar_f32.rs

@@ -0,0 +1,286 @@
+//! Tests for f32 Scalar + Real + Transcendental trait methods (coverage for scalar.rs).
+
+use qtty_core::scalar::{Real, Scalar, Transcendental};
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Scalar methods for f32
+// ─────────────────────────────────────────────────────────────────────────────
+
+#[test]
+fn f32_scalar_zero_one() {
+    assert_eq!(f32::ZERO, 0.0_f32);
+    assert_eq!(f32::ONE, 1.0_f32);
+}
+
+#[test]
+fn f32_abs() {
+    assert_eq!(Scalar::abs(-5.0_f32), 5.0);
+    assert_eq!(Scalar::abs(5.0_f32), 5.0);
+    assert_eq!(Scalar::abs(0.0_f32), 0.0);
+}
+
+#[test]
+fn f32_min() {
+    assert_eq!(Scalar::min(3.0_f32, 7.0), 3.0);
+    assert_eq!(Scalar::min(7.0_f32, 3.0), 3.0);
+    assert_eq!(Scalar::min(-1.0_f32, 1.0), -1.0);
+}
+
+#[test]
+fn f32_max() {
+    assert_eq!(Scalar::max(3.0_f32, 7.0), 7.0);
+    assert_eq!(Scalar::max(7.0_f32, 3.0), 7.0);
+    assert_eq!(Scalar::max(-1.0_f32, 1.0), 1.0);
+}
+
+#[test]
+fn f32_rem_euclid() {
+    let r = Scalar::rem_euclid(10.0_f32, 3.0);
+    assert!((r - 1.0).abs() < 1e-6);
+    let r = Scalar::rem_euclid(-10.0_f32, 3.0);
+    assert!((r - 2.0).abs() < 1e-6);
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Real constants and conversions
+// ─────────────────────────────────────────────────────────────────────────────
+
+#[test]
+fn f32_real_constants() {
+    assert!((f32::PI - core::f32::consts::PI).abs() < 1e-6);
+    assert!((f32::TAU - core::f32::consts::TAU).abs() < 1e-5);
+    assert!((f32::E - core::f32::consts::E).abs() < 1e-6);
+    assert!(f32::INFINITY.is_infinite());
+    assert!(f32::NEG_INFINITY.is_infinite());
+    assert!(f32::NAN.is_nan());
+}
+
+#[test]
+fn f32_from_to_f64() {
+    let val = f32::from_f64(42.5);
+    assert!((val - 42.5_f32).abs() < 1e-6);
+    assert!((val.to_f64() - 42.5).abs() < 1e-6);
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Real methods
+// ─────────────────────────────────────────────────────────────────────────────
+
+#[test]
+fn f32_signum() {
+    assert_eq!(Real::signum(5.0_f32), 1.0);
+    assert_eq!(Real::signum(-5.0_f32), -1.0);
+    assert!(Real::signum(f32::NAN).is_nan());
+}
+
+#[test]
+fn f32_is_nan() {
+    assert!(Real::is_nan(f32::NAN));
+    assert!(!Real::is_nan(0.0_f32));
+}
+
+#[test]
+fn f32_is_infinite() {
+    assert!(Real::is_infinite(f32::INFINITY));
+    assert!(Real::is_infinite(f32::NEG_INFINITY));
+    assert!(!Real::is_infinite(42.0_f32));
+}
+
+#[test]
+fn f32_is_finite() {
+    assert!(Real::is_finite(42.0_f32));
+    assert!(!Real::is_finite(f32::INFINITY));
+    assert!(!Real::is_finite(f32::NAN));
+}
+
+#[test]
+fn f32_mul_add() {
+    let r = Real::mul_add(2.0_f32, 3.0, 4.0);
+    assert!((r - 10.0).abs() < 1e-6);
+}
+
+#[test]
+fn f32_floor() {
+    assert_eq!(Real::floor(3.7_f32), 3.0);
+    assert_eq!(Real::floor(-3.7_f32), -4.0);
+}
+
+#[test]
+fn f32_ceil() {
+    assert_eq!(Real::ceil(3.2_f32), 4.0);
+    assert_eq!(Real::ceil(-3.2_f32), -3.0);
+}
+
+#[test]
+fn f32_round() {
+    assert_eq!(Real::round(3.5_f32), 4.0);
+    assert_eq!(Real::round(3.4_f32), 3.0);
+    assert_eq!(Real::round(-3.5_f32), -4.0);
+}
+
+#[test]
+fn f32_trunc() {
+    assert_eq!(Real::trunc(3.9_f32), 3.0);
+    assert_eq!(Real::trunc(-3.9_f32), -3.0);
+}
+
+#[test]
+fn f32_fract() {
+    let f = Real::fract(3.75_f32);
+    assert!((f - 0.75).abs() < 1e-6);
+}
+
+#[test]
+fn f32_powf() {
+    let r = Real::powf(2.0_f32, 10.0);
+    assert!((r - 1024.0).abs() < 1e-2);
+}
+
+#[test]
+fn f32_powi() {
+    let r = Real::powi(2.0_f32, 10);
+    assert!((r - 1024.0).abs() < 1e-2);
+}
+
+#[test]
+fn f32_sqrt() {
+    assert!((Real::sqrt(16.0_f32) - 4.0).abs() < 1e-6);
+    assert!((Real::sqrt(2.0_f32) - core::f32::consts::SQRT_2).abs() < 1e-6);
+}
+
+#[test]
+fn f32_cbrt() {
+    assert!((Real::cbrt(27.0_f32) - 3.0).abs() < 1e-5);
+    assert!((Real::cbrt(-8.0_f32) + 2.0).abs() < 1e-5);
+}
+
+#[test]
+fn f32_ln() {
+    assert!((Real::ln(1.0_f32)).abs() < 1e-6);
+    assert!((Real::ln(core::f32::consts::E) - 1.0).abs() < 1e-6);
+}
+
+#[test]
+fn f32_log10() {
+    assert!((Real::log10(100.0_f32) - 2.0).abs() < 1e-5);
+}
+
+#[test]
+fn f32_log2() {
+    assert!((Real::log2(8.0_f32) - 3.0).abs() < 1e-5);
+}
+
+#[test]
+fn f32_log() {
+    assert!((Real::log(1000.0_f32, 10.0) - 3.0).abs() < 1e-3);
+}
+
+#[test]
+fn f32_exp() {
+    assert!((Real::exp(0.0_f32) - 1.0).abs() < 1e-6);
+    assert!((Real::exp(1.0_f32) - core::f32::consts::E).abs() < 1e-5);
+}
+
+#[test]
+fn f32_exp2() {
+    assert!((Real::exp2(0.0_f32) - 1.0).abs() < 1e-6);
+    assert!((Real::exp2(10.0_f32) - 1024.0).abs() < 1e-2);
+}
+
+#[test]
+fn f32_hypot() {
+    assert!((Real::hypot(3.0_f32, 4.0) - 5.0).abs() < 1e-6);
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Transcendental methods — f32
+// ─────────────────────────────────────────────────────────────────────────────
+
+#[test]
+fn f32_sin() {
+    let pi = core::f32::consts::PI;
+    assert!((Transcendental::sin(0.0_f32)).abs() < 1e-6);
+    assert!((Transcendental::sin(pi / 2.0) - 1.0).abs() < 1e-6);
+}
+
+#[test]
+fn f32_cos() {
+    let pi = core::f32::consts::PI;
+    assert!((Transcendental::cos(0.0_f32) - 1.0).abs() < 1e-6);
+    assert!((Transcendental::cos(pi) + 1.0).abs() < 1e-6);
+}
+
+#[test]
+fn f32_tan() {
+    let pi = core::f32::consts::PI;
+    assert!((Transcendental::tan(0.0_f32)).abs() < 1e-6);
+    assert!((Transcendental::tan(pi / 4.0) - 1.0).abs() < 1e-5);
+}
+
+#[test]
+fn f32_sin_cos() {
+    let pi = core::f32::consts::PI;
+    let (s, c) = Transcendental::sin_cos(pi / 6.0_f32);
+    assert!((s - 0.5).abs() < 1e-6);
+    assert!((c - (3.0_f32).sqrt() / 2.0).abs() < 1e-6);
+}
+
+#[test]
+fn f32_asin() {
+    assert!((Transcendental::asin(0.5_f32) - core::f32::consts::FRAC_PI_6).abs() < 1e-6);
+    assert!((Transcendental::asin(1.0_f32) - core::f32::consts::FRAC_PI_2).abs() < 1e-6);
+}
+
+#[test]
+fn f32_acos() {
+    assert!((Transcendental::acos(0.5_f32) - core::f32::consts::FRAC_PI_3).abs() < 1e-6);
+    assert!((Transcendental::acos(1.0_f32)).abs() < 1e-6);
+}
+
+#[test]
+fn f32_atan() {
+    assert!((Transcendental::atan(1.0_f32) - core::f32::consts::FRAC_PI_4).abs() < 1e-6);
+}
+
+#[test]
+fn f32_atan2() {
+    let pi = core::f32::consts::PI;
+    assert!((Transcendental::atan2(1.0_f32, 1.0) - pi / 4.0).abs() < 1e-6);
+    assert!((Transcendental::atan2(0.0_f32, -1.0) - pi).abs() < 1e-6);
+}
+
+#[test]
+fn f32_sinh() {
+    assert!((Transcendental::sinh(0.0_f32)).abs() < 1e-6);
+    assert!((Transcendental::sinh(1.0_f32) - 1.0_f32.sinh()).abs() < 1e-6);
+}
+
+#[test]
+fn f32_cosh() {
+    assert!((Transcendental::cosh(0.0_f32) - 1.0).abs() < 1e-6);
+    assert!((Transcendental::cosh(1.0_f32) - 1.0_f32.cosh()).abs() < 1e-6);
+}
+
+#[test]
+fn f32_tanh() {
+    assert!((Transcendental::tanh(0.0_f32)).abs() < 1e-6);
+    assert!((Transcendental::tanh(1.0_f32) - 1.0_f32.tanh()).abs() < 1e-6);
+}
+
+#[test]
+fn f32_asinh() {
+    assert!((Transcendental::asinh(0.0_f32)).abs() < 1e-6);
+    assert!((Transcendental::asinh(1.0_f32) - 1.0_f32.asinh()).abs() < 1e-6);
+}
+
+#[test]
+fn f32_acosh() {
+    assert!((Transcendental::acosh(1.0_f32)).abs() < 1e-6);
+    assert!((Transcendental::acosh(2.0_f32) - 2.0_f32.acosh()).abs() < 1e-6);
+}
+
+#[test]
+fn f32_atanh() {
+    assert!((Transcendental::atanh(0.0_f32)).abs() < 1e-6);
+    assert!((Transcendental::atanh(0.5_f32) - 0.5_f32.atanh()).abs() < 1e-6);
+}