Struct DynVector 

pub struct DynVector<T> { /* private fields */ }

Dynamically-sized vector (wraps a 1×N DynMatrix).

Enforces single-row constraint and provides single-index access v[i].

Examples

use numeris::DynVector;

let v = DynVector::from_slice(&[1.0_f64, 2.0, 3.0]);
assert_eq!(v[0], 1.0);
assert_eq!(v.len(), 3);
assert!((v.dot(&v) - 14.0).abs() < 1e-12);

Implementations

impl<T: Scalar> DynVector<T>

pub fn norm_squared(&self) -> T

Squared L2 norm (dot product with self).

use numeris::DynVector;
let v = DynVector::from_slice(&[3.0, 4.0]);
assert_eq!(v.norm_squared(), 25.0);

impl<T: LinalgScalar> DynVector<T>

pub fn norm(&self) -> T::Real

L2 (Euclidean) norm.

use numeris::DynVector;
let v = DynVector::from_slice(&[3.0_f64, 4.0]);
assert!((v.norm() - 5.0).abs() < 1e-12);

pub fn norm_l1(&self) -> T::Real

L1 norm (sum of absolute values / moduli).

use numeris::DynVector;
let v = DynVector::from_slice(&[1.0_f64, -2.0, 3.0]);
assert!((v.norm_l1() - 6.0).abs() < 1e-12);

pub fn normalize(&self) -> Self

Return a unit vector in the same direction.

Panics if the norm is zero.

use numeris::DynVector;
let v = DynVector::from_slice(&[3.0_f64, 4.0]);
let u = v.normalize();
assert!((u.norm() - 1.0).abs() < 1e-12);
assert!((u[0] - 0.6).abs() < 1e-12);

impl<T: Scalar> DynVector<T>

pub fn from_slice(data: &[T]) -> Self

Create a vector from a flat slice.

use numeris::DynVector;
let v = DynVector::from_slice(&[1.0, 2.0, 3.0]);
assert_eq!(v[0], 1.0);
assert_eq!(v.len(), 3);

pub fn from_vec(data: Vec<T>) -> Self

Create a vector from an owned Vec.

use numeris::DynVector;
let v = DynVector::from_vec(vec![1.0, 2.0, 3.0]);
assert_eq!(v[2], 3.0);

pub fn zeros(n: usize, _zero: T) -> Self

Create a zero vector of length n.

use numeris::DynVector;
let v = DynVector::zeros(4, 0.0_f64);
assert_eq!(v.len(), 4);
assert_eq!(v[3], 0.0);

pub fn fill(n: usize, value: T) -> Self

Create a vector filled with a value.

pub fn len(&self) -> usize

Number of elements.

pub fn is_empty(&self) -> bool

Whether the vector is empty.

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

Dot product.

use numeris::DynVector;
let a = DynVector::from_slice(&[1.0, 2.0, 3.0]);
let b = DynVector::from_slice(&[4.0, 5.0, 6.0]);
assert_eq!(a.dot(&b), 32.0);

pub fn cast<U: Scalar + NumCast>(&self) -> DynVector<U>

where T: ToPrimitive,

Cast every element to a different numeric type.

use numeris::DynVector;
let v = DynVector::from_slice(&[1.0_f64, 2.0, 3.0]);
let v32: DynVector<f32> = v.cast();
assert_eq!(v32[0], 1.0_f32);

pub fn as_slice(&self) -> &[T]

View the vector data as a slice.

pub fn as_mut_slice(&mut self) -> &mut [T]

View the vector data as a mutable slice.

Trait Implementations

impl<T: Clone> Clone for DynVector<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for DynVector<T>

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

Formats the value using the given formatter.

impl<T: Scalar> From<&DynVector<T>> for DynMatrix<T>

fn from(v: &DynVector<T>) -> Self

Converts to this type from the input type.

impl<T: Scalar, const N: usize> From<&Matrix<T, 1, N>> for DynVector<T>

fn from(v: &Vector<T, N>) -> Self

Converts to this type from the input type.

impl<T: Scalar> From<DynVector<T>> for DynMatrix<T>

fn from(v: DynVector<T>) -> Self

Converts to this type from the input type.

impl<T: Scalar, const N: usize> From<Matrix<T, 1, N>> for DynVector<T>

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

Convert a fixed-size Vector into a DynVector.

use numeris::{Vector, DynVector};
let v = Vector::from_array([1.0, 2.0, 3.0]);
let dv: DynVector<f64> = v.into();
assert_eq!(dv.len(), 3);
assert_eq!(dv[0], 1.0);

impl<T> Index<usize> for DynVector<T>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> IndexMut<usize> for DynVector<T>

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

Performs the mutable indexing (container[index]) operation.

impl<T> MatrixMut<T> for DynVector<T>

fn get_mut(&mut self, row: usize, col: usize) -> &mut T

Mutable reference to the element at (row, col).

fn col_as_mut_slice(&mut self, col: usize, row_start: usize) -> &mut [T]

Mutable contiguous slice of column col from row row_start to end.

impl<T> MatrixRef<T> for DynVector<T>

fn nrows(&self) -> usize

Number of rows.

fn ncols(&self) -> usize

Number of columns.

fn get(&self, row: usize, col: usize) -> &T

Reference to the element at (row, col).

fn col_as_slice(&self, col: usize, row_start: usize) -> &[T]

Contiguous slice of column col from row row_start to end.

impl<T: PartialEq> PartialEq for DynVector<T>

fn eq(&self, other: &DynVector<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> StructuralPartialEq for DynVector<T>