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

Update to the last rust-nightly. 

Version of rustc: 0.13.0-nightly (c6c786671 2015-01-04 00:50:59 +0000).
This commit is contained in:
Sébastien Crozet 2015-01-04 19:03:28 +01:00
parent 0e2563a88f
commit 014aabb856
19 changed files with 330 additions and 144 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/lib.rs
View File

@ -84,6 +84,8 @@ Feel free to add your project to this list if you happen to use **nalgebra**!
#![warn(missing_docs)] #![warn(missing_docs)]
#![feature(macro_rules)] #![feature(macro_rules)]
#![feature(globs)] #![feature(globs)]
#![feature(default_type_params)]
#![feature(associated_types)]
#![feature(old_orphan_check)] #![feature(old_orphan_check)]
#![doc(html_root_url = "http://nalgebra.org/doc")] #![doc(html_root_url = "http://nalgebra.org/doc")]
@ -578,7 +580,7 @@ pub fn inv_rotate<V, M: Rotate<V>>(m: &M, v: &V) -> V {
/// Rotates a copy of `m` by `amount` using `center` as the pivot point. /// Rotates a copy of `m` by `amount` using `center` as the pivot point.
#[inline(always)] #[inline(always)]
pub fn append_rotation_wrt_point<LV: Neg<LV> + Copy, pub fn append_rotation_wrt_point<LV: Neg<Output = LV> + Copy,
AV, AV,
M: RotationWithTranslation<LV, AV>>( M: RotationWithTranslation<LV, AV>>(
m: &M, m: &M,
@ -589,7 +591,7 @@ pub fn append_rotation_wrt_point<LV: Neg<LV> + Copy,
/// Rotates a copy of `m` by `amount` using `m.translation()` as the pivot point. /// Rotates a copy of `m` by `amount` using `m.translation()` as the pivot point.
#[inline(always)] #[inline(always)]
pub fn append_rotation_wrt_center<LV: Neg<LV> + Copy, pub fn append_rotation_wrt_center<LV: Neg<Output = LV> + Copy,
AV, AV,
M: RotationWithTranslation<LV, AV>>( M: RotationWithTranslation<LV, AV>>(
m: &M, m: &M,
@ -603,7 +605,7 @@ pub fn append_rotation_wrt_center<LV: Neg<LV> + Copy,
/// Builds a rotation matrix from `r`. /// Builds a rotation matrix from `r`.
#[inline(always)] #[inline(always)]
pub fn to_rot_mat<N, LV, AV, M: Mat<N, LV, LV> + Rotation<AV>, R: RotationMatrix<N, LV, AV, M>>(r: &R) -> M { pub fn to_rot_mat<N, LV, AV, R: RotationMatrix<N, LV, AV>>(r: &R) -> R::Output {
r.to_rot_mat() r.to_rot_mat()
} }
@ -702,7 +704,7 @@ pub fn det<M: Det<N>, N>(m: &M) -> N {
/// Computes the cross product of two vectors. /// Computes the cross product of two vectors.
#[inline(always)] #[inline(always)]
pub fn cross<LV: Cross<AV>, AV>(a: &LV, b: &LV) -> AV { pub fn cross<LV: Cross>(a: &LV, b: &LV) -> LV::Output {
Cross::cross(a, b) Cross::cross(a, b)
} }
@ -909,7 +911,7 @@ pub fn dim<V: Dim>() -> uint {
/// Gets the indexable range of an object. /// Gets the indexable range of an object.
#[inline(always)] #[inline(always)]
pub fn shape<V: Shape<I, N>, I, N>(v: &V) -> I { pub fn shape<V: Shape<I>, I, N>(v: &V) -> I {
v.shape() v.shape()
} }

6
src/linalg/decompositions.rs
View File

@ -41,7 +41,8 @@ pub fn householder_matrix<N, V, M>(dim: uint, start: uint, vec: V) -> M
pub fn qr<N, V, M>(m: &M) -> (M, M) pub fn qr<N, V, M>(m: &M) -> (M, M)
where N: BaseFloat, where N: BaseFloat,
V: Indexable<uint, N> + Norm<N>, V: Indexable<uint, N> + Norm<N>,
M: Copy + Eye + ColSlice<V> + Transpose + Indexable<(uint, uint), N> + Mul<M, M> { M: Copy + Eye + ColSlice<V> + Transpose + Indexable<(uint, uint), N> +
Mul<M, Output = M> {
let (rows, cols) = m.shape(); let (rows, cols) = m.shape();
assert!(rows >= cols); assert!(rows >= cols);
let mut q : M = Eye::new_identity(rows); let mut q : M = Eye::new_identity(rows);
@ -76,7 +77,8 @@ pub fn qr<N, V, M>(m: &M) -> (M, M)
pub fn eigen_qr<N, V, VS, M>(m: &M, eps: &N, niter: uint) -> (M, V) pub fn eigen_qr<N, V, VS, M>(m: &M, eps: &N, niter: uint) -> (M, V)
where N: BaseFloat, where N: BaseFloat,
VS: Indexable<uint, N> + Norm<N>, VS: Indexable<uint, N> + Norm<N>,
M: Indexable<(uint, uint), N> + SquareMat<N, V> + Add<M, M> + Sub<M, M> + ColSlice<VS> + M: Indexable<(uint, uint), N> + SquareMat<N, V> + Add<M, Output = M> +
Sub<M, Output = M> + ColSlice<VS> +
ApproxEq<N> + Copy { ApproxEq<N> + Copy {
let mut eigenvectors: M = ::one::<M>(); let mut eigenvectors: M = ::one::<M>();
let mut eigenvalues = *m; let mut eigenvalues = *m;

38
src/structs/dmat.rs
View File

@ -255,14 +255,16 @@ impl<N: Copy> Indexable<(uint, uint), N> for DMat<N> {
} }
impl<N> Shape<(uint, uint), N> for DMat<N> { impl<N> Shape<(uint, uint)> for DMat<N> {
#[inline] #[inline]
fn shape(&self) -> (uint, uint) { fn shape(&self) -> (uint, uint) {
(self.nrows, self.ncols) (self.nrows, self.ncols)
} }
} }
impl<N> Index<(uint, uint), N> for DMat<N> { impl<N> Index<(uint, uint)> for DMat<N> {
type Output = N;
fn index(&self, &(i, j): &(uint, uint)) -> &N { fn index(&self, &(i, j): &(uint, uint)) -> &N {
assert!(i < self.nrows); assert!(i < self.nrows);
assert!(j < self.ncols); assert!(j < self.ncols);
@ -273,7 +275,9 @@ impl<N> Index<(uint, uint), N> for DMat<N> {
} }
} }
impl<N> IndexMut<(uint, uint), N> for DMat<N> { impl<N> IndexMut<(uint, uint)> for DMat<N> {
type Output = N;
fn index_mut(&mut self, &(i, j): &(uint, uint)) -> &mut N { fn index_mut(&mut self, &(i, j): &(uint, uint)) -> &mut N {
assert!(i < self.nrows); assert!(i < self.nrows);
assert!(j < self.ncols); assert!(j < self.ncols);
@ -286,7 +290,9 @@ impl<N> IndexMut<(uint, uint), N> for DMat<N> {
} }
} }
impl<N: Copy + Mul<N, N> + Add<N, N> + Zero> Mul<DMat<N>, DMat<N>> for DMat<N> { impl<N: Copy + Mul<N, Output = N> + Add<N, Output = N> + Zero> Mul<DMat<N>> for DMat<N> {
type Output = DMat<N>;
fn mul(self, right: DMat<N>) -> DMat<N> { fn mul(self, right: DMat<N>) -> DMat<N> {
assert!(self.ncols == right.nrows); assert!(self.ncols == right.nrows);
@ -311,7 +317,9 @@ impl<N: Copy + Mul<N, N> + Add<N, N> + Zero> Mul<DMat<N>, DMat<N>> for DMat<N> {
} }
} }
impl<N: Copy + Add<N, N> + Mul<N, N> + Zero> Mul<DVec<N>, DVec<N>> for DMat<N> { impl<N: Copy + Add<N, Output = N> + Mul<N, Output = N> + Zero> Mul<DVec<N>> for DMat<N> {
type Output = DVec<N>;
fn mul(self, right: DVec<N>) -> DVec<N> { fn mul(self, right: DVec<N>) -> DVec<N> {
assert!(self.ncols == right.at.len()); assert!(self.ncols == right.at.len());
@ -334,7 +342,9 @@ impl<N: Copy + Add<N, N> + Mul<N, N> + Zero> Mul<DVec<N>, DVec<N>> for DMat<N> {
} }
impl<N: Copy + Add<N, N> + Mul<N, N> + Zero> Mul<DMat<N>, DVec<N>> for DVec<N> { impl<N: Copy + Add<N, Output = N> + Mul<N, Output = N> + Zero> Mul<DMat<N>> for DVec<N> {
type Output = DVec<N>;
fn mul(self, right: DMat<N>) -> DVec<N> { fn mul(self, right: DMat<N>) -> DVec<N> {
assert!(right.nrows == self.at.len()); assert!(right.nrows == self.at.len());
@ -635,7 +645,9 @@ impl<N: Show + Copy> Show for DMat<N> {
} }
} }
impl<N: Copy + Mul<N, N>> Mul<N, DMat<N>> for DMat<N> { impl<N: Copy + Mul<N, Output = N>> Mul<N> for DMat<N> {
type Output = DMat<N>;
#[inline] #[inline]
fn mul(self, right: N) -> DMat<N> { fn mul(self, right: N) -> DMat<N> {
let mut res = self; let mut res = self;
@ -648,7 +660,9 @@ impl<N: Copy + Mul<N, N>> Mul<N, DMat<N>> for DMat<N> {
} }
} }
impl<N: Copy + Div<N, N>> Div<N, DMat<N>> for DMat<N> { impl<N: Copy + Div<N, Output = N>> Div<N> for DMat<N> {
type Output = DMat<N>;
#[inline] #[inline]
fn div(self, right: N) -> DMat<N> { fn div(self, right: N) -> DMat<N> {
let mut res = self; let mut res = self;
@ -661,7 +675,9 @@ impl<N: Copy + Div<N, N>> Div<N, DMat<N>> for DMat<N> {
} }
} }
impl<N: Copy + Add<N, N>> Add<N, DMat<N>> for DMat<N> { impl<N: Copy + Add<N, Output = N>> Add<N> for DMat<N> {
type Output = DMat<N>;
#[inline] #[inline]
fn add(self, right: N) -> DMat<N> { fn add(self, right: N) -> DMat<N> {
let mut res = self; let mut res = self;
@ -674,7 +690,9 @@ impl<N: Copy + Add<N, N>> Add<N, DMat<N>> for DMat<N> {
} }
} }
impl<N: Copy + Sub<N, N>> Sub<N, DMat<N>> for DMat<N> { impl<N: Copy + Sub<N, Output = N>> Sub<N> for DMat<N> {
type Output = DMat<N>;
#[inline] #[inline]
fn sub(self, right: N) -> DMat<N> { fn sub(self, right: N) -> DMat<N> {
let mut res = self; let mut res = self;

2
src/structs/dvec.rs
View File

@ -67,7 +67,7 @@ impl<N> DVec<N> {
impl<N> FromIterator<N> for DVec<N> { impl<N> FromIterator<N> for DVec<N> {
#[inline] #[inline]
fn from_iter<I: Iterator<N>>(mut param: I) -> DVec<N> { fn from_iter<I: Iterator<Item = N>>(mut param: I) -> DVec<N> {
let mut res = DVec { at: Vec::new() }; let mut res = DVec { at: Vec::new() };
for e in param { for e in param {

50
src/structs/dvec_macros.rs
View File

@ -34,7 +34,7 @@ macro_rules! dvec_impl(
} }
} }
impl<N> Shape<uint, N> for $dvec<N> { impl<N> Shape<uint> for $dvec<N> {
#[inline] #[inline]
fn shape(&self) -> uint { fn shape(&self) -> uint {
self.len() self.len()
@ -77,13 +77,17 @@ macro_rules! dvec_impl(
} }
impl<N> Index<uint, N> for $dvec<N> { impl<N> Index<uint> for $dvec<N> {
type Output = N;
fn index(&self, i: &uint) -> &N { fn index(&self, i: &uint) -> &N {
&self.as_slice()[*i] &self.as_slice()[*i]
} }
} }
impl<N> IndexMut<uint, N> for $dvec<N> { impl<N> IndexMut<uint> for $dvec<N> {
type Output = N;
fn index_mut(&mut self, i: &uint) -> &mut N { fn index_mut(&mut self, i: &uint) -> &mut N {
&mut self.as_mut_slice()[*i] &mut self.as_mut_slice()[*i]
} }
@ -122,7 +126,7 @@ macro_rules! dvec_impl(
} }
} }
impl<N: Copy + Add<N, N> + Mul<N, N>> Axpy<N> for $dvec<N> { impl<N: Copy + Add<N, Output = N> + Mul<N, Output = N>> Axpy<N> for $dvec<N> {
fn axpy(&mut self, a: &N, x: &$dvec<N>) { fn axpy(&mut self, a: &N, x: &$dvec<N>) {
assert!(self.len() == x.len()); assert!(self.len() == x.len());
@ -190,7 +194,9 @@ macro_rules! dvec_impl(
} }
} }
impl<N: Copy + Mul<N, N> + Zero> Mul<$dvec<N>, $dvec<N>> for $dvec<N> { impl<N: Copy + Mul<N, Output = N> + Zero> Mul<$dvec<N>> for $dvec<N> {
type Output = $dvec<N>;
#[inline] #[inline]
fn mul(self, right: $dvec<N>) -> $dvec<N> { fn mul(self, right: $dvec<N>) -> $dvec<N> {
assert!(self.len() == right.len()); assert!(self.len() == right.len());
@ -205,7 +211,9 @@ macro_rules! dvec_impl(
} }
} }
impl<N: Copy + Div<N, N> + Zero> Div<$dvec<N>, $dvec<N>> for $dvec<N> { impl<N: Copy + Div<N, Output = N> + Zero> Div<$dvec<N>> for $dvec<N> {
type Output = $dvec<N>;
#[inline] #[inline]
fn div(self, right: $dvec<N>) -> $dvec<N> { fn div(self, right: $dvec<N>) -> $dvec<N> {
assert!(self.len() == right.len()); assert!(self.len() == right.len());
@ -220,7 +228,9 @@ macro_rules! dvec_impl(
} }
} }
impl<N: Copy + Add<N, N> + Zero> Add<$dvec<N>, $dvec<N>> for $dvec<N> { impl<N: Copy + Add<N, Output = N> + Zero> Add<$dvec<N>> for $dvec<N> {
type Output = $dvec<N>;
#[inline] #[inline]
fn add(self, right: $dvec<N>) -> $dvec<N> { fn add(self, right: $dvec<N>) -> $dvec<N> {
assert!(self.len() == right.len()); assert!(self.len() == right.len());
@ -235,7 +245,9 @@ macro_rules! dvec_impl(
} }
} }
impl<N: Copy + Sub<N, N> + Zero> Sub<$dvec<N>, $dvec<N>> for $dvec<N> { impl<N: Copy + Sub<N, Output = N> + Zero> Sub<$dvec<N>> for $dvec<N> {
type Output = $dvec<N>;
#[inline] #[inline]
fn sub(self, right: $dvec<N>) -> $dvec<N> { fn sub(self, right: $dvec<N>) -> $dvec<N> {
assert!(self.len() == right.len()); assert!(self.len() == right.len());
@ -250,7 +262,9 @@ macro_rules! dvec_impl(
} }
} }
impl<N: Neg<N> + Zero + Copy> Neg<$dvec<N>> for $dvec<N> { impl<N: Neg<Output = N> + Zero + Copy> Neg for $dvec<N> {
type Output = $dvec<N>;
#[inline] #[inline]
fn neg(self) -> $dvec<N> { fn neg(self) -> $dvec<N> {
FromIterator::from_iter(self.as_slice().iter().map(|a| -*a)) FromIterator::from_iter(self.as_slice().iter().map(|a| -*a))
@ -318,7 +332,9 @@ macro_rules! dvec_impl(
} }
} }
impl<N: Copy + Mul<N, N> + Zero> Mul<N, $dvec<N>> for $dvec<N> { impl<N: Copy + Mul<N, Output = N> + Zero> Mul<N> for $dvec<N> {
type Output = $dvec<N>;
#[inline] #[inline]
fn mul(self, right: N) -> $dvec<N> { fn mul(self, right: N) -> $dvec<N> {
let mut res = self; let mut res = self;
@ -331,7 +347,9 @@ macro_rules! dvec_impl(
} }
} }
impl<N: Copy + Div<N, N> + Zero> Div<N, $dvec<N>> for $dvec<N> { impl<N: Copy + Div<N, Output = N> + Zero> Div<N> for $dvec<N> {
type Output = $dvec<N>;
#[inline] #[inline]
fn div(self, right: N) -> $dvec<N> { fn div(self, right: N) -> $dvec<N> {
let mut res = self; let mut res = self;
@ -344,7 +362,9 @@ macro_rules! dvec_impl(
} }
} }
impl<N: Copy + Add<N, N> + Zero> Add<N, $dvec<N>> for $dvec<N> { impl<N: Copy + Add<N, Output = N> + Zero> Add<N> for $dvec<N> {
type Output = $dvec<N>;
#[inline] #[inline]
fn add(self, right: N) -> $dvec<N> { fn add(self, right: N) -> $dvec<N> {
let mut res = self; let mut res = self;
@ -357,7 +377,9 @@ macro_rules! dvec_impl(
} }
} }
impl<N: Copy + Sub<N, N> + Zero> Sub<N, $dvec<N>> for $dvec<N> { impl<N: Copy + Sub<N, Output = N> + Zero> Sub<N> for $dvec<N> {
type Output = $dvec<N>;
#[inline] #[inline]
fn sub(self, right: N) -> $dvec<N> { fn sub(self, right: N) -> $dvec<N> {
let mut res = self; let mut res = self;
@ -477,7 +499,7 @@ macro_rules! small_dvec_from_impl (
impl<N: Zero> FromIterator<N> for $dvec<N> { impl<N: Zero> FromIterator<N> for $dvec<N> {
#[inline] #[inline]
fn from_iter<I: Iterator<N>>(mut param: I) -> $dvec<N> { fn from_iter<I: Iterator<Item = N>>(mut param: I) -> $dvec<N> {
let mut at: [N; $dim] = [ $( $zeros, )* ]; let mut at: [N; $dim] = [ $( $zeros, )* ];
let mut dim = 0; let mut dim = 0;

17
src/structs/iso_macros.rs
View File

@ -27,7 +27,9 @@ macro_rules! iso_impl(
macro_rules! rotation_matrix_impl( macro_rules! rotation_matrix_impl(
($t: ident, $trot: ident, $tlv: ident, $tav: ident) => ( ($t: ident, $trot: ident, $tlv: ident, $tav: ident) => (
impl<N: Cast<f64> + BaseFloat> impl<N: Cast<f64> + BaseFloat>
RotationMatrix<N, $tlv<N>, $tav<N>, $trot<N>> for $t<N> { RotationMatrix<N, $tlv<N>, $tav<N>> for $t<N> {
type Output = $trot<N>;
#[inline] #[inline]
fn to_rot_mat(&self) -> $trot<N> { fn to_rot_mat(&self) -> $trot<N> {
self.rotation self.rotation
@ -61,7 +63,9 @@ macro_rules! one_impl(
macro_rules! iso_mul_iso_impl( macro_rules! iso_mul_iso_impl(
($t: ident) => ( ($t: ident) => (
impl<N: BaseFloat> Mul<$t<N>, $t<N>> for $t<N> { impl<N: BaseFloat> Mul<$t<N>> for $t<N> {
type Output = $t<N>;
#[inline] #[inline]
fn mul(self, right: $t<N>) -> $t<N> { fn mul(self, right: $t<N>) -> $t<N> {
$t::new_with_rotmat( $t::new_with_rotmat(
@ -74,7 +78,9 @@ macro_rules! iso_mul_iso_impl(
macro_rules! iso_mul_pnt_impl( macro_rules! iso_mul_pnt_impl(
($t: ident, $tv: ident) => ( ($t: ident, $tv: ident) => (
impl<N: BaseNum> Mul<$tv<N>, $tv<N>> for $t<N> { impl<N: BaseNum> Mul<$tv<N>> for $t<N> {
type Output = $tv<N>;
#[inline] #[inline]
fn mul(self, right: $tv<N>) -> $tv<N> { fn mul(self, right: $tv<N>) -> $tv<N> {
self.rotation * right + self.translation self.rotation * right + self.translation
@ -85,7 +91,8 @@ macro_rules! iso_mul_pnt_impl(
macro_rules! pnt_mul_iso_impl( macro_rules! pnt_mul_iso_impl(
($t: ident, $tv: ident) => ( ($t: ident, $tv: ident) => (
impl<N: BaseNum> Mul<$t<N>, $tv<N>> for $tv<N> { impl<N: BaseNum> Mul<$t<N>> for $tv<N> {
type Output = $tv<N>;
#[inline] #[inline]
fn mul(self, right: $t<N>) -> $tv<N> { fn mul(self, right: $t<N>) -> $tv<N> {
(self + right.translation) * right.rotation (self + right.translation) * right.rotation
@ -137,7 +144,7 @@ macro_rules! translation_impl(
macro_rules! translate_impl( macro_rules! translate_impl(
($t: ident, $tv: ident) => ( ($t: ident, $tv: ident) => (
impl<N: Copy + Add<N, N> + Sub<N, N>> Translate<$tv<N>> for $t<N> { impl<N: Copy + Add<N, Output = N> + Sub<N, Output = N>> Translate<$tv<N>> for $t<N> {
#[inline] #[inline]
fn translate(&self, v: &$tv<N>) -> $tv<N> { fn translate(&self, v: &$tv<N>) -> $tv<N> {
*v + self.translation *v + self.translation

47
src/structs/mat_macros.rs
View File

@ -88,7 +88,9 @@ macro_rules! mat_cast_impl(
macro_rules! add_impl( macro_rules! add_impl(
($t: ident, $comp0: ident $(,$compN: ident)*) => ( ($t: ident, $comp0: ident $(,$compN: ident)*) => (
impl<N: Add<N, N>> Add<$t<N>, $t<N>> for $t<N> { impl<N: Add<N, Output = N>> Add<$t<N>> for $t<N> {
type Output = $t<N>;
#[inline] #[inline]
fn add(self, right: $t<N>) -> $t<N> { fn add(self, right: $t<N>) -> $t<N> {
$t::new(self.$comp0 + right.$comp0 $(, self.$compN + right.$compN)*) $t::new(self.$comp0 + right.$comp0 $(, self.$compN + right.$compN)*)
@ -99,7 +101,9 @@ macro_rules! add_impl(
macro_rules! sub_impl( macro_rules! sub_impl(
($t: ident, $comp0: ident $(,$compN: ident)*) => ( ($t: ident, $comp0: ident $(,$compN: ident)*) => (
impl<N: Sub<N, N>> Sub<$t<N>, $t<N>> for $t<N> { impl<N: Sub<N, Output = N>> Sub<$t<N>> for $t<N> {
type Output = $t<N>;
#[inline] #[inline]
fn sub(self, right: $t<N>) -> $t<N> { fn sub(self, right: $t<N>) -> $t<N> {
$t::new(self.$comp0 - right.$comp0 $(, self.$compN - right.$compN)*) $t::new(self.$comp0 - right.$comp0 $(, self.$compN - right.$compN)*)
@ -110,7 +114,9 @@ macro_rules! sub_impl(
macro_rules! mat_mul_scalar_impl( macro_rules! mat_mul_scalar_impl(
($t: ident, $comp0: ident $(,$compN: ident)*) => ( ($t: ident, $comp0: ident $(,$compN: ident)*) => (
impl<N: Mul<N, N>> Mul<N, $t<N>> for N { impl<N: Mul<N, Output = N>> Mul<N> for N {
type Output = $t<N>;
#[inline] #[inline]
fn mul(self, right: N) -> $t<N> { fn mul(self, right: N) -> $t<N> {
$t::new(self.$comp0 * *right $(, self.$compN * *right)*) $t::new(self.$comp0 * *right $(, self.$compN * *right)*)
@ -121,7 +127,9 @@ macro_rules! mat_mul_scalar_impl(
macro_rules! mat_div_scalar_impl( macro_rules! mat_div_scalar_impl(
($t: ident, $comp0: ident $(,$compN: ident)*) => ( ($t: ident, $comp0: ident $(,$compN: ident)*) => (
impl<N: Div<N, N>> Div<N, $t<N>> for $t<N> { impl<N: Div<N, Output = N>> Div<N> for $t<N> {
type Output = $t<N>;
#[inline] #[inline]
fn div(self, right: N) -> $t<N> { fn div(self, right: N) -> $t<N> {
$t::new(self.$comp0 / *right $(, self.$compN / *right)*) $t::new(self.$comp0 / *right $(, self.$compN / *right)*)
@ -132,7 +140,9 @@ macro_rules! mat_div_scalar_impl(
macro_rules! mat_add_scalar_impl( macro_rules! mat_add_scalar_impl(
($t: ident, $comp0: ident $(,$compN: ident)*) => ( ($t: ident, $comp0: ident $(,$compN: ident)*) => (
impl<N: Add<N, N>> Add<N, $t<N>> for $t<N> { impl<N: Add<N, Output = N>> Add<N> for $t<N> {
type Output = $t<N>;
#[inline] #[inline]
fn add(self, right: N) -> $t<N> { fn add(self, right: N) -> $t<N> {
$t::new(self.$comp0 + *right $(, self.$compN + *right)*) $t::new(self.$comp0 + *right $(, self.$compN + *right)*)
@ -157,7 +167,9 @@ macro_rules! eye_impl(
macro_rules! mat_sub_scalar_impl( macro_rules! mat_sub_scalar_impl(
($t: ident, $comp0: ident $(,$compN: ident)*) => ( ($t: ident, $comp0: ident $(,$compN: ident)*) => (
impl<N: Sub<N, N> Sub<N, $t<N>> for $t<N> { impl<N: Sub<N, Output = N> Sub<N> for $t<N> {
type Output = $t<N>;
#[inline] #[inline]
fn sub(self, right: &N) -> $t<N> { fn sub(self, right: &N) -> $t<N> {
$t::new(self.$comp0 - *right $(, self.$compN - *right)*) $t::new(self.$comp0 - *right $(, self.$compN - *right)*)
@ -246,7 +258,7 @@ macro_rules! dim_impl(
macro_rules! indexable_impl( macro_rules! indexable_impl(
($t: ident, $dim: expr) => ( ($t: ident, $dim: expr) => (
impl<N> Shape<(uint, uint), N> for $t<N> { impl<N> Shape<(uint, uint)> for $t<N> {
#[inline] #[inline]
fn shape(&self) -> (uint, uint) { fn shape(&self) -> (uint, uint) {
($dim, $dim) ($dim, $dim)
@ -291,7 +303,9 @@ macro_rules! indexable_impl(
macro_rules! index_impl( macro_rules! index_impl(
($t: ident, $dim: expr) => ( ($t: ident, $dim: expr) => (
impl<N> Index<(uint, uint), N> for $t<N> { impl<N> Index<(uint, uint)> for $t<N> {
type Output = N;
fn index(&self, &(i, j): &(uint, uint)) -> &N { fn index(&self, &(i, j): &(uint, uint)) -> &N {
unsafe { unsafe {
&mem::transmute::<&$t<N>, &mut [N; $dim * $dim]>(self)[i + j * $dim] &mem::transmute::<&$t<N>, &mut [N; $dim * $dim]>(self)[i + j * $dim]
@ -299,7 +313,9 @@ macro_rules! index_impl(
} }
} }
impl<N> IndexMut<(uint, uint), N> for $t<N> { impl<N> IndexMut<(uint, uint)> for $t<N> {
type Output = N;
fn index_mut(&mut self, &(i, j): &(uint, uint)) -> &mut N { fn index_mut(&mut self, &(i, j): &(uint, uint)) -> &mut N {
unsafe { unsafe {
&mut mem::transmute::<&mut $t<N>, &mut [N; $dim * $dim]>(self)[i + j * $dim] &mut mem::transmute::<&mut $t<N>, &mut [N; $dim * $dim]>(self)[i + j * $dim]
@ -426,7 +442,8 @@ macro_rules! diag_impl(
macro_rules! mat_mul_mat_impl( macro_rules! mat_mul_mat_impl(
($t: ident, $dim: expr) => ( ($t: ident, $dim: expr) => (
impl<N: Copy + BaseNum> Mul<$t<N>, $t<N>> for $t<N> { impl<N: Copy + BaseNum> Mul<$t<N>> for $t<N> {
type Output = $t<N>;
#[inline] #[inline]
fn mul(self, 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).
@ -454,7 +471,9 @@ macro_rules! mat_mul_mat_impl(
macro_rules! vec_mul_mat_impl( macro_rules! vec_mul_mat_impl(
($t: ident, $v: ident, $dim: expr, $zero: expr) => ( ($t: ident, $v: ident, $dim: expr, $zero: expr) => (
impl<N: Copy + BaseNum> Mul<$t<N>, $v<N>> for $v<N> { impl<N: Copy + BaseNum> Mul<$t<N>> for $v<N> {
type Output = $v<N>;
#[inline] #[inline]
fn mul(self, 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();
@ -476,7 +495,9 @@ macro_rules! vec_mul_mat_impl(
macro_rules! mat_mul_vec_impl( macro_rules! mat_mul_vec_impl(
($t: ident, $v: ident, $dim: expr, $zero: expr) => ( ($t: ident, $v: ident, $dim: expr, $zero: expr) => (
impl<N: Copy + BaseNum> Mul<$v<N>, $v<N>> for $t<N> { impl<N: Copy + BaseNum> Mul<$v<N>> for $t<N> {
type Output = $v<N>;
#[inline] #[inline]
fn mul(self, 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();
@ -685,7 +706,7 @@ macro_rules! from_homogeneous_impl(
macro_rules! outer_impl( macro_rules! outer_impl(
($t: ident, $m: ident) => ( ($t: ident, $m: ident) => (
impl<N: Copy + Mul<N, N> + Zero> Outer<$m<N>> for $t<N> { impl<N: Copy + Mul<N, Output = N> + Zero> Outer<$m<N>> for $t<N> {
#[inline] #[inline]
fn outer(&self, other: &$t<N>) -> $m<N> { fn outer(&self, other: &$t<N>) -> $m<N> {
let mut res: $m<N> = ::zero(); let mut res: $m<N> = ::zero();

14
src/structs/pnt_macros.rs
View File

@ -21,7 +21,9 @@ macro_rules! orig_impl(
macro_rules! pnt_sub_impl( macro_rules! pnt_sub_impl(
($t: ident, $tv: ident) => ( ($t: ident, $tv: ident) => (
impl<N: Copy + Sub<N, N>> Sub<$t<N>, $tv<N>> for $t<N> { impl<N: Copy + Sub<N, Output = N>> Sub<$t<N>> for $t<N> {
type Output = $tv<N>;
#[inline] #[inline]
fn sub(self, right: $t<N>) -> $tv<N> { fn sub(self, right: $t<N>) -> $tv<N> {
*self.as_vec() - *right.as_vec() *self.as_vec() - *right.as_vec()
@ -32,7 +34,9 @@ macro_rules! pnt_sub_impl(
macro_rules! pnt_add_vec_impl( macro_rules! pnt_add_vec_impl(
($t: ident, $tv: ident, $comp0: ident $(,$compN: ident)*) => ( ($t: ident, $tv: ident, $comp0: ident $(,$compN: ident)*) => (
impl<N: Copy + Add<N, N>> Add<$tv<N>, $t<N>> for $t<N> { impl<N: Copy + Add<N, Output = N>> Add<$tv<N>> for $t<N> {
type Output = $t<N>;
#[inline] #[inline]
fn add(self, right: $tv<N>) -> $t<N> { fn add(self, right: $tv<N>) -> $t<N> {
$t::new(self.$comp0 + right.$comp0 $(, self.$compN + right.$compN)*) $t::new(self.$comp0 + right.$comp0 $(, self.$compN + right.$compN)*)
@ -43,7 +47,9 @@ macro_rules! pnt_add_vec_impl(
macro_rules! pnt_sub_vec_impl( macro_rules! pnt_sub_vec_impl(
($t: ident, $tv: ident, $comp0: ident $(,$compN: ident)*) => ( ($t: ident, $tv: ident, $comp0: ident $(,$compN: ident)*) => (
impl<N: Copy + Sub<N, N>> Sub<$tv<N>, $t<N>> for $t<N> { impl<N: Copy + Sub<N, Output = N>> Sub<$tv<N>> for $t<N> {
type Output = $t<N>;
#[inline] #[inline]
fn sub(self, right: $tv<N>) -> $t<N> { fn sub(self, right: $tv<N>) -> $t<N> {
$t::new(self.$comp0 - right.$comp0 $(, self.$compN - right.$compN)*) $t::new(self.$comp0 - right.$comp0 $(, self.$compN - right.$compN)*)
@ -116,7 +122,7 @@ macro_rules! pnt_to_homogeneous_impl(
macro_rules! pnt_from_homogeneous_impl( macro_rules! pnt_from_homogeneous_impl(
($t: ident, $t2: ident, $extra: ident, $comp0: ident $(,$compN: ident)*) => ( ($t: ident, $t2: ident, $extra: ident, $comp0: ident $(,$compN: ident)*) => (
impl<N: Copy + Div<N, N> + One + Zero> FromHomogeneous<$t2<N>> for $t<N> { impl<N: Copy + Div<N, Output = N> + One + Zero> FromHomogeneous<$t2<N>> for $t<N> {
fn from(v: &$t2<N>) -> $t<N> { fn from(v: &$t2<N>) -> $t<N> {
let mut res: $t<N> = Orig::orig(); let mut res: $t<N> = Orig::orig();

37
src/structs/quat.rs
View File

@ -56,7 +56,7 @@ impl<N> Quat<N> {
} }
} }
impl<N: Neg<N> + Copy> Quat<N> { impl<N: Neg<Output = N> + Copy> Quat<N> {
/// Replaces this quaternion by its conjugate. /// Replaces this quaternion by its conjugate.
#[inline] #[inline]
pub fn conjugate(&mut self) { pub fn conjugate(&mut self) {
@ -123,7 +123,10 @@ impl<N: BaseFloat> Norm<N> for Quat<N> {
} }
} }
impl<N: Copy + Mul<N, N> + Sub<N, N> + Add<N, N>> Mul<Quat<N>, Quat<N>> for Quat<N> { impl<N> Mul<Quat<N>> for Quat<N>
where N: Copy + Mul<N, Output = N> + Sub<N, Output = N> + Add<N, Output = N> {
type Output = Quat<N>;
#[inline] #[inline]
fn mul(self, right: Quat<N>) -> Quat<N> { fn mul(self, right: Quat<N>) -> Quat<N> {
Quat::new( Quat::new(
@ -134,7 +137,9 @@ impl<N: Copy + Mul<N, N> + Sub<N, N> + Add<N, N>> Mul<Quat<N>, Quat<N>> for Quat
} }
} }
impl<N: ApproxEq<N> + BaseFloat> Div<Quat<N>, Quat<N>> for Quat<N> { impl<N: ApproxEq<N> + BaseFloat> Div<Quat<N>> for Quat<N> {
type Output = Quat<N>;
#[inline] #[inline]
fn div(self, right: Quat<N>) -> Quat<N> { fn div(self, right: Quat<N>) -> Quat<N> {
self * right.inv_cpy().expect("Unable to invert the denominator.") self * right.inv_cpy().expect("Unable to invert the denominator.")
@ -261,7 +266,7 @@ impl<N: BaseNum> One for UnitQuat<N> {
} }
} }
impl<N: Copy + Neg<N>> Inv for UnitQuat<N> { impl<N: Copy + Neg<Output = N>> Inv for UnitQuat<N> {
#[inline] #[inline]
fn inv_cpy(&self) -> Option<UnitQuat<N>> { fn inv_cpy(&self) -> Option<UnitQuat<N>> {
let mut cpy = *self; let mut cpy = *self;
@ -307,21 +312,27 @@ impl<N: ApproxEq<N>> ApproxEq<N> for UnitQuat<N> {
} }
} }
impl<N: BaseFloat + ApproxEq<N>> Div<UnitQuat<N>, UnitQuat<N>> for UnitQuat<N> { impl<N: BaseFloat + ApproxEq<N>> Div<UnitQuat<N>> for UnitQuat<N> {
type Output = UnitQuat<N>;
#[inline] #[inline]
fn div(self, other: UnitQuat<N>) -> UnitQuat<N> { fn div(self, other: UnitQuat<N>) -> UnitQuat<N> {
UnitQuat { q: self.q / other.q } UnitQuat { q: self.q / other.q }
} }
} }
impl<N: BaseNum> Mul<UnitQuat<N>, UnitQuat<N>> for UnitQuat<N> { impl<N: BaseNum> Mul<UnitQuat<N>> for UnitQuat<N> {
type Output = UnitQuat<N>;
#[inline] #[inline]
fn mul(self, right: UnitQuat<N>) -> UnitQuat<N> { fn mul(self, right: UnitQuat<N>) -> UnitQuat<N> {
UnitQuat { q: self.q * right.q } UnitQuat { q: self.q * right.q }
} }
} }
impl<N: BaseNum> Mul<Vec3<N>, Vec3<N>> for UnitQuat<N> { impl<N: BaseNum> Mul<Vec3<N>> for UnitQuat<N> {
type Output = Vec3<N>;
#[inline] #[inline]
fn mul(self, 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();
@ -334,14 +345,18 @@ impl<N: BaseNum> Mul<Vec3<N>, Vec3<N>> for UnitQuat<N> {
} }
} }
impl<N: BaseNum> Mul<Pnt3<N>, Pnt3<N>> for UnitQuat<N> { impl<N: BaseNum> Mul<Pnt3<N>> for UnitQuat<N> {
type Output = Pnt3<N>;
#[inline] #[inline]
fn mul(self, right: Pnt3<N>) -> Pnt3<N> { fn mul(self, right: Pnt3<N>) -> Pnt3<N> {
::orig::<Pnt3<N>>() + self * *right.as_vec() ::orig::<Pnt3<N>>() + self * *right.as_vec()
} }
} }
impl<N: BaseNum> Mul<UnitQuat<N>, Vec3<N>> for Vec3<N> { impl<N: BaseNum> Mul<UnitQuat<N>> for Vec3<N> {
type Output = Vec3<N>;
#[inline] #[inline]
fn mul(self, right: UnitQuat<N>) -> Vec3<N> { fn mul(self, right: UnitQuat<N>) -> Vec3<N> {
let mut inv_quat = right; let mut inv_quat = right;
@ -352,7 +367,9 @@ impl<N: BaseNum> Mul<UnitQuat<N>, Vec3<N>> for Vec3<N> {
} }
} }
impl<N: BaseNum> Mul<UnitQuat<N>, Pnt3<N>> for Pnt3<N> { impl<N: BaseNum> Mul<UnitQuat<N>> for Pnt3<N> {
type Output = Pnt3<N>;
#[inline] #[inline]
fn mul(self, right: UnitQuat<N>) -> Pnt3<N> { fn mul(self, right: UnitQuat<N>) -> Pnt3<N> {
::orig::<Pnt3<N>>() + *self.as_vec() * right ::orig::<Pnt3<N>>() + *self.as_vec() * right

4
src/structs/rot.rs
View File

@ -19,7 +19,7 @@ pub struct Rot2<N> {
submat: Mat2<N> submat: Mat2<N>
} }
impl<N: Clone + BaseFloat + Neg<N> + Copy> Rot2<N> { impl<N: Clone + BaseFloat + Neg<Output = N> + Copy> Rot2<N> {
/// Builds a 2 dimensional rotation matrix from an angle in radian. /// Builds a 2 dimensional rotation matrix from an angle in radian.
pub fn new(angle: Vec1<N>) -> Rot2<N> { pub fn new(angle: Vec1<N>) -> Rot2<N> {
let (sia, coa) = angle.x.sin_cos(); let (sia, coa) = angle.x.sin_cos();
@ -67,7 +67,7 @@ impl<N: BaseFloat + Clone> Rotation<Vec1<N>> for Rot2<N> {
} }
} }
impl<N: Clone + Rand + BaseFloat + Neg<N> + Copy> Rand for Rot2<N> { impl<N: Rand + BaseFloat> Rand for Rot2<N> {
#[inline] #[inline]
fn rand<R: Rng>(rng: &mut R) -> Rot2<N> { fn rand<R: Rng>(rng: &mut R) -> Rot2<N> {
Rot2::new(rng.gen()) Rot2::new(rng.gen())

20
src/structs/rot_macros.rs
View File

@ -80,7 +80,9 @@ macro_rules! dim_impl(
macro_rules! rotation_matrix_impl( macro_rules! rotation_matrix_impl(
($t: ident, $tlv: ident, $tav: ident) => ( ($t: ident, $tlv: ident, $tav: ident) => (
impl<N: Zero + BaseNum + Cast<f64> + BaseFloat> RotationMatrix<N, $tlv<N>, $tav<N>, $t<N>> for $t<N> { impl<N: Zero + BaseNum + Cast<f64> + BaseFloat> RotationMatrix<N, $tlv<N>, $tav<N>> for $t<N> {
type Output = $t<N>;
#[inline] #[inline]
fn to_rot_mat(&self) -> $t<N> { fn to_rot_mat(&self) -> $t<N> {
self.clone() self.clone()
@ -102,7 +104,9 @@ macro_rules! one_impl(
macro_rules! rot_mul_rot_impl( macro_rules! rot_mul_rot_impl(
($t: ident) => ( ($t: ident) => (
impl<N: BaseNum> Mul<$t<N>, $t<N>> for $t<N> { impl<N: BaseNum> Mul<$t<N>> for $t<N> {
type Output = $t<N>;
#[inline] #[inline]
fn mul(self, right: $t<N>) -> $t<N> { fn mul(self, right: $t<N>) -> $t<N> {
$t { submat: self.submat * right.submat } $t { submat: self.submat * right.submat }
@ -113,7 +117,9 @@ macro_rules! rot_mul_rot_impl(
macro_rules! rot_mul_vec_impl( macro_rules! rot_mul_vec_impl(
($t: ident, $tv: ident) => ( ($t: ident, $tv: ident) => (
impl<N: BaseNum> Mul<$tv<N>, $tv<N>> for $t<N> { impl<N: BaseNum> Mul<$tv<N>> for $t<N> {
type Output = $tv<N>;
#[inline] #[inline]
fn mul(self, right: $tv<N>) -> $tv<N> { fn mul(self, right: $tv<N>) -> $tv<N> {
self.submat * right self.submat * right
@ -130,7 +136,9 @@ macro_rules! rot_mul_pnt_impl(
macro_rules! vec_mul_rot_impl( macro_rules! vec_mul_rot_impl(
($t: ident, $tv: ident) => ( ($t: ident, $tv: ident) => (
impl<N: BaseNum> Mul<$t<N>, $tv<N>> for $tv<N> { impl<N: BaseNum> Mul<$t<N>> for $tv<N> {
type Output = $tv<N>;
#[inline] #[inline]
fn mul(self, right: $t<N>) -> $tv<N> { fn mul(self, right: $t<N>) -> $tv<N> {
self * right.submat self * right.submat
@ -223,7 +231,9 @@ macro_rules! col_impl(
macro_rules! index_impl( macro_rules! index_impl(
($t: ident) => ( ($t: ident) => (
impl<N> Index<(uint, uint), N> for $t<N> { impl<N> Index<(uint, uint)> for $t<N> {
type Output = N;
fn index(&self, i: &(uint, uint)) -> &N { fn index(&self, i: &(uint, uint)) -> &N {
&self.submat[*i] &self.submat[*i]
} }

4
src/structs/spec/identity.rs
View File

@ -22,7 +22,9 @@ impl Inv for mat::Identity {
} }
} }
impl<T: Clone> Mul<T, T> for mat::Identity { impl<T: Clone> Mul<T> for mat::Identity {
type Output = T;
#[inline] #[inline]
fn mul(self, other: T) -> T { fn mul(self, other: T) -> T {
other other

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

@ -210,7 +210,9 @@ impl<N: Copy> Col<Vec3<N>> for Mat3<N> {
} }
} }
impl<N: Copy + Mul<N, N> + Add<N, N>> Mul<Mat3<N>, Mat3<N>> for Mat3<N> { impl<N: Copy + Mul<N, Output = N> + Add<N, Output = N>> Mul<Mat3<N>> for Mat3<N> {
type Output = Mat3<N>;
#[inline] #[inline]
fn mul(self, right: Mat3<N>) -> Mat3<N> { fn mul(self, right: Mat3<N>) -> Mat3<N> {
Mat3::new( Mat3::new(
@ -229,7 +231,9 @@ impl<N: Copy + Mul<N, N> + Add<N, N>> Mul<Mat3<N>, Mat3<N>> for Mat3<N> {
} }
} }
impl<N: Copy + Mul<N, N> + Add<N, N>> Mul<Mat2<N>, Mat2<N>> for Mat2<N> { impl<N: Copy + Mul<N, Output = N> + Add<N, Output = N>> Mul<Mat2<N>> for Mat2<N> {
type Output = Mat2<N>;
#[inline(always)] #[inline(always)]
fn mul(self, right: Mat2<N>) -> Mat2<N> { fn mul(self, right: Mat2<N>) -> Mat2<N> {
Mat2::new( Mat2::new(
@ -242,7 +246,9 @@ impl<N: Copy + Mul<N, N> + Add<N, N>> Mul<Mat2<N>, Mat2<N>> for Mat2<N> {
} }
} }
impl<N: Copy + Mul<N, N> + Add<N, N>> Mul<Vec3<N>, Vec3<N>> for Mat3<N> { impl<N: Copy + Mul<N, Output = N> + Add<N, Output = N>> Mul<Vec3<N>> for Mat3<N> {
type Output = Vec3<N>;
#[inline(always)] #[inline(always)]
fn mul(self, right: Vec3<N>) -> Vec3<N> { fn mul(self, right: Vec3<N>) -> Vec3<N> {
Vec3::new( Vec3::new(
@ -253,7 +259,9 @@ impl<N: Copy + Mul<N, N> + Add<N, N>> Mul<Vec3<N>, Vec3<N>> for Mat3<N> {
} }
} }
impl<N: Copy + Mul<N, N> + Add<N, N>> Mul<Mat3<N>, Vec3<N>> for Vec3<N> { impl<N: Copy + Mul<N, Output = N> + Add<N, Output = N>> Mul<Mat3<N>> for Vec3<N> {
type Output = Vec3<N>;
#[inline(always)] #[inline(always)]
fn mul(self, right: Mat3<N>) -> Vec3<N> { fn mul(self, right: Mat3<N>) -> Vec3<N> {
Vec3::new( Vec3::new(
@ -264,7 +272,9 @@ impl<N: Copy + Mul<N, N> + Add<N, N>> Mul<Mat3<N>, Vec3<N>> for Vec3<N> {
} }
} }
impl<N: Copy + Mul<N, N> + Add<N, N>> Mul<Mat2<N>, Vec2<N>> for Vec2<N> { impl<N: Copy + Mul<N, Output = N> + Add<N, Output = N>> Mul<Mat2<N>> for Vec2<N> {
type Output = Vec2<N>;
#[inline(always)] #[inline(always)]
fn mul(self, right: Mat2<N>) -> Vec2<N> { fn mul(self, right: Mat2<N>) -> Vec2<N> {
Vec2::new( Vec2::new(
@ -274,7 +284,9 @@ impl<N: Copy + Mul<N, N> + Add<N, N>> Mul<Mat2<N>, Vec2<N>> for Vec2<N> {
} }
} }
impl<N: Copy + Mul<N, N> + Add<N, N>> Mul<Vec2<N>, Vec2<N>> for Mat2<N> { impl<N: Copy + Mul<N, Output = N> + Add<N, Output = N>> Mul<Vec2<N>> for Mat2<N> {
type Output = Vec2<N>;
#[inline(always)] #[inline(always)]
fn mul(self, right: Vec2<N>) -> Vec2<N> { fn mul(self, right: Vec2<N>) -> Vec2<N> {
Vec2::new( Vec2::new(
@ -284,7 +296,9 @@ impl<N: Copy + Mul<N, N> + Add<N, N>> Mul<Vec2<N>, Vec2<N>> for Mat2<N> {
} }
} }
impl<N: Copy + Mul<N, N> + Add<N, N>> Mul<Pnt3<N>, Pnt3<N>> for Mat3<N> { impl<N: Copy + Mul<N, Output = N> + Add<N, Output = N>> Mul<Pnt3<N>> for Mat3<N> {
type Output = Pnt3<N>;
#[inline(always)] #[inline(always)]
fn mul(self, right: Pnt3<N>) -> Pnt3<N> { fn mul(self, right: Pnt3<N>) -> Pnt3<N> {
Pnt3::new( Pnt3::new(
@ -295,7 +309,9 @@ impl<N: Copy + Mul<N, N> + Add<N, N>> Mul<Pnt3<N>, Pnt3<N>> for Mat3<N> {
} }
} }
impl<N: Copy + Mul<N, N> + Add<N, N>> Mul<Mat3<N>, Pnt3<N>> for Pnt3<N> { impl<N: Copy + Mul<N, Output = N> + Add<N, Output = N>> Mul<Mat3<N>> for Pnt3<N> {
type Output = Pnt3<N>;
#[inline(always)] #[inline(always)]
fn mul(self, right: Mat3<N>) -> Pnt3<N> { fn mul(self, right: Mat3<N>) -> Pnt3<N> {
Pnt3::new( Pnt3::new(
@ -306,7 +322,9 @@ impl<N: Copy + Mul<N, N> + Add<N, N>> Mul<Mat3<N>, Pnt3<N>> for Pnt3<N> {
} }
} }
impl<N: Copy + Mul<N, N> + Add<N, N>> Mul<Mat2<N>, Pnt2<N>> for Pnt2<N> { impl<N: Copy + Mul<N, Output = N> + Add<N, Output = N>> Mul<Mat2<N>> for Pnt2<N> {
type Output = Pnt2<N>;
#[inline(always)] #[inline(always)]
fn mul(self, right: Mat2<N>) -> Pnt2<N> { fn mul(self, right: Mat2<N>) -> Pnt2<N> {
Pnt2::new( Pnt2::new(
@ -316,7 +334,9 @@ impl<N: Copy + Mul<N, N> + Add<N, N>> Mul<Mat2<N>, Pnt2<N>> for Pnt2<N> {
} }
} }
impl<N: Copy + Mul<N, N> + Add<N, N>> Mul<Pnt2<N>, Pnt2<N>> for Mat2<N> { impl<N: Copy + Mul<N, Output = N> + Add<N, Output = N>> Mul<Pnt2<N>> for Mat2<N> {
type Output = Pnt2<N>;
#[inline(always)] #[inline(always)]
fn mul(self, right: Pnt2<N>) -> Pnt2<N> { fn mul(self, right: Pnt2<N>) -> Pnt2<N> {
Pnt2::new( Pnt2::new(

14
src/structs/spec/vec.rs
View File

@ -4,7 +4,9 @@ use traits::geometry::{Norm, Cross, CrossMatrix, UniformSphereSample};
use structs::vec::{Vec1, Vec2, Vec3, Vec4}; use structs::vec::{Vec1, Vec2, Vec3, Vec4};
use structs::mat::Mat3; use structs::mat::Mat3;
impl<N: Copy + Mul<N, N> + Sub<N, N>> Cross<Vec1<N>> for Vec2<N> { impl<N: Copy + Mul<N, Output = N> + Sub<N, Output = N>> Cross for Vec2<N> {
type Output = Vec1<N>;
#[inline] #[inline]
fn cross(&self, other: &Vec2<N>) -> Vec1<N> { fn cross(&self, other: &Vec2<N>) -> Vec1<N> {
Vec1::new(self.x * other.y - self.y * other.x) Vec1::new(self.x * other.y - self.y * other.x)
@ -12,14 +14,16 @@ impl<N: Copy + Mul<N, N> + Sub<N, N>> Cross<Vec1<N>> for Vec2<N> {
} }
// FIXME: instead of returning a Vec2, define a Mat2x1 matrix? // FIXME: instead of returning a Vec2, define a Mat2x1 matrix?
impl<N: Neg<N> + Copy> CrossMatrix<Vec2<N>> for Vec2<N> { impl<N: Neg<Output = N> + Copy> CrossMatrix<Vec2<N>> for Vec2<N> {
#[inline] #[inline]
fn cross_matrix(&self) -> Vec2<N> { fn cross_matrix(&self) -> Vec2<N> {
Vec2::new(-self.y, self.x) Vec2::new(-self.y, self.x)
} }
} }
impl<N: Copy + Mul<N, N> + Sub<N, N>> Cross<Vec3<N>> for Vec3<N> { impl<N: Copy + Mul<N, Output = N> + Sub<N, Output = N>> Cross for Vec3<N> {
type Output = Vec3<N>;
#[inline] #[inline]
fn cross(&self, other: &Vec3<N>) -> Vec3<N> { fn cross(&self, other: &Vec3<N>) -> Vec3<N> {
Vec3::new( Vec3::new(
@ -30,7 +34,7 @@ impl<N: Copy + Mul<N, N> + Sub<N, N>> Cross<Vec3<N>> for Vec3<N> {
} }
} }
impl<N: Neg<N> + Zero + Copy> CrossMatrix<Mat3<N>> for Vec3<N> { impl<N: Neg<Output = N> + Zero + Copy> CrossMatrix<Mat3<N>> for Vec3<N> {
#[inline] #[inline]
fn cross_matrix(&self) -> Mat3<N> { fn cross_matrix(&self) -> Mat3<N> {
Mat3::new( Mat3::new(
@ -88,7 +92,7 @@ impl<N: One> Basis for Vec1<N> {
} }
} }
impl<N: Copy + One + Zero + Neg<N>> Basis for Vec2<N> { impl<N: Copy + One + Zero + Neg<Output = N>> Basis for Vec2<N> {
#[inline(always)] #[inline(always)]
fn canonical_basis(f: |Vec2<N>| -> bool) { fn canonical_basis(f: |Vec2<N>| -> bool) {
if !f(Vec2::new(::one(), ::zero())) { return }; if !f(Vec2::new(::one(), ::zero())) { return };

34
src/structs/spec/vec0.rs
View File

@ -20,21 +20,25 @@ impl<N> Zero for vec::Vec0<N> {
} }
} }
impl<N> Index<uint, N> for vec::Vec0<N> { impl<N> Index<uint> for vec::Vec0<N> {
type Output = N;
#[inline] #[inline]
fn index(&self, _: &uint) -> &N { fn index(&self, _: &uint) -> &N {
panic!("Canot index a Vec0.") panic!("Canot index a Vec0.")
} }
} }
impl<N> IndexMut<uint, N> for vec::Vec0<N> { impl<N> IndexMut<uint> for vec::Vec0<N> {
type Output = N;
#[inline] #[inline]
fn index_mut(&mut self, _: &uint) -> &mut N { fn index_mut(&mut self, _: &uint) -> &mut N {
panic!("Canot index a Vec0.") panic!("Canot index a Vec0.")
} }
} }
impl<N> Shape<uint, N> for vec::Vec0<N> { impl<N> Shape<uint> for vec::Vec0<N> {
#[inline] #[inline]
fn shape(&self) -> uint { fn shape(&self) -> uint {
0 0
@ -99,21 +103,27 @@ impl<N> Basis for vec::Vec0<N> {
} }
} }
impl<N, T> Add<T, vec::Vec0<N>> for vec::Vec0<N> { impl<N, T> Add<T> for vec::Vec0<N> {
type Output = vec::Vec0<N>;
#[inline] #[inline]
fn add(self, _: T) -> vec::Vec0<N> { fn add(self, _: T) -> vec::Vec0<N> {
vec::Vec0 vec::Vec0
} }
} }
impl<N, T> Sub<T, vec::Vec0<N>> for vec::Vec0<N> { impl<N, T> Sub<T> for vec::Vec0<N> {
type Output = vec::Vec0<N>;
#[inline] #[inline]
fn sub(self, _: T) -> vec::Vec0<N> { fn sub(self, _: T) -> vec::Vec0<N> {
vec::Vec0 vec::Vec0
} }
} }
impl<N: Neg<N> + Copy> Neg<vec::Vec0<N>> for vec::Vec0<N> { impl<N: Neg<Output = N> + Copy> Neg for vec::Vec0<N> {
type Output = vec::Vec0<N>;
#[inline] #[inline]
fn neg(self) -> vec::Vec0<N> { fn neg(self) -> vec::Vec0<N> {
vec::Vec0 vec::Vec0
@ -127,21 +137,25 @@ impl<N: BaseNum> Dot<N> for vec::Vec0<N> {
} }
} }
impl<N, T> Mul<T, vec::Vec0<N>> for vec::Vec0<N> { impl<N, T> Mul<T> for vec::Vec0<N> {
type Output = vec::Vec0<N>;
#[inline] #[inline]
fn mul(self, _: T) -> vec::Vec0<N> { fn mul(self, _: T) -> vec::Vec0<N> {
vec::Vec0 vec::Vec0
} }
} }
impl<N, T> Div<T, vec::Vec0<N>> for vec::Vec0<N> { impl<N, T> Div<T> for vec::Vec0<N> {
type Output = vec::Vec0<N>;
#[inline] #[inline]
fn div(self, _: T) -> vec::Vec0<N> { fn div(self, _: T) -> vec::Vec0<N> {
vec::Vec0 vec::Vec0
} }
} }
impl<N: Copy + Add<N, N> + Neg<N>> Translation<vec::Vec0<N>> for vec::Vec0<N> { impl<N: Copy + Add<N, Output = N> + Neg<Output = N>> Translation<vec::Vec0<N>> for vec::Vec0<N> {
#[inline] #[inline]
fn translation(&self) -> vec::Vec0<N> { fn translation(&self) -> vec::Vec0<N> {
*self *self
@ -229,7 +243,7 @@ impl<N: One> One for vec::Vec0<N> {
impl<N> FromIterator<N> for vec::Vec0<N> { impl<N> FromIterator<N> for vec::Vec0<N> {
#[inline] #[inline]
fn from_iter<I: Iterator<N>>(_: I) -> vec::Vec0<N> { fn from_iter<I: Iterator<Item = N>>(_: I) -> vec::Vec0<N> {
vec::Vec0 vec::Vec0
} }
} }

63
src/structs/vec_macros.rs
View File

@ -192,7 +192,7 @@ macro_rules! vec_cast_impl(
macro_rules! indexable_impl( macro_rules! indexable_impl(
($t: ident, $dim: expr) => ( ($t: ident, $dim: expr) => (
impl<N> Shape<uint, N> for $t<N> { impl<N> Shape<uint> for $t<N> {
#[inline] #[inline]
fn shape(&self) -> uint { fn shape(&self) -> uint {
$dim $dim
@ -236,13 +236,17 @@ macro_rules! indexable_impl(
macro_rules! index_impl( macro_rules! index_impl(
($t: ident) => ( ($t: ident) => (
impl<N> Index<uint, N> for $t<N> { impl<N> Index<uint> for $t<N> {
type Output = N;
fn index(&self, i: &uint) -> &N { fn index(&self, i: &uint) -> &N {
&self.as_array()[*i] &self.as_array()[*i]
} }
} }
impl<N> IndexMut<uint, N> for $t<N> { impl<N> IndexMut<uint> for $t<N> {
type Output = N;
fn index_mut(&mut self, i: &uint) -> &mut N { fn index_mut(&mut self, i: &uint) -> &mut N {
&mut self.as_array_mut()[*i] &mut self.as_array_mut()[*i]
} }
@ -391,7 +395,9 @@ macro_rules! axpy_impl(
macro_rules! add_impl( macro_rules! add_impl(
($t: ident, $comp0: ident $(,$compN: ident)*) => ( ($t: ident, $comp0: ident $(,$compN: ident)*) => (
impl<N: Add<N, N>> Add<$t<N>, $t<N>> for $t<N> { impl<N: Add<N, Output = N>> Add<$t<N>> for $t<N> {
type Output = $t<N>;
#[inline] #[inline]
fn add(self, right: $t<N>) -> $t<N> { fn add(self, right: $t<N>) -> $t<N> {
$t::new(self.$comp0 + right.$comp0 $(, self.$compN + right.$compN)*) $t::new(self.$comp0 + right.$comp0 $(, self.$compN + right.$compN)*)
@ -403,7 +409,9 @@ macro_rules! add_impl(
macro_rules! scalar_add_impl( macro_rules! scalar_add_impl(
($t: ident, $comp0: ident $(,$compN: ident)*) => ( ($t: ident, $comp0: ident $(,$compN: ident)*) => (
// $t against scalar // $t against scalar
impl<N: Copy + Add<N, N>> Add<N, $t<N>> for $t<N> { impl<N: Copy + Add<N, Output = N>> Add<N> for $t<N> {
type Output = $t<N>;
#[inline] #[inline]
fn add(self, right: N) -> $t<N> { fn add(self, right: N) -> $t<N> {
$t::new(self.$comp0 + right $(, self.$compN + right)*) $t::new(self.$comp0 + right $(, self.$compN + right)*)
@ -414,7 +422,9 @@ macro_rules! scalar_add_impl(
macro_rules! sub_impl( macro_rules! sub_impl(
($t: ident, $comp0: ident $(,$compN: ident)*) => ( ($t: ident, $comp0: ident $(,$compN: ident)*) => (
impl<N: Sub<N, N>> Sub<$t<N>, $t<N>> for $t<N> { impl<N: Sub<N, Output = N>> Sub<$t<N>> for $t<N> {
type Output = $t<N>;
#[inline] #[inline]
fn sub(self, right: $t<N>) -> $t<N> { fn sub(self, right: $t<N>) -> $t<N> {
$t::new(self.$comp0 - right.$comp0 $(, self.$compN - right.$compN)*) $t::new(self.$comp0 - right.$comp0 $(, self.$compN - right.$compN)*)
@ -425,7 +435,9 @@ macro_rules! sub_impl(
macro_rules! scalar_sub_impl( macro_rules! scalar_sub_impl(
($t: ident, $comp0: ident $(,$compN: ident)*) => ( ($t: ident, $comp0: ident $(,$compN: ident)*) => (
impl<N: Copy + Sub<N, N>> Sub<N, $t<N>> for $t<N> { impl<N: Copy + Sub<N, Output = N>> Sub<N> for $t<N> {
type Output = $t<N>;
#[inline] #[inline]
fn sub(self, right: N) -> $t<N> { fn sub(self, right: N) -> $t<N> {
$t::new(self.$comp0 - right $(, self.$compN - right)*) $t::new(self.$comp0 - right $(, self.$compN - right)*)
@ -436,7 +448,8 @@ macro_rules! scalar_sub_impl(
macro_rules! mul_impl( macro_rules! mul_impl(
($t: ident, $comp0: ident $(,$compN: ident)*) => ( ($t: ident, $comp0: ident $(,$compN: ident)*) => (
impl<N: Copy + Mul<N, N>> Mul<$t<N>, $t<N>> for $t<N> { impl<N: Copy + Mul<N, Output = N>> Mul<$t<N>> for $t<N> {
type Output = $t<N>;
#[inline] #[inline]
fn mul(self, right: $t<N>) -> $t<N> { fn mul(self, right: $t<N>) -> $t<N> {
$t::new(self.$comp0 * right.$comp0 $(, self.$compN * right.$compN)*) $t::new(self.$comp0 * right.$comp0 $(, self.$compN * right.$compN)*)
@ -447,7 +460,9 @@ macro_rules! mul_impl(
macro_rules! scalar_mul_impl( macro_rules! scalar_mul_impl(
($t: ident, $comp0: ident $(,$compN: ident)*) => ( ($t: ident, $comp0: ident $(,$compN: ident)*) => (
impl<N: Copy + Mul<N, N>> Mul<N, $t<N>> for $t<N> { impl<N: Copy + Mul<N, Output = N>> Mul<N> for $t<N> {
type Output = $t<N>;
#[inline] #[inline]
fn mul(self, right: N) -> $t<N> { fn mul(self, right: N) -> $t<N> {
$t::new(self.$comp0 * right $(, self.$compN * right)*) $t::new(self.$comp0 * right $(, self.$compN * right)*)
@ -458,7 +473,9 @@ macro_rules! scalar_mul_impl(
macro_rules! div_impl( macro_rules! div_impl(
($t: ident, $comp0: ident $(,$compN: ident)*) => ( ($t: ident, $comp0: ident $(,$compN: ident)*) => (
impl<N: Copy + Div<N, N>> Div<$t<N>, $t<N>> for $t<N> { impl<N: Copy + Div<N, Output = N>> Div<$t<N>> for $t<N> {
type Output = $t<N>;
#[inline] #[inline]
fn div(self, right: $t<N>) -> $t<N> { fn div(self, right: $t<N>) -> $t<N> {
$t::new(self.$comp0 / right.$comp0 $(, self.$compN / right.$compN)*) $t::new(self.$comp0 / right.$comp0 $(, self.$compN / right.$compN)*)
@ -469,7 +486,9 @@ macro_rules! div_impl(
macro_rules! scalar_div_impl( macro_rules! scalar_div_impl(
($t: ident, $comp0: ident $(,$compN: ident)*) => ( ($t: ident, $comp0: ident $(,$compN: ident)*) => (
impl<N: Copy + Div<N, N>> Div<N, $t<N>> for $t<N> { impl<N: Copy + Div<N, Output = N>> Div<N> for $t<N> {
type Output = $t<N>;
#[inline] #[inline]
fn div(self, right: N) -> $t<N> { fn div(self, right: N) -> $t<N> {
$t::new(self.$comp0 / right $(, self.$compN / right)*) $t::new(self.$comp0 / right $(, self.$compN / right)*)
@ -480,7 +499,9 @@ macro_rules! scalar_div_impl(
macro_rules! neg_impl( macro_rules! neg_impl(
($t: ident, $comp0: ident $(,$compN: ident)*) => ( ($t: ident, $comp0: ident $(,$compN: ident)*) => (
impl<N: Neg<N> + Copy> Neg<$t<N>> for $t<N> { impl<N: Neg<Output = N> + Copy> Neg for $t<N> {
type Output = $t<N>;
#[inline] #[inline]
fn neg(self) -> $t<N> { fn neg(self) -> $t<N> {
$t::new(-self.$comp0 $(, -self.$compN )*) $t::new(-self.$comp0 $(, -self.$compN )*)
@ -502,28 +523,28 @@ macro_rules! dot_impl(
macro_rules! scalar_ops_impl( macro_rules! scalar_ops_impl(
($t: ident, $comp0: ident $(,$compN: ident)*) => ( ($t: ident, $comp0: ident $(,$compN: ident)*) => (
impl<N: Copy + Mul<N, N>> ScalarMul<N> for $t<N> { impl<N: Copy + Mul<N, Output = N>> ScalarMul<N> for $t<N> {
#[inline] #[inline]
fn mul_s(&self, other: &N) -> $t<N> { fn mul_s(&self, other: &N) -> $t<N> {
$t::new(self.$comp0 * *other $(, self.$compN * *other)*) $t::new(self.$comp0 * *other $(, self.$compN * *other)*)
} }
} }
impl<N: Copy + Div<N, N>> ScalarDiv<N> for $t<N> { impl<N: Copy + Div<N, Output = N>> ScalarDiv<N> for $t<N> {
#[inline] #[inline]
fn div_s(&self, other: &N) -> $t<N> { fn div_s(&self, other: &N) -> $t<N> {
$t::new(self.$comp0 / *other $(, self.$compN / *other)*) $t::new(self.$comp0 / *other $(, self.$compN / *other)*)
} }
} }
impl<N: Copy + Add<N, N>> ScalarAdd<N> for $t<N> { impl<N: Copy + Add<N, Output = N>> ScalarAdd<N> for $t<N> {
#[inline] #[inline]
fn add_s(&self, other: &N) -> $t<N> { fn add_s(&self, other: &N) -> $t<N> {
$t::new(self.$comp0 + *other $(, self.$compN + *other)*) $t::new(self.$comp0 + *other $(, self.$compN + *other)*)
} }
} }
impl<N: Copy + Sub<N, N>> ScalarSub<N> for $t<N> { impl<N: Copy + Sub<N, Output = N>> ScalarSub<N> for $t<N> {
#[inline] #[inline]
fn sub_s(&self, other: &N) -> $t<N> { fn sub_s(&self, other: &N) -> $t<N> {
$t::new(self.$comp0 - *other $(, self.$compN - *other)*) $t::new(self.$comp0 - *other $(, self.$compN - *other)*)
@ -534,7 +555,7 @@ macro_rules! scalar_ops_impl(
macro_rules! translation_impl( macro_rules! translation_impl(
($t: ident) => ( ($t: ident) => (
impl<N: Copy + Add<N, N> + Neg<N>> Translation<$t<N>> for $t<N> { impl<N: Copy + Add<N, Output = N> + Neg<Output = N>> Translation<$t<N>> for $t<N> {
#[inline] #[inline]
fn translation(&self) -> $t<N> { fn translation(&self) -> $t<N> {
*self *self
@ -669,7 +690,7 @@ macro_rules! from_iterator_impl(
($t: ident, $param0: ident $(, $paramN: ident)*) => ( ($t: ident, $param0: ident $(, $paramN: ident)*) => (
impl<N> FromIterator<N> for $t<N> { impl<N> FromIterator<N> for $t<N> {
#[inline] #[inline]
fn from_iter<I: Iterator<N>>(mut $param0: I) -> $t<N> { fn from_iter<I: Iterator<Item = N>>(mut $param0: I) -> $t<N> {
$t::new($param0.next().unwrap() $(, $paramN.next().unwrap())*) $t::new($param0.next().unwrap() $(, $paramN.next().unwrap())*)
} }
} }
@ -715,7 +736,7 @@ macro_rules! vec_to_homogeneous_impl(
macro_rules! vec_from_homogeneous_impl( macro_rules! vec_from_homogeneous_impl(
($t: ident, $t2: ident, $extra: ident, $comp0: ident $(,$compN: ident)*) => ( ($t: ident, $t2: ident, $extra: ident, $comp0: ident $(,$compN: ident)*) => (
impl<N: Copy + Div<N, N> + One + Zero> FromHomogeneous<$t2<N>> for $t<N> { impl<N: Copy + Div<N, Output = N> + One + Zero> FromHomogeneous<$t2<N>> for $t<N> {
fn from(v: &$t2<N>) -> $t<N> { fn from(v: &$t2<N>) -> $t<N> {
let mut res: $t<N> = ::zero(); let mut res: $t<N> = ::zero();
@ -730,7 +751,7 @@ macro_rules! vec_from_homogeneous_impl(
macro_rules! translate_impl( macro_rules! translate_impl(
($tv: ident, $t: ident) => ( ($tv: ident, $t: ident) => (
impl<N: Copy + Add<N, N> + Sub<N, N>> Translate<$t<N>> for $tv<N> { impl<N: Copy + Add<N, Output = N> + Sub<N, Output = N>> Translate<$t<N>> for $tv<N> {
fn translate(&self, other: &$t<N>) -> $t<N> { fn translate(&self, other: &$t<N>) -> $t<N> {
*other + *self *other + *self
} }
@ -758,7 +779,7 @@ macro_rules! rotate_impl(
macro_rules! transform_impl( macro_rules! transform_impl(
($tv: ident, $t: ident) => ( ($tv: ident, $t: ident) => (
impl<N: Copy + Add<N, N> + Sub<N, N>> Transform<$t<N>> for $tv<N> { impl<N: Copy + Add<N, Output = N> + Sub<N, Output = N>> Transform<$t<N>> for $tv<N> {
fn transform(&self, other: &$t<N>) -> $t<N> { fn transform(&self, other: &$t<N>) -> $t<N> {
self.translate(other) self.translate(other)
} }

16
src/traits/geometry.rs
View File

@ -82,7 +82,7 @@ pub trait Rotate<V> {
/// ///
/// Those operations are automatically implemented in term of the `Rotation` and `Translation` /// Those operations are automatically implemented in term of the `Rotation` and `Translation`
/// traits. /// traits.
pub trait RotationWithTranslation<LV: Neg<LV> + Copy, AV>: Rotation<AV> + Translation<LV> + Sized { pub trait RotationWithTranslation<LV: Neg<Output = LV> + Copy, AV>: Rotation<AV> + Translation<LV> + Sized {
/// Applies a rotation centered on a specific point. /// Applies a rotation centered on a specific point.
/// ///
/// # Arguments /// # Arguments
@ -136,14 +136,16 @@ pub trait RotationWithTranslation<LV: Neg<LV> + Copy, AV>: Rotation<AV> + Transl
} }
} }
impl<LV: Neg<LV> + Copy, AV, M: Rotation<AV> + Translation<LV>> RotationWithTranslation<LV, AV> for M { impl<LV: Neg<Output = LV> + Copy, AV, M: Rotation<AV> + Translation<LV>> RotationWithTranslation<LV, AV> for M {
} }
/// Trait of transformation having a rotation extractable as a rotation matrix. This can typically /// Trait of transformation having a rotation extractable as a rotation matrix. This can typically
/// be implemented by quaternions to convert them to a rotation matrix. /// be implemented by quaternions to convert them to a rotation matrix.
pub trait RotationMatrix<N, LV, AV, M: Mat<N, LV, LV> + Rotation<AV>> : Rotation<AV> { pub trait RotationMatrix<N, LV, AV> : Rotation<AV> {
type Output: Mat<N, LV, LV> + Rotation<AV>;
/// Gets the rotation matrix represented by `self`. /// Gets the rotation matrix represented by `self`.
fn to_rot_mat(&self) -> M; fn to_rot_mat(&self) -> Self::Output;
} }
/// Composition of a rotation and an absolute value. /// Composition of a rotation and an absolute value.
@ -227,9 +229,11 @@ pub trait Norm<N: BaseFloat> {
/** /**
* Trait of elements having a cross product. * Trait of elements having a cross product.
*/ */
pub trait Cross<V> { pub trait Cross {
type Output;
/// Computes the cross product between two elements (usually vectors). /// Computes the cross product between two elements (usually vectors).
fn cross(&self, other: &Self) -> V; fn cross(&self, other: &Self) -> Self::Output;
} }
/** /**

4
src/traits/operations.rs
View File

@ -314,7 +314,7 @@ pub trait RMul<V> {
fn rmul(&self, v: &V) -> V; fn rmul(&self, v: &V) -> V;
} }
impl<M: Copy + Mul<T, T>, T: Copy> RMul<T> for M { impl<M: Copy + Mul<T, Output = T>, T: Copy> RMul<T> for M {
fn rmul(&self, v: &T) -> T { fn rmul(&self, v: &T) -> T {
*self * *v *self * *v
} }
@ -326,7 +326,7 @@ pub trait LMul<V> {
fn lmul(&self, &V) -> V; fn lmul(&self, &V) -> V;
} }
impl<T: Copy + Mul<M, T>, M: Copy> LMul<T> for M { impl<T: Copy + Mul<M, Output = T>, M: Copy> LMul<T> for M {
fn lmul(&self, v: &T) -> T { fn lmul(&self, v: &T) -> T {
*v * *self *v * *self
} }

52
src/traits/structure.rs
View File

@ -9,9 +9,11 @@ use traits::operations::{RMul, LMul, Axpy, Transpose, Inv, Absolute};
use traits::geometry::{Dot, Norm, Orig}; use traits::geometry::{Dot, Norm, Orig};
/// Basic integral numeric trait. /// Basic integral numeric trait.
pub trait BaseNum: Copy + Zero + One + Add<Self, Self> + Sub<Self, Self> + Mul<Self, Self> + pub trait BaseNum: Copy + Zero + One +
Div<Self, Self> + Rem<Self, Self> + Neg<Self> + PartialEq + Absolute<Self> + Add<Self, Output = Self> + Sub<Self, Output = Self> +
Axpy<Self> { Mul<Self, Output = Self> + Div<Self, Output = Self> +
Rem<Self, Output = Self> + Neg<Output = Self> + PartialEq +
Absolute<Self> + Axpy<Self> {
} }
/// Basic floating-point number numeric trait. /// Basic floating-point number numeric trait.
@ -58,19 +60,19 @@ pub trait Cast<T> {
/// Trait of matrices. /// Trait of matrices.
/// ///
/// A matrix has rows and columns and are able to multiply them. /// A matrix has rows and columns and are able to multiply them.
pub trait Mat<N, R, C>: Row<R> + Col<C> + RMul<R> + LMul<C> + Index<(uint, uint), N> { } pub trait Mat<N, R, C>: Row<R> + Col<C> + RMul<R> + LMul<C> + Index<(uint, uint), Output = N> { }
impl<N, M, R, C> Mat<N, R, C> for M impl<N, M, R, C> Mat<N, R, C> for M
where M: Row<R> + Col<C> + RMul<R> + LMul<C> + Index<(uint, uint), N> { where M: Row<R> + Col<C> + RMul<R> + LMul<C> + Index<(uint, uint), Output = N> {
} }
/// Trait implemented by square matrices. /// Trait implemented by square matrices.
pub trait SquareMat<N, V>: Mat<N, V, V> + Mul<Self, Self> + Eye + Transpose + Diag<V> + Inv + Dim + pub trait SquareMat<N, V>: Mat<N, V, V> +
One { Mul<Self, Output = Self> + Eye + Transpose + Diag<V> + Inv + Dim + One {
} }
impl<N, V, M> SquareMat<N, V> for M impl<N, V, M> SquareMat<N, V> for M
where M: Mat<N, V, V> + Mul<M, M> + Eye + Transpose + Diag<V> + Inv + Dim + One { where M: Mat<N, V, V> + Mul<M, Output = M> + Eye + Transpose + Diag<V> + Inv + Dim + One {
} }
/// Trait for constructing the identity matrix /// Trait for constructing the identity matrix
@ -175,7 +177,7 @@ pub trait Diag<V> {
} }
/// The shape of an indexable object. /// The shape of an indexable object.
pub trait Shape<I, Res>: Index<I, Res> { pub trait Shape<I>: Index<I> {
/// Returns the shape of an indexable object. /// Returns the shape of an indexable object.
fn shape(&self) -> I; fn shape(&self) -> I;
} }
@ -185,24 +187,24 @@ pub trait Shape<I, Res>: Index<I, Res> {
/// It exists because the `I` trait cannot be used to express write access. /// It exists because the `I` trait cannot be used to express write access.
/// Thus, this is the same as the `I` trait but without the syntactic sugar and with a method /// Thus, this is the same as the `I` trait but without the syntactic sugar and with a method
/// to write to a specific index. /// to write to a specific index.
pub trait Indexable<I, Res>: Shape<I, Res> + IndexMut<I, Res> { pub trait Indexable<I, N>: Shape<I> + IndexMut<I, Output = N> {
#[deprecated = "use the Index `[]` overloaded operator instead"] #[deprecated = "use the Index `[]` overloaded operator instead"]
/// Reads the `i`-th element of `self`. /// Reads the `i`-th element of `self`.
fn at(&self, i: I) -> Res; fn at(&self, i: I) -> N;
#[deprecated = "use the IndexMut `[]` overloaded operator instead"] #[deprecated = "use the IndexMut `[]` overloaded operator instead"]
/// Writes to the `i`-th element of `self`. /// Writes to the `i`-th element of `self`.
fn set(&mut self, i: I, Res); fn set(&mut self, i: I, N);
/// Swaps the `i`-th element of `self` with its `j`-th element. /// Swaps the `i`-th element of `self` with its `j`-th element.
fn swap(&mut self, i: I, j: I); fn swap(&mut self, i: I, j: I);
/// Reads the `i`-th element of `self`. /// Reads the `i`-th element of `self`.
/// ///
/// `i` is not checked. /// `i` is not checked.
unsafe fn unsafe_at(&self, i: I) -> Res; unsafe fn unsafe_at(&self, i: I) -> N;
/// Writes to the `i`-th element of `self`. /// Writes to the `i`-th element of `self`.
/// ///
/// `i` is not checked. /// `i` is not checked.
unsafe fn unsafe_set(&mut self, i: I, Res); unsafe fn unsafe_set(&mut self, i: I, N);
} }
/// This is a workaround of current Rust limitations. /// This is a workaround of current Rust limitations.
@ -235,8 +237,12 @@ pub trait VecAsPnt<P> {
} }
/// Trait grouping most common operations on vectors. /// Trait grouping most common operations on vectors.
pub trait NumVec<N>: Dim + Sub<Self, Self> + Add<Self, Self> + Neg<Self> + Zero + PartialEq + pub trait NumVec<N>: Dim +
Mul<N, Self> + Div<N, Self> + Dot<N> + Axpy<N> + Index<uint, N> { Sub<Self, Output = Self> + Add<Self, Output = Self> +
Mul<N, Output = Self> + Div<N, Output = Self> +
Neg<Output = Self> +
Index<uint, Output = N> +
Zero + PartialEq + Dot<N> + Axpy<N> {
} }
/// Trait of vector with components implementing the `BaseFloat` trait. /// Trait of vector with components implementing the `BaseFloat` trait.
@ -264,8 +270,18 @@ pub trait PntAsVec<V> {
// XXX: the vector space element `V` should be an associated type. Though this would prevent V from // XXX: the vector space element `V` should be an associated type. Though this would prevent V from
// having bounds (they are not supported yet). So, for now, we will just use a type parameter. // having bounds (they are not supported yet). So, for now, we will just use a type parameter.
pub trait NumPnt<N, V>: pub trait NumPnt<N, V>:
Copy + PntAsVec<V> + Dim + Sub<Self, V> + Orig + Neg<Self> + PartialEq + Mul<N, Self> + Copy +
Div<N, Self> + Add<V, Self> + Axpy<N> + Index<uint, N> { // FIXME: + Sub<V, Self> PntAsVec<V> +
Dim +
Orig +
PartialEq +
Axpy<N> +
Sub<Self, Output = V> +
Neg<Output = Self> +
Mul<N, Output = Self> +
Div<N, Output = Self> +
Add<V, Output = Self> +
Index<uint, Output = N> { // FIXME: + Sub<V, Self>
} }
/// Trait of points with components implementing the `BaseFloat` trait. /// Trait of points with components implementing the `BaseFloat` trait.