public void Add()
{
Vector v1 = Vector.LinSpace(100, -1.0, 1.0);
DeviceManager.CheckDeviceSanity();
var _v1 = v1.Get <float>();
Vector v2 = Vector.RandomGaussian(v1.Size, 1234);
DeviceManager.CheckDeviceSanity();
var _v2 = v2.Get <float>();
var v3 = v1 + v2;
DeviceManager.CheckDeviceSanity();
var _v3 = v3.Get <float>();
for (int i = 0; i < v1.Size; ++i)
{
Assert.IsTrue(Math.Abs(_v3[i] - _v1[i] - _v2[i]) <= 3e-7, String.Format("i({0}) err({1})", i, Math.Abs(_v3[i] - _v1[i] - _v2[i])));
}
var v4 = Vector.Add(v1, v2, 2.0);
DeviceManager.CheckDeviceSanity();
var _v4 = v4.Get <float>();
for (int i = 0; i < v1.Size; ++i)
{
Assert.IsTrue(Math.Abs(_v4[i] - _v1[i] - 2.0 * _v2[i]) <= 5e-7, String.Format("i({0}) err({1})", i, Math.Abs(_v4[i] - _v1[i] - 2.0 * _v2[i])));
}
}
public void Add()
{
int[] indices = new int[] { 0, 5, 10, 50, 75 };
Vector gpuIndices = new Vector(indices);
SparseVector v1 = new SparseVector(100, gpuIndices, 1.2345, MathDomain.Float);
DeviceManager.CheckDeviceSanity();
var _v1 = v1.Get <float>();
Vector v2 = Vector.RandomUniform(v1.denseSize, 1234, MemorySpace.Device, MathDomain.Float);
DeviceManager.CheckDeviceSanity();
var _v2 = v2.Get <float>();
var v3 = v1 + v2;
DeviceManager.CheckDeviceSanity();
var _v3 = v3.Get <float>();
for (int i = 0; i < v1.Size; ++i)
{
Assert.IsTrue(Math.Abs(_v3[i] - _v1[i] - _v2[i]) <= 1e-7);
}
}
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 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 void Copy()
{
int[] indices = new int[] { 0, 5 };
Vector gpuIndices = new Vector(indices);
SparseVector v1 = new SparseVector(10, gpuIndices, 1.2345f, MathDomain.Float);
DeviceManager.CheckDeviceSanity();
SparseVector v2 = new SparseVector(v1);
DeviceManager.CheckDeviceSanity();
Assert.AreEqual(v1, v2);
SparseVector v3 = new SparseVector(10, gpuIndices, 1.2345, MathDomain.Double);
DeviceManager.CheckDeviceSanity();
SparseVector v4 = new SparseVector(v3);
DeviceManager.CheckDeviceSanity();
Assert.AreEqual(v3, v4);
SparseVector v5 = new SparseVector(10, gpuIndices, 10, MathDomain.Int);
DeviceManager.CheckDeviceSanity();
SparseVector v6 = new SparseVector(v5);
DeviceManager.CheckDeviceSanity();
Assert.AreEqual(v5, v6);
}
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 Allocation()
{
var v1 = new Vector(10, 1, MemorySpace.Device, MathDomain.Int);
v1.Print();
DeviceManager.CheckDeviceSanity();
var v2 = new Vector(10, 1.234f, MemorySpace.Device, MathDomain.Float);
v2.Print();
DeviceManager.CheckDeviceSanity();
var v3 = new Vector(10, 1.2345, MemorySpace.Device, MathDomain.Double);
v3.Print();
DeviceManager.CheckDeviceSanity();
var v4 = new Vector(10, 1, MemorySpace.Host, MathDomain.Int);
v4.Print();
DeviceManager.CheckDeviceSanity();
var v5 = new Vector(10, 1.234f, MemorySpace.Host, MathDomain.Float);
v5.Print();
DeviceManager.CheckDeviceSanity();
var v6 = new Vector(10, 1.2345, MemorySpace.Host, MathDomain.Double);
v6.Print();
DeviceManager.CheckDeviceSanity();
}
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));
}
}
}
public void Allocation()
{
var t1 = new Tensor(10, 5, 5, 1, MemorySpace.Device, MathDomain.Int);
t1.Print();
DeviceManager.CheckDeviceSanity();
var t2 = new Tensor(10, 5, 4, 1.234f, MemorySpace.Device, MathDomain.Float);
t2.Print();
DeviceManager.CheckDeviceSanity();
var t3 = new Tensor(10, 5, 3, 1.2345, MemorySpace.Device, MathDomain.Double);
t3.Print();
DeviceManager.CheckDeviceSanity();
var t4 = new Tensor(10, 5, 7, 1, MemorySpace.Host, MathDomain.Int);
t4.Print();
DeviceManager.CheckDeviceSanity();
var t5 = new Tensor(10, 5, 1, 1.234f, MemorySpace.Host, MathDomain.Float);
t5.Print();
DeviceManager.CheckDeviceSanity();
var t6 = new Tensor(10, 5, 10, 1.2345, MemorySpace.Host, MathDomain.Double);
t6.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 Copy()
{
var v1 = new Vector(10, 1, MemorySpace.Device, MathDomain.Int);
v1.Print();
var v1Copy = new Vector(v1);
DeviceManager.CheckDeviceSanity();
v1Copy.Print();
Assert.AreEqual(v1, v1Copy);
var v2 = new Vector(10, 1.234f, MemorySpace.Device, MathDomain.Float);
v2.Print();
var v2Copy = new Vector(v2);
DeviceManager.CheckDeviceSanity();
v2Copy.Print();
Assert.AreEqual(v2, v2Copy);
var v3 = new Vector(10, 1.2345, MemorySpace.Device, MathDomain.Double);
v3.Print();
var v3Copy = new Vector(v3);
DeviceManager.CheckDeviceSanity();
v3Copy.Print();
Assert.AreEqual(v3, v3Copy);
var v4 = new Vector(10, 1, MemorySpace.Host, MathDomain.Int);
v4.Print();
var v4Copy = new Vector(v4);
DeviceManager.CheckDeviceSanity();
v4Copy.Print();
Assert.AreEqual(v4, v4Copy);
var v5 = new Vector(10, 1.234f, MemorySpace.Host, MathDomain.Float);
v5.Print();
var v5Copy = new Vector(v5);
DeviceManager.CheckDeviceSanity();
v5Copy.Print();
Assert.AreEqual(v5, v5Copy);
var v6 = new Vector(10, 1.2345, MemorySpace.Host, MathDomain.Double);
v6.Print();
var v6Copy = new Vector(v6);
DeviceManager.CheckDeviceSanity();
v6Copy.Print();
Assert.AreEqual(v6, v6Copy);
}
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 Copy()
{
var t1 = new Tensor(10, 5, 5, 1, MemorySpace.Device, MathDomain.Int);
t1.Print();
var t1Copy = new Tensor(t1);
DeviceManager.CheckDeviceSanity();
t1Copy.Print();
Assert.AreEqual(t1, t1Copy);
var t2 = new Tensor(10, 5, 5, 1.234f, MemorySpace.Device, MathDomain.Float);
t2.Print();
var t2Copy = new Tensor(t2);
DeviceManager.CheckDeviceSanity();
t2Copy.Print();
Assert.AreEqual(t2, t2Copy);
var t3 = new Tensor(10, 5, 5, 1.2345, MemorySpace.Device, MathDomain.Double);
t3.Print();
var t3Copy = new Tensor(t3);
DeviceManager.CheckDeviceSanity();
t3Copy.Print();
Assert.AreEqual(t3, t3Copy);
var t4 = new Tensor(10, 5, 5, 1, MemorySpace.Host, MathDomain.Int);
t4.Print();
var t4Copy = new Tensor(t4);
DeviceManager.CheckDeviceSanity();
t4Copy.Print();
Assert.AreEqual(t4, t4Copy);
var t5 = new Tensor(10, 5, 5, 1.234f, MemorySpace.Host, MathDomain.Float);
t5.Print();
var t5Copy = new Tensor(t5);
DeviceManager.CheckDeviceSanity();
t5Copy.Print();
Assert.AreEqual(t5, t5Copy);
var t6 = new Tensor(10, 5, 5, 1.2345, MemorySpace.Host, MathDomain.Double);
t6.Print();
var t6Copy = new Tensor(t6);
DeviceManager.CheckDeviceSanity();
t6Copy.Print();
Assert.AreEqual(t6, t6Copy);
}
public void LinSpace()
{
var t = Tensor.LinSpace(10, 5, 5, 0.0, 1.0);
DeviceManager.CheckDeviceSanity();
var _t = t.Get <float>();
Assert.IsTrue(System.Math.Abs(_t[0] - 0.0) <= 1e-7);
Assert.IsTrue(System.Math.Abs(_t[_t.Count - 1] - 1.0) <= 1e-7);
}
public void LinSpace()
{
var v = Vector.LinSpace(10, 0.0, 1.0);
DeviceManager.CheckDeviceSanity();
var _v = v.Get <float>();
Assert.IsTrue(System.Math.Abs(_v[0] - 0.0) <= 1e-7);
Assert.IsTrue(System.Math.Abs(_v[_v.Count - 1] - 1.0) <= 1e-7);
}
public void DeviceInitialization()
{
for (int i = 0; i < DeviceManager.GetDeviceCount(); ++i)
{
DeviceManager.SetDevice(i);
DeviceManager.CheckDeviceSanity();
}
DeviceManager.SetBestDevice();
DeviceManager.CheckDeviceSanity();
}
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 RandomGaussian()
{
var t = Tensor.RandomGaussian(10, 5, 5, 1234);
DeviceManager.CheckDeviceSanity();
var _t = t.Get <float>();
for (int i = 0; i < _t.Count / 2; ++i)
{
Assert.IsTrue(System.Math.Abs(_t[2 * i] + _t[2 * i + 1]) <= 1e-7);
}
}
public void RandomUniform()
{
var v = Vector.RandomUniform(11, 1234);
DeviceManager.CheckDeviceSanity();
var _v = v.Get <float>();
foreach (var iter in _v)
{
Assert.IsTrue(iter >= 0.0 && iter <= 1.0);
}
}
public void RandomGaussian()
{
var v = Vector.RandomGaussian(11, 1234);
DeviceManager.CheckDeviceSanity();
var _v = v.Get <float>();
for (int i = 0; i < _v.Count / 2; ++i)
{
Assert.IsTrue(System.Math.Abs(_v[2 * i] + _v[2 * i + 1]) <= 1e-7);
}
}
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);
}
}
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 DeviceProperties()
{
for (int i = 0; i < DeviceManager.GetDeviceCount(); ++i)
{
var dp = DeviceManager.GetDeviceProperties(i);
Assert.IsTrue(dp.major > 0);
Assert.IsTrue(dp.clockRate > 0);
Assert.IsTrue(dp.warpSize > 0);
}
DeviceManager.SetBestDevice();
DeviceManager.CheckDeviceSanity();
}
public void RandomUniform()
{
var t = Tensor.RandomUniform(10, 5, 5, 1234);
DeviceManager.CheckDeviceSanity();
var _t = t.Get <float>();
foreach (var iter in _t)
{
Assert.IsTrue(iter >= 0.0 && iter <= 1.0);
}
}
public void Scale()
{
var v1 = Vector.LinSpace(100, -1.0, 1.0);
DeviceManager.CheckDeviceSanity();
var _v1 = v1.Get <float>();
v1.Scale(2.0);
var _v2 = v1.Get <float>();
for (int i = 0; i < v1.Size; ++i)
{
Assert.IsTrue(Math.Abs(2.0 * _v1[i] - _v2[i]) <= 1e-7);
}
}
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 Allocation()
{
int[] indices = new int[] { 0, 5 };
Vector gpuIndices = new Vector(indices);
SparseVector v1 = new SparseVector(10, gpuIndices, 1.2345f, MathDomain.Float);
DeviceManager.CheckDeviceSanity();
SparseVector v2 = new SparseVector(10, gpuIndices, 1.2345, MathDomain.Double);
DeviceManager.CheckDeviceSanity();
SparseVector v3 = new SparseVector(10, gpuIndices, 1, MathDomain.Int);
DeviceManager.CheckDeviceSanity();
}
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 ElementWiseProduct()
{
var v1 = Vector.LinSpace(100, -1.0, 1.0);
DeviceManager.CheckDeviceSanity();
var _v1 = v1.Get <float>();
var v2 = Vector.LinSpace(100, -2.0, 2.0);
DeviceManager.CheckDeviceSanity();
var _v2 = v2.Get <float>();
var v3 = v1 % v2;
var _v3 = v3.Get <float>();
for (int i = 0; i < v1.Size; ++i)
{
Assert.IsTrue(Math.Abs(_v3[i] - _v1[i] * _v2[i]) <= 1e-7);
}
}