OpenRadioss 2025.1.11
OpenRadioss project
Loading...
Searching...
No Matches
lapacke_utils.h File Reference
#include "lapacke.h"

Go to the source code of this file.

Macros

#define ABS(x)
#define MAX(x, y)
#define MIN(x, y)
#define MAX3(x, y, z)
#define MIN3(x, y, z)
#define IS_S_NONZERO(x)
#define IS_D_NONZERO(x)
#define IS_C_NONZERO(x)
#define IS_Z_NONZERO(x)
#define LAPACK_SISNAN(x)
#define LAPACK_DISNAN(x)
#define LAPACK_CISNAN(x)
#define LAPACK_ZISNAN(x)

Functions

void LAPACKE_xerbla (const char *name, lapack_int info)
lapack_logical LAPACKE_lsame (char ca, char cb)
void LAPACKE_cgb_trans (int matrix_layout, 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_layout, 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_layout, 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_layout, 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_layout, 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_layout, char uplo, lapack_int n, const lapack_complex_float *in, lapack_complex_float *out)
void LAPACKE_chs_trans (int matrix_layout, lapack_int n, const lapack_complex_float *in, lapack_int ldin, lapack_complex_float *out, lapack_int ldout)
void LAPACKE_cpb_trans (int matrix_layout, 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_layout, char transr, char uplo, lapack_int n, const lapack_complex_float *in, lapack_complex_float *out)
void LAPACKE_cpo_trans (int matrix_layout, 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_layout, char uplo, lapack_int n, const lapack_complex_float *in, lapack_complex_float *out)
void LAPACKE_csp_trans (int matrix_layout, char uplo, lapack_int n, const lapack_complex_float *in, lapack_complex_float *out)
void LAPACKE_csy_trans (int matrix_layout, 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_layout, 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_layout, char transr, char uplo, char diag, lapack_int n, const lapack_complex_float *in, lapack_complex_float *out)
void LAPACKE_ctp_trans (int matrix_layout, char uplo, char diag, lapack_int n, const lapack_complex_float *in, lapack_complex_float *out)
void LAPACKE_ctr_trans (int matrix_layout, 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_layout, 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_layout, lapack_int m, lapack_int n, const double *in, lapack_int ldin, double *out, lapack_int ldout)
void LAPACKE_dgg_trans (int matrix_layout, lapack_int m, lapack_int n, const double *in, lapack_int ldin, double *out, lapack_int ldout)
void LAPACKE_dhs_trans (int matrix_layout, lapack_int n, const double *in, lapack_int ldin, double *out, lapack_int ldout)
void LAPACKE_dpb_trans (int matrix_layout, 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_layout, char transr, char uplo, lapack_int n, const double *in, double *out)
void LAPACKE_dpo_trans (int matrix_layout, char uplo, lapack_int n, const double *in, lapack_int ldin, double *out, lapack_int ldout)
void LAPACKE_dpp_trans (int matrix_layout, char uplo, lapack_int n, const double *in, double *out)
void LAPACKE_dsb_trans (int matrix_layout, 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_layout, char uplo, lapack_int n, const double *in, double *out)
void LAPACKE_dsy_trans (int matrix_layout, char uplo, lapack_int n, const double *in, lapack_int ldin, double *out, lapack_int ldout)
void LAPACKE_dtb_trans (int matrix_layout, 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_layout, char transr, char uplo, char diag, lapack_int n, const double *in, double *out)
void LAPACKE_dtp_trans (int matrix_layout, char uplo, char diag, lapack_int n, const double *in, double *out)
void LAPACKE_dtr_trans (int matrix_layout, char uplo, char diag, lapack_int n, const double *in, lapack_int ldin, double *out, lapack_int ldout)
void LAPACKE_sgb_trans (int matrix_layout, 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_layout, lapack_int m, lapack_int n, const float *in, lapack_int ldin, float *out, lapack_int ldout)
void LAPACKE_sgg_trans (int matrix_layout, lapack_int m, lapack_int n, const float *in, lapack_int ldin, float *out, lapack_int ldout)
void LAPACKE_shs_trans (int matrix_layout, lapack_int n, const float *in, lapack_int ldin, float *out, lapack_int ldout)
void LAPACKE_spb_trans (int matrix_layout, 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_layout, char transr, char uplo, lapack_int n, const float *in, float *out)
void LAPACKE_spo_trans (int matrix_layout, char uplo, lapack_int n, const float *in, lapack_int ldin, float *out, lapack_int ldout)
void LAPACKE_spp_trans (int matrix_layout, char uplo, lapack_int n, const float *in, float *out)
void LAPACKE_ssb_trans (int matrix_layout, 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_layout, char uplo, lapack_int n, const float *in, float *out)
void LAPACKE_ssy_trans (int matrix_layout, char uplo, lapack_int n, const float *in, lapack_int ldin, float *out, lapack_int ldout)
void LAPACKE_stb_trans (int matrix_layout, 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_layout, char transr, char uplo, char diag, lapack_int n, const float *in, float *out)
void LAPACKE_stp_trans (int matrix_layout, char uplo, char diag, lapack_int n, const float *in, float *out)
void LAPACKE_str_trans (int matrix_layout, char uplo, char diag, lapack_int n, const float *in, lapack_int ldin, float *out, lapack_int ldout)
void LAPACKE_zgb_trans (int matrix_layout, 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_layout, 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_layout, 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_layout, 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_layout, 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_layout, char uplo, lapack_int n, const lapack_complex_double *in, lapack_complex_double *out)
void LAPACKE_zhs_trans (int matrix_layout, lapack_int n, const lapack_complex_double *in, lapack_int ldin, lapack_complex_double *out, lapack_int ldout)
void LAPACKE_zpb_trans (int matrix_layout, 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_layout, char transr, char uplo, lapack_int n, const lapack_complex_double *in, lapack_complex_double *out)
void LAPACKE_zpo_trans (int matrix_layout, 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_layout, char uplo, lapack_int n, const lapack_complex_double *in, lapack_complex_double *out)
void LAPACKE_zsp_trans (int matrix_layout, char uplo, lapack_int n, const lapack_complex_double *in, lapack_complex_double *out)
void LAPACKE_zsy_trans (int matrix_layout, 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_layout, 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_layout, char transr, char uplo, char diag, lapack_int n, const lapack_complex_double *in, lapack_complex_double *out)
void LAPACKE_ztp_trans (int matrix_layout, char uplo, char diag, lapack_int n, const lapack_complex_double *in, lapack_complex_double *out)
void LAPACKE_ztr_trans (int matrix_layout, 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_layout, 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_layout, lapack_int m, lapack_int n, const lapack_complex_float *a, lapack_int lda)
lapack_logical LAPACKE_cgg_nancheck (int matrix_layout, 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_layout, char uplo, lapack_int n, lapack_int kd, const lapack_complex_float *ab, lapack_int ldab)
lapack_logical LAPACKE_che_nancheck (int matrix_layout, 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_layout, lapack_int n, const lapack_complex_float *a, lapack_int lda)
lapack_logical LAPACKE_cpb_nancheck (int matrix_layout, 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_layout, 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_layout, char uplo, lapack_int n, const lapack_complex_float *a, lapack_int lda)
lapack_logical LAPACKE_ctb_nancheck (int matrix_layout, 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_layout, char transr, char uplo, char diag, lapack_int n, const lapack_complex_float *a)
lapack_logical LAPACKE_ctp_nancheck (int matrix_layout, char uplo, char diag, lapack_int n, const lapack_complex_float *ap)
lapack_logical LAPACKE_ctr_nancheck (int matrix_layout, char uplo, char diag, lapack_int n, const lapack_complex_float *a, lapack_int lda)
lapack_logical LAPACKE_dgb_nancheck (int matrix_layout, 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_layout, lapack_int m, lapack_int n, const double *a, lapack_int lda)
lapack_logical LAPACKE_dgg_nancheck (int matrix_layout, 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_layout, lapack_int n, const double *a, lapack_int lda)
lapack_logical LAPACKE_dpb_nancheck (int matrix_layout, 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_layout, 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_layout, 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_layout, char uplo, lapack_int n, const double *a, lapack_int lda)
lapack_logical LAPACKE_dtb_nancheck (int matrix_layout, char uplo, char diag, lapack_int n, lapack_int kd, const double *ab, lapack_int ldab)
lapack_logical LAPACKE_dtf_nancheck (int matrix_layout, char transr, char uplo, char diag, lapack_int n, const double *a)
lapack_logical LAPACKE_dtp_nancheck (int matrix_layout, char uplo, char diag, lapack_int n, const double *ap)
lapack_logical LAPACKE_dtr_nancheck (int matrix_layout, char uplo, char diag, lapack_int n, const double *a, lapack_int lda)
lapack_logical LAPACKE_sgb_nancheck (int matrix_layout, 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_layout, lapack_int m, lapack_int n, const float *a, lapack_int lda)
lapack_logical LAPACKE_sgg_nancheck (int matrix_layout, 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_layout, lapack_int n, const float *a, lapack_int lda)
lapack_logical LAPACKE_spb_nancheck (int matrix_layout, 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_layout, 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_layout, 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_layout, char uplo, lapack_int n, const float *a, lapack_int lda)
lapack_logical LAPACKE_stb_nancheck (int matrix_layout, char uplo, char diag, lapack_int n, lapack_int kd, const float *ab, lapack_int ldab)
lapack_logical LAPACKE_stf_nancheck (int matrix_layout, char transr, char uplo, char diag, lapack_int n, const float *a)
lapack_logical LAPACKE_stp_nancheck (int matrix_layout, char uplo, char diag, lapack_int n, const float *ap)
lapack_logical LAPACKE_str_nancheck (int matrix_layout, char uplo, char diag, lapack_int n, const float *a, lapack_int lda)
lapack_logical LAPACKE_zgb_nancheck (int matrix_layout, 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_layout, lapack_int m, lapack_int n, const lapack_complex_double *a, lapack_int lda)
lapack_logical LAPACKE_zgg_nancheck (int matrix_layout, 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_layout, char uplo, lapack_int n, lapack_int kd, const lapack_complex_double *ab, lapack_int ldab)
lapack_logical LAPACKE_zhe_nancheck (int matrix_layout, 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_layout, lapack_int n, const lapack_complex_double *a, lapack_int lda)
lapack_logical LAPACKE_zpb_nancheck (int matrix_layout, 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_layout, 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_layout, char uplo, lapack_int n, const lapack_complex_double *a, lapack_int lda)
lapack_logical LAPACKE_ztb_nancheck (int matrix_layout, 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_layout, char transr, char uplo, char diag, lapack_int n, const lapack_complex_double *a)
lapack_logical LAPACKE_ztp_nancheck (int matrix_layout, char uplo, char diag, lapack_int n, const lapack_complex_double *ap)
lapack_logical LAPACKE_ztr_nancheck (int matrix_layout, char uplo, char diag, lapack_int n, const lapack_complex_double *a, lapack_int lda)

Macro Definition Documentation

◆ ABS

#define ABS ( x)
Value:
(((x) < 0) ? -(x) : (x))
x
x
Definition schur_example.m:53

Definition at line 43 of file lapacke_utils.h.

◆ IS_C_NONZERO

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

Definition at line 60 of file lapacke_utils.h.

60#define IS_C_NONZERO(x) ( IS_S_NONZERO(*((float*)&x)) || \
61 IS_S_NONZERO(*(((float*)&x)+1)) )

◆ IS_D_NONZERO

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

Definition at line 59 of file lapacke_utils.h.

◆ IS_S_NONZERO

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

Definition at line 58 of file lapacke_utils.h.

◆ IS_Z_NONZERO

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

Definition at line 62 of file lapacke_utils.h.

62#define IS_Z_NONZERO(x) ( IS_D_NONZERO(*((double*)&x)) || \
63 IS_D_NONZERO(*(((double*)&x)+1)) )

◆ LAPACK_CISNAN

#define LAPACK_CISNAN ( x)
Value:
( LAPACK_SISNAN(*((float*) &x)) || \
LAPACK_SISNAN(*(((float*) &x)+1)) )
LAPACK_SISNAN
#define LAPACK_SISNAN(x)
Definition lapacke_utils.h:289

Definition at line 291 of file lapacke_utils.h.

291#define LAPACK_CISNAN( x ) ( LAPACK_SISNAN(*((float*) &x)) || \
292 LAPACK_SISNAN(*(((float*) &x)+1)) )

◆ LAPACK_DISNAN

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

Definition at line 290 of file lapacke_utils.h.

◆ LAPACK_SISNAN

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

Definition at line 289 of file lapacke_utils.h.

◆ LAPACK_ZISNAN

#define LAPACK_ZISNAN ( x)
Value:
( LAPACK_DISNAN(*((double*)&x)) || \
LAPACK_DISNAN(*(((double*)&x)+1)) )
LAPACK_DISNAN
#define LAPACK_DISNAN(x)
Definition lapacke_utils.h:290

Definition at line 293 of file lapacke_utils.h.

293#define LAPACK_ZISNAN( x ) ( LAPACK_DISNAN(*((double*)&x)) || \
294 LAPACK_DISNAN(*(((double*)&x)+1)) )

◆ MAX

#define MAX ( x,
y )
Value:
(((x) > (y)) ? (x) : (y))
y
y
Definition schur_example.m:54

Definition at line 46 of file lapacke_utils.h.

◆ MAX3

#define MAX3 ( x,
y,
z )
Value:
(((x) > MAX(y,z)) ? (x) : MAX(y,z))
MAX
#define MAX(x, y)
Definition lapacke_utils.h:46

Definition at line 52 of file lapacke_utils.h.

◆ MIN

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

Definition at line 49 of file lapacke_utils.h.

◆ MIN3

#define MIN3 ( x,
y,
z )
Value:
(((x) < MIN(y,z)) ? (x) : MIN(y,z))
MIN
#define MIN(x, y)
Definition lapacke_utils.h:49

Definition at line 55 of file lapacke_utils.h.

Function Documentation

◆ LAPACKE_c_nancheck()

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

Definition at line 36 of file lapacke_c_nancheck.c.

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

◆ LAPACKE_cgb_nancheck()

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

Definition at line 36 of file lapacke_cgb_nancheck.c.

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

◆ LAPACKE_cgb_trans()

void LAPACKE_cgb_trans ( int matrix_layout,
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 39 of file lapacke_cgb_trans.c.

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

◆ LAPACKE_cge_nancheck()

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

Definition at line 36 of file lapacke_cge_nancheck.c.

40{
41 lapack_int i, j;
42
43 if( a == NULL ) return (lapack_logical) 0;
44
45 if( matrix_layout == LAPACK_COL_MAJOR ) {
46 for( j = 0; j < n; j++ ) {
47 for( i = 0; i < MIN( m, lda ); i++ ) {
48 if( LAPACK_CISNAN( a[i+(size_t)j*lda] ) )
49 return (lapack_logical) 1;
50 }
51 }
52 } else if ( matrix_layout == LAPACK_ROW_MAJOR ) {
53 for( i = 0; i < m; i++ ) {
54 for( j = 0; j < MIN( n, lda ); j++ ) {
55 if( LAPACK_CISNAN( a[(size_t)i*lda+j] ) )
56 return (lapack_logical) 1;
57 }
58 }
59 }
60 return (lapack_logical) 0;
61}

◆ LAPACKE_cge_trans()

void LAPACKE_cge_trans ( int matrix_layout,
lapack_int m,
lapack_int n,
const lapack_complex_float * in,
lapack_int ldin,
lapack_complex_float * out,
lapack_int ldout )

Definition at line 39 of file lapacke_cge_trans.c.

42{
43 lapack_int i, j, x, y;
44
45 if( in == NULL || out == NULL ) return;
46
47 if( matrix_layout == LAPACK_COL_MAJOR ) {
48 x = n;
49 y = m;
50 } else if ( matrix_layout == LAPACK_ROW_MAJOR ) {
51 x = m;
52 y = n;
53 } else {
54 /* Unknown input layout */
55 return;
56 }
57
58 /* In case of incorrect m, n, ldin or ldout the function does nothing */
59 for( i = 0; i < MIN( y, ldin ); i++ ) {
60 for( j = 0; j < MIN( x, ldout ); j++ ) {
61 out[ (size_t)i*ldout + j ] = in[ (size_t)j*ldin + i ];
62 }
63 }
64}

◆ LAPACKE_cgg_nancheck()

lapack_logical LAPACKE_cgg_nancheck ( int matrix_layout,
lapack_int m,
lapack_int n,
const lapack_complex_float * a,
lapack_int lda )

Definition at line 36 of file lapacke_cgg_nancheck.c.

40{
41 return LAPACKE_cge_nancheck( matrix_layout, m, n, a, lda );
42}
LAPACKE_cge_nancheck
lapack_logical LAPACKE_cge_nancheck(int matrix_layout, lapack_int m, lapack_int n, const lapack_complex_float *a, lapack_int lda)
Definition lapacke_cge_nancheck.c:36

◆ LAPACKE_cgg_trans()

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

Definition at line 39 of file lapacke_cgg_trans.c.

42{
43 LAPACKE_cge_trans( matrix_layout, m, n, in, ldin, out, ldout );
44}
LAPACKE_cge_trans
void LAPACKE_cge_trans(int matrix_layout, lapack_int m, lapack_int n, const lapack_complex_float *in, lapack_int ldin, lapack_complex_float *out, lapack_int ldout)
Definition lapacke_cge_trans.c:39

◆ LAPACKE_cgt_nancheck()

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 36 of file lapacke_cgt_nancheck.c.

40{
41 return LAPACKE_c_nancheck( n-1, dl, 1 )
42 || LAPACKE_c_nancheck( n , d, 1 )
43 || LAPACKE_c_nancheck( n-1, du, 1 );
44}
LAPACKE_c_nancheck
lapack_logical LAPACKE_c_nancheck(lapack_int n, const lapack_complex_float *x, lapack_int incx)
Definition lapacke_c_nancheck.c:36

◆ LAPACKE_chb_nancheck()

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

Definition at line 36 of file lapacke_chb_nancheck.c.

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

◆ LAPACKE_chb_trans()

void LAPACKE_chb_trans ( int matrix_layout,
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 39 of file lapacke_chb_trans.c.

43{
44 if( LAPACKE_lsame( uplo, 'u' ) ) {
45 LAPACKE_cgb_trans( matrix_layout, n, n, 0, kd, in, ldin, out, ldout );
46 } else if( LAPACKE_lsame( uplo, 'l' ) ) {
47 LAPACKE_cgb_trans( matrix_layout, n, n, kd, 0, in, ldin, out, ldout );
48 }
49}
LAPACKE_cgb_trans
void LAPACKE_cgb_trans(int matrix_layout, 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 lapacke_cgb_trans.c:39

◆ LAPACKE_che_nancheck()

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

Definition at line 36 of file lapacke_che_nancheck.c.

40{
41 return LAPACKE_ctr_nancheck( matrix_layout, uplo, 'n', n, a, lda );
42}
LAPACKE_ctr_nancheck
lapack_logical LAPACKE_ctr_nancheck(int matrix_layout, char uplo, char diag, lapack_int n, const lapack_complex_float *a, lapack_int lda)
Definition lapacke_ctr_nancheck.c:36

◆ LAPACKE_che_trans()

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

Definition at line 39 of file lapacke_che_trans.c.

42{
43 LAPACKE_ctr_trans( matrix_layout, uplo, 'n', n, in, ldin, out, ldout );
44}
LAPACKE_ctr_trans
void LAPACKE_ctr_trans(int matrix_layout, char uplo, char diag, lapack_int n, const lapack_complex_float *in, lapack_int ldin, lapack_complex_float *out, lapack_int ldout)
Definition lapacke_ctr_trans.c:39

◆ LAPACKE_chp_nancheck()

lapack_logical LAPACKE_chp_nancheck ( lapack_int n,
const lapack_complex_float * ap )

Definition at line 39 of file lapacke_chp_nancheck.c.

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

◆ LAPACKE_chp_trans()

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

Definition at line 39 of file lapacke_chp_trans.c.

42{
43 LAPACKE_ctp_trans( matrix_layout, uplo, 'n', n, in, out );
44}
LAPACKE_ctp_trans
void LAPACKE_ctp_trans(int matrix_layout, char uplo, char diag, lapack_int n, const lapack_complex_float *in, lapack_complex_float *out)
Definition lapacke_ctp_trans.c:39

◆ LAPACKE_chs_nancheck()

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

Definition at line 36 of file lapacke_chs_nancheck.c.

39{
40 lapack_logical subdiag_nans;
41
42 if( a == NULL ) return (lapack_logical) 0;
43
44 /* Check subdiagonal first */
45 if( matrix_layout == LAPACK_COL_MAJOR ) {
46 subdiag_nans = LAPACKE_c_nancheck( n-1, &a[1], lda+1 );
47 } else if ( matrix_layout == LAPACK_ROW_MAJOR ) {
48 subdiag_nans = LAPACKE_c_nancheck( n-1, &a[lda], lda+1 );
49 } else {
50 return (lapack_logical) 0;
51 }
52
53 /* Check upper triangular if subdiagonal has no NaNs. */
54 return subdiag_nans || LAPACKE_ctr_nancheck( matrix_layout, 'u', 'n',
55 n, a, lda);
56}

◆ LAPACKE_chs_trans()

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

Definition at line 39 of file lapacke_chs_trans.c.

42{
43 if( in == NULL || out == NULL ) return;
44
45 /* Convert subdiagonal first */
46 if( matrix_layout == LAPACK_COL_MAJOR ) {
47 LAPACKE_cge_trans( LAPACK_COL_MAJOR, 1, n-1, &in[1], ldin+1,
48 &out[ldout], ldout+1 );
49 } else if ( matrix_layout == LAPACK_ROW_MAJOR ) {
50 LAPACKE_cge_trans( LAPACK_ROW_MAJOR, n-1, 1, &in[ldin], ldin+1,
51 &out[1], ldout+1 );
52 } else {
53 return;
54 }
55
56 /* Convert upper triangular. */
57 LAPACKE_ctr_trans( matrix_layout, 'u', 'n', n, in, ldin, out, ldout);
58}

◆ LAPACKE_cpb_nancheck()

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

Definition at line 36 of file lapacke_cpb_nancheck.c.

40{
41 if( LAPACKE_lsame( uplo, 'u' ) ) {
42 return LAPACKE_cgb_nancheck( matrix_layout, n, n, 0, kd, ab, ldab );
43 } else if( LAPACKE_lsame( uplo, 'l' ) ) {
44 return LAPACKE_cgb_nancheck( matrix_layout, n, n, kd, 0, ab, ldab );
45 }
46 return (lapack_logical) 0;
47}

◆ LAPACKE_cpb_trans()

void LAPACKE_cpb_trans ( int matrix_layout,
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 39 of file lapacke_cpb_trans.c.

43{
44 if( LAPACKE_lsame( uplo, 'u' ) ) {
45 LAPACKE_cgb_trans( matrix_layout, n, n, 0, kd, in, ldin, out, ldout );
46 } else if( LAPACKE_lsame( uplo, 'l' ) ) {
47 LAPACKE_cgb_trans( matrix_layout, n, n, kd, 0, in, ldin, out, ldout );
48 }
49}

◆ LAPACKE_cpf_nancheck()

lapack_logical LAPACKE_cpf_nancheck ( lapack_int n,
const lapack_complex_float * a )

Definition at line 40 of file lapacke_cpf_nancheck.c.

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

◆ LAPACKE_cpf_trans()

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

Definition at line 39 of file lapacke_cpf_trans.c.

42{
43 LAPACKE_ctf_trans( matrix_layout, transr, uplo, 'n', n, in, out );
44}
LAPACKE_ctf_trans
void LAPACKE_ctf_trans(int matrix_layout, char transr, char uplo, char diag, lapack_int n, const lapack_complex_float *in, lapack_complex_float *out)
Definition lapacke_ctf_trans.c:40

◆ LAPACKE_cpo_nancheck()

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

Definition at line 36 of file lapacke_cpo_nancheck.c.

40{
41 return LAPACKE_ctr_nancheck( matrix_layout, uplo, 'n', n, a, lda );
42}

◆ LAPACKE_cpo_trans()

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

Definition at line 39 of file lapacke_cpo_trans.c.

42{
43 LAPACKE_ctr_trans( matrix_layout, uplo, 'n', n, in, ldin, out, ldout );
44}

◆ LAPACKE_cpp_nancheck()

lapack_logical LAPACKE_cpp_nancheck ( lapack_int n,
const lapack_complex_float * ap )

Definition at line 39 of file lapacke_cpp_nancheck.c.

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

◆ LAPACKE_cpp_trans()

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

Definition at line 39 of file lapacke_cpp_trans.c.

42{
43 LAPACKE_ctp_trans( matrix_layout, uplo, 'n', n, in, out );
44}

◆ LAPACKE_cpt_nancheck()

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

Definition at line 36 of file lapacke_cpt_nancheck.c.

39{
40 return LAPACKE_s_nancheck( n, d, 1 )
41 || LAPACKE_c_nancheck( n-1, e, 1 );
42}
LAPACKE_s_nancheck
lapack_logical LAPACKE_s_nancheck(lapack_int n, const float *x, lapack_int incx)
Definition lapacke_s_nancheck.c:36

◆ LAPACKE_csp_nancheck()

lapack_logical LAPACKE_csp_nancheck ( lapack_int n,
const lapack_complex_float * ap )

Definition at line 39 of file lapacke_csp_nancheck.c.

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

◆ LAPACKE_csp_trans()

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

Definition at line 39 of file lapacke_csp_trans.c.

42{
43 LAPACKE_ctp_trans( matrix_layout, uplo, 'n', n, in, out );
44}

◆ LAPACKE_cst_nancheck()

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

Definition at line 36 of file lapacke_cst_nancheck.c.

39{
40 return LAPACKE_c_nancheck( n, d, 1 )
41 || LAPACKE_c_nancheck( n-1, e, 1 );
42}

◆ LAPACKE_csy_nancheck()

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

Definition at line 36 of file lapacke_csy_nancheck.c.

40{
41 return LAPACKE_ctr_nancheck( matrix_layout, uplo, 'n', n, a, lda );
42}

◆ LAPACKE_csy_trans()

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

Definition at line 39 of file lapacke_csy_trans.c.

42{
43 LAPACKE_ctr_trans( matrix_layout, uplo, 'n', n, in, ldin, out, ldout );
44}

◆ LAPACKE_ctb_nancheck()

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

Definition at line 36 of file lapacke_ctb_nancheck.c.

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

◆ LAPACKE_ctb_trans()

void LAPACKE_ctb_trans ( int matrix_layout,
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 39 of file lapacke_ctb_trans.c.

43{
44 lapack_logical colmaj, upper, unit;
45
46 if( in == NULL || out == NULL ) return;
47
48 colmaj = ( matrix_layout == LAPACK_COL_MAJOR );
49 upper = LAPACKE_lsame( uplo, 'u' );
50 unit = LAPACKE_lsame( diag, 'u' );
51
52 if( ( !colmaj && ( matrix_layout != LAPACK_ROW_MAJOR ) ) ||
53 ( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
54 ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
55 /* Just exit if any of input parameters are wrong */
56 return;
57 }
58
59 if( unit ) {
60 /* Unit case, diagonal excluded from transposition */
61 if( colmaj ) {
62 if( upper ) {
63 LAPACKE_cgb_trans( matrix_layout, n-1, n-1, 0, kd-1,
64 &in[ldin], ldin, &out[1], ldout );
65 } else {
66 LAPACKE_cgb_trans( matrix_layout, n-1, n-1, kd-1, 0,
67 &in[1], ldin, &out[ldout], ldout );
68 }
69 } else {
70 if( upper ) {
71 LAPACKE_cgb_trans( matrix_layout, n-1, n-1, 0, kd-1,
72 &in[1], ldin, &out[ldout], ldout );
73 } else {
74 LAPACKE_cgb_trans( matrix_layout, n-1, n-1, kd-1, 0,
75 &in[ldin], ldin, &out[1], ldout );
76 }
77 }
78 } else {
79 /* Non-unit case */
80 if( upper ) {
81 LAPACKE_cgb_trans( matrix_layout, n, n, 0, kd, in, ldin, out,
82 ldout );
83 } else {
84 LAPACKE_cgb_trans( matrix_layout, n, n, kd, 0, in, ldin, out,
85 ldout );
86 }
87 }
88}

◆ LAPACKE_ctf_nancheck()

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

Definition at line 36 of file lapacke_ctf_nancheck.c.

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

◆ LAPACKE_ctf_trans()

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

Definition at line 40 of file lapacke_ctf_trans.c.

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

◆ LAPACKE_ctp_nancheck()

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

Definition at line 39 of file lapacke_ctp_nancheck.c.

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

◆ LAPACKE_ctp_trans()

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

Definition at line 39 of file lapacke_ctp_trans.c.

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

◆ LAPACKE_ctr_nancheck()

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

Definition at line 36 of file lapacke_ctr_nancheck.c.

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

◆ LAPACKE_ctr_trans()

void LAPACKE_ctr_trans ( int matrix_layout,
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 39 of file lapacke_ctr_trans.c.

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

◆ LAPACKE_d_nancheck()

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

Definition at line 36 of file lapacke_d_nancheck.c.

39{
40 lapack_int i, inc;
41
42 if( incx == 0 ) return (lapack_logical) LAPACK_DISNAN( x[0] );
43 inc = ( incx > 0 ) ? incx : -incx ;
44
45 for( i = 0; i < n*inc; i+=inc ) {
46 if( LAPACK_DISNAN( x[i] ) )
47 return (lapack_logical) 1;
48 }
49 return (lapack_logical) 0;
50}

◆ LAPACKE_dgb_nancheck()

lapack_logical LAPACKE_dgb_nancheck ( int matrix_layout,
lapack_int m,
lapack_int n,
lapack_int kl,
lapack_int ku,
const double * ab,
lapack_int ldab )

Definition at line 36 of file lapacke_dgb_nancheck.c.

41{
42 lapack_int i, j;
43
44 if( ab == NULL ) return (lapack_logical) 0;
45
46 if( matrix_layout == LAPACK_COL_MAJOR ) {
47 for( j = 0; j < n; j++ ) {
48 for( i = MAX( ku-j, 0 ); i < MIN( m+ku-j, kl+ku+1 );
49 i++ ) {
50 if( LAPACK_DISNAN( ab[i+(size_t)j*ldab] ) )
51 return (lapack_logical) 1;
52 }
53 }
54 } else if ( matrix_layout == LAPACK_ROW_MAJOR ) {
55 for( j = 0; j < n; j++ ) {
56 for( i = MAX( ku-j, 0 ); i < MIN( m+ku-j, kl+ku+1 ); i++ ) {
57 if( LAPACK_DISNAN( ab[(size_t)i*ldab+j] ) )
58 return (lapack_logical) 1;
59 }
60 }
61 }
62 return (lapack_logical) 0;
63}

◆ LAPACKE_dgb_trans()

void LAPACKE_dgb_trans ( int matrix_layout,
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 39 of file lapacke_dgb_trans.c.

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

◆ LAPACKE_dge_nancheck()

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

Definition at line 36 of file lapacke_dge_nancheck.c.

40{
41 lapack_int i, j;
42
43 if( a == NULL ) return (lapack_logical) 0;
44
45 if( matrix_layout == LAPACK_COL_MAJOR ) {
46 for( j = 0; j < n; j++ ) {
47 for( i = 0; i < MIN( m, lda ); i++ ) {
48 if( LAPACK_DISNAN( a[i+(size_t)j*lda] ) )
49 return (lapack_logical) 1;
50 }
51 }
52 } else if ( matrix_layout == LAPACK_ROW_MAJOR ) {
53 for( i = 0; i < m; i++ ) {
54 for( j = 0; j < MIN( n, lda ); j++ ) {
55 if( LAPACK_DISNAN( a[(size_t)i*lda+j] ) )
56 return (lapack_logical) 1;
57 }
58 }
59 }
60 return (lapack_logical) 0;
61}

◆ LAPACKE_dge_trans()

void LAPACKE_dge_trans ( int matrix_layout,
lapack_int m,
lapack_int n,
const double * in,
lapack_int ldin,
double * out,
lapack_int ldout )

Definition at line 39 of file lapacke_dge_trans.c.

42{
43 lapack_int i, j, x, y;
44
45 if( in == NULL || out == NULL ) return;
46
47 if( matrix_layout == LAPACK_COL_MAJOR ) {
48 x = n;
49 y = m;
50 } else if ( matrix_layout == LAPACK_ROW_MAJOR ) {
51 x = m;
52 y = n;
53 } else {
54 /* Unknown input layout */
55 return;
56 }
57
58 /* In case of incorrect m, n, ldin or ldout the function does nothing */
59 for( i = 0; i < MIN( y, ldin ); i++ ) {
60 for( j = 0; j < MIN( x, ldout ); j++ ) {
61 out[ (size_t)i*ldout + j ] = in[ (size_t)j*ldin + i ];
62 }
63 }
64}

◆ LAPACKE_dgg_nancheck()

lapack_logical LAPACKE_dgg_nancheck ( int matrix_layout,
lapack_int m,
lapack_int n,
const double * a,
lapack_int lda )

Definition at line 36 of file lapacke_dgg_nancheck.c.

40{
41 return LAPACKE_dge_nancheck( matrix_layout, m, n, a, lda );
42}
LAPACKE_dge_nancheck
lapack_logical LAPACKE_dge_nancheck(int matrix_layout, lapack_int m, lapack_int n, const double *a, lapack_int lda)
Definition lapacke_dge_nancheck.c:36

◆ LAPACKE_dgg_trans()

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

Definition at line 39 of file lapacke_dgg_trans.c.

42{
43 LAPACKE_dge_trans( matrix_layout, m, n, in, ldin, out, ldout );
44}
LAPACKE_dge_trans
void LAPACKE_dge_trans(int matrix_layout, lapack_int m, lapack_int n, const double *in, lapack_int ldin, double *out, lapack_int ldout)
Definition lapacke_dge_trans.c:39

◆ LAPACKE_dgt_nancheck()

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

Definition at line 36 of file lapacke_dgt_nancheck.c.

40{
41 return LAPACKE_d_nancheck( n-1, dl, 1 )
42 || LAPACKE_d_nancheck( n , d, 1 )
43 || LAPACKE_d_nancheck( n-1, du, 1 );
44}
LAPACKE_d_nancheck
lapack_logical LAPACKE_d_nancheck(lapack_int n, const double *x, lapack_int incx)
Definition lapacke_d_nancheck.c:36

◆ LAPACKE_dhs_nancheck()

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

Definition at line 36 of file lapacke_dhs_nancheck.c.

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

◆ LAPACKE_dhs_trans()

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

Definition at line 39 of file lapacke_dhs_trans.c.

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

◆ LAPACKE_dpb_nancheck()

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

Definition at line 36 of file lapacke_dpb_nancheck.c.

40{
41 if( LAPACKE_lsame( uplo, 'u' ) ) {
42 return LAPACKE_dgb_nancheck( matrix_layout, n, n, 0, kd, ab, ldab );
43 } else if( LAPACKE_lsame( uplo, 'l' ) ) {
44 return LAPACKE_dgb_nancheck( matrix_layout, n, n, kd, 0, ab, ldab );
45 }
46 return (lapack_logical) 0;
47}
LAPACKE_dgb_nancheck
lapack_logical LAPACKE_dgb_nancheck(int matrix_layout, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const double *ab, lapack_int ldab)
Definition lapacke_dgb_nancheck.c:36

◆ LAPACKE_dpb_trans()

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

Definition at line 39 of file lapacke_dpb_trans.c.

43{
44 if( LAPACKE_lsame( uplo, 'u' ) ) {
45 LAPACKE_dgb_trans( matrix_layout, n, n, 0, kd, in, ldin, out, ldout );
46 } else if( LAPACKE_lsame( uplo, 'l' ) ) {
47 LAPACKE_dgb_trans( matrix_layout, n, n, kd, 0, in, ldin, out, ldout );
48 }
49}
LAPACKE_dgb_trans
void LAPACKE_dgb_trans(int matrix_layout, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const double *in, lapack_int ldin, double *out, lapack_int ldout)
Definition lapacke_dgb_trans.c:39

◆ LAPACKE_dpf_nancheck()

lapack_logical LAPACKE_dpf_nancheck ( lapack_int n,
const double * a )

Definition at line 40 of file lapacke_dpf_nancheck.c.

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

◆ LAPACKE_dpf_trans()

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

Definition at line 39 of file lapacke_dpf_trans.c.

42{
43 LAPACKE_dtf_trans( matrix_layout, transr, uplo, 'n', n, in, out );
44}
LAPACKE_dtf_trans
void LAPACKE_dtf_trans(int matrix_layout, char transr, char uplo, char diag, lapack_int n, const double *in, double *out)
Definition lapacke_dtf_trans.c:40

◆ LAPACKE_dpo_nancheck()

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

Definition at line 36 of file lapacke_dpo_nancheck.c.

40{
41 return LAPACKE_dtr_nancheck( matrix_layout, uplo, 'n', n, a, lda );
42}

◆ LAPACKE_dpo_trans()

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

Definition at line 39 of file lapacke_dpo_trans.c.

42{
43 LAPACKE_dtr_trans( matrix_layout, uplo, 'n', n, in, ldin, out, ldout );
44}

◆ LAPACKE_dpp_nancheck()

lapack_logical LAPACKE_dpp_nancheck ( lapack_int n,
const double * ap )

Definition at line 39 of file lapacke_dpp_nancheck.c.

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

◆ LAPACKE_dpp_trans()

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

Definition at line 39 of file lapacke_dpp_trans.c.

42{
43 LAPACKE_dtp_trans( matrix_layout, uplo, 'n', n, in, out );
44}
LAPACKE_dtp_trans
void LAPACKE_dtp_trans(int matrix_layout, char uplo, char diag, lapack_int n, const double *in, double *out)
Definition lapacke_dtp_trans.c:39

◆ LAPACKE_dpt_nancheck()

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

Definition at line 36 of file lapacke_dpt_nancheck.c.

39{
40 return LAPACKE_d_nancheck( n, d, 1 )
41 || LAPACKE_d_nancheck( n-1, e, 1 );
42}

◆ LAPACKE_dsb_nancheck()

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

Definition at line 36 of file lapacke_dsb_nancheck.c.

40{
41 if( LAPACKE_lsame( uplo, 'u' ) ) {
42 return LAPACKE_dgb_nancheck( matrix_layout, n, n, 0, kd, ab, ldab );
43 } else if( LAPACKE_lsame( uplo, 'l' ) ) {
44 return LAPACKE_dgb_nancheck( matrix_layout, n, n, kd, 0, ab, ldab );
45 }
46 return (lapack_logical) 0;
47}

◆ LAPACKE_dsb_trans()

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

Definition at line 39 of file lapacke_dsb_trans.c.

43{
44 if( LAPACKE_lsame( uplo, 'u' ) ) {
45 LAPACKE_dgb_trans( matrix_layout, n, n, 0, kd, in, ldin, out, ldout );
46 } else if( LAPACKE_lsame( uplo, 'l' ) ) {
47 LAPACKE_dgb_trans( matrix_layout, n, n, kd, 0, in, ldin, out, ldout );
48 }
49}

◆ LAPACKE_dsp_nancheck()

lapack_logical LAPACKE_dsp_nancheck ( lapack_int n,
const double * ap )

Definition at line 39 of file lapacke_dsp_nancheck.c.

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

◆ LAPACKE_dsp_trans()

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

Definition at line 39 of file lapacke_dsp_trans.c.

42{
43 LAPACKE_dtp_trans( matrix_layout, uplo, 'n', n, in, out );
44}

◆ LAPACKE_dst_nancheck()

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

Definition at line 36 of file lapacke_dst_nancheck.c.

39{
40 return LAPACKE_d_nancheck( n, d, 1 )
41 || LAPACKE_d_nancheck( n-1, e, 1 );
42}

◆ LAPACKE_dsy_nancheck()

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

Definition at line 36 of file lapacke_dsy_nancheck.c.

40{
41 return LAPACKE_dtr_nancheck( matrix_layout, uplo, 'n', n, a, lda );
42}

◆ LAPACKE_dsy_trans()

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

Definition at line 39 of file lapacke_dsy_trans.c.

42{
43 LAPACKE_dtr_trans( matrix_layout, uplo, 'n', n, in, ldin, out, ldout );
44}

◆ LAPACKE_dtb_nancheck()

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

Definition at line 36 of file lapacke_dtb_nancheck.c.

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

◆ LAPACKE_dtb_trans()

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

Definition at line 39 of file lapacke_dtb_trans.c.

43{
44 lapack_logical colmaj, upper, unit;
45
46 if( in == NULL || out == NULL ) return;
47
48 colmaj = ( matrix_layout == LAPACK_COL_MAJOR );
49 upper = LAPACKE_lsame( uplo, 'u' );
50 unit = LAPACKE_lsame( diag, 'u' );
51
52 if( ( !colmaj && ( matrix_layout != LAPACK_ROW_MAJOR ) ) ||
53 ( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
54 ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
55 /* Just exit if any of input parameters are wrong */
56 return;
57 }
58
59 if( unit ) {
60 /* Unit case, diagonal excluded from transposition */
61 if( colmaj ) {
62 if( upper ) {
63 LAPACKE_dgb_trans( matrix_layout, n-1, n-1, 0, kd-1,
64 &in[ldin], ldin, &out[1], ldout );
65 } else {
66 LAPACKE_dgb_trans( matrix_layout, n-1, n-1, kd-1, 0,
67 &in[1], ldin, &out[ldout], ldout );
68 }
69 } else {
70 if( upper ) {
71 LAPACKE_dgb_trans( matrix_layout, n-1, n-1, 0, kd-1,
72 &in[1], ldin, &out[ldout], ldout );
73 } else {
74 LAPACKE_dgb_trans( matrix_layout, n-1, n-1, kd-1, 0,
75 &in[ldin], ldin, &out[1], ldout );
76 }
77 }
78 } else {
79 /* Non-unit case */
80 if( upper ) {
81 LAPACKE_dgb_trans( matrix_layout, n, n, 0, kd, in, ldin, out,
82 ldout );
83 } else {
84 LAPACKE_dgb_trans( matrix_layout, n, n, kd, 0, in, ldin, out,
85 ldout );
86 }
87 }
88}

◆ LAPACKE_dtf_nancheck()

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

Definition at line 36 of file lapacke_dtf_nancheck.c.

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

◆ LAPACKE_dtf_trans()

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

Definition at line 40 of file lapacke_dtf_trans.c.

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

◆ LAPACKE_dtp_nancheck()

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

Definition at line 39 of file lapacke_dtp_nancheck.c.

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

◆ LAPACKE_dtp_trans()

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

Definition at line 39 of file lapacke_dtp_trans.c.

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

◆ LAPACKE_dtr_nancheck()

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

Definition at line 36 of file lapacke_dtr_nancheck.c.

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

◆ LAPACKE_dtr_trans()

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

Definition at line 39 of file lapacke_dtr_trans.c.

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

◆ LAPACKE_lsame()

lapack_logical LAPACKE_lsame ( char ca,
char cb )

Definition at line 35 of file lapacke_lsame.c.

36{
37 return (lapack_logical) LAPACK_lsame( &ca, &cb, 1, 1 );
38}
LAPACK_lsame
#define LAPACK_lsame(...)
Definition lapack.h:125

◆ LAPACKE_s_nancheck()

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

Definition at line 36 of file lapacke_s_nancheck.c.

39{
40 lapack_int i, inc;
41
42 if( incx == 0 ) return (lapack_logical) LAPACK_SISNAN( x[0] );
43 inc = ( incx > 0 ) ? incx : -incx ;
44
45 for( i = 0; i < n*inc; i+=inc ) {
46 if( LAPACK_SISNAN( x[i] ) )
47 return (lapack_logical) 1;
48 }
49 return (lapack_logical) 0;
50}

◆ LAPACKE_sgb_nancheck()

lapack_logical LAPACKE_sgb_nancheck ( int matrix_layout,
lapack_int m,
lapack_int n,
lapack_int kl,
lapack_int ku,
const float * ab,
lapack_int ldab )

Definition at line 36 of file lapacke_sgb_nancheck.c.

41{
42 lapack_int i, j;
43
44 if( ab == NULL ) return (lapack_logical) 0;
45
46 if( matrix_layout == LAPACK_COL_MAJOR ) {
47 for( j = 0; j < n; j++ ) {
48 for( i = MAX( ku-j, 0 ); i < MIN( m+ku-j, kl+ku+1 );
49 i++ ) {
50 if( LAPACK_SISNAN( ab[i+(size_t)j*ldab] ) )
51 return (lapack_logical) 1;
52 }
53 }
54 } else if ( matrix_layout == LAPACK_ROW_MAJOR ) {
55 for( j = 0; j < n; j++ ) {
56 for( i = MAX( ku-j, 0 ); i < MIN( m+ku-j, kl+ku+1 ); i++ ) {
57 if( LAPACK_SISNAN( ab[(size_t)i*ldab+j] ) )
58 return (lapack_logical) 1;
59 }
60 }
61 }
62 return (lapack_logical) 0;
63}

◆ LAPACKE_sgb_trans()

void LAPACKE_sgb_trans ( int matrix_layout,
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 39 of file lapacke_sgb_trans.c.

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

◆ LAPACKE_sge_nancheck()

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

Definition at line 36 of file lapacke_sge_nancheck.c.

40{
41 lapack_int i, j;
42
43 if( a == NULL ) return (lapack_logical) 0;
44
45 if( matrix_layout == LAPACK_COL_MAJOR ) {
46 for( j = 0; j < n; j++ ) {
47 for( i = 0; i < MIN( m, lda ); i++ ) {
48 if( LAPACK_SISNAN( a[i+(size_t)j*lda] ) )
49 return (lapack_logical) 1;
50 }
51 }
52 } else if ( matrix_layout == LAPACK_ROW_MAJOR ) {
53 for( i = 0; i < m; i++ ) {
54 for( j = 0; j < MIN( n, lda ); j++ ) {
55 if( LAPACK_SISNAN( a[(size_t)i*lda+j] ) )
56 return (lapack_logical) 1;
57 }
58 }
59 }
60 return (lapack_logical) 0;
61}

◆ LAPACKE_sge_trans()

void LAPACKE_sge_trans ( int matrix_layout,
lapack_int m,
lapack_int n,
const float * in,
lapack_int ldin,
float * out,
lapack_int ldout )

Definition at line 39 of file lapacke_sge_trans.c.

42{
43 lapack_int i, j, x, y;
44
45 if( in == NULL || out == NULL ) return;
46
47 if( matrix_layout == LAPACK_COL_MAJOR ) {
48 x = n;
49 y = m;
50 } else if ( matrix_layout == LAPACK_ROW_MAJOR ) {
51 x = m;
52 y = n;
53 } else {
54 /* Unknown input layout */
55 return;
56 }
57
58 /* In case of incorrect m, n, ldin or ldout the function does nothing */
59 for( i = 0; i < MIN( y, ldin ); i++ ) {
60 for( j = 0; j < MIN( x, ldout ); j++ ) {
61 out[ (size_t)i*ldout + j ] = in[ (size_t)j*ldin + i ];
62 }
63 }
64}

◆ LAPACKE_sgg_nancheck()

lapack_logical LAPACKE_sgg_nancheck ( int matrix_layout,
lapack_int m,
lapack_int n,
const float * a,
lapack_int lda )

Definition at line 36 of file lapacke_sgg_nancheck.c.

40{
41 return LAPACKE_sge_nancheck( matrix_layout, m, n, a, lda );
42}
LAPACKE_sge_nancheck
lapack_logical LAPACKE_sge_nancheck(int matrix_layout, lapack_int m, lapack_int n, const float *a, lapack_int lda)
Definition lapacke_sge_nancheck.c:36

◆ LAPACKE_sgg_trans()

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

Definition at line 39 of file lapacke_sgg_trans.c.

42{
43 LAPACKE_sge_trans( matrix_layout, m, n, in, ldin, out, ldout );
44}
LAPACKE_sge_trans
void LAPACKE_sge_trans(int matrix_layout, lapack_int m, lapack_int n, const float *in, lapack_int ldin, float *out, lapack_int ldout)
Definition lapacke_sge_trans.c:39

◆ LAPACKE_sgt_nancheck()

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

Definition at line 36 of file lapacke_sgt_nancheck.c.

40{
41 return LAPACKE_s_nancheck( n-1, dl, 1 )
42 || LAPACKE_s_nancheck( n , d, 1 )
43 || LAPACKE_s_nancheck( n-1, du, 1 );
44}

◆ LAPACKE_shs_nancheck()

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

Definition at line 36 of file lapacke_shs_nancheck.c.

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

◆ LAPACKE_shs_trans()

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

Definition at line 39 of file lapacke_shs_trans.c.

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

◆ LAPACKE_spb_nancheck()

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

Definition at line 36 of file lapacke_spb_nancheck.c.

40{
41 if( LAPACKE_lsame( uplo, 'u' ) ) {
42 return LAPACKE_sgb_nancheck( matrix_layout, n, n, 0, kd, ab, ldab );
43 } else if( LAPACKE_lsame( uplo, 'l' ) ) {
44 return LAPACKE_sgb_nancheck( matrix_layout, n, n, kd, 0, ab, ldab );
45 }
46 return (lapack_logical) 0;
47}
LAPACKE_sgb_nancheck
lapack_logical LAPACKE_sgb_nancheck(int matrix_layout, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const float *ab, lapack_int ldab)
Definition lapacke_sgb_nancheck.c:36

◆ LAPACKE_spb_trans()

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

Definition at line 39 of file lapacke_spb_trans.c.

43{
44 if( LAPACKE_lsame( uplo, 'u' ) ) {
45 LAPACKE_sgb_trans( matrix_layout, n, n, 0, kd, in, ldin, out, ldout );
46 } else if( LAPACKE_lsame( uplo, 'l' ) ) {
47 LAPACKE_sgb_trans( matrix_layout, n, n, kd, 0, in, ldin, out, ldout );
48 }
49}
LAPACKE_sgb_trans
void LAPACKE_sgb_trans(int matrix_layout, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const float *in, lapack_int ldin, float *out, lapack_int ldout)
Definition lapacke_sgb_trans.c:39

◆ LAPACKE_spf_nancheck()

lapack_logical LAPACKE_spf_nancheck ( lapack_int n,
const float * a )

Definition at line 40 of file lapacke_spf_nancheck.c.

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

◆ LAPACKE_spf_trans()

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

Definition at line 39 of file lapacke_spf_trans.c.

42{
43 LAPACKE_stf_trans( matrix_layout, transr, uplo, 'n', n, in, out );
44}
LAPACKE_stf_trans
void LAPACKE_stf_trans(int matrix_layout, char transr, char uplo, char diag, lapack_int n, const float *in, float *out)
Definition lapacke_stf_trans.c:40

◆ LAPACKE_spo_nancheck()

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

Definition at line 36 of file lapacke_spo_nancheck.c.

40{
41 return LAPACKE_str_nancheck( matrix_layout, uplo, 'n', n, a, lda );
42}

◆ LAPACKE_spo_trans()

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

Definition at line 39 of file lapacke_spo_trans.c.

42{
43 LAPACKE_str_trans( matrix_layout, uplo, 'n', n, in, ldin, out, ldout );
44}

◆ LAPACKE_spp_nancheck()

lapack_logical LAPACKE_spp_nancheck ( lapack_int n,
const float * ap )

Definition at line 39 of file lapacke_spp_nancheck.c.

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

◆ LAPACKE_spp_trans()

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

Definition at line 39 of file lapacke_spp_trans.c.

42{
43 LAPACKE_stp_trans( matrix_layout, uplo, 'n', n, in, out );
44}
LAPACKE_stp_trans
void LAPACKE_stp_trans(int matrix_layout, char uplo, char diag, lapack_int n, const float *in, float *out)
Definition lapacke_stp_trans.c:39

◆ LAPACKE_spt_nancheck()

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

Definition at line 36 of file lapacke_spt_nancheck.c.

39{
40 return LAPACKE_s_nancheck( n, d, 1 )
41 || LAPACKE_s_nancheck( n-1, e, 1 );
42}

◆ LAPACKE_ssb_nancheck()

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

Definition at line 36 of file lapacke_ssb_nancheck.c.

40{
41 if( LAPACKE_lsame( uplo, 'u' ) ) {
42 return LAPACKE_sgb_nancheck( matrix_layout, n, n, 0, kd, ab, ldab );
43 } else if( LAPACKE_lsame( uplo, 'l' ) ) {
44 return LAPACKE_sgb_nancheck( matrix_layout, n, n, kd, 0, ab, ldab );
45 }
46 return (lapack_logical) 0;
47}

◆ LAPACKE_ssb_trans()

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

Definition at line 39 of file lapacke_ssb_trans.c.

43{
44 if( LAPACKE_lsame( uplo, 'u' ) ) {
45 LAPACKE_sgb_trans( matrix_layout, n, n, 0, kd, in, ldin, out, ldout );
46 } else if( LAPACKE_lsame( uplo, 'l' ) ) {
47 LAPACKE_sgb_trans( matrix_layout, n, n, kd, 0, in, ldin, out, ldout );
48 }
49}

◆ LAPACKE_ssp_nancheck()

lapack_logical LAPACKE_ssp_nancheck ( lapack_int n,
const float * ap )

Definition at line 39 of file lapacke_ssp_nancheck.c.

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

◆ LAPACKE_ssp_trans()

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

Definition at line 39 of file lapacke_ssp_trans.c.

42{
43 LAPACKE_stp_trans( matrix_layout, uplo, 'n', n, in, out );
44}

◆ LAPACKE_sst_nancheck()

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

Definition at line 36 of file lapacke_sst_nancheck.c.

39{
40 return LAPACKE_s_nancheck( n, d, 1 )
41 || LAPACKE_s_nancheck( n-1, e, 1 );
42}

◆ LAPACKE_ssy_nancheck()

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

Definition at line 36 of file lapacke_ssy_nancheck.c.

40{
41 return LAPACKE_str_nancheck( matrix_layout, uplo, 'n', n, a, lda );
42}

◆ LAPACKE_ssy_trans()

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

Definition at line 39 of file lapacke_ssy_trans.c.

42{
43 LAPACKE_str_trans( matrix_layout, uplo, 'n', n, in, ldin, out, ldout );
44}

◆ LAPACKE_stb_nancheck()

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

Definition at line 36 of file lapacke_stb_nancheck.c.

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

◆ LAPACKE_stb_trans()

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

Definition at line 39 of file lapacke_stb_trans.c.

43{
44 lapack_logical colmaj, upper, unit;
45
46 if( in == NULL || out == NULL ) return;
47
48 colmaj = ( matrix_layout == LAPACK_COL_MAJOR );
49 upper = LAPACKE_lsame( uplo, 'u' );
50 unit = LAPACKE_lsame( diag, 'u' );
51
52 if( ( !colmaj && ( matrix_layout != LAPACK_ROW_MAJOR ) ) ||
53 ( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
54 ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
55 /* Just exit if any of input parameters are wrong */
56 return;
57 }
58
59 if( unit ) {
60 /* Unit case, diagonal excluded from transposition */
61 if( colmaj ) {
62 if( upper ) {
63 LAPACKE_sgb_trans( matrix_layout, n-1, n-1, 0, kd-1,
64 &in[ldin], ldin, &out[1], ldout );
65 } else {
66 LAPACKE_sgb_trans( matrix_layout, n-1, n-1, kd-1, 0,
67 &in[1], ldin, &out[ldout], ldout );
68 }
69 } else {
70 if( upper ) {
71 LAPACKE_sgb_trans( matrix_layout, n-1, n-1, 0, kd-1,
72 &in[1], ldin, &out[ldout], ldout );
73 } else {
74 LAPACKE_sgb_trans( matrix_layout, n-1, n-1, kd-1, 0,
75 &in[ldin], ldin, &out[1], ldout );
76 }
77 }
78 } else {
79 /* Non-unit case */
80 if( upper ) {
81 LAPACKE_sgb_trans( matrix_layout, n, n, 0, kd, in, ldin, out,
82 ldout );
83 } else {
84 LAPACKE_sgb_trans( matrix_layout, n, n, kd, 0, in, ldin, out,
85 ldout );
86 }
87 }
88}

◆ LAPACKE_stf_nancheck()

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

Definition at line 36 of file lapacke_stf_nancheck.c.

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

◆ LAPACKE_stf_trans()

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

Definition at line 40 of file lapacke_stf_trans.c.

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

◆ LAPACKE_stp_nancheck()

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

Definition at line 39 of file lapacke_stp_nancheck.c.

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

◆ LAPACKE_stp_trans()

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

Definition at line 39 of file lapacke_stp_trans.c.

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

◆ LAPACKE_str_nancheck()

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

Definition at line 36 of file lapacke_str_nancheck.c.

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

◆ LAPACKE_str_trans()

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

Definition at line 39 of file lapacke_str_trans.c.

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

◆ LAPACKE_xerbla()

void LAPACKE_xerbla ( const char * name,
lapack_int info )

Definition at line 36 of file lapacke_xerbla.c.

37{
38 if( info == LAPACK_WORK_MEMORY_ERROR ) {
39 printf( "Not enough memory to allocate work array in %s\n", name );
40 } else if( info == LAPACK_TRANSPOSE_MEMORY_ERROR ) {
41 printf( "Not enough memory to transpose matrix in %s\n", name );
42 } else if( info < 0 ) {
43 printf( "Wrong parameter %d in %s\n", -(int) info, name );
44 }
45}
LAPACK_WORK_MEMORY_ERROR
#define LAPACK_WORK_MEMORY_ERROR
Definition lapacke.h:55
LAPACK_TRANSPOSE_MEMORY_ERROR
#define LAPACK_TRANSPOSE_MEMORY_ERROR
Definition lapacke.h:56

◆ LAPACKE_z_nancheck()

lapack_logical LAPACKE_z_nancheck ( lapack_int n,
const lapack_complex_double * x,
lapack_int incx )

Definition at line 36 of file lapacke_z_nancheck.c.

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

◆ LAPACKE_zgb_nancheck()

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

Definition at line 36 of file lapacke_zgb_nancheck.c.

41{
42 lapack_int i, j;
43
44 if( ab == NULL ) return (lapack_logical) 0;
45
46 if( matrix_layout == LAPACK_COL_MAJOR ) {
47 for( j = 0; j < n; j++ ) {
48 for( i = MAX( ku-j, 0 ); i < MIN( m+ku-j, kl+ku+1 );
49 i++ ) {
50 if( LAPACK_ZISNAN( ab[i+(size_t)j*ldab] ) )
51 return (lapack_logical) 1;
52 }
53 }
54 } else if ( matrix_layout == LAPACK_ROW_MAJOR ) {
55 for( j = 0; j < n; j++ ) {
56 for( i = MAX( ku-j, 0 ); i < MIN( m+ku-j, kl+ku+1 ); i++ ) {
57 if( LAPACK_ZISNAN( ab[(size_t)i*ldab+j] ) )
58 return (lapack_logical) 1;
59 }
60 }
61 }
62 return (lapack_logical) 0;
63}

◆ LAPACKE_zgb_trans()

void LAPACKE_zgb_trans ( int matrix_layout,
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 39 of file lapacke_zgb_trans.c.

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

◆ LAPACKE_zge_nancheck()

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

Definition at line 36 of file lapacke_zge_nancheck.c.

40{
41 lapack_int i, j;
42
43 if( a == NULL ) return (lapack_logical) 0;
44
45 if( matrix_layout == LAPACK_COL_MAJOR ) {
46 for( j = 0; j < n; j++ ) {
47 for( i = 0; i < MIN( m, lda ); i++ ) {
48 if( LAPACK_ZISNAN( a[i+(size_t)j*lda] ) )
49 return (lapack_logical) 1;
50 }
51 }
52 } else if ( matrix_layout == LAPACK_ROW_MAJOR ) {
53 for( i = 0; i < m; i++ ) {
54 for( j = 0; j < MIN( n, lda ); j++ ) {
55 if( LAPACK_ZISNAN( a[(size_t)i*lda+j] ) )
56 return (lapack_logical) 1;
57 }
58 }
59 }
60 return (lapack_logical) 0;
61}

◆ LAPACKE_zge_trans()

void LAPACKE_zge_trans ( int matrix_layout,
lapack_int m,
lapack_int n,
const lapack_complex_double * in,
lapack_int ldin,
lapack_complex_double * out,
lapack_int ldout )

Definition at line 39 of file lapacke_zge_trans.c.

42{
43 lapack_int i, j, x, y;
44
45 if( in == NULL || out == NULL ) return;
46
47 if( matrix_layout == LAPACK_COL_MAJOR ) {
48 x = n;
49 y = m;
50 } else if ( matrix_layout == LAPACK_ROW_MAJOR ) {
51 x = m;
52 y = n;
53 } else {
54 /* Unknown input layout */
55 return;
56 }
57
58 /* In case of incorrect m, n, ldin or ldout the function does nothing */
59 for( i = 0; i < MIN( y, ldin ); i++ ) {
60 for( j = 0; j < MIN( x, ldout ); j++ ) {
61 out[ (size_t)i*ldout + j ] = in[ (size_t)j*ldin + i ];
62 }
63 }
64}

◆ LAPACKE_zgg_nancheck()

lapack_logical LAPACKE_zgg_nancheck ( int matrix_layout,
lapack_int m,
lapack_int n,
const lapack_complex_double * a,
lapack_int lda )

Definition at line 36 of file lapacke_zgg_nancheck.c.

40{
41 return LAPACKE_zge_nancheck( matrix_layout, m, n, a, lda );
42}
LAPACKE_zge_nancheck
lapack_logical LAPACKE_zge_nancheck(int matrix_layout, lapack_int m, lapack_int n, const lapack_complex_double *a, lapack_int lda)
Definition lapacke_zge_nancheck.c:36

◆ LAPACKE_zgg_trans()

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

Definition at line 39 of file lapacke_zgg_trans.c.

42{
43 LAPACKE_zge_trans( matrix_layout, m, n, in, ldin, out, ldout );
44}
LAPACKE_zge_trans
void LAPACKE_zge_trans(int matrix_layout, lapack_int m, lapack_int n, const lapack_complex_double *in, lapack_int ldin, lapack_complex_double *out, lapack_int ldout)
Definition lapacke_zge_trans.c:39

◆ LAPACKE_zgt_nancheck()

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 36 of file lapacke_zgt_nancheck.c.

40{
41 return LAPACKE_z_nancheck( n-1, dl, 1 )
42 || LAPACKE_z_nancheck( n , d, 1 )
43 || LAPACKE_z_nancheck( n-1, du, 1 );
44}
LAPACKE_z_nancheck
lapack_logical LAPACKE_z_nancheck(lapack_int n, const lapack_complex_double *x, lapack_int incx)
Definition lapacke_z_nancheck.c:36

◆ LAPACKE_zhb_nancheck()

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

Definition at line 36 of file lapacke_zhb_nancheck.c.

40{
41 if( LAPACKE_lsame( uplo, 'u' ) ) {
42 return LAPACKE_zgb_nancheck( matrix_layout, n, n, 0, kd, ab, ldab );
43 } else if( LAPACKE_lsame( uplo, 'l' ) ) {
44 return LAPACKE_zgb_nancheck( matrix_layout, n, n, kd, 0, ab, ldab );
45 }
46 return (lapack_logical) 0;
47}
LAPACKE_zgb_nancheck
lapack_logical LAPACKE_zgb_nancheck(int matrix_layout, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const lapack_complex_double *ab, lapack_int ldab)
Definition lapacke_zgb_nancheck.c:36

◆ LAPACKE_zhb_trans()

void LAPACKE_zhb_trans ( int matrix_layout,
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 39 of file lapacke_zhb_trans.c.

43{
44 if( LAPACKE_lsame( uplo, 'u' ) ) {
45 LAPACKE_zgb_trans( matrix_layout, n, n, 0, kd, in, ldin, out, ldout );
46 } else if( LAPACKE_lsame( uplo, 'l' ) ) {
47 LAPACKE_zgb_trans( matrix_layout, n, n, kd, 0, in, ldin, out, ldout );
48 }
49}
LAPACKE_zgb_trans
void LAPACKE_zgb_trans(int matrix_layout, 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 lapacke_zgb_trans.c:39

◆ LAPACKE_zhe_nancheck()

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

Definition at line 36 of file lapacke_zhe_nancheck.c.

40{
41 return LAPACKE_ztr_nancheck( matrix_layout, uplo, 'n', n, a, lda );
42}
LAPACKE_ztr_nancheck
lapack_logical LAPACKE_ztr_nancheck(int matrix_layout, char uplo, char diag, lapack_int n, const lapack_complex_double *a, lapack_int lda)
Definition lapacke_ztr_nancheck.c:36

◆ LAPACKE_zhe_trans()

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

Definition at line 39 of file lapacke_zhe_trans.c.

42{
43 LAPACKE_ztr_trans( matrix_layout, uplo, 'n', n, in, ldin, out, ldout );
44}
LAPACKE_ztr_trans
void LAPACKE_ztr_trans(int matrix_layout, char uplo, char diag, lapack_int n, const lapack_complex_double *in, lapack_int ldin, lapack_complex_double *out, lapack_int ldout)
Definition lapacke_ztr_trans.c:39

◆ LAPACKE_zhp_nancheck()

lapack_logical LAPACKE_zhp_nancheck ( lapack_int n,
const lapack_complex_double * ap )

Definition at line 39 of file lapacke_zhp_nancheck.c.

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

◆ LAPACKE_zhp_trans()

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

Definition at line 39 of file lapacke_zhp_trans.c.

42{
43 LAPACKE_ztp_trans( matrix_layout, uplo, 'n', n, in, out );
44}
LAPACKE_ztp_trans
void LAPACKE_ztp_trans(int matrix_layout, char uplo, char diag, lapack_int n, const lapack_complex_double *in, lapack_complex_double *out)
Definition lapacke_ztp_trans.c:39

◆ LAPACKE_zhs_nancheck()

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

Definition at line 36 of file lapacke_zhs_nancheck.c.

39{
40 lapack_logical subdiag_nans;
41
42 if( a == NULL ) return (lapack_logical) 0;
43
44 /* Check subdiagonal first */
45 if( matrix_layout == LAPACK_COL_MAJOR ) {
46 subdiag_nans = LAPACKE_z_nancheck( n-1, &a[1], lda+1 );
47 } else if ( matrix_layout == LAPACK_ROW_MAJOR ) {
48 subdiag_nans = LAPACKE_z_nancheck( n-1, &a[lda], lda+1 );
49 } else {
50 return (lapack_logical) 0;
51 }
52
53 /* Check upper triangular if subdiagonal has no NaNs. */
54 return subdiag_nans || LAPACKE_ztr_nancheck( matrix_layout, 'u', 'n',
55 n, a, lda);
56}

◆ LAPACKE_zhs_trans()

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

Definition at line 39 of file lapacke_zhs_trans.c.

42{
43 if( in == NULL || out == NULL ) return;
44
45 /* Convert subdiagonal first */
46 if( matrix_layout == LAPACK_COL_MAJOR ) {
47 LAPACKE_zge_trans( LAPACK_COL_MAJOR, 1, n-1, &in[1], ldin+1,
48 &out[ldout], ldout+1 );
49 } else if ( matrix_layout == LAPACK_ROW_MAJOR ) {
50 LAPACKE_zge_trans( LAPACK_ROW_MAJOR, n-1, 1, &in[ldin], ldin+1,
51 &out[1], ldout+1 );
52 } else {
53 return;
54 }
55
56 /* Convert upper triangular. */
57 LAPACKE_ztr_trans( matrix_layout, 'u', 'n', n, in, ldin, out, ldout);
58}

◆ LAPACKE_zpb_nancheck()

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

Definition at line 36 of file lapacke_zpb_nancheck.c.

40{
41 if( LAPACKE_lsame( uplo, 'u' ) ) {
42 return LAPACKE_zgb_nancheck( matrix_layout, n, n, 0, kd, ab, ldab );
43 } else if( LAPACKE_lsame( uplo, 'l' ) ) {
44 return LAPACKE_zgb_nancheck( matrix_layout, n, n, kd, 0, ab, ldab );
45 }
46 return (lapack_logical) 0;
47}

◆ LAPACKE_zpb_trans()

void LAPACKE_zpb_trans ( int matrix_layout,
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 39 of file lapacke_zpb_trans.c.

43{
44 if( LAPACKE_lsame( uplo, 'u' ) ) {
45 LAPACKE_zgb_trans( matrix_layout, n, n, 0, kd, in, ldin, out, ldout );
46 } else if( LAPACKE_lsame( uplo, 'l' ) ) {
47 LAPACKE_zgb_trans( matrix_layout, n, n, kd, 0, in, ldin, out, ldout );
48 }
49}

◆ LAPACKE_zpf_nancheck()

lapack_logical LAPACKE_zpf_nancheck ( lapack_int n,
const lapack_complex_double * a )

Definition at line 40 of file lapacke_zpf_nancheck.c.

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

◆ LAPACKE_zpf_trans()

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

Definition at line 39 of file lapacke_zpf_trans.c.

42{
43 LAPACKE_ztf_trans( matrix_layout, transr, uplo, 'n', n, in, out );
44}
LAPACKE_ztf_trans
void LAPACKE_ztf_trans(int matrix_layout, char transr, char uplo, char diag, lapack_int n, const lapack_complex_double *in, lapack_complex_double *out)
Definition lapacke_ztf_trans.c:40

◆ LAPACKE_zpo_nancheck()

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

Definition at line 36 of file lapacke_zpo_nancheck.c.

40{
41 return LAPACKE_ztr_nancheck( matrix_layout, uplo, 'n', n, a, lda );
42}

◆ LAPACKE_zpo_trans()

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

Definition at line 39 of file lapacke_zpo_trans.c.

42{
43 LAPACKE_ztr_trans( matrix_layout, uplo, 'n', n, in, ldin, out, ldout );
44}

◆ LAPACKE_zpp_nancheck()

lapack_logical LAPACKE_zpp_nancheck ( lapack_int n,
const lapack_complex_double * ap )

Definition at line 39 of file lapacke_zpp_nancheck.c.

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

◆ LAPACKE_zpp_trans()

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

Definition at line 39 of file lapacke_zpp_trans.c.

42{
43 LAPACKE_ztp_trans( matrix_layout, uplo, 'n', n, in, out );
44}

◆ LAPACKE_zpt_nancheck()

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

Definition at line 36 of file lapacke_zpt_nancheck.c.

39{
40 return LAPACKE_d_nancheck( n, d, 1 )
41 || LAPACKE_z_nancheck( n-1, e, 1 );
42}

◆ LAPACKE_zsp_nancheck()

lapack_logical LAPACKE_zsp_nancheck ( lapack_int n,
const lapack_complex_double * ap )

Definition at line 39 of file lapacke_zsp_nancheck.c.

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

◆ LAPACKE_zsp_trans()

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

Definition at line 39 of file lapacke_zsp_trans.c.

42{
43 LAPACKE_ztp_trans( matrix_layout, uplo, 'n', n, in, out );
44}

◆ LAPACKE_zst_nancheck()

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

Definition at line 36 of file lapacke_zst_nancheck.c.

39{
40 return LAPACKE_z_nancheck( n, d, 1 )
41 || LAPACKE_z_nancheck( n-1, e, 1 );
42}

◆ LAPACKE_zsy_nancheck()

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

Definition at line 36 of file lapacke_zsy_nancheck.c.

40{
41 return LAPACKE_ztr_nancheck( matrix_layout, uplo, 'n', n, a, lda );
42}

◆ LAPACKE_zsy_trans()

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

Definition at line 39 of file lapacke_zsy_trans.c.

42{
43 LAPACKE_ztr_trans( matrix_layout, uplo, 'n', n, in, ldin, out, ldout );
44}

◆ LAPACKE_ztb_nancheck()

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

Definition at line 36 of file lapacke_ztb_nancheck.c.

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

◆ LAPACKE_ztb_trans()

void LAPACKE_ztb_trans ( int matrix_layout,
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 39 of file lapacke_ztb_trans.c.

43{
44 lapack_logical colmaj, upper, unit;
45
46 if( in == NULL || out == NULL ) return;
47
48 colmaj = ( matrix_layout == LAPACK_COL_MAJOR );
49 upper = LAPACKE_lsame( uplo, 'u' );
50 unit = LAPACKE_lsame( diag, 'u' );
51
52 if( ( !colmaj && ( matrix_layout != LAPACK_ROW_MAJOR ) ) ||
53 ( !upper && !LAPACKE_lsame( uplo, 'l' ) ) ||
54 ( !unit && !LAPACKE_lsame( diag, 'n' ) ) ) {
55 /* Just exit if any of input parameters are wrong */
56 return;
57 }
58
59 if( unit ) {
60 /* Unit case, diagonal excluded from transposition */
61 if( colmaj ) {
62 if( upper ) {
63 LAPACKE_zgb_trans( matrix_layout, n-1, n-1, 0, kd-1,
64 &in[ldin], ldin, &out[1], ldout );
65 } else {
66 LAPACKE_zgb_trans( matrix_layout, n-1, n-1, kd-1, 0,
67 &in[1], ldin, &out[ldout], ldout );
68 }
69 } else {
70 if( upper ) {
71 LAPACKE_zgb_trans( matrix_layout, n-1, n-1, 0, kd-1,
72 &in[1], ldin, &out[ldout], ldout );
73 } else {
74 LAPACKE_zgb_trans( matrix_layout, n-1, n-1, kd-1, 0,
75 &in[ldin], ldin, &out[1], ldout );
76 }
77 }
78 } else {
79 /* Non-unit case */
80 if( upper ) {
81 LAPACKE_zgb_trans( matrix_layout, n, n, 0, kd, in, ldin, out,
82 ldout );
83 } else {
84 LAPACKE_zgb_trans( matrix_layout, n, n, kd, 0, in, ldin, out,
85 ldout );
86 }
87 }
88}

◆ LAPACKE_ztf_nancheck()

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

Definition at line 36 of file lapacke_ztf_nancheck.c.

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

◆ LAPACKE_ztf_trans()

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

Definition at line 40 of file lapacke_ztf_trans.c.

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

◆ LAPACKE_ztp_nancheck()

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

Definition at line 39 of file lapacke_ztp_nancheck.c.

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

◆ LAPACKE_ztp_trans()

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

Definition at line 39 of file lapacke_ztp_trans.c.

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

◆ LAPACKE_ztr_nancheck()

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

Definition at line 36 of file lapacke_ztr_nancheck.c.

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

◆ LAPACKE_ztr_trans()

void LAPACKE_ztr_trans ( int matrix_layout,
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 39 of file lapacke_ztr_trans.c.

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