LAPACK  3.5.0
LAPACK: Linear Algebra PACKage
lapacke_utils.h File Reference
#include "lapacke.h"
Include dependency graph for lapacke_utils.h:

Go to the source code of this file.

Macros

#define ABS(x)   (((x) < 0) ? -(x) : (x))
 
#define MAX(x, y)   (((x) > (y)) ? (x) : (y))
 
#define MIN(x, y)   (((x) < (y)) ? (x) : (y))
 
#define MAX3(x, y, z)   (((x) > MAX(y,z)) ? (x) : MAX(y,z))
 
#define MIN3(x, y, z)   (((x) < MIN(y,z)) ? (x) : MIN(y,z))
 
#define IS_S_NONZERO(x)   ( (x) < 0 || (x) > 0 )
 
#define IS_D_NONZERO(x)   ( (x) < 0 || (x) > 0 )
 
#define IS_C_NONZERO(x)
 
#define IS_Z_NONZERO(x)
 
#define LAPACK_SISNAN(x)   ( x != x )
 
#define LAPACK_DISNAN(x)   ( x != x )
 
#define LAPACK_CISNAN(x)
 
#define LAPACK_ZISNAN(x)
 

Functions

void LAPACKE_xerbla (const char *name, lapack_int info)
 
lapack_logical LAPACKE_lsame (char ca, char cb)
 
void LAPACKE_cgb_trans (int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const lapack_complex_float *in, lapack_int ldin, lapack_complex_float *out, lapack_int ldout)
 
void LAPACKE_cge_trans (int matrix_order, lapack_int m, lapack_int n, const lapack_complex_float *in, lapack_int ldin, lapack_complex_float *out, lapack_int ldout)
 
void LAPACKE_cgg_trans (int matrix_order, lapack_int m, lapack_int n, const lapack_complex_float *in, lapack_int ldin, lapack_complex_float *out, lapack_int ldout)
 
void LAPACKE_chb_trans (int matrix_order, char uplo, lapack_int n, lapack_int kd, const lapack_complex_float *in, lapack_int ldin, lapack_complex_float *out, lapack_int ldout)
 
void LAPACKE_che_trans (int matrix_order, char uplo, lapack_int n, const lapack_complex_float *in, lapack_int ldin, lapack_complex_float *out, lapack_int ldout)
 
void LAPACKE_chp_trans (int matrix_order, char uplo, lapack_int n, const lapack_complex_float *in, lapack_complex_float *out)
 
void LAPACKE_chs_trans (int matrix_order, lapack_int n, const lapack_complex_float *in, lapack_int ldin, lapack_complex_float *out, lapack_int ldout)
 
void LAPACKE_cpb_trans (int matrix_order, char uplo, lapack_int n, lapack_int kd, const lapack_complex_float *in, lapack_int ldin, lapack_complex_float *out, lapack_int ldout)
 
void LAPACKE_cpf_trans (int matrix_order, char transr, char uplo, lapack_int n, const lapack_complex_float *in, lapack_complex_float *out)
 
void LAPACKE_cpo_trans (int matrix_order, char uplo, lapack_int n, const lapack_complex_float *in, lapack_int ldin, lapack_complex_float *out, lapack_int ldout)
 
void LAPACKE_cpp_trans (int matrix_order, char uplo, lapack_int n, const lapack_complex_float *in, lapack_complex_float *out)
 
void LAPACKE_csp_trans (int matrix_order, char uplo, lapack_int n, const lapack_complex_float *in, lapack_complex_float *out)
 
void LAPACKE_csy_trans (int matrix_order, char uplo, lapack_int n, const lapack_complex_float *in, lapack_int ldin, lapack_complex_float *out, lapack_int ldout)
 
void LAPACKE_ctb_trans (int matrix_order, char uplo, char diag, lapack_int n, lapack_int kd, const lapack_complex_float *in, lapack_int ldin, lapack_complex_float *out, lapack_int ldout)
 
void LAPACKE_ctf_trans (int matrix_order, char transr, char uplo, char diag, lapack_int n, const lapack_complex_float *in, lapack_complex_float *out)
 
void LAPACKE_ctp_trans (int matrix_order, char uplo, char diag, lapack_int n, const lapack_complex_float *in, lapack_complex_float *out)
 
void LAPACKE_ctr_trans (int matrix_order, char uplo, char diag, lapack_int n, const lapack_complex_float *in, lapack_int ldin, lapack_complex_float *out, lapack_int ldout)
 
void LAPACKE_dgb_trans (int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const double *in, lapack_int ldin, double *out, lapack_int ldout)
 
void LAPACKE_dge_trans (int matrix_order, lapack_int m, lapack_int n, const double *in, lapack_int ldin, double *out, lapack_int ldout)
 
void LAPACKE_dgg_trans (int matrix_order, lapack_int m, lapack_int n, const double *in, lapack_int ldin, double *out, lapack_int ldout)
 
void LAPACKE_dhs_trans (int matrix_order, lapack_int n, const double *in, lapack_int ldin, double *out, lapack_int ldout)
 
void LAPACKE_dpb_trans (int matrix_order, char uplo, lapack_int n, lapack_int kd, const double *in, lapack_int ldin, double *out, lapack_int ldout)
 
void LAPACKE_dpf_trans (int matrix_order, char transr, char uplo, lapack_int n, const double *in, double *out)
 
void LAPACKE_dpo_trans (int matrix_order, char uplo, lapack_int n, const double *in, lapack_int ldin, double *out, lapack_int ldout)
 
void LAPACKE_dpp_trans (int matrix_order, char uplo, lapack_int n, const double *in, double *out)
 
void LAPACKE_dsb_trans (int matrix_order, char uplo, lapack_int n, lapack_int kd, const double *in, lapack_int ldin, double *out, lapack_int ldout)
 
void LAPACKE_dsp_trans (int matrix_order, char uplo, lapack_int n, const double *in, double *out)
 
void LAPACKE_dsy_trans (int matrix_order, char uplo, lapack_int n, const double *in, lapack_int ldin, double *out, lapack_int ldout)
 
void LAPACKE_dtb_trans (int matrix_order, char uplo, char diag, lapack_int n, lapack_int kd, const double *in, lapack_int ldin, double *out, lapack_int ldout)
 
void LAPACKE_dtf_trans (int matrix_order, char transr, char uplo, char diag, lapack_int n, const double *in, double *out)
 
void LAPACKE_dtp_trans (int matrix_order, char uplo, char diag, lapack_int n, const double *in, double *out)
 
void LAPACKE_dtr_trans (int matrix_order, char uplo, char diag, lapack_int n, const double *in, lapack_int ldin, double *out, lapack_int ldout)
 
void LAPACKE_sgb_trans (int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const float *in, lapack_int ldin, float *out, lapack_int ldout)
 
void LAPACKE_sge_trans (int matrix_order, lapack_int m, lapack_int n, const float *in, lapack_int ldin, float *out, lapack_int ldout)
 
void LAPACKE_sgg_trans (int matrix_order, lapack_int m, lapack_int n, const float *in, lapack_int ldin, float *out, lapack_int ldout)
 
void LAPACKE_shs_trans (int matrix_order, lapack_int n, const float *in, lapack_int ldin, float *out, lapack_int ldout)
 
void LAPACKE_spb_trans (int matrix_order, char uplo, lapack_int n, lapack_int kd, const float *in, lapack_int ldin, float *out, lapack_int ldout)
 
void LAPACKE_spf_trans (int matrix_order, char transr, char uplo, lapack_int n, const float *in, float *out)
 
void LAPACKE_spo_trans (int matrix_order, char uplo, lapack_int n, const float *in, lapack_int ldin, float *out, lapack_int ldout)
 
void LAPACKE_spp_trans (int matrix_order, char uplo, lapack_int n, const float *in, float *out)
 
void LAPACKE_ssb_trans (int matrix_order, char uplo, lapack_int n, lapack_int kd, const float *in, lapack_int ldin, float *out, lapack_int ldout)
 
void LAPACKE_ssp_trans (int matrix_order, char uplo, lapack_int n, const float *in, float *out)
 
void LAPACKE_ssy_trans (int matrix_order, char uplo, lapack_int n, const float *in, lapack_int ldin, float *out, lapack_int ldout)
 
void LAPACKE_stb_trans (int matrix_order, char uplo, char diag, lapack_int n, lapack_int kd, const float *in, lapack_int ldin, float *out, lapack_int ldout)
 
void LAPACKE_stf_trans (int matrix_order, char transr, char uplo, char diag, lapack_int n, const float *in, float *out)
 
void LAPACKE_stp_trans (int matrix_order, char uplo, char diag, lapack_int n, const float *in, float *out)
 
void LAPACKE_str_trans (int matrix_order, char uplo, char diag, lapack_int n, const float *in, lapack_int ldin, float *out, lapack_int ldout)
 
void LAPACKE_zgb_trans (int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const lapack_complex_double *in, lapack_int ldin, lapack_complex_double *out, lapack_int ldout)
 
void LAPACKE_zge_trans (int matrix_order, lapack_int m, lapack_int n, const lapack_complex_double *in, lapack_int ldin, lapack_complex_double *out, lapack_int ldout)
 
void LAPACKE_zgg_trans (int matrix_order, lapack_int m, lapack_int n, const lapack_complex_double *in, lapack_int ldin, lapack_complex_double *out, lapack_int ldout)
 
void LAPACKE_zhb_trans (int matrix_order, char uplo, lapack_int n, lapack_int kd, const lapack_complex_double *in, lapack_int ldin, lapack_complex_double *out, lapack_int ldout)
 
void LAPACKE_zhe_trans (int matrix_order, char uplo, lapack_int n, const lapack_complex_double *in, lapack_int ldin, lapack_complex_double *out, lapack_int ldout)
 
void LAPACKE_zhp_trans (int matrix_order, char uplo, lapack_int n, const lapack_complex_double *in, lapack_complex_double *out)
 
void LAPACKE_zhs_trans (int matrix_order, lapack_int n, const lapack_complex_double *in, lapack_int ldin, lapack_complex_double *out, lapack_int ldout)
 
void LAPACKE_zpb_trans (int matrix_order, char uplo, lapack_int n, lapack_int kd, const lapack_complex_double *in, lapack_int ldin, lapack_complex_double *out, lapack_int ldout)
 
void LAPACKE_zpf_trans (int matrix_order, char transr, char uplo, lapack_int n, const lapack_complex_double *in, lapack_complex_double *out)
 
void LAPACKE_zpo_trans (int matrix_order, char uplo, lapack_int n, const lapack_complex_double *in, lapack_int ldin, lapack_complex_double *out, lapack_int ldout)
 
void LAPACKE_zpp_trans (int matrix_order, char uplo, lapack_int n, const lapack_complex_double *in, lapack_complex_double *out)
 
void LAPACKE_zsp_trans (int matrix_order, char uplo, lapack_int n, const lapack_complex_double *in, lapack_complex_double *out)
 
void LAPACKE_zsy_trans (int matrix_order, char uplo, lapack_int n, const lapack_complex_double *in, lapack_int ldin, lapack_complex_double *out, lapack_int ldout)
 
void LAPACKE_ztb_trans (int matrix_order, char uplo, char diag, lapack_int n, lapack_int kd, const lapack_complex_double *in, lapack_int ldin, lapack_complex_double *out, lapack_int ldout)
 
void LAPACKE_ztf_trans (int matrix_order, char transr, char uplo, char diag, lapack_int n, const lapack_complex_double *in, lapack_complex_double *out)
 
void LAPACKE_ztp_trans (int matrix_order, char uplo, char diag, lapack_int n, const lapack_complex_double *in, lapack_complex_double *out)
 
void LAPACKE_ztr_trans (int matrix_order, char uplo, char diag, lapack_int n, const lapack_complex_double *in, lapack_int ldin, lapack_complex_double *out, lapack_int ldout)
 
lapack_logical LAPACKE_c_nancheck (lapack_int n, const lapack_complex_float *x, lapack_int incx)
 
lapack_logical LAPACKE_d_nancheck (lapack_int n, const double *x, lapack_int incx)
 
lapack_logical LAPACKE_s_nancheck (lapack_int n, const float *x, lapack_int incx)
 
lapack_logical LAPACKE_z_nancheck (lapack_int n, const lapack_complex_double *x, lapack_int incx)
 
lapack_logical LAPACKE_cgb_nancheck (int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const lapack_complex_float *ab, lapack_int ldab)
 
lapack_logical LAPACKE_cge_nancheck (int matrix_order, lapack_int m, lapack_int n, const lapack_complex_float *a, lapack_int lda)
 
lapack_logical LAPACKE_cgg_nancheck (int matrix_order, lapack_int m, lapack_int n, const lapack_complex_float *a, lapack_int lda)
 
lapack_logical LAPACKE_cgt_nancheck (lapack_int n, const lapack_complex_float *dl, const lapack_complex_float *d, const lapack_complex_float *du)
 
lapack_logical LAPACKE_chb_nancheck (int matrix_order, char uplo, lapack_int n, lapack_int kd, const lapack_complex_float *ab, lapack_int ldab)
 
lapack_logical LAPACKE_che_nancheck (int matrix_order, char uplo, lapack_int n, const lapack_complex_float *a, lapack_int lda)
 
lapack_logical LAPACKE_chp_nancheck (lapack_int n, const lapack_complex_float *ap)
 
lapack_logical LAPACKE_chs_nancheck (int matrix_order, lapack_int n, const lapack_complex_float *a, lapack_int lda)
 
lapack_logical LAPACKE_cpb_nancheck (int matrix_order, char uplo, lapack_int n, lapack_int kd, const lapack_complex_float *ab, lapack_int ldab)
 
lapack_logical LAPACKE_cpf_nancheck (lapack_int n, const lapack_complex_float *a)
 
lapack_logical LAPACKE_cpo_nancheck (int matrix_order, char uplo, lapack_int n, const lapack_complex_float *a, lapack_int lda)
 
lapack_logical LAPACKE_cpp_nancheck (lapack_int n, const lapack_complex_float *ap)
 
lapack_logical LAPACKE_cpt_nancheck (lapack_int n, const float *d, const lapack_complex_float *e)
 
lapack_logical LAPACKE_csp_nancheck (lapack_int n, const lapack_complex_float *ap)
 
lapack_logical LAPACKE_cst_nancheck (lapack_int n, const lapack_complex_float *d, const lapack_complex_float *e)
 
lapack_logical LAPACKE_csy_nancheck (int matrix_order, char uplo, lapack_int n, const lapack_complex_float *a, lapack_int lda)
 
lapack_logical LAPACKE_ctb_nancheck (int matrix_order, char uplo, char diag, lapack_int n, lapack_int kd, const lapack_complex_float *ab, lapack_int ldab)
 
lapack_logical LAPACKE_ctf_nancheck (int matrix_order, char transr, char uplo, char diag, lapack_int n, const lapack_complex_float *a)
 
lapack_logical LAPACKE_ctp_nancheck (int matrix_order, char uplo, char diag, lapack_int n, const lapack_complex_float *ap)
 
lapack_logical LAPACKE_ctr_nancheck (int matrix_order, char uplo, char diag, lapack_int n, const lapack_complex_float *a, lapack_int lda)
 
lapack_logical LAPACKE_dgb_nancheck (int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const double *ab, lapack_int ldab)
 
lapack_logical LAPACKE_dge_nancheck (int matrix_order, lapack_int m, lapack_int n, const double *a, lapack_int lda)
 
lapack_logical LAPACKE_dgg_nancheck (int matrix_order, lapack_int m, lapack_int n, const double *a, lapack_int lda)
 
lapack_logical LAPACKE_dgt_nancheck (lapack_int n, const double *dl, const double *d, const double *du)
 
lapack_logical LAPACKE_dhs_nancheck (int matrix_order, lapack_int n, const double *a, lapack_int lda)
 
lapack_logical LAPACKE_dpb_nancheck (int matrix_order, char uplo, lapack_int n, lapack_int kd, const double *ab, lapack_int ldab)
 
lapack_logical LAPACKE_dpf_nancheck (lapack_int n, const double *a)
 
lapack_logical LAPACKE_dpo_nancheck (int matrix_order, char uplo, lapack_int n, const double *a, lapack_int lda)
 
lapack_logical LAPACKE_dpp_nancheck (lapack_int n, const double *ap)
 
lapack_logical LAPACKE_dpt_nancheck (lapack_int n, const double *d, const double *e)
 
lapack_logical LAPACKE_dsb_nancheck (int matrix_order, char uplo, lapack_int n, lapack_int kd, const double *ab, lapack_int ldab)
 
lapack_logical LAPACKE_dsp_nancheck (lapack_int n, const double *ap)
 
lapack_logical LAPACKE_dst_nancheck (lapack_int n, const double *d, const double *e)
 
lapack_logical LAPACKE_dsy_nancheck (int matrix_order, char uplo, lapack_int n, const double *a, lapack_int lda)
 
lapack_logical LAPACKE_dtb_nancheck (int matrix_order, char uplo, char diag, lapack_int n, lapack_int kd, const double *ab, lapack_int ldab)
 
lapack_logical LAPACKE_dtf_nancheck (int matrix_order, char transr, char uplo, char diag, lapack_int n, const double *a)
 
lapack_logical LAPACKE_dtp_nancheck (int matrix_order, char uplo, char diag, lapack_int n, const double *ap)
 
lapack_logical LAPACKE_dtr_nancheck (int matrix_order, char uplo, char diag, lapack_int n, const double *a, lapack_int lda)
 
lapack_logical LAPACKE_sgb_nancheck (int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const float *ab, lapack_int ldab)
 
lapack_logical LAPACKE_sge_nancheck (int matrix_order, lapack_int m, lapack_int n, const float *a, lapack_int lda)
 
lapack_logical LAPACKE_sgg_nancheck (int matrix_order, lapack_int m, lapack_int n, const float *a, lapack_int lda)
 
lapack_logical LAPACKE_sgt_nancheck (lapack_int n, const float *dl, const float *d, const float *du)
 
lapack_logical LAPACKE_shs_nancheck (int matrix_order, lapack_int n, const float *a, lapack_int lda)
 
lapack_logical LAPACKE_spb_nancheck (int matrix_order, char uplo, lapack_int n, lapack_int kd, const float *ab, lapack_int ldab)
 
lapack_logical LAPACKE_spf_nancheck (lapack_int n, const float *a)
 
lapack_logical LAPACKE_spo_nancheck (int matrix_order, char uplo, lapack_int n, const float *a, lapack_int lda)
 
lapack_logical LAPACKE_spp_nancheck (lapack_int n, const float *ap)
 
lapack_logical LAPACKE_spt_nancheck (lapack_int n, const float *d, const float *e)
 
lapack_logical LAPACKE_ssb_nancheck (int matrix_order, char uplo, lapack_int n, lapack_int kd, const float *ab, lapack_int ldab)
 
lapack_logical LAPACKE_ssp_nancheck (lapack_int n, const float *ap)
 
lapack_logical LAPACKE_sst_nancheck (lapack_int n, const float *d, const float *e)
 
lapack_logical LAPACKE_ssy_nancheck (int matrix_order, char uplo, lapack_int n, const float *a, lapack_int lda)
 
lapack_logical LAPACKE_stb_nancheck (int matrix_order, char uplo, char diag, lapack_int n, lapack_int kd, const float *ab, lapack_int ldab)
 
lapack_logical LAPACKE_stf_nancheck (int matrix_order, char transr, char uplo, char diag, lapack_int n, const float *a)
 
lapack_logical LAPACKE_stp_nancheck (int matrix_order, char uplo, char diag, lapack_int n, const float *ap)
 
lapack_logical LAPACKE_str_nancheck (int matrix_order, char uplo, char diag, lapack_int n, const float *a, lapack_int lda)
 
lapack_logical LAPACKE_zgb_nancheck (int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const lapack_complex_double *ab, lapack_int ldab)
 
lapack_logical LAPACKE_zge_nancheck (int matrix_order, lapack_int m, lapack_int n, const lapack_complex_double *a, lapack_int lda)
 
lapack_logical LAPACKE_zgg_nancheck (int matrix_order, lapack_int m, lapack_int n, const lapack_complex_double *a, lapack_int lda)
 
lapack_logical LAPACKE_zgt_nancheck (lapack_int n, const lapack_complex_double *dl, const lapack_complex_double *d, const lapack_complex_double *du)
 
lapack_logical LAPACKE_zhb_nancheck (int matrix_order, char uplo, lapack_int n, lapack_int kd, const lapack_complex_double *ab, lapack_int ldab)
 
lapack_logical LAPACKE_zhe_nancheck (int matrix_order, char uplo, lapack_int n, const lapack_complex_double *a, lapack_int lda)
 
lapack_logical LAPACKE_zhp_nancheck (lapack_int n, const lapack_complex_double *ap)
 
lapack_logical LAPACKE_zhs_nancheck (int matrix_order, lapack_int n, const lapack_complex_double *a, lapack_int lda)
 
lapack_logical LAPACKE_zpb_nancheck (int matrix_order, char uplo, lapack_int n, lapack_int kd, const lapack_complex_double *ab, lapack_int ldab)
 
lapack_logical LAPACKE_zpf_nancheck (lapack_int n, const lapack_complex_double *a)
 
lapack_logical LAPACKE_zpo_nancheck (int matrix_order, char uplo, lapack_int n, const lapack_complex_double *a, lapack_int lda)
 
lapack_logical LAPACKE_zpp_nancheck (lapack_int n, const lapack_complex_double *ap)
 
lapack_logical LAPACKE_zpt_nancheck (lapack_int n, const double *d, const lapack_complex_double *e)
 
lapack_logical LAPACKE_zsp_nancheck (lapack_int n, const lapack_complex_double *ap)
 
lapack_logical LAPACKE_zst_nancheck (lapack_int n, const lapack_complex_double *d, const lapack_complex_double *e)
 
lapack_logical LAPACKE_zsy_nancheck (int matrix_order, char uplo, lapack_int n, const lapack_complex_double *a, lapack_int lda)
 
lapack_logical LAPACKE_ztb_nancheck (int matrix_order, char uplo, char diag, lapack_int n, lapack_int kd, const lapack_complex_double *ab, lapack_int ldab)
 
lapack_logical LAPACKE_ztf_nancheck (int matrix_order, char transr, char uplo, char diag, lapack_int n, const lapack_complex_double *a)
 
lapack_logical LAPACKE_ztp_nancheck (int matrix_order, char uplo, char diag, lapack_int n, const lapack_complex_double *ap)
 
lapack_logical LAPACKE_ztr_nancheck (int matrix_order, char uplo, char diag, lapack_int n, const lapack_complex_double *a, lapack_int lda)
 

Macro Definition Documentation

#define ABS (   x)    (((x) < 0) ? -(x) : (x))

Definition at line 44 of file lapacke_utils.h.

#define IS_C_NONZERO (   x)
Value:
( IS_S_NONZERO(*((float*)&x)) || \
IS_S_NONZERO(*(((float*)&x)+1)) )
#define IS_S_NONZERO(x)
Definition: lapacke_utils.h:59

Definition at line 61 of file lapacke_utils.h.

#define IS_D_NONZERO (   x)    ( (x) < 0 || (x) > 0 )

Definition at line 60 of file lapacke_utils.h.

#define IS_S_NONZERO (   x)    ( (x) < 0 || (x) > 0 )

Definition at line 59 of file lapacke_utils.h.

#define IS_Z_NONZERO (   x)
Value:
( IS_D_NONZERO(*((double*)&x)) || \
IS_D_NONZERO(*(((double*)&x)+1)) )
#define IS_D_NONZERO(x)
Definition: lapacke_utils.h:60

Definition at line 63 of file lapacke_utils.h.

#define LAPACK_CISNAN (   x)
Value:
( LAPACK_SISNAN(*((float*) &x)) || \
LAPACK_SISNAN(*(((float*) &x)+1)) )
#define LAPACK_SISNAN(x)

Definition at line 288 of file lapacke_utils.h.

#define LAPACK_DISNAN (   x)    ( x != x )

Definition at line 287 of file lapacke_utils.h.

#define LAPACK_SISNAN (   x)    ( x != x )

Definition at line 286 of file lapacke_utils.h.

#define LAPACK_ZISNAN (   x)
Value:
( LAPACK_DISNAN(*((double*)&x)) || \
LAPACK_DISNAN(*(((double*)&x)+1)) )
#define LAPACK_DISNAN(x)

Definition at line 290 of file lapacke_utils.h.

#define MAX (   x,
 
)    (((x) > (y)) ? (x) : (y))

Definition at line 47 of file lapacke_utils.h.

#define MAX3 (   x,
  y,
 
)    (((x) > MAX(y,z)) ? (x) : MAX(y,z))

Definition at line 53 of file lapacke_utils.h.

#define MIN (   x,
 
)    (((x) < (y)) ? (x) : (y))

Definition at line 50 of file lapacke_utils.h.

#define MIN3 (   x,
  y,
 
)    (((x) < MIN(y,z)) ? (x) : MIN(y,z))

Definition at line 56 of file lapacke_utils.h.

Function Documentation

lapack_logical LAPACKE_c_nancheck ( lapack_int  n,
const lapack_complex_float x,
lapack_int  incx 
)

Definition at line 37 of file lapacke_c_nancheck.c.

40 {
41  lapack_int i, inc;
42 
43  if( incx == 0 ) return (lapack_logical) LAPACK_CISNAN( x[0] );
44  inc = ( incx > 0 ) ? incx : -incx ;
45 
46  for( i = 0; i < n*inc; i+=inc ) {
47  if( LAPACK_CISNAN( x[i] ) )
48  return (lapack_logical) 1;
49  }
50  return (lapack_logical) 0;
51 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_CISNAN(x)
#define lapack_int
Definition: lapacke.h:47

Here is the caller graph for this function:

lapack_logical LAPACKE_cgb_nancheck ( int  matrix_order,
lapack_int  m,
lapack_int  n,
lapack_int  kl,
lapack_int  ku,
const lapack_complex_float ab,
lapack_int  ldab 
)

Definition at line 37 of file lapacke_cgb_nancheck.c.

42 {
43  lapack_int i, j;
44 
45  if( ab == NULL ) return (lapack_logical) 0;
46 
47  if( matrix_order == LAPACK_COL_MAJOR ) {
48  for( j = 0; j < n; j++ ) {
49  for( i = MAX( ku-j, 0 ); i < MIN3( ldab, m+ku-j, kl+ku+1 );
50  i++ ) {
51  if( LAPACK_CISNAN( ab[i+(size_t)j*ldab] ) )
52  return (lapack_logical) 1;
53  }
54  }
55  } else if ( matrix_order == LAPACK_ROW_MAJOR ) {
56  for( j = 0; j < MIN( n, ldab ); j++ ) {
57  for( i = MAX( ku-j, 0 ); i < MIN( m+ku-j, kl+ku+1 ); i++ ) {
58  if( LAPACK_CISNAN( ab[(size_t)i*ldab+j] ) )
59  return (lapack_logical) 1;
60  }
61  }
62  }
63  return (lapack_logical) 0;
64 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define MIN3(x, y, z)
Definition: lapacke_utils.h:56
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
#define MAX(x, y)
Definition: lapacke_utils.h:47
#define LAPACK_CISNAN(x)
#define MIN(x, y)
Definition: lapacke_utils.h:50
#define lapack_int
Definition: lapacke.h:47

Here is the caller graph for this function:

void LAPACKE_cgb_trans ( int  matrix_order,
lapack_int  m,
lapack_int  n,
lapack_int  kl,
lapack_int  ku,
const lapack_complex_float in,
lapack_int  ldin,
lapack_complex_float out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_cgb_trans.c.

44 {
45  lapack_int i, j;
46 
47  if( in == NULL || out == NULL ) return;
48 
49  if( matrix_order == LAPACK_COL_MAJOR ) {
50  for( j = 0; j < MIN( ldout, n ); j++ ) {
51  for( i = MAX( ku-j, 0 ); i < MIN3( ldin, m+ku-j, kl+ku+1 );
52  i++ ) {
53  out[(size_t)i*ldout+j] = in[i+(size_t)j*ldin];
54  }
55  }
56  } else if ( matrix_order == LAPACK_ROW_MAJOR ) {
57  /* TODO: interchange loops for performance.
58  * This is just reference impemeltation.
59  */
60  for( j = 0; j < MIN( n, ldin ); j++ ) {
61  for( i = MAX( ku-j, 0 ); i < MIN3( ldout, m+ku-j, kl+ku+1 );
62  i++ ) {
63  out[i+(size_t)j*ldout] = in[(size_t)i*ldin+j];
64  }
65  }
66  }
67 }
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define MIN3(x, y, z)
Definition: lapacke_utils.h:56
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
#define MAX(x, y)
Definition: lapacke_utils.h:47
#define MIN(x, y)
Definition: lapacke_utils.h:50
#define lapack_int
Definition: lapacke.h:47

Here is the caller graph for this function:

lapack_logical LAPACKE_cge_nancheck ( int  matrix_order,
lapack_int  m,
lapack_int  n,
const lapack_complex_float a,
lapack_int  lda 
)

Definition at line 37 of file lapacke_cge_nancheck.c.

41 {
42  lapack_int i, j;
43 
44  if( a == NULL ) return (lapack_logical) 0;
45 
46  if( matrix_order == LAPACK_COL_MAJOR ) {
47  for( j = 0; j < n; j++ ) {
48  for( i = 0; i < MIN( m, lda ); i++ ) {
49  if( LAPACK_CISNAN( a[i+(size_t)j*lda] ) )
50  return (lapack_logical) 1;
51  }
52  }
53  } else if ( matrix_order == LAPACK_ROW_MAJOR ) {
54  for( i = 0; i < m; i++ ) {
55  for( j = 0; j < MIN( n, lda ); j++ ) {
56  if( LAPACK_CISNAN( a[(size_t)i*lda+j] ) )
57  return (lapack_logical) 1;
58  }
59  }
60  }
61  return (lapack_logical) 0;
62 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
#define LAPACK_CISNAN(x)
#define MIN(x, y)
Definition: lapacke_utils.h:50
#define lapack_int
Definition: lapacke.h:47
void LAPACKE_cge_trans ( int  matrix_order,
lapack_int  m,
lapack_int  n,
const lapack_complex_float in,
lapack_int  ldin,
lapack_complex_float out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_cge_trans.c.

43 {
44  lapack_int i, j, x, y;
45 
46  if( in == NULL || out == NULL ) return;
47 
48  if( matrix_order == LAPACK_COL_MAJOR ) {
49  x = n;
50  y = m;
51  } else if ( matrix_order == LAPACK_ROW_MAJOR ) {
52  x = m;
53  y = n;
54  } else {
55  /* Unknown input layout */
56  return;
57  }
58 
59  /* In case of incorrect m, n, ldin or ldout the function does nothing */
60  for( i = 0; i < MIN( y, ldin ); i++ ) {
61  for( j = 0; j < MIN( x, ldout ); j++ ) {
62  out[ (size_t)i*ldout + j ] = in[ (size_t)j*ldin + i ];
63  }
64  }
65 }
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
#define MIN(x, y)
Definition: lapacke_utils.h:50
#define lapack_int
Definition: lapacke.h:47
lapack_logical LAPACKE_cgg_nancheck ( int  matrix_order,
lapack_int  m,
lapack_int  n,
const lapack_complex_float a,
lapack_int  lda 
)

Definition at line 37 of file lapacke_cgg_nancheck.c.

41 {
42  return LAPACKE_cge_nancheck( matrix_order, m, n, a, lda );
43 }
lapack_logical LAPACKE_cge_nancheck(int matrix_order, lapack_int m, lapack_int n, const lapack_complex_float *a, lapack_int lda)

Here is the call graph for this function:

void LAPACKE_cgg_trans ( int  matrix_order,
lapack_int  m,
lapack_int  n,
const lapack_complex_float in,
lapack_int  ldin,
lapack_complex_float out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_cgg_trans.c.

43 {
44  LAPACKE_cge_trans( matrix_order, m, n, in, ldin, out, ldout );
45 }
void LAPACKE_cge_trans(int matrix_order, lapack_int m, lapack_int n, const lapack_complex_float *in, lapack_int ldin, lapack_complex_float *out, lapack_int ldout)

Here is the call graph for this function:

lapack_logical LAPACKE_cgt_nancheck ( lapack_int  n,
const lapack_complex_float dl,
const lapack_complex_float d,
const lapack_complex_float du 
)

Definition at line 37 of file lapacke_cgt_nancheck.c.

41 {
42  return LAPACKE_c_nancheck( n-1, dl, 1 )
43  || LAPACKE_c_nancheck( n , d, 1 )
44  || LAPACKE_c_nancheck( n-1, du, 1 );
45 }
lapack_logical LAPACKE_c_nancheck(lapack_int n, const lapack_complex_float *x, lapack_int incx)

Here is the call graph for this function:

lapack_logical LAPACKE_chb_nancheck ( int  matrix_order,
char  uplo,
lapack_int  n,
lapack_int  kd,
const lapack_complex_float ab,
lapack_int  ldab 
)

Definition at line 37 of file lapacke_chb_nancheck.c.

41 {
42  if( LAPACKE_lsame( uplo, 'u' ) ) {
43  return LAPACKE_cgb_nancheck( matrix_order, n, n, 0, kd, ab, ldab );
44  } else if( LAPACKE_lsame( uplo, 'l' ) ) {
45  return LAPACKE_cgb_nancheck( matrix_order, n, n, kd, 0, ab, ldab );
46  }
47  return (lapack_logical) 0;
48 }
#define lapack_logical
Definition: lapacke.h:51
lapack_logical LAPACKE_cgb_nancheck(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const lapack_complex_float *ab, lapack_int ldab)
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_chb_trans ( int  matrix_order,
char  uplo,
lapack_int  n,
lapack_int  kd,
const lapack_complex_float in,
lapack_int  ldin,
lapack_complex_float out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_chb_trans.c.

44 {
45  if( LAPACKE_lsame( uplo, 'u' ) ) {
46  LAPACKE_cgb_trans( matrix_order, n, n, 0, kd, in, ldin, out, ldout );
47  } else if( LAPACKE_lsame( uplo, 'l' ) ) {
48  LAPACKE_cgb_trans( matrix_order, n, n, kd, 0, in, ldin, out, ldout );
49  }
50 }
void LAPACKE_cgb_trans(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const lapack_complex_float *in, lapack_int ldin, lapack_complex_float *out, lapack_int ldout)
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_che_nancheck ( int  matrix_order,
char  uplo,
lapack_int  n,
const lapack_complex_float a,
lapack_int  lda 
)

Definition at line 37 of file lapacke_che_nancheck.c.

41 {
42  return LAPACKE_ctr_nancheck( matrix_order, uplo, 'n', n, a, lda );
43 }
lapack_logical LAPACKE_ctr_nancheck(int matrix_order, char uplo, char diag, lapack_int n, const lapack_complex_float *a, lapack_int lda)

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_che_trans ( int  matrix_order,
char  uplo,
lapack_int  n,
const lapack_complex_float in,
lapack_int  ldin,
lapack_complex_float out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_che_trans.c.

43 {
44  LAPACKE_ctr_trans( matrix_order, uplo, 'n', n, in, ldin, out, ldout );
45 }
void LAPACKE_ctr_trans(int matrix_order, char uplo, char diag, lapack_int n, const lapack_complex_float *in, lapack_int ldin, lapack_complex_float *out, lapack_int ldout)

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_chp_nancheck ( lapack_int  n,
const lapack_complex_float ap 
)

Definition at line 40 of file lapacke_chp_nancheck.c.

42 {
43  lapack_int len = n*(n+1)/2;
44  return LAPACKE_c_nancheck( len, ap, 1 );
45 }
lapack_logical LAPACKE_c_nancheck(lapack_int n, const lapack_complex_float *x, lapack_int incx)
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_chp_trans ( int  matrix_order,
char  uplo,
lapack_int  n,
const lapack_complex_float in,
lapack_complex_float out 
)

Definition at line 40 of file lapacke_chp_trans.c.

43 {
44  LAPACKE_ctp_trans( matrix_order, uplo, 'n', n, in, out );
45 }
void LAPACKE_ctp_trans(int matrix_order, char uplo, char diag, lapack_int n, const lapack_complex_float *in, lapack_complex_float *out)

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_chs_nancheck ( int  matrix_order,
lapack_int  n,
const lapack_complex_float a,
lapack_int  lda 
)

Definition at line 37 of file lapacke_chs_nancheck.c.

40 {
41  lapack_logical subdiag_nans;
42 
43  if( a == NULL ) return (lapack_logical) 0;
44 
45  /* Check subdiagonal first */
46  if( matrix_order == LAPACK_COL_MAJOR ) {
47  subdiag_nans = LAPACKE_c_nancheck( n-1, &a[1], lda+1 );
48  } else if ( matrix_order == LAPACK_ROW_MAJOR ) {
49  subdiag_nans = LAPACKE_c_nancheck( n-1, &a[lda], lda+1 );
50  } else {
51  return (lapack_logical) 0;
52  }
53 
54  /* Check upper triangular if subdiagonal has no NaNs. */
55  return subdiag_nans || LAPACKE_ctr_nancheck( matrix_order, 'u', 'n',
56  n, a, lda);
57 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
lapack_logical LAPACKE_ctr_nancheck(int matrix_order, char uplo, char diag, lapack_int n, const lapack_complex_float *a, lapack_int lda)
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
lapack_logical LAPACKE_c_nancheck(lapack_int n, const lapack_complex_float *x, lapack_int incx)

Here is the call graph for this function:

void LAPACKE_chs_trans ( int  matrix_order,
lapack_int  n,
const lapack_complex_float in,
lapack_int  ldin,
lapack_complex_float out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_chs_trans.c.

43 {
44  if( in == NULL || out == NULL ) return;
45 
46  /* Convert subdiagonal first */
47  if( matrix_order == LAPACK_COL_MAJOR ) {
48  LAPACKE_cge_trans( LAPACK_COL_MAJOR, 1, n-1, &in[1], ldin+1,
49  &out[ldout], ldout+1 );
50  } else if ( matrix_order == LAPACK_ROW_MAJOR ) {
51  LAPACKE_cge_trans( LAPACK_ROW_MAJOR, n-1, 1, &in[ldin], ldin+1,
52  &out[1], ldout+1 );
53  } else {
54  return;
55  }
56 
57  /* Convert upper triangular. */
58  LAPACKE_ctr_trans( matrix_order, 'u', 'n', n, in, ldin, out, ldout);
59 }
void LAPACKE_ctr_trans(int matrix_order, char uplo, char diag, lapack_int n, const lapack_complex_float *in, lapack_int ldin, lapack_complex_float *out, lapack_int ldout)
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
void LAPACKE_cge_trans(int matrix_order, lapack_int m, lapack_int n, const lapack_complex_float *in, lapack_int ldin, lapack_complex_float *out, lapack_int ldout)
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119

Here is the call graph for this function:

lapack_logical LAPACKE_cpb_nancheck ( int  matrix_order,
char  uplo,
lapack_int  n,
lapack_int  kd,
const lapack_complex_float ab,
lapack_int  ldab 
)

Definition at line 37 of file lapacke_cpb_nancheck.c.

41 {
42  if( LAPACKE_lsame( uplo, 'u' ) ) {
43  return LAPACKE_cgb_nancheck( matrix_order, n, n, 0, kd, ab, ldab );
44  } else if( LAPACKE_lsame( uplo, 'l' ) ) {
45  return LAPACKE_cgb_nancheck( matrix_order, n, n, kd, 0, ab, ldab );
46  }
47  return (lapack_logical) 0;
48 }
#define lapack_logical
Definition: lapacke.h:51
lapack_logical LAPACKE_cgb_nancheck(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const lapack_complex_float *ab, lapack_int ldab)
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_cpb_trans ( int  matrix_order,
char  uplo,
lapack_int  n,
lapack_int  kd,
const lapack_complex_float in,
lapack_int  ldin,
lapack_complex_float out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_cpb_trans.c.

44 {
45  if( LAPACKE_lsame( uplo, 'u' ) ) {
46  LAPACKE_cgb_trans( matrix_order, n, n, 0, kd, in, ldin, out, ldout );
47  } else if( LAPACKE_lsame( uplo, 'l' ) ) {
48  LAPACKE_cgb_trans( matrix_order, n, n, kd, 0, in, ldin, out, ldout );
49  }
50 }
void LAPACKE_cgb_trans(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const lapack_complex_float *in, lapack_int ldin, lapack_complex_float *out, lapack_int ldout)
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_cpf_nancheck ( lapack_int  n,
const lapack_complex_float a 
)

Definition at line 41 of file lapacke_cpf_nancheck.c.

43 {
44  lapack_int len = n*(n+1)/2;
45  return LAPACKE_c_nancheck( len, a, 1 );
46 }
lapack_logical LAPACKE_c_nancheck(lapack_int n, const lapack_complex_float *x, lapack_int incx)
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_cpf_trans ( int  matrix_order,
char  transr,
char  uplo,
lapack_int  n,
const lapack_complex_float in,
lapack_complex_float out 
)

Definition at line 40 of file lapacke_cpf_trans.c.

43 {
44  LAPACKE_ctf_trans( matrix_order, transr, uplo, 'n', n, in, out );
45 }
void LAPACKE_ctf_trans(int matrix_order, char transr, char uplo, char diag, lapack_int n, const lapack_complex_float *in, lapack_complex_float *out)

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_cpo_nancheck ( int  matrix_order,
char  uplo,
lapack_int  n,
const lapack_complex_float a,
lapack_int  lda 
)

Definition at line 37 of file lapacke_cpo_nancheck.c.

41 {
42  return LAPACKE_ctr_nancheck( matrix_order, uplo, 'n', n, a, lda );
43 }
lapack_logical LAPACKE_ctr_nancheck(int matrix_order, char uplo, char diag, lapack_int n, const lapack_complex_float *a, lapack_int lda)

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_cpo_trans ( int  matrix_order,
char  uplo,
lapack_int  n,
const lapack_complex_float in,
lapack_int  ldin,
lapack_complex_float out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_cpo_trans.c.

43 {
44  LAPACKE_ctr_trans( matrix_order, uplo, 'n', n, in, ldin, out, ldout );
45 }
void LAPACKE_ctr_trans(int matrix_order, char uplo, char diag, lapack_int n, const lapack_complex_float *in, lapack_int ldin, lapack_complex_float *out, lapack_int ldout)

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_cpp_nancheck ( lapack_int  n,
const lapack_complex_float ap 
)

Definition at line 40 of file lapacke_cpp_nancheck.c.

42 {
43  lapack_int len = n*(n+1)/2;
44  return LAPACKE_c_nancheck( len, ap, 1 );
45 }
lapack_logical LAPACKE_c_nancheck(lapack_int n, const lapack_complex_float *x, lapack_int incx)
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_cpp_trans ( int  matrix_order,
char  uplo,
lapack_int  n,
const lapack_complex_float in,
lapack_complex_float out 
)

Definition at line 40 of file lapacke_cpp_trans.c.

43 {
44  LAPACKE_ctp_trans( matrix_order, uplo, 'n', n, in, out );
45 }
void LAPACKE_ctp_trans(int matrix_order, char uplo, char diag, lapack_int n, const lapack_complex_float *in, lapack_complex_float *out)

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_cpt_nancheck ( lapack_int  n,
const float *  d,
const lapack_complex_float e 
)

Definition at line 37 of file lapacke_cpt_nancheck.c.

40 {
41  return LAPACKE_s_nancheck( n, d, 1 )
42  || LAPACKE_c_nancheck( n-1, e, 1 );
43 }
lapack_logical LAPACKE_s_nancheck(lapack_int n, const float *x, lapack_int incx)
lapack_logical LAPACKE_c_nancheck(lapack_int n, const lapack_complex_float *x, lapack_int incx)

Here is the call graph for this function:

lapack_logical LAPACKE_csp_nancheck ( lapack_int  n,
const lapack_complex_float ap 
)

Definition at line 40 of file lapacke_csp_nancheck.c.

42 {
43  lapack_int len = n*(n+1)/2;
44  return LAPACKE_c_nancheck( len, ap, 1 );
45 }
lapack_logical LAPACKE_c_nancheck(lapack_int n, const lapack_complex_float *x, lapack_int incx)
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_csp_trans ( int  matrix_order,
char  uplo,
lapack_int  n,
const lapack_complex_float in,
lapack_complex_float out 
)

Definition at line 40 of file lapacke_csp_trans.c.

43 {
44  LAPACKE_ctp_trans( matrix_order, uplo, 'n', n, in, out );
45 }
void LAPACKE_ctp_trans(int matrix_order, char uplo, char diag, lapack_int n, const lapack_complex_float *in, lapack_complex_float *out)

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_cst_nancheck ( lapack_int  n,
const lapack_complex_float d,
const lapack_complex_float e 
)

Definition at line 37 of file lapacke_cst_nancheck.c.

40 {
41  return LAPACKE_c_nancheck( n, d, 1 )
42  || LAPACKE_c_nancheck( n-1, e, 1 );
43 }
lapack_logical LAPACKE_c_nancheck(lapack_int n, const lapack_complex_float *x, lapack_int incx)

Here is the call graph for this function:

lapack_logical LAPACKE_csy_nancheck ( int  matrix_order,
char  uplo,
lapack_int  n,
const lapack_complex_float a,
lapack_int  lda 
)

Definition at line 37 of file lapacke_csy_nancheck.c.

41 {
42  return LAPACKE_ctr_nancheck( matrix_order, uplo, 'n', n, a, lda );
43 }
lapack_logical LAPACKE_ctr_nancheck(int matrix_order, char uplo, char diag, lapack_int n, const lapack_complex_float *a, lapack_int lda)

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_csy_trans ( int  matrix_order,
char  uplo,
lapack_int  n,
const lapack_complex_float in,
lapack_int  ldin,
lapack_complex_float out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_csy_trans.c.

43 {
44  LAPACKE_ctr_trans( matrix_order, uplo, 'n', n, in, ldin, out, ldout );
45 }
void LAPACKE_ctr_trans(int matrix_order, char uplo, char diag, lapack_int n, const lapack_complex_float *in, lapack_int ldin, lapack_complex_float *out, lapack_int ldout)

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_ctb_nancheck ( int  matrix_order,
char  uplo,
char  diag,
lapack_int  n,
lapack_int  kd,
const lapack_complex_float ab,
lapack_int  ldab 
)

Definition at line 37 of file lapacke_ctb_nancheck.c.

41 {
42  lapack_logical colmaj, upper, unit;
43 
44  if( ab == NULL ) return (lapack_logical) 0;
45 
46  colmaj = ( matrix_order == LAPACK_COL_MAJOR );
47  upper = LAPACKE_lsame( uplo, 'u' );
48  unit = LAPACKE_lsame( diag, 'u' );
49 
50  if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
51  ( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
52  ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
53  /* Just exit if any of input parameters are wrong */
54  return (lapack_logical) 0;
55  }
56 
57  if( unit ) {
58  /* Unit case, diagonal should be excluded from the check for NaN. */
59  if( colmaj ) {
60  if( upper ) {
61  return LAPACKE_cgb_nancheck( matrix_order, n-1, n-1, 0, kd-1,
62  &ab[ldab], ldab );
63  } else {
64  return LAPACKE_cgb_nancheck( matrix_order, n-1, n-1, kd-1, 0,
65  &ab[1], ldab );
66  }
67  } else {
68  if( upper ) {
69  return LAPACKE_cgb_nancheck( matrix_order, n-1, n-1, 0, kd-1,
70  &ab[1], ldab );
71  } else {
72  return LAPACKE_cgb_nancheck( matrix_order, n-1, n-1, kd-1, 0,
73  &ab[ldab], ldab );
74  }
75  }
76  } else {
77  /* Non-unit case */
78  if( upper ) {
79  return LAPACKE_cgb_nancheck( matrix_order, n, n, 0, kd, ab, ldab );
80  } else {
81  return LAPACKE_cgb_nancheck( matrix_order, n, n, kd, 0, ab, ldab );
82  }
83  }
84 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
lapack_logical LAPACKE_cgb_nancheck(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const lapack_complex_float *ab, lapack_int ldab)
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_ctb_trans ( int  matrix_order,
char  uplo,
char  diag,
lapack_int  n,
lapack_int  kd,
const lapack_complex_float in,
lapack_int  ldin,
lapack_complex_float out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_ctb_trans.c.

44 {
45  lapack_logical colmaj, upper, unit;
46 
47  if( in == NULL || out == NULL ) return;
48 
49  colmaj = ( matrix_order == LAPACK_COL_MAJOR );
50  upper = LAPACKE_lsame( uplo, 'u' );
51  unit = LAPACKE_lsame( diag, 'u' );
52 
53  if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
54  ( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
55  ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
56  /* Just exit if any of input parameters are wrong */
57  return;
58  }
59 
60  if( unit ) {
61  /* Unit case, diagonal excluded from transposition */
62  if( colmaj ) {
63  if( upper ) {
64  LAPACKE_cgb_trans( matrix_order, n-1, n-1, 0, kd-1,
65  &in[ldin], ldin, &out[1], ldout );
66  } else {
67  LAPACKE_cgb_trans( matrix_order, n-1, n-1, kd-1, 0,
68  &in[1], ldin, &out[ldout], ldout );
69  }
70  } else {
71  if( upper ) {
72  LAPACKE_cgb_trans( matrix_order, n-1, n-1, 0, kd-1,
73  &in[1], ldin, &out[ldout], ldout );
74  } else {
75  LAPACKE_cgb_trans( matrix_order, n-1, n-1, kd-1, 0,
76  &in[ldin], ldin, &out[1], ldout );
77  }
78  }
79  } else {
80  /* Non-unit case */
81  if( upper ) {
82  LAPACKE_cgb_trans( matrix_order, n, n, 0, kd, in, ldin, out,
83  ldout );
84  } else {
85  LAPACKE_cgb_trans( matrix_order, n, n, kd, 0, in, ldin, out,
86  ldout );
87  }
88  }
89 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
void LAPACKE_cgb_trans(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const lapack_complex_float *in, lapack_int ldin, lapack_complex_float *out, lapack_int ldout)
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_ctf_nancheck ( int  matrix_order,
char  transr,
char  uplo,
char  diag,
lapack_int  n,
const lapack_complex_float a 
)

Definition at line 37 of file lapacke_ctf_nancheck.c.

41 {
42  lapack_int len;
43  lapack_logical rowmaj, ntr, lower, unit;
44  lapack_int n1, n2, k;
45 
46  if( a == NULL ) return (lapack_logical) 0;
47 
48  rowmaj = (matrix_order == LAPACK_ROW_MAJOR);
49  ntr = LAPACKE_lsame( transr, 'n' );
50  lower = LAPACKE_lsame( uplo, 'l' );
51  unit = LAPACKE_lsame( diag, 'u' );
52 
53  if( ( !rowmaj && ( matrix_order != LAPACK_COL_MAJOR ) ) ||
54  ( !ntr && !LAPACKE_lsame( transr, 't' )
55  && !LAPACKE_lsame( transr, 'c' ) ) ||
56  ( !lower && !LAPACKE_lsame( uplo, 'u' ) ) ||
57  ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
58  /* Just exit if any of input parameters are wrong */
59  return (lapack_logical) 0;
60  }
61 
62  if( unit ) {
63  /* Unit case, diagonal should be excluded from the check for NaN.
64  * Decoding RFP and checking both triangulars and rectangular
65  * for NaNs.
66  */
67  if( lower ) {
68  n2 = n / 2;
69  n1 = n - n2;
70  } else {
71  n1 = n / 2;
72  n2 = n - n1;
73  }
74  if( n % 2 == 1 ) {
75  /* N is odd */
76  if( ( rowmaj || ntr ) && !( rowmaj && ntr ) ) {
77  /* N is odd and ( TRANSR = 'N' .XOR. ROWMAJOR) */
78  if( lower ) {
79  return LAPACKE_ctr_nancheck( LAPACK_ROW_MAJOR, 'l', 'u',
80  n1, &a[0], n )
82  &a[n1], n )
84  n2, &a[n], n );
85  } else {
86  return LAPACKE_ctr_nancheck( LAPACK_ROW_MAJOR, 'l', 'u',
87  n1, &a[n2], n )
89  &a[0], n )
91  n2, &a[n1], n );
92  }
93  } else {
94  /* N is odd and
95  ( ( TRANSR = 'C' || TRANSR = 'T' ) .XOR. COLMAJOR ) */
96  if( lower ) {
97  return LAPACKE_ctr_nancheck( LAPACK_ROW_MAJOR, 'u', 'u',
98  n1, &a[0], n1 )
100  &a[1], n1 )
102  n2, &a[1], n1 );
103  } else {
104  return LAPACKE_ctr_nancheck( LAPACK_ROW_MAJOR, 'u', 'u',
105  n1, &a[(size_t)n2*n2], n2 )
107  &a[0], n2 )
109  n2, &a[(size_t)n1*n2], n2 );
110  }
111  }
112  } else {
113  /* N is even */
114  k = n / 2;
115  if( ( rowmaj || ntr ) && !( rowmaj && ntr ) ) {
116  /* N is even and ( TRANSR = 'N' .XOR. ROWMAJOR) */
117  if( lower ) {
118  return LAPACKE_ctr_nancheck( LAPACK_ROW_MAJOR, 'l', 'u',
119  k, &a[1], n+1 )
121  &a[k+1], n+1 )
123  k, &a[0], n+1 );
124  } else {
125  return LAPACKE_ctr_nancheck( LAPACK_ROW_MAJOR, 'l', 'u',
126  k, &a[k+1], n+1 )
128  &a[0], n+1 )
130  k, &a[k], n+1 );
131  }
132  } else {
133  /* N is even and
134  ( ( TRANSR = 'C' || TRANSR = 'T' ) .XOR. COLMAJOR ) */
135  if( lower ) {
136  return LAPACKE_ctr_nancheck( LAPACK_ROW_MAJOR, 'u', 'u',
137  k, &a[k], k )
139  &a[(size_t)k*(k+1)], k )
141  k, &a[0], k );
142  } else {
143  return LAPACKE_ctr_nancheck( LAPACK_ROW_MAJOR, 'u', 'u',
144  k, &a[(size_t)k*(k+1)], k )
146  &a[0], k )
148  k, &a[(size_t)k*k], k );
149  }
150  }
151  }
152  } else {
153  /* Non-unit case - just check whole array for NaNs. */
154  len = n*(n+1)/2;
155  return LAPACKE_cge_nancheck( LAPACK_COL_MAJOR, len, 1, a, len );
156  }
157 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
lapack_logical LAPACKE_ctr_nancheck(int matrix_order, char uplo, char diag, lapack_int n, const lapack_complex_float *a, lapack_int lda)
lapack_logical LAPACKE_cge_nancheck(int matrix_order, lapack_int m, lapack_int n, const lapack_complex_float *a, lapack_int lda)
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_ctf_trans ( int  matrix_order,
char  transr,
char  uplo,
char  diag,
lapack_int  n,
const lapack_complex_float in,
lapack_complex_float out 
)

Definition at line 41 of file lapacke_ctf_trans.c.

44 {
45  lapack_int row, col;
46  lapack_logical rowmaj, ntr, lower, unit;
47 
48  if( in == NULL || out == NULL ) return ;
49 
50  rowmaj = (matrix_order == LAPACK_ROW_MAJOR);
51  ntr = LAPACKE_lsame( transr, 'n' );
52  lower = LAPACKE_lsame( uplo, 'l' );
53  unit = LAPACKE_lsame( diag, 'u' );
54 
55  if( ( !rowmaj && ( matrix_order != LAPACK_COL_MAJOR ) ) ||
56  ( !ntr && !LAPACKE_lsame( transr, 't' ) &&
57  !LAPACKE_lsame( transr, 'c' ) ) ||
58  ( !lower && !LAPACKE_lsame( uplo, 'u' ) ) ||
59  ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
60  /* Just exit if input parameters are wrong */
61  return;
62  }
63 
64  /* Determine parameters of array representing RFP */
65  if( ntr ) {
66  if( n%2 == 0 ) {
67  row = n + 1;
68  col = n / 2;
69  } else {
70  row = n;
71  col = (n + 1) / 2;
72  }
73  } else {
74  if( n%2 == 0 ) {
75  row = n / 2;
76  col = n + 1;
77  } else {
78  row = (n + 1) / 2;
79  col = n;
80  }
81  }
82 
83  /* Perform conversion: */
84  if( rowmaj ) {
85  LAPACKE_cge_trans( LAPACK_ROW_MAJOR, row, col, in, col, out, row );
86  } else {
87  LAPACKE_cge_trans( LAPACK_COL_MAJOR, row, col, in, row, out, col );
88  }
89 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
void LAPACKE_cge_trans(int matrix_order, lapack_int m, lapack_int n, const lapack_complex_float *in, lapack_int ldin, lapack_complex_float *out, lapack_int ldout)
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_ctp_nancheck ( int  matrix_order,
char  uplo,
char  diag,
lapack_int  n,
const lapack_complex_float ap 
)

Definition at line 40 of file lapacke_ctp_nancheck.c.

43 {
44  lapack_int i, len;
45  lapack_logical colmaj, upper, unit;
46 
47  if( ap == NULL ) return (lapack_logical) 0;
48 
49  colmaj = ( matrix_order == LAPACK_COL_MAJOR );
50  upper = LAPACKE_lsame( uplo, 'u' );
51  unit = LAPACKE_lsame( diag, 'u' );
52 
53  if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
54  ( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
55  ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
56  /* Just exit if any of input parameters are wrong */
57  return (lapack_logical) 0;
58  }
59 
60  if( unit ) {
61  /* Unit case, diagonal should be excluded from the check for NaN. */
62 
63  /* Since col_major upper and row_major lower are equal,
64  * and col_major lower and row_major upper are equals too -
65  * using one code for equal cases. XOR( colmaj, upper )
66  */
67  if( ( colmaj || upper ) && !( colmaj && upper ) ) {
68  for( i = 1; i < n; i++ )
69  if( LAPACKE_c_nancheck( i, &ap[ ((size_t)i+1)*i/2 ], 1 ) )
70  return (lapack_logical) 1;
71  } else {
72  for( i = 0; i < n-1; i++ )
73  if( LAPACKE_c_nancheck( n-i-1,
74  &ap[ (size_t)i+1 + i*((size_t)2*n-i+1)/2 ], 1 ) )
75  return (lapack_logical) 1;
76  }
77  return (lapack_logical) 0;
78  } else {
79  /* Non-unit case - just check whole array for NaNs. */
80  len = n*(n+1)/2;
81  return LAPACKE_c_nancheck( len, ap, 1 );
82  }
83 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
lapack_logical LAPACKE_c_nancheck(lapack_int n, const lapack_complex_float *x, lapack_int incx)
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_ctp_trans ( int  matrix_order,
char  uplo,
char  diag,
lapack_int  n,
const lapack_complex_float in,
lapack_complex_float out 
)

Definition at line 40 of file lapacke_ctp_trans.c.

43 {
44  lapack_int i, j, st;
45  lapack_logical colmaj, upper, unit;
46 
47  if( in == NULL || out == NULL ) return ;
48 
49  colmaj = ( matrix_order == LAPACK_COL_MAJOR );
50  upper = LAPACKE_lsame( uplo, 'u' );
51  unit = LAPACKE_lsame( diag, 'u' );
52 
53  if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
54  ( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
55  ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
56  /* Just exit if any of input parameters are wrong */
57  return;
58  }
59  if( unit ) {
60  /* If unit, then don't touch diagonal, start from 1st column or row */
61  st = 1;
62  } else {
63  /* If non-unit, then check diagonal also, starting from [0,0] */
64  st = 0;
65  }
66 
67  /* Perform conversion:
68  * Since col_major upper and row_major lower are equal,
69  * and col_major lower and row_major upper are equals too -
70  * using one code for equal cases. XOR( colmaj, upper )
71  */
72  if( ( colmaj || upper ) && !( colmaj && upper ) ) {
73  for( j = st; j < n; j++ ) {
74  for( i = 0; i < j+1-st; i++ ) {
75  out[ j-i + (i*(2*n-i+1))/2 ] = in[ ((j+1)*j)/2 + i ];
76  }
77  }
78  } else {
79  for( j = 0; j < n-st; j++ ) {
80  for( i = j+st; i < n; i++ ) {
81  out[ j + ((i+1)*i)/2 ] = in[ (j*(2*n-j+1))/2 + i-j ];
82  }
83  }
84  }
85 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_ctr_nancheck ( int  matrix_order,
char  uplo,
char  diag,
lapack_int  n,
const lapack_complex_float a,
lapack_int  lda 
)

Definition at line 37 of file lapacke_ctr_nancheck.c.

41 {
42  lapack_int i, j, st;
43  lapack_logical colmaj, lower, unit;
44 
45  if( a == NULL ) return (lapack_logical) 0;
46 
47  colmaj = ( matrix_order == LAPACK_COL_MAJOR );
48  lower = LAPACKE_lsame( uplo, 'l' );
49  unit = LAPACKE_lsame( diag, 'u' );
50 
51  if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
52  ( !lower && !LAPACKE_lsame( uplo, 'u' ) ) ||
53  ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
54  /* Just exit if any of input parameters are wrong */
55  return (lapack_logical) 0;
56  }
57  if( unit ) {
58  /* If unit, then don't touch diagonal, start from 1st column or row */
59  st = 1;
60  } else {
61  /* If non-unit, then check diagonal also, starting from [0,0] */
62  st = 0;
63  }
64 
65  /* Since col_major upper and row_major lower are equal,
66  * and col_major lower and row_major upper are equals too -
67  * using one code for equal cases. XOR( colmaj, upper )
68  */
69  if( ( colmaj || lower ) && !( colmaj && lower ) ) {
70  for( j = st; j < n; j++ ) {
71  for( i = 0; i < MIN( j+1-st, lda ); i++ ) {
72  if( LAPACK_CISNAN( a[i+j*lda] ) )
73  return (lapack_logical) 1;
74  }
75  }
76  } else {
77  for( j = 0; j < n-st; j++ ) {
78  for( i = j+st; i < MIN( n, lda ); i++ ) {
79  if( LAPACK_CISNAN( a[i+j*lda] ) )
80  return (lapack_logical) 1;
81  }
82  }
83  }
84  return (lapack_logical) 0;
85 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
#define LAPACK_CISNAN(x)
#define MIN(x, y)
Definition: lapacke_utils.h:50
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_ctr_trans ( int  matrix_order,
char  uplo,
char  diag,
lapack_int  n,
const lapack_complex_float in,
lapack_int  ldin,
lapack_complex_float out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_ctr_trans.c.

43 {
44  lapack_int i, j, st;
45  lapack_logical colmaj, lower, unit;
46 
47  if( in == NULL || out == NULL ) return ;
48 
49  colmaj = ( matrix_order == LAPACK_COL_MAJOR );
50  lower = LAPACKE_lsame( uplo, 'l' );
51  unit = LAPACKE_lsame( diag, 'u' );
52 
53  if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
54  ( !lower && !LAPACKE_lsame( uplo, 'u' ) ) ||
55  ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
56  /* Just exit if any of input parameters are wrong */
57  return;
58  }
59  if( unit ) {
60  /* If unit, then don't touch diagonal, start from 1st column or row */
61  st = 1;
62  } else {
63  /* If non-unit, then check diagonal also, starting from [0,0] */
64  st = 0;
65  }
66 
67  /* Perform conversion:
68  * Since col_major upper and row_major lower are equal,
69  * and col_major lower and row_major upper are equals too -
70  * using one code for equal cases. XOR( colmaj, upper )
71  */
72  if( ( colmaj || lower ) && !( colmaj && lower ) ) {
73  for( j = st; j < MIN( n, ldout ); j++ ) {
74  for( i = 0; i < MIN( j+1-st, ldin ); i++ ) {
75  out[ j+i*ldout ] = in[ i+j*ldin ];
76  }
77  }
78  } else {
79  for( j = 0; j < MIN( n-st, ldout ); j++ ) {
80  for( i = j+st; i < MIN( n, ldin ); i++ ) {
81  out[ j+i*ldout ] = in[ i+j*ldin ];
82  }
83  }
84  }
85 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
#define MIN(x, y)
Definition: lapacke_utils.h:50
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_d_nancheck ( lapack_int  n,
const double *  x,
lapack_int  incx 
)

Definition at line 37 of file lapacke_d_nancheck.c.

40 {
41  lapack_int i, inc;
42 
43  if( incx == 0 ) return (lapack_logical) LAPACK_DISNAN( x[0] );
44  inc = ( incx > 0 ) ? incx : -incx ;
45 
46  for( i = 0; i < n*inc; i+=inc ) {
47  if( LAPACK_DISNAN( x[i] ) )
48  return (lapack_logical) 1;
49  }
50  return (lapack_logical) 0;
51 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_DISNAN(x)
#define lapack_int
Definition: lapacke.h:47
lapack_logical LAPACKE_dgb_nancheck ( int  matrix_order,
lapack_int  m,
lapack_int  n,
lapack_int  kl,
lapack_int  ku,
const double *  ab,
lapack_int  ldab 
)

Definition at line 37 of file lapacke_dgb_nancheck.c.

42 {
43  lapack_int i, j;
44 
45  if( ab == NULL ) return (lapack_logical) 0;
46 
47  if( matrix_order == LAPACK_COL_MAJOR ) {
48  for( j = 0; j < n; j++ ) {
49  for( i = MAX( ku-j, 0 ); i < MIN3( ldab, m+ku-j, kl+ku+1 );
50  i++ ) {
51  if( LAPACK_DISNAN( ab[i+(size_t)j*ldab] ) )
52  return (lapack_logical) 1;
53  }
54  }
55  } else if ( matrix_order == LAPACK_ROW_MAJOR ) {
56  for( j = 0; j < MIN( n, ldab ); j++ ) {
57  for( i = MAX( ku-j, 0 ); i < MIN( m+ku-j, kl+ku+1 ); i++ ) {
58  if( LAPACK_DISNAN( ab[(size_t)i*ldab+j] ) )
59  return (lapack_logical) 1;
60  }
61  }
62  }
63  return (lapack_logical) 0;
64 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define MIN3(x, y, z)
Definition: lapacke_utils.h:56
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
#define MAX(x, y)
Definition: lapacke_utils.h:47
#define LAPACK_DISNAN(x)
#define MIN(x, y)
Definition: lapacke_utils.h:50
#define lapack_int
Definition: lapacke.h:47

Here is the caller graph for this function:

void LAPACKE_dgb_trans ( int  matrix_order,
lapack_int  m,
lapack_int  n,
lapack_int  kl,
lapack_int  ku,
const double *  in,
lapack_int  ldin,
double *  out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_dgb_trans.c.

44 {
45  lapack_int i, j;
46 
47  if( in == NULL || out == NULL ) return;
48 
49  if( matrix_order == LAPACK_COL_MAJOR ) {
50  for( j = 0; j < MIN( ldout, n ); j++ ) {
51  for( i = MAX( ku-j, 0 ); i < MIN3( ldin, m+ku-j, kl+ku+1 );
52  i++ ) {
53  out[(size_t)i*ldout+j] = in[i+(size_t)j*ldin];
54  }
55  }
56  } else if ( matrix_order == LAPACK_ROW_MAJOR ) {
57  /* TODO: interchange loops for performance.
58  * This is just reference impemeltation.
59  */
60  for( j = 0; j < MIN( n, ldin ); j++ ) {
61  for( i = MAX( ku-j, 0 ); i < MIN3( ldout, m+ku-j, kl+ku+1 );
62  i++ ) {
63  out[i+(size_t)j*ldout] = in[(size_t)i*ldin+j];
64  }
65  }
66  }
67 }
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define MIN3(x, y, z)
Definition: lapacke_utils.h:56
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
#define MAX(x, y)
Definition: lapacke_utils.h:47
#define MIN(x, y)
Definition: lapacke_utils.h:50
#define lapack_int
Definition: lapacke.h:47

Here is the caller graph for this function:

lapack_logical LAPACKE_dge_nancheck ( int  matrix_order,
lapack_int  m,
lapack_int  n,
const double *  a,
lapack_int  lda 
)

Definition at line 37 of file lapacke_dge_nancheck.c.

41 {
42  lapack_int i, j;
43 
44  if( a == NULL ) return (lapack_logical) 0;
45 
46  if( matrix_order == LAPACK_COL_MAJOR ) {
47  for( j = 0; j < n; j++ ) {
48  for( i = 0; i < MIN( m, lda ); i++ ) {
49  if( LAPACK_DISNAN( a[i+(size_t)j*lda] ) )
50  return (lapack_logical) 1;
51  }
52  }
53  } else if ( matrix_order == LAPACK_ROW_MAJOR ) {
54  for( i = 0; i < m; i++ ) {
55  for( j = 0; j < MIN( n, lda ); j++ ) {
56  if( LAPACK_DISNAN( a[(size_t)i*lda+j] ) )
57  return (lapack_logical) 1;
58  }
59  }
60  }
61  return (lapack_logical) 0;
62 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
#define LAPACK_DISNAN(x)
#define MIN(x, y)
Definition: lapacke_utils.h:50
#define lapack_int
Definition: lapacke.h:47
void LAPACKE_dge_trans ( int  matrix_order,
lapack_int  m,
lapack_int  n,
const double *  in,
lapack_int  ldin,
double *  out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_dge_trans.c.

43 {
44  lapack_int i, j, x, y;
45 
46  if( in == NULL || out == NULL ) return;
47 
48  if( matrix_order == LAPACK_COL_MAJOR ) {
49  x = n;
50  y = m;
51  } else if ( matrix_order == LAPACK_ROW_MAJOR ) {
52  x = m;
53  y = n;
54  } else {
55  /* Unknown input layout */
56  return;
57  }
58 
59  /* In case of incorrect m, n, ldin or ldout the function does nothing */
60  for( i = 0; i < MIN( y, ldin ); i++ ) {
61  for( j = 0; j < MIN( x, ldout ); j++ ) {
62  out[ (size_t)i*ldout + j ] = in[ (size_t)j*ldin + i ];
63  }
64  }
65 }
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
#define MIN(x, y)
Definition: lapacke_utils.h:50
#define lapack_int
Definition: lapacke.h:47
lapack_logical LAPACKE_dgg_nancheck ( int  matrix_order,
lapack_int  m,
lapack_int  n,
const double *  a,
lapack_int  lda 
)

Definition at line 37 of file lapacke_dgg_nancheck.c.

41 {
42  return LAPACKE_dge_nancheck( matrix_order, m, n, a, lda );
43 }
lapack_logical LAPACKE_dge_nancheck(int matrix_order, lapack_int m, lapack_int n, const double *a, lapack_int lda)

Here is the call graph for this function:

void LAPACKE_dgg_trans ( int  matrix_order,
lapack_int  m,
lapack_int  n,
const double *  in,
lapack_int  ldin,
double *  out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_dgg_trans.c.

43 {
44  LAPACKE_dge_trans( matrix_order, m, n, in, ldin, out, ldout );
45 }
void LAPACKE_dge_trans(int matrix_order, lapack_int m, lapack_int n, const double *in, lapack_int ldin, double *out, lapack_int ldout)

Here is the call graph for this function:

lapack_logical LAPACKE_dgt_nancheck ( lapack_int  n,
const double *  dl,
const double *  d,
const double *  du 
)

Definition at line 37 of file lapacke_dgt_nancheck.c.

41 {
42  return LAPACKE_d_nancheck( n-1, dl, 1 )
43  || LAPACKE_d_nancheck( n , d, 1 )
44  || LAPACKE_d_nancheck( n-1, du, 1 );
45 }
lapack_logical LAPACKE_d_nancheck(lapack_int n, const double *x, lapack_int incx)

Here is the call graph for this function:

lapack_logical LAPACKE_dhs_nancheck ( int  matrix_order,
lapack_int  n,
const double *  a,
lapack_int  lda 
)

Definition at line 37 of file lapacke_dhs_nancheck.c.

40 {
41  lapack_logical subdiag_nans;
42 
43  if( a == NULL ) return (lapack_logical) 0;
44 
45  /* Check subdiagonal first */
46  if( matrix_order == LAPACK_COL_MAJOR ) {
47  subdiag_nans = LAPACKE_d_nancheck( n-1, &a[1], lda+1 );
48  } else if ( matrix_order == LAPACK_ROW_MAJOR ) {
49  subdiag_nans = LAPACKE_d_nancheck( n-1, &a[lda], lda+1 );
50  } else {
51  return (lapack_logical) 0;
52  }
53 
54  /* Check upper triangular if subdiagonal has no NaNs. */
55  return subdiag_nans || LAPACKE_dtr_nancheck( matrix_order, 'u', 'n',
56  n, a, lda);
57 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
lapack_logical LAPACKE_dtr_nancheck(int matrix_order, char uplo, char diag, lapack_int n, const double *a, lapack_int lda)
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
lapack_logical LAPACKE_d_nancheck(lapack_int n, const double *x, lapack_int incx)

Here is the call graph for this function:

void LAPACKE_dhs_trans ( int  matrix_order,
lapack_int  n,
const double *  in,
lapack_int  ldin,
double *  out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_dhs_trans.c.

43 {
44  if( in == NULL || out == NULL ) return;
45 
46  /* Convert subdiagonal first */
47  if( matrix_order == LAPACK_COL_MAJOR ) {
48  LAPACKE_dge_trans( LAPACK_COL_MAJOR, 1, n-1, &in[1], ldin+1,
49  &out[ldout], ldout+1 );
50  } else if ( matrix_order == LAPACK_ROW_MAJOR ) {
51  LAPACKE_dge_trans( LAPACK_ROW_MAJOR, n-1, 1, &in[ldin], ldin+1,
52  &out[1], ldout+1 );
53  } else {
54  return;
55  }
56 
57  /* Convert upper triangular. */
58  LAPACKE_dtr_trans( matrix_order, 'u', 'n', n, in, ldin, out, ldout);
59 }
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
void LAPACKE_dtr_trans(int matrix_order, char uplo, char diag, lapack_int n, const double *in, lapack_int ldin, double *out, lapack_int ldout)
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
void LAPACKE_dge_trans(int matrix_order, lapack_int m, lapack_int n, const double *in, lapack_int ldin, double *out, lapack_int ldout)

Here is the call graph for this function:

lapack_logical LAPACKE_dpb_nancheck ( int  matrix_order,
char  uplo,
lapack_int  n,
lapack_int  kd,
const double *  ab,
lapack_int  ldab 
)

Definition at line 37 of file lapacke_dpb_nancheck.c.

41 {
42  if( LAPACKE_lsame( uplo, 'u' ) ) {
43  return LAPACKE_dgb_nancheck( matrix_order, n, n, 0, kd, ab, ldab );
44  } else if( LAPACKE_lsame( uplo, 'l' ) ) {
45  return LAPACKE_dgb_nancheck( matrix_order, n, n, kd, 0, ab, ldab );
46  }
47  return (lapack_logical) 0;
48 }
#define lapack_logical
Definition: lapacke.h:51
lapack_logical LAPACKE_dgb_nancheck(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const double *ab, lapack_int ldab)
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_dpb_trans ( int  matrix_order,
char  uplo,
lapack_int  n,
lapack_int  kd,
const double *  in,
lapack_int  ldin,
double *  out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_dpb_trans.c.

44 {
45  if( LAPACKE_lsame( uplo, 'u' ) ) {
46  LAPACKE_dgb_trans( matrix_order, n, n, 0, kd, in, ldin, out, ldout );
47  } else if( LAPACKE_lsame( uplo, 'l' ) ) {
48  LAPACKE_dgb_trans( matrix_order, n, n, kd, 0, in, ldin, out, ldout );
49  }
50 }
void LAPACKE_dgb_trans(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const double *in, lapack_int ldin, double *out, lapack_int ldout)
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_dpf_nancheck ( lapack_int  n,
const double *  a 
)

Definition at line 41 of file lapacke_dpf_nancheck.c.

43 {
44  lapack_int len = n*(n+1)/2;
45  return LAPACKE_d_nancheck( len, a, 1 );
46 }
lapack_logical LAPACKE_d_nancheck(lapack_int n, const double *x, lapack_int incx)
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_dpf_trans ( int  matrix_order,
char  transr,
char  uplo,
lapack_int  n,
const double *  in,
double *  out 
)

Definition at line 40 of file lapacke_dpf_trans.c.

43 {
44  LAPACKE_dtf_trans( matrix_order, transr, uplo, 'n', n, in, out );
45 }
void LAPACKE_dtf_trans(int matrix_order, char transr, char uplo, char diag, lapack_int n, const double *in, double *out)

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_dpo_nancheck ( int  matrix_order,
char  uplo,
lapack_int  n,
const double *  a,
lapack_int  lda 
)

Definition at line 37 of file lapacke_dpo_nancheck.c.

41 {
42  return LAPACKE_dtr_nancheck( matrix_order, uplo, 'n', n, a, lda );
43 }
lapack_logical LAPACKE_dtr_nancheck(int matrix_order, char uplo, char diag, lapack_int n, const double *a, lapack_int lda)

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_dpo_trans ( int  matrix_order,
char  uplo,
lapack_int  n,
const double *  in,
lapack_int  ldin,
double *  out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_dpo_trans.c.

43 {
44  LAPACKE_dtr_trans( matrix_order, uplo, 'n', n, in, ldin, out, ldout );
45 }
void LAPACKE_dtr_trans(int matrix_order, char uplo, char diag, lapack_int n, const double *in, lapack_int ldin, double *out, lapack_int ldout)

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_dpp_nancheck ( lapack_int  n,
const double *  ap 
)

Definition at line 40 of file lapacke_dpp_nancheck.c.

42 {
43  lapack_int len = n*(n+1)/2;
44  return LAPACKE_d_nancheck( len, ap, 1 );
45 }
lapack_logical LAPACKE_d_nancheck(lapack_int n, const double *x, lapack_int incx)
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_dpp_trans ( int  matrix_order,
char  uplo,
lapack_int  n,
const double *  in,
double *  out 
)

Definition at line 40 of file lapacke_dpp_trans.c.

43 {
44  LAPACKE_dtp_trans( matrix_order, uplo, 'n', n, in, out );
45 }
void LAPACKE_dtp_trans(int matrix_order, char uplo, char diag, lapack_int n, const double *in, double *out)

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_dpt_nancheck ( lapack_int  n,
const double *  d,
const double *  e 
)

Definition at line 37 of file lapacke_dpt_nancheck.c.

40 {
41  return LAPACKE_d_nancheck( n, d, 1 )
42  || LAPACKE_d_nancheck( n-1, e, 1 );
43 }
lapack_logical LAPACKE_d_nancheck(lapack_int n, const double *x, lapack_int incx)

Here is the call graph for this function:

lapack_logical LAPACKE_dsb_nancheck ( int  matrix_order,
char  uplo,
lapack_int  n,
lapack_int  kd,
const double *  ab,
lapack_int  ldab 
)

Definition at line 37 of file lapacke_dsb_nancheck.c.

41 {
42  if( LAPACKE_lsame( uplo, 'u' ) ) {
43  return LAPACKE_dgb_nancheck( matrix_order, n, n, 0, kd, ab, ldab );
44  } else if( LAPACKE_lsame( uplo, 'l' ) ) {
45  return LAPACKE_dgb_nancheck( matrix_order, n, n, kd, 0, ab, ldab );
46  }
47  return (lapack_logical) 0;
48 }
#define lapack_logical
Definition: lapacke.h:51
lapack_logical LAPACKE_dgb_nancheck(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const double *ab, lapack_int ldab)
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_dsb_trans ( int  matrix_order,
char  uplo,
lapack_int  n,
lapack_int  kd,
const double *  in,
lapack_int  ldin,
double *  out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_dsb_trans.c.

44 {
45  if( LAPACKE_lsame( uplo, 'u' ) ) {
46  LAPACKE_dgb_trans( matrix_order, n, n, 0, kd, in, ldin, out, ldout );
47  } else if( LAPACKE_lsame( uplo, 'l' ) ) {
48  LAPACKE_dgb_trans( matrix_order, n, n, kd, 0, in, ldin, out, ldout );
49  }
50 }
void LAPACKE_dgb_trans(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const double *in, lapack_int ldin, double *out, lapack_int ldout)
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_dsp_nancheck ( lapack_int  n,
const double *  ap 
)

Definition at line 40 of file lapacke_dsp_nancheck.c.

42 {
43  lapack_int len = n*(n+1)/2;
44  return LAPACKE_d_nancheck( len, ap, 1 );
45 }
lapack_logical LAPACKE_d_nancheck(lapack_int n, const double *x, lapack_int incx)
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_dsp_trans ( int  matrix_order,
char  uplo,
lapack_int  n,
const double *  in,
double *  out 
)

Definition at line 40 of file lapacke_dsp_trans.c.

43 {
44  LAPACKE_dtp_trans( matrix_order, uplo, 'n', n, in, out );
45 }
void LAPACKE_dtp_trans(int matrix_order, char uplo, char diag, lapack_int n, const double *in, double *out)

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_dst_nancheck ( lapack_int  n,
const double *  d,
const double *  e 
)

Definition at line 37 of file lapacke_dst_nancheck.c.

40 {
41  return LAPACKE_d_nancheck( n, d, 1 )
42  || LAPACKE_d_nancheck( n-1, e, 1 );
43 }
lapack_logical LAPACKE_d_nancheck(lapack_int n, const double *x, lapack_int incx)

Here is the call graph for this function:

lapack_logical LAPACKE_dsy_nancheck ( int  matrix_order,
char  uplo,
lapack_int  n,
const double *  a,
lapack_int  lda 
)

Definition at line 37 of file lapacke_dsy_nancheck.c.

41 {
42  return LAPACKE_dtr_nancheck( matrix_order, uplo, 'n', n, a, lda );
43 }
lapack_logical LAPACKE_dtr_nancheck(int matrix_order, char uplo, char diag, lapack_int n, const double *a, lapack_int lda)

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_dsy_trans ( int  matrix_order,
char  uplo,
lapack_int  n,
const double *  in,
lapack_int  ldin,
double *  out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_dsy_trans.c.

43 {
44  LAPACKE_dtr_trans( matrix_order, uplo, 'n', n, in, ldin, out, ldout );
45 }
void LAPACKE_dtr_trans(int matrix_order, char uplo, char diag, lapack_int n, const double *in, lapack_int ldin, double *out, lapack_int ldout)

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_dtb_nancheck ( int  matrix_order,
char  uplo,
char  diag,
lapack_int  n,
lapack_int  kd,
const double *  ab,
lapack_int  ldab 
)

Definition at line 37 of file lapacke_dtb_nancheck.c.

41 {
42  lapack_logical colmaj, upper, unit;
43 
44  if( ab == NULL ) return (lapack_logical) 0;
45 
46  colmaj = ( matrix_order == LAPACK_COL_MAJOR );
47  upper = LAPACKE_lsame( uplo, 'u' );
48  unit = LAPACKE_lsame( diag, 'u' );
49 
50  if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
51  ( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
52  ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
53  /* Just exit if any of input parameters are wrong */
54  return (lapack_logical) 0;
55  }
56 
57  if( unit ) {
58  /* Unit case, diagonal should be excluded from the check for NaN. */
59  if( colmaj ) {
60  if( upper ) {
61  return LAPACKE_dgb_nancheck( matrix_order, n-1, n-1, 0, kd-1,
62  &ab[ldab], ldab );
63  } else {
64  return LAPACKE_dgb_nancheck( matrix_order, n-1, n-1, kd-1, 0,
65  &ab[1], ldab );
66  }
67  } else {
68  if( upper ) {
69  return LAPACKE_dgb_nancheck( matrix_order, n-1, n-1, 0, kd-1,
70  &ab[1], ldab );
71  } else {
72  return LAPACKE_dgb_nancheck( matrix_order, n-1, n-1, kd-1, 0,
73  &ab[ldab], ldab );
74  }
75  }
76  } else {
77  /* Non-unit case */
78  if( upper ) {
79  return LAPACKE_dgb_nancheck( matrix_order, n, n, 0, kd, ab, ldab );
80  } else {
81  return LAPACKE_dgb_nancheck( matrix_order, n, n, kd, 0, ab, ldab );
82  }
83  }
84 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
lapack_logical LAPACKE_dgb_nancheck(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const double *ab, lapack_int ldab)
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_dtb_trans ( int  matrix_order,
char  uplo,
char  diag,
lapack_int  n,
lapack_int  kd,
const double *  in,
lapack_int  ldin,
double *  out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_dtb_trans.c.

44 {
45  lapack_logical colmaj, upper, unit;
46 
47  if( in == NULL || out == NULL ) return;
48 
49  colmaj = ( matrix_order == LAPACK_COL_MAJOR );
50  upper = LAPACKE_lsame( uplo, 'u' );
51  unit = LAPACKE_lsame( diag, 'u' );
52 
53  if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
54  ( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
55  ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
56  /* Just exit if any of input parameters are wrong */
57  return;
58  }
59 
60  if( unit ) {
61  /* Unit case, diagonal excluded from transposition */
62  if( colmaj ) {
63  if( upper ) {
64  LAPACKE_dgb_trans( matrix_order, n-1, n-1, 0, kd-1,
65  &in[ldin], ldin, &out[1], ldout );
66  } else {
67  LAPACKE_dgb_trans( matrix_order, n-1, n-1, kd-1, 0,
68  &in[1], ldin, &out[ldout], ldout );
69  }
70  } else {
71  if( upper ) {
72  LAPACKE_dgb_trans( matrix_order, n-1, n-1, 0, kd-1,
73  &in[1], ldin, &out[ldout], ldout );
74  } else {
75  LAPACKE_dgb_trans( matrix_order, n-1, n-1, kd-1, 0,
76  &in[ldin], ldin, &out[1], ldout );
77  }
78  }
79  } else {
80  /* Non-unit case */
81  if( upper ) {
82  LAPACKE_dgb_trans( matrix_order, n, n, 0, kd, in, ldin, out,
83  ldout );
84  } else {
85  LAPACKE_dgb_trans( matrix_order, n, n, kd, 0, in, ldin, out,
86  ldout );
87  }
88  }
89 }
void LAPACKE_dgb_trans(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const double *in, lapack_int ldin, double *out, lapack_int ldout)
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_dtf_nancheck ( int  matrix_order,
char  transr,
char  uplo,
char  diag,
lapack_int  n,
const double *  a 
)

Definition at line 37 of file lapacke_dtf_nancheck.c.

41 {
42  lapack_int len;
43  lapack_logical rowmaj, ntr, lower, unit;
44  lapack_int n1, n2, k;
45 
46  if( a == NULL ) return (lapack_logical) 0;
47 
48  rowmaj = (matrix_order == LAPACK_ROW_MAJOR);
49  ntr = LAPACKE_lsame( transr, 'n' );
50  lower = LAPACKE_lsame( uplo, 'l' );
51  unit = LAPACKE_lsame( diag, 'u' );
52 
53  if( ( !rowmaj && ( matrix_order != LAPACK_COL_MAJOR ) ) ||
54  ( !ntr && !LAPACKE_lsame( transr, 't' )
55  && !LAPACKE_lsame( transr, 'c' ) ) ||
56  ( !lower && !LAPACKE_lsame( uplo, 'u' ) ) ||
57  ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
58  /* Just exit if any of input parameters are wrong */
59  return (lapack_logical) 0;
60  }
61 
62  if( unit ) {
63  /* Unit case, diagonal should be excluded from the check for NaN.
64  * Decoding RFP and checking both triangulars and rectangular
65  * for NaNs.
66  */
67  if( lower ) {
68  n2 = n / 2;
69  n1 = n - n2;
70  } else {
71  n1 = n / 2;
72  n2 = n - n1;
73  }
74  if( n % 2 == 1 ) {
75  /* N is odd */
76  if( ( rowmaj || ntr ) && !( rowmaj && ntr ) ) {
77  /* N is odd and ( TRANSR = 'N' .XOR. ROWMAJOR) */
78  if( lower ) {
79  return LAPACKE_dtr_nancheck( LAPACK_ROW_MAJOR, 'l', 'u',
80  n1, &a[0], n )
82  &a[n1], n )
84  n2, &a[n], n );
85  } else {
86  return LAPACKE_dtr_nancheck( LAPACK_ROW_MAJOR, 'l', 'u',
87  n1, &a[n2], n )
89  &a[0], n )
91  n2, &a[n1], n );
92  }
93  } else {
94  /* N is odd and
95  ( ( TRANSR = 'C' || TRANSR = 'T' ) .XOR. COLMAJOR ) */
96  if( lower ) {
97  return LAPACKE_dtr_nancheck( LAPACK_ROW_MAJOR, 'u', 'u',
98  n1, &a[0], n1 )
100  &a[1], n1 )
102  n2, &a[1], n1 );
103  } else {
104  return LAPACKE_dtr_nancheck( LAPACK_ROW_MAJOR, 'u', 'u',
105  n1, &a[(size_t)n2*n2], n2 )
107  &a[0], n2 )
109  n2, &a[(size_t)n1*n2], n2 );
110  }
111  }
112  } else {
113  /* N is even */
114  k = n / 2;
115  if( ( rowmaj || ntr ) && !( rowmaj && ntr ) ) {
116  /* N is even and ( TRANSR = 'N' .XOR. ROWMAJOR) */
117  if( lower ) {
118  return LAPACKE_dtr_nancheck( LAPACK_ROW_MAJOR, 'l', 'u',
119  k, &a[1], n+1 )
121  &a[k+1], n+1 )
123  k, &a[0], n+1 );
124  } else {
125  return LAPACKE_dtr_nancheck( LAPACK_ROW_MAJOR, 'l', 'u',
126  k, &a[k+1], n+1 )
128  &a[0], n+1 )
130  k, &a[k], n+1 );
131  }
132  } else {
133  /* N is even and
134  ( ( TRANSR = 'C' || TRANSR = 'T' ) .XOR. COLMAJOR ) */
135  if( lower ) {
136  return LAPACKE_dtr_nancheck( LAPACK_ROW_MAJOR, 'u', 'u',
137  k, &a[k], k )
139  &a[(size_t)k*(k+1)], k )
141  k, &a[0], k );
142  } else {
143  return LAPACKE_dtr_nancheck( LAPACK_ROW_MAJOR, 'u', 'u',
144  k, &a[(size_t)k*(k+1)], k )
146  &a[0], k )
148  k, &a[(size_t)k*k], k );
149  }
150  }
151  }
152  } else {
153  /* Non-unit case - just check whole array for NaNs. */
154  len = n*(n+1)/2;
155  return LAPACKE_dge_nancheck( LAPACK_COL_MAJOR, len, 1, a, len );
156  }
157 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
lapack_logical LAPACKE_dtr_nancheck(int matrix_order, char uplo, char diag, lapack_int n, const double *a, lapack_int lda)
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36
lapack_logical LAPACKE_dge_nancheck(int matrix_order, lapack_int m, lapack_int n, const double *a, lapack_int lda)
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_dtf_trans ( int  matrix_order,
char  transr,
char  uplo,
char  diag,
lapack_int  n,
const double *  in,
double *  out 
)

Definition at line 41 of file lapacke_dtf_trans.c.

44 {
45  lapack_int row, col;
46  lapack_logical rowmaj, ntr, lower, unit;
47 
48  if( in == NULL || out == NULL ) return ;
49 
50  rowmaj = (matrix_order == LAPACK_ROW_MAJOR);
51  ntr = LAPACKE_lsame( transr, 'n' );
52  lower = LAPACKE_lsame( uplo, 'l' );
53  unit = LAPACKE_lsame( diag, 'u' );
54 
55  if( ( !rowmaj && ( matrix_order != LAPACK_COL_MAJOR ) ) ||
56  ( !ntr && !LAPACKE_lsame( transr, 't' ) &&
57  !LAPACKE_lsame( transr, 'c' ) ) ||
58  ( !lower && !LAPACKE_lsame( uplo, 'u' ) ) ||
59  ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
60  /* Just exit if input parameters are wrong */
61  return;
62  }
63 
64  /* Determine parameters of array representing RFP */
65  if( ntr ) {
66  if( n%2 == 0 ) {
67  row = n + 1;
68  col = n / 2;
69  } else {
70  row = n;
71  col = (n + 1) / 2;
72  }
73  } else {
74  if( n%2 == 0 ) {
75  row = n / 2;
76  col = n + 1;
77  } else {
78  row = (n + 1) / 2;
79  col = n;
80  }
81  }
82 
83  /* Perform conversion: */
84  if( rowmaj ) {
85  LAPACKE_dge_trans( LAPACK_ROW_MAJOR, row, col, in, col, out, row );
86  } else {
87  LAPACKE_dge_trans( LAPACK_COL_MAJOR, row, col, in, row, out, col );
88  }
89 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
void LAPACKE_dge_trans(int matrix_order, lapack_int m, lapack_int n, const double *in, lapack_int ldin, double *out, lapack_int ldout)
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_dtp_nancheck ( int  matrix_order,
char  uplo,
char  diag,
lapack_int  n,
const double *  ap 
)

Definition at line 40 of file lapacke_dtp_nancheck.c.

43 {
44  lapack_int i, len;
45  lapack_logical colmaj, upper, unit;
46 
47  if( ap == NULL ) return (lapack_logical) 0;
48 
49  colmaj = ( matrix_order == LAPACK_COL_MAJOR );
50  upper = LAPACKE_lsame( uplo, 'u' );
51  unit = LAPACKE_lsame( diag, 'u' );
52 
53  if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
54  ( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
55  ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
56  /* Just exit if any of input parameters are wrong */
57  return (lapack_logical) 0;
58  }
59 
60  if( unit ) {
61  /* Unit case, diagonal should be excluded from the check for NaN. */
62 
63  /* Since col_major upper and row_major lower are equal,
64  * and col_major lower and row_major upper are equals too -
65  * using one code for equal cases. XOR( colmaj, upper )
66  */
67  if( ( colmaj || upper ) && !( colmaj && upper ) ) {
68  for( i = 1; i < n; i++ )
69  if( LAPACKE_d_nancheck( i, &ap[ ((size_t)i+1)*i/2 ], 1 ) )
70  return (lapack_logical) 1;
71  } else {
72  for( i = 0; i < n-1; i++ )
73  if( LAPACKE_d_nancheck( n-i-1,
74  &ap[ (size_t)i+1 + i*((size_t)2*n-i+1)/2 ], 1 ) )
75  return (lapack_logical) 1;
76  }
77  return (lapack_logical) 0;
78  } else {
79  /* Non-unit case - just check whole array for NaNs. */
80  len = n*(n+1)/2;
81  return LAPACKE_d_nancheck( len, ap, 1 );
82  }
83 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36
lapack_logical LAPACKE_d_nancheck(lapack_int n, const double *x, lapack_int incx)
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_dtp_trans ( int  matrix_order,
char  uplo,
char  diag,
lapack_int  n,
const double *  in,
double *  out 
)

Definition at line 40 of file lapacke_dtp_trans.c.

43 {
44  lapack_int i, j, st;
45  lapack_logical colmaj, upper, unit;
46 
47  if( in == NULL || out == NULL ) return ;
48 
49  colmaj = ( matrix_order == LAPACK_COL_MAJOR );
50  upper = LAPACKE_lsame( uplo, 'u' );
51  unit = LAPACKE_lsame( diag, 'u' );
52 
53  if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
54  ( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
55  ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
56  /* Just exit if any of input parameters are wrong */
57  return;
58  }
59  if( unit ) {
60  /* If unit, then don't touch diagonal, start from 1st column or row */
61  st = 1;
62  } else {
63  /* If non-unit, then check diagonal also, starting from [0,0] */
64  st = 0;
65  }
66 
67  /* Perform conversion:
68  * Since col_major upper and row_major lower are equal,
69  * and col_major lower and row_major upper are equals too -
70  * using one code for equal cases. XOR( colmaj, upper )
71  */
72  if( ( colmaj || upper ) && !( colmaj && upper ) ) {
73  for( j = st; j < n; j++ ) {
74  for( i = 0; i < j+1-st; i++ ) {
75  out[ j-i + (i*(2*n-i+1))/2 ] = in[ ((j+1)*j)/2 + i ];
76  }
77  }
78  } else {
79  for( j = 0; j < n-st; j++ ) {
80  for( i = j+st; i < n; i++ ) {
81  out[ j + ((i+1)*i)/2 ] = in[ (j*(2*n-j+1))/2 + i-j ];
82  }
83  }
84  }
85 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_dtr_nancheck ( int  matrix_order,
char  uplo,
char  diag,
lapack_int  n,
const double *  a,
lapack_int  lda 
)

Definition at line 37 of file lapacke_dtr_nancheck.c.

41 {
42  lapack_int i, j, st;
43  lapack_logical colmaj, lower, unit;
44 
45  if( a == NULL ) return (lapack_logical) 0;
46 
47  colmaj = ( matrix_order == LAPACK_COL_MAJOR );
48  lower = LAPACKE_lsame( uplo, 'l' );
49  unit = LAPACKE_lsame( diag, 'u' );
50 
51  if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
52  ( !lower && !LAPACKE_lsame( uplo, 'u' ) ) ||
53  ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
54  /* Just exit if any of input parameters are wrong */
55  return (lapack_logical) 0;
56  }
57  if( unit ) {
58  /* If unit, then don't touch diagonal, start from 1st column or row */
59  st = 1;
60  } else {
61  /* If non-unit, then check diagonal also, starting from [0,0] */
62  st = 0;
63  }
64 
65  /* Since col_major upper and row_major lower are equal,
66  * and col_major lower and row_major upper are equals too -
67  * using one code for equal cases. XOR( colmaj, upper )
68  */
69  if( ( colmaj || lower ) && !( colmaj && lower ) ) {
70  for( j = st; j < n; j++ ) {
71  for( i = 0; i < MIN( j+1-st, lda ); i++ ) {
72  if( LAPACK_DISNAN( a[i+j*lda] ) )
73  return (lapack_logical) 1;
74  }
75  }
76  } else {
77  for( j = 0; j < n-st; j++ ) {
78  for( i = j+st; i < MIN( n, lda ); i++ ) {
79  if( LAPACK_DISNAN( a[i+j*lda] ) )
80  return (lapack_logical) 1;
81  }
82  }
83  }
84  return (lapack_logical) 0;
85 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
#define LAPACK_DISNAN(x)
#define MIN(x, y)
Definition: lapacke_utils.h:50
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_dtr_trans ( int  matrix_order,
char  uplo,
char  diag,
lapack_int  n,
const double *  in,
lapack_int  ldin,
double *  out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_dtr_trans.c.

43 {
44  lapack_int i, j, st;
45  lapack_logical colmaj, lower, unit;
46 
47  if( in == NULL || out == NULL ) return ;
48 
49  colmaj = ( matrix_order == LAPACK_COL_MAJOR );
50  lower = LAPACKE_lsame( uplo, 'l' );
51  unit = LAPACKE_lsame( diag, 'u' );
52 
53  if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
54  ( !lower && !LAPACKE_lsame( uplo, 'u' ) ) ||
55  ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
56  /* Just exit if any of input parameters are wrong */
57  return;
58  }
59  if( unit ) {
60  /* If unit, then don't touch diagonal, start from 1st column or row */
61  st = 1;
62  } else {
63  /* If non-unit, then check diagonal also, starting from [0,0] */
64  st = 0;
65  }
66 
67  /* Perform conversion:
68  * Since col_major upper and row_major lower are equal,
69  * and col_major lower and row_major upper are equals too -
70  * using one code for equal cases. XOR( colmaj, upper )
71  */
72  if( ( colmaj || lower ) && !( colmaj && lower ) ) {
73  for( j = st; j < MIN( n, ldout ); j++ ) {
74  for( i = 0; i < MIN( j+1-st, ldin ); i++ ) {
75  out[ j+i*ldout ] = in[ i+j*ldin ];
76  }
77  }
78  } else {
79  for( j = 0; j < MIN( n-st, ldout ); j++ ) {
80  for( i = j+st; i < MIN( n, ldin ); i++ ) {
81  out[ j+i*ldout ] = in[ i+j*ldin ];
82  }
83  }
84  }
85 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
#define MIN(x, y)
Definition: lapacke_utils.h:50
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_lsame ( char  ca,
char  cb 
)

Definition at line 36 of file lapacke_lsame.c.

37 {
38  return (lapack_logical) LAPACK_lsame( &ca, &cb, 1, 1 );
39 }
#define lapack_logical
Definition: lapacke.h:51
lapack_logical LAPACK_lsame(char *ca, char *cb, lapack_int lca, lapack_int lcb)

Here is the call graph for this function:

lapack_logical LAPACKE_s_nancheck ( lapack_int  n,
const float *  x,
lapack_int  incx 
)

Definition at line 37 of file lapacke_s_nancheck.c.

40 {
41  lapack_int i, inc;
42 
43  if( incx == 0 ) return (lapack_logical) LAPACK_SISNAN( x[0] );
44  inc = ( incx > 0 ) ? incx : -incx ;
45 
46  for( i = 0; i < n*inc; i+=inc ) {
47  if( LAPACK_SISNAN( x[i] ) )
48  return (lapack_logical) 1;
49  }
50  return (lapack_logical) 0;
51 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_SISNAN(x)
#define lapack_int
Definition: lapacke.h:47
lapack_logical LAPACKE_sgb_nancheck ( int  matrix_order,
lapack_int  m,
lapack_int  n,
lapack_int  kl,
lapack_int  ku,
const float *  ab,
lapack_int  ldab 
)

Definition at line 37 of file lapacke_sgb_nancheck.c.

42 {
43  lapack_int i, j;
44 
45  if( ab == NULL ) return (lapack_logical) 0;
46 
47  if( matrix_order == LAPACK_COL_MAJOR ) {
48  for( j = 0; j < n; j++ ) {
49  for( i = MAX( ku-j, 0 ); i < MIN3( ldab, m+ku-j, kl+ku+1 );
50  i++ ) {
51  if( LAPACK_SISNAN( ab[i+(size_t)j*ldab] ) )
52  return (lapack_logical) 1;
53  }
54  }
55  } else if ( matrix_order == LAPACK_ROW_MAJOR ) {
56  for( j = 0; j < MIN( n, ldab ); j++ ) {
57  for( i = MAX( ku-j, 0 ); i < MIN( m+ku-j, kl+ku+1 ); i++ ) {
58  if( LAPACK_SISNAN( ab[(size_t)i*ldab+j] ) )
59  return (lapack_logical) 1;
60  }
61  }
62  }
63  return (lapack_logical) 0;
64 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define MIN3(x, y, z)
Definition: lapacke_utils.h:56
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
#define MAX(x, y)
Definition: lapacke_utils.h:47
#define MIN(x, y)
Definition: lapacke_utils.h:50
#define LAPACK_SISNAN(x)
#define lapack_int
Definition: lapacke.h:47

Here is the caller graph for this function:

void LAPACKE_sgb_trans ( int  matrix_order,
lapack_int  m,
lapack_int  n,
lapack_int  kl,
lapack_int  ku,
const float *  in,
lapack_int  ldin,
float *  out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_sgb_trans.c.

44 {
45  lapack_int i, j;
46 
47  if( in == NULL || out == NULL ) return;
48 
49  if( matrix_order == LAPACK_COL_MAJOR ) {
50  for( j = 0; j < MIN( ldout, n ); j++ ) {
51  for( i = MAX( ku-j, 0 ); i < MIN3( ldin, m+ku-j, kl+ku+1 );
52  i++ ) {
53  out[(size_t)i*ldout+j] = in[i+(size_t)j*ldin];
54  }
55  }
56  } else if ( matrix_order == LAPACK_ROW_MAJOR ) {
57  /* TODO: interchange loops for performance.
58  * This is just reference impemeltation.
59  */
60  for( j = 0; j < MIN( n, ldin ); j++ ) {
61  for( i = MAX( ku-j, 0 ); i < MIN3( ldout, m+ku-j, kl+ku+1 );
62  i++ ) {
63  out[i+(size_t)j*ldout] = in[(size_t)i*ldin+j];
64  }
65  }
66  }
67 }
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define MIN3(x, y, z)
Definition: lapacke_utils.h:56
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
#define MAX(x, y)
Definition: lapacke_utils.h:47
#define MIN(x, y)
Definition: lapacke_utils.h:50
#define lapack_int
Definition: lapacke.h:47

Here is the caller graph for this function:

lapack_logical LAPACKE_sge_nancheck ( int  matrix_order,
lapack_int  m,
lapack_int  n,
const float *  a,
lapack_int  lda 
)

Definition at line 37 of file lapacke_sge_nancheck.c.

41 {
42  lapack_int i, j;
43 
44  if( a == NULL ) return (lapack_logical) 0;
45 
46  if( matrix_order == LAPACK_COL_MAJOR ) {
47  for( j = 0; j < n; j++ ) {
48  for( i = 0; i < MIN( m, lda ); i++ ) {
49  if( LAPACK_SISNAN( a[i+(size_t)j*lda] ) )
50  return (lapack_logical) 1;
51  }
52  }
53  } else if ( matrix_order == LAPACK_ROW_MAJOR ) {
54  for( i = 0; i < m; i++ ) {
55  for( j = 0; j < MIN( n, lda ); j++ ) {
56  if( LAPACK_SISNAN( a[(size_t)i*lda+j] ) )
57  return (lapack_logical) 1;
58  }
59  }
60  }
61  return (lapack_logical) 0;
62 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
#define MIN(x, y)
Definition: lapacke_utils.h:50
#define LAPACK_SISNAN(x)
#define lapack_int
Definition: lapacke.h:47
void LAPACKE_sge_trans ( int  matrix_order,
lapack_int  m,
lapack_int  n,
const float *  in,
lapack_int  ldin,
float *  out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_sge_trans.c.

43 {
44  lapack_int i, j, x, y;
45 
46  if( in == NULL || out == NULL ) return;
47 
48  if( matrix_order == LAPACK_COL_MAJOR ) {
49  x = n;
50  y = m;
51  } else if ( matrix_order == LAPACK_ROW_MAJOR ) {
52  x = m;
53  y = n;
54  } else {
55  /* Unknown input layout */
56  return;
57  }
58 
59  /* In case of incorrect m, n, ldin or ldout the function does nothing */
60  for( i = 0; i < MIN( y, ldin ); i++ ) {
61  for( j = 0; j < MIN( x, ldout ); j++ ) {
62  out[ (size_t)i*ldout + j ] = in[ (size_t)j*ldin + i ];
63  }
64  }
65 }
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
#define MIN(x, y)
Definition: lapacke_utils.h:50
#define lapack_int
Definition: lapacke.h:47
lapack_logical LAPACKE_sgg_nancheck ( int  matrix_order,
lapack_int  m,
lapack_int  n,
const float *  a,
lapack_int  lda 
)

Definition at line 37 of file lapacke_sgg_nancheck.c.

41 {
42  return LAPACKE_sge_nancheck( matrix_order, m, n, a, lda );
43 }
lapack_logical LAPACKE_sge_nancheck(int matrix_order, lapack_int m, lapack_int n, const float *a, lapack_int lda)

Here is the call graph for this function:

void LAPACKE_sgg_trans ( int  matrix_order,
lapack_int  m,
lapack_int  n,
const float *  in,
lapack_int  ldin,
float *  out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_sgg_trans.c.

43 {
44  LAPACKE_sge_trans( matrix_order, m, n, in, ldin, out, ldout );
45 }
void LAPACKE_sge_trans(int matrix_order, lapack_int m, lapack_int n, const float *in, lapack_int ldin, float *out, lapack_int ldout)

Here is the call graph for this function:

lapack_logical LAPACKE_sgt_nancheck ( lapack_int  n,
const float *  dl,
const float *  d,
const float *  du 
)

Definition at line 37 of file lapacke_sgt_nancheck.c.

41 {
42  return LAPACKE_s_nancheck( n-1, dl, 1 )
43  || LAPACKE_s_nancheck( n , d, 1 )
44  || LAPACKE_s_nancheck( n-1, du, 1 );
45 }
lapack_logical LAPACKE_s_nancheck(lapack_int n, const float *x, lapack_int incx)

Here is the call graph for this function:

lapack_logical LAPACKE_shs_nancheck ( int  matrix_order,
lapack_int  n,
const float *  a,
lapack_int  lda 
)

Definition at line 37 of file lapacke_shs_nancheck.c.

40 {
41  lapack_logical subdiag_nans;
42 
43  if( a == NULL ) return (lapack_logical) 0;
44 
45  /* Check subdiagonal first */
46  if( matrix_order == LAPACK_COL_MAJOR ) {
47  subdiag_nans = LAPACKE_s_nancheck( n-1, &a[1], lda+1 );
48  } else if ( matrix_order == LAPACK_ROW_MAJOR ) {
49  subdiag_nans = LAPACKE_s_nancheck( n-1, &a[lda], lda+1 );
50  } else {
51  return (lapack_logical) 0;
52  }
53 
54  /* Check upper triangular if subdiagonal has no NaNs. */
55  return subdiag_nans || LAPACKE_str_nancheck( matrix_order, 'u', 'n',
56  n, a, lda);
57 }
lapack_logical LAPACKE_str_nancheck(int matrix_order, char uplo, char diag, lapack_int n, const float *a, lapack_int lda)
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
lapack_logical LAPACKE_s_nancheck(lapack_int n, const float *x, lapack_int incx)
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119

Here is the call graph for this function:

void LAPACKE_shs_trans ( int  matrix_order,
lapack_int  n,
const float *  in,
lapack_int  ldin,
float *  out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_shs_trans.c.

43 {
44  if( in == NULL || out == NULL ) return;
45 
46  /* Convert subdiagonal first */
47  if( matrix_order == LAPACK_COL_MAJOR ) {
48  LAPACKE_sge_trans( LAPACK_COL_MAJOR, 1, n-1, &in[1], ldin+1,
49  &out[ldout], ldout+1 );
50  } else if ( matrix_order == LAPACK_ROW_MAJOR ) {
51  LAPACKE_sge_trans( LAPACK_ROW_MAJOR, n-1, 1, &in[ldin], ldin+1,
52  &out[1], ldout+1 );
53  } else {
54  return;
55  }
56 
57  /* Convert upper triangular. */
58  LAPACKE_str_trans( matrix_order, 'u', 'n', n, in, ldin, out, ldout);
59 }
void LAPACKE_sge_trans(int matrix_order, lapack_int m, lapack_int n, const float *in, lapack_int ldin, float *out, lapack_int ldout)
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
void LAPACKE_str_trans(int matrix_order, char uplo, char diag, lapack_int n, const float *in, lapack_int ldin, float *out, lapack_int ldout)

Here is the call graph for this function:

lapack_logical LAPACKE_spb_nancheck ( int  matrix_order,
char  uplo,
lapack_int  n,
lapack_int  kd,
const float *  ab,
lapack_int  ldab 
)

Definition at line 37 of file lapacke_spb_nancheck.c.

41 {
42  if( LAPACKE_lsame( uplo, 'u' ) ) {
43  return LAPACKE_sgb_nancheck( matrix_order, n, n, 0, kd, ab, ldab );
44  } else if( LAPACKE_lsame( uplo, 'l' ) ) {
45  return LAPACKE_sgb_nancheck( matrix_order, n, n, kd, 0, ab, ldab );
46  }
47  return (lapack_logical) 0;
48 }
#define lapack_logical
Definition: lapacke.h:51
lapack_logical LAPACKE_sgb_nancheck(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const float *ab, lapack_int ldab)
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_spb_trans ( int  matrix_order,
char  uplo,
lapack_int  n,
lapack_int  kd,
const float *  in,
lapack_int  ldin,
float *  out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_spb_trans.c.

44 {
45  if( LAPACKE_lsame( uplo, 'u' ) ) {
46  LAPACKE_sgb_trans( matrix_order, n, n, 0, kd, in, ldin, out, ldout );
47  } else if( LAPACKE_lsame( uplo, 'l' ) ) {
48  LAPACKE_sgb_trans( matrix_order, n, n, kd, 0, in, ldin, out, ldout );
49  }
50 }
void LAPACKE_sgb_trans(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const float *in, lapack_int ldin, float *out, lapack_int ldout)
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_spf_nancheck ( lapack_int  n,
const float *  a 
)

Definition at line 41 of file lapacke_spf_nancheck.c.

43 {
44  lapack_int len = n*(n+1)/2;
45  return LAPACKE_s_nancheck( len, a, 1 );
46 }
lapack_logical LAPACKE_s_nancheck(lapack_int n, const float *x, lapack_int incx)
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_spf_trans ( int  matrix_order,
char  transr,
char  uplo,
lapack_int  n,
const float *  in,
float *  out 
)

Definition at line 40 of file lapacke_spf_trans.c.

43 {
44  LAPACKE_stf_trans( matrix_order, transr, uplo, 'n', n, in, out );
45 }
void LAPACKE_stf_trans(int matrix_order, char transr, char uplo, char diag, lapack_int n, const float *in, float *out)

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_spo_nancheck ( int  matrix_order,
char  uplo,
lapack_int  n,
const float *  a,
lapack_int  lda 
)

Definition at line 37 of file lapacke_spo_nancheck.c.

41 {
42  return LAPACKE_str_nancheck( matrix_order, uplo, 'n', n, a, lda );
43 }
lapack_logical LAPACKE_str_nancheck(int matrix_order, char uplo, char diag, lapack_int n, const float *a, lapack_int lda)

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_spo_trans ( int  matrix_order,
char  uplo,
lapack_int  n,
const float *  in,
lapack_int  ldin,
float *  out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_spo_trans.c.

43 {
44  LAPACKE_str_trans( matrix_order, uplo, 'n', n, in, ldin, out, ldout );
45 }
void LAPACKE_str_trans(int matrix_order, char uplo, char diag, lapack_int n, const float *in, lapack_int ldin, float *out, lapack_int ldout)

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_spp_nancheck ( lapack_int  n,
const float *  ap 
)

Definition at line 40 of file lapacke_spp_nancheck.c.

42 {
43  lapack_int len = n*(n+1)/2;
44  return LAPACKE_s_nancheck( len, ap, 1 );
45 }
lapack_logical LAPACKE_s_nancheck(lapack_int n, const float *x, lapack_int incx)
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_spp_trans ( int  matrix_order,
char  uplo,
lapack_int  n,
const float *  in,
float *  out 
)

Definition at line 40 of file lapacke_spp_trans.c.

43 {
44  LAPACKE_stp_trans( matrix_order, uplo, 'n', n, in, out );
45 }
void LAPACKE_stp_trans(int matrix_order, char uplo, char diag, lapack_int n, const float *in, float *out)

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_spt_nancheck ( lapack_int  n,
const float *  d,
const float *  e 
)

Definition at line 37 of file lapacke_spt_nancheck.c.

40 {
41  return LAPACKE_s_nancheck( n, d, 1 )
42  || LAPACKE_s_nancheck( n-1, e, 1 );
43 }
lapack_logical LAPACKE_s_nancheck(lapack_int n, const float *x, lapack_int incx)

Here is the call graph for this function:

lapack_logical LAPACKE_ssb_nancheck ( int  matrix_order,
char  uplo,
lapack_int  n,
lapack_int  kd,
const float *  ab,
lapack_int  ldab 
)

Definition at line 37 of file lapacke_ssb_nancheck.c.

41 {
42  if( LAPACKE_lsame( uplo, 'u' ) ) {
43  return LAPACKE_sgb_nancheck( matrix_order, n, n, 0, kd, ab, ldab );
44  } else if( LAPACKE_lsame( uplo, 'l' ) ) {
45  return LAPACKE_sgb_nancheck( matrix_order, n, n, kd, 0, ab, ldab );
46  }
47  return (lapack_logical) 0;
48 }
#define lapack_logical
Definition: lapacke.h:51
lapack_logical LAPACKE_sgb_nancheck(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const float *ab, lapack_int ldab)
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_ssb_trans ( int  matrix_order,
char  uplo,
lapack_int  n,
lapack_int  kd,
const float *  in,
lapack_int  ldin,
float *  out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_ssb_trans.c.

44 {
45  if( LAPACKE_lsame( uplo, 'u' ) ) {
46  LAPACKE_sgb_trans( matrix_order, n, n, 0, kd, in, ldin, out, ldout );
47  } else if( LAPACKE_lsame( uplo, 'l' ) ) {
48  LAPACKE_sgb_trans( matrix_order, n, n, kd, 0, in, ldin, out, ldout );
49  }
50 }
void LAPACKE_sgb_trans(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const float *in, lapack_int ldin, float *out, lapack_int ldout)
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_ssp_nancheck ( lapack_int  n,
const float *  ap 
)

Definition at line 40 of file lapacke_ssp_nancheck.c.

42 {
43  lapack_int len = n*(n+1)/2;
44  return LAPACKE_s_nancheck( len, ap, 1 );
45 }
lapack_logical LAPACKE_s_nancheck(lapack_int n, const float *x, lapack_int incx)
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_ssp_trans ( int  matrix_order,
char  uplo,
lapack_int  n,
const float *  in,
float *  out 
)

Definition at line 40 of file lapacke_ssp_trans.c.

43 {
44  LAPACKE_stp_trans( matrix_order, uplo, 'n', n, in, out );
45 }
void LAPACKE_stp_trans(int matrix_order, char uplo, char diag, lapack_int n, const float *in, float *out)

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_sst_nancheck ( lapack_int  n,
const float *  d,
const float *  e 
)

Definition at line 37 of file lapacke_sst_nancheck.c.

40 {
41  return LAPACKE_s_nancheck( n, d, 1 )
42  || LAPACKE_s_nancheck( n-1, e, 1 );
43 }
lapack_logical LAPACKE_s_nancheck(lapack_int n, const float *x, lapack_int incx)

Here is the call graph for this function:

lapack_logical LAPACKE_ssy_nancheck ( int  matrix_order,
char  uplo,
lapack_int  n,
const float *  a,
lapack_int  lda 
)

Definition at line 37 of file lapacke_ssy_nancheck.c.

41 {
42  return LAPACKE_str_nancheck( matrix_order, uplo, 'n', n, a, lda );
43 }
lapack_logical LAPACKE_str_nancheck(int matrix_order, char uplo, char diag, lapack_int n, const float *a, lapack_int lda)

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_ssy_trans ( int  matrix_order,
char  uplo,
lapack_int  n,
const float *  in,
lapack_int  ldin,
float *  out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_ssy_trans.c.

43 {
44  LAPACKE_str_trans( matrix_order, uplo, 'n', n, in, ldin, out, ldout );
45 }
void LAPACKE_str_trans(int matrix_order, char uplo, char diag, lapack_int n, const float *in, lapack_int ldin, float *out, lapack_int ldout)

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_stb_nancheck ( int  matrix_order,
char  uplo,
char  diag,
lapack_int  n,
lapack_int  kd,
const float *  ab,
lapack_int  ldab 
)

Definition at line 37 of file lapacke_stb_nancheck.c.

41 {
42  lapack_logical colmaj, upper, unit;
43 
44  if( ab == NULL ) return (lapack_logical) 0;
45 
46  colmaj = ( matrix_order == LAPACK_COL_MAJOR );
47  upper = LAPACKE_lsame( uplo, 'u' );
48  unit = LAPACKE_lsame( diag, 'u' );
49 
50  if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
51  ( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
52  ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
53  /* Just exit if any of input parameters are wrong */
54  return (lapack_logical) 0;
55  }
56 
57  if( unit ) {
58  /* Unit case, diagonal should be excluded from the check for NaN. */
59  if( colmaj ) {
60  if( upper ) {
61  return LAPACKE_sgb_nancheck( matrix_order, n-1, n-1, 0, kd-1,
62  &ab[ldab], ldab );
63  } else {
64  return LAPACKE_sgb_nancheck( matrix_order, n-1, n-1, kd-1, 0,
65  &ab[1], ldab );
66  }
67  } else {
68  if( upper ) {
69  return LAPACKE_sgb_nancheck( matrix_order, n-1, n-1, 0, kd-1,
70  &ab[1], ldab );
71  } else {
72  return LAPACKE_sgb_nancheck( matrix_order, n-1, n-1, kd-1, 0,
73  &ab[ldab], ldab );
74  }
75  }
76  } else {
77  /* Non-unit case */
78  if( upper ) {
79  return LAPACKE_sgb_nancheck( matrix_order, n, n, 0, kd, ab, ldab );
80  } else {
81  return LAPACKE_sgb_nancheck( matrix_order, n, n, kd, 0, ab, ldab );
82  }
83  }
84 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
lapack_logical LAPACKE_sgb_nancheck(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const float *ab, lapack_int ldab)
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_stb_trans ( int  matrix_order,
char  uplo,
char  diag,
lapack_int  n,
lapack_int  kd,
const float *  in,
lapack_int  ldin,
float *  out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_stb_trans.c.

44 {
45  lapack_logical colmaj, upper, unit;
46 
47  if( in == NULL || out == NULL ) return;
48 
49  colmaj = ( matrix_order == LAPACK_COL_MAJOR );
50  upper = LAPACKE_lsame( uplo, 'u' );
51  unit = LAPACKE_lsame( diag, 'u' );
52 
53  if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
54  ( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
55  ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
56  /* Just exit if any of input parameters are wrong */
57  return;
58  }
59 
60  if( unit ) {
61  /* Unit case, diagonal excluded from transposition */
62  if( colmaj ) {
63  if( upper ) {
64  LAPACKE_sgb_trans( matrix_order, n-1, n-1, 0, kd-1,
65  &in[ldin], ldin, &out[1], ldout );
66  } else {
67  LAPACKE_sgb_trans( matrix_order, n-1, n-1, kd-1, 0,
68  &in[1], ldin, &out[ldout], ldout );
69  }
70  } else {
71  if( upper ) {
72  LAPACKE_sgb_trans( matrix_order, n-1, n-1, 0, kd-1,
73  &in[1], ldin, &out[ldout], ldout );
74  } else {
75  LAPACKE_sgb_trans( matrix_order, n-1, n-1, kd-1, 0,
76  &in[ldin], ldin, &out[1], ldout );
77  }
78  }
79  } else {
80  /* Non-unit case */
81  if( upper ) {
82  LAPACKE_sgb_trans( matrix_order, n, n, 0, kd, in, ldin, out,
83  ldout );
84  } else {
85  LAPACKE_sgb_trans( matrix_order, n, n, kd, 0, in, ldin, out,
86  ldout );
87  }
88  }
89 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
void LAPACKE_sgb_trans(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const float *in, lapack_int ldin, float *out, lapack_int ldout)
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_stf_nancheck ( int  matrix_order,
char  transr,
char  uplo,
char  diag,
lapack_int  n,
const float *  a 
)

Definition at line 37 of file lapacke_stf_nancheck.c.

41 {
42  lapack_int len;
43  lapack_logical rowmaj, ntr, lower, unit;
44  lapack_int n1, n2, k;
45 
46  if( a == NULL ) return (lapack_logical) 0;
47 
48  rowmaj = (matrix_order == LAPACK_ROW_MAJOR);
49  ntr = LAPACKE_lsame( transr, 'n' );
50  lower = LAPACKE_lsame( uplo, 'l' );
51  unit = LAPACKE_lsame( diag, 'u' );
52 
53  if( ( !rowmaj && ( matrix_order != LAPACK_COL_MAJOR ) ) ||
54  ( !ntr && !LAPACKE_lsame( transr, 't' )
55  && !LAPACKE_lsame( transr, 'c' ) ) ||
56  ( !lower && !LAPACKE_lsame( uplo, 'u' ) ) ||
57  ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
58  /* Just exit if any of input parameters are wrong */
59  return (lapack_logical) 0;
60  }
61 
62  if( unit ) {
63  /* Unit case, diagonal should be excluded from the check for NaN.
64  * Decoding RFP and checking both triangulars and rectangular
65  * for NaNs.
66  */
67  if( lower ) {
68  n2 = n / 2;
69  n1 = n - n2;
70  } else {
71  n1 = n / 2;
72  n2 = n - n1;
73  }
74  if( n % 2 == 1 ) {
75  /* N is odd */
76  if( ( rowmaj || ntr ) && !( rowmaj && ntr ) ) {
77  /* N is odd and ( TRANSR = 'N' .XOR. ROWMAJOR) */
78  if( lower ) {
79  return LAPACKE_str_nancheck( LAPACK_ROW_MAJOR, 'l', 'u',
80  n1, &a[0], n )
82  &a[n1], n )
84  n2, &a[n], n );
85  } else {
86  return LAPACKE_str_nancheck( LAPACK_ROW_MAJOR, 'l', 'u',
87  n1, &a[n2], n )
89  &a[0], n )
91  n2, &a[n1], n );
92  }
93  } else {
94  /* N is odd and
95  ( ( TRANSR = 'C' || TRANSR = 'T' ) .XOR. COLMAJOR ) */
96  if( lower ) {
97  return LAPACKE_str_nancheck( LAPACK_ROW_MAJOR, 'u', 'u',
98  n1, &a[0], n1 )
100  &a[1], n1 )
102  n2, &a[1], n1 );
103  } else {
104  return LAPACKE_str_nancheck( LAPACK_ROW_MAJOR, 'u', 'u',
105  n1, &a[(size_t)n2*n2], n2 )
107  &a[0], n2 )
109  n2, &a[(size_t)n1*n2], n2 );
110  }
111  }
112  } else {
113  /* N is even */
114  k = n / 2;
115  if( ( rowmaj || ntr ) && !( rowmaj && ntr ) ) {
116  /* N is even and ( TRANSR = 'N' .XOR. ROWMAJOR) */
117  if( lower ) {
118  return LAPACKE_str_nancheck( LAPACK_ROW_MAJOR, 'l', 'u',
119  k, &a[1], n+1 )
121  &a[k+1], n+1 )
123  k, &a[0], n+1 );
124  } else {
125  return LAPACKE_str_nancheck( LAPACK_ROW_MAJOR, 'l', 'u',
126  k, &a[k+1], n+1 )
128  &a[0], n+1 )
130  k, &a[k], n+1 );
131  }
132  } else {
133  /* N is even and
134  * ( ( TRANSR = 'C' || TRANSR = 'T' ) .XOR. COLMAJOR )
135  */
136  if( lower ) {
137  return LAPACKE_str_nancheck( LAPACK_ROW_MAJOR, 'u', 'u',
138  k, &a[k], k )
140  &a[(size_t)k*(k+1)], k )
142  k, &a[0], k );
143  } else {
144  return LAPACKE_str_nancheck( LAPACK_ROW_MAJOR, 'u', 'u',
145  k, &a[(size_t)k*(k+1)], k )
147  &a[0], k )
149  k, &a[(size_t)k*k], k );
150  }
151  }
152  }
153  } else {
154  /* Non-unit case - just check whole array for NaNs. */
155  len = n*(n+1)/2;
156  return LAPACKE_sge_nancheck( LAPACK_COL_MAJOR, len, 1, a, len );
157  }
158 }
lapack_logical LAPACKE_str_nancheck(int matrix_order, char uplo, char diag, lapack_int n, const float *a, lapack_int lda)
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
lapack_logical LAPACKE_sge_nancheck(int matrix_order, lapack_int m, lapack_int n, const float *a, lapack_int lda)
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_stf_trans ( int  matrix_order,
char  transr,
char  uplo,
char  diag,
lapack_int  n,
const float *  in,
float *  out 
)

Definition at line 41 of file lapacke_stf_trans.c.

44 {
45  lapack_int row, col;
46  lapack_logical rowmaj, ntr, lower, unit;
47 
48  if( in == NULL || out == NULL ) return ;
49 
50  rowmaj = (matrix_order == LAPACK_ROW_MAJOR);
51  ntr = LAPACKE_lsame( transr, 'n' );
52  lower = LAPACKE_lsame( uplo, 'l' );
53  unit = LAPACKE_lsame( diag, 'u' );
54 
55  if( ( !rowmaj && ( matrix_order != LAPACK_COL_MAJOR ) ) ||
56  ( !ntr && !LAPACKE_lsame( transr, 't' ) &&
57  !LAPACKE_lsame( transr, 'c' ) ) ||
58  ( !lower && !LAPACKE_lsame( uplo, 'u' ) ) ||
59  ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
60  /* Just exit if input parameters are wrong */
61  return;
62  }
63 
64  /* Determine parameters of array representing RFP */
65  if( ntr ) {
66  if( n%2 == 0 ) {
67  row = n + 1;
68  col = n / 2;
69  } else {
70  row = n;
71  col = (n + 1) / 2;
72  }
73  } else {
74  if( n%2 == 0 ) {
75  row = n / 2;
76  col = n + 1;
77  } else {
78  row = (n + 1) / 2;
79  col = n;
80  }
81  }
82 
83  /* Perform conversion: */
84  if( rowmaj ) {
85  LAPACKE_sge_trans( LAPACK_ROW_MAJOR, row, col, in, col, out, row );
86  } else {
87  LAPACKE_sge_trans( LAPACK_COL_MAJOR, row, col, in, row, out, col );
88  }
89 }
void LAPACKE_sge_trans(int matrix_order, lapack_int m, lapack_int n, const float *in, lapack_int ldin, float *out, lapack_int ldout)
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_stp_nancheck ( int  matrix_order,
char  uplo,
char  diag,
lapack_int  n,
const float *  ap 
)

Definition at line 40 of file lapacke_stp_nancheck.c.

43 {
44  lapack_int i, len;
45  lapack_logical colmaj, upper, unit;
46 
47  if( ap == NULL ) return (lapack_logical) 0;
48 
49  colmaj = ( matrix_order == LAPACK_COL_MAJOR );
50  upper = LAPACKE_lsame( uplo, 'u' );
51  unit = LAPACKE_lsame( diag, 'u' );
52 
53  if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
54  ( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
55  ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
56  /* Just exit if any of input parameters are wrong */
57  return (lapack_logical) 0;
58  }
59 
60  if( unit ) {
61  /* Unit case, diagonal should be excluded from the check for NaN. */
62 
63  /* Since col_major upper and row_major lower are equal,
64  * and col_major lower and row_major upper are equals too -
65  * using one code for equal cases. XOR( colmaj, upper )
66  */
67  if( ( colmaj || upper ) && !( colmaj && upper ) ) {
68  for( i = 1; i < n; i++ )
69  if( LAPACKE_s_nancheck( i, &ap[ ((size_t)i+1)*i/2 ], 1 ) )
70  return (lapack_logical) 1;
71  } else {
72  for( i = 0; i < n-1; i++ )
73  if( LAPACKE_s_nancheck( n-i-1,
74  &ap[ (size_t)i+1 + i*((size_t)2*n-i+1)/2 ], 1 ) )
75  return (lapack_logical) 1;
76  }
77  return (lapack_logical) 0;
78  } else {
79  /* Non-unit case - just check whole array for NaNs. */
80  len = n*(n+1)/2;
81  return LAPACKE_s_nancheck( len, ap, 1 );
82  }
83 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
lapack_logical LAPACKE_s_nancheck(lapack_int n, const float *x, lapack_int incx)
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_stp_trans ( int  matrix_order,
char  uplo,
char  diag,
lapack_int  n,
const float *  in,
float *  out 
)

Definition at line 40 of file lapacke_stp_trans.c.

43 {
44  lapack_int i, j, st;
45  lapack_logical colmaj, upper, unit;
46 
47  if( in == NULL || out == NULL ) return ;
48 
49  colmaj = ( matrix_order == LAPACK_COL_MAJOR );
50  upper = LAPACKE_lsame( uplo, 'u' );
51  unit = LAPACKE_lsame( diag, 'u' );
52 
53  if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
54  ( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
55  ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
56  /* Just exit if any of input parameters are wrong */
57  return;
58  }
59  if( unit ) {
60  /* If unit, then don't touch diagonal, start from 1st column or row */
61  st = 1;
62  } else {
63  /* If non-unit, then check diagonal also, starting from [0,0] */
64  st = 0;
65  }
66 
67  /* Perform conversion:
68  * Since col_major upper and row_major lower are equal,
69  * and col_major lower and row_major upper are equals too -
70  * using one code for equal cases. XOR( colmaj, upper )
71  */
72  if( ( colmaj || upper ) && !( colmaj && upper ) ) {
73  for( j = st; j < n; j++ ) {
74  for( i = 0; i < j+1-st; i++ ) {
75  out[ j-i + (i*(2*n-i+1))/2 ] = in[ ((j+1)*j)/2 + i ];
76  }
77  }
78  } else {
79  for( j = 0; j < n-st; j++ ) {
80  for( i = j+st; i < n; i++ ) {
81  out[ j + ((i+1)*i)/2 ] = in[ (j*(2*n-j+1))/2 + i-j ];
82  }
83  }
84  }
85 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_str_nancheck ( int  matrix_order,
char  uplo,
char  diag,
lapack_int  n,
const float *  a,
lapack_int  lda 
)

Definition at line 37 of file lapacke_str_nancheck.c.

41 {
42  lapack_int i, j, st;
43  lapack_logical colmaj, lower, unit;
44 
45  if( a == NULL ) return (lapack_logical) 0;
46 
47  colmaj = ( matrix_order == LAPACK_COL_MAJOR );
48  lower = LAPACKE_lsame( uplo, 'l' );
49  unit = LAPACKE_lsame( diag, 'u' );
50 
51  if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
52  ( !lower && !LAPACKE_lsame( uplo, 'u' ) ) ||
53  ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
54  /* Just exit if any of input parameters are wrong */
55  return (lapack_logical) 0;
56  }
57  if( unit ) {
58  /* If unit, then don't touch diagonal, start from 1st column or row */
59  st = 1;
60  } else {
61  /* If non-unit, then check diagonal also, starting from [0,0] */
62  st = 0;
63  }
64 
65  /* Since col_major upper and row_major lower are equal,
66  * and col_major lower and row_major upper are equals too -
67  * using one code for equal cases. XOR( colmaj, upper )
68  */
69  if( ( colmaj || lower ) && !( colmaj && lower ) ) {
70  for( j = st; j < n; j++ ) {
71  for( i = 0; i < MIN( j+1-st, lda ); i++ ) {
72  if( LAPACK_SISNAN( a[i+j*lda] ) )
73  return (lapack_logical) 1;
74  }
75  }
76  } else {
77  for( j = 0; j < n-st; j++ ) {
78  for( i = j+st; i < MIN( n, lda ); i++ ) {
79  if( LAPACK_SISNAN( a[i+j*lda] ) )
80  return (lapack_logical) 1;
81  }
82  }
83  }
84  return (lapack_logical) 0;
85 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
#define MIN(x, y)
Definition: lapacke_utils.h:50
#define LAPACK_SISNAN(x)
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_str_trans ( int  matrix_order,
char  uplo,
char  diag,
lapack_int  n,
const float *  in,
lapack_int  ldin,
float *  out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_str_trans.c.

43 {
44  lapack_int i, j, st;
45  lapack_logical colmaj, lower, unit;
46 
47  if( in == NULL || out == NULL ) return ;
48 
49  colmaj = ( matrix_order == LAPACK_COL_MAJOR );
50  lower = LAPACKE_lsame( uplo, 'l' );
51  unit = LAPACKE_lsame( diag, 'u' );
52 
53  if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
54  ( !lower && !LAPACKE_lsame( uplo, 'u' ) ) ||
55  ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
56  /* Just exit if any of input parameters are wrong */
57  return;
58  }
59  if( unit ) {
60  /* If unit, then don't touch diagonal, start from 1st column or row */
61  st = 1;
62  } else {
63  /* If non-unit, then check diagonal also, starting from [0,0] */
64  st = 0;
65  }
66 
67  /* Perform conversion:
68  * Since col_major upper and row_major lower are equal,
69  * and col_major lower and row_major upper are equals too -
70  * using one code for equal cases. XOR( colmaj, upper )
71  */
72  if( ( colmaj || lower ) && !( colmaj && lower ) ) {
73  for( j = st; j < MIN( n, ldout ); j++ ) {
74  for( i = 0; i < MIN( j+1-st, ldin ); i++ ) {
75  out[ j+i*ldout ] = in[ i+j*ldin ];
76  }
77  }
78  } else {
79  for( j = 0; j < MIN( n-st, ldout ); j++ ) {
80  for( i = j+st; i < MIN( n, ldin ); i++ ) {
81  out[ j+i*ldout ] = in[ i+j*ldin ];
82  }
83  }
84  }
85 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
#define MIN(x, y)
Definition: lapacke_utils.h:50
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_xerbla ( const char *  name,
lapack_int  info 
)

Definition at line 37 of file lapacke_xerbla.c.

38 {
39  if( info == LAPACK_WORK_MEMORY_ERROR ) {
40  printf( "Not enough memory to allocate work array in %s\n", name );
41  } else if( info == LAPACK_TRANSPOSE_MEMORY_ERROR ) {
42  printf( "Not enough memory to transpose matrix in %s\n", name );
43  } else if( info < 0 ) {
44  printf( "Wrong parameter %d in %s\n", -(int) info, name );
45  }
46 }
#define LAPACK_TRANSPOSE_MEMORY_ERROR
Definition: lapacke.h:123
#define LAPACK_WORK_MEMORY_ERROR
Definition: lapacke.h:122
lapack_logical LAPACKE_z_nancheck ( lapack_int  n,
const lapack_complex_double x,
lapack_int  incx 
)

Definition at line 37 of file lapacke_z_nancheck.c.

40 {
41  lapack_int i, inc;
42 
43  if( incx == 0 ) return (lapack_logical) LAPACK_ZISNAN( x[0] );
44  inc = ( incx > 0 ) ? incx : -incx ;
45 
46  for( i = 0; i < n*inc; i+=inc ) {
47  if( LAPACK_ZISNAN( x[i] ) )
48  return (lapack_logical) 1;
49  }
50  return (lapack_logical) 0;
51 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_ZISNAN(x)
#define lapack_int
Definition: lapacke.h:47

Here is the caller graph for this function:

lapack_logical LAPACKE_zgb_nancheck ( int  matrix_order,
lapack_int  m,
lapack_int  n,
lapack_int  kl,
lapack_int  ku,
const lapack_complex_double ab,
lapack_int  ldab 
)

Definition at line 37 of file lapacke_zgb_nancheck.c.

42 {
43  lapack_int i, j;
44 
45  if( ab == NULL ) return (lapack_logical) 0;
46 
47  if( matrix_order == LAPACK_COL_MAJOR ) {
48  for( j = 0; j < n; j++ ) {
49  for( i = MAX( ku-j, 0 ); i < MIN3( ldab, m+ku-j, kl+ku+1 );
50  i++ ) {
51  if( LAPACK_ZISNAN( ab[i+(size_t)j*ldab] ) )
52  return (lapack_logical) 1;
53  }
54  }
55  } else if ( matrix_order == LAPACK_ROW_MAJOR ) {
56  for( j = 0; j < MIN( n, ldab ); j++ ) {
57  for( i = MAX( ku-j, 0 ); i < MIN( m+ku-j, kl+ku+1 ); i++ ) {
58  if( LAPACK_ZISNAN( ab[(size_t)i*ldab+j] ) )
59  return (lapack_logical) 1;
60  }
61  }
62  }
63  return (lapack_logical) 0;
64 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define MIN3(x, y, z)
Definition: lapacke_utils.h:56
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
#define MAX(x, y)
Definition: lapacke_utils.h:47
#define LAPACK_ZISNAN(x)
#define MIN(x, y)
Definition: lapacke_utils.h:50
#define lapack_int
Definition: lapacke.h:47

Here is the caller graph for this function:

void LAPACKE_zgb_trans ( int  matrix_order,
lapack_int  m,
lapack_int  n,
lapack_int  kl,
lapack_int  ku,
const lapack_complex_double in,
lapack_int  ldin,
lapack_complex_double out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_zgb_trans.c.

44 {
45  lapack_int i, j;
46 
47  if( in == NULL || out == NULL ) return;
48 
49  if( matrix_order == LAPACK_COL_MAJOR ) {
50  for( j = 0; j < MIN( ldout, n ); j++ ) {
51  for( i = MAX( ku-j, 0 ); i < MIN3( ldin, m+ku-j, kl+ku+1 );
52  i++ ) {
53  out[(size_t)i*ldout+j] = in[i+(size_t)j*ldin];
54  }
55  }
56  } else if ( matrix_order == LAPACK_ROW_MAJOR ) {
57  /* TODO: interchange loops for performance.
58  * This is just reference impemeltation
59  */
60  for( j = 0; j < MIN( n, ldin ); j++ ) {
61  for( i = MAX( ku-j, 0 ); i < MIN3( ldout, m+ku-j, kl+ku+1 );
62  i++ ) {
63  out[i+(size_t)j*ldout] = in[(size_t)i*ldin+j];
64  }
65  }
66  }
67 }
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define MIN3(x, y, z)
Definition: lapacke_utils.h:56
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
#define MAX(x, y)
Definition: lapacke_utils.h:47
#define MIN(x, y)
Definition: lapacke_utils.h:50
#define lapack_int
Definition: lapacke.h:47

Here is the caller graph for this function:

lapack_logical LAPACKE_zge_nancheck ( int  matrix_order,
lapack_int  m,
lapack_int  n,
const lapack_complex_double a,
lapack_int  lda 
)

Definition at line 37 of file lapacke_zge_nancheck.c.

41 {
42  lapack_int i, j;
43 
44  if( a == NULL ) return (lapack_logical) 0;
45 
46  if( matrix_order == LAPACK_COL_MAJOR ) {
47  for( j = 0; j < n; j++ ) {
48  for( i = 0; i < MIN( m, lda ); i++ ) {
49  if( LAPACK_ZISNAN( a[i+(size_t)j*lda] ) )
50  return (lapack_logical) 1;
51  }
52  }
53  } else if ( matrix_order == LAPACK_ROW_MAJOR ) {
54  for( i = 0; i < m; i++ ) {
55  for( j = 0; j < MIN( n, lda ); j++ ) {
56  if( LAPACK_ZISNAN( a[(size_t)i*lda+j] ) )
57  return (lapack_logical) 1;
58  }
59  }
60  }
61  return (lapack_logical) 0;
62 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
#define LAPACK_ZISNAN(x)
#define MIN(x, y)
Definition: lapacke_utils.h:50
#define lapack_int
Definition: lapacke.h:47
void LAPACKE_zge_trans ( int  matrix_order,
lapack_int  m,
lapack_int  n,
const lapack_complex_double in,
lapack_int  ldin,
lapack_complex_double out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_zge_trans.c.

43 {
44  lapack_int i, j, x, y;
45 
46  if( in == NULL || out == NULL ) return;
47 
48  if( matrix_order == LAPACK_COL_MAJOR ) {
49  x = n;
50  y = m;
51  } else if ( matrix_order == LAPACK_ROW_MAJOR ) {
52  x = m;
53  y = n;
54  } else {
55  /* Unknown input layout */
56  return;
57  }
58 
59  /* In case of incorrect m, n, ldin or ldout the function does nothing */
60  for( i = 0; i < MIN( y, ldin ); i++ ) {
61  for( j = 0; j < MIN( x, ldout ); j++ ) {
62  out[ (size_t)i*ldout + j ] = in[ (size_t)j*ldin + i ];
63  }
64  }
65 }
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
#define MIN(x, y)
Definition: lapacke_utils.h:50
#define lapack_int
Definition: lapacke.h:47
lapack_logical LAPACKE_zgg_nancheck ( int  matrix_order,
lapack_int  m,
lapack_int  n,
const lapack_complex_double a,
lapack_int  lda 
)

Definition at line 37 of file lapacke_zgg_nancheck.c.

41 {
42  return LAPACKE_zge_nancheck( matrix_order, m, n, a, lda );
43 }
lapack_logical LAPACKE_zge_nancheck(int matrix_order, lapack_int m, lapack_int n, const lapack_complex_double *a, lapack_int lda)

Here is the call graph for this function:

void LAPACKE_zgg_trans ( int  matrix_order,
lapack_int  m,
lapack_int  n,
const lapack_complex_double in,
lapack_int  ldin,
lapack_complex_double out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_zgg_trans.c.

43 {
44  LAPACKE_zge_trans( matrix_order, m, n, in, ldin, out, ldout );
45 }
void LAPACKE_zge_trans(int matrix_order, lapack_int m, lapack_int n, const lapack_complex_double *in, lapack_int ldin, lapack_complex_double *out, lapack_int ldout)

Here is the call graph for this function:

lapack_logical LAPACKE_zgt_nancheck ( lapack_int  n,
const lapack_complex_double dl,
const lapack_complex_double d,
const lapack_complex_double du 
)

Definition at line 37 of file lapacke_zgt_nancheck.c.

41 {
42  return LAPACKE_z_nancheck( n-1, dl, 1 )
43  || LAPACKE_z_nancheck( n , d, 1 )
44  || LAPACKE_z_nancheck( n-1, du, 1 );
45 }
lapack_logical LAPACKE_z_nancheck(lapack_int n, const lapack_complex_double *x, lapack_int incx)

Here is the call graph for this function:

lapack_logical LAPACKE_zhb_nancheck ( int  matrix_order,
char  uplo,
lapack_int  n,
lapack_int  kd,
const lapack_complex_double ab,
lapack_int  ldab 
)

Definition at line 37 of file lapacke_zhb_nancheck.c.

41 {
42  if( LAPACKE_lsame( uplo, 'u' ) ) {
43  return LAPACKE_zgb_nancheck( matrix_order, n, n, 0, kd, ab, ldab );
44  } else if( LAPACKE_lsame( uplo, 'l' ) ) {
45  return LAPACKE_zgb_nancheck( matrix_order, n, n, kd, 0, ab, ldab );
46  }
47  return (lapack_logical) 0;
48 }
#define lapack_logical
Definition: lapacke.h:51
lapack_logical LAPACKE_zgb_nancheck(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const lapack_complex_double *ab, lapack_int ldab)
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_zhb_trans ( int  matrix_order,
char  uplo,
lapack_int  n,
lapack_int  kd,
const lapack_complex_double in,
lapack_int  ldin,
lapack_complex_double out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_zhb_trans.c.

44 {
45  if( LAPACKE_lsame( uplo, 'u' ) ) {
46  LAPACKE_zgb_trans( matrix_order, n, n, 0, kd, in, ldin, out, ldout );
47  } else if( LAPACKE_lsame( uplo, 'l' ) ) {
48  LAPACKE_zgb_trans( matrix_order, n, n, kd, 0, in, ldin, out, ldout );
49  }
50 }
void LAPACKE_zgb_trans(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const lapack_complex_double *in, lapack_int ldin, lapack_complex_double *out, lapack_int ldout)
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_zhe_nancheck ( int  matrix_order,
char  uplo,
lapack_int  n,
const lapack_complex_double a,
lapack_int  lda 
)

Definition at line 37 of file lapacke_zhe_nancheck.c.

41 {
42  return LAPACKE_ztr_nancheck( matrix_order, uplo, 'n', n, a, lda );
43 }
lapack_logical LAPACKE_ztr_nancheck(int matrix_order, char uplo, char diag, lapack_int n, const lapack_complex_double *a, lapack_int lda)

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_zhe_trans ( int  matrix_order,
char  uplo,
lapack_int  n,
const lapack_complex_double in,
lapack_int  ldin,
lapack_complex_double out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_zhe_trans.c.

43 {
44  LAPACKE_ztr_trans( matrix_order, uplo, 'n', n, in, ldin, out, ldout );
45 }
void LAPACKE_ztr_trans(int matrix_order, char uplo, char diag, lapack_int n, const lapack_complex_double *in, lapack_int ldin, lapack_complex_double *out, lapack_int ldout)

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_zhp_nancheck ( lapack_int  n,
const lapack_complex_double ap 
)

Definition at line 40 of file lapacke_zhp_nancheck.c.

42 {
43  lapack_int len = n*(n+1)/2;
44  return LAPACKE_z_nancheck( len, ap, 1 );
45 }
lapack_logical LAPACKE_z_nancheck(lapack_int n, const lapack_complex_double *x, lapack_int incx)
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_zhp_trans ( int  matrix_order,
char  uplo,
lapack_int  n,
const lapack_complex_double in,
lapack_complex_double out 
)

Definition at line 40 of file lapacke_zhp_trans.c.

43 {
44  LAPACKE_ztp_trans( matrix_order, uplo, 'n', n, in, out );
45 }
void LAPACKE_ztp_trans(int matrix_order, char uplo, char diag, lapack_int n, const lapack_complex_double *in, lapack_complex_double *out)

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_zhs_nancheck ( int  matrix_order,
lapack_int  n,
const lapack_complex_double a,
lapack_int  lda 
)

Definition at line 37 of file lapacke_zhs_nancheck.c.

40 {
41  lapack_logical subdiag_nans;
42 
43  if( a == NULL ) return (lapack_logical) 0;
44 
45  /* Check subdiagonal first */
46  if( matrix_order == LAPACK_COL_MAJOR ) {
47  subdiag_nans = LAPACKE_z_nancheck( n-1, &a[1], lda+1 );
48  } else if ( matrix_order == LAPACK_ROW_MAJOR ) {
49  subdiag_nans = LAPACKE_z_nancheck( n-1, &a[lda], lda+1 );
50  } else {
51  return (lapack_logical) 0;
52  }
53 
54  /* Check upper triangular if subdiagonal has no NaNs. */
55  return subdiag_nans || LAPACKE_ztr_nancheck( matrix_order, 'u', 'n',
56  n, a, lda);
57 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
lapack_logical LAPACKE_z_nancheck(lapack_int n, const lapack_complex_double *x, lapack_int incx)
lapack_logical LAPACKE_ztr_nancheck(int matrix_order, char uplo, char diag, lapack_int n, const lapack_complex_double *a, lapack_int lda)

Here is the call graph for this function:

void LAPACKE_zhs_trans ( int  matrix_order,
lapack_int  n,
const lapack_complex_double in,
lapack_int  ldin,
lapack_complex_double out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_zhs_trans.c.

43 {
44  if( in == NULL || out == NULL ) return;
45 
46  /* Convert subdiagonal first */
47  if( matrix_order == LAPACK_COL_MAJOR ) {
48  LAPACKE_zge_trans( LAPACK_COL_MAJOR, 1, n-1, &in[1], ldin+1,
49  &out[ldout], ldout+1 );
50  } else if ( matrix_order == LAPACK_ROW_MAJOR ) {
51  LAPACKE_zge_trans( LAPACK_ROW_MAJOR, n-1, 1, &in[ldin], ldin+1,
52  &out[1], ldout+1 );
53  } else {
54  return;
55  }
56 
57  /* Convert upper triangular. */
58  LAPACKE_ztr_trans( matrix_order, 'u', 'n', n, in, ldin, out, ldout);
59 }
void LAPACKE_zge_trans(int matrix_order, lapack_int m, lapack_int n, const lapack_complex_double *in, lapack_int ldin, lapack_complex_double *out, lapack_int ldout)
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
void LAPACKE_ztr_trans(int matrix_order, char uplo, char diag, lapack_int n, const lapack_complex_double *in, lapack_int ldin, lapack_complex_double *out, lapack_int ldout)
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119

Here is the call graph for this function:

lapack_logical LAPACKE_zpb_nancheck ( int  matrix_order,
char  uplo,
lapack_int  n,
lapack_int  kd,
const lapack_complex_double ab,
lapack_int  ldab 
)

Definition at line 37 of file lapacke_zpb_nancheck.c.

41 {
42  if( LAPACKE_lsame( uplo, 'u' ) ) {
43  return LAPACKE_zgb_nancheck( matrix_order, n, n, 0, kd, ab, ldab );
44  } else if( LAPACKE_lsame( uplo, 'l' ) ) {
45  return LAPACKE_zgb_nancheck( matrix_order, n, n, kd, 0, ab, ldab );
46  }
47  return (lapack_logical) 0;
48 }
#define lapack_logical
Definition: lapacke.h:51
lapack_logical LAPACKE_zgb_nancheck(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const lapack_complex_double *ab, lapack_int ldab)
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_zpb_trans ( int  matrix_order,
char  uplo,
lapack_int  n,
lapack_int  kd,
const lapack_complex_double in,
lapack_int  ldin,
lapack_complex_double out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_zpb_trans.c.

44 {
45  if( LAPACKE_lsame( uplo, 'u' ) ) {
46  LAPACKE_zgb_trans( matrix_order, n, n, 0, kd, in, ldin, out, ldout );
47  } else if( LAPACKE_lsame( uplo, 'l' ) ) {
48  LAPACKE_zgb_trans( matrix_order, n, n, kd, 0, in, ldin, out, ldout );
49  }
50 }
void LAPACKE_zgb_trans(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const lapack_complex_double *in, lapack_int ldin, lapack_complex_double *out, lapack_int ldout)
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_zpf_nancheck ( lapack_int  n,
const lapack_complex_double a 
)

Definition at line 41 of file lapacke_zpf_nancheck.c.

43 {
44  lapack_int len = n*(n+1)/2;
45  return LAPACKE_z_nancheck( len, a, 1 );
46 }
lapack_logical LAPACKE_z_nancheck(lapack_int n, const lapack_complex_double *x, lapack_int incx)
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_zpf_trans ( int  matrix_order,
char  transr,
char  uplo,
lapack_int  n,
const lapack_complex_double in,
lapack_complex_double out 
)

Definition at line 40 of file lapacke_zpf_trans.c.

43 {
44  LAPACKE_ztf_trans( matrix_order, transr, uplo, 'n', n, in, out );
45 }
void LAPACKE_ztf_trans(int matrix_order, char transr, char uplo, char diag, lapack_int n, const lapack_complex_double *in, lapack_complex_double *out)

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_zpo_nancheck ( int  matrix_order,
char  uplo,
lapack_int  n,
const lapack_complex_double a,
lapack_int  lda 
)

Definition at line 37 of file lapacke_zpo_nancheck.c.

41 {
42  return LAPACKE_ztr_nancheck( matrix_order, uplo, 'n', n, a, lda );
43 }
lapack_logical LAPACKE_ztr_nancheck(int matrix_order, char uplo, char diag, lapack_int n, const lapack_complex_double *a, lapack_int lda)

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_zpo_trans ( int  matrix_order,
char  uplo,
lapack_int  n,
const lapack_complex_double in,
lapack_int  ldin,
lapack_complex_double out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_zpo_trans.c.

43 {
44  LAPACKE_ztr_trans( matrix_order, uplo, 'n', n, in, ldin, out, ldout );
45 }
void LAPACKE_ztr_trans(int matrix_order, char uplo, char diag, lapack_int n, const lapack_complex_double *in, lapack_int ldin, lapack_complex_double *out, lapack_int ldout)

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_zpp_nancheck ( lapack_int  n,
const lapack_complex_double ap 
)

Definition at line 40 of file lapacke_zpp_nancheck.c.

42 {
43  lapack_int len = n*(n+1)/2;
44  return LAPACKE_z_nancheck( len, ap, 1 );
45 }
lapack_logical LAPACKE_z_nancheck(lapack_int n, const lapack_complex_double *x, lapack_int incx)
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_zpp_trans ( int  matrix_order,
char  uplo,
lapack_int  n,
const lapack_complex_double in,
lapack_complex_double out 
)

Definition at line 40 of file lapacke_zpp_trans.c.

43 {
44  LAPACKE_ztp_trans( matrix_order, uplo, 'n', n, in, out );
45 }
void LAPACKE_ztp_trans(int matrix_order, char uplo, char diag, lapack_int n, const lapack_complex_double *in, lapack_complex_double *out)

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_zpt_nancheck ( lapack_int  n,
const double *  d,
const lapack_complex_double e 
)

Definition at line 37 of file lapacke_zpt_nancheck.c.

40 {
41  return LAPACKE_d_nancheck( n, d, 1 )
42  || LAPACKE_z_nancheck( n-1, e, 1 );
43 }
lapack_logical LAPACKE_z_nancheck(lapack_int n, const lapack_complex_double *x, lapack_int incx)
lapack_logical LAPACKE_d_nancheck(lapack_int n, const double *x, lapack_int incx)

Here is the call graph for this function:

lapack_logical LAPACKE_zsp_nancheck ( lapack_int  n,
const lapack_complex_double ap 
)

Definition at line 40 of file lapacke_zsp_nancheck.c.

42 {
43  lapack_int len = n*(n+1)/2;
44  return LAPACKE_z_nancheck( len, ap, 1 );
45 }
lapack_logical LAPACKE_z_nancheck(lapack_int n, const lapack_complex_double *x, lapack_int incx)
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_zsp_trans ( int  matrix_order,
char  uplo,
lapack_int  n,
const lapack_complex_double in,
lapack_complex_double out 
)

Definition at line 40 of file lapacke_zsp_trans.c.

43 {
44  LAPACKE_ztp_trans( matrix_order, uplo, 'n', n, in, out );
45 }
void LAPACKE_ztp_trans(int matrix_order, char uplo, char diag, lapack_int n, const lapack_complex_double *in, lapack_complex_double *out)

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_zst_nancheck ( lapack_int  n,
const lapack_complex_double d,
const lapack_complex_double e 
)

Definition at line 37 of file lapacke_zst_nancheck.c.

40 {
41  return LAPACKE_z_nancheck( n, d, 1 )
42  || LAPACKE_z_nancheck( n-1, e, 1 );
43 }
lapack_logical LAPACKE_z_nancheck(lapack_int n, const lapack_complex_double *x, lapack_int incx)

Here is the call graph for this function:

lapack_logical LAPACKE_zsy_nancheck ( int  matrix_order,
char  uplo,
lapack_int  n,
const lapack_complex_double a,
lapack_int  lda 
)

Definition at line 37 of file lapacke_zsy_nancheck.c.

41 {
42  return LAPACKE_ztr_nancheck( matrix_order, uplo, 'n', n, a, lda );
43 }
lapack_logical LAPACKE_ztr_nancheck(int matrix_order, char uplo, char diag, lapack_int n, const lapack_complex_double *a, lapack_int lda)

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_zsy_trans ( int  matrix_order,
char  uplo,
lapack_int  n,
const lapack_complex_double in,
lapack_int  ldin,
lapack_complex_double out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_zsy_trans.c.

43 {
44  LAPACKE_ztr_trans( matrix_order, uplo, 'n', n, in, ldin, out, ldout );
45 }
void LAPACKE_ztr_trans(int matrix_order, char uplo, char diag, lapack_int n, const lapack_complex_double *in, lapack_int ldin, lapack_complex_double *out, lapack_int ldout)

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_ztb_nancheck ( int  matrix_order,
char  uplo,
char  diag,
lapack_int  n,
lapack_int  kd,
const lapack_complex_double ab,
lapack_int  ldab 
)

Definition at line 37 of file lapacke_ztb_nancheck.c.

41 {
42  lapack_logical colmaj, upper, unit;
43 
44  if( ab == NULL ) return (lapack_logical) 0;
45 
46  colmaj = ( matrix_order == LAPACK_COL_MAJOR );
47  upper = LAPACKE_lsame( uplo, 'u' );
48  unit = LAPACKE_lsame( diag, 'u' );
49 
50  if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
51  ( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
52  ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
53  /* Just exit if any of input parameters are wrong */
54  return (lapack_logical) 0;
55  }
56 
57  if( unit ) {
58  /* Unit case, diagonal should be excluded from the check for NaN. */
59  if( colmaj ) {
60  if( upper ) {
61  return LAPACKE_zgb_nancheck( matrix_order, n-1, n-1, 0, kd-1,
62  &ab[ldab], ldab );
63  } else {
64  return LAPACKE_zgb_nancheck( matrix_order, n-1, n-1, kd-1, 0,
65  &ab[1], ldab );
66  }
67  } else {
68  if( upper ) {
69  return LAPACKE_zgb_nancheck( matrix_order, n-1, n-1, 0, kd-1,
70  &ab[1], ldab );
71  } else {
72  return LAPACKE_zgb_nancheck( matrix_order, n-1, n-1, kd-1, 0,
73  &ab[ldab], ldab );
74  }
75  }
76  } else {
77  /* Non-unit case */
78  if( upper ) {
79  return LAPACKE_zgb_nancheck( matrix_order, n, n, 0, kd, ab, ldab );
80  } else {
81  return LAPACKE_zgb_nancheck( matrix_order, n, n, kd, 0, ab, ldab );
82  }
83  }
84 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
lapack_logical LAPACKE_zgb_nancheck(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const lapack_complex_double *ab, lapack_int ldab)
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_ztb_trans ( int  matrix_order,
char  uplo,
char  diag,
lapack_int  n,
lapack_int  kd,
const lapack_complex_double in,
lapack_int  ldin,
lapack_complex_double out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_ztb_trans.c.

44 {
45  lapack_logical colmaj, upper, unit;
46 
47  if( in == NULL || out == NULL ) return;
48 
49  colmaj = ( matrix_order == LAPACK_COL_MAJOR );
50  upper = LAPACKE_lsame( uplo, 'u' );
51  unit = LAPACKE_lsame( diag, 'u' );
52 
53  if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
54  ( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
55  ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
56  /* Just exit if any of input parameters are wrong */
57  return;
58  }
59 
60  if( unit ) {
61  /* Unit case, diagonal excluded from transposition */
62  if( colmaj ) {
63  if( upper ) {
64  LAPACKE_zgb_trans( matrix_order, n-1, n-1, 0, kd-1,
65  &in[ldin], ldin, &out[1], ldout );
66  } else {
67  LAPACKE_zgb_trans( matrix_order, n-1, n-1, kd-1, 0,
68  &in[1], ldin, &out[ldout], ldout );
69  }
70  } else {
71  if( upper ) {
72  LAPACKE_zgb_trans( matrix_order, n-1, n-1, 0, kd-1,
73  &in[1], ldin, &out[ldout], ldout );
74  } else {
75  LAPACKE_zgb_trans( matrix_order, n-1, n-1, kd-1, 0,
76  &in[ldin], ldin, &out[1], ldout );
77  }
78  }
79  } else {
80  /* Non-unit case */
81  if( upper ) {
82  LAPACKE_zgb_trans( matrix_order, n, n, 0, kd, in, ldin, out,
83  ldout );
84  } else {
85  LAPACKE_zgb_trans( matrix_order, n, n, kd, 0, in, ldin, out,
86  ldout );
87  }
88  }
89 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
void LAPACKE_zgb_trans(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const lapack_complex_double *in, lapack_int ldin, lapack_complex_double *out, lapack_int ldout)
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_ztf_nancheck ( int  matrix_order,
char  transr,
char  uplo,
char  diag,
lapack_int  n,
const lapack_complex_double a 
)

Definition at line 37 of file lapacke_ztf_nancheck.c.

41 {
42  lapack_int len;
43  lapack_logical rowmaj, ntr, lower, unit;
44  lapack_int n1, n2, k;
45 
46  if( a == NULL ) return (lapack_logical) 0;
47 
48  rowmaj = (matrix_order == LAPACK_ROW_MAJOR);
49  ntr = LAPACKE_lsame( transr, 'n' );
50  lower = LAPACKE_lsame( uplo, 'l' );
51  unit = LAPACKE_lsame( diag, 'u' );
52 
53  if( ( !rowmaj && ( matrix_order != LAPACK_COL_MAJOR ) ) ||
54  ( !ntr && !LAPACKE_lsame( transr, 't' )
55  && !LAPACKE_lsame( transr, 'c' ) ) ||
56  ( !lower && !LAPACKE_lsame( uplo, 'u' ) ) ||
57  ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
58  /* Just exit if any of input parameters are wrong */
59  return (lapack_logical) 0;
60  }
61 
62  if( unit ) {
63  /* Unit case, diagonal should be excluded from the check for NaN.
64  * Decoding RFP and checking both triangulars and rectangular
65  * for NaNs.
66  */
67  if( lower ) {
68  n2 = n / 2;
69  n1 = n - n2;
70  } else {
71  n1 = n / 2;
72  n2 = n - n1;
73  }
74  if( n % 2 == 1 ) {
75  /* N is odd */
76  if( ( rowmaj || ntr ) && !( rowmaj && ntr ) ) {
77  /* N is odd and ( TRANSR = 'N' .XOR. ROWMAJOR) */
78  if( lower ) {
79  return LAPACKE_ztr_nancheck( LAPACK_ROW_MAJOR, 'l', 'u',
80  n1, &a[0], n )
82  &a[n1], n )
84  n2, &a[n], n );
85  } else {
86  return LAPACKE_ztr_nancheck( LAPACK_ROW_MAJOR, 'l', 'u',
87  n1, &a[n2], n )
89  &a[0], n )
91  n2, &a[n1], n );
92  }
93  } else {
94  /* N is odd and
95  * ( ( TRANSR = 'C' || TRANSR = 'T' ) .XOR. COLMAJOR )
96  */
97  if( lower ) {
98  return LAPACKE_ztr_nancheck( LAPACK_ROW_MAJOR, 'u', 'u',
99  n1, &a[0], n1 )
101  &a[1], n1 )
103  n2, &a[1], n1 );
104  } else {
105  return LAPACKE_ztr_nancheck( LAPACK_ROW_MAJOR, 'u', 'u',
106  n1, &a[(size_t)n2*n2], n2 )
108  &a[0], n2 )
110  n2, &a[(size_t)n1*n2], n2 );
111  }
112  }
113  } else {
114  /* N is even */
115  k = n / 2;
116  if( ( rowmaj || ntr ) && !( rowmaj && ntr ) ) {
117  /* N is even and ( TRANSR = 'N' .XOR. ROWMAJOR) */
118  if( lower ) {
119  return LAPACKE_ztr_nancheck( LAPACK_ROW_MAJOR, 'l', 'u',
120  k, &a[1], n+1 )
122  &a[k+1], n+1 )
124  k, &a[0], n+1 );
125  } else {
126  return LAPACKE_ztr_nancheck( LAPACK_ROW_MAJOR, 'l', 'u',
127  k, &a[k+1], n+1 )
129  &a[0], n+1 )
131  k, &a[k], n+1 );
132  }
133  } else {
134  /* N is even and
135  ( ( TRANSR = 'C' || TRANSR = 'T' ) .XOR. COLMAJOR ) */
136  if( lower ) {
137  return LAPACKE_ztr_nancheck( LAPACK_ROW_MAJOR, 'u', 'u',
138  k, &a[k], k )
140  &a[(size_t)k*(k+1)], k )
142  k, &a[0], k );
143  } else {
144  return LAPACKE_ztr_nancheck( LAPACK_ROW_MAJOR, 'u', 'u',
145  k, &a[(size_t)k*(k+1)], k )
147  &a[0], k )
149  k, &a[(size_t)k*k], k );
150  }
151  }
152  }
153  } else {
154  /* Non-unit case - just check whole array for NaNs. */
155  len = n*(n+1)/2;
156  return LAPACKE_zge_nancheck( LAPACK_COL_MAJOR, len, 1, a, len );
157  }
158 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
lapack_logical LAPACKE_zge_nancheck(int matrix_order, lapack_int m, lapack_int n, const lapack_complex_double *a, lapack_int lda)
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
lapack_logical LAPACKE_ztr_nancheck(int matrix_order, char uplo, char diag, lapack_int n, const lapack_complex_double *a, lapack_int lda)
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_ztf_trans ( int  matrix_order,
char  transr,
char  uplo,
char  diag,
lapack_int  n,
const lapack_complex_double in,
lapack_complex_double out 
)

Definition at line 41 of file lapacke_ztf_trans.c.

44 {
45  lapack_int row, col;
46  lapack_logical rowmaj, ntr, lower, unit;
47 
48  if( in == NULL || out == NULL ) return ;
49 
50  rowmaj = (matrix_order == LAPACK_ROW_MAJOR);
51  ntr = LAPACKE_lsame( transr, 'n' );
52  lower = LAPACKE_lsame( uplo, 'l' );
53  unit = LAPACKE_lsame( diag, 'u' );
54 
55  if( ( !rowmaj && ( matrix_order != LAPACK_COL_MAJOR ) ) ||
56  ( !ntr && !LAPACKE_lsame( transr, 't' ) &&
57  !LAPACKE_lsame( transr, 'c' ) ) ||
58  ( !lower && !LAPACKE_lsame( uplo, 'u' ) ) ||
59  ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
60  /* Just exit if input parameters are wrong */
61  return;
62  }
63 
64  /* Determine parameters of array representing RFP */
65  if( ntr ) {
66  if( n%2 == 0 ) {
67  row = n + 1;
68  col = n / 2;
69  } else {
70  row = n;
71  col = (n + 1) / 2;
72  }
73  } else {
74  if( n%2 == 0 ) {
75  row = n / 2;
76  col = n + 1;
77  } else {
78  row = (n + 1) / 2;
79  col = n;
80  }
81  }
82 
83  /* Perform conversion: */
84  if( rowmaj ) {
85  LAPACKE_zge_trans( LAPACK_ROW_MAJOR, row, col, in, col, out, row );
86  } else {
87  LAPACKE_zge_trans( LAPACK_COL_MAJOR, row, col, in, row, out, col );
88  }
89 }
#define lapack_logical
Definition: lapacke.h:51
void LAPACKE_zge_trans(int matrix_order, lapack_int m, lapack_int n, const lapack_complex_double *in, lapack_int ldin, lapack_complex_double *out, lapack_int ldout)
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_ztp_nancheck ( int  matrix_order,
char  uplo,
char  diag,
lapack_int  n,
const lapack_complex_double ap 
)

Definition at line 40 of file lapacke_ztp_nancheck.c.

43 {
44  lapack_int i, len;
45  lapack_logical colmaj, upper, unit;
46 
47  if( ap == NULL ) return (lapack_logical) 0;
48 
49  colmaj = ( matrix_order == LAPACK_COL_MAJOR );
50  upper = LAPACKE_lsame( uplo, 'u' );
51  unit = LAPACKE_lsame( diag, 'u' );
52 
53  if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
54  ( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
55  ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
56  /* Just exit if any of input parameters are wrong */
57  return (lapack_logical) 0;
58  }
59 
60  if( unit ) {
61  /* Unit case, diagonal should be excluded from the check for NaN. */
62 
63  /* Since col_major upper and row_major lower are equal,
64  * and col_major lower and row_major upper are equals too -
65  * using one code for equal cases. XOR( colmaj, upper )
66  */
67  if( ( colmaj || upper ) && !( colmaj && upper ) ) {
68  for( i = 1; i < n; i++ )
69  if( LAPACKE_z_nancheck( i, &ap[ ((size_t)i+1)*i/2 ], 1 ) )
70  return (lapack_logical) 1;
71  } else {
72  for( i = 0; i < n-1; i++ )
73  if( LAPACKE_z_nancheck( n-i-1,
74  &ap[ (size_t)i+1 + i*((size_t)2*n-i+1)/2 ], 1 ) )
75  return (lapack_logical) 1;
76  }
77  return (lapack_logical) 0;
78  } else {
79  /* Non-unit case - just check whole array for NaNs. */
80  len = n*(n+1)/2;
81  return LAPACKE_z_nancheck( len, ap, 1 );
82  }
83 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
lapack_logical LAPACKE_z_nancheck(lapack_int n, const lapack_complex_double *x, lapack_int incx)
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_ztp_trans ( int  matrix_order,
char  uplo,
char  diag,
lapack_int  n,
const lapack_complex_double in,
lapack_complex_double out 
)

Definition at line 40 of file lapacke_ztp_trans.c.

43 {
44  lapack_int i, j, st;
45  lapack_logical colmaj, upper, unit;
46 
47  if( in == NULL || out == NULL ) return ;
48 
49  colmaj = ( matrix_order == LAPACK_COL_MAJOR );
50  upper = LAPACKE_lsame( uplo, 'u' );
51  unit = LAPACKE_lsame( diag, 'u' );
52 
53  if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
54  ( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
55  ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
56  /* Just exit if any of input parameters are wrong */
57  return;
58  }
59  if( unit ) {
60  /* If unit, then don't touch diagonal, start from 1st column or row */
61  st = 1;
62  } else {
63  /* If non-unit, then check diagonal also, starting from [0,0] */
64  st = 0;
65  }
66 
67  /* Perform conversion:
68  * Since col_major upper and row_major lower are equal,
69  * and col_major lower and row_major upper are equals too -
70  * using one code for equal cases. XOR( colmaj, upper )
71  */
72  if( ( colmaj || upper ) && !( colmaj && upper ) ) {
73  for( j = st; j < n; j++ ) {
74  for( i = 0; i < j+1-st; i++ ) {
75  out[ j-i + (i*(2*n-i+1))/2 ] = in[ ((j+1)*j)/2 + i ];
76  }
77  }
78  } else {
79  for( j = 0; j < n-st; j++ ) {
80  for( i = j+st; i < n; i++ ) {
81  out[ j + ((i+1)*i)/2 ] = in[ (j*(2*n-j+1))/2 + i-j ];
82  }
83  }
84  }
85 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

lapack_logical LAPACKE_ztr_nancheck ( int  matrix_order,
char  uplo,
char  diag,
lapack_int  n,
const lapack_complex_double a,
lapack_int  lda 
)

Definition at line 37 of file lapacke_ztr_nancheck.c.

41 {
42  lapack_int i, j, st;
43  lapack_logical colmaj, lower, unit;
44 
45  if( a == NULL ) return (lapack_logical) 0;
46 
47  colmaj = ( matrix_order == LAPACK_COL_MAJOR );
48  lower = LAPACKE_lsame( uplo, 'l' );
49  unit = LAPACKE_lsame( diag, 'u' );
50 
51  if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
52  ( !lower && !LAPACKE_lsame( uplo, 'u' ) ) ||
53  ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
54  /* Just exit if any of input parameters are wrong */
55  return (lapack_logical) 0;
56  }
57  if( unit ) {
58  /* If unit, then don't touch diagonal, start from 1st column or row */
59  st = 1;
60  } else {
61  /* If non-unit, then check diagonal also, starting from [0,0] */
62  st = 0;
63  }
64 
65  /* Since col_major upper and row_major lower are equal,
66  * and col_major lower and row_major upper are equals too -
67  * using one code for equal cases. XOR( colmaj, upper )
68  */
69  if( ( colmaj || lower ) && !( colmaj && lower ) ) {
70  for( j = st; j < n; j++ ) {
71  for( i = 0; i < MIN( j+1-st, lda ); i++ ) {
72  if( LAPACK_ZISNAN( a[i+j*lda] ) )
73  return (lapack_logical) 1;
74  }
75  }
76  } else {
77  for( j = 0; j < n-st; j++ ) {
78  for( i = j+st; i < MIN( n, lda ); i++ ) {
79  if( LAPACK_ZISNAN( a[i+j*lda] ) )
80  return (lapack_logical) 1;
81  }
82  }
83  }
84  return (lapack_logical) 0;
85 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
#define LAPACK_ZISNAN(x)
#define MIN(x, y)
Definition: lapacke_utils.h:50
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function:

void LAPACKE_ztr_trans ( int  matrix_order,
char  uplo,
char  diag,
lapack_int  n,
const lapack_complex_double in,
lapack_int  ldin,
lapack_complex_double out,
lapack_int  ldout 
)

Definition at line 40 of file lapacke_ztr_trans.c.

43 {
44  lapack_int i, j, st;
45  lapack_logical colmaj, lower, unit;
46 
47  if( in == NULL || out == NULL ) return ;
48 
49  colmaj = ( matrix_order == LAPACK_COL_MAJOR );
50  lower = LAPACKE_lsame( uplo, 'l' );
51  unit = LAPACKE_lsame( diag, 'u' );
52 
53  if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
54  ( !lower && !LAPACKE_lsame( uplo, 'u' ) ) ||
55  ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
56  /* Just exit if any of input parameters are wrong */
57  return;
58  }
59  if( unit ) {
60  /* If unit, then don't touch diagonal, start from 1st column or row */
61  st = 1;
62  } else {
63  /* If non-unit, then check diagonal also, starting from [0,0] */
64  st = 0;
65  }
66 
67  /* Perform conversion:
68  * Since col_major upper and row_major lower are equal,
69  * and col_major lower and row_major upper are equals too -
70  * using one code for equal cases. XOR( colmaj, upper )
71  */
72  if( ( colmaj || lower ) && !( colmaj && lower ) ) {
73  for( j = st; j < MIN( n, ldout ); j++ ) {
74  for( i = 0; i < MIN( j+1-st, ldin ); i++ ) {
75  out[ j+i*ldout ] = in[ i+j*ldin ];
76  }
77  }
78  } else {
79  for( j = 0; j < MIN( n-st, ldout ); j++ ) {
80  for( i = j+st; i < MIN( n, ldin ); i++ ) {
81  out[ j+i*ldout ] = in[ i+j*ldin ];
82  }
83  }
84  }
85 }
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
#define MIN(x, y)
Definition: lapacke_utils.h:50
lapack_logical LAPACKE_lsame(char ca, char cb)
Definition: lapacke_lsame.c:36
#define lapack_int
Definition: lapacke.h:47

Here is the call graph for this function:

Here is the caller graph for this function: