public void Multiply()
{
ColumnWiseMatrix m1 = new ColumnWiseMatrix(10, 10, 1.2345f);
DeviceManager.CheckDeviceSanity();
var _m1 = m1.GetMatrix <float>();
ColumnWiseMatrix m2 = new ColumnWiseMatrix(10, 10, 9.8765f);
DeviceManager.CheckDeviceSanity();
var _m2 = m2.GetMatrix <float>();
var m3 = m1 * m2;
DeviceManager.CheckDeviceSanity();
var _m3 = m3.GetMatrix <float>();
for (int i = 0; i < m1.nRows; ++i)
{
for (int j = 0; j < m1.nCols; ++j)
{
double m1m2 = 0.0;
for (int k = 0; k < m1.nCols; ++k)
{
m1m2 += _m1[i, k] * _m2[k, j];
}
Assert.IsTrue(Math.Abs(m1m2 - _m3[i, j]) <= 5e-5);
}
}
}
public void Allocation()
{
var m1 = new ColumnWiseMatrix(10, 5, 2, MemorySpace.Device, MathDomain.Int);
m1.Print();
DeviceManager.CheckDeviceSanity();
var m2 = new ColumnWiseMatrix(10, 5, 1.234f, MemorySpace.Device, MathDomain.Float);
m2.Print();
DeviceManager.CheckDeviceSanity();
var m3 = new ColumnWiseMatrix(10, 5, 1.2345, MemorySpace.Device, MathDomain.Double);
m3.Print();
DeviceManager.CheckDeviceSanity();
var m4 = new ColumnWiseMatrix(10, 5, 1, MemorySpace.Host, MathDomain.Int);
m4.Print();
DeviceManager.CheckDeviceSanity();
var m5 = new ColumnWiseMatrix(10, 5, 1.234f, MemorySpace.Host, MathDomain.Float);
m5.Print();
DeviceManager.CheckDeviceSanity();
var m6 = new ColumnWiseMatrix(10, 5, 1.2345, MemorySpace.Host, MathDomain.Double);
m6.Print();
DeviceManager.CheckDeviceSanity();
}
public void Dot()
{
ColumnWiseMatrix m1 = new ColumnWiseMatrix(10, 10, 1.2345f);
DeviceManager.CheckDeviceSanity();
var _m1 = m1.GetMatrix <float>();
Vector v1 = new Vector(10, 9.8765f);
DeviceManager.CheckDeviceSanity();
var _v1 = v1.Get <float>();
var v2 = m1 * v1;
DeviceManager.CheckDeviceSanity();
var _v2 = v2.Get <float>();
for (int i = 0; i < m1.nRows; ++i)
{
double m1v1 = 0.0;
for (int j = 0; j < m1.nCols; ++j)
{
m1v1 += _m1[i, j] * _v1[j];
}
Assert.IsTrue(Math.Abs(m1v1 - _v2[i]) <= 5e-5);
}
}
public void KroneckerProduct()
{
Vector u = new Vector(128, 0.01);
DeviceManager.CheckDeviceSanity();
var _u = u.Get <float>();
Vector v = new Vector(64, 0.02);
DeviceManager.CheckDeviceSanity();
var _v = v.Get <float>();
var A = ColumnWiseMatrix.KroneckerProduct(u, v, 2.0);
DeviceManager.CheckDeviceSanity();
var _A = A.GetMatrix <float>();
for (int i = 0; i < A.nRows; ++i)
{
for (int j = 0; j < A.nCols; ++j)
{
double expected = 2.0 * _u[i] * _v[j];
double err = Math.Abs(expected - _A[i, j]);
Assert.IsTrue(err <= 5e-4, String.Format("i({0}) j({1}) err({2})", i, j, err));
}
}
}
private void Compress <T>(ColumnWiseMatrix denseMatrix) where T : struct, IEquatable <T>, IFormattable
{
var hostDenseMatrix = denseMatrix.GetMatrix <T>();
List <T> nonZeroValues = new List <T>();
List <int> nonZeroColumnIndices = new List <int>();
List <int> nNonZeroRows = new List <int>();
int nNonZeros = 0;
for (int i = 0; i < denseMatrix.nRows; i++)
{
for (int j = 0; j < denseMatrix.nCols; j++)
{
if (Math.Abs(Convert.ToDouble(hostDenseMatrix[i, j])) > 1e-7)
{
nNonZeros++;
nonZeroValues.Add(hostDenseMatrix[i, j]);
nonZeroColumnIndices.Add(j);
}
}
nNonZeroRows.Add(nNonZeros);
}
Buffer.size = (uint)nNonZeros;
values = new Vector(nonZeroValues.Count, memorySpace, mathDomain);
values.ReadFrom(nonZeroValues, nonZeroValues.Count);
this.nonZeroColumnIndices = new Vector(nonZeroColumnIndices.Count, memorySpace, MathDomain.Int);
this.nonZeroColumnIndices.ReadFrom(nonZeroColumnIndices, nonZeroColumnIndices.Count);
this.nNonZeroRows = new Vector(nNonZeroRows.Count, memorySpace, MathDomain.Int);
this.nNonZeroRows.ReadFrom(nNonZeroRows, nNonZeroRows.Count);
}
/// <summary>
/// Copy denseVector to host, numerically finds the non-zero indices, and then copy back to device
/// </summary>
public CompressedSparseRowMatrix(ColumnWiseMatrix denseMatrix)
: base(false, denseMatrix.memorySpace, denseMatrix.mathDomain)
{
_buffer = new SparseMemoryTile(0, 0, 0, 0, (uint)denseMatrix.nRows, (uint)denseMatrix.nCols, denseMatrix.memorySpace, denseMatrix.mathDomain);
switch (denseMatrix.mathDomain)
{
case MathDomain.Int:
Compress <int>(denseMatrix);
break;
case MathDomain.Float:
Compress <float>(denseMatrix);
break;
case MathDomain.Double:
Compress <double>(denseMatrix);
break;
default:
break;
}
SyncPointers();
}
public void Invert()
{
ColumnWiseMatrix A = GetInvertibleMatrix(128);
DeviceManager.CheckDeviceSanity();
ColumnWiseMatrix AMinus1 = new ColumnWiseMatrix(A);
AMinus1.Invert();
DeviceManager.CheckDeviceSanity();
var eye = A.Multiply(AMinus1);
var _eye = eye.GetMatrix <float>();
var _A = A.GetMatrix <float>();
var _AMinus1 = AMinus1.GetMatrix <float>();
for (int i = 0; i < A.nRows; ++i)
{
for (int j = 0; j < A.nCols; ++j)
{
double expected = i == j ? 1.0 : 0.0;
Assert.IsTrue(Math.Abs(_eye[i, j] - expected) <= 5e-5);
}
}
}
public void Solve()
{
ColumnWiseMatrix A = GetInvertibleMatrix(128);
DeviceManager.CheckDeviceSanity();
var _A = A.GetMatrix <float>();
ColumnWiseMatrix B = GetInvertibleMatrix(128, 2345);
DeviceManager.CheckDeviceSanity();
var _B = B.GetMatrix <float>();
A.Solve(B);
DeviceManager.CheckDeviceSanity();
var _x = B.Get <float>();
var BSanity = A.Multiply(B);
var _BSanity = BSanity.GetMatrix <float>();
for (int i = 0; i < A.nRows; ++i)
{
for (int j = 0; j < A.nCols; ++j)
{
double expected = _B[i, j];
Assert.IsTrue(Math.Abs(_BSanity[i, j] - expected) <= 5e-5);
}
}
}
public ColumnWiseMatrix Multiply(ColumnWiseMatrix rhs, MatrixOperation lhsOperation = MatrixOperation.None, MatrixOperation rhsOperation = MatrixOperation.None, double alpha = 1.0)
{
ColumnWiseMatrix ret = new ColumnWiseMatrix(nRows, rhs.nCols, memorySpace, rhs.mathDomain);
Multiply(ret, rhs, lhsOperation, rhsOperation, alpha);
return(ret);
}
public void Copy()
{
var m1 = new ColumnWiseMatrix(10, 5, 1, MemorySpace.Device, MathDomain.Int);
m1.Print();
var m1Copy = new ColumnWiseMatrix(m1);
DeviceManager.CheckDeviceSanity();
m1Copy.Print();
Assert.AreEqual(m1, m1Copy);
var m2 = new ColumnWiseMatrix(10, 5, 1.234f, MemorySpace.Device, MathDomain.Float);
m2.Print();
var m2Copy = new ColumnWiseMatrix(m2);
DeviceManager.CheckDeviceSanity();
m2Copy.Print();
Assert.AreEqual(m2, m2Copy);
var m3 = new ColumnWiseMatrix(10, 5, 1.2345, MemorySpace.Device, MathDomain.Double);
m3.Print();
var m3Copy = new ColumnWiseMatrix(m3);
DeviceManager.CheckDeviceSanity();
m3Copy.Print();
Assert.AreEqual(m3, m3Copy);
var m4 = new ColumnWiseMatrix(10, 5, 1, MemorySpace.Host, MathDomain.Int);
m4.Print();
var m4Copy = new ColumnWiseMatrix(m4);
DeviceManager.CheckDeviceSanity();
m4Copy.Print();
Assert.AreEqual(m4, m4Copy);
var m5 = new ColumnWiseMatrix(10, 5, 1.234f, MemorySpace.Host, MathDomain.Float);
m5.Print();
var m5Copy = new ColumnWiseMatrix(m5);
DeviceManager.CheckDeviceSanity();
m5Copy.Print();
Assert.AreEqual(m5, m5Copy);
var m6 = new ColumnWiseMatrix(10, 5, 1.2345, MemorySpace.Host, MathDomain.Double);
m6.Print();
var m6Copy = new ColumnWiseMatrix(m6);
DeviceManager.CheckDeviceSanity();
m6Copy.Print();
Assert.AreEqual(m6, m6Copy);
}
public void MatrixSerializationInversion()
{
ColumnWiseMatrix A = new ColumnWiseMatrix(10, 20, 5.0);
A.ToBinaryFile <float>("A.zf");
ColumnWiseMatrix B = new ColumnWiseMatrix("A.zf", MathDomain.Float);
Assert.AreEqual(A, B);
}
public void LinSpace()
{
var m = ColumnWiseMatrix.LinSpace(10, 5, 0.0, 1.0);
DeviceManager.CheckDeviceSanity();
var _m = m.Get <float>();
Assert.IsTrue(System.Math.Abs(_m[0] - 0.0) <= 1e-7);
Assert.IsTrue(System.Math.Abs(_m[_m.Count - 1] - 1.0) <= 1e-7);
}
public void RandomUniform()
{
var m = ColumnWiseMatrix.RandomUniform(10, 5, 1234);
DeviceManager.CheckDeviceSanity();
var _m = m.Get <float>();
foreach (var iter in _m)
{
Assert.IsTrue(iter >= 0.0 && iter <= 1.0);
}
}
public void RandomGaussian()
{
var m = ColumnWiseMatrix.RandomGaussian(10, 5, 1234);
DeviceManager.CheckDeviceSanity();
var _m = m.Get <float>();
for (int i = 0; i < _m.Count / 2; ++i)
{
Assert.IsTrue(System.Math.Abs(_m[2 * i] + _m[2 * i + 1]) <= 1e-7);
}
}
static ColumnWiseMatrix GetInvertibleMatrix(int nRows, int seed = 1234)
{
var A = ColumnWiseMatrix.RandomUniform(nRows, nRows, seed);
var _A = A.GetMatrix <float>();
for (int i = 0; i < nRows; ++i)
{
_A[i, i] += 2;
}
A.ReadFrom(_A);
return(A);
}
public static ColumnWiseMatrix operator *(CompressedSparseRowMatrix lhs, ColumnWiseMatrix rhs)
{
Debug.Assert(rhs.nRows == lhs.nCols);
Debug.Assert(lhs.memorySpace == rhs.memorySpace);
Debug.Assert(lhs.mathDomain == rhs.mathDomain);
Debug.Assert(lhs.Buffer.pointer != 0);
Debug.Assert(rhs.Buffer.pointer != 0);
ColumnWiseMatrix ret = new ColumnWiseMatrix(lhs.nRows, rhs.nCols, lhs.memorySpace, lhs.mathDomain);
CuSparseApi.SparseMultiply(ret.Buffer as MemoryTile, lhs._buffer, rhs.Buffer as MemoryTile, lhs.nRows, rhs.nRows, MatrixOperation.None, MatrixOperation.None, 1.0);
return(ret);
}
/// <summary>
/// Same version as above, but gives the possibility of reusing the output buffer
/// </summary>
/// <param name="output"></param>
/// <param name="rhs"></param>
/// <param name="lhsOperation"></param>
/// <param name="rhsOperation"></param>
/// <param name="alpha"></param>
public void Multiply(ColumnWiseMatrix output, ColumnWiseMatrix rhs, MatrixOperation lhsOperation = MatrixOperation.None, MatrixOperation rhsOperation = MatrixOperation.None, double alpha = 1.0)
{
Debug.Assert(rhs.nRows == nCols);
Debug.Assert(output.nRows == nRows);
Debug.Assert(output.nCols == rhs.nCols);
Debug.Assert(memorySpace == rhs.memorySpace);
Debug.Assert(memorySpace == output.memorySpace);
Debug.Assert(mathDomain == rhs.mathDomain);
Debug.Assert(mathDomain == output.mathDomain);
Debug.Assert(Buffer.pointer != 0);
Debug.Assert(rhs.Buffer.pointer != 0);
Debug.Assert(output.Buffer.pointer != 0);
CuSparseApi.SparseMultiply(output.Buffer as MemoryTile, _buffer, rhs.Buffer as MemoryTile, nRows, rhs.nRows, lhsOperation, rhsOperation, alpha);
}
public void Eye()
{
var m = ColumnWiseMatrix.Eye(10);
m.Print();
DeviceManager.CheckDeviceSanity();
var _m = m.GetMatrix <float>();
for (int i = 0; i < m.nRows; ++i)
{
for (int j = 0; j < m.nCols; ++j)
{
Assert.AreEqual(j == i ? 1.0 : 0.0, _m[i, j]);
}
}
}
public void ColumnWiseArgAbsoluteMinMax()
{
ColumnWiseMatrix A = ColumnWiseMatrix.LinSpace(128, 64, -1, 1);
var _A = A.GetMatrix <float>();
var min = A.ColumnWiseAbsoluteMinimumIndex().GetRaw <int>();
var max = A.ColumnWiseAbsoluteMaximumIndex().GetRaw <int>();
int[] _min = new int[A.nCols];
int[] _max = new int[A.nCols];
for (int j = 0; j < A.nCols; j++)
{
_min[j] = _A.Column(j).AbsoluteMinimumIndex();
_max[j] = _A.Column(j).AbsoluteMaximumIndex();
Assert.AreEqual(min[j] - 1, _min[j]);
Assert.AreEqual(max[j] - 1, _max[j]);
}
}
public void GetColumn()
{
var m1 = new ColumnWiseMatrix(10, 5, 1.2345f);
m1.Print();
DeviceManager.CheckDeviceSanity();
for (int j = 0; j < m1.nCols; ++j)
{
var col = m1.Get <float>(j);
DeviceManager.CheckDeviceSanity();
Assert.AreEqual(col.Count, m1.nRows);
for (int i = 0; i < m1.nRows; ++i)
{
Assert.IsTrue(Math.Abs(col[i] - 1.2345f) <= 1e-7);
}
}
}
public void SetColumn()
{
var m1 = new ColumnWiseMatrix(10, 5, 1.2345f);
m1.Print();
DeviceManager.CheckDeviceSanity();
var _m1 = m1.Get <float>();
var v1 = new Vector(10, 2.3456f);
v1.Print();
DeviceManager.CheckDeviceSanity();
var _v1 = v1.Get <float>();
m1.Set(v1, 3);
for (int j = 0; j < m1.nCols; ++j)
{
var col = m1.Get <float>(j);
DeviceManager.CheckDeviceSanity();
Assert.AreEqual(col.Count, m1.nRows);
if (j != 3)
{
for (int i = 0; i < m1.nRows; ++i)
{
Assert.IsTrue(Math.Abs(col[i] - _m1[i + m1.nRows * j]) <= 1e-7);
}
}
else
{
for (int i = 0; i < m1.nRows; ++i)
{
Assert.IsTrue(Math.Abs(col[i] - _v1[i]) <= 1e-7);
}
}
}
}
public void AddMatrix()
{
ColumnWiseMatrix m1 = ColumnWiseMatrix.LinSpace(100, 20, -1.0, 1.0);
DeviceManager.CheckDeviceSanity();
var _m1 = m1.GetMatrix <float>();
ColumnWiseMatrix m2 = ColumnWiseMatrix.RandomGaussian(m1.nRows, m1.nCols, 1234);
DeviceManager.CheckDeviceSanity();
var _m2 = m2.GetMatrix <float>();
var m3 = m1 + m2;
DeviceManager.CheckDeviceSanity();
var _m3 = m3.GetMatrix <float>();
for (int i = 0; i < m1.nRows; ++i)
{
for (int j = 0; j < m1.nCols; ++j)
{
Assert.IsTrue(Math.Abs(_m3[i, j] - _m1[i, j] - _m2[i, j]) <= 3e-7, String.Format("i({0}) j({1}) err({2})", i, j, Math.Abs(_m3[i, j] - _m1[i, j] - _m2[i, j])));
}
}
var m4 = ColumnWiseMatrix.Add(m1, m2, alpha: 2.0);
DeviceManager.CheckDeviceSanity();
var _m4 = m4.GetMatrix <float>();
for (int i = 0; i < m1.nRows; ++i)
{
for (int j = 0; j < m1.nCols; ++j)
{
Assert.IsTrue(Math.Abs(_m4[i, j] - _m1[i, j] - 2.0 * _m2[i, j]) <= 5e-7, String.Format("i({0}) j({1}) err({2})", i, j, Math.Abs(_m4[i, j] - _m1[i, j] - 2.0 * _m2[i, j])));
}
}
}
public void Multiply()
{
int[] _NonZeroCols = new int[] { 0, 1, 1, 3, 2, 3, 4, 5 };
Vector gpuNonZeroCols = new Vector(_NonZeroCols);
int[] _NonZeroRows = new int[] { 0, 2, 4, 7, 8 };
Vector gpuNonZeroRows = new Vector(_NonZeroRows);
CompressedSparseRowMatrix m1 = new CompressedSparseRowMatrix(4, 6, gpuNonZeroCols, gpuNonZeroRows, 1.2345f, MathDomain.Float);
DeviceManager.CheckDeviceSanity();
var _m1 = m1.GetMatrix <float>();
ColumnWiseMatrix m2 = new ColumnWiseMatrix(6, 8, 9.8765f, MemorySpace.Device, MathDomain.Float);
DeviceManager.CheckDeviceSanity();
var _m2 = m2.GetMatrix <float>();
var m3 = m1 * m2;
DeviceManager.CheckDeviceSanity();
var _m3 = m3.GetMatrix <float>();
for (int i = 0; i < m1.nRows; ++i)
{
for (int j = 0; j < m2.nCols; ++j)
{
double m1m2 = 0.0;
for (int k = 0; k < m1.nCols; ++k)
{
m1m2 += _m1[i, k] * _m2[k, j];
}
Assert.IsTrue(Math.Abs(m1m2 - _m3[i, j]) <= 5e-5);
}
}
}