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;
}
});
}
