create-dubhe 0.1.13 → 1.2.0-pre.51

package/template/101/aptos-template/contracts/counter/build/counter/sources/dependencies/AptosStdlib/math64.move

@@ -1,336 +0,0 @@
-/// Standard math utilities missing in the Move Language.
-module aptos_std::math64 {
-
-    use std::fixed_point32::FixedPoint32;
-    use std::fixed_point32;
-
-    /// Cannot log2 the value 0
-    const EINVALID_ARG_FLOOR_LOG2: u64 = 1;
-
-    /// Return the largest of two numbers.
-    public fun max(a: u64, b: u64): u64 {
-        if (a >= b) a else b
-    }
-
-    /// Return the smallest of two numbers.
-    public fun min(a: u64, b: u64): u64 {
-        if (a < b) a else b
-    }
-
-    /// Return the average of two.
-    public fun average(a: u64, b: u64): u64 {
-        if (a < b) {
-            a + (b - a) / 2
-        } else {
-            b + (a - b) / 2
-        }
-    }
-
-    /// Return greatest common divisor of `a` & `b`, via the Euclidean algorithm.
-    public inline fun gcd(a: u64, b: u64): u64 {
-        let (large, small) = if (a > b) (a, b) else (b, a);
-        while (small != 0) {
-            let tmp = small;
-            small = large % small;
-            large = tmp;
-        };
-        large
-    }
-
-    /// Returns least common multiple of `a` & `b`.
-    public inline fun lcm(a: u64, b: u64): u64 {
-        if (a == 0 || b == 0) {
-            0
-        } else {
-            a / gcd(a, b) * b
-        }
-    }
-
-    /// Returns a * b / c going through u128 to prevent intermediate overflow
-    public inline fun mul_div(a: u64, b: u64, c: u64): u64 {
-        // Inline functions cannot take constants, as then every module using it needs the constant
-        assert!(c != 0, std::error::invalid_argument(4));
-        (((a as u128) * (b as u128) / (c as u128)) as u64)
-    }
-
-    /// Return x clamped to the interval [lower, upper].
-    public fun clamp(x: u64, lower: u64, upper: u64): u64 {
-        min(upper, max(lower, x))
-    }
-
-    /// Return the value of n raised to power e
-    public fun pow(n: u64, e: u64): u64 {
-        if (e == 0) {
-            1
-        } else {
-            let p = 1;
-            while (e > 1) {
-                if (e % 2 == 1) {
-                    p = p * n;
-                };
-                e = e / 2;
-                n = n * n;
-            };
-            p * n
-        }
-    }
-
-    /// Returns floor(lg2(x))
-    public fun floor_log2(x: u64): u8 {
-        let res = 0;
-        assert!(x != 0, std::error::invalid_argument(EINVALID_ARG_FLOOR_LOG2));
-        // Effectively the position of the most significant set bit
-        let n = 32;
-        while (n > 0) {
-            if (x >= (1 << n)) {
-                x = x >> n;
-                res = res + n;
-            };
-            n = n >> 1;
-        };
-        res
-    }
-
-    // Returns log2(x)
-    public fun log2(x: u64): FixedPoint32 {
-        let integer_part = floor_log2(x);
-        // Normalize x to [1, 2) in fixed point 32.
-        let y = (if (x >= 1 << 32) {
-            x >> (integer_part - 32)
-        } else {
-            x << (32 - integer_part)
-        } as u128);
-        let frac = 0;
-        let delta = 1 << 31;
-        while (delta != 0) {
-            // log x = 1/2 log x^2
-            // x in [1, 2)
-            y = (y * y) >> 32;
-            // x is now in [1, 4)
-            // if x in [2, 4) then log x = 1 + log (x / 2)
-            if (y >= (2 << 32)) { frac = frac + delta; y = y >> 1; };
-            delta = delta >> 1;
-        };
-        fixed_point32::create_from_raw_value (((integer_part as u64) << 32) + frac)
-    }
-
-    /// Returns square root of x, precisely floor(sqrt(x))
-    public fun sqrt(x: u64): u64 {
-        if (x == 0) return 0;
-        // Note the plus 1 in the expression. Let n = floor_lg2(x) we have x in [2^n, 2^(n+1)> and thus the answer in
-        // the half-open interval [2^(n/2), 2^((n+1)/2)>. For even n we can write this as [2^(n/2), sqrt(2) 2^(n/2)>
-        // for odd n [2^((n+1)/2)/sqrt(2), 2^((n+1)/2>. For even n the left end point is integer for odd the right
-        // end point is integer. If we choose as our first approximation the integer end point we have as maximum
-        // relative error either (sqrt(2) - 1) or (1 - 1/sqrt(2)) both are smaller then 1/2.
-        let res = 1 << ((floor_log2(x) + 1) >> 1);
-        // We use standard newton-rhapson iteration to improve the initial approximation.
-        // The error term evolves as delta_i+1 = delta_i^2 / 2 (quadratic convergence).
-        // It turns out that after 4 iterations the delta is smaller than 2^-32 and thus below the treshold.
-        res = (res + x / res) >> 1;
-        res = (res + x / res) >> 1;
-        res = (res + x / res) >> 1;
-        res = (res + x / res) >> 1;
-        min(res, x / res)
-    }
-
-    public inline fun ceil_div(x: u64, y: u64): u64 {
-        // ceil_div(x, y) = floor((x + y - 1) / y) = floor((x - 1) / y) + 1
-        // (x + y - 1) could spuriously overflow. so we use the later version
-        if (x == 0) {
-            // Inline functions cannot take constants, as then every module using it needs the constant
-            assert!(y != 0, std::error::invalid_argument(4));
-            0
-        }
-        else (x - 1) / y + 1
-    }
-
-    #[test]
-    public entry fun test_ceil_div() {
-        assert!(ceil_div(9, 3) == 3, 0);
-        assert!(ceil_div(10, 3) == 4, 0);
-        assert!(ceil_div(11, 3) == 4, 0);
-        assert!(ceil_div(12, 3) == 4, 0);
-        assert!(ceil_div(13, 3) == 5, 0);
-
-        // No overflow
-        assert!(ceil_div((((1u128<<64) - 9) as u64), 11) == 1676976733973595601, 0);
-    }
-
-    #[test]
-    fun test_gcd() {
-        assert!(gcd(20, 8) == 4, 0);
-        assert!(gcd(8, 20) == 4, 0);
-        assert!(gcd(1, 100) == 1, 0);
-        assert!(gcd(100, 1) == 1, 0);
-        assert!(gcd(210, 45) == 15, 0);
-        assert!(gcd(45, 210) == 15, 0);
-        assert!(gcd(0, 0) == 0, 0);
-        assert!(gcd(1, 0) == 1, 0);
-        assert!(gcd(50, 0) == 50, 0);
-        assert!(gcd(0, 1) == 1, 0);
-        assert!(gcd(0, 50) == 50, 0);
-        assert!(gcd(54, 24) == 6, 0);
-        assert!(gcd(24, 54) == 6, 0);
-        assert!(gcd(10, 10) == 10, 0);
-        assert!(gcd(1071, 462) == 21, 0);
-        assert!(gcd(462, 1071) == 21, 0);
-    }
-
-   #[test]
-    fun test_lcm() {
-        assert!(lcm(0, 0) == 0, 0);
-        assert!(lcm(0, 1) == 0, 0);
-        assert!(lcm(1, 0) == 0, 0);
-        assert!(lcm(1, 1) == 1, 0);
-        assert!(lcm(1024, 144) == 9216, 0);
-        assert!(lcm(2, 17) == 34, 0);
-        assert!(lcm(17, 2) == 34, 0);
-        assert!(lcm(24, 54) == 216, 0);
-        assert!(lcm(115, 9) == 1035, 0);
-        assert!(lcm(101, 14) == 1414, 0);
-        assert!(lcm(110, 5) == 110, 0);
-        assert!(lcm(100, 8) == 200, 0);
-        assert!(lcm(32, 6) == 96, 0);
-        assert!(lcm(110, 13) == 1430, 0);
-        assert!(lcm(117, 13) == 117, 0);
-        assert!(lcm(100, 125) == 500, 0);
-        assert!(lcm(101, 3) == 303, 0);
-        assert!(lcm(115, 16) == 1840, 0);
-    }
-
-    #[test]
-    public entry fun test_max_64() {
-        let result = max(3u64, 6u64);
-        assert!(result == 6, 0);
-
-        let result = max(15u64, 12u64);
-        assert!(result == 15, 1);
-    }
-
-    #[test]
-    public entry fun test_min() {
-        let result = min(3u64, 6u64);
-        assert!(result == 3, 0);
-
-        let result = min(15u64, 12u64);
-        assert!(result == 12, 1);
-    }
-
-    #[test]
-    public entry fun test_average() {
-        let result = average(3u64, 6u64);
-        assert!(result == 4, 0);
-
-        let result = average(15u64, 12u64);
-        assert!(result == 13, 0);
-    }
-
-    #[test]
-    public entry fun test_average_does_not_overflow() {
-        let result = average(18446744073709551615, 18446744073709551615);
-        assert!(result == 18446744073709551615, 0);
-    }
-
-    #[test]
-    public entry fun test_pow() {
-        let result = pow(10u64, 18u64);
-        assert!(result == 1000000000000000000, 0);
-
-        let result = pow(10u64, 1u64);
-        assert!(result == 10, 0);
-
-        let result = pow(10u64, 0u64);
-        assert!(result == 1, 0);
-    }
-
-    #[test]
-    public entry fun test_mul_div() {
-        let tmp: u64 = 1<<63;
-        assert!(mul_div(tmp,tmp,tmp) == tmp, 0);
-
-        assert!(mul_div(tmp,5,5) == tmp, 0);
-        // Note that ordering other way is imprecise.
-        assert!((tmp / 5) * 5 != tmp, 0);
-    }
-
-    #[test]
-    #[expected_failure(abort_code = 0x10004, location = aptos_std::math64)]
-    public entry fun test_mul_div_by_zero() {
-        mul_div(1, 1, 0);
-    }
-
-    #[test]
-    public entry fun test_floor_lg2() {
-        let idx: u8 = 0;
-        while (idx < 64) {
-            assert!(floor_log2(1<<idx) == idx, 0);
-            idx = idx + 1;
-        };
-        idx = 1;
-        while (idx <= 64) {
-            assert!(floor_log2((((1u128<<idx) - 1) as u64)) == idx - 1, 0);
-            idx = idx + 1;
-        };
-    }
-
-    #[test]
-    public entry fun test_log2() {
-        let idx: u8 = 0;
-        while (idx < 64) {
-            let res = log2(1<<idx);
-            assert!(fixed_point32::get_raw_value(res) == (idx as u64) << 32, 0);
-            idx = idx + 1;
-        };
-        idx = 10;
-        while (idx <= 64) {
-            let res = log2((((1u128<<idx) - 1) as u64));
-            // idx + log2 (1 - 1/2^idx) = idx + ln (1-1/2^idx)/ln2
-            // Use 3rd order taylor to approximate expected result
-            let expected = (idx as u128) << 32;
-            let taylor1 = ((1 << 32) / ((1u256<<idx)) as u128);
-            let taylor2 = (taylor1 * taylor1) >> 32;
-            let taylor3 = (taylor2 * taylor1) >> 32;
-            let expected = expected - ((taylor1 + taylor2 / 2 + taylor3 / 3) << 32) / 2977044472;
-            // verify it matches to 8 significant digits
-            assert_approx_the_same((fixed_point32::get_raw_value(res) as u128), expected, 8);
-            idx = idx + 1;
-        };
-    }
-
-    #[test]
-    public entry fun test_sqrt() {
-        let result = sqrt(0);
-        assert!(result == 0, 0);
-
-        let result = sqrt(1);
-        assert!(result == 1, 0);
-
-        let result = sqrt(256);
-        assert!(result == 16, 0);
-
-        let result = sqrt(1<<62);
-        assert!(result == 1<<31, 0);
-
-        let result = sqrt((((1u128 << 64) - 1) as u64));
-        assert!(result == (1u64 << 32) - 1, 0);
-
-        let result = sqrt((1u64 << 63));
-        assert!(result == 3037000499, 0);
-
-        let result = sqrt((1u64 << 63) - 1);
-        assert!(result == 3037000499, 0);
-    }
-
-    #[test_only]
-    /// For functions that approximate a value it's useful to test a value is close
-    /// to the most correct value up to last digit
-    fun assert_approx_the_same(x: u128, y: u128, precission: u64) {
-        if (x < y) {
-            let tmp = x;
-            x = y;
-            y = tmp;
-        };
-        let mult = (pow(10, precission) as u128);
-        assert!((x - y) * mult < x, 0);
-    }
-}

package/template/101/aptos-template/contracts/counter/build/counter/sources/dependencies/AptosStdlib/math_fixed.move

@@ -1,139 +0,0 @@
-/// Standard math utilities missing in the Move Language.
-module aptos_std::math_fixed {
-    use std::fixed_point32;
-    use std::fixed_point32::FixedPoint32;
-    use aptos_std::math128;
-    use aptos_std::math64;
-
-    /// Abort code on overflow
-    const EOVERFLOW_EXP: u64 = 1;
-
-    /// Natural log 2 in 32 bit fixed point
-    const LN2: u128 = 2977044472;  // ln(2) in fixed 32 representation
-    const LN2_X_32: u64 = 32 * 2977044472;  // 32 * ln(2) in fixed 32 representation
-
-    /// Square root of fixed point number
-    public fun sqrt(x: FixedPoint32): FixedPoint32 {
-        let y = (fixed_point32::get_raw_value(x) as u128);
-        fixed_point32::create_from_raw_value((math128::sqrt(y << 32) as u64))
-    }
-
-    /// Exponent function with a precission of 9 digits.
-    public fun exp(x: FixedPoint32): FixedPoint32 {
-        let raw_value = (fixed_point32::get_raw_value(x) as u128);
-        fixed_point32::create_from_raw_value((exp_raw(raw_value) as u64))
-    }
-
-    /// Because log2 is negative for values < 1 we instead return log2(x) + 32 which
-    /// is positive for all values of x.
-    public fun log2_plus_32(x: FixedPoint32): FixedPoint32 {
-        let raw_value = (fixed_point32::get_raw_value(x) as u128);
-        math128::log2(raw_value)
-    }
-
-    public fun ln_plus_32ln2(x: FixedPoint32): FixedPoint32 {
-        let raw_value = (fixed_point32::get_raw_value(x) as u128);
-        let x = (fixed_point32::get_raw_value(math128::log2(raw_value)) as u128);
-        fixed_point32::create_from_raw_value((x * LN2 >> 32 as u64))
-    }
-
-    /// Integer power of a fixed point number
-    public fun pow(x: FixedPoint32, n: u64): FixedPoint32 {
-        let raw_value = (fixed_point32::get_raw_value(x) as u128);
-        fixed_point32::create_from_raw_value((pow_raw(raw_value, (n as u128)) as u64))
-    }
-
-    /// Specialized function for x * y / z that omits intermediate shifting
-    public fun mul_div(x: FixedPoint32, y: FixedPoint32, z: FixedPoint32): FixedPoint32 {
-        let a = fixed_point32::get_raw_value(x);
-        let b = fixed_point32::get_raw_value(y);
-        let c = fixed_point32::get_raw_value(z);
-        fixed_point32::create_from_raw_value (math64::mul_div(a, b, c))
-    }
-
-    // Calculate e^x where x and the result are fixed point numbers
-    fun exp_raw(x: u128): u128 {
-        // exp(x / 2^32) = 2^(x / (2^32 * ln(2))) = 2^(floor(x / (2^32 * ln(2))) + frac(x / (2^32 * ln(2))))
-        let shift_long = x / LN2;
-        assert!(shift_long <= 31, std::error::invalid_state(EOVERFLOW_EXP));
-        let shift = (shift_long as u8);
-        let remainder = x % LN2;
-        // At this point we want to calculate 2^(remainder / ln2) << shift
-        // ln2 = 595528 * 4999 which means
-        let bigfactor = 595528;
-        let exponent = remainder / bigfactor;
-        let x = remainder % bigfactor;
-        // 2^(remainder / ln2) = (2^(1/4999))^exponent * exp(x / 2^32)
-        let roottwo = 4295562865;  // fixed point representation of 2^(1/4999)
-        // This has an error of 5000 / 4 10^9 roughly 6 digits of precission
-        let power = pow_raw(roottwo, exponent);
-        let eps_correction = 1241009291;
-        power = power + ((power * eps_correction * exponent) >> 64);
-        // x is fixed point number smaller than 595528/2^32 < 0.00014 so we need only 2 tayler steps
-        // to get the 6 digits of precission
-        let taylor1 = (power * x) >> (32 - shift);
-        let taylor2 = (taylor1 * x) >> 32;
-        let taylor3 = (taylor2 * x) >> 32;
-        (power << shift) + taylor1 + taylor2 / 2 + taylor3 / 6
-    }
-
-    // Calculate x to the power of n, where x and the result are fixed point numbers.
-    fun pow_raw(x: u128, n: u128): u128 {
-        let res: u256 = 1 << 64;
-        x = x << 32;
-        while (n != 0) {
-            if (n & 1 != 0) {
-                res = (res * (x as u256)) >> 64;
-            };
-            n = n >> 1;
-            x = ((((x as u256) * (x as u256)) >> 64) as u128);
-        };
-        ((res >> 32) as u128)
-    }
-
-    #[test]
-    public entry fun test_sqrt() {
-        // Sqrt is based on math128::sqrt and thus most of the testing is done there.
-        let fixed_base = 1 << 32;
-        let result = sqrt(fixed_point32::create_from_u64(1));
-        assert!(fixed_point32::get_raw_value(result) == fixed_base, 0);
-
-        let result = sqrt(fixed_point32::create_from_u64(2));
-        assert_approx_the_same((fixed_point32::get_raw_value(result) as u128), 6074001000, 9);
-    }
-
-    #[test]
-    public entry fun test_exp() {
-        let fixed_base = 1 << 32;
-        let result = exp_raw(0);
-        assert!(result == fixed_base, 0);
-
-        let result = exp_raw(fixed_base);
-        let e = 11674931554;  // e in 32 bit fixed point
-        assert_approx_the_same(result, e, 9);
-
-        let result = exp_raw(10 * fixed_base);
-        let exp10 = 94602950235157;  // e^10 in 32 bit fixed point
-        assert_approx_the_same(result, exp10, 9);
-    }
-
-    #[test]
-    public entry fun test_pow() {
-        // We use the case of exp
-        let result = pow_raw(4295562865, 4999);
-        assert_approx_the_same(result,  1 << 33, 6);
-    }
-
-    #[test_only]
-    /// For functions that approximate a value it's useful to test a value is close
-    /// to the most correct value up to last digit
-    fun assert_approx_the_same(x: u128, y: u128, precission: u128) {
-        if (x < y) {
-            let tmp = x;
-            x = y;
-            y = tmp;
-        };
-        let mult = math128::pow(10, precission);
-        assert!((x - y) * mult < x, 0);
-    }
-}

package/template/101/aptos-template/contracts/counter/build/counter/sources/dependencies/AptosStdlib/math_fixed64.move

@@ -1,142 +0,0 @@
-/// Standard math utilities missing in the Move Language.
-
-module aptos_std::math_fixed64 {
-    use aptos_std::fixed_point64;
-    use aptos_std::fixed_point64::FixedPoint64;
-    use aptos_std::math128;
-
-    /// Abort code on overflow
-    const EOVERFLOW_EXP: u64 = 1;
-
-    /// Natural log 2 in 32 bit fixed point
-    const LN2: u256 = 12786308645202655660;  // ln(2) in fixed 64 representation
-
-    /// Square root of fixed point number
-    public fun sqrt(x: FixedPoint64): FixedPoint64 {
-        let y = fixed_point64::get_raw_value(x);
-        let z = (math128::sqrt(y) << 32 as u256);
-        z = (z + ((y as u256) << 64) / z) >> 1;
-        fixed_point64::create_from_raw_value((z as u128))
-    }
-
-    /// Exponent function with a precission of 9 digits.
-    public fun exp(x: FixedPoint64): FixedPoint64 {
-        let raw_value = (fixed_point64::get_raw_value(x) as u256);
-        fixed_point64::create_from_raw_value((exp_raw(raw_value) as u128))
-    }
-
-    /// Because log2 is negative for values < 1 we instead return log2(x) + 64 which
-    /// is positive for all values of x.
-    public fun log2_plus_64(x: FixedPoint64): FixedPoint64 {
-        let raw_value = (fixed_point64::get_raw_value(x) as u128);
-        math128::log2_64(raw_value)
-    }
-
-    public fun ln_plus_32ln2(x: FixedPoint64): FixedPoint64 {
-        let raw_value = fixed_point64::get_raw_value(x);
-        let x = (fixed_point64::get_raw_value(math128::log2_64(raw_value)) as u256);
-        fixed_point64::create_from_raw_value(((x * LN2) >> 64 as u128))
-    }
-
-    /// Integer power of a fixed point number
-    public fun pow(x: FixedPoint64, n: u64): FixedPoint64 {
-        let raw_value = (fixed_point64::get_raw_value(x) as u256);
-        fixed_point64::create_from_raw_value((pow_raw(raw_value, (n as u128)) as u128))
-    }
-
-    /// Specialized function for x * y / z that omits intermediate shifting
-    public fun mul_div(x: FixedPoint64, y: FixedPoint64, z: FixedPoint64): FixedPoint64 {
-        let a = fixed_point64::get_raw_value(x);
-        let b = fixed_point64::get_raw_value(y);
-        let c = fixed_point64::get_raw_value(z);
-        fixed_point64::create_from_raw_value (math128::mul_div(a, b, c))
-    }
-
-    // Calculate e^x where x and the result are fixed point numbers
-    fun exp_raw(x: u256): u256 {
-        // exp(x / 2^64) = 2^(x / (2^64 * ln(2))) = 2^(floor(x / (2^64 * ln(2))) + frac(x / (2^64 * ln(2))))
-        let shift_long = x / LN2;
-        assert!(shift_long <= 63, std::error::invalid_state(EOVERFLOW_EXP));
-        let shift = (shift_long as u8);
-        let remainder = x % LN2;
-        // At this point we want to calculate 2^(remainder / ln2) << shift
-        // ln2 = 580 * 22045359733108027
-        let bigfactor = 22045359733108027;
-        let exponent = remainder / bigfactor;
-        let x = remainder % bigfactor;
-        // 2^(remainder / ln2) = (2^(1/580))^exponent * exp(x / 2^64)
-        let roottwo = 18468802611690918839;  // fixed point representation of 2^(1/580)
-        // 2^(1/580) = roottwo(1 - eps), so the number we seek is roottwo^exponent (1 - eps * exponent)
-        let power = pow_raw(roottwo, (exponent as u128));
-        let eps_correction = 219071715585908898;
-        power = power - ((power * eps_correction * exponent) >> 128);
-        // x is fixed point number smaller than bigfactor/2^64 < 0.0011 so we need only 5 tayler steps
-        // to get the 15 digits of precission
-        let taylor1 = (power * x) >> (64 - shift);
-        let taylor2 = (taylor1 * x) >> 64;
-        let taylor3 = (taylor2 * x) >> 64;
-        let taylor4 = (taylor3 * x) >> 64;
-        let taylor5 = (taylor4 * x) >> 64;
-        let taylor6 = (taylor5 * x) >> 64;
-        (power << shift) + taylor1 + taylor2 / 2 + taylor3 / 6 + taylor4 / 24 + taylor5 / 120 + taylor6 / 720
-    }
-
-    // Calculate x to the power of n, where x and the result are fixed point numbers.
-    fun pow_raw(x: u256, n: u128): u256 {
-        let res: u256 = 1 << 64;
-        while (n != 0) {
-            if (n & 1 != 0) {
-                res = (res * x) >> 64;
-            };
-            n = n >> 1;
-            x = (x * x) >> 64;
-        };
-        res
-    }
-
-    #[test]
-    public entry fun test_sqrt() {
-        // Sqrt is based on math128::sqrt and thus most of the testing is done there.
-        let fixed_base = 1 << 64;
-        let result = sqrt(fixed_point64::create_from_u128(1));
-        assert!(fixed_point64::get_raw_value(result) == fixed_base, 0);
-
-        let result = sqrt(fixed_point64::create_from_u128(2));
-        assert_approx_the_same((fixed_point64::get_raw_value(result) as u256), 26087635650665564424, 16);
-    }
-
-    #[test]
-    public entry fun test_exp() {
-        let fixed_base = 1 << 64;
-        let result = exp_raw(0);
-        assert!(result == fixed_base, 0);
-
-        let result = exp_raw(fixed_base);
-        let e = 50143449209799256682;  // e in 32 bit fixed point
-        assert_approx_the_same(result, e, 16);
-
-        let result = exp_raw(10 * fixed_base);
-        let exp10 = 406316577365116946489258;  // e^10 in 32 bit fixed point
-        assert_approx_the_same(result, exp10, 16);
-    }
-
-    #[test]
-    public entry fun test_pow() {
-        // We use the case of exp
-        let result = pow_raw(18468802611690918839, 580);
-        assert_approx_the_same(result,  1 << 65, 16);
-    }
-
-    #[test_only]
-    /// For functions that approximate a value it's useful to test a value is close
-    /// to the most correct value up to last digit
-    fun assert_approx_the_same(x: u256, y: u256, precission: u128) {
-        if (x < y) {
-            let tmp = x;
-            x = y;
-            y = tmp;
-        };
-        let mult = (math128::pow(10, precission) as u256);
-        assert!((x - y) * mult < x, 0);
-    }
-}