sgbsv(kl,ku,ab,b,[overwrite_ab,overwrite_b])
|
sgbsv 的包裝函式。
|
dgbsv(kl,ku,ab,b,[overwrite_ab,overwrite_b])
|
dgbsv 的包裝函式。
|
cgbsv(kl,ku,ab,b,[overwrite_ab,overwrite_b])
|
cgbsv 的包裝函式。
|
zgbsv(kl,ku,ab,b,[overwrite_ab,overwrite_b])
|
zgbsv 的包裝函式。
|
sgbtrf(ab,kl,ku,[m,n,ldab,overwrite_ab])
|
sgbtrf 的包裝函式。
|
dgbtrf(ab,kl,ku,[m,n,ldab,overwrite_ab])
|
dgbtrf 的包裝函式。
|
cgbtrf(ab,kl,ku,[m,n,ldab,overwrite_ab])
|
cgbtrf 的包裝函式。
|
zgbtrf(ab,kl,ku,[m,n,ldab,overwrite_ab])
|
zgbtrf 的包裝函式。
|
sgbtrs(...)
|
sgbtrs 的包裝函式。
|
dgbtrs(...)
|
dgbtrs 的包裝函式。
|
cgbtrs(...)
|
cgbtrs 的包裝函式。
|
zgbtrs(...)
|
zgbtrs 的包裝函式。
|
sgebal(a,[scale,permute,overwrite_a])
|
sgebal 的包裝函式。
|
dgebal(a,[scale,permute,overwrite_a])
|
dgebal 的包裝函式。
|
cgebal(a,[scale,permute,overwrite_a])
|
cgebal 的包裝函式。
|
zgebal(a,[scale,permute,overwrite_a])
|
zgebal 的包裝函式。
|
sgecon(a,anorm,[norm])
|
sgecon 的包裝函式。
|
dgecon(a,anorm,[norm])
|
dgecon 的包裝函式。
|
cgecon(a,anorm,[norm])
|
cgecon 的包裝函式。
|
zgecon(a,anorm,[norm])
|
zgecon 的包裝函式。
|
sgeequ(a)
|
sgeequ 的包裝函式。
|
dgeequ(a)
|
dgeequ 的包裝函式。
|
cgeequ(a)
|
cgeequ 的包裝函式。
|
zgeequ(a)
|
zgeequ 的包裝函式。
|
sgeequb(a)
|
sgeequb 的包裝函式。
|
dgeequb(a)
|
dgeequb 的包裝函式。
|
cgeequb(a)
|
cgeequb 的包裝函式。
|
zgeequb(a)
|
zgeequb 的包裝函式。
|
sgees(...)
|
sgees 的包裝函式。
|
dgees(...)
|
dgees 的包裝函式。
|
cgees(...)
|
cgees 的包裝函式。
|
zgees(...)
|
zgees 的包裝函式。
|
sgeev(...)
|
sgeev 的包裝函式。
|
dgeev(...)
|
dgeev 的包裝函式。
|
cgeev(...)
|
cgeev 的包裝函式。
|
zgeev(...)
|
zgeev 的包裝函式。
|
sgeev_lwork(n,[compute_vl,compute_vr])
|
sgeev_lwork 的包裝函式。
|
dgeev_lwork(n,[compute_vl,compute_vr])
|
dgeev_lwork 的包裝函式。
|
cgeev_lwork(n,[compute_vl,compute_vr])
|
cgeev_lwork 的包裝函式。
|
zgeev_lwork(n,[compute_vl,compute_vr])
|
zgeev_lwork 的包裝函式。
|
sgehrd(a,[lo,hi,lwork,overwrite_a])
|
sgehrd 的包裝函式。
|
dgehrd(a,[lo,hi,lwork,overwrite_a])
|
dgehrd 的包裝函式。
|
cgehrd(a,[lo,hi,lwork,overwrite_a])
|
cgehrd 的包裝函式。
|
zgehrd(a,[lo,hi,lwork,overwrite_a])
|
zgehrd 的包裝函式。
|
sgehrd_lwork(n,[lo,hi])
|
sgehrd_lwork 的包裝函式。
|
dgehrd_lwork(n,[lo,hi])
|
dgehrd_lwork 的包裝函式。
|
cgehrd_lwork(n,[lo,hi])
|
cgehrd_lwork 的包裝函式。
|
zgehrd_lwork(n,[lo,hi])
|
zgehrd_lwork 的包裝函式。
|
sgejsv(...)
|
sgejsv 的包裝函式。
|
dgejsv(...)
|
dgejsv 的包裝函式。
|
sgels(a,b,[trans,lwork,overwrite_a,overwrite_b])
|
sgels 的包裝函式。
|
dgels(a,b,[trans,lwork,overwrite_a,overwrite_b])
|
dgels 的包裝函式。
|
cgels(a,b,[trans,lwork,overwrite_a,overwrite_b])
|
cgels 的包裝函式。
|
zgels(a,b,[trans,lwork,overwrite_a,overwrite_b])
|
zgels 的包裝函式。
|
sgels_lwork(m,n,nrhs,[trans])
|
sgels_lwork 的包裝函式。
|
dgels_lwork(m,n,nrhs,[trans])
|
dgels_lwork 的包裝函式。
|
cgels_lwork(m,n,nrhs,[trans])
|
cgels_lwork 的包裝函式。
|
zgels_lwork(m,n,nrhs,[trans])
|
zgels_lwork 的包裝函式。
|
sgelsd(...)
|
sgelsd 的包裝函式。
|
dgelsd(...)
|
dgelsd 的包裝函式。
|
cgelsd(...)
|
cgelsd 的包裝函式。
|
zgelsd(...)
|
zgelsd 的包裝函式。
|
sgelsd_lwork(m,n,nrhs,[cond,lwork])
|
sgelsd_lwork 的包裝函式。
|
dgelsd_lwork(m,n,nrhs,[cond,lwork])
|
dgelsd_lwork 的包裝函式。
|
cgelsd_lwork(m,n,nrhs,[cond,lwork])
|
cgelsd_lwork 的包裝函式。
|
zgelsd_lwork(m,n,nrhs,[cond,lwork])
|
zgelsd_lwork 的包裝函式。
|
sgelss(a,b,[cond,lwork,overwrite_a,overwrite_b])
|
sgelss 的包裝函式。
|
dgelss(a,b,[cond,lwork,overwrite_a,overwrite_b])
|
dgelss 的包裝函式。
|
cgelss(a,b,[cond,lwork,overwrite_a,overwrite_b])
|
cgelss 的包裝函式。
|
zgelss(a,b,[cond,lwork,overwrite_a,overwrite_b])
|
zgelss 的包裝函式。
|
sgelss_lwork(m,n,nrhs,[cond,lwork])
|
sgelss_lwork 的包裝函式。
|
dgelss_lwork(m,n,nrhs,[cond,lwork])
|
dgelss_lwork 的包裝函式。
|
cgelss_lwork(m,n,nrhs,[cond,lwork])
|
cgelss_lwork 的包裝函式。
|
zgelss_lwork(m,n,nrhs,[cond,lwork])
|
zgelss_lwork 的包裝函式。
|
sgelsy(...)
|
sgelsy 的包裝函式。
|
dgelsy(...)
|
dgelsy 的包裝函式。
|
cgelsy(...)
|
cgelsy 的包裝函式。
|
zgelsy(...)
|
zgelsy 的包裝函式。
|
sgelsy_lwork(m,n,nrhs,cond,[lwork])
|
sgelsy_lwork 的包裝函式。
|
dgelsy_lwork(m,n,nrhs,cond,[lwork])
|
dgelsy_lwork 的包裝函式。
|
cgelsy_lwork(m,n,nrhs,cond,[lwork])
|
cgelsy_lwork 的包裝函式。
|
zgelsy_lwork(m,n,nrhs,cond,[lwork])
|
zgelsy_lwork 的包裝函式。
|
sgeqp3(a,[lwork,overwrite_a])
|
sgeqp3 的包裝函式。
|
dgeqp3(a,[lwork,overwrite_a])
|
dgeqp3 的包裝函式。
|
cgeqp3(a,[lwork,overwrite_a])
|
cgeqp3 的包裝函式。
|
zgeqp3(a,[lwork,overwrite_a])
|
zgeqp3 的包裝函式。
|
sgeqrf(a,[lwork,overwrite_a])
|
sgeqrf 的包裝函式。
|
dgeqrf(a,[lwork,overwrite_a])
|
dgeqrf 的包裝函式。
|
cgeqrf(a,[lwork,overwrite_a])
|
cgeqrf 的包裝函式。
|
zgeqrf(a,[lwork,overwrite_a])
|
zgeqrf 的包裝函式。
|
sgeqrf_lwork(m, n)
|
sgeqrf_lwork 的包裝函式。
|
dgeqrf_lwork(m, n)
|
dgeqrf_lwork 的包裝函式。
|
cgeqrf_lwork(m, n)
|
cgeqrf_lwork 的包裝函式。
|
zgeqrf_lwork(m, n)
|
zgeqrf_lwork 的包裝函式。
|
sgeqrfp(a,[lwork,overwrite_a])
|
sgeqrfp 的包裝函式。
|
dgeqrfp(a,[lwork,overwrite_a])
|
dgeqrfp 的包裝函式。
|
cgeqrfp(a,[lwork,overwrite_a])
|
cgeqrfp 的包裝函式。
|
zgeqrfp(a,[lwork,overwrite_a])
|
zgeqrfp 的包裝函式。
|
sgeqrfp_lwork(m, n)
|
sgeqrfp_lwork 的包裝函式。
|
dgeqrfp_lwork(m, n)
|
dgeqrfp_lwork 的包裝函式。
|
cgeqrfp_lwork(m, n)
|
cgeqrfp_lwork 的包裝函式。
|
zgeqrfp_lwork(m, n)
|
zgeqrfp_lwork 的包裝函式。
|
sgerqf(a,[lwork,overwrite_a])
|
sgerqf 的包裝函式。
|
dgerqf(a,[lwork,overwrite_a])
|
dgerqf 的包裝函式。
|
cgerqf(a,[lwork,overwrite_a])
|
cgerqf 的包裝函式。
|
zgerqf(a,[lwork,overwrite_a])
|
zgerqf 的包裝函式。
|
sgesdd(...)
|
sgesdd 的包裝函式。
|
dgesdd(...)
|
dgesdd 的包裝函式。
|
cgesdd(...)
|
cgesdd 的包裝函式。
|
zgesdd(...)
|
zgesdd 的包裝函式。
|
sgesdd_lwork(m,n,[compute_uv,full_matrices])
|
sgesdd_lwork 的包裝函式。
|
dgesdd_lwork(m,n,[compute_uv,full_matrices])
|
dgesdd_lwork 的包裝函式。
|
cgesdd_lwork(m,n,[compute_uv,full_matrices])
|
cgesdd_lwork 的包裝函式。
|
zgesdd_lwork(m,n,[compute_uv,full_matrices])
|
zgesdd_lwork 的包裝函式。
|
sgesv(a,b,[overwrite_a,overwrite_b])
|
sgesv 的包裝函式。
|
dgesv(a,b,[overwrite_a,overwrite_b])
|
用於 dgesv 的包裝函式。 |
cgesv(a,b,[overwrite_a,overwrite_b])
|
用於 cgesv 的包裝函式。 |
zgesv(a,b,[overwrite_a,overwrite_b])
|
用於 zgesv 的包裝函式。 |
sgesvd(...)
|
用於 sgesvd 的包裝函式。 |
dgesvd(...)
|
用於 dgesvd 的包裝函式。 |
cgesvd(...)
|
用於 cgesvd 的包裝函式。 |
zgesvd(...)
|
用於 zgesvd 的包裝函式。 |
sgesvd_lwork(m,n,[compute_uv,full_matrices])
|
用於 sgesvd_lwork 的包裝函式。 |
dgesvd_lwork(m,n,[compute_uv,full_matrices])
|
用於 dgesvd_lwork 的包裝函式。 |
cgesvd_lwork(m,n,[compute_uv,full_matrices])
|
用於 cgesvd_lwork 的包裝函式。 |
zgesvd_lwork(m,n,[compute_uv,full_matrices])
|
用於 zgesvd_lwork 的包裝函式。 |
sgesvx(...)
|
用於 sgesvx 的包裝函式。 |
dgesvx(...)
|
用於 dgesvx 的包裝函式。 |
cgesvx(...)
|
用於 cgesvx 的包裝函式。 |
zgesvx(...)
|
用於 zgesvx 的包裝函式。 |
sgetrf(a,[overwrite_a])
|
用於 sgetrf 的包裝函式。 |
dgetrf(a,[overwrite_a])
|
用於 dgetrf 的包裝函式。 |
cgetrf(a,[overwrite_a])
|
用於 cgetrf 的包裝函式。 |
zgetrf(a,[overwrite_a])
|
用於 zgetrf 的包裝函式。 |
sgetc2(a,[overwrite_a])
|
用於 sgetc2 的包裝函式。 |
dgetc2(a,[overwrite_a])
|
用於 dgetc2 的包裝函式。 |
cgetc2(a,[overwrite_a])
|
用於 cgetc2 的包裝函式。 |
zgetc2(a,[overwrite_a])
|
用於 zgetc2 的包裝函式。 |
sgetri(lu,piv,[lwork,overwrite_lu])
|
用於 sgetri 的包裝函式。 |
dgetri(lu,piv,[lwork,overwrite_lu])
|
用於 dgetri 的包裝函式。 |
cgetri(lu,piv,[lwork,overwrite_lu])
|
用於 cgetri 的包裝函式。 |
zgetri(lu,piv,[lwork,overwrite_lu])
|
用於 zgetri 的包裝函式。 |
sgetri_lwork(n)
|
用於 sgetri_lwork 的包裝函式。 |
dgetri_lwork(n)
|
用於 dgetri_lwork 的包裝函式。 |
cgetri_lwork(n)
|
用於 cgetri_lwork 的包裝函式。 |
zgetri_lwork(n)
|
用於 zgetri_lwork 的包裝函式。 |
sgetrs(lu,piv,b,[trans,overwrite_b])
|
用於 sgetrs 的包裝函式。 |
dgetrs(lu,piv,b,[trans,overwrite_b])
|
用於 dgetrs 的包裝函式。 |
cgetrs(lu,piv,b,[trans,overwrite_b])
|
用於 cgetrs 的包裝函式。 |
zgetrs(lu,piv,b,[trans,overwrite_b])
|
用於 zgetrs 的包裝函式。 |
sgesc2(lu,rhs,ipiv,jpiv,[overwrite_rhs])
|
用於 sgesc2 的包裝函式。 |
dgesc2(lu,rhs,ipiv,jpiv,[overwrite_rhs])
|
用於 dgesc2 的包裝函式。 |
cgesc2(lu,rhs,ipiv,jpiv,[overwrite_rhs])
|
用於 cgesc2 的包裝函式。 |
zgesc2(lu,rhs,ipiv,jpiv,[overwrite_rhs])
|
用於 zgesc2 的包裝函式。 |
sgges(...)
|
用於 sgges 的包裝函式。 |
dgges(...)
|
用於 dgges 的包裝函式。 |
cgges(...)
|
用於 cgges 的包裝函式。 |
zgges(...)
|
用於 zgges 的包裝函式。 |
sggev(...)
|
用於 sggev 的包裝函式。 |
dggev(...)
|
用於 dggev 的包裝函式。 |
cggev(...)
|
用於 cggev 的包裝函式。 |
zggev(...)
|
用於 zggev 的包裝函式。 |
sgglse(...)
|
用於 sgglse 的包裝函式。 |
dgglse(...)
|
用於 dgglse 的包裝函式。 |
cgglse(...)
|
用於 cgglse 的包裝函式。 |
zgglse(...)
|
用於 zgglse 的包裝函式。 |
sgglse_lwork(m, n, p)
|
用於 sgglse_lwork 的包裝函式。 |
dgglse_lwork(m, n, p)
|
用於 dgglse_lwork 的包裝函式。 |
cgglse_lwork(m, n, p)
|
用於 cgglse_lwork 的包裝函式。 |
zgglse_lwork(m, n, p)
|
用於 zgglse_lwork 的包裝函式。 |
sgtsv(...)
|
用於 sgtsv 的包裝函式。 |
dgtsv(...)
|
用於 dgtsv 的包裝函式。 |
cgtsv(...)
|
用於 cgtsv 的包裝函式。 |
zgtsv(...)
|
用於 zgtsv 的包裝函式。 |
sgtsvx(...)
|
用於 sgtsvx 的包裝函式。 |
dgtsvx(...)
|
用於 dgtsvx 的包裝函式。 |
cgtsvx(...)
|
用於 cgtsvx 的包裝函式。 |
zgtsvx(...)
|
用於 zgtsvx 的包裝函式。 |
chbevd(...)
|
用於 chbevd 的包裝函式。 |
zhbevd(...)
|
用於 zhbevd 的包裝函式。 |
chbevx(...)
|
用於 chbevx 的包裝函式。 |
zhbevx(...)
|
用於 zhbevx 的包裝函式。 |
checon(a,ipiv,anorm,[lower])
|
用於 checon 的包裝函式。 |
zhecon(a,ipiv,anorm,[lower])
|
用於 zhecon 的包裝函式。 |
cheequb(a,[lower])
|
用於 cheequb 的包裝函式。 |
zheequb(a,[lower])
|
用於 zheequb 的包裝函式。 |
cheev(a,[compute_v,lower,lwork,overwrite_a])
|
用於 cheev 的包裝函式。 |
zheev(a,[compute_v,lower,lwork,overwrite_a])
|
用於 zheev 的包裝函式。 |
cheev_lwork(n,[lower])
|
用於 cheev_lwork 的包裝函式。 |
zheev_lwork(n,[lower])
|
用於 zheev_lwork 的包裝函式。 |
cheevd(...)
|
用於 cheevd 的包裝函式。 |
zheevd(...)
|
用於 zheevd 的包裝函式。 |
cheevd_lwork(n,[compute_v,lower])
|
用於 cheevd_lwork 的包裝函式。 |
zheevd_lwork(n,[compute_v,lower])
|
用於 zheevd_lwork 的包裝函式。 |
cheevr(...)
|
用於 cheevr 的包裝函式。 |
zheevr(...)
|
用於 zheevr 的包裝函式。 |
cheevr_lwork(n,[lower])
|
用於 cheevr_lwork 的包裝函式。 |
zheevr_lwork(n,[lower])
|
用於 zheevr_lwork 的包裝函式。 |
cheevx(...)
|
用於 cheevx 的包裝函式。 |
zheevx(...)
|
用於 zheevx 的包裝函式。 |
cheevx_lwork(n,[lower])
|
用於 cheevx_lwork 的包裝函式。 |
zheevx_lwork(n,[lower])
|
用於 zheevx_lwork 的包裝函式。 |
chegst(a,b,[itype,lower,overwrite_a])
|
用於 chegst 的包裝函式。 |
zhegst(a,b,[itype,lower,overwrite_a])
|
用於 zhegst 的包裝函式。 |
chegv(...)
|
用於 chegv 的包裝函式。 |
zhegv(...)
|
用於 zhegv 的包裝函式。 |
chegv_lwork(n,[uplo])
|
用於 chegv_lwork 的包裝函式。 |
zhegv_lwork(n,[uplo])
|
用於 zhegv_lwork 的包裝函式。 |
chegvd(...)
|
用於 chegvd 的包裝函式。 |
zhegvd(...)
|
用於 zhegvd 的包裝函式。 |
chegvx(...)
|
用於 chegvx 的包裝函式。 |
zhegvx(...)
|
用於 zhegvx 的包裝函式。 |
chegvx_lwork(n,[uplo])
|
用於 chegvx_lwork 的包裝函式。 |
zhegvx_lwork(n,[uplo])
|
用於 zhegvx_lwork 的包裝函式。 |
chesv(a,b,[lwork,lower,overwrite_a,overwrite_b])
|
用於 chesv 的包裝函式。 |
zhesv(a,b,[lwork,lower,overwrite_a,overwrite_b])
|
用於 zhesv 的包裝函式。 |
chesv_lwork(n,[lower])
|
用於 chesv_lwork 的包裝函式。 |
zhesv_lwork(n,[lower])
|
用於 zhesv_lwork 的包裝函式。 |
chesvx(...)
|
用於 chesvx 的包裝函式。 |
zhesvx(...)
|
用於 zhesvx 的包裝函式。 |
chesvx_lwork(n,[lower])
|
用於 chesvx_lwork 的包裝函式。 |
zhesvx_lwork(n,[lower])
|
用於 zhesvx_lwork 的包裝函式。 |
chetrd(a,[lower,lwork,overwrite_a])
|
用於 chetrd 的包裝函式。 |
zhetrd(a,[lower,lwork,overwrite_a])
|
用於 zhetrd 的包裝函式。 |
chetrd_lwork(n,[lower])
|
用於 chetrd_lwork 的包裝函式。 |
zhetrd_lwork(n,[lower])
|
用於 zhetrd_lwork 的包裝函式。 |
chetrf(a,[lower,lwork,overwrite_a])
|
用於 chetrf 的包裝函式。 |
zhetrf(a,[lower,lwork,overwrite_a])
|
用於 zhetrf 的包裝函式。 |
chetrf_lwork(n,[lower])
|
用於 chetrf_lwork 的包裝函式。 |
zhetrf_lwork(n,[lower])
|
用於 zhetrf_lwork 的包裝函式。 |
chetrs(a,ipiv,b,[lower,overwrite_b])
|
用於 chetrs 的包裝函式。 |
zhetrs(a,ipiv,b,[lower,overwrite_b])
|
用於 zhetrs 的包裝函式。 |
chfrk(...)
|
用於 chfrk 的包裝函式。 |
zhfrk(...)
|
用於 zhfrk 的包裝函式。 |
slamch(cmach)
|
用於 slamch 的包裝函式。 |
dlamch(cmach)
|
用於 dlamch 的包裝函式。 |
slange(norm, a)
|
用於 slange 的包裝函式。 |
dlange(norm, a)
|
用於 dlange 的包裝函式。 |
clange(norm, a)
|
用於 clange 的包裝函式。 |
zlange(norm, a)
|
用於 zlange 的包裝函式。 |
slantr(norm,a,[uplo,diag])
|
用於 slantr 的包裝函式。 |
dlantr(norm,a,[uplo,diag])
|
用於 dlantr 的包裝函式。 |
clantr(norm,a,[uplo,diag])
|
用於 clantr 的包裝函式。 |
zlantr(norm,a,[uplo,diag])
|
用於 zlantr 的包裝函式。 |
slarf(v,tau,c,work,[side,incv,overwrite_c])
|
用於 slarf 的包裝函式。 |
dlarf(v,tau,c,work,[side,incv,overwrite_c])
|
用於 dlarf 的包裝函式。 |
clarf(v,tau,c,work,[side,incv,overwrite_c])
|
用於 clarf 的包裝函式。 |
zlarf(v,tau,c,work,[side,incv,overwrite_c])
|
用於 zlarf 的包裝函式。 |
slarfg(n,alpha,x,[incx,overwrite_x])
|
用於 slarfg 的包裝函式。 |
dlarfg(n,alpha,x,[incx,overwrite_x])
|
用於 dlarfg 的包裝函式。 |
clarfg(n,alpha,x,[incx,overwrite_x])
|
用於 clarfg 的包裝函式。 |
zlarfg(n,alpha,x,[incx,overwrite_x])
|
用於 zlarfg 的包裝函式。 |
slartg(f, g)
|
用於 slartg 的包裝函式。 |
dlartg(f, g)
|
用於 dlartg 的包裝函式。 |
clartg(f, g)
|
用於 clartg 的包裝函式。 |
zlartg(f, g)
|
用於 zlartg 的包裝函式。 |
slasd4(i,d,z,[rho])
|
用於 slasd4 的包裝函式。 |
dlasd4(i,d,z,[rho])
|
用於 dlasd4 的包裝函式。 |
slaswp(a,piv,[k1,k2,off,inc,overwrite_a])
|
用於 slaswp 的包裝函式。 |
dlaswp(a,piv,[k1,k2,off,inc,overwrite_a])
|
用於 dlaswp 的包裝函式。 |
claswp(a,piv,[k1,k2,off,inc,overwrite_a])
|
用於 claswp 的包裝函式。 |
zlaswp(a,piv,[k1,k2,off,inc,overwrite_a])
|
用於 zlaswp 的包裝函式。 |
slauum(c,[lower,overwrite_c])
|
用於 slauum 的包裝函式。 |
dlauum(c,[lower,overwrite_c])
|
用於 dlauum 的包裝函式。 |
clauum(c,[lower,overwrite_c])
|
用於 clauum 的包裝函式。 |
zlauum(c,[lower,overwrite_c])
|
用於 zlauum 的包裝函式。 |
sorcsd(...)
|
用於 sorcsd 的包裝函式。 |
dorcsd(...)
|
用於 dorcsd 的包裝函式。 |
sorcsd_lwork(m, p, q)
|
用於 sorcsd_lwork 的包裝函式。 |
dorcsd_lwork(m, p, q)
|
用於 dorcsd_lwork 的包裝函式。 |
sorghr(a,tau,[lo,hi,lwork,overwrite_a])
|
用於 sorghr 的包裝函式。 |
dorghr(a,tau,[lo,hi,lwork,overwrite_a])
|
用於 dorghr 的包裝函式。 |
sorghr_lwork(n,[lo,hi])
|
針對 sorghr_lwork 的包裝器。 |
dorghr_lwork(n,[lo,hi])
|
針對 dorghr_lwork 的包裝器。 |
sorgqr(a,tau,[lwork,overwrite_a])
|
針對 sorgqr 的包裝器。 |
dorgqr(a,tau,[lwork,overwrite_a])
|
針對 dorgqr 的包裝器。 |
sorgrq(a,tau,[lwork,overwrite_a])
|
針對 sorgrq 的包裝器。 |
dorgrq(a,tau,[lwork,overwrite_a])
|
針對 dorgrq 的包裝器。 |
sormqr(side,trans,a,tau,c,lwork,[overwrite_c])
|
針對 sormqr 的包裝器。 |
dormqr(side,trans,a,tau,c,lwork,[overwrite_c])
|
針對 dormqr 的包裝器。 |
sormrz(a,tau,c,[side,trans,lwork,overwrite_c])
|
針對 sormrz 的包裝器。 |
dormrz(a,tau,c,[side,trans,lwork,overwrite_c])
|
針對 dormrz 的包裝器。 |
sormrz_lwork(m,n,[side,trans])
|
針對 sormrz_lwork 的包裝器。 |
dormrz_lwork(m,n,[side,trans])
|
針對 dormrz_lwork 的包裝器。 |
spbsv(ab,b,[lower,ldab,overwrite_ab,overwrite_b])
|
針對 spbsv 的包裝器。 |
dpbsv(ab,b,[lower,ldab,overwrite_ab,overwrite_b])
|
針對 dpbsv 的包裝器。 |
cpbsv(ab,b,[lower,ldab,overwrite_ab,overwrite_b])
|
針對 cpbsv 的包裝器。 |
zpbsv(ab,b,[lower,ldab,overwrite_ab,overwrite_b])
|
針對 zpbsv 的包裝器。 |
spbtrf(ab,[lower,ldab,overwrite_ab])
|
針對 spbtrf 的包裝器。 |
dpbtrf(ab,[lower,ldab,overwrite_ab])
|
針對 dpbtrf 的包裝器。 |
cpbtrf(ab,[lower,ldab,overwrite_ab])
|
針對 cpbtrf 的包裝器。 |
zpbtrf(ab,[lower,ldab,overwrite_ab])
|
針對 zpbtrf 的包裝器。 |
spbtrs(ab,b,[lower,ldab,overwrite_b])
|
針對 spbtrs 的包裝器。 |
dpbtrs(ab,b,[lower,ldab,overwrite_b])
|
針對 dpbtrs 的包裝器。 |
cpbtrs(ab,b,[lower,ldab,overwrite_b])
|
針對 cpbtrs 的包裝器。 |
zpbtrs(ab,b,[lower,ldab,overwrite_b])
|
針對 zpbtrs 的包裝器。 |
spftrf(n,a,[transr,uplo,overwrite_a])
|
針對 spftrf 的包裝器。 |
dpftrf(n,a,[transr,uplo,overwrite_a])
|
針對 dpftrf 的包裝器。 |
cpftrf(n,a,[transr,uplo,overwrite_a])
|
針對 cpftrf 的包裝器。 |
zpftrf(n,a,[transr,uplo,overwrite_a])
|
針對 zpftrf 的包裝器。 |
spftri(n,a,[transr,uplo,overwrite_a])
|
針對 spftri 的包裝器。 |
dpftri(n,a,[transr,uplo,overwrite_a])
|
針對 dpftri 的包裝器。 |
cpftri(n,a,[transr,uplo,overwrite_a])
|
針對 cpftri 的包裝器。 |
zpftri(n,a,[transr,uplo,overwrite_a])
|
針對 zpftri 的包裝器。 |
spftrs(n,a,b,[transr,uplo,overwrite_b])
|
針對 spftrs 的包裝器。 |
dpftrs(n,a,b,[transr,uplo,overwrite_b])
|
針對 dpftrs 的包裝器。 |
cpftrs(n,a,b,[transr,uplo,overwrite_b])
|
針對 cpftrs 的包裝器。 |
zpftrs(n,a,b,[transr,uplo,overwrite_b])
|
針對 zpftrs 的包裝器。 |
spocon(a,anorm,[uplo])
|
針對 spocon 的包裝器。 |
dpocon(a,anorm,[uplo])
|
針對 dpocon 的包裝器。 |
cpocon(a,anorm,[uplo])
|
針對 cpocon 的包裝器。 |
zpocon(a,anorm,[uplo])
|
針對 zpocon 的包裝器。 |
spstrf(a,[tol,lower,overwrite_a])
|
針對 spstrf 的包裝器。 |
dpstrf(a,[tol,lower,overwrite_a])
|
針對 dpstrf 的包裝器。 |
cpstrf(a,[tol,lower,overwrite_a])
|
針對 cpstrf 的包裝器。 |
zpstrf(a,[tol,lower,overwrite_a])
|
針對 zpstrf 的包裝器。 |
spstf2(a,[tol,lower,overwrite_a])
|
針對 spstf2 的包裝器。 |
dpstf2(a,[tol,lower,overwrite_a])
|
針對 dpstf2 的包裝器。 |
cpstf2(a,[tol,lower,overwrite_a])
|
針對 cpstf2 的包裝器。 |
zpstf2(a,[tol,lower,overwrite_a])
|
針對 zpstf2 的包裝器。 |
sposv(a,b,[lower,overwrite_a,overwrite_b])
|
針對 sposv 的包裝器。 |
dposv(a,b,[lower,overwrite_a,overwrite_b])
|
針對 dposv 的包裝器。 |
cposv(a,b,[lower,overwrite_a,overwrite_b])
|
針對 cposv 的包裝器。 |
zposv(a,b,[lower,overwrite_a,overwrite_b])
|
針對 zposv 的包裝器。 |
sposvx(...)
|
針對 sposvx 的包裝器。 |
dposvx(...)
|
針對 dposvx 的包裝器。 |
cposvx(...)
|
針對 cposvx 的包裝器。 |
zposvx(...)
|
針對 zposvx 的包裝器。 |
spotrf(a,[lower,clean,overwrite_a])
|
針對 spotrf 的包裝器。 |
dpotrf(a,[lower,clean,overwrite_a])
|
針對 dpotrf 的包裝器。 |
cpotrf(a,[lower,clean,overwrite_a])
|
針對 cpotrf 的包裝器。 |
zpotrf(a,[lower,clean,overwrite_a])
|
針對 zpotrf 的包裝器。 |
spotri(c,[lower,overwrite_c])
|
針對 spotri 的包裝器。 |
dpotri(c,[lower,overwrite_c])
|
針對 dpotri 的包裝器。 |
cpotri(c,[lower,overwrite_c])
|
針對 cpotri 的包裝器。 |
zpotri(c,[lower,overwrite_c])
|
針對 zpotri 的包裝器。 |
spotrs(c,b,[lower,overwrite_b])
|
針對 spotrs 的包裝器。 |
dpotrs(c,b,[lower,overwrite_b])
|
針對 dpotrs 的包裝器。 |
cpotrs(c,b,[lower,overwrite_b])
|
針對 cpotrs 的包裝器。 |
zpotrs(c,b,[lower,overwrite_b])
|
針對 zpotrs 的包裝器。 |
sppcon(n,ap,anorm,[lower])
|
針對 sppcon 的包裝器。 |
dppcon(n,ap,anorm,[lower])
|
針對 dppcon 的包裝器。 |
cppcon(n,ap,anorm,[lower])
|
針對 cppcon 的包裝器。 |
zppcon(n,ap,anorm,[lower])
|
針對 zppcon 的包裝器。 |
sppsv(n,ap,b,[lower,overwrite_b])
|
針對 sppsv 的包裝器。 |
dppsv(n,ap,b,[lower,overwrite_b])
|
針對 dppsv 的包裝器。 |
cppsv(n,ap,b,[lower,overwrite_b])
|
針對 cppsv 的包裝器。 |
zppsv(n,ap,b,[lower,overwrite_b])
|
針對 zppsv 的包裝器。 |
spptrf(n,ap,[lower,overwrite_ap])
|
針對 spptrf 的包裝器。 |
dpptrf(n,ap,[lower,overwrite_ap])
|
針對 dpptrf 的包裝器。 |
cpptrf(n,ap,[lower,overwrite_ap])
|
針對 cpptrf 的包裝器。 |
zpptrf(n,ap,[lower,overwrite_ap])
|
針對 zpptrf 的包裝器。 |
spptri(n,ap,[lower,overwrite_ap])
|
針對 spptri 的包裝器。 |
dpptri(n,ap,[lower,overwrite_ap])
|
針對 dpptri 的包裝器。 |
cpptri(n,ap,[lower,overwrite_ap])
|
針對 cpptri 的包裝器。 |
zpptri(n,ap,[lower,overwrite_ap])
|
針對 zpptri 的包裝器。 |
spptrs(n,ap,b,[lower,overwrite_b])
|
針對 spptrs 的包裝器。 |
dpptrs(n,ap,b,[lower,overwrite_b])
|
針對 dpptrs 的包裝器。 |
cpptrs(n,ap,b,[lower,overwrite_b])
|
針對 cpptrs 的包裝器。 |
zpptrs(n,ap,b,[lower,overwrite_b])
|
針對 zpptrs 的包裝器。 |
sptsv(...)
|
針對 sptsv 的包裝器。 |
dptsv(...)
|
針對 dptsv 的包裝器。 |
cptsv(...)
|
針對 cptsv 的包裝器。 |
zptsv(...)
|
針對 zptsv 的包裝器。 |
sptsvx(d,e,b,[fact,df,ef])
|
針對 sptsvx 的包裝器。 |
dptsvx(d,e,b,[fact,df,ef])
|
針對 dptsvx 的包裝器。 |
cptsvx(d,e,b,[fact,df,ef])
|
針對 cptsvx 的包裝器。 |
zptsvx(d,e,b,[fact,df,ef])
|
針對 zptsvx 的包裝器。 |
spttrf(d,e,[overwrite_d,overwrite_e])
|
針對 spttrf 的包裝器。 |
dpttrf(d,e,[overwrite_d,overwrite_e])
|
針對 dpttrf 的包裝器。 |
cpttrf(d,e,[overwrite_d,overwrite_e])
|
針對 cpttrf 的包裝器。 |
zpttrf(d,e,[overwrite_d,overwrite_e])
|
針對 zpttrf 的包裝器。 |
spttrs(d,e,b,[overwrite_b])
|
針對 spttrs 的包裝器。 |
dpttrs(d,e,b,[overwrite_b])
|
針對 dpttrs 的包裝器。 |
cpttrs(d,e,b,[lower,overwrite_b])
|
針對 cpttrs 的包裝器。 |
zpttrs(d,e,b,[lower,overwrite_b])
|
針對 zpttrs 的包裝器。 |
spteqr(...)
|
針對 spteqr 的包裝器。 |
dpteqr(...)
|
針對 dpteqr 的包裝器。 |
cpteqr(...)
|
針對 cpteqr 的包裝器。 |
zpteqr(...)
|
針對 zpteqr 的包裝器。 |
crot(...)
|
針對 crot 的包裝器。 |
zrot(...)
|
針對 zrot 的包裝器。 |
ssbev(ab,[compute_v,lower,ldab,overwrite_ab])
|
針對 ssbev 的包裝器。 |
dsbev(ab,[compute_v,lower,ldab,overwrite_ab])
|
針對 dsbev 的包裝器。 |
ssbevd(...)
|
針對 ssbevd 的包裝器。 |
dsbevd(...)
|
針對 dsbevd 的包裝器。 |
ssbevx(...)
|
針對 ssbevx 的包裝器。 |
dsbevx(...)
|
針對 dsbevx 的包裝器。 |
ssfrk(...)
|
針對 ssfrk 的包裝器。 |
dsfrk(...)
|
針對 dsfrk 的包裝器。 |
sstebz(d, e, range, vl, vu, il, iu, tol, order)
|
針對 sstebz 的包裝器。 |
dstebz(d, e, range, vl, vu, il, iu, tol, order)
|
針對 dstebz 的包裝器。 |
sstein(d, e, w, iblock, isplit)
|
針對 sstein 的包裝器。 |
dstein(d, e, w, iblock, isplit)
|
針對 dstein 的包裝器。 |
sstemr(...)
|
針對 sstemr 的包裝器。 |
dstemr(...)
|
針對 dstemr 的包裝器。 |
sstemr_lwork(...)
|
針對 sstemr_lwork 的包裝器。 |
dstemr_lwork(...)
|
針對 dstemr_lwork 的包裝器。 |
ssterf(d,e,[overwrite_d,overwrite_e])
|
針對 ssterf 的包裝器。 |
dsterf(d,e,[overwrite_d,overwrite_e])
|
針對 dsterf 的包裝器。 |
sstev(d,e,[compute_v,overwrite_d,overwrite_e])
|
針對 sstev 的包裝器。 |
dstev(d,e,[compute_v,overwrite_d,overwrite_e])
|
針對 dstev 的封裝器。 |
ssycon(a,ipiv,anorm,[lower])
|
針對 ssycon 的封裝器。 |
dsycon(a,ipiv,anorm,[lower])
|
針對 dsycon 的封裝器。 |
csycon(a,ipiv,anorm,[lower])
|
針對 csycon 的封裝器。 |
zsycon(a,ipiv,anorm,[lower])
|
針對 zsycon 的封裝器。 |
ssyconv(a,ipiv,[lower,way,overwrite_a])
|
針對 ssyconv 的封裝器。 |
dsyconv(a,ipiv,[lower,way,overwrite_a])
|
針對 dsyconv 的封裝器。 |
csyconv(a,ipiv,[lower,way,overwrite_a])
|
針對 csyconv 的封裝器。 |
zsyconv(a,ipiv,[lower,way,overwrite_a])
|
針對 zsyconv 的封裝器。 |
ssyequb(a,[lower])
|
針對 ssyequb 的封裝器。 |
dsyequb(a,[lower])
|
針對 dsyequb 的封裝器。 |
csyequb(a,[lower])
|
針對 csyequb 的封裝器。 |
zsyequb(a,[lower])
|
針對 zsyequb 的封裝器。 |
ssyev(a,[compute_v,lower,lwork,overwrite_a])
|
針對 ssyev 的封裝器。 |
dsyev(a,[compute_v,lower,lwork,overwrite_a])
|
針對 dsyev 的封裝器。 |
ssyev_lwork(n,[lower])
|
針對 ssyev_lwork 的封裝器。 |
dsyev_lwork(n,[lower])
|
針對 dsyev_lwork 的封裝器。 |
ssyevd(...)
|
針對 ssyevd 的封裝器。 |
dsyevd(...)
|
針對 dsyevd 的封裝器。 |
ssyevd_lwork(n,[compute_v,lower])
|
針對 ssyevd_lwork 的封裝器。 |
dsyevd_lwork(n,[compute_v,lower])
|
針對 dsyevd_lwork 的封裝器。 |
ssyevr(...)
|
針對 ssyevr 的封裝器。 |
dsyevr(...)
|
針對 dsyevr 的封裝器。 |
ssyevr_lwork(n,[lower])
|
針對 ssyevr_lwork 的封裝器。 |
dsyevr_lwork(n,[lower])
|
針對 dsyevr_lwork 的封裝器。 |
ssyevx(...)
|
針對 ssyevx 的封裝器。 |
dsyevx(...)
|
針對 dsyevx 的封裝器。 |
ssyevx_lwork(n,[lower])
|
針對 ssyevx_lwork 的封裝器。 |
dsyevx_lwork(n,[lower])
|
針對 dsyevx_lwork 的封裝器。 |
ssygst(a,b,[itype,lower,overwrite_a])
|
針對 ssygst 的封裝器。 |
dsygst(a,b,[itype,lower,overwrite_a])
|
針對 dsygst 的封裝器。 |
ssygv(...)
|
針對 ssygv 的封裝器。 |
dsygv(...)
|
針對 dsygv 的封裝器。 |
ssygv_lwork(n,[uplo])
|
針對 ssygv_lwork 的封裝器。 |
dsygv_lwork(n,[uplo])
|
針對 dsygv_lwork 的封裝器。 |
ssygvd(...)
|
針對 ssygvd 的封裝器。 |
dsygvd(...)
|
針對 dsygvd 的封裝器。 |
ssygvx(...)
|
針對 ssygvx 的封裝器。 |
dsygvx(...)
|
針對 dsygvx 的封裝器。 |
ssygvx_lwork(n,[uplo])
|
針對 ssygvx_lwork 的封裝器。 |
dsygvx_lwork(n,[uplo])
|
針對 dsygvx_lwork 的封裝器。 |
ssysv(a,b,[lwork,lower,overwrite_a,overwrite_b])
|
針對 ssysv 的封裝器。 |
dsysv(a,b,[lwork,lower,overwrite_a,overwrite_b])
|
針對 dsysv 的封裝器。 |
csysv(a,b,[lwork,lower,overwrite_a,overwrite_b])
|
針對 csysv 的封裝器。 |
zsysv(a,b,[lwork,lower,overwrite_a,overwrite_b])
|
針對 zsysv 的封裝器。 |
ssysv_lwork(n,[lower])
|
針對 ssysv_lwork 的封裝器。 |
dsysv_lwork(n,[lower])
|
針對 dsysv_lwork 的封裝器。 |
csysv_lwork(n,[lower])
|
針對 csysv_lwork 的封裝器。 |
zsysv_lwork(n,[lower])
|
針對 zsysv_lwork 的封裝器。 |
ssysvx(...)
|
針對 ssysvx 的封裝器。 |
dsysvx(...)
|
針對 dsysvx 的封裝器。 |
csysvx(...)
|
針對 csysvx 的封裝器。 |
zsysvx(...)
|
針對 zsysvx 的封裝器。 |
ssysvx_lwork(n,[lower])
|
針對 ssysvx_lwork 的封裝器。 |
dsysvx_lwork(n,[lower])
|
針對 dsysvx_lwork 的封裝器。 |
csysvx_lwork(n,[lower])
|
針對 csysvx_lwork 的封裝器。 |
zsysvx_lwork(n,[lower])
|
針對 zsysvx_lwork 的封裝器。 |
ssytf2(a,[lower,overwrite_a])
|
針對 ssytf2 的封裝器。 |
dsytf2(a,[lower,overwrite_a])
|
針對 dsytf2 的封裝器。 |
csytf2(a,[lower,overwrite_a])
|
針對 csytf2 的封裝器。 |
zsytf2(a,[lower,overwrite_a])
|
針對 zsytf2 的封裝器。 |
ssytrd(a,[lower,lwork,overwrite_a])
|
針對 ssytrd 的封裝器。 |
dsytrd(a,[lower,lwork,overwrite_a])
|
針對 dsytrd 的封裝器。 |
ssytrd_lwork(n,[lower])
|
針對 ssytrd_lwork 的封裝器。 |
dsytrd_lwork(n,[lower])
|
針對 dsytrd_lwork 的封裝器。 |
ssytrf(a,[lower,lwork,overwrite_a])
|
針對 ssytrf 的封裝器。 |
dsytrf(a,[lower,lwork,overwrite_a])
|
針對 dsytrf 的封裝器。 |
csytrf(a,[lower,lwork,overwrite_a])
|
針對 csytrf 的封裝器。 |
zsytrf(a,[lower,lwork,overwrite_a])
|
針對 zsytrf 的封裝器。 |
ssytrf_lwork(n,[lower])
|
針對 ssytrf_lwork 的封裝器。 |
dsytrf_lwork(n,[lower])
|
針對 dsytrf_lwork 的封裝器。 |
csytrf_lwork(n,[lower])
|
針對 csytrf_lwork 的封裝器。 |
zsytrf_lwork(n,[lower])
|
針對 zsytrf_lwork 的封裝器。 |
ssytrs(a,ipiv,b,[lower,overwrite_b])
|
針對 ssytrs 的封裝器。 |
dsytrs(a,ipiv,b,[lower,overwrite_b])
|
針對 dsytrs 的封裝器。 |
csytrs(a,ipiv,b,[lower,overwrite_b])
|
針對 csytrs 的封裝器。 |
zsytrs(a,ipiv,b,[lower,overwrite_b])
|
針對 zsytrs 的封裝器。 |
stbtrs(ab,b,[uplo,trans,diag,overwrite_b])
|
針對 stbtrs 的封裝器。 |
dtbtrs(ab,b,[uplo,trans,diag,overwrite_b])
|
針對 dtbtrs 的封裝器。 |
ctbtrs(ab,b,[uplo,trans,diag,overwrite_b])
|
針對 ctbtrs 的封裝器。 |
ztbtrs(ab,b,[uplo,trans,diag,overwrite_b])
|
針對 ztbtrs 的封裝器。 |
stfsm(...)
|
針對 stfsm 的封裝器。 |
dtfsm(...)
|
針對 dtfsm 的封裝器。 |
ctfsm(...)
|
針對 ctfsm 的封裝器。 |
ztfsm(...)
|
針對 ztfsm 的封裝器。 |
stfttp(n,arf,[transr,uplo])
|
針對 stfttp 的封裝器。 |
dtfttp(n,arf,[transr,uplo])
|
針對 dtfttp 的封裝器。 |
ctfttp(n,arf,[transr,uplo])
|
針對 ctfttp 的封裝器。 |
ztfttp(n,arf,[transr,uplo])
|
針對 ztfttp 的封裝器。 |
stfttr(n,arf,[transr,uplo])
|
針對 stfttr 的封裝器。 |
dtfttr(n,arf,[transr,uplo])
|
針對 dtfttr 的封裝器。 |
ctfttr(n,arf,[transr,uplo])
|
針對 ctfttr 的封裝器。 |
ztfttr(n,arf,[transr,uplo])
|
針對 ztfttr 的封裝器。 |
stgexc(...)
|
針對 stgexc 的封裝器。 |
dtgexc(...)
|
針對 dtgexc 的封裝器。 |
ctgexc(...)
|
針對 ctgexc 的封裝器。 |
ztgexc(...)
|
針對 ztgexc 的封裝器。 |
stgsen(...)
|
針對 stgsen 的封裝器。 |
dtgsen(...)
|
針對 dtgsen 的封裝器。 |
ctgsen(...)
|
針對 ctgsen 的封裝器。 |
ztgsen(...)
|
針對 ztgsen 的封裝器。 |
stgsen_lwork(select,a,[ijob])
|
針對 stgsen_lwork 的封裝器。 |
dtgsen_lwork(select,a,[ijob])
|
針對 dtgsen_lwork 的封裝器。 |
ctgsen_lwork(select,a,b,[ijob])
|
針對 ctgsen_lwork 的封裝器。 |
ztgsen_lwork(select,a,b,[ijob])
|
針對 ztgsen_lwork 的封裝器。 |
stgsyl(...)
|
針對 stgsyl 的封裝器。 |
dtgsyl(...)
|
針對 dtgsyl 的封裝器。 |
stpttf(n,ap,[transr,uplo])
|
針對 stpttf 的封裝器。 |
dtpttf(n,ap,[transr,uplo])
|
針對 dtpttf 的封裝器。 |
ctpttf(n,ap,[transr,uplo])
|
針對 ctpttf 的封裝器。 |
ztpttf(n,ap,[transr,uplo])
|
針對 ztpttf 的封裝器。 |
stpttr(n,ap,[uplo])
|
針對 stpttr 的封裝器。 |
dtpttr(n,ap,[uplo])
|
針對 dtpttr 的封裝器。 |
ctpttr(n,ap,[uplo])
|
針對 ctpttr 的封裝器。 |
ztpttr(n,ap,[uplo])
|
針對 ztpttr 的封裝器。 |
strcon(a,[norm,uplo,diag])
|
針對 strcon 的封裝器。 |
dtrcon(a,[norm,uplo,diag])
|
針對 dtrcon 的封裝器。 |
ctrcon(a,[norm,uplo,diag])
|
針對 ctrcon 的封裝器。 |
ztrcon(a,[norm,uplo,diag])
|
針對 ztrcon 的封裝器。 |
strexc(...)
|
針對 strexc 的封裝器。 |
dtrexc(...)
|
針對 dtrexc 的封裝器。 |
ctrexc(...)
|
針對 ctrexc 的封裝器。 |
ztrexc(...)
|
針對 ztrexc 的封裝器。 |
strsen(...)
|
針對 strsen 的封裝器。 |
dtrsen(...)
|
針對 dtrsen 的封裝器。 |
ctrsen(...)
|
針對 ctrsen 的封裝器。 |
ztrsen(...)
|
針對 ztrsen 的封裝器。 |
strsen_lwork(select,t,[job])
|
針對 strsen_lwork 的封裝器。 |
dtrsen_lwork(select,t,[job])
|
針對 dtrsen_lwork 的封裝器。 |
ctrsen_lwork(select,t,[job])
|
用於 ctrsen_lwork 的包裝函式。 |
ztrsen_lwork(select,t,[job])
|
用於 ztrsen_lwork 的包裝函式。 |
strsyl(a,b,c,[trana,tranb,isgn,overwrite_c])
|
用於 strsyl 的包裝函式。 |
dtrsyl(a,b,c,[trana,tranb,isgn,overwrite_c])
|
用於 dtrsyl 的包裝函式。 |
ctrsyl(a,b,c,[trana,tranb,isgn,overwrite_c])
|
用於 ctrsyl 的包裝函式。 |
ztrsyl(a,b,c,[trana,tranb,isgn,overwrite_c])
|
用於 ztrsyl 的包裝函式。 |
strtri(c,[lower,unitdiag,overwrite_c])
|
用於 strtri 的包裝函式。 |
dtrtri(c,[lower,unitdiag,overwrite_c])
|
用於 dtrtri 的包裝函式。 |
ctrtri(c,[lower,unitdiag,overwrite_c])
|
用於 ctrtri 的包裝函式。 |
ztrtri(c,[lower,unitdiag,overwrite_c])
|
用於 ztrtri 的包裝函式。 |
strtrs(...)
|
用於 strtrs 的包裝函式。 |
dtrtrs(...)
|
用於 dtrtrs 的包裝函式。 |
ctrtrs(...)
|
用於 ctrtrs 的包裝函式。 |
ztrtrs(...)
|
用於 ztrtrs 的包裝函式。 |
strttf(a,[transr,uplo])
|
用於 strttf 的包裝函式。 |
dtrttf(a,[transr,uplo])
|
用於 dtrttf 的包裝函式。 |
ctrttf(a,[transr,uplo])
|
用於 ctrttf 的包裝函式。 |
ztrttf(a,[transr,uplo])
|
用於 ztrttf 的包裝函式。 |
strttp(a,[uplo])
|
用於 strttp 的包裝函式。 |
dtrttp(a,[uplo])
|
用於 dtrttp 的包裝函式。 |
ctrttp(a,[uplo])
|
用於 ctrttp 的包裝函式。 |
ztrttp(a,[uplo])
|
用於 ztrttp 的包裝函式。 |
stzrzf(a,[lwork,overwrite_a])
|
用於 stzrzf 的包裝函式。 |
dtzrzf(a,[lwork,overwrite_a])
|
用於 dtzrzf 的包裝函式。 |
ctzrzf(a,[lwork,overwrite_a])
|
用於 ctzrzf 的包裝函式。 |
ztzrzf(a,[lwork,overwrite_a])
|
用於 ztzrzf 的包裝函式。 |
stzrzf_lwork(m, n)
|
用於 stzrzf_lwork 的包裝函式。 |
dtzrzf_lwork(m, n)
|
用於 dtzrzf_lwork 的包裝函式。 |
ctzrzf_lwork(m, n)
|
用於 ctzrzf_lwork 的包裝函式。 |
ztzrzf_lwork(m, n)
|
用於 ztzrzf_lwork 的包裝函式。 |
cunghr(a,tau,[lo,hi,lwork,overwrite_a])
|
用於 cunghr 的包裝函式。 |
zunghr(a,tau,[lo,hi,lwork,overwrite_a])
|
用於 zunghr 的包裝函式。 |
cunghr_lwork(n,[lo,hi])
|
用於 cunghr_lwork 的包裝函式。 |
zunghr_lwork(n,[lo,hi])
|
用於 zunghr_lwork 的包裝函式。 |
cungqr(a,tau,[lwork,overwrite_a])
|
用於 cungqr 的包裝函式。 |
zungqr(a,tau,[lwork,overwrite_a])
|
用於 zungqr 的包裝函式。 |
cungrq(a,tau,[lwork,overwrite_a])
|
用於 cungrq 的包裝函式。 |
zungrq(a,tau,[lwork,overwrite_a])
|
用於 zungrq 的包裝函式。 |
cunmqr(side,trans,a,tau,c,lwork,[overwrite_c])
|
用於 cunmqr 的包裝函式。 |
zunmqr(side,trans,a,tau,c,lwork,[overwrite_c])
|
用於 zunmqr 的包裝函式。 |
sgeqrt(nb,a,[overwrite_a])
|
用於 sgeqrt 的包裝函式。 |
dgeqrt(nb,a,[overwrite_a])
|
用於 dgeqrt 的包裝函式。 |
cgeqrt(nb,a,[overwrite_a])
|
用於 cgeqrt 的包裝函式。 |
zgeqrt(nb,a,[overwrite_a])
|
用於 zgeqrt 的包裝函式。 |
sgemqrt(v,t,c,[side,trans,overwrite_c])
|
用於 sgemqrt 的包裝函式。 |
dgemqrt(v,t,c,[side,trans,overwrite_c])
|
用於 dgemqrt 的包裝函式。 |
cgemqrt(v,t,c,[side,trans,overwrite_c])
|
用於 cgemqrt 的包裝函式。 |
zgemqrt(v,t,c,[side,trans,overwrite_c])
|
用於 zgemqrt 的包裝函式。 |
sgttrf(...)
|
用於 sgttrf 的包裝函式。 |
dgttrf(...)
|
用於 dgttrf 的包裝函式。 |
cgttrf(...)
|
用於 cgttrf 的包裝函式。 |
zgttrf(...)
|
用於 zgttrf 的包裝函式。 |
sgttrs(dl,d,du,du2,ipiv,b,[trans,overwrite_b])
|
用於 sgttrs 的包裝函式。 |
dgttrs(dl,d,du,du2,ipiv,b,[trans,overwrite_b])
|
用於 dgttrs 的包裝函式。 |
cgttrs(dl,d,du,du2,ipiv,b,[trans,overwrite_b])
|
用於 cgttrs 的包裝函式。 |
zgttrs(dl,d,du,du2,ipiv,b,[trans,overwrite_b])
|
用於 zgttrs 的包裝函式。 |
sgtcon(dl,d,du,du2,ipiv,anorm,[norm])
|
用於 sgtcon 的包裝函式。 |
dgtcon(dl,d,du,du2,ipiv,anorm,[norm])
|
用於 dgtcon 的包裝函式。 |
cgtcon(dl,d,du,du2,ipiv,anorm,[norm])
|
用於 cgtcon 的包裝函式。 |
zgtcon(dl,d,du,du2,ipiv,anorm,[norm])
|
用於 zgtcon 的包裝函式。 |
stpqrt(l,nb,a,b,[overwrite_a,overwrite_b])
|
用於 stpqrt 的包裝函式。 |
dtpqrt(l,nb,a,b,[overwrite_a,overwrite_b])
|
用於 dtpqrt 的包裝函式。 |
ctpqrt(l,nb,a,b,[overwrite_a,overwrite_b])
|
用於 ctpqrt 的包裝函式。 |
ztpqrt(l,nb,a,b,[overwrite_a,overwrite_b])
|
用於 ztpqrt 的包裝函式。 |
stpmqrt(...)
|
用於 stpmqrt 的包裝函式。 |
dtpmqrt(...)
|
用於 dtpmqrt 的包裝函式。 |
ctpmqrt(...)
|
用於 ctpmqrt 的包裝函式。 |
ztpmqrt(...)
|
用於 ztpmqrt 的包裝函式。 |
cuncsd(...)
|
用於 cuncsd 的包裝函式。 |
zuncsd(...)
|
用於 zuncsd 的包裝函式。 |
cuncsd_lwork(m, p, q)
|
用於 cuncsd_lwork 的包裝函式。 |
zuncsd_lwork(m, p, q)
|
用於 zuncsd_lwork 的包裝函式。 |
cunmrz(a,tau,c,[side,trans,lwork,overwrite_c])
|
用於 cunmrz 的包裝函式。 |
zunmrz(a,tau,c,[side,trans,lwork,overwrite_c])
|
用於 zunmrz 的包裝函式。 |
cunmrz_lwork(m,n,[side,trans])
|
用於 cunmrz_lwork 的包裝函式。 |
zunmrz_lwork(m,n,[side,trans])
|
用於 zunmrz_lwork 的包裝函式。 |
ilaver()
|
用於 ilaver 的包裝函式。 |
