# [−][src]Struct cgmath::Basis2

    pub struct Basis2<S> { /* fields omitted */ }

A two-dimensional rotation matrix.

The matrix is guaranteed to be orthogonal, so some operations can be implemented more efficiently than the implementations for `math::Matrix2`. To enforce orthogonality at the type level the operations have been restricted to a subset of those implemented on `Matrix2`.

## Example

Suppose we want to rotate a vector that lies in the x-y plane by some angle. We can accomplish this quite easily with a two-dimensional rotation matrix:

    use cgmath::Rad;
    use cgmath::Vector2;
    use cgmath::{Matrix, Matrix2};
    use cgmath::{Rotation, Rotation2, Basis2};
    use cgmath::UlpsEq;
    use std::f64;

    // For simplicity, we will rotate the unit x vector to the unit y vector --
    // so the angle is 90 degrees, or π/2.
    let unit_x: Vector2<f64> = Vector2::unit_x();
    let rot: Basis2<f64> = Rotation2::from_angle(Rad(0.5f64 * f64::consts::PI));

    // Rotate the vector using the two-dimensional rotation matrix:
    let unit_y = rot.rotate_vector(unit_x);

    // Since sin(π/2) may not be exactly zero due to rounding errors, we can
    // use approx's assert_ulps_eq!() feature to show that it is close enough.
    // assert_ulps_eq!(&unit_y, &Vector2::unit_y()); // TODO: Figure out how to use this

    // This is exactly equivalent to using the raw matrix itself:
    let unit_y2: Matrix2<_> = rot.into();
    let unit_y2 = unit_y2 * unit_x;
    assert_eq!(unit_y2, unit_y);

    // Note that we can also concatenate rotations:
    let rot_half: Basis2<f64> = Rotation2::from_angle(Rad(0.25f64 * f64::consts::PI));
    let unit_y3 = (rot_half * rot_half).rotate_vector(unit_x);
    // assert_ulps_eq!(&unit_y3, &unit_y2); // TODO: Figure out how to use this

## Trait Implementations

### `impl<S: BaseFloat> Rotation<Point2<S>> for Basis2<S>`[src]

#### `fn look_at(dir: Vector2<S>, up: Vector2<S>) -> Basis2<S>`[src]

Create a rotation to a given direction with an 'up' vector.

#### `fn between_vectors(a: Vector2<S>, b: Vector2<S>) -> Basis2<S>`[src]

Create a shortest rotation to transform vector 'a' into 'b'. Both given vectors are assumed to have unit length. Read more

#### `fn rotate_vector(&self, vec: Vector2<S>) -> Vector2<S>`[src]

Rotate a vector using this rotation.

#### `fn invert(&self) -> Basis2<S>`[src]

Create a new rotation which "un-does" this rotation. That is, `r * r.invert()` is the identity. Read more

#### `fn rotate_point(&self, point: P) -> P`[src]

Rotate a point using this rotation, by converting it to its representation as a vector. Read more

### `impl<S: BaseFloat> Rotation2<S> for Basis2<S>`[src]

#### `fn from_angle<A: Into<Rad<S>>>(theta: A) -> Basis2<S>`[src]

Create a rotation by a given angle. Thus is a redundant case of both from_axis_angle() and from_euler() for 2D space. Read more

### `impl<S: Clone> Clone for Basis2<S>`[src]

#### `fn clone(&self) -> Basis2<S>`[src]

Returns a copy of the value. Read more

#### `fn clone_from(&mut self, source: &Self)`1.0.0[src]

Performs copy-assignment from `source`. Read more

### `impl<S: BaseFloat> AsRef<Matrix2<S>> for Basis2<S>`[src]

#### `fn as_ref(&self) -> &Matrix2<S>`[src]

Performs the conversion.

### `impl<S: PartialEq> PartialEq<Basis2<S>> for Basis2<S>`[src]

#### `fn eq(&self, other: &Basis2<S>) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `fn ne(&self, other: &Basis2<S>) -> bool`[src]

This method tests for `!=`.

### `impl<S: BaseFloat> From<Basis2<S>> for Matrix2<S>`[src]

#### `fn from(b: Basis2<S>) -> Matrix2<S>`[src]

Performs the conversion.

### `impl<S: Copy> Copy for Basis2<S>`[src]

### `impl<S: BaseFloat> Mul<Basis2<S>> for Basis2<S>`[src]

#### `type Output = Basis2<S>`

The resulting type after applying the `*` operator.

#### `fn mul(self, other: Basis2<S>) -> Basis2<S>`[src]

Performs the `*` operation.

### `impl<'a, S: BaseFloat> Mul<&'a Basis2<S>> for Basis2<S>`[src]

#### `type Output = Basis2<S>`

The resulting type after applying the `*` operator.

#### `fn mul(self, other: &'a Basis2<S>) -> Basis2<S>`[src]

Performs the `*` operation.

### `impl<'a, S: BaseFloat> Mul<Basis2<S>> for &'a Basis2<S>`[src]

#### `type Output = Basis2<S>`

The resulting type after applying the `*` operator.

#### `fn mul(self, other: Basis2<S>) -> Basis2<S>`[src]

Performs the `*` operation.

### `impl<'a, 'b, S: BaseFloat> Mul<&'a Basis2<S>> for &'b Basis2<S>`[src]

#### `type Output = Basis2<S>`

The resulting type after applying the `*` operator.

#### `fn mul(self, other: &'a Basis2<S>) -> Basis2<S>`[src]

Performs the `*` operation.

### `impl<S: Debug> Debug for Basis2<S>`[src]

#### `fn fmt(&self, f: &mut Formatter) -> Result`[src]

Formats the value using the given formatter. Read more

### `impl<S: BaseFloat> Product<Basis2<S>> for Basis2<S>`[src]

#### `fn product<I: Iterator<Item = Basis2<S>>>(iter: I) -> Basis2<S>`[src]

Method which takes an iterator and generates `Self` from the elements by multiplying the items. Read more

### `impl<'a, S: 'a + BaseFloat> Product<&'a Basis2<S>> for Basis2<S>`[src]

#### `fn product<I: Iterator<Item = &'a Basis2<S>>>(iter: I) -> Basis2<S>`[src]

Method which takes an iterator and generates `Self` from the elements by multiplying the items. Read more

### `impl<S: BaseFloat> AbsDiffEq<Basis2<S>> for Basis2<S>`[src]

#### `type Epsilon = S::Epsilon`

Used for specifying relative comparisons.

#### `fn default_epsilon() -> S::Epsilon`[src]

The default tolerance to use when testing values that are close together. Read more

#### `fn abs_diff_eq(&self, other: &Self, epsilon: S::Epsilon) -> bool`[src]

A test for equality that uses the absolute difference to compute the approximate equality of two numbers. Read more

#### `fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool`[src]

The inverse of `ApproxEq::abs_diff_eq`.

### `impl<S: BaseFloat> RelativeEq<Basis2<S>> for Basis2<S>`[src]

#### `fn default_max_relative() -> S::Epsilon`[src]

The default relative tolerance for testing values that are far-apart. Read more

#### `fn relative_eq(
&self,
other: &Self,
epsilon: S::Epsilon,
max_relative: S::Epsilon
) -> bool`[src]

A test for equality that uses a relative comparison if the values are far apart.

#### `fn relative_ne(
&self,
other: &Rhs,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool`[src]

The inverse of `ApproxEq::relative_eq`.

### `impl<S: BaseFloat> UlpsEq<Basis2<S>> for Basis2<S>`[src]

#### `fn default_max_ulps() -> u32`[src]

The default ULPs to tolerate when testing values that are far-apart. Read more

#### `fn ulps_eq(&self, other: &Self, epsilon: S::Epsilon, max_ulps: u32) -> bool`[src]

A test for equality that uses units in the last place (ULP) if the values are far apart.

#### `fn ulps_ne(&self, other: &Rhs, epsilon: Self::Epsilon, max_ulps: u32) -> bool`[src]

The inverse of `ApproxEq::ulps_eq`.

### `impl<S: BaseFloat> One for Basis2<S>`[src]

#### `fn one() -> Basis2<S>`[src]

Returns the multiplicative identity element of `Self`, `1`. Read more

#### `fn set_one(&mut self)`[src]

Sets `self` to the multiplicative identity element of `Self`, `1`.

#### `fn is_one(&self) -> bool where
Self: PartialEq<Self>,` [src]

Returns `true` if `self` is equal to the multiplicative identity. Read more

## Auto Trait Implementations

### `impl<S> Send for Basis2<S> where
S: Send,`

### `impl<S> Unpin for Basis2<S> where
S: Unpin,`

### `impl<S> Sync for Basis2<S> where
S: Sync,`

### `impl<S> UnwindSafe for Basis2<S> where
S: UnwindSafe,`

### `impl<S> RefUnwindSafe for Basis2<S> where
S: RefUnwindSafe,`

## Blanket Implementations

### `impl<T> ToOwned for T where
T: Clone,` [src]

#### `type Owned = T`

The resulting type after obtaining ownership.

#### `fn to_owned(&self) -> T`[src]

Creates owned data from borrowed data, usually by cloning. Read more

#### `fn clone_into(&self, target: &mut T)`[src]

🔬 This is a nightly-only experimental API. (`toowned_clone_into`)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `fn into(self) -> U`[src]

Performs the conversion.

### `impl<T> From<T> for T`[src]

#### `fn from(t: T) -> T`[src]

Performs the conversion.

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`[src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`[src]

Performs the conversion.

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `fn borrow_mut(&mut self) -> &mut T`[src]

Mutably borrows from an owned value. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `fn borrow(&self) -> &T`[src]

Immutably borrows from an owned value. Read more

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `fn type_id(&self) -> TypeId`[src]

Gets the `TypeId` of `self`. Read more

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)