Matthew Johnson
11 years ago
6 changed files with 684 additions and 6 deletions
@ -0,0 +1,93 @@ |
|||
#include "cublas_v2.h" |
|||
#include "wrapper_common.h" |
|||
|
|||
#if GCC |
|||
extern "C" { |
|||
#endif |
|||
DLLEXPORT void s_axpy(const cublasHandle_t handle, const int n, const float alpha, const float x[], float y[]){ |
|||
cublasSaxpy(handle, n, &alpha, x, 1, y, 1); |
|||
} |
|||
|
|||
DLLEXPORT void d_axpy(const cublasHandle_t handle, const int n, const double alpha, const double x[], double y[]){ |
|||
cublasDaxpy(handle, n, &alpha, x, 1, y, 1); |
|||
} |
|||
|
|||
DLLEXPORT void c_axpy(const cublasHandle_t handle, const int n, const cuComplex alpha, const cuComplex x[], cuComplex y[]){ |
|||
cublasCaxpy(handle, n, &alpha, x, 1, y, 1); |
|||
} |
|||
|
|||
DLLEXPORT void z_axpy(const cublasHandle_t handle, const int n, const cuDoubleComplex alpha, const cuDoubleComplex x[], cuDoubleComplex y[]){ |
|||
cublasZaxpy(handle, n, &alpha, x, 1, y, 1); |
|||
} |
|||
|
|||
DLLEXPORT void s_scale(const cublasHandle_t handle, const int n, const float alpha, float x[]){ |
|||
cublasSscal(handle, n, &alpha, x, 1); |
|||
} |
|||
|
|||
DLLEXPORT void d_scale(const cublasHandle_t handle, const int n, const double alpha, double x[]){ |
|||
cublasDscal(handle, n, &alpha, x, 1); |
|||
} |
|||
|
|||
DLLEXPORT void c_scale(const cublasHandle_t handle, const int n, const cuComplex alpha, cuComplex x[]){ |
|||
cublasCscal(handle, n, &alpha, x, 1); |
|||
} |
|||
|
|||
DLLEXPORT void z_scale(const cublasHandle_t handle, const int n, const cuDoubleComplex alpha, cuDoubleComplex x[]){ |
|||
cublasZscal(handle, n, &alpha, x, 1); |
|||
} |
|||
|
|||
DLLEXPORT float s_dot_product(const cublasHandle_t handle, const int n, const float x[], const float y[]){ |
|||
float ret; |
|||
cublasSdot(handle, n, x, 1, y, 1, &ret); |
|||
return ret; |
|||
} |
|||
|
|||
DLLEXPORT double d_dot_product(const cublasHandle_t handle, const int n, const double x[], const double y[]){ |
|||
double ret; |
|||
cublasDdot(handle, n, x, 1, y, 1, &ret); |
|||
return ret; |
|||
} |
|||
|
|||
DLLEXPORT cuComplex c_dot_product(const cublasHandle_t handle, const int n, const cuComplex x[], const cuComplex y[]){ |
|||
cuComplex ret; |
|||
cublasCdotu(handle, n, x, 1, y, 1, &ret); |
|||
return ret; |
|||
} |
|||
|
|||
DLLEXPORT cuDoubleComplex z_dot_product(const cublasHandle_t handle, const int n, const cuDoubleComplex x[], const cuDoubleComplex y[]){ |
|||
cuDoubleComplex ret; |
|||
cublasZdotu(handle, n, x, 1, y, 1, &ret); |
|||
return ret; |
|||
} |
|||
|
|||
DLLEXPORT void s_matrix_multiply(const cublasHandle_t handle, 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[]){ |
|||
int lda = transA == CUBLAS_OP_N ? m : k; |
|||
int ldb = transB == CUBLAS_OP_N ? k : n; |
|||
|
|||
cublasSgemm(handle, transA, transB, m, n, k, &alpha, x, lda, y, ldb, &beta, c, m); |
|||
} |
|||
|
|||
DLLEXPORT void d_matrix_multiply(const cublasHandle_t handle, 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[]){ |
|||
int lda = transA == CUBLAS_OP_N ? m : k; |
|||
int ldb = transB == CUBLAS_OP_N ? k : n; |
|||
|
|||
cublasDgemm(handle, transA, transB, m, n, k, &alpha, x, lda, y, ldb, &beta, c, m); |
|||
} |
|||
|
|||
DLLEXPORT void c_matrix_multiply(const cublasHandle_t handle, 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[]){ |
|||
int lda = transA == CUBLAS_OP_N ? m : k; |
|||
int ldb = transB == CUBLAS_OP_N ? k : n; |
|||
|
|||
cublasCgemm(handle, transA, transB, m, n, k, &alpha, x, lda, y, ldb, &beta, c, m); |
|||
} |
|||
|
|||
DLLEXPORT void z_matrix_multiply(const cublasHandle_t handle, 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[]){ |
|||
int lda = transA == CUBLAS_OP_N ? m : k; |
|||
int ldb = transB == CUBLAS_OP_N ? k : n; |
|||
|
|||
cublasZgemm(handle, transA, transB, m, n, k, &alpha, x, lda, y, ldb, &beta, c, m); |
|||
} |
|||
|
|||
#if GCC |
|||
} |
|||
#endif |
|||
@ -0,0 +1,521 @@ |
|||
#include "lapack_common.h" |
|||
#include "wrapper_common.h" |
|||
#include "cublas.h" |
|||
#include "cusolverDn.h" |
|||
#include <algorithm> |
|||
|
|||
template<typename T, typename K> |
|||
inline int lu_factor(int m, T a[], int ipiv[], |
|||
int(*getrf) (CBLAS_ORDER, const int, const int, K*, const int, int*)) |
|||
{ |
|||
int info = getrf(CblasColMajor, m, m, a, m, ipiv); |
|||
shift_ipiv_down(m, ipiv); |
|||
return info; |
|||
}; |
|||
|
|||
template<typename T, typename K> |
|||
inline int lu_inverse(int n, T a[], |
|||
int(*getrf) (CBLAS_ORDER, const int, const int, K*, const int, int*), |
|||
int(*getri) (CBLAS_ORDER, const int, K*, const int, const int*)) |
|||
{ |
|||
int* ipiv = new int[n]; |
|||
int info = getrf(CblasColMajor, n, n, a, n, ipiv); |
|||
|
|||
if (info != 0){ |
|||
delete[] ipiv; |
|||
return info; |
|||
} |
|||
|
|||
info = getri(CblasColMajor, n, a, n, ipiv); |
|||
delete[] ipiv; |
|||
return info; |
|||
}; |
|||
|
|||
template<typename T, typename K> |
|||
inline int lu_inverse_factored(int n, T a[], int ipiv[], |
|||
int(*getri) (CBLAS_ORDER, const int, K*, const int, const int*)) |
|||
{ |
|||
shift_ipiv_up(n, ipiv); |
|||
int info = getri(CblasColMajor, n, a, n, ipiv); |
|||
shift_ipiv_down(n, ipiv); |
|||
return info; |
|||
} |
|||
|
|||
template<typename T, typename K> |
|||
inline int lu_solve_factored(int n, int nrhs, T a[], int ipiv[], T b[], |
|||
int(*getrs) (CBLAS_ORDER, CBLAS_TRANSPOSE, const int, const int, const K*, const int, const int*, K*, const int)) |
|||
{ |
|||
shift_ipiv_up(n, ipiv); |
|||
int info = getrs(CblasColMajor, CblasNoTrans, n, nrhs, a, n, ipiv, b, n); |
|||
shift_ipiv_down(n, ipiv); |
|||
return info; |
|||
} |
|||
|
|||
template<typename T, typename K> |
|||
inline int lu_solve(int n, int nrhs, T a[], T b[], |
|||
int(*getrf) (CBLAS_ORDER, const int, const int, K*, const int, int*), |
|||
int(*getrs) (CBLAS_ORDER, CBLAS_TRANSPOSE, const int, const int, const K*, const int, const int*, K*, const int)) |
|||
{ |
|||
T* clone = Clone(n, n, a); |
|||
int* ipiv = new int[n]; |
|||
int info = getrf(CblasColMajor, n, n, clone, n, ipiv); |
|||
|
|||
if (info != 0){ |
|||
delete[] ipiv; |
|||
delete[] clone; |
|||
return info; |
|||
} |
|||
|
|||
info = getrs(CblasColMajor, CblasNoTrans, n, nrhs, clone, n, ipiv, b, n); |
|||
delete[] ipiv; |
|||
delete[] clone; |
|||
return info; |
|||
} |
|||
|
|||
template<typename T, typename K> |
|||
inline int cholesky_factor(int n, T* a, int(*potrf) (CBLAS_ORDER, CBLAS_UPLO, const int, K*, const int)) |
|||
{ |
|||
int info = potrf(CblasColMajor, CblasLower, n, a, n); |
|||
T zero = T(); |
|||
for (int i = 0; i < n; ++i) |
|||
{ |
|||
int index = i * n; |
|||
for (int j = 0; j < n && i > j; ++j) |
|||
{ |
|||
a[index + j] = zero; |
|||
} |
|||
} |
|||
return info; |
|||
} |
|||
|
|||
template<typename T, typename K> |
|||
inline int cholesky_solve(int n, int nrhs, T a[], T b[], |
|||
int(*potrf) (CBLAS_ORDER, CBLAS_UPLO, const int, K*, const int), |
|||
int(*potrs) (CBLAS_ORDER, CBLAS_UPLO, const int, const int, const K*, const int, K*, const int)) |
|||
{ |
|||
T* clone = Clone(n, n, a); |
|||
int info = potrf(CblasColMajor, CblasLower, n, clone, n); |
|||
|
|||
if (info != 0){ |
|||
delete[] clone; |
|||
return info; |
|||
} |
|||
|
|||
info = potrs(CblasColMajor, CblasLower, n, nrhs, clone, n, b, n); |
|||
delete[] clone; |
|||
return info; |
|||
} |
|||
|
|||
template<typename T, typename K> |
|||
inline int cholesky_solve_factored(int n, int nrhs, T a[], T b[], |
|||
int(*potrs) (CBLAS_ORDER, CBLAS_UPLO, const int, const int, const K*, const int, K*, const int)) |
|||
{ |
|||
return potrs(CblasColMajor, CblasLower, n, nrhs, a, n, b, n); |
|||
} |
|||
|
|||
template<typename T, typename K> |
|||
inline int qr_factor(int m, int n, T r[], T tau[], T q[], T work[], int len, |
|||
int(*geqrf) (const int, const int, K*, const int, T*), |
|||
int(*orgqr) (const int, const int, const int, K*, const int, const K*)) |
|||
{ |
|||
int info = geqrf(m, n, r, m, tau); |
|||
|
|||
for (int i = 0; i < m; ++i) |
|||
{ |
|||
for (int j = 0; j < m && j < n; ++j) |
|||
{ |
|||
if (i > j) |
|||
{ |
|||
q[j * m + i] = r[j * m + i]; |
|||
} |
|||
} |
|||
} |
|||
|
|||
//compute the q elements explicitly
|
|||
if (m <= n) |
|||
{ |
|||
info = orgqr(m, m, m, q, m, tau); |
|||
} |
|||
else |
|||
{ |
|||
info = orgqr(m, m, n, q, m, tau); |
|||
} |
|||
|
|||
return info; |
|||
} |
|||
|
|||
template<typename T> |
|||
inline int qr_thin_factor(int m, int n, T q[], T tau[], T r[], T work[], int len, |
|||
void(*geqrf) (const int*, const int*, T*, const int*, T*, T*, const int*, int*), |
|||
void(*orgqr) (const int*, const int*, const int*, T*, const int*, const T*, T*, const int*, int*)) |
|||
{ |
|||
int info = 0; |
|||
geqrf(&m, &n, q, &m, tau, work, &len, &info); |
|||
|
|||
for (int i = 0; i < n; ++i) |
|||
{ |
|||
for (int j = 0; j < n; ++j) |
|||
{ |
|||
if (i <= j) { |
|||
r[j * n + i] = q[j * m + i]; |
|||
} |
|||
} |
|||
} |
|||
|
|||
orgqr(&m, &n, &n, q, &m, tau, work, &len, &info); |
|||
|
|||
return info; |
|||
} |
|||
|
|||
template<typename T> |
|||
inline int qr_solve(int m, int n, int bn, T a[], T b[], T x[], T work[], int len, |
|||
void(*gels) (const char*, const int*, const int*, const int*, T*, |
|||
const int*, T* b, const int*, T*, const int*, int*)) |
|||
{ |
|||
T* clone_a = new T[m*n]; |
|||
std::memcpy(clone_a, a, m*n*sizeof(T)); |
|||
|
|||
T* clone_b = new T[m*bn]; |
|||
std::memcpy(clone_b, b, m*bn*sizeof(T)); |
|||
|
|||
char N = 'N'; |
|||
int info = 0; |
|||
gels(&N, &m, &n, &bn, clone_a, &m, clone_b, &m, work, &len, &info); |
|||
copyBtoX(n, n, bn, clone_b, x); |
|||
|
|||
delete[] clone_a; |
|||
delete[] clone_b; |
|||
return info; |
|||
} |
|||
|
|||
template<typename T> |
|||
inline int qr_solve_factored(int m, int n, int bn, T r[], T b[], T tau[], T x[], T work[], int len, |
|||
void(*ormqr) (const char*, const char*, const int*, const int*, const int*, |
|||
const T*, const int*, const T*, T*, const int*, T*, const int*, int* info), |
|||
void(*trsm) (const CBLAS_ORDER, const CBLAS_SIDE, const CBLAS_UPLO, const CBLAS_TRANSPOSE, const CBLAS_DIAG, |
|||
const int, const int, const T, const T*, const int, T*, const int)) |
|||
{ |
|||
T* clone_b = new T[m*bn]; |
|||
std::memcpy(clone_b, b, m*bn*sizeof(T)); |
|||
|
|||
char side = 'L'; |
|||
char tran = 'T'; |
|||
int info = 0; |
|||
ormqr(&side, &tran, &m, &bn, &n, r, &m, tau, clone_b, &m, work, &len, &info); |
|||
trsm(CblasColMajor, CblasLeft, CblasUpper, CblasNoTrans, CblasNonUnit, n, bn, 1.0, r, m, clone_b, m); |
|||
copyBtoX(n, n, bn, clone_b, x); |
|||
|
|||
delete[] clone_b; |
|||
return info; |
|||
} |
|||
|
|||
template<typename T> |
|||
inline int complex_qr_solve_factored(int m, int n, int bn, T r[], T b[], T tau[], T x[], T work[], int len, |
|||
void(*unmqr) (const char*, const char*, const int*, const int*, const int*, |
|||
const T*, const int*, const T*, T*, const int*, T*, const int*, int* info), |
|||
void(*trsm) (const CBLAS_ORDER, const CBLAS_SIDE, const CBLAS_UPLO, const CBLAS_TRANSPOSE, const CBLAS_DIAG, |
|||
const int, const int, const void*, const void*, const int, void*, const int ldb)) |
|||
{ |
|||
T* clone_b = new T[m*bn]; |
|||
std::memcpy(clone_b, b, m*bn*sizeof(T)); |
|||
|
|||
char side = 'L'; |
|||
char tran = 'C'; |
|||
int info = 0; |
|||
unmqr(&side, &tran, &m, &bn, &n, r, &m, tau, clone_b, &m, work, &len, &info); |
|||
|
|||
T one = { 1.0f, 0.0f }; |
|||
trsm(CblasColMajor, CblasLeft, CblasUpper, CblasNoTrans, CblasNonUnit, n, bn, &one, r, m, clone_b, m); |
|||
copyBtoX(n, n, bn, clone_b, x); |
|||
|
|||
delete[] clone_b; |
|||
return info; |
|||
} |
|||
|
|||
template<typename T> |
|||
inline int svd_factor(bool compute_vectors, int m, int n, T a[], T s[], T u[], T v[], T work[], int len, |
|||
void(*gesvd) (const char*, const char*, const int*, const int*, T*, const int*, |
|||
T*, T*, const int*, T*, const int*, T*, const int*, int*)) |
|||
{ |
|||
int info = 0; |
|||
char job = compute_vectors ? 'A' : 'N'; |
|||
gesvd(&job, &job, &m, &n, a, &m, s, u, &m, v, &n, work, &len, &info); |
|||
return info; |
|||
} |
|||
|
|||
|
|||
template<typename T, typename R> |
|||
inline int complex_svd_factor(bool compute_vectors, int m, int n, T a[], T s[], T u[], T v[], T work[], int len, |
|||
void(*gesvd) (const char*, const char*, const int*, const int*, T*, const int*, |
|||
R*, T*, const int*, T*, const int*, T*, const int*, R*, int*)) |
|||
{ |
|||
int info = 0; |
|||
int dim_s = std::min(m, n); |
|||
R* rwork = new R[5 * dim_s]; |
|||
R* s_local = new R[dim_s]; |
|||
char job = compute_vectors ? 'A' : 'N'; |
|||
gesvd(&job, &job, &m, &n, a, &m, s_local, u, &m, v, &n, work, &len, rwork, &info); |
|||
|
|||
for (int index = 0; index < dim_s; ++index){ |
|||
T value = { s_local[index], 0.0f }; |
|||
s[index] = value; |
|||
} |
|||
|
|||
delete[] rwork; |
|||
delete[] s_local; |
|||
return info; |
|||
} |
|||
|
|||
extern "C" { |
|||
DLLEXPORT int s_lu_factor(int m, float a[], int ipiv[]) { |
|||
return lu_factor<float, float>(m, a, ipiv, cusolverDnSgetrf); |
|||
} |
|||
|
|||
DLLEXPORT int d_lu_factor(int m, double a[], int ipiv[]) { |
|||
return lu_factor<double, double>(m, a, ipiv, cusolverDnDgetrf); |
|||
} |
|||
|
|||
DLLEXPORT int c_lu_factor(int m, cuComplex a[], int ipiv[]) { |
|||
return lu_factor<cuComplex, void>(m, a, ipiv, cusolverDnCgetrf); |
|||
} |
|||
|
|||
DLLEXPORT int z_lu_factor(int m, cuDoubleComplex a[], int ipiv[]) { |
|||
return lu_factor(m, a, ipiv, cusolverDnZgetrf); |
|||
} |
|||
|
|||
DLLEXPORT int s_lu_inverse(int n, float a[]) |
|||
{ |
|||
return lu_inverse<float, float>(n, a, cusolverDnSgetrf, cusolverDnSgetri); |
|||
} |
|||
|
|||
DLLEXPORT int d_lu_inverse(int n, double a[]) |
|||
{ |
|||
return lu_inverse<double, double>(n, a, cusolverDnDgetrf, cusolverDnDgetri); |
|||
} |
|||
|
|||
DLLEXPORT int c_lu_inverse(int n, cuComplex a[]) |
|||
{ |
|||
return lu_inverse<cuComplex, void>(n, a, cusolverDnCgetrf, cusolverDnCgetri); |
|||
} |
|||
|
|||
DLLEXPORT int z_lu_inverse(int n, cuDoubleComplex a[]) |
|||
{ |
|||
return lu_inverse<cuDoubleComplex, void>(n, a, cusolverDnZgetrf, cusolverDnZgetri); |
|||
} |
|||
|
|||
DLLEXPORT int s_lu_inverse_factored(int n, float a[], int ipiv[], float work[], int lwork) |
|||
{ |
|||
return lu_inverse_factored<float, float>(n, a, ipiv, cusolverDnSgetri); |
|||
} |
|||
|
|||
DLLEXPORT int d_lu_inverse_factored(int n, double a[], int ipiv[], double work[], int lwork) |
|||
{ |
|||
return lu_inverse_factored<double, double>(n, a, ipiv, cusolverDnDgetri); |
|||
} |
|||
|
|||
DLLEXPORT int c_lu_inverse_factored(int n, cuComplex a[], int ipiv[], cuComplex work[], int lwork) |
|||
{ |
|||
return lu_inverse_factored<cuComplex, void>(n, a, ipiv, cusolverDnCgetri); |
|||
} |
|||
|
|||
DLLEXPORT int z_lu_inverse_factored(int n, cuDoubleComplex a[], int ipiv[], cuDoubleComplex work[], int lwork) |
|||
{ |
|||
return lu_inverse_factored<cuDoubleComplex, void>(n, a, ipiv, cusolverDnZgetri); |
|||
} |
|||
|
|||
DLLEXPORT int s_lu_solve_factored(int n, int nrhs, float a[], int ipiv[], float b[]) |
|||
{ |
|||
return lu_solve_factored<float, float>(n, nrhs, a, ipiv, b, cusolverDnSgetrs); |
|||
} |
|||
|
|||
DLLEXPORT int d_lu_solve_factored(int n, int nrhs, double a[], int ipiv[], double b[]) |
|||
{ |
|||
return lu_solve_factored<double, double>(n, nrhs, a, ipiv, b, cusolverDnDgetrs); |
|||
} |
|||
|
|||
DLLEXPORT int c_lu_solve_factored(int n, int nrhs, cuComplex a[], int ipiv[], cuComplex b[]) |
|||
{ |
|||
return lu_solve_factored<cuComplex, void>(n, nrhs, a, ipiv, b, cusolverDnCgetrs); |
|||
} |
|||
|
|||
DLLEXPORT int z_lu_solve_factored(int n, int nrhs, cuDoubleComplex a[], int ipiv[], cuDoubleComplex b[]) |
|||
{ |
|||
return lu_solve_factored<cuDoubleComplex, void>(n, nrhs, a, ipiv, b, cusolverDnZgetrs); |
|||
} |
|||
|
|||
DLLEXPORT int s_lu_solve(int n, int nrhs, float a[], float b[]) |
|||
{ |
|||
return lu_solve<float, float>(n, nrhs, a, b, cusolverDnSgetrf, cusolverDnSgetrs); |
|||
} |
|||
|
|||
DLLEXPORT int d_lu_solve(int n, int nrhs, double a[], double b[]) |
|||
{ |
|||
return lu_solve<double, double>(n, nrhs, a, b, cusolverDnDgetrf, cusolverDnDgetrs); |
|||
} |
|||
|
|||
DLLEXPORT int c_lu_solve(int n, int nrhs, cuComplex a[], cuComplex b[]) |
|||
{ |
|||
return lu_solve<cuComplex, void>(n, nrhs, a, b, cusolverDnCgetrf, cusolverDnCgetrs); |
|||
} |
|||
|
|||
DLLEXPORT int z_lu_solve(int n, int nrhs, cuDoubleComplex a[], cuDoubleComplex b[]) |
|||
{ |
|||
return lu_solve<cuDoubleComplex, void>(n, nrhs, a, b, cusolverDnZgetrf, cusolverDnZgetrs); |
|||
} |
|||
|
|||
DLLEXPORT int s_cholesky_factor(int n, float a[]){ |
|||
return cholesky_factor<float, float>(n, a, cusolverDnSpotrf); |
|||
} |
|||
|
|||
DLLEXPORT int d_cholesky_factor(int n, double* a){ |
|||
return cholesky_factor<double, double>(n, a, cusolverDnDpotrf); |
|||
} |
|||
|
|||
DLLEXPORT int c_cholesky_factor(int n, cuComplex a[]){ |
|||
return cholesky_factor<cuComplex, void>(n, a, cusolverDnCpotrf); |
|||
} |
|||
|
|||
DLLEXPORT int z_cholesky_factor(int n, cuDoubleComplex a[]){ |
|||
return cholesky_factor<cuDoubleComplex, void>(n, a, cusolverDnZpotrf); |
|||
} |
|||
|
|||
DLLEXPORT int s_cholesky_solve(int n, int nrhs, float a[], float b[]) |
|||
{ |
|||
return cholesky_solve<float, float>(n, nrhs, a, b, cusolverDnSpotrf, cusolverDnSpotrs); |
|||
} |
|||
|
|||
DLLEXPORT int d_cholesky_solve(int n, int nrhs, double a[], double b[]) |
|||
{ |
|||
return cholesky_solve<double, double>(n, nrhs, a, b, cusolverDnDpotrf, cusolverDnDpotrs); |
|||
} |
|||
|
|||
DLLEXPORT int c_cholesky_solve(int n, int nrhs, cuComplex a[], cuComplex b[]) |
|||
{ |
|||
return cholesky_solve<cuComplex, void>(n, nrhs, a, b, cusolverDnCpotrf, cusolverDnCpotrs); |
|||
} |
|||
|
|||
DLLEXPORT int z_cholesky_solve(int n, int nrhs, cuDoubleComplex a[], cuDoubleComplex b[]) |
|||
{ |
|||
return cholesky_solve<cuDoubleComplex, void>(n, nrhs, a, b, cusolverDnZpotrf, cusolverDnZpotrs); |
|||
} |
|||
|
|||
DLLEXPORT int s_cholesky_solve_factored(int n, int nrhs, float a[], float b[]) |
|||
{ |
|||
return cholesky_solve_factored<float, float>(n, nrhs, a, b, cusolverDnSpotrs); |
|||
} |
|||
|
|||
DLLEXPORT int d_cholesky_solve_factored(int n, int nrhs, double a[], double b[]) |
|||
{ |
|||
return cholesky_solve_factored<double, double>(n, nrhs, a, b, cusolverDnDpotrs); |
|||
} |
|||
|
|||
DLLEXPORT int c_cholesky_solve_factored(int n, int nrhs, cuComplex a[], cuComplex b[]) |
|||
{ |
|||
return cholesky_solve_factored<cuComplex, void>(n, nrhs, a, b, cusolverDnCpotrs); |
|||
} |
|||
|
|||
DLLEXPORT int z_cholesky_solve_factored(int n, int nrhs, cuDoubleComplex a[], cuDoubleComplex b[]) |
|||
{ |
|||
return cholesky_solve_factored<cuDoubleComplex, void>(n, nrhs, a, b, cusolverDnZpotrs); |
|||
} |
|||
|
|||
/*DLLEXPORT int s_qr_factor(int m, int n, float r[], float tau[], float q[], float work[], int len)
|
|||
{ |
|||
return qr_factor<float, float>(m, n, r, tau, q, work, len, cusolverDnSgeqrf, cusolverDnSorgqr); |
|||
} |
|||
|
|||
DLLEXPORT int s_qr_thin_factor(int m, int n, float q[], float tau[], float r[], float work[], int len) |
|||
{ |
|||
return qr_thin_factor<float>(m, n, q, tau, r, work, len, cusolverDnSgeqrf, cusolverDnSorgqr); |
|||
} |
|||
|
|||
DLLEXPORT int d_qr_factor(int m, int n, double r[], double tau[], double q[], double work[], int len) |
|||
{ |
|||
return qr_factor<double>(m, n, r, tau, q, work, len, cusolverDnDgeqrf, cusolverDnDorgqr); |
|||
} |
|||
|
|||
DLLEXPORT int d_qr_thin_factor(int m, int n, double q[], double tau[], double r[], double work[], int len) |
|||
{ |
|||
return qr_thin_factor<double>(m, n, q, tau, r, work, len, cusolverDnDgeqrf, cusolverDnDorgqr); |
|||
} |
|||
|
|||
DLLEXPORT int c_qr_factor(int m, int n, cuComplex r[], cuComplex tau[], cuComplex q[], cuComplex work[], int len) |
|||
{ |
|||
return qr_factor<cuComplex>(m, n, r, tau, q, work, len, cusolverDnCgeqrf, cusolverDnCungqr); |
|||
} |
|||
|
|||
DLLEXPORT int c_qr_thin_factor(int m, int n, cuComplex q[], cuComplex tau[], cuComplex r[], cuComplex work[], int len) |
|||
{ |
|||
return qr_thin_factor<cuComplex>(m, n, q, tau, r, work, len, cusolverDnCgeqrf, cusolverDnCungqr); |
|||
} |
|||
|
|||
DLLEXPORT int z_qr_factor(int m, int n, cuDoubleComplex r[], cuDoubleComplex tau[], cuDoubleComplex q[]) |
|||
{ |
|||
return qr_factor<cuDoubleComplex>(m, n, r, tau, q, work, len, cusolverDnZgeqrf, cusolverDnZungqr); |
|||
} |
|||
|
|||
DLLEXPORT int z_qr_thin_factor(int m, int n, cuDoubleComplex q[], cuDoubleComplex tau[], cuDoubleComplex r[]) |
|||
{ |
|||
return qr_thin_factor<cuDoubleComplex>(m, n, q, tau, r, work, len, cusolverDnZgeqrf, cusolverDnZungqr); |
|||
} |
|||
|
|||
DLLEXPORT int s_qr_solve(int m, int n, int bn, float a[], float b[], float x[], float work[], int len) |
|||
{ |
|||
return qr_solve<float>(m, n, bn, a, b, x, work, len, sgels); |
|||
} |
|||
|
|||
DLLEXPORT int d_qr_solve(int m, int n, int bn, double a[], double b[], double x[], double work[], int len) |
|||
{ |
|||
return qr_solve<double>(m, n, bn, a, b, x, work, len, dgels); |
|||
} |
|||
|
|||
DLLEXPORT int c_qr_solve(int m, int n, int bn, cuComplex a[], cuComplex b[], cuComplex x[], cuComplex work[], int len) |
|||
{ |
|||
return qr_solve<cuComplex>(m, n, bn, a, b, x, work, len, cgels); |
|||
} |
|||
|
|||
DLLEXPORT int z_qr_solve(int m, int n, int bn, cuDoubleComplex a[], cuDoubleComplex b[], cuDoubleComplex x[], cuDoubleComplex work[], int len) |
|||
{ |
|||
return qr_solve<cuDoubleComplex>(m, n, bn, a, b, x, work, len, zgels); |
|||
} |
|||
|
|||
DLLEXPORT int s_qr_solve_factored(int m, int n, int bn, float r[], float b[], float tau[], float x[], float work[], int len) |
|||
{ |
|||
return qr_solve_factored<float>(m, n, bn, r, b, tau, x, work, len, sormqr, cblas_strsm); |
|||
} |
|||
|
|||
DLLEXPORT int d_qr_solve_factored(int m, int n, int bn, double r[], double b[], double tau[], double x[], double work[], int len) |
|||
{ |
|||
return qr_solve_factored<double>(m, n, bn, r, b, tau, x, work, len, dormqr, cblas_dtrsm); |
|||
} |
|||
|
|||
DLLEXPORT int c_qr_solve_factored(int m, int n, int bn, cuComplex r[], cuComplex b[], cuComplex tau[], cuComplex x[], cuComplex work[], int len) |
|||
{ |
|||
return complex_qr_solve_factored<cuComplex>(m, n, bn, r, b, tau, x, work, len, cunmqr, cblas_ctrsm); |
|||
} |
|||
|
|||
DLLEXPORT int z_qr_solve_factored(int m, int n, int bn, cuDoubleComplex r[], cuDoubleComplex b[], cuDoubleComplex tau[], cuDoubleComplex x[], cuDoubleComplex work[], int len) |
|||
{ |
|||
return complex_qr_solve_factored<cuDoubleComplex>(m, n, bn, r, b, tau, x, work, len, zunmqr, cblas_ztrsm); |
|||
} |
|||
|
|||
DLLEXPORT int s_svd_factor(bool compute_vectors, int m, int n, float a[], float s[], float u[], float v[], float work[], int len) |
|||
{ |
|||
return svd_factor<float>(compute_vectors, m, n, a, s, u, v, work, len, sgesvd); |
|||
} |
|||
|
|||
DLLEXPORT int d_svd_factor(bool compute_vectors, int m, int n, double a[], double s[], double u[], double v[], double work[], int len) |
|||
{ |
|||
return svd_factor<double>(compute_vectors, m, n, a, s, u, v, work, len, dgesvd); |
|||
} |
|||
|
|||
DLLEXPORT int c_svd_factor(bool compute_vectors, int m, int n, cuComplex a[], cuComplex s[], cuComplex u[], cuComplex v[], cuComplex work[], int len) |
|||
{ |
|||
return complex_svd_factor<cuComplex, float>(compute_vectors, m, n, a, s, u, v, work, len, cgesvd); |
|||
} |
|||
|
|||
DLLEXPORT int z_svd_factor(bool compute_vectors, int m, int n, cuDoubleComplex a[], cuDoubleComplex s[], cuDoubleComplex u[], cuDoubleComplex v[], cuDoubleComplex work[], int len) |
|||
{ |
|||
return complex_svd_factor<cuDoubleComplex, double>(compute_vectors, m, n, a, s, u, v, work, len, zgesvd); |
|||
}*/ |
|||
} |
|||
Loading…
Reference in new issue