Сonvert functions for u32

simf/lib/u32/convert.simf

@@ -0,0 +1,64 @@
+/// Widening uint conversions
+
+/// Converts u32 to u64
+pub fn u32_to_u64(a: u32) -> u64 {
+    jet::left_pad_low_32_64(a)
+}
+
+/// Converts u32 to u128
+pub fn u32_to_u128(a: u32) -> u128 {
+    let a_u64: u64 = u32_to_u64(a);
+
+    <(u64, u64)>::into((0, a_u64))
+}
+
+/// Converts u32 to u256
+pub fn u32_to_u256(a: u32) -> u256 {
+    let a_u128: u128 = u32_to_u128(a);
+
+    <(u128, u128)>::into((0, a_u128))
+}
+
+/// Splitting uint conversions
+
+/// Splits u32 into four u8
+pub fn split_u32_to_u8(a: u32) -> (u8, u8, u8, u8) {
+    <u32>::into(a)
+}
+
+/// Splits u32 into two u16
+pub fn split_u32_to_u16(a: u32) -> (u16, u16) {
+    <u32>::into(a)
+}
+
+/// Narrowing uint conversions
+
+/// Converts u32 into u1.
+/// Panics if the value does not fit in u1
+pub fn safe_u32_to_u1(a: u32) -> u1 {
+    let u1_max: u32 = jet::left_pad_low_1_32(jet::high_1());
+
+    assert!(jet::le_32(a, u1_max));
+
+    jet::rightmost_32_1(a)
+}
+
+/// Converts u32 into u8.
+/// Panics if the value does not fit in u8
+pub fn safe_u32_to_u8(a: u32) -> u8 {
+    let u8_max: u32 = jet::left_pad_low_8_32(jet::high_8());
+
+    assert!(jet::le_32(a, u8_max));
+
+    jet::rightmost_32_8(a)
+}
+
+/// Converts u32 into u16.
+/// Panics if the value does not fit in u16
+pub fn safe_u32_to_u16(a: u32) -> u16 {
+    let u16_max: u32 = jet::left_pad_low_16_32(jet::high_16());
+
+    assert!(jet::le_32(a, u16_max));
+
+    jet::rightmost_32_16(a)
+}

simf/u32_convert_test.simf

@@ -0,0 +1,111 @@
+use crate::lib::u32::convert::{
+    u32_to_u64,
+    u32_to_u128,
+    u32_to_u256,
+    split_u32_to_u8,
+    split_u32_to_u16,
+    safe_u32_to_u1,
+    safe_u32_to_u8,
+    safe_u32_to_u16
+};
+use crate::lib::u128::eq_128;
+use crate::lib::asserts::{assert_eq_1, assert_eq_8, assert_eq_16};
+use crate::helper::if_test_this_function;
+
+fn main() {
+    let fn_idx: u8 = witness::FUNCTION_INDEX;
+
+    let a: u32 = witness::FIRST_ARG;
+
+    let expected: u256 = witness::EXPECTED;
+
+    match if_test_this_function(0, fn_idx) {
+        true => {
+            let (_, _, _, expected): (u64, u64, u64, u64) = <u256>::into(expected);
+
+            assert!(jet::eq_64(u32_to_u64(a), expected));
+        },
+        false => {},
+    };
+
+    match if_test_this_function(1, fn_idx) {
+        true => {
+            let (_, expected): (u128, u128) = <u256>::into(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));
+        },
+        false => {},
+    };
+
+    match if_test_this_function(3, fn_idx) {
+        true => {
+            let (a3, a2, a1, a0): (u8, u8, u8, u8) = split_u32_to_u8(a);
+
+            let (_, _, _, expected): (u64, u64, u64, u64) = <u256>::into(expected);
+            let expected: u32 = jet::rightmost_64_32(expected);
+            let (
+                expected3,
+                expected2,
+                expected1,
+                expected0
+            ): (u8, u8, u8, u8) = <u32>::into(expected);
+
+            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(4, fn_idx) {
+        true => {
+            let (a1, a0): (u16, u16) = split_u32_to_u16(a);
+
+            let (_, _, _, expected): (u64, u64, u64, u64) = <u256>::into(expected);
+            let expected: u32 = jet::rightmost_64_32(expected);
+            let (expected1, expected0): (u16, u16) = <u32>::into(expected);
+
+            assert_eq_16(a1, expected1);
+            assert_eq_16(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_u32_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_u32_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_u32_to_u16(a), expected);
+        },
+        false => {},
+    };
+}

simf/u32_test.simf → simf/u32_math_test.simf

@@ -1,4 +1,4 @@
-use crate::lib::u32::{checked_add_32, safe_add_32, checked_sub_32, safe_sub_32, checked_mul_32, safe_mul_32, checked_div_32, safe_div_32, gt_32, ge_32};
+use crate::lib::u32::math::{checked_add_32, safe_add_32, checked_sub_32, safe_sub_32, checked_mul_32, safe_mul_32, checked_div_32, safe_div_32, gt_32, ge_32};
 use crate::lib::asserts::{assert_none_32, assert_eq_32};
 use crate::lib::binary::not;
 use crate::helper::if_test_this_function;