Add implementation of Vec0.

src/nalgebra.rc

@@ -21,6 +21,7 @@ pub mod dvec;
 // specialization for some 1d, 2d and 3d operations
 pub mod mat_spec;
 pub mod vec_spec;
+pub mod vec0_spec;
 
 /// Wrappers around raw matrices to restrict their behaviour.
 pub mod adaptors

src/vec.rs

@@ -20,44 +20,8 @@ use traits::indexable::Indexable;
 
 mod vec_impl;
 
-// #[deriving(Ord, ToStr)]
-// pub struct Vec0<N>
-// { at: [N, ..0] }
-
-// impl<N: Clone> Vec0<N>
-// {
-//   #[inline]
-//   pub fn new_repeat(_: N) -> Vec0<N>
-//   { Vec0 { at: [ ] } }
-// }
-
-// clone_impl!(Vec0)
-// deep_clone_impl!(Vec0)
-// new_impl!(Vec0, 0)
-// indexable_impl!(Vec0)
-// dim_impl!(Vec0, 0)
-// eq_impl!(Vec0)
-// // (specialized) basis_impl!(Vec0, 0)
-// add_impl!(Vec0)
-// sub_impl!(Vec0)
-// neg_impl!(Vec0)
-// dot_impl!(Vec0, 0)
-// sub_dot_impl!(Vec0, 0)
-// scalar_mul_impl!(Vec0, 0)
-// scalar_div_impl!(Vec0, 0)
-// scalar_add_impl!(Vec0, 0)
-// scalar_sub_impl!(Vec0, 0)
-// translation_impl!(Vec0)
-// translatable_impl!(Vec0)
-// norm_impl!(Vec0, 0)
-// approx_eq_impl!(Vec0)
-// zero_impl!(Vec0)
-// one_impl!(Vec0)
-// bounded_impl!(Vec0)
-// iterable_impl!(Vec0)
-// iterable_mut_impl!(Vec0)
-// to_homogeneous_impl!(Vec0, Vec1)
-// from_homogeneous_impl!(Vec1, Vec0, 1)
+#[deriving(Eq, Ord, Encodable, Decodable, Clone, DeepClone, Rand, Zero, ToStr)]
+pub struct Vec0<N>;
 
 #[deriving(Eq, Ord, Encodable, Decodable, Clone, DeepClone, IterBytes, Rand, Zero, ToStr)]
 pub struct Vec1<N>

src/vec0_spec.rs

@@ -0,0 +1,285 @@
+use std::cast;
+use std::num::{Zero, One, Algebraic, Bounded};
+use std::vec::{VecIterator, VecMutIterator};
+use std::iterator::{Iterator, IteratorUtil, FromIterator};
+use std::cmp::ApproxEq;
+use std::uint::iterate;
+use traits::iterable::{Iterable, IterableMut};
+use traits::basis::Basis;
+use traits::dim::Dim;
+use traits::dot::Dot;
+use traits::sub_dot::SubDot;
+use traits::norm::Norm;
+use traits::translation::{Translation, Translatable};
+use traits::scalar_op::{ScalarMul, ScalarDiv, ScalarAdd, ScalarSub};
+use traits::ring::Ring;
+use traits::division_ring::DivisionRing;
+use traits::indexable::Indexable;
+use vec;
+
+impl<N> vec::Vec0<N>
+{
+  #[inline]
+  pub fn new() -> vec::Vec0<N>
+  { vec::Vec0 }
+}
+
+impl<N: Clone> Indexable<uint, N> for vec::Vec0<N>
+{
+  #[inline]
+  pub fn at(&self, i: uint) -> N
+  { unsafe { cast::transmute::<&vec::Vec0<N>, &[N, ..0]>(self)[i].clone() } }
+
+  #[inline]
+  pub fn set(&mut self, i: uint, val: N)
+  { unsafe { cast::transmute::<&mut vec::Vec0<N>, &mut [N, ..0]>(self)[i] = val } }
+
+  #[inline]
+  pub fn swap(&mut self, i1: uint, i2: uint)
+  { unsafe { cast::transmute::<&mut vec::Vec0<N>, &mut [N, ..0]>(self).swap(i1, i2) } }
+}
+
+impl<N: Clone> vec::Vec0<N>
+{
+  #[inline]
+  pub fn new_repeat(_: N) -> vec::Vec0<N>
+  { vec::Vec0 }
+}
+
+impl<N> Iterable<N> for vec::Vec0<N>
+{
+  fn iter<'l>(&'l self) -> VecIterator<'l, N>
+  { unsafe { cast::transmute::<&'l vec::Vec0<N>, &'l [N, ..0]>(self).iter() } }
+}
+
+impl<N> IterableMut<N> for vec::Vec0<N>
+{
+  fn mut_iter<'l>(&'l mut self) -> VecMutIterator<'l, N>
+  { unsafe { cast::transmute::<&'l mut vec::Vec0<N>, &'l mut [N, ..0]>(self).mut_iter() } }
+}
+
+impl<N> Dim for vec::Vec0<N>
+{
+  #[inline]
+  fn dim() -> uint
+  { 0 }
+}
+
+impl<N: Clone + DivisionRing + Algebraic + ApproxEq<N>> Basis for vec::Vec0<N>
+{
+  pub fn canonical_basis(f: &fn(vec::Vec0<N>))
+  {
+    for iterate(0u, 0) |i|
+    {
+      let mut basis_element : vec::Vec0<N> = Zero::zero();
+
+      basis_element.set(i, One::one());
+
+      f(basis_element);
+    }
+  }
+
+  pub fn orthonormal_subspace_basis(&self, f: &fn(vec::Vec0<N>))
+  {
+    // compute the basis of the orthogonal subspace using Gram-Schmidt
+    // orthogonalization algorithm
+    let mut basis: ~[vec::Vec0<N>] = ~[];
+
+    for iterate(0u, 0) |i|
+    {
+      let mut basis_element : vec::Vec0<N> = Zero::zero();
+
+      basis_element.set(i, One::one());
+
+      if basis.len() == 0 - 1
+      { break; }
+
+      let mut elt = basis_element.clone();
+
+      elt = elt - self.scalar_mul(&basis_element.dot(self));
+
+      for basis.iter().advance |v|
+      { elt = elt - v.scalar_mul(&elt.dot(v)) };
+
+      if !elt.sqnorm().approx_eq(&Zero::zero())
+      {
+        let new_element = elt.normalized();
+
+        f(new_element.clone());
+
+        basis.push(new_element);
+      }
+    }
+  }
+}
+
+impl<N: Clone + Add<N,N>> Add<vec::Vec0<N>, vec::Vec0<N>> for vec::Vec0<N>
+{
+  #[inline]
+  fn add(&self, _: &vec::Vec0<N>) -> vec::Vec0<N>
+  { vec::Vec0 }
+}
+
+impl<N: Clone + Sub<N,N>> Sub<vec::Vec0<N>, vec::Vec0<N>> for vec::Vec0<N>
+{
+  #[inline]
+  fn sub(&self, _: &vec::Vec0<N>) -> vec::Vec0<N>
+  { vec::Vec0 }
+}
+
+impl<N: Neg<N>> Neg<vec::Vec0<N>> for vec::Vec0<N>
+{
+  #[inline]
+  fn neg(&self) -> vec::Vec0<N>
+  { vec::Vec0 }
+}
+
+impl<N: Ring> Dot<N> for vec::Vec0<N>
+{
+  #[inline]
+  fn dot(&self, _: &vec::Vec0<N>) -> N
+  { Zero::zero() } 
+}
+
+impl<N: Ring> SubDot<N> for vec::Vec0<N>
+{
+  #[inline]
+  fn sub_dot(&self, _: &vec::Vec0<N>, _: &vec::Vec0<N>) -> N
+  { Zero::zero() } 
+}
+
+impl<N: Mul<N, N>> ScalarMul<N> for vec::Vec0<N>
+{
+  #[inline]
+  fn scalar_mul(&self, _: &N) -> vec::Vec0<N>
+  { vec::Vec0 }
+
+  #[inline]
+  fn scalar_mul_inplace(&mut self, _: &N)
+  { }
+}
+
+impl<N: Div<N, N>> ScalarDiv<N> for vec::Vec0<N>
+{
+  #[inline]
+  fn scalar_div(&self, _: &N) -> vec::Vec0<N>
+  { vec::Vec0 }
+
+  #[inline]
+  fn scalar_div_inplace(&mut self, _: &N)
+  { }
+}
+
+impl<N: Add<N, N>> ScalarAdd<N> for vec::Vec0<N>
+{
+  #[inline]
+  fn scalar_add(&self, _: &N) -> vec::Vec0<N>
+  { vec::Vec0 }
+
+  #[inline]
+  fn scalar_add_inplace(&mut self, _: &N)
+  { }
+}
+
+impl<N: Sub<N, N>> ScalarSub<N> for vec::Vec0<N>
+{
+  #[inline]
+  fn scalar_sub(&self, _: &N) -> vec::Vec0<N>
+  { vec::Vec0 }
+
+  #[inline]
+  fn scalar_sub_inplace(&mut self, _: &N)
+  { }
+}
+
+impl<N: Clone + Add<N, N> + Neg<N>> Translation<vec::Vec0<N>> for vec::Vec0<N>
+{
+  #[inline]
+  fn translation(&self) -> vec::Vec0<N>
+  { self.clone() }
+
+  #[inline]
+  fn inv_translation(&self) -> vec::Vec0<N>
+  { -self }
+
+  #[inline]
+  fn translate_by(&mut self, t: &vec::Vec0<N>)
+  { *self = *self + *t; }
+}
+
+impl<N: Add<N, N> + Neg<N> + Clone> Translatable<vec::Vec0<N>, vec::Vec0<N>> for vec::Vec0<N>
+{
+  #[inline]
+  fn translated(&self, t: &vec::Vec0<N>) -> vec::Vec0<N>
+  { self + *t }
+}
+
+impl<N: Clone + DivisionRing + Algebraic> Norm<N> for vec::Vec0<N>
+{
+  #[inline]
+  fn sqnorm(&self) -> N
+  { self.dot(self) }
+
+  #[inline]
+  fn norm(&self) -> N
+  { self.sqnorm().sqrt() }
+
+  #[inline]
+  fn normalized(&self) -> vec::Vec0<N>
+  {
+    let mut res : vec::Vec0<N> = self.clone();
+
+    res.normalize();
+
+    res
+  }
+
+  #[inline]
+  fn normalize(&mut self) -> N
+  {
+    let l = self.norm();
+
+    self.scalar_div_inplace(&l);
+
+    l
+  }
+}
+
+impl<N: ApproxEq<N>> ApproxEq<N> for vec::Vec0<N>
+{
+  #[inline]
+  fn approx_epsilon() -> N
+  { ApproxEq::approx_epsilon::<N, N>() }
+
+  #[inline]
+  fn approx_eq(&self, _: &vec::Vec0<N>) -> bool
+  { true }
+
+  #[inline]
+  fn approx_eq_eps(&self, _: &vec::Vec0<N>, _: &N) -> bool
+  { true }
+}
+
+impl<N: Clone + One> One for vec::Vec0<N>
+{
+  #[inline]
+  fn one() -> vec::Vec0<N>
+  { vec::Vec0 }
+}
+
+impl<N, Iter: Iterator<N>> FromIterator<N, Iter> for vec::Vec0<N>
+{
+  fn from_iterator(_: &mut Iter) -> vec::Vec0<N>
+  { vec::Vec0 }
+}
+
+impl<N: Bounded + Clone> Bounded for vec::Vec0<N>
+{
+  #[inline]
+  fn max_value() -> vec::Vec0<N>
+  { vec::Vec0 }
+
+  #[inline]
+  fn min_value() -> vec::Vec0<N>
+  { vec::Vec0 }
+}

src/vec_impl.rs

@@ -82,7 +82,6 @@ macro_rules! dim_impl(
   )
 )
 
-// FIXME: add the possibility to specialize that
 macro_rules! basis_impl(
   ($t: ident, $dim: expr) => (
     impl<N: Clone + DivisionRing + Algebraic + ApproxEq<N>> Basis for $t<N>

src/vec_spec.rs

@@ -6,12 +6,6 @@ use traits::norm::Norm;
 use traits::sample::UniformSphereSample;
 use vec::{Vec1, Vec2, Vec3};
 
-// FIXME: impl<N, Iter: Iterator<N>> FromIterator<N, Iter> for Vec0<N>
-// FIXME: {
-// FIXME:   fn from_iterator(_: &mut Iter) -> Vec0<N>
-// FIXME:   { Vec0 { at: [ ] } }
-// FIXME: }
-
 impl<N: Mul<N, N> + Sub<N, N>> Cross<Vec1<N>> for Vec2<N>
 {
   #[inline]