Matrix Operations

This page lists only a selection of commonly used matrix operations provided by FsAlg.

Please refer to API Reference for a full list of supported operations.

The FsAlg.Generic.Matrix module provides functionality similar to the F# Collecitons.Array2D module, for creating and manipulating matrices.

Creating Matrices

1: 
2: 
3: 
4: 
5:

open FsAlg.Generic

let m1 = matrix [[1.; 2.]; [3.; 4.]]
let m2 = Matrix.create 2 2 1.
let m3 = Matrix.init 2 2 (fun i j -> exp (float (i + j)))

val m1 : Matrix<float> = Matrix [[1.0; 1.0]
                                 [1.0; 1.0]]
val m2 : Matrix<float> = Matrix [[1.0; 1.0]
                                 [1.0; 1.0]]
val m3 : Matrix<float> = Matrix [[1.0; 2.718281828]
                                 [2.718281828; 7.389056099]]

Basic Operations

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

let m4 = m1 + m2  // Matrix addition
let m5 = m1 - m2  // Matrix subtraction
let m6 = m1 * m2  // Matrix product
let m7 = m1 .* m2 // Matrix element-wise (Hadamard) product
let m8 = m1 ./ m2 // Matrix element-wise (Hadamard) division

let v = vector [1.; 2.]
let m9 = m1 * v   // Matrix-vector product
let m10 = v * m1  // Vector-matrix product

let m11 = m1 + 2. // Add scalar to matrix
let m12 = m1 - 2. // Subtract scalar from matrix
let m13 = 2. - m1 // Subtract each element of matrix from scalar
let m14 = m1 * 2. // Matrix-scalar multiplication
let m15 = m1 / 2. // Matrix-scalar division
let m16 = 2. / m1 // Divides each element of matrix by scalar
let m17 = -m1     // Unary negation

val m4 : Matrix<float> = Matrix [[2.0; 3.0]
                                 [4.0; 5.0]]
val m5 : Matrix<float> = Matrix [[0.0; 1.0]
                                 [2.0; 3.0]]
val m6 : Matrix<float> = Matrix [[3.0; 3.0]
                                 [7.0; 7.0]]
val m7 : Matrix<float> = Matrix [[1.0; 2.0]
                                 [3.0; 4.0]]
val m8 : Matrix<float> = Matrix [[1.0; 2.0]
                                 [3.0; 4.0]]
val v : Vector<float> = Vector [|1.0; 2.0|]
val m9 : Vector<float> = Vector [|5.0; 11.0|]
val m10 : Vector<float> = Vector [|7.0; 10.0|]
val m11 : Matrix<float> = Matrix [[3.0; 4.0]
                                  [5.0; 6.0]]
val m12 : Matrix<float> = Matrix [[-1.0; 0.0]
                                  [1.0; 2.0]]
val m13 : Matrix<float> = Matrix [[1.0; 0.0]
                                  [-1.0; -2.0]]
val m14 : Matrix<float> = Matrix [[2.0; 4.0]
                                  [6.0; 8.0]]
val m15 : Matrix<float> = Matrix [[0.5; 1.0]
                                  [1.5; 2.0]]
val m16 : Matrix<float> = Matrix [[2.0; 1.0]
                                  [0.6666666667; 0.5]]
val m17 : Matrix<float> = Matrix [[-1.0; -2.0]
                                  [-3.0; -4.0]]

Matrix Operations

1: 
2: 
3: 
4: 
5: 
6:

let m1det = Matrix.det m1         // Determinant
let m1inv = Matrix.inverse m1     // Inverse
let m1eig = Matrix.eigenvalues m1 // Eigenvalues
let m1t   = Matrix.transpose m1   // Transpose
let m1tr  = Matrix.trace m1       // Trace
let m1dia = Matrix.diagonal m1    // Diagonal

val m1det : float = -2.0
val m1inv : Matrix<float> = Matrix [[-2.0; 1.0]
                                    [1.5; -0.5]]
val m1eig : Vector<float> = Vector [|5.372281312; -0.3722813117|]
val m1t : Matrix<float> = Matrix [[1.0; 3.0]
                                  [2.0; 4.0]]
val m1tr : float = 5.0
val m1dia : Vector<float> = Vector [|1.0; 4.0|]

Solving Systems of Linear Equations

We can solve a system of linear equations represented in matrix form \(\mathbf{A} \mathbf{x} = \mathbf{b} \;,\) which has solution \(\mathbf{x} = \mathbf{A}^{-1} \mathbf{b}\;\).

For example, the system

\[ \begin{eqnarray*} 3x + 2y - z &=& 1\\ 2x - 2y +4z &=& -2\\ -x + 0.5y -z &=& 0\\ \end{eqnarray*}\]

can be represented as

\[ \begin{bmatrix} 3 & 2 & -1\\ 2 & -2 & 4\\ -1& 0.5 &-1\\ \end{bmatrix} \begin{bmatrix} x\\ y\\ z\\ \end{bmatrix} = \begin{bmatrix} 1\\ -2\\ 0\\ \end{bmatrix}\]

and has solution

\[ \begin{eqnarray*} x &=& 1\\ y &=& -2\\ z &=& -2\\ \end{eqnarray*}\; .\]

1: 
2: 
3: 
4:

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

let x = Matrix.solve A b

val A : Matrix<float> = Matrix [[3.0; 2.0; -1.0]
                                [2.0; -2.0; 4.0]
                                [-1.0; 0.5; -1.0]]
val b : Vector<float> = Vector [|1.0; -2.0; 0.0|]
val x : Vector<float> = Vector [|1.0; -2.0; -2.0|]

Matrix Decompositions

1: 
2:

let lu, piv, togg = Matrix.decomposeLU m1 // LU decomposition
let q, r = Matrix.decomposeQR m1 // QR decomposition

val togg : float = -1.0
val piv : int [] = [|1; 0|]
val lu : Matrix<float> = Matrix [[3.0; 4.0]
                                 [0.3333333333; 0.6666666667]]
val r : Matrix<float> = Matrix [[3.16227766; 4.427188724]
                                [4.440892099e-16; 0.632455532]]
val q : Matrix<float> = Matrix [[0.316227766; 0.9486832981]
                                [0.9486832981; -0.316227766]]

Accessing Elements & Conversions

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

let el1 = m1.[0, 0]         // Element at 0, 0
let el2 = Matrix.get m1 1 1 // Element at 1, 1
let sl1 = m1.[0..1, 1..]    // Slice, between rows 0 and 1, columns 1 and beyond
let sl2 = m1.[*, 0..1]      // Slice, all rows, between columns 0 and 1
let sl3 = m1.[0, *]         // Return row 0
let sl4 = Matrix.row 0 m1   // Return row 0
let sl5 = m1.[*, 1]         // Return column 1
let sl6 = Matrix.col 1 m1   // Return column 1
let sl7 = Matrix.toRows m1  // Return rows as a sequence
let m18 = Matrix.ofRows [vector [1.;2.]; vector [3.;4.]] // Create matrix from row vectors
let sl8 = Matrix.toCols m1  // Return columns as a sequence
let m19 = Matrix.ofCols [vector [1.;2.]; vector [3.;4.]] // Create matrix from column vectors
let m20 = Matrix.ofSeqSeq [[1.; 2.]; [3.; 4.]]  // Convert sequence of sequences to matrix
let m21 = matrix [[1.; 2.]; [3.; 4.]]        // Same with above, supports lists,
let m22 = matrix [|[|1.; 2.|]; [|3.; 4.|]|]  // arrays,
let m23 = matrix (seq {yield seq {yield 1.}}) // and sequences.
let aa1 = Matrix.toArrayArray m1   // Convert matrix to jagged array
let aa2 = Matrix.toArray2D m1   // Convert matrix to 2d array
let aa3 = Matrix.toArray m1     // Convert matrix to 1d array, scanning left to right, top to bottom
let ma3 = Matrix.ofArray 2 aa3  // Convert 1d array to matrix, populating two rows
let vv1 = Matrix.toVector m1    // Convert matrix to vector, scanning left to right, top to bottom
let mv1 = Matrix.ofVector 2 vv1 // Convert vector to matrix, populating two rows

val el1 : float = 1.0
val el2 : float = 4.0
val sl1 : Matrix<float> = Matrix [[2.0]
                                  [4.0]]
val sl2 : Matrix<float> = Matrix [[1.0; 2.0]
                                  [3.0; 4.0]]
val sl3 : Matrix<float> = Matrix [[1.0; 2.0]]
val sl4 : Matrix<float> = Matrix [[1.0; 2.0]]
val sl5 : Matrix<float> = Matrix [[2.0]
                                  [4.0]]
val sl6 : Matrix<float> = Matrix [[2.0]
                                  [4.0]]
val sl7 : seq<Matrix<float>>
val m18 : Matrix<float> = Matrix [[1.0; 2.0]
                                  [3.0; 4.0]]
val sl8 : seq<Matrix<float>>
val m19 : Matrix<float> = Matrix [[1.0; 3.0]
                                  [2.0; 4.0]]
val m20 : Matrix<float> = Matrix [[1.0; 2.0]
                                  [3.0; 4.0]]
val m21 : Matrix<float> = Matrix [[1.0; 2.0]
                                  [3.0; 4.0]]
val m22 : Matrix<float> = Matrix [[1.0; 2.0]
                                  [3.0; 4.0]]
val m23 : Matrix<float> = Matrix [[1.0]]
val aa1 : float [] [] = [|[|1.0; 2.0|]; [|3.0; 4.0|]|]
val aa2 : float [,] = [[1.0; 1.0]
                       [1.0; 1.0]]
val aa3 : float [] = [|1.0; 2.0; 3.0; 4.0|]
val ma3 : Matrix<float> = Matrix [[1.0; 2.0]
                                  [3.0; 4.0]]
val vv1 : Vector<float> = Vector [|1.0; 2.0; 3.0; 4.0|]
val mv1 : Matrix<float> = Matrix [[1.0; 2.0]
                                  [3.0; 4.0]]

Mutating/Replacing Elements

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10:

m1.[0, 0] <- 4. // Mutate an element
Matrix.replace (fun x -> x + 2.) m1 // Replace by mapping a function, mutating in place
Matrix.replacei (fun i j x -> x + float (i * j)) m1 // Replace in place, with index
Matrix.replace2 (fun x y -> x - y) m1 m2 // Replace m1 in place, using a function of m1 and m2
Matrix.replacei2 (fun i j x y -> x - y + float (i * j)) m1 m2 // Replace m1 in place, with index
Matrix.replaceWith m1 m2  // Replace elements of m1 with m2, mutating in place
Matrix.appendRow v m1     // Append a vector to a matrix as a new row
Matrix.appendCol v m1  // Append a vector to a matrix as a new column
Matrix.prependRow v m1    // Prepend a vector to a matrix as a new row
Matrix.prependCol v m1 // Prepend a vector to a matrix as a new column

Mathematica and MATLAB Strings

You can generate string representations of matrices that you can copy and paste into Mathematica notebooks or MATLAB.

1: 
2:

let s1 = m1.ToMathematicaString()
let s2 = m2.ToMatlabString()

val s1 : string = "{{1.00, 2.00}, {3.00, 4.00}}"
val s2 : string = "[1.00 1.00; 1.00 1.00]"

Other Operations

The following are just a selection of other operations. Please refer to API Reference for a full list of supported operations.

1: 
2: 
3:

let l1  = Matrix.rows m1 // Number of rows
let l2  = Matrix.cols m1 // Number of columns
let m24 = Matrix.map (fun x -> sin x) m1 // Map function to matrix

val l1 : int = 2
val l2 : int = 2
val m24 : Matrix<float> = Matrix [[0.8414709848; 0.8414709848]
                                  [0.8414709848; 0.8414709848]]

namespace FsAlg

namespace FsAlg.Generic

val m1 : Matrix<float>

Full name: Matrix-operations.m1

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 m2 : Matrix<float>

Full name: Matrix-operations.m2

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 create : m:int -> n:int -> v:'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.create

val m3 : Matrix<float>

Full name: Matrix-operations.m3

val init : m:int -> n:int -> f:(int -> int -> '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.init

val i : int

val j : int

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

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

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 printf : format:Printf.TextWriterFormat<'T> -> 'T

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.printf

val m4 : Matrix<float>

Full name: Matrix-operations.m4

val m5 : Matrix<float>

Full name: Matrix-operations.m5

val m6 : Matrix<float>

Full name: Matrix-operations.m6

val m7 : Matrix<float>

Full name: Matrix-operations.m7

val m8 : Matrix<float>

Full name: Matrix-operations.m8

val v : Vector<float>

Full name: Matrix-operations.v

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 m9 : Vector<float>

Full name: Matrix-operations.m9

val m10 : Vector<float>

Full name: Matrix-operations.m10

val m11 : Matrix<float>

Full name: Matrix-operations.m11

val m12 : Matrix<float>

Full name: Matrix-operations.m12

val m13 : Matrix<float>

Full name: Matrix-operations.m13

val m14 : Matrix<float>

Full name: Matrix-operations.m14

val m15 : Matrix<float>

Full name: Matrix-operations.m15

val m16 : Matrix<float>

Full name: Matrix-operations.m16

val m17 : Matrix<float>

Full name: Matrix-operations.m17

val m1det : float

Full name: Matrix-operations.m1det

val det : m:Matrix<'T> -> '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.det

val m1inv : Matrix<float>

Full name: Matrix-operations.m1inv

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 m1eig : Vector<float>

Full name: Matrix-operations.m1eig

val eigenvalues : m:Matrix<'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.eigenvalues

val m1t : Matrix<float>

Full name: Matrix-operations.m1t

val transpose : 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.transpose

val m1tr : float

Full name: Matrix-operations.m1tr

val trace : m:Matrix<'T> -> '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.trace

val m1dia : Vector<float>

Full name: Matrix-operations.m1dia

val diagonal : m:Matrix<'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.diagonal

val A : Matrix<float>

Full name: Matrix-operations.A

val b : Vector<float>

Full name: Matrix-operations.b

val x : Vector<float>

Full name: Matrix-operations.x

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 lu : Matrix<float>

Full name: Matrix-operations.lu

val piv : int []

Full name: Matrix-operations.piv

val togg : float

Full name: Matrix-operations.togg

val decomposeLU : m:Matrix<'T> -> Matrix<'T> * int [] * '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.decomposeLU

val q : Matrix<float>

Full name: Matrix-operations.q

val r : Matrix<float>

Full name: Matrix-operations.r

val decomposeQR : m:Matrix<'T> -> 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.decomposeQR

val el1 : float

Full name: Matrix-operations.el1

val el2 : float

Full name: Matrix-operations.el2

val get : m:Matrix<'T> -> i:int -> j:int -> '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.get

val sl1 : Matrix<float>

Full name: Matrix-operations.sl1

val sl2 : Matrix<float>

Full name: Matrix-operations.sl2

val sl3 : Matrix<float>

Full name: Matrix-operations.sl3

val sl4 : Matrix<float>

Full name: Matrix-operations.sl4

val row : i:int -> 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.row

val sl5 : Matrix<float>

Full name: Matrix-operations.sl5

val sl6 : Matrix<float>

Full name: Matrix-operations.sl6

val col : j:int -> 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.col

val sl7 : seq<Matrix<float>>

Full name: Matrix-operations.sl7

val toRows : m:Matrix<'T> -> seq<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.toRows

val m18 : Matrix<float>

Full name: Matrix-operations.m18

val ofRows : v:seq<Vector<'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.ofRows

val sl8 : seq<Matrix<float>>

Full name: Matrix-operations.sl8

val toCols : m:Matrix<'T> -> seq<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.toCols

val m19 : Matrix<float>

Full name: Matrix-operations.m19

val ofCols : v:seq<Vector<'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.ofCols

val m20 : Matrix<float>

Full name: Matrix-operations.m20

val ofSeqSeq : s: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.Matrix.ofSeqSeq

val m21 : Matrix<float>

Full name: Matrix-operations.m21

val m22 : Matrix<float>

Full name: Matrix-operations.m22

val m23 : Matrix<float>

Full name: Matrix-operations.m23

Multiple items
val seq : sequence:seq<'T> -> seq<'T>

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

--------------------
type seq<'T> = System.Collections.Generic.IEnumerable<'T>

Full name: Microsoft.FSharp.Collections.seq<_>

val aa1 : float [] []

Full name: Matrix-operations.aa1

val toArrayArray : m:Matrix<'T> -> '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.toArrayArray

val aa2 : float [,]

Full name: Matrix-operations.aa2

val toArray2D : m:Matrix<'T> -> '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.toArray2D

val aa3 : float []

Full name: Matrix-operations.aa3

val toArray : m:Matrix<'T> -> '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.toArray

val ma3 : Matrix<float>

Full name: Matrix-operations.ma3

val ofArray : m:int -> a:'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.ofArray

val vv1 : Vector<float>

Full name: Matrix-operations.vv1

val toVector : m:Matrix<'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.toVector

val mv1 : Matrix<float>

Full name: Matrix-operations.mv1

val ofVector : m:int -> v:Vector<'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.ofVector

val replace : f:('T -> 'T) -> m:Matrix<'T> -> unit (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.replace

val x : float

val replacei : f:(int -> int -> 'T -> 'T) -> m:Matrix<'T> -> unit (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.replacei

val replace2 : f:('T1 -> 'T2 -> 'T1) -> m1:Matrix<'T1> -> m2:Matrix<'T2> -> unit (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.Matrix.replace2

val y : float

val replacei2 : f:(int -> int -> 'T1 -> 'T2 -> 'T1) -> m1:Matrix<'T1> -> m2:Matrix<'T2> -> unit (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.Matrix.replacei2

val replaceWith : m1:Matrix<'T> -> m2:Matrix<'T> -> unit (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.replaceWith

val appendRow : v:Vector<'T> -> 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.appendRow

val appendCol : v:Vector<'T> -> 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.appendCol

val prependRow : v:Vector<'T> -> 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.prependRow

val prependCol : v:Vector<'T> -> 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.prependCol

val s1 : string

Full name: Matrix-operations.s1

member Matrix.ToMathematicaString : unit -> string

val s2 : string

Full name: Matrix-operations.s2

member Matrix.ToMatlabString : unit -> string

val l1 : int

Full name: Matrix-operations.l1

val rows : m:Matrix<'T> -> int (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.rows

val l2 : int

Full name: Matrix-operations.l2

val cols : m:Matrix<'T> -> int (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.cols

val m24 : Matrix<float>

Full name: Matrix-operations.m24

val map : f:('T -> 'U) -> m:Matrix<'T> -> Matrix<'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.Matrix.map

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

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