types.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_TYPES_HH
#define TLAPACK_TYPES_HH
 
#include <vector>
 
// blfoat16 and float16 are supported by the C++23 standard
#if __has_include(<stdfloat>) && __cplusplus > 202002L
    #include <stdfloat>
#endif
 
#include "tlapack/base/StrongZero.hpp"
#include "tlapack/base/scalar_type_traits.hpp"
 
namespace tlapack {
 
// -----------------------------------------------------------------------------
// Layouts
 
enum class Layout : char {
    Strided = 'S',   
    ColMajor = 'C',  
    RowMajor = 'R',  
    Unspecified = 0  
};
inline std::ostream& operator<<(std::ostream& out, const Layout v)
{
    if (v == Layout::Unspecified) return out << "Unspecified";
    if (v == Layout::ColMajor) return out << "ColMajor";
    if (v == Layout::RowMajor) return out << "RowMajor";
    if (v == Layout::Strided) return out << "Strided";
    return out << "<Invalid>";
}
 
// -----------------------------------------------------------------------------
// Upper or Lower access
 
enum class Uplo : char {
    General = 'G',          
    Upper = 'U',            
    Lower = 'L',            
    UpperHessenberg = 'H',  
    LowerHessenberg = 4,    
    StrictUpper = 'S',      
    StrictLower = 6,        
};
inline std::ostream& operator<<(std::ostream& out, const Uplo v)
{
    if (v == Uplo::Upper) return out << "Upper";
    if (v == Uplo::Lower) return out << "Lower";
    if (v == Uplo::General) return out << "General";
    if (v == Uplo::UpperHessenberg) return out << "UpperHessenberg";
    if (v == Uplo::LowerHessenberg) return out << "LowerHessenberg";
    if (v == Uplo::StrictUpper) return out << "StrictUpper";
    if (v == Uplo::StrictLower) return out << "StrictLower";
    return out << "<Invalid>";
}
 
namespace internal {
    struct GeneralAccess {
        constexpr operator Uplo() const noexcept { return Uplo::General; }
    };
 
    struct UpperTriangle {
        constexpr operator Uplo() const noexcept { return Uplo::Upper; }
    };
 
    struct LowerTriangle {
        constexpr operator Uplo() const noexcept { return Uplo::Lower; }
    };
 
    struct UpperHessenberg {
        constexpr operator Uplo() const noexcept
        {
            return Uplo::UpperHessenberg;
        }
    };
 
    struct LowerHessenberg {
        constexpr operator Uplo() const noexcept
        {
            return Uplo::LowerHessenberg;
        }
    };
 
    struct StrictUpper {
        constexpr operator Uplo() const noexcept { return Uplo::StrictUpper; }
    };
 
    struct StrictLower {
        constexpr operator Uplo() const noexcept { return Uplo::StrictLower; }
    };
}  // namespace internal
 
// constant expressions for upper/lower access
 
constexpr internal::GeneralAccess GENERAL = {};
constexpr internal::UpperHessenberg UPPER_HESSENBERG = {};
constexpr internal::LowerHessenberg LOWER_HESSENBERG = {};
constexpr internal::UpperTriangle UPPER_TRIANGLE = {};
constexpr internal::LowerTriangle LOWER_TRIANGLE = {};
constexpr internal::StrictUpper STRICT_UPPER = {};
constexpr internal::StrictLower STRICT_LOWER = {};
 
// -----------------------------------------------------------------------------
// Information about the main diagonal
 
enum class Diag : char {
    NonUnit = 'N',  
    Unit = 'U'      
};
inline std::ostream& operator<<(std::ostream& out, const Diag v)
{
    if (v == Diag::NonUnit) return out << "NonUnit";
    if (v == Diag::Unit) return out << "Unit";
    return out << "<Invalid>";
}
 
namespace internal {
    struct NonUnitDiagonal {
        constexpr operator Diag() const noexcept { return Diag::NonUnit; }
    };
    struct UnitDiagonal {
        constexpr operator Diag() const noexcept { return Diag::Unit; }
    };
}  // namespace internal
 
// constant expressions about the main diagonal
 
constexpr internal::NonUnitDiagonal NON_UNIT_DIAG = {};
constexpr internal::UnitDiagonal UNIT_DIAG = {};
 
// -----------------------------------------------------------------------------
// Operations over data
 
enum class Op : char {
    NoTrans = 'N',    
    Trans = 'T',      
    ConjTrans = 'C',  
    Conj = 3          
};
inline std::ostream& operator<<(std::ostream& out, const Op v)
{
    if (v == Op::NoTrans) return out << "NoTrans";
    if (v == Op::Trans) return out << "Trans";
    if (v == Op::ConjTrans) return out << "ConjTrans";
    if (v == Op::Conj) return out << "Conj";
    return out << "<Invalid>";
}
 
namespace internal {
    struct NoTranspose {
        constexpr operator Op() const noexcept { return Op::NoTrans; }
    };
    struct Transpose {
        constexpr operator Op() const noexcept { return Op::Trans; }
    };
    struct ConjTranspose {
        constexpr operator Op() const noexcept { return Op::ConjTrans; }
    };
    struct Conjugate {
        constexpr operator Op() const noexcept { return Op::Conj; }
    };
}  // namespace internal
 
// Constant expressions for operations over data
 
constexpr internal::NoTranspose NO_TRANS = {};
constexpr internal::Transpose TRANSPOSE = {};
constexpr internal::ConjTranspose CONJ_TRANS = {};
constexpr internal::Conjugate CONJUGATE = {};
 
// -----------------------------------------------------------------------------
// Sides
 
enum class Side : char {
    Left = 'L',   
    Right = 'R',  
    Both = 'B'    
};
inline std::ostream& operator<<(std::ostream& out, const Side v)
{
    if (v == Side::Left) return out << "Left";
    if (v == Side::Right) return out << "Right";
    if (v == Side::Both) return out << "Both";
    return out << "<Invalid>";
}
 
namespace internal {
    struct LeftSide {
        constexpr operator Side() const noexcept { return Side::Left; }
    };
    struct RightSide {
        constexpr operator Side() const noexcept { return Side::Right; }
    };
    struct BothSides {
        constexpr operator Side() const noexcept { return Side::Both; }
    };
}  // namespace internal
 
// Constant expressions for sides
 
constexpr internal::LeftSide LEFT_SIDE{};
constexpr internal::RightSide RIGHT_SIDE{};
constexpr internal::BothSides BOTH_SIDES{};
 
// -----------------------------------------------------------------------------
// Norm types
 
enum class Norm : char {
    One = '1',  
    Two = '2',  
    Inf = 'I',  
    Fro = 'F',  
    Max = 'M',  
};
inline std::ostream& operator<<(std::ostream& out, const Norm v)
{
    if (v == Norm::One) return out << "One";
    if (v == Norm::Two) return out << "Two";
    if (v == Norm::Inf) return out << "Inf";
    if (v == Norm::Fro) return out << "Fro";
    if (v == Norm::Max) return out << "Max";
    return out << "<Invalid>";
}
 
namespace internal {
    struct MaxNorm {
        constexpr operator Norm() const noexcept { return Norm::Max; }
    };
    struct OneNorm {
        constexpr operator Norm() const noexcept { return Norm::One; }
    };
    struct TwoNorm {
        constexpr operator Norm() const noexcept { return Norm::Two; }
    };
    struct InfNorm {
        constexpr operator Norm() const noexcept { return Norm::Inf; }
    };
    struct FrobNorm {
        constexpr operator Norm() const noexcept { return Norm::Fro; }
    };
}  // namespace internal
 
// Constant expressions for norm types
 
constexpr internal::MaxNorm MAX_NORM = {};
constexpr internal::OneNorm ONE_NORM = {};
constexpr internal::TwoNorm TWO_NORM = {};
constexpr internal::InfNorm INF_NORM = {};
constexpr internal::FrobNorm FROB_NORM = {};
 
// -----------------------------------------------------------------------------
// Directions
 
enum class Direction : char {
    Forward = 'F',   
    Backward = 'B',  
};
inline std::ostream& operator<<(std::ostream& out, const Direction v)
{
    if (v == Direction::Forward) return out << "Forward";
    if (v == Direction::Backward) return out << "Backward";
    return out << "<Invalid>";
}
 
namespace internal {
    struct Forward {
        constexpr operator Direction() const noexcept
        {
            return Direction::Forward;
        }
    };
    struct Backward {
        constexpr operator Direction() const noexcept
        {
            return Direction::Backward;
        }
    };
}  // namespace internal
 
// Constant expressions for directions
 
constexpr internal::Forward FORWARD{};
constexpr internal::Backward BACKWARD{};
 
// -----------------------------------------------------------------------------
// Storage types
 
enum class StoreV : char {
    Columnwise = 'C',  
    Rowwise = 'R',     
};
inline std::ostream& operator<<(std::ostream& out, const StoreV v)
{
    if (v == StoreV::Columnwise) return out << "Columnwise";
    if (v == StoreV::Rowwise) return out << "Rowwise";
    return out << "<Invalid>";
}
 
namespace internal {
    struct ColumnwiseStorage {
        constexpr operator StoreV() const noexcept
        {
            return StoreV::Columnwise;
        }
    };
    struct RowwiseStorage {
        constexpr operator StoreV() const noexcept { return StoreV::Rowwise; }
    };
}  // namespace internal
 
// Constant expressions for storage types
 
constexpr internal::ColumnwiseStorage COLUMNWISE_STORAGE{};
constexpr internal::RowwiseStorage ROWWISE_STORAGE{};
 
// -----------------------------------------------------------------------------
// Band access
 
struct BandAccess {
    std::size_t lower_bandwidth;  
    std::size_t upper_bandwidth;  
};
 
// -----------------------------------------------------------------------------
// Legacy matrix and vector structures
 
namespace legacy {
    template <class T, class idx_t>
    struct Matrix {
        Layout layout;
        idx_t m;
        idx_t n;
        T* ptr;
        idx_t ldim;
    };
 
    template <class T, class idx_t>
    struct Vector {
        idx_t n;
        T* ptr;
        idx_t inc;
    };
}  // namespace legacy
}  // namespace tlapack
 
#endif  // TLAPACK_TYPES_HH