Struct ImproperRotation

pub struct ImproperRotation { /* private fields */ }

As per a Rotation, but one that specifically needs at least one reflection.

Trait Implementations

impl Clone for ImproperRotation

fn clone(&self) -> ImproperRotation

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ImproperRotation

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

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 From<ImproperRotation> for OppositeGroupPoint

fn from(x: ImproperRotation) -> Self

Converts to this type from the input type.

impl From<ImproperRotation> for OppositeGroupPoint

fn from(x: ImproperRotation) -> 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<OppositeGroupPoint> for ImproperRotation

fn from(corresponding_point: OppositeGroupPoint) -> Self

Converts to this type from the input type.

impl From<OppositeGroupPoint> for ImproperRotation

fn from(corresponding_point: OppositeGroupPoint) -> Self

Converts to this type from the input type.

impl Mul<ImproperRotation> for CubeSurfacePoint

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

type Output = CubeSurfacePoint

Although the Geometric Group does change, CubeSurfacePoint does not change its data-type depending on Geometric Group. Thus the data-type remains the same.

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

Performs the * operation.

impl Mul<ImproperRotation> for CubeSurfacePoint<false>

Rotates a copy of self according to an ImproperRotation. Switches Geometric Group.

type Output = CubeSurfacePoint<false>

Although the Geometric Group does change, CubeSurfacePoint does not change its data-type depending on Geometric Group. Thus the data-type remains the same.

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

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

impl Mul<ImproperRotation> for CubeSurfacePoint<true>

Rotates a copy of self according to an ImproperRotation. Switches Geometric Group.

type Output = CubeSurfacePoint<true>

Although the Geometric Group does change, CubeSurfacePoint does not change its data-type depending on Geometric Group. Thus the data-type remains the same.

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

The ImproperRotation 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<ImproperRotation> for OppositeGroupPoint

Rotates a copy of self according to an ImproperRotation. Switches Geometric Group.

type Output = ReferenceGroupPoint

Output belongs to the other Geometric Group.

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

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

impl Mul<ImproperRotation> for OppositeGroupPoint

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

type Output = ReferenceGroupPoint

Output belongs to the other Geometric Group.

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

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

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<ImproperRotation> for ReferenceGroupPoint

Rotates a copy of self according to an ImproperRotation. Switches Geometric Group.

type Output = OppositeGroupPoint

Output belongs to the other Geometric Group.

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

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

impl Mul<ImproperRotation> for ReferenceGroupPoint

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

type Output = OppositeGroupPoint

Output belongs to the other Geometric Group.

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

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

impl Mul<OppositeGroupPoint> for ImproperRotation

type Output = ReferenceGroupPoint

Output belongs to the other Geometric Group.

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

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

impl Mul<OppositeGroupPoint> for ImproperRotation

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

type Output = ReferenceGroupPoint

Output belongs to the other Geometric Group.

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

Performs the * operation.

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<ReferenceGroupPoint> for ImproperRotation

type Output = OppositeGroupPoint

Output belongs to the other Geometric Group.

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

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

impl Mul<ReferenceGroupPoint> for ImproperRotation

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

type Output = OppositeGroupPoint

Output belongs to the other Geometric Group.

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

Performs the * operation.

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

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 MulAssign<ImproperRotation> for CubeSurfacePoint

Rotates self in a way that switches its Geometric Group.

fn mul_assign(&mut self, x: ImproperRotation)

The data-type remains the same, despite the Geometric Group changing. Thus, the result can be directly assigned.

impl MulAssign<ImproperRotation> for CubeSurfacePoint<false>

Rotates self according to a ImproperRotation. Switches Geometric Group.

fn mul_assign(&mut self, x: ImproperRotation)

The data-type remains the same, despite the Geometric Group changing. Thus, the result can be directly assigned.

The ImproperRotation 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<ImproperRotation> for CubeSurfacePoint<true>

Rotates self according to an ImproperRotation. Switches Geometric Group.

fn mul_assign(&mut self, x: ImproperRotation)

The data-type remains the same, despite the Geometric Group changing. Thus, the result can be directly assigned.

The ImproperRotation 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 Ord for ImproperRotation

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

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

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

impl Eq for ImproperRotation

impl StructuralPartialEq for ImproperRotation