From cfee5d2214681931058d26b6434bd52dfbf2f4a0 Mon Sep 17 00:00:00 2001
From: Hexa Dust <hxd@hexadust.net>
Date: Fri, 18 Jul 2025 21:19:30 +0100
Subject: [PATCH] use f32

---
 src/calc.rs |  4 ++--
 src/lib.rs  | 40 ++++++++++++++++++++--------------------
 2 files changed, 22 insertions(+), 22 deletions(-)

diff --git a/src/calc.rs b/src/calc.rs
index a7fb508..555994c 100644
--- a/src/calc.rs
+++ b/src/calc.rs
@@ -72,8 +72,8 @@ impl<const SS: usize, const DS: usize, E: PrimInt + Unsigned> StackCalc<SS, DS,
     pub fn add(&mut self) -> Result<Decimal<DS, E>, StackCalcError> {
         let a = self.pop()?;
         let b = self.pop()?;
-        let a = f64::try_from(a)?;
-        let b = f64::try_from(b)?;
+        let a = f32::try_from(a)?;
+        let b = f32::try_from(b)?;
         let res = Decimal::try_from(a + b)?;
         self.push(res)?;
         Ok(res)
diff --git a/src/lib.rs b/src/lib.rs
index 942c4dc..508b794 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -60,10 +60,10 @@ impl<const S: usize, E: Display> Display for Decimal<S, E> {
     }
 }
 
-impl<const S: usize, E: PrimInt + Unsigned> TryFrom<f64> for Decimal<S, E> {
+impl<const S: usize, E: PrimInt + Unsigned> TryFrom<f32> for Decimal<S, E> {
     type Error = DecimalError;
 
-    fn try_from(mut f: f64) -> Result<Self, Self::Error> {
+    fn try_from(mut f: f32) -> Result<Self, Self::Error> {
         if !f.is_finite() {
             return Err(DecimalError::NotANumber);
         }
@@ -92,7 +92,7 @@ impl<const S: usize, E: PrimInt + Unsigned> TryFrom<f64> for Decimal<S, E> {
         for i in 0..S {
             let s = f as u8;
             f *= 10.0;
-            f -= (s * 10) as f64;
+            f -= (s * 10) as f32;
             significant[i] = s;
         }
         Ok(Decimal {
@@ -104,7 +104,7 @@ impl<const S: usize, E: PrimInt + Unsigned> TryFrom<f64> for Decimal<S, E> {
     }
 }
 
-impl<const S: usize, E: PrimInt + Unsigned> TryFrom<Decimal<S, E>> for f64 {
+impl<const S: usize, E: PrimInt + Unsigned> TryFrom<Decimal<S, E>> for f32 {
     type Error = DecimalError;
 
     fn try_from(val: Decimal<S, E>) -> Result<Self, Self::Error> {
@@ -119,14 +119,14 @@ impl<const S: usize, E: PrimInt + Unsigned> TryFrom<Decimal<S, E>> for f64 {
         if minus_exponent {
             e = -e;
         }
-        let e = 10.0f64.powi(e);
+        let e = 10.0f32.powi(e);
 
-        let mut f: f64 = 0.0;
+        let mut f: f32 = 0.0;
 
         for i in (0..S).rev() {
             f /= 10.0;
             let s = significant[i];
-            f += (s as f64) * e;
+            f += (s as f32) * e;
         }
 
         if minus {
@@ -189,13 +189,13 @@ mod tests {
 
     #[test]
     fn float_to_decimal_nan() {
-        let err = Decimal::<7>::try_from(f64::NAN).unwrap_err();
+        let err = Decimal::<7>::try_from(f32::NAN).unwrap_err();
         assert!(matches!(err, DecimalError::NotANumber));
     }
 
     #[test]
     fn float_to_decimal_max() {
-        let dec = Decimal::<7>::try_from(f64::MAX).unwrap();
+        let dec = Decimal::<7>::try_from(f32::MAX).unwrap();
         assert!(!dec.minus);
         assert_eq!(dec.significant, [1, 7, 9, 7, 6, 9, 3]);
         assert!(!dec.minus_exponent);
@@ -204,13 +204,13 @@ mod tests {
 
     #[test]
     fn float_to_decimal_max_overflow() {
-        let err = Decimal::<7, u8>::try_from(f64::MAX).unwrap_err();
+        let err = Decimal::<7, u8>::try_from(f32::MAX).unwrap_err();
         assert!(matches!(err, DecimalError::ExponentOverflow));
     }
 
     #[test]
     fn float_to_decimal_min() {
-        let dec = Decimal::<7>::try_from(f64::MIN).unwrap();
+        let dec = Decimal::<7>::try_from(f32::MIN).unwrap();
         assert!(dec.minus);
         assert_eq!(dec.significant, [1, 7, 9, 7, 6, 9, 3]);
         assert!(!dec.minus_exponent);
@@ -219,13 +219,13 @@ mod tests {
 
     #[test]
     fn float_to_decimal_min_overflow() {
-        let err = Decimal::<7, u8>::try_from(f64::MIN).unwrap_err();
+        let err = Decimal::<7, u8>::try_from(f32::MIN).unwrap_err();
         assert!(matches!(err, DecimalError::ExponentOverflow));
     }
 
     #[test]
     fn float_to_decimal_epsilon() {
-        let dec = Decimal::<7>::try_from(f64::EPSILON).unwrap();
+        let dec = Decimal::<7>::try_from(f32::EPSILON).unwrap();
         assert!(!dec.minus);
         assert_eq!(dec.significant, [2, 2, 2, 0, 4, 4, 6]);
         assert!(dec.minus_exponent);
@@ -235,7 +235,7 @@ mod tests {
     #[test]
     fn decimal_to_float_zero() {
         let dec = Decimal::<5, u8>::default();
-        assert_eq!(f64::try_from(dec).unwrap(), 0.0);
+        assert_eq!(f32::try_from(dec).unwrap(), 0.0);
     }
 
     #[test]
@@ -243,7 +243,7 @@ mod tests {
         let mut dec = Decimal::<7, u8>::default();
         dec.significant = [1, 3, 3, 7, 4, 2, 0];
         dec.exponent = 3;
-        assert_eq!(f64::try_from(dec).unwrap(), 1337.42);
+        assert_eq!(f32::try_from(dec).unwrap(), 1337.42);
     }
 
     #[test]
@@ -252,7 +252,7 @@ mod tests {
         dec.significant = [1, 3, 3, 7, 4, 2, 0];
         dec.minus_exponent = true;
         dec.exponent = 2;
-        assert_eq!(f64::try_from(dec).unwrap(), 0.0133742);
+        assert_eq!(f32::try_from(dec).unwrap(), 0.0133742);
     }
 
     #[test]
@@ -261,7 +261,7 @@ mod tests {
         dec.minus = true;
         dec.significant = [1, 3, 3, 7, 4, 2, 0];
         dec.exponent = 3;
-        assert_eq!(f64::try_from(dec).unwrap(), -1337.42);
+        assert_eq!(f32::try_from(dec).unwrap(), -1337.42);
     }
 
     #[test]
@@ -271,14 +271,14 @@ mod tests {
         dec.significant = [1, 3, 3, 7, 4, 2, 0];
         dec.minus_exponent = true;
         dec.exponent = 2;
-        assert_eq!(f64::try_from(dec).unwrap(), -0.0133742);
+        assert_eq!(f32::try_from(dec).unwrap(), -0.0133742);
     }
 
     #[test]
     #[ignore = "not working due to precission issues"]
     fn decimal_to_float_max() {
-        let dec = Decimal::<16>::try_from(f64::MAX).unwrap();
-        assert_eq!(f64::try_from(dec).unwrap(), f64::MAX);
+        let dec = Decimal::<16>::try_from(f32::MAX).unwrap();
+        assert_eq!(f32::try_from(dec).unwrap(), f32::MAX);
     }
 
     #[test]