/**
* Returns the Hessenberg matrix H of the transform.
*
* @return the H matrix
*/
public RealMatrix getH()
{
if (cachedH == null)
{
int m = householderVectors.Length;
double[][] h = Java.CreateArray <double[][]>(m, m);// new double[m][m];
for (int i = 0; i < m; ++i)
{
if (i > 0)
{
// copy the entry of the lower sub-diagonal
h[i][i - 1] = householderVectors[i][i - 1];
}
// copy upper triangular part of the matrix
for (int j = i; j < m; ++j)
{
h[i][j] = householderVectors[i][j];
}
}
cachedH = MatrixUtils.CreateRealMatrix(h);
}
// return the cached matrix
return(cachedH);
}
/**
* Get the inverse of the decomposed matrix.
*
* @return the inverse matrix.
* @throws SingularMatrixException if the decomposed matrix is singular.
*/
public RealMatrix getInverse()
{
if (!isNonSingular())
{
throw new Exception("SingularMatrixException");
}
int m = realEigenvalues.Length;
double[][] invData = Java.CreateArray <double[][]>(m, m);// new double[m][m];
for (int i = 0; i < m; ++i)
{
double[] invI = invData[i];
for (int j = 0; j < m; ++j)
{
double invIJ = 0;
for (int k = 0; k < m; ++k)
{
double[] vK = eigenvectors[k].getDataRef();
invIJ += vK[i] * vK[j] / realEigenvalues[k];
}
invI[j] = invIJ;
}
}
return(MatrixUtils.CreateRealMatrix(invData));
}
/// <summary>
/// Used for computing the actual transformations (A and B matrices). These are stored in As and Bs.
/// </summary>
/// <param name="regLs">The reg ls.</param>
/// <param name="regRs">The reg rs.</param>
private void ComputeMllrTransforms(double[][][][][] regLs, double[][][][] regRs)
{
int len;
for (int c = 0; c < _nrOfClusters; c++)
{
As[c] = new float[_loader.NumStreams][][];
Bs[c] = new float[_loader.NumStreams][];
for (int i = 0; i < _loader.NumStreams; i++)
{
len = _loader.VectorLength[i];
As[c][i] = Java.CreateArray <float[][]>(len, len); //this.As[c][i] = new float[len][len];
Bs[c][i] = new float[len];
for (int j = 0; j < len; ++j)
{
var coef = new Array2DRowRealMatrix(regLs[c][i][j], false);
var solver = new LUDecomposition(coef).getSolver();
var vect = new ArrayRealVector(regRs[c][i][j], false);
var aBloc = solver.solve(vect);
for (int k = 0; k < len; ++k)
{
As[c][i][j][k] = (float)aBloc.getEntry(k);
}
Bs[c][i][j] = (float)aBloc.getEntry(len);
}
}
}
}
public Array2DRowRealMatrix(double[] v)
{
int nRows = v.Length;
data = Java.CreateArray <double[][]>(nRows, 1);// new double[nRows][1];
for (int row = 0; row < nRows; row++)
{
data[row][0] = v[row];
}
}
/**
* Returns the matrix P of the transform.
* <p>P is an orthogonal matrix, i.e. its inverse is also its transpose.</p>
*
* @return the P matrix
*/
public RealMatrix getP()
{
if (cachedP == null)
{
int n = householderVectors.Length;
int high = n - 1;
double[][] pa = Java.CreateArray <double[][]>(n, n);// new double[n][n];
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
pa[i][j] = (i == j) ? 1 : 0;
}
}
for (int m = high - 1; m >= 1; m--)
{
if (householderVectors[m][m - 1] != 0.0)
{
for (int i = m + 1; i <= high; i++)
{
ort[i] = householderVectors[i][m - 1];
}
for (int j = m; j <= high; j++)
{
double g = 0.0;
for (int i = m; i <= high; i++)
{
g += ort[i] * pa[i][j];
}
// Double division avoids possible underflow
g = (g / ort[m]) / householderVectors[m][m - 1];
for (int i = m; i <= high; i++)
{
pa[i][j] += g * ort[i];
}
}
}
}
cachedP = MatrixUtils.CreateRealMatrix(pa);
}
return(cachedP);
}
/** {@inheritDoc} */
public virtual double[][] getData()
{
var data = Java.CreateArray <double[][]>(getRowDimension(), getColumnDimension());
for (int i = 0; i < data.Length; ++i)
{
double[] dataI = data[i];
for (int j = 0; j < dataI.Length; ++j)
{
dataI[j] = getEntry(i, j);
}
}
return(data);
}
/// <summary>
/// Compute the MelCosine filter bank.
/// </summary>
protected virtual void ComputeMelCosine()
{
//melcosine = new double[cepstrumSize][numberMelFilters];
Melcosine = Java.CreateArray <double[][]>(CepstrumSize, NumberMelFilters);
var period = (double)2 * NumberMelFilters;
for (var i = 0; i < CepstrumSize; i++)
{
var frequency = 2 * Math.PI * i / period;
for (var j = 0; j < NumberMelFilters; j++)
{
Melcosine[i][j] = Math.Cos(frequency * (j + 0.5));
}
}
}
/**
* Calculates the eigen decomposition of the symmetric tridiagonal
* matrix. The Householder matrix is assumed to be the identity matrix.
*
* @param main Main diagonal of the symmetric tridiagonal form.
* @param secondary Secondary of the tridiagonal form.
* @throws MaxCountExceededException if the algorithm fails to converge.
* @since 3.1
*/
public EigenDecomposition(double[] main, double[] secondary)
{
isSymmetric = true;
this.main = main.Clone() as double[];
this.secondary = secondary.Clone() as double[];
transformer = null;
int size = main.Length;
var z = Java.CreateArray <double[][]>(size, size);// new double[size][size];
for (int i = 0; i < size; i++)
{
z[i][i] = 1.0;
}
findEigenVectors(z);
}
protected override void ComputeMelCosine()
{
Melcosine = Java.CreateArray <double[][]>(CepstrumSize, NumberMelFilters); //melcosine = new double[cepstrumSize][numberMelFilters];
Arrays.Fill(Melcosine[0], Math.Sqrt(1f / NumberMelFilters));
var normScale = Math.Sqrt(2f / NumberMelFilters);
for (var i = 1; i < CepstrumSize; i++)
{
var frequency = Math.PI * i / NumberMelFilters;
for (var j = 0; j < NumberMelFilters; j++)
{
Melcosine[i][j] = normScale * Math.Cos(frequency * (j + 0.5));
}
}
}
/** {@inheritDoc} */
public RealMatrix solve(RealMatrix b)
{
if (!isNonSingular())
{
throw new Exception("SingularMatrixException");
}
int m = realEigenvalues.Length;
if (b.getRowDimension() != m)
{
throw new Exception("DimensionMismatchException");
}
int nColB = b.getColumnDimension();
double[][] bp = Java.CreateArray <double[][]>(m, nColB);// new double[m][nColB];
double[] tmpCol = new double[m];
for (int k = 0; k < nColB; ++k)
{
for (int i = 0; i < m; ++i)
{
tmpCol[i] = b.getEntry(i, k);
bp[i][k] = 0;
}
for (int i = 0; i < m; ++i)
{
ArrayRealVector v = eigenvectors[i];
double[] vData = v.getDataRef();
double s = 0;
for (int j = 0; j < m; ++j)
{
s += v.getEntry(j) * tmpCol[j];
}
s /= realEigenvalues[i];
for (int j = 0; j < m; ++j)
{
bp[j][k] += s * vData[j];
}
}
}
return(new Array2DRowRealMatrix(bp, false));
}
/**
* Returns the transpose of the matrix Q of the transform.
* <p>Q is an orthogonal matrix, i.e. its transpose is also its inverse.</p>
* @return the Q matrix
*/
public RealMatrix getQT()
{
if (cachedQt == null)
{
int m = householderVectors.Length;
var qta = Java.CreateArray <double[][]>(m, m);
// build up first part of the matrix by applying Householder transforms
for (int k = m - 1; k >= 1; --k)
{
double[] hK = householderVectors[k - 1];
qta[k][k] = 1;
if (hK[k] != 0.0)
{
double inv = 1.0 / (secondary[k - 1] * hK[k]);
double beta = 1.0 / secondary[k - 1];
qta[k][k] = 1 + beta * hK[k];
for (int i = k + 1; i < m; ++i)
{
qta[k][i] = beta * hK[i];
}
for (int j = k + 1; j < m; ++j)
{
beta = 0;
for (int i = k + 1; i < m; ++i)
{
beta += qta[j][i] * hK[i];
}
beta *= inv;
qta[j][k] = beta * hK[k];
for (int i = k + 1; i < m; ++i)
{
qta[j][i] += beta * hK[i];
}
}
}
}
qta[0][0] = 1;
cachedQt = MatrixUtils.CreateRealMatrix(qta);
}
// return the cached matrix
return(cachedQt);
}
private void Init()
{
int len = _loader.VectorLength[0];
RegLs = new double[_nrOfClusters][][][][];
RegRs = new double[_nrOfClusters][][][];
for (int i = 0; i < _nrOfClusters; i++)
{
RegLs[i] = new double[_loader.NumStreams][][][];
RegRs[i] = new double[_loader.NumStreams][][];
for (int j = 0; j < _loader.NumStreams; j++)
{
len = _loader.VectorLength[j];
RegLs[i][j] = Java.CreateArray <double[][][]>(len, len + 1, len + 1); //this.regLs[i][j] = new double[len][len + 1][len + 1];
RegRs[i][j] = Java.CreateArray <double[][]>(len, len + 1); // this.regRs[i][j] = new double[len][len + 1];
}
}
}
public Array2DRowRealMatrix subtract(Array2DRowRealMatrix m)
{
//MatrixUtils.checkSubtractionCompatible(this, m);
int rowCount = getRowDimension();
int columnCount = getColumnDimension();
double[][] outData = Java.CreateArray <double[][]>(rowCount, columnCount);// new double[rowCount][columnCount];
for (int row = 0; row < rowCount; row++)
{
double[] dataRow = data[row];
double[] mRow = m.data[row];
double[] outDataRow = outData[row];
for (int col = 0; col < columnCount; col++)
{
outDataRow[col] = dataRow[col] - mRow[col];
}
}
return(new Array2DRowRealMatrix(outData, false));
}
/// <summary>
///Read the transformation from a file
/// </summary>
/// <param name="filePath">The file path.</param>
public void Load(string filePath)
{
//TODO: IMPLEMENT A LESS MEMORY CONSUMING METHOD
var input = new Scanner(File.ReadAllText(filePath));
int numStreams, nMllrClass;
int[] vectorLength = new int[1];
nMllrClass = input.NextInt();
Debug.Assert(nMllrClass == 1);
numStreams = input.NextInt();
As = new float[nMllrClass][][][];
Bs = new float[nMllrClass][][];
for (int i = 0; i < numStreams; i++)
{
vectorLength[i] = input.NextInt();
int length = vectorLength[i];
As[0] = Java.CreateArray <float[][][]>(numStreams, length, length); //this.As[0] = new float[numStreams][length][length];
Bs[0] = Java.CreateArray <float[][]>(numStreams, length); //this.Bs[0] = new float[numStreams][length];
for (int j = 0; j < length; j++)
{
for (int k = 0; k < length; ++k)
{
As[0][i][j][k] = input.NextFloat();
}
}
for (int j = 0; j < length; j++)
{
Bs[0][i][j] = input.NextFloat();
}
}
//input.close();
}
public Array2DRowRealMatrix multiply(Array2DRowRealMatrix m)
{
//MatrixUtils.checkMultiplicationCompatible(this, m);
int nRows = getRowDimension();
int nCols = m.getColumnDimension();
int nSum = getColumnDimension();
double[][] outData = Java.CreateArray <double[][]>(nRows, nCols);// new double[nRows][nCols];
// Will hold a column of "m".
double[] mCol = new double[nSum];
double[][] mData = m.data;
// Multiply.
for (int col = 0; col < nCols; col++)
{
// Copy all elements of column "col" of "m" so that
// will be in contiguous memory.
for (int mRow = 0; mRow < nSum; mRow++)
{
mCol[mRow] = mData[mRow][col];
}
for (int row = 0; row < nRows; row++)
{
double[] dataRow = data[row];
double sum = 0;
for (int i = 0; i < nSum; i++)
{
sum += dataRow[i] * mCol[i];
}
outData[row][col] = sum;
}
}
return(new Array2DRowRealMatrix(outData, false));
}
/**
* Returns the tridiagonal matrix T of the transform.
* @return the T matrix
*/
public RealMatrix getT()
{
if (cachedT == null)
{
int m = main.Length;
double[][] ta = Java.CreateArray <double[][]>(m, m);
for (int i = 0; i < m; ++i)
{
ta[i][i] = main[i];
if (i > 0)
{
ta[i][i - 1] = secondary[i - 1];
}
if (i < main.Length - 1)
{
ta[i][i + 1] = secondary[i];
}
}
cachedT = MatrixUtils.CreateRealMatrix(ta);
}
// return the cached matrix
return(cachedT);
}
public Array2DRowRealMatrix(int rowDimension, int columnDimension)
{
data = Java.CreateArray <double[][]>(rowDimension, columnDimension); // new double[rowDimension][columnDimension];
}
internal static int[] AlignTextSimple(List <string> database, List <string> query, int offset)
{
int n = database.Count + 1;
int m = query.Count + 1;
int[][] f = Java.CreateArray <int[][]>(n, m);// new int[n][];
f[0][0] = 0;
for (int i = 1; i < n; ++i)
{
f[i][0] = i;
}
for (int j = 1; j < m; ++j)
{
f[0][j] = j;
}
for (int i = 1; i < n; ++i)
{
for (int j = 1; j < m; ++j)
{
int match = f[i - 1][j - 1];
var refWord = database[i - 1];
var queryWord = query[j - 1];
if (!refWord.Equals(queryWord))
{
++match;
}
int insert = f[i][j - 1] + 1;
int delete = f[i - 1][j] + 1;
f[i][j] = Math.Min(match, Math.Min(insert, delete));
}
}
--n;
--m;
int[] alignment = new int[m];
Arrays.Fill(alignment, -1);
while (m > 0)
{
if (n == 0)
{
--m;
}
else
{
var refWord = database[n - 1];
var queryWord = query[m - 1];
if (f[n - 1][m - 1] <= f[n - 1][m - 1] && f[n - 1][m - 1] <= f[n][m - 1] && refWord.Equals(queryWord))
{
alignment[--m] = --n + offset;
}
else
{
if (f[n - 1][m] < f[n][m - 1])
{
--n;
}
else
{
--m;
}
}
}
}
return(alignment);
}
private readonly int[][] _ids; //id[featureStreamIdx][gaussianIndex]
public MixtureComponentSetScores(int numStreams, int gauNum, long frameStartSample)
{
_scores = Java.CreateArray <float[][]>(numStreams, gauNum); // new float[numStreams][gauNum];
_ids = Java.CreateArray <int[][]>(numStreams, gauNum); //new int[numStreams][gauNum];
FrameStartSample = frameStartSample;
}
