Struct QAdic 

pub struct QAdic<A>
where
    A: AdicInteger,
{ /* private fields */ }

Fractional adic number

The struct holds an adic integer and a valuation. Digitally, there are -valuation digits to the right of the decimal. With this, you can represent any adic number.

The adic integer is generic and so can be e.g.

• natural number UAdic
• exact number EAdic
• approximate number ZAdic

let twenty_three_and_11_25 = QAdic::new(UAdic::new(5, vec![1, 2, 3, 4]), Valuation::Finite(-2));
assert_eq!("43.21_5", twenty_three_and_11_25.to_string());
let fifty = QAdic::new(UAdic::new(5, vec![0, 2]), 1);
assert_eq!("200._5", fifty.to_string());
let neg_one_tenth = QAdic::new(EAdic::new_repeating(5, vec![], vec![2]), -1);
assert_eq!("(2).2_5", neg_one_tenth.to_string());

assert_eq!(
    QAdic::new(UAdic::new(5, vec![1, 2, 4, 1, 1]), -2),
    QAdic::new(UAdic::new(5, vec![1, 2, 3, 4]), -2) + QAdic::new(UAdic::new(5, vec![1, 2]), 0)
);
assert_eq!(
    QAdic::new(UAdic::new(5, vec![2, 2]), -3),
    QAdic::new(UAdic::new(5, vec![3]), -2) * QAdic::new(UAdic::new(5, vec![4]), -1)
);

assert_eq!(Ratio::new(1, 1), QAdic::new(UAdic::new(5, vec![4, 1, 3, 2]), 0).norm());
assert_eq!(Ratio::new(1, 25), QAdic::new(UAdic::new(5, vec![4, 1, 3, 2]), 2).norm());
assert_eq!(Ratio::new(25, 1), QAdic::new(UAdic::new(5, vec![4, 1, 3, 2]), -2).norm());

This struct represents adic numbers as base-p digital expansions, with a possibly-infinite number of digits to the left of a decimal point and a finite number of digits to the right.

AdicIntegers are similar, but without digits to the right of the decimal. QAdics can represent all rational numbers as well as many irrational (distinct from the real number irrationals). Using the p-adic norm, these numbers have valuation -inf < v <= inf, i.e. |x| = p^(-v).

let neg_one = -EAdic::one(5);
let neg_one_fifth = QAdic::new(neg_one.clone(), -1);
let neg_one_twenty_fifth = QAdic::new(neg_one.clone(), -2);
let sqrt_neg_one = ZAdic::new_approx(5, 6, vec![2, 1, 2, 1, 3, 4]);
assert_eq!("...431212._5", sqrt_neg_one.to_string());
let sqrt_neg_one_twenty_fifth = QAdic::new(sqrt_neg_one.clone(), -1);
assert_eq!("...43121.2_5", sqrt_neg_one_twenty_fifth.to_string());
assert_eq!(
    Ok(Variety::new(vec![sqrt_neg_one.clone(), -sqrt_neg_one.clone()])),
    neg_one.nth_root(2, 6)
);
assert!(neg_one_fifth.nth_root(2, 5).is_ok_and(|variety| variety.is_empty()));
assert_eq!(
    Ok(Variety::new(vec![sqrt_neg_one_twenty_fifth.clone(), -sqrt_neg_one_twenty_fifth])),
    neg_one_twenty_fifth.nth_root(2, 5)
);

https://en.wikipedia.org/wiki/P-adic_number

Panics

Many methods will panic if a provided prime p is not prime or digits are outside of [0, p).

Implementations

impl<A> QAdic<A>

where A: AdicInteger,

pub fn new<V>(adic_int: A, valuation: V) -> Self

where V: Into<Valuation<isize>>,

Create an adic number with the given digits and valuation

pub fn frac_and_int(&self) -> (QAdic<UAdic>, A)

Split QAdic into fraction (as QAdic<UAdic>) and integer (as A)

let r = EAdic::new_repeating(7, vec![1, 2], vec![3, 4, 5]);
assert_eq!("(543)21._7", r.to_string());
let q = QAdic::new(r, -6);
assert_eq!("(354).354321_7", q.to_string());
let (q_frac, q_int) = q.frac_and_int();
assert_eq!("0.354321_7", q_frac.to_string());
assert_eq!("(354)._7", q_int.to_string());

pub fn from_integer(adic_int: A) -> Self

Create an adic number with the given digits and zero valuation

pub fn try_into_integer(self) -> AdicResult<A>

Try to convert into an AdicInteger, returning error if there are fractional digits

let r = EAdic::new_repeating(7, vec![1, 2], vec![3, 4, 5]);
assert_eq!("(543)21._7", r.to_string());
let q = QAdic::new(r.clone(), 3);
assert_eq!("(543)21000._7", q.to_string());
let q_int = q.try_into_integer();
assert_eq!(Ok("(543)21000._7".to_string()), q_int.map(|a| a.to_string()));
let q = QAdic::new(r, -3);
assert_eq!("(354).321_7", q.to_string());
let q_int = q.try_into_integer();
assert_eq!(Err(AdicError::AdicIntegerExpected), q_int);

pub fn nth_root( &self, n: u32, precision: isize, ) -> AdicResult<Variety<QAdic<ZAdic>>>

where Self: Into<QAdic<ZAdic>>,

Calculate the n-th root, to precision digits, using Hensel lifting.

This is a specific case of Polynomial::variety, for the polynomial f(x) = x^n - a = 0.

If n has a factor of p, then the algorithm is more complicated because you have to take into account more digits.

7-adic sqrt(1/98) has two solutions, starting with 3 and with 4

let seven_adic_2_49 = QAdic::new(UAdic::new(7, vec![2]), -2);
let variety = seven_adic_2_49.nth_root(2, 6).unwrap();
let expected = Variety::new(vec![
    QAdic::new(ZAdic::new_approx(7, 7, vec![3, 1, 2, 6, 1, 2, 1]), -1),
    QAdic::new(ZAdic::new_approx(7, 7, vec![4, 5, 4, 0, 5, 4, 5]), -1),
]);
assert_eq!(expected, variety);
assert_eq!("variety(...121621.3_7, ...545045.4_7)", variety.to_string());

Errors

1. QAdic’s certainty is not high enough for desired precision
2. n == 0

Panics

Panics if certainty does not behave as expected

pub fn num_nth_roots(&self, n: u32) -> AdicResult<usize>

where Self: Into<QAdic<ZAdic>>,

Return the number of n-th roots of this QAdic

let two_49ths = QAdic::<EAdic>::primed_from(7, Rational32::new(2, 49));
assert_eq!(Ok(0), two_49ths.num_nth_roots(0));
assert_eq!(Ok(1), two_49ths.num_nth_roots(1));
assert_eq!(Ok(2), two_49ths.num_nth_roots(2));
assert_eq!(Ok(0), two_49ths.num_nth_roots(3));
assert_eq!(Ok(0), two_49ths.num_nth_roots(4));
assert_eq!(Ok(0), two_49ths.num_nth_roots(5));
assert_eq!(Ok(0), two_49ths.num_nth_roots(6));
assert_eq!(Ok(0), two_49ths.num_nth_roots(7));

Errors

Errors if rootfinding encounters problems, e.g. heavily degenerate roots

impl QAdic<ZAdic>

pub fn empty<P, V>(p: P, v: V) -> Self

where P: Into<Prime>, V: Into<Valuation<isize>>,

Create the empty QAdic<ZAdic> with valuation v

Trait Implementations

impl<A> Add for QAdic<A>

where A: AdicInteger,

type Output = QAdic<A>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<A> AddAssign for QAdic<A>

where A: AdicInteger,

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<A> AdicPrimitive for QAdic<A>

where A: AdicInteger,

fn zero<P>(p: P) -> Self

where P: Into<Prime>,

Create the zero adic number

fn one<P>(p: P) -> Self

where P: Into<Prime>,

Create the one adic number

fn p(&self) -> Prime

Prime for this adic

fn from_prime<P>(p: P) -> Self

where P: Into<Prime>,

Create the adic number associated with its prime

fn from_prime_power<PP>(pp: PP) -> Self

where PP: Into<PrimePower>,

Create the adic number associated with a power of its prime

impl<A> CanApproximate for QAdic<A>

where A: AdicInteger,

type Approximation = QAdic<ZAdic>

Output of the approximation

fn approximation(&self, n: isize) -> Self::Approximation

Approximate an number expansion to digit index n. See also: into_approximation

fn into_approximation(self, n: isize) -> Self::Approximation

where A: HasApproximateDigits,

Consume and get the approximation to digit index n. See also: approximation

impl<A> CanTruncate for QAdic<A>

where A: AdicInteger,

type Quotient = A

Output of quotient

type Truncation = QAdic<UAdic>

Output of truncation

fn split(&self, n: Self::DigitIndex) -> (Self::Truncation, Self::Quotient)

Split adic into digits [0, n) and [n, …). This splits the number into remainder and quotient. See also: into_split

fn into_split(self, n: Self::DigitIndex) -> (Self::Truncation, Self::Quotient)

Split adic into digits [0, n) and [n, …). This splits the number into remainder and quotient. See also: split

fn truncation(&self, n: Self::DigitIndex) -> Self::Truncation

where Self: Sized,

Truncate an adic number’s expansion to n. This can be thought of as the remainder a % p^n. See also: into_truncation

fn into_truncation(self, n: Self::DigitIndex) -> Self::Truncation

where Self: Sized,

Truncate an adic number’s expansion to n. This can be thought of as the remainder a % p^n. See also: truncation

fn quotient(&self, n: Self::DigitIndex) -> Self::Quotient

where Self: Sized,

Divide an adic number by p^n. This can be thought of as the quotient a // p^n See also: into_quotient

fn into_quotient(self, n: Self::DigitIndex) -> Self::Quotient

where Self: Sized,

Divide an adic number by p^n. This can be thought of as the quotient a // p^n See also: quotient

impl CheckedDiv for QAdic<EAdic>

fn checked_div(&self, v: &Self) -> Option<Self>

Divides two numbers, checking for underflow, overflow and division by zero. If any of that happens, None is returned.

impl CheckedDiv for QAdic<ZAdic>

fn checked_div(&self, v: &Self) -> Option<Self>

Divides two numbers, checking for underflow, overflow and division by zero. If any of that happens, None is returned.

impl<A> Clone for QAdic<A>

where A: AdicInteger + Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A> Debug for QAdic<A>

where A: AdicInteger + Debug,

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

Formats the value using the given formatter.

impl<A> Display for QAdic<A>

where A: AdicInteger + HasDigitDisplay<DigitDisplay = String>,

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

Formats the value using the given formatter.

impl Div for QAdic<EAdic>

type Output = QAdic<EAdic>

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl Div for QAdic<ZAdic>

type Output = QAdic<ZAdic>

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<A> Eq for QAdic<A>

where A: AdicInteger + Eq,

impl From<QAdic<EAdic>> for QAdic<ZAdic>

fn from(value: QAdic<EAdic>) -> Self

Converts to this type from the input type.

impl From<QAdic<IAdic>> for QAdic<ZAdic>

fn from(value: QAdic<IAdic>) -> Self

Converts to this type from the input type.

impl From<QAdic<RAdic>> for QAdic<ZAdic>

fn from(value: QAdic<RAdic>) -> Self

Converts to this type from the input type.

impl From<QAdic<UAdic>> for QAdic<ZAdic>

fn from(value: QAdic<UAdic>) -> Self

Converts to this type from the input type.

impl<A> From<UAdic> for QAdic<A>

where A: AdicInteger,

fn from(value: UAdic) -> Self

Converts to this type from the input type.

impl<A> HasApproximateDigits for QAdic<A>

where A: AdicInteger,

fn certainty(&self) -> Valuation<isize>

The index of the first unknown digit for this number: v(...0021.30_5) = 4

fn has_no_certainty(&self) -> bool

The number is completely uncertain, has no known digits

fn is_certain(&self) -> bool

The number is completely certain, has no unknown digits

fn significance(&self) -> Valuation<Self::ValuationRing>

where Self: UltraNormed<ValuationRing = Self::DigitIndex>, Self::ValuationRing: Sub<Output = Self::ValuationRing>,

The digital distance between minimum index and maximum (certainty).

impl<A> HasDigits for QAdic<A>

where A: AdicInteger,

type DigitIndex = isize

Type for the digits’ index, e.g. usize for EAdic or isize for QAdic

fn base(&self) -> Composite

Number of possibilities for digits

fn min_index(&self) -> Valuation<Self::DigitIndex>

Minimum digit index, possibly zero for positive valuation numbers. This is the index where the first digit of [digits](Self::digits) starts.

fn num_digits(&self) -> Valuation<usize>

The number of digits this number ultimately has, finite or infinite. Returns num-valuation if valuation is negative and num if it is positive.

fn digit(&self, n: isize) -> AdicResult<u32>

Gets the digit at this coefficient of p^n; error if it is beyond known digits (certainty)

fn digits(&self) -> impl Iterator<Item = u32>

Digits iterator for this object, starting from min_index

fn has_finite_digits(&self) -> bool

Test if this has a finite number of digits

fn digit0(&self) -> AdicResult<u32>

Returns the digit in the zeroth position or Err if it is beyond known digits (certainty)

fn real_projection(&self) -> AdicResult<f64>

Flips the digit indices from positive to negative and returns the corresponding f64. E.g. if this is an adic number, it flips the digits around its decimal point and returns the value as a real number.

impl<A> Hash for QAdic<A>

where A: AdicInteger + Hash,

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Inv for QAdic<EAdic>

type Output = QAdic<EAdic>

The result after applying the operator.

fn inv(self) -> Self::Output

Returns the multiplicative inverse of self.

impl Inv for QAdic<ZAdic>

type Output = QAdic<ZAdic>

The result after applying the operator.

fn inv(self) -> Self::Output

Returns the multiplicative inverse of self.

impl<A> LocalOne for QAdic<A>

where A: AdicInteger,

fn local_one(&self) -> Self

Returns a one local to self

fn is_local_one(&self) -> bool

Checks whether or not self is equivalent to its local one

fn set_local_one(&mut self)

Sets the object equal to its local one

impl<A> LocalZero for QAdic<A>

where A: AdicInteger,

fn local_zero(&self) -> Self

Returns a zero local to self

fn is_local_zero(&self) -> bool

Checks whether or not self is equivalent to its local zero

fn set_local_zero(&mut self)

Sets the object equal to its local zero

impl<A> Mul for QAdic<A>

where A: AdicInteger,

type Output = QAdic<A>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<A> Mul<QAdic<A>> for u32

where A: AdicInteger,

type Output = QAdic<A>

The resulting type after applying the * operator.

fn mul(self, adic_int: QAdic<A>) -> QAdic<A>

Performs the * operation.

impl<A> MulAssign for QAdic<A>

where A: AdicInteger,

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<A> Neg for QAdic<A>

where A: AdicInteger + Neg<Output = A>,

type Output = QAdic<A>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<A> Normed for QAdic<A>

where A: AdicInteger,

type Norm = Ratio<u32>

Type for the number’s norm

type Unit = A

Type for the number’s unit

fn norm(&self) -> Ratio<u32>

Norm of the number, the “size”

fn unit(&self) -> Option<Self::Unit>

Unit component of the number, or None if Zero

fn into_unit(self) -> Option<Self::Unit>

Unit component of the number, or None if Zero

fn from_norm_and_unit(norm: Self::Norm, u: Self::Unit) -> Self

Create with given norm and unit

fn from_unit(u: Self::Unit) -> Self

Create from a unit

fn is_unit(&self) -> bool

Test if the number is a unit

impl<A> PartialEq for QAdic<A>

where A: AdicInteger + PartialEq,

fn eq(&self, other: &QAdic<A>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<A> Pow<u32> for QAdic<A>

where A: AdicInteger,

type Output = QAdic<A>

The result after applying the operator.

fn pow(self, power: u32) -> Self::Output

Returns self to the power rhs.

impl<T> PrimedFrom<Ratio<BigInt>> for QAdic<T>

where T: AdicInteger, Self: From<QAdic<EAdic>>,

fn primed_from<P>(p: P, n: BigRational) -> Self

where P: Into<Prime>,

Convert from N to Self with Prime p

impl<T> PrimedFrom<Ratio<i32>> for QAdic<T>

where T: AdicInteger, Self: From<QAdic<EAdic>>,

fn primed_from<P>(p: P, n: Rational32) -> Self

where P: Into<Prime>,

Convert from N to Self with Prime p

impl<A> StructuralPartialEq for QAdic<A>

where A: AdicInteger + PartialEq,

impl<A> Sub for QAdic<A>

where A: AdicInteger + Neg<Output = A>,

type Output = QAdic<A>

The resulting type after applying the - operator.

fn sub(self, rhs: QAdic<A>) -> Self::Output

Performs the - operation.

impl<A> SubAssign for QAdic<A>

where A: AdicInteger + Neg<Output = A>,

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<A> UltraNormed for QAdic<A>

where A: AdicInteger,

type ValuationRing = isize

Type for the valuation, e.g. the type of v in a/b p^v

fn from_unit_and_valuation( u: Self::Unit, v: Valuation<Self::ValuationRing>, ) -> Self

Create with the given unit and valuation

fn valuation(&self) -> Valuation<isize>

The adic valuation for this number: v(a/b p^v) = v

fn unit_and_valuation( &self, ) -> (Option<Self::Unit>, Valuation<Self::ValuationRing>)

Transform into the adic unit and valuation form; transforms zero into (None, PosInf)

fn into_unit_and_valuation( self, ) -> (Option<Self::Unit>, Valuation<Self::ValuationRing>)

where Self: Sized,

Transform into the adic unit and valuation form; transforms zero into (None, PosInf)