Index

Modules: manu, manu/cholesky, manu/eigen, manu/lu, manu/matrix, manu/qr, manu/svd.

API symbols

`$`:

• matrix: proc `$`[T](m: Matrix[T]): string

`*.=`:

• matrix: proc `*.=`[T](a`gensym127: var Matrix[T]; b`gensym127: Matrix[T])
• matrix: proc `*.=`[T](a`gensym127: var Matrix[T]; b`gensym127: ColVector[T])
• matrix: proc `*.=`[T](a`gensym127: var Matrix[T]; b`gensym127: RowVector[T])

`*.`:

• matrix: proc `*.`[T](a`gensym126: ColVector[T]; b`gensym126: RowVector[T]): Matrix[T]
• matrix: proc `*.`[T](b`gensym126: RowVector[T]; a`gensym126: ColVector[T]): Matrix[T]
• matrix: proc `*.`[T](b`gensym126: ColVector[T]; a`gensym126: sink Matrix[T]): Matrix[T]
• matrix: proc `*.`[T](b`gensym126: RowVector[T]; a`gensym126: sink Matrix[T]): Matrix[T]
• matrix: proc `*.`[T](a`gensym126: sink Matrix[T]; b`gensym126: Matrix[T]): Matrix[T]
• matrix: proc `*.`[T](a`gensym126: sink Matrix[T]; b`gensym126: ColVector[T]): Matrix[T]
• matrix: proc `*.`[T](a`gensym126: sink Matrix[T]; b`gensym126: RowVector[T]): Matrix[T]

`*=`:

• matrix: proc `*=`[T](m`gensym125: var Matrix[T]; s`gensym125: T)

`*`:

• matrix: proc `*`[T](a, b: Matrix[T]): Matrix[T]
• matrix: proc `*`[T](m`gensym124: sink Matrix[T]; s`gensym124: T): Matrix[T]
• matrix: proc `*`[T](s`gensym124: T; m`gensym124: sink Matrix[T]): Matrix[T]

`+=`:

• matrix: proc `+=`[T](a`gensym120: var Matrix[T]; b`gensym120: Matrix[T])
• matrix: proc `+=`[T](a`gensym120: var Matrix[T]; b`gensym120: ColVector[T])
• matrix: proc `+=`[T](a`gensym120: var Matrix[T]; b`gensym120: RowVector[T])
• matrix: proc `+=`[T](m`gensym121: var Matrix[T]; s`gensym121: T)

`+`:

• matrix: proc `+`[T](a`gensym117: ColVector[T]; b`gensym117: RowVector[T]): Matrix[T]
• matrix: proc `+`[T](b`gensym117: RowVector[T]; a`gensym117: ColVector[T]): Matrix[T]
• matrix: proc `+`[T](b`gensym117: ColVector[T]; a`gensym117: sink Matrix[T]): Matrix[T]
• matrix: proc `+`[T](b`gensym117: RowVector[T]; a`gensym117: sink Matrix[T]): Matrix[T]
• matrix: proc `+`[T](a`gensym117: sink Matrix[T]; b`gensym117: Matrix[T]): Matrix[T]
• matrix: proc `+`[T](a`gensym117: sink Matrix[T]; b`gensym117: ColVector[T]): Matrix[T]
• matrix: proc `+`[T](a`gensym117: sink Matrix[T]; b`gensym117: RowVector[T]): Matrix[T]
• matrix: proc `+`[T](m`gensym118: sink Matrix[T]; s`gensym118: T): Matrix[T]
• matrix: proc `+`[T](s`gensym118: T; m`gensym118: sink Matrix[T]): Matrix[T]

`-=`:

• matrix: proc `-=`[T](a`gensym114: var Matrix[T]; b`gensym114: Matrix[T])
• matrix: proc `-=`[T](a`gensym114: var Matrix[T]; b`gensym114: ColVector[T])
• matrix: proc `-=`[T](a`gensym114: var Matrix[T]; b`gensym114: RowVector[T])
• matrix: proc `-=`[T](m`gensym115: var Matrix[T]; s`gensym115: T)

`-`:

• matrix: proc `-`[T](a`gensym111: ColVector[T]; b`gensym111: RowVector[T]): Matrix[T]
• matrix: proc `-`[T](a`gensym111: RowVector[T]; b`gensym111: ColVector[T]): Matrix[T]
• matrix: proc `-`[T](a`gensym111: ColVector[T]; b`gensym111: sink Matrix[T]): Matrix[T]
• matrix: proc `-`[T](a`gensym111: RowVector[T]; b`gensym111: sink Matrix[T]): Matrix[T]
• matrix: proc `-`[T](m`gensym109: sink Matrix[T]): Matrix[T]
• matrix: proc `-`[T](a`gensym111: sink Matrix[T]; b`gensym111: Matrix[T]): Matrix[T]
• matrix: proc `-`[T](a`gensym111: sink Matrix[T]; b`gensym111: ColVector[T]): Matrix[T]
• matrix: proc `-`[T](a`gensym111: sink Matrix[T]; b`gensym111: RowVector[T]): Matrix[T]
• matrix: proc `-`[T](m`gensym112: sink Matrix[T]; s`gensym112: T): Matrix[T]
• matrix: proc `-`[T](s`gensym112: T; m`gensym112: sink Matrix[T]): Matrix[T]

`/.=`:

• matrix: proc `/.=`[T](a`gensym129: var Matrix[T]; b`gensym129: Matrix[T])
• matrix: proc `/.=`[T](a`gensym129: var Matrix[T]; b`gensym129: ColVector[T])
• matrix: proc `/.=`[T](a`gensym129: var Matrix[T]; b`gensym129: RowVector[T])

`/.`:

• matrix: proc `/.`[T](a`gensym128: ColVector[T]; b`gensym128: RowVector[T]): Matrix[T]
• matrix: proc `/.`[T](a`gensym128: RowVector[T]; b`gensym128: ColVector[T]): Matrix[T]
• matrix: proc `/.`[T](a`gensym128: ColVector[T]; b`gensym128: sink Matrix[T]): Matrix[T]
• matrix: proc `/.`[T](a`gensym128: RowVector[T]; b`gensym128: sink Matrix[T]): Matrix[T]
• matrix: proc `/.`[T](a`gensym128: sink Matrix[T]; b`gensym128: Matrix[T]): Matrix[T]
• matrix: proc `/.`[T](a`gensym128: sink Matrix[T]; b`gensym128: ColVector[T]): Matrix[T]
• matrix: proc `/.`[T](a`gensym128: sink Matrix[T]; b`gensym128: RowVector[T]): Matrix[T]

`/=`:

• matrix: proc `/=`[T](m`gensym123: var Matrix[T]; s`gensym123: T)

`/`:

• matrix: proc `/`[T](m`gensym122: sink Matrix[T]; s`gensym122: T): Matrix[T]
• matrix: proc `/`[T](s`gensym122: T; m`gensym122: sink Matrix[T]): Matrix[T]

`=copy`:

• matrix: proc `=copy`[T](a: var Matrix[T]; b: Matrix[T])

`=destroy`:

• matrix: proc `=destroy`[T](a: var Matrix[T])

`=dup`:

• matrix: proc `=dup`[T](b: Matrix[T]): Matrix[T]

`[]=`:

• matrix: proc `[]=`[T](v: var ColVector[T]; i: int; s: T)
• matrix: proc `[]=`[T, U, V, W, X](m: var Matrix[T]; r: HSlice[U, V]; c: HSlice[W, X]; a: Matrix[T])
• matrix: proc `[]=`[T, U, V](m: var Matrix[T]; r: HSlice[U, V]; c: openArray[SomeInteger]; a: Matrix[T])
• matrix: proc `[]=`[T](m: var Matrix[T]; i, j: int; s: T)
• matrix: proc `[]=`[T, U, V](m: var Matrix[T]; r: openArray[SomeInteger]; c: HSlice[U, V]; a: Matrix[T])
• matrix: proc `[]=`[T](m: var Matrix[T]; r, c: openArray[SomeInteger]; a: Matrix[T])
• matrix: proc `[]=`[T](v: var RowVector[T]; j: int; s: T)

`[]`:

• matrix: proc `[]`[T](v: ColVector[T]; i: int): T
• matrix: proc `[]`[T](v: var ColVector[T]; i: int): var T
• matrix: proc `[]`[T, U, V, W, X](m: Matrix[T]; r: HSlice[U, V]; c: HSlice[W, X]): Matrix[T]
• matrix: proc `[]`[T, U, V](m: Matrix[T]; r: HSlice[U, V]; c: openArray[SomeInteger]): Matrix[ T]
• matrix: proc `[]`[T](m: Matrix[T]; i, j: int): T
• matrix: proc `[]`[T](m: var Matrix[T]; i, j: int): var T
• matrix: proc `[]`[T, U, V](m: Matrix[T]; r: openArray[SomeInteger]; c: HSlice[U, V]): Matrix[ T]
• matrix: proc `[]`[T](m: Matrix[T]; r, c: openArray[SomeInteger]): Matrix[T]
• matrix: proc `[]`[T](v: RowVector[T]; j: int): T
• matrix: proc `[]`[T](v: var RowVector[T]; j: int): var T

arccos:

• matrix: proc arccos[T](m`gensym91: sink Matrix[T]): Matrix[T]

arcsin:

• matrix: proc arcsin[T](m`gensym92: sink Matrix[T]): Matrix[T]

arctan:

• matrix: proc arctan[T](m`gensym93: sink Matrix[T]): Matrix[T]

cbrt:

• matrix: proc cbrt[T](m`gensym86: sink Matrix[T]): Matrix[T]

ceil:

• matrix: proc ceil[T](m`gensym106: sink Matrix[T]): Matrix[T]

chol:

• cholesky: proc chol[T](a: Matrix[T]): CholeskyDecomposition[T]

CholeskyDecomposition:

• cholesky: object CholeskyDecomposition

columnDimension:

• matrix: proc columnDimension[T](m: Matrix[T]): int

ColVector:

• matrix: type ColVector

ColVector32:

• matrix: type ColVector32

ColVector64:

• matrix: type ColVector64

cond:

• manu: proc cond[T](m: sink Matrix[T]): T
• svd: proc cond[T](sv: SingularValueDecomposition[T]): T

cos:

• matrix: proc cos[T](m`gensym94: sink Matrix[T]): Matrix[T]

cosh:

• matrix: proc cosh[T](m`gensym95: sink Matrix[T]): Matrix[T]

degToRad:

• matrix: proc degToRad[T](m`gensym107: sink Matrix[T]): Matrix[T]

det:

• manu: proc det[T](m: sink Matrix[T]): T
• lu: proc det[T](l: LUDecomposition[T]): T

dim:

• matrix: proc dim[T](m: Matrix[T]): (int, int)

eig:

• eigen: proc eig[T](a: sink Matrix[T]): EigenvalueDecomposition[T]

EigenvalueDecomposition:

• eigen: object EigenvalueDecomposition

erf:

• matrix: proc erf[T](m`gensym100: sink Matrix[T]): Matrix[T]

erfc:

• matrix: proc erfc[T](m`gensym101: sink Matrix[T]): Matrix[T]

exp:

• matrix: proc exp[T](m`gensym90: sink Matrix[T]): Matrix[T]

eye:

• matrix: proc eye[T](m: int): Matrix[T]

eye32:

• matrix: proc eye32(m: int): Matrix32

eye64:

• matrix: proc eye64(m: int): Matrix64

floor:

• matrix: proc floor[T](m`gensym105: sink Matrix[T]): Matrix[T]

gamma:

• matrix: proc gamma[T](m`gensym103: sink Matrix[T]): Matrix[T]

getArray:

• matrix: proc getArray[T](m: Matrix[T]): seq[seq[T]]

getColumnPacked:

• matrix: proc getColumnPacked[T](m: Matrix[T]): seq[T]

getD:

• eigen: proc getD[T](ei: EigenvalueDecomposition[T]): Matrix[T]

getFloatPivot:

• lu: proc getFloatPivot[T](l: LUDecomposition[T]): seq[T]

getH:

• qr: proc getH[T](q: QRDecomposition[T]): Matrix[T]

getImagEigenvalues:

• eigen: proc getImagEigenvalues[T](ei: EigenvalueDecomposition[T]): lent seq[T]

getL:

• cholesky: proc getL[T](c: CholeskyDecomposition[T]): lent Matrix[T]
• lu: proc getL[T](l: LUDecomposition[T]): Matrix[T]

getPivot:

• lu: proc getPivot[T](l: LUDecomposition[T]): lent seq[int]

getQ:

• qr: proc getQ[T](q: QRDecomposition[T]): Matrix[T]

getR:

• qr: proc getR[T](q: QRDecomposition[T]): Matrix[T]

getRealEigenvalues:

• eigen: proc getRealEigenvalues[T](ei: EigenvalueDecomposition[T]): lent seq[T]

getRowPacked:

• matrix: proc getRowPacked[T](m: Matrix[T]): seq[T]

getS:

• svd: proc getS[T](sv: SingularValueDecomposition[T]): Matrix[T]

getSingularValues:

• svd: proc getSingularValues[T](sv: SingularValueDecomposition[T]): lent seq[T]

getU:

• lu: proc getU[T](l: LUDecomposition[T]): Matrix[T]
• svd: proc getU[T](sv: SingularValueDecomposition[T]): lent Matrix[T]

getV:

• eigen: proc getV[T](ei: EigenvalueDecomposition[T]): lent Matrix[T]
• svd: proc getV[T](sv: SingularValueDecomposition[T]): lent Matrix[T]

identity:

• matrix: proc identity[T: SomeFloat](m: int): Matrix[T]

inverse:

• manu: proc inverse[T](m: sink Matrix[T]): Matrix[T]

isFullRank:

• qr: proc isFullRank[T](q: QRDecomposition[T]): bool

isNonsingular:

• lu: proc isNonsingular[T](l: LUDecomposition[T]): bool

isSpd:

• cholesky: proc isSpd[T](c: CholeskyDecomposition[T]): bool

lgamma:

• matrix: proc lgamma[T](m`gensym102: sink Matrix[T]): Matrix[T]

ln:

• matrix: proc ln[T](m`gensym89: sink Matrix[T]): Matrix[T]

log10:

• matrix: proc log10[T](m`gensym87: sink Matrix[T]): Matrix[T]

log2:

• matrix: proc log2[T](m`gensym88: sink Matrix[T]): Matrix[T]

lu:

• lu: proc lu[T](a: sink Matrix[T]): LUDecomposition[T]

LUDecomposition:

• lu: object LUDecomposition

luGauss:

• lu: proc luGauss[T](a: sink Matrix[T]): LUDecomposition[T]

m:

• matrix: proc m[T](m: Matrix[T]): int

makeUniversal:

• matrix: template makeUniversal(fname: untyped)

makeUniversalBinary:

• matrix: template makeUniversalBinary(fname: untyped; isCommutative = false)

makeUniversalBinaryImpl:

• matrix: template makeUniversalBinaryImpl(fname, opname: untyped; isCommutative = false)

makeUniversalBinaryInplace:

• matrix: template makeUniversalBinaryInplace(fnameInplace, opname: untyped)

makeUniversalBinaryInplaceImpl:

• matrix: template makeUniversalBinaryInplaceImpl(fnameInplace, opname: untyped)

makeUniversalBinaryScalarInplace:

• matrix: template makeUniversalBinaryScalarInplace(fnameInplace, opname: untyped)

Matrix:

• matrix: object Matrix

matrix:

• matrix: proc matrix[T: SomeFloat](m, n: int): Matrix[T]
• matrix: proc matrix[T: SomeFloat](m, n: int; s: T): Matrix[T]
• matrix: proc matrix[T: SomeFloat](n: int; data: seq[T]): Matrix[T]
• matrix: proc matrix[T: SomeFloat](data: seq[seq[T]]): Matrix[T]
• matrix: proc matrix[T: SomeFloat](data: seq[seq[T]]; m, n: int): Matrix[T]
• matrix: proc matrix[T: SomeFloat](data: seq[T]; m: int): Matrix[T]

Matrix32:

• matrix: type Matrix32

Matrix64:

• matrix: type Matrix64

matrixUninit:

• matrix: proc matrixUninit[T: SomeFloat](m, n: int): Matrix[T]

n:

• matrix: proc n[T](m: Matrix[T]): int

norm1:

• matrix: proc norm1[T](m: Matrix[T]): T

norm2:

• manu: proc norm2[T](m: sink Matrix[T]): T
• svd: proc norm2[T](sv: SingularValueDecomposition[T]): T

normF:

• matrix: proc normF[T](m: Matrix[T]): T

normInf:

• matrix: proc normInf[T](m: Matrix[T]): T

ones:

• matrix: proc ones[T](m, n: int): Matrix[T]

ones32:

• matrix: proc ones32(m, n: int): Matrix32

ones64:

• matrix: proc ones64(m, n: int): Matrix64

qr:

• qr: proc qr[T](a: sink Matrix[T]): QRDecomposition[T]

QRDecomposition:

• qr: object QRDecomposition

radToDeg:

• matrix: proc radToDeg[T](m`gensym108: sink Matrix[T]): Matrix[T]

randMatrix:

• matrix: proc randMatrix[T](m, n: int): Matrix[T]
• matrix: proc randMatrix[T: SomeFloat](m, n: int; x: Slice[T]): Matrix[T]
• matrix: proc randMatrix[T: SomeFloat](m, n: int; max: T): Matrix[T]

randMatrix32:

• matrix: proc randMatrix32(m, n: int): Matrix32

randMatrix64:

• matrix: proc randMatrix64(m, n: int): Matrix64

randNMatrix:

• matrix: proc randNMatrix[T](m, n: int): Matrix[T]
• matrix: proc randNMatrix[T: SomeFloat](m, n: int; mu, sigma: T): Matrix[T]

randNMatrix32:

• matrix: proc randNMatrix32(m, n: int): Matrix32

randNMatrix64:

• matrix: proc randNMatrix64(m, n: int): Matrix64

rank:

• manu: proc rank[T](m: sink Matrix[T]): int
• svd: proc rank[T](sv: SingularValueDecomposition[T]): int

rowDimension:

• matrix: proc rowDimension[T](m: Matrix[T]): int

RowVector:

• matrix: type RowVector

RowVector32:

• matrix: type RowVector32

RowVector64:

• matrix: type RowVector64

sin:

• matrix: proc sin[T](m`gensym96: sink Matrix[T]): Matrix[T]

SingularValueDecomposition:

• svd: object SingularValueDecomposition

sinh:

• matrix: proc sinh[T](m`gensym97: sink Matrix[T]): Matrix[T]

solve:

• manu: proc solve[T](a: sink Matrix[T]; b: Matrix[T]): Matrix[T]
• cholesky: proc solve[T](c: CholeskyDecomposition[T]; b: sink Matrix[T]): Matrix[T]
• lu: proc solve[T](l: LUDecomposition[T]; b: Matrix[T]): Matrix[T]
• qr: proc solve[T](q: QRDecomposition[T]; b: Matrix[T]): Matrix[T]

solveTranspose:

• manu: proc solveTranspose[T](a, b: Matrix[T]): Matrix[T]

sqrt:

• matrix: proc sqrt[T](m`gensym85: sink Matrix[T]): Matrix[T]

sum:

• matrix: proc sum[T](m: Matrix[T]): T

sumColumns:

• matrix: proc sumColumns[T](m: Matrix[T]): Matrix[T]

sumRows:

• matrix: proc sumRows[T](m: Matrix[T]): Matrix[T]

svd:

• svd: proc svd[T](a: sink Matrix[T]): SingularValueDecomposition[T]

tan:

• matrix: proc tan[T](m`gensym98: sink Matrix[T]): Matrix[T]

tanh:

• matrix: proc tanh[T](m`gensym99: sink Matrix[T]): Matrix[T]

trace:

• matrix: proc trace[T](m: Matrix[T]): T

transpose:

• matrix: proc transpose[T](m: Matrix[T]): Matrix[T]

trunc:

• matrix: proc trunc[T](m`gensym104: sink Matrix[T]): Matrix[T]

zeros:

• matrix: proc zeros[T](m, n: int): Matrix[T]

zeros32:

• matrix: proc zeros32(m, n: int): Matrix32

zeros64:

• matrix: proc zeros64(m, n: int): Matrix64