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

Merge pull request #63 from aepsil0n/rust-nightly

Browse Source 
Update to latest Rust
This commit is contained in:
Sébastien Crozet 2015-01-03 20:12:20 +01:00
commit cc2a9c29c5
6 changed files with 43 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/structs/dvec.rs
View File

@ -82,7 +82,7 @@ dvec_impl!(DVec);
/// Stack-allocated, dynamically sized vector with a maximum size of 1. /// Stack-allocated, dynamically sized vector with a maximum size of 1.
pub struct DVec1<N> { pub struct DVec1<N> {
at: [N, ..1], at: [N; 1],
dim: uint dim: uint
} }
@ -92,7 +92,7 @@ small_dvec_from_impl!(DVec1, 1, ::zero());
/// Stack-allocated, dynamically sized vector with a maximum size of 2. /// Stack-allocated, dynamically sized vector with a maximum size of 2.
pub struct DVec2<N> { pub struct DVec2<N> {
at: [N, ..2], at: [N; 2],
dim: uint dim: uint
} }
@ -102,7 +102,7 @@ small_dvec_from_impl!(DVec2, 2, ::zero(), ::zero());
/// Stack-allocated, dynamically sized vector with a maximum size of 3. /// Stack-allocated, dynamically sized vector with a maximum size of 3.
pub struct DVec3<N> { pub struct DVec3<N> {
at: [N, ..3], at: [N; 3],
dim: uint dim: uint
} }
@ -112,7 +112,7 @@ small_dvec_from_impl!(DVec3, 3, ::zero(), ::zero(), ::zero());
/// Stack-allocated, dynamically sized vector with a maximum size of 4. /// Stack-allocated, dynamically sized vector with a maximum size of 4.
pub struct DVec4<N> { pub struct DVec4<N> {
at: [N, ..4], at: [N; 4],
dim: uint dim: uint
} }
@ -122,7 +122,7 @@ small_dvec_from_impl!(DVec4, 4, ::zero(), ::zero(), ::zero(), ::zero());
/// Stack-allocated, dynamically sized vector with a maximum size of 5. /// Stack-allocated, dynamically sized vector with a maximum size of 5.
pub struct DVec5<N> { pub struct DVec5<N> {
at: [N, ..5], at: [N; 5],
dim: uint dim: uint
} }
@ -132,7 +132,7 @@ small_dvec_from_impl!(DVec5, 5, ::zero(), ::zero(), ::zero(), ::zero(), ::zero()
/// Stack-allocated, dynamically sized vector with a maximum size of 6. /// Stack-allocated, dynamically sized vector with a maximum size of 6.
pub struct DVec6<N> { pub struct DVec6<N> {
at: [N, ..6], at: [N; 6],
dim: uint dim: uint
} }

10
src/structs/dvec_macros.rs
View File

@ -389,7 +389,7 @@ macro_rules! small_dvec_impl (
impl<N: Clone> Clone for $dvec<N> { impl<N: Clone> Clone for $dvec<N> {
fn clone(&self) -> $dvec<N> { fn clone(&self) -> $dvec<N> {
let at: [N, ..$dim] = [ $( self.at[$idx].clone(), )* ]; let at: [N; $dim] = [ $( self.at[$idx].clone(), )* ];
$dvec { $dvec {
at: at, at: at,
@ -410,7 +410,7 @@ macro_rules! small_dvec_from_impl (
pub fn from_elem(dim: uint, elem: N) -> $dvec<N> { pub fn from_elem(dim: uint, elem: N) -> $dvec<N> {
assert!(dim <= $dim); assert!(dim <= $dim);
let mut at: [N, ..$dim] = [ $( $zeros, )* ]; let mut at: [N; $dim] = [ $( $zeros, )* ];
for n in at.slice_to_mut(dim).iter_mut() { for n in at.slice_to_mut(dim).iter_mut() {
*n = elem; *n = elem;
@ -432,7 +432,7 @@ macro_rules! small_dvec_from_impl (
assert!(dim <= vec.len() && dim <= $dim); assert!(dim <= vec.len() && dim <= $dim);
// FIXME: not safe. // FIXME: not safe.
let mut at: [N, ..$dim] = [ $( $zeros, )* ]; let mut at: [N; $dim] = [ $( $zeros, )* ];
for (curr, other) in vec.iter().zip(at.iter_mut()) { for (curr, other) in vec.iter().zip(at.iter_mut()) {
*other = *curr; *other = *curr;
@ -451,7 +451,7 @@ macro_rules! small_dvec_from_impl (
pub fn from_fn(dim: uint, f: |uint| -> N) -> $dvec<N> { pub fn from_fn(dim: uint, f: |uint| -> N) -> $dvec<N> {
assert!(dim <= $dim); assert!(dim <= $dim);
let mut at: [N, ..$dim] = [ $( $zeros, )* ]; let mut at: [N; $dim] = [ $( $zeros, )* ];
for i in range(0, dim) { for i in range(0, dim) {
at[i] = f(i); at[i] = f(i);
@ -467,7 +467,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<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;

32
src/structs/mat_macros.rs
View File

@ -19,7 +19,7 @@ macro_rules! as_array_impl(
impl<N> $t<N> { impl<N> $t<N> {
/// View this matrix as a column-major array of arrays. /// View this matrix as a column-major array of arrays.
#[inline] #[inline]
pub fn as_array(&self) -> &[[N, ..$dim], ..$dim] { pub fn as_array(&self) -> &[[N; $dim]; $dim] {
unsafe { unsafe {
mem::transmute(self) mem::transmute(self)
} }
@ -27,7 +27,7 @@ macro_rules! as_array_impl(
/// View this matrix as a column-major mutable array of arrays. /// View this matrix as a column-major mutable array of arrays.
#[inline] #[inline]
pub fn as_array_mut<'a>(&'a mut self) -> &'a mut [[N, ..$dim], ..$dim] { pub fn as_array_mut<'a>(&'a mut self) -> &'a mut [[N; $dim]; $dim] {
unsafe { unsafe {
mem::transmute(self) mem::transmute(self)
} }
@ -36,11 +36,11 @@ macro_rules! as_array_impl(
// FIXME: because of https://github.com/rust-lang/rust/issues/16418 we cannot do the // FIXME: because of https://github.com/rust-lang/rust/issues/16418 we cannot do the
// array-to-mat conversion by-value: // array-to-mat conversion by-value:
// //
// pub fn from_array(array: [N, ..$dim]) -> $t<N> // pub fn from_array(array: [N; $dim]) -> $t<N>
/// View a column-major array of array as a vector. /// View a column-major array of array as a vector.
#[inline] #[inline]
pub fn from_array_ref(array: &[[N, ..$dim], ..$dim]) -> &$t<N> { pub fn from_array_ref(array: &[[N; $dim]; $dim]) -> &$t<N> {
unsafe { unsafe {
mem::transmute(array) mem::transmute(array)
} }
@ -48,7 +48,7 @@ macro_rules! as_array_impl(
/// View a column-major array of array as a mutable vector. /// View a column-major array of array as a mutable vector.
#[inline] #[inline]
pub fn from_array_mut(array: &mut [[N, ..$dim], ..$dim]) -> &mut $t<N> { pub fn from_array_mut(array: &mut [[N; $dim]; $dim]) -> &mut $t<N> {
unsafe { unsafe {
mem::transmute(array) mem::transmute(array)
} }
@ -62,13 +62,13 @@ macro_rules! at_fast_impl(
impl<N: Copy> $t<N> { impl<N: Copy> $t<N> {
#[inline] #[inline]
pub unsafe fn at_fast(&self, (i, j): (uint, uint)) -> N { pub unsafe fn at_fast(&self, (i, j): (uint, uint)) -> N {
(*mem::transmute::<&$t<N>, &[N, ..$dim * $dim]>(self) (*mem::transmute::<&$t<N>, &[N; $dim * $dim]>(self)
.unsafe_get(i + j * $dim)) .unsafe_get(i + j * $dim))
} }
#[inline] #[inline]
pub unsafe fn set_fast(&mut self, (i, j): (uint, uint), val: N) { pub unsafe fn set_fast(&mut self, (i, j): (uint, uint), val: N) {
(*mem::transmute::<&mut $t<N>, &mut [N, ..$dim * $dim]>(self) (*mem::transmute::<&mut $t<N>, &mut [N; $dim * $dim]>(self)
.get_unchecked_mut(i + j * $dim)) = val .get_unchecked_mut(i + j * $dim)) = val
} }
} }
@ -183,7 +183,7 @@ macro_rules! iterable_impl(
#[inline] #[inline]
fn iter<'l>(&'l self) -> Iter<'l, N> { fn iter<'l>(&'l self) -> Iter<'l, N> {
unsafe { unsafe {
mem::transmute::<&'l $t<N>, &'l [N, ..$dim * $dim]>(self).iter() mem::transmute::<&'l $t<N>, &'l [N; $dim * $dim]>(self).iter()
} }
} }
} }
@ -196,7 +196,7 @@ macro_rules! iterable_mut_impl(
#[inline] #[inline]
fn iter_mut<'l>(&'l mut self) -> IterMut<'l, N> { fn iter_mut<'l>(&'l mut self) -> IterMut<'l, N> {
unsafe { unsafe {
mem::transmute::<&'l mut $t<N>, &'l mut [N, ..$dim * $dim]>(self).iter_mut() mem::transmute::<&'l mut $t<N>, &'l mut [N; $dim * $dim]>(self).iter_mut()
} }
} }
} }
@ -257,33 +257,33 @@ macro_rules! indexable_impl(
#[inline] #[inline]
fn at(&self, (i, j): (uint, uint)) -> N { fn at(&self, (i, j): (uint, uint)) -> N {
unsafe { unsafe {
mem::transmute::<&$t<N>, &[N, ..$dim * $dim]>(self)[i + j * $dim] mem::transmute::<&$t<N>, &[N; $dim * $dim]>(self)[i + j * $dim]
} }
} }
#[inline] #[inline]
fn set(&mut self, (i, j): (uint, uint), val: N) { fn set(&mut self, (i, j): (uint, uint), val: N) {
unsafe { unsafe {
mem::transmute::<&mut $t<N>, &mut [N, ..$dim * $dim]>(self)[i + j * $dim] = val mem::transmute::<&mut $t<N>, &mut [N; $dim * $dim]>(self)[i + j * $dim] = val
} }
} }
#[inline] #[inline]
fn swap(&mut self, (i1, j1): (uint, uint), (i2, j2): (uint, uint)) { fn swap(&mut self, (i1, j1): (uint, uint), (i2, j2): (uint, uint)) {
unsafe { unsafe {
mem::transmute::<&mut $t<N>, &mut [N, ..$dim * $dim]>(self) mem::transmute::<&mut $t<N>, &mut [N; $dim * $dim]>(self)
.swap(i1 + j1 * $dim, i2 + j2 * $dim) .swap(i1 + j1 * $dim, i2 + j2 * $dim)
} }
} }
#[inline] #[inline]
unsafe fn unsafe_at(&self, (i, j): (uint, uint)) -> N { unsafe fn unsafe_at(&self, (i, j): (uint, uint)) -> N {
(*mem::transmute::<&$t<N>, &[N, ..$dim * $dim]>(self).unsafe_get(i + j * $dim)) (*mem::transmute::<&$t<N>, &[N; $dim * $dim]>(self).unsafe_get(i + j * $dim))
} }
#[inline] #[inline]
unsafe fn unsafe_set(&mut self, (i, j): (uint, uint), val: N) { unsafe fn unsafe_set(&mut self, (i, j): (uint, uint), val: N) {
(*mem::transmute::<&mut $t<N>, &mut [N, ..$dim * $dim]>(self).get_unchecked_mut(i + j * $dim)) = val (*mem::transmute::<&mut $t<N>, &mut [N; $dim * $dim]>(self).get_unchecked_mut(i + j * $dim)) = val
} }
} }
) )
@ -294,7 +294,7 @@ macro_rules! index_impl(
impl<N> Index<(uint, uint), N> for $t<N> { impl<N> Index<(uint, uint), N> for $t<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]
} }
} }
} }
@ -302,7 +302,7 @@ macro_rules! index_impl(
impl<N> IndexMut<(uint, uint), N> for $t<N> { impl<N> IndexMut<(uint, uint), N> for $t<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]
} }
} }
} }

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

@ -153,7 +153,7 @@ impl<N: BaseFloat> Basis for Vec3<N> {
} }
// FIXME: this bad: this fixes definitly the number of samples… // FIXME: this bad: this fixes definitly the number of samples…
static SAMPLES_2_F64: [Vec2<f64>, ..21] = [ static SAMPLES_2_F64: [Vec2<f64>; 21] = [
Vec2 { x: 1.0, y: 0.0 }, Vec2 { x: 1.0, y: 0.0 },
Vec2 { x: 0.95557281, y: 0.29475517 }, Vec2 { x: 0.95557281, y: 0.29475517 },
Vec2 { x: 0.82623877, y: 0.56332006 }, Vec2 { x: 0.82623877, y: 0.56332006 },
@ -178,7 +178,7 @@ static SAMPLES_2_F64: [Vec2<f64>, ..21] = [
]; ];
// Those vectors come from bullet 3d // Those vectors come from bullet 3d
static SAMPLES_3_F64: [Vec3<f64>, ..42] = [ static SAMPLES_3_F64: [Vec3<f64>; 42] = [
Vec3 { x: 0.000000 , y: -0.000000, z: -1.000000 }, Vec3 { x: 0.000000 , y: -0.000000, z: -1.000000 },
Vec3 { x: 0.723608 , y: -0.525725, z: -0.447219 }, Vec3 { x: 0.723608 , y: -0.525725, z: -0.447219 },
Vec3 { x: -0.276388, y: -0.850649, z: -0.447219 }, Vec3 { x: -0.276388, y: -0.850649, z: -0.447219 },

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

@ -67,14 +67,14 @@ impl<N> Indexable<uint, N> for vec::Vec0<N> {
impl<N: 'static> Iterable<N> for vec::Vec0<N> { impl<N: 'static> Iterable<N> for vec::Vec0<N> {
#[inline] #[inline]
fn iter<'l>(&'l self) -> Iter<'l, N> { fn iter<'l>(&'l self) -> Iter<'l, N> {
unsafe { mem::transmute::<&'l vec::Vec0<N>, &'l [N, ..0]>(self).iter() } unsafe { mem::transmute::<&'l vec::Vec0<N>, &'l [N; 0]>(self).iter() }
} }
} }
impl<N: 'static> IterableMut<N> for vec::Vec0<N> { impl<N: 'static> IterableMut<N> for vec::Vec0<N> {
#[inline] #[inline]
fn iter_mut<'l>(&'l mut self) -> IterMut<'l, N> { fn iter_mut<'l>(&'l mut self) -> IterMut<'l, N> {
unsafe { mem::transmute::<&'l mut vec::Vec0<N>, &'l mut [N, ..0]>(self).iter_mut() } unsafe { mem::transmute::<&'l mut vec::Vec0<N>, &'l mut [N; 0]>(self).iter_mut() }
} }
} }

24
src/structs/vec_macros.rs
View File

@ -20,7 +20,7 @@ macro_rules! as_array_impl(
impl<N> $t<N> { impl<N> $t<N> {
/// View this vector as an array. /// View this vector as an array.
#[inline] #[inline]
pub fn as_array(&self) -> &[N, ..$dim] { pub fn as_array(&self) -> &[N; $dim] {
unsafe { unsafe {
mem::transmute(self) mem::transmute(self)
} }
@ -28,7 +28,7 @@ macro_rules! as_array_impl(
/// View this vector as a mutable array. /// View this vector as a mutable array.
#[inline] #[inline]
pub fn as_array_mut(&mut self) -> &mut [N, ..$dim] { pub fn as_array_mut(&mut self) -> &mut [N; $dim] {
unsafe { unsafe {
mem::transmute(self) mem::transmute(self)
} }
@ -37,11 +37,11 @@ macro_rules! as_array_impl(
// FIXME: because of https://github.com/rust-lang/rust/issues/16418 we cannot do the // FIXME: because of https://github.com/rust-lang/rust/issues/16418 we cannot do the
// array-to-vec conversion by-value: // array-to-vec conversion by-value:
// //
// pub fn from_array(array: [N, ..$dim]) -> $t<N> // pub fn from_array(array: [N; $dim]) -> $t<N>
/// View an array as a vector. /// View an array as a vector.
#[inline] #[inline]
pub fn from_array_ref(array: &[N, ..$dim]) -> &$t<N> { pub fn from_array_ref(array: &[N; $dim]) -> &$t<N> {
unsafe { unsafe {
mem::transmute(array) mem::transmute(array)
} }
@ -49,7 +49,7 @@ macro_rules! as_array_impl(
/// View an array as a vector. /// View an array as a vector.
#[inline] #[inline]
pub fn from_array_mut(array: &mut [N, ..$dim]) -> &mut $t<N> { pub fn from_array_mut(array: &mut [N; $dim]) -> &mut $t<N> {
unsafe { unsafe {
mem::transmute(array) mem::transmute(array)
} }
@ -203,32 +203,32 @@ macro_rules! indexable_impl(
#[inline] #[inline]
fn at(&self, i: uint) -> N { fn at(&self, i: uint) -> N {
unsafe { unsafe {
mem::transmute::<&$t<N>, &[N, ..$dim]>(self)[i] mem::transmute::<&$t<N>, &[N; $dim]>(self)[i]
} }
} }
#[inline] #[inline]
fn set(&mut self, i: uint, val: N) { fn set(&mut self, i: uint, val: N) {
unsafe { unsafe {
mem::transmute::<&mut $t<N>, &mut [N, ..$dim]>(self)[i] = val mem::transmute::<&mut $t<N>, &mut [N; $dim]>(self)[i] = val
} }
} }
#[inline] #[inline]
fn swap(&mut self, i1: uint, i2: uint) { fn swap(&mut self, i1: uint, i2: uint) {
unsafe { unsafe {
mem::transmute::<&mut $t<N>, &mut [N, ..$dim]>(self).swap(i1, i2) mem::transmute::<&mut $t<N>, &mut [N; $dim]>(self).swap(i1, i2)
} }
} }
#[inline] #[inline]
unsafe fn unsafe_at(&self, i: uint) -> N { unsafe fn unsafe_at(&self, i: uint) -> N {
(*mem::transmute::<&$t<N>, &[N, ..$dim]>(self).unsafe_get(i)) (*mem::transmute::<&$t<N>, &[N; $dim]>(self).unsafe_get(i))
} }
#[inline] #[inline]
unsafe fn unsafe_set(&mut self, i: uint, val: N) { unsafe fn unsafe_set(&mut self, i: uint, val: N) {
(*mem::transmute::<&mut $t<N>, &mut [N, ..$dim]>(self).get_unchecked_mut(i)) = val (*mem::transmute::<&mut $t<N>, &mut [N; $dim]>(self).get_unchecked_mut(i)) = val
} }
} }
) )
@ -271,7 +271,7 @@ macro_rules! iterable_impl(
#[inline] #[inline]
fn iter<'l>(&'l self) -> Iter<'l, N> { fn iter<'l>(&'l self) -> Iter<'l, N> {
unsafe { unsafe {
mem::transmute::<&'l $t<N>, &'l [N, ..$dim]>(self).iter() mem::transmute::<&'l $t<N>, &'l [N; $dim]>(self).iter()
} }
} }
} }
@ -284,7 +284,7 @@ macro_rules! iterable_mut_impl(
#[inline] #[inline]
fn iter_mut<'l>(&'l mut self) -> IterMut<'l, N> { fn iter_mut<'l>(&'l mut self) -> IterMut<'l, N> {
unsafe { unsafe {
mem::transmute::<&'l mut $t<N>, &'l mut [N, ..$dim]>(self).iter_mut() mem::transmute::<&'l mut $t<N>, &'l mut [N; $dim]>(self).iter_mut()
} }
} }
} }