Struct IAdic

pub struct IAdic { /* private fields */ }

Adic that represents a signed integer (iadic_pos, iadic_neg)

An AdicInteger. This can represent any real, signed integer. The struct holds a finite list of digits, from the “zero” digit place to the max. After this, it holds either all zeros or all (p-1)s, aka -1 in F_p. This second-most basic Adic struct, has a finite number of digits and a sign. With this, you can represent exactly the real integers.

assert_eq!("4321._5", IAdic::new_pos(5, vec![1, 2, 3, 4]).to_string());
let two = IAdic::new_pos(5, vec![2]);
assert_eq!(2, two.i32_value());
let neg_two = IAdic::new_neg(5, vec![3]);
assert_eq!("(4)3._5", neg_two.to_string());
assert_eq!(-2, neg_two.i32_value());
assert!((two + neg_two).is_zero());

This representation EXACTLY matches the real number base-p digits for a positive real integer. 2 = 2._5, 123 (base 5) = 123._5 You can perform the same arithmetic on these numbers. However, as a signed number, we can also represent negative numbers. -2 = (4)3._5 = ...4443._5, -123 (base 5) = (4)322._5

These numbers can be subtracted but not divided. Instead, look to rationals, RAdic, or if they can be approximate, ZAdic.

ZAdic internally uses IAdic for the exact case.

Implementations

impl IAdic

pub fn new<P>(p: P, init_digits: Vec<u32>, sign: Sign) -> Self

where P: Into<Prime>,

Create an adic number with the given digits and sign

Panics

Panics if p is not prime or digits are outside of [0, p)

pub fn new_pos<P>(p: P, init_digits: Vec<u32>) -> Self

where P: Into<Prime>,

Create a positive adic number with the given digits

Panics

Panics if p is not prime or digits are outside of [0, p)

pub fn new_neg<P>(p: P, init_digits: Vec<u32>) -> Self

where P: Into<Prime>,

Create a negative adic number with the given digits

Panics

Panics if p is not prime or digits are outside of [0, p)

pub fn into_abs(self) -> UAdic

Consume IAdic and get the real absolute value UAdic

let i = iadic_pos!(5, [1, 2, 3, 4, 0]);
assert_eq!(uadic!(5, [1, 2, 3, 4]), i.into_abs());
let i = iadic_neg!(5, [1, 2, 3, 4, 0]);
assert_eq!(uadic!(5, [4, 2, 1, 0, 4]), i.into_abs());

pub fn abs(&self) -> UAdic

Real absolute value UAdic

let i = iadic_pos!(5, [1, 2, 3, 4, 0]);
assert_eq!(uadic!(5, [1, 2, 3, 4]), i.abs());
let i = iadic_neg!(5, [1, 2, 3, 4, 0]);
assert_eq!(uadic!(5, [4, 2, 1, 0, 4]), i.abs());

pub fn is_non_negative(&self) -> bool

Does the IAdic repesent a non-negative integer

pub fn num_non_trailing(&self) -> usize

Number of non-trailing digits

assert_eq!(2, iadic_pos!(5, [2, 4, 0]).num_non_trailing());
assert_eq!(1, iadic_neg!(5, [2, 4, 4]).num_non_trailing());

pub fn trailing_digit(&self) -> u32

Trailing digit for IAdic, either 0 or (p-1)

assert_eq!(0, iadic_pos!(5, [4, 2]).trailing_digit());
assert_eq!(4, iadic_neg!(5, [4, 2]).trailing_digit());

pub fn i32_value(&self) -> i32

The natural number value of the number, e.g. 5-adic 123 is 25+10+3=38

Warning: This can overflow; use signed_bigint_value if unsure

Panics

Panics if u32 -> i32 conversion fails

assert_eq!(38, iadic_pos!(5, [3, 2, 1]).i32_value());
assert_eq!(-38, iadic_neg!(5, [2, 2, 3]).i32_value());

pub fn signed_bigint_value(&self) -> BigInt

The bigint representation for the natural number value of the number (i32_value)

assert_eq!(BigInt::from(38), iadic_pos!(5, [3, 2, 1]).signed_bigint_value());
assert_eq!(BigInt::from(-38), iadic_neg!(5, [2, 2, 3]).signed_bigint_value());

Trait Implementations

impl Add<&IAdic> for &IAdic

type Output = IAdic

The resulting type after applying the + operator.

fn add(self, b: &IAdic) -> Self::Output

Performs the + operation.

impl Add<&IAdic> for IAdic

type Output = IAdic

The resulting type after applying the + operator.

fn add(self, b: &IAdic) -> Self::Output

Performs the + operation.

impl Add<IAdic> for &IAdic

type Output = IAdic

The resulting type after applying the + operator.

fn add(self, b: IAdic) -> Self::Output

Performs the + operation.

impl Add for IAdic

type Output = IAdic

The resulting type after applying the + operator.

fn add(self, b: IAdic) -> Self::Output

Performs the + operation.

impl AdicApproximate for IAdic

fn certainty(&self) -> AdicValuation<Self::DigitIndex>

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

fn has_no_certainty(&self) -> bool

The adic is completely uncertain, has no known digits

fn is_certain(&self) -> bool

Test if adic number is completely known

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

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

The digital distance between valuation and certainty.

impl AdicInteger for IAdic

fn digit_str(&self) -> String

A string representing the digits of this adic number; used to Display the integer.

fn into_split(self, n: usize) -> (UAdic, Self)

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

fn p_power<P, I>(p: P, n: I) -> Self

where P: Into<Prime>, I: Into<AdicValuation<usize>>,

Create an AdicInteger representing a power of p

fn padded_digits(&self, n: usize) -> Vec<u32>

Get a vector of the digits, padding with zeros, to exactly n. See also: into_padded_digits

fn into_padded_digits(self, n: usize) -> Vec<u32>

where Self: Sized,

Get a vector of the digits, padding with zeros, to exactly n. See also: padded_digits

fn truncation(&self, n: usize) -> UAdic

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: usize) -> UAdic

Consume AdicInteger and get the truncation. See also: truncation

fn approximation(&self, n: usize) -> ZAdic

where Self: AdicApproximate,

Approximate an adic number’s expansion to n digits. See also: into_approximation

fn into_approximation(self, n: usize) -> ZAdic

where Self: AdicApproximate,

Consume AdicInteger and get the approximation. See also: approximation

fn split(&self, n: usize) -> (UAdic, Self)

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

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

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

fn into_quotient(self, n: usize) -> Self

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

fn nth_root(&self, n: u32, precision: usize) -> AdicResult<ZAdicVariety>

where Self: Into<ZAdic>,

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

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

where Self: Into<ZAdic>,

Return the number of n-th roots of this AdicInteger

impl AdicNumber for IAdic

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_u32<P>(p: P, n: u32) -> Self

where P: Into<Prime>,

Create AdicNumber from u32

fn is_zero(&self) -> bool

Test if it is the zero adic number

impl Clone for IAdic

fn clone(&self) -> IAdic

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for IAdic

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

Formats the value using the given formatter.

impl Display for IAdic

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

Formats the value using the given formatter.

impl Div<&IAdic> for &IAdic

type Output = LazyDiv<IAdic>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<&IAdic> for IAdic

type Output = LazyDiv<IAdic>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<IAdic> for &IAdic

type Output = LazyDiv<IAdic>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div for IAdic

type Output = LazyDiv<IAdic>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<A> From<IAdic> for QAdic<A>

where A: AdicInteger + From<IAdic>,

fn from(value: IAdic) -> Self

Converts to this type from the input type.

impl From<IAdic> for RAdic

fn from(a: IAdic) -> Self

Converts to this type from the input type.

impl From<IAdic> for ZAdic

fn from(a: IAdic) -> Self

Converts to this type from the input type.

impl From<UAdic> for IAdic

fn from(a: UAdic) -> Self

Converts to this type from the input type.

impl HasDigits for IAdic

type DigitIndex = usize

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

fn base(&self) -> Composite

Number of possibilities for digits

fn min_index(&self) -> AdicValuation<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) -> AdicValuation<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: usize) -> 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 for this adic, from the p^v coefficient to p^(v+1), etc.

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

Consume AdicInteger and get the digits iterator

fn has_finite_digits(&self) -> bool

Test if adic number has finite digits

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

Returns the digit in the zeroth position or Err if certainty <= 0

impl Hash for IAdic

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 IAdic

type Output = LazyDiv<IAdic>

The result after applying the operator.

fn inv(self) -> Self::Output

Returns the multiplicative inverse of self.

impl Mul<&IAdic> for &IAdic

type Output = IAdic

The resulting type after applying the * operator.

fn mul(self, b: &IAdic) -> Self::Output

Performs the * operation.

impl Mul<&IAdic> for IAdic

type Output = IAdic

The resulting type after applying the * operator.

fn mul(self, b: &IAdic) -> Self::Output

Performs the * operation.

impl Mul<&IAdic> for u32

type Output = IAdic

The resulting type after applying the * operator.

fn mul(self, adic_int: &IAdic) -> IAdic

Performs the * operation.

impl Mul<IAdic> for &IAdic

type Output = IAdic

The resulting type after applying the * operator.

fn mul(self, b: IAdic) -> Self::Output

Performs the * operation.

impl Mul<IAdic> for u32

type Output = IAdic

The resulting type after applying the * operator.

fn mul(self, adic_int: IAdic) -> IAdic

Performs the * operation.

impl Mul<u32> for &IAdic

type Output = IAdic

The resulting type after applying the * operator.

fn mul(self, coeff: u32) -> IAdic

Performs the * operation.

impl Mul<u32> for IAdic

type Output = IAdic

The resulting type after applying the * operator.

fn mul(self, coeff: u32) -> IAdic

Performs the * operation.

impl Mul for IAdic

type Output = IAdic

The resulting type after applying the * operator.

fn mul(self, b: IAdic) -> Self::Output

Performs the * operation.

impl Neg for &IAdic

type Output = IAdic

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for IAdic

type Output = IAdic

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl PartialEq for IAdic

fn eq(&self, other: &IAdic) -> 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 Pow<u32> for &IAdic

type Output = IAdic

The result after applying the operator.

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

Returns self to the power rhs.

impl Pow<u32> for IAdic

type Output = IAdic

The result after applying the operator.

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

Returns self to the power rhs.

impl Sub<&IAdic> for &IAdic

type Output = IAdic

The resulting type after applying the - operator.

fn sub(self, b: &IAdic) -> Self::Output

Performs the - operation.

impl Sub<&IAdic> for IAdic

type Output = IAdic

The resulting type after applying the - operator.

fn sub(self, b: &IAdic) -> Self::Output

Performs the - operation.

impl Sub<IAdic> for &IAdic

type Output = IAdic

The resulting type after applying the - operator.

fn sub(self, b: IAdic) -> Self::Output

Performs the - operation.

impl Sub for IAdic

type Output = IAdic

The resulting type after applying the - operator.

fn sub(self, b: IAdic) -> Self::Output

Performs the - operation.

impl TryFrom<IAdic> for UAdic

type Error = AdicError

The type returned in the event of a conversion error.

fn try_from(a: IAdic) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<RAdic> for IAdic

type Error = AdicError

The type returned in the event of a conversion error.

fn try_from(a: RAdic) -> Result<Self, Self::Error>

Performs the conversion.

impl Eq for IAdic

impl StructuralPartialEq for IAdic