Struct FullModuleHomomorphism 

pub struct FullModuleHomomorphism<S: Module, T: Module<Algebra = S::Algebra> = S> {
    source: Arc<S>,
    target: Arc<T>,
    degree_shift: i32,
    matrices: OnceBiVec<Matrix>,
    quasi_inverses: OnceBiVec<QuasiInverse>,
    kernels: OnceBiVec<Subspace>,
    images: OnceBiVec<Subspace>,
}

A ModuleHomomorphism that simply records the matrix of the homomorphism in every degree. This is currently rather bare bones.

Fields

source: Arc<S>

target: Arc<T>

degree_shift: i32

matrices: OnceBiVec<Matrix>

The matrices of the module homomorphism. Unspecified matrices are assumed to be zero

quasi_inverses: OnceBiVec<QuasiInverse>

kernels: OnceBiVec<Subspace>

images: OnceBiVec<Subspace>

Implementations

impl<A, S, T> FullModuleHomomorphism<S, T>

where A: Algebra, S: Module<Algebra = A>, T: Module<Algebra = A>,

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

pub fn from_matrices( source: Arc<S>, target: Arc<T>, degree_shift: i32, matrices: BiVec<Matrix>, ) -> Self

pub fn from<F: ModuleHomomorphism<Source = S, Target = T>>(f: &F) -> Self

pub fn replace_source<S_: Module<Algebra = A>>( self, source: Arc<S_>, ) -> FullModuleHomomorphism<S_, T>

This function replaces the source of the ModuleHomomorphism and does nothing else. This is useful for changing the type of the source (but not the mathematical module itself).

pub fn replace_target<T_: Module<Algebra = A>>( self, target: Arc<T_>, ) -> FullModuleHomomorphism<S, T_>

See replace_source

Trait Implementations

impl<S: Module, T: Module<Algebra = S::Algebra>> Clone for FullModuleHomomorphism<S, T>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S: Module> IdentityHomomorphism<S> for FullModuleHomomorphism<S, S>

fn identity_homomorphism(source: Arc<S>) -> Self

impl<S: Module, T: Module<Algebra = S::Algebra>> ModuleHomomorphism for FullModuleHomomorphism<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, result: FpSliceMut<'_>, coeff: u32, input_degree: i32, input_idx: 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 image(&self, degree: i32) -> Option<&Subspace>

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

fn kernel(&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 FullModuleHomomorphism<S, T>

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