Jak pracować z liczbami zespolonymi w C?

Jak mogę pracować z liczbami zespolonymi w C? Widzę, że istnieje complex.hplik nagłówkowy, ale nie zawiera on zbyt wielu informacji o tym, jak go używać. Jak efektywnie uzyskać dostęp do rzeczywistych i wyimaginowanych części? Czy istnieją natywne funkcje do pobrania modułu i fazy?

Ten kod ci pomoże i jest dość zrozumiały:

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

  z:

creal(z1): zdobądź prawdziwą część (dla float crealf(z1), dla długiego double creall(z1))

cimag(z1): pobierz część urojoną (dla float cimagf(z1), dla długiego double cimagl(z1))

Innym ważnym punktem pamiętać podczas pracy z liczb zespolonych jest to, że funkcje takie jak cos(), exp()i sqrt()muszą być zastępowane ich złożonych form, na przykład ccos(), cexp(), csqrt().

Typy złożone są w języku C od standardu C99 ( -std=c99opcja GCC). Niektóre kompilatory mogą implementować złożone typy nawet we wcześniejszych trybach, ale jest to niestandardowe i nieprzenośne rozszerzenie (np. IBM XL, GCC, może być intel, ...).

Możesz zacząć od http://en.wikipedia.org/wiki/Complex.h - zawiera opis funkcji z complex.h

Ten podręcznik http://pubs.opengroup.org/onlinepubs/009604499/basedefs/complex.h.html również zawiera informacje o makrach.

Aby zadeklarować zmienną złożoną, użyj

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

lub

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

Aby nadać wartość złożonemu, użyj _Complex_Imakra z complex.h:

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

(właściwie mogą tu występować problemy z (0,-0i)liczbami i NaN w jednej połowie złożonej)

Moduł to cabs(a)/ cabsl(c)/ cabsf(b); Prawdziwą częścią jest creal(a)wyobrażenie cimag(a). carg(a)służy do złożonych argumentów.

Aby uzyskać bezpośredni dostęp (odczyt / zapis) do rzeczywistej części obrazu , możesz użyć tego nieporęcznego rozszerzenia GCC :

 __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));
}

Dla wygody można dołączyć tgmath.hbibliotekę dla typu generującego makra. Tworzy tę samą nazwę funkcji co podwójna wersja dla wszystkich typów zmiennych. Na przykład, na przykład, definiuje sqrt()makro, która rozciąga się na sqrtf(), sqrt()lub sqrtl()funkcji, w zależności od rodzaju argumentu usług.

Nie trzeba więc pamiętać odpowiedniej nazwy funkcji dla różnych typów zmiennych!

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

Pojęcie liczb zespolonych zostało wprowadzone do matematyki z potrzeby obliczania ujemnych pierwiastków kwadratowych. Złożona koncepcja liczbowa została podjęta w różnych dziedzinach inżynierii.

Dziś te liczby zespolone są szeroko stosowane w zaawansowanych dziedzinach inżynierii, takich jak fizyka, elektronika, mechanika, astronomia itp.

Część rzeczywista i urojona ujemnego pierwiastka kwadratowego:

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

Aby wyodrębnić część rzeczywistą wyrażenia o wartościach zespolonych z, użyj notacji as __real__ z. Podobnie użyj __imag__atrybutu w, zaby wyodrębnić część urojoną.

Na przykład;

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

r jest częścią rzeczywistą liczby zespolonej „z” i jest częścią urojoną liczby zespolonej „z”