pull in log2

Author: timschmidt

src/real/arithmetic.rs

@@ -544,7 +544,7 @@ impl Class {
                 Self::ln_computable(base).multiply(Self::ln_computable(&rationals::TEN).inverse())
             }
             Log2(base) => {
-                Self::ln_computable(base).multiply(Self::ln_computable(&*rationals::TWO).inverse())
+                Self::ln_computable(base).multiply(Self::ln_computable(&rationals::TWO).inverse())
             }
             SinPi(rational) => {
                 let argument =
@@ -1533,7 +1533,8 @@ impl Real {
                 Irrational => "scaled-computable",
                 Pi | PiPow(_) | PiInv | PiExp(_) | PiInvExp(_) | PiSqrt(_) | ConstProduct(_)
                 | ConstOffset(_) | ConstProductSqrt(_) | Sqrt(_) | Exp(_) | Ln(_) | LnAffine(_)
-                | LnProduct(_) | Log10(_) | Log2(_) | SinPi(_) | TanPi(_) => "symbolic-nonzero-scale",
+                | LnProduct(_) | Log10(_) | Log2(_) | SinPi(_) | TanPi(_) =>
+                    "symbolic-nonzero-scale",
             }
         );
 
@@ -3345,7 +3346,7 @@ impl Real {
 
         crate::trace_dispatch!("real", "log2", "rational-log2-special-form");
         let computable =
-            Class::ln_computable(&r).multiply(Class::ln_computable(&*rationals::TWO).inverse());
+            Class::ln_computable(&r).multiply(Class::ln_computable(&rationals::TWO).inverse());
         Ok(Self {
             rational: Rational::one(),
             class: Log2(r),

src/real/tests.rs

@@ -1162,6 +1162,20 @@ mod tests {
         }
     }
 
+    #[test]
+    fn log2_of_fractional_non_power_rational_matches_f64() {
+        for (numerator, denominator) in [(3_i64, 8_u64), (5, 12), (17, 1024)] {
+            let value = Real::new(Rational::fraction(numerator, denominator).unwrap())
+                .log2()
+                .unwrap();
+            assert_close(
+                value,
+                ((numerator as f64) / (denominator as f64)).log2(),
+                1e-12,
+            );
+        }
+    }
+
     #[test]
     fn log2_of_negative_errors() {
         let negative = Real::new(Rational::new(-3));
@@ -1206,6 +1220,30 @@ mod tests {
         assert_eq!(quotient, expected);
     }
 
+    #[test]
+    fn log2_ln_quotient_preserves_exact_scaled_logs() {
+        let numerator = Real::new(Rational::new(9)).ln().unwrap();
+        let denominator = Real::new(Rational::new(4)).ln().unwrap();
+        let quotient = (numerator / denominator).unwrap();
+        let expected = Real::new(Rational::new(3)).log2().unwrap();
+        assert_eq!(quotient, expected);
+
+        let numerator = Real::new(Rational::new(32)).ln().unwrap();
+        let denominator = Real::new(Rational::fraction(1, 2).unwrap()).ln().unwrap();
+        assert_eq!((numerator / denominator).unwrap(), Rational::new(-5));
+    }
+
+    #[test]
+    fn log2_ln_quotient_ignores_warmed_numerator_cache() {
+        let numerator = Real::new(Rational::new(5)).ln().unwrap();
+        let warmed = numerator.to_f64_approx().unwrap();
+        assert!((warmed - 5.0_f64.ln()).abs() < 1e-12);
+
+        let denominator = Real::new(Rational::new(2)).ln().unwrap();
+        let quotient = (numerator / denominator).unwrap();
+        assert_close(quotient, 5.0_f64.log2(), 1e-12);
+    }
+
     fn assert_close(value: Real, expected: f64, tolerance: f64) {
         let actual: f64 = value.into();
         let scale = expected.abs().max(1.0);

src/simple.rs

@@ -280,7 +280,7 @@ impl Simple {
                 };
                 let mut value = first.value(names)?;
                 for operand in operands {
-                    value = value + operand.value(names)?;
+                    value += operand.value(names)?;
                 }
                 Ok(value)
             }
@@ -323,7 +323,7 @@ impl Simple {
                     let mut value: Real = self.operands.first().unwrap().value(names)?;
                     let operands = self.operands.iter().skip(1);
                     for operand in operands {
-                        value = value - (operand.value(names)?);
+                        value -= operand.value(names)?;
                     }
                     Ok(value)
                 }
@@ -353,7 +353,7 @@ impl Simple {
                 };
                 let mut value = first.value(names)?;
                 for operand in operands {
-                    value = value * operand.value(names)?;
+                    value *= operand.value(names)?;
                 }
                 Ok(value)
             }
@@ -703,6 +703,8 @@ mod tests {
             "(l 5)",
             "(log 5)",
             "(log10 5)",
+            "(log2 5)",
+            "(lg 5)",
             "(exp 5)",
             "(e 5)",
             "(sqrt 5)",
@@ -823,6 +825,28 @@ mod tests {
         }
     }
 
+    #[test]
+    fn log2_aliases_parse_as_base2() {
+        let empty = HashMap::new();
+        for case in ["(log2 1024)", "(lg 1024)"] {
+            let xpr: Simple = case.parse().unwrap();
+            let result = xpr.evaluate(&empty).unwrap();
+            assert!(result.is_integer(), "{case}");
+            assert_eq!(format!("{result}"), "10", "{case}");
+        }
+    }
+
+    #[test]
+    fn log2_parser_rejects_bad_domain_and_arity() {
+        let empty = HashMap::new();
+
+        let negative: Simple = "(lg -1)".parse().unwrap();
+        assert_eq!(negative.evaluate(&empty), Err(Problem::NotANumber));
+
+        let wrong_arity: Simple = "(log2 2 4)".parse().unwrap();
+        assert_eq!(wrong_arity.evaluate(&empty), Err(Problem::ParseError));
+    }
+
     #[test]
     fn div_pi_e_4() {
         let empty = HashMap::new();