347 lines
8.2 KiB
C++
347 lines
8.2 KiB
C++
// Copyright 2008-2016 Conrad Sanderson (http://conradsanderson.id.au)
|
|
// Copyright 2008-2016 National ICT Australia (NICTA)
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
// ------------------------------------------------------------------------
|
|
|
|
|
|
|
|
#if defined(ARMA_USE_SUPERLU)
|
|
|
|
//! \namespace superlu namespace for SuperLU functions
|
|
namespace superlu
|
|
{
|
|
|
|
template<typename eT>
|
|
inline
|
|
void
|
|
gssv(superlu_options_t* options, SuperMatrix* A, int* perm_c, int* perm_r, SuperMatrix* L, SuperMatrix* U, SuperMatrix* B, SuperLUStat_t* stat, int* info)
|
|
{
|
|
arma_type_check(( is_supported_blas_type<eT>::value == false ));
|
|
|
|
if(is_float<eT>::value)
|
|
{
|
|
arma_wrapper(sgssv)(options, A, perm_c, perm_r, L, U, B, stat, info);
|
|
}
|
|
else
|
|
if(is_double<eT>::value)
|
|
{
|
|
arma_wrapper(dgssv)(options, A, perm_c, perm_r, L, U, B, stat, info);
|
|
}
|
|
else
|
|
if(is_cx_float<eT>::value)
|
|
{
|
|
arma_wrapper(cgssv)(options, A, perm_c, perm_r, L, U, B, stat, info);
|
|
}
|
|
else
|
|
if(is_cx_double<eT>::value)
|
|
{
|
|
arma_wrapper(zgssv)(options, A, perm_c, perm_r, L, U, B, stat, info);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
template<typename eT>
|
|
inline
|
|
void
|
|
gssvx(
|
|
superlu_options_t* opts,
|
|
SuperMatrix* A,
|
|
int* perm_c, int* perm_r,
|
|
int* etree, char* equed,
|
|
typename get_pod_type<eT>::result* R, typename get_pod_type<eT>::result* C,
|
|
SuperMatrix* L, SuperMatrix* U,
|
|
void* work, int lwork,
|
|
SuperMatrix* B, SuperMatrix* X,
|
|
typename get_pod_type<eT>::result* rpg, typename get_pod_type<eT>::result* rcond,
|
|
typename get_pod_type<eT>::result* ferr, typename get_pod_type<eT>::result* berr,
|
|
GlobalLU_t* glu, mem_usage_t* mu, SuperLUStat_t* stat, int* info
|
|
)
|
|
{
|
|
arma_type_check(( is_supported_blas_type<eT>::value == false ));
|
|
|
|
if(is_float<eT>::value)
|
|
{
|
|
typedef float T;
|
|
arma_wrapper(sgssvx)(opts, A, perm_c, perm_r, etree, equed, (T*)R, (T*)C, L, U, work, lwork, B, X, (T*)rpg, (T*)rcond, (T*)ferr, (T*)berr, glu, mu, stat, info);
|
|
}
|
|
else
|
|
if(is_double<eT>::value)
|
|
{
|
|
typedef double T;
|
|
arma_wrapper(dgssvx)(opts, A, perm_c, perm_r, etree, equed, (T*)R, (T*)C, L, U, work, lwork, B, X, (T*)rpg, (T*)rcond, (T*)ferr, (T*)berr, glu, mu, stat, info);
|
|
}
|
|
else
|
|
if(is_cx_float<eT>::value)
|
|
{
|
|
typedef float T;
|
|
arma_wrapper(cgssvx)(opts, A, perm_c, perm_r, etree, equed, (T*)R, (T*)C, L, U, work, lwork, B, X, (T*)rpg, (T*)rcond, (T*)ferr, (T*)berr, glu, mu, stat, info);
|
|
}
|
|
else
|
|
if(is_cx_double<eT>::value)
|
|
{
|
|
typedef double T;
|
|
arma_wrapper(zgssvx)(opts, A, perm_c, perm_r, etree, equed, (T*)R, (T*)C, L, U, work, lwork, B, X, (T*)rpg, (T*)rcond, (T*)ferr, (T*)berr, glu, mu, stat, info);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
template<typename eT>
|
|
inline
|
|
void
|
|
gstrf(superlu_options_t* options,
|
|
SuperMatrix* A,
|
|
int relax,
|
|
int panel_size, int *etree,
|
|
void *work, int lwork,
|
|
int* perm_c, int* perm_r,
|
|
SuperMatrix* L, SuperMatrix* U,
|
|
GlobalLU_t* Glu, SuperLUStat_t* stat, int* info
|
|
)
|
|
{
|
|
arma_type_check(( is_supported_blas_type<eT>::value == false ));
|
|
|
|
if(is_float<eT>::value)
|
|
{
|
|
arma_wrapper(sgstrf)(options, A, relax, panel_size, etree, work, lwork, perm_c, perm_r, L, U, Glu, stat, info);
|
|
}
|
|
else
|
|
if(is_double<eT>::value)
|
|
{
|
|
arma_wrapper(dgstrf)(options, A, relax, panel_size, etree, work, lwork, perm_c, perm_r, L, U, Glu, stat, info);
|
|
}
|
|
else
|
|
if(is_cx_float<eT>::value)
|
|
{
|
|
arma_wrapper(cgstrf)(options, A, relax, panel_size, etree, work, lwork, perm_c, perm_r, L, U, Glu, stat, info);
|
|
}
|
|
else
|
|
if(is_cx_double<eT>::value)
|
|
{
|
|
arma_wrapper(zgstrf)(options, A, relax, panel_size, etree, work, lwork, perm_c, perm_r, L, U, Glu, stat, info);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
template<typename eT>
|
|
inline
|
|
void
|
|
gstrs(trans_t trans,
|
|
SuperMatrix* L, SuperMatrix* U,
|
|
int* perm_c, int* perm_r,
|
|
SuperMatrix* B, SuperLUStat_t* stat, int* info
|
|
)
|
|
{
|
|
arma_type_check(( is_supported_blas_type<eT>::value == false ));
|
|
|
|
if(is_float<eT>::value)
|
|
{
|
|
arma_wrapper(sgstrs)(trans, L, U, perm_c, perm_r, B, stat, info);
|
|
}
|
|
else
|
|
if(is_double<eT>::value)
|
|
{
|
|
arma_wrapper(dgstrs)(trans, L, U, perm_c, perm_r, B, stat, info);
|
|
}
|
|
else
|
|
if(is_cx_float<eT>::value)
|
|
{
|
|
arma_wrapper(cgstrs)(trans, L, U, perm_c, perm_r, B, stat, info);
|
|
}
|
|
else
|
|
if(is_cx_double<eT>::value)
|
|
{
|
|
arma_wrapper(zgstrs)(trans, L, U, perm_c, perm_r, B, stat, info);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
template<typename eT>
|
|
inline
|
|
typename get_pod_type<eT>::result
|
|
langs(char* norm, superlu::SuperMatrix* A)
|
|
{
|
|
arma_type_check(( is_supported_blas_type<eT>::value == false ));
|
|
|
|
typedef typename get_pod_type<eT>::result T;
|
|
|
|
if(is_float<eT>::value)
|
|
{
|
|
return arma_wrapper(slangs)(norm, A);
|
|
}
|
|
else
|
|
if(is_double<eT>::value)
|
|
{
|
|
return arma_wrapper(dlangs)(norm, A);
|
|
}
|
|
else
|
|
if(is_cx_float<eT>::value)
|
|
{
|
|
return arma_wrapper(clangs)(norm, A);
|
|
}
|
|
else
|
|
if(is_cx_double<eT>::value)
|
|
{
|
|
return arma_wrapper(zlangs)(norm, A);
|
|
}
|
|
|
|
return T(0); // to avoid false warnigns from the compiler
|
|
}
|
|
|
|
|
|
|
|
template<typename eT>
|
|
inline
|
|
void
|
|
gscon(char* norm, superlu::SuperMatrix* L, superlu::SuperMatrix* U, typename get_pod_type<eT>::result anorm, typename get_pod_type<eT>::result* rcond, superlu::SuperLUStat_t* stat, int* info)
|
|
{
|
|
arma_type_check(( is_supported_blas_type<eT>::value == false ));
|
|
|
|
if(is_float<eT>::value)
|
|
{
|
|
typedef float T;
|
|
arma_wrapper(sgscon)(norm, L, U, (T)anorm, (T*)rcond, stat, info);
|
|
}
|
|
else
|
|
if(is_double<eT>::value)
|
|
{
|
|
typedef double T;
|
|
arma_wrapper(dgscon)(norm, L, U, (T)anorm, (T*)rcond, stat, info);
|
|
}
|
|
else
|
|
if(is_cx_float<eT>::value)
|
|
{
|
|
typedef float T;
|
|
arma_wrapper(cgscon)(norm, L, U, (T)anorm, (T*)rcond, stat, info);
|
|
}
|
|
else
|
|
if(is_cx_double<eT>::value)
|
|
{
|
|
typedef double T;
|
|
arma_wrapper(zgscon)(norm, L, U, (T)anorm, (T*)rcond, stat, info);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
inline
|
|
void
|
|
init_stat(SuperLUStat_t* stat)
|
|
{
|
|
arma_wrapper(StatInit)(stat);
|
|
}
|
|
|
|
|
|
inline
|
|
void
|
|
free_stat(SuperLUStat_t* stat)
|
|
{
|
|
arma_wrapper(StatFree)(stat);
|
|
}
|
|
|
|
|
|
|
|
inline
|
|
void
|
|
set_default_opts(superlu_options_t* opts)
|
|
{
|
|
arma_wrapper(set_default_options)(opts);
|
|
}
|
|
|
|
|
|
inline
|
|
void
|
|
get_permutation_c(int ispec, SuperMatrix* A, int* perm_c)
|
|
{
|
|
arma_wrapper(get_perm_c)(ispec, A, perm_c);
|
|
}
|
|
|
|
|
|
|
|
inline
|
|
void
|
|
sp_preorder_mat(superlu_options_t* opts, SuperMatrix* A, int* perm_c, int* etree, SuperMatrix* AC)
|
|
{
|
|
arma_wrapper(sp_preorder)(opts, A, perm_c, etree, AC);
|
|
}
|
|
|
|
|
|
|
|
inline
|
|
int
|
|
sp_ispec_environ(int ispec)
|
|
{
|
|
return arma_wrapper(sp_ienv)(ispec);
|
|
}
|
|
|
|
|
|
|
|
inline
|
|
void
|
|
destroy_supernode_mat(SuperMatrix* a)
|
|
{
|
|
arma_wrapper(Destroy_SuperNode_Matrix)(a);
|
|
}
|
|
|
|
|
|
|
|
inline
|
|
void
|
|
destroy_compcol_mat(SuperMatrix* a)
|
|
{
|
|
arma_wrapper(Destroy_CompCol_Matrix)(a);
|
|
}
|
|
|
|
|
|
|
|
inline
|
|
void
|
|
destroy_compcolperm_mat(SuperMatrix* a)
|
|
{
|
|
arma_wrapper(Destroy_CompCol_Permuted)(a);
|
|
}
|
|
|
|
|
|
|
|
inline
|
|
void
|
|
destroy_dense_mat(SuperMatrix* a)
|
|
{
|
|
arma_wrapper(Destroy_SuperMatrix_Store)(a);
|
|
}
|
|
|
|
|
|
|
|
inline
|
|
void*
|
|
malloc(size_t N)
|
|
{
|
|
return arma_wrapper(superlu_malloc)(N);
|
|
}
|
|
|
|
|
|
|
|
inline
|
|
void
|
|
free(void* mem)
|
|
{
|
|
arma_wrapper(superlu_free)(mem);
|
|
}
|
|
|
|
} // namespace superlu
|
|
|
|
#endif
|