Vec (Java Statistical Analysis Tool 0.0.8 API)

java.lang.Object
- jsat.linear.Vec

All Implemented Interfaces:

Serializable, Cloneable, Iterable<IndexValue>

Direct Known Subclasses:

ConcatenatedVec, ConstantVector, DenseVector, Poly2Vec, RandomVector, ScaledVector, ShiftedVec, SparseVector, SubVector, VecPaired, VecWithNorm
```
public abstract class Vec
extends Object
implements Cloneable, Iterable<IndexValue>, Serializable
```
Vec is a object representing the math concept of a vector. A vector could be either sparse or dense, where sparse vectors have a high number of zero values that are not explicitly stored.

This abstract class provides a large number of pre-implemented methods. Some of which are implemented only for a dense vector, or may not be completely efficient for the underlying implementation. Methods that should be considered for overloading by an implementation will be indicated in the documentation.

Author:

Edward Raff

See Also:

Serialized Form

Constructor Summary

Constructors
Constructor and Description

Vec()

Constructors
Constructor and Description
`Vec()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`Vec`	`add(double c)` Returns a new vector that is the result of `this + c`
`Vec`	`add(Vec b)` Returns a new vector that is the result of `this + b`
`void`	`applyFunction(Function f)` Applies the given function to each and every value in the vector.
`void`	`applyIndexFunction(IndexFunction f)` Applies the given function to each and every value in the vector.
`double[]`	`arrayCopy()` Creates a new array that contains all the values of this vector in the appropriate indices
`boolean`	`canBeMutated()` Indicates whether or not this vector can be mutated.
`abstract Vec`	`clone()`
`void`	`copyTo(Vec destination)` Copies the values of this Vector into another vector
`void`	`copyToCol(Matrix A, int col)` Copies the values of this vector into a column of another Matrix.
`void`	`copyToRow(Matrix A, int row)` Copies the values of this vector into a row of another Matrix
`int`	`countNaNs()`
`Vec`	`divide(double c)` Returns a new vector that is the result of `this / c`
`double`	`dot(Vec v)` Computes the dot product between two vectors, which is equivalent to Σ this_i*v_i This method should be overloaded for a serious implementation.
`boolean`	`equals(Object obj)`
`boolean`	`equals(Object obj, double range)`
`abstract double`	`get(int index)` Gets the value stored at a specific index in the vector
`Iterator<IndexValue>`	`getNonZeroIterator()` Returns an iterator that will go over the non zero values in the given vector.
`Iterator<IndexValue>`	`getNonZeroIterator(int start)` Returns an iterator that will go over the non zero values starting from the specified index in the given vector.
`int`	`hashCode()` Provides a hashcode for Vectors.
`void`	`increment(int index, double val)` Increments the value stored at a specified index in the vector
`abstract boolean`	`isSparse()` Indicates whether or not this vector is optimized for sparce computation, meaning that most values in the vector are zero - and considered implicit.
`Iterator<IndexValue>`	`iterator()`
`double`	`kurtosis()` Computes the kurtosis of this vector, which is the 4th moment.
`abstract int`	`length()` Returns the length of this vector
`double`	`max()` Returns the maximum value stored in this vector
`double`	`mean()` Computes the mean value of all values stored in this vector
`double`	`median()` Returns the median value in this vector
`double`	`min()` Returns the minimum value stored in this vector
`Vec`	`multiply(double c)` Returns a new vector that is the result of `this * c`
`void`	`multiply(double c, Matrix A, Vec b)` If this is vector `a`, this this computes b = b + c `a`^T*`A`
`Vec`	`multiply(Matrix A)` Returns a new vector that is the result of the vector matrix product `this^TA`
`void`	`multiply(Matrix A, Vec b)` If this is vector `a`, this this computes b = b + `a`^T*`A`
`void`	`mutableAdd(double c)` Alters this vector such that `this` = `this` + `c` This method should be overloaded for a serious implementation.
`void`	`mutableAdd(double c, Vec b)` Alters this vector such that `this` = `this` + `c` * `b` This method should be overloaded for a serious implementation.
`void`	`mutableAdd(Vec b)` Alters this vector such that `this` = `this` + `b`
`void`	`mutableDivide(double c)` Mutates `this /= c` This method should be overloaded for a serious implementation.
`void`	`mutableMultiply(double c)` Mutates `this *= c` This method should be overloaded for a serious implementation.
`void`	`mutablePairwiseDivide(Vec b)` Mutates `this` by dividing each value by the value in `b` that has the same index This method should be overloaded for a serious implementation.
`void`	`mutablePairwiseMultiply(Vec b)` Mutates `this` by multiplying each value by the value in `b` that has the same index.
`void`	`mutableSubtract(double c)` Alters this vector such that `this` = `this` - `c`
`void`	`mutableSubtract(double c, Vec b)` Alters this vector such that `this` = `this` - `c` * `b`
`void`	`mutableSubtract(Vec b)` Alters this vector such that `this` = `this` - `b`
`int`	`nnz()` Computes the number of non zero values in this vector
`void`	`normalize()` Mutates this vector to be normalized by the L₂ norm
`Vec`	`normalized()` Returns a new vector that is the result of normalizing this vector by the L₂ norm
`Vec`	`pairwiseDivide(Vec b)` Returns a new vector that is the result of dividing each value in `this` by the value in the same index in `b`
`Vec`	`pairwiseMultiply(Vec b)` Returns a new vector that is the result of multiplying each value in `this` by its corresponding value in `b`
`double`	`pNorm(double p)` Returns the p-norm of this vector.
`double`	`pNormDist(double p, Vec y)` Returns the p-norm distance between this and another vector y.
`static Vec`	`random(int length)` Creates a dense vector full of random values in the range [0, 1]
`static Vec`	`random(int length, Random rand)` Creates a dense vector full of random values in the range [0, 1]
`abstract void`	`set(int index, double val)` Sets the value stored at a specified index in the vector
`double`	`skewness()` Computes the skewness of this vector, which is the 3rd moment.
`Vec`	`sortedCopy()` Returns a copy of this array with the values moved around so that they are in sorted order
`double`	`standardDeviation()` Computes the standard deviation of the values in this vector
`Vec`	`subtract(double c)` Returns a new vector that is the result of `this - c`
`Vec`	`subtract(Vec b)` Returns a new vector that is the result of `this - b`
`double`	`sum()` Computes the sum of the values in this vector
`String`	`toString()`
`double`	`variance()` Computes the variance of the values in this vector, which is `standardDeviation()`²
`void`	`zeroOut()` Zeroes out all values in this vector This method should be overloaded for a serious implementation.
`static Vec`	`zeros(int length)` Creates a dense vector full of zeros.

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

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

- Constructor Detail
  - Vec
```
public Vec()
```
- Method Detail
  - length
```
public abstract int length()
```
    Returns the length of this vector
    
    Returns:
    
    the length of this vector
  - countNaNs
```
public int countNaNs()
```
    Returns:
    
    the number of NaNs present in this vector
  - canBeMutated
```
public boolean canBeMutated()
```
    Indicates whether or not this vector can be mutated. If false, any method that contains "mutate" will not work.
    
    By default, this returns true
    
    Returns:
    
    true if the vector supports being altered, false other wise.
  - nnz
```
public int nnz()
```
    Computes the number of non zero values in this vector
    
    Returns:
    
    the number of non zero values stored
  - get
```
public abstract double get(int index)
```
    Gets the value stored at a specific index in the vector
    
    Parameters:
    
    index - the index to access
    
    Returns:
    
    the double value in the vector
    
    Throws:
    
    IndexOutOfBoundsException - if the index given is greater than or equal to its length()
  - set
```
public abstract void set(int index,
                         double val)
```
    Sets the value stored at a specified index in the vector
    
    Parameters:
    
    index - the index to access
    
    val - the value to store in the index
    
    Throws:
    
    IndexOutOfBoundsException - if the index given is greater than or equal to its length()
  - increment
```
public void increment(int index,
                      double val)
```
    Increments the value stored at a specified index in the vector
    
    Parameters:
    
    index - the index to access
    
    val - the value to store in the index
    
    Throws:
    
    IndexOutOfBoundsException - if the index given is greater than or equal to its length()
  - add
```
public Vec add(double c)
```
    Returns a new vector that is the result of this + c
    
    Parameters:
    
    c - the constant to add
    
    Returns:
    
    the result of adding c to this
  - add
```
public Vec add(Vec b)
```
    Returns a new vector that is the result of this + b
    
    Parameters:
    
    b - the vector to add
    
    Returns:
    
    the result of b + this
  - subtract
```
public Vec subtract(double c)
```
    Returns a new vector that is the result of this - c
    
    Parameters:
    
    c - the constant to subtract
    
    Returns:
    
    the result of this - c
  - subtract
```
public Vec subtract(Vec b)
```
    Returns a new vector that is the result of this - b
    
    Parameters:
    
    b - the vector to subtract from this
    
    Returns:
    
    the result of this - b
  - pairwiseMultiply
```
public Vec pairwiseMultiply(Vec b)
```
    Returns a new vector that is the result of multiplying each value in this by its corresponding value in b
    
    Parameters:
    
    b - the vector to pairwise multiply by
    
    Returns:
    
    the result of the pairwise multiplication of b onto the values of this
  - multiply
```
public Vec multiply(double c)
```
    Returns a new vector that is the result of this * c
    
    Parameters:
    
    c - the constant to multiply by
    
    Returns:
    
    the result of this * c
  - multiply
```
public Vec multiply(Matrix A)
```
    Returns a new vector that is the result of the vector matrix product this^TA
    
    Parameters:
    
    A - the matrix to multiply with
    
    Returns:
    
    the vector matrix product
  - multiply
```
public void multiply(Matrix A,
                     Vec b)
```
    If this is vector a, this this computes b = b + a^T*A
    
    Parameters:
    
    A - the matrix to multiple by
    
    b - the vector to mutate by adding the result to
  - multiply
```
public void multiply(double c,
                     Matrix A,
                     Vec b)
```
    If this is vector a, this this computes b = b + c a^T*A
    
    Parameters:
    
    c - the constant factor to multiply by
    
    A - the matrix to multiple by
    
    b - the vector to mutate by adding the result to
  - pairwiseDivide
```
public Vec pairwiseDivide(Vec b)
```
    Returns a new vector that is the result of dividing each value in this by the value in the same index in b
    
    Parameters:
    
    b - the vector to pairwise divide by
    
    Returns:
    
    the result of pairwise division of this by b
  - divide
```
public Vec divide(double c)
```
    Returns a new vector that is the result of this / c
    
    Parameters:
    
    c - the constant to divide by
    
    Returns:
    
    the result of this / c
  - mutableAdd
```
public void mutableAdd(double c)
```
    Alters this vector such that this = this + c
    
    This method should be overloaded for a serious implementation.
    
    Parameters:
    
    c - a scalar constant to add to each value in this vector
  - mutableAdd
```
public void mutableAdd(double c,
                       Vec b)
```
    Alters this vector such that this = this + c * b
    
    This method should be overloaded for a serious implementation.
    
    Parameters:
    
    c - a scalar constant
    
    b - the vector to add to this
  - mutableAdd
```
public void mutableAdd(Vec b)
```
    Alters this vector such that this = this + b
    
    Parameters:
    
    b - the vector to add to this
    
    Throws:
    
    ArithmeticException - if the vectors do not have the same length
  - mutableSubtract
```
public void mutableSubtract(double c)
```
    Alters this vector such that this = this - c
    
    Parameters:
    
    c - the scalar constant to subtract from all values in this vector
  - mutableSubtract
```
public void mutableSubtract(double c,
                            Vec b)
```
    Alters this vector such that this = this - c * b
    
    Parameters:
    
    c - a scalar constant
    
    b - the vector to subtract from this
    
    Throws:
    
    ArithmeticException - if the vectors do not have the same length
  - mutableSubtract
```
public void mutableSubtract(Vec b)
```
    Alters this vector such that this = this - b
    
    Parameters:
    
    b - the vector to subtract from this
    
    Throws:
    
    ArithmeticException - if the vectors are not the same length
  - mutablePairwiseMultiply
```
public void mutablePairwiseMultiply(Vec b)
```
    Mutates this by multiplying each value by the value in b that has the same index.
    
    This method should be overloaded for a serious implementation.
    
    Parameters:
    
    b - the vector to pairwise multiply by
  - mutableMultiply
```
public void mutableMultiply(double c)
```
    Mutates this *= c
    
    This method should be overloaded for a serious implementation.
    
    Parameters:
    
    c - the constant to multiply by
  - mutablePairwiseDivide
```
public void mutablePairwiseDivide(Vec b)
```
    Mutates this by dividing each value by the value in b that has the same index
    
    This method should be overloaded for a serious implementation.
    
    Parameters:
    
    b - the vector to pairwise divide by
  - mutableDivide
```
public void mutableDivide(double c)
```
    Mutates this /= c
    
    This method should be overloaded for a serious implementation.
    
    Parameters:
    
    c - the constant to divide by
  - sortedCopy
```
public Vec sortedCopy()
```
    Returns a copy of this array with the values moved around so that they are in sorted order
    
    Returns:
    
    a new array in sorted order
  - min
```
public double min()
```
    Returns the minimum value stored in this vector
    
    Returns:
    
    the minimum value in this vector
  - max
```
public double max()
```
    Returns the maximum value stored in this vector
    
    Returns:
    
    the maximum value in this vector
  - sum
```
public double sum()
```
    Computes the sum of the values in this vector
    
    Returns:
    
    the sum of this vector's values
  - mean
```
public double mean()
```
    Computes the mean value of all values stored in this vector
    
    Returns:
    
    the mean value
  - standardDeviation
```
public double standardDeviation()
```
    Computes the standard deviation of the values in this vector
    
    Returns:
    
    the standard deviation
  - variance
```
public double variance()
```
    Computes the variance of the values in this vector, which is standardDeviation()²
    
    Returns:
    
    the variance
  - median
```
public double median()
```
    Returns the median value in this vector
    
    Returns:
    
    the median
  - skewness
```
public double skewness()
```
    Computes the skewness of this vector, which is the 3rd moment.
    
    Returns:
    
    the skewness
  - kurtosis
```
public double kurtosis()
```
    Computes the kurtosis of this vector, which is the 4th moment.
    
    Returns:
    
    the kurtosis
  - isSparse
```
public abstract boolean isSparse()
```
    Indicates whether or not this vector is optimized for sparce computation, meaning that most values in the vector are zero - and considered implicit. Only non-zero values are stored.
    
    Returns:
    
    true if the vector is sparce, false otherwise.
  - copyTo
```
public void copyTo(Vec destination)
```
    Copies the values of this Vector into another vector
    
    Parameters:
    
    destination - the vector to store the values in.
    
    Throws:
    
    ArithmeticException - if the vectors are not of the same length
  - copyToRow
```
public void copyToRow(Matrix A,
                      int row)
```
    Copies the values of this vector into a row of another Matrix
    
    Parameters:
    
    A - the matrix to store the contents of this vector in
    
    row - the row of the matrix to store the values to
    
    Throws:
    
    ArithmeticException - if the columns of the matrix is not the same as the length of this vector.
  - copyToCol
```
public void copyToCol(Matrix A,
                      int col)
```
    Copies the values of this vector into a column of another Matrix.
    
    Parameters:
    
    A - the matrix to store the contents of this vector in
    
    col - the column of the matrix to store the values to
  - clone
```
public abstract Vec clone()
```
    Overrides:
    
    clone in class Object
  - normalized
```
public Vec normalized()
```
    Returns a new vector that is the result of normalizing this vector by the L₂ norm
    
    Returns:
    
    a normalized version of this vector
  - normalize
```
public void normalize()
```
    Mutates this vector to be normalized by the L₂ norm
  - applyFunction
```
public void applyFunction(Function f)
```
    Applies the given function to each and every value in the vector.
    
    This method should be overloaded for a serious implementation.
    
    Parameters:
    
    f - the single variable function to apply
  - applyIndexFunction
```
public void applyIndexFunction(IndexFunction f)
```
    Applies the given function to each and every value in the vector. The function takes 2 arguments, an arbitrary value, and then an index. The index passed to the function is the index in the array that the value came from.
    
    NOTE: Because negative values are invalid indexes. The given function should return 0.0 when given a negative index, if and only if, f(0,index) = 0 for any valid index. If f(0, index) != 0 for even one value of index, it should return any non zero value when given a negative index.
    
    IE: f(value_i, i) = x
    
    This method should be overloaded for a serious implementation.
    
    Parameters:
    
    f - the 2 dimensional index function to apply
  - pNormDist
```
public double pNormDist(double p,
                        Vec y)
```
    Returns the p-norm distance between this and another vector y.
    
    Parameters:
    
    p - the distance type. 2 is the common value
    
    y - the other vector to compare against
    
    Returns:
    
    the p-norm distance
  - pNorm
```
public double pNorm(double p)
```
    Returns the p-norm of this vector.
    
    Parameters:
    
    p - the norm type. 2 is a common value
    
    Returns:
    
    the p-norm of this vector
  - dot
```
public double dot(Vec v)
```
    Computes the dot product between two vectors, which is equivalent to
    Σ this_i*v_i
    
    This method should be overloaded for a serious implementation.
    
    Parameters:
    
    v - the other vector
    
    Returns:
    
    the dot product of this vector and another
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - equals
```
public boolean equals(Object obj)
```
    Overrides:
    
    equals in class Object
  - equals
```
public boolean equals(Object obj,
                      double range)
```
  - arrayCopy
```
public double[] arrayCopy()
```
    Creates a new array that contains all the values of this vector in the appropriate indices
    
    Returns:
    
    a new array that is a copy of this vector
  - iterator
```
public Iterator<IndexValue> iterator()
```
    Specified by:
    
    iterator in interface Iterable<IndexValue>
  - getNonZeroIterator
```
public Iterator<IndexValue> getNonZeroIterator()
```
    Returns an iterator that will go over the non zero values in the given vector. The iterator does not support the Iterator.remove() method.
    
    Returns:
    
    an iterator for the non zero index value pairs.
  - getNonZeroIterator
```
public Iterator<IndexValue> getNonZeroIterator(int start)
```
    Returns an iterator that will go over the non zero values starting from the specified index in the given vector. The iterator does not support the Iterator.remove() method.
    
    This method should be overloaded for a serious implementation.
    
    Parameters:
    
    start - the first index (inclusive) to start returning non-zero values from
    
    Returns:
    
    an iterator for the non zero index value pairs
  - zeroOut
```
public void zeroOut()
```
    Zeroes out all values in this vector
    
    This method should be overloaded for a serious implementation.
  - hashCode
```
public int hashCode()
```
    Provides a hashcode for Vectors. All vector implementations should return the same result for cases when equals(java.lang.Object) returns true. Below is the code used for this class
    
    int result = 1; for (int i = 0; i < length(); i++) { double val = get(i); if(val != 0) { long bits = Double.doubleToLongBits(val); result = 31 * result + (int)(bits ^ (bits >>> 32)); result = 31 * result + i; } } return 31* result + length();
    
    Overrides:
    
    hashCode in class Object
    
    Returns:
    
    the hash code for a vector
  - random
```
public static Vec random(int length)
```
    Creates a dense vector full of random values in the range [0, 1]
    
    Parameters:
    
    length - the length of the random vector to create
    
    Returns:
    
    a random vector of the specified length
  - random
```
public static Vec random(int length,
                         Random rand)
```
    Creates a dense vector full of random values in the range [0, 1]
    
    Parameters:
    
    length - the length of the random vector to create
    
    rand - the source of randomness
    
    Returns:
    
    a random vector of the specified length
  - zeros
```
public static Vec zeros(int length)
```
    Creates a dense vector full of zeros.
    
    Parameters:
    
    length - the length of the vector to create
    
    Returns:
    
    a vector of zeros

Class Vec

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.Iterable

Constructor Detail

Vec

Method Detail

length

countNaNs

canBeMutated

nnz

get

set

increment

add

add

subtract

subtract

pairwiseMultiply

multiply

multiply

multiply

multiply

pairwiseDivide

divide

mutableAdd

mutableAdd

mutableAdd

mutableSubtract

mutableSubtract

mutableSubtract

mutablePairwiseMultiply

mutableMultiply

mutablePairwiseDivide

mutableDivide

sortedCopy

min

max

sum

mean

standardDeviation

variance

median

skewness

kurtosis

isSparse

copyTo

copyToRow

copyToCol

clone

normalized

normalize

applyFunction

applyIndexFunction

pNormDist

pNorm

dot

toString

equals

equals

arrayCopy

iterator

getNonZeroIterator

getNonZeroIterator

zeroOut

hashCode

random

random

zeros