ATSLIB/contrib/libfloats/lamatrix

This package is a thin layer for helping use various BLAS and BLAS-like functions on matrices.
  • LAgmat
  • LAgmat_vtype
  • lemma_LAgmat_param
  • LAgmat_mord
  • LAgmat_nrow
  • LAgmat_ncol
  • LAgmat_vtakeout_row
  • LAgmat_vtakeout_col
  • LAgmat_vtakeout_matrix
  • LAgmat_get_at
  • LAgmat_set_at
  • LAgmat_getref_at
  • fprint_LAgmat
  • fprint_LAgmat$sep1
  • fprint_LAgmat$sep2
  • fprint_LAgmat_sep
  • LAgmat_split_1x2
  • LAgmat_split_2x1
  • LAgmat_split_2x2
  • LAgmat_tabulate
  • LAgmat_tabulate$fopr
  • LAgmat_iforeach
  • LAgmat_iforeach_env
  • LAgmat_iforeach$fwork
  • LAgmat_imake_arrayptr
  • LAgmat_imake_matrixptr
  • LAgmat_imake$fopr
  • LAgmat_scal
  • scal_LAgmat
  • LAgmat_copy
  • copy_LAgmat
  • LAgmat_transp
  • transp_LAgmat
  • LAgmat_ax1y
  • LAgmat_axby
  • add11_LAgmat_LAgmat
  • sub11_LAgmat_LAgmat
  • LAgmat_gemm
  • LAgmat_gemm_nn
  • LAgmat_gemm_nt
  • LAgmat_gemm_tn
  • LAgmat_gemm_tt
  • mul00_LAgmat_LAgmat
  • mul10_LAgmat_LAgmat
  • mul01_LAgmat_LAgmat
  • mul11_LAgmat_LAgmat
  • Overloaded Symbols
  • +
  • -
  • *
  • []
  • .nrow
  • .ncol
  • fprint

  • LAgmat

    Synopsis

    stadef LAgmat = LAgmat_vtype
    vtypedef LAgmat
      (a:t@ype, mo: mord, m: int, n: int) = [l:addr] LAgmat(a, mo, l, m, n)

    LAgmat_vtype

    Synopsis

    absvtype
    LAgmat_vtype
      (a:t@ype, mo: mord, l: addr, m: int, n: int) = ptr(l)

    lemma_LAgmat_param

    Synopsis

    praxi
    lemma_LAgmat_param
      {a:t0p}{mo:mord}{m,n:int}
      (M: !LAgmat(a, mo, m, n))
    : [0 <= mo; mo <= 1; 0 <= m; 0 <= n] void

    LAgmat_mord

    Synopsis

    fun{}
    LAgmat_mord
      {a:t0p}{mo:mord}{m,n:int}
      (M: !LAgmat(a, mo, m, n)): MORD(mo)

    LAgmat_nrow

    Synopsis

    fun{}
    LAgmat_nrow
      {a:t0p}{mo:mord}{m,n:int}
      (M: !LAgmat(a, mo, m, n)): int (m)

    LAgmat_ncol

    Synopsis

    fun{}
    LAgmat_ncol
      {a:t0p}{mo:mord}{m,n:int}
      (M: !LAgmat(a, mo, m, n)): int (n)

    LAgmat_vtakeout_row

    Synopsis

    fun{}
    LAgmat_vtakeout_row
      {a:t0p}{mo:mord}{m,n:int}
    (
      !LAgmat(a, mo, m, n)
    , i: natLt(m), d: &int? >> int(d)
    ) :
    #[
      l:addr;d:int
    ] (
      gvector_v (a, l, n, d)
    , gvector_v (a, l, n, d) -<lin,prf> void
    | ptr (l)
    ) // end of [LAgmat_vtakeout_row]

    LAgmat_vtakeout_col

    Synopsis

    fun{}
    LAgmat_vtakeout_col
      {a:t0p}{mo:mord}{m,n:int}
    (
      !LAgmat(a, mo, m, n)
    , j: natLt(n), d: &int? >> int(d)
    ) :
    #[
      l:addr;d:int
    ] (
      gvector_v (a, l, m, d)
    , gvector_v (a, l, m, d) -<lin,prf> void
    | ptr (l)
    ) // end of [LAgmat_vtakeout_col]

    LAgmat_vtakeout_matrix

    Synopsis

    fun{}
    LAgmat_vtakeout_matrix
      {a:t0p}{mo:mord}{m,n:int}
    (
      !LAgmat(a, mo, m, n)
    , ld: &int? >> int(ld)
    ) :
    #[
      l:addr;ld:int
    ] (
      gmatrix_v (a, mo, l, m, n, ld)
    , gmatrix_v (a, mo, l, m, n, ld) -<lin,prf> void
    | ptr (l)
    ) // end of [LAgmat_vtakeout_matrix]

    LAgmat_get_at

    Synopsis

    fun{a:t0p}
    LAgmat_get_at
      {mo:mord}{m,n:int}
    (
      M: !LAgmat(a, mo, m, n), i: natLt(m), j: natLt(n)
    ) : (a) // endfun

    LAgmat_set_at

    Synopsis

    fun{a:t0p}
    LAgmat_set_at
      {mo:mord}{m,n:int}
    (
      M: !LAgmat(a, mo, m, n), i: natLt(m), j: natLt(n), x: a
    ) : void // endfun

    LAgmat_getref_at

    Synopsis

    fun{a:t0p}
    LAgmat_getref_at
      {mo:mord}{m,n:int}
    (
      M: !LAgmat(a, mo, m, n), i: natLt(m), j: natLt(n)
    ) : cPtr1(a) // end of [LAgmat_getref_at]

    fprint_LAgmat

    Synopsis

    fun{a:t0p}
    fprint_LAgmat
      {mo:mord}{m,n:int} (FILEref, !LAgmat(a, mo, m, n)): void

    fprint_LAgmat$sep1

    Synopsis

    fun{}
    fprint_LAgmat$sep1 (FILEref): void

    fprint_LAgmat$sep2

    Synopsis

    fun{}
    fprint_LAgmat$sep2 (FILEref): void

    fprint_LAgmat_sep

    Synopsis

    fun{a:t0p}
    fprint_LAgmat_sep
      {mo:mord}{m,n:int}
      (FILEref, !LAgmat(a, mo, m, n), sep1: string, sep2: string): void

    LAgmat_split_1x2

    Synopsis

    fun{a:t0p}
    LAgmat_split_1x2
      {mo:mord}{m,n:int}
      {j:nat | j <= n}
    (
      LAgmat(a, mo, m, n), j: int j
    ) :
    (
      LAgmat(a, mo,   m,   j)
    , LAgmat(a, mo,   m, n-j)
    ) (* end of [LAgmat_split_1x2] *)

    LAgmat_split_2x1

    Synopsis

    fun{a:t0p}
    LAgmat_split_2x1
      {mo:mord}{m,n:int}
      {i:nat | i <= m}
    (
      LAgmat(a, mo, m, n), i: int i
    ) :
    (
      LAgmat(a, mo,   i,   n)
    , LAgmat(a, mo, m-i,   n)
    ) (* end of [LAgmat_split_2x1] *)

    LAgmat_split_2x2

    Synopsis

    fun{a:t0p}
    LAgmat_split_2x2
      {mo:mord}{m,n:int}
      {i,j:nat | i <= m; j <= n}
    (
      LAgmat(a, mo, m, n), i: int i, j: int j
    ) :
    (
      LAgmat(a, mo,   i,   j)
    , LAgmat(a, mo,   i, n-j)
    , LAgmat(a, mo, m-i,   j)
    , LAgmat(a, mo, m-i, n-j)
    ) (* end of [LAgmat_split_2x2] *)

    LAgmat_tabulate

    Synopsis

    fun{a:t0p}
    LAgmat_tabulate
      {mo:mord}{m,n:pos}
      (mo: MORD(mo), m: int m, n: int n): LAgmat(a, mo, m, n)

    LAgmat_tabulate$fopr

    Synopsis

    fun{a:t0p}
    LAgmat_tabulate$fopr (i: int, j: int): a

    LAgmat_iforeach

    Synopsis

    fun{a:t0p}
    LAgmat_iforeach
      {mo:mord}{m,n:int} (!LAgmat (a, mo, m, n) >> _): void

    LAgmat_iforeach_env

    Synopsis

    fun
    {a:t0p}
    {env:vt0p}
    LAgmat_iforeach_env
      {mo:mord}{m,n:int}
      (M: !LAgmat (a, mo, m, n) >> _, env: &env >> _): void

    LAgmat_iforeach$fwork

    Synopsis

    fun
    {a:t0p}
    {env:vt0p}
    LAgmat_iforeach$fwork
      (i: int, j: int, x: &a >> _, env: &env >> _): void

    LAgmat_imake_arrayptr

    Synopsis

    fun{a:t0p}
    LAgmat_imake_arrayptr
      {mo:mord}{m,n:int}
      (M: !LAgmat (a, mo, m, n)): arrayptr (a, m*n)

    LAgmat_imake_matrixptr

    Synopsis

    fun{a:t0p}
    LAgmat_imake_matrixptr
      {mo:mord}{m,n:int}
      (M: !LAgmat (a, mo, m, n)): matrixptr (a, m, n)

    LAgmat_imake$fopr

    Synopsis

    fun{a:t0p}
    LAgmat_imake$fopr (i: int, j: int, x: a): a

    LAgmat_scal

    Synopsis

    fun{a:t0p}
    LAgmat_scal
      {mo:mord}{m,n:int}
    (
      alpha: a
    , X: !LAgmat(a, mo, m, n) >> _
    ) : void // endfun

    scal_LAgmat

    Synopsis

    fun{a:t0p}
    scal_LAgmat
      {mo:mord}{m,n:int}
    (
      alpha: a, X: !LAgmat(a, mo, m, n)
    ) : LAgmat(a, mo, m, n)

    LAgmat_copy

    Synopsis

    fun{a:t0p}
    LAgmat_copy
      {mo:mord}{m,n:int}
    (
      X: !LAgmat(a, mo, m, n)
    , Y: !LAgmat(a?, mo, m, n) >> LAgmat(a, mo, m, n)
    ) : void // endfun

    copy_LAgmat

    Synopsis

    fun{a:t0p}
    copy_LAgmat
      {mo:mord}{m,n:int}
      (X: !LAgmat(a, mo, m, n)) : LAgmat(a, mo, m, n)

    LAgmat_transp

    Synopsis

    fun{a:t0p}
    LAgmat_transp
      {mo:mord}{m,n:int}
    (
      X: !LAgmat(a, mo, m, n)
    , Y: !LAgmat(a?, mo, n, m) >> LAgmat(a, mo, n, m)
    ) : void // endfun

    transp_LAgmat

    Synopsis

    fun{a:t0p}
    transp_LAgmat
      {mo:mord}{m,n:int}
      (X: !LAgmat(a, mo, m, n)) : LAgmat(a, mo, n, m)

    LAgmat_ax1y

    Synopsis

    fun{a:t0p}
    LAgmat_ax1y
      {mo:mord}{m,n:int}
    (
      alpha: a
    , X: !LAgmat(a, mo, m, n)
    , Y: !LAgmat(a, mo, m, n) >> _
    ) : void // endfun

    LAgmat_axby

    Synopsis

    fun{a:t0p}
    LAgmat_axby
      {mo:mord}{m,n:int}
    (
      alpha: a
    , X: !LAgmat(a, mo, m, n)
    , beta: a
    , Y: !LAgmat(a, mo, m, n) >> _
    ) : void // endfun

    add11_LAgmat_LAgmat

    Synopsis

    fun{a:t0p}
    add11_LAgmat_LAgmat
      {mo:mord}{m,n:int}
    (
      X: !LAgmat(a, mo, m, n), Y: !LAgmat(a, mo, m, n)
    ) : LAgmat(a, mo, m, n)

    sub11_LAgmat_LAgmat

    Synopsis

    fun{a:t0p}
    sub11_LAgmat_LAgmat
      {mo:mord}{m,n:int}
    (
      X: !LAgmat(a, mo, m, n), Y: !LAgmat(a, mo, m, n)
    ) : LAgmat(a, mo, m, n)

    LAgmat_gemm

    Synopsis

    fun{a:t0p}
    LAgmat_gemm
      {mo:mord}
      {p,q,r:int}
      {tra,trb:transp}
      {ma,na:int}{mb,nb:int}
    (
      pfa: transpdim (tra, ma, na, p, q)
    , pfb: transpdim (trb, mb, nb, q, r)   
    | alpha: a
    , A: !LAgmat(a, mo, ma, na), TRANSP(tra)
    , B: !LAgmat(a, mo, mb, nb), TRANSP(trb)
    , beta: a
    , C: !LAgmat(a, mo, p, r) >> _
    ) : void // endfun

    LAgmat_gemm_nn

    Synopsis

    fun{a:t0p}
    LAgmat_gemm_nn
      {mo:mord}
      {p,q,r:int}
    (
      alpha: a
    , A: !LAgmat(a, mo, p, q)
    , B: !LAgmat(a, mo, q, r)
    , beta: a
    , C: !LAgmat(a, mo, p, r) >> _
    ) : void // endfun

    LAgmat_gemm_nt

    Synopsis

    fun{a:t0p}
    LAgmat_gemm_nt
      {mo:mord}
      {p,q,r:int}
    (
      alpha: a
    , A: !LAgmat(a, mo, p, q)
    , B: !LAgmat(a, mo, r, q)
    , beta: a
    , C: !LAgmat(a, mo, p, r) >> _
    ) : void // endfun

    LAgmat_gemm_tn

    Synopsis

    fun{a:t0p}
    LAgmat_gemm_tn
      {mo:mord}
      {p,q,r:int}
    (
      alpha: a
    , A: !LAgmat(a, mo, q, p)
    , B: !LAgmat(a, mo, q, r)
    , beta: a
    , C: !LAgmat(a, mo, p, r) >> _
    ) : void // endfun

    LAgmat_gemm_tt

    Synopsis

    fun{a:t0p}
    LAgmat_gemm_tt
      {mo:mord}
      {p,q,r:int}
    (
      alpha: a
    , A: !LAgmat(a, mo, q, p)
    , B: !LAgmat(a, mo, r, q)
    , beta: a
    , C: !LAgmat(a, mo, p, r) >> _
    ) : void // endfun

    mul00_LAgmat_LAgmat

    Synopsis

    fun{a:t0p}
    mul00_LAgmat_LAgmat
      {mo:mord}{p,q,r:int}
    (
      X: LAgmat(a, mo, p, q), Y: LAgmat(a, mo, q, r)
    ) : LAgmat(a, mo, p, r)

    mul10_LAgmat_LAgmat

    Synopsis

    fun{a:t0p}
    mul10_LAgmat_LAgmat
      {mo:mord}{p,q,r:int}
    (
      X: !LAgmat(a, mo, p, q), Y: LAgmat(a, mo, q, r)
    ) : LAgmat(a, mo, p, r)

    mul01_LAgmat_LAgmat

    Synopsis

    fun{a:t0p}
    mul01_LAgmat_LAgmat
      {mo:mord}{p,q,r:int}
    (
      X: LAgmat(a, mo, p, q), Y: !LAgmat(a, mo, q, r)
    ) : LAgmat(a, mo, p, r)

    mul11_LAgmat_LAgmat

    Synopsis

    fun{a:t0p}
    mul11_LAgmat_LAgmat
      {mo:mord}{p,q,r:int}
    (
      X: !LAgmat(a, mo, p, q), Y: !LAgmat(a, mo, q, r)
    ) : LAgmat(a, mo, p, r)

    Overloaded Symbols


    +

    Synopsis

    overload + with add11_LAgmat_LAgmat

    -

    Synopsis

    overload - with sub11_LAgmat_LAgmat

    *

    Synopsis

    overload * with mul11_LAgmat_LAgmat

    []

    Synopsis

    overload [] with LAgmat_get_at
    overload [] with LAgmat_set_at

    .nrow

    Synopsis

    overload .nrow with LAgmat_nrow

    .ncol

    Synopsis

    overload .ncol with LAgmat_ncol

    fprint

    Synopsis

    overload fprint with fprint_LAgmat

    This page is created with ATS by Hongwei Xi and also maintained by Hongwei Xi. SourceForge.net Logo