ZeroVector (Vectorz 0.62.0 API)

java.lang.Object
- mikera.arrayz.impl.AbstractArray<Double>
- - mikera.vectorz.AVector
  - - mikera.vectorz.impl.ASizedVector
    - - mikera.vectorz.impl.ASparseVector
      - mikera.vectorz.impl.ZeroVector

All Implemented Interfaces:

Serializable, Cloneable, Comparable<AVector>, Iterable<Double>, INDArray, ISparse, ISparseVector, IVector
```
public final class ZeroVector
extends ASparseVector
```
Specialised immutable vector containing nothing but zeros. This enables significant optimisations on operations involving zeros and composite arrays that have zero areas. Must have length 1 or more: use Vector0 instead for immutable length 0 vectors.

Author:

Mike

See Also:

Serialized Form

Field Summary
- Fields inherited from class mikera.vectorz.impl.ASizedVector
  length

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`ZeroVector`	`absCopy()` Returns a copy of the array with the abs operator applied to each element
`void`	`add(ASparseVector v)`
`AVector`	`addCopy(AVector a)` Adds a vector element-wise to this vector, returning a new vector.
`AVector`	`addCopy(double a)` Creates a new array equal to this array with a constant value added to every element
`void`	`addMultipleToArray(double factor, int offset, double[] array, int arrayOffset, int length)` Adds a multiple of a subvector of this vector into a double array at the specified offset
`void`	`addToArray(double[] dest, int offset, int stride)` Adds this vector to a double[] array, using the specified offset and stride into the destination array
`void`	`addToArray(int offset, double[] array, int arrayOffset, int length)` Adds a subvector of this vector into a double array at the specified offset
`AVector`	`applyOpCopy(Op op)` Applies a unary operator to all elements of the array (creating a new array)
`void`	`copyTo(int offset, double[] dest, int destOffset, int length, int stride)` Copies a subset of this vector to a specified destination array offset using the given stride.
`static ZeroVector`	`create(INDArray array)` Creates a ZeroVector with the same number of elements as the given array.
`static ZeroVector`	`create(int dimensions)` Create a ZeroVector with the specified number of dimensions
`static ZeroVector`	`createCached(int dimensions)`
`static ZeroVector`	`createNew(int dimensions)`
`double`	`density()` Computes the density ratio of this sparse array (proportion of non-zero elements)
`ZeroVector`	`divideCopy(AVector a)` Divides this vector element-wise by another vector, returning a new vector.
`double`	`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`	`dotProduct(double[] data, int offset)` Fast dot product with a double[] array.
`double`	`dotProduct(double[] data, int offset, int stride)` Fast dot product with a double[] array and a stride.
`double`	`elementAbsPowSum(double p)` Returns the sum of the absolute values of all the elements raised to a specified power
`double`	`elementMax()` Returns the maximum element value in this array.
`double`	`elementMin()` Returns the maximum element value in this array.
`double`	`elementPowSum(double p)` Returns the sum of all the elements raised to a specified power
`double`	`elementProduct()` Returns the product of all elements in the array.
`boolean`	`elementsEqual(double value)` Returns true if all elements are equal to a specific value
`double`	`elementSquaredSum()` Returns the sum of squared elements in this array.
`double`	`elementSum()` Returns the sum of all elements in a vector
`boolean`	`equals(AVector v)`
`boolean`	`equalsArray(double[] data, int offset)` Returns true if this vector exactly matches the elements in double[] array, starting from the specified offset
`ZeroVector`	`exactClone()` Returns an exact clone of this vector, i.e.
`double`	`get(int i)` Returns the double value at the specified position in a 1D vector
`void`	`getElements(double[] dest, int offset)` Gets all elements of the array, copying them into a double array at the specified offset
`void`	`getElements(Object[] dest, int offset)` Gets all elements of the array, copying them into an object array at the specified offset
`int`	`hashCode()` Computes the hashcode of a vector.
`boolean`	`hasUncountable()` Returns true if any element is this array is NaN or infinite
`boolean`	`includesIndex(int i)` Returns true iff the sparse vector contains the index i
`Scalar`	`innerProduct(ADenseArrayVector v)` Overloaded inner product for dense array vector argument
`AVector`	`innerProduct(AMatrix m)` Computes the inner product of this vector with a matrix
`boolean`	`isBoolean()` Returns true if the array is boolean (contains only 0.0 or 1.0 values)
`boolean`	`isFullyMutable()` Returns true if this vector is fully mutable, i.e.
`boolean`	`isMutable()` Returns true if this vector is mutable.
`boolean`	`isRangeZero(int start, int length)` Returns true if a sub-vector range is completely zero.
`boolean`	`isUnitLengthVector()` Returns true if the vector has unit length
`boolean`	`isZero()` Returns true if this vector is a zero vector (all components zero)
`Iterator<Double>`	`iterator()`
`ZeroVector`	`join(ZeroVector a)`
`double`	`magnitude()` Returns the magnitude (Euclidean length) of the vector
`double`	`maxAbsElement()` Returns the maximum absolute element value of a vector
`int`	`maxAbsElementIndex()` Returns the index of the maximum absolute element of a vector
`int`	`maxElementIndex()` Returns the index of the maximum element of a vector
`int`	`minElementIndex()` Returns the index of the minimum element of a vector
`void`	`multiply(AVector a)`
`void`	`multiply(double factor)` Multiplies the vector by a constant factor
`ZeroVector`	`multiplyCopy(AVector a)` Multiplies a vector element-wise with this vector, returning a new vector.
`ZeroVector`	`multiplyCopy(double factor)` Returns a copy of the array with all elements multiplied by a single constant value
`int`	`nonSparseElementCount()` Returns the number of non-sparse elements in the sparse vector.
`Index`	`nonSparseIndex()` Returns an Index indicating which elements of this vector are defined as non-sparse.
`AVector`	`nonSparseValues()` Returns the non-sparse elements as a compacted vector
`long`	`nonZeroCount()` Returns the number of non-zero elements in the array.
`int[]`	`nonZeroIndices()` Return an int array specifying the positions in this vector which are non-zero
`double[]`	`nonZeroValues()` Return an double array specifying the values in this vector which are non-zero
`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.
`RepeatedElementVector`	`reciprocalCopy()` Returns a new array where every element is the reciprocal of the corresponding element in this array
`double`	`reduce(Op2 op)` Reduces over all elements of the array in row-major order.
`double`	`reduce(Op2 op, double init)` Reduces over all elements of the array in row-major order.
`AVector`	`select(int... order)` Selects a subset of indices from a vector
`AVector`	`selectClone(int... inds)` Selects a subset of indices from a vector, returning a mutable clone of data
`AVector`	`selectView(int... inds)` Selects a subset of indices from a vector, returning a view
`void`	`set(int i, double value)` Sets a value at a given position in a mutable 1D array
`ImmutableScalar`	`slice(int i)` 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.
`AVector`	`sparseClone()` Clones the vector into a sparse mutable format
`AVector`	`squareCopy()` Squares all elements of the array, returning a new array
`AVector`	`subCopy(AVector a)` Subtracts a vector element-wise from this vector, returning a new vector.
`AVector`	`subVector(int offset, int length)` Obtains a sub-vector view that refers to this vector.
`double[]`	`toDoubleArray()` Copies the elements of this array to a new double[] array.
`AVector`	`tryEfficientJoin(AVector a)` Attempts to perform an efficient join with a second vector.
`double`	`unsafeGet(int i)`
`void`	`unsafeSet(int i, double value)`

Methods inherited from class mikera.vectorz.impl.ASparseVector
add, addMultiple, clone, copyTo, distanceL1, distanceLinf, distanceSquared, dotProduct, equals, getSlices, isSparse, isView, reduceSlices, roundToZero, sparse, toSparseIndexedVector

Methods inherited from class mikera.vectorz.impl.ASizedVector
checkIndex, checkLength, checkRange, checkSameLength, checkSameLength, elementCount, equalsArray, get, getShape, getShapeClone, isSameShape, length, sliceCount

Methods inherited from class mikera.vectorz.AVector
abs, add, add, add, add, add, add, add, add, addAt, addAt, addCopy, addInnerProduct, addInnerProduct, addInnerProduct, addMultiple, addMultiple, addMultiple, addMultiple, addMultiple, addMultiple, addMultiple, addMultipleCopy, addMultipleToArray, addPower, addPower, addPower, addProduct, addProduct, addProduct, addProductCopy, addProductCopy, addProductToArray, addProductToArray, addToArray, addWeighted, angle, applyOp, applyOp, applyOp, applyOp, applyOp, asDoubleArray, asElementList, asVector, broadcast, broadcastLike, broadcastLike, broadcastLike, checkDimension, checkSameLength, clamp, clampMax, clampMin, compareTo, copy, copyTo, copyTo, copyTo, crossProduct, crossProduct, dense, denseClone, dimensionality, distance, divide, divide, divide, divide, divideCopy, divideTo, dotProduct, elementIterator, epsilonEquals, epsilonEquals, epsilonEquals, epsilonEquals, equals, equals, fill, fillRange, get, get, get, get, getElements, getLongShape, getShape, getTranspose, getTransposeCopy, getTransposeView, immutable, innerProduct, innerProduct, innerProduct, innerProduct, interpolate, isElementConstrained, isSameShape, isUnitLengthVector, join, join, join, log, logistic, magnitudeSquared, maxElement, minElement, multiply, multiply, multiply, multiplyCopy, multiplyTo, mutable, negate, negateCopy, normalise, normaliseMaxAbsElement, outerProduct, outerProduct, pow, projectToPlane, reduceSlices, reorder, reorder, reshape, rotateCopy, rotateView, rotateView, scale, scaleAdd, scaleAdd, scaleAdd, scaleAdd, scaleCopy, scaleToMagnitude, set, set, set, set, set, set, set, set, set, set, setElements, setElements, setElements, setInnerProduct, setInnerProduct, setInnerProduct, setMultiple, setMultiple, setMultiple, setMultiple, shiftCopy, signum, slice, sliceValue, softmax, softmaxCopy, sqrtCopy, square, sub, sub, subArray, subAt, subCopy, subMultiple, tanh, toDoubleBuffer, toList, toNormal, toSliceArray, toString, toStringFull, toVector, validate

Methods inherited from class mikera.arrayz.impl.AbstractArray
add, addInnerProduct, addInnerProduct, addOuterProduct, broadcastCloneLike, broadcastCopyLike, checkMutable, componentCount, ensureMutable, exp, get, get, get, getComponent, getComponents, getElements, getElements, getSlices, getSliceViews, isDense, reciprocal, scale, set, set, signumCopy, sqrt, sub, sub, toArray, withComponents

Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface mikera.vectorz.IVector
epsilonEquals, isSameShape, length, normalise, rotateCopy, rotateView, shiftCopy, sqrtCopy

Methods inherited from interface mikera.arrayz.INDArray
abs, add, add, addAt, addCopy, addInnerProduct, addMultiple, addOuterProduct, addPower, addPower, addToArray, applyOp, applyOp, applyOp, applyOp, asDoubleArray, asElementList, asVector, broadcast, broadcastCloneLike, broadcastCopyLike, broadcastLike, broadcastLike, broadcastLike, checkMutable, clamp, componentCount, copy, dense, denseClone, dimensionality, divide, divide, divideCopy, elementCount, elementIterator, ensureMutable, epsilonEquals, epsilonEquals, equals, equalsArray, exp, fill, get, get, get, get, get, get, get, get, getComponent, getComponents, getElements, getElements, getLongShape, getShape, getShape, getShapeClone, getSlices, getSliceViews, getTranspose, getTransposeCopy, getTransposeView, immutable, innerProduct, innerProduct, innerProduct, innerProduct, isDense, isElementConstrained, isSameShape, join, join, log, multiply, multiplyCopy, mutable, negate, negateCopy, outerProduct, pow, reciprocal, reduceSlices, reorder, reorder, reshape, rotateView, scale, scaleAdd, scaleAdd, scaleCopy, set, set, set, set, set, set, setElements, setElements, setElements, setInnerProduct, setMultiple, setMultiple, signum, signumCopy, slice, sliceCount, sliceValue, sqrt, square, sub, sub, subArray, subCopy, toArray, toDoubleBuffer, toSliceArray, toVector, validate, withComponents

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Method Detail
  - create
```
public static ZeroVector create(int dimensions)
```
    Create a ZeroVector with the specified number of dimensions
    
    Parameters:
    
    dimensions -
    
    Returns:
  - createNew
```
public static ZeroVector createNew(int dimensions)
```
  - createCached
```
public static ZeroVector createCached(int dimensions)
```
  - create
```
public static ZeroVector create(INDArray array)
```
    Creates a ZeroVector with the same number of elements as the given array.
    
    Parameters:
    
    arraySize -
    
    Returns:
  - dotProduct
```
public double dotProduct(AVector v)
```
    Description copied from class: AVector
    
    Returns the dot product of this vector with another vector The vectors must have the same length: if not the result is undefined
    
    Overrides:
    
    dotProduct in class ASparseVector
    
    Returns:
  - dotProduct
```
public double dotProduct(double[] data,
                         int offset)
```
    Description copied from class: AVector
    
    Fast dot product with a double[] array. Performs no bounds checking. Likely to be faster than most other dot product operations
    
    Specified by:
    
    dotProduct in class AVector
  - innerProduct
```
public AVector innerProduct(AMatrix m)
```
    Description copied from class: AVector
    
    Computes the inner product of this vector with a matrix
    
    Overrides:
    
    innerProduct in class ASparseVector
    
    Returns:
    
    a vector representing the inner product
  - innerProduct
```
public Scalar innerProduct(ADenseArrayVector v)
```
    Description copied from class: AVector
    
    Overloaded inner product for dense array vector argument
    
    Overrides:
    
    innerProduct in class AVector
    
    Returns:
  - get
```
public double get(int i)
```
    Description copied from interface: INDArray
    
    Returns the double value at the specified position in a 1D vector
    
    Specified by:
    
    get in interface INDArray
    
    Specified by:
    
    get in interface IVector
    
    Specified by:
    
    get in class AVector
  - set
```
public void set(int i,
                double value)
```
    Description copied from interface: INDArray
    
    Sets a value at a given position in a mutable 1D array
    
    Specified by:
    
    set in interface INDArray
    
    Specified by:
    
    set in interface IVector
    
    Specified by:
    
    set in class AVector
  - unsafeGet
```
public double unsafeGet(int i)
```
    Overrides:
    
    unsafeGet in class AVector
  - unsafeSet
```
public void unsafeSet(int i,
                      double value)
```
    Overrides:
    
    unsafeSet in class AVector
  - add
```
public void add(ASparseVector v)
```
    Specified by:
    
    add in class ASparseVector
  - addCopy
```
public AVector addCopy(AVector a)
```
    Description copied from interface: IVector
    
    Adds a vector element-wise to this vector, returning a new vector.
    
    Specified by:
    
    addCopy in interface IVector
    
    Overrides:
    
    addCopy in class AVector
    
    Returns:
  - addCopy
```
public AVector addCopy(double a)
```
    Description copied from interface: INDArray
    
    Creates a new array equal to this array with a constant value added to every element
    
    Specified by:
    
    addCopy in interface INDArray
    
    Overrides:
    
    addCopy in class AVector
    
    Returns:
  - subCopy
```
public AVector subCopy(AVector a)
```
    Description copied from interface: IVector
    
    Subtracts a vector element-wise from this vector, returning a new vector.
    
    Specified by:
    
    subCopy in interface IVector
    
    Overrides:
    
    subCopy in class AVector
    
    Returns:
  - reciprocalCopy
```
public RepeatedElementVector reciprocalCopy()
```
    Description copied from interface: INDArray
    
    Returns a new array where every element is the reciprocal of the corresponding element in this array
    
    Specified by:
    
    reciprocalCopy in interface INDArray
    
    Overrides:
    
    reciprocalCopy in class AbstractArray<Double>
  - absCopy
```
public ZeroVector absCopy()
```
    Description copied from interface: INDArray
    
    Returns a copy of the array with the abs operator applied to each element
    
    Specified by:
    
    absCopy in interface INDArray
    
    Overrides:
    
    absCopy in class AVector
    
    Returns:
    
    A new array containing the absolute element values
  - multiply
```
public void multiply(AVector a)
```
    Overrides:
    
    multiply in class AVector
  - multiply
```
public void multiply(double factor)
```
    Description copied from class: AVector
    
    Multiplies the vector by a constant factor
    
    Specified by:
    
    multiply in interface INDArray
    
    Overrides:
    
    multiply in class AVector
    
    Parameters:
    
    factor - Factor by which to multiply each component of the vector
  - multiplyCopy
```
public ZeroVector multiplyCopy(AVector a)
```
    Description copied from interface: IVector
    
    Multiplies a vector element-wise with this vector, returning a new vector.
    
    Specified by:
    
    multiplyCopy in interface IVector
    
    Overrides:
    
    multiplyCopy in class AVector
    
    Returns:
  - multiplyCopy
```
public ZeroVector multiplyCopy(double factor)
```
    Description copied from interface: INDArray
    
    Returns a copy of the array with all elements multiplied by a single constant value
    
    Specified by:
    
    multiplyCopy in interface INDArray
    
    Overrides:
    
    multiplyCopy in class AVector
    
    Parameters:
    
    factor - A scalar factor
    
    Returns:
    
    A new array, with all element values scaled by the given factor
  - normaliseCopy
```
public AVector normaliseCopy()
```
    Description copied from class: AVector
    
    Returns a copy of this vector normalised to a Euclidean length of 1.0 Has no effect on a zero-length vector (i.e. it will return a zero length vector)
    
    Specified by:
    
    normaliseCopy in interface IVector
    
    Overrides:
    
    normaliseCopy in class AVector
    
    Returns:
  - divideCopy
```
public ZeroVector divideCopy(AVector a)
```
    Description copied from interface: IVector
    
    Divides this vector element-wise by another vector, returning a new vector.
    
    Specified by:
    
    divideCopy in interface IVector
    
    Overrides:
    
    divideCopy in class AVector
    
    Returns:
  - elementSquaredSum
```
public double elementSquaredSum()
```
    Description copied from interface: INDArray
    
    Returns the sum of squared elements in this array.
    
    Specified by:
    
    elementSquaredSum in interface INDArray
    
    Overrides:
    
    elementSquaredSum in class ASparseVector
  - magnitude
```
public double magnitude()
```
    Description copied from class: AVector
    
    Returns the magnitude (Euclidean length) of the vector
    
    Overrides:
    
    magnitude in class AVector
    
    Returns:
  - elementSum
```
public double elementSum()
```
    Description copied from class: AVector
    
    Returns the sum of all elements in a vector
    
    Specified by:
    
    elementSum in interface INDArray
    
    Overrides:
    
    elementSum in class ASparseVector
  - elementProduct
```
public double elementProduct()
```
    Description copied from interface: INDArray
    
    Returns the product of all elements in the array.
    
    Specified by:
    
    elementProduct in interface INDArray
    
    Overrides:
    
    elementProduct in class ASparseVector
    
    Returns:
  - elementMax
```
public double elementMax()
```
    Description copied from interface: INDArray
    
    Returns the maximum element value in this array. Throws an error if there are no elements.
    
    Specified by:
    
    elementMax in interface INDArray
    
    Overrides:
    
    elementMax in class AVector
  - elementMin
```
public double elementMin()
```
    Description copied from interface: INDArray
    
    Returns the maximum element value in this array. Throws an error if there are no elements.
    
    Specified by:
    
    elementMin in interface INDArray
    
    Overrides:
    
    elementMin in class AVector
  - maxElementIndex
```
public int maxElementIndex()
```
    Description copied from class: AVector
    
    Returns the index of the maximum element of a vector
    
    Overrides:
    
    maxElementIndex in class AVector
    
    Returns:
  - maxAbsElement
```
public double maxAbsElement()
```
    Description copied from class: AVector
    
    Returns the maximum absolute element value of a vector
    
    Overrides:
    
    maxAbsElement in class AVector
    
    Returns:
  - maxAbsElementIndex
```
public int maxAbsElementIndex()
```
    Description copied from class: AVector
    
    Returns the index of the maximum absolute element of a vector
    
    Overrides:
    
    maxAbsElementIndex in class AVector
    
    Returns:
  - minElementIndex
```
public int minElementIndex()
```
    Description copied from class: AVector
    
    Returns the index of the minimum element of a vector
    
    Overrides:
    
    minElementIndex in class AVector
  - nonZeroCount
```
public long nonZeroCount()
```
    Description copied from interface: INDArray
    
    Returns the number of non-zero elements in the array.
    
    Specified by:
    
    nonZeroCount in interface INDArray
    
    Overrides:
    
    nonZeroCount in class ASparseVector
  - nonZeroValues
```
public double[] nonZeroValues()
```
    Description copied from class: AVector
    
    Return an double array specifying the values in this vector which are non-zero
    
    Overrides:
    
    nonZeroValues in class AVector
    
    Returns:
  - isZero
```
public boolean isZero()
```
    Description copied from class: AVector
    
    Returns true if this vector is a zero vector (all components zero)
    
    Specified by:
    
    isZero in interface INDArray
    
    Overrides:
    
    isZero in class ASparseVector
  - isRangeZero
```
public boolean isRangeZero(int start,
                           int length)
```
    Description copied from class: AVector
    
    Returns true if a sub-vector range is completely zero. Unsafe operation - does not perform bounds checking, results are undefined if sub-vector is out of range
    
    Overrides:
    
    isRangeZero in class AVector
    
    Returns:
  - isBoolean
```
public boolean isBoolean()
```
    Description copied from interface: INDArray
    
    Returns true if the array is boolean (contains only 0.0 or 1.0 values)
    
    Specified by:
    
    isBoolean in interface INDArray
    
    Overrides:
    
    isBoolean in class AbstractArray<Double>
  - isMutable
```
public boolean isMutable()
```
    Description copied from class: AVector
    
    Returns true if this vector is mutable.
    
    Specified by:
    
    isMutable in interface INDArray
    
    Overrides:
    
    isMutable in class AVector
  - isFullyMutable
```
public boolean isFullyMutable()
```
    Description copied from class: AVector
    
    Returns true if this vector is fully mutable, i.e. can contain any unconstrained double values
    
    Specified by:
    
    isFullyMutable in interface INDArray
    
    Overrides:
    
    isFullyMutable in class AVector
  - isUnitLengthVector
```
public boolean isUnitLengthVector()
```
    Description copied from class: AVector
    
    Returns true if the vector has unit length
    
    Overrides:
    
    isUnitLengthVector in class AVector
    
    Returns:
  - reduce
```
public double reduce(Op2 op,
                     double init)
```
    Description copied from interface: INDArray
    
    Reduces over all elements of the array in row-major order. Applies the operator to the initial/previous result at each step. Returns the final result.
    
    Specified by:
    
    reduce in interface INDArray
    
    Overrides:
    
    reduce in class ASparseVector
  - reduce
```
public double reduce(Op2 op)
```
    Description copied from interface: INDArray
    
    Reduces over all elements of the array in row-major order. Applies the operator to the previous result at each step. Returns the final result.
    
    Specified by:
    
    reduce in interface INDArray
    
    Overrides:
    
    reduce in class ASparseVector
  - applyOpCopy
```
public AVector applyOpCopy(Op op)
```
    Description copied from interface: INDArray
    
    Applies a unary operator to all elements of the array (creating a new array)
    
    Specified by:
    
    applyOpCopy in interface INDArray
    
    Overrides:
    
    applyOpCopy in class AVector
  - addToArray
```
public void addToArray(int offset,
                       double[] array,
                       int arrayOffset,
                       int length)
```
    Description copied from class: AVector
    
    Adds a subvector of this vector into a double array at the specified offset
    
    Overrides:
    
    addToArray in class AVector
  - copyTo
```
public void copyTo(int offset,
                   double[] dest,
                   int destOffset,
                   int length,
                   int stride)
```
    Description copied from class: AVector
    
    Copies a subset of this vector to a specified destination array offset using the given stride. Unsafe operation: performs no bounds checking
    
    Overrides:
    
    copyTo in class ASparseVector
  - addToArray
```
public void addToArray(double[] dest,
                       int offset,
                       int stride)
```
    Description copied from class: AVector
    
    Adds this vector to a double[] array, using the specified offset and stride into the destination array
    
    Overrides:
    
    addToArray in class AVector
  - addMultipleToArray
```
public void addMultipleToArray(double factor,
                               int offset,
                               double[] array,
                               int arrayOffset,
                               int length)
```
    Description copied from class: AVector
    
    Adds a multiple of a subvector of this vector into a double array at the specified offset
    
    Overrides:
    
    addMultipleToArray in class AVector
  - slice
```
public final ImmutableScalar slice(int i)
```
    Description copied from interface: INDArray
    
    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.
    
    Specified by:
    
    slice in interface INDArray
    
    Overrides:
    
    slice in class AVector
  - iterator
```
public Iterator<Double> iterator()
```
    Specified by:
    
    iterator in interface Iterable<Double>
    
    Overrides:
    
    iterator in class AVector
  - density
```
public double density()
```
    Description copied from interface: ISparse
    
    Computes the density ratio of this sparse array (proportion of non-zero elements)
    
    Specified by:
    
    density in interface ISparse
    
    Overrides:
    
    density in class AbstractArray<Double>
    
    Returns:
  - subVector
```
public AVector subVector(int offset,
                         int length)
```
    Description copied from class: AVector
    
    Obtains a sub-vector view that refers to this vector. Changes to the sub-vector will be reflected in this vector
    
    Overrides:
    
    subVector in class AVector
  - join
```
public ZeroVector join(ZeroVector a)
```
  - tryEfficientJoin
```
public AVector tryEfficientJoin(AVector a)
```
    Description copied from class: AVector
    
    Attempts to perform an efficient join with a second vector. An efficient join is guaranteed to be better than a simple JoinedVector(left,right) If possible, returns the joined vector. If not, returns null
    
    Overrides:
    
    tryEfficientJoin in class AVector
  - select
```
public AVector select(int... order)
```
    Description copied from class: AVector
    
    Selects a subset of indices from a vector
    
    Overrides:
    
    select in class AVector
    
    Returns:
  - nonSparseElementCount
```
public int nonSparseElementCount()
```
    Description copied from class: ASparseVector
    
    Returns the number of non-sparse elements in the sparse vector. This will be greater or equal to the number of non-zero elements
    
    Specified by:
    
    nonSparseElementCount in class ASparseVector
    
    Returns:
  - nonSparseValues
```
public AVector nonSparseValues()
```
    Description copied from interface: ISparseVector
    
    Returns the non-sparse elements as a compacted vector
    
    Specified by:
    
    nonSparseValues in interface ISparseVector
    
    Specified by:
    
    nonSparseValues in class ASparseVector
    
    Returns:
  - nonSparseIndex
```
public Index nonSparseIndex()
```
    Description copied from class: AVector
    
    Returns an Index indicating which elements of this vector are defined as non-sparse. A sparse index must be zero. A non-sparse element may be zero, but is expected be non-zero.
    
    Specified by:
    
    nonSparseIndex in interface ISparseVector
    
    Specified by:
    
    nonSparseIndex in class ASparseVector
    
    Returns:
  - nonZeroIndices
```
public int[] nonZeroIndices()
```
    Description copied from class: AVector
    
    Return an int array specifying the positions in this vector which are non-zero
    
    Overrides:
    
    nonZeroIndices in class AVector
    
    Returns:
  - squareCopy
```
public AVector squareCopy()
```
    Description copied from interface: INDArray
    
    Squares all elements of the array, returning a new array
    
    Specified by:
    
    squareCopy in interface INDArray
    
    Overrides:
    
    squareCopy in class AVector
  - includesIndex
```
public boolean includesIndex(int i)
```
    Description copied from class: ASparseVector
    
    Returns true iff the sparse vector contains the index i
    
    Specified by:
    
    includesIndex in class ASparseVector
    
    Returns:
  - hashCode
```
public int hashCode()
```
    Description copied from class: AVector
    
    Computes the hashcode of a vector. Currently defined to be equal to List.hashCode for a equivalent list of Double values, this may change in future versions.
    
    Overrides:
    
    hashCode in class AVector
  - exactClone
```
public ZeroVector exactClone()
```
    Description copied from class: AVector
    
    Returns an exact clone of this vector, i.e. of the same type
    
    Specified by:
    
    exactClone in interface INDArray
    
    Specified by:
    
    exactClone in class AVector
    
    Returns:
    
    A clone of the original array
  - sparseClone
```
public AVector sparseClone()
```
    Description copied from class: AVector
    
    Clones the vector into a sparse mutable format
    
    Specified by:
    
    sparseClone in interface INDArray
    
    Overrides:
    
    sparseClone in class AVector
  - toDoubleArray
```
public double[] toDoubleArray()
```
    Description copied from interface: INDArray
    
    Copies the elements of this array to a new double[] array.
    
    Specified by:
    
    toDoubleArray in interface INDArray
    
    Overrides:
    
    toDoubleArray in class ASparseVector
  - getElements
```
public void getElements(double[] dest,
                        int offset)
```
    Description copied from interface: INDArray
    
    Gets all elements of the array, copying them into a double array at the specified offset
    
    Specified by:
    
    getElements in interface INDArray
    
    Overrides:
    
    getElements in class AVector
  - getElements
```
public void getElements(Object[] dest,
                        int offset)
```
    Description copied from interface: INDArray
    
    Gets all elements of the array, copying them into an object array at the specified offset
    
    Specified by:
    
    getElements in interface INDArray
    
    Overrides:
    
    getElements in class AVector
  - selectClone
```
public AVector selectClone(int... inds)
```
    Description copied from class: AVector
    
    Selects a subset of indices from a vector, returning a mutable clone of data
    
    Overrides:
    
    selectClone in class AVector
    
    Returns:
    
    a new mutable vector containing the selected indices
  - selectView
```
public AVector selectView(int... inds)
```
    Description copied from class: AVector
    
    Selects a subset of indices from a vector, returning a view
    
    Overrides:
    
    selectView in class AVector
    
    Returns:
    
    a view of the selected indices
  - equals
```
public boolean equals(AVector v)
```
    Overrides:
    
    equals in class ASparseVector
  - equalsArray
```
public boolean equalsArray(double[] data,
                           int offset)
```
    Description copied from class: AVector
    
    Returns true if this vector exactly matches the elements in double[] array, starting from the specified offset
    
    Specified by:
    
    equalsArray in interface INDArray
    
    Overrides:
    
    equalsArray in class ASizedVector
    
    Parameters:
    
    data - Array of double element values to check for equality
    
    offset - Offset into the data array
    
    Returns:
  - elementsEqual
```
public boolean elementsEqual(double value)
```
    Description copied from interface: INDArray
    
    Returns true if all elements are equal to a specific value
    
    Specified by:
    
    elementsEqual in interface INDArray
    
    Overrides:
    
    elementsEqual in class AVector
  - hasUncountable
```
public boolean hasUncountable()
```
    Description copied from class: AbstractArray
    
    Returns true if any element is this array is NaN or infinite
    
    Specified by:
    
    hasUncountable in interface INDArray
    
    Overrides:
    
    hasUncountable in class ASparseVector
    
    Returns:
    
    True if any element is this array is NaN or infinite, false otherwise
  - elementPowSum
```
public double elementPowSum(double p)
```
    Description copied from class: ASparseVector
    
    Returns the sum of all the elements raised to a specified power
    
    Specified by:
    
    elementPowSum in interface INDArray
    
    Overrides:
    
    elementPowSum in class ASparseVector
    
    Returns:
  - elementAbsPowSum
```
public double elementAbsPowSum(double p)
```
    Description copied from class: ASparseVector
    
    Returns the sum of the absolute values of all the elements raised to a specified power
    
    Specified by:
    
    elementAbsPowSum in interface INDArray
    
    Overrides:
    
    elementAbsPowSum in class ASparseVector
    
    Returns:
  - dotProduct
```
public double dotProduct(double[] data,
                         int offset,
                         int stride)
```
    Description copied from class: AVector
    
    Fast dot product with a double[] array and a stride. Performs no bounds checking. Likely to be faster than other dot product operations
    
    Overrides:
    
    dotProduct in class AVector

Class ZeroVector

Field Summary

Fields inherited from class mikera.vectorz.impl.ASizedVector

Method Summary

Methods inherited from class mikera.vectorz.impl.ASparseVector

Methods inherited from class mikera.vectorz.impl.ASizedVector

Methods inherited from class mikera.vectorz.AVector

Methods inherited from class mikera.arrayz.impl.AbstractArray

Methods inherited from class java.lang.Object

Methods inherited from interface mikera.vectorz.IVector

Methods inherited from interface mikera.arrayz.INDArray

Methods inherited from interface java.lang.Iterable

Method Detail

create

createNew

createCached

create

dotProduct

dotProduct

innerProduct

innerProduct

get

set

unsafeGet

unsafeSet

add

addCopy

addCopy

subCopy

reciprocalCopy

absCopy

multiply

multiply

multiplyCopy

multiplyCopy

normaliseCopy

divideCopy

elementSquaredSum

magnitude

elementSum

elementProduct

elementMax

elementMin

maxElementIndex

maxAbsElement

maxAbsElementIndex

minElementIndex

nonZeroCount

nonZeroValues

isZero

isRangeZero

isBoolean

isMutable

isFullyMutable

isUnitLengthVector

reduce

reduce

applyOpCopy

addToArray

copyTo

addToArray

addMultipleToArray

slice

iterator

density

subVector

join

tryEfficientJoin

select

nonSparseElementCount

nonSparseValues

nonSparseIndex

nonZeroIndices

squareCopy

includesIndex

hashCode

exactClone

sparseClone

toDoubleArray

getElements