1use base2k::{Backend, FFT64, MatZnxDft, MatZnxDftAlloc, Module, VecZnx, VecZnxAlloc, VecZnxDft, VecZnxDftAlloc};
  2
  3pub struct Ciphertext<T> {
  4    data: T,
  5    log_base2k: usize,
  6    log_q: usize,
  7}
  8
  9impl<T> Ciphertext<T> {
 10    pub fn log_base2k(&self) -> usize {
 11        self.log_base2k
 12    }
 13
 14    pub fn log_q(&self) -> usize {
 15        self.log_q
 16    }
 17
 18    pub fn data(&self) -> &T {
 19        &self.data
 20    }
 21
 22    pub fn data_mut(&mut self) -> &mut T {
 23        &mut self.data
 24    }
 25}
 26
 27pub struct Plaintext<T> {
 28    data: T,
 29    log_base2k: usize,
 30    log_q: usize,
 31}
 32
 33impl<T> Plaintext<T> {
 34    pub fn log_base2k(&self) -> usize {
 35        self.log_base2k
 36    }
 37
 38    pub fn log_q(&self) -> usize {
 39        self.log_q
 40    }
 41
 42    pub fn data(&self) -> &T {
 43        &self.data
 44    }
 45
 46    pub fn data_mut(&mut self) -> &mut T {
 47        &mut self.data
 48    }
 49}
 50
 51pub(crate) type CtVecZnx<C> = Ciphertext<VecZnx<C>>;
 52pub(crate) type CtVecZnxDft<C, B: Backend> = Ciphertext<VecZnxDft<C, B>>;
 53pub(crate) type CtMatZnxDft<C, B: Backend> = Ciphertext<MatZnxDft<C, B>>;
 54pub(crate) type PtVecZnx<C> = Plaintext<VecZnx<C>>;
 55pub(crate) type PtVecZnxDft<C, B: Backend> = Plaintext<VecZnxDft<C, B>>;
 56pub(crate) type PtMatZnxDft<C, B: Backend> = Plaintext<MatZnxDft<C, B>>;
 57
 58impl Ciphertext<VecZnx<Vec<u8>>> {
 59    pub fn new<B: Backend>(module: &Module<B>, log_base2k: usize, log_q: usize, cols: usize) -> Self {
 60        Self {
 61            data: module.new_vec_znx(cols, derive_size(log_base2k, log_q)),
 62            log_base2k: log_base2k,
 63            log_q: log_q,
 64        }
 65    }
 66}
 67
 68impl Plaintext<VecZnx<Vec<u8>>> {
 69    pub fn new<B: Backend>(module: &Module<B>, log_base2k: usize, log_q: usize) -> Self {
 70        Self {
 71            data: module.new_vec_znx(1, derive_size(log_base2k, log_q)),
 72            log_base2k: log_base2k,
 73            log_q: log_q,
 74        }
 75    }
 76}
 77
 78impl<B: Backend> Ciphertext<VecZnxDft<Vec<u8>, B>> {
 79    pub fn new(module: &Module<B>, log_base2k: usize, log_q: usize, cols: usize) -> Self {
 80        Self {
 81            data: module.new_vec_znx_dft(cols, derive_size(log_base2k, log_q)),
 82            log_base2k: log_base2k,
 83            log_q: log_q,
 84        }
 85    }
 86}
 87
 88impl<B: Backend> Ciphertext<MatZnxDft<Vec<u8>, B>> {
 89    pub fn new(module: &Module<B>, log_base2k: usize, rows: usize, cols_in: usize, cols_out: usize, log_q: usize) -> Self {
 90        Self {
 91            data: module.new_mat_znx_dft(rows, cols_in, cols_out, derive_size(log_base2k, log_q)),
 92            log_base2k: log_base2k,
 93            log_q: log_q,
 94        }
 95    }
 96}
 97
 98pub(crate) fn derive_size(log_base2k: usize, log_q: usize) -> usize {
 99    (log_q + log_base2k - 1) / log_base2k
100}