imaginäre Zahlen

[Stutz]

Hi,
ich hätte mal eine kleine Frage, nachdem mein Mathelehrer mir bei brachte mit komplexen und imaginären Zahlen zu rechnen, würde es mich rein interessehalber reizen ein Programm zu schreiben das mit solchen Zahlen zurecht kommt. Jetzt die Frage: kann ich mit Delphi ein solches Programm schreiben, bzw. gibt es in Delphi die Zahl "i" und kommen Funktionen wie power() damit zurecht.

Als Beispiel würde ich gerne einen Taschenrechner Programmieren, der bei sqrt(-4) anstatt einem Mathematischen Fehler ein "2i" ausgibt.


Falls jemand eine schlaue idee hat oder ebenfalls schon damit gerechnet hat wäre es interessant zu wissen.

Mein bisheriger Lösungsansatz wäre die Diskriminante zu überprüfen ob sie kleiner ist als 0 und gegebenenfalls das i auszumultiplizieren. Das Problem ist eben dass ich in diesem Fall alle zahlen die mit der imaginären Zahl multipliziert werden dennoch multiplizieren muss --> mein Programm muss zwischen punkt und Strich rechnung unterscheiden können. Deshalb wäre eine einfachere Lösung interessant.

Beispielrechnung mit i:

(2+2i)²
=4+8i-4 //da i² =-1 ist gibt 4i²=-4
=8i



liebe grüße und Danke im voraus,
Stutz

[Medium]

Rechnen mit komplexen Zahlen ist in aktuellen CPUs nicht direkt eingebaut, folglich lässt sich das ganze nur mit Hilfe von Software regeln, die die entsprechenden Rechenregeln implementiert. Du wirst also nicht einfach "x := 2+4i;" in den Code schreiben können.

Was du brauchst ist ein Parser, oder aber eine Bibliothek, die entsprechende Methoden und Datentypen bereit stellt. Je nach Kenntnisstand und Zeit die du investieren willst könntest du dich selbst an so etwas wagen, oder z.B. das Teil hier nutzen (ist auf Anhieb der einzige/vollständigste hier, der u.a. auch mit komplexen Zahlen kann, den ich gefunden habe). Oder du versuchst dich daran zu orientieren beim Eigenbau - aber sei darauf hingewiesen, dass das sicherlich nicht "mal eben" zusammengestrickt ist, und es zu dem gesamten Themenbereich ganze Bücher gibt. (Stichwort: Compilerbau, Automatentheorie)

[WS1976]

Hallo,

komplexe Zahlen zu implementieren ist relativ einfach.
Sieh eine komplexe Zahl einfach als 2 dimensionalen Vektor.

z.B.

Delphi-Quellcode:

//komplexer Zahlentyp
complextyp=record
  re:real;
  im:real; 
end;

tcomplex=class
  z:complextyp;
  function add(a,b:complextyp):complextyp;
  function sub(a,b:complextyp):complextyp;
  ....
  //Hier implementierst du die weiteren Rechenroutinen
  .... 
  //das hier nimmst du um das Ganze darzustellen
  function display(a:complextyp):string;
end;

Dafür brauchst du keine Automatentheorie und auch keinen Parser. Die Automatentheorie bzw Compilerbau hat hier überhaupt nichts zu suchen und der Hinweis auf einen Parser geht an der Frage vorbei.
Selbst die Implementierung für exp, sin und cosinus sind so einfach, dass das eigentlich kein Problem darstellen sollte.
Vorrausgesetzt du hast das Basiswissen und kannst mit komplexen Zahlen umgehen.
Ansonsten empfehle ich ein mathematisches Fachbuch.
Ich glaub, dass es eine entsprechende Unit bereits gibt. Suche nach tcomplex.

Grüsse
Rainer

PS: Ich hab mir mal die Mühe gemacht und hier im Forum nach komplexen Zahlen, tcomplex und so weiter gesucht. Es gibt endlos viele Antworten auf deine Frage. Suchen muss man allerdings schon.

[mkinzler]

Welche Delphiversion? Ab D10 würde sich ein Record mit Klassenoperatoren anbieten. Mit diesem Typ kann dann wie mit den Standardtypen gearbeitet werden.

[Stutz]

HI,
erstmal danke für die guten Ansätze, ich denke damit kann ich etwas anfangen(ich denke es wird auf einen Parser hinauslaufen, der die Zahlen so zerlegt dass sie mit hilfe der von WS1976 angesprochenen Funktionen gerechnet werden können). Leider kann ich nicht sagen bis wann ich ein solches Programm fertiggestellt habe um genauere Auskünfte darüber zu machen. Aber ich werde den Threat erstmal als gelöst markieren.

liebe Grüße
Stutz


@ mkinzler: Wie oben schon erwähnt programmiere ich nicht mit delphi sondern mit der Open-source Alternative Lazarus, da ich unter Linux arbeite.

[mkinzler]

Klassenoperatoren werden auch von FPC unterstützt. Vgl Chapter 12 der Referenz ( am Beispiel von TComplex )

[Medium]

Zitat von WS1976:

Dafür brauchst du keine Automatentheorie und auch keinen Parser. Die Automatentheorie bzw Compilerbau hat hier überhaupt nichts zu suchen und der Hinweis auf einen Parser geht an der Frage vorbei.

Nur weiter gedacht. Klar, mit ein paar Funktionen kann man komplex rechnen. Da der TE aber u.a. davon sprach die i-Notation verwenden zu wollen, ist der Hinweis auf einen Parser alles andere als am Thema vorbei.
Zudem liest es sich so, als würde er dem Benutzer die Eingabe der Formeln ermöglichen, wodurch er an einem Parser schon garnicht mehr vorbei kommt.

[Stutz]

hi,

ich hab mal angefangen einen parser zu schreiben, der mir imaginär und realteil trennt. is zwar chaotisch und wahrscheinlich der am schlimmsten programmierte quellcode der hier bisher gepostet wird, aber ich kanns net besser und steh bisher noch dazu. falls ihr verbesserungsvorschläge habt, bin ich offen für alles.

Delphi-Quellcode:

function imaginaerteil_bestimmen(komplex:string):string;
var
   imaginaer,real,merker,vz:string;
   bimag:boolean;
   i:integer;
   offene_klammer:integer;
begin
   offene_klammer:=0;
   bimag := false;
   real := '';
   imaginaer :='';
   vz:='+';
   for i:=1to length(komplex)+1 do
   begin

      if (komplex[i] = '(')then
      offene_klammer := offene_klammer +1;


      if (komplex[i]=')')then
      offene_klammer := offene_klammer -1;


      if(offene_klammer =0) then //wenn an stelle i keine klammer offen ist
      begin


         if ((komplex[i] <> '+') and (komplex[i]<>'-')and (i<=length(komplex))) then  //wenn inerhalb der punkt vor strich rechnung
         begin
            merker := merker+komplex[i];
            if komplex[i]='i' then
               begin
               bimag := true;
               end;

         end

         else if i>1 then//wenn plus oder minus kommt die volle gleichung in imaginaerteil oder realteil speichern
         begin
            if bimag = true then
            begin
               imaginaer := imaginaer +vz+ merker;
               bimag := false;
            end
            else
            begin
               real := real+vz+merker;
            end;
            merker := '';
         end;



      //aktuelles vorzeichen merken
         if komplex[i]='-' then
         begin
            vz:='-';
         end;

         if komplex[i]='+' then
         begin
            vz:='+';
         end;



      end


      else//inerhalb einer oder mehreren klammern
      begin
         merker := merker + komplex[i];//klammer wird prinzipiell als ganzes betrachtet
         //markieren wenn imaginaere zahl
         if komplex[i]='i' then
         begin
            bimag := true;
         end;
      end;





   end;
   
   imaginaerteil_bestimmen := 'realteil: '+real + #13 +'imaginaerteil: '+ imaginaer;
end;

PS:mir fiel gerade auf dass es sehr verwirrend is dass die schleifenvariable i heißt und ich ständig nach i suche, ich glaube das sollte ich so schnell wie möglich ändern

gruß
stutz

[WS1976]

Hallo,

er will doch einen Taschenrechner programmieren.
Bei einem Taschenrechner, zumindest wenn er einen normalen Taschenrechner programmieren will, beschränkt sich das "parsen" nur auf die Umwandlung der Eingaben von maximal einer komplexen Zahl in ein internes Ablageformat.
BSP:
3 + 4i
Es gibt natürlich auch die Möglichkeit komplette Ausdrücke berechnen zu wollen ( z.B. (3+4i)*(6-7i) ) Davon war hier nie die Rede.

Ablauf (als Beispiel):
Eingabe komplexe Zahl
Eingabe Operator
Eingabe komplexe Zahl
Ergebnis erscheint.

Der Begriff "parsen" ist hier doch wohl völlig overstyled. Es wird doch nichts gemacht als ein String zerlegt. Ein Parser zerlegt einen String, analysiert diesen, reduziert (berechnet) den im String enthaltenen Ausdruck und legt das Ergebnis ab.
Die Hauptarbeit die der Parser leistet liegt im analysieren der Operatoren und im reduzieren.

Grüsse
Rainer

[Corpsman]

schau dir mal das Hier an.

das ist ein Generischer Taschenrechner. Dem köntest du das alles evtl beibringen