srenblad/nalgebra
1
0
Fork 0
forked from M-Labs/nalgebra
Code Pull Requests Activity

Merge pull request #66 from sebcrozet/rustup

Browse Source 
Update to the last rust-nightly.
This commit is contained in:
Sébastien Crozet 2015-01-04 19:08:58 +01:00
commit f48cefe13f
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)]
#![feature(macro_rules)]
#![feature(globs)]
#![feature(default_type_params)]
#![feature(associated_types)]
#![feature(old_orphan_check)]
#![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.
#[inline(always)]
pub fn append_rotation_wrt_point<LV: Neg<LV> + Copy,
pub fn append_rotation_wrt_point<LV: Neg<Output = LV> + Copy,
AV,
M: RotationWithTranslation<LV, AV>>(
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.
#[inline(always)]
pub fn append_rotation_wrt_center<LV: Neg<LV> + Copy,
pub fn append_rotation_wrt_center<LV: Neg<Output = LV> + Copy,
AV,
M: RotationWithTranslation<LV, AV>>(
m: &M,
@ -603,7 +605,7 @@ pub fn append_rotation_wrt_center<LV: Neg<LV> + Copy,
/// Builds a rotation matrix from `r`.
#[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()
}
@ -702,7 +704,7 @@ pub fn det<M: Det<N>, N>(m: &M) -> N {
/// Computes the cross product of two vectors.
#[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)
}
@ -909,7 +911,7 @@ pub fn dim<V: Dim>() -> uint {
/// Gets the indexable range of an object.
#[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()
}

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)
where N: BaseFloat,
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();
assert!(rows >= cols);
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)
where N: BaseFloat,
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 {
let mut eigenvectors: M = ::one::<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]
fn shape(&self) -> (uint, uint) {
(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 {
assert!(i < self.nrows);
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 {
assert!(i < self.nrows);
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> {
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> {
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> {
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]
fn mul(self, right: N) -> DMat<N> {
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]
fn div(self, right: N) -> DMat<N> {
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]
fn add(self, right: N) -> DMat<N> {
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]
fn sub(self, right: N) -> DMat<N> {
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> {
#[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() };
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]
fn shape(&self) -> uint {
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 {
&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 {
&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>) {
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]
fn mul(self, right: $dvec<N>) -> $dvec<N> {
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]
fn div(self, right: $dvec<N>) -> $dvec<N> {
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]
fn add(self, right: $dvec<N>) -> $dvec<N> {
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]
fn sub(self, right: $dvec<N>) -> $dvec<N> {
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]
fn neg(self) -> $dvec<N> {
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]
fn mul(self, right: N) -> $dvec<N> {
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]
fn div(self, right: N) -> $dvec<N> {
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]
fn add(self, right: N) -> $dvec<N> {
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]
fn sub(self, right: N) -> $dvec<N> {
let mut res = self;
@ -477,7 +499,7 @@ macro_rules! small_dvec_from_impl (
impl<N: Zero> FromIterator<N> for $dvec<N> {
#[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 dim = 0;

17
src/structs/iso_macros.rs
View File

@ -27,7 +27,9 @@ macro_rules! iso_impl(
macro_rules! rotation_matrix_impl(
($t: ident, $trot: ident, $tlv: ident, $tav: ident) => (
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]
fn to_rot_mat(&self) -> $trot<N> {
self.rotation
@ -61,7 +63,9 @@ macro_rules! one_impl(
macro_rules! iso_mul_iso_impl(
($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]
fn mul(self, right: $t<N>) -> $t<N> {
$t::new_with_rotmat(
@ -74,7 +78,9 @@ macro_rules! iso_mul_iso_impl(
macro_rules! iso_mul_pnt_impl(
($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]
fn mul(self, right: $tv<N>) -> $tv<N> {
self.rotation * right + self.translation
@ -85,7 +91,8 @@ macro_rules! iso_mul_pnt_impl(
macro_rules! pnt_mul_iso_impl(
($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]
fn mul(self, right: $t<N>) -> $tv<N> {
(self + right.translation) * right.rotation
@ -137,7 +144,7 @@ macro_rules! translation_impl(
macro_rules! translate_impl(
($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]
fn translate(&self, v: &$tv<N>) -> $tv<N> {
*v + self.translation

47
src/structs/mat_macros.rs
View File

@ -88,7 +88,9 @@ macro_rules! mat_cast_impl(
macro_rules! add_impl(
($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]
fn add(self, right: $t<N>) -> $t<N> {
$t::new(self.$comp0 + right.$comp0 $(, self.$compN + right.$compN)*)
@ -99,7 +101,9 @@ macro_rules! add_impl(
macro_rules! sub_impl(
($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]
fn sub(self, right: $t<N>) -> $t<N> {
$t::new(self.$comp0 - right.$comp0 $(, self.$compN - right.$compN)*)
@ -110,7 +114,9 @@ macro_rules! sub_impl(
macro_rules! mat_mul_scalar_impl(
($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]
fn mul(self, right: N) -> $t<N> {
$t::new(self.$comp0 * *right $(, self.$compN * *right)*)
@ -121,7 +127,9 @@ macro_rules! mat_mul_scalar_impl(
macro_rules! mat_div_scalar_impl(
($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]
fn div(self, right: N) -> $t<N> {
$t::new(self.$comp0 / *right $(, self.$compN / *right)*)
@ -132,7 +140,9 @@ macro_rules! mat_div_scalar_impl(
macro_rules! mat_add_scalar_impl(
($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]
fn add(self, right: N) -> $t<N> {
$t::new(self.$comp0 + *right $(, self.$compN + *right)*)
@ -157,7 +167,9 @@ macro_rules! eye_impl(
macro_rules! mat_sub_scalar_impl(
($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]
fn sub(self, right: &N) -> $t<N> {
$t::new(self.$comp0 - *right $(, self.$compN - *right)*)
@ -246,7 +258,7 @@ macro_rules! dim_impl(
macro_rules! indexable_impl(
($t: ident, $dim: expr) => (
impl<N> Shape<(uint, uint), N> for $t<N> {
impl<N> Shape<(uint, uint)> for $t<N> {
#[inline]
fn shape(&self) -> (uint, uint) {
($dim, $dim)
@ -291,7 +303,9 @@ macro_rules! indexable_impl(
macro_rules! index_impl(
($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 {
unsafe {
&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 {
unsafe {
&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(
($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]
fn mul(self, right: $t<N>) -> $t<N> {
// 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(
($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]
fn mul(self, right: $t<N>) -> $v<N> {
let mut res : $v<N> = $zero();
@ -476,7 +495,9 @@ macro_rules! vec_mul_mat_impl(
macro_rules! mat_mul_vec_impl(
($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]
fn mul(self, right: $v<N>) -> $v<N> {
let mut res : $v<N> = $zero();
@ -685,7 +706,7 @@ macro_rules! from_homogeneous_impl(
macro_rules! outer_impl(
($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]
fn outer(&self, other: &$t<N>) -> $m<N> {
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(
($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]
fn sub(self, right: $t<N>) -> $tv<N> {
*self.as_vec() - *right.as_vec()
@ -32,7 +34,9 @@ macro_rules! pnt_sub_impl(
macro_rules! pnt_add_vec_impl(
($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]
fn add(self, right: $tv<N>) -> $t<N> {
$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(
($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]
fn sub(self, right: $tv<N>) -> $t<N> {
$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(
($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> {
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.
#[inline]
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]
fn mul(self, right: Quat<N>) -> Quat<N> {
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]
fn div(self, right: Quat<N>) -> Quat<N> {
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]
fn inv_cpy(&self) -> Option<UnitQuat<N>> {
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]
fn div(self, other: UnitQuat<N>) -> UnitQuat<N> {
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]
fn mul(self, right: UnitQuat<N>) -> UnitQuat<N> {
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]
fn mul(self, right: Vec3<N>) -> Vec3<N> {
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]
fn mul(self, right: Pnt3<N>) -> Pnt3<N> {
::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]
fn mul(self, right: UnitQuat<N>) -> Vec3<N> {
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]
fn mul(self, right: UnitQuat<N>) -> Pnt3<N> {
::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>
}
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.
pub fn new(angle: Vec1<N>) -> Rot2<N> {
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]
fn rand<R: Rng>(rng: &mut R) -> Rot2<N> {
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(
($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]
fn to_rot_mat(&self) -> $t<N> {
self.clone()
@ -102,7 +104,9 @@ macro_rules! one_impl(
macro_rules! rot_mul_rot_impl(
($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]
fn mul(self, right: $t<N>) -> $t<N> {
$t { submat: self.submat * right.submat }
@ -113,7 +117,9 @@ macro_rules! rot_mul_rot_impl(
macro_rules! rot_mul_vec_impl(
($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]
fn mul(self, right: $tv<N>) -> $tv<N> {
self.submat * right
@ -130,7 +136,9 @@ macro_rules! rot_mul_pnt_impl(
macro_rules! vec_mul_rot_impl(
($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]
fn mul(self, right: $t<N>) -> $tv<N> {
self * right.submat
@ -223,7 +231,9 @@ macro_rules! col_impl(
macro_rules! index_impl(
($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 {
&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]
fn mul(self, other: T) -> T {
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]
fn mul(self, right: Mat3<N>) -> Mat3<N> {
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)]
fn mul(self, right: Mat2<N>) -> Mat2<N> {
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)]
fn mul(self, right: Vec3<N>) -> Vec3<N> {
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)]
fn mul(self, right: Mat3<N>) -> Vec3<N> {
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)]
fn mul(self, right: Mat2<N>) -> Vec2<N> {
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)]
fn mul(self, right: Vec2<N>) -> Vec2<N> {
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)]
fn mul(self, right: Pnt3<N>) -> Pnt3<N> {
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)]
fn mul(self, right: Mat3<N>) -> Pnt3<N> {
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)]
fn mul(self, right: Mat2<N>) -> Pnt2<N> {
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)]
fn mul(self, right: Pnt2<N>) -> Pnt2<N> {
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::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]
fn cross(&self, other: &Vec2<N>) -> Vec1<N> {
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?
impl<N: Neg<N> + Copy> CrossMatrix<Vec2<N>> for Vec2<N> {
impl<N: Neg<Output = N> + Copy> CrossMatrix<Vec2<N>> for Vec2<N> {
#[inline]
fn cross_matrix(&self) -> Vec2<N> {
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]
fn cross(&self, other: &Vec3<N>) -> Vec3<N> {
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]
fn cross_matrix(&self) -> Mat3<N> {
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)]
fn canonical_basis(f: |Vec2<N>| -> bool) {
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]
fn index(&self, _: &uint) -> &N {
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]
fn index_mut(&mut self, _: &uint) -> &mut N {
panic!("Canot index a Vec0.")
}
}
impl<N> Shape<uint, N> for vec::Vec0<N> {
impl<N> Shape<uint> for vec::Vec0<N> {
#[inline]
fn shape(&self) -> uint {
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]
fn add(self, _: T) -> vec::Vec0<N> {
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]
fn sub(self, _: T) -> vec::Vec0<N> {
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]
fn neg(self) -> vec::Vec0<N> {
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]
fn mul(self, _: T) -> vec::Vec0<N> {
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]
fn div(self, _: T) -> vec::Vec0<N> {
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]
fn translation(&self) -> vec::Vec0<N> {
*self
@ -229,7 +243,7 @@ impl<N: One> One for vec::Vec0<N> {
impl<N> FromIterator<N> for vec::Vec0<N> {
#[inline]
fn from_iter<I: Iterator<N>>(_: I) -> vec::Vec0<N> {
fn from_iter<I: Iterator<Item = N>>(_: I) -> vec::Vec0<N> {
vec::Vec0
}
}

63
src/structs/vec_macros.rs
View File

@ -192,7 +192,7 @@ macro_rules! vec_cast_impl(
macro_rules! indexable_impl(
($t: ident, $dim: expr) => (
impl<N> Shape<uint, N> for $t<N> {
impl<N> Shape<uint> for $t<N> {
#[inline]
fn shape(&self) -> uint {
$dim
@ -236,13 +236,17 @@ macro_rules! indexable_impl(
macro_rules! index_impl(
($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 {
&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 {
&mut self.as_array_mut()[*i]
}
@ -391,7 +395,9 @@ macro_rules! axpy_impl(
macro_rules! add_impl(
($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]
fn add(self, right: $t<N>) -> $t<N> {
$t::new(self.$comp0 + right.$comp0 $(, self.$compN + right.$compN)*)
@ -403,7 +409,9 @@ macro_rules! add_impl(
macro_rules! scalar_add_impl(
($t: ident, $comp0: ident $(,$compN: ident)*) => (
// $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]
fn add(self, right: N) -> $t<N> {
$t::new(self.$comp0 + right $(, self.$compN + right)*)
@ -414,7 +422,9 @@ macro_rules! scalar_add_impl(
macro_rules! sub_impl(
($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]
fn sub(self, right: $t<N>) -> $t<N> {
$t::new(self.$comp0 - right.$comp0 $(, self.$compN - right.$compN)*)
@ -425,7 +435,9 @@ macro_rules! sub_impl(
macro_rules! scalar_sub_impl(
($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]
fn sub(self, right: N) -> $t<N> {
$t::new(self.$comp0 - right $(, self.$compN - right)*)
@ -436,7 +448,8 @@ macro_rules! scalar_sub_impl(
macro_rules! mul_impl(
($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]
fn mul(self, right: $t<N>) -> $t<N> {
$t::new(self.$comp0 * right.$comp0 $(, self.$compN * right.$compN)*)
@ -447,7 +460,9 @@ macro_rules! mul_impl(
macro_rules! scalar_mul_impl(
($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]
fn mul(self, right: N) -> $t<N> {
$t::new(self.$comp0 * right $(, self.$compN * right)*)
@ -458,7 +473,9 @@ macro_rules! scalar_mul_impl(
macro_rules! div_impl(
($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]
fn div(self, right: $t<N>) -> $t<N> {
$t::new(self.$comp0 / right.$comp0 $(, self.$compN / right.$compN)*)
@ -469,7 +486,9 @@ macro_rules! div_impl(
macro_rules! scalar_div_impl(
($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]
fn div(self, right: N) -> $t<N> {
$t::new(self.$comp0 / right $(, self.$compN / right)*)
@ -480,7 +499,9 @@ macro_rules! scalar_div_impl(
macro_rules! neg_impl(
($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]
fn neg(self) -> $t<N> {
$t::new(-self.$comp0 $(, -self.$compN )*)
@ -502,28 +523,28 @@ macro_rules! dot_impl(
macro_rules! scalar_ops_impl(
($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]
fn mul_s(&self, other: &N) -> $t<N> {
$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]
fn div_s(&self, other: &N) -> $t<N> {
$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]
fn add_s(&self, other: &N) -> $t<N> {
$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]
fn sub_s(&self, other: &N) -> $t<N> {
$t::new(self.$comp0 - *other $(, self.$compN - *other)*)
@ -534,7 +555,7 @@ macro_rules! scalar_ops_impl(
macro_rules! translation_impl(
($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]
fn translation(&self) -> $t<N> {
*self
@ -669,7 +690,7 @@ macro_rules! from_iterator_impl(
($t: ident, $param0: ident $(, $paramN: ident)*) => (
impl<N> FromIterator<N> for $t<N> {
#[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())*)
}
}
@ -715,7 +736,7 @@ macro_rules! vec_to_homogeneous_impl(
macro_rules! vec_from_homogeneous_impl(
($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> {
let mut res: $t<N> = ::zero();
@ -730,7 +751,7 @@ macro_rules! vec_from_homogeneous_impl(
macro_rules! translate_impl(
($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> {
*other + *self
}
@ -758,7 +779,7 @@ macro_rules! rotate_impl(
macro_rules! transform_impl(
($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> {
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`
/// 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.
///
/// # 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
/// 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`.
fn to_rot_mat(&self) -> M;
fn to_rot_mat(&self) -> Self::Output;
}
/// Composition of a rotation and an absolute value.
@ -227,9 +229,11 @@ pub trait Norm<N: BaseFloat> {
/**
* 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).
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;
}
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 {
*self * *v
}
@ -326,7 +326,7 @@ pub trait LMul<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 {
*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};
/// Basic integral numeric trait.
pub trait BaseNum: Copy + Zero + One + Add<Self, Self> + Sub<Self, Self> + Mul<Self, Self> +
Div<Self, Self> + Rem<Self, Self> + Neg<Self> + PartialEq + Absolute<Self> +
Axpy<Self> {
pub trait BaseNum: Copy + Zero + One +
Add<Self, Output = Self> + Sub<Self, Output = 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.
@ -58,19 +60,19 @@ pub trait Cast<T> {
/// Trait of matrices.
///
/// 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
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.
pub trait SquareMat<N, V>: Mat<N, V, V> + Mul<Self, Self> + Eye + Transpose + Diag<V> + Inv + Dim +
One {
pub trait SquareMat<N, V>: Mat<N, V, V> +
Mul<Self, Output = Self> + Eye + Transpose + Diag<V> + Inv + Dim + One {
}
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
@ -175,7 +177,7 @@ pub trait Diag<V> {
}
/// 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.
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.
/// Thus, this is the same as the `I` trait but without the syntactic sugar and with a method
/// 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"]
/// 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"]
/// 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.
fn swap(&mut self, i: I, j: I);
/// Reads the `i`-th element of `self`.
///
/// `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`.
///
/// `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.
@ -235,8 +237,12 @@ pub trait VecAsPnt<P> {
}
/// Trait grouping most common operations on vectors.
pub trait NumVec<N>: Dim + Sub<Self, Self> + Add<Self, Self> + Neg<Self> + Zero + PartialEq +
Mul<N, Self> + Div<N, Self> + Dot<N> + Axpy<N> + Index<uint, N> {
pub trait NumVec<N>: Dim +
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.
@ -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
// having bounds (they are not supported yet). So, for now, we will just use a type parameter.
pub trait NumPnt<N, V>:
Copy + PntAsVec<V> + Dim + Sub<Self, V> + Orig + Neg<Self> + PartialEq + Mul<N, Self> +
Div<N, Self> + Add<V, Self> + Axpy<N> + Index<uint, N> { // FIXME: + Sub<V, Self>
Copy +
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.