public static void Log(DenseMatrix Z, DenseMatrix X) { // Dimension check if (Z.nCols != X.nCols || Z.nCols != X.nCols) { throw new Exception("Dimension mismatch."); } // Computation var nRows = Z.nRows; var nCols = Z.nCols; Parallel.For(0, nCols, new ParallelOptions { MaxDegreeOfParallelism = MaxMultiThreadDegree }, IdxCol => { var zVal = Z.DenseMatrixValue[IdxCol].VectorValue; var xVal = X.DenseMatrixValue[IdxCol].VectorValue; for (int IdxRow = 0; IdxRow < nRows; ++IdxRow) { zVal[IdxRow] = (float)Math.Log((double)xVal[IdxRow]); } }); }
/* * Set the rows of a matrix to zero if the corresponding rows of a column vector are negative */ public static void SetRowsToZeroGivenColVector(DenseMatrix Z, DenseColumnVector x) { int nCols = Z.nCols; List<int> IdxNegX = new List<int>(); var xVal = x.VectorValue; int xDim = x.Dim; for (int IdxRow = 0; IdxRow < xDim; ++IdxRow ) { if (xVal[IdxRow]<0.0f) { IdxNegX.Add(IdxRow); } } Parallel.For(0, nCols, new ParallelOptions { MaxDegreeOfParallelism = MaxMultiThreadDegree }, IdxCol => { var ZVal = Z.DenseMatrixValue[IdxCol].VectorValue; int nCnt = IdxNegX.Count; for (int IdxRow = 0; IdxRow < nCnt; ++IdxRow) { ZVal[IdxNegX[IdxRow]] = 0.0f; } }); }
/* * Z = X*Y, where X and Y are dense. * Only nonzero positions of Z will be computed if Z is sparse. */ public static void MatrixMultiplyMatrix(SparseMatrix Z, DenseMatrix X, DenseMatrix Y) { // Dimension check if (Z.nRows != X.nRows || Z.nCols != Y.nCols || X.nCols != Y.nRows) { throw new Exception("Matrix dimension mismatch in multiplication."); } int total = Z.nCols ; int process_len = (total + THREADNUM - 1) / THREADNUM; Parallel.For(0, THREADNUM, new ParallelOptions{ MaxDegreeOfParallelism = MaxMultiThreadDegree}, thread_idx => { for (int t = 0; t < process_len; t++) { int IdxCol = thread_idx * process_len + t; if (IdxCol < total) { var yVector = Y.DenseMatrixValue[IdxCol].VectorValue; SparseColumnVector z = Z.SparseColumnVectors[IdxCol]; var zVal = z.Val; var zKey = z.Key; int nNonzero = z.nNonzero; for (int IdxRow = 0; IdxRow < nNonzero; ++IdxRow) { zVal[IdxRow] = 0; } for (int Idx = 0; Idx < X.nCols; ++ Idx) { // Compute the (IdxTrueRow, IdxCol)-th entry of Z, stored at (IdxRow, IdxCol) var xVector = X.DenseMatrixValue[Idx].VectorValue; var y = yVector[Idx]; for (int IdxRow = 0; IdxRow < nNonzero; ++ IdxRow) { // Get the actual row index of Z zVal[IdxRow] += xVector[zKey[IdxRow]] * y; } } } else break; } }); }
/* * Z = X - Y */ public static void MatrixSubtractMatrix(DenseMatrix Z, DenseMatrix X, DenseMatrix Y) { if (Z.nCols != X.nCols || Z.nRows != X.nRows || Z.nCols != Y.nCols || Z.nRows != Y.nRows) { throw new Exception("Dimension mismatch."); } Parallel.For(0, Z.nCols, new ParallelOptions { MaxDegreeOfParallelism = MaxMultiThreadDegree }, IdxCol => { var zVal = Z.DenseMatrixValue[IdxCol].VectorValue; var xVal = X.DenseMatrixValue[IdxCol].VectorValue; var yVal = Y.DenseMatrixValue[IdxCol].VectorValue; int nRows = Z.nRows; for (int IdxRow = 0; IdxRow < nRows; IdxRow++) { zVal[IdxRow] = xVal[IdxRow] - yVal[IdxRow]; } }); }
/* * Z = x ./ Z or b = bsxfun(@rdivide, x, Z) * Vector divide by matrix */ public static void bsxfunVectorDivideMatrix(DenseMatrix Z, DenseColumnVector x) { // Dimension check if (x.Dim != Z.nRows) { throw new Exception("Dimension mismatch."); } // Computation int nRows = Z.nRows; var xVal = x.VectorValue; Parallel.For(0, Z.nCols, new ParallelOptions { MaxDegreeOfParallelism = MaxMultiThreadDegree }, IdxCol => { var zVal = Z.DenseMatrixValue[IdxCol].VectorValue; for (int IdxRow = 0; IdxRow < nRows; ++IdxRow) { zVal[IdxRow] = xVal[IdxRow] / (zVal[IdxRow]+1e-12f); } }); }
public static void ElementwiseMatrixDivideMatrix(DenseMatrix Z, DenseMatrix X, DenseMatrix Y) { if (Z.nRows != X.nRows || Z.nCols != X.nCols || Z.nRows != Y.nRows || Z.nCols != Y.nCols) { throw new Exception("Dimension mismatch."); } int nRows = Z.nRows; Parallel.For(0, Z.nCols, new ParallelOptions { MaxDegreeOfParallelism = MaxMultiThreadDegree }, IdxCol => { var zVal = Z.DenseMatrixValue[IdxCol].VectorValue; var xVal = X.DenseMatrixValue[IdxCol].VectorValue; var yVal = Y.DenseMatrixValue[IdxCol].VectorValue; for (int IdxRow = 0; IdxRow < nRows; ++IdxRow) { zVal[IdxRow] = xVal[IdxRow] / (yVal[IdxRow]+1e-12f); } }); }
public static void ElementwiseMatrixMultiplyMatrix(SparseMatrix Z, SparseMatrix X, DenseMatrix Y) { // Dimension check if (X.nCols != Y.nCols || X.nRows != Y.nRows || Z.nCols != X.nCols || Z.nRows != X.nRows) { throw new Exception("Dimension mismatch during elementwise matrix multiplication."); } // Elementwise matrix multiplication Parallel.For(0, Z.nCols, new ParallelOptions { MaxDegreeOfParallelism = MaxMultiThreadDegree }, IdxCol => { var zVal = Z.SparseColumnVectors[IdxCol].Val; var xVal = X.SparseColumnVectors[IdxCol].Val; var yVal = Y.DenseMatrixValue[IdxCol].VectorValue; var zKey = Z.SparseColumnVectors[IdxCol].Key; int nNonzero = Z.SparseColumnVectors[IdxCol].nNonzero; for (int IdxRow = 0; IdxRow < nNonzero; ++IdxRow) { zVal[IdxRow] = xVal[IdxRow] * yVal[zKey[IdxRow]]; } }); }
public DenseMatrix(DenseMatrix SourceMatrix) { nRows = SourceMatrix.nRows; nCols = SourceMatrix.nCols; DenseMatrixValue = new DenseColumnVector[nCols]; for (int IdxCol = 0; IdxCol < nCols; IdxCol++) { DenseMatrixValue[IdxCol] = new DenseColumnVector(nRows); DenseMatrixValue[IdxCol].DeepCopyFrom(SourceMatrix.DenseMatrixValue[IdxCol]); } }
public static void MatrixMultiplyVector(SparseColumnVector z, DenseMatrix X, DenseColumnVector y) { // Dimension check if (X.nCols != y.Dim || z.Dim != X.nRows) { throw new Exception("Dimension mismatch."); } // Computation var zVal = z.Val; var zKey = z.Key; Array.Clear(zVal, 0, zVal.Length); var zNNonzero = z.nNonzero; var xnCols = X.nCols; float[] xColumn = null; float yValue; for (int Idx = 0; Idx < xnCols; ++ Idx) { xColumn = X.DenseMatrixValue[Idx].VectorValue; yValue = y.VectorValue[Idx]; for (int IdxRow = 0; IdxRow < zNNonzero; ++ IdxRow) { zVal[IdxRow] += xColumn[zKey[IdxRow]] * yValue; } } }
/* * z = X * y * Matrix multiply vector */ public static void MatrixMultiplyVector(DenseColumnVector z, DenseMatrix X, DenseColumnVector y) { if (z.Dim != X.nRows || X.nCols != y.Dim) { throw new Exception("Dimension mismatch."); } Array.Clear(z.VectorValue, 0, z.VectorValue.Length); int XnCols = X.nCols; int zDim = z.Dim; for (int IdxCol = 0; IdxCol < XnCols; ++IdxCol) { var zVal = z.VectorValue; var XVal = X.DenseMatrixValue[IdxCol].VectorValue; var yVal = y.VectorValue; for (int IdxRow = 0; IdxRow < zDim; ++IdxRow) { zVal[IdxRow] += XVal[IdxRow] * yVal[IdxCol]; } } }
public static void AtomicAddVectorMultiplyVectorTranspose(DenseMatrix Z, SparseColumnVector x, DenseColumnVector y, float a) { if (Z.nRows != x.Dim || Z.nCols != y.Dim) { throw new Exception("Dimension mismatch."); } float product = 0.0f; float InitVal = 0.0f; float ComputedVal = 0.0f; int ZnCols = Z.nCols; int xNz = x.nNonzero; var xVal = x.Val; var xKey = x.Key; var yVal = y.VectorValue; for (int IdxCol = 0; IdxCol < ZnCols; ++IdxCol) { var ZVal = Z.DenseMatrixValue[IdxCol].VectorValue; for (int IdxRow = 0; IdxRow < xNz; ++IdxRow) { product = xVal[IdxRow] * yVal[IdxCol] * a; do { InitVal = ZVal[xKey[IdxRow]]; ComputedVal = InitVal + product; } while (InitVal != Interlocked.CompareExchange(ref ZVal[xKey[IdxRow]], ComputedVal, InitVal)); } } }
public static void MatrixMultiplyMatrixTranspose(SparseMatrix Z, SparseMatrix X, DenseMatrix Y, bool IsCumSum) { if (Z.nRows != X.nRows || Z.nCols != Y.nRows || X.nCols != Y.nCols) { throw new Exception("Dimension mismatch."); } int total = Z.nCols; int process_len = (total + THREADNUM - 1) / THREADNUM; Parallel.For(0, THREADNUM, new ParallelOptions{ MaxDegreeOfParallelism = MaxMultiThreadDegree}, thread_idx => { var ZSparsePatternOfEachColumn = Z.SparsePatternOfEachColumn; var xnCols = X.nCols; for (int t = 0; t < process_len; ++t) { int IdxCol = thread_idx * process_len + t; if (IdxCol < total) { SparseColumnVector z = Z.SparseColumnVectors[IdxCol]; var zVal = z.Val; if (!IsCumSum) Array.Clear(zVal, 0, z.nNonzero); for (int Idx = 0; Idx < xnCols; ++Idx) { float yvalue = Y.DenseMatrixValue[Idx].VectorValue[IdxCol]; var xKey = X.SparseColumnVectors[Idx].Key; var xVal = X.SparseColumnVectors[Idx].Val; var xnNonzero = X.SparseColumnVectors[Idx].nNonzero; for (int IdxRow = 0; IdxRow < xnNonzero; ++IdxRow) { int xkey = xKey[IdxRow]; float xvalue = xVal[IdxRow]; zVal[ZSparsePatternOfEachColumn[xkey]] += xvalue * yvalue; } } } else break; } }); }
/* * Z = X * Y^T if IsCumSum == false * Z += X * Y^T is IsCumSum == true */ public static void MatrixMultiplyMatrixTranspose(DenseMatrix Z, SparseMatrix X, DenseMatrix Y, bool IsCumSum) { if (Z.nRows != X.nRows || Z.nCols != Y.nRows || X.nCols != Y.nCols) { throw new Exception("Dimension mismatch."); } int total = Z.nCols; int process_len = (total + THREADNUM - 1) / THREADNUM; Parallel.For(0, THREADNUM, new ParallelOptions{ MaxDegreeOfParallelism = MaxMultiThreadDegree}, thread_idx => { for (int t = 0; t < process_len; t++) { int IdxCol = thread_idx * process_len + t; if (IdxCol < total) { DenseColumnVector z = Z.DenseMatrixValue[IdxCol]; if (!IsCumSum) Array.Clear(z.VectorValue, 0, Z.nRows); for (int Idx = 0; Idx < X.nCols; Idx++) { SparseColumnVector x = X.SparseColumnVectors[Idx]; float yvalue = Y.DenseMatrixValue[Idx].VectorValue[IdxCol]; for (int IdxRow = 0; IdxRow < x.nNonzero; IdxRow++) { z.VectorValue[x.Key[IdxRow]] += x.Val[IdxRow] * yvalue; } } } else break; } }); }
public static void MatrixMultiplyMatrix(DenseMatrix Z, DenseMatrix X, DenseMatrix Y) { // Dimension check if (Z.nRows != X.nRows || Z.nCols != Y.nCols || X.nCols != Y.nRows) { throw new Exception("Matrix dimension mismatch in multiplication."); } int total = Z.nCols * Z.nRows; int process_len = (total + THREADNUM - 1) / THREADNUM; Parallel.For(0, THREADNUM, new ParallelOptions{ MaxDegreeOfParallelism = MaxMultiThreadDegree}, thread_idx => { for (int t = 0; t < process_len; t++) { int id = thread_idx * process_len + t; if (id < total) { int IdxCol = id / Z.nRows; int IdxRow = id % Z.nRows; float sum = 0; var yVal = Y.DenseMatrixValue[IdxCol].VectorValue; for(int Idx = 0; Idx<X.nCols;Idx++) { sum += X.DenseMatrixValue[Idx].VectorValue[IdxRow] * yVal[Idx]; } Z.DenseMatrixValue[IdxCol].VectorValue[IdxRow] = sum; } else break; } }); }
/* * Project each column of the input matrix X onto the affine space defined by 1^T x = 1 */ public static void ProjCols2SimplexPlane(DenseMatrix X) { DenseRowVector TmpDenseRowVec = new DenseRowVector(X.nCols); MatrixOperation.VerticalSumMatrix(TmpDenseRowVec, X); MatrixOperation.ScalarMultiplyVector(TmpDenseRowVec, 1.0f / ((float)X.nRows)); MatrixOperation.bsxfunMatrixSubtractVector(X, X, TmpDenseRowVec); MatrixOperation.ScalarAddMatrix(X, 1.0f / ((float)X.nRows)); }
/* * z = X^T * y */ public static void MatrixTransposeMultiplyVector(DenseColumnVector z, DenseMatrix X, DenseColumnVector y) { if (z.Dim != X.nCols || X.nRows != y.Dim) { throw new Exception("Dimension mismatch."); } int zDim = z.Dim; int yDim = y.Dim; var XMat = X.DenseMatrixValue; var zVal = z.VectorValue; var yVal = y.VectorValue; Parallel.For(0, zDim, new ParallelOptions { MaxDegreeOfParallelism = MaxMultiThreadDegree }, IdxRow => { float sum = 0.0f; var XCol = XMat[IdxRow].VectorValue; for (int Idx = 0; Idx < yDim; ++Idx) { sum += XCol[Idx] * yVal[Idx]; } zVal[IdxRow] = sum; }); }
public static void ProjCols2SimplexPlane(DenseMatrix Z, DenseMatrix X) { if (Z.nCols != X.nCols || Z.nRows != X.nRows) { throw new Exception("Dimension mismatch."); } DenseRowVector TmpDenseRowVec = new DenseRowVector(X.nCols); MatrixOperation.VerticalSumMatrix(TmpDenseRowVec, X); MatrixOperation.ScalarMultiplyVector(TmpDenseRowVec, 1.0f / ((float)X.nRows)); MatrixOperation.bsxfunMatrixSubtractVector(Z, X, TmpDenseRowVec); MatrixOperation.ScalarAddMatrix(Z, 1.0f / ((float)X.nRows)); }
public static void MatrixTransposeMultiplyVector(DenseColumnVector z, DenseMatrix X, SparseColumnVector y) { if (z.Dim != X.nCols || X.nRows != y.Dim) { throw new Exception("Dimension mismatch."); } int zDim = z.Dim; float sum = 0.0f; int yNz = y.nNonzero; var XMat = X.DenseMatrixValue; var zVal = z.VectorValue; for (int IdxRow = 0; IdxRow < zDim; ++IdxRow) { sum = 0.0f; var XCol = XMat[IdxRow].VectorValue; var yKey = y.Key; var yVal = y.Val; for (int Idx = 0; Idx < yNz; ++Idx) { sum += XCol[yKey[Idx]] * yVal[Idx]; } zVal[IdxRow] = sum; } }
/* * Z = Z.^{1/2} */ public static void ElementwiseSquareRoot(DenseMatrix Z) { int nCols = Z.nCols; int nRows = Z.nRows; Parallel.For(0, nCols, new ParallelOptions { MaxDegreeOfParallelism = MaxMultiThreadDegree }, IdxCol => { var zVal = Z.DenseMatrixValue[IdxCol].VectorValue; for (int IdxRow = 0; IdxRow < nRows; ++IdxRow) { zVal[IdxRow] = (float)Math.Sqrt(zVal[IdxRow]); } }); }
/* * Z = X^T * Y * Matrix transpose mulplication */ public static void MatrixTransposeMultiplyMatrix(DenseMatrix Z,DenseMatrix X, SparseMatrix Y) { // Dimension check if (X.nRows != Y.nRows || Z.nRows != X.nCols || Z.nCols != Y.nCols) { throw new Exception("Dimension mismatch."); } // Computation int total = Z.nCols * Z.nRows; int process_len = (total + THREADNUM - 1) / THREADNUM; Parallel.For(0, THREADNUM, new ParallelOptions{ MaxDegreeOfParallelism = MaxMultiThreadDegree}, thread_idx => { for (int t = 0; t < process_len; t++) { int id = thread_idx * process_len + t; if (id < total) { int IdxCol = id / Z.nRows; int IdxRow = id % Z.nRows; DenseColumnVector z = Z.DenseMatrixValue[IdxCol]; var x = X.DenseMatrixValue[IdxRow].VectorValue; SparseColumnVector y = Y.SparseColumnVectors[IdxCol]; var nNonzero = y.nNonzero; float sum = 0; var yKey = y.Key; var yVal = y.Val; for (int Idx = 0; Idx < nNonzero; ++ Idx) { sum += x[yKey[Idx]] * yVal[Idx]; } z.VectorValue[IdxRow] = sum; } else break; } }); }
public static void ElementwiseMatrixMultiplyMatrix(DenseMatrix Z, SparseMatrix X) { if (Z.nCols != X.nCols || Z.nRows != X.nRows) { throw new Exception("Dimension mismatch."); } Parallel.For(0, Z.nCols, new ParallelOptions { MaxDegreeOfParallelism = MaxMultiThreadDegree }, IdxCol => { int nNz = X.SparseColumnVectors[IdxCol].nNonzero; var xKey = X.SparseColumnVectors[IdxCol].Key; var xVal = X.SparseColumnVectors[IdxCol].Val; var zVal = Z.DenseMatrixValue[IdxCol].VectorValue; for (int IdxRow = 0; IdxRow < nNz; ++IdxRow) { zVal[xKey[IdxRow]] *= xVal[IdxRow]; } } ); }
public static void MatrixTransposeMultiplyMatrix(DenseMatrix Z, DenseMatrix X, DenseMatrix Y) { if (Z.nRows != X.nCols || Z.nCols != Y.nCols || X.nRows != Y.nRows) { throw new Exception("Dimension mismatch."); } int total = Z.nCols * Z.nRows; int process_len = (total + THREADNUM - 1) / THREADNUM; Parallel.For(0, THREADNUM, new ParallelOptions{ MaxDegreeOfParallelism = MaxMultiThreadDegree}, thread_idx => { for (int t = 0; t < process_len; t++) { int id = thread_idx * process_len + t; if (id < total) { int IdxCol = id / Z.nRows; int IdxRow = id % Z.nRows; Z.DenseMatrixValue[IdxCol].VectorValue[IdxRow] = 0; DenseColumnVector z = Z.DenseMatrixValue[IdxCol]; DenseColumnVector x = X.DenseMatrixValue[IdxRow]; DenseColumnVector y = Y.DenseMatrixValue[IdxCol]; for (int Idx = 0; Idx < X.nRows; Idx++) { z.VectorValue[IdxRow] += x.VectorValue[Idx] * y.VectorValue[Idx]; } } else break; } }); }
public static void ScalarDivideMatrix(DenseMatrix Z, float x, DenseMatrix Y, bool IsCumSum) { if (Z.nCols != Y.nCols || Z.nRows != Y.nRows) { throw new Exception("Dimension mismatch."); } int nRows = Z.nRows; if (IsCumSum) { Parallel.For(0, Z.nCols, new ParallelOptions { MaxDegreeOfParallelism = MaxMultiThreadDegree }, IdxCol => { var zVal = Z.DenseMatrixValue[IdxCol].VectorValue; var yVal = Y.DenseMatrixValue[IdxCol].VectorValue; for (int IdxRow = 0; IdxRow < nRows; ++IdxRow) { zVal[IdxRow] += x / (yVal[IdxRow]+1e-12f); } }); } else { Parallel.For(0, Z.nCols, new ParallelOptions { MaxDegreeOfParallelism = MaxMultiThreadDegree }, IdxCol => { var zVal = Z.DenseMatrixValue[IdxCol].VectorValue; var yVal = Y.DenseMatrixValue[IdxCol].VectorValue; for (int IdxRow = 0; IdxRow < nRows; ++IdxRow) { zVal[IdxRow] = x / (yVal[IdxRow]+1e-12f); } }); } }
/* * z = max(X, [], 1) * Vertial max: generate a row vector contains the maximum of each column */ public static void VerticalMaxMatrix(DenseRowVector z, DenseMatrix X) { int zDim = z.Dim; var zVal = z.VectorValue; var XMat = X.DenseMatrixValue; Parallel.For(0, zDim, new ParallelOptions { MaxDegreeOfParallelism = MaxMultiThreadDegree }, IdxCol => { zVal[IdxCol] = XMat[IdxCol].MaxValue(); }); }
/* * Z = x ./ Y or b = bsxfun(@rdivide, x, Y) * Vector divide by matrix */ public static void bsxfunVectorDivideMatrix(DenseMatrix Z, DenseColumnVector x, DenseMatrix Y) { // Dimension check if (x.Dim != Z.nRows || Z.nCols != Y.nCols || Z.nRows != Y.nRows) { throw new Exception("Dimension mismatch."); } // Computation for (int IdxCol = 0; IdxCol < Z.nCols; IdxCol++) { for (int IdxRow = 0; IdxRow < Z.nRows; IdxRow++) { Z.DenseMatrixValue[IdxCol].VectorValue[IdxRow] = x.VectorValue[IdxRow] / (Y.DenseMatrixValue[IdxCol].VectorValue[IdxRow]+1e-12f); } } }
/* * Count the values less than a certain value at each column of a matrix */ public static void CountValuesLessThanThreshold(DenseRowVector NumSpecialElementPerCol, DenseMatrix X, float Threshold) { if (NumSpecialElementPerCol.Dim != X.nCols) { throw new Exception("Dimension mismatch."); } for (int IdxCol = 0; IdxCol < X.nCols; IdxCol++ ) { NumSpecialElementPerCol.VectorValue[IdxCol] = 0.0f; for (int IdxRow = 0; IdxRow < X.nRows; IdxRow++) { if (X.DenseMatrixValue[IdxCol].VectorValue[IdxRow]<Threshold) { NumSpecialElementPerCol.VectorValue[IdxCol]++; } } } }
/* * Z = Z - Y */ public static void MatrixSubtractMatrix(DenseMatrix Z, SparseMatrix Y) { if (Z.nRows != Y.nRows || Z.nCols != Y.nCols) { throw new Exception("Dimension mismatch."); } Parallel.For(0, Z.nCols, new ParallelOptions { MaxDegreeOfParallelism = MaxMultiThreadDegree }, IdxCol => { int nNonzero = Y.SparseColumnVectors[IdxCol].nNonzero; var zVal = Z.DenseMatrixValue[IdxCol].VectorValue; var yKey = Y.SparseColumnVectors[IdxCol].Key; var yVal = Y.SparseColumnVectors[IdxCol].Val; for (int IdxRow = 0; IdxRow < nNonzero; ++IdxRow) { zVal[yKey[IdxRow]] -= yVal[IdxRow]; } }); }
/* * Set elements of Z to zero if the corresponding elements of X is zero. */ public static void ResetMatrixSparsePattern(DenseMatrix Z, DenseMatrix X) { if (Z.nCols != X.nCols || Z.nRows != X.nRows) { throw new Exception("Dimension mismatch."); } Parallel.For(0, Z.nCols, new ParallelOptions { MaxDegreeOfParallelism = MaxMultiThreadDegree }, IdxCol => { int nRows = Z.nRows; var XVal = X.DenseMatrixValue[IdxCol].VectorValue; var ZVal = Z.DenseMatrixValue[IdxCol].VectorValue; for (int IdxRow = 0; IdxRow < nRows; ++IdxRow) { if (Math.Abs(XVal[IdxRow]) < 1e-30f) { ZVal[IdxRow] = 0.0f; } } }); }
/* * X = X + y (scalar) */ public static void ScalarAddMatrix(DenseMatrix X, float y) { Parallel.For(0, X.nCols, new ParallelOptions { MaxDegreeOfParallelism = MaxMultiThreadDegree }, IdxCol => { var xVal = X.DenseMatrixValue[IdxCol].VectorValue; for (int IdxRow = 0; IdxRow < X.nRows; IdxRow++) { xVal[IdxRow] += y; } }); }
/* * Z = bsxfun(@minus, X, y) */ public static void bsxfunMatrixSubtractVector(DenseMatrix Z, DenseMatrix X, DenseRowVector y) { if (Z.nCols != X.nCols || Z.nRows != X.nRows || Z.nCols != y.Dim) { throw new Exception("Dimension mismatch."); } int total = Z.nCols * Z.nRows; int process_len = (total + THREADNUM - 1) / THREADNUM; Parallel.For(0, THREADNUM, new ParallelOptions{ MaxDegreeOfParallelism = MaxMultiThreadDegree}, thread_idx => { for (int t = 0; t < process_len; t++) { int id = thread_idx * process_len + t; if (id < total) { int IdxCol = id / Z.nRows; int IdxRow = id % Z.nRows; Z.DenseMatrixValue[IdxCol].VectorValue[IdxRow] = X.DenseMatrixValue[IdxCol].VectorValue[IdxRow] - y.VectorValue[IdxCol]; } else break; } }); }