bend-blas-lapack

Search uses release 0.0.0.1 · 107 definitions

Releases (1)

0.0.0.1 indexed

Definitions (107)

blas.bend

def Blas.sgemmC = alpha op(A) op(B) + beta C.
def Blas.sgemm.try
def Blas.sgemvy = alpha op(A) x + beta y.
def Blas.sgemv.try
def Blas.sgerA = alpha x y^T + A, the rank-1 update; A is m x n, x has m elements, y has n.
def Blas.sger.try
def Blas.sdotThe dot product of the first n elements of x and y.
def Blas.sdot.try
def Blas.snrm2The Euclidean norm of the first n elements of x.
def Blas.snrm2.try
def Blas.sasumThe sum of the absolute values of the first n elements of x.
def Blas.sasum.try
def Blas.isamaxThe index (from 0) of the element of largest absolute value among the first n of x.
def Blas.isamax.try
def Blas.saxpyy = alpha x + y over the first n elements; y is consumed and the updated copy answered.
def Blas.saxpy.try
def Blas.sscalx = alpha x over the first n elements; x is consumed and the scaled copy answered.
def Blas.sscal.try

cublas.bend

def Cublas.availableTrue when cuBLAS opens on this machine: the answer of every other routine is Fail{(1, ..)} otherwise.
def Cublas.available.try
def Cublas.uploadThe first n floats of an array copied to the device; answers the buffer id.
def Cublas.upload.try
def Cublas.downloadThe n floats of a device buffer back in a fresh array; the buffer stays.
def Cublas.download.try
def Cublas.freeFrees a device buffer; its id is dead after.
def Cublas.free.try
def Cublas.sgemmC = alpha op(A) op(B) + beta C on the GPU, the operands copied to the device for the call and the result back; the same arguments as Blas.sgemm.
def Cublas.sgemm.try
def Cublas.sgemm_wCublas.sgemm with the right operand a device buffer (uploaded once with Cublas.upload, never consumed): the shape of a model's weights.
def Cublas.sgemm_w.try

lapack.bend

def Lapack.sgesvX = A^-1 B: A is n x n, B is n x nrhs, both row-major, both consumed; answers X (n x nrhs).
def Lapack.sgesv.try
def Lapack.spotrfThe Cholesky factor of a symmetric positive definite n x n matrix: answers L, row-major, lower triangular with zeros above, A = L L^T.
def Lapack.spotrf.try
def Lapack.spotrsX = A^-1 B given the Cholesky factor L of A from spotrf (n x n, lower, row-major) and B (n x nrhs, row-major); both consumed, answers X.
def Lapack.spotrs.try
def Lapack.sgesvd_sThe singular values of an m x n row-major matrix (consumed), largest first, min(m, n) of them.
def Lapack.sgesvd_s.try
def Lapack.sgesvdThe thin SVD of an m x n row-major matrix (consumed): answers (s, (u, vt)) with s the min(m, n) singular values largest first, u m x k and vt k x n row-major, A = u diag(s) vt.
def Lapack.sgesvd.try
def Lapack.ssyevThe eigenvalues and eigenvectors of a symmetric n x n row-major matrix (consumed, its lower triangle read): answers (w, v) with w the n eigenvalues ascending and v n x n row-major, row i the unit eigenvector of w[i].
def Lapack.ssyev.try

mat.bend

type Mat
type Vec
def depth.gothe depth of the smallest power-of-two block holding count floats
def depth
def fill.go
def array.ofan array of the smallest power-of-two size holding count floats, the first ones from xs (cut or padded with 0.0), the rest 0.0
def take.go
def list.ofthe first count floats of an array, as a list
def rows.ofxs cut into rows of cols
def F32.show.of
def row.show
def Mat.from_listrows * cols floats, row-major, cut or padded with 0.0
def Mat.zeros
def Mat.to_list
def Mat.to_rows
def Mat.show
def Mat.clone.fin
def Mat.clonea Mat is affine: two copies, to be opened by matching in a def of its own
def Vec.from_list
def Vec.zeros
def Vec.to_list
def Vec.show
def Vec.clone.fin
def Vec.clone
def Mat.wrapthe raw answers, shaped
def Vec.wrap
def Mat.gemmC = alpha A B + beta C
def Mat.gemm.try
def Mat.gemm_tC = alpha A B^T + beta C, B stored cols x k
def Mat.gemm_t.try
def Mat.gemm_tnC = alpha A^T B + beta C, A stored k x rows
def Mat.gemm_tn.try
def Mat.gemvy = alpha A x + beta y
def Mat.gemv.try
def Mat.gemv_ty = alpha A^T x + beta y
def Mat.gemv_t.try
def Mat.gerA = alpha x y^T + A
def Mat.ger.try
def Vec.dot
def Vec.dot.try
def Vec.nrm2
def Vec.nrm2.try
def Vec.asum
def Vec.asum.try
def Vec.iamax
def Vec.iamax.try
def Vec.axpyy = alpha x + y
def Vec.axpy.try
def Vec.scal
def Vec.scal.try
def Mat.solveX = A^-1 B; Fail with the zero pivot as the code when A is singular
def Mat.solve.try
def Mat.choleskythe lower Cholesky factor L of a symmetric positive definite A
def Mat.cholesky.try
def Mat.cholesky_solveX = A^-1 B given L from Mat.cholesky
def Mat.cholesky_solve.try
def Mat.svd_valuesthe singular values, largest first
def Mat.svd_values.try