komplexe Zahlen: r-phi-Darstellung & Operationen (plus, minus, mal, geteilt)



  • Hallo Leute!

    Folgendes Aufgabe steht hinter dem Programm:

    Komplexe Zahlen können, wie aus der Mathematik bekannt, auf unterschiedliche Arten dargestellt werden. Eine geometrisch orientierte Darstellung ist die r-phi-Darstellung: r ist der Abstand der Zahl vom Nullpunkt der x-y-Achse. phi ist der Winkel zwischen x-Achse und der Verbindung des Nullpunktes mit der komplexen Zahl z.(Winkel wird im Bogenmaß von 0 bis 2*Pi angegeben, Pi =180 Grad).

    Aufgabenstellung:

    Schaffen Sie die Klasse Komplex_Phi mit komplexen Zahlen in der r-phi-Darstellung und mit den Attributen r und PHI vom Typ double. Die Klasse enthält als Methode einen Konstruktor, mit zwei Parametern, der r auf 1 und PHI auf 0 vorbelegt, falls der Anwender keine andere Vorbelegung beim Kreieren der Objekte vornimmt. Die Klasse enthält die Operatoren +, -, * und / .

    Hinweise:
    Die Methoden * und / sind sehr einfach zu realisieren:
    (r1,phi1)(r2,phi2) ergibt die komplexe Zahl: (r1r2, phi1+phi2)
    (r1,phi1)/(r2,phi2) ergibt die komplexe Zahl: (r1/r2, phi1-phi2)
    Bei den Methoden + und – rechnet man zunächst mittels sin(PHI) und cos(PHI) in die x-y-Darstellung um, addiert bzw subtrahiert komponentenweise und berechnet mittels atan(y/x) den Winkel PHI und mittels Pythagoras den Abstand r vom Nullpunkt.

    So, folgendes hab ich mir ausgedacht:

    Komplex_Phi.h:

    class Komplex_Phi
    {
     private:
      double r;
      double PHI;
     public:
      Komplex_Phi(double a = 1, double b = 0);
      Komplex_Phi operator +(Komplex_Phi z);
      Komplex_Phi operator -(Komplex_Phi z);
      Komplex_Phi operator *(Komplex_Phi z);
      Komplex_Phi operator /(Komplex_Phi z);
      double r_out();
      double PHI_out();
    };
    

    Komplex_Phi.cpp:

    #include <iostream.h>
    #include <math.h>
    #include "Komplex_Phi.h"
    
    Komplex_Phi::Komplex_Phi(double a, double b)
    {
     r = a;
     PHI = b;
    }
    
    Komplex_Phi Komplex_Phi::operator *(Komplex_Phi z)
    {
     Komplex_Phi speicher;
    
     speicher.r = r * z.r;
     speicher.PHI = PHI + z.PHI;
    
     return speicher;
    }
    
    Komplex_Phi Komplex_Phi::operator /(Komplex_Phi z)
    {
     Komplex_Phi speicher;
    
     speicher.r = r / z.r;
     speicher.PHI = PHI - z.PHI;
    
     return speicher;
    }
    
    Komplex_Phi Komplex_Phi::operator +(Komplex_Phi z)
    {
     Komplex_Phi speicher;
    
     double x, y, x1, y1, x2, y2;
    
     x1 = r * cos(PHI);
     y1 = r * sin(PHI);
    
     x2 = z.r * cos(z.PHI);
     y2 = z.r * sin(z.PHI);
    
     x = x1 + x2;
     y = y1 + y2;
    
     speicher.r = sqrt(pow(x, 2.) + pow(y, 2.));
     speicher.PHI = atan(y/x);
    
     return speicher;
    }
    
    Komplex_Phi Komplex_Phi::operator -(Komplex_Phi z)
    {
     Komplex_Phi speicher;
    
     double x, y, x1, y1, x2, y2;
    
     x1 = r * cos(PHI);
     y1 = r * sin(PHI);
    
     x2 = z.r * cos(z.PHI);
     y2 = z.r * sin(z.PHI);
    
     x = x1 - x2;
     y = y1 - y2;
    
     speicher.r = sqrt(pow(x, 2.) + pow(y, 2.));
     speicher.PHI = atan(y/x);
    
     return speicher;
    }
    
    double Komplex_Phi::r_out()
    {
     return r;
    }
    
    double Komplex_Phi::PHI_out()
    {
     return PHI;
    }
    

    haupt.cpp:

    #include <iostream.h>
    #include <math.h>
    #include "Komplex_Phi.h"
    
    Komplex_Phi z1(3.0,2.0),z2(2.0,1.0),z3;
    
    void main()
    {
     z3 = z1 * z2;
     cout<<"r: "<<z3.r_out();
     cout<<"PHI: "<<z3.PHI_out();
    
     z3 = z1 / z2;
     cout<<"r: "<<z3.r_out();
     cout<<"PHI: "<<z3.PHI_out();
    
     z3 = z1 + z2;
     cout<<"r: "<<z3.r_out();
     cout<<"PHI: "<<z3.PHI_out();
    
     z3 = z1 - z2;
     cout<<"r: "<<z3.r_out();
     cout<<"PHI: "<<z3.PHI_out();
    }
    

    Das Programm läuft soweit ganz gut.

    Gibt es evtl. noch Verbesserungsmöglichkeiten bzw. Formfehler die sich eingeschlichen haben? Oder hätte ich es ganz anders und viel leichter umsetzen können?

    Danke schonmal an jeden der sich die Zeit nimmt!

    Gruß,
    Johrtreel



  • Hi,

    Etwas geht immer. Die Includes heißen <iostream> und <cmath>, und dann muß es std::cout heißen. Dazu kommt noch das 'void main()'. Da ist ein 'int main()' pflicht, und ein Rückgabewert muß dann auch her. Zu dem Thema aber hier mehr.

    ein wenig abkürzen könnte man einiges noch:
    z.Bsp:

    Komplex_Phi Komplex_Phi::operator *(Komplex_Phi z) 
    { 
          return Komplex_Phi (r * z.r,PHI + z.PHI); 
    }
    

    grüße Con@n



  • Die Operatoren sollten besser Nonmembers sein. Weil dann auch auf dem linken Parameter ne Konvertierung durchgeführt werden kann. Außerdem ist es geschickter sie mit den op= zu implementieren.

    Implementiere zum Beispiel einen operator+= (der gehört dann zur Klasse)

    operator+ geht dann so:

    const Komplex_Phi operator+(const Komplex_Phi & lhs, const Komplex_Phi & rhs)
    {
    Komplex_Phi res(lhs);
    res += rhs;
    return res;
    }

    Damit brauchst Du Dir dann auch keine Sorgen mehr um Konsistenzprobleme von op und op= machen.

    Rückgabewerte der Operatoren sollten übrigens konstant sein, damit man ihnen nichts zuweisen kann.

    z1+z2=z3;

    ist in Deinem Code nämlich erlaubt, aber halt kein Stück sinnvoll.

    MfG Jester


Log in to reply