1use backend::{FFT64, Module, Scratch, VecZnxOps};
  2
  3use crate::{AutomorphismKey, GLWECiphertext};
  4
  5impl GLWECiphertext<Vec<u8>> {
  6    pub fn automorphism_scratch_space(
  7        module: &Module<FFT64>,
  8        basek: usize,
  9        k_out: usize,
 10        k_in: usize,
 11        k_ksk: usize,
 12        digits: usize,
 13        rank: usize,
 14    ) -> usize {
 15        Self::keyswitch_scratch_space(module, basek, k_out, k_in, k_ksk, digits, rank, rank)
 16    }
 17
 18    pub fn automorphism_inplace_scratch_space(
 19        module: &Module<FFT64>,
 20        basek: usize,
 21        k_out: usize,
 22        k_ksk: usize,
 23        digits: usize,
 24        rank: usize,
 25    ) -> usize {
 26        Self::keyswitch_inplace_scratch_space(module, basek, k_out, k_ksk, digits, rank)
 27    }
 28}
 29
 30impl<DataSelf: AsRef<[u8]> + AsMut<[u8]>> GLWECiphertext<DataSelf> {
 31    pub fn automorphism<DataLhs: AsRef<[u8]>, DataRhs: AsRef<[u8]>>(
 32        &mut self,
 33        module: &Module<FFT64>,
 34        lhs: &GLWECiphertext<DataLhs>,
 35        rhs: &AutomorphismKey<DataRhs, FFT64>,
 36        scratch: &mut Scratch,
 37    ) {
 38        self.keyswitch(module, lhs, &rhs.key, scratch);
 39        (0..self.rank() + 1).for_each(|i| {
 40            module.vec_znx_automorphism_inplace(rhs.p(), &mut self.data, i);
 41        })
 42    }
 43
 44    pub fn automorphism_inplace<DataRhs: AsRef<[u8]>>(
 45        &mut self,
 46        module: &Module<FFT64>,
 47        rhs: &AutomorphismKey<DataRhs, FFT64>,
 48        scratch: &mut Scratch,
 49    ) {
 50        self.keyswitch_inplace(module, &rhs.key, scratch);
 51        (0..self.rank() + 1).for_each(|i| {
 52            module.vec_znx_automorphism_inplace(rhs.p(), &mut self.data, i);
 53        })
 54    }
 55
 56    pub fn automorphism_add<DataLhs: AsRef<[u8]>, DataRhs: AsRef<[u8]>>(
 57        &mut self,
 58        module: &Module<FFT64>,
 59        lhs: &GLWECiphertext<DataLhs>,
 60        rhs: &AutomorphismKey<DataRhs, FFT64>,
 61        scratch: &mut Scratch,
 62    ) {
 63        Self::keyswitch_private::<_, _, 1>(self, rhs.p(), module, lhs, &rhs.key, scratch);
 64    }
 65
 66    pub fn automorphism_add_inplace<DataRhs: AsRef<[u8]>>(
 67        &mut self,
 68        module: &Module<FFT64>,
 69        rhs: &AutomorphismKey<DataRhs, FFT64>,
 70        scratch: &mut Scratch,
 71    ) {
 72        unsafe {
 73            let self_ptr: *mut GLWECiphertext<DataSelf> = self as *mut GLWECiphertext<DataSelf>;
 74            Self::keyswitch_private::<_, _, 1>(self, rhs.p(), module, &*self_ptr, &rhs.key, scratch);
 75        }
 76    }
 77
 78    pub fn automorphism_sub_ab<DataLhs: AsRef<[u8]>, DataRhs: AsRef<[u8]>>(
 79        &mut self,
 80        module: &Module<FFT64>,
 81        lhs: &GLWECiphertext<DataLhs>,
 82        rhs: &AutomorphismKey<DataRhs, FFT64>,
 83        scratch: &mut Scratch,
 84    ) {
 85        Self::keyswitch_private::<_, _, 2>(self, rhs.p(), module, lhs, &rhs.key, scratch);
 86    }
 87
 88    pub fn automorphism_sub_ab_inplace<DataRhs: AsRef<[u8]>>(
 89        &mut self,
 90        module: &Module<FFT64>,
 91        rhs: &AutomorphismKey<DataRhs, FFT64>,
 92        scratch: &mut Scratch,
 93    ) {
 94        unsafe {
 95            let self_ptr: *mut GLWECiphertext<DataSelf> = self as *mut GLWECiphertext<DataSelf>;
 96            Self::keyswitch_private::<_, _, 2>(self, rhs.p(), module, &*self_ptr, &rhs.key, scratch);
 97        }
 98    }
 99
100    pub fn automorphism_sub_ba<DataLhs: AsRef<[u8]>, DataRhs: AsRef<[u8]>>(
101        &mut self,
102        module: &Module<FFT64>,
103        lhs: &GLWECiphertext<DataLhs>,
104        rhs: &AutomorphismKey<DataRhs, FFT64>,
105        scratch: &mut Scratch,
106    ) {
107        Self::keyswitch_private::<_, _, 3>(self, rhs.p(), module, lhs, &rhs.key, scratch);
108    }
109
110    pub fn automorphism_sub_ba_inplace<DataRhs: AsRef<[u8]>>(
111        &mut self,
112        module: &Module<FFT64>,
113        rhs: &AutomorphismKey<DataRhs, FFT64>,
114        scratch: &mut Scratch,
115    ) {
116        unsafe {
117            let self_ptr: *mut GLWECiphertext<DataSelf> = self as *mut GLWECiphertext<DataSelf>;
118            Self::keyswitch_private::<_, _, 3>(self, rhs.p(), module, &*self_ptr, &rhs.key, scratch);
119        }
120    }
121}