/home/brandes/workspace/LAMA/src/lama/Scalar.hpp

Go to the documentation of this file.

#ifndef LAMA_SCALAR_HPP_
#define LAMA_SCALAR_HPP_

// for dll_import
#include <lama/config.hpp>

// base classes
#include <lama/Printable.hpp>

// others
#include <lama/LAMATypes.hpp>

#include <lama/exception/LAMAAssert.hpp>

// logging
#include <logging/logging.hpp>

#include <complex>
#include <cmath>
#include <cstdio>

namespace lama
{

class LAMA_DLL_IMPORTEXPORT Scalar : public Printable
{
public:

    enum ScalarType { INDEX_TYPE, FLOAT, DOUBLE, LONG_DOUBLE, 
                      COMPLEX, DOUBLE_COMPLEX, LONG_DOUBLE_COMPLEX, UNKNOWN };

    typedef const Scalar ExpressionMemberType;

    inline Scalar();

    template<typename T>
    explicit inline Scalar( const T value );

    inline Scalar( const float value );

    inline Scalar( const double value );

    inline Scalar( const long double value );

    template<typename T>
    inline Scalar( const std::complex<T> value );

    inline virtual ~Scalar();

    template<typename T>
    inline T getValue() const;

    // Removed: template<typename T> operator T () const  for type conversions
    // Might cause problems due to implicit conversions, should only be used explicitly
    // Now should be done as: cast<T>( scalar )

    inline Scalar operator-() const;

    inline bool isReal() const;

    inline virtual void writeAt( std::ostream& stream ) const;

    template<typename T>
    inline static ScalarType getType();

    inline static size_t getTypeSize( const ScalarType type );

protected:

    LAMA_LOG_DECL_STATIC_LOGGER( logger );

private:

    std::complex<long double> mValue;
};

LAMA_DLL_IMPORTEXPORT std::ostream& operator<<( std::ostream& stream, const Scalar::ScalarType& object );

template<typename T>
T cast( const Scalar& scalar )
{
    return scalar.getValue<T>();
}

const Scalar zero;

inline Scalar::Scalar()
    : mValue( 0.0, 0.0 )
{}

template<typename T>
inline Scalar::Scalar( const T value )
    : mValue( value, 0.0 )
{}

inline Scalar::Scalar( const float value )
    : mValue( value, 0.0 )
{}

inline Scalar::Scalar( const double value )
    : mValue( value, 0.0 )
{}

inline Scalar::Scalar( const long double value )
    : mValue( value, 0.0 )
{}

template<typename T>
inline Scalar::Scalar( const std::complex<T> value )
    : mValue( value.real(), value.imag() )
{}


inline Scalar::~Scalar()
{}

template<typename T>
inline T Scalar::getValue() const
{
    return static_cast<T>( mValue.real() );
}

template<>
inline std::complex<float> Scalar::getValue() const
{
    return std::complex<float>( static_cast<float>( mValue.real() ), static_cast<float>( mValue.imag() ) );
}

template<>
inline std::complex<double> Scalar::getValue() const
{
    return std::complex<double>( static_cast<double>( mValue.real() ), static_cast<double>( mValue.imag() ) );
}

template<>
inline std::complex<long double> Scalar::getValue() const
{
    return std::complex<long double>( mValue.real(), mValue.imag() );
}

inline Scalar Scalar::operator-() const
{
    return Scalar( -mValue );
}

inline bool Scalar::isReal() const
{
    return mValue.imag() == 0.0;
}

inline void Scalar::writeAt( std::ostream& stream ) const
{
    stream << "Scalar(" << mValue.real() << ")";
}

template<typename T>
inline Scalar::ScalarType Scalar::getType()
{
    return UNKNOWN;
}

template<>
inline Scalar::ScalarType Scalar::getType<IndexType>()
{
    return INDEX_TYPE;
}

template<>
inline Scalar::ScalarType Scalar::getType<float>()
{
    return FLOAT;
}

template<>
inline Scalar::ScalarType Scalar::getType<double>()
{
    return DOUBLE;
}

template<>
inline Scalar::ScalarType Scalar::getType<long double>()
{
    return LONG_DOUBLE;
}

template<>
inline Scalar::ScalarType Scalar::getType<std::complex<float> >()
{
    return COMPLEX;
}

template<>
inline Scalar::ScalarType Scalar::getType<std::complex<double> >()
{
    return DOUBLE_COMPLEX;
}

template<>
inline Scalar::ScalarType Scalar::getType<std::complex<long double> >()
{
    return LONG_DOUBLE_COMPLEX;
}

inline size_t Scalar::getTypeSize( const ScalarType type )
{
    size_t typeSize = 0;

    switch ( type )
    {
        case FLOAT:
            typeSize = 4;
            break;

        case DOUBLE:
            typeSize = 8;
            break;

        case LONG_DOUBLE:
            typeSize = 16;
            break;

        case COMPLEX:
            typeSize = 8;
            break;

        case DOUBLE_COMPLEX:
            typeSize = 16;
            break;

        case LONG_DOUBLE_COMPLEX:
            typeSize = 32;
            break;

        default:
            typeSize = 0;
    }

    return typeSize;
}

inline Scalar operator+ ( const Scalar& a, const Scalar& b )
{
    return Scalar( a.getValue<long double>() + b.getValue<long double>() );
}

inline Scalar operator- ( const Scalar& a, const Scalar& b )
{
    return Scalar( a.getValue<long double>() - b.getValue<long double>() );
}

inline Scalar operator* ( const Scalar& a, const Scalar& b )
{
    return Scalar( a.getValue<long double>() * b.getValue<long double>() );
}

inline Scalar operator/ ( const Scalar& a, const Scalar& b )
{
    return Scalar( a.getValue<long double>() / b.getValue<long double>() );
}

inline bool operator==( const Scalar& a, const Scalar& b )
{
    return a.getValue<long double>() == b.getValue<long double>();
}

inline bool operator!=( const Scalar& a, const Scalar& b )
{
    return !( a == b );
}

inline bool operator<( const Scalar& a, const Scalar& b )
{
    if ( !a.isReal() || !b.isReal() )
    {
        LAMA_THROWEXCEPTION( "Could not call operator< for Scalar a = " << a << ", b = " << b
                             << ", because one of them is not real." );
    }

    return a.getValue<long double>() < b.getValue<long double>() ;
}

inline bool operator>( const Scalar& a, const Scalar& b )
{
    if ( !a.isReal() || !b.isReal() )
    {
        LAMA_THROWEXCEPTION( "Could not call operator> for Scalar a = " << a << ", b = " << b
                             << ", because one of them is not real." );
    }

    return a.getValue<long double>() > b.getValue<long double>() ;
}

inline bool operator<=( const Scalar& a, const Scalar& b )
{
    return !( a > b );
}

inline bool operator>=( const Scalar& a, const Scalar& b )
{
    return !( a < b );
}

inline Scalar sqrt( const Scalar scalar )
{
    return std::sqrt( scalar.getValue<std::complex<long double> >() );
}

inline Scalar abs( const Scalar scalar )
{
    return std::abs( scalar.getValue<std::complex<long double> >() );
}

inline Scalar max( const Scalar a, const Scalar b )
{
    LAMA_ASSERT_DEBUG( a.isReal(), "Non-real value in max : " << a  );
    LAMA_ASSERT_DEBUG( b.isReal(), "Non-real value in max : " << b  );

    return std::max( a.getValue<long double >(), b.getValue<long double >() );
}

inline Scalar min( const Scalar a, const Scalar b )
{
    LAMA_ASSERT_DEBUG( a.isReal(), "Non-real value in max : " << a  );
    LAMA_ASSERT_DEBUG( b.isReal(), "Non-real value in max : " << b  );

    return std::min( a.getValue<long double >(), b.getValue<long double >() );
}

} //namespace lama

#endif // LAMA_SCALAR_HPP_