Wie arbeite ich mit komplexen Zahlen in C?

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

Dieser Code hilft Ihnen 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 Long Double creall(z1))

cimag(z1): Holen Sie sich den Imaginärteil (für Float cimagf(z1), für Long Double cimagl(z1))

Ein weiterer wichtiger Punkt zu erinnern , wenn mit komplexen Zahlen arbeiten , ist , dass Funktionen wie cos(), exp()und sqrt()müssen mit ihren komplexen Formen ersetzt werden, zum Beispiel ccos(), cexp(), csqrt().

Komplexe Typen sind seit dem C99-Standard in der Sprache C ( -std=c99Option von GCC). Einige Compiler implementieren möglicherweise komplexe Typen auch in früheren Modi, dies ist jedoch eine nicht standardmäßige und nicht portable Erweiterung (z. B. IBM XL, GCC, möglicherweise Intel, ...).

Sie können von http://en.wikipedia.org/wiki/Complex.h ausgehen - es enthält eine Beschreibung der Funktionen von complex.h

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

Verwenden Sie, um eine komplexe Variable zu deklarieren

  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

Verwenden Sie ein _Complex_IMakro aus complex.h:

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

( (0,-0i)Tatsächlich kann es hier einige Probleme mit Zahlen und NaNs in einer Hälfte des Komplexes geben.)

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

Um direkt auf ein Bildteil zuzugreifen (lesen / schreiben), können Sie diese nicht portierbare GCC-Erweiterung verwenden :

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

Complex.h

#include <stdio.h>      /* Standard Library of Input and Output */
#include <complex.h>    /* Standart 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));
}

Der Einfachheit halber kann man eine tgmath.hBibliothek für die Typgenerierungsmakros einschließen . Es wird für alle Variablentypen der gleiche Funktionsname wie für die Doppelversion erstellt. Zum Beispiel Zum Beispiel definiert es einen sqrt()Makro , das auf das erweitert sqrtf(), sqrt()odersqrtl() Funktion, abhängig von der Art des Arguments vorgesehen.

Man muss sich also nicht den entsprechenden Funktionsnamen für verschiedene Variablentypen 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;
}

Der Begriff der komplexen Zahlen wurde in der Mathematik eingeführt, da negative quadratische Wurzeln berechnet werden mussten. Das komplexe Zahlenkonzept wurde von einer Vielzahl von technischen Bereichen übernommen.

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

Real- und Imaginärteil eines negativen Quadratwurzelbeispiels:

#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;
}

zVerwenden Sie die Notation as, um den Realteil eines Ausdrucks mit komplexem Wert zu extrahieren __real__ z. Verwenden Sie in ähnlicher Weise das __imag__Attribut on z, um den Imaginärteil zu extrahieren.

Beispielsweise;

__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"