Struct AlmostExactSharedBaseConversion

pub struct AlmostExactSharedBaseConversion<A = Global>
where
    A: Allocator + Clone,
{ /* private fields */ }

Computes almost exact base conversion with a shared factor. The exact map would be

  Z/aqZ -> Z/aq'Z, x -> lift(x) mod aq'

but as usual, we allow an error of +/- aq, unless the shortest lift of the input is bounded by aq/4, in which case the result is always correct.

The functionality is exactly as for super::lift::AlmostExactBaseConversion, except that it might be faster by reusing the shared factor a.

Implementations

impl<A> AlmostExactSharedBaseConversion<A>

where A: Allocator + Clone,

pub fn new_with( shared_moduli: Vec<Zn>, additional_in_moduli: Vec<Zn>, additional_out_moduli: Vec<Zn>, allocator: A, ) -> Self

Creates a new AlmostExactSharedBaseConversion, where

• a is the product of shared_moduli
• q is the product of additional_in_moduli
• a' is the product of additional_out_moduli

The input resp. output moduli are ordered as in shared_moduli, followed by additional_in_moduli resp. additional_out_moduli. In other words, the additional moduli are appended at the end to the shared moduli.

Trait Implementations

impl<A> RNSOperation for AlmostExactSharedBaseConversion<A>

where A: Allocator + Clone,

type Ring = RingValue<ZnBase>

type RingType = ZnBase

fn input_rings<'a>(&'a self) -> &'a [Self::Ring]

fn output_rings<'a>(&'a self) -> &'a [Self::Ring]

fn apply<V1, V2>( &self, input: Submatrix<'_, V1, El<Self::Ring>>, output: SubmatrixMut<'_, V2, El<Self::Ring>>, )

where V1: AsPointerToSlice<El<Self::Ring>>, V2: AsPointerToSlice<El<Self::Ring>>,

Applies the RNS operation to each column of the given matrix, and writes the results to the columns of output. The entries of the i-th row are considered to be elements of self.input_rings().at(i) resp. self.output_rings().at(i).