Struct RationalFieldBase 

pub struct RationalFieldBase<I: RingStore>
where
    I::Type: IntegerRing,
{ /* private fields */ }

An implementation of the rational number Q, based on representing them as a tuple (numerator, denominator).

Be careful when instantiating it with finite-precision integers, like StaticRing<i64>, since by nature of the rational numbers, both numerator and denominator can increase dramatically, even when the numbers itself are of moderate size.

Example

let ZZ = StaticRing::<i64>::RING;
let QQ = RationalField::new(ZZ);
let hom = QQ.can_hom(&ZZ).unwrap();
let one_half = QQ.div(&QQ.one(), &hom.map(2));
assert_el_eq!(QQ, QQ.div(&QQ.one(), &hom.map(4)), QQ.pow(one_half, 2));

You can also retrieve numerator and denominator.

assert_el_eq!(ZZ, ZZ.int_hom().map(1), QQ.num(&one_half));
assert_el_eq!(ZZ, ZZ.int_hom().map(2), QQ.den(&one_half));

Implementations

impl<I> RationalFieldBase<I>

where I: RingStore, I::Type: IntegerRing,

pub fn num<'a>(&'a self, el: &'a <Self as RingBase>::Element) -> &'a El<I>

The numerator of the fully reduced fraction.

Example

assert_el_eq!(ZZ, 2, QQ.num(&QQ.div(&QQ.inclusion().map(6), &QQ.inclusion().map(3))));

pub fn den<'a>(&'a self, el: &'a <Self as RingBase>::Element) -> &'a El<I>

The denominator of the fully reduced fraction.

Example

assert_el_eq!(ZZ, 3, QQ.den(&QQ.div(&QQ.inclusion().map(3), &QQ.inclusion().map(9))));

Trait Implementations

impl<I, J> CanHomFrom<J> for RationalFieldBase<I>

where I: RingStore, I::Type: IntegerRing, J: IntegerRing,

type Homomorphism = ()

Data required to compute the action of the canonical homomorphism on ring elements.

fn has_canonical_hom(&self, _from: &J) -> Option<Self::Homomorphism>

If there is a canonical homomorphism from -> self, returns Some(data), where data is additional data that can be used to compute the action of the homomorphism on ring elements. Otherwise, None is returned.

fn map_in( &self, from: &J, el: <J as RingBase>::Element, (): &Self::Homomorphism, ) -> Self::Element

Evaluates the homomorphism.

fn map_in_ref( &self, from: &S, el: &S::Element, hom: &Self::Homomorphism, ) -> Self::Element

Evaluates the homomorphism, taking the element by reference.

fn mul_assign_map_in( &self, from: &S, lhs: &mut Self::Element, rhs: S::Element, hom: &Self::Homomorphism, )

Evaluates the homomorphism on rhs, and multiplies the result to lhs.

fn mul_assign_map_in_ref( &self, from: &S, lhs: &mut Self::Element, rhs: &S::Element, hom: &Self::Homomorphism, )

Evaluates the homomorphism on rhs, taking it by reference, and multiplies the result to lhs.

fn fma_map_in( &self, from: &S, lhs: &Self::Element, rhs: &S::Element, summand: Self::Element, hom: &Self::Homomorphism, ) -> Self::Element

Fused-multiply-add. Computes summand + lhs * rhs, where rhs is mapped into the ring via the homomorphism.

impl<I> CanHomFrom<RationalFieldBase<I>> for Complex64Base

where I: IntegerRingStore, I::Type: IntegerRing,

type Homomorphism = <Complex64Base as CanHomFrom<<I as RingStore>::Type>>::Homomorphism

Data required to compute the action of the canonical homomorphism on ring elements.

fn has_canonical_hom( &self, from: &RationalFieldBase<I>, ) -> Option<Self::Homomorphism>

If there is a canonical homomorphism from -> self, returns Some(data), where data is additional data that can be used to compute the action of the homomorphism on ring elements. Otherwise, None is returned.

fn map_in( &self, from: &RationalFieldBase<I>, el: <RationalFieldBase<I> as RingBase>::Element, hom: &Self::Homomorphism, ) -> Self::Element

Evaluates the homomorphism.

fn map_in_ref( &self, from: &RationalFieldBase<I>, el: &<RationalFieldBase<I> as RingBase>::Element, hom: &Self::Homomorphism, ) -> Self::Element

Evaluates the homomorphism, taking the element by reference.

fn mul_assign_map_in( &self, from: &S, lhs: &mut Self::Element, rhs: S::Element, hom: &Self::Homomorphism, )

Evaluates the homomorphism on rhs, and multiplies the result to lhs.

fn mul_assign_map_in_ref( &self, from: &S, lhs: &mut Self::Element, rhs: &S::Element, hom: &Self::Homomorphism, )

Evaluates the homomorphism on rhs, taking it by reference, and multiplies the result to lhs.

fn fma_map_in( &self, from: &S, lhs: &Self::Element, rhs: &S::Element, summand: Self::Element, hom: &Self::Homomorphism, ) -> Self::Element

Fused-multiply-add. Computes summand + lhs * rhs, where rhs is mapped into the ring via the homomorphism.

impl<R, I> CanHomFrom<RationalFieldBase<I>> for FractionFieldImplBase<R>

where R: RingStore, I: RingStore, R::Type: Domain + CanHomFrom<I::Type>, I::Type: IntegerRing,

type Homomorphism = <<R as RingStore>::Type as CanHomFrom<<I as RingStore>::Type>>::Homomorphism

Data required to compute the action of the canonical homomorphism on ring elements.

fn has_canonical_hom( &self, from: &RationalFieldBase<I>, ) -> Option<Self::Homomorphism>

If there is a canonical homomorphism from -> self, returns Some(data), where data is additional data that can be used to compute the action of the homomorphism on ring elements. Otherwise, None is returned.

fn map_in( &self, from: &RationalFieldBase<I>, el: <RationalFieldBase<I> as RingBase>::Element, hom: &Self::Homomorphism, ) -> Self::Element

Evaluates the homomorphism.

fn map_in_ref( &self, from: &S, el: &S::Element, hom: &Self::Homomorphism, ) -> Self::Element

Evaluates the homomorphism, taking the element by reference.

fn mul_assign_map_in( &self, from: &S, lhs: &mut Self::Element, rhs: S::Element, hom: &Self::Homomorphism, )

Evaluates the homomorphism on rhs, and multiplies the result to lhs.

fn mul_assign_map_in_ref( &self, from: &S, lhs: &mut Self::Element, rhs: &S::Element, hom: &Self::Homomorphism, )

Evaluates the homomorphism on rhs, taking it by reference, and multiplies the result to lhs.

fn fma_map_in( &self, from: &S, lhs: &Self::Element, rhs: &S::Element, summand: Self::Element, hom: &Self::Homomorphism, ) -> Self::Element

Fused-multiply-add. Computes summand + lhs * rhs, where rhs is mapped into the ring via the homomorphism.

impl<I> CanHomFrom<RationalFieldBase<I>> for Real64Base

where I: IntegerRingStore, I::Type: IntegerRing,

type Homomorphism = ()

Data required to compute the action of the canonical homomorphism on ring elements.

fn has_canonical_hom( &self, _from: &RationalFieldBase<I>, ) -> Option<Self::Homomorphism>

If there is a canonical homomorphism from -> self, returns Some(data), where data is additional data that can be used to compute the action of the homomorphism on ring elements. Otherwise, None is returned.

fn map_in( &self, from: &RationalFieldBase<I>, el: El<RationalField<I>>, hom: &Self::Homomorphism, ) -> Self::Element

Evaluates the homomorphism.

fn map_in_ref( &self, from: &RationalFieldBase<I>, el: &El<RationalField<I>>, _hom: &Self::Homomorphism, ) -> Self::Element

Evaluates the homomorphism, taking the element by reference.

fn mul_assign_map_in( &self, from: &S, lhs: &mut Self::Element, rhs: S::Element, hom: &Self::Homomorphism, )

Evaluates the homomorphism on rhs, and multiplies the result to lhs.

fn mul_assign_map_in_ref( &self, from: &S, lhs: &mut Self::Element, rhs: &S::Element, hom: &Self::Homomorphism, )

Evaluates the homomorphism on rhs, taking it by reference, and multiplies the result to lhs.

fn fma_map_in( &self, from: &S, lhs: &Self::Element, rhs: &S::Element, summand: Self::Element, hom: &Self::Homomorphism, ) -> Self::Element

Fused-multiply-add. Computes summand + lhs * rhs, where rhs is mapped into the ring via the homomorphism.

impl<I, J> CanHomFrom<RationalFieldBase<J>> for RationalFieldBase<I>

where I: RingStore, I::Type: IntegerRing, J: RingStore, J::Type: IntegerRing,

type Homomorphism = ()

Data required to compute the action of the canonical homomorphism on ring elements.

fn has_canonical_hom( &self, _from: &RationalFieldBase<J>, ) -> Option<Self::Homomorphism>

If there is a canonical homomorphism from -> self, returns Some(data), where data is additional data that can be used to compute the action of the homomorphism on ring elements. Otherwise, None is returned.

fn map_in( &self, from: &RationalFieldBase<J>, el: <RationalFieldBase<J> as RingBase>::Element, (): &Self::Homomorphism, ) -> Self::Element

Evaluates the homomorphism.

fn map_in_ref( &self, from: &S, el: &S::Element, hom: &Self::Homomorphism, ) -> Self::Element

Evaluates the homomorphism, taking the element by reference.

fn mul_assign_map_in( &self, from: &S, lhs: &mut Self::Element, rhs: S::Element, hom: &Self::Homomorphism, )

Evaluates the homomorphism on rhs, and multiplies the result to lhs.

fn mul_assign_map_in_ref( &self, from: &S, lhs: &mut Self::Element, rhs: &S::Element, hom: &Self::Homomorphism, )

Evaluates the homomorphism on rhs, taking it by reference, and multiplies the result to lhs.

fn fma_map_in( &self, from: &S, lhs: &Self::Element, rhs: &S::Element, summand: Self::Element, hom: &Self::Homomorphism, ) -> Self::Element

Fused-multiply-add. Computes summand + lhs * rhs, where rhs is mapped into the ring via the homomorphism.

impl<R, I> CanIsoFromTo<RationalFieldBase<I>> for FractionFieldImplBase<R>

where R: RingStore, I: RingStore, R::Type: Domain + CanIsoFromTo<I::Type>, I::Type: IntegerRing,

type Isomorphism = <<R as RingStore>::Type as CanIsoFromTo<<I as RingStore>::Type>>::Isomorphism

Data required to compute a preimage under the canonical homomorphism.

fn has_canonical_iso( &self, from: &RationalFieldBase<I>, ) -> Option<Self::Isomorphism>

If there is a canonical homomorphism from -> self, and this homomorphism is an isomorphism, returns Some(data), where data is additional data that can be used to compute preimages under the homomorphism. Otherwise, None is returned.

fn map_out( &self, from: &RationalFieldBase<I>, el: Self::Element, iso: &Self::Isomorphism, ) -> <RationalFieldBase<I> as RingBase>::Element

Computes the preimage of el under the canonical homomorphism from -> self.

impl<I, J> CanIsoFromTo<RationalFieldBase<J>> for RationalFieldBase<I>

where I: RingStore, I::Type: IntegerRing, J: RingStore, J::Type: IntegerRing,

type Isomorphism = ()

Data required to compute a preimage under the canonical homomorphism.

fn has_canonical_iso( &self, _from: &RationalFieldBase<J>, ) -> Option<Self::Isomorphism>

If there is a canonical homomorphism from -> self, and this homomorphism is an isomorphism, returns Some(data), where data is additional data that can be used to compute preimages under the homomorphism. Otherwise, None is returned.

fn map_out( &self, from: &RationalFieldBase<J>, el: Self::Element, (): &Self::Homomorphism, ) -> <RationalFieldBase<J> as RingBase>::Element

Computes the preimage of el under the canonical homomorphism from -> self.

impl<I> Clone for RationalFieldBase<I>

where I: RingStore + Clone, I::Type: IntegerRing,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I> ComputeResultantRing for RationalFieldBase<I>

where I: RingStore, I::Type: IntegerRing,

fn resultant<P>( ring: P, f: El<P>, g: El<P>, ) -> El<<P::Type as RingExtension>::BaseRing>

where P: RingStore + Copy, P::Type: PolyRing, <P::Type as RingExtension>::BaseRing: RingStore<Type = Self>,

Available on crate feature unstable-enable only.

Computes the resultant of f and g over the base ring.

impl<I> Debug for RationalFieldBase<I>

where I: RingStore, I::Type: IntegerRing,

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

Formats the value using the given formatter.

impl<'de, I> Deserialize<'de> for RationalFieldBase<I>

where I: RingStore + Deserialize<'de>, I::Type: IntegerRing,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<I> DivisibilityRing for RationalFieldBase<I>

where I: RingStore, I::Type: IntegerRing,

fn checked_left_div( &self, lhs: &Self::Element, rhs: &Self::Element, ) -> Option<Self::Element>

Checks whether there is an element x such that rhs * x = lhs, and returns it if it exists.

fn is_unit(&self, x: &Self::Element) -> bool

Returns whether the given element is a unit, i.e. has an inverse.

fn balance_factor<'a, J>(&self, elements: J) -> Option<Self::Element>

where J: Iterator<Item = &'a Self::Element>, Self: 'a,

Function that computes a “balancing” factor of a sequence of ring elements. The only use of the balancing factor is to increase performance, in particular, dividing all elements in the sequence by this factor should make them “smaller” resp. cheaper to process.

type PreparedDivisorData = ()

Additional data associated to a fixed ring element that can be used to speed up division by this ring element.

fn divides_left(&self, lhs: &Self::Element, rhs: &Self::Element) -> bool

Returns whether there is an element x such that rhs * x = lhs. If you need such an element, consider using DivisibilityRing::checked_left_div().

fn divides(&self, lhs: &Self::Element, rhs: &Self::Element) -> bool

Same as DivisibilityRing::divides_left(), but requires a commutative ring.

fn checked_div( &self, lhs: &Self::Element, rhs: &Self::Element, ) -> Option<Self::Element>

Same as DivisibilityRing::checked_left_div(), but requires a commutative ring.

fn prepare_divisor(&self, _: &Self::Element) -> Self::PreparedDivisorData

“Prepares” an element of this ring for division.

fn checked_left_div_prepared( &self, lhs: &Self::Element, rhs: &Self::Element, _rhs_prep: &Self::PreparedDivisorData, ) -> Option<Self::Element>

Same as DivisibilityRing::checked_left_div() but for a prepared divisor.

fn divides_left_prepared( &self, lhs: &Self::Element, rhs: &Self::Element, _rhs_prep: &Self::PreparedDivisorData, ) -> bool

Same as DivisibilityRing::divides_left() but for a prepared divisor.

fn is_unit_prepared(&self, x: &PreparedDivisor<Self>) -> bool

Same as DivisibilityRing::is_unit() but for a prepared divisor.

fn invert(&self, el: &Self::Element) -> Option<Self::Element>

If the given element is a unit, returns its inverse, otherwise None.

impl<I> EuclideanRing for RationalFieldBase<I>

where I: RingStore, I::Type: IntegerRing,

fn euclidean_deg(&self, val: &Self::Element) -> Option<usize>

Defines how “small” an element is. For details, see EuclideanRing.

fn euclidean_div_rem( &self, lhs: Self::Element, rhs: &Self::Element, ) -> (Self::Element, Self::Element)

Computes euclidean division with remainder.

fn euclidean_div( &self, lhs: Self::Element, rhs: &Self::Element, ) -> Self::Element

Computes euclidean division without remainder.

fn euclidean_rem( &self, lhs: Self::Element, rhs: &Self::Element, ) -> Self::Element

Computes only the remainder of euclidean division.

impl<I> FactorPolyField for RationalFieldBase<I>

where I: RingStore, I::Type: IntegerRing, ZnBase: CanHomFrom<I::Type>,

fn factor_poly<P>( poly_ring: P, poly: &El<P>, ) -> (Vec<(El<P>, usize)>, Self::Element)

where P: RingStore + Copy, P::Type: PolyRing + EuclideanRing, <P::Type as RingExtension>::BaseRing: RingStore<Type = Self>,

Factors a univariate polynomial with coefficients in this field into its irreducible factors.

fn factor_poly_with_controller<P, Controller>( poly_ring: P, poly: &El<P>, controller: Controller, ) -> (Vec<(El<P>, usize)>, Self::Element)

where P: RingStore + Copy, P::Type: PolyRing + EuclideanRing, <P::Type as RingExtension>::BaseRing: RingStore<Type = Self>, Controller: ComputationController,

As FactorPolyField::factor_poly(), this computes the factorization of a polynomial. However, it additionally accepts a ComputationController to customize the performed computation.

fn is_irred<P>(poly_ring: P, poly: &El<P>) -> bool

where P: RingStore + Copy, P::Type: PolyRing + EuclideanRing, <P::Type as RingExtension>::BaseRing: RingStore<Type = Self>,

Returns whether the given polynomial is irreducible over the base field.

impl<I> Field for RationalFieldBase<I>

where I: RingStore, I::Type: IntegerRing,

fn div(&self, lhs: &Self::Element, rhs: &Self::Element) -> Self::Element

Computes the division lhs / rhs, where rhs != 0.

impl<I> FiniteRingSpecializable for RationalFieldBase<I>

where I: RingStore, I::Type: IntegerRing,

fn specialize<O: FiniteRingOperation<Self>>(op: O) -> O::Output

Available on crate feature unstable-enable only.

fn is_finite_ring() -> bool

Available on crate feature unstable-enable only.

impl<I> FractionField for RationalFieldBase<I>

where I: RingStore, I::Type: IntegerRing,

fn as_fraction( &self, el: Self::Element, ) -> (El<Self::BaseRing>, El<Self::BaseRing>)

Available on crate feature unstable-enable only.

Returns a, b such that the given element is a/b.

fn from_fraction( &self, num: El<Self::BaseRing>, den: El<Self::BaseRing>, ) -> Self::Element

Available on crate feature unstable-enable only.

Computes num / den.

impl<I: RingStore> HashableElRing for RationalFieldBase<I>

where I::Type: IntegerRing + HashableElRing,

fn hash<H: Hasher>(&self, el: &Self::Element, h: &mut H)

Hashes the given ring element.

impl<I> InterpolationBaseRing for RationalFieldBase<I>

where I: RingStore, I::Type: IntegerRing + ComputeResultantRing,

type ExtendedRing<'a> = RingRef<'a, RationalFieldBase<I>> where Self: 'a

Available on crate feature unstable-enable only.

type ExtendedRingBase<'a> = RationalFieldBase<I> where Self: 'a

Available on crate feature unstable-enable only.

The type of the extension ring we can switch to to get more points.

fn in_base<'a, S>(&self, _ext_ring: S, el: El<S>) -> Option<Self::Element>

where Self: 'a, S: RingStore<Type = Self::ExtendedRingBase<'a>>,

Available on crate feature unstable-enable only.

fn in_extension<'a, S>(&self, _ext_ring: S, el: Self::Element) -> El<S>

where Self: 'a, S: RingStore<Type = Self::ExtendedRingBase<'a>>,

Available on crate feature unstable-enable only.

fn interpolation_points<'a>( &'a self, count: usize, ) -> (Self::ExtendedRing<'a>, Vec<El<Self::ExtendedRing<'a>>>)

Available on crate feature unstable-enable only.

Returns count points such that the difference between any two of them is a non-zero-divisor.

impl<I: RingStore> KaratsubaHint for RationalFieldBase<I>

where I::Type: IntegerRing,

default fn karatsuba_threshold(&self) -> usize

Available on crate feature unstable-enable only.

Define a threshold from which on KaratsubaAlgorithm will use the Karatsuba algorithm.

impl<I> OrderedRing for RationalFieldBase<I>

where I: RingStore, I::Type: IntegerRing,

fn cmp(&self, lhs: &Self::Element, rhs: &Self::Element) -> Ordering

Returns whether lhs is Ordering::Less, Ordering::Equal or Ordering::Greater than rhs.

fn abs_cmp(&self, lhs: &Self::Element, rhs: &Self::Element) -> Ordering

Returns whether abs(lhs) is Ordering::Less, Ordering::Equal or Ordering::Greater than abs(rhs).

fn is_leq(&self, lhs: &Self::Element, rhs: &Self::Element) -> bool

Returns whether lhs <= rhs.

fn is_geq(&self, lhs: &Self::Element, rhs: &Self::Element) -> bool

Returns whether lhs >= rhs.

fn is_lt(&self, lhs: &Self::Element, rhs: &Self::Element) -> bool

Returns whether lhs < rhs.

fn is_gt(&self, lhs: &Self::Element, rhs: &Self::Element) -> bool

Returns whether lhs > rhs.

fn is_neg(&self, value: &Self::Element) -> bool

Returns whether value < 0.

fn is_pos(&self, value: &Self::Element) -> bool

Returns whether value > 0.

fn abs(&self, value: Self::Element) -> Self::Element

Returns the absolute value of value, i.e. value if value >= 0 and -value otherwise.

fn max<'a>( &self, fst: &'a Self::Element, snd: &'a Self::Element, ) -> &'a Self::Element

Returns the larger one of fst and snd.

impl<I> PartialEq for RationalFieldBase<I>

where I: RingStore, I::Type: IntegerRing,

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<I> PolyTFracGCDRing for RationalFieldBase<I>

where I: RingStore, I::Type: IntegerRing,

fn power_decomposition<P>(poly_ring: P, poly: &El<P>) -> Vec<(El<P>, usize)>

where P: RingStore + Copy, P::Type: PolyRing, <P::Type as RingExtension>::BaseRing: RingStore<Type = Self>,

Compute square-free polynomials f1, f2, ... such that a f = f1 f2^2 f3^3 ... for some non-zero-divisor a of this ring. They are returned as tuples (fi, i) where deg(fi) > 0.

fn gcd<P>(poly_ring: P, lhs: &El<P>, rhs: &El<P>) -> El<P>

where P: RingStore + Copy, P::Type: PolyRing, <P::Type as RingExtension>::BaseRing: RingStore<Type = Self>,

Computes the greatest common divisor of two polynomials f, g over the fraction field, which is the largest-degree polynomial d such that d | a f, a g for some non-zero-divisor a of this ring.

fn squarefree_part<P>(poly_ring: P, poly: &El<P>) -> El<P>

where P: RingStore + Copy, P::Type: PolyRing + DivisibilityRing, <P::Type as RingExtension>::BaseRing: RingStore<Type = Self>,

Computes the square-free part of a polynomial f, which is the largest-degree squarefree polynomial d such that d | a f for some non-zero-divisor a of this ring.

fn power_decomposition_with_controller<P, Controller>( poly_ring: P, poly: &El<P>, _: Controller, ) -> Vec<(El<P>, usize)>

where P: RingStore + Copy, P::Type: PolyRing + DivisibilityRing, <P::Type as RingExtension>::BaseRing: RingStore<Type = Self>, Controller: ComputationController,

As PolyTFracGCDRing::power_decomposition(), this writes a polynomial as a product of powers of square-free polynomials. However, it additionally accepts a ComputationController to customize the performed computation.

fn gcd_with_controller<P, Controller>( poly_ring: P, lhs: &El<P>, rhs: &El<P>, _: Controller, ) -> El<P>

where P: RingStore + Copy, P::Type: PolyRing + DivisibilityRing, <P::Type as RingExtension>::BaseRing: RingStore<Type = Self>, Controller: ComputationController,

As PolyTFracGCDRing::gcd(), this computes the gcd of two polynomials. However, it additionally accepts a ComputationController to customize the performed computation.

impl<I> PrincipalIdealRing for RationalFieldBase<I>

where I: RingStore, I::Type: IntegerRing,

fn checked_div_min( &self, lhs: &Self::Element, rhs: &Self::Element, ) -> Option<Self::Element>

Similar to DivisibilityRing::checked_left_div() this computes a “quotient” q of lhs and rhs, if it exists. However, we impose the additional constraint that this quotient be minimal, i.e. there is no q' with q' | q properly and q' * rhs = lhs.

fn extended_ideal_gen( &self, lhs: &Self::Element, rhs: &Self::Element, ) -> (Self::Element, Self::Element, Self::Element)

Computes a Bezout identity for the generator g of the ideal (lhs, rhs) as g = s * lhs + t * rhs.

fn annihilator(&self, val: &Self::Element) -> Self::Element

Returns the (w.r.t. divisibility) smallest element x such that x * val = 0.

fn create_elimination_matrix( &self, a: &Self::Element, b: &Self::Element, ) -> ([Self::Element; 4], Self::Element)

Creates a matrix A of unit determinant such that A * (a, b)^T = (d, 0). Returns (A, d).

fn ideal_gen(&self, lhs: &Self::Element, rhs: &Self::Element) -> Self::Element

Computes a generator g of the ideal (lhs, rhs) = (g), also known as greatest common divisor.

fn ideal_gen_with_controller<Controller>( &self, lhs: &Self::Element, rhs: &Self::Element, _: Controller, ) -> Self::Element

where Controller: ComputationController,

As PrincipalIdealRing::ideal_gen(), this computes a generator of the ideal (lhs, rhs). However, it additionally accepts a ComputationController to customize the performed computation.

fn lcm(&self, lhs: &Self::Element, rhs: &Self::Element) -> Self::Element

Computes a generator of the ideal (lhs) ∩ (rhs), also known as least common multiple.

impl<I> QRDecompositionField for RationalFieldBase<I>

where I: RingStore, I::Type: IntegerRing,

fn scaled_qr_decomposition<V1, V2>( &self, matrix: SubmatrixMut<'_, V1, Self::Element>, q: SubmatrixMut<'_, V2, Self::Element>, ) -> Vec<Self::Element>

where V1: AsPointerToSlice<Self::Element>, V2: AsPointerToSlice<Self::Element>,

Available on crate feature unstable-enable only.

Given a matrix A, computes an orthogonal matrix Q and an upper triangular matrix R with A = Q R. The function writes Q diag(x_1, ..., x_n) to q and diag(1/x_1, ..., 1/x_n) R to matrix, and returns x_1^2, ..., x_n^2, where x_1, ..., x_n are the elements on the diagonal of R.

fn ldl_decomposition<V>( &self, matrix: SubmatrixMut<'_, V, Self::Element>, ) -> Vec<Self::Element>

where V: AsPointerToSlice<Self::Element>,

Available on crate feature unstable-enable only.

Given a square symmetric matrix A, computes a strict lower triangular matrix L and a diagonal matrix D such that A = L D L^T. The function writes L to matrix and returns the diagonal elements of D.

impl<I> RingBase for RationalFieldBase<I>

where I: RingStore, I::Type: IntegerRing,

type Element = RationalFieldEl<I>

Type of elements of the ring

fn add_assign(&self, lhs: &mut Self::Element, rhs: Self::Element)

fn clone_el(&self, val: &Self::Element) -> Self::Element

fn add_assign_ref(&self, lhs: &mut Self::Element, rhs: &Self::Element)

fn mul_assign_ref(&self, lhs: &mut Self::Element, rhs: &Self::Element)

fn mul_assign(&self, lhs: &mut Self::Element, rhs: Self::Element)

fn negate_inplace(&self, lhs: &mut Self::Element)

fn eq_el(&self, lhs: &Self::Element, rhs: &Self::Element) -> bool

fn is_zero(&self, value: &Self::Element) -> bool

fn is_one(&self, value: &Self::Element) -> bool

fn is_neg_one(&self, value: &Self::Element) -> bool

fn is_approximate(&self) -> bool

Returns whether this ring computes with approximations to elements. This would usually be the case for rings that are based on f32 or f64, to represent real or complex numbers.

fn is_commutative(&self) -> bool

Returns whether the ring is commutative, i.e. a * b = b * a for all elements a, b. Note that addition is assumed to be always commutative.

fn is_noetherian(&self) -> bool

Returns whether the ring is noetherian, i.e. every ideal is finitely generated.

fn characteristic<J: RingStore + Copy>(&self, ZZ: J) -> Option<El<J>>

where J::Type: IntegerRing,

Returns the characteristic of this ring as an element of the given implementation of ZZ.

fn dbg_within<'a>( &self, value: &Self::Element, out: &mut Formatter<'a>, env: EnvBindingStrength, ) -> Result

Writes a human-readable representation of value to out, taking into account the possible context to place parenthesis as needed.

fn from_int(&self, value: i32) -> Self::Element

fn sub_assign_ref(&self, lhs: &mut Self::Element, rhs: &Self::Element)

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

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

fn neg_one(&self) -> Self::Element

fn fma( &self, lhs: &Self::Element, rhs: &Self::Element, summand: Self::Element, ) -> Self::Element

Fused-multiply-add. This computes summand + lhs * rhs.

fn dbg<'a>(&self, value: &Self::Element, out: &mut Formatter<'a>) -> Result

Writes a human-readable representation of value to out.

fn square(&self, value: &mut Self::Element)

fn negate(&self, value: Self::Element) -> Self::Element

fn sub_assign(&self, lhs: &mut Self::Element, rhs: Self::Element)

fn mul_assign_int(&self, lhs: &mut Self::Element, rhs: i32)

fn mul_int(&self, lhs: Self::Element, rhs: i32) -> Self::Element

fn mul_int_ref(&self, lhs: &Self::Element, rhs: i32) -> Self::Element

fn fma_int( &self, lhs: &Self::Element, rhs: i32, summand: Self::Element, ) -> Self::Element

Fused-multiply-add with an integer. This computes summand + lhs * rhs.

fn sub_self_assign(&self, lhs: &mut Self::Element, rhs: Self::Element)

Computes lhs := rhs - lhs.

fn sub_self_assign_ref(&self, lhs: &mut Self::Element, rhs: &Self::Element)

Computes lhs := rhs - lhs.

fn add_ref(&self, lhs: &Self::Element, rhs: &Self::Element) -> Self::Element

fn add_ref_fst(&self, lhs: &Self::Element, rhs: Self::Element) -> Self::Element

fn add_ref_snd(&self, lhs: Self::Element, rhs: &Self::Element) -> Self::Element

fn add(&self, lhs: Self::Element, rhs: Self::Element) -> Self::Element

fn sub_ref(&self, lhs: &Self::Element, rhs: &Self::Element) -> Self::Element

fn sub_ref_fst(&self, lhs: &Self::Element, rhs: Self::Element) -> Self::Element

fn sub_ref_snd(&self, lhs: Self::Element, rhs: &Self::Element) -> Self::Element

fn sub(&self, lhs: Self::Element, rhs: Self::Element) -> Self::Element

fn mul_ref(&self, lhs: &Self::Element, rhs: &Self::Element) -> Self::Element

fn mul_ref_fst(&self, lhs: &Self::Element, rhs: Self::Element) -> Self::Element

fn mul_ref_snd(&self, lhs: Self::Element, rhs: &Self::Element) -> Self::Element

fn mul(&self, lhs: Self::Element, rhs: Self::Element) -> Self::Element

fn pow_gen<R: RingStore>( &self, x: Self::Element, power: &El<R>, integers: R, ) -> Self::Element

where R::Type: IntegerRing,

Raises x to the power of an arbitrary, nonnegative integer given by a custom integer ring implementation.

fn sum<I>(&self, els: I) -> Self::Element

where I: IntoIterator<Item = Self::Element>,

Sums the elements given by the iterator.

fn prod<I>(&self, els: I) -> Self::Element

where I: IntoIterator<Item = Self::Element>,

Computes the product of the elements given by the iterator.

impl<I> RingExtension for RationalFieldBase<I>

where I: RingStore, I::Type: IntegerRing,

type BaseRing = I

Type of the base ring;

fn base_ring<'a>(&'a self) -> &'a Self::BaseRing

Returns a reference to the base ring.

fn from(&self, x: El<Self::BaseRing>) -> Self::Element

Maps an element of the base ring into this ring.

fn mul_assign_base(&self, lhs: &mut Self::Element, rhs: &El<Self::BaseRing>)

Computes lhs := lhs * rhs, where rhs is mapped into this ring via RingExtension::from_ref(). Note that this may be faster than self.mul_assign(lhs, self.from_ref(rhs)).

fn from_ref(&self, x: &El<Self::BaseRing>) -> Self::Element

Maps an element of the base ring (given as reference) into this ring.

fn fma_base( &self, lhs: &Self::Element, rhs: &El<Self::BaseRing>, summand: Self::Element, ) -> Self::Element

fn mul_assign_base_through_hom<S: ?Sized + RingBase, H: Homomorphism<S, <Self::BaseRing as RingStore>::Type>>( &self, lhs: &mut Self::Element, rhs: &S::Element, hom: H, )

Computes lhs := lhs * rhs, where rhs is mapped into this ring via the given homomorphism, followed by the inclusion (as specified by RingExtension::from_ref()).

impl<I> SerializableElementRing for RationalFieldBase<I>

where I: RingStore, I::Type: IntegerRing + SerializableElementRing,

fn deserialize<'de, D>( &self, deserializer: D, ) -> Result<Self::Element, D::Error>

where D: Deserializer<'de>,

Available on crate feature unstable-enable only.

Deserializes an element of this ring from the given deserializer.

fn serialize<S>( &self, el: &Self::Element, serializer: S, ) -> Result<S::Ok, S::Error>

where S: Serializer,

Available on crate feature unstable-enable only.

Serializes an element of this ring to the given serializer.

impl<I> Serialize for RationalFieldBase<I>

where I: RingStore + Serialize, I::Type: IntegerRing,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<I: RingStore> StrassenHint for RationalFieldBase<I>

where I::Type: IntegerRing,

default fn strassen_threshold(&self) -> usize

Available on crate feature unstable-enable only.

Define a threshold from which on StrassenAlgorithm will use the Strassen algorithm.

impl<I> Copy for RationalFieldBase<I>

where I: RingStore + Copy, I::Type: IntegerRing, El<I>: Copy,

impl<I> Domain for RationalFieldBase<I>

where I: RingStore, I::Type: IntegerRing,

impl<I> PerfectField for RationalFieldBase<I>

where I: RingStore, I::Type: IntegerRing,