Struct ProperRotation 

pub struct ProperRotation { /* private fields */ }

As per a Rotation, but one that specifically needs no reflections.

Trait Implementations

impl Clone for ProperRotation

fn clone(&self) -> ProperRotation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProperRotation

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

Formats the value using the given formatter.

impl Div<ImproperRotation> for ProperRotation

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 = ImproperRotation

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

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

Implemented by dividing the two corresponding points with one another.

impl Div<ProperRotation> for ImproperRotation

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 = ImproperRotation

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

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

Implemented by dividing the two corresponding points with one another.

impl Div for ProperRotation

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 = ProperRotation

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

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

Implemented by dividing the two corresponding points with one another.

impl From<ProperRotation> for ReferenceGroupPoint

fn from(x: ProperRotation) -> Self

Converts to this type from the input type.

impl From<ProperRotation> for ReferenceGroupPoint

fn from(x: ProperRotation) -> 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<ReferenceGroupPoint> for ProperRotation

fn from(corresponding_point: ReferenceGroupPoint) -> Self

Converts to this type from the input type.

impl From<ReferenceGroupPoint> for ProperRotation

fn from(corresponding_point: ReferenceGroupPoint) -> Self

Converts to this type from the input type.

impl Mul<ImproperRotation> for ProperRotation

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 = ImproperRotation

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

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

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

impl Mul<OppositeGroupPoint> for ProperRotation

type Output = OppositeGroupPoint

Output belongs to the same Geometric Group.

fn mul(self, x: OppositeGroupPoint) -> Self::Output

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

impl Mul<OppositeGroupPoint> for ProperRotation

Rotates a copy the argument in a way that maintains its Geometric Group.

type Output = OppositeGroupPoint

Same Geometric Group, so same data-type.

fn mul(self, x: OppositeGroupPoint) -> Self::Output

Performs the * operation.

impl Mul<ProperRotation> for CubeSurfacePoint

Rotates a copy of self in a way that maintains its Geometric Group.

type Output = CubeSurfacePoint

The Geometric Group doesn’t change. Even if it did, this data-type is group-agnostic.

fn mul(self, rotation: ProperRotation) -> Self

Performs the * operation.

impl Mul<ProperRotation> for CubeSurfacePoint<false>

Rotates a copy of self according to a ProperRotation. Maintains Geometric Group.

type Output = CubeSurfacePoint<false>

The Geometric Group doesn’t change. Even if it did, this data-type is group-agnostic.

fn mul(self, x: ProperRotation) -> Self

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

impl Mul<ProperRotation> for CubeSurfacePoint<true>

Rotates a copy of self according to a ProperRotation. Maintains Geometric Group.

type Output = CubeSurfacePoint<true>

The Geometric Group doesn’t change. Even if it did, this data-type is group-agnostic.

fn mul(self, x: ProperRotation) -> Self

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

While this could have been implemented using smaller LUTs than the ones used for Mul<Rotation>, it was deemed a useless middle solution.

impl Mul<ProperRotation> for ImproperRotation

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 = ImproperRotation

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

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

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

impl Mul<ProperRotation> for OppositeGroupPoint

Rotates a copy of self according to a ProperRotation. Maintains Geometric Group.

type Output = OppositeGroupPoint

Output belongs to the same Geometric Group.

fn mul(self, x: ProperRotation) -> Self::Output

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

impl Mul<ProperRotation> for OppositeGroupPoint

Rotates a copy of self in a way that maintains its Geometric Group.

type Output = OppositeGroupPoint

Same Geometric Group, so same data-type.

fn mul(self, other: ProperRotation) -> OppositeGroupPoint

Multiplies one OppositeGroupPoint with one ProperRotation, producing one OppositeGroupPoint as a result. Useful for static confirmation of Geometric Groups.

impl Mul<ProperRotation> for ReferenceGroupPoint

Rotates a copy of self according to a ProperRotation. Maintains Geometric Group.

type Output = ReferenceGroupPoint

Output belongs to the same Geometric Group.

fn mul(self, x: ProperRotation) -> Self::Output

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

impl Mul<ProperRotation> for ReferenceGroupPoint

Rotates a copy of self in a way that maintains its Geometric Group.

type Output = ReferenceGroupPoint

Same Geometric Group, so same data-type.

fn mul(self, other: ProperRotation) -> ReferenceGroupPoint

Multiplies one ReferenceGroupPoint with one ProperRotation, producing one ReferenceGroupPoint as a result. Useful for static confirmation of Geometric Groups.

impl Mul<ReferenceGroupPoint> for ProperRotation

type Output = ReferenceGroupPoint

Output belongs to the same Geometric Group.

fn mul(self, x: ReferenceGroupPoint) -> Self::Output

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

impl Mul<ReferenceGroupPoint> for ProperRotation

Rotates a copy the argument in a way that maintains its Geometric Group.

type Output = ReferenceGroupPoint

Same Geometric Group, so same data-type.

fn mul(self, x: ReferenceGroupPoint) -> Self::Output

Performs the * operation.

impl Mul for ProperRotation

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 = ProperRotation

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

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

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

impl MulAssign<ProperRotation> for CubeSurfacePoint

Rotates self in a way that maintains its Geometric Group.

fn mul_assign(&mut self, x: ProperRotation)

Neither the Geometric Group nor the data-type change, so the result can be directly assigned.

impl MulAssign<ProperRotation> for CubeSurfacePoint<false>

Rotates self according to a ProperRotation. Maintains Geometric Group.

fn mul_assign(&mut self, x: ProperRotation)

Neither the Geometric Group nor the data-type change, so the result can be directly assigned.

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

While this could have been implemented using smaller LUTs than the ones used for Mul<Rotation>, it was deemed a useless middle solution.

impl MulAssign<ProperRotation> for CubeSurfacePoint<true>

Rotates self according to a ProperRotation. Maintains Geometric Group.

fn mul_assign(&mut self, x: ProperRotation)

Neither the Geometric Group nor the data-type change, so the result can be directly assigned.

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

While this could have been implemented using smaller LUTs than the ones used for Mul<Rotation>, it was deemed a useless middle solution.

impl MulAssign<ProperRotation> for OppositeGroupPoint

Rotates self according to a ProperRotation. Maintains Geometric Group.

fn mul_assign(&mut self, x: ProperRotation)

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

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

impl MulAssign<ProperRotation> for OppositeGroupPoint

Rotates self in a way that maintains its Geometric Group.

fn mul_assign(&mut self, x: ProperRotation)

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

impl MulAssign<ProperRotation> for ReferenceGroupPoint

Rotates self according to a ProperRotation. Maintains Geometric Group.

fn mul_assign(&mut self, x: ProperRotation)

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

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

impl MulAssign<ProperRotation> for ReferenceGroupPoint

Rotates self in a way that maintains its Geometric Group.

fn mul_assign(&mut self, x: ProperRotation)

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

impl Ord for ProperRotation

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

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

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

impl Eq for ProperRotation

impl StructuralPartialEq for ProperRotation