## Class FComplexFactory2D

- java.lang.Object
- cern.colt.PersistentObject
- cern.colt.matrix.tfcomplex.FComplexFactory2D

- All Implemented Interfaces:
- Serializable, Cloneable

public class FComplexFactory2Dextends PersistentObject

Factory for convenient construction of 2-d matrices holding`complex`cells. Also provides convenient methods to compose (concatenate) and decompose (split) matrices from/to constituent blocks.*Construction*Use idioms like `ComplexFactory2D.dense.make(4,4)`to construct dense matrices,`ComplexFactory2D.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:

ComplexFactory2D F = ComplexFactory2D.dense; F.make(4,4); F.random(4,4); ...

- See Also:
- Serialized Form

### Field Summary

Fields Modifier and Type Field and Description `static FComplexFactory2D`

**dense**A factory producing dense matrices.`static FComplexFactory2D`

**sparse**A factory producing sparse hash matrices.

### Method Summary

Methods Modifier and Type Method and Description `FComplexMatrix2D`

**appendColumn**(FComplexMatrix2D A, FComplexMatrix1D b)C = A||b; Constructs a new matrix which is the column-wise concatenation of two other matrices.`FComplexMatrix2D`

**appendColumns**(FComplexMatrix2D A, FComplexMatrix2D B)C = A||B; Constructs a new matrix which is the column-wise concatenation of two other matrices.`FComplexMatrix2D`

**appendRow**(FComplexMatrix2D A, FComplexMatrix1D b)C = A||b; Constructs a new matrix which is the row-wise concatenation of two other matrices.`FComplexMatrix2D`

**appendRows**(FComplexMatrix2D A, FComplexMatrix2D B)C = A||B; Constructs a new matrix which is the row-wise concatenation of two other matrices.`FComplexMatrix2D`

**compose**(FComplexMatrix2D[][] parts)Constructs a block matrix made from the given parts.`FComplexMatrix2D`

**composeBidiagonal**(FComplexMatrix2D A, FComplexMatrix2D B)Constructs a bidiagonal block matrix from the given parts.`FComplexMatrix2D`

**composeDiagonal**(FComplexMatrix2D A, FComplexMatrix2D B)Constructs a diagonal block matrix from the given parts (the*direct sum*of two matrices).`FComplexMatrix2D`

**composeDiagonal**(FComplexMatrix2D A, FComplexMatrix2D B, FComplexMatrix2D C)Constructs a diagonal block matrix from the given parts.`void`

**decompose**(FComplexMatrix2D[][] parts, FComplexMatrix2D 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.`FComplexMatrix2D`

**diagonal**(FComplexMatrix1D vector)Constructs a new diagonal matrix whose diagonal elements are the elements of`vector`.`FComplexMatrix1D`

**diagonal**(FComplexMatrix2D A)Constructs a new vector consisting of the diagonal elements of`A`.`FComplexMatrix2D`

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

**make**(float[][] values)Constructs a matrix with the given cell values.`FComplexMatrix2D`

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

**make**(int rows, int columns, float[] initialValue)Constructs a matrix with the given shape, each cell initialized with the given value.`FComplexMatrix2D`

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

**repeat**(FComplexMatrix2D A, int rowRepeat, int columnRepeat)C = A||A||..||A; Constructs a new matrix which is duplicated both along the row and column dimension.`FComplexMatrix2D`

**sample**(FComplexMatrix2D matrix, float[] value, float nonZeroFraction)Modifies the given matrix to be a randomly sampled matrix.`FComplexMatrix2D`

**sample**(int rows, int columns, float[] value, float nonZeroFraction)Constructs a randomly sampled matrix with the given shape.### Methods inherited from class cern.colt.PersistentObject

`clone`

### Field Detail

#### dense

public static final FComplexFactory2D dense

A factory producing dense matrices.

#### sparse

public static final FComplexFactory2D sparse

A factory producing sparse hash matrices.

### Method Detail

#### appendColumns

public FComplexMatrix2D appendColumns(FComplexMatrix2D A, FComplexMatrix2D 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 FComplexMatrix2D appendColumn(FComplexMatrix2D A, FComplexMatrix1D b)

C = A||b; Constructs a new matrix which is the column-wise concatenation of two other matrices.0 1 2 3 4 5 appendColumn 6 8 --> 0 1 2 6 3 4 5 8

#### appendRows

public FComplexMatrix2D appendRows(FComplexMatrix2D A, FComplexMatrix2D B)

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

#### appendRow

public FComplexMatrix2D appendRow(FComplexMatrix2D A, FComplexMatrix1D b)

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

#### compose

public FComplexMatrix2D compose(FComplexMatrix2D[][] parts)

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

.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`null`s within`parts[row,col]`are an exception to this rule: they are ignored. Cells are copied.- Throws:
`IllegalArgumentException`

- subject to the conditions outlined above.

#### composeDiagonal

public FComplexMatrix2D composeDiagonal(FComplexMatrix2D A, FComplexMatrix2D B)

Constructs a diagonal block matrix from the given parts (the*direct sum*of two matrices). That is the concatenationA 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 FComplexMatrix2D composeDiagonal(FComplexMatrix2D A, FComplexMatrix2D B, FComplexMatrix2D C)

Constructs a diagonal block matrix from the given parts. The concatenation has the formA 0 0 0 B 0 0 0 C

from the given parts. Cells are copied.

#### composeBidiagonal

public FComplexMatrix2D composeBidiagonal(FComplexMatrix2D A, FComplexMatrix2D B)

Constructs a bidiagonal block matrix from the given parts. from the given parts. Cells are copied.

#### decompose

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

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

.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`null`s within`parts[row,col]`are an exception to this rule: they are ignored. Cells are copied.- 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.

#### diagonal

public FComplexMatrix2D diagonal(FComplexMatrix1D 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.- Returns:
- a new matrix.

#### diagonal

public FComplexMatrix1D diagonal(FComplexMatrix2D A)

Constructs a new vector consisting of the diagonal elements of`A`. Cells values are copied. The new vector is not a view.- Parameters:
`A`

- the matrix, need not be square.- Returns:
- a new vector.

#### identity

public FComplexMatrix2D identity(int rowsAndColumns)

Constructs an identity matrix (having ones on the diagonal and zeros elsewhere).

#### make

public FComplexMatrix2D make(float[][] 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 FComplexMatrix2D make(int rows, int columns)

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

#### make

public FComplexMatrix2D make(int rows, int columns, float[] initialValue)

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

#### random

public FComplexMatrix2D random(int rows, int columns)

Constructs a matrix with uniformly distributed values in`(0,1)`(exclusive).

#### repeat

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

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

#### sample

public FComplexMatrix2D sample(int rows, int columns, float[] value, float 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:
`FloatRandomSampler`

#### sample

public FComplexMatrix2D sample(FComplexMatrix2D matrix, float[] value, float 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:
`FloatRandomSampler`

**SCaVis 2.2 © jWork.ORG**