Function vec_u64_from_bytes

ciphercore-base/src/bytes.rs:322–361

Can return excess zero elements when ScalarType = BIT and the number of bits in bytes is bigger than the actual number of packed bits

(x: &[u8], st: ScalarType)

/// Can return excess zero elements when ScalarType = BIT and
/// the number of bits in bytes is bigger than the actual number of packed bits
pub fn vec_u64_from_bytes(x: &[u8], st: ScalarType) -> Result<Vec<u64>> {
    let mut x_u64s = vec![];
    match st {
        BIT => {
            for byte in x {
                for i in 0..8 {
                    let bit = ((byte >> i) & 1) as u64;
                    x_u64s.push(bit);
                }
            }
        }
        _ => {
            let byte_length = scalar_size_in_bytes(st) as usize;
            // Whether to look at the leading bit when padding to 8 bytes.
            let pad_with_sign_bit = st.is_signed() && byte_length < 8;
            // E.g. 0xFFFFFFFFFFFF0000 if byte_length == 2.
            let sign_mask = match pad_with_sign_bit {
                false => 0,
                true => u64::MAX ^ ((1 << (byte_length * 8)) - 1),
            };
            if x.len() % byte_length != 0 {
                return Err(runtime_error!("Incompatible vector and scalar type"));
            }
            for x_slice in x.chunks_exact(byte_length) {
                let mut res = 0u64;
                for (i, xi) in x_slice.iter().enumerate() {
                    res += (*xi as u64) << (i * 8);
                }
                if pad_with_sign_bit {
                    let sign_bit = res >> (byte_length * 8 - 1);
                    if sign_bit == 1 {
                        res |= sign_mask;
                    }
                }
                x_u64s.push(res);
            }
        }
    }
    Ok(x_u64s)
}

pub fn vec_u128_from_bytes(x: &[u8], st: ScalarType) -> Result<Vec<u128>> {
    let mut x_u128s = vec![];