A |
| a_str [Lacaml_utils] |
|
| ab_str [Lacaml_utils] |
|
| add [Lacaml_complex64] |
|
| add [Lacaml_complex32] |
|
| add [Lacaml_float64] |
|
| add [Lacaml_float32] |
|
| add [Lacaml_C.Vec] |
add ?n ?ofsz ?incz ?z ?ofsx ?incx x ?ofsy ?incy y adds n
elements of vectors x and y elementwise, using incx and incy
as incremental steps respectively.
|
| add [Lacaml_Z.Vec] |
add ?n ?ofsz ?incz ?z ?ofsx ?incx x ?ofsy ?incy y adds n
elements of vectors x and y elementwise, using incx and incy
as incremental steps respectively.
|
| add [Lacaml_S.Vec] |
add ?n ?ofsz ?incz ?z ?ofsx ?incx x ?ofsy ?incy y adds n
elements of vectors x and y elementwise, using incx and incy
as incremental steps respectively.
|
| add [Lacaml_D.Vec] |
add ?n ?ofsz ?incz ?z ?ofsx ?incx x ?ofsy ?incy y adds n
elements of vectors x and y elementwise, using incx and incy
as incremental steps respectively.
|
| add_const [Lacaml_C.Mat] |
add_const c ?m ?n ?br ?bc ?b ?ar ?ac a adds constant c to the
designated m by n submatrix in a and stores the result in the
designated submatrix in b.
|
| add_const [Lacaml_C.Vec] |
add_const c ?n ?ofsy ?incy ?y ?ofsx ?incx x adds constant c to the n
elements of vector x and stores the result in y, using incx and incy
as incremental steps respectively.
|
| add_const [Lacaml_Z.Mat] |
add_const c ?m ?n ?br ?bc ?b ?ar ?ac a adds constant c to the
designated m by n submatrix in a and stores the result in the
designated submatrix in b.
|
| add_const [Lacaml_Z.Vec] |
add_const c ?n ?ofsy ?incy ?y ?ofsx ?incx x adds constant c to the n
elements of vector x and stores the result in y, using incx and incy
as incremental steps respectively.
|
| add_const [Lacaml_S.Mat] |
add_const c ?m ?n ?br ?bc ?b ?ar ?ac a adds constant c to the
designated m by n submatrix in a and stores the result in the
designated submatrix in b.
|
| add_const [Lacaml_S.Vec] |
add_const c ?n ?ofsy ?incy ?y ?ofsx ?incx x adds constant c to the n
elements of vector x and stores the result in y, using incx and incy
as incremental steps respectively.
|
| add_const [Lacaml_D.Mat] |
add_const c ?m ?n ?br ?bc ?b ?ar ?ac a adds constant c to the
designated m by n submatrix in a and stores the result in the
designated submatrix in b.
|
| add_const [Lacaml_D.Vec] |
add_const c ?n ?ofsy ?incy ?y ?ofsx ?incx x adds constant c to the n
elements of vector x and stores the result in y, using incx and incy
as incremental steps respectively.
|
| alphas_str [Lacaml_utils] |
|
| amax [Lacaml_C] |
|
| amax [Lacaml_Z] |
|
| amax [Lacaml_S] |
|
| amax [Lacaml_D] |
|
| ap_str [Lacaml_utils] |
|
| append [Lacaml_C.Vec] |
|
| append [Lacaml_Z.Vec] |
|
| append [Lacaml_S.Vec] |
|
| append [Lacaml_D.Vec] |
|
| as_vec [Lacaml_C.Mat] |
|
| as_vec [Lacaml_Z.Mat] |
|
| as_vec [Lacaml_S.Mat] |
|
| as_vec [Lacaml_D.Mat] |
|
| asum [Lacaml_S] |
asum ?n ?ofsx ?incx x see BLAS documentation!
|
| asum [Lacaml_D] |
asum ?n ?ofsx ?incx x see BLAS documentation!
|
| axpy [Lacaml_C.Mat] |
axpy ?alpha ?m ?n ?xr ?xc x ?yr ?yc y BLAS axpy function for
matrices.
|
| axpy [Lacaml_C] |
axpy ?alpha ?n ?ofsx ?incx x ?ofsy ?incy y see BLAS documentation!
|
| axpy [Lacaml_Z.Mat] |
axpy ?alpha ?m ?n ?xr ?xc x ?yr ?yc y BLAS axpy function for
matrices.
|
| axpy [Lacaml_Z] |
axpy ?alpha ?n ?ofsx ?incx x ?ofsy ?incy y see BLAS documentation!
|
| axpy [Lacaml_S.Mat] |
axpy ?alpha ?m ?n ?xr ?xc x ?yr ?yc y BLAS axpy function for
matrices.
|
| axpy [Lacaml_S] |
axpy ?alpha ?n ?ofsx ?incx x ?ofsy ?incy y see BLAS documentation!
|
| axpy [Lacaml_D.Mat] |
axpy ?alpha ?m ?n ?xr ?xc x ?yr ?yc y BLAS axpy function for
matrices.
|
| axpy [Lacaml_D] |
axpy ?alpha ?n ?ofsx ?incx x ?ofsy ?incy y see BLAS documentation!
|
B |
| b_str [Lacaml_utils] |
|
| bc_str [Lacaml_utils] |
|
| br_str [Lacaml_utils] |
|
C |
| c_str [Lacaml_utils] |
|
| calc_unpacked_dim [Lacaml_utils] |
|
| check_dim1_mat [Lacaml_utils] |
|
| check_dim2_mat [Lacaml_utils] |
|
| check_dim_mat [Lacaml_utils] |
|
| check_mat_square [Lacaml_utils] |
|
| check_var_ltz [Lacaml_utils] |
|
| check_vec [Lacaml_utils] |
|
| col [Lacaml_C.Mat] |
|
| col [Lacaml_Z.Mat] |
|
| col [Lacaml_S.Mat] |
|
| col [Lacaml_D.Mat] |
|
| concat [Lacaml_C.Vec] |
|
| concat [Lacaml_Z.Vec] |
|
| concat [Lacaml_S.Vec] |
|
| concat [Lacaml_D.Vec] |
|
| copy [Lacaml_C] |
copy ?n ?ofsy ?incy ?y ?ofsx ?incx x see BLAS documentation!
|
| copy [Lacaml_Z] |
copy ?n ?ofsy ?incy ?y ?ofsx ?incx x see BLAS documentation!
|
| copy [Lacaml_S] |
copy ?n ?ofsy ?incy ?y ?ofsx ?incx x see BLAS documentation!
|
| copy [Lacaml_D] |
copy ?n ?ofsy ?incy ?y ?ofsx ?incx x see BLAS documentation!
|
| copy_diag [Lacaml_C.Mat] |
|
| copy_diag [Lacaml_Z.Mat] |
|
| copy_diag [Lacaml_S.Mat] |
|
| copy_diag [Lacaml_D.Mat] |
|
| copy_row [Lacaml_C.Mat] |
|
| copy_row [Lacaml_Z.Mat] |
|
| copy_row [Lacaml_S.Mat] |
|
| copy_row [Lacaml_D.Mat] |
|
| cos [Lacaml_S.Vec] |
cos ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the cosine of n elements
of the vector x using incx as incremental steps.
|
| cos [Lacaml_D.Vec] |
cos ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the cosine of n elements
of the vector x using incx as incremental steps.
|
| create [Lacaml_C.Mat] |
|
| create [Lacaml_C.Vec] |
|
| create [Lacaml_Z.Mat] |
|
| create [Lacaml_Z.Vec] |
|
| create [Lacaml_S.Mat] |
|
| create [Lacaml_S.Vec] |
|
| create [Lacaml_D.Mat] |
|
| create [Lacaml_D.Vec] |
|
| create [Lacaml_io.Context] |
|
| create_int32_vec [Lacaml_common] |
|
| create_int_vec [Lacaml_common] |
|
| create_mvec [Lacaml_C.Mat] |
|
| create_mvec [Lacaml_Z.Mat] |
|
| create_mvec [Lacaml_S.Mat] |
|
| create_mvec [Lacaml_D.Mat] |
|
D |
| d_str [Lacaml_utils] |
|
| detri [Lacaml_C.Mat] |
detri ?up ?n ?ar ?ac a takes a triangular (sub-)matrix a, i.e.
|
| detri [Lacaml_Z.Mat] |
detri ?up ?n ?ar ?ac a takes a triangular (sub-)matrix a, i.e.
|
| detri [Lacaml_S.Mat] |
detri ?up ?n ?ar ?ac a takes a triangular (sub-)matrix a, i.e.
|
| detri [Lacaml_D.Mat] |
detri ?up ?n ?ar ?ac a takes a triangular (sub-)matrix a, i.e.
|
| dim [Lacaml_C.Vec] |
|
| dim [Lacaml_Z.Vec] |
|
| dim [Lacaml_S.Vec] |
|
| dim [Lacaml_D.Vec] |
|
| dim1 [Lacaml_C.Mat] |
|
| dim1 [Lacaml_Z.Mat] |
|
| dim1 [Lacaml_S.Mat] |
|
| dim1 [Lacaml_D.Mat] |
|
| dim2 [Lacaml_C.Mat] |
|
| dim2 [Lacaml_Z.Mat] |
|
| dim2 [Lacaml_S.Mat] |
|
| dim2 [Lacaml_D.Mat] |
|
| div [Lacaml_C.Vec] |
div ?n ?ofsz ?incz ?z ?ofsx ?incx x ?ofsy ?incy y divides n
elements of vectors x and y elementwise, using incx and incy
as incremental steps respectively.
|
| div [Lacaml_Z.Vec] |
div ?n ?ofsz ?incz ?z ?ofsx ?incx x ?ofsy ?incy y divides n
elements of vectors x and y elementwise, using incx and incy
as incremental steps respectively.
|
| div [Lacaml_S.Vec] |
div ?n ?ofsz ?incz ?z ?ofsx ?incx x ?ofsy ?incy y divides n
elements of vectors x and y elementwise, using incx and incy
as incremental steps respectively.
|
| div [Lacaml_D.Vec] |
div ?n ?ofsz ?incz ?z ?ofsx ?incx x ?ofsy ?incy y divides n
elements of vectors x and y elementwise, using incx and incy
as incremental steps respectively.
|
| dl_str [Lacaml_utils] |
|
| dot [Lacaml_S] |
dot ?n ?ofsx ?incx x ?ofsy ?incy y see BLAS documentation!
|
| dot [Lacaml_D] |
dot ?n ?ofsx ?incx x ?ofsy ?incy y see BLAS documentation!
|
| dotc [Lacaml_C] |
dotc ?n ?ofsx ?incx x ?ofsy ?incy y see BLAS documentation!
|
| dotc [Lacaml_Z] |
dotc ?n ?ofsx ?incx x ?ofsy ?incy y see BLAS documentation!
|
| dotu [Lacaml_C] |
dotu ?n ?ofsx ?incx x ?ofsy ?incy y see BLAS documentation!
|
| dotu [Lacaml_Z] |
dotu ?n ?ofsx ?incx x ?ofsy ?incy y see BLAS documentation!
|
| du_str [Lacaml_utils] |
|
| dummy_select_fun [Lacaml_utils] |
|
E |
| e_str [Lacaml_utils] |
|
| ellipsis_default [Lacaml_io.Context] |
|
| empty [Lacaml_C.Mat] |
|
| empty [Lacaml_C.Vec] |
|
| empty [Lacaml_Z.Mat] |
|
| empty [Lacaml_Z.Vec] |
|
| empty [Lacaml_S.Mat] |
|
| empty [Lacaml_S.Vec] |
|
| empty [Lacaml_D.Mat] |
|
| empty [Lacaml_D.Vec] |
|
| empty_int32_vec [Lacaml_utils] |
|
| exp [Lacaml_S.Vec] |
exp ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the exponential
of n elements of the vector x using incx as incremental
steps.
|
| exp [Lacaml_D.Vec] |
exp ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the exponential
of n elements of the vector x using incx as incremental
steps.
|
F |
| fill [Lacaml_C.Mat] |
fill ?m ?n ?ar ?ac a x fills the specified sub-matrix in a with value
x.
|
| fill [Lacaml_C.Vec] |
fill ?n ?ofsx ?incx x a fills vector x with value a in the
designated range.
|
| fill [Lacaml_Z.Mat] |
fill ?m ?n ?ar ?ac a x fills the specified sub-matrix in a with value
x.
|
| fill [Lacaml_Z.Vec] |
fill ?n ?ofsx ?incx x a fills vector x with value a in the
designated range.
|
| fill [Lacaml_S.Mat] |
fill ?m ?n ?ar ?ac a x fills the specified sub-matrix in a with value
x.
|
| fill [Lacaml_S.Vec] |
fill ?n ?ofsx ?incx x a fills vector x with value a in the
designated range.
|
| fill [Lacaml_D.Mat] |
fill ?m ?n ?ar ?ac a x fills the specified sub-matrix in a with value
x.
|
| fill [Lacaml_D.Vec] |
fill ?n ?ofsx ?incx x a fills vector x with value a in the
designated range.
|
| fold [Lacaml_C.Vec] |
fold f a ?n ?ofsx ?incx x is
f (... (f (f a x.{ofsx}) x.{ofsx + incx}) ...) x.{ofsx + (n-1)*incx}
if incx > 0 and the same in the reverse order of appearance of the
x values if incx < 0.
|
| fold [Lacaml_Z.Vec] |
fold f a ?n ?ofsx ?incx x is
f (... (f (f a x.{ofsx}) x.{ofsx + incx}) ...) x.{ofsx + (n-1)*incx}
if incx > 0 and the same in the reverse order of appearance of the
x values if incx < 0.
|
| fold [Lacaml_S.Vec] |
fold f a ?n ?ofsx ?incx x is
f (... (f (f a x.{ofsx}) x.{ofsx + incx}) ...) x.{ofsx + (n-1)*incx}
if incx > 0 and the same in the reverse order of appearance of the
x values if incx < 0.
|
| fold [Lacaml_D.Vec] |
fold f a ?n ?ofsx ?incx x is
f (... (f (f a x.{ofsx}) x.{ofsx + incx}) ...) x.{ofsx + (n-1)*incx}
if incx > 0 and the same in the reverse order of appearance of the
x values if incx < 0.
|
| fold_cols [Lacaml_C.Mat] |
|
| fold_cols [Lacaml_Z.Mat] |
|
| fold_cols [Lacaml_S.Mat] |
|
| fold_cols [Lacaml_D.Mat] |
|
| from_col_vec [Lacaml_C.Mat] |
|
| from_col_vec [Lacaml_Z.Mat] |
|
| from_col_vec [Lacaml_S.Mat] |
|
| from_col_vec [Lacaml_D.Mat] |
|
| from_row_vec [Lacaml_C.Mat] |
|
| from_row_vec [Lacaml_Z.Mat] |
|
| from_row_vec [Lacaml_S.Mat] |
|
| from_row_vec [Lacaml_D.Mat] |
|
G |
| gXmv_get_params [Lacaml_utils] |
|
| gbmv [Lacaml_C] |
gbmv
?m ?n ?beta ?ofsy ?incy ?y ?trans ?alpha ?ar ?ac a kl ku ?ofsx ?incx x
see BLAS documentation!
|
| gbmv [Lacaml_Z] |
gbmv
?m ?n ?beta ?ofsy ?incy ?y ?trans ?alpha ?ar ?ac a kl ku ?ofsx ?incx x
see BLAS documentation!
|
| gbmv [Lacaml_S] |
gbmv
?m ?n ?beta ?ofsy ?incy ?y ?trans ?alpha ?ar ?ac a kl ku ?ofsx ?incx x
see BLAS documentation!
|
| gbmv [Lacaml_D] |
gbmv
?m ?n ?beta ?ofsy ?incy ?y ?trans ?alpha ?ar ?ac a kl ku ?ofsx ?incx x
see BLAS documentation!
|
| gbsv [Lacaml_C] |
gbsv ?n ?ipiv ?abr ?abc ab kl ku ?nrhs ?br ?bc b computes the
solution to a real system of linear equations a * X = b, where
a is a band matrix of order n with kl subdiagonals and ku
superdiagonals, and X and b are n-by-nrhs matrices.
|
| gbsv [Lacaml_Z] |
gbsv ?n ?ipiv ?abr ?abc ab kl ku ?nrhs ?br ?bc b computes the
solution to a real system of linear equations a * X = b, where
a is a band matrix of order n with kl subdiagonals and ku
superdiagonals, and X and b are n-by-nrhs matrices.
|
| gbsv [Lacaml_S] |
gbsv ?n ?ipiv ?abr ?abc ab kl ku ?nrhs ?br ?bc b computes the
solution to a real system of linear equations a * X = b, where
a is a band matrix of order n with kl subdiagonals and ku
superdiagonals, and X and b are n-by-nrhs matrices.
|
| gbsv [Lacaml_D] |
gbsv ?n ?ipiv ?abr ?abc ab kl ku ?nrhs ?br ?bc b computes the
solution to a real system of linear equations a * X = b, where
a is a band matrix of order n with kl subdiagonals and ku
superdiagonals, and X and b are n-by-nrhs matrices.
|
| geXrf_get_params [Lacaml_utils] |
|
| gecon [Lacaml_C] |
gecon ?n ?norm ?anorm ?work ?rwork ?ar ?ac a
|
| gecon [Lacaml_Z] |
gecon ?n ?norm ?anorm ?work ?rwork ?ar ?ac a
|
| gecon [Lacaml_S] |
gecon ?n ?norm ?anorm ?work ?rwork ?ar ?ac a
|
| gecon [Lacaml_D] |
gecon ?n ?norm ?anorm ?work ?rwork ?ar ?ac a
|
| gecon_err [Lacaml_utils] |
|
| gecon_min_liwork [Lacaml_S] |
|
| gecon_min_liwork [Lacaml_D] |
|
| gecon_min_lrwork [Lacaml_C] |
|
| gecon_min_lrwork [Lacaml_Z] |
|
| gecon_min_lwork [Lacaml_C] |
|
| gecon_min_lwork [Lacaml_Z] |
|
| gecon_min_lwork [Lacaml_S] |
|
| gecon_min_lwork [Lacaml_D] |
|
| gees [Lacaml_C] |
gees ?n ?jobvs ?sort ?w ?vsr ?vsc ?vs ?work ?ar ?ac a
See gees-function for details about arguments.
|
| gees [Lacaml_Z] |
gees ?n ?jobvs ?sort ?w ?vsr ?vsc ?vs ?work ?ar ?ac a
See gees-function for details about arguments.
|
| gees [Lacaml_S] |
gees ?n ?jobvs ?sort ?w ?vsr ?vsc ?vs ?work ?ar ?ac a
See gees-function for details about arguments.
|
| gees [Lacaml_D] |
gees ?n ?jobvs ?sort ?w ?vsr ?vsc ?vs ?work ?ar ?ac a
See gees-function for details about arguments.
|
| gees_err [Lacaml_utils] |
|
| gees_get_params_complex [Lacaml_utils] |
|
| gees_get_params_generic [Lacaml_utils] |
|
| gees_get_params_real [Lacaml_utils] |
|
| geev [Lacaml_C] |
geev ?work ?rwork ?n
?vlr ?vlc ?vl
?vrr ?vrc ?vr
?ofsw w
?ar ?ac a
|
| geev [Lacaml_Z] |
geev ?work ?rwork ?n
?vlr ?vlc ?vl
?vrr ?vrc ?vr
?ofsw w
?ar ?ac a
|
| geev [Lacaml_S] |
geev ?work ?n
?vlr ?vlc ?vl
?vrr ?vrc ?vr
?ofswr wr ?ofswi wi
?ar ?ac a
|
| geev [Lacaml_D] |
geev ?work ?n
?vlr ?vlc ?vl
?vrr ?vrc ?vr
?ofswr wr ?ofswi wi
?ar ?ac a
|
| geev_gen_get_params [Lacaml_utils] |
|
| geev_get_job_side [Lacaml_utils] |
|
| geev_min_lrwork [Lacaml_C] |
|
| geev_min_lrwork [Lacaml_Z] |
|
| geev_min_lwork [Lacaml_C] |
|
| geev_min_lwork [Lacaml_Z] |
|
| geev_min_lwork [Lacaml_S] |
|
| geev_min_lwork [Lacaml_D] |
|
| geev_opt_lwork [Lacaml_C] |
geev ?work ?rwork ?n ?vlr ?vlc ?vl ?vrr ?vrc ?vr ?ofsw w ?ar ?ac a
See geev-function for details about arguments.
|
| geev_opt_lwork [Lacaml_Z] |
geev ?work ?rwork ?n ?vlr ?vlc ?vl ?vrr ?vrc ?vr ?ofsw w ?ar ?ac a
See geev-function for details about arguments.
|
| geev_opt_lwork [Lacaml_S] |
geev_opt_lwork
?n
?vlr ?vlc ?vl
?vrr ?vrc ?vr
?ofswr wr
?ofswi wi
?ar ?ac a
See geev-function for details about arguments.
|
| geev_opt_lwork [Lacaml_D] |
geev_opt_lwork
?n
?vlr ?vlc ?vl
?vrr ?vrc ?vr
?ofswr wr
?ofswi wi
?ar ?ac a
See geev-function for details about arguments.
|
| gels [Lacaml_C] |
gels ?m ?n ?work ?trans ?ar ?ac a ?nrhs ?br ?bc b see
LAPACK documentation!
|
| gels [Lacaml_Z] |
gels ?m ?n ?work ?trans ?ar ?ac a ?nrhs ?br ?bc b see
LAPACK documentation!
|
| gels [Lacaml_S] |
gels ?m ?n ?work ?trans ?ar ?ac a ?nrhs ?br ?bc b see
LAPACK documentation!
|
| gels [Lacaml_D] |
gels ?m ?n ?work ?trans ?ar ?ac a ?nrhs ?br ?bc b see
LAPACK documentation!
|
| gelsX_err [Lacaml_utils] |
|
| gelsX_get_params [Lacaml_utils] |
|
| gelsX_get_s [Lacaml_utils] |
|
| gels_min_lwork [Lacaml_C] |
gels_min_lwork ~m ~n ~nrhs
|
| gels_min_lwork [Lacaml_Z] |
gels_min_lwork ~m ~n ~nrhs
|
| gels_min_lwork [Lacaml_S] |
gels_min_lwork ~m ~n ~nrhs
|
| gels_min_lwork [Lacaml_D] |
gels_min_lwork ~m ~n ~nrhs
|
| gels_opt_lwork [Lacaml_C] |
gels_opt_lwork ?m ?n ?trans ?ar ?ac a ?nrhs ?br ?bc b
|
| gels_opt_lwork [Lacaml_Z] |
gels_opt_lwork ?m ?n ?trans ?ar ?ac a ?nrhs ?br ?bc b
|
| gels_opt_lwork [Lacaml_S] |
gels_opt_lwork ?m ?n ?trans ?ar ?ac a ?nrhs ?br ?bc b
|
| gels_opt_lwork [Lacaml_D] |
gels_opt_lwork ?m ?n ?trans ?ar ?ac a ?nrhs ?br ?bc b
|
| gelsd [Lacaml_S] |
gelsd ?m ?n ?rcond ?ofss ?s ?ofswork ?work ?ar ?ac a ?nrhs b
see LAPACK documentation!
|
| gelsd [Lacaml_D] |
gelsd ?m ?n ?rcond ?ofss ?s ?ofswork ?work ?ar ?ac a ?nrhs b
see LAPACK documentation!
|
| gelsd_min_iwork [Lacaml_S] |
|
| gelsd_min_iwork [Lacaml_D] |
|
| gelsd_min_lwork [Lacaml_S] |
gelsd_min_lwork ~m ~n ~nrhs
|
| gelsd_min_lwork [Lacaml_D] |
gelsd_min_lwork ~m ~n ~nrhs
|
| gelsd_opt_lwork [Lacaml_S] |
gelsd_opt_lwork ?m ?n ?ar ?ac a ?nrhs b
|
| gelsd_opt_lwork [Lacaml_D] |
gelsd_opt_lwork ?m ?n ?ar ?ac a ?nrhs b
|
| gelss [Lacaml_S] |
gelss ?m ?n ?rcond ?ofss ?s ?ofswork ?work ?ar ?ac a ?nrhs ?br ?bc b
see LAPACK documentation!
|
| gelss [Lacaml_D] |
gelss ?m ?n ?rcond ?ofss ?s ?ofswork ?work ?ar ?ac a ?nrhs ?br ?bc b
see LAPACK documentation!
|
| gelss_min_lwork [Lacaml_S] |
gelss_min_lwork ~m ~n ~nrhs
|
| gelss_min_lwork [Lacaml_D] |
gelss_min_lwork ~m ~n ~nrhs
|
| gelss_opt_lwork [Lacaml_S] |
gelss_opt_lwork ?ar ?ac a ?m ?n ?nrhs ?br ?bc b
|
| gelss_opt_lwork [Lacaml_D] |
gelss_opt_lwork ?ar ?ac a ?m ?n ?nrhs ?br ?bc b
|
| gelsy [Lacaml_S] |
gelsy ?m ?n ?ar ?ac a ?rcond ?jpvt ?ofswork ?work ?nrhs b see LAPACK
documentation!
|
| gelsy [Lacaml_D] |
gelsy ?m ?n ?ar ?ac a ?rcond ?jpvt ?ofswork ?work ?nrhs b see LAPACK
documentation!
|
| gelsy_min_lwork [Lacaml_S] |
gelsy_min_lwork ~m ~n ~nrhs
|
| gelsy_min_lwork [Lacaml_D] |
gelsy_min_lwork ~m ~n ~nrhs
|
| gelsy_opt_lwork [Lacaml_S] |
gelsy_opt_lwork ?m ?n ?ar ?ac a ?nrhs ?br ?bc b
|
| gelsy_opt_lwork [Lacaml_D] |
gelsy_opt_lwork ?m ?n ?ar ?ac a ?nrhs ?br ?bc b
|
| gemm [Lacaml_C] |
gemm ?m ?n ?k ?beta ?cr ?cc ?c ?transa ?alpha ?ar ?ac a ?transb ?br ?bc b
see BLAS documentation!
|
| gemm [Lacaml_Z] |
gemm ?m ?n ?k ?beta ?cr ?cc ?c ?transa ?alpha ?ar ?ac a ?transb ?br ?bc b
see BLAS documentation!
|
| gemm [Lacaml_S] |
gemm ?m ?n ?k ?beta ?cr ?cc ?c ?transa ?alpha ?ar ?ac a ?transb ?br ?bc b
see BLAS documentation!
|
| gemm [Lacaml_D] |
gemm ?m ?n ?k ?beta ?cr ?cc ?c ?transa ?alpha ?ar ?ac a ?transb ?br ?bc b
see BLAS documentation!
|
| gemm_diag [Lacaml_C.Mat] |
gemm_diag ?n ?k ?beta ?ofsy ?y ?transa ?transb ?alpha ?ar ?ac a ?br ?bc b
computes the diagonal of the product of the (sub-)matrices a
and b (taking into account potential transposing), multiplying
it with alpha and adding beta times y, storing the result in
y starting at the specified offset.
|
| gemm_diag [Lacaml_Z.Mat] |
gemm_diag ?n ?k ?beta ?ofsy ?y ?transa ?transb ?alpha ?ar ?ac a ?br ?bc b
computes the diagonal of the product of the (sub-)matrices a
and b (taking into account potential transposing), multiplying
it with alpha and adding beta times y, storing the result in
y starting at the specified offset.
|
| gemm_diag [Lacaml_S.Mat] |
gemm_diag ?n ?k ?beta ?ofsy ?y ?transa ?transb ?alpha ?ar ?ac a ?br ?bc b
computes the diagonal of the product of the (sub-)matrices a
and b (taking into account potential transposing), multiplying
it with alpha and adding beta times y, storing the result in
y starting at the specified offset.
|
| gemm_diag [Lacaml_D.Mat] |
gemm_diag ?n ?k ?beta ?ofsy ?y ?transa ?transb ?alpha ?ar ?ac a ?br ?bc b
computes the diagonal of the product of the (sub-)matrices a
and b (taking into account potential transposing), multiplying
it with alpha and adding beta times y, storing the result in
y starting at the specified offset.
|
| gemm_get_params [Lacaml_utils] |
|
| gemm_trace [Lacaml_C.Mat] |
gemm_trace ?n ?k ?transa ?ar ?ac a ?transb ?br ?bc b computes
the trace of the product of the (sub-)matrices a and b (taking into
account potential transposing).
|
| gemm_trace [Lacaml_Z.Mat] |
gemm_trace ?n ?k ?transa ?ar ?ac a ?transb ?br ?bc b computes
the trace of the product of the (sub-)matrices a and b (taking into
account potential transposing).
|
| gemm_trace [Lacaml_S.Mat] |
gemm_trace ?n ?k ?transa ?ar ?ac a ?transb ?br ?bc b computes
the trace of the product of the (sub-)matrices a and b (taking into
account potential transposing).
|
| gemm_trace [Lacaml_D.Mat] |
gemm_trace ?n ?k ?transa ?ar ?ac a ?transb ?br ?bc b computes
the trace of the product of the (sub-)matrices a and b (taking into
account potential transposing).
|
| gemv [Lacaml_C] |
gemv ?m ?n ?beta ?ofsy ?incy ?y ?trans ?alpha ?ar ?ac a ?ofsx ?incx x
see BLAS documentation! BEWARE that the 1988 BLAS-2 specification
mandates that this function has no effect when n=0 while the
mathematically expected behabior is y ← beta * y.
|
| gemv [Lacaml_Z] |
gemv ?m ?n ?beta ?ofsy ?incy ?y ?trans ?alpha ?ar ?ac a ?ofsx ?incx x
see BLAS documentation! BEWARE that the 1988 BLAS-2 specification
mandates that this function has no effect when n=0 while the
mathematically expected behabior is y ← beta * y.
|
| gemv [Lacaml_S] |
gemv ?m ?n ?beta ?ofsy ?incy ?y ?trans ?alpha ?ar ?ac a ?ofsx ?incx x
see BLAS documentation! BEWARE that the 1988 BLAS-2 specification
mandates that this function has no effect when n=0 while the
mathematically expected behabior is y ← beta * y.
|
| gemv [Lacaml_D] |
gemv ?m ?n ?beta ?ofsy ?incy ?y ?trans ?alpha ?ar ?ac a ?ofsx ?incx x
see BLAS documentation! BEWARE that the 1988 BLAS-2 specification
mandates that this function has no effect when n=0 while the
mathematically expected behabior is y ← beta * y.
|
| geqrf [Lacaml_C] |
geqrf ?m ?n ?work ?tau ?ar ?ac a computes a QR factorization of
a real m-by-n matrix a.
|
| geqrf [Lacaml_Z] |
geqrf ?m ?n ?work ?tau ?ar ?ac a computes a QR factorization of
a real m-by-n matrix a.
|
| geqrf [Lacaml_S] |
geqrf ?m ?n ?work ?tau ?ar ?ac a computes a QR factorization of
a real m-by-n matrix a.
|
| geqrf [Lacaml_D] |
geqrf ?m ?n ?work ?tau ?ar ?ac a computes a QR factorization of
a real m-by-n matrix a.
|
| geqrf_min_lwork [Lacaml_C] |
|
| geqrf_min_lwork [Lacaml_Z] |
|
| geqrf_min_lwork [Lacaml_S] |
|
| geqrf_min_lwork [Lacaml_D] |
|
| geqrf_opt_lwork [Lacaml_C] |
geqrf_opt_lwork ?m ?n ?ar ?ac a
|
| geqrf_opt_lwork [Lacaml_Z] |
geqrf_opt_lwork ?m ?n ?ar ?ac a
|
| geqrf_opt_lwork [Lacaml_S] |
geqrf_opt_lwork ?m ?n ?ar ?ac a
|
| geqrf_opt_lwork [Lacaml_D] |
geqrf_opt_lwork ?m ?n ?ar ?ac a
|
| ger [Lacaml_S] |
ger ?m ?n ?alpha ?ofsx ?incx x ?ofsy ?incy y n ?ar ?ac a see
BLAS documentation!
|
| ger [Lacaml_D] |
ger ?m ?n ?alpha ?ofsx ?incx x ?ofsy ?incy y n ?ar ?ac a see
BLAS documentation!
|
| gesdd [Lacaml_S] |
|
| gesdd [Lacaml_D] |
|
| gesdd_err [Lacaml_utils] |
|
| gesdd_get_params [Lacaml_utils] |
|
| gesdd_liwork [Lacaml_S] |
|
| gesdd_liwork [Lacaml_D] |
|
| gesdd_min_lwork [Lacaml_S] |
gesdd_min_lwork ?jobz ~m ~n
|
| gesdd_min_lwork [Lacaml_D] |
gesdd_min_lwork ?jobz ~m ~n
|
| gesdd_opt_lwork [Lacaml_S] |
|
| gesdd_opt_lwork [Lacaml_D] |
|
| gesv [Lacaml_C] |
gesv ?n ?ipiv ?ar ?ac a ?nrhs ?br ?bc b computes the solution to
a real system of linear equations a * X = b, where a is an
n-by-n matrix and X and b are n-by-nrhs matrices.
|
| gesv [Lacaml_Z] |
gesv ?n ?ipiv ?ar ?ac a ?nrhs ?br ?bc b computes the solution to
a real system of linear equations a * X = b, where a is an
n-by-n matrix and X and b are n-by-nrhs matrices.
|
| gesv [Lacaml_S] |
gesv ?n ?ipiv ?ar ?ac a ?nrhs ?br ?bc b computes the solution to
a real system of linear equations a * X = b, where a is an
n-by-n matrix and X and b are n-by-nrhs matrices.
|
| gesv [Lacaml_D] |
gesv ?n ?ipiv ?ar ?ac a ?nrhs ?br ?bc b computes the solution to
a real system of linear equations a * X = b, where a is an
n-by-n matrix and X and b are n-by-nrhs matrices.
|
| gesvd [Lacaml_C] |
|
| gesvd [Lacaml_Z] |
|
| gesvd [Lacaml_S] |
|
| gesvd [Lacaml_D] |
|
| gesvd_err [Lacaml_utils] |
|
| gesvd_get_params [Lacaml_utils] |
|
| gesvd_lrwork [Lacaml_C] |
|
| gesvd_lrwork [Lacaml_Z] |
|
| gesvd_min_lwork [Lacaml_C] |
|
| gesvd_min_lwork [Lacaml_Z] |
|
| gesvd_min_lwork [Lacaml_S] |
|
| gesvd_min_lwork [Lacaml_D] |
|
| gesvd_opt_lwork [Lacaml_C] |
|
| gesvd_opt_lwork [Lacaml_Z] |
|
| gesvd_opt_lwork [Lacaml_S] |
|
| gesvd_opt_lwork [Lacaml_D] |
|
| get_c [Lacaml_utils] |
|
| get_cols_mat_tr [Lacaml_utils] |
|
| get_diag_char [Lacaml_utils] |
|
| get_dim1_mat [Lacaml_utils] |
|
| get_dim2_mat [Lacaml_utils] |
|
| get_dim_mat_packed [Lacaml_utils] |
|
| get_dim_vec [Lacaml_utils] |
|
| get_inc [Lacaml_utils] |
|
| get_inner_dim [Lacaml_utils] |
|
| get_job_char [Lacaml_utils] |
|
| get_k_mat_sb [Lacaml_utils] |
|
| get_mat [Lacaml_utils] |
|
| get_n_of_a [Lacaml_utils] |
|
| get_n_of_square [Lacaml_utils] |
|
| get_norm_char [Lacaml_utils] |
|
| get_nrhs_of_b [Lacaml_utils] |
|
| get_ofs [Lacaml_utils] |
|
| get_rows_mat_tr [Lacaml_utils] |
|
| get_s_d_job_char [Lacaml_utils] |
|
| get_side_char [Lacaml_utils] |
|
| get_trans_char [Lacaml_utils] |
|
| get_unpacked_dim [Lacaml_utils] |
|
| get_uplo_char [Lacaml_utils] |
|
| get_vec [Lacaml_utils] |
|
| get_vec_geom [Lacaml_utils] |
|
| get_work [Lacaml_utils] |
|
| getrf [Lacaml_C] |
getrf ?m ?n ?ipiv ?ar ?ac a computes an LU factorization of a
general m-by-n matrix a using partial pivoting with row
interchanges.
|
| getrf [Lacaml_Z] |
getrf ?m ?n ?ipiv ?ar ?ac a computes an LU factorization of a
general m-by-n matrix a using partial pivoting with row
interchanges.
|
| getrf [Lacaml_S] |
getrf ?m ?n ?ipiv ?ar ?ac a computes an LU factorization of a
general m-by-n matrix a using partial pivoting with row
interchanges.
|
| getrf [Lacaml_D] |
getrf ?m ?n ?ipiv ?ar ?ac a computes an LU factorization of a
general m-by-n matrix a using partial pivoting with row
interchanges.
|
| getrf_err [Lacaml_utils] |
|
| getrf_get_ipiv [Lacaml_utils] |
|
| getrf_lu_err [Lacaml_utils] |
|
| getri [Lacaml_C] |
getri ?n ?ipiv ?work ?ar ?ac a computes the inverse of a matrix
using the LU factorization computed by Lacaml_C.getrf.
|
| getri [Lacaml_Z] |
getri ?n ?ipiv ?work ?ar ?ac a computes the inverse of a matrix
using the LU factorization computed by Lacaml_Z.getrf.
|
| getri [Lacaml_S] |
getri ?n ?ipiv ?work ?ar ?ac a computes the inverse of a matrix
using the LU factorization computed by Lacaml_S.getrf.
|
| getri [Lacaml_D] |
getri ?n ?ipiv ?work ?ar ?ac a computes the inverse of a matrix
using the LU factorization computed by Lacaml_D.getrf.
|
| getri_err [Lacaml_utils] |
|
| getri_min_lwork [Lacaml_C] |
|
| getri_min_lwork [Lacaml_Z] |
|
| getri_min_lwork [Lacaml_S] |
|
| getri_min_lwork [Lacaml_D] |
|
| getri_opt_lwork [Lacaml_C] |
getri_opt_lwork ?n ?ar ?ac a
|
| getri_opt_lwork [Lacaml_Z] |
getri_opt_lwork ?n ?ar ?ac a
|
| getri_opt_lwork [Lacaml_S] |
getri_opt_lwork ?n ?ar ?ac a
|
| getri_opt_lwork [Lacaml_D] |
getri_opt_lwork ?n ?ar ?ac a
|
| getrs [Lacaml_C] |
getrs ?n ?ipiv ?trans ?ar ?ac a ?nrhs ?br ?bc b solves a system
of linear equations a * X = b or a' * X = b with a general
n-by-n matrix a using the LU factorization computed by
Lacaml_C.getrf.
|
| getrs [Lacaml_Z] |
getrs ?n ?ipiv ?trans ?ar ?ac a ?nrhs ?br ?bc b solves a system
of linear equations a * X = b or a' * X = b with a general
n-by-n matrix a using the LU factorization computed by
Lacaml_Z.getrf.
|
| getrs [Lacaml_S] |
getrs ?n ?ipiv ?trans ?ar ?ac a ?nrhs ?br ?bc b solves a system
of linear equations a * X = b or a' * X = b with a general
n-by-n matrix a using the LU factorization computed by
Lacaml_S.getrf.
|
| getrs [Lacaml_D] |
getrs ?n ?ipiv ?trans ?ar ?ac a ?nrhs ?br ?bc b solves a system
of linear equations a * X = b or a' * X = b with a general
n-by-n matrix a using the LU factorization computed by
Lacaml_D.getrf.
|
| gtsv [Lacaml_C] |
gtsv ?n ?ofsdl dl ?ofsd d ?ofsdu du ?nrhs ?br ?bc b solves the
equation a * X = b where a is an n-by-n tridiagonal
matrix, by Gaussian elimination with partial pivoting.
|
| gtsv [Lacaml_Z] |
gtsv ?n ?ofsdl dl ?ofsd d ?ofsdu du ?nrhs ?br ?bc b solves the
equation a * X = b where a is an n-by-n tridiagonal
matrix, by Gaussian elimination with partial pivoting.
|
| gtsv [Lacaml_S] |
gtsv ?n ?ofsdl dl ?ofsd d ?ofsdu du ?nrhs ?br ?bc b solves the
equation a * X = b where a is an n-by-n tridiagonal
matrix, by Gaussian elimination with partial pivoting.
|
| gtsv [Lacaml_D] |
gtsv ?n ?ofsdl dl ?ofsd d ?ofsdu du ?nrhs ?br ?bc b solves the
equation a * X = b where a is an n-by-n tridiagonal
matrix, by Gaussian elimination with partial pivoting.
|
H |
| hankel [Lacaml_S.Mat] |
|
| hankel [Lacaml_D.Mat] |
|
| hilbert [Lacaml_S.Mat] |
|
| hilbert [Lacaml_D.Mat] |
|
| horizontal_default [Lacaml_io.Context] |
|
I |
| iamax [Lacaml_C] |
iamax ?n ?ofsx ?incx x see BLAS documentation!
|
| iamax [Lacaml_Z] |
iamax ?n ?ofsx ?incx x see BLAS documentation!
|
| iamax [Lacaml_S] |
iamax ?n ?ofsx ?incx x see BLAS documentation!
|
| iamax [Lacaml_D] |
iamax ?n ?ofsx ?incx x see BLAS documentation!
|
| identity [Lacaml_C.Mat] |
|
| identity [Lacaml_Z.Mat] |
|
| identity [Lacaml_S.Mat] |
|
| identity [Lacaml_D.Mat] |
|
| ilaenv [Lacaml_utils] |
|
| init [Lacaml_C.Vec] |
|
| init [Lacaml_Z.Vec] |
|
| init [Lacaml_S.Vec] |
|
| init [Lacaml_D.Vec] |
|
| init_cols [Lacaml_C.Mat] |
|
| init_cols [Lacaml_Z.Mat] |
|
| init_cols [Lacaml_S.Mat] |
|
| init_cols [Lacaml_D.Mat] |
|
| init_rows [Lacaml_C.Mat] |
|
| init_rows [Lacaml_Z.Mat] |
|
| init_rows [Lacaml_S.Mat] |
|
| init_rows [Lacaml_D.Mat] |
|
| int_of_complex32 [Lacaml_complex32] |
|
| int_of_complex64 [Lacaml_complex64] |
|
| int_of_float32 [Lacaml_float32] |
|
| int_of_float64 [Lacaml_float64] |
|
| ipiv_str [Lacaml_utils] |
|
| iseed_str [Lacaml_utils] |
|
| iter [Lacaml_C.Vec] |
iter ?n ?ofsx ?incx f x applies function f in turn to all elements
of vector x.
|
| iter [Lacaml_Z.Vec] |
iter ?n ?ofsx ?incx f x applies function f in turn to all elements
of vector x.
|
| iter [Lacaml_S.Vec] |
iter ?n ?ofsx ?incx f x applies function f in turn to all elements
of vector x.
|
| iter [Lacaml_D.Vec] |
iter ?n ?ofsx ?incx f x applies function f in turn to all elements
of vector x.
|
| iteri [Lacaml_C.Vec] |
iteri ?n ?ofsx ?incx f x same as iter but additionally passes
the index of the element as first argument and the element itself
as second argument.
|
| iteri [Lacaml_Z.Vec] |
iteri ?n ?ofsx ?incx f x same as iter but additionally passes
the index of the element as first argument and the element itself
as second argument.
|
| iteri [Lacaml_S.Vec] |
iteri ?n ?ofsx ?incx f x same as iter but additionally passes
the index of the element as first argument and the element itself
as second argument.
|
| iteri [Lacaml_D.Vec] |
iteri ?n ?ofsx ?incx f x same as iter but additionally passes
the index of the element as first argument and the element itself
as second argument.
|
J |
| job_char_false [Lacaml_utils] |
|
| job_char_true [Lacaml_utils] |
|
K |
| k_str [Lacaml_utils] |
|
| ka_str [Lacaml_utils] |
|
| kb_str [Lacaml_utils] |
|
| kd_str [Lacaml_utils] |
|
| kl_str [Lacaml_utils] |
|
| ku_str [Lacaml_utils] |
|
L |
| lacpy [Lacaml_C] |
lacpy ?uplo ?m ?n ?br ?bc ?b ?ar ?ac a copy a (triangular)
(sub-)matrix a (to an optional (sub-)matrix b).
|
| lacpy [Lacaml_Z] |
lacpy ?uplo ?m ?n ?br ?bc ?b ?ar ?ac a copy a (triangular)
(sub-)matrix a (to an optional (sub-)matrix b).
|
| lacpy [Lacaml_S] |
lacpy ?uplo ?m ?n ?br ?bc ?b ?ar ?ac a copy a (triangular)
(sub-)matrix a (to an optional (sub-)matrix b).
|
| lacpy [Lacaml_D] |
lacpy ?uplo ?m ?n ?br ?bc ?b ?ar ?ac a copy a (triangular)
(sub-)matrix a (to an optional (sub-)matrix b).
|
| lamch [Lacaml_S] |
lamch cmach see LAPACK documentation!
|
| lamch [Lacaml_D] |
lamch cmach see LAPACK documentation!
|
| lange [Lacaml_C] |
lange ?m ?n ?norm ?work ?ar ?ac a
|
| lange [Lacaml_Z] |
lange ?m ?n ?norm ?work ?ar ?ac a
|
| lange [Lacaml_S] |
lange ?m ?n ?norm ?work ?ar ?ac a
|
| lange [Lacaml_D] |
lange ?m ?n ?norm ?work ?ar ?ac a
|
| lange_min_lwork [Lacaml_C] |
|
| lange_min_lwork [Lacaml_Z] |
|
| lange_min_lwork [Lacaml_S] |
|
| lange_min_lwork [Lacaml_D] |
|
| lansy [Lacaml_C] |
lansy ?n ?up ?norm ?work ?ar ?ac a see LAPACK documentation!
|
| lansy [Lacaml_Z] |
lansy ?n ?up ?norm ?work ?ar ?ac a see LAPACK documentation!
|
| lansy [Lacaml_S] |
lansy ?norm ?up ?n ?ar ?ac ?work a see LAPACK documentation!
|
| lansy [Lacaml_D] |
lansy ?norm ?up ?n ?ar ?ac ?work a see LAPACK documentation!
|
| lansy_min_lwork [Lacaml_C] |
|
| lansy_min_lwork [Lacaml_Z] |
|
| lansy_min_lwork [Lacaml_S] |
|
| lansy_min_lwork [Lacaml_D] |
|
| larnv [Lacaml_C] |
larnv ?idist ?iseed ?n ?ofsx ?x ()
|
| larnv [Lacaml_Z] |
larnv ?idist ?iseed ?n ?ofsx ?x ()
|
| larnv [Lacaml_S] |
larnv ?idist ?iseed ?n ?ofsx ?x ()
|
| larnv [Lacaml_D] |
larnv ?idist ?iseed ?n ?ofsx ?x ()
|
| lassq [Lacaml_C] |
lassq ?n ?ofsx ?incx ?scale ?sumsq
|
| lassq [Lacaml_Z] |
lassq ?n ?ofsx ?incx ?scale ?sumsq
|
| lassq [Lacaml_S] |
lassq ?n ?ofsx ?incx ?scale ?sumsq
|
| lassq [Lacaml_D] |
lassq ?n ?ofsx ?incx ?scale ?sumsq
|
| lauum [Lacaml_C] |
lauum ?up ?n ?ar ?ac a computes the product U * U**T or L**T * L,
where the triangular factor U or L is stored in the upper or lower
triangular part of the array a.
|
| lauum [Lacaml_Z] |
lauum ?up ?n ?ar ?ac a computes the product U * U**T or L**T * L,
where the triangular factor U or L is stored in the upper or lower
triangular part of the array a.
|
| lauum [Lacaml_S] |
lauum ?up ?n ?ar ?ac a computes the product U * U**T or L**T * L,
where the triangular factor U or L is stored in the upper or lower
triangular part of the array a.
|
| lauum [Lacaml_D] |
lauum ?up ?n ?ar ?ac a computes the product U * U**T or L**T * L,
where the triangular factor U or L is stored in the upper or lower
triangular part of the array a.
|
| linspace [Lacaml_C.Vec] |
|
| linspace [Lacaml_Z.Vec] |
|
| linspace [Lacaml_S.Vec] |
|
| linspace [Lacaml_D.Vec] |
|
| liwork_str [Lacaml_utils] |
|
| log [Lacaml_S.Vec] |
log ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the logarithm
of n elements of the vector x using incx as incremental
steps.
|
| log [Lacaml_D.Vec] |
log ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the logarithm
of n elements of the vector x using incx as incremental
steps.
|
| logspace [Lacaml_C.Vec] |
|
| logspace [Lacaml_Z.Vec] |
|
| logspace [Lacaml_S.Vec] |
|
| logspace [Lacaml_D.Vec] |
|
| lsc [Lacaml_io.Toplevel] |
|
| lwork_str [Lacaml_utils] |
|
M |
| m_str [Lacaml_utils] |
|
| make [Lacaml_C.Mat] |
|
| make [Lacaml_C.Vec] |
|
| make [Lacaml_Z.Mat] |
|
| make [Lacaml_Z.Vec] |
|
| make [Lacaml_S.Mat] |
|
| make [Lacaml_S.Vec] |
|
| make [Lacaml_D.Mat] |
|
| make [Lacaml_D.Vec] |
|
| make0 [Lacaml_C.Mat] |
|
| make0 [Lacaml_C.Vec] |
|
| make0 [Lacaml_Z.Mat] |
|
| make0 [Lacaml_Z.Vec] |
|
| make0 [Lacaml_S.Mat] |
|
| make0 [Lacaml_S.Vec] |
|
| make0 [Lacaml_D.Mat] |
|
| make0 [Lacaml_D.Vec] |
|
| make_mvec [Lacaml_C.Mat] |
|
| make_mvec [Lacaml_Z.Mat] |
|
| make_mvec [Lacaml_S.Mat] |
|
| make_mvec [Lacaml_D.Mat] |
|
| map [Lacaml_C.Mat] |
map f ?m ?n ?br ?bc ?b ?ar ?ac a
|
| map [Lacaml_C.Vec] |
|
| map [Lacaml_Z.Mat] |
map f ?m ?n ?br ?bc ?b ?ar ?ac a
|
| map [Lacaml_Z.Vec] |
|
| map [Lacaml_S.Mat] |
map f ?m ?n ?br ?bc ?b ?ar ?ac a
|
| map [Lacaml_S.Vec] |
|
| map [Lacaml_D.Mat] |
map f ?m ?n ?br ?bc ?b ?ar ?ac a
|
| map [Lacaml_D.Vec] |
|
| mat_from_vec [Lacaml_common] |
mat_from_vec a converts the vector a into a matrix with Array1.dim a
rows and 1 column.
|
| max [Lacaml_C.Vec] |
max ?n ?ofsx ?incx x computes the greater of the n elements
in vector x (2-norm), separated by incx incremental steps.
|
| max [Lacaml_Z.Vec] |
max ?n ?ofsx ?incx x computes the greater of the n elements
in vector x (2-norm), separated by incx incremental steps.
|
| max [Lacaml_S.Vec] |
max ?n ?ofsx ?incx x computes the greater of the n elements
in vector x (2-norm), separated by incx incremental steps.
|
| max [Lacaml_D.Vec] |
max ?n ?ofsx ?incx x computes the greater of the n elements
in vector x (2-norm), separated by incx incremental steps.
|
| min [Lacaml_C.Vec] |
min ?n ?ofsx ?incx x computes the smaller of the n elements
in vector x (2-norm), separated by incx incremental steps.
|
| min [Lacaml_Z.Vec] |
min ?n ?ofsx ?incx x computes the smaller of the n elements
in vector x (2-norm), separated by incx incremental steps.
|
| min [Lacaml_S.Vec] |
min ?n ?ofsx ?incx x computes the smaller of the n elements
in vector x (2-norm), separated by incx incremental steps.
|
| min [Lacaml_D.Vec] |
min ?n ?ofsx ?incx x computes the smaller of the n elements
in vector x (2-norm), separated by incx incremental steps.
|
| mul [Lacaml_C.Vec] |
mul ?n ?ofsz ?incz ?z ?ofsx ?incx x ?ofsy ?incy y multiplies
n elements of vectors x and y elementwise, using incx
and incy as incremental steps respectively.
|
| mul [Lacaml_Z.Vec] |
mul ?n ?ofsz ?incz ?z ?ofsx ?incx x ?ofsy ?incy y multiplies
n elements of vectors x and y elementwise, using incx
and incy as incremental steps respectively.
|
| mul [Lacaml_S.Vec] |
mul ?n ?ofsz ?incz ?z ?ofsx ?incx x ?ofsy ?incy y multiplies
n elements of vectors x and y elementwise, using incx
and incy as incremental steps respectively.
|
| mul [Lacaml_D.Vec] |
mul ?n ?ofsz ?incz ?z ?ofsx ?incx x ?ofsy ?incy y multiplies
n elements of vectors x and y elementwise, using incx
and incy as incremental steps respectively.
|
| mvec_of_array [Lacaml_C.Mat] |
|
| mvec_of_array [Lacaml_Z.Mat] |
|
| mvec_of_array [Lacaml_S.Mat] |
|
| mvec_of_array [Lacaml_D.Mat] |
|
| mvec_to_array [Lacaml_C.Mat] |
|
| mvec_to_array [Lacaml_Z.Mat] |
|
| mvec_to_array [Lacaml_S.Mat] |
|
| mvec_to_array [Lacaml_D.Mat] |
|
N |
| n_str [Lacaml_utils] |
|
| neg [Lacaml_C.Vec] |
neg ?n ?ofsy ?incy ?y ?ofsx ?incx x negates n elements of the
vector x using incx as incremental steps.
|
| neg [Lacaml_Z.Vec] |
neg ?n ?ofsy ?incy ?y ?ofsx ?incx x negates n elements of the
vector x using incx as incremental steps.
|
| neg [Lacaml_S.Vec] |
neg ?n ?ofsy ?incy ?y ?ofsx ?incx x negates n elements of the
vector x using incx as incremental steps.
|
| neg [Lacaml_D.Vec] |
neg ?n ?ofsy ?incy ?y ?ofsx ?incx x negates n elements of the
vector x using incx as incremental steps.
|
| nrhs_str [Lacaml_utils] |
|
| nrm2 [Lacaml_C] |
nrm2 ?n ?ofsx ?incx x see BLAS documentation!
|
| nrm2 [Lacaml_Z] |
nrm2 ?n ?ofsx ?incx x see BLAS documentation!
|
| nrm2 [Lacaml_S] |
nrm2 ?n ?ofsx ?incx x see BLAS documentation!
|
| nrm2 [Lacaml_D] |
nrm2 ?n ?ofsx ?incx x see BLAS documentation!
|
O |
| of_array [Lacaml_C.Mat] |
|
| of_array [Lacaml_C.Vec] |
|
| of_array [Lacaml_Z.Mat] |
|
| of_array [Lacaml_Z.Vec] |
|
| of_array [Lacaml_S.Mat] |
|
| of_array [Lacaml_S.Vec] |
|
| of_array [Lacaml_D.Mat] |
|
| of_array [Lacaml_D.Vec] |
|
| of_col_vecs [Lacaml_C.Mat] |
|
| of_col_vecs [Lacaml_Z.Mat] |
|
| of_col_vecs [Lacaml_S.Mat] |
|
| of_col_vecs [Lacaml_D.Mat] |
|
| of_diag [Lacaml_C.Mat] |
|
| of_diag [Lacaml_Z.Mat] |
|
| of_diag [Lacaml_S.Mat] |
|
| of_diag [Lacaml_D.Mat] |
|
| of_list [Lacaml_C.Vec] |
|
| of_list [Lacaml_Z.Vec] |
|
| of_list [Lacaml_S.Vec] |
|
| of_list [Lacaml_D.Vec] |
|
| one [Lacaml_complex64] |
|
| one [Lacaml_complex32] |
|
| one [Lacaml_float64] |
|
| one [Lacaml_float32] |
|
| orgqr [Lacaml_S] |
orgqr ?m ?n ?k ?work ~tau ?ar ?ac a see LAPACK documentation!
|
| orgqr [Lacaml_D] |
orgqr ?m ?n ?k ?work ~tau ?ar ?ac a see LAPACK documentation!
|
| orgqr_err [Lacaml_utils] |
|
| orgqr_get_params [Lacaml_utils] |
|
| orgqr_min_lwork [Lacaml_S] |
|
| orgqr_min_lwork [Lacaml_D] |
|
| orgqr_opt_lwork [Lacaml_S] |
orgqr_opt_lwork ?m ?n ?k ~tau ?ar ?ac a
|
| orgqr_opt_lwork [Lacaml_D] |
orgqr_opt_lwork ?m ?n ?k ~tau ?ar ?ac a
|
| ormqr [Lacaml_S] |
ormqr ?side ?trans ?m ?n ?k ?work ~tau ?ar ?ac a ?cr ?cc c
see LAPACK documentation!
|
| ormqr [Lacaml_D] |
ormqr ?side ?trans ?m ?n ?k ?work ~tau ?ar ?ac a ?cr ?cc c
see LAPACK documentation!
|
| ormqr_err [Lacaml_utils] |
|
| ormqr_get_params [Lacaml_utils] |
|
| ormqr_opt_lwork [Lacaml_S] |
ormqr_opt_lwork ?side ?trans ?m ?n ?k ~tau ?ar ?ac a ?cr ?cc c
|
| ormqr_opt_lwork [Lacaml_D] |
ormqr_opt_lwork ?side ?trans ?m ?n ?k ~tau ?ar ?ac a ?cr ?cc c
|
P |
| packed [Lacaml_C.Mat] |
|
| packed [Lacaml_Z.Mat] |
|
| packed [Lacaml_S.Mat] |
|
| packed [Lacaml_D.Mat] |
|
| pascal [Lacaml_S.Mat] |
|
| pascal [Lacaml_D.Mat] |
|
| pbsv [Lacaml_C] |
pbsv ?n ?up ?kd ?abr ?abc ab ?nrhs ?br ?bc b computes the
solution to a real system of linear equations a * X = b, where
a is an n-by-n symmetric positive definite band matrix and X
and b are n-by-nrhs matrices.
|
| pbsv [Lacaml_Z] |
pbsv ?n ?up ?kd ?abr ?abc ab ?nrhs ?br ?bc b computes the
solution to a real system of linear equations a * X = b, where
a is an n-by-n symmetric positive definite band matrix and X
and b are n-by-nrhs matrices.
|
| pbsv [Lacaml_S] |
pbsv ?n ?up ?kd ?abr ?abc ab ?nrhs ?br ?bc b computes the
solution to a real system of linear equations a * X = b, where
a is an n-by-n symmetric positive definite band matrix and X
and b are n-by-nrhs matrices.
|
| pbsv [Lacaml_D] |
pbsv ?n ?up ?kd ?abr ?abc ab ?nrhs ?br ?bc b computes the
solution to a real system of linear equations a * X = b, where
a is an n-by-n symmetric positive definite band matrix and X
and b are n-by-nrhs matrices.
|
| pocon [Lacaml_C] |
pocon ?n ?up ?anorm ?work ?rwork ?ar ?ac a
|
| pocon [Lacaml_Z] |
pocon ?n ?up ?anorm ?work ?rwork ?ar ?ac a
|
| pocon [Lacaml_S] |
pocon ?n ?up ?anorm ?work ?iwork ?ar ?ac a
|
| pocon [Lacaml_D] |
pocon ?n ?up ?anorm ?work ?iwork ?ar ?ac a
|
| pocon_min_liwork [Lacaml_S] |
|
| pocon_min_liwork [Lacaml_D] |
|
| pocon_min_lrwork [Lacaml_C] |
|
| pocon_min_lrwork [Lacaml_Z] |
|
| pocon_min_lwork [Lacaml_C] |
|
| pocon_min_lwork [Lacaml_Z] |
|
| pocon_min_lwork [Lacaml_S] |
|
| pocon_min_lwork [Lacaml_D] |
|
| posv [Lacaml_C] |
posv ?n ?up ?ar ?ac a ?nrhs ?br ?bc b computes the solution to a
real system of linear equations a * X = b, where a is an
n-by-n symmetric positive definite matrix and X and b are
n-by-nrhs matrices.
|
| posv [Lacaml_Z] |
posv ?n ?up ?ar ?ac a ?nrhs ?br ?bc b computes the solution to a
real system of linear equations a * X = b, where a is an
n-by-n symmetric positive definite matrix and X and b are
n-by-nrhs matrices.
|
| posv [Lacaml_S] |
posv ?n ?up ?ar ?ac a ?nrhs ?br ?bc b computes the solution to a
real system of linear equations a * X = b, where a is an
n-by-n symmetric positive definite matrix and X and b are
n-by-nrhs matrices.
|
| posv [Lacaml_D] |
posv ?n ?up ?ar ?ac a ?nrhs ?br ?bc b computes the solution to a
real system of linear equations a * X = b, where a is an
n-by-n symmetric positive definite matrix and X and b are
n-by-nrhs matrices.
|
| potrf [Lacaml_C] |
potrf ?n ?up ?ar ?ac ?jitter a factorizes symmetric positive
definite matrix a (or the designated submatrix) using Cholesky
factorization.
|
| potrf [Lacaml_Z] |
potrf ?n ?up ?ar ?ac ?jitter a factorizes symmetric positive
definite matrix a (or the designated submatrix) using Cholesky
factorization.
|
| potrf [Lacaml_S] |
potrf ?n ?up ?ar ?ac ?jitter a factorizes symmetric positive
definite matrix a (or the designated submatrix) using Cholesky
factorization.
|
| potrf [Lacaml_D] |
potrf ?n ?up ?ar ?ac ?jitter a factorizes symmetric positive
definite matrix a (or the designated submatrix) using Cholesky
factorization.
|
| potrf_chol_err [Lacaml_utils] |
|
| potrf_err [Lacaml_utils] |
|
| potri [Lacaml_C] |
potri ?n ?up ?ar ?ac ?factorize ?jitter a computes the inverse
of the real symmetric positive definite matrix a using the
Cholesky factorization a = U**T*U or a = L*L**T computed by
Lacaml_C.potrf.
|
| potri [Lacaml_Z] |
potri ?n ?up ?ar ?ac ?factorize ?jitter a computes the inverse
of the real symmetric positive definite matrix a using the
Cholesky factorization a = U**T*U or a = L*L**T computed by
Lacaml_Z.potrf.
|
| potri [Lacaml_S] |
potri ?n ?up ?ar ?ac ?factorize ?jitter a computes the inverse
of the real symmetric positive definite matrix a using the
Cholesky factorization a = U**T*U or a = L*L**T computed by
Lacaml_S.potrf.
|
| potri [Lacaml_D] |
potri ?n ?up ?ar ?ac ?factorize ?jitter a computes the inverse
of the real symmetric positive definite matrix a using the
Cholesky factorization a = U**T*U or a = L*L**T computed by
Lacaml_D.potrf.
|
| potrs [Lacaml_C] |
potrs ?n ?up ?ar ?ac a ?nrhs ?br ?bc ?factorize ?jitter b solves
a system of linear equations a*X = b, where a is symmetric
positive definite matrix, using the Cholesky factorization a =
U**T*U or a = L*L**T computed by Lacaml_C.potrf.
|
| potrs [Lacaml_Z] |
potrs ?n ?up ?ar ?ac a ?nrhs ?br ?bc ?factorize ?jitter b solves
a system of linear equations a*X = b, where a is symmetric
positive definite matrix, using the Cholesky factorization a =
U**T*U or a = L*L**T computed by Lacaml_Z.potrf.
|
| potrs [Lacaml_S] |
potrs ?n ?up ?ar ?ac a ?nrhs ?br ?bc ?factorize ?jitter b solves
a system of linear equations a*X = b, where a is symmetric
positive definite matrix, using the Cholesky factorization a =
U**T*U or a = L*L**T computed by Lacaml_S.potrf.
|
| potrs [Lacaml_D] |
potrs ?n ?up ?ar ?ac a ?nrhs ?br ?bc ?factorize ?jitter b solves
a system of linear equations a*X = b, where a is symmetric
positive definite matrix, using the Cholesky factorization a =
U**T*U or a = L*L**T computed by Lacaml_D.potrf.
|
| potrs_err [Lacaml_utils] |
|
| pp_cmat [Lacaml_io.Toplevel] |
|
| pp_cmat [Lacaml_io] |
|
| pp_complex_el_default [Lacaml_io] |
fprintf ppf "(%G, %Gi)" el.re el.im
|
| pp_cvec [Lacaml_io.Toplevel] |
|
| pp_cvec [Lacaml_io] |
|
| pp_float_el_default [Lacaml_io] |
|
| pp_fmat [Lacaml_io.Toplevel] |
|
| pp_fmat [Lacaml_io] |
|
| pp_fvec [Lacaml_io.Toplevel] |
|
| pp_fvec [Lacaml_io] |
|
| pp_imat [Lacaml_io.Toplevel] |
|
| pp_imat [Lacaml_io] |
|
| pp_int32_el [Lacaml_io] |
|
| pp_ivec [Lacaml_io.Toplevel] |
|
| pp_ivec [Lacaml_io] |
|
| pp_labeled_cmat [Lacaml_io] |
|
| pp_labeled_cvec [Lacaml_io] |
|
| pp_labeled_fmat [Lacaml_io] |
|
| pp_labeled_fvec [Lacaml_io] |
|
| pp_labeled_imat [Lacaml_io] |
|
| pp_labeled_ivec [Lacaml_io] |
|
| pp_labeled_rcvec [Lacaml_io] |
|
| pp_labeled_rfvec [Lacaml_io] |
|
| pp_labeled_rivec [Lacaml_io] |
|
| pp_lcmat [Lacaml_io] |
|
| pp_lcvec [Lacaml_io] |
|
| pp_lfmat [Lacaml_io] |
|
| pp_lfvec [Lacaml_io] |
|
| pp_limat [Lacaml_io] |
|
| pp_livec [Lacaml_io] |
|
| pp_mat [Lacaml_C] |
Pretty-printer for matrices.
|
| pp_mat [Lacaml_Z] |
Pretty-printer for matrices.
|
| pp_mat [Lacaml_S] |
Pretty-printer for matrices.
|
| pp_mat [Lacaml_D] |
Pretty-printer for matrices.
|
| pp_mat_gen [Lacaml_io] |
pp_mat_gen
?pp_open ?pp_close ?pp_head ?pp_foot ?pp_end_row ?pp_end_col
?pp_left ?pp_right ?pad pp_el ppf mat
|
| pp_num [Lacaml_C] |
pp_num ppf el is equivalent to fprintf ppf "(%G, %Gi)"
el.re el.im.
|
| pp_num [Lacaml_Z] |
pp_num ppf el is equivalent to fprintf ppf "(%G, %Gi)"
el.re el.im.
|
| pp_num [Lacaml_S] |
pp_num ppf el is equivalent to fprintf ppf "%G" el.
|
| pp_num [Lacaml_D] |
pp_num ppf el is equivalent to fprintf ppf "%G" el.
|
| pp_ocmat [Lacaml_io] |
|
| pp_ocvec [Lacaml_io] |
|
| pp_ofmat [Lacaml_io] |
|
| pp_ofvec [Lacaml_io] |
|
| pp_oimat [Lacaml_io] |
|
| pp_oivec [Lacaml_io] |
|
| pp_omat [Lacaml_io] |
pp_omat ppf pp_el mat prints matrix mat to formatter ppf
in OCaml-style using the element printer pp_el.
|
| pp_ovec [Lacaml_io] |
pp_ovec ppf pp_el vec prints the column vector vec to formatter
ppf in OCaml-style using the element printer pp_el.
|
| pp_rcvec [Lacaml_io.Toplevel] |
|
| pp_rcvec [Lacaml_io] |
|
| pp_rfvec [Lacaml_io.Toplevel] |
|
| pp_rfvec [Lacaml_io] |
|
| pp_rivec [Lacaml_io.Toplevel] |
|
| pp_rivec [Lacaml_io] |
|
| pp_rlcvec [Lacaml_io] |
|
| pp_rlfvec [Lacaml_io] |
|
| pp_rlivec [Lacaml_io] |
|
| pp_rocvec [Lacaml_io] |
|
| pp_rofvec [Lacaml_io] |
|
| pp_roivec [Lacaml_io] |
|
| pp_rovec [Lacaml_io] |
pp_rovec ppf pp_el vec prints the row vector vec to formatter
ppf in OCaml-style using the element printer pp_el.
|
| pp_vec [Lacaml_C] |
Pretty-printer for column vectors.
|
| pp_vec [Lacaml_Z] |
Pretty-printer for column vectors.
|
| pp_vec [Lacaml_S] |
Pretty-printer for column vectors.
|
| pp_vec [Lacaml_D] |
Pretty-printer for column vectors.
|
| ppsv [Lacaml_C] |
ppsv ?n ?up ?ofsap ap ?nrhs ?br ?bc b computes the solution to
the real system of linear equations a * X = b, where a is an
n-by-n symmetric positive definite matrix stored in packed
format and X and b are n-by-nrhs matrices.
|
| ppsv [Lacaml_Z] |
ppsv ?n ?up ?ofsap ap ?nrhs ?br ?bc b computes the solution to
the real system of linear equations a * X = b, where a is an
n-by-n symmetric positive definite matrix stored in packed
format and X and b are n-by-nrhs matrices.
|
| ppsv [Lacaml_S] |
ppsv ?n ?up ?ofsap ap ?nrhs ?br ?bc b computes the solution to
the real system of linear equations a * X = b, where a is an
n-by-n symmetric positive definite matrix stored in packed
format and X and b are n-by-nrhs matrices.
|
| ppsv [Lacaml_D] |
ppsv ?n ?up ?ofsap ap ?nrhs ?br ?bc b computes the solution to
the real system of linear equations a * X = b, where a is an
n-by-n symmetric positive definite matrix stored in packed
format and X and b are n-by-nrhs matrices.
|
| prec [Lacaml_complex64] |
|
| prec [Lacaml_complex32] |
|
| prec [Lacaml_float64] |
|
| prec [Lacaml_float32] |
|
| prec [Lacaml_C] |
Precision for this submodule C.
|
| prec [Lacaml_Z] |
Precision for this submodule Z.
|
| prec [Lacaml_S] |
Precision for this submodule S.
|
| prec [Lacaml_D] |
Precision for this submodule D.
|
| prod [Lacaml_C.Vec] |
prod ?n ?ofsx ?incx x computes the product of the n elements
in vector x, separated by incx incremental steps.
|
| prod [Lacaml_Z.Vec] |
prod ?n ?ofsx ?incx x computes the product of the n elements
in vector x, separated by incx incremental steps.
|
| prod [Lacaml_S.Vec] |
prod ?n ?ofsx ?incx x computes the product of the n elements
in vector x, separated by incx incremental steps.
|
| prod [Lacaml_D.Vec] |
prod ?n ?ofsx ?incx x computes the product of the n elements
in vector x, separated by incx incremental steps.
|
| ptsv [Lacaml_C] |
ptsv ?n ?ofsd d ?ofse e ?nrhs ?br ?bc b computes the solution to
the real system of linear equations a*X = b, where a is an
n-by-n symmetric positive definite tridiagonal matrix, and X
and b are n-by-nrhs matrices.
|
| ptsv [Lacaml_Z] |
ptsv ?n ?ofsd d ?ofse e ?nrhs ?br ?bc b computes the solution to
the real system of linear equations a*X = b, where a is an
n-by-n symmetric positive definite tridiagonal matrix, and X
and b are n-by-nrhs matrices.
|
| ptsv [Lacaml_S] |
ptsv ?n ?ofsd d ?ofse e ?nrhs ?br ?bc b computes the solution to
the real system of linear equations a*X = b, where a is an
n-by-n symmetric positive definite tridiagonal matrix, and X
and b are n-by-nrhs matrices.
|
| ptsv [Lacaml_D] |
ptsv ?n ?ofsd d ?ofse e ?nrhs ?br ?bc b computes the solution to
the real system of linear equations a*X = b, where a is an
n-by-n symmetric positive definite tridiagonal matrix, and X
and b are n-by-nrhs matrices.
|
R |
| raise_mat_ofs [Lacaml_utils] |
|
| raise_mat_ofs_neg [Lacaml_utils] |
|
| random [Lacaml_C.Mat] |
random ?rnd_state ?re_from ?re_range ?im_from ?im_range m n
|
| random [Lacaml_C.Vec] |
random ?rnd_state ?re_from ?re_range ?im_from ?im_range n
|
| random [Lacaml_Z.Mat] |
random ?rnd_state ?re_from ?re_range ?im_from ?im_range m n
|
| random [Lacaml_Z.Vec] |
random ?rnd_state ?re_from ?re_range ?im_from ?im_range n
|
| random [Lacaml_S.Mat] |
random ?rnd_state ?from ?range m n
|
| random [Lacaml_S.Vec] |
random ?rnd_state ?from ?range n
|
| random [Lacaml_D.Mat] |
random ?rnd_state ?from ?range m n
|
| random [Lacaml_D.Vec] |
random ?rnd_state ?from ?range n
|
| reci [Lacaml_C.Vec] |
reci ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the reciprocal value
of n elements of the vector x using incx as incremental steps.
|
| reci [Lacaml_Z.Vec] |
reci ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the reciprocal value
of n elements of the vector x using incx as incremental steps.
|
| reci [Lacaml_S.Vec] |
reci ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the reciprocal value
of n elements of the vector x using incx as incremental steps.
|
| reci [Lacaml_D.Vec] |
reci ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the reciprocal value
of n elements of the vector x using incx as incremental steps.
|
| rev [Lacaml_C.Vec] |
rev x reverses vector x (non-destructive).
|
| rev [Lacaml_Z.Vec] |
rev x reverses vector x (non-destructive).
|
| rev [Lacaml_S.Vec] |
rev x reverses vector x (non-destructive).
|
| rev [Lacaml_D.Vec] |
rev x reverses vector x (non-destructive).
|
| rosser [Lacaml_S.Mat] |
|
| rosser [Lacaml_D.Mat] |
|
S |
| s_str [Lacaml_utils] |
|
| sbev [Lacaml_S] |
sbev ?n ?vectors ?zr ?zc ?z ?up ?ofswork ?work ?ofsw ?w ?abr ?abc ab
computes all the eigenvalues and, optionally, eigenvectors of the
real symmetric band matrix ab.
|
| sbev [Lacaml_D] |
sbev ?n ?vectors ?zr ?zc ?z ?up ?ofswork ?work ?ofsw ?w ?abr ?abc ab
computes all the eigenvalues and, optionally, eigenvectors of the
real symmetric band matrix ab.
|
| sbev_min_lwork [Lacaml_S] |
|
| sbev_min_lwork [Lacaml_D] |
|
| sbgv [Lacaml_S] |
sbgv ?n ?ka ?kb ?zr ?zc ?z ?up ?work ?ofsw ?w ?ar ?ac a ?br ?bc b
computes all the eigenvalues, and optionally, the eigenvectors of a
real generalized symmetric-definite banded eigenproblem, of the
form a*x=(lambda)*b*x.
|
| sbgv [Lacaml_D] |
sbgv ?n ?ka ?kb ?zr ?zc ?z ?up ?work ?ofsw ?w ?ar ?ac a ?br ?bc b
computes all the eigenvalues, and optionally, the eigenvectors of a
real generalized symmetric-definite banded eigenproblem, of the
form a*x=(lambda)*b*x.
|
| sbmv [Lacaml_S] |
sbmv ?n ?k ?ofsy ?incy ?y ?ar ?ac a ?up ?alpha ?beta ?ofsx ?incx x see
BLAS documentation!
|
| sbmv [Lacaml_D] |
sbmv ?n ?k ?ofsy ?incy ?y ?ar ?ac a ?up ?alpha ?beta ?ofsx ?incx x see
BLAS documentation!
|
| scal [Lacaml_C.Mat] |
scal ?m ?n alpha ?ar ?ac a BLAS scal function for (sub-)matrices.
|
| scal [Lacaml_C] |
scal ?n alpha ?ofsx ?incx x see BLAS documentation!
|
| scal [Lacaml_Z.Mat] |
scal ?m ?n alpha ?ar ?ac a BLAS scal function for (sub-)matrices.
|
| scal [Lacaml_Z] |
scal ?n alpha ?ofsx ?incx x see BLAS documentation!
|
| scal [Lacaml_S.Mat] |
scal ?m ?n alpha ?ar ?ac a BLAS scal function for (sub-)matrices.
|
| scal [Lacaml_S] |
scal ?n alpha ?ofsx ?incx x see BLAS documentation!
|
| scal [Lacaml_D.Mat] |
scal ?m ?n alpha ?ar ?ac a BLAS scal function for (sub-)matrices.
|
| scal [Lacaml_D] |
scal ?n alpha ?ofsx ?incx x see BLAS documentation!
|
| scal_cols [Lacaml_C.Mat] |
scal_cols ?m ?n ?ar ?ac a ?ofs alphas column-wise scal
function for matrices.
|
| scal_cols [Lacaml_Z.Mat] |
scal_cols ?m ?n ?ar ?ac a ?ofs alphas column-wise scal
function for matrices.
|
| scal_cols [Lacaml_S.Mat] |
scal_cols ?m ?n ?ar ?ac a ?ofs alphas column-wise scal
function for matrices.
|
| scal_cols [Lacaml_D.Mat] |
scal_cols ?m ?n ?ar ?ac a ?ofs alphas column-wise scal
function for matrices.
|
| scal_rows [Lacaml_C.Mat] |
scal_rows ?m ?n ?ofs alphas ?ar ?ac a row-wise scal
function for matrices.
|
| scal_rows [Lacaml_Z.Mat] |
scal_rows ?m ?n ?ofs alphas ?ar ?ac a row-wise scal
function for matrices.
|
| scal_rows [Lacaml_S.Mat] |
scal_rows ?m ?n ?ofs alphas ?ar ?ac a row-wise scal
function for matrices.
|
| scal_rows [Lacaml_D.Mat] |
scal_rows ?m ?n ?ofs alphas ?ar ?ac a row-wise scal
function for matrices.
|
| set_dim_defaults [Lacaml_io.Context] |
|
| sin [Lacaml_S.Vec] |
sin ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the sine of n elements
of the vector x using incx as incremental steps.
|
| sin [Lacaml_D.Vec] |
sin ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the sine of n elements
of the vector x using incx as incremental steps.
|
| sort [Lacaml_C.Vec] |
sort ?cmp ?n ?ofsx ?incx x sorts the array x in increasing
order according to the comparison function cmp.
|
| sort [Lacaml_Z.Vec] |
sort ?cmp ?n ?ofsx ?incx x sorts the array x in increasing
order according to the comparison function cmp.
|
| sort [Lacaml_S.Vec] |
sort ?cmp ?n ?ofsx ?incx x sorts the array x in increasing
order according to the comparison function cmp.
|
| sort [Lacaml_D.Vec] |
sort ?cmp ?n ?ofsx ?incx x sorts the array x in increasing
order according to the comparison function cmp.
|
| spsv [Lacaml_C] |
spsv ?n ?up ?ipiv ?ofsap ap ?nrhs ?br ?bc b computes the
solution to the real system of linear equations a * X = b,
where a is an n-by-n symmetric matrix stored in packed
format and X and b are n-by-nrhs matrices.
|
| spsv [Lacaml_Z] |
spsv ?n ?up ?ipiv ?ofsap ap ?nrhs ?br ?bc b computes the
solution to the real system of linear equations a * X = b,
where a is an n-by-n symmetric matrix stored in packed
format and X and b are n-by-nrhs matrices.
|
| spsv [Lacaml_S] |
spsv ?n ?up ?ipiv ?ofsap ap ?nrhs ?br ?bc b computes the
solution to the real system of linear equations a * X = b,
where a is an n-by-n symmetric matrix stored in packed
format and X and b are n-by-nrhs matrices.
|
| spsv [Lacaml_D] |
spsv ?n ?up ?ipiv ?ofsap ap ?nrhs ?br ?bc b computes the
solution to the real system of linear equations a * X = b,
where a is an n-by-n symmetric matrix stored in packed
format and X and b are n-by-nrhs matrices.
|
| sqr [Lacaml_S.Vec] |
sqr ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the square
of n elements of the vector x using incx as incremental
steps.
|
| sqr [Lacaml_D.Vec] |
sqr ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the square
of n elements of the vector x using incx as incremental
steps.
|
| sqr_nrm2 [Lacaml_C.Vec] |
sqr_nrm2 ?stable ?n ?c ?ofsx ?incx x computes the square of
the 2-norm (Euclidean norm) of vector x separated by incx
incremental steps.
|
| sqr_nrm2 [Lacaml_Z.Vec] |
sqr_nrm2 ?stable ?n ?c ?ofsx ?incx x computes the square of
the 2-norm (Euclidean norm) of vector x separated by incx
incremental steps.
|
| sqr_nrm2 [Lacaml_S.Vec] |
sqr_nrm2 ?stable ?n ?c ?ofsx ?incx x computes the square of
the 2-norm (Euclidean norm) of vector x separated by incx
incremental steps.
|
| sqr_nrm2 [Lacaml_D.Vec] |
sqr_nrm2 ?stable ?n ?c ?ofsx ?incx x computes the square of
the 2-norm (Euclidean norm) of vector x separated by incx
incremental steps.
|
| sqrt [Lacaml_S.Vec] |
sqrt ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the square root
of n elements of the vector x using incx as incremental
steps.
|
| sqrt [Lacaml_D.Vec] |
sqrt ?n ?ofsy ?incy ?y ?ofsx ?incx x computes the square root
of n elements of the vector x using incx as incremental
steps.
|
| ssqr [Lacaml_C.Vec] |
ssqr ?n ?c ?ofsx ?incx x computes the sum of squared differences
of the n elements in vector x from constant c, separated
by incx incremental steps.
|
| ssqr [Lacaml_Z.Vec] |
ssqr ?n ?c ?ofsx ?incx x computes the sum of squared differences
of the n elements in vector x from constant c, separated
by incx incremental steps.
|
| ssqr [Lacaml_S.Vec] |
ssqr ?n ?c ?ofsx ?incx x computes the sum of squared differences
of the n elements in vector x from constant c, separated
by incx incremental steps.
|
| ssqr [Lacaml_D.Vec] |
ssqr ?n ?c ?ofsx ?incx x computes the sum of squared differences
of the n elements in vector x from constant c, separated
by incx incremental steps.
|
| ssqr_diff [Lacaml_C.Vec] |
ssqr_diff ?n ?ofsx ?incx x ?ofsy ?incy y returns the sum of
squared differences of n elements of vectors x and y, using
incx and incy as incremental steps respectively.
|
| ssqr_diff [Lacaml_Z.Vec] |
ssqr_diff ?n ?ofsx ?incx x ?ofsy ?incy y returns the sum of
squared differences of n elements of vectors x and y, using
incx and incy as incremental steps respectively.
|
| ssqr_diff [Lacaml_S.Vec] |
ssqr_diff ?n ?ofsx ?incx x ?ofsy ?incy y returns the sum of
squared differences of n elements of vectors x and y, using
incx and incy as incremental steps respectively.
|
| ssqr_diff [Lacaml_D.Vec] |
ssqr_diff ?n ?ofsx ?incx x ?ofsy ?incy y returns the sum of
squared differences of n elements of vectors x and y, using
incx and incy as incremental steps respectively.
|
| sub [Lacaml_C.Vec] |
sub ?n ?ofsz ?incz ?z ?ofsx ?incx x ?ofsy ?incy y subtracts n
elements of vectors x and y elementwise, using incx and incy
as incremental steps respectively.
|
| sub [Lacaml_Z.Vec] |
sub ?n ?ofsz ?incz ?z ?ofsx ?incx x ?ofsy ?incy y subtracts n
elements of vectors x and y elementwise, using incx and incy
as incremental steps respectively.
|
| sub [Lacaml_S.Vec] |
sub ?n ?ofsz ?incz ?z ?ofsx ?incx x ?ofsy ?incy y subtracts n
elements of vectors x and y elementwise, using incx and incy
as incremental steps respectively.
|
| sub [Lacaml_D.Vec] |
sub ?n ?ofsz ?incz ?z ?ofsx ?incx x ?ofsy ?incy y subtracts n
elements of vectors x and y elementwise, using incx and incy
as incremental steps respectively.
|
| sum [Lacaml_C.Mat] |
sum ?m ?n ?ar ?ac a computes the sum of all elements in
the m-by-n submatrix starting at row ar and column ac.
|
| sum [Lacaml_C.Vec] |
sum ?n ?ofsx ?incx x computes the sum of the n elements in
vector x, separated by incx incremental steps.
|
| sum [Lacaml_Z.Mat] |
sum ?m ?n ?ar ?ac a computes the sum of all elements in
the m-by-n submatrix starting at row ar and column ac.
|
| sum [Lacaml_Z.Vec] |
sum ?n ?ofsx ?incx x computes the sum of the n elements in
vector x, separated by incx incremental steps.
|
| sum [Lacaml_S.Mat] |
sum ?m ?n ?ar ?ac a computes the sum of all elements in
the m-by-n submatrix starting at row ar and column ac.
|
| sum [Lacaml_S.Vec] |
sum ?n ?ofsx ?incx x computes the sum of the n elements in
vector x, separated by incx incremental steps.
|
| sum [Lacaml_D.Mat] |
sum ?m ?n ?ar ?ac a computes the sum of all elements in
the m-by-n submatrix starting at row ar and column ac.
|
| sum [Lacaml_D.Vec] |
sum ?n ?ofsx ?incx x computes the sum of the n elements in
vector x, separated by incx incremental steps.
|
| swap [Lacaml_C] |
swap ?n ?ofsx ?incx ~x ?ofsy ?incy y see BLAS documentation!
|
| swap [Lacaml_Z] |
swap ?n ?ofsx ?incx ~x ?ofsy ?incy y see BLAS documentation!
|
| swap [Lacaml_S] |
swap ?n ?ofsx ?incx ~x ?ofsy ?incy y see BLAS documentation!
|
| swap [Lacaml_D] |
swap ?n ?ofsx ?incx ~x ?ofsy ?incy y see BLAS documentation!
|
| sycon [Lacaml_C] |
sycon ?n ?up ?ipiv ?anorm ?work ?ar ?ac a
|
| sycon [Lacaml_Z] |
sycon ?n ?up ?ipiv ?anorm ?work ?ar ?ac a
|
| sycon [Lacaml_S] |
sycon ?n ?up ?ipiv ?anorm ?work ?iwork ?ar ?ac a
|
| sycon [Lacaml_D] |
sycon ?n ?up ?ipiv ?anorm ?work ?iwork ?ar ?ac a
|
| sycon_min_liwork [Lacaml_S] |
|
| sycon_min_liwork [Lacaml_D] |
|
| sycon_min_lwork [Lacaml_C] |
|
| sycon_min_lwork [Lacaml_Z] |
|
| sycon_min_lwork [Lacaml_S] |
|
| sycon_min_lwork [Lacaml_D] |
|
| syev [Lacaml_S] |
syev ?n ?vectors ?up ?ofswork ?work ?ofsw ?w ?ar ?ac a computes
all eigenvalues and, optionally, eigenvectors of the real symmetric
matrix a.
|
| syev [Lacaml_D] |
syev ?n ?vectors ?up ?ofswork ?work ?ofsw ?w ?ar ?ac a computes
all eigenvalues and, optionally, eigenvectors of the real symmetric
matrix a.
|
| syev_min_lwork [Lacaml_S] |
|
| syev_min_lwork [Lacaml_D] |
|
| syev_opt_lwork [Lacaml_S] |
syev_opt_lwork ?n ?vectors ?up ?ar ?ac a
|
| syev_opt_lwork [Lacaml_D] |
syev_opt_lwork ?n ?vectors ?up ?ar ?ac a
|
| syevd [Lacaml_S] |
syevd ?n ?vectors ?up ?ofswork ?work ?iwork ?ofsw ?w ?ar ?ac a
computes all eigenvalues and, optionally, eigenvectors of the real
symmetric matrix a.
|
| syevd [Lacaml_D] |
syevd ?n ?vectors ?up ?ofswork ?work ?iwork ?ofsw ?w ?ar ?ac a
computes all eigenvalues and, optionally, eigenvectors of the real
symmetric matrix a.
|
| syevd_min_liwork [Lacaml_S] |
syevd_min_liwork vectors n
|
| syevd_min_liwork [Lacaml_D] |
syevd_min_liwork vectors n
|
| syevd_min_lwork [Lacaml_S] |
syevd_min_lwork vectors n
|
| syevd_min_lwork [Lacaml_D] |
syevd_min_lwork vectors n
|
| syevd_opt_l_li_work [Lacaml_S] |
syevd_opt_l_li_iwork ?n ?vectors ?up ?ar ?ac a
|
| syevd_opt_l_li_work [Lacaml_D] |
syevd_opt_l_li_iwork ?n ?vectors ?up ?ar ?ac a
|
| syevd_opt_liwork [Lacaml_S] |
syevd_opt_liwork ?n ?vectors ?up ?ar ?ac a
|
| syevd_opt_liwork [Lacaml_D] |
syevd_opt_liwork ?n ?vectors ?up ?ar ?ac a
|
| syevd_opt_lwork [Lacaml_S] |
syevd_opt_lwork ?n ?vectors ?up ?ar ?ac a
|
| syevd_opt_lwork [Lacaml_D] |
syevd_opt_lwork ?n ?vectors ?up ?ar ?ac a
|
| syevr [Lacaml_S] |
syevr
?n ?vectors ?range ?up ?abstol ?work ?iwork
?ofsw ?w ?zr ?zc ?z ?isuppz ?ar ?ac a
range is either `A for computing all eigenpairs, `V (vl, vu)
defines the lower and upper range of computed eigenvalues, `I (il,
iu) defines the indexes of the computed eigenpairs, which are sorted
in ascending order.
|
| syevr [Lacaml_D] |
syevr
?n ?vectors ?range ?up ?abstol ?work ?iwork
?ofsw ?w ?zr ?zc ?z ?isuppz ?ar ?ac a
range is either `A for computing all eigenpairs, `V (vl, vu)
defines the lower and upper range of computed eigenvalues, `I (il,
iu) defines the indexes of the computed eigenpairs, which are sorted
in ascending order.
|
| syevr_min_liwork [Lacaml_S] |
|
| syevr_min_liwork [Lacaml_D] |
|
| syevr_min_lwork [Lacaml_S] |
|
| syevr_min_lwork [Lacaml_D] |
|
| syevr_opt_l_li_work [Lacaml_S] |
syevr_opt_l_li_iwork ?n ?vectors ?range ?up ?abstol ?ar ?ac a
|
| syevr_opt_l_li_work [Lacaml_D] |
syevr_opt_l_li_iwork ?n ?vectors ?range ?up ?abstol ?ar ?ac a
|
| syevr_opt_liwork [Lacaml_S] |
syevr_opt_liwork ?n ?vectors ?range ?up ?abstol ?ar ?ac a
|
| syevr_opt_liwork [Lacaml_D] |
syevr_opt_liwork ?n ?vectors ?range ?up ?abstol ?ar ?ac a
|
| syevr_opt_lwork [Lacaml_S] |
syevr_opt_lwork ?n ?vectors ?range ?up ?abstol ?ar ?ac a
|
| syevr_opt_lwork [Lacaml_D] |
syevr_opt_lwork ?n ?vectors ?range ?up ?abstol ?ar ?ac a
|
| sygv [Lacaml_S] |
sygv ?n ?vectors ?up ?ofswork ?work ?ofsw ?w ?ar ?ac a
computes all the eigenvalues, and optionally, the eigenvectors
of a real generalized symmetric-definite eigenproblem, of the
form a*x=(lambda)*b*x, a*b*x=(lambda)*x, or b*a*x=(lambda)*x.
|
| sygv [Lacaml_D] |
sygv ?n ?vectors ?up ?ofswork ?work ?ofsw ?w ?ar ?ac a
computes all the eigenvalues, and optionally, the eigenvectors
of a real generalized symmetric-definite eigenproblem, of the
form a*x=(lambda)*b*x, a*b*x=(lambda)*x, or b*a*x=(lambda)*x.
|
| sygv_opt_lwork [Lacaml_S] |
sygv_opt_lwork ?n ?vectors ?up ?ar ?ac a ?br ?bc b
|
| sygv_opt_lwork [Lacaml_D] |
sygv_opt_lwork ?n ?vectors ?up ?ar ?ac a ?br ?bc b
|
| symm [Lacaml_C] |
symm ?m ?n ?side ?up ?beta ?cr ?cc ?c ?alpha ?ar ?ac a ?br ?bc b
see BLAS documentation!
|
| symm [Lacaml_Z] |
symm ?m ?n ?side ?up ?beta ?cr ?cc ?c ?alpha ?ar ?ac a ?br ?bc b
see BLAS documentation!
|
| symm [Lacaml_S] |
symm ?m ?n ?side ?up ?beta ?cr ?cc ?c ?alpha ?ar ?ac a ?br ?bc b
see BLAS documentation!
|
| symm [Lacaml_D] |
symm ?m ?n ?side ?up ?beta ?cr ?cc ?c ?alpha ?ar ?ac a ?br ?bc b
see BLAS documentation!
|
| symm2_trace [Lacaml_C.Mat] |
symm2_trace ?n ?upa ?ar ?ac a ?upb ?br ?bc b computes the
trace of the product of the symmetric (sub-)matrices a and
b.
|
| symm2_trace [Lacaml_Z.Mat] |
symm2_trace ?n ?upa ?ar ?ac a ?upb ?br ?bc b computes the
trace of the product of the symmetric (sub-)matrices a and
b.
|
| symm2_trace [Lacaml_S.Mat] |
symm2_trace ?n ?upa ?ar ?ac a ?upb ?br ?bc b computes the
trace of the product of the symmetric (sub-)matrices a and
b.
|
| symm2_trace [Lacaml_D.Mat] |
symm2_trace ?n ?upa ?ar ?ac a ?upb ?br ?bc b computes the
trace of the product of the symmetric (sub-)matrices a and
b.
|
| symm_get_params [Lacaml_utils] |
|
| symv [Lacaml_C] |
symv ?n ?beta ?ofsy ?incy ?y ?up ?alpha ?ar ?ac a ?ofsx ?incx x
see BLAS documentation!
|
| symv [Lacaml_Z] |
symv ?n ?beta ?ofsy ?incy ?y ?up ?alpha ?ar ?ac a ?ofsx ?incx x
see BLAS documentation!
|
| symv [Lacaml_S] |
symv ?n ?beta ?ofsy ?incy ?y ?up ?alpha ?ar ?ac a ?ofsx ?incx x
see BLAS documentation!
|
| symv [Lacaml_D] |
symv ?n ?beta ?ofsy ?incy ?y ?up ?alpha ?ar ?ac a ?ofsx ?incx x
see BLAS documentation!
|
| symv_get_params [Lacaml_utils] |
|
| syr [Lacaml_S] |
syr ?n ?alpha ?up ?ofsx ?incx x ?ar ?ac a see BLAS documentation!
|
| syr [Lacaml_D] |
syr ?n ?alpha ?up ?ofsx ?incx x ?ar ?ac a see BLAS documentation!
|
| syr2k [Lacaml_C] |
syr2k ?n ?k ?up ?beta ?cr ?cc ?c ?trans ?alpha ?ar ?ac a ?br ?bc b
see BLAS documentation!
|
| syr2k [Lacaml_Z] |
syr2k ?n ?k ?up ?beta ?cr ?cc ?c ?trans ?alpha ?ar ?ac a ?br ?bc b
see BLAS documentation!
|
| syr2k [Lacaml_S] |
syr2k ?n ?k ?up ?beta ?cr ?cc ?c ?trans ?alpha ?ar ?ac a ?br ?bc b
see BLAS documentation!
|
| syr2k [Lacaml_D] |
syr2k ?n ?k ?up ?beta ?cr ?cc ?c ?trans ?alpha ?ar ?ac a ?br ?bc b
see BLAS documentation!
|
| syr2k_get_params [Lacaml_utils] |
|
| syrk [Lacaml_C] |
syrk ?n ?k ?up ?beta ?cr ?cc ?c ?trans ?alpha ?ar ?ac a
see BLAS documentation!
|
| syrk [Lacaml_Z] |
syrk ?n ?k ?up ?beta ?cr ?cc ?c ?trans ?alpha ?ar ?ac a
see BLAS documentation!
|
| syrk [Lacaml_S] |
syrk ?n ?k ?up ?beta ?cr ?cc ?c ?trans ?alpha ?ar ?ac a
see BLAS documentation!
|
| syrk [Lacaml_D] |
syrk ?n ?k ?up ?beta ?cr ?cc ?c ?trans ?alpha ?ar ?ac a
see BLAS documentation!
|
| syrk_diag [Lacaml_C.Mat] |
syrk_diag ?n ?k ?beta ?ofsy ?y ?trans ?alpha ?ar ?ac a
computes the diagonal of the symmetric rank-k product of the
(sub-)matrix a, multiplying it with alpha and adding beta
times y, storing the result in y starting at the specified
offset.
|
| syrk_diag [Lacaml_Z.Mat] |
syrk_diag ?n ?k ?beta ?ofsy ?y ?trans ?alpha ?ar ?ac a
computes the diagonal of the symmetric rank-k product of the
(sub-)matrix a, multiplying it with alpha and adding beta
times y, storing the result in y starting at the specified
offset.
|
| syrk_diag [Lacaml_S.Mat] |
syrk_diag ?n ?k ?beta ?ofsy ?y ?trans ?alpha ?ar ?ac a
computes the diagonal of the symmetric rank-k product of the
(sub-)matrix a, multiplying it with alpha and adding beta
times y, storing the result in y starting at the specified
offset.
|
| syrk_diag [Lacaml_D.Mat] |
syrk_diag ?n ?k ?beta ?ofsy ?y ?trans ?alpha ?ar ?ac a
computes the diagonal of the symmetric rank-k product of the
(sub-)matrix a, multiplying it with alpha and adding beta
times y, storing the result in y starting at the specified
offset.
|
| syrk_get_params [Lacaml_utils] |
|
| syrk_trace [Lacaml_C.Mat] |
syrk_trace ?n ?k ?ar ?ac a computes the trace of either a' * a
or a * a', whichever is more efficient (results are identical), of the
(sub-)matrix a multiplied by its own transpose.
|
| syrk_trace [Lacaml_Z.Mat] |
syrk_trace ?n ?k ?ar ?ac a computes the trace of either a' * a
or a * a', whichever is more efficient (results are identical), of the
(sub-)matrix a multiplied by its own transpose.
|
| syrk_trace [Lacaml_S.Mat] |
syrk_trace ?n ?k ?ar ?ac a computes the trace of either a' * a
or a * a', whichever is more efficient (results are identical), of the
(sub-)matrix a multiplied by its own transpose.
|
| syrk_trace [Lacaml_D.Mat] |
syrk_trace ?n ?k ?ar ?ac a computes the trace of either a' * a
or a * a', whichever is more efficient (results are identical), of the
(sub-)matrix a multiplied by its own transpose.
|
| sysv [Lacaml_C] |
sysv ?n ?up ?ipiv ?work ?ar ?ac a ?nrhs ?br ?bc b computes the
solution to a real system of linear equations a * X = b, where
a is an N-by-N symmetric matrix and X and b are n-by-nrhs
matrices.
|
| sysv [Lacaml_Z] |
sysv ?n ?up ?ipiv ?work ?ar ?ac a ?nrhs ?br ?bc b computes the
solution to a real system of linear equations a * X = b, where
a is an N-by-N symmetric matrix and X and b are n-by-nrhs
matrices.
|
| sysv [Lacaml_S] |
sysv ?n ?up ?ipiv ?work ?ar ?ac a ?nrhs ?br ?bc b computes the
solution to a real system of linear equations a * X = b, where
a is an N-by-N symmetric matrix and X and b are n-by-nrhs
matrices.
|
| sysv [Lacaml_D] |
sysv ?n ?up ?ipiv ?work ?ar ?ac a ?nrhs ?br ?bc b computes the
solution to a real system of linear equations a * X = b, where
a is an N-by-N symmetric matrix and X and b are n-by-nrhs
matrices.
|
| sysv_opt_lwork [Lacaml_C] |
sysv_opt_lwork ?n ?up ?ar ?ac a ?nrhs ?br ?bc b
|
| sysv_opt_lwork [Lacaml_Z] |
sysv_opt_lwork ?n ?up ?ar ?ac a ?nrhs ?br ?bc b
|
| sysv_opt_lwork [Lacaml_S] |
sysv_opt_lwork ?n ?up ?ar ?ac a ?nrhs ?br ?bc b
|
| sysv_opt_lwork [Lacaml_D] |
sysv_opt_lwork ?n ?up ?ar ?ac a ?nrhs ?br ?bc b
|
| sytrf [Lacaml_C] |
sytrf ?n ?up ?ipiv ?work ?ar ?ac a computes the factorization of
the real symmetric matrix a using the Bunch-Kaufman diagonal
pivoting method.
|
| sytrf [Lacaml_Z] |
sytrf ?n ?up ?ipiv ?work ?ar ?ac a computes the factorization of
the real symmetric matrix a using the Bunch-Kaufman diagonal
pivoting method.
|
| sytrf [Lacaml_S] |
sytrf ?n ?up ?ipiv ?work ?ar ?ac a computes the factorization of
the real symmetric matrix a using the Bunch-Kaufman diagonal
pivoting method.
|
| sytrf [Lacaml_D] |
sytrf ?n ?up ?ipiv ?work ?ar ?ac a computes the factorization of
the real symmetric matrix a using the Bunch-Kaufman diagonal
pivoting method.
|
| sytrf_err [Lacaml_utils] |
|
| sytrf_fact_err [Lacaml_utils] |
|
| sytrf_get_ipiv [Lacaml_utils] |
|
| sytrf_min_lwork [Lacaml_C] |
|
| sytrf_min_lwork [Lacaml_Z] |
|
| sytrf_min_lwork [Lacaml_S] |
|
| sytrf_min_lwork [Lacaml_D] |
|
| sytrf_opt_lwork [Lacaml_C] |
sytrf_opt_lwork ?n ?up ?ar ?ac a
|
| sytrf_opt_lwork [Lacaml_Z] |
sytrf_opt_lwork ?n ?up ?ar ?ac a
|
| sytrf_opt_lwork [Lacaml_S] |
sytrf_opt_lwork ?n ?up ?ar ?ac a
|
| sytrf_opt_lwork [Lacaml_D] |
sytrf_opt_lwork ?n ?up ?ar ?ac a
|
| sytri [Lacaml_C] |
sytri ?n ?up ?ipiv ?work ?ar ?ac a computes the inverse of the
real symmetric indefinite matrix a using the factorization a =
U*D*U**T or a = L*D*L**T computed by Lacaml_C.sytrf.
|
| sytri [Lacaml_Z] |
sytri ?n ?up ?ipiv ?work ?ar ?ac a computes the inverse of the
real symmetric indefinite matrix a using the factorization a =
U*D*U**T or a = L*D*L**T computed by Lacaml_Z.sytrf.
|
| sytri [Lacaml_S] |
sytri ?n ?up ?ipiv ?work ?ar ?ac a computes the inverse of the
real symmetric indefinite matrix a using the factorization a =
U*D*U**T or a = L*D*L**T computed by Lacaml_S.sytrf.
|
| sytri [Lacaml_D] |
sytri ?n ?up ?ipiv ?work ?ar ?ac a computes the inverse of the
real symmetric indefinite matrix a using the factorization a =
U*D*U**T or a = L*D*L**T computed by Lacaml_D.sytrf.
|
| sytri_min_lwork [Lacaml_C] |
|
| sytri_min_lwork [Lacaml_Z] |
|
| sytri_min_lwork [Lacaml_S] |
|
| sytri_min_lwork [Lacaml_D] |
|
| sytrs [Lacaml_C] |
sytrs ?n ?up ?ipiv ?ar ?ac a ?nrhs ?br ?bc b solves a system of
linear equations a*X = b with a real symmetric matrix a
using the factorization a = U*D*U**T or a = L*D*L**T computed
by Lacaml_C.sytrf.
|
| sytrs [Lacaml_Z] |
sytrs ?n ?up ?ipiv ?ar ?ac a ?nrhs ?br ?bc b solves a system of
linear equations a*X = b with a real symmetric matrix a
using the factorization a = U*D*U**T or a = L*D*L**T computed
by Lacaml_Z.sytrf.
|
| sytrs [Lacaml_S] |
sytrs ?n ?up ?ipiv ?ar ?ac a ?nrhs ?br ?bc b solves a system of
linear equations a*X = b with a real symmetric matrix a
using the factorization a = U*D*U**T or a = L*D*L**T computed
by Lacaml_S.sytrf.
|
| sytrs [Lacaml_D] |
sytrs ?n ?up ?ipiv ?ar ?ac a ?nrhs ?br ?bc b solves a system of
linear equations a*X = b with a real symmetric matrix a
using the factorization a = U*D*U**T or a = L*D*L**T computed
by Lacaml_D.sytrf.
|
T |
| tau_str [Lacaml_utils] |
|
| tbtrs [Lacaml_C] |
tbtrs ?n ?kd ?up ?trans ?diag ?abr ?abc ab ?nrhs ?br ?bc b
solves a triangular system of the form a * X = b or a**T * X = b,
where a is a triangular band matrix of order n, and b is
an n-by-nrhs matrix.
|
| tbtrs [Lacaml_Z] |
tbtrs ?n ?kd ?up ?trans ?diag ?abr ?abc ab ?nrhs ?br ?bc b
solves a triangular system of the form a * X = b or a**T * X = b,
where a is a triangular band matrix of order n, and b is
an n-by-nrhs matrix.
|
| tbtrs [Lacaml_S] |
tbtrs ?n ?kd ?up ?trans ?diag ?abr ?abc ab ?nrhs ?br ?bc b
solves a triangular system of the form a * X = b or a**T * X = b,
where a is a triangular band matrix of order n, and b is
an n-by-nrhs matrix.
|
| tbtrs [Lacaml_D] |
tbtrs ?n ?kd ?up ?trans ?diag ?abr ?abc ab ?nrhs ?br ?bc b
solves a triangular system of the form a * X = b or a**T * X = b,
where a is a triangular band matrix of order n, and b is
an n-by-nrhs matrix.
|
| tbtrs_err [Lacaml_utils] |
|
| to_array [Lacaml_C.Mat] |
|
| to_array [Lacaml_C.Vec] |
|
| to_array [Lacaml_Z.Mat] |
|
| to_array [Lacaml_Z.Vec] |
|
| to_array [Lacaml_S.Mat] |
|
| to_array [Lacaml_S.Vec] |
|
| to_array [Lacaml_D.Mat] |
|
| to_array [Lacaml_D.Vec] |
|
| to_col_vecs [Lacaml_C.Mat] |
|
| to_col_vecs [Lacaml_Z.Mat] |
|
| to_col_vecs [Lacaml_S.Mat] |
|
| to_col_vecs [Lacaml_D.Mat] |
|
| to_list [Lacaml_C.Vec] |
|
| to_list [Lacaml_Z.Vec] |
|
| to_list [Lacaml_S.Vec] |
|
| to_list [Lacaml_D.Vec] |
|
| toeplitz [Lacaml_S.Mat] |
|
| toeplitz [Lacaml_D.Mat] |
|
| tpXv_get_params [Lacaml_utils] |
|
| tpmv [Lacaml_C] |
tpmv ?n ?trans ?diag ?up ?ofsap ap ?ofsx ?incx x
see BLAS documentation!
|
| tpmv [Lacaml_Z] |
tpmv ?n ?trans ?diag ?up ?ofsap ap ?ofsx ?incx x
see BLAS documentation!
|
| tpmv [Lacaml_S] |
tpmv ?n ?trans ?diag ?up ?ofsap ap ?ofsx ?incx x
see BLAS documentation!
|
| tpmv [Lacaml_D] |
tpmv ?n ?trans ?diag ?up ?ofsap ap ?ofsx ?incx x
see BLAS documentation!
|
| tpsv [Lacaml_C] |
tpsv ?n ?trans ?diag ?up ?ofsap ap ?ofsx ?incx x
see BLAS documentation!
|
| tpsv [Lacaml_Z] |
tpsv ?n ?trans ?diag ?up ?ofsap ap ?ofsx ?incx x
see BLAS documentation!
|
| tpsv [Lacaml_S] |
tpsv ?n ?trans ?diag ?up ?ofsap ap ?ofsx ?incx x
see BLAS documentation!
|
| tpsv [Lacaml_D] |
tpsv ?n ?trans ?diag ?up ?ofsap ap ?ofsx ?incx x
see BLAS documentation!
|
| trXm_get_params [Lacaml_utils] |
|
| trXv_get_params [Lacaml_utils] |
|
| trace [Lacaml_C.Mat] |
|
| trace [Lacaml_Z.Mat] |
|
| trace [Lacaml_S.Mat] |
|
| trace [Lacaml_D.Mat] |
|
| transpose [Lacaml_C.Mat] |
transpose ?m ?n ?ar ?ac aa
|
| transpose [Lacaml_Z.Mat] |
transpose ?m ?n ?ar ?ac aa
|
| transpose [Lacaml_S.Mat] |
transpose ?m ?n ?ar ?ac aa
|
| transpose [Lacaml_D.Mat] |
transpose ?m ?n ?ar ?ac aa
|
| transpose_copy [Lacaml_C.Mat] |
transpose_copy ?m ?n ?ar ?ac a ?br ?bc b copy the transpose
of (sub-)matrix a into (sub-)matrix b.
|
| transpose_copy [Lacaml_Z.Mat] |
transpose_copy ?m ?n ?ar ?ac a ?br ?bc b copy the transpose
of (sub-)matrix a into (sub-)matrix b.
|
| transpose_copy [Lacaml_S.Mat] |
transpose_copy ?m ?n ?ar ?ac a ?br ?bc b copy the transpose
of (sub-)matrix a into (sub-)matrix b.
|
| transpose_copy [Lacaml_D.Mat] |
transpose_copy ?m ?n ?ar ?ac a ?br ?bc b copy the transpose
of (sub-)matrix a into (sub-)matrix b.
|
| trmm [Lacaml_C] |
trmm ?m ?n ?side ?up ?transa ?diag ?alpha ?ar ?ac ~a ?br ?bc b
see BLAS documentation!
|
| trmm [Lacaml_Z] |
trmm ?m ?n ?side ?up ?transa ?diag ?alpha ?ar ?ac ~a ?br ?bc b
see BLAS documentation!
|
| trmm [Lacaml_S] |
trmm ?m ?n ?side ?up ?transa ?diag ?alpha ?ar ?ac ~a ?br ?bc b
see BLAS documentation!
|
| trmm [Lacaml_D] |
trmm ?m ?n ?side ?up ?transa ?diag ?alpha ?ar ?ac ~a ?br ?bc b
see BLAS documentation!
|
| trmv [Lacaml_C] |
trmv ?n ?trans ?diag ?up ?ar ?ac a ?ofsx ?incx x
see BLAS documentation!
|
| trmv [Lacaml_Z] |
trmv ?n ?trans ?diag ?up ?ar ?ac a ?ofsx ?incx x
see BLAS documentation!
|
| trmv [Lacaml_S] |
trmv ?n ?trans ?diag ?up ?ar ?ac a ?ofsx ?incx x
see BLAS documentation!
|
| trmv [Lacaml_D] |
trmv ?n ?trans ?diag ?up ?ar ?ac a ?ofsx ?incx x
see BLAS documentation!
|
| trsm [Lacaml_C] |
trsm ?m ?n ?side ?up ?transa ?diag ?alpha ?ar ?ac ~a ?br ?bc b
see BLAS documentation!
|
| trsm [Lacaml_Z] |
trsm ?m ?n ?side ?up ?transa ?diag ?alpha ?ar ?ac ~a ?br ?bc b
see BLAS documentation!
|
| trsm [Lacaml_S] |
trsm ?m ?n ?side ?up ?transa ?diag ?alpha ?ar ?ac ~a ?br ?bc b
see BLAS documentation!
|
| trsm [Lacaml_D] |
trsm ?m ?n ?side ?up ?transa ?diag ?alpha ?ar ?ac ~a ?br ?bc b
see BLAS documentation!
|
| trsv [Lacaml_C] |
trsv ?n ?trans ?diag ?up ?ar ?ac a ?ofsx ?incx x
see BLAS documentation!
|
| trsv [Lacaml_Z] |
trsv ?n ?trans ?diag ?up ?ar ?ac a ?ofsx ?incx x
see BLAS documentation!
|
| trsv [Lacaml_S] |
trsv ?n ?trans ?diag ?up ?ar ?ac a ?ofsx ?incx x
see BLAS documentation!
|
| trsv [Lacaml_D] |
trsv ?n ?trans ?diag ?up ?ar ?ac a ?ofsx ?incx x
see BLAS documentation!
|
| trtri [Lacaml_C] |
trtri ?n ?up ?diag ?ar ?ac a computes the inverse of a real
upper or lower triangular matrix a.
|
| trtri [Lacaml_Z] |
trtri ?n ?up ?diag ?ar ?ac a computes the inverse of a real
upper or lower triangular matrix a.
|
| trtri [Lacaml_S] |
trtri ?n ?up ?diag ?ar ?ac a computes the inverse of a real
upper or lower triangular matrix a.
|
| trtri [Lacaml_D] |
trtri ?n ?up ?diag ?ar ?ac a computes the inverse of a real
upper or lower triangular matrix a.
|
| trtri_err [Lacaml_utils] |
|
| trtrs [Lacaml_C] |
trtrs ?n ?up ?trans ?diag ?ar ?ac a ?nrhs ?br ?bc b solves a
triangular system of the form a * X = b or a**T * X = n,
where a is a triangular matrix of order n, and b is an
n-by-nrhs matrix.
|
| trtrs [Lacaml_Z] |
trtrs ?n ?up ?trans ?diag ?ar ?ac a ?nrhs ?br ?bc b solves a
triangular system of the form a * X = b or a**T * X = n,
where a is a triangular matrix of order n, and b is an
n-by-nrhs matrix.
|
| trtrs [Lacaml_S] |
trtrs ?n ?up ?trans ?diag ?ar ?ac a ?nrhs ?br ?bc b solves a
triangular system of the form a * X = b or a**T * X = n,
where a is a triangular matrix of order n, and b is an
n-by-nrhs matrix.
|
| trtrs [Lacaml_D] |
trtrs ?n ?up ?trans ?diag ?ar ?ac a ?nrhs ?br ?bc b solves a
triangular system of the form a * X = b or a**T * X = n,
where a is a triangular matrix of order n, and b is an
n-by-nrhs matrix.
|
| trtrs_err [Lacaml_utils] |
|
U |
| u_str [Lacaml_utils] |
|
| um_str [Lacaml_utils] |
|
| un_str [Lacaml_utils] |
|
| unpacked [Lacaml_C.Mat] |
|
| unpacked [Lacaml_Z.Mat] |
|
| unpacked [Lacaml_S.Mat] |
|
| unpacked [Lacaml_D.Mat] |
|
V |
| vandermonde [Lacaml_S.Mat] |
|
| vandermonde [Lacaml_D.Mat] |
|
| version [Lacaml_version] |
|
| vertical_default [Lacaml_io.Context] |
|
| vm_str [Lacaml_utils] |
|
| vn_str [Lacaml_utils] |
|
| vs_str [Lacaml_utils] |
|
| vsc_str [Lacaml_utils] |
|
| vsr_str [Lacaml_utils] |
|
| vt_str [Lacaml_utils] |
|
W |
| w_str [Lacaml_utils] |
|
| wi_str [Lacaml_utils] |
|
| wilkinson [Lacaml_S.Mat] |
|
| wilkinson [Lacaml_D.Mat] |
|
| work_str [Lacaml_utils] |
|
| wr_str [Lacaml_utils] |
|
X |
| x_str [Lacaml_utils] |
|
| xlange_get_params [Lacaml_utils] |
|
| xxcon_err [Lacaml_utils] |
|
| xxev_get_params [Lacaml_utils] |
|
| xxev_get_wx [Lacaml_utils] |
|
| xxsv_a_err [Lacaml_utils] |
|
| xxsv_err [Lacaml_utils] |
|
| xxsv_get_ipiv [Lacaml_utils] |
|
| xxsv_get_params [Lacaml_utils] |
|
| xxsv_ind_err [Lacaml_utils] |
|
| xxsv_lu_err [Lacaml_utils] |
|
| xxsv_pos_err [Lacaml_utils] |
|
| xxsv_work_err [Lacaml_utils] |
|
| xxtri_err [Lacaml_utils] |
|
| xxtri_singular_err [Lacaml_utils] |
|
| xxtrs_err [Lacaml_utils] |
|
| xxtrs_get_params [Lacaml_utils] |
|
Y |
| y_str [Lacaml_utils] |
|
Z |
| z_str [Lacaml_utils] |
|
| zero [Lacaml_complex64] |
|
| zero [Lacaml_complex32] |
|
| zero [Lacaml_float64] |
|
| zero [Lacaml_float32] |
|
| zmxy [Lacaml_C.Vec] |
zmxy ?n ?ofsz ?incz ?z ?ofsx ?incx x ?ofsy ?incy y multiplies n
elements of vectors x and y elementwise, using incx and incy
as incremental steps respectively, and substracts the result from and
stores it in the specified range in z if provided.
|
| zmxy [Lacaml_Z.Vec] |
zmxy ?n ?ofsz ?incz ?z ?ofsx ?incx x ?ofsy ?incy y multiplies n
elements of vectors x and y elementwise, using incx and incy
as incremental steps respectively, and substracts the result from and
stores it in the specified range in z if provided.
|
| zmxy [Lacaml_S.Vec] |
zmxy ?n ?ofsz ?incz ?z ?ofsx ?incx x ?ofsy ?incy y multiplies n
elements of vectors x and y elementwise, using incx and incy
as incremental steps respectively, and substracts the result from and
stores it in the specified range in z if provided.
|
| zmxy [Lacaml_D.Vec] |
zmxy ?n ?ofsz ?incz ?z ?ofsx ?incx x ?ofsy ?incy y multiplies n
elements of vectors x and y elementwise, using incx and incy
as incremental steps respectively, and substracts the result from and
stores it in the specified range in z if provided.
|
| zpxy [Lacaml_C.Vec] |
zpxy ?n ?ofsz ?incz ?z ?ofsx ?incx x ?ofsy ?incy y multiplies n
elements of vectors x and y elementwise, using incx and incy as
incremental steps respectively, and adds the result to and stores it in
the specified range in z if provided.
|
| zpxy [Lacaml_Z.Vec] |
zpxy ?n ?ofsz ?incz ?z ?ofsx ?incx x ?ofsy ?incy y multiplies n
elements of vectors x and y elementwise, using incx and incy as
incremental steps respectively, and adds the result to and stores it in
the specified range in z if provided.
|
| zpxy [Lacaml_S.Vec] |
zpxy ?n ?ofsz ?incz ?z ?ofsx ?incx x ?ofsy ?incy y multiplies n
elements of vectors x and y elementwise, using incx and incy as
incremental steps respectively, and adds the result to and stores it in
the specified range in z if provided.
|
| zpxy [Lacaml_D.Vec] |
zpxy ?n ?ofsz ?incz ?z ?ofsx ?incx x ?ofsy ?incy y multiplies n
elements of vectors x and y elementwise, using incx and incy as
incremental steps respectively, and adds the result to and stores it in
the specified range in z if provided.
|