From 8b2d16d17942e1fe1a4f69518a7ded983b7a1df5 Mon Sep 17 00:00:00 2001 From: aritkulova Date: Tue, 11 Aug 2026 17:31:42 +0300 Subject: [PATCH 1/9] moved u128 to math file --- simf/lib/asserts.simf | 2 +- simf/lib/{u128.simf => u128/math.simf} | 0 simf/{u128_test.simf => u128_math_test.simf} | 16 ++++++++++++-- simf/u128_test_arithmetic.simf | 23 ++++++++++++++++---- simf/u128_test_bits.simf | 4 ++-- simf/u16_convert_test.simf | 2 +- simf/u1_convert_test.simf | 2 +- simf/u32_convert_test.simf | 2 +- simf/u8_convert_test.simf | 2 +- tests/{u128_test.rs => u128_math_test.rs} | 20 ++++++++--------- 10 files changed, 50 insertions(+), 23 deletions(-) rename simf/lib/{u128.simf => u128/math.simf} (100%) rename simf/{u128_test.simf => u128_math_test.simf} (91%) rename tests/{u128_test.rs => u128_math_test.rs} (58%) diff --git a/simf/lib/asserts.simf b/simf/lib/asserts.simf index 63c4a9a..009c94c 100644 --- a/simf/lib/asserts.simf +++ b/simf/lib/asserts.simf @@ -1,4 +1,4 @@ -use crate::lib::u128::eq_128; +use crate::lib::u128::math::eq_128; /// Asserts that two `u1` are equal pub fn assert_eq_1(a: u1, b: u1) { diff --git a/simf/lib/u128.simf b/simf/lib/u128/math.simf similarity index 100% rename from simf/lib/u128.simf rename to simf/lib/u128/math.simf diff --git a/simf/u128_test.simf b/simf/u128_math_test.simf similarity index 91% rename from simf/u128_test.simf rename to simf/u128_math_test.simf index cbaeedf..bf2024c 100644 --- a/simf/u128_test.simf +++ b/simf/u128_math_test.simf @@ -1,4 +1,16 @@ -use crate::lib::u128::{ checked_add_128, safe_add_128, checked_sub_128, safe_sub_128, checked_mul_128, safe_mul_128, checked_div_128, safe_div_128, eq_128, gt_128, ge_128 }; +use crate::lib::u128::math::{ + checked_add_128, + safe_add_128, + checked_sub_128, + safe_sub_128, + checked_mul_128, + safe_mul_128, + checked_div_128, + safe_div_128, + eq_128, + gt_128, + ge_128 +}; use crate::lib::asserts::{assert_none_128, assert_eq_128}; use crate::lib::binary::not; use crate::helper::if_test_this_function; @@ -8,8 +20,8 @@ use crate::helper::if_test_this_function; /// witness value carries both, removing the need for a separate overflow flag. fn assert_eq_opt(result: Option, expected: Option) { match expected { - None => assert_none_128(result), Some(e: u128) => assert_eq_128(unwrap(result), e), + None => assert_none_128(result), } } diff --git a/simf/u128_test_arithmetic.simf b/simf/u128_test_arithmetic.simf index a95ee18..82c33ae 100644 --- a/simf/u128_test_arithmetic.simf +++ b/simf/u128_test_arithmetic.simf @@ -1,4 +1,19 @@ -use crate::lib::u128::{ eq_128, is_zero_128, lt_128, le_128, add_128, add_128_64, sub_128, mul_128, split_256_into_64, normalize_to_threshold, algorithm_d, div_mod_128_64, div_mod_128, div_128 }; +use crate::lib::u128::math::{ + eq_128, + is_zero_128, + lt_128, + le_128, + add_128, + add_128_64, + sub_128, + mul_128, + split_256_into_64, + normalize_to_threshold, + algorithm_d, + div_mod_128_64, + div_mod_128, + div_128 +}; use crate::helper::{if_test_this_function, assert_bool}; /// Asserts a result equals expected u128 and bool values. @@ -7,7 +22,7 @@ fn assert_eq_uint_bool(result: (bool, u128), expected: u128, expected_bool: bool let (bool_res, uint_res): (bool, u128) = result; assert_bool(bool_res, expected_bool); - + assert!(eq_128(uint_res, expected)); } @@ -37,7 +52,7 @@ fn main() { let result: u256 = mul_128(a, b); let (result_high, result_low): (u128, u128) = ::into(result); - + assert!(eq_128(result_high, unwrap(expected))); assert!(eq_128(result_low, second_expected)); }, @@ -51,7 +66,7 @@ fn main() { let (expected1, expected2): (u64, u64) = ::into(unwrap(expected)); let (expected3, expected4): (u64, u64) = ::into(second_expected); - + assert!(jet::eq_64(res1, expected1)); assert!(jet::eq_64(res2, expected2)); assert!(jet::eq_64(res3, expected3)); diff --git a/simf/u128_test_bits.simf b/simf/u128_test_bits.simf index 725cad9..85d6084 100644 --- a/simf/u128_test_bits.simf +++ b/simf/u128_test_bits.simf @@ -1,4 +1,4 @@ -use crate::lib::u128::{ and_128, or_128, eq_128, left_shift_128, right_shift_128 }; +use crate::lib::u128::math::{and_128, or_128, eq_128, left_shift_128, right_shift_128}; use crate::helper::{if_test_this_function, assert_bool}; fn main() { @@ -9,7 +9,7 @@ fn main() { let expected: Option = witness::EXPECTED; let expected_bool: bool = witness::EXPECTED_BOOL; - + /// Bit logic match if_test_this_function(0, fn_idx) { true => { assert!(eq_128(and_128(a, b), unwrap(expected))); }, false => (), }; diff --git a/simf/u16_convert_test.simf b/simf/u16_convert_test.simf index 7a59769..f36f725 100644 --- a/simf/u16_convert_test.simf +++ b/simf/u16_convert_test.simf @@ -7,7 +7,7 @@ use crate::lib::u16::convert::{ safe_u16_to_u1, safe_u16_to_u8 }; -use crate::lib::u128::eq_128; +use crate::lib::u128::math::eq_128; use crate::lib::asserts::{assert_eq_1, assert_eq_8}; use crate::helper::if_test_this_function; diff --git a/simf/u1_convert_test.simf b/simf/u1_convert_test.simf index a432dd9..31e667e 100644 --- a/simf/u1_convert_test.simf +++ b/simf/u1_convert_test.simf @@ -7,7 +7,7 @@ use crate::lib::u1::convert::{ u1_to_u256, u1_to_bool }; -use crate::lib::u128::eq_128; +use crate::lib::u128::math::eq_128; use crate::lib::asserts::assert_eq_bool; use crate::helper::if_test_this_function; diff --git a/simf/u32_convert_test.simf b/simf/u32_convert_test.simf index af21275..f96ddc5 100644 --- a/simf/u32_convert_test.simf +++ b/simf/u32_convert_test.simf @@ -8,7 +8,7 @@ use crate::lib::u32::convert::{ safe_u32_to_u8, safe_u32_to_u16 }; -use crate::lib::u128::eq_128; +use crate::lib::u128::math::eq_128; use crate::lib::asserts::{assert_eq_1, assert_eq_8, assert_eq_16}; use crate::helper::if_test_this_function; diff --git a/simf/u8_convert_test.simf b/simf/u8_convert_test.simf index 7589160..f9808fb 100644 --- a/simf/u8_convert_test.simf +++ b/simf/u8_convert_test.simf @@ -8,7 +8,7 @@ use crate::lib::u8::convert::{ safe_u8_to_u1 }; // use crate::lib::u256::{split_256_into_64}; TODO: uncomment when u256 functions are merged -use crate::lib::u128::eq_128; +use crate::lib::u128::math::eq_128; use crate::lib::asserts::assert_eq_1; use crate::helper::if_test_this_function; diff --git a/tests/u128_test.rs b/tests/u128_math_test.rs similarity index 58% rename from tests/u128_test.rs rename to tests/u128_math_test.rs index 5791165..ced65d1 100644 --- a/tests/u128_test.rs +++ b/tests/u128_math_test.rs @@ -2,15 +2,15 @@ mod common; use common::uint::TestUint; -use simplicityhl_std::artifacts::u128_test::U128TestProgram; -use simplicityhl_std::artifacts::u128_test::derived_u128_test::{ - U128TestArguments, U128TestWitness, +use simplicityhl_std::artifacts::u128_math_test::U128MathTestProgram; +use simplicityhl_std::artifacts::u128_math_test::derived_u128_math_test::{ + U128MathTestArguments, U128MathTestWitness, }; // The only per-width code for the common operations. impl TestUint for u128 { - type Program = U128TestProgram; - type Witness = U128TestWitness; + type Program = U128MathTestProgram; + type Witness = U128MathTestWitness; const ZERO: u128 = 0; const ONE: u128 = 1; @@ -18,12 +18,12 @@ impl TestUint for u128 { const HALF_MAX: u128 = u128::MAX / 2; const MUL_BOUND: u128 = 1 << 64; // 2^(128/2) - fn program() -> U128TestProgram { - U128TestProgram::new(U128TestArguments {}) + fn program() -> U128MathTestProgram { + U128MathTestProgram::new(U128MathTestArguments {}) } - fn witness(op: u8, a: u128, b: u128, expected: Option) -> U128TestWitness { - U128TestWitness { + fn witness(op: u8, a: u128, b: u128, expected: Option) -> U128MathTestWitness { + U128MathTestWitness { function_index: op, first_arg: a, second_arg: b, @@ -32,7 +32,7 @@ impl TestUint for u128 { } } -mod u128_tests { +mod u128_math_tests { use super::*; // Stamps the 16 `#[simplex::test]` entry points for u128. Logic lives in common::uint. From 189ce948dcb2fdbfe9b16717df2783b180ba081f Mon Sep 17 00:00:00 2001 From: aritkulova Date: Tue, 11 Aug 2026 17:33:24 +0300 Subject: [PATCH 2/9] added convert functions for u128 --- simf/lib/u128/convert.simf | 82 +++++++++++ simf/u128_convert_test.simf | 111 +++++++++++++++ tests/u128_convert_test.rs | 261 ++++++++++++++++++++++++++++++++++++ 3 files changed, 454 insertions(+) create mode 100644 simf/lib/u128/convert.simf create mode 100644 simf/u128_convert_test.simf create mode 100644 tests/u128_convert_test.rs diff --git a/simf/lib/u128/convert.simf b/simf/lib/u128/convert.simf new file mode 100644 index 0000000..21995eb --- /dev/null +++ b/simf/lib/u128/convert.simf @@ -0,0 +1,82 @@ +use crate::lib::u1::convert::u1_to_u128; +use crate::lib::u8::convert::u8_to_u128; +use crate::lib::u16::convert::u16_to_u128; +use crate::lib::u32::convert::u32_to_u128; +// use crate::lib::u64::convert::u64_to_u128; TODO: add when merged +use crate::lib::u128::math::le_128; + +/// Widening uint conversions + +/// Converts u128 to u256 +pub fn u128_to_u256(a: u128) -> u256 { + <(u128, u128)>::into((0, a)) +} + +/// Splitting uint conversions + +/// Splits u128 into four u32 +pub fn split_u128_to_u32(a: u128) -> (u32, u32, u32, u32) { + ::into(a) +} + +/// Splits u128 into two u64 +pub fn split_u128_to_u64(a: u128) -> (u64, u64) { + ::into(a) +} + +/// Narrowing uint conversions + +/// Converts u128 into u1. +/// Panics if the value does not fit in u1 +pub fn safe_u128_to_u1(a: u128) -> u1 { + let u1_max: u128 = u1_to_u128(jet::high_1()); + let (_, a_64): (u64, u64) = split_u128_to_u64(a); + + assert!(le_128(a, u1_max)); + + jet::rightmost_64_1(a_64) +} + +/// Converts u128 into u8. +/// Panics if the value does not fit in u8 +pub fn safe_u128_to_u8(a: u128) -> u8 { + let u8_max: u128 = u8_to_u128(jet::high_8()); + let (_, a_64): (u64, u64) = split_u128_to_u64(a); + + assert!(le_128(a, u8_max)); + + jet::rightmost_64_8(a_64) +} + +/// Converts u128 into u16. +/// Panics if the value does not fit in u16 +pub fn safe_u128_to_u16(a: u128) -> u16 { + let u16_max: u128 = u16_to_u128(jet::high_16()); + let (_, a_64): (u64, u64) = split_u128_to_u64(a); + + assert!(le_128(a, u16_max)); + + jet::rightmost_64_16(a_64) +} + +/// Converts u128 into u32. +/// Panics if the value does not fit in u32 +pub fn safe_u128_to_u32(a: u128) -> u32 { + let u32_max: u128 = u32_to_u128(jet::high_32()); + let (_, a_64): (u64, u64) = split_u128_to_u64(a); + + assert!(le_128(a, u32_max)); + + jet::rightmost_64_32(a_64) +} + +/// Converts u128 into u64. +/// Panics if the value does not fit in u64 +pub fn safe_u128_to_u64(a: u128) -> u64 { + let u64_max: u128 = <(u64, u64)>::into((0, jet::high_64())); + let (_, a_64): (u64, u64) = split_u128_to_u64(a); + + assert!(le_128(a, u64_max)); + + a_64 +} diff --git a/simf/u128_convert_test.simf b/simf/u128_convert_test.simf new file mode 100644 index 0000000..ef2127f --- /dev/null +++ b/simf/u128_convert_test.simf @@ -0,0 +1,111 @@ +use crate::lib::u128::convert::{ + u128_to_u256, + split_u128_to_u32, + split_u128_to_u64, + safe_u128_to_u1, + safe_u128_to_u8, + safe_u128_to_u16, + safe_u128_to_u32, + safe_u128_to_u64 +}; +use crate::lib::asserts::{ + assert_eq_1, + assert_eq_8, + assert_eq_16, + assert_eq_32, + assert_eq_64, + assert_eq_256 +}; +use crate::helper::if_test_this_function; + +fn main() { + let fn_idx: u8 = witness::FUNCTION_INDEX; + + let a: u128 = witness::FIRST_ARG; + + let expected: u256 = witness::EXPECTED; + + match if_test_this_function(0, fn_idx) { + true => { + assert_eq_256(u128_to_u256(a), expected); + }, + false => {}, + }; + + match if_test_this_function(1, fn_idx) { + true => { + let (a3, a2, a1, a0): (u32, u32, u32, u32) = split_u128_to_u32(a); + + let (_, _, expected1, expected0): (u64, u64, u64, u64) = ::into(expected); + let (expected3, expected2): (u32, u32) = ::into(expected1); + let (expected1, expected0): (u32, u32) = ::into(expected0); + + assert_eq_32(a3, expected3); + assert_eq_32(a2, expected2); + assert_eq_32(a1, expected1); + assert_eq_32(a0, expected0); + }, + false => {}, + }; + + match if_test_this_function(2, fn_idx) { + true => { + let (a1, a0): (u64, u64) = split_u128_to_u64(a); + + let (_, _, expected1, expected0): (u64, u64, u64, u64) = ::into(expected); + + assert_eq_64(a1, expected1); + assert_eq_64(a0, expected0); + }, + false => {}, + }; + + match if_test_this_function(3, fn_idx) { + true => { + let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); + let expected: u1 = jet::rightmost_64_1(expected); + + assert_eq_1(safe_u128_to_u1(a), expected); + }, + false => {}, + }; + + match if_test_this_function(4, fn_idx) { + true => { + let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); + let expected: u8 = jet::rightmost_64_8(expected); + + assert_eq_8(safe_u128_to_u8(a), expected); + }, + false => {}, + }; + + match if_test_this_function(5, fn_idx) { + true => { + let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); + let expected: u16 = jet::rightmost_64_16(expected); + + assert_eq_16(safe_u128_to_u16(a), expected); + }, + false => {}, + }; + + match if_test_this_function(6, fn_idx) { + true => { + let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); + let expected: u32 = jet::rightmost_64_32(expected); + + assert_eq_32(safe_u128_to_u32(a), expected); + }, + false => {}, + }; + + match if_test_this_function(7, fn_idx) { + true => { + let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); + + assert_eq_64(safe_u128_to_u64(a), expected); + }, + false => {}, + }; +} diff --git a/tests/u128_convert_test.rs b/tests/u128_convert_test.rs new file mode 100644 index 0000000..c62bbde --- /dev/null +++ b/tests/u128_convert_test.rs @@ -0,0 +1,261 @@ +mod common; + +use primitive_types::U256; +use rand::Rng; + +use common::core::{Expect, run}; + +use simplicityhl_std::artifacts::u128_convert_test::U128ConvertTestProgram; +use simplicityhl_std::artifacts::u128_convert_test::derived_u128_convert_test::{ + U128ConvertTestArguments, U128ConvertTestWitness, +}; + +enum FunctionToTest { + U128ToU256, + SplitU128ToU32, + SplitU128ToU64, + SafeU128ToU1, + SafeU128ToU8, + SafeU128ToU16, + SafeU128ToU32, + SafeU128ToU64, +} + +#[inline] +fn op(o: FunctionToTest) -> u8 { + o as u8 +} + +fn program() -> U128ConvertTestProgram { + U128ConvertTestProgram::new(U128ConvertTestArguments {}) +} + +fn build_witness(function: u8, a: u128, expected: [u8; 32]) -> U128ConvertTestWitness { + U128ConvertTestWitness { + function_index: function, + first_arg: a, + expected, + } +} + +mod u128_convert_test { + use super::*; + + #[simplex::test] + fn u128_convert_test_u128_to_u256(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=u128::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::U128ToU256), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u128_convert_test_split_u128_to_u32(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=u128::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SplitU128ToU32), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u128_convert_test_split_u128_to_u64(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=u128::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SplitU128ToU64), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u128_convert_test_safe_u128_to_u1(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=1); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU128ToU1), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u128_convert_test_safe_u128_to_u1_overflow( + context: simplex::TestContext, + ) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(2..=u128::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU128ToU1), + a, + U256::from(a).to_big_endian(), + ), + Expect::AssertFailed, + ) + } + + #[simplex::test] + fn u128_convert_test_safe_u128_to_u8(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=u8::MAX as u128); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU128ToU8), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u128_convert_test_safe_u128_to_u8_overflow( + context: simplex::TestContext, + ) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(u8::MAX as u128 + 1..=u128::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU128ToU8), + a, + U256::from(a).to_big_endian(), + ), + Expect::AssertFailed, + ) + } + + #[simplex::test] + fn u128_convert_test_safe_u128_to_u16(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=u16::MAX as u128); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU128ToU16), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u128_convert_test_safe_u128_to_u16_overflow( + context: simplex::TestContext, + ) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(u16::MAX as u128 + 1..=u128::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU128ToU16), + a, + U256::from(a).to_big_endian(), + ), + Expect::AssertFailed, + ) + } + + #[simplex::test] + fn u128_convert_test_safe_u128_to_u32(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=u32::MAX as u128); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU128ToU32), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u128_convert_test_safe_u128_to_u32_overflow( + context: simplex::TestContext, + ) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(u32::MAX as u128 + 1..=u128::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU128ToU32), + a, + U256::from(a).to_big_endian(), + ), + Expect::AssertFailed, + ) + } + + #[simplex::test] + fn u128_convert_test_safe_u128_to_u64(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=u64::MAX as u128); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU128ToU64), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u128_convert_test_safe_u128_to_u64_overflow( + context: simplex::TestContext, + ) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(u64::MAX as u128 + 1..=u128::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU128ToU64), + a, + U256::from(a).to_big_endian(), + ), + Expect::AssertFailed, + ) + } +} From 84f1ae82578d761bb48c9202cda51104a04471d0 Mon Sep 17 00:00:00 2001 From: aritkulova Date: Tue, 11 Aug 2026 20:11:54 +0300 Subject: [PATCH 3/9] typo --- simf/lib/u128/convert.simf | 14 +++++++------- simf/u128_convert_test.simf | 8 ++++---- tests/u128_convert_test.rs | 4 ++-- 3 files changed, 13 insertions(+), 13 deletions(-) diff --git a/simf/lib/u128/convert.simf b/simf/lib/u128/convert.simf index 21995eb..9cfc159 100644 --- a/simf/lib/u128/convert.simf +++ b/simf/lib/u128/convert.simf @@ -15,12 +15,12 @@ pub fn u128_to_u256(a: u128) -> u256 { /// Splitting uint conversions /// Splits u128 into four u32 -pub fn split_u128_to_u32(a: u128) -> (u32, u32, u32, u32) { +pub fn split_u128_into_u32(a: u128) -> (u32, u32, u32, u32) { ::into(a) } /// Splits u128 into two u64 -pub fn split_u128_to_u64(a: u128) -> (u64, u64) { +pub fn split_u128_into_u64(a: u128) -> (u64, u64) { ::into(a) } @@ -30,7 +30,7 @@ pub fn split_u128_to_u64(a: u128) -> (u64, u64) { /// Panics if the value does not fit in u1 pub fn safe_u128_to_u1(a: u128) -> u1 { let u1_max: u128 = u1_to_u128(jet::high_1()); - let (_, a_64): (u64, u64) = split_u128_to_u64(a); + let (_, a_64): (u64, u64) = split_u128_into_u64(a); assert!(le_128(a, u1_max)); @@ -41,7 +41,7 @@ pub fn safe_u128_to_u1(a: u128) -> u1 { /// Panics if the value does not fit in u8 pub fn safe_u128_to_u8(a: u128) -> u8 { let u8_max: u128 = u8_to_u128(jet::high_8()); - let (_, a_64): (u64, u64) = split_u128_to_u64(a); + let (_, a_64): (u64, u64) = split_u128_into_u64(a); assert!(le_128(a, u8_max)); @@ -52,7 +52,7 @@ pub fn safe_u128_to_u8(a: u128) -> u8 { /// Panics if the value does not fit in u16 pub fn safe_u128_to_u16(a: u128) -> u16 { let u16_max: u128 = u16_to_u128(jet::high_16()); - let (_, a_64): (u64, u64) = split_u128_to_u64(a); + let (_, a_64): (u64, u64) = split_u128_into_u64(a); assert!(le_128(a, u16_max)); @@ -63,7 +63,7 @@ pub fn safe_u128_to_u16(a: u128) -> u16 { /// Panics if the value does not fit in u32 pub fn safe_u128_to_u32(a: u128) -> u32 { let u32_max: u128 = u32_to_u128(jet::high_32()); - let (_, a_64): (u64, u64) = split_u128_to_u64(a); + let (_, a_64): (u64, u64) = split_u128_into_u64(a); assert!(le_128(a, u32_max)); @@ -74,7 +74,7 @@ pub fn safe_u128_to_u32(a: u128) -> u32 { /// Panics if the value does not fit in u64 pub fn safe_u128_to_u64(a: u128) -> u64 { let u64_max: u128 = <(u64, u64)>::into((0, jet::high_64())); - let (_, a_64): (u64, u64) = split_u128_to_u64(a); + let (_, a_64): (u64, u64) = split_u128_into_u64(a); assert!(le_128(a, u64_max)); diff --git a/simf/u128_convert_test.simf b/simf/u128_convert_test.simf index ef2127f..06bea8f 100644 --- a/simf/u128_convert_test.simf +++ b/simf/u128_convert_test.simf @@ -1,7 +1,7 @@ use crate::lib::u128::convert::{ u128_to_u256, - split_u128_to_u32, - split_u128_to_u64, + split_u128_into_u32, + split_u128_into_u64, safe_u128_to_u1, safe_u128_to_u8, safe_u128_to_u16, @@ -34,7 +34,7 @@ fn main() { match if_test_this_function(1, fn_idx) { true => { - let (a3, a2, a1, a0): (u32, u32, u32, u32) = split_u128_to_u32(a); + let (a3, a2, a1, a0): (u32, u32, u32, u32) = split_u128_into_u32(a); let (_, _, expected1, expected0): (u64, u64, u64, u64) = ::into(expected); let (expected3, expected2): (u32, u32) = ::into(expected1); @@ -50,7 +50,7 @@ fn main() { match if_test_this_function(2, fn_idx) { true => { - let (a1, a0): (u64, u64) = split_u128_to_u64(a); + let (a1, a0): (u64, u64) = split_u128_into_u64(a); let (_, _, expected1, expected0): (u64, u64, u64, u64) = ::into(expected); diff --git a/tests/u128_convert_test.rs b/tests/u128_convert_test.rs index c62bbde..162b4d3 100644 --- a/tests/u128_convert_test.rs +++ b/tests/u128_convert_test.rs @@ -58,7 +58,7 @@ mod u128_convert_test { } #[simplex::test] - fn u128_convert_test_split_u128_to_u32(context: simplex::TestContext) -> anyhow::Result<()> { + fn u128_convert_test_split_u128_into_u32(context: simplex::TestContext) -> anyhow::Result<()> { let a = rand::thread_rng().gen_range(0..=u128::MAX); run( @@ -74,7 +74,7 @@ mod u128_convert_test { } #[simplex::test] - fn u128_convert_test_split_u128_to_u64(context: simplex::TestContext) -> anyhow::Result<()> { + fn u128_convert_test_split_u128_into_u64(context: simplex::TestContext) -> anyhow::Result<()> { let a = rand::thread_rng().gen_range(0..=u128::MAX); run( From a123b068b3cd58a2a29877132133a896d3e13d4c Mon Sep 17 00:00:00 2001 From: aritkulova Date: Fri, 14 Aug 2026 19:52:24 +0300 Subject: [PATCH 4/9] fixed typo --- tests/u128_convert_test.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/u128_convert_test.rs b/tests/u128_convert_test.rs index 162b4d3..7bcd29b 100644 --- a/tests/u128_convert_test.rs +++ b/tests/u128_convert_test.rs @@ -12,8 +12,8 @@ use simplicityhl_std::artifacts::u128_convert_test::derived_u128_convert_test::{ enum FunctionToTest { U128ToU256, - SplitU128ToU32, - SplitU128ToU64, + SplitU128IntoU32, + SplitU128IntoU64, SafeU128ToU1, SafeU128ToU8, SafeU128ToU16, @@ -65,7 +65,7 @@ mod u128_convert_test { &context, program(), build_witness( - op(FunctionToTest::SplitU128ToU32), + op(FunctionToTest::SplitU128IntoU32), a, U256::from(a).to_big_endian(), ), @@ -81,7 +81,7 @@ mod u128_convert_test { &context, program(), build_witness( - op(FunctionToTest::SplitU128ToU64), + op(FunctionToTest::SplitU128IntoU64), a, U256::from(a).to_big_endian(), ), From 2c95d3b7b03a8f47d6b8496bcf0e941ebf3b35fc Mon Sep 17 00:00:00 2001 From: aritkulova Date: Fri, 14 Aug 2026 19:54:40 +0300 Subject: [PATCH 5/9] added missing split_u128 functions --- simf/lib/u128/convert.simf | 12 +++ simf/u128_convert_test.simf | 141 ++++++++++++++++++++++++++++++++++-- tests/u128_convert_test.rs | 34 +++++++++ 3 files changed, 181 insertions(+), 6 deletions(-) diff --git a/simf/lib/u128/convert.simf b/simf/lib/u128/convert.simf index 9cfc159..8e3f623 100644 --- a/simf/lib/u128/convert.simf +++ b/simf/lib/u128/convert.simf @@ -14,6 +14,18 @@ pub fn u128_to_u256(a: u128) -> u256 { /// Splitting uint conversions +/// Splits u128 into sixteen u8 +pub fn split_u128_into_u8( + a: u128 +) -> (u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8) { + ::into(a) +} + +/// Splits u128 into eight u16 +pub fn split_u128_into_u16(a: u128) -> (u16, u16, u16, u16, u16, u16, u16, u16) { + ::into(a) +} + /// Splits u128 into four u32 pub fn split_u128_into_u32(a: u128) -> (u32, u32, u32, u32) { ::into(a) diff --git a/simf/u128_convert_test.simf b/simf/u128_convert_test.simf index 06bea8f..0d70dcf 100644 --- a/simf/u128_convert_test.simf +++ b/simf/u128_convert_test.simf @@ -1,5 +1,7 @@ use crate::lib::u128::convert::{ u128_to_u256, + split_u128_into_u8, + split_u128_into_u16, split_u128_into_u32, split_u128_into_u64, safe_u128_to_u1, @@ -33,6 +35,133 @@ fn main() { }; match if_test_this_function(1, fn_idx) { + true => { + let ( + a15, + a14, + a13, + a12, + a11, + a10, + a9, + a8, + a7, + a6, + a5, + a4, + a3, + a2, + a1, + a0 + ): ( + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8 + ) = split_u128_into_u8(a); + + let (_, _, expected1, expected0): (u64, u64, u64, u64) = ::into(expected); + let (expected3, expected2): (u32, u32) = ::into(expected1); + let (expected1, expected0): (u32, u32) = ::into(expected0); + + let ( + expected15, + expected14, + expected13, + expected12 + ): (u8, u8, u8, u8) = ::into(expected3); + let ( + expected11, + expected10, + expected9, + expected8 + ): (u8, u8, u8, u8) = ::into(expected2); + let ( + expected7, + expected6, + expected5, + expected4 + ): (u8, u8, u8, u8) = ::into(expected1); + let ( + expected3, + expected2, + expected1, + expected0 + ): (u8, u8, u8, u8) = ::into(expected0); + + assert_eq_8(a15, expected15); + assert_eq_8(a14, expected14); + assert_eq_8(a13, expected13); + assert_eq_8(a12, expected12); + assert_eq_8(a11, expected11); + assert_eq_8(a10, expected10); + assert_eq_8(a9, expected9); + assert_eq_8(a8, expected8); + assert_eq_8(a7, expected7); + assert_eq_8(a6, expected6); + assert_eq_8(a5, expected5); + assert_eq_8(a4, expected4); + assert_eq_8(a3, expected3); + assert_eq_8(a2, expected2); + assert_eq_8(a1, expected1); + assert_eq_8(a0, expected0); + }, + false => {}, + }; + + match if_test_this_function(2, fn_idx) { + true => { + let ( + a7, + a6, + a5, + a4, + a3, + a2, + a1, + a0 + ): (u16, u16, u16, u16, u16, u16, u16, u16) = split_u128_into_u16(a); + + let (_, _, expected1, expected0): (u64, u64, u64, u64) = ::into(expected); + + let ( + expected7, + expected6, + expected5, + expected4 + ): (u16, u16, u16, u16) = ::into(expected1); + let ( + expected3, + expected2, + expected1, + expected0 + ): (u16, u16, u16, u16) = ::into(expected0); + + assert_eq_16(a7, expected7); + assert_eq_16(a6, expected6); + assert_eq_16(a5, expected5); + assert_eq_16(a4, expected4); + assert_eq_16(a3, expected3); + assert_eq_16(a2, expected2); + assert_eq_16(a1, expected1); + assert_eq_16(a0, expected0); + }, + false => {}, + }; + + match if_test_this_function(3, fn_idx) { true => { let (a3, a2, a1, a0): (u32, u32, u32, u32) = split_u128_into_u32(a); @@ -48,7 +177,7 @@ fn main() { false => {}, }; - match if_test_this_function(2, fn_idx) { + match if_test_this_function(4, fn_idx) { true => { let (a1, a0): (u64, u64) = split_u128_into_u64(a); @@ -60,7 +189,7 @@ fn main() { false => {}, }; - match if_test_this_function(3, fn_idx) { + match if_test_this_function(5, fn_idx) { true => { let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); let expected: u1 = jet::rightmost_64_1(expected); @@ -70,7 +199,7 @@ fn main() { false => {}, }; - match if_test_this_function(4, fn_idx) { + match if_test_this_function(6, fn_idx) { true => { let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); let expected: u8 = jet::rightmost_64_8(expected); @@ -80,7 +209,7 @@ fn main() { false => {}, }; - match if_test_this_function(5, fn_idx) { + match if_test_this_function(7, fn_idx) { true => { let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); let expected: u16 = jet::rightmost_64_16(expected); @@ -90,7 +219,7 @@ fn main() { false => {}, }; - match if_test_this_function(6, fn_idx) { + match if_test_this_function(8, fn_idx) { true => { let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); let expected: u32 = jet::rightmost_64_32(expected); @@ -100,7 +229,7 @@ fn main() { false => {}, }; - match if_test_this_function(7, fn_idx) { + match if_test_this_function(9, fn_idx) { true => { let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); diff --git a/tests/u128_convert_test.rs b/tests/u128_convert_test.rs index 7bcd29b..3e4e2ec 100644 --- a/tests/u128_convert_test.rs +++ b/tests/u128_convert_test.rs @@ -12,6 +12,8 @@ use simplicityhl_std::artifacts::u128_convert_test::derived_u128_convert_test::{ enum FunctionToTest { U128ToU256, + SplitU128IntoU8, + SplitU128IntoU16, SplitU128IntoU32, SplitU128IntoU64, SafeU128ToU1, @@ -56,6 +58,38 @@ mod u128_convert_test { Expect::Ok, ) } + + #[simplex::test] + fn u128_convert_test_split_u128_into_u8(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=u128::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SplitU128IntoU8), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u128_convert_test_split_u128_into_u16(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=u128::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SplitU128IntoU16), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } #[simplex::test] fn u128_convert_test_split_u128_into_u32(context: simplex::TestContext) -> anyhow::Result<()> { From 5ba3339d5b5f65bea92c47deed1f2bcd8b1a4df3 Mon Sep 17 00:00:00 2001 From: aritkulova Date: Fri, 14 Aug 2026 20:15:28 +0300 Subject: [PATCH 6/9] resolved todo; utilized assert_eq in tests --- simf/lib/u128/convert.simf | 4 ++-- simf/u16_convert_test.simf | 17 ++++++++++++----- simf/u1_convert_test.simf | 22 +++++++++++++++------- simf/u32_convert_test.simf | 15 +++++++++++---- simf/u8_convert_test.simf | 20 +++++++++++++------- 5 files changed, 53 insertions(+), 25 deletions(-) diff --git a/simf/lib/u128/convert.simf b/simf/lib/u128/convert.simf index 8e3f623..4f503e9 100644 --- a/simf/lib/u128/convert.simf +++ b/simf/lib/u128/convert.simf @@ -2,7 +2,7 @@ use crate::lib::u1::convert::u1_to_u128; use crate::lib::u8::convert::u8_to_u128; use crate::lib::u16::convert::u16_to_u128; use crate::lib::u32::convert::u32_to_u128; -// use crate::lib::u64::convert::u64_to_u128; TODO: add when merged +use crate::lib::u64::convert::u64_to_u128; use crate::lib::u128::math::le_128; /// Widening uint conversions @@ -85,7 +85,7 @@ pub fn safe_u128_to_u32(a: u128) -> u32 { /// Converts u128 into u64. /// Panics if the value does not fit in u64 pub fn safe_u128_to_u64(a: u128) -> u64 { - let u64_max: u128 = <(u64, u64)>::into((0, jet::high_64())); + let u64_max: u128 = u64_to_u128(jet::high_64()); let (_, a_64): (u64, u64) = split_u128_into_u64(a); assert!(le_128(a, u64_max)); diff --git a/simf/u16_convert_test.simf b/simf/u16_convert_test.simf index f36f725..3c7ce54 100644 --- a/simf/u16_convert_test.simf +++ b/simf/u16_convert_test.simf @@ -8,7 +8,14 @@ use crate::lib::u16::convert::{ safe_u16_to_u8 }; use crate::lib::u128::math::eq_128; -use crate::lib::asserts::{assert_eq_1, assert_eq_8}; +use crate::lib::asserts::{ + assert_eq_1, + assert_eq_8, + assert_eq_32, + assert_eq_64, + assert_eq_128, + assert_eq_256 +}; use crate::helper::if_test_this_function; fn main() { @@ -23,7 +30,7 @@ fn main() { let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); let (_, expected): (u32, u32) = ::into(expected); - assert!(jet::eq_32(u16_to_u32(a), expected)); + assert_eq_32(u16_to_u32(a), expected); }, false => {}, }; @@ -32,7 +39,7 @@ fn main() { true => { let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); - assert!(jet::eq_64(u16_to_u64(a), expected)); + assert_eq_64(u16_to_u64(a), expected); }, false => {}, }; @@ -41,14 +48,14 @@ fn main() { true => { let (_, expected): (u128, u128) = ::into(expected); - assert!(eq_128(u16_to_u128(a), expected)); + assert_eq_128(u16_to_u128(a), expected); }, false => {}, }; match if_test_this_function(3, fn_idx) { true => { - assert!(jet::eq_256(u16_to_u256(a), expected)); + assert_eq_256(u16_to_u256(a), expected); }, false => {}, }; diff --git a/simf/u1_convert_test.simf b/simf/u1_convert_test.simf index 0451d9a..9fc035e 100644 --- a/simf/u1_convert_test.simf +++ b/simf/u1_convert_test.simf @@ -8,7 +8,15 @@ use crate::lib::u1::convert::{ u1_to_bool }; use crate::lib::u128::math::eq_128; -use crate::lib::asserts::assert_eq_bool; +use crate::lib::asserts::{ + assert_eq_bool, + assert_eq_8, + assert_eq_16, + assert_eq_32, + assert_eq_64, + assert_eq_128, + assert_eq_256 +}; use crate::helper::if_test_this_function; fn main() { @@ -24,7 +32,7 @@ fn main() { let (_, _, _, expected): (u16, u16, u16, u16) = ::into(expected); let (_, expected): (u8, u8) = ::into(expected); - assert!(jet::eq_8(u1_to_u8(a), expected)); + assert_eq_8(u1_to_u8(a), expected); }, false => (), }; @@ -34,7 +42,7 @@ fn main() { let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); let (_, _, _, expected): (u16, u16, u16, u16) = ::into(expected); - assert!(jet::eq_16(u1_to_u16(a), expected)); + assert_eq_16(u1_to_u16(a), expected); }, false => (), }; @@ -44,7 +52,7 @@ fn main() { let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); let (_, expected): (u32, u32) = ::into(expected); - assert!(jet::eq_32(u1_to_u32(a), expected)); + assert_eq_32(u1_to_u32(a), expected); }, false => (), }; @@ -53,7 +61,7 @@ fn main() { true => { let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); - assert!(jet::eq_64(u1_to_u64(a), expected)); + assert_eq_64(u1_to_u64(a), expected); }, false => (), }; @@ -62,14 +70,14 @@ fn main() { true => { let (_, expected): (u128, u128) = ::into(expected); - assert!(eq_128(u1_to_u128(a), expected)); + assert_eq_128(u1_to_u128(a), expected); }, false => (), }; match if_test_this_function(5, fn_idx) { true => { - assert!(jet::eq_256(u1_to_u256(a), expected)); + assert_eq_256(u1_to_u256(a), expected); }, false => (), }; diff --git a/simf/u32_convert_test.simf b/simf/u32_convert_test.simf index f96ddc5..b4fdd59 100644 --- a/simf/u32_convert_test.simf +++ b/simf/u32_convert_test.simf @@ -9,7 +9,14 @@ use crate::lib::u32::convert::{ safe_u32_to_u16 }; use crate::lib::u128::math::eq_128; -use crate::lib::asserts::{assert_eq_1, assert_eq_8, assert_eq_16}; +use crate::lib::asserts::{ + assert_eq_1, + assert_eq_8, + assert_eq_16, + assert_eq_64, + assert_eq_128, + assert_eq_256 +}; use crate::helper::if_test_this_function; fn main() { @@ -23,7 +30,7 @@ fn main() { true => { let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); - assert!(jet::eq_64(u32_to_u64(a), expected)); + assert_eq_64(u32_to_u64(a), expected); }, false => {}, }; @@ -32,14 +39,14 @@ fn main() { true => { let (_, expected): (u128, u128) = ::into(expected); - assert!(eq_128(u32_to_u128(a), expected)); + assert_eq_128(u32_to_u128(a), expected); }, false => {}, }; match if_test_this_function(2, fn_idx) { true => { - assert!(jet::eq_256(u32_to_u256(a), expected)); + assert_eq_256(u32_to_u256(a), expected); }, false => {}, }; diff --git a/simf/u8_convert_test.simf b/simf/u8_convert_test.simf index 92cbf8d..e788315 100644 --- a/simf/u8_convert_test.simf +++ b/simf/u8_convert_test.simf @@ -7,9 +7,15 @@ use crate::lib::u8::convert::{ split_u8_to_u1, safe_u8_to_u1 }; -// use crate::lib::u256::{split_256_into_64}; TODO: uncomment when u256 functions are merged use crate::lib::u128::math::eq_128; -use crate::lib::asserts::assert_eq_1; +use crate::lib::asserts::{ + assert_eq_1, + assert_eq_16, + assert_eq_32, + assert_eq_64, + assert_eq_128, + assert_eq_256 +}; use crate::helper::if_test_this_function; fn main() { @@ -24,7 +30,7 @@ fn main() { let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); let (_, _, _, expected): (u16, u16, u16, u16) = ::into(expected); - assert!(jet::eq_16(u8_to_u16(a), expected)); + assert_eq_16(u8_to_u16(a), expected); }, false => (), }; @@ -34,7 +40,7 @@ fn main() { let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); let (_, expected): (u32, u32) = ::into(expected); - assert!(jet::eq_32(u8_to_u32(a), expected)); + assert_eq_32(u8_to_u32(a), expected); }, false => (), }; @@ -43,7 +49,7 @@ fn main() { true => { let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); - assert!(jet::eq_64(u8_to_u64(a), expected)); + assert_eq_64(u8_to_u64(a), expected); }, false => (), }; @@ -52,14 +58,14 @@ fn main() { true => { let (_, expected): (u128, u128) = ::into(expected); - assert!(eq_128(u8_to_u128(a), expected)); + assert_eq_128(u8_to_u128(a), expected); }, false => (), }; match if_test_this_function(4, fn_idx) { true => { - assert!(jet::eq_256(u8_to_u256(a), expected)); + assert_eq_256(u8_to_u256(a), expected); }, false => (), }; From 2503f40d9e46d0260555a2471abbd78122d59ede Mon Sep 17 00:00:00 2001 From: aritkulova Date: Fri, 14 Aug 2026 20:18:06 +0300 Subject: [PATCH 7/9] fixed path --- simf/lib/u256.simf | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/simf/lib/u256.simf b/simf/lib/u256.simf index fcbe0a8..262dea1 100644 --- a/simf/lib/u256.simf +++ b/simf/lib/u256.simf @@ -1,5 +1,5 @@ use crate::lib::binary::{not, and}; -use crate::lib::u128::{ +use crate::lib::u128::math::{ and_128, or_128, eq_128, From 5540a750aff482525f2aee5897153f4e414a6a75 Mon Sep 17 00:00:00 2001 From: aritkulova Date: Sat, 15 Aug 2026 22:04:18 +0300 Subject: [PATCH 8/9] splitted math file into comparison and bit --- simf/lib/asserts.simf | 2 +- simf/lib/u128/bit.simf | 79 ++++++++++ simf/lib/u128/comparison.simf | 48 ++++++ simf/lib/u128/convert.simf | 2 +- simf/lib/u128/math.simf | 124 +-------------- simf/lib/u256.simf | 10 +- ...thmetic.simf => u128_basic_math_test.simf} | 34 ++--- simf/u128_math_test.simf | 14 +- simf/u128_test_bits.simf | 2 +- simf/u128_test_compare.simf | 20 +++ simf/u16_convert_test.simf | 2 +- simf/u1_convert_test.simf | 2 +- simf/u32_convert_test.simf | 2 +- simf/u8_convert_test.simf | 2 +- tests/u128_convert_test.rs | 6 +- tests/u128_test_compare.rs | 142 ++++++++++++++++++ 16 files changed, 321 insertions(+), 170 deletions(-) create mode 100644 simf/lib/u128/bit.simf create mode 100644 simf/lib/u128/comparison.simf rename simf/{u128_test_arithmetic.simf => u128_basic_math_test.simf} (75%) create mode 100644 simf/u128_test_compare.simf create mode 100644 tests/u128_test_compare.rs diff --git a/simf/lib/asserts.simf b/simf/lib/asserts.simf index 009c94c..1c6ad58 100644 --- a/simf/lib/asserts.simf +++ b/simf/lib/asserts.simf @@ -1,4 +1,4 @@ -use crate::lib::u128::math::eq_128; +use crate::lib::u128::bit::eq_128; /// Asserts that two `u1` are equal pub fn assert_eq_1(a: u1, b: u1) { diff --git a/simf/lib/u128/bit.simf b/simf/lib/u128/bit.simf new file mode 100644 index 0000000..1e4f0e9 --- /dev/null +++ b/simf/lib/u128/bit.simf @@ -0,0 +1,79 @@ +use crate::lib::binary::and; + +/// Bit logic + +/// Bitwise AND of two 128-bit values +pub fn and_128(a: u128, b: u128) -> u128 { + let (a_high, a_low): (u64, u64) = ::into(a); + let (b_high, b_low): (u64, u64) = ::into(b); + + <(u64, u64)>::into((jet::and_64(a_high, b_high), jet::and_64(a_low, b_low))) +} + +/// Bitwise OR of two 128-bit values +pub fn or_128(a: u128, b: u128) -> u128 { + let (a_high, a_low): (u64, u64) = ::into(a); + let (b_high, b_low): (u64, u64) = ::into(b); + + <(u64, u64)>::into((jet::or_64(a_high, b_high), jet::or_64(a_low, b_low))) +} + +/// Checks if two 128-bit values are equal +pub fn eq_128(a: u128, b: u128) -> bool { + let (a_high, a_low): (u64, u64) = ::into(a); + let (b_high, b_low): (u64, u64) = ::into(b); + + and(jet::eq_64(a_high, b_high), jet::eq_64(a_low, b_low)) +} + +/// Left-shift a 128-bit value by the given amount. Bits are filled with zeroes +pub fn left_shift_128(shift: u8, a: u128) -> u128 { + match jet::is_zero_8(shift) { + true => a, + false => { + let (a_high, a_low): (u64, u64) = ::into(a); + + match jet::lt_8(shift, 64) { + true => { + let (_, low_to_high_amount): (bool, u8) = jet::subtract_8(64, shift); // shift < 64 + let shifted_bits: u64 = jet::right_shift_64(low_to_high_amount, a_low); + + let res_high: u64 = jet::or_64(jet::left_shift_64(shift, a_high), shifted_bits); + + <(u64, u64)>::into((res_high, jet::left_shift_64(shift, a_low))) + }, + false => { + let (_, shift): (bool, u8) = jet::subtract_8(shift, 64); // shift >= 64 + + <(u64, u64)>::into((jet::left_shift_64(shift, a_low), 0)) + } + } + } + } +} + +/// Right-shift a 128-bit value by the given amount. Bits are filled with zeroes +pub fn right_shift_128(shift: u8, a: u128) -> u128 { + match jet::is_zero_8(shift) { + true => a, + false => { + let (a_high, a_low): (u64, u64) = ::into(a); + + match jet::lt_8(shift, 64) { + true => { + let (_, high_to_low_amount): (bool, u8) = jet::subtract_8(64, shift); // shift < 64 + let shifted_bits: u64 = jet::left_shift_64(high_to_low_amount, a_high); + + let res_low: u64 = jet::or_64(jet::right_shift_64(shift, a_low), shifted_bits); + + <(u64, u64)>::into((jet::right_shift_64(shift, a_high), res_low)) + }, + false => { + let (_, shift): (bool, u8) = jet::subtract_8(shift, 64); // shift >= 64 + + <(u64, u64)>::into((0, jet::right_shift_64(shift, a_high))) + } + } + } + } +} diff --git a/simf/lib/u128/comparison.simf b/simf/lib/u128/comparison.simf new file mode 100644 index 0000000..25c0b58 --- /dev/null +++ b/simf/lib/u128/comparison.simf @@ -0,0 +1,48 @@ +use crate::lib::binary::and; + +/// Comparison operations + +/// Checks if an integer is zero +pub fn is_zero_128(a: u128) -> bool { + let (a_high, a_low): (u64, u64) = ::into(a); + + and(jet::is_zero_64(a_high), jet::is_zero_64(a_low)) +} + +/// Checks if an integer is less than another integer +pub fn lt_128(a: u128, b: u128) -> bool { + let (a_high, a_low): (u64, u64) = ::into(a); + let (b_high, b_low): (u64, u64) = ::into(b); + + match jet::lt_64(a_high, b_high) { + true => true, + false => match jet::eq_64(a_high, b_high) { + true => jet::lt_64(a_low, b_low), + false => false, + }, + } +} + +/// Checks if an integer is less than or equal to another integer +pub fn le_128(a: u128, b: u128) -> bool { + let (a_high, a_low): (u64, u64) = ::into(a); + let (b_high, b_low): (u64, u64) = ::into(b); + + match jet::lt_64(a_high, b_high) { + true => true, + false => match jet::eq_64(a_high, b_high) { + true => jet::le_64(a_low, b_low), + false => false, + }, + } +} + +/// Check if an integer is greater than another integer +pub fn gt_128(a: u128, b: u128) -> bool { + lt_128(b, a) +} + +/// Check if an integer is greater than or equal to another integer +pub fn ge_128(a: u128, b: u128) -> bool { + le_128(b, a) +} diff --git a/simf/lib/u128/convert.simf b/simf/lib/u128/convert.simf index 4f503e9..4b6aea9 100644 --- a/simf/lib/u128/convert.simf +++ b/simf/lib/u128/convert.simf @@ -3,7 +3,7 @@ use crate::lib::u8::convert::u8_to_u128; use crate::lib::u16::convert::u16_to_u128; use crate::lib::u32::convert::u32_to_u128; use crate::lib::u64::convert::u64_to_u128; -use crate::lib::u128::math::le_128; +use crate::lib::u128::comparison::le_128; /// Widening uint conversions diff --git a/simf/lib/u128/math.simf b/simf/lib/u128/math.simf index 342de61..1909850 100644 --- a/simf/lib/u128/math.simf +++ b/simf/lib/u128/math.simf @@ -1,130 +1,8 @@ use crate::lib::binary::{not, or, and}; - -/// Bit logic - -/// Bitwise AND of two 128-bit values -pub fn and_128(a: u128, b: u128) -> u128 { - let (a_high, a_low): (u64, u64) = ::into(a); - let (b_high, b_low): (u64, u64) = ::into(b); - - <(u64, u64)>::into((jet::and_64(a_high, b_high), jet::and_64(a_low, b_low))) -} - -/// Bitwise OR of two 128-bit values -pub fn or_128(a: u128, b: u128) -> u128 { - let (a_high, a_low): (u64, u64) = ::into(a); - let (b_high, b_low): (u64, u64) = ::into(b); - - <(u64, u64)>::into((jet::or_64(a_high, b_high), jet::or_64(a_low, b_low))) -} - -/// Checks if two 128-bit values are equal -pub fn eq_128(a: u128, b: u128) -> bool { - let (a_high, a_low): (u64, u64) = ::into(a); - let (b_high, b_low): (u64, u64) = ::into(b); - - and(jet::eq_64(a_high, b_high), jet::eq_64(a_low, b_low)) -} - -/// Left-shift a 128-bit value by the given amount. Bits are filled with zeroes -pub fn left_shift_128(shift: u8, a: u128) -> u128 { - match jet::is_zero_8(shift) { - true => a, - false => { - let (a_high, a_low): (u64, u64) = ::into(a); - - match jet::lt_8(shift, 64) { - true => { - let (_, low_to_high_amount): (bool, u8) = jet::subtract_8(64, shift); // shift < 64 - let shifted_bits: u64 = jet::right_shift_64(low_to_high_amount, a_low); - - let res_high: u64 = jet::or_64(jet::left_shift_64(shift, a_high), shifted_bits); - - <(u64, u64)>::into((res_high, jet::left_shift_64(shift, a_low))) - }, - false => { - let (_, shift): (bool, u8) = jet::subtract_8(shift, 64); // shift >= 64 - - <(u64, u64)>::into((jet::left_shift_64(shift, a_low), 0)) - } - } - } - } -} - -/// Right-shift a 128-bit value by the given amount. Bits are filled with zeroes -pub fn right_shift_128(shift: u8, a: u128) -> u128 { - match jet::is_zero_8(shift) { - true => a, - false => { - let (a_high, a_low): (u64, u64) = ::into(a); - - match jet::lt_8(shift, 64) { - true => { - let (_, high_to_low_amount): (bool, u8) = jet::subtract_8(64, shift); // shift < 64 - let shifted_bits: u64 = jet::left_shift_64(high_to_low_amount, a_high); - - let res_low: u64 = jet::or_64(jet::right_shift_64(shift, a_low), shifted_bits); - - <(u64, u64)>::into((jet::right_shift_64(shift, a_high), res_low)) - }, - false => { - let (_, shift): (bool, u8) = jet::subtract_8(shift, 64); // shift >= 64 - - <(u64, u64)>::into((0, jet::right_shift_64(shift, a_high))) - } - } - } - } -} +use crate::lib::u128::comparison::{is_zero_128, lt_128}; /// Arithmetic -/// Checks if an integer is zero -pub fn is_zero_128(a: u128) -> bool { - let (a_high, a_low): (u64, u64) = ::into(a); - - and(jet::is_zero_64(a_high), jet::is_zero_64(a_low)) -} - -/// Checks if an integer is less than another integer -pub fn lt_128(a: u128, b: u128) -> bool { - let (a_high, a_low): (u64, u64) = ::into(a); - let (b_high, b_low): (u64, u64) = ::into(b); - - match jet::lt_64(a_high, b_high) { - true => true, - false => match jet::eq_64(a_high, b_high) { - true => jet::lt_64(a_low, b_low), - false => false, - }, - } -} - -/// Checks if an integer is less than or equal to another integer -pub fn le_128(a: u128, b: u128) -> bool { - let (a_high, a_low): (u64, u64) = ::into(a); - let (b_high, b_low): (u64, u64) = ::into(b); - - match jet::lt_64(a_high, b_high) { - true => true, - false => match jet::eq_64(a_high, b_high) { - true => jet::le_64(a_low, b_low), - false => false, - }, - } -} - -/// Check if an integer is greater than another integer -pub fn gt_128(a: u128, b: u128) -> bool { - lt_128(b, a) -} - -/// Check if an integer is greater than or equal to another integer -pub fn ge_128(a: u128, b: u128) -> bool { - le_128(b, a) -} - /// Adds two integers and returns the carry pub fn add_128(a: u128, b: u128) -> (bool, u128) { let (a_high, a_low): (u64, u64) = ::into(a); diff --git a/simf/lib/u256.simf b/simf/lib/u256.simf index 262dea1..95c8d79 100644 --- a/simf/lib/u256.simf +++ b/simf/lib/u256.simf @@ -1,13 +1,5 @@ use crate::lib::binary::{not, and}; use crate::lib::u128::math::{ - and_128, - or_128, - eq_128, - left_shift_128, - right_shift_128, - is_zero_128, - lt_128, - le_128, add_128, full_add_128, sub_128, @@ -20,6 +12,8 @@ use crate::lib::u128::math::{ div_mod_128, div_mod_128_64 }; +use crate::lib::u128::bit::{and_128, or_128, eq_128, left_shift_128, right_shift_128}; +use crate::lib::u128::comparison::{is_zero_128, lt_128, le_128}; /// Bit logic diff --git a/simf/u128_test_arithmetic.simf b/simf/u128_basic_math_test.simf similarity index 75% rename from simf/u128_test_arithmetic.simf rename to simf/u128_basic_math_test.simf index e583078..17d5992 100644 --- a/simf/u128_test_arithmetic.simf +++ b/simf/u128_basic_math_test.simf @@ -1,8 +1,4 @@ use crate::lib::u128::math::{ - eq_128, - is_zero_128, - lt_128, - le_128, add_128, add_128_64, full_add_128, @@ -16,6 +12,7 @@ use crate::lib::u128::math::{ div_mod_128, div_128 }; +use crate::lib::u128::bit::eq_128; use crate::helper::{if_test_this_function, assert_bool}; /// Asserts a result equals expected u128 and bool values. @@ -37,22 +34,17 @@ fn main() { let expected_bool: bool = witness::EXPECTED_BOOL; let second_expected: u128 = witness::SECOND_EXPECTED; // for cases where the result is a 256 bit value - let third_expected: u128 = witness::THIRD_EXPECTED; // for cases where the result is 256 bit + 128 bit values /// Arithmetic - match if_test_this_function(0, fn_idx) { true => { assert_bool(is_zero_128(a), expected_bool); }, false => (), }; - match if_test_this_function(1, fn_idx) { true => { assert_bool(lt_128(a, b), expected_bool); }, false => (), }; - match if_test_this_function(2, fn_idx) { true => { assert_bool(le_128(a, b), expected_bool); }, false => (), }; + match if_test_this_function(0, fn_idx) { true => { assert_eq_uint_bool(add_128(a, b), unwrap(expected), expected_bool); }, false => (), }; + match if_test_this_function(1, fn_idx) { true => { let (_, b): (u64, u64) = ::into(b); assert_eq_uint_bool(add_128_64(a, b), unwrap(expected), expected_bool); }, false => (), }; + match if_test_this_function(2, fn_idx) { true => { assert_eq_uint_bool(full_add_128(eq_128(second_expected, 1), a, b), unwrap(expected), expected_bool); }, false => (), }; - match if_test_this_function(3, fn_idx) { true => { assert_eq_uint_bool(add_128(a, b), unwrap(expected), expected_bool); }, false => (), }; - match if_test_this_function(4, fn_idx) { true => { let (_, b): (u64, u64) = ::into(b); assert_eq_uint_bool(add_128_64(a, b), unwrap(expected), expected_bool); }, false => (), }; - match if_test_this_function(5, fn_idx) { true => { assert_eq_uint_bool(full_add_128(eq_128(second_expected, 1), a, b), unwrap(expected), expected_bool); }, false => (), }; + match if_test_this_function(3, fn_idx) { true => { assert_eq_uint_bool(sub_128(a, b), unwrap(expected), expected_bool); }, false => (), }; + match if_test_this_function(4, fn_idx) { true => { assert_eq_uint_bool(full_sub_128(eq_128(second_expected, 1), a, b), unwrap(expected), expected_bool); }, false => (), }; - match if_test_this_function(6, fn_idx) { true => { assert_eq_uint_bool(sub_128(a, b), unwrap(expected), expected_bool); }, false => (), }; - match if_test_this_function(7, fn_idx) { true => { assert_eq_uint_bool(full_sub_128(eq_128(second_expected, 1), a, b), unwrap(expected), expected_bool); }, false => (), }; - - match if_test_this_function(8, fn_idx) { + match if_test_this_function(5, fn_idx) { true => { let result: u256 = mul_128(a, b); @@ -64,7 +56,7 @@ fn main() { false => (), }; - match if_test_this_function(9, fn_idx) { + match if_test_this_function(6, fn_idx) { true => { let (_, b): (u64, u64) = ::into(b); let result: u256 = mul_128_64(a, b); @@ -77,7 +69,7 @@ fn main() { false => (), }; - match if_test_this_function(10, fn_idx) { + match if_test_this_function(7, fn_idx) { true => { let norm: u64 = calculate_normalizer_base_64(b, expected_bool); @@ -88,7 +80,7 @@ fn main() { false => (), }; - match if_test_this_function(11, fn_idx) { + match if_test_this_function(8, fn_idx) { true => { let (_, u2): (u64, u64) = ::into(a); let (u1, u0): (u64, u64) = ::into(b); @@ -103,7 +95,7 @@ fn main() { false => (), }; - match if_test_this_function(12, fn_idx) { + match if_test_this_function(9, fn_idx) { true => { let (_, b): (u64, u64) = ::into(b); let (_, expected_r): (u64, u64) = ::into(second_expected); @@ -116,7 +108,7 @@ fn main() { false => (), }; - match if_test_this_function(13, fn_idx) { + match if_test_this_function(10, fn_idx) { true => { let (q, r): (u128, u128) = div_mod_128(a, b); @@ -126,5 +118,5 @@ fn main() { false => (), }; - match if_test_this_function(14, fn_idx) { true => { assert!(eq_128(div_128(a, b), unwrap(expected))); }, false => (), }; + match if_test_this_function(11, fn_idx) { true => { assert!(eq_128(div_128(a, b), unwrap(expected))); }, false => (), }; } diff --git a/simf/u128_math_test.simf b/simf/u128_math_test.simf index bf2024c..1c73009 100644 --- a/simf/u128_math_test.simf +++ b/simf/u128_math_test.simf @@ -6,11 +6,9 @@ use crate::lib::u128::math::{ checked_mul_128, safe_mul_128, checked_div_128, - safe_div_128, - eq_128, - gt_128, - ge_128 + safe_div_128 }; +use crate::lib::u128::comparison::{gt_128, ge_128}; use crate::lib::asserts::{assert_none_128, assert_eq_128}; use crate::lib::binary::not; use crate::helper::if_test_this_function; @@ -45,19 +43,19 @@ fn main() { // add match if_test_this_function(0, fn_idx) { true => { assert_eq_opt(checked_add_128(a, b), expected); }, false => (), }; - match if_test_this_function(1, fn_idx) { true => { assert!(eq_128(safe_add_128(a, b), unwrap(expected))); }, false => (), }; + match if_test_this_function(1, fn_idx) { true => {assert_eq_128(safe_add_128(a, b), unwrap(expected)); }, false => (), }; // sub match if_test_this_function(2, fn_idx) { true => { assert_eq_opt(checked_sub_128(a, b), expected); }, false => (), }; - match if_test_this_function(3, fn_idx) { true => { assert!(eq_128(safe_sub_128(a, b), unwrap(expected))); }, false => (), }; + match if_test_this_function(3, fn_idx) { true => {assert_eq_128(safe_sub_128(a, b), unwrap(expected)); }, false => (), }; // mul match if_test_this_function(4, fn_idx) { true => { assert_eq_opt(checked_mul_128(a, b), expected); }, false => (), }; - match if_test_this_function(5, fn_idx) { true => { assert!(eq_128(safe_mul_128(a, b), unwrap(expected))); }, false => (), }; + match if_test_this_function(5, fn_idx) { true => {assert_eq_128(safe_mul_128(a, b), unwrap(expected)); }, false => (), }; // div match if_test_this_function(6, fn_idx) { true => { assert_eq_opt(checked_div_128(a, b), expected); }, false => (), }; - match if_test_this_function(7, fn_idx) { true => { assert!(eq_128(safe_div_128(a, b), unwrap(expected))); }, false => (), }; + match if_test_this_function(7, fn_idx) { true => {assert_eq_128(safe_div_128(a, b), unwrap(expected)); }, false => (), }; // gt, ge match if_test_this_function(8, fn_idx) { true => { assert_bool_by_opt(gt_128(a, b), expected); }, false => (), }; diff --git a/simf/u128_test_bits.simf b/simf/u128_test_bits.simf index 85d6084..b3ea239 100644 --- a/simf/u128_test_bits.simf +++ b/simf/u128_test_bits.simf @@ -1,4 +1,4 @@ -use crate::lib::u128::math::{and_128, or_128, eq_128, left_shift_128, right_shift_128}; +use crate::lib::u128::bit::{and_128, or_128, eq_128, left_shift_128, right_shift_128}; use crate::helper::{if_test_this_function, assert_bool}; fn main() { diff --git a/simf/u128_test_compare.simf b/simf/u128_test_compare.simf new file mode 100644 index 0000000..e9badb1 --- /dev/null +++ b/simf/u128_test_compare.simf @@ -0,0 +1,20 @@ +use crate::lib::u128::comparison::{ + is_zero_128, + lt_128, + le_128, +}; +use crate::helper::{if_test_this_function, assert_bool}; + +fn main() { + let fn_idx: u8 = witness::FUNCTION_INDEX; + + let a: u128 = witness::FIRST_ARG; + let b: u128 = witness::SECOND_ARG; + let expected_bool: bool = witness::EXPECTED_BOOL; + + /// Comparison operations + + match if_test_this_function(0, fn_idx) { true => { assert_bool(is_zero_128(a), expected_bool); }, false => (), }; + match if_test_this_function(1, fn_idx) { true => { assert_bool(lt_128(a, b), expected_bool); }, false => (), }; + match if_test_this_function(2, fn_idx) { true => { assert_bool(le_128(a, b), expected_bool); }, false => (), }; +} diff --git a/simf/u16_convert_test.simf b/simf/u16_convert_test.simf index 3c7ce54..ed4c7ac 100644 --- a/simf/u16_convert_test.simf +++ b/simf/u16_convert_test.simf @@ -7,7 +7,7 @@ use crate::lib::u16::convert::{ safe_u16_to_u1, safe_u16_to_u8 }; -use crate::lib::u128::math::eq_128; +use crate::lib::u128::bit::eq_128; use crate::lib::asserts::{ assert_eq_1, assert_eq_8, diff --git a/simf/u1_convert_test.simf b/simf/u1_convert_test.simf index 9fc035e..8263efc 100644 --- a/simf/u1_convert_test.simf +++ b/simf/u1_convert_test.simf @@ -7,7 +7,7 @@ use crate::lib::u1::convert::{ u1_to_u256, u1_to_bool }; -use crate::lib::u128::math::eq_128; +use crate::lib::u128::bit::eq_128; use crate::lib::asserts::{ assert_eq_bool, assert_eq_8, diff --git a/simf/u32_convert_test.simf b/simf/u32_convert_test.simf index b4fdd59..ae4b69a 100644 --- a/simf/u32_convert_test.simf +++ b/simf/u32_convert_test.simf @@ -8,7 +8,7 @@ use crate::lib::u32::convert::{ safe_u32_to_u8, safe_u32_to_u16 }; -use crate::lib::u128::math::eq_128; +use crate::lib::u128::bit::eq_128; use crate::lib::asserts::{ assert_eq_1, assert_eq_8, diff --git a/simf/u8_convert_test.simf b/simf/u8_convert_test.simf index e788315..11d8387 100644 --- a/simf/u8_convert_test.simf +++ b/simf/u8_convert_test.simf @@ -7,7 +7,7 @@ use crate::lib::u8::convert::{ split_u8_to_u1, safe_u8_to_u1 }; -use crate::lib::u128::math::eq_128; +use crate::lib::u128::bit::eq_128; use crate::lib::asserts::{ assert_eq_1, assert_eq_16, diff --git a/tests/u128_convert_test.rs b/tests/u128_convert_test.rs index 3e4e2ec..bf42042 100644 --- a/tests/u128_convert_test.rs +++ b/tests/u128_convert_test.rs @@ -58,8 +58,8 @@ mod u128_convert_test { Expect::Ok, ) } - - #[simplex::test] + + #[simplex::test] fn u128_convert_test_split_u128_into_u8(context: simplex::TestContext) -> anyhow::Result<()> { let a = rand::thread_rng().gen_range(0..=u128::MAX); @@ -75,7 +75,7 @@ mod u128_convert_test { ) } - #[simplex::test] + #[simplex::test] fn u128_convert_test_split_u128_into_u16(context: simplex::TestContext) -> anyhow::Result<()> { let a = rand::thread_rng().gen_range(0..=u128::MAX); diff --git a/tests/u128_test_compare.rs b/tests/u128_test_compare.rs new file mode 100644 index 0000000..24e1187 --- /dev/null +++ b/tests/u128_test_compare.rs @@ -0,0 +1,142 @@ +mod common; + +use rand::Rng; + +use common::core::{Expect, run}; + +use simplicityhl_std::artifacts::u128_test_compare::U128TestCompareProgram; +use simplicityhl_std::artifacts::u128_test_compare::derived_u128_test_compare::{ + U128TestCompareArguments, U128TestCompareWitness, +}; + +enum FunctionToTest { + IsZero128, + Lt128, + Le128, +} + +#[inline] +fn op(o: FunctionToTest) -> u8 { + o as u8 +} + +const DEFAULT_EXPECTED: u128 = 0; + +fn program() -> U128TestCompareProgram { + U128TestCompareProgram::new(U128TestCompareArguments {}) +} + +fn build_witness(function: u8, a: u128, b: u128, expected_bool: bool) -> U128TestCompareWitness { + U128TestCompareWitness { + function_index: function, + first_arg: a, + second_arg: b, + expected_bool, + } +} + +mod u128_tests_arithmetic { + use super::*; + + #[simplex::test] + fn u128_test_is_zero_128_true(context: simplex::TestContext) -> anyhow::Result<()> { + let a = 0; + + run( + &context, + program(), + build_witness(op(FunctionToTest::IsZero128), a, DEFAULT_EXPECTED, true), + Expect::Ok, + ) + } + + #[simplex::test] + fn u128_test_is_zero_128_false(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(1..=u128::MAX); + + run( + &context, + program(), + build_witness(op(FunctionToTest::IsZero128), a, DEFAULT_EXPECTED, false), + Expect::Ok, + ) + } + + #[simplex::test] + fn u128_test_lt_128_less(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..u128::MAX); + let b = a + 1; + + run( + &context, + program(), + build_witness(op(FunctionToTest::Lt128), a, b, true), + Expect::Ok, + ) + } + + #[simplex::test] + fn u128_test_lt_128_eq(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..u128::MAX); + let b = a; + + run( + &context, + program(), + build_witness(op(FunctionToTest::Lt128), a, b, false), + Expect::Ok, + ) + } + + #[simplex::test] + fn u128_test_lt_128_bigger(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(1..=u128::MAX); + let b = a - 1; + + run( + &context, + program(), + build_witness(op(FunctionToTest::Lt128), a, b, false), + Expect::Ok, + ) + } + + #[simplex::test] + fn u128_test_le_128_less(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..u128::MAX); + let b = a + 1; + + run( + &context, + program(), + build_witness(op(FunctionToTest::Le128), a, b, true), + Expect::Ok, + ) + } + + #[simplex::test] + fn u128_test_le_128_eq(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..u128::MAX); + let b = a; + + run( + &context, + program(), + build_witness(op(FunctionToTest::Le128), a, b, true), + Expect::Ok, + ) + } + + #[simplex::test] + fn u128_test_le_128_bigger(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(1..=u128::MAX); + let b = a - 1; + + run( + &context, + program(), + build_witness(op(FunctionToTest::Le128), a, b, false), + Expect::Ok, + ) + } +} From 9e486fb4fd63eacc9ce6d09c58c818c076b546ff Mon Sep 17 00:00:00 2001 From: aritkulova Date: Sat, 15 Aug 2026 22:05:02 +0300 Subject: [PATCH 9/9] renamed arithmetic test to basic math test for avoid ambiguity --- ..._arithmetic.rs => u128_basic_math_test.rs} | 225 +----------------- 1 file changed, 7 insertions(+), 218 deletions(-) rename tests/{u128_test_arithmetic.rs => u128_basic_math_test.rs} (81%) diff --git a/tests/u128_test_arithmetic.rs b/tests/u128_basic_math_test.rs similarity index 81% rename from tests/u128_test_arithmetic.rs rename to tests/u128_basic_math_test.rs index 5fb5f95..133f2bc 100644 --- a/tests/u128_test_arithmetic.rs +++ b/tests/u128_basic_math_test.rs @@ -6,15 +6,12 @@ use rand::Rng; use crate::common::helper::DEFAULT_BOOL; use common::core::{Expect, run}; -use simplicityhl_std::artifacts::u128_test_arithmetic::U128TestArithmeticProgram; -use simplicityhl_std::artifacts::u128_test_arithmetic::derived_u128_test_arithmetic::{ - U128TestArithmeticArguments, U128TestArithmeticWitness, +use simplicityhl_std::artifacts::u128_basic_math_test::U128BasicMathTestProgram; +use simplicityhl_std::artifacts::u128_basic_math_test::derived_u128_basic_math_test::{ + U128BasicMathTestArguments, U128BasicMathTestWitness, }; enum FunctionToTest { - IsZero128, - Lt128, - Le128, Add128, Add128_64, FullAdd128, @@ -36,8 +33,8 @@ fn op(o: FunctionToTest) -> u8 { const DEFAULT_EXPECTED: u128 = 0; -fn program() -> U128TestArithmeticProgram { - U128TestArithmeticProgram::new(U128TestArithmeticArguments {}) +fn program() -> U128BasicMathTestProgram { + U128BasicMathTestProgram::new(U128BasicMathTestArguments {}) } fn build_witness( @@ -47,16 +44,14 @@ fn build_witness( expected: Option, expected_bool: bool, second_expected: u128, - third_expected: u128, -) -> U128TestArithmeticWitness { - U128TestArithmeticWitness { +) -> U128BasicMathTestWitness { + U128BasicMathTestWitness { function_index: function, first_arg: a, second_arg: b, expected, expected_bool, second_expected, - third_expected, } } @@ -70,172 +65,6 @@ fn split_helper(a: U256) -> (u128, u128) { mod u128_tests_arithmetic { use super::*; - #[simplex::test] - fn u128_test_is_zero_128_true(context: simplex::TestContext) -> anyhow::Result<()> { - let a = 0; - - run( - &context, - program(), - build_witness( - op(FunctionToTest::IsZero128), - a, - DEFAULT_EXPECTED, - Some(DEFAULT_EXPECTED), - true, - DEFAULT_EXPECTED, - DEFAULT_EXPECTED, - ), - Expect::Ok, - ) - } - - #[simplex::test] - fn u128_test_is_zero_128_false(context: simplex::TestContext) -> anyhow::Result<()> { - let a = rand::thread_rng().gen_range(1..=u128::MAX); - - run( - &context, - program(), - build_witness( - op(FunctionToTest::IsZero128), - a, - DEFAULT_EXPECTED, - Some(DEFAULT_EXPECTED), - false, - DEFAULT_EXPECTED, - DEFAULT_EXPECTED, - ), - Expect::Ok, - ) - } - - #[simplex::test] - fn u128_test_lt_128_less(context: simplex::TestContext) -> anyhow::Result<()> { - let a = rand::thread_rng().gen_range(0..u128::MAX); - let b = a + 1; - - run( - &context, - program(), - build_witness( - op(FunctionToTest::Lt128), - a, - b, - Some(DEFAULT_EXPECTED), - true, - DEFAULT_EXPECTED, - DEFAULT_EXPECTED, - ), - Expect::Ok, - ) - } - - #[simplex::test] - fn u128_test_lt_128_eq(context: simplex::TestContext) -> anyhow::Result<()> { - let a = rand::thread_rng().gen_range(0..u128::MAX); - let b = a; - - run( - &context, - program(), - build_witness( - op(FunctionToTest::Lt128), - a, - b, - Some(DEFAULT_EXPECTED), - false, - DEFAULT_EXPECTED, - DEFAULT_EXPECTED, - ), - Expect::Ok, - ) - } - - #[simplex::test] - fn u128_test_lt_128_bigger(context: simplex::TestContext) -> anyhow::Result<()> { - let a = rand::thread_rng().gen_range(1..=u128::MAX); - let b = a - 1; - - run( - &context, - program(), - build_witness( - op(FunctionToTest::Lt128), - a, - b, - Some(DEFAULT_EXPECTED), - false, - DEFAULT_EXPECTED, - DEFAULT_EXPECTED, - ), - Expect::Ok, - ) - } - - #[simplex::test] - fn u128_test_le_128_less(context: simplex::TestContext) -> anyhow::Result<()> { - let a = rand::thread_rng().gen_range(0..u128::MAX); - let b = a + 1; - - run( - &context, - program(), - build_witness( - op(FunctionToTest::Le128), - a, - b, - Some(DEFAULT_EXPECTED), - true, - DEFAULT_EXPECTED, - DEFAULT_EXPECTED, - ), - Expect::Ok, - ) - } - - #[simplex::test] - fn u128_test_le_128_eq(context: simplex::TestContext) -> anyhow::Result<()> { - let a = rand::thread_rng().gen_range(0..u128::MAX); - let b = a; - - run( - &context, - program(), - build_witness( - op(FunctionToTest::Le128), - a, - b, - Some(DEFAULT_EXPECTED), - true, - DEFAULT_EXPECTED, - DEFAULT_EXPECTED, - ), - Expect::Ok, - ) - } - - #[simplex::test] - fn u128_test_le_128_bigger(context: simplex::TestContext) -> anyhow::Result<()> { - let a = rand::thread_rng().gen_range(1..=u128::MAX); - let b = a - 1; - - run( - &context, - program(), - build_witness( - op(FunctionToTest::Le128), - a, - b, - Some(DEFAULT_EXPECTED), - false, - DEFAULT_EXPECTED, - DEFAULT_EXPECTED, - ), - Expect::Ok, - ) - } - #[simplex::test] fn u128_test_add_128_not_overflow(context: simplex::TestContext) -> anyhow::Result<()> { let a = rand::thread_rng().gen_range(0..=u128::MAX / 2); @@ -252,7 +81,6 @@ mod u128_tests_arithmetic { Some(result), false, DEFAULT_EXPECTED, - DEFAULT_EXPECTED, ), Expect::Ok, ) @@ -274,7 +102,6 @@ mod u128_tests_arithmetic { Some(result), true, DEFAULT_EXPECTED, - DEFAULT_EXPECTED, ), Expect::Ok, ) @@ -296,7 +123,6 @@ mod u128_tests_arithmetic { Some(result), false, DEFAULT_EXPECTED, - DEFAULT_EXPECTED, ), Expect::Ok, ) @@ -318,7 +144,6 @@ mod u128_tests_arithmetic { Some(result), true, DEFAULT_EXPECTED, - DEFAULT_EXPECTED, ), Expect::Ok, ) @@ -344,7 +169,6 @@ mod u128_tests_arithmetic { Some(result), result_carry, carry_low, - DEFAULT_EXPECTED, ), Expect::Ok, ) @@ -370,7 +194,6 @@ mod u128_tests_arithmetic { Some(result), result_carry, carry_low, - DEFAULT_EXPECTED, ), Expect::Ok, ) @@ -396,7 +219,6 @@ mod u128_tests_arithmetic { Some(result), result_carry, carry_low, - DEFAULT_EXPECTED, ), Expect::Ok, ) @@ -422,7 +244,6 @@ mod u128_tests_arithmetic { Some(result), result_carry, carry_low, - DEFAULT_EXPECTED, ), Expect::Ok, ) @@ -444,7 +265,6 @@ mod u128_tests_arithmetic { Some(result), false, DEFAULT_EXPECTED, - DEFAULT_EXPECTED, ), Expect::Ok, ) @@ -464,7 +284,6 @@ mod u128_tests_arithmetic { Some(0), false, DEFAULT_EXPECTED, - DEFAULT_EXPECTED, ), Expect::Ok, ) @@ -491,7 +310,6 @@ mod u128_tests_arithmetic { Some(result), carry, DEFAULT_EXPECTED, - DEFAULT_EXPECTED, ), Expect::Ok, ) @@ -520,7 +338,6 @@ mod u128_tests_arithmetic { Some(result), carry, DEFAULT_EXPECTED, - DEFAULT_EXPECTED, ), Expect::Ok, ) @@ -541,7 +358,6 @@ mod u128_tests_arithmetic { Some(a), false, DEFAULT_EXPECTED, - DEFAULT_EXPECTED, ), Expect::Ok, ) @@ -563,7 +379,6 @@ mod u128_tests_arithmetic { Some(result), true, DEFAULT_EXPECTED, - DEFAULT_EXPECTED, ), Expect::Ok, ) @@ -589,7 +404,6 @@ mod u128_tests_arithmetic { Some(result), result_borrow, borrow_low, - DEFAULT_EXPECTED, ), Expect::Ok, ) @@ -615,7 +429,6 @@ mod u128_tests_arithmetic { Some(result), result_borrow, borrow_low, - DEFAULT_EXPECTED, ), Expect::Ok, ) @@ -639,7 +452,6 @@ mod u128_tests_arithmetic { Some(result), result_borrow, borrow_low, - DEFAULT_EXPECTED, ), Expect::Ok, ) @@ -665,7 +477,6 @@ mod u128_tests_arithmetic { Some(result - 1), result_borrow, borrow_low, - DEFAULT_EXPECTED, ), Expect::Ok, ) @@ -689,7 +500,6 @@ mod u128_tests_arithmetic { Some(result_high), DEFAULT_BOOL, result_low, - DEFAULT_EXPECTED, ), Expect::Ok, ) @@ -713,7 +523,6 @@ mod u128_tests_arithmetic { Some(result_high), DEFAULT_BOOL, result_low, - DEFAULT_EXPECTED, ), Expect::Ok, ) @@ -739,7 +548,6 @@ mod u128_tests_arithmetic { Some(norm), false, DEFAULT_EXPECTED, - DEFAULT_EXPECTED, ), Expect::Ok, ) @@ -763,7 +571,6 @@ mod u128_tests_arithmetic { Some(1), false, DEFAULT_EXPECTED, - DEFAULT_EXPECTED, ), Expect::Ok, ) @@ -790,7 +597,6 @@ mod u128_tests_arithmetic { Some(norm), true, DEFAULT_EXPECTED, - DEFAULT_EXPECTED, ), Expect::Ok, ) @@ -812,7 +618,6 @@ mod u128_tests_arithmetic { Some(DEFAULT_EXPECTED), false, DEFAULT_EXPECTED, - DEFAULT_EXPECTED, ), Expect::AssertFailed, ) @@ -834,7 +639,6 @@ mod u128_tests_arithmetic { Some(DEFAULT_EXPECTED), true, DEFAULT_EXPECTED, - DEFAULT_EXPECTED, ), Expect::AssertFailed, ) @@ -856,7 +660,6 @@ mod u128_tests_arithmetic { Some(DEFAULT_EXPECTED), false, DEFAULT_EXPECTED, - DEFAULT_EXPECTED, ), Expect::AssertFailed, ) @@ -889,7 +692,6 @@ mod u128_tests_arithmetic { Some(q), DEFAULT_BOOL, b, - DEFAULT_EXPECTED, ), Expect::Ok, ) @@ -923,7 +725,6 @@ mod u128_tests_arithmetic { Some(q), DEFAULT_BOOL, b, - DEFAULT_EXPECTED, ), Expect::AssertFailed, ) @@ -947,7 +748,6 @@ mod u128_tests_arithmetic { Some(q), DEFAULT_BOOL, r, - DEFAULT_EXPECTED, ), Expect::Ok, ) @@ -968,7 +768,6 @@ mod u128_tests_arithmetic { Some(DEFAULT_EXPECTED), DEFAULT_BOOL, DEFAULT_EXPECTED, - DEFAULT_EXPECTED, ), Expect::AssertFailed, ) @@ -992,7 +791,6 @@ mod u128_tests_arithmetic { Some(q), DEFAULT_BOOL, r, - DEFAULT_EXPECTED, ), Expect::Ok, ) @@ -1016,7 +814,6 @@ mod u128_tests_arithmetic { Some(q), DEFAULT_BOOL, r, - DEFAULT_EXPECTED, ), Expect::Ok, ) @@ -1045,7 +842,6 @@ mod u128_tests_arithmetic { Some(q), DEFAULT_BOOL, r, - DEFAULT_EXPECTED, ), Expect::Ok, ) @@ -1069,7 +865,6 @@ mod u128_tests_arithmetic { Some(q), DEFAULT_BOOL, r, - DEFAULT_EXPECTED, ), Expect::Ok, ) @@ -1096,7 +891,6 @@ mod u128_tests_arithmetic { Some(q), DEFAULT_BOOL, r, - DEFAULT_EXPECTED, ), Expect::Ok, ) @@ -1116,7 +910,6 @@ mod u128_tests_arithmetic { Some(1u128), DEFAULT_BOOL, 0u128, - DEFAULT_EXPECTED, ), Expect::Ok, ) @@ -1141,7 +934,6 @@ mod u128_tests_arithmetic { Some(1u128), DEFAULT_BOOL, u64::MAX as u128, - DEFAULT_EXPECTED, ), Expect::Ok, ) @@ -1166,7 +958,6 @@ mod u128_tests_arithmetic { Some(0u128), DEFAULT_BOOL, a, - DEFAULT_EXPECTED, ), Expect::Ok, ) @@ -1188,7 +979,6 @@ mod u128_tests_arithmetic { Some(result), DEFAULT_BOOL, DEFAULT_EXPECTED, - DEFAULT_EXPECTED, ), Expect::Ok, ) @@ -1209,7 +999,6 @@ mod u128_tests_arithmetic { Some(DEFAULT_EXPECTED), DEFAULT_BOOL, DEFAULT_EXPECTED, - DEFAULT_EXPECTED, ), Expect::AssertFailed, )