Struct feanor_math::rings::rust_bigint::RustBigintRingBase

pub struct RustBigintRingBase;

Arbitrary-precision integer implementation.

This is a not-too-well optimized implementation, written in pure Rust. If you need very high performance, consider using [crate::rings::mpir::MPZ] (requires an installation of mpir and activating the feature “mpir”).

For the difference to RustBigintRing, see the documentation of crate::ring::RingStore.

Implementations

impl RustBigintRingBase

pub fn map_i128(&self, val: &RustBigint) -> Option<i128>

pub fn parse(&self, string: &str, base: u32) -> Result<RustBigint, ()>

pub fn abs_base_u64_repr<'a>( &self, el: &'a RustBigint, ) -> impl 'a + Iterator<Item = u64>

pub fn from_base_u64_repr<I>(&self, data: I) -> RustBigint

where I: Iterator<Item = u64>,

Trait Implementations

impl Clone for RustBigintRingBase

fn clone(&self) -> RustBigintRingBase

Returns a copy of the value.

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

Performs copy-assignment from source.

impl DivisibilityRing for RustBigintRingBase

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. Note that this does not have to be unique, if rhs is a left zero-divisor. In particular, this function will return any element in the ring if lhs = rhs = 0.

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

impl EuclideanRing for RustBigintRingBase

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

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

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

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

impl HashableElRing for RustBigintRingBase

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

impl IntCast<RustBigintRingBase> for RustBigintRingBase

fn cast(&self, _: &RustBigintRingBase, value: Self::Element) -> Self::Element

impl IntCast<RustBigintRingBase> for StaticRingBase<i128>

fn cast(&self, from: &RustBigintRingBase, value: RustBigint) -> i128

impl IntCast<RustBigintRingBase> for StaticRingBase<i16>

fn cast(&self, from: &RustBigintRingBase, value: RustBigint) -> i16

impl IntCast<RustBigintRingBase> for StaticRingBase<i32>

fn cast(&self, from: &RustBigintRingBase, value: RustBigint) -> i32

impl IntCast<RustBigintRingBase> for StaticRingBase<i64>

fn cast(&self, from: &RustBigintRingBase, value: RustBigint) -> i64

impl IntCast<RustBigintRingBase> for StaticRingBase<i8>

fn cast(&self, from: &RustBigintRingBase, value: RustBigint) -> i8

impl IntCast<StaticRingBase<i128>> for RustBigintRingBase

fn cast(&self, _: &StaticRingBase<i128>, value: i128) -> RustBigint

impl IntCast<StaticRingBase<i16>> for RustBigintRingBase

fn cast(&self, _: &StaticRingBase<i16>, value: i16) -> RustBigint

impl IntCast<StaticRingBase<i32>> for RustBigintRingBase

fn cast(&self, _: &StaticRingBase<i32>, value: i32) -> RustBigint

impl IntCast<StaticRingBase<i64>> for RustBigintRingBase

fn cast(&self, _: &StaticRingBase<i64>, value: i64) -> RustBigint

impl IntCast<StaticRingBase<i8>> for RustBigintRingBase

fn cast(&self, _: &StaticRingBase<i8>, value: i8) -> RustBigint

impl IntegerRing for RustBigintRingBase

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

Computes a float value that is supposed to be close to value. However, no guarantees are made on how close it must be, in particular, this function may also always return 0. (this is just an example - it’s not a good idea).

fn from_float_approx(&self, value: f64) -> Option<Self::Element>

Computes a value that is “close” to the given float. However, no guarantees are made on the definition of close, in particular, this does not have to be the closest integer to the given float, and cannot be used to compute rounding. It is also implementation-defined when to return None, although this is usually the case on infinity and NaN.

fn abs_lowest_set_bit(&self, value: &Self::Element) -> Option<usize>

Returns the index of the lowest set bit in the two-complements representation of abs(value), or None if the value is zero.

fn abs_is_bit_set(&self, value: &Self::Element, i: usize) -> bool

Return whether the i-th bit in the two-complements representation of abs(value) is 1.

fn abs_highest_set_bit(&self, value: &Self::Element) -> Option<usize>

Returns the index of the highest set bit in the two-complements representation of abs(value), or None if the value is zero.

fn euclidean_div_pow_2(&self, value: &mut Self::Element, power: usize)

Computes the euclidean division by a power of two, always rounding to zero (note that euclidean division requires that |remainder| < |divisor|, and thus would otherwise leave multiple possible results).

fn mul_pow_2(&self, value: &mut Self::Element, power: usize)

Multiplies the element by a power of two.

fn get_uniformly_random_bits<G: FnMut() -> u64>( &self, log2_bound_exclusive: usize, rng: G, ) -> Self::Element

Computes a uniformly random integer in [0, 2^log_bound_exclusive - 1], assuming that rng provides uniformly random values in the whole range of u64.

fn representable_bits(&self) -> Option<usize>

Returns n such that this ring can represent at least [-2^n, ..., 2^n - 1]. Returning None means that the size of representable integers is unbounded.

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

Computes the rounded division, i.e. rounding to the closest integer. In the case of a tie (i.e. round(0.5)), we round towards +/- infinity.

fn power_of_two(&self, power: usize) -> Self::Element

Returns the value 2^power in this integer ring.

impl OrderedRing for RustBigintRingBase

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

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

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

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

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

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

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

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

impl PartialEq for RustBigintRingBase

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PrincipalIdealRing for RustBigintRingBase

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 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 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 RingBase for RustBigintRingBase

type Element = RustBigint

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

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

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

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

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

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

fn mul_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 from_int(&self, value: i32) -> 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_commutative(&self) -> bool

fn is_noetherian(&self) -> bool

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

fn characteristic<I: IntegerRingStore>(&self, other_ZZ: &I) -> Option<El<I>>

where I::Type: IntegerRing,

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

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 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 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: IntegerRingStore>( &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: Iterator<Item = Self::Element>,

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

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

impl Copy for RustBigintRingBase

impl Domain for RustBigintRingBase

impl StructuralPartialEq for RustBigintRingBase