Struct ShortlexUnsignedVectorRef 

pub struct ShortlexUnsignedVectorRef<'a, T: PrimitiveUnsigned>(pub &'a UnsignedVector<T>);

ShortlexUnsignedVectorRef is a wrapper around an UnsignedVector, taking the UnsignedVector by reference.

See the ShortlexUnsignedVector documentation for details.

Tuple Fields

0: &'a UnsignedVector<T>

Trait Implementations

impl<'a, T: Clone + PrimitiveUnsigned> Clone for ShortlexUnsignedVectorRef<'a, 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 ShortlexUnsignedVectorRef<'_, T>

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

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

Examples

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

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

impl<T: PrimitiveUnsigned> Deref for ShortlexUnsignedVectorRef<'_, T>

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

Allows a ShortlexUnsignedVectorRef to dereference to an UnsignedVector.

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

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

type Target = UnsignedVector<T>

The resulting type after dereferencing.

impl<'a, T: Eq + PrimitiveUnsigned> Eq for ShortlexUnsignedVectorRef<'a, T>

impl<'a, T: Hash + PrimitiveUnsigned> Hash for ShortlexUnsignedVectorRef<'a, 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 ShortlexUnsignedVectorRef<'_, T>

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

Compares two ShortlexUnsignedVectorRefs.

The order is shortlex: the vectors are compared first by dimension, and then, in case of a tie, lexicographically, by their elements from first to last. The 0-dimensional vector comes first. This is a total order, and its equality agrees with UnsignedVector equality.

Where the dimensions differ this parts company with the lexicographic order of Vecs: here dimension decides outright, so $(5) < (0, 0)$, where lexicographic order has $(5) > (0, 0)$.

Examples

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

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

// The 0-dimensional vector comes first.
assert!(ShortlexUnsignedVectorRef(&empty) < ShortlexUnsignedVectorRef(&five));
// Dimension decides, whatever the elements.
assert!(ShortlexUnsignedVectorRef(&five) < ShortlexUnsignedVectorRef(&zero_zero));
// At equal dimensions, the first differing element decides.
assert!(ShortlexUnsignedVectorRef(&zero_zero) < ShortlexUnsignedVectorRef(&zero_one));

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<'a, T: PartialEq + PrimitiveUnsigned> PartialEq for ShortlexUnsignedVectorRef<'a, T>

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

Equality operator ==.

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

Inequality operator !=.

impl<T: PrimitiveUnsigned> PartialOrd for ShortlexUnsignedVectorRef<'_, T>

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

Compares two ShortlexUnsignedVectorRefs.

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<'a, T: PartialEq + PrimitiveUnsigned> StructuralPartialEq for ShortlexUnsignedVectorRef<'a, T>