Struct russell_lab::Vector

pub struct Vector { /* fields omitted */ }

Holds vector components and associated functions

Implementations

impl Vector

pub fn new(dim: usize) -> Self

Creates a new (zeroed) vector

Example

use russell_lab::*;
let u = Vector::new(3);
let correct = "┌   ┐\n\
               │ 0 │\n\
               │ 0 │\n\
               │ 0 │\n\
               └   ┘";
assert_eq!(format!("{}", u), correct);

pub fn filled(dim: usize, value: f64) -> Self

Creates new vector completely filled with the same value

Example

use russell_lab::*;
let u = Vector::filled(3, 4.0);
let correct = "┌   ┐\n\
               │ 4 │\n\
               │ 4 │\n\
               │ 4 │\n\
               └   ┘";
assert_eq!(format!("{}", u), correct);

pub fn from(data: &[f64]) -> Self

Creates a vector from data

Example

use russell_lab::*;
let u = Vector::from(&[1.0, 2.0, 3.0]);
let correct = "┌   ┐\n\
               │ 1 │\n\
               │ 2 │\n\
               │ 3 │\n\
               └   ┘";
assert_eq!(format!("{}", u), correct);

pub fn linspace(start: f64, stop: f64, count: usize) -> Self

Returns evenly spaced numbers over a specified closed interval

Example

use russell_lab::*;
let x = Vector::linspace(2.0, 3.0, 5);
let correct = "┌      ┐\n\
               │    2 │\n\
               │ 2.25 │\n\
               │  2.5 │\n\
               │ 2.75 │\n\
               │    3 │\n\
               └      ┘";
assert_eq!(format!("{}", x), correct);

pub fn dim(&self) -> usize

Returns the dimension (size) of this vector

Example

use russell_lab::*;
let u = Vector::from(&[1.0, 2.0, 3.0]);
assert_eq!(u.dim(), 3);

pub fn scale(&mut self, alpha: f64)

Scales this vector

u := alpha * u

Example

use russell_lab::*;
let mut u = Vector::from(&[1.0, 2.0, 3.0]);
u.scale(0.5);
let correct = "┌     ┐\n\
               │ 0.5 │\n\
               │   1 │\n\
               │ 1.5 │\n\
               └     ┘";
assert_eq!(format!("{}", u), correct);

pub fn fill(&mut self, value: f64)

Fills this vector with a given value

u[i] := value

Example

use russell_lab::*;
let mut u = Vector::new(3);
u.fill(8.8);
let correct = "┌     ┐\n\
               │ 8.8 │\n\
               │ 8.8 │\n\
               │ 8.8 │\n\
               └     ┘";
assert_eq!(format!("{}", u), correct);

pub fn as_data(&self) -> &Vec<f64>

Returns an access to the underlying data

Example

use russell_lab::*;
let u = Vector::from(&[1.0, 2.0, 3.0]);
assert_eq!(u.as_data(), &[1.0, 2.0, 3.0]);

pub fn as_mut_data(&mut self) -> &mut Vec<f64>

Returns a mutable access to the underlying data

Example

use russell_lab::*;
let mut u = Vector::from(&[1.0, 2.0, 3.0]);
let data = u.as_mut_data();
data[1] = 2.2;
assert_eq!(data, &[1.0, 2.2, 3.0]);

pub fn get(&self, i: usize) -> f64

Returns the i-th component

Example

use russell_lab::*;
let u = Vector::from(&[1.0, 2.0]);
assert_eq!(u.get(1), 2.0);

pub fn set(&mut self, i: usize, value: f64)

Change the i-th component

Example

use russell_lab::*;
let mut u = Vector::from(&[1.0, 2.0]);
u.set(1, -2.0);
let correct = "┌    ┐\n\
               │  1 │\n\
               │ -2 │\n\
               └    ┘";
assert_eq!(format!("{}", u), correct);

pub fn plus_equal(&mut self, i: usize, value: f64)

Executes the += operation on the i-th component

u_i += value

Example

use russell_lab::*;
let mut u = Vector::from(&[1.0, 2.0]);
u.plus_equal(1, 0.22);
let correct = "┌      ┐\n\
               │ 1.00 │\n\
               │ 2.22 │\n\
               └      ┘";
assert_eq!(format!("{:.2}", u), correct);

pub fn apply<F>(&mut self, function: F) where
    F: Fn(f64) -> f64, 

Applies a function over all components of this vector

u := apply(function(ui))

Example

use russell_lab::*;
let mut u = Vector::from(&[1.0, 2.0, 3.0]);
u.apply(|x| x * x);
let correct = "┌   ┐\n\
               │ 1 │\n\
               │ 4 │\n\
               │ 9 │\n\
               └   ┘";
assert_eq!(format!("{}", u), correct);

pub fn apply_with_index<F>(&mut self, function: F) where
    F: Fn(usize, f64) -> f64, 

Applies a function (with index) over all components of this vector

u := apply(function(i, ui))

Example

use russell_lab::*;
let mut u = Vector::from(&[1.0, 2.0, 3.0]);
u.apply_with_index(|i, x| x * x + (i as f64));
let correct = "┌    ┐\n\
               │  1 │\n\
               │  5 │\n\
               │ 11 │\n\
               └    ┘";
assert_eq!(format!("{}", u), correct);

pub fn get_copy(&self) -> Self

Returns a copy of this vector

Example

use russell_lab::*;
let mut u = Vector::from(&[1.0, 2.0, 3.0]);
let u_copy = u.get_copy();
u.set(1, 5.0);
let u_correct = "┌   ┐\n\
                 │ 1 │\n\
                 │ 5 │\n\
                 │ 3 │\n\
                 └   ┘";
let u_copy_correct = "┌   ┐\n\
                      │ 1 │\n\
                      │ 2 │\n\
                      │ 3 │\n\
                      └   ┘";
assert_eq!(format!("{}", u), u_correct);
assert_eq!(format!("{}", u_copy), u_copy_correct);

pub fn norm(&self, kind: EnumVectorNorm) -> f64

Returns the vector norm

Computes one of:

One:  1-norm (taxicab or sum of abs values)

      ‖u‖_1 := sum_i |uᵢ|

Euc:  Euclidean-norm

      ‖u‖_2 = sqrt(Σ_i uᵢ⋅uᵢ)

Max:  max-norm (inf-norm)

      ‖u‖_max = max_i ( |uᵢ| ) == ‖u‖_∞

Example

use russell_lab::*;
let u = Vector::from(&[2.0, -2.0, 2.0, -2.0, -3.0]);
assert_eq!(u.norm(EnumVectorNorm::One), 11.0);
assert_eq!(u.norm(EnumVectorNorm::Euc), 5.0);
assert_eq!(u.norm(EnumVectorNorm::Max), 3.0);

Trait Implementations

impl Display for Vector

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

Formats the value using the given formatter.