komplex2.h

Go to the documentation of this file.

#pragma once
#include <cassert>      // static_assert
#include <cmath>        // sqrt()
#include <concepts>
#include <iostream>
//#include <type_traits>  // std::is_floating_point<T>()
 
// Concepts: See [Grimm: C++20 Get the details, p.10 and §4.1]
// see also:  https://akrzemi1.wordpress.com/2020/01/29/requires-expression/
template<typename T>            // C++20: concepts
concept FloatDouble = sizeof(T)>=sizeof(float) && std::floating_point<T>;  // float32 and larger
//concept FloatDouble = sizeof(T)>=sizeof(double) && std::floating_point<T>;  // float64 and larger
 
        
template<FloatDouble T>
class Komplex
{
public:
    Komplex() : Komplex(T(0),T(0))                           // constructor forwarding  
    { }
        //          |-- Standardwert
    Komplex(T re, T im=0.0) // Parameterkonstruktor mit ein oder zwei Argumenten
    : _re(re), _im(im)
    { }    
   // See rule of five: https://en.cppreference.com/w/cpp/language/rule_of_three
   //
    Komplex(const Komplex<T>&  org)               = default; // Copykonstruktor
    Komplex(      Komplex<T>&& org)               = default; // Movekonstruktor
    Komplex<T>& operator=(const Komplex<T>&  rhs) = default; // Copy-Zuweisungsoperator
    Komplex<T>& operator=(      Komplex<T>&& rhs) = default; // Move-Zuweisungsoperator
    ~Komplex()                                    = default; // Destruktor
 
    //            |--  Member der Instanz werden durch die Methode nicht veraendert!
    T Get_re() const
    {
        return _re;
    }
    void Set_re(T val)
    {
        _re = val;
    }
    //            |--  Member der Instanz werden durch die Methode nicht veraendert!
    T Get_im() const
    {
        return _im;
    }
    void Set_im(T val)
    {
        _im = val;
    }
 
    Komplex<T>& operator+=(const Komplex<T>& rhs);
 
    //                                             |--  Member der Instanz werden durch die Methode nicht veraendert!
    Komplex<T> operator+(const Komplex<T>& rhs) const;
 
    bool operator<(const Komplex<T>& rhs) const
    {
        return _re < rhs._re || ( _re == rhs._re && _im < rhs._im );
    }
 
    bool operator==(const Komplex<T>& rhs) const
    {
        return _re == rhs._re && _im == rhs._im ;
    }
 
    bool operator>(const Komplex<T>& rhs) const
    {
        return !( *this < rhs || *this== rhs ) ;
    }
 
   template <class S>
   friend std::ostream& operator<<(std::ostream& s, const Komplex<S>& rhs);
 
protected:
private:
    T _re; 
    T _im; 
};
 
template <FloatDouble T>
Komplex<T> operator+(T lhs, const Komplex<T>& rhs);
 
 
template <FloatDouble T>
T abs(const Komplex<T>& rhs)
{
    return std::sqrt(rhs.Get_re()*rhs.Get_re()+rhs.Get_im()*rhs.Get_im());
}
 
 
#include "komplex2.tcc"