|
|||||||||
| PREV CLASS NEXT CLASS | All Classes | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
java.lang.Objectcern.colt.PersistentObject
cern.colt.matrix.AbstractMatrix
cern.colt.matrix.AbstractMatrix2D
cern.colt.matrix.tfloat.FloatMatrix2D
cern.colt.matrix.tfloat.impl.WrapperFloatMatrix2D
cern.colt.matrix.tfloat.impl.DenseLargeFloatMatrix2D
public class DenseLargeFloatMatrix2D
Dense 2-d matrix holding float elements. First see the package summary and javadoc tree view to get the broad picture.
Implementation:
This data structure allows to store more than 2^31 elements. Internally holds one two-dimensional array, elements[rows][columns]. Note that this implementation is not synchronized.
Time complexity:
O(1) (i.e. constant time) for the basic operations get, getQuick, set, setQuick and size.
| Constructor Summary | |
|---|---|
DenseLargeFloatMatrix2D(int rows,
int columns)
|
|
| Method Summary | |
|---|---|
void |
dct2(boolean scale)
Computes the 2D discrete cosine transform (DCT-II) of this matrix. |
void |
dctColumns(boolean scale)
Computes the discrete cosine transform (DCT-II) of each column of this matrix. |
void |
dctRows(boolean scale)
Computes the discrete cosine transform (DCT-II) of each row of this matrix. |
void |
dht2()
Computes the 2D discrete Hartley transform (DHT) of this matrix. |
void |
dhtColumns()
Computes the discrete Hartley transform (DHT) of each column of this matrix. |
void |
dhtRows()
Computes the discrete Hartley transform (DHT) of each row of this matrix. |
void |
dst2(boolean scale)
Computes the 2D discrete sine transform (DST-II) of this matrix. |
void |
dstColumns(boolean scale)
Computes the discrete sine transform (DST-II) of each column of this matrix. |
void |
dstRows(boolean scale)
Computes the discrete sine transform (DST-II) of each row of this matrix. |
float[][] |
elements()
Returns the elements of this matrix. |
void |
fft2()
Computes the 2D discrete Fourier transform (DFT) of this matrix. |
DenseLargeFComplexMatrix2D |
getFft2()
Returns new complex matrix which is the 2D discrete Fourier transform (DFT) of this matrix. |
DenseLargeFComplexMatrix2D |
getFftColumns()
Returns new complex matrix which is the discrete Fourier transform (DFT) of each column of this matrix. |
DenseLargeFComplexMatrix2D |
getFftRows()
Returns new complex matrix which is the discrete Fourier transform (DFT) of each row of this matrix. |
DenseLargeFComplexMatrix2D |
getIfft2(boolean scale)
Returns new complex matrix which is the 2D inverse of the discrete Fourier transform (IDFT) of this matrix. |
DenseLargeFComplexMatrix2D |
getIfftColumns(boolean scale)
Returns new complex matrix which is the inverse of the discrete Fourier transform (IDFT) of each column of this matrix. |
DenseLargeFComplexMatrix2D |
getIfftRows(boolean scale)
Returns new complex matrix which is the inverse of the discrete Fourier transform (IDFT) of each row of this matrix. |
float |
getQuick(int row,
int column)
Returns the matrix cell value at coordinate [row,column]. |
void |
idct2(boolean scale)
Computes the 2D inverse of the discrete cosine transform (DCT-III) of this matrix. |
void |
idctColumns(boolean scale)
Computes the inverse of the discrete cosine transform (DCT-III) of each column of this matrix. |
void |
idctRows(boolean scale)
Computes the inverse of the discrete cosine transform (DCT-III) of each row of this matrix. |
void |
idht2(boolean scale)
Computes the 2D inverse of the discrete Hartley transform (IDHT) of this matrix. |
void |
idhtColumns(boolean scale)
Computes the inverse of the discrete Hartley transform (IDHT) of each column of this matrix. |
void |
idhtRows(boolean scale)
Computes the inverse of the discrete Hartley transform (IDHT) of each row of this matrix. |
void |
idst2(boolean scale)
Computes the 2D inverse of the discrete sine transform (DST-III) of this matrix. |
void |
idstColumns(boolean scale)
Computes the inverse of the discrete sine transform (DST-III) of each column of this matrix. |
void |
idstRows(boolean scale)
Computes the inverse of the discrete sine transform (DST-III) of each row of this matrix. |
void |
ifft2(boolean scale)
Computes the 2D inverse of the discrete Fourier transform (IDFT) of this matrix. |
FloatMatrix2D |
like(int rows,
int columns)
Construct and returns a new empty matrix of the same dynamic type as the receiver, having the specified number of rows and columns. |
FloatMatrix1D |
like1D(int size)
Construct and returns a new 1-d matrix of the corresponding dynamic type, entirelly independent of the receiver. |
void |
setQuick(int row,
int column,
float value)
Sets the matrix cell at coordinate [row,column] to the specified value. |
| Methods inherited from class cern.colt.matrix.tfloat.impl.WrapperFloatMatrix2D |
|---|
assign, assign, equals, equals, vectorize, viewColumn, viewColumnFlip, viewDice, viewPart, viewRow, viewRowFlip, viewSelection, viewStrides |
| Methods inherited from class cern.colt.matrix.tfloat.FloatMatrix2D |
|---|
aggregate, aggregate, aggregate, aggregate, assign, assign, assign, assign, assign, assign, assign, cardinality, copy, forEachNonZero, get, getMaxLocation, getMinLocation, getNegativeValues, getNonZeros, getPositiveValues, like, normalize, set, toArray, toString, viewSelection, viewSelection, viewSorted, zAssign8Neighbors, zMult, zMult, zMult, zMult, zSum |
| Methods inherited from class cern.colt.matrix.AbstractMatrix2D |
|---|
checkShape, checkShape, columns, columnStride, index, rows, rowStride, size, toStringShort |
| Methods inherited from class cern.colt.matrix.AbstractMatrix |
|---|
ensureCapacity, isView, trimToSize |
| Methods inherited from class cern.colt.PersistentObject |
|---|
clone |
| Methods inherited from class java.lang.Object |
|---|
getClass, hashCode, notify, notifyAll, wait, wait, wait |
| Constructor Detail |
|---|
public DenseLargeFloatMatrix2D(int rows,
int columns)
| Method Detail |
|---|
public void dct2(boolean scale)
dct2 in class WrapperFloatMatrix2Dscale - if true then scaling is performedpublic void dctColumns(boolean scale)
dctColumns in class WrapperFloatMatrix2Dscale - if true then scaling is performedpublic void dctRows(boolean scale)
dctRows in class WrapperFloatMatrix2Dscale - if true then scaling is performedpublic void dht2()
dht2 in class WrapperFloatMatrix2Dpublic void dhtColumns()
dhtColumns in class WrapperFloatMatrix2Dpublic void dhtRows()
dhtRows in class WrapperFloatMatrix2Dpublic void dst2(boolean scale)
dst2 in class WrapperFloatMatrix2Dscale - if true then scaling is performedpublic void dstColumns(boolean scale)
dstColumns in class WrapperFloatMatrix2Dscale - if true then scaling is performedpublic void dstRows(boolean scale)
dstRows in class WrapperFloatMatrix2Dscale - if true then scaling is performedpublic void fft2()
this[k1][2*k2] = Re[k1][k2] = Re[rows-k1][columns-k2],
this[k1][2*k2+1] = Im[k1][k2] = -Im[rows-k1][columns-k2],
0<k1<rows, 0<k2<columns/2,
this[0][2*k2] = Re[0][k2] = Re[0][columns-k2],
this[0][2*k2+1] = Im[0][k2] = -Im[0][columns-k2],
0<k2<columns/2,
this[k1][0] = Re[k1][0] = Re[rows-k1][0],
this[k1][1] = Im[k1][0] = -Im[rows-k1][0],
this[rows-k1][1] = Re[k1][columns/2] = Re[rows-k1][columns/2],
this[rows-k1][0] = -Im[k1][columns/2] = Im[rows-k1][columns/2],
0<k1<rows/2,
this[0][0] = Re[0][0],
this[0][1] = Re[0][columns/2],
this[rows/2][0] = Re[rows/2][0],
this[rows/2][1] = Re[rows/2][columns/2]
This method computes only half of the elements of the real transform. The
other half satisfies the symmetry condition. If you want the full real
forward transform, use getFft2. To get back the original
data, use ifft2.
fft2 in class WrapperFloatMatrix2DIllegalArgumentException - if the row size or the column size of this matrix is not a
power of 2 number.public DenseLargeFComplexMatrix2D getFft2()
getFft2 in class WrapperFloatMatrix2Dpublic DenseLargeFComplexMatrix2D getFftColumns()
getFftColumns in class WrapperFloatMatrix2Dpublic DenseLargeFComplexMatrix2D getFftRows()
getFftRows in class WrapperFloatMatrix2Dpublic DenseLargeFComplexMatrix2D getIfft2(boolean scale)
getIfft2 in class WrapperFloatMatrix2Dpublic DenseLargeFComplexMatrix2D getIfftColumns(boolean scale)
getIfftColumns in class WrapperFloatMatrix2Dpublic DenseLargeFComplexMatrix2D getIfftRows(boolean scale)
getIfftRows in class WrapperFloatMatrix2D
public float getQuick(int row,
int column)
FloatMatrix2DProvided 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): 0 <= column < columns() && 0 <= row < rows().
getQuick in class WrapperFloatMatrix2Drow - the index of the row-coordinate.column - the index of the column-coordinate.
public void idct2(boolean scale)
idct2 in class WrapperFloatMatrix2Dscale - if true then scaling is performedpublic void idctColumns(boolean scale)
idctColumns in class WrapperFloatMatrix2Dscale - if true then scaling is performedpublic void idctRows(boolean scale)
idctRows in class WrapperFloatMatrix2Dscale - if true then scaling is performedpublic void idht2(boolean scale)
idht2 in class WrapperFloatMatrix2Dscale - if true then scaling is performedpublic void idhtColumns(boolean scale)
idhtColumns in class WrapperFloatMatrix2Dscale - if true then scaling is performedpublic void idhtRows(boolean scale)
idhtRows in class WrapperFloatMatrix2Dscale - if true then scaling is performedpublic void idst2(boolean scale)
idst2 in class WrapperFloatMatrix2Dscale - if true then scaling is performedpublic void idstColumns(boolean scale)
idstColumns in class WrapperFloatMatrix2Dscale - if true then scaling is performedpublic void idstRows(boolean scale)
idstRows in class WrapperFloatMatrix2Dscale - if true then scaling is performedpublic void ifft2(boolean scale)
this[k1][2*k2] = Re[k1][k2] = Re[rows-k1][columns-k2],
this[k1][2*k2+1] = Im[k1][k2] = -Im[rows-k1][columns-k2],
0<k1<rows, 0<k2<columns/2,
this[0][2*k2] = Re[0][k2] = Re[0][columns-k2],
this[0][2*k2+1] = Im[0][k2] = -Im[0][columns-k2],
0<k2<columns/2,
this[k1][0] = Re[k1][0] = Re[rows-k1][0],
this[k1][1] = Im[k1][0] = -Im[rows-k1][0],
this[rows-k1][1] = Re[k1][columns/2] = Re[rows-k1][columns/2],
this[rows-k1][0] = -Im[k1][columns/2] = Im[rows-k1][columns/2],
0<k1<rows/2,
this[0][0] = Re[0][0],
this[0][1] = Re[0][columns/2],
this[rows/2][0] = Re[rows/2][0],
this[rows/2][1] = Re[rows/2][columns/2]
This method computes only half of the elements of the real transform. The
other half satisfies the symmetry condition. If you want the full real
inverse transform, use getIfft2.
ifft2 in class WrapperFloatMatrix2Dscale - if true then scaling is performed
IllegalArgumentException - if the row size or the column size of this matrix is not a
power of 2 number.
public void setQuick(int row,
int column,
float value)
FloatMatrix2DProvided 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): 0 <= column < columns() && 0 <= row < rows().
setQuick in class WrapperFloatMatrix2Drow - the index of the row-coordinate.column - the index of the column-coordinate.value - the value to be filled into the specified cell.public float[][] elements()
FloatMatrix2D
elements in class WrapperFloatMatrix2D
public FloatMatrix2D like(int rows,
int columns)
FloatMatrix2D
like in class WrapperFloatMatrix2Drows - the number of rows the matrix shall have.columns - the number of columns the matrix shall have.
public FloatMatrix1D like1D(int size)
FloatMatrix2D
like1D in class WrapperFloatMatrix2Dsize - the number of cells the matrix shall have.
|
|||||||||
| PREV CLASS NEXT CLASS | All Classes | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||