(index ("scopy" 0) ("dcopy" 69) ("ccopy" 138) ("zcopy" 207) ("srot" 498) ("drot" 599) ("sscal" 1079) ("dscal" 1159) ("cscal" 1239) ("zscal" 1319) ("sswap" 1477) ("dswap" 1560) ("cswap" 1643) ("zswap" 1726) ("sdot" 1891) ("ddot" 1969) ("cdotu" 2176) ("zdotu" 2256) ("cdotc" 2470) ("zdotc" 2550) ("saxpy" 2819) ("daxpy" 2910) ("caxpy" 3001) ("zaxpy" 3092) ("siaxpy" 3288) ("diaxpy" 3395) ("ciaxpy" 3502) ("ziaxpy" 3609) ("snrm2" 3905) ("dnrm2" 3974) ("cnrm2" 4043) ("znrm2" 4112) ("sasum" 4247) ("dasum" 4316) ("casum" 4385) ("zasum" 4454) ("samax" 4597) ("damax" 4665) ("camax" 4733) ("zamax" 4801) ("sgemv" 5002) ("dgemv" 5130) ("cgemv" 5258) ("zgemv" 5386) ("sgbmv" 6189) ("dgbmv" 6327) ("cgbmv" 6465) ("zgbmv" 6603) ("chemv" 7490) ("zhemv" 7613) ("chbmv" 8125) ("zhbmv" 8252) ("ssymv" 8809) ("dsymv" 8933) ("ssbmv" 9348) ("dsbmv" 9476) ("strmv" 9937) ("dtrmv" 10050) ("ctrmv" 10163) ("ztrmv" 10276) ("stbmv" 10758) ("dtbmv" 10875) ("ctbmv" 10992) ("ztbmv" 11109) ("strsv" 11636) ("dtrsv" 11758) ("ctrsv" 11872) ("ztrsv" 11986) ("stbsv" 12358) ("dtbsv" 12476) ("ctbsv" 12594) ("ztbsv" 12712) ("sger" 13125) ("dger" 13236) ("siger" 13605) ("diger" 13732) ("cgeru" 14134) ("zgeru" 14247) ("cgerc" 14619) ("zgerc" 14732) ("cher" 15111) ("zher" 15214) ("cher2" 15554) ("zher2" 15670) ("ssyr" 16067) ("dsyr" 16170) ("ssyr2" 16503) ("dsyr2" 16619) ("sgemm" 16995) ("dgemm" 17135) ("cgemm" 17275) ("zgemm" 17415) ("ssymm" 18024) ("dsymm" 18156) ("csymm" 18288) ("zsymm" 18420) ("ssyrk" 18858) ("dsyrk" 18987) ("csyrk" 19116) ("zsyrk" 19245) ("cherk" 19688) ("zherk" 19817) ("ssyr2k" 20279) ("dsyr2k" 20414) ("csyr2k" 20549) ("zsyr2k" 20684) ("cher2k" 21157) ("zher2k" 21292) ("strmm" 21779) ("dtrmm" 21910) ("ctrmm" 22041) ("ztrmm" 22172) ("strsm" 22579) ("dtrsm" 22718) ("ctrsm" 22857) ("ztrsm" 22996))
(def (sig (procedure "scopy:: F32VECTOR -> F32VECTOR " (id scopy))))
(def (sig (procedure "dcopy:: F64VECTOR -> F64VECTOR " (id dcopy))))
(def (sig (procedure "ccopy:: F32VECTOR -> F32VECTOR " (id ccopy))))
(def (sig (procedure "zcopy:: F64VECTOR -> F64VECTOR " (id zcopy))) (p "These procedures return a copy of given input SRFI-4 vector. The returned vector is allocated with the corresponding SRFI-4 constructor, and the input vector is copied to it by the corresponding BLAS copy procedure."))
(def (sig (procedure "srot:: N * X * Y * C * S [INCX * INCY] -> F32VECTOR * F32VECTOR " (id srot))))
(def (sig (procedure "drot:: N * X * Y * C * S [INCX * INCY] -> F64VECTOR * F64VECTOR " (id drot))) (p (tt "xROT") " applies a plane rotation matrix to a sequence of ordered pairs: " (tt "(x_i , y_i)") ", for " (tt "i = 1, 2, ..., n") ".") (p (tt "X") " and " (tt "Y") " are vector of dimensions " (tt "(N-1) * abs(incx) + 1") " and " (tt "(N-1) * abs(incy) + 1") ", respectively.") (p (tt "C") " and " (tt "S") " are respectively the cosine and sine of the plane of rotation."))
(def (sig (procedure "sscal:: N * ALPHA * X [INCX] -> F32VECTOR " (id sscal))))
(def (sig (procedure "dscal:: N * ALPHA * X [INCX] -> F64VECTOR " (id dscal))))
(def (sig (procedure "cscal:: N * ALPHA * X [INCX] -> F32VECTOR " (id cscal))))
(def (sig (procedure "zscal:: N * ALPHA * X [INCX] -> F64VECTOR " (id zscal))) (p (tt "xSCAL") " scales a vector with a scalar: " (tt "x := alpha * x") "."))
(def (sig (procedure "sswap:: N * X * Y [INCX * INCY] -> F32VECTOR " (id sswap))))
(def (sig (procedure "dswap:: N * X * Y [INCX * INCY] -> F64VECTOR " (id dswap))))
(def (sig (procedure "cswap:: N * X * Y [INCX * INCY] -> F32VECTOR " (id cswap))))
(def (sig (procedure "zswap:: N * X * Y [INCX * INCY] -> F64VECTOR " (id zswap))) (p (tt "xSWAP") " interchanges the elements of two vectors: " (tt "x <-> y") "."))
(def (sig (procedure "sdot:: N * X * Y [INCX * INCY] -> NUMBER " (id sdot))))
(def (sig (procedure "ddot:: N * X * Y [INCX * INCY] -> NUMBER " (id ddot))) (p (tt "xDOT") " computes the dot product of two vectors of real values: " (tt "dot := x'*y = \\Sum_{i=1}^{n} (x_i * y_i)") "."))
(def (sig (procedure "cdotu:: N * X * Y [INCX * INCY] -> NUMBER " (id cdotu))))
(def (sig (procedure "zdotu:: N * X * Y [INCX * INCY] -> NUMBER " (id zdotu))) (p (tt "xDOTU") " computes the dot product of two vectors of complex values: " (tt "dotu := x'*y = \\Sum_{i=1}^{n} (x_i * y_i)") "."))
(def (sig (procedure "cdotc:: N * X * Y [INCX * INCY] -> NUMBER " (id cdotc))))
(def (sig (procedure "zdotc:: N * X * Y [INCX * INCY] -> NUMBER " (id zdotc))) (p (tt "xDOTC") " computes the dot product of the conjugates of two complex vectors: " (tt "dotu := conjg(x')*y = \\Sum_{i=1}^{n} (conjg(x_i) * y_i)") ", for " (tt "i = 1, 2, ..., n") "."))
(def (sig (procedure "saxpy:: N * ALPHA * X * Y [INCX * INCY] -> F32VECTOR " (id saxpy))))
(def (sig (procedure "daxpy:: N * ALPHA * X * Y [INCX * INCY] -> F64VECTOR " (id daxpy))))
(def (sig (procedure "caxpy:: N * ALPHA * X * Y [INCX * INCY] -> F32VECTOR " (id caxpy))))
(def (sig (procedure "zaxpy:: N * ALPHA * X * Y [INCX * INCY] -> F64VECTOR " (id zaxpy))) (p (tt "xAXPY") " adds a scalar multiple of a vector to another vector: " (tt "y := alpha * x + y") "."))
(def (sig (procedure "siaxpy:: N * ALPHA * X * Y [INCX * INCY * XOFS * YOFS] -> F32VECTOR " (id siaxpy))))
(def (sig (procedure "diaxpy:: N * ALPHA * X * Y [INCX * INCY * XOFS * YOFS] -> F64VECTOR " (id diaxpy))))
(def (sig (procedure "ciaxpy:: N * ALPHA * X * Y [INCX * INCY * XOFS * YOFS] -> F32VECTOR " (id ciaxpy))))
(def (sig (procedure "ziaxpy:: N * ALPHA * X * Y [INCX * INCY * XOFS * YOFS] -> F64VECTOR " (id ziaxpy))) (p (tt "xIAXPY") " adds a scalar multiple of a vector to another vector, where the beginning of each vector argument can be offset: " (tt "y[yofs:n] := alpha * x[xofs:n] + y[yofs:n]") "."))
(def (sig (procedure "snrm2:: N * X [INCX] -> NUMBER " (id snrm2))))
(def (sig (procedure "dnrm2:: N * X [INCX] -> NUMBER " (id dnrm2))))
(def (sig (procedure "cnrm2:: N * X [INCX] -> NUMBER " (id cnrm2))))
(def (sig (procedure "znrm2:: N * X [INCX] -> NUMBER " (id znrm2))) (p (tt "xNRM2") " computes the Euclidean (L2) norm of a vector."))
(def (sig (procedure "sasum:: N * X [INCX] -> NUMBER " (id sasum))))
(def (sig (procedure "dasum:: N * X [INCX] -> NUMBER " (id dasum))))
(def (sig (procedure "casum:: N * X [INCX] -> NUMBER " (id casum))))
(def (sig (procedure "zasum:: N * X [INCX] -> NUMBER " (id zasum))) (p (tt "xASUM") " sums the absolute values of the elements in a vector."))
(def (sig (procedure "samax:: N * X [INCX] -> INDEX " (id samax))))
(def (sig (procedure "damax:: N * X [INCX] -> INDEX " (id damax))))
(def (sig (procedure "camax:: N * X [INCX] -> INDEX " (id camax))))
(def (sig (procedure "zamax:: N * X [INCX] -> INDEX " (id zamax))) (p (tt "xAMAX") " searches a vector for the first occurrence of its maximum absolute value, and returns the index of that element."))
(def (sig (procedure "sgemv:: ORDER * TRANS * M * N * ALPHA * A * X * BETA * Y [LDA * INCX * INCY] -> F32VECTOR " (id sgemv))))
(def (sig (procedure "dgemv:: ORDER * TRANS * M * N * ALPHA * A * X * BETA * Y [LDA * INCX * INCY] -> F64VECTOR " (id dgemv))))
(def (sig (procedure "cgemv:: ORDER * TRANS * M * N * ALPHA * A * X * BETA * Y [LDA * INCX * INCY] -> F32VECTOR " (id cgemv))))
(def (sig (procedure "zgemv:: ORDER * TRANS * M * N * ALPHA * A * X * BETA * Y [LDA * INCX * INCY] -> F64VECTOR " (id zgemv))) (p (tt "xGEMV") " performs the matrix-vector multiply-add operation of the form " (tt "y := alpha*op( A )*x + beta*y") ", where " (tt "op( X )") " is one of " (tt "op( A ) = A") " or " (tt "op( A ) = A'") ".") (p (tt "ALPHA") " and " (tt "BETA") " are  scalars, and " (tt "A") " is an " (tt "M x N") " matrix.") (p (tt "X") " is a vector of size " (tt "(1 + ( N - 1 ) * abs(INCX))") " when argument " (tt "TRANS") " is " (tt "NoTrans") ", and " (tt "(1 + ( M - 1 ) * abs(INCX))") " otherwise. " (tt "Y") " is a vector of size " (tt "(1 + ( M - 1 ) * abs(INCY))") " when argument " (tt "TRANS") " is " (tt "NoTrans") ", and " (tt "(1 + ( N - 1 ) * abs(INCY))") " otherwise."))
(def (sig (procedure "sgbmv:: ORDER * TRANS * M * N * KL * KU * ALPHA * A * X * BETA * Y [LDA * INCX * INCY] -> F32VECTOR " (id sgbmv))))
(def (sig (procedure "dgbmv:: ORDER * TRANS * M * N * KL * KU * ALPHA * A * X * BETA * Y [LDA * INCX * INCY] -> F64VECTOR " (id dgbmv))))
(def (sig (procedure "cgbmv:: ORDER * TRANS * M * N * KL * KU * ALPHA * A * X * BETA * Y [LDA * INCX * INCY] -> F32VECTOR " (id cgbmv))))
(def (sig (procedure "zgbmv:: ORDER * TRANS * M * N * KL * KU * ALPHA * A * X * BETA * Y [LDA * INCX * INCY] -> F64VECTOR " (id zgbmv))) (p (tt "xGBMV") " performs the matrix-vector multiply-add operation of the form " (tt "y := alpha*op( A )*x + beta*y") ", where " (tt "op( X )") " is one of " (tt "op( A ) = A") " or " (tt "op( A ) = A'") ".") (p (tt "ALPHA") " and " (tt "BETA") " are scalars, and " (tt "A") " is an " (tt "M x N") " banded matrix, with " (tt "KL") " sub-diagonals and " (tt "KU") " super-diagonals.") (p (tt "X") " is a vector of size " (tt "(1 + ( N - 1 ) * abs(INCX))") " when argument " (tt "TRANS") " is " (tt "NoTrans") ", and " (tt "(1 + ( M - 1 ) * abs(INCX))") " otherwise. " (tt "Y") " is a vector of size " (tt "(1 + ( M - 1 ) * abs(INCY))") " when argument " (tt "TRANS") " is " (tt "NoTrans") ", and " (tt "(1 + ( N - 1 ) * abs(INCY))") " otherwise."))
(def (sig (procedure "chemv:: ORDER * UPLO * N * ALPHA * A * X * BETA * Y [LDA * INCX * INCY] -> F32VECTOR " (id chemv))))
(def (sig (procedure "zhemv:: ORDER * UPLO * N * ALPHA * A * X * BETA * Y [LDA * INCX * INCY] -> F64VECTOR " (id zhemv))) (p (tt "xHEMV") " performs the matrix-vector multiply-add operation of the form " (tt "y := alpha*op( A )*x + beta*y") ", where " (tt "op( X )") " is one of " (tt "op( A ) = A") " or " (tt "op( A ) = A'") ".") (p (tt "ALPHA") " and " (tt "BETA") " are  scalars, and " (tt "A") " is an " (tt "N x N") " Hermitian matrix.") (p (tt "X") " and " (tt "Y") " are " (tt "N") " element vectors."))
(def (sig (procedure "chbmv:: ORDER * UPLO * N * K * ALPHA * A * X * BETA * Y [LDA * INCX * INCY] -> F32VECTOR " (id chbmv))))
(def (sig (procedure "zhbmv:: ORDER * UPLO * N * K * ALPHA * A * X * BETA * Y [LDA * INCX * INCY] -> F64VECTOR " (id zhbmv))) (p (tt "xHBMV") " performs the matrix-vector multiply-add operation of the form " (tt "y := alpha*op( A )*x + beta*y") ", where " (tt "op( X )") " is one of " (tt "op( A ) = A") " or " (tt "op( A ) = A'") ".") (p (tt "ALPHA") " and " (tt "BETA") " are scalars, and " (tt "A") " is an " (tt "N x N") " Hermitian banded matrix, with " (tt "K") " super-diagonals.") (p (tt "X") " and " (tt "Y") " are " (tt "N") " element vectors."))
(def (sig (procedure "ssymv::  ORDER * UPLO * N * ALPHA * A * X * BETA * Y [LDA * INCX * INCY] -> F32VECTOR " (id ssymv))))
(def (sig (procedure "dsymv:: ORDER * UPLO * N * ALPHA * A * X * BETA * Y [LDA * INCX * INCY] -> F64VECTOR " (id dsymv))) (p (tt "xSYMV") " performs matrix-vector multiply-add operation of the form " (tt "y := alpha*A*x + beta*y") ".") (p (tt "ALPHA") " and " (tt "BETA") " are scalars, and " (tt "A") " is an " (tt "N x N") " symmetric matrix.") (p (tt "X") " and " (tt "Y") " are " (tt "N") " element vectors."))
(def (sig (procedure "ssbmv::  ORDER * UPLO * N * K * ALPHA * A * X * BETA * Y [LDA * INCX * INCY] -> F32VECTOR " (id ssbmv))))
(def (sig (procedure "dsbmv:: ORDER * UPLO * N * K * ALPHA * A * X * BETA * Y [LDA * INCX * INCY] -> F64VECTOR " (id dsbmv))) (p (tt "xSBMV") " performs matrix-vector multiply-add operation of the form " (tt "y := alpha*A*B + beta*y") ".") (p (tt "ALPHA") " and " (tt "BETA") " are scalars, and " (tt "A") " is an " (tt "N x N") " symmetric banded matrix, with " (tt "K") " super-diagonals.") (p (tt "X") " and " (tt "Y") " are " (tt "N") " element vectors."))
(def (sig (procedure "strmv::  ORDER * UPLO * TRANS * DIAG * N * A * X [LDA * INCX] -> F32VECTOR " (id strmv))))
(def (sig (procedure "dtrmv::  ORDER * UPLO * TRANS * DIAG * N * A * X [LDA * INCX] -> F64VECTOR " (id dtrmv))))
(def (sig (procedure "ctrmv::  ORDER * UPLO * TRANS * DIAG * N * A * X [LDA * INCX] -> F32VECTOR " (id ctrmv))))
(def (sig (procedure "ztrmv::  ORDER * UPLO * TRANS * DIAG * N * A * X [LDA * INCX] -> F64VECTOR " (id ztrmv))) (p (tt "xTRMV") " performs matrix-vector multiply-add operation of the form " (tt "y := alpha*op( A )*x") ", where " (tt "op ( A ) = A") " or " (tt "op ( A ) = A'")) (p (tt "ALPHA") " and " (tt "BETA") " are scalars, and " (tt "A") " is an " (tt "N x N") " upper or lower triangular matrix.") (p (tt "X") " is a vector of length " (tt "(1 + (n - 1) * abs(INCX))") "."))
(def (sig (procedure "stbmv::  ORDER * UPLO * TRANS * DIAG * N * K * A * X [LDA * INCX] -> F32VECTOR " (id stbmv))))
(def (sig (procedure "dtbmv::  ORDER * UPLO * TRANS * DIAG * N * K * A * X [LDA * INCX] -> F64VECTOR " (id dtbmv))))
(def (sig (procedure "ctbmv::  ORDER * UPLO * TRANS * DIAG * N * K * A * X [LDA * INCX] -> F32VECTOR " (id ctbmv))))
(def (sig (procedure "ztbmv::  ORDER * UPLO * TRANS * DIAG * N * K * A * X [LDA * INCX] -> F64VECTOR " (id ztbmv))) (p (tt "xTBMV") " performs matrix-vector multiply-add operation of the form " (tt "y := alpha*A*B + beta*y") ", where " (tt "op ( A ) = A") " or " (tt "op ( A ) = A'")) (p (tt "ALPHA") " and " (tt "BETA") " are scalars, and " (tt "A") " is an " (tt "N x N") " upper or lower triangular banded matrix, with " (tt "K+1") " diagonals.") (p (tt "X") " is a vector of length " (tt "(1 + (n - 1) * abs(INCX))") "."))
(def (sig (procedure "strsv:: ORDER * UPLO * TRANS * DIAG * N * ALPHA * A * B * [LDA * INCB] -> F32VECTOR " (id strsv))))
(def (sig (procedure "dtrsv:: ORDER * UPLO * TRANS * DIAG * N * A * B * [LDA * INCB] -> F64VECTOR " (id dtrsv))))
(def (sig (procedure "ctrsv:: ORDER * UPLO * TRANS * DIAG * N * A * B * [LDA * INCB] -> F32VECTOR " (id ctrsv))))
(def (sig (procedure "ztrsv:: ORDER * UPLO * TRANS * DIAG * N * A * B * [LDA * INCB] -> F64VECTOR " (id ztrsv))) (p (tt "xTRSV") " solves one of the systems of equations " (tt "A*x = b") " or " (tt "A'*x = b") ".") (p (tt "ALPHA") " and " (tt "BETA") " are scalars, " (tt "A") " is a upper or lower triangular matrix, and " (tt "B") " is a " (tt "N") " element vector."))
(def (sig (procedure "stbsv:: ORDER * UPLO * TRANS * DIAG * N * K * A * B * [LDA * INCB] -> F32VECTOR " (id stbsv))))
(def (sig (procedure "dtbsv:: ORDER * UPLO * TRANS * DIAG * N * K * A * B * [LDA * INCB] -> F64VECTOR " (id dtbsv))))
(def (sig (procedure "ctbsv:: ORDER * UPLO * TRANS * DIAG * N * K * A * B * [LDA * INCB] -> F32VECTOR " (id ctbsv))))
(def (sig (procedure "ztbsv:: ORDER * UPLO * TRANS * DIAG * N * K * A * B * [LDA * INCB] -> F64VECTOR " (id ztbsv))) (p (tt "xTBSV") " solves one of the systems of equations " (tt "A*x = b") " or " (tt "A'*x = b") ".") (p (tt "ALPHA") " and " (tt "BETA") " are scalars, " (tt "A") " is a upper or lower banded triangular matrix with " (tt "K+1") " diagonals, and " (tt "B") " is a " (tt "N") " element vector."))
(def (sig (procedure "sger:: ORDER * M * N * ALPHA * X * Y * A [LDA * INCX * INCY] -> F32VECTOR " (id sger))))
(def (sig (procedure "dger:: ORDER * M * N * ALPHA * X * Y * A [LDA * INCX * INCY] -> F64VECTOR " (id dger))) (p (tt "xGER") " performs the rank 1 operation " (tt "A := alpha*x*y' + A") ".") (p (tt "ALPHA") " is a scalar, " (tt "X") " is an " (tt "M") " element vector, " (tt "Y") " is an " (tt "N") " element vector, and " (tt "A") " is an " (tt "M x N") " matrix."))
(def (sig (procedure "siger:: ORDER * M * N * ALPHA * X * Y * A [LDA * INCX * INCY * XOFS * YOFS] -> F32VECTOR " (id siger))))
(def (sig (procedure "diger:: ORDER * M * N * ALPHA * X * Y * A [LDA * INCX * INCY * XOFS * YOFS] -> F64VECTOR " (id diger))) (p (tt "xIGER") " performs the rank 1 operation " (tt "A := alpha*x[xofs:M]*y'[yofs:N] + A") ".") (p (tt "ALPHA") " is a scalar, " (tt "X") " is an " (tt "M") " element vector, " (tt "Y") " is an " (tt "N") " element vector, and " (tt "A") " is an " (tt "M x N") " matrix."))
(def (sig (procedure "cgeru:: ORDER * M * N * ALPHA * X * Y * A [LDA * INCX * INCY] -> F32VECTOR " (id cgeru))))
(def (sig (procedure "zgeru:: ORDER * M * N * ALPHA * X * Y * A [LDA * INCX * INCY] -> F64VECTOR " (id zgeru))) (p (tt "xGERU") " performs the rank 1 operation " (tt "A := alpha*x*y' + A") ".") (p (tt "ALPHA") " is a scalar, " (tt "X") " is an " (tt "M") " element vector, " (tt "Y") " is an " (tt "N") " element vector, and " (tt "A") " is an " (tt "M x N") " matrix."))
(def (sig (procedure "cgerc:: ORDER * M * N * ALPHA * X * Y * A [LDA * INCX * INCY] -> F32VECTOR " (id cgerc))))
(def (sig (procedure "zgerc:: ORDER * M * N * ALPHA * X * Y * A [LDA * INCX * INCY] -> F64VECTOR " (id zgerc))) (p (tt "xGERC") " performs the rank 1 operation " (tt "A := alpha*x*conjg(y') + A") ".") (p (tt "ALPHA") " is a scalar, " (tt "X") " is an " (tt "M") " element vector, " (tt "Y") " is an " (tt "N") " element vector, and " (tt "A") " is an " (tt "M x N") " matrix."))
(def (sig (procedure "cher:: ORDER * UPLO * N * ALPHA * X * A [LDA * INCX] -> F32VECTOR " (id cher))))
(def (sig (procedure "zher:: ORDER * UPLO * N * ALPHA * X * A [LDA * INCX] -> F64VECTOR " (id zher))) (p (tt "xHER") " performs the Hermitian rank 1 operation " (tt "A := alpha*x*conjg(x') + A") ".") (p (tt "ALPHA") " is a scalar, " (tt "X") " is an " (tt "N") " element vector, and " (tt "A") " is an " (tt "N x N") " Hermitian matrix."))
(def (sig (procedure "cher2:: ORDER * UPLO * N * ALPHA * X * Y * A [LDA * INCX * INCY] -> F32VECTOR " (id cher2))))
(def (sig (procedure "zher2:: ORDER * UPLO * N * ALPHA * X * Y * A [LDA * INCX * INCY] -> F64VECTOR " (id zher2))) (p (tt "xHER2") " performs the Hermitian rank 2 operation " (tt "A := alpha*x*conjg(y') + conjg(alpha)*y*conjg(x') + A") ".") (p (tt "ALPHA") " is a scalar, " (tt "X") " and " (tt "Y") " are " (tt "N") " element vectors, and " (tt "A") " is an " (tt "N x N") " Hermitian matrix."))
(def (sig (procedure "ssyr:: ORDER * UPLO * N * ALPHA * X * A [LDA * INCX] -> F32VECTOR " (id ssyr))))
(def (sig (procedure "dsyr:: ORDER * UPLO * N * ALPHA * X * A [LDA * INCX] -> F64VECTOR " (id dsyr))) (p (tt "xSYR") " performs the symmetric rank 1 operation " (tt "A := alpha*x*x' + A") ".") (p (tt "ALPHA") " is a scalar, " (tt "X") " is an " (tt "N") " element vector, and " (tt "A") " is an " (tt "N x N") " symmetric matrix."))
(def (sig (procedure "ssyr2:: ORDER * UPLO * N * ALPHA * X * Y * A [LDA * INCX * INCY] -> F32VECTOR " (id ssyr2))))
(def (sig (procedure "dsyr2:: ORDER * UPLO * N * ALPHA * X * Y * A [LDA * INCX * INCY] -> F64VECTOR " (id dsyr2))) (p (tt "xSYR2") " performs the symmetric rank 2 operation " (tt "A := alpha*x*y' + alpha*y*x' + A") ".") (p (tt "ALPHA") " is a scalar, " (tt "X") " and " (tt "Y") " are " (tt "N") " element vectors, and " (tt "A") " is an " (tt "N x N") " symmetric matrix."))
(def (sig (procedure "sgemm:: ORDER * TRANSA * TRANSB * M * N * K * ALPHA * A * B * BETA * C [LDA * LDB * LDC] -> F32VECTOR " (id sgemm))))
(def (sig (procedure "dgemm:: ORDER * TRANSA * TRANSB * M * N * K * ALPHA * A * B * BETA * C [LDA * LDB * LDC] -> F64VECTOR " (id dgemm))))
(def (sig (procedure "cgemm:: ORDER * TRANSA * TRANSB * M * N * K * ALPHA * A * B * BETA * C [LDA * LDB * LDC] -> F32VECTOR " (id cgemm))))
(def (sig (procedure "zgemm:: ORDER * TRANSA * TRANSB * M * N * K * ALPHA * A * B * BETA * C [LDA * LDB * LDC] -> F64VECTOR " (id zgemm))) (p (tt "xGEMM") " performs matrix-matrix multiply-add operation of the form " (tt "C := alpha*op( A )*op( B ) + beta*C") ", where " (tt "op( X )") " is one of " (tt "op( X ) = X") " or " (tt "op( X ) = X'") ".") (p (tt "ALPHA") " and " (tt "BETA") " are scalars, and " (tt "A") ", " (tt "B") " and " (tt "C") " are matrices, with " (tt "op( A )") " an " (tt "M x K") " matrix, " (tt "op( B )") " a " (tt "K x N") " matrix and " (tt "C") " an " (tt "M x N") " matrix."))
(def (sig (procedure "ssymm:: ORDER * SIDE * UPLO * M * N * ALPHA * A * B * BETA * C [LDA * LDB * LDC] -> F32VECTOR " (id ssymm))))
(def (sig (procedure "dsymm:: ORDER * SIDE * UPLO * M * N * ALPHA * A * B * BETA * C [LDA * LDB * LDC] -> F64VECTOR " (id dsymm))))
(def (sig (procedure "csymm:: ORDER * SIDE * UPLO * M * N * ALPHA * A * B * BETA * C [LDA * LDB * LDC] -> F32VECTOR " (id csymm))))
(def (sig (procedure "zsymm:: ORDER * SIDE * UPLO * M * N * ALPHA * A * B * BETA * C [LDA * LDB * LDC] -> F64VECTOR " (id zsymm))) (p (tt "xSYMM") " performs matrix-matrix multiply-add operation of the form " (tt "C := alpha*A*B + beta*C") " or " (tt "C := alpha*B*A + beta*C") ".") (p (tt "ALPHA") " and " (tt "BETA") " are scalars, " (tt "A") " is a symmetric matrix, and " (tt "B") " and " (tt "C") " are " (tt "M x N") " matrices."))
(def (sig (procedure "ssyrk:: ORDER * UPLO * TRANS * N * K * ALPHA * A * BETA * C [LDA * LDB * LDC] -> F32VECTOR " (id ssyrk))))
(def (sig (procedure "dsyrk:: ORDER * UPLO * TRANS * N * K * ALPHA * A * BETA * C [LDA * LDB * LDC] -> F64VECTOR " (id dsyrk))))
(def (sig (procedure "csyrk:: ORDER * UPLO * TRANS * N * K * ALPHA * A * BETA * C [LDA * LDB * LDC] -> F64VECTOR " (id csyrk))))
(def (sig (procedure "zsyrk:: ORDER * UPLO * TRANS * N * K * ALPHA * A * BETA * C [LDA * LDB * LDC] -> F64VECTOR " (id zsyrk))) (p (tt "xSYRK") " performs one of the symmetric rank k operations") (pre "{{C := alpha*A*A' + beta*C}} or {{C := alpha*A'*A + beta*C}}. ") (p (tt "ALPHA") " and " (tt "BETA") " are scalars, " (tt "A") " is an " (tt "N x K") " or " (tt "K x N") " matrix, and " (tt "C") " is an " (tt "N x N") " symmetric matrix."))
(def (sig (procedure "cherk:: ORDER * UPLO * TRANS * N * K * ALPHA * A * BETA * C [LDA * LDB * LDC] -> F32VECTOR " (id cherk))))
(def (sig (procedure "zherk:: ORDER * UPLO * TRANS * N * K * ALPHA * A * BETA * C [LDA * LDB * LDC] -> F64VECTOR " (id zherk))) (p (tt "xHERK") " performs one of the hermitian rank k operations " (tt "C := alpha*A*conjg(A') + beta*C") " or " (tt "C := alpha*conjg(A')*A + beta*C") ".") (p (tt "ALPHA") " and " (tt "BETA") " are scalars, " (tt "A") " is an " (tt "N x K") " or " (tt "K x N") " matrix, and " (tt "C") " is an " (tt "N x N") " hermitian matrix."))
(def (sig (procedure "ssyr2k:: ORDER * UPLO * TRANS * N * K * ALPHA * A * B * BETA * C [LDA * LDB * LDC] -> F32VECTOR " (id ssyr2k))))
(def (sig (procedure "dsyr2k:: ORDER * UPLO * TRANS * N * K * ALPHA * A * B * BETA * C [LDA * LDB * LDC] -> F64VECTOR " (id dsyr2k))))
(def (sig (procedure "csyr2k:: ORDER * UPLO * TRANS * N * K * ALPHA * A * B * BETA * C [LDA * LDB * LDC] -> F64VECTOR " (id csyr2k))))
(def (sig (procedure "zsyr2k:: ORDER * UPLO * TRANS * N * K * ALPHA * A * B * BETA * C [LDA * LDB * LDC] -> F64VECTOR " (id zsyr2k))) (p (tt "xSYR2K") " performs one of the symmetric rank 2k operations " (tt "C := alpha*A*B' + beta*C") " or " (tt "C := alpha*B'*A + beta*C") ".") (p (tt "ALPHA") " and " (tt "BETA") " are scalars, " (tt "A") " and " (tt "B") " are " (tt "N x K") " or " (tt "K x N") " matrices, and " (tt "C") " is an " (tt "N x N") " symmetric matrix."))
(def (sig (procedure "cher2k:: ORDER * UPLO * TRANS * N * K * ALPHA * A * B * BETA * C [LDA * LDB * LDC] -> F32VECTOR " (id cher2k))))
(def (sig (procedure "zher2k:: ORDER * UPLO * TRANS * N * K * ALPHA * A * B * BETA * C [LDA * LDB * LDC] -> F64VECTOR " (id zher2k))) (p (tt "xHER2K") " performs one of the hermitian rank 2k operations " (tt "C := alpha*A*conjg(B') + beta*C") " or " (tt "C := alpha*conjg(B')*A + beta*C") ".") (p (tt "ALPHA") " and " (tt "BETA") " are scalars, " (tt "A") " and " (tt "B") " are " (tt "N x K") " or " (tt "K x N") " matrices, and " (tt "C") " is an " (tt "N x N") " hermitian matrix."))
(def (sig (procedure "strmm:: ORDER * SIDE * UPLO * TRANSA * DIAG * M * N * ALPHA * A * B [LDA * LDB] -> F32VECTOR " (id strmm))))
(def (sig (procedure "dtrmm:: ORDER * SIDE * UPLO * TRANSA * DIAG * M * N * ALPHA * A * B [LDA * LDB] -> F64VECTOR " (id dtrmm))))
(def (sig (procedure "ctrmm:: ORDER * SIDE * UPLO * TRANSA * DIAG * M * N * ALPHA * A * B [LDA * LDB] -> F32VECTOR " (id ctrmm))))
(def (sig (procedure "ztrmm:: ORDER * SIDE * UPLO * TRANSA * DIAG * M * N * ALPHA * A * B [LDA * LDB] -> F64VECTOR " (id ztrmm))) (p (tt "xTRMM") " performs matrix-matrix multiply operation of the form " (tt "B := alpha*op( A )*B") " or " (tt "B := alpha*B*op( A )") ".") (p (tt "ALPHA") " is a scalar, " (tt "A") " is an upper or lower triangular matrix, and " (tt "B") " is an " (tt "M x N") " matrix."))
(def (sig (procedure "strsm:: ORDER * SIDE * UPLO * TRANSA * DIAG * M * N * ALPHA * A * B * [LDA * LDB * LDC] -> F32VECTOR " (id strsm))))
(def (sig (procedure "dtrsm:: ORDER * SIDE * UPLO * TRANSA * DIAG * M * N * ALPHA * A * B * [LDA * LDB * LDC] -> F64VECTOR " (id dtrsm))))
(def (sig (procedure "ctrsm:: ORDER * SIDE * UPLO * TRANSA * DIAG * M * N * ALPHA * A * B * [LDA * LDB * LDC] -> F32VECTOR " (id ctrsm))))
(def (sig (procedure "ztrsm:: ORDER * SIDE * UPLO * TRANSA * DIAG * M * N * ALPHA * A * B * [LDA * LDB * LDC] -> F64VECTOR " (id ztrsm))) (p (tt "xTRSM") " solves one of the matrix equations") (pre "{{op( A )*X = alpha*B}} or {{X*op( A ) = alpha*B}}. ") (p (tt "op( A )") " is one of " (tt "op( A ) = A") " or " (tt "op( A ) = A'") ".") (p (tt "ALPHA") " and " (tt "BETA") " are scalars, " (tt "A") " is a upper or lower triangular matrix, and " (tt "B") " is a " (tt "M x N") " matrix."))
