Struct CanHomRef 

pub struct CanHomRef<'a, R, S>
where
    R: RingStore,
    S: RingStore,
    S::Type: CanHomFrom<R::Type>,
{ /* private fields */ }

Available on crate feature unstable-enable only.

A wrapper of CanHomFrom::Homomorphism that does not own the data associated with the homomorphism. Use cases are rare, prefer to use CanHom whenever possible.

More concretely, this should only be used when you only have a reference to <R as CanHomFrom<S>>::Homomorphism, but cannot refactor code to wrap that object in a CanHom instead. The main situation where this occurs is when implementing CanHomFrom, since a the lifetime of CanHom is bound by the lifetime of the domain and codomain rings, but CanHomFrom::Type does not allow this.

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.

Implementations

impl<'a, R, S> CanHomRef<'a, R, S>

where R: RingStore, S: RingStore, S::Type: CanHomFrom<R::Type>,

pub fn raw_hom(&self) -> &<S::Type as CanHomFrom<R::Type>>::Homomorphism

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.

pub fn from_raw_parts( from: R, to: S, data: &'a <S::Type as CanHomFrom<R::Type>>::Homomorphism, ) -> Self

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<'a, R, S> Clone for CanHomRef<'a, R, S>

where R: RingStore + Clone, S: RingStore + Clone, S::Type: CanHomFrom<R::Type>,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, R, S> Homomorphism<<R as RingStore>::Type, <S as RingStore>::Type> for CanHomRef<'a, R, S>

where R: RingStore, S: RingStore, S::Type: CanHomFrom<R::Type>,

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 map(&self, el: El<R>) -> El<S>

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

fn map_ref(&self, el: &El<R>) -> El<S>

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

fn domain(&self) -> &R

Returns a reference to the domain ring.

fn codomain(&self) -> &S

Returns a reference to the codomain ring.

fn mul_assign_map(&self, lhs: &mut El<S>, rhs: El<R>)

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 El<S>, rhs: &El<R>)

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: &El<S>, rhs: &El<R>, summand: El<S>) -> El<S>

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

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 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.

impl<'a, R, S> Copy for CanHomRef<'a, R, S>

where R: RingStore + Copy, S: RingStore + Copy, S::Type: CanHomFrom<R::Type>, El<R>: Copy, El<S>: Copy,