¿Cómo trabajar con números complejos en C?

¿Cómo puedo trabajar con números complejos en C? Veo que hay un complex.harchivo de encabezado, pero no me da mucha información sobre cómo usarlo. ¿Cómo acceder a partes reales e imaginarias de manera eficiente? ¿Hay funciones nativas para obtener el módulo y la fase?

Este código te ayudará, y es bastante claro:

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

  con:

creal(z1): obtener la parte real (para flotante crealf(z1), para doble largo creall(z1))

cimag(z1): obtener la parte imaginaria (para flotante cimagf(z1), para doble largo cimagl(z1))

Otro punto importante a recordar cuando se trabaja con números complejos es que funciona como cos(), exp()y sqrt()debe ser reemplazado con sus formas complejas, por ejemplo ccos(), cexp(), csqrt().

Los tipos complejos están en lenguaje C desde el estándar C99 ( -std=c99opción de GCC). Algunos compiladores pueden implementar tipos complejos incluso en modos más anteriores, pero esta es una extensión no estándar y no portátil (por ejemplo, IBM XL, GCC, puede ser Intel, ...).

Puede comenzar desde http://en.wikipedia.org/wiki/Complex.h : proporciona una descripción de las funciones de complex.h

Este manual http://pubs.opengroup.org/onlinepubs/009604499/basedefs/complex.h.html también brinda información sobre macros.

Para declarar una variable compleja, use

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

o

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

Para dar un valor en complejo, use _Complex_Imacro de complex.h:

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

(en realidad puede haber algunos problemas aquí con (0,-0i)números y NaN en la mitad del complejo)

Módulo es cabs(a)/ cabsl(c)/ cabsf(b); La parte real es creal(a), Imaginary is cimag(a). carg(a)es para argumentos complejos.

Para acceder directamente (leer / escribir) una parte real e imag puede usar esta extensión GCC no portable :

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

Por conveniencia, se puede incluir una tgmath.hbiblioteca para el tipo generar macros. Crea el mismo nombre de función que la versión doble para todo tipo de variable. Por ejemplo, Por ejemplo, se define una sqrt()macro que se expande a la sqrtf(), sqrt()o sqrtl()función, dependiendo del tipo de argumento proporcionado.

¡Entonces no es necesario recordar el nombre de la función correspondiente para diferentes tipos de variables!

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

La noción de números complejos se introdujo en las matemáticas, a partir de la necesidad de calcular raíces cuadráticas negativas. El concepto de número complejo fue tomado por una variedad de campos de ingeniería.

Hoy en día, los números complejos se utilizan ampliamente en dominios de ingeniería avanzados como la física, la electrónica, la mecánica, la astronomía, etc.

Parte real e imaginaria, de un ejemplo de raíz cuadrada negativa:

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

Para extraer la parte real de una expresión de valor complejo z, use la notación como __real__ z. Del mismo modo, use el __imag__atributo en zpara extraer la parte imaginaria.

Por ejemplo;

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

r es la parte real del número complejo "z" i es la parte imaginaria del número complejo "z"