Struct ha_ndarray::ArrayBase

pub struct ArrayBase<Buf> { /* private fields */ }

Implementations

impl<Buf> ArrayBase<Buf>

pub fn into_inner(self) -> Buf

impl<T: CDatatype> ArrayBase<Vec<T>>

pub fn new(shape: Shape, data: Vec<T>) -> Result<Self, Error>

pub fn with_context( context: Context, shape: Shape, data: Vec<T> ) -> Result<Self, Error>

Examples found in repository

examples/benchmarks.rs (lines 15-19)

fn broadcast_and_multiply(context: &Context) -> Result<(), Error> {
    for m in 0..4 {
        let dim = 10usize.pow(m);
        let shape = vec![3, dim, 5, 10];
        let size = shape.iter().product::<usize>();
        let queue = Queue::new(context.clone(), size)?;

        let left = ArrayBase::<Vec<_>>::with_context(
            context.clone(),
            vec![dim, 5, 10],
            vec![1.0f64; dim * 5 * 10],
        )?;

        let right = ArrayBase::<Vec<_>>::with_context(
            context.clone(),
            vec![3, dim, 1, 10],
            vec![1.0f64; 3 * dim * 10],
        )?;

        println!(
            "broadcast and multiply {:?} and {:?} (size {})...",
            left, right, size
        );

        let product = left.broadcast(shape.to_vec())? * right.broadcast(shape)?;

        for _ in 0..ITERATIONS {
            let start = Instant::now();
            product.read(&queue)?;
            let duration = start.elapsed();
            println!("{:?} us", duration.as_micros());
        }
    }

    Ok(())
}

fn matmul(context: &Context) -> Result<(), Error> {
    for m in 1..16usize {
        let dim = 2usize.pow(m as u32);

        let l = ArrayBase::<Vec<_>>::with_context(
            context.clone(),
            vec![16 * m, dim],
            vec![1.0f32; 16 * m * dim],
        )?;

        let r = ArrayBase::<Vec<_>>::with_context(
            context.clone(),
            vec![dim, m * 32],
            vec![1.0f32; dim * m * 32],
        )?;

        let num_ops = 16 * 32 * dim;
        println!("matmul {:?} with {:?} ({} ops)", l, r, num_ops);

        let x = l.matmul(r)?;
        let queue = Queue::new(context.clone(), x.size())?;

        for _ in 0..ITERATIONS {
            let start = Instant::now();
            let _output = x.read(&queue)?;
            let duration = start.elapsed();
            let rate = num_ops as f32 / duration.as_secs_f32();
            println!("{:?} us @ {} M/s", duration.as_micros(), rate / 1_000_000.);
        }
    }

    Ok(())
}

fn reduce_sum_axis(context: &Context) -> Result<(), Error> {
    let shape = vec![10, 20, 30, 40, 50];
    let size = shape.iter().product();
    let queue = Queue::new(context.clone(), size)?;
    let x = ArrayBase::<Vec<_>>::with_context(context.clone(), shape, vec![1; size])?;

    println!("reduce axis {} of {:?} (size {})", 2, x, x.size());

    let reduced = x.sum(vec![2], false)?;

    for _ in 0..ITERATIONS {
        let start = Instant::now();
        let _output = reduced.read(&queue)?;
        let duration = start.elapsed();
        println!("{:?} ms", duration.as_millis());
    }

    Ok(())
}

fn reduce_sum_all(context: &Context) -> Result<(), Error> {
    for m in 2..8 {
        let shape = (1..m).map(|dim| dim * 10).collect::<Vec<usize>>();
        let size = shape.iter().product();
        let x = ArrayBase::<Arc<Vec<_>>>::with_context(
            context.clone(),
            shape,
            Arc::new(vec![1; size]),
        )?;

        println!("reduce {:?} (size {})...", x, x.size());

        for _ in 0..ITERATIONS {
            let start = Instant::now();
            let _x = x.clone().sum_all()?;
            let duration = start.elapsed();
            println!("{:?} us", duration.as_micros());
        }
    }

    Ok(())
}

fn transpose(context: &Context) -> Result<(), Error> {
    let shape = vec![10, 20, 30, 40, 50];
    let size = shape.iter().product();
    let permutation = vec![2, 4, 3, 0, 1];

    let queue = Queue::new(context.clone(), size)?;
    let x = ArrayBase::<Vec<_>>::with_context(context.clone(), shape, vec![1; size])?;

    println!("transpose axes {permutation:?} of {x:?}...");

    let transposed = x.transpose(Some(permutation))?;
    for _ in 0..ITERATIONS {
        let start = Instant::now();
        transposed.read(&queue)?;
        let duration = start.elapsed();
        println!("{:?} ms", duration.as_millis());
    }

    Ok(())
}

impl<T: CDatatype> ArrayBase<Arc<Vec<T>>>

pub fn new(shape: Shape, data: Arc<Vec<T>>) -> Result<Self, Error>

pub fn with_context( context: Context, shape: Shape, data: Arc<Vec<T>> ) -> Result<Self, Error>

Examples found in repository

examples/benchmarks.rs (lines 103-107)

fn reduce_sum_all(context: &Context) -> Result<(), Error> {
    for m in 2..8 {
        let shape = (1..m).map(|dim| dim * 10).collect::<Vec<usize>>();
        let size = shape.iter().product();
        let x = ArrayBase::<Arc<Vec<_>>>::with_context(
            context.clone(),
            shape,
            Arc::new(vec![1; size]),
        )?;

        println!("reduce {:?} (size {})...", x, x.size());

        for _ in 0..ITERATIONS {
            let start = Instant::now();
            let _x = x.clone().sum_all()?;
            let duration = start.elapsed();
            println!("{:?} us", duration.as_micros());
        }
    }

    Ok(())
}

impl<T: CDatatype> ArrayBase<Buffer<T>>

pub fn new(shape: Shape, data: Buffer<T>) -> Result<Self, Error>

pub fn with_context( context: Context, shape: Shape, data: Buffer<T> ) -> Result<Self, Error>

impl<T: CDatatype> ArrayBase<Arc<Buffer<T>>>

pub fn new(shape: Shape, data: Arc<Buffer<T>>) -> Result<Self, Error>

pub fn with_context( context: Context, shape: Shape, data: Arc<Buffer<T>> ) -> Result<Self, Error>

impl<T: CDatatype> ArrayBase<Arc<RwLock<Vec<T>>>>

pub fn new(shape: Shape, data: Vec<T>) -> Result<Self, Error>

pub fn with_context( context: Context, shape: Shape, data: Vec<T> ) -> Result<Self, Error>

impl<T: CDatatype> ArrayBase<Arc<RwLock<Buffer<T>>>>

pub fn new(shape: Shape, data: Buffer<T>) -> Result<Self, Error>

pub fn with_context( context: Context, shape: Shape, data: Buffer<T> ) -> Result<Self, Error>

impl<T: CDatatype> ArrayBase<Vec<T>>

pub fn copy<O: NDArrayRead<DType = T>>(other: &O) -> Result<Self, Error>

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

impl<T: CDatatype> ArrayBase<Arc<Vec<T>>>

pub fn copy<O: NDArrayRead<DType = T>>(other: &O) -> Result<Self, Error>

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

impl<T: CDatatype> ArrayBase<Arc<RwLock<Vec<T>>>>

pub fn copy<O: NDArrayRead<DType = T>>(other: &O) -> Result<Self, Error>

impl<T: CDatatype> ArrayBase<Buffer<T>>

pub fn copy<O: NDArrayRead<DType = T>>(other: &O) -> Result<Self, Error>

Examples found in repository

examples/backprop.rs (line 32)

fn main() -> Result<(), Error> {
    let context = Context::default()?;
    let weights = RandomNormal::with_context(context.clone(), 2)?;
    let weights = ArrayOp::new(vec![2, 1], weights) - 0.5;
    let mut weights = ArrayBase::<Arc<RwLock<Buffer<f32>>>>::copy(&weights)?;

    let inputs = RandomUniform::with_context(context, vec![NUM_EXAMPLES, 2])?;
    let inputs = ArrayOp::new(vec![NUM_EXAMPLES, 2], inputs) * 2.;
    let inputs = ArrayBase::<Arc<Buffer<f32>>>::copy(&inputs)?;

    let inputs_bool = inputs.clone().lt_scalar(1.0)?;

    let inputs_left = inputs_bool
        .clone()
        .slice(vec![(0..NUM_EXAMPLES).into(), 0.into()])?;

    let inputs_right = inputs_bool.slice(vec![(0..NUM_EXAMPLES).into(), 1.into()])?;

    let labels = inputs_left
        .and(inputs_right)?
        .expand_dims(vec![1])?
        .cast()?;

    let labels = ArrayBase::<Buffer<f32>>::copy(&labels)?;

    let output = inputs.matmul(weights.clone())?;
    let error = labels.sub(output)?;
    let loss = error.clone().pow_scalar(2.)?;

    let d_loss = error * 2.;
    let weights_t = weights.clone().transpose(None)?;
    let gradient = d_loss.matmul(weights_t)?;
    let deltas = gradient.sum(vec![0], false)?.expand_dims(vec![1])?;
    let new_weights = weights.clone().add(deltas * LEARNING_RATE)?;

    let mut i = 0;
    loop {
        let loss = ArrayBase::<Buffer<f32>>::copy(&loss)?;

        if loss.clone().lt_scalar(1.0)?.all()? {
            return Ok(());
        }

        if i % 100 == 0 {
            println!(
                "loss: {} (max {})",
                loss.clone().sum_all()?,
                loss.clone().max_all()?
            );
        }

        assert!(!loss.clone().is_inf()?.any()?, "divergence at iteration {i}");
        assert!(!loss.is_nan()?.any()?, "unstable by iteration {i}");

        weights.write(&new_weights)?;

        i += 1;
    }
}

impl<T: CDatatype> ArrayBase<Arc<Buffer<T>>>

pub fn copy<O: NDArrayRead<DType = T>>(other: &O) -> Result<Self, Error>

Examples found in repository

examples/backprop.rs (line 17)

fn main() -> Result<(), Error> {
    let context = Context::default()?;
    let weights = RandomNormal::with_context(context.clone(), 2)?;
    let weights = ArrayOp::new(vec![2, 1], weights) - 0.5;
    let mut weights = ArrayBase::<Arc<RwLock<Buffer<f32>>>>::copy(&weights)?;

    let inputs = RandomUniform::with_context(context, vec![NUM_EXAMPLES, 2])?;
    let inputs = ArrayOp::new(vec![NUM_EXAMPLES, 2], inputs) * 2.;
    let inputs = ArrayBase::<Arc<Buffer<f32>>>::copy(&inputs)?;

    let inputs_bool = inputs.clone().lt_scalar(1.0)?;

    let inputs_left = inputs_bool
        .clone()
        .slice(vec![(0..NUM_EXAMPLES).into(), 0.into()])?;

    let inputs_right = inputs_bool.slice(vec![(0..NUM_EXAMPLES).into(), 1.into()])?;

    let labels = inputs_left
        .and(inputs_right)?
        .expand_dims(vec![1])?
        .cast()?;

    let labels = ArrayBase::<Buffer<f32>>::copy(&labels)?;

    let output = inputs.matmul(weights.clone())?;
    let error = labels.sub(output)?;
    let loss = error.clone().pow_scalar(2.)?;

    let d_loss = error * 2.;
    let weights_t = weights.clone().transpose(None)?;
    let gradient = d_loss.matmul(weights_t)?;
    let deltas = gradient.sum(vec![0], false)?.expand_dims(vec![1])?;
    let new_weights = weights.clone().add(deltas * LEARNING_RATE)?;

    let mut i = 0;
    loop {
        let loss = ArrayBase::<Buffer<f32>>::copy(&loss)?;

        if loss.clone().lt_scalar(1.0)?.all()? {
            return Ok(());
        }

        if i % 100 == 0 {
            println!(
                "loss: {} (max {})",
                loss.clone().sum_all()?,
                loss.clone().max_all()?
            );
        }

        assert!(!loss.clone().is_inf()?.any()?, "divergence at iteration {i}");
        assert!(!loss.is_nan()?.any()?, "unstable by iteration {i}");

        weights.write(&new_weights)?;

        i += 1;
    }
}

impl<T: CDatatype> ArrayBase<Arc<RwLock<Buffer<T>>>>

pub fn copy<O: NDArrayRead<DType = T>>(other: &O) -> Result<Self, Error>

Examples found in repository

examples/backprop.rs (line 13)

fn main() -> Result<(), Error> {
    let context = Context::default()?;
    let weights = RandomNormal::with_context(context.clone(), 2)?;
    let weights = ArrayOp::new(vec![2, 1], weights) - 0.5;
    let mut weights = ArrayBase::<Arc<RwLock<Buffer<f32>>>>::copy(&weights)?;

    let inputs = RandomUniform::with_context(context, vec![NUM_EXAMPLES, 2])?;
    let inputs = ArrayOp::new(vec![NUM_EXAMPLES, 2], inputs) * 2.;
    let inputs = ArrayBase::<Arc<Buffer<f32>>>::copy(&inputs)?;

    let inputs_bool = inputs.clone().lt_scalar(1.0)?;

    let inputs_left = inputs_bool
        .clone()
        .slice(vec![(0..NUM_EXAMPLES).into(), 0.into()])?;

    let inputs_right = inputs_bool.slice(vec![(0..NUM_EXAMPLES).into(), 1.into()])?;

    let labels = inputs_left
        .and(inputs_right)?
        .expand_dims(vec![1])?
        .cast()?;

    let labels = ArrayBase::<Buffer<f32>>::copy(&labels)?;

    let output = inputs.matmul(weights.clone())?;
    let error = labels.sub(output)?;
    let loss = error.clone().pow_scalar(2.)?;

    let d_loss = error * 2.;
    let weights_t = weights.clone().transpose(None)?;
    let gradient = d_loss.matmul(weights_t)?;
    let deltas = gradient.sum(vec![0], false)?.expand_dims(vec![1])?;
    let new_weights = weights.clone().add(deltas * LEARNING_RATE)?;

    let mut i = 0;
    loop {
        let loss = ArrayBase::<Buffer<f32>>::copy(&loss)?;

        if loss.clone().lt_scalar(1.0)?.all()? {
            return Ok(());
        }

        if i % 100 == 0 {
            println!(
                "loss: {} (max {})",
                loss.clone().sum_all()?,
                loss.clone().max_all()?
            );
        }

        assert!(!loss.clone().is_inf()?.any()?, "divergence at iteration {i}");
        assert!(!loss.is_nan()?.any()?, "unstable by iteration {i}");

        weights.write(&new_weights)?;

        i += 1;
    }
}

Trait Implementations

impl<T: CDatatype, Op: Op<Out = T>, O> Add<ArrayBase<O>> for ArrayOp<Op>where ArrayBase<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayOp<Op>, ArrayBase<O>>>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: CDatatype, A: NDArray<DType = T>, O> Add<ArrayBase<O>> for ArraySlice<A>where ArrayBase<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArraySlice<A>, ArrayBase<O>>>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: CDatatype, A: NDArray<DType = T>, O> Add<ArrayBase<O>> for ArrayView<A>where ArrayBase<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayView<A>, ArrayBase<O>>>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, LB, RB> Add<ArrayBase<RB>> for ArrayBase<LB>where T: CDatatype, LB: BufferInstance<DType = T>, RB: BufferInstance<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayBase<LB>, ArrayBase<RB>>>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: CDatatype, Buf: BufferInstance<DType = T>, O> Add<ArrayOp<O>> for ArrayBase<Buf>where ArrayOp<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayBase<Buf>, ArrayOp<O>>>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: CDatatype, Buf: BufferInstance<DType = T>, O> Add<ArraySlice<O>> for ArrayBase<Buf>where ArraySlice<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayBase<Buf>, ArraySlice<O>>>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: CDatatype, Buf: BufferInstance<DType = T>, O> Add<ArrayView<O>> for ArrayBase<Buf>where ArrayView<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayBase<Buf>, ArrayView<O>>>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: CDatatype, Buf: BufferInstance<DType = T>> Add<T> for ArrayBase<Buf>

type Output = ArrayOp<ArrayScalar<T, ArrayBase<Buf>>>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: CDatatype> AsBuffer for ArrayBase<Buffer<T>>

fn as_buffer(&self) -> BufferConverter<'_, Self::DType>

fn as_buffer_mut(&mut self) -> BufferConverterMut<'_, Self::DType>

impl<T: CDatatype> AsBuffer for ArrayBase<Vec<T>>

fn as_buffer(&self) -> BufferConverter<'_, Self::DType>

fn as_buffer_mut(&mut self) -> BufferConverterMut<'_, Self::DType>

impl<Buf: Clone> Clone for ArrayBase<Buf>

fn clone(&self) -> ArrayBase<Buf>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Buf: BufferInstance> Debug for ArrayBase<Buf>

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

Formats the value using the given formatter.

impl<T: CDatatype, Op: Op<Out = T>, O> Div<ArrayBase<O>> for ArrayOp<Op>where ArrayBase<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayOp<Op>, ArrayBase<O>>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: CDatatype, A: NDArray<DType = T>, O> Div<ArrayBase<O>> for ArraySlice<A>where ArrayBase<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArraySlice<A>, ArrayBase<O>>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: CDatatype, A: NDArray<DType = T>, O> Div<ArrayBase<O>> for ArrayView<A>where ArrayBase<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayView<A>, ArrayBase<O>>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, LB, RB> Div<ArrayBase<RB>> for ArrayBase<LB>where T: CDatatype, LB: BufferInstance<DType = T>, RB: BufferInstance<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayBase<LB>, ArrayBase<RB>>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: CDatatype, Buf: BufferInstance<DType = T>, O> Div<ArrayOp<O>> for ArrayBase<Buf>where ArrayOp<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayBase<Buf>, ArrayOp<O>>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: CDatatype, Buf: BufferInstance<DType = T>, O> Div<ArraySlice<O>> for ArrayBase<Buf>where ArraySlice<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayBase<Buf>, ArraySlice<O>>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: CDatatype, Buf: BufferInstance<DType = T>, O> Div<ArrayView<O>> for ArrayBase<Buf>where ArrayView<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayBase<Buf>, ArrayView<O>>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: CDatatype, Buf: BufferInstance<DType = T>> Div<T> for ArrayBase<Buf>

type Output = ArrayOp<ArrayScalar<T, ArrayBase<Buf>>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: CDatatype> From<ArrayBase<Arc<Buffer<T>, Global>>> for Array<T>

fn from(base: ArrayBase<Arc<Buffer<T>>>) -> Self

Converts to this type from the input type.

impl<T: CDatatype> From<ArrayBase<Arc<Vec<T, Global>, Global>>> for Array<T>

fn from(base: ArrayBase<Arc<Vec<T>>>) -> Self

Converts to this type from the input type.

impl<T: CDatatype> From<ArrayBase<Box<dyn BufferRead<DType = T>, Global>>> for Array<T>

fn from(base: ArrayBase<Box<dyn BufferRead<DType = T>>>) -> Self

Converts to this type from the input type.

impl<T: CDatatype> From<ArrayBase<Buffer<T>>> for Array<T>

fn from(base: ArrayBase<Buffer<T>>) -> Self

Converts to this type from the input type.

impl<T: CDatatype> From<ArrayBase<Buffer<T>>> for ArrayBase<Arc<Buffer<T>>>

fn from(base: ArrayBase<Buffer<T>>) -> Self

Converts to this type from the input type.

impl<T: CDatatype> From<ArrayBase<Vec<T, Global>>> for Array<T>

fn from(base: ArrayBase<Vec<T>>) -> Self

Converts to this type from the input type.

impl<T: CDatatype> From<ArrayBase<Vec<T, Global>>> for ArrayBase<Arc<Buffer<T>>>

fn from(base: ArrayBase<Vec<T>>) -> Self

Converts to this type from the input type.

impl<T: CDatatype> From<ArrayBase<Vec<T, Global>>> for ArrayBase<Arc<Vec<T>>>

fn from(base: ArrayBase<Vec<T>>) -> Self

Converts to this type from the input type.

impl<T: CDatatype> From<ArrayBase<Vec<T, Global>>> for ArrayBase<Box<dyn BufferRead<DType = T>>>

fn from(base: ArrayBase<Vec<T>>) -> Self

Converts to this type from the input type.

impl<T: CDatatype> From<ArrayBase<Vec<T, Global>>> for ArrayBase<Buffer<T>>

fn from(base: ArrayBase<Vec<T>>) -> Self

Converts to this type from the input type.

impl<T: CDatatype, Op: Op<Out = T>, O> Mul<ArrayBase<O>> for ArrayOp<Op>where ArrayBase<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayOp<Op>, ArrayBase<O>>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: CDatatype, A: NDArray<DType = T>, O> Mul<ArrayBase<O>> for ArraySlice<A>where ArrayBase<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArraySlice<A>, ArrayBase<O>>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: CDatatype, A: NDArray<DType = T>, O> Mul<ArrayBase<O>> for ArrayView<A>where ArrayBase<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayView<A>, ArrayBase<O>>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, LB, RB> Mul<ArrayBase<RB>> for ArrayBase<LB>where T: CDatatype, LB: BufferInstance<DType = T>, RB: BufferInstance<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayBase<LB>, ArrayBase<RB>>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: CDatatype, Buf: BufferInstance<DType = T>, O> Mul<ArrayOp<O>> for ArrayBase<Buf>where ArrayOp<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayBase<Buf>, ArrayOp<O>>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: CDatatype, Buf: BufferInstance<DType = T>, O> Mul<ArraySlice<O>> for ArrayBase<Buf>where ArraySlice<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayBase<Buf>, ArraySlice<O>>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: CDatatype, Buf: BufferInstance<DType = T>, O> Mul<ArrayView<O>> for ArrayBase<Buf>where ArrayView<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayBase<Buf>, ArrayView<O>>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: CDatatype, Buf: BufferInstance<DType = T>> Mul<T> for ArrayBase<Buf>

type Output = ArrayOp<ArrayScalar<T, ArrayBase<Buf>>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Buf: BufferInstance> NDArray for ArrayBase<Buf>

type DType = <Buf as BufferInstance>::DType

fn context(&self) -> &Context

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

fn ndim(&self) -> usize

fn size(&self) -> usize

impl<T: CDatatype> NDArrayRead for ArrayBase<Arc<Buffer<T>>>

fn read(&self, _queue: &Queue) -> Result<BufferConverter<'_, T>, Error>

fn read_value(&self, coord: &[usize]) -> Result<Self::DType, Error>

fn to_host( &self, queue: &Queue ) -> Result<SliceConverter<'_, Self::DType>, Error>

impl<T: CDatatype> NDArrayRead for ArrayBase<Arc<RwLock<Buffer<T>>>>

fn read(&self, queue: &Queue) -> Result<BufferConverter<'_, T>, Error>

fn read_value(&self, coord: &[usize]) -> Result<Self::DType, Error>

fn to_host( &self, queue: &Queue ) -> Result<SliceConverter<'_, Self::DType>, Error>

impl<T: CDatatype> NDArrayRead for ArrayBase<Arc<RwLock<Vec<T>>>>

fn read(&self, _queue: &Queue) -> Result<BufferConverter<'_, T>, Error>

fn read_value(&self, coord: &[usize]) -> Result<Self::DType, Error>

fn to_host( &self, queue: &Queue ) -> Result<SliceConverter<'_, Self::DType>, Error>

impl<T: CDatatype> NDArrayRead for ArrayBase<Arc<Vec<T>>>

fn read(&self, _queue: &Queue) -> Result<BufferConverter<'_, T>, Error>

fn read_value(&self, coord: &[usize]) -> Result<Self::DType, Error>

fn to_host( &self, queue: &Queue ) -> Result<SliceConverter<'_, Self::DType>, Error>

impl<T: CDatatype> NDArrayRead for ArrayBase<Box<dyn BufferRead<DType = T>>>

fn read( &self, _queue: &Queue ) -> Result<BufferConverter<'_, Self::DType>, Error>

fn read_value(&self, coord: &[usize]) -> Result<Self::DType, Error>

fn to_host( &self, queue: &Queue ) -> Result<SliceConverter<'_, Self::DType>, Error>

impl<T: CDatatype> NDArrayRead for ArrayBase<Buffer<T>>

fn read(&self, _queue: &Queue) -> Result<BufferConverter<'_, T>, Error>

fn read_value(&self, coord: &[usize]) -> Result<Self::DType, Error>

fn to_host( &self, queue: &Queue ) -> Result<SliceConverter<'_, Self::DType>, Error>

impl<T: CDatatype> NDArrayRead for ArrayBase<Vec<T>>

fn read(&self, _queue: &Queue) -> Result<BufferConverter<'_, T>, Error>

fn read_value(&self, coord: &[usize]) -> Result<Self::DType, Error>

fn to_host( &self, queue: &Queue ) -> Result<SliceConverter<'_, Self::DType>, Error>

impl<Buf: BufferInstance> NDArrayTransform for ArrayBase<Buf>where Self: NDArrayRead,

type Broadcast = ArrayView<ArrayBase<Buf>>

type Expand = ArrayBase<Buf>

type Reshape = ArrayBase<Buf>

type Slice = ArraySlice<ArrayBase<Buf>>

type Transpose = ArrayView<ArrayBase<Buf>>

fn broadcast(self, shape: Shape) -> Result<ArrayView<Self>, Error>

fn expand_dims(self, axes: Vec<usize>) -> Result<Self::Expand, Error>

fn reshape(self, shape: Shape) -> Result<Self, Error>

fn slice(self, bounds: Vec<AxisBound>) -> Result<ArraySlice<Self>, Error>

fn transpose(self, axes: Option<Vec<usize>>) -> Result<ArrayView<Self>, Error>

impl<'a, T: CDatatype> NDArrayWrite for ArrayBase<Arc<RwLock<Buffer<T>>>>

fn write<O: NDArrayRead<DType = T>>(&mut self, other: &O) -> Result<(), Error>

fn write_value(&mut self, value: T) -> Result<(), Error>

fn write_value_at(&mut self, coord: &[usize], value: T) -> Result<(), Error>

impl<'a, T: CDatatype> NDArrayWrite for ArrayBase<Arc<RwLock<Vec<T>>>>

fn write<O: NDArrayRead<DType = T>>(&mut self, other: &O) -> Result<(), Error>

fn write_value(&mut self, value: T) -> Result<(), Error>

fn write_value_at(&mut self, coord: &[usize], value: T) -> Result<(), Error>

impl<'a, T: CDatatype> NDArrayWrite for ArrayBase<Buffer<T>>

fn write<O: NDArrayRead<DType = T>>(&mut self, other: &O) -> Result<(), Error>

fn write_value(&mut self, value: T) -> Result<(), Error>

fn write_value_at(&mut self, coord: &[usize], value: T) -> Result<(), Error>

impl<'a, T: CDatatype> NDArrayWrite for ArrayBase<Vec<T>>

fn write<O: NDArrayRead<DType = T>>(&mut self, other: &O) -> Result<(), Error>

fn write_value(&mut self, value: T) -> Result<(), Error>

fn write_value_at(&mut self, coord: &[usize], value: T) -> Result<(), Error>

impl<Buf: BufferInstance> Neg for ArrayBase<Buf>

type Output = ArrayOp<ArrayUnary<<Buf as BufferInstance>::DType, <<Buf as BufferInstance>::DType as CDatatype>::Neg, ArrayBase<Buf>>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<Buf: BufferInstance> Not for ArrayBase<Buf>

type Output = ArrayOp<ArrayUnary<<Buf as BufferInstance>::DType, u8, ArrayBase<Buf>>>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T: CDatatype, Op: Op<Out = T>, O> Rem<ArrayBase<O>> for ArrayOp<Op>where ArrayBase<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayOp<Op>, ArrayBase<O>>>

The resulting type after applying the % operator.

fn rem(self, rhs: ArrayBase<O>) -> Self::Output

Performs the % operation.

impl<T: CDatatype, A: NDArray<DType = T>, O> Rem<ArrayBase<O>> for ArraySlice<A>where ArrayBase<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArraySlice<A>, ArrayBase<O>>>

The resulting type after applying the % operator.

fn rem(self, rhs: ArrayBase<O>) -> Self::Output

Performs the % operation.

impl<T: CDatatype, A: NDArray<DType = T>, O> Rem<ArrayBase<O>> for ArrayView<A>where ArrayBase<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayView<A>, ArrayBase<O>>>

The resulting type after applying the % operator.

fn rem(self, rhs: ArrayBase<O>) -> Self::Output

Performs the % operation.

impl<T, LB, RB> Rem<ArrayBase<RB>> for ArrayBase<LB>where T: CDatatype, LB: BufferInstance<DType = T>, RB: BufferInstance<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayBase<LB>, ArrayBase<RB>>>

The resulting type after applying the % operator.

fn rem(self, rhs: ArrayBase<RB>) -> Self::Output

Performs the % operation.

impl<T: CDatatype, Buf: BufferInstance<DType = T>, O> Rem<ArrayOp<O>> for ArrayBase<Buf>where ArrayOp<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayBase<Buf>, ArrayOp<O>>>

The resulting type after applying the % operator.

fn rem(self, rhs: ArrayOp<O>) -> Self::Output

Performs the % operation.

impl<T: CDatatype, Buf: BufferInstance<DType = T>, O> Rem<ArraySlice<O>> for ArrayBase<Buf>where ArraySlice<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayBase<Buf>, ArraySlice<O>>>

The resulting type after applying the % operator.

fn rem(self, rhs: ArraySlice<O>) -> Self::Output

Performs the % operation.

impl<T: CDatatype, Buf: BufferInstance<DType = T>, O> Rem<ArrayView<O>> for ArrayBase<Buf>where ArrayView<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayBase<Buf>, ArrayView<O>>>

The resulting type after applying the % operator.

fn rem(self, rhs: ArrayView<O>) -> Self::Output

Performs the % operation.

impl<T: CDatatype, Buf: BufferInstance<DType = T>> Rem<T> for ArrayBase<Buf>

type Output = ArrayOp<ArrayScalar<T, ArrayBase<Buf>>>

The resulting type after applying the % operator.

fn rem(self, rhs: T) -> Self::Output

Performs the % operation.

impl<T: CDatatype, Op: Op<Out = T>, O> Sub<ArrayBase<O>> for ArrayOp<Op>where ArrayBase<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayOp<Op>, ArrayBase<O>>>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: CDatatype, A: NDArray<DType = T>, O> Sub<ArrayBase<O>> for ArraySlice<A>where ArrayBase<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArraySlice<A>, ArrayBase<O>>>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: CDatatype, A: NDArray<DType = T>, O> Sub<ArrayBase<O>> for ArrayView<A>where ArrayBase<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayView<A>, ArrayBase<O>>>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, LB, RB> Sub<ArrayBase<RB>> for ArrayBase<LB>where T: CDatatype, LB: BufferInstance<DType = T>, RB: BufferInstance<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayBase<LB>, ArrayBase<RB>>>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: CDatatype, Buf: BufferInstance<DType = T>, O> Sub<ArrayOp<O>> for ArrayBase<Buf>where ArrayOp<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayBase<Buf>, ArrayOp<O>>>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: CDatatype, Buf: BufferInstance<DType = T>, O> Sub<ArraySlice<O>> for ArrayBase<Buf>where ArraySlice<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayBase<Buf>, ArraySlice<O>>>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: CDatatype, Buf: BufferInstance<DType = T>, O> Sub<ArrayView<O>> for ArrayBase<Buf>where ArrayView<O>: NDArray<DType = T>,

type Output = ArrayOp<ArrayDual<T, ArrayBase<Buf>, ArrayView<O>>>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: CDatatype, Buf: BufferInstance<DType = T>> Sub<T> for ArrayBase<Buf>

type Output = ArrayOp<ArrayScalar<T, ArrayBase<Buf>>>

The resulting type after applying the - operator.

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

Performs the - operation.