Struct CanIso

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

A wrapper around CanIsoFromTo::Isomorphism that references the domain and codomain rings, making it much easier to use. This also contains the homomorphism in the other direction, i.e. allows mapping in both directions.

Example

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

See also

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

Implementations

impl<R, S> CanIso<R, S>

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

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

pub fn into_inv(self) -> CanHom<R, S>

pub fn inv<'a>(&'a self) -> CanHom<&'a R, &'a S>

pub fn raw_iso(&self) -> &<S::Type as CanIsoFromTo<R::Type>>::Isomorphism

Trait Implementations

impl<R, S> Clone for CanIso<R, S>

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

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R, S> Debug for CanIso<R, S>

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

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

Formats the value using the given formatter.

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

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

type DomainStore = S

type CodomainStore = R

fn map(&self, x: El<S>) -> El<R>

fn domain(&self) -> &S

fn codomain(&self) -> &R

fn map_ref(&self, x: &Domain::Element) -> Codomain::Element

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

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

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

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

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

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

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

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