Struct abstalg::Polynomials

pub struct Polynomials<R> where
    R: UnitaryRing,  { /* fields omitted */ }

The ring of polynomials over a base ring or field where each element is represented as a vector whose last element, the leading coefficient (if any) must be non-zero. This means that the empty vector is the zero element, and every polynomial has a unique representation.

Implementations

impl<R: UnitaryRing> Polynomials<R>

pub fn new(base: R) -> Self

Creates a new ring of polynomials over the given ring. The ring cannot be trivial, that is one must be different from zero.

pub fn base(&self) -> &R

Returns the base ring from which this ring was created.

pub fn degree(&self, elem: &Vec<R::Elem>) -> Option<usize>

Returns the degree of the given polynomial. The zero polynomial has no degree.

pub fn leading_coef(&self, elem: &Vec<R::Elem>) -> Option<R::Elem>

Returns the leading coefficient of the given polynomial. The zero polynomial has no leading coefficient.

Trait Implementations

impl<R> Domain for Polynomials<R> where
    R: UnitaryRing, 

type Elem = Vec<R::Elem>

The type of the elements of this domain.

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

Checks if the given element is a member of the domain. Not all possible objects need to be elements of the set.

impl<F> EuclideanDomain for Polynomials<F> where
    F: Field, 

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

Performs the euclidean division algorithm dividing the first elem with the second one and returning the quotient and the remainder. The remainder should be the one with the least norm among all possible ones so that the Euclidean algorithm runs fast. The second element may be zero, in which case the quotient shall be zero and the remainder be the first element.

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

We assume, that among all the associates of the given elem there must be a well defined unique one (non-negative for integers, zero or monoic for polynomials). This method returns that representative and the unit element whose product with the given element is the representative.

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

Performs the division just like the quo_rem method would do and returns the quotient.

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

Performs the division just like the quo_rem method would do and returns the remainder

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

Returns true if the first element is a multiple of the second one, that is the remainder is zero.

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

Returns true if the quotient is zero, that is the first element equals is own remainder when divided by the second one.

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

Returns true if the two elements are associated (divide each other)

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

Returns true if the given element has a multiplicative inverse, that is, it is a divisor of the identity element.

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

Calculates the greatest common divisor of two elements using the Euclidean algorithm.

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

Calculates the lest common divisor of the two elements.

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

Performs the extended Euclidean algorithm which returns the greatest common divisor, and two elements that multiplied with the inputs gives the greatest common divisor.

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

Checks if the given two elements are relative prime.

impl<R> IntegralDomain for Polynomials<R> where
    R: IntegralDomain, 

impl<R> UnitaryRing for Polynomials<R> where
    R: UnitaryRing, 

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

The additive identity element of the ring.

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

Checks if the given element is the additive identity 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 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 of the ring.

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

The multiplicative product of the given elements.

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

The difference of the given elements.