SparseCostMatrix (Fiji Javadocs 0-SNAPSHOT API)

java.lang.Object
- fiji.plugin.trackmate.tracking.sparselap.linker.SparseCostMatrix

```
public class SparseCostMatrix
extends Object
```
A class to represent a sparse cost matrix.
This class aims at representing in a memory-efficient way a possibly rectangular double matrix used in linear assignment problems (LAP). It is useful when the number of sources (rows of the matrix) and the number of targets (columns of the matrix) are large, but only a fraction of the costs are not infinite (assignment forbidden). In this case, infinite cost can be omitted and it is implicitly understood that missing values of the matrix represent infinite costs. This situation is very common in single-particle tracking for Life-Sciences, and this class is especially designed for these problems.
This class does not do much. It just stores the arrays (described below) that represent the matrix. It is the caller responsibility to ensure they are properly arranged and that they represent the desired cost matrix. The arrays are accessible via default visibility.
This matrix follow the row compressed storage convention, taken from the Volgenant paper: Volgenant. Linear and semi-assignment problems: A core oriented approach. Computers & Operations Research (1996) vol. 23 (10) pp. 917-932

Author:

Jean-Yves Tinevez - 2014

Constructor Summary

Constructors
Constructor and Description
`SparseCostMatrix(double[] cc, int[] kk, int[] number, int nCols)` Instantiate a new sparse cost matrix.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`fillWith(double value)` Replace all the non-infinite values of this matrix by the specified value.
`double`	`get(int i, int j, double missingValue)` Returns the value stored by this matrix at the specified row and column.
`double[]`	`getCosts()` Exposes the array of all the non-infinite costs.
`int`	`getNCols()`
`int`	`getNRows()`
`SparseCostMatrix`	`hcat(SparseCostMatrix B)` Returns the horizontal concatenation of this matrix with the specified one.
`double[][]`	`toFullMatrix()` Creates and returns a new `double[][]` matrix representing a non-sparse version of this cost matrix.
`String`	`toString()`
`String`	`toString(List<?> rows, List<?> columns)`
`double`	`totalAssignmentCost(int[] rowAssignment)` Computes the total cost for an assignment specified by row.
`SparseCostMatrix`	`transpose()` Returns the transpose of this matrix.
`SparseCostMatrix`	`vcat(SparseCostMatrix B)` Returns the vertical concatenation of this matrix with the specified one.

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

- Constructor Detail
  - SparseCostMatrix
```
public SparseCostMatrix(double[] cc,
                        int[] kk,
                        int[] number,
                        int nCols)
```
    Instantiate a new sparse cost matrix. The caller must provide 3 arrays:
    1. cc, the double[] array containing all the non-infinite costs.
    2. kk, an int[] array of the same length that cc, and that contains the columns of the cost.
    These two arrays must be arranged row by row, starting with the first one. And in each row, the columns must be sorted in increasing order (to facilitate index search). Also, each row must have at least one non-infinte cost. If not, an IllegalArgumentException is thrown.
    1. number an int[] array, with one element per row, that contains the number of non infinite cost for a row.
    Parameters:
    
    cc - the cost array.
    
    kk - the column index of each cost.
    
    number - the number of element for each row.
    
    Throws:
    
    IllegalArgumentException - if the cost and column arrays are not of the same size, if the column array is not sorted row by row, of if one row has 0 non-infinite costs.
- Method Detail
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - toString
```
public String toString(List<?> rows,
                       List<?> columns)
```
  - totalAssignmentCost
```
public double totalAssignmentCost(int[] rowAssignment)
```
    Computes the total cost for an assignment specified by row. It is supposed that row i is assigned to column rowAssignment[i].
    
    Parameters:
    
    rowAssignment - the assignment, specified by row.
    
    Returns:
    
    the total cost for this assignment.
  - toFullMatrix
```
public double[][] toFullMatrix()
```
    Creates and returns a new double[][] matrix representing a non-sparse version of this cost matrix. Missing costs are replace by Double.MAX_VALUE.
    
    Returns:
    
    a new double[][]
  - get
```
public final double get(int i,
                        int j,
                        double missingValue)
```
    Returns the value stored by this matrix at the specified row and column. If a value is not present in the sparse matrix, the specified missing value is returned.
    
    Parameters:
    
    i - the row.
    
    j - the column.
    
    missingValue - what to return if the sparse matrix does not store a value at the specified row and column.
    
    Returns:
    
    the value.
  - getCosts
```
public double[] getCosts()
```
    Exposes the array of all the non-infinite costs.
    
    Returns:
    
    the costs.
  - getNCols
```
public int getNCols()
```
  - getNRows
```
public int getNRows()
```
  - vcat
```
public final SparseCostMatrix vcat(SparseCostMatrix B)
```
    Returns the vertical concatenation of this matrix with the specified one. So that if this matrix is A and the specified matrix is B, you get
```
 -----
 | A |
 | B |
 -----
 
```
    Parameters:
    
    B - the matrix to concatenate this matrix with
    
    Returns:
    
    a new sparse matrix.
    
    Throws:
    
    IllegalArgumentException - if B does not have the same number of columns as this matrix.
  - hcat
```
public final SparseCostMatrix hcat(SparseCostMatrix B)
```
    Returns the horizontal concatenation of this matrix with the specified one. So that if this matrix is A and the specified matrix is B, you get
```
 -------
 | A B |
 -------
 
```
    Parameters:
    
    B - the matrix to concatenate this matrix with
    
    Returns:
    
    a new sparse matrix.
    
    Throws:
    
    IllegalArgumentException - if B does not have the same number of rows as this matrix.
  - transpose
```
public final SparseCostMatrix transpose()
```
    Returns the transpose of this matrix.
    
    Returns:
    
    a new sparse matrix.
  - fillWith
```
public void fillWith(double value)
```
    Replace all the non-infinite values of this matrix by the specified value.
    
    Parameters:
    
    value - the value to write in this matrix.

Class SparseCostMatrix

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

SparseCostMatrix

Method Detail

toString

toString

totalAssignmentCost

toFullMatrix

get

getCosts

getNCols

getNRows

vcat

hcat

transpose

fillWith