Struct mathru::algebra::linear::vector::vector::Vector

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

Implementations

impl<T> Vector<T>

pub fn iter(&self) -> VectorIterator<'_, T>

pub fn iter_mut(&mut self) -> VectorIteratorMut<'_, T>

impl<T> Vector<T> where
    T: Field + Scalar + Power, 

pub fn p_norm(&self, p: &T) -> T

Computes the p norm

Arguments

p >= 1.0

Panics

p < 1.0

Example

use mathru::algebra::linear::Vector;

let a: Vector<f64> = Vector::new_column(4, vec![1.0, 0.0, 3.0, -2.0]);
let p: f64 = 2.0;
let norm_ref: f64 = a.eucl_norm();
let norm: f64 = a.p_norm(&p);

assert_eq!(norm_ref, norm);

impl<T> Vector<T>

pub fn convert_to_vec(self) -> Vec<T>

impl<T> Vector<T> where
    T: Field + Scalar + Power + Exponential, 

pub fn eucl_norm(&self) -> T

Computes the euclidean norm

Example

use mathru::algebra::linear::Vector;

let a: Vector<f64> = Vector::new_column(4, vec![1.0, 0.0, 3.0, -2.0]);
let norm_ref: f64 = 3.7416573867739413;
let norm: f64 = a.eucl_norm();

assert_eq!(norm_ref, norm);

impl<T> Vector<T> where
    T: Clone + Copy, 

pub fn new_row(n: usize, data: Vec<T>) -> Self

Returns a row vector

Panics

n != data.len()

Example

use mathru::algebra::linear::Vector;

let a: Vector<f64> = Vector::new_row(4, vec![1.0, 0.0, 3.0, -2.0]);

pub fn new_column(m: usize, data: Vec<T>) -> Self

Returns a column vector

Panics

m != data.len()

Example

use mathru::algebra::linear::Vector;

let a: Vector<f64> = Vector::new_column(4, vec![1.0, 0.0, 3.0, -2.0]);

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

impl<T> Vector<T> where
    T: Scalar, 

pub fn new_row_random(n: usize) -> Self

Returns a row vector initialized with random numbers

Example

use mathru::algebra::linear::Vector;

let a: Vector<f64> = Vector::new_row_random(4);

pub fn new_column_random(m: usize) -> Self

Returns a column vector initialized with random numbers

Example

use mathru::algebra::linear::Vector;

let a: Vector<f64> = Vector::new_column_random(4);

impl<T> Vector<T> where
    T: Field + Scalar, 

pub fn transpose(self) -> Self

Returns the transposed vector

Example

use mathru::algebra::linear::Vector;

let a: Vector<f64> = Vector::new_column(4, vec![1.0, 0.0, 3.0, -2.0]);
let b: Vector<f64> = a.transpose();

impl<T> Vector<T> where
    T: Field + Scalar, 

pub fn dotp<'a, 'b>(&'a self, rhs: &'b Self) -> T

Computes the dot product of two vectors

Example

use mathru::algebra::linear::Vector;

let a: Vector<f64> = Vector::new_column(4, vec![1.0, 0.0, 3.0, -2.0]);
let b: Vector<f64> = Vector::new_column(4, vec![-1.0, 2.0, 3.0, 5.0]);
let dotp_ref: f64 = -2.0;

let dotp: f64 = a.dotp(&b);

assert_eq!(dotp_ref, dotp);

pub fn argmax(&self) -> usize

Find the argmax of the vector.

Returns the index of the largest value in the vector.

Examples

use mathru::algebra::linear::Vector;

let a = Vector::new_column(4, vec![1.0, 2.0, -3.0, 5.0]);
let idx = a.argmax();
assert_eq!(idx, 3);

pub fn argmin(&self) -> usize

Find the argmin of the vector.

Returns the index of the smallest value in the vector.

Examples

use mathru::algebra::linear::Vector;

let a = Vector::new_column(4, vec![1.0, -2.0, -6.0, 75.0]);
let b = a.argmin();
assert_eq!(b, 2);

impl<T> Vector<T> where
    T: Field + Scalar, 

pub fn dyadp(&self, rhs: &Self) -> Matrix<T>

Computes the dyadic product of two vectors

Example

use mathru::algebra::linear::{Matrix, Vector};

let a: Vector<f64> = Vector::new_row(4, vec![1.0, 0.0, 3.0, -2.0]);
let b: Vector<f64> = Vector::new_column(4, vec![-1.0, 2.0, 3.0, 5.0]);

let m: Matrix<f64> = a.dyadp(&b);

impl<T> Vector<T>

pub fn get_mut(&mut self, i: usize) -> &mut T

Returns the mutual component

Arguments

Panics

if i out of bounds

Example

use mathru::algebra::linear::Vector;

let mut a: Vector<f64> = Vector::new_row(4, vec![1.0, 0.0, 3.0, -2.0]);

*a.get_mut(1) = -4.0;

impl<T> Vector<T>

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

Returns the component

Panics

if i out of bounds

Example

use mathru::algebra::linear::Vector;

let mut a: Vector<f64> = Vector::new_row(4, vec![1.0, 0.0, 3.0, -2.0]);

assert_eq!(-2.0, *a.get_mut(3))

impl<T> Vector<T> where
    T: Field + Scalar + Power, 

pub fn reflector(&self) -> Vector<T>

impl<T> Vector<T> where
    T: Field + Scalar, 

pub fn zero(m: usize) -> Self

Returns the zero vector

Example

use mathru::algebra::linear::Vector;

let a: Vector<f64> = Vector::new_column(4, vec![0.0, 0.0, 0.0, 0.0]);
let b: Vector<f64> = Vector::zero(4);

assert_eq!(a, b)

impl<T> Vector<T> where
    T: Field + Scalar, 

pub fn one(m: usize) -> Self

Returns the one vector

Example

use mathru::algebra::linear::Vector;

let a: Vector<f64> = Vector::new_column(4, vec![1.0, 1.0, 1.0, 1.0]);
let b: Vector<f64> = Vector::one(4);

assert_eq!(a, b)

impl<T> Vector<T>

pub fn dim(&self) -> (usize, usize)

Returns the vector dimension

Example

use mathru::algebra::linear::Vector;

let a: Vector<f64> = Vector::new_column(4, vec![1.0, 2.0, 3.0, 4.0]);
let (m, n): (usize, usize) = a.dim();
assert_eq!(4, m);
assert_eq!(1, n);

impl<T> Vector<T> where
    T: Field + Scalar, 

pub fn get_slice(&self, s: usize, e: usize) -> Vector<T>

Returns a slice of the vector

Arugments

0 <= s < m
0 <= e < m

s: start
e: end

Panics

iff s and e are out of bounds

Example

use mathru::algebra::linear::Vector;

let mut a: Vector<f64> = Vector::new_column(4, vec![1.0, -2.0, 3.0, -7.0]);
a = a.get_slice(1, 2);

let a_ref: Vector<f64> = Vector::new_column(2, vec![-2.0, 3.0]);

assert_eq!(a_ref, a);

pub fn set_slice<'a>(&mut self, rhs: &Self, s: usize)

Overwrite a slice of the vector with the given values

Arugments

0 <= s < m

s: start

Example

use mathru::algebra::linear::Vector;

let mut a: Vector<f64> = Vector::new_column(4, vec![1.0, -2.0, 3.0, -7.0]);
let b: Vector<f64> = Vector::new_column(2, vec![-5.0, 4.0]);
a.set_slice(&b, 1);

let a_ref: Vector<f64> = Vector::new_column(4, vec![1.0, -5.0, 4.0, -7.0]);

assert_eq!(a_ref, a);

impl<T> Vector<T> where
    T: Field + Scalar, 

pub fn compare_neighbourhood(&self, b: &Self, epsilon: T) -> bool

Trait Implementations

impl AbsDiffEq<Vector<f32>> for Vector<f32>

type Epsilon = f32

Used for specifying relative comparisons.

pub fn default_epsilon() -> f32

The default tolerance to use when testing values that are close together.

pub fn abs_diff_eq(&self, other: &Vector<f32>, epsilon: f32) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

pub fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl AbsDiffEq<Vector<f64>> for Vector<f64>

type Epsilon = f64

Used for specifying relative comparisons.

pub fn default_epsilon() -> f64

The default tolerance to use when testing values that are close together.

pub fn abs_diff_eq(&self, other: &Vector<f64>, epsilon: f64) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

pub fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl<'a, T, '_> Add<&'_ T> for &'a Vector<T> where
    T: Field + Scalar, 

type Output = Vector<T>

The resulting type after applying the + operator.

pub fn add(self, rhs: &T) -> Self::Output

Adds a scalar to the vector

Example

use mathru::algebra::linear::Vector;

let a: Vector<f64> = Vector::new_column(4, vec![1.0, 2.0, 3.0, 4.0]);
let res_ref: Vector<f64> = Vector::new_column(4, vec![-4.0, -3.0, -2.0, -1.0]);

assert_eq!(res_ref, &a + &-5.0)

impl<'a, 'b, T> Add<&'b Vector<T>> for &'a Vector<T> where
    T: Field + Scalar, 

type Output = Vector<T>

The resulting type after applying the + operator.

pub fn add(self, rhs: &'b Vector<T>) -> Self::Output

Adds two vectors

Example

use mathru::algebra::linear::Vector;

let a: Vector<f64> = Vector::new_column(4, vec![1.0, 2.0, 3.0, 4.0]);
let b: Vector<f64> = Vector::new_column(4, vec![3.0, -4.0, 5.0, 4.0]);
let res_ref: Vector<f64> = Vector::new_column(4, vec![4.0, -2.0, 8.0, 8.0]);

assert_eq!(res_ref, &a + &b)

impl<T> Add<T> for Vector<T> where
    T: Field + Scalar, 

type Output = Vector<T>

The resulting type after applying the + operator.

pub fn add(self, rhs: T) -> Self::Output

Adds a scalar to the vector

Example

use mathru::algebra::linear::Vector;

let a: Vector<f64> = Vector::new_column(4, vec![1.0, 2.0, 3.0, 4.0]);
let res_ref: Vector<f64> = Vector::new_column(4, vec![-4.0, -3.0, -2.0, -1.0]);

assert_eq!(res_ref, a + -5.0)

impl<T> Add<Vector<T>> for Vector<T> where
    T: Field + Scalar, 

type Output = Vector<T>

The resulting type after applying the + operator.

pub fn add(self, rhs: Self) -> Self::Output

Adds two vectors

Example

use mathru::algebra::linear::Vector;

let a: Vector<f64> = Vector::new_column(4, vec![1.0, 2.0, 3.0, 4.0]);
let b: Vector<f64> = Vector::new_column(4, vec![3.0, -4.0, 5.0, 4.0]);
let res_ref: Vector<f64> = Vector::new_column(4, vec![4.0, -2.0, 8.0, 8.0]);

assert_eq!(res_ref, a + b)

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for Vector<T> where
    T: Deserialize<'de>, 

pub fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

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

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

Formats the value using the given formatter.

impl<'a, T, '_> Div<&'_ T> for &'a Vector<T> where
    T: Field + Scalar, 

type Output = Vector<T>

The resulting type after applying the / operator.

pub fn div(self, rhs: &T) -> Self::Output

Divides the elements of a vector with the scalar value

Example

use mathru::algebra::linear::Vector;

let a: Vector<f64> = Vector::new_column(4, vec![5.0, 10.0, 15.0, 20.0]);
let res_ref: Vector<f64> = Vector::new_column(4, vec![1.0, 2.0, 3.0, 4.0]);

assert_eq!(res_ref, a / 5.0)

impl<T> Div<T> for Vector<T> where
    T: Field + Scalar, 

type Output = Vector<T>

The resulting type after applying the / operator.

pub fn div(self, rhs: T) -> Self::Output

Divides the vector elements with scalar values

Example

use mathru::algebra::linear::Vector;

let a: Vector<f64> = Vector::new_column(4, vec![-5.0, -10.0, -15.0, -20.0]);
let res_ref: Vector<f64> = Vector::new_column(4, vec![1.0, 2.0, 3.0, 4.0]);

assert_eq!(res_ref, a / -5.0)

impl<T> From<Vector<T>> for Matrix<T> where
    T: Field + Scalar, 

pub fn from(v: Vector<T>) -> Self

Performs the conversion.

impl<T> IntoIterator for Vector<T> where
    T: Field + Scalar, 

type Item = T

The type of the elements being iterated over.

type IntoIter = VectorIntoIterator<T>

Which kind of iterator are we turning this into?

pub fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T, '_> Mul<&'_ T> for &'a Vector<T> where
    T: Field + Scalar, 

type Output = Vector<T>

The resulting type after applying the * operator.

pub fn mul(self, rhs: &T) -> Self::Output

Multiplies the vector elements with the scalar value

Example

use mathru::algebra::linear::Vector;

let a: Vector<f64> = Vector::new_column(4, vec![1.0, 2.0, 3.0, 4.0]);
let res_ref: Vector<f64> = Vector::new_column(4, vec![5.0, 10.0, 15.0, 20.0]);

assert_eq!(res_ref, a * 5.0)

impl<'a, 'b, T> Mul<&'b Matrix<T>> for &'a Vector<T> where
    T: Field + Scalar, 

type Output = Vector<T>

The resulting type after applying the * operator.

pub fn mul(self, rhs: &'b Matrix<T>) -> Self::Output

Performs the * operation.

impl<'a, 'b, T> Mul<&'b Vector<T>> for &'a Matrix<T> where
    T: Field + Scalar, 

Multiplies matrix by vector.

type Output = Vector<T>

The resulting type after applying the * operator.

pub fn mul(self, v: &'b Vector<T>) -> Vector<T>

Performs the * operation.

impl<T> Mul<Matrix<T>> for Vector<T> where
    T: Field + Scalar, 

type Output = Vector<T>

The resulting type after applying the * operator.

pub fn mul(self, rhs: Matrix<T>) -> Self::Output

Performs the * operation.

impl<T> Mul<T> for Vector<T> where
    T: Field + Scalar, 

type Output = Vector<T>

The resulting type after applying the * operator.

pub fn mul(self, rhs: T) -> Self::Output

Multiplies the vector elements with a scalar value

Example

use mathru::algebra::linear::Vector;

let a: Vector<f64> = Vector::new_column(4, vec![1.0, 2.0, 3.0, 4.0]);
let res_ref: Vector<f64> = Vector::new_column(4, vec![-5.0, -10.0, -15.0, -20.0]);

assert_eq!(res_ref, a * -5.0)

impl<T> Mul<Vector<T>> for Matrix<T> where
    T: Field + Scalar, 

type Output = Vector<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Neg for Vector<T> where
    T: Field + Scalar, 

type Output = Vector<T>

The resulting type after applying the - operator.

pub fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T> PartialEq<Vector<T>> for Vector<T> where
    T: Scalar, 

pub fn eq(&self, other: &Self) -> bool

Compares if two vectors are equal

Example

use mathru::algebra::linear::Vector;

let a: Vector<f64> = Vector::new_column(4, vec![0.0, 0.0, 0.0, 0.0]);
let b: Vector<f64> = Vector::zero(4);

assert_eq!(true, a.eq(&b))

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl RelativeEq<Vector<f32>> for Vector<f32>

pub fn default_max_relative() -> f32

The default relative tolerance for testing values that are far-apart.

pub fn relative_eq(
    &self,
    other: &Vector<f32>,
    epsilon: Self::Epsilon,
    max_relative: Self::Epsilon
) -> bool

A test for equality that uses a relative comparison if the values are far apart.

pub fn relative_ne(
    &self,
    other: &Rhs,
    epsilon: Self::Epsilon,
    max_relative: Self::Epsilon
) -> bool

The inverse of RelativeEq::relative_eq.

impl RelativeEq<Vector<f64>> for Vector<f64>

pub fn default_max_relative() -> f64

The default relative tolerance for testing values that are far-apart.

pub fn relative_eq(
    &self,
    other: &Vector<f64>,
    epsilon: Self::Epsilon,
    max_relative: Self::Epsilon
) -> bool

A test for equality that uses a relative comparison if the values are far apart.

pub fn relative_ne(
    &self,
    other: &Rhs,
    epsilon: Self::Epsilon,
    max_relative: Self::Epsilon
) -> bool

The inverse of RelativeEq::relative_eq.

impl<T> Serialize for Vector<T> where
    T: Serialize, 

pub fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl<T> Sign for Vector<T> where
    T: Field + Scalar, 

pub fn sign(&self) -> Self

Returns the sign of a number

pub fn abs(&self) -> Self

pub fn is_positive(&self) -> bool

pub fn is_negative(&self) -> bool

impl<T> Solve<Vector<T>> for LUDec<T> where
    T: Field + Scalar, 

pub fn solve(&self, rhs: &Vector<T>) -> Result<Vector<T>, ()>

Solves Ax = y where A \in R^{m * n}, x \in R^n, y \in R^m

impl<T> Solve<Vector<T>> for Matrix<T> where
    T: Field + Scalar, 

pub fn solve(&self, rhs: &Vector<T>) -> Result<Vector<T>, ()>

Solves Ax = y where A \in R^{m * n}, x \in R^n, y \in R^m

impl<'a, T, '_> Sub<&'_ T> for &'a Vector<T> where
    T: Field + Scalar, 

type Output = Vector<T>

The resulting type after applying the - operator.

pub fn sub(self, rhs: &T) -> Self::Output

Subtract a scalar from vector elements

Example

use mathru::algebra::linear::Vector;

let a: Vector<f64> = Vector::new_column(4, vec![1.0, 2.0, 3.0, 4.0]);
let res_ref: Vector<f64> = Vector::new_column(4, vec![-4.0, -3.0, -2.0, -1.0]);

assert_eq!(res_ref, a - 5.0)

impl<'a, 'b, T> Sub<&'b Vector<T>> for &'a Vector<T> where
    T: Field + Scalar, 

type Output = Vector<T>

The resulting type after applying the - operator.

pub fn sub(self, rhs: &'b Vector<T>) -> Self::Output

Subtracts two vectors

Example

use mathru::algebra::linear::Vector;

let a: Vector<f64> = Vector::new_column(4, vec![1.0, 2.0, 3.0, 4.0]);
let b: Vector<f64> = Vector::new_column(4, vec![3.0, -4.0, 5.0, 4.0]);
let res_ref: Vector<f64> = Vector::new_column(4, vec![-2.0, 6.0, -2.0, 0.0]);

assert_eq!(res_ref, &a - &b)

impl<T> Sub<T> for Vector<T> where
    T: Field + Scalar, 

type Output = Vector<T>

The resulting type after applying the - operator.

pub fn sub(self, rhs: T) -> Self::Output

Subtracts a scalar value from all vector elements

Example

use mathru::algebra::linear::Vector;

let a: Vector<f64> = Vector::new_column(4, vec![1.0, 2.0, 3.0, 4.0]);
let res_ref: Vector<f64> = Vector::new_column(4, vec![6.0, 7.0, 8.0, 9.0]);

assert_eq!(res_ref, a - -5.0)

impl<T> Sub<Vector<T>> for Vector<T> where
    T: Field + Scalar, 

type Output = Vector<T>

The resulting type after applying the - operator.

pub fn sub(self, rhs: Vector<T>) -> Self::Output

Subtracts two vectors

Example

use mathru::algebra::linear::Vector;

let a: Vector<f64> = Vector::new_column(4, vec![1.0, 2.0, 3.0, 4.0]);
let b: Vector<f64> = Vector::new_column(4, vec![3.0, -4.0, 5.0, 4.0]);
let res_ref: Vector<f64> = Vector::new_column(4, vec![-2.0, 6.0, -2.0, 0.0]);

assert_eq!(res_ref, a - b)

impl<T> Substitute<Vector<T>> for Matrix<T> where
    T: Field + Scalar, 

pub fn substitute_forward(&self, a: Vector<T>) -> Vector<T>

pub fn substitute_backward(&self, c: Vector<T>) -> Vector<T>