IntegralElement.h

Go to the documentation of this file.

/*  YAP - Yet another PWA toolkit
    Copyright 2015, Technische Universitaet Muenchen,
    Authors: Daniel Greenwald, Johannes Rauch

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */


#ifndef yap_IntegralElement_h
#define yap_IntegralElement_h

#include "fwd/IntegralElement.h"

#include "complex_to_string.h"

namespace yap {

template <typename T>
class IntegralElement
{
public:

    explicit IntegralElement(T val = 0) : Value_(val) {}

    void reset()
    { Value_ = 0; }

    const T value() const
    { return Value_; }

    T& value()
    { return Value_; }

    template <typename U>
    IntegralElement& operator*=(const U& rhs)
    { Value_ *= rhs; return *this; }

    IntegralElement& operator+=(const IntegralElement& B)
    { Value_ += B.Value_; return *this; }

    IntegralElement& operator-() const
    { Value_ *= -1; return *this; }

    IntegralElement& operator-=(const IntegralElement& B)
    { return *this += -B; }

    IntegralElement& operator*=(const IntegralElement& B)
    { Value_ *= B.Value_; return *this; }

    IntegralElement& operator/=(const IntegralElement& B)
    { Value_ /= B.Value_; return *this; }

    template <typename U>
    friend const IntegralElement operator*(IntegralElement A, const U& B)
    { return A *= B; }

    template <typename U>
    friend const IntegralElement operator*(const U& A, IntegralElement B)
    { return operator*(B, A); }

    explicit operator T() const
    { return value; }

    template <typename U>
    explicit operator std::complex<U>() const
    { return static_cast<std::complex<U> >(Value_); }

    template <typename U>
    explicit operator IntegralElement<std::complex<U> >() const
    { return IntegralElement<std::complex<U> >(static_cast<std::complex<U> >(Value_)); }

private:

    T Value_;

};

template <typename T>
inline const IntegralElement<T> operator+(IntegralElement<T> A, const IntegralElement<T>& B)
{ return A += B; }

template <typename T>
inline const IntegralElement<T> operator-(IntegralElement<T> A, const IntegralElement<T>& B)
{ return A -= B; }

template <typename T>
inline const IntegralElement<T> operator*(IntegralElement<T> A, const IntegralElement<T>& B)
{ return A *= B; }

template <typename T>
inline const IntegralElement<T> operator/(IntegralElement<T> A, const IntegralElement<T>& B)
{ return A /= B; }

template <typename T>
inline std::string to_string(const IntegralElement<T>& a)
{ using std::to_string; return to_string(a.value()); }


inline ComplexIntegralElement conj(const ComplexIntegralElement& Z)
{ return ComplexIntegralElement(conj(Z.value())); }

inline RealIntegralElement real(const ComplexIntegralElement& Z)
{ return RealIntegralElement(real(Z.value())); }

inline RealIntegralElement imag(const ComplexIntegralElement& Z)
{ return RealIntegralElement(imag(Z.value())); }



}

#endif