Convert functions for u8

simf/lib/u8/convert.simf

@@ -0,0 +1,49 @@
+/// Widening uint conversions
+
+/// Converts u8 to u16
+pub fn u8_to_u16(a: u8) -> u16 {
+    jet::left_pad_low_8_16(a)
+}
+
+/// Converts u8 to u32
+pub fn u8_to_u32(a: u8) -> u32 {
+    jet::left_pad_low_8_32(a)
+}
+
+/// Converts u8 to u64
+pub fn u8_to_u64(a: u8) -> u64 {
+    jet::left_pad_low_8_64(a)
+}
+
+/// Converts u8 to u128
+pub fn u8_to_u128(a: u8) -> u128 {
+    let a_u64: u64 = u8_to_u64(a);
+
+    <(u64, u64)>::into((0, a_u64))
+}
+
+/// Converts u8 to u256
+pub fn u8_to_u256(a: u8) -> u256 {
+    let a_u128: u128 = u8_to_u128(a);
+
+    <(u128, u128)>::into((0, a_u128))
+}
+
+/// Splitting uint conversions
+
+/// Splits u8 into eight u1
+pub fn split_u8_to_u1(a: u8) -> (u1, u1, u1, u1, u1, u1, u1, u1) {
+    <u8>::into(a)
+}
+
+/// Narrowing uint conversions
+
+/// Converts u8 into u1.
+/// Panics if the value does not fit in u1
+pub fn safe_u8_to_u1(a: u8) -> u1 {
+    let u1_max: u8 = jet::left_pad_low_1_8(jet::high_1());
+
+    assert!(jet::le_8(a, u1_max));
+
+    jet::rightmost_8_1(a)
+}

simf/u8_convert_test.simf

@@ -0,0 +1,114 @@
+use crate::lib::u8::convert::{
+    u8_to_u16,
+    u8_to_u32,
+    u8_to_u64,
+    u8_to_u128,
+    u8_to_u256,
+    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::eq_128;
+use crate::lib::asserts::assert_eq_1;
+use crate::helper::if_test_this_function;
+
+fn main() {
+    let fn_idx: u8 = witness::FUNCTION_INDEX;
+
+    let a: u8 = 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);
+            let (_, _, _, expected): (u16, u16, u16, u16) = <u64>::into(expected);
+
+            assert!(jet::eq_16(u8_to_u16(a), expected));
+        },
+        false => {},
+    };
+
+    match if_test_this_function(1, fn_idx) {
+        true => {
+            let (_, _, _, expected): (u64, u64, u64, u64) = <u256>::into(expected);
+            let (_, expected): (u32, u32) = <u64>::into(expected);
+
+            assert!(jet::eq_32(u8_to_u32(a), expected));
+        },
+        false => {},
+    };
+
+    match if_test_this_function(2, fn_idx) {
+        true => {
+            let (_, _, _, expected): (u64, u64, u64, u64) = <u256>::into(expected);
+
+            assert!(jet::eq_64(u8_to_u64(a), expected));
+        },
+        false => {},
+    };
+
+    match if_test_this_function(3, fn_idx) {
+        true => {
+            let (_, expected): (u128, u128) = <u256>::into(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));
+        },
+        false => {},
+    };
+
+    match if_test_this_function(5, fn_idx) {
+        true => {
+            let (
+                a7,
+                a6,
+                a5,
+                a4,
+                a3,
+                a2,
+                a1,
+                a0
+            ): (u1, u1, u1, u1, u1, u1, u1, u1) = split_u8_to_u1(a);
+
+            let (_, _, _, expected): (u64, u64, u64, u64) = <u256>::into(expected);
+            let expected: u8 = jet::rightmost_64_8(expected);
+            let (
+                expected7,
+                expected6,
+                expected5,
+                expected4,
+                expected3,
+                expected2,
+                expected1,
+                expected0
+            ): (u1, u1, u1, u1, u1, u1, u1, u1) = <u8>::into(expected);
+
+            assert_eq_1(a7, expected7);
+            assert_eq_1(a6, expected6);
+            assert_eq_1(a5, expected5);
+            assert_eq_1(a4, expected4);
+            assert_eq_1(a3, expected3);
+            assert_eq_1(a2, expected2);
+            assert_eq_1(a1, expected1);
+            assert_eq_1(a0, expected0);
+        },
+        false => {},
+    };
+
+    match if_test_this_function(6, fn_idx) {
+        true => {
+            let (_, _, _, expected): (u64, u64, u64, u64) = <u256>::into(expected);
+            let expected: u1 = jet::rightmost_64_1(expected);
+
+            assert_eq_1(safe_u8_to_u1(a), expected);
+        },
+        false => {},
+    };
+}

simf/u8_test.simf → simf/u8_math_test.simf

@@ -1,4 +1,15 @@
-use crate::lib::u8::{checked_add_8, safe_add_8, checked_sub_8, safe_sub_8, checked_mul_8, safe_mul_8, checked_div_8, safe_div_8, gt_8, ge_8};
+use crate::lib::u8::math::{
+    checked_add_8,
+    safe_add_8,
+    checked_sub_8,
+    safe_sub_8,
+    checked_mul_8,
+    safe_mul_8,
+    checked_div_8,
+    safe_div_8,
+    gt_8,
+    ge_8
+};
 use crate::lib::asserts::{assert_none_8, assert_eq_8};
 use crate::lib::binary::not;
 use crate::helper::if_test_this_function;
@@ -8,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<u8>, expected: Option<u8>) {
     match expected {
-        None => assert_none_8(result),
         Some(e: u8) => assert_eq_8(unwrap(result), e),
+        None => assert_none_8(result),
     }
 }
 
@@ -30,22 +41,22 @@ fn main() {
     let expected: Option<u8> = witness::EXPECTED;
 
     // add
-    match if_test_this_function(0, fn_idx) { true => { assert_eq_opt(checked_add_8(a, b), expected); }, false => (), };
-    match if_test_this_function(1, fn_idx) { true => { assert!(jet::eq_8(safe_add_8(a, b), unwrap(expected))); }, false => (), };
+    match if_test_this_function(0, fn_idx) { true => { assert_eq_opt(checked_add_8(a, b), expected); }, false => {}, };
+    match if_test_this_function(1, fn_idx) { true => { assert!(jet::eq_8(safe_add_8(a, b), unwrap(expected))); }, false => {}, };
 
     // sub
-    match if_test_this_function(2, fn_idx) { true => { assert_eq_opt(checked_sub_8(a, b), expected); }, false => (), };
-    match if_test_this_function(3, fn_idx) { true => { assert!(jet::eq_8(safe_sub_8(a, b), unwrap(expected))); }, false => (), };
+    match if_test_this_function(2, fn_idx) { true => { assert_eq_opt(checked_sub_8(a, b), expected); }, false => {}, };
+    match if_test_this_function(3, fn_idx) { true => { assert!(jet::eq_8(safe_sub_8(a, b), unwrap(expected))); }, false => {}, };
 
     // mul
-    match if_test_this_function(4, fn_idx) { true => { assert_eq_opt(checked_mul_8(a, b), expected); }, false => (), };
-    match if_test_this_function(5, fn_idx) { true => { assert!(jet::eq_8(safe_mul_8(a, b), unwrap(expected))); }, false => (), };
+    match if_test_this_function(4, fn_idx) { true => { assert_eq_opt(checked_mul_8(a, b), expected); }, false => {}, };
+    match if_test_this_function(5, fn_idx) { true => { assert!(jet::eq_8(safe_mul_8(a, b), unwrap(expected))); }, false => {}, };
 
     // div
-    match if_test_this_function(6, fn_idx) { true => { assert_eq_opt(checked_div_8(a, b), expected); }, false => (), };
-    match if_test_this_function(7, fn_idx) { true => { assert!(jet::eq_8(safe_div_8(a, b), unwrap(expected))); }, false => (), };
+    match if_test_this_function(6, fn_idx) { true => { assert_eq_opt(checked_div_8(a, b), expected); }, false => {}, };
+    match if_test_this_function(7, fn_idx) { true => { assert!(jet::eq_8(safe_div_8(a, b), unwrap(expected))); }, false => {}, };
 
     // gt, ge
-    match if_test_this_function(8, fn_idx) { true => { assert_bool_by_opt(gt_8(a, b), expected); }, false => (), };
-    match if_test_this_function(9, fn_idx) { true => { assert_bool_by_opt(ge_8(a, b), expected); }, false => (), };
+    match if_test_this_function(8, fn_idx) { true => { assert_bool_by_opt(gt_8(a, b), expected); }, false => {}, };
+    match if_test_this_function(9, fn_idx) { true => { assert_bool_by_opt(ge_8(a, b), expected); }, false => {}, };
 }

tests/u8_convert_test.rs

@@ -0,0 +1,170 @@
+mod common;
+
+use primitive_types::U256;
+use rand::Rng;
+
+use common::core::{Expect, run};
+
+use simplicityhl_std::artifacts::u8_convert_test::U8ConvertTestProgram;
+use simplicityhl_std::artifacts::u8_convert_test::derived_u8_convert_test::{
+    U8ConvertTestArguments, U8ConvertTestWitness,
+};
+
+enum FunctionToTest {
+    U8ToU16,
+    U8ToU32,
+    U8ToU64,
+    U8ToU128,
+    U8ToU256,
+    SplitU8ToU1,
+    SafeU8ToU1,
+}
+
+#[inline]
+fn op(o: FunctionToTest) -> u8 {
+    o as u8
+}
+
+fn program() -> U8ConvertTestProgram {
+    U8ConvertTestProgram::new(U8ConvertTestArguments {})
+}
+
+fn build_witness(function: u8, a: u8, expected: [u8; 32]) -> U8ConvertTestWitness {
+    U8ConvertTestWitness {
+        function_index: function,
+        first_arg: a,
+        expected,
+    }
+}
+
+mod u8_convert_test {
+    use super::*;
+
+    #[simplex::test]
+    fn u8_convert_test_u8_to_u16(context: simplex::TestContext) -> anyhow::Result<()> {
+        let a = rand::thread_rng().gen_range(0..=u8::MAX);
+
+        run(
+            &context,
+            program(),
+            build_witness(
+                op(FunctionToTest::U8ToU16),
+                a,
+                U256::from(a).to_big_endian(),
+            ),
+            Expect::Ok,
+        )
+    }
+
+    #[simplex::test]
+    fn u8_convert_test_u8_to_u32(context: simplex::TestContext) -> anyhow::Result<()> {
+        let a = rand::thread_rng().gen_range(0..=u8::MAX);
+
+        run(
+            &context,
+            program(),
+            build_witness(
+                op(FunctionToTest::U8ToU32),
+                a,
+                U256::from(a).to_big_endian(),
+            ),
+            Expect::Ok,
+        )
+    }
+
+    #[simplex::test]
+    fn u8_convert_test_u8_to_u64(context: simplex::TestContext) -> anyhow::Result<()> {
+        let a = rand::thread_rng().gen_range(0..=u8::MAX);
+
+        run(
+            &context,
+            program(),
+            build_witness(
+                op(FunctionToTest::U8ToU64),
+                a,
+                U256::from(a).to_big_endian(),
+            ),
+            Expect::Ok,
+        )
+    }
+
+    #[simplex::test]
+    fn u8_convert_test_u8_to_u128(context: simplex::TestContext) -> anyhow::Result<()> {
+        let a = rand::thread_rng().gen_range(0..=u8::MAX);
+
+        run(
+            &context,
+            program(),
+            build_witness(
+                op(FunctionToTest::U8ToU128),
+                a,
+                U256::from(a).to_big_endian(),
+            ),
+            Expect::Ok,
+        )
+    }
+
+    #[simplex::test]
+    fn u8_convert_test_u8_to_u256(context: simplex::TestContext) -> anyhow::Result<()> {
+        let a = rand::thread_rng().gen_range(0..=u8::MAX);
+
+        run(
+            &context,
+            program(),
+            build_witness(
+                op(FunctionToTest::U8ToU256),
+                a,
+                U256::from(a).to_big_endian(),
+            ),
+            Expect::Ok,
+        )
+    }
+
+    #[simplex::test]
+    fn u8_convert_test_split_u8_to_u1(context: simplex::TestContext) -> anyhow::Result<()> {
+        let a = rand::thread_rng().gen_range(0..=u8::MAX);
+
+        run(
+            &context,
+            program(),
+            build_witness(
+                op(FunctionToTest::SplitU8ToU1),
+                a,
+                U256::from(a).to_big_endian(),
+            ),
+            Expect::Ok,
+        )
+    }
+
+    #[simplex::test]
+    fn u8_convert_test_safe_u8_to_u1(context: simplex::TestContext) -> anyhow::Result<()> {
+        let a = rand::thread_rng().gen_range(0..=1);
+
+        run(
+            &context,
+            program(),
+            build_witness(
+                op(FunctionToTest::SafeU8ToU1),
+                a,
+                U256::from(a).to_big_endian(),
+            ),
+            Expect::Ok,
+        )
+    }
+
+    #[simplex::test]
+    fn u8_convert_test_safe_u8_to_u1_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
+        let a = rand::thread_rng().gen_range(2..=u8::MAX);
+
+        run(
+            &context,
+            program(),
+            build_witness(
+                op(FunctionToTest::SafeU8ToU1),
+                a,
+                U256::from(a).to_big_endian(),
+            ),
+            Expect::AssertFailed,
+        )
+    }
+}