SpecializedGenericImpl Module

Generic operations that, when used on floating point types, use the specialized versions in DoubleImpl

Functions and values

Function or value Description

addM a b

Full Usage: addM a b

Parameters:
Returns: Matrix<'b>
a : Matrix<'b>
b : Matrix<'b>
Returns: Matrix<'b>

addRV a b

Full Usage: addRV a b

Parameters:
Returns: RowVector<'a>
a : RowVector<'a>
b : RowVector<'a>
Returns: RowVector<'a>

addScalarM a b

Full Usage: addScalarM a b

Parameters:
Returns: Matrix<'a>
a : 'a
b : Matrix<'a>
Returns: Matrix<'a>

addScalarRV a b

Full Usage: addScalarRV a b

Parameters:
Returns: RowVector<'a>
a : 'a
b : RowVector<'a>
Returns: RowVector<'a>

addScalarV a b

Full Usage: addScalarV a b

Parameters:
Returns: Vector<'a>
a : 'a
b : Vector<'a>
Returns: Vector<'a>

addV a b

Full Usage: addV a b

Parameters:
Returns: Vector<'b>
a : Vector<'b>
b : Vector<'b>
Returns: Vector<'b>

arrayM xss

Full Usage: arrayM xss

Parameters:
    xss : 'T[,]

Returns: Matrix<'T>
xss : 'T[,]
Returns: Matrix<'T>

arrayRV xss

Full Usage: arrayRV xss

Parameters:
    xss : 'T[]

Returns: RowVector<'T>
xss : 'T[]
Returns: RowVector<'T>

arraySM xss

Full Usage: arraySM xss

Parameters:
    xss : 'T[,]

Returns: Matrix<'T>
xss : 'T[,]
Returns: Matrix<'T>

arrayV xss

Full Usage: arrayV xss

Parameters:
    xss : 'T[]

Returns: Vector<'T>
xss : 'T[]
Returns: Vector<'T>

assignV f a

Full Usage: assignV f a

Parameters:
    f : int -> 'b
    a : Vector<'b>

Modifiers: inline
Type parameters: 'b
f : int -> 'b
a : Vector<'b>

binaryOpM opDenseDS opDenseGU opSparseDS opSparseMatrixGU a b

Full Usage: binaryOpM opDenseDS opDenseGU opSparseDS opSparseMatrixGU a b

Parameters:
Returns: Matrix<'e>
Modifiers: inline
opDenseDS : dmatrix -> dmatrix -> 'a
opDenseGU : DenseMatrix<'b> -> DenseMatrix<'c> -> 'd
opSparseDS : smatrix -> smatrix -> 'f
opSparseMatrixGU : SparseMatrix<'b> -> SparseMatrix<'c> -> 'g
a : Matrix<'b>
b : Matrix<'c>
Returns: Matrix<'e>

coerce2 x

Full Usage: coerce2 x

Parameters:
    x : 'a

Returns: 'b
x : 'a
Returns: 'b

combineHash x y

Full Usage: combineHash x y

Parameters:
    x : ^a
    y : ^b

Returns: int
Modifiers: inline
x : ^a
y : ^b
Returns: int

compareM comp a b

Full Usage: compareM comp a b

Parameters:
Returns: int
comp : IComparer
a : Matrix<'T>
b : Matrix<'T>
Returns: int

compareRV comp a b

Full Usage: compareRV comp a b

Parameters:
Returns: int
comp : IComparer
a : RowVector<'T>
b : RowVector<'T>
Returns: int

compareV comp a b

Full Usage: compareV comp a b

Parameters:
Returns: int
comp : IComparer
a : Vector<'T>
b : Vector<'T>
Returns: int

constDiagM n x

Full Usage: constDiagM n x

Parameters:
    n : int
    x : 'T

Returns: Matrix<'T>
n : int
x : 'T
Returns: Matrix<'T>

constM m n x

Full Usage: constM m n x

Parameters:
    m : int
    n : int
    x : 'T

Returns: Matrix<'T>
m : int
n : int
x : 'T
Returns: Matrix<'T>

constRV m x

Full Usage: constRV m x

Parameters:
    m : int
    x : 'T

Returns: RowVector<'T>
m : int
x : 'T
Returns: RowVector<'T>

constV m x

Full Usage: constV m x

Parameters:
    m : int
    x : 'T

Returns: Vector<'T>
m : int
x : 'T
Returns: Vector<'T>

copyM a

Full Usage: copyM a

Parameters:
Returns: Matrix<'b>
a : Matrix<'b>
Returns: Matrix<'b>

copyRV a

Full Usage: copyRV a

Parameters:
Returns: RowVector<'b>
a : RowVector<'b>
Returns: RowVector<'b>

copyV a

Full Usage: copyV a

Parameters:
Returns: Vector<'b>
a : Vector<'b>
Returns: Vector<'b>

countR (arg1, arg2)

Full Usage: countR (arg1, arg2)

Parameters:
    arg0 : int
    arg1 : int

Returns: int
arg0 : int
arg1 : int
Returns: int

cptMaxM a b

Full Usage: cptMaxM a b

Parameters:
Returns: Matrix<'b>
a : Matrix<'b>
b : Matrix<'b>
Returns: Matrix<'b>

cptMaxV a b

Full Usage: cptMaxV a b

Parameters:
Returns: Vector<'b>
a : Vector<'b>
b : Vector<'b>
Returns: Vector<'b>

cptMinM a b

Full Usage: cptMinM a b

Parameters:
Returns: Matrix<'b>
a : Matrix<'b>
b : Matrix<'b>
Returns: Matrix<'b>

cptMinV a b

Full Usage: cptMinV a b

Parameters:
Returns: Vector<'b>
a : Vector<'b>
b : Vector<'b>
Returns: Vector<'b>

cptMulM a b

Full Usage: cptMulM a b

Parameters:
Returns: Matrix<'b>
a : Matrix<'b>
b : Matrix<'b>
Returns: Matrix<'b>

cptMulRV a b

Full Usage: cptMulRV a b

Parameters:
Returns: RowVector<'a>
a : RowVector<'a>
b : RowVector<'a>
Returns: RowVector<'a>

cptMulV a b

Full Usage: cptMulV a b

Parameters:
Returns: Vector<'b>
a : Vector<'b>
b : Vector<'b>
Returns: Vector<'b>

createMx ops rows columns f

Full Usage: createMx ops rows columns f

Parameters:
    ops : OpsData<'a>
    rows : int
    columns : int
    f : int -> int -> 'a

Returns: Matrix<'a>
Modifiers: inline
ops : OpsData<'a>
rows : int
columns : int
f : int -> int -> 'a
Returns: Matrix<'a>

createNumericV m f

Full Usage: createNumericV m f

Parameters:
Returns: Vector<'T>
m : int
f : INumeric<'T> -> int -> 'T
Returns: Vector<'T>

createRVx ops m f

Full Usage: createRVx ops m f

Parameters:
    ops : INumeric<'a> option
    m : int
    f : int -> 'a

Returns: RowVector<'a>
Modifiers: inline
ops : INumeric<'a> option
m : int
f : int -> 'a
Returns: RowVector<'a>

createVx ops m f

Full Usage: createVx ops m f

Parameters:
    ops : INumeric<'a> option
    m : int
    f : int -> 'a

Returns: Vector<'a>
Modifiers: inline
ops : INumeric<'a> option
m : int
f : int -> 'a
Returns: Vector<'a>

dense x

Full Usage: dense x

Parameters:
Returns: Matrix<'a>
Modifiers: inline
Type parameters: 'a
x : DenseMatrix<'a>
Returns: Matrix<'a>

diagM v

Full Usage: diagM v

Parameters:
Returns: Matrix<'b>
v : Vector<'b>
Returns: Matrix<'b>

diagnM v n

Full Usage: diagnM v n

Parameters:
Returns: Matrix<'a>
v : Vector<'a>
n : int
Returns: Matrix<'a>

dotM a b

Full Usage: dotM a b

Parameters:
Returns: 'b
a : Matrix<'b>
b : Matrix<'b>
Returns: 'b

dotV a b

Full Usage: dotV a b

Parameters:
Returns: 'b
a : Vector<'b>
b : Vector<'b>
Returns: 'b

equalsM comp a b

Full Usage: equalsM comp a b

Parameters:
Returns: bool
comp : IEqualityComparer
a : Matrix<'T>
b : Matrix<'T>
Returns: bool

equalsRV comp a b

Full Usage: equalsRV comp a b

Parameters:
Returns: bool
comp : IEqualityComparer
a : RowVector<'T>
b : RowVector<'T>
Returns: bool

equalsV comp a b

Full Usage: equalsV comp a b

Parameters:
Returns: bool
comp : IEqualityComparer
a : Vector<'T>
b : Vector<'T>
Returns: bool

existsM f a

Full Usage: existsM f a

Parameters:
    f : 'b -> bool
    a : Matrix<'b>

Returns: bool
f : 'b -> bool
a : Matrix<'b>
Returns: bool

existsV f a

Full Usage: existsV f a

Parameters:
    f : 'a -> bool
    a : Vector<'a>

Returns: bool
f : 'a -> bool
a : Vector<'a>
Returns: bool

existsiM f a

Full Usage: existsiM f a

Parameters:
    f : int -> int -> 'b -> bool
    a : Matrix<'b>

Returns: bool
f : int -> int -> 'b -> bool
a : Matrix<'b>
Returns: bool

existsiV f a

Full Usage: existsiV f a

Parameters:
    f : int -> 'a -> bool
    a : Vector<'a>

Returns: bool
f : int -> 'a -> bool
a : Vector<'a>
Returns: bool

floatUnaryOpM opDenseDS opDenseGU opSparseDS opSparseMatrixGU b

Full Usage: floatUnaryOpM opDenseDS opDenseGU opSparseDS opSparseMatrixGU b

Parameters:
Returns: 'b
Modifiers: inline
opDenseDS : dmatrix -> float
opDenseGU : DenseMatrix<'a> -> 'b
opSparseDS : smatrix -> float
opSparseMatrixGU : SparseMatrix<'a> -> 'b
b : Matrix<'a>
Returns: 'b

foldM f z a

Full Usage: foldM f z a

Parameters:
    f : 'c -> 'd -> 'c
    z : 'c
    a : Matrix<'d>

Returns: 'c
Modifiers: inline
Type parameters: 'c, 'd
f : 'c -> 'd -> 'c
z : 'c
a : Matrix<'d>
Returns: 'c

foldV f z a

Full Usage: foldV f z a

Parameters:
    f : 'a -> 'b -> 'a
    z : 'a
    a : Vector<'b>

Returns: 'a
Modifiers: inline
Type parameters: 'a, 'b
f : 'a -> 'b -> 'a
z : 'a
a : Vector<'b>
Returns: 'a

foldiM f z a

Full Usage: foldiM f z a

Parameters:
    f : int -> int -> 'c -> 'd -> 'c
    z : 'c
    a : Matrix<'d>

Returns: 'c
Modifiers: inline
Type parameters: 'c, 'd
f : int -> int -> 'c -> 'd -> 'c
z : 'c
a : Matrix<'d>
Returns: 'c

foldiV f z a

Full Usage: foldiV f z a

Parameters:
    f : int -> 'a -> 'b -> 'a
    z : 'a
    a : Vector<'b>

Returns: 'a
Modifiers: inline
Type parameters: 'a, 'b
f : int -> 'a -> 'b -> 'a
z : 'a
a : Vector<'b>
Returns: 'a

forallM f a

Full Usage: forallM f a

Parameters:
    f : 'b -> bool
    a : Matrix<'b>

Returns: bool
f : 'b -> bool
a : Matrix<'b>
Returns: bool

forallV f a

Full Usage: forallV f a

Parameters:
    f : 'a -> bool
    a : Vector<'a>

Returns: bool
f : 'a -> bool
a : Vector<'a>
Returns: bool

foralliM f a

Full Usage: foralliM f a

Parameters:
    f : int -> int -> 'b -> bool
    a : Matrix<'b>

Returns: bool
f : int -> int -> 'b -> bool
a : Matrix<'b>
Returns: bool

foralliV f a

Full Usage: foralliV f a

Parameters:
    f : int -> 'a -> bool
    a : Vector<'a>

Returns: bool
f : int -> 'a -> bool
a : Vector<'a>
Returns: bool

getColM a j

Full Usage: getColM a j

Parameters:
Returns: Vector<'b>

Returns col of index i of matrix a as a vector

a : Matrix<'b>
j : int
Returns: Vector<'b>

getColsM a (arg2, arg3)

Full Usage: getColsM a (arg2, arg3)

Parameters:
    a : Matrix<'b>
    arg1 : int
    arg2 : int

Returns: Matrix<'b>
a : Matrix<'b>
arg1 : int
arg2 : int
Returns: Matrix<'b>

getDiagM a

Full Usage: getDiagM a

Parameters:
Returns: Vector<'a>
a : Matrix<'a>
Returns: Vector<'a>

getDiagnM a n

Full Usage: getDiagnM a n

Parameters:
Returns: Vector<'b>
a : Matrix<'b>
n : int
Returns: Vector<'b>

getRegionM a (arg2, arg3) (arg4, arg5)

Full Usage: getRegionM a (arg2, arg3) (arg4, arg5)

Parameters:
    a : Matrix<'b>
    arg1 : int
    arg2 : int
    arg3 : int
    arg4 : int

Returns: Matrix<'b>
a : Matrix<'b>
arg1 : int
arg2 : int
arg3 : int
arg4 : int
Returns: Matrix<'b>

getRegionRV a (arg2, arg3)

Full Usage: getRegionRV a (arg2, arg3)

Parameters:
Returns: RowVector<'a>
a : RowVector<'a>
arg1 : int
arg2 : int
Returns: RowVector<'a>

getRegionV a (arg2, arg3)

Full Usage: getRegionV a (arg2, arg3)

Parameters:
    a : Vector<'a>
    arg1 : int
    arg2 : int

Returns: Vector<'a>
a : Vector<'a>
arg1 : int
arg2 : int
Returns: Vector<'a>

getRowM a i

Full Usage: getRowM a i

Parameters:
Returns: RowVector<'b>

Returns row of index i of matrix a as a vector

a : Matrix<'b>
i : int
Returns: RowVector<'b>

getRowsM a (arg2, arg3)

Full Usage: getRowsM a (arg2, arg3)

Parameters:
    a : Matrix<'b>
    arg1 : int
    arg2 : int

Returns: Matrix<'b>
a : Matrix<'b>
arg1 : int
arg2 : int
Returns: Matrix<'b>

hashM comp a

Full Usage: hashM comp a

Parameters:
Returns: int
comp : IEqualityComparer
a : Matrix<'b>
Returns: int

hashRV comp a

Full Usage: hashRV comp a

Parameters:
Returns: int
comp : IEqualityComparer
a : RowVector<'a>
Returns: int

hashV comp a

Full Usage: hashV comp a

Parameters:
Returns: int
comp : IEqualityComparer
a : Vector<'b>
Returns: int

identityM m

Full Usage: identityM m

Parameters:
    m : int

Returns: Matrix<'T>
m : int
Returns: Matrix<'T>

idxR (arg1, arg2) i

Full Usage: idxR (arg1, arg2) i

Parameters:
    arg0 : int
    arg1 : int
    i : int

Returns: int
arg0 : int
arg1 : int
i : int
Returns: int

inR (arg1, arg2) i

Full Usage: inR (arg1, arg2) i

Parameters:
    arg0 : int
    arg1 : int
    i : int

Returns: bool
arg0 : int
arg1 : int
i : int
Returns: bool

initDenseM i j x

Full Usage: initDenseM i j x

Parameters:
    i : int
    j : int
    x : seq<int * int * 'T>

Returns: Matrix<'T>
i : int
j : int
x : seq<int * int * 'T>
Returns: Matrix<'T>

initM m n f

Full Usage: initM m n f

Parameters:
    m : int
    n : int
    f : int -> int -> 'T

Returns: Matrix<'T>
m : int
n : int
f : int -> int -> 'T
Returns: Matrix<'T>

initNumericM m n f

Full Usage: initNumericM m n f

Parameters:
    m : int
    n : int
    f : INumeric<'T> -> int -> int -> 'T

Returns: Matrix<'T>
m : int
n : int
f : INumeric<'T> -> int -> int -> 'T
Returns: Matrix<'T>

initRV m f

Full Usage: initRV m f

Parameters:
    m : int
    f : int -> 'T

Returns: RowVector<'T>
m : int
f : int -> 'T
Returns: RowVector<'T>

initSparseM i j x

Full Usage: initSparseM i j x

Parameters:
    i : int
    j : int
    x : seq<int * int * 'T>

Returns: Matrix<'T>
i : int
j : int
x : seq<int * int * 'T>
Returns: Matrix<'T>

initV m f

Full Usage: initV m f

Parameters:
    m : int
    f : int -> 'T

Returns: Vector<'T>
m : int
f : int -> 'T
Returns: Vector<'T>

inplaceAddM a b

Full Usage: inplaceAddM a b

Parameters:
a : Matrix<'b>
b : Matrix<'b>

inplaceAddV a b

Full Usage: inplaceAddV a b

Parameters:
a : Vector<'b>
b : Vector<'b>

inplaceAssignM f a

Full Usage: inplaceAssignM f a

Parameters:
    f : int -> int -> 'b
    a : Matrix<'b>

Modifiers: inline
Type parameters: 'b
f : int -> int -> 'b
a : Matrix<'b>

inplaceCptMulM a b

Full Usage: inplaceCptMulM a b

Parameters:
a : Matrix<'b>
b : Matrix<'b>

inplaceCptMulV a b

Full Usage: inplaceCptMulV a b

Parameters:
a : Vector<'b>
b : Vector<'b>

inplaceScaleM a b

Full Usage: inplaceScaleM a b

Parameters:
a : 'b
b : Matrix<'b>

inplaceScaleV a b

Full Usage: inplaceScaleV a b

Parameters:
a : 'b
b : Vector<'b>

inplaceSubM a b

Full Usage: inplaceSubM a b

Parameters:
a : Matrix<'b>
b : Matrix<'b>

inplaceSubV a b

Full Usage: inplaceSubV a b

Parameters:
a : Vector<'b>
b : Vector<'b>

inplace_mapM f a

Full Usage: inplace_mapM f a

Parameters:
Modifiers: inline
Type parameters: 'b
f : 'b -> 'b
a : Matrix<'b>

inplace_mapV f a

Full Usage: inplace_mapV f a

Parameters:
Modifiers: inline
Type parameters: 'b
f : 'b -> 'b
a : Vector<'b>

inplace_mapiM f a

Full Usage: inplace_mapiM f a

Parameters:
    f : int -> int -> 'b -> 'b
    a : Matrix<'b>

Modifiers: inline
Type parameters: 'b
f : int -> int -> 'b -> 'b
a : Matrix<'b>

inplace_mapiV f a

Full Usage: inplace_mapiV f a

Parameters:
    f : int -> 'b -> 'b
    a : Vector<'b>

Modifiers: inline
Type parameters: 'b
f : int -> 'b -> 'b
a : Vector<'b>

listM xss

Full Usage: listM xss

Parameters:
    xss : 'T list list

Returns: Matrix<'T>
xss : 'T list list
Returns: Matrix<'T>

listRV xss

Full Usage: listRV xss

Parameters:
    xss : 'T list

Returns: RowVector<'T>
xss : 'T list
Returns: RowVector<'T>

listV xss

Full Usage: listV xss

Parameters:
    xss : 'T list

Returns: Vector<'T>
xss : 'T list
Returns: Vector<'T>

loosenDM x

Full Usage: loosenDM x

Parameters:
Returns: DenseMatrix<'a>
x : dmatrix
Returns: DenseMatrix<'a>

loosenF x

Full Usage: loosenF x

Parameters:
    x : float

Returns: 'T
x : float
Returns: 'T

loosenRV x

Full Usage: loosenRV x

Parameters:
Returns: RowVector<'a>
x : rowvec
Returns: RowVector<'a>

loosenSM x

Full Usage: loosenSM x

Parameters:
Returns: SparseMatrix<'a>
x : smatrix
Returns: SparseMatrix<'a>

loosenV x

Full Usage: loosenV x

Parameters:
Returns: Vector<'a>
x : vector
Returns: Vector<'a>

map2V f a b

Full Usage: map2V f a b

Parameters:
Returns: Vector<'b>
f : 'b -> 'b -> 'b
a : Vector<'b>
b : Vector<'b>
Returns: Vector<'b>

map3V f a b c

Full Usage: map3V f a b c

Parameters:
Returns: Vector<'b>
f : 'b -> 'b -> 'b -> 'b
a : Vector<'b>
b : Vector<'b>
c : Vector<'b>
Returns: Vector<'b>

mapM f a

Full Usage: mapM f a

Parameters:
Returns: Matrix<'b>
f : 'b -> 'b
a : Matrix<'b>
Returns: Matrix<'b>

mapRV f a

Full Usage: mapRV f a

Parameters:
Returns: RowVector<'b>
f : 'b -> 'b
a : RowVector<'b>
Returns: RowVector<'b>

mapV f a

Full Usage: mapV f a

Parameters:
Returns: Vector<'b>
f : 'b -> 'b
a : Vector<'b>
Returns: Vector<'b>

mapiM f a

Full Usage: mapiM f a

Parameters:
    f : int -> int -> 'b -> 'b
    a : Matrix<'b>

Returns: Matrix<'b>
f : int -> int -> 'b -> 'b
a : Matrix<'b>
Returns: Matrix<'b>

mapiRV f a

Full Usage: mapiRV f a

Parameters:
Returns: RowVector<'b>
f : int -> 'b -> 'b
a : RowVector<'b>
Returns: RowVector<'b>

mapiV f a

Full Usage: mapiV f a

Parameters:
    f : int -> 'b -> 'b
    a : Vector<'b>

Returns: Vector<'b>
f : int -> 'b -> 'b
a : Vector<'b>
Returns: Vector<'b>

mergeSorted cf s1 s2

Full Usage: mergeSorted cf s1 s2

Parameters:
    cf : 'T -> 'b -> int -
    s1 : seq<'T> -
    s2 : seq<'b> -

Returns: seq<'T option * 'b option>

Merge two sorted sequences

cf : 'T -> 'b -> int

s1 : seq<'T>

s2 : seq<'b>

Returns: seq<'T option * 'b option>

Example

mergedNonZeroEntriesM a b

Full Usage: mergedNonZeroEntriesM a b

Parameters:
Returns: seq<'a * 'a>

Non-zero entries from two sequences

a : Matrix<'a>
b : Matrix<'a>
Returns: seq<'a * 'a>

mulM a b

Full Usage: mulM a b

Parameters:
Returns: Matrix<'b>
a : Matrix<'b>
b : Matrix<'b>
Returns: Matrix<'b>

mulMV a b

Full Usage: mulMV a b

Parameters:
Returns: Vector<'b>
a : Matrix<'b>
b : Vector<'b>
Returns: Vector<'b>

mulRVM a b

Full Usage: mulRVM a b

Parameters:
Returns: RowVector<'b>
a : RowVector<'b>
b : Matrix<'b>
Returns: RowVector<'b>

mulRVV a b

Full Usage: mulRVV a b

Parameters:
Returns: 'b
a : RowVector<'b>
b : Vector<'b>
Returns: 'b

mulVRV a b

Full Usage: mulVRV a b

Parameters:
Returns: Matrix<'b>
a : Vector<'b>
b : RowVector<'b>
Returns: Matrix<'b>

negM a

Full Usage: negM a

Parameters:
Returns: Matrix<'b>
a : Matrix<'b>
Returns: Matrix<'b>

negRV a

Full Usage: negRV a

Parameters:
Returns: RowVector<'a>
a : RowVector<'a>
Returns: RowVector<'a>

negV a

Full Usage: negV a

Parameters:
Returns: Vector<'b>
a : Vector<'b>
Returns: Vector<'b>

nonZeroEntriesM a

Full Usage: nonZeroEntriesM a

Parameters:
Returns: seq<int * int * 'b>
a : Matrix<'b>
Returns: seq<int * int * 'b>

normM a

Full Usage: normM a

Parameters:
Returns: float
a : Matrix<'b>
Returns: float

opsM a

Full Usage: opsM a

Parameters:
Returns: OpsData<'a>
a : Matrix<'a>
Returns: OpsData<'a>

permuteColumns p a

Full Usage: permuteColumns p a

Parameters:
Returns: Matrix<'a>
p : permutation
a : Matrix<'a>
Returns: Matrix<'a>

permuteRV p a

Full Usage: permuteRV p a

Parameters:
Returns: RowVector<'a>
p : permutation
a : RowVector<'a>
Returns: RowVector<'a>

permuteRows p a

Full Usage: permuteRows p a

Parameters:
Returns: Matrix<'a>
p : permutation
a : Matrix<'a>
Returns: Matrix<'a>

permuteV p a

Full Usage: permuteV p a

Parameters:
Returns: Vector<'a>
p : permutation
a : Vector<'a>
Returns: Vector<'a>

prodM a

Full Usage: prodM a

Parameters:
Returns: 'b
a : Matrix<'b>
Returns: 'b

rowVecM xss

Full Usage: rowVecM xss

Parameters:
Returns: Matrix<'T>
xss : RowVector<'T>
Returns: Matrix<'T>

rowvecM x

Full Usage: rowvecM x

Parameters:
Returns: Matrix<'b>
x : RowVector<'b>
Returns: Matrix<'b>

scalarM x

Full Usage: scalarM x

Parameters:
    x : 'b

Returns: Matrix<'b>
x : 'b
Returns: Matrix<'b>

scalarRV x

Full Usage: scalarRV x

Parameters:
    x : 'a

Returns: RowVector<'a>
x : 'a
Returns: RowVector<'a>

scalarV x

Full Usage: scalarV x

Parameters:
    x : 'b

Returns: Vector<'b>
x : 'b
Returns: Vector<'b>

scaleM a b

Full Usage: scaleM a b

Parameters:
Returns: Matrix<'b>
a : 'b
b : Matrix<'b>
Returns: Matrix<'b>

scaleRV a b

Full Usage: scaleRV a b

Parameters:
Returns: RowVector<'a>
a : 'a
b : RowVector<'a>
Returns: RowVector<'a>

scaleV a b

Full Usage: scaleV a b

Parameters:
Returns: Vector<'b>
a : 'b
b : Vector<'b>
Returns: Vector<'b>

seqCM xss

Full Usage: seqCM xss

Parameters:
    xss : seq<'c>

Returns: Matrix<'T>
xss : seq<'c>
Returns: Matrix<'T>

seqM xss

Full Usage: seqM xss

Parameters:
    xss : seq<'c>

Returns: Matrix<'T>
xss : seq<'c>
Returns: Matrix<'T>

seqRV xss

Full Usage: seqRV xss

Parameters:
    xss : seq<'T>

Returns: RowVector<'T>
xss : seq<'T>
Returns: RowVector<'T>

seqV xss

Full Usage: seqV xss

Parameters:
    xss : seq<'T>

Returns: Vector<'T>
xss : seq<'T>
Returns: Vector<'T>

setColM a j v

Full Usage: setColM a j v

Parameters:

Replaces column of index i of matrix a with values of vector v, if vector length matches columnsize

a : Matrix<'b>

j : int

v : Vector<'b>

Example

setRowM a i v

Full Usage: setRowM a i v

Parameters:

Replaces row of index j of matrix a with values of vector v, if vector length matches rowsize

a : Matrix<'b>

i : int

v : Vector<'b>

Example

sparse x

Full Usage: sparse x

Parameters:
Returns: Matrix<'a>
Modifiers: inline
x : SparseMatrix<'a>
Returns: Matrix<'a>

startR (arg1, arg2)

Full Usage: startR (arg1, arg2)

Parameters:
    arg0 : int
    arg1 : int

Returns: int
arg0 : int
arg1 : int
Returns: int

subM a b

Full Usage: subM a b

Parameters:
Returns: Matrix<'b>
a : Matrix<'b>
b : Matrix<'b>
Returns: Matrix<'b>

subRV a b

Full Usage: subRV a b

Parameters:
Returns: RowVector<'a>
a : RowVector<'a>
b : RowVector<'a>
Returns: RowVector<'a>

subScalarM a b

Full Usage: subScalarM a b

Parameters:
Returns: Matrix<'a>
a : 'a
b : Matrix<'a>
Returns: Matrix<'a>

subScalarRV a b

Full Usage: subScalarRV a b

Parameters:
Returns: RowVector<'a>
a : 'a
b : RowVector<'a>
Returns: RowVector<'a>

subScalarV a b

Full Usage: subScalarV a b

Parameters:
Returns: Vector<'a>
a : 'a
b : Vector<'a>
Returns: Vector<'a>

subV a b

Full Usage: subV a b

Parameters:
Returns: Vector<'b>
a : Vector<'b>
b : Vector<'b>
Returns: Vector<'b>

sumM a

Full Usage: sumM a

Parameters:
Returns: 'b
a : Matrix<'b>
Returns: 'b

tightenDM x

Full Usage: tightenDM x

Parameters:
Returns: dmatrix
x : DenseMatrix<'a>
Returns: dmatrix

tightenF x

Full Usage: tightenF x

Parameters:
    x : 'T

Returns: float
x : 'T
Returns: float

tightenRV x

Full Usage: tightenRV x

Parameters:
Returns: rowvec
x : RowVector<'a>
Returns: rowvec

tightenSM x

Full Usage: tightenSM x

Parameters:
Returns: smatrix
x : SparseMatrix<'a>
Returns: smatrix

tightenV x

Full Usage: tightenV x

Parameters:
Returns: vector
x : Vector<'a>
Returns: vector

toDenseM a

Full Usage: toDenseM a

Parameters:
Returns: Matrix<'b>
a : Matrix<'b>
Returns: Matrix<'b>

toRowVectorM x

Full Usage: toRowVectorM x

Parameters:
Returns: RowVector<'b>
x : Matrix<'b>
Returns: RowVector<'b>

toScalarM x

Full Usage: toScalarM x

Parameters:
Returns: 'b
x : Matrix<'b>
Returns: 'b

toSparseM a

Full Usage: toSparseM a

Parameters:
Returns: Matrix<'T>
a : Matrix<'T>
Returns: Matrix<'T>

toVectorM x

Full Usage: toVectorM x

Parameters:
Returns: Vector<'b>
x : Matrix<'b>
Returns: Vector<'b>

traceM a

Full Usage: traceM a

Parameters:
Returns: 'b
a : Matrix<'b>
Returns: 'b

traceMGU a

Full Usage: traceMGU a

Parameters:
Returns: 'a
a : Matrix<'a>
Returns: 'a

transM a

Full Usage: transM a

Parameters:
Returns: Matrix<'b>
a : Matrix<'b>
Returns: Matrix<'b>

transRV a

Full Usage: transRV a

Parameters:
Returns: Vector<'b>
a : RowVector<'b>
Returns: Vector<'b>

transV a

Full Usage: transV a

Parameters:
Returns: RowVector<'b>
a : Vector<'b>
Returns: RowVector<'b>

unaryOpM opDenseDS opDenseGU opSparseDS opSparseMatrixGU b

Full Usage: unaryOpM opDenseDS opDenseGU opSparseDS opSparseMatrixGU b

Parameters:
Returns: Matrix<'d>
Modifiers: inline
opDenseDS : dmatrix -> 'a
opDenseGU : DenseMatrix<'b> -> 'c
opSparseDS : smatrix -> 'e
opSparseMatrixGU : SparseMatrix<'b> -> 'f
b : Matrix<'b>
Returns: Matrix<'d>

unzipV a

Full Usage: unzipV a

Parameters:
Returns: Vector<'c> * Vector<'d>
a : Vector<'c * 'd>
Returns: Vector<'c> * Vector<'d>

vecM xss

Full Usage: vecM xss

Parameters:
Returns: Matrix<'T>
xss : Vector<'T>
Returns: Matrix<'T>

vectorM x

Full Usage: vectorM x

Parameters:
Returns: Matrix<'b>
x : Vector<'b>
Returns: Matrix<'b>

zeroM m n

Full Usage: zeroM m n

Parameters:
    m : int
    n : int

Returns: Matrix<'b>
m : int
n : int
Returns: Matrix<'b>

zeroRV m

Full Usage: zeroRV m

Parameters:
    m : int

Returns: RowVector<'T>
m : int
Returns: RowVector<'T>

zeroV m

Full Usage: zeroV m

Parameters:
    m : int

Returns: Vector<'T>
m : int
Returns: Vector<'T>

zipV a b

Full Usage: zipV a b

Parameters:
Returns: Vector<'c * 'd>
a : Vector<'c>
b : Vector<'d>
Returns: Vector<'c * 'd>