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/Subroutines

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)) )

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)) )

Definition at line 63 of file lapacke_utils.h.

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

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)) )

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/Subroutine 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.

{
if( incx == 0 ) return (lapack_logical) LAPACK_CISNAN( x[0] );
inc = ( incx > 0 ) ? incx : -incx ;
for( i = 0; i < n*inc; i+=inc ) {
if( LAPACK_CISNAN( x[i] ) )
return (lapack_logical) 1;
}
return (lapack_logical) 0;
}

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.

{
if( ab == NULL ) return (lapack_logical) 0;
if( matrix_order == LAPACK_COL_MAJOR ) {
for( j = 0; j < n; j++ ) {
for( i = MAX( ku-j, 0 ); i < MIN3( ldab, m+ku-j, kl+ku+1 );
i++ ) {
if( LAPACK_CISNAN( ab[i+(size_t)j*ldab] ) )
return (lapack_logical) 1;
}
}
} else if ( matrix_order == LAPACK_ROW_MAJOR ) {
for( j = 0; j < MIN( n, ldab ); j++ ) {
for( i = MAX( ku-j, 0 ); i < MIN( m+ku-j, kl+ku+1 ); i++ ) {
if( LAPACK_CISNAN( ab[(size_t)i*ldab+j] ) )
return (lapack_logical) 1;
}
}
}
return (lapack_logical) 0;
}

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.

{
if( in == NULL || out == NULL ) return;
if( matrix_order == LAPACK_COL_MAJOR ) {
for( j = 0; j < MIN( ldout, n ); j++ ) {
for( i = MAX( ku-j, 0 ); i < MIN3( ldin, m+ku-j, kl+ku+1 );
i++ ) {
out[(size_t)i*ldout+j] = in[i+(size_t)j*ldin];
}
}
} else if ( matrix_order == LAPACK_ROW_MAJOR ) {
/* TODO: interchange loops for performance.
* This is just reference impemeltation.
*/
for( j = 0; j < MIN( n, ldin ); j++ ) {
for( i = MAX( ku-j, 0 ); i < MIN3( ldout, m+ku-j, kl+ku+1 );
i++ ) {
out[i+(size_t)j*ldout] = in[(size_t)i*ldin+j];
}
}
}
}

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.

{
if( a == NULL ) return (lapack_logical) 0;
if( matrix_order == LAPACK_COL_MAJOR ) {
for( j = 0; j < n; j++ ) {
for( i = 0; i < MIN( m, lda ); i++ ) {
if( LAPACK_CISNAN( a[i+(size_t)j*lda] ) )
return (lapack_logical) 1;
}
}
} else if ( matrix_order == LAPACK_ROW_MAJOR ) {
for( i = 0; i < m; i++ ) {
for( j = 0; j < MIN( n, lda ); j++ ) {
if( LAPACK_CISNAN( a[(size_t)i*lda+j] ) )
return (lapack_logical) 1;
}
}
}
return (lapack_logical) 0;
}
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.

{
lapack_int i, j, x, y;
if( in == NULL || out == NULL ) return;
if( matrix_order == LAPACK_COL_MAJOR ) {
x = n;
y = m;
} else if ( matrix_order == LAPACK_ROW_MAJOR ) {
x = m;
y = n;
} else {
/* Unknown input layout */
return;
}
/* In case of incorrect m, n, ldin or ldout the function does nothing */
for( i = 0; i < MIN( y, ldin ); i++ ) {
for( j = 0; j < MIN( x, ldout ); j++ ) {
out[ (size_t)i*ldout + j ] = in[ (size_t)j*ldin + i ];
}
}
}
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.

{
return LAPACKE_cge_nancheck( matrix_order, m, n, a, 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.

{
LAPACKE_cge_trans( matrix_order, m, n, in, ldin, out, 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.

{
return LAPACKE_c_nancheck( n-1, dl, 1 )
|| LAPACKE_c_nancheck( n , d, 1 )
|| LAPACKE_c_nancheck( n-1, du, 1 );
}

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.

{
if( LAPACKE_lsame( uplo, 'u' ) ) {
return LAPACKE_cgb_nancheck( matrix_order, n, n, 0, kd, ab, ldab );
} else if( LAPACKE_lsame( uplo, 'l' ) ) {
return LAPACKE_cgb_nancheck( matrix_order, n, n, kd, 0, ab, ldab );
}
return (lapack_logical) 0;
}

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.

{
if( LAPACKE_lsame( uplo, 'u' ) ) {
LAPACKE_cgb_trans( matrix_order, n, n, 0, kd, in, ldin, out, ldout );
} else if( LAPACKE_lsame( uplo, 'l' ) ) {
LAPACKE_cgb_trans( matrix_order, n, n, kd, 0, in, ldin, out, ldout );
}
}

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.

{
return LAPACKE_ctr_nancheck( matrix_order, uplo, 'n', n, a, 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.

{
LAPACKE_ctr_trans( matrix_order, uplo, 'n', n, in, ldin, out, 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.

{
lapack_int len = n*(n+1)/2;
return LAPACKE_c_nancheck( len, ap, 1 );
}

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.

{
LAPACKE_ctp_trans( matrix_order, uplo, 'n', n, in, 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.

{
lapack_logical subdiag_nans;
if( a == NULL ) return (lapack_logical) 0;
/* Check subdiagonal first */
if( matrix_order == LAPACK_COL_MAJOR ) {
subdiag_nans = LAPACKE_c_nancheck( n-1, &a[1], lda+1 );
} else if ( matrix_order == LAPACK_ROW_MAJOR ) {
subdiag_nans = LAPACKE_c_nancheck( n-1, &a[lda], lda+1 );
} else {
return (lapack_logical) 0;
}
/* Check upper triangular if subdiagonal has no NaNs. */
return subdiag_nans || LAPACKE_ctr_nancheck( matrix_order, 'u', 'n',
n, a, lda);
}

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.

{
if( in == NULL || out == NULL ) return;
/* Convert subdiagonal first */
if( matrix_order == LAPACK_COL_MAJOR ) {
LAPACKE_cge_trans( LAPACK_COL_MAJOR, 1, n-1, &in[1], ldin+1,
&out[ldout], ldout+1 );
} else if ( matrix_order == LAPACK_ROW_MAJOR ) {
LAPACKE_cge_trans( LAPACK_ROW_MAJOR, n-1, 1, &in[ldin], ldin+1,
&out[1], ldout+1 );
} else {
return;
}
/* Convert upper triangular. */
LAPACKE_ctr_trans( matrix_order, 'u', 'n', n, in, ldin, out, ldout);
}

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.

{
if( LAPACKE_lsame( uplo, 'u' ) ) {
return LAPACKE_cgb_nancheck( matrix_order, n, n, 0, kd, ab, ldab );
} else if( LAPACKE_lsame( uplo, 'l' ) ) {
return LAPACKE_cgb_nancheck( matrix_order, n, n, kd, 0, ab, ldab );
}
return (lapack_logical) 0;
}

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.

{
if( LAPACKE_lsame( uplo, 'u' ) ) {
LAPACKE_cgb_trans( matrix_order, n, n, 0, kd, in, ldin, out, ldout );
} else if( LAPACKE_lsame( uplo, 'l' ) ) {
LAPACKE_cgb_trans( matrix_order, n, n, kd, 0, in, ldin, out, ldout );
}
}

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.

{
lapack_int len = n*(n+1)/2;
return LAPACKE_c_nancheck( len, a, 1 );
}

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.

{
LAPACKE_ctf_trans( matrix_order, transr, uplo, 'n', n, in, 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.

{
return LAPACKE_ctr_nancheck( matrix_order, uplo, 'n', n, a, 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.

{
LAPACKE_ctr_trans( matrix_order, uplo, 'n', n, in, ldin, out, 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.

{
lapack_int len = n*(n+1)/2;
return LAPACKE_c_nancheck( len, ap, 1 );
}

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.

{
LAPACKE_ctp_trans( matrix_order, uplo, 'n', n, in, 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.

{
return LAPACKE_s_nancheck( n, d, 1 )
|| LAPACKE_c_nancheck( n-1, e, 1 );
}

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.

{
lapack_int len = n*(n+1)/2;
return LAPACKE_c_nancheck( len, ap, 1 );
}

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.

{
LAPACKE_ctp_trans( matrix_order, uplo, 'n', n, in, 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.

{
return LAPACKE_c_nancheck( n, d, 1 )
|| LAPACKE_c_nancheck( n-1, e, 1 );
}

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.

{
return LAPACKE_ctr_nancheck( matrix_order, uplo, 'n', n, a, 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.

{
LAPACKE_ctr_trans( matrix_order, uplo, 'n', n, in, ldin, out, 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.

{
lapack_logical colmaj, upper, unit;
if( ab == NULL ) return (lapack_logical) 0;
colmaj = ( matrix_order == LAPACK_COL_MAJOR );
upper = LAPACKE_lsame( uplo, 'u' );
unit = LAPACKE_lsame( diag, 'u' );
if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
/* Just exit if any of input parameters are wrong */
return (lapack_logical) 0;
}
if( unit ) {
/* Unit case, diagonal should be excluded from the check for NaN. */
if( colmaj ) {
if( upper ) {
return LAPACKE_cgb_nancheck( matrix_order, n-1, n-1, 0, kd-1,
&ab[ldab], ldab );
} else {
return LAPACKE_cgb_nancheck( matrix_order, n-1, n-1, kd-1, 0,
&ab[1], ldab );
}
} else {
if( upper ) {
return LAPACKE_cgb_nancheck( matrix_order, n-1, n-1, 0, kd-1,
&ab[1], ldab );
} else {
return LAPACKE_cgb_nancheck( matrix_order, n-1, n-1, kd-1, 0,
&ab[ldab], ldab );
}
}
} else {
/* Non-unit case */
if( upper ) {
return LAPACKE_cgb_nancheck( matrix_order, n, n, 0, kd, ab, ldab );
} else {
return LAPACKE_cgb_nancheck( matrix_order, n, n, kd, 0, ab, ldab );
}
}
}

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.

{
lapack_logical colmaj, upper, unit;
if( in == NULL || out == NULL ) return;
colmaj = ( matrix_order == LAPACK_COL_MAJOR );
upper = LAPACKE_lsame( uplo, 'u' );
unit = LAPACKE_lsame( diag, 'u' );
if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
/* Just exit if any of input parameters are wrong */
return;
}
if( unit ) {
/* Unit case, diagonal excluded from transposition */
if( colmaj ) {
if( upper ) {
LAPACKE_cgb_trans( matrix_order, n-1, n-1, 0, kd-1,
&in[ldin], ldin, &out[1], ldout );
} else {
LAPACKE_cgb_trans( matrix_order, n-1, n-1, kd-1, 0,
&in[1], ldin, &out[ldout], ldout );
}
} else {
if( upper ) {
LAPACKE_cgb_trans( matrix_order, n-1, n-1, 0, kd-1,
&in[1], ldin, &out[ldout], ldout );
} else {
LAPACKE_cgb_trans( matrix_order, n-1, n-1, kd-1, 0,
&in[ldin], ldin, &out[1], ldout );
}
}
} else {
/* Non-unit case */
if( upper ) {
LAPACKE_cgb_trans( matrix_order, n, n, 0, kd, in, ldin, out,
ldout );
} else {
LAPACKE_cgb_trans( matrix_order, n, n, kd, 0, in, ldin, out,
ldout );
}
}
}

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.

{
lapack_logical rowmaj, ntr, lower, unit;
lapack_int n1, n2, k;
if( a == NULL ) return (lapack_logical) 0;
rowmaj = (matrix_order == LAPACK_ROW_MAJOR);
ntr = LAPACKE_lsame( transr, 'n' );
lower = LAPACKE_lsame( uplo, 'l' );
unit = LAPACKE_lsame( diag, 'u' );
if( ( !rowmaj && ( matrix_order != LAPACK_COL_MAJOR ) ) ||
( !ntr && !LAPACKE_lsame( transr, 't' )
&& !LAPACKE_lsame( transr, 'c' ) ) ||
( !lower && !LAPACKE_lsame( uplo, 'u' ) ) ||
( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
/* Just exit if any of input parameters are wrong */
return (lapack_logical) 0;
}
if( unit ) {
/* Unit case, diagonal should be excluded from the check for NaN.
* Decoding RFP and checking both triangulars and rectangular
* for NaNs.
*/
if( lower ) {
n2 = n / 2;
n1 = n - n2;
} else {
n1 = n / 2;
n2 = n - n1;
}
if( n % 2 == 1 ) {
/* N is odd */
if( ( rowmaj || ntr ) && !( rowmaj && ntr ) ) {
/* N is odd and ( TRANSR = 'N' .XOR. ROWMAJOR) */
if( lower ) {
n1, &a[0], n )
&a[n1], n )
n2, &a[n], n );
} else {
n1, &a[n2], n )
&a[0], n )
n2, &a[n1], n );
}
} else {
/* N is odd and
( ( TRANSR = 'C' || TRANSR = 'T' ) .XOR. COLMAJOR ) */
if( lower ) {
n1, &a[0], n1 )
&a[1], n1 )
n2, &a[1], n1 );
} else {
n1, &a[(size_t)n2*n2], n2 )
&a[0], n2 )
n2, &a[(size_t)n1*n2], n2 );
}
}
} else {
/* N is even */
k = n / 2;
if( ( rowmaj || ntr ) && !( rowmaj && ntr ) ) {
/* N is even and ( TRANSR = 'N' .XOR. ROWMAJOR) */
if( lower ) {
k, &a[1], n+1 )
&a[k+1], n+1 )
k, &a[0], n+1 );
} else {
k, &a[k+1], n+1 )
&a[0], n+1 )
k, &a[k], n+1 );
}
} else {
/* N is even and
( ( TRANSR = 'C' || TRANSR = 'T' ) .XOR. COLMAJOR ) */
if( lower ) {
k, &a[k], k )
&a[(size_t)k*(k+1)], k )
k, &a[0], k );
} else {
k, &a[(size_t)k*(k+1)], k )
&a[0], k )
k, &a[(size_t)k*k], k );
}
}
}
} else {
/* Non-unit case - just check whole array for NaNs. */
len = n*(n+1)/2;
return LAPACKE_cge_nancheck( LAPACK_COL_MAJOR, len, 1, a, len );
}
}

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.

{
lapack_int row, col;
lapack_logical rowmaj, ntr, lower, unit;
if( in == NULL || out == NULL ) return ;
rowmaj = (matrix_order == LAPACK_ROW_MAJOR);
ntr = LAPACKE_lsame( transr, 'n' );
lower = LAPACKE_lsame( uplo, 'l' );
unit = LAPACKE_lsame( diag, 'u' );
if( ( !rowmaj && ( matrix_order != LAPACK_COL_MAJOR ) ) ||
( !ntr && !LAPACKE_lsame( transr, 't' ) &&
!LAPACKE_lsame( transr, 'c' ) ) ||
( !lower && !LAPACKE_lsame( uplo, 'u' ) ) ||
( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
/* Just exit if input parameters are wrong */
return;
}
/* Determine parameters of array representing RFP */
if( ntr ) {
if( n%2 == 0 ) {
row = n + 1;
col = n / 2;
} else {
row = n;
col = (n + 1) / 2;
}
} else {
if( n%2 == 0 ) {
row = n / 2;
col = n + 1;
} else {
row = (n + 1) / 2;
col = n;
}
}
/* Perform conversion: */
if( rowmaj ) {
LAPACKE_cge_trans( LAPACK_ROW_MAJOR, row, col, in, col, out, row );
} else {
LAPACKE_cge_trans( LAPACK_COL_MAJOR, row, col, in, row, out, col );
}
}

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.

{
lapack_int i, len;
lapack_logical colmaj, upper, unit;
if( ap == NULL ) return (lapack_logical) 0;
colmaj = ( matrix_order == LAPACK_COL_MAJOR );
upper = LAPACKE_lsame( uplo, 'u' );
unit = LAPACKE_lsame( diag, 'u' );
if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
/* Just exit if any of input parameters are wrong */
return (lapack_logical) 0;
}
if( unit ) {
/* Unit case, diagonal should be excluded from the check for NaN. */
/* Since col_major upper and row_major lower are equal,
* and col_major lower and row_major upper are equals too -
* using one code for equal cases. XOR( colmaj, upper )
*/
if( ( colmaj || upper ) && !( colmaj && upper ) ) {
for( i = 1; i < n; i++ )
if( LAPACKE_c_nancheck( i, &ap[ ((size_t)i+1)*i/2 ], 1 ) )
return (lapack_logical) 1;
} else {
for( i = 0; i < n-1; i++ )
if( LAPACKE_c_nancheck( n-i-1,
&ap[ (size_t)i+1 + i*((size_t)2*n-i+1)/2 ], 1 ) )
return (lapack_logical) 1;
}
return (lapack_logical) 0;
} else {
/* Non-unit case - just check whole array for NaNs. */
len = n*(n+1)/2;
return LAPACKE_c_nancheck( len, ap, 1 );
}
}

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.

{
lapack_int i, j, st;
lapack_logical colmaj, upper, unit;
if( in == NULL || out == NULL ) return ;
colmaj = ( matrix_order == LAPACK_COL_MAJOR );
upper = LAPACKE_lsame( uplo, 'u' );
unit = LAPACKE_lsame( diag, 'u' );
if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
/* Just exit if any of input parameters are wrong */
return;
}
if( unit ) {
/* If unit, then don't touch diagonal, start from 1st column or row */
st = 1;
} else {
/* If non-unit, then check diagonal also, starting from [0,0] */
st = 0;
}
/* Perform conversion:
* Since col_major upper and row_major lower are equal,
* and col_major lower and row_major upper are equals too -
* using one code for equal cases. XOR( colmaj, upper )
*/
if( ( colmaj || upper ) && !( colmaj && upper ) ) {
for( j = st; j < n; j++ ) {
for( i = 0; i < j+1-st; i++ ) {
out[ j-i + (i*(2*n-i+1))/2 ] = in[ ((j+1)*j)/2 + i ];
}
}
} else {
for( j = 0; j < n-st; j++ ) {
for( i = j+st; i < n; i++ ) {
out[ j + ((i+1)*i)/2 ] = in[ (j*(2*n-j+1))/2 + i-j ];
}
}
}
}

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.

{
lapack_int i, j, st;
lapack_logical colmaj, lower, unit;
if( a == NULL ) return (lapack_logical) 0;
colmaj = ( matrix_order == LAPACK_COL_MAJOR );
lower = LAPACKE_lsame( uplo, 'l' );
unit = LAPACKE_lsame( diag, 'u' );
if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
( !lower && !LAPACKE_lsame( uplo, 'u' ) ) ||
( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
/* Just exit if any of input parameters are wrong */
return (lapack_logical) 0;
}
if( unit ) {
/* If unit, then don't touch diagonal, start from 1st column or row */
st = 1;
} else {
/* If non-unit, then check diagonal also, starting from [0,0] */
st = 0;
}
/* Since col_major upper and row_major lower are equal,
* and col_major lower and row_major upper are equals too -
* using one code for equal cases. XOR( colmaj, upper )
*/
if( ( colmaj || lower ) && !( colmaj && lower ) ) {
for( j = st; j < n; j++ ) {
for( i = 0; i < MIN( j+1-st, lda ); i++ ) {
if( LAPACK_CISNAN( a[i+j*lda] ) )
return (lapack_logical) 1;
}
}
} else {
for( j = 0; j < n-st; j++ ) {
for( i = j+st; i < MIN( n, lda ); i++ ) {
if( LAPACK_CISNAN( a[i+j*lda] ) )
return (lapack_logical) 1;
}
}
}
return (lapack_logical) 0;
}

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.

{
lapack_int i, j, st;
lapack_logical colmaj, lower, unit;
if( in == NULL || out == NULL ) return ;
colmaj = ( matrix_order == LAPACK_COL_MAJOR );
lower = LAPACKE_lsame( uplo, 'l' );
unit = LAPACKE_lsame( diag, 'u' );
if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
( !lower && !LAPACKE_lsame( uplo, 'u' ) ) ||
( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
/* Just exit if any of input parameters are wrong */
return;
}
if( unit ) {
/* If unit, then don't touch diagonal, start from 1st column or row */
st = 1;
} else {
/* If non-unit, then check diagonal also, starting from [0,0] */
st = 0;
}
/* Perform conversion:
* Since col_major upper and row_major lower are equal,
* and col_major lower and row_major upper are equals too -
* using one code for equal cases. XOR( colmaj, upper )
*/
if( ( colmaj || lower ) && !( colmaj && lower ) ) {
for( j = st; j < MIN( n, ldout ); j++ ) {
for( i = 0; i < MIN( j+1-st, ldin ); i++ ) {
out[ j+i*ldout ] = in[ i+j*ldin ];
}
}
} else {
for( j = 0; j < MIN( n-st, ldout ); j++ ) {
for( i = j+st; i < MIN( n, ldin ); i++ ) {
out[ j+i*ldout ] = in[ i+j*ldin ];
}
}
}
}

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.

{
if( incx == 0 ) return (lapack_logical) LAPACK_DISNAN( x[0] );
inc = ( incx > 0 ) ? incx : -incx ;
for( i = 0; i < n*inc; i+=inc ) {
if( LAPACK_DISNAN( x[i] ) )
return (lapack_logical) 1;
}
return (lapack_logical) 0;
}
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.

{
if( ab == NULL ) return (lapack_logical) 0;
if( matrix_order == LAPACK_COL_MAJOR ) {
for( j = 0; j < n; j++ ) {
for( i = MAX( ku-j, 0 ); i < MIN3( ldab, m+ku-j, kl+ku+1 );
i++ ) {
if( LAPACK_DISNAN( ab[i+(size_t)j*ldab] ) )
return (lapack_logical) 1;
}
}
} else if ( matrix_order == LAPACK_ROW_MAJOR ) {
for( j = 0; j < MIN( n, ldab ); j++ ) {
for( i = MAX( ku-j, 0 ); i < MIN( m+ku-j, kl+ku+1 ); i++ ) {
if( LAPACK_DISNAN( ab[(size_t)i*ldab+j] ) )
return (lapack_logical) 1;
}
}
}
return (lapack_logical) 0;
}

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.

{
if( in == NULL || out == NULL ) return;
if( matrix_order == LAPACK_COL_MAJOR ) {
for( j = 0; j < MIN( ldout, n ); j++ ) {
for( i = MAX( ku-j, 0 ); i < MIN3( ldin, m+ku-j, kl+ku+1 );
i++ ) {
out[(size_t)i*ldout+j] = in[i+(size_t)j*ldin];
}
}
} else if ( matrix_order == LAPACK_ROW_MAJOR ) {
/* TODO: interchange loops for performance.
* This is just reference impemeltation.
*/
for( j = 0; j < MIN( n, ldin ); j++ ) {
for( i = MAX( ku-j, 0 ); i < MIN3( ldout, m+ku-j, kl+ku+1 );
i++ ) {
out[i+(size_t)j*ldout] = in[(size_t)i*ldin+j];
}
}
}
}

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.

{
if( a == NULL ) return (lapack_logical) 0;
if( matrix_order == LAPACK_COL_MAJOR ) {
for( j = 0; j < n; j++ ) {
for( i = 0; i < MIN( m, lda ); i++ ) {
if( LAPACK_DISNAN( a[i+(size_t)j*lda] ) )
return (lapack_logical) 1;
}
}
} else if ( matrix_order == LAPACK_ROW_MAJOR ) {
for( i = 0; i < m; i++ ) {
for( j = 0; j < MIN( n, lda ); j++ ) {
if( LAPACK_DISNAN( a[(size_t)i*lda+j] ) )
return (lapack_logical) 1;
}
}
}
return (lapack_logical) 0;
}
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.

{
lapack_int i, j, x, y;
if( in == NULL || out == NULL ) return;
if( matrix_order == LAPACK_COL_MAJOR ) {
x = n;
y = m;
} else if ( matrix_order == LAPACK_ROW_MAJOR ) {
x = m;
y = n;
} else {
/* Unknown input layout */
return;
}
/* In case of incorrect m, n, ldin or ldout the function does nothing */
for( i = 0; i < MIN( y, ldin ); i++ ) {
for( j = 0; j < MIN( x, ldout ); j++ ) {
out[ (size_t)i*ldout + j ] = in[ (size_t)j*ldin + i ];
}
}
}
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.

{
return LAPACKE_dge_nancheck( matrix_order, m, n, a, 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.

{
LAPACKE_dge_trans( matrix_order, m, n, in, ldin, out, 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.

{
return LAPACKE_d_nancheck( n-1, dl, 1 )
|| LAPACKE_d_nancheck( n , d, 1 )
|| LAPACKE_d_nancheck( n-1, du, 1 );
}

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.

{
lapack_logical subdiag_nans;
if( a == NULL ) return (lapack_logical) 0;
/* Check subdiagonal first */
if( matrix_order == LAPACK_COL_MAJOR ) {
subdiag_nans = LAPACKE_d_nancheck( n-1, &a[1], lda+1 );
} else if ( matrix_order == LAPACK_ROW_MAJOR ) {
subdiag_nans = LAPACKE_d_nancheck( n-1, &a[lda], lda+1 );
} else {
return (lapack_logical) 0;
}
/* Check upper triangular if subdiagonal has no NaNs. */
return subdiag_nans || LAPACKE_dtr_nancheck( matrix_order, 'u', 'n',
n, a, lda);
}

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.

{
if( in == NULL || out == NULL ) return;
/* Convert subdiagonal first */
if( matrix_order == LAPACK_COL_MAJOR ) {
LAPACKE_dge_trans( LAPACK_COL_MAJOR, 1, n-1, &in[1], ldin+1,
&out[ldout], ldout+1 );
} else if ( matrix_order == LAPACK_ROW_MAJOR ) {
LAPACKE_dge_trans( LAPACK_ROW_MAJOR, n-1, 1, &in[ldin], ldin+1,
&out[1], ldout+1 );
} else {
return;
}
/* Convert upper triangular. */
LAPACKE_dtr_trans( matrix_order, 'u', 'n', n, in, ldin, out, 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.

{
if( LAPACKE_lsame( uplo, 'u' ) ) {
return LAPACKE_dgb_nancheck( matrix_order, n, n, 0, kd, ab, ldab );
} else if( LAPACKE_lsame( uplo, 'l' ) ) {
return LAPACKE_dgb_nancheck( matrix_order, n, n, kd, 0, ab, ldab );
}
return (lapack_logical) 0;
}

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.

{
if( LAPACKE_lsame( uplo, 'u' ) ) {
LAPACKE_dgb_trans( matrix_order, n, n, 0, kd, in, ldin, out, ldout );
} else if( LAPACKE_lsame( uplo, 'l' ) ) {
LAPACKE_dgb_trans( matrix_order, n, n, kd, 0, in, ldin, out, ldout );
}
}

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.

{
lapack_int len = n*(n+1)/2;
return LAPACKE_d_nancheck( len, a, 1 );
}

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.

{
LAPACKE_dtf_trans( matrix_order, transr, uplo, 'n', n, in, 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.

{
return LAPACKE_dtr_nancheck( matrix_order, uplo, 'n', n, a, 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.

{
LAPACKE_dtr_trans( matrix_order, uplo, 'n', n, in, ldin, out, 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.

{
lapack_int len = n*(n+1)/2;
return LAPACKE_d_nancheck( len, ap, 1 );
}

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.

{
LAPACKE_dtp_trans( matrix_order, uplo, 'n', n, in, 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.

{
return LAPACKE_d_nancheck( n, d, 1 )
|| LAPACKE_d_nancheck( n-1, e, 1 );
}

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.

{
if( LAPACKE_lsame( uplo, 'u' ) ) {
return LAPACKE_dgb_nancheck( matrix_order, n, n, 0, kd, ab, ldab );
} else if( LAPACKE_lsame( uplo, 'l' ) ) {
return LAPACKE_dgb_nancheck( matrix_order, n, n, kd, 0, ab, ldab );
}
return (lapack_logical) 0;
}

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.

{
if( LAPACKE_lsame( uplo, 'u' ) ) {
LAPACKE_dgb_trans( matrix_order, n, n, 0, kd, in, ldin, out, ldout );
} else if( LAPACKE_lsame( uplo, 'l' ) ) {
LAPACKE_dgb_trans( matrix_order, n, n, kd, 0, in, ldin, out, ldout );
}
}

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.

{
lapack_int len = n*(n+1)/2;
return LAPACKE_d_nancheck( len, ap, 1 );
}

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.

{
LAPACKE_dtp_trans( matrix_order, uplo, 'n', n, in, 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.

{
return LAPACKE_d_nancheck( n, d, 1 )
|| LAPACKE_d_nancheck( n-1, e, 1 );
}

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.

{
return LAPACKE_dtr_nancheck( matrix_order, uplo, 'n', n, a, 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.

{
LAPACKE_dtr_trans( matrix_order, uplo, 'n', n, in, ldin, out, 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.

{
lapack_logical colmaj, upper, unit;
if( ab == NULL ) return (lapack_logical) 0;
colmaj = ( matrix_order == LAPACK_COL_MAJOR );
upper = LAPACKE_lsame( uplo, 'u' );
unit = LAPACKE_lsame( diag, 'u' );
if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
/* Just exit if any of input parameters are wrong */
return (lapack_logical) 0;
}
if( unit ) {
/* Unit case, diagonal should be excluded from the check for NaN. */
if( colmaj ) {
if( upper ) {
return LAPACKE_dgb_nancheck( matrix_order, n-1, n-1, 0, kd-1,
&ab[ldab], ldab );
} else {
return LAPACKE_dgb_nancheck( matrix_order, n-1, n-1, kd-1, 0,
&ab[1], ldab );
}
} else {
if( upper ) {
return LAPACKE_dgb_nancheck( matrix_order, n-1, n-1, 0, kd-1,
&ab[1], ldab );
} else {
return LAPACKE_dgb_nancheck( matrix_order, n-1, n-1, kd-1, 0,
&ab[ldab], ldab );
}
}
} else {
/* Non-unit case */
if( upper ) {
return LAPACKE_dgb_nancheck( matrix_order, n, n, 0, kd, ab, ldab );
} else {
return LAPACKE_dgb_nancheck( matrix_order, n, n, kd, 0, ab, ldab );
}
}
}

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.

{
lapack_logical colmaj, upper, unit;
if( in == NULL || out == NULL ) return;
colmaj = ( matrix_order == LAPACK_COL_MAJOR );
upper = LAPACKE_lsame( uplo, 'u' );
unit = LAPACKE_lsame( diag, 'u' );
if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
/* Just exit if any of input parameters are wrong */
return;
}
if( unit ) {
/* Unit case, diagonal excluded from transposition */
if( colmaj ) {
if( upper ) {
LAPACKE_dgb_trans( matrix_order, n-1, n-1, 0, kd-1,
&in[ldin], ldin, &out[1], ldout );
} else {
LAPACKE_dgb_trans( matrix_order, n-1, n-1, kd-1, 0,
&in[1], ldin, &out[ldout], ldout );
}
} else {
if( upper ) {
LAPACKE_dgb_trans( matrix_order, n-1, n-1, 0, kd-1,
&in[1], ldin, &out[ldout], ldout );
} else {
LAPACKE_dgb_trans( matrix_order, n-1, n-1, kd-1, 0,
&in[ldin], ldin, &out[1], ldout );
}
}
} else {
/* Non-unit case */
if( upper ) {
LAPACKE_dgb_trans( matrix_order, n, n, 0, kd, in, ldin, out,
ldout );
} else {
LAPACKE_dgb_trans( matrix_order, n, n, kd, 0, in, ldin, out,
ldout );
}
}
}

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.

{
lapack_logical rowmaj, ntr, lower, unit;
lapack_int n1, n2, k;
if( a == NULL ) return (lapack_logical) 0;
rowmaj = (matrix_order == LAPACK_ROW_MAJOR);
ntr = LAPACKE_lsame( transr, 'n' );
lower = LAPACKE_lsame( uplo, 'l' );
unit = LAPACKE_lsame( diag, 'u' );
if( ( !rowmaj && ( matrix_order != LAPACK_COL_MAJOR ) ) ||
( !ntr && !LAPACKE_lsame( transr, 't' )
&& !LAPACKE_lsame( transr, 'c' ) ) ||
( !lower && !LAPACKE_lsame( uplo, 'u' ) ) ||
( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
/* Just exit if any of input parameters are wrong */
return (lapack_logical) 0;
}
if( unit ) {
/* Unit case, diagonal should be excluded from the check for NaN.
* Decoding RFP and checking both triangulars and rectangular
* for NaNs.
*/
if( lower ) {
n2 = n / 2;
n1 = n - n2;
} else {
n1 = n / 2;
n2 = n - n1;
}
if( n % 2 == 1 ) {
/* N is odd */
if( ( rowmaj || ntr ) && !( rowmaj && ntr ) ) {
/* N is odd and ( TRANSR = 'N' .XOR. ROWMAJOR) */
if( lower ) {
n1, &a[0], n )
&a[n1], n )
n2, &a[n], n );
} else {
n1, &a[n2], n )
&a[0], n )
n2, &a[n1], n );
}
} else {
/* N is odd and
( ( TRANSR = 'C' || TRANSR = 'T' ) .XOR. COLMAJOR ) */
if( lower ) {
n1, &a[0], n1 )
&a[1], n1 )
n2, &a[1], n1 );
} else {
n1, &a[(size_t)n2*n2], n2 )
&a[0], n2 )
n2, &a[(size_t)n1*n2], n2 );
}
}
} else {
/* N is even */
k = n / 2;
if( ( rowmaj || ntr ) && !( rowmaj && ntr ) ) {
/* N is even and ( TRANSR = 'N' .XOR. ROWMAJOR) */
if( lower ) {
k, &a[1], n+1 )
&a[k+1], n+1 )
k, &a[0], n+1 );
} else {
k, &a[k+1], n+1 )
&a[0], n+1 )
k, &a[k], n+1 );
}
} else {
/* N is even and
( ( TRANSR = 'C' || TRANSR = 'T' ) .XOR. COLMAJOR ) */
if( lower ) {
k, &a[k], k )
&a[(size_t)k*(k+1)], k )
k, &a[0], k );
} else {
k, &a[(size_t)k*(k+1)], k )
&a[0], k )
k, &a[(size_t)k*k], k );
}
}
}
} else {
/* Non-unit case - just check whole array for NaNs. */
len = n*(n+1)/2;
return LAPACKE_dge_nancheck( LAPACK_COL_MAJOR, len, 1, a, len );
}
}

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.

{
lapack_int row, col;
lapack_logical rowmaj, ntr, lower, unit;
if( in == NULL || out == NULL ) return ;
rowmaj = (matrix_order == LAPACK_ROW_MAJOR);
ntr = LAPACKE_lsame( transr, 'n' );
lower = LAPACKE_lsame( uplo, 'l' );
unit = LAPACKE_lsame( diag, 'u' );
if( ( !rowmaj && ( matrix_order != LAPACK_COL_MAJOR ) ) ||
( !ntr && !LAPACKE_lsame( transr, 't' ) &&
!LAPACKE_lsame( transr, 'c' ) ) ||
( !lower && !LAPACKE_lsame( uplo, 'u' ) ) ||
( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
/* Just exit if input parameters are wrong */
return;
}
/* Determine parameters of array representing RFP */
if( ntr ) {
if( n%2 == 0 ) {
row = n + 1;
col = n / 2;
} else {
row = n;
col = (n + 1) / 2;
}
} else {
if( n%2 == 0 ) {
row = n / 2;
col = n + 1;
} else {
row = (n + 1) / 2;
col = n;
}
}
/* Perform conversion: */
if( rowmaj ) {
LAPACKE_dge_trans( LAPACK_ROW_MAJOR, row, col, in, col, out, row );
} else {
LAPACKE_dge_trans( LAPACK_COL_MAJOR, row, col, in, row, out, col );
}
}

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.

{
lapack_int i, len;
lapack_logical colmaj, upper, unit;
if( ap == NULL ) return (lapack_logical) 0;
colmaj = ( matrix_order == LAPACK_COL_MAJOR );
upper = LAPACKE_lsame( uplo, 'u' );
unit = LAPACKE_lsame( diag, 'u' );
if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
/* Just exit if any of input parameters are wrong */
return (lapack_logical) 0;
}
if( unit ) {
/* Unit case, diagonal should be excluded from the check for NaN. */
/* Since col_major upper and row_major lower are equal,
* and col_major lower and row_major upper are equals too -
* using one code for equal cases. XOR( colmaj, upper )
*/
if( ( colmaj || upper ) && !( colmaj && upper ) ) {
for( i = 1; i < n; i++ )
if( LAPACKE_d_nancheck( i, &ap[ ((size_t)i+1)*i/2 ], 1 ) )
return (lapack_logical) 1;
} else {
for( i = 0; i < n-1; i++ )
if( LAPACKE_d_nancheck( n-i-1,
&ap[ (size_t)i+1 + i*((size_t)2*n-i+1)/2 ], 1 ) )
return (lapack_logical) 1;
}
return (lapack_logical) 0;
} else {
/* Non-unit case - just check whole array for NaNs. */
len = n*(n+1)/2;
return LAPACKE_d_nancheck( len, ap, 1 );
}
}

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.

{
lapack_int i, j, st;
lapack_logical colmaj, upper, unit;
if( in == NULL || out == NULL ) return ;
colmaj = ( matrix_order == LAPACK_COL_MAJOR );
upper = LAPACKE_lsame( uplo, 'u' );
unit = LAPACKE_lsame( diag, 'u' );
if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
/* Just exit if any of input parameters are wrong */
return;
}
if( unit ) {
/* If unit, then don't touch diagonal, start from 1st column or row */
st = 1;
} else {
/* If non-unit, then check diagonal also, starting from [0,0] */
st = 0;
}
/* Perform conversion:
* Since col_major upper and row_major lower are equal,
* and col_major lower and row_major upper are equals too -
* using one code for equal cases. XOR( colmaj, upper )
*/
if( ( colmaj || upper ) && !( colmaj && upper ) ) {
for( j = st; j < n; j++ ) {
for( i = 0; i < j+1-st; i++ ) {
out[ j-i + (i*(2*n-i+1))/2 ] = in[ ((j+1)*j)/2 + i ];
}
}
} else {
for( j = 0; j < n-st; j++ ) {
for( i = j+st; i < n; i++ ) {
out[ j + ((i+1)*i)/2 ] = in[ (j*(2*n-j+1))/2 + i-j ];
}
}
}
}

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.

{
lapack_int i, j, st;
lapack_logical colmaj, lower, unit;
if( a == NULL ) return (lapack_logical) 0;
colmaj = ( matrix_order == LAPACK_COL_MAJOR );
lower = LAPACKE_lsame( uplo, 'l' );
unit = LAPACKE_lsame( diag, 'u' );
if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
( !lower && !LAPACKE_lsame( uplo, 'u' ) ) ||
( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
/* Just exit if any of input parameters are wrong */
return (lapack_logical) 0;
}
if( unit ) {
/* If unit, then don't touch diagonal, start from 1st column or row */
st = 1;
} else {
/* If non-unit, then check diagonal also, starting from [0,0] */
st = 0;
}
/* Since col_major upper and row_major lower are equal,
* and col_major lower and row_major upper are equals too -
* using one code for equal cases. XOR( colmaj, upper )
*/
if( ( colmaj || lower ) && !( colmaj && lower ) ) {
for( j = st; j < n; j++ ) {
for( i = 0; i < MIN( j+1-st, lda ); i++ ) {
if( LAPACK_DISNAN( a[i+j*lda] ) )
return (lapack_logical) 1;
}
}
} else {
for( j = 0; j < n-st; j++ ) {
for( i = j+st; i < MIN( n, lda ); i++ ) {
if( LAPACK_DISNAN( a[i+j*lda] ) )
return (lapack_logical) 1;
}
}
}
return (lapack_logical) 0;
}

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.

{
lapack_int i, j, st;
lapack_logical colmaj, lower, unit;
if( in == NULL || out == NULL ) return ;
colmaj = ( matrix_order == LAPACK_COL_MAJOR );
lower = LAPACKE_lsame( uplo, 'l' );
unit = LAPACKE_lsame( diag, 'u' );
if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
( !lower && !LAPACKE_lsame( uplo, 'u' ) ) ||
( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
/* Just exit if any of input parameters are wrong */
return;
}
if( unit ) {
/* If unit, then don't touch diagonal, start from 1st column or row */
st = 1;
} else {
/* If non-unit, then check diagonal also, starting from [0,0] */
st = 0;
}
/* Perform conversion:
* Since col_major upper and row_major lower are equal,
* and col_major lower and row_major upper are equals too -
* using one code for equal cases. XOR( colmaj, upper )
*/
if( ( colmaj || lower ) && !( colmaj && lower ) ) {
for( j = st; j < MIN( n, ldout ); j++ ) {
for( i = 0; i < MIN( j+1-st, ldin ); i++ ) {
out[ j+i*ldout ] = in[ i+j*ldin ];
}
}
} else {
for( j = 0; j < MIN( n-st, ldout ); j++ ) {
for( i = j+st; i < MIN( n, ldin ); i++ ) {
out[ j+i*ldout ] = in[ i+j*ldin ];
}
}
}
}

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.

{
return (lapack_logical) LAPACK_lsame( &ca, &cb, 1, 1 );
}

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.

{
if( incx == 0 ) return (lapack_logical) LAPACK_SISNAN( x[0] );
inc = ( incx > 0 ) ? incx : -incx ;
for( i = 0; i < n*inc; i+=inc ) {
if( LAPACK_SISNAN( x[i] ) )
return (lapack_logical) 1;
}
return (lapack_logical) 0;
}
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.

{
if( ab == NULL ) return (lapack_logical) 0;
if( matrix_order == LAPACK_COL_MAJOR ) {
for( j = 0; j < n; j++ ) {
for( i = MAX( ku-j, 0 ); i < MIN3( ldab, m+ku-j, kl+ku+1 );
i++ ) {
if( LAPACK_SISNAN( ab[i+(size_t)j*ldab] ) )
return (lapack_logical) 1;
}
}
} else if ( matrix_order == LAPACK_ROW_MAJOR ) {
for( j = 0; j < MIN( n, ldab ); j++ ) {
for( i = MAX( ku-j, 0 ); i < MIN( m+ku-j, kl+ku+1 ); i++ ) {
if( LAPACK_SISNAN( ab[(size_t)i*ldab+j] ) )
return (lapack_logical) 1;
}
}
}
return (lapack_logical) 0;
}

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.

{
if( in == NULL || out == NULL ) return;
if( matrix_order == LAPACK_COL_MAJOR ) {
for( j = 0; j < MIN( ldout, n ); j++ ) {
for( i = MAX( ku-j, 0 ); i < MIN3( ldin, m+ku-j, kl+ku+1 );
i++ ) {
out[(size_t)i*ldout+j] = in[i+(size_t)j*ldin];
}
}
} else if ( matrix_order == LAPACK_ROW_MAJOR ) {
/* TODO: interchange loops for performance.
* This is just reference impemeltation.
*/
for( j = 0; j < MIN( n, ldin ); j++ ) {
for( i = MAX( ku-j, 0 ); i < MIN3( ldout, m+ku-j, kl+ku+1 );
i++ ) {
out[i+(size_t)j*ldout] = in[(size_t)i*ldin+j];
}
}
}
}

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.

{
if( a == NULL ) return (lapack_logical) 0;
if( matrix_order == LAPACK_COL_MAJOR ) {
for( j = 0; j < n; j++ ) {
for( i = 0; i < MIN( m, lda ); i++ ) {
if( LAPACK_SISNAN( a[i+(size_t)j*lda] ) )
return (lapack_logical) 1;
}
}
} else if ( matrix_order == LAPACK_ROW_MAJOR ) {
for( i = 0; i < m; i++ ) {
for( j = 0; j < MIN( n, lda ); j++ ) {
if( LAPACK_SISNAN( a[(size_t)i*lda+j] ) )
return (lapack_logical) 1;
}
}
}
return (lapack_logical) 0;
}
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.

{
lapack_int i, j, x, y;
if( in == NULL || out == NULL ) return;
if( matrix_order == LAPACK_COL_MAJOR ) {
x = n;
y = m;
} else if ( matrix_order == LAPACK_ROW_MAJOR ) {
x = m;
y = n;
} else {
/* Unknown input layout */
return;
}
/* In case of incorrect m, n, ldin or ldout the function does nothing */
for( i = 0; i < MIN( y, ldin ); i++ ) {
for( j = 0; j < MIN( x, ldout ); j++ ) {
out[ (size_t)i*ldout + j ] = in[ (size_t)j*ldin + i ];
}
}
}
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.

{
return LAPACKE_sge_nancheck( matrix_order, m, n, a, 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.

{
LAPACKE_sge_trans( matrix_order, m, n, in, ldin, out, ldout );
}

Here is the call graph for this function:

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

Definition at line 37 of file lapacke_sgt_nancheck.c.

{
return LAPACKE_s_nancheck( n-1, dl, 1 )
|| LAPACKE_s_nancheck( n , d, 1 )
|| LAPACKE_s_nancheck( n-1, du, 1 );
}

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.

{
lapack_logical subdiag_nans;
if( a == NULL ) return (lapack_logical) 0;
/* Check subdiagonal first */
if( matrix_order == LAPACK_COL_MAJOR ) {
subdiag_nans = LAPACKE_s_nancheck( n-1, &a[1], lda+1 );
} else if ( matrix_order == LAPACK_ROW_MAJOR ) {
subdiag_nans = LAPACKE_s_nancheck( n-1, &a[lda], lda+1 );
} else {
return (lapack_logical) 0;
}
/* Check upper triangular if subdiagonal has no NaNs. */
return subdiag_nans || LAPACKE_str_nancheck( matrix_order, 'u', 'n',
n, a, lda);
}

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.

{
if( in == NULL || out == NULL ) return;
/* Convert subdiagonal first */
if( matrix_order == LAPACK_COL_MAJOR ) {
LAPACKE_sge_trans( LAPACK_COL_MAJOR, 1, n-1, &in[1], ldin+1,
&out[ldout], ldout+1 );
} else if ( matrix_order == LAPACK_ROW_MAJOR ) {
LAPACKE_sge_trans( LAPACK_ROW_MAJOR, n-1, 1, &in[ldin], ldin+1,
&out[1], ldout+1 );
} else {
return;
}
/* Convert upper triangular. */
LAPACKE_str_trans( matrix_order, 'u', 'n', n, in, ldin, out, 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.

{
if( LAPACKE_lsame( uplo, 'u' ) ) {
return LAPACKE_sgb_nancheck( matrix_order, n, n, 0, kd, ab, ldab );
} else if( LAPACKE_lsame( uplo, 'l' ) ) {
return LAPACKE_sgb_nancheck( matrix_order, n, n, kd, 0, ab, ldab );
}
return (lapack_logical) 0;
}

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.

{
if( LAPACKE_lsame( uplo, 'u' ) ) {
LAPACKE_sgb_trans( matrix_order, n, n, 0, kd, in, ldin, out, ldout );
} else if( LAPACKE_lsame( uplo, 'l' ) ) {
LAPACKE_sgb_trans( matrix_order, n, n, kd, 0, in, ldin, out, ldout );
}
}

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.

{
lapack_int len = n*(n+1)/2;
return LAPACKE_s_nancheck( len, a, 1 );
}

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.

{
LAPACKE_stf_trans( matrix_order, transr, uplo, 'n', n, in, 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.

{
return LAPACKE_str_nancheck( matrix_order, uplo, 'n', n, a, 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.

{
LAPACKE_str_trans( matrix_order, uplo, 'n', n, in, ldin, out, 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.

{
lapack_int len = n*(n+1)/2;
return LAPACKE_s_nancheck( len, ap, 1 );
}

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.

{
LAPACKE_stp_trans( matrix_order, uplo, 'n', n, in, 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.

{
return LAPACKE_s_nancheck( n, d, 1 )
|| LAPACKE_s_nancheck( n-1, e, 1 );
}

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.

{
if( LAPACKE_lsame( uplo, 'u' ) ) {
return LAPACKE_sgb_nancheck( matrix_order, n, n, 0, kd, ab, ldab );
} else if( LAPACKE_lsame( uplo, 'l' ) ) {
return LAPACKE_sgb_nancheck( matrix_order, n, n, kd, 0, ab, ldab );
}
return (lapack_logical) 0;
}

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.

{
if( LAPACKE_lsame( uplo, 'u' ) ) {
LAPACKE_sgb_trans( matrix_order, n, n, 0, kd, in, ldin, out, ldout );
} else if( LAPACKE_lsame( uplo, 'l' ) ) {
LAPACKE_sgb_trans( matrix_order, n, n, kd, 0, in, ldin, out, ldout );
}
}

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.

{
lapack_int len = n*(n+1)/2;
return LAPACKE_s_nancheck( len, ap, 1 );
}

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.

{
LAPACKE_stp_trans( matrix_order, uplo, 'n', n, in, 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.

{
return LAPACKE_s_nancheck( n, d, 1 )
|| LAPACKE_s_nancheck( n-1, e, 1 );
}

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.

{
return LAPACKE_str_nancheck( matrix_order, uplo, 'n', n, a, 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.

{
LAPACKE_str_trans( matrix_order, uplo, 'n', n, in, ldin, out, 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.

{
lapack_logical colmaj, upper, unit;
if( ab == NULL ) return (lapack_logical) 0;
colmaj = ( matrix_order == LAPACK_COL_MAJOR );
upper = LAPACKE_lsame( uplo, 'u' );
unit = LAPACKE_lsame( diag, 'u' );
if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
/* Just exit if any of input parameters are wrong */
return (lapack_logical) 0;
}
if( unit ) {
/* Unit case, diagonal should be excluded from the check for NaN. */
if( colmaj ) {
if( upper ) {
return LAPACKE_sgb_nancheck( matrix_order, n-1, n-1, 0, kd-1,
&ab[ldab], ldab );
} else {
return LAPACKE_sgb_nancheck( matrix_order, n-1, n-1, kd-1, 0,
&ab[1], ldab );
}
} else {
if( upper ) {
return LAPACKE_sgb_nancheck( matrix_order, n-1, n-1, 0, kd-1,
&ab[1], ldab );
} else {
return LAPACKE_sgb_nancheck( matrix_order, n-1, n-1, kd-1, 0,
&ab[ldab], ldab );
}
}
} else {
/* Non-unit case */
if( upper ) {
return LAPACKE_sgb_nancheck( matrix_order, n, n, 0, kd, ab, ldab );
} else {
return LAPACKE_sgb_nancheck( matrix_order, n, n, kd, 0, ab, ldab );
}
}
}

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.

{
lapack_logical colmaj, upper, unit;
if( in == NULL || out == NULL ) return;
colmaj = ( matrix_order == LAPACK_COL_MAJOR );
upper = LAPACKE_lsame( uplo, 'u' );
unit = LAPACKE_lsame( diag, 'u' );
if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
/* Just exit if any of input parameters are wrong */
return;
}
if( unit ) {
/* Unit case, diagonal excluded from transposition */
if( colmaj ) {
if( upper ) {
LAPACKE_sgb_trans( matrix_order, n-1, n-1, 0, kd-1,
&in[ldin], ldin, &out[1], ldout );
} else {
LAPACKE_sgb_trans( matrix_order, n-1, n-1, kd-1, 0,
&in[1], ldin, &out[ldout], ldout );
}
} else {
if( upper ) {
LAPACKE_sgb_trans( matrix_order, n-1, n-1, 0, kd-1,
&in[1], ldin, &out[ldout], ldout );
} else {
LAPACKE_sgb_trans( matrix_order, n-1, n-1, kd-1, 0,
&in[ldin], ldin, &out[1], ldout );
}
}
} else {
/* Non-unit case */
if( upper ) {
LAPACKE_sgb_trans( matrix_order, n, n, 0, kd, in, ldin, out,
ldout );
} else {
LAPACKE_sgb_trans( matrix_order, n, n, kd, 0, in, ldin, out,
ldout );
}
}
}

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.

{
lapack_logical rowmaj, ntr, lower, unit;
lapack_int n1, n2, k;
if( a == NULL ) return (lapack_logical) 0;
rowmaj = (matrix_order == LAPACK_ROW_MAJOR);
ntr = LAPACKE_lsame( transr, 'n' );
lower = LAPACKE_lsame( uplo, 'l' );
unit = LAPACKE_lsame( diag, 'u' );
if( ( !rowmaj && ( matrix_order != LAPACK_COL_MAJOR ) ) ||
( !ntr && !LAPACKE_lsame( transr, 't' )
&& !LAPACKE_lsame( transr, 'c' ) ) ||
( !lower && !LAPACKE_lsame( uplo, 'u' ) ) ||
( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
/* Just exit if any of input parameters are wrong */
return (lapack_logical) 0;
}
if( unit ) {
/* Unit case, diagonal should be excluded from the check for NaN.
* Decoding RFP and checking both triangulars and rectangular
* for NaNs.
*/
if( lower ) {
n2 = n / 2;
n1 = n - n2;
} else {
n1 = n / 2;
n2 = n - n1;
}
if( n % 2 == 1 ) {
/* N is odd */
if( ( rowmaj || ntr ) && !( rowmaj && ntr ) ) {
/* N is odd and ( TRANSR = 'N' .XOR. ROWMAJOR) */
if( lower ) {
n1, &a[0], n )
&a[n1], n )
n2, &a[n], n );
} else {
n1, &a[n2], n )
&a[0], n )
n2, &a[n1], n );
}
} else {
/* N is odd and
( ( TRANSR = 'C' || TRANSR = 'T' ) .XOR. COLMAJOR ) */
if( lower ) {
n1, &a[0], n1 )
&a[1], n1 )
n2, &a[1], n1 );
} else {
n1, &a[(size_t)n2*n2], n2 )
&a[0], n2 )
n2, &a[(size_t)n1*n2], n2 );
}
}
} else {
/* N is even */
k = n / 2;
if( ( rowmaj || ntr ) && !( rowmaj && ntr ) ) {
/* N is even and ( TRANSR = 'N' .XOR. ROWMAJOR) */
if( lower ) {
k, &a[1], n+1 )
&a[k+1], n+1 )
k, &a[0], n+1 );
} else {
k, &a[k+1], n+1 )
&a[0], n+1 )
k, &a[k], n+1 );
}
} else {
/* N is even and
* ( ( TRANSR = 'C' || TRANSR = 'T' ) .XOR. COLMAJOR )
*/
if( lower ) {
k, &a[k], k )
&a[(size_t)k*(k+1)], k )
k, &a[0], k );
} else {
k, &a[(size_t)k*(k+1)], k )
&a[0], k )
k, &a[(size_t)k*k], k );
}
}
}
} else {
/* Non-unit case - just check whole array for NaNs. */
len = n*(n+1)/2;
return LAPACKE_sge_nancheck( LAPACK_COL_MAJOR, len, 1, a, len );
}
}

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.

{
lapack_int row, col;
lapack_logical rowmaj, ntr, lower, unit;
if( in == NULL || out == NULL ) return ;
rowmaj = (matrix_order == LAPACK_ROW_MAJOR);
ntr = LAPACKE_lsame( transr, 'n' );
lower = LAPACKE_lsame( uplo, 'l' );
unit = LAPACKE_lsame( diag, 'u' );
if( ( !rowmaj && ( matrix_order != LAPACK_COL_MAJOR ) ) ||
( !ntr && !LAPACKE_lsame( transr, 't' ) &&
!LAPACKE_lsame( transr, 'c' ) ) ||
( !lower && !LAPACKE_lsame( uplo, 'u' ) ) ||
( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
/* Just exit if input parameters are wrong */
return;
}
/* Determine parameters of array representing RFP */
if( ntr ) {
if( n%2 == 0 ) {
row = n + 1;
col = n / 2;
} else {
row = n;
col = (n + 1) / 2;
}
} else {
if( n%2 == 0 ) {
row = n / 2;
col = n + 1;
} else {
row = (n + 1) / 2;
col = n;
}
}
/* Perform conversion: */
if( rowmaj ) {
LAPACKE_sge_trans( LAPACK_ROW_MAJOR, row, col, in, col, out, row );
} else {
LAPACKE_sge_trans( LAPACK_COL_MAJOR, row, col, in, row, out, col );
}
}

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.

{
lapack_int i, len;
lapack_logical colmaj, upper, unit;
if( ap == NULL ) return (lapack_logical) 0;
colmaj = ( matrix_order == LAPACK_COL_MAJOR );
upper = LAPACKE_lsame( uplo, 'u' );
unit = LAPACKE_lsame( diag, 'u' );
if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
/* Just exit if any of input parameters are wrong */
return (lapack_logical) 0;
}
if( unit ) {
/* Unit case, diagonal should be excluded from the check for NaN. */
/* Since col_major upper and row_major lower are equal,
* and col_major lower and row_major upper are equals too -
* using one code for equal cases. XOR( colmaj, upper )
*/
if( ( colmaj || upper ) && !( colmaj && upper ) ) {
for( i = 1; i < n; i++ )
if( LAPACKE_s_nancheck( i, &ap[ ((size_t)i+1)*i/2 ], 1 ) )
return (lapack_logical) 1;
} else {
for( i = 0; i < n-1; i++ )
if( LAPACKE_s_nancheck( n-i-1,
&ap[ (size_t)i+1 + i*((size_t)2*n-i+1)/2 ], 1 ) )
return (lapack_logical) 1;
}
return (lapack_logical) 0;
} else {
/* Non-unit case - just check whole array for NaNs. */
len = n*(n+1)/2;
return LAPACKE_s_nancheck( len, ap, 1 );
}
}

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.

{
lapack_int i, j, st;
lapack_logical colmaj, upper, unit;
if( in == NULL || out == NULL ) return ;
colmaj = ( matrix_order == LAPACK_COL_MAJOR );
upper = LAPACKE_lsame( uplo, 'u' );
unit = LAPACKE_lsame( diag, 'u' );
if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
/* Just exit if any of input parameters are wrong */
return;
}
if( unit ) {
/* If unit, then don't touch diagonal, start from 1st column or row */
st = 1;
} else {
/* If non-unit, then check diagonal also, starting from [0,0] */
st = 0;
}
/* Perform conversion:
* Since col_major upper and row_major lower are equal,
* and col_major lower and row_major upper are equals too -
* using one code for equal cases. XOR( colmaj, upper )
*/
if( ( colmaj || upper ) && !( colmaj && upper ) ) {
for( j = st; j < n; j++ ) {
for( i = 0; i < j+1-st; i++ ) {
out[ j-i + (i*(2*n-i+1))/2 ] = in[ ((j+1)*j)/2 + i ];
}
}
} else {
for( j = 0; j < n-st; j++ ) {
for( i = j+st; i < n; i++ ) {
out[ j + ((i+1)*i)/2 ] = in[ (j*(2*n-j+1))/2 + i-j ];
}
}
}
}

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.

{
lapack_int i, j, st;
lapack_logical colmaj, lower, unit;
if( a == NULL ) return (lapack_logical) 0;
colmaj = ( matrix_order == LAPACK_COL_MAJOR );
lower = LAPACKE_lsame( uplo, 'l' );
unit = LAPACKE_lsame( diag, 'u' );
if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
( !lower && !LAPACKE_lsame( uplo, 'u' ) ) ||
( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
/* Just exit if any of input parameters are wrong */
return (lapack_logical) 0;
}
if( unit ) {
/* If unit, then don't touch diagonal, start from 1st column or row */
st = 1;
} else {
/* If non-unit, then check diagonal also, starting from [0,0] */
st = 0;
}
/* Since col_major upper and row_major lower are equal,
* and col_major lower and row_major upper are equals too -
* using one code for equal cases. XOR( colmaj, upper )
*/
if( ( colmaj || lower ) && !( colmaj && lower ) ) {
for( j = st; j < n; j++ ) {
for( i = 0; i < MIN( j+1-st, lda ); i++ ) {
if( LAPACK_SISNAN( a[i+j*lda] ) )
return (lapack_logical) 1;
}
}
} else {
for( j = 0; j < n-st; j++ ) {
for( i = j+st; i < MIN( n, lda ); i++ ) {
if( LAPACK_SISNAN( a[i+j*lda] ) )
return (lapack_logical) 1;
}
}
}
return (lapack_logical) 0;
}

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.

{
lapack_int i, j, st;
lapack_logical colmaj, lower, unit;
if( in == NULL || out == NULL ) return ;
colmaj = ( matrix_order == LAPACK_COL_MAJOR );
lower = LAPACKE_lsame( uplo, 'l' );
unit = LAPACKE_lsame( diag, 'u' );
if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
( !lower && !LAPACKE_lsame( uplo, 'u' ) ) ||
( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
/* Just exit if any of input parameters are wrong */
return;
}
if( unit ) {
/* If unit, then don't touch diagonal, start from 1st column or row */
st = 1;
} else {
/* If non-unit, then check diagonal also, starting from [0,0] */
st = 0;
}
/* Perform conversion:
* Since col_major upper and row_major lower are equal,
* and col_major lower and row_major upper are equals too -
* using one code for equal cases. XOR( colmaj, upper )
*/
if( ( colmaj || lower ) && !( colmaj && lower ) ) {
for( j = st; j < MIN( n, ldout ); j++ ) {
for( i = 0; i < MIN( j+1-st, ldin ); i++ ) {
out[ j+i*ldout ] = in[ i+j*ldin ];
}
}
} else {
for( j = 0; j < MIN( n-st, ldout ); j++ ) {
for( i = j+st; i < MIN( n, ldin ); i++ ) {
out[ j+i*ldout ] = in[ i+j*ldin ];
}
}
}
}

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.

{
if( info < 0 ) {
printf( "OVERRIDE SUCCESSFUL override %d in %s\n", -(int) info, name );
}
}
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.

{
if( incx == 0 ) return (lapack_logical) LAPACK_ZISNAN( x[0] );
inc = ( incx > 0 ) ? incx : -incx ;
for( i = 0; i < n*inc; i+=inc ) {
if( LAPACK_ZISNAN( x[i] ) )
return (lapack_logical) 1;
}
return (lapack_logical) 0;
}

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.

{
if( ab == NULL ) return (lapack_logical) 0;
if( matrix_order == LAPACK_COL_MAJOR ) {
for( j = 0; j < n; j++ ) {
for( i = MAX( ku-j, 0 ); i < MIN3( ldab, m+ku-j, kl+ku+1 );
i++ ) {
if( LAPACK_ZISNAN( ab[i+(size_t)j*ldab] ) )
return (lapack_logical) 1;
}
}
} else if ( matrix_order == LAPACK_ROW_MAJOR ) {
for( j = 0; j < MIN( n, ldab ); j++ ) {
for( i = MAX( ku-j, 0 ); i < MIN( m+ku-j, kl+ku+1 ); i++ ) {
if( LAPACK_ZISNAN( ab[(size_t)i*ldab+j] ) )
return (lapack_logical) 1;
}
}
}
return (lapack_logical) 0;
}

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.

{
if( in == NULL || out == NULL ) return;
if( matrix_order == LAPACK_COL_MAJOR ) {
for( j = 0; j < MIN( ldout, n ); j++ ) {
for( i = MAX( ku-j, 0 ); i < MIN3( ldin, m+ku-j, kl+ku+1 );
i++ ) {
out[(size_t)i*ldout+j] = in[i+(size_t)j*ldin];
}
}
} else if ( matrix_order == LAPACK_ROW_MAJOR ) {
/* TODO: interchange loops for performance.
* This is just reference impemeltation
*/
for( j = 0; j < MIN( n, ldin ); j++ ) {
for( i = MAX( ku-j, 0 ); i < MIN3( ldout, m+ku-j, kl+ku+1 );
i++ ) {
out[i+(size_t)j*ldout] = in[(size_t)i*ldin+j];
}
}
}
}

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.

{
if( a == NULL ) return (lapack_logical) 0;
if( matrix_order == LAPACK_COL_MAJOR ) {
for( j = 0; j < n; j++ ) {
for( i = 0; i < MIN( m, lda ); i++ ) {
if( LAPACK_ZISNAN( a[i+(size_t)j*lda] ) )
return (lapack_logical) 1;
}
}
} else if ( matrix_order == LAPACK_ROW_MAJOR ) {
for( i = 0; i < m; i++ ) {
for( j = 0; j < MIN( n, lda ); j++ ) {
if( LAPACK_ZISNAN( a[(size_t)i*lda+j] ) )
return (lapack_logical) 1;
}
}
}
return (lapack_logical) 0;
}
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.

{
lapack_int i, j, x, y;
if( in == NULL || out == NULL ) return;
if( matrix_order == LAPACK_COL_MAJOR ) {
x = n;
y = m;
} else if ( matrix_order == LAPACK_ROW_MAJOR ) {
x = m;
y = n;
} else {
/* Unknown input layout */
return;
}
/* In case of incorrect m, n, ldin or ldout the function does nothing */
for( i = 0; i < MIN( y, ldin ); i++ ) {
for( j = 0; j < MIN( x, ldout ); j++ ) {
out[ (size_t)i*ldout + j ] = in[ (size_t)j*ldin + i ];
}
}
}
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.

{
return LAPACKE_zge_nancheck( matrix_order, m, n, a, 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.

{
LAPACKE_zge_trans( matrix_order, m, n, in, ldin, out, 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.

{
return LAPACKE_z_nancheck( n-1, dl, 1 )
|| LAPACKE_z_nancheck( n , d, 1 )
|| LAPACKE_z_nancheck( n-1, du, 1 );
}

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.

{
if( LAPACKE_lsame( uplo, 'u' ) ) {
return LAPACKE_zgb_nancheck( matrix_order, n, n, 0, kd, ab, ldab );
} else if( LAPACKE_lsame( uplo, 'l' ) ) {
return LAPACKE_zgb_nancheck( matrix_order, n, n, kd, 0, ab, ldab );
}
return (lapack_logical) 0;
}

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.

{
if( LAPACKE_lsame( uplo, 'u' ) ) {
LAPACKE_zgb_trans( matrix_order, n, n, 0, kd, in, ldin, out, ldout );
} else if( LAPACKE_lsame( uplo, 'l' ) ) {
LAPACKE_zgb_trans( matrix_order, n, n, kd, 0, in, ldin, out, ldout );
}
}

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.

{
return LAPACKE_ztr_nancheck( matrix_order, uplo, 'n', n, a, 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.

{
LAPACKE_ztr_trans( matrix_order, uplo, 'n', n, in, ldin, out, 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.

{
lapack_int len = n*(n+1)/2;
return LAPACKE_z_nancheck( len, ap, 1 );
}

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.

{
LAPACKE_ztp_trans( matrix_order, uplo, 'n', n, in, 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.

{
lapack_logical subdiag_nans;
if( a == NULL ) return (lapack_logical) 0;
/* Check subdiagonal first */
if( matrix_order == LAPACK_COL_MAJOR ) {
subdiag_nans = LAPACKE_z_nancheck( n-1, &a[1], lda+1 );
} else if ( matrix_order == LAPACK_ROW_MAJOR ) {
subdiag_nans = LAPACKE_z_nancheck( n-1, &a[lda], lda+1 );
} else {
return (lapack_logical) 0;
}
/* Check upper triangular if subdiagonal has no NaNs. */
return subdiag_nans || LAPACKE_ztr_nancheck( matrix_order, 'u', 'n',
n, a, 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.

{
if( in == NULL || out == NULL ) return;
/* Convert subdiagonal first */
if( matrix_order == LAPACK_COL_MAJOR ) {
LAPACKE_zge_trans( LAPACK_COL_MAJOR, 1, n-1, &in[1], ldin+1,
&out[ldout], ldout+1 );
} else if ( matrix_order == LAPACK_ROW_MAJOR ) {
LAPACKE_zge_trans( LAPACK_ROW_MAJOR, n-1, 1, &in[ldin], ldin+1,
&out[1], ldout+1 );
} else {
return;
}
/* Convert upper triangular. */
LAPACKE_ztr_trans( matrix_order, 'u', 'n', n, in, ldin, out, ldout);
}

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.

{
if( LAPACKE_lsame( uplo, 'u' ) ) {
return LAPACKE_zgb_nancheck( matrix_order, n, n, 0, kd, ab, ldab );
} else if( LAPACKE_lsame( uplo, 'l' ) ) {
return LAPACKE_zgb_nancheck( matrix_order, n, n, kd, 0, ab, ldab );
}
return (lapack_logical) 0;
}

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.

{
if( LAPACKE_lsame( uplo, 'u' ) ) {
LAPACKE_zgb_trans( matrix_order, n, n, 0, kd, in, ldin, out, ldout );
} else if( LAPACKE_lsame( uplo, 'l' ) ) {
LAPACKE_zgb_trans( matrix_order, n, n, kd, 0, in, ldin, out, ldout );
}
}

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.

{
lapack_int len = n*(n+1)/2;
return LAPACKE_z_nancheck( len, a, 1 );
}

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.

{
LAPACKE_ztf_trans( matrix_order, transr, uplo, 'n', n, in, 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.

{
return LAPACKE_ztr_nancheck( matrix_order, uplo, 'n', n, a, 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.

{
LAPACKE_ztr_trans( matrix_order, uplo, 'n', n, in, ldin, out, 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.

{
lapack_int len = n*(n+1)/2;
return LAPACKE_z_nancheck( len, ap, 1 );
}

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.

{
LAPACKE_ztp_trans( matrix_order, uplo, 'n', n, in, 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.

{
return LAPACKE_d_nancheck( n, d, 1 )
|| LAPACKE_z_nancheck( n-1, e, 1 );
}

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.

{
lapack_int len = n*(n+1)/2;
return LAPACKE_z_nancheck( len, ap, 1 );
}

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.

{
LAPACKE_ztp_trans( matrix_order, uplo, 'n', n, in, 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.

{
return LAPACKE_z_nancheck( n, d, 1 )
|| LAPACKE_z_nancheck( n-1, e, 1 );
}

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.

{
return LAPACKE_ztr_nancheck( matrix_order, uplo, 'n', n, a, 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.

{
LAPACKE_ztr_trans( matrix_order, uplo, 'n', n, in, ldin, out, 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.

{
lapack_logical colmaj, upper, unit;
if( ab == NULL ) return (lapack_logical) 0;
colmaj = ( matrix_order == LAPACK_COL_MAJOR );
upper = LAPACKE_lsame( uplo, 'u' );
unit = LAPACKE_lsame( diag, 'u' );
if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
/* Just exit if any of input parameters are wrong */
return (lapack_logical) 0;
}
if( unit ) {
/* Unit case, diagonal should be excluded from the check for NaN. */
if( colmaj ) {
if( upper ) {
return LAPACKE_zgb_nancheck( matrix_order, n-1, n-1, 0, kd-1,
&ab[ldab], ldab );
} else {
return LAPACKE_zgb_nancheck( matrix_order, n-1, n-1, kd-1, 0,
&ab[1], ldab );
}
} else {
if( upper ) {
return LAPACKE_zgb_nancheck( matrix_order, n-1, n-1, 0, kd-1,
&ab[1], ldab );
} else {
return LAPACKE_zgb_nancheck( matrix_order, n-1, n-1, kd-1, 0,
&ab[ldab], ldab );
}
}
} else {
/* Non-unit case */
if( upper ) {
return LAPACKE_zgb_nancheck( matrix_order, n, n, 0, kd, ab, ldab );
} else {
return LAPACKE_zgb_nancheck( matrix_order, n, n, kd, 0, ab, ldab );
}
}
}

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.

{
lapack_logical colmaj, upper, unit;
if( in == NULL || out == NULL ) return;
colmaj = ( matrix_order == LAPACK_COL_MAJOR );
upper = LAPACKE_lsame( uplo, 'u' );
unit = LAPACKE_lsame( diag, 'u' );
if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
/* Just exit if any of input parameters are wrong */
return;
}
if( unit ) {
/* Unit case, diagonal excluded from transposition */
if( colmaj ) {
if( upper ) {
LAPACKE_zgb_trans( matrix_order, n-1, n-1, 0, kd-1,
&in[ldin], ldin, &out[1], ldout );
} else {
LAPACKE_zgb_trans( matrix_order, n-1, n-1, kd-1, 0,
&in[1], ldin, &out[ldout], ldout );
}
} else {
if( upper ) {
LAPACKE_zgb_trans( matrix_order, n-1, n-1, 0, kd-1,
&in[1], ldin, &out[ldout], ldout );
} else {
LAPACKE_zgb_trans( matrix_order, n-1, n-1, kd-1, 0,
&in[ldin], ldin, &out[1], ldout );
}
}
} else {
/* Non-unit case */
if( upper ) {
LAPACKE_zgb_trans( matrix_order, n, n, 0, kd, in, ldin, out,
ldout );
} else {
LAPACKE_zgb_trans( matrix_order, n, n, kd, 0, in, ldin, out,
ldout );
}
}
}

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.

{
lapack_logical rowmaj, ntr, lower, unit;
lapack_int n1, n2, k;
if( a == NULL ) return (lapack_logical) 0;
rowmaj = (matrix_order == LAPACK_ROW_MAJOR);
ntr = LAPACKE_lsame( transr, 'n' );
lower = LAPACKE_lsame( uplo, 'l' );
unit = LAPACKE_lsame( diag, 'u' );
if( ( !rowmaj && ( matrix_order != LAPACK_COL_MAJOR ) ) ||
( !ntr && !LAPACKE_lsame( transr, 't' )
&& !LAPACKE_lsame( transr, 'c' ) ) ||
( !lower && !LAPACKE_lsame( uplo, 'u' ) ) ||
( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
/* Just exit if any of input parameters are wrong */
return (lapack_logical) 0;
}
if( unit ) {
/* Unit case, diagonal should be excluded from the check for NaN.
* Decoding RFP and checking both triangulars and rectangular
* for NaNs.
*/
if( lower ) {
n2 = n / 2;
n1 = n - n2;
} else {
n1 = n / 2;
n2 = n - n1;
}
if( n % 2 == 1 ) {
/* N is odd */
if( ( rowmaj || ntr ) && !( rowmaj && ntr ) ) {
/* N is odd and ( TRANSR = 'N' .XOR. ROWMAJOR) */
if( lower ) {
n1, &a[0], n )
&a[n1], n )
n2, &a[n], n );
} else {
n1, &a[n2], n )
&a[0], n )
n2, &a[n1], n );
}
} else {
/* N is odd and
* ( ( TRANSR = 'C' || TRANSR = 'T' ) .XOR. COLMAJOR )
*/
if( lower ) {
n1, &a[0], n1 )
&a[1], n1 )
n2, &a[1], n1 );
} else {
n1, &a[(size_t)n2*n2], n2 )
&a[0], n2 )
n2, &a[(size_t)n1*n2], n2 );
}
}
} else {
/* N is even */
k = n / 2;
if( ( rowmaj || ntr ) && !( rowmaj && ntr ) ) {
/* N is even and ( TRANSR = 'N' .XOR. ROWMAJOR) */
if( lower ) {
k, &a[1], n+1 )
&a[k+1], n+1 )
k, &a[0], n+1 );
} else {
k, &a[k+1], n+1 )
&a[0], n+1 )
k, &a[k], n+1 );
}
} else {
/* N is even and
( ( TRANSR = 'C' || TRANSR = 'T' ) .XOR. COLMAJOR ) */
if( lower ) {
k, &a[k], k )
&a[(size_t)k*(k+1)], k )
k, &a[0], k );
} else {
k, &a[(size_t)k*(k+1)], k )
&a[0], k )
k, &a[(size_t)k*k], k );
}
}
}
} else {
/* Non-unit case - just check whole array for NaNs. */
len = n*(n+1)/2;
return LAPACKE_zge_nancheck( LAPACK_COL_MAJOR, len, 1, a, len );
}
}

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.

{
lapack_int row, col;
lapack_logical rowmaj, ntr, lower, unit;
if( in == NULL || out == NULL ) return ;
rowmaj = (matrix_order == LAPACK_ROW_MAJOR);
ntr = LAPACKE_lsame( transr, 'n' );
lower = LAPACKE_lsame( uplo, 'l' );
unit = LAPACKE_lsame( diag, 'u' );
if( ( !rowmaj && ( matrix_order != LAPACK_COL_MAJOR ) ) ||
( !ntr && !LAPACKE_lsame( transr, 't' ) &&
!LAPACKE_lsame( transr, 'c' ) ) ||
( !lower && !LAPACKE_lsame( uplo, 'u' ) ) ||
( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
/* Just exit if input parameters are wrong */
return;
}
/* Determine parameters of array representing RFP */
if( ntr ) {
if( n%2 == 0 ) {
row = n + 1;
col = n / 2;
} else {
row = n;
col = (n + 1) / 2;
}
} else {
if( n%2 == 0 ) {
row = n / 2;
col = n + 1;
} else {
row = (n + 1) / 2;
col = n;
}
}
/* Perform conversion: */
if( rowmaj ) {
LAPACKE_zge_trans( LAPACK_ROW_MAJOR, row, col, in, col, out, row );
} else {
LAPACKE_zge_trans( LAPACK_COL_MAJOR, row, col, in, row, out, col );
}
}

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.

{
lapack_int i, len;
lapack_logical colmaj, upper, unit;
if( ap == NULL ) return (lapack_logical) 0;
colmaj = ( matrix_order == LAPACK_COL_MAJOR );
upper = LAPACKE_lsame( uplo, 'u' );
unit = LAPACKE_lsame( diag, 'u' );
if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
/* Just exit if any of input parameters are wrong */
return (lapack_logical) 0;
}
if( unit ) {
/* Unit case, diagonal should be excluded from the check for NaN. */
/* Since col_major upper and row_major lower are equal,
* and col_major lower and row_major upper are equals too -
* using one code for equal cases. XOR( colmaj, upper )
*/
if( ( colmaj || upper ) && !( colmaj && upper ) ) {
for( i = 1; i < n; i++ )
if( LAPACKE_z_nancheck( i, &ap[ ((size_t)i+1)*i/2 ], 1 ) )
return (lapack_logical) 1;
} else {
for( i = 0; i < n-1; i++ )
if( LAPACKE_z_nancheck( n-i-1,
&ap[ (size_t)i+1 + i*((size_t)2*n-i+1)/2 ], 1 ) )
return (lapack_logical) 1;
}
return (lapack_logical) 0;
} else {
/* Non-unit case - just check whole array for NaNs. */
len = n*(n+1)/2;
return LAPACKE_z_nancheck( len, ap, 1 );
}
}

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.

{
lapack_int i, j, st;
lapack_logical colmaj, upper, unit;
if( in == NULL || out == NULL ) return ;
colmaj = ( matrix_order == LAPACK_COL_MAJOR );
upper = LAPACKE_lsame( uplo, 'u' );
unit = LAPACKE_lsame( diag, 'u' );
if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
/* Just exit if any of input parameters are wrong */
return;
}
if( unit ) {
/* If unit, then don't touch diagonal, start from 1st column or row */
st = 1;
} else {
/* If non-unit, then check diagonal also, starting from [0,0] */
st = 0;
}
/* Perform conversion:
* Since col_major upper and row_major lower are equal,
* and col_major lower and row_major upper are equals too -
* using one code for equal cases. XOR( colmaj, upper )
*/
if( ( colmaj || upper ) && !( colmaj && upper ) ) {
for( j = st; j < n; j++ ) {
for( i = 0; i < j+1-st; i++ ) {
out[ j-i + (i*(2*n-i+1))/2 ] = in[ ((j+1)*j)/2 + i ];
}
}
} else {
for( j = 0; j < n-st; j++ ) {
for( i = j+st; i < n; i++ ) {
out[ j + ((i+1)*i)/2 ] = in[ (j*(2*n-j+1))/2 + i-j ];
}
}
}
}

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.

{
lapack_int i, j, st;
lapack_logical colmaj, lower, unit;
if( a == NULL ) return (lapack_logical) 0;
colmaj = ( matrix_order == LAPACK_COL_MAJOR );
lower = LAPACKE_lsame( uplo, 'l' );
unit = LAPACKE_lsame( diag, 'u' );
if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
( !lower && !LAPACKE_lsame( uplo, 'u' ) ) ||
( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
/* Just exit if any of input parameters are wrong */
return (lapack_logical) 0;
}
if( unit ) {
/* If unit, then don't touch diagonal, start from 1st column or row */
st = 1;
} else {
/* If non-unit, then check diagonal also, starting from [0,0] */
st = 0;
}
/* Since col_major upper and row_major lower are equal,
* and col_major lower and row_major upper are equals too -
* using one code for equal cases. XOR( colmaj, upper )
*/
if( ( colmaj || lower ) && !( colmaj && lower ) ) {
for( j = st; j < n; j++ ) {
for( i = 0; i < MIN( j+1-st, lda ); i++ ) {
if( LAPACK_ZISNAN( a[i+j*lda] ) )
return (lapack_logical) 1;
}
}
} else {
for( j = 0; j < n-st; j++ ) {
for( i = j+st; i < MIN( n, lda ); i++ ) {
if( LAPACK_ZISNAN( a[i+j*lda] ) )
return (lapack_logical) 1;
}
}
}
return (lapack_logical) 0;
}

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.

{
lapack_int i, j, st;
lapack_logical colmaj, lower, unit;
if( in == NULL || out == NULL ) return ;
colmaj = ( matrix_order == LAPACK_COL_MAJOR );
lower = LAPACKE_lsame( uplo, 'l' );
unit = LAPACKE_lsame( diag, 'u' );
if( ( !colmaj && ( matrix_order != LAPACK_ROW_MAJOR ) ) ||
( !lower && !LAPACKE_lsame( uplo, 'u' ) ) ||
( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
/* Just exit if any of input parameters are wrong */
return;
}
if( unit ) {
/* If unit, then don't touch diagonal, start from 1st column or row */
st = 1;
} else {
/* If non-unit, then check diagonal also, starting from [0,0] */
st = 0;
}
/* Perform conversion:
* Since col_major upper and row_major lower are equal,
* and col_major lower and row_major upper are equals too -
* using one code for equal cases. XOR( colmaj, upper )
*/
if( ( colmaj || lower ) && !( colmaj && lower ) ) {
for( j = st; j < MIN( n, ldout ); j++ ) {
for( i = 0; i < MIN( j+1-st, ldin ); i++ ) {
out[ j+i*ldout ] = in[ i+j*ldin ];
}
}
} else {
for( j = 0; j < MIN( n-st, ldout ); j++ ) {
for( i = j+st; i < MIN( n, ldin ); i++ ) {
out[ j+i*ldout ] = in[ i+j*ldin ];
}
}
}
}

Here is the call graph for this function:

Here is the caller graph for this function: