tsai
/
mathnet-numerics
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Cleaned up the safe call mechanism further, and made all the managed changes.

cuda
Matthew Johnson 11 years ago
committed by Christoph Ruegg
parent
43d7a794ab
commit
ca0a1ab801
11 changed files with 184 additions and 193 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 138
      src/NativeProviders/CUDA/blas.cpp
  2. 26
      src/NativeProviders/CUDA/capabilities.cpp
  3. 3
      src/NativeProviders/CUDA/wrapper_cuda.h
  4. 4
      src/Numerics/Control.cs
  5. 32
      src/Numerics/Providers/LinearAlgebra/Cuda/CudaLinearAlgebraProvider.Complex.cs
  6. 32
      src/Numerics/Providers/LinearAlgebra/Cuda/CudaLinearAlgebraProvider.Complex32.cs
  7. 32
      src/Numerics/Providers/LinearAlgebra/Cuda/CudaLinearAlgebraProvider.Double.cs
  8. 32
      src/Numerics/Providers/LinearAlgebra/Cuda/CudaLinearAlgebraProvider.Single.cs
  9. 4
      src/Numerics/Providers/LinearAlgebra/Cuda/CudaLinearAlgebraProvider.cs
  10. 2
      src/Numerics/Providers/LinearAlgebra/Cuda/CudaResults.cs
  11. 72
      src/Numerics/Providers/LinearAlgebra/Cuda/SafeNativeMethods.cs

138
src/NativeProviders/CUDA/blas.cpp
View File

@ -4,201 +4,173 @@
#include "wrapper_cuda.h"
template<typename T, typename AXPY>
void cuda_axpy(const cublasHandle_t blasHandle, const int n, const T alpha, const T x[], int incX, T y[], int incY, AXPY axpy, cudaError_t *error, cublasStatus_t *blasStatus)
CudaResults cuda_axpy(const cublasHandle_t blasHandle, const int n, const T alpha, const T x[], int incX, T y[], int incY, AXPY axpy)
{
T *d_X = NULL;
T *d_Y = NULL;
*error = cudaError_t::cudaSuccess;
*blasStatus = cublasStatus_t::CUBLAS_STATUS_SUCCESS;
CudaResults results;
SAFECUDACALL(error, cudaMalloc((void**)&d_X, n*sizeof(T)))
SAFECUDACALL(error, cudaMalloc((void**)&d_Y, n*sizeof(T)))
SAFECUDACALL(results.error, cudaMalloc((void**)&d_X, n*sizeof(T)));
SAFECUDACALL(results.error, cudaMalloc((void**)&d_Y, n*sizeof(T)));
SAFECUDACALL(blasStatus, cublasSetVector(n, sizeof(T), x, incX, d_X, incX))
SAFECUDACALL(blasStatus, cublasSetVector(n, sizeof(T), y, incY, d_Y, incY))
SAFECUDACALL(results.blasStatus, cublasSetVector(n, sizeof(T), x, incX, d_X, incX));
SAFECUDACALL(results.blasStatus, cublasSetVector(n, sizeof(T), y, incY, d_Y, incY));
SAFECUDACALL(blasStatus, axpy(blasHandle, n, &alpha, d_X, incX, d_Y, incX))
SAFECUDACALL(results.blasStatus, axpy(blasHandle, n, &alpha, d_X, incX, d_Y, incX));
SAFECUDACALL(blasStatus, cublasGetVector(n, sizeof(T), d_Y, incY, y, incY))
SAFECUDACALL(results.blasStatus, cublasGetVector(n, sizeof(T), d_Y, incY, y, incY));
exit:
cudaFree(d_X);
cudaFree(d_Y);
return results;
}
template<typename T, typename SCAL>
void cuda_scal(const cublasHandle_t blasHandle, const int n, const T alpha, T x[], int incX, SCAL scal, cudaError_t *error, cublasStatus_t *blasStatus)
CudaResults cuda_scal(const cublasHandle_t blasHandle, const int n, const T alpha, T x[], int incX, SCAL scal)
{
T *d_X = NULL;
*error = cudaError_t::cudaSuccess;
*blasStatus = cublasStatus_t::CUBLAS_STATUS_SUCCESS;
CudaResults results;
SAFECUDACALL(error, cudaMalloc((void**)&d_X, n*sizeof(T)))
SAFECUDACALL(blasStatus, cublasSetVector(n, sizeof(T), x, incX, d_X, incX))
SAFECUDACALL(blasStatus, scal(blasHandle, n, &alpha, d_X, incX))
SAFECUDACALL(blasStatus, cublasGetVector(n, sizeof(T), d_X, incX, x, incX))
SAFECUDACALL(results.error, cudaMalloc((void**)&d_X, n*sizeof(T)));
SAFECUDACALL(results.blasStatus, cublasSetVector(n, sizeof(T), x, incX, d_X, incX));
SAFECUDACALL(results.blasStatus, scal(blasHandle, n, &alpha, d_X, incX));
SAFECUDACALL(results.blasStatus, cublasGetVector(n, sizeof(T), d_X, incX, x, incX));
exit:
cudaFree(d_X);
return results;
}
template<typename T, typename DOT>
void cuda_dot(const cublasHandle_t blasHandle, const int n, const T x[], int incX, const T y[], int incY, T* result, DOT dot, cudaError_t *error, cublasStatus_t *blasStatus)
CudaResults cuda_dot(const cublasHandle_t blasHandle, const int n, const T x[], int incX, const T y[], int incY, T* result, DOT dot)
{
T *d_X = NULL;
T *d_Y = NULL;
*error = cudaError_t::cudaSuccess;
*blasStatus = cublasStatus_t::CUBLAS_STATUS_SUCCESS;
CudaResults results;
SAFECUDACALL(error, cudaMalloc((void**)&d_X, n*sizeof(T)))
SAFECUDACALL(error, cudaMalloc((void**)&d_Y, n*sizeof(T)))
SAFECUDACALL(results.error, cudaMalloc((void**)&d_X, n*sizeof(T)));
SAFECUDACALL(results.error, cudaMalloc((void**)&d_Y, n*sizeof(T)));
SAFECUDACALL(blasStatus, cublasSetVector(n, sizeof(T), x, incX, d_X, incX))
SAFECUDACALL(blasStatus, cublasSetVector(n, sizeof(T), y, incY, d_Y, incY))
SAFECUDACALL(results.blasStatus, cublasSetVector(n, sizeof(T), x, incX, d_X, incX));
SAFECUDACALL(results.blasStatus, cublasSetVector(n, sizeof(T), y, incY, d_Y, incY));
SAFECUDACALL(blasStatus, dot(blasHandle, n, d_X, incX, d_Y, incY, result))
SAFECUDACALL(results.blasStatus, dot(blasHandle, n, d_X, incX, d_Y, incY, result));
exit:
cudaFree(d_X);
cudaFree(d_Y);
return results;
}
template<typename T, typename GEMM>
void cuda_gemm(const cublasHandle_t handle, const cublasOperation_t transa, const cublasOperation_t transb, int m, int n, int k, const T alpha, const T A[], int lda, const T B[], int ldb, const T beta, T C[], int ldc, GEMM gemm, cudaError_t *error, cublasStatus_t *blasStatus)
CudaResults cuda_gemm(const cublasHandle_t handle, const cublasOperation_t transa, const cublasOperation_t transb, int m, int n, int k, const T alpha, const T A[], int lda, const T B[], int ldb, const T beta, T C[], int ldc, GEMM gemm)
{
T *d_A = NULL;
T *d_B = NULL;
T *d_C = NULL;
*error = cudaError_t::cudaSuccess;
*blasStatus = cublasStatus_t::CUBLAS_STATUS_SUCCESS;
CudaResults results;
SAFECUDACALL(error, cudaMalloc((void**)&d_A, m*k*sizeof(T)))
SAFECUDACALL(blasStatus, cublasSetMatrix(m, k, sizeof(T), A, m, d_A, m))
SAFECUDACALL(results.error, cudaMalloc((void**)&d_A, m*k*sizeof(T)));
SAFECUDACALL(results.blasStatus, cublasSetMatrix(m, k, sizeof(T), A, m, d_A, m));
SAFECUDACALL(error, cudaMalloc((void**)&d_B, k*n*sizeof(T)))
SAFECUDACALL(blasStatus, cublasSetMatrix(k, n, sizeof(T), B, k, d_B, k))
SAFECUDACALL(results.error, cudaMalloc((void**)&d_B, k*n*sizeof(T)));
SAFECUDACALL(results.blasStatus, cublasSetMatrix(k, n, sizeof(T), B, k, d_B, k));
SAFECUDACALL(error, cudaMalloc((void**)&d_C, m*n*sizeof(T)))
SAFECUDACALL(blasStatus, cublasSetMatrix(m, n, sizeof(T), C, m, d_C, m))
SAFECUDACALL(results.error, cudaMalloc((void**)&d_C, m*n*sizeof(T)));
SAFECUDACALL(results.blasStatus, cublasSetMatrix(m, n, sizeof(T), C, m, d_C, m));
SAFECUDACALL(blasStatus, gemm(handle, transa, transb, m, n, k, &alpha, d_A, lda, d_B, ldb, &beta, d_C, ldc))
SAFECUDACALL(results.blasStatus, gemm(handle, transa, transb, m, n, k, &alpha, d_A, lda, d_B, ldb, &beta, d_C, ldc));
SAFECUDACALL(blasStatus, cublasGetMatrix(m, n, sizeof(T), d_C, m, C, m))
SAFECUDACALL(results.blasStatus, cublasGetMatrix(m, n, sizeof(T), d_C, m, C, m));
exit:
cudaFree(d_A);
cudaFree(d_B);
cudaFree(d_C);
return results;
}
extern "C" {
DLLEXPORT CudaResults s_axpy(const cublasHandle_t blasHandle, const int n, const float alpha, const float x[], float y[]){
CudaResults ret;
cuda_axpy(blasHandle, n, alpha, x, 1, y, 1, cublasSaxpy, &ret.error, &ret.blasStatus);
return ret;
return cuda_axpy(blasHandle, n, alpha, x, 1, y, 1, cublasSaxpy);
}
DLLEXPORT CudaResults d_axpy(const cublasHandle_t blasHandle, const int n, const double alpha, const double x[], double y[]){
CudaResults ret;
cuda_axpy(blasHandle, n, alpha, x, 1, y, 1, cublasDaxpy, &ret.error, &ret.blasStatus);
return ret;
return cuda_axpy(blasHandle, n, alpha, x, 1, y, 1, cublasDaxpy);
}
DLLEXPORT CudaResults c_axpy(const cublasHandle_t blasHandle, const int n, const cuComplex alpha, const cuComplex x[], cuComplex y[]){
CudaResults ret;
cuda_axpy(blasHandle, n, alpha, x, 1, y, 1, cublasCaxpy, &ret.error, &ret.blasStatus);
return ret;
return cuda_axpy(blasHandle, n, alpha, x, 1, y, 1, cublasCaxpy);
}
DLLEXPORT CudaResults z_axpy(const cublasHandle_t blasHandle, const int n, const cuDoubleComplex alpha, const cuDoubleComplex x[], cuDoubleComplex y[]){
CudaResults ret;
cuda_axpy(blasHandle, n, alpha, x, 1, y, 1, cublasZaxpy, &ret.error, &ret.blasStatus);
return ret;
return cuda_axpy(blasHandle, n, alpha, x, 1, y, 1, cublasZaxpy);
}
DLLEXPORT CudaResults s_scale(const cublasHandle_t blasHandle, const int n, const float alpha, float x[]){
CudaResults ret;
cuda_scal(blasHandle, n, alpha, x, 1, cublasSscal, &ret.error, &ret.blasStatus);
return ret;
return cuda_scal(blasHandle, n, alpha, x, 1, cublasSscal);
}
DLLEXPORT CudaResults d_scale(const cublasHandle_t blasHandle, const int n, const double alpha, double x[]){
CudaResults ret;
cuda_scal(blasHandle, n, alpha, x, 1, cublasDscal, &ret.error, &ret.blasStatus);
return ret;
return cuda_scal(blasHandle, n, alpha, x, 1, cublasDscal);
}
DLLEXPORT CudaResults c_scale(const cublasHandle_t blasHandle, const int n, const cuComplex alpha, cuComplex x[]){
CudaResults ret;
cuda_scal(blasHandle, n, alpha, x, 1, cublasCscal, &ret.error, &ret.blasStatus);
return ret;
return cuda_scal(blasHandle, n, alpha, x, 1, cublasCscal);
}
DLLEXPORT CudaResults z_scale(const cublasHandle_t blasHandle, const int n, const cuDoubleComplex alpha, cuDoubleComplex x[]){
CudaResults ret;
cuda_scal(blasHandle, n, alpha, x, 1, cublasZscal, &ret.error, &ret.blasStatus);
return ret;
return cuda_scal(blasHandle, n, alpha, x, 1, cublasZscal);
}
DLLEXPORT CudaResults s_dot_product(const cublasHandle_t blasHandle, const int n, const float x[], const float y[], float *result){
CudaResults ret;
cuda_dot(blasHandle, n, x, 1, y, 1, result, cublasSdot, &ret.error, &ret.blasStatus);
return ret;
return cuda_dot(blasHandle, n, x, 1, y, 1, result, cublasSdot);
}
DLLEXPORT CudaResults d_dot_product(const cublasHandle_t blasHandle, const int n, const double x[], const double y[], double *result){
CudaResults ret;
cuda_dot(blasHandle, n, x, 1, y, 1, result, cublasDdot, &ret.error, &ret.blasStatus);
return ret;
return cuda_dot(blasHandle, n, x, 1, y, 1, result, cublasDdot);
}
DLLEXPORT CudaResults c_dot_product(const cublasHandle_t blasHandle, const int n, const cuComplex x[], const cuComplex y[], cuComplex *result){
CudaResults ret;
cuda_dot(blasHandle, n, x, 1, y, 1, result, cublasCdotu, &ret.error, &ret.blasStatus);
return ret;
return cuda_dot(blasHandle, n, x, 1, y, 1, result, cublasCdotu);
}
DLLEXPORT CudaResults z_dot_product(const cublasHandle_t blasHandle, const int n, const cuDoubleComplex x[], const cuDoubleComplex y[], cuDoubleComplex *result){
CudaResults ret;
cuda_dot(blasHandle, n, x, 1, y, 1, result, cublasZdotu, &ret.error, &ret.blasStatus);
return ret;
return cuda_dot(blasHandle, n, x, 1, y, 1, result, cublasZdotu);
}
DLLEXPORT CudaResults s_matrix_multiply(const cublasHandle_t blasHandle, cublasOperation_t transA, cublasOperation_t transB, const int m, const int n, const int k, const float alpha, const float x[], const float y[], const float beta, float c[]){
CudaResults ret;
int lda = transA == CUBLAS_OP_N ? m : k;
int ldb = transB == CUBLAS_OP_N ? k : n;
cuda_gemm(blasHandle, transA, transB, m, n, k, alpha, x, lda, y, ldb, beta, c, m, cublasSgemm, &ret.error, &ret.blasStatus);
return ret;
return cuda_gemm(blasHandle, transA, transB, m, n, k, alpha, x, lda, y, ldb, beta, c, m, cublasSgemm);
}
DLLEXPORT CudaResults d_matrix_multiply(const cublasHandle_t blasHandle, cublasOperation_t transA, cublasOperation_t transB, const int m, const int n, const int k, const double alpha, const double x[], const double y[], const double beta, double c[]){
CudaResults ret;
int lda = transA == CUBLAS_OP_N ? m : k;
int ldb = transB == CUBLAS_OP_N ? k : n;
cuda_gemm(blasHandle, transA, transB, m, n, k, alpha, x, lda, y, ldb, beta, c, m, cublasDgemm, &ret.error, &ret.blasStatus);
return ret;
return cuda_gemm(blasHandle, transA, transB, m, n, k, alpha, x, lda, y, ldb, beta, c, m, cublasDgemm);
}
DLLEXPORT CudaResults c_matrix_multiply(const cublasHandle_t blasHandle, cublasOperation_t transA, cublasOperation_t transB, const int m, const int n, const int k, const cuComplex alpha, const cuComplex x[], const cuComplex y[], const cuComplex beta, cuComplex c[]){
CudaResults ret;
int lda = transA == CUBLAS_OP_N ? m : k;
int ldb = transB == CUBLAS_OP_N ? k : n;
cuda_gemm(blasHandle, transA, transB, m, n, k, alpha, x, lda, y, ldb, beta, c, m, cublasCgemm, &ret.error, &ret.blasStatus);
return ret;
return cuda_gemm(blasHandle, transA, transB, m, n, k, alpha, x, lda, y, ldb, beta, c, m, cublasCgemm);
}
DLLEXPORT CudaResults z_matrix_multiply(const cublasHandle_t blasHandle, cublasOperation_t transA, cublasOperation_t transB, const int m, const int n, const int k, const cuDoubleComplex alpha, const cuDoubleComplex x[], const cuDoubleComplex y[], const cuDoubleComplex beta, cuDoubleComplex c[]){
CudaResults ret;
int lda = transA == CUBLAS_OP_N ? m : k;
int ldb = transB == CUBLAS_OP_N ? k : n;
cuda_gemm(blasHandle, transA, transB, m, n, k, alpha, x, lda, y, ldb, beta, c, m, cublasZgemm, &ret.error, &ret.blasStatus);
return ret;
return cuda_gemm(blasHandle, transA, transB, m, n, k, alpha, x, lda, y, ldb, beta, c, m, cublasZgemm);
}
}

26
src/NativeProviders/CUDA/capabilities.cpp
View File

@ -1,4 +1,4 @@
#include "wrapper_common.h"
#include "wrapper_cuda.h"
#include "cuda_runtime.h"
#include "cublas_v2.h"
#include "cusolverDn.h"
@ -79,20 +79,28 @@ extern "C" {
}
}
DLLEXPORT cublasStatus_t createBLASHandle(cublasHandle_t *blasHandle){
return cublasCreate(blasHandle);
DLLEXPORT CudaResults createBLASHandle(cublasHandle_t *blasHandle){
CudaResults ret;
ret.blasStatus = cublasCreate(blasHandle);
return ret;
}
DLLEXPORT cublasStatus_t destroyBLASHandle(cublasHandle_t blasHandle){
return cublasDestroy(blasHandle);
DLLEXPORT CudaResults destroyBLASHandle(cublasHandle_t blasHandle){
CudaResults ret;
ret.blasStatus = cublasDestroy(blasHandle);
return ret;
}
DLLEXPORT cusolverStatus_t createSolverHandle(cusolverDnHandle_t *solverHandle){
return cusolverDnCreate(solverHandle);
DLLEXPORT CudaResults createSolverHandle(cusolverDnHandle_t *solverHandle){
CudaResults ret;
ret.solverStatus = cusolverDnCreate(solverHandle);
return ret;
}
DLLEXPORT cusolverStatus_t destroySolverHandle(cusolverDnHandle_t solverHandle){
return cusolverDnDestroy(solverHandle);
DLLEXPORT CudaResults destroySolverHandle(cusolverDnHandle_t solverHandle){
CudaResults ret;
ret.solverStatus = cusolverDnDestroy(solverHandle);
return ret;
}
#ifdef __cplusplus

3
src/NativeProviders/CUDA/wrapper_cuda.h
View File

@ -3,9 +3,10 @@
#include "wrapper_common.h"
#include "cuda_runtime.h"
#include "cublas_v2.h"
#include "cusolver_common.h"
#define SAFECUDACALL(error,call) {*error = call; if(*error){goto exit;}}
#define SAFECUDACALL(error,call) {error = call; if(error){goto exit;}}
typedef struct
{

4
src/Numerics/Control.cs
View File

@ -261,6 +261,10 @@ namespace MathNet.Numerics
{
value.InitializeVerify();
// dispose the previous value if necessary
if (_linearAlgebraProvider != null && _linearAlgebraProvider is IDisposable)
(_linearAlgebraProvider as IDisposable).Dispose();
// only actually set if verification did not throw
_linearAlgebraProvider = value;
}

32
src/Numerics/Providers/LinearAlgebra/Cuda/CudaLinearAlgebraProvider.Complex.cs
View File

@ -68,7 +68,9 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength);
}
return SafeNativeMethods.z_dot_product(_blasHandle, x.Length, x, y);
Complex result = 0;
HandleResults(SafeNativeMethods.z_dot_product(_blasHandle, x.Length, x, y, ref result));
return result;
}
/// <summary>
@ -107,7 +109,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
return;
}
SafeNativeMethods.z_axpy(_blasHandle, y.Length, alpha, x, result);
HandleResults(SafeNativeMethods.z_axpy(_blasHandle, y.Length, alpha, x, result));
}
/// <summary>
@ -135,7 +137,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
return;
}
SafeNativeMethods.z_scale(_blasHandle, x.Length, alpha, result);
HandleResults(SafeNativeMethods.z_scale(_blasHandle, x.Length, alpha, result));
}
/// <summary>
@ -202,7 +204,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentMatrixDimensions);
}
SafeNativeMethods.z_matrix_multiply(_blasHandle, transposeA.ToCUDA(), transposeB.ToCUDA(), m, n, k, alpha, a, b, beta, c);
HandleResults(SafeNativeMethods.z_matrix_multiply(_blasHandle, transposeA.ToCUDA(), transposeB.ToCUDA(), m, n, k, alpha, a, b, beta, c));
}
/// <summary>
@ -237,7 +239,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength, "ipiv");
}
Solver(SafeNativeMethods.z_lu_factor(_solverHandle, order, data, ipiv));
HandleResults(SafeNativeMethods.z_lu_factor(_solverHandle, order, data, ipiv));
}
/// <summary>
@ -259,7 +261,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength, "a");
}
Solver(SafeNativeMethods.z_lu_inverse(_solverHandle, _blasHandle, order, a));
HandleResults(SafeNativeMethods.z_lu_inverse(_solverHandle, _blasHandle, order, a));
}
/// <summary>
@ -292,7 +294,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength, "ipiv");
}
BLAS(SafeNativeMethods.z_lu_inverse_factored(_blasHandle, order, a, ipiv));
HandleResults(SafeNativeMethods.z_lu_inverse_factored(_blasHandle, order, a, ipiv));
}
/// <summary>
@ -320,7 +322,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.UserWorkBufferNotSupported);
}
Solver(SafeNativeMethods.z_lu_inverse(_solverHandle, _blasHandle, order, a));
HandleResults(SafeNativeMethods.z_lu_inverse(_solverHandle, _blasHandle, order, a));
}
/// <summary>
@ -359,7 +361,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.UserWorkBufferNotSupported);
}
BLAS(SafeNativeMethods.z_lu_inverse_factored(_blasHandle, order, a, ipiv));
HandleResults(SafeNativeMethods.z_lu_inverse_factored(_blasHandle, order, a, ipiv));
}
/// <summary>
@ -393,7 +395,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentReferenceDifferent);
}
Solver(SafeNativeMethods.z_lu_solve(_solverHandle, order, columnsOfB, a, b));
HandleResults(SafeNativeMethods.z_lu_solve(_solverHandle, order, columnsOfB, a, b));
}
/// <summary>
@ -438,7 +440,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentReferenceDifferent);
}
Solver(SafeNativeMethods.z_lu_solve_factored(_solverHandle, order, columnsOfB, a, ipiv, b));
HandleResults(SafeNativeMethods.z_lu_solve_factored(_solverHandle, order, columnsOfB, a, ipiv, b));
}
/// <summary>
@ -466,7 +468,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength, "a");
}
Solver(SafeNativeMethods.z_cholesky_factor(_solverHandle, order, a));
HandleResults(SafeNativeMethods.z_cholesky_factor(_solverHandle, order, a));
}
/// <summary>
@ -501,7 +503,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentReferenceDifferent);
}
Solver(SafeNativeMethods.z_cholesky_solve(_solverHandle, orderA, columnsB, a, b));
HandleResults(SafeNativeMethods.z_cholesky_solve(_solverHandle, orderA, columnsB, a, b));
}
/// <summary>
@ -535,7 +537,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentReferenceDifferent);
}
Solver(SafeNativeMethods.z_cholesky_solve_factored(_solverHandle, orderA, columnsB, a, b));
HandleResults(SafeNativeMethods.z_cholesky_solve_factored(_solverHandle, orderA, columnsB, a, b));
}
/// <summary>
@ -697,7 +699,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
if (columnsA > rowsA || !computeVectors) // see remarks http://docs.nvidia.com/cuda/cusolver/index.html#cuds-lt-t-gt-gesvd
base.SingularValueDecomposition(computeVectors, a, rowsA, columnsA, s, u, vt, new Complex[rowsA]);
else Solver(SafeNativeMethods.z_svd_factor(_solverHandle, computeVectors, rowsA, columnsA, a, s, u, vt));
else HandleResults(SafeNativeMethods.z_svd_factor(_solverHandle, computeVectors, rowsA, columnsA, a, s, u, vt));
}
}
}

32
src/Numerics/Providers/LinearAlgebra/Cuda/CudaLinearAlgebraProvider.Complex32.cs
View File

@ -68,7 +68,9 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength);
}
return SafeNativeMethods.c_dot_product(_blasHandle, x.Length, x, y);
Complex32 result = 0;
HandleResults(SafeNativeMethods.c_dot_product(_blasHandle, x.Length, x, y, ref result));
return result;
}
/// <summary>
@ -107,7 +109,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
return;
}
SafeNativeMethods.c_axpy(_blasHandle, y.Length, alpha, x, result);
HandleResults(SafeNativeMethods.c_axpy(_blasHandle, y.Length, alpha, x, result));
}
/// <summary>
@ -135,7 +137,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
return;
}
SafeNativeMethods.c_scale(_blasHandle, x.Length, alpha, result);
HandleResults(SafeNativeMethods.c_scale(_blasHandle, x.Length, alpha, result));
}
/// <summary>
@ -202,7 +204,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentMatrixDimensions);
}
SafeNativeMethods.c_matrix_multiply(_blasHandle, transposeA.ToCUDA(), transposeB.ToCUDA(), m, n, k, alpha, a, b, beta, c);
HandleResults(SafeNativeMethods.c_matrix_multiply(_blasHandle, transposeA.ToCUDA(), transposeB.ToCUDA(), m, n, k, alpha, a, b, beta, c));
}
/// <summary>
@ -237,7 +239,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength, "ipiv");
}
Solver(SafeNativeMethods.c_lu_factor(_solverHandle, order, data, ipiv));
HandleResults(SafeNativeMethods.c_lu_factor(_solverHandle, order, data, ipiv));
}
/// <summary>
@ -259,7 +261,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength, "a");
}
Solver(SafeNativeMethods.c_lu_inverse(_solverHandle, _blasHandle, order, a));
HandleResults(SafeNativeMethods.c_lu_inverse(_solverHandle, _blasHandle, order, a));
}
/// <summary>
@ -292,7 +294,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength, "ipiv");
}
BLAS(SafeNativeMethods.c_lu_inverse_factored(_blasHandle, order, a, ipiv));
HandleResults(SafeNativeMethods.c_lu_inverse_factored(_blasHandle, order, a, ipiv));
}
/// <summary>
@ -320,7 +322,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.UserWorkBufferNotSupported);
}
Solver(SafeNativeMethods.c_lu_inverse(_solverHandle, _blasHandle, order, a));
HandleResults(SafeNativeMethods.c_lu_inverse(_solverHandle, _blasHandle, order, a));
}
/// <summary>
@ -359,7 +361,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.UserWorkBufferNotSupported);
}
BLAS(SafeNativeMethods.c_lu_inverse_factored(_blasHandle, order, a, ipiv));
HandleResults(SafeNativeMethods.c_lu_inverse_factored(_blasHandle, order, a, ipiv));
}
/// <summary>
@ -393,7 +395,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentReferenceDifferent);
}
Solver(SafeNativeMethods.c_lu_solve(_solverHandle, order, columnsOfB, a, b));
HandleResults(SafeNativeMethods.c_lu_solve(_solverHandle, order, columnsOfB, a, b));
}
/// <summary>
@ -438,7 +440,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentReferenceDifferent);
}
Solver(SafeNativeMethods.c_lu_solve_factored(_solverHandle, order, columnsOfB, a, ipiv, b));
HandleResults(SafeNativeMethods.c_lu_solve_factored(_solverHandle, order, columnsOfB, a, ipiv, b));
}
/// <summary>
@ -466,7 +468,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength, "a");
}
Solver(SafeNativeMethods.c_cholesky_factor(_solverHandle, order, a));
HandleResults(SafeNativeMethods.c_cholesky_factor(_solverHandle, order, a));
}
/// <summary>
@ -501,7 +503,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentReferenceDifferent);
}
Solver(SafeNativeMethods.c_cholesky_solve(_solverHandle, orderA, columnsB, a, b));
HandleResults(SafeNativeMethods.c_cholesky_solve(_solverHandle, orderA, columnsB, a, b));
}
/// <summary>
@ -535,7 +537,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentReferenceDifferent);
}
Solver(SafeNativeMethods.c_cholesky_solve_factored(_solverHandle, orderA, columnsB, a, b));
HandleResults(SafeNativeMethods.c_cholesky_solve_factored(_solverHandle, orderA, columnsB, a, b));
}
/// <summary>
@ -697,7 +699,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
if (columnsA > rowsA || !computeVectors) // see remarks http://docs.nvidia.com/cuda/cusolver/index.html#cuds-lt-t-gt-gesvd
base.SingularValueDecomposition(computeVectors, a, rowsA, columnsA, s, u, vt, new Complex32[rowsA]);
else Solver(SafeNativeMethods.c_svd_factor(_solverHandle, computeVectors, rowsA, columnsA, a, s, u, vt));
else HandleResults(SafeNativeMethods.c_svd_factor(_solverHandle, computeVectors, rowsA, columnsA, a, s, u, vt));
}
}
}

32
src/Numerics/Providers/LinearAlgebra/Cuda/CudaLinearAlgebraProvider.Double.cs
View File

@ -68,7 +68,9 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength);
}
return SafeNativeMethods.d_dot_product(_blasHandle, x.Length, x, y);
double result = 0;
HandleResults(SafeNativeMethods.d_dot_product(_blasHandle, x.Length, x, y, ref result));
return result;
}
/// <summary>
@ -107,7 +109,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
return;
}
SafeNativeMethods.d_axpy(_blasHandle, y.Length, alpha, x, result);
HandleResults(SafeNativeMethods.d_axpy(_blasHandle, y.Length, alpha, x, result));
}
/// <summary>
@ -135,7 +137,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
return;
}
SafeNativeMethods.d_scale(_blasHandle, x.Length, alpha, result);
HandleResults(SafeNativeMethods.d_scale(_blasHandle, x.Length, alpha, result));
}
/// <summary>
@ -202,7 +204,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentMatrixDimensions);
}
SafeNativeMethods.d_matrix_multiply(_blasHandle, transposeA.ToCUDA(), transposeB.ToCUDA(), m, n, k, alpha, a, b, beta, c);
HandleResults(SafeNativeMethods.d_matrix_multiply(_blasHandle, transposeA.ToCUDA(), transposeB.ToCUDA(), m, n, k, alpha, a, b, beta, c));
}
/// <summary>
@ -237,7 +239,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength, "ipiv");
}
Solver(SafeNativeMethods.d_lu_factor(_solverHandle, order, data, ipiv));
HandleResults(SafeNativeMethods.d_lu_factor(_solverHandle, order, data, ipiv));
}
/// <summary>
@ -259,7 +261,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength, "a");
}
Solver(SafeNativeMethods.d_lu_inverse(_solverHandle, _blasHandle, order, a));
HandleResults(SafeNativeMethods.d_lu_inverse(_solverHandle, _blasHandle, order, a));
}
/// <summary>
@ -292,7 +294,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength, "ipiv");
}
BLAS(SafeNativeMethods.d_lu_inverse_factored(_blasHandle, order, a, ipiv));
HandleResults(SafeNativeMethods.d_lu_inverse_factored(_blasHandle, order, a, ipiv));
}
/// <summary>
@ -320,7 +322,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.UserWorkBufferNotSupported);
}
Solver(SafeNativeMethods.d_lu_inverse(_solverHandle, _blasHandle, order, a));
HandleResults(SafeNativeMethods.d_lu_inverse(_solverHandle, _blasHandle, order, a));
}
/// <summary>
@ -359,7 +361,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.UserWorkBufferNotSupported);
}
BLAS(SafeNativeMethods.d_lu_inverse_factored(_blasHandle, order, a, ipiv));
HandleResults(SafeNativeMethods.d_lu_inverse_factored(_blasHandle, order, a, ipiv));
}
/// <summary>
@ -393,7 +395,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentReferenceDifferent);
}
Solver(SafeNativeMethods.d_lu_solve(_solverHandle, order, columnsOfB, a, b));
HandleResults(SafeNativeMethods.d_lu_solve(_solverHandle, order, columnsOfB, a, b));
}
/// <summary>
@ -438,7 +440,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentReferenceDifferent);
}
Solver(SafeNativeMethods.d_lu_solve_factored(_solverHandle, order, columnsOfB, a, ipiv, b));
HandleResults(SafeNativeMethods.d_lu_solve_factored(_solverHandle, order, columnsOfB, a, ipiv, b));
}
/// <summary>
@ -466,7 +468,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength, "a");
}
Solver(SafeNativeMethods.d_cholesky_factor(_solverHandle, order, a));
HandleResults(SafeNativeMethods.d_cholesky_factor(_solverHandle, order, a));
}
/// <summary>
@ -501,7 +503,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentReferenceDifferent);
}
Solver(SafeNativeMethods.d_cholesky_solve(_solverHandle, orderA, columnsB, a, b));
HandleResults(SafeNativeMethods.d_cholesky_solve(_solverHandle, orderA, columnsB, a, b));
}
/// <summary>
@ -535,7 +537,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentReferenceDifferent);
}
Solver(SafeNativeMethods.d_cholesky_solve_factored(_solverHandle, orderA, columnsB, a, b));
HandleResults(SafeNativeMethods.d_cholesky_solve_factored(_solverHandle, orderA, columnsB, a, b));
}
/// <summary>
@ -697,7 +699,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
if (columnsA > rowsA || !computeVectors) // see remarks http://docs.nvidia.com/cuda/cusolver/index.html#cuds-lt-t-gt-gesvd
base.SingularValueDecomposition(computeVectors, a, rowsA, columnsA, s, u, vt, new double[rowsA]);
else Solver (SafeNativeMethods.d_svd_factor(_solverHandle, computeVectors, rowsA, columnsA, a, s, u, vt));
else HandleResults(SafeNativeMethods.d_svd_factor(_solverHandle, computeVectors, rowsA, columnsA, a, s, u, vt));
}
}
}

32
src/Numerics/Providers/LinearAlgebra/Cuda/CudaLinearAlgebraProvider.Single.cs
View File

@ -68,7 +68,9 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength);
}
return SafeNativeMethods.s_dot_product(_blasHandle, x.Length, x, y);
float result = 0;
HandleResults(SafeNativeMethods.s_dot_product(_blasHandle, x.Length, x, y, ref result));
return result;
}
/// <summary>
@ -107,7 +109,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
return;
}
SafeNativeMethods.s_axpy(_blasHandle, y.Length, alpha, x, result);
HandleResults(SafeNativeMethods.s_axpy(_blasHandle, y.Length, alpha, x, result));
}
/// <summary>
@ -135,7 +137,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
return;
}
SafeNativeMethods.s_scale(_blasHandle, x.Length, alpha, result);
HandleResults(SafeNativeMethods.s_scale(_blasHandle, x.Length, alpha, result));
}
/// <summary>
@ -202,7 +204,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentMatrixDimensions);
}
SafeNativeMethods.s_matrix_multiply(_blasHandle, transposeA.ToCUDA(), transposeB.ToCUDA(), m, n, k, alpha, a, b, beta, c);
HandleResults(SafeNativeMethods.s_matrix_multiply(_blasHandle, transposeA.ToCUDA(), transposeB.ToCUDA(), m, n, k, alpha, a, b, beta, c));
}
/// <summary>
@ -237,7 +239,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength, "ipiv");
}
Solver(SafeNativeMethods.s_lu_factor(_solverHandle, order, data, ipiv));
HandleResults(SafeNativeMethods.s_lu_factor(_solverHandle, order, data, ipiv));
}
/// <summary>
@ -259,7 +261,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength, "a");
}
Solver(SafeNativeMethods.s_lu_inverse(_solverHandle, _blasHandle, order, a));
HandleResults(SafeNativeMethods.s_lu_inverse(_solverHandle, _blasHandle, order, a));
}
/// <summary>
@ -292,7 +294,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength, "ipiv");
}
BLAS(SafeNativeMethods.s_lu_inverse_factored(_blasHandle, order, a, ipiv));
HandleResults(SafeNativeMethods.s_lu_inverse_factored(_blasHandle, order, a, ipiv));
}
/// <summary>
@ -320,7 +322,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.UserWorkBufferNotSupported);
}
Solver(SafeNativeMethods.s_lu_inverse(_solverHandle, _blasHandle, order, a));
HandleResults(SafeNativeMethods.s_lu_inverse(_solverHandle, _blasHandle, order, a));
}
/// <summary>
@ -359,7 +361,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.UserWorkBufferNotSupported);
}
BLAS(SafeNativeMethods.s_lu_inverse_factored(_blasHandle, order, a, ipiv));
HandleResults(SafeNativeMethods.s_lu_inverse_factored(_blasHandle, order, a, ipiv));
}
/// <summary>
@ -393,7 +395,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentReferenceDifferent);
}
Solver(SafeNativeMethods.s_lu_solve(_solverHandle, order, columnsOfB, a, b));
HandleResults(SafeNativeMethods.s_lu_solve(_solverHandle, order, columnsOfB, a, b));
}
/// <summary>
@ -438,7 +440,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentReferenceDifferent);
}
Solver(SafeNativeMethods.s_lu_solve_factored(_solverHandle, order, columnsOfB, a, ipiv, b));
HandleResults(SafeNativeMethods.s_lu_solve_factored(_solverHandle, order, columnsOfB, a, ipiv, b));
}
/// <summary>
@ -466,7 +468,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength, "a");
}
Solver(SafeNativeMethods.s_cholesky_factor(_solverHandle, order, a));
HandleResults(SafeNativeMethods.s_cholesky_factor(_solverHandle, order, a));
}
/// <summary>
@ -501,7 +503,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentReferenceDifferent);
}
Solver(SafeNativeMethods.s_cholesky_solve(_solverHandle, orderA, columnsB, a, b));
HandleResults(SafeNativeMethods.s_cholesky_solve(_solverHandle, orderA, columnsB, a, b));
}
/// <summary>
@ -535,7 +537,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentReferenceDifferent);
}
Solver(SafeNativeMethods.s_cholesky_solve_factored(_solverHandle, orderA, columnsB, a, b));
HandleResults(SafeNativeMethods.s_cholesky_solve_factored(_solverHandle, orderA, columnsB, a, b));
}
/// <summary>
@ -697,7 +699,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
if (columnsA > rowsA || !computeVectors) // see remarks http://docs.nvidia.com/cuda/cusolver/index.html#cuds-lt-t-gt-gesvd
base.SingularValueDecomposition(computeVectors, a, rowsA, columnsA, s, u, vt, new float[rowsA]);
else Solver(SafeNativeMethods.s_svd_factor(_solverHandle, computeVectors, rowsA, columnsA, a, s, u, vt));
else HandleResults(SafeNativeMethods.s_svd_factor(_solverHandle, computeVectors, rowsA, columnsA, a, s, u, vt));
}
}
}

4
src/Numerics/Providers/LinearAlgebra/Cuda/CudaLinearAlgebraProvider.cs
View File

@ -104,9 +104,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
public override string ToString()
{
return string.Format("Nvidia CUDA ({1}; revision {0})",
_nativeRevision,
_nativeIX86 ? "x86" : _nativeX64 ? "x64" : _nativeIA64 ? "IA64" : "unknown");
return string.Format("Nvidia CUDA ({1}; compute capability {0})", _nativeRevision, _nativeIX86 ? "x86" : _nativeX64 ? "x64" : _nativeIA64 ? "IA64" : "unknown");
}

2
src/Numerics/Providers/LinearAlgebra/Cuda/CudaResults.cs
View File

@ -38,7 +38,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
/// <summary>
/// Struct containing the various results from different CUDA API calls.
/// </summary>
private struct CudaResults
internal struct CudaResults
{
/// <summary>
/// Maps to cudaError_t

72
src/Numerics/Providers/LinearAlgebra/Cuda/SafeNativeMethods.cs
View File

@ -150,100 +150,100 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
//internal static extern double z_matrix_norm(byte norm, int rows, int columns, [In] Complex[] a, [In, Out] double[] work);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int s_cholesky_factor(IntPtr solverHandle, int n, [In, Out] float[] a);
internal static extern CudaResults s_cholesky_factor(IntPtr solverHandle, int n, [In, Out] float[] a);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int d_cholesky_factor(IntPtr solverHandle, int n, [In, Out] double[] a);
internal static extern CudaResults d_cholesky_factor(IntPtr solverHandle, int n, [In, Out] double[] a);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int c_cholesky_factor(IntPtr solverHandle, int n, [In, Out] Complex32[] a);
internal static extern CudaResults c_cholesky_factor(IntPtr solverHandle, int n, [In, Out] Complex32[] a);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int z_cholesky_factor(IntPtr solverHandle, int n, [In, Out] Complex[] a);
internal static extern CudaResults z_cholesky_factor(IntPtr solverHandle, int n, [In, Out] Complex[] a);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int s_lu_factor(IntPtr solverHandle, int n, [In, Out] float[] a, [In, Out] int[] ipiv);
internal static extern CudaResults s_lu_factor(IntPtr solverHandle, int n, [In, Out] float[] a, [In, Out] int[] ipiv);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int d_lu_factor(IntPtr solverHandle, int n, [In, Out] double[] a, [In, Out] int[] ipiv);
internal static extern CudaResults d_lu_factor(IntPtr solverHandle, int n, [In, Out] double[] a, [In, Out] int[] ipiv);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int c_lu_factor(IntPtr solverHandle, int n, [In, Out] Complex32[] a, [In, Out] int[] ipiv);
internal static extern CudaResults c_lu_factor(IntPtr solverHandle, int n, [In, Out] Complex32[] a, [In, Out] int[] ipiv);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int z_lu_factor(IntPtr solverHandle, int n, [In, Out] Complex[] a, [In, Out] int[] ipiv);
internal static extern CudaResults z_lu_factor(IntPtr solverHandle, int n, [In, Out] Complex[] a, [In, Out] int[] ipiv);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int s_lu_inverse(IntPtr solverHandle, IntPtr blasHandle, int n, [In, Out] float[] a);
internal static extern CudaResults s_lu_inverse(IntPtr solverHandle, IntPtr blasHandle, int n, [In, Out] float[] a);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int d_lu_inverse(IntPtr solverHandle, IntPtr blasHandle, int n, [In, Out] double[] a);
internal static extern CudaResults d_lu_inverse(IntPtr solverHandle, IntPtr blasHandle, int n, [In, Out] double[] a);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int c_lu_inverse(IntPtr solverHandle, IntPtr blasHandle, int n, [In, Out] Complex32[] a);
internal static extern CudaResults c_lu_inverse(IntPtr solverHandle, IntPtr blasHandle, int n, [In, Out] Complex32[] a);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int z_lu_inverse(IntPtr solverHandle, IntPtr blasHandle, int n, [In, Out] Complex[] a);
internal static extern CudaResults z_lu_inverse(IntPtr solverHandle, IntPtr blasHandle, int n, [In, Out] Complex[] a);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int s_lu_inverse_factored(IntPtr blasHandle, int n, [In, Out] float[] a, [In, Out] int[] ipiv);
internal static extern CudaResults s_lu_inverse_factored(IntPtr blasHandle, int n, [In, Out] float[] a, [In, Out] int[] ipiv);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int d_lu_inverse_factored(IntPtr blasHandle, int n, [In, Out] double[] a, [In, Out] int[] ipiv);
internal static extern CudaResults d_lu_inverse_factored(IntPtr blasHandle, int n, [In, Out] double[] a, [In, Out] int[] ipiv);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int c_lu_inverse_factored(IntPtr blasHandle, int n, [In, Out] Complex32[] a, [In, Out] int[] ipiv);
internal static extern CudaResults c_lu_inverse_factored(IntPtr blasHandle, int n, [In, Out] Complex32[] a, [In, Out] int[] ipiv);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int z_lu_inverse_factored(IntPtr blasHandle, int n, [In, Out] Complex[] a, [In, Out] int[] ipiv);
internal static extern CudaResults z_lu_inverse_factored(IntPtr blasHandle, int n, [In, Out] Complex[] a, [In, Out] int[] ipiv);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int s_lu_solve_factored(IntPtr solverHandle, int n, int nrhs, float[] a, [In, Out] int[] ipiv, [In, Out] float[] b);
internal static extern CudaResults s_lu_solve_factored(IntPtr solverHandle, int n, int nrhs, float[] a, [In, Out] int[] ipiv, [In, Out] float[] b);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int d_lu_solve_factored(IntPtr solverHandle, int n, int nrhs, double[] a, [In, Out] int[] ipiv, [In, Out] double[] b);
internal static extern CudaResults d_lu_solve_factored(IntPtr solverHandle, int n, int nrhs, double[] a, [In, Out] int[] ipiv, [In, Out] double[] b);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int c_lu_solve_factored(IntPtr solverHandle, int n, int nrhs, Complex32[] a, [In, Out] int[] ipiv, [In, Out] Complex32[] b);
internal static extern CudaResults c_lu_solve_factored(IntPtr solverHandle, int n, int nrhs, Complex32[] a, [In, Out] int[] ipiv, [In, Out] Complex32[] b);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int z_lu_solve_factored(IntPtr solverHandle, int n, int nrhs, Complex[] a, [In, Out] int[] ipiv, [In, Out] Complex[] b);
internal static extern CudaResults z_lu_solve_factored(IntPtr solverHandle, int n, int nrhs, Complex[] a, [In, Out] int[] ipiv, [In, Out] Complex[] b);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int s_lu_solve(IntPtr solverHandle, int n, int nrhs, float[] a, [In, Out] float[] b);
internal static extern CudaResults s_lu_solve(IntPtr solverHandle, int n, int nrhs, float[] a, [In, Out] float[] b);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int d_lu_solve(IntPtr solverHandle, int n, int nrhs, double[] a, [In, Out] double[] b);
internal static extern CudaResults d_lu_solve(IntPtr solverHandle, int n, int nrhs, double[] a, [In, Out] double[] b);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int c_lu_solve(IntPtr solverHandle, int n, int nrhs, Complex32[] a, [In, Out] Complex32[] b);
internal static extern CudaResults c_lu_solve(IntPtr solverHandle, int n, int nrhs, Complex32[] a, [In, Out] Complex32[] b);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int z_lu_solve(IntPtr solverHandle, int n, int nrhs, Complex[] a, [In, Out] Complex[] b);
internal static extern CudaResults z_lu_solve(IntPtr solverHandle, int n, int nrhs, Complex[] a, [In, Out] Complex[] b);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int s_cholesky_solve(IntPtr solverHandle, int n, int nrhs, float[] a, [In, Out] float[] b);
internal static extern CudaResults s_cholesky_solve(IntPtr solverHandle, int n, int nrhs, float[] a, [In, Out] float[] b);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int d_cholesky_solve(IntPtr solverHandle, int n, int nrhs, double[] a, [In, Out] double[] b);
internal static extern CudaResults d_cholesky_solve(IntPtr solverHandle, int n, int nrhs, double[] a, [In, Out] double[] b);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int c_cholesky_solve(IntPtr solverHandle, int n, int nrhs, Complex32[] a, [In, Out] Complex32[] b);
internal static extern CudaResults c_cholesky_solve(IntPtr solverHandle, int n, int nrhs, Complex32[] a, [In, Out] Complex32[] b);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int z_cholesky_solve(IntPtr solverHandle, int n, int nrhs, Complex[] a, [In, Out] Complex[] b);
internal static extern CudaResults z_cholesky_solve(IntPtr solverHandle, int n, int nrhs, Complex[] a, [In, Out] Complex[] b);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int s_cholesky_solve_factored(IntPtr solverHandle, int n, int nrhs, float[] a, [In, Out] float[] b);
internal static extern CudaResults s_cholesky_solve_factored(IntPtr solverHandle, int n, int nrhs, float[] a, [In, Out] float[] b);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int d_cholesky_solve_factored(IntPtr solverHandle, int n, int nrhs, double[] a, [In, Out] double[] b);
internal static extern CudaResults d_cholesky_solve_factored(IntPtr solverHandle, int n, int nrhs, double[] a, [In, Out] double[] b);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int c_cholesky_solve_factored(IntPtr solverHandle, int n, int nrhs, Complex32[] a, [In, Out] Complex32[] b);
internal static extern CudaResults c_cholesky_solve_factored(IntPtr solverHandle, int n, int nrhs, Complex32[] a, [In, Out] Complex32[] b);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int z_cholesky_solve_factored(IntPtr solverHandle, int n, int nrhs, Complex[] a, [In, Out] Complex[] b);
internal static extern CudaResults z_cholesky_solve_factored(IntPtr solverHandle, int n, int nrhs, Complex[] a, [In, Out] Complex[] b);
//[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
//internal static extern int s_qr_factor(int m, int n, [In, Out] float[] r, [In, Out] float[] tau, [In, Out] float[] q, [In, Out] float[] work, int len);
@ -294,16 +294,16 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
//internal static extern int z_qr_solve_factored(int m, int n, int bn, Complex[] r, Complex[] b, Complex[] tau, [In, Out] Complex[] x, [In, Out] Complex[] work, int len);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int s_svd_factor(IntPtr solverHandle, [MarshalAs(UnmanagedType.U1)] bool computeVectors, int m, int n, [In, Out] float[] a, [In, Out] float[] s, [In, Out] float[] u, [In, Out] float[] v);
internal static extern CudaResults s_svd_factor(IntPtr solverHandle, [MarshalAs(UnmanagedType.U1)] bool computeVectors, int m, int n, [In, Out] float[] a, [In, Out] float[] s, [In, Out] float[] u, [In, Out] float[] v);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int d_svd_factor(IntPtr solverHandle, [MarshalAs(UnmanagedType.U1)] bool computeVectors, int m, int n, [In, Out] double[] a, [In, Out] double[] s, [In, Out] double[] u, [In, Out] double[] v);
internal static extern CudaResults d_svd_factor(IntPtr solverHandle, [MarshalAs(UnmanagedType.U1)] bool computeVectors, int m, int n, [In, Out] double[] a, [In, Out] double[] s, [In, Out] double[] u, [In, Out] double[] v);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int c_svd_factor(IntPtr solverHandle, [MarshalAs(UnmanagedType.U1)] bool computeVectors, int m, int n, [In, Out] Complex32[] a, [In, Out] Complex32[] s, [In, Out] Complex32[] u, [In, Out] Complex32[] v);
internal static extern CudaResults c_svd_factor(IntPtr solverHandle, [MarshalAs(UnmanagedType.U1)] bool computeVectors, int m, int n, [In, Out] Complex32[] a, [In, Out] Complex32[] s, [In, Out] Complex32[] u, [In, Out] Complex32[] v);
[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
internal static extern int z_svd_factor(IntPtr solverHandle, [MarshalAs(UnmanagedType.U1)] bool computeVectors, int m, int n, [In, Out] Complex[] a, [In, Out] Complex[] s, [In, Out] Complex[] u, [In, Out] Complex[] v);
internal static extern CudaResults z_svd_factor(IntPtr solverHandle, [MarshalAs(UnmanagedType.U1)] bool computeVectors, int m, int n, [In, Out] Complex[] a, [In, Out] Complex[] s, [In, Out] Complex[] u, [In, Out] Complex[] v);
//[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
//internal static extern int s_eigen([MarshalAs(UnmanagedType.U1)] bool isSymmetric, int n, [In] float[] a, [In, Out] float[] vectors, [In, Out] Complex[] values, [In, Out] float[] d);

Write Preview
Loading…
Cancel
Save