Struct Rotation 

pub struct Rotation { /* private fields */ }

A data-type that describes, within 6 bits, the transformation from one CubeSurfacePoint to another.

Usage

let rotation = ending_point / beginning_point;
assert_eq!(beginning_point * rotation, ending_point);

Representation

For a complete correspondence between arithmetic values and geometric transformations, please refer to the documentation for CubeSurfacePoint. In here, we will describe the correspondence of each transformation with its binary representation.

The gist is that the three first bits describe the order in which the three coördinates must be positioned, while the last three bits describe which of their signs have to be flipped. It must be noted that the bits cannot be examined in arbitrary order: Bit 3 must always be examined first, and the three last bits must be examined last. Their order and meaning is as follows:

• 3: Swaps coöordinates 1 and 3.
• 4: Swaps coöordinates 2 and 3.
• 5: Swaps coöordinates 1 and 2.
• 2: Flips the sign of coördinate 1.
• 1: Flips the sign of coördinate 2.
• 0: Flips the sign of coördinate 3.

Also note that this data-type encodes both proper and improper rotations. The ProperRotation and ImproperRotation data-types separate the two.

Multiplying/dividing rotations together

The various rotation data-types can be multiplied, and therefore have had Mul and Div implemented between them:

• The ordinary Rotation can only be multiplied with itself.
• In contrast, the ProperRotation and the ImproperRotation can be multiplied both with themselves and with each other.

Implementations

impl Rotation

pub const fn mul(self, x: CubeSurfacePoint) -> CubeSurfacePoint

Because Mul is not const.

Trait Implementations

impl Clone for Rotation

fn clone(&self) -> Rotation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Rotation

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

Formats the value using the given formatter.

impl Div for Rotation

Implements division between rotations, such that (rot_a * rot_b) / rot_b == rot_a.

Important note: rot_a / rot_b is not necessarily equal to (1 / rot_b) * rot_a. See also the relevant comment on Mul.

type Output = Rotation

The output type tells us all we know about the propriety of the result.

fn div(self, other: Rotation) -> Self::Output

Implemented by dividing the two corresponding points with one another.

impl From<CubeSurfacePoint<false>> for Rotation

fn from(corresponding_point: CubeSurfacePoint<false>) -> Self

Converts to this type from the input type.

impl From<CubeSurfacePoint<true>> for Rotation

fn from(corresponding_point: CubeSurfacePoint<true>) -> Self

Converts to this type from the input type.

impl From<CubeSurfacePoint> for Rotation

fn from(corresponding_point: CubeSurfacePoint) -> Self

Converts to this type from the input type.

impl From<ImproperRotation> for Rotation

Discards any notion of propriety, producing a general Rotation.

fn from(x: ImproperRotation) -> Self

Converts to this type from the input type.

impl From<ProperRotation> for Rotation

Discards any notion of propriety, producing a general Rotation.

fn from(x: ProperRotation) -> Self

Converts to this type from the input type.

impl From<Rotation> for CubeSurfacePoint

fn from(x: Rotation) -> Self

Converts to this type from the input type.

impl From<Rotation> for CubeSurfacePoint<false>

fn from(x: Rotation) -> Self

Converts to this type from the input type.

impl From<Rotation> for CubeSurfacePoint<true>

fn from(x: Rotation) -> Self

Converts to this type from the input type.

impl Mul<CubeSurfacePoint<false>> for Rotation

Rotates a copy of a given CubeSurfacePoint according to self.

type Output = CubeSurfacePoint<false>

Output same as input.

fn mul(self, cub_sur_pt: Self::Output) -> Self::Output

The rotation happens Elementary-Reflection-by-Elementary-Reflection as usual, but each Elementary Reflection is performed with a LUT.

impl Mul<CubeSurfacePoint<true>> for Rotation

Rotates a copy of a given CubeSurfacePoint according to self.

type Output = CubeSurfacePoint<true>

Output same as input.

fn mul(self, cub_sur_pt: Self::Output) -> Self::Output

self is not examined bit-by-bit. Instead, a look-up on a 2-D LUT produces the result directly.

impl Mul<CubeSurfacePoint> for Rotation

Rotates a given CubeSurfacePoint according to self.

type Output = CubeSurfacePoint

Output same as input.

fn mul(self, cub_sur_pt: CubeSurfacePoint) -> Self::Output

The operation is performed by examining self’s bits one by one, and performing on the other surface_point the corresponding elementary reflections.

impl Mul<Rotation> for CubeSurfacePoint

Rotates a copy of self per some Rotation.

type Output = CubeSurfacePoint

Output same as input.

fn mul(self, rot: Rotation) -> Self::Output

The operation is performed by examining the bits of the Rotation one-by-one, then performing the corresponding elementary reflections on self.

impl Mul<Rotation> for CubeSurfacePoint<false>

Rotates a copy of self according to a Rotation.

type Output = CubeSurfacePoint<false>

We use the most general data-type possible, so the output does not change.

fn mul(self, rot: Rotation) -> Self::Output

The rotation happens Elementary-Reflection-by-Elementary-Reflection as usual, but each Elementary Reflection is performed with a LUT.

impl Mul<Rotation> for CubeSurfacePoint<true>

Rotates a copy of self according to a Rotation.

type Output = CubeSurfacePoint<true>

We use the most general data-type possible, so the output does not change.

fn mul(self, rot: Rotation) -> Self::Output

The Rotation is not examined bit-by-bit. Instead, a look-up on a 2-D LUT produces the result directly.

impl Mul for Rotation

Implements multiplication between rotations, such that rot_a * rot_b * point_x can be computed as either rot_a * (rot_b * point_x) or (rot_a * rot_b) * point_x, with no change to the result computed.

Important note: Rotations are essentially highly simplified matrices. This means that, in the general case, commutativity does not hold, and therefore rot_a * rot_b and rot_b * rot_a are not necessarily equal.

type Output = Rotation

The output type tells us all we know about the propriety of the result.

fn mul(self, other: Rotation) -> Self::Output

Implemented by multiplying the second rotation’s corresponding point with the first one.

impl MulAssign<Rotation> for CubeSurfacePoint

Rotates self per some Rotation.

fn mul_assign(&mut self, rot: Rotation)

The data-type doesn’t change, so the result can be directly assigned.

impl MulAssign<Rotation> for CubeSurfacePoint<false>

Rotates self according to a Rotation.

fn mul_assign(&mut self, rot: Rotation)

We use the most general data-type possible, so the output does not change. Thus, it can be directly assigned.

The rotation happens Elementary-Reflection-by-Elementary-Reflection as usual, but each Elementary Reflection is performed with a LUT.

impl MulAssign<Rotation> for CubeSurfacePoint<true>

Rotates self according to a Rotation.

fn mul_assign(&mut self, rot: Rotation)

We use the most general data-type possible, so the output does not change. Thus, it can be directly assigned.

The Rotation is not examined bit-by-bit. Instead, a look-up on a 2-D LUT produces the result directly.

impl Ord for Rotation

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

This method returns an Ordering between self and other.

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.

impl PartialEq for Rotation

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

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

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

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 TryFrom<Rotation> for ImproperRotation

Discriminates a Rotation based on impropriety.

type Error = ProperRotation

If a Rotation is not improper, it must by necessity be proper.

fn try_from(x: Rotation) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Rotation> for ProperRotation

Discriminates a Rotation based on propriety.

type Error = ImproperRotation

If a Rotation is not proper, it must by necessity be improper.

fn try_from(x: Rotation) -> Result<Self, Self::Error>

Performs the conversion.

impl Copy for Rotation

impl Eq for Rotation

impl StructuralPartialEq for Rotation