C API

blasfeo_allocate_dmat(m, n, sA)

create a strmat for a matrix of size m*n by dynamically allocating memory

blasfeo_allocate_dvec(m, sa)

create a strvec for a vector of size m by dynamically allocating memory

blasfeo_allocate_smat(m, n, sA)

create a strmat for a matrix of size m*n by dynamically allocating memory

blasfeo_allocate_svec(m, sa)

create a strvec for a vector of size m by dynamically allocating memory

blasfeo_cm_create_dmat(m, n, sA, memory)

create a strmat for a matrix of size m*n by using memory passed by a pointer (pointer is not updated)

blasfeo_cm_create_smat(m, n, sA, memory)

create a strmat for a matrix of size m*n by using memory passed by a pointer (pointer is not updated)

blasfeo_cm_memsize_dmat(m, n)

returns the memory size (in bytes) needed for a dmat

blasfeo_cm_memsize_smat(m, n)

returns the memory size (in bytes) needed for a dmat

blasfeo_create_dmat(m, n, sA, memory)

–- creation

create a strmat for a matrix of size m*n by using memory passed by a pointer (pointer is not updated)

blasfeo_create_dvec(m, sA, memory)

create a strvec for a vector of size m by using memory passed by a pointer (pointer is not updated)

blasfeo_create_smat(m, n, sA, memory)

creation create a strmat for a matrix of size m*n by using memory passed by a pointer (pointer is not updated)

blasfeo_create_svec(m, sA, memory)

create a strvec for a vector of size m by using memory passed by a pointer (pointer is not updated)

blasfeo_daxpby(kmax, alpha, sx, xi, beta, sy, yi, sz, zi)

z = betay + alphax

blasfeo_daxpy(kmax, alpha, sx, xi, sy, yi, sz, zi)

z = y + alphax z[zi:zi+n] = alphax[xi:xi+n] + y[yi:yi+n] NB: Different arguments semantic compare to equivalent standard BLAS routine

blasfeo_dcolex(kmax, sA, ai, aj, sx, xi)

col

blasfeo_dcolrot(m, sA, ai, aj0, aj1, c, s)

apply plane rotation [a b] [c -s; s; c] to the aj0 and aj1 columns of A at row index ai

blasfeo_ddiaad(kmax, alpha, sx, xi, sA, ai, aj)

diag(A) += alpha*x

blasfeo_ddiaad_sp(kmax, alpha, sx, xi, idx, sD, di, dj)

diag(A)[idx] += alpha*x

blasfeo_ddiaadin_sp(kmax, alpha, sx, xi, sy, yi, idx, sD, di, dj)

diag(A)[idx] = y + alpha*x

blasfeo_ddiaex(kmax, alpha, sA, ai, aj, sx, xi)

x <= diag(A)

blasfeo_ddiaex_sp(kmax, alpha, idx, sD, di, dj, sx, xi)

x <= diag(A)[idx]

blasfeo_ddiain(kmax, alpha, sx, xi, sA, ai, aj)

diag(A) <= alpha*x

blasfeo_ddiain_sp(kmax, alpha, sx, xi, idx, sD, di, dj)

diag(A)[idx] <= alpha*x

blasfeo_ddiare(kmax, alpha, sA, ai, aj)

dia diag(A) += alpha

blasfeo_ddot(m, sx, xi, sy, yi)

return x^T * y

blasfeo_dgead(m, n, alpha, sA, ai, aj, sB, bi, bj)

–- sum B <= B + alpha*A

blasfeo_dgecp(m, n, sA, ai, aj, sB, bi, bj)

–- copy / scale B <= A

blasfeo_dgecpsc(m, n, alpha, sA, ai, aj, sB, bi, bj)

B <= alpha*A

blasfeo_dgeex1(sA, ai, aj)

<= sA[ai, aj]

blasfeo_dgein1(a, sA, ai, aj)

ge –- insert/extract

sA[ai, aj] <= a

blasfeo_dgelqf(m, n, sC, ci, cj, sD, di, dj, work)

D <= lq( C )

blasfeo_dgelqf_pd(m, n, sC, ci, cj, sD, di, dj, work)

D <= lq( C ), positive diagonal elements

blasfeo_dgelqf_pd_la(m, n1, sL, li, lj, sA, ai, aj, work)

[L, A] <= lq( [L, A] ), positive diagonal elements, array of matrices, with L lower triangular, of size (m)x(m) A full, of size (m)x(n1)

blasfeo_dgelqf_pd_lla(m, n1, sL0, l0i, l0j, sL1, l1i, l1j, sA, ai, aj, work)

[L, L, A] <= lq( [L, L, A] ), positive diagonal elements, array of matrices, with: L lower triangular, of size (m)x(m) A full, of size (m)x(n1)

blasfeo_dgemm_nd(m, n, alpha, sA, ai, aj, sB, bi, beta, sC, ci, cj, sD, di, dj)

D <= alpha * A * B + beta * C, with B diagonal (stored as strvec)

blasfeo_dgemm_nn(m, n, k, alpha, sA, ai, aj, sB, bi, bj, beta, sC, ci, cj, sD, di, dj)

D <= beta * C + alpha * A * B

blasfeo_dgemm_nt(m, n, k, alpha, sA, ai, aj, sB, bi, bj, beta, sC, ci, cj, sD, di, dj)

D <= beta * C + alpha * A * B^T

blasfeo_dgemm_tn(m, n, k, alpha, sA, ai, aj, sB, bi, bj, beta, sC, ci, cj, sD, di, dj)

D <= beta * C + alpha * A^T * B

blasfeo_dgemm_tt(m, n, k, alpha, sA, ai, aj, sB, bi, bj, beta, sC, ci, cj, sD, di, dj)

D <= beta * C + alpha * A^T * B^T

blasfeo_dgemv_d(m, alpha, sA, ai, sx, xi, beta, sy, yi, sz, zi)

z <= beta * y + alpha * A * x, A diagonal

blasfeo_dgemv_n(m, n, alpha, sA, ai, aj, sx, xi, beta, sy, yi, sz, zi)

z <= beta * y + alpha * A * x

blasfeo_dgemv_nt(m, n, alpha_n, alpha_t, sA, ai, aj, sx_n, xi_n, sx_t, xi_t, beta_n, beta_t, sy_n, yi_n, sy_t, yi_t, sz_n, zi_n, sz_t, zi_t)

zn <= betan * yn + alphan * A * xn zt <= betat * yt + alphat * A^T * xt

blasfeo_dgemv_t(m, n, alpha, sA, ai, aj, sx, xi, beta, sy, yi, sz, zi)

z <= beta * y + alpha * A^T * x

blasfeo_dgeqrf_worksize(m, n)

D <= qr( C )

blasfeo_dger(m, n, alpha, sx, xi, sy, yi, sC, ci, cj, sD, di, dj)

D = C + alpha * x * y^T

blasfeo_dgesc(m, n, alpha, sA, ai, aj)

A <= alpha*A

blasfeo_dgese(m, n, alpha, sA, ai, aj)

–- set A <= alpha

blasfeo_dgetr(m, n, sA, ai, aj, sB, bi, bj)

–- traspositions B <= A'

blasfeo_dgetrf_np(m, n, sC, ci, cj, sD, di, dj)

D <= lu( C ) ; no pivoting

blasfeo_dgetrf_rp(m, n, sC, ci, cj, sD, di, dj, ipiv)

D <= lu( C ) ; row pivoting

blasfeo_dorglq_worksize(m, n, k)

D <= Q factor, where C is the output of the LQ factorization

blasfeo_dpotrf_l(m, sC, ci, cj, sD, di, dj)

D <= chol( C ) ; C, D lower triangular

blasfeo_dpotrf_u(m, sC, ci, cj, sD, di, dj)

D <= chol( C ) ; C, D upper triangular

blasfeo_drotg(a, b, c, s)

construct givens plane rotation

blasfeo_drowin(kmax, alpha, sx, xi, sA, ai, aj)

row

blasfeo_drowrot(m, sA, ai0, ai1, aj, c, s)

apply plane rotation [c s; -s c] [a; b] to the ai0 and ai1 rows of A at column index aj

blasfeo_dsymv_l(m, alpha, sA, ai, aj, sx, xi, beta, sy, yi, sz, zi)

z <= beta * y + alpha * A * x, where A is symmetric and only the lower triangular patr of A is accessed

blasfeo_dsymv_u(m, alpha, sA, ai, aj, sx, xi, beta, sy, yi, sz, zi)

z <= beta * y + alpha * A * x, where A is symmetric and only the upper triangular patr of A is accessed

blasfeo_dsyr2k_ln(m, k, alpha, sA, ai, aj, sB, bi, bj, beta, sC, ci, cj, sD, di, dj)

D <= beta * C + alpha * A * B^T + alpha * B * A^T; C, D lower triangular

blasfeo_dsyr2k_lt(m, k, alpha, sA, ai, aj, sB, bi, bj, beta, sC, ci, cj, sD, di, dj)

D <= beta * C + alpha * A^T * B + alpha * B^T * A; C, D lower triangular

blasfeo_dsyr2k_un(m, k, alpha, sA, ai, aj, sB, bi, bj, beta, sC, ci, cj, sD, di, dj)

D <= beta * C + alpha * A * B^T + alpha * B * A^T; C, D upper triangular

blasfeo_dsyr2k_ut(m, k, alpha, sA, ai, aj, sB, bi, bj, beta, sC, ci, cj, sD, di, dj)

D <= beta * C + alpha * A^T * B + alpha * B^T * A; C, D upper triangular

blasfeo_dsyrk_dpotrf_ln(m, k, sA, ai, aj, sB, bi, bj, sC, ci, cj, sD, di, dj)

D <= chol( C + A * B' ) ; C, D lower triangular D <= chol( C + A * B^T ) ; C, D lower triangular

blasfeo_dsyrk_ln(m, k, alpha, sA, ai, aj, sB, bi, bj, beta, sC, ci, cj, sD, di, dj)

D <= beta * C + alpha * A * B^T ; C, D lower triangular

blasfeo_dsyrk_lt(m, k, alpha, sA, ai, aj, sB, bi, bj, beta, sC, ci, cj, sD, di, dj)

D <= beta * C + alpha * A^T * B ; C, D lower triangular

blasfeo_dsyrk_un(m, k, alpha, sA, ai, aj, sB, bi, bj, beta, sC, ci, cj, sD, di, dj)

D <= beta * C + alpha * A * B^T ; C, D upper triangular

blasfeo_dsyrk_ut(m, k, alpha, sA, ai, aj, sB, bi, bj, beta, sC, ci, cj, sD, di, dj)

D <= beta * C + alpha * A^T * B ; C, D upper triangular

blasfeo_dtrcp_l(m, sA, ai, aj, sB, bi, bj)

B <= A, A lower triangular

blasfeo_dtrmm_llnn(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * A * B ; A lower triangular

blasfeo_dtrmm_llnu(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * A * B ; A lower triangular assuming unit diagonal

blasfeo_dtrmm_lltn(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * A^T * B ; A lower triangular

blasfeo_dtrmm_lltu(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * A^T * B ; A lower triangular assuming unit diagonal

blasfeo_dtrmm_lunn(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * A * B ; A upper triangular

blasfeo_dtrmm_lunu(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * A * B ; A upper triangular assuming unit diagonal

blasfeo_dtrmm_lutn(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * A^T * B ; A upper triangular

blasfeo_dtrmm_lutu(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * A^T * B ; A upper triangular assuming unit diagonal

blasfeo_dtrmm_rlnn(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * B * A ; A lower triangular

blasfeo_dtrmm_rlnu(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * B * A ; A lower triangular assuming unit diagonal

blasfeo_dtrmm_rltn(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * B * A^T ; A lower triangular

blasfeo_dtrmm_rltu(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * B * A^T ; A lower triangular assuming unit diagonal

blasfeo_dtrmm_runn(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * B * A ; A upper triangular

blasfeo_dtrmm_runu(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * B * A ; A upper triangular assuming unit diagonal

blasfeo_dtrmm_rutn(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * B * A^T ; A upper triangular

blasfeo_dtrmm_rutu(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * B * A^T ; A upper triangular assuming unit diagonal

blasfeo_dtrmv_lnn(m, sA, ai, aj, sx, xi, sz, zi)

z <= A * x ; A lower triangular

blasfeo_dtrmv_lnu(m, sA, ai, aj, sx, xi, sz, zi)

z <= A * x ; A lower triangular, assuming unit diagonal

blasfeo_dtrmv_ltn(m, sA, ai, aj, sx, xi, sz, zi)

z <= A^T * x ; A lower triangular

blasfeo_dtrmv_ltu(m, sA, ai, aj, sx, xi, sz, zi)

z <= A^T * x ; A lower triangular, assuming unit diagonal

blasfeo_dtrmv_unn(m, sA, ai, aj, sx, xi, sz, zi)

z <= beta * y + alpha * A * x ; A upper triangular

blasfeo_dtrmv_utn(m, sA, ai, aj, sx, xi, sz, zi)

z <= A^T * x ; A upper triangular

blasfeo_dtrsm_llnn(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * A^{-1} * B , with A lower triangular employing explicit inverse of diagonal

blasfeo_dtrsm_llnu(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * A^{-1} * B , with A lower triangular assuming unit diagonal

blasfeo_dtrsm_lltn(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * A^{-T} * B , with A lower triangular employing explicit inverse of diagonal

blasfeo_dtrsm_lltu(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * A^{-T} * B , with A lower triangular assuming unit diagonal

blasfeo_dtrsm_lunn(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * A^{-1} * B , with A upper triangular employing explicit inverse of diagonal

blasfeo_dtrsm_lunu(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * A^{-1} * B , with A upper triangular assuming unit diagonal

blasfeo_dtrsm_lutn(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * A^{-T} * B , with A upper triangular employing explicit inverse of diagonal

blasfeo_dtrsm_lutu(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * A^{-T} * B , with A upper triangular assuming unit diagonal

blasfeo_dtrsm_rlnn(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * B * A^{-1} , with A lower triangular employing explicit inverse of diagonal

blasfeo_dtrsm_rlnu(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * B * A^{-1} , with A lower triangular assuming unit diagonal

blasfeo_dtrsm_rltn(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * B * A^{-T} , with A lower triangular employing explicit inverse of diagonal

blasfeo_dtrsm_rltu(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * B * A^{-T} , with A lower triangular assuming unit diagonal

blasfeo_dtrsm_runn(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * B * A^{-1} , with A upper triangular employing explicit inverse of diagonal

blasfeo_dtrsm_runu(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * B * A^{-1} , with A upper triangular assuming unit diagonal

blasfeo_dtrsm_rutn(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * B * A^{-T} , with A upper triangular employing explicit inverse of diagonal

blasfeo_dtrsm_rutu(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * B * A^{-T} , with A upper triangular assuming unit diagonal

blasfeo_dtrsv_lnn(m, sA, ai, aj, sx, xi, sz, zi)

z <= inv( A ) * x, A (m)x(m) lower, not_transposed

blasfeo_dtrsv_lnn_mn(m, n, sA, ai, aj, sx, xi, sz, zi)

z <= inv( A ) * x, A (m)x(n)

blasfeo_dtrsv_lnu(m, sA, ai, aj, sx, xi, sz, zi)

z <= inv( A ) * x, A (m)x(m) lower, not_transposed, assuming unit diagonal

blasfeo_dtrsv_ltn(m, sA, ai, aj, sx, xi, sz, zi)

z <= inv( A^T ) * x, A (m)x(m) lower, transposed

blasfeo_dtrsv_ltn_mn(m, n, sA, ai, aj, sx, xi, sz, zi)

z <= inv( A^T ) * x, A (m)x(n)

blasfeo_dtrsv_ltu(m, sA, ai, aj, sx, xi, sz, zi)

z <= inv( A^T ) * x, A (m)x(m) lower, transposed, assuming unit diagonal

blasfeo_dtrsv_unn(m, sA, ai, aj, sx, xi, sz, zi)

z <= inv( A^T ) * x, A (m)x(m) upper, not_transposed

blasfeo_dtrsv_utn(m, sA, ai, aj, sx, xi, sz, zi)

z <= inv( A^T ) * x, A (m)x(m) upper, transposed

blasfeo_dtrtr_l(m, sA, ai, aj, sB, bi, bj)

B <= A', A lower triangular

blasfeo_dtrtr_u(m, sA, ai, aj, sB, bi, bj)

B <= A', A upper triangular

blasfeo_dvecad(m, alpha, sx, xi, sy, yi)

y <= y + alpha*x

blasfeo_dvecad_sp(m, alpha, sx, xi, idx, sz, zi)

z[idx] += alpha * x

blasfeo_dveccp(m, sx, xi, sy, yi)

y <= x

blasfeo_dveccpsc(m, alpha, sx, xi, sy, yi)

y <= alpha*x

blasfeo_dvecex1(sx, xi)

<= sx[xi]

blasfeo_dvecex_sp(m, alpha, idx, sx, xi, sz, zi)

z <= alpha * x[idx]

blasfeo_dvecexad_sp(m, alpha, idx, sx, xi, sz, zi)

z += alpha * x[idx]

blasfeo_dvecin1(a, sx, xi)

sx[xi] <= a

blasfeo_dvecin_sp(m, alpha, sx, xi, idx, sz, zi)

z[idx] <= alpha * x

blasfeo_dvecmul(m, sx, xi, sy, yi, sz, zi)

z = x .* y

blasfeo_dvecmulacc(m, sx, xi, sy, yi, sz, zi)

z += x .* y

blasfeo_dvecmuldot(m, sx, xi, sy, yi, sz, zi)

z = x .* y, return sum(z) = x^T * y

blasfeo_dvecsc(m, alpha, sx, xi)

x <= alpha*x

blasfeo_dvecse(m, alpha, sx, xi)

vec a <= alpha

blasfeo_free_dmat(sA)

free the memory allocated by blasfeoallocatedmat

blasfeo_free_dvec(sa)

free the memory allocated by blasfeoallocatedvec

blasfeo_free_smat(sA)

free the memory allocated by blasfeoallocatedmat

blasfeo_free_svec(sa)

free the memory allocated by blasfeoallocatedvec

blasfeo_memsize_diag_dmat(m, n)

returns the memory size (in bytes) needed for the diagonal of a dmat

blasfeo_memsize_diag_smat(m, n)

returns the memory size (in bytes) needed for the diagonal of a smat

blasfeo_memsize_dmat(m, n)

–- memory size calculations

returns the memory size (in bytes) needed for a dmat

blasfeo_memsize_dvec(m)

returns the memory size (in bytes) needed for a dvec

blasfeo_memsize_smat(m, n)

memory returns the memory size (in bytes) needed for a smat

blasfeo_memsize_svec(m)

returns the memory size (in bytes) needed for a svec

blasfeo_pack_dmat(m, n, A, lda, sB, bi, bj)

–- packing pack the column-major matrix A (with leading dimension lda) into the matrix struct B (at row and col offsets bi and bj)

blasfeo_pack_dvec(m, x, incx, sy, yi)

pack the vector x (using increment incx) into the vector structure y (at offset yi)

blasfeo_pack_l_dmat(m, n, A, lda, sB, bi, bj)

pack the lower-triangular column-major matrix A (with leading dimension lda) into the matrix struct B (at row and col offsets bi and bj)

blasfeo_pack_l_smat(m, n, A, lda, sA, ai, aj)

pack the lower-triangular column-major matrix A (with leading dimension lda) into the matrix struct B (at row and col offsets bi and bj)

blasfeo_pack_smat(m, n, A, lda, sA, ai, aj)

packing pack the column-major matrix A (with leading dimension lda) into the matrix struct B (at row and col offsets bi and bj)

blasfeo_pack_svec(m, x, xi, sa, ai)

pack the vector x (using increment incx) into the vector structure y (at offset yi)

blasfeo_pack_tran_dmat(m, n, A, lda, sB, bi, bj)

transpose and pack the column-major matrix A (with leading dimension lda) into the matrix struct B (at row and col offsets bi and bj)

blasfeo_pack_tran_smat(m, n, A, lda, sA, ai, aj)

transpose and pack the column-major matrix A (with leading dimension lda) into the matrix struct B (at row and col offsets bi and bj)

blasfeo_pack_u_dmat(m, n, A, lda, sB, bi, bj)

pack the upper-triangular column-major matrix A (with leading dimension lda) into the matrix struct B (at row and col offsets bi and bj)

blasfeo_pack_u_smat(m, n, A, lda, sA, ai, aj)

pack the upper-triangular column-major matrix A (with leading dimension lda) into the matrix struct B (at row and col offsets bi and bj)

blasfeo_pm_create_dmat(ps, m, n, sA, memory)

create a strmat for a matrix of size m*n by using memory passed by a pointer (pointer is not updated)

blasfeo_pm_create_smat(ps, m, n, sA, memory)

create a strmat for a matrix of size m*n by using memory passed by a pointer (pointer is not updated)

blasfeo_pm_memsize_dmat(ps, m, n)

returns the memory size (in bytes) needed for a dmat

blasfeo_pm_memsize_smat(ps, m, n)

returns the memory size (in bytes) needed for a dmat

blasfeo_pm_print_dmat(m, n, sA, ai, aj)

print

blasfeo_print_dmat(m, n, sA, ai, aj)

print a strmat

blasfeo_print_dvec(m, sa, ai)

print a strvec

blasfeo_print_exp_dmat(m, n, sA, ai, aj)

print in exponential notation a strmat

blasfeo_print_exp_dvec(m, sa, ai)

print in exponential notation a strvec

blasfeo_print_exp_smat(m, n, sA, ai, aj)

print in exponential notation a strmat

blasfeo_print_exp_svec(m, sa, ai)

print in exponential notation a strvec

blasfeo_print_exp_tran_dvec(m, sa, ai)

print in exponential notation the transposed of a strvec

blasfeo_print_exp_tran_svec(m, sa, ai)

print in exponential notation the transposed of a strvec

blasfeo_print_smat(m, n, sA, ai, aj)

print a strmat

blasfeo_print_svec(m, sa, ai)

print a strvec

blasfeo_print_to_file_dmat(file, m, n, sA, ai, aj)

print to file a strmat

blasfeo_print_to_file_dvec(file, m, sa, ai)

print to file a strvec

blasfeo_print_to_file_exp_dmat(file, m, n, sA, ai, aj)

print to file a strmat in exponential format

blasfeo_print_to_file_exp_smat(file, m, n, sA, ai, aj)

print to file a strmat in exponential format

blasfeo_print_to_file_smat(file, m, n, sA, ai, aj)

print to file a strmat

blasfeo_print_to_file_svec(file, m, sa, ai)

print to file a strvec

blasfeo_print_to_file_tran_dvec(file, m, sa, ai)

print to file the transposed of a strvec

blasfeo_print_to_file_tran_svec(file, m, sa, ai)

print to file the transposed of a strvec

blasfeo_print_to_string_dmat(buf_out, m, n, sA, ai, aj)

print to string a strmat

blasfeo_print_to_string_dvec(buf_out, m, sa, ai)

print to string a strvec

blasfeo_print_to_string_smat(buf_out, m, n, sA, ai, aj)

print to string a strmat

blasfeo_print_to_string_svec(buf_out, m, sa, ai)

print to string a strvec

blasfeo_print_to_string_tran_dvec(buf_out, m, sa, ai)

print to string the transposed of a strvec

blasfeo_print_to_string_tran_svec(buf_out, m, sa, ai)

print to string the transposed of a strvec

blasfeo_print_tran_dmat(m, n, sA, ai, aj)

print the transposed of a strmat

blasfeo_print_tran_dvec(m, sa, ai)

print the transposed of a strvec

blasfeo_print_tran_smat(m, n, sA, ai, aj)

print the transpose of a strmat

blasfeo_print_tran_svec(m, sa, ai)

print the transposed of a strvec

blasfeo_saxpby(kmax, alpha, sx, xi, beta, sy, yi, sz, zi)

z = betay + alphax

blasfeo_saxpy(kmax, alpha, sx, xi, sy, yi, sz, zi)

z = y + alpha*x

blasfeo_scolex(kmax, sA, ai, aj, sx, xi)

col

blasfeo_scolrot(m, sA, ai, aj0, aj1, c, s)

apply plane rotation [a b] [c -s; s; c] to the aj0 and aj1 columns of A at row index ai

blasfeo_sdiare(kmax, alpha, sA, ai, aj)

dia

blasfeo_sdot(m, sx, xi, sy, yi)

return x^T * y

blasfeo_sgelqf(m, n, sC, ci, cj, sD, di, dj, work)

D <= lq( C )

blasfeo_sgelqf_pd(m, n, sC, ci, cj, sD, di, dj, work)

D <= lq( C ), positive diagonal elements

blasfeo_sgelqf_pd_la(m, n1, sL, li, lj, sA, ai, aj, work)

[L, A] <= lq( [L, A] ), positive diagonal elements, array of matrices, with L lower triangular, of size (m)x(m) A full, of size (m)x(n1)

blasfeo_sgelqf_pd_lla(m, n1, sL0, l0i, l0j, sL1, l1i, l1j, sA, ai, aj, work)

[L, L, A] <= lq( [L, L, A] ), positive diagonal elements, array of matrices, with: L lower triangular, of size (m)x(m) A full, of size (m)x(n1)

blasfeo_sgemm_nd(m, n, alpha, sA, ai, aj, sB, bi, beta, sC, ci, cj, sD, di, dj)

D <= alpha * A * B + beta * C, with B diagonal (stored as strvec)

blasfeo_sgemm_nn(m, n, k, alpha, sA, ai, aj, sB, bi, bj, beta, sC, ci, cj, sD, di, dj)

D <= beta * C + alpha * A * B

blasfeo_sgemm_nt(m, n, k, alpha, sA, ai, aj, sB, bi, bj, beta, sC, ci, cj, sD, di, dj)

D <= beta * C + alpha * A * B^T

blasfeo_sgemm_tn(m, n, k, alpha, sA, ai, aj, sB, bi, bj, beta, sC, ci, cj, sD, di, dj)

D <= beta * C + alpha * A^T * B

blasfeo_sgemm_tt(m, n, k, alpha, sA, ai, aj, sB, bi, bj, beta, sC, ci, cj, sD, di, dj)

D <= beta * C + alpha * A^T * B

blasfeo_sgemv_d(m, alpha, sA, ai, sx, xi, beta, sy, yi, sz, zi)

z <= beta * y + alpha * A * x, A diagonal

blasfeo_sgemv_n(m, n, alpha, sA, ai, aj, sx, xi, beta, sy, yi, sz, zi)

z <= beta * y + alpha * A * x

blasfeo_sgemv_nt(m, n, alpha_n, alpha_t, sA, ai, aj, sx_n, xi_n, sx_t, xi_t, beta_n, beta_t, sy_n, yi_n, sy_t, yi_t, sz_n, zi_n, sz_t, zi_t)

zn <= betan * yn + alphan * A * xn zt <= betat * yt + alphat * A' * xt

blasfeo_sgemv_t(m, n, alpha, sA, ai, aj, sx, xi, beta, sy, yi, sz, zi)

z <= beta * y + alpha * A' * x

blasfeo_sgeqrf(m, n, sC, ci, cj, sD, di, dj, work)

D <= qr( C )

blasfeo_sger(m, n, alpha, sx, xi, sy, yi, sC, ci, cj, sD, di, dj)

D = C + alpha * x * y^T

blasfeo_sgese(m, n, alpha, sA, ai, aj)

ge

blasfeo_sgetrf_np(m, n, sC, ci, cj, sD, di, dj)

D <= lu( C ) ; no pivoting

blasfeo_sgetrf_rp(m, n, sC, ci, cj, sD, di, dj, ipiv)

D <= lu( C ) ; row pivoting

blasfeo_sorglq_worksize(m, n, k)

D <= Q factor, where C is the output of the LQ factorization

blasfeo_spotrf_l(m, sC, ci, cj, sD, di, dj)

D <= chol( C ) ; C, D lower triangular

blasfeo_spotrf_u(m, sC, ci, cj, sD, di, dj)

D <= chol( C ) ; C, D upper triangular

blasfeo_srotg(a, b, c, s)

construct givens plane rotation

blasfeo_srowin(kmax, alpha, sx, xi, sA, ai, aj)

row

blasfeo_srowrot(m, sA, ai0, ai1, aj, c, s)

apply plane rotation [c s; -s c] [a; b] to the ai0 and ai1 rows of A at column index aj

blasfeo_ssymv_l(m, alpha, sA, ai, aj, sx, xi, beta, sy, yi, sz, zi)

z <= beta * y + alpha * A * x, where A is symmetric and only the lower triangular patr of A is accessed

blasfeo_ssymv_u(m, alpha, sA, ai, aj, sx, xi, beta, sy, yi, sz, zi)

z <= beta * y + alpha * A * x, where A is symmetric and only the upper triangular patr of A is accessed

blasfeo_ssyr2k_ln(m, k, alpha, sA, ai, aj, sB, bi, bj, beta, sC, ci, cj, sD, di, dj)

D <= beta * C + alpha * A * B^T + alpha * B * A^T; C, D lower triangular

blasfeo_ssyr2k_lt(m, k, alpha, sA, ai, aj, sB, bi, bj, beta, sC, ci, cj, sD, di, dj)

D <= beta * C + alpha * A^T * B + alpha * B^T * A; C, D lower triangular

blasfeo_ssyr2k_un(m, k, alpha, sA, ai, aj, sB, bi, bj, beta, sC, ci, cj, sD, di, dj)

D <= beta * C + alpha * A * B^T + alpha * B * A^T; C, D upper triangular

blasfeo_ssyr2k_ut(m, k, alpha, sA, ai, aj, sB, bi, bj, beta, sC, ci, cj, sD, di, dj)

D <= beta * C + alpha * A^T * B + alpha * B^T * A; C, D upper triangular

blasfeo_ssyrk_ln(m, k, alpha, sA, ai, aj, sB, bi, bj, beta, sC, ci, cj, sD, di, dj)

D <= beta * C + alpha * A * B^T ; C, D lower triangular

blasfeo_ssyrk_lt(m, k, alpha, sA, ai, aj, sB, bi, bj, beta, sC, ci, cj, sD, di, dj)

D <= beta * C + alpha * A^T * B ; C, D lower triangular

blasfeo_ssyrk_spotrf_ln(m, k, sA, ai, aj, sB, bi, bj, sC, ci, cj, sD, di, dj)

D <= chol( C + A * B' ) ; C, D lower triangular

blasfeo_ssyrk_un(m, k, alpha, sA, ai, aj, sB, bi, bj, beta, sC, ci, cj, sD, di, dj)

D <= beta * C + alpha * A * B^T ; C, D upper triangular

blasfeo_ssyrk_ut(m, k, alpha, sA, ai, aj, sB, bi, bj, beta, sC, ci, cj, sD, di, dj)

D <= beta * C + alpha * A^T * B ; C, D upper triangular

blasfeo_strcp_l(m, sA, ai, aj, sC, ci, cj)

tr

blasfeo_strmm_llnn(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * A * B ; A lower triangular

blasfeo_strmm_llnu(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * A * B ; A lower triangular assuming unit diagonal

blasfeo_strmm_lltn(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * A^T * B ; A lower triangular

blasfeo_strmm_lltu(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * A^T * B ; A lower triangular assuming unit diagonal

blasfeo_strmm_lunn(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * A * B ; A upper triangular

blasfeo_strmm_lunu(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * A * B ; A upper triangular assuming unit diagonal

blasfeo_strmm_lutn(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * A^T * B ; A upper triangular

blasfeo_strmm_lutu(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * A^T * B ; A upper triangular assuming unit diagonal

blasfeo_strmm_rlnn(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * B * A ; A lower triangular

blasfeo_strmm_rlnu(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * B * A ; A lower triangular assuming unit diagonal

blasfeo_strmm_rltn(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * B * A^T ; A lower triangular

blasfeo_strmm_rltu(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * B * A^T ; A lower triangular assuming unit diagonal

blasfeo_strmm_runn(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * B * A ; A upper triangular

blasfeo_strmm_runu(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * B * A ; A upper triangular assuming unit diagonal

blasfeo_strmm_rutn(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * B * A^T ; A upper triangular

blasfeo_strmm_rutu(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * B * A^T ; A upper triangular assuming unit diagonal

blasfeo_strmv_lnn(m, sA, ai, aj, sx, xi, sz, zi)

z <= A * x ; A lower triangular

blasfeo_strmv_lnu(m, sA, ai, aj, sx, xi, sz, zi)

z <= A * x ; A lower triangular, assuming unit diagonal

blasfeo_strmv_ltn(m, sA, ai, aj, sx, xi, sz, zi)

z <= A' * x ; A lower triangular

blasfeo_strmv_ltu(m, sA, ai, aj, sx, xi, sz, zi)

z <= A' * x ; A lower triangular, assuming unit diagonal

blasfeo_strmv_unn(m, sA, ai, aj, sx, xi, sz, zi)

z <= beta * y + alpha * A * x ; A upper triangular

blasfeo_strmv_utn(m, sA, ai, aj, sx, xi, sz, zi)

z <= A' * x ; A upper triangular

blasfeo_strsm_llnn(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * A^{-1} * B , with A lower triangular employint explicit inverse of diagonal

blasfeo_strsm_llnu(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * A^{-1} * B , with A lower triangular assuming unit diagonal

blasfeo_strsm_lltn(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * A^{-T} * B , with A lower triangular employint explicit inverse of diagonal

blasfeo_strsm_lltu(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * A^{-T} * B , with A lower triangular assuming unit diagonal

blasfeo_strsm_lunn(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * A^{-1} * B , with A upper triangular employing explicit inverse of diagonal

blasfeo_strsm_lunu(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * A^{-1} * B , with A upper triangular assuming unit diagonal

blasfeo_strsm_lutn(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * A^{-T} * B , with A upper triangular employing explicit inverse of diagonal

blasfeo_strsm_lutu(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * A^{-T} * B , with A upper triangular assuming unit diagonal

blasfeo_strsm_rlnn(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * B * A^{-1} , with A lower triangular employing explicit inverse of diagonal

blasfeo_strsm_rlnu(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * B * A^{-1} , with A lower triangular assuming unit diagonal

blasfeo_strsm_rltn(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * B * A^{-T} , with A lower triangular employing explicit inverse of diagonal

blasfeo_strsm_rltu(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * B * A^{-T} , with A lower triangular assuming unit diagonal

blasfeo_strsm_runn(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * B * A^{-1} , with A upper triangular employing explicit inverse of diagonal

blasfeo_strsm_runu(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * B * A^{-1} , with A upper triangular assuming unit diagonal

blasfeo_strsm_rutn(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * B * A^{-T} , with A upper triangular employing explicit inverse of diagonal

blasfeo_strsm_rutu(m, n, alpha, sA, ai, aj, sB, bi, bj, sD, di, dj)

D <= alpha * B * A^{-T} , with A upper triangular assuming unit diagonal

blasfeo_strsv_lnn(m, sA, ai, aj, sx, xi, sz, zi)

z <= inv( A ) * x, A (m)x(m) lower, not_transposed

blasfeo_strsv_lnn_mn(m, n, sA, ai, aj, sx, xi, sz, zi)

z <= inv( A ) * x, A (m)x(n)

blasfeo_strsv_lnu(m, sA, ai, aj, sx, xi, sz, zi)

z <= inv( A ) * x, A (m)x(m) lower, not_transposed, assuming unit diagonal

blasfeo_strsv_ltn(m, sA, ai, aj, sx, xi, sz, zi)

z <= inv( A' ) * x, A (m)x(m) lower, transposed

blasfeo_strsv_ltn_mn(m, n, sA, ai, aj, sx, xi, sz, zi)

z <= inv( A' ) * x, A (m)x(n)

blasfeo_strsv_ltu(m, sA, ai, aj, sx, xi, sz, zi)

z <= inv( A' ) * x, A (m)x(m) lower, transposed, assuming unit diagonal

blasfeo_strsv_unn(m, sA, ai, aj, sx, xi, sz, zi)

z <= inv( A' ) * x, A (m)x(m) upper, not_transposed

blasfeo_strsv_utn(m, sA, ai, aj, sx, xi, sz, zi)

z <= inv( A' ) * x, A (m)x(m) upper, transposed

blasfeo_svecexad_sp(m, alpha, idx, sx, xi, sz, zi)

z += alpha * x[idx]

blasfeo_svecmul(m, sx, xi, sy, yi, sz, zi)

z = x .* y

blasfeo_svecmulacc(m, sx, xi, sy, yi, sz, zi)

z += x .* y

blasfeo_svecmuldot(m, sx, xi, sy, yi, sz, zi)

z = x .* y, return sum(z) = x^T * y

blasfeo_svecse(m, alpha, sx, xi)

vec

blasfeo_unpack_dmat(m, n, sA, ai, aj, B, ldb)

unpack the matrix structure A (at row and col offsets ai and aj) into the column-major matrix B (with leading dimension ldb)

blasfeo_unpack_dvec(m, sx, xi, y, incy)

unpack the vector structure x (at offset xi) into the vector y (using increment incy)

blasfeo_unpack_smat(m, n, sA, ai, aj, A, lda)

unpack the matrix structure A (at row and col offsets ai and aj) into the column-major matrix B (with leading dimension ldb)

blasfeo_unpack_svec(m, sa, ai, x, xi)

unpack the vector structure x (at offset xi) into the vector y (using increment incy)

blasfeo_unpack_tran_dmat(m, n, sA, ai, aj, B, ldb)

transpose and unpack the matrix structure A (at row and col offsets ai and aj) into the column-major matrix B (with leading dimension ldb)

blasfeo_unpack_tran_smat(m, n, sA, ai, aj, A, lda)

transpose and unpack the matrix structure A (at row and col offsets ai and aj) into the column-major matrix B (with leading dimension ldb)

d_free(pA)

free the memory allocated by d_zeros

d_free_align(pA)

free the memory allocated by dzerosalign or dzerosalign_bytes

d_print_exp_mat(m, n, A, lda)

print in exponential notation a column-major matrix

d_print_exp_tran_mat(row, col, A, lda)

print in exponential notation the transposed of a column-major matrix

d_print_mat(m, n, A, lda)

print a column-major matrix

d_print_to_file_exp_mat(file, row, col, A, lda)

print to file a column-major matrix in exponential format

d_print_to_file_mat(file, row, col, A, lda)

print to file a column-major matrix

d_print_to_string_mat(buf_out, row, col, A, lda)

print to string a column-major matrix

d_print_tran_mat(row, col, A, lda)

print the transposed of a column-major matrix

d_print_tran_to_file_exp_mat(file, row, col, A, lda)

print to file the transposed of a column-major matrix in exponential format

d_print_tran_to_file_mat(file, row, col, A, lda)

print to file the transposed of a column-major matrix

d_zeros(pA, row, col)

dynamically allocate row*col doubles of memory and set accordingly a pointer to double; set allocated memory to zero

d_zeros_align(pA, row, col)

dynamically allocate row*col doubles of memory aligned to 64-byte boundaries and set accordingly a pointer to double; set allocated memory to zero

d_zeros_align_bytes(pA, size)

dynamically allocate size bytes of memory aligned to 64-byte boundaries and set accordingly a pointer to double; set allocated memory to zero

ddiain_sqrt_lib(kmax, x, offset, pD, sdd)

TODO remove ???

ddiareg_lib(kmax, reg, offset, pD, sdd)

TODO ddiaad1

dgemm_diag_left_lib(m, n, alpha, dA, pB, sdb, beta, pC, sdc, pD, sdd)

D <= alpha * A * B + beta * C, with A diagonal (stored as strvec)

s_free(pA)

free the memory allocated by d_zeros

s_free_align(pA)

free the memory allocated by dzerosalign or dzerosalign_bytes

s_print_exp_mat(m, n, A, lda)

print in exponential notation a column-major matrix

s_print_exp_tran_mat(row, col, A, lda)

print in exponential notation the transposed of a column-major matrix

s_print_mat(m, n, A, lda)

print a column-major matrix

s_print_to_file_exp_mat(file, row, col, A, lda)

print to file a column-major matrix in exponential format

s_print_to_file_mat(file, row, col, A, lda)

print to file a column-major matrix

s_print_to_string_mat(buf_out, row, col, A, lda)

print to string a column-major matrix

s_print_tran_mat(row, col, A, lda)

print the transposed of a column-major matrix

s_print_tran_to_file_exp_mat(file, row, col, A, lda)

print to file the transposed of a column-major matrix in exponential format

s_print_tran_to_file_mat(file, row, col, A, lda)

print to file the transposed of a column-major matrix

s_zeros(pA, row, col)

dynamically allocate row*col floats of memory and set accordingly a pointer to float; set allocated memory to zero

s_zeros_align(pA, row, col)

dynamically allocate row*col floats of memory aligned to 64-byte boundaries and set accordingly a pointer to float; set allocated memory to zero

s_zeros_align_bytes(pA, size)

dynamically allocate size bytes of memory aligned to 64-byte boundaries and set accordingly a pointer to float; set allocated memory to zero

sgemm_diag_left_ib(m, n, alpha, dA, pB, sdb, beta, pC, sdc, pD, sdd)

D <= alpha * A * B + beta * C, with A diagonal (stored as strvec)

strcp_l_lib(m, alpha, offsetA, A, sda, offsetB, B, sdb)

TODO remove

blasfeo_cm_dmat

Explicitly column-major matrix structure

blasfeo_dmat

matrix structure

blasfeo_dvec

vector structure

blasfeo_pm_dmat

Explicitly panel-major matrix structure