Struct ohsl::vector::Vector

pub struct Vector<T> {
    pub vec: Vec<T>,
    // some fields omitted
}

Fields

vec: Vec<T>

Implementations

impl<T> Vector<T>

pub const fn empty() -> Self

Create a new vector of unspecified size

pub fn create(vec: Vec<T>) -> Self

Create a vector from an std::vec::Vec

pub fn size(&self) -> usize

Return the size of the vector

pub fn clear(&mut self)

Remove all of the element from the vector

pub fn swap(&mut self, i: usize, j: usize)

Swap elements two elements in the vector

pub fn push(&mut self, elem: T)

Push a new element onto the end of the vector

pub fn insert(&mut self, pos: usize, new_elem: T)

Insert a new element into the Vector at a specified position

pub fn pop(&mut self) -> T

Remove the last element from the vector and return it

impl<T: PartialEq> Vector<T>

pub fn find(&self, value: T) -> usize

Return the index of the first element in the Vector equal to a given value

impl<T: Clone> Vector<T>

pub fn new(size: usize, elem: T) -> Self

Create a new vector of specified size

pub fn assign(&mut self, elem: T)

Assign a value to every element in the vector

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

pub fn zeros(size: usize) -> Self

Create a vector of zeros

pub fn ones(size: usize) -> Self

Create a vector of ones

impl<T: Default> Vector<T>

pub fn resize(&mut self, new_size: usize)

Resize the vector

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

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

Return the dot product of two vectors v.dot(w)

pub fn sum(&self) -> T

Return the sum of all the elements in the vector

pub fn sum_slice(&self, start: usize, end: usize) -> T

Return the sum of the elements in the vector from index start to end

pub fn product(&self) -> T

Return the product of all the elements in the vector

pub fn product_slice(&self, start: usize, end: usize) -> T

Return the product of the elements in the vector from index start to end

impl<T: Display> Vector<T>

pub fn output(&self, filename: &str)

Print the vector to a file

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

pub fn abs(&self) -> Self

Return a vector containing the absolute values of the elements

pub fn norm_1(&self) -> T

Return the L1 norm: sum of absolute values

impl<T: Clone + Signed> Vector<Complex<T>>

pub fn conj(&self) -> Self

Return a vector containing the complex conjugate of the elements

impl<T: Clone + Number> Vector<Complex<T>>

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

Return a vector containing the real parts of a vector of complex numbers

impl Vector<f64>

pub fn linspace(a: f64, b: f64, size: usize) -> Self

Create a linearly spaced vector of f64 with n elements with lower limit a and upper limit b

pub fn powspace(a: f64, b: f64, size: usize, p: f64) -> Self

Create a nonuniform vector of f64 with n elements with lower limit a, upper limit b and exponent p (p=1 -> linear)

pub fn norm_2(&self) -> f64

Return the L2 norm: square root of the sum of the squares

pub fn norm_p(&self, p: f64) -> f64

Return the Lp norm: p-th root of the sum of the absolute values raised to the power p

pub fn norm_inf(&self) -> f64

Return the Inf norm: largest absolute value element (p -> infinity)

pub fn random(size: usize) -> Self

pub fn dotf64(&self, w: &Vector<f64>) -> f64

Return the dot product of two vectors v.dot(w)

impl<T: Ord + PartialEq + PartialOrd> Vector<T>

pub fn sort(&mut self)

Sort the Vector of elements

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

pub fn sort_by<F>(&mut self, compare: F) where
    F: FnMut(&T, &T) -> Ordering, 

Sort the Vector of elements using a comparison function

Trait Implementations

impl<T: Clone + Number> Add<Vector<T>> for Vector<T>

type Output = Self

The resulting type after applying the + operator.

fn add(self, plus: Self) -> Self::Output

Add the elements of two vectors together ( binary + )

impl<T: Clone + Number> AddAssign<T> for Vector<T>

fn add_assign(&mut self, rhs: T)

Add the same value to every element in a mutable vector

impl<T: Clone + Number> AddAssign<Vector<T>> for Vector<T>

fn add_assign(&mut self, rhs: Self)

Add a vector to a mutable vector and assign the result ( += )

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

fn clone(&self) -> Self

Clone the vector

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

Performs copy-assignment from source.

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

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

Format the output [ v_0, v_1, ... ]

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

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

Format the output [ v_0, v_1, ... ]

impl<T: Clone + Number> Div<T> for Vector<T>

type Output = Self

The resulting type after applying the / operator.

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

Divide a vector by a scalar (vector / scalar)

impl<T: Clone + Number> DivAssign<T> for Vector<T>

fn div_assign(&mut self, rhs: T)

Divide every element in a mutable vector by a scalar

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

type Output = T

The returned type after indexing.

fn index<'a>(&'a self, index: usize) -> &'a T

Indexing operator [] (read only)

impl<T> IndexMut<usize> for Vector<T>

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

Indexing operator [] (read/write)

impl<T: Clone + Number> Mul<T> for Vector<T>

type Output = Self

The resulting type after applying the * operator.

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

Multiply a vector by a scalar (vector * scalar)

impl<T: Clone + Number> Mul<Vector<T>> for Matrix<T>

type Output = Vector<T>

The resulting type after applying the * operator.

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

Multiply a matrix with a (column) vector ( matrix * vector )

impl<T: Clone + Number> MulAssign<T> for Vector<T>

fn mul_assign(&mut self, rhs: T)

Multiply every element in a mutable vector by a scalar

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

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Return the unary negation ( unary - ) of each element

impl<T: Clone + Number> Sub<Vector<T>> for Vector<T>

type Output = Self

The resulting type after applying the - operator.

fn sub(self, minus: Self) -> Self::Output

Subtract the elements of one vector from another ( binary - )

impl<T: Clone + Number> SubAssign<T> for Vector<T>

fn sub_assign(&mut self, rhs: T)

Subtract the same value from every element in a mutable vector

impl<T: Clone + Number> SubAssign<Vector<T>> for Vector<T>

fn sub_assign(&mut self, rhs: Self)

Substract a vector from a mutable vector and assign the result ( -= )