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

Rollup of minor beaking changes. 

Use associated types for the `Outer` trait.
Add a `Repeat` trait for constructing a multidimensional value by repeating an element.
Split the `Diag` trait into `Diag` and `DiagMut`.
Implement `RustEncodable` for `Identity`.
This commit is contained in:
Sébastien Crozet 2015-05-25 14:47:14 +02:00
parent bf4c27ae10
commit ca87f9eb95
15 changed files with 181 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
src/lib.rs
View File

@ -92,7 +92,7 @@ extern crate num;
extern crate quickcheck;
use std::cmp;
use std::ops::{Neg, Mul};
use std::ops::Neg;
use num::{Zero, One};
pub use traits::{
Absolute,
@ -132,6 +132,7 @@ pub use traits::{
POrd,
POrdering,
PntAsVec,
Repeat,
Rotate, Rotation, RotationMatrix, RotationWithTranslation,
Row,
Shape,
@ -576,8 +577,7 @@ pub fn append_rotation_wrt_center<LV: Neg<Output = LV> + Copy,
#[inline(always)]
pub fn to_rot_mat<N, LV, AV, R, M>(r: &R) -> M
where R: RotationMatrix<N, LV, AV, Output = M>,
M: Mat<N, LV, AV> + Rotation<AV> + Col<LV> + Copy,
LV: Mul<M, Output=LV> + Copy,
M: SquareMat<N, LV> + Rotation<AV> + Copy
{
// FIXME: rust-lang/rust#20413
r.to_rot_mat()
@ -678,7 +678,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>(a: &LV, b: &LV) -> LV::Output {
pub fn cross<LV: Cross>(a: &LV, b: &LV) -> LV::CrossProductType {
Cross::cross(a, b)
}
@ -785,7 +785,7 @@ pub fn transpose<M: Transpose>(m: &M) -> M {
/// Computes the outer product of two vectors.
#[inline(always)]
pub fn outer<V: Outer<M>, M>(a: &V, b: &V) -> M {
pub fn outer<V: Outer>(a: &V, b: &V) -> V::OuterProductType {
Outer::outer(a, b)
}
@ -833,6 +833,18 @@ pub fn new_identity<M: Eye>(dim: usize) -> M {
Eye::new_identity(dim)
}
/*
* Repeat
*/
/// Create an object by repeating a value.
///
/// Same as `Identity::new()`.
#[inline(always)]
pub fn repeat<N, T: Repeat<N>>(val: N) -> T {
Repeat::repeat(val)
}
/*
* Basis
*/

26
src/structs/dmat.rs
View File

@ -10,7 +10,7 @@ use rand::{self, Rand};
use num::{Zero, One};
use structs::dvec::DVec;
use traits::operations::{ApproxEq, Inv, Transpose, Mean, Cov};
use traits::structure::{Cast, ColSlice, RowSlice, Diag, Eye, Indexable, Shape, BaseNum};
use traits::structure::{Cast, ColSlice, RowSlice, Diag, DiagMut, Eye, Indexable, Shape, BaseNum};
#[cfg(feature="arbitrary")]
use quickcheck::{Arbitrary, Gen};
@ -555,17 +555,6 @@ impl<N: Copy + Clone + Zero> Diag<DVec<N>> for DMat<N> {
res
}
#[inline]
fn set_diag(&mut self, diag: &DVec<N>) {
let smallest_dim = cmp::min(self.nrows, self.ncols);
assert!(diag.len() == smallest_dim);
for i in 0..smallest_dim {
unsafe { self.unsafe_set((i, i), diag.unsafe_at(i)) }
}
}
#[inline]
fn diag(&self) -> DVec<N> {
let smallest_dim = cmp::min(self.nrows, self.ncols);
@ -580,6 +569,19 @@ impl<N: Copy + Clone + Zero> Diag<DVec<N>> for DMat<N> {
}
}
impl<N: Copy + Clone + Zero> DiagMut<DVec<N>> for DMat<N> {
#[inline]
fn set_diag(&mut self, diag: &DVec<N>) {
let smallest_dim = cmp::min(self.nrows, self.ncols);
assert!(diag.len() == smallest_dim);
for i in 0..smallest_dim {
unsafe { self.unsafe_set((i, i), diag.unsafe_at(i)) }
}
}
}
impl<N: ApproxEq<N>> ApproxEq<N> for DMat<N> {
#[inline]
fn approx_epsilon(_: Option<DMat<N>>) -> N {

33
src/structs/mat.rs
View File

@ -12,8 +12,8 @@ use structs::vec::{Vec1, Vec2, Vec3, Vec4, Vec5, Vec6};
use structs::pnt::{Pnt1, Pnt4, Pnt5, Pnt6};
use structs::dvec::{DVec1, DVec2, DVec3, DVec4, DVec5, DVec6};
use traits::structure::{Cast, Row, Col, Iterable, IterableMut, Dim, Indexable,
Eye, ColSlice, RowSlice, Diag, Shape, BaseFloat, BaseNum};
use traits::structure::{Cast, Row, Col, Iterable, IterableMut, Dim, Indexable, Eye, ColSlice,
RowSlice, Diag, DiagMut, Shape, BaseFloat, BaseNum, Repeat};
use traits::operations::{Absolute, Transpose, Inv, Outer, EigenQR};
use traits::geometry::{ToHomogeneous, FromHomogeneous, Orig};
use linalg;
@ -23,7 +23,7 @@ use quickcheck::{Arbitrary, Gen};
/// Special identity matrix. All its operation are no-ops.
#[repr(C)]
#[derive(Eq, PartialEq, RustcDecodable, Clone, Debug, Copy)]
#[derive(Eq, PartialEq, RustcEncodable, RustcDecodable, Clone, Debug, Copy)]
pub struct Identity;
impl Identity {
@ -44,6 +44,7 @@ pub struct Mat1<N> {
eye_impl!(Mat1, 1, m11);
mat_impl!(Mat1, m11);
repeat_impl!(Mat1, m11);
as_array_impl!(Mat1, 1);
mat_cast_impl!(Mat1, m11);
add_impl!(Mat1, m11);
@ -93,6 +94,8 @@ eye_impl!(Mat2, 2, m11, m22);
mat_impl!(Mat2, m11, m12,
m21, m22);
repeat_impl!(Mat2, m11, m12,
m21, m22);
as_array_impl!(Mat2, 2);
mat_cast_impl!(Mat2, m11, m12,
m21, m22);
@ -146,6 +149,9 @@ eye_impl!(Mat3, 3, m11, m22, m33);
mat_impl!(Mat3, m11, m12, m13,
m21, m22, m23,
m31, m32, m33);
repeat_impl!(Mat3, m11, m12, m13,
m21, m22, m23,
m31, m32, m33);
as_array_impl!(Mat3, 3);
mat_cast_impl!(Mat3, m11, m12, m13,
m21, m22, m23,
@ -243,6 +249,12 @@ mat_impl!(Mat4,
m31, m32, m33, m34,
m41, m42, m43, m44
);
repeat_impl!(Mat4,
m11, m12, m13, m14,
m21, m22, m23, m24,
m31, m32, m33, m34,
m41, m42, m43, m44
);
as_array_impl!(Mat4, 4);
mat_cast_impl!(Mat4,
m11, m12, m13, m14,
@ -358,6 +370,13 @@ mat_impl!(Mat5,
m41, m42, m43, m44, m45,
m51, m52, m53, m54, m55
);
repeat_impl!(Mat5,
m11, m12, m13, m14, m15,
m21, m22, m23, m24, m25,
m31, m32, m33, m34, m35,
m41, m42, m43, m44, m45,
m51, m52, m53, m54, m55
);
as_array_impl!(Mat5, 5);
mat_cast_impl!(Mat5,
m11, m12, m13, m14, m15,
@ -489,6 +508,14 @@ mat_impl!(Mat6,
m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66
);
repeat_impl!(Mat6,
m11, m12, m13, m14, m15, m16,
m21, m22, m23, m24, m25, m26,
m31, m32, m33, m34, m35, m36,
m41, m42, m43, m44, m45, m46,
m51, m52, m53, m54, m55, m56,
m61, m62, m63, m64, m65, m66
);
as_array_impl!(Mat6, 6);
mat_cast_impl!(Mat6,
m11, m12, m13, m14, m15, m16,

32
src/structs/mat_macros.rs
View File

@ -164,6 +164,18 @@ macro_rules! eye_impl(
)
);
macro_rules! repeat_impl(
($t: ident, $($compN: ident),+) => (
impl<N: Copy> Repeat<N> for $t<N> {
fn repeat(val: N) -> $t<N> {
$t {
$($compN: val ),+
}
}
}
)
);
macro_rules! mat_sub_scalar_impl(
($t: ident, $($compN: ident),+) => (
impl<N: Sub<N, Output = N> Sub<N> for $t<N> {
@ -401,13 +413,6 @@ macro_rules! diag_impl(
res
}
#[inline]
fn set_diag(&mut self, diag: &$tv<N>) {
for i in 0..$dim {
unsafe { self.unsafe_set((i, i), diag.unsafe_at(i)) }
}
}
#[inline]
fn diag(&self) -> $tv<N> {
let mut diag: $tv<N> = ::zero();
@ -419,6 +424,15 @@ macro_rules! diag_impl(
diag
}
}
impl<N: Copy + Zero> DiagMut<$tv<N>> for $t<N> {
#[inline]
fn set_diag(&mut self, diag: &$tv<N>) {
for i in 0..$dim {
unsafe { self.unsafe_set((i, i), diag.unsafe_at(i)) }
}
}
}
)
);
@ -688,7 +702,9 @@ macro_rules! from_homogeneous_impl(
macro_rules! outer_impl(
($t: ident, $m: ident) => (
impl<N: Copy + Mul<N, Output = N> + Zero> Outer<$m<N>> for $t<N> {
impl<N: Copy + Mul<N, Output = N> + Zero> Outer for $t<N> {
type OuterProductType = $m<N>;
#[inline]
fn outer(&self, other: &$t<N>) -> $m<N> {
let mut res: $m<N> = ::zero();

19
src/structs/pnt.rs
View File

@ -11,7 +11,7 @@ use rand::{Rand, Rng};
use num::{Zero, One};
use traits::operations::{ApproxEq, POrd, POrdering, Axpy};
use traits::structure::{Cast, Dim, Indexable, Iterable, IterableMut, PntAsVec, Shape,
NumPnt, FloatPnt, BaseFloat, BaseNum, Bounded};
NumPnt, FloatPnt, BaseFloat, BaseNum, Bounded, Repeat};
use traits::geometry::{Orig, FromHomogeneous, ToHomogeneous};
use structs::vec::{Vec1, Vec2, Vec3, Vec4, Vec5, Vec6};
#[cfg(feature="arbitrary")]
@ -29,10 +29,11 @@ impl<N> Pnt0<N> {
pub fn new() -> Pnt0<N> {
Pnt0(PhantomData)
}
}
/// Creates a new point. The parameter is not taken in account.
impl<N> Repeat<N> for Pnt0<N> {
#[inline]
pub fn new_repeat(_: N) -> Pnt0<N> {
fn repeat(_: N) -> Pnt0<N> {
Pnt0(PhantomData)
}
}
@ -57,7 +58,7 @@ as_array_impl!(Pnt1, 1);
index_impl!(Pnt1);
indexable_impl!(Pnt1, 1);
at_fast_impl!(Pnt1, 1);
new_repeat_impl!(Pnt1, val, x);
repeat_impl!(Pnt1, val, x);
dim_impl!(Pnt1, 1);
container_impl!(Pnt1);
pnt_as_vec_impl!(Pnt1, Vec1, x);
@ -99,7 +100,7 @@ as_array_impl!(Pnt2, 2);
index_impl!(Pnt2);
indexable_impl!(Pnt2, 2);
at_fast_impl!(Pnt2, 2);
new_repeat_impl!(Pnt2, val, x, y);
repeat_impl!(Pnt2, val, x, y);
dim_impl!(Pnt2, 2);
container_impl!(Pnt2);
pnt_as_vec_impl!(Pnt2, Vec2, x, y);
@ -143,7 +144,7 @@ as_array_impl!(Pnt3, 3);
index_impl!(Pnt3);
indexable_impl!(Pnt3, 3);
at_fast_impl!(Pnt3, 3);
new_repeat_impl!(Pnt3, val, x, y, z);
repeat_impl!(Pnt3, val, x, y, z);
dim_impl!(Pnt3, 3);
container_impl!(Pnt3);
pnt_as_vec_impl!(Pnt3, Vec3, x, y, z);
@ -189,7 +190,7 @@ as_array_impl!(Pnt4, 4);
index_impl!(Pnt4);
indexable_impl!(Pnt4, 4);
at_fast_impl!(Pnt4, 4);
new_repeat_impl!(Pnt4, val, x, y, z, w);
repeat_impl!(Pnt4, val, x, y, z, w);
dim_impl!(Pnt4, 4);
container_impl!(Pnt4);
pnt_as_vec_impl!(Pnt4, Vec4, x, y, z, w);
@ -237,7 +238,7 @@ as_array_impl!(Pnt5, 5);
index_impl!(Pnt5);
indexable_impl!(Pnt5, 5);
at_fast_impl!(Pnt5, 5);
new_repeat_impl!(Pnt5, val, x, y, z, w, a);
repeat_impl!(Pnt5, val, x, y, z, w, a);
dim_impl!(Pnt5, 5);
container_impl!(Pnt5);
pnt_as_vec_impl!(Pnt5, Vec5, x, y, z, w, a);
@ -287,7 +288,7 @@ as_array_impl!(Pnt6, 6);
index_impl!(Pnt6);
indexable_impl!(Pnt6, 6);
at_fast_impl!(Pnt6, 6);
new_repeat_impl!(Pnt6, val, x, y, z, w, a, b);
repeat_impl!(Pnt6, val, x, y, z, w, a, b);
dim_impl!(Pnt6, 6);
container_impl!(Pnt6);
pnt_as_vec_impl!(Pnt6, Vec6, x, y, z, w, a, b);

4
src/structs/quat.rs
View File

@ -11,7 +11,7 @@ use num::{Zero, One};
use structs::{Vec3, Pnt3, Rot3, Mat3};
use traits::operations::{ApproxEq, Inv, POrd, POrdering, Axpy};
use traits::structure::{Cast, Indexable, Iterable, IterableMut, Dim, Shape, BaseFloat, BaseNum,
Bounded};
Bounded, Repeat};
use traits::geometry::{Norm, Rotation, Rotate, Transform};
#[cfg(feature="arbitrary")]
@ -495,7 +495,7 @@ as_array_impl!(Quat, 4);
index_impl!(Quat);
indexable_impl!(Quat, 4);
at_fast_impl!(Quat, 4);
new_repeat_impl!(Quat, val, w, i, j, k);
repeat_impl!(Quat, val, w, i, j, k);
dim_impl!(Quat, 3);
container_impl!(Quat);
add_impl!(Quat, w, i, j, k);

8
src/structs/rot.rs
View File

@ -7,7 +7,7 @@ use rand::{Rand, Rng};
use num::{Zero, One};
use traits::geometry::{Rotate, Rotation, AbsoluteRotate, RotationMatrix, Transform, ToHomogeneous,
Norm, Cross};
use traits::structure::{Cast, Dim, Row, Col, BaseFloat, BaseNum, };
use traits::structure::{Cast, Dim, Row, Col, BaseFloat, BaseNum, Eye, Diag};
use traits::operations::{Absolute, Inv, Transpose, ApproxEq};
use structs::vec::{Vec1, Vec2, Vec3, Vec4};
use structs::pnt::{Pnt2, Pnt3, Pnt4};
@ -408,6 +408,7 @@ vec_mul_rot_impl!(Rot2, Vec2);
rot_mul_pnt_impl!(Rot2, Pnt2);
pnt_mul_rot_impl!(Rot2, Pnt2);
one_impl!(Rot2);
eye_impl!(Rot2);
rotation_matrix_impl!(Rot2, Vec2, Vec1);
col_impl!(Rot2, Vec2);
row_impl!(Rot2, Vec2);
@ -417,6 +418,7 @@ to_homogeneous_impl!(Rot2, Mat3);
inv_impl!(Rot2);
transpose_impl!(Rot2);
approx_eq_impl!(Rot2);
diag_impl!(Rot2, Vec2);
submat_impl!(Rot3, Mat3);
rotate_impl!(Rot3, Vec3, Pnt3);
@ -428,6 +430,7 @@ vec_mul_rot_impl!(Rot3, Vec3);
rot_mul_pnt_impl!(Rot3, Pnt3);
pnt_mul_rot_impl!(Rot3, Pnt3);
one_impl!(Rot3);
eye_impl!(Rot3);
rotation_matrix_impl!(Rot3, Vec3, Vec3);
col_impl!(Rot3, Vec3);
row_impl!(Rot3, Vec3);
@ -437,6 +440,7 @@ to_homogeneous_impl!(Rot3, Mat4);
inv_impl!(Rot3);
transpose_impl!(Rot3);
approx_eq_impl!(Rot3);
diag_impl!(Rot3, Vec3);
submat_impl!(Rot4, Mat4);
rotate_impl!(Rot4, Vec4, Pnt4);
@ -448,6 +452,7 @@ vec_mul_rot_impl!(Rot4, Vec4);
rot_mul_pnt_impl!(Rot4, Pnt4);
pnt_mul_rot_impl!(Rot4, Pnt4);
one_impl!(Rot4);
eye_impl!(Rot4);
rotation_matrix_impl!(Rot4, Vec4, Vec4);
col_impl!(Rot4, Vec4);
row_impl!(Rot4, Vec4);
@ -457,3 +462,4 @@ to_homogeneous_impl!(Rot4, Mat5);
inv_impl!(Rot4);
transpose_impl!(Rot4);
approx_eq_impl!(Rot4);
diag_impl!(Rot4, Vec4);

32
src/structs/rot_macros.rs
View File

@ -102,6 +102,38 @@ macro_rules! one_impl(
)
);
macro_rules! eye_impl(
($t: ident) => (
impl<N: BaseNum> Eye for $t<N> {
#[inline]
fn new_identity(dim: usize) -> $t<N> {
if dim != ::dim::<$t<N>>() {
panic!("Dimension mismatch: should be {}, got {}.", ::dim::<$t<N>>(), dim);
}
else {
::one()
}
}
}
)
);
macro_rules! diag_impl(
($t: ident, $tv: ident) => (
impl<N: Copy + Zero> Diag<$tv<N>> for $t<N> {
#[inline]
fn from_diag(diag: &$tv<N>) -> $t<N> {
$t { submat: Diag::from_diag(diag) }
}
#[inline]
fn diag(&self) -> $tv<N> {
self.submat.diag()
}
}
)
);
macro_rules! rot_mul_rot_impl(
($t: ident) => (
impl<N: BaseNum> Mul<$t<N>> for $t<N> {

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

@ -6,7 +6,7 @@ use structs::vec::{Vec1, Vec2, Vec3, Vec4};
use structs::mat::Mat3;
impl<N: Copy + Mul<N, Output = N> + Sub<N, Output = N>> Cross for Vec2<N> {
type Output = Vec1<N>;
type CrossProductType = Vec1<N>;
#[inline]
fn cross(&self, other: &Vec2<N>) -> Vec1<N> {
@ -23,7 +23,7 @@ impl<N: Neg<Output = N> + Copy> CrossMatrix<Vec2<N>> for Vec2<N> {
}
impl<N: Copy + Mul<N, Output = N> + Sub<N, Output = N>> Cross for Vec3<N> {
type Output = Vec3<N>;
type CrossProductType = Vec3<N>;
#[inline]
fn cross(&self, other: &Vec3<N>) -> Vec3<N> {

19
src/structs/vec.rs
View File

@ -13,7 +13,7 @@ use traits::operations::{ApproxEq, POrd, POrdering, Axpy, Absolute};
use traits::geometry::{Transform, Rotate, FromHomogeneous, ToHomogeneous, Dot, Norm,
Translation, Translate};
use traits::structure::{Basis, Cast, Dim, Indexable, Iterable, IterableMut, Shape, NumVec,
FloatVec, BaseFloat, BaseNum, Bounded};
FloatVec, BaseFloat, BaseNum, Bounded, Repeat};
use structs::pnt::{Pnt1, Pnt2, Pnt3, Pnt4, Pnt5, Pnt6};
#[cfg(feature="arbitrary")]
@ -31,10 +31,11 @@ impl<N> Vec0<N> {
pub fn new() -> Vec0<N> {
Vec0(PhantomData)
}
}
/// Creates a new vector. The parameter is not taken in account.
impl<N> Repeat<N> for Vec0<N> {
#[inline]
pub fn new_repeat(_: N) -> Vec0<N> {
fn repeat(_: N) -> Vec0<N> {
Vec0(PhantomData)
}
}
@ -55,7 +56,7 @@ as_array_impl!(Vec1, 1);
index_impl!(Vec1);
indexable_impl!(Vec1, 1);
at_fast_impl!(Vec1, 1);
new_repeat_impl!(Vec1, val, x);
repeat_impl!(Vec1, val, x);
dim_impl!(Vec1, 1);
container_impl!(Vec1);
// (specialized); basis_impl!(Vec1, 1);
@ -108,7 +109,7 @@ as_array_impl!(Vec2, 2);
index_impl!(Vec2);
indexable_impl!(Vec2, 2);
at_fast_impl!(Vec2, 2);
new_repeat_impl!(Vec2, val, x, y);
repeat_impl!(Vec2, val, x, y);
dim_impl!(Vec2, 2);
container_impl!(Vec2);
// (specialized); basis_impl!(Vec2, 1);
@ -163,7 +164,7 @@ as_array_impl!(Vec3, 3);
index_impl!(Vec3);
indexable_impl!(Vec3, 3);
at_fast_impl!(Vec3, 3);
new_repeat_impl!(Vec3, val, x, y, z);
repeat_impl!(Vec3, val, x, y, z);
dim_impl!(Vec3, 3);
container_impl!(Vec3);
// (specialized); basis_impl!(Vec3, 1);
@ -221,7 +222,7 @@ as_array_impl!(Vec4, 4);
index_impl!(Vec4);
indexable_impl!(Vec4, 4);
at_fast_impl!(Vec4, 4);
new_repeat_impl!(Vec4, val, x, y, z, w);
repeat_impl!(Vec4, val, x, y, z, w);
dim_impl!(Vec4, 4);
container_impl!(Vec4);
basis_impl!(Vec4, 4);
@ -280,7 +281,7 @@ as_array_impl!(Vec5, 5);
index_impl!(Vec5);
indexable_impl!(Vec5, 5);
at_fast_impl!(Vec5, 5);
new_repeat_impl!(Vec5, val, x, y, z, w, a);
repeat_impl!(Vec5, val, x, y, z, w, a);
dim_impl!(Vec5, 5);
container_impl!(Vec5);
basis_impl!(Vec5, 5);
@ -341,7 +342,7 @@ as_array_impl!(Vec6, 6);
index_impl!(Vec6);
indexable_impl!(Vec6, 6);
at_fast_impl!(Vec6, 6);
new_repeat_impl!(Vec6, val, x, y, z, w, a, b);
repeat_impl!(Vec6, val, x, y, z, w, a, b);
dim_impl!(Vec6, 6);
container_impl!(Vec6);
basis_impl!(Vec6, 6);

6
src/structs/vec_macros.rs
View File

@ -227,12 +227,12 @@ macro_rules! index_impl(
)
);
macro_rules! new_repeat_impl(
macro_rules! repeat_impl(
($t: ident, $param: ident, $($compN: ident),+) => (
impl<N: Copy> $t<N> {
impl<N: Copy> Repeat<N> for $t<N> {
/// Creates a new vector with all its components equal to a given value.
#[inline]
pub fn new_repeat($param: N) -> $t<N> {
fn repeat($param: N) -> $t<N> {
$t{
$($compN: $param ),+
}

8
src/traits/geometry.rs
View File

@ -1,7 +1,7 @@
//! Traits of operations having a well-known or explicit geometric meaning.
use std::ops::Neg;
use traits::structure::{BaseFloat, Mat};
use traits::structure::{BaseFloat, SquareMat};
/// Trait of object which represent a translation, and to wich new translation
/// can be appended.
@ -143,7 +143,7 @@ impl<LV: Neg<Output = LV> + Copy, AV, M: Rotation<AV> + Translation<LV>> Rotatio
/// be implemented by quaternions to convert them to a rotation matrix.
pub trait RotationMatrix<N, LV, AV> : Rotation<AV> {
/// The output rotation matrix type.
type Output: Mat<N, LV, LV> + Rotation<AV>;
type Output: SquareMat<N, LV> + Rotation<AV>;
/// Gets the rotation matrix represented by `self`.
fn to_rot_mat(&self) -> Self::Output;
@ -232,10 +232,10 @@ pub trait Norm<N: BaseFloat> {
*/
pub trait Cross {
/// The cross product output.
type Output;
type CrossProductType;
/// Computes the cross product between two elements (usually vectors).
fn cross(&self, other: &Self) -> Self::Output;
fn cross(&self, other: &Self) -> Self::CrossProductType;
}
/**

3
src/traits/mod.rs
View File

@ -6,7 +6,8 @@ pub use traits::geometry::{AbsoluteRotate, Cross, CrossMatrix, Dot, FromHomogene
pub use traits::structure::{FloatVec, FloatPnt, Basis, Cast, Col, Dim, Indexable, Iterable,
IterableMut, Mat, SquareMat, Row, NumVec, NumPnt, PntAsVec, ColSlice,
RowSlice, Diag, Eye, Shape, BaseFloat, BaseNum, Bounded};
RowSlice, Diag, DiagMut, Eye, Repeat, Shape, BaseFloat, BaseNum,
Bounded};
pub use traits::operations::{Absolute, ApproxEq, Axpy, Cov, Det, Inv, Mean, Outer, POrd, Transpose,
EigenQR};

7
src/traits/operations.rs
View File

@ -299,9 +299,12 @@ pub trait Transpose {
}
/// Traits of objects having an outer product.
pub trait Outer<M> {
pub trait Outer {
/// Result type of the outer product.
type OuterProductType;
/// Computes the outer product: `a * b`
fn outer(&self, other: &Self) -> M;
fn outer(&self, other: &Self) -> Self::OuterProductType;
}
/// Trait for computing the covariance of a set of data.

23
src/traits/structure.rs
View File

@ -59,11 +59,13 @@ 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: Mul<Self>>: Row<R> + Col<C> + Mul<R> + Index<(usize, usize), Output = N> { }
pub trait Mat<N, R, C: Mul<Self, Output = R>>: Row<R> + Col<C> + Mul<R, Output = C> +
Index<(usize, usize), Output = N>
{ }
impl<N, M, R, C> Mat<N, R, C> for M
where M: Row<R> + Col<C> + Mul<R> + Index<(usize, usize), Output = N>,
C: Mul<M>,
where M: Row<R> + Col<C> + Mul<R, Output = C> + Index<(usize, usize), Output = N>,
C: Mul<M, Output = R>,
{ }
/// Trait implemented by square matrices.
@ -81,6 +83,12 @@ pub trait Eye {
fn new_identity(dim: usize) -> Self;
}
/// Trait for constructiong an object repeating a value.
pub trait Repeat<N> {
/// Returns a value with filled by `val`.
fn repeat(val: N) -> Self;
}
/// Types that have maximum and minimum value.
pub trait Bounded {
/// The minimum value.
@ -155,13 +163,16 @@ pub trait Diag<V> {
/// Creates a new matrix with the given diagonal.
fn from_diag(diag: &V) -> Self;
/// Sets the diagonal of this matrix.
fn set_diag(&mut self, diag: &V);
/// The diagonal of this matrix.
fn diag(&self) -> V;
}
/// Trait to set the diagonal of square matrices.
pub trait DiagMut<V>: Diag<V> {
/// Sets the diagonal of this matrix.
fn set_diag(&mut self, diag: &V);
}
/// The shape of an indexable object.
pub trait Shape<I>: Index<I> {
/// Returns the shape of an indexable object.