A module internal to `Core_bench`. Please look at Bench.

Some basic linear algebra code, so that basic operations can be done without introducing a dependency on Lacaml/LAPACK. Currently only has the minimum needed to do ordinary least squares.

Matrices are represented via `float array array`, in row-major order.

`module Vec : `sig .. end``
Vectors
`type t = `float array``
`val copy : `t -> t``
Copy a vector
`val create0 : `int -> t``
`create0 len` sreate a vector of 0s of length `len`.
`val sumsq : `t -> float``
The sum of squares of entries in a vector
`val norm : `t -> float``
The Euclidean length of a vector
`val t_of_sexp : `Sexplib.Sexp.t -> t``
`val sexp_of_t : `t -> Sexplib.Sexp.t``
`module Mat : `sig .. end``
Matrices
`type t = `float array array``
`val copy : `t -> t``
Copy a matrix
`val create0 : `rows:int -> cols:int -> t``
Create a matrix of 0s
`val create_per_row : `rows:int -> cols:int -> f:(int -> float) -> t``
`val get_column : `t -> int -> Vec.t``
Extract a column. Data is copied. Indices start at 0.
`val t_of_sexp : `Sexplib.Sexp.t -> t``
`val sexp_of_t : `t -> Sexplib.Sexp.t``
`val qr : `?in_place:bool -> Mat.t -> Mat.t * Mat.t``
`qr A` returns the QR-decomposition of `A` as a pair (Q,R). `A` must have at least as many rows as columns and have full rank.

If `in_place` (default: `false`) is `true`, then `A` is overwritten with `Q`.

`val triu_solve : `Mat.t -> Vec.t -> Vec.t Core.Std.Or_error.t``
`triu_solve R b` solves R x = b where `R` is an m x m upper-triangular matrix and `b` is an m x 1 column vector.
`val mul_mv : `?transa:bool -> Mat.t -> Vec.t -> Vec.t``
`mul_mv A x` computes the product `A * x` (where `M` is a matrix and `x` is a column vector).
`val ols : `?in_place:bool -> Mat.t -> Vec.t -> Vec.t Core.Std.Or_error.t``
`ols A b` computes the ordinary least-squares solution to A x = b. `A` must have at least as many rows as columns and have full rank.

This can be used to compute solutions to non-singular square systems, but is somewhat sub-optimal for that purpose. The algorithm is to factor A = Q * R and solve R x = Q' b where Q' denotes the transpose of Q.

If `in_place` (default: `false`) is `true`, then `A` will be destroyed.