Scalar.h

Go to the documentation of this file.

#ifndef included_AMP_Scalar
#define included_AMP_Scalar
 
#include <any>
#include <cstddef>
#include <cstdint>
 
#include "AMP/utils/TypeTraits.h"
#include "AMP/utils/typeid.h"
 
 
namespace AMP {
 
 
class Scalar
{
public:
    inline Scalar() = default;
 
    template<class TYPE>
    Scalar( const TYPE &x );
 
    Scalar( const Scalar & ) = default;
 
    Scalar( Scalar && ) = default;
 
    Scalar &operator=( const Scalar & ) = default;
 
    Scalar &operator=( Scalar && ) = default;
 
    template<class TYPE>
    Scalar create( const TYPE &x ) const;
 
    template<class TYPE>
    TYPE get( double tol = Scalar::getTol<TYPE>() ) const;
 
    inline bool is_floating_point() const { return d_type == 'f'; }
 
    inline bool is_integral() const { return d_type == 'i'; }
 
    inline bool is_complex() const { return d_type == 'c'; }
 
    inline const auto &type() const { return d_data.type(); }
 
    inline uint32_t getTypeHash() const { return d_hash; }
 
    inline bool has_value() const noexcept { return d_data.has_value(); }
 
    template<class TYPE>
    static constexpr double getTol()
    {
        if constexpr ( std::is_integral_v<TYPE> ) {
            return 0;
        } else if constexpr ( std::is_floating_point_v<TYPE> ) {
            constexpr double tol = 10 * std::numeric_limits<TYPE>::epsilon();
            return tol;
        } else if constexpr ( AMP::is_complex_v<TYPE> ) {
            constexpr double tol = 10 * std::numeric_limits<TYPE>::epsilon().real();
            return tol;
        } else {
            constexpr double tol = 10 * std::numeric_limits<TYPE>::epsilon();
            return tol;
        }
    }
 
    void print( std::ostream &out ) const;
 
 
public: // Comparison operators
    bool operator==( const Scalar &rhs ) const;
    bool operator!=( const Scalar &rhs ) const;
    bool operator>( const Scalar &rhs ) const;
    bool operator>=( const Scalar &rhs ) const;
    bool operator<( const Scalar &rhs ) const;
    bool operator<=( const Scalar &rhs ) const;
 
 
public: // Overload some typecast operators
    template<class TYPE>
    inline explicit operator TYPE() const
    {
        return get<TYPE>();
    }
 
 
public: // Limits
    Scalar limitsMax() const;
 
    Scalar limitsMin() const;
 
    Scalar zero() const;
 
 
public: // Math functions
    Scalar abs() const;
    Scalar sqrt() const;
 
 
private: // Helper functions
    template<class TYPE>
    inline void store( const TYPE &x );
 
 
private: // Internal data
    char d_type     = 0;
    uint32_t d_hash = 0;
    std::any d_data;
};
 
 
/********************************************************************
 * Operator overloading                                              *
 ********************************************************************/
Scalar operator-( const Scalar &x );
Scalar operator+( const Scalar &x, const Scalar &y );
Scalar operator-( const Scalar &x, const Scalar &y );
Scalar operator*( const Scalar &x, const Scalar &y );
Scalar operator/( const Scalar &x, const Scalar &y );
inline bool operator==( double x, const Scalar &y ) { return y.operator==( x ); }
 
 
/********************************************************
 *  ostream operator                                     *
 ********************************************************/
template<class TYPE>
typename std::enable_if_t<std::is_same_v<TYPE, Scalar>, std::ostream &>
operator<<( std::ostream &out, const TYPE &x )
{
    x.print( out );
    return out;
}
 
 
} // namespace AMP
 
#endif