Struct Heap

pub struct Heap;

Trait Implementations

impl Clone for Heap

fn clone(&self) -> Heap

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

type Buffer = Vec<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> Convert<T> for Heap

type Buffer = Vec<T>

The type of buffer use by this platform

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

impl Debug for Heap

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

Formats the value using the given formatter.

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

type Buffer = Vec<OT>

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

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

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

type Buffer = Vec<OT>

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

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

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

type Buffer = Vec<OT>

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

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

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

type Buffer = Vec<OT>

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

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

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

type Buffer = Vec<T>

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

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

type Buffer = Vec<T>

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

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

type Buffer = Vec<T>

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

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

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

type Buffer = Vec<T>

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

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

type Buffer = Vec<T>

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

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

type Buffer = Vec<T>

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

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

type Buffer = Vec<T>

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

impl Enqueue<Heap, f32> for RandomNormal

type Buffer = Vec<f32>

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

impl Enqueue<Heap, f32> for RandomUniform

type Buffer = Vec<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 PartialEq for Heap

fn eq(&self, other: &Heap) -> 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 PlatformInstance for Heap

fn select(_size_hint: usize) -> Self

Select a specific sub-platform based on data size.

impl<A, T> ReduceAll<A, T> for Heap

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

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, T> Write<Heap, 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 Heap

impl Eq for Heap

impl StructuralPartialEq for Heap