Struct Array 

pub struct Array<T> {
    pub data: Vec<T>,
    pub shape: Vec<usize>,
    pub strides: Vec<usize>,
}

Fields

data: Vec<T>

shape: Vec<usize>

strides: Vec<usize>

Implementations

impl<T: Clone + Default> Array<T>

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

Create an array from a vector with given shape

pub fn zeros(shape: Vec<usize>) -> Self

Create an array filled with zeros

pub fn ones(shape: Vec<usize>) -> Array<f64>

where T: Into<f64>,

Create an array filled with ones (for numeric types)

pub fn full(shape: Vec<usize>, fill_value: T) -> Self

Create array with given shape and fill value

pub fn arange(start: T, stop: T, step: T) -> Array<T>

where T: Num + PartialOrd + Copy,

Create array from range

pub fn ravel_index(&self, indices: &[usize]) -> usize

Convert multi-dimensional index to flat index

pub fn get(&self, indices: &[usize]) -> Option<&T>

Get element at multi-dimensional index

pub fn get_mut(&mut self, indices: &[usize]) -> Option<&mut T>

Get mutable element at mutli-dimensional index

pub fn reshape(&self, new_shape: Vec<usize>) -> Array<T>

Reshape array to new shape (must have same total size)

pub fn ndim(&self) -> usize

Get the number of dimensions

pub fn len(&self) -> usize

Get total number of elements

pub fn is_empty(&self) -> bool

Check if array is empty

pub fn size(&self) -> usize

Get array size (total elements)

pub fn transpose(&self) -> Array<T>

Transpose 2D array

impl Array<f64>

pub fn dot(&self, other: &Array<f64>) -> Array<f64>

Matrix multiplication (dot product)

pub fn det(&self) -> f64

Matrix determinant (2x2 and 3x3 only)

pub fn trace(&self) -> f64

Matrix trace (sum of diagonal elements)

pub fn inv(&self) -> Option<Array<f64>>

Matrix inverse (2x2 only for now)

pub fn qr(&self) -> (Array<f64>, Array<f64>)

QR decomposition (Gram-Schmidt process)

pub fn solve(&self, b: &Array<f64>) -> Option<Array<f64>>

Solve linear system Ax = b using QR decomposition

pub fn eig(&self) -> Option<(Array<f64>, Array<f64>)>

Compute eigenvalues and eigenvectors (2x2 only)

pub fn svd(&self) -> (Array<f64>, Array<f64>, Array<f64>)

Singular Value Decomposition (SVD) - simplified version for 2x2 matrices

pub fn norm(&self) -> f64

Compute matrix norm (Frobenius norm)

pub fn rank(&self, tolerance: Option<f64>) -> usize

Compute matrix rank (approximate, using SVD)

pub fn is_symmetric(&self, tolerance: Option<f64>) -> bool

Check if matrix is symmetric

pub fn is_orthogonal(&self, tolerance: Option<f64>) -> bool

Check if matrix is orthogonal

impl Array<f64>

pub fn shapes_broadcastable(shape1: &[usize], shape2: &[usize]) -> bool

Check if two shapes are broadcastable

pub fn broadcast_shapes( shape1: &[usize], shape2: &[usize], ) -> Option<Vec<usize>>

Compute the resulting shape after broadcasting

pub fn get_broadcasted(&self, indices: &[usize], target_shape: &[usize]) -> &f64

Get element with broadcasting

pub fn add_broadcast(&self, other: &Array<f64>) -> Option<Array<f64>>

Element-wise addition with broadcasting

pub fn sub_broadcast(&self, other: &Array<f64>) -> Option<Array<f64>>

Element-wise subtraction with broadcasting

pub fn mul_broadcast(&self, other: &Array<f64>) -> Option<Array<f64>>

Element-wise multiplication with broadcasting

pub fn div_broadcast(&self, other: &Array<f64>) -> Option<Array<f64>>

Element-wise division with broadcasting

pub fn unravel_index(flat_index: usize, shape: &[usize]) -> Vec<usize>

Convert flat index to multi-dimensional index

pub fn add_scalar(&self, scalar: f64) -> Array<f64>

Scalar operations

pub fn sub_scalar(&self, scalar: f64) -> Array<f64>

pub fn mul_scalar(&self, scalar: f64) -> Array<f64>

pub fn div_scalar(&self, scalar: f64) -> Array<f64>

pub fn sum(&self) -> f64

Reduction operations

pub fn sum_axis(&self, axis: usize) -> Array<f64>

pub fn mean(&self) -> f64

pub fn mean_axis(&self, axis: usize) -> Array<f64>

pub fn max(&self) -> f64

pub fn min(&self) -> f64

pub fn exp(&self) -> Array<f64>

Element-wise mathematical functions

pub fn ln(&self) -> Array<f64>

pub fn sin(&self) -> Array<f64>

pub fn cos(&self) -> Array<f64>

pub fn sqrt(&self) -> Array<f64>

pub fn pow(&self, exponent: f64) -> Array<f64>

Trait Implementations

impl Add<f64> for &Array<f64>

type Output = Array<f64>

The resulting type after applying the + operator.

fn add(self, scalar: f64) -> Self::Output

Performs the + operation.

impl Add for &Array<f64>

type Output = Array<f64>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Clone> Clone for Array<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Array<T>

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

Formats the value using the given formatter.

impl Div<f64> for &Array<f64>

type Output = Array<f64>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div for &Array<f64>

type Output = Array<f64>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Clone + Default> Index<&[usize]> for Array<T>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T: Clone + Default> Index<(usize, usize)> for Array<T>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T: Clone + Default> IndexMut<&[usize]> for Array<T>

fn index_mut(&mut self, indices: &[usize]) -> &mut Self::Output

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

impl<T: Clone + Default> IndexMut<(usize, usize)> for Array<T>

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

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

impl Mul<f64> for &Array<f64>

type Output = Array<f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul for &Array<f64>

type Output = Array<f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: PartialEq> PartialEq for Array<T>

fn eq(&self, other: &Array<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 Sub<f64> for &Array<f64>

type Output = Array<f64>

The resulting type after applying the - operator.

fn sub(self, scalar: f64) -> Self::Output

Performs the - operation.

impl Sub for &Array<f64>

type Output = Array<f64>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> StructuralPartialEq for Array<T>