N-dimensional array type, i.e. Bigarray Genarray type.

empty m n creates an m by n matrix without initialising the values of elements in x.

create m n a creates an m by n matrix and all the elements of x are initialised with the value a.

init m n f creates a matrix x of shape m x n, then using f to initialise the elements in x. The input of f is 1-dimensional index of the matrix. You need to explicitly convert it if you need 2D index. The function Owl_utils.ind can help you.

init_2d m n f s almost the same as init but f receives 2D index as input. It is more convenient since you don't have to convert the index by yourself, but this also means init_2d is slower than init.

zeros m n creates an m by n matrix where all the elements are initialised to zeros.

ones m n creates an m by n matrix where all the elements are ones.

eye m creates an m by m identity matrix.

complex re im constructs a complex ndarray/matrix from re and im. re and im contain the real and imaginary part of x respectively.

Note that both re and im can be complex but must have same type. The real part of re will be the real part of x and the imaginary part of im will be the imaginary part of x.

complex rho theta constructs a complex ndarray/matrix from polar coordinates rho and theta. rho contains the magnitudes and theta contains phase angles. Note that the behaviour is undefined if rho has negative elelments or theta has infinity elelments.

unit_basis k n i returns a unit basis vector with ith element set to 1.

sequential ~a ~step m n creates an m by n matrix. The elements in x are initialised sequentiallly from ~a and is increased by ~step.

The default value of ~a is zero whilst the default value of ~step is one.

uniform m n creates an m by n matrix where all the elements follow a uniform distribution in (0,1) interval. uniform ~scale:a m n adjusts the interval to (0,a).

gaussian m n creates an m by n matrix where all the elements in x follow a Gaussian distribution with specified sigma. By default sigma = 1.

poisson m n creates an m by n matrix where all the elements in x follow a Poisson distribution with specified rate mu.

semidef n returns an random n by n positive semi-definite matrix.

linspace a b n linearly divides the interval [a,b] into n pieces by creating an m by 1 row vector. E.g., linspace 0. 5. 6 will create a row vector [0;1;2;3;4;5].

logspace base a b n ... the default value of base is e.

meshgrid a1 b1 a2 b2 n1 n2 is similar to the meshgrid function in Matlab. It returns two matrices x and y where the row vectors in x are linearly spaced between [a1,b1] by n1 whilst the column vectors in y are linearly spaced between (a2,b2) by n2.

meshup x y creates mesh grids by using two row vectors x and y.

bernoulli k ~p:0.3 m n

diagm k v creates a diagonal matrix using the elements in v as diagonal values. k specifies the main diagonal index. If k > 0 then it is above the main diagonal, if k < 0 then it is below the main diagonal. This function is the same as the diag function in Matlab.

triu k x returns the element on and above the kth diagonal of x. k = 0 is the main diagonal, k > 0 is above the main diagonal, and k < 0 is below the main diagonal.

tril k x returns the element on and below the kth diagonal of x. k = 0 is the main diagonal, k > 0 is above the main diagonal, and k < 0 is below the main diagonal.

symmetric ~upper x creates a symmetric matrix using either upper or lower triangular part of x. If upper is true then it uses the upper part, if upper is false, then symmetric uses the lower part. By default upper is true.

hermitian ~upper x creates a hermitian matrix based on x. By default, the upper triangular part is used for creating the hermitian matrix, but you use the lower part by setting upper=false

bidiagonal upper dv ev creates a bidiagonal matrix using dv and ev. Both dv and ev are row vectors. dv is the main diagonal. If upper is true then ev is superdiagonal; if upper is false then ev is subdiagonal. By default, upper is true.

NOTE: because the diagonal elements in a hermitian matrix must be real, the function set the imaginary part of the diagonal elements to zero by default. In other words, if the diagonal elements of x have non-zero imaginary parts, the imaginary parts will be dropped without a warning.

toeplitz ~c r generates a toeplitz matrix using r and c. Both r and c are row vectors of the same length. If the first elements of c is different from that of r, r's first element will be used.

Note: 1) If c is not passed in, then c = r will be used. 2) If c is not passed in and r is complex, the c = conj r will be used. 3) If r and c have different length, then the result is a rectangular matrix.

hankel ~r c generates a hankel matrix using r and c. c will be the first column and r will be the last row of the returned matrix.

Note: 1) If only c is passed in, the elelments below the anti-diagnoal are zero. 2) If the last element of c is different from the first element of r then the first element of c prevails. 3) c and r can have different length, the return will be an rectangular matrix.

hadamard k n constructs a hadamard matrix of order n. For a hadamard H, we have H'*H = n*I. Currently, this function handles only the cases where n, n/12, or n/20 is a power of 2.

magic k n constructs a n x n magic square matrix x. The elements in x are consecutive numbers increasing from 1 to n^2. n must n >= 3.

There are three different algorithms to deal with n is odd, singly even, and doubly even respectively.

If x is an m by n matrix, shape x returns (m,n), i.e., the size of two dimensions of x.

row_num x returns the number of rows in matrix x.

col_num x returns the number of columns in matrix x.

numel x returns the number of elements in matrix x. It is equivalent to (row_num x) * (col_num x).

nnz x returns the number of non-zero elements in x.

density x returns the percentage of non-zero elements in x.

size_in_bytes x returns the size of x in bytes in memory.

same_shape x y returns true if two matrics have the same shape.

Refer to :doc:`owl_dense_ndarray_generic`.

kind x returns the type of matrix x.

get x i j returns the value of element (i,j) of x. The shorthand for get x i j is x.{i,j}

set x i j a sets the element (i,j) of x to value a. The shorthand for set x i j a is x.{i,j} <- a

get_index i x returns an array of element values specified by the indices i. The length of array i equals the number of dimensions of x. The arrays in i must have the same length, and each represents the indices in that dimension.

E.g., [| [|1;2|]; [|3;4|] |] returns the value of elements at position (1,3) and (2,4) respectively.

set_index sets the value of elements in x according to the indices specified by i. The length of array i equals the number of dimensions of x. The arrays in i must have the same length, and each represents the indices in that dimension.

get_fancy s x returns a copy of the slice in x. The slice is defined by a which is an int array. Please refer to the same function in the Owl_dense_ndarray_generic documentation for more details.

set_fancy axis x y set the slice defined by axis in x according to the values in y. y must have the same shape as the one defined by axis.

About the slice definition of axis, please refer to slice function.

This function is used for extended indexing operator since ocaml 4.10.0. The indexing and slicing syntax become much ligher.

This function is used for extended indexing operator since ocaml 4.10.0. The indexing and slicing syntax become much ligher.

get_slice axis x aims to provide a simpler version of get_fancy. This function assumes that every list element in the passed in in list list represents a range, i.e., R constructor.

E.g., [[];[0;3];[0]] is equivalent to [R []; R [0;3]; R [0]].

set_slice axis x y aims to provide a simpler version of set_slice. This function assumes that every list element in the passed in in list list represents a range, i.e., R constructor.

E.g., [[];[0;3];[0]] is equivalent to [R []; R [0;3]; R [0]].

Please refer to Ndarray document.

Please refer to Ndarray document.

row x i returns row i of x. Note: Unlike col, the return value is simply a view onto the original row in x, so modifying row's value also alters x.

The function supports nagative indices.

col x j returns column j of x. Note: Unlike row, the return value is a copy of the original row in x.

The function supports nagative indices.

rows x a returns the rows (defined in an int array a) of x. The returned rows will be combined into a new dense matrix. The order of rows in the new matrix is the same as that in the array a.

The function supports nagative indices.

Similar to rows, cols x a returns the columns (specified in array a) of x in a new dense matrix.

The function supports nagative indices.

resize x s please refer to the Ndarray document.

reshape x s returns a new m by n matrix from the m' by n' matrix x. Note that (m * n) must be equal to (m' * n'), and the returned matrix shares the same memory with the original x.

flatten x reshape x into a 1 by n row vector without making a copy. Therefore the returned value shares the same memory space with original x.

reverse x reverse the order of all elements in the flattened x and returns the results in a new matrix. The original x remains intact.

flip ~axis x flips a matrix/ndarray along axis. By default axis = 0. The result is returned in a new matrix/ndarray, so the original x remains intact.

rotate x d rotates x clockwise d degrees. d must be multiple times of 90, otherwise the function will fail. If x is an n-dimensional array, then the function rotates the plane formed by the first and second dimensions.

reset x resets all the elements of x to zero value.

fill x a fills the x with value a.

copy x returns a copy of matrix x.

copy_row_to v x i copies an 1 by n row vector v to the ith row in an m by n matrix x.

copy_col_to v x j copies an 1 by n column vector v to the jth column in an m by n matrix x.

concat_vertical x y concats two matrices x and y vertically, therefore their column numbers must be the same.

The associated operator is @=, please refer to :doc:`owl_operator`.

concat_horizontal x y concats two matrices x and y horizontally, therefore their row numbers must be the same.

The associated operator is @||, please refer to :doc:`owl_operator`.

concat_vh is used to assemble small parts of matrices into a bigger one. E.g. [| [|a; b; c|]; [|d; e; f|]; [|g; h; i|] |] will be concatenated into a big matrix as follows.

Please refer to :doc:`owl_dense_ndarray_generic`. for details.

concatenate ~axis:1 x concatenates an array of matrices along the second dimension. For the matrices in x, they must have the same shape except the dimension specified by axis. The default value of axis is 0, i.e., the lowest dimension on a marix, i.e., rows.

split ~axis parts x splits an ndarray x into parts along the specified axis. This function is the inverse operation of concatenate. The elements in x must sum up to the dimension in the specified axis.

Please refer to :doc:`owl_dense_ndarray_generic`. for details.

transpose x transposes an m by n matrix to n by m one.

ctranspose x performs conjugate transpose of a complex matrix x. If x is a real matrix, then ctranspose x is equivalent to transpose x.

diag k x returns the kth diagonal elements of x. k > 0 means above the main diagonal and k < 0 means the below the main diagonal.

swap_rows x i i' swaps the row i with row i' of x.

swap_cols x j j' swaps the column j with column j' of x.

tile x a provides the exact behaviour as numpy.tile function.

repeat x a repeats the elements x according the repetition specified by a.

padd ~v:0. [[1;1]] x

dropout ~rate:0.3 x drops out 30% of the elements in x, in other words, by setting their values to zeros.

top x n returns the indices of n greatest values of x. The indices are arranged according to the corresponding element values, from the greatest one to the smallest one.

bottom x n returns the indices of n smallest values of x. The indices are arranged according to the corresponding element values, from the smallest one to the greatest one.

sort x performs quicksort of the elelments in x. A new copy is returned as result, the original x remains intact. If you want to perform in-place sorting, please use `sort_` instead.

argsort x returns the indices with which the elements in x are sorted in increasing order. Note that the returned index ndarray has the same shape as that of x, and the indices are 1D indices.

iteri f x iterates all the elements in x and applies the user defined function f : int -> int -> float -> 'a. f i j v takes three parameters, i and j are the coordinates of current element, and v is its value.

iter f x is the same as as iteri f x except the coordinates of the current element is not passed to the function f : float -> 'a

mapi f x maps each element in x to a new value by applying f : int -> int -> float -> float. The first two parameters are the coordinates of the element, and the third parameter is the value.

map f x is similar to mapi f x except the coordinates of the current element is not passed to the function f : float -> float

foldi ~axis f a x folds (or reduces) the elements in x from left along the specified axis using passed in function f. a is the initial element and in f i acc b acc is the accumulater and b is one of the elements in x along the same axis. Note that i is 1d index of b.