Class and Description |
---|
Op.Type |
Class and Description |
---|
Op.Type |
Class and Description |
---|
DynamicCustomOp
Basic implementation for CustomOp
|
Class and Description |
---|
BaseOp
Base op.
|
BaseReduceOp
Base class for accumulation, initiates the initial entry
with respect to the child class.
|
BaseTransformOp
A base op for basic getters and setters
|
BroadcastOp
A broad cast op is one where a scalar
or less rank array
is broadcast to fill
a bigg er array.
|
CustomOp
This interface describe "custom operations.
|
CustomOpDescriptor
This class is simple POJO that contains basic information about CustomOp
|
DynamicCustomOp
Basic implementation for CustomOp
|
DynamicCustomOp.DynamicCustomOpsBuilder |
GridOp
MetaOp is special op, that contains multiple ops
|
IndexAccumulation
An index accumulation is an operation that returns an index within
a NDArray.
Examples of IndexAccumulation operations include finding the index of the minimim value, index of the maximum value, index of the first element equal to value y, index of the maximum pair-wise difference between two NDArrays X and Y etc. Index accumulation is similar to ReduceOp in that both are
accumulation/reduction operations, however index accumulation returns
an integer corresponding to an index, rather than a real (or complex)
value.Index accumulation operations generally have 3 inputs: x -> the origin ndarray y -> the pairwise ndarray (frequently null/not applicable) n -> the number of times to accumulate Note that IndexAccumulation op implementations should be stateless (other than the final result and x/y/n arguments) and hence threadsafe, such that they may be parallelized using the update, combineSubResults and set/getFinalResults methods. |
Op
An op is defined as follows:
opName: opName of the operation
x: the origin ndarray
y: the ndarray to parse in parallel
z: the resulting buffer
n: the number of elements to iterate over
where x is the origin ndarray,
y, is a pairwise op
over n elements in the ndarray
stored in result z
This is followed from the standard template for a BLAS operation
such that given a linear buffer, a function defines 3 buffers (x,y,z)
and the associated strides and offsets (handled by the ndarrays in this case)
|
Op.Type |
OpContext
This interface describes OpContext, abstraction used to setup op for execution.
|
ReduceBoolOp
ReduceLong take any type in, and return BOOL type
|
ReduceFloatOp
ReduceLong take any type in, and return FLOATING-POINT type
|
ReduceLongOp
ReduceLong take any type in, and return LONG type
|
ReduceOp
An accumulation is an op that given:
x -> the origin ndarray y -> the pairwise ndarray n -> the number of times to accumulate Of note here in the extra arguments. |
ReduceSameOp
ReduceLong take any type in, and return same type
|
ScalarOp
Applies a scalar
along a bigger input array.
|
TransformFloatOp
Strict transforms take any type in, and return FLOATING-POINT type
|
TransformOp
Transform operation:
stores the result in an ndarray
|
TransformSameOp
Strict transforms take any type in, and return same type
|
TransformStrictOp
Strict transforms take floating-point type in, and return same type
|
Class and Description |
---|
CustomOp
This interface describe "custom operations.
|
CustomOpDescriptor
This class is simple POJO that contains basic information about CustomOp
|
DynamicCustomOp
Basic implementation for CustomOp
|
Class and Description |
---|
BroadcastOp
A broad cast op is one where a scalar
or less rank array
is broadcast to fill
a bigg er array.
|
CustomOp
This interface describe "custom operations.
|
CustomOpDescriptor
This class is simple POJO that contains basic information about CustomOp
|
GridOp
MetaOp is special op, that contains multiple ops
|
IndexAccumulation
An index accumulation is an operation that returns an index within
a NDArray.
Examples of IndexAccumulation operations include finding the index of the minimim value, index of the maximum value, index of the first element equal to value y, index of the maximum pair-wise difference between two NDArrays X and Y etc. Index accumulation is similar to ReduceOp in that both are
accumulation/reduction operations, however index accumulation returns
an integer corresponding to an index, rather than a real (or complex)
value.Index accumulation operations generally have 3 inputs: x -> the origin ndarray y -> the pairwise ndarray (frequently null/not applicable) n -> the number of times to accumulate Note that IndexAccumulation op implementations should be stateless (other than the final result and x/y/n arguments) and hence threadsafe, such that they may be parallelized using the update, combineSubResults and set/getFinalResults methods. |
MetaOp
MetaOp is special op, that contains multiple ops
|
Op
An op is defined as follows:
opName: opName of the operation
x: the origin ndarray
y: the ndarray to parse in parallel
z: the resulting buffer
n: the number of elements to iterate over
where x is the origin ndarray,
y, is a pairwise op
over n elements in the ndarray
stored in result z
This is followed from the standard template for a BLAS operation
such that given a linear buffer, a function defines 3 buffers (x,y,z)
and the associated strides and offsets (handled by the ndarrays in this case)
|
OpContext
This interface describes OpContext, abstraction used to setup op for execution.
|
RandomOp |
ReduceOp
An accumulation is an op that given:
x -> the origin ndarray y -> the pairwise ndarray n -> the number of times to accumulate Of note here in the extra arguments. |
ScalarOp
Applies a scalar
along a bigger input array.
|
TransformOp
Transform operation:
stores the result in an ndarray
|
Class and Description |
---|
Op
An op is defined as follows:
opName: opName of the operation
x: the origin ndarray
y: the ndarray to parse in parallel
z: the resulting buffer
n: the number of elements to iterate over
where x is the origin ndarray,
y, is a pairwise op
over n elements in the ndarray
stored in result z
This is followed from the standard template for a BLAS operation
such that given a linear buffer, a function defines 3 buffers (x,y,z)
and the associated strides and offsets (handled by the ndarrays in this case)
|
Class and Description |
---|
BaseBroadcastOp |
BaseOp
Base op.
|
BroadcastOp
A broad cast op is one where a scalar
or less rank array
is broadcast to fill
a bigg er array.
|
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Op
An op is defined as follows:
opName: opName of the operation
x: the origin ndarray
y: the ndarray to parse in parallel
z: the resulting buffer
n: the number of elements to iterate over
where x is the origin ndarray,
y, is a pairwise op
over n elements in the ndarray
stored in result z
This is followed from the standard template for a BLAS operation
such that given a linear buffer, a function defines 3 buffers (x,y,z)
and the associated strides and offsets (handled by the ndarrays in this case)
|
Class and Description |
---|
BaseBroadcastBoolOp |
BaseOp
Base op.
|
BroadcastOp
A broad cast op is one where a scalar
or less rank array
is broadcast to fill
a bigg er array.
|
Op
An op is defined as follows:
opName: opName of the operation
x: the origin ndarray
y: the ndarray to parse in parallel
z: the resulting buffer
n: the number of elements to iterate over
where x is the origin ndarray,
y, is a pairwise op
over n elements in the ndarray
stored in result z
This is followed from the standard template for a BLAS operation
such that given a linear buffer, a function defines 3 buffers (x,y,z)
and the associated strides and offsets (handled by the ndarrays in this case)
|
Class and Description |
---|
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Class and Description |
---|
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Op.Type |
Class and Description |
---|
BaseOp
Base op.
|
GridOp
MetaOp is special op, that contains multiple ops
|
Op
An op is defined as follows:
opName: opName of the operation
x: the origin ndarray
y: the ndarray to parse in parallel
z: the resulting buffer
n: the number of elements to iterate over
where x is the origin ndarray,
y, is a pairwise op
over n elements in the ndarray
stored in result z
This is followed from the standard template for a BLAS operation
such that given a linear buffer, a function defines 3 buffers (x,y,z)
and the associated strides and offsets (handled by the ndarrays in this case)
|
Class and Description |
---|
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Op.Type |
Class and Description |
---|
BaseIndexAccumulation
Index based reduction algo
|
BaseOp
Base op.
|
IndexAccumulation
An index accumulation is an operation that returns an index within
a NDArray.
Examples of IndexAccumulation operations include finding the index of the minimim value, index of the maximum value, index of the first element equal to value y, index of the maximum pair-wise difference between two NDArrays X and Y etc. Index accumulation is similar to ReduceOp in that both are
accumulation/reduction operations, however index accumulation returns
an integer corresponding to an index, rather than a real (or complex)
value.Index accumulation operations generally have 3 inputs: x -> the origin ndarray y -> the pairwise ndarray (frequently null/not applicable) n -> the number of times to accumulate Note that IndexAccumulation op implementations should be stateless (other than the final result and x/y/n arguments) and hence threadsafe, such that they may be parallelized using the update, combineSubResults and set/getFinalResults methods. |
Op
An op is defined as follows:
opName: opName of the operation
x: the origin ndarray
y: the ndarray to parse in parallel
z: the resulting buffer
n: the number of elements to iterate over
where x is the origin ndarray,
y, is a pairwise op
over n elements in the ndarray
stored in result z
This is followed from the standard template for a BLAS operation
such that given a linear buffer, a function defines 3 buffers (x,y,z)
and the associated strides and offsets (handled by the ndarrays in this case)
|
Op.Type |
Class and Description |
---|
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Class and Description |
---|
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Op.Type |
Class and Description |
---|
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Class and Description |
---|
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Class and Description |
---|
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Op.Type |
Class and Description |
---|
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Class and Description |
---|
BaseOp
Base op.
|
GridOp
MetaOp is special op, that contains multiple ops
|
MetaOp
MetaOp is special op, that contains multiple ops
|
Op
An op is defined as follows:
opName: opName of the operation
x: the origin ndarray
y: the ndarray to parse in parallel
z: the resulting buffer
n: the number of elements to iterate over
where x is the origin ndarray,
y, is a pairwise op
over n elements in the ndarray
stored in result z
This is followed from the standard template for a BLAS operation
such that given a linear buffer, a function defines 3 buffers (x,y,z)
and the associated strides and offsets (handled by the ndarrays in this case)
|
ReduceOp
An accumulation is an op that given:
x -> the origin ndarray y -> the pairwise ndarray n -> the number of times to accumulate Of note here in the extra arguments. |
ScalarOp
Applies a scalar
along a bigger input array.
|
TransformOp
Transform operation:
stores the result in an ndarray
|
Class and Description |
---|
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Class and Description |
---|
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Op.Type |
Class and Description |
---|
BaseOp
Base op.
|
BaseReduceBoolOp |
BaseReduceOp
Base class for accumulation, initiates the initial entry
with respect to the child class.
|
Op
An op is defined as follows:
opName: opName of the operation
x: the origin ndarray
y: the ndarray to parse in parallel
z: the resulting buffer
n: the number of elements to iterate over
where x is the origin ndarray,
y, is a pairwise op
over n elements in the ndarray
stored in result z
This is followed from the standard template for a BLAS operation
such that given a linear buffer, a function defines 3 buffers (x,y,z)
and the associated strides and offsets (handled by the ndarrays in this case)
|
ReduceBoolOp
ReduceLong take any type in, and return BOOL type
|
ReduceOp
An accumulation is an op that given:
x -> the origin ndarray y -> the pairwise ndarray n -> the number of times to accumulate Of note here in the extra arguments. |
Class and Description |
---|
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Class and Description |
---|
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Class and Description |
---|
BaseOp
Base op.
|
BaseReduceFloatOp |
BaseReduceOp
Base class for accumulation, initiates the initial entry
with respect to the child class.
|
Op
An op is defined as follows:
opName: opName of the operation
x: the origin ndarray
y: the ndarray to parse in parallel
z: the resulting buffer
n: the number of elements to iterate over
where x is the origin ndarray,
y, is a pairwise op
over n elements in the ndarray
stored in result z
This is followed from the standard template for a BLAS operation
such that given a linear buffer, a function defines 3 buffers (x,y,z)
and the associated strides and offsets (handled by the ndarrays in this case)
|
Op.Type |
ReduceFloatOp
ReduceLong take any type in, and return FLOATING-POINT type
|
ReduceOp
An accumulation is an op that given:
x -> the origin ndarray y -> the pairwise ndarray n -> the number of times to accumulate Of note here in the extra arguments. |
Class and Description |
---|
BaseOp
Base op.
|
BaseReduceLongOp |
BaseReduceOp
Base class for accumulation, initiates the initial entry
with respect to the child class.
|
Op
An op is defined as follows:
opName: opName of the operation
x: the origin ndarray
y: the ndarray to parse in parallel
z: the resulting buffer
n: the number of elements to iterate over
where x is the origin ndarray,
y, is a pairwise op
over n elements in the ndarray
stored in result z
This is followed from the standard template for a BLAS operation
such that given a linear buffer, a function defines 3 buffers (x,y,z)
and the associated strides and offsets (handled by the ndarrays in this case)
|
ReduceLongOp
ReduceLong take any type in, and return LONG type
|
ReduceOp
An accumulation is an op that given:
x -> the origin ndarray y -> the pairwise ndarray n -> the number of times to accumulate Of note here in the extra arguments. |
Class and Description |
---|
BaseOp
Base op.
|
BaseReduceOp
Base class for accumulation, initiates the initial entry
with respect to the child class.
|
BaseReduceSameOp |
Op
An op is defined as follows:
opName: opName of the operation
x: the origin ndarray
y: the ndarray to parse in parallel
z: the resulting buffer
n: the number of elements to iterate over
where x is the origin ndarray,
y, is a pairwise op
over n elements in the ndarray
stored in result z
This is followed from the standard template for a BLAS operation
such that given a linear buffer, a function defines 3 buffers (x,y,z)
and the associated strides and offsets (handled by the ndarrays in this case)
|
ReduceOp
An accumulation is an op that given:
x -> the origin ndarray y -> the pairwise ndarray n -> the number of times to accumulate Of note here in the extra arguments. |
ReduceSameOp
ReduceLong take any type in, and return same type
|
Class and Description |
---|
BaseOp
Base op.
|
BaseReduceFloatOp |
BaseReduceOp
Base class for accumulation, initiates the initial entry
with respect to the child class.
|
Op
An op is defined as follows:
opName: opName of the operation
x: the origin ndarray
y: the ndarray to parse in parallel
z: the resulting buffer
n: the number of elements to iterate over
where x is the origin ndarray,
y, is a pairwise op
over n elements in the ndarray
stored in result z
This is followed from the standard template for a BLAS operation
such that given a linear buffer, a function defines 3 buffers (x,y,z)
and the associated strides and offsets (handled by the ndarrays in this case)
|
Op.Type |
ReduceFloatOp
ReduceLong take any type in, and return FLOATING-POINT type
|
ReduceOp
An accumulation is an op that given:
x -> the origin ndarray y -> the pairwise ndarray n -> the number of times to accumulate Of note here in the extra arguments. |
Class and Description |
---|
BaseOp
Base op.
|
BaseScalarOp
Base scalar operation
|
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Op
An op is defined as follows:
opName: opName of the operation
x: the origin ndarray
y: the ndarray to parse in parallel
z: the resulting buffer
n: the number of elements to iterate over
where x is the origin ndarray,
y, is a pairwise op
over n elements in the ndarray
stored in result z
This is followed from the standard template for a BLAS operation
such that given a linear buffer, a function defines 3 buffers (x,y,z)
and the associated strides and offsets (handled by the ndarrays in this case)
|
ScalarOp
Applies a scalar
along a bigger input array.
|
Class and Description |
---|
BaseOp
Base op.
|
BaseScalarBoolOp
Base scalar boolean operation
|
BaseScalarOp
Base scalar operation
|
Op
An op is defined as follows:
opName: opName of the operation
x: the origin ndarray
y: the ndarray to parse in parallel
z: the resulting buffer
n: the number of elements to iterate over
where x is the origin ndarray,
y, is a pairwise op
over n elements in the ndarray
stored in result z
This is followed from the standard template for a BLAS operation
such that given a linear buffer, a function defines 3 buffers (x,y,z)
and the associated strides and offsets (handled by the ndarrays in this case)
|
ScalarOp
Applies a scalar
along a bigger input array.
|
Class and Description |
---|
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Class and Description |
---|
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Op.Type |
Class and Description |
---|
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Op.Type |
Class and Description |
---|
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Op.Type |
Class and Description |
---|
BaseOp
Base op.
|
BaseReduceOp
Base class for accumulation, initiates the initial entry
with respect to the child class.
|
Op
An op is defined as follows:
opName: opName of the operation
x: the origin ndarray
y: the ndarray to parse in parallel
z: the resulting buffer
n: the number of elements to iterate over
where x is the origin ndarray,
y, is a pairwise op
over n elements in the ndarray
stored in result z
This is followed from the standard template for a BLAS operation
such that given a linear buffer, a function defines 3 buffers (x,y,z)
and the associated strides and offsets (handled by the ndarrays in this case)
|
Op.Type |
ReduceOp
An accumulation is an op that given:
x -> the origin ndarray y -> the pairwise ndarray n -> the number of times to accumulate Of note here in the extra arguments. |
Class and Description |
---|
BaseOp
Base op.
|
BaseTransformOp
A base op for basic getters and setters
|
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Op
An op is defined as follows:
opName: opName of the operation
x: the origin ndarray
y: the ndarray to parse in parallel
z: the resulting buffer
n: the number of elements to iterate over
where x is the origin ndarray,
y, is a pairwise op
over n elements in the ndarray
stored in result z
This is followed from the standard template for a BLAS operation
such that given a linear buffer, a function defines 3 buffers (x,y,z)
and the associated strides and offsets (handled by the ndarrays in this case)
|
Op.Type |
TransformOp
Transform operation:
stores the result in an ndarray
|
Class and Description |
---|
BaseOp
Base op.
|
BaseTransformAnyOp |
BaseTransformOp
A base op for basic getters and setters
|
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Op
An op is defined as follows:
opName: opName of the operation
x: the origin ndarray
y: the ndarray to parse in parallel
z: the resulting buffer
n: the number of elements to iterate over
where x is the origin ndarray,
y, is a pairwise op
over n elements in the ndarray
stored in result z
This is followed from the standard template for a BLAS operation
such that given a linear buffer, a function defines 3 buffers (x,y,z)
and the associated strides and offsets (handled by the ndarrays in this case)
|
TransformOp
Transform operation:
stores the result in an ndarray
|
TransformSameOp
Strict transforms take any type in, and return same type
|
Class and Description |
---|
BaseOp
Base op.
|
BaseTransformBoolOp |
BaseTransformOp
A base op for basic getters and setters
|
Op
An op is defined as follows:
opName: opName of the operation
x: the origin ndarray
y: the ndarray to parse in parallel
z: the resulting buffer
n: the number of elements to iterate over
where x is the origin ndarray,
y, is a pairwise op
over n elements in the ndarray
stored in result z
This is followed from the standard template for a BLAS operation
such that given a linear buffer, a function defines 3 buffers (x,y,z)
and the associated strides and offsets (handled by the ndarrays in this case)
|
TransformOp
Transform operation:
stores the result in an ndarray
|
TransformSameOp
Strict transforms take any type in, and return same type
|
Class and Description |
---|
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Class and Description |
---|
BaseOp
Base op.
|
BaseTransformBoolOp |
BaseTransformOp
A base op for basic getters and setters
|
BaseTransformSameOp |
Op
An op is defined as follows:
opName: opName of the operation
x: the origin ndarray
y: the ndarray to parse in parallel
z: the resulting buffer
n: the number of elements to iterate over
where x is the origin ndarray,
y, is a pairwise op
over n elements in the ndarray
stored in result z
This is followed from the standard template for a BLAS operation
such that given a linear buffer, a function defines 3 buffers (x,y,z)
and the associated strides and offsets (handled by the ndarrays in this case)
|
TransformOp
Transform operation:
stores the result in an ndarray
|
TransformSameOp
Strict transforms take any type in, and return same type
|
Class and Description |
---|
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Op.Type |
Class and Description |
---|
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Class and Description |
---|
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Class and Description |
---|
BaseOp
Base op.
|
BaseTransformFloatOp |
BaseTransformOp
A base op for basic getters and setters
|
Op
An op is defined as follows:
opName: opName of the operation
x: the origin ndarray
y: the ndarray to parse in parallel
z: the resulting buffer
n: the number of elements to iterate over
where x is the origin ndarray,
y, is a pairwise op
over n elements in the ndarray
stored in result z
This is followed from the standard template for a BLAS operation
such that given a linear buffer, a function defines 3 buffers (x,y,z)
and the associated strides and offsets (handled by the ndarrays in this case)
|
TransformFloatOp
Strict transforms take any type in, and return FLOATING-POINT type
|
TransformOp
Transform operation:
stores the result in an ndarray
|
Class and Description |
---|
BaseOp
Base op.
|
BaseScalarOp
Base scalar operation
|
BaseTransformOp
A base op for basic getters and setters
|
BaseTransformStrictOp |
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Op
An op is defined as follows:
opName: opName of the operation
x: the origin ndarray
y: the ndarray to parse in parallel
z: the resulting buffer
n: the number of elements to iterate over
where x is the origin ndarray,
y, is a pairwise op
over n elements in the ndarray
stored in result z
This is followed from the standard template for a BLAS operation
such that given a linear buffer, a function defines 3 buffers (x,y,z)
and the associated strides and offsets (handled by the ndarrays in this case)
|
ScalarOp
Applies a scalar
along a bigger input array.
|
TransformOp
Transform operation:
stores the result in an ndarray
|
TransformStrictOp
Strict transforms take floating-point type in, and return same type
|
Class and Description |
---|
BaseOp
Base op.
|
BaseTransformAnyOp |
BaseTransformOp
A base op for basic getters and setters
|
BaseTransformSameOp |
Op
An op is defined as follows:
opName: opName of the operation
x: the origin ndarray
y: the ndarray to parse in parallel
z: the resulting buffer
n: the number of elements to iterate over
where x is the origin ndarray,
y, is a pairwise op
over n elements in the ndarray
stored in result z
This is followed from the standard template for a BLAS operation
such that given a linear buffer, a function defines 3 buffers (x,y,z)
and the associated strides and offsets (handled by the ndarrays in this case)
|
TransformOp
Transform operation:
stores the result in an ndarray
|
TransformSameOp
Strict transforms take any type in, and return same type
|
Class and Description |
---|
BaseOp
Base op.
|
BaseTransformAnyOp |
BaseTransformOp
A base op for basic getters and setters
|
BaseTransformSameOp |
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Op
An op is defined as follows:
opName: opName of the operation
x: the origin ndarray
y: the ndarray to parse in parallel
z: the resulting buffer
n: the number of elements to iterate over
where x is the origin ndarray,
y, is a pairwise op
over n elements in the ndarray
stored in result z
This is followed from the standard template for a BLAS operation
such that given a linear buffer, a function defines 3 buffers (x,y,z)
and the associated strides and offsets (handled by the ndarrays in this case)
|
TransformOp
Transform operation:
stores the result in an ndarray
|
TransformSameOp
Strict transforms take any type in, and return same type
|
Class and Description |
---|
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Class and Description |
---|
BaseOp
Base op.
|
BaseTransformBoolOp |
BaseTransformOp
A base op for basic getters and setters
|
Op
An op is defined as follows:
opName: opName of the operation
x: the origin ndarray
y: the ndarray to parse in parallel
z: the resulting buffer
n: the number of elements to iterate over
where x is the origin ndarray,
y, is a pairwise op
over n elements in the ndarray
stored in result z
This is followed from the standard template for a BLAS operation
such that given a linear buffer, a function defines 3 buffers (x,y,z)
and the associated strides and offsets (handled by the ndarrays in this case)
|
Op.Type |
TransformOp
Transform operation:
stores the result in an ndarray
|
TransformSameOp
Strict transforms take any type in, and return same type
|
Class and Description |
---|
BaseOp
Base op.
|
BaseTransformOp
A base op for basic getters and setters
|
BaseTransformSameOp |
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Op
An op is defined as follows:
opName: opName of the operation
x: the origin ndarray
y: the ndarray to parse in parallel
z: the resulting buffer
n: the number of elements to iterate over
where x is the origin ndarray,
y, is a pairwise op
over n elements in the ndarray
stored in result z
This is followed from the standard template for a BLAS operation
such that given a linear buffer, a function defines 3 buffers (x,y,z)
and the associated strides and offsets (handled by the ndarrays in this case)
|
TransformOp
Transform operation:
stores the result in an ndarray
|
TransformSameOp
Strict transforms take any type in, and return same type
|
Class and Description |
---|
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Class and Description |
---|
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Class and Description |
---|
BaseOp
Base op.
|
BaseTransformOp
A base op for basic getters and setters
|
BaseTransformStrictOp |
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Op
An op is defined as follows:
opName: opName of the operation
x: the origin ndarray
y: the ndarray to parse in parallel
z: the resulting buffer
n: the number of elements to iterate over
where x is the origin ndarray,
y, is a pairwise op
over n elements in the ndarray
stored in result z
This is followed from the standard template for a BLAS operation
such that given a linear buffer, a function defines 3 buffers (x,y,z)
and the associated strides and offsets (handled by the ndarrays in this case)
|
TransformOp
Transform operation:
stores the result in an ndarray
|
TransformStrictOp
Strict transforms take floating-point type in, and return same type
|
Class and Description |
---|
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Class and Description |
---|
BaseOp
Base op.
|
Op
An op is defined as follows:
opName: opName of the operation
x: the origin ndarray
y: the ndarray to parse in parallel
z: the resulting buffer
n: the number of elements to iterate over
where x is the origin ndarray,
y, is a pairwise op
over n elements in the ndarray
stored in result z
This is followed from the standard template for a BLAS operation
such that given a linear buffer, a function defines 3 buffers (x,y,z)
and the associated strides and offsets (handled by the ndarrays in this case)
|
Op.Type |
RandomOp |
Class and Description |
---|
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Class and Description |
---|
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Class and Description |
---|
BaseOp
Base op.
|
CustomOp
This interface describe "custom operations.
|
DynamicCustomOp
Basic implementation for CustomOp
|
Op
An op is defined as follows:
opName: opName of the operation
x: the origin ndarray
y: the ndarray to parse in parallel
z: the resulting buffer
n: the number of elements to iterate over
where x is the origin ndarray,
y, is a pairwise op
over n elements in the ndarray
stored in result z
This is followed from the standard template for a BLAS operation
such that given a linear buffer, a function defines 3 buffers (x,y,z)
and the associated strides and offsets (handled by the ndarrays in this case)
|
Op.Type |
RandomOp |
Class and Description |
---|
CustomOp
This interface describe "custom operations.
|
Op
An op is defined as follows:
opName: opName of the operation
x: the origin ndarray
y: the ndarray to parse in parallel
z: the resulting buffer
n: the number of elements to iterate over
where x is the origin ndarray,
y, is a pairwise op
over n elements in the ndarray
stored in result z
This is followed from the standard template for a BLAS operation
such that given a linear buffer, a function defines 3 buffers (x,y,z)
and the associated strides and offsets (handled by the ndarrays in this case)
|
OpContext
This interface describes OpContext, abstraction used to setup op for execution.
|
Class and Description |
---|
CustomOp
This interface describe "custom operations.
|
Op
An op is defined as follows:
opName: opName of the operation
x: the origin ndarray
y: the ndarray to parse in parallel
z: the resulting buffer
n: the number of elements to iterate over
where x is the origin ndarray,
y, is a pairwise op
over n elements in the ndarray
stored in result z
This is followed from the standard template for a BLAS operation
such that given a linear buffer, a function defines 3 buffers (x,y,z)
and the associated strides and offsets (handled by the ndarrays in this case)
|
Class and Description |
---|
CustomOp
This interface describe "custom operations.
|
Op
An op is defined as follows:
opName: opName of the operation
x: the origin ndarray
y: the ndarray to parse in parallel
z: the resulting buffer
n: the number of elements to iterate over
where x is the origin ndarray,
y, is a pairwise op
over n elements in the ndarray
stored in result z
This is followed from the standard template for a BLAS operation
such that given a linear buffer, a function defines 3 buffers (x,y,z)
and the associated strides and offsets (handled by the ndarrays in this case)
|
Copyright © 2019. All rights reserved.