Index of values

add ?z (x1, x2, ..., xn) (y1, y2, ..., yn) returns (x1 + y1, x2 + y2, ..., xn + yn).

add ?z (x1, x2, ..., xn) (y1, y2, ..., yn) returns (x1 + y1, x2 + y2, ..., xn + yn).

add ?z (x1, x2, ..., xn) (y1, y2, ..., yn) returns (x1 + y1, x2 + y2, ..., xn + yn).

add ?z (x1, x2, ..., xn) (y1, y2, ..., yn) returns (x1 + y1, x2 + y2, ..., xn + yn).

add m n

add_const c ?b a adds constant value c to all elements in a.

add_const c ?y x adds constant value c to all elements in vector x.

add_const c ?b a adds constant value c to all elements in a.

add_const c ?y x adds constant value c to all elements in vector x.

add_const c ?b a adds constant value c to all elements in a.

add_const c ?y x adds constant value c to all elements in vector x.

add_const c ?b a adds constant value c to all elements in a.

add_const c ?y x adds constant value c to all elements in vector x.

amax x finds the maximum value of all elements in x.

amax x finds the maximum value of all elements in x.

amax x finds the maximum value of all elements in x.

amax x finds the maximum value of all elements in x.

Concatenate two vectors.

Concatenate two vectors.

Concatenate two vectors.

Concatenate two vectors.

Concatenate two vectors.

as_vec a

as_vec a

as_vec a

as_vec a

as_vec a

asum x

asum x

axpy ?alpha x y computes y := alpha * x + y.

axpy ?alpha x y executes y := alpha * x + y with scalar value alpha, and vectors x and y.

axpy ?alpha x y computes y := alpha * x + y.

axpy ?alpha x y executes y := alpha * x + y with scalar value alpha, and vectors x and y.

axpy ?alpha x y computes y := alpha * x + y.

axpy ?alpha x y executes y := alpha * x + y with scalar value alpha, and vectors x and y.

axpy ?alpha x y computes y := alpha * x + y.

axpy ?alpha x y executes y := alpha * x + y with scalar value alpha, and vectors x and y.

Return a character of a flag (for BLAS/LAPACK).

Return a character of a flag (for BLAS/LAPACK).

Return a character of a flag (for BLAS/LAPACK).

Return a character of a flag (for BLAS/LAPACK).

Return a character of a flag (for BLAS/LAPACK).

Return a character of a flag (for BLAS/LAPACK).

Auxiliary function (used internally)

Recover polymorphism of the fifth type parameter.

Recover polymorphism of the fourth type parameter.

Recover polymorphism of the fifth type parameter.

Recover polymorphism of the fourth type parameter.

Recover polymorphism of the fifth type parameter.

Recover polymorphism of the fourth type parameter.

Recover polymorphism of the fifth type parameter.

Recover polymorphism of the fourth type parameter.

Recover polymorphism of the fifth type parameter.

Recover polymorphism of the fourth type parameter.

col_dyn a i

col_dyn a i

col_dyn a i

col_dyn a i

col_dyn a i

Conjugate transpose of a matrix.

cons ?y e x adds element e at the beginning of vector x, and copies it into y.

cons ?y e x adds element e at the beginning of vector x, and copies it into y.

cons ?y e x adds element e at the beginning of vector x, and copies it into y.

cons ?y e x adds element e at the beginning of vector x, and copies it into y.

cons ?y e x adds element e at the beginning of vector x, and copies it into y.

copy ?uplo ?b a copies the matrix a into the matrix b with the LAPACK function lacpy.

copy ?y x copies the vector x to the vector y with the BLAS-1 function [sdcz]copy.

copy ?y x copies x into y.

copy ?uplo ?b a copies the matrix a into the matrix b with the LAPACK function lacpy.

copy ?y x copies the vector x to the vector y with the BLAS-1 function [sdcz]copy.

copy ?y x copies x into y.

copy ?uplo ?b a copies the matrix a into the matrix b with the LAPACK function lacpy.

copy ?y x copies the vector x to the vector y with the BLAS-1 function [sdcz]copy.

copy ?y x copies x into y.

copy ?uplo ?b a copies the matrix a into the matrix b with the LAPACK function lacpy.

copy ?y x copies the vector x to the vector y with the BLAS-1 function [sdcz]copy.

copy ?y x copies x into y.

copy ?b a copies the matrix a into the matrix b.

copy ?y x copies the vector x to the vector y.

copy_diag a is Vec.copy (Mat.diag a).

copy_diag a is Vec.copy (Mat.diag a).

copy_diag a is Vec.copy (Mat.diag a).

copy_diag a is Vec.copy (Mat.diag a).

copy_diag_rect a is Vec.copy (Mat.diag_rect a).

copy_diag_rect a is Vec.copy (Mat.diag_rect a).

copy_diag_rect a is Vec.copy (Mat.diag_rect a).

copy_diag_rect a is Vec.copy (Mat.diag_rect a).

copy_row_dyn a i is Vec.copy (Mat.row_dyn a i).

copy_row_dyn a i is Vec.copy (Mat.row_dyn a i).

copy_row_dyn a i is Vec.copy (Mat.row_dyn a i).

copy_row_dyn a i is Vec.copy (Mat.row_dyn a i).

cos ?y (x1, x2, ..., xn) returns (cos x1, cos x2, ..., cos xn).

cos ?y (x1, x2, ..., xn) returns (cos x1, cos x2, ..., cos xn).

create m n

create n

create m n

create n

create m n

create n

create m n

create n

create kind m n

create kind n

detri ?up a converts triangular matrix a to a symmetric matrix, i.e., copies the upper or lower triangular part of a into another part.

detri ?up a converts triangular matrix a to a symmetric matrix, i.e., copies the upper or lower triangular part of a into another part.

detri ?up a converts triangular matrix a to a symmetric matrix, i.e., copies the upper or lower triangular part of a into another part.

detri ?up a converts triangular matrix a to a symmetric matrix, i.e., copies the upper or lower triangular part of a into another part.

diag a

diag a

diag a

diag a

diag a

diag_rect a

diag_rect a

diag_rect a

diag_rect a

diag_rect a

dim a is (dim1 a, dim2 a).

dim x

dim a is (dim1 a, dim2 a).

dim x

dim a is (dim1 a, dim2 a).

dim x

dim a is (dim1 a, dim2 a).

dim x

dim a is (dim1 a, dim2 a).

dim x

dim1 a

dim1 a

dim1 a

dim1 a

dim1 a

dim1 a

dim1 a

dim1 a

dim1 a

dim1 a

dim_array_array aa returns Some (n_rows, n_cols) with the number of rows n_rows and the number of columns n_cols of the given array of arrays.

dim_list list ll returns Some (n_rows, n_cols) with the number of rows n_rows and the number of columns n_cols of the given list of lists.

div ?z (x1, x2, ..., xn) (y1, y2, ..., yn) returns (x1 / y1, x2 / y2, ..., xn / yn).

div ?z (x1, x2, ..., xn) (y1, y2, ..., yn) returns (x1 / y1, x2 / y2, ..., xn / yn).

div ?z (x1, x2, ..., xn) (y1, y2, ..., yn) returns (x1 / y1, x2 / y2, ..., xn / yn).

div ?z (x1, x2, ..., xn) (y1, y2, ..., yn) returns (x1 / y1, x2 / y2, ..., xn / yn).

div_dyn m n

dot x y

dot x y

dotc x y computes x^H y.

dotc x y computes x^H y.

dotc x y computes x^T y.

dotc x y computes x^T y.

default = "..."

An empty matrix.

An empty vector.

An empty matrix.

An empty vector.

An empty matrix.

An empty vector.

An empty matrix.

An empty vector.

exists p (x1, x2, ..., xn) is (p x1) || (p x2) || ... || (p xn).

exists p (x1, x2, ..., xn) is (p x1) || (p x2) || ... || (p xn).

exists p (x1, x2, ..., xn) is (p x1) || (p x2) || ... || (p xn).

exists p (x1, x2, ..., xn) is (p x1) || (p x2) || ... || (p xn).

exists p (x1, x2, ..., xn) is (p x1) || (p x2) || ... || (p xn).

exists2 p (x1, x2, ..., xn) (y1, y2, ..., yn) is (p x1 y1) || (p x2 y2) || ... || (p xn yn).

exists2 p (x1, x2, ..., xn) (y1, y2, ..., yn) is (p x1 y1) || (p x2 y2) || ... || (p xn yn).

exists2 p (x1, x2, ..., xn) (y1, y2, ..., yn) is (p x1 y1) || (p x2 y2) || ... || (p xn yn).

exists2 p (x1, x2, ..., xn) (y1, y2, ..., yn) is (p x1 y1) || (p x2 y2) || ... || (p xn yn).

exists2 p (x1, x2, ..., xn) (y1, y2, ..., yn) is (p x1 y1) || (p x2 y2) || ... || (p xn yn).

exp ?y (x1, x2, ..., xn) returns (exp x1, exp x2, ..., exp xn).

exp ?y (x1, x2, ..., xn) returns (exp x1, exp x2, ..., exp xn).

failwith + printf-style format

Fill the given matrix with the given value.

Fill the given vector with the given value.

Fill the given matrix with the given value.

Fill the given vector with the given value.

Fill the given matrix with the given value.

Fill the given vector with the given value.

Fill the given matrix with the given value.

Fill the given vector with the given value.

Fill the given matrix with the given value.

Fill the given vector with the given value.

fold_bottom f a init folds row vectors of matrix a by f in the order bottom to top.

fold_bottom f a init folds row vectors of matrix a by f in the order bottom to top.

fold_bottom f a init folds row vectors of matrix a by f in the order bottom to top.

fold_bottom f a init folds row vectors of matrix a by f in the order bottom to top.

fold_bottom f a init folds row vectors of matrix a by f in the order bottom to top.

fold_bottomi f a init folds row vectors of matrix a by f in the order bottom to top.

fold_bottomi f a init folds row vectors of matrix a by f in the order bottom to top.

fold_bottomi f a init folds row vectors of matrix a by f in the order bottom to top.

fold_bottomi f a init folds row vectors of matrix a by f in the order bottom to top.

fold_bottomi f a init folds row vectors of matrix a by f in the order bottom to top.

fold_left f init a folds column vectors of matrix a by f in the order left to right.

fold_left f init (x1, x2, ..., xn) is f (... (f (f init x1) x2) ...) xn.

fold_left f init a folds column vectors of matrix a by f in the order left to right.

fold_left f init (x1, x2, ..., xn) is f (... (f (f init x1) x2) ...) xn.

fold_left f init a folds column vectors of matrix a by f in the order left to right.

fold_left f init (x1, x2, ..., xn) is f (... (f (f init x1) x2) ...) xn.

fold_left f init a folds column vectors of matrix a by f in the order left to right.

fold_left f init (x1, x2, ..., xn) is f (... (f (f init x1) x2) ...) xn.

fold_left f init a folds column vectors of matrix a by f in the order left to right.

fold_left f init (x1, x2, ..., xn) is f (... (f (f init x1) x2) ...) xn.

fold_left f init n is f (... (f (f init 1) 2) ...) n.

fold_left2 f init (x1, x2, ..., xn) (y1, y2, ..., yn) is f (... (f (f init x1 y1) x2 y2) ...) xn yn.

fold_left2 f init (x1, x2, ..., xn) (y1, y2, ..., yn) is f (... (f (f init x1 y1) x2 y2) ...) xn yn.

fold_left2 f init (x1, x2, ..., xn) (y1, y2, ..., yn) is f (... (f (f init x1 y1) x2 y2) ...) xn yn.

fold_left2 f init (x1, x2, ..., xn) (y1, y2, ..., yn) is f (... (f (f init x1 y1) x2 y2) ...) xn yn.

fold_left2 f init (x1, x2, ..., xn) (y1, y2, ..., yn) is f (... (f (f init x1 y1) x2 y2) ...) xn yn.

fold_left3 f init (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is f (... (f (f init x1 y1 z1) x2 y2 z2) ...) xn yn zn.

fold_left3 f init (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is f (... (f (f init x1 y1 z1) x2 y2 z2) ...) xn yn zn.

fold_left3 f init (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is f (... (f (f init x1 y1 z1) x2 y2 z2) ...) xn yn zn.

fold_left3 f init (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is f (... (f (f init x1 y1 z1) x2 y2 z2) ...) xn yn zn.

fold_left3 f init (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is f (... (f (f init x1 y1 z1) x2 y2 z2) ...) xn yn zn.

fold_lefti f init a folds column vectors of matrix a by f in the order left to right.

fold_lefti f init (x1, x2, ..., xn) is f n (... (f 2 (f 1 init x1) x2) ...) xn with the vector's dimension n.

fold_lefti f init a folds column vectors of matrix a by f in the order left to right.

fold_lefti f init (x1, x2, ..., xn) is f n (... (f 2 (f 1 init x1) x2) ...) xn with the vector's dimension n.

fold_lefti f init a folds column vectors of matrix a by f in the order left to right.

fold_lefti f init (x1, x2, ..., xn) is f n (... (f 2 (f 1 init x1) x2) ...) xn with the vector's dimension n.

fold_lefti f init a folds column vectors of matrix a by f in the order left to right.

fold_lefti f init (x1, x2, ..., xn) is f n (... (f 2 (f 1 init x1) x2) ...) xn with the vector's dimension n.

fold_lefti f init a folds column vectors of matrix a by f in the order left to right.

fold_lefti f init (x1, x2, ..., xn) is f n (... (f 2 (f 1 init x1) x2) ...) xn with the vector's dimension n.

fold_lefti f init n is f (... (f (f init 1) 2) ...) (to_int n).

fold_lefti2 f init (x1, x2, ..., xn) (y1, y2, ..., yn) is f n (... (f 2 (f 1 init x1 y1) x2 y2) ...) xn yn with the vectors' dimension n.

fold_lefti2 f init (x1, x2, ..., xn) (y1, y2, ..., yn) is f n (... (f 2 (f 1 init x1 y1) x2 y2) ...) xn yn with the vectors' dimension n.

fold_lefti2 f init (x1, x2, ..., xn) (y1, y2, ..., yn) is f n (... (f 2 (f 1 init x1 y1) x2 y2) ...) xn yn with the vectors' dimension n.

fold_lefti2 f init (x1, x2, ..., xn) (y1, y2, ..., yn) is f n (... (f 2 (f 1 init x1 y1) x2 y2) ...) xn yn with the vectors' dimension n.

fold_lefti2 f init (x1, x2, ..., xn) (y1, y2, ..., yn) is f n (... (f 2 (f 1 init x1 y1) x2 y2) ...) xn yn with the vectors' dimension n.

fold_lefti3 f init (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is f n (... (f 2 (f 1 init x1 y1 z1) x2 y2 z2) ...) xn yn zn with the vectors' dimension n.

fold_lefti3 f init (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is f n (... (f 2 (f 1 init x1 y1 z1) x2 y2 z2) ...) xn yn zn with the vectors' dimension n.

fold_lefti3 f init (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is f n (... (f 2 (f 1 init x1 y1 z1) x2 y2 z2) ...) xn yn zn with the vectors' dimension n.

fold_lefti3 f init (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is f n (... (f 2 (f 1 init x1 y1 z1) x2 y2 z2) ...) xn yn zn with the vectors' dimension n.

fold_lefti3 f init (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is f n (... (f 2 (f 1 init x1 y1 z1) x2 y2 z2) ...) xn yn zn with the vectors' dimension n.

fold_right f a init folds column vectors of matrix a by f in the order right to left.

fold_right f (x1, x2, ..., xn) init is f x1 (f x2 (... (f xn init) ...)).

fold_right f a init folds column vectors of matrix a by f in the order right to left.

fold_right f (x1, x2, ..., xn) init is f x1 (f x2 (... (f xn init) ...)).

fold_right f a init folds column vectors of matrix a by f in the order right to left.

fold_right f (x1, x2, ..., xn) init is f x1 (f x2 (... (f xn init) ...)).

fold_right f a init folds column vectors of matrix a by f in the order right to left.

fold_right f (x1, x2, ..., xn) init is f x1 (f x2 (... (f xn init) ...)).

fold_right f a init folds column vectors of matrix a by f in the order right to left.

fold_right f (x1, x2, ..., xn) init is f x1 (f x2 (... (f xn init) ...)).

fold_right f n init is f 1 (f 2 (... (f n init) ...)).

fold_righti2 f (x1, x2, ..., xn) (y1, y2, ..., yn) init is f x1 y1 (f x2 y2 (... (f xn yn init) ...)).

fold_righti2 f (x1, x2, ..., xn) (y1, y2, ..., yn) init is f x1 y1 (f x2 y2 (... (f xn yn init) ...)).

fold_righti2 f (x1, x2, ..., xn) (y1, y2, ..., yn) init is f x1 y1 (f x2 y2 (... (f xn yn init) ...)).

fold_righti2 f (x1, x2, ..., xn) (y1, y2, ..., yn) init is f x1 y1 (f x2 y2 (... (f xn yn init) ...)).

fold_righti2 f (x1, x2, ..., xn) (y1, y2, ..., yn) init is f x1 y1 (f x2 y2 (... (f xn yn init) ...)).

fold_right3 f (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) init is f x1 y1 z1 (f x2 y2 z2 (... (f xn yn zn init) ...)).

fold_right3 f (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) init is f x1 y1 z1 (f x2 y2 z2 (... (f xn yn zn init) ...)).

fold_right3 f (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) init is f x1 y1 z1 (f x2 y2 z2 (... (f xn yn zn init) ...)).

fold_right3 f (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) init is f x1 y1 z1 (f x2 y2 z2 (... (f xn yn zn init) ...)).

fold_right3 f (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) init is f x1 y1 z1 (f x2 y2 z2 (... (f xn yn zn init) ...)).

fold_righti f a init folds column vectors of matrix a by f in the order right to left.

fold_righti f (x1, x2, ..., xn) init is f 1 x1 (f 2 x2 (... (f n xn init) ...)) with the vector's dimension n.

fold_righti f a init folds column vectors of matrix a by f in the order right to left.

fold_righti f (x1, x2, ..., xn) init is f 1 x1 (f 2 x2 (... (f n xn init) ...)) with the vector's dimension n.

fold_righti f a init folds column vectors of matrix a by f in the order right to left.

fold_righti f (x1, x2, ..., xn) init is f 1 x1 (f 2 x2 (... (f n xn init) ...)) with the vector's dimension n.

fold_righti f a init folds column vectors of matrix a by f in the order right to left.

fold_righti f (x1, x2, ..., xn) init is f 1 x1 (f 2 x2 (... (f n xn init) ...)) with the vector's dimension n.

fold_righti f a init folds column vectors of matrix a by f in the order right to left.

fold_righti f (x1, x2, ..., xn) init is f 1 x1 (f 2 x2 (... (f n xn init) ...)) with the vector's dimension n.

fold_righti f n init is f 1 (f 2 (... (f (to_int n) init) ...)).

fold_righti2 f (x1, x2, ..., xn) (y1, y2, ..., yn) init is f 1 x1 y1 (f 2 x2 y2 (... (f n xn yn init) ...)) with the vectors' dimension n.

fold_righti2 f (x1, x2, ..., xn) (y1, y2, ..., yn) init is f 1 x1 y1 (f 2 x2 y2 (... (f n xn yn init) ...)) with the vectors' dimension n.

fold_righti2 f (x1, x2, ..., xn) (y1, y2, ..., yn) init is f 1 x1 y1 (f 2 x2 y2 (... (f n xn yn init) ...)) with the vectors' dimension n.

fold_righti2 f (x1, x2, ..., xn) (y1, y2, ..., yn) init is f 1 x1 y1 (f 2 x2 y2 (... (f n xn yn init) ...)) with the vectors' dimension n.

fold_righti2 f (x1, x2, ..., xn) (y1, y2, ..., yn) init is f 1 x1 y1 (f 2 x2 y2 (... (f n xn yn init) ...)) with the vectors' dimension n.

fold_righti3 f (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) init is f 1 x1 y1 z1 (f 2 x2 y2 z2 (... (f n xn yn zn init) ...)) with the vectors' dimension n.

fold_righti3 f (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) init is f 1 x1 y1 z1 (f 2 x2 y2 z2 (... (f n xn yn zn init) ...)) with the vectors' dimension n.

fold_righti3 f (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) init is f 1 x1 y1 z1 (f 2 x2 y2 z2 (... (f n xn yn zn init) ...)) with the vectors' dimension n.

fold_righti3 f (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) init is f 1 x1 y1 z1 (f 2 x2 y2 z2 (... (f n xn yn zn init) ...)) with the vectors' dimension n.

fold_righti3 f (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) init is f 1 x1 y1 z1 (f 2 x2 y2 z2 (... (f n xn yn zn init) ...)) with the vectors' dimension n.

fold_top f init a folds row vectors of matrix a by f in the order top to bottom.

fold_top f init a folds row vectors of matrix a by f in the order top to bottom.

fold_top f init a folds row vectors of matrix a by f in the order top to bottom.

fold_top f init a folds row vectors of matrix a by f in the order top to bottom.

fold_top f init a folds row vectors of matrix a by f in the order top to bottom.

fold_topi f init a folds row vectors of matrix a by f in the order top to bottom.

fold_topi f init a folds row vectors of matrix a by f in the order top to bottom.

fold_topi f init a folds row vectors of matrix a by f in the order top to bottom.

fold_topi f init a folds row vectors of matrix a by f in the order top to bottom.

fold_topi f init a folds row vectors of matrix a by f in the order top to bottom.

for_all p (x1, x2, ..., xn) is (p x1) && (p x2) && ... && (p xn).

for_all p (x1, x2, ..., xn) is (p x1) && (p x2) && ... && (p xn).

for_all p (x1, x2, ..., xn) is (p x1) && (p x2) && ... && (p xn).

for_all p (x1, x2, ..., xn) is (p x1) && (p x2) && ... && (p xn).

for_all p (x1, x2, ..., xn) is (p x1) && (p x2) && ... && (p xn).

for_all2 p (x1, x2, ..., xn) (y1, y2, ..., yn) is (p x1 y1) && (p x2 y2) && ... && (p xn yn).

for_all2 p (x1, x2, ..., xn) (y1, y2, ..., yn) is (p x1 y1) && (p x2 y2) && ... && (p xn yn).

for_all2 p (x1, x2, ..., xn) (y1, y2, ..., yn) is (p x1 y1) && (p x2 y2) && ... && (p xn yn).

for_all2 p (x1, x2, ..., xn) (y1, y2, ..., yn) is (p x1 y1) && (p x2 y2) && ... && (p xn yn).

for_all2 p (x1, x2, ..., xn) (y1, y2, ..., yn) is (p x1 y1) && (p x2 y2) && ... && (p xn yn).

gbmv ~m ?beta ?y ~trans ?alpha a kl ku x computes y := alpha * OP(a) * x + beta * y where a is a band matrix stored in band storage.

gbmv ~m ?beta ?y ~trans ?alpha a kl ku x computes y := alpha * OP(a) * x + beta * y where a is a band matrix stored in band storage.

gbmv ~m ?beta ?y ~trans ?alpha a kl ku x computes y := alpha * OP(a) * x + beta * y where a is a band matrix stored in band storage.

gbmv ~m ?beta ?y ~trans ?alpha a kl ku x computes y := alpha * OP(a) * x + beta * y where a is a band matrix stored in band storage.

gbsv ?ipiv ab kl ku b solves a system of linear equations A * X = B where A is a 'n-by-'n band matrix, each column of matrix B is the r.h.s.

gbsv ?ipiv ab kl ku b solves a system of linear equations A * X = B where A is a 'n-by-'n band matrix, each column of matrix B is the r.h.s.

gbsv ?ipiv ab kl ku b solves a system of linear equations A * X = B where A is a 'n-by-'n band matrix, each column of matrix B is the r.h.s.

gbsv ?ipiv ab kl ku b solves a system of linear equations A * X = B where A is a 'n-by-'n band matrix, each column of matrix B is the r.h.s.

geband_dyn kl ku ?b a converts matrix a into a matrix stored in band storage.

geband_dyn kl ku ?b a converts matrix a into a matrix stored in band storage.

geband_dyn kl ku ?b a converts matrix a into a matrix stored in band storage.

geband_dyn kl ku ?b a converts matrix a into a matrix stored in band storage.

geband_dyn kl ku ?b a converts matrix a into a matrix stored in band storage.

geband_dyn m n kl ku computs the band storage size of m-by-n band matrices with kl subdiagonals and ku superdiagonals.

gecon ?norm ?anorm ?work ?iwork a estimates the reciprocal of the condition number of general matrix a.

gecon ?norm ?anorm ?work ?iwork a estimates the reciprocal of the condition number of general matrix a.

gecon_min_liwork n computes the minimum length of workspace iwork for gecon routine.

gecon_min_liwork n computes the minimum length of workspace iwork for gecon routine.

gecon_min_lwork n computes the minimum length of workspace work for gecon routine.

gecon_min_lwork n computes the minimum length of workspace work for gecon routine.

geev ?work ?vl ?vr ?wr ?wi a computes the eigenvalues and the left and right eigenvectors of 'n-by-'n nonsymmetric matrix a:

geev ?work ?vl ?vr ?wr ?wi a computes the eigenvalues and the left and right eigenvectors of 'n-by-'n nonsymmetric matrix a:

geev_min_lwork ?vectors n computes the minimum length of workspace for geev routine.

geev_min_lwork ?vectors n computes the minimum length of workspace for geev routine.

geev_opt_lwork ?vl ?vr ?wr ?vi a computes the optimum length of workspace for geev routine.

geev_opt_lwork ?vl ?vr ?wr ?vi a computes the optimum length of workspace for geev routine.

gels ?work ~trans a b solves an overdetermined or underdetermined system of linear equations using QR or LU factorization.

gels ?work ~trans a b solves an overdetermined or underdetermined system of linear equations using QR or LU factorization.

gels ?work ~trans a b solves an overdetermined or underdetermined system of linear equations using QR or LU factorization.

gels ?work ~trans a b solves an overdetermined or underdetermined system of linear equations using QR or LU factorization.

gels_min_lwork ~n computes the minimum length of workspace for gels routine.

gels_min_lwork ~n computes the minimum length of workspace for gels routine.

gels_min_lwork ~n computes the minimum length of workspace for gels routine.

gels_min_lwork ~n computes the minimum length of workspace for gels routine.

gels_opt_lwork ~trans a b computes the optimum length of workspace for gels routine.

gels_opt_lwork ~trans a b computes the optimum length of workspace for gels routine.

gels_opt_lwork ~trans a b computes the optimum length of workspace for gels routine.

gels_opt_lwork ~trans a b computes the optimum length of workspace for gels routine.

gelsd a ?rcond ?jpvt ?work b computes the minimum-norm solution to a linear least square problem (minimize ||b - a * x||) using the singular value decomposition (SVD) of a and a divide and conquer method.

gelsd a ?rcond ?jpvt ?work b computes the minimum-norm solution to a linear least square problem (minimize ||b - a * x||) using the singular value decomposition (SVD) of a and a divide and conquer method.

gelsd_min_iwork ~m ~n ~nrhs computes the minimum length of workspace iwork for gelsd routine.

gelsd_min_iwork ~m ~n ~nrhs computes the minimum length of workspace iwork for gelsd routine.

gelsd_min_lwork ~m ~n ~nrhs computes the minimum length of workspace for gelsd routine.

gelsd_min_lwork ~m ~n ~nrhs computes the minimum length of workspace for gelsd routine.

gelsd_opt_lwork a b computes the optimum length of workspace for gelsd routine.

gelsd_opt_lwork a b computes the optimum length of workspace for gelsd routine.

gelss a ?rcond ?work b computes the minimum-norm solution to a linear least square problem (minimize ||b - a * x||) using the singular value decomposition (SVD) of a.

gelss a ?rcond ?work b computes the minimum-norm solution to a linear least square problem (minimize ||b - a * x||) using the singular value decomposition (SVD) of a.

gelss_min_lwork ~m ~n ~nrhs computes the minimum length of workspace for gelss routine.

gelss_min_lwork ~m ~n ~nrhs computes the minimum length of workspace for gelss routine.

gelss_min_lwork a b computes the optimum length of workspace for gelss routine.

gelss_min_lwork a b computes the optimum length of workspace for gelss routine.

gelsy a ?rcond ?jpvt ?work b computes the minimum-norm solution to a linear least square problem (minimize ||b - a * x||) using a complete orthogonal factorization of a.

gelsy a ?rcond ?jpvt ?work b computes the minimum-norm solution to a linear least square problem (minimize ||b - a * x||) using a complete orthogonal factorization of a.

gelsy_min_lwork ~m ~n ~nrhs computes the minimum length of workspace for gelsy routine.

gelsy_min_lwork ~m ~n ~nrhs computes the minimum length of workspace for gelsy routine.

gelsy_opt_lwork a b computes the optimum length of workspace for gelsy routine.

gelsy_opt_lwork a b computes the optimum length of workspace for gelsy routine.

gemm ?beta ?c ~transa ?alpha a ~transb b executes c := alpha * OP(a) * OP(b) + beta * c.

gemm ?beta ?c ~transa ?alpha a ~transb b executes c := alpha * OP(a) * OP(b) + beta * c.

gemm ?beta ?c ~transa ?alpha a ~transb b executes c := alpha * OP(a) * OP(b) + beta * c.

gemm ?beta ?c ~transa ?alpha a ~transb b executes c := alpha * OP(a) * OP(b) + beta * c.

gemm_diag ?beta ?y ~transa ?alpha a ~transb b executes y := DIAG(alpha * OP(a) * OP(b)) + beta * y where DIAG(x) is the vector of the diagonal elements in matrix x, and OP(x) is one of OP(x) = x, OP(x) = x^T, or OP(x) = x^H (the conjugate transpose of x).

gemm_diag ?beta ?y ~transa ?alpha a ~transb b executes y := DIAG(alpha * OP(a) * OP(b)) + beta * y where DIAG(x) is the vector of the diagonal elements in matrix x, and OP(x) is one of OP(x) = x, OP(x) = x^T, or OP(x) = x^H (the conjugate transpose of x).

gemm_diag ?beta ?y ~transa ?alpha a ~transb b executes y := DIAG(alpha * OP(a) * OP(b)) + beta * y where DIAG(x) is the vector of the diagonal elements in matrix x, and OP(x) is one of OP(x) = x, OP(x) = x^T, or OP(x) = x^H (the conjugate transpose of x).

gemm_diag ?beta ?y ~transa ?alpha a ~transb b executes y := DIAG(alpha * OP(a) * OP(b)) + beta * y where DIAG(x) is the vector of the diagonal elements in matrix x, and OP(x) is one of OP(x) = x, OP(x) = x^T, or OP(x) = x^H (the conjugate transpose of x).

gemm_trace ~transa a ~transb b

gemm_trace ~transa a ~transb b

gemm_trace ~transa a ~transb b

gemm_trace ~transa a ~transb b

gemv ?beta ?y ~trans ?alpha a x executes y := alpha * OP(a) * x + beta * y.

gemv ?beta ?y ~trans ?alpha a x executes y := alpha * OP(a) * x + beta * y.

gemv ?beta ?y ~trans ?alpha a x executes y := alpha * OP(a) * x + beta * y.

gemv ?beta ?y ~trans ?alpha a x executes y := alpha * OP(a) * x + beta * y.

geqrf ?work ?tau a computes the QR factorization of general matrix a: a = Q * R where Q is an orthogonal (unitary) matrix and R is an upper triangular matrix.

geqrf ?work ?tau a computes the QR factorization of general matrix a: a = Q * R where Q is an orthogonal (unitary) matrix and R is an upper triangular matrix.

geqrf ?work ?tau a computes the QR factorization of general matrix a: a = Q * R where Q is an orthogonal (unitary) matrix and R is an upper triangular matrix.

geqrf ?work ?tau a computes the QR factorization of general matrix a: a = Q * R where Q is an orthogonal (unitary) matrix and R is an upper triangular matrix.

geqrf_min_lwork ~n computes the minimum length of workspace for geqrf routine.

geqrf_min_lwork ~n computes the minimum length of workspace for geqrf routine.

geqrf_min_lwork ~n computes the minimum length of workspace for geqrf routine.

geqrf_min_lwork ~n computes the minimum length of workspace for geqrf routine.

geqrf_opt_lwork a computes the optimum length of workspace for geqrf routine.

geqrf_opt_lwork a computes the optimum length of workspace for geqrf routine.

geqrf_opt_lwork a computes the optimum length of workspace for geqrf routine.

geqrf_opt_lwork a computes the optimum length of workspace for geqrf routine.

ger ?alpha x y a computes a := alpha * x * y^T + a with the general matrix a, the vector x and the transposed vector y^T of y.

ger ?alpha x y a computes a := alpha * x * y^T + a with the general matrix a, the vector x and the transposed vector y^T of y.

gesdd ~jobz ?s ?u ?vt ?work ?iwork a computes the singular value decomposition (SVD) of general rectangular matrix a using a divide and conquer method: a = U * D * V^T where

gesdd ~jobz ?s ?u ?vt ?work ?iwork a computes the singular value decomposition (SVD) of general rectangular matrix a using a divide and conquer method: a = U * D * V^T where

gesdd_liwork ~m ~n computes the length of workspace iwork for gesdd routine.

gesdd_liwork ~m ~n computes the length of workspace iwork for gesdd routine.

gesdd_min_lwork ~m ~n computes the minimum length of workspace work for gesdd routine.

gesdd_min_lwork ~m ~n computes the minimum length of workspace work for gesdd routine.

gesdd_opt_lwork ~jobz ?s ?u ?vt ?iwork a computes the optimum length of workspace work for gesdd routine.

gesdd_opt_lwork ~jobz ?s ?u ?vt ?iwork a computes the optimum length of workspace work for gesdd routine.

gesv ?ipiv a b solves a system of linear equations a * x = b where a is a 'n-by-'n general matrix, each column of matrix b is the r.h.s.

gesv ?ipiv a b solves a system of linear equations a * x = b where a is a 'n-by-'n general matrix, each column of matrix b is the r.h.s.

gesv ?ipiv a b solves a system of linear equations a * x = b where a is a 'n-by-'n general matrix, each column of matrix b is the r.h.s.

gesv ?ipiv a b solves a system of linear equations a * x = b where a is a 'n-by-'n general matrix, each column of matrix b is the r.h.s.

gesvd ?jobu ?jobvt ?s ?u ?vt ?work a computes the singular value decomposition (SVD) of 'm-by-'n general rectangular matrix a: a = U * D * V^T where

gesvd ?jobu ?jobvt ?s ?u ?vt ?work a computes the singular value decomposition (SVD) of 'm-by-'n general rectangular matrix a: a = U * D * V^T where

gesvd_min_lwork ~m ~n computes the minimum length of workspace for gesvd routine.

gesvd_min_lwork ~m ~n computes the minimum length of workspace for gesvd routine.

gesvd_opt_lwork ~jobu ~jobvt ?s ?u ?vt computes the optimum length of workspace for gesvd routine.

gesvd_opt_lwork ~jobu ~jobvt ?s ?u ?vt computes the optimum length of workspace for gesvd routine.

get_dyn a i j

get_dyn x i

get_dyn a i j

get_dyn x i

get_dyn a i j

get_dyn x i

get_dyn a i j

get_dyn x i

get_dyn a i j

get_dyn x i

get_transposed_dim trans m n returns (m * n) if trans is Slap_common.normal;, (n * m) if trans is Slap_common.trans or Slap_common.conjtr.

getrf ?ipiv a computes LU factorization of matrix a using partial pivoting with row interchanges: a = P * L * U where P is a permutation matrix, and L and U are lower and upper triangular matrices, respectively.

getrf ?ipiv a computes LU factorization of matrix a using partial pivoting with row interchanges: a = P * L * U where P is a permutation matrix, and L and U are lower and upper triangular matrices, respectively.

getrf ?ipiv a computes LU factorization of matrix a using partial pivoting with row interchanges: a = P * L * U where P is a permutation matrix, and L and U are lower and upper triangular matrices, respectively.

getrf ?ipiv a computes LU factorization of matrix a using partial pivoting with row interchanges: a = P * L * U where P is a permutation matrix, and L and U are lower and upper triangular matrices, respectively.

getri ?ipiv ?work a computes the inverse of general matrix a by LU-factorization.

getri ?ipiv ?work a computes the inverse of general matrix a by LU-factorization.

getri ?ipiv ?work a computes the inverse of general matrix a by LU-factorization.

getri ?ipiv ?work a computes the inverse of general matrix a by LU-factorization.

getri_min_lwork n computes the minimum length of workspace for getri routine.

getri_min_lwork n computes the minimum length of workspace for getri routine.

getri_min_lwork n computes the minimum length of workspace for getri routine.

getri_min_lwork n computes the minimum length of workspace for getri routine.

getri_opt_lwork a computes the optimal length of workspace for getri routine.

getri_opt_lwork a computes the optimal length of workspace for getri routine.

getri_opt_lwork a computes the optimal length of workspace for getri routine.

getri_opt_lwork a computes the optimal length of workspace for getri routine.

getrs ?ipiv trans a b solves systems of linear equations OP(a) * x = b where a a 'n-by-'n general matrix, each column of matrix b is the r.h.s.

getrs ?ipiv trans a b solves systems of linear equations OP(a) * x = b where a a 'n-by-'n general matrix, each column of matrix b is the r.h.s.

getrs ?ipiv trans a b solves systems of linear equations OP(a) * x = b where a a 'n-by-'n general matrix, each column of matrix b is the r.h.s.

getrs ?ipiv trans a b solves systems of linear equations OP(a) * x = b where a a 'n-by-'n general matrix, each column of matrix b is the r.h.s.

- If Some n, the first n columns and the last n columns of a table are printed.

iamax x returns the index of the maximum value of all elements in x.

iamax x returns the index of the maximum value of all elements in x.

iamax x returns the index of the maximum value of all elements in x.

iamax x returns the index of the maximum value of all elements in x.

The identity function.

identity n

identity n

identity n

identity n

An alias of init_cols.

init n f

An alias of init_cols.

init n f

An alias of init_cols.

init n f

An alias of init_cols.

init n f

An alias of init_cols.

init kind n f

init_cols m n f returns a fresh m-by-n matrix whose the (i,j) element is initialized by the result of calling f i j.

init_cols m n f returns a fresh m-by-n matrix whose the (i,j) element is initialized by the result of calling f i j.

init_cols m n f returns a fresh m-by-n matrix whose the (i,j) element is initialized by the result of calling f i j.

init_cols m n f returns a fresh m-by-n matrix whose the (i,j) element is initialized by the result of calling f i j.

init_cols kind m n f returns a fresh m-by-n matrix whose the (i,j) element is initialized by the result of calling f i j.

init_rows m n f returns a fresh m-by-n matrix whose the (i,j) element is initialized by the result of calling f i j.

init_rows m n f returns a fresh m-by-n matrix whose the (i,j) element is initialized by the result of calling f i j.

init_rows m n f returns a fresh m-by-n matrix whose the (i,j) element is initialized by the result of calling f i j.

init_rows m n f returns a fresh m-by-n matrix whose the (i,j) element is initialized by the result of calling f i j.

init_rows kind m n f returns a fresh m-by-n matrix whose the (i,j) element is initialized by the result of calling f i j.

invalid_arg + printf-style format

iszero n returns true if size n is zero.

iter f (x1, x2, ..., xn) is f x1; f x2; ...; f xn.

iter f (x1, x2, ..., xn) is f x1; f x2; ...; f xn.

iter f (x1, x2, ..., xn) is f x1; f x2; ...; f xn.

iter f (x1, x2, ..., xn) is f x1; f x2; ...; f xn.

iter f (x1, x2, ..., xn) is f x1; f x2; ...; f xn.

iter f n is f 1; f 2; ...; f n.

iter2 f (x1, x2, ..., xn) (y1, y2, ..., yn) is f x1 y1; f x2 y2; ...; f xn yn.

iter2 f (x1, x2, ..., xn) (y1, y2, ..., yn) is f x1 y1; f x2 y2; ...; f xn yn.

iter2 f (x1, x2, ..., xn) (y1, y2, ..., yn) is f x1 y1; f x2 y2; ...; f xn yn.

iter2 f (x1, x2, ..., xn) (y1, y2, ..., yn) is f x1 y1; f x2 y2; ...; f xn yn.

iter2 f (x1, x2, ..., xn) (y1, y2, ..., yn) is f x1 y1; f x2 y2; ...; f xn yn.

iter3 f (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is f x1 y1 z1; f x2 y2 z2; ...; f xn yn zn.

iter3 f (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is f x1 y1 z1; f x2 y2 z2; ...; f xn yn zn.

iter3 f (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is f x1 y1 z1; f x2 y2 z2; ...; f xn yn zn.

iter3 f (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is f x1 y1 z1; f x2 y2 z2; ...; f xn yn zn.

iter3 f (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is f x1 y1 z1; f x2 y2 z2; ...; f xn yn zn.

iteri f (x1, x2, ..., xn) is f 1 x1; f 2 x2; ...; f n xn.

iteri f (x1, x2, ..., xn) is f 1 x1; f 2 x2; ...; f n xn.

iteri f (x1, x2, ..., xn) is f 1 x1; f 2 x2; ...; f n xn.

iteri f (x1, x2, ..., xn) is f 1 x1; f 2 x2; ...; f n xn.

iteri f (x1, x2, ..., xn) is f 1 x1; f 2 x2; ...; f n xn.

iteri f n is f 1; f 2; ...; f (to_int n).

iteri2 f (x1, x2, ..., xn) (y1, y2, ..., yn) is f 1 x1 y1; f 2 x2 y2; ...; f n xn yn.

iteri2 f (x1, x2, ..., xn) (y1, y2, ..., yn) is f 1 x1 y1; f 2 x2 y2; ...; f n xn yn.

iteri2 f (x1, x2, ..., xn) (y1, y2, ..., yn) is f 1 x1 y1; f 2 x2 y2; ...; f n xn yn.

iteri2 f (x1, x2, ..., xn) (y1, y2, ..., yn) is f 1 x1 y1; f 2 x2 y2; ...; f n xn yn.

iteri2 f (x1, x2, ..., xn) (y1, y2, ..., yn) is f 1 x1 y1; f 2 x2 y2; ...; f n xn yn.

iteri3 f (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is f 1 x1 y1 z1; f 2 x2 y2 z2; ...; f n xn yn zn.

iteri3 f (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is f 1 x1 y1 z1; f 2 x2 y2 z2; ...; f n xn yn zn.

iteri3 f (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is f 1 x1 y1 z1; f 2 x2 y2 z2; ...; f n xn yn zn.

iteri3 f (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is f 1 x1 y1 z1; f 2 x2 y2 z2; ...; f n xn yn zn.

iteri3 f (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is f 1 x1 y1 z1; f 2 x2 y2 z2; ...; f n xn yn zn.

lacpy ?uplo ?b a copies the matrix a into the matrix b.

lacpy ?uplo ?b a copies the matrix a into the matrix b.

lacpy ?uplo ?b a copies the matrix a into the matrix b.

lacpy ?uplo ?b a copies the matrix a into the matrix b.

lamch cmach see LAPACK documentation.

lamch cmach see LAPACK documentation.

lange ?norm ?work a

lange ?norm ?work a

lange ?norm ?work a

lange ?norm ?work a

lange_min_lwork m norm computes the minimum length of workspace for lange routine.

lange_min_lwork m norm computes the minimum length of workspace for lange routine.

lange_min_lwork m norm computes the minimum length of workspace for lange routine.

lange_min_lwork m norm computes the minimum length of workspace for lange routine.

lansy ?up ?norm ?work a

lansy ?up ?norm ?work a

lansy_min_lwork n norm computes the minimum length of workspace for lansy routine.

lansy_min_lwork n norm computes the minimum length of workspace for lansy routine.

larnv ?idist ?iseed ~x () generates a random vector with the random distribution specified by idist and random seed iseed.

larnv ?idist ?iseed ~x () generates a random vector with the random distribution specified by idist and random seed iseed.

larnv ?idist ?iseed ~x () generates a random vector with the random distribution specified by idist and random seed iseed.

larnv ?idist ?iseed ~x () generates a random vector with the random distribution specified by idist and random seed iseed.

lassq ?scale ?sumsq x

lassq ?scale ?sumsq x

lassq ?scale ?sumsq x

lassq ?scale ?sumsq x

lauum ?up a computes

lauum ?up a computes

lauum ?up a computes

lauum ?up a computes

Left multiplication

log ?y (x1, x2, ..., xn) returns (log x1, log x2, ..., log xn).

log ?y (x1, x2, ..., xn) returns (log x1, log x2, ..., log xn).

Using the lower triangular (or trapezoidal) part of a matrix.

An alias of ssc for compatibility with Lacaml.

luband_dyn kl ku ?ab a converts matrix a into a matrix stored in band storage for LU factorization.

luband_dyn kl ku ?ab a converts matrix a into a matrix stored in band storage for LU factorization.

luband_dyn kl ku ?ab a converts matrix a into a matrix stored in band storage for LU factorization.

luband_dyn kl ku ?ab a converts matrix a into a matrix stored in band storage for LU factorization.

luband_dyn kl ku ?ab a converts matrix a into a matrix stored in band storage for LU factorization.

luband_dyn m n kl ku computs the band storage size for LU factorization of m-by-n band matrices with kl subdiagonals and ku superdiagonals.

The major version of SLAP.

make m n x

make n a

make m n x

make n a

make m n x

make n a

make m n x

make n a

make kind m n x

make kind n a

make0 m n

zeros n

make0 m n

zeros n

make0 m n

zeros n

make0 m n

zeros n

make1 m n

make1 n

make1 m n

make1 n

make1 m n

make1 n

make1 m n

make1 n

map f ?y (x1, ..., xn) is (f x1, ..., f xn).

map f ?y (x1, ..., xn) is (f x1, ..., f xn).

map f ?y (x1, ..., xn) is (f x1, ..., f xn).

map f ?y (x1, ..., xn) is (f x1, ..., f xn).

map kind f ?y (x1, ..., xn) is (f x1, ..., f xn).

map2 f ?z (x1, x2, ..., xn) (y1, y2, ..., yn) is (f x1 y1, f x2 y2, ..., f xn yn).

map2 f ?z (x1, x2, ..., xn) (y1, y2, ..., yn) is (f x1 y1, f x2 y2, ..., f xn yn).

map2 f ?z (x1, x2, ..., xn) (y1, y2, ..., yn) is (f x1 y1, f x2 y2, ..., f xn yn).

map2 f ?z (x1, x2, ..., xn) (y1, y2, ..., yn) is (f x1 y1, f x2 y2, ..., f xn yn).

map2 kind f ?z (x1, x2, ..., xn) (y1, y2, ..., yn) is (f x1 y1, f x2 y2, ..., f xn yn).

map3 f ?w (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is (f x1 y1 z1, f x2 y2 z2, ..., f xn yn zn).

map3 f ?w (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is (f x1 y1 z1, f x2 y2 z2, ..., f xn yn zn).

map3 f ?w (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is (f x1 y1 z1, f x2 y2 z2, ..., f xn yn zn).

map3 f ?w (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is (f x1 y1 z1, f x2 y2 z2, ..., f xn yn zn).

map3 kind f ?w (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is (f x1 y1 z1, f x2 y2 z2, ..., f xn yn zn).

mapi f ?y (x1, ..., xn) is (f 1 x1, ..., f n xn) with the vector's dimension n.

mapi f ?y (x1, ..., xn) is (f 1 x1, ..., f n xn) with the vector's dimension n.

mapi f ?y (x1, ..., xn) is (f 1 x1, ..., f n xn) with the vector's dimension n.

mapi f ?y (x1, ..., xn) is (f 1 x1, ..., f n xn) with the vector's dimension n.

mapi kind f ?y (x1, ..., xn) is (f 1 x1, ..., f n xn) with the vector's dimension n.

mapi2 f ?z (x1, x2, ..., xn) (y1, y2, ..., yn) is (f 1 x1 y1, f 2 x2 y2, ..., f n xn yn) with the vectors' dimension n.

mapi2 f ?z (x1, x2, ..., xn) (y1, y2, ..., yn) is (f 1 x1 y1, f 2 x2 y2, ..., f n xn yn) with the vectors' dimension n.

mapi2 f ?z (x1, x2, ..., xn) (y1, y2, ..., yn) is (f 1 x1 y1, f 2 x2 y2, ..., f n xn yn) with the vectors' dimension n.

mapi2 f ?z (x1, x2, ..., xn) (y1, y2, ..., yn) is (f 1 x1 y1, f 2 x2 y2, ..., f n xn yn) with the vectors' dimension n.

mapi2 kind f ?z (x1, x2, ..., xn) (y1, y2, ..., yn) is (f 1 x1 y1, f 2 x2 y2, ..., f n xn yn) with the vectors' dimension n.

mapi3 f ?w (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is (f 1 x1 y1 z1, f 2 x2 y2 z2, ..., f n xn yn zn) with the vectors' dimension n.

mapi3 f ?w (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is (f 1 x1 y1 z1, f 2 x2 y2 z2, ..., f n xn yn zn) with the vectors' dimension n.

mapi3 f ?w (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is (f 1 x1 y1 z1, f 2 x2 y2 z2, ..., f n xn yn zn) with the vectors' dimension n.

mapi3 f ?w (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is (f 1 x1 y1 z1, f 2 x2 y2 z2, ..., f n xn yn zn) with the vectors' dimension n.

mapi3 kind f ?w (x1, x2, ..., xn) (y1, y2, ..., yn) (z1, z2, ..., zn) is (f 1 x1 y1 z1, f 2 x2 y2 z2, ..., f n xn yn zn) with the vectors' dimension n.

max x

max x

max x

max x

max m n

mem ?equal a v

The micro version of SLAP.

min x

min x

min x

min x

min m n

The minor version of SLAP.

mul ?z (x1, x2, ..., xn) (y1, y2, ..., yn) returns (x1 * y1, x2 * y2, ..., xn * yn).

mul ?z (x1, x2, ..., xn) (y1, y2, ..., yn) returns (x1 * y1, x2 * y2, ..., xn * yn).

mul ?z (x1, x2, ..., xn) (y1, y2, ..., yn) returns (x1 * y1, x2 * y2, ..., xn * yn).

mul ?z (x1, x2, ..., xn) (y1, y2, ..., yn) returns (x1 * y1, x2 * y2, ..., xn * yn).

mul m n

neg ?y (x1, x2, ..., xn) returns (-x1, -x2, ..., -xn).

neg ?y (x1, x2, ..., xn) returns (-x1, -x2, ..., -xn).

neg ?y (x1, x2, ..., xn) returns (-x1, -x2, ..., -xn).

neg ?y (x1, x2, ..., xn) returns (-x1, -x2, ..., -xn).

A matrix is not unit triagular.

nonzero n returns true if size n is not zero.

1-norm of a matrix (maximum column sum).

Largest absolute value of a matrix.

Frobenius norm of a matrix.

Infinity-norm of a matrix (maximum row sum).

Non-transposed matrix.

nrm2 x retruns the L2 norm of vector x: ||x||.

nrm2 x retruns the L2 norm of vector x: ||x||.

nrm2 x retruns the L2 norm of vector x: ||x||.

nrm2 x retruns the L2 norm of vector x: ||x||.

module M = (val of_array aa : CNTMAT)

module V = (val of_array [|a1; ...; an|] : CNTVEC)

module M = (val of_array aa : CNTMAT)

module V = (val of_array [|a1; ...; an|] : CNTVEC)

module M = (val of_array aa : CNTMAT)

module V = (val of_array [|a1; ...; an|] : CNTVEC)

module M = (val of_array aa : CNTMAT)

module V = (val of_array [|a1; ...; an|] : CNTVEC)

let Slap.Mat.MAT n = of_array_c arr

let Slap.Vec.VEC n = of_array_c [|a1; ...; an|]

let Slap.Mat.MAT n = of_array_c arr

let Slap.Vec.VEC n = of_array_c [|a1; ...; an|]

let Slap.Mat.MAT n = of_array_c arr

let Slap.Vec.VEC n = of_array_c [|a1; ...; an|]

let Slap.Mat.MAT n = of_array_c arr

let Slap.Vec.VEC n = of_array_c [|a1; ...; an|]

let MAT n = of_array_c kind arr

let VEC n = of_array_c kind [|a1; ...; an|]

Build a matrix initialized from the given array of arrays.

of_array_dyn n [|a1; ...; an|]

Build a matrix initialized from the given array of arrays.

of_array_dyn n [|a1; ...; an|]

Build a matrix initialized from the given array of arrays.

of_array_dyn n [|a1; ...; an|]

Build a matrix initialized from the given array of arrays.

of_array_dyn n [|a1; ...; an|]

Build a matrix initialized from the given array of arrays.

of_array_dyn kind n [|a1; ...; an|]

module M = (val of_bigarray ba : CNTMAT)

module V = (val of_bigarray ?share n ba : CNTVEC)

module M = (val of_bigarray ba : CNTMAT)

module V = (val of_bigarray ?share n ba : CNTVEC)

module M = (val of_bigarray ba : CNTMAT)

module V = (val of_bigarray ?share n ba : CNTVEC)

module M = (val of_bigarray ba : CNTMAT)

module V = (val of_bigarray ?share n ba : CNTVEC)

let Slap.Mat.MAT n = of_bigarray_c ?share ba

let Slap.Vec.VEC n = of_bigarray_c ?share ba

let Slap.Mat.MAT n = of_bigarray_c ?share ba

let Slap.Vec.VEC n = of_bigarray_c ?share ba

let Slap.Mat.MAT n = of_bigarray_c ?share ba

let Slap.Vec.VEC n = of_bigarray_c ?share ba

let Slap.Mat.MAT n = of_bigarray_c ?share ba

let Slap.Vec.VEC n = of_bigarray_c ?share ba

let MAT n = of_bigarray_c ?share ba

let VEC n = of_bigarray_c ?share ba

of_bigarray_dyn ?share m n ba

of_bigarray_dyn ?share n ba

of_bigarray_dyn ?share m n ba

of_bigarray_dyn ?share n ba

of_bigarray_dyn ?share m n ba

of_bigarray_dyn ?share n ba

of_bigarray_dyn ?share m n ba

of_bigarray_dyn ?share n ba

of_bigarray_dyn ?share m n ba

of_bigarray_dyn ?share n ba

let SIZE n = of_int_c_dyn i

module N = (val of_int_dyn n : SIZE)

module M = (val of_list ll : CNTMAT)

module V = (val of_list [a1; ...; an] : CNTVEC)

module M = (val of_list ll : CNTMAT)

module V = (val of_list [a1; ...; an] : CNTVEC)

module M = (val of_list ll : CNTMAT)

module V = (val of_list [a1; ...; an] : CNTVEC)

module M = (val of_list ll : CNTMAT)

module V = (val of_list [a1; ...; an] : CNTVEC)

let Slap.Mat.MAT n = of_list_c kind lst

let Slap.Vec.VEC n = of_list_c [a1; ...; an]

let Slap.Mat.MAT n = of_list_c kind lst

let Slap.Vec.VEC n = of_list_c [a1; ...; an]

let Slap.Mat.MAT n = of_list_c kind lst

let Slap.Vec.VEC n = of_list_c [a1; ...; an]

let Slap.Mat.MAT n = of_list_c kind lst

let Slap.Vec.VEC n = of_list_c [a1; ...; an]

let MAT n = of_list_c kind lst

let VEC n = of_list_c kind [a1; ...; an]

Build a matrix initialized from the given list of lists.

of_list_dyn n [a1; ...; an]

Build a matrix initialized from the given list of lists.

of_list_dyn n [a1; ...; an]

Build a matrix initialized from the given list of lists.

of_list_dyn n [a1; ...; an]

Build a matrix initialized from the given list of lists.

of_list_dyn n [a1; ...; an]

Build a matrix initialized from the given list of lists.

of_list_dyn kind n [a1; ...; an]

orgqr_dyn ?work ~tau a generates the orthogonal matrix Q of the QR factorization formed by geqrf/geqpf.

orgqr_dyn ?work ~tau a generates the orthogonal matrix Q of the QR factorization formed by geqrf/geqpf.

orgqr_min_lwork ~n computes the minimum length of workspace for orgqr routine.

orgqr_min_lwork ~n computes the minimum length of workspace for orgqr routine.

orgqr_min_lwork ~tau a computes the optimum length of workspace for orgqr routine.

orgqr_min_lwork ~tau a computes the optimum length of workspace for orgqr routine.

ormqr_dyn ~side ~trans ?work ~tau a c multiplies a matrix c by the orthogonal matrix Q of the QR factorization formed by geqrf/geqpf:

ormqr_dyn ~side ~trans ?work ~tau a c multiplies a matrix c by the orthogonal matrix Q of the QR factorization formed by geqrf/geqpf:

ormqr_min_lwork ~side ~m ~n computes the minimum length of workspace for ormqr routine.

ormqr_min_lwork ~side ~m ~n computes the minimum length of workspace for ormqr routine.

ormqr_opt_lwork ~side ~trans ~tau a c computes the optimum length of workspace for ormqr routine.

ormqr_opt_lwork ~side ~trans ~tau a c computes the optimum length of workspace for ormqr routine.

packed ?up ?x a transforms matrix a into packed storage format.

packed ?up ?x a transforms matrix a into packed storage format.

packed ?up ?x a transforms matrix a into packed storage format.

packed ?up ?x a transforms matrix a into packed storage format.

packed ?up ?x a transforms triangular matrix a into packed storage format.

packed n computes the packed storage size of a n-by-n matrix.

pbsv ?up ~kd ab b solves systems of linear equations ab * x = b where ab is a 'n-by-'n symmetric positive-definite band matrix with kd subdiangonals, stored in band storage format, each column of matrix b is the r.h.s vector, and each column of matrix x is the corresponding solution.

pbsv ?up ~kd ab b solves systems of linear equations ab * x = b where ab is a 'n-by-'n symmetric positive-definite band matrix with kd subdiangonals, stored in band storage format, each column of matrix b is the r.h.s vector, and each column of matrix x is the corresponding solution.

pbsv ?up ~kd ab b solves systems of linear equations ab * x = b where ab is a 'n-by-'n symmetric positive-definite band matrix with kd subdiangonals, stored in band storage format, each column of matrix b is the r.h.s vector, and each column of matrix x is the corresponding solution.

pbsv ?up ~kd ab b solves systems of linear equations ab * x = b where ab is a 'n-by-'n symmetric positive-definite band matrix with kd subdiangonals, stored in band storage format, each column of matrix b is the r.h.s vector, and each column of matrix x is the corresponding solution.

pocon ?up ?anorm ?work ?iwork a estimates the reciprocal of the condition number of symmetric positive-definite matrix a.

pocon ?up ?anorm ?work ?iwork a estimates the reciprocal of the condition number of symmetric positive-definite matrix a.

pocon_min_liwork n computes the minimum length of workspace iwork for pocon routine.

pocon_min_liwork n computes the minimum length of workspace iwork for pocon routine.

pocon_min_lwork n computes the minimum length of workspace work for pocon routine.

pocon_min_lwork n computes the minimum length of workspace work for pocon routine.

posv ?up a b solves systems of linear equations a * x = b where a is a 'n-by-'n symmetric positive-definite matrix, each column of matrix b is the r.h.s vector, and each column of matrix x is the corresponding solution.

posv ?up a b solves systems of linear equations a * x = b where a is a 'n-by-'n symmetric positive-definite matrix, each column of matrix b is the r.h.s vector, and each column of matrix x is the corresponding solution.

posv ?up a b solves systems of linear equations a * x = b where a is a 'n-by-'n symmetric positive-definite matrix, each column of matrix b is the r.h.s vector, and each column of matrix x is the corresponding solution.

posv ?up a b solves systems of linear equations a * x = b where a is a 'n-by-'n symmetric positive-definite matrix, each column of matrix b is the r.h.s vector, and each column of matrix x is the corresponding solution.

potrf ?up ?jitter a computes the Cholesky factorization of symmetrix (Hermitian) positive-definite matrix a:

potrf ?up ?jitter a computes the Cholesky factorization of symmetrix (Hermitian) positive-definite matrix a:

potrf ?up ?jitter a computes the Cholesky factorization of symmetrix (Hermitian) positive-definite matrix a:

potrf ?up ?jitter a computes the Cholesky factorization of symmetrix (Hermitian) positive-definite matrix a:

potrf ?up ?jitter a computes the inverse of symmetrix (Hermitian) positive-definite matrix a using the Cholesky factorization:

potrf ?up ?jitter a computes the inverse of symmetrix (Hermitian) positive-definite matrix a using the Cholesky factorization:

potrf ?up ?jitter a computes the inverse of symmetrix (Hermitian) positive-definite matrix a using the Cholesky factorization:

potrf ?up ?jitter a computes the inverse of symmetrix (Hermitian) positive-definite matrix a using the Cholesky factorization:

potrf ?up a ?jitter b solves systems of linear equations a * x = b using the Cholesky factorization of symmetrix (Hermitian) positive-definite matrix a:

potrf ?up a ?jitter b solves systems of linear equations a * x = b using the Cholesky factorization of symmetrix (Hermitian) positive-definite matrix a:

potrf ?up a ?jitter b solves systems of linear equations a * x = b using the Cholesky factorization of symmetrix (Hermitian) positive-definite matrix a:

potrf ?up a ?jitter b solves systems of linear equations a * x = b using the Cholesky factorization of symmetrix (Hermitian) positive-definite matrix a:

fprintf ppf "(%G, %Gi)" x.re x.im

fprintf ppf "%G" el

fprintf ppf "%ld" x

A pretty-printer for matrices.

A pretty-printer for matrices.

A pretty-printer for matrices.

A pretty-printer for matrices.

A generator of pretty printers for matrices.

A pretty-printer for elements in vectors and matrices.

A pretty-printer for elements in vectors and matrices.

A pretty-printer for elements in vectors and matrices.

A pretty-printer for elements in vectors and matrices.

A generator of pretty printers for row vectors.

pp_table ?pp_open ?pp_close ?pp_head ?pp_foot ?pp_end_row ?pp_end_col ?pp_left ?pp_right ?pad ?ellipsis ?vertical_context ?horizontal_context pp_el ppf n_rows n_cols get_el

A pretty-printer for column vectors.

A pretty-printer for column vectors.

A pretty-printer for column vectors.

A pretty-printer for column vectors.

A generator of pretty printers for (column) vectors.

ppsv ?up a b solves systems of linear equations a * x = b where a is a 'n-by-'n symmetric positive-definite matrix stored in packed format, each column of matrix b is the r.h.s vector, and each column of matrix x is the corresponding solution.

ppsv ?up a b solves systems of linear equations a * x = b where a is a 'n-by-'n symmetric positive-definite matrix stored in packed format, each column of matrix b is the r.h.s vector, and each column of matrix x is the corresponding solution.

ppsv ?up a b solves systems of linear equations a * x = b where a is a 'n-by-'n symmetric positive-definite matrix stored in packed format, each column of matrix b is the r.h.s vector, and each column of matrix x is the corresponding solution.

ppsv ?up a b solves systems of linear equations a * x = b where a is a 'n-by-'n symmetric positive-definite matrix stored in packed format, each column of matrix b is the r.h.s vector, and each column of matrix x is the corresponding solution.

pred n returns

pred_dyn n

prod x

prod x

prod x

prod x

ptsv d e b solves systems of linear equations A * x = b where A is a 'n-by-'n symmetric positive-definite tridiagonal matrix with diagonal elements d and subdiagonal elements e, each column of matrix b is the r.h.s vector, and each column of matrix x is the corresponding solution.

ptsv d e b solves systems of linear equations A * x = b where A is a 'n-by-'n symmetric positive-definite tridiagonal matrix with diagonal elements d and subdiagonal elements e, each column of matrix b is the r.h.s vector, and each column of matrix x is the corresponding solution.

ptsv d e b solves systems of linear equations A * x = b where A is a 'n-by-'n symmetric positive-definite tridiagonal matrix with diagonal elements d and subdiagonal elements e, each column of matrix b is the r.h.s vector, and each column of matrix x is the corresponding solution.

ptsv d e b solves systems of linear equations A * x = b where A is a 'n-by-'n symmetric positive-definite tridiagonal matrix with diagonal elements d and subdiagonal elements e, each column of matrix b is the r.h.s vector, and each column of matrix x is the corresponding solution.

random ?rnd_state ?from ?range m n creates a m-by-n matrix randomly initialized with the uniform distribution between re_from/im_from and re_from+re_range/im_from+im_range for real and imaginary parts, respectively.

random ?rnd_state ?from ?range n creates a n-dimensional vector randomly initialized with the uniform distribution between re_from/im_from and re_from+re_range/im_from+im_range for real and imaginary parts, respectively.

random ?rnd_state ?from ?range m n creates a m-by-n matrix randomly initialized with the uniform distribution between re_from/im_from and re_from+re_range/im_from+im_range for real and imaginary parts, respectively.

random ?rnd_state ?from ?range n creates a n-dimensional vector randomly initialized with the uniform distribution between re_from/im_from and re_from+re_range/im_from+im_range for real and imaginary parts, respectively.

random ?rnd_state ?from ?range m n creates a m-by-n matrix randomly initialized with the uniform distribution between from and from + range.

random ?rnd_state ?from ?range n creates a n-dimensional vector randomly initialized with the uniform distribution between from and from + range.

random ?rnd_state ?from ?range m n creates a m-by-n matrix randomly initialized with the uniform distribution between from and from + range.

random ?rnd_state ?from ?range n creates a n-dimensional vector randomly initialized with the uniform distribution between from and from + range.

reci ?y (x1, x2, ..., xn) returns (1 / x1, 1 / x2, ..., 1 / xn).

reci ?y (x1, x2, ..., xn) returns (1 / x1, 1 / x2, ..., 1 / xn).

reci ?y (x1, x2, ..., xn) returns (1 / x1, 1 / x2, ..., 1 / xn).

reci ?y (x1, x2, ..., xn) returns (1 / x1, 1 / x2, ..., 1 / xn).

replace_all a f modifies the matrix a in place -- the (i,j)-element aij of a will be set to f aij.

replace_all x f modifies the vector x in place -- the i-th element xi of x will be set to f xi.

replace_all a f modifies the matrix a in place -- the (i,j)-element aij of a will be set to f aij.

replace_all x f modifies the vector x in place -- the i-th element xi of x will be set to f xi.

replace_all a f modifies the matrix a in place -- the (i,j)-element aij of a will be set to f aij.

replace_all x f modifies the vector x in place -- the i-th element xi of x will be set to f xi.

replace_all a f modifies the matrix a in place -- the (i,j)-element aij of a will be set to f aij.

replace_all x f modifies the vector x in place -- the i-th element xi of x will be set to f xi.

replace_all a f modifies the matrix a in place -- the (i,j)-element aij of a will be set to f aij.

replace_all x f modifies the vector x in place -- the i-th element xi of x will be set to f xi.

replace_all a f modifies the matrix a in place -- the (i,j)-element aij of a will be set to f i j aij.

replace_alli x f modifies the vector x in place -- the i-th element xi of x will be set to f i xi.

replace_all a f modifies the matrix a in place -- the (i,j)-element aij of a will be set to f i j aij.

replace_alli x f modifies the vector x in place -- the i-th element xi of x will be set to f i xi.

replace_all a f modifies the matrix a in place -- the (i,j)-element aij of a will be set to f i j aij.

replace_alli x f modifies the vector x in place -- the i-th element xi of x will be set to f i xi.

replace_all a f modifies the matrix a in place -- the (i,j)-element aij of a will be set to f i j aij.

replace_alli x f modifies the vector x in place -- the i-th element xi of x will be set to f i xi.

replace_all a f modifies the matrix a in place -- the (i,j)-element aij of a will be set to f i j aij.

replace_alli x f modifies the vector x in place -- the i-th element xi of x will be set to f i xi.

replace_dyn v i f is set_dyn v i (f (get_dyn v i)).

replace_dyn v i f is set_dyn v i (f (get_dyn v i)).

replace_dyn v i f is set_dyn v i (f (get_dyn v i)).

replace_dyn v i f is set_dyn v i (f (get_dyn v i)).

replace_dyn a i j f is set a i j (f (get a i j)).

replace_dyn v i f is set_dyn v i (f (get_dyn v i)).

rev (x1, x2, ..., xn)

rev (x1, x2, ..., xn)

rev (x1, x2, ..., xn)

rev (x1, x2, ..., xn)

rev (x1, x2, ..., xn)

Right multiplication

riter f n is f n; ...; f 2; f 1.

riteri f n is f (to_int n); ...; f 2; f 1.

row_dyn a i

row_dyn a i

row_dyn a i

row_dyn a i

row_dyn a i

sbev ~kd ?z ?up ?work ?w ab computes all eigenvalues and, optionally, eigenvectors of real symmetric band matrix ab store in band storage format.

sbev ~kd ?z ?up ?work ?w ab computes all eigenvalues and, optionally, eigenvectors of real symmetric band matrix ab store in band storage format.

sbev_min_lwork n computes the minimum length of workspace work for sbev routine.

sbev_min_lwork n computes the minimum length of workspace work for sbev routine.

sbgv ~ka ~kb ?z ?up ?work ?w ab bb solves a general eigenvalue problem ab * z = (lambda) * bb * z where ab is a 'n-by-'n symmetric band matrix with ka subdiagonals, and bb is a 'n-by-'n symmetric positive-definite band matrix with kb subdiagonals.

sbgv ~ka ~kb ?z ?up ?work ?w ab bb solves a general eigenvalue problem ab * z = (lambda) * bb * z where ab is a 'n-by-'n symmetric band matrix with ka subdiagonals, and bb is a 'n-by-'n symmetric positive-definite band matrix with kb subdiagonals.

sbmv ~k ?y a ?up ?alpha ?beta x computes y := alpha * a * x + beta * y where a is a 'n-by-'n symmetric band matrix with k super-(or sub-)diagonals, and x and y are 'n-dimensional vectors.

sbmv ~k ?y a ?up ?alpha ?beta x computes y := alpha * a * x + beta * y where a is a 'n-by-'n symmetric band matrix with k super-(or sub-)diagonals, and x and y are 'n-dimensional vectors.

scal alpha a computes a := alpha * a with the scalar value alpha and the matrix a.

scal c x multiplies all elements in x by scalar value c, and destructively assigns the result to x.

scal alpha a computes a := alpha * a with the scalar value alpha and the matrix a.

scal c x multiplies all elements in x by scalar value c, and destructively assigns the result to x.

scal alpha a computes a := alpha * a with the scalar value alpha and the matrix a.

scal c x multiplies all elements in x by scalar value c, and destructively assigns the result to x.

scal alpha a computes a := alpha * a with the scalar value alpha and the matrix a.

scal c x multiplies all elements in x by scalar value c, and destructively assigns the result to x.

A column-wise scal function for matrices.

A column-wise scal function for matrices.

A column-wise scal function for matrices.

A column-wise scal function for matrices.

A row-wise scal function for matrices.

A row-wise scal function for matrices.

A row-wise scal function for matrices.

A row-wise scal function for matrices.

set_dim_defaults opt_n sets both Slap_io.Context.vertical_default and Slap_io.Context.horizontal_default to opt_n.

set_dyn a i j x assigns x to the (i,j) element of the matrix a.

set_dyn x i a assigns a to the i-th element of the vector x.

set_dyn a i j x assigns x to the (i,j) element of the matrix a.

set_dyn x i a assigns a to the i-th element of the vector x.

set_dyn a i j x assigns x to the (i,j) element of the matrix a.

set_dyn x i a assigns a to the i-th element of the vector x.

set_dyn a i j x assigns x to the (i,j) element of the matrix a.

set_dyn x i a assigns a to the i-th element of the vector x.

set_dyn a i j x assigns x to the (i,j) element of the matrix a.

set_dyn x i a assigns a to the i-th element of the vector x.

shared_rev (x1, x2, ..., xn)

shared_rev (x1, x2, ..., xn)

shared_rev (x1, x2, ..., xn)

shared_rev (x1, x2, ..., xn)

shared_rev (x1, x2, ..., xn)

sin ?y (x1, x2, ..., xn) returns (sin x1, sin x2, ..., sin xn).

sin ?y (x1, x2, ..., xn) returns (sin x1, sin x2, ..., sin xn).

sort ?cmp ?decr ?p x sorts the elements in vector x in increasing order according to the comparison function cmp.

sort ?cmp ?decr ?p x sorts the elements in vector x in increasing order according to the comparison function cmp.

sort ?cmp ?decr ?p x sorts the elements in vector x in increasing order according to the comparison function cmp.

sort ?cmp ?decr ?p x sorts the elements in vector x in increasing order according to the comparison function cmp.

spsv ?up a b solves systems of linear equations a * x = b where a is a 'n-by-'n symmetric matrix stored in packed format, each column of matrix b is the r.h.s.

spsv ?up a b solves systems of linear equations a * x = b where a is a 'n-by-'n symmetric matrix stored in packed format, each column of matrix b is the r.h.s.