/** * 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; }