Struct rulinalg::vector::Vector

pub struct Vector<T> {
    // some fields omitted
}

The Vector struct.

Can be instantiated with any type.

Methods

impl<T> Vector<T>

fn new<U: Into<Vec<T>>>(data: U) -> 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]);

fn size(&self) -> usize

Returns the size of the Vector.

fn data(&self) -> &Vec<T>

Returns a non-mutable reference to the underlying data.

fn mut_data(&mut self) -> &mut [T]

Returns a mutable slice of the underlying data.

fn into_vec(self) -> Vec<T>

Consumes the Vector and returns the Vec of data.

impl<T: Copy> Vector<T>

fn apply(self, f: &Fn(T) -> T) -> Vector<T>

Applies a function to each element in the vector.

Examples

use rulinalg::vector::Vector;
fn add_two(a: f64) -> f64 {
    a + 2f64
}

let a = Vector::new(vec![0.;4]);

let b = a.apply(&add_two);

assert_eq!(b.into_vec(), vec![2.0; 4]);

impl<T: Copy + PartialOrd> Vector<T>

fn argmax(&self) -> (usize, T)

Find the argmax of the Vector.

Returns the index of the largest value in the vector.

Examples

use rulinalg::vector::Vector;

let a = Vector::new(vec![1.0,2.0,0.0,5.0]);
let b = a.argmax();
assert_eq!(b.0, 3);
assert_eq!(b.1, 5.0);

fn argmin(&self) -> (usize, T)

Find the argmin of the Vector.

Returns the index of the smallest value in the vector.

Examples

use rulinalg::vector::Vector;

let a = Vector::new(vec![1.0,2.0,0.0,5.0]);
let b = a.argmin();
assert_eq!(b.0, 2);
assert_eq!(b.1, 0.0);

fn select(&self, idxs: &[usize]) -> Vector<T>

Select elements from the Vector and form a new Vector from them.

Examples

use rulinalg::vector::Vector;

let a = Vector::new(vec![1.0,2.0,3.0,4.0,5.0]);

let a_lower = a.select(&[2,3,4]);

// Prints [3,4,5]
println!("{:?}", a_lower.data());

impl<T: Clone + Zero> Vector<T>

fn zeros(size: usize) -> Vector<T>

Constructs Vector of all zeros.

Requires the size of the vector.

Examples

use rulinalg::vector::Vector;

let vec = Vector::<f64>::zeros(10);

impl<T: Clone + One> Vector<T>

fn ones(size: usize) -> Vector<T>

Constructs Vector of all ones.

Requires the size of the vector.

Examples

use rulinalg::vector::Vector;

let vec = Vector::<f64>::ones(10);

impl<T: Copy + Zero + Mul<T, Output=T> + Add<T, Output=T>> Vector<T>

fn dot(&self, v: &Vector<T>) -> T

Compute dot product with specified Vector.

Examples

use rulinalg::vector::Vector;

let a = Vector::new(vec![1.0,2.0,3.0,4.0]);
let b = Vector::new(vec![2.0; 4]);

let c = a.dot(&b);
assert_eq!(c, 20.0);

impl<T: Copy + Zero + Add<T, Output=T>> Vector<T>

fn sum(&self) -> T

The sum of the vector.

Returns the sum of all elements in the vector.

Examples

use rulinalg::vector::Vector;

let a = Vector::new(vec![1.0,2.0,3.0,4.0]);

let c = a.sum();
assert_eq!(c, 10.0);

impl<T: Copy + Mul<T, Output=T>> Vector<T>

fn elemul(&self, v: &Vector<T>) -> Vector<T>

The elementwise product of two vectors.

Examples

use rulinalg::vector::Vector;

let a = Vector::new(vec![1.0,2.0,3.0,4.0]);
let b = Vector::new(vec![1.0,2.0,3.0,4.0]);

let c = &a.elemul(&b);
assert_eq!(*c.data(), vec![1.0, 4.0, 9.0, 16.0]);

impl<T: Copy + Div<T, Output=T>> Vector<T>

fn elediv(&self, v: &Vector<T>) -> Vector<T>

The elementwise division of two vectors.

Examples

use rulinalg::vector::Vector;

let a = Vector::new(vec![1.0,2.0,3.0,4.0]);
let b = Vector::new(vec![1.0,2.0,3.0,4.0]);

let c = &a.elediv(&b);
assert_eq!(*c.data(), vec![1.0; 4]);

impl<T: Float + FromPrimitive> Vector<T>

fn mean(&self) -> T

The mean of the vector.

Returns the arithmetic mean of the vector.

Examples

use rulinalg::vector::Vector;

let a = Vector::<f32>::new(vec![1.0,2.0,3.0,4.0]);

let c = a.mean();
assert_eq!(c, 2.5);

fn variance(&self) -> T

The variance of the vector.

Returns the unbiased sample variance of the vector.

Examples

use rulinalg::vector::Vector;

let a = Vector::<f32>::new(vec![1.0,2.0,3.0,4.0]);

let c = a.variance();
assert_eq!(c, 5.0/3.0);

Trait Implementations

impl<T: Debug> Debug for Vector<T>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T: PartialEq> PartialEq for Vector<T>

fn eq(&self, __arg_0: &Vector<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, __arg_0: &Vector<T>) -> bool

This method tests for !=.

impl<T: Eq> Eq for Vector<T>

impl<T: Hash> Hash for Vector<T>

fn hash<__HT: Hasher>(&self, __arg_0: &mut __HT)

Feeds this value into the state given, updating the hasher as necessary.

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher

Feeds a slice of this type into the state provided.

impl<T: Display> Display for Vector<T>

fn fmt(&self, f: &mut Formatter) -> Result

Displays the Vector.

impl<T: Clone> Clone for Vector<T>

fn clone(&self) -> Vector<T>

Clones the Vector.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Copy + Mul<T, Output=T>> Mul<T> for Vector<T>

Multiplies vector by scalar.

type Output = Vector<T>

The resulting type after applying the * operator

fn mul(self, f: T) -> Vector<T>

The method for the * operator

impl<'a, T: Copy + Mul<T, Output=T>> Mul<T> for &'a Vector<T>

Multiplies vector by scalar.

type Output = Vector<T>

The resulting type after applying the * operator

fn mul(self, f: T) -> Vector<T>

The method for the * operator

impl<'a, T: Copy + Mul<T, Output=T>> Mul<&'a T> for Vector<T>

Multiplies vector by scalar.

type Output = Vector<T>

The resulting type after applying the * operator

fn mul(self, f: &T) -> Vector<T>

The method for the * operator

impl<'a, 'b, T: Copy + Mul<T, Output=T>> Mul<&'b T> for &'a Vector<T>

Multiplies vector by scalar.

type Output = Vector<T>

The resulting type after applying the * operator

fn mul(self, f: &T) -> Vector<T>

The method for the * operator

impl<T: Copy + Zero + PartialEq + Div<T, Output=T>> Div<T> for Vector<T>

Divides vector by scalar.

type Output = Vector<T>

The resulting type after applying the / operator

fn div(self, f: T) -> Vector<T>

The method for the / operator

impl<'a, T: Copy + Zero + PartialEq + Div<T, Output=T>> Div<T> for &'a Vector<T>

Divides vector by scalar.

type Output = Vector<T>

The resulting type after applying the / operator

fn div(self, f: T) -> Vector<T>

The method for the / operator

impl<'a, T: Copy + Zero + PartialEq + Div<T, Output=T>> Div<&'a T> for Vector<T>

Divides vector by scalar.

type Output = Vector<T>

The resulting type after applying the / operator

fn div(self, f: &T) -> Vector<T>

The method for the / operator

impl<'a, 'b, T: Copy + Zero + PartialEq + Div<T, Output=T>> Div<&'b T> for &'a Vector<T>

Divides vector by scalar.

type Output = Vector<T>

The resulting type after applying the / operator

fn div(self, f: &T) -> Vector<T>

The method for the / operator

impl<T: Copy + Add<T, Output=T>> Add<T> for Vector<T>

Adds scalar to vector.

type Output = Vector<T>

The resulting type after applying the + operator

fn add(self, f: T) -> Vector<T>

The method for the + operator

impl<'a, T: Copy + Add<T, Output=T>> Add<T> for &'a Vector<T>

Adds scalar to vector.

type Output = Vector<T>

The resulting type after applying the + operator

fn add(self, f: T) -> Vector<T>

The method for the + operator

impl<'a, T: Copy + Add<T, Output=T>> Add<&'a T> for Vector<T>

Adds scalar to vector.

type Output = Vector<T>

The resulting type after applying the + operator

fn add(self, f: &T) -> Vector<T>

The method for the + operator

impl<'a, 'b, T: Copy + Add<T, Output=T>> Add<&'b T> for &'a Vector<T>

Adds scalar to vector.

type Output = Vector<T>

The resulting type after applying the + operator

fn add(self, f: &T) -> Vector<T>

The method for the + operator

impl<T: Copy + Add<T, Output=T>> Add<Vector<T>> for Vector<T>

Adds vector to vector.

type Output = Vector<T>

The resulting type after applying the + operator

fn add(self, v: Vector<T>) -> Vector<T>

The method for the + operator

impl<'a, T: Copy + Add<T, Output=T>> Add<Vector<T>> for &'a Vector<T>

Adds vector to vector.

type Output = Vector<T>

The resulting type after applying the + operator

fn add(self, v: Vector<T>) -> Vector<T>

The method for the + operator

impl<'a, T: Copy + Add<T, Output=T>> Add<&'a Vector<T>> for Vector<T>

Adds vector to vector.

type Output = Vector<T>

The resulting type after applying the + operator

fn add(self, v: &Vector<T>) -> Vector<T>

The method for the + operator

impl<'a, 'b, T: Copy + Add<T, Output=T>> Add<&'b Vector<T>> for &'a Vector<T>

Adds vector to vector.

type Output = Vector<T>

The resulting type after applying the + operator

fn add(self, v: &Vector<T>) -> Vector<T>

The method for the + operator

impl<T: Copy + Sub<T, Output=T>> Sub<T> for Vector<T>

Subtracts scalar from vector.

type Output = Vector<T>

The resulting type after applying the - operator

fn sub(self, f: T) -> Vector<T>

The method for the - operator

impl<'a, T: Copy + Sub<T, Output=T>> Sub<T> for &'a Vector<T>

Subtracts scalar from vector.

type Output = Vector<T>

The resulting type after applying the - operator

fn sub(self, f: T) -> Vector<T>

The method for the - operator

impl<'a, T: Copy + Sub<T, Output=T>> Sub<&'a T> for Vector<T>

Subtracts scalar from vector.

type Output = Vector<T>

The resulting type after applying the - operator

fn sub(self, f: &T) -> Vector<T>

The method for the - operator

impl<'a, 'b, T: Copy + Sub<T, Output=T>> Sub<&'b T> for &'a Vector<T>

Subtracts scalar from vector.

type Output = Vector<T>

The resulting type after applying the - operator

fn sub(self, f: &T) -> Vector<T>

The method for the - operator

impl<T: Copy + Sub<T, Output=T>> Sub<Vector<T>> for Vector<T>

Subtracts vector from vector.

type Output = Vector<T>

The resulting type after applying the - operator

fn sub(self, v: Vector<T>) -> Vector<T>

The method for the - operator

impl<'a, T: Copy + Sub<T, Output=T>> Sub<Vector<T>> for &'a Vector<T>

Subtracts vector from vector.

type Output = Vector<T>

The resulting type after applying the - operator

fn sub(self, v: Vector<T>) -> Vector<T>

The method for the - operator

impl<'a, T: Copy + Sub<T, Output=T>> Sub<&'a Vector<T>> for Vector<T>

Subtracts vector from vector.

type Output = Vector<T>

The resulting type after applying the - operator

fn sub(self, v: &Vector<T>) -> Vector<T>

The method for the - operator

impl<'a, 'b, T: Copy + Sub<T, Output=T>> Sub<&'b Vector<T>> for &'a Vector<T>

Subtracts vector from vector.

type Output = Vector<T>

The resulting type after applying the - operator

fn sub(self, v: &Vector<T>) -> Vector<T>

The method for the - operator

impl<T: Neg<Output=T> + Copy> Neg for Vector<T>

Gets negative of vector.

type Output = Vector<T>

The resulting type after applying the - operator

fn neg(self) -> Vector<T>

The method for the unary - operator

impl<'a, T: Neg<Output=T> + Copy> Neg for &'a Vector<T>

Gets negative of vector.

type Output = Vector<T>

The resulting type after applying the - operator

fn neg(self) -> Vector<T>

The method for the unary - operator

impl<T> Index<usize> for Vector<T>

Indexes vector.

type Output = T

The returned type after indexing

fn index(&self, idx: usize) -> &T

The method for the indexing (Foo[Bar]) operation

impl<T: Float> Metric<T> for Vector<T>

fn norm(&self) -> T

Compute euclidean norm for vector.

Examples

use rulinalg::vector::Vector;
use rulinalg::Metric;

let a = Vector::new(vec![3.0,4.0]);
let c = a.norm();

assert_eq!(c, 5.0);

impl<T: Copy + Add<T, Output=T>> AddAssign<T> for Vector<T>

Performs addition assignment between a vector and a scalar.

fn add_assign(&mut self, _rhs: T)

The method for the += operator

impl<'a, T: Copy + Add<T, Output=T>> AddAssign<&'a T> for Vector<T>

Performs addition assignment between a vector and a scalar.

fn add_assign(&mut self, _rhs: &T)

The method for the += operator

impl<T: Copy + Sub<T, Output=T>> SubAssign<T> for Vector<T>

Performs subtraction assignment between a vector and a scalar.

fn sub_assign(&mut self, _rhs: T)

The method for the -= operator

impl<'a, T: Copy + Sub<T, Output=T>> SubAssign<&'a T> for Vector<T>

Performs subtraction assignment between a vector and a scalar.

fn sub_assign(&mut self, _rhs: &T)

The method for the -= operator

impl<T: Copy + Div<T, Output=T>> DivAssign<T> for Vector<T>

Performs division assignment between a vector and a scalar.

fn div_assign(&mut self, _rhs: T)

The method for the /= operator

impl<'a, T: Copy + Div<T, Output=T>> DivAssign<&'a T> for Vector<T>

Performs division assignment between a vector and a scalar.

fn div_assign(&mut self, _rhs: &T)

The method for the /= operator

impl<T: Copy + Mul<T, Output=T>> MulAssign<T> for Vector<T>

Performs multiplication assignment between a vector and a scalar.

fn mul_assign(&mut self, _rhs: T)

The method for the *= operator

impl<'a, T: Copy + Mul<T, Output=T>> MulAssign<&'a T> for Vector<T>

Performs multiplication assignment between a vector and a scalar.

fn mul_assign(&mut self, _rhs: &T)

The method for the *= operator

impl<T: Copy + Add<T, Output=T>> AddAssign<Vector<T>> for Vector<T>

Performs elementwise addition assignment between two vectors.

fn add_assign(&mut self, _rhs: Vector<T>)

The method for the += operator

impl<'a, T: Copy + Add<T, Output=T>> AddAssign<&'a Vector<T>> for Vector<T>

Performs elementwise addition assignment between two vectors.

fn add_assign(&mut self, _rhs: &Vector<T>)

The method for the += operator

impl<T: Copy + Sub<T, Output=T>> SubAssign<Vector<T>> for Vector<T>

Performs elementwise subtraction assignment between two vectors.

fn sub_assign(&mut self, _rhs: Vector<T>)

The method for the -= operator

impl<'a, T: Copy + Sub<T, Output=T>> SubAssign<&'a Vector<T>> for Vector<T>

Performs elementwise subtraction assignment between two vectors.

fn sub_assign(&mut self, _rhs: &Vector<T>)

The method for the -= operator