1use backend::hal::{
  2    api::{FillUniform, Reset},
  3    layouts::{Backend, Data, DataMut, DataRef, MatZnx, Module, ReaderFrom, WriterTo},
  4};
  5
  6use crate::{
  7    layouts::{Infos, LWEToGLWESwitchingKey, compressed::GGLWESwitchingKeyCompressed},
  8    trait_families::Decompress,
  9};
 10use std::fmt;
 11
 12use crate::trait_families::{GGLWEEncryptSkFamily, GLWESecretExecModuleFamily};
 13
 14#[derive(PartialEq, Eq, Clone)]
 15pub struct LWEToGLWESwitchingKeyCompressed<D: Data>(pub(crate) GGLWESwitchingKeyCompressed<D>);
 16
 17impl<D: DataRef> fmt::Debug for LWEToGLWESwitchingKeyCompressed<D> {
 18    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 19        write!(f, "{}", self)
 20    }
 21}
 22
 23impl<D: DataMut> FillUniform for LWEToGLWESwitchingKeyCompressed<D> {
 24    fn fill_uniform(&mut self, source: &mut sampling::source::Source) {
 25        self.0.fill_uniform(source);
 26    }
 27}
 28
 29impl<D: DataMut> Reset for LWEToGLWESwitchingKeyCompressed<D> {
 30    fn reset(&mut self) {
 31        self.0.reset();
 32    }
 33}
 34
 35impl<D: DataRef> fmt::Display for LWEToGLWESwitchingKeyCompressed<D> {
 36    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 37        write!(f, "(LWEToGLWESwitchingKeyCompressed) {}", self.0)
 38    }
 39}
 40
 41impl<D: Data> Infos for LWEToGLWESwitchingKeyCompressed<D> {
 42    type Inner = MatZnx<D>;
 43
 44    fn inner(&self) -> &Self::Inner {
 45        &self.0.inner()
 46    }
 47
 48    fn basek(&self) -> usize {
 49        self.0.basek()
 50    }
 51
 52    fn k(&self) -> usize {
 53        self.0.k()
 54    }
 55}
 56
 57impl<D: Data> LWEToGLWESwitchingKeyCompressed<D> {
 58    pub fn digits(&self) -> usize {
 59        self.0.digits()
 60    }
 61
 62    pub fn rank(&self) -> usize {
 63        self.0.rank()
 64    }
 65
 66    pub fn rank_in(&self) -> usize {
 67        self.0.rank_in()
 68    }
 69
 70    pub fn rank_out(&self) -> usize {
 71        self.0.rank_out()
 72    }
 73}
 74
 75impl<D: DataMut> ReaderFrom for LWEToGLWESwitchingKeyCompressed<D> {
 76    fn read_from<R: std::io::Read>(&mut self, reader: &mut R) -> std::io::Result<()> {
 77        self.0.read_from(reader)
 78    }
 79}
 80
 81impl<D: DataRef> WriterTo for LWEToGLWESwitchingKeyCompressed<D> {
 82    fn write_to<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
 83        self.0.write_to(writer)
 84    }
 85}
 86
 87impl LWEToGLWESwitchingKeyCompressed<Vec<u8>> {
 88    pub fn alloc(n: usize, basek: usize, k: usize, rows: usize, rank_out: usize) -> Self {
 89        Self(GGLWESwitchingKeyCompressed::alloc(
 90            n, basek, k, rows, 1, 1, rank_out,
 91        ))
 92    }
 93
 94    pub fn encrypt_sk_scratch_space<B: Backend>(module: &Module<B>, n: usize, basek: usize, k: usize, rank_out: usize) -> usize
 95    where
 96        Module<B>: GGLWEEncryptSkFamily<B> + GLWESecretExecModuleFamily<B>,
 97    {
 98        LWEToGLWESwitchingKey::encrypt_sk_scratch_space(module, n, basek, k, rank_out)
 99    }
100}
101
102impl<D: DataMut, DR: DataRef, B: Backend> Decompress<B, LWEToGLWESwitchingKeyCompressed<DR>> for LWEToGLWESwitchingKey<D> {
103    fn decompress(&mut self, module: &Module<B>, other: &LWEToGLWESwitchingKeyCompressed<DR>)
104    where
105        Module<B>: crate::trait_families::DecompressFamily<B>,
106    {
107        self.0.decompress(module, &other.0);
108    }
109}