FloatProperty (Parallel Colt 0.10.1

java.lang.Object
- cern.colt.PersistentObject
- - cern.colt.matrix.tfloat.algo.FloatProperty

All Implemented Interfaces:: Serializable, Cloneable

public class FloatProperty
extends PersistentObject

Tests matrices for linear algebraic properties (equality, tridiagonality, symmetry, singularity, etc).

Except where explicitly indicated, all methods involving equality tests ( ==) allow for numerical instability, to a degree specified upon instance construction and returned by method tolerance(). The public static final variable DEFAULT represents a default Property object with a tolerance of 1.0E-5. The public static final variable ZERO represents a Property object with a tolerance of 0.0. The public static final variable SEVEN represents a Property object with a tolerance of 1.0E-7. As long as you are happy with these tolerances, there is no need to construct Property objects. Simply use idioms like Property.DEFAULT.equals(A,B), Property.ZERO.equals(A,B), Property.SEVEN.equals(A,B).

To work with a different tolerance (e.g. 1.0E-2) use the constructor and/or method setTolerance(float). Note that the public static final Property objects are immutable: Is is not possible to alter their tolerance. Any attempt to do so will throw an Exception.

Note that this implementation is not synchronized.

Example: equals(FloatMatrix2D A, FloatMatrix2D B) is defined as follows

  { some other tests not related to tolerance go here }
  float epsilon = tolerance();
  for (int row=rows; --row >= 0;) {
     for (int column=columns; --column >= 0;) {
        //if (!(A.getQuick(row,column) == B.getQuick(row,column))) return false;
        if (Math.abs(A.getQuick(row,column) - B.getQuick(row,column)) > epsilon) return false;
     }
  }
  return true;

Here are some example properties

`matrix`	`4 x 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0`	`4 x 4 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1`	`4 x 4 1 1 0 0 1 1 1 0 0 1 1 1 0 0 1 1`	`4 x 4 0 1 1 1 0 1 1 1 0 0 0 1 0 0 0 1`	`4 x 4 0 0 0 0 1 1 0 0 1 1 0 0 1 1 1 1`	`4 x 4 1 1 0 0 0 1 1 0 0 1 0 1 1 0 1 1`	`4 x 4 1 1 1 0 0 1 0 0 1 1 0 1 0 0 1 1`
`upperBandwidth`	`0`	`0`	`1`	`3`	`0`	`1`	`2`
`lowerBandwidth`	`0`	`0`	`1`	`0`	`3`	`3`	`2`
`semiBandwidth`	`1`	`1`	`2`	`4`	`4`	`4`	`3`
`description`	`zero`	`diagonal`	`tridiagonal`	`upper triangular`	`lower triangular`	`unstructured`	`unstructured`

Version:: 1.1, 28/May/2000 (fixed strange bugs involving NaN, -inf, inf)
Author:: wolfgang.hoschek@cern.ch, Piotr Wendykier (piotr.wendykier@gmail.com)
See Also:: Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static FloatProperty`	`DEFAULT` The default Property object; currently has `tolerance()==1.0E-5`.
`static FloatProperty`	`SEVEN` A Property object with `tolerance()==1.0E-7`.
`static FloatProperty`	`ZERO` A Property object with `tolerance()==0.0`.

Constructor Summary

Constructors
Constructor and Description

FloatProperty(float newTolerance)
Constructs an instance with a tolerance of Math.abs(newTolerance).

Constructors
Constructor and Description
`FloatProperty(float newTolerance)` Constructs an instance with a tolerance of `Math.abs(newTolerance)`.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`checkDense(FloatMatrix1D A)`
`void`	`checkDense(FloatMatrix2D A)`
`void`	`checkRectangular(FloatMatrix2D A)` Checks whether the given matrix `A` is rectangular.
`void`	`checkSparse(FloatMatrix1D A)`
`void`	`checkSparse(FloatMatrix2D A)`
`void`	`checkSquare(FloatMatrix2D A)` Checks whether the given matrix `A` is square.
`float`	`density(FloatMatrix2D A)` Returns the matrix's fraction of non-zero cells; `A.cardinality() / A.size()`.
`boolean`	`equals(FloatMatrix1D A, float value)` Returns whether all cells of the given matrix `A` are equal to the given value.
`boolean`	`equals(FloatMatrix1D A, FloatMatrix1D B)` Returns whether both given matrices `A` and `B` are equal.
`boolean`	`equals(FloatMatrix2D A, float value)` Returns whether all cells of the given matrix `A` are equal to the given value.
`boolean`	`equals(FloatMatrix2D A, FloatMatrix2D B)` Returns whether both given matrices `A` and `B` are equal.
`boolean`	`equals(FloatMatrix3D A, float value)` Returns whether all cells of the given matrix `A` are equal to the given value.
`boolean`	`equals(FloatMatrix3D A, FloatMatrix3D B)` Returns whether both given matrices `A` and `B` are equal.
`void`	`generateNonSingular(FloatMatrix2D A)` Modifies the given matrix square matrix `A` such that it is diagonally dominant by row and column, hence non-singular, hence invertible.
`boolean`	`isDiagonal(FloatMatrix2D A)` A matrix `A` is diagonal if `A[i,j] == 0` whenever `i != j`.
`boolean`	`isDiagonallyDominantByColumn(FloatMatrix2D A)` A matrix `A` is diagonally dominant by column if the absolute value of each diagonal element is larger than the sum of the absolute values of the off-diagonal elements in the corresponding column.
`boolean`	`isDiagonallyDominantByRow(FloatMatrix2D A)` A matrix `A` is diagonally dominant by row if the absolute value of each diagonal element is larger than the sum of the absolute values of the off-diagonal elements in the corresponding row.
`boolean`	`isIdentity(FloatMatrix2D A)` A matrix `A` is an identity matrix if `A[i,i] == 1` and all other cells are zero.
`boolean`	`isLowerBidiagonal(FloatMatrix2D A)` A matrix `A` is lower bidiagonal if `A[i,j]==0` unless `i==j \|\| i==j+1`.
`boolean`	`isLowerTriangular(FloatMatrix2D A)` A matrix `A` is lower triangular if `A[i,j]==0` whenever `i < j`.
`boolean`	`isNonNegative(FloatMatrix2D A)` A matrix `A` is non-negative if `A[i,j] >= 0` holds for all cells.
`boolean`	`isOrthogonal(FloatMatrix2D A)` A square matrix `A` is orthogonal if `A*transpose(A) = I`.
`boolean`	`isPositive(FloatMatrix2D A)` A matrix `A` is positive if `A[i,j] > 0` holds for all cells.
`boolean`	`isSingular(FloatMatrix2D A)` A matrix `A` is singular if it has no inverse, that is, iff `det(A)==0`.
`boolean`	`isSkewSymmetric(FloatMatrix2D A)` A square matrix `A` is skew-symmetric if `A = -transpose(A)`, that is `A[i,j] == -A[j,i]`.
`boolean`	`isSquare(FloatMatrix2D A)` A matrix `A` is square if it has the same number of rows and columns.
`boolean`	`isStrictlyLowerTriangular(FloatMatrix2D A)` A matrix `A` is strictly lower triangular if `A[i,j]==0` whenever `i <= j`.
`boolean`	`isStrictlyTriangular(FloatMatrix2D A)` A matrix `A` is strictly triangular if it is triangular and its diagonal elements all equal 0.
`boolean`	`isStrictlyUpperTriangular(FloatMatrix2D A)` A matrix `A` is strictly upper triangular if `A[i,j]==0` whenever `i >= j`.
`boolean`	`isSymmetric(FloatMatrix2D A)` A matrix `A` is symmetric if `A = tranpose(A)`, that is `A[i,j] == A[j,i]`.
`boolean`	`isTriangular(FloatMatrix2D A)` A matrix `A` is triangular iff it is either upper or lower triangular.
`boolean`	`isTridiagonal(FloatMatrix2D A)` A matrix `A` is tridiagonal if `A[i,j]==0` whenever `Math.abs(i-j) > 1`.
`boolean`	`isUnitTriangular(FloatMatrix2D A)` A matrix `A` is unit triangular if it is triangular and its diagonal elements all equal 1.
`boolean`	`isUpperBidiagonal(FloatMatrix2D A)` A matrix `A` is upper bidiagonal if `A[i,j]==0` unless `i==j \|\| i==j-1`.
`boolean`	`isUpperTriangular(FloatMatrix2D A)` A matrix `A` is upper triangular if `A[i,j]==0` whenever `i > j`.
`boolean`	`isZero(FloatMatrix2D A)` A matrix `A` is zero if all its cells are zero.
`int`	`lowerBandwidth(FloatMatrix2D A)` The lower bandwidth of a square matrix `A` is the maximum `i-j` for which `A[i,j]` is nonzero and `i > j`.
`int`	`semiBandwidth(FloatMatrix2D A)` Returns the semi-bandwidth of the given square matrix `A`.
`void`	`setTolerance(float newTolerance)` Sets the tolerance to `Math.abs(newTolerance)`.
`float`	`tolerance()` Returns the current tolerance.
`String`	`toString(FloatMatrix2D A)` Returns summary information about the given matrix `A`.
`int`	`upperBandwidth(FloatMatrix2D A)` The upper bandwidth of a square matrix `A` is the maximum `j-i` for which `A[i,j]` is nonzero and `j > i`.

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
- DEFAULT
```
public static final FloatProperty DEFAULT
```
  The default Property object; currently has tolerance()==1.0E-5.
- ZERO
```
public static final FloatProperty ZERO
```
  A Property object with tolerance()==0.0.
- SEVEN
```
public static final FloatProperty SEVEN
```
  A Property object with tolerance()==1.0E-7.

Constructor Detail
- FloatProperty
```
public FloatProperty(float newTolerance)
```
  Constructs an instance with a tolerance of Math.abs(newTolerance).

Method Detail

checkRectangular
```
public void checkRectangular(FloatMatrix2D A)
```
Checks whether the given matrix A is rectangular.

Throws:

IllegalArgumentException - if A.rows() < A.columns().

checkSquare
```
public void checkSquare(FloatMatrix2D A)
```
Checks whether the given matrix A is square.

Throws:

IllegalArgumentException - if A.rows() != A.columns().

checkDense

public void checkDense(FloatMatrix2D A)

checkDense

public void checkDense(FloatMatrix1D A)

checkSparse

public void checkSparse(FloatMatrix1D A)

checkSparse

public void checkSparse(FloatMatrix2D A)

density
```
public float density(FloatMatrix2D A)
```
Returns the matrix's fraction of non-zero cells; A.cardinality() / A.size().

equals
```
public boolean equals(FloatMatrix1D A,
             float value)
```
Returns whether all cells of the given matrix A are equal to the given value. The result is true if and only if A != null and ! (Math.abs(value - A[i]) > tolerance()) holds for all coordinates.

Parameters:
A - the first matrix to compare.
value - the value to compare against.

Returns:
true if the matrix is equal to the value; false otherwise.

equals
```
public boolean equals(FloatMatrix1D A,
             FloatMatrix1D B)
```
Returns whether both given matrices A and B are equal. The result is true if A==B. Otherwise, the result is true if and only if both arguments are != null, have the same size and ! (Math.abs(A[i] - B[i]) > tolerance()) holds for all indexes.

Parameters:
A - the first matrix to compare.
B - the second matrix to compare.

Returns:
true if both matrices are equal; false otherwise.

equals
```
public boolean equals(FloatMatrix2D A,
             float value)
```
Returns whether all cells of the given matrix A are equal to the given value. The result is true if and only if A != null and ! (Math.abs(value - A[row,col]) > tolerance()) holds for all coordinates.

Parameters:
A - the first matrix to compare.
value - the value to compare against.

Returns:
true if the matrix is equal to the value; false otherwise.

equals
```
public boolean equals(FloatMatrix2D A,
             FloatMatrix2D B)
```
Returns whether both given matrices A and B are equal. The result is true if A==B. Otherwise, the result is true if and only if both arguments are != null, have the same number of columns and rows and ! (Math.abs(A[row,col] - B[row,col]) > tolerance()) holds for all coordinates.

Parameters:
A - the first matrix to compare.
B - the second matrix to compare.

Returns:
true if both matrices are equal; false otherwise.

equals
```
public boolean equals(FloatMatrix3D A,
             float value)
```
Returns whether all cells of the given matrix A are equal to the given value. The result is true if and only if A != null and ! (Math.abs(value - A[slice,row,col]) > tolerance()) holds for all coordinates.

Parameters:
A - the first matrix to compare.
value - the value to compare against.

Returns:
true if the matrix is equal to the value; false otherwise.

equals
```
public boolean equals(FloatMatrix3D A,
             FloatMatrix3D B)
```
Returns whether both given matrices A and B are equal. The result is true if A==B. Otherwise, the result is true if and only if both arguments are != null, have the same number of columns, rows and slices, and ! (Math.abs(A[slice,row,col] - B[slice,row,col]) > tolerance()) holds for all coordinates.

Parameters:
A - the first matrix to compare.
B - the second matrix to compare.

Returns:
true if both matrices are equal; false otherwise.

generateNonSingular
```
public void generateNonSingular(FloatMatrix2D A)
```
Modifies the given matrix square matrix A such that it is diagonally dominant by row and column, hence non-singular, hence invertible. For testing purposes only.

Parameters:
A - the square matrix to modify.

Throws:

IllegalArgumentException - if !isSquare(A).

isDiagonal
```
public boolean isDiagonal(FloatMatrix2D A)
```
A matrix A is diagonal if A[i,j] == 0 whenever i != j. Matrix may but need not be square.

isDiagonallyDominantByColumn
```
public boolean isDiagonallyDominantByColumn(FloatMatrix2D A)
```
A matrix A is diagonally dominant by column if the absolute value of each diagonal element is larger than the sum of the absolute values of the off-diagonal elements in the corresponding column. returns true if for all i: abs(A[i,i]) > Sum(abs(A[j,i])); j != i. Matrix may but need not be square.
Note: Ignores tolerance.

isDiagonallyDominantByRow
```
public boolean isDiagonallyDominantByRow(FloatMatrix2D A)
```
A matrix A is diagonally dominant by row if the absolute value of each diagonal element is larger than the sum of the absolute values of the off-diagonal elements in the corresponding row. returns true if for all i: abs(A[i,i]) > Sum(abs(A[i,j])); j != i. Matrix may but need not be square.
Note: Ignores tolerance.

isIdentity
```
public boolean isIdentity(FloatMatrix2D A)
```
A matrix A is an identity matrix if A[i,i] == 1 and all other cells are zero. Matrix may but need not be square.

isLowerBidiagonal
```
public boolean isLowerBidiagonal(FloatMatrix2D A)
```
A matrix A is lower bidiagonal if A[i,j]==0 unless i==j || i==j+1. Matrix may but need not be square.

isLowerTriangular
```
public boolean isLowerTriangular(FloatMatrix2D A)
```
A matrix A is lower triangular if A[i,j]==0 whenever i < j. Matrix may but need not be square.

isNonNegative
```
public boolean isNonNegative(FloatMatrix2D A)
```
A matrix A is non-negative if A[i,j] >= 0 holds for all cells.
Note: Ignores tolerance.

isOrthogonal
```
public boolean isOrthogonal(FloatMatrix2D A)
```
A square matrix A is orthogonal if A*transpose(A) = I.

Throws:

IllegalArgumentException - if !isSquare(A).

isPositive
```
public boolean isPositive(FloatMatrix2D A)
```
A matrix A is positive if A[i,j] > 0 holds for all cells.
Note: Ignores tolerance.

isSingular
```
public boolean isSingular(FloatMatrix2D A)
```
A matrix A is singular if it has no inverse, that is, iff det(A)==0.

isSkewSymmetric
```
public boolean isSkewSymmetric(FloatMatrix2D A)
```
A square matrix A is skew-symmetric if A = -transpose(A), that is A[i,j] == -A[j,i].

Throws:

IllegalArgumentException - if !isSquare(A).

isSquare
```
public boolean isSquare(FloatMatrix2D A)
```
A matrix A is square if it has the same number of rows and columns.

isStrictlyLowerTriangular
```
public boolean isStrictlyLowerTriangular(FloatMatrix2D A)
```
A matrix A is strictly lower triangular if A[i,j]==0 whenever i <= j. Matrix may but need not be square.

isStrictlyTriangular
```
public boolean isStrictlyTriangular(FloatMatrix2D A)
```
A matrix A is strictly triangular if it is triangular and its diagonal elements all equal 0. Matrix may but need not be square.

isStrictlyUpperTriangular
```
public boolean isStrictlyUpperTriangular(FloatMatrix2D A)
```
A matrix A is strictly upper triangular if A[i,j]==0 whenever i >= j. Matrix may but need not be square.

isSymmetric
```
public boolean isSymmetric(FloatMatrix2D A)
```
A matrix A is symmetric if A = tranpose(A), that is A[i,j] == A[j,i].

Throws:

IllegalArgumentException - if !isSquare(A).

isTriangular
```
public boolean isTriangular(FloatMatrix2D A)
```
A matrix A is triangular iff it is either upper or lower triangular. Matrix may but need not be square.

isTridiagonal
```
public boolean isTridiagonal(FloatMatrix2D A)
```
A matrix A is tridiagonal if A[i,j]==0 whenever Math.abs(i-j) > 1. Matrix may but need not be square.

isUnitTriangular
```
public boolean isUnitTriangular(FloatMatrix2D A)
```
A matrix A is unit triangular if it is triangular and its diagonal elements all equal 1. Matrix may but need not be square.

isUpperBidiagonal
```
public boolean isUpperBidiagonal(FloatMatrix2D A)
```
A matrix A is upper bidiagonal if A[i,j]==0 unless i==j || i==j-1. Matrix may but need not be square.

isUpperTriangular
```
public boolean isUpperTriangular(FloatMatrix2D A)
```
A matrix A is upper triangular if A[i,j]==0 whenever i > j. Matrix may but need not be square.

isZero
```
public boolean isZero(FloatMatrix2D A)
```
A matrix A is zero if all its cells are zero.

lowerBandwidth
```
public int lowerBandwidth(FloatMatrix2D A)
```
The lower bandwidth of a square matrix A is the maximum i-j for which A[i,j] is nonzero and i > j. A banded matrix has a "band" about the diagonal. Diagonal, tridiagonal and triangular matrices are special cases.

Parameters:
A - the square matrix to analyze.

Returns:
the lower bandwith.

Throws:

IllegalArgumentException - if !isSquare(A).
See Also:
semiBandwidth(FloatMatrix2D), upperBandwidth(FloatMatrix2D)

semiBandwidth

public int semiBandwidth(FloatMatrix2D A)

Returns the semi-bandwidth of the given square matrix A. A banded matrix has a "band" about the diagonal. It is a matrix with all cells equal to zero, with the possible exception of the cells along the diagonal line, the k diagonal lines above the diagonal, and the k diagonal lines below the diagonal. The semi-bandwith l is the number k+1. The bandwidth p is the number 2*k + 1. For example, a tridiagonal matrix corresponds to k=1, l=2, p=3, a diagonal or zero matrix corresponds to k=0, l=1, p=1,

The upper bandwidth is the maximum j-i for which A[i,j] is nonzero and j > i. The lower bandwidth is the maximum i-j for which A[i,j] is nonzero and i > j. Diagonal, tridiagonal and triangular matrices are special cases.

Examples:

`matrix`	`4 x 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0`	`4 x 4 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1`	`4 x 4 1 1 0 0 1 1 1 0 0 1 1 1 0 0 1 1`	`4 x 4 0 1 1 1 0 1 1 1 0 0 0 1 0 0 0 1`	`4 x 4 0 0 0 0 1 1 0 0 1 1 0 0 1 1 1 1`	`4 x 4 1 1 0 0 0 1 1 0 0 1 0 1 1 0 1 1`	`4 x 4 1 1 1 0 0 1 0 0 1 1 0 1 0 0 1 1`
`upperBandwidth`	`0`	`0`	`1`	`3`	`0`	`1`	`2`
`lowerBandwidth`	`0`	`0`	`1`	`0`	`3`	`3`	`2`
`semiBandwidth`	`1`	`1`	`2`	`4`	`4`	`4`	`3`
`description`	`zero`	`diagonal`	`tridiagonal`	`upper triangular`	`lower triangular`	`unstructured`	`unstructured`

Parameters:: A - the square matrix to analyze.
Returns:: the semi-bandwith l.
Throws:: IllegalArgumentException - if !isSquare(A).
See Also:: lowerBandwidth(FloatMatrix2D), upperBandwidth(FloatMatrix2D)

setTolerance
```
public void setTolerance(float newTolerance)
```
Sets the tolerance to Math.abs(newTolerance).

Throws:

UnsupportedOperationException - if this==DEFAULT || this==ZERO || this==TWELVE.

tolerance
```
public float tolerance()
```
Returns the current tolerance.

toString

public String toString(FloatMatrix2D A)

Returns summary information about the given matrix A. That is a String with (propertyName, propertyValue) pairs. Useful for debugging or to quickly get the rough picture of a matrix. For example,

         density                      : 0.9
         isDiagonal                   : false
         isDiagonallyDominantByRow    : false
         isDiagonallyDominantByColumn : false
         isIdentity                   : false
         isLowerBidiagonal            : false
         isLowerTriangular            : false
         isNonNegative                : true
         isOrthogonal                 : Illegal operation or error: Matrix must be square.
         isPositive                   : true
         isSingular                   : Illegal operation or error: Matrix must be square.
         isSkewSymmetric              : Illegal operation or error: Matrix must be square.
         isSquare                     : false
         isStrictlyLowerTriangular    : false
         isStrictlyTriangular         : false
         isStrictlyUpperTriangular    : false
         isSymmetric                  : Illegal operation or error: Matrix must be square.
         isTriangular                 : false
         isTridiagonal                : false
         isUnitTriangular             : false
         isUpperBidiagonal            : false
         isUpperTriangular            : false
         isZero                       : false
         lowerBandwidth               : Illegal operation or error: Matrix must be square.
         semiBandwidth                : Illegal operation or error: Matrix must be square.
         upperBandwidth               : Illegal operation or error: Matrix must be square.

upperBandwidth
```
public int upperBandwidth(FloatMatrix2D A)
```
The upper bandwidth of a square matrix A is the maximum j-i for which A[i,j] is nonzero and j > i. A banded matrix has a "band" about the diagonal. Diagonal, tridiagonal and triangular matrices are special cases.

Parameters:
A - the square matrix to analyze.

Returns:
the upper bandwith.

Throws:

IllegalArgumentException - if !isSquare(A).
See Also:
semiBandwidth(FloatMatrix2D), lowerBandwidth(FloatMatrix2D)

Class FloatProperty

Field Summary

Constructor Summary

Method Summary

Methods inherited from class cern.colt.PersistentObject

Methods inherited from class java.lang.Object

Field Detail

DEFAULT

ZERO

SEVEN

Constructor Detail

FloatProperty

Method Detail

checkRectangular

checkSquare

checkDense

checkDense

checkSparse

checkSparse

density

equals

equals

equals

equals

equals

equals

generateNonSingular

isDiagonal

isDiagonallyDominantByColumn

isDiagonallyDominantByRow

isIdentity

isLowerBidiagonal

isLowerTriangular

isNonNegative

isOrthogonal

isPositive

isSingular

isSkewSymmetric

isSquare

isStrictlyLowerTriangular

isStrictlyTriangular

isStrictlyUpperTriangular

isSymmetric

isTriangular

isTridiagonal

isUnitTriangular

isUpperBidiagonal

isUpperTriangular

isZero

lowerBandwidth

semiBandwidth

setTolerance

tolerance

toString

upperBandwidth