bend-blas-lapack Releases (1): 0.0.0.1 0xf090bec5d73bd2d01f26c93f586673b1 indexed https://jend.leeeet.dev/files.txt?path=bend-blas-lapack@0.0.0.1 Definitions (107, 1 to 100 shown): Blas.Blas.sgemm (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/blas.bend&name=Blas.sgemm) # C = alpha op(A) op(B) + beta C. A is m x k as stored (k x m when ta = 1), # B is k x n (n x k when tb = 1), C is m x n, all row-major. C is consumed # and the updated copy answered; pass beta = 0 and any m x n block for a # fresh product. def Blas.sgemm(ta: U32, tb: U32, m: U32, n: U32, k: U32, alpha: F32, a: Array, b: Array, beta: F32, c: Array) -> IO(Result<&1, &1, U32 & String, Array>): Blas.Blas.sgemm.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/blas.bend&name=Blas.sgemm.try) def Blas.sgemm.try(ta: U32, tb: U32, m: U32, n: U32, k: U32, alpha: F32, a: Array, b: Array, beta: F32, c: Array) -> IO(Array): Blas.Blas.sgemv (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/blas.bend&name=Blas.sgemv) # y = alpha op(A) x + beta y. A is m x n as stored, row-major; ta = 1 # applies A^T, so x has n elements (m when ta) and y has m (n when ta). # y is consumed and the updated copy answered. def Blas.sgemv(ta: U32, m: U32, n: U32, alpha: F32, a: Array, x: Array, beta: F32, y: Array) -> IO(Result<&1, &1, U32 & String, Array>): Blas.Blas.sgemv.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/blas.bend&name=Blas.sgemv.try) def Blas.sgemv.try(ta: U32, m: U32, n: U32, alpha: F32, a: Array, x: Array, beta: F32, y: Array) -> IO(Array): Blas.Blas.sger (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/blas.bend&name=Blas.sger) # A = alpha x y^T + A, the rank-1 update; A is m x n, x has m elements, # y has n. A is consumed and the updated copy answered. def Blas.sger(m: U32, n: U32, alpha: F32, x: Array, y: Array, a: Array) -> IO(Result<&1, &1, U32 & String, Array>): Blas.Blas.sger.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/blas.bend&name=Blas.sger.try) def Blas.sger.try(m: U32, n: U32, alpha: F32, x: Array, y: Array, a: Array) -> IO(Array): Blas.Blas.sdot (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/blas.bend&name=Blas.sdot) # The dot product of the first n elements of x and y. def Blas.sdot(n: U32, x: Array, y: Array) -> IO(Result<&1, &1, U32 & String, F32>): Blas.Blas.sdot.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/blas.bend&name=Blas.sdot.try) def Blas.sdot.try(n: U32, x: Array, y: Array) -> IO(F32): Blas.Blas.snrm2 (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/blas.bend&name=Blas.snrm2) # The Euclidean norm of the first n elements of x. def Blas.snrm2(n: U32, x: Array) -> IO(Result<&1, &1, U32 & String, F32>): Blas.Blas.snrm2.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/blas.bend&name=Blas.snrm2.try) def Blas.snrm2.try(n: U32, x: Array) -> IO(F32): Blas.Blas.sasum (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/blas.bend&name=Blas.sasum) # The sum of the absolute values of the first n elements of x. def Blas.sasum(n: U32, x: Array) -> IO(Result<&1, &1, U32 & String, F32>): Blas.Blas.sasum.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/blas.bend&name=Blas.sasum.try) def Blas.sasum.try(n: U32, x: Array) -> IO(F32): Blas.Blas.isamax (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/blas.bend&name=Blas.isamax) # The index (from 0) of the element of largest absolute value among the first n of x. def Blas.isamax(n: U32, x: Array) -> IO(Result<&1, &1, U32 & String, U32>): Blas.Blas.isamax.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/blas.bend&name=Blas.isamax.try) def Blas.isamax.try(n: U32, x: Array) -> IO(U32): Blas.Blas.saxpy (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/blas.bend&name=Blas.saxpy) # y = alpha x + y over the first n elements; y is consumed and the updated copy answered. def Blas.saxpy(n: U32, alpha: F32, x: Array, y: Array) -> IO(Result<&1, &1, U32 & String, Array>): Blas.Blas.saxpy.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/blas.bend&name=Blas.saxpy.try) def Blas.saxpy.try(n: U32, alpha: F32, x: Array, y: Array) -> IO(Array): Blas.Blas.sscal (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/blas.bend&name=Blas.sscal) # x = alpha x over the first n elements; x is consumed and the scaled copy answered. def Blas.sscal(n: U32, alpha: F32, x: Array) -> IO(Result<&1, &1, U32 & String, Array>): Blas.Blas.sscal.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/blas.bend&name=Blas.sscal.try) def Blas.sscal.try(n: U32, alpha: F32, x: Array) -> IO(Array): Cublas.Cublas.available (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/cublas.bend&name=Cublas.available) # True when cuBLAS opens on this machine: the answer of every other routine is Fail{(1, ..)} otherwise. Never fails. def Cublas.available() -> IO(Result<&1, &1, U32 & String, Bool>): Cublas.Cublas.available.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/cublas.bend&name=Cublas.available.try) def Cublas.available.try() -> IO(Bool): Cublas.Cublas.upload (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/cublas.bend&name=Cublas.upload) # The first n floats of an array copied to the device; answers the buffer id. The array is consumed. def Cublas.upload(n: U32, a: Array) -> IO(Result<&1, &1, U32 & String, U32>): Cublas.Cublas.upload.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/cublas.bend&name=Cublas.upload.try) def Cublas.upload.try(n: U32, a: Array) -> IO(U32): Cublas.Cublas.download (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/cublas.bend&name=Cublas.download) # The n floats of a device buffer back in a fresh array; the buffer stays. def Cublas.download(id: U32) -> IO(Result<&1, &1, U32 & String, Array>): Cublas.Cublas.download.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/cublas.bend&name=Cublas.download.try) def Cublas.download.try(id: U32) -> IO(Array): Cublas.Cublas.free (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/cublas.bend&name=Cublas.free) # Frees a device buffer; its id is dead after. def Cublas.free(id: U32) -> IO(Result<&1, &1, U32 & String, Unit>): Cublas.Cublas.free.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/cublas.bend&name=Cublas.free.try) def Cublas.free.try(id: U32) -> IO(Unit): Cublas.Cublas.sgemm (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/cublas.bend&name=Cublas.sgemm) # C = 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(ta: U32, tb: U32, m: U32, n: U32, k: U32, alpha: F32, a: Array, b: Array, beta: F32, c: Array) -> IO(Result<&1, &1, U32 & String, Array>): Cublas.Cublas.sgemm.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/cublas.bend&name=Cublas.sgemm.try) def Cublas.sgemm.try(ta: U32, tb: U32, m: U32, n: U32, k: U32, alpha: F32, a: Array, b: Array, beta: F32, c: Array) -> IO(Array): Cublas.Cublas.sgemm_w (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/cublas.bend&name=Cublas.sgemm_w) # Cublas.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(ta: U32, tb: U32, m: U32, n: U32, k: U32, alpha: F32, a: Array, b: U32, beta: F32, c: Array) -> IO(Result<&1, &1, U32 & String, Array>): Cublas.Cublas.sgemm_w.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/cublas.bend&name=Cublas.sgemm_w.try) def Cublas.sgemm_w.try(ta: U32, tb: U32, m: U32, n: U32, k: U32, alpha: F32, a: Array, b: U32, beta: F32, c: Array) -> IO(Array): Lapack.Lapack.sgesv (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/lapack.bend&name=Lapack.sgesv) # X = A^-1 B: A is n x n, B is n x nrhs, both row-major, both consumed; # answers X (n x nrhs). Fails with code i when U(i, i) of the LU # factorization is exactly zero (A singular). def Lapack.sgesv(n: U32, nrhs: U32, a: Array, b: Array) -> IO(Result<&1, &1, U32 & String, Array>): Lapack.Lapack.sgesv.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/lapack.bend&name=Lapack.sgesv.try) def Lapack.sgesv.try(n: U32, nrhs: U32, a: Array, b: Array) -> IO(Array): Lapack.Lapack.spotrf (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/lapack.bend&name=Lapack.spotrf) # The Cholesky factor of a symmetric positive definite n x n matrix: # answers L, row-major, lower triangular with zeros above, A = L L^T. # Fails with code i when the leading minor of order i is not positive. def Lapack.spotrf(n: U32, a: Array) -> IO(Result<&1, &1, U32 & String, Array>): Lapack.Lapack.spotrf.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/lapack.bend&name=Lapack.spotrf.try) def Lapack.spotrf.try(n: U32, a: Array) -> IO(Array): Lapack.Lapack.spotrs (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/lapack.bend&name=Lapack.spotrs) # X = 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(n: U32, nrhs: U32, l: Array, b: Array) -> IO(Result<&1, &1, U32 & String, Array>): Lapack.Lapack.spotrs.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/lapack.bend&name=Lapack.spotrs.try) def Lapack.spotrs.try(n: U32, nrhs: U32, l: Array, b: Array) -> IO(Array): Lapack.Lapack.sgesvd_s (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/lapack.bend&name=Lapack.sgesvd_s) # The singular values of an m x n row-major matrix (consumed), largest # first, min(m, n) of them. def Lapack.sgesvd_s(m: U32, n: U32, a: Array) -> IO(Result<&1, &1, U32 & String, Array>): Lapack.Lapack.sgesvd_s.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/lapack.bend&name=Lapack.sgesvd_s.try) def Lapack.sgesvd_s.try(m: U32, n: U32, a: Array) -> IO(Array): Lapack.Lapack.sgesvd (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/lapack.bend&name=Lapack.sgesvd) # The 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(m: U32, n: U32, a: Array) -> IO(Result<&1, &1, U32 & String, Array & (Array & Array)>): Lapack.Lapack.sgesvd.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/lapack.bend&name=Lapack.sgesvd.try) def Lapack.sgesvd.try(m: U32, n: U32, a: Array) -> IO(Array & (Array & Array)): Lapack.Lapack.ssyev (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/lapack.bend&name=Lapack.ssyev) # The 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(n: U32, a: Array) -> IO(Result<&1, &1, U32 & String, Array & Array>): Lapack.Lapack.ssyev.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/lapack.bend&name=Lapack.ssyev.try) def Lapack.ssyev.try(n: U32, a: Array) -> IO(Array & Array): Mat.Mat (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Mat) type Mat<-rows: Nat, -cols: Nat> is Type: MatA{a: Array} Mat.Vec (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Vec) type Vec<-n: Nat> is Type: VecA{a: Array} Mat.depth.go (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=depth.go) # the depth of the smallest power-of-two block holding count floats def depth.go(fuel: Nat, +n: U32, +d: Nat, +cap: U32) -> Nat: Mat.depth (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=depth) def depth(+count: Nat) -> Nat: Mat.fill.go (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=fill.go) def fill.go(xs: List<&2, F32>, +i: U32, a: Array) -> Array: Mat.array.of (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=array.of) # an 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 array.of(+count: Nat, xs: List<&2, F32>) -> Array: Mat.take.go (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=take.go) def take.go(n: Nat, +i: U32, r: Array & F32, acc: List<&2, F32>) -> List<&2, F32>: Mat.list.of (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=list.of) # the first count floats of an array, as a list def list.of(+count: Nat, a: Array) -> List<&2, F32>: Mat.rows.of (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=rows.of) # xs cut into rows of cols def rows.of(rows: Nat, +cols: Nat, +xs: List<&2, F32>) -> List<&2, List<&2, F32>>: Mat.F32.show.of (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=F32.show.of) def F32.show.of(x: F32) -> String: Mat.row.show (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=row.show) def row.show(xs: List<&2, F32>) -> String: Mat.Mat.from_list (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Mat.from_list) # rows * cols floats, row-major, cut or padded with 0.0 def Mat.from_list(+rows: Nat, +cols: Nat, xs: List<&2, F32>) -> Mat: Mat.Mat.zeros (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Mat.zeros) def Mat.zeros(+rows: Nat, +cols: Nat) -> Mat: Mat.Mat.to_list (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Mat.to_list) def Mat.to_list(+rows: Nat, +cols: Nat, m: Mat) -> List<&2, F32>: Mat.Mat.to_rows (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Mat.to_rows) def Mat.to_rows(+rows: Nat, +cols: Nat, m: Mat) -> List<&2, List<&2, F32>>: Mat.Mat.show (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Mat.show) def Mat.show(+rows: Nat, +cols: Nat, m: Mat) -> String: Mat.Mat.clone.fin (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Mat.clone.fin) def Mat.clone.fin(-rows: Nat, -cols: Nat, r: Array & Array) -> Mat & Mat: Mat.Mat.clone (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Mat.clone) # a Mat is affine: two copies, to be opened by matching in a def of its own def Mat.clone(+rows: Nat, +cols: Nat, m: Mat) -> Mat & Mat: Mat.Vec.from_list (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Vec.from_list) def Vec.from_list(+n: Nat, xs: List<&2, F32>) -> Vec: Mat.Vec.zeros (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Vec.zeros) def Vec.zeros(+n: Nat) -> Vec: Mat.Vec.to_list (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Vec.to_list) def Vec.to_list(+n: Nat, v: Vec) -> List<&2, F32>: Mat.Vec.show (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Vec.show) def Vec.show(+n: Nat, v: Vec) -> String: Mat.Vec.clone.fin (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Vec.clone.fin) def Vec.clone.fin(-n: Nat, r: Array & Array) -> Vec & Vec: Mat.Vec.clone (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Vec.clone) def Vec.clone(+n: Nat, v: Vec) -> Vec & Vec: Mat.Mat.wrap (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Mat.wrap) # the raw answers, shaped def Mat.wrap(-rows: Nat, -cols: Nat, r: Result<&1, &1, U32 & String, Array>) -> IO(Result<&1, &1, U32 & String, Mat>): Mat.Vec.wrap (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Vec.wrap) def Vec.wrap(-n: Nat, r: Result<&1, &1, U32 & String, Array>) -> IO(Result<&1, &1, U32 & String, Vec>): Mat.Mat.gemm (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Mat.gemm) # C = alpha A B + beta C def Mat.gemm(+rows: Nat, +k: Nat, +cols: Nat, alpha: F32, a: Mat, b: Mat, beta: F32, c: Mat) -> IO(Result<&1, &1, U32 & String, Mat>): Mat.Mat.gemm.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Mat.gemm.try) def Mat.gemm.try(+rows: Nat, +k: Nat, +cols: Nat, alpha: F32, a: Mat, b: Mat, beta: F32, c: Mat) -> IO(Mat): Mat.Mat.gemm_t (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Mat.gemm_t) # C = alpha A B^T + beta C, B stored cols x k def Mat.gemm_t(+rows: Nat, +k: Nat, +cols: Nat, alpha: F32, a: Mat, b: Mat, beta: F32, c: Mat) -> IO(Result<&1, &1, U32 & String, Mat>): Mat.Mat.gemm_t.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Mat.gemm_t.try) def Mat.gemm_t.try(+rows: Nat, +k: Nat, +cols: Nat, alpha: F32, a: Mat, b: Mat, beta: F32, c: Mat) -> IO(Mat): Mat.Mat.gemm_tn (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Mat.gemm_tn) # C = alpha A^T B + beta C, A stored k x rows def Mat.gemm_tn(+rows: Nat, +k: Nat, +cols: Nat, alpha: F32, a: Mat, b: Mat, beta: F32, c: Mat) -> IO(Result<&1, &1, U32 & String, Mat>): Mat.Mat.gemm_tn.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Mat.gemm_tn.try) def Mat.gemm_tn.try(+rows: Nat, +k: Nat, +cols: Nat, alpha: F32, a: Mat, b: Mat, beta: F32, c: Mat) -> IO(Mat): Mat.Mat.gemv (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Mat.gemv) # y = alpha A x + beta y def Mat.gemv(+rows: Nat, +cols: Nat, alpha: F32, a: Mat, x: Vec, beta: F32, y: Vec) -> IO(Result<&1, &1, U32 & String, Vec>): Mat.Mat.gemv.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Mat.gemv.try) def Mat.gemv.try(+rows: Nat, +cols: Nat, alpha: F32, a: Mat, x: Vec, beta: F32, y: Vec) -> IO(Vec): Mat.Mat.gemv_t (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Mat.gemv_t) # y = alpha A^T x + beta y def Mat.gemv_t(+rows: Nat, +cols: Nat, alpha: F32, a: Mat, x: Vec, beta: F32, y: Vec) -> IO(Result<&1, &1, U32 & String, Vec>): Mat.Mat.gemv_t.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Mat.gemv_t.try) def Mat.gemv_t.try(+rows: Nat, +cols: Nat, alpha: F32, a: Mat, x: Vec, beta: F32, y: Vec) -> IO(Vec): Mat.Mat.ger (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Mat.ger) # A = alpha x y^T + A def Mat.ger(+rows: Nat, +cols: Nat, alpha: F32, x: Vec, y: Vec, a: Mat) -> IO(Result<&1, &1, U32 & String, Mat>): Mat.Mat.ger.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Mat.ger.try) def Mat.ger.try(+rows: Nat, +cols: Nat, alpha: F32, x: Vec, y: Vec, a: Mat) -> IO(Mat): Mat.Vec.dot (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Vec.dot) def Vec.dot(+n: Nat, x: Vec, y: Vec) -> IO(Result<&1, &1, U32 & String, F32>): Mat.Vec.dot.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Vec.dot.try) def Vec.dot.try(+n: Nat, x: Vec, y: Vec) -> IO(F32): Mat.Vec.nrm2 (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Vec.nrm2) def Vec.nrm2(+n: Nat, x: Vec) -> IO(Result<&1, &1, U32 & String, F32>): Mat.Vec.nrm2.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Vec.nrm2.try) def Vec.nrm2.try(+n: Nat, x: Vec) -> IO(F32): Mat.Vec.asum (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Vec.asum) def Vec.asum(+n: Nat, x: Vec) -> IO(Result<&1, &1, U32 & String, F32>): Mat.Vec.asum.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Vec.asum.try) def Vec.asum.try(+n: Nat, x: Vec) -> IO(F32): Mat.Vec.iamax (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Vec.iamax) def Vec.iamax(+n: Nat, x: Vec) -> IO(Result<&1, &1, U32 & String, U32>): Mat.Vec.iamax.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Vec.iamax.try) def Vec.iamax.try(+n: Nat, x: Vec) -> IO(U32): Mat.Vec.axpy (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Vec.axpy) # y = alpha x + y def Vec.axpy(+n: Nat, alpha: F32, x: Vec, y: Vec) -> IO(Result<&1, &1, U32 & String, Vec>): Mat.Vec.axpy.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Vec.axpy.try) def Vec.axpy.try(+n: Nat, alpha: F32, x: Vec, y: Vec) -> IO(Vec): Mat.Vec.scal (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Vec.scal) def Vec.scal(+n: Nat, alpha: F32, x: Vec) -> IO(Result<&1, &1, U32 & String, Vec>): Mat.Vec.scal.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Vec.scal.try) def Vec.scal.try(+n: Nat, alpha: F32, x: Vec) -> IO(Vec): Mat.Mat.solve (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Mat.solve) # X = A^-1 B; Fail with the zero pivot as the code when A is singular def Mat.solve(+n: Nat, +nrhs: Nat, a: Mat, b: Mat) -> IO(Result<&1, &1, U32 & String, Mat>): Mat.Mat.solve.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Mat.solve.try) def Mat.solve.try(+n: Nat, +nrhs: Nat, a: Mat, b: Mat) -> IO(Mat): Mat.Mat.cholesky (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Mat.cholesky) # the lower Cholesky factor L of a symmetric positive definite A def Mat.cholesky(+n: Nat, a: Mat) -> IO(Result<&1, &1, U32 & String, Mat>): Mat.Mat.cholesky.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Mat.cholesky.try) def Mat.cholesky.try(+n: Nat, a: Mat) -> IO(Mat): Mat.Mat.cholesky_solve (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Mat.cholesky_solve) # X = A^-1 B given L from Mat.cholesky def Mat.cholesky_solve(+n: Nat, +nrhs: Nat, l: Mat, b: Mat) -> IO(Result<&1, &1, U32 & String, Mat>): Mat.Mat.cholesky_solve.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Mat.cholesky_solve.try) def Mat.cholesky_solve.try(+n: Nat, +nrhs: Nat, l: Mat, b: Mat) -> IO(Mat): Mat.Mat.svd_values (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Mat.svd_values) # the singular values, largest first def Mat.svd_values(+m: Nat, +n: Nat, a: Mat) -> IO(Result<&1, &1, U32 & String, Vec>): Mat.Mat.svd_values.try (https://jend.leeeet.dev/definition.txt?path=bend-blas-lapack@0.0.0.1/mat.bend&name=Mat.svd_values.try) def Mat.svd_values.try(+m: Nat, +n: Nat, a: Mat) -> IO(Vec): More: https://jend.leeeet.dev/packages/bend-blas-lapack.txt?definitions_offset=100