bend-ml-tensor-array

Search uses release 0.1.19.0 · 321 definitions

Releases (20)

0.1.19.0 indexed
0.1.18.0 unindexed
0.1.17.0 unindexed
0.1.16.0 unindexed
0.1.15.0 unindexed
0.1.14.0 unindexed
0.1.13.0 unindexed
0.1.12.0 unindexed
0.1.11.0 unindexed
0.1.10.0 unindexed
0.1.9.0 unindexed
0.1.8.0 unindexed
0.1.7.0 unindexed
0.1.6.0 unindexed
0.1.5.0 unindexed
0.1.4.0 unindexed
0.1.3.0 unindexed
0.1.2.0 unindexed
0.1.1.0 unindexed
0.1.0.0 unindexed

Definitions (321)

main.bend

def Mat.zeros
def Mat.fill
def fill_list
def len_is
def Mat.of_list2
def Mat.of_list
def Mat.from_list
def Mat.fill_atwrites the numbers of xs into m starting at flat index i (row-major); numbers past the capacity are dropped.
type ML
def Mat.to_list2
def ML.len
def Mat.to_list_countn numbers from index 0, in row order; n = 0 gives the empty list (a Mat with no numbers)
def Mat.to_list
type MM2
def Mat.clone2
def Mat.clone
type MMul
type MMulNT
type MMulTN
type T8
def t8_zero
def pick0
type PK
def pk_g7one cell: the 8 numbers of a at idx, idx + st, ..., those at positions q0 + q >= lim (past the end of the line) as 0
def pk_g6
def pk_g5
def pk_g4
def pk_g3
def pk_g2
def pk_g1
def pk_g0
def pk_linethe cells of one line, cell o..
def pk_lineslines count lines; source line i starts at i * lstep (in a), and goes to cell row o (cells o * tku ..
def pk_pack
def t8_dotthe dot of two lines of cells: tk cells from ia (in a) and ib (in b); ra, rb hold the arrays and the cells at ia, ib, already read.
type TD
def t8_combdotr's final sum after k products: the sums sit rotated by k mod 4 when its loop ends
type TR
def t8_fin
def t8_cell
type TG
def t8_set
def t8_cols
def t8_rows
type TLrows i0 ..
def t8_lcolscells j..
def t8_lrows
def t8_lfin
type PKK
def t8_pk2
def t8_g
def t8_out_seq
type PT
type PKT
def pkt_leaf
def pkt_then
def pk_treelines i ..
def t8_with2
def t8_rparsplit by rows of C: the pieces are A's rows, B is shared; the result is C's rows in order
type CBa block of C's columns j0 ..
def t8_cparsplit by columns of C: the pieces are B's columns, A is shared
type RW
def cb_roww numbers of xs into c from idx; what is left of xs comes back
def cb_rows
def cb_write
def t8_pr2
def t8_pc2
def t8_par22^d blocks along the larger of n (rows of C, pieces of A) and m (columns of C, pieces of B)
def gemm_t8b
def gemm_t8_acC (n x m) = A · B (or C + A · B when ac) in cells of 8, sequential (d = 0) or with 2^d blocks of rows in parallel; A and B come back intact
def gemm_t8
def gemm_any3one row (matrix · vector): the scalar loop at every depth; two or more rows: cells of 8.
def gemm_any2
def gemm_any
def mmul_fin
def mmul_nt_fin
def mmul_tn_fin
def split_pick---- the split depth of a product (0.1.11.0): par is an upper bound, and a product too small to gain splits 0 times ----
def split_depth
def mm_a
def Mat.matmul
def Mat.matmul_acc
def mm_nt
def Mat.matmul_nt
def Mat.matmul_nt_acc
def mm_tn
def Mat.matmul_tn
def Mat.matmul_tn_acc
type SL
def sl_rowd[di..] = src[si..], k numbers; r holds src[si], already read
def sl_rowsrows i..
def blk_len
def mp_s4
def mp_s3
def mp_s2
def mp_stepblock bi: A's columns o..o+w (A is n x k) and B's rows o..o+w (B is k x m), multiplied into C (added when ac)
def mp_go
def mm_precise2
def Mat.matmul_preciseC = A · B (n x k) · (k x m), k summed in blocks of 1024 (above); opt-in
type MBias