## Class SparseDoubleMatrix1D

- java.lang.Object
- cern.colt.PersistentObject
- cern.colt.matrix.impl.AbstractMatrix
- cern.colt.matrix.impl.AbstractMatrix1D
- cern.colt.matrix.DoubleMatrix1D
- cern.colt.matrix.impl.SparseDoubleMatrix1D

- All Implemented Interfaces:
- Serializable, Cloneable

public class SparseDoubleMatrix1Dextends DoubleMatrix1D

Sparse hashed 1-d matrix (aka*vector*) holding`double`elements.First see the package summary and javadoc tree view to get the broad picture.**Implementation:**Note that this implementation is not synchronized.Uses a

`OpenIntDoubleHashMap`

, which is a compact and performant hashing technique.**Memory requirements:**Cells that

- are never set to non-zero values do not use any memory.
- switch from zero to non-zero state do use memory.
- switch back from non-zero to zero state also do use memory. However, their memory is automatically reclaimed from time to time. It can also manually be reclaimed by calling
`trimToSize()`

.

worst case:

`memory [bytes] = (1/minLoadFactor) * nonZeros * 13`.

best case:`memory [bytes] = (1/maxLoadFactor) * nonZeros * 13`.

Where`nonZeros = cardinality()`is the number of non-zero cells.Thus, a 1000000 matrix with minLoadFactor=0.25 and maxLoadFactor=0.5 and 1000000 non-zero cells consumes between 25 MB and 50 MB.The same 1000000 matrix with 1000 non-zero cells consumes between 25 and 50 KB.**Time complexity:**This class offers

*expected*time complexity`O(1)`(i.e. constant time) for the basic operations`get`,`getQuick`,`set`,`setQuick`and`size`assuming the hash function disperses the elements properly among the buckets.Otherwise, pathological cases, although highly improbable, can occur, degrading performance to`O(N)`in the worst case.As such this sparse class is expected to have no worse time complexity than its dense counterpart`DenseDoubleMatrix1D`

.However, constant factors are considerably larger.- See Also:
- Serialized Form

### Field Summary

### Fields inherited from class cern.colt.PersistentObject

`serialVersionUID`

### Constructor Summary

Constructors Constructor and Description **SparseDoubleMatrix1D**(double[] values)Constructs a matrix with a copy of the given values.**SparseDoubleMatrix1D**(int size)Constructs a matrix with a given number of cells.**SparseDoubleMatrix1D**(int size, int initialCapacity, double minLoadFactor, double maxLoadFactor)Constructs a matrix with a given number of parameters.

### Method Summary

Methods Modifier and Type Method and Description `DoubleMatrix1D`

**assign**(double value)Sets all cells to the state specified by`value`.`int`

**cardinality**()Returns the number of cells having non-zero values.`void`

**ensureCapacity**(int minCapacity)Ensures that the receiver can hold at least the specified number of non-zero cells without needing to allocate new internal memory.`double`

**getQuick**(int index)Returns the matrix cell value at coordinate`index`.`DoubleMatrix1D`

**like**(int size)Construct and returns a new empty matrix*of the same dynamic type*as the receiver, having the specified size.`DoubleMatrix2D`

**like2D**(int rows, int columns)Construct and returns a new 2-d matrix*of the corresponding dynamic type*, entirelly independent of the receiver.`void`

**setQuick**(int index, double value)Sets the matrix cell at coordinate`index`to the specified value.`void`

**trimToSize**()Releases any superfluous memory created by explicitly putting zero values into cells formerly having non-zero values; An application can use this operation to minimize the storage of the receiver.### Methods inherited from class cern.colt.matrix.DoubleMatrix1D

`aggregate, aggregate, assign, assign, assign, assign, assign, copy, equals, equals, get, getNonZeros, getNonZeros, like, set, swap, toArray, toArray, toString, viewFlip, viewPart, viewSelection, viewSelection, viewSorted, viewStrides, zDotProduct, zDotProduct, zDotProduct, zSum`

### Methods inherited from class cern.colt.matrix.impl.AbstractMatrix1D

`checkSize, size, toStringShort`

### Methods inherited from class cern.colt.PersistentObject

`clone`

### Constructor Detail

#### SparseDoubleMatrix1D

public SparseDoubleMatrix1D(double[] values)

Constructs a matrix with a copy of the given values. The values are copied. So subsequent changes in`values`are not reflected in the matrix, and vice-versa.- Parameters:
`values`

- The values to be filled into the new matrix.

#### SparseDoubleMatrix1D

public SparseDoubleMatrix1D(int size)

Constructs a matrix with a given number of cells. All entries are initially`0`.- Parameters:
`size`

- the number of cells the matrix shall have.- Throws:
`IllegalArgumentException`

- if`size<0`.

#### SparseDoubleMatrix1D

public SparseDoubleMatrix1D(int size, int initialCapacity, double minLoadFactor, double maxLoadFactor)

Constructs a matrix with a given number of parameters. All entries are initially`0`. For details related to memory usage see`OpenIntDoubleHashMap`

.- Parameters:
`size`

- the number of cells the matrix shall have.`initialCapacity`

- the initial capacity of the hash map. If not known, set`initialCapacity=0`or small.`minLoadFactor`

- the minimum load factor of the hash map.`maxLoadFactor`

- the maximum load factor of the hash map.- Throws:
`IllegalArgumentException`

- if`initialCapacity < 0 || (minLoadFactor < 0.0 || minLoadFactor >= 1.0) || (maxLoadFactor <= 0.0 || maxLoadFactor >= 1.0) || (minLoadFactor >= maxLoadFactor)`.`IllegalArgumentException`

- if`size<0`.

### Method Detail

#### assign

public DoubleMatrix1D assign(double value)

Sets all cells to the state specified by`value`.**Overrides:**`assign`

in class`DoubleMatrix1D`

- Parameters:
`value`

- the value to be filled into the cells.- Returns:
`this`(for convenience only).

#### cardinality

public int cardinality()

Returns the number of cells having non-zero values.**Overrides:**`cardinality`

in class`DoubleMatrix1D`

#### ensureCapacity

public void ensureCapacity(int minCapacity)

Ensures that the receiver can hold at least the specified number of non-zero cells without needing to allocate new internal memory. If necessary, allocates new internal memory and increases the capacity of the receiver.This method never need be called; it is for performance tuning only. Calling this method before tt>set()ing a large number of non-zero values boosts performance, because the receiver will grow only once instead of potentially many times and hash collisions get less probable.

**Overrides:**`ensureCapacity`

in class`AbstractMatrix`

- Parameters:
`minNonZeros`

- the desired minimum number of non-zero cells.

#### getQuick

public double getQuick(int index)

Returns the matrix cell value at coordinate`index`.Provided with invalid parameters this method may return invalid objects without throwing any exception.

**You should only use this method when you are absolutely sure that the coordinate is within bounds.**Precondition (unchecked):`index<0 || index>=size()`.**Specified by:**`getQuick`

in class`DoubleMatrix1D`

- Parameters:
`index`

- the index of the cell.- Returns:
- the value of the specified cell.

#### like

public DoubleMatrix1D like(int size)

Construct and returns a new empty matrix*of the same dynamic type*as the receiver, having the specified size. For example, if the receiver is an instance of type`DenseDoubleMatrix1D`the new matrix must also be of type`DenseDoubleMatrix1D`, if the receiver is an instance of type`SparseDoubleMatrix1D`the new matrix must also be of type`SparseDoubleMatrix1D`, etc. In general, the new matrix should have internal parametrization as similar as possible.**Specified by:**`like`

in class`DoubleMatrix1D`

- Parameters:
`size`

- the number of cell the matrix shall have.- Returns:
- a new empty matrix of the same dynamic type.

#### like2D

public DoubleMatrix2D like2D(int rows, int columns)

Construct and returns a new 2-d matrix*of the corresponding dynamic type*, entirelly independent of the receiver. For example, if the receiver is an instance of type`DenseDoubleMatrix1D`the new matrix must be of type`DenseDoubleMatrix2D`, if the receiver is an instance of type`SparseDoubleMatrix1D`the new matrix must be of type`SparseDoubleMatrix2D`, etc.**Specified by:**`like2D`

in class`DoubleMatrix1D`

- Parameters:
`rows`

- the number of rows the matrix shall have.`columns`

- the number of columns the matrix shall have.- Returns:
- a new matrix of the corresponding dynamic type.

#### setQuick

public void setQuick(int index, double value)

Sets the matrix cell at coordinate`index`to the specified value.Provided with invalid parameters this method may access illegal indexes without throwing any exception.

**You should only use this method when you are absolutely sure that the coordinate is within bounds.**Precondition (unchecked):`index<0 || index>=size()`.**Specified by:**`setQuick`

in class`DoubleMatrix1D`

- Parameters:
`index`

- the index of the cell.`value`

- the value to be filled into the specified cell.

#### trimToSize

public void trimToSize()

Releases any superfluous memory created by explicitly putting zero values into cells formerly having non-zero values; An application can use this operation to minimize the storage of the receiver.**Background:**Cells that

- are never set to non-zero values do not use any memory.
- switch from zero to non-zero state do use memory.
- switch back from non-zero to zero state also do use memory. However, their memory can be reclaimed by calling
`trimToSize()`.

`set(i,5); set(i,0);`sets a cell to non-zero state and later back to zero state. Such as sequence generates obsolete memory that is automatically reclaimed from time to time or can manually be reclaimed by calling`trimToSize()`. Putting zeros into cells already containing zeros does not generate obsolete memory since no memory was allocated to them in the first place.**Overrides:**`trimToSize`

in class`AbstractMatrix`

**SCaVis 2.0 © jWork.ORG**