RandomVector (Java Statistical Analysis Tool 0.0.8 API)

java.lang.Object
- jsat.linear.Vec
- - jsat.linear.RandomVector

All Implemented Interfaces:

Serializable, Cloneable, Iterable<IndexValue>
```
public abstract class RandomVector
extends Vec
```
Stores a Vector full of random values in constant O(1) space by re-computing all matrix values on the fly as need. This allows memory reduction and use when it is necessary to use the matrix with a large sparse data set, where some matrix values may never even be used - or used very infrequently.

Because the values of the random vector are computed on the fly, the Random Vector can not be altered. If attempted, an exception will be thrown.

Author:

Edward Raff

See Also:

Serialized Form

Constructor Summary

Constructors
Modifier	Constructor and Description
	`RandomVector(int length)` Creates a new Random Vector object
	`RandomVector(int length, long seedMult)` Creates a new Random Vector object
`protected`	`RandomVector(RandomVector toCopy)` Copy constructor

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`canBeMutated()` Indicates whether or not this vector can be mutated.
`abstract Vec`	`clone()`
`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.
`double`	`get(int index)` Gets the value stored at a specific index in the vector
`protected abstract double`	`getVal(Random rand)` Computes the value of an index given the already initialized `Random` object.
`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.
`int`	`length()` Returns the length of this vector
`double`	`max()` Returns the maximum value stored in this vector
`double`	`min()` Returns the minimum value stored in this vector
`void`	`multiply(double c, Matrix A, Vec b)` If this is vector `a`, this this computes b = b + c `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`	`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`	`set(int index, double val)` Sets the value stored at a specified index in the vector
`Vec`	`sortedCopy()` Returns a copy of this array with the values moved around so that they are in sorted order

Methods inherited from class jsat.linear.Vec
add, add, applyFunction, applyIndexFunction, arrayCopy, copyTo, copyToCol, copyToRow, countNaNs, divide, equals, equals, getNonZeroIterator, getNonZeroIterator, hashCode, increment, iterator, kurtosis, mean, median, multiply, multiply, multiply, mutableAdd, mutableSubtract, mutableSubtract, mutableSubtract, nnz, normalize, normalized, pairwiseDivide, pairwiseMultiply, pNorm, pNormDist, random, random, skewness, standardDeviation, subtract, subtract, sum, toString, variance, zeroOut, 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
  - RandomVector
```
public RandomVector(int length)
```
    Creates a new Random Vector object
    
    Parameters:
    
    length - the length of the vector
  - RandomVector
```
public RandomVector(int length,
                    long seedMult)
```
    Creates a new Random Vector object
    
    Parameters:
    
    length - the length of the vector
    
    seedMult - a value to multiply with the seed used for each individual index. It should be a large value
  - RandomVector
```
protected RandomVector(RandomVector toCopy)
```
    Copy constructor
    
    Parameters:
    
    toCopy - the object to copy
- Method Detail
  - getVal
```
protected abstract double getVal(Random rand)
```
    Computes the value of an index given the already initialized Random object. This is called by the get(int) method, and will make sure that the correct seed is set before calling this method.
    
    Parameters:
    
    rand - the PRNG to generate the index value from
    
    Returns:
    
    the value for a given index based on the given PRNG
  - get
```
public double get(int index)
```
    Description copied from class: Vec
    
    Gets the value stored at a specific index in the vector
    
    Specified by:
    
    get in class Vec
    
    Parameters:
    
    index - the index to access
    
    Returns:
    
    the double value in the vector
  - set
```
public void set(int index,
                double val)
```
    Description copied from class: Vec
    
    Sets the value stored at a specified index in the vector
    
    Specified by:
    
    set in class Vec
    
    Parameters:
    
    index - the index to access
    
    val - the value to store in the index
  - length
```
public int length()
```
    Description copied from class: Vec
    
    Returns the length of this vector
    
    Specified by:
    
    length in class Vec
    
    Returns:
    
    the length of this vector
  - multiply
```
public void multiply(double c,
                     Matrix A,
                     Vec b)
```
    Description copied from class: Vec
    
    If this is vector a, this this computes b = b + c a^T*A
    
    Overrides:
    
    multiply in class Vec
    
    Parameters:
    
    c - the constant factor to multiply by
    
    A - the matrix to multiple by
    
    b - the vector to mutate by adding the result to
  - mutableAdd
```
public void mutableAdd(double c)
```
    Description copied from class: Vec
    
    Alters this vector such that this = this + c
    
    This method should be overloaded for a serious implementation.
    
    Overrides:
    
    mutableAdd in class Vec
    
    Parameters:
    
    c - a scalar constant to add to each value in this vector
  - mutableAdd
```
public void mutableAdd(double c,
                       Vec b)
```
    Description copied from class: Vec
    
    Alters this vector such that this = this + c * b
    
    This method should be overloaded for a serious implementation.
    
    Overrides:
    
    mutableAdd in class Vec
    
    Parameters:
    
    c - a scalar constant
    
    b - the vector to add to this
  - mutablePairwiseMultiply
```
public void mutablePairwiseMultiply(Vec b)
```
    Description copied from class: Vec
    
    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.
    
    Overrides:
    
    mutablePairwiseMultiply in class Vec
    
    Parameters:
    
    b - the vector to pairwise multiply by
  - mutableMultiply
```
public void mutableMultiply(double c)
```
    Description copied from class: Vec
    
    Mutates this *= c
    
    This method should be overloaded for a serious implementation.
    
    Overrides:
    
    mutableMultiply in class Vec
    
    Parameters:
    
    c - the constant to multiply by
  - mutablePairwiseDivide
```
public void mutablePairwiseDivide(Vec b)
```
    Description copied from class: Vec
    
    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.
    
    Overrides:
    
    mutablePairwiseDivide in class Vec
    
    Parameters:
    
    b - the vector to pairwise divide by
  - mutableDivide
```
public void mutableDivide(double c)
```
    Description copied from class: Vec
    
    Mutates this /= c
    
    This method should be overloaded for a serious implementation.
    
    Overrides:
    
    mutableDivide in class Vec
    
    Parameters:
    
    c - the constant to divide by
  - sortedCopy
```
public Vec sortedCopy()
```
    Description copied from class: Vec
    
    Returns a copy of this array with the values moved around so that they are in sorted order
    
    Overrides:
    
    sortedCopy in class Vec
    
    Returns:
    
    a new array in sorted order
  - min
```
public double min()
```
    Description copied from class: Vec
    
    Returns the minimum value stored in this vector
    
    Overrides:
    
    min in class Vec
    
    Returns:
    
    the minimum value in this vector
  - max
```
public double max()
```
    Description copied from class: Vec
    
    Returns the maximum value stored in this vector
    
    Overrides:
    
    max in class Vec
    
    Returns:
    
    the maximum value in this vector
  - isSparse
```
public boolean isSparse()
```
    Description copied from class: Vec
    
    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.
    
    Specified by:
    
    isSparse in class Vec
    
    Returns:
    
    true if the vector is sparce, false otherwise.
  - clone
```
public abstract Vec clone()
```
    Specified by:
    
    clone in class Vec
  - dot
```
public double dot(Vec v)
```
    Description copied from class: Vec
    
    Computes the dot product between two vectors, which is equivalent to
    Σ this_i*v_i
    
    This method should be overloaded for a serious implementation.
    
    Overrides:
    
    dot in class Vec
    
    Parameters:
    
    v - the other vector
    
    Returns:
    
    the dot product of this vector and another
  - canBeMutated
```
public boolean canBeMutated()
```
    Description copied from class: Vec
    
    Indicates whether or not this vector can be mutated. If false, any method that contains "mutate" will not work.
    
    By default, this returns true
    
    Overrides:
    
    canBeMutated in class Vec
    
    Returns:
    
    true if the vector supports being altered, false other wise.

Class RandomVector

Constructor Summary

Method Summary

Methods inherited from class jsat.linear.Vec

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.Iterable

Constructor Detail

RandomVector

RandomVector

RandomVector

Method Detail

getVal

get

set

length

multiply

mutableAdd

mutableAdd

mutablePairwiseMultiply

mutableMultiply

mutablePairwiseDivide

mutableDivide

sortedCopy

min

max

isSparse

clone

dot

canBeMutated