Struct abstalg::ApproxFloats

pub struct ApproxFloats<E> { /* fields omitted */ }

The field of real numbers approximated by a primitive floating point number. NaN and infinity values are not considered as members, so all operations resulting one of these will panic. The lattice order is the normal total order, which is not bounded.

Trait Implementations

impl<E: Default> Default for ApproxFloats<E>

fn default() -> ApproxFloats<E>

Returns the "default value" for a type.

impl<E> DistributiveLattice for ApproxFloats<E> where
    E: Float + Debug + Zero + One, 

impl<E> Domain for ApproxFloats<E> where
    E: Float + Debug + Zero + One, 

type Elem = E

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<E> EuclideanDomain for ApproxFloats<E> where
    E: Float + Debug + Zero + One, 

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<E> Field for ApproxFloats<E> where
    E: Float + Debug + Zero + One, 

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

Returns the multiplicative inverse of the given non-zero element. This method panics for the zero element.

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

Returns the quotient of the two elements in the field. This method panics if the second element is zero.

impl<E> IntegralDomain for ApproxFloats<E> where
    E: Float + Debug + Zero + One, 

impl<E> Lattice for ApproxFloats<E> where
    E: Float + Debug + Zero + One, 

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

Returns the largest element that is less than or equal to both given elements.

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

Returns the smallest element that is greater than or equal to both given elements.

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

Returns true if the first element is less than or equal to the second one in the lattice order.

impl<E> UnitaryRing for ApproxFloats<E> where
    E: Float + Debug + Zero + One, 

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 one(&self) -> Self::Elem

The multiplicative identity element of the ring.

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

The multiplicative product 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 sub(&self, elem1: &Self::Elem, elem2: &Self::Elem) -> Self::Elem

The difference of the given elements.

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

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