rename int_power → pow + extend prop test generators

Author: KtorZ

aiken.lock

@@ -13,4 +13,4 @@ requirements = []
 source = "github"
 
 [etags]
-"aiken-lang/fuzz@v2" = [{ secs_since_epoch = 1726162866, nanos_since_epoch = 876390466 }, "34ffec10cce786bf823c7505589a3b5e0663792ef8efd31f870d7bcc37e0f593"]
+"aiken-lang/fuzz@v2" = [{ secs_since_epoch = 1726317927, nanos_since_epoch = 830395000 }, "34ffec10cce786bf823c7505589a3b5e0663792ef8efd31f870d7bcc37e0f593"]

lib/aiken/math/rational.ak

@@ -821,51 +821,51 @@ test truncate_1() {
   }
 }
 
+/// Computes the rational number x raised to the power y. Returns `None` for
+/// invalid exponentiation.
 ///
 /// ```aiken
-/// It computes the rational number x raised to the power y and returns an 
-/// Option<Rational> (either Some(Rational) or None).
-///
 /// expect Some(x) = rational.new(50, 2500)
-/// rational.reduce(rational.int_power(x, 3)) == rational.new(1, 125000)
-/// 
+/// rational.reduce(rational.pow(x, 3)) == rational.new(1, 125000)
+///
 /// expect Some(x) = rational.new(50, 2500)
-/// rational.reduce(rational.int_power(x, -3)) == rational.new(125000, 1)
+/// rational.reduce(rational.pow(x, -3)) == rational.new(125000, 1)
 /// ```
-pub fn int_power(x: Rational, y: Int) -> Option<Rational> {
+pub fn pow(x: Rational, y: Int) -> Option<Rational> {
   let Rational { numerator: a, denominator: b } = x
-  
+
   if a == 0 && y <= 0 {
-      None
+    None
   } else if y > 0 {
-      Some(Rational { numerator: math.pow(a, y), denominator: math.pow(b, y) })
+    Some(Rational { numerator: math.pow(a, y), denominator: math.pow(b, y) })
   } else if y < 0 {
-      Some(Rational { numerator: math.pow(b, math.abs(y)), denominator: math.pow(a, math.abs(y)) })
+    Some(Rational { numerator: math.pow(b, -y), denominator: math.pow(a, -y) })
   } else {
-      Some(Rational { numerator: 1, denominator: 1 })
+    Some(Rational { numerator: 1, denominator: 1 })
   }
 }
 
-test int_power_negative_exponent_non_zero_fraction() {
+test pow_negative_exponent_non_zero_fraction() {
   expect Some(base) = new(50, 2500)
-  expect Some(calculated_result) = int_power(base, -3)
+  expect Some(calculated_result) = pow(base, -3)
   expect Some(expected_result) = new(125000, 1)
   reduce(calculated_result) == expected_result
 }
 
-test int_power_positive_exponent() {
+test pow_positive_exponent() {
   expect Some(base) = new(50, 2500)
-  expect Some(calculated_result) = int_power(base, 3)
+  expect Some(calculated_result) = pow(base, 3)
   expect Some(expected_result) = new(1, 125000)
   reduce(calculated_result) == expected_result
 }
 
-test int_power_exponent_zero() {
+test pow_exponent_zero() {
   expect Some(base) = new(50, 2500)
-  int_power(base, 0) == new(1, 1)
+  pow(base, 0) == new(1, 1)
+}
+
+test pow_rational_zero_exponent_zero() {
+  expect Some(base) = new(0, 1)
+  pow(base, 0) == None
 }
 
-test int_power_rational_zero_exponent_zero(){
-  expect Some(base) = new(0,1)
-  int_power(base,0) == None
-}

lib/aiken/math/rational.tests.ak

@@ -1,48 +1,65 @@
-use aiken/math/rational.{Rational, int_power, new}
 use aiken/fuzz.{both, either, map}
+use aiken/math/rational.{Rational, new, pow}
 
-fn positive_rational_fuzz() -> Fuzzer<Rational>{
-  map(
-    both(fuzz.int_at_least(1), fuzz.int_at_least(1)), 
-    fn((num,den)){
-      expect Some(new_fraction) = new(num,den)
-      new_fraction
-    }
+const any_positive_rational: Fuzzer<Rational> =
+  either(
+    map(
+      both(fuzz.int_at_least(1), fuzz.int_at_least(1)),
+      fn((num, den)) {
+        expect Some(new_fraction) = new(num, den)
+        new_fraction
+      },
+    ),
+    map(
+      both(fuzz.int_at_most(-1), fuzz.int_at_most(-1)),
+      fn((num, den)) {
+        expect Some(new_fraction) = new(num, den)
+        new_fraction
+      },
+    ),
   )
-}
 
-fn negative_rational_fuzz() -> Fuzzer<Rational>{
-  map(both(fuzz.int_at_most(-1),fuzz.int_at_least(1)),
-    fn((num,den)){
-      expect Some(new_fraction) = new(num,den)
-      new_fraction
-    }
+const any_negative_rational: Fuzzer<Rational> =
+  either(
+    map(
+      both(fuzz.int_at_most(-1), fuzz.int_at_least(1)),
+      fn((num, den)) {
+        expect Some(new_fraction) = new(num, den)
+        new_fraction
+      },
+    ),
+    map(
+      both(fuzz.int_at_least(1), fuzz.int_at_most(-1)),
+      fn((num, den)) {
+        expect Some(new_fraction) = new(num, den)
+        new_fraction
+      },
+    ),
   )
-}
 
-fn rational_fuzz() -> Fuzzer<Rational> {
-  either(negative_rational_fuzz(),positive_rational_fuzz())
-}
+const any_non_zero_rational: Fuzzer<Rational> =
+  either(any_negative_rational, any_positive_rational)
 
-test prop_power_of_zero_returns_one(rational via rational_fuzz()){
-  expect Some(calculated_result) = int_power(rational, 0)
-  expect Some(expected_result) = new(1,1)
+test prop_power_of_zero_returns_one(rational via any_non_zero_rational) {
+  expect Some(calculated_result) = pow(rational, 0)
+  expect Some(expected_result) = new(1, 1)
   calculated_result == expected_result
 }
 
-test prop_power_of_one_returns_same_fraction(rational via rational_fuzz()){
-  expect Some(calculated_result) = int_power(rational, 1)
+test prop_power_of_one_returns_same_fraction(rational via any_non_zero_rational) {
+  expect Some(calculated_result) = pow(rational, 1)
   calculated_result == rational
 }
 
-test prop_power_numerator_zero_exponent_negative_returns_none((denominator,exponent) via both(fuzz.int_at_least(1),fuzz.int_at_most(-1))){
+test prop_power_numerator_zero_exponent_negative_returns_none(
+  (denominator, exponent) via both(fuzz.int_at_least(1), fuzz.int_at_most(-1)),
+) {
   expect Some(fraction) = new(0, denominator)
-  expect None = int_power(fraction,exponent)
+  expect None = pow(fraction, exponent)
 }
 
-
 test prop_power_unit_fraction_is_immutable(exponent via fuzz.int()) {
-  expect Some(unit) = new(1,1)
-  expect Some(calculated_result) = int_power(unit, exponent)
+  expect Some(unit) = new(1, 1)
+  expect Some(calculated_result) = pow(unit, exponent)
   calculated_result == unit
-}
+}