Komplexe Zahlen in C < C/C++ < Programmiersprachen < Praxis < Informatik < Vorhilfe
|
| Status: |
(Frage) beantwortet  | | Datum: | 21:37 So 31.03.2013 | | Autor: | Mija |
| Aufgabe | Definieren Sie einen Strukturdatentyp complex für das Rechnen mit komplexen Zahlen. Stellen Sie für diesen Datentyp die folgenden Funktionen bereit:
a) Die Funktion betrag() berechnet den Betrag einer komplexen Zahl.
b) Die Funktionen real() und imag() liefern den reellen bzw. den imaginären Teil einer komplexen Zahl.
c) Die Funktion print() gibt eine komplexe Zahl 1, 2 − 4, 3 i auf der Konsole in der Form (1.20, -4.30) aus.
d) Die Rechenfunktionen für die Addition add() und die Subtraktion sub(), Multiplikation mult() und Division div() zweier komplexen Zahlen.
e) read() zur Eingabe einer Variablen vom Typ complex über die Tastatur, d.h. des reellen und imaginären Anteils der Variablen.
f) set() zur Erzeugung einer Variablen vom Strukturdatentyp complex. Diese Funktion soll als Parameter zwei Gleitkommazahlen für den reellen bzw. den imaginären Teil bekommen und eine Variable vom Strukturdatentyp complex zurückliefern.
Schreiben Sie ein Hauptprogramm zum Testen aller dieser Funktionen (vorzugsweise eine switch-Anweisung). Der Dialog könnte so aussehen:
Komplexe Zahlen
===================
Eingabe 1. Zahl: 1
Betrag: 2
Reeller Teil: 3
Imaginaerer Teil: 4
-------------------
Eingabe 2. Zahl 5
Addieren 6
Subtrahieren 7
Multiplizieren 8
Dividieren 9
-------------------
Setzen 10
-------------------
Ende 0
===================
Ihre Wahl? 1
Benutzen Sie die Funktion print() bei der Ausgabe einer komplexen Zahl. |
Hallo, ich habe ein paar Probleme mit der oben stehenden Aufgabe bzw. einige Fragen dazu:
- Zu meinen Funktionen real() (Zeile 47) und imag() (Zeile 53) sagt Visual Studio, dass dies keine Funktionen sind. Was habe ich da falsch gemacht bzw. was muss ich ändern?
Außerdem sagt mir Visual Studio, dass es dort irgendwie pointer-to-Variablen sein müssen. Aber wie soll ich das da einbauen. Das brauche ich doch garnicht?!
- Irgendwie komme ich mit der read()-Funktion (ab Zeile 106) noch nicht zurecht. Könnte mir da bitte jemand helfen?
Ich würde mich sehr freuen, wenn mir jemand weiterhelfen könnte! 
Hier ist mein C-Code:
| 1: |
| | 2: | #include <stdio.h>
| | 3: | #include <stdlib.h>
| | 4: | #include <math.h>
| | 5: |
| | 6: | //Strukturdatentyp complex
| | 7: | typedef struct {
| | 8: | double real;
| | 9: | double imag;
| | 10: | } complex;
| | 11: |
| | 12: | //Funktionsdeklarationen
| | 13: | void clearBuffer();
| | 14: | double betrag(double,double);
| | 15: | double real(complex);
| | 16: | double imag(complex);
| | 17: | complex add(complex,complex);
| | 18: | complex sub(complex,complex);
| | 19: | complex mult(complex,complex);
| | 20: | complex divi(complex,complex);
| | 21: | void print(complex);
| | 22: | complex read(complex);
| | 23: | complex set(double,double);
| | 24: |
| | 25: |
| | 26: | //Funktionsdefinitionen
| | 27: |
| | 28: | //Puffer leeren
| | 29: | void clearBuffer()
| | 30: | {
| | 31: | char Dummy;
| | 32: | do
| | 33: | {
| | 34: | scanf("%c", &Dummy);
| | 35: | } while (Dummy != '\n');
| | 36: |
| | 37: | return;
| | 38: | }
| | 39: |
| | 40: | //Berechnung des Betrags
| | 41: | double betrag(double real, double imag)
| | 42: | {
| | 43: | return sqrt(real*real+imag*imag);
| | 44: | }
| | 45: |
| | 46: | //liefert Realteil einer komplexen Zahl
| | 47: | double real(complex z)
| | 48: | {
| | 49: | return z.real;
| | 50: | }
| | 51: |
| | 52: | //liefert Imaginerteil einer komplexen Zahl
| | 53: | double imag(complex z)
| | 54: | {
| | 55: | return z.imag;
| | 56: | }
| | 57: |
| | 58: | //Addition von komplexen Zahlen
| | 59: | complex add(complex x, complex y)
| | 60: | {
| | 61: | complex ausgabewert;
| | 62: | ausgabewert.real = x.real + y.real;
| | 63: | ausgabewert.imag = x.imag + y.imag;
| | 64: | return ausgabewert;
| | 65: | }
| | 66: |
| | 67: | //Subtraktion von komplexen Zahlen
| | 68: | complex sub(complex x, complex y)
| | 69: | {
| | 70: | complex ausgabewert;
| | 71: | ausgabewert.real = x.real - y.real;
| | 72: | ausgabewert.imag = x.imag - y.imag;
| | 73: | return ausgabewert;
| | 74: | }
| | 75: |
| | 76: | //Multiplikation von komplexen Zahlen
| | 77: | complex mult(complex x, complex y)
| | 78: | {
| | 79: | complex ausgabewert;
| | 80: | ausgabewert.real = x.real*y.real - x.imag*y.imag;
| | 81: | ausgabewert.imag = x.real*y.imag - x.imag*y.real;
| | 82: | return ausgabewert;
| | 83: | }
| | 84: |
| | 85: | //Division von komplexen Zahlen
| | 86: | complex divi(complex x, complex y)
| | 87: | {
| | 88: | complex ausgabewert;
| | 89: | if (y.real==0 && y.imag==0)
| | 90: | perror("Division durch 0!");
| | 91: | else
| | 92: | {
| | 93: | ausgabewert.real = (x.real*y.real - x.imag*y.imag) / (y.imag*y.imag + x.imag*x.imag);
| | 94: | ausgabewert.imag = (x.real*y.imag - x.imag*y.real) / (y.imag*y.imag + x.imag*x.imag);
| | 95: | }
| | 96: | return ausgabewert;
| | 97: | }
| | 98: |
| | 99: | //Ausgabefunktion
| | 100: | void print(complex z)
| | 101: | {
| | 102: | printf("(%.2f%,.2f)\n",z.real,z.imag);
| | 103: | }
| | 104: |
| | 105: | //Eingabefunktion
| | 106: | complex read(complex z)
| | 107: | {
| | 108: | double real;
| | 109: | double imag;
| | 110: | printf("Geben Sie eine komplexe Zahl ein, indem Sie zuerst den Realteil\n");
| | 111: | printf("und dann durch enter getrennt den Imaginaerteil eingeben.\n");
| | 112: | scanf("%f", &z.real);
| | 113: | scanf("%f", &z.imag);
| | 114: | /*real = z.real;
| | 115: | imag = z.imag;
| | 116: | return real;
| | 117: | return imag;*/
| | 118: | }
| | 119: |
| | 120: | //Funktion zur Erzeugung einer Variablen vom Strukturdatentyp complex
| | 121: | complex set(double real, double imag)
| | 122: | {
| | 123: | complex ausgabewert;
| | 124: | printf("Realteil: ");
| | 125: | scanf("%f", &real);
| | 126: | printf("Imaginaerteil: ");
| | 127: | scanf("%f", &imag);
| | 128: | ausgabewert.real = real;
| | 129: | ausgabewert.imag = imag;
| | 130: | return ausgabewert;
| | 131: | }
| | 132: |
| | 133: |
| | 134: | //Main-Programm
| | 135: | int main(void)
| | 136: | {
| | 137: | int wahl;
| | 138: | double real, imag, ergreell;
| | 139: | complex x,y,z, ergcomplex;
| | 140: |
| | 141: | //Eingabe
| | 142: | printf("Komplexe Zahlen");
| | 143: | printf("===================");
| | 144: | printf("Eingabe 1. Zahl: 1");
| | 145: | printf("Betrag: 2");
| | 146: | printf("Reeller Teil: 3");
| | 147: | printf("Imaginaerer Teil: 4");
| | 148: | printf("-------------------");
| | 149: | printf("Eingabe 2. Zahl: 5");
| | 150: | printf("Addieren: 6");
| | 151: | printf("Subtrahieren: 7");
| | 152: | printf("Multiplizieren: 8");
| | 153: | printf("Dividieren: 9");
| | 154: | printf("-------------------");
| | 155: | printf("Setzen: 10");
| | 156: | printf("-------------------");
| | 157: | printf("Ende: 0");
| | 158: | printf("===================");
| | 159: | printf("Ihre Wahl? ");
| | 160: | scanf("%d", &wahl);
| | 161: |
| | 162: | switch(wahl)
| | 163: | {
| | 164: | case 1: ergcomplex = read(z); print(ergcomplex); break;
| | 165: | case 2: ergreell = betrag(real,imag); printf("(%lf,0.00)\n", ergreell); break;
| | 166: | case 3: ergreell = real(z); printf("(%lf,0.00)\n", ergreell); break;
| | 167: | case 4: ergreell = imag(z); printf("(%lf,0.00)\n", ergreell); break;
| | 168: | case 5: ergcomplex = read(z); print(ergcomplex); break;
| | 169: | case 6: ergcomplex = add(x,y); print(ergcomplex); break;
| | 170: | case 7: ergcomplex = sub(x,y); print(ergcomplex); break;
| | 171: | case 8: ergcomplex = mult(x,y); print(ergcomplex); break;
| | 172: | case 9: ergcomplex = divi(x,y); print(ergcomplex); break;
| | 173: | case 10: ergcomplex = set(real,imag); print(ergcomplex); break;
| | 174: | case 0: printf("\nEnde.\n"); break;
| | 175: | default: printf("\nUngueltige Eingabe!\n"); break;
| | 176: | }
| | 177: |
| | 178: |
| | 179: | clearBuffer();
| | 180: |
| | 181: | return 0;
| | 182: | } |
|
|
| |
|
Hallo Mija,
> Definieren Sie einen Strukturdatentyp complex
> für das Rechnen mit komplexen Zahlen. Stellen Sie für
> diesen Datentyp die folgenden Funktionen bereit:
> a) Die Funktion betrag() berechnet den Betrag einer
> komplexen Zahl.
> b) Die Funktionen real() und imag() liefern den reellen
> bzw. den imaginären Teil einer komplexen Zahl.
> c) Die Funktion print() gibt eine komplexe Zahl 1, 2 −
> 4, 3 i auf der Konsole in der Form (1.20, -4.30) aus.
> d) Die Rechenfunktionen für die Addition add() und die
> Subtraktion sub(), Multiplikation mult() und Division div()
> zweier komplexen Zahlen.
> e) read() zur Eingabe einer Variablen vom Typ complex
> über die Tastatur, d.h. des reellen und imaginären
> Anteils der Variablen.
> f) set() zur Erzeugung einer Variablen vom
> Strukturdatentyp complex. Diese Funktion soll als Parameter
> zwei Gleitkommazahlen für den reellen bzw. den imaginären
> Teil bekommen und eine Variable vom Strukturdatentyp
> complex zurückliefern.
> Schreiben Sie ein Hauptprogramm zum Testen aller dieser
> Funktionen (vorzugsweise eine switch-Anweisung). Der Dialog
> könnte so aussehen:
>
> Komplexe Zahlen
> ===================
> Eingabe 1. Zahl: 1
> Betrag: 2
> Reeller Teil: 3
> Imaginaerer Teil: 4
> -------------------
> Eingabe 2. Zahl 5
> Addieren 6
> Subtrahieren 7
> Multiplizieren 8
> Dividieren 9
> -------------------
> Setzen 10
> -------------------
> Ende 0
> ===================
> Ihre Wahl? 1
>
> Benutzen Sie die Funktion print() bei der Ausgabe einer
> komplexen Zahl.
>
> Hallo, ich habe ein paar Probleme mit der oben stehenden
> Aufgabe bzw. einige Fragen dazu:
>
> - Zu meinen Funktionen real() (Zeile 47) und imag() (Zeile
> 53) sagt Visual Studio, dass dies keine Funktionen sind.
> Was habe ich da falsch gemacht bzw. was muss ich ändern?
Nun in main wurden die Variablen real und imag als double definiert.
Gleichzeitig werden in main auch Funktionen gleichen Namens aufgerufen.
Das kannst Du beheben, in dem Du die Variablennamen änderst.
> Außerdem sagt mir Visual Studio, dass es dort irgendwie
> pointer-to-Variablen sein müssen. Aber wie soll ich das da
> einbauen. Das brauche ich doch garnicht?!
> - Irgendwie komme ich mit der read()-Funktion (ab Zeile
> 106) noch nicht zurecht. Könnte mir da bitte jemand
> helfen?
Erstens liest Du double Variablen ein.
Zweitens erwartet scanf dann eine Adresse.
Drittens müßtest Du noch in eine float-Adresse konvertieren.
Statt
scanf("%f", z.real);
muss es
scanf("%f", (float *) &z.real);
lauten.
Bei der Ausgabefunktion void print(complex z) ist das Format anzupassen.
>
> Ich würde mich sehr freuen, wenn mir jemand weiterhelfen
> könnte!
Gruss
MathePower
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 18:07 Mo 01.04.2013 | | Autor: | Mija |
Hallo MathePower, vielen Dank für deine schnelle Antwort!
Ich bekomme zwar momentan keine Fehlermeldungen mehr, aber Warnungen, dass ich die Variablen x,y und z noch (in der Main) initialisieren muss.
Wie mache ich das denn mir typedef struct - Strukturdatentypen? Muss ich das ganz oben bei der Deklaration schon machen?
Ist meine aktuelle read()-Funktion (Zeile 106) denn so richtig?
| 1: |
| | 2: | #include <stdio.h>
| | 3: | #include <stdlib.h>
| | 4: | #include <math.h>
| | 5: |
| | 6: | //Strukturdatentyp complex
| | 7: | typedef struct {
| | 8: | double real;
| | 9: | double imag;
| | 10: | } complex;
| | 11: |
| | 12: | //Funktionsdeklarationen
| | 13: | void clearBuffer();
| | 14: | double betrag(double,double);
| | 15: | double real(complex);
| | 16: | double imag(complex);
| | 17: | complex add(complex,complex);
| | 18: | complex sub(complex,complex);
| | 19: | complex mult(complex,complex);
| | 20: | complex divi(complex,complex);
| | 21: | void print(complex);
| | 22: | complex read(complex);
| | 23: | complex set(double,double);
| | 24: |
| | 25: |
| | 26: | //Funktionsdefinitionen
| | 27: |
| | 28: | //Puffer leeren
| | 29: | void clearBuffer()
| | 30: | {
| | 31: | char Dummy;
| | 32: | do
| | 33: | {
| | 34: | scanf_s("%c", &Dummy);
| | 35: | } while (Dummy != '\n');
| | 36: |
| | 37: | return;
| | 38: | }
| | 39: |
| | 40: | //Berechnung des Betrags
| | 41: | double betrag(double real, double imag)
| | 42: | {
| | 43: | return sqrt(real*real+imag*imag);
| | 44: | }
| | 45: |
| | 46: | //liefert Realteil einer komplexen Zahl
| | 47: | double real(complex z)
| | 48: | {
| | 49: | return z.real;
| | 50: | }
| | 51: |
| | 52: | //liefert Imaginerteil einer komplexen Zahl
| | 53: | double imag(complex z)
| | 54: | {
| | 55: | return z.imag;
| | 56: | }
| | 57: |
| | 58: | //Addition von komplexen Zahlen
| | 59: | complex add(complex x, complex y)
| | 60: | {
| | 61: | complex ausgabewert;
| | 62: | ausgabewert.real = x.real + y.real;
| | 63: | ausgabewert.imag = x.imag + y.imag;
| | 64: | return ausgabewert;
| | 65: | }
| | 66: |
| | 67: | //Subtraktion von komplexen Zahlen
| | 68: | complex sub(complex x, complex y)
| | 69: | {
| | 70: | complex ausgabewert;
| | 71: | ausgabewert.real = x.real - y.real;
| | 72: | ausgabewert.imag = x.imag - y.imag;
| | 73: | return ausgabewert;
| | 74: | }
| | 75: |
| | 76: | //Multiplikation von komplexen Zahlen
| | 77: | complex mult(complex x, complex y)
| | 78: | {
| | 79: | complex ausgabewert;
| | 80: | ausgabewert.real = x.real*y.real - x.imag*y.imag;
| | 81: | ausgabewert.imag = x.real*y.imag - x.imag*y.real;
| | 82: | return ausgabewert;
| | 83: | }
| | 84: |
| | 85: | //Division von komplexen Zahlen
| | 86: | complex divi(complex x, complex y)
| | 87: | {
| | 88: | complex ausgabewert;
| | 89: | if (y.real==0 && y.imag==0)
| | 90: | perror("Division durch 0!");
| | 91: | else
| | 92: | {
| | 93: | ausgabewert.real = (x.real*y.real - x.imag*y.imag) / (y.imag*y.imag + x.imag*x.imag);
| | 94: | ausgabewert.imag = (x.real*y.imag - x.imag*y.real) / (y.imag*y.imag + x.imag*x.imag);
| | 95: | }
| | 96: | return ausgabewert;
| | 97: | }
| | 98: |
| | 99: | //Ausgabefunktion
| | 100: | void print(complex z)
| | 101: | {
| | 102: | printf("\n\n(%.2lf,%.2lf)\n\n",z.real,z.imag);
| | 103: | }
| | 104: |
| | 105: | //Eingabefunktion
| | 106: | complex read(complex z)
| | 107: | {
| | 108: | //double real;
| | 109: | //double imag;
| | 110: | printf("Geben Sie eine komplexe Zahl ein, indem Sie zuerst den Realteil\n");
| | 111: | printf("und dann durch enter getrennt den Imaginaerteil eingeben.\n");
| | 112: | scanf_s("%f", &z.real);
| | 113: | scanf_s("%f", &z.imag);
| | 114: | return z;
| | 115: | }
| | 116: |
| | 117: | //Funktion zur Erzeugung einer Variablen vom Strukturdatentyp complex
| | 118: | complex set(double real, double imag)
| | 119: | {
| | 120: | complex ausgabewert;
| | 121: | printf("Realteil: ");
| | 122: | scanf_s("%f", &real);
| | 123: | printf("Imaginaerteil: ");
| | 124: | scanf_s("%f", &imag);
| | 125: | ausgabewert.real = real;
| | 126: | ausgabewert.imag = imag;
| | 127: | return ausgabewert;
| | 128: | }
| | 129: |
| | 130: |
| | 131: | //Main-Programm
| | 132: | int main(void)
| | 133: | {
| | 134: | int wahl;
| | 135: | double realt=0, imagt=0, ergreell=0;
| | 136: | complex x,y,z, ergcomplex;
| | 137: |
| | 138: | //Eingabe
| | 139: | printf("Komplexe Zahlen\n");
| | 140: | printf("===================\n");
| | 141: | printf("Eingabe 1. Zahl: 1\n");
| | 142: | printf("Betrag: 2\n");
| | 143: | printf("Reeller Teil: 3\n");
| | 144: | printf("Imaginaerer Teil: 4\n");
| | 145: | printf("-------------------\n");
| | 146: | printf("Eingabe 2. Zahl: 5\n");
| | 147: | printf("Addieren: 6\n");
| | 148: | printf("Subtrahieren: 7\n");
| | 149: | printf("Multiplizieren: 8\n");
| | 150: | printf("Dividieren: 9\n");
| | 151: | printf("-------------------\n");
| | 152: | printf("Setzen: 10\n");
| | 153: | printf("-------------------\n");
| | 154: | printf("Ende: 0\n");
| | 155: | printf("===================\n");
| | 156: | printf("Ihre Wahl? ");
| | 157: | scanf_s("%d", &wahl);
| | 158: |
| | 159: | switch(wahl)
| | 160: | {
| | 161: | case 1: read(z); break;
| | 162: | case 2: ergreell = betrag(realt,imagt); printf("(%lf,0.00)\n", ergreell); break;
| | 163: | case 3: ergreell = real(z); printf("(%lf,0.00)\n", ergreell); break;
| | 164: | case 4: ergreell = imag(z); printf("(%lf,0.00)\n", ergreell); break;
| | 165: | case 5: read(z); break;
| | 166: | case 6: ergcomplex = add(x,y); print(ergcomplex); break;
| | 167: | case 7: ergcomplex = sub(x,y); print(ergcomplex); break;
| | 168: | case 8: ergcomplex = mult(x,y); print(ergcomplex); break;
| | 169: | case 9: ergcomplex = divi(x,y); print(ergcomplex); break;
| | 170: | case 10: ergcomplex = set(realt,imagt); print(ergcomplex); break;
| | 171: | case 0: printf("\nEnde.\n"); break;
| | 172: | default: printf("\nUngueltige Eingabe!\n"); break;
| | 173: | }
| | 174: |
| | 175: |
| | 176: | clearBuffer();
| | 177: |
| | 178: | return 0;
| | 179: | } |
|
|
|
| |
|
Hallo Mija,
> Hallo MathePower, vielen Dank für deine schnelle Antwort!
>
> Ich bekomme zwar momentan keine Fehlermeldungen mehr, aber
> Warnungen, dass ich die Variablen x,y und z noch (in der
> Main) initialisieren muss.
> Wie mache ich das denn mir typedef struct -
> Strukturdatentypen? Muss ich das ganz oben bei der
> Deklaration schon machen?
Nein.
Das machst Du wenn die Variablen definiert werden.
Das geht dann so:
complex x={0,0}, y={0,0},z={0,0};
>
> Ist meine aktuelle read()-Funktion (Zeile 106) denn so
> richtig?
>
Eventuell kannst Du bei der [mm] scanf\_s-Funktion [/mm] als Format "%lf" verwenden,
da der Real- und Imaginärteil als double deklariert wurden.
Gruss
MathePower
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 19:33 Mo 01.04.2013 | | Autor: | Mija |
Hallo Mathepower, jetzt bin ich fast fertig
Eine Frage habe ich noch:
Wenn ich den Real- und Imaginaerteil für komplexe Zahlen eingegeben habe, dann bekomme ich zwar die richtige Ausgabe als Rückversicherung, dass alles stimmt. Aber nachdem irgendeine Funktion, z.B. Addieren angewendet wurde, bekomme ich als Ergebnis immer (0.00,0.00).
Wo ist da mein Fehler? %lf stimmt doch für die Ausgabe, oder?
| 1: |
| | 2: | #include <stdio.h>
| | 3: | #include <stdlib.h>
| | 4: | #include <math.h>
| | 5: |
| | 6: | //Strukturdatentyp complex
| | 7: | typedef struct{
| | 8: | double real;
| | 9: | double imag;
| | 10: | } complex;
| | 11: |
| | 12: |
| | 13: | //Funktionsdeklarationen
| | 14: | void clearBuffer();
| | 15: | double betrag(double,double);
| | 16: | double real(complex);
| | 17: | double imag(complex);
| | 18: | complex add(complex,complex);
| | 19: | complex sub(complex,complex);
| | 20: | complex mult(complex,complex);
| | 21: | complex divi(complex,complex);
| | 22: | void print(complex);
| | 23: | complex read(complex);
| | 24: | complex set(double,double);
| | 25: |
| | 26: |
| | 27: | //Funktionsdefinitionen
| | 28: |
| | 29: | //Puffer leeren
| | 30: | void clearBuffer()
| | 31: | {
| | 32: | char Dummy;
| | 33: | do
| | 34: | {
| | 35: | scanf_s("%c", &Dummy);
| | 36: | } while (Dummy != '\n');
| | 37: |
| | 38: | return;
| | 39: | }
| | 40: |
| | 41: | //Berechnung des Betrags
| | 42: | double betrag(double real, double imag)
| | 43: | {
| | 44: | return sqrt(real*real+imag*imag);
| | 45: | }
| | 46: |
| | 47: | //liefert Realteil einer komplexen Zahl
| | 48: | double real(complex z)
| | 49: | {
| | 50: | return z.real;
| | 51: | }
| | 52: |
| | 53: | //liefert Imaginerteil einer komplexen Zahl
| | 54: | double imag(complex z)
| | 55: | {
| | 56: | return z.imag;
| | 57: | }
| | 58: |
| | 59: | //Addition von komplexen Zahlen
| | 60: | complex add(complex x, complex y)
| | 61: | {
| | 62: | complex ausgabewert;
| | 63: | ausgabewert.real = x.real + y.real;
| | 64: | ausgabewert.imag = x.imag + y.imag;
| | 65: | return ausgabewert;
| | 66: | }
| | 67: |
| | 68: | //Subtraktion von komplexen Zahlen
| | 69: | complex sub(complex x, complex y)
| | 70: | {
| | 71: | complex ausgabewert;
| | 72: | ausgabewert.real = x.real - y.real;
| | 73: | ausgabewert.imag = x.imag - y.imag;
| | 74: | return ausgabewert;
| | 75: | }
| | 76: |
| | 77: | //Multiplikation von komplexen Zahlen
| | 78: | complex mult(complex x, complex y)
| | 79: | {
| | 80: | complex ausgabewert;
| | 81: | ausgabewert.real = x.real*y.real - x.imag*y.imag;
| | 82: | ausgabewert.imag = x.real*y.imag - x.imag*y.real;
| | 83: | return ausgabewert;
| | 84: | }
| | 85: |
| | 86: | //Division von komplexen Zahlen
| | 87: | complex divi(complex x, complex y)
| | 88: | {
| | 89: | complex ausgabewert;
| | 90: | if (y.real==0 && y.imag==0)
| | 91: | perror("Division durch 0!");
| | 92: | else
| | 93: | {
| | 94: | ausgabewert.real = (x.real*y.real - x.imag*y.imag) / (y.imag*y.imag + x.imag*x.imag);
| | 95: | ausgabewert.imag = (x.real*y.imag - x.imag*y.real) / (y.imag*y.imag + x.imag*x.imag);
| | 96: | }
| | 97: | return ausgabewert;
| | 98: | }
| | 99: |
| | 100: | //Ausgabefunktion
| | 101: | void print(complex z)
| | 102: | {
| | 103: | printf("\n\n(%.2lf,%.2lf)\n\n",z.real,z.imag);
| | 104: | }
| | 105: |
| | 106: | //Eingabefunktion
| | 107: | complex read(complex z)
| | 108: | {
| | 109: | //double real;
| | 110: | //double imag;
| | 111: | printf("Geben Sie eine komplexe Zahl ein, indem Sie zuerst den Realteil\n");
| | 112: | printf("und dann durch enter getrennt den Imaginaerteil eingeben.\n");
| | 113: | scanf_s("%lf", &z.real);
| | 114: | //clearBuffer();
| | 115: | scanf_s("%lf", &z.imag);
| | 116: | //clearBuffer();
| | 117: | printf("Ihre Eingabe: (%.2lf,%.2lf)\n\n",z.real,z.imag);
| | 118: | return z;
| | 119: | }
| | 120: |
| | 121: | //Funktion zur Erzeugung einer Variablen vom Strukturdatentyp complex
| | 122: | complex set(double real, double imag)
| | 123: | {
| | 124: | complex ausgabewert;
| | 125: | printf("Realteil: ");
| | 126: | scanf_s("%lf", &real);
| | 127: | clearBuffer();
| | 128: | printf("Imaginaerteil: ");
| | 129: | scanf_s("%lf", &imag);
| | 130: | clearBuffer();
| | 131: | ausgabewert.real = real;
| | 132: | ausgabewert.imag = imag;
| | 133: | return ausgabewert;
| | 134: | }
| | 135: |
| | 136: |
| | 137: | //Main-Programm
| | 138: | int main(void)
| | 139: | {
| | 140: | int wahl;
| | 141: | double realt=0.0, imagt=0.0, ergreell=0.0;
| | 142: | complex x={0.0, 0.0}, y={0.0, 0.0}, z={0.0, 0.0}, ergcomplex={0.0, 0.0};
| | 143: |
| | 144: | //Eingabe
| | 145: | do{
| | 146: | printf("Komplexe Zahlen\n");
| | 147: | printf("===================\n");
| | 148: | printf("Eingabe 1. Zahl: 1\n");
| | 149: | printf("Betrag: 2\n");
| | 150: | printf("Reeller Teil: 3\n");
| | 151: | printf("Imaginaerer Teil: 4\n");
| | 152: | printf("-------------------\n");
| | 153: | printf("Eingabe 2. Zahl: 5\n");
| | 154: | printf("Addieren: 6\n");
| | 155: | printf("Subtrahieren: 7\n");
| | 156: | printf("Multiplizieren: 8\n");
| | 157: | printf("Dividieren: 9\n");
| | 158: | printf("-------------------\n");
| | 159: | printf("Setzen: 10\n");
| | 160: | printf("-------------------\n");
| | 161: | printf("Ende: 0\n");
| | 162: | printf("===================\n");
| | 163: | printf("Ihre Wahl? ");
| | 164: | scanf_s("%d", &wahl);
| | 165: |
| | 166: | switch(wahl)
| | 167: | {
| | 168: | case 1: read(z); break;
| | 169: | case 2: ergreell = betrag(realt,imagt); printf("\nBetrag: |z| = %.2lf\n\n", ergreell); break;
| | 170: | case 3: ergreell = real(z); printf("\nRealteil: x = %.2lf\n\n", ergreell); break;
| | 171: | case 4: ergreell = imag(z); printf("\nImaginaerteil: y = %.2lf\n\n", ergreell); break;
| | 172: | case 5: read(z); break;
| | 173: | case 6: ergcomplex = add(x,y); print(ergcomplex); break;
| | 174: | case 7: ergcomplex = sub(x,y); print(ergcomplex); break;
| | 175: | case 8: ergcomplex = mult(x,y); print(ergcomplex); break;
| | 176: | case 9: ergcomplex = divi(x,y); print(ergcomplex); break;
| | 177: | case 10: ergcomplex = set(realt,imagt); print(ergcomplex); break;
| | 178: | case 0: printf("\nEnde.\n"); break;
| | 179: | default: printf("\nUngueltige Eingabe!\n"); break;
| | 180: | }
| | 181: |
| | 182: | clearBuffer();
| | 183: |
| | 184: | } while (wahl==1 || wahl==5);
| | 185: |
| | 186: | return 0;
| | 187: | } |
|
|
|
| |
|
Hallo Mija,
> Hallo Mathepower, jetzt bin ich fast fertig
>
> Eine Frage habe ich noch:
> Wenn ich den Real- und Imaginaerteil für komplexe Zahlen
> eingegeben habe, dann bekomme ich zwar die richtige Ausgabe
> als Rückversicherung, dass alles stimmt. Aber nachdem
> irgendeine Funktion, z.B. Addieren angewendet wurde,
> bekomme ich als Ergebnis immer (0.00,0.00).
> Wo ist da mein Fehler? %lf stimmt doch für die Ausgabe,
> oder?
>
Ja, das stimmt.
Das das Ergebnis so wwie beschrieben ausgegeben wird,
liegt am Ausgabeformat "%.2lf".
Gruss
MathePower
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 20:10 Mo 01.04.2013 | | Autor: | Mija |
Ja, aber warum bekomme ich immer nur Nullen als Lösung heraus?
|
|
|
| |
|
Hallo Mija,
> Ja, aber warum bekomme ich immer nur Nullen als Lösung
> heraus?
Die komplexen Zahlen x und y haben nach wie vor den Wert (0,0).
Willst Du dies veränderen, dann musst Du, bevor Du z.B. addierst,
den Benutzer zur Eingabe dieser komplexen Zahlen auffordern.
Gruss
MathePower
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 20:34 Mo 01.04.2013 | | Autor: | Mija |
Wenn ich die komplexen Zahlen x und y eingebe (also wahl=1 und dann wahl=5, also die read()-Funktion angewendet wird - dort werden Sie ja richtig eingelesen), und dann die Zahlen z.B. addieren will, dann kommen trotzdem nur Nullen als Lösungen heraus..
|
|
|
| |
|
Hallo Mija,
> Wenn ich die komplexen Zahlen x und y eingebe (also wahl=1
> und dann wahl=5, also die read()-Funktion angewendet wird -
> dort werden Sie ja richtig eingelesen), und dann die Zahlen
> z.B. addieren will, dann kommen trotzdem nur Nullen als
> Lösungen heraus..
Das ist klar, da Du die Variable z einliest (1)
und die Variablen x und y addierst (5).
Das musst Du dann in etwa so ändern:
case 6: read(x);read(y);ergcomplex = add(x,y); print(ergcomplex); break;
Desweiteren kann entweder nur eingegeben (1)
oder addiert (5) werden, da der Benutzer nur einmal die Wahl hat.
Gruss
MathePower
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 20:51 Mo 01.04.2013 | | Autor: | Mija |
Ich hatte eine do-while-Schleife gemacht, die solange läuft solange man die erste oder zweite Zahl eingegeben hat.
Davon mal abgesehen habe es mal so ausprobiert wie du vorgeschlagen hast, aber dann bekomme ich leider auch nur Nullen heraus.
|
|
|
| |
|
Hallo Mija,
> Ich hatte eine do-while-Schleife gemacht, die solange
> läuft solange man die erste oder zweite Zahl eingegeben
> hat.
>
> Davon mal abgesehen habe es mal so ausprobiert wie du
> vorgeschlagen hast, aber dann bekomme ich leider auch nur
> Nullen heraus.
Es muss natürlich so lauten:
x=read(x);y=read(y);
Dann sollte das funktionieren.
Gruss
MathePower
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig  | | Datum: | 21:30 Mo 01.04.2013 | | Autor: | Mija |
Juhu, es funktioniert!!
Vielen Dank für deine Geduld!
|
|
|
|
