diff --git a/sui/Move.lock b/Move.lock similarity index 85% rename from sui/Move.lock rename to Move.lock index 4dbed60..e4ae1ee 100644 --- a/sui/Move.lock +++ b/Move.lock @@ -2,7 +2,7 @@ [move] version = 3 -manifest_digest = "24814DF551096BA472A2B43A3C4234C6E195BB35AEBCE313151D3C3C5B38EA8B" +manifest_digest = "127ED13782FCE705A927196B6884D7338BDAC3EBF81A38F67F60B5907EFBBBAF" deps_digest = "F8BBB0CCB2491CA29A3DF03D6F92277A4F3574266507ACD77214D37ECA3F3082" dependencies = [ { id = "Sui", name = "Sui" }, @@ -21,6 +21,6 @@ dependencies = [ ] [move.toolchain-version] -compiler-version = "1.48.4" +compiler-version = "1.55.0" edition = "2024" flavor = "sui" diff --git a/sui/Move.toml b/Move.toml similarity index 100% rename from sui/Move.toml rename to Move.toml diff --git a/aptos/Move.toml b/aptos/Move.toml deleted file mode 100644 index 3177b6e..0000000 --- a/aptos/Move.toml +++ /dev/null @@ -1,14 +0,0 @@ -[package] -name = 'IntegerMate' -version = '1.0.0' - -[addresses] -std = "0x1" -aptos_std = "0x1" -aptos_framework = "0x1" -integer_mate = "_" - -[dependencies.MoveStdlib] -git = "https://github.com/aptos-labs/aptos-core.git" -subdir = "aptos-move/framework/move-stdlib" -rev = "40d169ad5ace6298a84b0f401b4b5e7ccce701fc" diff --git a/aptos/sources/full_math_u128.move b/aptos/sources/full_math_u128.move deleted file mode 100644 index 76d8944..0000000 --- a/aptos/sources/full_math_u128.move +++ /dev/null @@ -1,44 +0,0 @@ -module integer_mate::full_math_u128 { - use integer_mate::u256; - use integer_mate::math_u128; - - public fun mul_div_floor(num1: u128, num2: u128, denom: u128): u128 { - let r = full_mul_v2(num1, num2) / (denom as u256); - (r as u128) - } - - public fun mul_div_round(num1: u128, num2: u128, denom: u128): u128 { - let r = (full_mul_v2(num1, num2) + ((denom as u256) >> 1)) / (denom as u256); - (r as u128) - } - - public fun mul_div_ceil(num1: u128, num2: u128, denom: u128): u128 { - let r = (full_mul_v2(num1, num2) + ((denom as u256) - 1)) / (denom as u256); - (r as u128) - } - - public fun mul_shr(num1: u128, num2: u128, shift: u8): u128 { - let product = full_mul_v2(num1, num2) >> shift; - (product as u128) - } - - public fun mul_shl(num1: u128, num2: u128, shift: u8): u128 { - let product = full_mul_v2(num1, num2) << shift; - (product as u128) - } - - public fun full_mul(num1: u128, num2: u128): u256::U256 { - let (lo, hi) = math_u128::full_mul(num1, num2); - u256::new( - math_u128::lo(lo), - math_u128::hi(lo), - math_u128::lo(hi), - math_u128::hi(hi), - ) - } - - public fun full_mul_v2(num1: u128, num2: u128): u256 { - (num1 as u256) * (num2 as u256) - } - -} diff --git a/aptos/sources/full_math_u64.move b/aptos/sources/full_math_u64.move deleted file mode 100644 index 7ff7a5d..0000000 --- a/aptos/sources/full_math_u64.move +++ /dev/null @@ -1,31 +0,0 @@ -module integer_mate::full_math_u64 { - public fun mul_div_floor(num1: u64, num2: u64, denom: u64): u64 { - let r = full_mul(num1, num2) / (denom as u128); - (r as u64) - } - - public fun mul_div_round(num1: u64, num2: u64, denom: u64): u64 { - let r = (full_mul(num1, num2) + ((denom as u128) >> 1)) / (denom as u128); - (r as u64) - } - - public fun mul_div_ceil(num1: u64, num2: u64, denom: u64): u64 { - let r = (full_mul(num1, num2) + ((denom as u128) - 1)) / (denom as u128); - (r as u64) - } - - public fun mul_shr(num1: u64, num2: u64, shift: u8): u64 { - let r = full_mul(num1, num2) >> shift; - (r as u64) - } - - public fun mul_shl(num1: u64, num2: u64, shift: u8): u64 { - let r = full_mul(num1, num2) << shift; - (r as u64) - } - - public fun full_mul(num1: u64, num2: u64): u128 { - ((num1 as u128) * (num2 as u128)) - } -} - diff --git a/aptos/sources/i128.move b/aptos/sources/i128.move deleted file mode 100644 index 43540c0..0000000 --- a/aptos/sources/i128.move +++ /dev/null @@ -1,522 +0,0 @@ -module integer_mate::i128 { - use std::error; - use integer_mate::i64; - use integer_mate::i32; - - const OVERFLOW: u64 = 0; - - const MIN_AS_U128: u128 = 1 << 127; - const MAX_AS_U128: u128 = 0x7fffffffffffffffffffffffffffffff; - - const LT: u8 = 0; - const EQ: u8 = 1; - const GT: u8 = 2; - - struct I128 has copy, drop, store { - bits: u128 - } - - public fun zero(): I128 { - I128 { - bits: 0 - } - } - - public fun from(v: u128): I128 { - assert!(v <= MAX_AS_U128, error::invalid_argument(OVERFLOW)); - I128 { - bits: v - } - } - - public fun neg_from(v: u128): I128 { - assert!(v <= MIN_AS_U128, error::invalid_argument(OVERFLOW)); - if (v == 0) { - I128 { - bits: v - } - } else { - I128 { - bits: (u128_neg(v) + 1) | (1 << 127) - } - } - } - - public fun neg(v: I128): I128 { - if (is_neg(v)) { - abs(v) - } else { - neg_from(v.bits) - } - } - - public fun wrapping_add(num1: I128, num2:I128): I128 { - let sum = num1.bits ^ num2.bits; - let carry = (num1.bits & num2.bits) << 1; - while (carry != 0) { - let a = sum; - let b = carry; - sum = a ^ b; - carry = (a & b) << 1; - }; - I128 { - bits: sum - } - } - - public fun add(num1: I128, num2: I128): I128 { - let sum = wrapping_add(num1, num2); - let overflow = (sign(num1) & sign(num2) & u8_neg(sign(sum))) + (u8_neg(sign(num1)) & u8_neg(sign(num2)) & sign(sum)); - assert!(overflow == 0, error::invalid_argument(OVERFLOW)); - sum - } - - public fun overflowing_add(num1: I128, num2: I128): (I128, bool) { - let sum = wrapping_add(num1, num2); - let overflow = (sign(num1) & sign(num2) & u8_neg(sign(sum))) + (u8_neg(sign(num1)) & u8_neg(sign(num2)) & sign(sum)); - (sum, overflow != 0) - } - - public fun wrapping_sub(num1: I128, num2: I128): I128 { - let sub_num = wrapping_add(I128 { - bits: u128_neg(num2.bits) - }, from(1)); - wrapping_add(num1, sub_num) - } - - public fun sub(num1: I128, num2: I128): I128 { - let (v, overflow) = overflowing_sub(num1, num2); - assert!(!overflow, EOverflow); - v - } - - public fun overflowing_sub(num1: I128, num2: I128): (I128, bool) { - let v = wrapping_sub(num1, num2); - let overflow = sign(num1) != sign(num2) && sign(num1) != sign(v); - (v, overflow) - } - - public fun mul(num1: I128, num2: I128): I128 { - let product = abs_u128(num1) * abs_u128(num2); - if (sign(num1) != sign(num2)) { - return neg_from(product) - }; - return from(product) - } - - public fun div(num1: I128, num2: I128): I128 { - let result = abs_u128(num1) / abs_u128(num2); - if (sign(num1) != sign(num2)) { - return neg_from(result) - }; - return from(result) - } - - public fun abs(v: I128): I128 { - if (sign(v) == 0) { - v - } else { - assert!(v.bits > MIN_AS_U128, error::invalid_argument(OVERFLOW)); - I128 { - bits: u128_neg(v.bits - 1) - } - } - } - - public fun abs_u128(v: I128): u128 { - if (sign(v) == 0) { - v.bits - } else { - u128_neg(v.bits - 1) - } - } - - public fun shl(v: I128, shift: u8): I128 { - I128 { - bits: v.bits << shift - } - } - - public fun shr(v: I128, shift: u8): I128 { - if (shift == 0) { - return v - }; - let mask = 0xffffffffffffffffffffffffffffffff << (128 - shift); - if (sign(v) == 1) { - return I128 { - bits: (v.bits >> shift) | mask - } - }; - I128 { - bits: v.bits >> shift - } - } - - public fun as_u128(v: I128): u128 { - v.bits - } - - public fun as_i64(v: I128): i64::I64 { - if (is_neg(v)) { - return i64::neg_from((abs_u128(v) as u64)) - } else { - return i64::from((abs_u128(v) as u64)) - } - } - - public fun as_i32(v: I128): i32::I32 { - if (is_neg(v)) { - return i32::neg_from((abs_u128(v) as u32)) - } else { - return i32::from((abs_u128(v) as u32)) - } - } - - public fun sign(v: I128): u8 { - ((v.bits >> 127) as u8) - } - - public fun is_neg(v: I128): bool { - sign(v) == 1 - } - - public fun cmp(num1: I128, num2: I128): u8 { - if (num1.bits == num2.bits) return EQ; - if (sign(num1) > sign(num2)) return LT; - if (sign(num1) < sign(num2)) return GT; - if (num1.bits > num2.bits) { - return GT - } else { - return LT - } - } - - public fun eq(num1: I128, num2: I128): bool { - num1.bits == num2.bits - } - - public fun gt(num1: I128, num2: I128): bool { - cmp(num1, num2) == GT - } - - public fun gte(num1: I128, num2: I128): bool { - cmp(num1, num2) >= EQ - } - - public fun lt(num1: I128, num2: I128): bool { - cmp(num1, num2) == LT - } - - public fun lte(num1: I128, num2: I128): bool { - cmp(num1, num2) <= EQ - } - - public fun or(num1: I128, num2: I128): I128 { - I128 { - bits: (num1.bits | num2.bits) - } - } - - public fun and(num1: I128, num2: I128): I128 { - I128 { - bits: (num1.bits & num2.bits) - } - } - - fun u128_neg(v :u128) : u128 { - v ^ 0xffffffffffffffffffffffffffffffff - } - - fun u8_neg(v: u8): u8 { - v ^ 0xff - } - - #[test] - fun test_from_ok() { - assert!(as_u128(from(0)) == 0, 0); - assert!(as_u128(from(10)) == 10, 1); - } - - #[test] - #[expected_failure] - fun test_from_overflow() { - as_u128(from(MIN_AS_U128)); - as_u128(from(0xffffffffffffffffffffffffffffffff)); - } - - #[test] - fun test_neg_from() { - assert!(as_u128(neg_from(0)) == 0, 0); - assert!(as_u128(neg_from(1)) == 0xffffffffffffffffffffffffffffffff, 1); - assert!(as_u128(neg_from(0x7fffffffffffffffffffffffffffffff)) == 0x80000000000000000000000000000001, 2); - assert!(as_u128(neg_from(MIN_AS_U128)) == MIN_AS_U128, 2); - } - - #[test] - #[expected_failure] - fun test_neg_from_overflow() { - neg_from(0x80000000000000000000000000000001); - } - - #[test] - fun test_abs() { - assert!(as_u128(from(10)) == 10u128, 0); - assert!(as_u128(abs(neg_from(10))) == 10u128, 1); - assert!(as_u128(abs(neg_from(0))) == 0u128, 2); - assert!(as_u128(abs(neg_from(0x7fffffffffffffffffffffffffffffff))) == 0x7fffffffffffffffffffffffffffffff, 3); - assert!(as_u128(neg_from(MIN_AS_U128)) == MIN_AS_U128, 4); - } - - #[test] - #[expected_failure] - fun test_abs_overflow() { - abs(neg_from(1<<127)); - } - - #[test] - fun test_wrapping_add() { - assert!(as_u128(wrapping_add(from(0), from(1))) == 1, 0); - assert!(as_u128(wrapping_add(from(1), from(0))) == 1, 0); - assert!(as_u128(wrapping_add(from(10000), from(99999))) == 109999, 0); - assert!(as_u128(wrapping_add(from(99999), from(10000))) == 109999, 0); - assert!(as_u128(wrapping_add(from(MAX_AS_U128-1), from(1))) == MAX_AS_U128, 0); - assert!(as_u128(wrapping_add(from(0), from(0))) == 0, 0); - - assert!(as_u128(wrapping_add(neg_from(0), neg_from(0))) == 0, 1); - assert!(as_u128(wrapping_add(neg_from(1), neg_from(0))) == 0xffffffffffffffffffffffffffffffff, 1); - assert!(as_u128(wrapping_add(neg_from(0), neg_from(1))) == 0xffffffffffffffffffffffffffffffff, 1); - assert!(as_u128(wrapping_add(neg_from(10000), neg_from(99999))) == 0xfffffffffffffffffffffffffffe5251, 1); - assert!(as_u128(wrapping_add(neg_from(99999), neg_from(10000))) == 0xfffffffffffffffffffffffffffe5251, 1); - assert!(as_u128(wrapping_add(neg_from(MIN_AS_U128-1), neg_from(1))) == MIN_AS_U128, 1); - - assert!(as_u128(wrapping_add(from(0), neg_from(0))) == 0, 2); - assert!(as_u128(wrapping_add(neg_from(0), from(0))) == 0, 2); - assert!(as_u128(wrapping_add(neg_from(1), from(1))) == 0, 2); - assert!(as_u128(wrapping_add(from(1), neg_from(1))) == 0, 2); - assert!(as_u128(wrapping_add(from(10000), neg_from(99999))) == 0xfffffffffffffffffffffffffffea071, 2); - assert!(as_u128(wrapping_add(from(99999), neg_from(10000))) == 89999, 2); - assert!(as_u128(wrapping_add(neg_from(MIN_AS_U128), from(1))) == 0x80000000000000000000000000000001, 2); - assert!(as_u128(wrapping_add(from(MAX_AS_U128), neg_from(1))) == MAX_AS_U128 - 1, 2); - - assert!(as_u128(wrapping_add(from(MAX_AS_U128), from(1))) == MIN_AS_U128, 2); - } - - #[test] - fun test_add() { - assert!(as_u128(add(from(0), from(0))) == 0, 0); - assert!(as_u128(add(from(0), from(1))) == 1, 0); - assert!(as_u128(add(from(1), from(0))) == 1, 0); - assert!(as_u128(add(from(10000), from(99999))) == 109999, 0); - assert!(as_u128(add(from(99999), from(10000))) == 109999, 0); - assert!(as_u128(add(from(MAX_AS_U128-1), from(1))) == MAX_AS_U128, 0); - - assert!(as_u128(add(neg_from(0), neg_from(0))) == 0, 1); - assert!(as_u128(add(neg_from(1), neg_from(0))) == 0xffffffffffffffffffffffffffffffff, 1); - assert!(as_u128(add(neg_from(0), neg_from(1))) == 0xffffffffffffffffffffffffffffffff, 1); - assert!(as_u128(add(neg_from(10000), neg_from(99999))) == 0xfffffffffffffffffffffffffffe5251, 1); - assert!(as_u128(add(neg_from(99999), neg_from(10000))) == 0xfffffffffffffffffffffffffffe5251, 1); - assert!(as_u128(add(neg_from(MIN_AS_U128-1), neg_from(1))) == MIN_AS_U128, 1); - - assert!(as_u128(add(from(0), neg_from(0))) == 0, 2); - assert!(as_u128(add(neg_from(0), from(0))) == 0, 2); - assert!(as_u128(add(neg_from(1), from(1))) == 0, 2); - assert!(as_u128(add(from(1), neg_from(1))) == 0, 2); - assert!(as_u128(add(from(10000), neg_from(99999))) == 0xfffffffffffffffffffffffffffea071, 2); - assert!(as_u128(add(from(99999), neg_from(10000))) == 89999, 2); - assert!(as_u128(add(neg_from(MIN_AS_U128), from(1))) == 0x80000000000000000000000000000001, 2); - assert!(as_u128(add(from(MAX_AS_U128), neg_from(1))) == MAX_AS_U128 - 1, 2); - } - - #[test] - fun test_overflowing_add() { - let (result, overflow) = overflowing_add(from(MAX_AS_U128), neg_from(1)); - assert!(overflow == false && as_u128(result) == MAX_AS_U128 - 1, 1); - let (_, overflow) = overflowing_add(from(MAX_AS_U128), from(1)); - assert!(overflow == true, 1); - let (_, overflow) = overflowing_add(neg_from(MIN_AS_U128), neg_from(1)); - assert!(overflow == true, 1); - } - - #[test] - #[expected_failure] - fun test_add_overflow() { - add(from(MAX_AS_U128), from(1)); - } - - #[test] - #[expected_failure] - fun test_add_underflow() { - add(neg_from(MIN_AS_U128), neg_from(1)); - } - - #[test] - fun test_wrapping_sub() { - assert!(as_u128(wrapping_sub(from(0), from(0))) == 0, 0); - assert!(as_u128(wrapping_sub(from(1), from(0))) == 1, 0); - assert!(as_u128(wrapping_sub(from(0), from(1))) == as_u128(neg_from(1)), 0); - assert!(as_u128(wrapping_sub(from(1), from(1))) == as_u128(neg_from(0)), 0); - assert!(as_u128(wrapping_sub(from(1), neg_from(1))) == as_u128(from(2)), 0); - assert!(as_u128(wrapping_sub(neg_from(1), from(1))) == as_u128(neg_from(2)), 0); - assert!(as_u128(wrapping_sub(from(1000000), from(1))) == 999999, 0); - assert!(as_u128(wrapping_sub(neg_from(1000000), neg_from(1))) == as_u128(neg_from(999999)), 0); - assert!(as_u128(wrapping_sub(from(1), from(1000000))) == as_u128(neg_from(999999)), 0); - assert!(as_u128(wrapping_sub(from(MAX_AS_U128), from(MAX_AS_U128))) == as_u128(from(0)), 0); - assert!(as_u128(wrapping_sub(from(MAX_AS_U128), from(1))) == as_u128(from(MAX_AS_U128 - 1)), 0); - assert!(as_u128(wrapping_sub(from(MAX_AS_U128), neg_from(1))) == as_u128(neg_from(MIN_AS_U128)), 0); - assert!(as_u128(wrapping_sub(neg_from(MIN_AS_U128), neg_from(1))) == as_u128(neg_from(MIN_AS_U128 - 1)), 0); - assert!(as_u128(wrapping_sub(neg_from(MIN_AS_U128), from(1))) == as_u128(from(MAX_AS_U128)), 0); - } - - #[test] - fun test_sub() { - assert!(as_u128(sub(from(0), from(0))) == 0, 0); - assert!(as_u128(sub(from(1), from(0))) == 1, 0); - assert!(as_u128(sub(from(0), from(1))) == as_u128(neg_from(1)), 0); - assert!(as_u128(sub(from(1), from(1))) == as_u128(neg_from(0)), 0); - assert!(as_u128(sub(from(1), neg_from(1))) == as_u128(from(2)), 0); - assert!(as_u128(sub(neg_from(1), from(1))) == as_u128(neg_from(2)), 0); - assert!(as_u128(sub(from(1000000), from(1))) == 999999, 0); - assert!(as_u128(sub(neg_from(1000000), neg_from(1))) == as_u128(neg_from(999999)), 0); - assert!(as_u128(sub(from(1), from(1000000))) == as_u128(neg_from(999999)), 0); - assert!(as_u128(sub(from(MAX_AS_U128), from(MAX_AS_U128))) == as_u128(from(0)), 0); - assert!(as_u128(sub(from(MAX_AS_U128), from(1))) == as_u128(from(MAX_AS_U128 - 1)), 0); - assert!(as_u128(sub(neg_from(MIN_AS_U128), neg_from(1))) == as_u128(neg_from(MIN_AS_U128 - 1)), 0); - } - - #[test] - fun test_checked_sub() { - let (result, overflowing) = overflowing_sub(from(MAX_AS_U128), from(1)); - assert!(overflowing == false && as_u128(result) == MAX_AS_U128 - 1, 1); - - let (_, overflowing) = overflowing_sub(neg_from(MIN_AS_U128), from(1)); - assert!(overflowing == true, 1); - - let (_, overflowing) = overflowing_sub(from(MAX_AS_U128), neg_from(1)); - assert!(overflowing == true, 1); - } - - #[test] - #[expected_failure] - fun test_sub_overflow() { - sub(from(MAX_AS_U128), neg_from(1)); - } - - #[test] - #[expected_failure] - fun test_sub_underflow() { - sub(neg_from(MIN_AS_U128), from(1)); - } - - #[test] - fun test_mul() { - assert!(as_u128(mul(from(1), from(1))) == 1, 0); - assert!(as_u128(mul(from(10), from(10))) == 100, 0); - assert!(as_u128(mul(from(100), from(100))) == 10000, 0); - assert!(as_u128(mul(from(10000), from(10000))) == 100000000, 0); - - assert!(as_u128(mul(neg_from(1), from(1))) == as_u128(neg_from(1)), 0); - assert!(as_u128(mul(neg_from(10), from(10))) == as_u128(neg_from(100)), 0); - assert!(as_u128(mul(neg_from(100), from(100))) == as_u128(neg_from(10000)), 0); - assert!(as_u128(mul(neg_from(10000), from(10000))) == as_u128(neg_from(100000000)), 0); - - assert!(as_u128(mul(from(1), neg_from(1))) == as_u128(neg_from(1)), 0); - assert!(as_u128(mul(from(10), neg_from(10))) == as_u128(neg_from(100)), 0); - assert!(as_u128(mul(from(100), neg_from(100))) == as_u128(neg_from(10000)), 0); - assert!(as_u128(mul(from(10000), neg_from(10000))) == as_u128(neg_from(100000000)), 0); - assert!(as_u128(mul(from(MIN_AS_U128/2), neg_from(2))) == as_u128(neg_from(MIN_AS_U128)), 0); - } - - #[test] - #[expected_failure] - fun test_mul_overflow() { - mul(from(MIN_AS_U128/2), from(1)); - mul(neg_from(MIN_AS_U128/2), neg_from(2)); - } - - #[test] - fun test_div() { - assert!(as_u128(div(from(0), from(1))) == 0, 0); - assert!(as_u128(div(from(10), from(1))) == 10, 0); - assert!(as_u128(div(from(10), neg_from(1))) == as_u128(neg_from(10)), 0); - assert!(as_u128(div(neg_from(10), neg_from(1))) == as_u128(from(10)), 0); - - assert!(abs_u128(neg_from(MIN_AS_U128)) == MIN_AS_U128, 0); - assert!(as_u128(div(neg_from(MIN_AS_U128), from(1))) == MIN_AS_U128, 0); - } - - #[test] - #[expected_failure] - fun test_div_overflow() { - div(neg_from(MIN_AS_U128), neg_from(1)); - } - - #[test] - fun test_shl() { - assert!(as_u128(shl(from(10), 0)) == 10, 0); - assert!(as_u128(shl(neg_from(10), 0)) == as_u128(neg_from(10)), 0); - - assert!(as_u128(shl(from(10), 1)) == 20, 0); - assert!(as_u128(shl(neg_from(10), 1)) == as_u128(neg_from(20)), 0); - - assert!(as_u128(shl(from(10), 8)) == 2560, 0); - assert!(as_u128(shl(neg_from(10), 8)) == as_u128(neg_from(2560)), 0); - - assert!(as_u128(shl(from(10), 32)) == 42949672960, 0); - assert!(as_u128(shl(neg_from(10), 32)) == as_u128(neg_from(42949672960)), 0); - - assert!(as_u128(shl(from(10), 64)) == 184467440737095516160, 0); - assert!(as_u128(shl(neg_from(10), 64)) == as_u128(neg_from(184467440737095516160)), 0); - - assert!(as_u128(shl(from(10), 127)) == 0, 0); - assert!(as_u128(shl(neg_from(10), 127)) == 0, 0); - } - - #[test] - fun test_shr() { - assert!(as_u128(shr(from(10), 0)) == 10, 0); - assert!(as_u128(shr(neg_from(10), 0)) == as_u128(neg_from(10)), 0); - - assert!(as_u128(shr(from(10), 1)) == 5, 0); - assert!(as_u128(shr(neg_from(10), 1)) == as_u128(neg_from(5)), 0); - - assert!(as_u128(shr(from(MAX_AS_U128), 8)) == 0x7fffffffffffffffffffffffffffff, 0); - assert!(as_u128(shr(neg_from(MIN_AS_U128), 8)) == 0xff800000000000000000000000000000, 0); - - assert!(as_u128(shr(from(MAX_AS_U128), 96)) == 0x7fffffff, 0); - assert!(as_u128(shr(neg_from(MIN_AS_U128), 96)) == 0xffffffffffffffffffffffff80000000, 0); - - assert!(as_u128(shr(from(MAX_AS_U128), 127)) == 0, 0); - assert!(as_u128(shr(neg_from(MIN_AS_U128), 127)) == 0xffffffffffffffffffffffffffffffff, 0); - } - - #[test] - fun test_sign() { - assert!(sign(neg_from(10)) == 1u8, 0); - assert!(sign(from(10)) == 0u8, 0); - } - - #[test] - fun test_cmp() { - assert!(cmp(from(1), from(0)) == GT, 0); - assert!(cmp(from(0), from(1)) == LT, 0); - - assert!(cmp(from(0), neg_from(1)) == GT, 0); - assert!(cmp(neg_from(0), neg_from(1)) == GT, 0); - assert!(cmp(neg_from(1), neg_from(0)) == LT, 0); - - assert!(cmp(neg_from(MIN_AS_U128), from(MAX_AS_U128)) == LT, 0); - assert!(cmp(from(MAX_AS_U128), neg_from(MIN_AS_U128)) == GT, 0); - - assert!(cmp(from(MAX_AS_U128), from(MAX_AS_U128-1)) == GT, 0); - assert!(cmp(from(MAX_AS_U128-1), from(MAX_AS_U128)) == LT, 0); - - assert!(cmp(neg_from(MIN_AS_U128), neg_from(MIN_AS_U128-1)) == LT, 0); - assert!(cmp(neg_from(MIN_AS_U128-1), neg_from(MIN_AS_U128)) == GT, 0); - } - - #[test] - fun test_castdown() { - assert!((1u128 as u8) == 1u8, 0); - } -} - diff --git a/aptos/sources/i32.move b/aptos/sources/i32.move deleted file mode 100644 index ab0dcce..0000000 --- a/aptos/sources/i32.move +++ /dev/null @@ -1,480 +0,0 @@ -module integer_mate::i32 { - const EOverflow: u64 = 0; - - const MIN_AS_U32: u32 = 1 << 31; - const MAX_AS_U32: u32 = 0x7fffffff; - - const LT: u8 = 0; - const EQ: u8 = 1; - const GT: u8 = 2; - - struct I32 has copy, drop, store { - bits: u32 - } - - public fun zero(): I32 { - I32 { - bits: 0 - } - } - - public fun from_u32(v: u32): I32 { - I32 { - bits: v - } - } - - public fun from(v: u32): I32 { - assert!(v <= MAX_AS_U32, EOverflow); - I32 { - bits: v - } - } - - public fun neg_from(v: u32): I32 { - assert!(v <= MIN_AS_U32, EOverflow); - if (v == 0) { - I32 { - bits: v - } - } else { - I32 { - bits: (u32_neg(v) + 1) | (1 << 31) - } - } - } - - public fun wrapping_add(num1: I32, num2: I32): I32 { - let sum = num1.bits ^ num2.bits; - let carry = (num1.bits & num2.bits) << 1; - while (carry != 0) { - let a = sum; - let b = carry; - sum = a ^ b; - carry = (a & b) << 1; - }; - I32 { - bits: sum - } - } - - public fun add(num1: I32, num2: I32): I32 { - let sum = wrapping_add(num1, num2); - let overflow = (sign(num1) & sign(num2) & u8_neg(sign(sum))) + - (u8_neg(sign(num1)) & u8_neg(sign(num2)) & sign(sum)); - assert!(overflow == 0, EOverflow); - sum - } - - public fun wrapping_sub(num1: I32, num2: I32): I32 { - let sub_num = wrapping_add(I32 { - bits: u32_neg(num2.bits) - }, from(1)); - wrapping_add(num1, sub_num) - } - - public fun sub(num1: I32, num2: I32): I32 { - let v = wrapping_sub(num1, num2); - let overflow = sign(num1) != sign(num2) && sign(num1) != sign(v); - assert!(!overflow, EOverflow); - v - } - - public fun mul(num1: I32, num2: I32): I32 { - let product = abs_u32(num1) * abs_u32(num2); - if (sign(num1) != sign(num2)) { - return neg_from(product) - }; - return from(product) - } - - public fun div(num1: I32, num2: I32): I32 { - let result = abs_u32(num1) / abs_u32(num2); - if (sign(num1) != sign(num2)) { - return neg_from(result) - }; - return from(result) - } - - public fun abs(v: I32): I32 { - if (sign(v) == 0) { - v - } else { - assert!(v.bits > MIN_AS_U32, EOverflow); - I32 { - bits: u32_neg(v.bits - 1) - } - } - } - - public fun abs_u32(v: I32): u32 { - if (sign(v) == 0) { - v.bits - } else { - u32_neg(v.bits - 1) - } - } - - public fun shl(v: I32, shift: u8): I32 { - I32 { - bits: v.bits << shift - } - } - - public fun shr(v: I32, shift: u8): I32 { - if (shift == 0) { - return v - }; - let mask = 0xffffffff << (32 - shift); - if (sign(v) == 1) { - return I32 { - bits: (v.bits >> shift) | mask - } - }; - I32 { - bits: v.bits >> shift - } - } - - public fun mod(v: I32, n: I32): I32 { - if (sign(v) == 1) { - neg_from((abs_u32(v) % abs_u32(n))) - } else { - from((as_u32(v) % abs_u32(n))) - } - } - - public fun as_u32(v: I32): u32 { - v.bits - } - - public fun sign(v: I32): u8 { - ((v.bits >> 31) as u8) - } - - public fun is_neg(v: I32): bool { - sign(v) == 1 - } - - public fun cmp(num1: I32, num2: I32): u8 { - if (num1.bits == num2.bits) return EQ; - if (sign(num1) > sign(num2)) return LT; - if (sign(num1) < sign(num2)) return GT; - if (num1.bits > num2.bits) { - return GT - } else { - return LT - } - } - - public fun eq(num1: I32, num2: I32): bool { - num1.bits == num2.bits - } - - public fun gt(num1: I32, num2: I32): bool { - cmp(num1, num2) == GT - } - - public fun gte(num1: I32, num2: I32): bool { - cmp(num1, num2) >= EQ - } - - public fun lt(num1: I32, num2: I32): bool { - cmp(num1, num2) == LT - } - - public fun lte(num1: I32, num2: I32): bool { - cmp(num1, num2) <= EQ - } - - public fun or(num1: I32, num2: I32): I32 { - I32 { - bits: (num1.bits | num2.bits) - } - } - - public fun and(num1: I32, num2: I32): I32 { - I32 { - bits: (num1.bits & num2.bits) - } - } - - fun u32_neg(v: u32): u32 { - v ^ 0xffffffff - } - - fun u8_neg(v: u8): u8 { - v ^ 0xff - } - - #[test] - fun test_from_ok() { - assert!(as_u32(from(0)) == 0, 0); - assert!(as_u32(from(10)) == 10, 1); - } - - #[test] - #[expected_failure] - fun test_from_overflow() { - as_u32(from(MIN_AS_U32)); - as_u32(from(0xffffffff)); - } - - #[test] - fun test_neg_from() { - assert!(as_u32(neg_from(0)) == 0, 0); - assert!(as_u32(neg_from(1)) == 0xffffffff, 1); - assert!(as_u32(neg_from(0x7fffffff)) == 0x80000001, 2); - assert!(as_u32(neg_from(MIN_AS_U32)) == MIN_AS_U32, 2); - } - - #[test] - #[expected_failure] - fun test_neg_from_overflow() { - neg_from(0x80000001); - } - - #[test] - fun test_abs() { - assert!(as_u32(from(10)) == 10u32, 0); - assert!(as_u32(abs(neg_from(10))) == 10u32, 1); - assert!(as_u32(abs(neg_from(0))) == 0u32, 2); - assert!(as_u32(abs(neg_from(0x7fffffff))) == 0x7fffffff, 3); - assert!(as_u32(neg_from(MIN_AS_U32)) == MIN_AS_U32, 4); - } - - #[test] - #[expected_failure] - fun test_abs_overflow() { - abs(neg_from(1 << 31)); - } - - #[test] - fun test_wrapping_add() { - assert!(as_u32(wrapping_add(from(0), from(1))) == 1, 0); - assert!(as_u32(wrapping_add(from(1), from(0))) == 1, 0); - assert!(as_u32(wrapping_add(from(10000), from(99999))) == 109999, 0); - assert!(as_u32(wrapping_add(from(99999), from(10000))) == 109999, 0); - assert!(as_u32(wrapping_add(from(MAX_AS_U32 - 1), from(1))) == MAX_AS_U32, 0); - assert!(as_u32(wrapping_add(from(0), from(0))) == 0, 0); - - assert!(as_u32(wrapping_add(neg_from(0), neg_from(0))) == 0, 1); - assert!(as_u32(wrapping_add(neg_from(1), neg_from(0))) == 0xffffffff, 1); - assert!(as_u32(wrapping_add(neg_from(0), neg_from(1))) == 0xffffffff, 1); - assert!(as_u32(wrapping_add(neg_from(10000), neg_from(99999))) == 0xfffe5251, 1); - assert!(as_u32(wrapping_add(neg_from(99999), neg_from(10000))) == 0xfffe5251, 1); - assert!(as_u32(wrapping_add(neg_from(MIN_AS_U32 - 1), neg_from(1))) == MIN_AS_U32, 1); - - assert!(as_u32(wrapping_add(from(0), neg_from(0))) == 0, 2); - assert!(as_u32(wrapping_add(neg_from(0), from(0))) == 0, 2); - assert!(as_u32(wrapping_add(neg_from(1), from(1))) == 0, 2); - assert!(as_u32(wrapping_add(from(1), neg_from(1))) == 0, 2); - assert!(as_u32(wrapping_add(from(10000), neg_from(99999))) == 0xfffea071, 2); - assert!(as_u32(wrapping_add(from(99999), neg_from(10000))) == 89999, 2); - assert!(as_u32(wrapping_add(neg_from(MIN_AS_U32), from(1))) == 0x80000001, 2); - assert!(as_u32(wrapping_add(from(MAX_AS_U32), neg_from(1))) == MAX_AS_U32 - 1, 2); - - assert!(as_u32(wrapping_add(from(MAX_AS_U32), from(1))) == MIN_AS_U32, 2); - } - - #[test] - fun test_add() { - assert!(as_u32(add(from(0), from(0))) == 0, 0); - assert!(as_u32(add(from(0), from(1))) == 1, 0); - assert!(as_u32(add(from(1), from(0))) == 1, 0); - assert!(as_u32(add(from(10000), from(99999))) == 109999, 0); - assert!(as_u32(add(from(99999), from(10000))) == 109999, 0); - assert!(as_u32(add(from(MAX_AS_U32 - 1), from(1))) == MAX_AS_U32, 0); - - assert!(as_u32(add(neg_from(0), neg_from(0))) == 0, 1); - assert!(as_u32(add(neg_from(1), neg_from(0))) == 0xffffffff, 1); - assert!(as_u32(add(neg_from(0), neg_from(1))) == 0xffffffff, 1); - assert!(as_u32(add(neg_from(10000), neg_from(99999))) == 0xfffe5251, 1); - assert!(as_u32(add(neg_from(99999), neg_from(10000))) == 0xfffe5251, 1); - assert!(as_u32(add(neg_from(MIN_AS_U32 - 1), neg_from(1))) == MIN_AS_U32, 1); - - assert!(as_u32(add(from(0), neg_from(0))) == 0, 2); - assert!(as_u32(add(neg_from(0), from(0))) == 0, 2); - assert!(as_u32(add(neg_from(1), from(1))) == 0, 2); - assert!(as_u32(add(from(1), neg_from(1))) == 0, 2); - assert!(as_u32(add(from(10000), neg_from(99999))) == 0xfffea071, 2); - assert!(as_u32(add(from(99999), neg_from(10000))) == 89999, 2); - assert!(as_u32(add(neg_from(MIN_AS_U32), from(1))) == 0x80000001, 2); - assert!(as_u32(add(from(MAX_AS_U32), neg_from(1))) == MAX_AS_U32 - 1, 2); - } - - #[test] - #[expected_failure] - fun test_add_overflow() { - add(from(MAX_AS_U32), from(1)); - } - - #[test] - #[expected_failure] - fun test_add_underflow() { - add(neg_from(MIN_AS_U32), neg_from(1)); - } - - #[test] - fun test_wrapping_sub() { - assert!(as_u32(wrapping_sub(from(0), from(0))) == 0, 0); - assert!(as_u32(wrapping_sub(from(1), from(0))) == 1, 0); - assert!(as_u32(wrapping_sub(from(0), from(1))) == as_u32(neg_from(1)), 0); - assert!(as_u32(wrapping_sub(from(1), from(1))) == as_u32(neg_from(0)), 0); - assert!(as_u32(wrapping_sub(from(1), neg_from(1))) == as_u32(from(2)), 0); - assert!(as_u32(wrapping_sub(neg_from(1), from(1))) == as_u32(neg_from(2)), 0); - assert!(as_u32(wrapping_sub(from(1000000), from(1))) == 999999, 0); - assert!(as_u32(wrapping_sub(neg_from(1000000), neg_from(1))) == as_u32(neg_from(999999)), 0); - assert!(as_u32(wrapping_sub(from(1), from(1000000))) == as_u32(neg_from(999999)), 0); - assert!(as_u32(wrapping_sub(from(MAX_AS_U32), from(MAX_AS_U32))) == as_u32(from(0)), 0); - assert!(as_u32(wrapping_sub(from(MAX_AS_U32), from(1))) == as_u32(from(MAX_AS_U32 - 1)), 0); - assert!(as_u32(wrapping_sub(from(MAX_AS_U32), neg_from(1))) == as_u32(neg_from(MIN_AS_U32)), 0); - assert!(as_u32(wrapping_sub(neg_from(MIN_AS_U32), neg_from(1))) == as_u32(neg_from(MIN_AS_U32 - 1)), 0); - assert!(as_u32(wrapping_sub(neg_from(MIN_AS_U32), from(1))) == as_u32(from(MAX_AS_U32)), 0); - } - - #[test] - fun test_sub() { - assert!(as_u32(sub(from(0), from(0))) == 0, 0); - assert!(as_u32(sub(from(1), from(0))) == 1, 0); - assert!(as_u32(sub(from(0), from(1))) == as_u32(neg_from(1)), 0); - assert!(as_u32(sub(from(1), from(1))) == as_u32(neg_from(0)), 0); - assert!(as_u32(sub(from(1), neg_from(1))) == as_u32(from(2)), 0); - assert!(as_u32(sub(neg_from(1), from(1))) == as_u32(neg_from(2)), 0); - assert!(as_u32(sub(from(1000000), from(1))) == 999999, 0); - assert!(as_u32(sub(neg_from(1000000), neg_from(1))) == as_u32(neg_from(999999)), 0); - assert!(as_u32(sub(from(1), from(1000000))) == as_u32(neg_from(999999)), 0); - assert!(as_u32(sub(from(MAX_AS_U32), from(MAX_AS_U32))) == as_u32(from(0)), 0); - assert!(as_u32(sub(from(MAX_AS_U32), from(1))) == as_u32(from(MAX_AS_U32 - 1)), 0); - assert!(as_u32(sub(neg_from(MIN_AS_U32), neg_from(1))) == as_u32(neg_from(MIN_AS_U32 - 1)), 0); - } - - #[test] - #[expected_failure] - fun test_sub_overflow() { - sub(from(MAX_AS_U32), neg_from(1)); - } - - #[test] - #[expected_failure] - fun test_sub_underflow() { - sub(neg_from(MIN_AS_U32), from(1)); - } - - #[test] - fun test_mul() { - assert!(as_u32(mul(from(1), from(1))) == 1, 0); - assert!(as_u32(mul(from(10), from(10))) == 100, 0); - assert!(as_u32(mul(from(100), from(100))) == 10000, 0); - assert!(as_u32(mul(from(10000), from(10000))) == 100000000, 0); - - assert!(as_u32(mul(neg_from(1), from(1))) == as_u32(neg_from(1)), 0); - assert!(as_u32(mul(neg_from(10), from(10))) == as_u32(neg_from(100)), 0); - assert!(as_u32(mul(neg_from(100), from(100))) == as_u32(neg_from(10000)), 0); - assert!(as_u32(mul(neg_from(10000), from(10000))) == as_u32(neg_from(100000000)), 0); - - assert!(as_u32(mul(from(1), neg_from(1))) == as_u32(neg_from(1)), 0); - assert!(as_u32(mul(from(10), neg_from(10))) == as_u32(neg_from(100)), 0); - assert!(as_u32(mul(from(100), neg_from(100))) == as_u32(neg_from(10000)), 0); - assert!(as_u32(mul(from(10000), neg_from(10000))) == as_u32(neg_from(100000000)), 0); - assert!(as_u32(mul(from(MIN_AS_U32 / 2), neg_from(2))) == as_u32(neg_from(MIN_AS_U32)), 0); - } - - #[test] - #[expected_failure] - fun test_mul_overflow() { - mul(from(MIN_AS_U32 / 2), from(1)); - mul(neg_from(MIN_AS_U32 / 2), neg_from(2)); - } - - #[test] - fun test_div() { - assert!(as_u32(div(from(0), from(1))) == 0, 0); - assert!(as_u32(div(from(10), from(1))) == 10, 0); - assert!(as_u32(div(from(10), neg_from(1))) == as_u32(neg_from(10)), 0); - assert!(as_u32(div(neg_from(10), neg_from(1))) == as_u32(from(10)), 0); - - assert!(abs_u32(neg_from(MIN_AS_U32)) == MIN_AS_U32, 0); - assert!(as_u32(div(neg_from(MIN_AS_U32), from(1))) == MIN_AS_U32, 0); - } - - #[test] - #[expected_failure] - fun test_div_overflow() { - div(neg_from(MIN_AS_U32), neg_from(1)); - } - - #[test] - fun test_shl() { - assert!(as_u32(shl(from(10), 0)) == 10, 0); - assert!(as_u32(shl(neg_from(10), 0)) == as_u32(neg_from(10)), 0); - - assert!(as_u32(shl(from(10), 1)) == 20, 0); - assert!(as_u32(shl(neg_from(10), 1)) == as_u32(neg_from(20)), 0); - - assert!(as_u32(shl(from(10), 8)) == 2560, 0); - assert!(as_u32(shl(neg_from(10), 8)) == as_u32(neg_from(2560)), 0); - - assert!(as_u32(shl(from(10), 31)) == 0, 0); - assert!(as_u32(shl(neg_from(10), 31)) == 0, 0); - } - - #[test] - fun test_shr() { - assert!(as_u32(shr(from(10), 0)) == 10, 0); - assert!(as_u32(shr(neg_from(10), 0)) == as_u32(neg_from(10)), 0); - - assert!(as_u32(shr(from(10), 1)) == 5, 0); - assert!(as_u32(shr(neg_from(10), 1)) == as_u32(neg_from(5)), 0); - - assert!(as_u32(shr(from(MAX_AS_U32), 8)) == MAX_AS_U32 >> 8, 0); - assert!(as_u32(shr(neg_from(MIN_AS_U32), 8)) == 0xff800000, 0); - } - - #[test] - fun test_sign() { - assert!(sign(neg_from(10)) == 1u8, 0); - assert!(sign(from(10)) == 0u8, 0); - } - - #[test] - fun test_cmp() { - assert!(cmp(from(1), from(0)) == GT, 0); - assert!(cmp(from(0), from(1)) == LT, 0); - - assert!(cmp(from(0), neg_from(1)) == GT, 0); - assert!(cmp(neg_from(0), neg_from(1)) == GT, 0); - assert!(cmp(neg_from(1), neg_from(0)) == LT, 0); - - assert!(cmp(neg_from(MIN_AS_U32), from(MAX_AS_U32)) == LT, 0); - assert!(cmp(from(MAX_AS_U32), neg_from(MIN_AS_U32)) == GT, 0); - - assert!(cmp(from(MAX_AS_U32), from(MAX_AS_U32 - 1)) == GT, 0); - assert!(cmp(from(MAX_AS_U32 - 1), from(MAX_AS_U32)) == LT, 0); - - assert!(cmp(neg_from(MIN_AS_U32), neg_from(MIN_AS_U32 - 1)) == LT, 0); - assert!(cmp(neg_from(MIN_AS_U32 - 1), neg_from(MIN_AS_U32)) == GT, 0); - } - - #[test] - fun test_castdown() { - assert!((1u32 as u8) == 1u8, 0); - } - - #[test] - fun test_mod() { - //use aptos_std::debug; - let i = mod(neg_from(2), from(5)); - assert!(cmp(i, neg_from(2)) == EQ, 0); - - i = mod(neg_from(2), neg_from(5)); - assert!(cmp(i, neg_from(2)) == EQ, 0); - - i = mod(from(2), from(5)); - assert!(cmp(i, from(2)) == EQ, 0); - - i = mod(from(2), neg_from(5)); - assert!(cmp(i, from(2)) == EQ, 0); - } -} - diff --git a/aptos/sources/i64.move b/aptos/sources/i64.move deleted file mode 100644 index 995afbf..0000000 --- a/aptos/sources/i64.move +++ /dev/null @@ -1,492 +0,0 @@ -module integer_mate::i64 { - use std::error; - - const OVERFLOW: u64 = 0; - - const MIN_AS_U64: u64 = 1 << 63; - const MAX_AS_U64: u64 = 0x7fffffffffffffff; - - const LT: u8 = 0; - const EQ: u8 = 1; - const GT: u8 = 2; - - struct I64 has copy, drop, store { - bits: u64 - } - - public fun zero(): I64 { - I64 { - bits: 0 - } - } - - public fun from_u64(v: u64): I64 { - I64 { - bits: v - } - } - - public fun from(v: u64): I64 { - assert!(v <= MAX_AS_U64, error::invalid_argument(OVERFLOW)); - I64 { - bits: v - } - } - - public fun neg_from(v: u64): I64 { - assert!(v <= MIN_AS_U64, error::invalid_argument(OVERFLOW)); - if (v == 0) { - I64 { - bits: v - } - } else { - I64 { - bits: (u64_neg(v) + 1) | (1 << 63) - } - } - } - - public fun wrapping_add(num1: I64, num2: I64): I64 { - let sum = num1.bits ^ num2.bits; - let carry = (num1.bits & num2.bits) << 1; - while (carry != 0) { - let a = sum; - let b = carry; - sum = a ^ b; - carry = (a & b) << 1; - }; - I64 { - bits: sum - } - } - - public fun add(num1: I64, num2: I64): I64 { - let sum = wrapping_add(num1, num2); - let overflow = (sign(num1) & sign(num2) & u8_neg(sign(sum))) + (u8_neg(sign(num1)) & u8_neg(sign(num2)) & sign( - sum - )); - assert!(overflow == 0, error::invalid_argument(OVERFLOW)); - sum - } - - public fun wrapping_sub(num1: I64, num2: I64): I64 { - let sub_num = wrapping_add(I64 { - bits: u64_neg(num2.bits) - }, from(1)); - wrapping_add(num1, sub_num) - } - - public fun sub(num1: I64, num2: I64): I64 { - let v = wrapping_sub(num1, num2); - let overflow = sign(num1) != sign(num2) && sign(num1) != sign(v); - assert!(!overflow, EOverflow); - v - } - - public fun mul(num1: I64, num2: I64): I64 { - let product = abs_u64(num1) * abs_u64(num2); - if (sign(num1) != sign(num2)) { - return neg_from(product) - }; - return from(product) - } - - public fun div(num1: I64, num2: I64): I64 { - let result = abs_u64(num1) / abs_u64(num2); - if (sign(num1) != sign(num2)) { - return neg_from(result) - }; - return from(result) - } - - public fun abs(v: I64): I64 { - if (sign(v) == 0) { - v - } else { - assert!(v.bits > MIN_AS_U64, error::invalid_argument(OVERFLOW)); - I64 { - bits: u64_neg(v.bits - 1) - } - } - } - - public fun abs_u64(v: I64): u64 { - if (sign(v) == 0) { - v.bits - } else { - u64_neg(v.bits - 1) - } - } - - public fun shl(v: I64, shift: u8): I64 { - I64 { - bits: v.bits << shift - } - } - - public fun shr(v: I64, shift: u8): I64 { - if (shift == 0) { - return v - }; - let mask = 0xffffffffffffffff << (64 - shift); - if (sign(v) == 1) { - return I64 { - bits: (v.bits >> shift) | mask - } - }; - I64 { - bits: v.bits >> shift - } - } - - public fun mod(v: I64, n: I64): I64 { - if (sign(v) == 1) { - neg_from((abs_u64(v) % abs_u64(n))) - } else { - from((as_u64(v) % abs_u64(n))) - } - } - - public fun as_u64(v: I64): u64 { - v.bits - } - - public fun sign(v: I64): u8 { - ((v.bits >> 63) as u8) - } - - public fun is_neg(v: I64): bool { - sign(v) == 1 - } - - public fun cmp(num1: I64, num2: I64): u8 { - if (num1.bits == num2.bits) return EQ; - if (sign(num1) > sign(num2)) return LT; - if (sign(num1) < sign(num2)) return GT; - if (num1.bits > num2.bits) { - return GT - } else { - return LT - } - } - - public fun eq(num1: I64, num2: I64): bool { - num1.bits == num2.bits - } - - public fun gt(num1: I64, num2: I64): bool { - cmp(num1, num2) == GT - } - - public fun gte(num1: I64, num2: I64): bool { - cmp(num1, num2) >= EQ - } - - public fun lt(num1: I64, num2: I64): bool { - cmp(num1, num2) == LT - } - - public fun lte(num1: I64, num2: I64): bool { - cmp(num1, num2) <= EQ - } - - public fun or(num1: I64, num2: I64): I64 { - I64 { - bits: (num1.bits | num2.bits) - } - } - - public fun and(num1: I64, num2: I64): I64 { - I64 { - bits: (num1.bits & num2.bits) - } - } - - fun u64_neg(v: u64): u64 { - v ^ 0xffffffffffffffff - } - - fun u8_neg(v: u8): u8 { - v ^ 0xff - } - - #[test] - fun test_from_ok() { - assert!(as_u64(from(0)) == 0, 0); - assert!(as_u64(from(10)) == 10, 1); - } - - #[test] - #[expected_failure] - fun test_from_overflow() { - as_u64(from(MIN_AS_U64)); - as_u64(from(0xffffffffffffffff)); - } - - #[test] - fun test_neg_from() { - assert!(as_u64(neg_from(0)) == 0, 0); - assert!(as_u64(neg_from(1)) == 0xffffffffffffffff, 1); - assert!(as_u64(neg_from(0x7fffffffffffffff)) == 0x8000000000000001, 2); - assert!(as_u64(neg_from(MIN_AS_U64)) == MIN_AS_U64, 2); - } - - #[test] - #[expected_failure] - fun test_neg_from_overflow() { - neg_from(0x8000000000000001); - } - - #[test] - fun test_abs() { - assert!(as_u64(from(10)) == 10u64, 0); - assert!(as_u64(abs(neg_from(10))) == 10u64, 1); - assert!(as_u64(abs(neg_from(0))) == 0u64, 2); - assert!(as_u64(abs(neg_from(0x7fffffffffffffff))) == 0x7fffffffffffffff, 3); - assert!(as_u64(neg_from(MIN_AS_U64)) == MIN_AS_U64, 4); - } - - #[test] - #[expected_failure] - fun test_abs_overflow() { - abs(neg_from(1 << 63)); - } - - #[test] - fun test_wrapping_add() { - assert!(as_u64(wrapping_add(from(0), from(1))) == 1, 0); - assert!(as_u64(wrapping_add(from(1), from(0))) == 1, 0); - assert!(as_u64(wrapping_add(from(10000), from(99999))) == 109999, 0); - assert!(as_u64(wrapping_add(from(99999), from(10000))) == 109999, 0); - assert!(as_u64(wrapping_add(from(MAX_AS_U64 - 1), from(1))) == MAX_AS_U64, 0); - assert!(as_u64(wrapping_add(from(0), from(0))) == 0, 0); - - assert!(as_u64(wrapping_add(neg_from(0), neg_from(0))) == 0, 1); - assert!(as_u64(wrapping_add(neg_from(1), neg_from(0))) == 0xffffffffffffffff, 1); - assert!(as_u64(wrapping_add(neg_from(0), neg_from(1))) == 0xffffffffffffffff, 1); - assert!(as_u64(wrapping_add(neg_from(10000), neg_from(99999))) == 0xfffffffffffe5251, 1); - assert!(as_u64(wrapping_add(neg_from(99999), neg_from(10000))) == 0xfffffffffffe5251, 1); - assert!(as_u64(wrapping_add(neg_from(MIN_AS_U64 - 1), neg_from(1))) == MIN_AS_U64, 1); - - assert!(as_u64(wrapping_add(from(0), neg_from(0))) == 0, 2); - assert!(as_u64(wrapping_add(neg_from(0), from(0))) == 0, 2); - assert!(as_u64(wrapping_add(neg_from(1), from(1))) == 0, 2); - assert!(as_u64(wrapping_add(from(1), neg_from(1))) == 0, 2); - assert!(as_u64(wrapping_add(from(10000), neg_from(99999))) == 0xfffffffffffea071, 2); - assert!(as_u64(wrapping_add(from(99999), neg_from(10000))) == 89999, 2); - assert!(as_u64(wrapping_add(neg_from(MIN_AS_U64), from(1))) == 0x8000000000000001, 2); - assert!(as_u64(wrapping_add(from(MAX_AS_U64), neg_from(1))) == MAX_AS_U64 - 1, 2); - - assert!(as_u64(wrapping_add(from(MAX_AS_U64), from(1))) == MIN_AS_U64, 2); - } - - #[test] - fun test_add() { - assert!(as_u64(add(from(0), from(0))) == 0, 0); - assert!(as_u64(add(from(0), from(1))) == 1, 0); - assert!(as_u64(add(from(1), from(0))) == 1, 0); - assert!(as_u64(add(from(10000), from(99999))) == 109999, 0); - assert!(as_u64(add(from(99999), from(10000))) == 109999, 0); - assert!(as_u64(add(from(MAX_AS_U64 - 1), from(1))) == MAX_AS_U64, 0); - - assert!(as_u64(add(neg_from(0), neg_from(0))) == 0, 1); - assert!(as_u64(add(neg_from(1), neg_from(0))) == 0xffffffffffffffff, 1); - assert!(as_u64(add(neg_from(0), neg_from(1))) == 0xffffffffffffffff, 1); - assert!(as_u64(add(neg_from(10000), neg_from(99999))) == 0xfffffffffffe5251, 1); - assert!(as_u64(add(neg_from(99999), neg_from(10000))) == 0xfffffffffffe5251, 1); - assert!(as_u64(add(neg_from(MIN_AS_U64 - 1), neg_from(1))) == MIN_AS_U64, 1); - - assert!(as_u64(add(from(0), neg_from(0))) == 0, 2); - assert!(as_u64(add(neg_from(0), from(0))) == 0, 2); - assert!(as_u64(add(neg_from(1), from(1))) == 0, 2); - assert!(as_u64(add(from(1), neg_from(1))) == 0, 2); - assert!(as_u64(add(from(10000), neg_from(99999))) == 0xfffffffffffea071, 2); - assert!(as_u64(add(from(99999), neg_from(10000))) == 89999, 2); - assert!(as_u64(add(neg_from(MIN_AS_U64), from(1))) == 0x8000000000000001, 2); - assert!(as_u64(add(from(MAX_AS_U64), neg_from(1))) == MAX_AS_U64 - 1, 2); - } - - #[test] - #[expected_failure] - fun test_add_overflow() { - add(from(MAX_AS_U64), from(1)); - } - - #[test] - #[expected_failure] - fun test_add_underflow() { - add(neg_from(MIN_AS_U64), neg_from(1)); - } - - #[test] - fun test_wrapping_sub() { - assert!(as_u64(wrapping_sub(from(0), from(0))) == 0, 0); - assert!(as_u64(wrapping_sub(from(1), from(0))) == 1, 0); - assert!(as_u64(wrapping_sub(from(0), from(1))) == as_u64(neg_from(1)), 0); - assert!(as_u64(wrapping_sub(from(1), from(1))) == as_u64(neg_from(0)), 0); - assert!(as_u64(wrapping_sub(from(1), neg_from(1))) == as_u64(from(2)), 0); - assert!(as_u64(wrapping_sub(neg_from(1), from(1))) == as_u64(neg_from(2)), 0); - assert!(as_u64(wrapping_sub(from(1000000), from(1))) == 999999, 0); - assert!(as_u64(wrapping_sub(neg_from(1000000), neg_from(1))) == as_u64(neg_from(999999)), 0); - assert!(as_u64(wrapping_sub(from(1), from(1000000))) == as_u64(neg_from(999999)), 0); - assert!(as_u64(wrapping_sub(from(MAX_AS_U64), from(MAX_AS_U64))) == as_u64(from(0)), 0); - assert!(as_u64(wrapping_sub(from(MAX_AS_U64), from(1))) == as_u64(from(MAX_AS_U64 - 1)), 0); - assert!(as_u64(wrapping_sub(from(MAX_AS_U64), neg_from(1))) == as_u64(neg_from(MIN_AS_U64)), 0); - assert!(as_u64(wrapping_sub(neg_from(MIN_AS_U64), neg_from(1))) == as_u64(neg_from(MIN_AS_U64 - 1)), 0); - assert!(as_u64(wrapping_sub(neg_from(MIN_AS_U64), from(1))) == as_u64(from(MAX_AS_U64)), 0); - } - - #[test] - fun test_sub() { - assert!(as_u64(sub(from(0), from(0))) == 0, 0); - assert!(as_u64(sub(from(1), from(0))) == 1, 0); - assert!(as_u64(sub(from(0), from(1))) == as_u64(neg_from(1)), 0); - assert!(as_u64(sub(from(1), from(1))) == as_u64(neg_from(0)), 0); - assert!(as_u64(sub(from(1), neg_from(1))) == as_u64(from(2)), 0); - assert!(as_u64(sub(neg_from(1), from(1))) == as_u64(neg_from(2)), 0); - assert!(as_u64(sub(from(1000000), from(1))) == 999999, 0); - assert!(as_u64(sub(neg_from(1000000), neg_from(1))) == as_u64(neg_from(999999)), 0); - assert!(as_u64(sub(from(1), from(1000000))) == as_u64(neg_from(999999)), 0); - assert!(as_u64(sub(from(MAX_AS_U64), from(MAX_AS_U64))) == as_u64(from(0)), 0); - assert!(as_u64(sub(from(MAX_AS_U64), from(1))) == as_u64(from(MAX_AS_U64 - 1)), 0); - assert!(as_u64(sub(neg_from(MIN_AS_U64), neg_from(1))) == as_u64(neg_from(MIN_AS_U64 - 1)), 0); - } - - #[test] - #[expected_failure] - fun test_sub_overflow() { - sub(from(MAX_AS_U64), neg_from(1)); - } - - #[test] - #[expected_failure] - fun test_sub_underflow() { - sub(neg_from(MIN_AS_U64), from(1)); - } - - #[test] - fun test_mul() { - assert!(as_u64(mul(from(1), from(1))) == 1, 0); - assert!(as_u64(mul(from(10), from(10))) == 100, 0); - assert!(as_u64(mul(from(100), from(100))) == 10000, 0); - assert!(as_u64(mul(from(10000), from(10000))) == 100000000, 0); - - assert!(as_u64(mul(neg_from(1), from(1))) == as_u64(neg_from(1)), 0); - assert!(as_u64(mul(neg_from(10), from(10))) == as_u64(neg_from(100)), 0); - assert!(as_u64(mul(neg_from(100), from(100))) == as_u64(neg_from(10000)), 0); - assert!(as_u64(mul(neg_from(10000), from(10000))) == as_u64(neg_from(100000000)), 0); - - assert!(as_u64(mul(from(1), neg_from(1))) == as_u64(neg_from(1)), 0); - assert!(as_u64(mul(from(10), neg_from(10))) == as_u64(neg_from(100)), 0); - assert!(as_u64(mul(from(100), neg_from(100))) == as_u64(neg_from(10000)), 0); - assert!(as_u64(mul(from(10000), neg_from(10000))) == as_u64(neg_from(100000000)), 0); - assert!(as_u64(mul(from(MIN_AS_U64 / 2), neg_from(2))) == as_u64(neg_from(MIN_AS_U64)), 0); - } - - #[test] - #[expected_failure] - fun test_mul_overflow() { - mul(from(MIN_AS_U64 / 2), from(1)); - mul(neg_from(MIN_AS_U64 / 2), neg_from(2)); - } - - #[test] - fun test_div() { - assert!(as_u64(div(from(0), from(1))) == 0, 0); - assert!(as_u64(div(from(10), from(1))) == 10, 0); - assert!(as_u64(div(from(10), neg_from(1))) == as_u64(neg_from(10)), 0); - assert!(as_u64(div(neg_from(10), neg_from(1))) == as_u64(from(10)), 0); - - assert!(abs_u64(neg_from(MIN_AS_U64)) == MIN_AS_U64, 0); - assert!(as_u64(div(neg_from(MIN_AS_U64), from(1))) == MIN_AS_U64, 0); - } - - #[test] - #[expected_failure] - fun test_div_overflow() { - div(neg_from(MIN_AS_U64), neg_from(1)); - } - - #[test] - fun test_shl() { - assert!(as_u64(shl(from(10), 0)) == 10, 0); - assert!(as_u64(shl(neg_from(10), 0)) == as_u64(neg_from(10)), 0); - - assert!(as_u64(shl(from(10), 1)) == 20, 0); - assert!(as_u64(shl(neg_from(10), 1)) == as_u64(neg_from(20)), 0); - - assert!(as_u64(shl(from(10), 8)) == 2560, 0); - assert!(as_u64(shl(neg_from(10), 8)) == as_u64(neg_from(2560)), 0); - - assert!(as_u64(shl(from(10), 32)) == 42949672960, 0); - assert!(as_u64(shl(neg_from(10), 32)) == as_u64(neg_from(42949672960)), 0); - - assert!(as_u64(shl(from(10), 63)) == 0, 0); - assert!(as_u64(shl(neg_from(10), 63)) == 0, 0); - } - - #[test] - fun test_shr() { - assert!(as_u64(shr(from(10), 0)) == 10, 0); - assert!(as_u64(shr(neg_from(10), 0)) == as_u64(neg_from(10)), 0); - - assert!(as_u64(shr(from(10), 1)) == 5, 0); - assert!(as_u64(shr(neg_from(10), 1)) == as_u64(neg_from(5)), 0); - - assert!(as_u64(shr(from(MAX_AS_U64), 8)) == 36028797018963967, 0); - assert!(as_u64(shr(neg_from(MIN_AS_U64), 8)) == 0xff80000000000000, 0); - - assert!(as_u64(shr(from(MAX_AS_U64), 32)) == 2147483647, 0); - assert!(as_u64(shr(neg_from(MIN_AS_U64), 32)) == 0xffffffff80000000, 0); - - assert!(as_u64(shr(from(MAX_AS_U64), 63)) == 0, 0); - assert!(as_u64(shr(neg_from(MIN_AS_U64), 63)) == 0xffffffffffffffff, 0); - } - - #[test] - fun test_sign() { - assert!(sign(neg_from(10)) == 1u8, 0); - assert!(sign(from(10)) == 0u8, 0); - } - - #[test] - fun test_cmp() { - assert!(cmp(from(1), from(0)) == GT, 0); - assert!(cmp(from(0), from(1)) == LT, 0); - - assert!(cmp(from(0), neg_from(1)) == GT, 0); - assert!(cmp(neg_from(0), neg_from(1)) == GT, 0); - assert!(cmp(neg_from(1), neg_from(0)) == LT, 0); - - assert!(cmp(neg_from(MIN_AS_U64), from(MAX_AS_U64)) == LT, 0); - assert!(cmp(from(MAX_AS_U64), neg_from(MIN_AS_U64)) == GT, 0); - - assert!(cmp(from(MAX_AS_U64), from(MAX_AS_U64 - 1)) == GT, 0); - assert!(cmp(from(MAX_AS_U64 - 1), from(MAX_AS_U64)) == LT, 0); - - assert!(cmp(neg_from(MIN_AS_U64), neg_from(MIN_AS_U64 - 1)) == LT, 0); - assert!(cmp(neg_from(MIN_AS_U64 - 1), neg_from(MIN_AS_U64)) == GT, 0); - } - - #[test] - fun test_castdown() { - assert!((1u64 as u8) == 1u8, 0); - } - - #[test] - fun test_mod() { - //use aptos_std::debug; - let i = mod(neg_from(2), from(5)); - assert!(cmp(i, neg_from(2)) == EQ, 0); - - i = mod(neg_from(2), neg_from(5)); - assert!(cmp(i, neg_from(2)) == EQ, 0); - - i = mod(from(2), from(5)); - assert!(cmp(i, from(2)) == EQ, 0); - - i = mod(from(2), neg_from(5)); - assert!(cmp(i, from(2)) == EQ, 0); - } -} - diff --git a/aptos/sources/math_u128.move b/aptos/sources/math_u128.move deleted file mode 100644 index b1855cc..0000000 --- a/aptos/sources/math_u128.move +++ /dev/null @@ -1,173 +0,0 @@ -module integer_mate::math_u128 { - - const MAX_U128: u128 = 0xffffffffffffffffffffffffffffffff; - - const HI_64_MASK: u128 = 0xffffffffffffffff0000000000000000; - const LO_64_MASK: u128 = 0x0000000000000000ffffffffffffffff; - const LO_128_MASK: u256 = 0x00000000000000000000000000000000ffffffffffffffffffffffffffffffff; - - const DIV_BY_ZERO: u64 = 1; - - public fun wrapping_add(n1: u128, n2: u128): u128 { - let (sum, _) = overflowing_add(n1, n2); - sum - } - - public fun overflowing_add(n1: u128, n2: u128): (u128, bool) { - let sum = (n1 as u256) + (n2 as u256); - if (sum > (MAX_U128 as u256)) { - (((sum & LO_128_MASK) as u128), true) - } else { - ((sum as u128), false) - } - } - - public fun wrapping_sub(n1: u128, n2: u128): u128 { - let (result, _) = overflowing_sub(n1, n2); - result - } - - public fun overflowing_sub(n1: u128, n2: u128): (u128, bool) { - if (n1 >= n2) { - ((n1 - n2), false) - } else { - ((MAX_U128 - n2 + n1 + 1), true) - } - } - - public fun wrapping_mul(n1: u128, n2: u128): u128 { - let (m, _) = overflowing_mul(n1, n2); - m - } - - public fun overflowing_mul(n1: u128, n2: u128): (u128, bool) { - let (c0, c1) = full_mul(n1, n2); - if (c1 > 0) { - (c0, true) - } else { - (c0, false) - } - } - - public fun full_mul(n1: u128, n2: u128): (u128, u128) { - let hi_mask: u256 = 0xffffffffffffffffffffffffffffffff00000000000000000000000000000000; - let lo_mask: u256 = 0x00000000000000000000000000000000ffffffffffffffffffffffffffffffff; - let r = (n1 as u256) * (n2 as u256); - let hi = (((r & hi_mask) >> 128) as u128); - let lo = ((r & lo_mask) as u128); - (lo, hi) - } - - public fun hi(n: u128): u64 { - (((n & HI_64_MASK) >> 64) as u64) - } - - public fun lo(n: u128): u64 { - ((n & LO_64_MASK) as u64) - } - - public fun hi_u128(n: u128): u128 { - (n & HI_64_MASK) >> 64 - } - - public fun lo_u128(n: u128): u128 { - (n & LO_64_MASK) - } - - public fun from_lo_hi(lo: u64, hi: u64): u128 { - ((hi as u128) << 64) + (lo as u128) - } - - public fun checked_div_round(num: u128, denom: u128, round_up: bool): u128 { - if (denom == 0) { - abort DIV_BY_ZERO - }; - let quotient = num / denom; - let remainer = num % denom; - if (round_up && (remainer > 0)) { - return (quotient + 1) - }; - quotient - } - - public fun max(num1: u128, num2: u128): u128 { - if (num1 > num2) { - num1 - } else { - num2 - } - } - - public fun min(num1: u128, num2: u128): u128 { - if (num1 < num2) { - num1 - } else { - num2 - } - } - - public fun add_check(num1: u128, num2: u128): bool { - (MAX_U128 - num1 >= num2) - } - - #[test] - fun test_overflowing_add() { - let (m, o) = overflowing_add(10, 10); - assert!(m == 20u128 && o == false, 0); - - let (m, o) = overflowing_add(MAX_U128, 10); - assert!(m == 9u128 && o == true, 0); - } - - #[test] - fun test_full_mul() { - let (lo, hi) = full_mul(0, 10); - assert!(hi == 0 && lo == 0, 0); - - let (lo, hi) = full_mul(10, 10); - assert!(hi == 0 && lo == 100, 0); - - let (lo, hi) = full_mul(9999, 10); - assert!(hi == 0 && lo == 99990, 0); - - let (lo, hi) = full_mul(MAX_U128, 0); - assert!(hi == 0 && lo == 0, 0); - - let (lo, hi) = full_mul(MAX_U128, 1); - assert!(hi == 0 && lo == MAX_U128, 0); - - let (lo, hi) = full_mul(MAX_U128, 10); - assert!(hi == 9 && lo == 0xfffffffffffffffffffffffffffffff6, 0); - - let (lo, hi) = full_mul(10, MAX_U128); - assert!(hi == 9 && lo == 0xfffffffffffffffffffffffffffffff6, 0); - - let (lo, hi) = full_mul(MAX_U128, MAX_U128); - assert!(hi == 0xfffffffffffffffffffffffffffffffe && lo == 1, 0); - } - - #[test] - fun test_wrapping_mul() { - assert!(wrapping_mul(0, 10) == 0, 0); - assert!(wrapping_mul(10, 0) == 0, 0); - assert!(wrapping_mul(10, 10) == 100, 0); - assert!(wrapping_mul(99999, 10) == 10 * 99999, 0); - assert!(wrapping_mul(MAX_U128, 0) == 0, 0); - assert!(wrapping_mul(MAX_U128, 1) == MAX_U128, 0); - assert!(wrapping_mul(MAX_U128, 10) == 0xfffffffffffffffffffffffffffffff6, 0); - assert!(wrapping_mul(10, MAX_U128) == 0xfffffffffffffffffffffffffffffff6, 0); - assert!(wrapping_mul(MAX_U128, MAX_U128) == 1, 0); - } - - #[test] - fun test_overflowing_mul() { - let (r, o) = overflowing_mul(0, 10); - assert!(r == 0 && o == false, 0); - - let (r, o) = overflowing_mul(10, 10); - assert!(r == 100 && o == false, 0); - - let (r, o) = overflowing_mul(MAX_U128, 10); - assert!(r == 0xfffffffffffffffffffffffffffffff6 && o == true, 0); - } -} diff --git a/aptos/sources/math_u256.move b/aptos/sources/math_u256.move deleted file mode 100644 index 2775033..0000000 --- a/aptos/sources/math_u256.move +++ /dev/null @@ -1,49 +0,0 @@ -module integer_mate::math_u256 { - const MAX_U256: u256 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; - - public fun div_mod(num: u256, denom: u256): (u256, u256) { - let p = num / denom; - let r: u256 = num - (p * denom); - (p, r) - } - - public fun shlw(n: u256): u256 { - n << 64 - } - - public fun shrw(n: u256): u256 { - n >> 64 - } - - public fun checked_shlw(n: u256): (u256, bool) { - let mask = 1 << 192; - if (n >= mask) { - (0, true) - } else { - ((n << 64), false) - } - } - - public fun div_round(num: u256, denom: u256, round_up: bool): u256 { - let p = num / denom; - if (round_up && ((p * denom) != num)) { - p + 1 - } else { - p - } - } - - public fun add_check(num1: u256, num2: u256): bool { - (MAX_U256 - num1 >= num2) - } - - #[test] - fun test_div_round() { - div_round(1, 1, true); - } - - #[test] - fun test_add() { - 1000u256 + 1000u256; - } -} diff --git a/aptos/sources/u256.move b/aptos/sources/u256.move deleted file mode 100644 index 0d6b889..0000000 --- a/aptos/sources/u256.move +++ /dev/null @@ -1,596 +0,0 @@ -module integer_mate::u256 { - use std::error; - use integer_mate::math_u64; - use integer_mate::math_u128; - - const OVERFLOW: u64 = 0; - const DIV_BY_ZERO: u64 = 1; - - const LT: u8 = 0; - const EQ: u8 = 1; - const GT: u8 = 2; - - const HI_64_MASK: u128 = 0xffffffffffffffff0000000000000000; - const LO_64_MASK: u128 = 0x0000000000000000ffffffffffffffff; - - const MAX_U128: u128 = 0xffffffffffffffffffffffffffffffff; - const MAX_U64: u64 = 0xffffffffffffffff; - - /// Total words in `U256` (64 * 4 = 256). - const WORDS: u8 = 4; - - struct U256 has copy, drop, store { - n0: u64, - n1: u64, - n2: u64, - n3: u64 - } - - public fun zero(): U256 { - U256 { - n0: 0, - n1: 0, - n2: 0, - n3: 0 - } - } - - public fun from(n: u128): U256 { - U256 { - n0: ((n & LO_64_MASK) as u64), - n1: ((n >> 64) as u64), - n2: 0u64, - n3: 0u64, - } - } - - public fun new(n0: u64, n1: u64, n2: u64, n3: u64): U256 { - U256 { - n0, - n1, - n2, - n3 - } - } - - public fun add(a: U256, b: U256): U256 { - let (sum0, carry0) = math_u64::carry_add(a.n0, b.n0, 0); - let (sum1, carry1) = math_u64::carry_add(a.n1, b.n1, carry0); - let (sum2, carry2) = math_u64::carry_add(a.n2, b.n2, carry1); - let (sum3, carry3) = math_u64::carry_add(a.n3, b.n3, carry2); - assert!(carry3 == 0, error::invalid_argument(OVERFLOW)); - U256 { - n0: sum0, - n1: sum1, - n2: sum2, - n3: sum3, - } - } - - public fun sub(a: U256, b: U256): U256 { - let (r0, overflow_s0) = math_u64::overflowing_sub(a.n0, b.n0); - let carry0 = if (overflow_s0) { 1 } else { 0 }; - let (t1, overflow_t1) = math_u64::overflowing_sub(a.n1, b.n1); - let (r1, overflow_s1) = math_u64::overflowing_sub(t1, carry0); - let carry1 = if (overflow_t1 || overflow_s1) { 1 } else { 0 }; - let (t2, overflow_t2) = math_u64::overflowing_sub(a.n2, b.n2); - let (r2, overflow_s2) = math_u64::overflowing_sub(t2, carry1); - let carry2 = if (overflow_t2 || overflow_s2) { 1 } else { 0 }; - let (t3, overflow_t3) = math_u64::overflowing_sub(a.n3, b.n3); - let (r3, overflow_s3) = math_u64::overflowing_sub(t3, carry2); - let carry3 = if (overflow_t3 || overflow_s3) { 1 } else { 0 }; - assert!(carry3 == 0, error::invalid_argument(OVERFLOW)); - U256 { - n0: r0, - n1: r1, - n2: r2, - n3: r3 - } - } - - // It will does not triger overflow - public fun mul(a: U256, b: U256): U256 { - let result = zero(); - let m = num_words(a); - let n = num_words(b); - let j = 0u8; - while (j < n) { - let k = 0u128; - let i = 0u8; - while (i < m) { - let x = (get(&a, i) as u128); - let y = (get(&b, j) as u128); - if ((i + j) < 4) { - let z = (get(&result, i+j) as u128); - let t = math_u128::wrapping_add(math_u128::wrapping_add(math_u128::wrapping_mul(x, y), z), k); - set(&mut result, (i + j), math_u128::lo(t)); - k = math_u128::hi_u128(t); - }; - i = i + 1; - }; - if ((j + m) < 4) { - set(&mut result, (j + m), (k as u64)); - }; - j = j + 1; - }; - result - } - - public fun div_mod(a: U256, b: U256): (U256, U256) { - let ret = zero(); - let remainer = a; - - let a_bits = bits(&a); - let b_bits = bits(&b); - - assert!(b_bits != 0, DIV_BY_ZERO); // DIVIDE BY ZERO. - if (a_bits < b_bits) { - // Immidiatelly return. - return (ret, remainer) - }; - - let shift = a_bits - b_bits; - b = shl(b, (shift as u8)); - - loop { - if (gte(a, b)) { - let index = shift / 64; - let m = get(&ret, (index as u8)); - let c = m | 1 << ((shift % 64) as u8); - set(&mut ret, (index as u8), c); - - a = sub(a, b); - }; - - b = shr(b, 1); - if (shift == 0) { - remainer = a; - break - }; - - shift = shift - 1; - }; - - (ret, remainer) - } - - public fun div(a: U256, b: U256): U256 { - let (q, _) = div_mod(a, b); - q - } - - public fun as_u128(n: U256): u128 { - assert!(n.n3 == 0 && n.n2 == 0, error::invalid_argument(OVERFLOW)); - math_u128::from_lo_hi(n.n0, n.n1) - } - - public fun as_u64(n: U256): u64 { - assert!(n.n3 == 0 && n.n2 == 0 && n.n1 == 0, error::invalid_argument(OVERFLOW)); - n.n0 - } - - public fun checked_as_u128(n: U256): (u128, bool) { - if ((n.n3 != 0) || (n.n2 != 0)) { - return (0, true) - }; - (math_u128::from_lo_hi(n.n0, n.n1), false) - } - - public fun checked_as_u64(n: U256): (u64, bool) { - if (n.n3 != 0 || n.n2 != 0 || n.n1 != 0) { - return (0, true) - }; - (n.n0, false) - } - - // Shift left 64bit, does not triger overflow - public fun shlw(n: U256): U256 { - U256 { - n0: 0, - n1: n.n0, - n2: n.n1, - n3: n.n2 - } - } - - // Shift right 64bit, does not triger overflow - public fun shrw(n: U256): U256 { - U256 { - n0: n.n1, - n1: n.n2, - n2: n.n3, - n3: 0 - } - } - - public fun checked_shlw(n: U256): (U256, bool) { - if (n.n3 > 0) { - return (zero(), true) - }; - (shlw(n), false) - } - - public fun shl(n: U256, shift: u8): U256 { - let result = n; - let num = shift; - - while (num >= 64) { - result = shlw(result); - num = num - 64; - }; - if (num == 0) { - return result - }; - - result.n3 = result.n3 << num | (result.n2 >> (64 - num)); - result.n2 = result.n2 << num | (result.n1 >> (64 - num)); - result.n1 = result.n1 << num | (result.n0 >> (64 - num)); - result.n0 = result.n0 << num; - - result - } - - public fun shr(n: U256, shift: u8): U256 { - let result = n; - let num = shift; - - while (num >= 64) { - result = shrw(result); - num = num - 64; - }; - if (num == 0) { - return result - }; - - result.n0 = result.n0 >> num | (result.n1 << (64 - num)); - result.n1 = result.n1 >> num | (result.n2 << (64 - num)); - result.n2 = result.n2 >> num | (result.n3 << (64 - num)); - result.n3 = result.n3 >> num; - - result - } - - - public fun cmp(a: U256, b: U256): u8 { - let i = 4; - while (i > 0) { - i = i - 1; - let ai = get(&a, i); - let bi = get(&b, i); - if (ai != bi) { - if (ai < bi) { - return LT - } else { - return GT - } - } - }; - - EQ - } - - public fun eq(num1: U256, num2: U256): bool { - cmp(num1, num2) == EQ - } - - public fun gt(num1: U256, num2: U256): bool { - cmp(num1, num2) == GT - } - - public fun gte(num1: U256, num2: U256): bool { - cmp(num1, num2) >= EQ - } - - public fun lt(num1: U256, num2: U256): bool { - cmp(num1, num2) == LT - } - - public fun lte(num1: U256, num2: U256): bool { - cmp(num1, num2) <= EQ - } - - // TODO: Add test - public fun checked_div_round(num: U256, denom: U256, round_up: bool): U256 { - let (q, r) = div_mod(num, denom); - if (round_up && gt(r, zero())) { - return add(q, from(1)) - }; - q - } - - public fun lo_u128(num: U256): u128 { - (((num.n1 as u128) << 64) + (num.n0 as u128)) - } - - public fun hi_u128(num: U256): u128 { - (((num.n3 as u128) << 64) + (num.n2 as u128)) - } - - public fun get(a: &U256, i: u8): u64 { - if (i == 0) { - a.n0 - } else if (i == 1) { - a.n1 - } else if (i == 2) { - a.n2 - } else if (i == 3) { - a.n3 - } else { - abort OVERFLOW - } - } - - fun num_words(a: U256): u8 { - let n = 0; - if (a.n0 > 0) { - n = n + 1; - }; - if (a.n1 > 0) { - n = n + 1; - }; - if (a.n2 > 0) { - n = n + 1; - }; - if (a.n3 > 0) { - n = n + 1 - }; - n - } - - - fun set(a: &mut U256, i: u8, v: u64) { - if (i == 0) { - a.n0 = v; - } else if (i == 1) { - a.n1 = v; - } else if (i == 2) { - a.n2 = v; - } else if (i == 3) { - a.n3 = v; - } else { - abort OVERFLOW - } - } - - fun bits(a: &U256): u64 { - let i = 1; - while (i < WORDS) { - let a1 = get(a, WORDS - i); - if (a1 > 0) { - return (((0x40 as u64) * ((WORDS - i + 1) as u64)) - (leading_zeros_u64(a1) as u64)) - }; - - i = i + 1; - }; - - let a1 = get(a, 0); - 0x40 - (leading_zeros_u64(a1) as u64) - } - - fun leading_zeros_u64(a: u64): u8 { - if (a == 0) { - return 64 - }; - - let a1 = a & 0xFFFFFFFF; - let a2 = a >> 32; - - if (a2 == 0) { - let bit = 32; - - while (bit >= 1) { - let b = (a1 >> (bit-1)) & 1; - if (b != 0) { - break - }; - - bit = bit - 1; - }; - - (32 - bit) + 32 - } else { - let bit = 64; - while (bit >= 1) { - let b = (a >> (bit-1)) & 1; - if (b != 0) { - break - }; - bit = bit - 1; - }; - - 64 - bit - } - } - - #[test] - fun test_from() { - let v = from(0x80000000000000000000000000000010); - assert!(v.n0 == 0x10, 0); - assert!(v.n1 == 1 << 63, 0); - } - - #[test] - fun test_add() { - let s = add(new(10, 10, 10, 10), new(10, 10, 10, 10)); - assert!(s.n0 == 20 && s.n1 == 20 && s.n2 == 20 && s.n3 == 20, 0); - - let s = add(from(0xffffffffffffffffffffffffffffffff), from(0xffffffffffffffffffffffffffffffff)); - assert!(s.n0 == 18446744073709551614 && s.n1 == 18446744073709551615 && s.n2 == 1 && s.n3 == 0, 0); - - let max = MAX_U64; - let s = add(new(max, max, max, 10), new(max, max, max, 10)); - assert!(s.n0 == 18446744073709551614 && s.n1 == 18446744073709551615 && s.n2 == 18446744073709551615 && s.n3 == 21, 0); - } - - #[test] - #[expected_failure] - fun test_add_overflow() { - // TODO: Add more test - add(new(10, 100, 1000, MAX_U64), new(11, 101, 1001, 1)); - } - - #[test] - fun test_sub() { - // TODO: Add more test - let s = sub(new(10, 100, 1000, 10000), new(11, 101, 1001, 1000)); - assert!(s.n0 == 18446744073709551615 && s.n1 == 18446744073709551614 && s.n2 == 18446744073709551614 && s.n3 == 8999, 0); - } - - #[test] - #[expected_failure] - fun test_sub_overflow() { - // TODO: Add more test - sub(new(10, 100, 1000, 10000), new(11, 101, 1001, 10000)); - } - - #[test] - fun test_mul() { - let r = mul(from(10), from(10)); - assert!(r.n0 == 100 && r.n1 == 0 && r.n2 == 0 && r.n3 == 0, 0); - - let r = mul(from(0), from(10)); - assert!(r.n0 == 0 && r.n1 == 0 && r.n2 == 0 && r.n3 == 0, 0); - - let r = mul(from(10), from(0)); - assert!(r.n0 == 0 && r.n1 == 0 && r.n2 == 0 && r.n3 == 0, 0); - - let r = mul(from(999999), from(999999)); - assert!(r.n0 == 999998000001 && r.n1 == 0 && r.n2 == 0 && r.n3 == 0, 0); - - let r = mul(from(MAX_U128), from(2)); - assert!(r.n0 == 18446744073709551614 && r.n1 == 18446744073709551615 && r.n2 == 1 && r.n3 == 0, 0); - - let r = mul(from(2), from(MAX_U128)); - assert!(r.n0 == 18446744073709551614 && r.n1 == 18446744073709551615 && r.n2 == 1 && r.n3 == 0, 0); - - let r = mul(from(MAX_U128), from((MAX_U64 as u128))); - assert!(r.n0 == 1 && r.n1 == 18446744073709551615 && r.n2 == 18446744073709551614 && r.n3 == 0, 0); - - let r = mul(from(MAX_U128), from(MAX_U128)); - assert!(eq(r, new(1, 0, 18446744073709551614, 18446744073709551615)) == true, 0); - - mul(new(10, 10, 10, 10), new(10, 10, 10, 10)); - - // TODO: Add more test - } - - #[test] - fun test_div() { - // TODO: Add more test - let a = from(100); - let b = from(5); - let d = div(a, b); - assert!(as_u128(d) == 20, 0); - - let a = from((MAX_U64 as u128)); - let b = from(MAX_U128); - let d = div(a, b); - assert!(as_u128(d) == 0, 1); - - let a = from((MAX_U64 as u128)); - let b = from(MAX_U128); - let d = div(a, b); - assert!(as_u128(d) == 0, 2); - - let a = from(MAX_U128); - let b = from((MAX_U64 as u128)); - let d = div(a, b); - assert!(as_u128(d) == 18446744073709551617, 2); - - let m = new( - 10655214313433269453, - 15734150612341066489, - 14649800231932480840, - 7840575814708351719, - ); - let n = new( - 14649800231932480840, - 7840575814708351719, - 10655214313433269453, - 15734150612341066489, - ); - let (q, r) = div_mod(m, n); - assert!(eq(q, zero()) == true, 0); - assert!(eq(r, new(10655214313433269453, 15734150612341066489, 14649800231932480840, 7840575814708351719)) == true, 0); - - let m = new(12636451795089125100, 10304548827917701964, 2223071594322190165, 18320302927055064890); - let n = new(2223071594322190165, 14427030292705506480, 12636451795089125100, 427701964); - let (q, r) = div_mod(m, n); - assert!(eq(q, new(42834273488, 0, 0, 0)) == true, 0); - assert!(eq(r, new(15466148154527319516, 8118191964138314409, 1682799980586770877, 381853750)) == true, 0); - - } - - #[test] - fun test_shl() { - assert!(eq(shl(from(10), 2), from(10 << 2)) == true, 0); - assert!(eq(shl(from(10), 8), from(10 << 8)) == true, 0); - assert!(eq(shl(from(10), 16), from(10 << 16)) == true, 0); - assert!(eq(shl(from(10), 32), from(10 << 32)) == true, 0); - assert!(eq(shl(from(10), 64), from(10 << 64)) == true, 0); - assert!(eq(shl(from(10), 120), from(10 << 120)) == true, 0); - assert!(eq(shl(from(10), 128), new(0, 0, 10, 0)) == true, 0); - assert!(eq(shl(from(10), 190), new(0, 0, 9223372036854775808, 2)) == true, 0); - assert!(eq(shl(from(10), 192), new(0, 0, 0, 10)) == true, 0); - assert!(eq(shl(from(10), 196), new(0, 0, 0, 160)) == true, 0); - assert!(eq(shl(from(10), 250), new(0, 0, 0, 2882303761517117440)) == true, 0); - assert!(eq(shl(from(1), 255), new(0, 0, 0, 9223372036854775808)) == true, 0); - assert!(eq(shl(from(2), 255), new(0, 0, 0, 0)) == true, 0); - } - - #[test] - fun test_shr() { - assert!(eq(shr(from(99), 0), new(99, 0, 0, 0)) == true, 0); - assert!(eq(shr(from(99), 1), new(49, 0, 0, 0)) == true, 0); - assert!(eq(shr(from(99), 2), new(24, 0, 0, 0)) == true, 0); - assert!(eq(shr(from(99), 8), new(0, 0, 0, 0)) == true, 0); - - assert!(eq(shr(from(MAX_U128), 16), new(18446744073709551615, 281474976710655, 0, 0)) == true, 0); - assert!(eq(shr(from(MAX_U128), 63), new(18446744073709551615, 1, 0, 0)) == true, 0); - assert!(eq(shr(from(MAX_U128), 64), new(18446744073709551615, 0, 0, 0)) == true, 0); - assert!(eq(shr(from(MAX_U128), 65), new(9223372036854775807, 0, 0, 0)) == true, 0); - assert!(eq(shr(from(MAX_U128), 127), new(1, 0, 0, 0)) == true, 0); - - assert!(eq(shr(new(MAX_U64, MAX_U64, MAX_U64, MAX_U64), 191), new(18446744073709551615, 1, 0, 0)) == true, 0); - assert!(eq(shr(new(MAX_U64, MAX_U64, MAX_U64, MAX_U64), 192), new(18446744073709551615, 0, 0, 0)) == true, 0); - assert!(eq(shr(new(MAX_U64, MAX_U64, MAX_U64, MAX_U64), 193), new(9223372036854775807, 0, 0, 0)) == true, 0); - assert!(eq(shr(new(MAX_U64, MAX_U64, MAX_U64, MAX_U64), 255), new(1, 0, 0, 0)) == true, 0); - } - - #[test] - fun test_compare() { - assert!(cmp(from(99), from(99)) == EQ, 0); - assert!(cmp(new(100, 100, 100, 100), new(100, 100, 100, 101)) == LT, 0); - assert!(cmp(new(100, 100, 100, 101), new(100, 100, 100, 100)) == GT, 0); - assert!(cmp(new(100, 100, 100, 100), new(100, 100, 100, 100)) == EQ, 0); - - assert!(eq(new(100, 100, 100, 100), new(100, 100, 100, 100)) == true, 0); - assert!(lte(new(100, 100, 100, 100), new(100, 100, 100, 100)) == true, 0); - assert!(lte(new(100, 100, 100, 100), new(100, 100, 100, 101)) == true, 0); - assert!(lt(new(100, 100, 100, 100), new(100, 100, 100, 101)) == true, 0); - - assert!(lte(new(100000, 100, 100, 100), new(100, 100, 100, 101)) == true, 0); - assert!(lt(new(100000, 100, 100000, 100), new(100, 100, 100, 101)) == true, 0); - - assert!(gte(new(100, 100, 100, 101), new(100, 100, 100, 101)) == true, 0); - assert!(gte(new(100, 100, 100, 101), new(100, 100, 100, 100)) == true, 0); - assert!(gt(new(100, 100, 100, 101), new(100, 100, 100, 100)) == true, 0); - - assert!(gte(new(100, 100, 100, 101), new(100, 100, 99999, 100)) == true, 0); - assert!(gt(new(100, 100, 100, 101), new(100, 100, 99999, 100)) == true, 0); - } - - #[test] - fun test_check_div_round() { - assert!(eq(checked_div_round(from(23), from(10), false), from(2)) == true, 0); - assert!(eq(checked_div_round(from(23), from(10), true), from(3)) == true, 0); - assert!(eq(checked_div_round(from(20), from(10), true), from(2)) == true, 0); - assert!(eq(checked_div_round(from(2), from(10), true), from(1)) == true, 0); - - assert!(eq(checked_div_round(from(MAX_U128), from(10), true), from((MAX_U128 / 10) + 1)) == true, 0); - assert!(eq(checked_div_round(from(MAX_U128), from(10), false), from((MAX_U128 / 10))) == true, 0); - - //assert!(eq(checked_div_round(from(MAX_U128), from((MAX_U64 as u128)), true), from((MAX_U128 / 10) + 1)) == true, 0); - //assert!(eq(checked_div_round(from(MAX_U128), from((MAX_U64 as u128)), false), from((MAX_U128 / 10))) == true, 0); - } -} diff --git a/sui/sources/full_math_u128.move b/sources/full_math_u128.move similarity index 100% rename from sui/sources/full_math_u128.move rename to sources/full_math_u128.move diff --git a/sui/sources/full_math_u64.move b/sources/full_math_u64.move similarity index 100% rename from sui/sources/full_math_u64.move rename to sources/full_math_u64.move diff --git a/sui/sources/i128.move b/sources/i128.move similarity index 100% rename from sui/sources/i128.move rename to sources/i128.move diff --git a/sui/sources/i32.move b/sources/i32.move similarity index 100% rename from sui/sources/i32.move rename to sources/i32.move diff --git a/sui/sources/i64.move b/sources/i64.move similarity index 100% rename from sui/sources/i64.move rename to sources/i64.move diff --git a/sui/sources/math_u128.move b/sources/math_u128.move similarity index 100% rename from sui/sources/math_u128.move rename to sources/math_u128.move diff --git a/sui/sources/math_u256.move b/sources/math_u256.move similarity index 100% rename from sui/sources/math_u256.move rename to sources/math_u256.move diff --git a/aptos/sources/math_u64.move b/sources/math_u64.move similarity index 100% rename from aptos/sources/math_u64.move rename to sources/math_u64.move diff --git a/sui/migration.patch b/sui/migration.patch deleted file mode 100644 index 8ce13c6..0000000 --- a/sui/migration.patch +++ /dev/null @@ -1,40 +0,0 @@ ---- ./sources/i128.move -+++ ./sources/i128.move -@@ -14 +14 @@ -- struct I128 has copy, drop, store { -+ public struct I128 has copy, drop, store { -@@ -53,2 +53,2 @@ -- let sum = num1.bits ^ num2.bits; -- let carry = (num1.bits & num2.bits) << 1; -+ let mut sum = num1.bits ^ num2.bits; -+ let mut carry = (num1.bits & num2.bits) << 1; ---- ./sources/i32.move -+++ ./sources/i32.move -@@ -11 +11 @@ -- struct I32 has copy, drop, store { -+ public struct I32 has copy, drop, store { -@@ -48,2 +48,2 @@ -- let sum = num1.bits ^ num2.bits; -- let carry = (num1.bits & num2.bits) << 1; -+ let mut sum = num1.bits ^ num2.bits; -+ let mut carry = (num1.bits & num2.bits) << 1; ---- ./sources/i64.move -+++ ./sources/i64.move -@@ -11 +11 @@ -- struct I64 has copy, drop, store { -+ public struct I64 has copy, drop, store { -@@ -48,2 +48,2 @@ -- let sum = num1.bits ^ num2.bits; -- let carry = (num1.bits & num2.bits) << 1; -+ let mut sum = num1.bits ^ num2.bits; -+ let mut carry = (num1.bits & num2.bits) << 1; ---- ./tests/i32_tests.move -+++ ./tests/i32_tests.move -@@ -733 +733 @@ -- let i = mod(neg_from(2), from(5)); -+ let mut i = mod(neg_from(2), from(5)); ---- ./tests/i64_tests.move -+++ ./tests/i64_tests.move -@@ -622 +622 @@ -- let i = mod(neg_from(2), from(5)); -+ let mut i = mod(neg_from(2), from(5)); diff --git a/sui/sources/math_u64.move b/sui/sources/math_u64.move deleted file mode 100644 index b64480e..0000000 --- a/sui/sources/math_u64.move +++ /dev/null @@ -1,57 +0,0 @@ -module integer_mate::math_u64 { - const MAX_U64: u64 = 0xffffffffffffffff; - - const HI_64_MASK: u128 = 0xffffffffffffffff0000000000000000; - const LO_64_MASK: u128 = 0x0000000000000000ffffffffffffffff; - - public fun wrapping_add(n1: u64, n2: u64): u64 { - let (sum, _) = overflowing_add(n1, n2); - sum - } - - public fun overflowing_add(n1: u64, n2: u64): (u64, bool) { - let sum = (n1 as u128) + (n2 as u128); - if (sum > (MAX_U64 as u128)) { - (((sum & LO_64_MASK) as u64), true) - } else { - ((sum as u64), false) - } - } - - public fun wrapping_sub(n1: u64, n2: u64): u64 { - let (result, _) = overflowing_sub(n1, n2); - result - } - - public fun overflowing_sub(n1: u64, n2: u64): (u64, bool) { - if (n1 >= n2) { - ((n1 - n2), false) - } else { - ((MAX_U64 - n2 + n1 + 1), true) - } - } - - public fun wrapping_mul(n1: u64, n2: u64): u64 { - let (m, _) = overflowing_mul(n1, n2); - m - } - - public fun overflowing_mul(n1: u64, n2: u64): (u64, bool) { - let m = (n1 as u128) * (n2 as u128); - (((m & LO_64_MASK) as u64), (m & HI_64_MASK) > 0) - } - - public fun carry_add(n1: u64, n2: u64, carry: u64): (u64, u64) { - assert!(carry <= 1, 0); - let sum = (n1 as u128) + (n2 as u128) + (carry as u128); - if (sum > LO_64_MASK) { - (((sum & LO_64_MASK) as u64), 1) - } else { - ((sum as u64), 0) - } - } - - public fun add_check(n1: u64, n2: u64): bool { - (MAX_U64 - n1 >= n2) - } -} diff --git a/sui/tests/full_math_u128_tests.move b/tests/full_math_u128_tests.move similarity index 100% rename from sui/tests/full_math_u128_tests.move rename to tests/full_math_u128_tests.move diff --git a/sui/tests/full_math_u64_tests.move b/tests/full_math_u64_tests.move similarity index 100% rename from sui/tests/full_math_u64_tests.move rename to tests/full_math_u64_tests.move diff --git a/sui/tests/i128_tests.move b/tests/i128_tests.move similarity index 100% rename from sui/tests/i128_tests.move rename to tests/i128_tests.move diff --git a/sui/tests/i32_tests.move b/tests/i32_tests.move similarity index 100% rename from sui/tests/i32_tests.move rename to tests/i32_tests.move diff --git a/sui/tests/i64_tests.move b/tests/i64_tests.move similarity index 100% rename from sui/tests/i64_tests.move rename to tests/i64_tests.move diff --git a/sui/tests/math_u128_tests.move b/tests/math_u128_tests.move similarity index 100% rename from sui/tests/math_u128_tests.move rename to tests/math_u128_tests.move diff --git a/sui/tests/math_u256_tests.move b/tests/math_u256_tests.move similarity index 100% rename from sui/tests/math_u256_tests.move rename to tests/math_u256_tests.move diff --git a/sui/tests/math_u64_tests.move b/tests/math_u64_tests.move similarity index 100% rename from sui/tests/math_u64_tests.move rename to tests/math_u64_tests.move