@@ -10,7 +10,7 @@ use num_traits::{FromPrimitive, Num, One, PrimInt, ToPrimitive, WrappingSub, Zero};
 
 use crate::{
     backend::{ArithmeticOps, ModInit, ModularOpsU64, VectorOps},
-    decomposer::{gadget_vector, Decomposer, DefaultDecomposer, NumInfo},
+    decomposer::{Decomposer, DefaultDecomposer, NumInfo},
     lwe::{decrypt_lwe, encrypt_lwe, lwe_key_switch, lwe_ksk_keygen, measure_noise_lwe, LweSecret},
     multi_party::public_key_share,
     ntt::{self, Ntt, NttBackendU64, NttInit},
@@ -715,11 +715,7 @@
             let sk_rlwe = &client_key.sk_rlwe;
             let sk_lwe = &client_key.sk_lwe;
 
-            let d_rgsw_gadget_vec = gadget_vector(
-                self.parameters.rlwe_logq,
-                self.parameters.logb_rgsw,
-                self.parameters.d_rgsw,
-            );
+            let d_rgsw_gadget_vec = self.decomposer_rlwe.gadget_vector();
 
             // generate auto keys -g, g
             let mut auto_keys = HashMap::new();
@@ -775,11 +771,7 @@ })
                 .collect_vec();
 
             // LWE KSK from RLWE secret s -> LWE secret z
-            let d_lwe_gadget = gadget_vector(
-                self.parameters.lwe_logq,
-                self.parameters.logb_lwe,
-                self.parameters.d_lwe,
-            );
+            let d_lwe_gadget = self.decomposer_lwe.gadget_vector();
 
             let mut lwe_ksk = M::R::zeros(self.parameters.d_lwe * ring_size);
             lwe_ksk_keygen(
@@ -822,8 +814,7 @@ let d_lwe = self.parameters.d_lwe;
             let rlwe_q = self.parameters.rlwe_q;
             let lwe_q = self.parameters.lwe_q;
 
-            let d_rgsw_gadget_vec =
-                gadget_vector(self.parameters.rlwe_logq, self.parameters.logb_rgsw, d_rgsw);
+            let d_rgsw_gadget_vec = self.decomposer_rlwe.gadget_vector();
 
             let rlweq_modop = ModOp::new(rlwe_q);
             let rlweq_nttop = NttOp::new(rlwe_q, ring_size);
@@ -887,8 +878,7 @@
             // LWE ksk
             let mut lwe_ksk = M::R::zeros(d_lwe * ring_size);
             let lwe_modop = ModOp::new(lwe_q);
-            let d_lwe_gadget_vec =
-                gadget_vector(self.parameters.lwe_logq, self.parameters.logb_lwe, d_lwe);
+            let d_lwe_gadget_vec = self.decomposer_lwe.gadget_vector();
             lwe_ksk_keygen(
                 sk_rlwe.values(),
                 sk_lwe.values(),
@@ -1944,8 +1934,10 @@ let lwe_logq = 18;
         let lwe_q = 1 << lwe_logq;
         let d_lwe = 1;
         let logb_lwe = 6;
-        let lwe_gadgect_vec = gadget_vector(lwe_logq, logb_lwe, d_lwe);
         let lweq_modop = ModularOpsU64::new(lwe_q);
+
+        let decomposer = DefaultDecomposer::new(lwe_q, logb_lwe, d_lwe);
+        let lwe_gadgect_vec = decomposer.gadget_vector();
         let logp = 2;
 
         let from_lwe_n = 2048;
@@ -2020,7 +2012,6 @@
             // Key switch
             let lwe_ct_key_switched = {
                 let mut lwe_ct_key_switched = vec![0u64; to_lwe_n + 1];
-                let decomposer = DefaultDecomposer::new(lwe_q, logb_lwe, d_lwe);
                 lwe_key_switch(
                     &mut lwe_ct_key_switched,
                     &lwe_ct,
@@ -2214,12 +2205,7 @@ }
 
         // Measure noise in RGSW ciphertexts of ideal LWE secrets
         if true {
-            let gadget_vec = gadget_vector(
-                bool_evaluator.parameters.rlwe_logq,
-                bool_evaluator.parameters.logb_rgsw,
-                bool_evaluator.parameters.d_rgsw,
-            );
-
+            let gadget_vec = rlwe_decomposer.gadget_vector();
             for i in 0..20 {
                 // measure noise in RGSW(s[i])
                 let si =
@@ -2548,11 +2534,7 @@ let lwe_modop = &bool_evaluator.lwe_modop;
         let rlwe_nttop = &bool_evaluator.rlwe_nttop;
         let rlwe_modop = &bool_evaluator.rlwe_modop;
         let rlwe_decomposer = &bool_evaluator.decomposer_rlwe;
-        let rlwe_gadget_vector = gadget_vector(
-            bool_evaluator.parameters.rlwe_logq,
-            bool_evaluator.parameters.logb_rgsw,
-            d_rgsw,
-        );
+        let rlwe_gadget_vector = rlwe_decomposer.gadget_vector();
 
         let parties = (0..no_of_parties)
             .map(|_| bool_evaluator.client_key())

@@ -4,7 +4,7 @@ use std::{fmt::Debug, marker::PhantomData, ops::Rem};
 
 use crate::backend::{ArithmeticOps, ModularOpsU64};
 
-pub fn gadget_vector<T: PrimInt>(logq: usize, logb: usize, d: usize) -> Vec<T> {
+fn gadget_vector<T: PrimInt>(logq: usize, logb: usize, d: usize) -> Vec<T> {
     let d_ideal = (logq as f64 / logb as f64).ceil().to_usize().unwrap();
     let ignored_limbs = d_ideal - d;
     (ignored_limbs..ignored_limbs + d)
@@ -82,6 +82,10 @@ )),
             )
         }
         value
+    }
+
+    pub(crate) fn gadget_vector(&self) -> Vec<T> {
+        return gadget_vector(self.logq, self.logb, self.d);
     }
 }
 

@@ -274,7 +274,7 @@ mod tests {
 
     use crate::{
         backend::{ModInit, ModularOpsU64},
-        decomposer::{gadget_vector, DefaultDecomposer},
+        decomposer::DefaultDecomposer,
         lwe::{lwe_key_switch, measure_noise_lwe},
         random::DefaultSecureRng,
         rgsw::measure_noise,
@@ -342,7 +342,8 @@ rng.fill_bytes(&mut ksk_seed);
             let mut seeded_ksk =
                 SeededLweKeySwitchingKey::empty(lwe_in_n, lwe_out_n, d_ks, ksk_seed, q);
             let mut p_rng = DefaultSecureRng::new_seeded(ksk_seed);
-            let gadget = gadget_vector(logq, logb, d_ks);
+            let decomposer = DefaultDecomposer::new(q, logb, d_ks);
+            let gadget = decomposer.gadget_vector();
             lwe_ksk_keygen(
                 &lwe_sk_in.values(),
                 &lwe_sk_out.values(),

@@ -4,7 +4,7 @@ use rand::{thread_rng, Rng};
 
     use crate::{
         backend::{ArithmeticOps, ModInit, ModularOpsU64},
-        decomposer::{gadget_vector, Decomposer, DefaultDecomposer},
+        decomposer::{Decomposer, DefaultDecomposer},
         ntt::{Ntt, NttBackendU64, NttInit},
         random::{DefaultSecureRng, RandomGaussianDist, RandomUniformDist},
         rgsw::{
@@ -30,7 +30,8 @@
         let sk = RlweSecret::random((ring_size >> 1) as usize, ring_size as usize);
 
         let mut rng = DefaultSecureRng::new();
-        let gadget_vector = gadget_vector(logq, logb, d0);
+        let decomposer = DefaultDecomposer::new(q, logb, d0);
+        let gadget_vector = decomposer.gadget_vector();
 
         for i in 0..100 {
             // m should have norm 1
@@ -82,7 +83,6 @@ );
 
             // RLWE(m0m1) = RLWE(m1) x RGSW(m0)
             let mut scratch = vec![vec![0u64; ring_size]; d0 + 2];
-            let decomposer = DefaultDecomposer::new(q, logb, d0);
             less1_rlwe_by_rgsw(
                 &mut rlwe,
                 &rgsw.data,
@@ -122,9 +122,9 @@
         let sk = RlweSecret::random((ring_size >> 1) as usize, ring_size as usize);
 
         let mut rng = DefaultSecureRng::new();
-        let gadget_vector = gadget_vector(logq, logb, d0);
 
         let decomposer = DefaultDecomposer::new(q, logb, d0);
+        let gadget_vector = decomposer.gadget_vector();
 
         for i in 0..100 {
             let modq_op = ModularOpsU64::new(q);

@@ -1502,7 +1502,7 @@ use rand::{thread_rng, Rng};
 
     use crate::{
         backend::{ModInit, ModularOpsU64, VectorOps},
-        decomposer::{gadget_vector, DefaultDecomposer},
+        decomposer::DefaultDecomposer,
         ntt::{self, Ntt, NttBackendU64, NttInit},
         random::{DefaultSecureRng, NewWithSeed, RandomUniformDist},
         rgsw::{
@@ -1600,7 +1600,8 @@ m1[thread_rng().gen_range(0..ring_size) as usize] = 1;
 
         let ntt_op = NttBackendU64::new(q, ring_size as usize);
         let mod_op = ModularOpsU64::new(q);
-        let gadget_vector = gadget_vector(logq, logb, d_rgsw);
+        let decomposer = DefaultDecomposer::new(q, logb, d_rgsw);
+        let gadget_vector = decomposer.gadget_vector();
 
         // Encrypt m1 as RGSW(m1)
         let rgsw_ct = {
@@ -1665,7 +1666,6 @@ };
 
         // RLWE(m0m1) = RLWE(m0) x RGSW(m1)
         let mut scratch_space = vec![vec![0u64; ring_size as usize]; d_rgsw + 2];
-        let decomposer = DefaultDecomposer::new(q, logb, d_rgsw);
         rlwe_by_rgsw(
             &mut rlwe_in_ct,
             &rgsw_ct.data,
@@ -1752,8 +1752,8 @@ let s = RlweSecret::random((ring_size >> 1) as usize, ring_size as usize);
 
         let ntt_op = NttBackendU64::new(q, ring_size as usize);
         let mod_op = ModularOpsU64::new(q);
-        let gadget_vector = gadget_vector(logq, logb, d_rgsw);
         let decomposer = DefaultDecomposer::new(q, logb, d_rgsw);
+        let gadget_vector = decomposer.gadget_vector();
 
         let mul_mod = |v0: &u64, v1: &u64| ((*v0 as u128 * *v1 as u128) % (q as u128)) as u64;
 
@@ -1930,8 +1930,8 @@
         let mut rng = DefaultSecureRng::new();
         let ntt_op = NttBackendU64::new(q, ring_size as usize);
         let mod_op = ModularOpsU64::new(q);
-        let gadget_vector = gadget_vector(logq, logb, d_rgsw);
         let decomposer = DefaultDecomposer::new(q, logb, d_rgsw);
+        let gadget_vector = decomposer.gadget_vector();
 
         let mul_mod = |a: &u64, b: &u64| ((*a as u128 * *b as u128) % q as u128) as u64;
 
@@ -2051,8 +2051,8 @@
         let mut rng = DefaultSecureRng::new();
         let ntt_op = NttBackendU64::new(q, ring_size as usize);
         let mod_op = ModularOpsU64::new(q);
-        let gadget_vector = gadget_vector(logq, logb, d_rgsw);
         let decomposer = DefaultDecomposer::new(q, logb, d_rgsw);
+        let gadget_vector = decomposer.gadget_vector();
         let mul_mod = |a: &u64, b: &u64| ((*a as u128 * *b as u128) % q as u128) as u64;
 
         let mut carry_m = vec![0u64; ring_size as usize];
@@ -2167,7 +2167,8 @@ let mut seed_auto = [0u8; 32];
         rng.fill_bytes(&mut seed_auto);
         let mut seeded_auto_key = SeededAutoKey::empty(ring_size as usize, d_rgsw, seed_auto, q);
         let mut p_rng = DefaultSecureRng::new_seeded(seed_auto);
-        let gadget_vector = gadget_vector(logq, logb, d_rgsw);
+        let decomposer = DefaultDecomposer::new(q, logb, d_rgsw);
+        let gadget_vector = decomposer.gadget_vector();
         galois_key_gen(
             &mut seeded_auto_key.data,
             s.values(),
@@ -2186,7 +2187,6 @@
         // Send RLWE_{s}(m) -> RLWE_{s}(m^k)
         let mut scratch_space = vec![vec![0u64; ring_size as usize]; d_rgsw + 2];
         let (auto_map_index, auto_map_sign) = generate_auto_map(ring_size as usize, auto_k);
-        let decomposer = DefaultDecomposer::new(q, logb, d_rgsw);
         galois_auto(
             &mut rlwe_m,
             &auto_key.data,