Struct LeftDeadEnd

pub struct LeftDeadEnd { /* private fields */ }

Represents a Left dead end; it is identified with its set of options.

Implementations

impl LeftDeadEnd

pub const ZERO: LeftDeadEnd

The zero game.

pub fn new() -> Self

Constructs a new LeftDeadEnd with no options; i.e. the zero game. This is the same as LeftDeadEnd::default() and LeftDeadEnd::ZERO.

pub fn with_options( options: impl IntoIterator<Item = impl Into<LeftDeadEnd>>, ) -> Self

Creates a new LeftDeadEnd given an iterable of elements that can each be converted into a LeftDeadEnd.

Examples

let g = LeftDeadEnd::with_options(0..2);

assert_eq!(g.options(), vec![LeftDeadEnd::ZERO, LeftDeadEnd::integer(1)]);

pub fn options(&self) -> &[Self]

Returns a borrowed slice to the options of the LeftDeadEnd.

Examples

let g = LeftDeadEnd::ZERO;
assert!(g.options().is_empty());

let g = LeftDeadEnd::integer(4);
let h = LeftDeadEnd::integer(3);
assert_eq!(g.options(), vec!(h));

pub fn options_iter(&self) -> Iter<'_, LeftDeadEnd>

Returns an iterator over the options of the LeftDeadEnd.

pub fn novel_factors(&self) -> Vec<LeftDeadEnd>

Return the novel factors of a LeftDeadEnd.

If a sum g = h + k is novel, then, without loss of generality, h appears in every factorisation of g. But k, the counterpart to h, is not necessarily in the factors of the options of g, and so we have to build and check for it separately.

As of writing, no Left dead ends are known not to be uniquely factorisable, and so the output will likely be identical to LeftDeadEnd::factors.

pub fn factors(&self) -> Vec<LeftDeadEnd>

Return the factors of the LeftDeadEnd. They will not be in canonical form when returned.

Examples

let g = LeftDeadEnd::waiting(2) + 1;

let factors = g.factors();

assert_eq!(factors, vec![LeftDeadEnd::integer(1), LeftDeadEnd::waiting(2),
LeftDeadEnd::waiting(2) + 1, LeftDeadEnd::ZERO]);

let g = LeftDeadEnd::integer(3);

let factors = g.factors();

assert_eq!(factors, vec![LeftDeadEnd::integer(1), LeftDeadEnd::integer(2),
LeftDeadEnd::integer(3), LeftDeadEnd::ZERO]);

pub fn is_atom(&self) -> bool

Returns whether or not the LeftDeadEnd is an atom; i.e. if it has precisely two factors.

Examples

let g = LeftDeadEnd::ZERO;
assert!(!g.is_atom());

let g = LeftDeadEnd::integer(1);
assert!(g.is_atom());

pub fn integer(rank: usize) -> Self

Returns the strict form of a negative integer of given rank.

Examples

let g = LeftDeadEnd::ZERO;
let h = LeftDeadEnd::integer(0);
assert_eq!(g, h);

// The same form as the canonical form of -1 in normal play.
let g = LeftDeadEnd::integer(1);
// The same form as the canonical form of -2 in normal play.
let h = LeftDeadEnd::integer(2);
assert_eq!(&g + &g, h);

pub fn waiting(rank: usize) -> Self

Returns the waiting game of given rank. Sometimes also called the perfect murder.

Examples

let g = LeftDeadEnd::waiting(1);
let h = LeftDeadEnd::integer(1);
assert_eq!(g, h);

let g = LeftDeadEnd::ZERO;
let h = LeftDeadEnd::integer(1);
let k = LeftDeadEnd::waiting(2);
assert_eq!(k.options(), vec![g, h]);

pub fn canonical(&self) -> Self

Returns the canonical (simplest) form of the LeftDeadEnd.

Examples

let g = LeftDeadEnd::integer(1);
let h = LeftDeadEnd::waiting(2);
let k = LeftDeadEnd::with_options(vec![g.clone(), h.clone()]);

// The waiting game dominates the integer here.
assert_eq!(k.canonical().options(), vec![h]);

pub fn is_waiting(&self) -> (usize, bool)

Returns whether or not the LeftDeadEnd is a canonical form waiting game in the form of a tuple (a, b), where a respresents the rank of the waiting game (if it is one), and b represents whether or not it is a waiting game.

pub fn is_integer(&self) -> (usize, &LeftDeadEnd, bool)

Returns a 3-tuple (a, b, c), where a is the maximum rank of an integer that divides the LeftDeadEnd, b is the counterpart to the integer in the factorisation of the game, and c represents whether the game is an integer.

This function expects the LeftDeadEnd to be in canonical form!

Examples

let g = LeftDeadEnd::integer(3);
let h = LeftDeadEnd::waiting(2);
let k = (&g + &h).canonical();

let (a, b, c) = k.is_integer();

// The maximum rank of an integer dividing `k` is 3.
assert_eq!(a, 3);

// The counterpart to the integer in the factorisation of `k` is `h` (by construction).
assert_eq!(b, &h);

// The game `k` is not an integer.
assert_eq!(c, false);

let g = LeftDeadEnd::integer(7);

let (a, b, c) = g.is_integer();

// The maximum rank of an integer dividing `g` is 7.
assert_eq!(a, 7);

// The counterpart to the integer in the factorisation of `g` is 0 (by construction).
assert_eq!(b, &LeftDeadEnd::ZERO);

// The game `g` *is* an integer.
assert_eq!(c, true);

pub fn bound_length(&self) -> usize

Bounds the length of factorisations of the LeftDeadEnd. This bound is not always optimal.

pub fn flex(&self) -> usize

Returns the flexibility of the LeftDeadEnd.

pub fn birth(&self) -> usize

Returns the birthday of the LeftDeadEnd. Note that this is equivalent to its formal birthday, and hence there is no separate function for that. Also note that this is equivalent to max(self.term_lengths()).

pub fn race(&self) -> usize

Returns the race of the LeftDeadEnd. Note that this is equivalent to min(self.term_lengths()).

pub fn term_lengths(&self) -> Vec<usize>

Returns the set of terminal lengths of the LeftDeadEnd as a vector; there are no repeated entries. Note that min(self.term_lengths()) == self.race() and max(self.term_lengths()) == self.birth().

Trait Implementations

impl<Rhs> Add<Rhs> for LeftDeadEnd

where Rhs: Into<LeftDeadEnd>,

type Output = LeftDeadEnd

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for &LeftDeadEnd

type Output = LeftDeadEnd

The resulting type after applying the + operator.

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

Performs the + operation.

impl Clone for LeftDeadEnd

fn clone(&self) -> LeftDeadEnd

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LeftDeadEnd

Will only format canonical form integers.

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

Formats the value using the given formatter.

impl Default for LeftDeadEnd

fn default() -> Self

Returns the “default value” for a type.

impl Display for LeftDeadEnd

Will format canonical form integers and waiting games.

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

Formats the value using the given formatter.

impl From<usize> for LeftDeadEnd

Convert a usize into what would be the canonical form of a (negative) integer in normal play; i.e. an integer Left dead end.

fn from(value: usize) -> Self

Converts to this type from the input type.

impl Hash for LeftDeadEnd

The hash is not well-defined up to equivalence.

Example

let g = LeftDeadEnd::waiting(2) + 1;
let h = (LeftDeadEnd::waiting(2) + 1).canonical();

let mut hasher = DefaultHasher::new();
g.hash(&mut hasher);
let first_hash = hasher.finish();

let mut hasher = DefaultHasher::new();
h.hash(&mut hasher);
let second_hash = hasher.finish();

assert_ne!(first_hash, second_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 PartialEq for LeftDeadEnd

fn eq(&self, other: &LeftDeadEnd) -> 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 PartialOrd for LeftDeadEnd

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

This method returns an ordering between self and other values if one exists.

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

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

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.

impl Eq for LeftDeadEnd