1#[allow(
  2    non_camel_case_types,
  3    non_snake_case,
  4    non_upper_case_globals,
  5    dead_code,
  6    improper_ctypes
  7)]
  8pub mod ffi;
  9
 10pub mod module;
 11#[allow(unused_imports)]
 12pub use module::*;
 13
 14pub mod vec_znx;
 15#[allow(unused_imports)]
 16pub use vec_znx::*;
 17
 18pub mod vec_znx_big;
 19#[allow(unused_imports)]
 20pub use vec_znx_big::*;
 21
 22pub mod vec_znx_dft;
 23#[allow(unused_imports)]
 24pub use vec_znx_dft::*;
 25
 26pub mod svp;
 27#[allow(unused_imports)]
 28pub use svp::*;
 29
 30pub mod vmp;
 31#[allow(unused_imports)]
 32pub use vmp::*;
 33
 34pub mod sampling;
 35#[allow(unused_imports)]
 36pub use sampling::*;
 37
 38pub mod encoding;
 39#[allow(unused_imports)]
 40pub use encoding::*;
 41
 42pub mod infos;
 43#[allow(unused_imports)]
 44pub use infos::*;
 45
 46pub mod free;
 47#[allow(unused_imports)]
 48pub use free::*;
 49
 50pub const GALOISGENERATOR: u64 = 5;
 51
 52#[allow(dead_code)]
 53pub fn cast_mut_u64_to_mut_u8_slice(data: &mut [u64]) -> &mut [u8] {
 54    let ptr: *mut u8 = data.as_mut_ptr() as *mut u8;
 55    let len: usize = data.len() * std::mem::size_of::<u64>();
 56    unsafe { std::slice::from_raw_parts_mut(ptr, len) }
 57}
 58
 59pub fn cast_mut_u8_to_mut_i64_slice(data: &mut [u8]) -> &mut [i64] {
 60    let ptr: *mut i64 = data.as_mut_ptr() as *mut i64;
 61    let len: usize = data.len() / std::mem::size_of::<i64>();
 62    unsafe { std::slice::from_raw_parts_mut(ptr, len) }
 63}
 64
 65pub fn cast_mut_u8_to_mut_f64_slice(data: &mut [u8]) -> &mut [f64] {
 66    let ptr: *mut f64 = data.as_mut_ptr() as *mut f64;
 67    let len: usize = data.len() / std::mem::size_of::<f64>();
 68    unsafe { std::slice::from_raw_parts_mut(ptr, len) }
 69}
 70
 71pub fn cast_u8_to_f64_slice(data: &mut [u8]) -> &[f64] {
 72    let ptr: *const f64 = data.as_mut_ptr() as *const f64;
 73    let len: usize = data.len() / std::mem::size_of::<f64>();
 74    unsafe { std::slice::from_raw_parts(ptr, len) }
 75}
 76
 77use std::alloc::{alloc, Layout};
 78
 79pub fn alloc_aligned_u8(size: usize, align: usize) -> Vec<u8> {
 80    assert_eq!(
 81        align & (align - 1),
 82        0,
 83        "align={} must be a power of two",
 84        align
 85    );
 86    assert_eq!(
 87        (size * std::mem::size_of::<u8>()) % align,
 88        0,
 89        "size={} must be a multiple of align={}",
 90        size,
 91        align
 92    );
 93    unsafe {
 94        let layout: Layout = Layout::from_size_align(size, align).expect("Invalid alignment");
 95        let ptr: *mut u8 = alloc(layout);
 96        if ptr.is_null() {
 97            panic!("Memory allocation failed");
 98        }
 99        Vec::from_raw_parts(ptr, size, size)
100    }
101}
102
103pub fn alloc_aligned<T>(size: usize, align: usize) -> Vec<T> {
104    assert_eq!(
105        (size * std::mem::size_of::<T>()) % align,
106        0,
107        "size={} must be a multiple of align={}",
108        size,
109        align
110    );
111    let mut vec_u8: Vec<u8> = alloc_aligned_u8(std::mem::size_of::<T>() * size, align);
112    let ptr: *mut T = vec_u8.as_mut_ptr() as *mut T;
113    let len: usize = vec_u8.len() / std::mem::size_of::<T>();
114    let cap: usize = vec_u8.capacity() / std::mem::size_of::<T>();
115    std::mem::forget(vec_u8);
116    unsafe { Vec::from_raw_parts(ptr, len, cap) }
117}
118
119fn alias_mut_slice_to_vec<T>(slice: &mut [T]) -> Vec<T> {
120    let ptr = slice.as_mut_ptr();
121    let len = slice.len();
122    unsafe { Vec::from_raw_parts(ptr, len, len) }
123}