Struct LambdaHom 

pub struct LambdaHom<R: RingStore, S: RingStore, F>
where
    F: Fn(&R, &S, &El<R>) -> El<S>,
{ /* private fields */ }

A homomorphism between rings R -> S, with its action on elements defined by a user-provided closure.

It is up to the user to ensure that the given closure indeed satisfies the ring homomorphism axioms:

• For x, y in R, it should satisfy f(x) + f(y) = f(x + y)
• For x, y in R, it should satisfy f(x) * f(y) = f(x * y)
• It should map f(0) = 0 and f(1) = 1

Hence, a LambdaHom should only be used if none of the builtin homomorphisms can achieve the same result, since a function that does not follow the above axioms will make algorithms misbehave, and can lead to hard-to-debug errors.

Implementations

impl<R: RingStore, S: RingStore, F> LambdaHom<R, S, F>

where F: Fn(&R, &S, &El<R>) -> El<S>,

pub fn new(from: R, to: S, f: F) -> Self

Creates a new LambdaHom from from to to, mapping elements as specified by the given function.

It is up to the user to ensure that the given closure indeed satisfies the ring homomorphism axioms:

• For x, y in R, it should satisfy f(x) + f(y) = f(x + y)
• For x, y in R, it should satisfy f(x) * f(y) = f(x * y)
• It should map f(0) = 0 and f(1) = 1

Hence, a LambdaHom should only be used if none of the builtin homomorphisms can achieve the same result, since a function that does not follow the above axioms will make algorithms misbehave, and can lead to hard-to-debug errors.

pub fn into_domain_codomain(self) -> (R, S)

Available on crate feature unstable-enable only.

Returns the stored domain and codomain rings, consuming this object.

Availability

This API is marked as unstable and is only available when the unstable-enable crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.

Trait Implementations

impl<R: Clone + RingStore, S: Clone + RingStore, F> Clone for LambdaHom<R, S, F>

where F: Fn(&R, &S, &El<R>) -> El<S> + Clone,

fn clone(&self) -> LambdaHom<R, S, F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R, S, F> Copy for LambdaHom<R, S, F>

where F: Copy + Fn(&R, &S, &El<R>) -> El<S>, R: Copy + RingStore, El<R>: Copy, S: Copy + RingStore, El<S>: Copy,

impl<R: RingStore, S: RingStore, F> Homomorphism<<R as RingStore>::Type, <S as RingStore>::Type> for LambdaHom<R, S, F>

where F: Fn(&R, &S, &El<R>) -> El<S>,

type CodomainStore = S

The type of the RingStore used by this object to store the codomain ring.

type DomainStore = R

The type of the RingStore used by this object to store the domain ring.

fn codomain(&self) -> &Self::CodomainStore

Returns a reference to the codomain ring.

fn domain(&self) -> &Self::DomainStore

Returns a reference to the domain ring.

fn map(&self, x: El<R>) -> <S::Type as RingBase>::Element

Applies this homomorphism to the given element from the domain ring, resulting in an element in the codomain ring.

fn map_ref(&self, x: &El<R>) -> <S::Type as RingBase>::Element

Applies this homomorphism to the given element from the domain ring, resulting in an element in the codomain ring.

fn mul_assign_map(&self, lhs: &mut Codomain::Element, rhs: Domain::Element)

Multiplies the given element in the codomain ring with an element obtained by applying this homomorphism to a given element from the domain ring.

fn mul_assign_ref_map(&self, lhs: &mut Codomain::Element, rhs: &Domain::Element)

Multiplies the given element in the codomain ring with an element obtained by applying this homomorphism to a given element from the domain ring.

fn mul_map( &self, lhs: Codomain::Element, rhs: Domain::Element, ) -> Codomain::Element

Multiplies the given element in the codomain ring with an element obtained by applying this homomorphism to a given element from the domain ring.

fn fma_map( &self, lhs: &Codomain::Element, rhs: &Domain::Element, summand: Codomain::Element, ) -> Codomain::Element

Fused-multiply-add. This computes lhs * rhs + summand, where rhs is mapped into the ring via this homomorphism.

fn mul_ref_fst_map( &self, lhs: &Codomain::Element, rhs: Domain::Element, ) -> Codomain::Element

Multiplies the given element in the codomain ring with an element obtained by applying this homomorphism to a given element from the domain ring.

fn mul_ref_snd_map( &self, lhs: Codomain::Element, rhs: &Domain::Element, ) -> Codomain::Element

Multiplies the given element in the codomain ring with an element obtained by applying this homomorphism to a given element from the domain ring.

fn mul_ref_map( &self, lhs: &Codomain::Element, rhs: &Domain::Element, ) -> Codomain::Element

Multiplies the given element in the codomain ring with an element obtained by applying this homomorphism to a given element from the domain ring.

fn compose<F, PrevDomain: ?Sized + RingBase>( self, prev: F, ) -> ComposedHom<PrevDomain, Domain, Codomain, F, Self>

where Self: Sized, F: Homomorphism<PrevDomain, Domain>,

Constructs the homomorphism x -> self.map(prev.map(x)).

fn mul_assign_ref_map_through_hom<First: ?Sized + RingBase, H: Homomorphism<First, Domain>>( &self, lhs: &mut Codomain::Element, rhs: &First::Element, hom: H, )

Multiplies the given element in the codomain ring with an element obtained by applying this and another homomorphism to a given element from another ring.

fn mul_assign_map_through_hom<First: ?Sized + RingBase, H: Homomorphism<First, Domain>>( &self, lhs: &mut Codomain::Element, rhs: First::Element, hom: H, )

Multiplies the given element in the codomain ring with an element obtained by applying this and another homomorphism to a given element from another ring.