Struct abstalg::QuotientRing

pub struct QuotientRing<A> where
    A: EuclideanDomain, { /* private fields */ }

A quotient ring of an Euclidean domain by a principal ideal.

Implementations

impl<A> QuotientRing<A> where
    A: EuclideanDomain, 

pub fn new(base: A, modulo: A::Elem) -> Self

Creates a new quotient ring from the given Euclidean domain and one of its element.

pub fn base(&self) -> &A

Returns the base ring from which this ring was constructed.

pub fn modulo(&self) -> &A::Elem

Returns the modulo element from which this ring was constructed.

Trait Implementations

impl<A> AbelianGroup for QuotientRing<A> where
    A: EuclideanDomain, 

fn zero(&self) -> Self::Elem

The additive identity element of the ring.

fn neg(&self, elem: &Self::Elem) -> Self::Elem

The additive inverse of the given element.

fn add(&self, elem1: &Self::Elem, elem2: &Self::Elem) -> Self::Elem

The additive sum of the given elements

fn is_zero(&self, elem: &Self::Elem) -> bool

Checks if the given element is the additive identity of the ring.

fn neg_assign(&self, elem: &mut Self::Elem)

The element is changed to its additive inverse.

fn add_assign(&self, elem1: &mut Self::Elem, elem2: &Self::Elem)

The second element is added to the first one.

fn double(&self, elem: &mut Self::Elem)

Doubles the given element in place.

fn sub(&self, elem1: &Self::Elem, elem2: &Self::Elem) -> Self::Elem

The difference of the given elements.

fn sub_assign(&self, elem1: &mut Self::Elem, elem2: &Self::Elem)

The second element is subtracted from the first one.

fn times(&self, num: isize, elem: &Self::Elem) -> Self::Elem

Returns an integer multiple of the given element.

impl<A: Clone> Clone for QuotientRing<A> where
    A: EuclideanDomain,
    A::Elem: Clone, 

fn clone(&self) -> QuotientRing<A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Debug> Debug for QuotientRing<A> where
    A: EuclideanDomain,
    A::Elem: Debug, 

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

Formats the value using the given formatter.

impl<A> Domain for QuotientRing<A> where
    A: EuclideanDomain, 

type Elem = <A as Domain>::Elem

The type of the elements of this domain.

fn contains(&self, elem: &Self::Elem) -> bool

Checks if the given object is a member of the domain.

fn equals(&self, elem1: &Self::Elem, elem2: &Self::Elem) -> bool

Checks if the given objects represent the same element of the set.

impl<A> Monoid for QuotientRing<A> where
    A: EuclideanDomain, 

fn one(&self) -> Self::Elem

The multiplicative identity element of the ring.

fn is_one(&self, elem: &Self::Elem) -> bool

Checks if the given element is the multiplicative identity.

fn try_inv(&self, elem: &Self::Elem) -> Option<Self::Elem>

Calculates the multiplicative inverse of the given element if it exists.

fn invertible(&self, elem: &Self::Elem) -> bool

Returns true if the given element has a multiplicative inverse.

impl<A> Semigroup for QuotientRing<A> where
    A: EuclideanDomain, 

fn mul(&self, elem1: &Self::Elem, elem2: &Self::Elem) -> Self::Elem

The multiplicative product of the given elements.

fn mul_assign(&self, elem1: &mut Self::Elem, elem2: &Self::Elem)

The first element is multiplied with the second one in place.

fn square(&self, elem: &mut Self::Elem)

Squares the given element in place.

impl<A> UnitaryRing for QuotientRing<A> where
    A: EuclideanDomain, 

fn int(&self, elem: isize) -> Self::Elem

Returns the integer multiple of the one element in the ring.