Uses of Class mikera.vectorz.AVector (Vectorz 0.62.0 API)

Packages that use AVector
Package	Description
mikera.arrayz
mikera.arrayz.impl
mikera.indexz
mikera.matrixx
mikera.matrixx.decompose
mikera.matrixx.decompose.impl.eigen
mikera.matrixx.decompose.impl.svd
mikera.matrixx.impl
mikera.matrixx.solve
mikera.transformz
mikera.transformz.impl
mikera.vectorz
mikera.vectorz.functions
mikera.vectorz.impl
mikera.vectorz.ops
mikera.vectorz.util

Uses of AVector in mikera.arrayz

Methods in mikera.arrayz that return AVector
Modifier and Type	Method and Description
`AVector`	NDArray.`asVector()`
`AVector`	INDArray.`asVector()` Constructs a view of all elements in the array as a single vector in row-major order.
`AVector`	INDArray.`broadcastLike(AVector target)` Broadcasts an array to match the shape of the target vector
`AVector`	INDArray.`reduceSlices(Op2 op)` Reduces each slice of the array by the given operator
`AVector`	INDArray.`reduceSlices(Op2 op, double init)` Reduces each slice of the array by the given operator Uses the specified init value for reduction of each slice

Methods in mikera.arrayz with parameters of type AVector
Modifier and Type	Method and Description
`AVector`	INDArray.`broadcastLike(AVector target)` Broadcasts an array to match the shape of the target vector
`static INDArray`	Arrayz.`createFromVector(AVector a, int... shape)` Creates a new array using the elements in the specified vector.
`static Array`	Array.`createFromVector(AVector a, int... shape)` Creates a new matrix using the elements in the specified vector.
`INDArray`	INDArray.`innerProduct(AVector v)` Computes the inner product of this array with a vector

Uses of AVector in mikera.arrayz.impl

Methods in mikera.arrayz.impl that return AVector
Modifier and Type	Method and Description
`AVector`	ZeroArray.`asVector()`
`AVector`	SliceArray.`asVector()`
`AVector`	ImmutableArray.`asVector()`
`AVector`	AbstractArray.`asVector()`
`AVector`	AbstractArray.`broadcastLike(AVector target)`
`AVector`	AbstractArray.`reduceSlices(Op2 op)`
`AVector`	AbstractArray.`reduceSlices(Op2 op, double init)`

Methods in mikera.arrayz.impl with parameters of type AVector
Modifier and Type	Method and Description
`void`	AbstractArray.`addInnerProduct(AVector a, INDArray b)` Adds the inner product of a vector and an array to this array
`AVector`	AbstractArray.`broadcastLike(AVector target)`
`boolean`	AbstractArray.`equals(AVector a)`
`INDArray`	AbstractArray.`innerProduct(AVector a)`

Uses of AVector in mikera.indexz

Methods in mikera.indexz that return AVector
Modifier and Type	Method and Description
`AVector`	Index.`asVector()`

Methods in mikera.indexz with parameters of type AVector
Modifier and Type	Method and Description
`static Index`	Index.`create(AVector v)` Creates an Index using the values from the given AVector.

Uses of AVector in mikera.matrixx

Methods in mikera.matrixx that return AVector
Modifier and Type	Method and Description
`AVector`	AMatrix.`asVector()` Returns the matrix values as a single reference Vector in the form [row0 row1 row2....]
`AVector`	IMatrix.`getBand(int band)` Gets a band of a matrix The band is defined such that: - 0 is the main diagonal - bands above the main diagonal are 1, 2, 3 etc.
`AVector`	AMatrix.`getBand(int band)` Gets a specific band of the matrix, as a view vector.
`AVector`	AMatrix.`getBandWrapped(int band)`
`AVector`	IMatrix.`getColumn(int column)` Returns a column of the matrix.
`AVector`	AMatrix.`getColumn(int column)`
`AVector`	IMatrix.`getColumnClone(int column)` Returns a column of the matrix as a new cloned, mutable vector The cloned column may be modified without affecting the original matrix.
`AVector`	AMatrix.`getColumnClone(int column)`
`AVector`	IMatrix.`getColumnView(int column)` Returns a column of the matrix as a vector view.
`AVector`	AMatrix.`getColumnView(int column)`
`AVector`	AMatrix.`getLeadingDiagonal()` Returns a vector view of the leading diagonal values of the matrix
`AVector`	IMatrix.`getRow(int row)` Returns a row of the matrix.
`AVector`	AMatrix.`getRow(int row)`
`AVector`	IMatrix.`getRowClone(int row)` Returns a row of the matrix as a new cloned, mutable vector.
`AVector`	AMatrix.`getRowClone(int row)`
`AVector`	IMatrix.`getRowView(int row)` Returns a row of the matrix as a vector view.
`AVector`	AMatrix.`getRowView(int row)`
`AVector`	Matrix33.`innerProduct(AVector a)`
`AVector`	Matrix22.`innerProduct(AVector a)`
`AVector`	IMatrix.`innerProduct(AVector source)` Transforms a source vector into a using matrix multiplication (inner product).
`AVector`	AMatrix.`innerProduct(AVector v)`
`AVector`	AMatrix.`reduceSlices(Op2 op)`
`AVector`	AMatrix.`reduceSlices(Op2 op, double init)`
`AVector`	AMatrix.`slice(int row)`
`AVector`	AMatrix.`slice(int dimension, int index)`
`AVector[]`	AMatrix.`toSliceArray()`

Methods in mikera.matrixx that return types with arguments of type AVector
Modifier and Type	Method and Description
`static ArrayList<AVector>`	Matrixx.`createSparseArray(Iterator<AVector> vecIterator)` Creates a sparse matrix from the given iterator.
`List<AVector>`	IMatrix.`getColumns()` Gets a List of columns of a matrix.
`List<AVector>`	AMatrix.`getColumns()`
`List<AVector>`	IMatrix.`getRows()` Gets a List of rows of a matrix.
`List<AVector>`	AMatrix.`getRows()`
`List<AVector>`	AMatrix.`getSlices()`
`List<AVector>`	AMatrix.`getSlices(int dimension)`
`Iterator<AVector>`	AMatrix.`iterator()` Returns an iterator over rows in this Matrix

Methods in mikera.matrixx with parameters of type AVector
Modifier and Type	Method and Description
`void`	AMatrix.`add(AVector v)` Adds a vector to every row of this matrix.
`AMatrix`	IMatrix.`addCopy(AVector v)` Adds a vector to every row of this matrix, returning a new matrix
`AMatrix`	AMatrix.`addCopy(AVector v)`
`void`	AMatrix.`addMultiple(AVector v, double factor)` Adds a scalar multiple of a vector to every row of this matrix
`void`	AMatrix.`addOuterProduct(AVector a, AVector b)` Adds the outer product of two vectors to this matrix
`void`	AMatrix.`applyOp(Op2 op, AVector b)`
`static Matrix`	Matrix.`create(AVector... data)` Creates a new Matrix using the given vectors as row data
`static DiagonalMatrix`	Matrixx.`createDiagonalMatrix(AVector diagonalValues)` Creates a diagonal matrix using the given vector of values on the main diagonal.
`static Matrix`	Matrixx.`createFromVector(AVector source, int rows, int columns)` Creates a new matrix using the elements in the specified vector.
`static Matrix22`	Matrix22.`createReflectionMatrix(AVector normal)`
`static Matrix33`	Matrixx.`createRotationMatrix(AVector v, double angle)` Create a 3x3 rotation matrix using the given rotation axis and angle in radians
`static AMatrix`	Matrixx.`createSparse(int columnCount, Index[] indexes, AVector[] weights)` Create a sparse array, given an Index of column positions and AVector of corresponding values for each row in the sparse array Performs a defensive copy of underlying data.
`void`	AMatrix.`divide(AVector v)` Divides every row of this matrix by the given vector
`AVector`	Matrix33.`innerProduct(AVector a)`
`AVector`	Matrix22.`innerProduct(AVector a)`
`Vector`	Matrix.`innerProduct(AVector a)`
`AVector`	IMatrix.`innerProduct(AVector source)` Transforms a source vector into a using matrix multiplication (inner product).
`AVector`	AMatrix.`innerProduct(AVector v)`
`void`	AMatrix.`multiply(AVector v)` Multiply each row in this matrix by a vector.
`void`	AMatrix.`replaceColumn(int i, AVector row)` Replaces a column in a matrix, adding the column to the internal structure of the matrix.
`void`	AMatrix.`replaceRow(int i, AVector row)` Replaces a row in a matrix, adding the row to the internal structure of the matrix.
`double`	AMatrix.`rowDotProduct(int i, AVector a)` Returns the dot product of a specific row with a vector.
`void`	Matrix.`set(AVector a)`
`void`	AMatrix.`set(AVector v)` Sets every row of this matrix with the element values from a vector.
`void`	Matrix.`setColumn(int j, AVector col)`
`void`	AMatrix.`setColumn(int i, AVector col)` Sets a column in a matrix.
`void`	Matrix.`setRow(int i, AVector row)`
`void`	AMatrix.`setRow(int i, AVector row)` Sets a row in a matrix to the value specified by the given vector
`void`	AMatrix.`sub(AVector v)` Subtracts a vector from every row of this matrix.
`void`	Matrix33.`transform(AVector source, AVector dest)`
`void`	Matrix22.`transform(AVector source, AVector dest)`
`void`	Matrix.`transform(AVector source, AVector dest)`
`void`	IMatrix.`transform(AVector source, AVector dest)` Transforms a source vector into a destination vector, using matrix multiplication (inner product).
`void`	AMatrix.`transform(AVector source, AVector dest)`
`void`	Matrix22.`transform(Vector2 source, AVector dest)`
`void`	Matrix33.`transform(Vector3 source, AVector dest)`
`void`	Matrix33.`transformInPlace(AVector dest)`
`void`	IMatrix.`transformInPlace(AVector v)`
`void`	AMatrix.`transformInPlace(AVector v)`
`void`	Matrix33.`transformNormal(AVector source, AVector dest)`

Method parameters in mikera.matrixx with type arguments of type AVector
Modifier and Type	Method and Description
`static ArrayList<AVector>`	Matrixx.`createSparseArray(Iterator<AVector> vecIterator)` Creates a sparse matrix from the given iterator.
`static SparseColumnMatrix`	Matrixx.`createSparseColumns(Iterator<AVector> colIterator)`
`static SparseRowMatrix`	Matrixx.`createSparseRows(Iterable<AVector> rows)` Creates a sparse matrix from the given matrix, ignoring zeros.
`static SparseRowMatrix`	Matrixx.`createSparseRows(Iterator<AVector> rowIterator)`

Uses of AVector in mikera.matrixx.decompose

Methods in mikera.matrixx.decompose that return AVector
Modifier and Type	Method and Description
`AVector[]`	IEigenResult.`getEigenVectors()` Used to retrieve an array real valued eigenvectors.
`AVector`	ISVDResult.`getSingularValues()` Returns an array containing singular values.

Uses of AVector in mikera.matrixx.decompose.impl.eigen

Methods in mikera.matrixx.decompose.impl.eigen that return AVector
Modifier and Type	Method and Description
`AVector`	SymmetricQRAlgorithmDecomposition.`getEigenVector(int index)`
`AVector[]`	EigenResult.`getEigenVectors()`

Constructors in mikera.matrixx.decompose.impl.eigen with parameters of type AVector
Constructor and Description
`EigenResult(Vector2[] eigenValues, AVector[] eigenVectors)`

Uses of AVector in mikera.matrixx.decompose.impl.svd

Methods in mikera.matrixx.decompose.impl.svd that return AVector
Modifier and Type	Method and Description
`AVector`	SVDResult.`getSingularValues()`
`AVector`	SvdImplicitQr.`getSingularValues()`

Constructors in mikera.matrixx.decompose.impl.svd with parameters of type AVector
Constructor and Description
`SVDResult(AMatrix U, AMatrix S, AMatrix V, AVector singularValues)`

Uses of AVector in mikera.matrixx.impl

Classes in mikera.matrixx.impl with type parameters of type AVector
Modifier and Type	Class and Description
`class`	`AVectorMatrix<T extends AVector>` Abstract base class for matrices that use a collection of Vectors as storage for the matrix rows.

Subclasses of AVector in mikera.matrixx.impl
Modifier and Type	Class and Description
`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.

Fields in mikera.matrixx.impl declared as AVector
Modifier and Type	Field and Description
`protected AVector[]`	ASparseRCMatrix.`data`
`protected AVector[]`	VectorMatrixMN.`rowData`

Methods in mikera.matrixx.impl that return AVector
Modifier and Type	Method and Description
`AVector`	ZeroMatrix.`asVector()`
`AVector`	SubMatrixView.`asVector()`
`AVector`	StridedRowMatrix.`asVector()`
`AVector`	StridedMatrix.`asVector()`
`AVector`	RowMatrix.`asVector()`
`AVector`	ColumnMatrix.`asVector()`
`AVector`	AVectorMatrix.`asVector()`
`AVector`	MatrixRowView.`clone()`
`AVector`	MatrixColumnView.`clone()`
`static AVector`	MatrixBandView.`create(AMatrix source, int band)`
`AVector`	MatrixBandView.`exactClone()`
`AVector`	MatrixRowList.`get(int index)`
`AVector`	MatrixColumnList.`get(int index)`
`AVector`	ZeroMatrix.`getBand(int band)`
`AVector`	UpperTriangularMatrix.`getBand(int band)`
`AVector`	TransposedMatrix.`getBand(int i)`
`AVector`	LowerTriangularMatrix.`getBand(int band)`
`AVector`	IFastBands.`getBand(int i)`
`AVector`	BandedMatrix.`getBand(int band)`
`abstract AVector`	ATriangularMatrix.`getBand(int i)`
`AVector`	ASingleBandMatrix.`getBand(int band)`
`AVector`	ADiagonalMatrix.`getBand(int band)`
`abstract AVector`	ABandedMatrix.`getBand(int band)`
`AVector`	TransposedMatrix.`getColumn(int column)`
`AVector`	SubMatrixView.`getColumn(int j)`
`AVector`	SparseColumnMatrix.`getColumn(int j)`
`AVector`	IFastColumns.`getColumn(int i)` Gets a column of this matrix.
`AVector`	BroadcastVectorMatrix.`getColumn(int col)`
`AVector`	APrimitiveMatrix.`getColumn(int j)`
`AVector`	ZeroMatrix.`getColumnClone(int col)`
`AVector`	TransposedMatrix.`getColumnClone(int column)`
`AVector`	SubMatrixView.`getColumnClone(int j)`
`AVector`	ASparseRCMatrix.`getColumnClone(int column)`
`AVector`	ZeroMatrix.`getColumnView(int col)`
`AVector`	UpperTriangularMatrix.`getColumnView(int j)`
`AVector`	TransposedMatrix.`getColumnView(int column)`
`AVector`	SubMatrixView.`getColumnView(int j)`
`AVector`	SparseColumnMatrix.`getColumnView(int j)`
`AVector`	RowMatrix.`getColumnView(int i)`
`AVector`	QuadtreeMatrix.`getColumnView(int col)`
`AVector`	PermutedMatrix.`getColumnView(int column)` Returns a column of the permuted matrix as a vector reference
`AVector`	ColumnMatrix.`getColumnView(int i)`
`AVector`	ABlockMatrix.`getColumnView(int col)`
`AVector`	SparseRowMatrix.`getComponent(int k)`
`AVector`	SparseColumnMatrix.`getComponent(int k)`
`AVector`	AVectorMatrix.`getComponent(int i)`
`abstract AVector`	ASparseRCMatrix.`getComponent(int k)`
`AVector`	ZeroMatrix.`getLeadingDiagonal()`
`AVector`	IdentityMatrix.`getLeadingDiagonal()`
`abstract AVector`	ADiagonalMatrix.`getLeadingDiagonal()`
`abstract AVector`	ASingleBandMatrix.`getNonZeroBand()` Gets the non-zero band from the matrix
`AVector`	ADiagonalMatrix.`getNonZeroBand()`
`AVector`	VectorMatrixMN.`getRow(int row)`
`AVector`	TransposedMatrix.`getRow(int row)`
`AVector`	SubMatrixView.`getRow(int i)`
`AVector`	SparseRowMatrix.`getRow(int i)`
`AVector`	IFastRows.`getRow(int i)` Gets a row of this matrix.
`AVector`	BroadcastVectorMatrix.`getRow(int row)`
`AVector`	APrimitiveMatrix.`getRow(int i)`
`AVector`	ZeroMatrix.`getRowClone(int row)`
`AVector`	TransposedMatrix.`getRowClone(int row)`
`AVector`	SubMatrixView.`getRowClone(int i)`
`AVector`	ASparseRCMatrix.`getRowClone(int row)`
`AVector`	ZeroMatrix.`getRowView(int row)`
`AVector`	TransposedMatrix.`getRowView(int row)`
`AVector`	SubMatrixView.`getRowView(int i)`
`AVector`	SparseRowMatrix.`getRowView(int i)`
`AVector`	RowMatrix.`getRowView(int i)`
`AVector`	QuadtreeMatrix.`getRowView(int row)`
`AVector`	PermutedMatrix.`getRowView(int row)` Returns a row of the permuted matrix as a vector reference
`AVector`	LowerTriangularMatrix.`getRowView(int i)`
`AVector`	ColumnMatrix.`getRowView(int i)`
`AVector`	BroadcastVectorMatrix.`getRowView(int row)`
`AVector`	ABlockMatrix.`getRowView(int row)`
`AVector`	ABandedMatrix.`getRowView(int row)`
`AVector`	SparseRowMatrix.`innerProduct(AVector a)`
`AVector`	SparseColumnMatrix.`innerProduct(AVector a)`
`AVector`	IdentityMatrix.`innerProduct(AVector v)`
`AVector`	AVectorMatrix.`innerProduct(AVector v)`
`AVector`	MatrixRowIterator.`next()`
`AVector`	ASparseRCMatrix.`unsafeGetVector(int i)` Gets a vector from the internal data array The vector may be null (indicating a zero row or column)

Methods in mikera.matrixx.impl that return types with arguments of type AVector
Modifier and Type	Method and Description
`List<AVector>`	TransposedMatrix.`getColumns()`
`List<AVector>`	SparseRowMatrix.`getColumns()`
`List<AVector>`	ASparseRCMatrix.`getRotatedData(int outerLen, int innerLen)`
`List<AVector>`	TransposedMatrix.`getRows()`
`List<AVector>`	SparseRowMatrix.`getRows()`
`List<AVector>`	SparseColumnMatrix.`getRows()`

Methods in mikera.matrixx.impl with parameters of type AVector
Modifier and Type	Method and Description
`void`	QuadtreeMatrix.`add(AVector v)`
`void`	MatrixRowView.`add(AVector v)`
`void`	AStridedMatrix.`add(AVector v)`
`void`	ADenseArrayMatrix.`add(AVector v)`
`SparseRowMatrix`	SparseColumnMatrix.`addCopy(AVector v)`
`void`	MatrixRowView.`addMultiple(AVector v, double factor)`
`void`	DenseColumnMatrix.`addOuterProduct(AVector a, AVector b)`
`void`	ADenseArrayMatrix.`addOuterProduct(AVector a, AVector b)`
`void`	MatrixRowView.`applyOp(Op2 op, AVector v)`
`static SparseRowMatrix`	SparseRowMatrix.`create(AVector... vecs)`
`static SparseColumnMatrix`	SparseColumnMatrix.`create(AVector... vecs)`
`static DiagonalMatrix`	DiagonalMatrix.`create(AVector v)`
`static SparseRowMatrix`	SparseRowMatrix.`create(AVector[] data, int rows, int cols)`
`static SparseColumnMatrix`	SparseColumnMatrix.`create(AVector[] data, int rows, int cols)`
`boolean`	MatrixRowView.`equals(AVector v)`
`AVector`	SparseRowMatrix.`innerProduct(AVector a)`
`AVector`	SparseColumnMatrix.`innerProduct(AVector a)`
`Vector`	ImmutableMatrix.`innerProduct(AVector a)`
`AVector`	IdentityMatrix.`innerProduct(AVector v)`
`AVector`	AVectorMatrix.`innerProduct(AVector v)`
`void`	MatrixRowView.`multiply(AVector v)`
`void`	SparseColumnMatrix.`replaceColumn(int i, AVector vec)`
`void`	VectorMatrixMN.`replaceRow(int i, AVector row)`
`void`	VectorMatrixM3.`replaceRow(int i, AVector row)`
`void`	SparseRowMatrix.`replaceRow(int i, AVector vec)`
`abstract void`	AVectorMatrix.`replaceRow(int i, AVector row)` Replaces a row in this matrix.
`double`	ZeroMatrix.`rowDotProduct(int i, AVector v)`
`double`	VectorMatrixMN.`rowDotProduct(int i, AVector inputVector)`
`double`	VectorMatrixM3.`rowDotProduct(int i, AVector inputVector)`
`double`	StridedRowMatrix.`rowDotProduct(int row, AVector v)`
`double`	SparseRowMatrix.`rowDotProduct(int i, AVector a)`
`double`	PermutationMatrix.`rowDotProduct(int i, AVector v)`
`double`	IdentityMatrix.`rowDotProduct(int i, AVector v)`
`double`	DiagonalMatrix.`rowDotProduct(int i, AVector v)`
`double`	AVectorMatrix.`rowDotProduct(int i, AVector inputVector)`
`double`	AStridedMatrix.`rowDotProduct(int i, AVector a)`
`double`	ADiagonalMatrix.`rowDotProduct(int i, AVector v)`
`double`	ADenseArrayMatrix.`rowDotProduct(int i, AVector a)`
`void`	MatrixRowView.`set(AVector v)`
`void`	ADenseArrayMatrix.`set(AVector v)`
`void`	DenseColumnMatrix.`setColumn(int j, AVector col)`
`void`	StridedRowMatrix.`setRow(int row, AVector v)`
`void`	SparseRowMatrix.`setRow(int i, AVector v)`
`void`	DenseColumnMatrix.`setRow(int i, AVector row)`
`void`	ADenseArrayMatrix.`setRow(int i, AVector row)`
`void`	MatrixRowView.`sub(AVector v)`
`void`	ZeroMatrix.`transform(AVector input, AVector output)`
`void`	VectorMatrixMN.`transform(AVector source, AVector dest)`
`void`	VectorMatrixM3.`transform(AVector source, AVector dest)`
`void`	PermutationMatrix.`transform(AVector source, AVector dest)`
`void`	IdentityMatrix.`transform(AVector source, AVector dest)`
`void`	BandedMatrix.`transform(AVector source, AVector dest)`
`void`	AVectorMatrix.`transform(AVector source, AVector dest)`
`void`	ADenseArrayMatrix.`transform(AVector source, AVector dest)`
`void`	VectorMatrixM3.`transform(Vector3 source, AVector dest)`
`void`	ScalarMatrix.`transformInPlace(AVector v)`
`void`	IdentityMatrix.`transformInPlace(AVector v)`
`void`	DiagonalMatrix.`transformInPlace(AVector v)`
`void`	ADiagonalMatrix.`transformInPlace(AVector v)`
`protected void`	ASparseRCMatrix.`unsafeSetVec(int i, AVector vec)`
`static SparseRowMatrix`	SparseRowMatrix.`wrap(AVector... vecs)`
`static SparseColumnMatrix`	SparseColumnMatrix.`wrap(AVector... vecs)`
`static RowMatrix`	RowMatrix.`wrap(AVector v)`
`static ColumnMatrix`	ColumnMatrix.`wrap(AVector v)`
`static VectorMatrixMN`	VectorMatrixMN.`wrap(AVector[] rows)`
`static SparseRowMatrix`	SparseRowMatrix.`wrap(AVector[] vecs, int rows, int cols)`
`static SparseColumnMatrix`	SparseColumnMatrix.`wrap(AVector[] vecs, int rows, int cols)`
`static BroadcastVectorMatrix`	BroadcastVectorMatrix.`wrap(AVector v, int rows)`
`static BandedMatrix`	BandedMatrix.`wrap(int rowCount, int columnCount, int minBand, int maxBand, AVector... bands)`

Method parameters in mikera.matrixx.impl with type arguments of type AVector
Modifier and Type	Method and Description
`static SparseRowMatrix`	SparseRowMatrix.`create(List<AVector> rows)`
`static SparseColumnMatrix`	SparseColumnMatrix.`create(List<AVector> columns)`
`static SparseRowMatrix`	SparseRowMatrix.`wrap(List<AVector> vecs)`
`static SparseColumnMatrix`	SparseColumnMatrix.`wrap(List<AVector> vecs)`

Constructors in mikera.matrixx.impl with parameters of type AVector
Constructor and Description
`ASparseRCMatrix(int rows, int cols, AVector[] data)`
`ColumnMatrix(AVector v)`
`RowMatrix(AVector v)`
`SparseColumnMatrix(AVector... vectors)`
`SparseColumnMatrix(AVector[] data, int rowCount, int columnCount)`
`SparseRowMatrix(AVector... vectors)`
`SparseRowMatrix(AVector[] data, int rowCount, int columnCount)`
`VectorMatrixMN(AVector... rows)`

Constructor parameters in mikera.matrixx.impl with type arguments of type AVector
Constructor and Description
`SparseColumnMatrix(List<AVector> data)`
`SparseColumnMatrix(List<AVector> data, int rowCount, int columnCount)`
`SparseRowMatrix(List<AVector> data)`
`SparseRowMatrix(List<AVector> data, int rowCount, int columnCount)`

Uses of AVector in mikera.matrixx.solve

Methods in mikera.matrixx.solve that return AVector
Modifier and Type	Method and Description
`static AVector`	Linear.`solve(AMatrix A, AVector b)` A general linear system solver, Returns the solution to the equation A.x = b, returns null if A is square and has no unique solution.
`static AVector`	Linear.`solveLeastSquares(AMatrix A, AVector b)` Returns the least squares solution to the equation A.x = b Use this in the case of over-determined (more equations than unknowns) or under-determined (more unknowns than equations)

Methods in mikera.matrixx.solve with parameters of type AVector
Modifier and Type	Method and Description
`static AVector`	Linear.`solve(AMatrix A, AVector b)` A general linear system solver, Returns the solution to the equation A.x = b, returns null if A is square and has no unique solution.
`static AVector`	Linear.`solveLeastSquares(AMatrix A, AVector b)` Returns the least squares solution to the equation A.x = b Use this in the case of over-determined (more equations than unknowns) or under-determined (more unknowns than equations)

Uses of AVector in mikera.transformz

Methods in mikera.transformz that return AVector
Modifier and Type	Method and Description
`AVector`	AAffineTransform.`copyOfTranslationVector()` Returns a deep copy of the translation vector for this affine transform
`AVector`	Translation.`getTranslationVector()`
`abstract AVector`	ATranslation.`getTranslationVector()` Gets the vector offset that this translation represents.
`AVector`	AAffineTransform.`getTranslationVector()` Gets the translation offset that is part of this affine transform.
`AVector`	ATransform.`transform(AVector v)` Transforms a vector, returning a new transformed vector

Methods in mikera.transformz with parameters of type AVector
Modifier and Type	Method and Description
`double`	Translation3.`calculateElement(int i, AVector v)`
`double`	Translation.`calculateElement(int i, AVector v)`
`double`	ATranslation.`calculateElement(int i, AVector v)`
`double`	ATransform.`calculateElement(int i, AVector inputVector)` Calculates a single element of the output.
`double`	AAffineTransform.`calculateElement(int i, AVector v)`
`static ATransform`	Transformz.`constantTransform(int inputDimensions, AVector v)`
`static AAffineTransform`	Transformz.`createAffineTransform(AMatrix m, AVector v)`
`static Affine34`	Transformz.`createAffineTransform(Matrix33 m, AVector v)`
`static ATranslation`	Transformz.`createTranslation(AVector v)`
`AVector`	ATransform.`transform(AVector v)` Transforms a vector, returning a new transformed vector
`void`	Translation3.`transform(AVector source, AVector dest)`
`void`	Translation.`transform(AVector source, AVector dest)`
`void`	OpTransform.`transform(AVector source, AVector dest)`
`void`	ITransform.`transform(AVector source, AVector dest)` Transforms the source vector, storing the result in the given destination vector
`void`	ATranslation.`transform(AVector source, AVector dest)`
`abstract void`	ATransform.`transform(AVector source, AVector dest)`
`void`	AffineMN.`transform(AVector source, AVector dest)`
`void`	Affine34.`transform(AVector source, AVector dest)`
`void`	Affine23.`transform(AVector source, AVector dest)`
`void`	AAffineTransform.`transform(AVector source, AVector dest)`
`void`	Translation3.`transformInPlace(AVector v)`
`void`	Translation.`transformInPlace(AVector v)`
`void`	ATranslation.`transformInPlace(AVector v)`
`void`	ATransform.`transformInPlace(AVector v)` Transforms a vector destructively.
`void`	Affine34.`transformInPlace(AVector dest)`
`void`	Affine23.`transformInPlace(AVector dest)`
`void`	AAffineTransform.`transformInPlace(AVector v)`
`void`	ATranslation.`transformNormal(AVector source, AVector dest)`
`void`	Affine34.`transformNormal(AVector source, AVector dest)`
`void`	Affine23.`transformNormal(AVector source, AVector dest)`
`void`	AAffineTransform.`transformNormal(AVector source, AVector dest)`

Constructors in mikera.transformz with parameters of type AVector
Constructor and Description
`Affine23(AMatrix m, AVector v)`
`Affine23(Matrix22 m, AVector v)`
`Affine34(AMatrix m, AVector v)`
`Affine34(Matrix33 m, AVector v)`
`AffineMN(AMatrix m, AVector v)`
`Translation(AVector source)`
`Translation3(AVector v)`

Uses of AVector in mikera.transformz.impl

Methods in mikera.transformz.impl that return AVector
Modifier and Type	Method and Description
`AVector`	ConstantTransform4.`getConstantValue()`
`AVector`	ConstantTransform3.`getConstantValue()`
`AVector`	ConstantTransform.`getConstantValue()`
`abstract AVector`	AConstantTransform.`getConstantValue()`
`AVector`	IdentityTranslation.`getTranslationVector()`

Methods in mikera.transformz.impl with parameters of type AVector
Modifier and Type	Method and Description
`double`	SubsetTransform.`calculateElement(int i, AVector source)`
`double`	IdentityTranslation.`calculateElement(int i, AVector v)`
`double`	ConstantTransform4.`calculateElement(int i, AVector inputVector)`
`double`	ConstantTransform3.`calculateElement(int i, AVector inputVector)`
`double`	ConstantTransform.`calculateElement(int i, AVector v)`
`double`	AOpTransform.`calculateElement(int i, AVector inputVector)`
`Vector`	IdentityTranslation.`transform(AVector source)`
`Vector`	ConstantTransform3.`transform(AVector source)`
`void`	SubsetTransform.`transform(AVector source, AVector dest)`
`void`	IdentityTranslation.`transform(AVector source, AVector dest)`
`void`	ConstantTransform4.`transform(AVector source, AVector dest)`
`void`	ConstantTransform3.`transform(AVector source, AVector dest)`
`void`	ConstantTransform.`transform(AVector source, AVector dest)`
`void`	CompoundTransform.`transform(AVector source, AVector dest)`
`void`	AOpTransform.`transform(AVector source, AVector dest)`
`void`	ConstantTransform3.`transform(AVector source, Vector3 dest)`
`void`	ConstantTransform4.`transform(AVector source, Vector4 dest)`
`void`	IdentityTranslation.`transformInPlace(AVector v)`

Constructors in mikera.transformz.impl with parameters of type AVector
Constructor and Description
`ConstantTransform(int inputDimensions, AVector value)` Creates a new constant transform, using the provided vector as the constant value Does not take a defensive copy
`ConstantTransform3(int inputDimensions, AVector value)` Creates a new constant transform, using the provided vector as the constant value Does not take a defensive copy
`ConstantTransform4(int inputDimensions, AVector value)` Creates a new constant transform, using the provided vector as the constant value Does not take a defensive copy

Uses of AVector in mikera.vectorz

Subclasses of AVector in mikera.vectorz
Modifier and Type	Class and Description
`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`	`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 AVector
Modifier and Type	Method and Description
`AVector`	AVector.`absCopy()`
`AVector`	IVector.`addCopy(AVector a)` Adds a vector element-wise to this vector, returning a new vector.
`AVector`	AVector.`addCopy(AVector a)`
`AVector`	AVector.`addCopy(double a)`
`AVector`	AVector.`addMultipleCopy(AVector src, double factor)` Returns the sum of this vector with a scaled multiple of a second vector.
`AVector`	AVector.`addProductCopy(AVector a, AVector b)` Adds the element-wise product of two vectors to this vector.
`AVector`	AVector.`addProductCopy(AVector a, AVector b, double factor)` Adds the element-wise product of two vectors and a constant factor to this vector.
`AVector`	AVector.`applyOpCopy(Op op)`
`AVector`	AVector.`asVector()`
`AVector`	AScalar.`asVector()`
`static AVector`	Vectorz.`axisVector(int axisIndex, int dimensions)`
`AVector`	AVector.`broadcastLike(AVector target)`
`AVector`	AScalar.`broadcastLike(AVector v)`
`AVector`	GrowableVector.`build()` Function to build a fixed-size vector containing a copy of data once the GrowableVector is constructed
`AVector`	IVector.`clone()`
`AVector`	AVector.`clone()` Clones the vector, creating a new mutable copy of all data.
`AVector`	AVector.`copy()`
`static AVector`	Vectorz.`create(AVector vector)` Creates a mutable clone of a given vector
`static AVector`	Vectorz.`create(double... data)` Creates a vector using the given double data, using the most efficient dense representation.
`static AVector`	Vectorz.`create(DoubleBuffer d)` Create a vector from a DoubleBuffer Note: consumes all doubles from the buffer
`static AVector`	Vectorz.`create(Iterable<Object> d)` Create a vector from an arbitrary iterable object
`static AVector`	Vectorz.`create(IVector vector)` Creates a mutable clone of a given vector
`static AVector`	Vectorz.`create(List<Object> d)` Create a vector from a list of numerical values (objects should be java.lang.Number instances)
`static AVector`	Vectorz.`create(Object o)`
`static AVector`	Vectorz.`createMutableRange(int length)` Create a mutable vector contain the sequence of integers from 0 to length-1
`static AVector`	Vectorz.`createMutableVector(AVector v)` Deprecated.
`static AVector`	Vectorz.`createRange(int length)` Create an immutable vector contain the sequence of integers from 0 to length-1
`static AVector`	Vectorz.`createRepeatedElement(int length, double value)` Create an immutable vector containing a single repeated value.
`static AVector`	Vectorz.`createSameSize(AVector v)` Creates a new zero-filled vector of the same size as the given Vector.
`static AVector`	Vectorz.`createSparse(AVector v)` Creates a sparse vector from the data in the given vector.
`static AVector`	Vectorz.`createSparse(Object... values)` Creates a sparse vector from an array of Object values
`static AVector`	Vectorz.`createSparse(Object data)` Creates a sparse vector from an array of Object values
`static AVector`	Vectorz.`createSparseMutable(AVector v)`
`static AVector`	Vectorz.`createSparseMutable(int length)` Creates a mutable sparse vector from the data in the given vector.
`static AVector`	Vectorz.`createUniformRandomVector(int dimensions)`
`static AVector`	Vectorz.`createZeroVector(long l)` Creates an immutable zero vector of the specified length.
`AVector`	AVector.`dense()`
`AVector`	IVector.`divideCopy(AVector a)` Divides this vector element-wise by another vector, returning a new vector.
`AVector`	AVector.`divideCopy(AVector a)`
`abstract AVector`	AVector.`exactClone()` Returns an exact clone of this vector, i.e.
`AVector`	AVector.`getTranspose()`
`AVector`	AVector.`getTransposeCopy()`
`AVector`	AVector.`getTransposeView()`
`AVector`	AVector.`immutable()` Creates an immutable copy of a vector
`static AVector`	Vectorz.`immutableZeroVector(int dimensions)` Returns an immutable vector of zeros
`AVector`	AVector.`innerProduct(AMatrix m)` Computes the inner product of this vector with a matrix
`AVector`	AVector.`innerProduct(AScalar s)` Computes the inner product of this vector with a scalar
`AVector`	AScalar.`innerProduct(AVector a)`
`AVector`	AVector.`innerProduct(double a)`
`static AVector`	Vectorz.`join(AVector... vectors)` Join one or more vectors into a single concatenated vector
`AVector`	AVector.`join(AVector second)`
`static AVector`	Vectorz.`join(AVector first, AVector second)` Creates a joined vector that refers to the two underlying vectors
`AVector`	AVector.`join(INDArray b)` Returns a new vector that refers to this vector joined to a second vector.
`static AVector`	Vectorz.`join(List<AVector> vectors)` Join a list of vectors into a single concatenated vector
`AVector`	IVector.`multiplyCopy(AVector a)` Multiplies a vector element-wise with this vector, returning a new vector.
`AVector`	AVector.`multiplyCopy(AVector a)`
`AVector`	AVector.`multiplyCopy(double d)`
`AVector`	AVector.`mutable()` Coerces to a mutable version of a vector.
`AVector`	AVector.`negateCopy()`
`static AVector`	Vectorz.`newVector(int length)` Returns a new mutable vector filled with zeros of the specified length.
`AVector`	IVector.`normaliseCopy()` Normalises this vector to unit length, returning a new vector.
`AVector`	AVector.`normaliseCopy()` Returns a copy of this vector normalised to a Euclidean length of 1.0 Has no effect on a zero-length vector (i.e.
`static AVector`	Vectorz.`parse(String ednString)` Parse a vector in edn format
`AVector`	AVector.`reduceSlices(Op2 op)`
`AVector`	AVector.`reduceSlices(Op2 op, double init)`
`AVector`	AVector.`reorder(int[] order)`
`AVector`	AVector.`reorder(int dim, int[] order)`
`AVector`	IVector.`rotateCopy(int shift)` Rotates a vector by the specified number of elements, wrapping around element values.
`AVector`	AVector.`rotateCopy(int shift)`
`AVector`	IVector.`rotateView(int shift)` Rotates a vector by the specified number of elements, wrapping around element values.
`AVector`	AVector.`rotateView(int shift)`
`AVector`	AVector.`scaleCopy(double d)`
`AVector`	AVector.`select(int... indices)` Selects a subset of indices from a vector
`AVector`	AVector.`selectClone(int... inds)` Selects a subset of indices from a vector, returning a mutable clone of data
`AVector`	AVector.`selectView(int... indices)` Selects a subset of indices from a vector, returning a view
`AVector`	IVector.`shiftCopy(int shift)` Shifts a vector by the specified number of elements, filling with zeros.
`AVector`	AVector.`shiftCopy(int shift)`
`AVector`	AVector.`softmaxCopy()` Computes the softmax function over this vector, returning a new mutable vector
`AVector`	AVector.`sparse()`
`AVector`	AVector.`sparseClone()` Clones the vector into a sparse mutable format
`AVector`	IVector.`sqrtCopy()` Computes the square root for each element in this vector, returning a new vector.
`AVector`	AVector.`sqrtCopy()`
`AVector`	AVector.`squareCopy()`
`AVector`	AVector.`subArray(int[] offsets, int[] shape)`
`AVector`	IVector.`subCopy(AVector a)` Subtracts a vector element-wise from this vector, returning a new vector.
`AVector`	AVector.`subCopy(AVector a)`
`AVector`	AVector.`subVector(int offset, int length)` Obtains a sub-vector view that refers to this vector.
`AVector`	AVector.`toNormal()` Creates a new mutable vector representing the normalised value of this vector Returns null if the vector cannot be normalised (i.e.
`static AVector`	Vectorz.`toVector(Object o)` Coerce to AVector.
`AVector`	AVector.`tryEfficientJoin(AVector second)` Attempts to perform an efficient join with a second vector.
`static AVector`	Vectorz.`wrap(double[][] data)`

Methods in mikera.vectorz with parameters of type AVector
Modifier and Type	Method and Description
`void`	Vector4.`add(AVector v)`
`void`	Vector3.`add(AVector v)`
`void`	Vector2.`add(AVector v)`
`void`	Vector1.`add(AVector v)`
`void`	Vector.`add(AVector v)`
`void`	AVector.`add(AVector v)` Adds another vector to this one
`void`	AVector.`add(AVector src, int srcOffset)` Adds part another vector to this one, starting at the specified offset in the source vector
`void`	AVector.`add(int offset, AVector src)` Adds another vector into this one, at the specified offset
`void`	AVector.`add(int offset, AVector src, int srcOffset, int length)` Adds a segment of another vector into this one, at the specified offset
`Vector3`	Vector3.`addCopy(AVector v)`
`AVector`	IVector.`addCopy(AVector a)` Adds a vector element-wise to this vector, returning a new vector.
`AVector`	AVector.`addCopy(AVector a)`
`void`	AVector.`addInnerProduct(AMatrix a, AVector b)` Adds the inner product of the arguments (matrix a and vector b) to this vector.
`void`	AVector.`addInnerProduct(AVector a, AMatrix b)` Adds the inner product of the arguments (vector a and matrix b) to this vector.
`void`	Vector4.`addMultiple(AVector v, double factor)`
`void`	Vector3.`addMultiple(AVector v, double factor)`
`void`	Vector.`addMultiple(AVector v, double factor)`
`void`	AVector.`addMultiple(AVector src, double factor)` Adds a scaled multiple of another vector to this vector
`void`	AVector.`addMultiple(AVector source, Index sourceToDest, double factor)` Adds source vector to this vector at the specified indexes which should map from source->this
`void`	AVector.`addMultiple(AVector src, int srcOffset, double factor)` Adds a multiple of a subvector of another vector to this vector.
`void`	AVector.`addMultiple(int offset, AVector v, double factor)`
`void`	AVector.`addMultiple(int offset, AVector src, int srcOffset, int length, double factor)`
`AVector`	AVector.`addMultipleCopy(AVector src, double factor)` Returns the sum of this vector with a scaled multiple of a second vector.
`protected void`	AVector.`addPower(AVector src, double exponent, double factor)` Adds a multiple of the source vector raised to the specified power to this vector
`void`	Vector.`addProduct(AVector a, AVector b)`
`void`	AVector.`addProduct(AVector a, AVector b)` Adds the element-wise product of two vectors to this vector.
`void`	AVector.`addProduct(AVector a, AVector b, double factor)` Adds the element-wise product of two vectors and a constant factor to this vector.
`void`	AVector.`addProduct(AVector a, int aOffset, AVector b, int bOffset, double factor)` Adds the scaled elementwise product of two vectors to this vector
`AVector`	AVector.`addProductCopy(AVector a, AVector b)` Adds the element-wise product of two vectors to this vector.
`AVector`	AVector.`addProductCopy(AVector a, AVector b, double factor)` Adds the element-wise product of two vectors and a constant factor to this vector.
`void`	AVector.`addProductToArray(double factor, int offset, AVector other, int otherOffset, double[] array, int arrayOffset, int length)`
`void`	AVector.`addWeighted(AVector v, double factor)` Updates a weighted average of this vector with another vector
`double`	Vector3.`angle(AVector v)`
`double`	AVector.`angle(AVector v)` Returns the Euclidean angle between this vector and another vector
`void`	GrowableVector.`append(AVector v)`
`void`	AVector.`applyOp(Op2 op, AVector b)` Applies a binary operator to this vector and a second vector
`void`	Op2.`applyTo(ADenseArrayVector a, AVector b)`
`void`	Op.`applyTo(AVector v)`
`void`	IOperator.`applyTo(AVector v)` Applies this operator to a mutable vector.
`void`	Op2.`applyTo(AVector a, AVector b)`
`void`	Op.`applyTo(AVector v, int start, int length)`
`void`	IOperator.`applyTo(AVector v, int start, int length)` Applies this operator to the specified range within a mutable vector.
`void`	Op2.`applyTo(double[] data, AVector b)`
`void`	Op2.`applyTo(double[] data, int start, int length, AVector b)`
`static double`	Vectorz.`averageSquaredDifference(AVector a, AVector b)` Deprecated.
`static double`	Vectorz.`averageValue(AVector v)` Deprecated.
`AVector`	AVector.`broadcastLike(AVector target)`
`AVector`	AScalar.`broadcastLike(AVector v)`
`protected int`	AVector.`checkSameLength(AVector v)` Utility function to check vector length and throw an exception if not same shape.
`protected int`	AVector.`checkSameLength(AVector v, AVector w)` Utility function to check vector length and throw an exception if not same shape.
`int`	AVector.`compareTo(AVector a)`
`void`	AVector.`copyTo(AVector dest, int destOffset)` Copies a the contents of a vector to a vector at the specified offset
`void`	AVector.`copyTo(int offset, AVector dest, int destOffset, int length)` Copies a subset of this vector to a vector at the specified offset
`static AVector`	Vectorz.`create(AVector vector)` Creates a mutable clone of a given vector
`static Vector3`	Vector3.`create(AVector v)`
`static Vector2`	Vector2.`create(AVector v)`
`static Vector`	Vector.`create(AVector a)`
`static GrowableVector`	GrowableVector.`create(AVector values)` Creates a GrowableVector containing a copy of the elements of a given vector
`static BitVector`	BitVector.`create(AVector source)`
`static Scalar`	Scalar.`createFromVector(AVector data)` Creates a new Scalar using the elements in the specified vector.
`static Vector`	Vector.`createFromVector(AVector source, int length)` Creates a new vector using the elements in the specified vector.
`static AVector`	Vectorz.`createMutableVector(AVector v)` Deprecated.
`static AVector`	Vectorz.`createSameSize(AVector v)` Creates a new zero-filled vector of the same size as the given Vector.
`static AVector`	Vectorz.`createSparse(AVector v)` Creates a sparse vector from the data in the given vector.
`static AVector`	Vectorz.`createSparseMutable(AVector v)`
`void`	Vector3.`crossProduct(AVector a)`
`void`	AVector.`crossProduct(AVector a)` Computes the crossProduct of this vector with another vector, and stores the result in this vector.
`double`	Vector3.`distance(AVector v)`
`double`	Vector.`distance(AVector v)`
`double`	AVector.`distance(AVector v)` Returns the Euclidean distance to another vector.
`double`	AVector.`distanceL1(AVector v)` Returns the distance from this vector to another vector according to the L1 (Taxicab) norm.
`double`	AVector.`distanceLinf(AVector v)` Returns the distance from this vector to another vector according to the Linf norm.
`double`	AVector.`distanceSquared(AVector v)` Returns the squared Euclidean distance to another vector.
`void`	Vector.`divide(AVector v)`
`void`	AVector.`divide(AVector v)`
`AVector`	IVector.`divideCopy(AVector a)` Divides this vector element-wise by another vector, returning a new vector.
`AVector`	AVector.`divideCopy(AVector a)`
`double`	Vector4.`dotProduct(AVector v)`
`double`	Vector3.`dotProduct(AVector v)`
`double`	Vector2.`dotProduct(AVector a)`
`double`	Vector1.`dotProduct(AVector a)`
`double`	BitVector.`dotProduct(AVector v)`
`double`	AVector.`dotProduct(AVector v)` Returns the dot product of this vector with another vector The vectors must have the same length: if not the result is undefined
`double`	Vector.`dotProduct(AVector v, Index ix)`
`double`	AVector.`dotProduct(AVector v, Index ix)` Returns the dotProduct of this vector with the elements of another vector mapped to specified indexes in this vector.
`boolean`	AVector.`epsilonEquals(AVector v)` Returns true if this vector is approximately equal to another vector.
`boolean`	IVector.`epsilonEquals(AVector v, double tolerance)`
`boolean`	AVector.`epsilonEquals(AVector v, double tolerance)`
`boolean`	Vector3.`equals(AVector v)`
`boolean`	Vector2.`equals(AVector v)`
`boolean`	Vector.`equals(AVector v)`
`boolean`	AVector.`equals(AVector v)`
`static void`	Vectorz.`fillBinaryRandom(AVector v)`
`static void`	Vectorz.`fillBinaryRandom(AVector v, double prob)`
`static void`	Vectorz.`fillGaussian(AVector v)`
`static void`	Vectorz.`fillGaussian(AVector v, double mean, double sd)`
`static void`	Vectorz.`fillGaussian(AVector v, double mean, double sd, Random r)`
`static void`	Vectorz.`fillGaussian(AVector v, Random r)`
`static void`	Vectorz.`fillIndexes(AVector v)` Fills a vector with index values
`static void`	Vectorz.`fillNormal(AVector v, long seed)` Fills a mutable vector with random normally distributed values
`static void`	Vectorz.`fillNormal(AVector v, Random random)` Fills a mutable vector with random normally distributed values
`static void`	Vectorz.`fillRandom(AVector v)` Fills a vector with uniform random numbers in the range [0..1)
`static void`	Vectorz.`fillRandom(AVector v, long seed)` Fills a mutable vector with random double values in the range [0..1)
`static void`	Vectorz.`fillRandom(AVector v, Random random)` Fills a mutable vector with random double values in the range [0..1)
`static int`	Vectorz.`indexOfMaxValue(AVector v)` Deprecated.
`static int`	Vectorz.`indexOfMinValue(AVector v)` Deprecated.
`AScalar`	AVector.`innerProduct(AVector v)` Computes the inner product of this vector with another vector
`AVector`	AScalar.`innerProduct(AVector a)`
`void`	AVector.`interpolate(AVector v, double alpha)`
`static void`	Vectorz.`invSqrt(AVector v)`
`boolean`	IVector.`isSameShape(AVector a)` Returns true if this vector is exactly the same shape as another vector.
`boolean`	AVector.`isSameShape(AVector a)`
`static AVector`	Vectorz.`join(AVector... vectors)` Join one or more vectors into a single concatenated vector
`AVector`	AVector.`join(AVector second)`
`static AVector`	Vectorz.`join(AVector first, AVector second)` Creates a joined vector that refers to the two underlying vectors
`static double`	Vectorz.`maxValue(AVector v)` Deprecated.
`static double`	Vectorz.`minValue(AVector v)` Deprecated.
`void`	Vector.`multiply(AVector v)`
`void`	AVector.`multiply(AVector v)`
`AVector`	IVector.`multiplyCopy(AVector a)` Multiplies a vector element-wise with this vector, returning a new vector.
`Vector`	BitVector.`multiplyCopy(AVector v)`
`AVector`	AVector.`multiplyCopy(AVector a)`
`AMatrix`	AVector.`outerProduct(AVector a)` Computes the outer product of this vector with another vector
`void`	Vector3.`projectToPlane(AVector normal, double distance)`
`void`	AVector.`projectToPlane(AVector normal, double distance)` Projects the vector to the plane defined by: x.normal=distance
`static double`	Vectorz.`rmsDifference(AVector a, AVector b)`
`void`	AVector.`scale(AVector v)` Scales the vector by another vector of the same size
`void`	Vector3.`scaleAdd(double factor, AVector constant)`
`void`	Vector2.`scaleAdd(double factor, AVector constant)`
`void`	AVector.`scaleAdd(double factor, AVector v)`
`void`	AVector.`scaleAdd(double factor, AVector b, double bfactor, double constant)` Scales all elements of the array by a given double value, adds a scaled second vector and adds a constant value
`void`	Vector3.`set(AVector v)`
`void`	Vector.`set(AVector a)`
`void`	AVector.`set(AVector src)` Sets the vector to equal the value of another vector
`void`	AVector.`set(AVector source, Index indexes)` sets the vector using values indexed from another vector
`void`	AVector.`set(AVector src, int srcOffset)` Set the vector equal to an offset into another vector
`void`	AVector.`set(AVector source, int[] indexes)` sets the vector using values indexed from another vector
`void`	AVector.`setInnerProduct(AMatrix a, AVector b)` Sets this vector to the inner product of the arguments (matrix a and vector b).
`void`	AVector.`setInnerProduct(AVector a, AMatrix b)` Sets this vector to the inner product of the arguments (vector a and matrix b) to this vector.
`void`	AVector.`setMultiple(AVector a, AVector b)` Sets this vector to the element-wise product of two otehr vectors
`void`	AVector.`setMultiple(AVector a, double b)` Sets this vector to be a multiple of another vector
`void`	Vector.`sub(AVector v)`
`void`	AVector.`sub(AVector v)` Subtracts a vector from this vector
`AVector`	IVector.`subCopy(AVector a)` Subtracts a vector element-wise from this vector, returning a new vector.
`AVector`	AVector.`subCopy(AVector a)`
`void`	AVector.`subMultiple(AVector v, double factor)` Subtracts a scaled multiple of another vector from this vector
`static void`	Vectorz.`swap(AVector a, AVector b)` Swaps two vectors, mutating both.
`static double`	Vectorz.`totalValue(AVector v)` Deprecated.
`AVector`	AVector.`tryEfficientJoin(AVector second)` Attempts to perform an efficient join with a second vector.

Method parameters in mikera.vectorz with type arguments of type AVector
Modifier and Type	Method and Description
`static AVector`	Vectorz.`join(List<AVector> vectors)` Join a list of vectors into a single concatenated vector

Constructors in mikera.vectorz with parameters of type AVector
Constructor and Description
`GrowableVector(AVector v)`
`Vector(AVector source)` Copy constructor from an arbitrary vector
`Vector3(AVector v)`

Uses of AVector in mikera.vectorz.functions

Methods in mikera.vectorz.functions with parameters of type AVector
Modifier and Type	Method and Description
`abstract double`	ScalarFunction.`calculate(AVector input)` Calculates the result of this scalar function with the given input vector
`void`	ScalarFunction.`transform(AVector src, AVector dest)`

Uses of AVector in mikera.vectorz.impl

Subclasses of AVector 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`	`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`	`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`	`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`	`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.

Fields in mikera.vectorz.impl declared as AVector
Modifier and Type	Field and Description
`protected AVector`	BaseDerivedVector.`source`

Methods in mikera.vectorz.impl that return AVector
Modifier and Type	Method and Description
`AVector`	RepeatedElementVector.`absCopy()`
`AVector`	JoinedVector.`absCopy()`
`AVector`	ZeroVector.`addCopy(AVector a)`
`AVector`	RepeatedElementVector.`addCopy(AVector v)`
`AVector`	JoinedVector.`addCopy(AVector a)`
`AVector`	AxisVector.`addCopy(AVector v)`
`AVector`	ZeroVector.`addCopy(double a)`
`AVector`	RepeatedElementVector.`addCopy(double v)`
`AVector`	ZeroVector.`applyOpCopy(Op op)`
`AVector`	SingleElementVector.`applyOpCopy(Op op)`
`AVector`	RepeatedElementVector.`applyOpCopy(Op op)`
`AVector`	ASparseVector.`clone()`
`static AVector`	SparseImmutableVector.`create(ASparseVector source)`
`static AVector`	JoinedMultiVector.`create(AVector... vecs)`
`static AVector`	SparseImmutableVector.`create(AVector source)` Creates a sparse immutable vector from the given vector, ignoring the zeros in the source.
`static AVector`	SparseImmutableVector.`create(int length, Index sparseIndex, AVector sparseValues)` Creates a SparseImmutableVector using the given sorted Index to identify the indexes of non-zero values, and a dense vector to specify all the non-zero element values
`static AVector`	SparseImmutableVector.`create(int length, Index sparseIndex, double[] sparseValues)` Creates a SparseImmutableVector using the given sorted Index to identify the indexes of non-zero values, and a double[] array to specify all the non-zero element values
`static AVector`	RangeVector.`create(int start, int length)`
`static AVector`	SparseIndexedVector.`createFromRow(AMatrix m, int row)` Creates a SparseIndexedVector from a row of an existing matrix
`static AVector`	SparseImmutableVector.`createFromRow(AMatrix m, int row)` Creates a SparseIndexedVector from a row of an existing matrix
`static AVector`	SparseHashedVector.`createFromRow(AMatrix m, int row)` Creates a SparseIndexedVector from a row of an existing matrix
`static AVector`	SparseIndexedVector.`createWithIndices(AVector v, int[] ixs)` Creates a sparse indexed vector using the specified indexed values from the source vector All non-indexed vales will be zero.
`AVector`	TriangularIndexedVector.`exactClone()`
`AVector`	SubMatrixViewVector.`exactClone()`
`AVector`	MatrixViewVector.`exactClone()`
`AVector`	IndexVector.`exactClone()`
`AVector`	ImmutableVector.`exactClone()`
`AVector`	GrowableIndexedVector.`exactClone()`
`AVector`	JoinedVector.`getComponent(int k)`
`AVector`	JoinedMultiVector.`getComponent(int k)`
`abstract AVector`	AJoinedVector.`getComponent(int k)`
`AVector`	SparseIndexedVector.`immutable()`
`AVector`	ImmutableVector.`immutable()`
`AVector`	ZeroVector.`innerProduct(AMatrix m)`
`AVector`	SparseIndexedVector.`innerProduct(AMatrix m)`
`AVector`	SingleElementVector.`innerProduct(AMatrix a)`
`AVector`	RepeatedElementVector.`innerProduct(AMatrix m)`
`AVector`	AxisVector.`innerProduct(AMatrix m)`
`AVector`	ASparseVector.`innerProduct(AMatrix m)`
`AVector`	ASparseIndexedVector.`innerProduct(AMatrix a)`
`AVector`	SparseIndexedVector.`innerProduct(SparseColumnMatrix m)`
`AVector`	SparseIndexedVector.`innerProduct(SparseRowMatrix m)`
`AVector`	ADenseArrayVector.`join(ADenseArrayVector v)`
`AVector`	Vector0.`join(AVector v)`
`AVector`	IndexedSubVector.`join(AVector v)`
`AVector`	IndexedArrayVector.`join(AVector v)`
`AVector`	ADenseArrayVector.`join(AVector v)`
`AVector`	JoinedMultiVector.`join(JoinedMultiVector v)`
`AVector`	JoinedVector.`join(JoinedVector a)`
`AVector`	JoinedMultiVector.`join(JoinedVector v)`
`static AVector`	JoinedArrayVector.`joinVectors(ADenseArrayVector a, ADenseArrayVector b)`
`static AVector`	JoinedVector.`joinVectors(AVector left, AVector right)` Returns a JoinedVector connecting the two vectors
`AVector`	RepeatedElementVector.`multiplyCopy(AVector v)`
`AVector`	SingleElementVector.`multiplyCopy(double d)`
`AVector`	RepeatedElementVector.`multiplyCopy(double d)`
`AVector`	AxisVector.`multiplyCopy(double d)`
`AVector`	RepeatedElementVector.`negateCopy()`
`AVector`	JoinedVector.`negateCopy()`
`AVector`	ZeroVector.`nonSparseValues()`
`AVector`	SingleElementVector.`nonSparseValues()`
`AVector`	ISparseVector.`nonSparseValues()` Returns the non-sparse elements as a compacted vector
`AVector`	GrowableIndexedVector.`nonSparseValues()`
`AVector`	AxisVector.`nonSparseValues()`
`abstract AVector`	ASparseVector.`nonSparseValues()`
`AVector`	ASingleElementVector.`nonSparseValues()`
`AVector`	ZeroVector.`normaliseCopy()`
`AVector`	AxisVector.`normaliseCopy()`
`AVector`	RepeatedElementVector.`reciprocalCopy()`
`AVector`	ASparseVector.`reduceSlices(Op2 op, double init)`
`AVector`	ZeroVector.`select(int... order)`
`AVector`	RepeatedElementVector.`select(int... order)`
`AVector`	ZeroVector.`selectClone(int... inds)`
`AVector`	ZeroVector.`selectView(int... inds)`
`AVector`	IndexedSubVector.`selectView(int... inds)`
`AVector`	AStridedVector.`selectView(int... inds)`
`AVector`	ADenseArrayVector.`selectView(int... inds)`
`AVector`	AArrayVector.`selectView(int... indices)`
`AVector`	UnmodifiableVector.`sparse()`
`AVector`	ImmutableVector.`sparse()`
`AVector`	ZeroVector.`sparseClone()`
`AVector`	ZeroVector.`squareCopy()`
`AVector`	AxisVector.`squareCopy()`
`AVector`	ZeroVector.`subCopy(AVector a)`
`AVector`	AxisVector.`subCopy(AVector v)`
`AVector`	ZeroVector.`subVector(int offset, int length)`
`AVector`	WrappedSubVector.`subVector(int offset, int length)`
`AVector`	UnmodifiableVector.`subVector(int offset, int length)`
`AVector`	TriangularIndexedVector.`subVector(int start, int length)`
`AVector`	StridedVector.`subVector(int start, int length)`
`AVector`	StridedMatrixViewVector.`subVector(int start, int length)`
`AVector`	SingleElementVector.`subVector(int offset, int length)`
`AVector`	RepeatedElementVector.`subVector(int offset, int length)`
`AVector`	RangeVector.`subVector(int start, int length)`
`AVector`	MatrixViewVector.`subVector(int start, int length)`
`AVector`	JoinedVector.`subVector(int start, int length)`
`AVector`	JoinedMultiVector.`subVector(int start, int length)`
`AVector`	JoinedArrayVector.`subVector(int start, int length)`
`AVector`	IndexedSubVector.`subVector(int offset, int length)`
`AVector`	IndexedArrayVector.`subVector(int offset, int length)`
`AVector`	ImmutableVector.`subVector(int start, int length)`
`AVector`	BufferVector.`subVector(int offset, int length)`
`AVector`	AxisVector.`subVector(int start, int length)`
`AVector`	ArraySubVector.`subVector(int start, int length)`
`AVector`	ADenseArrayVector.`subVector(int offset, int length)`
`AVector`	ZeroVector.`tryEfficientJoin(AVector a)`
`AVector`	WrappedSubVector.`tryEfficientJoin(AVector a)`
`AVector`	SingleElementVector.`tryEfficientJoin(AVector a)`
`AVector`	RepeatedElementVector.`tryEfficientJoin(AVector a)`
`AVector`	RangeVector.`tryEfficientJoin(AVector a)`
`AVector`	JoinedVector.`tryEfficientJoin(AVector a)`
`AVector`	JoinedMultiVector.`tryEfficientJoin(AVector v)`
`AVector`	JoinedArrayVector.`tryEfficientJoin(AVector v)`
`AVector`	ADenseArrayVector.`tryEfficientJoin(AVector v)`
`static AVector`	JoinedMultiVector.`wrap(AVector... vecs)`

Methods in mikera.vectorz.impl with parameters of type AVector
Modifier and Type	Method and Description
`void`	StridedVector.`add(AVector v)`
`void`	SparseIndexedVector.`add(AVector v)`
`void`	JoinedVector.`add(AVector a)`
`void`	JoinedMultiVector.`add(AVector a)`
`void`	JoinedArrayVector.`add(AVector a)`
`void`	ASparseVector.`add(AVector v)`
`void`	ArraySubVector.`add(AVector v)`
`void`	ADenseArrayVector.`add(AVector src)`
`void`	WrappedSubVector.`add(AVector src, int offset)`
`void`	JoinedVector.`add(AVector a, int aOffset)`
`void`	JoinedMultiVector.`add(AVector a, int aOffset)`
`void`	ADenseArrayVector.`add(AVector src, int srcOffset)`
`void`	StridedVector.`add(int offset, AVector a)`
`void`	JoinedVector.`add(int offset, AVector a)`
`void`	JoinedMultiVector.`add(int offset, AVector a)`
`void`	JoinedArrayVector.`add(int offset, AVector a)`
`void`	ADenseArrayVector.`add(int offset, AVector src)`
`void`	JoinedVector.`add(int offset, AVector a, int aOffset, int length)`
`void`	JoinedArrayVector.`add(int offset, AVector a, int aOffset, int length)`
`void`	AStridedVector.`add(int offset, AVector a, int aOffset, int length)`
`AVector`	ZeroVector.`addCopy(AVector a)`
`AVector`	RepeatedElementVector.`addCopy(AVector v)`
`AVector`	JoinedVector.`addCopy(AVector a)`
`Vector`	JoinedArrayVector.`addCopy(AVector a)`
`AVector`	AxisVector.`addCopy(AVector v)`
`void`	SparseIndexedVector.`addMultiple(AVector v, double factor)`
`void`	JoinedVector.`addMultiple(AVector a, double factor)`
`void`	JoinedMultiVector.`addMultiple(AVector a, double factor)`
`void`	JoinedArrayVector.`addMultiple(AVector a, double factor)`
`void`	ASparseVector.`addMultiple(AVector src, double factor)`
`void`	ArraySubVector.`addMultiple(AVector v, double factor)`
`void`	ADenseArrayVector.`addMultiple(AVector v, double factor)`
`void`	JoinedVector.`addMultiple(AVector a, int aOffset, double factor)`
`void`	JoinedMultiVector.`addMultiple(AVector a, int aOffset, double factor)`
`void`	JoinedArrayVector.`addMultiple(int offset, AVector a, int aOffset, int length, double factor)`
`void`	ADenseArrayVector.`addMultiple(int offset, AVector src, int srcOffset, int length, double factor)`
`void`	ADenseArrayVector.`addProduct(AVector a, AVector b)`
`void`	JoinedVector.`addProduct(AVector a, AVector b, double factor)`
`void`	JoinedMultiVector.`addProduct(AVector a, AVector b, double factor)`
`void`	JoinedArrayVector.`addProduct(AVector a, AVector b, double factor)`
`void`	ADenseArrayVector.`addProduct(AVector a, AVector b, double factor)`
`void`	JoinedVector.`addProduct(AVector a, int aOffset, AVector b, int bOffset, double factor)`
`void`	JoinedMultiVector.`addProduct(AVector a, int aOffset, AVector b, int bOffset, double factor)`
`void`	JoinedArrayVector.`addProduct(AVector a, int aOffset, AVector b, int bOffset, double factor)`
`void`	ADenseArrayVector.`addProduct(AVector a, int aOffset, AVector b, int bOffset, double factor)`
`void`	SparseHashedVector.`addProductToArray(double factor, int offset, AVector other, int otherOffset, double[] array, int arrayOffset, int length)`
`void`	ASparseIndexedVector.`addProductToArray(double factor, int offset, AVector other, int otherOffset, double[] array, int arrayOffset, int length)`
`void`	ADenseArrayVector.`addProductToArray(double factor, int offset, AVector other, int otherOffset, double[] array, int arrayOffset, int length)`
`void`	AJoinedVector.`applyOp(Op2 op, AVector b)`
`void`	ADenseArrayVector.`applyOp(Op2 op, AVector b)`
`protected int`	ASizedVector.`checkSameLength(AVector v)`
`void`	SparseHashedVector.`copyTo(AVector v, int offset)`
`void`	JoinedVector.`copyTo(AVector dest, int offset)`
`void`	JoinedMultiVector.`copyTo(AVector dest, int offset)`
`void`	ASparseIndexedVector.`copyTo(AVector v, int offset)`
`void`	AJoinedVector.`copyTo(AVector dest, int offset)`
`void`	WrappedSubVector.`copyTo(int offset, AVector dest, int destOffset, int length)`
`void`	JoinedVector.`copyTo(int start, AVector dest, int destOffset, int length)`
`void`	AJoinedVector.`copyTo(int offset, AVector dest, int destOffset, int length)`
`void`	ADenseArrayVector.`copyTo(int start, AVector dest, int destOffset, int length)`
`static AVector`	JoinedMultiVector.`create(AVector... vecs)`
`static SparseIndexedVector`	SparseIndexedVector.`create(AVector source)` Creates a SparseIndexedVector from the given vector, ignoring the zeros in the source.
`static AVector`	SparseImmutableVector.`create(AVector source)` Creates a sparse immutable vector from the given vector, ignoring the zeros in the source.
`static SparseHashedVector`	SparseHashedVector.`create(AVector v)` Creates a SparseHashedVector with the specified values
`static JoinedArrayVector`	JoinedArrayVector.`create(AVector v)`
`static ImmutableVector`	ImmutableVector.`create(AVector v)` Create an ImmutableVector with a copy of the elements in the source vector
`static GrowableIndexedVector`	GrowableIndexedVector.`create(AVector v)` Creates a GrowableIndexedVector from the specified Iterable object
`static BufferVector`	BufferVector.`create(AVector v)`
`static SparseIndexedVector`	SparseIndexedVector.`create(int length, Index index, AVector data)` Creates a SparseIndexedVector using the given sorted Index to identify the indexes of non-zero values, and a dense vector to specify all the non-zero element values
`static AVector`	SparseImmutableVector.`create(int length, Index sparseIndex, AVector sparseValues)` Creates a SparseImmutableVector using the given sorted Index to identify the indexes of non-zero values, and a dense vector to specify all the non-zero element values
`static AVector`	SparseIndexedVector.`createWithIndices(AVector v, int[] ixs)` Creates a sparse indexed vector using the specified indexed values from the source vector All non-indexed vales will be zero.
`static int`	JoinedVector.`depthCalc(AVector v)`
`double`	ASparseVector.`distanceL1(AVector v)`
`double`	ASparseVector.`distanceLinf(AVector v)`
`double`	ASparseVector.`distanceSquared(AVector v)`
`void`	ADenseArrayVector.`divide(AVector v)`
`ZeroVector`	ZeroVector.`divideCopy(AVector a)`
`double`	ZeroVector.`dotProduct(AVector v)`
`double`	SparseHashedVector.`dotProduct(AVector v)`
`double`	RepeatedElementVector.`dotProduct(AVector v)`
`double`	JoinedVector.`dotProduct(AVector v)`
`double`	JoinedMultiVector.`dotProduct(AVector v)`
`double`	JoinedArrayVector.`dotProduct(AVector v)`
`double`	ImmutableVector.`dotProduct(AVector v)`
`double`	BaseStridedVector.`dotProduct(AVector v)`
`double`	AxisVector.`dotProduct(AVector v)`
`double`	AStridedVector.`dotProduct(AVector v)`
`double`	ASparseVector.`dotProduct(AVector v)`
`double`	ASparseIndexedVector.`dotProduct(AVector v)`
`double`	ASingleElementVector.`dotProduct(AVector v)`
`double`	ADenseArrayVector.`dotProduct(AVector v)`
`boolean`	ZeroVector.`equals(AVector v)`
`boolean`	Vector0.`equals(AVector v)`
`boolean`	SingleElementVector.`equals(AVector v)`
`boolean`	RepeatedElementVector.`equals(AVector v)`
`boolean`	JoinedVector.`equals(AVector v)`
`boolean`	JoinedMultiVector.`equals(AVector v)`
`boolean`	ImmutableVector.`equals(AVector v)`
`boolean`	BaseDerivedVector.`equals(AVector v)`
`boolean`	AxisVector.`equals(AVector v)`
`boolean`	ASparseVector.`equals(AVector v)`
`boolean`	ASparseIndexedVector.`equals(AVector v)`
`boolean`	ASingleElementVector.`equals(AVector v)`
`boolean`	AMatrixViewVector.`equals(AVector v)`
`boolean`	AJoinedVector.`equals(AVector a)`
`boolean`	ADenseArrayVector.`equals(AVector v)`
`void`	SparseIndexedVector.`includeIndices(AVector v)` Include additional indices in the non-sparse index set of this vector.
`boolean`	ASizedVector.`isSameShape(AVector a)`
`AVector`	Vector0.`join(AVector v)`
`AVector`	IndexedSubVector.`join(AVector v)`
`AVector`	IndexedArrayVector.`join(AVector v)`
`AVector`	ADenseArrayVector.`join(AVector v)`
`static AVector`	JoinedVector.`joinVectors(AVector left, AVector right)` Returns a JoinedVector connecting the two vectors
`void`	ZeroVector.`multiply(AVector a)`
`void`	SparseIndexedVector.`multiply(AVector v)`
`void`	ADenseArrayVector.`multiply(AVector v)`
`ZeroVector`	ZeroVector.`multiplyCopy(AVector a)`
`AVector`	RepeatedElementVector.`multiplyCopy(AVector v)`
`void`	AJoinedVector.`scaleAdd(double factor, AVector b, double bfactor, double constant)`
`void`	ADenseArrayVector.`scaleAdd(double factor, AVector v, double vfactor, double constant)`
`void`	StridedVector.`set(AVector v)`
`void`	StridedMatrixViewVector.`set(AVector v)`
`void`	SparseIndexedVector.`set(AVector v)`
`void`	SparseImmutableVector.`set(AVector v)`
`void`	SparseHashedVector.`set(AVector v)`
`void`	JoinedVector.`set(AVector src)`
`void`	JoinedMultiVector.`set(AVector src)`
`void`	JoinedArrayVector.`set(AVector v)`
`void`	ImmutableVector.`set(AVector v)`
`abstract void`	AStridedVector.`set(AVector v)`
`void`	ADenseArrayVector.`set(AVector a)`
`void`	JoinedVector.`set(AVector src, int srcOffset)`
`void`	JoinedMultiVector.`set(AVector src, int srcOffset)`
`void`	ADenseArrayVector.`set(AVector src, int srcOffset)`
`void`	SparseIndexedVector.`sub(AVector v)`
`AVector`	ZeroVector.`subCopy(AVector a)`
`Vector`	JoinedArrayVector.`subCopy(AVector a)`
`AVector`	AxisVector.`subCopy(AVector v)`
`AVector`	ZeroVector.`tryEfficientJoin(AVector a)`
`AVector`	WrappedSubVector.`tryEfficientJoin(AVector a)`
`AVector`	SingleElementVector.`tryEfficientJoin(AVector a)`
`AVector`	RepeatedElementVector.`tryEfficientJoin(AVector a)`
`AVector`	RangeVector.`tryEfficientJoin(AVector a)`
`AVector`	JoinedVector.`tryEfficientJoin(AVector a)`
`AVector`	JoinedMultiVector.`tryEfficientJoin(AVector v)`
`AVector`	JoinedArrayVector.`tryEfficientJoin(AVector v)`
`AVector`	ADenseArrayVector.`tryEfficientJoin(AVector v)`
`static AVector`	JoinedMultiVector.`wrap(AVector... vecs)`
`UnmodifiableVector`	UnmodifiableVector.`wrap(AVector v)`
`static VectorIndexScalar`	VectorIndexScalar.`wrap(AVector vector, int index)`
`static IndexedSubVector`	IndexedSubVector.`wrap(AVector source, int[] indexes)`
`static WrappedSubVector`	WrappedSubVector.`wrap(AVector source, int offset, int length)`

Constructors in mikera.vectorz.impl with parameters of type AVector
Constructor and Description
`BaseDerivedVector(AVector source)`
`ListWrapper(AVector v)`
`VectorIterator(AVector source)`
`VectorIterator(AVector source, int start, int length)`

Uses of AVector in mikera.vectorz.ops

Methods in mikera.vectorz.ops with parameters of type AVector
Modifier and Type	Method and Description
`void`	Tanh.`applyTo(AVector v)`
`void`	Square.`applyTo(AVector v)`
`void`	Sqrt.`applyTo(AVector a)`
`void`	Signum.`applyTo(AVector v)`
`void`	Reciprocal.`applyTo(AVector a)`
`void`	Quadratic.`applyTo(AVector v)`
`void`	Power.`applyTo(AVector a)`
`void`	Offset.`applyTo(AVector v)`
`void`	Logistic.`applyTo(AVector v)`
`void`	Log.`applyTo(AVector a)`
`void`	Linear.`applyTo(AVector v)`
`void`	Identity.`applyTo(AVector v)`
`void`	Constant.`applyTo(AVector v)`
`void`	Clamp.`applyTo(AVector v)`
`void`	ALinearOp.`applyTo(AVector v)`
`void`	Absolute.`applyTo(AVector v)`
`void`	CrossEntropyLogisticDerivative.`applyTo(double[] data, int start, int length, AVector b)`
`void`	CrossEntropyDerivative.`applyTo(double[] data, int start, int length, AVector b)`
`void`	CrossEntropy.`applyTo(double[] data, int start, int length, AVector b)`
`void`	ComposedOp2.`applyTo(double[] data, int start, int length, AVector b)`
`void`	AddFunction.`applyTo(double[] data, int start, int length, AVector b)`
`void`	Add.`applyTo(double[] data, int start, int length, AVector b)`

Uses of AVector in mikera.vectorz.util

Methods in mikera.vectorz.util that return AVector
Modifier and Type	Method and Description
`static AVector`	Testing.`createTestVector(int length)`
`static AVector`	Testing.`createTestVector(int length, mikera.util.Random r)`
`AVector`	MatrixBuilder.`getRowView(int row)`

Methods in mikera.vectorz.util with parameters of type AVector
Modifier and Type	Method and Description
`void`	MatrixBuilder.`append(AVector v)`
`void`	MatrixBuilder.`appendRow(AVector row)`
`static String`	ErrorMessages.`incompatibleShapes(Index index, AVector v)`
`static String`	ErrorMessages.`invalidIndex(AVector a, long[] indexes)`
`static String`	ErrorMessages.`invalidRange(AVector v, int start, int length)`
`void`	MatrixBuilder.`replaceRow(int i, AVector row)`
`static String`	ErrorMessages.`wrongDestLength(AVector dest)`
`static String`	ErrorMessages.`wrongSourceLength(AVector source)`

Uses of Classmikera.vectorz.AVector

Uses of AVector in mikera.arrayz

Uses of AVector in mikera.arrayz.impl

Uses of AVector in mikera.indexz

Uses of AVector in mikera.matrixx

Uses of AVector in mikera.matrixx.decompose

Uses of AVector in mikera.matrixx.decompose.impl.eigen

Uses of AVector in mikera.matrixx.decompose.impl.svd

Uses of AVector in mikera.matrixx.impl

Uses of AVector in mikera.matrixx.solve

Uses of AVector in mikera.transformz

Uses of AVector in mikera.transformz.impl

Uses of AVector in mikera.vectorz

Uses of AVector in mikera.vectorz.functions

Uses of AVector in mikera.vectorz.impl

Uses of AVector in mikera.vectorz.ops

Uses of AVector in mikera.vectorz.util

Uses of Class
mikera.vectorz.AVector