Enum ha_ndarray::host::Host

pub enum Host {
    Stack(Stack),
    Heap(Heap),
}

Variants

Stack(Stack)

Heap(Heap)

Trait Implementations

impl Clone for Host

fn clone(&self) -> Host

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: CType> Constant<T> for Host

type Buffer = Buffer<T>

The type of buffer use by this platform

fn constant(&self, value: T, size: usize) -> Result<Self::Buffer, Error>

Construct a new buffer filled with a single value.

impl<T: CType> Construct<T> for Host

type Range = Linear<T>

fn range( self, start: T, stop: T, size: usize ) -> Result<AccessOp<Self::Range, Self>, Error>

impl<T: CType> Convert<T> for Host

type Buffer = Buffer<T>

The type of buffer use by this platform

fn convert(&self, buffer: BufferConverter<'_, T>) -> Result<Self::Buffer, Error>

impl Debug for Host

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

Formats the value using the given formatter.

impl<L, R, T> ElementwiseBoolean<L, R, T> for Host

where L: Access<T>, R: Access<T>, T: CType,

type Op = Dual<L, R, T, u8>

fn and(self, left: L, right: R) -> Result<AccessOp<Self::Op, Self>, Error>

fn or(self, left: L, right: R) -> Result<AccessOp<Self::Op, Self>, Error>

fn xor(self, left: L, right: R) -> Result<AccessOp<Self::Op, Self>, Error>

impl<A: Access<T>, T: CType> ElementwiseBooleanScalar<A, T> for Host

type Op = Scalar<A, T, u8>

fn and_scalar( self, left: A, right: T ) -> Result<AccessOp<Self::Op, Self>, Error>

fn or_scalar(self, left: A, right: T) -> Result<AccessOp<Self::Op, Self>, Error>

fn xor_scalar( self, left: A, right: T ) -> Result<AccessOp<Self::Op, Self>, Error>

impl<A: Access<IT>, IT: CType, OT: CType> ElementwiseCast<A, IT, OT> for Host

type Op = Cast<A, IT, OT>

fn cast(self, access: A) -> Result<AccessOp<Self::Op, Self>, Error>

impl<L, R, T> ElementwiseCompare<L, R, T> for Host

where L: Access<T>, R: Access<T>, T: CType,

type Op = Dual<L, R, T, u8>

fn eq(self, left: L, right: R) -> Result<AccessOp<Self::Op, Self>, Error>

fn ge(self, left: L, right: R) -> Result<AccessOp<Self::Op, Self>, Error>

fn gt(self, left: L, right: R) -> Result<AccessOp<Self::Op, Self>, Error>

fn le(self, left: L, right: R) -> Result<AccessOp<Self::Op, Self>, Error>

fn lt(self, left: L, right: R) -> Result<AccessOp<Self::Op, Self>, Error>

fn ne(self, left: L, right: R) -> Result<AccessOp<Self::Op, Self>, Error>

impl<L, R, T> ElementwiseDual<L, R, T> for Host

where L: Access<T>, R: Access<T>, T: CType,

type Op = Dual<L, R, T, T>

fn add(self, left: L, right: R) -> Result<AccessOp<Self::Op, Self>, Error>

fn div(self, left: L, right: R) -> Result<AccessOp<Self::Op, Self>, Error>

fn log(self, arg: L, base: R) -> Result<AccessOp<Self::Op, Self>, Error>

fn mul(self, left: L, right: R) -> Result<AccessOp<Self::Op, Self>, Error>

fn pow(self, arg: L, exp: R) -> Result<AccessOp<Self::Op, Self>, Error>

fn rem(self, left: L, right: R) -> Result<AccessOp<Self::Op, Self>, Error>

fn sub(self, left: L, right: R) -> Result<AccessOp<Self::Op, Self>, Error>

impl<A: Access<T>, T: Float> ElementwiseNumeric<A, T> for Host

type Op = Unary<A, T, u8>

fn is_inf(self, access: A) -> Result<AccessOp<Self::Op, Self>, Error>

fn is_nan(self, access: A) -> Result<AccessOp<Self::Op, Self>, Error>

impl<A: Access<T>, T: CType> ElementwiseScalar<A, T> for Host

type Op = Scalar<A, T, T>

fn add_scalar( self, left: A, right: T ) -> Result<AccessOp<Self::Op, Self>, Error>

fn div_scalar( self, left: A, right: T ) -> Result<AccessOp<Self::Op, Self>, Error>

fn log_scalar(self, arg: A, base: T) -> Result<AccessOp<Self::Op, Self>, Error>

fn mul_scalar( self, left: A, right: T ) -> Result<AccessOp<Self::Op, Self>, Error>

fn pow_scalar(self, arg: A, exp: T) -> Result<AccessOp<Self::Op, Self>, Error>

fn rem_scalar( self, left: A, right: T ) -> Result<AccessOp<Self::Op, Self>, Error>

fn sub_scalar( self, left: A, right: T ) -> Result<AccessOp<Self::Op, Self>, Error>

impl<A: Access<T>, T: CType> ElementwiseScalarCompare<A, T> for Host

type Op = Scalar<A, T, u8>

fn eq_scalar(self, left: A, right: T) -> Result<AccessOp<Self::Op, Self>, Error>

fn ge_scalar(self, left: A, right: T) -> Result<AccessOp<Self::Op, Self>, Error>

fn gt_scalar(self, left: A, right: T) -> Result<AccessOp<Self::Op, Self>, Error>

fn le_scalar(self, left: A, right: T) -> Result<AccessOp<Self::Op, Self>, Error>

fn lt_scalar(self, left: A, right: T) -> Result<AccessOp<Self::Op, Self>, Error>

fn ne_scalar(self, left: A, right: T) -> Result<AccessOp<Self::Op, Self>, Error>

impl<A: Access<T>, T: CType> ElementwiseTrig<A, T> for Host

type Op = Unary<A, T, <T as CType>::Float>

fn sin(self, access: A) -> Result<AccessOp<Self::Op, Self>, Error>

fn asin(self, access: A) -> Result<AccessOp<Self::Op, Self>, Error>

fn sinh(self, access: A) -> Result<AccessOp<Self::Op, Self>, Error>

fn cos(self, access: A) -> Result<AccessOp<Self::Op, Self>, Error>

fn acos(self, access: A) -> Result<AccessOp<Self::Op, Self>, Error>

fn cosh(self, access: A) -> Result<AccessOp<Self::Op, Self>, Error>

fn tan(self, access: A) -> Result<AccessOp<Self::Op, Self>, Error>

fn atan(self, access: A) -> Result<AccessOp<Self::Op, Self>, Error>

fn tanh(self, access: A) -> Result<AccessOp<Self::Op, Self>, Error>

impl<A: Access<T>, T: CType> ElementwiseUnary<A, T> for Host

type Op = Unary<A, T, T>

fn abs(self, access: A) -> Result<AccessOp<Self::Op, Self>, Error>

fn exp(self, access: A) -> Result<AccessOp<Self::Op, Self>, Error>

fn ln(self, access: A) -> Result<AccessOp<Self::Op, Self>, Error>

fn round(self, access: A) -> Result<AccessOp<Self::Op, Self>, Error>

impl<A: Access<T>, T: CType> ElementwiseUnaryBoolean<A, T> for Host

type Op = Unary<A, T, u8>

fn not(self, access: A) -> Result<AccessOp<Self::Op, Self>, Error>

impl<A: Access<IT>, IT: CType, OT: CType> Enqueue<Host, OT> for Cast<A, IT, OT>

type Buffer = Buffer<OT>

fn enqueue(&self) -> Result<Self::Buffer, Error>

impl<L, R, IT, OT> Enqueue<Host, OT> for Dual<L, R, IT, OT>

where L: Access<IT>, R: Access<IT>, IT: CType, OT: CType,

type Buffer = Buffer<OT>

fn enqueue(&self) -> Result<Self::Buffer, Error>

impl<A, IT, OT> Enqueue<Host, OT> for Scalar<A, IT, OT>

where A: Access<IT>, IT: CType, OT: CType,

type Buffer = Buffer<OT>

fn enqueue(&self) -> Result<Self::Buffer, Error>

impl<A, IT, OT> Enqueue<Host, OT> for Unary<A, IT, OT>

where A: Access<IT>, IT: CType, OT: CType,

type Buffer = Buffer<OT>

fn enqueue(&self) -> Result<Self::Buffer, Error>

impl<A, L, R, T> Enqueue<Host, T> for Cond<A, L, R, T>

where A: Access<u8>, L: Access<T>, R: Access<T>, T: CType,

type Buffer = Buffer<T>

fn enqueue(&self) -> Result<Self::Buffer, Error>

impl<T: CType> Enqueue<Host, T> for Linear<T>

type Buffer = Buffer<T>

fn enqueue(&self) -> Result<Self::Buffer, Error>

impl<A: Access<T>, T: CType> Enqueue<Host, T> for MatDiag<A, T>

type Buffer = Buffer<T>

fn enqueue(&self) -> Result<Self::Buffer, Error>

impl<L, R, T> Enqueue<Host, T> for MatMul<L, R, T>

where L: Access<T>, R: Access<T>, T: CType,

type Buffer = Buffer<T>

fn enqueue(&self) -> Result<Self::Buffer, Error>

impl<A: Access<T>, T: CType> Enqueue<Host, T> for Reduce<A, T>

type Buffer = Buffer<T>

fn enqueue(&self) -> Result<Self::Buffer, Error>

impl<A: Access<T>, T: CType> Enqueue<Host, T> for Slice<A, T>

type Buffer = Buffer<T>

fn enqueue(&self) -> Result<Self::Buffer, Error>

impl<A: Access<T>, T: CType> Enqueue<Host, T> for View<A, T>

type Buffer = Buffer<T>

fn enqueue(&self) -> Result<Self::Buffer, Error>

impl Enqueue<Host, f32> for RandomNormal

type Buffer = Buffer<f32>

fn enqueue(&self) -> Result<Self::Buffer, Error>

impl Enqueue<Host, f32> for RandomUniform

type Buffer = Buffer<f32>

fn enqueue(&self) -> Result<Self::Buffer, Error>

impl From<Heap> for Host

fn from(heap: Heap) -> Self

Converts to this type from the input type.

impl From<Host> for Platform

fn from(host: Host) -> Self

Converts to this type from the input type.

impl From<Stack> for Host

fn from(stack: Stack) -> Self

Converts to this type from the input type.

impl<A, L, R, T> GatherCond<A, L, R, T> for Host

where A: Access<u8>, L: Access<T>, R: Access<T>, T: CType,

type Op = Cond<A, L, R, T>

fn cond( self, cond: A, then: L, or_else: R ) -> Result<AccessOp<Self::Op, Self>, Error>

impl<L, R, T> LinAlgDual<L, R, T> for Host

where L: Access<T>, R: Access<T>, T: CType,

type Op = MatMul<L, R, T>

fn matmul( self, left: L, right: R, dims: [usize; 4] ) -> Result<AccessOp<Self::Op, Self>, Error>

impl<A: Access<T>, T: CType> LinAlgUnary<A, T> for Host

type Op = MatDiag<A, T>

fn diag( self, access: A, batch_size: usize, dim: usize ) -> Result<AccessOp<Self::Op, Self>, Error>

impl PartialEq for Host

fn eq(&self, other: &Host) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PlatformInstance for Host

fn select(size_hint: usize) -> Self

Select a specific sub-platform based on data size.

impl Random for Host

type Normal = RandomNormal

type Uniform = RandomUniform

fn random_normal( self, size: usize ) -> Result<AccessOp<Self::Normal, Self>, Error>

fn random_uniform( self, size: usize ) -> Result<AccessOp<Self::Uniform, Self>, Error>

impl<A: Access<IT>, IT: CType, OT: CType> ReadValue<Host, OT> for Cast<A, IT, OT>

fn read_value(&self, offset: usize) -> Result<OT, Error>

impl<L, R, IT, OT> ReadValue<Host, OT> for Dual<L, R, IT, OT>

where L: Access<IT>, R: Access<IT>, IT: CType, OT: CType,

fn read_value(&self, offset: usize) -> Result<OT, Error>

impl<A, IT, OT> ReadValue<Host, OT> for Scalar<A, IT, OT>

where A: Access<IT>, IT: CType, OT: CType,

fn read_value(&self, offset: usize) -> Result<OT, Error>

impl<A, IT, OT> ReadValue<Host, OT> for Unary<A, IT, OT>

where A: Access<IT>, IT: CType, OT: CType,

fn read_value(&self, offset: usize) -> Result<OT, Error>

impl<A, L, R, T> ReadValue<Host, T> for Cond<A, L, R, T>

where A: Access<u8>, L: Access<T>, R: Access<T>, T: CType,

fn read_value(&self, offset: usize) -> Result<T, Error>

impl<T: CType> ReadValue<Host, T> for Linear<T>

fn read_value(&self, offset: usize) -> Result<T, Error>

impl<A: Access<T>, T: CType> ReadValue<Host, T> for MatDiag<A, T>

fn read_value(&self, offset: usize) -> Result<T, Error>

impl<L, R, T> ReadValue<Host, T> for MatMul<L, R, T>

where L: Access<T>, R: Access<T>, T: CType,

fn read_value(&self, _offset: usize) -> Result<T, Error>

impl<A: Access<T>, T: CType> ReadValue<Host, T> for Reduce<A, T>

fn read_value(&self, offset: usize) -> Result<T, Error>

impl<A: Access<T>, T: CType> ReadValue<Host, T> for Slice<A, T>

fn read_value(&self, offset: usize) -> Result<T, Error>

impl<A: Access<T>, T: CType> ReadValue<Host, T> for View<A, T>

fn read_value(&self, offset: usize) -> Result<T, Error>

impl ReadValue<Host, f32> for RandomNormal

fn read_value(&self, _offset: usize) -> Result<f32, Error>

impl ReadValue<Host, f32> for RandomUniform

fn read_value(&self, _offset: usize) -> Result<f32, Error>

impl<A: Access<T>, T: CType> ReduceAll<A, T> for Host

fn all(self, access: A) -> Result<bool, Error>

fn any(self, access: A) -> Result<bool, Error>

fn max(self, access: A) -> Result<T, Error>

fn min(self, access: A) -> Result<T, Error>

fn product(self, access: A) -> Result<T, Error>

fn sum(self, access: A) -> Result<T, Error>

impl<A: Access<T>, T: CType> ReduceAxes<A, T> for Host

type Op = Reduce<A, T>

fn max( self, access: A, stride: usize ) -> Result<AccessOp<Self::Op, Self>, Error>

fn min( self, access: A, stride: usize ) -> Result<AccessOp<Self::Op, Self>, Error>

fn product( self, access: A, stride: usize ) -> Result<AccessOp<Self::Op, Self>, Error>

fn sum( self, access: A, stride: usize ) -> Result<AccessOp<Self::Op, Self>, Error>

impl<'a, A, T> Transform<A, T> for Host

where A: Access<T>, T: CType,

type Broadcast = View<A, T>

type Slice = Slice<A, T>

type Transpose = View<A, T>

fn broadcast( self, access: A, shape: Shape, broadcast: Shape ) -> Result<AccessOp<Self::Broadcast, Self>, Error>

fn slice( self, access: A, shape: &[usize], range: Range ) -> Result<AccessOp<Self::Slice, Self>, Error>

fn transpose( self, access: A, shape: Shape, permutation: Axes ) -> Result<AccessOp<Self::Transpose, Self>, Error>

impl<A, T> Write<Host, T> for Slice<A, T>

where T: CType, A: AccessMut<T>,

fn write<'a>(&mut self, data: BufferConverter<'a, T>) -> Result<(), Error>

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

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

impl Copy for Host

impl Eq for Host

impl StructuralEq for Host

impl StructuralPartialEq for Host