syr2k.hpp

Go to the documentation of this file.

 
//
// Copyright (c) 2017-2021, University of Tennessee. All rights reserved.
// Copyright (c) 2021-2023, University of Colorado Denver. All rights reserved.
//
// This file is part of <T>LAPACK.
// <T>LAPACK 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 TLAPACK_LEGACY_SYR2K_HH
#define TLAPACK_LEGACY_SYR2K_HH
 
#include "tlapack/blas/syr2k.hpp"
#include "tlapack/legacy_api/base/types.hpp"
#include "tlapack/legacy_api/base/utils.hpp"
 
namespace tlapack {
namespace legacy {
 
    template <typename TA, typename TB, typename TC>
    void syr2k(Layout layout,
               Uplo uplo,
               Op trans,
               idx_t n,
               idx_t k,
               scalar_type<TA, TB, TC> alpha,
               TA const* A,
               idx_t lda,
               TB const* B,
               idx_t ldb,
               scalar_type<TA, TB, TC> beta,
               TC* C,
               idx_t ldc)
    {
        using internal::create_matrix;
        using scalar_t = scalar_type<TA, TB, TC>;
 
        // check arguments
        tlapack_check_false(layout != Layout::ColMajor &&
                            layout != Layout::RowMajor);
        tlapack_check_false(uplo != Uplo::Lower && uplo != Uplo::Upper &&
                            uplo != Uplo::General);
        tlapack_check_false(trans != Op::NoTrans && trans != Op::Trans &&
                            trans != Op::ConjTrans);
        tlapack_check_false(is_complex<TA> && trans == Op::ConjTrans);
        tlapack_check_false(n < 0);
        tlapack_check_false(k < 0);
        tlapack_check_false(lda < ((layout == Layout::RowMajor)
                                       ? ((trans == Op::NoTrans) ? k : n)
                                       : ((trans == Op::NoTrans) ? n : k)));
        tlapack_check_false(ldb < ((layout == Layout::RowMajor)
                                       ? ((trans == Op::NoTrans) ? k : n)
                                       : ((trans == Op::NoTrans) ? n : k)));
        tlapack_check_false(ldc < n);
 
        // quick return
        if (n == 0 ||
            ((alpha == scalar_t(0) || k == 0) && (beta == scalar_t(1))))
            return;
 
        // This algorithm only works with Op::NoTrans or Op::Trans
        if (trans == Op::ConjTrans) trans = Op::Trans;
 
        // adapt if row major
        if (layout == Layout::RowMajor) {
            if (uplo == Uplo::Lower)
                uplo = Uplo::Upper;
            else if (uplo == Uplo::Upper)
                uplo = Uplo::Lower;
            trans = (trans == Op::NoTrans) ? Op::Trans : Op::NoTrans;
        }
 
        // Matrix views
        const auto A_ = (trans == Op::NoTrans)
                            ? create_matrix<TA>((TA*)A, n, k, lda)
                            : create_matrix<TA>((TA*)A, k, n, lda);
        const auto B_ = (trans == Op::NoTrans)
                            ? create_matrix<TB>((TB*)B, n, k, ldb)
                            : create_matrix<TB>((TB*)B, k, n, ldb);
        auto C_ = create_matrix<TC>(C, n, n, ldc);
 
        if (alpha == scalar_t(0)) {
            if (beta == scalar_t(0)) {
                for (idx_t j = 0; j < n; ++j)
                    for (idx_t i = 0; i < n; ++i)
                        C_(i, j) = TC(0);
            }
            else {
                for (idx_t j = 0; j < n; ++j)
                    for (idx_t i = 0; i < n; ++i)
                        C_(i, j) *= beta;
            }
        }
        else {
            if (beta == scalar_t(0))
                syr2k(uplo, trans, alpha, A_, B_, C_);
            else
                syr2k(uplo, trans, alpha, A_, B_, beta, C_);
        }
    }
 
}  // namespace legacy
}  // namespace tlapack
 
#endif  //  #ifndef TLAPACK_LEGACY_SYMM_HH