IntFactory2D (Parallel Colt 0.10.1

java.lang.Object
- cern.colt.PersistentObject
- - cern.colt.matrix.tint.IntFactory2D

All Implemented Interfaces:: Serializable, Cloneable

public class IntFactory2D
extends PersistentObject

Factory for convenient construction of 2-d matrices holding int cells. Also provides convenient methods to compose (concatenate) and decompose (split) matrices from/to constituent blocks.

Construction	Use idioms like `IntFactory2D.dense.make(4,4)` to construct dense matrices, `IntFactory2D.sparse.make(4,4)` to construct sparse matrices.
Construction with initial values	Use other `make` methods to construct matrices with given initial values.
Appending rows and columns	Use methods `appendColumns`, `appendRows` and `repeat` to append rows and columns.
General block matrices	Use methods `compose` and `decompose` to work with general block matrices.
Diagonal matrices	Use methods `diagonal(vector)`, `diagonal(matrix)` and `identity` to work with diagonal matrices.
Diagonal block matrices	Use method `composeDiagonal` to work with diagonal block matrices.
Random	Use methods `random` and `sample` to construct random matrices.

If the factory is used frequently it might be useful to streamline the notation. For example by aliasing:

  IntFactory2D F = IntFactory2D.dense;
  F.make(4,4);
  F.descending(10,20);
  F.random(4,4);
  ...

Version:: 1.0, 09/24/99
Author:: wolfgang.hoschek@cern.ch
See Also:: Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static IntFactory2D`	`dense` A factory producing dense matrices.
`static IntFactory2D`	`rowCompressed` A factory producing sparse row compressed matrices.
`static IntFactory2D`	`sparse` A factory producing sparse hash matrices.

Method Summary

Methods
Modifier and Type	Method and Description
`IntMatrix2D`	`appendColumn(IntMatrix2D A, IntMatrix1D b)`
`IntMatrix2D`	`appendColumns(IntMatrix2D A, IntMatrix2D B)` C = A\|\|B; Constructs a new matrix which is the column-wise concatenation of two other matrices.
`IntMatrix2D`	`appendRow(IntMatrix2D A, IntMatrix1D b)`
`IntMatrix2D`	`appendRows(IntMatrix2D A, IntMatrix2D B)` C = A\|\|B; Constructs a new matrix which is the row-wise concatenation of two other matrices.
`IntMatrix2D`	`ascending(int rows, int columns)` Constructs a matrix with cells having ascending values.
`IntMatrix2D`	`compose(IntMatrix2D[][] parts)` Constructs a block matrix made from the given parts.
`IntMatrix2D`	`composeBidiagonal(IntMatrix2D A, IntMatrix2D B)`
`IntMatrix2D`	`composeDiagonal(IntMatrix2D A, IntMatrix2D B)` Constructs a diagonal block matrix from the given parts (the direct sum of two matrices).
`IntMatrix2D`	`composeDiagonal(IntMatrix2D A, IntMatrix2D B, IntMatrix2D C)` Constructs a diagonal block matrix from the given parts.
`void`	`decompose(IntMatrix2D[][] parts, IntMatrix2D matrix)` Splits a block matrix into its constituent blocks; Copies blocks of a matrix into the given parts.
`void`	`demo1()` Demonstrates usage of this class.
`void`	`demo2()` Demonstrates usage of this class.
`IntMatrix2D`	`descending(int rows, int columns)` Constructs a matrix with cells having descending values.
`IntMatrix2D`	`diagonal(int[] vector)` Constructs a new diagonal matrix whose diagonal elements are the elements of `vector`.
`IntMatrix2D`	`diagonal(IntMatrix1D vector)` Constructs a new diagonal matrix whose diagonal elements are the elements of `vector`.
`IntMatrix1D`	`diagonal(IntMatrix2D A)` Constructs a new vector consisting of the diagonal elements of `A` .
`IntMatrix2D`	`identity(int rowsAndColumns)` Constructs an identity matrix (having ones on the diagonal and zeros elsewhere).
`IntMatrix2D`	`make(int[][] values)` Constructs a matrix with the given cell values.
`IntMatrix2D`	`make(int[] values, int rows)` Construct a matrix from a one-dimensional column-major packed array, ala Fortran.
`IntMatrix2D`	`make(int rows, int columns)` Constructs a matrix with the given shape, each cell initialized with zero.
`IntMatrix2D`	`make(int rows, int columns, int initialValue)` Constructs a matrix with the given shape, each cell initialized with the given value.
`IntMatrix2D`	`random(int rows, int columns)` Constructs a matrix with uniformly distributed values in `(0,1)` (exclusive).
`IntMatrix2D`	`repeat(IntMatrix2D A, int rowRepeat, int columnRepeat)` C = A\|\|A\|\|..\|\|A; Constructs a new matrix which is duplicated both along the row and column dimension.
`IntMatrix2D`	`reshape(IntMatrix1D a, int rows, int columns)`
`IntMatrix2D`	`sample(int rows, int columns, int value, int nonZeroFraction)` Constructs a randomly sampled matrix with the given shape.
`IntMatrix2D`	`sample(IntMatrix2D matrix, int value, int nonZeroFraction)` Modifies the given matrix to be a randomly sampled matrix.

Methods inherited from class cern.colt.PersistentObject
clone

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

Field Detail
- dense
```
public static final IntFactory2D dense
```
  A factory producing dense matrices.
- sparse
```
public static final IntFactory2D sparse
```
  A factory producing sparse hash matrices.
- rowCompressed
```
public static final IntFactory2D rowCompressed
```
  A factory producing sparse row compressed matrices.

Method Detail

appendColumns

public IntMatrix2D appendColumns(IntMatrix2D A,
                        IntMatrix2D B)

C = A||B; Constructs a new matrix which is the column-wise concatenation of two other matrices.

   0 1 2
   3 4 5
   appendColumns
   6 7
   8 9
   -->
   0 1 2 6 7 
   3 4 5 8 9

appendColumn

public IntMatrix2D appendColumn(IntMatrix2D A,
                       IntMatrix1D b)

appendRows

public IntMatrix2D appendRows(IntMatrix2D A,
                     IntMatrix2D B)

C = A||B; Constructs a new matrix which is the row-wise concatenation of two other matrices.

appendRow

public IntMatrix2D appendRow(IntMatrix2D A,
                    IntMatrix1D b)

ascending

public IntMatrix2D ascending(int rows,
                    int columns)

Constructs a matrix with cells having ascending values. For debugging purposes. Example:

   0 1 2 
   3 4 5

reshape

public IntMatrix2D reshape(IntMatrix1D a,
                  int rows,
                  int columns)

compose

public IntMatrix2D compose(IntMatrix2D[][] parts)

Constructs a block matrix made from the given parts. The inverse to method decompose(IntMatrix2D[][], IntMatrix2D).

All matrices of a given column within parts must have the same number of columns. All matrices of a given row within parts must have the same number of rows. Otherwise an IllegalArgumentException is thrown. Note that nulls within parts[row,col] are an exception to this rule: they are ignored. Cells are copied. Example:

`Code`	`Result`
IntMatrix2D[][] parts1 = { { null, make(2, 2, 1), null }, { make(4, 4, 2), null, make(4, 3, 3) }, { null, make(2, 2, 4), null } }; System.out.println(compose(parts1));	`8 x 9 matrix 0 0 0 0 1 1 0 0 0 0 0 0 0 1 1 0 0 0 2 2 2 2 0 0 3 3 3 2 2 2 2 0 0 3 3 3 2 2 2 2 0 0 3 3 3 2 2 2 2 0 0 3 3 3 0 0 0 0 4 4 0 0 0 0 0 0 0 4 4 0 0 0`
IntMatrix2D[][] parts3 = { { identity(3), null, }, { null, identity(3).viewColumnFlip() }, { identity(3).viewRowFlip(), null } }; System.out.println("\n" + make(parts3));	`9 x 6 matrix 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0`
IntMatrix2D A = ascending(2, 2); IntMatrix2D B = descending(2, 2); IntMatrix2D _ = null; IntMatrix2D[][] parts4 = { { A, _, A, _ }, { _, A, _, B } }; System.out.println("\n" + make(parts4));	`4 x 8 matrix 1 2 0 0 1 2 0 0 3 4 0 0 3 4 0 0 0 0 1 2 0 0 3 2 0 0 3 4 0 0 1 0`
IntMatrix2D[][] parts2 = { { null, make(2, 2, 1), null }, { make(4, 4, 2), null, make(4, 3, 3) }, { null, make(2, 3, 4), null } }; System.out.println("\n" + Factory2D.make(parts2));	`IllegalArgumentException A[0,1].columns != A[2,1].columns (2 != 3)`

Throws:: IllegalArgumentException - subject to the conditions outlined above.

composeDiagonal
```
public IntMatrix2D composeDiagonal(IntMatrix2D A,
                          IntMatrix2D B)
```
Constructs a diagonal block matrix from the given parts (the direct sum of two matrices). That is the concatenation
```
   A 0
   0 B
 
 
```
(The direct sum has A.rows()+B.rows() rows and A.columns()+B.columns() columns). Cells are copied.
Returns:
a new matrix which is the direct sum.

composeDiagonal

public IntMatrix2D composeDiagonal(IntMatrix2D A,
                          IntMatrix2D B,
                          IntMatrix2D C)

Constructs a diagonal block matrix from the given parts. The concatenation has the form

   A 0 0
   0 B 0
   0 0 C

from the given parts. Cells are copied.

composeBidiagonal

public IntMatrix2D composeBidiagonal(IntMatrix2D A,
                            IntMatrix2D B)

decompose

public void decompose(IntMatrix2D[][] parts,
             IntMatrix2D matrix)

Splits a block matrix into its constituent blocks; Copies blocks of a matrix into the given parts. The inverse to method compose(IntMatrix2D[][]).

Code matrix --> parts

   IntMatrix2D matrix = ... ;
   IntMatrix2D _ = null;
   IntMatrix2D A,B,C,D;
   A = make(2,2); B = make (4,4);
   C = make(4,3); D = make (2,2);
   IntMatrix2D[][] parts = 
   {
      { _, A, _ },
      { B, _, C },
      { _, D, _ }
   };
   decompose(parts,matrix);
   System.out.println("\nA = "+A);
   System.out.println("\nB = "+B);
   System.out.println("\nC = "+C);
   System.out.println("\nD = "+D);

8 x 9 matrix 9 9 9 9 1 1 9 9 9 9 9 9 9 1 1 9 9 9 2 2 2 2 9 9 3 3 3 2 2 2 2 9 9 3 3 3 2 2 2 2 9 9 3 3 3 2 2 2 2 9 9 3 3 3 9 9 9 9 4 4 9 9 9 9 9 9 9 4 4 9 9 9

A = 2 x 2 matrix 1 1 1 1

B = 4 x 4 matrix 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2

C = 4 x 3 matrix 3 3 3 3 3 33 3 33 3 3

D = 2 x 2 matrix 4 4 4 4

Throws:: IllegalArgumentException - subject to the conditions outlined above.

demo1
```
public void demo1()
```
Demonstrates usage of this class.

demo2
```
public void demo2()
```
Demonstrates usage of this class.

descending

public IntMatrix2D descending(int rows,
                     int columns)

Constructs a matrix with cells having descending values. For debugging purposes. Example:

   5 4 3 
   2 1 0

diagonal
```
public IntMatrix2D diagonal(IntMatrix1D vector)
```
Constructs a new diagonal matrix whose diagonal elements are the elements of vector. Cells values are copied. The new matrix is not a view. Example:
```
   5 4 3 -->
   5 0 0
   0 4 0
   0 0 3
 
 
```
Returns:
a new matrix.

diagonal
```
public IntMatrix2D diagonal(int[] vector)
```
Constructs a new diagonal matrix whose diagonal elements are the elements of vector. Cells values are copied. The new matrix is not a view. Example:
```
   5 4 3 -->
   5 0 0
   0 4 0
   0 0 3
 
 
```
Returns:
a new matrix.

diagonal
```
public IntMatrix1D diagonal(IntMatrix2D A)
```
Constructs a new vector consisting of the diagonal elements of A . Cells values are copied. The new vector is not a view. Example:
```
   5 0 0 9
   0 4 0 9
   0 0 3 9
   --> 5 4 3
 
 
```
Parameters:
A - the matrix, need not be square.

Returns:
a new vector.

identity
```
public IntMatrix2D identity(int rowsAndColumns)
```
Constructs an identity matrix (having ones on the diagonal and zeros elsewhere).

make
```
public IntMatrix2D make(int[][] values)
```
Constructs a matrix with the given cell values. values is required to have the form values[row][column] and have exactly the same number of columns in every row.
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.

Throws:

IllegalArgumentException - if for any 1 <= row < values.length: values[row].length != values[row-1].length .

make
```
public IntMatrix2D make(int[] values,
               int rows)
```
Construct a matrix from a one-dimensional column-major packed array, ala Fortran. Has the form matrix.get(row,column) == values[row + column*rows]. The values are copied.

Parameters:
values - One-dimensional array of doubles, packed by columns (ala Fortran).
rows - the number of rows.

Throws:

IllegalArgumentException - values.length must be a multiple of rows .

make
```
public IntMatrix2D make(int rows,
               int columns)
```
Constructs a matrix with the given shape, each cell initialized with zero.

make

public IntMatrix2D make(int rows,
               int columns,
               int initialValue)

Constructs a matrix with the given shape, each cell initialized with the given value.

random
```
public IntMatrix2D random(int rows,
                 int columns)
```
Constructs a matrix with uniformly distributed values in (0,1) (exclusive).

repeat

public IntMatrix2D repeat(IntMatrix2D A,
                 int rowRepeat,
                 int columnRepeat)

C = A||A||..||A; Constructs a new matrix which is duplicated both along the row and column dimension. Example:

   0 1
   2 3
   repeat(2,3) -->
   0 1 0 1 0 1
   2 3 2 3 2 3
   0 1 0 1 0 1
   2 3 2 3 2 3

sample
```
public IntMatrix2D sample(int rows,
                 int columns,
                 int value,
                 int nonZeroFraction)
```
Constructs a randomly sampled matrix with the given shape. Randomly picks exactly Math.round(rows*columns*nonZeroFraction) cells and initializes them to value, all the rest will be initialized to zero. Note that this is not the same as setting each cell with probability nonZeroFraction to value. Note: The random seed is a constant.

Throws:

IllegalArgumentException - if nonZeroFraction < 0 || nonZeroFraction > 1.
See Also:
DoubleRandomSamplingAssistant

sample
```
public IntMatrix2D sample(IntMatrix2D matrix,
                 int value,
                 int nonZeroFraction)
```
Modifies the given matrix to be a randomly sampled matrix. Randomly picks exactly Math.round(rows*columns*nonZeroFraction) cells and initializes them to value, all the rest will be initialized to zero. Note that this is not the same as setting each cell with probability nonZeroFraction to value. Note: The random seed is a constant.

Throws:

IllegalArgumentException - if nonZeroFraction < 0 || nonZeroFraction > 1.
See Also:
DoubleRandomSamplingAssistant

Class IntFactory2D

Field Summary

Method Summary

Methods inherited from class cern.colt.PersistentObject

Methods inherited from class java.lang.Object

Field Detail

dense

sparse

rowCompressed

Method Detail

appendColumns

appendColumn

appendRows

appendRow

ascending

reshape

compose

composeDiagonal

composeDiagonal

composeBidiagonal

decompose

demo1

demo2

descending

diagonal

diagonal

diagonal

identity

make

make

make

make

random

repeat

sample

sample