=============================
BLAS Level 1 Extension: raxpy                                            [TOC]
=============================

*raxpy* (defined in namespace `flens::blas`) computes $y \leftarrow y
+\frac{1}{\alpha} x$ where $x, y$ are vectors and $\alpha$ is a constant
scalar. *raxpy* is short for *r*eciprocal of *a*lpha times *x* *p*lus *y*.

We also provide a variant that does the computation for matrices instead of
vectors.


Vector Variant
==============
*--[CODEREF]----------------------------------------------------------------*
|                                                                           |
|  template <typename ALPHA, typename VX, typename VY>                      |
|      typename RestrictTo<IsDenseVector<VX>::value                         |
|                       && IsDenseVector<VY>::value,                        |
|               void>::Type                                                 |
|      raxpy(const ALPHA &alpha, const VX &x, VY &&y);                      |
|                                                                           |
*---------------------------------------------------------------------------*
                         [c:@N@flens@N@blas@FT@>3#T#T#Traxpy#&1t0.0#&1t0.1#&]
                         [t0.2#templatetypenameALPHA,typenameVX,typenameVYty]
                         [penameRestrictToIsDenseVectorVXvalueandIsDenseVect]
                         [orVYvalue,voidType                                ]

    alpha    `(input) real scalar`                                             +
             Reciprocal scaling factor for the values in $x$.
    x        `(input) real or complex valued DenseVector`                      +
             Vector $x$.
    y        `(input/output) real or complex valued DenseVector`               +
             Vector $y$.


Matrix Variant (Level 1 Extension)
==================================
*--[CODEREF]----------------------------------------------------------------*
|                                                                           |
|  template <typename ALPHA, typename MA, typename MB>                      |
|      typename RestrictTo<IsGeMatrix<MA>::value                            |
|                       && IsGeMatrix<MB>::value,                           |
|               void>::Type                                                 |
|      raxpy(Transpose trans, const ALPHA &alpha, const MA &A, MB &&B);     |
|                                                                           |
*---------------------------------------------------------------------------*
                         [c:@N@flens@N@blas@FT@>3#T#T#Traxpy#$@N@cxxblas@E@T]
                         [ranspose#&1t0.0#&1t0.1#&t0.2#templatetypenameALPHA]
                         [,typenameMA,typenameMBtypenameRestrictToIsGeMatrix]
                         [MAvalueandIsGeMatrixMBvalue,voidType              ]

    trans    `(input)`                                                         +
             Specifiy the operation, i.e.
              NoTrans      $B \leftarrow B + \frac{1}{\alpha}\,A$
              Trans        $B \leftarrow B + \frac{1}{\alpha}\,A^T$
              ConjTrans    $B \leftarrow B + \frac{1}{\alpha}\,A^H$
    alpha    `(input) real scalar`                                             +
             Reciprocal scaling factor for the values in $x$.
    A        `(input) real or complex valued GeMatrix`                         +
             Matrix $A$.
    B        `(input/output) real or complex valued GeMatrix`                  +
             Matrix $B$.