#![cfg_attr(feature = "unstable_simd", feature(portable_simd))]
#![cfg_attr(
feature = "unstable_simd",
expect(clippy::too_many_arguments, clippy::type_complexity)
)]
use tk_pg_core::Pauli;
mod kernels;
mod slice;
mod u8_encodings;
pub use kernels::*;
pub use slice::*;
pub use u8_encodings::*;
#[cfg(feature = "unstable_simd")]
mod simd;
#[cfg(feature = "unstable_simd")]
pub use simd::*;
#[cfg(test)]
mod test_utils;
pub fn bools_to_u64_vec(bits: &[bool]) -> Vec<u64> {
bits.chunks(64)
.map(|chunk| {
chunk
.iter()
.enumerate()
.fold(0u64, |acc, (i, &b)| if b { acc | (1 << i) } else { acc })
})
.collect()
}
pub fn paulis_to_u64s(paulis: &[Pauli]) -> (Vec<u64>, Vec<u64>) {
let n_u64s = paulis.len().div_ceil(64);
let mut zs = Vec::with_capacity(n_u64s);
let mut xs = Vec::with_capacity(n_u64s);
let mut z_current: u64 = 0;
let mut x_current: u64 = 0;
let mut bits_filled = 0;
for pauli in paulis {
let z_bit = match pauli {
Pauli::I => 0,
Pauli::X => 0,
Pauli::Z => 1,
Pauli::Y => 1,
};
let x_bit = match pauli {
Pauli::I => 0,
Pauli::X => 1,
Pauli::Z => 0,
Pauli::Y => 1,
};
z_current |= (z_bit as u64) << bits_filled;
x_current |= (x_bit as u64) << bits_filled;
bits_filled += 1;
if bits_filled == 64 {
zs.push(z_current);
xs.push(x_current);
z_current = 0;
x_current = 0;
bits_filled = 0;
}
}
if bits_filled > 0 {
zs.push(z_current);
xs.push(x_current);
}
(zs, xs)
}
pub fn u64s_to_paulis(packed_z_bits: &[u64], packed_x_bits: &[u64], n_paulis: usize) -> Vec<Pauli> {
let mut paulis = Vec::with_capacity(n_paulis);
let mut decoded = 0;
for (z_pack, x_pack) in packed_z_bits.iter().zip(packed_x_bits) {
for i in 0..64 {
if decoded == n_paulis {
return paulis;
}
let z_bit = (z_pack >> i) & 0b1;
let x_bit = (x_pack >> i) & 0b1;
let pauli = match (z_bit, x_bit) {
(0, 0) => Pauli::I,
(0, 1) => Pauli::X,
(1, 0) => Pauli::Z,
(1, 1) => Pauli::Y,
_ => unreachable!(),
};
paulis.push(pauli);
decoded += 1;
}
}
paulis
}
pub fn sign_flips_to_u64s(sign_flips: &[bool]) -> Vec<u64> {
let n_u64s = sign_flips.len().div_ceil(64);
let mut encodings = Vec::with_capacity(n_u64s);
let mut current: u64 = 0;
let mut bits_filled = 0;
for &sign in sign_flips {
if sign {
current |= 1 << bits_filled;
}
bits_filled += 1;
if bits_filled == 64 {
encodings.push(current);
current = 0;
bits_filled = 0;
}
}
if bits_filled > 0 {
encodings.push(current);
}
encodings
}
pub fn u64s_to_sign_flips(packed_sign_flip_bits: &[u64], n_signs: usize) -> Vec<bool> {
let mut signs = Vec::with_capacity(n_signs);
let mut decoded = 0;
for encoding in packed_sign_flip_bits {
for i in 0..64 {
if decoded == n_signs {
return signs;
}
let bits = (encoding >> i) & 0b1;
signs.push(bits == 1);
decoded += 1;
}
}
signs
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_bools_to_u64_vec() {
let bits = vec![true, false, true, false];
assert_eq!(bools_to_u64_vec(&bits), vec![0b0101_u64]);
assert_eq!(bools_to_u64_vec(&[]), Vec::<u64>::new());
let mut long_bits = vec![false; 65];
long_bits[64] = true;
assert_eq!(bools_to_u64_vec(&long_bits), vec![0_u64, 1_u64]);
let bits_128: Vec<bool> = (0..128).map(|i| i % 2 == 0).collect();
let packed = bools_to_u64_vec(&bits_128);
assert_eq!(packed.len(), 2);
assert_eq!(packed[0], 0x5555_5555_5555_5555_u64);
assert_eq!(packed[1], 0x5555_5555_5555_5555_u64);
}
#[test]
fn test_paulis_to_u64s() {
let paulis = vec![Pauli::I, Pauli::X, Pauli::Y, Pauli::Z];
let (zs, xs) = paulis_to_u64s(&paulis);
assert_eq!(zs, vec![0b1100_u64]);
assert_eq!(xs, vec![0b0110_u64]);
let (zs, xs) = paulis_to_u64s(&[]);
assert!(zs.is_empty());
assert!(xs.is_empty());
}
#[test]
fn test_paulis_to_u64s_long() {
let mut paulis = vec![Pauli::I; 65];
paulis[64] = Pauli::X;
let (zs, xs) = paulis_to_u64s(&paulis);
assert_eq!(zs, vec![0_u64, 0_u64]);
assert_eq!(xs, vec![0_u64, 1_u64]);
let paulis: Vec<Pauli> = (0..128)
.map(|i| match i % 4 {
0 => Pauli::I,
1 => Pauli::X,
2 => Pauli::Y,
_ => Pauli::Z,
})
.collect();
let (zs, xs) = paulis_to_u64s(&paulis);
assert_eq!(zs.len(), 2);
assert_eq!(xs.len(), 2);
assert_eq!(u64s_to_paulis(&zs, &xs, paulis.len()), paulis);
}
#[test]
fn test_u64s_to_paulis() {
let paulis = vec![Pauli::I, Pauli::X, Pauli::Y, Pauli::Z];
let (zs, xs) = paulis_to_u64s(&paulis);
assert_eq!(u64s_to_paulis(&zs, &xs, paulis.len()), paulis);
let (zs, xs) = paulis_to_u64s(&[Pauli::X, Pauli::Z]);
assert_eq!(u64s_to_paulis(&zs, &xs, 2), vec![Pauli::X, Pauli::Z]);
}
#[test]
fn test_sign_flips_to_u64s() {
let signs = vec![true, false, true, false];
assert_eq!(sign_flips_to_u64s(&signs), vec![0b0101_u64]);
assert_eq!(sign_flips_to_u64s(&[]), Vec::<u64>::new());
}
#[test]
fn test_sign_flips_to_u64s_long() {
let mut signs = vec![false; 65];
signs[64] = true;
assert_eq!(sign_flips_to_u64s(&signs), vec![0_u64, 1_u64]);
let signs: Vec<bool> = (0..128).map(|i| i % 3 == 0).collect();
let packed = sign_flips_to_u64s(&signs);
assert_eq!(packed.len(), 2);
assert_eq!(u64s_to_sign_flips(&packed, signs.len()), signs);
}
#[test]
fn test_u64s_to_sign_flips() {
let signs = vec![true, false, true, false];
let packed = sign_flips_to_u64s(&signs);
assert_eq!(u64s_to_sign_flips(&packed, signs.len()), signs);
let packed = sign_flips_to_u64s(&[true, true, false]);
assert_eq!(u64s_to_sign_flips(&packed, 3), vec![true, true, false]);
}
}