CudaVector[A] = object
  data*: ref [ptr A]
  fp*: ptr A
  len, step*: int32

CudaMatrix[A] = object
  M*, N*, ld*: int32
  data*: ref [ptr A]
  fp*: ptr A
  shape*: set[MatrixShape]

proc isContiguous(v: CudaVector): bool {...}{.inline.}

proc isContiguous(m: CudaMatrix): bool {...}{.inline.}

proc newCudaVector[A](n: int): CudaVector[A] {...}{.inline.}

proc newCudaMatrix[A](m, n: int): CudaMatrix[A] {...}{.inline.}

proc gpu[A](v: Vector[A]): CudaVector[A]

proc gpu[A](m: Matrix[A]): CudaMatrix[A]

proc cpu[A](v: CudaVector[A]): Vector[A]

proc cpu[A](m: CudaMatrix[A]): Matrix[A]

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

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

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

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

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

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

proc `[]`[A](v: CudaVector[A]; s: Slice[int]): CudaVector[A]

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

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

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

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

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

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

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

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

proc asMatrix[A](v: CudaVector[A]; a, b: int): CudaMatrix[A]

proc asVector[A](m: CudaMatrix[A]): CudaVector[A]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template init[A](v: CudaVector[A]; n: int)

template init[A](v: CudaMatrix[A]; m, n: int)

template `*`[A; ](k: A; v: CudaVector[A] or CudaMatrix[A]): auto

template `/`[A; ](v: CudaVector[A] or CudaMatrix[A]; k: A): auto

template `/=`[A; ](v: var CudaVector[A] or var CudaMatrix[A]; k: A)

template `!=~`(a, b: CudaVector or CudaMatrix): bool