PageRenderTime 763ms queryTime 25ms sortTime 0ms getByIdsTime 670ms findMatchingLines 22ms

49+ results for 'DGGEVX repo:seanfarley/nudg' (763 ms)

Not the results you expected?
lapacke_dggevx_work.c git://pkgs.fedoraproject.org/lapack | C | 165 lines
                    
28*****************************************************************************
                    
29* Contents: Native middle-level C interface to LAPACK function dggevx
                    
30* Author: Intel Corporation
                    
36
                    
37lapack_int LAPACKE_dggevx_work( int matrix_order, char balanc, char jobvl,
                    
38                                char jobvr, char sense, lapack_int n, double* a,
                    
50        /* Call LAPACK function and adjust info */
                    
51        LAPACK_dggevx( &balanc, &jobvl, &jobvr, &sense, &n, a, &lda, b, &ldb,
                    
52                       alphar, alphai, beta, vl, &ldvl, vr, &ldvr, ilo, ihi,
                    
69            info = -8;
                    
70            LAPACKE_xerbla( "LAPACKE_dggevx_work", info );
                    
71            return info;
                    
74            info = -10;
                    
75            LAPACKE_xerbla( "LAPACKE_dggevx_work", info );
                    
76            return info;
                    
                
exports.def https://dnAnalytics.svn.codeplex.com/svn | Windows Module Definition | 1 lines
                    
1EXPORTS
 cblas_sdsdot
 cblas_dsdot
 cblas_sdot
 cblas_ddot
 cblas_cdotu_sub
 cblas_cdotc_sub
 cblas_zdotu_sub
 cblas_zdotc_sub
 cblas_snrm2
 cblas_sasum
 cblas_dnrm2
 cblas_dasum
 cblas_scnrm2
 cblas_scasum
 cblas_dznrm2
 cblas_dzasum
 cblas_isamax
 cblas_idamax
 cblas_icamax
 cblas_izamax
 cblas_sswap
 cblas_scopy
 cblas_saxpy
 cblas_dswap
 cblas_dcopy
 cblas_daxpy
 cblas_cswap
 cblas_ccopy
 cblas_caxpy
 cblas_zswap
 cblas_zcopy
 cblas_zaxpy
 cblas_srotg
 cblas_srotmg
 cblas_srot
 cblas_srotm
 cblas_drotg
 cblas_drotmg
 cblas_drot
 cblas_drotm
 cblas_sscal
 cblas_dscal
 cblas_cscal
 cblas_zscal
 cblas_csscal
 cblas_zdscal
 cblas_crotg
 cblas_zrotg
 cblas_csrot
 cblas_zdrot
 cblas_sgemv
 cblas_sgbmv
 cblas_strmv
 cblas_stbmv
 cblas_stpmv
 cblas_strsv
 cblas_stbsv
 cblas_stpsv
 cblas_dgemv
 cblas_dgbmv
 cblas_dtrmv
 cblas_dtbmv
 cblas_dtpmv
 cblas_dtrsv
 cblas_dtbsv
 cblas_dtpsv
 cblas_cgemv
 cblas_cgbmv
 cblas_ctrmv
 cblas_ctbmv
 cblas_ctpmv
 cblas_ctrsv
 cblas_ctbsv
 cblas_ctpsv
 cblas_zgemv
 cblas_zgbmv
 cblas_ztrmv
 cblas_ztbmv
 cblas_ztpmv
 cblas_ztrsv
 cblas_ztbsv
 cblas_ztpsv
 cblas_ssymv
 cblas_ssbmv
 cblas_sspmv
 cblas_sger
 cblas_ssyr
 cblas_sspr
 cblas_ssyr2
 cblas_sspr2
 cblas_dsymv
 cblas_dsbmv
 cblas_dspmv
 cblas_dger
 cblas_dsyr
 cblas_dspr
 cblas_dsyr2
 cblas_dspr2
 cblas_chemv
 cblas_chbmv
 cblas_chpmv
 cblas_cgeru
 cblas_cgerc
 cblas_cher
 cblas_chpr
 cblas_cher2
 cblas_chpr2
 cblas_zhemv
 cblas_zhbmv
 cblas_zhpmv
 cblas_zgeru
 cblas_zgerc
 cblas_zher
 cblas_zhpr
 cblas_zher2
 cblas_zhpr2
 cblas_sgemm
 cblas_ssymm
 cblas_ssyrk
 cblas_ssyr2k
 cblas_strmm
 cblas_strsm
 cblas_dgemm
 cblas_dsymm
 cblas_dsyrk
 cblas_dsyr2k
 cblas_dtrmm
 cblas_dtrsm
 cblas_cgemm
 cblas_csymm
 cblas_csyrk
 cblas_csyr2k
 cblas_ctrmm
 cblas_ctrsm
 cblas_zgemm
 cblas_zsymm
 cblas_zsyrk
 cblas_zsyr2k
 cblas_ztrmm
 cblas_ztrsm
 cblas_chemm
 cblas_cherk
 cblas_cher2k
 cblas_zhemm
 cblas_zherk
 cblas_zher2k
 clapack_sgesv
 clapack_sgetrs
 clapack_sposv
 clapack_spotrf
 clapack_spotrs
 clapack_spotri
 clapack_slauum
 clapack_strtri
 clapack_dgesv
 clapack_dgetrs
 clapack_dposv
 clapack_dpotrf
 clapack_dpotrs
 clapack_dpotri
 clapack_dlauum
 clapack_dtrtri
 clapack_cgesv
 clapack_cgetrs
 clapack_cposv
 clapack_cpotrf
 clapack_cpotrs
 clapack_cpotri
 clapack_clauum
 clapack_ctrtri
 clapack_zgesv
 clapack_zgetrs
 clapack_zposv
 clapack_zpotrf
 clapack_zpotrs
 clapack_zpotri
 clapack_zlauum
 clapack_ztrtri
 clapack_sgetri
 clapack_dgetri
 clapack_cgetri
 clapack_zgetri
 clapack_sgetrf
 clapack_dgetrf
 clapack_cgetrf
 clapack_zgetrf
 cbdsqr_
 cgbbrd_
 cgbcon_
 cgbequ_
 cgbrfs_
 cgbsv_
 cgbsvx_
 cgbtf2_
 cgbtrf_
 cgbtrs_
 cgebak_
 cgebal_
 cgebd2_
 cgebrd_
 cgecon_
 cgeequ_
 cgees_
 cgeesx_
 cgeev_
 cgeevx_
 cgegs_
 cgegv_
 cgehd2_
 cgehrd_
 cgelq2_
 cgelqf_
 cgels_
 cgelss_
 cgelsx_
 cgelsy_
 cgeql2_
 cgeqlf_
 cgeqp3_
 cgeqpf_
 cgeqr2_
 cgeqrf_
 cgerfs_
 cgerq2_
 cgerqf_
 cgesc2_
 cgesv_
 cgesvd_
 cgesvx_
 cgetc2_
 cgetf2_
 cgetrf_
 cgetri_
 cgetrs_
 cggbak_
 cggbal_
 cgges_
 cggesx_
 cggev_
 cggevx_
 cggglm_
 cgghrd_
 cgglse_
 cggqrf_
 cggrqf_
 cggsvd_
 cggsvp_
 cgtcon_
 cgtrfs_
 cgtsv_
 cgtsvx_
 cgttrf_
 cgttrs_
 cgtts2_
 chbev_
 chbevd_
 chbevx_
 chbgst_
 chbgv_
 chbgvx_
 chbtrd_
 checon_
 cheev_
 cheevd_
 cheevr_
 cheevx_
 chegs2_
 chegst_
 chegv_
 chegvd_
 chegvx_
 cherfs_
 chesv_
 chesvx_
 chetf2_
 chetrd_
 chetrf_
 chetri_
 chetrs_
 chgeqz_
 chpcon_
 chpev_
 chpevd_
 chpevx_
 chpgst_
 chpgv_
 chpgvd_
 chpgvx_
 chprfs_
 chpsv_
 chpsvx_
 chptrd_
 chptrf_
 chptri_
 chptrs_
 chsein_
 chseqr_
 clabrd_
 clacgv_
 clacon_
 clacp2_
 clacpy_
 clacrm_
 clacrt_
 claed0_
 claed7_
 claed8_
 claein_
 claesy_
 claev2_
 clags2_
 clagtm_
 clahef_
 clahqr_
 clahrd_
 claic1_
 clals0_
 clalsa_
 clapll_
 clapmt_
 claqgb_
 claqge_
 claqhb_
 claqhe_
 claqhp_
 claqp2_
 claqps_
 claqsb_
 claqsp_
 claqsy_
 clar1v_
 clar2v_
 clarcm_
 clarf_
 clarfb_
 clarfg_
 clarft_
 clarfx_
 clargv_
 clarnv_
 clarrv_
 clartg_
 clartv_
 clarz_
 clarzb_
 clarzt_
 clascl_
 claset_
 clasr_
 classq_
 claswp_
 clasyf_
 clatbs_
 clatdf_
 clatps_
 clatrd_
 clatrs_
 clatrz_
 clatzm_
 clauu2_
 clauum_
 cpbcon_
 cpbequ_
 cpbrfs_
 cpbstf_
 cpbsv_
 cpbsvx_
 cpbtf2_
 cpbtrf_
 cpbtrs_
 cpocon_
 cpoequ_
 cporfs_
 cposv_
 cposvx_
 cpotf2_
 cpotrf_
 cpotri_
 cpotrs_
 cppcon_
 cppequ_
 cpprfs_
 cppsv_
 cppsvx_
 cpptrf_
 cpptri_
 cpptrs_
 cptcon_
 cptrfs_
 cptsv_
 cptsvx_
 cpttrf_
 cpttrs_
 cptts2_
 crot_
 cspcon_
 cspmv_
 cspr_
 csprfs_
 cspsv_
 cspsvx_
 csptrf_
 csptri_
 csptrs_
 csrot_
 csrscl_
 cstedc_
 cstein_
 csteqr_
 csycon_
 csymv_
 csyr_
 csyrfs_
 csysv_
 csysvx_
 csytf2_
 csytrf_
 csytri_
 csytrs_
 ctbcon_
 ctbrfs_
 ctbtrs_
 ctgevc_
 ctgex2_
 ctgexc_
 ctgsen_
 ctgsja_
 ctgsna_
 ctgsy2_
 ctgsyl_
 ctpcon_
 ctprfs_
 ctptri_
 ctptrs_
 ctrcon_
 ctrevc_
 ctrexc_
 ctrrfs_
 ctrsen_
 ctrsna_
 ctrsyl_
 ctrti2_
 ctrtri_
 ctrtrs_
 ctzrqf_
 ctzrzf_
 cung2l_
 cung2r_
 cungbr_
 cunghr_
 cungl2_
 cunglq_
 cungql_
 cungqr_
 cungr2_
 cungrq_
 cungtr_
 cunm2l_
 cunm2r_
 cunmbr_
 cunmhr_
 cunml2_
 cunmlq_
 cunmql_
 cunmqr_
 cunmr2_
 cunmr3_
 cunmrq_
 cunmrz_
 cunmtr_
 cupgtr_
 cupmtr_
 dbdsdc_
 dbdsqr_
 ddisna_
 dgbbrd_
 dgbcon_
 dgbequ_
 dgbrfs_
 dgbsv_
 dgbsvx_
 dgbtf2_
 dgbtrf_
 dgbtrs_
 dgebak_
 dgebal_
 dgebd2_
 dgebrd_
 dgecon_
 dgeequ_
 dgees_
 dgeesx_
 dgeev_
 dgeevx_
 dgegs_
 dgegv_
 dgehd2_
 dgehrd_
 dgelq2_
 dgelqf_
 dgels_
 dgelsd_
 dgelss_
 dgelsx_
 dgelsy_
 dgeql2_
 dgeqlf_
 dgeqp3_
 dgeqpf_
 dgeqr2_
 dgeqrf_
 dgerfs_
 dgerq2_
 dgerqf_
 dgesc2_
 dgesdd_
 dgesv_
 dgesvd_
 dgesvx_
 dgetc2_
 dgetf2_
 dgetrf_
 dgetri_
 dgetrs_
 dggbak_
 dggbal_
 dgges_
 dggesx_
 dggev_
 dggevx_
 dggglm_
 dgghrd_
 dgglse_
 dggqrf_
 dggrqf_
 dggsvd_
 dggsvp_
 dgtcon_
 dgtrfs_
 dgtsv_
 dgtsvx_
 dgttrf_
 dgttrs_
 dgtts2_
 dhgeqz_
 dhsein_
 dhseqr_
 dlabad_
 dlabrd_
 dlacon_
 dlacpy_
 dladiv_
 dlae2_
 dlaebz_
 dlaed0_
 dlaed1_
 dlaed2_
 dlaed3_
 dlaed4_
 dlaed5_
 dlaed6_
 dlaed7_
 dlaed8_
 dlaed9_
 dlaeda_
 dlaein_
 dlaev2_
 dlaexc_
 dlag2_
 dlags2_
 dlagtf_
 dlagtm_
 dlagts_
 dlagv2_
 dlahqr_
 dlahrd_
 dlaic1_
 dlaln2_
 dlals0_
 dlalsa_
 dlalsd_
 dlamc1_
 dlamc2_
 dlamc4_
 dlamc5_
 dlamrg_
 dlanv2_
 dlapll_
 dlapmt_
 dlaqgb_
 dlaqge_
 dlaqp2_
 dlaqps_
 dlaqsb_
 dlaqsp_
 dlaqsy_
 dlaqtr_
 dlar1v_
 dlar2v_
 dlarf_
 dlarfb_
 dlarfg_
 dlarft_
 dlarfx_
 dlargv_
 dlarnv_
 dlarrb_
 dlarre_
 dlarrf_
 dlarrv_
 dlartg_
 dlartv_
 dlaruv_
 dlarz_
 dlarzb_
 dlarzt_
 dlas2_
 dlascl_
 dlasd0_
 dlasd1_
 dlasd2_
 dlasd3_
 dlasd4_
 dlasd5_
 dlasd6_
 dlasd7_
 dlasd8_
 dlasd9_
 dlasda_
 dlasdq_
 dlasdt_
 dlaset_
 dlasq1_
 dlasq2_
 dlasq3_
 dlasq4_
 dlasq5_
 dlasq6_
 dlasr_
 dlasrt_
 dlassq_
 dlasv2_
 dlaswp_
 dlasy2_
 dlasyf_
 dlatbs_
 dlatdf_
 dlatps_
 dlatrd_
 dlatrs_
 dlatrz_
 dlatzm_
 dlauu2_
 dlauum_
 dopgtr_
 dopmtr_
 dorg2l_
 dorg2r_
 dorgbr_
 dorghr_
 dorgl2_
 dorglq_
 dorgql_
 dorgqr_
 dorgr2_
 dorgrq_
 dorgtr_
 dorm2l_
 dorm2r_
 dormbr_
 dormhr_
 dorml2_
 dormlq_
 dormql_
 dormqr_
 dormr2_
 dormr3_
 dormrq_
 dormrz_
 dormtr_
 dpbcon_
 dpbequ_
 dpbrfs_
 dpbstf_
 dpbsv_
 dpbsvx_
 dpbtf2_
 dpbtrf_
 dpbtrs_
 dpocon_
 dpoequ_
 dporfs_
 dposv_
 dposvx_
 dpotf2_
 dpotrf_
 dpotri_
 dpotrs_
 dppcon_
 dppequ_
 dpprfs_
 dppsv_
 dppsvx_
 dpptrf_
 dpptri_
 dpptrs_
 dptcon_
 dpteqr_
 dptrfs_
 dptsv_
 dptsvx_
 dpttrf_
 dpttrs_
 dptts2_
 drscl_
 dsbev_
 dsbevd_
 dsbevx_
 dsbgst_
 dsbgv_
 dsbgvd_
 dsbgvx_
 dsbtrd_
 dspcon_
 dspev_
 dspevd_
 dspevx_
 dspgst_
 dspgv_
 dspgvd_
 dspgvx_
 dsprfs_
 dspsv_
 dspsvx_
 dsptrd_
 dsptrf_
 dsptri_
 dsptrs_
 dstebz_
 dstedc_
 dstegr_
 dstein_
 dsteqr_
 dsterf_
 dstev_
 dstevd_
 dstevr_
 dstevx_
 dsycon_
 dsyev_
 dsyevd_
 dsyevr_
 dsyevx_
 dsygs2_
 dsygst_
 dsygv_
 dsygvd_
 dsygvx_
 dsyrfs_
 dsysv_
 dsysvx_
 dsytd2_
 dsytf2_
 dsytrd_
 dsytrf_
 dsytri_
 dsytrs_
 dtbcon_
 dtbrfs_
 dtbtrs_
 dtgevc_
 dtgex2_
 dtgexc_
 dtgsen_
 dtgsja_
 dtgsna_
 dtgsy2_
 dtgsyl_
 dtpcon_
 dtprfs_
 dtptri_
 dtptrs_
 dtrcon_
 dtrevc_
 dtrexc_
 dtrrfs_
 dtrsen_
 dtrsna_
 dtrsyl_
 dtrti2_
 dtrtri_
 dtrtrs_
 dtzrqf_
 dtzrzf_
 sbdsdc_
 sbdsqr_
 sdisna_
 sgbbrd_
 sgbcon_
 sgbequ_
 sgbrfs_
 sgbsv_
 sgbsvx_
 sgbtf2_
 sgbtrf_
 sgbtrs_
 sgebak_
 sgebal_
 sgebd2_
 sgebrd_
 sgecon_
 sgeequ_
 sgees_
 sgeesx_
 sgeev_
 sgeevx_
 sgegs_
 sgegv_
 sgehd2_
 sgehrd_
 sgelq2_
 sgelqf_
 sgels_
 sgelsd_
 sgelss_
 sgelsx_
 sgelsy_
 sgeql2_
 sgeqlf_
 sgeqp3_
 sgeqpf_
 sgeqr2_
 sgeqrf_
 sgerfs_
 sgerq2_
 sgerqf_
 sgesc2_
 sgesdd_
 sgesv_
 sgesvd_
 sgesvx_
 sgetc2_
 sgetf2_
 sgetrf_
 sgetri_
 sgetrs_
 sggbak_
 sggbal_
 sgges_
 sggesx_
 sggev_
 sggevx_
 sggglm_
 sgghrd_
 sgglse_
 sggqrf_
 sggrqf_
 sggsvd_
 sggsvp_
 sgtcon_
 sgtrfs_
 sgtsv_
 sgtsvx_
 sgttrf_
 sgttrs_
 sgtts2_
 shgeqz_
 shsein_
 shseqr_
 slabad_
 slabrd_
 slacon_
 slacpy_
 sladiv_
 slae2_
 slaebz_
 slaed0_
 slaed1_
 slaed2_
 slaed3_
 slaed4_
 slaed5_
 slaed6_
 slaed7_
 slaed8_
 slaed9_
 slaeda_
 slaein_
 slaev2_
 slaexc_
 slag2_
 slags2_
 slagtf_
 slagtm_
 slagts_
 slagv2_
 slahqr_
 slahrd_
 slaic1_
 slaln2_
 slals0_
 slalsa_
 slalsd_
 slamc1_
 slamc2_
 slamc4_
 slamc5_
 slamrg_
 slanv2_
 slapll_
 slapmt_
 slaqgb_
 slaqge_
 slaqp2_
 slaqps_
 slaqsb_
 slaqsp_
 slaqsy_
 slaqtr_
 slar1v_
 slar2v_
 slarf_
 slarfb_
 slarfg_
 slarft_
 slarfx_
 slargv_
 slarnv_
 slarrb_
 slarre_
 slarrf_
 slarrv_
 slartg_
 slartv_
 slaruv_
 slarz_
 slarzb_
 slarzt_
 slas2_
 slascl_
 slasd0_
 slasd1_
 slasd2_
 slasd3_
 slasd4_
 slasd5_
 slasd6_
 slasd7_
 slasd8_
 slasd9_
 slasda_
 slasdq_
 slasdt_
 slaset_
 slasq1_
 slasq2_
 slasq3_
 slasq4_
 slasq5_
 slasq6_
 slasr_
 slasrt_
 slassq_
 slasv2_
 slaswp_
 slasy2_
 slasyf_
 slatbs_
 slatdf_
 slatps_
 slatrd_
 slatrs_
 slatrz_
 slatzm_
 slauu2_
 slauum_
 sopgtr_
 sopmtr_
 sorg2l_
 sorg2r_
 sorgbr_
 sorghr_
 sorgl2_
 sorglq_
 sorgql_
 sorgqr_
 sorgr2_
 sorgrq_
 sorgtr_
 sorm2l_
 sorm2r_
 sormbr_
 sormhr_
 sorml2_
 sormlq_
 sormql_
 sormqr_
 sormr2_
 sormr3_
 sormrq_
 sormrz_
 sormtr_
 spbcon_
 spbequ_
 spbrfs_
 spbstf_
 spbsv_
 spbsvx_
 spbtf2_
 spbtrf_
 spbtrs_
 spocon_
 spoequ_
 sporfs_
 sposv_
 sposvx_
 spotf2_
 spotrf_
 spotri_
 spotrs_
 sppcon_
 sppequ_
 spprfs_
 sppsv_
 sppsvx_
 spptrf_
 spptri_
 spptrs_
 sptcon_
 spteqr_
 sptrfs_
 sptsv_
 sptsvx_
 spttrf_
 spttrs_
 sptts2_
 srscl_
 ssbev_
 ssbevd_
 ssbevx_
 ssbgst_
 ssbgv_
 ssbgvd_
 ssbgvx_
 ssbtrd_
 sspcon_
 sspev_
 sspevd_
 sspevx_
 sspgst_
 sspgv_
 sspgvd_
 sspgvx_
 ssprfs_
 sspsv_
 sspsvx_
 ssptrd_
 ssptrf_
 ssptri_
 ssptrs_
 sstebz_
 sstedc_
 sstegr_
 sstein_
 ssteqr_
 ssterf_
 sstev_
 sstevd_
 sstevr_
 sstevx_
 ssycon_
 ssyev_
 ssyevd_
 ssyevr_
 ssyevx_
 ssygs2_
 ssygst_
 ssygv_
 ssygvd_
 ssygvx_
 ssyrfs_
 ssysv_
 ssysvx_
 ssytd2_
 ssytf2_
 ssytrd_
 ssytrf_
 ssytri_
 ssytrs_
 stbcon_
 stbrfs_
 stbtrs_
 stgevc_
 stgex2_
 stgexc_
 stgsen_
 stgsja_
 stgsna_
 stgsy2_
 stgsyl_
 stpcon_
 stprfs_
 stptri_
 stptrs_
 strcon_
 strevc_
 strexc_
 strrfs_
 strsen_
 strsna_
 strsyl_
 strti2_
 strtri_
 strtrs_
 stzrqf_
 stzrzf_
 xerbla_
 zbdsqr_
 zdrot_
 zdrscl_
 zgbbrd_
 zgbcon_
 zgbequ_
 zgbrfs_
 zgbsv_
 zgbsvx_
 zgbtf2_
 zgbtrf_
 zgbtrs_
 zgebak_
 zgebal_
 zgebd2_
 zgebrd_
 zgecon_
 zgeequ_
 zgees_
 zgeesx_
 zgeev_
 zgeevx_
 zgegs_
 zgegv_
 zgehd2_
 zgehrd_
 zgelq2_
 zgelqf_
 zgels_
 zgelss_
 zgelsx_
 zgelsy_
 zgeql2_
 zgeqlf_
 zgeqp3_
 zgeqpf_
 zgeqr2_
 zgeqrf_
 zgerfs_
 zgerq2_
 zgerqf_
 zgesc2_
 zgesv_
 zgesvd_
 zgesvx_
 zgetc2_
 zgetf2_
 zgetrf_
 zgetri_
 zgetrs_
 zggbak_
 zggbal_
 zgges_
 zggesx_
 zggev_
 zggevx_
 zggglm_
 zgghrd_
 zgglse_
 zggqrf_
 zggrqf_
 zggsvd_
 zggsvp_
 zgtcon_
 zgtrfs_
 zgtsv_
 zgtsvx_
 zgttrf_
 zgttrs_
 zgtts2_
 zhbev_
 zhbevd_
 zhbevx_
 zhbgst_
 zhbgv_
 zhbgvx_
 zhbtrd_
 zhecon_
 zheev_
 zheevd_
 zheevr_
 zheevx_
 zhegs2_
 zhegst_
 zhegv_
 zhegvd_
 zhegvx_
 zherfs_
 zhesv_
 zhesvx_
 zhetf2_
 zhetrd_
 zhetrf_
 zhetri_
 zhetrs_
 zhgeqz_
 zhpcon_
 zhpev_
 zhpevd_
 zhpevx_
 zhpgst_
 zhpgv_
 zhpgvd_
 zhpgvx_
 zhprfs_
 zhpsv_
 zhpsvx_
 zhptrd_
 zhptrf_
 zhptri_
 zhptrs_
 zhsein_
 zhseqr_
 zlabrd_
 zlacgv_
 zlacon_
 zlacp2_
 zlacpy_
 zlacrm_
 zlacrt_
 zlaed0_
 zlaed7_
 zlaed8_
 zlaein_
 zlaesy_
 zlaev2_
 zlags2_
 zlagtm_
 zlahef_
 zlahqr_
 zlahrd_
 zlaic1_
 zlals0_
 zlalsa_
 zlapll_
 zlapmt_
 zlaqgb_
 zlaqge_
 zlaqhb_
 zlaqhe_
 zlaqhp_
 zlaqp2_
 zlaqps_
 zlaqsb_
 zlaqsp_
 zlaqsy_
 zlar1v_
 zlar2v_
 zlarcm_
 zlarf_
 zlarfb_
 zlarfg_
 zlarft_
 zlarfx_
 zlargv_
 zlarnv_
 zlarrv_
 zlartg_
 zlartv_
 zlarz_
 zlarzb_
 zlarzt_
 zlascl_
 zlaset_
 zlasr_
 zlassq_
 zlaswp_
 zlasyf_
 zlatbs_
 zlatdf_
 zlatps_
 zlatrd_
 zlatrs_
 zlatrz_
 zlatzm_
 zlauu2_
 zlauum_
 zpbcon_
 zpbequ_
 zpbrfs_
 zpbstf_
 zpbsv_
 zpbsvx_
 zpbtf2_
 zpbtrf_
 zpbtrs_
 zpocon_
 zpoequ_
 zporfs_
 zposv_
 zposvx_
 zpotf2_
 zpotrf_
 zpotri_
 zpotrs_
 zppcon_
 zppequ_
 zpprfs_
 zppsv_
 zppsvx_
 zpptrf_
 zpptri_
 zpptrs_
 zptcon_
 zptrfs_
 zptsv_
 zptsvx_
 zpttrf_
 zpttrs_
 zptts2_
 zrot_
 zspcon_
 zspmv_
 zspr_
 zsprfs_
 zspsv_
 zspsvx_
 zsptrf_
 zsptri_
 zsptrs_
 zstedc_
 zstein_
 zsteqr_
 zsycon_
 zsymv_
 zsyr_
 zsyrfs_
 zsysv_
 zsysvx_
 zsytf2_
 zsytrf_
 zsytri_
 zsytrs_
 ztbcon_
 ztbrfs_
 ztbtrs_
 ztgevc_
 ztgex2_
 ztgexc_
 ztgsen_
 ztgsja_
 ztgsna_
 ztgsy2_
 ztgsyl_
 ztpcon_
 ztprfs_
 ztptri_
 ztptrs_
 ztrcon_
 ztrevc_
 ztrexc_
 ztrrfs_
 ztrsen_
 ztrsna_
 ztrsyl_
 ztrti2_
 ztrtri_
 ztrtrs_
 ztzrqf_
 ztzrzf_
 zung2l_
 zung2r_
 zungbr_
 zunghr_
 zungl2_
 zunglq_
 zungql_
 zungqr_
 zungr2_
 zungrq_
 zungtr_
 zunm2l_
 zunm2r_
 zunmbr_
 zunmhr_
 zunml2_
 zunmlq_
 zunmql_
 zunmqr_
 zunmr2_
 zunmr3_
 zunmrq_
 zunmrz_
 zunmtr_
 zupgtr_
 zupmtr_
 slange_
 dlange_
 clange_
 zlange_
 ilaenv_
                    
                
lapacksyms.def https://bitbucket.org/palday/fieldtrip.git | Module-Definition | 718 lines
                    
67dggev
                    
68dggevx
                    
69dggglm
                    
                
lapack_prototypes.h https://github.com/certik/openmx.git | C Header | 97 lines
                    
89void dpotri_(char *uplo, INTEGER *n, double *a, INTEGER *lda, INTEGER *info);
                    
90void dggevx_(char *balanc, char *jobvl, char *jobvr, char *sense,
                    
91             INTEGER *n, double *a, INTEGER *lda, double *b, 
                    
                
dggevx.f https://github.com/jbwhit/pymc.git | FORTRAN Legacy | 718 lines
                    
1      SUBROUTINE DGGEVX( BALANC, JOBVL, JOBVR, SENSE, N, A, LDA, B, LDB,
                    
2     $                   ALPHAR, ALPHAI, BETA, VL, LDVL, VR, LDVR, ILO,
                    
26*
                    
27*  DGGEVX computes for a pair of N-by-N real nonsymmetric matrices (A,B)
                    
28*  the generalized eigenvalues, and optionally, the left and/or right
                    
                
dggevx.c https://bitbucket.org/jeromerobert/starpu.git | C | 885 lines
                    
1/* dggevx.f -- translated by f2c (version 20061008).
                    
2   You must link the resulting object file with libf2c:
                    
22
                    
23/* Subroutine */ int dggevx_(char *balanc, char *jobvl, char *jobvr, char *
                    
24	sense, integer *n, doublereal *a, integer *lda, doublereal *b, 
                    
118
                    
119/*  DGGEVX computes for a pair of N-by-N real nonsymmetric matrices (A,B) */
                    
120/*  the generalized eigenvalues, and optionally, the left and/or right */
                    
                
dggevx.c https://github.com/zye/cmvs.git | C | 873 lines
                    
10
                    
11/* Subroutine */ int dggevx_(char *balanc, char *jobvl, char *jobvr, char *
                    
12	sense, integer *n, doublereal *a, integer *lda, doublereal *b, 
                    
106
                    
107/*  DGGEVX computes for a pair of N-by-N real nonsymmetric matrices (A,B) */
                    
108/*  the generalized eigenvalues, and optionally, the left and/or right */
                    
                
CMakeLists.txt https://bitbucket.org/iricpt/lapack.git | CMake | 2436 lines
                    
749lapacke_dggev3_work.c
                    
750lapacke_dggevx.c
                    
751lap
                    
                
Makefile https://github.com/vext01/ports-wip.git | Makefile | 261 lines
                    
153   dgetrf.f dgetri.f \
                    
154   dgetrs.f dggbak.f dggbal.f dgges.f  dggesx.f dggev.f  dggevx.f \
                    
155   dggglm.f dgghrd.f dgglse.f dggqrf.f \
                    
                
dggevx.c https://github.com/geoffdavis/antelope_contrib.git | C | 843 lines
                    
3
                    
4/* Subroutine */ int dggevx_(char *balanc, char *jobvl, char *jobvr, char *
                    
5	sense, integer *n, doublereal *a, integer *lda, doublereal *b, 
                    
21
                    
22    DGGEVX computes for a pair of N-by-N real nonsymmetric matrices (A,B)   
                    
23    the generalized eigenvalues, and optionally, the left and/or right   
                    
                
Makefile https://github.com/geoffdavis/antelope_contrib.git | Makefile | 374 lines
                    
155   dgetrf.o dgetri.o \
                    
156   dgetrs.o dggbak.o dggbal.o dgges.o  dggesx.o dggev.o  dggevx.o \
                    
157   dggglm.o dgghrd.o dgglse.o dggqrf.o \
                    
                
libLAPACK.dylib-Symbols.h https://gitlab.com/edelmaks/iOS-iphoneheaders | C Header | 1672 lines
                    
402_dggev_
                    
403_dggevx_
                    
404_dggglm_
                    
                
zero_cfrac.c https://github.com/certik/openmx.git | C | 320 lines
                    
33
                    
34static void Eigen_DGGEVX( int n, double **a, double **s, double *eval,
                    
35                          double *resr, double *resi );
                    
99
                    
100  Eigen_DGGEVX( N, a, s, eval, resr, resi );
                    
101
                    
144
                    
145void Eigen_DGGEVX( int n, double **a, double **s, double *eval, double *resr, double *resi )
                    
146{
                    
214
                    
215  /* call dggevx_() */
                    
216
                    
216
                    
217  F77_NAME(dggevx,DGGEVX)(
                    
218           &balanc, &jobvl, & jobvr, &sense, &n, A, &lda, b, &ldb,
                    
                
clapackwrap.h https://github.com/jkdirac/igame.git | C Header | 1270 lines
                    
364# define dggev_ DGGEV
                    
365# define dggevx_ DGGEVX
                    
366# define dggglm_ DGGGLM
                    
                
lapacke_dggevx.c git://pkgs.fedoraproject.org/lapack | C | 122 lines
                    
28*****************************************************************************
                    
29* Contents: Native high-level C interface to LAPACK function dggevx
                    
30* Author: Intel Corporation
                    
36
                    
37lapack_int LAPACKE_dggevx( int matrix_order, char balanc, char jobvl,
                    
38                           char jobvr, char sense, lapack_int n, double* a,
                    
52    if( matrix_order != LAPACK_COL_MAJOR && matrix_order != LAPACK_ROW_MAJOR ) {
                    
53        LAPACKE_xerbla( "LAPACKE_dggevx", -1 );
                    
54        return -1;
                    
83    /* Query optimal working array(s) size */
                    
84    info = LAPACKE_dggevx_work( matrix_order, balanc, jobvl, jobvr, sense, n, a,
                    
85                                lda, b, ldb, alphar, alphai, beta, vl, ldvl, vr,
                    
99    /* Call middle-level interface */
                    
100    info = LAPACKE_dggevx_work( matrix_order, balanc, jobvl, jobvr, sense, n, a,
                    
101                                lda, b, ldb, alphar, alphai, beta, vl, ldvl, vr,
                    
                
Makefile.am git://git.savannah.nongnu.org/freeon.git | Makefile | 1391 lines
                    
402  dggev.f   \
                    
403  dggevx.f  \
                    
404  dggglm.f  \
                    
                
lapack.f90 git://github.com/certik/fortran-utils.git | FORTRAN Modern | 407 lines
                    
140
                    
141    SUBROUTINE DGGEVX( BALANC, JOBVL, JOBVR, SENSE, N, A, LDA, B, LDB, &
                    
142                       ALPHAR, ALPHAI, BETA, VL, LDVL, VR, LDVR, ILO, IHI, &
                    
                
clapack_double.h git://pkgs.fedoraproject.org/gretl | C Header | 1450 lines
                    
256 
                    
257int dggevx_(char *balanc, char *jobvl, char *jobvr, char *
                    
258	    sense, integer *n, doublereal *a, integer *lda, doublereal *b, 
                    
                
cython_lapack.pyx git://github.com/scipy/scipy.git | Cython | 8037 lines
                    
382- dggev
                    
383- dggevx
                    
384- dggglm
                    
                
ddrgvx.f git://pkgs.fedoraproject.org/lapack | FORTRAN Legacy | 763 lines
                    
37*> DDRGVX checks the nonsymmetric generalized eigenvalue problem
                    
38*> expert driver DGGEVX.
                    
39*>
                    
39*>
                    
40*> DGGEVX computes the generalized eigenvalues, (optionally) the left
                    
41*> and/or right eigenvectors, (optionally) computes a balancing
                    
45*> When DDRGVX is called with NSIZE > 0, two types of test matrix pairs
                    
46*> are generated by the subroutine DLATM6 and test the driver DGGEVX.
                    
47*> The test matrices have the known exact condition numbers for
                    
64*>
                    
65*> (3) The condition number S(i) of eigenvalues computed by DGGEVX
                    
66*>     differs less than a factor THRESH from the exact S(i) (see
                    
166*>          AI is DOUBLE PRECISION array, dimension (LDA, NSIZE)
                    
167*>          Copy of A, modified by DGGEVX.
                    
168*> \endverbatim
                    
                
dchkee.f git://pkgs.fedoraproject.org/lapack | FORTRAN Legacy | 2456 lines
                    
59*> DXV (Generalized Nonsymmetric Eigenvalue/eigenvector Expert Driver):
                    
60*>     Test DGGEVX
                    
61*>
                    
                
derrgg.f git://pkgs.fedoraproject.org/lapack | FORTRAN Legacy | 1060 lines
                    
23*>
                    
24*> DERRGG tests the error exits for DGGES, DGGESX, DGGEV, DGGEVX,
                    
25*> DGGGLM, DGGHRD, DGGLSE, DGGQRF, DGGRQF, DGGSVD, DGGSVP, DHGEQZ,
                    
96*     .. External Subroutines ..
                    
97      EXTERNAL           CHKXER, DGGES, DGGESX, DGGEV, DGGEVX, DGGGLM,
                    
98     $                   DGGHRD, DGGLSE, DGGQRF, DGGRQF, DGGSVD, DGGSVP,
                    
                
Makefile git://pkgs.fedoraproject.org/lapack | Makefile | 337 lines
                    
70   dgetrf.o dgetri.o									\
                    
71   dgetrs.o dggbak.o dggbal.o dgges.o  dggesx.o dggev.o  dggevx.o			\
                    
72   dggglm.o dgghrd.o dgglse.o dggqrf.o							\
                    
                
dchkee.f git://github.com/numpy/vendor.git | FORTRAN Legacy | 2357 lines
                    
50*  DXV (Generalized Nonsymmetric Eigenvalue/eigenvector Expert Driver):
                    
51*      Test DGGEVX
                    
52*
                    
                
ddrgvx.f git://github.com/numpy/vendor.git | FORTRAN Legacy | 624 lines
                    
28*  DDRGVX checks the nonsymmetric generalized eigenvalue problem
                    
29*  expert driver DGGEVX.
                    
30*
                    
30*
                    
31*  DGGEVX computes the generalized eigenvalues, (optionally) the left
                    
32*  and/or right eigenvectors, (optionally) computes a balancing
                    
36*  When DDRGVX is called with NSIZE > 0, two types of test matrix pairs
                    
37*  are generated by the subroutine DLATM6 and test the driver DGGEVX.
                    
38*  The test matrices have the known exact condition numbers for
                    
55*
                    
56*  (3) The condition number S(i) of eigenvalues computed by DGGEVX
                    
57*      differs less than a factor THRESH from the exact S(i) (see
                    
133*  AI      (workspace) DOUBLE PRECISION array, dimension (LDA, NSIZE)
                    
134*          Copy of A, modified by DGGEVX.
                    
135*
                    
                
derrgg.f git://github.com/numpy/vendor.git | FORTRAN Legacy | 953 lines
                    
14*
                    
15*  DERRGG tests the error exits for DGGES, DGGESX, DGGEV, DGGEVX,
                    
16*  DGGGLM, DGGHRD, DGGLSE, DGGQRF, DGGRQF, DGGSVD, DGGSVP, DHGEQZ,
                    
55*     .. External Subroutines ..
                    
56      EXTERNAL           CHKXER, DGGES, DGGESX, DGGEV, DGGEVX, DGGGLM,
                    
57     $                   DGGHRD, DGGLSE, DGGQRF, DGGRQF, DGGSVD, DGGSVP,
                    
                
lapack.def https://octave.svn.sourceforge.net/svnroot/octave | Teamcenter def | 1369 lines
                    
381dggev_
                    
382dggevx_
                    
383dggglm_
                    
                
lapacke_dggevx.c https://bitbucket.org/iricpt/lapack.git | C | 121 lines
                    
28*****************************************************************************
                    
29* Contents: Native high-level C interface to LAPACK function dggevx
                    
30* Author: Intel Corporation
                    
34
                    
35lapack_int LAPACKE_dggevx( int matrix_layout, char balanc, char jobvl,
                    
36                           char jobvr, char sense, lapack_int n, double* a,
                    
50    if( matrix_layout != LAPACK_COL_MAJOR && matrix_layout != LAPACK_ROW_MAJOR ) {
                    
51        LAPACKE_xerbla( "LAPACKE_dggevx", -1 );
                    
52        return -1;
                    
83    /* Query optimal working array(s) size */
                    
84    info = LAPACKE_dggevx_work( matrix_layout, balanc, jobvl, jobvr, sense, n, a,
                    
85                                lda, b, ldb, alphar, alphai, beta, vl, ldvl, vr,
                    
99    /* Call middle-level interface */
                    
100    info = LAPACKE_dggevx_work( matrix_layout, balanc, jobvl, jobvr, sense, n, a,
                    
101                                lda, b, ldb, alphar, alphai, beta, vl, ldvl, vr,
                    
                
ggevx.hpp git://github.com/quantmind/jflib.git | C++ Header | 559 lines
                    
61            logical_t* bwork, integer_t& info ) {
                    
62        LAPACK_DGGEVX( &balanc, &jobvl, &jobvr, &sense, &n, a, &lda, b, &ldb,
                    
63                alphar, alphai, beta, vl, &ldvl, vr, &ldvr, &ilo, &ihi,
                    
                
clapack.h https://bitbucket.org/raviyellani/opencv.git | C Header | 1025 lines
                    
261
                    
262/* Subroutine */ int dggevx_(char *balanc, char *jobvl, char *jobvr, char *
                    
263	sense, integer *n, doublereal *a, integer *lda, doublereal *b, 
                    
                
Lapack.hh https://github.com/leppert/fire.git | C++ Header | 62 lines
                    
8  
                    
9  void dggevx(char* balanc, char* jobvl, char* jobvr, char* sense,
                    
10              long* n, double* a, long* lda, double* b, long* ldb,
                    
                
TRAN_Set_IntegPath.c https://github.com/certik/openmx.git | C | 1133 lines
                    
24/* Taisuke Ozaki Copyright (C) */
                    
25static void Eigen_DGGEVX( int n, double **a, double **s, double *eval,
                    
26                          double *resr, double *resi );
                    
                
Lapack.cpp https://github.com/leppert/fire.git | C++ | 171 lines
                    
16  
                    
17    void F77NAME(dggevx)(char* balanc, char* jobvl, char* jobvr, char* sense,
                    
18                         long* n, double* a, long* lda, double* b, long* ldb,
                    
70
                    
71  void dggevx(char* balanc, char* jobvl, char* jobvr, char* sense,
                    
72              long* n, double* a, long* lda, double* b, long* ldb,
                    
77#ifdef HAVE_LAPACK
                    
78    F77NAME(dggevx)(balanc, jobvl, jobvr, sense, n, a, lda, b, ldb,
                    
79                    alphar, alphai, beta, vl, ldvl, vr, ldvr,
                    
                
lapacke_dggevx_work.c https://bitbucket.org/iricpt/lapack.git | C | 162 lines
                    
28*****************************************************************************
                    
29* Contents: Native middle-level C interface to LAPACK function dggevx
                    
30* Author: Intel Corporation
                    
34
                    
35lapack_int LAPACKE_dggevx_work( int matrix_layout, char balanc, char jobvl,
                    
36                                char jobvr, char sense, lapack_int n, double* a,
                    
48        /* Call LAPACK function and adjust info */
                    
49        LAPACK_dggevx( &balanc, &jobvl, &jobvr, &sense, &n, a, &lda, b, &ldb,
                    
50                       alphar, alphai, beta, vl, &ldvl, vr, &ldvr, ilo, ihi,
                    
67            info = -8;
                    
68            LAPACKE_xerbla( "LAPACKE_dggevx_work", info );
                    
69            return info;
                    
72            info = -10;
                    
73            LAPACKE_xerbla( "LAPACKE_dggevx_work", info );
                    
74            return info;
                    
                
derrgg.c https://bitbucket.org/rutad/libs.git | C | 1310 lines
                    
106	    integer *, integer *, doublereal *, integer *), 
                    
107	    chkxer_(char *, integer *, integer *, logical *, logical *), dggevx_(char *, char *, char *, char *, integer *, 
                    
108	    doublereal *, integer *, doublereal *, integer *, doublereal *, 
                    
165
                    
166    DERRGG tests the error exits for DGGES, DGGESX, DGGEV, DGGEVX,   
                    
167    DGGGLM, DGGHRD, DGGLSE, DGGQRF, DGGRQF, DGGSVD, DGGSVP, DHGEQZ,   
                    
                
ddrgvx.c https://bitbucket.org/rutad/libs.git | C | 955 lines
                    
105    extern /* Subroutine */ int alasvm_(char *, integer *, integer *, integer 
                    
106	    *, integer *), dggevx_(char *, char *, char *, char *, 
                    
107	    integer *, doublereal *, integer *, doublereal *, integer *, 
                    
160    DDRGVX checks the nonsymmetric generalized eigenvalue problem   
                    
161    expert driver DGGEVX.   
                    
162
                    
162
                    
163    DGGEVX computes the generalized eigenvalues, (optionally) the left   
                    
164    and/or right eigenvectors, (optionally) computes a balancing   
                    
168    When DDRGVX is called with NSIZE > 0, two types of test matrix pairs   
                    
169    are generated by the subroutine DLATM6 and test the driver DGGEVX.   
                    
170    The test matrices have the known exact condition numbers for   
                    
187
                    
188    (3) The condition number S(i) of eigenvalues computed by DGGEVX   
                    
189        differs less than a factor THRESH from the exact S(i) (see   
                    
                
dchkee.c https://bitbucket.org/rutad/libs.git | C | 3127 lines
                    
98    static char fmt_9962[] = "(/\002 Tests of the Generalized Nonsymmetric E"
                    
99	    "igenvalue \002,\002Problem Expert Driver DGGEVX\002)";
                    
100    static char fmt_9974[] = "(\002 Tests of DSBTRD\002,/\002 (reduction of "
                    
                
dggevx.c https://bitbucket.org/slawton/windturbinemdo-stevebitb | C | 1028 lines
                    
1/* dggevx.f -- translated by f2c (version 20000121).
                    
2   You must link the resulting object file with the libraries:
                    
14
                    
15/* > \brief <b> DGGEVX computes the eigenvalues and, optionally, the left and/or right eigenvectors for GE mat
                    
16rices</b> */
                    
23/* > \htmlonly */
                    
24/* > Download DGGEVX + dependencies */
                    
25/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/dggevx.
                    
27/* > [TGZ]</a> */
                    
28/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/dggevx.
                    
29f"> */
                    
30/* > [ZIP]</a> */
                    
31/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/dggevx.
                    
32f"> */
                    
38
                    
39/*       SUBROUTINE DGGEVX( BALANC, JOBVL, JOBVR, SENSE, N, A, LDA, B, LDB, */
                    
40/*                          ALPHAR, ALPHAI, BETA, VL, LDVL, VR, LDVR, ILO, */
                    
                
derrgg.f https://bitbucket.org/iricpt/lapack.git | FORTRAN Legacy | 1207 lines
                    
23*>
                    
24*> DERRGG tests the error exits for DGGES, DGGESX, DGGEV,  DGGEVX,
                    
25*> DGGGLM, DGGHRD, DGGLSE, DGGQRF, DGGRQF, DGGSVD3,
                    
94*     .. External Subroutines ..
                    
95      EXTERNAL           CHKXER, DGGES, DGGESX, DGGEV, DGGEVX, DGGGLM,
                    
96     $                   DGGHRD, DGGLSE, DGGQRF, DGGRQF,
                    
                
dggevx.f https://bitbucket.org/iricpt/lapack.git | FORTRAN Legacy | 865 lines
                    
1*> \brief <b> DGGEVX computes the eigenvalues and, optionally, the left and/or right eigenvectors for GE matrices</b>
                    
2*
                    
8*> \htmlonly
                    
9*> Download DGGEVX + dependencies
                    
10*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/dggevx.f">
                    
11*> [TGZ]</a>
                    
12*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/dggevx.f">
                    
13*> [ZIP]</a>
                    
13*> [ZIP]</a>
                    
14*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/dggevx.f">
                    
15*> [TXT]</a>
                    
20*
                    
21*       SUBROUTINE DGGEVX( BALANC, JOBVL, JOBVR, SENSE, N, A, LDA, B, LDB,
                    
22*                          ALPHAR, ALPHAI, BETA, VL, LDVL, VR, LDVR, ILO,
                    
45*>
                    
46*> DGGEVX computes for a pair of N-by-N real nonsymmetric matrices (A,B)
                    
47*> the generalized eigenvalues, and optionally, the left and/or right
                    
                
dggglm.c https://bitbucket.org/slawton/windturbinemdo-stevebitb | C | 419 lines
                    
14
                    
15/* > \brief <b> DGGEVX computes the eigenvalues and, optionally, the left and/or right eigenvectors for GE mat
                    
16rices</b> */
                    
                
CMakeLists.txt https://github.com/xianyi/OpenBLAS.git | CMake | 2427 lines
                    
743lapacke_dggev3_work.c
                    
744lapacke_dggevx.c
                    
745lapacke_dggevx_work.c
                    
                
Config.mk https://gitlab.com/kollo/X11-Basic.git | Makefile | 311 lines
                    
179   dgetrf.c dgetri.c \
                    
180   dgetrs.c dggbak.c dggbal.c dgges.c  dggesx.c dggev.c  dggevx.c \
                    
181   dggglm.c dgghrd.c dgglse.c dggqrf.c \
                    
                
lapack_f77.h https://github.com/b45ch1/taylorpoly.git | C Header | 5272 lines
                    
375	#define f77_dggev dggev_
                    
376	#define f77_dggevx dggevx_
                    
377	#define f77_dggglm dggglm_
                    
                
Teuchos_LAPACK_wrappers.hpp https://github.com/qsnake/trilinos.git | C++ Header | 881 lines
                    
74#define DGESVD_F77  F77_BLAS_MANGLE(sgesvd,SGESVD)
                    
75#define DGGEVX_F77  F77_BLAS_MANGLE(sggevx,SGGEVX)
                    
76#define DGEHRD_F77  F77_BLAS_MANGLE(sgehrd,SGEHRD)
                    
188#define DGESVD_F77   F77_BLAS_MANGLE(dgesvd,DGESVD)
                    
189#define DGGEVX_F77  F77_BLAS_MANGLE(dggevx,DGGEVX)
                    
190#define DGEHRD_F77  F77_BLAS_MANGLE(dgehrd,DGEHRD)
                    
301#define DGESVD_F77   F77_BLAS_MANGLE(dgesvd,DGESVD)
                    
302#define DGGEVX_F77  F77_BLAS_MANGLE(dggevx,DGGEVX)
                    
303#define DGEHRD_F77  F77_BLAS_MANGLE(dgehrd,DGEHRD)
                    
                
Makefile.in https://gitlab.com/jnorthrup1/jmodelica | Autoconf | 1033 lines
                    
113	dggbal.$(OBJEXT) dgges.$(OBJEXT) dggesx.$(OBJEXT) \
                    
114	dggev.$(OBJEXT) dggevx.$(OBJEXT) dggglm.$(OBJEXT) \
                    
115	dgghrd.$(OBJEXT) dgglse.$(OBJEXT) dggqrf.$(OBJEXT) \
                    
435	dggev.f \
                    
436	dggevx.f \
                    
437	dggglm.f \
                    
                
lapack_intfc_mangle.h https://gitlab.com/y-shao/psi4public | C Header | 1023 lines
                    
93#define F_DGGEV  FC_GLOBAL(dggev,  DGGEV )
                    
94#define F_DGGEVX FC_GLOBAL(dggevx, DGGEVX)
                    
95#define F_DGGGLM FC_GLOBAL(dggglm, DGGGLM)
                    
290#define F_DGGEV dggev_
                    
291#define F_DGGEVX dggevx_
                    
292#define F_DGGGLM dggglm_
                    
                
lapack_intfc.cc https://gitlab.com/y-shao/psi4public | C++ | 20287 lines
                    
81extern int F_DGGEV(char*, char*, int*, double*, int*, double*, int*, double*, double*, double*, double*, int*, double*, int*, double*, int*,  int*);
                    
82extern int F_DGGEVX(char*, char*, char*, char*, int*, double*, int*, double*, int*, double*, double*, double*, double*, int*, double*, int*, int*, int*, double*, double*, double*, double*, double*, double*, double*, int*, int*,  int*);
                    
83extern int F_DGGGLM(int*, int*, int*, double*, int*, double*, int*, double*, double*, double*, double*, int*,  int*);
                    
                
export_blas_lapack.cc https://gitlab.com/y-shao/psi4public | C++ | 220 lines
                    
113    def("DGGEV", &psi::PSI_DGGEV);
                    
114    def("DGGEVX", &psi::PSI_DGGEVX);
                    
115    def("DGGGLM", &psi::PSI_DGGGLM);
                    
                
 

Source

Language