| Package | Description |
|---|---|
| mikera.arrayz | |
| mikera.matrixx | |
| mikera.matrixx.impl | |
| mikera.vectorz | |
| mikera.vectorz.impl | |
| mikera.vectorz.util |
| Modifier and Type | Class and Description |
|---|---|
class |
SliceArray<T extends INDArray>
A general n-dimensional double array implemented as a collection of (n-1) dimensional slices
|
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractArray<T>
Abstract base class for INDArray implementations
|
class |
NDArray
General purpose NDArray class
|
class |
SliceArray<T extends INDArray>
A general n-dimensional double array implemented as a collection of (n-1) dimensional slices
|
| Modifier and Type | Method and Description |
|---|---|
static <T extends INDArray> |
SliceArray.create(List<T> slices) |
static <T extends INDArray> |
SliceArray.create(T... slices) |
static <T extends INDArray> |
SliceArray.repeat(T s,
int n) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
NDArray.broadcast(int... dimensions) |
INDArray |
INDArray.broadcast(int... dimensions) |
INDArray |
AbstractArray.broadcast(int... targetShape) |
INDArray |
INDArray.clone()
Returns a clone of the array, as a new array which will be fully mutable
and may be of a different class to the original.
|
static INDArray |
Arrayz.create(Object... os) |
static INDArray |
Arrayz.create(Object object)
Creates an array from the given data
|
static INDArray |
Arrayz.createFromVector(AVector a,
int[] shape) |
INDArray |
INDArray.exactClone()
Returns an exact deep clone of an array (i.e.
|
INDArray |
SliceArray.innerProduct(INDArray a) |
INDArray |
NDArray.innerProduct(INDArray a) |
INDArray |
INDArray.innerProduct(INDArray a) |
INDArray |
AbstractArray.innerProduct(INDArray a) |
INDArray |
SliceArray.outerProduct(INDArray a) |
INDArray |
NDArray.outerProduct(INDArray a) |
INDArray |
INDArray.outerProduct(INDArray a) |
INDArray |
AbstractArray.outerProduct(INDArray a) |
INDArray |
SliceArray.reshape(int... dimensions) |
INDArray |
NDArray.reshape(int... dimensions) |
INDArray |
INDArray.reshape(int... dimensions) |
INDArray |
AbstractArray.reshape(int... targetShape) |
INDArray |
SliceArray.slice(int majorSlice) |
INDArray |
NDArray.slice(int majorSlice) |
INDArray |
INDArray.slice(int majorSlice) |
| Modifier and Type | Method and Description |
|---|---|
List<INDArray> |
NDArray.getSlices() |
| Modifier and Type | Method and Description |
|---|---|
void |
NDArray.add(INDArray a) |
void |
INDArray.add(INDArray a) |
void |
AbstractArray.add(INDArray a) |
static <T extends INDArray> |
SliceArray.create(T... slices) |
boolean |
SliceArray.equals(INDArray a) |
boolean |
NDArray.equals(INDArray a) |
boolean |
INDArray.equals(INDArray a)
Returns true if the two arrays are exactly equal in value and shape
|
INDArray |
SliceArray.innerProduct(INDArray a) |
INDArray |
NDArray.innerProduct(INDArray a) |
INDArray |
INDArray.innerProduct(INDArray a) |
INDArray |
AbstractArray.innerProduct(INDArray a) |
INDArray |
SliceArray.outerProduct(INDArray a) |
INDArray |
NDArray.outerProduct(INDArray a) |
INDArray |
INDArray.outerProduct(INDArray a) |
INDArray |
AbstractArray.outerProduct(INDArray a) |
void |
INDArray.set(INDArray a) |
void |
AbstractArray.set(INDArray a) |
void |
NDArray.sub(INDArray a) |
void |
INDArray.sub(INDArray a) |
void |
AbstractArray.sub(INDArray a) |
| Constructor and Description |
|---|
SliceIterator(INDArray source) |
SliceIterator(INDArray source,
int start,
int length) |
| Modifier and Type | Class and Description |
|---|---|
class |
AMatrix
General abstract 2D matrix class.
|
class |
Matrix
Standard MxN matrix class backed by a flat double[] array
|
class |
Matrix22
Specialised 2*2 Matrix for Vector2 maths, using primitive matrix elements
|
class |
Matrix33
Specialised 3*3 Matrix for Vector3 maths, using primitive matrix elements
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
AMatrix.broadcast(int... targetShape) |
INDArray |
AMatrix.innerProduct(INDArray a) |
INDArray |
AMatrix.outerProduct(INDArray a) |
INDArray |
AMatrix.reshape(int... dimensions) |
| Modifier and Type | Method and Description |
|---|---|
void |
AMatrix.add(INDArray a) |
boolean |
AMatrix.equals(INDArray v) |
INDArray |
AMatrix.innerProduct(INDArray a) |
INDArray |
AMatrix.outerProduct(INDArray a) |
void |
AMatrix.set(INDArray a) |
void |
AMatrix.sub(INDArray a) |
| Modifier and Type | Class and Description |
|---|---|
class |
ADiagonalMatrix
Abstract base class for diagonal matrices
|
class |
AVectorMatrix<T extends AVector>
Abstract base class for matrices that use a collection of Vectors
as storage for the matrix rows.
|
class |
ColumnMatrix
Matrix class that wraps a vector as a 1-columns matrix
|
class |
DiagonalMatrix
Specialised diagonal matrix class
Not fully mutable - only the diagonal values can be changed
|
class |
IdentityMatrix
Specialised identity matrix class.
|
class |
MatrixSubVector
Abstract class for matrix sub vector views (rows and columns etc.)
|
class |
PermutedMatrix
Reference matrix class representing a permutation of a matrix
|
class |
RowMatrix
Matrix class that wraps a vector as a 1-row matrix
|
class |
ScalarMatrix
Scalar matrix class - i.e.
|
class |
SubsetMatrix
Matrix that transforms to a subset of elements of the source vector
i.e.
|
class |
TransposedMatrix
Class representing a transposed view of another matrix
The transposed matrix is a reference to the underlying matrix data
|
class |
VectorMatrixM3
Specialised N*3 Matrix with Vector3 row components
|
class |
VectorMatrixMN
A matrix implemented as a composition of M length N vectors
|
class |
ZeroMatrix
Lightweight immutable zero matrix class
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
IVector
Basic interface for a Vector
Implementations should normally extend AVector directly, which implements IVector plus
a considerable amount of other important functionality.
|
| Modifier and Type | Class and Description |
|---|---|
class |
APrimitiveVector
Abstract base class for specialised primitive vectors
|
class |
ArrayVector
Base class for vectors backed by a double[] array.
|
class |
AScalar
Class to represent a wrapped 0-d scalar value.
|
class |
AVector
Main abstract base class for all types of vector
Contains default implementations for most vector operations which can be
overriden to achieve better performance in derived classes.
|
class |
BitVector
Vector of bits - constrained to 0.0 / 1.0 values
Intended for compact representation/storage of binary vectors
|
class |
GrowableVector
Implements a growable vector, intended for incrementally building vectors
Note that getting the underlying array or a subVector is unsafe, since the
underlying array may be discarded as the vector is grown.
|
class |
Vector
General purpose vector of arbitrary length, backed by an internal double[] array
|
class |
Vector1
Specialised 1D vector
|
class |
Vector2
Specialised 2D vector
|
class |
Vector3
Specialised 3D vector
Represents a point in 3D x,y,z space.
|
class |
Vector4
Specialised 4D vector
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
AVector.broadcast(int... targetShape) |
INDArray |
AScalar.broadcast(int... targetShape) |
INDArray |
AVector.innerProduct(INDArray a) |
INDArray |
AScalar.innerProduct(INDArray a) |
INDArray |
AVector.outerProduct(INDArray a) |
INDArray |
AScalar.outerProduct(INDArray a) |
INDArray |
AVector.reshape(int... dimensions) |
INDArray |
AScalar.reshape(int... dimensions) |
INDArray |
AScalar.slice(int position) |
| Modifier and Type | Method and Description |
|---|---|
void |
AVector.add(INDArray a) |
void |
AScalar.add(INDArray a) |
boolean |
AVector.equals(INDArray v) |
boolean |
AScalar.equals(INDArray o) |
INDArray |
AVector.innerProduct(INDArray a) |
INDArray |
AScalar.innerProduct(INDArray a) |
INDArray |
AVector.outerProduct(INDArray a) |
INDArray |
AScalar.outerProduct(INDArray a) |
void |
AVector.set(INDArray a) |
void |
AVector.sub(INDArray a) |
void |
AScalar.sub(INDArray a) |
| Modifier and Type | Class and Description |
|---|---|
class |
ADerivedVector
Derived vector delegates all calls to an underlying vector
|
class |
ArrayIndexScalar |
class |
ArraySubVector
Vector referring to an offset into a double[] array
|
class |
ASparseVector
Abstract base class for Sparse vector implementations
|
class |
AxisVector
Specialized unit axis vector.
|
class |
ComputedVector
Base class for computed vectors.
|
class |
DoubleScalar |
class |
IndexedArrayVector
Vector that addresses elements indexed into double[] array
|
class |
IndexedSubVector
Vector that addresses elements indexed into another source vector
|
class |
JoinedArrayVector
Class representing a join of one or more array subvectors
|
class |
JoinedVector
A vector that represents the concatenation of two vectors.
|
class |
RepeatedElementVector
A mutable vector that always has a single repeated component.
|
class |
ScalarVector
A length 1 vector, as a view wrapping a single AScalar
|
class |
SingleElementVector
A sparse mutable vector that has one non-zero element.
|
class |
SparseIndexedVector
Indexed sparse vector.
|
class |
StridedArrayVector |
class |
UnmodifiableVector |
class |
Vector0
Special singleton zero length vector class.
|
class |
VectorIndexScalar |
class |
WrappedSubVector |
class |
ZeroVector
Specialised vector containing nothing but zeros.
|
| Modifier and Type | Method and Description |
|---|---|
boolean |
Testing.validateFullyMutable(INDArray m) |
Copyright © 2013. All Rights Reserved.