Struct FreeAlgebraHom 

pub struct FreeAlgebraHom<R, S>
where
    R: RingStore,
    R::Type: FreeAlgebra,
    S: RingStore,
    S::Type: FreeAlgebra,
    <S::Type as RingExtension>::BaseRing: RingStore<Type = <<R::Type as RingExtension>::BaseRing as RingStore>::Type>,
{ /* private fields */ }

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.

Implementations

impl<R> FreeAlgebraHom<R, R>

where R: RingStore + Clone, R::Type: FreeAlgebra,

pub fn identity(ring: R) -> 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.

impl<R, S> FreeAlgebraHom<R, S>

where R: RingStore, R::Type: FreeAlgebra, S: RingStore, S::Type: FreeAlgebra, <S::Type as RingExtension>::BaseRing: RingStore<Type = <<R::Type as RingExtension>::BaseRing as RingStore>::Type>,

pub fn promise_is_well_defined( from: R, to: S, image_of_generator: El<S>, ) -> Self

Creates a new FreeAlgebraHom from R to S, mapping the canonical generator of R to the given element of S. This assumes that the resulting homomorphism is well-defined, i.e. the generating polynomial of R evaluated at image_of_generator gives zero in S.

The checked variant of this function is FreeAlgebraHom::new().

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 new(from: R, to: S, image_of_generator: El<S>) -> Self

Creates a new FreeAlgebraHom from R to S, mapping the canonical generator of R to the given element of S.

As opposed to FreeAlgebraHom::promise_is_well_defined(), this function checks that the resulting homomorphism is well-defined.

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 destruct(self) -> (R, S, El<S>)

Consumes this object, producing the domain ring store, the codomain ring store and the image of the canonical generator of the domain number field.

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

where R: RingStore, R::Type: FreeAlgebra, S: RingStore, S::Type: FreeAlgebra, <S::Type as RingExtension>::BaseRing: RingStore<Type = <<R::Type as RingExtension>::BaseRing as RingStore>::Type>,

type DomainStore = R

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

type CodomainStore = S

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

fn domain<'a>(&'a self) -> &'a Self::DomainStore

Returns a reference to the domain ring.

fn codomain<'a>(&'a self) -> &'a Self::CodomainStore

Returns a reference to the codomain ring.

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

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.