FsAlg: Generic Linear Algebra Library

FsAlg is a linear algebra library that supports generic types. It is implemented in the F# language.

The library provides generic Vector and Matrix types that support most of the commonly used linear algebra operations, including matrix–vector operations, matrix inverse, determinants, eigenvalues, LU and QR decompositions. Its intended use is to enable writing generic linear algebra code with custom numeric types. It can also be used as a lightweight library for prototyping and scripting with primitive floating point types.

FsAlg is developed by Atılım Güneş Baydin and Barak A. Pearlmutter as part of their work at the Brain and Computation Lab, Hamilton Institute, National University of Ireland Maynooth.

How to Get

You can install the library via NuGet. You can also download the source code or the binaries of the latest release on GitHub.

The FsAlg library is available on NuGet. To install, run the following command in the Package Manager Console:

PM> Install-Package FsAlg

Quick Usage Example

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19:

open FsAlg.Generic

let A = matrix [[3.; 1.]; [2.; -1.]]
let b = vector [5.; 0.]

// Solve a matrix equation
let x = Matrix.solve A b

// Find inverse of A
let Ainv = Matrix.inverse A

// Initialize a vector
let w = Vector.init 2 (fun i -> float (i * i))

// Map a function to a vector
let y = Vector.map (fun x -> sin (exp x)) w

// Matrix-vector operations
let z = A * (x - y)

namespace FsAlg

namespace FsAlg.Generic

val A : Matrix<float>

Full name: Index.A

val matrix : m:seq<seq<'T>> -> Matrix<'T> (requires member get_Zero and member get_One and member ( + ) and member ( - ) and member ( * ) and member ( / ) and member ( ~- ) and member Abs and member Pow and member Sqrt and member op_Explicit and comparison)

Full name: FsAlg.Generic.Ops.matrix

val b : Vector<float>

Full name: Index.b

val vector : v:seq<'T> -> Vector<'T> (requires member get_Zero and member get_One and member ( + ) and member ( - ) and member ( * ) and member ( / ) and member ( ~- ) and member Abs and member Pow and member Sqrt and member op_Explicit and comparison)

Full name: FsAlg.Generic.Ops.vector

val x : Vector<float>

Full name: Index.x

Multiple items
union case Matrix.Matrix: 'T [,] -> Matrix<'T>

--------------------
module Matrix

from FsAlg.Generic

--------------------
type Matrix<'T (requires member get_Zero and member get_One and member ( + ) and member ( - ) and member ( * ) and member ( / ) and member ( ~- ) and member Abs and member Pow and member Sqrt and member op_Explicit and comparison)> =
  | ZeroMatrix of 'T
  | Matrix of 'T [,]
  member Copy : unit -> Matrix<'T>
  member GetDeterminant : unit -> 'T
  member GetDiagonal : unit -> 'T []
  member GetEigenvalues : unit -> 'T []
  member GetEnumerator : unit -> IEnumerator<'T>
  member GetInverse : unit -> Matrix<'T>
  member GetLUDecomposition : unit -> Matrix<'T> * int [] * 'T
  member GetQRDecomposition : unit -> Matrix<'T> * Matrix<'T>
  member GetSlice : rowStart:int option * rowFinish:int option * col:int -> Matrix<'T>
  member GetSlice : row:int * colStart:int option * colFinish:int option -> Matrix<'T>
  member GetSlice : rowStart:int option * rowFinish:int option * colStart:int option * colFinish:int option -> Matrix<'T>
  member GetTrace : unit -> 'T
  member GetTranspose : unit -> Matrix<'T>
  member ToArray : unit -> 'T [] []
  member ToArray2D : unit -> 'T [,]
  member ToMathematicaString : unit -> string
  member ToMatlabString : unit -> string
  member ToSeq : unit -> seq<'T>
  member Cols : int
  member Item : i:int * j:int -> 'T with get
  member Rows : int
  member Item : i:int * j:int -> 'T with set
  static member Zero : Matrix<'T>
  static member ( + ) : a:'T * b:Matrix<'T> -> Matrix<'T>
  static member ( + ) : a:Matrix<'T> * b:'T -> Matrix<'T>
  static member ( + ) : a:Matrix<'T> * b:Matrix<'T> -> Matrix<'T>
  static member ( / ) : a:'T * b:Matrix<'T> -> Matrix<'T>
  static member ( / ) : a:Matrix<'T> * b:'T -> Matrix<'T>
  static member ( ./ ) : a:Matrix<'T> * b:Matrix<'T> -> Matrix<'T>
  static member ( .* ) : a:Matrix<'T> * b:Matrix<'T> -> Matrix<'T>
  static member op_Explicit : m:Matrix<'T> -> float [,]
  static member ( * ) : a:'T * b:Matrix<'T> -> Matrix<'T>
  static member ( * ) : a:Matrix<'T> * b:'T -> Matrix<'T>
  static member ( * ) : a:Vector<'T> * b:Matrix<'T> -> Vector<'T>
  static member ( * ) : a:Matrix<'T> * b:Vector<'T> -> Vector<'T>
  static member ( * ) : a:Matrix<'T> * b:Matrix<'T> -> Matrix<'T>
  static member ( - ) : a:'T * b:Matrix<'T> -> Matrix<'T>
  static member ( - ) : a:Matrix<'T> * b:'T -> Matrix<'T>
  static member ( - ) : a:Matrix<'T> * b:Matrix<'T> -> Matrix<'T>
  static member ( ~- ) : a:Matrix<'T> -> Matrix<'T>

Full name: FsAlg.Generic.Matrix<_>

val solve : a:Matrix<'T> -> b:Vector<'T> -> Vector<'T> (requires member get_Zero and member get_One and member ( + ) and member ( - ) and member ( * ) and member ( / ) and member ( ~- ) and member Abs and member Pow and member Sqrt and member op_Explicit and comparison)

Full name: FsAlg.Generic.Matrix.solve

val Ainv : Matrix<float>

Full name: Index.Ainv

val inverse : m:Matrix<'T> -> Matrix<'T> (requires member get_Zero and member get_One and member ( + ) and member ( - ) and member ( * ) and member ( / ) and member ( ~- ) and member Abs and member Pow and member Sqrt and member op_Explicit and comparison)

Full name: FsAlg.Generic.Matrix.inverse

val w : Vector<float>

Full name: Index.w

Multiple items
union case Vector.Vector: 'T [] -> Vector<'T>

--------------------
module Vector

from FsAlg.Generic

--------------------
type Vector<'T (requires member get_Zero and member get_One and member ( + ) and member ( - ) and member ( * ) and member ( / ) and member ( ~- ) and member Abs and member Pow and member Sqrt and member op_Explicit and comparison)> =
  | ZeroVector of 'T
  | Vector of 'T []
  member Convert : f:('T -> 'a) -> Vector<'a> (requires member get_Zero and member get_One and member ( + ) and member ( - ) and member ( * ) and member ( / ) and member ( ~- ) and member Abs and member Pow and member Sqrt and member op_Explicit and comparison)
  member Copy : unit -> Vector<'T>
  member GetEnumerator : unit -> IEnumerator<'T>
  member GetL1Norm : unit -> 'T
  member GetL2Norm : unit -> 'T
  member GetL2NormSq : unit -> 'T
  member GetLPNorm : p:'T -> 'T
  member GetMax : unit -> 'T
  member GetMaxBy : f:('T -> 'a1) -> 'T (requires comparison)
  member GetMin : unit -> 'T
  member GetMinBy : f:('T -> 'a1) -> 'T (requires comparison)
  member GetSlice : lower:int option * upper:int option -> Vector<'T>
  member GetSubVector : s:int * c:int -> Vector<'T>
  member GetUnitVector : unit -> Vector<'T>
  member Split : n:seq<int> -> seq<Vector<'T>>
  member SplitEqual : n:int -> seq<Vector<'T>>
  member ToArray : unit -> 'T []
  member ToMathematicaString : unit -> string
  member ToMatlabString : unit -> string
  member ToSeq : unit -> seq<'T>
  member FirstItem : 'T
  member Item : i:int -> 'T with get
  member Length : int
  member Item : i:int -> 'T with set
  static member Zero : Vector<'T>
  static member ( + ) : a:'T * b:Vector<'T> -> Vector<'T>
  static member ( + ) : a:Vector<'T> * b:'T -> Vector<'T>
  static member ( + ) : a:Vector<'T> * b:Vector<'T> -> Vector<'T>
  static member ( / ) : a:'T * b:Vector<'T> -> Vector<'T>
  static member ( / ) : a:Vector<'T> * b:'T -> Vector<'T>
  static member ( ./ ) : a:Vector<'T> * b:Vector<'T> -> Vector<'T>
  static member ( .* ) : a:Vector<'T> * b:Vector<'T> -> Vector<'T>
  static member op_Explicit : v:Vector<'T> -> float []
  static member ( * ) : a:'T * b:Vector<'T> -> Vector<'T>
  static member ( * ) : a:Vector<'T> * b:'T -> Vector<'T>
  static member ( * ) : a:Vector<'T> * b:Vector<'T> -> 'T
  static member ( %* ) : a:Vector<'T> * b:Vector<'T> -> Vector<'T>
  static member ( - ) : a:'T * b:Vector<'T> -> Vector<'T>
  static member ( - ) : a:Vector<'T> * b:'T -> Vector<'T>
  static member ( - ) : a:Vector<'T> * b:Vector<'T> -> Vector<'T>
  static member ( ~- ) : a:Vector<'T> -> Vector<'T>

Full name: FsAlg.Generic.Vector<_>

val init : n:int -> f:(int -> 'T) -> Vector<'T> (requires member get_Zero and member get_One and member ( + ) and member ( - ) and member ( * ) and member ( / ) and member ( ~- ) and member Abs and member Pow and member Sqrt and member op_Explicit and comparison)

Full name: FsAlg.Generic.Vector.init

val i : int

Multiple items
val float : value:'T -> float (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.float

--------------------
type float = System.Double

Full name: Microsoft.FSharp.Core.float

--------------------
type float<'Measure> = float

Full name: Microsoft.FSharp.Core.float<_>

val y : Vector<float>

Full name: Index.y

val map : f:('T -> 'U) -> v:Vector<'T> -> Vector<'U> (requires member get_Zero and member get_One and member ( + ) and member ( - ) and member ( * ) and member ( / ) and member ( ~- ) and member Abs and member Pow and member Sqrt and member op_Explicit and comparison and member get_Zero and member get_One and member ( + ) and member ( - ) and member ( * ) and member ( / ) and member ( ~- ) and member Abs and member Pow and member Sqrt and member op_Explicit and comparison)

Full name: FsAlg.Generic.Vector.map

val x : float

val sin : value:'T -> 'T (requires member Sin)

Full name: Microsoft.FSharp.Core.Operators.sin

val exp : value:'T -> 'T (requires member Exp)

Full name: Microsoft.FSharp.Core.Operators.exp

val z : Vector<float>

Full name: Index.z