/**
    ------------------------------------------------------------
    @defgroup blas1            Level 1: vectors operations, O(n) work
    @brief    Vector operations that perform $O(n)$ work on $O(n)$ data.
              These are memory bound, since every operation requires a memory read or write.
    @{
        @defgroup asum         asum:  Vector 1 norm (sum)
        @brief    $\sum_i |Re(x_i)| + |Im(x_i)|$

        @defgroup axpy         axpy:  Add vectors
        @brief    $y = \alpha x + y$

        @defgroup copy         copy:  Copy vector
        @brief    $y = x$

        @defgroup dot          dot:   Dot (inner) product
        @brief    $x^H y$

        @defgroup dotu         dotu:  Dot (inner) product, unconjugated
        @brief    $x^T y$

        @defgroup iamax        iamax: Find max element
        @brief    $\text{argmax}_i\; |x_i|$

        @defgroup nrm2         nrm2:  Vector 2 norm
        @brief    $||x||_2$

        @defgroup rot          rot:   Apply Givens plane rotation

        @defgroup rotg         rotg:  Generate Givens plane rotation

        @defgroup rotm         rotm:  Apply modified (fast) Givens plane rotation

        @defgroup rotmg        rotmg: Generate modified (fast) Givens plane rotation

        @defgroup scal         scal:  Scale vector
        @brief    $x = \alpha x$

        @defgroup swap         swap:  Swap vectors
        @brief    $x \leftrightarrow y$
    @}

    ------------------------------------------------------------
    @defgroup blas2            Level 2: matrix-vector operations, O(n^2) work
    @brief    Matrix operations that perform $O(n^2)$ work on $O(n^2)$ data.
              These are memory bound, since every operation requires a memory read or write.
    @{
        @defgroup gemv         gemv:       General matrix-vector multiply
        @brief    $y = \alpha Ax + \beta y$

        @defgroup ger          ger:        General matrix rank 1 update
        @brief    $A = \alpha xy^H + A$

        @defgroup geru         geru:       General matrix rank 1 update, unconjugated
        @brief    $A = \alpha xy^T + A$

        @defgroup hemv         hemv:    Hermitian matrix-vector multiply
        @brief    $y = \alpha Ax + \beta y$

        @defgroup her          her:     Hermitian rank 1 update
        @brief    $A = \alpha xx^H + A$

        @defgroup her2         her2:    Hermitian rank 2 update
        @brief    $A = \alpha xy^H + conj(\alpha) yx^H + A$

        @defgroup symv         symv:    Symmetric matrix-vector multiply
        @brief    $y = \alpha Ax + \beta y$

        @defgroup syr          syr:     Symmetric rank 1 update
        @brief    $A = \alpha xx^T + A$

        @defgroup syr2         syr2:    Symmetric rank 2 update
        @brief    $A = \alpha xy^T + \alpha yx^T + A$

        @defgroup trmv         trmv:       Triangular matrix-vector multiply
        @brief    $x = Ax$

        @defgroup trsv         trsv:       Triangular matrix-vector solve
        @brief    $x = op(A^{-1})\; b$
    @}

    ------------------------------------------------------------
    @defgroup blas3            Level 3: matrix-matrix operations, O(n^3) work
    @brief    Matrix-matrix operations that perform $O(n^3)$ work on $O(n^2)$ data.
              These benefit from cache reuse, since many operations can be
              performed for every read from main memory.
    @{
        @defgroup gemm         gemm:  General matrix multiply
        @brief    $C = \alpha \;op(A) \;op(B) + \beta C$

        @defgroup hemm         hemm:  Hermitian matrix multiply
        @brief    $C = \alpha A B + \beta C$
               or $C = \alpha B A + \beta C$ where $A$ is Hermitian

        @defgroup herk         herk:  Hermitian rank k update
        @brief    $C = \alpha A A^H + \beta C$ where $C$ is Hermitian

        @defgroup her2k        her2k: Hermitian rank 2k update
        @brief    $C = \alpha A B^H + conj(\alpha) B A^H + \beta C$ where $C$ is Hermitian

        @defgroup symm         symm:  Symmetric matrix multiply
        @brief    $C = \alpha A B + \beta C$
               or $C = \alpha B A + \beta C$ where $A$ is symmetric

        @defgroup syrk         syrk:  Symmetric rank k update
        @brief    $C = \alpha A A^T + \beta C$ where $C$ is symmetric

        @defgroup syr2k        syr2k: Symmetric rank 2k update
        @brief    $C = \alpha A B^T + \alpha B A^T + \beta C$ where $C$ is symmetric

        @defgroup trmm         trmm:  Triangular matrix multiply
        @brief    $B = \alpha \;op(A)\; B$
               or $B = \alpha B \;op(A)$ where $A$ is triangular

        @defgroup trsm         trsm:  Triangular solve matrix
        @brief    $C = op(A)^{-1} B  $
               or $C = B \;op(A)^{-1}$ where $A$ is triangular
    @}

    ------------------------------------------------------------
    @defgroup blas1_internal            Level 1: internal routines.
    @brief    Internal low-level and mid-level wrappers.
    @{
        @defgroup asum_internal         asum:   Vector 1 norm (sum)
        @defgroup axpy_internal         axpy:   Add vectors
        @defgroup copy_internal         copy:   Copy vector
        @defgroup dot_internal          dot:    Dot (inner) product
        @defgroup dotu_internal         dotu:   Dot (inner) product, unconjugated
        @defgroup iamax_internal        iamax:  Find max element
        @defgroup nrm2_internal         nrm2:   Vector 2 norm
        @defgroup rot_internal          rot:    Apply Givens plane rotation
        @defgroup rotg_internal         rotg:   Generate Givens plane rotation
        @defgroup rotm_internal         rotm:   Apply modified (fast) Givens plane rotation
        @defgroup rotmg_internal        rotmg:  Generate modified (fast) Givens plane rotation
        @defgroup scal_internal         scal:   Scale vector
        @defgroup swap_internal         swap:   Swap vectors
    @}

    ------------------------------------------------------------
    @defgroup blas2_internal            Level 2: internal routines.
    @brief    Internal low-level and mid-level wrappers.
    @{
        @defgroup gemv_internal         gemv:   General matrix-vector multiply
        @defgroup ger_internal          ger:    General matrix rank 1 update
        @defgroup geru_internal         geru:   General matrix rank 1 update, unconjugated
        @defgroup hemv_internal         hemv:   Hermitian matrix-vector multiply
        @defgroup her_internal          her:    Hermitian rank 1 update
        @defgroup her2_internal         her2:   Hermitian rank 2 update
        @defgroup symv_internal         symv:   Symmetric matrix-vector multiply
        @defgroup syr_internal          syr:    Symmetric rank 1 update
        @defgroup syr2_internal         syr2:   Symmetric rank 2 update
        @defgroup trmv_internal         trmv:   Triangular matrix-vector multiply
        @defgroup trsv_internal         trsv:   Triangular matrix-vector solve
    @}

    ------------------------------------------------------------
    @defgroup blas3_internal            Level 3: internal routines.
    @brief    Internal low-level and mid-level wrappers.
    @{
        @defgroup gemm_internal         gemm:   General matrix multiply
        @defgroup hemm_internal         hemm:   Hermitian matrix multiply
        @defgroup herk_internal         herk:   Hermitian rank k update
        @defgroup her2k_internal        her2k:  Hermitian rank 2k update
        @defgroup symm_internal         symm:   Symmetric matrix multiply
        @defgroup syrk_internal         syrk:   Symmetric rank k update
        @defgroup syr2k_internal        syr2k:  Symmetric rank 2k update
        @defgroup trmm_internal         trmm:   Triangular matrix multiply
        @defgroup trsm_internal         trsm:   Triangular solve matrix
    @}
*/
