[C++] Wie geht das? (Komplexe Zahlen berechnung)

H

HCI

Grünschnabel
Ich hab folgendes Programm geschrieben:
Code: 
#include <iostream>
#include <stdlib.h>

using namespace std;

int main(int argc, char *argv[])
{  
  double a1,a2,b1,b2,diff,summ,qdiff,qsumm;

  // Liest Realteil von a ein
  cout << "Re(a) = ";
  cin >> a1;
  
// Liest Imaginaerteil von a ein
  cout << "Im(a) = ";
  cin >> a2;

  // Liest Realteil von b ein
  cout << "Re(b) = "; 
  cin >> b1;

  // Liest Imaginaerteil von b ein
  cout << "Im(b) = ";
  cin >> b2;

  // Berechnet Differenz von Realteilen von a und b ein
  diff = (a1*b1) - (a2*b2);

  // Berechnet Summe von Imaginaerteilen von a und b ein
  summ = (a1*b2) + (a2*b1);

  // Berechne Quadrat von diff
  qdiff = diff * diff;

  // Berechne Quadrat von summ
  qsumm = summ * summ;

  /* Gebe Ergebnis auf dem Bildschrim aus */
  cout << "a*b = " <<"("<<diff<<")+i*("<<summ<<")"<<endl;
  
  cout << "(a*b)^(-1) = " <<"("<<diff/(qdiff+qsumm)<<")+i*("<<              
   -(summ/(qdiff+qsumm))<<")"<<endl;
  
  cout << "(a*b)*(a*b)^(-1) = "<<"("<<(qdiff+qsumm)/(qdiff+qsumm)<<")+i*("<<
  (-((diff*summ)/(qdiff+qsumm))+((diff*summ)/(qdiff+qsumm)))<<")"<<endl;
  
  system("PAUSE");	
  return 0;
}

Dieses berechnet mir das Produkt von zwei Komplexen Zahlen a und b.
das erst Ergebnis (a*b) ist das Produkt von a und b
das zweite Ergebnis (a*b)^(-1) ist das Inverse zum Produkt von a und b
das dritte Ergebnis (a*b)*(a*b)^(-1) liefert das Produkt vom Inversen und Produkt.

Mein Problem liegt jetzt beim dritten Ergebnis.
Im Bereich der ganzen Zahlen leifert es das Ergbnis 0, was hier auch der Fall ist, aber ich rechne hier im Geltikommazahlen Bereich, d.h. beim dirtten Ergebnis soll nicht 1 + i * 0 herauskommen, sondern 1 + i * (....).
Das heisst ich will verhindern, dass das Programm mir beim dritten Ergbnis aufrundet, namlich statt einer ganz kleinen Zahl einfach auf 0 zu runden.
Bsp: (5.42101e-20) wird zum beispiel zu 0 gerundet.
Dies will ich aber verhindern. Wie kann ich die Berechnung vom dritten Ergebnis so umschreiben, dass das Programm eben nicht aufrundet.?

Hoffe mir kann jemand helfen.
Gruß HCI
 
Code: 
cout << "(a*b)*(a*b)^(-1) = "<<"("<<(qdiff+qsumm)/(qdiff+qsumm)<<")+i*("<<
  (-((diff*summ)/(qdiff+qsumm))+((diff*summ)/(qdiff+qsumm)))<<")"<<endl;

Korregiere mich, wenn ich irre, aber wenn man

diff*summ = _x
qdiff+qsumm = _y

setzt, dann steht da

... (-(_x/_y) + (_x/_y) )

und das ist doch immer 0 , oder ?
 
du hast recht, ich weiss halt nicht wie ich es schreiben soll, damit eben das verhindert werden soll. Ich will halt, dass das teil am ende mir statt auf 0 zu runden, den gleitkommawert liefert. also ich suche nach einer "funktion" für den dritten fall, der mir 1 + i * (gleitkommazahl) liefert.
Die funtktion die du da oben siehst ist nur eine "übergangslösung", bis ich halt die richtige funktion herausgefunden habe.
Gruss Haichao
 
Meine Mathezeit ist schon etwas länger her und es kann sein, dass ich vollkommen schief liege, aber ich habe auch den Verdacht, dass du in deiner dritten Formel einen Denkfehler hast.
(a*b)*(a*b)^(-1)
Zum Vergrößern anklicken....
Wenn du das Produkt (a*b) mit seiner Inversion multiplizierst, sollte doch immer das neutrale Element bezüglich der Multiplikation rauskommen. Ist das (1,0) für die komplexen Zahlen? Weiss es leider nicht mehr. *schäm*

Nur meine zwei Eurocent.
 
Kachelator hat vollkommen recht das Ergebnis ist
1 + i*0 == (1,0)
Die genauigkeit von double reicht vollkommen aus um das richtige Ergebniss zu liefern .

Bist du dir sicher dass du dass mit den komplexen Zahlen (von der Theorie) ganz verstanden hast ?

Rechne doch mal analytisch das Ergebnis und du wirst sehen dass 1 die richtige Antwort ist !
 
Ihr habt schon recht, aber bei komplexen Zahlen wird normalerweise nicht mit Zahlen gerechnet, die vielleicht auf den ersten zig nachkommastellen zwar null sind, aber irgendwann dann eine zahl auftaucht (bsp. 1*10^(-50)) . Ich hab halt mal ein programm gesehen(vor vielen Jahren, als ich mal an der uni zu besuch war), bei dem zahlen, wie 5,5*10^(-20) eingegeben wurden und am ende nicht wilklich null herausgekommen ist. Ich hab mal einen Freund gefragt, warum das nicht 0 ist und er hat gemeint, dass bei einem "ungenauen" Algorithmus, der PC einfach auf 0 aufrundet, was auch bei den meisten Taschenrechnern der Fall ist. Und so ein Programm wollte ich mal aus Neugier mal schreiben und ich suche halt jetzt eine Möglichkeit, wie man den PC davon abhalten kann aufzurunden, sei es über einer speziellen Funktion oder sonst was. Aber ich habs jetzt aufgegeben, da das sowieso eine Spielerei ist und nicht so "wichtig" fürs richtige Leben ;-). Naja trotzdem danke ich allen, die geantowortet haben. Thx.

Gruss HCI
 
Zuletzt bearbeitet:
Ich arbeite viel mit komplexen Zahlen und der Wertebereich ist keineswegs beschränkt !
"Oft" rechnet man aber in Wertebereichen zwischen 0 und 1.(Z.B: in der Signalverarbeitung , wenn die Zahlen von einem "Fractional Prozessor" abstammen)
Der PC rechnet mit doubles halt genau genug , versuche doch fractionals um deine Auflösung zu verschlechtern. DSPs und Microcontroller haben/hatten oft nicht "teure" floating point einheiten und rechen mit Fractional Werten.

Fractional ::= man codiert eine Fließkommazahl in einem Integerwert, in dem man bestimmt, dass die höchsten x Bits vor dem Komma stehen und die dahinter für die Nachkomma stelle. Z.B.: ein 32 Bit Integer stellt den Wertebereich [-1, 1] dar. Das Problem ist hier dann dass du ein Quantisierungsfehler hast der 1/(2^31 ) ist.
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück