ufkc7e3d
/
mathnet-numerics
forked from 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 12 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
Unified 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" #include "wrapper_cuda.h"
template<typename T, typename AXPY> 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_X = NULL;
T *d_Y = NULL; T *d_Y = NULL;
*error = cudaError_t::cudaSuccess; CudaResults results;
*blasStatus = cublasStatus_t::CUBLAS_STATUS_SUCCESS;
SAFECUDACALL(error, cudaMalloc((void**)&d_X, n*sizeof(T))) SAFECUDACALL(results.error, cudaMalloc((void**)&d_X, n*sizeof(T)));
SAFECUDACALL(error, cudaMalloc((void**)&d_Y, 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(results.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), 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: exit:
cudaFree(d_X); cudaFree(d_X);
cudaFree(d_Y); cudaFree(d_Y);
return results;
} }
template<typename T, typename SCAL> 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; T *d_X = NULL;
*error = cudaError_t::cudaSuccess; CudaResults results;
*blasStatus = cublasStatus_t::CUBLAS_STATUS_SUCCESS;
SAFECUDACALL(error, cudaMalloc((void**)&d_X, n*sizeof(T))) SAFECUDACALL(results.error, cudaMalloc((void**)&d_X, n*sizeof(T)));
SAFECUDACALL(blasStatus, cublasSetVector(n, sizeof(T), x, incX, d_X, incX)) SAFECUDACALL(results.blasStatus, cublasSetVector(n, sizeof(T), x, incX, d_X, incX));
SAFECUDACALL(blasStatus, scal(blasHandle, n, &alpha, d_X, incX)) SAFECUDACALL(results.blasStatus, scal(blasHandle, n, &alpha, d_X, incX));
SAFECUDACALL(blasStatus, cublasGetVector(n, sizeof(T), d_X, incX, x, incX)) SAFECUDACALL(results.blasStatus, cublasGetVector(n, sizeof(T), d_X, incX, x, incX));
exit: exit:
cudaFree(d_X); cudaFree(d_X);
return results;
} }
template<typename T, typename DOT> 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_X = NULL;
T *d_Y = NULL; T *d_Y = NULL;
*error = cudaError_t::cudaSuccess; CudaResults results;
*blasStatus = cublasStatus_t::CUBLAS_STATUS_SUCCESS;
SAFECUDACALL(error, cudaMalloc((void**)&d_X, n*sizeof(T))) SAFECUDACALL(results.error, cudaMalloc((void**)&d_X, n*sizeof(T)));
SAFECUDACALL(error, cudaMalloc((void**)&d_Y, 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(results.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), 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: exit:
cudaFree(d_X); cudaFree(d_X);
cudaFree(d_Y); cudaFree(d_Y);
return results;
} }
template<typename T, typename GEMM> 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_A = NULL;
T *d_B = NULL; T *d_B = NULL;
T *d_C = NULL; T *d_C = NULL;
*error = cudaError_t::cudaSuccess; CudaResults results;
*blasStatus = cublasStatus_t::CUBLAS_STATUS_SUCCESS;
SAFECUDACALL(error, cudaMalloc((void**)&d_A, m*k*sizeof(T))) SAFECUDACALL(results.error, cudaMalloc((void**)&d_A, m*k*sizeof(T)));
SAFECUDACALL(blasStatus, cublasSetMatrix(m, k, sizeof(T), A, m, d_A, m)) SAFECUDACALL(results.blasStatus, cublasSetMatrix(m, k, sizeof(T), A, m, d_A, m));
SAFECUDACALL(error, cudaMalloc((void**)&d_B, k*n*sizeof(T))) SAFECUDACALL(results.error, cudaMalloc((void**)&d_B, k*n*sizeof(T)));
SAFECUDACALL(blasStatus, cublasSetMatrix(k, n, sizeof(T), B, k, d_B, k)) SAFECUDACALL(results.blasStatus, cublasSetMatrix(k, n, sizeof(T), B, k, d_B, k));
SAFECUDACALL(error, cudaMalloc((void**)&d_C, m*n*sizeof(T))) SAFECUDACALL(results.error, cudaMalloc((void**)&d_C, m*n*sizeof(T)));
SAFECUDACALL(blasStatus, cublasSetMatrix(m, n, sizeof(T), C, m, d_C, m)) 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: exit:
cudaFree(d_A); cudaFree(d_A);
cudaFree(d_B); cudaFree(d_B);
cudaFree(d_C); cudaFree(d_C);
return results;
} }
extern "C" { extern "C" {
DLLEXPORT CudaResults s_axpy(const cublasHandle_t blasHandle, const int n, const float alpha, const float x[], float y[]){ DLLEXPORT CudaResults s_axpy(const cublasHandle_t blasHandle, const int n, const float alpha, const float x[], float y[]){
CudaResults ret; return cuda_axpy(blasHandle, n, alpha, x, 1, y, 1, cublasSaxpy);
cuda_axpy(blasHandle, n, alpha, x, 1, y, 1, cublasSaxpy, &ret.error, &ret.blasStatus);
return ret;
} }
DLLEXPORT CudaResults d_axpy(const cublasHandle_t blasHandle, const int n, const double alpha, const double x[], double y[]){ DLLEXPORT CudaResults d_axpy(const cublasHandle_t blasHandle, const int n, const double alpha, const double x[], double y[]){
CudaResults ret; return cuda_axpy(blasHandle, n, alpha, x, 1, y, 1, cublasDaxpy);
cuda_axpy(blasHandle, n, alpha, x, 1, y, 1, cublasDaxpy, &ret.error, &ret.blasStatus);
return ret;
} }
DLLEXPORT CudaResults c_axpy(const cublasHandle_t blasHandle, const int n, const cuComplex alpha, const cuComplex x[], cuComplex y[]){ DLLEXPORT CudaResults c_axpy(const cublasHandle_t blasHandle, const int n, const cuComplex alpha, const cuComplex x[], cuComplex y[]){
CudaResults ret; return cuda_axpy(blasHandle, n, alpha, x, 1, y, 1, cublasCaxpy);
cuda_axpy(blasHandle, n, alpha, x, 1, y, 1, cublasCaxpy, &ret.error, &ret.blasStatus);
return ret;
} }
DLLEXPORT CudaResults z_axpy(const cublasHandle_t blasHandle, const int n, const cuDoubleComplex alpha, const cuDoubleComplex x[], cuDoubleComplex y[]){ DLLEXPORT CudaResults z_axpy(const cublasHandle_t blasHandle, const int n, const cuDoubleComplex alpha, const cuDoubleComplex x[], cuDoubleComplex y[]){
CudaResults ret; return cuda_axpy(blasHandle, n, alpha, x, 1, y, 1, cublasZaxpy);
cuda_axpy(blasHandle, n, alpha, x, 1, y, 1, cublasZaxpy, &ret.error, &ret.blasStatus);
return ret;
} }
DLLEXPORT CudaResults s_scale(const cublasHandle_t blasHandle, const int n, const float alpha, float x[]){ DLLEXPORT CudaResults s_scale(const cublasHandle_t blasHandle, const int n, const float alpha, float x[]){
CudaResults ret; return cuda_scal(blasHandle, n, alpha, x, 1, cublasSscal);
cuda_scal(blasHandle, n, alpha, x, 1, cublasSscal, &ret.error, &ret.blasStatus);
return ret;
} }
DLLEXPORT CudaResults d_scale(const cublasHandle_t blasHandle, const int n, const double alpha, double x[]){ DLLEXPORT CudaResults d_scale(const cublasHandle_t blasHandle, const int n, const double alpha, double x[]){
CudaResults ret; return cuda_scal(blasHandle, n, alpha, x, 1, cublasDscal);
cuda_scal(blasHandle, n, alpha, x, 1, cublasDscal, &ret.error, &ret.blasStatus);
return ret;
} }
DLLEXPORT CudaResults c_scale(const cublasHandle_t blasHandle, const int n, const cuComplex alpha, cuComplex x[]){ DLLEXPORT CudaResults c_scale(const cublasHandle_t blasHandle, const int n, const cuComplex alpha, cuComplex x[]){
CudaResults ret; return cuda_scal(blasHandle, n, alpha, x, 1, cublasCscal);
cuda_scal(blasHandle, n, alpha, x, 1, cublasCscal, &ret.error, &ret.blasStatus);
return ret;
} }
DLLEXPORT CudaResults z_scale(const cublasHandle_t blasHandle, const int n, const cuDoubleComplex alpha, cuDoubleComplex x[]){ DLLEXPORT CudaResults z_scale(const cublasHandle_t blasHandle, const int n, const cuDoubleComplex alpha, cuDoubleComplex x[]){
CudaResults ret; return cuda_scal(blasHandle, n, alpha, x, 1, cublasZscal);
cuda_scal(blasHandle, n, alpha, x, 1, cublasZscal, &ret.error, &ret.blasStatus);
return ret;
} }
DLLEXPORT CudaResults s_dot_product(const cublasHandle_t blasHandle, const int n, const float x[], const float y[], float *result){ DLLEXPORT CudaResults s_dot_product(const cublasHandle_t blasHandle, const int n, const float x[], const float y[], float *result){
CudaResults ret; return cuda_dot(blasHandle, n, x, 1, y, 1, result, cublasSdot);
cuda_dot(blasHandle, n, x, 1, y, 1, result, cublasSdot, &ret.error, &ret.blasStatus);
return ret;
} }
DLLEXPORT CudaResults d_dot_product(const cublasHandle_t blasHandle, const int n, const double x[], const double y[], double *result){ DLLEXPORT CudaResults d_dot_product(const cublasHandle_t blasHandle, const int n, const double x[], const double y[], double *result){
CudaResults ret; return cuda_dot(blasHandle, n, x, 1, y, 1, result, cublasDdot);
cuda_dot(blasHandle, n, x, 1, y, 1, result, cublasDdot, &ret.error, &ret.blasStatus);
return ret;
} }
DLLEXPORT CudaResults c_dot_product(const cublasHandle_t blasHandle, const int n, const cuComplex x[], const cuComplex y[], cuComplex *result){ DLLEXPORT CudaResults c_dot_product(const cublasHandle_t blasHandle, const int n, const cuComplex x[], const cuComplex y[], cuComplex *result){
CudaResults ret; return cuda_dot(blasHandle, n, x, 1, y, 1, result, cublasCdotu);
cuda_dot(blasHandle, n, x, 1, y, 1, result, cublasCdotu, &ret.error, &ret.blasStatus);
return ret;
} }
DLLEXPORT CudaResults z_dot_product(const cublasHandle_t blasHandle, const int n, const cuDoubleComplex x[], const cuDoubleComplex y[], cuDoubleComplex *result){ DLLEXPORT CudaResults z_dot_product(const cublasHandle_t blasHandle, const int n, const cuDoubleComplex x[], const cuDoubleComplex y[], cuDoubleComplex *result){
CudaResults ret; return cuda_dot(blasHandle, n, x, 1, y, 1, result, cublasZdotu);
cuda_dot(blasHandle, n, x, 1, y, 1, result, cublasZdotu, &ret.error, &ret.blasStatus);
return ret;
} }
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[]){ 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 lda = transA == CUBLAS_OP_N ? m : k;
int ldb = transB == CUBLAS_OP_N ? k : n; 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 cuda_gemm(blasHandle, transA, transB, m, n, k, alpha, x, lda, y, ldb, beta, c, m, cublasSgemm);
return ret;
} }
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[]){ 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 lda = transA == CUBLAS_OP_N ? m : k;
int ldb = transB == CUBLAS_OP_N ? k : n; 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 cuda_gemm(blasHandle, transA, transB, m, n, k, alpha, x, lda, y, ldb, beta, c, m, cublasDgemm);
return ret;
} }
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[]){ 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 lda = transA == CUBLAS_OP_N ? m : k;
int ldb = transB == CUBLAS_OP_N ? k : n; 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 cuda_gemm(blasHandle, transA, transB, m, n, k, alpha, x, lda, y, ldb, beta, c, m, cublasCgemm);
return ret;
} }
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[]){ 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 lda = transA == CUBLAS_OP_N ? m : k;
int ldb = transB == CUBLAS_OP_N ? k : n; 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 cuda_gemm(blasHandle, transA, transB, m, n, k, alpha, x, lda, y, ldb, beta, c, m, cublasZgemm);
return ret;
} }
} }

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

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

@ -3,9 +3,10 @@
#include "wrapper_common.h" #include "wrapper_common.h"
#include "cuda_runtime.h" #include "cuda_runtime.h"
#include "cublas_v2.h"
#include "cusolver_common.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 typedef struct
{ {

4
src/Numerics/Control.cs
View File

@ -261,6 +261,10 @@ namespace MathNet.Numerics
{ {
value.InitializeVerify(); 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 // only actually set if verification did not throw
_linearAlgebraProvider = value; _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); 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> /// <summary>
@ -107,7 +109,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
return; return;
} }
SafeNativeMethods.z_axpy(_blasHandle, y.Length, alpha, x, result); HandleResults(SafeNativeMethods.z_axpy(_blasHandle, y.Length, alpha, x, result));
} }
/// <summary> /// <summary>
@ -135,7 +137,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
return; return;
} }
SafeNativeMethods.z_scale(_blasHandle, x.Length, alpha, result); HandleResults(SafeNativeMethods.z_scale(_blasHandle, x.Length, alpha, result));
} }
/// <summary> /// <summary>
@ -202,7 +204,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentMatrixDimensions); 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> /// <summary>
@ -237,7 +239,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength, "ipiv"); 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> /// <summary>
@ -259,7 +261,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength, "a"); 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> /// <summary>
@ -292,7 +294,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength, "ipiv"); 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> /// <summary>
@ -320,7 +322,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.UserWorkBufferNotSupported); throw new ArgumentException(Resources.UserWorkBufferNotSupported);
} }
Solver(SafeNativeMethods.z_lu_inverse(_solverHandle, _blasHandle, order, a)); HandleResults(SafeNativeMethods.z_lu_inverse(_solverHandle, _blasHandle, order, a));
} }
/// <summary> /// <summary>
@ -359,7 +361,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.UserWorkBufferNotSupported); 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> /// <summary>
@ -393,7 +395,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentReferenceDifferent); 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> /// <summary>
@ -438,7 +440,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentReferenceDifferent); 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> /// <summary>
@ -466,7 +468,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength, "a"); throw new ArgumentException(Resources.ArgumentArraysSameLength, "a");
} }
Solver(SafeNativeMethods.z_cholesky_factor(_solverHandle, order, a)); HandleResults(SafeNativeMethods.z_cholesky_factor(_solverHandle, order, a));
} }
/// <summary> /// <summary>
@ -501,7 +503,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentReferenceDifferent); 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> /// <summary>
@ -535,7 +537,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentReferenceDifferent); 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> /// <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 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]); 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); 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> /// <summary>
@ -107,7 +109,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
return; return;
} }
SafeNativeMethods.c_axpy(_blasHandle, y.Length, alpha, x, result); HandleResults(SafeNativeMethods.c_axpy(_blasHandle, y.Length, alpha, x, result));
} }
/// <summary> /// <summary>
@ -135,7 +137,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
return; return;
} }
SafeNativeMethods.c_scale(_blasHandle, x.Length, alpha, result); HandleResults(SafeNativeMethods.c_scale(_blasHandle, x.Length, alpha, result));
} }
/// <summary> /// <summary>
@ -202,7 +204,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentMatrixDimensions); 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> /// <summary>
@ -237,7 +239,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength, "ipiv"); 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> /// <summary>
@ -259,7 +261,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength, "a"); 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> /// <summary>
@ -292,7 +294,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength, "ipiv"); 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> /// <summary>
@ -320,7 +322,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.UserWorkBufferNotSupported); throw new ArgumentException(Resources.UserWorkBufferNotSupported);
} }
Solver(SafeNativeMethods.c_lu_inverse(_solverHandle, _blasHandle, order, a)); HandleResults(SafeNativeMethods.c_lu_inverse(_solverHandle, _blasHandle, order, a));
} }
/// <summary> /// <summary>
@ -359,7 +361,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.UserWorkBufferNotSupported); 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> /// <summary>
@ -393,7 +395,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentReferenceDifferent); 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> /// <summary>
@ -438,7 +440,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentReferenceDifferent); 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> /// <summary>
@ -466,7 +468,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength, "a"); throw new ArgumentException(Resources.ArgumentArraysSameLength, "a");
} }
Solver(SafeNativeMethods.c_cholesky_factor(_solverHandle, order, a)); HandleResults(SafeNativeMethods.c_cholesky_factor(_solverHandle, order, a));
} }
/// <summary> /// <summary>
@ -501,7 +503,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentReferenceDifferent); 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> /// <summary>
@ -535,7 +537,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentReferenceDifferent); 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> /// <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 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]); 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); 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> /// <summary>
@ -107,7 +109,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
return; return;
} }
SafeNativeMethods.d_axpy(_blasHandle, y.Length, alpha, x, result); HandleResults(SafeNativeMethods.d_axpy(_blasHandle, y.Length, alpha, x, result));
} }
/// <summary> /// <summary>
@ -135,7 +137,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
return; return;
} }
SafeNativeMethods.d_scale(_blasHandle, x.Length, alpha, result); HandleResults(SafeNativeMethods.d_scale(_blasHandle, x.Length, alpha, result));
} }
/// <summary> /// <summary>
@ -202,7 +204,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentMatrixDimensions); 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> /// <summary>
@ -237,7 +239,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength, "ipiv"); 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> /// <summary>
@ -259,7 +261,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength, "a"); 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> /// <summary>
@ -292,7 +294,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength, "ipiv"); 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> /// <summary>
@ -320,7 +322,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.UserWorkBufferNotSupported); throw new ArgumentException(Resources.UserWorkBufferNotSupported);
} }
Solver(SafeNativeMethods.d_lu_inverse(_solverHandle, _blasHandle, order, a)); HandleResults(SafeNativeMethods.d_lu_inverse(_solverHandle, _blasHandle, order, a));
} }
/// <summary> /// <summary>
@ -359,7 +361,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.UserWorkBufferNotSupported); 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> /// <summary>
@ -393,7 +395,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentReferenceDifferent); 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> /// <summary>
@ -438,7 +440,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentReferenceDifferent); 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> /// <summary>
@ -466,7 +468,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength, "a"); throw new ArgumentException(Resources.ArgumentArraysSameLength, "a");
} }
Solver(SafeNativeMethods.d_cholesky_factor(_solverHandle, order, a)); HandleResults(SafeNativeMethods.d_cholesky_factor(_solverHandle, order, a));
} }
/// <summary> /// <summary>
@ -501,7 +503,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentReferenceDifferent); 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> /// <summary>
@ -535,7 +537,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentReferenceDifferent); 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> /// <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 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]); 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); 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> /// <summary>
@ -107,7 +109,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
return; return;
} }
SafeNativeMethods.s_axpy(_blasHandle, y.Length, alpha, x, result); HandleResults(SafeNativeMethods.s_axpy(_blasHandle, y.Length, alpha, x, result));
} }
/// <summary> /// <summary>
@ -135,7 +137,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
return; return;
} }
SafeNativeMethods.s_scale(_blasHandle, x.Length, alpha, result); HandleResults(SafeNativeMethods.s_scale(_blasHandle, x.Length, alpha, result));
} }
/// <summary> /// <summary>
@ -202,7 +204,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentMatrixDimensions); 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> /// <summary>
@ -237,7 +239,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength, "ipiv"); 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> /// <summary>
@ -259,7 +261,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength, "a"); 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> /// <summary>
@ -292,7 +294,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength, "ipiv"); 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> /// <summary>
@ -320,7 +322,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.UserWorkBufferNotSupported); throw new ArgumentException(Resources.UserWorkBufferNotSupported);
} }
Solver(SafeNativeMethods.s_lu_inverse(_solverHandle, _blasHandle, order, a)); HandleResults(SafeNativeMethods.s_lu_inverse(_solverHandle, _blasHandle, order, a));
} }
/// <summary> /// <summary>
@ -359,7 +361,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.UserWorkBufferNotSupported); 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> /// <summary>
@ -393,7 +395,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentReferenceDifferent); 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> /// <summary>
@ -438,7 +440,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentReferenceDifferent); 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> /// <summary>
@ -466,7 +468,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentArraysSameLength, "a"); throw new ArgumentException(Resources.ArgumentArraysSameLength, "a");
} }
Solver(SafeNativeMethods.s_cholesky_factor(_solverHandle, order, a)); HandleResults(SafeNativeMethods.s_cholesky_factor(_solverHandle, order, a));
} }
/// <summary> /// <summary>
@ -501,7 +503,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentReferenceDifferent); 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> /// <summary>
@ -535,7 +537,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
throw new ArgumentException(Resources.ArgumentReferenceDifferent); 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> /// <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 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]); 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() public override string ToString()
{ {
return string.Format("Nvidia CUDA ({1}; revision {0})", return string.Format("Nvidia CUDA ({1}; compute capability {0})", _nativeRevision, _nativeIX86 ? "x86" : _nativeX64 ? "x64" : _nativeIA64 ? "IA64" : "unknown");
_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> /// <summary>
/// Struct containing the various results from different CUDA API calls. /// Struct containing the various results from different CUDA API calls.
/// </summary> /// </summary>
private struct CudaResults internal struct CudaResults
{ {
/// <summary> /// <summary>
/// Maps to cudaError_t /// 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); //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)] [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)] [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)] [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)] [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)] [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)] [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)] [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)] [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)] [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)] [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)] [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)] [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)] [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)] [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)] [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)] [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)] [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)] [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)] [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)] [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)] [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)] [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)] [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)] [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)] [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)] [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)] [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)] [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)] [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)] [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)] [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)] [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)] //[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); //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); //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)] [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)] [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)] [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)] [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)] //[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); //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