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

operaciones con numeros complejos

Question

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

Answer 1

Este código lo ayudará, y es bastante autoexplicativo:

#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 crealf(z1) flotante crealf(z1) , para doble creall(z1) doble creall(z1) )

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

Otro punto importante para recordar cuando se trabaja con números complejos es que las funciones como cos() , exp() y sqrt() deben reemplazarse por sus formas complejas, por ejemplo, ccos() , cexp() , csqrt() .

Answer 2

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 son ampliamente utilizados en dominios de ingeniería avanzada 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;
}

Answer 3

Los tipos complejos están en el lenguaje C desde el estándar C99 (opción -std=c99 de GCC). Algunos compiladores pueden implementar tipos complejos incluso en modos más antiguos, 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 las 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 la macro _Complex_I :

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

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

El módulo es cabs(a) / cabsl(c) / cabsf(b) ; La parte real es creal(a) , imaginaria es cimag(a) . carg(a) es para argumento complejo.

Para acceder directamente (leer / escribir) a una parte real de una imag puede usar esta inportable GCC-extension :

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

Answer 4

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 atributo __imag__ en la z para 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"

Answer 5

Para mayor comodidad, uno puede incluir la biblioteca tgmath.h 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, define una macro sqrt() que se expande a la función sqrtf() , sqrt() o sqrtl() , según el tipo de argumento proporcionado.

¡Entonces uno no necesita 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;
}

Answer 6

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