C语言fft库函数是线程安全吗

Python024

C语言fft库函数是线程安全吗,第1张

是的。

多线程程序中，线程安全是必须要考虑的因素。C语言中大部分函库函数都是线程安全的，但是也有几个常用函数是线程不安全的，也叫不可重入函数。之所线程不安全，是因为这些系统函数使用了某些全局或者静态变量。

我们知道，全局变量和静态变量分别对应内存中的全局变量区和静态存储区，这些区域都是可以跨函数跨线程访问的。

#include <stdio.h>

#include <math.h>

#include <stdlib.h>

#define N 1000

/*定义复数类型*/

typedef struct{

double real

double img

}complex

complex x[N], *W/*输入序列,变换核*/

int size_x=0 /*输入序列的大小，在本程序中仅限2的次幂*/

double PI/*圆周率*/

void fft()/*快速傅里叶变换*/

void initW() /*初始化变换核*/

void change()/*变址*/

void add(complex ,complex ,complex *)/*复数加法*/

void mul(complex ,complex ,complex *)/*复数乘法*/

void sub(complex ,complex ,complex *)/*复数减法*/

void output()

int main(){

int i/*输出结果*/

system("cls")

PI=atan(1)*4

printf("Please input the size of x:\n")

scanf("%d",&size_x)

printf("Please input the data in x[N]:\n")

for(i=0i<size_xi++)

scanf("%lf%lf",&x[i].real,&x[i].img)

initW()

fft()

output()

return 0

}

/*快速傅里叶变换*/

void fft(){

int i=0,j=0,k=0,l=0

complex up,down,product

change()

for(i=0i<log(size_x)/log(2) i++){ /*一级蝶形运算*/

l=1<<i

for(j=0j<size_xj+= 2*l ){ /*一组蝶形运算*/

for(k=0k<lk++){/*一个蝶形运算*/

mul(x[j+k+l],W[size_x*k/2/l],&product)

add(x[j+k],product,&up)

sub(x[j+k],product,&down)

x[j+k]=up

x[j+k+l]=down

}

}

}

}

/*初始化变换核*/

void initW(){

int i

W=(complex *)malloc(sizeof(complex) * size_x)

for(i=0i<size_xi++){

W[i].real=cos(2*PI/size_x*i)

W[i].img=-1*sin(2*PI/size_x*i)

}

}

/*变址计算，将x(n)码位倒置*/

void change(){

complex temp

unsigned short i=0,j=0,k=0

double t

for(i=0i<size_xi++){

k=ij=0

t=(log(size_x)/log(2))

while( (t--)>0 ){

j=j<<1

j|=(k &1)

k=k>>1

}

if(j>i){

temp=x[i]

x[i]=x[j]

x[j]=temp

}

}

}

/*输出傅里叶变换的结果*/

void output(){

int i

printf("The result are as follows\n")

for(i=0i<size_xi++){

printf("%.4f",x[i].real)

if(x[i].img>=0.0001)printf("+%.4fj\n",x[i].img)

else if(fabs(x[i].img)<0.0001)printf("\n")

else printf("%.4fj\n",x[i].img)

}

}

void add(complex a,complex b,complex *c){

c->real=a.real+b.real

c->img=a.img+b.img

}

void mul(complex a,complex b,complex *c){

c->real=a.real*b.real - a.img*b.img

c->img=a.real*b.img + a.img*b.real

}

void sub(complex a,complex b,complex *c){

c->real=a.real-b.real

c->img=a.img-b.img

}