Module linalg

Types

Vector32[N] = ref array[N, float32]
  Source 
Vector64[N] = ref array[N, float64]
  Source 
Matrix32[M, N] = object
  order: OrderType
  data: ref array[N * M, float32]
  Source 
Matrix64[M, N] = object
  order: OrderType
  data: ref array[M * N, float64]
  Source 
DVector32 = seq[float32]
  Source 
DVector64 = seq[float64]
  Source 
DMatrix32 = object
  order: OrderType
  M, N: int
  data: seq[float32]
  Source 
DMatrix64 = object
  order: OrderType
  M, N: int
  data: seq[float64]
  Source 
CudaVector32[N] = ref [ptr float32]
  Source 
CudaVector64[N] = ref [ptr float64]
  Source 
CudaMatrix32[M, N] = object
  data: ref [ptr float32]
  Source 
CudaMatrix64[M, N] = object
  data: ref [ptr float64]
  Source 
CudaDVector32 = object
  N: int
  data: ref [ptr float32]
  Source 
CudaDVector64 = object
  N: int
  data: ref [ptr float64]
  Source 
CudaDMatrix32 = object
  M, N: int
  data: ref [ptr float32]
  Source 
CudaDMatrix64 = object
  M, N: int
  data: ref [ptr float64]
  Source

Procs

proc `==`[](u, v: Vector32 or Vector64): bool
  Source 
proc `==`[](m, n: Matrix32 or Matrix64): bool
  Source 
proc `==`[](m, n: DMatrix32 or DMatrix64): bool
  Source 
proc to32[N](v: Vector64[N]): Vector32[N]
  Source 
proc to64[N](v: Vector32[N]): Vector64[N]
  Source 
proc to32(v: DVector64): DVector32 {.raises: [], tags: [].}
  Source 
proc to64(v: DVector32): DVector64 {.raises: [], tags: [].}
  Source 
proc to32[M, N](m: Matrix64[M, N]): Matrix32[M, N]
  Source 
proc to64[M, N](m: Matrix32[M, N]): Matrix64[M, N]
  Source 
proc to32(v: DMatrix64): DMatrix32 {.raises: [], tags: [].}
  Source 
proc to64(v: DMatrix32): DMatrix64 {.raises: [], tags: [].}
  Source 
proc toDynamic[N, ](v: Vector32[N] or Vector64[N]): auto
  Source 
proc toDynamic[M, N](m: Matrix32[M, N]): DMatrix32
  Source 
proc toDynamic[M, N](m: Matrix64[M, N]): DMatrix64
  Source 
proc toStatic[](v: DVector32; N: static[int]): Vector32[N]
  Source 
proc toStatic[](v: DVector64; N: static[int]): Vector64[N]
  Source 
proc toStatic[](m: DMatrix32; M, N: static[int]): Matrix32[M, N]
  Source 
proc toStatic[](m: DMatrix64; M, N: static[int]): Matrix64[M, N]
  Source 
proc gpu[N](v: Vector32[N]): CudaVector32[N]
  Source 
proc gpu[N](v: Vector64[N]): CudaVector64[N]
  Source 
proc gpu(v: DVector32): CudaDVector32 {.raises: [Exception, CudaException,
    CublasException], tags: [RootEffect].}
  Source 
proc gpu(v: DVector64): CudaDVector64 {.raises: [Exception, CudaException,
    CublasException], tags: [RootEffect].}
  Source 
proc cpu[N](v: CudaVector32[N]): Vector32[N]
  Source 
proc cpu[N](v: CudaVector64[N]): Vector64[N]
  Source 
proc cpu(v: CudaDVector32): DVector32 {.raises: [CublasException], tags: [].}
  Source 
proc cpu(v: CudaDVector64): DVector64 {.raises: [CublasException], tags: [].}
  Source 
proc gpu[M, N](m: Matrix32[M, N]): CudaMatrix32[M, N]
  Source 
proc gpu[M, N](m: Matrix64[M, N]): CudaMatrix64[M, N]
  Source 
proc gpu(m: DMatrix32): CudaDMatrix32 {.raises: [Exception, CudaException,
    CublasException], tags: [RootEffect].}
  Source 
proc gpu(m: DMatrix64): CudaDMatrix64 {.raises: [Exception, CudaException,
    CublasException], tags: [RootEffect].}
  Source 
proc cpu[M, N](m: CudaMatrix32[M, N]): Matrix32[M, N]
  Source 
proc cpu[M, N](m: CudaMatrix64[M, N]): Matrix64[M, N]
  Source 
proc cpu(m: CudaDMatrix32): DMatrix32 {.raises: [CublasException], tags: [].}
  Source 
proc cpu(m: CudaDMatrix64): DMatrix64 {.raises: [CublasException], tags: [].}
  Source 
proc `*=`[N](v: var CudaVector32[N]; k: float32) {.inline.}
  Source 
proc `*=`(v: var CudaDVector32; k: float32) {.inline, raises: [CublasException], tags: [].}
  Source 
proc `*=`[N](v: var CudaVector64[N]; k: float64) {.inline.}
  Source 
proc `*=`(v: var CudaDVector64; k: float64) {.inline, raises: [CublasException], tags: [].}
  Source 
proc `*`[N](v: CudaVector32[N]; k: float32): CudaVector32[N] {.inline.}
  Source 
proc `*`(v: CudaDVector32; k: float32): CudaDVector32 {.inline,
    raises: [Exception, CudaException, CublasException], tags: [RootEffect].}
  Source 
proc `*`[N](v: CudaVector64[N]; k: float64): CudaVector64[N] {.inline.}
  Source 
proc `*`(v: CudaDVector64; k: float64): CudaDVector64 {.inline,
    raises: [Exception, CudaException, CublasException], tags: [RootEffect].}
  Source 
proc `+=`[N](v: var CudaVector32[N]; w: CudaVector32[N]) {.inline.}
  Source 
proc `+=`(v: var CudaDVector32; w: CudaDVector32) {.inline, raises: [CublasException],
    tags: [].}
  Source 
proc `+=`[N](v: var CudaVector64[N]; w: CudaVector64[N]) {.inline.}
  Source 
proc `+=`(v: var CudaDVector64; w: CudaDVector64) {.inline, raises: [CublasException],
    tags: [].}
  Source 
proc `+`[N](v, w: CudaVector32[N]): CudaVector32[N] {.inline.}
  Source 
proc `+`(v, w: CudaDVector32): CudaDVector32 {.inline,
    raises: [Exception, CudaException, CublasException], tags: [RootEffect].}
  Source 
proc `+`[N](v, w: CudaVector64[N]): CudaVector64[N] {.inline.}
  Source 
proc `+`(v, w: CudaDVector64): CudaDVector64 {.inline,
    raises: [Exception, CudaException, CublasException], tags: [RootEffect].}
  Source 
proc `-=`[N](v: var CudaVector32[N]; w: CudaVector32[N]) {.inline.}
  Source 
proc `-=`(v: var CudaDVector32; w: CudaDVector32) {.inline, raises: [CublasException],
    tags: [].}
  Source 
proc `-=`[N](v: var CudaVector64[N]; w: CudaVector64[N]) {.inline.}
  Source 
proc `-=`(v: var CudaDVector64; w: CudaDVector64) {.inline, raises: [CublasException],
    tags: [].}
  Source 
proc `-`[N](v, w: CudaVector32[N]): CudaVector32[N] {.inline.}
  Source 
proc `-`(v, w: CudaDVector32): CudaDVector32 {.inline,
    raises: [Exception, CudaException, CublasException], tags: [RootEffect].}
  Source 
proc `-`[N](v, w: CudaVector64[N]): CudaVector64[N] {.inline.}
  Source 
proc `-`(v, w: CudaDVector64): CudaDVector64 {.inline,
    raises: [Exception, CudaException, CublasException], tags: [RootEffect].}
  Source 
proc `*`[N](v, w: CudaVector32[N]): float32 {.inline.}
  Source 
proc `*`(v, w: CudaDVector32): float32 {.inline, raises: [CublasException], tags: [].}
  Source 
proc `*`[N](v, w: CudaVector64[N]): float64 {.inline.}
  Source 
proc `*`(v, w: CudaDVector64): float64 {.inline, raises: [CublasException], tags: [].}
  Source 
proc l_2[N](v: CudaVector32[N]): float32 {.inline.}
  Source 
proc l_2(v: CudaDVector32): float32 {.inline, raises: [CublasException], tags: [].}
  Source 
proc l_2[N](v: CudaVector64[N]): float64 {.inline.}
  Source 
proc l_2(v: CudaDVector64): float64 {.inline, raises: [CublasException], tags: [].}
  Source 
proc l_1[N](v: CudaVector32[N]): float32 {.inline.}
  Source 
proc l_1(v: CudaDVector32): float32 {.inline, raises: [CublasException], tags: [].}
  Source 
proc l_1[N](v: CudaVector64[N]): float64 {.inline.}
  Source 
proc l_1(v: CudaDVector64): float64 {.inline, raises: [CublasException], tags: [].}
  Source 
proc `*`[M, N](a: CudaMatrix32[M, N]; v: CudaVector32[N]): CudaVector32[M] {.inline.}
  Source 
proc `*`(a: CudaDMatrix32; v: CudaDVector32): CudaDVector32 {.inline,
    raises: [Exception, CudaException, CublasException], tags: [RootEffect].}
  Source 
proc `*`[M, N](a: CudaMatrix64[M, N]; v: CudaVector64[N]): CudaVector64[M] {.inline.}
  Source 
proc `*`(a: CudaDMatrix64; v: CudaDVector64): CudaDVector64 {.inline,
    raises: [Exception, CudaException, CublasException], tags: [RootEffect].}
  Source 
proc `*=`[M, N](m: var CudaMatrix32[M, N]; k: float32) {.inline.}
  Source 
proc `*=`(m: var CudaDMatrix32; k: float32) {.inline, raises: [CublasException], tags: [].}
  Source 
proc `*=`[M, N](m: var CudaMatrix64[M, N]; k: float64) {.inline.}
  Source 
proc `*=`(m: var CudaDMatrix64; k: float64) {.inline, raises: [CublasException], tags: [].}
  Source 
proc `*`[M, N](m: CudaMatrix32[M, N]; k: float32): CudaMatrix32[M, N] {.inline.}
  Source 
proc `*`(m: CudaDMatrix32; k: float32): CudaDMatrix32 {.inline,
    raises: [Exception, CudaException, CublasException], tags: [RootEffect].}
  Source 
proc `*`[M, N](m: CudaMatrix64[M, N]; k: float64): CudaMatrix64[M, N] {.inline.}
  Source 
proc `*`(m: CudaDMatrix64; k: float64): CudaDMatrix64 {.inline,
    raises: [Exception, CudaException, CublasException], tags: [RootEffect].}
  Source 
proc `+=`[M, N](a: var CudaMatrix32[M, N]; b: CudaMatrix32[M, N]) {.inline.}
  Source 
proc `+=`(a: var CudaDMatrix32; b: CudaDMatrix32) {.inline, raises: [CublasException],
    tags: [].}
  Source 
proc `+=`[M, N](a: var CudaMatrix64[M, N]; b: CudaMatrix64[M, N]) {.inline.}
  Source 
proc `+=`(a: var CudaDMatrix64; b: CudaDMatrix64) {.inline, raises: [CublasException],
    tags: [].}
  Source 
proc `+`[M, N](a, b: CudaMatrix32[M, N]): CudaMatrix32[M, N] {.inline.}
  Source 
proc `+`(a, b: CudaDMatrix32): CudaDMatrix32 {.inline,
    raises: [Exception, CudaException, CublasException], tags: [RootEffect].}
  Source 
proc `+`[M, N](a, b: CudaMatrix64[M, N]): CudaMatrix64[M, N] {.inline.}
  Source 
proc `+`(a, b: CudaDMatrix64): CudaDMatrix64 {.inline,
    raises: [Exception, CudaException, CublasException], tags: [RootEffect].}
  Source 
proc `-=`[M, N](a: var CudaMatrix32[M, N]; b: CudaMatrix32[M, N]) {.inline.}
  Source 
proc `-=`(a: var CudaDMatrix32; b: CudaDMatrix32) {.inline, raises: [CublasException],
    tags: [].}
  Source 
proc `-=`[M, N](a: var CudaMatrix64[M, N]; b: CudaMatrix64[M, N]) {.inline.}
  Source 
proc `-=`(a: var CudaDMatrix64; b: CudaDMatrix64) {.inline, raises: [CublasException],
    tags: [].}
  Source 
proc `-`[M, N](a, b: CudaMatrix32[M, N]): CudaMatrix32[M, N] {.inline.}
  Source 
proc `-`(a, b: CudaDMatrix32): CudaDMatrix32 {.inline,
    raises: [Exception, CudaException, CublasException], tags: [RootEffect].}
  Source 
proc `-`[M, N](a, b: CudaMatrix64[M, N]): CudaMatrix64[M, N] {.inline.}
  Source 
proc `-`(a, b: CudaDMatrix64): CudaDMatrix64 {.inline,
    raises: [Exception, CudaException, CublasException], tags: [RootEffect].}
  Source 
proc `*`[M, N, K](a: CudaMatrix32[M, K]; b: CudaMatrix32[K, N]): CudaMatrix32[M, N] {.
    inline.}
  Source 
proc `*`(a: CudaDMatrix32; b: CudaDMatrix32): CudaDMatrix32 {.inline,
    raises: [Exception, CudaException, CublasException], tags: [RootEffect].}
  Source 
proc `*`[M, N, K](a: CudaMatrix64[M, K]; b: CudaMatrix64[K, N]): CudaMatrix64[M, N] {.
    inline.}
  Source 
proc `*`(a: CudaDMatrix64; b: CudaDMatrix64): CudaDMatrix64 {.inline,
    raises: [Exception, CudaException, CublasException], tags: [RootEffect].}
  Source 
proc l_2[M, N](m: CudaMatrix32[M, N]): float32 {.inline.}
  Source 
proc l_2(m: CudaDMatrix32): float32 {.inline, raises: [CublasException], tags: [].}
  Source 
proc l_2[M, N](m: CudaMatrix64[M, N]): float64 {.inline.}
  Source 
proc l_2(m: CudaDMatrix64): float64 {.inline, raises: [CublasException], tags: [].}
  Source 
proc l_1[M, N](m: CudaMatrix32[M, N]): float32 {.inline.}
  Source 
proc l_1(m: CudaDMatrix32): float32 {.inline, raises: [CublasException], tags: [].}
  Source 
proc l_1[M, N](m: CudaMatrix64[M, N]): float64 {.inline.}
  Source 
proc l_1(m: CudaDMatrix64): float64 {.inline, raises: [CublasException], tags: [].}
  Source 
proc `==`[N](v, w: CudaVector32[N]): bool
  Source 
proc `==`(m, n: CudaDVector32): bool {.raises: [CublasException], tags: [].}
  Source 
proc `==`[N](v, w: CudaVector64[N]): bool
  Source 
proc `==`(m, n: CudaDVector64): bool {.raises: [CublasException], tags: [].}
  Source 
proc `==`[M, N](m, n: CudaMatrix32[M, N]): bool
  Source 
proc `==`(m, n: CudaDMatrix32): bool {.raises: [CublasException], tags: [].}
  Source 
proc `==`[M, N](m, n: CudaMatrix64[M, N]): bool
  Source 
proc `==`(m, n: CudaDMatrix64): bool {.raises: [CublasException], tags: [].}
  Source 
proc `=~`[N](v, w: CudaVector32[N]): bool
  Source 
proc `=~`(v, w: CudaDVector32): bool {.raises: [CublasException, Exception,
    CudaException], tags: [RootEffect].}
  Source 
proc `=~`[N](v, w: CudaVector64[N]): bool
  Source 
proc `=~`(v, w: CudaDVector64): bool {.raises: [CublasException, Exception,
    CudaException], tags: [RootEffect].}
  Source 
proc `=~`[M, N](m, n: CudaMatrix32[M, N]): bool
  Source 
proc `=~`(v, w: CudaDMatrix32): bool {.raises: [CublasException, Exception,
    CudaException], tags: [RootEffect].}
  Source 
proc `=~`[M, N](m, n: CudaMatrix64[M, N]): bool
  Source 
proc `=~`(v, w: CudaDMatrix64): bool {.raises: [CublasException, Exception,
    CudaException], tags: [RootEffect].}
  Source 
proc `$`[N](v: CudaVector32[N]): string
  Source 
proc `$`[N](v: CudaVector64[N]): string
  Source 
proc `$`[M, N](m: CudaMatrix32[M, N]): string
  Source 
proc `$`[M, N](m: CudaMatrix64[M, N]): string
  Source 
proc `$`(v: CudaDVector32): string {.raises: [CublasException], tags: [].}
  Source 
proc `$`(v: CudaDVector64): string {.raises: [CublasException], tags: [].}
  Source 
proc `$`(m: CudaDMatrix32): string {.raises: [CublasException], tags: [].}
  Source 
proc `$`(m: CudaDMatrix64): string {.raises: [CublasException], tags: [].}
  Source 
proc makeVector[](N: int or static[int]; f: proc (i: int): float64): auto
  Source 
proc makeVector[](N: int or static[int]; f: proc (i: int): float32): auto
  Source 
proc randomVector[](N: int or static[int]; max: float64 = 1): auto
  Source 
proc randomVector[](N: int or static[int]; max: float32): auto
  Source 
proc constantVector[](N: int or static[int]; x: float32 or float64): auto
  Source 
proc zeros[](N: int or static[int]): auto
  Source 
proc zeros[](N: int or static[int]; A: typedesc[float32]): auto
  Source 
proc ones[](N: int or static[int]): auto
  Source 
proc ones[](N: int or static[int]; A: typedesc[float32]): auto
  Source 
proc vector[N](xs: Array32[N]): Vector32[N]
  Source 
proc vector[N](xs: Array64[N]): Vector64[N]
  Source 
proc makeMatrix[](M: int or static[int]; N: int or static[int];
                 f: proc (i, j: int): float32; order: OrderType = colMajor): auto
  Source 
proc makeMatrix[](M: int or static[int]; N: int or static[int];
                 f: proc (i, j: int): float64; order: OrderType = colMajor): auto
  Source 
proc randomMatrix[](M: int or static[int]; N: int or static[int]; max: float64 = 1;
                   order: OrderType = colMajor): auto
  Source 
proc randomMatrix[](M: int or static[int]; N: int or static[int]; max: float32;
                   order: OrderType = colMajor): auto
  Source 
proc constantMatrix[](M: int or static[int]; N: int or static[int]; x: float64;
                     order: OrderType = colMajor): auto
  Source 
proc constantMatrix[](M: int or static[int]; N: int or static[int]; x: float32;
                     order: OrderType = colMajor): auto
  Source 
proc zeros[](M: int or static[int]; N: int or static[int]; order: OrderType = colMajor): auto
  Source 
proc zeros[](M: int or static[int]; N: int or static[int]; A: typedesc[float32];
            order: OrderType = colMajor): auto
  Source 
proc ones[](M: int or static[int]; N: int or static[int]; order: OrderType = colMajor): auto
  Source 
proc ones[](M: int or static[int]; N: int or static[int]; A: typedesc[float32];
           order: OrderType = colMajor): auto
  Source 
proc eye[](N: int or static[int]; order: OrderType = colMajor): auto
  Source 
proc eye[](N: int or static[int]; A: typedesc[float32]; order: OrderType = colMajor): auto
  Source 
proc matrix(xs: seq[seq[float32]]; order: OrderType = colMajor): DMatrix32 {.raises: [],
    tags: [].}
  Source 
proc matrix(xs: seq[seq[float64]]; order: OrderType = colMajor): DMatrix64 {.raises: [],
    tags: [].}
  Source 
proc matrix[M, N](xs: DoubleArray32[M, N]; order: OrderType = colMajor): Matrix32[M, N]
  Source 
proc matrix[M, N](xs: DoubleArray64[M, N]; order: OrderType = colMajor): Matrix64[M, N]
  Source 
proc matrix[](xs: seq[seq[float32]]; M, N: static[int]; order: OrderType = colMajor): Matrix32[
    M, N]
  Source 
proc matrix[](xs: seq[seq[float64]]; M, N: static[int]; order: OrderType = colMajor): Matrix64[
    M, N]
  Source 
proc len[N, ](v: Vector32[N] or Vector64[N]): int
  Source 
proc clone[N](v: Vector64[N]): Vector64[N]
  Source 
proc clone[N](v: Vector32[N]): Vector32[N]
  Source 
proc clone[](v: DVector64 or DVector32): auto
  Source 
proc map[N](v: Vector32[N]; f: proc (x: float32): float32): Vector32[N]
  Source 
proc map[N](v: Vector64[N]; f: proc (x: float64): float64): Vector64[N]
  Source 
proc at[M, N](m: Matrix64[M, N]; i, j: int): float64 {.inline.}
  Source 
proc at(m: DMatrix64; i, j: int): float64 {.inline, raises: [], tags: [].}
  Source 
proc at[M, N](m: Matrix32[M, N]; i, j: int): float32 {.inline.}
  Source 
proc at(m: DMatrix32; i, j: int): float32 {.inline, raises: [], tags: [].}
  Source 
proc put[M, N](m: var Matrix64[M, N]; i, j: int; val: float64) {.inline.}
  Source 
proc put(m: var DMatrix64; i, j: int; val: float64) {.inline, raises: [], tags: [].}
  Source 
proc `[]=`[Matrix64](m: var Matrix64; i, j: int; val: float64) {.inline.}
  Source 
proc `[]=`(m: var DMatrix64; i, j: int; val: float64) {.inline, raises: [], tags: [].}
  Source 
proc put[M, N](m: var Matrix32[M, N]; i, j: int; val: float32) {.inline.}
  Source 
proc put(m: var DMatrix32; i, j: int; val: float32) {.inline, raises: [], tags: [].}
  Source 
proc `[]=`[Matrix32](m: var Matrix32; i, j: int; val: float32) {.inline.}
  Source 
proc `[]=`(m: var DMatrix32; i, j: int; val: float32) {.inline, raises: [], tags: [].}
  Source 
proc column[M, N](m: Matrix32[M, N]; j: int): Vector32[M] {.inline.}
  Source 
proc row[M, N](m: Matrix32[M, N]; i: int): Vector32[N] {.inline.}
  Source 
proc column(m: DMatrix32; j: int): DVector32 {.inline, raises: [], tags: [].}
  Source 
proc row(m: DMatrix32; i: int): DVector32 {.inline, raises: [], tags: [].}
  Source 
proc column[M, N](m: Matrix64[M, N]; j: int): Vector64[M] {.inline.}
  Source 
proc row[M, N](m: Matrix64[M, N]; i: int): Vector64[N] {.inline.}
  Source 
proc column(m: DMatrix64; j: int): DVector64 {.inline, raises: [], tags: [].}
  Source 
proc row(m: DMatrix64; i: int): DVector64 {.inline, raises: [], tags: [].}
  Source 
proc dim[M, N, ](m: Matrix32[M, N] or Matrix64[M, N]): tuple[rows, columns: int]
  Source 
proc dim[](m: DMatrix32 or DMatrix64): tuple[rows, columns: int]
  Source 
proc clone[M, N](m: Matrix32[M, N]): Matrix32[M, N]
  Source 
proc clone[M, N](m: Matrix64[M, N]): Matrix64[M, N]
  Source 
proc clone(m: DMatrix32): DMatrix32 {.raises: [], tags: [].}
  Source 
proc clone(m: DMatrix64): DMatrix64 {.raises: [], tags: [].}
  Source 
proc map[M, N](m: Matrix32[M, N]; f: proc (x: float32): float32): Matrix32[M, N]
  Source 
proc map[M, N](m: Matrix64[M, N]; f: proc (x: float64): float64): Matrix64[M, N]
  Source 
proc map(m: DMatrix32; f: proc (x: float32): float32): DMatrix32 {.raises: [], tags: [].}
  Source 
proc map(m: DMatrix64; f: proc (x: float64): float64): DMatrix64 {.raises: [], tags: [].}
  Source 
proc `$`[N, ](v: Vector32[N] or Vector64[N]): string
  Source 
proc `$`[M, N](m: Matrix32[M, N]): string
  Source 
proc `$`[M, N](m: Matrix64[M, N]): string
  Source 
proc `$`[](m: DMatrix32 or DMatrix64): string
  Source 
proc t[M, N](a: Matrix32[M, N]): Matrix32[N, M]
  Source 
proc t(a: DMatrix32): DMatrix32 {.raises: [], tags: [].}
  Source 
proc t[M, N](a: Matrix64[M, N]): Matrix64[N, M]
  Source 
proc t(a: DMatrix64): DMatrix64 {.raises: [], tags: [].}
  Source 
proc reshape[M, N, ](m: Matrix32[M, N]; A, B: static[int]): Matrix32[A, B]
  Source 
proc reshape(m: DMatrix32; A, B: int): DMatrix32 {.raises: [], tags: [].}
  Source 
proc reshape[M, N, ](m: Matrix64[M, N]; A, B: static[int]): Matrix64[A, B]
  Source 
proc reshape(m: DMatrix64; A, B: int): DMatrix64 {.raises: [], tags: [].}
  Source 
proc asMatrix[N, ](v: Vector32[N]; A, B: static[int]; order: OrderType = colMajor): Matrix32[
    A, B]
  Source 
proc asMatrix(v: DVector32; A, B: int; order: OrderType = colMajor): DMatrix32 {.
    raises: [], tags: [].}
  Source 
proc asMatrix[N, ](v: Vector64[N]; A, B: static[int]; order: OrderType = colMajor): Matrix64[
    A, B]
  Source 
proc asMatrix(v: DVector64; A, B: int; order: OrderType = colMajor): DMatrix64 {.
    raises: [], tags: [].}
  Source 
proc asVector[M, N](m: Matrix32[M, N]): Vector32[M * N]
  Source 
proc asVector[M, N](m: Matrix64[M, N]): Vector64[M * N]
  Source 
proc asVector(m: DMatrix32): DVector32 {.raises: [], tags: [].}
  Source 
proc asVector(m: DMatrix64): DVector64 {.raises: [], tags: [].}
  Source 
proc `*=`[N](v: var Vector32[N]; k: float32) {.inline.}
  Source 
proc `*=`(v: var DVector32; k: float32) {.inline, raises: [], tags: [].}
  Source 
proc `*`[N](v: Vector32[N]; k: float32): Vector32[N] {.inline.}
  Source 
proc `*`(v: DVector32; k: float32): DVector32 {.inline, raises: [], tags: [].}
  Source 
proc `*=`[N](v: var Vector64[N]; k: float64) {.inline.}
  Source 
proc `*=`(v: var DVector64; k: float64) {.inline, raises: [], tags: [].}
  Source 
proc `*`[N](v: Vector64[N]; k: float64): Vector64[N] {.inline.}
  Source 
proc `*`(v: DVector64; k: float64): DVector64 {.inline, raises: [], tags: [].}
  Source 
proc `+=`[N](v: var Vector32[N]; w: Vector32[N]) {.inline.}
  Source 
proc `+=`(v: var DVector32; w: DVector32) {.inline, raises: [], tags: [].}
  Source 
proc `+`[N](v, w: Vector32[N]): Vector32[N] {.inline.}
  Source 
proc `+`(v, w: DVector32): DVector32 {.inline, raises: [], tags: [].}
  Source 
proc `+=`[N](v: var Vector64[N]; w: Vector64[N]) {.inline.}
  Source 
proc `+=`(v: var DVector64; w: DVector64) {.inline, raises: [], tags: [].}
  Source 
proc `+`[N](v, w: Vector64[N]): Vector64[N] {.inline.}
  Source 
proc `+`(v, w: DVector64): DVector64 {.inline, raises: [], tags: [].}
  Source 
proc `-=`[N](v: var Vector32[N]; w: Vector32[N]) {.inline.}
  Source 
proc `-=`(v: var DVector32; w: DVector32) {.inline, raises: [], tags: [].}
  Source 
proc `-`[N](v, w: Vector32[N]): Vector32[N] {.inline.}
  Source 
proc `-`(v, w: DVector32): DVector32 {.inline, raises: [], tags: [].}
  Source 
proc `-=`[N](v: var Vector64[N]; w: Vector64[N]) {.inline.}
  Source 
proc `-=`(v: var DVector64; w: DVector64) {.inline, raises: [], tags: [].}
  Source 
proc `-`[N](v, w: Vector64[N]): Vector64[N] {.inline.}
  Source 
proc `-`(v, w: DVector64): DVector64 {.inline, raises: [], tags: [].}
  Source 
proc `*`[N](v, w: Vector32[N]): float32 {.inline.}
  Source 
proc `*`[N](v, w: Vector64[N]): float64 {.inline.}
  Source 
proc `*`(v, w: DVector32): float32 {.inline, raises: [], tags: [].}
  Source 
proc `*`(v, w: DVector64): float64 {.inline, raises: [], tags: [].}
  Source 
proc l_2[N, ](v: Vector32[N] or Vector64[N]): auto {.inline.}
  Source 
proc l_2[](v: DVector32 or DVector64): auto {.inline.}
  Source 
proc l_1[N, ](v: Vector32[N] or Vector64[N]): auto {.inline.}
  Source 
proc l_1[](v: DVector32 or DVector64): auto {.inline.}
  Source 
proc maxIndex[N](v: Vector32[N]): tuple[i: int, val: float32]
  Source 
proc maxIndex[N](v: Vector64[N]): tuple[i: int, val: float64]
  Source 
proc maxIndex(v: DVector32): tuple[i: int, val: float32] {.raises: [], tags: [].}
  Source 
proc maxIndex(v: DVector64): tuple[i: int, val: float64] {.raises: [], tags: [].}
  Source 
proc minIndex[N](v: Vector32[N]): tuple[i: int, val: float32]
  Source 
proc minIndex[N](v: Vector64[N]): tuple[i: int, val: float64]
  Source 
proc minIndex(v: DVector32): tuple[i: int, val: float32] {.raises: [], tags: [].}
  Source 
proc minIndex(v: DVector64): tuple[i: int, val: float64] {.raises: [], tags: [].}
  Source 
proc `*`[M, N](a: Matrix32[M, N]; v: Vector32[N]): Vector32[M] {.inline.}
  Source 
proc `*`(a: DMatrix32; v: DVector32): DVector32 {.inline, raises: [], tags: [].}
  Source 
proc `*`[M, N](a: Matrix64[M, N]; v: Vector64[N]): Vector64[M] {.inline.}
  Source 
proc `*`(a: DMatrix64; v: DVector64): DVector64 {.inline, raises: [], tags: [].}
  Source 
proc `*=`[M, N](m: var Matrix32[M, N]; k: float32) {.inline.}
  Source 
proc `*`[M, N](m: Matrix32[M, N]; k: float32): Matrix32[M, N] {.inline.}
  Source 
proc `*=`(m: var DMatrix32; k: float32) {.inline, raises: [], tags: [].}
  Source 
proc `*`(m: DMatrix32; k: float32): DMatrix32 {.inline, raises: [], tags: [].}
  Source 
proc `*=`[M, N](m: var Matrix64[M, N]; k: float64) {.inline.}
  Source 
proc `*`[M, N](m: Matrix64[M, N]; k: float64): Matrix64[M, N] {.inline.}
  Source 
proc `*=`(m: var DMatrix64; k: float64) {.inline, raises: [], tags: [].}
  Source 
proc `*`(m: DMatrix64; k: float64): DMatrix64 {.inline, raises: [], tags: [].}
  Source 
proc `+=`[M, N](a: var Matrix32[M, N]; b: Matrix32[M, N]) {.inline.}
  Source 
proc `+=`(a: var DMatrix32; b: DMatrix32) {.inline, raises: [], tags: [].}
  Source 
proc `+=`[M, N](a: var Matrix64[M, N]; b: Matrix64[M, N]) {.inline.}
  Source 
proc `+=`(a: var DMatrix64; b: DMatrix64) {.inline, raises: [], tags: [].}
  Source 
proc `+`[M, N](a, b: Matrix32[M, N]): Matrix32[M, N] {.inline.}
  Source 
proc `+`(a, b: DMatrix32): DMatrix32 {.inline, raises: [], tags: [].}
  Source 
proc `+`[M, N](a, b: Matrix64[M, N]): Matrix64[M, N] {.inline.}
  Source 
proc `+`(a, b: DMatrix64): DMatrix64 {.inline, raises: [], tags: [].}
  Source 
proc `-=`[M, N](a: var Matrix32[M, N]; b: Matrix32[M, N]) {.inline.}
  Source 
proc `-=`(a: var DMatrix32; b: DMatrix32) {.inline, raises: [], tags: [].}
  Source 
proc `-`[M, N](a, b: Matrix32[M, N]): Matrix32[M, N] {.inline.}
  Source 
proc `-`(a, b: DMatrix32): DMatrix32 {.inline, raises: [], tags: [].}
  Source 
proc `-=`[M, N](a: var Matrix64[M, N]; b: Matrix64[M, N]) {.inline.}
  Source 
proc `-=`(a: var DMatrix64; b: DMatrix64) {.inline, raises: [], tags: [].}
  Source 
proc `-`[M, N](a, b: Matrix64[M, N]): Matrix64[M, N] {.inline.}
  Source 
proc `-`(a, b: DMatrix64): DMatrix64 {.inline, raises: [], tags: [].}
  Source 
proc l_2[M, N, ](m: Matrix32[M, N] or Matrix64[M, N]): auto {.inline.}
  Source 
proc l_2[](m: DMatrix32 or DMatrix64): auto {.inline.}
  Source 
proc l_1[M, N, ](m: Matrix32[M, N] or Matrix64[M, N]): auto {.inline.}
  Source 
proc l_1[](m: DMatrix32 or DMatrix64): auto {.inline.}
  Source 
proc `*`[M, N, K](a: Matrix32[M, K]; b: Matrix32[K, N]): Matrix32[M, N] {.inline.}
  Source 
proc `*`(a: DMatrix32; b: DMatrix32): DMatrix32 {.inline, raises: [], tags: [].}
  Source 
proc `*`[M, N, K](a: Matrix64[M, K]; b: Matrix64[K, N]): Matrix64[M, N] {.inline.}
  Source 
proc `*`(a: DMatrix64; b: DMatrix64): DMatrix64 {.inline, raises: [], tags: [].}
  Source 
proc `=~`[M, N](m, n: Matrix32[M, N]): bool
  Source 
proc `=~`[M, N](m, n: Matrix64[M, N]): bool
  Source 
proc sqrt(x: float32): float32 {.raises: [], tags: [].}
  Source 
proc sqrt[N](v: Vector32[N]): Vector32[N]
  Source 
proc sqrt(v: DVector32): DVector32 {.raises: [], tags: [].}
  Source 
proc sqrt[M, N](m: Matrix32[M, N]): Matrix32[M, N]
  Source 
proc sqrt(m: DMatrix32): DMatrix32 {.raises: [], tags: [].}
  Source 
proc sqrt[N](v: Vector64[N]): Vector64[N]
  Source 
proc sqrt(v: DVector64): DVector64 {.raises: [], tags: [].}
  Source 
proc sqrt[M, N](m: Matrix64[M, N]): Matrix64[M, N]
  Source 
proc sqrt(m: DMatrix64): DMatrix64 {.raises: [], tags: [].}
  Source 
proc cbrt(x: float32): float32 {.raises: [], tags: [].}
  Source 
proc cbrt[N](v: Vector32[N]): Vector32[N]
  Source 
proc cbrt(v: DVector32): DVector32 {.raises: [], tags: [].}
  Source 
proc cbrt[M, N](m: Matrix32[M, N]): Matrix32[M, N]
  Source 
proc cbrt(m: DMatrix32): DMatrix32 {.raises: [], tags: [].}
  Source 
proc cbrt[N](v: Vector64[N]): Vector64[N]
  Source 
proc cbrt(v: DVector64): DVector64 {.raises: [], tags: [].}
  Source 
proc cbrt[M, N](m: Matrix64[M, N]): Matrix64[M, N]
  Source 
proc cbrt(m: DMatrix64): DMatrix64 {.raises: [], tags: [].}
  Source 
proc log10(x: float32): float32 {.raises: [], tags: [].}
  Source 
proc log10[N](v: Vector32[N]): Vector32[N]
  Source 
proc log10(v: DVector32): DVector32 {.raises: [], tags: [].}
  Source 
proc log10[M, N](m: Matrix32[M, N]): Matrix32[M, N]
  Source 
proc log10(m: DMatrix32): DMatrix32 {.raises: [], tags: [].}
  Source 
proc log10[N](v: Vector64[N]): Vector64[N]
  Source 
proc log10(v: DVector64): DVector64 {.raises: [], tags: [].}
  Source 
proc log10[M, N](m: Matrix64[M, N]): Matrix64[M, N]
  Source 
proc log10(m: DMatrix64): DMatrix64 {.raises: [], tags: [].}
  Source 
proc log2(x: float32): float32 {.raises: [], tags: [].}
  Source 
proc log2[N](v: Vector32[N]): Vector32[N]
  Source 
proc log2(v: DVector32): DVector32 {.raises: [], tags: [].}
  Source 
proc log2[M, N](m: Matrix32[M, N]): Matrix32[M, N]
  Source 
proc log2(m: DMatrix32): DMatrix32 {.raises: [], tags: [].}
  Source 
proc log2[N](v: Vector64[N]): Vector64[N]
  Source 
proc log2(v: DVector64): DVector64 {.raises: [], tags: [].}
  Source 
proc log2[M, N](m: Matrix64[M, N]): Matrix64[M, N]
  Source 
proc log2(m: DMatrix64): DMatrix64 {.raises: [], tags: [].}
  Source 
proc log(x: float32): float32 {.raises: [], tags: [].}
  Source 
proc log[N](v: Vector32[N]): Vector32[N]
  Source 
proc log(v: DVector32): DVector32 {.raises: [], tags: [].}
  Source 
proc log[M, N](m: Matrix32[M, N]): Matrix32[M, N]
  Source 
proc log(m: DMatrix32): DMatrix32 {.raises: [], tags: [].}
  Source 
proc log[N](v: Vector64[N]): Vector64[N]
  Source 
proc log(v: DVector64): DVector64 {.raises: [], tags: [].}
  Source 
proc log[M, N](m: Matrix64[M, N]): Matrix64[M, N]
  Source 
proc log(m: DMatrix64): DMatrix64 {.raises: [], tags: [].}
  Source 
proc exp(x: float32): float32 {.raises: [], tags: [].}
  Source 
proc exp[N](v: Vector32[N]): Vector32[N]
  Source 
proc exp(v: DVector32): DVector32 {.raises: [], tags: [].}
  Source 
proc exp[M, N](m: Matrix32[M, N]): Matrix32[M, N]
  Source 
proc exp(m: DMatrix32): DMatrix32 {.raises: [], tags: [].}
  Source 
proc exp[N](v: Vector64[N]): Vector64[N]
  Source 
proc exp(v: DVector64): DVector64 {.raises: [], tags: [].}
  Source 
proc exp[M, N](m: Matrix64[M, N]): Matrix64[M, N]
  Source 
proc exp(m: DMatrix64): DMatrix64 {.raises: [], tags: [].}
  Source 
proc arccos(x: float32): float32 {.raises: [], tags: [].}
  Source 
proc arccos[N](v: Vector32[N]): Vector32[N]
  Source 
proc arccos(v: DVector32): DVector32 {.raises: [], tags: [].}
  Source 
proc arccos[M, N](m: Matrix32[M, N]): Matrix32[M, N]
  Source 
proc arccos(m: DMatrix32): DMatrix32 {.raises: [], tags: [].}
  Source 
proc arccos[N](v: Vector64[N]): Vector64[N]
  Source 
proc arccos(v: DVector64): DVector64 {.raises: [], tags: [].}
  Source 
proc arccos[M, N](m: Matrix64[M, N]): Matrix64[M, N]
  Source 
proc arccos(m: DMatrix64): DMatrix64 {.raises: [], tags: [].}
  Source 
proc arcsin(x: float32): float32 {.raises: [], tags: [].}
  Source 
proc arcsin[N](v: Vector32[N]): Vector32[N]
  Source 
proc arcsin(v: DVector32): DVector32 {.raises: [], tags: [].}
  Source 
proc arcsin[M, N](m: Matrix32[M, N]): Matrix32[M, N]
  Source 
proc arcsin(m: DMatrix32): DMatrix32 {.raises: [], tags: [].}
  Source 
proc arcsin[N](v: Vector64[N]): Vector64[N]
  Source 
proc arcsin(v: DVector64): DVector64 {.raises: [], tags: [].}
  Source 
proc arcsin[M, N](m: Matrix64[M, N]): Matrix64[M, N]
  Source 
proc arcsin(m: DMatrix64): DMatrix64 {.raises: [], tags: [].}
  Source 
proc arctan(x: float32): float32 {.raises: [], tags: [].}
  Source 
proc arctan[N](v: Vector32[N]): Vector32[N]
  Source 
proc arctan(v: DVector32): DVector32 {.raises: [], tags: [].}
  Source 
proc arctan[M, N](m: Matrix32[M, N]): Matrix32[M, N]
  Source 
proc arctan(m: DMatrix32): DMatrix32 {.raises: [], tags: [].}
  Source 
proc arctan[N](v: Vector64[N]): Vector64[N]
  Source 
proc arctan(v: DVector64): DVector64 {.raises: [], tags: [].}
  Source 
proc arctan[M, N](m: Matrix64[M, N]): Matrix64[M, N]
  Source 
proc arctan(m: DMatrix64): DMatrix64 {.raises: [], tags: [].}
  Source 
proc cos(x: float32): float32 {.raises: [], tags: [].}
  Source 
proc cos[N](v: Vector32[N]): Vector32[N]
  Source 
proc cos(v: DVector32): DVector32 {.raises: [], tags: [].}
  Source 
proc cos[M, N](m: Matrix32[M, N]): Matrix32[M, N]
  Source 
proc cos(m: DMatrix32): DMatrix32 {.raises: [], tags: [].}
  Source 
proc cos[N](v: Vector64[N]): Vector64[N]
  Source 
proc cos(v: DVector64): DVector64 {.raises: [], tags: [].}
  Source 
proc cos[M, N](m: Matrix64[M, N]): Matrix64[M, N]
  Source 
proc cos(m: DMatrix64): DMatrix64 {.raises: [], tags: [].}
  Source 
proc cosh(x: float32): float32 {.raises: [], tags: [].}
  Source 
proc cosh[N](v: Vector32[N]): Vector32[N]
  Source 
proc cosh(v: DVector32): DVector32 {.raises: [], tags: [].}
  Source 
proc cosh[M, N](m: Matrix32[M, N]): Matrix32[M, N]
  Source 
proc cosh(m: DMatrix32): DMatrix32 {.raises: [], tags: [].}
  Source 
proc cosh[N](v: Vector64[N]): Vector64[N]
  Source 
proc cosh(v: DVector64): DVector64 {.raises: [], tags: [].}
  Source 
proc cosh[M, N](m: Matrix64[M, N]): Matrix64[M, N]
  Source 
proc cosh(m: DMatrix64): DMatrix64 {.raises: [], tags: [].}
  Source 
proc sin(x: float32): float32 {.raises: [], tags: [].}
  Source 
proc sin[N](v: Vector32[N]): Vector32[N]
  Source 
proc sin(v: DVector32): DVector32 {.raises: [], tags: [].}
  Source 
proc sin[M, N](m: Matrix32[M, N]): Matrix32[M, N]
  Source 
proc sin(m: DMatrix32): DMatrix32 {.raises: [], tags: [].}
  Source 
proc sin[N](v: Vector64[N]): Vector64[N]
  Source 
proc sin(v: DVector64): DVector64 {.raises: [], tags: [].}
  Source 
proc sin[M, N](m: Matrix64[M, N]): Matrix64[M, N]
  Source 
proc sin(m: DMatrix64): DMatrix64 {.raises: [], tags: [].}
  Source 
proc sinh(x: float32): float32 {.raises: [], tags: [].}
  Source 
proc sinh[N](v: Vector32[N]): Vector32[N]
  Source 
proc sinh(v: DVector32): DVector32 {.raises: [], tags: [].}
  Source 
proc sinh[M, N](m: Matrix32[M, N]): Matrix32[M, N]
  Source 
proc sinh(m: DMatrix32): DMatrix32 {.raises: [], tags: [].}
  Source 
proc sinh[N](v: Vector64[N]): Vector64[N]
  Source 
proc sinh(v: DVector64): DVector64 {.raises: [], tags: [].}
  Source 
proc sinh[M, N](m: Matrix64[M, N]): Matrix64[M, N]
  Source 
proc sinh(m: DMatrix64): DMatrix64 {.raises: [], tags: [].}
  Source 
proc tan(x: float32): float32 {.raises: [], tags: [].}
  Source 
proc tan[N](v: Vector32[N]): Vector32[N]
  Source 
proc tan(v: DVector32): DVector32 {.raises: [], tags: [].}
  Source 
proc tan[M, N](m: Matrix32[M, N]): Matrix32[M, N]
  Source 
proc tan(m: DMatrix32): DMatrix32 {.raises: [], tags: [].}
  Source 
proc tan[N](v: Vector64[N]): Vector64[N]
  Source 
proc tan(v: DVector64): DVector64 {.raises: [], tags: [].}
  Source 
proc tan[M, N](m: Matrix64[M, N]): Matrix64[M, N]
  Source 
proc tan(m: DMatrix64): DMatrix64 {.raises: [], tags: [].}
  Source 
proc tanh(x: float32): float32 {.raises: [], tags: [].}
  Source 
proc tanh[N](v: Vector32[N]): Vector32[N]
  Source 
proc tanh(v: DVector32): DVector32 {.raises: [], tags: [].}
  Source 
proc tanh[M, N](m: Matrix32[M, N]): Matrix32[M, N]
  Source 
proc tanh(m: DMatrix32): DMatrix32 {.raises: [], tags: [].}
  Source 
proc tanh[N](v: Vector64[N]): Vector64[N]
  Source 
proc tanh(v: DVector64): DVector64 {.raises: [], tags: [].}
  Source 
proc tanh[M, N](m: Matrix64[M, N]): Matrix64[M, N]
  Source 
proc tanh(m: DMatrix64): DMatrix64 {.raises: [], tags: [].}
  Source 
proc erf(x: float32): float32 {.raises: [], tags: [].}
  Source 
proc erf[N](v: Vector32[N]): Vector32[N]
  Source 
proc erf(v: DVector32): DVector32 {.raises: [], tags: [].}
  Source 
proc erf[M, N](m: Matrix32[M, N]): Matrix32[M, N]
  Source 
proc erf(m: DMatrix32): DMatrix32 {.raises: [], tags: [].}
  Source 
proc erf[N](v: Vector64[N]): Vector64[N]
  Source 
proc erf(v: DVector64): DVector64 {.raises: [], tags: [].}
  Source 
proc erf[M, N](m: Matrix64[M, N]): Matrix64[M, N]
  Source 
proc erf(m: DMatrix64): DMatrix64 {.raises: [], tags: [].}
  Source 
proc erfc(x: float32): float32 {.raises: [], tags: [].}
  Source 
proc erfc[N](v: Vector32[N]): Vector32[N]
  Source 
proc erfc(v: DVector32): DVector32 {.raises: [], tags: [].}
  Source 
proc erfc[M, N](m: Matrix32[M, N]): Matrix32[M, N]
  Source 
proc erfc(m: DMatrix32): DMatrix32 {.raises: [], tags: [].}
  Source 
proc erfc[N](v: Vector64[N]): Vector64[N]
  Source 
proc erfc(v: DVector64): DVector64 {.raises: [], tags: [].}
  Source 
proc erfc[M, N](m: Matrix64[M, N]): Matrix64[M, N]
  Source 
proc erfc(m: DMatrix64): DMatrix64 {.raises: [], tags: [].}
  Source 
proc lgamma(x: float32): float32 {.raises: [], tags: [].}
  Source 
proc lgamma[N](v: Vector32[N]): Vector32[N]
  Source 
proc lgamma(v: DVector32): DVector32 {.raises: [], tags: [].}
  Source 
proc lgamma[M, N](m: Matrix32[M, N]): Matrix32[M, N]
  Source 
proc lgamma(m: DMatrix32): DMatrix32 {.raises: [], tags: [].}
  Source 
proc lgamma[N](v: Vector64[N]): Vector64[N]
  Source 
proc lgamma(v: DVector64): DVector64 {.raises: [], tags: [].}
  Source 
proc lgamma[M, N](m: Matrix64[M, N]): Matrix64[M, N]
  Source 
proc lgamma(m: DMatrix64): DMatrix64 {.raises: [], tags: [].}
  Source 
proc tgamma(x: float32): float32 {.raises: [], tags: [].}
  Source 
proc tgamma[N](v: Vector32[N]): Vector32[N]
  Source 
proc tgamma(v: DVector32): DVector32 {.raises: [], tags: [].}
  Source 
proc tgamma[M, N](m: Matrix32[M, N]): Matrix32[M, N]
  Source 
proc tgamma(m: DMatrix32): DMatrix32 {.raises: [], tags: [].}
  Source 
proc tgamma[N](v: Vector64[N]): Vector64[N]
  Source 
proc tgamma(v: DVector64): DVector64 {.raises: [], tags: [].}
  Source 
proc tgamma[M, N](m: Matrix64[M, N]): Matrix64[M, N]
  Source 
proc tgamma(m: DMatrix64): DMatrix64 {.raises: [], tags: [].}
  Source 
proc trunc(x: float32): float32 {.raises: [], tags: [].}
  Source 
proc trunc[N](v: Vector32[N]): Vector32[N]
  Source 
proc trunc(v: DVector32): DVector32 {.raises: [], tags: [].}
  Source 
proc trunc[M, N](m: Matrix32[M, N]): Matrix32[M, N]
  Source 
proc trunc(m: DMatrix32): DMatrix32 {.raises: [], tags: [].}
  Source 
proc trunc[N](v: Vector64[N]): Vector64[N]
  Source 
proc trunc(v: DVector64): DVector64 {.raises: [], tags: [].}
  Source 
proc trunc[M, N](m: Matrix64[M, N]): Matrix64[M, N]
  Source 
proc trunc(m: DMatrix64): DMatrix64 {.raises: [], tags: [].}
  Source 
proc floor(x: float32): float32 {.raises: [], tags: [].}
  Source 
proc floor[N](v: Vector32[N]): Vector32[N]
  Source 
proc floor(v: DVector32): DVector32 {.raises: [], tags: [].}
  Source 
proc floor[M, N](m: Matrix32[M, N]): Matrix32[M, N]
  Source 
proc floor(m: DMatrix32): DMatrix32 {.raises: [], tags: [].}
  Source 
proc floor[N](v: Vector64[N]): Vector64[N]
  Source 
proc floor(v: DVector64): DVector64 {.raises: [], tags: [].}
  Source 
proc floor[M, N](m: Matrix64[M, N]): Matrix64[M, N]
  Source 
proc floor(m: DMatrix64): DMatrix64 {.raises: [], tags: [].}
  Source 
proc ceil(x: float32): float32 {.raises: [], tags: [].}
  Source 
proc ceil[N](v: Vector32[N]): Vector32[N]
  Source 
proc ceil(v: DVector32): DVector32 {.raises: [], tags: [].}
  Source 
proc ceil[M, N](m: Matrix32[M, N]): Matrix32[M, N]
  Source 
proc ceil(m: DMatrix32): DMatrix32 {.raises: [], tags: [].}
  Source 
proc ceil[N](v: Vector64[N]): Vector64[N]
  Source 
proc ceil(v: DVector64): DVector64 {.raises: [], tags: [].}
  Source 
proc ceil[M, N](m: Matrix64[M, N]): Matrix64[M, N]
  Source 
proc ceil(m: DMatrix64): DMatrix64 {.raises: [], tags: [].}
  Source 
proc degToRad(x: float32): float32 {.raises: [], tags: [].}
  Source 
proc degToRad[N](v: Vector32[N]): Vector32[N]
  Source 
proc degToRad(v: DVector32): DVector32 {.raises: [], tags: [].}
  Source 
proc degToRad[M, N](m: Matrix32[M, N]): Matrix32[M, N]
  Source 
proc degToRad(m: DMatrix32): DMatrix32 {.raises: [], tags: [].}
  Source 
proc degToRad[N](v: Vector64[N]): Vector64[N]
  Source 
proc degToRad(v: DVector64): DVector64 {.raises: [], tags: [].}
  Source 
proc degToRad[M, N](m: Matrix64[M, N]): Matrix64[M, N]
  Source 
proc degToRad(m: DMatrix64): DMatrix64 {.raises: [], tags: [].}
  Source 
proc radToDeg(x: float32): float32 {.raises: [], tags: [].}
  Source 
proc radToDeg[N](v: Vector32[N]): Vector32[N]
  Source 
proc radToDeg(v: DVector32): DVector32 {.raises: [], tags: [].}
  Source 
proc radToDeg[M, N](m: Matrix32[M, N]): Matrix32[M, N]
  Source 
proc radToDeg(m: DMatrix32): DMatrix32 {.raises: [], tags: [].}
  Source 
proc radToDeg[N](v: Vector64[N]): Vector64[N]
  Source 
proc radToDeg(v: DVector64): DVector64 {.raises: [], tags: [].}
  Source 
proc radToDeg[M, N](m: Matrix64[M, N]): Matrix64[M, N]
  Source 
proc radToDeg(m: DMatrix64): DMatrix64 {.raises: [], tags: [].}
  Source

Iterators

iterator items[N, ](v: Vector32[N] or Vector64[N]): auto {.inline.}
  Source 
iterator pairs[N, ](v: Vector32[N] or Vector64[N]): auto {.inline.}
  Source 
iterator columns[M, N, ](m: Matrix32[M, N] or Matrix64[M, N]): auto {.inline.}
  Source 
iterator columns[](m: DMatrix32 or DMatrix64): auto {.inline.}
  Source 
iterator rows[M, N, ](m: Matrix32[M, N] or Matrix64[M, N]): auto {.inline.}
  Source 
iterator rows[](m: DMatrix32 or DMatrix64): auto {.inline.}
  Source 
iterator items[M, N, ](m: Matrix32[M, N] or Matrix64[M, N]): auto {.inline.}
  Source 
iterator items[](m: DMatrix32 or DMatrix64): auto {.inline.}
  Source 
iterator pairs[M, N, ](m: Matrix32[M, N] or Matrix64[M, N]): auto {.inline.}
  Source 
iterator pairs[](m: DMatrix32 or DMatrix64): auto {.inline.}
  Source

Templates

template `*`[](k: float32;
              v: CudaVector32 or CudaMatrix32 or CudaDVector32 or CudaDMatrix32): expr
  Source 
template `*`[](k: float64;
              v: CudaVector64 or CudaMatrix64 or CudaDVector64 or CudaDMatrix64): expr
  Source 
template `/`[](v: CudaVector32 or CudaMatrix32 or CudaDVector32 or CudaDMatrix32;
              k: float32): expr
  Source 
template `/`[](v: CudaVector64 or CudaMatrix64 or CudaDVector64 or CudaDMatrix64;
              k: float64): expr
  Source 
template `/=`[](v: var CudaVector32 or var CudaMatrix32 or var CudaDVector32 or
    var CudaDMatrix32; k: float32): expr
  Source 
template `/=`[](v: var CudaVector64 or var CudaMatrix64 or var CudaDVector64 or
    var CudaDMatrix64; k: float64): expr
  Source 
template `!=~`[AnyCuda](a, b: AnyCuda): bool
  Source 
template `[]`[](m: Matrix64 or DMatrix64; i, j: int): float64
  Source 
template `[]`[](m: Matrix32 or DMatrix32; i, j: int): float32
  Source 
template max[](v: Vector32 or Vector64): auto
  Source 
template min[](v: Vector32 or Vector64): auto
  Source 
template `*`[](k: float32; v: Vector32 or Matrix32 or DVector32 or DMatrix32): expr
  Source 
template `/`[](v: Vector32 or Matrix32 or DVector32 or DMatrix32; k: float32): expr
  Source 
template `/=`[](v: var Vector32 or var Matrix32 or var DVector32 or var DMatrix32; k: float32): expr
  Source 
template `*`[](k: float64; v: Vector64 or Matrix64 or DVector64 or DMatrix64): expr
  Source 
template `/`[](v: Vector64 or Matrix64 or DVector64 or DMatrix64; k: float64): expr
  Source 
template `/=`[](v: var Vector64 or var Matrix64 or var DVector64 or var DMatrix64; k: float64): expr
  Source 
template max[](m: Matrix32 or Matrix64 or DMatrix32 or DMatrix64): auto
  Source 
template min[](m: Matrix32 or Matrix64 or DMatrix32 or DMatrix64): auto
  Source 
template `=~`[N](v, w: Vector32[N]): bool
  Source 
template `=~`[N](v, w: Vector64[N]): bool
  Source 
template `=~`(v, w: DVector32): bool
  Source 
template `=~`(v, w: DVector64): bool
  Source 
template `=~`(v, w: DMatrix32): bool
  Source 
template `=~`(v, w: DMatrix64): bool
  Source 
template `!=~`[](a, b: Vector32 or Vector64 or DVector32 or DVector64 or Matrix32 or
    Matrix64 or DMatrix32 or DMatrix64): bool
  Source 
template makeUniversal(fname: expr)
  Source 
template makeUniversalLocal(fname: expr)
  Source 
template rewriteLinearCombination{v + *(w, a)
}[Vector64](a: float64; v, w: Vector64): auto
  Source 
template rewriteLinearCombinationMut{v += *(w, a)
}[Vector64](a: float64; v: var Vector64; w: Vector64): auto
  Source 
template rewriteLinearCombination{v + *(w, a)
}[Vector32](a: float32; v, w: Vector32): auto
  Source 
template rewriteLinearCombinationMut{v += *(w, a)
}[Vector32](a: float32; v: var Vector32; w: Vector32): auto
  Source

Made with Nim. Generated: 2016-05-26 12:12:50 UTC