public int CountEquals(ContiguousMemoryBuffer rhs, MemoryBuffer cache)
{
Debug.Assert(Buffer.pointer != 0);
Debug.Assert(rhs.Buffer.pointer != 0);
Debug.Assert(Size == rhs.Size);
bool needToFreeCache = cache.pointer == 0;
if (needToFreeCache)
{
cache.memorySpace = memorySpace;
cache.mathDomain = mathDomain;
cache.size = (uint)Size;
Alloc(cache);
}
// calculate the difference
CuBlasApi.Subtract(cache, Buffer, rhs.Buffer);
// calculate how many non-zeros, overriding cache
CuBlasApi.IsNonZero(cache, cache);
double ret = CubApi.Sum(cache);
// we are counting the zero entries
ret = Size - ret;
if (needToFreeCache)
{
Free(cache);
}
return((int)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, double beta = 0.0)
{
if (lhsOperation == MatrixOperation.None)
{
Debug.Assert(rhs.nRows == nCols);
Debug.Assert(output.nRows == nRows);
Debug.Assert(output.nCols == rhs.nCols);
}
else
{
Debug.Assert(rhs.nCols == nCols);
Debug.Assert(output.nCols == nRows);
Debug.Assert(output.nRows == 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);
CuBlasApi.Multiply(output._buffer, _buffer, rhs._buffer, nRows, rhs.nRows, lhsOperation, rhsOperation, alpha, beta);
}
/// <summary>
/// Invert inplace - WARNING, use Solve for higher performance
/// </summary>
/// <param name="operation"></param>
public void Invert(MatrixOperation operation = MatrixOperation.None)
{
Debug.Assert(nRows == nCols);
Debug.Assert(Buffer.pointer != 0);
CuBlasApi.Invert(_buffer, operation);
}
/// <summary>
/// Solve A * X = B, B is overwritten
/// </summary>
/// <param name="rhs"></param>
/// <param name="lhsOperation"></param>
public void Solve(ColumnWiseMatrix rhs, MatrixOperation lhsOperation = MatrixOperation.None)
{
Debug.Assert(nRows == nCols);
Debug.Assert(Buffer.pointer != 0);
CuBlasApi.Solve(_buffer, rhs._buffer, lhsOperation);
}
/// <summary>
/// A = alpha * B + beta * A
/// </summary>
/// <param name="lhs"></param>
/// <param name="rhs"></param>
/// <param name="lhsOperation"></param>
/// <param name="rhsOperation"></param>
/// <param name="alpha"></param>
/// <param name="beta"></param>
/// <returns></returns>
public static ColumnWiseMatrix Add(ColumnWiseMatrix lhs, ColumnWiseMatrix rhs, MatrixOperation lhsOperation = MatrixOperation.None, MatrixOperation rhsOperation = MatrixOperation.None, double alpha = 1.0, double beta = 1.0)
{
ColumnWiseMatrix ret = new ColumnWiseMatrix(lhs);
CuBlasApi.AddEqualMatrix(ret._buffer, rhs._buffer, lhsOperation, rhsOperation, alpha, beta);
return(ret);
}
public static ColumnWiseMatrix Subtract(ColumnWiseMatrix lhs, ColumnWiseMatrix rhs, MatrixOperation lhsOperation = MatrixOperation.None, MatrixOperation rhsOperation = MatrixOperation.None)
{
ColumnWiseMatrix ret = new ColumnWiseMatrix(lhs);
CuBlasApi.AddEqualMatrix(ret._buffer, rhs._buffer, lhsOperation, rhsOperation, -1.0, 1.0);
return(ret);
}
public void AddEqual(ContiguousMemoryBuffer rhs, double alpha = 1.0)
{
Debug.Assert(Size == rhs.Size);
Debug.Assert(memorySpace == rhs.memorySpace);
Debug.Assert(mathDomain == rhs.mathDomain);
Debug.Assert(Buffer.pointer != 0);
Debug.Assert(rhs.Buffer.pointer != 0);
CuBlasApi.AddEqual(Buffer, rhs.Buffer, alpha);
}
public void SubtractEqual(ContiguousMemoryBuffer rhs)
{
Debug.Assert(Size == rhs.Size);
Debug.Assert(memorySpace == rhs.memorySpace);
Debug.Assert(mathDomain == rhs.mathDomain);
Debug.Assert(Buffer.pointer != 0);
Debug.Assert(rhs.Buffer.pointer != 0);
CuBlasApi.SubtractEqual(Buffer, rhs.Buffer);
}
public static SparseVector operator -(SparseVector lhs, SparseVector rhs)
{
Debug.Assert(lhs.Size == rhs.Size);
Debug.Assert(lhs.memorySpace == rhs.memorySpace);
Debug.Assert(lhs.mathDomain == rhs.mathDomain);
Debug.Assert(lhs.Buffer.pointer != 0);
Debug.Assert(rhs.Buffer.pointer != 0);
SparseVector ret = new SparseVector(lhs);
CuBlasApi.AddEqual(ret.Buffer, rhs.Buffer, -1.0);
return(ret);
}
public static Vector operator *(ColumnWiseMatrix lhs, Vector rhs)
{
Debug.Assert(rhs.Size == 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);
Vector ret = new Vector(rhs.Size, lhs.memorySpace, rhs.mathDomain);
CuBlasApi.Dot(ret.Buffer, lhs._buffer, rhs.Buffer, MatrixOperation.None, 1.0, 0.0);
return(ret);
}
public static ColumnWiseMatrix operator *(ColumnWiseMatrix 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, rhs.mathDomain);
CuBlasApi.Multiply(ret._buffer, lhs._buffer, rhs._buffer, lhs.nRows, rhs.nRows, MatrixOperation.None, MatrixOperation.None, 1.0, 0.0);
return(ret);
}
public static ColumnWiseMatrix operator -(ColumnWiseMatrix lhs, ColumnWiseMatrix rhs)
{
Debug.Assert(lhs.nRows == rhs.nRows);
Debug.Assert(lhs.nCols == rhs.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 tmp = new ColumnWiseMatrix(lhs);
CuBlasApi.AddEqualMatrix(tmp._buffer, rhs._buffer, MatrixOperation.None, MatrixOperation.None, -1.0, 1.0);
return(tmp);
}
/// <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="alpha"></param>
public void Dot(Vector output, Vector rhs, MatrixOperation lhsOperation = MatrixOperation.None, double alpha = 1.0, double beta = 0.0)
{
if (lhsOperation == MatrixOperation.None)
{
Debug.Assert(rhs.Size == nCols);
Debug.Assert(output.Size == nRows);
}
else
{
Debug.Assert(rhs.Size == nRows);
Debug.Assert(output.Size == 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);
CuBlasApi.Dot(output.Buffer, _buffer, rhs.Buffer, lhsOperation, alpha, beta);
}
internal static MemoryBuffer Add(MemoryBuffer lhs, MemoryBuffer rhs)
{
CuBlasApi.AddEqual(lhs, rhs, 1.0);
return(lhs);
}
public void MakeIdentity()
{
CuBlasApi.Eye(_buffer);
}
internal static MemoryBuffer Subtract(MemoryBuffer lhs, MemoryBuffer rhs)
{
CuBlasApi.SubtractEqual(lhs, rhs);
return(lhs);
}
internal static MemoryBuffer ElementWiseProduct(MemoryBuffer output, MemoryBuffer lhs, MemoryBuffer rhs)
{
CuBlasApi.ElementwiseProduct(output, lhs, rhs, 1.0);
return(output);
}
public void Scale(double alpha)
{
Debug.Assert(Buffer.pointer != 0);
CuBlasApi.Scale(Buffer, alpha);
}
public static void KroneckerProduct(ColumnWiseMatrix output, Vector lhs, Vector rhs, double alpha = 1.0)
{
CuBlasApi.KroneckerProduct(output._buffer, lhs.Buffer, rhs.Buffer, alpha);
}
public void ColumnWiseAbsoluteMaximumIndex(Vector output)
{
Debug.Assert(output.Buffer.pointer != 0);
Debug.Assert(output.Size == nCols);
CuBlasApi.ColumnWiseAbsoluteMaximumIndex(output.Buffer, _buffer);
}
public int AbsoluteMaximumIndex()
{
Debug.Assert(Buffer.pointer != 0);
return(CuBlasApi.AbsoluteMaximumIndex(Buffer));
}
