Struct Array 

pub struct Array<T: DTypeValue = f32> {
    pub shape: Vec<usize>,
    pub dtype: DType,
    pub data: Vec<T>,
    pub strides: Option<Vec<isize>>,
    pub offset: usize,
}

A lightweight n-dimensional array with generic dtype support.

Arrays are memory contiguous (row-major) and can hold different data types. The type parameter T must implement DTypeValue trait.

Arrays now support zero-copy views with strides and offset:

• strides: Step size in each dimension (None = C-contiguous)
• offset: Starting offset in data buffer (0 = start at beginning)

Fields

shape: Vec<usize>

dtype: DType

data: Vec<T>

strides: Option<Vec<isize>>

Strides for each dimension (None = C-contiguous layout)

offset: usize

Offset into data buffer for view (0 = no offset)

Implementations

impl<T: DTypeValue> Array<T>

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

Create a new array given a shape and a flat data vector. The dtype is automatically inferred from type T.

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

Create a new array with implicit type conversion from any DTypeValue.

This allows you to create arrays with automatic casting from input data to the target dtype using the promotion engine.

Examples

use numrs::Array;

// Create f32 array from i32 data - automatic conversion
let arr = Array::<f32>::from_vec(vec![3], vec![1i32, 2, 3]);
assert_eq!(arr.data, vec![1.0f32, 2.0, 3.0]);

// Create i32 array from f32 data - automatic conversion
let arr = Array::<i32>::from_vec(vec![2], vec![1.5f32, 2.7]);
assert_eq!(arr.data, vec![1, 2]);

pub fn to_f32(&self) -> Array<f32>

Helper to convert any array to f32 (useful for tests and interoperability)

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

Create an array initialized with zeros for a shape.

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

Create an array initialized with ones.

pub fn shape(&self) -> &[usize]

Return shape as a slice

pub fn dtype(&self) -> DType

Return the dtype of this array

pub fn len(&self) -> usize

Helper to get length

pub fn is_contiguous(&self) -> bool

Check if array is C-contiguous (no custom strides)

pub fn compute_default_strides(&self) -> Vec<isize>

Compute C-contiguous strides for current shape

pub fn get_strides(&self) -> Vec<isize>

Get effective strides (either custom or computed default)

pub fn broadcast_view(&self, target_shape: &[usize]) -> Result<Self>

Create a broadcast view without copying data

This creates a zero-copy view that logically broadcasts the array to a new shape by adjusting strides (setting stride to 0 for broadcast dims).

Arguments

• target_shape - The shape to broadcast to

Returns

A new Array that shares the same data but appears to have the target shape

pub fn to_contiguous(&self) -> Self

Materialize a view into a contiguous array

If the array is already contiguous, returns a clone. Otherwise, creates a new contiguous array with the data arranged properly.

pub fn to_hlo_const(&self) -> HloNode

Build an HLO graph node representing a constant array

Trait Implementations

impl Add<&Array> for Array

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

Addition: a + &b

type Output = Array

The resulting type after applying the + operator.

impl Add<Array> for &Array

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

Addition: &a + b

type Output = Array

The resulting type after applying the + operator.

impl Add for &Array

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

Addition: &a + &b (most common, avoids moves)

type Output = Array

The resulting type after applying the + operator.

impl Add for Array

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

Addition: a + b

type Output = Array

The resulting type after applying the + operator.

impl<T: Clone + DTypeValue> 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 + DTypeValue> Debug for Array<T>

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

Formats the value using the given formatter.

impl Div<&Array> for Array

type Output = Array

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Array> for &Array

type Output = Array

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div for &Array

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

Element-wise division: &a / &b

type Output = Array

The resulting type after applying the / operator.

impl Div for Array

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

Element-wise division: a / b

type Output = Array

The resulting type after applying the / operator.

impl From<Array<bool>> for DynArray

fn from(arr: Array<bool>) -> Self

Converts to this type from the input type.

impl From<Array<f64>> for DynArray

fn from(arr: Array<f64>) -> Self

Converts to this type from the input type.

impl From<Array<i32>> for DynArray

fn from(arr: Array<i32>) -> Self

Converts to this type from the input type.

impl From<Array<i8>> for DynArray

fn from(arr: Array<i8>) -> Self

Converts to this type from the input type.

impl From<Array<u8>> for DynArray

fn from(arr: Array<u8>) -> Self

Converts to this type from the input type.

impl From<Array> for DynArray

fn from(arr: Array<f32>) -> Self

Converts to this type from the input type.

impl Mul<&Array> for Array

type Output = Array

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Array> for &Array

type Output = Array

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul for &Array

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

Element-wise multiplication: &a * &b

type Output = Array

The resulting type after applying the * operator.

impl Mul for Array

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

Element-wise multiplication: a * b

type Output = Array

The resulting type after applying the * operator.

impl Neg for &Array

fn neg(self) -> Self::Output

Negation: -&a

type Output = Array

The resulting type after applying the - operator.

impl Neg for Array

fn neg(self) -> Self::Output

Negation: -a

type Output = Array

The resulting type after applying the - operator.

impl Sub<&Array> for Array

type Output = Array

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Array> for &Array

type Output = Array

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub for &Array

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

Subtraction: &a - &b

type Output = Array

The resulting type after applying the - operator.

impl Sub for Array

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

Subtraction: a - b

type Output = Array

The resulting type after applying the - operator.

impl TryFrom<DynArray> for Array<f32>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(dyn_arr: DynArray) -> Result<Self>

Performs the conversion.

impl TryFrom<DynArray> for Array<bool>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(dyn_arr: DynArray) -> Result<Self>

Performs the conversion.

impl TryFrom<DynArray> for Array<f64>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(dyn_arr: DynArray) -> Result<Self>

Performs the conversion.

impl TryFrom<DynArray> for Array<i32>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(dyn_arr: DynArray) -> Result<Self>

Performs the conversion.

impl TryFrom<DynArray> for Array<i8>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(dyn_arr: DynArray) -> Result<Self>

Performs the conversion.

impl TryFrom<DynArray> for Array<u8>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(dyn_arr: DynArray) -> Result<Self>

Performs the conversion.