MatrixShape = enum
  Diagonal, UpperTriangular, LowerTriangular, UpperHessenberg, LowerHessenberg,
  Symmetric

Vector[A] = ref object
  data*: seq[A]
  fp*: ptr A
  len*, step*: int

Matrix[A] = ref object
  order*: OrderType
  M*, N*, ld*: int
  fp*: ptr A
  data*: seq[A]
  shape*: set[MatrixShape]

All = object

BalanceOp {...}{.pure.} = enum
  NoOp, Permute, Scale, Both

EigenMode {...}{.pure.} = enum
  Eigenvalues, Schur

SchurCompute {...}{.pure.} = enum
  NoOp, Initialize, Provided

BalanceResult[A] = object
  matrix*: Matrix[A]
  ihi*, ilo*: cint
  scale*: seq[A]

EigenValues[A] = ref object
  real*, img*: seq[A]

SchurResult[A] = object
  factorization*: Matrix[A]
  eigenvalues*: EigenValues[A]

proc isFull(v: Vector): bool {...}{.inline.}

proc isFull(m: Matrix): bool {...}{.inline.}

proc `==`[A](v, w: Vector[A]): bool

proc `==`[A](m, n: Matrix[A]): bool

proc vector[A](data: seq[A]): Vector[A]

proc vector[A](data: varargs[A]): Vector[A]

proc stackVector[N: static[int]](a: var Array32[N]): Vector[float32]

proc stackVector[N: static[int]](a: var Array64[N]): Vector[float64]

proc sharedVector(N: int; A: typedesc): Vector[A]

proc dealloc[A](v: Vector[A])

proc makeVector[A](N: int; f: proc (i: int): A): Vector[A]

proc randomVector(N: int; max: float64 = 1): Vector[float64] {...}{.raises: [], tags: [].}

proc randomVector(N: int; max: float32): Vector[float32] {...}{.raises: [], tags: [].}

proc constantVector[A](N: int; a: A): Vector[A]

proc zeros(N: int): auto {...}{.raises: [], tags: [].}

proc zeros(N: int; A: typedesc): auto

proc ones(N: int): auto {...}{.raises: [], tags: [].}

proc ones(N: int; A: typedesc[float32]): auto

proc ones(N: int; A: typedesc[float64]): auto

proc matrix[A](order: OrderType; M, N: int; data: seq[A]): Matrix[A]

proc makeMatrix[A](M, N: int; f: proc (i, j: int): A; order = colMajor): Matrix[A]

proc randomMatrix[A: SomeFloat](M, N: int; max: A = 1; order = colMajor): Matrix[A]

proc randomMatrix(M, N: int; order = colMajor): Matrix[float64] {...}{.raises: [], tags: [].}

proc constantMatrix[A](M, N: int; a: A; order = colMajor): Matrix[A]

proc zeros(M, N: int; order = colMajor): auto {...}{.raises: [], tags: [].}

proc zeros(M, N: int; A: typedesc; order = colMajor): auto

proc ones(M, N: int): auto {...}{.raises: [], tags: [].}

proc ones(M, N: int; A: typedesc[float32]): auto

proc ones(M, N: int; A: typedesc[float64]): auto

proc eye(N: int; order = colMajor): Matrix[float64] {...}{.raises: [], tags: [].}

proc eye(N: int; A: typedesc[float32]; order = colMajor): Matrix[float32]

proc eye(N: int; A: typedesc[float64]; order = colMajor): Matrix[float64]

proc matrix[A](xs: seq[seq[A]]; order = colMajor): Matrix[A]

proc matrix[A](xs: seq[Vector[A]]; order = colMajor): Matrix[A]

proc stackMatrix[M, N: static[int]](a: var DoubleArray32[M, N]; order = colMajor): Matrix[
    float32]

proc stackMatrix[M, N: static[int]](a: var DoubleArray64[M, N]; order = colMajor): Matrix[
    float64]

proc sharedMatrix(M, N: int; A: typedesc; order = colMajor): Matrix[A]

proc dealloc[A](m: Matrix[A])

proc diag[A: SomeFloat](xs: varargs[A]): Matrix[A]

proc `[]`[A](v: Vector[A]; i: int): A {...}{.inline.}

proc `[]`[A](v: var Vector[A]; i: int): var A {...}{.inline.}

proc `[]=`[A](v: Vector[A]; i: int; val: A) {...}{.inline.}

proc `[]`[A](m: Matrix[A]; i, j: int): A {...}{.inline.}

proc `[]`[A](m: var Matrix[A]; i, j: int): var A {...}{.inline.}

proc `[]=`[A](m: var Matrix[A]; i, j: int; val: A) {...}{.inline.}

proc column[A](m: Matrix[A]; j: int): Vector[A] {...}{.inline.}

proc row[A](m: Matrix[A]; i: int): Vector[A] {...}{.inline.}

proc dim(m: Matrix): tuple[rows, columns: int]

proc clone[A](v: Vector[A]): Vector[A]

proc clone[A](m: Matrix[A]): Matrix[A]

proc map[A, B](v: Vector[A]; f: proc (x: A): B): Vector[B]

proc map[A, B](m: Matrix[A]; f: proc (x: A): B): Matrix[B]

proc to32(v: Vector[float64]): Vector[float32] {...}{.raises: [], tags: [].}

proc to64(v: Vector[float32]): Vector[float64] {...}{.raises: [], tags: [].}

proc to32(m: Matrix[float64]): Matrix[float32] {...}{.raises: [OutOfBoundsError], tags: [].}

proc to64(m: Matrix[float32]): Matrix[float64] {...}{.raises: [OutOfBoundsError], tags: [].}

proc `$`[A](v: Vector[A]): string

proc `$`[A](m: Matrix[A]): string

proc t[A](m: Matrix[A]): Matrix[A]

proc reshape[A](m: Matrix[A]; a, b: int): Matrix[A]

proc asMatrix[A](v: Vector[A]; a, b: int; order = colMajor): Matrix[A]

proc asVector[A](m: Matrix[A]): Vector[A]

proc hstack[A](vectors: varargs[Vector[A]]): Vector[A]

proc hstack[A](matrices: varargs[Matrix[A]]): Matrix[A]

proc vstack[A](matrices: varargs[Matrix[A]]): Matrix[A]

proc `[]`[A](v: Vector[A]; s: Slice[int]): Vector[A] {...}{.inline.}

proc `[]=`[A](v: var Vector[A]; s: Slice[int]; val: Vector[A]) {...}{.inline.}

proc `[]`[A](m: Matrix[A]; rows, cols: Slice[int]): Matrix[A]

proc `[]`[A](m: Matrix[A]; rows: Slice[int]; cols: typedesc[All]): Matrix[A]

proc `[]`[A](m: Matrix[A]; rows: typedesc[All]; cols: Slice[int]): Matrix[A]

proc `[]=`[A](m: var Matrix[A]; rows, cols: Slice[int]; val: Matrix[A]) {...}{.inline.}

proc `[]=`[A](m: var Matrix[A]; rows: Slice[int]; cols: typedesc[All]; val: Matrix[A]) {...}{.
    inline.}

proc `[]=`[A](m: var Matrix[A]; rows: typedesc[All]; cols: Slice[int]; val: Matrix[A]) {...}{.
    inline.}

proc `*=`[A: SomeFloat](v: var Vector[A]; k: A) {...}{.inline.}

proc `*`[A: SomeFloat](v: Vector[A]; k: A): Vector[A] {...}{.inline.}

proc `+=`[A: SomeFloat](v: var Vector[A]; w: Vector[A]) {...}{.inline.}

proc `+`[A: SomeFloat](v, w: Vector[A]): Vector[A] {...}{.inline.}

proc `-=`[A: SomeFloat](v: var Vector[A]; w: Vector[A]) {...}{.inline.}

proc `-`[A: SomeFloat](v, w: Vector[A]): Vector[A] {...}{.inline.}

proc `*`[A: SomeFloat](v, w: Vector[A]): A {...}{.inline.}

proc l_2[A: SomeFloat](v: Vector[A]): auto {...}{.inline.}

proc l_1[A: SomeFloat](v: Vector[A]): auto {...}{.inline.}

proc maxIndex[A](v: Vector[A]): tuple[i: int, val: A]

proc minIndex[A](v: Vector[A]): tuple[i: int, val: A]

proc `*=`[A: SomeFloat](m: var Matrix[A]; k: A) {...}{.inline.}

proc `*`[A: SomeFloat](m: Matrix[A]; k: A): Matrix[A] {...}{.inline.}

proc `+=`[A: SomeFloat](a: var Matrix[A]; b: Matrix[A]) {...}{.inline.}

proc `+`[A: SomeFloat](a, b: Matrix[A]): Matrix[A] {...}{.inline.}

proc `-=`[A: SomeFloat](a: var Matrix[A]; b: Matrix[A]) {...}{.inline.}

proc `-`[A: SomeFloat](a, b: Matrix[A]): Matrix[A] {...}{.inline.}

proc l_2[A: SomeFloat](m: Matrix[A]): A {...}{.inline.}

proc l_1[A: SomeFloat](m: Matrix[A]): A {...}{.inline.}

proc max[A](m: Matrix[A]): A

proc min[A](m: Matrix[A]): A

proc T[A](m: Matrix[A]): Matrix[A]

proc `*`[A: SomeFloat](a: Matrix[A]; v: Vector[A]): Vector[A] {...}{.inline.}

proc `*`[A: SomeFloat](a, b: Matrix[A]): Matrix[A] {...}{.inline.}

proc `=~`[A: SomeFloat](v, w: Vector[A]): bool

proc `=~`[A: SomeFloat](v, w: Matrix[A]): bool

proc `|*|`[A](a, b: Vector[A]): Vector[A]

proc `|*|`[A](a, b: Matrix[A]): Matrix[A]

proc sqrt[A: SomeFloat](v`gensym352431: Vector[A]): Vector[A]

proc sqrt[A: SomeFloat](m`gensym352434: Matrix[A]): Matrix[A]

proc cbrt[A: SomeFloat](v`gensym352628: Vector[A]): Vector[A]

proc cbrt[A: SomeFloat](m`gensym352631: Matrix[A]): Matrix[A]

proc log10[A: SomeFloat](v`gensym352828: Vector[A]): Vector[A]

proc log10[A: SomeFloat](m`gensym352831: Matrix[A]): Matrix[A]

proc log2[A: SomeFloat](v`gensym353028: Vector[A]): Vector[A]

proc log2[A: SomeFloat](m`gensym353031: Matrix[A]): Matrix[A]

proc log(x`gensym353227: float32): float32 {...}{.raises: [], tags: [].}

proc log[A: SomeFloat](v`gensym353228: Vector[A]): Vector[A]

proc log[A: SomeFloat](m`gensym353231: Matrix[A]): Matrix[A]

proc exp[A: SomeFloat](v`gensym353428: Vector[A]): Vector[A]

proc exp[A: SomeFloat](m`gensym353431: Matrix[A]): Matrix[A]

proc arccos[A: SomeFloat](v`gensym353628: Vector[A]): Vector[A]

proc arccos[A: SomeFloat](m`gensym353631: Matrix[A]): Matrix[A]

proc arcsin[A: SomeFloat](v`gensym353828: Vector[A]): Vector[A]

proc arcsin[A: SomeFloat](m`gensym353831: Matrix[A]): Matrix[A]

proc arctan[A: SomeFloat](v`gensym354028: Vector[A]): Vector[A]

proc arctan[A: SomeFloat](m`gensym354031: Matrix[A]): Matrix[A]

proc cos[A: SomeFloat](v`gensym354228: Vector[A]): Vector[A]

proc cos[A: SomeFloat](m`gensym354231: Matrix[A]): Matrix[A]

proc cosh[A: SomeFloat](v`gensym354428: Vector[A]): Vector[A]

proc cosh[A: SomeFloat](m`gensym354431: Matrix[A]): Matrix[A]

proc sin[A: SomeFloat](v`gensym354628: Vector[A]): Vector[A]

proc sin[A: SomeFloat](m`gensym354631: Matrix[A]): Matrix[A]

proc sinh[A: SomeFloat](v`gensym354828: Vector[A]): Vector[A]

proc sinh[A: SomeFloat](m`gensym354831: Matrix[A]): Matrix[A]

proc tan[A: SomeFloat](v`gensym355028: Vector[A]): Vector[A]

proc tan[A: SomeFloat](m`gensym355031: Matrix[A]): Matrix[A]

proc tanh[A: SomeFloat](v`gensym355228: Vector[A]): Vector[A]

proc tanh[A: SomeFloat](m`gensym355231: Matrix[A]): Matrix[A]

proc erf[A: SomeFloat](v`gensym355428: Vector[A]): Vector[A]

proc erf[A: SomeFloat](m`gensym355431: Matrix[A]): Matrix[A]

proc erfc[A: SomeFloat](v`gensym355628: Vector[A]): Vector[A]

proc erfc[A: SomeFloat](m`gensym355631: Matrix[A]): Matrix[A]

proc lgamma[A: SomeFloat](v`gensym355828: Vector[A]): Vector[A]

proc lgamma[A: SomeFloat](m`gensym355831: Matrix[A]): Matrix[A]

proc gamma[A: SomeFloat](v`gensym356028: Vector[A]): Vector[A]

proc gamma[A: SomeFloat](m`gensym356031: Matrix[A]): Matrix[A]

proc trunc[A: SomeFloat](v`gensym356228: Vector[A]): Vector[A]

proc trunc[A: SomeFloat](m`gensym356231: Matrix[A]): Matrix[A]

proc floor[A: SomeFloat](v`gensym356428: Vector[A]): Vector[A]

proc floor[A: SomeFloat](m`gensym356431: Matrix[A]): Matrix[A]

proc ceil[A: SomeFloat](v`gensym356628: Vector[A]): Vector[A]

proc ceil[A: SomeFloat](m`gensym356631: Matrix[A]): Matrix[A]

proc degToRad[A: SomeFloat](v`gensym356828: Vector[A]): Vector[A]

proc degToRad[A: SomeFloat](m`gensym356831: Matrix[A]): Matrix[A]

proc radToDeg[A: SomeFloat](v`gensym357028: Vector[A]): Vector[A]

proc radToDeg[A: SomeFloat](m`gensym357031: Matrix[A]): Matrix[A]

proc cumsum[A](v: Vector[A]): Vector[A]

proc sum[A](v: Vector[A]): A

proc mean[A: SomeFloat](v: Vector[A]): A {...}{.inline.}

proc variance[A: SomeFloat](v: Vector[A]): A

proc solve[A: SomeFloat](a, b: Matrix[A]): Matrix[A] {...}{.inline.}

proc solve[A: SomeFloat](a: Matrix[A]; b: Vector[A]): Vector[A] {...}{.inline.}

proc inv[A: SomeFloat](a: Matrix[A]): Matrix[A] {...}{.inline.}

proc balance[A: SomeFloat](a: Matrix[A]; op = BalanceOp.Both): BalanceResult[A]

proc hessenberg[A: SomeFloat](a: Matrix[A]): Matrix[A]

proc eigenvalues[A: SomeFloat](a: Matrix[A]): EigenValues[A]

proc schur[A: SomeFloat](a: Matrix[A]): SchurResult[A]

proc tr[A](a: Matrix[A]): A

proc det[A: SomeFloat](a: Matrix[A]): A

iterator items[A](v: Vector[A]): auto {...}{.inline.}

iterator pairs[A](v: Vector[A]): auto {...}{.inline.}

iterator columns[A](m: Matrix[A]): auto {...}{.inline.}

iterator rows[A](m: Matrix[A]): auto {...}{.inline.}

iterator columnsSlow[A](m: Matrix[A]): auto {...}{.inline.}

iterator rowsSlow[A](m: Matrix[A]): auto {...}{.inline.}

iterator items[A](m: Matrix[A]): auto {...}{.inline.}

iterator pairs[A](m: Matrix[A]): auto {...}{.inline.}

template makeVectorI[A](N: int; f: untyped): Vector[A]

template makeMatrixIJ(A: typedesc; M1, N1: int; f: untyped; ord = colMajor): auto

template concat[A](vectors: varargs[Vector[A]]): Vector[A]

template vstack[A](vectors: varargs[Vector[A]]): Matrix[A]

template max[A](v: Vector[A]): A

template min[A](v: Vector[A]): A

template `*`[A; ](k: A; v: Vector[A] or Matrix[A]): auto

template `/`[A; ](v: Vector[A] or Matrix[A]; k: A): auto

template `/=`[A; ](v: var Vector[A] or var Matrix[A]; k: A)

template `!=~`(a, b: Vector or Matrix): bool

template makeUniversal(fname: untyped)

template makeUniversalLocal(fname: untyped)

template stddev[A](v: Vector[A]): A

template sum(m: Matrix): auto

template mean(m: Matrix): auto

template variance(m: Matrix): auto

template stddev(m: Matrix): auto

template rewriteLinearCombination{
  v + `*`(w, a)
}[A](a: A; v, w: Vector[A]): auto

template rewriteLinearCombinationMut{
  v += `*`(w, a)
}[A](a: A; v: var Vector[A]; w: Vector[A]): auto

template `\`(a: Matrix; b: Matrix or Vector): auto