ATSLIB/contrib/libfloats/blas

This package contains various BLAS (Basic Linear Algebra Subprograms) and BLAS-like functions.

blas$gnorm

blas$gnorm2

blas$_alpha_0

blas$gnorm

Synopsis

fun
{a:t0p}
{a2:t0p} blas$gnorm (x: a): a2

blas$gnorm2

Synopsis

fun
{a:t0p}
{a2:t0p} blas$gnorm2 (x: a): a2

blas$_alpha_0

Synopsis

fun{a:t0p}
blas$_alpha_0 (alpha: a, x: a): a

blas$_alpha_1

Synopsis

fun{a:t0p}
blas$_alpha_1 (alpha: a, x: a, y: a): a

blas$_alpha_beta

Synopsis

fun{a:t0p}
blas$_alpha_beta (alpha: a, x: a, beta: a, y: a): a

blas_nrm2

Synopsis

fun
{a:t0p}
{a2:t0p}
blas_nrm2
  {n:int}{d:int}
  (V: &GVT(a, n, d), int n, int d): (a2)

blas_iamax

Synopsis

fun
{a:t0p}
{a2:t0p}
blas_iamax
  {n:int | n > 0}{d:int}
  (V: &GVT(a, n, d), int n, int d): natLt(n)

blas_inner

Synopsis

fun{a:t0p}
blas_inner
  {n:int}{d1,d2:int}
(
  V1: &GVT(a, n, d1)
, V2: &GVT(a, n, d2), int(n), int(d1), int(d2)
) : (a) // end of [blas_inner]

blas_inner$fmul

Synopsis

fun{a:t0p}
blas_inner$fmul (x: a, y: a): a

blas_inner_u

Synopsis

fun{a:t0p}
blas_inner_u
  {n:int}{d1,d2:int}
(
  V1: &GVT(a, n, d1)
, V2: &GVT(a, n, d2), int(n), int(d1), int(d2)
) : (a) // end of [blas_inner_u]

blas_inner_c

Synopsis

fun{a:t0p}
blas_inner_c
  {n:int}{d1,d2:int}
(
  V1: &GVT(a, n, d1)
, V2: &GVT(a, n, d2), int(n), int(d1), int(d2)
) : (a) // end of [blas_inner_c]

blas_copy

Synopsis

fun{a:t0p}
blas_copy
  {n:int}{d1,d2:int}
(
  V1: &GVT(a, n, d1)
, V2: &GVT(a?, n, d2) >> GVT(a, n, d2)
, int(n), int(d1), int(d2)
) : void // end of [blas_copy]

blas_copy2_row

Synopsis

fun{a:t0p}
blas_copy2_row
  {m,n:int}{ld1,ld2:int}
(
  M1: &GMR(a, m, n, ld1)
, M2: &GMR(a?, m, n, ld2) >> GMR(a, m, n, ld2)
, int(m), int(n), int(ld1), int(ld2)
) : void // end of [blas_copy2_row]

blas_copy2_col

Synopsis

fun{a:t0p}
blas_copy2_col
  {m,n:int}{ld1,ld2:int}
(
  M1: &GMC(a, m, n, ld1)
, M2: &GMC(a?, m, n, ld2) >> GMC(a, m, n, ld2)
, int(m), int(n), int(ld1), int(ld2)
) : void // end of [blas_copy2_col]

blas_swap

Synopsis

fun{a:t0p}
blas_swap
  {n:int}{d1,d2:int}
(
  V1: &GVT(a, n, d1)
, V2: &GVT(a, n, d2), int(n), int(d1), int(d2)
) : void // end of [blas_swap]

blas_scal

Synopsis

fun{a:t0p}
blas_scal
  {n:int}{dx:int}
(
  alpha: a
, X: &GVT(a, n, dx) >> _, int n, int dx
) : void // end of [blas_scal]

blas_scal2_row

Synopsis

fun{a:t0p}
blas_scal2_row
  {m,n:int}{ld:int}
(
  alpha: a
, X2: &GMR(a, m, n, ld) >> _, int m, int n, int ld
) : void // end of [blas_scal2_row]

blas_scal2_col

Synopsis

fun{a:t0p}
blas_scal2_col
  {m,n:int}{ld:int}
(
  alpha: a
, X2: &GMC(a, m, n, ld) >> _, int m, int n, int ld
) : void // end of [blas_scal2_col]

blas_ax1y

Synopsis

fun{a:t0p}
blas_ax1y
  {n:int}{dx,dy:int}
(
  alpha: a
, X: &GVT(a, n, dx)
, Y: &GVT(a, n, dy) >> _, int n, int dx, int dy
) : void // end of [blas_ax1y]

blas_ax1y2_row

Synopsis

fun{
a:t0p
} blas_ax1y2_row
  {m,n:int}{lda,ldb:int}
(
  alpha: a
, X2: &GMR(a, m, n, lda)
, Y2: &GMR(a, m, n, ldb) >> _, int m, int n, int lda, int ldb
) : void // end of [blas_ax1y2_row]

blas_ax1y2_col

Synopsis

fun{
a:t0p
} blas_ax1y2_col
  {m,n:int}{lda,ldb:int}
(
  alpha: a
, X2: &GMC(a, m, n, lda)
, Y2: &GMC(a, m, n, ldb) >> _, int m, int n, int lda, int ldb
) : void // end of [blas_ax1y2_col]

blas_axby

Synopsis

fun{a:t0p}
blas_axby
  {n:int}{dx,dy:int}
(
  alpha: a
, X: &GVT(a, n, dx)
, beta: a
, Y: &GVT(a, n, dy) >> _, int n, int dx, int dy
) : void // end of [blas_axby]

blas_axby2_row

Synopsis

fun{
a:t0p
} blas_axby2_row
  {m,n:int}{lda,ldb:int}
(
  alpha: a
, X2: &GMR(a, m, n, lda)
, beta: a
, Y2: &GMR(a, m, n, ldb) >> _, int m, int n, int lda, int ldb
) : void // end of [blas_axby2_row]

blas_axby2_col

Synopsis

fun{
a:t0p
} blas_axby2_col
  {m,n:int}{lda,ldb:int}
(
  alpha: a
, X2: &GMC(a, m, n, lda)
, beta: a
, Y2: &GMC(a, m, n, ldb) >> _, int m, int n, int lda, int ldb
) : void // end of [blas_axby2_col]

blas_gemv_row

Synopsis

fun{a:t0p}
blas_gemv_row
  {m,n:int}
  {tp:transp}
  {ma,na:int}
  {lda,dx,dy:int}
(
  pf: transpdim (tp, ma, na, m, n)
| alpha: a
, A: &GMR(a, m, n, lda), tp: TRANSP(tp)
, X: &GVT(a, n, dx)
, beta: a
, Y: &GVT(a, m, dy) >> _
, int(m), int(n), int(lda), int(dx), int(dy)
) : void // end of [blas_gemv_row]

blas_gemv_row_n

Synopsis

fun{a:t0p}
blas_gemv_row_n
  {m,n:int}{lda,dx,dy:int}
(
  alpha: a
, A: &GMR(a, m, n, lda)
, X: &GVT(a, n, dx)
, beta: a
, Y: &GVT(a, m, dy) >> _
, int(m), int(n), int(lda), int(dx), int(dy)
) : void // end of [blas_gemv_row_n]

blas_gemv_row_t

Synopsis

fun{a:t0p}
blas_gemv_row_t
  {m,n:int}{lda,dx,dy:int}
(
  alpha: a
, A: &GMR(a, n, m, lda)
, X: &GVT(a, n, dx)
, beta: a
, Y: &GVT(a, m, dy) >> _
, int(m), int(n), int(lda), int(dx), int(dy)
) : void // end of [blas_gemv_row_t]

blas_gemv_col

Synopsis

fun{a:t0p}
blas_gemv_col
  {m,n:int}
  {tp:transp}
  {ma,na:int}
  {lda,dx,dy:int}
(
  pf: transpdim (tp, ma, na, m, n)
| alpha: a
, A: &GMC(a, ma, na, lda), tp: TRANSP(tp)
, X: &GVT(a, n, dx)
, beta: a
, Y: &GVT(a, m, dy) >> _
, int(m), int(n), int(lda), int(dx), int(dy)
) : void // end of [blas_gemv_col]

blas_gemv_col_n

Synopsis

fun{a:t0p}
blas_gemv_col_n
  {m,n:int}{lda,dx,dy:int}
(
  alpha: a
, A: &GMC(a, m, n, lda)
, X: &GVT(a, n, dx)
, beta: a
, Y: &GVT(a, m, dy) >> _
, int(m), int(n), int(lda), int(dx), int(dy)
) : void // end of [blas_gemv_col_n]

blas_gemv_col_t

Synopsis

fun{a:t0p}
blas_gemv_col_t
  {m,n:int}{lda,dx,dy:int}
(
  alpha: a
, A: &GMC(a, n, m, lda)
, X: &GVT(a, n, dx)
, beta: a
, Y: &GVT(a, m, dy) >> _
, int(m), int(n), int(lda), int(dx), int(dy)
) : void // end of [blas_gemv_col_t]

blas_gemm_row

Synopsis

fun{
a:t0p
} blas_gemm_row
  {p,q,r:int}
  {tra,trb:transp}
  {ma,na:int}{mb,nb:int}
  {lda,ldb,ldc:int}
(
  pfa: transpdim (tra, ma, na, p, q)
, pfb: transpdim (trb, mb, nb, q, r)   
| alpha: a
, A: &GMR(a, ma, na, lda), TRANSP(tra)
, B: &GMR(a, mb, nb, ldb), TRANSP(trb)
, beta: a
, C: &GMR(a, p, r, ldc) >> _
, int p, int q, int r, int lda, int ldb, int ldc
) : void // end of [blas_gemm_row]

blas_gemm_row_nn

Synopsis

fun{
a:t0p
} blas_gemm_row_nn
  {p,q,r:int}{lda,ldb,ldc:int}
(
  alpha: a
, A: &GMR(a, p, q, lda)
, B: &GMR(a, q, r, ldb)
, beta: a
, C: &GMR(a, p, r, ldc) >> _
, int p, int q, int r, int lda, int ldb, int ldc
) : void // end of [blas_gemm_row_nn]

blas_gemm_row_nt

Synopsis

fun{
a:t0p
} blas_gemm_row_nt
  {p,q,r:int}{lda,ldb,ldc:int}
(
  alpha: a
, A: &GMR(a, p, q, lda)
, B: &GMR(a, r, q, ldb)
, beta: a
, C: &GMR(a, p, r, ldc) >> _
, int p, int q, int r, int lda, int ldb, int ldc
) : void // end of [blas_gemm_row_nt]

blas_gemm_row_tn

Synopsis

fun{
a:t0p
} blas_gemm_row_tn
  {p,q,r:int}{lda,ldb,ldc:int}
(
  alpha: a
, A: &GMR(a, q, p, lda)
, B: &GMR(a, q, r, ldb)
, beta: a
, C: &GMR(a, p, r, ldc) >> _
, int p, int q, int r, int lda, int ldb, int ldc
) : void // end of [blas_gemm_row_tn]

blas_gemm_row_tt

Synopsis

fun{
a:t0p
} blas_gemm_row_tt
  {p,q,r:int}{lda,ldb,ldc:int}
(
  alpha: a
, A: &GMR(a, q, p, lda)
, B: &GMR(a, r, q, ldb)
, beta: a
, C: &GMR(a, p, r, ldc) >> _
, int p, int q, int r, int lda, int ldb, int ldc
) : void // end of [blas_gemm_row_tt]

blas_gemm_col

Synopsis

fun{
a:t0p
} blas_gemm_col
  {p,q,r:int}
  {tra,trb:transp}
  {ma,na:int}{mb,nb:int}
  {lda,ldb,ldc:int}
(
  pfa: transpdim (tra, ma, na, p, q)
, pfb: transpdim (trb, mb, nb, q, r)   
| alpha: a
, A: &GMC(a, ma, na, lda), TRANSP(tra)
, B: &GMC(a, mb, nb, ldb), TRANSP(trb)
, beta: a
, C: &GMC(a, p, r, ldc) >> _
, int p, int q, int r, int lda, int ldb, int ldc
) : void // end of [blas_gemm_col]

blas_gemm_col_nn

Synopsis

fun{
a:t0p
} blas_gemm_col_nn
  {p,q,r:int}{lda,ldb,ldc:int}
(
  alpha: a
, A: &GMC(a, p, q, lda)
, B: &GMC(a, q, r, ldb)
, beta: a
, C: &GMC(a, p, r, ldc) >> _
, int p, int q, int r, int lda, int ldb, int ldc
) : void // end of [blas_gemm_col_nn]

blas_gemm_col_nt

Synopsis

fun{
a:t0p
} blas_gemm_col_nt
  {p,q,r:int}{lda,ldb,ldc:int}
(
  alpha: a
, A: &GMC(a, p, q, lda)
, B: &GMC(a, r, q, ldb)
, beta: a
, C: &GMC(a, p, r, ldc) >> _
, int p, int q, int r, int lda, int ldb, int ldc
) : void // end of [blas_gemm_col_nt]

blas_gemm_col_tn

Synopsis

fun{
a:t0p
} blas_gemm_col_tn
  {p,q,r:int}{lda,ldb,ldc:int}
(
  alpha: a
, A: &GMC(a, q, p, lda)
, B: &GMC(a, q, r, ldb)
, beta: a
, C: &GMC(a, p, r, ldc) >> _
, int p, int q, int r, int lda, int ldb, int ldc
) : void // end of [blas_gemm_col_tn]

blas_gemm_col_tt

Synopsis

fun{
a:t0p
} blas_gemm_col_tt
  {p,q,r:int}{lda,ldb,ldc:int}
(
  alpha: a
, A: &GMC(a, q, p, lda)
, B: &GMC(a, r, q, ldb)
, beta: a
, C: &GMC(a, p, r, ldc) >> _
, int p, int q, int r, int lda, int ldb, int ldc
) : void // end of [blas_gemm_col_tt]

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