算法与编程--信号初步处理

这几天做简单的算法题目，在学校发的教材里面挑选了几道稍微难一点的题目做了一下。花了一天时间做了出来。如此一来稍微找回了一点编程的感觉。

下面是题目：

下面是我的代码：

 

#include <stdio.h>
#include <math.h>

typedef struct My_Plural{												//定义复数结构体
	double RP;
	double VP;
}Plural;

#define PI 3.14159265354

void Initx2(double x[]);												//初始化一维信号第一组
void Inity1(double y[][15]);											//初始化二维信号第一组
void Inity3(double y[][15]);											//初始化二维信号第一组
void EulerFormula(double p, Plural * MP);								//欧拉公式
void OneDimension(double x[], Plural y[], int N);						//一维信号处理从实数空间到复数空间
void OneDimensionReverse(Plural x[], int N);							//一维信号处理从复数空间到实数空间
void DoubleDimension(double x[][15], Plural y[][15], int M, int N);		//二维信号处理从实数空间到复数空间
void DoubleDimensionReverse(Plural x[][15], int M, int N);				//二维信号处理从复数空间到实数空间

int main()
{
	
	//一维信号处理1
	double x1[4] = {1, 1, -1, -1};
	Plural x2[4];
	OneDimension(x1, x2, 4);
	OneDimensionReverse(x2, 4);

	//一维信号处理2
	double x3[12];
	Plural x4[12];
	Initx2(x3);
	OneDimension(x3, x4, 12);
	OneDimensionReverse(x4, 12);

	//二维信号处理1
	double y1[15][15];
	Plural y2[15][15];
	Inity1(y1);
	DoubleDimension(y1, y2, 15, 15);
	DoubleDimensionReverse(y2, 15, 15);

	
	//二维信号处理2
	double y3[15][15];
	Plural y4[15][15];
	Inity1(y3);
	DoubleDimension(y3, y4, 14, 12);
	DoubleDimensionReverse(y4, 14, 12);
	
	return 0;
}

void Initx2(double x2[])
{
	for (int i = 0; i < 12; i++)
	{
		x2[i] = cos(PI / 6 * i);
	}
}

void Inity1(double y[][15])
{
	for (int i = 0; i < 15; i++)
	{
		for (int j = 0 ; j < 15; j++)
		{
			if (i == 8 || j == 8)
				y[i][j] = 1;
			else
				y[i][j] = 0;
		}
	}
}

void Inity3(double y[][15])
{
	for (int i = 0; i < 15; i++)
	{
		for (int j = 0 ; j < 15; j++)
		{
			y[i][j] = cos(PI / 6.0 * i) * cos(PI / 7 * j);
		}
	}
}

void EulerFormula(double p, Plural * MP)
{
	MP->RP = cos(p);
	MP->VP = sin(p);
}

void OneDimension(double x[], Plural y[], int N)
{
	Plural sum;
	double sita = 0;
	Plural  MP;

	for (int k = 0; k < N; k++)
	{
		sum.RP = 0;
		sum.VP = 0;
		for (int i = 0; i < N; i++)
		{
			sita = 2 * PI / N * k * i * -1.0;
			EulerFormula(sita, &MP);
			sum.RP += x[i] * MP.RP;
			sum.VP += x[i] * MP.VP;
		}
		y[k].RP = sum.RP;
		y[k].VP = sum.VP;
		printf("一维信号公式正向结果X(%d)实部%.2lf， 虚部%.2lf\n", k, sum.RP, sum.VP);
	}
	printf("\n");
}

void OneDimensionReverse(Plural x[], int N)
{
	Plural sum;
	double sita = 0;
	Plural  MP;

	for (int k = 0; k < N; k++)
	{
		sum.RP = 0;
		sum.VP = 0;
		for (int i = 0; i < N; i++)
		{
			sita = 2.0 * PI / N * k * i;
			EulerFormula(sita, &MP);
			sum.RP += x[i].RP * MP.RP - x[i].VP * MP.VP;
			sum.VP += x[i].VP * MP.RP + x[i].RP * MP.VP;
		}
		sum.RP /= N;
		sum.VP /= N;
		printf("一维信号公式反向结果X(%d)实部%.2lf， 虚部%.2lf\n", k, sum.RP, sum.VP);
	}
	printf("\n");
}

void DoubleDimension(double x[][15], Plural y[][15], int M, int N)
{
	Plural all[15];
	Plural sum[15];
	double sita = 0;
	Plural  MP;
	for (int s = 0; s < N; s++)						//u
	{
		for (int j = 0; j < M; j++)					//v
		{
			all[j].RP = 0;
			all[j].VP = 0;
			for (int k = 0; k < N; k++)				//n
			{
				sum[k].RP = 0;
				sum[k].VP = 0;
				for (int i = 0; i < M; i++)			//m
				{
					sita = 2 * PI / N * i * j * -1.0;
					EulerFormula(sita, &MP);
					sum[k].RP += x[k][i] * MP.RP;
					sum[k].VP += x[k][i] * MP.VP;
				}

				sita = 2 * PI / N * s * k * -1.0;
				EulerFormula(sita, &MP);

				all[j].RP += sum[k].RP * MP.RP - sum[k].VP * MP.VP;				//all里面存放的是一维信号计算出来的值
				all[j].VP += sum[k].RP * MP.VP + sum[k].VP * MP.RP;
			}	
			y[s][j].RP = all[j].RP;
			y[s][j].VP = all[j].VP;
			printf("二维信号公式正向结果X(%d, %d)实部%.2lf， 虚部%.2lf\n", s, j, all[j].RP, all[j].VP);
		}
	}
	printf("\n");
}

void DoubleDimensionReverse(Plural x[][15], int M, int N)
{
	Plural all[15];
	Plural sum[15];
	double sita = 0;
	Plural  MP;
	for (int s = 0 ; s < N; s++)					//u
	{
		for (int j = 0; j < M; j++)					//v
		{
			all[j].RP = 0;
			all[j].VP = 0;
			for (int k = 0; k < N; k++)				//n
			{
				sum[k].RP = 0;
				sum[k].VP = 0;
				for (int i = 0; i < M; i++)			//m
				{
					sita = 2 * PI / N * i * j * 1.0;
					EulerFormula(sita, &MP);
					sum[k].RP += x[k][i].RP * MP.RP - x[k][i].VP * MP.VP;
					sum[k].VP += x[k][i].RP * MP.VP + x[k][i].VP * MP.RP;
				}

				sita = 2 * PI / N * s * k * 1.0;
				EulerFormula(sita, &MP);

				all[j].RP += sum[k].RP * MP.RP - sum[k].VP * MP.VP;				//all里面存放的是一维信号计算出来的值
				all[j].VP += sum[k].RP * MP.VP + sum[k].VP * MP.RP;
			}	
			all[j].RP = all[j].RP / M / N;
			all[j].VP = all[j].VP / M / N;
			printf("二维信号公式反向结果X(%d, %d)实部%.2lf， 虚部%.2lf\n", s, j, all[j].RP, all[j].VP);
		}
	}
	printf("\n");
}