M-Labs
/
nalgebra
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Replace the double dispatch trick by multidispatch! 

Fix #38.
This commit is contained in:
Sébastien Crozet 2014-11-26 14:17:34 +01:00
parent 3317e057f5
commit d296bebfac
18 changed files with 687 additions and 2168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
src/lib.rs
View File

@ -193,41 +193,6 @@ mod macros;
// mod lower_triangular; // mod lower_triangular;
// mod chol; // mod chol;
/*
* Reexport everything.
*/
/// Traits to work around the language limitations related to operator overloading.
///
/// The trait names are formed by:
///
/// * a type name (eg. Vec1, Vec2, Mat3, Mat4, etc.).
/// * the name of a binary operation (eg. Mul, Div, Add, Sub, etc.).
/// * the word `Rhs`.
///
/// When implemented by the type `T`, the trait makes it possible to overload the binary operator
/// between `T` and the type name given by the trait.
///
/// # Examples:
///
/// * `Vec3MulRhs` will allow the overload of the `*` operator between the implementor type and
/// `Vec3`. The `Vec3` being the first argument of the multiplication.
/// * `Mat4DivRhs` will allow the overload of the `/` operator between the implementor type and
/// `Mat4`. The `Mat4` being the first argument of the division.
pub mod overload {
pub use structs::{Vec1MulRhs, Vec2MulRhs, Vec3MulRhs, Vec4MulRhs, Vec5MulRhs, Vec6MulRhs,
Vec1DivRhs, Vec2DivRhs, Vec3DivRhs, Vec4DivRhs, Vec5DivRhs, Vec6DivRhs,
Vec1AddRhs, Vec2AddRhs, Vec3AddRhs, Vec4AddRhs, Vec5AddRhs, Vec6AddRhs,
Vec1SubRhs, Vec2SubRhs, Vec3SubRhs, Vec4SubRhs, Vec5SubRhs, Vec6SubRhs,
Pnt1MulRhs, Pnt2MulRhs, Pnt3MulRhs, Pnt4MulRhs, Pnt5MulRhs, Pnt6MulRhs,
Pnt1DivRhs, Pnt2DivRhs, Pnt3DivRhs, Pnt4DivRhs, Pnt5DivRhs, Pnt6DivRhs,
Pnt1AddRhs, Pnt2AddRhs, Pnt3AddRhs, Pnt4AddRhs, Pnt5AddRhs, Pnt6AddRhs,
Pnt1SubRhs, Pnt2SubRhs, Pnt3SubRhs, Pnt4SubRhs, Pnt5SubRhs, Pnt6SubRhs,
Mat1MulRhs, Mat2MulRhs, Mat3MulRhs, Mat4MulRhs, Mat5MulRhs, Mat6MulRhs,
Mat1DivRhs, Mat2DivRhs, Mat3DivRhs, Mat4DivRhs, Mat5DivRhs, Mat6DivRhs,
Mat1AddRhs, Mat2AddRhs, Mat3AddRhs, Mat4AddRhs, Mat5AddRhs, Mat6AddRhs,
Mat1SubRhs, Mat2SubRhs, Mat3SubRhs, Mat4SubRhs, Mat5SubRhs, Mat6SubRhs};
}
/// Change the input value to ensure it is on the range `[min, max]`. /// Change the input value to ensure it is on the range `[min, max]`.
#[inline(always)] #[inline(always)]
pub fn clamp<T: PartialOrd>(val: T, min: T, max: T) -> T { pub fn clamp<T: PartialOrd>(val: T, min: T, max: T) -> T {

160
src/structs/dmat.rs
View File

@ -7,7 +7,7 @@ use std::rand::Rand;
use std::rand; use std::rand;
use traits::operations::ApproxEq; use traits::operations::ApproxEq;
use std::mem; use std::mem;
use structs::dvec::{DVec, DVecMulRhs}; use structs::dvec::DVec;
use traits::operations::{Inv, Transpose, Mean, Cov}; use traits::operations::{Inv, Transpose, Mean, Cov};
use traits::structure::{Cast, ColSlice, RowSlice, Diag, Eye, Indexable, Shape, Zero, One, BaseNum}; use traits::structure::{Cast, ColSlice, RowSlice, Diag, Eye, Indexable, Shape, Zero, One, BaseNum};
use std::fmt::{Show, Formatter, Result}; use std::fmt::{Show, Formatter, Result};
@ -21,16 +21,6 @@ pub struct DMat<N> {
mij: Vec<N> mij: Vec<N>
} }
double_dispatch_binop_decl_trait!(DMat, DMatMulRhs)
double_dispatch_binop_decl_trait!(DMat, DMatDivRhs)
double_dispatch_binop_decl_trait!(DMat, DMatAddRhs)
double_dispatch_binop_decl_trait!(DMat, DMatSubRhs)
mul_redispatch_impl!(DMat, DMatMulRhs)
div_redispatch_impl!(DMat, DMatDivRhs)
add_redispatch_impl!(DMat, DMatAddRhs)
sub_redispatch_impl!(DMat, DMatSubRhs)
impl<N> DMat<N> { impl<N> DMat<N> {
/// Creates an uninitialized matrix. /// Creates an uninitialized matrix.
#[inline] #[inline]
@ -293,20 +283,20 @@ impl<N> IndexMut<(uint, uint), N> for DMat<N> {
} }
} }
impl<N: Clone + Mul<N, N> + Add<N, N> + Zero> DMatMulRhs<N, DMat<N>> for DMat<N> { impl<N: Clone + Mul<N, N> + Add<N, N> + Zero> Mul<DMat<N>, DMat<N>> for DMat<N> {
fn binop(left: &DMat<N>, right: &DMat<N>) -> DMat<N> { fn mul(&self, right: &DMat<N>) -> DMat<N> {
assert!(left.ncols == right.nrows); assert!(self.ncols == right.nrows);
let mut res = unsafe { DMat::new_uninitialized(left.nrows, right.ncols) }; let mut res = unsafe { DMat::new_uninitialized(self.nrows, right.ncols) };
for i in range(0u, left.nrows) { for i in range(0u, self.nrows) {
for j in range(0u, right.ncols) { for j in range(0u, right.ncols) {
let mut acc: N = ::zero(); let mut acc: N = ::zero();
unsafe { unsafe {
for k in range(0u, left.ncols) { for k in range(0u, self.ncols) {
acc = acc acc = acc
+ left.unsafe_at((i, k)) * right.unsafe_at((k, j)); + self.unsafe_at((i, k)) * right.unsafe_at((k, j));
} }
res.unsafe_set((i, j), acc); res.unsafe_set((i, j), acc);
@ -318,19 +308,18 @@ impl<N: Clone + Mul<N, N> + Add<N, N> + Zero> DMatMulRhs<N, DMat<N>> for DMat<N>
} }
} }
impl<N: Clone + Add<N, N> + Mul<N, N> + Zero> impl<N: Clone + Add<N, N> + Mul<N, N> + Zero> Mul<DVec<N>, DVec<N>> for DMat<N> {
DMatMulRhs<N, DVec<N>> for DVec<N> { fn mul(&self, right: &DVec<N>) -> DVec<N> {
fn binop(left: &DMat<N>, right: &DVec<N>) -> DVec<N> { assert!(self.ncols == right.at.len());
assert!(left.ncols == right.at.len());
let mut res : DVec<N> = unsafe { DVec::new_uninitialized(left.nrows) }; let mut res : DVec<N> = unsafe { DVec::new_uninitialized(self.nrows) };
for i in range(0u, left.nrows) { for i in range(0u, self.nrows) {
let mut acc: N = ::zero(); let mut acc: N = ::zero();
for j in range(0u, left.ncols) { for j in range(0u, self.ncols) {
unsafe { unsafe {
acc = acc + left.unsafe_at((i, j)) * right.unsafe_at(j); acc = acc + self.unsafe_at((i, j)) * right.unsafe_at(j);
} }
} }
@ -342,10 +331,9 @@ DMatMulRhs<N, DVec<N>> for DVec<N> {
} }
impl<N: Clone + Add<N, N> + Mul<N, N> + Zero> impl<N: Clone + Add<N, N> + Mul<N, N> + Zero> Mul<DMat<N>, DVec<N>> for DVec<N> {
DVecMulRhs<N, DVec<N>> for DMat<N> { fn mul(&self, right: &DMat<N>) -> DVec<N> {
fn binop(left: &DVec<N>, right: &DMat<N>) -> DVec<N> { assert!(right.nrows == self.at.len());
assert!(right.nrows == left.at.len());
let mut res : DVec<N> = unsafe { DVec::new_uninitialized(right.ncols) }; let mut res : DVec<N> = unsafe { DVec::new_uninitialized(right.ncols) };
@ -354,7 +342,7 @@ DVecMulRhs<N, DVec<N>> for DMat<N> {
for j in range(0u, right.nrows) { for j in range(0u, right.nrows) {
unsafe { unsafe {
acc = acc + left.unsafe_at(j) * right.unsafe_at((j, i)); acc = acc + self.unsafe_at(j) * right.unsafe_at((j, i));
} }
} }
@ -516,7 +504,7 @@ impl<N: BaseNum + Cast<f64> + Zero + Clone> Mean<DVec<N>> for DMat<N> {
} }
} }
impl<N: Clone + BaseNum + Cast<f64> + DMatDivRhs<N, DMat<N>>> Cov<DMat<N>> for DMat<N> { impl<N: Clone + BaseNum + Cast<f64> + Div<N, N>> Cov<DMat<N>> for DMat<N> {
// FIXME: this could be heavily optimized, removing all temporaries by merging loops. // FIXME: this could be heavily optimized, removing all temporaries by merging loops.
fn cov(m: &DMat<N>) -> DMat<N> { fn cov(m: &DMat<N>) -> DMat<N> {
assert!(m.nrows > 1); assert!(m.nrows > 1);
@ -642,114 +630,46 @@ impl<N: Show + Clone> Show for DMat<N> {
} }
} }
macro_rules! scalar_mul_impl ( impl<N: Mul<N, N>> Mul<N, DMat<N>> for DMat<N> {
($n: ident) => (
impl DMatMulRhs<$n, DMat<$n>> for $n {
#[inline] #[inline]
fn binop(left: &DMat<$n>, right: &$n) -> DMat<$n> { fn mul(&self, right: &N) -> DMat<N> {
DMat { DMat {
nrows: left.nrows, nrows: self.nrows,
ncols: left.ncols, ncols: self.ncols,
mij: left.mij.iter().map(|a| *a * *right).collect() mij: self.mij.iter().map(|a| *a * *right).collect()
} }
} }
} }
)
)
macro_rules! scalar_div_impl ( impl<N: Div<N, N>> Div<N, DMat<N>> for DMat<N> {
($n: ident) => (
impl DMatDivRhs<$n, DMat<$n>> for $n {
#[inline] #[inline]
fn binop(left: &DMat<$n>, right: &$n) -> DMat<$n> { fn div(&self, right: &N) -> DMat<N> {
DMat { DMat {
nrows: left.nrows, nrows: self.nrows,
ncols: left.ncols, ncols: self.ncols,
mij: left.mij.iter().map(|a| *a / *right).collect() mij: self.mij.iter().map(|a| *a / *right).collect()
} }
} }
} }
)
)
macro_rules! scalar_add_impl ( impl<N: Add<N, N>> Add<N, DMat<N>> for DMat<N> {
($n: ident) => (
impl DMatAddRhs<$n, DMat<$n>> for $n {
#[inline] #[inline]
fn binop(left: &DMat<$n>, right: &$n) -> DMat<$n> { fn add(&self, right: &N) -> DMat<N> {
DMat { DMat {
nrows: left.nrows, nrows: self.nrows,
ncols: left.ncols, ncols: self.ncols,
mij: left.mij.iter().map(|a| *a + *right).collect() mij: self.mij.iter().map(|a| *a + *right).collect()
} }
} }
} }
)
)
macro_rules! scalar_sub_impl ( impl<N: Sub<N, N>> Sub<N, DMat<N>> for DMat<N> {
($n: ident) => (
impl DMatSubRhs<$n, DMat<$n>> for $n {
#[inline] #[inline]
fn binop(left: &DMat<$n>, right: &$n) -> DMat<$n> { fn sub(&self, right: &N) -> DMat<N> {
DMat { DMat {
nrows: left.nrows, nrows: self.nrows,
ncols: left.ncols, ncols: self.ncols,
mij: left.mij.iter().map(|a| *a - *right).collect() mij: self.mij.iter().map(|a| *a - *right).collect()
} }
} }
} }
)
)
scalar_mul_impl!(f64)
scalar_mul_impl!(f32)
scalar_mul_impl!(u64)
scalar_mul_impl!(u32)
scalar_mul_impl!(u16)
scalar_mul_impl!(u8)
scalar_mul_impl!(i64)
scalar_mul_impl!(i32)
scalar_mul_impl!(i16)
scalar_mul_impl!(i8)
scalar_mul_impl!(uint)
scalar_mul_impl!(int)
scalar_div_impl!(f64)
scalar_div_impl!(f32)
scalar_div_impl!(u64)
scalar_div_impl!(u32)
scalar_div_impl!(u16)
scalar_div_impl!(u8)
scalar_div_impl!(i64)
scalar_div_impl!(i32)
scalar_div_impl!(i16)
scalar_div_impl!(i8)
scalar_div_impl!(uint)
scalar_div_impl!(int)
scalar_add_impl!(f64)
scalar_add_impl!(f32)
scalar_add_impl!(u64)
scalar_add_impl!(u32)
scalar_add_impl!(u16)
scalar_add_impl!(u8)
scalar_add_impl!(i64)
scalar_add_impl!(i32)
scalar_add_impl!(i16)
scalar_add_impl!(i8)
scalar_add_impl!(uint)
scalar_add_impl!(int)
scalar_sub_impl!(f64)
scalar_sub_impl!(f32)
scalar_sub_impl!(u64)
scalar_sub_impl!(u32)
scalar_sub_impl!(u16)
scalar_sub_impl!(u8)
scalar_sub_impl!(i64)
scalar_sub_impl!(i32)
scalar_sub_impl!(i16)
scalar_sub_impl!(i8)
scalar_sub_impl!(uint)
scalar_sub_impl!(int)

14
src/structs/dvec.rs
View File

@ -77,7 +77,7 @@ impl<N> FromIterator<N> for DVec<N> {
} }
dvec_impl!(DVec, DVecMulRhs, DVecDivRhs, DVecAddRhs, DVecSubRhs) dvec_impl!(DVec)
/// Stack-allocated, dynamically sized vector with a maximum size of 1. /// Stack-allocated, dynamically sized vector with a maximum size of 1.
pub struct DVec1<N> { pub struct DVec1<N> {
@ -85,7 +85,7 @@ pub struct DVec1<N> {
dim: uint dim: uint
} }
small_dvec_impl!(DVec1, 1, DVec1MulRhs, DVec1DivRhs, DVec1AddRhs, DVec1SubRhs, 0) small_dvec_impl!(DVec1, 1, 0)
small_dvec_from_impl!(DVec1, 1, ::zero()) small_dvec_from_impl!(DVec1, 1, ::zero())
@ -95,7 +95,7 @@ pub struct DVec2<N> {
dim: uint dim: uint
} }
small_dvec_impl!(DVec2, 2, DVec2MulRhs, DVec2DivRhs, DVec2AddRhs, DVec2SubRhs, 0, 1) small_dvec_impl!(DVec2, 2, 0, 1)
small_dvec_from_impl!(DVec2, 2, ::zero(), ::zero()) small_dvec_from_impl!(DVec2, 2, ::zero(), ::zero())
@ -105,7 +105,7 @@ pub struct DVec3<N> {
dim: uint dim: uint
} }
small_dvec_impl!(DVec3, 3, DVec3MulRhs, DVec3DivRhs, DVec3AddRhs, DVec3SubRhs, 0, 1, 2) small_dvec_impl!(DVec3, 3, 0, 1, 2)
small_dvec_from_impl!(DVec3, 3, ::zero(), ::zero(), ::zero()) small_dvec_from_impl!(DVec3, 3, ::zero(), ::zero(), ::zero())
@ -115,7 +115,7 @@ pub struct DVec4<N> {
dim: uint dim: uint
} }
small_dvec_impl!(DVec4, 4, DVec4MulRhs, DVec4DivRhs, DVec4AddRhs, DVec4SubRhs, 0, 1, 2, 3) small_dvec_impl!(DVec4, 4, 0, 1, 2, 3)
small_dvec_from_impl!(DVec4, 4, ::zero(), ::zero(), ::zero(), ::zero()) small_dvec_from_impl!(DVec4, 4, ::zero(), ::zero(), ::zero(), ::zero())
@ -125,7 +125,7 @@ pub struct DVec5<N> {
dim: uint dim: uint
} }
small_dvec_impl!(DVec5, 5, DVec5MulRhs, DVec5DivRhs, DVec5AddRhs, DVec5SubRhs, 0, 1, 2, 3, 4) small_dvec_impl!(DVec5, 5, 0, 1, 2, 3, 4)
small_dvec_from_impl!(DVec5, 5, ::zero(), ::zero(), ::zero(), ::zero(), ::zero()) small_dvec_from_impl!(DVec5, 5, ::zero(), ::zero(), ::zero(), ::zero(), ::zero())
@ -135,5 +135,5 @@ pub struct DVec6<N> {
dim: uint dim: uint
} }
small_dvec_impl!(DVec6, 6, DVec6MulRhs, DVec6DivRhs, DVec6AddRhs, DVec6SubRhs, 0, 1, 2, 3, 4, 5) small_dvec_impl!(DVec6, 6, 0, 1, 2, 3, 4, 5)
small_dvec_from_impl!(DVec6, 6, ::zero(), ::zero(), ::zero(), ::zero(), ::zero(), ::zero()) small_dvec_from_impl!(DVec6, 6, ::zero(), ::zero(), ::zero(), ::zero(), ::zero(), ::zero())

142
src/structs/dvec_macros.rs
View File

@ -1,17 +1,7 @@
#![macro_escape] #![macro_escape]
macro_rules! dvec_impl( macro_rules! dvec_impl(
($dvec: ident, $mul: ident, $div: ident, $add: ident, $sub: ident) => ( ($dvec: ident) => (
double_dispatch_binop_decl_trait!($dvec, $mul)
double_dispatch_binop_decl_trait!($dvec, $div)
double_dispatch_binop_decl_trait!($dvec, $add)
double_dispatch_binop_decl_trait!($dvec, $sub)
mul_redispatch_impl!($dvec, $mul)
div_redispatch_impl!($dvec, $div)
add_redispatch_impl!($dvec, $add)
sub_redispatch_impl!($dvec, $sub)
impl<N: Zero + Clone> $dvec<N> { impl<N: Zero + Clone> $dvec<N> {
/// Builds a vector filled with zeros. /// Builds a vector filled with zeros.
/// ///
@ -132,7 +122,7 @@ macro_rules! dvec_impl(
} }
} }
impl<N: Clone + BaseFloat + ApproxEq<N> + $mul<N, $dvec<N>>> $dvec<N> { impl<N: Clone + BaseFloat + ApproxEq<N>> $dvec<N> {
/// Computes the canonical basis for the given dimension. A canonical basis is a set of /// Computes the canonical basis for the given dimension. A canonical basis is a set of
/// vectors, mutually orthogonal, with all its component equal to 0.0 except one which is equal /// vectors, mutually orthogonal, with all its component equal to 0.0 except one which is equal
/// to 1.0. /// to 1.0.
@ -186,35 +176,35 @@ macro_rules! dvec_impl(
} }
} }
impl<N: Mul<N, N> + Zero> $mul<N, $dvec<N>> for $dvec<N> { impl<N: Mul<N, N> + Zero> Mul<$dvec<N>, $dvec<N>> for $dvec<N> {
#[inline] #[inline]
fn binop(left: &$dvec<N>, right: &$dvec<N>) -> $dvec<N> { fn mul(&self, right: &$dvec<N>) -> $dvec<N> {
assert!(left.len() == right.len()); assert!(self.len() == right.len());
FromIterator::from_iter(left.as_slice().iter().zip(right.as_slice().iter()).map(|(a, b)| *a * *b)) FromIterator::from_iter(self.as_slice().iter().zip(right.as_slice().iter()).map(|(a, b)| *a * *b))
} }
} }
impl<N: Div<N, N> + Zero> $div<N, $dvec<N>> for $dvec<N> { impl<N: Div<N, N> + Zero> Div<$dvec<N>, $dvec<N>> for $dvec<N> {
#[inline] #[inline]
fn binop(left: &$dvec<N>, right: &$dvec<N>) -> $dvec<N> { fn div(&self, right: &$dvec<N>) -> $dvec<N> {
assert!(left.len() == right.len()); assert!(self.len() == right.len());
FromIterator::from_iter(left.as_slice().iter().zip(right.as_slice().iter()).map(|(a, b)| *a / *b)) FromIterator::from_iter(self.as_slice().iter().zip(right.as_slice().iter()).map(|(a, b)| *a / *b))
} }
} }
impl<N: Add<N, N> + Zero> $add<N, $dvec<N>> for $dvec<N> { impl<N: Add<N, N> + Zero> Add<$dvec<N>, $dvec<N>> for $dvec<N> {
#[inline] #[inline]
fn binop(left: &$dvec<N>, right: &$dvec<N>) -> $dvec<N> { fn add(&self, right: &$dvec<N>) -> $dvec<N> {
assert!(left.len() == right.len()); assert!(self.len() == right.len());
FromIterator::from_iter(left.as_slice().iter().zip(right.as_slice().iter()).map(|(a, b)| *a + *b)) FromIterator::from_iter(self.as_slice().iter().zip(right.as_slice().iter()).map(|(a, b)| *a + *b))
} }
} }
impl<N: Sub<N, N> + Zero> $sub<N, $dvec<N>> for $dvec<N> { impl<N: Sub<N, N> + Zero> Sub<$dvec<N>, $dvec<N>> for $dvec<N> {
#[inline] #[inline]
fn binop(left: &$dvec<N>, right: &$dvec<N>) -> $dvec<N> { fn sub(&self, right: &$dvec<N>) -> $dvec<N> {
assert!(left.len() == right.len()); assert!(self.len() == right.len());
FromIterator::from_iter(left.as_slice().iter().zip(right.as_slice().iter()).map(|(a, b)| *a - *b)) FromIterator::from_iter(self.as_slice().iter().zip(right.as_slice().iter()).map(|(a, b)| *a - *b))
} }
} }
@ -293,106 +283,38 @@ macro_rules! dvec_impl(
} }
} }
dvec_scalar_mul_impl!($dvec, f64, $mul) impl<N: Mul<N, N> + Zero> Mul<N, $dvec<N>> for $dvec<N> {
dvec_scalar_mul_impl!($dvec, f32, $mul)
dvec_scalar_mul_impl!($dvec, u64, $mul)
dvec_scalar_mul_impl!($dvec, u32, $mul)
dvec_scalar_mul_impl!($dvec, u16, $mul)
dvec_scalar_mul_impl!($dvec, u8, $mul)
dvec_scalar_mul_impl!($dvec, i64, $mul)
dvec_scalar_mul_impl!($dvec, i32, $mul)
dvec_scalar_mul_impl!($dvec, i16, $mul)
dvec_scalar_mul_impl!($dvec, i8, $mul)
dvec_scalar_mul_impl!($dvec, uint, $mul)
dvec_scalar_mul_impl!($dvec, int, $mul)
dvec_scalar_div_impl!($dvec, f64, $div)
dvec_scalar_div_impl!($dvec, f32, $div)
dvec_scalar_div_impl!($dvec, u64, $div)
dvec_scalar_div_impl!($dvec, u32, $div)
dvec_scalar_div_impl!($dvec, u16, $div)
dvec_scalar_div_impl!($dvec, u8, $div)
dvec_scalar_div_impl!($dvec, i64, $div)
dvec_scalar_div_impl!($dvec, i32, $div)
dvec_scalar_div_impl!($dvec, i16, $div)
dvec_scalar_div_impl!($dvec, i8, $div)
dvec_scalar_div_impl!($dvec, uint, $div)
dvec_scalar_div_impl!($dvec, int, $div)
dvec_scalar_add_impl!($dvec, f64, $add)
dvec_scalar_add_impl!($dvec, f32, $add)
dvec_scalar_add_impl!($dvec, u64, $add)
dvec_scalar_add_impl!($dvec, u32, $add)
dvec_scalar_add_impl!($dvec, u16, $add)
dvec_scalar_add_impl!($dvec, u8, $add)
dvec_scalar_add_impl!($dvec, i64, $add)
dvec_scalar_add_impl!($dvec, i32, $add)
dvec_scalar_add_impl!($dvec, i16, $add)
dvec_scalar_add_impl!($dvec, i8, $add)
dvec_scalar_add_impl!($dvec, uint, $add)
dvec_scalar_add_impl!($dvec, int, $add)
dvec_scalar_sub_impl!($dvec, f64, $sub)
dvec_scalar_sub_impl!($dvec, f32, $sub)
dvec_scalar_sub_impl!($dvec, u64, $sub)
dvec_scalar_sub_impl!($dvec, u32, $sub)
dvec_scalar_sub_impl!($dvec, u16, $sub)
dvec_scalar_sub_impl!($dvec, u8, $sub)
dvec_scalar_sub_impl!($dvec, i64, $sub)
dvec_scalar_sub_impl!($dvec, i32, $sub)
dvec_scalar_sub_impl!($dvec, i16, $sub)
dvec_scalar_sub_impl!($dvec, i8, $sub)
dvec_scalar_sub_impl!($dvec, uint, $sub)
dvec_scalar_sub_impl!($dvec, int, $sub)
)
)
macro_rules! dvec_scalar_mul_impl (
($dvec: ident, $n: ident, $mul: ident) => (
impl $mul<$n, $dvec<$n>> for $n {
#[inline] #[inline]
fn binop(left: &$dvec<$n>, right: &$n) -> $dvec<$n> { fn mul(&self, right: &N) -> $dvec<N> {
FromIterator::from_iter(left.as_slice().iter().map(|a| *a * *right)) FromIterator::from_iter(self.as_slice().iter().map(|a| *a * *right))
} }
} }
)
)
macro_rules! dvec_scalar_div_impl ( impl<N: Div<N, N> + Zero> Div<N, $dvec<N>> for $dvec<N> {
($dvec: ident, $n: ident, $div: ident) => (
impl $div<$n, $dvec<$n>> for $n {
#[inline] #[inline]
fn binop(left: &$dvec<$n>, right: &$n) -> $dvec<$n> { fn div(&self, right: &N) -> $dvec<N> {
FromIterator::from_iter(left.as_slice().iter().map(|a| *a / *right)) FromIterator::from_iter(self.as_slice().iter().map(|a| *a / *right))
} }
} }
)
)
macro_rules! dvec_scalar_add_impl ( impl<N: Add<N, N> + Zero> Add<N, $dvec<N>> for $dvec<N> {
($dvec: ident, $n: ident, $add: ident) => (
impl $add<$n, $dvec<$n>> for $n {
#[inline] #[inline]
fn binop(left: &$dvec<$n>, right: &$n) -> $dvec<$n> { fn add(&self, right: &N) -> $dvec<N> {
FromIterator::from_iter(left.as_slice().iter().map(|a| *a + *right)) FromIterator::from_iter(self.as_slice().iter().map(|a| *a + *right))
} }
} }
)
)
macro_rules! dvec_scalar_sub_impl ( impl<N: Sub<N, N> + Zero> Sub<N, $dvec<N>> for $dvec<N> {
($dvec: ident, $n: ident, $sub: ident) => (
impl $sub<$n, $dvec<$n>> for $n {
#[inline] #[inline]
fn binop(left: &$dvec<$n>, right: &$n) -> $dvec<$n> { fn sub(&self, right: &N) -> $dvec<N> {
FromIterator::from_iter(left.as_slice().iter().map(|a| *a - *right)) FromIterator::from_iter(self.as_slice().iter().map(|a| *a - *right))
} }
} }
) )
) )
macro_rules! small_dvec_impl ( macro_rules! small_dvec_impl (
($dvec: ident, $dim: expr, $mul: ident, $div: ident, $add: ident, $sub: ident $(,$idx: expr)*) => ( ($dvec: ident, $dim: expr $(,$idx: expr)*) => (
impl<N> $dvec<N> { impl<N> $dvec<N> {
#[inline] #[inline]
pub fn len(&self) -> uint { pub fn len(&self) -> uint {
@ -428,7 +350,7 @@ macro_rules! small_dvec_impl (
} }
} }
dvec_impl!($dvec, $mul, $div, $add, $sub) dvec_impl!($dvec)
) )
) )

32
src/structs/iso.rs
View File

@ -10,7 +10,7 @@ use traits::geometry::{RotationMatrix, Rotation, Rotate, AbsoluteRotate, Transfo
Translate, Translation, ToHomogeneous}; Translate, Translation, ToHomogeneous};
use structs::vec::{Vec1, Vec2, Vec3, Vec4}; use structs::vec::{Vec1, Vec2, Vec3, Vec4};
use structs::pnt::{Pnt2, Pnt3, Pnt4, Pnt2MulRhs, Pnt3MulRhs, Pnt4MulRhs}; use structs::pnt::{Pnt2, Pnt3, Pnt4};
use structs::rot::{Rot2, Rot3, Rot4}; use structs::rot::{Rot2, Rot3, Rot4};
@ -93,8 +93,6 @@ impl<N> Iso4<N> {
} }
iso_impl!(Iso2, Rot2, Vec2, Vec1) iso_impl!(Iso2, Rot2, Vec2, Vec1)
double_dispatch_binop_decl_trait!(Iso2, Iso2MulRhs)
mul_redispatch_impl!(Iso2, Iso2MulRhs)
rotation_matrix_impl!(Iso2, Rot2, Vec2, Vec1) rotation_matrix_impl!(Iso2, Rot2, Vec2, Vec1)
rotation_impl!(Iso2, Rot2, Vec1) rotation_impl!(Iso2, Rot2, Vec1)
dim_impl!(Iso2, 2) dim_impl!(Iso2, 2)
@ -104,18 +102,16 @@ rand_impl!(Iso2)
approx_eq_impl!(Iso2) approx_eq_impl!(Iso2)
to_homogeneous_impl!(Iso2, Mat3) to_homogeneous_impl!(Iso2, Mat3)
inv_impl!(Iso2) inv_impl!(Iso2)
transform_impl!(Iso2TransformRhs, Iso2, Vec2, Pnt2) transform_impl!(Iso2, Pnt2)
transformation_impl!(Iso2) transformation_impl!(Iso2)
rotate_impl!(Iso2, Vec2) rotate_impl!(Iso2, Vec2)
translation_impl!(Iso2, Vec2) translation_impl!(Iso2, Vec2)
translate_impl!(Iso2, Pnt2) translate_impl!(Iso2, Pnt2)
iso_mul_iso_impl!(Iso2, Iso2MulRhs) iso_mul_iso_impl!(Iso2)
iso_mul_pnt_impl!(Iso2, Pnt2, Iso2MulRhs) iso_mul_pnt_impl!(Iso2, Pnt2)
pnt_mul_iso_impl!(Iso2, Pnt2, Pnt2MulRhs) pnt_mul_iso_impl!(Iso2, Pnt2)
iso_impl!(Iso3, Rot3, Vec3, Vec3) iso_impl!(Iso3, Rot3, Vec3, Vec3)
double_dispatch_binop_decl_trait!(Iso3, Iso3MulRhs)
mul_redispatch_impl!(Iso3, Iso3MulRhs)
rotation_matrix_impl!(Iso3, Rot3, Vec3, Vec3) rotation_matrix_impl!(Iso3, Rot3, Vec3, Vec3)
rotation_impl!(Iso3, Rot3, Vec3) rotation_impl!(Iso3, Rot3, Vec3)
dim_impl!(Iso3, 3) dim_impl!(Iso3, 3)
@ -125,18 +121,16 @@ rand_impl!(Iso3)
approx_eq_impl!(Iso3) approx_eq_impl!(Iso3)
to_homogeneous_impl!(Iso3, Mat4) to_homogeneous_impl!(Iso3, Mat4)
inv_impl!(Iso3) inv_impl!(Iso3)
transform_impl!(Iso3TransformRhs, Iso3, Vec3, Pnt3) transform_impl!(Iso3, Pnt3)
transformation_impl!(Iso3) transformation_impl!(Iso3)
rotate_impl!(Iso3, Vec3) rotate_impl!(Iso3, Vec3)
translation_impl!(Iso3, Vec3) translation_impl!(Iso3, Vec3)
translate_impl!(Iso3, Pnt3) translate_impl!(Iso3, Pnt3)
iso_mul_iso_impl!(Iso3, Iso3MulRhs) iso_mul_iso_impl!(Iso3)
iso_mul_pnt_impl!(Iso3, Pnt3, Iso3MulRhs) iso_mul_pnt_impl!(Iso3, Pnt3)
pnt_mul_iso_impl!(Iso3, Pnt3, Pnt3MulRhs) pnt_mul_iso_impl!(Iso3, Pnt3)
// iso_impl!(Iso4, Rot4, Vec4, Vec4) // iso_impl!(Iso4, Rot4, Vec4, Vec4)
double_dispatch_binop_decl_trait!(Iso4, Iso4MulRhs)
mul_redispatch_impl!(Iso4, Iso4MulRhs)
// rotation_matrix_impl!(Iso4, Rot4, Vec4, Vec4) // rotation_matrix_impl!(Iso4, Rot4, Vec4, Vec4)
// rotation_impl!(Iso4, Rot4, Vec4) // rotation_impl!(Iso4, Rot4, Vec4)
dim_impl!(Iso4, 4) dim_impl!(Iso4, 4)
@ -146,11 +140,11 @@ absolute_rotate_impl!(Iso4, Vec4)
approx_eq_impl!(Iso4) approx_eq_impl!(Iso4)
to_homogeneous_impl!(Iso4, Mat5) to_homogeneous_impl!(Iso4, Mat5)
inv_impl!(Iso4) inv_impl!(Iso4)
transform_impl!(Iso4TransformRhs, Iso4, Vec4, Pnt4) transform_impl!(Iso4, Pnt4)
transformation_impl!(Iso4) transformation_impl!(Iso4)
rotate_impl!(Iso4, Vec4) rotate_impl!(Iso4, Vec4)
translation_impl!(Iso4, Vec4) translation_impl!(Iso4, Vec4)
translate_impl!(Iso4, Pnt4) translate_impl!(Iso4, Pnt4)
iso_mul_iso_impl!(Iso4, Iso4MulRhs) iso_mul_iso_impl!(Iso4)
iso_mul_pnt_impl!(Iso4, Pnt4, Iso4MulRhs) iso_mul_pnt_impl!(Iso4, Pnt4)
pnt_mul_iso_impl!(Iso4, Pnt4, Pnt4MulRhs) pnt_mul_iso_impl!(Iso4, Pnt4)

59
src/structs/iso_macros.rs
View File

@ -60,35 +60,35 @@ macro_rules! one_impl(
) )
macro_rules! iso_mul_iso_impl( macro_rules! iso_mul_iso_impl(
($t: ident, $tmul: ident) => ( ($t: ident) => (
impl<N: BaseFloat + Clone> $tmul<N, $t<N>> for $t<N> { impl<N: BaseFloat + Clone> Mul<$t<N>, $t<N>> for $t<N> {
#[inline] #[inline]
fn binop(left: &$t<N>, right: &$t<N>) -> $t<N> { fn mul(&self, right: &$t<N>) -> $t<N> {
$t::new_with_rotmat( $t::new_with_rotmat(
left.translation + left.rotation * right.translation, self.translation + self.rotation * right.translation,
left.rotation * right.rotation) self.rotation * right.rotation)
} }
} }
) )
) )
macro_rules! iso_mul_pnt_impl( macro_rules! iso_mul_pnt_impl(
($t: ident, $tv: ident, $tmul: ident) => ( ($t: ident, $tv: ident) => (
impl<N: BaseNum + Clone> $tmul<N, $tv<N>> for $tv<N> { impl<N: BaseNum + Clone> Mul<$tv<N>, $tv<N>> for $t<N> {
#[inline] #[inline]
fn binop(left: &$t<N>, right: &$tv<N>) -> $tv<N> { fn mul(&self, right: &$tv<N>) -> $tv<N> {
left.rotation * *right + left.translation self.rotation * *right + self.translation
} }
} }
) )
) )
macro_rules! pnt_mul_iso_impl( macro_rules! pnt_mul_iso_impl(
($t: ident, $tv: ident, $tmul: ident) => ( ($t: ident, $tv: ident) => (
impl<N: Clone + BaseNum> $tmul<N, $tv<N>> for $t<N> { impl<N: Clone + BaseNum> Mul<$t<N>, $tv<N>> for $tv<N> {
#[inline] #[inline]
fn binop(left: &$tv<N>, right: &$t<N>) -> $tv<N> { fn mul(&self, right: &$t<N>) -> $tv<N> {
(*left + right.translation) * right.rotation (*self + right.translation) * right.rotation
} }
} }
) )
@ -254,37 +254,16 @@ macro_rules! transformation_impl(
) )
macro_rules! transform_impl( macro_rules! transform_impl(
($trhs: ident, $t: ident, $tv: ident, $tp: ident) => ( ($t: ident, $tp: ident) => (
/* impl<N: BaseNum + Clone> Transform<$tp<N>> for $t<N> {
* FIXME: we use the double dispatch trick here so that we can transform vectors _and_
* points. Remove this as soon as rust supports multidispatch.
*/
pub trait $trhs<N> {
fn transform(left: &$t<N>, right: &Self) -> Self;
fn inv_transform(left: &$t<N>, right: &Self) -> Self;
}
impl<N, V: $trhs<N>> Transform<V> for $t<N> {
#[inline(always)]
fn transform(&self, other: &V) -> V {
$trhs::transform(self, other)
}
#[inline(always)]
fn inv_transform(&self, other: &V) -> V {
$trhs::inv_transform(self, other)
}
}
impl<N: BaseNum + Clone> $trhs<N> for $tp<N> {
#[inline] #[inline]
fn transform(t: &$t<N>, p: &$tp<N>) -> $tp<N> { fn transform(&self, p: &$tp<N>) -> $tp<N> {
t.rotation.transform(p) + t.translation self.rotation.transform(p) + self.translation
} }
#[inline] #[inline]
fn inv_transform(t: &$t<N>, p: &$tp<N>) -> $tp<N> { fn inv_transform(&self, p: &$tp<N>) -> $tp<N> {
t.rotation.inv_transform(&(*p - t.translation)) self.rotation.inv_transform(&(*p - self.translation))
} }
} }
) )

753
src/structs/mat.rs
View File

@ -5,9 +5,8 @@
use std::mem; use std::mem;
use traits::operations::ApproxEq; use traits::operations::ApproxEq;
use std::slice::{Items, MutItems}; use std::slice::{Items, MutItems};
use structs::vec::{Vec1, Vec2, Vec3, Vec4, Vec5, Vec6, use structs::vec::{Vec1, Vec2, Vec3, Vec4, Vec5, Vec6};
Vec1MulRhs, Vec4MulRhs, Vec5MulRhs, Vec6MulRhs}; use structs::pnt::{Pnt1, Pnt4, Pnt5, Pnt6};
use structs::pnt::{Pnt1, Pnt4, Pnt5, Pnt6, Pnt1MulRhs, Pnt4MulRhs, Pnt5MulRhs, Pnt6MulRhs};
use structs::dvec::{DVec1, DVec2, DVec3, DVec4, DVec5, DVec6}; use structs::dvec::{DVec1, DVec2, DVec3, DVec4, DVec5, DVec6};
use traits::structure::{Cast, Row, Col, Iterable, IterableMut, Dim, Indexable, use traits::structure::{Cast, Row, Col, Iterable, IterableMut, Dim, Indexable,
@ -37,74 +36,15 @@ pub struct Mat1<N> {
eye_impl!(Mat1, 1, m11) eye_impl!(Mat1, 1, m11)
double_dispatch_binop_decl_trait!(Mat1, Mat1MulRhs)
double_dispatch_binop_decl_trait!(Mat1, Mat1DivRhs)
double_dispatch_binop_decl_trait!(Mat1, Mat1AddRhs)
double_dispatch_binop_decl_trait!(Mat1, Mat1SubRhs)
double_dispatch_cast_decl_trait!(Mat1, Mat1Cast)
mul_redispatch_impl!(Mat1, Mat1MulRhs)
div_redispatch_impl!(Mat1, Mat1DivRhs)
add_redispatch_impl!(Mat1, Mat1AddRhs)
sub_redispatch_impl!(Mat1, Mat1SubRhs)
cast_redispatch_impl!(Mat1, Mat1Cast)
mat_impl!(Mat1, m11) mat_impl!(Mat1, m11)
as_array_impl!(Mat1, 1) as_array_impl!(Mat1, 1)
mat_cast_impl!(Mat1, Mat1Cast, m11) mat_cast_impl!(Mat1, m11)
add_impl!(Mat1, Mat1AddRhs, m11) add_impl!(Mat1, m11)
sub_impl!(Mat1, Mat1SubRhs, m11) sub_impl!(Mat1, m11)
scalar_add_impl!(Mat1, m11)
mat_mul_scalar_impl!(Mat1, f64, Mat1MulRhs, m11) scalar_sub_impl!(Mat1, m11)
mat_mul_scalar_impl!(Mat1, f32, Mat1MulRhs, m11) scalar_mul_impl!(Mat1, m11)
mat_mul_scalar_impl!(Mat1, i64, Mat1MulRhs, m11) scalar_div_impl!(Mat1, m11)
mat_mul_scalar_impl!(Mat1, i32, Mat1MulRhs, m11)
mat_mul_scalar_impl!(Mat1, i16, Mat1MulRhs, m11)
mat_mul_scalar_impl!(Mat1, i8, Mat1MulRhs, m11)
mat_mul_scalar_impl!(Mat1, u64, Mat1MulRhs, m11)
mat_mul_scalar_impl!(Mat1, u32, Mat1MulRhs, m11)
mat_mul_scalar_impl!(Mat1, u16, Mat1MulRhs, m11)
mat_mul_scalar_impl!(Mat1, u8, Mat1MulRhs, m11)
mat_mul_scalar_impl!(Mat1, uint, Mat1MulRhs, m11)
mat_mul_scalar_impl!(Mat1, int, Mat1MulRhs, m11)
mat_div_scalar_impl!(Mat1, f64, Mat1DivRhs, m11)
mat_div_scalar_impl!(Mat1, f32, Mat1DivRhs, m11)
mat_div_scalar_impl!(Mat1, i64, Mat1DivRhs, m11)
mat_div_scalar_impl!(Mat1, i32, Mat1DivRhs, m11)
mat_div_scalar_impl!(Mat1, i16, Mat1DivRhs, m11)
mat_div_scalar_impl!(Mat1, i8, Mat1DivRhs, m11)
mat_div_scalar_impl!(Mat1, u64, Mat1DivRhs, m11)
mat_div_scalar_impl!(Mat1, u32, Mat1DivRhs, m11)
mat_div_scalar_impl!(Mat1, u16, Mat1DivRhs, m11)
mat_div_scalar_impl!(Mat1, u8, Mat1DivRhs, m11)
mat_div_scalar_impl!(Mat1, uint, Mat1DivRhs, m11)
mat_div_scalar_impl!(Mat1, int, Mat1DivRhs, m11)
mat_add_scalar_impl!(Mat1, f64, Mat1AddRhs, m11)
mat_add_scalar_impl!(Mat1, f32, Mat1AddRhs, m11)
mat_add_scalar_impl!(Mat1, i64, Mat1AddRhs, m11)
mat_add_scalar_impl!(Mat1, i32, Mat1AddRhs, m11)
mat_add_scalar_impl!(Mat1, i16, Mat1AddRhs, m11)
mat_add_scalar_impl!(Mat1, i8, Mat1AddRhs, m11)
mat_add_scalar_impl!(Mat1, u64, Mat1AddRhs, m11)
mat_add_scalar_impl!(Mat1, u32, Mat1AddRhs, m11)
mat_add_scalar_impl!(Mat1, u16, Mat1AddRhs, m11)
mat_add_scalar_impl!(Mat1, u8, Mat1AddRhs, m11)
mat_add_scalar_impl!(Mat1, uint, Mat1AddRhs, m11)
mat_add_scalar_impl!(Mat1, int, Mat1AddRhs, m11)
mat_sub_scalar_impl!(Mat1, f64, Mat1SubRhs, m11)
mat_sub_scalar_impl!(Mat1, f32, Mat1SubRhs, m11)
mat_sub_scalar_impl!(Mat1, i64, Mat1SubRhs, m11)
mat_sub_scalar_impl!(Mat1, i32, Mat1SubRhs, m11)
mat_sub_scalar_impl!(Mat1, i16, Mat1SubRhs, m11)
mat_sub_scalar_impl!(Mat1, i8, Mat1SubRhs, m11)
mat_sub_scalar_impl!(Mat1, u64, Mat1SubRhs, m11)
mat_sub_scalar_impl!(Mat1, u32, Mat1SubRhs, m11)
mat_sub_scalar_impl!(Mat1, u16, Mat1SubRhs, m11)
mat_sub_scalar_impl!(Mat1, u8, Mat1SubRhs, m11)
mat_sub_scalar_impl!(Mat1, uint, Mat1SubRhs, m11)
mat_sub_scalar_impl!(Mat1, int, Mat1SubRhs, m11)
absolute_impl!(Mat1, m11) absolute_impl!(Mat1, m11)
zero_impl!(Mat1, m11) zero_impl!(Mat1, m11)
one_impl!(Mat1, ::one) one_impl!(Mat1, ::one)
@ -114,11 +54,11 @@ at_fast_impl!(Mat1, 1)
dim_impl!(Mat1, 1) dim_impl!(Mat1, 1)
indexable_impl!(Mat1, 1) indexable_impl!(Mat1, 1)
index_impl!(Mat1, 1) index_impl!(Mat1, 1)
mat_mul_mat_impl!(Mat1, Mat1MulRhs, 1) mat_mul_mat_impl!(Mat1, 1)
mat_mul_vec_impl!(Mat1, Vec1, Mat1MulRhs, 1, ::zero) mat_mul_vec_impl!(Mat1, Vec1, 1, ::zero)
vec_mul_mat_impl!(Mat1, Vec1, Vec1MulRhs, 1, ::zero) vec_mul_mat_impl!(Mat1, Vec1, 1, ::zero)
mat_mul_pnt_impl!(Mat1, Pnt1, Mat1MulRhs, 1, Orig::orig) mat_mul_pnt_impl!(Mat1, Pnt1, 1, Orig::orig)
pnt_mul_mat_impl!(Mat1, Pnt1, Pnt1MulRhs, 1, Orig::orig) pnt_mul_mat_impl!(Mat1, Pnt1, 1, Orig::orig)
// (specialized) inv_impl!(Mat1, 1) // (specialized) inv_impl!(Mat1, 1)
transpose_impl!(Mat1, 1) transpose_impl!(Mat1, 1)
approx_eq_impl!(Mat1) approx_eq_impl!(Mat1)
@ -141,76 +81,17 @@ pub struct Mat2<N> {
eye_impl!(Mat2, 2, m11, m22) eye_impl!(Mat2, 2, m11, m22)
double_dispatch_binop_decl_trait!(Mat2, Mat2MulRhs)
double_dispatch_binop_decl_trait!(Mat2, Mat2DivRhs)
double_dispatch_binop_decl_trait!(Mat2, Mat2AddRhs)
double_dispatch_binop_decl_trait!(Mat2, Mat2SubRhs)
double_dispatch_cast_decl_trait!(Mat2, Mat2Cast)
mul_redispatch_impl!(Mat2, Mat2MulRhs)
div_redispatch_impl!(Mat2, Mat2DivRhs)
add_redispatch_impl!(Mat2, Mat2AddRhs)
sub_redispatch_impl!(Mat2, Mat2SubRhs)
cast_redispatch_impl!(Mat2, Mat2Cast)
mat_impl!(Mat2, m11, m12, mat_impl!(Mat2, m11, m12,
m21, m22) m21, m22)
as_array_impl!(Mat2, 2) as_array_impl!(Mat2, 2)
mat_cast_impl!(Mat2, Mat2Cast, m11, m12, mat_cast_impl!(Mat2, m11, m12,
m21, m22) m21, m22)
add_impl!(Mat2, Mat2AddRhs, m11, m12, m21, m22) add_impl!(Mat2, m11, m12, m21, m22)
sub_impl!(Mat2, Mat2SubRhs, m11, m12, m21, m22) sub_impl!(Mat2, m11, m12, m21, m22)
scalar_add_impl!(Mat2, m11, m12, m21, m22)
mat_mul_scalar_impl!(Mat2, f64, Mat2MulRhs, m11, m12, m21, m22) scalar_sub_impl!(Mat2, m11, m12, m21, m22)
mat_mul_scalar_impl!(Mat2, f32, Mat2MulRhs, m11, m12, m21, m22) scalar_mul_impl!(Mat2, m11, m12, m21, m22)
mat_mul_scalar_impl!(Mat2, i64, Mat2MulRhs, m11, m12, m21, m22) scalar_div_impl!(Mat2, m11, m12, m21, m22)
mat_mul_scalar_impl!(Mat2, i32, Mat2MulRhs, m11, m12, m21, m22)
mat_mul_scalar_impl!(Mat2, i16, Mat2MulRhs, m11, m12, m21, m22)
mat_mul_scalar_impl!(Mat2, i8, Mat2MulRhs, m11, m12, m21, m22)
mat_mul_scalar_impl!(Mat2, u64, Mat2MulRhs, m11, m12, m21, m22)
mat_mul_scalar_impl!(Mat2, u32, Mat2MulRhs, m11, m12, m21, m22)
mat_mul_scalar_impl!(Mat2, u16, Mat2MulRhs, m11, m12, m21, m22)
mat_mul_scalar_impl!(Mat2, u8, Mat2MulRhs, m11, m12, m21, m22)
mat_mul_scalar_impl!(Mat2, uint, Mat2MulRhs, m11, m12, m21, m22)
mat_mul_scalar_impl!(Mat2, int, Mat2MulRhs, m11, m12, m21, m22)
mat_div_scalar_impl!(Mat2, f64, Mat2DivRhs, m11, m12, m21, m22)
mat_div_scalar_impl!(Mat2, f32, Mat2DivRhs, m11, m12, m21, m22)
mat_div_scalar_impl!(Mat2, i64, Mat2DivRhs, m11, m12, m21, m22)
mat_div_scalar_impl!(Mat2, i32, Mat2DivRhs, m11, m12, m21, m22)
mat_div_scalar_impl!(Mat2, i16, Mat2DivRhs, m11, m12, m21, m22)
mat_div_scalar_impl!(Mat2, i8, Mat2DivRhs, m11, m12, m21, m22)
mat_div_scalar_impl!(Mat2, u64, Mat2DivRhs, m11, m12, m21, m22)
mat_div_scalar_impl!(Mat2, u32, Mat2DivRhs, m11, m12, m21, m22)
mat_div_scalar_impl!(Mat2, u16, Mat2DivRhs, m11, m12, m21, m22)
mat_div_scalar_impl!(Mat2, u8, Mat2DivRhs, m11, m12, m21, m22)
mat_div_scalar_impl!(Mat2, uint, Mat2DivRhs, m11, m12, m21, m22)
mat_div_scalar_impl!(Mat2, int, Mat2DivRhs, m11, m12, m21, m22)
mat_add_scalar_impl!(Mat2, f64, Mat2AddRhs, m11, m12, m21, m22)
mat_add_scalar_impl!(Mat2, f32, Mat2AddRhs, m11, m12, m21, m22)
mat_add_scalar_impl!(Mat2, i64, Mat2AddRhs, m11, m12, m21, m22)
mat_add_scalar_impl!(Mat2, i32, Mat2AddRhs, m11, m12, m21, m22)
mat_add_scalar_impl!(Mat2, i16, Mat2AddRhs, m11, m12, m21, m22)
mat_add_scalar_impl!(Mat2, i8, Mat2AddRhs, m11, m12, m21, m22)
mat_add_scalar_impl!(Mat2, u64, Mat2AddRhs, m11, m12, m21, m22)
mat_add_scalar_impl!(Mat2, u32, Mat2AddRhs, m11, m12, m21, m22)
mat_add_scalar_impl!(Mat2, u16, Mat2AddRhs, m11, m12, m21, m22)
mat_add_scalar_impl!(Mat2, u8, Mat2AddRhs, m11, m12, m21, m22)
mat_add_scalar_impl!(Mat2, uint, Mat2AddRhs, m11, m12, m21, m22)
mat_add_scalar_impl!(Mat2, int, Mat2AddRhs, m11, m12, m21, m22)
mat_sub_scalar_impl!(Mat2, f64, Mat2SubRhs, m11, m12, m21, m22)
mat_sub_scalar_impl!(Mat2, f32, Mat2SubRhs, m11, m12, m21, m22)
mat_sub_scalar_impl!(Mat2, i64, Mat2SubRhs, m11, m12, m21, m22)
mat_sub_scalar_impl!(Mat2, i32, Mat2SubRhs, m11, m12, m21, m22)
mat_sub_scalar_impl!(Mat2, i16, Mat2SubRhs, m11, m12, m21, m22)
mat_sub_scalar_impl!(Mat2, i8, Mat2SubRhs, m11, m12, m21, m22)
mat_sub_scalar_impl!(Mat2, u64, Mat2SubRhs, m11, m12, m21, m22)
mat_sub_scalar_impl!(Mat2, u32, Mat2SubRhs, m11, m12, m21, m22)
mat_sub_scalar_impl!(Mat2, u16, Mat2SubRhs, m11, m12, m21, m22)
mat_sub_scalar_impl!(Mat2, u8, Mat2SubRhs, m11, m12, m21, m22)
mat_sub_scalar_impl!(Mat2, uint, Mat2SubRhs, m11, m12, m21, m22)
mat_sub_scalar_impl!(Mat2, int, Mat2SubRhs, m11, m12, m21, m22)
absolute_impl!(Mat2, m11, m12, absolute_impl!(Mat2, m11, m12,
m21, m22) m21, m22)
zero_impl!(Mat2, m11, m12, zero_impl!(Mat2, m11, m12,
@ -249,85 +130,43 @@ pub struct Mat3<N> {
eye_impl!(Mat3, 3, m11, m22, m33) eye_impl!(Mat3, 3, m11, m22, m33)
double_dispatch_binop_decl_trait!(Mat3, Mat3MulRhs)
double_dispatch_binop_decl_trait!(Mat3, Mat3DivRhs)
double_dispatch_binop_decl_trait!(Mat3, Mat3AddRhs)
double_dispatch_binop_decl_trait!(Mat3, Mat3SubRhs)
double_dispatch_cast_decl_trait!(Mat3, Mat3Cast)
mul_redispatch_impl!(Mat3, Mat3MulRhs)
div_redispatch_impl!(Mat3, Mat3DivRhs)
add_redispatch_impl!(Mat3, Mat3AddRhs)
sub_redispatch_impl!(Mat3, Mat3SubRhs)
cast_redispatch_impl!(Mat3, Mat3Cast)
mat_impl!(Mat3, m11, m12, m13, mat_impl!(Mat3, m11, m12, m13,
m21, m22, m23, m21, m22, m23,
m31, m32, m33) m31, m32, m33)
as_array_impl!(Mat3, 3) as_array_impl!(Mat3, 3)
mat_cast_impl!(Mat3, Mat3Cast, m11, m12, m13, mat_cast_impl!(Mat3, m11, m12, m13,
m21, m22, m23, m21, m22, m23,
m31, m32, m33) m31, m32, m33)
add_impl!(Mat3, Mat3AddRhs, add_impl!(Mat3,
m11, m12, m13, m11, m12, m13,
m21, m22, m23, m21, m22, m23,
m31, m32, m33 m31, m32, m33
) )
sub_impl!(Mat3, Mat3SubRhs, sub_impl!(Mat3,
m11, m12, m13,
m21, m22, m23,
m31, m32, m33
)
scalar_add_impl!(Mat3,
m11, m12, m13,
m21, m22, m23,
m31, m32, m33
)
scalar_sub_impl!(Mat3,
m11, m12, m13,
m21, m22, m23,
m31, m32, m33
)
scalar_mul_impl!(Mat3,
m11, m12, m13,
m21, m22, m23,
m31, m32, m33
)
scalar_div_impl!(Mat3,
m11, m12, m13, m11, m12, m13,
m21, m22, m23, m21, m22, m23,
m31, m32, m33 m31, m32, m33
) )
mat_mul_scalar_impl!(Mat3, f64, Mat3MulRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_mul_scalar_impl!(Mat3, f32, Mat3MulRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_mul_scalar_impl!(Mat3, i64, Mat3MulRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_mul_scalar_impl!(Mat3, i32, Mat3MulRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_mul_scalar_impl!(Mat3, i16, Mat3MulRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_mul_scalar_impl!(Mat3, i8, Mat3MulRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_mul_scalar_impl!(Mat3, u64, Mat3MulRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_mul_scalar_impl!(Mat3, u32, Mat3MulRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_mul_scalar_impl!(Mat3, u16, Mat3MulRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_mul_scalar_impl!(Mat3, u8, Mat3MulRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_mul_scalar_impl!(Mat3, uint, Mat3MulRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_mul_scalar_impl!(Mat3, int, Mat3MulRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_div_scalar_impl!(Mat3, f64, Mat3DivRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_div_scalar_impl!(Mat3, f32, Mat3DivRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_div_scalar_impl!(Mat3, i64, Mat3DivRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_div_scalar_impl!(Mat3, i32, Mat3DivRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_div_scalar_impl!(Mat3, i16, Mat3DivRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_div_scalar_impl!(Mat3, i8, Mat3DivRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_div_scalar_impl!(Mat3, u64, Mat3DivRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_div_scalar_impl!(Mat3, u32, Mat3DivRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_div_scalar_impl!(Mat3, u16, Mat3DivRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_div_scalar_impl!(Mat3, u8, Mat3DivRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_div_scalar_impl!(Mat3, uint, Mat3DivRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_div_scalar_impl!(Mat3, int, Mat3DivRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_add_scalar_impl!(Mat3, f64, Mat3AddRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_add_scalar_impl!(Mat3, f32, Mat3AddRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_add_scalar_impl!(Mat3, i64, Mat3AddRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_add_scalar_impl!(Mat3, i32, Mat3AddRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_add_scalar_impl!(Mat3, i16, Mat3AddRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_add_scalar_impl!(Mat3, i8, Mat3AddRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_add_scalar_impl!(Mat3, u64, Mat3AddRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_add_scalar_impl!(Mat3, u32, Mat3AddRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_add_scalar_impl!(Mat3, u16, Mat3AddRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_add_scalar_impl!(Mat3, u8, Mat3AddRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_add_scalar_impl!(Mat3, uint, Mat3AddRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_add_scalar_impl!(Mat3, int, Mat3AddRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_sub_scalar_impl!(Mat3, f64, Mat3SubRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_sub_scalar_impl!(Mat3, f32, Mat3SubRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_sub_scalar_impl!(Mat3, i64, Mat3SubRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_sub_scalar_impl!(Mat3, i32, Mat3SubRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_sub_scalar_impl!(Mat3, i16, Mat3SubRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_sub_scalar_impl!(Mat3, i8, Mat3SubRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_sub_scalar_impl!(Mat3, u64, Mat3SubRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_sub_scalar_impl!(Mat3, u32, Mat3SubRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_sub_scalar_impl!(Mat3, u16, Mat3SubRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_sub_scalar_impl!(Mat3, u8, Mat3SubRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_sub_scalar_impl!(Mat3, uint, Mat3SubRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
mat_sub_scalar_impl!(Mat3, int, Mat3SubRhs, m11, m12, m13, m21, m22, m23, m31, m32, m33)
absolute_impl!(Mat3, absolute_impl!(Mat3,
m11, m12, m13, m11, m12, m13,
m21, m22, m23, m21, m22, m23,
@ -374,16 +213,6 @@ pub struct Mat4<N> {
eye_impl!(Mat4, 4, m11, m22, m33, m44) eye_impl!(Mat4, 4, m11, m22, m33, m44)
double_dispatch_binop_decl_trait!(Mat4, Mat4MulRhs)
double_dispatch_binop_decl_trait!(Mat4, Mat4DivRhs)
double_dispatch_binop_decl_trait!(Mat4, Mat4AddRhs)
double_dispatch_binop_decl_trait!(Mat4, Mat4SubRhs)
double_dispatch_cast_decl_trait!(Mat4, Mat4Cast)
mul_redispatch_impl!(Mat4, Mat4MulRhs)
div_redispatch_impl!(Mat4, Mat4DivRhs)
add_redispatch_impl!(Mat4, Mat4AddRhs)
sub_redispatch_impl!(Mat4, Mat4SubRhs)
cast_redispatch_impl!(Mat4, Mat4Cast)
mat_impl!(Mat4, mat_impl!(Mat4,
m11, m12, m13, m14, m11, m12, m13, m14,
m21, m22, m23, m24, m21, m22, m23, m24,
@ -391,117 +220,48 @@ mat_impl!(Mat4,
m41, m42, m43, m44 m41, m42, m43, m44
) )
as_array_impl!(Mat4, 4) as_array_impl!(Mat4, 4)
mat_cast_impl!(Mat4, Mat4Cast, mat_cast_impl!(Mat4,
m11, m12, m13, m14, m11, m12, m13, m14,
m21, m22, m23, m24, m21, m22, m23, m24,
m31, m32, m33, m34, m31, m32, m33, m34,
m41, m42, m43, m44 m41, m42, m43, m44
) )
add_impl!(Mat4, Mat4AddRhs, add_impl!(Mat4,
m11, m12, m13, m14, m11, m12, m13, m14,
m21, m22, m23, m24, m21, m22, m23, m24,
m31, m32, m33, m34, m31, m32, m33, m34,
m41, m42, m43, m44 m41, m42, m43, m44
) )
sub_impl!(Mat4, Mat4SubRhs, sub_impl!(Mat4,
m11, m12, m13, m14,
m21, m22, m23, m24,
m31, m32, m33, m34,
m41, m42, m43, m44
)
scalar_add_impl!(Mat4,
m11, m12, m13, m14,
m21, m22, m23, m24,
m31, m32, m33, m34,
m41, m42, m43, m44
)
scalar_sub_impl!(Mat4,
m11, m12, m13, m14,
m21, m22, m23, m24,
m31, m32, m33, m34,
m41, m42, m43, m44
)
scalar_mul_impl!(Mat4,
m11, m12, m13, m14,
m21, m22, m23, m24,
m31, m32, m33, m34,
m41, m42, m43, m44
)
scalar_div_impl!(Mat4,
m11, m12, m13, m14, m11, m12, m13, m14,
m21, m22, m23, m24, m21, m22, m23, m24,
m31, m32, m33, m34, m31, m32, m33, m34,
m41, m42, m43, m44 m41, m42, m43, m44
) )
mat_mul_scalar_impl!(Mat4, f64, Mat4MulRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_mul_scalar_impl!(Mat4, f32, Mat4MulRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_mul_scalar_impl!(Mat4, i64, Mat4MulRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_mul_scalar_impl!(Mat4, i32, Mat4MulRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_mul_scalar_impl!(Mat4, i16, Mat4MulRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_mul_scalar_impl!(Mat4, i8, Mat4MulRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_mul_scalar_impl!(Mat4, u32, Mat4MulRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_mul_scalar_impl!(Mat4, u16, Mat4MulRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_mul_scalar_impl!(Mat4, u8, Mat4MulRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_mul_scalar_impl!(Mat4, uint, Mat4MulRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_mul_scalar_impl!(Mat4, int, Mat4MulRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_div_scalar_impl!(Mat4, f64, Mat4DivRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_div_scalar_impl!(Mat4, f32, Mat4DivRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_div_scalar_impl!(Mat4, i64, Mat4DivRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_div_scalar_impl!(Mat4, i32, Mat4DivRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_div_scalar_impl!(Mat4, i16, Mat4DivRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_div_scalar_impl!(Mat4, i8, Mat4DivRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_div_scalar_impl!(Mat4, u32, Mat4DivRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_div_scalar_impl!(Mat4, u16, Mat4DivRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_div_scalar_impl!(Mat4, u8, Mat4DivRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_div_scalar_impl!(Mat4, uint, Mat4DivRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_div_scalar_impl!(Mat4, int, Mat4DivRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_add_scalar_impl!(Mat4, f64, Mat4AddRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_add_scalar_impl!(Mat4, f32, Mat4AddRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_add_scalar_impl!(Mat4, i64, Mat4AddRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_add_scalar_impl!(Mat4, i32, Mat4AddRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_add_scalar_impl!(Mat4, i16, Mat4AddRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_add_scalar_impl!(Mat4, i8, Mat4AddRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_add_scalar_impl!(Mat4, u32, Mat4AddRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_add_scalar_impl!(Mat4, u16, Mat4AddRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_add_scalar_impl!(Mat4, u8, Mat4AddRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_add_scalar_impl!(Mat4, uint, Mat4AddRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_add_scalar_impl!(Mat4, int, Mat4AddRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_sub_scalar_impl!(Mat4, f64, Mat4SubRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_sub_scalar_impl!(Mat4, f32, Mat4SubRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_sub_scalar_impl!(Mat4, i64, Mat4SubRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_sub_scalar_impl!(Mat4, i32, Mat4SubRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_sub_scalar_impl!(Mat4, i16, Mat4SubRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_sub_scalar_impl!(Mat4, i8, Mat4SubRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_sub_scalar_impl!(Mat4, u32, Mat4SubRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_sub_scalar_impl!(Mat4, u16, Mat4SubRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_sub_scalar_impl!(Mat4, u8, Mat4SubRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_sub_scalar_impl!(Mat4, uint, Mat4SubRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
mat_sub_scalar_impl!(Mat4, int, Mat4SubRhs, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
m41, m42, m43, m44)
absolute_impl!(Mat4, absolute_impl!(Mat4,
m11, m12, m13, m14, m11, m12, m13, m14,
m21, m22, m23, m24, m21, m22, m23, m24,
@ -524,11 +284,11 @@ dim_impl!(Mat4, 4)
indexable_impl!(Mat4, 4) indexable_impl!(Mat4, 4)
index_impl!(Mat4, 4) index_impl!(Mat4, 4)
at_fast_impl!(Mat4, 4) at_fast_impl!(Mat4, 4)
mat_mul_mat_impl!(Mat4, Mat4MulRhs, 4) mat_mul_mat_impl!(Mat4, 4)
mat_mul_vec_impl!(Mat4, Vec4, Mat4MulRhs, 4, ::zero) mat_mul_vec_impl!(Mat4, Vec4, 4, ::zero)
vec_mul_mat_impl!(Mat4, Vec4, Vec4MulRhs, 4, ::zero) vec_mul_mat_impl!(Mat4, Vec4, 4, ::zero)
mat_mul_pnt_impl!(Mat4, Pnt4, Mat4MulRhs, 4, Orig::orig) mat_mul_pnt_impl!(Mat4, Pnt4, 4, Orig::orig)
pnt_mul_mat_impl!(Mat4, Pnt4, Pnt4MulRhs, 4, Orig::orig) pnt_mul_mat_impl!(Mat4, Pnt4, 4, Orig::orig)
inv_impl!(Mat4, 4) inv_impl!(Mat4, 4)
transpose_impl!(Mat4, 4) transpose_impl!(Mat4, 4)
approx_eq_impl!(Mat4) approx_eq_impl!(Mat4)
@ -554,16 +314,6 @@ pub struct Mat5<N> {
eye_impl!(Mat5, 5, m11, m22, m33, m44, m55) eye_impl!(Mat5, 5, m11, m22, m33, m44, m55)
double_dispatch_binop_decl_trait!(Mat5, Mat5MulRhs)
double_dispatch_binop_decl_trait!(Mat5, Mat5DivRhs)
double_dispatch_binop_decl_trait!(Mat5, Mat5AddRhs)
double_dispatch_binop_decl_trait!(Mat5, Mat5SubRhs)
double_dispatch_cast_decl_trait!(Mat5, Mat5Cast)
mul_redispatch_impl!(Mat5, Mat5MulRhs)
div_redispatch_impl!(Mat5, Mat5DivRhs)
add_redispatch_impl!(Mat5, Mat5AddRhs)
sub_redispatch_impl!(Mat5, Mat5SubRhs)
cast_redispatch_impl!(Mat5, Mat5Cast)
mat_impl!(Mat5, mat_impl!(Mat5,
m11, m12, m13, m14, m15, m11, m12, m13, m14, m15,
m21, m22, m23, m24, m25, m21, m22, m23, m24, m25,
@ -572,7 +322,7 @@ mat_impl!(Mat5,
m51, m52, m53, m54, m55 m51, m52, m53, m54, m55
) )
as_array_impl!(Mat5, 5) as_array_impl!(Mat5, 5)
mat_cast_impl!(Mat5, Mat5Cast, mat_cast_impl!(Mat5,
m11, m12, m13, m14, m15, m11, m12, m13, m14, m15,
m21, m22, m23, m24, m25, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m31, m32, m33, m34, m35,
@ -600,131 +350,59 @@ one_impl!(Mat5,
::zero, ::zero, ::zero, ::one , ::zero, ::zero, ::zero, ::zero, ::one , ::zero,
::zero, ::zero, ::zero, ::zero, ::one ::zero, ::zero, ::zero, ::zero, ::one
) )
add_impl!(Mat5, Mat5AddRhs, add_impl!(Mat5,
m11, m12, m13, m14, m15, m11, m12, m13, m14, m15,
m21, m22, m23, m24, m25, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m31, m32, m33, m34, m35,
m41, m42, m43, m44, m45, m41, m42, m43, m44, m45,
m51, m52, m53, m54, m55 m51, m52, m53, m54, m55
) )
sub_impl!(Mat5, Mat5SubRhs, sub_impl!(Mat5,
m11, m12, m13, m14, m15,
m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35,
m41, m42, m43, m44, m45,
m51, m52, m53, m54, m55
)
scalar_add_impl!(Mat5,
m11, m12, m13, m14, m15,
m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35,
m41, m42, m43, m44, m45,
m51, m52, m53, m54, m55
)
scalar_sub_impl!(Mat5,
m11, m12, m13, m14, m15,
m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35,
m41, m42, m43, m44, m45,
m51, m52, m53, m54, m55
)
scalar_mul_impl!(Mat5,
m11, m12, m13, m14, m15,
m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35,
m41, m42, m43, m44, m45,
m51, m52, m53, m54, m55
)
scalar_div_impl!(Mat5,
m11, m12, m13, m14, m15, m11, m12, m13, m14, m15,
m21, m22, m23, m24, m25, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m31, m32, m33, m34, m35,
m41, m42, m43, m44, m45, m41, m42, m43, m44, m45,
m51, m52, m53, m54, m55 m51, m52, m53, m54, m55
) )
mat_mul_scalar_impl!(Mat5, f64, Mat5MulRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_mul_scalar_impl!(Mat5, f32, Mat5MulRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_mul_scalar_impl!(Mat5, i64, Mat5MulRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_mul_scalar_impl!(Mat5, i32, Mat5MulRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_mul_scalar_impl!(Mat5, i16, Mat5MulRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_mul_scalar_impl!(Mat5, i8, Mat5MulRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_mul_scalar_impl!(Mat5, u64, Mat5MulRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_mul_scalar_impl!(Mat5, u32, Mat5MulRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_mul_scalar_impl!(Mat5, u16, Mat5MulRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_mul_scalar_impl!(Mat5, u8, Mat5MulRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_mul_scalar_impl!(Mat5, uint, Mat5MulRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_mul_scalar_impl!(Mat5, int, Mat5MulRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_div_scalar_impl!(Mat5, f64, Mat5DivRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_div_scalar_impl!(Mat5, f32, Mat5DivRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_div_scalar_impl!(Mat5, i64, Mat5DivRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_div_scalar_impl!(Mat5, i32, Mat5DivRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_div_scalar_impl!(Mat5, i16, Mat5DivRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_div_scalar_impl!(Mat5, i8, Mat5DivRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_div_scalar_impl!(Mat5, u64, Mat5DivRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_div_scalar_impl!(Mat5, u32, Mat5DivRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_div_scalar_impl!(Mat5, u16, Mat5DivRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_div_scalar_impl!(Mat5, u8, Mat5DivRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_div_scalar_impl!(Mat5, uint, Mat5DivRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_div_scalar_impl!(Mat5, int, Mat5DivRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_add_scalar_impl!(Mat5, f64, Mat5AddRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_add_scalar_impl!(Mat5, f32, Mat5AddRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_add_scalar_impl!(Mat5, i64, Mat5AddRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_add_scalar_impl!(Mat5, i32, Mat5AddRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_add_scalar_impl!(Mat5, i16, Mat5AddRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_add_scalar_impl!(Mat5, i8, Mat5AddRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_add_scalar_impl!(Mat5, u64, Mat5AddRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_add_scalar_impl!(Mat5, u32, Mat5AddRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_add_scalar_impl!(Mat5, u16, Mat5AddRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_add_scalar_impl!(Mat5, u8, Mat5AddRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_add_scalar_impl!(Mat5, uint, Mat5AddRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_add_scalar_impl!(Mat5, int, Mat5AddRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_sub_scalar_impl!(Mat5, f64, Mat5SubRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_sub_scalar_impl!(Mat5, f32, Mat5SubRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_sub_scalar_impl!(Mat5, i64, Mat5SubRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_sub_scalar_impl!(Mat5, i32, Mat5SubRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_sub_scalar_impl!(Mat5, i16, Mat5SubRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_sub_scalar_impl!(Mat5, i8, Mat5SubRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_sub_scalar_impl!(Mat5, u64, Mat5SubRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_sub_scalar_impl!(Mat5, u32, Mat5SubRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_sub_scalar_impl!(Mat5, u16, Mat5SubRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_sub_scalar_impl!(Mat5, u8, Mat5SubRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_sub_scalar_impl!(Mat5, uint, Mat5SubRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
mat_sub_scalar_impl!(Mat5, int, Mat5SubRhs, m11, m12, m13, m14, m15, m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35, m41, m42, m43, m44, m45, m51, m52, m53, m54, m55)
iterable_impl!(Mat5, 5) iterable_impl!(Mat5, 5)
iterable_mut_impl!(Mat5, 5) iterable_mut_impl!(Mat5, 5)
dim_impl!(Mat5, 5) dim_impl!(Mat5, 5)
indexable_impl!(Mat5, 5) indexable_impl!(Mat5, 5)
index_impl!(Mat5, 5) index_impl!(Mat5, 5)
at_fast_impl!(Mat5, 5) at_fast_impl!(Mat5, 5)
mat_mul_mat_impl!(Mat5, Mat5MulRhs, 5) mat_mul_mat_impl!(Mat5, 5)
mat_mul_vec_impl!(Mat5, Vec5, Mat5MulRhs, 5, ::zero) mat_mul_vec_impl!(Mat5, Vec5, 5, ::zero)
vec_mul_mat_impl!(Mat5, Vec5, Vec5MulRhs, 5, ::zero) vec_mul_mat_impl!(Mat5, Vec5, 5, ::zero)
mat_mul_pnt_impl!(Mat5, Pnt5, Mat5MulRhs, 5, Orig::orig) mat_mul_pnt_impl!(Mat5, Pnt5, 5, Orig::orig)
pnt_mul_mat_impl!(Mat5, Pnt5, Pnt5MulRhs, 5, Orig::orig) pnt_mul_mat_impl!(Mat5, Pnt5, 5, Orig::orig)
inv_impl!(Mat5, 5) inv_impl!(Mat5, 5)
transpose_impl!(Mat5, 5) transpose_impl!(Mat5, 5)
approx_eq_impl!(Mat5) approx_eq_impl!(Mat5)
@ -751,16 +429,6 @@ pub struct Mat6<N> {
eye_impl!(Mat6, 6, m11, m22, m33, m44, m55, m66) eye_impl!(Mat6, 6, m11, m22, m33, m44, m55, m66)
double_dispatch_binop_decl_trait!(Mat6, Mat6MulRhs)
double_dispatch_binop_decl_trait!(Mat6, Mat6DivRhs)
double_dispatch_binop_decl_trait!(Mat6, Mat6AddRhs)
double_dispatch_binop_decl_trait!(Mat6, Mat6SubRhs)
double_dispatch_cast_decl_trait!(Mat6, Mat6Cast)
mul_redispatch_impl!(Mat6, Mat6MulRhs)
div_redispatch_impl!(Mat6, Mat6DivRhs)
add_redispatch_impl!(Mat6, Mat6AddRhs)
sub_redispatch_impl!(Mat6, Mat6SubRhs)
cast_redispatch_impl!(Mat6, Mat6Cast)
mat_impl!(Mat6, mat_impl!(Mat6,
m11, m12, m13, m14, m15, m16, m11, m12, m13, m14, m15, m16,
m21, m22, m23, m24, m25, m26, m21, m22, m23, m24, m25, m26,
@ -770,7 +438,7 @@ mat_impl!(Mat6,
m61, m62, m63, m64, m65, m66 m61, m62, m63, m64, m65, m66
) )
as_array_impl!(Mat6, 6) as_array_impl!(Mat6, 6)
mat_cast_impl!(Mat6, Mat6Cast, mat_cast_impl!(Mat6,
m11, m12, m13, m14, m15, m16, m11, m12, m13, m14, m15, m16,
m21, m22, m23, m24, m25, m26, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m31, m32, m33, m34, m35, m36,
@ -778,7 +446,7 @@ mat_cast_impl!(Mat6, Mat6Cast,
m51, m52, m53, m54, m55, m56, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66 m61, m62, m63, m64, m65, m66
) )
add_impl!(Mat6, Mat6AddRhs, add_impl!(Mat6,
m11, m12, m13, m14, m15, m16, m11, m12, m13, m14, m15, m16,
m21, m22, m23, m24, m25, m26, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m31, m32, m33, m34, m35, m36,
@ -786,7 +454,39 @@ add_impl!(Mat6, Mat6AddRhs,
m51, m52, m53, m54, m55, m56, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66 m61, m62, m63, m64, m65, m66
) )
sub_impl!(Mat6, Mat6SubRhs, sub_impl!(Mat6,
m11, m12, m13, m14, m15, m16,
m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36,
m41, m42, m43, m44, m45, m46,
m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66
)
scalar_add_impl!(Mat6,
m11, m12, m13, m14, m15, m16,
m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36,
m41, m42, m43, m44, m45, m46,
m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66
)
scalar_sub_impl!(Mat6,
m11, m12, m13, m14, m15, m16,
m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36,
m41, m42, m43, m44, m45, m46,
m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66
)
scalar_mul_impl!(Mat6,
m11, m12, m13, m14, m15, m16,
m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36,
m41, m42, m43, m44, m45, m46,
m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66
)
scalar_div_impl!(Mat6,
m11, m12, m13, m14, m15, m16, m11, m12, m13, m14, m15, m16,
m21, m22, m23, m24, m25, m26, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m31, m32, m33, m34, m35, m36,
@ -794,155 +494,6 @@ sub_impl!(Mat6, Mat6SubRhs,
m51, m52, m53, m54, m55, m56, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66 m61, m62, m63, m64, m65, m66
) )
mat_mul_scalar_impl!(Mat6, f64, Mat6MulRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_mul_scalar_impl!(Mat6, f32, Mat6MulRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_mul_scalar_impl!(Mat6, i64, Mat6MulRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_mul_scalar_impl!(Mat6, i32, Mat6MulRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_mul_scalar_impl!(Mat6, i16, Mat6MulRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_mul_scalar_impl!(Mat6, i8, Mat6MulRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_mul_scalar_impl!(Mat6, u64, Mat6MulRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_mul_scalar_impl!(Mat6, u32, Mat6MulRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_mul_scalar_impl!(Mat6, u16, Mat6MulRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_mul_scalar_impl!(Mat6, u8, Mat6MulRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_mul_scalar_impl!(Mat6, uint, Mat6MulRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_mul_scalar_impl!(Mat6, int, Mat6MulRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_div_scalar_impl!(Mat6, f64, Mat6DivRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_div_scalar_impl!(Mat6, f32, Mat6DivRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_div_scalar_impl!(Mat6, i64, Mat6DivRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_div_scalar_impl!(Mat6, i32, Mat6DivRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_div_scalar_impl!(Mat6, i16, Mat6DivRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_div_scalar_impl!(Mat6, i8, Mat6DivRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_div_scalar_impl!(Mat6, u64, Mat6DivRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_div_scalar_impl!(Mat6, u32, Mat6DivRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_div_scalar_impl!(Mat6, u16, Mat6DivRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_div_scalar_impl!(Mat6, u8, Mat6DivRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_div_scalar_impl!(Mat6, uint, Mat6DivRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_div_scalar_impl!(Mat6, int, Mat6DivRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_add_scalar_impl!(Mat6, f64, Mat6AddRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_add_scalar_impl!(Mat6, f32, Mat6AddRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_add_scalar_impl!(Mat6, i64, Mat6AddRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_add_scalar_impl!(Mat6, i32, Mat6AddRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_add_scalar_impl!(Mat6, i16, Mat6AddRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_add_scalar_impl!(Mat6, i8, Mat6AddRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_add_scalar_impl!(Mat6, u64, Mat6AddRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_add_scalar_impl!(Mat6, u32, Mat6AddRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_add_scalar_impl!(Mat6, u16, Mat6AddRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_add_scalar_impl!(Mat6, u8, Mat6AddRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_add_scalar_impl!(Mat6, uint, Mat6AddRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_add_scalar_impl!(Mat6, int, Mat6AddRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_sub_scalar_impl!(Mat6, f64, Mat6SubRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_sub_scalar_impl!(Mat6, f32, Mat6SubRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_sub_scalar_impl!(Mat6, i64, Mat6SubRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_sub_scalar_impl!(Mat6, i32, Mat6SubRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_sub_scalar_impl!(Mat6, i16, Mat6SubRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_sub_scalar_impl!(Mat6, i8, Mat6SubRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_sub_scalar_impl!(Mat6, u64, Mat6SubRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_sub_scalar_impl!(Mat6, u32, Mat6SubRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_sub_scalar_impl!(Mat6, u16, Mat6SubRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_sub_scalar_impl!(Mat6, u8, Mat6SubRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_sub_scalar_impl!(Mat6, uint, Mat6SubRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
mat_sub_scalar_impl!(Mat6, int, Mat6SubRhs, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66)
absolute_impl!(Mat6, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26, absolute_impl!(Mat6, m11, m12, m13, m14, m15, m16, m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56, m31, m32, m33, m34, m35, m36, m41, m42, m43, m44, m45, m46, m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66) m61, m62, m63, m64, m65, m66)
@ -965,11 +516,11 @@ dim_impl!(Mat6, 6)
indexable_impl!(Mat6, 6) indexable_impl!(Mat6, 6)
index_impl!(Mat6, 6) index_impl!(Mat6, 6)
at_fast_impl!(Mat6, 6) at_fast_impl!(Mat6, 6)
mat_mul_mat_impl!(Mat6, Mat6MulRhs, 6) mat_mul_mat_impl!(Mat6, 6)
mat_mul_vec_impl!(Mat6, Vec6, Mat6MulRhs, 6, ::zero) mat_mul_vec_impl!(Mat6, Vec6, 6, ::zero)
vec_mul_mat_impl!(Mat6, Vec6, Vec6MulRhs, 6, ::zero) vec_mul_mat_impl!(Mat6, Vec6, 6, ::zero)
mat_mul_pnt_impl!(Mat6, Pnt6, Mat6MulRhs, 6, Orig::orig) mat_mul_pnt_impl!(Mat6, Pnt6, 6, Orig::orig)
pnt_mul_mat_impl!(Mat6, Pnt6, Pnt6MulRhs, 6, Orig::orig) pnt_mul_mat_impl!(Mat6, Pnt6, 6, Orig::orig)
inv_impl!(Mat6, 6) inv_impl!(Mat6, 6)
transpose_impl!(Mat6, 6) transpose_impl!(Mat6, 6)
approx_eq_impl!(Mat6) approx_eq_impl!(Mat6)

90
src/structs/mat_macros.rs
View File

@ -76,10 +76,10 @@ macro_rules! at_fast_impl(
) )
macro_rules! mat_cast_impl( macro_rules! mat_cast_impl(
($t: ident, $tcast: ident, $comp0: ident $(,$compN: ident)*) => ( ($t: ident, $comp0: ident $(,$compN: ident)*) => (
impl<Nin: Clone, Nout: Clone + Cast<Nin>> $tcast<Nout> for $t<Nin> { impl<Nin: Clone, Nout: Clone + Cast<Nin>> Cast<$t<Nin>> for $t<Nout> {
#[inline] #[inline]
fn to(v: $t<Nin>) -> $t<Nout> { fn from(v: $t<Nin>) -> $t<Nout> {
$t::new(Cast::from(v.$comp0.clone()) $(, Cast::from(v.$compN.clone()))*) $t::new(Cast::from(v.$comp0.clone()) $(, Cast::from(v.$compN.clone()))*)
} }
} }
@ -87,55 +87,55 @@ macro_rules! mat_cast_impl(
) )
macro_rules! add_impl( macro_rules! add_impl(
($t: ident, $trhs: ident, $comp0: ident $(,$compN: ident)*) => ( ($t: ident, $comp0: ident $(,$compN: ident)*) => (
impl<N: Add<N, N>> $trhs<N, $t<N>> for $t<N> { impl<N: Add<N, N>> Add<$t<N>, $t<N>> for $t<N> {
#[inline] #[inline]
fn binop(left: &$t<N>, right: &$t<N>) -> $t<N> { fn add(&self, right: &$t<N>) -> $t<N> {
$t::new(left.$comp0 + right.$comp0 $(, left.$compN + right.$compN)*) $t::new(self.$comp0 + right.$comp0 $(, self.$compN + right.$compN)*)
} }
} }
) )
) )
macro_rules! sub_impl( macro_rules! sub_impl(
($t: ident, $trhs: ident, $comp0: ident $(,$compN: ident)*) => ( ($t: ident, $comp0: ident $(,$compN: ident)*) => (
impl<N: Sub<N, N>> $trhs<N, $t<N>> for $t<N> { impl<N: Sub<N, N>> Sub<$t<N>, $t<N>> for $t<N> {
#[inline] #[inline]
fn binop(left: &$t<N>, right: &$t<N>) -> $t<N> { fn sub(&self, right: &$t<N>) -> $t<N> {
$t::new(left.$comp0 - right.$comp0 $(, left.$compN - right.$compN)*) $t::new(self.$comp0 - right.$comp0 $(, self.$compN - right.$compN)*)
} }
} }
) )
) )
macro_rules! mat_mul_scalar_impl( macro_rules! mat_mul_scalar_impl(
($t: ident, $n: ident, $trhs: ident, $comp0: ident $(,$compN: ident)*) => ( ($t: ident, $comp0: ident $(,$compN: ident)*) => (
impl $trhs<$n, $t<$n>> for $n { impl<N: Mul<N, N>> Mul<N, $t<N>> for N {
#[inline] #[inline]
fn binop(left: &$t<$n>, right: &$n) -> $t<$n> { fn mul(&self, right: &N) -> $t<N> {
$t::new(left.$comp0 * *right $(, left.$compN * *right)*) $t::new(self.$comp0 * *right $(, self.$compN * *right)*)
} }
} }
) )
) )
macro_rules! mat_div_scalar_impl( macro_rules! mat_div_scalar_impl(
($t: ident, $n: ident, $trhs: ident, $comp0: ident $(,$compN: ident)*) => ( ($t: ident, $comp0: ident $(,$compN: ident)*) => (
impl $trhs<$n, $t<$n>> for $n { impl<N: Div<N, N>> Div<N, $t<N>> for $t<N> {
#[inline] #[inline]
fn binop(left: &$t<$n>, right: &$n) -> $t<$n> { fn div(&self, right: &N) -> $t<N> {
$t::new(left.$comp0 / *right $(, left.$compN / *right)*) $t::new(self.$comp0 / *right $(, self.$compN / *right)*)
} }
} }
) )
) )
macro_rules! mat_add_scalar_impl( macro_rules! mat_add_scalar_impl(
($t: ident, $n: ident, $trhs: ident, $comp0: ident $(,$compN: ident)*) => ( ($t: ident, $comp0: ident $(,$compN: ident)*) => (
impl $trhs<$n, $t<$n>> for $n { impl<N: Add<N, N>> Add<N, $t<N>> for $t<N> {
#[inline] #[inline]
fn binop(left: &$t<$n>, right: &$n) -> $t<$n> { fn add(&self, right: &N) -> $t<N> {
$t::new(left.$comp0 + *right $(, left.$compN + *right)*) $t::new(self.$comp0 + *right $(, self.$compN + *right)*)
} }
} }
) )
@ -143,10 +143,10 @@ macro_rules! mat_add_scalar_impl(
macro_rules! eye_impl( macro_rules! eye_impl(
($t: ident, $ndim: expr, $($comp_diagN: ident),+) => ( ($t: ident, $dim: expr, $($comp_diagN: ident),+) => (
impl<N: Zero + One> Eye for $t<N> { impl<N: Zero + One> Eye for $t<N> {
fn new_identity(dim: uint) -> $t<N> { fn new_identity(dim: uint) -> $t<N> {
assert!(dim == $ndim); assert!(dim == $dim);
let mut eye: $t<N> = ::zero(); let mut eye: $t<N> = ::zero();
$(eye.$comp_diagN = ::one();)+ $(eye.$comp_diagN = ::one();)+
eye eye
@ -156,11 +156,11 @@ macro_rules! eye_impl(
) )
macro_rules! mat_sub_scalar_impl( macro_rules! mat_sub_scalar_impl(
($t: ident, $n: ident, $trhs: ident, $comp0: ident $(,$compN: ident)*) => ( ($t: ident, $comp0: ident $(,$compN: ident)*) => (
impl $trhs<$n, $t<$n>> for $n { impl<N: Sub<N, N> Sub<N, $t<N>> for $t<N> {
#[inline] #[inline]
fn binop(left: &$t<$n>, right: &$n) -> $t<$n> { fn sub(self, right: &N) -> $t<N> {
$t::new(left.$comp0 - *right $(, left.$compN - *right)*) $t::new(self.$comp0 - *right $(, self.$compN - *right)*)
} }
} }
) )
@ -425,10 +425,10 @@ macro_rules! diag_impl(
) )
macro_rules! mat_mul_mat_impl( macro_rules! mat_mul_mat_impl(
($t: ident, $trhs: ident, $dim: expr) => ( ($t: ident, $dim: expr) => (
impl<N: Clone + BaseNum> $trhs<N, $t<N>> for $t<N> { impl<N: Clone + BaseNum> Mul<$t<N>, $t<N>> for $t<N> {
#[inline] #[inline]
fn binop(left: &$t<N>, right: &$t<N>) -> $t<N> { fn mul(&self, right: &$t<N>) -> $t<N> {
// careful! we need to comute other * self here (self is the rhs). // careful! we need to comute other * self here (self is the rhs).
let mut res: $t<N> = ::zero(); let mut res: $t<N> = ::zero();
@ -438,7 +438,7 @@ macro_rules! mat_mul_mat_impl(
unsafe { unsafe {
for k in range(0u, $dim) { for k in range(0u, $dim) {
acc = acc + left.at_fast((i, k)) * right.at_fast((k, j)); acc = acc + self.at_fast((i, k)) * right.at_fast((k, j));
} }
res.set_fast((i, j), acc); res.set_fast((i, j), acc);
@ -453,16 +453,16 @@ macro_rules! mat_mul_mat_impl(
) )
macro_rules! vec_mul_mat_impl( macro_rules! vec_mul_mat_impl(
($t: ident, $v: ident, $trhs: ident, $dim: expr, $zero: expr) => ( ($t: ident, $v: ident, $dim: expr, $zero: expr) => (
impl<N: Clone + BaseNum> $trhs<N, $v<N>> for $t<N> { impl<N: Clone + BaseNum> Mul<$t<N>, $v<N>> for $v<N> {
#[inline] #[inline]
fn binop(left: &$v<N>, right: &$t<N>) -> $v<N> { fn mul(&self, right: &$t<N>) -> $v<N> {
let mut res : $v<N> = $zero(); let mut res : $v<N> = $zero();
for i in range(0u, $dim) { for i in range(0u, $dim) {
for j in range(0u, $dim) { for j in range(0u, $dim) {
unsafe { unsafe {
let val = res.at_fast(i) + left.at_fast(j) * right.at_fast((j, i)); let val = res.at_fast(i) + self.at_fast(j) * right.at_fast((j, i));
res.set_fast(i, val) res.set_fast(i, val)
} }
} }
@ -475,16 +475,16 @@ macro_rules! vec_mul_mat_impl(
) )
macro_rules! mat_mul_vec_impl( macro_rules! mat_mul_vec_impl(
($t: ident, $v: ident, $trhs: ident, $dim: expr, $zero: expr) => ( ($t: ident, $v: ident, $dim: expr, $zero: expr) => (
impl<N: Clone + BaseNum> $trhs<N, $v<N>> for $v<N> { impl<N: Clone + BaseNum> Mul<$v<N>, $v<N>> for $t<N> {
#[inline] #[inline]
fn binop(left: &$t<N>, right: &$v<N>) -> $v<N> { fn mul(&self, right: &$v<N>) -> $v<N> {
let mut res : $v<N> = $zero(); let mut res : $v<N> = $zero();
for i in range(0u, $dim) { for i in range(0u, $dim) {
for j in range(0u, $dim) { for j in range(0u, $dim) {
unsafe { unsafe {
let val = res.at_fast(i) + left.at_fast((i, j)) * right.at_fast(j); let val = res.at_fast(i) + self.at_fast((i, j)) * right.at_fast(j);
res.set_fast(i, val) res.set_fast(i, val)
} }
} }
@ -497,14 +497,14 @@ macro_rules! mat_mul_vec_impl(
) )
macro_rules! pnt_mul_mat_impl( macro_rules! pnt_mul_mat_impl(
($t: ident, $v: ident, $trhs: ident, $dim: expr, $zero: expr) => ( ($t: ident, $v: ident, $dim: expr, $zero: expr) => (
vec_mul_mat_impl!($t, $v, $trhs, $dim, $zero) vec_mul_mat_impl!($t, $v, $dim, $zero)
) )
) )
macro_rules! mat_mul_pnt_impl( macro_rules! mat_mul_pnt_impl(
($t: ident, $v: ident, $trhs: ident, $dim: expr, $zero: expr) => ( ($t: ident, $v: ident, $dim: expr, $zero: expr) => (
mat_mul_vec_impl!($t, $v, $trhs, $dim, $zero) mat_mul_vec_impl!($t, $v, $dim, $zero)
) )
) )

88
src/structs/metal.rs
View File

@ -1,88 +0,0 @@
#![macro_escape]
#![doc(hidden)] // we hide doc to not have to document the $trhs double dispatch trait.
// Create the traits needed to do fancy operator oveloading.
// This is a meta version of
// http://smallcultfollowing.com/babysteps/blog/2012/10/04/refining-traits-slash-impls/
//
// Hopefully future version of the language will make this useless.
macro_rules! double_dispatch_binop_decl_trait(
($t: ident, $trhs: ident) => (
pub trait $trhs<N, Res> {
/// Applies the binary operation represented by this trait.
///
/// In infix notation, assuming the operation is noted `*`, the following is computed:
/// `right * left`.
fn binop(left: &$t<N>, right: &Self) -> Res;
}
)
)
// Macro driving the `Mul` trait to use the related trait for double redispatch.
macro_rules! mul_redispatch_impl(
($t: ident, $trhs: ident) => (
impl<N, Rhs: $trhs<N, Res>, Res> Mul<Rhs, Res> for $t<N> {
#[inline(always)]
fn mul(&self, other: &Rhs) -> Res {
$trhs::binop(self, other)
}
}
)
)
// Macro driving the `Div` trait to use the related trait for double redispatch.
macro_rules! div_redispatch_impl(
($t: ident, $trhs: ident) => (
impl<N, Rhs: $trhs<N, Res>, Res> Div<Rhs, Res> for $t<N> {
#[inline(always)]
fn div(&self, other: &Rhs) -> Res {
$trhs::binop(self, other)
}
}
)
)
// Macro driving the `Add` trait to use the related trait for double redispatch.
macro_rules! add_redispatch_impl(
($t: ident, $trhs: ident) => (
impl<N, Rhs: $trhs<N, Res>, Res> Add<Rhs, Res> for $t<N> {
#[inline(always)]
fn add(&self, other: &Rhs) -> Res {
$trhs::binop(self, other)
}
}
)
)
// Macro driving the `Sub` trait to use the related trait for double redispatch.
macro_rules! sub_redispatch_impl(
($t: ident, $trhs: ident) => (
impl<N, Rhs: $trhs<N, Res>, Res> Sub<Rhs, Res> for $t<N> {
#[inline(always)]
fn sub(&self, other: &Rhs) -> Res {
$trhs::binop(self, other)
}
}
)
)
// Double dispatch traits to drive the Cast method for structured types with one type parameter.
macro_rules! double_dispatch_cast_decl_trait(
($t: ident, $tcast: ident) => (
pub trait $tcast<N> {
fn to(Self) -> $t<N>;
}
)
)
macro_rules! cast_redispatch_impl(
($t:ident, $tcast: ident) => (
impl<T: $tcast<N>, N> Cast<T> for $t<N> {
#[inline(always)]
fn from(t: T) -> $t<N> {
$tcast::to(t)
}
}
)
)

14
src/structs/mod.rs
View File

@ -11,20 +11,6 @@ pub use self::persp::{Persp3, PerspMat3};
pub use self::ortho::{Ortho3, OrthoMat3}; pub use self::ortho::{Ortho3, OrthoMat3};
pub use self::quat::{Quat, UnitQuat}; pub use self::quat::{Quat, UnitQuat};
pub use self::vec::{Vec1MulRhs, Vec2MulRhs, Vec3MulRhs, Vec4MulRhs, Vec5MulRhs, Vec6MulRhs,
Vec1DivRhs, Vec2DivRhs, Vec3DivRhs, Vec4DivRhs, Vec5DivRhs, Vec6DivRhs,
Vec1AddRhs, Vec2AddRhs, Vec3AddRhs, Vec4AddRhs, Vec5AddRhs, Vec6AddRhs,
Vec1SubRhs, Vec2SubRhs, Vec3SubRhs, Vec4SubRhs, Vec5SubRhs, Vec6SubRhs};
pub use self::pnt::{Pnt1MulRhs, Pnt2MulRhs, Pnt3MulRhs, Pnt4MulRhs, Pnt5MulRhs, Pnt6MulRhs,
Pnt1DivRhs, Pnt2DivRhs, Pnt3DivRhs, Pnt4DivRhs, Pnt5DivRhs, Pnt6DivRhs,
Pnt1AddRhs, Pnt2AddRhs, Pnt3AddRhs, Pnt4AddRhs, Pnt5AddRhs, Pnt6AddRhs,
Pnt1SubRhs, Pnt2SubRhs, Pnt3SubRhs, Pnt4SubRhs, Pnt5SubRhs, Pnt6SubRhs};
pub use self::mat::{Mat1MulRhs, Mat2MulRhs, Mat3MulRhs, Mat4MulRhs, Mat5MulRhs, Mat6MulRhs,
Mat1DivRhs, Mat2DivRhs, Mat3DivRhs, Mat4DivRhs, Mat5DivRhs, Mat6DivRhs,
Mat1AddRhs, Mat2AddRhs, Mat3AddRhs, Mat4AddRhs, Mat5AddRhs, Mat6AddRhs,
Mat1SubRhs, Mat2SubRhs, Mat3SubRhs, Mat4SubRhs, Mat5SubRhs, Mat6SubRhs};
mod metal;
mod dmat; mod dmat;
mod dvec_macros; mod dvec_macros;
mod dvec; mod dvec;

432
src/structs/pnt.rs
View File

@ -38,20 +38,14 @@ pub struct Pnt1<N> {
pub x: N pub x: N
} }
double_dispatch_binop_decl_trait!(Pnt1, Pnt1MulRhs)
double_dispatch_binop_decl_trait!(Pnt1, Pnt1DivRhs)
double_dispatch_binop_decl_trait!(Pnt1, Pnt1AddRhs)
double_dispatch_binop_decl_trait!(Pnt1, Pnt1SubRhs)
double_dispatch_cast_decl_trait!(Pnt1, Pnt1Cast)
mul_redispatch_impl!(Pnt1, Pnt1MulRhs)
div_redispatch_impl!(Pnt1, Pnt1DivRhs)
add_redispatch_impl!(Pnt1, Pnt1AddRhs)
sub_redispatch_impl!(Pnt1, Pnt1SubRhs)
cast_redispatch_impl!(Pnt1, Pnt1Cast)
new_impl!(Pnt1, x) new_impl!(Pnt1, x)
orig_impl!(Pnt1, x) orig_impl!(Pnt1, x)
ord_impl!(Pnt1, x) ord_impl!(Pnt1, x)
vec_cast_impl!(Pnt1, Pnt1Cast, x) scalar_mul_impl!(Pnt1, x)
scalar_div_impl!(Pnt1, x)
scalar_add_impl!(Pnt1, x)
scalar_sub_impl!(Pnt1, x)
vec_cast_impl!(Pnt1, x)
as_array_impl!(Pnt1, 1) as_array_impl!(Pnt1, 1)
index_impl!(Pnt1) index_impl!(Pnt1)
indexable_impl!(Pnt1, 1) indexable_impl!(Pnt1, 1)
@ -60,59 +54,11 @@ new_repeat_impl!(Pnt1, val, x)
dim_impl!(Pnt1, 1) dim_impl!(Pnt1, 1)
container_impl!(Pnt1) container_impl!(Pnt1)
pnt_as_vec_impl!(Pnt1, Vec1, x) pnt_as_vec_impl!(Pnt1, Vec1, x)
pnt_sub_impl!(Pnt1, Vec1, Pnt1SubRhs) pnt_sub_impl!(Pnt1, Vec1)
neg_impl!(Pnt1, x) neg_impl!(Pnt1, x)
pnt_add_vec_impl!(Pnt1, Vec1, Pnt1AddRhs, x) pnt_add_vec_impl!(Pnt1, Vec1, x)
pnt_sub_vec_impl!(Pnt1, Vec1, Pnt1SubRhs, x) pnt_sub_vec_impl!(Pnt1, Vec1, x)
scalar_ops_impl!(Pnt1, x) scalar_ops_impl!(Pnt1, x)
vec_mul_scalar_impl!(Pnt1, f64, Pnt1MulRhs, x)
vec_mul_scalar_impl!(Pnt1, f32, Pnt1MulRhs, x)
vec_mul_scalar_impl!(Pnt1, u64, Pnt1MulRhs, x)
vec_mul_scalar_impl!(Pnt1, u32, Pnt1MulRhs, x)
vec_mul_scalar_impl!(Pnt1, u16, Pnt1MulRhs, x)
vec_mul_scalar_impl!(Pnt1, u8, Pnt1MulRhs, x)
vec_mul_scalar_impl!(Pnt1, i64, Pnt1MulRhs, x)
vec_mul_scalar_impl!(Pnt1, i32, Pnt1MulRhs, x)
vec_mul_scalar_impl!(Pnt1, i16, Pnt1MulRhs, x)
vec_mul_scalar_impl!(Pnt1, i8, Pnt1MulRhs, x)
vec_mul_scalar_impl!(Pnt1, uint, Pnt1MulRhs, x)
vec_mul_scalar_impl!(Pnt1, int, Pnt1MulRhs, x)
vec_div_scalar_impl!(Pnt1, f64, Pnt1DivRhs, x)
vec_div_scalar_impl!(Pnt1, f32, Pnt1DivRhs, x)
vec_div_scalar_impl!(Pnt1, u64, Pnt1DivRhs, x)
vec_div_scalar_impl!(Pnt1, u32, Pnt1DivRhs, x)
vec_div_scalar_impl!(Pnt1, u16, Pnt1DivRhs, x)
vec_div_scalar_impl!(Pnt1, u8, Pnt1DivRhs, x)
vec_div_scalar_impl!(Pnt1, i64, Pnt1DivRhs, x)
vec_div_scalar_impl!(Pnt1, i32, Pnt1DivRhs, x)
vec_div_scalar_impl!(Pnt1, i16, Pnt1DivRhs, x)
vec_div_scalar_impl!(Pnt1, i8, Pnt1DivRhs, x)
vec_div_scalar_impl!(Pnt1, uint, Pnt1DivRhs, x)
vec_div_scalar_impl!(Pnt1, int, Pnt1DivRhs, x)
vec_add_scalar_impl!(Pnt1, f64, Pnt1AddRhs, x)
vec_add_scalar_impl!(Pnt1, f32, Pnt1AddRhs, x)
vec_add_scalar_impl!(Pnt1, u64, Pnt1AddRhs, x)
vec_add_scalar_impl!(Pnt1, u32, Pnt1AddRhs, x)
vec_add_scalar_impl!(Pnt1, u16, Pnt1AddRhs, x)
vec_add_scalar_impl!(Pnt1, u8, Pnt1AddRhs, x)
vec_add_scalar_impl!(Pnt1, i64, Pnt1AddRhs, x)
vec_add_scalar_impl!(Pnt1, i32, Pnt1AddRhs, x)
vec_add_scalar_impl!(Pnt1, i16, Pnt1AddRhs, x)
vec_add_scalar_impl!(Pnt1, i8, Pnt1AddRhs, x)
vec_add_scalar_impl!(Pnt1, uint, Pnt1AddRhs, x)
vec_add_scalar_impl!(Pnt1, int, Pnt1AddRhs, x)
vec_sub_scalar_impl!(Pnt1, f64, Pnt1SubRhs, x)
vec_sub_scalar_impl!(Pnt1, f32, Pnt1SubRhs, x)
vec_sub_scalar_impl!(Pnt1, u64, Pnt1SubRhs, x)
vec_sub_scalar_impl!(Pnt1, u32, Pnt1SubRhs, x)
vec_sub_scalar_impl!(Pnt1, u16, Pnt1SubRhs, x)
vec_sub_scalar_impl!(Pnt1, u8, Pnt1SubRhs, x)
vec_sub_scalar_impl!(Pnt1, i64, Pnt1SubRhs, x)
vec_sub_scalar_impl!(Pnt1, i32, Pnt1SubRhs, x)
vec_sub_scalar_impl!(Pnt1, i16, Pnt1SubRhs, x)
vec_sub_scalar_impl!(Pnt1, i8, Pnt1SubRhs, x)
vec_sub_scalar_impl!(Pnt1, uint, Pnt1SubRhs, x)
vec_sub_scalar_impl!(Pnt1, int, Pnt1SubRhs, x)
approx_eq_impl!(Pnt1, x) approx_eq_impl!(Pnt1, x)
from_iterator_impl!(Pnt1, iterator) from_iterator_impl!(Pnt1, iterator)
bounded_impl!(Pnt1, x) bounded_impl!(Pnt1, x)
@ -121,7 +67,7 @@ iterable_impl!(Pnt1, 1)
iterable_mut_impl!(Pnt1, 1) iterable_mut_impl!(Pnt1, 1)
pnt_to_homogeneous_impl!(Pnt1, Pnt2, y, x) pnt_to_homogeneous_impl!(Pnt1, Pnt2, y, x)
pnt_from_homogeneous_impl!(Pnt1, Pnt2, y, x) pnt_from_homogeneous_impl!(Pnt1, Pnt2, y, x)
num_float_pnt_impl!(Pnt1, Vec1, Pnt1MulRhs, Pnt1DivRhs) num_float_pnt_impl!(Pnt1, Vec1)
/// Point of dimension 2. /// Point of dimension 2.
#[deriving(Eq, PartialEq, Encodable, Decodable, Clone, Hash, Rand, Show)] #[deriving(Eq, PartialEq, Encodable, Decodable, Clone, Hash, Rand, Show)]
@ -132,20 +78,14 @@ pub struct Pnt2<N> {
pub y: N pub y: N
} }
double_dispatch_binop_decl_trait!(Pnt2, Pnt2MulRhs)
double_dispatch_binop_decl_trait!(Pnt2, Pnt2DivRhs)
double_dispatch_binop_decl_trait!(Pnt2, Pnt2AddRhs)
double_dispatch_binop_decl_trait!(Pnt2, Pnt2SubRhs)
double_dispatch_cast_decl_trait!(Pnt2, Pnt2Cast)
mul_redispatch_impl!(Pnt2, Pnt2MulRhs)
div_redispatch_impl!(Pnt2, Pnt2DivRhs)
add_redispatch_impl!(Pnt2, Pnt2AddRhs)
sub_redispatch_impl!(Pnt2, Pnt2SubRhs)
cast_redispatch_impl!(Pnt2, Pnt2Cast)
new_impl!(Pnt2, x, y) new_impl!(Pnt2, x, y)
orig_impl!(Pnt2, x, y) orig_impl!(Pnt2, x, y)
ord_impl!(Pnt2, x, y) ord_impl!(Pnt2, x, y)
vec_cast_impl!(Pnt2, Pnt2Cast, x, y) scalar_mul_impl!(Pnt2, x, y)
scalar_div_impl!(Pnt2, x, y)
scalar_add_impl!(Pnt2, x, y)
scalar_sub_impl!(Pnt2, x, y)
vec_cast_impl!(Pnt2, x, y)
as_array_impl!(Pnt2, 2) as_array_impl!(Pnt2, 2)
index_impl!(Pnt2) index_impl!(Pnt2)
indexable_impl!(Pnt2, 2) indexable_impl!(Pnt2, 2)
@ -154,59 +94,11 @@ new_repeat_impl!(Pnt2, val, x, y)
dim_impl!(Pnt2, 2) dim_impl!(Pnt2, 2)
container_impl!(Pnt2) container_impl!(Pnt2)
pnt_as_vec_impl!(Pnt2, Vec2, x, y) pnt_as_vec_impl!(Pnt2, Vec2, x, y)
pnt_sub_impl!(Pnt2, Vec2, Pnt2SubRhs) pnt_sub_impl!(Pnt2, Vec2)
neg_impl!(Pnt2, x, y) neg_impl!(Pnt2, x, y)
pnt_add_vec_impl!(Pnt2, Vec2, Pnt2AddRhs, x, y) pnt_add_vec_impl!(Pnt2, Vec2, x, y)
pnt_sub_vec_impl!(Pnt2, Vec2, Pnt2SubRhs, x, y) pnt_sub_vec_impl!(Pnt2, Vec2, x, y)
scalar_ops_impl!(Pnt2, x, y) scalar_ops_impl!(Pnt2, x, y)
vec_mul_scalar_impl!(Pnt2, f64, Pnt2MulRhs, x, y)
vec_mul_scalar_impl!(Pnt2, f32, Pnt2MulRhs, x, y)
vec_mul_scalar_impl!(Pnt2, u64, Pnt2MulRhs, x, y)
vec_mul_scalar_impl!(Pnt2, u32, Pnt2MulRhs, x, y)
vec_mul_scalar_impl!(Pnt2, u16, Pnt2MulRhs, x, y)
vec_mul_scalar_impl!(Pnt2, u8, Pnt2MulRhs, x, y)
vec_mul_scalar_impl!(Pnt2, i64, Pnt2MulRhs, x, y)
vec_mul_scalar_impl!(Pnt2, i32, Pnt2MulRhs, x, y)
vec_mul_scalar_impl!(Pnt2, i16, Pnt2MulRhs, x, y)
vec_mul_scalar_impl!(Pnt2, i8, Pnt2MulRhs, x, y)
vec_mul_scalar_impl!(Pnt2, uint, Pnt2MulRhs, x, y)
vec_mul_scalar_impl!(Pnt2, int, Pnt2MulRhs, x, y)
vec_div_scalar_impl!(Pnt2, f64, Pnt2DivRhs, x, y)
vec_div_scalar_impl!(Pnt2, f32, Pnt2DivRhs, x, y)
vec_div_scalar_impl!(Pnt2, u64, Pnt2DivRhs, x, y)
vec_div_scalar_impl!(Pnt2, u32, Pnt2DivRhs, x, y)
vec_div_scalar_impl!(Pnt2, u16, Pnt2DivRhs, x, y)
vec_div_scalar_impl!(Pnt2, u8, Pnt2DivRhs, x, y)
vec_div_scalar_impl!(Pnt2, i64, Pnt2DivRhs, x, y)
vec_div_scalar_impl!(Pnt2, i32, Pnt2DivRhs, x, y)
vec_div_scalar_impl!(Pnt2, i16, Pnt2DivRhs, x, y)
vec_div_scalar_impl!(Pnt2, i8, Pnt2DivRhs, x, y)
vec_div_scalar_impl!(Pnt2, uint, Pnt2DivRhs, x, y)
vec_div_scalar_impl!(Pnt2, int, Pnt2DivRhs, x, y)
vec_add_scalar_impl!(Pnt2, f64, Pnt2AddRhs, x, y)
vec_add_scalar_impl!(Pnt2, f32, Pnt2AddRhs, x, y)
vec_add_scalar_impl!(Pnt2, u64, Pnt2AddRhs, x, y)
vec_add_scalar_impl!(Pnt2, u32, Pnt2AddRhs, x, y)
vec_add_scalar_impl!(Pnt2, u16, Pnt2AddRhs, x, y)
vec_add_scalar_impl!(Pnt2, u8, Pnt2AddRhs, x, y)
vec_add_scalar_impl!(Pnt2, i64, Pnt2AddRhs, x, y)
vec_add_scalar_impl!(Pnt2, i32, Pnt2AddRhs, x, y)
vec_add_scalar_impl!(Pnt2, i16, Pnt2AddRhs, x, y)
vec_add_scalar_impl!(Pnt2, i8, Pnt2AddRhs, x, y)
vec_add_scalar_impl!(Pnt2, uint, Pnt2AddRhs, x, y)
vec_add_scalar_impl!(Pnt2, int, Pnt2AddRhs, x, y)
vec_sub_scalar_impl!(Pnt2, f64, Pnt2SubRhs, x, y)
vec_sub_scalar_impl!(Pnt2, f32, Pnt2SubRhs, x, y)
vec_sub_scalar_impl!(Pnt2, u64, Pnt2SubRhs, x, y)
vec_sub_scalar_impl!(Pnt2, u32, Pnt2SubRhs, x, y)
vec_sub_scalar_impl!(Pnt2, u16, Pnt2SubRhs, x, y)
vec_sub_scalar_impl!(Pnt2, u8, Pnt2SubRhs, x, y)
vec_sub_scalar_impl!(Pnt2, i64, Pnt2SubRhs, x, y)
vec_sub_scalar_impl!(Pnt2, i32, Pnt2SubRhs, x, y)
vec_sub_scalar_impl!(Pnt2, i16, Pnt2SubRhs, x, y)
vec_sub_scalar_impl!(Pnt2, i8, Pnt2SubRhs, x, y)
vec_sub_scalar_impl!(Pnt2, uint, Pnt2SubRhs, x, y)
vec_sub_scalar_impl!(Pnt2, int, Pnt2SubRhs, x, y)
approx_eq_impl!(Pnt2, x, y) approx_eq_impl!(Pnt2, x, y)
from_iterator_impl!(Pnt2, iterator, iterator) from_iterator_impl!(Pnt2, iterator, iterator)
bounded_impl!(Pnt2, x, y) bounded_impl!(Pnt2, x, y)
@ -215,7 +107,7 @@ iterable_impl!(Pnt2, 2)
iterable_mut_impl!(Pnt2, 2) iterable_mut_impl!(Pnt2, 2)
pnt_to_homogeneous_impl!(Pnt2, Pnt3, z, x, y) pnt_to_homogeneous_impl!(Pnt2, Pnt3, z, x, y)
pnt_from_homogeneous_impl!(Pnt2, Pnt3, z, x, y) pnt_from_homogeneous_impl!(Pnt2, Pnt3, z, x, y)
num_float_pnt_impl!(Pnt2, Vec2, Pnt2MulRhs, Pnt2DivRhs) num_float_pnt_impl!(Pnt2, Vec2)
/// Point of dimension 3. /// Point of dimension 3.
#[deriving(Eq, PartialEq, Encodable, Decodable, Clone, Hash, Rand, Show)] #[deriving(Eq, PartialEq, Encodable, Decodable, Clone, Hash, Rand, Show)]
@ -228,20 +120,14 @@ pub struct Pnt3<N> {
pub z: N pub z: N
} }
double_dispatch_binop_decl_trait!(Pnt3, Pnt3MulRhs)
double_dispatch_binop_decl_trait!(Pnt3, Pnt3DivRhs)
double_dispatch_binop_decl_trait!(Pnt3, Pnt3AddRhs)
double_dispatch_binop_decl_trait!(Pnt3, Pnt3SubRhs)
double_dispatch_cast_decl_trait!(Pnt3, Pnt3Cast)
mul_redispatch_impl!(Pnt3, Pnt3MulRhs)
div_redispatch_impl!(Pnt3, Pnt3DivRhs)
add_redispatch_impl!(Pnt3, Pnt3AddRhs)
sub_redispatch_impl!(Pnt3, Pnt3SubRhs)
cast_redispatch_impl!(Pnt3, Pnt3Cast)
new_impl!(Pnt3, x, y, z) new_impl!(Pnt3, x, y, z)
orig_impl!(Pnt3, x, y, z) orig_impl!(Pnt3, x, y, z)
ord_impl!(Pnt3, x, y, z) ord_impl!(Pnt3, x, y, z)
vec_cast_impl!(Pnt3, Pnt3Cast, x, y, z) scalar_mul_impl!(Pnt3, x, y, z)
scalar_div_impl!(Pnt3, x, y, z)
scalar_add_impl!(Pnt3, x, y, z)
scalar_sub_impl!(Pnt3, x, y, z)
vec_cast_impl!(Pnt3, x, y, z)
as_array_impl!(Pnt3, 3) as_array_impl!(Pnt3, 3)
index_impl!(Pnt3) index_impl!(Pnt3)
indexable_impl!(Pnt3, 3) indexable_impl!(Pnt3, 3)
@ -250,59 +136,11 @@ new_repeat_impl!(Pnt3, val, x, y, z)
dim_impl!(Pnt3, 3) dim_impl!(Pnt3, 3)
container_impl!(Pnt3) container_impl!(Pnt3)
pnt_as_vec_impl!(Pnt3, Vec3, x, y, z) pnt_as_vec_impl!(Pnt3, Vec3, x, y, z)
pnt_sub_impl!(Pnt3, Vec3, Pnt3SubRhs) pnt_sub_impl!(Pnt3, Vec3)
neg_impl!(Pnt3, x, y, z) neg_impl!(Pnt3, x, y, z)
pnt_add_vec_impl!(Pnt3, Vec3, Pnt3AddRhs, x, y, z) pnt_add_vec_impl!(Pnt3, Vec3, x, y, z)
pnt_sub_vec_impl!(Pnt3, Vec3, Pnt3SubRhs, x, y, z) pnt_sub_vec_impl!(Pnt3, Vec3, x, y, z)
scalar_ops_impl!(Pnt3, x, y, z) scalar_ops_impl!(Pnt3, x, y, z)
vec_mul_scalar_impl!(Pnt3, f64, Pnt3MulRhs, x, y, z)
vec_mul_scalar_impl!(Pnt3, f32, Pnt3MulRhs, x, y, z)
vec_mul_scalar_impl!(Pnt3, u64, Pnt3MulRhs, x, y, z)
vec_mul_scalar_impl!(Pnt3, u32, Pnt3MulRhs, x, y, z)
vec_mul_scalar_impl!(Pnt3, u16, Pnt3MulRhs, x, y, z)
vec_mul_scalar_impl!(Pnt3, u8, Pnt3MulRhs, x, y, z)
vec_mul_scalar_impl!(Pnt3, i64, Pnt3MulRhs, x, y, z)
vec_mul_scalar_impl!(Pnt3, i32, Pnt3MulRhs, x, y, z)
vec_mul_scalar_impl!(Pnt3, i16, Pnt3MulRhs, x, y, z)
vec_mul_scalar_impl!(Pnt3, i8, Pnt3MulRhs, x, y, z)
vec_mul_scalar_impl!(Pnt3, uint, Pnt3MulRhs, x, y, z)
vec_mul_scalar_impl!(Pnt3, int, Pnt3MulRhs, x, y, z)
vec_div_scalar_impl!(Pnt3, f64, Pnt3DivRhs, x, y, z)
vec_div_scalar_impl!(Pnt3, f32, Pnt3DivRhs, x, y, z)
vec_div_scalar_impl!(Pnt3, u64, Pnt3DivRhs, x, y, z)
vec_div_scalar_impl!(Pnt3, u32, Pnt3DivRhs, x, y, z)
vec_div_scalar_impl!(Pnt3, u16, Pnt3DivRhs, x, y, z)
vec_div_scalar_impl!(Pnt3, u8, Pnt3DivRhs, x, y, z)
vec_div_scalar_impl!(Pnt3, i64, Pnt3DivRhs, x, y, z)
vec_div_scalar_impl!(Pnt3, i32, Pnt3DivRhs, x, y, z)
vec_div_scalar_impl!(Pnt3, i16, Pnt3DivRhs, x, y, z)
vec_div_scalar_impl!(Pnt3, i8, Pnt3DivRhs, x, y, z)
vec_div_scalar_impl!(Pnt3, uint, Pnt3DivRhs, x, y, z)
vec_div_scalar_impl!(Pnt3, int, Pnt3DivRhs, x, y, z)
vec_add_scalar_impl!(Pnt3, f64, Pnt3AddRhs, x, y, z)
vec_add_scalar_impl!(Pnt3, f32, Pnt3AddRhs, x, y, z)
vec_add_scalar_impl!(Pnt3, u64, Pnt3AddRhs, x, y, z)
vec_add_scalar_impl!(Pnt3, u32, Pnt3AddRhs, x, y, z)
vec_add_scalar_impl!(Pnt3, u16, Pnt3AddRhs, x, y, z)
vec_add_scalar_impl!(Pnt3, u8, Pnt3AddRhs, x, y, z)
vec_add_scalar_impl!(Pnt3, i64, Pnt3AddRhs, x, y, z)
vec_add_scalar_impl!(Pnt3, i32, Pnt3AddRhs, x, y, z)
vec_add_scalar_impl!(Pnt3, i16, Pnt3AddRhs, x, y, z)
vec_add_scalar_impl!(Pnt3, i8, Pnt3AddRhs, x, y, z)
vec_add_scalar_impl!(Pnt3, uint, Pnt3AddRhs, x, y, z)
vec_add_scalar_impl!(Pnt3, int, Pnt3AddRhs, x, y, z)
vec_sub_scalar_impl!(Pnt3, f64, Pnt3SubRhs, x, y, z)
vec_sub_scalar_impl!(Pnt3, f32, Pnt3SubRhs, x, y, z)
vec_sub_scalar_impl!(Pnt3, u64, Pnt3SubRhs, x, y, z)
vec_sub_scalar_impl!(Pnt3, u32, Pnt3SubRhs, x, y, z)
vec_sub_scalar_impl!(Pnt3, u16, Pnt3SubRhs, x, y, z)
vec_sub_scalar_impl!(Pnt3, u8, Pnt3SubRhs, x, y, z)
vec_sub_scalar_impl!(Pnt3, i64, Pnt3SubRhs, x, y, z)
vec_sub_scalar_impl!(Pnt3, i32, Pnt3SubRhs, x, y, z)
vec_sub_scalar_impl!(Pnt3, i16, Pnt3SubRhs, x, y, z)
vec_sub_scalar_impl!(Pnt3, i8, Pnt3SubRhs, x, y, z)
vec_sub_scalar_impl!(Pnt3, uint, Pnt3SubRhs, x, y, z)
vec_sub_scalar_impl!(Pnt3, int, Pnt3SubRhs, x, y, z)
approx_eq_impl!(Pnt3, x, y, z) approx_eq_impl!(Pnt3, x, y, z)
from_iterator_impl!(Pnt3, iterator, iterator, iterator) from_iterator_impl!(Pnt3, iterator, iterator, iterator)
bounded_impl!(Pnt3, x, y, z) bounded_impl!(Pnt3, x, y, z)
@ -311,7 +149,7 @@ iterable_impl!(Pnt3, 3)
iterable_mut_impl!(Pnt3, 3) iterable_mut_impl!(Pnt3, 3)
pnt_to_homogeneous_impl!(Pnt3, Pnt4, w, x, y, z) pnt_to_homogeneous_impl!(Pnt3, Pnt4, w, x, y, z)
pnt_from_homogeneous_impl!(Pnt3, Pnt4, w, x, y, z) pnt_from_homogeneous_impl!(Pnt3, Pnt4, w, x, y, z)
num_float_pnt_impl!(Pnt3, Vec3, Pnt3MulRhs, Pnt3DivRhs) num_float_pnt_impl!(Pnt3, Vec3)
/// Point of dimension 4. /// Point of dimension 4.
#[deriving(Eq, PartialEq, Encodable, Decodable, Clone, Hash, Rand, Show)] #[deriving(Eq, PartialEq, Encodable, Decodable, Clone, Hash, Rand, Show)]
@ -326,20 +164,14 @@ pub struct Pnt4<N> {
pub w: N pub w: N
} }
double_dispatch_binop_decl_trait!(Pnt4, Pnt4MulRhs)
double_dispatch_binop_decl_trait!(Pnt4, Pnt4DivRhs)
double_dispatch_binop_decl_trait!(Pnt4, Pnt4AddRhs)
double_dispatch_binop_decl_trait!(Pnt4, Pnt4SubRhs)
double_dispatch_cast_decl_trait!(Pnt4, Pnt4Cast)
mul_redispatch_impl!(Pnt4, Pnt4MulRhs)
div_redispatch_impl!(Pnt4, Pnt4DivRhs)
add_redispatch_impl!(Pnt4, Pnt4AddRhs)
sub_redispatch_impl!(Pnt4, Pnt4SubRhs)
cast_redispatch_impl!(Pnt4, Pnt4Cast)
new_impl!(Pnt4, x, y, z, w) new_impl!(Pnt4, x, y, z, w)
orig_impl!(Pnt4, x, y, z, w) orig_impl!(Pnt4, x, y, z, w)
ord_impl!(Pnt4, x, y, z, w) ord_impl!(Pnt4, x, y, z, w)
vec_cast_impl!(Pnt4, Pnt4Cast, x, y, z, w) scalar_mul_impl!(Pnt4, x, y, z, w)
scalar_div_impl!(Pnt4, x, y, z, w)
scalar_add_impl!(Pnt4, x, y, z, w)
scalar_sub_impl!(Pnt4, x, y, z, w)
vec_cast_impl!(Pnt4, x, y, z, w)
as_array_impl!(Pnt4, 4) as_array_impl!(Pnt4, 4)
index_impl!(Pnt4) index_impl!(Pnt4)
indexable_impl!(Pnt4, 4) indexable_impl!(Pnt4, 4)
@ -348,59 +180,11 @@ new_repeat_impl!(Pnt4, val, x, y, z, w)
dim_impl!(Pnt4, 4) dim_impl!(Pnt4, 4)
container_impl!(Pnt4) container_impl!(Pnt4)
pnt_as_vec_impl!(Pnt4, Vec4, x, y, z, w) pnt_as_vec_impl!(Pnt4, Vec4, x, y, z, w)
pnt_sub_impl!(Pnt4, Vec4, Pnt4SubRhs) pnt_sub_impl!(Pnt4, Vec4)
neg_impl!(Pnt4, x, y, z, w) neg_impl!(Pnt4, x, y, z, w)
pnt_add_vec_impl!(Pnt4, Vec4, Pnt4AddRhs, x, y, z, w) pnt_add_vec_impl!(Pnt4, Vec4, x, y, z, w)
pnt_sub_vec_impl!(Pnt4, Vec4, Pnt4SubRhs, x, y, z, w) pnt_sub_vec_impl!(Pnt4, Vec4, x, y, z, w)
scalar_ops_impl!(Pnt4, x, y, z, w) scalar_ops_impl!(Pnt4, x, y, z, w)
vec_mul_scalar_impl!(Pnt4, f64, Pnt4MulRhs, x, y, z, w)
vec_mul_scalar_impl!(Pnt4, f32, Pnt4MulRhs, x, y, z, w)
vec_mul_scalar_impl!(Pnt4, u64, Pnt4MulRhs, x, y, z, w)
vec_mul_scalar_impl!(Pnt4, u32, Pnt4MulRhs, x, y, z, w)
vec_mul_scalar_impl!(Pnt4, u16, Pnt4MulRhs, x, y, z, w)
vec_mul_scalar_impl!(Pnt4, u8, Pnt4MulRhs, x, y, z, w)
vec_mul_scalar_impl!(Pnt4, i64, Pnt4MulRhs, x, y, z, w)
vec_mul_scalar_impl!(Pnt4, i32, Pnt4MulRhs, x, y, z, w)
vec_mul_scalar_impl!(Pnt4, i16, Pnt4MulRhs, x, y, z, w)
vec_mul_scalar_impl!(Pnt4, i8, Pnt4MulRhs, x, y, z, w)
vec_mul_scalar_impl!(Pnt4, uint, Pnt4MulRhs, x, y, z, w)
vec_mul_scalar_impl!(Pnt4, int, Pnt4MulRhs, x, y, z, w)
vec_div_scalar_impl!(Pnt4, f64, Pnt4DivRhs, x, y, z, w)
vec_div_scalar_impl!(Pnt4, f32, Pnt4DivRhs, x, y, z, w)
vec_div_scalar_impl!(Pnt4, u64, Pnt4DivRhs, x, y, z, w)
vec_div_scalar_impl!(Pnt4, u32, Pnt4DivRhs, x, y, z, w)
vec_div_scalar_impl!(Pnt4, u16, Pnt4DivRhs, x, y, z, w)
vec_div_scalar_impl!(Pnt4, u8, Pnt4DivRhs, x, y, z, w)
vec_div_scalar_impl!(Pnt4, i64, Pnt4DivRhs, x, y, z, w)
vec_div_scalar_impl!(Pnt4, i32, Pnt4DivRhs, x, y, z, w)
vec_div_scalar_impl!(Pnt4, i16, Pnt4DivRhs, x, y, z, w)
vec_div_scalar_impl!(Pnt4, i8, Pnt4DivRhs, x, y, z, w)
vec_div_scalar_impl!(Pnt4, uint, Pnt4DivRhs, x, y, z, w)
vec_div_scalar_impl!(Pnt4, int, Pnt4DivRhs, x, y, z, w)
vec_add_scalar_impl!(Pnt4, f64, Pnt4AddRhs, x, y, z, w)
vec_add_scalar_impl!(Pnt4, f32, Pnt4AddRhs, x, y, z, w)
vec_add_scalar_impl!(Pnt4, u64, Pnt4AddRhs, x, y, z, w)
vec_add_scalar_impl!(Pnt4, u32, Pnt4AddRhs, x, y, z, w)
vec_add_scalar_impl!(Pnt4, u16, Pnt4AddRhs, x, y, z, w)
vec_add_scalar_impl!(Pnt4, u8, Pnt4AddRhs, x, y, z, w)
vec_add_scalar_impl!(Pnt4, i64, Pnt4AddRhs, x, y, z, w)
vec_add_scalar_impl!(Pnt4, i32, Pnt4AddRhs, x, y, z, w)
vec_add_scalar_impl!(Pnt4, i16, Pnt4AddRhs, x, y, z, w)
vec_add_scalar_impl!(Pnt4, i8, Pnt4AddRhs, x, y, z, w)
vec_add_scalar_impl!(Pnt4, uint, Pnt4AddRhs, x, y, z, w)
vec_add_scalar_impl!(Pnt4, int, Pnt4AddRhs, x, y, z, w)
vec_sub_scalar_impl!(Pnt4, f64, Pnt4SubRhs, x, y, z, w)
vec_sub_scalar_impl!(Pnt4, f32, Pnt4SubRhs, x, y, z, w)
vec_sub_scalar_impl!(Pnt4, u64, Pnt4SubRhs, x, y, z, w)
vec_sub_scalar_impl!(Pnt4, u32, Pnt4SubRhs, x, y, z, w)
vec_sub_scalar_impl!(Pnt4, u16, Pnt4SubRhs, x, y, z, w)
vec_sub_scalar_impl!(Pnt4, u8, Pnt4SubRhs, x, y, z, w)
vec_sub_scalar_impl!(Pnt4, i64, Pnt4SubRhs, x, y, z, w)
vec_sub_scalar_impl!(Pnt4, i32, Pnt4SubRhs, x, y, z, w)
vec_sub_scalar_impl!(Pnt4, i16, Pnt4SubRhs, x, y, z, w)
vec_sub_scalar_impl!(Pnt4, i8, Pnt4SubRhs, x, y, z, w)
vec_sub_scalar_impl!(Pnt4, uint, Pnt4SubRhs, x, y, z, w)
vec_sub_scalar_impl!(Pnt4, int, Pnt4SubRhs, x, y, z, w)
approx_eq_impl!(Pnt4, x, y, z, w) approx_eq_impl!(Pnt4, x, y, z, w)
from_iterator_impl!(Pnt4, iterator, iterator, iterator, iterator) from_iterator_impl!(Pnt4, iterator, iterator, iterator, iterator)
bounded_impl!(Pnt4, x, y, z, w) bounded_impl!(Pnt4, x, y, z, w)
@ -409,7 +193,7 @@ iterable_impl!(Pnt4, 4)
iterable_mut_impl!(Pnt4, 4) iterable_mut_impl!(Pnt4, 4)
pnt_to_homogeneous_impl!(Pnt4, Pnt5, a, x, y, z, w) pnt_to_homogeneous_impl!(Pnt4, Pnt5, a, x, y, z, w)
pnt_from_homogeneous_impl!(Pnt4, Pnt5, a, x, y, z, w) pnt_from_homogeneous_impl!(Pnt4, Pnt5, a, x, y, z, w)
num_float_pnt_impl!(Pnt4, Vec4, Pnt4MulRhs, Pnt4DivRhs) num_float_pnt_impl!(Pnt4, Vec4)
/// Point of dimension 5. /// Point of dimension 5.
#[deriving(Eq, PartialEq, Encodable, Decodable, Clone, Hash, Rand, Show)] #[deriving(Eq, PartialEq, Encodable, Decodable, Clone, Hash, Rand, Show)]
@ -426,20 +210,14 @@ pub struct Pnt5<N> {
pub a: N pub a: N
} }
double_dispatch_binop_decl_trait!(Pnt5, Pnt5MulRhs)
double_dispatch_binop_decl_trait!(Pnt5, Pnt5DivRhs)
double_dispatch_binop_decl_trait!(Pnt5, Pnt5AddRhs)
double_dispatch_binop_decl_trait!(Pnt5, Pnt5SubRhs)
double_dispatch_cast_decl_trait!(Pnt5, Pnt5Cast)
mul_redispatch_impl!(Pnt5, Pnt5MulRhs)
div_redispatch_impl!(Pnt5, Pnt5DivRhs)
add_redispatch_impl!(Pnt5, Pnt5AddRhs)
sub_redispatch_impl!(Pnt5, Pnt5SubRhs)
cast_redispatch_impl!(Pnt5, Pnt5Cast)
new_impl!(Pnt5, x, y, z, w, a) new_impl!(Pnt5, x, y, z, w, a)
orig_impl!(Pnt5, x, y, z, w, a) orig_impl!(Pnt5, x, y, z, w, a)
ord_impl!(Pnt5, x, y, z, w, a) ord_impl!(Pnt5, x, y, z, w, a)
vec_cast_impl!(Pnt5, Pnt5Cast, x, y, z, w, a) scalar_mul_impl!(Pnt5, x, y, z, w, a)
scalar_div_impl!(Pnt5, x, y, z, w, a)
scalar_add_impl!(Pnt5, x, y, z, w, a)
scalar_sub_impl!(Pnt5, x, y, z, w, a)
vec_cast_impl!(Pnt5, x, y, z, w, a)
as_array_impl!(Pnt5, 5) as_array_impl!(Pnt5, 5)
index_impl!(Pnt5) index_impl!(Pnt5)
indexable_impl!(Pnt5, 5) indexable_impl!(Pnt5, 5)
@ -448,59 +226,11 @@ new_repeat_impl!(Pnt5, val, x, y, z, w, a)
dim_impl!(Pnt5, 5) dim_impl!(Pnt5, 5)
container_impl!(Pnt5) container_impl!(Pnt5)
pnt_as_vec_impl!(Pnt5, Vec5, x, y, z, w, a) pnt_as_vec_impl!(Pnt5, Vec5, x, y, z, w, a)
pnt_sub_impl!(Pnt5, Vec5, Pnt5SubRhs) pnt_sub_impl!(Pnt5, Vec5)
neg_impl!(Pnt5, x, y, z, w, a) neg_impl!(Pnt5, x, y, z, w, a)
pnt_add_vec_impl!(Pnt5, Vec5, Pnt5AddRhs, x, y, z, w, a) pnt_add_vec_impl!(Pnt5, Vec5, x, y, z, w, a)
pnt_sub_vec_impl!(Pnt5, Vec5, Pnt5SubRhs, x, y, z, w, a) pnt_sub_vec_impl!(Pnt5, Vec5, x, y, z, w, a)
scalar_ops_impl!(Pnt5, x, y, z, w, a) scalar_ops_impl!(Pnt5, x, y, z, w, a)
vec_mul_scalar_impl!(Pnt5, f64, Pnt5MulRhs, x, y, z, w, a)
vec_mul_scalar_impl!(Pnt5, f32, Pnt5MulRhs, x, y, z, w, a)
vec_mul_scalar_impl!(Pnt5, u64, Pnt5MulRhs, x, y, z, w, a)
vec_mul_scalar_impl!(Pnt5, u32, Pnt5MulRhs, x, y, z, w, a)
vec_mul_scalar_impl!(Pnt5, u16, Pnt5MulRhs, x, y, z, w, a)
vec_mul_scalar_impl!(Pnt5, u8, Pnt5MulRhs, x, y, z, w, a)
vec_mul_scalar_impl!(Pnt5, i64, Pnt5MulRhs, x, y, z, w, a)
vec_mul_scalar_impl!(Pnt5, i32, Pnt5MulRhs, x, y, z, w, a)
vec_mul_scalar_impl!(Pnt5, i16, Pnt5MulRhs, x, y, z, w, a)
vec_mul_scalar_impl!(Pnt5, i8, Pnt5MulRhs, x, y, z, w, a)
vec_mul_scalar_impl!(Pnt5, uint, Pnt5MulRhs, x, y, z, w, a)
vec_mul_scalar_impl!(Pnt5, int, Pnt5MulRhs, x, y, z, w, a)
vec_div_scalar_impl!(Pnt5, f64, Pnt5DivRhs, x, y, z, w, a)
vec_div_scalar_impl!(Pnt5, f32, Pnt5DivRhs, x, y, z, w, a)
vec_div_scalar_impl!(Pnt5, u64, Pnt5DivRhs, x, y, z, w, a)
vec_div_scalar_impl!(Pnt5, u32, Pnt5DivRhs, x, y, z, w, a)
vec_div_scalar_impl!(Pnt5, u16, Pnt5DivRhs, x, y, z, w, a)
vec_div_scalar_impl!(Pnt5, u8, Pnt5DivRhs, x, y, z, w, a)
vec_div_scalar_impl!(Pnt5, i64, Pnt5DivRhs, x, y, z, w, a)
vec_div_scalar_impl!(Pnt5, i32, Pnt5DivRhs, x, y, z, w, a)
vec_div_scalar_impl!(Pnt5, i16, Pnt5DivRhs, x, y, z, w, a)
vec_div_scalar_impl!(Pnt5, i8, Pnt5DivRhs, x, y, z, w, a)
vec_div_scalar_impl!(Pnt5, uint, Pnt5DivRhs, x, y, z, w, a)
vec_div_scalar_impl!(Pnt5, int, Pnt5DivRhs, x, y, z, w, a)
vec_add_scalar_impl!(Pnt5, f64, Pnt5AddRhs, x, y, z, w, a)
vec_add_scalar_impl!(Pnt5, f32, Pnt5AddRhs, x, y, z, w, a)
vec_add_scalar_impl!(Pnt5, u64, Pnt5AddRhs, x, y, z, w, a)
vec_add_scalar_impl!(Pnt5, u32, Pnt5AddRhs, x, y, z, w, a)
vec_add_scalar_impl!(Pnt5, u16, Pnt5AddRhs, x, y, z, w, a)
vec_add_scalar_impl!(Pnt5, u8, Pnt5AddRhs, x, y, z, w, a)
vec_add_scalar_impl!(Pnt5, i64, Pnt5AddRhs, x, y, z, w, a)
vec_add_scalar_impl!(Pnt5, i32, Pnt5AddRhs, x, y, z, w, a)
vec_add_scalar_impl!(Pnt5, i16, Pnt5AddRhs, x, y, z, w, a)
vec_add_scalar_impl!(Pnt5, i8, Pnt5AddRhs, x, y, z, w, a)
vec_add_scalar_impl!(Pnt5, uint, Pnt5AddRhs, x, y, z, w, a)
vec_add_scalar_impl!(Pnt5, int, Pnt5AddRhs, x, y, z, w, a)
vec_sub_scalar_impl!(Pnt5, f64, Pnt5SubRhs, x, y, z, w, a)
vec_sub_scalar_impl!(Pnt5, f32, Pnt5SubRhs, x, y, z, w, a)
vec_sub_scalar_impl!(Pnt5, u64, Pnt5SubRhs, x, y, z, w, a)
vec_sub_scalar_impl!(Pnt5, u32, Pnt5SubRhs, x, y, z, w, a)
vec_sub_scalar_impl!(Pnt5, u16, Pnt5SubRhs, x, y, z, w, a)
vec_sub_scalar_impl!(Pnt5, u8, Pnt5SubRhs, x, y, z, w, a)
vec_sub_scalar_impl!(Pnt5, i64, Pnt5SubRhs, x, y, z, w, a)
vec_sub_scalar_impl!(Pnt5, i32, Pnt5SubRhs, x, y, z, w, a)
vec_sub_scalar_impl!(Pnt5, i16, Pnt5SubRhs, x, y, z, w, a)
vec_sub_scalar_impl!(Pnt5, i8, Pnt5SubRhs, x, y, z, w, a)
vec_sub_scalar_impl!(Pnt5, uint, Pnt5SubRhs, x, y, z, w, a)
vec_sub_scalar_impl!(Pnt5, int, Pnt5SubRhs, x, y, z, w, a)
approx_eq_impl!(Pnt5, x, y, z, w, a) approx_eq_impl!(Pnt5, x, y, z, w, a)
from_iterator_impl!(Pnt5, iterator, iterator, iterator, iterator, iterator) from_iterator_impl!(Pnt5, iterator, iterator, iterator, iterator, iterator)
bounded_impl!(Pnt5, x, y, z, w, a) bounded_impl!(Pnt5, x, y, z, w, a)
@ -509,7 +239,7 @@ iterable_impl!(Pnt5, 5)
iterable_mut_impl!(Pnt5, 5) iterable_mut_impl!(Pnt5, 5)
pnt_to_homogeneous_impl!(Pnt5, Pnt6, b, x, y, z, w, a) pnt_to_homogeneous_impl!(Pnt5, Pnt6, b, x, y, z, w, a)
pnt_from_homogeneous_impl!(Pnt5, Pnt6, b, x, y, z, w, a) pnt_from_homogeneous_impl!(Pnt5, Pnt6, b, x, y, z, w, a)
num_float_pnt_impl!(Pnt5, Vec5, Pnt5MulRhs, Pnt5DivRhs) num_float_pnt_impl!(Pnt5, Vec5)
/// Point of dimension 6. /// Point of dimension 6.
#[deriving(Eq, PartialEq, Encodable, Decodable, Clone, Hash, Rand, Show)] #[deriving(Eq, PartialEq, Encodable, Decodable, Clone, Hash, Rand, Show)]
@ -528,20 +258,14 @@ pub struct Pnt6<N> {
pub b: N pub b: N
} }
double_dispatch_binop_decl_trait!(Pnt6, Pnt6MulRhs)
double_dispatch_binop_decl_trait!(Pnt6, Pnt6DivRhs)
double_dispatch_binop_decl_trait!(Pnt6, Pnt6AddRhs)
double_dispatch_binop_decl_trait!(Pnt6, Pnt6SubRhs)
double_dispatch_cast_decl_trait!(Pnt6, Pnt6Cast)
mul_redispatch_impl!(Pnt6, Pnt6MulRhs)
div_redispatch_impl!(Pnt6, Pnt6DivRhs)
add_redispatch_impl!(Pnt6, Pnt6AddRhs)
sub_redispatch_impl!(Pnt6, Pnt6SubRhs)
cast_redispatch_impl!(Pnt6, Pnt6Cast)
new_impl!(Pnt6, x, y, z, w, a, b) new_impl!(Pnt6, x, y, z, w, a, b)
orig_impl!(Pnt6, x, y, z, w, a, b) orig_impl!(Pnt6, x, y, z, w, a, b)
ord_impl!(Pnt6, x, y, z, w, a, b) ord_impl!(Pnt6, x, y, z, w, a, b)
vec_cast_impl!(Pnt6, Pnt6Cast, x, y, z, w, a, b) scalar_mul_impl!(Pnt6, x, y, z, w, a, b)
scalar_div_impl!(Pnt6, x, y, z, w, a, b)
scalar_add_impl!(Pnt6, x, y, z, w, a, b)
scalar_sub_impl!(Pnt6, x, y, z, w, a, b)
vec_cast_impl!(Pnt6, x, y, z, w, a, b)
as_array_impl!(Pnt6, 6) as_array_impl!(Pnt6, 6)
index_impl!(Pnt6) index_impl!(Pnt6)
indexable_impl!(Pnt6, 6) indexable_impl!(Pnt6, 6)
@ -550,63 +274,15 @@ new_repeat_impl!(Pnt6, val, x, y, z, w, a, b)
dim_impl!(Pnt6, 6) dim_impl!(Pnt6, 6)
container_impl!(Pnt6) container_impl!(Pnt6)
pnt_as_vec_impl!(Pnt6, Vec6, x, y, z, w, a, b) pnt_as_vec_impl!(Pnt6, Vec6, x, y, z, w, a, b)
pnt_sub_impl!(Pnt6, Vec6, Pnt6SubRhs) pnt_sub_impl!(Pnt6, Vec6)
neg_impl!(Pnt6, x, y, z, w, a, b) neg_impl!(Pnt6, x, y, z, w, a, b)
pnt_add_vec_impl!(Pnt6, Vec6, Pnt6AddRhs, x, y, z, w, a, b) pnt_add_vec_impl!(Pnt6, Vec6, x, y, z, w, a, b)
pnt_sub_vec_impl!(Pnt6, Vec6, Pnt6SubRhs, x, y, z, w, a, b) pnt_sub_vec_impl!(Pnt6, Vec6, x, y, z, w, a, b)
scalar_ops_impl!(Pnt6, x, y, z, w, a, b) scalar_ops_impl!(Pnt6, x, y, z, w, a, b)
vec_mul_scalar_impl!(Pnt6, f64, Pnt6MulRhs, x, y, z, w, a, b)
vec_mul_scalar_impl!(Pnt6, f32, Pnt6MulRhs, x, y, z, w, a, b)
vec_mul_scalar_impl!(Pnt6, u64, Pnt6MulRhs, x, y, z, w, a, b)
vec_mul_scalar_impl!(Pnt6, u32, Pnt6MulRhs, x, y, z, w, a, b)
vec_mul_scalar_impl!(Pnt6, u16, Pnt6MulRhs, x, y, z, w, a, b)
vec_mul_scalar_impl!(Pnt6, u8, Pnt6MulRhs, x, y, z, w, a, b)
vec_mul_scalar_impl!(Pnt6, i64, Pnt6MulRhs, x, y, z, w, a, b)
vec_mul_scalar_impl!(Pnt6, i32, Pnt6MulRhs, x, y, z, w, a, b)
vec_mul_scalar_impl!(Pnt6, i16, Pnt6MulRhs, x, y, z, w, a, b)
vec_mul_scalar_impl!(Pnt6, i8, Pnt6MulRhs, x, y, z, w, a, b)
vec_mul_scalar_impl!(Pnt6, uint, Pnt6MulRhs, x, y, z, w, a, b)
vec_mul_scalar_impl!(Pnt6, int, Pnt6MulRhs, x, y, z, w, a, b)
vec_div_scalar_impl!(Pnt6, f64, Pnt6DivRhs, x, y, z, w, a, b)
vec_div_scalar_impl!(Pnt6, f32, Pnt6DivRhs, x, y, z, w, a, b)
vec_div_scalar_impl!(Pnt6, u64, Pnt6DivRhs, x, y, z, w, a, b)
vec_div_scalar_impl!(Pnt6, u32, Pnt6DivRhs, x, y, z, w, a, b)
vec_div_scalar_impl!(Pnt6, u16, Pnt6DivRhs, x, y, z, w, a, b)
vec_div_scalar_impl!(Pnt6, u8, Pnt6DivRhs, x, y, z, w, a, b)
vec_div_scalar_impl!(Pnt6, i64, Pnt6DivRhs, x, y, z, w, a, b)
vec_div_scalar_impl!(Pnt6, i32, Pnt6DivRhs, x, y, z, w, a, b)
vec_div_scalar_impl!(Pnt6, i16, Pnt6DivRhs, x, y, z, w, a, b)
vec_div_scalar_impl!(Pnt6, i8, Pnt6DivRhs, x, y, z, w, a, b)
vec_div_scalar_impl!(Pnt6, uint, Pnt6DivRhs, x, y, z, w, a, b)
vec_div_scalar_impl!(Pnt6, int, Pnt6DivRhs, x, y, z, w, a, b)
vec_add_scalar_impl!(Pnt6, f64, Pnt6AddRhs, x, y, z, w, a, b)
vec_add_scalar_impl!(Pnt6, f32, Pnt6AddRhs, x, y, z, w, a, b)
vec_add_scalar_impl!(Pnt6, u64, Pnt6AddRhs, x, y, z, w, a, b)
vec_add_scalar_impl!(Pnt6, u32, Pnt6AddRhs, x, y, z, w, a, b)
vec_add_scalar_impl!(Pnt6, u16, Pnt6AddRhs, x, y, z, w, a, b)
vec_add_scalar_impl!(Pnt6, u8, Pnt6AddRhs, x, y, z, w, a, b)
vec_add_scalar_impl!(Pnt6, i64, Pnt6AddRhs, x, y, z, w, a, b)
vec_add_scalar_impl!(Pnt6, i32, Pnt6AddRhs, x, y, z, w, a, b)
vec_add_scalar_impl!(Pnt6, i16, Pnt6AddRhs, x, y, z, w, a, b)
vec_add_scalar_impl!(Pnt6, i8, Pnt6AddRhs, x, y, z, w, a, b)
vec_add_scalar_impl!(Pnt6, uint, Pnt6AddRhs, x, y, z, w, a, b)
vec_add_scalar_impl!(Pnt6, int, Pnt6AddRhs, x, y, z, w, a, b)
vec_sub_scalar_impl!(Pnt6, f64, Pnt6SubRhs, x, y, z, w, a, b)
vec_sub_scalar_impl!(Pnt6, f32, Pnt6SubRhs, x, y, z, w, a, b)
vec_sub_scalar_impl!(Pnt6, u64, Pnt6SubRhs, x, y, z, w, a, b)
vec_sub_scalar_impl!(Pnt6, u32, Pnt6SubRhs, x, y, z, w, a, b)
vec_sub_scalar_impl!(Pnt6, u16, Pnt6SubRhs, x, y, z, w, a, b)
vec_sub_scalar_impl!(Pnt6, u8, Pnt6SubRhs, x, y, z, w, a, b)
vec_sub_scalar_impl!(Pnt6, i64, Pnt6SubRhs, x, y, z, w, a, b)
vec_sub_scalar_impl!(Pnt6, i32, Pnt6SubRhs, x, y, z, w, a, b)
vec_sub_scalar_impl!(Pnt6, i16, Pnt6SubRhs, x, y, z, w, a, b)
vec_sub_scalar_impl!(Pnt6, i8, Pnt6SubRhs, x, y, z, w, a, b)
vec_sub_scalar_impl!(Pnt6, uint, Pnt6SubRhs, x, y, z, w, a, b)
vec_sub_scalar_impl!(Pnt6, int, Pnt6SubRhs, x, y, z, w, a, b)
approx_eq_impl!(Pnt6, x, y, z, w, a, b) approx_eq_impl!(Pnt6, x, y, z, w, a, b)
from_iterator_impl!(Pnt6, iterator, iterator, iterator, iterator, iterator, iterator) from_iterator_impl!(Pnt6, iterator, iterator, iterator, iterator, iterator, iterator)
bounded_impl!(Pnt6, x, y, z, w, a, b) bounded_impl!(Pnt6, x, y, z, w, a, b)
axpy_impl!(Pnt6, x, y, z, w, a, b) axpy_impl!(Pnt6, x, y, z, w, a, b)
iterable_impl!(Pnt6, 6) iterable_impl!(Pnt6, 6)
iterable_mut_impl!(Pnt6, 6) iterable_mut_impl!(Pnt6, 6)
num_float_pnt_impl!(Pnt6, Vec6, Pnt6MulRhs, Pnt6DivRhs) num_float_pnt_impl!(Pnt6, Vec6)

30
src/structs/pnt_macros.rs
View File

@ -20,33 +20,33 @@ macro_rules! orig_impl(
) )
macro_rules! pnt_sub_impl( macro_rules! pnt_sub_impl(
($t: ident, $tv: ident, $trhs: ident) => ( ($t: ident, $tv: ident) => (
impl<N: Sub<N, N>> $trhs<N, $tv<N>> for $t<N> { impl<N: Sub<N, N>> Sub<$t<N>, $tv<N>> for $t<N> {
#[inline] #[inline]
fn binop(left: &$t<N>, right: &$t<N>) -> $tv<N> { fn sub(&self, right: &$t<N>) -> $tv<N> {
*left.as_vec() - *right.as_vec() *self.as_vec() - *right.as_vec()
} }
} }
) )
) )
macro_rules! pnt_add_vec_impl( macro_rules! pnt_add_vec_impl(
($t: ident, $tv: ident, $trhs: ident, $comp0: ident $(,$compN: ident)*) => ( ($t: ident, $tv: ident, $comp0: ident $(,$compN: ident)*) => (
impl<N: Add<N, N>> $trhs<N, $t<N>> for $tv<N> { impl<N: Add<N, N>> Add<$tv<N>, $t<N>> for $t<N> {
#[inline] #[inline]
fn binop(left: &$t<N>, right: &$tv<N>) -> $t<N> { fn add(&self, right: &$tv<N>) -> $t<N> {
$t::new(left.$comp0 + right.$comp0 $(, left.$compN + right.$compN)*) $t::new(self.$comp0 + right.$comp0 $(, self.$compN + right.$compN)*)
} }
} }
) )
) )
macro_rules! pnt_sub_vec_impl( macro_rules! pnt_sub_vec_impl(
($t: ident, $tv: ident, $trhs: ident, $comp0: ident $(,$compN: ident)*) => ( ($t: ident, $tv: ident, $comp0: ident $(,$compN: ident)*) => (
impl<N: Sub<N, N>> $trhs<N, $t<N>> for $tv<N> { impl<N: Sub<N, N>> Sub<$tv<N>, $t<N>> for $t<N> {
#[inline] #[inline]
fn binop(left: &$t<N>, right: &$tv<N>) -> $t<N> { fn sub(&self, right: &$tv<N>) -> $t<N> {
$t::new(left.$comp0 - right.$comp0 $(, left.$compN - right.$compN)*) $t::new(self.$comp0 - right.$comp0 $(, self.$compN - right.$compN)*)
} }
} }
) )
@ -130,13 +130,13 @@ macro_rules! pnt_from_homogeneous_impl(
) )
macro_rules! num_float_pnt_impl( macro_rules! num_float_pnt_impl(
($t: ident, $tv: ident $(,$trhs: ident)*) => ( ($t: ident, $tv: ident) => (
impl<N> NumPnt<N, $tv<N>> for $t<N> impl<N> NumPnt<N, $tv<N>> for $t<N>
where N: BaseNum + Zero $(+ $trhs<N, $t<N>>)* { where N: BaseNum {
} }
impl<N> FloatPnt<N, $tv<N>> for $t<N> impl<N> FloatPnt<N, $tv<N>> for $t<N>
where N: BaseNum + One + Zero + ApproxEq<N> + BaseFloat $(+ $trhs<N, $t<N>>)* { where N: BaseFloat + ApproxEq<N> {
} }
) )
) )

124
src/structs/quat.rs
View File

@ -6,7 +6,7 @@ use std::mem;
use std::num; use std::num;
use std::rand::{Rand, Rng}; use std::rand::{Rand, Rng};
use std::slice::{Items, MutItems}; use std::slice::{Items, MutItems};
use structs::{Vec3, Pnt3, Rot3, Mat3, Vec3MulRhs, Pnt3MulRhs}; use structs::{Vec3, Pnt3, Rot3, Mat3};
use traits::operations::{ApproxEq, Inv, POrd, POrdering, Axpy, ScalarAdd, ScalarSub, ScalarMul, use traits::operations::{ApproxEq, Inv, POrd, POrdering, Axpy, ScalarAdd, ScalarSub, ScalarMul,
ScalarDiv}; ScalarDiv};
use traits::structure::{Cast, Indexable, Iterable, IterableMut, Dim, Shape, BaseFloat, BaseNum, Zero, use traits::structure::{Cast, Indexable, Iterable, IterableMut, Dim, Shape, BaseFloat, BaseNum, Zero,
@ -121,21 +121,21 @@ impl<N: BaseFloat> Norm<N> for Quat<N> {
} }
} }
impl<N: Mul<N, N> + Sub<N, N> + Add<N, N>> QuatMulRhs<N, Quat<N>> for Quat<N> { impl<N: Mul<N, N> + Sub<N, N> + Add<N, N>> Mul<Quat<N>, Quat<N>> for Quat<N> {
#[inline] #[inline]
fn binop(left: &Quat<N>, right: &Quat<N>) -> Quat<N> { fn mul(&self, right: &Quat<N>) -> Quat<N> {
Quat::new( Quat::new(
left.w * right.w - left.i * right.i - left.j * right.j - left.k * right.k, self.w * right.w - self.i * right.i - self.j * right.j - self.k * right.k,
left.w * right.i + left.i * right.w + left.j * right.k - left.k * right.j, self.w * right.i + self.i * right.w + self.j * right.k - self.k * right.j,
left.w * right.j - left.i * right.k + left.j * right.w + left.k * right.i, self.w * right.j - self.i * right.k + self.j * right.w + self.k * right.i,
left.w * right.k + left.i * right.j - left.j * right.i + left.k * right.w) self.w * right.k + self.i * right.j - self.j * right.i + self.k * right.w)
} }
} }
impl<N: ApproxEq<N> + BaseFloat + Clone> QuatDivRhs<N, Quat<N>> for Quat<N> { impl<N: ApproxEq<N> + BaseFloat + Clone> Div<Quat<N>, Quat<N>> for Quat<N> {
#[inline] #[inline]
fn binop(left: &Quat<N>, right: &Quat<N>) -> Quat<N> { fn div(&self, right: &Quat<N>) -> Quat<N> {
*left * Inv::inv_cpy(right).expect("Unable to invert the denominator.") *self * Inv::inv_cpy(right).expect("Unable to invert the denominator.")
} }
} }
@ -307,49 +307,49 @@ impl<N: BaseFloat + ApproxEq<N> + Clone> Div<UnitQuat<N>, UnitQuat<N>> for UnitQ
} }
} }
impl<N: BaseNum + Clone> UnitQuatMulRhs<N, UnitQuat<N>> for UnitQuat<N> { impl<N: BaseNum + Clone> Mul<UnitQuat<N>, UnitQuat<N>> for UnitQuat<N> {
#[inline] #[inline]
fn binop(left: &UnitQuat<N>, right: &UnitQuat<N>) -> UnitQuat<N> { fn mul(&self, right: &UnitQuat<N>) -> UnitQuat<N> {
UnitQuat { q: left.q * right.q } UnitQuat { q: self.q * right.q }
} }
} }
impl<N: BaseNum + Clone> UnitQuatMulRhs<N, Vec3<N>> for Vec3<N> { impl<N: BaseNum + Clone> Mul<Vec3<N>, Vec3<N>> for UnitQuat<N> {
#[inline] #[inline]
fn binop(left: &UnitQuat<N>, right: &Vec3<N>) -> Vec3<N> { fn mul(&self, right: &Vec3<N>) -> Vec3<N> {
let _2: N = ::one::<N>() + ::one(); let _2: N = ::one::<N>() + ::one();
let mut t = Cross::cross(left.q.vector(), right); let mut t = Cross::cross(self.q.vector(), right);
t.x = t.x * _2; t.x = t.x * _2;
t.y = t.y * _2; t.y = t.y * _2;
t.z = t.z * _2; t.z = t.z * _2;
Vec3::new(t.x * left.q.w, t.y * left.q.w, t.z * left.q.w) + Vec3::new(t.x * self.q.w, t.y * self.q.w, t.z * self.q.w) +
Cross::cross(left.q.vector(), &t) + Cross::cross(self.q.vector(), &t) +
*right *right
} }
} }
impl<N: BaseNum + Clone> UnitQuatMulRhs<N, Pnt3<N>> for Pnt3<N> { impl<N: BaseNum + Clone> Mul<Pnt3<N>, Pnt3<N>> for UnitQuat<N> {
#[inline] #[inline]
fn binop(left: &UnitQuat<N>, right: &Pnt3<N>) -> Pnt3<N> { fn mul(&self, right: &Pnt3<N>) -> Pnt3<N> {
::orig::<Pnt3<N>>() + *left * *right.as_vec() ::orig::<Pnt3<N>>() + *self * *right.as_vec()
} }
} }
impl<N: BaseNum + Clone> Vec3MulRhs<N, Vec3<N>> for UnitQuat<N> { impl<N: BaseNum + Clone> Mul<UnitQuat<N>, Vec3<N>> for Vec3<N> {
#[inline] #[inline]
fn binop(left: &Vec3<N>, right: &UnitQuat<N>) -> Vec3<N> { fn mul(&self, right: &UnitQuat<N>) -> Vec3<N> {
let mut inv_quat = right.clone(); let mut inv_quat = right.clone();
inv_quat.inv(); inv_quat.inv();
inv_quat * *left inv_quat * *self
} }
} }
impl<N: BaseNum + Clone> Pnt3MulRhs<N, Pnt3<N>> for UnitQuat<N> { impl<N: BaseNum + Clone> Mul<UnitQuat<N>, Pnt3<N>> for Pnt3<N> {
#[inline] #[inline]
fn binop(left: &Pnt3<N>, right: &UnitQuat<N>) -> Pnt3<N> { fn mul(&self, right: &UnitQuat<N>) -> Pnt3<N> {
::orig::<Pnt3<N>>() + *left.as_vec() * *right ::orig::<Pnt3<N>>() + *self.as_vec() * *right
} }
} }
@ -447,19 +447,9 @@ impl<N: BaseNum + Clone> Transform<Pnt3<N>> for UnitQuat<N> {
} }
} }
double_dispatch_binop_decl_trait!(Quat, QuatMulRhs)
double_dispatch_binop_decl_trait!(Quat, QuatDivRhs)
double_dispatch_binop_decl_trait!(Quat, QuatAddRhs)
double_dispatch_binop_decl_trait!(Quat, QuatSubRhs)
double_dispatch_cast_decl_trait!(Quat, QuatCast)
mul_redispatch_impl!(Quat, QuatMulRhs)
div_redispatch_impl!(Quat, QuatDivRhs)
add_redispatch_impl!(Quat, QuatAddRhs)
sub_redispatch_impl!(Quat, QuatSubRhs)
cast_redispatch_impl!(Quat, QuatCast)
ord_impl!(Quat, w, i, j, k) ord_impl!(Quat, w, i, j, k)
vec_axis_impl!(Quat, w, i, j, k) vec_axis_impl!(Quat, w, i, j, k)
vec_cast_impl!(Quat, QuatCast, w, i, j, k) vec_cast_impl!(Quat, w, i, j, k)
as_array_impl!(Quat, 4) as_array_impl!(Quat, 4)
index_impl!(Quat) index_impl!(Quat)
indexable_impl!(Quat, 4) indexable_impl!(Quat, 4)
@ -467,58 +457,14 @@ at_fast_impl!(Quat, 4)
new_repeat_impl!(Quat, val, w, i, j, k) new_repeat_impl!(Quat, val, w, i, j, k)
dim_impl!(Quat, 3) dim_impl!(Quat, 3)
container_impl!(Quat) container_impl!(Quat)
add_impl!(Quat, QuatAddRhs, w, i, j, k) add_impl!(Quat, w, i, j, k)
sub_impl!(Quat, QuatSubRhs, w, i, j, k) sub_impl!(Quat, w, i, j, k)
scalar_add_impl!(Quat, w, i, j, k)
scalar_sub_impl!(Quat, w, i, j, k)
scalar_mul_impl!(Quat, w, i, j, k)
scalar_div_impl!(Quat, w, i, j, k)
neg_impl!(Quat, w, i, j, k) neg_impl!(Quat, w, i, j, k)
scalar_ops_impl!(Quat, w, i, j, k) scalar_ops_impl!(Quat, w, i, j, k)
vec_mul_scalar_impl!(Quat, f64, QuatMulRhs, w, i, j, k)
vec_mul_scalar_impl!(Quat, f32, QuatMulRhs, w, i, j, k)
vec_mul_scalar_impl!(Quat, u64, QuatMulRhs, w, i, j, k)
vec_mul_scalar_impl!(Quat, u32, QuatMulRhs, w, i, j, k)
vec_mul_scalar_impl!(Quat, u16, QuatMulRhs, w, i, j, k)
vec_mul_scalar_impl!(Quat, u8, QuatMulRhs, w, i, j, k)
vec_mul_scalar_impl!(Quat, i64, QuatMulRhs, w, i, j, k)
vec_mul_scalar_impl!(Quat, i32, QuatMulRhs, w, i, j, k)
vec_mul_scalar_impl!(Quat, i16, QuatMulRhs, w, i, j, k)
vec_mul_scalar_impl!(Quat, i8, QuatMulRhs, w, i, j, k)
vec_mul_scalar_impl!(Quat, uint, QuatMulRhs, w, i, j, k)
vec_mul_scalar_impl!(Quat, int, QuatMulRhs, w, i, j, k)
vec_div_scalar_impl!(Quat, f64, QuatDivRhs, w, i, j, k)
vec_div_scalar_impl!(Quat, f32, QuatDivRhs, w, i, j, k)
vec_div_scalar_impl!(Quat, u64, QuatDivRhs, w, i, j, k)
vec_div_scalar_impl!(Quat, u32, QuatDivRhs, w, i, j, k)
vec_div_scalar_impl!(Quat, u16, QuatDivRhs, w, i, j, k)
vec_div_scalar_impl!(Quat, u8, QuatDivRhs, w, i, j, k)
vec_div_scalar_impl!(Quat, i64, QuatDivRhs, w, i, j, k)
vec_div_scalar_impl!(Quat, i32, QuatDivRhs, w, i, j, k)
vec_div_scalar_impl!(Quat, i16, QuatDivRhs, w, i, j, k)
vec_div_scalar_impl!(Quat, i8, QuatDivRhs, w, i, j, k)
vec_div_scalar_impl!(Quat, uint, QuatDivRhs, w, i, j, k)
vec_div_scalar_impl!(Quat, int, QuatDivRhs, w, i, j, k)
vec_add_scalar_impl!(Quat, f64, QuatAddRhs, w, i, j, k)
vec_add_scalar_impl!(Quat, f32, QuatAddRhs, w, i, j, k)
vec_add_scalar_impl!(Quat, u64, QuatAddRhs, w, i, j, k)
vec_add_scalar_impl!(Quat, u32, QuatAddRhs, w, i, j, k)
vec_add_scalar_impl!(Quat, u16, QuatAddRhs, w, i, j, k)
vec_add_scalar_impl!(Quat, u8, QuatAddRhs, w, i, j, k)
vec_add_scalar_impl!(Quat, i64, QuatAddRhs, w, i, j, k)
vec_add_scalar_impl!(Quat, i32, QuatAddRhs, w, i, j, k)
vec_add_scalar_impl!(Quat, i16, QuatAddRhs, w, i, j, k)
vec_add_scalar_impl!(Quat, i8, QuatAddRhs, w, i, j, k)
vec_add_scalar_impl!(Quat, uint, QuatAddRhs, w, i, j, k)
vec_add_scalar_impl!(Quat, int, QuatAddRhs, w, i, j, k)
vec_sub_scalar_impl!(Quat, f64, QuatSubRhs, w, i, j, k)
vec_sub_scalar_impl!(Quat, f32, QuatSubRhs, w, i, j, k)
vec_sub_scalar_impl!(Quat, u64, QuatSubRhs, w, i, j, k)
vec_sub_scalar_impl!(Quat, u32, QuatSubRhs, w, i, j, k)
vec_sub_scalar_impl!(Quat, u16, QuatSubRhs, w, i, j, k)
vec_sub_scalar_impl!(Quat, u8, QuatSubRhs, w, i, j, k)
vec_sub_scalar_impl!(Quat, i64, QuatSubRhs, w, i, j, k)
vec_sub_scalar_impl!(Quat, i32, QuatSubRhs, w, i, j, k)
vec_sub_scalar_impl!(Quat, i16, QuatSubRhs, w, i, j, k)
vec_sub_scalar_impl!(Quat, i8, QuatSubRhs, w, i, j, k)
vec_sub_scalar_impl!(Quat, uint, QuatSubRhs, w, i, j, k)
vec_sub_scalar_impl!(Quat, int, QuatSubRhs, w, i, j, k)
zero_one_impl!(Quat, w, i, j, k) zero_one_impl!(Quat, w, i, j, k)
approx_eq_impl!(Quat, w, i, j, k) approx_eq_impl!(Quat, w, i, j, k)
from_iterator_impl!(Quat, iterator, iterator, iterator, iterator) from_iterator_impl!(Quat, iterator, iterator, iterator, iterator)
@ -527,6 +473,4 @@ axpy_impl!(Quat, w, i, j, k)
iterable_impl!(Quat, 4) iterable_impl!(Quat, 4)
iterable_mut_impl!(Quat, 4) iterable_mut_impl!(Quat, 4)
double_dispatch_binop_decl_trait!(UnitQuat, UnitQuatMulRhs)
mul_redispatch_impl!(UnitQuat, UnitQuatMulRhs)
dim_impl!(UnitQuat, 3) dim_impl!(UnitQuat, 3)

52
src/structs/rot.rs
View File

@ -7,8 +7,8 @@ use traits::geometry::{Rotate, Rotation, AbsoluteRotate, RotationMatrix, Transfo
Norm, Cross}; Norm, Cross};
use traits::structure::{Cast, Dim, Row, Col, BaseFloat, BaseNum, Zero, One}; use traits::structure::{Cast, Dim, Row, Col, BaseFloat, BaseNum, Zero, One};
use traits::operations::{Absolute, Inv, Transpose, ApproxEq}; use traits::operations::{Absolute, Inv, Transpose, ApproxEq};
use structs::vec::{Vec1, Vec2, Vec3, Vec4, Vec2MulRhs, Vec3MulRhs, Vec4MulRhs}; use structs::vec::{Vec1, Vec2, Vec3, Vec4};
use structs::pnt::{Pnt2, Pnt3, Pnt4, Pnt2MulRhs, Pnt3MulRhs, Pnt4MulRhs}; use structs::pnt::{Pnt2, Pnt3, Pnt4};
use structs::mat::{Mat2, Mat3, Mat4, Mat5}; use structs::mat::{Mat2, Mat3, Mat4, Mat5};
@ -376,17 +376,15 @@ Rotation<Vec4<N>> for Rot4<N> {
* Common implementations. * Common implementations.
*/ */
double_dispatch_binop_decl_trait!(Rot2, Rot2MulRhs)
mul_redispatch_impl!(Rot2, Rot2MulRhs)
submat_impl!(Rot2, Mat2) submat_impl!(Rot2, Mat2)
rotate_impl!(Rot2RotateRhs, Rot2, Vec2, Pnt2) rotate_impl!(Rot2, Vec2, Pnt2)
transform_impl!(Rot2TransformRhs, Rot2, Vec2, Pnt2) transform_impl!(Rot2, Vec2, Pnt2)
dim_impl!(Rot2, 2) dim_impl!(Rot2, 2)
rot_mul_rot_impl!(Rot2, Rot2MulRhs) rot_mul_rot_impl!(Rot2)
rot_mul_vec_impl!(Rot2, Vec2, Rot2MulRhs) rot_mul_vec_impl!(Rot2, Vec2)
vec_mul_rot_impl!(Rot2, Vec2, Vec2MulRhs) vec_mul_rot_impl!(Rot2, Vec2)
rot_mul_pnt_impl!(Rot2, Pnt2, Rot2MulRhs) rot_mul_pnt_impl!(Rot2, Pnt2)
pnt_mul_rot_impl!(Rot2, Pnt2, Pnt2MulRhs) pnt_mul_rot_impl!(Rot2, Pnt2)
one_impl!(Rot2) one_impl!(Rot2)
rotation_matrix_impl!(Rot2, Vec2, Vec1) rotation_matrix_impl!(Rot2, Vec2, Vec1)
col_impl!(Rot2, Vec2) col_impl!(Rot2, Vec2)
@ -398,17 +396,15 @@ inv_impl!(Rot2)
transpose_impl!(Rot2) transpose_impl!(Rot2)
approx_eq_impl!(Rot2) approx_eq_impl!(Rot2)
double_dispatch_binop_decl_trait!(Rot3, Rot3MulRhs)
mul_redispatch_impl!(Rot3, Rot3MulRhs)
submat_impl!(Rot3, Mat3) submat_impl!(Rot3, Mat3)
rotate_impl!(Rot3RotateRhs, Rot3, Vec3, Pnt3) rotate_impl!(Rot3, Vec3, Pnt3)
transform_impl!(Rot3TransformRhs, Rot3, Vec3, Pnt3) transform_impl!(Rot3, Vec3, Pnt3)
dim_impl!(Rot3, 3) dim_impl!(Rot3, 3)
rot_mul_rot_impl!(Rot3, Rot3MulRhs) rot_mul_rot_impl!(Rot3)
rot_mul_vec_impl!(Rot3, Vec3, Rot3MulRhs) rot_mul_vec_impl!(Rot3, Vec3)
vec_mul_rot_impl!(Rot3, Vec3, Vec3MulRhs) vec_mul_rot_impl!(Rot3, Vec3)
rot_mul_pnt_impl!(Rot3, Pnt3, Rot3MulRhs) rot_mul_pnt_impl!(Rot3, Pnt3)
pnt_mul_rot_impl!(Rot3, Pnt3, Pnt3MulRhs) pnt_mul_rot_impl!(Rot3, Pnt3)
one_impl!(Rot3) one_impl!(Rot3)
rotation_matrix_impl!(Rot3, Vec3, Vec3) rotation_matrix_impl!(Rot3, Vec3, Vec3)
col_impl!(Rot3, Vec3) col_impl!(Rot3, Vec3)
@ -420,17 +416,15 @@ inv_impl!(Rot3)
transpose_impl!(Rot3) transpose_impl!(Rot3)
approx_eq_impl!(Rot3) approx_eq_impl!(Rot3)
double_dispatch_binop_decl_trait!(Rot4, Rot4MulRhs)
mul_redispatch_impl!(Rot4, Rot4MulRhs)
submat_impl!(Rot4, Mat4) submat_impl!(Rot4, Mat4)
rotate_impl!(Rot4RotateRhs, Rot4, Vec4, Pnt4) rotate_impl!(Rot4, Vec4, Pnt4)
transform_impl!(Rot4TransformRhs, Rot4, Vec4, Pnt4) transform_impl!(Rot4, Vec4, Pnt4)
dim_impl!(Rot4, 4) dim_impl!(Rot4, 4)
rot_mul_rot_impl!(Rot4, Rot4MulRhs) rot_mul_rot_impl!(Rot4)
rot_mul_vec_impl!(Rot4, Vec4, Rot4MulRhs) rot_mul_vec_impl!(Rot4, Vec4)
vec_mul_rot_impl!(Rot4, Vec4, Vec4MulRhs) vec_mul_rot_impl!(Rot4, Vec4)
rot_mul_pnt_impl!(Rot4, Pnt4, Rot4MulRhs) rot_mul_pnt_impl!(Rot4, Pnt4)
pnt_mul_rot_impl!(Rot4, Pnt4, Pnt4MulRhs) pnt_mul_rot_impl!(Rot4, Pnt4)
one_impl!(Rot4) one_impl!(Rot4)
rotation_matrix_impl!(Rot4, Vec4, Vec4) rotation_matrix_impl!(Rot4, Vec4, Vec4)
col_impl!(Rot4, Vec4) col_impl!(Rot4, Vec4)

118
src/structs/rot_macros.rs
View File

@ -12,98 +12,56 @@ macro_rules! submat_impl(
) )
macro_rules! rotate_impl( macro_rules! rotate_impl(
($trhs: ident, $t: ident, $tv: ident, $tp: ident) => ( ($t: ident, $tv: ident, $tp: ident) => (
/* impl<N: BaseNum + Clone> Rotate<$tv<N>> for $t<N> {
* FIXME: we use the double dispatch trick here so that we can rotate vectors _and_
* points. Remove this as soon as rust supports multidispatch.
*/
pub trait $trhs<N> {
fn rotate(left: &$t<N>, right: &Self) -> Self;
fn inv_rotate(left: &$t<N>, right: &Self) -> Self;
}
impl<N, V: $trhs<N>> Rotate<V> for $t<N> {
#[inline(always)]
fn rotate(&self, other: &V) -> V {
$trhs::rotate(self, other)
}
#[inline(always)]
fn inv_rotate(&self, other: &V) -> V {
$trhs::inv_rotate(self, other)
}
}
impl<N: BaseNum + Clone> $trhs<N> for $tv<N> {
#[inline] #[inline]
fn rotate(t: &$t<N>, v: &$tv<N>) -> $tv<N> { fn rotate(&self, v: &$tv<N>) -> $tv<N> {
*t * *v *self * *v
} }
#[inline] #[inline]
fn inv_rotate(t: &$t<N>, v: &$tv<N>) -> $tv<N> { fn inv_rotate(&self, v: &$tv<N>) -> $tv<N> {
*v * *t *v * *self
} }
} }
impl<N: BaseNum + Clone> $trhs<N> for $tp<N> { impl<N: BaseNum + Clone> Rotate<$tp<N>> for $t<N> {
#[inline] #[inline]
fn rotate(t: &$t<N>, p: &$tp<N>) -> $tp<N> { fn rotate(&self, p: &$tp<N>) -> $tp<N> {
*t * *p *self * *p
} }
#[inline] #[inline]
fn inv_rotate(t: &$t<N>, p: &$tp<N>) -> $tp<N> { fn inv_rotate(&self, p: &$tp<N>) -> $tp<N> {
*p * *t *p * *self
} }
} }
) )
) )
macro_rules! transform_impl( macro_rules! transform_impl(
($trhs: ident, $t: ident, $tv: ident, $tp: ident) => ( ($t: ident, $tv: ident, $tp: ident) => (
/* impl<N: BaseNum + Clone> Transform<$tv<N>> for $t<N> {
* FIXME: we use the double dispatch trick here so that we can transform vectors _and_
* points. Remove this as soon as rust supports multidispatch.
*/
pub trait $trhs<N> {
fn transform(left: &$t<N>, right: &Self) -> Self;
fn inv_transform(left: &$t<N>, right: &Self) -> Self;
}
impl<N, V: $trhs<N>> Transform<V> for $t<N> {
#[inline(always)]
fn transform(&self, other: &V) -> V {
$trhs::transform(self, other)
}
#[inline(always)]
fn inv_transform(&self, other: &V) -> V {
$trhs::inv_transform(self, other)
}
}
impl<N: BaseNum + Clone> $trhs<N> for $tv<N> {
#[inline] #[inline]
fn transform(t: &$t<N>, v: &$tv<N>) -> $tv<N> { fn transform(&self, v: &$tv<N>) -> $tv<N> {
t.rotate(v) self.rotate(v)
} }
#[inline] #[inline]
fn inv_transform(t: &$t<N>, v: &$tv<N>) -> $tv<N> { fn inv_transform(&self, v: &$tv<N>) -> $tv<N> {
t.inv_rotate(v) self.inv_rotate(v)
} }
} }
impl<N: BaseNum + Clone> $trhs<N> for $tp<N> { impl<N: BaseNum + Clone> Transform<$tp<N>> for $t<N> {
#[inline] #[inline]
fn transform(t: &$t<N>, p: &$tp<N>) -> $tp<N> { fn transform(&self, p: &$tp<N>) -> $tp<N> {
t.rotate(p) self.rotate(p)
} }
#[inline] #[inline]
fn inv_transform(t: &$t<N>, p: &$tp<N>) -> $tp<N> { fn inv_transform(&self, p: &$tp<N>) -> $tp<N> {
t.inv_rotate(p) self.inv_rotate(p)
} }
} }
) )
@ -143,47 +101,47 @@ macro_rules! one_impl(
) )
macro_rules! rot_mul_rot_impl( macro_rules! rot_mul_rot_impl(
($t: ident, $mulrhs: ident) => ( ($t: ident) => (
impl<N: BaseNum + Clone> $mulrhs<N, $t<N>> for $t<N> { impl<N: BaseNum + Clone> Mul<$t<N>, $t<N>> for $t<N> {
#[inline] #[inline]
fn binop(left: &$t<N>, right: &$t<N>) -> $t<N> { fn mul(&self, right: &$t<N>) -> $t<N> {
$t { submat: left.submat * right.submat } $t { submat: self.submat * right.submat }
} }
} }
) )
) )
macro_rules! rot_mul_vec_impl( macro_rules! rot_mul_vec_impl(
($t: ident, $tv: ident, $mulrhs: ident) => ( ($t: ident, $tv: ident) => (
impl<N: BaseNum + Clone> $mulrhs<N, $tv<N>> for $tv<N> { impl<N: BaseNum + Clone> Mul<$tv<N>, $tv<N>> for $t<N> {
#[inline] #[inline]
fn binop(left: &$t<N>, right: &$tv<N>) -> $tv<N> { fn mul(&self, right: &$tv<N>) -> $tv<N> {
left.submat * *right self.submat * *right
} }
} }
) )
) )
macro_rules! rot_mul_pnt_impl( macro_rules! rot_mul_pnt_impl(
($t: ident, $tv: ident, $mulrhs: ident) => ( ($t: ident, $tv: ident) => (
rot_mul_vec_impl!($t, $tv, $mulrhs) rot_mul_vec_impl!($t, $tv)
) )
) )
macro_rules! vec_mul_rot_impl( macro_rules! vec_mul_rot_impl(
($t: ident, $tv: ident, $mulrhs: ident) => ( ($t: ident, $tv: ident) => (
impl<N: BaseNum + Clone> $mulrhs<N, $tv<N>> for $t<N> { impl<N: BaseNum + Clone> Mul<$t<N>, $tv<N>> for $tv<N> {
#[inline] #[inline]
fn binop(left: &$tv<N>, right: &$t<N>) -> $tv<N> { fn mul(&self, right: &$t<N>) -> $tv<N> {
*left * right.submat *self * right.submat
} }
} }
) )
) )
macro_rules! pnt_mul_rot_impl( macro_rules! pnt_mul_rot_impl(
($t: ident, $tv: ident, $mulrhs: ident) => ( ($t: ident, $tv: ident) => (
vec_mul_rot_impl!($t, $tv, $mulrhs) vec_mul_rot_impl!($t, $tv)
) )
) )

112
src/structs/spec/mat.rs
View File

@ -1,6 +1,6 @@
use structs::vec::{Vec2, Vec3, Vec2MulRhs, Vec3MulRhs}; use structs::vec::{Vec2, Vec3};
use structs::pnt::{Pnt2, Pnt3, Pnt2MulRhs, Pnt3MulRhs}; use structs::pnt::{Pnt2, Pnt3};
use structs::mat::{Mat1, Mat2, Mat3, Mat3MulRhs, Mat2MulRhs}; use structs::mat::{Mat1, Mat2, Mat3};
use traits::operations::{Inv, Det, ApproxEq}; use traits::operations::{Inv, Det, ApproxEq};
use traits::structure::{Row, Col, BaseNum}; use traits::structure::{Row, Col, BaseNum};
@ -211,118 +211,118 @@ impl<N: Clone> Col<Vec3<N>> for Mat3<N> {
} }
} }
impl<N: Mul<N, N> + Add<N, N>> Mat3MulRhs<N, Mat3<N>> for Mat3<N> { impl<N: Mul<N, N> + Add<N, N>> Mul<Mat3<N>, Mat3<N>> for Mat3<N> {
#[inline] #[inline]
fn binop(left: &Mat3<N>, right: &Mat3<N>) -> Mat3<N> { fn mul(&self, right: &Mat3<N>) -> Mat3<N> {
Mat3::new( Mat3::new(
left.m11 * right.m11 + left.m12 * right.m21 + left.m13 * right.m31, self.m11 * right.m11 + self.m12 * right.m21 + self.m13 * right.m31,
left.m11 * right.m12 + left.m12 * right.m22 + left.m13 * right.m32, self.m11 * right.m12 + self.m12 * right.m22 + self.m13 * right.m32,
left.m11 * right.m13 + left.m12 * right.m23 + left.m13 * right.m33, self.m11 * right.m13 + self.m12 * right.m23 + self.m13 * right.m33,
left.m21 * right.m11 + left.m22 * right.m21 + left.m23 * right.m31, self.m21 * right.m11 + self.m22 * right.m21 + self.m23 * right.m31,
left.m21 * right.m12 + left.m22 * right.m22 + left.m23 * right.m32, self.m21 * right.m12 + self.m22 * right.m22 + self.m23 * right.m32,
left.m21 * right.m13 + left.m22 * right.m23 + left.m23 * right.m33, self.m21 * right.m13 + self.m22 * right.m23 + self.m23 * right.m33,
left.m31 * right.m11 + left.m32 * right.m21 + left.m33 * right.m31, self.m31 * right.m11 + self.m32 * right.m21 + self.m33 * right.m31,
left.m31 * right.m12 + left.m32 * right.m22 + left.m33 * right.m32, self.m31 * right.m12 + self.m32 * right.m22 + self.m33 * right.m32,
left.m31 * right.m13 + left.m32 * right.m23 + left.m33 * right.m33 self.m31 * right.m13 + self.m32 * right.m23 + self.m33 * right.m33
) )
} }
} }
impl<N: Mul<N, N> + Add<N, N>> Mat2MulRhs<N, Mat2<N>> for Mat2<N> { impl<N: Mul<N, N> + Add<N, N>> Mul<Mat2<N>, Mat2<N>> for Mat2<N> {
#[inline(always)] #[inline(always)]
fn binop(left: &Mat2<N>, right: &Mat2<N>) -> Mat2<N> { fn mul(&self, right: &Mat2<N>) -> Mat2<N> {
Mat2::new( Mat2::new(
left.m11 * right.m11 + left.m12 * right.m21, self.m11 * right.m11 + self.m12 * right.m21,
left.m11 * right.m12 + left.m12 * right.m22, self.m11 * right.m12 + self.m12 * right.m22,
left.m21 * right.m11 + left.m22 * right.m21, self.m21 * right.m11 + self.m22 * right.m21,
left.m21 * right.m12 + left.m22 * right.m22 self.m21 * right.m12 + self.m22 * right.m22
) )
} }
} }
impl<N: Mul<N, N> + Add<N, N>> Mat3MulRhs<N, Vec3<N>> for Vec3<N> { impl<N: Mul<N, N> + Add<N, N>> Mul<Vec3<N>, Vec3<N>> for Mat3<N> {
#[inline(always)] #[inline(always)]
fn binop(left: &Mat3<N>, right: &Vec3<N>) -> Vec3<N> { fn mul(&self, right: &Vec3<N>) -> Vec3<N> {
Vec3::new( Vec3::new(
left.m11 * right.x + left.m12 * right.y + left.m13 * right.z, self.m11 * right.x + self.m12 * right.y + self.m13 * right.z,
left.m21 * right.x + left.m22 * right.y + left.m23 * right.z, self.m21 * right.x + self.m22 * right.y + self.m23 * right.z,
left.m31 * right.x + left.m32 * right.y + left.m33 * right.z self.m31 * right.x + self.m32 * right.y + self.m33 * right.z
) )
} }
} }
impl<N: Mul<N, N> + Add<N, N>> Vec3MulRhs<N, Vec3<N>> for Mat3<N> { impl<N: Mul<N, N> + Add<N, N>> Mul<Mat3<N>, Vec3<N>> for Vec3<N> {
#[inline(always)] #[inline(always)]
fn binop(left: &Vec3<N>, right: &Mat3<N>) -> Vec3<N> { fn mul(&self, right: &Mat3<N>) -> Vec3<N> {
Vec3::new( Vec3::new(
left.x * right.m11 + left.y * right.m21 + left.z * right.m31, self.x * right.m11 + self.y * right.m21 + self.z * right.m31,
left.x * right.m12 + left.y * right.m22 + left.z * right.m32, self.x * right.m12 + self.y * right.m22 + self.z * right.m32,
left.x * right.m13 + left.y * right.m23 + left.z * right.m33 self.x * right.m13 + self.y * right.m23 + self.z * right.m33
) )
} }
} }
impl<N: Mul<N, N> + Add<N, N>> Vec2MulRhs<N, Vec2<N>> for Mat2<N> { impl<N: Mul<N, N> + Add<N, N>> Mul<Mat2<N>, Vec2<N>> for Vec2<N> {
#[inline(always)] #[inline(always)]
fn binop(left: &Vec2<N>, right: &Mat2<N>) -> Vec2<N> { fn mul(&self, right: &Mat2<N>) -> Vec2<N> {
Vec2::new( Vec2::new(
left.x * right.m11 + left.y * right.m21, self.x * right.m11 + self.y * right.m21,
left.x * right.m12 + left.y * right.m22 self.x * right.m12 + self.y * right.m22
) )
} }
} }
impl<N: Mul<N, N> + Add<N, N>> Mat2MulRhs<N, Vec2<N>> for Vec2<N> { impl<N: Mul<N, N> + Add<N, N>> Mul<Vec2<N>, Vec2<N>> for Mat2<N> {
#[inline(always)] #[inline(always)]
fn binop(left: &Mat2<N>, right: &Vec2<N>) -> Vec2<N> { fn mul(&self, right: &Vec2<N>) -> Vec2<N> {
Vec2::new( Vec2::new(
left.m11 * right.x + left.m12 * right.y, self.m11 * right.x + self.m12 * right.y,
left.m21 * right.x + left.m22 * right.y self.m21 * right.x + self.m22 * right.y
) )
} }
} }
impl<N: Mul<N, N> + Add<N, N>> Mat3MulRhs<N, Pnt3<N>> for Pnt3<N> { impl<N: Mul<N, N> + Add<N, N>> Mul<Pnt3<N>, Pnt3<N>> for Mat3<N> {
#[inline(always)] #[inline(always)]
fn binop(left: &Mat3<N>, right: &Pnt3<N>) -> Pnt3<N> { fn mul(&self, right: &Pnt3<N>) -> Pnt3<N> {
Pnt3::new( Pnt3::new(
left.m11 * right.x + left.m12 * right.y + left.m13 * right.z, self.m11 * right.x + self.m12 * right.y + self.m13 * right.z,
left.m21 * right.x + left.m22 * right.y + left.m23 * right.z, self.m21 * right.x + self.m22 * right.y + self.m23 * right.z,
left.m31 * right.x + left.m32 * right.y + left.m33 * right.z self.m31 * right.x + self.m32 * right.y + self.m33 * right.z
) )
} }
} }
impl<N: Mul<N, N> + Add<N, N>> Pnt3MulRhs<N, Pnt3<N>> for Mat3<N> { impl<N: Mul<N, N> + Add<N, N>> Mul<Mat3<N>, Pnt3<N>> for Pnt3<N> {
#[inline(always)] #[inline(always)]
fn binop(left: &Pnt3<N>, right: &Mat3<N>) -> Pnt3<N> { fn mul(&self, right: &Mat3<N>) -> Pnt3<N> {
Pnt3::new( Pnt3::new(
left.x * right.m11 + left.y * right.m21 + left.z * right.m31, self.x * right.m11 + self.y * right.m21 + self.z * right.m31,
left.x * right.m12 + left.y * right.m22 + left.z * right.m32, self.x * right.m12 + self.y * right.m22 + self.z * right.m32,
left.x * right.m13 + left.y * right.m23 + left.z * right.m33 self.x * right.m13 + self.y * right.m23 + self.z * right.m33
) )
} }
} }
impl<N: Mul<N, N> + Add<N, N>> Pnt2MulRhs<N, Pnt2<N>> for Mat2<N> { impl<N: Mul<N, N> + Add<N, N>> Mul<Mat2<N>, Pnt2<N>> for Pnt2<N> {
#[inline(always)] #[inline(always)]
fn binop(left: &Pnt2<N>, right: &Mat2<N>) -> Pnt2<N> { fn mul(&self, right: &Mat2<N>) -> Pnt2<N> {
Pnt2::new( Pnt2::new(
left.x * right.m11 + left.y * right.m21, self.x * right.m11 + self.y * right.m21,
left.x * right.m12 + left.y * right.m22 self.x * right.m12 + self.y * right.m22
) )
} }
} }
impl<N: Mul<N, N> + Add<N, N>> Mat2MulRhs<N, Pnt2<N>> for Pnt2<N> { impl<N: Mul<N, N> + Add<N, N>> Mul<Pnt2<N>, Pnt2<N>> for Mat2<N> {
#[inline(always)] #[inline(always)]
fn binop(left: &Mat2<N>, right: &Pnt2<N>) -> Pnt2<N> { fn mul(&self, right: &Pnt2<N>) -> Pnt2<N> {
Pnt2::new( Pnt2::new(
left.m11 * right.x + left.m12 * right.y, self.m11 * right.x + self.m12 * right.y,
left.m21 * right.x + left.m22 * right.y self.m21 * right.x + self.m22 * right.y
) )
} }
} }

455
src/structs/vec.rs
View File

@ -33,26 +33,16 @@ impl<N> Vec0<N> {
} }
/// Vector of dimension 1. /// Vector of dimension 1.
#[deriving(Eq, PartialEq, Encodable, Decodable, Clone, Hash, Rand, Zero, Show)] #[deriving(Eq, PartialEq, Encodable, Decodable, Clone, Hash, Rand, Show)]
pub struct Vec1<N> { pub struct Vec1<N> {
/// First component of the vector. /// First component of the vector.
pub x: N pub x: N
} }
double_dispatch_binop_decl_trait!(Vec1, Vec1MulRhs)
double_dispatch_binop_decl_trait!(Vec1, Vec1DivRhs)
double_dispatch_binop_decl_trait!(Vec1, Vec1AddRhs)
double_dispatch_binop_decl_trait!(Vec1, Vec1SubRhs)
double_dispatch_cast_decl_trait!(Vec1, Vec1Cast)
mul_redispatch_impl!(Vec1, Vec1MulRhs)
div_redispatch_impl!(Vec1, Vec1DivRhs)
add_redispatch_impl!(Vec1, Vec1AddRhs)
sub_redispatch_impl!(Vec1, Vec1SubRhs)
cast_redispatch_impl!(Vec1, Vec1Cast)
new_impl!(Vec1, x) new_impl!(Vec1, x)
ord_impl!(Vec1, x) ord_impl!(Vec1, x)
vec_axis_impl!(Vec1, x) vec_axis_impl!(Vec1, x)
vec_cast_impl!(Vec1, Vec1Cast, x) vec_cast_impl!(Vec1, x)
as_array_impl!(Vec1, 1) as_array_impl!(Vec1, 1)
index_impl!(Vec1) index_impl!(Vec1)
indexable_impl!(Vec1, 1) indexable_impl!(Vec1, 1)
@ -61,61 +51,17 @@ new_repeat_impl!(Vec1, val, x)
dim_impl!(Vec1, 1) dim_impl!(Vec1, 1)
container_impl!(Vec1) container_impl!(Vec1)
// (specialized) basis_impl!(Vec1, 1) // (specialized) basis_impl!(Vec1, 1)
add_impl!(Vec1, Vec1AddRhs, x) add_impl!(Vec1, x)
sub_impl!(Vec1, Vec1SubRhs, x) sub_impl!(Vec1, x)
mul_impl!(Vec1, Vec1MulRhs, x) mul_impl!(Vec1, x)
div_impl!(Vec1, Vec1DivRhs, x) div_impl!(Vec1, x)
scalar_add_impl!(Vec1, x)
scalar_sub_impl!(Vec1, x)
scalar_mul_impl!(Vec1, x)
scalar_div_impl!(Vec1, x)
neg_impl!(Vec1, x) neg_impl!(Vec1, x)
dot_impl!(Vec1, x) dot_impl!(Vec1, x)
scalar_ops_impl!(Vec1, x) scalar_ops_impl!(Vec1, x)
vec_mul_scalar_impl!(Vec1, f64, Vec1MulRhs, x)
vec_mul_scalar_impl!(Vec1, f32, Vec1MulRhs, x)
vec_mul_scalar_impl!(Vec1, u64, Vec1MulRhs, x)
vec_mul_scalar_impl!(Vec1, u32, Vec1MulRhs, x)
vec_mul_scalar_impl!(Vec1, u16, Vec1MulRhs, x)
vec_mul_scalar_impl!(Vec1, u8, Vec1MulRhs, x)
vec_mul_scalar_impl!(Vec1, i64, Vec1MulRhs, x)
vec_mul_scalar_impl!(Vec1, i32, Vec1MulRhs, x)
vec_mul_scalar_impl!(Vec1, i16, Vec1MulRhs, x)
vec_mul_scalar_impl!(Vec1, i8, Vec1MulRhs, x)
vec_mul_scalar_impl!(Vec1, uint, Vec1MulRhs, x)
vec_mul_scalar_impl!(Vec1, int, Vec1MulRhs, x)
vec_div_scalar_impl!(Vec1, f64, Vec1DivRhs, x)
vec_div_scalar_impl!(Vec1, f32, Vec1DivRhs, x)
vec_div_scalar_impl!(Vec1, u64, Vec1DivRhs, x)
vec_div_scalar_impl!(Vec1, u32, Vec1DivRhs, x)
vec_div_scalar_impl!(Vec1, u16, Vec1DivRhs, x)
vec_div_scalar_impl!(Vec1, u8, Vec1DivRhs, x)
vec_div_scalar_impl!(Vec1, i64, Vec1DivRhs, x)
vec_div_scalar_impl!(Vec1, i32, Vec1DivRhs, x)
vec_div_scalar_impl!(Vec1, i16, Vec1DivRhs, x)
vec_div_scalar_impl!(Vec1, i8, Vec1DivRhs, x)
vec_div_scalar_impl!(Vec1, uint, Vec1DivRhs, x)
vec_div_scalar_impl!(Vec1, int, Vec1DivRhs, x)
vec_add_scalar_impl!(Vec1, f64, Vec1AddRhs, x)
vec_add_scalar_impl!(Vec1, f32, Vec1AddRhs, x)
vec_add_scalar_impl!(Vec1, u64, Vec1AddRhs, x)
vec_add_scalar_impl!(Vec1, u32, Vec1AddRhs, x)
vec_add_scalar_impl!(Vec1, u16, Vec1AddRhs, x)
vec_add_scalar_impl!(Vec1, u8, Vec1AddRhs, x)
vec_add_scalar_impl!(Vec1, i64, Vec1AddRhs, x)
vec_add_scalar_impl!(Vec1, i32, Vec1AddRhs, x)
vec_add_scalar_impl!(Vec1, i16, Vec1AddRhs, x)
vec_add_scalar_impl!(Vec1, i8, Vec1AddRhs, x)
vec_add_scalar_impl!(Vec1, uint, Vec1AddRhs, x)
vec_add_scalar_impl!(Vec1, int, Vec1AddRhs, x)
vec_sub_scalar_impl!(Vec1, f64, Vec1SubRhs, x)
vec_sub_scalar_impl!(Vec1, f32, Vec1SubRhs, x)
vec_sub_scalar_impl!(Vec1, u64, Vec1SubRhs, x)
vec_sub_scalar_impl!(Vec1, u32, Vec1SubRhs, x)
vec_sub_scalar_impl!(Vec1, u16, Vec1SubRhs, x)
vec_sub_scalar_impl!(Vec1, u8, Vec1SubRhs, x)
vec_sub_scalar_impl!(Vec1, i64, Vec1SubRhs, x)
vec_sub_scalar_impl!(Vec1, i32, Vec1SubRhs, x)
vec_sub_scalar_impl!(Vec1, i16, Vec1SubRhs, x)
vec_sub_scalar_impl!(Vec1, i8, Vec1SubRhs, x)
vec_sub_scalar_impl!(Vec1, uint, Vec1SubRhs, x)
vec_sub_scalar_impl!(Vec1, int, Vec1SubRhs, x)
translation_impl!(Vec1) translation_impl!(Vec1)
norm_impl!(Vec1, x) norm_impl!(Vec1, x)
approx_eq_impl!(Vec1, x) approx_eq_impl!(Vec1, x)
@ -132,7 +78,7 @@ rotate_impl!(Vec1)
rotate_impl!(Pnt1) rotate_impl!(Pnt1)
transform_impl!(Vec1, Pnt1) transform_impl!(Vec1, Pnt1)
vec_as_pnt_impl!(Vec1, Pnt1, x) vec_as_pnt_impl!(Vec1, Pnt1, x)
num_float_vec_impl!(Vec1, Vec1MulRhs, Vec1DivRhs) num_float_vec_impl!(Vec1)
absolute_vec_impl!(Vec1, x) absolute_vec_impl!(Vec1, x)
/// Vector of dimension 2. /// Vector of dimension 2.
@ -144,20 +90,10 @@ pub struct Vec2<N> {
pub y: N pub y: N
} }
double_dispatch_binop_decl_trait!(Vec2, Vec2MulRhs)
double_dispatch_binop_decl_trait!(Vec2, Vec2DivRhs)
double_dispatch_binop_decl_trait!(Vec2, Vec2AddRhs)
double_dispatch_binop_decl_trait!(Vec2, Vec2SubRhs)
double_dispatch_cast_decl_trait!(Vec2, Vec2Cast)
mul_redispatch_impl!(Vec2, Vec2MulRhs)
div_redispatch_impl!(Vec2, Vec2DivRhs)
add_redispatch_impl!(Vec2, Vec2AddRhs)
sub_redispatch_impl!(Vec2, Vec2SubRhs)
cast_redispatch_impl!(Vec2, Vec2Cast)
new_impl!(Vec2, x, y) new_impl!(Vec2, x, y)
ord_impl!(Vec2, x, y) ord_impl!(Vec2, x, y)
vec_axis_impl!(Vec2, x, y) vec_axis_impl!(Vec2, x, y)
vec_cast_impl!(Vec2, Vec2Cast, x, y) vec_cast_impl!(Vec2, x, y)
as_array_impl!(Vec2, 2) as_array_impl!(Vec2, 2)
index_impl!(Vec2) index_impl!(Vec2)
indexable_impl!(Vec2, 2) indexable_impl!(Vec2, 2)
@ -166,61 +102,17 @@ new_repeat_impl!(Vec2, val, x, y)
dim_impl!(Vec2, 2) dim_impl!(Vec2, 2)
container_impl!(Vec2) container_impl!(Vec2)
// (specialized) basis_impl!(Vec2, 1) // (specialized) basis_impl!(Vec2, 1)
add_impl!(Vec2, Vec2AddRhs, x, y) add_impl!(Vec2, x, y)
sub_impl!(Vec2, Vec2SubRhs, x, y) sub_impl!(Vec2, x, y)
mul_impl!(Vec2, Vec2MulRhs, x, y) mul_impl!(Vec2, x, y)
div_impl!(Vec2, Vec2DivRhs, x, y) div_impl!(Vec2, x, y)
scalar_add_impl!(Vec2, x, y)
scalar_sub_impl!(Vec2, x, y)
scalar_mul_impl!(Vec2, x, y)
scalar_div_impl!(Vec2, x, y)
neg_impl!(Vec2, x, y) neg_impl!(Vec2, x, y)
dot_impl!(Vec2, x, y) dot_impl!(Vec2, x, y)
scalar_ops_impl!(Vec2, x, y) scalar_ops_impl!(Vec2, x, y)
vec_mul_scalar_impl!(Vec2, f64, Vec2MulRhs, x, y)
vec_mul_scalar_impl!(Vec2, f32, Vec2MulRhs, x, y)
vec_mul_scalar_impl!(Vec2, u64, Vec2MulRhs, x, y)
vec_mul_scalar_impl!(Vec2, u32, Vec2MulRhs, x, y)
vec_mul_scalar_impl!(Vec2, u16, Vec2MulRhs, x, y)
vec_mul_scalar_impl!(Vec2, u8, Vec2MulRhs, x, y)
vec_mul_scalar_impl!(Vec2, i64, Vec2MulRhs, x, y)
vec_mul_scalar_impl!(Vec2, i32, Vec2MulRhs, x, y)
vec_mul_scalar_impl!(Vec2, i16, Vec2MulRhs, x, y)
vec_mul_scalar_impl!(Vec2, i8, Vec2MulRhs, x, y)
vec_mul_scalar_impl!(Vec2, uint, Vec2MulRhs, x, y)
vec_mul_scalar_impl!(Vec2, int, Vec2MulRhs, x, y)
vec_div_scalar_impl!(Vec2, f64, Vec2DivRhs, x, y)
vec_div_scalar_impl!(Vec2, f32, Vec2DivRhs, x, y)
vec_div_scalar_impl!(Vec2, u64, Vec2DivRhs, x, y)
vec_div_scalar_impl!(Vec2, u32, Vec2DivRhs, x, y)
vec_div_scalar_impl!(Vec2, u16, Vec2DivRhs, x, y)
vec_div_scalar_impl!(Vec2, u8, Vec2DivRhs, x, y)
vec_div_scalar_impl!(Vec2, i64, Vec2DivRhs, x, y)
vec_div_scalar_impl!(Vec2, i32, Vec2DivRhs, x, y)
vec_div_scalar_impl!(Vec2, i16, Vec2DivRhs, x, y)
vec_div_scalar_impl!(Vec2, i8, Vec2DivRhs, x, y)
vec_div_scalar_impl!(Vec2, uint, Vec2DivRhs, x, y)
vec_div_scalar_impl!(Vec2, int, Vec2DivRhs, x, y)
vec_add_scalar_impl!(Vec2, f64, Vec2AddRhs, x, y)
vec_add_scalar_impl!(Vec2, f32, Vec2AddRhs, x, y)
vec_add_scalar_impl!(Vec2, u64, Vec2AddRhs, x, y)
vec_add_scalar_impl!(Vec2, u32, Vec2AddRhs, x, y)
vec_add_scalar_impl!(Vec2, u16, Vec2AddRhs, x, y)
vec_add_scalar_impl!(Vec2, u8, Vec2AddRhs, x, y)
vec_add_scalar_impl!(Vec2, i64, Vec2AddRhs, x, y)
vec_add_scalar_impl!(Vec2, i32, Vec2AddRhs, x, y)
vec_add_scalar_impl!(Vec2, i16, Vec2AddRhs, x, y)
vec_add_scalar_impl!(Vec2, i8, Vec2AddRhs, x, y)
vec_add_scalar_impl!(Vec2, uint, Vec2AddRhs, x, y)
vec_add_scalar_impl!(Vec2, int, Vec2AddRhs, x, y)
vec_sub_scalar_impl!(Vec2, f64, Vec2SubRhs, x, y)
vec_sub_scalar_impl!(Vec2, f32, Vec2SubRhs, x, y)
vec_sub_scalar_impl!(Vec2, u64, Vec2SubRhs, x, y)
vec_sub_scalar_impl!(Vec2, u32, Vec2SubRhs, x, y)
vec_sub_scalar_impl!(Vec2, u16, Vec2SubRhs, x, y)
vec_sub_scalar_impl!(Vec2, u8, Vec2SubRhs, x, y)
vec_sub_scalar_impl!(Vec2, i64, Vec2SubRhs, x, y)
vec_sub_scalar_impl!(Vec2, i32, Vec2SubRhs, x, y)
vec_sub_scalar_impl!(Vec2, i16, Vec2SubRhs, x, y)
vec_sub_scalar_impl!(Vec2, i8, Vec2SubRhs, x, y)
vec_sub_scalar_impl!(Vec2, uint, Vec2SubRhs, x, y)
vec_sub_scalar_impl!(Vec2, int, Vec2SubRhs, x, y)
translation_impl!(Vec2) translation_impl!(Vec2)
norm_impl!(Vec2, x, y) norm_impl!(Vec2, x, y)
approx_eq_impl!(Vec2, x, y) approx_eq_impl!(Vec2, x, y)
@ -237,7 +129,7 @@ rotate_impl!(Vec2)
rotate_impl!(Pnt2) rotate_impl!(Pnt2)
transform_impl!(Vec2, Pnt2) transform_impl!(Vec2, Pnt2)
vec_as_pnt_impl!(Vec2, Pnt2, x, y) vec_as_pnt_impl!(Vec2, Pnt2, x, y)
num_float_vec_impl!(Vec2, Vec2MulRhs, Vec2DivRhs) num_float_vec_impl!(Vec2)
absolute_vec_impl!(Vec2, x, y) absolute_vec_impl!(Vec2, x, y)
/// Vector of dimension 3. /// Vector of dimension 3.
@ -251,20 +143,10 @@ pub struct Vec3<N> {
pub z: N pub z: N
} }
double_dispatch_binop_decl_trait!(Vec3, Vec3MulRhs)
double_dispatch_binop_decl_trait!(Vec3, Vec3DivRhs)
double_dispatch_binop_decl_trait!(Vec3, Vec3AddRhs)
double_dispatch_binop_decl_trait!(Vec3, Vec3SubRhs)
double_dispatch_cast_decl_trait!(Vec3, Vec3Cast)
mul_redispatch_impl!(Vec3, Vec3MulRhs)
div_redispatch_impl!(Vec3, Vec3DivRhs)
add_redispatch_impl!(Vec3, Vec3AddRhs)
sub_redispatch_impl!(Vec3, Vec3SubRhs)
cast_redispatch_impl!(Vec3, Vec3Cast)
new_impl!(Vec3, x, y, z) new_impl!(Vec3, x, y, z)
ord_impl!(Vec3, x, y, z) ord_impl!(Vec3, x, y, z)
vec_axis_impl!(Vec3, x, y, z) vec_axis_impl!(Vec3, x, y, z)
vec_cast_impl!(Vec3, Vec3Cast, x, y, z) vec_cast_impl!(Vec3, x, y, z)
as_array_impl!(Vec3, 3) as_array_impl!(Vec3, 3)
index_impl!(Vec3) index_impl!(Vec3)
indexable_impl!(Vec3, 3) indexable_impl!(Vec3, 3)
@ -273,64 +155,17 @@ new_repeat_impl!(Vec3, val, x, y, z)
dim_impl!(Vec3, 3) dim_impl!(Vec3, 3)
container_impl!(Vec3) container_impl!(Vec3)
// (specialized) basis_impl!(Vec3, 1) // (specialized) basis_impl!(Vec3, 1)
add_impl!(Vec3, Vec3AddRhs, x, y, z) add_impl!(Vec3, x, y, z)
sub_impl!(Vec3, Vec3SubRhs, x, y, z) sub_impl!(Vec3, x, y, z)
mul_impl!(Vec3, Vec3MulRhs, x, y, z) mul_impl!(Vec3, x, y, z)
div_impl!(Vec3, Vec3DivRhs, x, y, z) div_impl!(Vec3, x, y, z)
scalar_add_impl!(Vec3, x, y, z)
scalar_sub_impl!(Vec3, x, y, z)
scalar_mul_impl!(Vec3, x, y, z)
scalar_div_impl!(Vec3, x, y, z)
neg_impl!(Vec3, x, y, z) neg_impl!(Vec3, x, y, z)
dot_impl!(Vec3, x, y, z) dot_impl!(Vec3, x, y, z)
scalar_ops_impl!(Vec3, x, y, z) scalar_ops_impl!(Vec3, x, y, z)
vec_mul_scalar_impl!(Vec3, f64, Vec3MulRhs, x, y, z)
vec_mul_scalar_impl!(Vec3, f32, Vec3MulRhs, x, y, z)
vec_mul_scalar_impl!(Vec3, u64, Vec3MulRhs, x, y, z)
vec_mul_scalar_impl!(Vec3, u32, Vec3MulRhs, x, y, z)
vec_mul_scalar_impl!(Vec3, u16, Vec3MulRhs, x, y, z)
vec_mul_scalar_impl!(Vec3, u8, Vec3MulRhs, x, y, z)
vec_mul_scalar_impl!(Vec3, i64, Vec3MulRhs, x, y, z)
vec_mul_scalar_impl!(Vec3, i32, Vec3MulRhs, x, y, z)
vec_mul_scalar_impl!(Vec3, i16, Vec3MulRhs, x, y, z)
vec_mul_scalar_impl!(Vec3, i8, Vec3MulRhs, x, y, z)
vec_mul_scalar_impl!(Vec3, uint, Vec3MulRhs, x, y, z)
vec_mul_scalar_impl!(Vec3, int, Vec3MulRhs, x, y, z)
vec_div_scalar_impl!(Vec3, f64, Vec3DivRhs, x, y, z)
vec_div_scalar_impl!(Vec3, f32, Vec3DivRhs, x, y, z)
vec_div_scalar_impl!(Vec3, u64, Vec3DivRhs, x, y, z)
vec_div_scalar_impl!(Vec3, u32, Vec3DivRhs, x, y, z)
vec_div_scalar_impl!(Vec3, u16, Vec3DivRhs, x, y, z)
vec_div_scalar_impl!(Vec3, u8, Vec3DivRhs, x, y, z)
vec_div_scalar_impl!(Vec3, i64, Vec3DivRhs, x, y, z)
vec_div_scalar_impl!(Vec3, i32, Vec3DivRhs, x, y, z)
vec_div_scalar_impl!(Vec3, i16, Vec3DivRhs, x, y, z)
vec_div_scalar_impl!(Vec3, i8, Vec3DivRhs, x, y, z)
vec_div_scalar_impl!(Vec3, uint, Vec3DivRhs, x, y, z)
vec_div_scalar_impl!(Vec3, int, Vec3DivRhs, x, y, z)
vec_add_scalar_impl!(Vec3, f64, Vec3AddRhs, x, y, z)
vec_add_scalar_impl!(Vec3, f32, Vec3AddRhs, x, y, z)
vec_add_scalar_impl!(Vec3, u64, Vec3AddRhs, x, y, z)
vec_add_scalar_impl!(Vec3, u32, Vec3AddRhs, x, y, z)
vec_add_scalar_impl!(Vec3, u16, Vec3AddRhs, x, y, z)
vec_add_scalar_impl!(Vec3, u8, Vec3AddRhs, x, y, z)
vec_add_scalar_impl!(Vec3, i64, Vec3AddRhs, x, y, z)
vec_add_scalar_impl!(Vec3, i32, Vec3AddRhs, x, y, z)
vec_add_scalar_impl!(Vec3, i16, Vec3AddRhs, x, y, z)
vec_add_scalar_impl!(Vec3, i8, Vec3AddRhs, x, y, z)
vec_add_scalar_impl!(Vec3, uint, Vec3AddRhs, x, y, z)
vec_add_scalar_impl!(Vec3, int, Vec3AddRhs, x, y, z)
vec_sub_scalar_impl!(Vec3, f64, Vec3SubRhs, x, y, z)
vec_sub_scalar_impl!(Vec3, f32, Vec3SubRhs, x, y, z)
vec_sub_scalar_impl!(Vec3, u64, Vec3SubRhs, x, y, z)
vec_sub_scalar_impl!(Vec3, u32, Vec3SubRhs, x, y, z)
vec_sub_scalar_impl!(Vec3, u16, Vec3SubRhs, x, y, z)
vec_sub_scalar_impl!(Vec3, u8, Vec3SubRhs, x, y, z)
vec_sub_scalar_impl!(Vec3, i64, Vec3SubRhs, x, y, z)
vec_sub_scalar_impl!(Vec3, i32, Vec3SubRhs, x, y, z)
vec_sub_scalar_impl!(Vec3, i16, Vec3SubRhs, x, y, z)
vec_sub_scalar_impl!(Vec3, i8, Vec3SubRhs, x, y, z)
vec_sub_scalar_impl!(Vec3, uint, Vec3SubRhs, x, y, z)
vec_sub_scalar_impl!(Vec3, int, Vec3SubRhs, x, y, z)
translation_impl!(Vec3) translation_impl!(Vec3)
norm_impl!(Vec3, x, y ,z) norm_impl!(Vec3, x, y ,z)
approx_eq_impl!(Vec3, x, y, z) approx_eq_impl!(Vec3, x, y, z)
@ -347,7 +182,7 @@ rotate_impl!(Vec3)
rotate_impl!(Pnt3) rotate_impl!(Pnt3)
transform_impl!(Vec3, Pnt3) transform_impl!(Vec3, Pnt3)
vec_as_pnt_impl!(Vec3, Pnt3, x, y, z) vec_as_pnt_impl!(Vec3, Pnt3, x, y, z)
num_float_vec_impl!(Vec3, Vec3MulRhs, Vec3DivRhs) num_float_vec_impl!(Vec3)
absolute_vec_impl!(Vec3, x, y, z) absolute_vec_impl!(Vec3, x, y, z)
@ -364,20 +199,10 @@ pub struct Vec4<N> {
pub w: N pub w: N
} }
double_dispatch_binop_decl_trait!(Vec4, Vec4MulRhs)
double_dispatch_binop_decl_trait!(Vec4, Vec4DivRhs)
double_dispatch_binop_decl_trait!(Vec4, Vec4AddRhs)
double_dispatch_binop_decl_trait!(Vec4, Vec4SubRhs)
double_dispatch_cast_decl_trait!(Vec4, Vec4Cast)
mul_redispatch_impl!(Vec4, Vec4MulRhs)
div_redispatch_impl!(Vec4, Vec4DivRhs)
add_redispatch_impl!(Vec4, Vec4AddRhs)
sub_redispatch_impl!(Vec4, Vec4SubRhs)
cast_redispatch_impl!(Vec4, Vec4Cast)
new_impl!(Vec4, x, y, z, w) new_impl!(Vec4, x, y, z, w)
ord_impl!(Vec4, x, y, z, w) ord_impl!(Vec4, x, y, z, w)
vec_axis_impl!(Vec4, x, y, z, w) vec_axis_impl!(Vec4, x, y, z, w)
vec_cast_impl!(Vec4, Vec4Cast, x, y, z, w) vec_cast_impl!(Vec4, x, y, z, w)
as_array_impl!(Vec4, 4) as_array_impl!(Vec4, 4)
index_impl!(Vec4) index_impl!(Vec4)
indexable_impl!(Vec4, 4) indexable_impl!(Vec4, 4)
@ -385,62 +210,18 @@ at_fast_impl!(Vec4, 4)
new_repeat_impl!(Vec4, val, x, y, z, w) new_repeat_impl!(Vec4, val, x, y, z, w)
dim_impl!(Vec4, 4) dim_impl!(Vec4, 4)
container_impl!(Vec4) container_impl!(Vec4)
basis_impl!(Vec4, Vec4MulRhs, 4) basis_impl!(Vec4, 4)
add_impl!(Vec4, Vec4AddRhs, x, y, z, w) add_impl!(Vec4, x, y, z, w)
sub_impl!(Vec4, Vec4SubRhs, x, y, z, w) sub_impl!(Vec4, x, y, z, w)
mul_impl!(Vec4, Vec4MulRhs, x, y, z, w) mul_impl!(Vec4, x, y, z, w)
div_impl!(Vec4, Vec4DivRhs, x, y, z, w) div_impl!(Vec4, x, y, z, w)
scalar_add_impl!(Vec4, x, y, z, w)
scalar_sub_impl!(Vec4, x, y, z, w)
scalar_mul_impl!(Vec4, x, y, z, w)
scalar_div_impl!(Vec4, x, y, z, w)
neg_impl!(Vec4, x, y, z, w) neg_impl!(Vec4, x, y, z, w)
dot_impl!(Vec4, x, y, z, w) dot_impl!(Vec4, x, y, z, w)
scalar_ops_impl!(Vec4, x, y, z, w) scalar_ops_impl!(Vec4, x, y, z, w)
vec_mul_scalar_impl!(Vec4, f64, Vec4MulRhs, x, y, z, w)
vec_mul_scalar_impl!(Vec4, f32, Vec4MulRhs, x, y, z, w)
vec_mul_scalar_impl!(Vec4, u64, Vec4MulRhs, x, y, z, w)
vec_mul_scalar_impl!(Vec4, u32, Vec4MulRhs, x, y, z, w)
vec_mul_scalar_impl!(Vec4, u16, Vec4MulRhs, x, y, z, w)
vec_mul_scalar_impl!(Vec4, u8, Vec4MulRhs, x, y, z, w)
vec_mul_scalar_impl!(Vec4, i64, Vec4MulRhs, x, y, z, w)
vec_mul_scalar_impl!(Vec4, i32, Vec4MulRhs, x, y, z, w)
vec_mul_scalar_impl!(Vec4, i16, Vec4MulRhs, x, y, z, w)
vec_mul_scalar_impl!(Vec4, i8, Vec4MulRhs, x, y, z, w)
vec_mul_scalar_impl!(Vec4, uint, Vec4MulRhs, x, y, z, w)
vec_mul_scalar_impl!(Vec4, int, Vec4MulRhs, x, y, z, w)
vec_div_scalar_impl!(Vec4, f64, Vec4DivRhs, x, y, z, w)
vec_div_scalar_impl!(Vec4, f32, Vec4DivRhs, x, y, z, w)
vec_div_scalar_impl!(Vec4, u64, Vec4DivRhs, x, y, z, w)
vec_div_scalar_impl!(Vec4, u32, Vec4DivRhs, x, y, z, w)
vec_div_scalar_impl!(Vec4, u16, Vec4DivRhs, x, y, z, w)
vec_div_scalar_impl!(Vec4, u8, Vec4DivRhs, x, y, z, w)
vec_div_scalar_impl!(Vec4, i64, Vec4DivRhs, x, y, z, w)
vec_div_scalar_impl!(Vec4, i32, Vec4DivRhs, x, y, z, w)
vec_div_scalar_impl!(Vec4, i16, Vec4DivRhs, x, y, z, w)
vec_div_scalar_impl!(Vec4, i8, Vec4DivRhs, x, y, z, w)
vec_div_scalar_impl!(Vec4, uint, Vec4DivRhs, x, y, z, w)
vec_div_scalar_impl!(Vec4, int, Vec4DivRhs, x, y, z, w)
vec_add_scalar_impl!(Vec4, f64, Vec4AddRhs, x, y, z, w)
vec_add_scalar_impl!(Vec4, f32, Vec4AddRhs, x, y, z, w)
vec_add_scalar_impl!(Vec4, u64, Vec4AddRhs, x, y, z, w)
vec_add_scalar_impl!(Vec4, u32, Vec4AddRhs, x, y, z, w)
vec_add_scalar_impl!(Vec4, u16, Vec4AddRhs, x, y, z, w)
vec_add_scalar_impl!(Vec4, u8, Vec4AddRhs, x, y, z, w)
vec_add_scalar_impl!(Vec4, i64, Vec4AddRhs, x, y, z, w)
vec_add_scalar_impl!(Vec4, i32, Vec4AddRhs, x, y, z, w)
vec_add_scalar_impl!(Vec4, i16, Vec4AddRhs, x, y, z, w)
vec_add_scalar_impl!(Vec4, i8, Vec4AddRhs, x, y, z, w)
vec_add_scalar_impl!(Vec4, uint, Vec4AddRhs, x, y, z, w)
vec_add_scalar_impl!(Vec4, int, Vec4AddRhs, x, y, z, w)
vec_sub_scalar_impl!(Vec4, f64, Vec4SubRhs, x, y, z, w)
vec_sub_scalar_impl!(Vec4, f32, Vec4SubRhs, x, y, z, w)
vec_sub_scalar_impl!(Vec4, u64, Vec4SubRhs, x, y, z, w)
vec_sub_scalar_impl!(Vec4, u32, Vec4SubRhs, x, y, z, w)
vec_sub_scalar_impl!(Vec4, u16, Vec4SubRhs, x, y, z, w)
vec_sub_scalar_impl!(Vec4, u8, Vec4SubRhs, x, y, z, w)
vec_sub_scalar_impl!(Vec4, i64, Vec4SubRhs, x, y, z, w)
vec_sub_scalar_impl!(Vec4, i32, Vec4SubRhs, x, y, z, w)
vec_sub_scalar_impl!(Vec4, i16, Vec4SubRhs, x, y, z, w)
vec_sub_scalar_impl!(Vec4, i8, Vec4SubRhs, x, y, z, w)
vec_sub_scalar_impl!(Vec4, uint, Vec4SubRhs, x, y, z, w)
vec_sub_scalar_impl!(Vec4, int, Vec4SubRhs, x, y, z, w)
translation_impl!(Vec4) translation_impl!(Vec4)
norm_impl!(Vec4, x, y, z, w) norm_impl!(Vec4, x, y, z, w)
approx_eq_impl!(Vec4, x, y, z, w) approx_eq_impl!(Vec4, x, y, z, w)
@ -457,7 +238,7 @@ rotate_impl!(Vec4)
rotate_impl!(Pnt4) rotate_impl!(Pnt4)
transform_impl!(Vec4, Pnt4) transform_impl!(Vec4, Pnt4)
vec_as_pnt_impl!(Vec4, Pnt4, x, y, z, w) vec_as_pnt_impl!(Vec4, Pnt4, x, y, z, w)
num_float_vec_impl!(Vec4, Vec4MulRhs, Vec4DivRhs) num_float_vec_impl!(Vec4)
absolute_vec_impl!(Vec4, x, y, z, w) absolute_vec_impl!(Vec4, x, y, z, w)
/// Vector of dimension 5. /// Vector of dimension 5.
@ -475,20 +256,10 @@ pub struct Vec5<N> {
pub a: N pub a: N
} }
double_dispatch_binop_decl_trait!(Vec5, Vec5MulRhs)
double_dispatch_binop_decl_trait!(Vec5, Vec5DivRhs)
double_dispatch_binop_decl_trait!(Vec5, Vec5AddRhs)
double_dispatch_binop_decl_trait!(Vec5, Vec5SubRhs)
double_dispatch_cast_decl_trait!(Vec5, Vec5Cast)
mul_redispatch_impl!(Vec5, Vec5MulRhs)
div_redispatch_impl!(Vec5, Vec5DivRhs)
add_redispatch_impl!(Vec5, Vec5AddRhs)
sub_redispatch_impl!(Vec5, Vec5SubRhs)
cast_redispatch_impl!(Vec5, Vec5Cast)
new_impl!(Vec5, x, y, z, w, a) new_impl!(Vec5, x, y, z, w, a)
ord_impl!(Vec5, x, y, z, w, a) ord_impl!(Vec5, x, y, z, w, a)
vec_axis_impl!(Vec5, x, y, z, w, a) vec_axis_impl!(Vec5, x, y, z, w, a)
vec_cast_impl!(Vec5, Vec5Cast, x, y, z, w, a) vec_cast_impl!(Vec5, x, y, z, w, a)
as_array_impl!(Vec5, 5) as_array_impl!(Vec5, 5)
index_impl!(Vec5) index_impl!(Vec5)
indexable_impl!(Vec5, 5) indexable_impl!(Vec5, 5)
@ -496,62 +267,18 @@ at_fast_impl!(Vec5, 5)
new_repeat_impl!(Vec5, val, x, y, z, w, a) new_repeat_impl!(Vec5, val, x, y, z, w, a)
dim_impl!(Vec5, 5) dim_impl!(Vec5, 5)
container_impl!(Vec5) container_impl!(Vec5)
basis_impl!(Vec5, Vec5MulRhs, 5) basis_impl!(Vec5, 5)
add_impl!(Vec5, Vec5AddRhs, x, y, z, w, a) add_impl!(Vec5, x, y, z, w, a)
sub_impl!(Vec5, Vec5SubRhs, x, y, z, w, a) sub_impl!(Vec5, x, y, z, w, a)
mul_impl!(Vec5, Vec5MulRhs, x, y, z, w, a) mul_impl!(Vec5, x, y, z, w, a)
div_impl!(Vec5, Vec5DivRhs, x, y, z, w, a) div_impl!(Vec5, x, y, z, w, a)
scalar_add_impl!(Vec5, x, y, z, w, a)
scalar_sub_impl!(Vec5, x, y, z, w, a)
scalar_mul_impl!(Vec5, x, y, z, w, a)
scalar_div_impl!(Vec5, x, y, z, w, a)
neg_impl!(Vec5, x, y, z, w, a) neg_impl!(Vec5, x, y, z, w, a)
dot_impl!(Vec5, x, y, z, w, a) dot_impl!(Vec5, x, y, z, w, a)
scalar_ops_impl!(Vec5, x, y, z, w, a) scalar_ops_impl!(Vec5, x, y, z, w, a)
vec_mul_scalar_impl!(Vec5, f64, Vec5MulRhs, x, y, z, w, a)
vec_mul_scalar_impl!(Vec5, f32, Vec5MulRhs, x, y, z, w, a)
vec_mul_scalar_impl!(Vec5, u64, Vec5MulRhs, x, y, z, w, a)
vec_mul_scalar_impl!(Vec5, u32, Vec5MulRhs, x, y, z, w, a)
vec_mul_scalar_impl!(Vec5, u16, Vec5MulRhs, x, y, z, w, a)
vec_mul_scalar_impl!(Vec5, u8, Vec5MulRhs, x, y, z, w, a)
vec_mul_scalar_impl!(Vec5, i64, Vec5MulRhs, x, y, z, w, a)
vec_mul_scalar_impl!(Vec5, i32, Vec5MulRhs, x, y, z, w, a)
vec_mul_scalar_impl!(Vec5, i16, Vec5MulRhs, x, y, z, w, a)
vec_mul_scalar_impl!(Vec5, i8, Vec5MulRhs, x, y, z, w, a)
vec_mul_scalar_impl!(Vec5, uint, Vec5MulRhs, x, y, z, w, a)
vec_mul_scalar_impl!(Vec5, int, Vec5MulRhs, x, y, z, w, a)
vec_div_scalar_impl!(Vec5, f64, Vec5DivRhs, x, y, z, w, a)
vec_div_scalar_impl!(Vec5, f32, Vec5DivRhs, x, y, z, w, a)
vec_div_scalar_impl!(Vec5, u64, Vec5DivRhs, x, y, z, w, a)
vec_div_scalar_impl!(Vec5, u32, Vec5DivRhs, x, y, z, w, a)
vec_div_scalar_impl!(Vec5, u16, Vec5DivRhs, x, y, z, w, a)
vec_div_scalar_impl!(Vec5, u8, Vec5DivRhs, x, y, z, w, a)
vec_div_scalar_impl!(Vec5, i64, Vec5DivRhs, x, y, z, w, a)
vec_div_scalar_impl!(Vec5, i32, Vec5DivRhs, x, y, z, w, a)
vec_div_scalar_impl!(Vec5, i16, Vec5DivRhs, x, y, z, w, a)
vec_div_scalar_impl!(Vec5, i8, Vec5DivRhs, x, y, z, w, a)
vec_div_scalar_impl!(Vec5, uint, Vec5DivRhs, x, y, z, w, a)
vec_div_scalar_impl!(Vec5, int, Vec5DivRhs, x, y, z, w, a)
vec_add_scalar_impl!(Vec5, f64, Vec5AddRhs, x, y, z, w, a)
vec_add_scalar_impl!(Vec5, f32, Vec5AddRhs, x, y, z, w, a)
vec_add_scalar_impl!(Vec5, u64, Vec5AddRhs, x, y, z, w, a)
vec_add_scalar_impl!(Vec5, u32, Vec5AddRhs, x, y, z, w, a)
vec_add_scalar_impl!(Vec5, u16, Vec5AddRhs, x, y, z, w, a)
vec_add_scalar_impl!(Vec5, u8, Vec5AddRhs, x, y, z, w, a)
vec_add_scalar_impl!(Vec5, i64, Vec5AddRhs, x, y, z, w, a)
vec_add_scalar_impl!(Vec5, i32, Vec5AddRhs, x, y, z, w, a)
vec_add_scalar_impl!(Vec5, i16, Vec5AddRhs, x, y, z, w, a)
vec_add_scalar_impl!(Vec5, i8, Vec5AddRhs, x, y, z, w, a)
vec_add_scalar_impl!(Vec5, uint, Vec5AddRhs, x, y, z, w, a)
vec_add_scalar_impl!(Vec5, int, Vec5AddRhs, x, y, z, w, a)
vec_sub_scalar_impl!(Vec5, f64, Vec5SubRhs, x, y, z, w, a)
vec_sub_scalar_impl!(Vec5, f32, Vec5SubRhs, x, y, z, w, a)
vec_sub_scalar_impl!(Vec5, u64, Vec5SubRhs, x, y, z, w, a)
vec_sub_scalar_impl!(Vec5, u32, Vec5SubRhs, x, y, z, w, a)
vec_sub_scalar_impl!(Vec5, u16, Vec5SubRhs, x, y, z, w, a)
vec_sub_scalar_impl!(Vec5, u8, Vec5SubRhs, x, y, z, w, a)
vec_sub_scalar_impl!(Vec5, i64, Vec5SubRhs, x, y, z, w, a)
vec_sub_scalar_impl!(Vec5, i32, Vec5SubRhs, x, y, z, w, a)
vec_sub_scalar_impl!(Vec5, i16, Vec5SubRhs, x, y, z, w, a)
vec_sub_scalar_impl!(Vec5, i8, Vec5SubRhs, x, y, z, w, a)
vec_sub_scalar_impl!(Vec5, uint, Vec5SubRhs, x, y, z, w, a)
vec_sub_scalar_impl!(Vec5, int, Vec5SubRhs, x, y, z, w, a)
translation_impl!(Vec5) translation_impl!(Vec5)
norm_impl!(Vec5, x, y, z, w, a) norm_impl!(Vec5, x, y, z, w, a)
approx_eq_impl!(Vec5, x, y, z, w, a) approx_eq_impl!(Vec5, x, y, z, w, a)
@ -568,7 +295,7 @@ rotate_impl!(Vec5)
rotate_impl!(Pnt5) rotate_impl!(Pnt5)
transform_impl!(Vec5, Pnt5) transform_impl!(Vec5, Pnt5)
vec_as_pnt_impl!(Vec5, Pnt5, x, y, z, w, a) vec_as_pnt_impl!(Vec5, Pnt5, x, y, z, w, a)
num_float_vec_impl!(Vec5, Vec5MulRhs, Vec5DivRhs) num_float_vec_impl!(Vec5)
absolute_vec_impl!(Vec5, x, y, z, w, a) absolute_vec_impl!(Vec5, x, y, z, w, a)
/// Vector of dimension 6. /// Vector of dimension 6.
@ -588,20 +315,10 @@ pub struct Vec6<N> {
pub b: N pub b: N
} }
double_dispatch_binop_decl_trait!(Vec6, Vec6MulRhs)
double_dispatch_binop_decl_trait!(Vec6, Vec6DivRhs)
double_dispatch_binop_decl_trait!(Vec6, Vec6AddRhs)
double_dispatch_binop_decl_trait!(Vec6, Vec6SubRhs)
double_dispatch_cast_decl_trait!(Vec6, Vec6Cast)
mul_redispatch_impl!(Vec6, Vec6MulRhs)
div_redispatch_impl!(Vec6, Vec6DivRhs)
add_redispatch_impl!(Vec6, Vec6AddRhs)
sub_redispatch_impl!(Vec6, Vec6SubRhs)
cast_redispatch_impl!(Vec6, Vec6Cast)
new_impl!(Vec6, x, y, z, w, a, b) new_impl!(Vec6, x, y, z, w, a, b)
ord_impl!(Vec6, x, y, z, w, a, b) ord_impl!(Vec6, x, y, z, w, a, b)
vec_axis_impl!(Vec6, x, y, z, w, a, b) vec_axis_impl!(Vec6, x, y, z, w, a, b)
vec_cast_impl!(Vec6, Vec6Cast, x, y, z, w, a, b) vec_cast_impl!(Vec6, x, y, z, w, a, b)
as_array_impl!(Vec6, 6) as_array_impl!(Vec6, 6)
index_impl!(Vec6) index_impl!(Vec6)
indexable_impl!(Vec6, 6) indexable_impl!(Vec6, 6)
@ -609,62 +326,18 @@ at_fast_impl!(Vec6, 6)
new_repeat_impl!(Vec6, val, x, y, z, w, a, b) new_repeat_impl!(Vec6, val, x, y, z, w, a, b)
dim_impl!(Vec6, 6) dim_impl!(Vec6, 6)
container_impl!(Vec6) container_impl!(Vec6)
basis_impl!(Vec6, Vec6MulRhs, 6) basis_impl!(Vec6, 6)
add_impl!(Vec6, Vec6AddRhs, x, y, z, w, a, b) add_impl!(Vec6, x, y, z, w, a, b)
sub_impl!(Vec6, Vec6SubRhs, x, y, z, w, a, b) sub_impl!(Vec6, x, y, z, w, a, b)
mul_impl!(Vec6, Vec6MulRhs, x, y, z, w, a, b) mul_impl!(Vec6, x, y, z, w, a, b)
div_impl!(Vec6, Vec6DivRhs, x, y, z, w, a, b) div_impl!(Vec6, x, y, z, w, a, b)
scalar_add_impl!(Vec6, x, y, z, w, a, b)
scalar_sub_impl!(Vec6, x, y, z, w, a, b)
scalar_mul_impl!(Vec6, x, y, z, w, a, b)
scalar_div_impl!(Vec6, x, y, z, w, a, b)
neg_impl!(Vec6, x, y, z, w, a, b) neg_impl!(Vec6, x, y, z, w, a, b)
dot_impl!(Vec6, x, y, z, w, a, b) dot_impl!(Vec6, x, y, z, w, a, b)
scalar_ops_impl!(Vec6, x, y, z, w, a, b) scalar_ops_impl!(Vec6, x, y, z, w, a, b)
vec_mul_scalar_impl!(Vec6, f64, Vec6MulRhs, x, y, z, w, a, b)
vec_mul_scalar_impl!(Vec6, f32, Vec6MulRhs, x, y, z, w, a, b)
vec_mul_scalar_impl!(Vec6, u64, Vec6MulRhs, x, y, z, w, a, b)
vec_mul_scalar_impl!(Vec6, u32, Vec6MulRhs, x, y, z, w, a, b)
vec_mul_scalar_impl!(Vec6, u16, Vec6MulRhs, x, y, z, w, a, b)
vec_mul_scalar_impl!(Vec6, u8, Vec6MulRhs, x, y, z, w, a, b)
vec_mul_scalar_impl!(Vec6, i64, Vec6MulRhs, x, y, z, w, a, b)
vec_mul_scalar_impl!(Vec6, i32, Vec6MulRhs, x, y, z, w, a, b)
vec_mul_scalar_impl!(Vec6, i16, Vec6MulRhs, x, y, z, w, a, b)
vec_mul_scalar_impl!(Vec6, i8, Vec6MulRhs, x, y, z, w, a, b)
vec_mul_scalar_impl!(Vec6, uint, Vec6MulRhs, x, y, z, w, a, b)
vec_mul_scalar_impl!(Vec6, int, Vec6MulRhs, x, y, z, w, a, b)
vec_div_scalar_impl!(Vec6, f64, Vec6DivRhs, x, y, z, w, a, b)
vec_div_scalar_impl!(Vec6, f32, Vec6DivRhs, x, y, z, w, a, b)
vec_div_scalar_impl!(Vec6, u64, Vec6DivRhs, x, y, z, w, a, b)
vec_div_scalar_impl!(Vec6, u32, Vec6DivRhs, x, y, z, w, a, b)
vec_div_scalar_impl!(Vec6, u16, Vec6DivRhs, x, y, z, w, a, b)
vec_div_scalar_impl!(Vec6, u8, Vec6DivRhs, x, y, z, w, a, b)
vec_div_scalar_impl!(Vec6, i64, Vec6DivRhs, x, y, z, w, a, b)
vec_div_scalar_impl!(Vec6, i32, Vec6DivRhs, x, y, z, w, a, b)
vec_div_scalar_impl!(Vec6, i16, Vec6DivRhs, x, y, z, w, a, b)
vec_div_scalar_impl!(Vec6, i8, Vec6DivRhs, x, y, z, w, a, b)
vec_div_scalar_impl!(Vec6, uint, Vec6DivRhs, x, y, z, w, a, b)
vec_div_scalar_impl!(Vec6, int, Vec6DivRhs, x, y, z, w, a, b)
vec_add_scalar_impl!(Vec6, f64, Vec6AddRhs, x, y, z, w, a, b)
vec_add_scalar_impl!(Vec6, f32, Vec6AddRhs, x, y, z, w, a, b)
vec_add_scalar_impl!(Vec6, u64, Vec6AddRhs, x, y, z, w, a, b)
vec_add_scalar_impl!(Vec6, u32, Vec6AddRhs, x, y, z, w, a, b)
vec_add_scalar_impl!(Vec6, u16, Vec6AddRhs, x, y, z, w, a, b)
vec_add_scalar_impl!(Vec6, u8, Vec6AddRhs, x, y, z, w, a, b)
vec_add_scalar_impl!(Vec6, i64, Vec6AddRhs, x, y, z, w, a, b)
vec_add_scalar_impl!(Vec6, i32, Vec6AddRhs, x, y, z, w, a, b)
vec_add_scalar_impl!(Vec6, i16, Vec6AddRhs, x, y, z, w, a, b)
vec_add_scalar_impl!(Vec6, i8, Vec6AddRhs, x, y, z, w, a, b)
vec_add_scalar_impl!(Vec6, uint, Vec6AddRhs, x, y, z, w, a, b)
vec_add_scalar_impl!(Vec6, int, Vec6AddRhs, x, y, z, w, a, b)
vec_sub_scalar_impl!(Vec6, f64, Vec6SubRhs, x, y, z, w, a, b)
vec_sub_scalar_impl!(Vec6, f32, Vec6SubRhs, x, y, z, w, a, b)
vec_sub_scalar_impl!(Vec6, u64, Vec6SubRhs, x, y, z, w, a, b)
vec_sub_scalar_impl!(Vec6, u32, Vec6SubRhs, x, y, z, w, a, b)
vec_sub_scalar_impl!(Vec6, u16, Vec6SubRhs, x, y, z, w, a, b)
vec_sub_scalar_impl!(Vec6, u8, Vec6SubRhs, x, y, z, w, a, b)
vec_sub_scalar_impl!(Vec6, i64, Vec6SubRhs, x, y, z, w, a, b)
vec_sub_scalar_impl!(Vec6, i32, Vec6SubRhs, x, y, z, w, a, b)
vec_sub_scalar_impl!(Vec6, i16, Vec6SubRhs, x, y, z, w, a, b)
vec_sub_scalar_impl!(Vec6, i8, Vec6SubRhs, x, y, z, w, a, b)
vec_sub_scalar_impl!(Vec6, uint, Vec6SubRhs, x, y, z, w, a, b)
vec_sub_scalar_impl!(Vec6, int, Vec6SubRhs, x, y, z, w, a, b)
translation_impl!(Vec6) translation_impl!(Vec6)
norm_impl!(Vec6, x, y, z, w, a, b) norm_impl!(Vec6, x, y, z, w, a, b)
approx_eq_impl!(Vec6, x, y, z, w, a, b) approx_eq_impl!(Vec6, x, y, z, w, a, b)
@ -679,5 +352,5 @@ rotate_impl!(Vec6)
rotate_impl!(Pnt6) rotate_impl!(Pnt6)
transform_impl!(Vec6, Pnt6) transform_impl!(Vec6, Pnt6)
vec_as_pnt_impl!(Vec6, Pnt6, x, y, z, w, a, b) vec_as_pnt_impl!(Vec6, Pnt6, x, y, z, w, a, b)
num_float_vec_impl!(Vec6, Vec6MulRhs, Vec6DivRhs) num_float_vec_impl!(Vec6)
absolute_vec_impl!(Vec6, x, y, z, w, a, b) absolute_vec_impl!(Vec6, x, y, z, w, a, b)

93
src/structs/vec_macros.rs
View File

@ -180,10 +180,10 @@ macro_rules! vec_axis_impl(
) )
macro_rules! vec_cast_impl( macro_rules! vec_cast_impl(
($t: ident, $tcast: ident, $comp0: ident $(,$compN: ident)*) => ( ($t: ident, $comp0: ident $(,$compN: ident)*) => (
impl<Nin: Clone, Nout: Clone + Cast<Nin>> $tcast<Nout> for $t<Nin> { impl<Nin: Clone, Nout: Clone + Cast<Nin>> Cast<$t<Nin>> for $t<Nout> {
#[inline] #[inline]
fn to(v: $t<Nin>) -> $t<Nout> { fn from(v: $t<Nin>) -> $t<Nout> {
$t::new(Cast::from(v.$comp0.clone()) $(, Cast::from(v.$compN.clone()))*) $t::new(Cast::from(v.$comp0.clone()) $(, Cast::from(v.$compN.clone()))*)
} }
} }
@ -314,8 +314,8 @@ macro_rules! container_impl(
) )
macro_rules! basis_impl( macro_rules! basis_impl(
($t: ident, $trhs: ident, $dim: expr) => ( ($t: ident, $dim: expr) => (
impl<N: Clone + BaseFloat + ApproxEq<N> + $trhs<N, $t<N>>> Basis for $t<N> { impl<N: Clone + BaseFloat + ApproxEq<N>> Basis for $t<N> {
#[inline] #[inline]
fn canonical_basis(f: |$t<N>| -> bool) { fn canonical_basis(f: |$t<N>| -> bool) {
for i in range(0u, $dim) { for i in range(0u, $dim) {
@ -390,44 +390,89 @@ macro_rules! axpy_impl(
) )
macro_rules! add_impl( macro_rules! add_impl(
($t: ident, $trhs: ident, $comp0: ident $(,$compN: ident)*) => ( ($t: ident, $comp0: ident $(,$compN: ident)*) => (
impl<N: Add<N, N>> $trhs<N, $t<N>> for $t<N> { impl<N: Add<N, N>> Add<$t<N>, $t<N>> for $t<N> {
#[inline] #[inline]
fn binop(left: &$t<N>, right: &$t<N>) -> $t<N> { fn add(&self, right: &$t<N>) -> $t<N> {
$t::new(left.$comp0 + right.$comp0 $(, left.$compN + right.$compN)*) $t::new(self.$comp0 + right.$comp0 $(, self.$compN + right.$compN)*)
}
}
)
)
macro_rules! scalar_add_impl(
($t: ident, $comp0: ident $(,$compN: ident)*) => (
// $t against scalar
impl<N: Add<N, N>> Add<N, $t<N>> for $t<N> {
#[inline]
fn add(&self, right: &N) -> $t<N> {
$t::new(self.$comp0 + *right $(, self.$compN + *right)*)
} }
} }
) )
) )
macro_rules! sub_impl( macro_rules! sub_impl(
($t: ident, $trhs: ident, $comp0: ident $(,$compN: ident)*) => ( ($t: ident, $comp0: ident $(,$compN: ident)*) => (
impl<N: Sub<N, N>> $trhs<N, $t<N>> for $t<N> { impl<N: Sub<N, N>> Sub<$t<N>, $t<N>> for $t<N> {
#[inline] #[inline]
fn binop(left: &$t<N>, right: &$t<N>) -> $t<N> { fn sub(&self, right: &$t<N>) -> $t<N> {
$t::new(left.$comp0 - right.$comp0 $(, left.$compN - right.$compN)*) $t::new(self.$comp0 - right.$comp0 $(, self.$compN - right.$compN)*)
}
}
)
)
macro_rules! scalar_sub_impl(
($t: ident, $comp0: ident $(,$compN: ident)*) => (
impl<N: Sub<N, N>> Sub<N, $t<N>> for $t<N> {
#[inline]
fn sub(&self, right: &N) -> $t<N> {
$t::new(self.$comp0 - *right $(, self.$compN - *right)*)
} }
} }
) )
) )
macro_rules! mul_impl( macro_rules! mul_impl(
($t: ident, $trhs: ident, $comp0: ident $(,$compN: ident)*) => ( ($t: ident, $comp0: ident $(,$compN: ident)*) => (
impl<N: Mul<N, N>> $trhs<N, $t<N>> for $t<N> { impl<N: Mul<N, N>> Mul<$t<N>, $t<N>> for $t<N> {
#[inline] #[inline]
fn binop(left: &$t<N>, right: &$t<N>) -> $t<N> { fn mul(&self, right: &$t<N>) -> $t<N> {
$t::new(left.$comp0 * right.$comp0 $(, left.$compN * right.$compN)*) $t::new(self.$comp0 * right.$comp0 $(, self.$compN * right.$compN)*)
}
}
)
)
macro_rules! scalar_mul_impl(
($t: ident, $comp0: ident $(,$compN: ident)*) => (
impl<N: Mul<N, N>> Mul<N, $t<N>> for $t<N> {
#[inline]
fn mul(&self, right: &N) -> $t<N> {
$t::new(self.$comp0 * *right $(, self.$compN * *right)*)
} }
} }
) )
) )
macro_rules! div_impl( macro_rules! div_impl(
($t: ident, $trhs: ident, $comp0: ident $(,$compN: ident)*) => ( ($t: ident, $comp0: ident $(,$compN: ident)*) => (
impl<N: Div<N, N>> $trhs<N, $t<N>> for $t<N> { impl<N: Div<N, N>> Div<$t<N>, $t<N>> for $t<N> {
#[inline] #[inline]
fn binop(left: &$t<N>, right: &$t<N>) -> $t<N> { fn div(&self, right: &$t<N>) -> $t<N> {
$t::new(left.$comp0 / right.$comp0 $(, left.$compN / right.$compN)*) $t::new(self.$comp0 / right.$comp0 $(, self.$compN / right.$compN)*)
}
}
)
)
macro_rules! scalar_div_impl(
($t: ident, $comp0: ident $(,$compN: ident)*) => (
impl<N: Div<N, N>> Div<N, $t<N>> for $t<N> {
#[inline]
fn div(&self, right: &N) -> $t<N> {
$t::new(self.$comp0 / *right $(, self.$compN / *right)*)
} }
} }
) )
@ -801,13 +846,13 @@ macro_rules! vec_as_pnt_impl(
) )
macro_rules! num_float_vec_impl( macro_rules! num_float_vec_impl(
($t: ident $(,$trhs: ident)*) => ( ($t: ident) => (
impl<N> NumVec<N> for $t<N> impl<N> NumVec<N> for $t<N>
where N: BaseNum + Zero $(+ $trhs<N, $t<N>>)* { where N: BaseNum {
} }
impl<N> FloatVec<N> for $t<N> impl<N> FloatVec<N> for $t<N>
where N: BaseNum + Zero + One + ApproxEq<N> + BaseFloat $(+ $trhs<N, $t<N>>)* { where N: BaseFloat + ApproxEq<N> {
} }
) )
) )