AVector (vectorz 0.22.0 API)

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

All Implemented Interfaces:

Serializable, Cloneable, Comparable<AVector>, Iterable<Double>, INDArray, IVector

Direct Known Subclasses:

AConstrainedVector, ADerivedVector, AMatrixSubVector, AMatrixViewVector, APrimitiveVector, AStridedVector, AWrappedVector, IndexedArrayVector, IndexedSubVector, JoinedArrayVector, JoinedVector
```
public abstract class AVector
extends AbstractArray<Double>
implements IVector, Comparable<AVector>, Serializable
```
Main abstract base class for all types of vector Contains default implementations for most vector operations which can be overriden to achieve better performance in derived classes.

Author:

Mike

See Also:
Serialized Form

Constructor Summary

Constructors
Constructor and Description

AVector()

Constructors
Constructor and Description
`AVector()`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`abs()` Sets each component of the vector to its absolute value
`void`	`add(AVector v)` Adds another vector to this one
`void`	`add(AVector src, int srcOffset)` Adds part another vector to this one, starting at the specified offset in the source vector
`void`	`add(double constant)` Adds a double value to all elements in this array
`void`	`add(INDArray a)` Adds all the elements of another array to this array, in an elementwise order.
`void`	`add(int offset, AVector a)` Adds another vector into this one, at the specified offset
`void`	`add(int offset, AVector a, int aOffset, int length)` Adds another vector into this one, at the specified offset
`void`	`addAt(int i, double v)` Adds a value to a specific element of the vector This function does not perform bounds checking
`void`	`addMultiple(AVector src, double factor)` Adds a scaled multiple of another vector to this one
`void`	`addMultiple(AVector source, Index sourceToDest, double factor)` Adds source vector to this vector at the specified indexes which should map from source->this
`void`	`addMultiple(AVector src, int srcOffset, double factor)`
`void`	`addMultiple(Index destToSource, AVector source, double factor)` Adds to this vector at taking values from source at the specified indexes which should map from this->source
`void`	`addMultiple(Index destToSource, Vector source, double factor)` Adds to this vector at taking values from source at the specified indexes which should map from this->source
`void`	`addMultiple(int offset, AVector v, double factor)`
`void`	`addMultiple(int offset, AVector src, int srcOffset, int length, double factor)`
`void`	`addMultiple(Vector source, Index sourceToDest, double factor)` Adds source vector to this vector at the specified indexes which should map from source->this
`void`	`addMultipleToArray(double factor, int offset, double[] array, int arrayOffset, int length)`
`void`	`addProduct(AVector a, AVector b)`
`void`	`addProduct(AVector a, AVector b, double factor)`
`void`	`addProduct(AVector a, int aOffset, AVector b, int bOffset, double factor)`
`void`	`addProductToArray(double factor, int offset, AArrayVector other, int otherOffset, double[] array, int arrayOffset, int length)`
`void`	`addProductToArray(double factor, int offset, AVector other, int otherOffset, double[] array, int arrayOffset, int length)`
`void`	`addToArray(double[] array, int offset)`
`void`	`addToArray(int offset, double[] array, int arrayOffset, int length)`
`void`	`addWeighted(AVector v, double factor)` Updates a weighted average of this vector with another vector
`double`	`angle(AVector v)` Returns the Euclidean angle between this vector and another vector
`void`	`applyOp(IOp op)` Applies a unary operator to all elements of the array (in-place)
`void`	`applyOp(Op op)` Applies a unary operator to all elements of the array (in-place)
`double[]`	`asDoubleArray()` Returns the underlying double array representing the packed elements of this array Returns nil if there is no such underlying array
`List<Double>`	`asElementList()` Returns a list containing all elements of this array
`AVector`	`asVector()` Constructs a view of the array as a single vector in row-major order.
`INDArray`	`broadcast(int... targetShape)` Returns a view of this array broadcasted up to a larger shape
`INDArray`	`broadcastLike(AMatrix target)`
`INDArray`	`broadcastLike(INDArray target)` Broadcasts to match the shape of the target
`void`	`clamp(double min, double max)` Clamps all values in the vector to a given range
`void`	`clampMax(double max)`
`void`	`clampMin(double min)`
`AVector`	`clone()` Clones the vector, creating a new copy of all data.
`int`	`compareTo(AVector a)`
`void`	`copyTo(AArrayVector dest, int destOffset)` Copies a the contents of a vector to a vector at the specified offset
`void`	`copyTo(AVector dest, int destOffset)` Copies a the contents of a vector to a vector at the specified offset
`void`	`copyTo(double[] arr)` Copies all the elements of this INDArray to the specified double array
`void`	`copyTo(double[] data, int offset)` Copies a the contents of a vector to a double array at the specified offset
`void`	`copyTo(int offset, AVector dest, int destOffset, int length)` Copies a subset of this vector to a vector at the specified offset
`void`	`copyTo(int offset, double[] dest, int destOffset, int length)`
`void`	`crossProduct(AVector a)`
`int`	`dimensionality()` Returns the dimensionality of the array (number of dimensions in the array shape) e.g.
`double`	`distance(AVector v)`
`double`	`distanceL1(AVector v)`
`double`	`distanceLinf(AVector v)`
`double`	`distanceSquared(AVector v)`
`void`	`divide(AVector v)`
`void`	`divide(double factor)` Divides all elements by a given factor
`void`	`divide(double[] data, int offset)`
`void`	`divide(INDArray a)` Divides all elements by the equivalent elements in a second array
`void`	`divideTo(double[] data, int offset)`
`double`	`dotProduct(AVector v)`
`double`	`dotProduct(AVector v, Index ix)`
`double`	`dotProduct(double[] data, int offset)` Fast dot product with a double[] array.
`double`	`dotProduct(Vector v)`
`long`	`elementCount()` Returns the total number of elements in this array.
`Iterator<Double>`	`elementIterator()` Returns an iterator over all elements in this array.
`double`	`elementSquaredSum()` Returns the total sum of elements in this array.
`double`	`elementSum()` Returns the sum of all elements in a vector
`boolean`	`epsilonEquals(AVector v)`
`boolean`	`epsilonEquals(AVector v, double tolerance)`
`boolean`	`epsilonEquals(INDArray a)` Tests is this array is approximately equal to another array.
`boolean`	`epsilonEquals(INDArray a, double tolerance)` Tests is this array is approximately equal to another array, up to a given tolerance (epsilon) The arrays must have the same shape
`boolean`	`equals(AVector v)`
`boolean`	`equals(INDArray v)` Returns true if the two arrays are exactly equal in value and shape
`boolean`	`equals(Object o)` Test for equality on vectors.
`boolean`	`equalsArray(double[] data)`
`abstract AVector`	`exactClone()` Returns an exact clone of this vector, i.e.
`void`	`fill(double value)` Fills the entire vector with a given value
`void`	`fillRange(int offset, int length, double value)`
`double`	`get()` Returns the double value of a scalar array
`double`	`get(int... indexes)` Returns the double value at the specified index position in an array
`abstract 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
`long[]`	`getLongShape()` Returns the shape of the array as an array of longs.
`int[]`	`getShape()` Returns the shape of the array as an array of ints.
`int`	`getShape(int dim)` Returns the dimension size for a specific dimension in the array's shape
`List<Double>`	`getSlices()` Returns a list of all major slices of this array.
`AVector`	`getTranspose()` Returns the transpose of this array.
`Vector`	`getTransposeCopy()` Returns a transposed copy of the array.
`AVector`	`getTransposeView()` Returns a transposed view of the array.
`int`	`hashCode()` Computes the hashcode of a vector.
`AVector`	`innerProduct(AMatrix m)`
`AVector`	`innerProduct(AScalar s)`
`Scalar`	`innerProduct(AVector v)`
`INDArray`	`innerProduct(INDArray a)` Calculates the inner product of this array with another array.
`Scalar`	`innerProduct(Vector v)`
`void`	`interpolate(AVector a, AVector b, double alpha)`
`void`	`interpolate(AVector v, double alpha)`
`boolean`	`isElementConstrained()` Returns true if this array has some constraints on element values
`boolean`	`isFullyMutable()` Returns true if this vector is fully mutable, i.e.
`boolean`	`isMutable()` Returns true if this vector is mutable.
`boolean`	`isSameShape(AVector a)`
`boolean`	`isSameShape(INDArray a)` Returns true if this array is the same shape as another array
`boolean`	`isUnitLengthVector()` Returns true if the vector has unit length
`boolean`	`isView()` Returns true if this vector is of a view type that references other vectors / data.
`boolean`	`isZero()` Returns true if this vector is a zero vector (all components zero)
`Iterator<Double>`	`iterator()`
`AVector`	`join(AVector second)` Returns a new vector that refers to this vector joined to a second vector
`abstract int`	`length()`
`void`	`log()` Computes the natural logarithm (in-place) for all array elements
`void`	`logistic()`
`double`	`magnitude()` Returns the magnitude (Euclidean length) of the vector
`double`	`magnitudeSquared()`
`double`	`maxAbsElement()` Returns the maximum absolute element of a vector
`void`	`multiply(AVector v)`
`void`	`multiply(double factor)` Multiplies the vector by a constant factor
`void`	`multiply(double[] data, int offset)`
`void`	`multiply(INDArray a)` Multiplies all elements by the equivalent elements in a second array
`void`	`multiplyTo(double[] data, int offset)`
`void`	`negate()` Negates all elements in the array
`long`	`nonZeroCount()` Returns the number of non-zero elements in the array.
`double`	`normalise()` Normalises this vector to a magnitude of 1.0 Has no effect on a zero-length vector (i.e.
`double`	`normaliseMaxAbsElement()` Normalises so that the maximum absolute element is 1.0 Returns the previous maximum absolute element.
`AMatrix`	`outerProduct(AVector a)`
`INDArray`	`outerProduct(INDArray a)` Calculates the outer product of this array with another array.
`void`	`pow(double exponent)` Raises all elements of the array to a specified power
`void`	`projectToPlane(AVector normal, double distance)`
`INDArray`	`reshape(int... dimensions)` Returns a new array by rearranging the elements of this array into the desired shape Truncates or zero-pads the elements as required to fill the new shape
`void`	`scale(AVector v)` Scales the vector by another vector of the same size
`void`	`scaleAdd(double factor, AVector v)`
`void`	`scaleAdd(double factor, double constant)` Scales all elements of the array by a given double value and adds a constant vale
`double`	`scaleToMagnitude(double targetMagnitude)` Scales the vector up to a specific target magnitude
`void`	`set(AVector src)` Sets the vector to equal the value of another vector
`void`	`set(AVector v, Index indexes)` sets the vector using values indexed from another vector
`void`	`set(AVector src, int srcOffset)` Set the vector equal to an offset into another vector
`void`	`set(double a)` Sets all elements of an array to a specific double value
`void`	`set(double[] data)` Deprecated.
`void`	`set(INDArray a)` Sets this array to the element values contained in another array
`void`	`set(int[] indexes, double value)`
`abstract void`	`set(int i, double value)`
`void`	`set(IVector vector)`
`void`	`setElements(double[] data)` Sets all elements in an array using the given double values
`void`	`setElements(double[] values, int offset, int length)` Sets all elements in an array using the given double values
`void`	`setRange(int offset, double[] data, int dataOffset, int length)` Set a subrange of this vector from a double array
`void`	`setValues(double... values)`
`void`	`signum()` Sets each component of the vector to its sign value (-1, 0 or 1)
`AScalar`	`slice(int position)` Returns the specified major slice of this array as a view (slice along dimension 0)
`AScalar`	`slice(int dimension, int index)` Returns a slice view of this array along the specified dimension
`int`	`sliceCount()` returns the number of major slices in this array.
`void`	`square()` Squares all elements of the vector
`void`	`sub(AVector v)` Subtracts a vector from this vector
`void`	`sub(double d)` Subtracts a double value from all elements in this array
`void`	`sub(INDArray a)` Subtracts all the elements of another array from this array, in an elementwise order.
`void`	`subMultiple(AVector v, double factor)` Subtracts a scaled multiple of another vector from this vector
`AVector`	`subVector(int offset, int length)` Obtains a sub-vector that refers to this vector.
`void`	`tanh()`
`double[]`	`toDoubleArray()` Copies the elements of this INDArray to a new double array
`void`	`toDoubleBuffer(DoubleBuffer dest)` Copies the elements of this INDArray to the specified double buffer
`List<Double>`	`toList()`
`AVector`	`toNormal()` Creates a new mutable vector representing the normalised value of this vector
`String`	`toString()`
`Vector`	`toVector()` Converts the array into a flattened vector
`double`	`unsafeGet(int i)`
`void`	`unsafeSet(int i, double value)`
`void`	`validate()` Validates the internal data structure of the INDArray.
`long`	`zeroCount()`

Methods inherited from class mikera.arrayz.impl.AbstractArray
broadcastCloneLike, ensureMutable, exp, get, getSliceViews, isBoolean, reciprocal, scale, set, set, sqrt, toArray

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

Methods inherited from interface mikera.arrayz.INDArray
broadcastCloneLike, ensureMutable, exp, get, getSliceViews, isBoolean, reciprocal, scale, set, set, sqrt, toArray

- Constructor Detail
  - AVector
```
public AVector()
```
- Method Detail
  - length
```
public abstract int length()
```
    Specified by:
    
    length in interface IVector
  - get
```
public abstract 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
    
    Overrides:
    
    get in class AbstractArray<Double>
    
    Returns:
  - set
```
public abstract void set(int i,
       double value)
```
    Specified by:
    
    set in interface INDArray
    
    Specified by:
    
    set in interface IVector
    
    Overrides:
    
    set in class AbstractArray<Double>
  - set
```
public void set(int[] indexes,
       double value)
```
    Specified by:
    
    set in interface INDArray
  - unsafeSet
```
public void unsafeSet(int i,
             double value)
```
  - unsafeGet
```
public double unsafeGet(int i)
```
  - dimensionality
```
public final int dimensionality()
```
    Description copied from interface: INDArray
    
    Returns the dimensionality of the array (number of dimensions in the array shape) e.g. 0 for a scalar, 1 for a vector, 2 for a matrix etc.
    
    Specified by:
    
    dimensionality in interface INDArray
    
    Returns:
  - get
```
public double get(int... indexes)
```
    Description copied from interface: INDArray
    
    Returns the double value at the specified index position in an array
    
    Specified by:
    
    get in interface INDArray
    
    Returns:
  - get
```
public double get()
```
    Description copied from interface: INDArray
    
    Returns the double value of a scalar array
    
    Specified by:
    
    get in interface INDArray
    
    Overrides:
    
    get in class AbstractArray<Double>
    
    Returns:
  - slice
```
public AScalar slice(int position)
```
    Description copied from interface: INDArray
    
    Returns the specified major slice of this array as a view (slice along dimension 0)
    
    Specified by:
    
    slice in interface INDArray
    
    Returns:
  - slice
```
public AScalar slice(int dimension,
            int index)
```
    Description copied from interface: INDArray
    
    Returns a slice view of this array along the specified dimension
    
    Specified by:
    
    slice in interface INDArray
    
    Returns:
  - sliceCount
```
public int sliceCount()
```
    Description copied from interface: INDArray
    
    returns the number of major slices in this array.
    
    Specified by:
    
    sliceCount in interface INDArray
    
    Returns:
  - getSlices
```
public List<Double> getSlices()
```
    Description copied from interface: INDArray
    
    Returns a list of all major slices of this array.
    
    Specified by:
    
    getSlices in interface INDArray
    
    Specified by:
    
    getSlices in class AbstractArray<Double>
    
    Returns:
  - getShape
```
public int[] getShape()
```
    Description copied from interface: INDArray
    
    Returns the shape of the array as an array of ints.
    
    Specified by:
    
    getShape in interface INDArray
    
    Returns:
  - getShape
```
public int getShape(int dim)
```
    Description copied from interface: INDArray
    
    Returns the dimension size for a specific dimension in the array's shape
    
    Specified by:
    
    getShape in interface INDArray
    
    Overrides:
    
    getShape in class AbstractArray<Double>
    
    Returns:
  - getLongShape
```
public long[] getLongShape()
```
    Description copied from interface: INDArray
    
    Returns the shape of the array as an array of longs.
    
    Specified by:
    
    getLongShape in interface INDArray
    
    Returns:
  - elementCount
```
public final long elementCount()
```
    Description copied from interface: INDArray
    
    Returns the total number of elements in this array. Equivalent to the product all dimension sizes.
    
    Specified by:
    
    elementCount in interface INDArray
    
    Returns:
  - 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 AbstractArray<Double>
    
    Returns:
  - subVector
```
public AVector subVector(int offset,
                int length)
```
    Obtains a sub-vector that refers to this vector. Changes to the sub-vector will be reflected in this vector
  - join
```
public AVector join(AVector second)
```
    Returns a new vector that refers to this vector joined to a second vector
    
    Parameters:
    second -
    
    Returns:
  - compareTo
```
public int compareTo(AVector a)
```
    Specified by:
    
    compareTo in interface Comparable<AVector>
  - equals
```
public boolean equals(Object o)
```
    Test for equality on vectors. Returns true iff all values in the vector are identical
    
    Overrides:
    
    equals in class AbstractArray<Double>
  - equals
```
public boolean equals(AVector v)
```
  - equals
```
public boolean equals(INDArray v)
```
    Description copied from interface: INDArray
    
    Returns true if the two arrays are exactly equal in value and shape
    
    Specified by:
    
    equals in interface INDArray
    
    Overrides:
    
    equals in class AbstractArray<Double>
    
    Returns:
  - toList
```
public List<Double> toList()
```
  - epsilonEquals
```
public boolean epsilonEquals(INDArray a,
                    double tolerance)
```
    Description copied from interface: INDArray
    
    Tests is this array is approximately equal to another array, up to a given tolerance (epsilon) The arrays must have the same shape
    
    Specified by:
    
    epsilonEquals in interface INDArray
    
    Overrides:
    
    epsilonEquals in class AbstractArray<Double>
    
    Returns:
  - epsilonEquals
```
public boolean epsilonEquals(INDArray a)
```
    Description copied from interface: INDArray
    
    Tests is this array is approximately equal to another array. The arrays must have the same shape
    
    Specified by:
    
    epsilonEquals in interface INDArray
    
    Overrides:
    
    epsilonEquals in class AbstractArray<Double>
    
    Returns:
  - epsilonEquals
```
public boolean epsilonEquals(AVector v)
```
  - epsilonEquals
```
public boolean epsilonEquals(AVector v,
                    double tolerance)
```
  - hashCode
```
public int hashCode()
```
    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 AbstractArray<Double>
  - copyTo
```
public void copyTo(double[] arr)
```
    Description copied from interface: INDArray
    
    Copies all the elements of this INDArray to the specified double array
    
    Specified by:
    
    copyTo in interface INDArray
    
    Overrides:
    
    copyTo in class AbstractArray<Double>
  - copyTo
```
public void copyTo(double[] data,
          int offset)
```
    Copies a the contents of a vector to a double array at the specified offset
  - copyTo
```
public void copyTo(int offset,
          double[] dest,
          int destOffset,
          int length)
```
  - toDoubleArray
```
public double[] toDoubleArray()
```
    Description copied from interface: INDArray
    
    Copies the elements of this INDArray to a new double array
    
    Specified by:
    
    toDoubleArray in interface INDArray
    
    Overrides:
    
    toDoubleArray in class AbstractArray<Double>
  - asDoubleArray
```
public double[] asDoubleArray()
```
    Description copied from interface: INDArray
    
    Returns the underlying double array representing the packed elements of this array Returns nil if there is no such underlying array
    
    Specified by:
    
    asDoubleArray in interface INDArray
    
    Overrides:
    
    asDoubleArray in class AbstractArray<Double>
  - toDoubleBuffer
```
public void toDoubleBuffer(DoubleBuffer dest)
```
    Description copied from interface: INDArray
    
    Copies the elements of this INDArray to the specified double buffer
    
    Specified by:
    
    toDoubleBuffer in interface INDArray
    
    Overrides:
    
    toDoubleBuffer in class AbstractArray<Double>
  - copyTo
```
public void copyTo(AVector dest,
          int destOffset)
```
    Copies a the contents of a vector to a vector at the specified offset
  - copyTo
```
public void copyTo(AArrayVector dest,
          int destOffset)
```
    Copies a the contents of a vector to a vector at the specified offset
  - copyTo
```
public void copyTo(int offset,
          AVector dest,
          int destOffset,
          int length)
```
    Copies a subset of this vector to a vector at the specified offset
  - fill
```
public void fill(double value)
```
    Fills the entire vector with a given value
    
    Specified by:
    
    fill in interface INDArray
    
    Overrides:
    
    fill in class AbstractArray<Double>
    
    Parameters:
    value -
  - fillRange
```
public void fillRange(int offset,
             int length,
             double value)
```
  - clamp
```
public void clamp(double min,
         double max)
```
    Clamps all values in the vector to a given range
    
    Specified by:
    
    clamp in interface INDArray
    
    Overrides:
    
    clamp in class AbstractArray<Double>
    
    Parameters:
    value -
  - clampMax
```
public void clampMax(double max)
```
  - clampMin
```
public void clampMin(double min)
```
  - multiply
```
public void multiply(double factor)
```
    Multiplies the vector by a constant factor
    
    Specified by:
    
    multiply in interface INDArray
    
    Parameters:
    factor - Factor by which to multiply each component of the vector
  - multiply
```
public void multiply(INDArray a)
```
    Description copied from interface: INDArray
    
    Multiplies all elements by the equivalent elements in a second array
    
    Specified by:
    
    multiply in interface INDArray
    
    Overrides:
    
    multiply in class AbstractArray<Double>
  - multiply
```
public void multiply(AVector v)
```
  - multiply
```
public void multiply(double[] data,
            int offset)
```
  - multiplyTo
```
public void multiplyTo(double[] data,
              int offset)
```
  - divide
```
public void divide(double factor)
```
    Description copied from interface: INDArray
    
    Divides all elements by a given factor
    
    Specified by:
    
    divide in interface INDArray
    
    Overrides:
    
    divide in class AbstractArray<Double>
  - divide
```
public void divide(INDArray a)
```
    Description copied from interface: INDArray
    
    Divides all elements by the equivalent elements in a second array
    
    Specified by:
    
    divide in interface INDArray
    
    Overrides:
    
    divide in class AbstractArray<Double>
  - divide
```
public void divide(AVector v)
```
  - divide
```
public void divide(double[] data,
          int offset)
```
  - divideTo
```
public void divideTo(double[] data,
            int offset)
```
  - abs
```
public void abs()
```
    Sets each component of the vector to its absolute value
    
    Specified by:
    
    abs in interface INDArray
    
    Overrides:
    
    abs in class AbstractArray<Double>
  - log
```
public void log()
```
    Description copied from interface: INDArray
    
    Computes the natural logarithm (in-place) for all array elements
    
    Specified by:
    
    log in interface INDArray
    
    Overrides:
    
    log in class AbstractArray<Double>
  - signum
```
public void signum()
```
    Sets each component of the vector to its sign value (-1, 0 or 1)
    
    Specified by:
    
    signum in interface INDArray
    
    Overrides:
    
    signum in class AbstractArray<Double>
  - square
```
public void square()
```
    Squares all elements of the vector
    
    Specified by:
    
    square in interface INDArray
    
    Overrides:
    
    square in class AbstractArray<Double>
  - tanh
```
public void tanh()
```
  - logistic
```
public void logistic()
```
  - scale
```
public final void scale(AVector v)
```
    Scales the vector by another vector of the same size
    
    Parameters:
    v -
  - scaleToMagnitude
```
public double scaleToMagnitude(double targetMagnitude)
```
    Scales the vector up to a specific target magnitude
    
    Returns:
    the old magnitude of the vector
  - scaleAdd
```
public void scaleAdd(double factor,
            AVector v)
```
  - interpolate
```
public void interpolate(AVector v,
               double alpha)
```
  - interpolate
```
public void interpolate(AVector a,
               AVector b,
               double alpha)
```
  - magnitudeSquared
```
public double magnitudeSquared()
```
  - getTranspose
```
public AVector getTranspose()
```
    Description copied from interface: INDArray
    
    Returns the transpose of this array. A transpose of an array is equivalent to reversing the order of dimensions
    
    Specified by:
    
    getTranspose in interface INDArray
    
    Overrides:
    
    getTranspose in class AbstractArray<Double>
    
    Returns:
  - getTransposeCopy
```
public Vector getTransposeCopy()
```
    Description copied from interface: INDArray
    
    Returns a transposed copy of the array.
    
    Specified by:
    
    getTransposeCopy in interface INDArray
    
    Overrides:
    
    getTransposeCopy in class AbstractArray<Double>
    
    Returns:
  - getTransposeView
```
public final AVector getTransposeView()
```
    Description copied from interface: INDArray
    
    Returns a transposed view of the array. May throw UnsupportedOperationException if the array does not support this capability
    
    Specified by:
    
    getTransposeView in interface INDArray
    
    Overrides:
    
    getTransposeView in class AbstractArray<Double>
    
    Returns:
  - outerProduct
```
public AMatrix outerProduct(AVector a)
```
  - outerProduct
```
public INDArray outerProduct(INDArray a)
```
    Description copied from interface: INDArray
    
    Calculates the outer product of this array with another array.
    
    Specified by:
    
    outerProduct in interface INDArray
    
    Overrides:
    
    outerProduct in class AbstractArray<Double>
    
    Returns:
  - innerProduct
```
public Scalar innerProduct(AVector v)
```
  - innerProduct
```
public Scalar innerProduct(Vector v)
```
  - innerProduct
```
public AVector innerProduct(AMatrix m)
```
  - innerProduct
```
public AVector innerProduct(AScalar s)
```
  - innerProduct
```
public INDArray innerProduct(INDArray a)
```
    Description copied from interface: INDArray
    
    Calculates the inner product of this array with another array.
    
    Specified by:
    
    innerProduct in interface INDArray
    
    Overrides:
    
    innerProduct in class AbstractArray<Double>
    
    Returns:
  - dotProduct
```
public double dotProduct(AVector v)
```
  - dotProduct
```
public double dotProduct(Vector v)
```
  - dotProduct
```
public double dotProduct(AVector v,
                Index ix)
```
  - dotProduct
```
public double dotProduct(double[] data,
                int offset)
```
    Fast dot product with a double[] array.
    
    Parameters:
    data -
    offset -
    
    Returns:
  - crossProduct
```
public void crossProduct(AVector a)
```
  - magnitude
```
public double magnitude()
```
    Returns the magnitude (Euclidean length) of the vector
    
    Returns:
  - distanceSquared
```
public double distanceSquared(AVector v)
```
  - distance
```
public double distance(AVector v)
```
  - distanceL1
```
public double distanceL1(AVector v)
```
  - distanceLinf
```
public double distanceLinf(AVector v)
```
  - maxAbsElement
```
public double maxAbsElement()
```
    Returns the maximum absolute element of a vector
    
    Returns:
  - normaliseMaxAbsElement
```
public double normaliseMaxAbsElement()
```
    Normalises so that the maximum absolute element is 1.0 Returns the previous maximum absolute element.
  - elementSum
```
public double elementSum()
```
    Returns the sum of all elements in a vector
    
    Specified by:
    
    elementSum in interface INDArray
    
    Overrides:
    
    elementSum in class AbstractArray<Double>
    
    Returns:
  - elementSquaredSum
```
public final double elementSquaredSum()
```
    Description copied from interface: INDArray
    
    Returns the total sum of elements in this array.
    
    Specified by:
    
    elementSquaredSum in interface INDArray
    
    Overrides:
    
    elementSquaredSum in class AbstractArray<Double>
    
    Returns:
  - angle
```
public double angle(AVector v)
```
    Returns the Euclidean angle between this vector and another vector
    
    Returns:
    angle in radians
  - normalise
```
public double normalise()
```
    Normalises this vector to a magnitude of 1.0 Has no effect on a zero-length vector (i.e. it will remain zero)
    
    Returns:
  - negate
```
public void negate()
```
    Description copied from interface: INDArray
    
    Negates all elements in the array
    
    Specified by:
    
    negate in interface INDArray
    
    Overrides:
    
    negate in class AbstractArray<Double>
  - pow
```
public void pow(double exponent)
```
    Description copied from interface: INDArray
    
    Raises all elements of the array to a specified power
    
    Specified by:
    
    pow in interface INDArray
    
    Overrides:
    
    pow in class AbstractArray<Double>
  - set
```
public void set(AVector src)
```
    Sets the vector to equal the value of another vector
  - set
```
public final void set(double a)
```
    Description copied from interface: INDArray
    
    Sets all elements of an array to a specific double value
    
    Specified by:
    
    set in interface INDArray
    
    Overrides:
    
    set in class AbstractArray<Double>
  - set
```
@Deprecated
public void set(double[] data)
```
    Deprecated.
  - setElements
```
public void setElements(double[] data)
```
    Description copied from interface: INDArray
    
    Sets all elements in an array using the given double values
    
    Specified by:
    
    setElements in interface INDArray
    
    Overrides:
    
    setElements in class AbstractArray<Double>
  - set
```
public void set(INDArray a)
```
    Description copied from interface: INDArray
    
    Sets this array to the element values contained in another array
    
    Specified by:
    
    set in interface INDArray
    
    Overrides:
    
    set in class AbstractArray<Double>
  - setElements
```
public void setElements(double[] values,
               int offset,
               int length)
```
    Description copied from interface: INDArray
    
    Sets all elements in an array using the given double values
    
    Specified by:
    
    setElements in interface INDArray
  - 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
    
    Specified by:
    
    getElements in interface INDArray
    
    Overrides:
    
    getElements in class AbstractArray<Double>
  - set
```
public void set(AVector src,
       int srcOffset)
```
    Set the vector equal to an offset into another vector
    
    Parameters:
    src -
    srcOffset -
  - setValues
```
public void setValues(double... values)
```
  - zeroCount
```
public long zeroCount()
```
  - clone
```
public AVector clone()
```
    Clones the vector, creating a new copy of all data. The clone is: - not guaranteed to be of the same type. - guaranteed to be fully mutable - guaranteed not to contain a reference (i.e. is a full deep copy)
    
    Specified by:
    
    clone in interface INDArray
    
    Overrides:
    
    clone in class AbstractArray<Double>
    
    Returns:
  - asVector
```
public final AVector asVector()
```
    Description copied from interface: INDArray
    
    Constructs a view of the array as a single vector in row-major order.
    
    Specified by:
    
    asVector in interface INDArray
    
    Returns:
  - reshape
```
public INDArray reshape(int... dimensions)
```
    Description copied from interface: INDArray
    
    Returns a new array by rearranging the elements of this array into the desired shape Truncates or zero-pads the elements as required to fill the new shape
    
    Specified by:
    
    reshape in interface INDArray
    
    Overrides:
    
    reshape in class AbstractArray<Double>
    
    Returns:
  - isView
```
public boolean isView()
```
    Returns true if this vector is of a view type that references other vectors / data.
    
    Specified by:
    
    isView in interface INDArray
    
    Returns:
  - isMutable
```
public boolean isMutable()
```
    Returns true if this vector is mutable.
    
    Specified by:
    
    isMutable in interface INDArray
    
    Returns:
  - isElementConstrained
```
public boolean isElementConstrained()
```
    Description copied from interface: INDArray
    
    Returns true if this array has some constraints on element values
    
    Specified by:
    
    isElementConstrained in interface INDArray
  - isFullyMutable
```
public boolean isFullyMutable()
```
    Returns true if this vector is fully mutable, i.e. can contain any unconstrained double values
    
    Specified by:
    
    isFullyMutable in interface INDArray
    
    Returns:
  - add
```
public void add(AVector v)
```
    Adds another vector to this one
    
    Parameters:
    v -
  - add
```
public void add(INDArray a)
```
    Description copied from interface: INDArray
    
    Adds all the elements of another array to this array, in an elementwise order.
    
    Specified by:
    
    add in interface INDArray
    
    Overrides:
    
    add in class AbstractArray<Double>
  - sub
```
public void sub(INDArray a)
```
    Description copied from interface: INDArray
    
    Subtracts all the elements of another array from this array, in an elementwise order.
    
    Specified by:
    
    sub in interface INDArray
    
    Overrides:
    
    sub in class AbstractArray<Double>
  - add
```
public void add(AVector src,
       int srcOffset)
```
    Adds part another vector to this one, starting at the specified offset in the source vector
    
    Parameters:
    src -
  - add
```
public void add(int offset,
       AVector a)
```
    Adds another vector into this one, at the specified offset
    
    Parameters:
    offset -
    a -
  - add
```
public void add(int offset,
       AVector a,
       int aOffset,
       int length)
```
    Adds another vector into this one, at the specified offset
    
    Parameters:
    offset -
    a -
  - addProduct
```
public void addProduct(AVector a,
              AVector b)
```
  - addProduct
```
public void addProduct(AVector a,
              AVector b,
              double factor)
```
  - addMultiple
```
public void addMultiple(AVector src,
               double factor)
```
    Adds a scaled multiple of another vector to this one
    
    Parameters:
    src -
  - addMultiple
```
public void addMultiple(AVector src,
               int srcOffset,
               double factor)
```
  - addMultiple
```
public void addMultiple(int offset,
               AVector src,
               int srcOffset,
               int length,
               double factor)
```
  - addMultiple
```
public void addMultiple(int offset,
               AVector v,
               double factor)
```
  - addWeighted
```
public void addWeighted(AVector v,
               double factor)
```
    Updates a weighted average of this vector with another vector
    
    Parameters:
    v -
  - sub
```
public void sub(AVector v)
```
    Subtracts a vector from this vector
    
    Parameters:
    v -
  - sub
```
public void sub(double d)
```
    Description copied from interface: INDArray
    
    Subtracts a double value from all elements in this array
    
    Specified by:
    
    sub in interface INDArray
    
    Overrides:
    
    sub in class AbstractArray<Double>
  - isZero
```
public boolean isZero()
```
    Returns true if this vector is a zero vector (all components zero)
    
    Specified by:
    
    isZero in interface INDArray
    
    Overrides:
    
    isZero in class AbstractArray<Double>
    
    Returns:
  - isUnitLengthVector
```
public boolean isUnitLengthVector()
```
    Returns true if the vector has unit length
    
    Returns:
  - isSameShape
```
public boolean isSameShape(INDArray a)
```
    Description copied from interface: INDArray
    
    Returns true if this array is the same shape as another array
    
    Specified by:
    
    isSameShape in interface INDArray
    
    Overrides:
    
    isSameShape in class AbstractArray<Double>
  - isSameShape
```
public boolean isSameShape(AVector a)
```
  - projectToPlane
```
public void projectToPlane(AVector normal,
                  double distance)
```
  - subMultiple
```
public void subMultiple(AVector v,
               double factor)
```
    Subtracts a scaled multiple of another vector from this vector
    
    Parameters:
    v -
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class AbstractArray<Double>
  - toVector
```
public Vector toVector()
```
    Description copied from interface: INDArray
    
    Converts the array into a flattened vector
    
    Specified by:
    
    toVector in interface INDArray
    
    Overrides:
    
    toVector in class AbstractArray<Double>
    
    Returns:
  - toNormal
```
public AVector toNormal()
```
    Creates a new mutable vector representing the normalised value of this vector
    
    Returns:
  - asElementList
```
public List<Double> asElementList()
```
    Description copied from interface: INDArray
    
    Returns a list containing all elements of this array
    
    Specified by:
    
    asElementList in interface INDArray
    
    Overrides:
    
    asElementList in class AbstractArray<Double>
    
    Returns:
  - iterator
```
public Iterator<Double> iterator()
```
    Specified by:
    
    iterator in interface Iterable<Double>
    
    Overrides:
    
    iterator in class AbstractArray<Double>
  - elementIterator
```
public Iterator<Double> elementIterator()
```
    Description copied from interface: INDArray
    
    Returns an iterator over all elements in this array.
    
    Specified by:
    
    elementIterator in interface INDArray
    
    Overrides:
    
    elementIterator in class AbstractArray<Double>
    
    Returns:
  - set
```
public void set(IVector vector)
```
  - addMultiple
```
public void addMultiple(Vector source,
               Index sourceToDest,
               double factor)
```
    Adds source vector to this vector at the specified indexes which should map from source->this
    
    Parameters:
    source -
    sourceToDest -
    factor -
  - addMultiple
```
public void addMultiple(AVector source,
               Index sourceToDest,
               double factor)
```
    Adds source vector to this vector at the specified indexes which should map from source->this
    
    Parameters:
    source -
    sourceToDest -
    factor -
  - addMultiple
```
public void addMultiple(Index destToSource,
               Vector source,
               double factor)
```
    Adds to this vector at taking values from source at the specified indexes which should map from this->source
    
    Parameters:
    source -
    destToSource -
    factor -
  - addMultiple
```
public void addMultiple(Index destToSource,
               AVector source,
               double factor)
```
    Adds to this vector at taking values from source at the specified indexes which should map from this->source
    
    Parameters:
    source -
    destToSource -
    factor -
  - set
```
public void set(AVector v,
       Index indexes)
```
    sets the vector using values indexed from another vector
  - addToArray
```
public void addToArray(double[] array,
              int offset)
```
  - addToArray
```
public void addToArray(int offset,
              double[] array,
              int arrayOffset,
              int length)
```
  - addMultipleToArray
```
public void addMultipleToArray(double factor,
                      int offset,
                      double[] array,
                      int arrayOffset,
                      int length)
```
  - addProductToArray
```
public void addProductToArray(double factor,
                     int offset,
                     AVector other,
                     int otherOffset,
                     double[] array,
                     int arrayOffset,
                     int length)
```
  - addProductToArray
```
public void addProductToArray(double factor,
                     int offset,
                     AArrayVector other,
                     int otherOffset,
                     double[] array,
                     int arrayOffset,
                     int length)
```
  - addProduct
```
public void addProduct(AVector a,
              int aOffset,
              AVector b,
              int bOffset,
              double factor)
```
  - applyOp
```
public void applyOp(IOp op)
```
    Description copied from interface: INDArray
    
    Applies a unary operator to all elements of the array (in-place)
    
    Specified by:
    
    applyOp in interface INDArray
  - applyOp
```
public void applyOp(Op op)
```
    Description copied from interface: INDArray
    
    Applies a unary operator to all elements of the array (in-place)
    
    Specified by:
    
    applyOp in interface INDArray
  - addAt
```
public void addAt(int i,
         double v)
```
    Adds a value to a specific element of the vector This function does not perform bounds checking
    
    Parameters:
    i -
    v -
  - scaleAdd
```
public void scaleAdd(double factor,
            double constant)
```
    Description copied from interface: INDArray
    
    Scales all elements of the array by a given double value and adds a constant vale
    
    Specified by:
    
    scaleAdd in interface INDArray
    
    Overrides:
    
    scaleAdd in class AbstractArray<Double>
  - add
```
public void add(double constant)
```
    Description copied from interface: INDArray
    
    Adds a double value to all elements in this array
    
    Specified by:
    
    add in interface INDArray
    
    Overrides:
    
    add in class AbstractArray<Double>
  - exactClone
```
public abstract AVector exactClone()
```
    Returns an exact clone of this vector, i.e. of the same type
    
    Specified by:
    
    exactClone in interface INDArray
    
    Returns:
  - equalsArray
```
public boolean equalsArray(double[] data)
```
  - setRange
```
public void setRange(int offset,
            double[] data,
            int dataOffset,
            int length)
```
    Set a subrange of this vector from a double array
  - broadcast
```
public INDArray broadcast(int... targetShape)
```
    Description copied from interface: INDArray
    
    Returns a view of this array broadcasted up to a larger shape
    
    Specified by:
    
    broadcast in interface INDArray
    
    Overrides:
    
    broadcast in class AbstractArray<Double>
    
    Returns:
  - broadcastLike
```
public INDArray broadcastLike(INDArray target)
```
    Description copied from interface: INDArray
    
    Broadcasts to match the shape of the target
    
    Specified by:
    
    broadcastLike in interface INDArray
    
    Overrides:
    
    broadcastLike in class AbstractArray<Double>
    
    Returns:
  - broadcastLike
```
public INDArray broadcastLike(AMatrix target)
```
  - validate
```
public void validate()
```
    Description copied from interface: INDArray
    
    Validates the internal data structure of the INDArray. Throws an exception on failure. Failure indicates a serious bug and/or data corruption.
    
    Specified by:
    
    validate in interface INDArray
    
    Overrides:
    
    validate in class AbstractArray<Double>

Class AVector

Constructor Summary

Method Summary

Methods inherited from class mikera.arrayz.impl.AbstractArray

Methods inherited from class java.lang.Object

Methods inherited from interface mikera.arrayz.INDArray

Constructor Detail

AVector

Method Detail

length

get

set

set

unsafeSet

unsafeGet

dimensionality

get

get

slice

slice

sliceCount

getSlices

getShape

getShape

getLongShape

elementCount

nonZeroCount

subVector

join

compareTo

equals

equals

equals

toList

epsilonEquals

epsilonEquals

epsilonEquals

epsilonEquals

hashCode

copyTo

copyTo

copyTo

toDoubleArray

asDoubleArray

toDoubleBuffer

copyTo

copyTo

copyTo

fill

fillRange

clamp

clampMax

clampMin

multiply

multiply

multiply

multiply

multiplyTo

divide

divide

divide

divide

divideTo

abs

log

signum

square

tanh

logistic

scale

scaleToMagnitude

scaleAdd

interpolate

interpolate

magnitudeSquared

getTranspose

getTransposeCopy

getTransposeView

outerProduct

outerProduct