Uses of Interface mikera.arrayz.INDArray (Vectorz 0.62.0 API)

Packages that use INDArray
Package	Description
mikera.arrayz
mikera.arrayz.impl
mikera.matrixx
mikera.matrixx.impl
mikera.vectorz
mikera.vectorz.impl
mikera.vectorz.ops
mikera.vectorz.util

Uses of INDArray in mikera.arrayz

Classes in mikera.arrayz that implement INDArray
Modifier and Type	Class and Description
`class`	`Array` General purpose, mutable, dense N-dimensional array This is the general multi-dimensional equivalent of Matrix and Vector, and as such is the most efficient storage type for dense 3D+ arrays
`class`	`NDArray` General purpose NDArray class.

Methods in mikera.arrayz that return INDArray
Modifier and Type	Method and Description
`INDArray`	INDArray.`absCopy()` Returns a copy of the array with the abs operator applied to each element
`INDArray`	INDArray.`addCopy(double d)` Creates a new array equal to this array with a constant value added to every element
`INDArray`	INDArray.`addCopy(INDArray a)` Creates a new array equal to the sum of this array with another array.
`INDArray`	INDArray.`applyOpCopy(Op op)` Applies a unary operator to all elements of the array (creating a new array)
`INDArray`	NDArray.`broadcast(int... dimensions)`
`INDArray`	INDArray.`broadcast(int... shape)` Returns a view of this array broadcasted up to a larger shape
`INDArray`	INDArray.`broadcastCloneLike(INDArray target)` Creates a mutable clone of the array, broadcasted upwards if necessary to match the shape of the target.
`INDArray`	INDArray.`broadcastCopyLike(INDArray target)` Creates a copy of the array, broadcasted upwards if necessary to match the shape of the target Like broadCastCloneLike, but does not guarantee a mutable clone - hence may be faster when used with immutable or specialized arrays
`INDArray`	INDArray.`broadcastLike(INDArray target)` Broadcasts an array to match the shape of the target
`INDArray`	NDArray.`clone()`
`INDArray`	INDArray.`clone()` Returns a clone of the array data, as a new array which will be fully mutable and may be of a different class to the original.
`INDArray`	Array.`clone()`
`INDArray`	INDArray.`copy()` Returns a defensive copy of the array data.
`static INDArray`	Arrayz.`create(INDArray a)`
`static INDArray`	Arrayz.`create(Object object)` Creates an array from the given data Handles double arrays, INDArray instances, and lists
`static <T> INDArray`	Arrayz.`create(T[] data)` Creates an array using the given data as slices.
`static INDArray`	Arrayz.`createFromVector(AVector a, int... shape)` Creates a new array using the elements in the specified vector.
`static INDArray`	Arrayz.`createSparse(INDArray a)` Creates a sparse copy of the given array.
`static <T> INDArray`	Arrayz.`createSparse(List<T> o)` Creates a sparse array given the provided List of slice objects
`static INDArray`	Arrayz.`createSparse(Object o)` Creates a sparse array given the provided input object Supports - Numbers (wrapped as scalars) - Existing INDArrays (copied into sparse format) - Iterable objects (interpreted as ordered lists of major slices) - Java Arrays (interpreted as arrays of slices Objects)
`static <T> INDArray`	Arrayz.`createSparse(T... slices)` Creates a sparse copy of the given data, given an array of slices to make sparse.
`static INDArray`	Arrayz.`createSparseArray(int... shape)` Creates a mutable sparse array of the specified shape.
`static INDArray`	Arrayz.`createSparseMutable(INDArray a)` Creates a fully mutable sparse clone of the given array
`static INDArray`	Arrayz.`createZeroArray(int... shape)` Creates an immutable zero-filled array of the given shape
`INDArray`	INDArray.`dense()` Coerces this INDArray to a dense format, without changing its element values.
`INDArray`	INDArray.`denseClone()` Creates a fully mutable dense clone of this array.
`INDArray`	INDArray.`divideCopy(INDArray a)` Divides all elements by the equivalent elements in a second array.
`INDArray`	INDArray.`ensureMutable()` Deprecated.
`INDArray`	INDArray.`exactClone()` Creates a deep clone of an array, using the same class implementation as the original array
`INDArray`	INDArray.`getComponent(int k)` Gets a component from the array at the specified index Will throw an error if components are not supported, or if the component is out of bounds as defined by 0 <= k
`INDArray[]`	INDArray.`getComponents()` Gets all components in a new array, with length componentCount();
`INDArray`	NDArray.`getTranspose()`
`INDArray`	INDArray.`getTranspose()` Returns the transpose of this array.
`INDArray`	Array.`getTranspose()`
`INDArray`	INDArray.`getTransposeCopy()` Returns a transposed copy of the array.
`INDArray`	NDArray.`getTransposeView()`
`INDArray`	INDArray.`getTransposeView()` Returns a transposed view of the array.
`INDArray`	Array.`getTransposeView()`
`INDArray`	NDArray.`immutable()`
`INDArray`	INDArray.`immutable()` Returns an immutable version of this array.
`INDArray`	Array.`immutable()`
`INDArray`	INDArray.`innerProduct(AScalar a)` Calculates the inner product of this array with a scalar
`INDArray`	INDArray.`innerProduct(AVector v)` Computes the inner product of this array with a vector
`INDArray`	INDArray.`innerProduct(double a)` Calculates the inner product of this array with a double value
`INDArray`	INDArray.`innerProduct(INDArray a)` Calculates the inner product of this array with another array.
`INDArray`	INDArray.`join(INDArray a)` Joins an array with another array along the major dimension
`INDArray`	INDArray.`join(INDArray a, int dimension)` Joins an array with another array along a specified dimension
`static INDArray`	Arrayz.`load(Reader reader)`
`INDArray`	INDArray.`multiplyCopy(double factor)` Returns a copy of the array with all elements multiplied by a single constant value
`INDArray`	INDArray.`multiplyCopy(INDArray a)` Multiplies all elements by the equivalent elements in a second array, i.e.
`INDArray`	INDArray.`mutable()` Coerces this INDArray to a fully mutable format.
`INDArray`	INDArray.`negateCopy()` Negates all elements in the array, returning a new array
`static INDArray`	Arrayz.`newArray(int... shape)` Create a new array instance with the given shape.
`INDArray`	INDArray.`outerProduct(INDArray a)` Calculates the outer product of this array with another array.
`static INDArray`	Arrayz.`parse(String ednString)` Parse an array from a String.
`INDArray`	INDArray.`reciprocalCopy()` Returns a new array where every element is the reciprocal of the corresponding element in this array
`INDArray`	INDArray.`reorder(int[] order)` Returns a re-ordered array by taking the specified order of slices along dimension 0
`INDArray`	INDArray.`reorder(int dimension, int[] order)` Returns a re-ordered array by taking the specified order of slices along a given dimension May or may not use views of underlying slices (i.e.
`INDArray`	NDArray.`reshape(int... dimensions)`
`INDArray`	INDArray.`reshape(int... shape)` Returns a new array by rearranging the elements of this array into the desired shape Truncates or zero-pads the elements as required to fill the new shape
`INDArray`	INDArray.`rotateView(int dimension, int shift)` Returns rotated view of this array
`INDArray`	INDArray.`scaleCopy(double factor)` Deprecated.
`INDArray`	INDArray.`signumCopy()` Returns a copy of the array with the signum operator applied to each element
`INDArray`	NDArray.`slice(int majorSlice)`
`INDArray`	INDArray.`slice(int majorSlice)` Returns the specified major slice of this array as a view (slice along dimension 0) 0 dimensional slice results are permitted, but attempting to slice a 0 dimensional array will result in an error.
`INDArray`	Array.`slice(int majorSlice)`
`INDArray`	NDArray.`slice(int dimension, int index)`
`INDArray`	INDArray.`slice(int dimension, int index)` Returns a slice view of this array along the specified dimension
`INDArray`	Array.`slice(int dimension, int index)`
`INDArray`	INDArray.`sparse()` Coerces this INDArray to a sparse format, without changing its element values.
`INDArray`	INDArray.`sparseClone()` Creates a fully mutable clone of this array.
`INDArray`	INDArray.`squareCopy()` Squares all elements of the array, returning a new array
`INDArray`	INDArray.`subArray(int[] offsets, int[] shape)` Returns a subarray view of a larger array
`INDArray`	Array.`subArray(int[] offsets, int[] shape)`
`INDArray`	INDArray.`subCopy(INDArray a)` Creates a new array equal to the subtraction of another array from this array
`INDArray[]`	INDArray.`toSliceArray()` Copies the slices of this array to a new INDArray[]
`INDArray`	INDArray.`withComponents(INDArray... components)` Returns a new array of the same shape/structure as the original but with the specified components.
`static INDArray`	Array.`wrap(double[] data, int... shape)` Wraps double[] array data in an Array of the specified shape.
`static INDArray`	Arrayz.`wrap(double[] data, int[] shape)` Creates an INDArray instance wrapping the given double data, with the provided shape.
`static INDArray`	NDArray.`wrapStrided(double[] data, int offset, int[] shape, int[] strides)`
`static INDArray`	Arrayz.`wrapStrided(double[] data, int offset, int[] shape, int[] strides)`

Methods in mikera.arrayz that return types with arguments of type INDArray
Modifier and Type	Method and Description
`List<INDArray>`	NDArray.`getSlices()`
`List<INDArray>`	INDArray.`getSliceViews()` Returns a list of slices as mutable INDArray views.

Methods in mikera.arrayz with parameters of type INDArray
Modifier and Type	Method and Description
`void`	INDArray.`add(INDArray a)` Adds all the elements of another array to this array, in an elementwise order.
`INDArray`	INDArray.`addCopy(INDArray a)` Creates a new array equal to the sum of this array with another array.
`void`	INDArray.`addInnerProduct(INDArray a, INDArray b)` Adds the inner product of two arrays to this array.
`void`	INDArray.`addMultiple(INDArray src, double factor)` Adds a scaled multiple of another array to this array
`void`	INDArray.`addOuterProduct(INDArray a, INDArray b)` Adds the outer product of two arrays to this array.
`void`	INDArray.`addPower(INDArray src, double exponent)` Adds an array with all elements raised to the specified power
`void`	INDArray.`addPower(INDArray src, double exponent, double factor)` Adds an array with all elements raised to the specified power and scaled by the given factor
`void`	INDArray.`applyOp(Op2 op, INDArray b)` Applies a binary operator to this array and a second array.
`INDArray`	INDArray.`broadcastCloneLike(INDArray target)` Creates a mutable clone of the array, broadcasted upwards if necessary to match the shape of the target.
`INDArray`	INDArray.`broadcastCopyLike(INDArray target)` Creates a copy of the array, broadcasted upwards if necessary to match the shape of the target Like broadCastCloneLike, but does not guarantee a mutable clone - hence may be faster when used with immutable or specialized arrays
`INDArray`	INDArray.`broadcastLike(INDArray target)` Broadcasts an array to match the shape of the target
`static void`	Arrayz.`checkShape(INDArray array, int dimension, int index)` Checks that a specified index exists along a specified dimension.
`static INDArray`	Arrayz.`create(INDArray a)`
`static Array`	Array.`create(INDArray a)` Crates a new Array with a copt of the data from the sepcified array, in the same shape
`static INDArray`	Arrayz.`createSparse(INDArray a)` Creates a sparse copy of the given array.
`static INDArray`	Arrayz.`createSparseMutable(INDArray a)` Creates a fully mutable sparse clone of the given array
`void`	INDArray.`divide(INDArray a)` Divides all elements in place by the equivalent elements in a second array
`INDArray`	INDArray.`divideCopy(INDArray a)` Divides all elements by the equivalent elements in a second array.
`boolean`	INDArray.`epsilonEquals(INDArray a)` Tests if this array is approximately equal to another array.
`boolean`	INDArray.`epsilonEquals(INDArray a, double epsilon)` Tests is this array is approximately equal to another array, up to a given tolerance (epsilon) The arrays must have the same shape
`boolean`	NDArray.`equals(INDArray a)`
`boolean`	INDArray.`equals(INDArray a)` Checks if two arrays are equal exactly in terms of both value and shape
`boolean`	Array.`equals(INDArray a)`
`static void`	Arrayz.`fillNormal(INDArray a, long seed)`
`static void`	Arrayz.`fillNormal(INDArray a, Random random)`
`static void`	Arrayz.`fillRandom(INDArray a, long seed)`
`static void`	Arrayz.`fillRandom(INDArray a, Random random)`
`INDArray`	INDArray.`innerProduct(INDArray a)` Calculates the inner product of this array with another array.
`boolean`	INDArray.`isSameShape(INDArray a)` Returns true if this array is the same shape as another array
`INDArray`	INDArray.`join(INDArray a)` Joins an array with another array along the major dimension
`INDArray`	INDArray.`join(INDArray a, int dimension)` Joins an array with another array along a specified dimension
`void`	INDArray.`multiply(INDArray a)` Multiplies all elements by the equivalent elements in a second array, i.e.
`INDArray`	INDArray.`multiplyCopy(INDArray a)` Multiplies all elements by the equivalent elements in a second array, i.e.
`INDArray`	INDArray.`outerProduct(INDArray a)` Calculates the outer product of this array with another array.
`void`	INDArray.`scaleAdd(double factor, INDArray b, double bfactor, double constant)` Scales all elements of the array by a given double value, adds a scaled second array and adds a constant value
`void`	INDArray.`set(INDArray a)` Sets this array to the element values contained in another array.
`void`	INDArray.`setInnerProduct(INDArray a, INDArray b)` Sets this array to the inner product of two arrays.
`void`	INDArray.`setMultiple(INDArray a, double b)` Sets this array to be the multiple of another array.
`void`	INDArray.`setMultiple(INDArray a, INDArray b)` Sets this array to the element-wise multiple of two arrays.
`void`	INDArray.`sub(INDArray a)` Subtracts all the elements of another array from this array, in an elementwise order.
`INDArray`	INDArray.`subCopy(INDArray a)` Creates a new array equal to the subtraction of another array from this array
`INDArray`	INDArray.`withComponents(INDArray... components)` Returns a new array of the same shape/structure as the original but with the specified components.
`static NDArray`	NDArray.`wrap(INDArray a)`

Uses of INDArray in mikera.arrayz.impl

Classes in mikera.arrayz.impl with type parameters of type INDArray
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 Must have dimensionality 1 or above, and at least one slice

Subinterfaces of INDArray in mikera.arrayz.impl
Modifier and Type	Interface and Description
`interface`	`IStridedArray` Interface for arrays that support strided access over underlying data

Classes in mikera.arrayz.impl that implement INDArray
Modifier and Type	Class and Description
`class`	`AbstractArray<T>` Abstract base class for INDArray implementations Contains generic implementations for most INDArray operations, enabling new INDArray implementations to inherit these (at least until more optimised implementations can be written).
`class`	`BaseNDArray` Base class for NDArray implementations.
`class`	`BaseShapedArray` Abstract base class for N-dimensional arrays that use a fixed int[] shape vector.
`class`	`BroadcastScalarArray` Specialized array class representing the broadcasting of a scalar value to fill an entire array.
`class`	`ImmutableArray` Immutable N-dimensional array class Uses strided array storage
`class`	`JoinedArray` Array created by joining two arrays along a specific dimension
`class`	`SliceArray<T extends INDArray>` A general N-dimensional double array implemented as a collection of (n-1) dimensional slices Must have dimensionality 1 or above, and at least one slice
`class`	`ZeroArray` Class representing an immutable array filled entirely with zeros.

Methods in mikera.arrayz.impl with type parameters of type INDArray
Modifier and Type	Method and Description
`static <T extends INDArray> SliceArray<T>`	SliceArray.`create(INDArray a)`
`static <T extends INDArray> SliceArray<T>`	SliceArray.`of(T... slices)`

Methods in mikera.arrayz.impl that return INDArray
Modifier and Type	Method and Description
`INDArray`	AbstractArray.`absCopy()`
`INDArray`	AbstractArray.`addCopy(double d)`
`INDArray`	ZeroArray.`addCopy(INDArray a)`
`INDArray`	AbstractArray.`addCopy(INDArray a)`
`INDArray`	AbstractArray.`applyOpCopy(Op op)`
`INDArray`	AbstractArray.`broadcast(int... targetShape)`
`INDArray`	AbstractArray.`broadcastCloneLike(INDArray target)`
`INDArray`	AbstractArray.`broadcastCopyLike(INDArray target)`
`INDArray`	AbstractArray.`broadcastLike(INDArray target)`
`INDArray`	ZeroArray.`clone()`
`INDArray`	AbstractArray.`clone()`
`INDArray`	AbstractArray.`copy()`
`static INDArray`	BroadcastScalarArray.`create(double d, int[] targetShape)`
`static INDArray`	ImmutableArray.`create(INDArray a)`
`INDArray`	AbstractArray.`dense()`
`INDArray`	AbstractArray.`denseClone()`
`INDArray`	AbstractArray.`divideCopy(INDArray a)`
`INDArray`	AbstractArray.`ensureMutable()`
`INDArray`	JoinedArray.`exactClone()`
`INDArray`	ImmutableArray.`exactClone()`
`INDArray`	JoinedArray.`getComponent(int k)`
`INDArray`	AbstractArray.`getComponent(int k)`
`INDArray[]`	SliceArray.`getComponents()`
`INDArray[]`	AbstractArray.`getComponents()`
`INDArray`	AbstractArray.`getTranspose()`
`INDArray`	AbstractArray.`getTransposeCopy()`
`INDArray`	AbstractArray.`getTransposeView()`
`INDArray`	AbstractArray.`immutable()`
`INDArray`	AbstractArray.`innerProduct(AScalar s)`
`INDArray`	AbstractArray.`innerProduct(AVector a)`
`INDArray`	AbstractArray.`innerProduct(double a)`
`INDArray`	SliceArray.`innerProduct(INDArray a)`
`INDArray`	AbstractArray.`innerProduct(INDArray a)`
`INDArray`	AbstractArray.`join(INDArray a)`
`INDArray`	AbstractArray.`join(INDArray a, int dimension)`
`INDArray`	AbstractArray.`multiplyCopy(double d)`
`INDArray`	AbstractArray.`multiplyCopy(INDArray a)`
`INDArray`	AbstractArray.`mutable()`
`INDArray`	AbstractArray.`negateCopy()`
`INDArray`	SliceArray.`outerProduct(INDArray a)`
`INDArray`	AbstractArray.`outerProduct(INDArray a)`
`INDArray`	AbstractArray.`reciprocalCopy()`
`INDArray`	AbstractArray.`reorder(int[] order)`
`INDArray`	AbstractArray.`reorder(int dim, int[] order)`
`INDArray`	SliceArray.`reshape(int... dimensions)`
`INDArray`	AbstractArray.`reshape(int... targetShape)`
`INDArray`	AbstractArray.`rotateView(int dimension, int shift)`
`INDArray`	AbstractArray.`scaleCopy(double d)`
`INDArray`	AbstractArray.`signumCopy()`
`INDArray`	ZeroArray.`slice(int majorSlice)`
`INDArray`	JoinedArray.`slice(int majorSlice)`
`INDArray`	ImmutableArray.`slice(int majorSlice)`
`INDArray`	BroadcastScalarArray.`slice(int majorSlice)`
`INDArray`	ZeroArray.`slice(int dimension, int index)`
`INDArray`	SliceArray.`slice(int dimension, int index)`
`INDArray`	JoinedArray.`slice(int dimension, int index)`
`INDArray`	ImmutableArray.`slice(int dimension, int index)`
`INDArray`	BroadcastScalarArray.`slice(int dimension, int index)`
`INDArray`	AbstractArray.`sparse()`
`INDArray`	ZeroArray.`sparseClone()`
`INDArray`	ImmutableArray.`sparseClone()`
`INDArray`	AbstractArray.`sparseClone()`
`INDArray`	AbstractArray.`squareCopy()`
`INDArray`	AbstractArray.`subArray(int[] offsets, int[] shape)`
`INDArray`	AbstractArray.`subCopy(INDArray a)`
`INDArray[]`	SliceArray.`toSliceArray()`
`INDArray[]`	AbstractArray.`toSliceArray()`
`INDArray`	AbstractArray.`withComponents(INDArray... cs)`
`static INDArray`	ImmutableArray.`wrap(double[] data, int[] shape)`

Methods in mikera.arrayz.impl that return types with arguments of type INDArray
Modifier and Type	Method and Description
`static SliceArray<INDArray>`	SliceArray.`create(List<INDArray> slices)`
`static SliceArray<INDArray>`	SliceArray.`create(List<INDArray> slices, int[] shape)`
`List<INDArray>`	ZeroArray.`getSlices()`
`List<INDArray>`	AbstractArray.`getSliceViews()`
`static SliceArray<INDArray>`	SliceArray.`repeat(INDArray s, int n)`

Methods in mikera.arrayz.impl with parameters of type INDArray
Modifier and Type	Method and Description
`void`	AbstractArray.`add(INDArray a)`
`INDArray`	ZeroArray.`addCopy(INDArray a)`
`INDArray`	AbstractArray.`addCopy(INDArray a)`
`void`	AbstractArray.`addInnerProduct(AMatrix a, INDArray b)` Adds the inner product of a matrix and an array to this array
`void`	AbstractArray.`addInnerProduct(AVector a, INDArray b)` Adds the inner product of a vector and an array to this array
`void`	AbstractArray.`addInnerProduct(INDArray a, INDArray b)`
`void`	AbstractArray.`addMultiple(INDArray src, double factor)`
`void`	AbstractArray.`addOuterProduct(INDArray a, INDArray b)`
`void`	AbstractArray.`addPower(INDArray src, double exponent)`
`void`	AbstractArray.`addPower(INDArray src, double exponent, double factor)`
`void`	AbstractArray.`applyOp(Op2 op, INDArray b)`
`INDArray`	AbstractArray.`broadcastCloneLike(INDArray target)`
`INDArray`	AbstractArray.`broadcastCopyLike(INDArray target)`
`INDArray`	AbstractArray.`broadcastLike(INDArray target)`
`static INDArray`	ImmutableArray.`create(INDArray a)`
`static <T extends INDArray> SliceArray<T>`	SliceArray.`create(INDArray a)`
`void`	AbstractArray.`divide(INDArray a)`
`INDArray`	AbstractArray.`divideCopy(INDArray a)`
`boolean`	AbstractArray.`epsilonEquals(INDArray a)`
`boolean`	AbstractArray.`epsilonEquals(INDArray a, double epsilon)`
`boolean`	ZeroArray.`equals(INDArray a)`
`boolean`	SliceArray.`equals(INDArray a)`
`boolean`	AbstractArray.`equals(INDArray a)`
`INDArray`	SliceArray.`innerProduct(INDArray a)`
`INDArray`	AbstractArray.`innerProduct(INDArray a)`
`boolean`	AbstractArray.`isSameShape(INDArray a)`
`INDArray`	AbstractArray.`join(INDArray a)`
`static JoinedArray`	JoinedArray.`join(INDArray a, INDArray b, int dim)`
`INDArray`	AbstractArray.`join(INDArray a, int dimension)`
`void`	AbstractArray.`multiply(INDArray a)`
`INDArray`	AbstractArray.`multiplyCopy(INDArray a)`
`static <T extends INDArray> SliceArray<T>`	SliceArray.`of(T... slices)`
`INDArray`	SliceArray.`outerProduct(INDArray a)`
`INDArray`	AbstractArray.`outerProduct(INDArray a)`
`static SliceArray<INDArray>`	SliceArray.`repeat(INDArray s, int n)`
`void`	AbstractArray.`scaleAdd(double factor, INDArray b, double bfactor, double constant)`
`void`	AbstractArray.`set(INDArray a)`
`void`	AbstractArray.`setInnerProduct(INDArray a, INDArray b)`
`void`	AbstractArray.`setMultiple(INDArray a, double b)`
`void`	AbstractArray.`setMultiple(INDArray a, INDArray b)`
`void`	AbstractArray.`sub(INDArray a)`
`INDArray`	AbstractArray.`subCopy(INDArray a)`
`INDArray`	AbstractArray.`withComponents(INDArray... cs)`

Method parameters in mikera.arrayz.impl with type arguments of type INDArray
Modifier and Type	Method and Description
`static SliceArray<INDArray>`	SliceArray.`create(List<INDArray> slices)`
`static SliceArray<INDArray>`	SliceArray.`create(List<INDArray> slices, int[] shape)`

Constructors in mikera.arrayz.impl with parameters of type INDArray
Constructor and Description
`SliceElementIterator(INDArray source)`
`SliceElementIterator(INDArray source, int start, int length)`
`SliceIterator(INDArray source)`
`SliceIterator(INDArray source, int start, int length)`

Uses of INDArray in mikera.matrixx

Subinterfaces of INDArray in mikera.matrixx
Modifier and Type	Interface and Description
`interface`	`IMatrix` Interface for matrix operations.

Classes in mikera.matrixx that implement INDArray
Modifier and Type	Class and Description
`class`	`AMatrix` Abstract 2D matrix class.
`class`	`Matrix` Standard MxN matrix class backed by a densely packed double[] array This is the most efficient Vectorz type for dense 2D matrices.
`class`	`Matrix11` Optimised 1x1 matrix implementation
`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

Methods in mikera.matrixx that return INDArray
Modifier and Type	Method and Description
`INDArray`	AMatrix.`addCopy(INDArray a)`
`INDArray`	AMatrix.`broadcast(int... targetShape)`
`INDArray`	AMatrix.`broadcastCloneLike(INDArray target)`
`INDArray`	AMatrix.`broadcastCopyLike(INDArray target)`
`INDArray`	AMatrix.`broadcastLike(INDArray target)`
`INDArray`	AMatrix.`immutable()`
`INDArray`	AMatrix.`innerProduct(INDArray a)`
`INDArray`	AMatrix.`join(INDArray a, int dimension)`
`INDArray`	AMatrix.`outerProduct(INDArray a)`
`INDArray`	AMatrix.`reshape(int... dimensions)`
`INDArray`	AMatrix.`rotateView(int dimension, int shift)`

Methods in mikera.matrixx that return types with arguments of type INDArray
Modifier and Type	Method and Description
`List<INDArray>`	AMatrix.`getSliceViews()`

Methods in mikera.matrixx with parameters of type INDArray
Modifier and Type	Method and Description
`void`	AMatrix.`add(INDArray a)`
`INDArray`	AMatrix.`addCopy(INDArray a)`
`void`	AMatrix.`addInnerProduct(AMatrix a, INDArray b)`
`void`	AMatrix.`addInnerProduct(INDArray a, INDArray b)`
`void`	AMatrix.`addMultiple(INDArray src, double factor)`
`void`	AMatrix.`addOuterProduct(INDArray a, INDArray b)`
`void`	AMatrix.`applyOp(Op2 op, INDArray b)`
`INDArray`	AMatrix.`broadcastCloneLike(INDArray target)`
`INDArray`	AMatrix.`broadcastCopyLike(INDArray target)`
`INDArray`	AMatrix.`broadcastLike(INDArray target)`
`static Matrix`	Matrix.`create(INDArray m)`
`static AMatrix`	Matrixx.`createFromVectors(INDArray... data)` Create a matrix using as array of vectors which represent the data for each row
`static SparseRowMatrix`	Matrixx.`createSparseRows(INDArray a)` Creates a SparseRowMatrix matrix from the given INDArray, ignoring zeros
`void`	AMatrix.`divide(INDArray a)`
`boolean`	AMatrix.`epsilonEquals(INDArray a)`
`boolean`	AMatrix.`epsilonEquals(INDArray a, double epsilon)`
`boolean`	AMatrix.`equals(INDArray v)`
`INDArray`	AMatrix.`innerProduct(INDArray a)`
`boolean`	AMatrix.`isSameShape(INDArray a)`
`INDArray`	AMatrix.`join(INDArray a, int dimension)`
`void`	AMatrix.`multiply(INDArray a)`
`INDArray`	AMatrix.`outerProduct(INDArray a)`
`void`	AMatrix.`scaleAdd(double factor, INDArray b, double bfactor, double constant)`
`void`	AMatrix.`set(INDArray a)`
`void`	AMatrix.`sub(INDArray a)`

Method parameters in mikera.matrixx with type arguments of type INDArray
Modifier and Type	Method and Description
`static AMatrix`	Matrixx.`createFromVectors(List<INDArray> data)` Create a matrix using a list of vectors as the data for each row
`static AMatrix`	Matrixx.`createSparse(Iterable<INDArray> slices)` Creates a sparse matrix using the given arrays as slices

Uses of INDArray in mikera.matrixx.impl

Subinterfaces of INDArray in mikera.matrixx.impl
Modifier and Type	Interface and Description
`interface`	`IFastColumns` Marker interface for matrices with fast column access General intention is that any matrix that implements this must have a fast getColumn(), typically - O(1) time and space - An efficient vector type returned
`interface`	`IFastRows` Marker interface for matrices with fast row access General intention is that any matrix that implements this must have a fast getRow(), typically - O(1) time and space - An efficient vector type returned (a strided vector or better)

Classes in mikera.matrixx.impl that implement INDArray
Modifier and Type	Class and Description
`class`	`AArrayMatrix` Abstract class for a Matrix backed with a single double[] data array Dimensions are fixed, but leaves open the possibility of arbitrary indexing
`class`	`ABandedMatrix` Abstract base class for banded matrices Banded matrix implementations are assumed to store their data efficiently in diagonal bands, so functions on banded matrices can be designed to exploit this fact.
`class`	`ABlockMatrix` Abstract base class for a large matrix constructed out of regular subMatrix blocks
`class`	`ABooleanMatrix` Abstract base class for matrices limited to boolean 0/1 values Such matrices allow for various efficient representations
`class`	`ADenseArrayMatrix` Abstract base class for matrices wrapping a dense (rows*cols) subset of a double[] array
`class`	`ADiagonalMatrix` Abstract base class for square diagonal matrices
`class`	`APrimitiveMatrix` Abstract base class for the small square primitive backed matrices
`class`	`ARectangularMatrix` Abstract class for regular rectangular matrices that maintain a final fixed row and column count.
`class`	`ASingleBandMatrix` Abstract base class to represent sparse matrices with a single non-zero band Unlike ADiagonalMatrix, this matrix need not be square, and may have non-zero values on an arbitrary diagonal.
`class`	`ASparseRCMatrix` Abstract base class for matrices that store sparse rows or columns.
`class`	`AStridedMatrix` Abstract base class for arbitrary strided matrices
`class`	`ATriangularMatrix` Abstract base class for densely packed triangular matrices (upper and lower)
`class`	`AVectorMatrix<T extends AVector>` Abstract base class for matrices that use a collection of Vectors as storage for the matrix rows.
`class`	`BandedMatrix` Sparse banded matrix implementation.
`class`	`BaseStridedMatrix`
`class`	`BlockDiagonalMatrix` Class representing a square, block diagonal matrix.
`class`	`BroadcastVectorMatrix` Specialised class representing the broadcasting of a vector to a matrix shape.
`class`	`BufferMatrix` A matrix class implemented using a java.nio.DoubleBuffer Intended for use with native libraries that require interop with buffer memory
`class`	`ColumnMatrix` Matrix class that wraps a vector as a single-column matrix
`class`	`DenseColumnMatrix` A densely packed matrix organised in column-major format.
`class`	`DiagonalMatrix` Specialised diagonal matrix class, with dense double[] array storage for the leading diagonal only.
`class`	`IdentityMatrix` Specialised identity matrix class.
`class`	`ImmutableMatrix` Immutable dense matrix class This is the immutable equivalent of mikera.matrixx.Matrix
`class`	`LowerTriangularMatrix` Class for a lower triangular matrix packed densely by rows.
`class`	`MatrixBandView` Vector class representing a view of a matrix band
`class`	`MatrixColumnView` A class representing a view of a matrix column as a vector Used where no better implementations for getColumnView(...) on a matrix exist.
`class`	`MatrixRowView` A class representing a view of a matrix row as a vector.
`class`	`PermutationMatrix` Class representing a square permutation matrix i.e.
`class`	`PermutedMatrix` Matrix class representing a permuted view of a matrix
`class`	`QuadtreeMatrix` A matrix implemented as a quadtree of submatrices.
`class`	`RowMatrix` Matrix class that wraps a vector as a single-row matrix
`class`	`ScalarMatrix` Immutable scalar matrix class - a diagonal matrix with an identical value along the leading diagonal.
`class`	`SparseColumnMatrix` Matrix stored as a collection of normally sparse column vectors This format is especially efficient for: - transposeInnerProduct() with another matrix - access via getColumn() operation - transpose into SparseRowMatrix
`class`	`SparseRowMatrix` Matrix stored as a collection of normally sparse row vectors.
`class`	`StridedMatrix` A general purpose strided matrix implementation
`class`	`StridedRowMatrix` A strided matrix implementation with a column stride of 1 Provides a fast, mutable subMatrix view for the dense Matrix class
`class`	`SubMatrixView` Matrix class that wraps a SubMatrix of another matrix
`class`	`TransposedMatrix` Class representing a transposed view of another matrix The transposed matrix is a reference to the underlying matrix data
`class`	`UpperTriangularMatrix` Class for an upper triangular matrix packed densely by columns.
`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.

Methods in mikera.matrixx.impl that return INDArray
Modifier and Type	Method and Description
`static INDArray`	SparseRowMatrix.`create(ArrayList<INDArray> slices, int rows, int cols)`

Methods in mikera.matrixx.impl with parameters of type INDArray
Modifier and Type	Method and Description
`boolean`	ADenseArrayMatrix.`equals(INDArray a)`
`boolean`	ARectangularMatrix.`isSameShape(INDArray m)`

Method parameters in mikera.matrixx.impl with type arguments of type INDArray
Modifier and Type	Method and Description
`static INDArray`	SparseRowMatrix.`create(ArrayList<INDArray> slices, int rows, int cols)`

Uses of INDArray in mikera.vectorz

Subinterfaces of INDArray in mikera.vectorz
Modifier and Type	Interface and Description
`interface`	`IScalar` Interface for scalar array objects
`interface`	`IVector` Basic interface for a Vector Implementations should normally extend AVector directly, which implements IVector plus a considerable amount of other important functionality.

Classes in mikera.vectorz that implement INDArray
Modifier and Type	Class and Description
`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` Boolean vector backed by densely packed single bits - constrained to 0.0 / 1.0 values Setting the BitVector will set to 1.0 for any positive values (true) and 0.0 otherwise (false) Intended for compact representation/storage of boolean vectors
`class`	`GrowableVector` Implements a growable vector, intended for incrementally building vectors Supports the following operations which etend the vector's length: - set (when used beyond array length) - append (adds a value to the end of the vector, extending length by one) Note that getting the underlying array or a subVector is unsafe, since the underlying array may be discarded as the vector is grown.
`class`	`Scalar` Basic Scalar class containing a single mutable double value
`class`	`Vector` General purpose vector of arbitrary length, backed by an densely packed 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

Methods in mikera.vectorz that return INDArray
Modifier and Type	Method and Description
`INDArray`	AVector.`addCopy(INDArray a)`
`INDArray`	AVector.`broadcast(int... targetShape)`
`INDArray`	AScalar.`broadcast(int... targetShape)`
`INDArray`	AVector.`broadcastLike(INDArray target)`
`INDArray`	AScalar.`broadcastLike(INDArray v)`
`static INDArray`	Scalar.`create(Number number)`
`INDArray`	AScalar.`dense()`
`INDArray`	AVector.`divideCopy(INDArray a)`
`INDArray`	AVector.`innerProduct(INDArray a)`
`INDArray`	AScalar.`innerProduct(INDArray a)`
`INDArray`	AVector.`join(INDArray a, int dimension)`
`INDArray`	AVector.`multiplyCopy(INDArray a)`
`INDArray`	AVector.`outerProduct(INDArray a)`
`INDArray`	AScalar.`outerProduct(INDArray a)`
`INDArray`	AVector.`reshape(int... dimensions)`
`INDArray`	AScalar.`reshape(int... dimensions)`
`INDArray`	AVector.`rotateView(int dimension, int shift)`
`INDArray`	AScalar.`slice(int position)`
`INDArray`	AScalar.`slice(int dimension, int index)`
`INDArray`	AVector.`subCopy(INDArray a)`
`INDArray[]`	AVector.`toSliceArray()`
`INDArray[]`	AScalar.`toSliceArray()`

Methods in mikera.vectorz with parameters of type INDArray
Modifier and Type	Method and Description
`void`	AVector.`add(INDArray a)`
`void`	AScalar.`add(INDArray a)`
`INDArray`	AVector.`addCopy(INDArray a)`
`void`	AVector.`addInnerProduct(INDArray a, INDArray b)`
`void`	AScalar.`addInnerProduct(INDArray a, INDArray b)`
`void`	AVector.`addMultiple(INDArray src, double factor)`
`void`	AVector.`addPower(INDArray src, double exponent)`
`void`	AVector.`addPower(INDArray src, double exponent, double factor)`
`void`	AVector.`applyOp(Op2 op, INDArray b)`
`void`	AScalar.`applyOp(Op2 op, INDArray b)`
`void`	Op.`applyTo(INDArray a)` Applies this operator to every element of a target array.
`void`	Op2.`applyTo(INDArray a, INDArray b)`
`INDArray`	AVector.`broadcastLike(INDArray target)`
`INDArray`	AScalar.`broadcastLike(INDArray v)`
`static Vector`	Vector.`create(INDArray a)`
`void`	AVector.`divide(INDArray a)`
`INDArray`	AVector.`divideCopy(INDArray a)`
`boolean`	AVector.`epsilonEquals(INDArray a)`
`boolean`	AScalar.`epsilonEquals(INDArray a)`
`boolean`	AVector.`epsilonEquals(INDArray a, double tolerance)`
`boolean`	AScalar.`epsilonEquals(INDArray a, double epsilon)`
`boolean`	AVector.`equals(INDArray v)`
`boolean`	AScalar.`equals(INDArray o)`
`INDArray`	AVector.`innerProduct(INDArray a)`
`INDArray`	AScalar.`innerProduct(INDArray a)`
`boolean`	AVector.`isSameShape(INDArray a)`
`AVector`	AVector.`join(INDArray b)` Returns a new vector that refers to this vector joined to a second vector.
`INDArray`	AVector.`join(INDArray a, int dimension)`
`void`	AVector.`multiply(INDArray a)`
`void`	AScalar.`multiply(INDArray a)`
`INDArray`	AVector.`multiplyCopy(INDArray a)`
`INDArray`	AVector.`outerProduct(INDArray a)`
`INDArray`	AScalar.`outerProduct(INDArray a)`
`void`	AVector.`scaleAdd(double factor, INDArray b, double bfactor, double constant)`
`void`	AVector.`set(INDArray a)`
`void`	AVector.`setInnerProduct(INDArray a, INDArray b)`
`void`	AVector.`setMultiple(INDArray a, double b)`
`void`	AVector.`setMultiple(INDArray a, INDArray b)`
`void`	AVector.`sub(INDArray a)`
`void`	AScalar.`sub(INDArray a)`
`INDArray`	AVector.`subCopy(INDArray a)`

Uses of INDArray in mikera.vectorz.impl

Subinterfaces of INDArray in mikera.vectorz.impl
Modifier and Type	Interface and Description
`interface`	`ISparseVector`

Classes in mikera.vectorz.impl that implement INDArray
Modifier and Type	Class and Description
`class`	`AArrayVector` Base class for all vectors backed by a single final double[] array Supports arbitrary indexing: array elements may not correspond to vector elements in any particular order.
`class`	`ABooleanVector` Abstract base class for boolean vectors Boolean vectors only support two element values, 0.0 and 1.0
`class`	`AComputedVector` Base class for computed vectors.
`class`	`ADenseArrayVector` Base class for mutable dense vectors backed by a double[] array with a fixed stride of 1 The double array can be directly accessed for performance purposes
`class`	`AJoinedVector` Base class for joined vectors Joined vectors are represented as the concatenation of a number of segments.
`class`	`AMatrixViewVector` Abstract Vector class representing a view over a matrix Supports arbitrary indexing into the underlying matrix
`class`	`APrimitiveVector` Abstract base class for specialised primitive vectors
`class`	`ArrayIndexScalar` Scalar class wrapping a single element of a dense double[] array.
`class`	`ArraySubVector` Vector referring to a fixed offset into a double[] array
`class`	`ASingleElementVector` Abstract base classes for sparse vectors that have a single potentially non-zero element
`class`	`ASizedVector` Abstract base class for vectors using a fixed final size
`class`	`ASparseIndexedVector` Base class containing common implementations for sparse indexed vectors
`class`	`ASparseVector` Abstract base class for Sparse vector implementations
`class`	`AStridedVector` Abstract base class for vectors backed by a double[] array with a constant stride The double array can be directly accessed for performance purposes
`class`	`AWrappedVector<T>` Abstract base class for vectors that wrap an underlying object
`class`	`AxisVector` Specialised immutable unit axis vector.
`class`	`BaseDerivedVector` Derived vector delegates all calls element-wise to an underlying vector
`class`	`BaseStridedVector` Base class for strided vectors backed with a double array and fixed offset / stride Supports both mutable an immutable subclasses
`class`	`BufferVector` A vector class implemented using a java.nio.DoubleBuffer Intended for use with native libraries that require interop with buffer memory
`class`	`GrowableIndexedVector` Implementation for a sparse indexed vector that can accumulate index/value pairs efficiently (in order) Length grows if elements are added beyond the end of the vector
`class`	`ImmutableScalar` Immutable scalar class Conceptually equivalent to a wrapped Double value, but supports all the Vectorz interfaces and functionality as a scalar object.
`class`	`ImmutableVector` Immutable array-backed vector.
`class`	`IndexedArrayVector` Vector that addresses elements indexed into double[] array.
`class`	`IndexedSubVector` Vector that addresses elements indexed into another source vector.
`class`	`IndexVector` A constrained immutable vector implementation wrapping an integer Index
`class`	`JoinedArrayVector` Class representing a join of one or more array segments, i.e.
`class`	`JoinedMultiVector` A vector that represents the concatenation of many vectors.
`class`	`JoinedVector` A vector that represents the concatenation of two vectors.
`class`	`MatrixIndexScalar` Class representing a scalar view over a single element indexed from an underlying matrix
`class`	`MatrixViewVector` Specialised class for viewing a matrix as a flattened vector
`class`	`RangeVector` Immutable vector type representing a consecutive, increasing range of integers.
`class`	`RepeatedElementVector` An immutable vector that has the same value for elements.
`class`	`SingleElementVector` A sparse immutable vector that has a only one element that can be non-zero.
`class`	`SparseHashedVector` Hashed sparse vector, intended for large vectors with very few randomly positioned non-zero elements.
`class`	`SparseImmutableVector` Indexed sparse immutable vector Efficient for sparse vectors.
`class`	`SparseIndexedVector` Indexed sparse vector.
`class`	`StridedMatrixViewVector`
`class`	`StridedVector` Mutable strided vector class
`class`	`SubMatrixViewVector` A vector that wraps a sub-matrix of an arbitrary matrix
`class`	`TriangularIndexedVector` Vector with an increasing triangular index.
`class`	`UnmodifiableVector` Unmodifiable wrapped for arbitrary vectors
`class`	`Vector0` Special singleton zero length vector class.
`class`	`VectorIndexScalar`
`class`	`WrappedScalarVector` A length 1 vector, as a view wrapping a single AScalar Main purpose is to provide an efficient view for AScalar.asVector()
`class`	`WrappedSubVector` View class referencing a contiguous subvector of another vector.
`class`	`ZeroVector` Specialised immutable vector containing nothing but zeros.

Methods in mikera.vectorz.impl that return INDArray
Modifier and Type	Method and Description
`INDArray`	AStridedVector.`broadcast(int... shape)`

Methods in mikera.vectorz.impl with parameters of type INDArray
Modifier and Type	Method and Description
`static ZeroVector`	ZeroVector.`create(INDArray array)` Creates a ZeroVector with the same number of elements as the given array.
`boolean`	ADenseArrayVector.`equals(INDArray v)`
`JoinedVector`	JoinedVector.`withComponents(INDArray... segments)`
`AJoinedVector`	JoinedMultiVector.`withComponents(INDArray... segments)`
`AJoinedVector`	JoinedArrayVector.`withComponents(INDArray... segments)`
`abstract AJoinedVector`	AJoinedVector.`withComponents(INDArray... segments)` Reconstructs a new joined vector of the same type and shape with the given segments.

Uses of INDArray in mikera.vectorz.ops

Methods in mikera.vectorz.ops with parameters of type INDArray
Modifier and Type	Method and Description
`void`	Sqrt.`applyTo(INDArray a)`
`void`	Signum.`applyTo(INDArray v)`
`void`	Reciprocal.`applyTo(INDArray a)`
`void`	Power.`applyTo(INDArray a)`
`void`	Offset.`applyTo(INDArray v)`
`void`	Log.`applyTo(INDArray a)`
`void`	Linear.`applyTo(INDArray v)`
`void`	Exp.`applyTo(INDArray a)`
`void`	Constant.`applyTo(INDArray v)`
`void`	Clamp.`applyTo(INDArray v)`
`void`	ALinearOp.`applyTo(INDArray a)`
`void`	Absolute.`applyTo(INDArray v)`

Uses of INDArray in mikera.vectorz.util

Classes in mikera.vectorz.util that implement INDArray
Modifier and Type	Class and Description
`class`	`MatrixBuilder` Utility class for efficiently building matrices by appending vector rows

Methods in mikera.vectorz.util that return INDArray
Modifier and Type	Method and Description
`static INDArray`	Testing.`fillRandom(INDArray a, mikera.util.Random r)` Fills an array with random values in the [0..1) range.

Methods in mikera.vectorz.util with parameters of type INDArray
Modifier and Type	Method and Description
`static INDArray`	Testing.`fillRandom(INDArray a, mikera.util.Random r)` Fills an array with random values in the [0..1) range.
`static String`	ErrorMessages.`incompatibleBroadcast(INDArray a, INDArray b)`
`static String`	ErrorMessages.`incompatibleBroadcast(INDArray a, int... shape)` Returns an error message indicating that a broadcast is not possible e.g.
`static String`	ErrorMessages.`incompatibleShape(INDArray m)`
`static String`	ErrorMessages.`incompatibleShapes(INDArray a, INDArray b)` Returns an error message indicating that two arrays have incompatible shapes.
`static String`	ErrorMessages.`invalidComponent(INDArray a, long i)`
`static String`	ErrorMessages.`invalidDimension(INDArray a, int dimension)`
`static String`	ErrorMessages.`invalidIndex(INDArray a, int... indexes)`
`static String`	ErrorMessages.`invalidIndex(INDArray a, long i)`
`static String`	ErrorMessages.`invalidSlice(INDArray a, int dimension, int slice)`
`static String`	ErrorMessages.`invalidSlice(INDArray a, long slice)`
`static String`	ErrorMessages.`mismatch(INDArray a, INDArray b)` Returns an error message indicating that two arrays have different sizes
`static String`	ErrorMessages.`noElements(INDArray a)`
`static String`	ErrorMessages.`noSlices(INDArray a)`
`static boolean`	Testing.`validateFullyMutable(INDArray m)`
`static String`	ErrorMessages.`zeroElementReduce(INDArray a)`

Uses of Interfacemikera.arrayz.INDArray

Uses of INDArray in mikera.arrayz

Uses of INDArray in mikera.arrayz.impl

Uses of INDArray in mikera.matrixx

Uses of INDArray in mikera.matrixx.impl

Uses of INDArray in mikera.vectorz

Uses of INDArray in mikera.vectorz.impl

Uses of INDArray in mikera.vectorz.ops

Uses of INDArray in mikera.vectorz.util

Uses of Interface
mikera.arrayz.INDArray