symv.hh

// Copyright (c) 2017-2023, University of Tennessee. All rights reserved.
// SPDX-License-Identifier: BSD-3-Clause
// This program is free software: you can redistribute it and/or modify it under
// the terms of the BSD 3-Clause license. See the accompanying LICENSE file.
 
#ifndef BLAS_SYMV_HH
#define BLAS_SYMV_HH
 
#include "blas/util.hh"
 
#include <limits>
 
namespace blas {
 
// =============================================================================
 
template <typename TA, typename TX, typename TY>
void symv(
    blas::Layout layout,
    blas::Uplo uplo,
    int64_t n,
    blas::scalar_type<TA, TX, TY> alpha,
    TA const *A, int64_t lda,
    TX const *x, int64_t incx,
    blas::scalar_type<TA, TX, TY> beta,
    TY *y, int64_t incy )
{
printf( "%s: %s\n", __func__, __PRETTY_FUNCTION__ );
    typedef blas::scalar_type<TA, TX, TY> scalar_t;
 
    #define A(i_, j_) A[ (i_) + (j_)*lda ]
 
    // constants
    const scalar_t zero = 0;
    const scalar_t one  = 1;
 
    // check arguments
    blas_error_if( layout != Layout::ColMajor &&
                   layout != Layout::RowMajor );
    blas_error_if( uplo != Uplo::Lower &&
                   uplo != Uplo::Upper );
    blas_error_if( n < 0 );
    blas_error_if( lda < n );
    blas_error_if( incx == 0 );
    blas_error_if( incy == 0 );
 
    // quick return
    if (n == 0 || (alpha == zero && beta == one))
        return;
 
    // for row major, swap lower <=> upper
    if (layout == Layout::RowMajor) {
        uplo = (uplo == Uplo::Lower ? Uplo::Upper : Uplo::Lower);
    }
 
    int64_t kx = (incx > 0 ? 0 : (-n + 1)*incx);
    int64_t ky = (incy > 0 ? 0 : (-n + 1)*incy);
 
    // form y = beta*y
    if (beta != one) {
        if (incy == 1) {
            if (beta == zero) {
                for (int64_t i = 0; i < n; ++i) {
                    y[i] = zero;
                }
            }
            else {
                for (int64_t i = 0; i < n; ++i) {
                    y[i] *= beta;
                }
            }
        }
        else {
            int64_t iy = ky;
            if (beta == zero) {
                for (int64_t i = 0; i < n; ++i) {
                    y[iy] = zero;
                    iy += incy;
                }
            }
            else {
                for (int64_t i = 0; i < n; ++i) {
                    y[iy] *= beta;
                    iy += incy;
                }
            }
        }
    }
    if (alpha == zero)
        return;
 
    if (uplo == Uplo::Upper) {
        // A is stored in upper triangle
        // form y += alpha * A * x
        if (incx == 1 && incy == 1) {
            // unit stride
            for (int64_t j = 0; j < n; ++j) {
                scalar_t tmp1 = alpha*x[j];
                scalar_t tmp2 = zero;
                for (int64_t i = 0; i < j; ++i) {
                    y[i] += tmp1 * A(i, j);
                    tmp2 += A(i, j) * x[i];
                }
                y[j] += tmp1 * A(j, j) + alpha * tmp2;
            }
        }
        else {
            // non-unit stride
            int64_t jx = kx;
            int64_t jy = ky;
            for (int64_t j = 0; j < n; ++j) {
                scalar_t tmp1 = alpha*x[jx];
                scalar_t tmp2 = zero;
                int64_t ix = kx;
                int64_t iy = ky;
                for (int64_t i = 0; i < j; ++i) {
                    y[iy] += tmp1 * A(i, j);
                    tmp2 += A(i, j) * x[ix];
                    ix += incx;
                    iy += incy;
                }
                y[jy] += tmp1 * A(j, j) + alpha * tmp2;
                jx += incx;
                jy += incy;
            }
        }
    }
    else {
        // A is stored in lower triangle
        // form y += alpha * A * x
        if (incx == 1 && incy == 1) {
            // unit stride
            for (int64_t j = 0; j < n; ++j) {
                scalar_t tmp1 = alpha*x[j];
                scalar_t tmp2 = zero;
                for (int64_t i = j+1; i < n; ++i) {
                    y[i] += tmp1 * A(i, j);
                    tmp2 += A(i, j) * x[i];
                }
                y[j] += tmp1 * A(j, j) + alpha * tmp2;
            }
        }
        else {
            // non-unit stride
            int64_t jx = kx;
            int64_t jy = ky;
            for (int64_t j = 0; j < n; ++j) {
                scalar_t tmp1 = alpha*x[jx];
                scalar_t tmp2 = zero;
                int64_t ix = jx;
                int64_t iy = jy;
                for (int64_t i = j+1; i < n; ++i) {
                    ix += incx;
                    iy += incy;
                    y[iy] += tmp1 * A(i, j);
                    tmp2 += A(i, j) * x[ix];
                }
                y[jy] += tmp1 * A(j, j) + alpha * tmp2;
                jx += incx;
                jy += incy;
            }
        }
    }
 
    #undef A
}
 
}  // namespace blas
 
#endif        //  #ifndef BLAS_SYMV_HH