Struct Algorithm 

pub struct Algorithm { /* private fields */ }

Represents a series of moves you can perform on a cube

Example

 use rubiks_moves::moves::Algorithm;

 let alg = Algorithm::from("R U R' U'").unwrap();

Implementations

impl Algorithm

pub const fn new() -> Self

Creates an Algorithm that doesn’t have any moves

pub fn simplify(&self) -> Self

Creates a shorter set of moves that still leaves the cube in the same state at the end

For example, combining U U into U2, or U U’ into nothing

Example

use rubiks_moves::moves::Algorithm;

let alg = Algorithm::from("U U").unwrap();
let simplified = Algorithm::from("U2").unwrap();

assert_eq!(alg.simplify(), simplified);

pub fn from(s: &str) -> Result<Self, MoveParseError>

Creates a Algorithm from a &str, mostly a convience function, or a way to take input from the user

Errors

This errors when it is not given a space seperated list of single face turns e.g. U, F’, or D2

Example

use rubiks_moves::moves::{Algorithm, Move, FaceTurn};

let parsed_alg = Algorithm::from("F' L").unwrap();

pub fn inverse(&self) -> Self

Calulates the inverse for a whole algorthm at once.

If a given Algorithm is performed on a cube, then if Algorithm::inverse() is perfermed, the cube will return to its origonal state

Example

use rubiks_moves::moves::Algorithm;

let original = Algorithm::from("F R U").unwrap();
let inversed = Algorithm::from("U' R' F'").unwrap();

assert_eq!(original.inverse(), inversed);

pub fn commute(&self, other: &Self) -> Self

Combines two Algorithms in the form of ABA’B’

Example

use rubiks_moves::moves::Algorithm;

let r = Algorithm::from("R").unwrap();
let u = Algorithm::from("U").unwrap();

let sexy = Algorithm::from("R U R' U'").unwrap();

assert_eq!(r.commute(&u), sexy);

pub fn permute(&self, other: &Self) -> Self

Combines two Algorithms in the form of ABA’

Example

use rubiks_moves::moves::Algorithm;

let r = Algorithm::from("R").unwrap();
let u = Algorithm::from("U").unwrap();

let r_u_r_rev = Algorithm::from("R U R'").unwrap();

assert_eq!(r.permute(&u), r_u_r_rev);

pub fn sexy() -> Self

A sample Algorithm that is used often in speedcubing. Equvalent to R U R’ U’

pub fn order(&self) -> u32

Determines how many times an algorithm needs to be repeated, to return to its origonal state

Example

use rubiks_moves::moves::Algorithm;

let sexy = Algorithm::from("R U R' U'").unwrap();

assert_eq!(sexy.order(), 6);

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

Determines if an Algorithm solves another one

Example

use rubiks_moves::moves::Algorithm;

let scramble = Algorithm::from("R' U' F D2 L2 F R2 U2 R2 B D2 L B2 D' B2 L' R' B D2 B U2 L U2 R' U' F").unwrap();
let solution = Algorithm::from("D2 F' D2 U2 F' L2 D R2 D B2 F L2 R' F' D U'").unwrap();

assert!(solution.solves(&scramble));

Trait Implementations

impl Add<&Algorithm> for Algorithm

type Output = Algorithm

The resulting type after applying the + operator.

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

Performs the + operation.

impl Clone for Algorithm

fn clone(&self) -> Algorithm

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Algorithm

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

Formats the value using the given formatter.

impl Default for Algorithm

fn default() -> Algorithm

Returns the “default value” for a type.

impl Display for Algorithm

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

Formats the value using the given formatter.

impl<T> From<Vec<T>> for Algorithm

where T: Into<Move> + Copy,

fn from(moves: Vec<T>) -> Self

Converts to this type from the input type.

impl IntoIterator for Algorithm

type Item = Move

The type of the elements being iterated over.

type IntoIter = IntoIter<<Algorithm as IntoIterator>::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for Algorithm

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

impl StructuralPartialEq for Algorithm