Struct ShortlexUnsignedVector 

pub struct ShortlexUnsignedVector<T: PrimitiveUnsigned>(pub UnsignedVector<T>);

ShortlexUnsignedVector is a wrapper around an UnsignedVector, taking the UnsignedVector by value.

UnsignedVector does not implement Ord, because no order on vectors is canonical: lex, graded lex, and the others all have their uses, and the order most natural mathematically, comparing vectors of the same dimension element by element, is only partial. Wrapping an UnsignedVector in a ShortlexUnsignedVector provides one total order: vectors are compared first by dimension and then, in case of a tie, lexicographically, by their elements from first to last. Its equality agrees with UnsignedVector equality.

Unlike lexicographic order on Vecs, this order puts every vector of a smaller dimension before every vector of a larger one, so that $(5) < (0, 0)$. It is a well-order: any nonempty set of vectors has a least element, the lexicographically least of those of the smallest dimension present.

ShortlexUnsignedVector owns its value. This is useful in many cases, for example if you want to use UnsignedVectors as keys in a BTreeMap. In other situations, it is better to use ShortlexUnsignedVectorRef, which only has a reference to its value.

Tuple Fields

0: UnsignedVector<T>

Implementations

impl<T: PrimitiveUnsigned> ShortlexUnsignedVector<T>

pub const fn as_ref(&self) -> ShortlexUnsignedVectorRef<'_, T>

Borrows a ShortlexUnsignedVector as a ShortlexUnsignedVectorRef.

Worst-case complexity

Constant time and additional memory.

Examples

use core::str::FromStr;
use malachite_base::unsigned_vector::{
    ShortlexUnsignedVector, ShortlexUnsignedVectorRef, UnsignedVector,
};

let v = UnsignedVector::<u32>::from_str("(1, 2, 3)").unwrap();
let x = ShortlexUnsignedVector(v.clone());
assert_eq!(x.as_ref(), ShortlexUnsignedVectorRef(&v));

Trait Implementations

impl<T: Clone + PrimitiveUnsigned> Clone for ShortlexUnsignedVector<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: PrimitiveUnsigned> Debug for ShortlexUnsignedVector<T>

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

Writes a ShortlexUnsignedVector as ShortlexUnsignedVector( followed by the vector and ).

Examples

use core::str::FromStr;
use malachite_base::strings::ToDebugString;
use malachite_base::unsigned_vector::{ShortlexUnsignedVector, UnsignedVector};

let v = UnsignedVector::<u32>::from_str("(1, 2)").unwrap();
assert_eq!(
    ShortlexUnsignedVector(v).to_debug_string(),
    "ShortlexUnsignedVector((1, 2))"
);

impl<T: PrimitiveUnsigned> Deref for ShortlexUnsignedVector<T>

fn deref(&self) -> &UnsignedVector<T>

Allows a ShortlexUnsignedVector to dereference to an UnsignedVector.

use core::str::FromStr;
use malachite_base::unsigned_vector::{ShortlexUnsignedVector, UnsignedVector};

let v = UnsignedVector::<u32>::from_str("(1, 2, 3)").unwrap();
let x = ShortlexUnsignedVector(v.clone());
assert_eq!(*x, v);

type Target = UnsignedVector<T>

The resulting type after dereferencing.

impl<T: Eq + PrimitiveUnsigned> Eq for ShortlexUnsignedVector<T>

impl<T: Hash + PrimitiveUnsigned> Hash for ShortlexUnsignedVector<T>

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<T: PrimitiveUnsigned> Ord for ShortlexUnsignedVector<T>

fn cmp(&self, other: &Self) -> Ordering

Compares two ShortlexUnsignedVectors.

The order is shortlex: the vectors are compared first by dimension, and then, in case of a tie, lexicographically. See the Ord implementation for ShortlexUnsignedVectorRef for details.

Examples

use core::str::FromStr;
use malachite_base::unsigned_vector::{ShortlexUnsignedVector, UnsignedVector};
use std::collections::BTreeSet;

let five = UnsignedVector::<u32>::from_str("(5)").unwrap();
let zero_zero = UnsignedVector::<u32>::from_str("(0, 0)").unwrap();

// Dimension decides, whatever the elements.
assert!(ShortlexUnsignedVector(five.clone()) < ShortlexUnsignedVector(zero_zero.clone()));

// The wrapper makes vectors usable in ordered collections.
let set: BTreeSet<_> = [zero_zero, five]
    .into_iter()
    .map(ShortlexUnsignedVector)
    .collect();
assert_eq!(
    set.iter().map(|v| v.to_string()).collect::<Vec<_>>(),
    ["(5)", "(0, 0)"]
);

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

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

Restrict a value to a certain range.

impl<T: PartialEq + PrimitiveUnsigned> PartialEq for ShortlexUnsignedVector<T>

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

Equality operator ==.

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

Inequality operator !=.

impl<T: PrimitiveUnsigned> PartialOrd for ShortlexUnsignedVector<T>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

Compares two ShortlexUnsignedVectors.

See the documentation for the Ord implementation.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: PartialEq + PrimitiveUnsigned> StructuralPartialEq for ShortlexUnsignedVector<T>