Uses of Class
mikera.arrayz.impl.AbstractArray

Packages that use AbstractArray

Package	Description
mikera.arrayz
mikera.arrayz.impl
mikera.matrixx
mikera.matrixx.impl
mikera.vectorz
mikera.vectorz.impl
mikera.vectorz.util

Uses of AbstractArray in mikera.arrayz

Subclasses of AbstractArray in mikera.arrayz

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.

Uses of AbstractArray in mikera.arrayz.impl

Subclasses of AbstractArray in mikera.arrayz.impl

Modifier and Type	Class and Description
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.

Uses of AbstractArray in mikera.matrixx

Subclasses of AbstractArray in mikera.matrixx

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

Uses of AbstractArray in mikera.matrixx.impl

Subclasses of AbstractArray in mikera.matrixx.impl

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.

Uses of AbstractArray in mikera.vectorz

Subclasses of AbstractArray in mikera.vectorz

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

Uses of AbstractArray in mikera.vectorz.impl

Subclasses of AbstractArray in mikera.vectorz.impl

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.

Uses of AbstractArray in mikera.vectorz.util

Subclasses of AbstractArray in mikera.vectorz.util

Modifier and Type	Class and Description
class	MatrixBuilder Utility class for efficiently building matrices by appending vector rows