Struct CanHom 

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

A high-level wrapper of CanHomFrom::Homomorphism that references the domain and codomain rings, and is much easier to use.

Example

let from = StaticRing::<i32>::RING;
let to = StaticRing::<i64>::RING;
let hom = to.can_hom(&from).unwrap();
assert_eq!(7, hom.map(7));
// instead of
let hom = to.get_ring().has_canonical_hom(from.get_ring()).unwrap();
assert_eq!(7, to.get_ring().map_in(from.get_ring(), 7, &hom));

See also

The “bi-directional” variant CanHom, the basic interfaces CanHomFrom and CanIsoFromTo and the very simplified function RingStore::coerce.

Implementations

impl<R, S> CanHom<R, S>

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

pub fn new(from: R, to: S) -> Result<Self, (R, S)>

Creates a new CanHom from from to to, if the corresonding rings support it.

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

Returns a reference to the underlying CanHomFrom::Homomorphism.

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

Returns the underlying CanHomFrom::Homomorphism, consuming this object.

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

Available on crate feature unstable-enable only.

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, S> Clone for CanHom<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<R, S> Debug for CanHom<R, S>

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

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<R, S> Homomorphism<<R as RingStore>::Type, <S as RingStore>::Type> for CanHom<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.