| use std::ops::{Mul, Add, Div}; |
| use libnum::{One, Zero, Float, FromPrimitive}; |
| use std::fmt; |
| use std::vec::*; |
| use std::iter::FromIterator; |
| use std::slice::{Iter, IterMut}; |
| use std::vec::IntoIter; |
| |
| use norm::{VectorNorm, VectorMetric}; |
| use utils; |
| |
| use super::Vector; |
| |
| impl<T> Vector<T> { |
| /// Constructor for Vector struct. |
| /// |
| /// Requires the vector data. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use rulinalg::vector::Vector; |
| /// |
| /// let vec = Vector::new(vec![1.0,2.0,3.0,4.0]); |
| /// ``` |
| pub fn new<U: Into<Vec<T>>>(data: U) -> Vector<T> { |
| let our_data = data.into(); |
| let size = our_data.len(); |
| |
| Vector { |
| size: size, |
| data: our_data, |
| } |
| } |
| |
| /// Constructor for Vector struct that takes a function `f` |
| /// and constructs a new vector such that `V_i = f(i)`, |
| /// where `i` is the index. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// # #[macro_use] extern crate rulinalg; fn main() { |
| /// use rulinalg::vector::Vector; |
| /// |
| /// let v = Vector::from_fn(4, |x| x * 3); |
| /// assert_eq!(v, vector![0, 3, 6, 9]); |
| /// # } |
| /// ``` |
| pub fn from_fn<F>(size: usize, mut f: F) -> Vector<T> |
| where F: FnMut(usize) -> T { |
| |
| let data: Vec<T> = (0..size).into_iter().map(|x| f(x)).collect(); |
| |
| Vector { |
| size: size, |
| data: data, |
| } |
| } |
| |
| /// Returns the size of the Vector. |
| pub fn size(&self) -> usize { |
| self.size |
| } |
| |
| /// Returns a non-mutable reference to the underlying data. |
| pub fn data(&self) -> &Vec<T> { |
| &self.data |
| } |
| |
| /// Returns a mutable slice of the underlying data. |
| pub fn mut_data(&mut self) -> &mut [T] { |
| &mut self.data |
| } |
| |
| /// Consumes the Vector and returns the Vec of data. |
| pub fn into_vec(self) -> Vec<T> { |
| self.data |
| } |
| |
| /// Returns an iterator over the Vector's data. |
| pub fn iter(&self) -> Iter<T> { |
| self.data.iter() |
| } |
| |
| /// Returns an iterator over mutable references to the Vector's data. |
| pub fn iter_mut(&mut self) -> IterMut<T> { |
| self.mut_data().iter_mut() |
| } |
| |
| /// Returns a pointer to the element at the given index, without doing |
| /// bounds checking. |
| pub unsafe fn get_unchecked(&self, index: usize) -> &T { |
| self.data.get_unchecked(index) |
| } |
| |
| /// Returns an unsafe mutable pointer to the element at the given index, |
| /// without doing bounds checking. |
| pub unsafe fn get_unchecked_mut(&mut self, index: usize) -> &mut T { |
| self.data.get_unchecked_mut(index) |
| } |
| |
| } |
| |
| impl<T> Into<Vec<T>> for Vector<T> { |
| fn into(self) -> Vec<T> { |
| self.data |
| } |
| } |
| |
| impl<T> IntoIterator for Vector<T> { |
| type Item = T; |
| type IntoIter = IntoIter<T>; |
| |
| fn into_iter(self) -> Self::IntoIter { |
| self.data.into_iter() |
| } |
| } |
| |
| impl<'a, T> IntoIterator for &'a Vector<T> { |
| type Item = &'a T; |
| type IntoIter = Iter<'a, T>; |
| |
| fn into_iter(self) -> Self::IntoIter { |
| self.iter() |
| } |
| } |
| |
| impl<T> FromIterator<T> for Vector<T> { |
| fn from_iter<I>(iter: I) -> Self where I: IntoIterator<Item=T> { |
| let values: Vec<T> = iter.into_iter().collect(); |
| Vector::new(values) |
| } |
| } |
| |
| impl<T: fmt::Display> fmt::Display for Vector<T> { |
| /// Displays the Vector. |
| fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| try!(write!(f, "[")); |
| for (i, datum) in self.data.iter().enumerate() { |
| match f.precision() { |
| Some(places) => { |
| try!(write!(f, " {:.*}", places, datum)); |
| } |
| None => { |
| try!(write!(f, " {}", datum)); |
| } |
| } |
| if i < self.data.len() - 1 { |
| try!(write!(f, ",")); |
| } |
| } |
| write!(f, "]") |
| } |
| } |
| |
| impl<T: Clone> Clone for Vector<T> { |
| /// Clones the Vector. |
| fn clone(&self) -> Vector<T> { |
| Vector { |
| size: self.size, |
| data: self.data.clone(), |
| } |
| } |
| } |
| |
| impl<T: Copy> Vector<T> { |
| /// Applies a function to each element in the vector. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// # #[macro_use] extern crate rulinalg; fn main() { |
| /// use rulinalg::vector::Vector; |
| /// fn add_two(a: f64) -> f64 { |
| /// a + 2f64 |
| /// } |
| /// |
| /// let a = vector![0.; 4]; |
| /// |
| /// let b = a.apply(&add_two); |
| /// |
| /// assert_eq!(b, vector![2.0; 4]); |
| /// # } |
| /// ``` |
| pub fn apply(mut self, f: &Fn(T) -> T) -> Vector<T> { |
| for val in &mut self.data { |
| *val = f(*val); |
| } |
| self |
| } |
| } |
| |
| impl<T: Copy + PartialOrd> Vector<T> { |
| /// Find the argmax of the Vector. |
| /// |
| /// Returns the index of the largest value in the vector. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// # #[macro_use] extern crate rulinalg; fn main() { |
| /// use rulinalg::vector::Vector; |
| /// |
| /// let a = vector![1.0,2.0,0.0,5.0]; |
| /// let b = a.argmax(); |
| /// assert_eq!(b.0, 3); |
| /// assert_eq!(b.1, 5.0); |
| /// # } |
| /// ``` |
| pub fn argmax(&self) -> (usize, T) { |
| utils::argmax(&self.data) |
| } |
| |
| /// Find the argmin of the Vector. |
| /// |
| /// Returns the index of the smallest value in the vector. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// # #[macro_use] extern crate rulinalg; fn main() { |
| /// use rulinalg::vector::Vector; |
| /// |
| /// let a = vector![1.0, 2.0, 0.0, 5.0]; |
| /// let b = a.argmin(); |
| /// assert_eq!(b.0, 2); |
| /// assert_eq!(b.1, 0.0); |
| /// # } |
| /// ``` |
| pub fn argmin(&self) -> (usize, T) { |
| utils::argmin(&self.data) |
| } |
| |
| /// Select elements from the Vector and form a new Vector from them. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// # #[macro_use] extern crate rulinalg; fn main() { |
| /// use rulinalg::vector::Vector; |
| /// |
| /// let a = vector![1.0, 2.0, 3.0, 4.0, 5.0]; |
| /// |
| /// let a_lower = a.select(&[2, 3, 4]); |
| /// |
| /// // Prints [3,4,5] |
| /// assert_eq!(a_lower, vector![3.0, 4.0, 5.0]); |
| /// # } |
| /// ``` |
| pub fn select(&self, idxs: &[usize]) -> Vector<T> { |
| let mut new_data = Vec::with_capacity(idxs.len()); |
| |
| for idx in idxs.into_iter() { |
| new_data.push(self[*idx]); |
| } |
| |
| Vector::new(new_data) |
| } |
| } |
| |
| impl<T: Clone + Zero> Vector<T> { |
| /// Constructs Vector of all zeros. |
| /// |
| /// Requires the size of the vector. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use rulinalg::vector::Vector; |
| /// |
| /// let vec = Vector::<f64>::zeros(10); |
| /// ``` |
| pub fn zeros(size: usize) -> Vector<T> { |
| Vector { |
| size: size, |
| data: vec![T::zero(); size], |
| } |
| } |
| } |
| |
| impl<T: Clone + One> Vector<T> { |
| /// Constructs Vector of all ones. |
| /// |
| /// Requires the size of the vector. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use rulinalg::vector::Vector; |
| /// |
| /// let vec = Vector::<f64>::ones(10); |
| /// ``` |
| pub fn ones(size: usize) -> Vector<T> { |
| Vector { |
| size: size, |
| data: vec![T::one(); size], |
| } |
| } |
| } |
| |
| impl<T: Copy + Zero + Mul<T, Output = T> + Add<T, Output = T>> Vector<T> { |
| /// Compute dot product with specified Vector. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// # #[macro_use] extern crate rulinalg; fn main() { |
| /// use rulinalg::vector::Vector; |
| /// |
| /// let a = vector![1.0, 2.0, 3.0, 4.0]; |
| /// let b = vector![2.0; 4]; |
| /// |
| /// let c = a.dot(&b); |
| /// assert_eq!(c, 20.0); |
| /// # } |
| /// ``` |
| pub fn dot(&self, v: &Vector<T>) -> T { |
| utils::dot(&self.data, &v.data) |
| } |
| } |
| |
| impl<T: Copy + Zero + Add<T, Output = T>> Vector<T> { |
| /// The sum of the vector. |
| /// |
| /// Returns the sum of all elements in the vector. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// # #[macro_use] extern crate rulinalg; fn main() { |
| /// use rulinalg::vector::Vector; |
| /// |
| /// let a = vector![1.0, 2.0, 3.0, 4.0]; |
| /// |
| /// let c = a.sum(); |
| /// assert_eq!(c, 10.0); |
| /// # } |
| /// ``` |
| pub fn sum(&self) -> T { |
| utils::unrolled_sum(&self.data[..]) |
| } |
| } |
| |
| impl<T: Copy + Mul<T, Output = T>> Vector<T> { |
| /// The elementwise product of two vectors. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// # #[macro_use] extern crate rulinalg; fn main() { |
| /// use rulinalg::vector::Vector; |
| /// |
| /// let a = vector![1.0, 2.0, 3.0, 4.0]; |
| /// let b = vector![1.0, 2.0, 3.0, 4.0]; |
| /// |
| /// let c = &a.elemul(&b); |
| /// assert_eq!(c, &vector![1.0, 4.0, 9.0, 16.0]); |
| /// # } |
| /// ``` |
| pub fn elemul(&self, v: &Vector<T>) -> Vector<T> { |
| assert_eq!(self.size, v.size); |
| Vector::new(utils::ele_mul(&self.data, &v.data)) |
| } |
| } |
| |
| impl<T: Copy + Div<T, Output = T>> Vector<T> { |
| /// The elementwise division of two vectors. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// # #[macro_use] extern crate rulinalg; fn main() { |
| /// use rulinalg::vector::Vector; |
| /// |
| /// let a = vector![1.0, 2.0, 3.0, 4.0]; |
| /// let b = vector![1.0, 2.0, 3.0, 4.0]; |
| /// |
| /// let c = &a.elediv(&b); |
| /// assert_eq!(c, &vector![1.0; 4]); |
| /// # } |
| /// ``` |
| pub fn elediv(&self, v: &Vector<T>) -> Vector<T> { |
| assert_eq!(self.size, v.size); |
| Vector::new(utils::ele_div(&self.data, &v.data)) |
| } |
| } |
| |
| impl<T: Float> Vector<T> { |
| /// Compute vector norm for vector. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// # #[macro_use] extern crate rulinalg; fn main() { |
| /// use rulinalg::vector::Vector; |
| /// use rulinalg::norm::Euclidean; |
| /// |
| /// let a = vector![3.0, 4.0]; |
| /// let c = a.norm(Euclidean); |
| /// |
| /// assert_eq!(c, 5.0); |
| /// # } |
| /// ``` |
| pub fn norm<N: VectorNorm<T>>(&self, norm: N) -> T { |
| norm.norm(self) |
| } |
| |
| /// Compute metric distance between two vectors. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// # #[macro_use] extern crate rulinalg; fn main() { |
| /// use rulinalg::vector::Vector; |
| /// use rulinalg::norm::Euclidean; |
| /// |
| /// let a = vector![3.0, 4.0]; |
| /// let b = vector![0.0, 8.0]; |
| /// |
| /// // Compute the square root of the sum of |
| /// // elementwise squared-differences |
| /// let c = a.metric(&b, Euclidean); |
| /// assert_eq!(c, 5.0); |
| /// # } |
| /// ``` |
| pub fn metric<M: VectorMetric<T>>(&self, v: &Vector<T>, m: M) -> T { |
| m.metric(self, v) |
| } |
| } |
| |
| impl<T: Float + FromPrimitive> Vector<T> { |
| /// The mean of the vector. |
| /// |
| /// Returns the arithmetic mean of the vector. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// # #[macro_use] extern crate rulinalg; fn main() { |
| /// use rulinalg::vector::Vector; |
| /// |
| /// let a = vector![1.0, 2.0, 3.0, 4.0]; |
| /// |
| /// let c = a.mean(); |
| /// assert_eq!(c, 2.5); |
| /// # } |
| /// ``` |
| pub fn mean(&self) -> T { |
| let sum = self.sum(); |
| sum / FromPrimitive::from_usize(self.size()).unwrap() |
| } |
| |
| /// The variance of the vector. |
| /// |
| /// Returns the unbiased sample variance of the vector. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// # #[macro_use] extern crate rulinalg; fn main() { |
| /// use rulinalg::vector::Vector; |
| /// |
| /// let a = vector![1.0, 2.0, 3.0, 4.0]; |
| /// |
| /// let c = a.variance(); |
| /// assert_eq!(c, 5.0 / 3.0); |
| /// # } |
| /// ``` |
| pub fn variance(&self) -> T { |
| let m = self.mean(); |
| let mut var = T::zero(); |
| |
| for u in &self.data { |
| var = var + (*u - m) * (*u - m); |
| } |
| |
| var / FromPrimitive::from_usize(self.size() - 1).unwrap() |
| } |
| } |
| |
| #[cfg(test)] |
| mod tests { |
| |
| use super::super::Vector; |
| use norm::Euclidean; |
| |
| #[test] |
| fn test_display() { |
| let v = vector![1, 2, 3, 4]; |
| assert_eq!(format!("{}", v), "[ 1, 2, 3, 4]"); |
| |
| let v2 = vector![3.3, 4.0, 5.0, 6.0]; |
| assert_eq!(format!("{}", v2), "[ 3.3, 4, 5, 6]"); |
| assert_eq!(format!("{:.1}", v2), "[ 3.3, 4.0, 5.0, 6.0]"); |
| } |
| |
| #[test] |
| fn test_equality() { |
| let v = vector![1, 2, 3, 4]; |
| let v_redux = v.clone(); |
| assert_eq!(v, v_redux); |
| } |
| |
| #[test] |
| fn create_vector_new() { |
| let a = vector![1.0; 12]; |
| |
| assert_eq!(a.size(), 12); |
| |
| for i in 0..12 { |
| assert_eq!(a[i], 1.0); |
| } |
| } |
| |
| #[test] |
| fn create_vector_new_from_slice() { |
| let data_vec: Vec<u32> = vec![1, 2, 3]; |
| let data_slice: &[u32] = &data_vec[..]; |
| let from_vec = Vector::new(data_vec.clone()); |
| let from_slice = Vector::new(data_slice); |
| assert_eq!(from_vec, from_slice); |
| } |
| |
| #[test] |
| fn create_vector_from_fn() { |
| let v1 = Vector::from_fn(3, |x| x + 1); |
| assert_eq!(v1, vector![1, 2, 3]); |
| |
| let v2 = Vector::from_fn(3, |x| x as f64); |
| assert_eq!(v2, vector![0., 1., 2.]); |
| |
| let mut z = 0; |
| let v3 = Vector::from_fn(3, |x| { z += 1; x + z }); |
| assert_eq!(v3, vector![0 + 1, 1 + 2, 2 + 3]); |
| |
| let v4 = Vector::from_fn(3, move |x| x + 1); |
| assert_eq!(v4, vector![1, 2, 3]); |
| |
| let v5 = Vector::from_fn(0, |x| x); |
| assert_eq!(v5, Vector::new(vec![])); |
| } |
| |
| #[test] |
| fn create_vector_zeros() { |
| let a = Vector::<f32>::zeros(7); |
| |
| assert_eq!(a.size(), 7); |
| |
| for i in 0..7 { |
| assert_eq!(a[i], 0.0); |
| } |
| } |
| |
| #[test] |
| fn vector_dot_product() { |
| let a = vector![1.0, 2.0, 3.0, 4.0, 5.0, 6.0]; |
| let b = vector![3.0; 6]; |
| |
| let c = a.dot(&b); |
| |
| assert_eq!(c, 63.0); |
| } |
| |
| #[test] |
| fn vector_euclidean_norm() { |
| let a = vector![1.0, 2.0, 3.0, 4.0, 5.0, 6.0]; |
| let b = a.norm(Euclidean); |
| |
| assert_eq!(b, (1. + 4. + 9. + 16. + 25. + 36. as f32).sqrt()); |
| } |
| |
| #[test] |
| fn vector_iteration() { |
| let our_vec = vec![2i32, 7, 1, 8, 2, 8]; |
| let our_vector = Vector::new(our_vec.clone()); |
| let our_vector_again = our_vector.clone(); |
| |
| // over Vector (consuming) |
| let mut our_recovered_vec = Vec::new(); |
| for i in our_vector { |
| our_recovered_vec.push(i); |
| } |
| assert_eq!(our_recovered_vec, our_vec); |
| |
| // over &Vector |
| let mut our_refcovered_vec = Vec::new(); |
| for i in &our_vector_again { |
| our_refcovered_vec.push(*i); |
| } |
| assert_eq!(our_refcovered_vec, our_vec); |
| } |
| |
| #[test] |
| fn vector_from_iter() { |
| let v1: Vector<usize> = (2..5).collect(); |
| let exp1 = vector![2, 3, 4]; |
| assert_eq!(v1, exp1); |
| |
| let orig: Vec<f64> = vec![2., 3., 4.]; |
| let v2: Vector<f64> = orig.iter().map(|x| x + 1.).collect(); |
| let exp2 = vector![3., 4., 5.]; |
| assert_eq!(v2, exp2); |
| } |
| |
| #[test] |
| fn vector_get_unchecked() { |
| let v1 = vector![1, 2, 3]; |
| unsafe { |
| assert_eq!(v1.get_unchecked(1), &2); |
| } |
| |
| let mut v2 = vector![1, 2, 3]; |
| |
| unsafe { |
| let elem = v2.get_unchecked_mut(1); |
| *elem = 4; |
| } |
| assert_eq!(v2, vector![1, 4, 3]); |
| } |
| |
| #[test] |
| fn vector_mul_f32_elemwise() { |
| let a = vector![1.0, 2.0, 3.0, 4.0, 5.0, 6.0]; |
| let b = vector![2.0, 3.0, 4.0, 5.0, 6.0, 7.0]; |
| |
| let exp = vector![2.0, 6.0, 12.0, 20.0, 30.0, 42.0]; |
| |
| // Allocating new memory |
| let c = &a.elemul(&b); |
| assert_eq!(c, &exp); |
| |
| // Allocating new memory |
| let c = a.elemul(&b); |
| assert_eq!(c, exp); |
| } |
| |
| #[test] |
| fn vector_mul_int_elemwise() { |
| let a = vector![1, 2, 3, 4]; |
| let b = vector![2, 4, 6, 8]; |
| |
| let exp = vector![2, 8, 18, 32]; |
| |
| // Allocating new memory |
| let c = &a.elemul(&b); |
| assert_eq!(c, &exp); |
| |
| // Allocating new memory |
| let c = a.elemul(&b); |
| assert_eq!(c, exp); |
| } |
| |
| #[test] |
| fn vector_div_f32_elemwise() { |
| let a = vector![1.0, 2.0, 3.0, 4.0, 5.0, 6.0]; |
| let b = vector![2.0, 3.0, 4.0, 5.0, 6.0, 7.0]; |
| |
| let exp = vector![1. / 2., 2. / 3., 3. / 4., 4. / 5., 5. / 6., 6. / 7.]; |
| |
| // Allocating new memory |
| let c = &a.elediv(&b); |
| assert_eq!(c, &exp); |
| |
| // Allocating new memory |
| let c = a.elediv(&b); |
| assert_eq!(c, exp); |
| } |
| |
| #[test] |
| fn vector_div_int_elemwise() { |
| let a = vector![2, 4, 6, 8]; |
| let b = vector![2, 2, 3, 3]; |
| |
| let exp = vector![1, 2, 2, 2]; |
| |
| // Allocating new memory |
| let c = &a.elediv(&b); |
| assert_eq!(c, &exp); |
| |
| // Allocating new memory |
| let c = a.elediv(&b); |
| assert_eq!(c, exp); |
| } |
| } |
