Сonvert functions for u64

simf/lib/u64/convert.simf

@@ -0,0 +1,72 @@
+/// Widening uint conversions
+
+/// Converts u64 to u128
+pub fn u64_to_u128(a: u64) -> u128 {
+    <(u64, u64)>::into((0, a))
+}
+
+/// Converts u64 to u256
+pub fn u64_to_u256(a: u64) -> u256 {
+    let a_u128: u128 = u64_to_u128(a);
+
+    <(u128, u128)>::into((0, a_u128))
+}
+
+/// Splitting uint conversions
+
+/// Splits u64 into eight u8
+pub fn split_u64_into_u8(a: u64) -> (u8, u8, u8, u8, u8, u8, u8, u8) {
+    <u64>::into(a)
+}
+
+/// Splits u64 into four u16
+pub fn split_u64_into_u16(a: u64) -> (u16, u16, u16, u16) {
+    <u64>::into(a)
+}
+
+/// Splits u64 into two u32
+pub fn split_u64_into_u32(a: u64) -> (u32, u32) {
+    <u64>::into(a)
+}
+
+/// Narrowing uint conversions
+
+/// Converts u64 into u1.
+/// Panics if the value does not fit in u1
+pub fn safe_u64_to_u1(a: u64) -> u1 {
+    let u1_max: u64 = jet::left_pad_low_1_64(jet::high_1());
+
+    assert!(jet::le_64(a, u1_max));
+
+    jet::rightmost_64_1(a)
+}
+
+/// Converts u64 into u8.
+/// Panics if the value does not fit in u8
+pub fn safe_u64_to_u8(a: u64) -> u8 {
+    let u8_max: u64 = jet::left_pad_low_8_64(jet::high_8());
+
+    assert!(jet::le_64(a, u8_max));
+
+    jet::rightmost_64_8(a)
+}
+
+/// Converts u64 into u16.
+/// Panics if the value does not fit in u16
+pub fn safe_u64_to_u16(a: u64) -> u16 {
+    let u16_max: u64 = jet::left_pad_low_16_64(jet::high_16());
+
+    assert!(jet::le_64(a, u16_max));
+
+    jet::rightmost_64_16(a)
+}
+
+/// Converts u64 into u32.
+/// Panics if the value does not fit in u32
+pub fn safe_u64_to_u32(a: u64) -> u32 {
+    let u32_max: u64 = jet::left_pad_low_32_64(jet::high_32());
+
+    assert!(jet::le_64(a, u32_max));
+
+    jet::rightmost_64_32(a)
+}

simf/lib/u64.simf → simf/lib/u64/math.simf

@@ -67,8 +67,3 @@ pub fn gt_64(a: u64, b: u64) -> bool {
 pub fn ge_64(a: u64, b: u64) -> bool {
     jet::le_64(b, a)
 }
-
-/// Widen `u64` to a `u256` scalar.
-pub fn u64_into_u256(val: u64) -> u256 {
-    <(u64, u64, u64, u64)>::into((0, 0, 0, val))
-}

simf/u64_convert_test.simf

@@ -0,0 +1,154 @@
+use crate::lib::u64::convert::{
+    u64_to_u128,
+    u64_to_u256,
+    split_u64_into_u8,
+    split_u64_into_u16,
+    split_u64_into_u32,
+    safe_u64_to_u1,
+    safe_u64_to_u8,
+    safe_u64_to_u16,
+    safe_u64_to_u32
+};
+use crate::lib::asserts::{
+    assert_eq_1,
+    assert_eq_8,
+    assert_eq_16,
+    assert_eq_32,
+    assert_eq_128,
+    assert_eq_256
+};
+use crate::helper::if_test_this_function;
+
+fn main() {
+    let fn_idx: u8 = witness::FUNCTION_INDEX;
+
+    let a: u64 = witness::FIRST_ARG;
+
+    let expected: u256 = witness::EXPECTED;
+
+    match if_test_this_function(0, fn_idx) {
+        true => {
+            let (_, expected): (u128, u128) = <u256>::into(expected);
+
+            assert_eq_128(u64_to_u128(a), expected);
+        },
+        false => {},
+    };
+
+    match if_test_this_function(1, fn_idx) {
+        true => {
+            assert_eq_256(u64_to_u256(a), expected);
+        },
+        false => {},
+    };
+
+    match if_test_this_function(2, fn_idx) {
+        true => {
+            let (
+                a7,
+                a6,
+                a5,
+                a4,
+                a3,
+                a2,
+                a1,
+                a0
+            ): (u8, u8, u8, u8, u8, u8, u8, u8) = split_u64_into_u8(a);
+
+            let (_, _, _, expected): (u64, u64, u64, u64) = <u256>::into(expected);
+            let (
+                expected7,
+                expected6,
+                expected5,
+                expected4,
+                expected3,
+                expected2,
+                expected1,
+                expected0
+            ): (u8, u8, u8, u8, u8, u8, u8, u8) = <u64>::into(expected);
+
+            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(3, fn_idx) {
+        true => {
+            let (a3, a2, a1, a0): (u16, u16, u16, u16) = split_u64_into_u16(a);
+
+            let (_, _, _, expected): (u64, u64, u64, u64) = <u256>::into(expected);
+            let (
+                expected3,
+                expected2,
+                expected1,
+                expected0
+            ): (u16, u16, u16, u16) = <u64>::into(expected);
+
+            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(4, fn_idx) {
+        true => {
+            let (a1, a0): (u32, u32) = split_u64_into_u32(a);
+
+            let (_, _, _, expected): (u64, u64, u64, u64) = <u256>::into(expected);
+            let (expected1, expected0): (u32, u32) = <u64>::into(expected);
+
+            assert_eq_32(a1, expected1);
+            assert_eq_32(a0, expected0);
+        },
+        false => {},
+    };
+
+    match if_test_this_function(5, fn_idx) {
+        true => {
+            let (_, _, _, expected): (u64, u64, u64, u64) = <u256>::into(expected);
+            let expected: u1 = jet::rightmost_64_1(expected);
+
+            assert_eq_1(safe_u64_to_u1(a), expected);
+        },
+        false => {},
+    };
+
+    match if_test_this_function(6, fn_idx) {
+        true => {
+            let (_, _, _, expected): (u64, u64, u64, u64) = <u256>::into(expected);
+            let expected: u8 = jet::rightmost_64_8(expected);
+
+            assert_eq_8(safe_u64_to_u8(a), expected);
+        },
+        false => {},
+    };
+
+    match if_test_this_function(7, fn_idx) {
+        true => {
+            let (_, _, _, expected): (u64, u64, u64, u64) = <u256>::into(expected);
+            let expected: u16 = jet::rightmost_64_16(expected);
+
+            assert_eq_16(safe_u64_to_u16(a), expected);
+        },
+        false => {},
+    };
+
+    match if_test_this_function(8, fn_idx) {
+        true => {
+            let (_, _, _, expected): (u64, u64, u64, u64) = <u256>::into(expected);
+            let expected: u32 = jet::rightmost_64_32(expected);
+
+            assert_eq_32(safe_u64_to_u32(a), expected);
+        },
+        false => {},
+    };
+}

simf/u64_test.simf → simf/u64_math_test.simf

@@ -1,6 +1,14 @@
-use crate::lib::u64::{
-    checked_add_64, safe_add_64, checked_sub_64, safe_sub_64, checked_mul_64, safe_mul_64, checked_div_64, safe_div_64,
-    gt_64, ge_64, u64_into_u256,
+use crate::lib::u64::math::{
+    checked_add_64,
+    safe_add_64,
+    checked_sub_64,
+    safe_sub_64,
+    checked_mul_64,
+    safe_mul_64,
+    checked_div_64,
+    safe_div_64,
+    gt_64,
+    ge_64
 };
 use crate::lib::asserts::{assert_none_64, assert_eq_64};
 use crate::lib::binary::not;
@@ -11,8 +19,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<u64>, expected: Option<u64>) {
     match expected {
-        None => assert_none_64(result),
         Some(e: u64) => assert_eq_64(unwrap(result), e),
+        None => assert_none_64(result),
     }
 }
 
@@ -32,9 +40,6 @@ fn main() {
     let b: u64 = witness::SECOND_ARG;
     let expected: Option<u64> = witness::EXPECTED;
 
-    let expected_widen: u256 = witness::EXPECTED_WIDEN;
-
-
     // add
     match if_test_this_function(0, fn_idx) { true => { assert_eq_opt(checked_add_64(a, b), expected); }, false => (), };
     match if_test_this_function(1, fn_idx) { true => { assert!(jet::eq_64(safe_add_64(a, b), unwrap(expected))); }, false => (), };
@@ -54,7 +59,4 @@ fn main() {
     // gt, ge
     match if_test_this_function(8, fn_idx) { true => { assert_bool_by_opt(gt_64(a, b), expected); }, false => (), };
     match if_test_this_function(9, fn_idx) { true => { assert_bool_by_opt(ge_64(a, b), expected); }, false => (), };
-
-    // Custom
-    match if_test_this_function(192, fn_idx) { true => { assert!(jet::eq_256(u64_into_u256(a), expected_widen)); }, false => (), };
 }