Wie arbeitet man mit komplexen Zahlen in C?

Lesezeit: 7 Minuten

Benutzeravatar von Charles Brunet
Karl Brunett

Wie kann ich mit komplexen Zahlen in C arbeiten? Ich sehe, es gibt eine complex.h Header-Datei, aber sie gibt mir nicht viele Informationen darüber, wie man sie benutzt. Wie greife ich effizient auf Real- und Imaginärteile zu? Gibt es native Funktionen, um Modul und Phase zu erhalten?

Dieser Code wird Ihnen helfen und ist ziemlich selbsterklärend:

#include <stdio.h>      /* Standard Library of Input and Output */
#include <complex.h>    /* Standard Library of Complex Numbers */

int main() {

    double complex z1 = 1.0 + 3.0 * I;
    double complex z2 = 1.0 - 4.0 * I;

    printf("Working with complex numbers:\n\v");

    printf("Starting values: Z1 = %.2f + %.2fi\tZ2 = %.2f %+.2fi\n", creal(z1), cimag(z1), creal(z2), cimag(z2));

    double complex sum = z1 + z2;
    printf("The sum: Z1 + Z2 = %.2f %+.2fi\n", creal(sum), cimag(sum));

    double complex difference = z1 - z2;
    printf("The difference: Z1 - Z2 = %.2f %+.2fi\n", creal(difference), cimag(difference));

    double complex product = z1 * z2;
    printf("The product: Z1 x Z2 = %.2f %+.2fi\n", creal(product), cimag(product));

    double complex quotient = z1 / z2;
    printf("The quotient: Z1 / Z2 = %.2f %+.2fi\n", creal(quotient), cimag(quotient));

    double complex conjugate = conj(z1);
    printf("The conjugate of Z1 = %.2f %+.2fi\n", creal(conjugate), cimag(conjugate));

    return 0;
}

mit:

creal(z1): Holen Sie sich den Realteil (für Float crealf(z1)für langes Doppel creall(z1))

cimag(z1): Holen Sie sich den Imaginärteil (für Float cimagf(z1)für langes Doppel cimagl(z1))

Ein weiterer wichtiger Punkt, den Sie bei der Arbeit mit komplexen Zahlen beachten sollten, sind die Funktionen wie cos(), exp() und sqrt() müssen durch ihre komplexen Formen ersetzt werden, z ccos(), cexp(), csqrt().

  • Was ist das double complex? Ist das eine Spracherweiterung oder eine Makromagie?

    – Kalmarius

    16. Dezember 2014 um 18:55 Uhr


  • @Calmarius complex ist ein Standard-c99-Typ (unter der Haube von GCC ist es eigentlich ein Alias ​​für den _Complex-Typ).

    – Schnaps

    12. April 2015 um 8:50 Uhr


  • @Snaipe: complex ist kein Typ. Es ist ein Makro, das erweitert wird _Complexdas ist ein Typ Bezeichner, aber kein eigener Typ. Die komplexen Typen sind float _Complex, double _Complexund long double _Complex.

    – Keith Thompson

    25. Mai 2015 um 8:22 Uhr

  • Es ist nicht nur GCC, es ist im Standard definiert, dass _Complex ein Typbezeichner ist und complex.h ein komplexes Makro hat, das zu _Complex erweitert wird. Gleiches gilt für _Bool und stdbool.h.

    – jv110

    13. Juli 2018 um 19:14 Uhr

Benutzeravatar von osgx
osgx

Komplexe Typen sind in der C-Sprache seit dem C99-Standard (-std=c99 Option von GCC). Einige Compiler können komplexe Typen sogar in früheren Modi implementieren, aber dies ist eine nicht standardmäßige und nicht portierbare Erweiterung (z. B. IBM XL, GCC, kann Intel sein, … ).

Sie können von beginnen http://en.wikipedia.org/wiki/Complex.h – Es gibt eine Beschreibung der Funktionen von complex.h

Dieses Handbuch http://pubs.opengroup.org/onlinepubs/009604499/basedefs/complex.h.html enthält auch einige Informationen über Makros.

Um eine komplexe Variable zu deklarieren, verwenden Sie

  double _Complex  a;        // use c* functions without suffix

oder

  float _Complex   b;        // use c*f functions - with f suffix
  long double _Complex c;    // use c*l functions - with l suffix

Um einem Komplex einen Wert zu geben, verwenden Sie _Complex_I Makro aus complex.h:

  float _Complex d = 2.0f + 2.0f*_Complex_I;

(Eigentlich kann es hier zu Problemen kommen (0,-0i) Zahlen und NaNs in der einzelnen Hälfte des Komplexes)

Modul ist cabs(a)/cabsl(c)/cabsf(b); Realteil ist creal(a)Eingebildet ist cimag(a). carg(a) ist für komplexe Argumente.

Um direkt auf einen echten Bildteil zuzugreifen (lesen/schreiben), können Sie dies verwenden nicht tragbar GCC-Erweiterung:

 __real__ a = 1.4;
 __imag__ a = 2.0;
 float b = __real__ a;

  • Fast jede komplexe Funktion wird vom Compiler auf effiziente Weise als eingebaute Funktion implementiert. Verwenden Sie einfach einen modernen Compiler und geben Sie ihm ein Optimierungsniveau ungleich Null.

    – osgx

    21. Juni 2011 um 0:07 Uhr


  • Zu Ihrer Information, da das OP Python-Bindungen erwähnt, versuche ich, mich bei der Arbeit mit Python an C89 zu halten (da der Rest des Python-Codes C89 ist, und wenn Sie möchten, dass Ihre Erweiterung unter Windows ausgeführt wird, wird sie normalerweise mit MVSC kompiliert, das auf beschränkt ist C89). Ich weiß aber nicht, ob es zwingend notwendig ist.

    – dezent

    9. Juli 2013 um 7:59 Uhr

  • Der Ausdruck (complex float) { r, i } kann auch verwendet werden, um die einzelnen Teile der Zahl unabhängig voneinander festzulegen (wobei der Realteil beispielsweise INF und der Imaginärteil NAN sein kann). Das vermeidet das GCC-spezifische Schlüsselwort, obwohl ich nicht sicher bin, ob es tatsächlich portabel ist.

    – Cleong

    25. April 2014 um 19:36 Uhr

  • Beachten Sie, dass die Complex-Unterstützung in C99 optional ist: Compiler haben sie möglicherweise einfach nicht, wenn sie definieren __STDC_NO_COMPLEX__. In der Praxis wird es jedoch auf den wichtigsten Compilern implementiert.

    – Ciro Santilli OurBigBook.com

    17. September 2014 um 12:04 Uhr


  • Jasen, siehe Seite 182 des N1256-Entwurfs open-std.org/jtc1/sc22/wg14/www/docs/n1256.pdf#page=182 “7.3 Komplexe Arithmetik “. Ein solches Schlüsselwort wurde wahrscheinlich in C99 ausgewählt, um vorhandene c (C90)-Programme, die komplexe von Hand implementieren, nicht zu beschädigen. Wenn enthalten ist, complex wird als Makro definiert, erweitert zu _Complex. Sie könnten auch an Derek M. Jones’ “The New C Standard: An Economic and Cultural Commentary” (2008) Seite 500 “Complex Types” interessiert sein. people.ece.cornell.edu/land/courses/ece4760/…

    – osgx

    25. Januar 2015 um 8:44 Uhr


ein Angebot kann den Benutzeravatar nicht ablehnen
Ein Angebot kann man nicht ablehnen

Der Einfachheit halber kann man einschließen tgmath.h Bibliothek für den Typ Makros generieren. Es erstellt den gleichen Funktionsnamen wie die doppelte Version für alle Arten von Variablen. Zum Beispiel definiert es zum Beispiel a sqrt() Makro, das auf erweitert wird sqrtf() , sqrt() oder sqrtl() Funktion, abhängig von der Art des bereitgestellten Arguments.

Man muss sich also nicht den entsprechenden Funktionsnamen für verschiedene Arten von Variablen merken!

#include <stdio.h>
#include <tgmath.h>//for the type generate macros. 
#include <complex.h>//for easier declare complex variables and complex unit I

int main(void)
{
    double complex z1=1./4.*M_PI+1./4.*M_PI*I;//M_PI is just pi=3.1415...
    double complex z2, z3, z4, z5; 

    z2=exp(z1);
    z3=sin(z1);
    z4=sqrt(z1);
    z5=log(z1);

    printf("exp(z1)=%lf + %lf I\n", creal(z2),cimag(z2));
    printf("sin(z1)=%lf + %lf I\n", creal(z3),cimag(z3));
    printf("sqrt(z1)=%lf + %lf I\n", creal(z4),cimag(z4));
    printf("log(z1)=%lf + %lf I\n", creal(z5),cimag(z5));

    return 0;
}

Benutzeravatar von LXSoft
LXSoft

Der Begriff der komplexen Zahlen wurde in der Mathematik eingeführt, weil negative Quadratwurzeln berechnet werden mussten. Das Konzept der komplexen Zahlen wurde von einer Vielzahl von Ingenieurbereichen übernommen.

Heutzutage werden diese komplexen Zahlen häufig in fortgeschrittenen technischen Bereichen wie Physik, Elektronik, Mechanik, Astronomie usw. verwendet.

Real- und Imaginärteil einer negativen Quadratwurzel Beispiel:

#include <stdio.h>   
#include <complex.h>

int main() 
{
    int negNum;

    printf("Calculate negative square roots:\n"
           "Enter negative number:");

    scanf("%d", &negNum);

    double complex negSqrt = csqrt(negNum);

    double pReal = creal(negSqrt);
    double pImag = cimag(negSqrt);

    printf("\nReal part %f, imaginary part %f"
           ", for negative square root.(%d)",
           pReal, pImag, negNum);

    return 0;
}

Benutzeravatar von Cyclops
Zyklop

Um den Realteil eines komplexwertigen Ausdrucks zu extrahieren zverwenden Sie die Schreibweise als __real__ z. Ebenso verwenden __imag__ Attribut auf der z um den Imaginärteil zu extrahieren.

Zum Beispiel;

__complex__ float z;
float r;
float i;
r = __real__ z;
i = __imag__ z;

r ist der Realteil der komplexen Zahl „z“ i ist der Imaginärteil der komplexen Zahl „z“

  • Dies sind gcc-spezifische Erweiterungen. Eine andere Antwort hat sie bereits erwähnt, und die akzeptierte Antwort bereits, wie dies in Standard C zu tun ist.

    – Keith Thompson

    25. Mai 2015 um 8:25 Uhr


  • Dies sind gcc-spezifische Erweiterungen. Eine andere Antwort hat sie bereits erwähnt, und die akzeptierte Antwort bereits, wie dies in Standard C zu tun ist.

    – Keith Thompson

    25. Mai 2015 um 8:25 Uhr


1423780cookie-checkWie arbeitet man mit komplexen Zahlen in C?

This website is using cookies to improve the user-friendliness. You agree by using the website further.

Privacy policy