AVector (vectorz 0.13.0 API)

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

All Implemented Interfaces:

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

Direct Known Subclasses:

ADerivedVector, APrimitiveVector, ArrayVector, ASparseVector, BitVector, ComputedVector, IndexedArrayVector, IndexedSubVector, JoinedArrayVector, JoinedVector, MatrixSubVector, RepeatedElementVector, ScalarVector, SingleElementVector, StridedArrayVector, WrappedSubVector
```
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)`
`void`	`add(INDArray a)`
`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)`
`void`	`addMultiple(AVector v, 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 v, int vOffset, 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 v, int vOffset, 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, ArrayVector 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(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)
`List<Double>`	`asElementList()`
`AVector`	`asVector()` Creates a view of the array as a single vector in row-major order.
`INDArray`	`broadcast(int... targetShape)`
`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(ArrayVector 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[] 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)`
`int`	`countZeros()`
`void`	`crossProduct(AVector a)`
`int`	`dimensionality()`
`double`	`distance(AVector v)`
`double`	`distanceL1(AVector v)`
`double`	`distanceLinf(AVector v)`
`double`	`distanceSquared(AVector v)`
`void`	`divide(AVector v)`
`void`	`divide(double factor)`
`void`	`divide(double[] data, int offset)`
`void`	`divideTo(double[] data, int offset)`
`double`	`dotProduct(AVector v)`
`double`	`dotProduct(AVector v, Index ix)`
`long`	`elementCount()`
`double`	`elementSum()` Returns the sum of all elements in a vector
`boolean`	`epsilonEquals(AVector v)`
`boolean`	`epsilonEquals(AVector v, double tolerance)`
`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(int... indexes)`
`abstract double`	`get(int i)`
`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.
`List<Double>`	`getSlices()`
`int`	`hashCode()`
`AVector`	`innerProduct(AMatrix m)`
`AScalar`	`innerProduct(AVector v)`
`INDArray`	`innerProduct(INDArray a)`
`void`	`interpolate(AVector a, AVector b, double alpha)`
`void`	`interpolate(AVector v, double alpha)`
`boolean`	`isElementConstrained()` Returns true if the IND has additional 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`	`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`	`isZeroVector()` 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()`
`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`	`multiplyTo(double[] data, int offset)`
`void`	`negate()`
`double`	`normalise()`
`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)`
`void`	`projectToPlane(AVector normal, double distance)`
`INDArray`	`reshape(int... dimensions)`
`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)`
`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)`
`void`	`set(INDArray a)`
`void`	`set(int[] indexes, double value)`
`abstract void`	`set(int i, double value)`
`void`	`set(int offset, double[] data, int dataOffset, int length)` Set part of this vector from a double array
`void`	`set(IVector vector)`
`void`	`setElements(double[] values, int offset, int length)`
`void`	`setValues(double... values)`
`void`	`signum()` Sets each component of the vector to its sign value (-1, 0 or 1)
`AScalar`	`slice(int position)`
`int`	`sliceCount()`
`void`	`square()`
`void`	`sub(AVector v)` Subtracts a vector from this vector
`void`	`sub(double d)`
`void`	`sub(INDArray a)`
`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.
`double[]`	`toArray()`
`List<Double>`	`toList()`
`String`	`toString()`

Methods inherited from class mikera.arrayz.AbstractArray
get, get, scale, set, set, setElements

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

Methods inherited from interface mikera.arrayz.INDArray
get, get, scale, set, set, setElements

- 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)
```
    Specified by:
    
    get in interface INDArray
    
    Specified by:
    
    get in interface IVector
    
    Overrides:
    
    get in class AbstractArray<Double>
  - 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
  - dimensionality
```
public int dimensionality()
```
    Specified by:
    
    dimensionality in interface INDArray
  - get
```
public double get(int... indexes)
```
    Specified by:
    
    get in interface INDArray
  - slice
```
public AScalar slice(int position)
```
    Specified by:
    
    slice in interface INDArray
  - sliceCount
```
public int sliceCount()
```
    Specified by:
    
    sliceCount in interface INDArray
  - getSlices
```
public List<Double> getSlices()
```
    Specified by:
    
    getSlices in interface INDArray
  - 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:
  - 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 long elementCount()
```
    Specified by:
    
    elementCount in interface INDArray
  - 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
    
    Returns:
  - toList
```
public List<Double> toList()
```
  - epsilonEquals
```
public boolean epsilonEquals(AVector v)
```
  - epsilonEquals
```
public boolean epsilonEquals(AVector v,
                    double tolerance)
```
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode 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)
```
  - toArray
```
public double[] toArray()
```
  - 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(ArrayVector 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
    
    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
    
    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(AVector v)
```
  - multiply
```
public void multiply(double[] data,
            int offset)
```
  - multiplyTo
```
public void multiplyTo(double[] data,
              int offset)
```
  - divide
```
public void divide(double factor)
```
  - 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
  - signum
```
public void signum()
```
    Sets each component of the vector to its sign value (-1, 0 or 1)
  - square
```
public void square()
```
    Overrides:
    
    square in class AbstractArray<Double>
  - 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()
```
  - outerProduct
```
public AMatrix outerProduct(AVector a)
```
  - outerProduct
```
public INDArray outerProduct(INDArray a)
```
    Specified by:
    
    outerProduct in interface INDArray
    
    Overrides:
    
    outerProduct in class AbstractArray<Double>
  - innerProduct
```
public AScalar innerProduct(AVector v)
```
  - innerProduct
```
public AVector innerProduct(AMatrix m)
```
  - innerProduct
```
public INDArray innerProduct(INDArray a)
```
    Specified by:
    
    innerProduct in interface INDArray
    
    Overrides:
    
    innerProduct in class AbstractArray<Double>
  - dotProduct
```
public double dotProduct(AVector v)
```
  - dotProduct
```
public double dotProduct(AVector v,
                Index ix)
```
  - 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
    
    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()
```
  - negate
```
public void negate()
```
  - set
```
public void set(AVector src)
```
    Sets the vector to equal the value of another vector
  - set
```
public void set(double a)
```
    Specified by:
    
    set in interface INDArray
    
    Overrides:
    
    set in class AbstractArray<Double>
  - set
```
public void set(INDArray a)
```
    Specified by:
    
    set in interface INDArray
    
    Overrides:
    
    set in class AbstractArray<Double>
  - setElements
```
public void setElements(double[] values,
               int offset,
               int length)
```
    Specified by:
    
    setElements in interface INDArray
  - 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)
```
  - countZeros
```
public int countZeros()
```
  - 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 AVector asVector()
```
    Description copied from interface: INDArray
    
    Creates 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)
```
    Specified by:
    
    reshape in interface INDArray
    
    Overrides:
    
    reshape in class AbstractArray<Double>
  - 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 the IND has additional 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)
```
    Specified by:
    
    add in interface INDArray
    
    Overrides:
    
    add in class AbstractArray<Double>
  - sub
```
public void sub(INDArray a)
```
    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 v,
               double factor)
```
    Adds a scaled multiple of another vector to this one
    
    Parameters:
    v -
  - addMultiple
```
public void addMultiple(AVector v,
               int vOffset,
               double factor)
```
  - addMultiple
```
public void addMultiple(int offset,
               AVector v,
               int vOffset,
               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)
```
  - isZeroVector
```
public boolean isZeroVector()
```
    Returns true if this vector is a zero vector (all components zero)
    
    Returns:
  - isUnitLengthVector
```
public boolean isUnitLengthVector()
```
    Returns true if the vector has unit length
    
    Returns:
  - 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>
  - asElementList
```
public List<Double> asElementList()
```
  - iterator
```
public Iterator<Double> iterator()
```
    Specified by:
    
    iterator in interface Iterable<Double>
    
    Overrides:
    
    iterator in class AbstractArray<Double>
  - 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(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,
                     ArrayVector 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)
```
  - scaleAdd
```
public void scaleAdd(double factor,
            double constant)
```
  - add
```
public void add(double constant)
```
  - 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)
```
  - set
```
public void set(int offset,
       double[] data,
       int dataOffset,
       int length)
```
    Set part of this vector from a double array
  - broadcast
```
public INDArray broadcast(int... targetShape)
```
    Specified by:
    
    broadcast in interface INDArray
    
    Overrides:
    
    broadcast in class AbstractArray<Double>

Class AVector

Constructor Summary

Method Summary

Methods inherited from class mikera.arrayz.AbstractArray

Methods inherited from class java.lang.Object

Methods inherited from interface mikera.arrayz.INDArray

Constructor Detail

AVector

Method Detail

length

get

set

set

dimensionality

get

slice

sliceCount

getSlices

getShape

getLongShape

elementCount

subVector

join

compareTo

equals

equals

equals

toList

epsilonEquals

epsilonEquals

hashCode

copyTo

copyTo

toArray

copyTo

copyTo

copyTo

fill

fillRange

clamp

clampMax

clampMin

multiply

multiply

multiply

multiplyTo

divide

divide

divide

divideTo

abs

signum

square

scale

scaleToMagnitude

scaleAdd

interpolate

interpolate

magnitudeSquared

outerProduct

outerProduct

innerProduct

innerProduct

innerProduct

dotProduct

dotProduct

crossProduct

magnitude

distanceSquared

distance

distanceL1

distanceLinf

maxAbsElement

normaliseMaxAbsElement

elementSum

angle

normalise

negate

set

set