rotm.hpp

Go to the documentation of this file.

 
//
// Copyright (c) 2017-2021, University of Tennessee. All rights reserved.
// Copyright (c) 2025, 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_BLAS_ROTM_HH
#define TLAPACK_BLAS_ROTM_HH
 
#include "tlapack/base/utils.hpp"
 
namespace tlapack {
 
template <
    int flag,
    TLAPACK_VECTOR vectorX_t,
    TLAPACK_VECTOR vectorY_t,
    enable_if_t<((-2 <= flag) && (flag <= 1)), int> = 0,
    class T = type_t<vectorX_t>,
    enable_if_t<is_same_v<T, real_type<T> >, int> = 0,
    disable_if_allow_optblas_t<pair<vectorX_t, T>, pair<vectorY_t, T> > = 0>
void rotm(vectorX_t& x, vectorY_t& y, const T h[4])
{
    using idx_t = size_type<vectorX_t>;
    using scalar_t = scalar_type<T, type_t<vectorX_t>, type_t<vectorY_t> >;
 
    // constants
    const idx_t n = size(x);
 
    // check arguments
    tlapack_check_false(size(y) != n);
 
    if (flag == -1) {
        for (idx_t i = 0; i < n; ++i) {
            const scalar_t stmp = h[0] * x[i] + h[2] * y[i];
            y[i] = h[3] * y[i] + h[1] * x[i];
            x[i] = stmp;
        }
    }
    else if (flag == 0) {
        for (idx_t i = 0; i < n; ++i) {
            const scalar_t stmp = x[i] + h[2] * y[i];
            y[i] = y[i] + h[1] * x[i];
            x[i] = stmp;
        }
    }
    else if (flag == 1) {
        for (idx_t i = 0; i < n; ++i) {
            const scalar_t stmp = h[0] * x[i] + y[i];
            y[i] = h[3] * y[i] - x[i];
            x[i] = stmp;
        }
    }
}
 
#ifdef TLAPACK_USE_LAPACKPP
 
template <
    int flag,
    TLAPACK_LEGACY_VECTOR vectorX_t,
    TLAPACK_LEGACY_VECTOR vectorY_t,
    enable_if_t<((-2 <= flag) && (flag <= 1)), int> = 0,
    class T = type_t<vectorX_t>,
    enable_if_t<is_same_v<T, real_type<T> >, int> = 0,
    enable_if_allow_optblas_t<pair<vectorX_t, T>, pair<vectorY_t, T> > = 0>
void rotm(vectorX_t& x, vectorY_t& y, const T h[4])
{
    // Legacy objects
    auto x_ = legacy_vector(x);
    auto y_ = legacy_vector(y);
 
    // Constants to forward
    const auto& n = x_.n;
    const T h_[] = {(T)flag, h[0], h[1], h[2], h[3]};
 
    return ::blas::rotm(n, x_.ptr, x_.inc, y_.ptr, y_.inc, h_);
}
 
#endif
 
}  // namespace tlapack
 
#endif  //  #ifndef TLAPACK_BLAS_ROTM_HH