Làm thế nào để làm việc với số phức trong C?

Làm cách nào để làm việc với các số phức trong C? Tôi thấy có một complex.htệp tiêu đề, nhưng nó không cung cấp cho tôi nhiều thông tin về cách sử dụng nó. Làm thế nào để truy cập các phần thực và ảo một cách hiệu quả? Có các hàm gốc để lấy mô-đun và pha không?

Mã này sẽ giúp bạn và nó khá dễ hiểu:

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

  với:

creal(z1): lấy phần thực (đối với float crealf(z1), đối với dài đôi creall(z1))

cimag(z1): lấy phần ảo (đối với float cimagf(z1), đối với dài gấp đôi cimagl(z1))

Một điểm quan trọng cần nhớ khi làm việc với những con số phức tạp là chức năng thích cos(), exp()và sqrt()phải được thay thế bằng hình thức phức tạp của họ, ví dụ như ccos(), cexp(), csqrt().

Các kiểu phức tạp trong ngôn ngữ C kể từ tiêu chuẩn C99 ( -std=c99tùy chọn của GCC). Một số trình biên dịch có thể thực hiện các kiểu phức tạp ngay cả trong các chế độ sớm hơn, nhưng đây là phần mở rộng không chuẩn và không di động (ví dụ như IBM XL, GCC, có thể là intel, ...).

Bạn có thể bắt đầu từ http://en.wikipedia.org/wiki/Complex.h - nó cung cấp mô tả về các chức năng từ complex.h

Hướng dẫn này http://pubs.opengroup.org/onlinepubs/009604499/basedefs/complex.h.html cũng cung cấp một số thông tin về macro.

Để khai báo một biến phức tạp, hãy sử dụng

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

hoặc là

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

Để cung cấp một giá trị thành phức, hãy sử dụng _Complex_Imacro từ complex.h:

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

(thực sự có thể có một số vấn đề ở đây với (0,-0i)số và NaN trong nửa đơn của phức)

Mô-đun là cabs(a)/ cabsl(c)/ cabsf(b); Phần thực là creal(a), phần tưởng tượng là cimag(a). carg(a)dành cho đối số phức tạp.

Trực tiếp truy cập (đọc / ghi) thực một phần IMAG bạn có thể sử dụng này unportable GCC-mở rộng :

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

Để thuận tiện, người ta có thể bao gồm tgmath.hthư viện cho kiểu tạo macro. Nó tạo ra tên hàm giống như phiên bản kép cho tất cả các loại biến. Ví dụ, ví dụ, nó định nghĩa một sqrt()macro mở rộng đến sqrtf(), sqrt()hoặc sqrtl()chức năng, tùy thuộc vào loại của các đối số được cung cấp.

Vì vậy, người ta không cần phải nhớ tên hàm tương ứng cho các loại biến khác nhau!

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

Khái niệm về số phức được đưa ra trong toán học, xuất phát từ nhu cầu tính các căn bậc hai âm. Khái niệm số phức đã được thực hiện bởi nhiều lĩnh vực kỹ thuật.

Ngày nay, số phức được sử dụng rộng rãi trong các lĩnh vực kỹ thuật tiên tiến như vật lý, điện tử, cơ học, thiên văn học, v.v.

Phần thực và phần ảo, của một ví dụ căn bậc hai âm:

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

Để trích xuất phần thực của một biểu thức có giá trị phức z, hãy sử dụng ký hiệu là __real__ z. Tương tự, sử dụng __imag__thuộc tính trên zđể trích xuất phần ảo.

Ví dụ;

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

r là phần thực của số phức "z" i là phần ảo của số phức "z"