package owl
Install
Dune Dependency
Authors
Maintainers
Sources
sha256=38d210ce6c1c2f09631fd59951430e4f364b5ae036c71ed1b32ce559b2a29263
sha512=c468100556445384b9c6adad9c37b5a9b8c27db8be35f61979e65fafa88c60221b8bda0a9c06cfbbc8d4e216a1ed08a315dfefb45bb4f5f15aa82d4358f57567
doc/owl/Owl_sparse_matrix_generic/index.html
Module Owl_sparse_matrix_genericSource
Sparse matrix module
Type definition
Abstract type of sparse matrices
Type of sparse matrices. It is defined in ``types.ml`` as record type.
Create sparse matrices
``zeros m n`` creates an ``m`` by ``n`` matrix where all the elements are zeros. This operation is very fast since it only allocates a small amount of memory. The memory will grow automatically as more elements are inserted.
``ones m n`` creates an ``m`` by ``n`` matrix where all the elements are ones. This operation can be very slow if matrix size is big. You might consider to use dense matrix for better performance in this case.
``eye m`` creates an ``m`` by ``m`` identity matrix.
``binary m n`` creates an ``m`` by ``n`` random matrix where 10% ~ 15% elements are 1.
``uniform m n`` creates an ``m`` by ``n`` matrix where 10% ~ 15% elements follow a uniform distribution in ``(0,1)`` interval. ``uniform ~scale:a m n`` adjusts the interval to ``(0,a)``.
Obtain the basic properties
If ``x`` is an ``m`` by ``n`` matrix, ``shape x`` returns ``(m,n)``, i.e., the size of two dimensions of ``x``.
``row_num_nz x`` returns the number of non-zero rows in matrix ``x``.
``col_num_nz x`` returns the number of non-zero 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_rows x`` returns the number of non-zero rows in matrix ``x``. A non-zero row means there is at least one non-zero element in that row.
``nnz_cols x`` returns the number of non-zero cols in matrix ``x``.
``density x`` returns the density of non-zero element. This operation is equivalent to ``nnz x`` divided by ``numel x``.
Manipulate a matrix
``set x i j a`` sets the element ``(i,j)`` of ``x`` to value ``a``.
``get x i j`` returns the value of element ``(i,j)`` of ``x``.
``copy x`` makes an exact copy of matrix ``x``. Note that the copy becomes mutable no matter ``w`` is mutable or not. This is especially useful if you want to modify certain elements in an immutable matrix from math operations.
``transpose x`` transposes an ``m`` by ``n`` matrix to ``n`` by ``m`` one.
``rows x a`` returns the rows (defined in an int array ``a``) of ``x``. The returned rows will be combined into a new sparse matrix. The order of rows in the new matrix is the same as that in the array ``a``.
Similar to ``rows``, ``cols x a`` returns the columns (specified in array ``a``) of x in a new sparse matrix.
``concat_vertical x y`` not implemented yet
``concat_horizontal x y`` not implemented yet
Iterate elements, columns, and rows
``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``
``fold f a x`` folds all the elements in ``x`` with the function ``f : 'a -> float -> 'a``. For an ``m`` by ``n`` matrix ``x``, the order of folding is from ``(0,0)`` to ``(m-1,n-1)``, row by row.
``filteri f x`` uses ``f : int -> int -> float -> bool`` to filter out certain elements in ``x``. An element will be included if ``f`` returns ``true``. The returned result is a list of coordinates of the selected elements.
Similar to ``filteri``, but the coordinates of the elements are not passed to the function ``f : float -> bool``.
``iteri_rows f x`` iterates every row in ``x`` and applies function ``f : int -> mat -> unit`` to each of them.
Similar to ``iteri_rows`` except row number is not passed to ``f``.
``iteri_cols f x`` iterates every column in ``x`` and applies function ``f : int -> mat -> unit`` to each of them. Column number is passed to ``f`` as the first parameter.
Similar to ``iteri_cols`` except col number is not passed to ``f``.
``mapi_rows f x`` maps every row in ``x`` to a type ``'a`` value by applying function ``f : int -> mat -> 'a`` to each of them. The results is an array of all the returned values.
Similar to ``mapi_rows`` except row number is not passed to ``f``.
``mapi_cols f x`` maps every column in ``x`` to a type ``'a`` value by applying function ``f : int -> mat -> 'a``.
Similar to ``mapi_cols`` except column number is not passed to ``f``.
``fold_rows f a x`` folds all the rows in ``x`` using function ``f``. The order of folding is from the first row to the last one.
``fold_cols f a x`` folds all the columns in ``x`` using function ``f``. The order of folding is from the first column to the last one.
``iteri_nz f x`` iterates all the non-zero elements in ``x`` by applying the function ``f : int -> int -> float -> 'a``. It is much faster than ``iteri``.
Similar to ``iter_nz`` except the coordinates of elements are not passed to ``f``.
``mapi_nz f x`` is similar to ``mapi f x`` but only applies ``f`` to non-zero elements in ``x``. The zeros in ``x`` will remain the same in the new matrix.
Similar to ``mapi_nz`` except the coordinates of elements are not passed to ``f``.
``fold_nz f a x`` is similar to ``fold f a x`` but only applies to non-zero rows in ``x``. zero rows will be simply skipped in folding.
``filteri_nz f x`` is similar to ``filter f x`` but only applies ``f`` to non-zero elements in ``x``.
``filter_nz f x`` is similar to ``filteri_nz`` except that the coordinates of matrix elements are not passed to ``f``.
``iteri_rows_nz f x`` is similar to ``iteri_rows`` but only applies ``f`` to non-zero rows in ``x``.
Similar to ``iteri_rows_nz`` except that row numbers are not passed to ``f``.
``iteri_cols_nz f x`` is similar to ``iteri_cols`` but only applies ``f`` to non-zero columns in ``x``.
Similar to ``iteri_cols_nz`` except that column numbers are not passed to ``f``.
``mapi_rows_nz f x`` applies ``f`` only to the non-zero rows in ``x``.
Similar to ``mapi_rows_nz``, but row numbers are not passed to ``f``.
``mapi_cols_nz f x`` applies ``f`` only to the non-zero columns in ``x``.
Similar to ``mapi_cols_nz``, but columns numbers are not passed to ``f``.
``fold_rows_nz f a x`` is similar to ``fold_rows`` but only folds non-zero rows in ``x`` using function ``f``. Zero rows will be dropped in iterating ``x``.
``fold_cols_nz f a x`` is similar to ``fold_cols`` but only folds non-zero columns in ``x`` using function ``f``. Zero columns will be dropped in iterating ``x``.
Examine elements and compare two matrices
``exists f x`` checks all the elements in ``x`` using ``f``. If at least one element satisfies ``f`` then the function returns ``true`` otherwise ``false``.
``not_exists f x`` checks all the elements in ``x``, the function returns ``true`` only if all the elements fail to satisfy ``f : float -> bool``.
``for_all f x`` checks all the elements in ``x``, the function returns ``true`` if and only if all the elements pass the check of function ``f``.
``exists_nz f x`` is similar to ``exists`` but only checks non-zero elements.
``not_exists_nz f x`` is similar to ``not_exists`` but only checks non-zero elements.
``for_all_nz f x`` is similar to ``for_all_nz`` but only checks non-zero elements.
``is_zero x`` returns ``true`` if all the elements in ``x`` are zeros.
``is_positive x`` returns ``true`` if all the elements in ``x`` are positive.
``is_negative x`` returns ``true`` if all the elements in ``x`` are negative.
``is_nonpositive`` returns ``true`` if all the elements in ``x`` are non-positive.
``is_nonnegative`` returns ``true`` if all the elements in ``x`` are non-negative.
``equal x y`` returns ``true`` if two matrices ``x`` and ``y`` are equal.
``not_equal x y`` returns ``true`` if there is at least one element in ``x`` is not equal to that in ``y``.
``greater x y`` returns ``true`` if all the elements in ``x`` are greater than the corresponding elements in ``y``.
``less x y`` returns ``true`` if all the elements in ``x`` are smaller than the corresponding elements in ``y``.
``greater_equal x y`` returns ``true`` if all the elements in ``x`` are not smaller than the corresponding elements in ``y``.
``less_equal x y`` returns ``true`` if all the elements in ``x`` are not greater than the corresponding elements in ``y``.
Randomisation functions
``permutation_matrix m`` returns an ``m`` by ``m`` permutation matrix.
``draw_rows x m`` draws ``m`` rows randomly from ``x``. The row indices are also returned in an int array along with the selected rows. The parameter ``replacement`` indicates whether the drawing is by replacement or not.
``draw_cols x m`` draws ``m`` cols randomly from ``x``. The column indices are also returned in an int array along with the selected columns. The parameter ``replacement`` indicates whether the drawing is by replacement or not.
``shuffle_rows x`` shuffles all the rows in matrix ``x``.
``shuffle_cols x`` shuffles all the columns in matrix ``x``.
``shuffle x`` shuffles all the elements in ``x`` by first shuffling along the rows then shuffling along columns. It is equivalent to ``shuffle_cols (shuffle_rows x)``.
Input/Output and helper functions
``to_dense x`` converts ``x`` into a dense matrix.
``of_dense x`` returns a sparse matrix from the dense matrix ``x``.
``pp_spmat x`` pretty prints matrix ``x`` with headings. Toplevel uses this function to print out the matrices.
``save x f`` saves the matrix ``x`` to a file with the name ``f``. The format is binary by using ``Marshal`` module to serialise the matrix.
``load k f`` loads a sparse matrix from file ``f``. The file must be previously saved by using ``save`` function.
Unary mathematical operations
``minmax x`` returns both the minimum and minimum values in ``x``.
``mean x`` returns the mean value of all the elements in ``x``. It is equivalent to calculate ``sum x`` divided by ``numel x``
``sum_rows x`` returns the summation of all the row vectors in ``x``.
``sum_cols`` returns the summation of all the column vectors in ``x``.
``mean_rows x`` returns the mean value of all row vectors in ``x``. It is equivalent to ``div_scalar (sum_rows x) (float_of_int (row_num x))``.
``mean_cols x`` returns the mean value of all column vectors in ``x``. It is equivalent to ``div_scalar (sum_cols x) (float_of_int (col_num x))``.
``abs x`` returns a new matrix where each element has the absolute value of that in the original matrix ``x``.
``neg x`` returns a new matrix where each element has the negative value of that in the original matrix ``x``.
Binary mathematical operations
``add x y`` adds two matrices ``x`` and ``y``. Both must have the same dimensions.
``sub x y`` subtracts the matrix ``x`` from ``y``. Both must have the same dimensions.
``mul x y`` performs an element-wise multiplication, so both ``x`` and ``y`` must have the same dimensions.
``div x y`` performs an element-wise division, so both ``x`` and ``y`` must have the same dimensions.
``dot x y`` calculates the dot product of an ``m`` by ``n`` matrix ``x`` and another ``n`` by ``p`` matrix ``y``.
``mul_scalar x a`` multiplies every element in ``x`` by a constant factor ``a``.
``div_scalar x a`` divides every element in ``x`` by a constant factor ``a``.
``power x a`` calculates the power of ``a`` of each element in ``x``.
ends here