wip

poulpy-core/src/layouts/gglwe_ct.rs

@@ -3,7 +3,7 @@ use poulpy_hal::{
     source::Source,
 };
 
-use crate::layouts::{Base2K, BuildError, Degree, Dnum, Dsize, GLWECiphertext, GLWEInfos, LWEInfos, Rank, TorusPrecision};
+use crate::layouts::{Base2K, Degree, Dnum, Dsize, GLWECiphertext, GLWEInfos, LWEInfos, Rank, TorusPrecision};
 use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
 
 use std::fmt;
@@ -132,107 +132,6 @@ impl<D: Data> GGLWEInfos for GGLWE<D> {
     }
 }
 
-pub struct GGLWECiphertextBuilder<D: Data> {
-    data: Option<MatZnx<D>>,
-    base2k: Option<Base2K>,
-    k: Option<TorusPrecision>,
-    dsize: Option<Dsize>,
-}
-
-impl<D: Data> GGLWE<D> {
-    #[inline]
-    pub fn builder() -> GGLWECiphertextBuilder<D> {
-        GGLWECiphertextBuilder {
-            data: None,
-            base2k: None,
-            k: None,
-            dsize: None,
-        }
-    }
-}
-
-impl GGLWECiphertextBuilder<Vec<u8>> {
-    #[inline]
-    pub fn layout<A>(mut self, infos: &A) -> Self
-    where
-        A: GGLWEInfos,
-    {
-        self.data = Some(MatZnx::alloc(
-            infos.n().into(),
-            infos.dnum().into(),
-            infos.rank_in().into(),
-            (infos.rank_out() + 1).into(),
-            infos.size(),
-        ));
-        self.base2k = Some(infos.base2k());
-        self.k = Some(infos.k());
-        self.dsize = Some(infos.dsize());
-        self
-    }
-}
-
-impl<D: Data> GGLWECiphertextBuilder<D> {
-    #[inline]
-    pub fn data(mut self, data: MatZnx<D>) -> Self {
-        self.data = Some(data);
-        self
-    }
-    #[inline]
-    pub fn base2k(mut self, base2k: Base2K) -> Self {
-        self.base2k = Some(base2k);
-        self
-    }
-    #[inline]
-    pub fn k(mut self, k: TorusPrecision) -> Self {
-        self.k = Some(k);
-        self
-    }
-
-    #[inline]
-    pub fn dsize(mut self, dsize: Dsize) -> Self {
-        self.dsize = Some(dsize);
-        self
-    }
-
-    pub fn build(self) -> Result<GGLWE<D>, BuildError> {
-        let data: MatZnx<D> = self.data.ok_or(BuildError::MissingData)?;
-        let base2k: Base2K = self.base2k.ok_or(BuildError::MissingBase2K)?;
-        let k: TorusPrecision = self.k.ok_or(BuildError::MissingK)?;
-        let dsize: Dsize = self.dsize.ok_or(BuildError::MissingDigits)?;
-
-        if base2k == 0_u32 {
-            return Err(BuildError::ZeroBase2K);
-        }
-
-        if dsize == 0_u32 {
-            return Err(BuildError::ZeroBase2K);
-        }
-
-        if k == 0_u32 {
-            return Err(BuildError::ZeroTorusPrecision);
-        }
-
-        if data.n() == 0 {
-            return Err(BuildError::ZeroDegree);
-        }
-
-        if data.cols() == 0 {
-            return Err(BuildError::ZeroCols);
-        }
-
-        if data.size() == 0 {
-            return Err(BuildError::ZeroLimbs);
-        }
-
-        Ok(GGLWE {
-            data,
-            base2k,
-            k,
-            dsize,
-        })
-    }
-}
-
 impl<D: DataRef> GGLWE<D> {
     pub fn data(&self) -> &MatZnx<D> {
         &self.data
@@ -272,23 +171,21 @@ impl<D: DataRef> fmt::Display for GGLWE<D> {
 
 impl<D: DataRef> GGLWE<D> {
     pub fn at(&self, row: usize, col: usize) -> GLWECiphertext<&[u8]> {
-        GLWECiphertext::builder()
-            .data(self.data.at(row, col))
-            .base2k(self.base2k())
-            .k(self.k())
-            .build()
-            .unwrap()
+        GLWECiphertext {
+            k: self.k,
+            base2k: self.base2k,
+            data: self.data.at(row, col),
+        }
     }
 }
 
 impl<D: DataMut> GGLWE<D> {
     pub fn at_mut(&mut self, row: usize, col: usize) -> GLWECiphertext<&mut [u8]> {
-        GLWECiphertext::builder()
-            .base2k(self.base2k())
-            .k(self.k())
-            .data(self.data.at_mut(row, col))
-            .build()
-            .unwrap()
+        GLWECiphertext {
+            k: self.k,
+            base2k: self.base2k,
+            data: self.data.at_mut(row, col),
+        }
     }
 }