edited avx2

Author: karthikbhargavan

library/Cargo.lock

@@ -17,6 +17,13 @@ use std::fmt::Formatter;
 #[derive(Copy, Clone, Eq, PartialEq)]
 pub struct BitVec<const N: u32>(FunArray<N, Bit>);
 
+impl<const N: u32> BitVec<N> {
+    #[allow(non_snake_case)]
+    pub fn ZERO() -> Self {
+        Self::from_fn(|_| Bit::Zero)
+    }
+}
+
 /// Pretty prints a bit slice by group of 8
 fn bit_slice_to_string(bits: &[Bit]) -> String {
     bits.iter()

testable-simd-models/src/abstractions/bitvec.rs

@@ -1,6 +1,8 @@
 //! This module implements a fixed-size array wrapper with functional semantics
 //! which are used in formulating abstractions.
 
+use crate::abstractions::bit::MachineInteger;
+
 /// `FunArray<N, T>` represents an array of `T` values of length `N`, where `N` is a compile-time constant.
 /// Internally, it uses a fixed-length array of `Option<T>` with a maximum capacity of 512 elements.
 /// Unused elements beyond `N` are filled with `None`.
@@ -53,6 +55,13 @@ impl<const N: u32, T> FunArray<N, T> {
     }
 }
 
+impl<const N: u32, T:MachineInteger> FunArray<N, T> {
+    #[allow(non_snake_case)]
+    pub fn ZERO() -> Self {
+        Self::from_fn(|_| T::ZEROS)
+    }
+}
+
 impl<const N: u32, T: Clone> TryFrom<Vec<T>> for FunArray<N, T> {
     type Error = ();
     fn try_from(v: Vec<T>) -> Result<Self, ()> {

testable-simd-models/src/abstractions/funarr.rs

@@ -25,6 +25,11 @@ macro_rules! interpretations {
                         #[doc = concat!("Conversion from bit vectors of size ", stringify!($n), " to ", stringify!($ty), " vectors of size ", stringify!($m))]
                         pub fn [< to_ $name >](bv: BitVec<$n>) -> $name {
             let vec: Vec<$ty> = bv.to_vec();
+            $name::from_fn(|i| vec[i as usize])
+                        }
+                        #[doc = concat!("Conversion from bit vectors of size ", stringify!($n), " to ", stringify!($ty), " vectors of size ", stringify!($m))]
+                        pub fn [< as_ $name >](self) -> $name {
+            let vec: Vec<$ty> = self.to_vec();
             $name::from_fn(|i| vec[i as usize])
                         }
 
@@ -71,7 +76,6 @@ interpretations!(32; i8x4 [i8; 4], u8x4 [u8; 4]);
 /// # Safety
 ///
 /// `idx` must be in-bounds of the vector, ie. idx < N
-
 pub fn simd_insert<const N: u32, T: Copy>(x: FunArray<N, T>, idx: u32, val: T) -> FunArray<N, T> {
     FunArray::from_fn(|i| if i == idx { val } else { x[i] })
 }
@@ -936,3 +940,8 @@ pub fn simd_select<const N: u32, T1: Eq + MachineInteger, T2: Copy + MachineInte
         }
     })
 }
+
+/// Converts one type to another
+pub fn transmute<T, U:From<T>>(a:T) -> U {
+    a.into()
+}