Simplify pow function

library/src/compute/calc.rs

@@ -90,28 +90,24 @@ pub fn pow(
     /// The exponent of the power. Must be non-negative.
     exponent: Spanned<Num>,
 ) -> Value {
-    let exponent_value = match exponent.v {
+    let Spanned { v: exp, span } = exponent;
-        Num::Int(i) if i > u32::MAX as i64 => {
+    match exp {
-            bail!(exponent.span, "exponent too large");
+        _ if exp.float() == 0.0 && base.float() == 0.0 => {
+            bail!(args.span, "zero to the power of zero is undefined")
         }
-        Num::Int(i) => exponent.v,
+        Num::Int(i) if i32::try_from(i).is_err() => {
-        Num::Float(f) if f.is_normal() || f == 0 as f64 => exponent.v,
+            bail!(span, "exponent is too large")
-        _ => {
-            bail!(
-                exponent.span,
-                "exponent must be normal (non-NaN, non-infinite, non-subnormal)"
-            );
         }
+        Num::Float(f) if !f.is_normal() && f != 0.0 => {
+            bail!(span, "exponent may not be NaN, infinite, or subnormal")
+        }
+        _ => {}
     };
 
-    if exponent_value.float() == 0 as f64 && base.float() == 0 as f64 {
+    match (base, exp) {
-        return bail!(exponent.span, "zero to the power of zero is undefined");
-    }
-
-    match (base, exponent_value) {
         (Num::Int(a), Num::Int(b)) if b >= 0 => Value::Int(a.pow(b as u32)),
         (a, Num::Int(b)) => Value::Float(a.float().powi(b as i32)),
-        (a, b) => Value::Float(f64::powf(a.float(), b.float())),
+        (a, b) => Value::Float(a.float().powf(b.float())),
     }
 }
 

tests/typ/compute/calc.typ

@@ -76,6 +76,23 @@
 #test(calc.max(-3, 11), 11)
 #test(calc.min("hi"), "hi")
 
+---
+// Test the `calc` function.
+#test(calc.pow(10, 0), 1)
+#test(calc.pow(2, 4), 16)
+
+---
+// Error: 10-16 zero to the power of zero is undefined
+#calc.pow(0, 0)
+
+---
+// Error: 14-31 exponent is too large
+#calc.pow(2, 10000000000000000)
+
+---
+// Error: 14-36 exponent may not be NaN, infinite, or subnormal
+#calc.pow(2, calc.pow(2.0, 10000.0))
+
 ---
 // Error: 10-12 expected at least one value
 #calc.min()