hodasemi/cgmath
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge pull request #12 from csherratt/master

Browse source 
update to compile on latest rustc
This commit is contained in:
Brendan Zabarauskas 2013-11-27 15:32:49 -08:00
commit bd6a7812f0
2 changed files with 91 additions and 91 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

168
src/bench/matrix.rs
View file

@ -62,420 +62,420 @@ pub mod mat4 {
#[bench]
fn bench_mat2_mul_m(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat2::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a = mat_a.mul_m(&mat2::B);
}
}
})
}
#[bench]
fn bench_mat3_mul_m(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat3::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a = mat_a.mul_m(&mat3::B);
}
}
})
}
#[bench]
fn bench_mat4_mul_m(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat4::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a = mat_a.mul_m(&mat4::B);
}
}
})
}
#[bench]
fn bench_mat2_add_m(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat2::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a = mat_a.add_m(&mat2::B);
}
}
})
}
#[bench]
fn bench_mat3_add_m(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat3::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a = mat_a.add_m(&mat3::B);
}
}
})
}
#[bench]
fn bench_mat4_add_m(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat4::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a = mat_a.add_m(&mat4::B);
}
}
})
}
#[bench]
fn bench_mat2_sub_m(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat2::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a = mat_a.sub_m(&mat2::B);
}
}
})
}
#[bench]
fn bench_mat3_sub_m(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat3::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a = mat_a.sub_m(&mat3::B);
}
}
})
}
#[bench]
fn bench_mat4_sub_m(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat4::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a = mat_a.sub_m(&mat4::B);
}
}
})
}
#[bench]
fn bench_mat2_mul_s(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat2::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a = mat_a.mul_s(2.0);
}
}
})
}
#[bench]
fn bench_mat3_mul_s(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat3::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a = mat_a.mul_s(2.0);
}
}
})
}
#[bench]
fn bench_mat4_mul_s(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat4::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a = mat_a.mul_s(2.0);
}
}
})
}
#[bench]
fn bench_mat2_div_s(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat2::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a = mat_a.div_s(2.);
}
}
})
}
#[bench]
fn bench_mat3_div_s(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat3::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a = mat_a.div_s(2.);
}
}
})
}
#[bench]
fn bench_mat4_div_s(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat4::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a = mat_a.div_s(2.);
}
}
})
}
#[bench]
fn bench_mat2_rem_s(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat2::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a = mat_a.rem_s(2.);
}
}
})
}
#[bench]
fn bench_mat3_rem_s(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat3::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a = mat_a.rem_s(2.);
}
}
})
}
#[bench]
fn bench_mat4_rem_s(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat4::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a = mat_a.rem_s(2.);
}
}
})
}
#[bench]
fn bench_mat2_neg_self(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat2::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a.neg_self();
}
}
})
}
#[bench]
fn bench_mat3_neg_self(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat3::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a.neg_self();
}
}
})
}
#[bench]
fn bench_mat4_neg_self(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat4::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a.neg_self();
}
}
})
}
#[bench]
fn bench_mat2_div_self_s(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat2::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a.div_self_s(2.);
}
}
})
}
#[bench]
fn bench_mat3_div_self_s(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat3::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a.div_self_s(2.);
}
}
})
}
#[bench]
fn bench_mat4_div_self_s(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat4::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a.div_self_s(2.);
}
}
})
}
#[bench]
fn bench_mat2_rem_self_s(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat2::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a.rem_self_s(2.);
}
}
})
}
#[bench]
fn bench_mat3_rem_self_s(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat3::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a.rem_self_s(2.);
}
}
})
}
#[bench]
fn bench_mat4_rem_self_s(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat4::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a.rem_self_s(2.);
}
}
})
}
#[bench]
fn bench_mat2_mul_self_m(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat2::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a.mul_self_m(&mat2::B);
}
}
})
}
#[bench]
fn bench_mat3_mul_self_m(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat3::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a.mul_self_m(&mat3::B);
}
}
})
}
#[bench]
fn bench_mat4_mul_self_m(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat4::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a.mul_self_m(&mat4::B);
}
}
})
}
#[bench]
fn bench_mat2_add_self_m(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat2::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a.add_self_m(&mat2::B);
}
}
})
}
#[bench]
fn bench_mat3_add_self_m(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat3::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a.add_self_m(&mat3::B);
}
}
})
}
#[bench]
fn bench_mat4_add_self_m(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat4::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a.add_self_m(&mat4::B);
}
}
})
}
#[bench]
fn bench_mat2_sub_self_m(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat2::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a.sub_self_m(&mat2::B);
}
}
})
}
#[bench]
fn bench_mat3_sub_self_m(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat3::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a.sub_self_m(&mat3::B);
}
}
})
}
#[bench]
fn bench_mat4_sub_self_m(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat4::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a.add_self_m(&mat4::B);
}
}
})
}
#[bench]
fn bench_mat2_transpose(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat2::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a = mat_a.transpose();
}
}
})
}
#[bench]
fn bench_mat3_transpose(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat3::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a = mat_a.transpose();
}
}
})
}
#[bench]
fn bench_mat4_transpose(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat4::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a = mat_a.transpose();
}
}
})
}
#[bench]
fn bench_mat2_transpose_self(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat2::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a.transpose_self();
}
}
})
}
#[bench]
fn bench_mat3_transpose_self(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat3::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a.transpose_self();
}
}
})
}
#[bench]
fn bench_mat4_transpose_self(b: &mut extra::test::BenchHarness) {
let mut mat_a = mat4::A.clone();
do b.iter {
b.iter(|| {
for _ in range(0, 1000) {
mat_a.transpose_self();
}
}
})
}

14
src/cgmath/array.rs
View file

@ -28,7 +28,7 @@ pub trait Array
fn as_slice<'a>(&'a self) -> &'a Slice;
fn as_mut_slice<'a>(&'a mut self) -> &'a mut Slice;
fn from_slice(slice: Slice) -> Self;
fn build(builder: &fn(i: uint) -> T) -> Self;
fn build(builder: |i: uint| -> T) -> Self;
fn iter<'a>(&'a self) -> VecIterator<'a, T>;
fn mut_iter<'a>(&'a mut self) -> VecMutIterator<'a, T>;
@ -40,8 +40,8 @@ pub trait Array
*self.mut_i(b) = tmp;
}
fn fold(&self, f: &fn(&T, &T) -> T) -> T;
fn each_mut(&mut self, f: &fn(i: uint, x: &mut T));
fn fold(&self, f: |&T, &T| -> T) -> T;
fn each_mut(&mut self, f: |i: uint, x: &mut T|);
}
macro_rules! array(
@ -73,7 +73,7 @@ macro_rules! array(
}
#[inline]
fn build(builder: &fn(i: uint) -> $T) -> $Self {
fn build(builder: |i: uint| -> $T) -> $Self {
Array::from_slice(gen_builder!($_n))
}
@ -88,12 +88,12 @@ macro_rules! array(
}
#[inline]
fn fold(&self, f: &fn(&$T, &$T) -> $T) -> $T {
fn fold(&self, f: |&$T, &$T| -> $T) -> $T {
gen_fold!($_n)
}
#[inline]
fn each_mut(&mut self, f: &fn(i: uint, x: &mut $T)) {
fn each_mut(&mut self, f: |i: uint, x: &mut $T|) {
gen_each_mut!($_n)
}
}
@ -101,7 +101,7 @@ macro_rules! array(
)
#[inline]
pub fn build<T: Clone, Slice, A: Array<T, Slice>>(builder: &fn(i: uint) -> T) -> A {
pub fn build<T: Clone, Slice, A: Array<T, Slice>>(builder: |i: uint| -> T) -> A {
Array::build(builder)
}