A | |
| a_str [Lacaml_utils] | |
| ab_str [Lacaml_utils] | |
| add [Lacaml_complex64] | |
| add [Lacaml_complex32] | |
| add [Lacaml_float64] | |
| add [Lacaml_float32] | |
| 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_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_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 [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_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_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_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.
|
| 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.
|
| alphas_str [Lacaml_utils] | |
| amax [Lacaml_Z] | amax ?n ?ofsx ?incx x
|
| amax [Lacaml_C] | amax ?n ?ofsx ?incx x
|
| amax [Lacaml_D] | amax ?n ?ofsx ?incx x
|
| amax [Lacaml_S] | amax ?n ?ofsx ?incx x
|
| ap_str [Lacaml_utils] | |
| append [Lacaml_Z.Vec] | append v1 v2
|
| append [Lacaml_C.Vec] | append v1 v2
|
| append [Lacaml_D.Vec] | append v1 v2
|
| append [Lacaml_S.Vec] | append v1 v2
|
| as_vec [Lacaml_Z.Mat] | as_vec mat
|
| as_vec [Lacaml_C.Mat] | as_vec mat
|
| as_vec [Lacaml_D.Mat] | as_vec mat
|
| as_vec [Lacaml_S.Mat] | as_vec mat
|
| asum [Lacaml_D] | asum ?n ?ofsx ?incx x see BLAS documentation!
|
| asum [Lacaml_S] | asum ?n ?ofsx ?incx x see BLAS documentation!
|
| axpy [Lacaml_Z.Mat] | axpy ?m ?n ?alpha ?xr ?xc ~x ?yr ?yc y BLAS axpy function for
matrices.
|
| axpy [Lacaml_Z] | axpy ?n ?alpha ?ofsx ?incx ~x ?ofsy ?incy y see BLAS documentation!
|
| axpy [Lacaml_C.Mat] | axpy ?m ?n ?alpha ?xr ?xc ~x ?yr ?yc y BLAS axpy function for
matrices.
|
| axpy [Lacaml_C] | axpy ?n ?alpha ?ofsx ?incx ~x ?ofsy ?incy y see BLAS documentation!
|
| axpy [Lacaml_D.Mat] | axpy ?m ?n ?alpha ?xr ?xc ~x ?yr ?yc y BLAS axpy function for
matrices.
|
| axpy [Lacaml_D] | axpy ?n ?alpha ?ofsx ?incx ~x ?ofsy ?incy y see BLAS documentation!
|
| axpy [Lacaml_S.Mat] | axpy ?m ?n ?alpha ?xr ?xc ~x ?yr ?yc y BLAS axpy function for
matrices.
|
| axpy [Lacaml_S] | axpy ?n ?alpha ?ofsx ?incx ~x ?ofsy ?incy y see BLAS documentation!
|
B | |
| b_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_Z.Mat] | col m n
|
| col [Lacaml_C.Mat] | col m n
|
| col [Lacaml_D.Mat] | col m n
|
| col [Lacaml_S.Mat] | col m n
|
| concat [Lacaml_Z.Vec] | concat vs
|
| concat [Lacaml_C.Vec] | concat vs
|
| concat [Lacaml_D.Vec] | concat vs
|
| concat [Lacaml_S.Vec] | concat vs
|
| copy [Lacaml_Z] | copy ?n ?ofsy ?incy ?y ?ofsx ?incx x see BLAS documentation!
|
| copy [Lacaml_C] | 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 [Lacaml_S] | copy ?n ?ofsy ?incy ?y ?ofsx ?incx x see BLAS documentation!
|
| copy_diag [Lacaml_Z.Mat] | copy_diag m
|
| copy_diag [Lacaml_C.Mat] | copy_diag m
|
| copy_diag [Lacaml_D.Mat] | copy_diag m
|
| copy_diag [Lacaml_S.Mat] | copy_diag m
|
| copy_row [Lacaml_Z.Mat] | copy_row ?vec mat int
|
| copy_row [Lacaml_C.Mat] | copy_row ?vec mat int
|
| copy_row [Lacaml_D.Mat] | copy_row ?vec mat int
|
| copy_row [Lacaml_S.Mat] | copy_row ?vec mat int
|
| 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.
|
| 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.
|
| create [Lacaml_Z.Mat] | create m n
|
| create [Lacaml_Z.Vec] | create n
|
| create [Lacaml_C.Mat] | create m n
|
| create [Lacaml_C.Vec] | create n
|
| create [Lacaml_D.Mat] | create m n
|
| create [Lacaml_D.Vec] | create n
|
| create [Lacaml_S.Mat] | create m n
|
| create [Lacaml_S.Vec] | create n
|
| create [Lacaml_io.Context] | |
| create_int32_vec [Lacaml_common] | create_int32_vec n
|
| create_int_vec [Lacaml_common] | create_int_vec n
|
| create_mvec [Lacaml_Z.Mat] | create_mvec m
|
| create_mvec [Lacaml_C.Mat] | create_mvec m
|
| create_mvec [Lacaml_D.Mat] | create_mvec m
|
| create_mvec [Lacaml_S.Mat] | create_mvec m
|
D | |
| d_str [Lacaml_utils] | |
| detri [Lacaml_Z.Mat] | detri ?up ?n ?ar ?ac a takes a triangular (sub-)matrix a, i.e.
|
| detri [Lacaml_C.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.
|
| detri [Lacaml_S.Mat] | detri ?up ?n ?ar ?ac a takes a triangular (sub-)matrix a, i.e.
|
| dim [Lacaml_Z.Vec] | dim x
|
| dim [Lacaml_C.Vec] | dim x
|
| dim [Lacaml_D.Vec] | dim x
|
| dim [Lacaml_S.Vec] | dim x
|
| dim1 [Lacaml_Z.Mat] | dim1 m
|
| dim1 [Lacaml_C.Mat] | dim1 m
|
| dim1 [Lacaml_D.Mat] | dim1 m
|
| dim1 [Lacaml_S.Mat] | dim1 m
|
| dim2 [Lacaml_Z.Mat] | dim2 m
|
| dim2 [Lacaml_C.Mat] | dim2 m
|
| dim2 [Lacaml_D.Mat] | dim2 m
|
| dim2 [Lacaml_S.Mat] | dim2 m
|
| 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_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_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.
|
| 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.
|
| dl_str [Lacaml_utils] | |
| dot [Lacaml_D] | dot ?n ?ofsy ?incy y ?ofsx ?incx x see BLAS documentation!
|
| dot [Lacaml_S] | dot ?n ?ofsy ?incy y ?ofsx ?incx x see BLAS documentation!
|
| dotc [Lacaml_Z] | dotc ?n ?ofsy ?incy y ?ofsx ?incx x see BLAS documentation!
|
| dotc [Lacaml_C] | dotc ?n ?ofsy ?incy y ?ofsx ?incx x see BLAS documentation!
|
| dotu [Lacaml_Z] | dotu ?n ?ofsy ?incy y ?ofsx ?incx x see BLAS documentation!
|
| dotu [Lacaml_C] | dotu ?n ?ofsy ?incy y ?ofsx ?incx x see BLAS documentation!
|
| du_str [Lacaml_utils] | |
E | |
| e_str [Lacaml_utils] | |
| ellipsis_default [Lacaml_io.Context] | |
| empty [Lacaml_Z.Mat] | empty, the empty matrix.
|
| empty [Lacaml_Z.Vec] | empty, the empty vector.
|
| empty [Lacaml_C.Mat] | empty, the empty matrix.
|
| empty [Lacaml_C.Vec] | empty, the empty vector.
|
| empty [Lacaml_D.Mat] | empty, the empty matrix.
|
| empty [Lacaml_D.Vec] | empty, the empty vector.
|
| empty [Lacaml_S.Mat] | empty, the empty matrix.
|
| empty [Lacaml_S.Vec] | empty, the empty vector.
|
| empty_int32_vec [Lacaml_utils] | |
| 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.
|
| 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.
|
F | |
| 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_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_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.
|
| 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.
|
| 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_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_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 [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_cols [Lacaml_Z.Mat] | fold_cols f ?n ?ac acc a
|
| fold_cols [Lacaml_C.Mat] | fold_cols f ?n ?ac acc a
|
| fold_cols [Lacaml_D.Mat] | fold_cols f ?n ?ac acc a
|
| fold_cols [Lacaml_S.Mat] | fold_cols f ?n ?ac acc a
|
| from_col_vec [Lacaml_Z.Mat] | from_col_vec v
|
| from_col_vec [Lacaml_C.Mat] | from_col_vec v
|
| from_col_vec [Lacaml_D.Mat] | from_col_vec v
|
| from_col_vec [Lacaml_S.Mat] | from_col_vec v
|
| from_row_vec [Lacaml_Z.Mat] | from_row_vec v
|
| from_row_vec [Lacaml_C.Mat] | from_row_vec v
|
| from_row_vec [Lacaml_D.Mat] | from_row_vec v
|
| from_row_vec [Lacaml_S.Mat] | from_row_vec v
|
G | |
| gXmv_get_params [Lacaml_utils] | |
| 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_C] | 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!
|
| gbmv [Lacaml_S] | gbmv
?m ?n ?beta ?ofsy ?incy ?y ?trans ?alpha ?ar ?ac a kl ku ?ofsx ?incx x
see BLAS documentation!
|
| 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_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_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.
|
| 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.
|
| geXrf_get_params [Lacaml_utils] | |
| gecon [Lacaml_Z] | gecon ?n ?norm ?anorm ?work ?rwork ?ar ?ac a
|
| gecon [Lacaml_C] | gecon ?n ?norm ?anorm ?work ?rwork ?ar ?ac a
|
| gecon [Lacaml_D] | gecon ?n ?norm ?anorm ?work ?rwork ?ar ?ac a
|
| gecon [Lacaml_S] | gecon ?n ?norm ?anorm ?work ?rwork ?ar ?ac a
|
| gecon_err [Lacaml_utils] | |
| gecon_min_liwork [Lacaml_D] | gecon_min_liwork n
|
| gecon_min_liwork [Lacaml_S] | gecon_min_liwork n
|
| gecon_min_lrwork [Lacaml_Z] | gecon_min_lrwork n
|
| gecon_min_lrwork [Lacaml_C] | gecon_min_lrwork n
|
| gecon_min_lwork [Lacaml_Z] | gecon_min_lwork n
|
| gecon_min_lwork [Lacaml_C] | gecon_min_lwork n
|
| gecon_min_lwork [Lacaml_D] | gecon_min_lwork n
|
| gecon_min_lwork [Lacaml_S] | gecon_min_lwork n
|
| geev [Lacaml_Z] | geev ?work ?rwork ?n
?vlr ?vlc ?vl
?vrr ?vrc ?vr
?ofsw w
?ar ?ac a
|
| geev [Lacaml_C] | geev ?work ?rwork ?n
?vlr ?vlc ?vl
?vrr ?vrc ?vr
?ofsw w
?ar ?ac a
|
| geev [Lacaml_D] | geev ?work ?n
?vlr ?vlc ?vl
?vrr ?vrc ?vr
?ofswr wr ?ofswi wi
?ar ?ac a
|
| geev [Lacaml_S] | 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_Z] | geev_min_lrwork n
|
| geev_min_lrwork [Lacaml_C] | geev_min_lrwork n
|
| geev_min_lwork [Lacaml_Z] | geev_min_lwork n
|
| geev_min_lwork [Lacaml_C] | geev_min_lwork n
|
| geev_min_lwork [Lacaml_D] | geev_min_lwork vectors n
|
| geev_min_lwork [Lacaml_S] | geev_min_lwork vectors n
|
| 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_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_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.
|
| 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.
|
| gels [Lacaml_Z] | gels ?m ?n ?work ?trans ?ar ?ac a ?nrhs ?br ?bc b see
LAPACK documentation!
|
| gels [Lacaml_C] | 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!
|
| gels [Lacaml_S] | 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_Z] | gels_min_lwork ~m ~n ~nrhs
|
| gels_min_lwork [Lacaml_C] | gels_min_lwork ~m ~n ~nrhs
|
| gels_min_lwork [Lacaml_D] | gels_min_lwork ~m ~n ~nrhs
|
| gels_min_lwork [Lacaml_S] | gels_min_lwork ~m ~n ~nrhs
|
| gels_opt_lwork [Lacaml_Z] | gels_opt_lwork ?m ?n ?trans ?ar ?ac a ?nrhs ?br ?bc b
|
| gels_opt_lwork [Lacaml_C] | 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
|
| gels_opt_lwork [Lacaml_S] | gels_opt_lwork ?m ?n ?trans ?ar ?ac a ?nrhs ?br ?bc b
|
| gelsd [Lacaml_D] | gelsd ?m ?n ?rcond ?ofss ?s ?ofswork ?work ?ar ?ac a ?nrhs b
see LAPACK documentation!
|
| gelsd [Lacaml_S] | gelsd ?m ?n ?rcond ?ofss ?s ?ofswork ?work ?ar ?ac a ?nrhs b
see LAPACK documentation!
|
| gelsd_min_iwork [Lacaml_D] | gelsd_min_iwork m n
|
| gelsd_min_iwork [Lacaml_S] | gelsd_min_iwork m n
|
| gelsd_min_lwork [Lacaml_D] | gelsd_min_lwork ~m ~n ~nrhs
|
| gelsd_min_lwork [Lacaml_S] | gelsd_min_lwork ~m ~n ~nrhs
|
| gelsd_opt_lwork [Lacaml_D] | gelsd_opt_lwork ?m ?n ?ar ?ac a ?nrhs b
|
| gelsd_opt_lwork [Lacaml_S] | gelsd_opt_lwork ?m ?n ?ar ?ac a ?nrhs b
|
| gelss [Lacaml_D] | gelss ?m ?n ?rcond ?ofss ?s ?ofswork ?work ?ar ?ac a ?nrhs ?br ?bc b
see LAPACK documentation!
|
| gelss [Lacaml_S] | gelss ?m ?n ?rcond ?ofss ?s ?ofswork ?work ?ar ?ac a ?nrhs ?br ?bc b
see LAPACK documentation!
|
| gelss_min_lwork [Lacaml_D] | gelss_min_lwork ~m ~n ~nrhs
|
| gelss_min_lwork [Lacaml_S] | gelss_min_lwork ~m ~n ~nrhs
|
| gelss_opt_lwork [Lacaml_D] | gelss_opt_lwork ?ar ?ac a ?m ?n ?nrhs ?br ?bc b
|
| gelss_opt_lwork [Lacaml_S] | gelss_opt_lwork ?ar ?ac a ?m ?n ?nrhs ?br ?bc b
|
| gelsy [Lacaml_D] | gelsy ?m ?n ?ar ?ac a ?rcond ?jpvt ?ofswork ?work ?nrhs b see LAPACK
documentation!
|
| gelsy [Lacaml_S] | gelsy ?m ?n ?ar ?ac a ?rcond ?jpvt ?ofswork ?work ?nrhs b see LAPACK
documentation!
|
| gelsy_min_lwork [Lacaml_D] | gelsy_min_lwork ~m ~n ~nrhs
|
| gelsy_min_lwork [Lacaml_S] | gelsy_min_lwork ~m ~n ~nrhs
|
| gelsy_opt_lwork [Lacaml_D] | gelsy_opt_lwork ?m ?n ?ar ?ac a ?nrhs ?br ?bc b
|
| gelsy_opt_lwork [Lacaml_S] | gelsy_opt_lwork ?m ?n ?ar ?ac a ?nrhs ?br ?bc b
|
| 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_C] | 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 [Lacaml_S] | gemm ?m ?n ?k ?beta ?cr ?cc ?c ?transa ?alpha ?ar ?ac a ?transb ?br ?bc b
see BLAS documentation!
|
| 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_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_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_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_get_params [Lacaml_utils] | |
| 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_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_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).
|
| 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).
|
| 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_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_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.
|
| 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.
|
| 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_C] | 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 [Lacaml_S] | geqrf ?m ?n ?work ?tau ?ar ?ac a computes a QR factorization of
a real m-by-n matrix a.
|
| geqrf_min_lwork [Lacaml_Z] | geqrf_min_lwork ~n
|
| geqrf_min_lwork [Lacaml_C] | geqrf_min_lwork ~n
|
| geqrf_min_lwork [Lacaml_D] | geqrf_min_lwork ~n
|
| geqrf_min_lwork [Lacaml_S] | geqrf_min_lwork ~n
|
| geqrf_opt_lwork [Lacaml_Z] | geqrf_opt_lwork ?m ?n ?ar ?ac a
|
| geqrf_opt_lwork [Lacaml_C] | geqrf_opt_lwork ?m ?n ?ar ?ac a
|
| geqrf_opt_lwork [Lacaml_D] | geqrf_opt_lwork ?m ?n ?ar ?ac a
|
| geqrf_opt_lwork [Lacaml_S] | geqrf_opt_lwork ?m ?n ?ar ?ac a
|
| ger [Lacaml_D] | ger ?m ?n ?alpha ?ofsx ?incx x ?ofsy ?incy y n ?ar ?ac a see
BLAS documentation!
|
| ger [Lacaml_S] | ger ?m ?n ?alpha ?ofsx ?incx x ?ofsy ?incy y n ?ar ?ac a see
BLAS documentation!
|
| gesdd [Lacaml_D] | |
| gesdd [Lacaml_S] | |
| gesdd_err [Lacaml_utils] | |
| gesdd_get_params [Lacaml_utils] | |
| gesdd_liwork [Lacaml_D] | |
| gesdd_liwork [Lacaml_S] | |
| gesdd_min_lwork [Lacaml_D] | gesdd_min_lwork ?jobz ~m ~n
|
| gesdd_min_lwork [Lacaml_S] | gesdd_min_lwork ?jobz ~m ~n
|
| gesdd_opt_lwork [Lacaml_D] | |
| gesdd_opt_lwork [Lacaml_S] | |
| 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_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_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.
|
| 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.
|
| gesvd [Lacaml_Z] | |
| gesvd [Lacaml_C] | |
| gesvd [Lacaml_D] | |
| gesvd [Lacaml_S] | |
| gesvd_err [Lacaml_utils] | |
| gesvd_get_params [Lacaml_utils] | |
| gesvd_lrwork [Lacaml_Z] | gesvd_lrwork m n
|
| gesvd_lrwork [Lacaml_C] | gesvd_lrwork m n
|
| gesvd_min_lwork [Lacaml_Z] | gesvd_min_lwork ~m ~n
|
| gesvd_min_lwork [Lacaml_C] | gesvd_min_lwork ~m ~n
|
| gesvd_min_lwork [Lacaml_D] | gesvd_min_lwork ~m ~n
|
| gesvd_min_lwork [Lacaml_S] | gesvd_min_lwork ~m ~n
|
| gesvd_opt_lwork [Lacaml_Z] | |
| gesvd_opt_lwork [Lacaml_C] | |
| gesvd_opt_lwork [Lacaml_D] | |
| gesvd_opt_lwork [Lacaml_S] | |
| 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_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_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_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 [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_err [Lacaml_utils] | |
| getrf_get_ipiv [Lacaml_utils] | |
| getrf_lu_err [Lacaml_utils] | |
| 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_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_D] | getri ?n ?ipiv ?work ?ar ?ac a computes the inverse of a matrix
using the LU factorization computed by Lacaml_D.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_err [Lacaml_utils] | |
| getri_min_lwork [Lacaml_Z] | getri_min_lwork n
|
| getri_min_lwork [Lacaml_C] | getri_min_lwork n
|
| getri_min_lwork [Lacaml_D] | getri_min_lwork n
|
| getri_min_lwork [Lacaml_S] | getri_min_lwork n
|
| getri_opt_lwork [Lacaml_Z] | getri_opt_lwork ?n ?ar ?ac a
|
| getri_opt_lwork [Lacaml_C] | getri_opt_lwork ?n ?ar ?ac a
|
| getri_opt_lwork [Lacaml_D] | getri_opt_lwork ?n ?ar ?ac a
|
| getri_opt_lwork [Lacaml_S] | getri_opt_lwork ?n ?ar ?ac a
|
| 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_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_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.
|
| 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.
|
| 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_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_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.
|
| 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.
|
H | |
| hankel [Lacaml_D.Mat] | hankel n
|
| hankel [Lacaml_S.Mat] | hankel n
|
| hilbert [Lacaml_D.Mat] | hilbert n
|
| hilbert [Lacaml_S.Mat] | hilbert n
|
| horizontal_default [Lacaml_io.Context] | |
I | |
| iamax [Lacaml_Z] | iamax ?n ?ofsx ?incx x see BLAS documentation!
|
| iamax [Lacaml_C] | iamax ?n ?ofsx ?incx x see BLAS documentation!
|
| iamax [Lacaml_D] | iamax ?n ?ofsx ?incx x see BLAS documentation!
|
| iamax [Lacaml_S] | iamax ?n ?ofsx ?incx x see BLAS documentation!
|
| identity [Lacaml_Z.Mat] | identity n
|
| identity [Lacaml_C.Mat] | identity n
|
| identity [Lacaml_D.Mat] | identity n
|
| identity [Lacaml_S.Mat] | identity n
|
| ilaenv [Lacaml_utils] | |
| init [Lacaml_Z.Vec] | init n f
|
| init [Lacaml_C.Vec] | init n f
|
| init [Lacaml_D.Vec] | init n f
|
| init [Lacaml_S.Vec] | init n f
|
| init_cols [Lacaml_Z.Mat] | init_cols m n f
|
| init_cols [Lacaml_C.Mat] | init_cols m n f
|
| init_cols [Lacaml_D.Mat] | init_cols m n f
|
| init_cols [Lacaml_S.Mat] | init_cols m n f
|
| init_rows [Lacaml_Z.Mat] | init_cols m n f
|
| init_rows [Lacaml_C.Mat] | init_cols m n f
|
| init_rows [Lacaml_D.Mat] | init_cols m n f
|
| init_rows [Lacaml_S.Mat] | init_cols m n f
|
| 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_Z.Vec] | iter ?n ?ofsx ?incx f x applies function f in turn to all elements
of vector x.
|
| iter [Lacaml_C.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.
|
| iter [Lacaml_S.Vec] | iter ?n ?ofsx ?incx f x applies function f in turn to all elements
of vector x.
|
| 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_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_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.
|
| 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.
|
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_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_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_D] | 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).
|
| lamch [Lacaml_D] | lamch cmach see LAPACK documentation!
|
| lamch [Lacaml_S] | lamch cmach see LAPACK documentation!
|
| lange [Lacaml_Z] | lange ?m ?n ?norm ?work ?ar ?ac a
|
| lange [Lacaml_C] | lange ?m ?n ?norm ?work ?ar ?ac a
|
| lange [Lacaml_D] | lange ?m ?n ?norm ?work ?ar ?ac a
|
| lange [Lacaml_S] | lange ?m ?n ?norm ?work ?ar ?ac a
|
| lange_min_lwork [Lacaml_Z] | lange_min_lwork m norm
|
| lange_min_lwork [Lacaml_C] | lange_min_lwork m norm
|
| lange_min_lwork [Lacaml_D] | lange_min_lwork m norm
|
| lange_min_lwork [Lacaml_S] | lange_min_lwork m norm
|
| lansy [Lacaml_Z] | lansy ?n ?up ?norm ?work ?ar ?ac a see LAPACK documentation!
|
| lansy [Lacaml_C] | lansy ?n ?up ?norm ?work ?ar ?ac a see LAPACK documentation!
|
| lansy [Lacaml_D] | lansy ?norm ?up ?n ?ar ?ac ?work a see LAPACK documentation!
|
| lansy [Lacaml_S] | lansy ?norm ?up ?n ?ar ?ac ?work a see LAPACK documentation!
|
| lansy_min_lwork [Lacaml_Z] | lansy_min_lwork m norm
|
| lansy_min_lwork [Lacaml_C] | lansy_min_lwork m norm
|
| lansy_min_lwork [Lacaml_D] | lansy_min_lwork m norm
|
| lansy_min_lwork [Lacaml_S] | lansy_min_lwork m norm
|
| larnv [Lacaml_Z] | larnv ?idist ?iseed ?n ?ofsx ?x ()
|
| larnv [Lacaml_C] | larnv ?idist ?iseed ?n ?ofsx ?x ()
|
| larnv [Lacaml_D] | larnv ?idist ?iseed ?n ?ofsx ?x ()
|
| larnv [Lacaml_S] | larnv ?idist ?iseed ?n ?ofsx ?x ()
|
| lassq [Lacaml_Z] | lassq ?n ?ofsx ?incx ?scale ?sumsq
|
| lassq [Lacaml_C] | lassq ?n ?ofsx ?incx ?scale ?sumsq
|
| lassq [Lacaml_D] | lassq ?n ?ofsx ?incx ?scale ?sumsq
|
| lassq [Lacaml_S] | lassq ?n ?ofsx ?incx ?scale ?sumsq
|
| 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_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_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.
|
| 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.
|
| linspace [Lacaml_Z.Vec] | linspace ?z a b n
|
| linspace [Lacaml_C.Vec] | linspace ?z a b n
|
| linspace [Lacaml_D.Vec] | linspace ?z a b n
|
| linspace [Lacaml_S.Vec] | linspace ?z a b n
|
| liwork_str [Lacaml_utils] | |
| 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.
|
| 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.
|
| logspace [Lacaml_Z.Vec] | logspace ?z a b base n
|
| logspace [Lacaml_C.Vec] | logspace ?z a b base n
|
| logspace [Lacaml_D.Vec] | logspace ?z a b base n
|
| logspace [Lacaml_S.Vec] | logspace ?z a b base n
|
| lsc [Lacaml_io.Toplevel] | |
| lwork_str [Lacaml_utils] | |
M | |
| m_str [Lacaml_utils] | |
| make [Lacaml_Z.Mat] | make m n x
|
| make [Lacaml_Z.Vec] | make n x
|
| make [Lacaml_C.Mat] | make m n x
|
| make [Lacaml_C.Vec] | make n x
|
| make [Lacaml_D.Mat] | make m n x
|
| make [Lacaml_D.Vec] | make n x
|
| make [Lacaml_S.Mat] | make m n x
|
| make [Lacaml_S.Vec] | make n x
|
| make0 [Lacaml_Z.Mat] | make0 m n x
|
| make0 [Lacaml_Z.Vec] | make0 n x
|
| make0 [Lacaml_C.Mat] | make0 m n x
|
| make0 [Lacaml_C.Vec] | make0 n x
|
| make0 [Lacaml_D.Mat] | make0 m n x
|
| make0 [Lacaml_D.Vec] | make0 n x
|
| make0 [Lacaml_S.Mat] | make0 m n x
|
| make0 [Lacaml_S.Vec] | make0 n x
|
| make_mvec [Lacaml_Z.Mat] | make_mvec m x
|
| make_mvec [Lacaml_C.Mat] | make_mvec m x
|
| make_mvec [Lacaml_D.Mat] | make_mvec m x
|
| make_mvec [Lacaml_S.Mat] | make_mvec m x
|
| map [Lacaml_Z.Mat] | map f ?m ?n ?br ?bc ?b ?ar ?ac a
|
| map [Lacaml_Z.Vec] | map f ?n ?ofsx ?incx x
|
| map [Lacaml_C.Mat] | map f ?m ?n ?br ?bc ?b ?ar ?ac a
|
| map [Lacaml_C.Vec] | map f ?n ?ofsx ?incx x
|
| map [Lacaml_D.Mat] | map f ?m ?n ?br ?bc ?b ?ar ?ac a
|
| map [Lacaml_D.Vec] | map f ?n ?ofsx ?incx x
|
| map [Lacaml_S.Mat] | map f ?m ?n ?br ?bc ?b ?ar ?ac a
|
| map [Lacaml_S.Vec] | map f ?n ?ofsx ?incx x
|
| 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_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_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_D.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.
|
| 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_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_D.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.
|
| 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_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_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.
|
| 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.
|
| mvec_of_array [Lacaml_Z.Mat] | mvec_of_array ar
|
| mvec_of_array [Lacaml_C.Mat] | mvec_of_array ar
|
| mvec_of_array [Lacaml_D.Mat] | mvec_of_array ar
|
| mvec_of_array [Lacaml_S.Mat] | mvec_of_array ar
|
| mvec_to_array [Lacaml_Z.Mat] | mvec_to_array mat
|
| mvec_to_array [Lacaml_C.Mat] | mvec_to_array mat
|
| mvec_to_array [Lacaml_D.Mat] | mvec_to_array mat
|
| mvec_to_array [Lacaml_S.Mat] | mvec_to_array mat
|
N | |
| n_str [Lacaml_utils] | |
| 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_C.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.
|
| neg [Lacaml_S.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_Z] | nrm2 ?n ?ofsx ?incx x see BLAS documentation!
|
| nrm2 [Lacaml_C] | nrm2 ?n ?ofsx ?incx x see BLAS documentation!
|
| nrm2 [Lacaml_D] | nrm2 ?n ?ofsx ?incx x see BLAS documentation!
|
| nrm2 [Lacaml_S] | nrm2 ?n ?ofsx ?incx x see BLAS documentation!
|
O | |
| of_array [Lacaml_Z.Mat] | of_array ar
|
| of_array [Lacaml_Z.Vec] | of_array ar
|
| of_array [Lacaml_C.Mat] | of_array ar
|
| of_array [Lacaml_C.Vec] | of_array ar
|
| of_array [Lacaml_D.Mat] | of_array ar
|
| of_array [Lacaml_D.Vec] | of_array ar
|
| of_array [Lacaml_S.Mat] | of_array ar
|
| of_array [Lacaml_S.Vec] | of_array ar
|
| of_col_vecs [Lacaml_Z.Mat] | of_col_vecs ar
|
| of_col_vecs [Lacaml_C.Mat] | of_col_vecs ar
|
| of_col_vecs [Lacaml_D.Mat] | of_col_vecs ar
|
| of_col_vecs [Lacaml_S.Mat] | of_col_vecs ar
|
| of_diag [Lacaml_Z.Mat] | of_diag v
|
| of_diag [Lacaml_C.Mat] | of_diag v
|
| of_diag [Lacaml_D.Mat] | of_diag v
|
| of_diag [Lacaml_S.Mat] | of_diag v
|
| of_list [Lacaml_Z.Vec] | of_list l
|
| of_list [Lacaml_C.Vec] | of_list l
|
| of_list [Lacaml_D.Vec] | of_list l
|
| of_list [Lacaml_S.Vec] | of_list l
|
| one [Lacaml_complex64] | |
| one [Lacaml_complex32] | |
| one [Lacaml_float64] | |
| one [Lacaml_float32] | |
| orgqr [Lacaml_D] | orgqr ?m ?n ?k ?work ~tau ?ar ?ac a see LAPACK documentation!
|
| orgqr [Lacaml_S] | 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_D] | orgqr_min_lwork ~n
|
| orgqr_min_lwork [Lacaml_S] | orgqr_min_lwork ~n
|
| orgqr_opt_lwork [Lacaml_D] | orgqr_opt_lwork ?m ?n ?k ~tau ?ar ?ac a
|
| orgqr_opt_lwork [Lacaml_S] | orgqr_opt_lwork ?m ?n ?k ~tau ?ar ?ac a
|
| ormqr [Lacaml_D] | ormqr ?side ?trans ?m ?n ?k ?work ~tau ?ar ?ac a ?cr ?cc c
see LAPACK documentation!
|
| ormqr [Lacaml_S] | 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_D] | ormqr_opt_lwork ?side ?trans ?m ?n ?k ~tau ?ar ?ac a ?cr ?cc c
|
| ormqr_opt_lwork [Lacaml_S] | ormqr_opt_lwork ?side ?trans ?m ?n ?k ~tau ?ar ?ac a ?cr ?cc c
|
P | |
| packed [Lacaml_Z.Mat] | packed ?up ?n ?ar ?ac a
|
| packed [Lacaml_C.Mat] | packed ?up ?n ?ar ?ac a
|
| packed [Lacaml_D.Mat] | packed ?up ?n ?ar ?ac a
|
| packed [Lacaml_S.Mat] | packed ?up ?n ?ar ?ac a
|
| pascal [Lacaml_D.Mat] | pascal n
|
| pascal [Lacaml_S.Mat] | pascal n
|
| 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_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_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.
|
| 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.
|
| pocon [Lacaml_Z] | pocon ?n ?up ?anorm ?work ?rwork ?ar ?ac a
|
| pocon [Lacaml_C] | pocon ?n ?up ?anorm ?work ?rwork ?ar ?ac a
|
| pocon [Lacaml_D] | pocon ?n ?up ?anorm ?work ?iwork ?ar ?ac a
|
| pocon [Lacaml_S] | pocon ?n ?up ?anorm ?work ?iwork ?ar ?ac a
|
| pocon_min_liwork [Lacaml_D] | pocon_min_liwork n
|
| pocon_min_liwork [Lacaml_S] | pocon_min_liwork n
|
| pocon_min_lrwork [Lacaml_Z] | pocon_min_lrwork n
|
| pocon_min_lrwork [Lacaml_C] | pocon_min_lrwork n
|
| pocon_min_lwork [Lacaml_Z] | pocon_min_lwork n
|
| pocon_min_lwork [Lacaml_C] | pocon_min_lwork n
|
| pocon_min_lwork [Lacaml_D] | pocon_min_lwork n
|
| pocon_min_lwork [Lacaml_S] | pocon_min_lwork n
|
| 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_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_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.
|
| 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.
|
| 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_C] | 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 [Lacaml_S] | 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_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_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_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.
|
| 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.
|
| 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_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_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 [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_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] |
fprintf ppf "%G" el
|
| 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] |
fprintf ppf "%ld" el
|
| 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_Z] |
Pretty-printer for matrices.
|
| pp_mat [Lacaml_C] |
Pretty-printer for matrices.
|
| pp_mat [Lacaml_D] |
Pretty-printer for matrices.
|
| pp_mat [Lacaml_S] |
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_Z] | pp_num ppf el is equivalent to fprintf ppf "(%G, %Gi)"
el.re el.im.
|
| pp_num [Lacaml_C] | pp_num ppf el is equivalent to fprintf ppf "(%G, %Gi)"
el.re el.im.
|
| pp_num [Lacaml_D] | pp_num ppf el is equivalent to fprintf ppf "%G" el.
|
| pp_num [Lacaml_S] | 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_Z] |
Pretty-printer for column vectors.
|
| pp_vec [Lacaml_C] |
Pretty-printer for column vectors.
|
| pp_vec [Lacaml_D] |
Pretty-printer for column vectors.
|
| pp_vec [Lacaml_S] |
Pretty-printer for column vectors.
|
| 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_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_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.
|
| 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.
|
| prec [Lacaml_complex64] | |
| prec [Lacaml_complex32] | |
| prec [Lacaml_float64] | |
| prec [Lacaml_float32] | |
| prec [Lacaml_Z] |
Precision for this submodule
Z.
|
| prec [Lacaml_C] |
Precision for this submodule
C.
|
| prec [Lacaml_D] |
Precision for this submodule
D.
|
| prec [Lacaml_S] |
Precision for this submodule
S.
|
| 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_C.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.
|
| prod [Lacaml_S.Vec] | prod ?n ?ofsx ?incx x computes the product of the n elements
in vector x, separated by incx incremental steps.
|
| 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_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_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.
|
| 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.
|
R | |
| 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_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_D.Mat] | random ?rnd_state ?from ?range m n
|
| random [Lacaml_D.Vec] | random ?rnd_state ?from ?range n
|
| random [Lacaml_S.Mat] | random ?rnd_state ?from ?range m n
|
| random [Lacaml_S.Vec] | random ?rnd_state ?from ?range n
|
| 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_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_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.
|
| 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.
|
| rev [Lacaml_Z.Vec] | rev x reverses vector x (non-destructive).
|
| rev [Lacaml_C.Vec] | rev x reverses vector x (non-destructive).
|
| rev [Lacaml_D.Vec] | rev x reverses vector x (non-destructive).
|
| rev [Lacaml_S.Vec] | rev x reverses vector x (non-destructive).
|
| rosser [Lacaml_D.Mat] | rosser n
|
| rosser [Lacaml_S.Mat] | rosser n
|
S | |
| s_str [Lacaml_utils] | |
| 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 [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_min_lwork [Lacaml_D] | sbev_min_lwork n
|
| sbev_min_lwork [Lacaml_S] | sbev_min_lwork n
|
| 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.
|
| 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.
|
| sbmv [Lacaml_D] | sbmv ?n ?k ?ofsy ?incy ?y ?ar ?ac a ?up ?alpha ?beta ?ofsx ?incx x see
BLAS documentation!
|
| sbmv [Lacaml_S] | sbmv ?n ?k ?ofsy ?incy ?y ?ar ?ac a ?up ?alpha ?beta ?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_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_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 [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_cols [Lacaml_Z.Mat] | scal_cols ?m ?n ?ar ?ac a ?ofs alphas column-wise scal
function for matrices.
|
| scal_cols [Lacaml_C.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_cols [Lacaml_S.Mat] | scal_cols ?m ?n ?ar ?ac a ?ofs alphas column-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_C.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.
|
| scal_rows [Lacaml_S.Mat] | scal_rows ?m ?n ?ofs alphas ?ar ?ac a row-wise scal
function for matrices.
|
| set_dim_defaults [Lacaml_io.Context] | |
| 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.
|
| 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.
|
| 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_C.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.
|
| sort [Lacaml_S.Vec] | sort ?cmp ?n ?ofsx ?incx x sorts the array x in increasing
order according to the comparison function cmp.
|
| 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_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_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.
|
| 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.
|
| 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 [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_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_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_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.
|
| 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.
|
| 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.
|
| 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.
|
| 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_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_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 [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_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_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_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.
|
| 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.
|
| 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_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_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.
|
| 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.
|
| 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_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_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.
|
| 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.
|
| swap [Lacaml_Z] | swap ?n ?ofsx ?incx ~x ?ofsy ?incy y see BLAS documentation!
|
| swap [Lacaml_C] | 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!
|
| swap [Lacaml_S] | swap ?n ?ofsx ?incx ~x ?ofsy ?incy y see BLAS documentation!
|
| sycon [Lacaml_Z] | sycon ?n ?up ?ipiv ?anorm ?work ?ar ?ac a
|
| sycon [Lacaml_C] | sycon ?n ?up ?ipiv ?anorm ?work ?ar ?ac a
|
| sycon [Lacaml_D] | sycon ?n ?up ?ipiv ?anorm ?work ?iwork ?ar ?ac a
|
| sycon [Lacaml_S] | sycon ?n ?up ?ipiv ?anorm ?work ?iwork ?ar ?ac a
|
| sycon_min_liwork [Lacaml_D] | sycon_min_liwork n
|
| sycon_min_liwork [Lacaml_S] | sycon_min_liwork n
|
| sycon_min_lwork [Lacaml_Z] | sycon_min_lwork n
|
| sycon_min_lwork [Lacaml_C] | sycon_min_lwork n
|
| sycon_min_lwork [Lacaml_D] | sycon_min_lwork n
|
| sycon_min_lwork [Lacaml_S] | sycon_min_lwork n
|
| 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 [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_min_lwork [Lacaml_D] | syev_min_lwork n
|
| syev_min_lwork [Lacaml_S] | syev_min_lwork n
|
| syev_opt_lwork [Lacaml_D] | syev_opt_lwork ?n ?vectors ?up ?ar ?ac a
|
| syev_opt_lwork [Lacaml_S] | syev_opt_lwork ?n ?vectors ?up ?ar ?ac 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 [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_min_liwork [Lacaml_D] | syevd_min_liwork vectors n
|
| syevd_min_liwork [Lacaml_S] | syevd_min_liwork vectors n
|
| syevd_min_lwork [Lacaml_D] | syevd_min_lwork vectors n
|
| syevd_min_lwork [Lacaml_S] | syevd_min_lwork vectors n
|
| syevd_opt_l_li_work [Lacaml_D] | syevd_opt_l_li_iwork ?n ?vectors ?up ?ar ?ac a
|
| syevd_opt_l_li_work [Lacaml_S] | syevd_opt_l_li_iwork ?n ?vectors ?up ?ar ?ac a
|
| syevd_opt_liwork [Lacaml_D] | syevd_opt_liwork ?n ?vectors ?up ?ar ?ac a
|
| syevd_opt_liwork [Lacaml_S] | syevd_opt_liwork ?n ?vectors ?up ?ar ?ac a
|
| syevd_opt_lwork [Lacaml_D] | syevd_opt_lwork ?n ?vectors ?up ?ar ?ac a
|
| syevd_opt_lwork [Lacaml_S] | syevd_opt_lwork ?n ?vectors ?up ?ar ?ac a
|
| 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 [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_min_liwork [Lacaml_D] | syevr_min_liwork n
|
| syevr_min_liwork [Lacaml_S] | syevr_min_liwork n
|
| syevr_min_lwork [Lacaml_D] | syevr_min_lwork n
|
| syevr_min_lwork [Lacaml_S] | syevr_min_lwork n
|
| syevr_opt_l_li_work [Lacaml_D] | syevr_opt_l_li_iwork ?n ?vectors ?range ?up ?abstol ?ar ?ac a
|
| syevr_opt_l_li_work [Lacaml_S] | syevr_opt_l_li_iwork ?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_liwork [Lacaml_S] | syevr_opt_liwork ?n ?vectors ?range ?up ?abstol ?ar ?ac a
|
| syevr_opt_lwork [Lacaml_D] | syevr_opt_lwork ?n ?vectors ?range ?up ?abstol ?ar ?ac a
|
| syevr_opt_lwork [Lacaml_S] | syevr_opt_lwork ?n ?vectors ?range ?up ?abstol ?ar ?ac a
|
| 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 [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_opt_lwork [Lacaml_D] | sygv_opt_lwork ?n ?vectors ?up ?ar ?ac a ?br ?bc b
|
| sygv_opt_lwork [Lacaml_S] | sygv_opt_lwork ?n ?vectors ?up ?ar ?ac a ?br ?bc b
|
| symm [Lacaml_Z] | symm ?m ?n ?side ?up ?beta ?cr ?cc ?c ?alpha ?ar ?ac a ?br ?bc b
see BLAS documentation!
|
| symm [Lacaml_C] | 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!
|
| symm [Lacaml_S] | symm ?m ?n ?side ?up ?beta ?cr ?cc ?c ?alpha ?ar ?ac a ?br ?bc b
see BLAS documentation!
|
| 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_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_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.
|
| 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.
|
| symm_get_params [Lacaml_utils] | |
| symv [Lacaml_Z] | symv ?n ?beta ?ofsy ?incy ?y ?up ?alpha ?ar ?ac a ?ofsx ?incx x
see BLAS documentation!
|
| symv [Lacaml_C] | 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 [Lacaml_S] | symv ?n ?beta ?ofsy ?incy ?y ?up ?alpha ?ar ?ac a ?ofsx ?incx x
see BLAS documentation!
|
| symv_get_params [Lacaml_utils] | |
| syr [Lacaml_D] | syr ?n ?alpha ?up ?ofsx ?incx x ?ar ?ac a see BLAS documentation!
|
| syr [Lacaml_S] | syr ?n ?alpha ?up ?ofsx ?incx x ?ar ?ac a 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_C] | 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 [Lacaml_S] | 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_Z] | syrk ?n ?k ?up ?beta ?cr ?cc ?c ?trans ?alpha ?ar ?ac a
see BLAS documentation!
|
| syrk [Lacaml_C] | 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 [Lacaml_S] | syrk ?n ?k ?up ?beta ?cr ?cc ?c ?trans ?alpha ?ar ?ac a
see BLAS documentation!
|
| 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_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_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_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_get_params [Lacaml_utils] | |
| 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_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_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.
|
| 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.
|
| 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_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_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 [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_opt_lwork [Lacaml_Z] | sysv_opt_lwork ?n ?up ?ar ?ac a ?nrhs ?br ?bc b
|
| sysv_opt_lwork [Lacaml_C] | 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
|
| sysv_opt_lwork [Lacaml_S] | sysv_opt_lwork ?n ?up ?ar ?ac a ?nrhs ?br ?bc b
|
| 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_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_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 [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_err [Lacaml_utils] | |
| sytrf_fact_err [Lacaml_utils] | |
| sytrf_get_ipiv [Lacaml_utils] | |
| sytrf_min_lwork [Lacaml_Z] | sytrf_min_lwork ()
|
| sytrf_min_lwork [Lacaml_C] | sytrf_min_lwork ()
|
| sytrf_min_lwork [Lacaml_D] | sytrf_min_lwork ()
|
| sytrf_min_lwork [Lacaml_S] | sytrf_min_lwork ()
|
| sytrf_opt_lwork [Lacaml_Z] | sytrf_opt_lwork ?n ?up ?ar ?ac a
|
| sytrf_opt_lwork [Lacaml_C] | sytrf_opt_lwork ?n ?up ?ar ?ac a
|
| sytrf_opt_lwork [Lacaml_D] | sytrf_opt_lwork ?n ?up ?ar ?ac a
|
| sytrf_opt_lwork [Lacaml_S] | sytrf_opt_lwork ?n ?up ?ar ?ac a
|
| 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_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_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 [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_min_lwork [Lacaml_Z] | sytri_min_lwork n
|
| sytri_min_lwork [Lacaml_C] | sytri_min_lwork n
|
| sytri_min_lwork [Lacaml_D] | sytri_min_lwork n
|
| sytri_min_lwork [Lacaml_S] | sytri_min_lwork n
|
| 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_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_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.
|
| 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.
|
T | |
| tau_str [Lacaml_utils] | |
| 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_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_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 [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_err [Lacaml_utils] | |
| to_array [Lacaml_Z.Mat] | to_array mat
|
| to_array [Lacaml_Z.Vec] | to_array v
|
| to_array [Lacaml_C.Mat] | to_array mat
|
| to_array [Lacaml_C.Vec] | to_array v
|
| to_array [Lacaml_D.Mat] | to_array mat
|
| to_array [Lacaml_D.Vec] | to_array v
|
| to_array [Lacaml_S.Mat] | to_array mat
|
| to_array [Lacaml_S.Vec] | to_array v
|
| to_col_vecs [Lacaml_Z.Mat] | to_col_vecs mat
|
| to_col_vecs [Lacaml_C.Mat] | to_col_vecs mat
|
| to_col_vecs [Lacaml_D.Mat] | to_col_vecs mat
|
| to_col_vecs [Lacaml_S.Mat] | to_col_vecs mat
|
| to_list [Lacaml_Z.Vec] | to_list v
|
| to_list [Lacaml_C.Vec] | to_list v
|
| to_list [Lacaml_D.Vec] | to_list v
|
| to_list [Lacaml_S.Vec] | to_list v
|
| toeplitz [Lacaml_D.Mat] | toeplitz v
|
| toeplitz [Lacaml_S.Mat] | toeplitz v
|
| tpXv_get_params [Lacaml_utils] | |
| tpmv [Lacaml_Z] | tpmv ?n ?trans ?diag ?up ?ofsap ap ?ofsx ?incx x
see BLAS documentation!
|
| tpmv [Lacaml_C] | 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!
|
| tpmv [Lacaml_S] | tpmv ?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_C] | 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!
|
| tpsv [Lacaml_S] | 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_Z.Mat] | trace m
|
| trace [Lacaml_C.Mat] | trace m
|
| trace [Lacaml_D.Mat] | trace m
|
| trace [Lacaml_S.Mat] | trace m
|
| transpose [Lacaml_Z.Mat] | transpose ?m ?n ?ar ?ac aa
|
| transpose [Lacaml_C.Mat] | transpose ?m ?n ?ar ?ac aa
|
| transpose [Lacaml_D.Mat] | transpose ?m ?n ?ar ?ac aa
|
| transpose [Lacaml_S.Mat] | transpose ?m ?n ?ar ?ac aa
|
| 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_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_D.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.
|
| trmm [Lacaml_Z] | trmm ?m ?n ?side ?up ?transa ?diag ?alpha ?ar ?ac ~a ?br ?bc b
see BLAS documentation!
|
| trmm [Lacaml_C] | 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!
|
| trmm [Lacaml_S] | trmm ?m ?n ?side ?up ?transa ?diag ?alpha ?ar ?ac ~a ?br ?bc b
see BLAS documentation!
|
| trmv [Lacaml_Z] | trmv ?n ?trans ?diag ?up ?ar ?ac a ?ofsx ?incx x
see BLAS documentation!
|
| trmv [Lacaml_C] | 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!
|
| trmv [Lacaml_S] | trmv ?n ?trans ?diag ?up ?ar ?ac a ?ofsx ?incx x
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_C] | 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!
|
| trsm [Lacaml_S] | trsm ?m ?n ?side ?up ?transa ?diag ?alpha ?ar ?ac ~a ?br ?bc b
see BLAS documentation!
|
| trsv [Lacaml_Z] | trsv ?n ?trans ?diag ?up ?ar ?ac a ?ofsx ?incx x
see BLAS documentation!
|
| trsv [Lacaml_C] | 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!
|
| trsv [Lacaml_S] | trsv ?n ?trans ?diag ?up ?ar ?ac a ?ofsx ?incx x
see BLAS documentation!
|
| trtri [Lacaml_Z] | trtri ?n ?up ?diag ?ar ?ac a computes the inverse of a real
upper or lower triangular matrix a.
|
| trtri [Lacaml_C] | 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 [Lacaml_S] | 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_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_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_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 [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_err [Lacaml_utils] | |
U | |
| u_str [Lacaml_utils] | |
| um_str [Lacaml_utils] | |
| un_str [Lacaml_utils] | |
| unpacked [Lacaml_Z.Mat] | unpacked ?up x
|
| unpacked [Lacaml_C.Mat] | unpacked ?up x
|
| unpacked [Lacaml_D.Mat] | unpacked ?up x
|
| unpacked [Lacaml_S.Mat] | unpacked ?up x
|
V | |
| vandermonde [Lacaml_D.Mat] | vandermonde v
|
| vandermonde [Lacaml_S.Mat] | vandermonde v
|
| version [Lacaml_version] | |
| vertical_default [Lacaml_io.Context] | |
| vm_str [Lacaml_utils] | |
| vn_str [Lacaml_utils] | |
| vt_str [Lacaml_utils] | |
W | |
| w_str [Lacaml_utils] | |
| wi_str [Lacaml_utils] | |
| wilkinson [Lacaml_D.Mat] | wilkinson n
|
| wilkinson [Lacaml_S.Mat] | wilkinson n
|
| 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_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_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_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.
|
| 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.
|
| 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_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_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.
|
| 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.
|