Struct GenericZeroHomomorphism 

pub struct GenericZeroHomomorphism<S: Module, T: Module<Algebra = S::Algebra>> {
    source: Arc<S>,
    target: Arc<T>,
    degree_shift: i32,
}

Fields

source: Arc<S>

target: Arc<T>

degree_shift: i32

Implementations

impl<S: Module, T: Module<Algebra = S::Algebra>> GenericZeroHomomorphism<S, T>

pub fn new(source: Arc<S>, target: Arc<T>, degree_shift: i32) -> Self

Trait Implementations

impl<S: Module, T: Module<Algebra = S::Algebra>> ModuleHomomorphism for GenericZeroHomomorphism<S, T>

type Source = S

type Target = T

fn source(&self) -> Arc<Self::Source>

fn target(&self) -> Arc<Self::Target>

fn degree_shift(&self) -> i32

fn apply_to_basis_element(&self, _: FpSliceMut<'_>, _: u32, _: i32, _: usize)

Calling this function when input_idx < source().dimension(input_degree) results in undefined behaviour. Implementations are encouraged to panic when this happens (this is usually the case because of out-of-bounds errors.

fn kernel(&self, degree: i32) -> Option<&Subspace>

fn quasi_inverse(&self, degree: i32) -> Option<&QuasiInverse>

fn image(&self, degree: i32) -> Option<&Subspace>

fn compute_auxiliary_data_through_degree(&self, degree: i32)

fn apply( &self, result: FpSliceMut<'_>, coeff: u32, input_degree: i32, input: FpSlice<'_>, )

fn prime(&self) -> ValidPrime

fn min_degree(&self) -> i32

fn auxiliary_data(&self, degree: i32) -> (Subspace, Subspace, QuasiInverse)

Compute the auxiliary data associated to the homomorphism at input degree degree. Returns it in the order image, kernel, quasi_inverse

fn get_matrix(&self, matrix: MatrixSliceMut<'_>, degree: i32)

Write the matrix of the homomorphism at input degree degree to matrix.

fn get_partial_matrix(&self, degree: i32, inputs: &[usize]) -> Matrix

Get the values of the homomorphism on the specified inputs to matrix.

fn apply_quasi_inverse( &self, result: FpSliceMut<'_>, degree: i32, input: FpSlice<'_>, ) -> bool

Attempt to apply quasi inverse to the input. Returns whether the operation was successful. This is required to either always succeed or always fail for each degree.

impl<S: Module, T: Module<Algebra = S::Algebra>> ZeroHomomorphism<S, T> for GenericZeroHomomorphism<S, T>

fn zero_homomorphism(source: Arc<S>, target: Arc<T>, degree_shift: i32) -> Self