Struct LazyArray 

pub struct LazyArray<A, D>
where
    A: Clone + 'static,
    D: Dimension + 'static,
{
    pub concrete_data: Option<Array<A, D>>,
    pub shape: Vec<usize>,
    pub ops: Vec<LazyOp>,
    pub sources: Vec<Rc<dyn Any>>,
}

A lazy array that stores operations to be performed later

Fields

concrete_data: Option<Array<A, D>>

The underlying concrete array data (optional, may be None for derived arrays)

shape: Vec<usize>

The shape of the array

ops: Vec<LazyOp>

The operations to be performed

sources: Vec<Rc<dyn Any>>

The source arrays for this lazy array (for binary operations)

Implementations

impl<A, D> LazyArray<A, D>

where A: Clone + 'static, D: Dimension + 'static,

pub fn new(array: Array<A, D>) -> Self

Create a new lazy array from a concrete array

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

Create a new lazy array with a given shape but no concrete data

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

Alias for fromshape for consistency with existing usage

pub fn map<F, B>(&self, op: F) -> LazyArray<B, D>

where F: Fn(&A) -> B + 'static, B: Clone + 'static,

Add a unary operation to the lazy array - immediate evaluation version

pub fn zip_with<F, B, C>( &self, other: &LazyArray<B, D>, op: F, ) -> LazyArray<C, D>

where F: Fn(&A, &B) -> C + 'static, B: Clone + 'static, C: Clone + 'static,

Add a binary operation between this lazy array and another

pub fn reduce<F, B>(&self, op: F) -> LazyArray<B, IxDyn>

where F: Fn(&A) -> B + 'static, B: Clone + 'static,

Add a reduction operation to the lazy array

pub fn reshape(&self, shape: Vec<usize>) -> Self

Add a reshape operation to the lazy array

pub fn transpose(&self, axes: Vec<usize>) -> Self

Add a transpose operation to the lazy array

Trait Implementations

impl<A, D> Add for &LazyArray<A, D>

where A: Clone + Add<Output = A> + 'static, D: Dimension + 'static,

type Output = LazyArray<A, D>

The resulting type after applying the + operator.

fn add(self, other: &LazyArray<A, D>) -> Self::Output

Performs the + operation.

impl<A, D> Clone for LazyArray<A, D>

where A: Clone + 'static, D: Dimension + 'static,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A, D> Debug for LazyArray<A, D>

where A: Clone + Debug + 'static, D: Dimension + 'static,

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

Formats the value using the given formatter.

impl<A, D> Div for &LazyArray<A, D>

where A: Clone + Div<Output = A> + 'static, D: Dimension + 'static,

type Output = LazyArray<A, D>

The resulting type after applying the / operator.

fn div(self, other: &LazyArray<A, D>) -> Self::Output

Performs the / operation.

impl<A, D> Mul for &LazyArray<A, D>

where A: Clone + Mul<Output = A> + 'static, D: Dimension + 'static,

type Output = LazyArray<A, D>

The resulting type after applying the * operator.

fn mul(self, other: &LazyArray<A, D>) -> Self::Output

Performs the * operation.

impl<A, D> Sub for &LazyArray<A, D>

where A: Clone + Sub<Output = A> + 'static, D: Dimension + 'static,

type Output = LazyArray<A, D>

The resulting type after applying the - operator.

fn sub(self, other: &LazyArray<A, D>) -> Self::Output

Performs the - operation.