SparseDoubleArray (S-Space Package 2.0.1 API)

java.lang.Object
- edu.ucla.sspace.util.SparseDoubleArray

All Implemented Interfaces:

SparseArray<Double>, SparseNumericArray<Double>, Serializable, Iterable<DoubleEntry>
```
public class SparseDoubleArray
extends Object
implements SparseNumericArray<Double>, Serializable, Iterable<DoubleEntry>
```
A sparse double array. This class trades increased space efficiency at the cost of decreased performance.
This class also provides additional primitive accessor methods. This allows users to invoke get and set without marshalling primitive types to their Double equivalents unnecessarily.
The get operation runs in logarithmic time. The set operation runs in consant time if setting an existing non-zero value to a non-zero value. However, if the set invocation sets a zero value to non-zero, the operation is linear with the size of the array.
Instance offer a space savings of retaining only the non-zero indices and values. For large array with only a few values set, this offers a huge savings. However, as the cardinality of the array grows in relation to its size, a dense double[] array will offer better performance in both space and time. This is especially true if the sparse array instance approaches a cardinality to size ratio of .5.
This class supports iterating over the non-zero indices and values in the array via the iterator() method. The indices will be returned in sorted order. In cases where both the values and indices are needed, iteration will be faster, O(k), than using getElementIndices() and getPrimitive(int) together, O(k * log(k)), where k is the number of non-zero indices. The iterator returned by this class is not thread-safe and will not throw an exception if the array is concurrently modified during iteration.

See Also:
SparseArray, Serialized Form

Constructor Summary

Constructors
Constructor and Description
`SparseDoubleArray()` Creates a sparse `double` array that grows to the maximum size set by `Double.MAX_VALUE`.
`SparseDoubleArray(double[] array)` Creates a sparse array copy of the provided array, retaining only the non-zero values.
`SparseDoubleArray(int length)` Creates a sparse `double` array with a fixed length
`SparseDoubleArray(int[] indices, double[] values, int length)` Creates a sparse array using the specified indices and their corresponding values.

Method Summary

Methods
Modifier and Type	Method and Description
`Double`	`add(int index, Double delta)` Adds the specified value to the value at the index and stores the result (just as `array[index] += delta`).
`double`	`addPrimitive(int index, double delta)` Adds the specified value to the index.
`int`	`cardinality()` Returns the number of non-zero values in this sparse array
`Double`	`divide(int index, Double value)` Divides the specified value to the index by the provided value and stores the result at the index (just as `array[index] /= value`)
`double`	`dividePrimitive(int index, double value)` Divides the specified value to the index by the provided value and stores the result at the index (just as `array[index] /= value`)
`Double`	`get(int index)` Returns the value of this array at the index.
`int[]`	`getElementIndices()` Returns the indices of the array that contain non-`0` values.
`double`	`getPrimitive(int index)` Retrieves the value at specified index or 0 if no value had been specified.
`Iterator<DoubleEntry>`	`iterator()` Returns an iterator over the non-zero values in this array.
`int`	`length()` Returns the maximum length of this array.
`Double`	`multiply(int index, Double value)` Multiplies the value to the index by the provided value and saves the result at the index (just as `array[index] *= value`)
`double`	`multiplyPrimitive(int index, double value)` Multiplies the value to the index by the provided value and saves the result at the index (just as `array[index] *= value`)
`void`	`set(int index, Double value)` Sets the object as the value at the index.
`void`	`setPrimitive(int index, double value)` Sets the value of the index to the value using the Java primitives without auto-boxing.
`<E> E[]`	`toArray(E[] array)` Fills the provided array with the values contained in this array that fit within the length of the provided array.
`double[]`	`toPrimitiveArray(double[] array)` Sets the values of the provided array using the contents of this array.
`String`	`toString()`

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

- Constructor Detail
  - SparseDoubleArray
```
public SparseDoubleArray()
```
    Creates a sparse double array that grows to the maximum size set by Double.MAX_VALUE.
  - SparseDoubleArray
```
public SparseDoubleArray(int length)
```
    Creates a sparse double array with a fixed length
  - SparseDoubleArray
```
public SparseDoubleArray(double[] array)
```
    Creates a sparse array copy of the provided array, retaining only the non-zero values. The length of the provided array is used to set the maximum size of this sparse array.
    
    Parameters:
    array - the array whose values will be copied into this sparse array
  - SparseDoubleArray
```
public SparseDoubleArray(int[] indices,
                 double[] values,
                 int length)
```
    Creates a sparse array using the specified indices and their corresponding values.
    
    Parameters:
    indices - an sorted array of positive values representing the non-zero indices of the array
    values - an array of values that correspond their respective indices
    length - the total length of the array
- Method Detail
  - addPrimitive
```
public double addPrimitive(int index,
                  double delta)
```
    Adds the specified value to the index. This call is more effecient than calling get and set.
    
    Parameters:
    index - the position in the array
    delta - the change in value at the index
  - add
```
public Double add(int index,
         Double delta)
```
    Adds the specified value to the value at the index and stores the result (just as array[index] += delta). Note that this can be used with negative delta values to achieve equivalent -= functionality.
    
    Specified by:
    
    add in interface SparseNumericArray<Double>
    
    Parameters:
    index - the position in the array
    delta - the change in value at the index
    
    Returns:
    the new value stored at the index
  - cardinality
```
public int cardinality()
```
    Returns the number of non-zero values in this sparse array
    
    Specified by:
    
    cardinality in interface SparseArray<Double>
  - dividePrimitive
```
public double dividePrimitive(int index,
                     double value)
```
    Divides the specified value to the index by the provided value and stores the result at the index (just as array[index] /= value)
    
    Parameters:
    index - the position in the array
    value - the value by which the value at the index will be divided
    
    Returns:
    the new value stored at the index
  - divide
```
public Double divide(int index,
            Double value)
```
    Divides the specified value to the index by the provided value and stores the result at the index (just as array[index] /= value)
    
    Specified by:
    
    divide in interface SparseNumericArray<Double>
    
    Parameters:
    index - the position in the array
    
    Returns:
    the new value stored at the index
  - get
```
public Double get(int index)
```
    Returns the value of this array at the index.
    
    Specified by:
    
    get in interface SparseArray<Double>
    
    Parameters:
    index - the position in the array
    
    Returns:
    the object at the position
  - getElementIndices
```
public int[] getElementIndices()
```
    Returns the indices of the array that contain non-0 values.
    
    Specified by:
    
    getElementIndices in interface SparseArray<Double>
    
    Returns:
    the indices that contain values
  - getPrimitive
```
public double getPrimitive(int index)
```
    Retrieves the value at specified index or 0 if no value had been specified.
    
    Parameters:
    index - the position in the array
    
    Returns:
    the primitive value at that position
    
    Throws:
    
    ArrayIndexOutOfBoundException - if the index is greater than the maximum length of the array.
  - iterator
```
public Iterator<DoubleEntry> iterator()
```
    Returns an iterator over the non-zero values in this array.
    
    Specified by:
    
    iterator in interface Iterable<DoubleEntry>
  - length
```
public int length()
```
    Returns the maximum length of this array.
    
    Specified by:
    
    length in interface SparseArray<Double>
  - multiplyPrimitive
```
public double multiplyPrimitive(int index,
                       double value)
```
    Multiplies the value to the index by the provided value and saves the result at the index (just as array[index] *= value)
    
    Parameters:
    index - the position in the array
    value - the value that will be multiplied in value at the index
    
    Returns:
    the new value stored at the index
  - multiply
```
public Double multiply(int index,
              Double value)
```
    Multiplies the value to the index by the provided value and saves the result at the index (just as array[index] *= value)
    
    Specified by:
    
    multiply in interface SparseNumericArray<Double>
    
    Parameters:
    index - the position in the array
    
    Returns:
    the new value stored at the index
  - set
```
public void set(int index,
       Double value)
```
    Sets the object as the value at the index.
    
    Specified by:
    
    set in interface SparseArray<Double>
    
    Parameters:
    index - an index in the array
    value - the value
  - setPrimitive
```
public void setPrimitive(int index,
                double value)
```
    Sets the value of the index to the value using the Java primitives without auto-boxing.
  - toArray
```
public <E> E[] toArray(E[] array)
```
    Fills the provided array with the values contained in this array that fit within the length of the provided array.
    
    Specified by:
    
    toArray in interface SparseArray<Double>
  - toPrimitiveArray
```
public double[] toPrimitiveArray(double[] array)
```
    Sets the values of the provided array using the contents of this array. If the provided array is longer than this array, the additional values are left unchanged.
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class SparseDoubleArray

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

SparseDoubleArray

SparseDoubleArray

SparseDoubleArray

SparseDoubleArray

Method Detail

addPrimitive

add

cardinality

dividePrimitive

divide

get

getElementIndices

getPrimitive

iterator

length

multiplyPrimitive

multiply

set

setPrimitive

toArray

toPrimitiveArray

toString