LAPACK  3.5.0
LAPACK: Linear Algebra PACKage
 All Classes Files Functions Variables Typedefs Macros
lapacke_utils.h File Reference
#include "lapacke.h"
Include dependency graph for lapacke_utils.h:
This graph shows which files directly or indirectly include this file:

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
error code as a return value instead of the INFO parameter This implementation supports both the ILP64 and LP64 programming and different complex type C99 This implementation includes interfaces for the LAPACK Driver and Computational routines only Product Directories The installation directory of this package has the following compiler names for binaries to be created linked to You may choose the appropriate LP64 ILP64 convenient complex type LAPACKE name and or redefine system malloc free in make inc Several examples of make inc are provided After setting up the make inc
Definition: README:24
#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
set ue cd $ADTTMP cat<< EOF > tmp f Program LinearEquations Implicit none Real j
Definition: xerbla-fortran:9
#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 }
Description ia64 stest out
#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
if("${line}"MATCHES processor) math(EXPR parallel"$
#define MIN(x, y)
Definition: lapacke_utils.h:50
set ue cd $ADTTMP cat<< EOF > tmp f Program LinearEquations Implicit none Real j
Definition: xerbla-fortran:9
#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
set ue cd $ADTTMP cat<< EOF > tmp f Program LinearEquations Implicit none Real j
Definition: xerbla-fortran:9
#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 }
Description ia64 stest out
#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
set ue cd $ADTTMP cat<< EOF > tmp f Program LinearEquations Implicit none Real j
Definition: xerbla-fortran:9
#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 }
Description ia64 stest out
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 }
Description ia64 stest out
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 }
Description ia64 stest 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)

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 }
Description ia64 stest out
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 }
Description ia64 stest 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)
#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 }
Description ia64 stest out
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 }
Description ia64 stest out
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 }
Description ia64 stest 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)

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 }
Description ia64 stest out
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 }
Description ia64 stest out
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 }
Description ia64 stest 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)

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 }
Description ia64 stest out
#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 }
Description ia64 stest out
#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 }
Description ia64 stest out
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
set ue cd $ADTTMP cat<< EOF > tmp f Program LinearEquations Implicit none Real j
Definition: xerbla-fortran:9
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
set ue cd $ADTTMP cat<< EOF > tmp f Program LinearEquations Implicit none Real j
Definition: xerbla-fortran:9
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 }
Description ia64 stest out
#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
set ue cd $ADTTMP cat<< EOF > tmp f Program LinearEquations Implicit none Real j
Definition: xerbla-fortran:9
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
error code as a return value instead of the INFO parameter This implementation supports both the ILP64 and LP64 programming and different complex type C99 This implementation includes interfaces for the LAPACK Driver and Computational routines only Product Directories The installation directory of this package has the following compiler names for binaries to be created linked to You may choose the appropriate LP64 ILP64 convenient complex type LAPACKE name and or redefine system malloc free in make inc Several examples of make inc are provided After setting up the make inc
Definition: README:24
#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
set ue cd $ADTTMP cat<< EOF > tmp f Program LinearEquations Implicit none Real j
Definition: xerbla-fortran:9
#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 }
Description ia64 stest out
#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
if("${line}"MATCHES processor) math(EXPR parallel"$
#define MIN(x, y)
Definition: lapacke_utils.h:50
set ue cd $ADTTMP cat<< EOF > tmp f Program LinearEquations Implicit none Real j
Definition: xerbla-fortran:9
#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
set ue cd $ADTTMP cat<< EOF > tmp f Program LinearEquations Implicit none Real j
Definition: xerbla-fortran:9
#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 }
Description ia64 stest out
#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
set ue cd $ADTTMP cat<< EOF > tmp f Program LinearEquations Implicit none Real j
Definition: xerbla-fortran:9
#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 }
Description ia64 stest out
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 }
Description ia64 stest out
#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)
Description ia64 stest out
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 }
Description ia64 stest out
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 }
Description ia64 stest 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)

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 }
Description ia64 stest out
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)
Description ia64 stest out
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 }
Description ia64 stest out
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 }
Description ia64 stest 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)

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)
Description ia64 stest out
#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 }
Description ia64 stest out
#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 }
Description ia64 stest out
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
set ue cd $ADTTMP cat<< EOF > tmp f Program LinearEquations Implicit none Real j
Definition: xerbla-fortran:9
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
set ue cd $ADTTMP cat<< EOF > tmp f Program LinearEquations Implicit none Real j
Definition: xerbla-fortran:9
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 }
Description ia64 stest out
#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
set ue cd $ADTTMP cat<< EOF > tmp f Program LinearEquations Implicit none Real j
Definition: xerbla-fortran:9
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
error code as a return value instead of the INFO parameter This implementation supports both the ILP64 and LP64 programming and different complex type C99 This implementation includes interfaces for the LAPACK Driver and Computational routines only Product Directories The installation directory of this package has the following compiler names for binaries to be created linked to You may choose the appropriate LP64 ILP64 convenient complex type LAPACKE name and or redefine system malloc free in make inc Several examples of make inc are provided After setting up the make inc
Definition: README:24
#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
set ue cd $ADTTMP cat<< EOF > tmp f Program LinearEquations Implicit none Real j
Definition: xerbla-fortran:9
#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 }
Description ia64 stest out
#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
if("${line}"MATCHES processor) math(EXPR parallel"$
#define MIN(x, y)
Definition: lapacke_utils.h:50
set ue cd $ADTTMP cat<< EOF > tmp f Program LinearEquations Implicit none Real j
Definition: xerbla-fortran:9
#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
set ue cd $ADTTMP cat<< EOF > tmp f Program LinearEquations Implicit none Real j
Definition: xerbla-fortran:9
#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 }
Description ia64 stest out
#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
set ue cd $ADTTMP cat<< EOF > tmp f Program LinearEquations Implicit none Real j
Definition: xerbla-fortran:9
#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)
Description ia64 stest out

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)
Description ia64 stest out
#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 }
Description ia64 stest out
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 }
Description ia64 stest out
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 }
Description ia64 stest 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)

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 }
Description ia64 stest out
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 }
Description ia64 stest out
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 }
Description ia64 stest out
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 }
Description ia64 stest 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)

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 }
Description ia64 stest out
#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)
Description ia64 stest out
#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 }
Description ia64 stest out
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
set ue cd $ADTTMP cat<< EOF > tmp f Program LinearEquations Implicit none Real j
Definition: xerbla-fortran:9
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
set ue cd $ADTTMP cat<< EOF > tmp f Program LinearEquations Implicit none Real j
Definition: xerbla-fortran:9
#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 }
Description ia64 stest out
#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
set ue cd $ADTTMP cat<< EOF > tmp f Program LinearEquations Implicit none Real j
Definition: xerbla-fortran:9
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 8 of file xerbla-c.

9 {
10  if( info < 0 ) {
11  printf( "OVERRIDE SUCCESSFUL override %d in %s\n", -(int) info, name );
12  }
13 }
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
error code as a return value instead of the INFO parameter This implementation supports both the ILP64 and LP64 programming and different complex type C99 This implementation includes interfaces for the LAPACK Driver and Computational routines only Product Directories The installation directory of this package has the following compiler names for binaries to be created linked to You may choose the appropriate LP64 ILP64 convenient complex type LAPACKE name and or redefine system malloc free in make inc Several examples of make inc are provided After setting up the make inc
Definition: README:24
#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
set ue cd $ADTTMP cat<< EOF > tmp f Program LinearEquations Implicit none Real j
Definition: xerbla-fortran:9
#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 }
Description ia64 stest out
#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
if("${line}"MATCHES processor) math(EXPR parallel"$
#define MIN(x, y)
Definition: lapacke_utils.h:50
set ue cd $ADTTMP cat<< EOF > tmp f Program LinearEquations Implicit none Real j
Definition: xerbla-fortran:9
#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
set ue cd $ADTTMP cat<< EOF > tmp f Program LinearEquations Implicit none Real j
Definition: xerbla-fortran:9
#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 }
Description ia64 stest out
#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
set ue cd $ADTTMP cat<< EOF > tmp f Program LinearEquations Implicit none Real j
Definition: xerbla-fortran:9
#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 }
Description ia64 stest out
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 }
Description ia64 stest out
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 }
Description ia64 stest 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)

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 }
Description ia64 stest out
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 }
Description ia64 stest out
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 }
Description ia64 stest out
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 }
Description ia64 stest out
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 }
Description ia64 stest 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)

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 }
Description ia64 stest out
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 }
Description ia64 stest out
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 }
Description ia64 stest 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)

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 }
Description ia64 stest out
#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 }
Description ia64 stest out
#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 }
Description ia64 stest out
#define lapack_logical
Definition: lapacke.h:51
#define LAPACK_COL_MAJOR
Definition: lapacke.h:120
#define LAPACK_ROW_MAJOR
Definition: lapacke.h:119
set ue cd $ADTTMP cat<< EOF > tmp f Program LinearEquations Implicit none Real j
Definition: xerbla-fortran:9
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
set ue cd $ADTTMP cat<< EOF > tmp f Program LinearEquations Implicit none Real j
Definition: xerbla-fortran:9
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 }
Description ia64 stest out
#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
set ue cd $ADTTMP cat<< EOF > tmp f Program LinearEquations Implicit none Real j
Definition: xerbla-fortran:9
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: