#define _USE_MATH_DEFINES
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cmath>
#include <fstream>
#define M_PI 3.14159265358979323846

using namespace std;

void WriteToFile(const char* filename, int N, double *table, double *time) {
	ofstream file(filename);

	for (int i = 0; i < N; i++) {
		file << table[i] << "\t" << time[i] << endl;
	}

};


class sinusoida
{
protected:

	double *x,*time, fs, f, T, fi;
	int N;

public:
	sinusoida(double Ts, double fs) {

		this->fi = 3 * M_PI / 4;
		this->N = fs*Ts;
		this->fs = fs;
		this->f = 22;
		x = new double[N];
		time = new double[N];
		for (int i = 0; i < N; i++) {
			time[i]=0;
		}
	}

	void generateSignal()
	{
		for (int i = 0; i< N; i++) {
			x[i] = 0.15*cos((2 * M_PI*f*i) / fs + fi);
			time[i] = (i + 1)*(1 / fs);
		}

	}

	virtual ~sinusoida() {
		delete[] x;
		delete[] time;
	}
};


class DFT1:sinusoida {
	double sumRe, sumIm;
	double *sumMod, *z;

public:
	DFT1() :sinusoida(2, 550){
		this->generateSignal();
		sumMod = new double[N];
		z = new double[N];

	}

	void generateDFT() {
		for (int k = 0; k < N; k++) {
			sumMod[k] = 0;
		}
		sumRe = 0;
		sumIm = 0;


		for (int k = 0; k < N; k++) {
			for (int n = 0; n < N; n++) {
				sumRe += x[n] * cos((-2 * M_PI*n*k) / N);
				sumIm += x[n] * sin((-2 * M_PI*n*k) / N);
			}

			sumMod[k] += (sqrt(pow(sumRe, 2) + pow(sumIm, 2)));
			time[k] = k * (fs / N);
			sumRe = 0;
			sumIm = 0;
		}
		WriteToFile("zad1widmo.xls", N/2, sumMod, time);
	}

};


class zad2 : public sinusoida {
	double *y, *z,*v;
	int nr;

	public:
		zad2() :sinusoida(2, 550) {
			y = new double[N];
			z = new double[N];
			v = new double[N];
		}

		void generateSignal1() {
			for (int i = 0; i < N; i++) {
				y[i] = sin(10 * M_PI*i / fs) + cos(16 * M_PI * i / fs);
			}
				for (int i = 0; i< N; i++) {

					z[i] = sqrt(abs(y[i])) - x[i / 2];

			}
				WriteToFile("zad2a.xls", N, z, time);

		}

		void generateSignal2() {
			for (int i = 0; i< N; i++) {
				y[i] = sin(10 * M_PI*i / fs) + cos(16 * M_PI * i / fs);
			}
			for (int i = 0; i< N; i++) {

				v[i] = x[i] * pow(y[i], 2);

			}
			WriteToFile("zad2b.xls", N, v, time);

		}



		~zad2() {}

};

class DFT2:zad2 {
	double sumRe, sumIm;
	double *sumMod, *z;

public:
	DFT2() :zad2(){
		this->generateSignal2();
		sumMod = new double[N];
		z = new double[N];

	}

	void generateDFT() {
		for (int k = 0; k < N; k++) {
			sumMod[k] = 0;
		}
		sumRe = 0;
		sumIm = 0;


		for (int k = 0; k < N; k++) {
			for (int n = 0; n < N; n++) {
				sumRe += x[n] * cos((-2 * M_PI*n*k) / N);
				sumIm += x[n] * sin((-2 * M_PI*n*k) / N);
			}

			sumMod[k] += (sqrt(pow(sumRe, 2) + pow(sumIm, 2)));
			time[k] = k * (fs / N);
			sumRe = 0;
			sumIm = 0;
		}
		WriteToFile("zad2bwidmo.xls", N/2, sumMod, time);
	}

};







class zad3 : public sinusoida {

	public:
		zad3() :sinusoida(2, 4000) {}
		void generateSignal() {


			for (int i = 0; i < 2400; i++) {
				x[i] = sin(12 * M_PI*8000 / 4000) + pow(i, 2);
			}
			for (int i = 2400; i < 6000; i++) {
				x[i] = pow(i, 3) / sin(8 * M_PI * 8000 / 4000);
			}
			for (int i = 6000; i < 8000; i++) {
				x[i] = log2(i) / i;

			}


			WriteToFile("zad3.xls", N, x, time);
		}
		~zad3() {}

};

class DFT3 :zad3 {
	double sumRe, sumIm;
	double *sumMod, *z;

public:
	DFT3() :zad3() {
		this->generateSignal();
		sumMod = new double[N];
		z = new double[N];

	}

	void generateDFT() {
		for (int k = 0; k < N; k++) {
			sumMod[k] = 0;
		}
		sumRe = 0;
		sumIm = 0;


		for (int k = 0; k < N; k++) {
			for (int n = 0; n < N; n++) {
				sumRe += x[n] * cos((-2 * M_PI*n*k) / N);
				sumIm += x[n] * sin((-2 * M_PI*n*k) / N);
			}

			sumMod[k] += (sqrt(pow(sumRe, 2) + pow(sumIm, 2)));
			time[k] = k * (fs / N);
			sumRe = 0;
			sumIm = 0;
		}
		WriteToFile("zad3widmo.xls", N / 2, sumMod, time);
	}

};


class zad4 : public sinusoida
{
	double sigma;
	int nr;
	char buffor[20];
public:
	zad4() :sinusoida(1, 10000)
	{
		this->sigma = 0;
		this->nr = 0;
	}
	void generateSignal(int H)
	{
		nr++;
		for (int i = 0; i<N; i++) {
			for (int j = 0; j < H; j++) {
				sigma += (double)sin(10 * M_PI * i / fs*(2 * j + 1) / (2 * j - 1));
			}
			x[i] = (4 / (M_PI * M_PI))*sigma;
			time[i] = (i + 1)*(1 / fs);
			sigma = 0;
		}
		sprintf(buffor, "zad4 nr %d", nr);
		WriteToFile(buffor, N, x, time);
	}
	~zad4() {}
};

class DFT4 :zad4 {
	double sumRe, sumIm;
	double *sumMod, *z;

public:
	DFT4() :zad4() {
		this->generateSignal(20);
		sumMod = new double[N];
		z = new double[N];

	}

	void generateDFT() {
		for (int k = 0; k < N; k++) {
			sumMod[k] = 0;
		}
		sumRe = 0;
		sumIm = 0;


		for (int k = 0; k < N; k++) {
			for (int n = 0; n < N; n++) {
				sumRe += x[n] * cos((-2 * M_PI*n*k) / N);
				sumIm += x[n] * sin((-2 * M_PI*n*k) / N);
			}

			sumMod[k] += (sqrt(pow(sumRe, 2) + pow(sumIm, 2)));
			time[k] = k * (fs / N);
			sumRe = 0;
			sumIm = 0;
		}
		WriteToFile("zad4awidmo.xls", N / 2, sumMod, time);
	}

};


int main() {


	DFT1 *obj = new DFT1();
	obj->generateDFT();

	DFT2 *obj1 = new DFT2();
	obj1->generateDFT();

	DFT3 *obj2 = new DFT3();
	obj1->generateDFT();

	DFT4 *obj3 = new DFT4();
	obj1->generateDFT();


	/*zad2 *obj = new zad2();
	obj->generateSignal();
	obj->generateSignal1();
	obj->generateSignal2();

	zad3* obj1 = new zad3();
	obj1->generateSignal();

	zad4 *obj2 = new zad4();
	obj2->generateSignal(20);
	obj2->generateSignal(60);
	obj2->generateSignal(80);

	*/


	//delete wsk;
	delete obj;
	delete obj1;
	delete obj2;
	delete obj3
	return 0;

}