public static void MyFirstBlasEmulatorTest()
{
Console.WriteLine("MyTest()");
// Get GPU device
CudafyModes.Target = eGPUType.Emulator;
GPGPU gpu = CudafyHost.GetDevice(CudafyModes.Target);
// Create GPGPUBLAS (CUBLAS Wrapper)
using (GPGPUBLAS blas = GPGPUBLAS.Create(gpu))
{
const int N = 100;
float[] a = new float[N];
float[] b = new float[N];
float[] c = new float[N];
float alpha = -1;
float beta = 0;
float[] device_a = gpu.CopyToDevice(a);
float[] device_b = gpu.CopyToDevice(b);
float[] device_c = gpu.CopyToDevice(c);
int m = 10;
int n = 10;
int k = 10;
cublasOperation Op = cublasOperation.N;
blas.GEMM(m, k, n, alpha, device_a, device_b, beta, device_c, Op);
gpu.CopyFromDevice <float>(device_c, c);
}
}
//
// http://stackoverflow.com/questions/18628447/cudafy-throws-an-exception-while-testing
//
private static void BlasSample(int deviceId)
{
CudafyModes.Target = eGPUType.Emulator;
GPGPU gpu = CudafyHost.GetDevice(CudafyModes.Target, deviceId);
CudafyModes.DeviceId = deviceId;
eArchitecture arch = gpu.GetArchitecture();
CudafyModule km = CudafyTranslator.Cudafy(arch);
gpu.LoadModule(km);
GPGPUBLAS blas = GPGPUBLAS.Create(gpu);
const int N = 100;
float[] a = new float[N];
float[] b = new float[N];
float[] c = new float[N];
float alpha = -1;
float beta = 0;
float[] device_a = gpu.CopyToDevice(a);
float[] device_b = gpu.CopyToDevice(b);
float[] device_c = gpu.CopyToDevice(c);
int m = 10;
int n = 10;
int k = 10;
cublasOperation Op = cublasOperation.N;
blas.GEMM(m, k, n, alpha, device_a, device_b, beta, device_c, Op);
throw new NotImplementedException();
}
public CUBLASStatusv2 cublasSsyrk(cublasHandle handle, cublasFillMode uplo, cublasOperation trans, int n, int k, ref float alpha, IntPtr A, int lda, ref float beta, IntPtr C, int ldc)
{
throw new NotImplementedException();
}
private static extern CUBLASStatusv2 cublasDgemv_v2(cublasHandle handle, cublasOperation trans, int m, int n, ref double alpha, IntPtr A, int lda, IntPtr x, int incx, ref double beta, IntPtr y, int incy);
public CUBLASStatusv2 cublasSsyrk(cublasHandle handle, cublasFillMode uplo, cublasOperation trans, int n, int k, ref float alpha, IntPtr A, int lda, ref float beta, IntPtr C, int ldc)
{
return cublasSsyrk_v2(handle, uplo, trans, n, k, ref alpha, A, lda, ref beta, C, ldc);
}
public CUBLASStatusv2 cublasDgemv(cublasHandle handle, cublasOperation trans, int m, int n, ref double alpha, IntPtr A, int lda, IntPtr x, int incx, ref double beta, IntPtr y, int incy)
{
return cublasDgemv_v2(handle, trans, m, n, ref alpha, A, lda, x, incx, ref beta, y, incy);
}
private static extern CUBLASStatusv2 cublasSsyrk_v2(cublasHandle handle, cublasFillMode uplo, cublasOperation trans, int n, int k, ref float alpha, IntPtr A, int lda, ref float beta, IntPtr C, int ldc);
/// <summary> /// Performs the triangular matrix-matrix multiplication. /// C = alpha * op(A) * B (side left), /// C = alpha * B * op(A) (side right) /// </summary> /// <param name="m">number of rows of matrix B, with matrix A sized accordingly.</param> /// <param name="n">number of columns of matrix B, with matrix A sized accordingly.</param> /// <param name="alpha">scalar used for multiplication.</param> /// <param name="A">array of dimension m * m.</param> /// <param name="B">array of dimension m * n.</param> /// <param name="C">array of dimension m * n.</param> /// <param name="side">indicates if matrix A is on the left or right of B.</param> /// <param name="trans">operation op(A) that is non- or (conj.) transpose.</param> /// <param name="uplo">indicates if matrix A lower or upper part is stored, the other part is not refernced and is inferred from the stored elements.</param> /// <param name="diag">indicates if the elements on the main diagonal of matrix A are unity and should not be accessed.</param> /// <param name="lda">leading dimension of two-dimensional array used to store matrix A.</param> /// <param name="ldb">leading dimension of two-dimensional array used to store matrix B.</param> /// <param name="ldc">leading dimension of two-dimensional array used to store matrix C.</param> public abstract void TRMM(int m, int n, float alpha, float[] A, float[] B, float[] C, cublasSideMode side = cublasSideMode.Left, cublasOperation trans = cublasOperation.N, cublasFillMode uplo = cublasFillMode.Lower, cublasDiagType diag = cublasDiagType.NonUnit, int lda = 0, int ldb = 0, int ldc = 0);
public CUBLASStatusv2 cublasDgemv(cublasHandle handle, cublasOperation trans, int m, int n, ref double alpha, IntPtr A, int lda, IntPtr x, int incx, ref double beta, IntPtr y, int incy)
{
return(cublasDgemv_v2(handle, trans, m, n, ref alpha, A, lda, x, incx, ref beta, y, incy));
}
public CUBLASStatusv2 cublasSgbmv(cublasHandle handle, cublasOperation trans, int m, int n, int kl, int ku, ref float alpha, IntPtr A, int lda, IntPtr x, int incx, ref float beta, IntPtr y, int incy)
{
return(cublasSgbmv_v2(handle, trans, m, n, kl, ku, ref alpha, A, lda, x, incx, ref beta, y, incy));
}
private static extern CUBLASStatusv2 cublasDtrsm_v2(cublasHandle handle, cublasSideMode side, cublasFillMode uplo, cublasOperation trans, cublasDiagType diag, int m, int n, ref double alpha, IntPtr A, int lda, IntPtr B, int ldb);
private static extern CUBLASStatusv2 cublasDsyr2k_v2(cublasHandle handle, cublasFillMode uplo, cublasOperation trans, int n, int k, ref double alpha, IntPtr A, int lda, IntPtr B, int ldb, ref double beta, IntPtr C, int ldc);
private static extern CUBLASStatusv2 cublasSsyrk_v2(cublasHandle handle, cublasFillMode uplo, cublasOperation trans, int n, int k, ref float alpha, IntPtr A, int lda, ref float beta, IntPtr C, int ldc);
private static extern CUBLASStatusv2 cublasDgemm_v2(cublasHandle handle, cublasOperation transa, cublasOperation transb, int m, int n, int k, ref double alpha, IntPtr A, int lda, IntPtr B, int ldb, ref double beta, IntPtr C, int ldc);
private static extern CUBLASStatusv2 cublasDtrsv_v2(cublasHandle handle, cublasFillMode uplo, cublasOperation trans, cublasDiagType diag, int n, IntPtr A, int lda, IntPtr x, int incx);
/// <summary> /// Performs the matrix-matrix multiplication. /// C = alpha * op(A) * op(B) + beta * C /// </summary> /// <param name="m">number of rows of matrix op(A) and C.</param> /// <param name="k">number of columns of matix op(A) and rows of op(B).</param> /// <param name="n">number of columns of matix op(B) and C.</param> /// <param name="alpha">scalar used for multiplication.</param> /// <param name="A">arrasy of dimensions m * k.</param> /// <param name="B">array of dimension k * n.</param> /// <param name="beta">scalar used for multiplication.</param> /// <param name="C">array of dimension m * n.</param> /// <param name="transa">operation op(A) that is non- or (conj.) transpose.</param> /// <param name="transb">operation op(B) that is non- or (conj.) transpose.</param> /// <param name="lda">leading dimension of two-dimensional array used to store the matrix A.</param> /// <param name="ldb">leading dimension of two-dimensional array used to store the matrix B.</param> /// <param name="ldc">leading dimension of two-dimensional array used to store the matrix C.</param> public abstract void GEMM(int m, int k, int n, float alpha, float[] A, float[] B, float beta, float[] C, cublasOperation transa = cublasOperation.N, cublasOperation transb = cublasOperation.N, int lda = 0, int ldb = 0, int ldc = 0);
/// <summary> /// Performs the symmetric rank-2k update. /// C = alpha * (op(A) * transpose(op(B)) + op(B) * transpose(op(A))) + beta * C /// </summary> /// <param name="n">number of rows of matrix op(A), op(B) and C.</param> /// <param name="k">number of columns of matrix op(A) and op(B).</param> /// <param name="alpha">scalar used for multiplication.</param> /// <param name="A">array of dimension n * k.</param> /// <param name="B">array of dimension n * k.</param> /// <param name="beta">scalar used for multiplication.</param> /// <param name="C">array of dimension n * n.</param> /// <param name="trans">operation op(A), op(B) that is non- or transpose.</param> /// <param name="uplo">indicates if matrix C lower of upper part is stored, the other symmetric part is not referenced and is inferred from the stored elements.</param> /// <param name="lda">leading dimension of two-dimensional array used to store matrix A.</param> /// <param name="ldb">leading dimension of two-dimensional array used to store matrix B.</param> /// <param name="ldc">leading dimension of two-dimensional array used to store matrix C.</param> public abstract void SYR2K(int n, int k, float alpha, float[] A, float[] B, float beta, float[] C, cublasOperation trans = cublasOperation.N, cublasFillMode uplo = cublasFillMode.Lower, int lda = 0, int ldb = 0, int ldc = 0);
public CUBLASStatusv2 cublasDtrsv(cublasHandle handle, cublasFillMode uplo, cublasOperation trans, cublasDiagType diag, int n, IntPtr A, int lda, IntPtr x, int incx)
{
return(cublasDtrsv_v2(handle, uplo, trans, diag, n, A, lda, x, incx));
}
private static extern CUBLASStatusv2 cublasDtrsv_v2(cublasHandle handle, cublasFillMode uplo, cublasOperation trans, cublasDiagType diag, int n, IntPtr A, int lda, IntPtr x, int incx);
public CUBLASStatusv2 cublasDgemm(cublasHandle handle, cublasOperation transa, cublasOperation transb, int m, int n, int k, ref double alpha, IntPtr A, int lda, IntPtr B, int ldb, ref double beta, IntPtr C, int ldc)
{
return(cublasDgemm_v2(handle, transa, transb, m, n, k, ref alpha, A, lda, B, ldb, ref beta, C, ldc));
}
private static extern CUBLASStatusv2 cublasDtrsm_v2(cublasHandle handle, cublasSideMode side, cublasFillMode uplo, cublasOperation trans, cublasDiagType diag, int m, int n, ref double alpha, IntPtr A, int lda, IntPtr B, int ldb);
private static extern CUBLASStatusv2 cublasSgbmv_v2(cublasHandle handle, cublasOperation trans, int m, int n, int kl, int ku, ref float alpha, IntPtr A, int lda, IntPtr x, int incx, ref float beta, IntPtr y, int incy);
public CUBLASStatusv2 cublasDgemm(cublasHandle handle, cublasOperation transa, cublasOperation transb, int m, int n, int k, ref double alpha, IntPtr A, int lda, IntPtr B, int ldb, ref double beta, IntPtr C, int ldc)
{
return cublasDgemm_v2(handle, transa, transb, m, n, k, ref alpha, A, lda, B, ldb, ref beta, C, ldc);
}
public CUBLASStatusv2 cublasSsyrk(cublasHandle handle, cublasFillMode uplo, cublasOperation trans, int n, int k, ref float alpha, IntPtr A, int lda, ref float beta, IntPtr C, int ldc)
{
return(cublasSsyrk_v2(handle, uplo, trans, n, k, ref alpha, A, lda, ref beta, C, ldc));
}
public CUBLASStatusv2 cublasStrmm(cublasHandle handle, cublasSideMode side, cublasFillMode uplo, cublasOperation trans, cublasDiagType diag, int m, int n, ref float alpha, IntPtr A, int lda, IntPtr B, int ldb, IntPtr C, int ldc)
{
return cublasStrmm_v2(handle, side, uplo, trans, diag, m, n, ref alpha, A, lda, B, ldb, C, ldc);
}
public CUBLASStatusv2 cublasDsyr2k(cublasHandle handle, cublasFillMode uplo, cublasOperation trans, int n, int k, ref double alpha, IntPtr A, int lda, IntPtr B, int ldb, ref double beta, IntPtr C, int ldc)
{
return(cublasDsyr2k_v2(handle, uplo, trans, n, k, ref alpha, A, lda, B, ldb, ref beta, C, ldc));
}
public CUBLASStatusv2 cublasDtrsv(cublasHandle handle, cublasFillMode uplo, cublasOperation trans, cublasDiagType diag, int n, IntPtr A, int lda, IntPtr x, int incx)
{
throw new NotImplementedException();
}
public CUBLASStatusv2 cublasStrmm(cublasHandle handle, cublasSideMode side, cublasFillMode uplo, cublasOperation trans, cublasDiagType diag, int m, int n, ref float alpha, IntPtr A, int lda, IntPtr B, int ldb, IntPtr C, int ldc)
{
return(cublasStrmm_v2(handle, side, uplo, trans, diag, m, n, ref alpha, A, lda, B, ldb, C, ldc));
}
public CUBLASStatusv2 cublasDtrsm(cublasHandle handle, cublasSideMode side, cublasFillMode uplo, cublasOperation trans, cublasDiagType diag, int m, int n, ref double alpha, IntPtr A, int lda, IntPtr B, int ldb)
{
throw new NotImplementedException();
}
public CUBLASStatusv2 cublasDtrsm(cublasHandle handle, cublasSideMode side, cublasFillMode uplo, cublasOperation trans, cublasDiagType diag, int m, int n, ref double alpha, IntPtr A, int lda, IntPtr B, int ldb)
{
return(cublasDtrsm_v2(handle, side, uplo, trans, diag, m, n, ref alpha, A, lda, B, ldb));
}
/// <summary> /// Solves the triangular linear system with a single right-hand-side. /// x = op(A)^-1 * x /// </summary> /// <param name="n">number of rows and columns of matrix A.</param> /// <param name="A">array of dimensions lda * n with lda >= max(1, n).</param> /// <param name="x">vector with n elements.</param> /// <param name="trans">operation op(A) that is non- or (conj.) transpose.</param> /// <param name="uplo">indicates if matrix A lower or upper part is stored, the other part is not referenced and is inferred from the stored elements.</param> /// <param name="diag">indicates if the elements on the main diagonal of matrix A are unity and should not be accessed.</param> /// <param name="lda">leading dimension of two-dimensional array used to store matrix A. if lda = 0, lda is automatically be n.</param> /// <param name="incx">stride between consecutive elements of x.</param> public abstract void TRSV(int n, double[] A, double[] x, cublasOperation trans = cublasOperation.N, cublasFillMode uplo = cublasFillMode.Lower, cublasDiagType diag = cublasDiagType.NonUnit, int lda = 0, int incx = 1);
private static extern CUBLASStatusv2 cublasDgemv_v2(cublasHandle handle, cublasOperation trans, int m, int n, ref double alpha, IntPtr A, int lda, IntPtr x, int incx, ref double beta, IntPtr y, int incy);
/// <summary> /// Performs the matrix-matrix multiplication. /// C = alpha * op(A) * op(B) + beta * C /// </summary> /// <param name="m">number of rows of matrix op(A) and C.</param> /// <param name="k">number of columns of matix op(A) and rows of op(B).</param> /// <param name="n">number of columns of matix op(B) and C.</param> /// <param name="alpha">scalar used for multiplication.</param> /// <param name="A">arrasy of dimensions m * k.</param> /// <param name="B">array of dimension k * n.</param> /// <param name="beta">scalar used for multiplication.</param> /// <param name="C">array of dimension m * n.</param> /// <param name="transa">operation op(A) that is non- or (conj.) transpose.</param> /// <param name="transb">operation op(B) that is non- or (conj.) transpose.</param> /// <param name="lda">leading dimension of two-dimensional array used to store the matrix A.</param> /// <param name="ldb">leading dimension of two-dimensional array used to store the matrix B.</param> /// <param name="ldc">leading dimension of two-dimensional array used to store the matrix C.</param> public abstract void GEMM(int m, int k, int n, double alpha, double[] A, double[] B, double beta, double[] C, cublasOperation transa = cublasOperation.N, cublasOperation transb = cublasOperation.N, int lda = 0, int ldb = 0, int ldc = 0);
public CUBLASStatusv2 cublasSgbmv(cublasHandle handle, cublasOperation trans, int m, int n, int kl, int ku, ref float alpha, IntPtr A, int lda, IntPtr x, int incx, ref float beta, IntPtr y, int incy)
{
throw new NotImplementedException();
}
/// <summary> /// Performs the symmetric rank-2k update. /// C = alpha * (op(A) * transpose(op(B)) + op(B) * transpose(op(A))) + beta * C /// </summary> /// <param name="n">number of rows of matrix op(A), op(B) and C.</param> /// <param name="k">number of columns of matrix op(A) and op(B).</param> /// <param name="alpha">scalar used for multiplication.</param> /// <param name="A">array of dimension n * k.</param> /// <param name="B">array of dimension n * k.</param> /// <param name="beta">scalar used for multiplication.</param> /// <param name="C">array of dimension n * n.</param> /// <param name="trans">operation op(A), op(B) that is non- or transpose.</param> /// <param name="uplo">indicates if matrix C lower of upper part is stored, the other symmetric part is not referenced and is inferred from the stored elements.</param> /// <param name="lda">leading dimension of two-dimensional array used to store matrix A.</param> /// <param name="ldb">leading dimension of two-dimensional array used to store matrix B.</param> /// <param name="ldc">leading dimension of two-dimensional array used to store matrix C.</param> public abstract void SYR2K(int n, int k, double alpha, double[] A, double[] B, double beta, double[] C, cublasOperation trans = cublasOperation.N, cublasFillMode uplo = cublasFillMode.Lower, int lda = 0, int ldb = 0, int ldc = 0);
public CUBLASStatusv2 cublasDgemv(cublasHandle handle, cublasOperation trans, int m, int n, ref double alpha, IntPtr A, int lda, IntPtr x, int incx, ref double beta, IntPtr y, int incy)
{
throw new NotImplementedException();
}
/// <summary> /// Solves the triangular linear system with multiple right-hand-sides. /// B = alpha * (op(A))^-1 * B (left side), /// B = alpha * B * (op(A))^-1 (right side) /// </summary> /// <param name="m">number of rows of matrix B, with matrix A sized accordingly.</param> /// <param name="n">number of columns of matrix B, with matrix A sized accordingly.</param> /// <param name="alpha">scalar used for multiplication.</param> /// <param name="A">array of dimension m * m (n * n right side).</param> /// <param name="B">array of dimension m * n.</param> /// <param name="side">indicates if matrix A is on the left or right of B.</param> /// <param name="trans">operation op(A) that is non- or (conj.) transpose.</param> /// <param name="uplo">indicates if matrix A lower or upper part is stored, the other part is not refernced and is inferred from the stored elements.</param> /// <param name="diag">indicates if the elements on the main diagonal of matrix A are unity and should not be accessed.</param> /// <param name="lda">leading dimension of two-dimensional array used to store matrix A.</param> /// <param name="ldb">leading dimension of two-dimensional array used to store matrix B.</param> public abstract void TRSM(int m, int n, double alpha, double[] A, double[] B, cublasSideMode side = cublasSideMode.Left, cublasOperation trans = cublasOperation.N, cublasFillMode uplo = cublasFillMode.Lower, cublasDiagType diag = cublasDiagType.NonUnit, int lda = 0, int ldb = 0);
public CUBLASStatusv2 cublasDtrsv(cublasHandle handle, cublasFillMode uplo, cublasOperation trans, cublasDiagType diag, int n, IntPtr A, int lda, IntPtr x, int incx)
{
throw new NotImplementedException();
}
private static extern CUBLASStatusv2 cublasDgemm_v2(cublasHandle handle, cublasOperation transa, cublasOperation transb, int m, int n, int k, ref double alpha, IntPtr A, int lda, IntPtr B, int ldb, ref double beta, IntPtr C, int ldc);
public CUBLASStatusv2 cublasDgemm(cublasHandle handle, cublasOperation transa, cublasOperation transb, int m, int n, int k, ref double alpha, IntPtr A, int lda, IntPtr B, int ldb, ref double beta, IntPtr C, int ldc)
{
throw new NotImplementedException();
}
private static extern CUBLASStatusv2 cublasDsyr2k_v2(cublasHandle handle, cublasFillMode uplo, cublasOperation trans, int n, int k, ref double alpha, IntPtr A, int lda, IntPtr B, int ldb, ref double beta, IntPtr C, int ldc);
public CUBLASStatusv2 cublasSsyrk(cublasHandle handle, cublasFillMode uplo, cublasOperation trans, int n, int k, ref float alpha, IntPtr A, int lda, ref float beta, IntPtr C, int ldc)
{
throw new NotImplementedException();
}
public CUBLASStatusv2 cublasSgbmv(cublasHandle handle, cublasOperation trans, int m, int n, int kl, int ku, ref float alpha, IntPtr A, int lda, IntPtr x, int incx, ref float beta, IntPtr y, int incy)
{
return cublasSgbmv_v2(handle, trans, m, n, kl, ku, ref alpha, A, lda, x, incx, ref beta, y, incy);
}
public CUBLASStatusv2 cublasDsyr2k(cublasHandle handle, cublasFillMode uplo, cublasOperation trans, int n, int k, ref double alpha, IntPtr A, int lda, IntPtr B, int ldb, ref double beta, IntPtr C, int ldc)
{
throw new NotImplementedException();
}
public CUBLASStatusv2 cublasDtrsv(cublasHandle handle, cublasFillMode uplo, cublasOperation trans, cublasDiagType diag, int n, IntPtr A, int lda, IntPtr x, int incx)
{
return cublasDtrsv_v2(handle, uplo, trans, diag, n, A, lda, x, incx);
}
public CUBLASStatusv2 cublasDtrsm(cublasHandle handle, cublasSideMode side, cublasFillMode uplo, cublasOperation trans, cublasDiagType diag, int m, int n, ref double alpha, IntPtr A, int lda, IntPtr B, int ldb)
{
throw new NotImplementedException();
}
private static extern CUBLASStatusv2 cublasSgbmv_v2(cublasHandle handle, cublasOperation trans, int m, int n, int kl, int ku, ref float alpha, IntPtr A, int lda, IntPtr x, int incx, ref float beta, IntPtr y, int incy);
public override void GEMV(int m, int n, double alpha, double[] A, double[] x, double beta, double[] y, cublasOperation op = cublasOperation.N, int lda = 0, int incx = 1, int incy = 1)
{
throw new NotImplementedException();
}
public CUBLASStatusv2 cublasDsyr2k(cublasHandle handle, cublasFillMode uplo, cublasOperation trans, int n, int k, ref double alpha, IntPtr A, int lda, IntPtr B, int ldb, ref double beta, IntPtr C, int ldc)
{
return cublasDsyr2k_v2(handle, uplo, trans, n, k, ref alpha, A, lda, B, ldb, ref beta, C, ldc);
}
public override void TRSV(int n, double[] A, double[] x, cublasOperation trans = cublasOperation.N, cublasFillMode uplo = cublasFillMode.Lower, cublasDiagType diag = cublasDiagType.NonUnit, int lda = 0, int incx = 1)
{
throw new NotImplementedException();
}
public CUBLASStatusv2 cublasDtrsm(cublasHandle handle, cublasSideMode side, cublasFillMode uplo, cublasOperation trans, cublasDiagType diag, int m, int n, ref double alpha, IntPtr A, int lda, IntPtr B, int ldb)
{
return cublasDtrsm_v2(handle, side, uplo, trans, diag, m, n, ref alpha, A, lda, B, ldb);
}
public override void GEMM(int m, int k, int n, double alpha, double[] A, double[] B, double beta, double[] C, cublasOperation transa = cublasOperation.N, cublasOperation transb = cublasOperation.N, int lda = 0, int ldb = 0, int ldc = 0)
{
throw new NotImplementedException();
}
public CUBLASStatusv2 cublasSgemv(cublasHandle handle, cublasOperation trans, int m, int n, ref float alpha, IntPtr A, int lda, IntPtr x, int incx, ref float beta, IntPtr y, int incy)
{
throw new NotImplementedException();
}
public override void SYRK(int n, int k, float alpha, float[] A, float beta, float[] C, cublasOperation trans = cublasOperation.N, cublasFillMode uplo = cublasFillMode.Lower, int lda = 0, int ldc = 0)
{
throw new NotImplementedException();
}
public CUBLASStatusv2 cublasDgemm(cublasHandle handle, cublasOperation transa, cublasOperation transb, int m, int n, int k, ref double alpha, IntPtr A, int lda, IntPtr B, int ldb, ref double beta, IntPtr C, int ldc)
{
throw new NotImplementedException();
}
public override void SYR2K(int n, int k, double alpha, double[] A, double[] B, double beta, double[] C, cublasOperation trans = cublasOperation.N, cublasFillMode uplo = cublasFillMode.Lower, int lda = 0, int ldb = 0, int ldc = 0)
{
throw new NotImplementedException();
}
public CUBLASStatusv2 cublasDsyr2k(cublasHandle handle, cublasFillMode uplo, cublasOperation trans, int n, int k, ref double alpha, IntPtr A, int lda, IntPtr B, int ldb, ref double beta, IntPtr C, int ldc)
{
throw new NotImplementedException();
}
public override void TRSM(int m, int n, double alpha, double[] A, double[] B, cublasSideMode side = cublasSideMode.Left, cublasOperation trans = cublasOperation.N, cublasFillMode uplo = cublasFillMode.Lower, cublasDiagType diag = cublasDiagType.NonUnit, int lda = 0, int ldb = 0)
{
throw new NotImplementedException();
}
public CUBLASStatusv2 cublasDgbmv(cublasHandle handle, cublasOperation trans, int m, int n, int kl, int ku, ref double alpha, IntPtr A, int lda, IntPtr x, int incx, ref double beta, IntPtr y, int incy)
{
throw new NotImplementedException();
}
/// <summary> /// Solves the packed triangular linear system with a single right-hand-side. /// x = op(A)^-1 * x /// </summary> /// <param name="n">number of rows and columns of matrix A.</param> /// <param name="AP">array with A stored in packed format.</param> /// <param name="x">vector with n elements.</param> /// <param name="trans">operation op(A) that is non- or (conj.) transpose.</param> /// <param name="uplo">indicates if matrix A lower or upper part is stored, the other part is not referenced and is inferred from the stored elements.</param> /// <param name="diag">indicates if the elements on the main diagonal of matrix A are unity and should not be accessed.</param> /// <param name="incx">stride between consecutive elements of x.</param> public abstract void TPSV(int n, float[] AP, float[] x, cublasOperation trans = cublasOperation.N, cublasFillMode uplo = cublasFillMode.Lower, cublasDiagType diag = cublasDiagType.NonUnit, int incx = 1);
