Struct cgmath::Matrix2 [−] [src]

pub struct Matrix2<S> {
    pub x: Vector2<S>,
    pub y: Vector2<S>,
}

A 2 x 2, column major matrix

Fields

`x`
`y`

Methods

`impl<S> Matrix2<S>`

`fn new(c0r0: S, c0r1: S, c1r0: S, c1r1: S) -> Matrix2<S>`

Create a new matrix, providing values for each index.

`fn from_cols(c0: Vector2<S>, c1: Vector2<S>) -> Matrix2<S>`

Create a new matrix, providing columns.

`impl<S: BaseNum> Matrix2<S>`

`fn from_value(value: S) -> Matrix2<S>`

Create a new diagonal matrix, providing a single value to use for each non-zero index.

`fn zero() -> Matrix2<S>`

Create a zero matrix (all zeros).

`fn identity() -> Matrix2<S>`

Create an identity matrix (diagonal matrix of ones).

`impl<S: BaseFloat> Matrix2<S>`

`fn look_at(dir: &Vector2<S>, up: &Vector2<S>) -> Matrix2<S>`

Create a transformation matrix that will cause a vector to point at dir, using up for orientation.

`fn from_angle(theta: Rad<S>) -> Matrix2<S>`

`impl<S: Copy + Neg<Output=S>> Matrix2<S>`

`fn neg_self(&mut self)`

Negate this Matrix2 in-place.

Trait Implementations

`impl<S: BaseFloat> Add for Matrix2<S>`

`type Output = Matrix2<S>`

`fn add(self, other: Matrix2<S>) -> Matrix2<S>`

`impl<S: BaseFloat> Sub for Matrix2<S>`

`type Output = Matrix2<S>`

`fn sub(self, other: Matrix2<S>) -> Matrix2<S>`

`impl<S: Neg<Output=S>> Neg for Matrix2<S>`

`type Output = Matrix2<S>`

`fn neg(self) -> Matrix2<S>`

`impl<S: BaseFloat> Zero for Matrix2<S>`

`fn zero() -> Matrix2<S>`

`fn is_zero(&self) -> bool`

`impl<S: BaseFloat> Mul for Matrix2<S>`

`type Output = Matrix2<S>`

`fn mul(self, other: Matrix2<S>) -> Matrix2<S>`

`impl<S: BaseFloat> Mul<S> for Matrix2<S>`

`type Output = Matrix2<S>`

`fn mul(self, other: S) -> Matrix2<S>`

`impl<S: BaseFloat> One for Matrix2<S>`

`fn one() -> Matrix2<S>`

`impl<S> FixedArray<[[S; 2]; 2]> for Matrix2<S>`

`fn into_fixed(self) -> [[S; 2]; 2]`

`fn as_fixed<'a>(&'a self) -> &'a [[S; 2]; 2]`

`fn as_mut_fixed<'a>(&'a mut self) -> &'a mut [[S; 2]; 2]`

`fn from_fixed(_v: [[S; 2]; 2]) -> Matrix2<S>`

`fn from_fixed_ref<'a>(v: &'a [[S; 2]; 2]) -> &'a Matrix2<S>`

`fn from_fixed_mut<'a>(v: &'a mut [[S; 2]; 2]) -> &'a mut Matrix2<S>`

`impl<S> Index<usize> for Matrix2<S>`

`type Output = Vector2<S>`

`fn index<'a>(&'a self, i: usize) -> &'a Vector2<S>`

`impl<S> IndexMut<usize> for Matrix2<S>`

`fn index_mut<'a>(&'a mut self, i: usize) -> &'a mut Vector2<S>`

`impl<S: Copy + 'static> Array2<Vector2<S>, Vector2<S>, S> for Matrix2<S>`

`fn row(&self, r: usize) -> Vector2<S>`

`fn swap_rows(&mut self, a: usize, b: usize)`

`fn map<F>(&mut self, op: F) -> Matrix2<S> where F: FnMut(&Vector2<S>) -> Vector2<S>`

`fn ptr<'a>(&'a self) -> &'a Element`

`fn mut_ptr<'a>(&'a mut self) -> &'a mut Element`

`fn swap_cols(&mut self, a: usize, b: usize)`

`fn replace_col(&mut self, c: usize, src: Column) -> Column`

`fn swap_elems(&mut self, a: (usize, usize), b: (usize, usize))`

`impl<S: BaseFloat> Matrix<S, Vector2<S>> for Matrix2<S>`

`fn mul_s(&self, s: S) -> Matrix2<S>`

`fn div_s(&self, s: S) -> Matrix2<S>`

`fn rem_s(&self, s: S) -> Matrix2<S>`

`fn add_m(&self, m: &Matrix2<S>) -> Matrix2<S>`

`fn sub_m(&self, m: &Matrix2<S>) -> Matrix2<S>`

`fn mul_v(&self, v: &Vector2<S>) -> Vector2<S>`

`fn mul_m(&self, other: &Matrix2<S>) -> Matrix2<S>`

`fn mul_self_s(&mut self, s: S)`

`fn div_self_s(&mut self, s: S)`

`fn rem_self_s(&mut self, s: S)`

`fn add_self_m(&mut self, m: &Matrix2<S>)`

`fn sub_self_m(&mut self, m: &Matrix2<S>)`

`fn transpose(&self) -> Matrix2<S>`

`fn transpose_self(&mut self)`

`fn determinant(&self) -> S`

`fn diagonal(&self) -> Vector2<S>`

`fn invert(&self) -> Option<Matrix2<S>>`

`fn is_diagonal(&self) -> bool`

`fn is_symmetric(&self) -> bool`

`fn mul_self_m(&mut self, m: &Self)`

`fn trace(&self) -> S`

`fn invert_self(&mut self)`

`fn is_invertible(&self) -> bool`

`fn is_identity(&self) -> bool`

`impl<S: BaseFloat> ApproxEq<S> for Matrix2<S>`

`fn approx_eq_eps(&self, other: &Matrix2<S>, epsilon: &S) -> bool`

`fn approx_epsilon(_hack: Option<Self>) -> T`

`fn approx_eq(&self, other: &Self) -> bool`

`impl<S: BaseNum> Debug for Matrix2<S>`

`fn fmt(&self, f: &mut Formatter) -> Result`

`impl<S: BaseFloat + Rand> Rand for Matrix2<S>`

`fn rand<R: Rng>(rng: &mut R) -> Matrix2<S>`

`impl<S: BaseFloat> From<Basis2<S>> for Matrix2<S>`

`fn from(b: Basis2<S>) -> Matrix2<S>`

Derived Implementations

`impl<S: Decodable> Decodable for Matrix2<S>`

`fn decode<D: Decoder>(arg_0: &mut D) -> Result<Matrix2<S>, D::Error>`

`impl<S: Encodable> Encodable for Matrix2<S>`

`fn encode<S: Encoder>(&self, arg_0: &mut S) -> Result<(), S::Error>`

`impl<S: PartialEq> PartialEq for Matrix2<S>`

`fn eq(&self, __arg_0: &Matrix2<S>) -> bool`

`fn ne(&self, __arg_0: &Matrix2<S>) -> bool`

`impl<S: Clone> Clone for Matrix2<S>`

`fn clone(&self) -> Matrix2<S>`

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

`impl<S: Copy> Copy for Matrix2<S>`