Struct Vector 

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

A 1D vector of floating-point values.

Examples

use aprender::primitives::Vector;

let v = Vector::from_slice(&[1.0, 2.0, 3.0]);
assert_eq!(v.len(), 3);
assert!((v.sum() - 6.0).abs() < 1e-6);

Implementations

impl<T: Copy> Vector<T>

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

Creates a new vector from a slice.

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

Creates a new vector from a Vec.

pub fn len(&self) -> usize

Returns the number of elements.

pub fn is_empty(&self) -> bool

Returns true if the vector is empty.

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

Returns a slice of the underlying data.

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

Returns a mutable slice of the underlying data.

pub fn slice(&self, start: usize, end: usize) -> Self

Returns a slice from start to end indices.

impl Vector<f32>

pub fn zeros(len: usize) -> Self

Creates a vector of zeros.

pub fn ones(len: usize) -> Self

Creates a vector of ones.

pub fn sum(&self) -> f32

Computes the sum of all elements.

pub fn mean(&self) -> f32

Computes the mean of all elements.

pub fn dot(&self, other: &Self) -> f32

Computes the dot product with another vector.

Panics

Panics if vectors have different lengths.

pub fn add_scalar(&self, scalar: f32) -> Self

Adds a scalar to each element.

pub fn mul_scalar(&self, scalar: f32) -> Self

Multiplies each element by a scalar.

pub fn norm_squared(&self) -> f32

Computes the squared L2 norm.

pub fn norm(&self) -> f32

Computes the L2 norm.

pub fn argmin(&self) -> usize

Returns the index of the minimum element.

pub fn argmax(&self) -> usize

Returns the index of the maximum element.

pub fn variance(&self) -> f32

Computes variance of all elements.

pub fn std(&self) -> f32

Computes standard deviation of all elements.

Standard deviation is the square root of variance.

Examples

use aprender::primitives::Vector;

let v = Vector::from_slice(&[1.0, 2.0, 3.0, 4.0, 5.0]);
let std = v.std();
assert!((std - 1.414).abs() < 0.01);

pub fn gini_coefficient(&self) -> f32

Computes Gini coefficient (inequality measure).

The Gini coefficient measures inequality in a distribution. Formula: G = Σ Σ |x_i - x_j| / (2n² * mean)

Returns

• 0.0: Perfect equality (all values are the same)
• 1.0: Maximum inequality (one value has everything)

Examples

use aprender::primitives::Vector;

// Perfect equality
let v = Vector::from_slice(&[5.0, 5.0, 5.0]);
assert!((v.gini_coefficient() - 0.0).abs() < 0.01);

// Some inequality
let v = Vector::from_slice(&[1.0, 2.0, 3.0, 4.0, 5.0]);
let gini = v.gini_coefficient();
assert!(gini > 0.0 && gini < 1.0);

Trait Implementations

impl Add for &Vector<f32>

type Output = Vector<f32>

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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

type Output = T

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

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

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

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

impl Mul for &Vector<f32>

type Output = Vector<f32>

The resulting type after applying the * operator.

fn mul(self, other: Self) -> Self::Output

Performs the * operation.

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

fn eq(&self, other: &Vector<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> Serialize for Vector<T>

where T: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub for &Vector<f32>

type Output = Vector<f32>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> StructuralPartialEq for Vector<T>