Struct Variety 

pub struct Variety<T> { /* private fields */ }

An algebraic variety, often a set of “roots” to an algebraic equation

let z = Variety::new(vec![
    ZAdic::new_approx(5, 6, vec![0, 1, 2, 3]),
    ZAdic::from(EAdic::new(5, vec![4, 3])),
]);
assert_eq!(ZAdic::new_approx(5, 6, vec![0, 1, 2, 3]), z[0]);
assert_eq!(Some(&ZAdic::from(EAdic::new(5, vec![4, 3]))), z.get(1));
assert_eq!(None, z.get(2));
assert_eq!("variety(...003210._5, 34._5)", z.to_string());

Often known as the “solutions” of the equation.

E.g. x^2 - 4 = 0 has an associated variety of {2, -2} (in both the reals and all p-adics).

E.g. x^2 - 2 = 0 has a non-integer variety {1.414..., -1.414...} in the reals, integer variety {...6213._5, ...0454._5} in the 7-adics, and no solutions/variety in the 5-adics (indecomposable and irreducible).

Note that the roots are not sorted in any way, and multiplicity/degeneracy is allowed. If sorting is desired, the adic_sort and adic_sorted methods will sort adic numbers by digit.

Implementations

impl<A> Variety<A>

where A: AdicPrimitive,

pub fn p(&self) -> AdicResult<Prime>

Prime for this adic variety, or error if the variety is empty

pub fn primed_from_roots<P, B, IB>(p: P, roots: IB) -> Self

where P: Into<Prime>, A: PrimedFrom<B>, IB: IntoIterator<Item = B>,

Create a Variety from a Vec of roots that can be primed into A

pub fn try_primed_from_roots<P, B, IB>(p: P, roots: IB) -> AdicResult<Self>

where P: Into<Prime>, A: TryPrimedFrom<B>, IB: IntoIterator<Item = B>, AdicError: From<A::Error>,

Create a Variety from a Vec of roots that can attempt to be primed into A

pub fn approximation(&self, n: A::DigitIndex) -> Variety<A::Approximation>

where A: CanApproximate, A::Approximation: AdicPrimitive,

Approximate all members of this variety to certainty n

let av = Variety::new(vec![UAdic::new(5, vec![]), UAdic::new(5, vec![1]), UAdic::new(5, vec![1, 2, 3, 4])]);
let zv = Variety::new(vec![ZAdic::new_approx(5, 2, vec![]), ZAdic::new_approx(5, 2, vec![1]), ZAdic::new_approx(5, 2, vec![1, 2])]);
assert_eq!(zv, av.approximation(2));

pub fn into_approximation(self, n: A::DigitIndex) -> Variety<A::Approximation>

where A: CanApproximate, A::Approximation: AdicPrimitive,

Approximate all members of this variety to certainty n

let av = Variety::new(vec![UAdic::new(5, vec![]), UAdic::new(5, vec![1]), UAdic::new(5, vec![1, 2, 3, 4])]);
let zv = Variety::new(vec![ZAdic::new_approx(5, 2, vec![]), ZAdic::new_approx(5, 2, vec![1]), ZAdic::new_approx(5, 2, vec![1, 2])]);
assert_eq!(zv, av.into_approximation(2));

pub fn adic_sort(&mut self)

where A: HasApproximateDigits,

Sort (in-place) this adic Variety, using digits from least to most significance

pub fn adic_sorted(self) -> Self

where A: HasApproximateDigits,

Sort this adic Variety, using digits from least to most significance

impl<A> Variety<A>

where A: AdicPrimitive + AdicInteger,

pub fn into_fractional(self) -> Variety<QAdic<A>>

Convert adic integer variety into QAdic variety

impl<A> Variety<QAdic<A>>

where A: AdicPrimitive + AdicInteger,

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

Convert QAdic variety into adic integer variety, throwing an error if any root is fractional

impl<T> Variety<T>

pub fn new(roots: Vec<T>) -> Self

Create a variety with the given roots/solutions

pub fn num_roots(&self) -> usize

Number of roots in variety

pub fn roots(&self) -> impl Iterator<Item = &T>

Iterator reference for the roots of this variety

let v = Variety::<ZAdic>::primed_from_roots(5, [86, 38, 42]);
let v = v.into_approximation(3).adic_sorted();
assert_eq!(
    vec![
        &ZAdic::new_approx(5, 3, vec![1, 2, 3]),
        &ZAdic::new_approx(5, 3, vec![2, 3, 1]),
        &ZAdic::new_approx(5, 3, vec![3, 2, 1]),
    ],
    v.roots().collect::<Vec<_>>()
);

pub fn into_roots(self) -> impl Iterator<Item = T>

Iterator for the roots of this variety

let v = Variety::<ZAdic>::primed_from_roots(5, [86, 38, 42]);
let v = v.into_approximation(3).adic_sorted();
assert_eq!(
    vec![
        ZAdic::new_approx(5, 3, vec![1, 2, 3]),
        ZAdic::new_approx(5, 3, vec![2, 3, 1]),
        ZAdic::new_approx(5, 3, vec![3, 2, 1]),
    ],
    v.into_roots().collect::<Vec<_>>()
);

pub fn is_empty(&self) -> bool

Do no roots exist

let v = Variety::new(vec![
    ZAdic::new_approx(5, 3, vec![1, 2, 3]),
    ZAdic::new_approx(5, 3, vec![3, 2, 1]),
]);
assert!(!v.is_empty());
let v = Variety::<ZAdic>::new(vec![]);
assert!(v.is_empty());

pub fn empty() -> Self

Create an empty adic variety

pub const fn len(&self) -> usize

Returns the number of roots in the variety

pub fn get(&self, idx: usize) -> Option<&T>

Returns a reference to an element or None if out of bounds

Trait Implementations

impl<T: Clone> Clone for Variety<T>

fn clone(&self) -> Variety<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Variety<T>

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

Formats the value using the given formatter.

impl<T> Display for Variety<T>

where T: Display,

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

Formats the value using the given formatter.

impl<T> Eq for Variety<T>

where T: Eq + Hash,

impl<T> Extend<T> for Variety<T>

fn extend<U: IntoIterator<Item = T>>(&mut self, iter: U)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: T)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<T> Index<usize> for Variety<T>

type Output = T

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T> PartialEq for Variety<T>

where T: Eq + Hash,

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

Equality operator ==.

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

Inequality operator !=.

impl<A, B> PrimedFrom<Variety<B>> for Variety<A>

where A: AdicPrimitive + PrimedFrom<B>,

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

where P: Into<Prime>,

Convert from N to Self with Prime p