Wavelet.cpp

//code ported from original code by Rafat Hussain
//https://github.com/rafat/wavelib
//see also: http://rafat.github.io/sites/wavebook/index.html

#pragma once
#define WAVE_EXPORT
#include "stdafx.h"

//kiss_fft_cfg fwd, bwd;
static unsigned int transient_size_of_fft = 0;

void* per_ext2d(std::vector<std::vector<double> > &signal, std::vector<std::vector<double> > &temp2, int a) {

	unsigned int rows = signal.size();
	unsigned int cols = signal[0].size();
	int cols2;
	if ((cols % 2) != 0) {
		cols2 = cols + 1;
	}
	else {
		cols2 = cols;
	}
	std::vector<std::vector<double> > temp_vec(rows, std::vector<double>(cols2 + 2 * a));
	//	std::vector<std::vector<double> > temp2(rows + 2 * a ,std::vector<double>(cols + 2* a));

	for (unsigned int i = 0; i < rows; i++) {
		std::vector<double> sig;
		for (unsigned int j = 0; j< cols; j++) {
			double temp = signal[i][j];
			sig.push_back(temp);
		}
		per_ext(sig, a);
		for (unsigned int j = 0; j< sig.size(); j++) {
			temp_vec[i][j] = sig[j];
		}
	}
	for (unsigned int j = 0; j < temp_vec[0].size(); j++) {
		std::vector<double> sig;
		for (unsigned int i = 0; i< rows; i++) {
			double temp = temp_vec[i][j];
			sig.push_back(temp);
		}
		per_ext(sig, a);
		for (unsigned int i = 0; i< sig.size(); i++) {
			temp2[i][j] = sig[i];
		}
	}


	return 0;
}

void* swt_2d(std::vector<std::vector<double> > &sig, int J, std::string nm, std::vector<double> &swt_output) {
	int m_size = sig.size(); // No. of rows
	int n_size = sig[0].size(); //No. of columns

	std::vector<std::vector<double> > sig2 = sig;

	int rows_n = m_size;
	int cols_n = n_size;
	std::vector<double> lp1, hp1, lp2, hp2;
	filtcoef(nm, lp1, hp1, lp2, hp2);

	for (int iter = 0; iter < J; iter++) {
		int U = (int)pow(2.0, (double)iter);
		std::vector<double> low_pass, high_pass;
		if (iter > 0) {
			upsamp(lp1, U, low_pass);
			upsamp(hp1, U, high_pass);
		}
		else {
			low_pass = lp1;
			high_pass = hp1;
		}
		int lf = low_pass.size();

		if ((sig.size() % 2) == 0) {
			rows_n = sig.size();
		}
		else {
			rows_n = sig.size() + 1;
		}

		if ((sig[0].size() % 2) == 0) {
			cols_n = sig[0].size();
		}
		else {
			cols_n = sig[0].size() + 1;
		}

		std::vector<std::vector<double> > signal(rows_n + lf, std::vector<double>(cols_n + lf));
		//    per_ext2d(sig,signal,lf/2); Edit per_ext if you want to use per_ext2d. Remove
		// the even indexing.

		per_ext2d(sig, signal, lf / 2);
		int len_x = signal.size();
		int len_y = signal[0].size();
		std::vector<std::vector<double> > sigL(rows_n + lf, std::vector<double>(cols_n));
		std::vector<std::vector<double> > sigH(rows_n + lf, std::vector<double>(cols_n));
		std::vector<std::vector<double> > cA(rows_n, std::vector<double>(cols_n));
		std::vector<std::vector<double> > cH(rows_n, std::vector<double>(cols_n));
		std::vector<std::vector<double> > cV(rows_n, std::vector<double>(cols_n));
		std::vector<std::vector<double> > cD(rows_n, std::vector<double>(cols_n));

		for (int i = 0; i < len_x; i++) {
			std::vector<double> temp_row;
			for (int j = 0; j < len_y; j++) {
				double temp = signal[i][j];
				temp_row.push_back(temp);

			}

			// ------------------Low Pass Branch--------------------------


			std::vector<double> oup;
			convfftm(temp_row, low_pass, oup);
			oup.erase(oup.begin(), oup.begin() + lf);
			oup.erase(oup.begin() + cols_n, oup.end());

			// ------------------High Pass Branch--------------------------

			std::vector<double> oup2;
			convfftm(temp_row, high_pass, oup2);
			oup2.erase(oup2.begin(), oup2.begin() + lf);
			oup2.erase(oup2.begin() + cols_n, oup2.end());

			temp_row.clear();

			for (unsigned int j = 0; j < oup.size(); j++) {
				sigL[i][j] = oup[j];
				sigH[i][j] = oup2[j];
			}

		}

		for (int j = 0; j < cols_n; j++) {
			std::vector<double> temp_row;
			for (int i = 0; i < len_x; i++) {
				double temp = sigL[i][j];
				temp_row.push_back(temp);
			}

			// ------------------Low Pass Branch--------------------------


			std::vector<double> oup;
			convfftm(temp_row, low_pass, oup);
			oup.erase(oup.begin(), oup.begin() + lf);
			oup.erase(oup.begin() + rows_n, oup.end());

			// ------------------High Pass Branch--------------------------

			std::vector<double> oup2;
			convfftm(temp_row, high_pass, oup2);
			oup2.erase(oup2.begin(), oup2.begin() + lf);
			oup2.erase(oup2.begin() + rows_n, oup2.end());

			temp_row.clear();


			for (unsigned int i = 0; i < oup.size(); i++) {
				cA[i][j] = oup[i];
			}

			for (unsigned int i = 0; i < oup2.size(); i++) {
				cH[i][j] = oup2[i];
			}


		}

		for (int j = 0; j < cols_n; j++) {
			std::vector<double> temp_row;
			for (int i = 0; i < len_x; i++) {
				double temp = sigH[i][j];
				temp_row.push_back(temp);
			}

			// ------------------Low Pass Branch--------------------------


			std::vector<double> oup;
			convfftm(temp_row, low_pass, oup);
			oup.erase(oup.begin(), oup.begin() + lf);
			oup.erase(oup.begin() + rows_n, oup.end());

			// ------------------High Pass Branch--------------------------

			std::vector<double> oup2;
			convfftm(temp_row, high_pass, oup2);
			oup2.erase(oup2.begin(), oup2.begin() + lf);
			oup2.erase(oup2.begin() + rows_n, oup2.end());

			temp_row.clear();


			for (unsigned int i = 0; i < oup.size(); i++) {
				cV[i][j] = oup[i];
			}

			for (unsigned int i = 0; i < oup2.size(); i++) {
				cD[i][j] = oup2[i];
			}


		}

		sig = cA;
		std::vector<double> temp_sig2;

		if (iter == J - 1) {
			for (int i = 0; i < rows_n; i++) {
				for (int j = 0; j < cols_n; j++) {
					double temp = cA[i][j];
					temp_sig2.push_back(temp);
				}
			}
		}
		for (int i = 0; i < rows_n; i++) {
			for (int j = cols_n; j < cols_n * 2; j++) {
				double temp = cH[i][j - cols_n];
				temp_sig2.push_back(temp);
			}
		}

		for (int i = rows_n; i < rows_n * 2; i++) {
			for (int j = 0; j < cols_n; j++) {
				double temp = cV[i - rows_n][j];
				temp_sig2.push_back(temp);
			}
		}

		for (int i = rows_n; i < rows_n * 2; i++) {
			for (int j = cols_n; j < cols_n * 2; j++) {
				double temp = cD[i - rows_n][j - cols_n];
				temp_sig2.push_back(temp);
			}
		}

		swt_output.insert(swt_output.begin(), temp_sig2.begin(), temp_sig2.end());



	}


	return 0;
}


void* per_ext(std::vector<double> &sig, int a) {
	unsigned int len;
	len = sig.size();
	if ((len % 2) != 0) {
		double temp = sig[len - 1];
		sig.push_back(temp);
		len = sig.size();
	}

	for (int i = 0; i < a; i++) {
		double temp1 = sig[2 * i];
		double temp2 = sig[len - 1];
		sig.insert(sig.begin(), temp2);
		sig.insert(sig.end(), temp1);

	}

	return 0;

}


void* iswt(std::vector<double> &swtop, int J, std::string nm, std::vector<double> &iswt_output) {
	int N = swtop.size() / (J + 1);

	std::vector<double> lpd, hpd, lpr, hpr;
	filtcoef(nm, lpd, hpd, lpr, hpr);

	std::vector<double> appx_sig;

	std::vector<double> low_pass = lpr;
	std::vector<double> high_pass = hpr;
	int lf = low_pass.size();

	for (int iter = 0; iter < J; iter++) {
		std::vector<double> det_sig;
		if (iter == 0) {
			for (int i = 0; i < N; i++) {
				double temp = swtop[i];
				appx_sig.push_back(temp);
				double temp1 = swtop[(iter + 1) * N + i];
				det_sig.push_back(temp1);
			}
		}
		else {
			for (int i = 0; i < N; i++) {
				double temp1 = swtop[(iter + 1) * N + i];
				det_sig.push_back(temp1);

			}
		}


		int value = (int)pow(2.0, double(J - 1 - iter));
		iswt_output.assign(N, 0.0);

		for (int count = 0; count < value; count++) {
			std::vector<double> appx1, det1;
			for (int index = count; index < N; index += value) {
				double temp = appx_sig[index];
				appx1.push_back(temp);
				double temp1 = det_sig[index];
				det1.push_back(temp1);

			}
			unsigned int len = appx1.size();

			// Shift = 0

			std::vector<double> appx2, det2;

			for (unsigned int index_shift = 0; index_shift < len; index_shift += 2) {
				double temp = appx1[index_shift];
				appx2.push_back(temp);
				double temp1 = det1[index_shift];
				det2.push_back(temp1);
			}

			int U = 2; // Upsampling Factor

			std::vector<double> cL0, cH0;
			upsamp(appx2, U, cL0);
			upsamp(det2, U, cH0);
			per_ext(cL0, lf / 2);
			per_ext(cH0, lf / 2);

			std::vector<double> oup00L, oup00H, oup00;
			convfft(cL0, low_pass, oup00L);
			convfft(cH0, high_pass, oup00H);

			oup00L.erase(oup00L.begin(), oup00L.begin() + lf - 1);
			oup00L.erase(oup00L.begin() + len, oup00L.end());
			oup00H.erase(oup00H.begin(), oup00H.begin() + lf - 1);
			oup00H.erase(oup00H.begin() + len, oup00H.end());

			vecsum(oup00L, oup00H, oup00);

			// Shift = 1

			std::vector<double> appx3, det3;

			for (unsigned int index_shift = 1; index_shift < len; index_shift += 2) {
				double temp = appx1[index_shift];
				appx3.push_back(temp);
				double temp1 = det1[index_shift];
				det3.push_back(temp1);
			}


			std::vector<double> cL1, cH1;
			upsamp(appx3, U, cL1);
			upsamp(det3, U, cH1);
			per_ext(cL1, lf / 2);
			per_ext(cH1, lf / 2);

			std::vector<double> oup01L, oup01H, oup01;
			convfft(cL1, low_pass, oup01L);
			convfft(cH1, high_pass, oup01H);

			oup01L.erase(oup01L.begin(), oup01L.begin() + lf - 1);
			oup01L.erase(oup01L.begin() + len, oup01L.end());
			oup01H.erase(oup01H.begin(), oup01H.begin() + lf - 1);
			oup01H.erase(oup01H.begin() + len, oup01H.end());

			vecsum(oup01L, oup01H, oup01);
			circshift(oup01, -1);

			//   Continue
			int index2 = 0;
			for (int index = count; index < N; index += value) {
				double temp = oup00[index2] + oup01[index2];
				iswt_output.at(index) = temp / 2;
				index2++;

			}


		}
		appx_sig = iswt_output;


	}
	return 0;
}

std::vector<double> swt(std::vector<double> signal1, int J, std::string filterCoefficientName, std::vector<double> swt_output, int length) {
	std::vector<double> lpd, hpd, lpr, hpr;
	std::vector<double> sig;
	sig = signal1;
	int N = sig.size();
	length = N;

	filtcoef(filterCoefficientName, lpd, hpd, lpr, hpr);

	for (int iter = 0; iter < J; iter++) {
		std::vector<double> low_pass;
		std::vector<double> high_pass;
		if (iter > 0) {

			int M = (int)pow(2.0, iter);
			upsamp(lpd, M, low_pass);
			upsamp(hpd, M, high_pass);


		}
		else {
			low_pass = lpd;
			high_pass = hpd;
		}

		unsigned int len_filt = low_pass.size();
		per_ext(sig, len_filt / 2);

		std::vector<double> cA;
		convfft(sig, low_pass, cA);
		std::vector<double> cD;
		convfft(sig, high_pass, cD);
		// Resize cA and cD
		cA.erase(cA.begin(), cA.begin() + len_filt);
		cA.erase(cA.begin() + N, cA.end());
		cD.erase(cD.begin(), cD.begin() + len_filt);
		cD.erase(cD.begin() + N, cD.end());
		// Reset signal value;

		sig = cA;

		if (iter == J - 1) {
			swt_output.insert(swt_output.begin(), cD.begin(), cD.end());
			swt_output.insert(swt_output.begin(), cA.begin(), cA.end());
		}
		else {
			swt_output.insert(swt_output.begin(), cD.begin(), cD.end());
		}
	}
	return swt_output;
}

void* dwt_output_dim_sym(std::vector<int> &length, std::vector<int> &length2, int J) {
	unsigned int sz = length.size();
	int rows = length[sz - 2];
	int cols = length[sz - 1];
	for (int i = 0; i < J; i++) {
		rows = (int)ceil((double)rows / 2.0);
		cols = (int)ceil((double)cols / 2.0);
	}
	for (int i = 0; i < J + 1; i++) {
		length2.push_back(rows);
		length2.push_back(cols);
		rows = rows * 2;
		cols = cols * 2;
	}
	return 0;
}

void* dwt_output_dim2(std::vector<int> &length, std::vector<int> &length2, int J) {

	int row = length[0];
	int col = length[1];

	for (int i = 0; i < J + 1; i++) {

		length2.push_back(row);
		length2.push_back(col);
		row = row * 2;
		col = col * 2;


	}


	return 0;
}

void* dispDWT(std::vector<double> &output, std::vector<std::vector<double> > &dwtdisp, std::vector<int> &length, std::vector<int> &length2, int J) {
	int sum = 0;


	for (int iter = 0; iter < J; iter++) {
		int d_rows = length[2 * iter] - length2[2 * iter];
		int d_cols = length[2 * iter + 1] - length2[2 * iter + 1];


		int rows_n = length[2 * iter];
		int cols_n = length[2 * iter + 1];
		std::vector<std::vector<double> >  dwt_output(2 * rows_n, std::vector<double>(2 * cols_n));
		if (iter == 0) {
			for (int i = 0; i < rows_n; i++) {
				for (int j = 0; j < cols_n; j++) {
					dwt_output[i][j] = output[i*cols_n + j];
				}
			}

			for (int i = 0; i < rows_n; i++) {
				for (int j = cols_n; j < cols_n * 2; j++) {
					dwt_output[i][j] = output[rows_n * cols_n + i * cols_n + (j - cols_n)];
				}
			}

			for (int i = rows_n; i < rows_n * 2; i++) {
				for (int j = 0; j < cols_n; j++) {
					dwt_output[i][j] = output[2 * rows_n * cols_n + (i - rows_n) * cols_n + j];
				}
			}


			for (int i = rows_n; i < rows_n * 2; i++) {
				for (int j = cols_n; j < cols_n * 2; j++) {
					dwt_output[i][j] = output[3 * rows_n * cols_n + (i - rows_n) * cols_n + (j - cols_n)];
				}
			}
		}
		else {
			for (int i = 0; i < rows_n; i++) {
				for (int j = cols_n; j < cols_n * 2; j++) {
					dwt_output[i][j] = output[sum + i * cols_n + (j - cols_n)];
				}
			}

			for (int i = rows_n; i < rows_n * 2; i++) {
				for (int j = 0; j < cols_n; j++) {
					dwt_output[i][j] = output[sum + rows_n * cols_n + (i - rows_n) * cols_n + j];
				}
			}


			for (int i = rows_n; i < rows_n * 2; i++) {
				for (int j = cols_n; j < cols_n * 2; j++) {
					dwt_output[i][j] = output[sum + 2 * rows_n * cols_n + (i - rows_n) * cols_n + (j - cols_n)];
				}
			}

		}

		int rows_x = length2[2 * iter];
		int cols_x = length2[2 * iter + 1];

		int d_cols2 = (int)ceil((double)(d_cols - 1) / 2.0);
		int d_rows2 = (int)ceil((double)(d_rows - 1) / 2.0);
		if (iter == 0) {
			for (int i = 0; i < rows_x; i++) {
				for (int j = 0; j < cols_x; j++) {
					if (i + d_rows - 1 < 0) {
						dwtdisp[i][j] = 0;
					}
					else if (j + d_cols - 1 < 0) {
						dwtdisp[i][j] = 0;
					}
					else {
						dwtdisp[i][j] = dwt_output[i + d_rows - 1][j + d_cols - 1];
					}
				}
			}
		}
		for (int i = 0; i < rows_x; i++) {
			for (int j = cols_x; j < cols_x * 2; j++) {
				if (i + d_rows2 < 0) {
					dwtdisp[i][j] = 0;
				}
				else if (j + 2 * (d_cols - 1) + 1 >(signed) dwt_output[0].size() - 1) {
					dwtdisp[i][j] = 0;
				}
				else {
					dwtdisp[i][j] = dwt_output[i + d_rows2][j + 2 * (d_cols - 1) + 1];
				}
			}
		}

		for (int i = rows_x; i < rows_x * 2; i++) {
			for (int j = 0; j < cols_x; j++) {
				if (i + 2 * (d_rows - 1) + 1 >(signed) dwt_output.size() - 1) {
					dwtdisp[i][j] = 0;
				}
				else if (j + d_cols2 < 0) {
					dwtdisp[i][j] = 0;
				}
				else {

					dwtdisp[i][j] = dwt_output[i + 2 * (d_rows - 1) + 1][j + d_cols2];
				}
			}
		}

		for (int i = rows_x; i < rows_x * 2; i++) {
			for (int j = cols_x; j < cols_x * 2; j++) {

				if (i + (d_rows - 1) + 1 + d_rows2 >(signed) dwt_output.size() - 1) {
					dwtdisp[i][j] = 0;
				}
				else if (j + (d_cols - 1) + 1 + d_cols2  >(signed) dwt_output[0].size() - 1) {
					dwtdisp[i][j] = 0;
				}
				else {
					dwtdisp[i][j] = dwt_output[i + (d_rows - 1) + 1 + d_rows2][j + (d_cols - 1) + 1 + d_cols2];
				}
			}
		}
		if (iter == 0) {
			sum += 4 * rows_n*cols_n;
		}
		else {
			sum += 3 * rows_n * cols_n;
		}

	}

	return 0;

}

void symm_ext2d(std::vector<std::vector<double> > &signal, std::vector<std::vector<double> > &temp2, int a) {
	unsigned int rows = signal.size();
	unsigned int cols = signal[0].size();
	std::vector<std::vector<double> > temp_vec(rows, std::vector<double>(cols + 2 * a));
	//	std::vector<std::vector<double> > temp2(rows + 2 * a ,std::vector<double>(cols + 2* a));

	for (unsigned int i = 0; i < rows; i++) {
		std::vector<double> sig;
		for (unsigned int j = 0; j< cols; j++) {
			double temp = signal[i][j];
			sig.push_back(temp);
		}
		symm_ext(sig, a);
		for (unsigned int j = 0; j< sig.size(); j++) {
			temp_vec[i][j] = sig[j];
		}
	}
	for (unsigned int j = 0; j < temp_vec[0].size(); j++) {
		std::vector<double> sig;
		for (unsigned int i = 0; i< rows; i++) {
			double temp = temp_vec[i][j];
			sig.push_back(temp);
		}
		symm_ext(sig, a);
		for (unsigned int i = 0; i< sig.size(); i++) {
			temp2[i][j] = sig[i];
		}
	}

}

void* circshift2d(std::vector<std::vector<double> > &signal, int x, int y) {
	unsigned int rows = signal.size();
	unsigned int cols = signal[0].size();
	std::vector<std::vector<double> > temp_vec(rows, std::vector<double>(cols));

	for (unsigned int i = 0; i < rows; i++) {
		std::vector<double> sig;
		for (unsigned int j = 0; j< cols; j++) {
			double temp = signal[i][j];
			sig.push_back(temp);
		}
		circshift(sig, x);
		for (unsigned int j = 0; j< cols; j++) {
			temp_vec[i][j] = sig[j];
		}
	}

	for (unsigned int j = 0; j < cols; j++) {
		std::vector<double> sig;
		for (unsigned int i = 0; i< rows; i++) {
			double temp = temp_vec[i][j];
			sig.push_back(temp);
		}
		circshift(sig, y);
		for (unsigned int i = 0; i< rows; i++) {
			signal[i][j] = sig[i];
		}
	}
	return 0;
}

void* idwt_2d_sym(std::vector<double>  &dwtop, std::vector<double> &flag, std::string nm,
	std::vector<std::vector<double> > &idwt_output, std::vector<int> &length) {
	int J = (int)flag[0];
	int rows = length[0];
	int cols = length[1];

	int sum_coef = 0;
	std::vector<double> lp1, hp1, lp2, hp2;
	filtcoef(nm, lp1, hp1, lp2, hp2);
	unsigned int lf = lp1.size();
	std::vector<std::vector<double> >  cLL(rows, std::vector<double>(cols));


	for (int iter = 0; iter < J; iter++) {

		int rows_n = length[2 * iter];
		int cols_n = length[2 * iter + 1];

		std::vector<std::vector<double> >  cLH(rows_n, std::vector<double>(cols_n));
		std::vector<std::vector<double> >  cHL(rows_n, std::vector<double>(cols_n));
		std::vector<std::vector<double> >  cHH(rows_n, std::vector<double>(cols_n));

		for (int i = 0; i < rows_n; i++) {
			for (int j = 0; j < cols_n; j++) {
				if (iter == 0) {
					cLL[i][j] = dwtop[sum_coef + i * cols_n + j];

					cLH[i][j] = dwtop[sum_coef + rows_n * cols_n + i * cols_n + j];

					cHL[i][j] = dwtop[sum_coef + 2 * rows_n * cols_n + i * cols_n + j];

					cHH[i][j] = dwtop[sum_coef + 3 * rows_n * cols_n + i * cols_n + j];
				}
				else {

					cLH[i][j] = dwtop[sum_coef + i * cols_n + j];

					cHL[i][j] = dwtop[sum_coef + rows_n * cols_n + i * cols_n + j];

					cHH[i][j] = dwtop[sum_coef + 2 * rows_n * cols_n + i * cols_n + j];

				}
			}
		}


		//      temp_A = cLL;
		//  	idwt2_sym(nm,idwt_output2, cA, cH,cV,cD);

		unsigned int len_x = cLH.size();
		unsigned int len_y = cLH[0].size();

		// Row Upsampling and Column Filtering at the first LP Stage
		std::vector<std::vector<double> > cL(2 * len_x - lf + 2, std::vector<double>(len_y));
		std::vector<std::vector<double> > cH(2 * len_x - lf + 2, std::vector<double>(len_y));

		if (iter == 0) {
			for (unsigned int j = 0; j < len_y; j++) {

				std::vector<double> sigLL, sigLH, oup;

				for (unsigned int i = 0;i < len_x;i++) {

					double temp1 = cLL[i][j];
					double temp2 = cLH[i][j];
					sigLL.push_back(temp1);
					sigLH.push_back(temp2);
				}
				idwt1_sym_m(nm, oup, sigLL, sigLH);

				for (int i = 0;i < (int)oup.size();i++) {
					cL[i][j] = oup[i];
				}

			}
		}
		else {
			unsigned int rows1 = cLH.size();
			unsigned int cols1 = cLH[0].size();

			for (unsigned int j = 0; j < cols1;j++) {
				std::vector<double> temp_L1, temp_L2, oup;
				for (unsigned int i = 0; i < rows1; i++) {
					double temp = cLL[i][j];
					temp_L1.push_back(temp);

					double temp2 = cLH[i][j];
					temp_L2.push_back(temp2);
				}
				idwt1_sym_m(nm, oup, temp_L1, temp_L2);

				for (unsigned int i = 0; i < oup.size(); i++) {
					cL[i][j] = oup[i];
				}

			}
		}


		for (unsigned int j = 0; j < len_y; j++) {
			std::vector<double> sigHL, sigHH, oup2;
			for (unsigned int i = 0;i < len_x;i++) {
				double temp3 = cHL[i][j];
				double temp4 = cHH[i][j];
				sigHL.push_back(temp3);
				sigHH.push_back(temp4);
			}
			idwt1_sym_m(nm, oup2, sigHL, sigHH);

			for (int i = 0;i < (int)oup2.size();i++) {
				cH[i][j] = oup2[i];
			}

		}

		std::vector<std::vector<double> > signal(2 * len_x - lf + 2, std::vector<double>(2 * len_y - lf + 2));
		for (unsigned int i = 0; i < 2 * len_x - lf + 2; i++) {
			std::vector<double> sigL, sigH, oup;
			for (unsigned int j = 0;j < len_y;j++) {
				double temp5 = cL[i][j];
				double temp6 = cH[i][j];
				sigL.push_back(temp5);
				sigH.push_back(temp6);
			}
			idwt1_sym_m(nm, oup, sigL, sigH);

			for (int j = 0;j < (int)oup.size();j++) {
				signal[i][j] = oup[j];
			}

		}


		idwt_output = signal;



		if (iter == 0) {
			sum_coef += 4 * rows_n * cols_n;
		}
		else {
			sum_coef += 3 * rows_n * cols_n;
		}
		cLL = signal;


	}


	return 0;
}


void* dwt2_sym(std::string name, std::vector<std::vector<double> > &signal, std::vector<std::vector<double> >  &cLL,
	std::vector<std::vector<double> >  &cLH, std::vector<std::vector<double> >  &cHL, std::vector<std::vector<double> > &cHH) {
	//Analysis
	int rows = signal.size();
	int cols = signal[0].size();
	int cols_lp1 = cLL[0].size();
	int cols_hp1 = cLL[0].size();
	std::vector<double> lp1, hp1, lp2, hp2;
	filtcoef(name, lp1, hp1, lp2, hp2);
	std::vector<std::vector<double> > lp_dn1(rows, std::vector<double>(cols_lp1));
	std::vector<std::vector<double> > hp_dn1(rows, std::vector<double>(cols_hp1));

	// Implementing row filtering and column downsampling in each branch.
	for (int i = 0; i < rows; i++) {
		std::vector<double> temp_row, oup_lp, oup_hp;
		for (int j = 0;j < cols;j++) {
			double temp = signal[i][j];
			temp_row.push_back(temp);
		}
		dwt1_sym_m(name, temp_row, oup_lp, oup_hp);

		for (int j = 0;j < (int)oup_lp.size();j++) {
			lp_dn1[i][j] = oup_lp[j];
			hp_dn1[i][j] = oup_hp[j];

		}

	}


	cols = cols_lp1;
	// Implementing column filtering and row downsampling in Low Pass branch.

	for (int j = 0; j < cols; j++) {
		std::vector<double> temp_row3, oup_lp, oup_hp;
		for (int i = 0;i < rows;i++) {
			double temp = lp_dn1[i][j];
			temp_row3.push_back(temp);
		}
		dwt1_sym_m(name, temp_row3, oup_lp, oup_hp);

		for (int i = 0;i < (int)oup_lp.size();i++) {
			cLL[i][j] = oup_lp[i];
			cLH[i][j] = oup_hp[i];

		}


	}



	// Implementing column filtering and row downsampling in High Pass branch.

	for (int j = 0; j < cols; j++) {
		std::vector<double> temp_row5, oup_lp, oup_hp;
		for (int i = 0;i < rows;i++) {
			double temp = hp_dn1[i][j];
			temp_row5.push_back(temp);
		}
		dwt1_sym_m(name, temp_row5, oup_lp, oup_hp);

		for (int i = 0;i < (int)oup_lp.size();i++) {
			cHL[i][j] = oup_lp[i];
			cHH[i][j] = oup_hp[i];

		}


	}
	return 0;
}


void* dwt_2d_sym(std::vector<std::vector<double> > &origsig, int J, std::string nm, std::vector<double> &dwt_output
	, std::vector<double> &flag, std::vector<int> &length) {

	std::vector<std::vector<double> >  sig = origsig;
	int rows_n = sig.size(); // No. of rows
	int cols_n = sig[0].size(); //No. of columns
	std::vector<std::vector<double> > original_copy(rows_n, std::vector<double>(cols_n));

	original_copy = sig;
	int Max_Iter;
	int temp1 = (int)ceil(log(double(sig.size())) / log(2.0));
	int temp2 = (int)ceil(log(double(sig[0].size())) / log(2.0));
	Max_Iter = (temp1 > temp2) ? temp1 : temp2;
	if (Max_Iter < J) {
		//cout << J << " Iterations are not possible with signals of this dimension " << endl;
		exit(1);
	}
	std::vector<double> lp1, hp1, lp2, hp2;

	flag.push_back(double(J));


	length.insert(length.begin(), cols_n);
	length.insert(length.begin(), rows_n);


	// Flag Values
	/*
	double temp = (double) (sig2.size() - sig.size()); // Number of zeropad rows
	flag.push_back(temp);
	double temp2 = (double) (sig2[0].size() - sig[0].size());// Number of zpad cols
	flag.push_back(temp2);
	flag.push_back((double) J); // Number of Iterations
	*/
	int sum_coef = 0;
	for (int iter = 0; iter < J; iter++) {
		filtcoef(nm, lp1, hp1, lp2, hp2);
		unsigned int lf = lp1.size();

		rows_n = (int)floor((double)(rows_n + lf - 1) / 2);
		cols_n = (int)floor((double)(cols_n + lf - 1) / 2);
		length.insert(length.begin(), cols_n);
		length.insert(length.begin(), rows_n);

		std::vector<std::vector<double> >  cA(rows_n, std::vector<double>(cols_n));
		std::vector<std::vector<double> >  cH(rows_n, std::vector<double>(cols_n));
		std::vector<std::vector<double> >  cV(rows_n, std::vector<double>(cols_n));
		std::vector<std::vector<double> >  cD(rows_n, std::vector<double>(cols_n));


		dwt2_sym(nm, original_copy, cA, cH, cV, cD);
		std::vector<double>   temp_sig2;

		original_copy = cA;
		if (iter == J - 1) {
			for (int i = 0; i < rows_n; i++) {
				for (int j = 0; j < cols_n; j++) {
					double temp = cA[i][j];
					temp_sig2.push_back(temp);
				}
			}
		}
		for (int i = 0; i < rows_n; i++) {
			for (int j = cols_n; j < cols_n * 2; j++) {
				double temp = cH[i][j - cols_n];
				temp_sig2.push_back(temp);
			}
		}

		for (int i = rows_n; i < rows_n * 2; i++) {
			for (int j = 0; j < cols_n; j++) {
				double temp = cV[i - rows_n][j];
				temp_sig2.push_back(temp);
			}
		}

		for (int i = rows_n; i < rows_n * 2; i++) {
			for (int j = cols_n; j < cols_n * 2; j++) {
				double temp = cD[i - rows_n][j - cols_n];
				temp_sig2.push_back(temp);
			}
		}

		dwt_output.insert(dwt_output.begin(), temp_sig2.begin(), temp_sig2.end());
		sum_coef += 4 * rows_n * cols_n;



	}
	/*
	ofstream dwt2out("dwt2out.dat");
	for (unsigned int i= 0; i < dwt_output.size(); i++){
	dwt2out << dwt_output[i] <<endl;
	}
	*/

	return 0;

}


void* idwt1_sym(std::string wname, std::vector<double> &X, std::vector<double> &app, std::vector<double> &detail) {

	// Not Tested. Use dwt_sym and idwt_sym for any and all computations
	std::vector<double> dwtop;
	std::vector<double> flag;
	std::vector<double> idwt_output;
	std::vector<int> length;
	length[0] = app.size();
	length[1] = detail.size();
	dwtop = app;
	dwtop.insert(dwtop.end(), detail.begin(), detail.end());
	flag.push_back(1);
	flag.push_back(0);
	idwt_sym(dwtop, flag, wname, idwt_output, length);
	X = idwt_output;

	return 0;
}

void* idwt1_sym_m(std::string wname, std::vector<double> &idwt_output, std::vector<double> &app, std::vector<double> &detail) {

	int U = 2; // Upsampling Factor
	std::vector<double> lpd1, hpd1, lpr1, hpr1;

	filtcoef(wname, lpd1, hpd1, lpr1, hpr1);
	int lf = lpr1.size();


	// Operations in the Low Frequency branch of the Synthesis Filter Bank
	std::vector<double> X_lp;
	std::vector<double> cA_up;
	upsamp(app, U, cA_up);
	cA_up.pop_back();
	convfftm(cA_up, lpr1, X_lp);



	// Operations in the High Frequency branch of the Synthesis Filter Bank

	std::vector<double> X_hp;
	std::vector<double> cD_up;
	upsamp(detail, U, cD_up);
	cD_up.pop_back();
	convfftm(cD_up, hpr1, X_hp);


	vecsum(X_lp, X_hp, idwt_output);

	idwt_output.erase(idwt_output.begin(), idwt_output.begin() + lf - 2);
	idwt_output.erase(idwt_output.end() - (lf - 2), idwt_output.end());

	return 0;
}


void* symm_ext(std::vector<double> &sig, int a) {
	unsigned int len = sig.size();
	for (int i = 0; i < a; i++) {
		double temp1 = sig[i * 2];
		double temp2 = sig[len - 1];
		sig.insert(sig.begin(), temp1);
		sig.insert(sig.end(), temp2);
	}

	return 0;

}

void* idwt_sym(std::vector<double> &dwtop, std::vector<double> &flag, std::string nm,
	std::vector<double> &idwt_output, std::vector<int> &length) {

	int J = (int)flag[1];
	unsigned int lf;

	std::vector<double> app;
	std::vector<double> detail;
	unsigned int app_len = length[0];
	unsigned int det_len = length[1];

	std::vector<double>::iterator dwt;
	dwt = dwtop.begin();
	app.assign(dwt, dwtop.begin() + app_len);
	detail.assign(dwtop.begin() + app_len, dwtop.begin() + 2 * app_len);

	for (int i = 0; i < J; i++) {

		int U = 2; // Upsampling Factor
		std::vector<double> lpd1, hpd1, lpr1, hpr1;

		filtcoef(nm, lpd1, hpd1, lpr1, hpr1);
		lf = lpr1.size();


		// Operations in the Low Frequency branch of the Synthesis Filter Bank
		std::vector<double> X_lp;
		std::vector<double> cA_up;
		upsamp(app, U, cA_up);
		cA_up.pop_back();
		convfft(cA_up, lpr1, X_lp);



		// Operations in the High Frequency branch of the Synthesis Filter Bank

		std::vector<double> X_hp;
		std::vector<double> cD_up;
		upsamp(detail, U, cD_up);
		cD_up.pop_back();
		convfft(cD_up, hpr1, X_hp);


		app_len += det_len;
		vecsum(X_lp, X_hp, idwt_output);

		idwt_output.erase(idwt_output.begin(), idwt_output.begin() + lf - 2);
		idwt_output.erase(idwt_output.end() - (lf - 2), idwt_output.end());

		app.clear();
		detail.clear();
		if (i < J - 1) {
			det_len = length[i + 2];
			//        detail.assign(dwtop.begin()+app_len, dwtop.begin()+ det_len);

			for (unsigned int l = 0; l < det_len;l++) {
				double temp = dwtop[app_len + l];
				detail.push_back(temp);
			}

		}
		app = idwt_output;

		for (int iter1 = 0; iter1 < (int)(app.size() - det_len);iter1++) {
			app.pop_back();
		}

	}


	// Remove ZeroPadding

	int zerop = (int)flag[0];
	idwt_output.erase(idwt_output.end() - zerop, idwt_output.end());
	return 0;
}

void* dwt1_sym(std::string wname, std::vector<double> &signal, std::vector<double> &cA, std::vector<double> &cD) {

	std::vector<double> lp1, hp1, lp2, hp2;

	filtcoef(wname, lp1, hp1, lp2, hp2);
	int D = 2; // Downsampling Factor is 2
	int lf = lp1.size();
	symm_ext(signal, lf - 1);

	std::vector<double> cA_undec;
	//sig value
	convfft(signal, lp1, cA_undec);
	cA_undec.erase(cA_undec.begin(), cA_undec.begin() + lf);
	cA_undec.erase(cA_undec.end() - lf + 1, cA_undec.end());
	downsamp(cA_undec, D, cA);
	//  cA.erase(cA.begin(),cA.begin()+(int) ceil(((double)lf-1.0)/2.0));
	//  cA.erase(cA.end()-(int) ceil(((double)lf-1.0)/2.0),cA.end());


	//High Pass Branch Computation

	std::vector<double> cD_undec;
	convfft(signal, hp1, cD_undec);
	cD_undec.erase(cD_undec.begin(), cD_undec.begin() + lf);
	cD_undec.erase(cD_undec.end() - lf + 1, cD_undec.end());
	downsamp(cD_undec, D, cD);
	//   cD.erase(cD.begin(),cD.begin()+(int) ceil(((double)lf-1.0)/2.0));
	//   cD.erase(cD.end()-(int) ceil(((double)lf-1.0)/2.0),cD.end());

	filtcoef(wname, lp1, hp1, lp2, hp2);

	return 0;
}

void* dwt1_sym_m(std::string wname, std::vector<double> &signal, std::vector<double> &cA, std::vector<double> &cD) {

	std::vector<double> lp1, hp1, lp2, hp2;

	filtcoef(wname, lp1, hp1, lp2, hp2);
	int D = 2; // Downsampling Factor is 2
	int lf = lp1.size();
	symm_ext(signal, lf - 1);

	std::vector<double> cA_undec;
	//sig value
	convfftm(signal, lp1, cA_undec);
	cA_undec.erase(cA_undec.begin(), cA_undec.begin() + lf);
	cA_undec.erase(cA_undec.end() - lf + 1, cA_undec.end());
	downsamp(cA_undec, D, cA);
	//  cA.erase(cA.begin(),cA.begin()+(int) ceil(((double)lf-1.0)/2.0));
	//  cA.erase(cA.end()-(int) ceil(((double)lf-1.0)/2.0),cA.end());


	//High Pass Branch Computation

	std::vector<double> cD_undec;
	convfftm(signal, hp1, cD_undec);
	cD_undec.erase(cD_undec.begin(), cD_undec.begin() + lf);
	cD_undec.erase(cD_undec.end() - lf + 1, cD_undec.end());
	downsamp(cD_undec, D, cD);
	//   cD.erase(cD.begin(),cD.begin()+(int) ceil(((double)lf-1.0)/2.0));
	//   cD.erase(cD.end()-(int) ceil(((double)lf-1.0)/2.0),cD.end());

	filtcoef(wname, lp1, hp1, lp2, hp2);

	return 0;
}

void* dwt_sym(std::vector<double> &signal, int J, std::string nm, std::vector<double> &dwt_output,
	std::vector<double> &flag, std::vector<int> &length) {

	unsigned int temp_len = signal.size();
	if ((temp_len % 2) != 0) {
		double temp = signal[temp_len - 1];
		signal.push_back(temp);
		flag.push_back(1);
		temp_len++;
	}
	else {
		flag.push_back(0);
	}
	length.push_back(temp_len);
	flag.push_back(double(J));
	// flag[2] contains symmetric extension length


	std::vector<double> original_copy, appx_sig, det_sig;
	original_copy = signal;

	//  Storing Filter Values for GnuPlot
	std::vector<double> lp1, hp1, lp2, hp2;
	filtcoef(nm, lp1, hp1, lp2, hp2);
	for (int iter = 0; iter < J; iter++) {
		dwt1_sym(nm, signal, appx_sig, det_sig);
		dwt_output.insert(dwt_output.begin(), det_sig.begin(), det_sig.end());
		int l_temp = det_sig.size();
		length.insert(length.begin(), l_temp);

		if (iter == J - 1) {
			dwt_output.insert(dwt_output.begin(), appx_sig.begin(), appx_sig.end());
			int l_temp = appx_sig.size();
			length.insert(length.begin(), l_temp);

		}

		signal.clear();
		signal = appx_sig;
		appx_sig.clear();
		det_sig.clear();

	}
	signal = original_copy;

	return 0;
}


void* freq(std::vector<double> &sig, std::vector<double> &freq_resp) {
	unsigned int K = sig.size();
	unsigned int N = (unsigned int)pow(2.0, ceil(log10(static_cast<double>(K)) / log10(2.0)));
	std::vector<std::complex<double> > fft_oup;
	for (unsigned int i = 0; i < sig.size(); i++) {
		double temp = sig[i];
		fft_oup.push_back(std::complex<double>(temp, 0));
	}
	fft(fft_oup, 1, N);

	for (unsigned int i = 0; i < N; i++) {
		double temp = abs(fft_oup[i]);
		freq_resp.push_back(temp);
	}
	circshift(freq_resp, N / 2);
	return 0;
}

double convfft(std::vector<double> &a, std::vector<double> &b, std::vector<double> &cx) {
/*	unsigned int sz = a.size() + b.size() - 1;

	kiss_fft_cfg fwd = kiss_fft_alloc(sz, 0, 0, 0);
	kiss_fft_cfg bwd = kiss_fft_alloc(sz, 1, 0, 0);

	//cout << sz << endl;

	//kiss_fft_cpx inp_data[sz],inp_fft[sz],temp_data[sz];

	//kiss_fft_cpx filt_data[sz],filt_fft[sz],temp_ifft[sz];

	kiss_fft_cpx* inp_data = (kiss_fft_cpx*)malloc(sizeof(kiss_fft_cpx) * (sz));
	kiss_fft_cpx* inp_fft = (kiss_fft_cpx*)malloc(sizeof(kiss_fft_cpx) * (sz));
	kiss_fft_cpx* temp_data = (kiss_fft_cpx*)malloc(sizeof(kiss_fft_cpx) * (sz));
	kiss_fft_cpx* filt_data = (kiss_fft_cpx*)malloc(sizeof(kiss_fft_cpx) * (sz));
	kiss_fft_cpx* filt_fft = (kiss_fft_cpx*)malloc(sizeof(kiss_fft_cpx) * (sz));
	kiss_fft_cpx* temp_ifft = (kiss_fft_cpx*)malloc(sizeof(kiss_fft_cpx) * (sz));

	for (unsigned int i = 0; i < sz; i++) {
		if (i < a.size()) {
			inp_data[i].r = a[i];
		}
		else {
			inp_data[i].r = 0.0;

		}
		inp_data[i].i = 0.0;
		if (i < b.size()) {
			filt_data[i].r = b[i];
		}
		else {
			filt_data[i].r = 0.0;

		}
		filt_data[i].i = 0.0;

	}

	kiss_fft(fwd, inp_data, inp_fft);
	kiss_fft(fwd, filt_data, filt_fft);

	for (unsigned int i = 0; i < sz; i++) {
		temp_data[i].r = inp_fft[i].r*filt_fft[i].r - inp_fft[i].i*filt_fft[i].i;

		temp_data[i].i = inp_fft[i].r*filt_fft[i].i + inp_fft[i].i*filt_fft[i].r;



	}

	kiss_fft(bwd, temp_data, temp_ifft);

	for (unsigned int i = 0; i < sz; i++) {
		double temp1;
		temp1 = temp_ifft[i].r / (double)sz;
		cx.push_back(temp1);
		// cout << temp1 << endl;

	}

	//    free(inp_data);
	//    free(filt_data);
	//    free(inp_fft);
	//    free(filt_fft);
	//    free(temp_data);
	//    free(temp_ifft);
	free(inp_data);
	free(inp_fft);
	free(temp_data);
	free(filt_data);
	free(filt_fft);
	free(temp_ifft);
	free(bwd);
	free(fwd);*/


	return 0;

}

double convfftm(std::vector<double> &a, std::vector<double> &b, std::vector<double> &cx) {
/*	unsigned int szd = a.size() + b.size() - 1;

	unsigned int sz = (int)pow(2.0, ceil(log(double(szd)) / log(2.0)));


	//kiss_fft_cpx inp_data[sz],inp_fft[sz],temp_data[sz];

	//kiss_fft_cpx filt_data[sz],filt_fft[sz],temp_ifft[sz];
	kiss_fft_cpx* inp_data = (kiss_fft_cpx*)malloc(sizeof(kiss_fft_cpx) * (sz));
	kiss_fft_cpx* inp_fft = (kiss_fft_cpx*)malloc(sizeof(kiss_fft_cpx) * (sz));
	kiss_fft_cpx* temp_data = (kiss_fft_cpx*)malloc(sizeof(kiss_fft_cpx) * (sz));
	kiss_fft_cpx* filt_data = (kiss_fft_cpx*)malloc(sizeof(kiss_fft_cpx) * (sz));
	kiss_fft_cpx* filt_fft = (kiss_fft_cpx*)malloc(sizeof(kiss_fft_cpx) * (sz));
	kiss_fft_cpx* temp_ifft = (kiss_fft_cpx*)malloc(sizeof(kiss_fft_cpx) * (sz));

	if (sz != transient_size_of_fft) {

		if (transient_size_of_fft != 0) {
			free(fwd);
			free(bwd);
		}

		fwd = kiss_fft_alloc(sz, 0, 0, 0);
		bwd = kiss_fft_alloc(sz, 1, 0, 0);
		transient_size_of_fft = sz;
	}

	for (unsigned int i = 0; i < sz; i++) {
		if (i < a.size()) {
			inp_data[i].r = a[i];
		}
		else {
			inp_data[i].r = 0.0;

		}
		inp_data[i].i = 0.0;
		if (i < b.size()) {
			filt_data[i].r = b[i];
		}
		else {
			filt_data[i].r = 0.0;

		}
		filt_data[i].i = 0.0;

	}

	kiss_fft(fwd, inp_data, inp_fft);
	kiss_fft(fwd, filt_data, filt_fft);

	for (unsigned int i = 0; i < sz; i++) {
		temp_data[i].r = inp_fft[i].r*filt_fft[i].r - inp_fft[i].i*filt_fft[i].i;

		temp_data[i].i = inp_fft[i].r*filt_fft[i].i + inp_fft[i].i*filt_fft[i].r;



	}

	kiss_fft(bwd, temp_data, temp_ifft);

	for (unsigned int i = 0; i < szd; i++) {
		double temp1;
		temp1 = temp_ifft[i].r / (double)sz;
		cx.push_back(temp1);
		// cout << temp1 << endl;

	}
	free(inp_data);
	free(inp_fft);
	free(temp_data);
	free(filt_data);
	free(filt_fft);
	free(temp_ifft);
	free(bwd);
	free(fwd);*/

	return 0;

}


void* fft(std::vector<std::complex<double>> &data, int sign, unsigned  int N) {
	double pi = -3.14159265358979;
	if (sign == 1 || sign == -1) {
		pi = sign * pi;
	}
	else {
		//cout << "Format fft(data, num), num = +1(fft) and num = -1 (Ifft)" << endl;
		exit(1);
	}
	unsigned int len = data.size();
	std::vector<std::complex<double> >::iterator it;
	it = data.end();
	if (len != N) {
		unsigned int al = N - len;
		data.insert(it, al, std::complex<double>(0, 0));
	}

	unsigned int K = (unsigned int)pow(2.0, ceil(log10(static_cast<double>(N)) / log10(2.0)));
	std::vector<std::complex<double> >::iterator it1;
	it1 = data.end();
	if (N < K) {
		unsigned int al = K - N;
		data.insert(it1, al, std::complex<double>(0, 0));
		N = K;
	}

	bitreverse(data);

	//	 radix2(data);
	for (unsigned int iter = 1; iter < N; iter <<= 1)
	{
		const unsigned int step = iter << 1;

		const double theta = pi / double(iter);

		double wtemp = sin(theta * .5);
		//   Multipliers
		double wreal = -2 * wtemp * wtemp;
		double wimag = sin(theta);

		//   Factors
		double wr = 1.0;
		double wi = 0.0;
		//   Iteration through two loops

		for (unsigned int m = 0; m < iter; m++)
		{
			//   Iteration within m
			for (unsigned int i = m; i < N; i += step)
			{
				//   jth position
				const unsigned int j = i + iter;

				double tempr = wr * std::real(data[j]) - wi * std::imag(data[j]);
				double tempi = wr * std::imag(data[j]) + wi * std::real(data[j]);

				std::complex<double> temp(tempr, tempi);
				data[j] = data[i] - temp;
				data[i] += temp;

			}
			//   Twiddle Factors updated
			wtemp = wr;
			wr += wr * wreal - wi * wimag;
			wi += wi * wreal + wtemp * wimag;
		}

	}

	if (sign == -1) {
		double scale = 1.0 / double(N);
		for (unsigned int i = 0; i < N; i++) {
			data[i] *= scale;
		}
	}

	// Place holder
	return 0;
}


void* bitreverse(std::vector<std::complex<double> > &sig) {
	unsigned int len = sig.size();
	unsigned int N = (unsigned int)pow(2.0, ceil(log10(static_cast<double>(len)) / log10(2.0)));
	unsigned int rev = 0;
	//   Processing Input Data
	for (unsigned int iter = 0; iter < N; ++iter)
	{
		if (rev > iter)
		{
			//   Replacing current values with reversed values

			double tempr = std::real(sig[rev]);
			double tempi = std::imag(sig[rev]);
			std::complex<double> temp(tempr, tempi);
			sig[rev] = sig[iter];
			sig[iter] = temp;

		}
		//   Using filter "filt" such that the value of reverse changes with each iteration
		unsigned int filt = N;
		while (rev & (filt >>= 1)) {
			rev &= ~filt;
		}
		rev |= filt;
	}
	return 0;

}


void* dwt(std::vector<double> &sig, int J, std::string nm, std::vector<double> &dwt_output
	, std::vector<double> &flag, std::vector<int> &length) {

	int Max_Iter;
	Max_Iter = (int)ceil(log(double(sig.size())) / log(2.0)) - 2;

	if (Max_Iter < J) {
		J = Max_Iter;

	}

	std::vector<double> original_copy, orig, appx_sig, det_sig;
	original_copy = sig;

	// Zero Pad the Signal to nearest 2^ M value ,where M is an integer.
	unsigned int temp_len = sig.size();
	if ((temp_len % 2) != 0) {
		double temp = sig[temp_len - 1];
		sig.push_back(temp);
		flag.push_back(1);
		temp_len++;
	}
	else {
		flag.push_back(0);
	}
	length.push_back(temp_len);
	flag.push_back(double(J));

	orig = sig;


	//  Storing Filter Values for GnuPlot
	std::vector<double> lp1, hp1, lp2, hp2;
	filtcoef(nm, lp1, hp1, lp2, hp2);


	for (int iter = 0; iter < J; iter++) {
		dwt1(nm, orig, appx_sig, det_sig);
		dwt_output.insert(dwt_output.begin(), det_sig.begin(), det_sig.end());

		int l_temp = det_sig.size();
		length.insert(length.begin(), l_temp);

		if (iter == J - 1) {
			dwt_output.insert(dwt_output.begin(), appx_sig.begin(), appx_sig.end());
			int l_temp2 = appx_sig.size();
			length.insert(length.begin(), l_temp2);

		}

		orig = appx_sig;
		appx_sig.clear();
		det_sig.clear();

	}

	sig = original_copy;
	return 0;
}


void circshift(std::vector<double> &sig_cir, int L) {
	if (abs(L) >(signed int)sig_cir.size()) {
		L = sign(L) * (abs(L) % sig_cir.size());
	}

	if (L < 0) {
		L = (sig_cir.size() + L) % sig_cir.size();
		//	cout << "L" << L << endl;
	}
	for (int i = 0; i < L; i++) {
		sig_cir.push_back(sig_cir[0]);
		sig_cir.erase(sig_cir.begin());
	}

}

double convol(std::vector<double> &a1, std::vector<double> &b1, std::vector<double> &c) {
	unsigned int len_c = a1.size() + b1.size() - 1;
	std::vector<double> a = a1;
	std::vector<double> b = b1;
	double*  oup = NULL;

	oup = new double[len_c];
	std::vector<double>::iterator a_it;
	a_it = a.end();
	signed int al = len_c - a.size();
	a.insert(a_it, al, 0);


	std::vector<double>::iterator b_it;
	b_it = b.end();
	signed int bl = len_c - b.size();
	b.insert(b_it, bl, 0);


	for (unsigned int ini = 0; ini < len_c; ini++) {
		double ou1 = 0;
		oup[ini] = 0;
		double temp = 0;
		for (unsigned int jni = 0; jni <= ini; jni++) {
			ou1 = a[jni] * b[ini - jni];
			oup[ini] += ou1;
		}
		temp = oup[ini];
		c.push_back(temp);
	}
	delete[] oup;
	oup = NULL;
	return 0;
}

void downsamp(std::vector<double> &sig, int M, std::vector<double> &sig_d) {
	int len = sig.size();
	double len_n = ceil((double)len / (double)M);
	for (int i = 0; i < (int)len_n; i++) {
		double temp = sig[i*M];
		sig_d.push_back(temp);
	}
}

void* dwt1(std::string wname, std::vector<double> &signal, std::vector<double> &cA, std::vector<double> &cD) {

	std::vector<double> lpd, hpd, lpr, hpr;

	filtcoef(wname, lpd, hpd, lpr, hpr);

	int len_lpfilt = lpd.size();
	int len_hpfilt = hpd.size();
	int len_avg = (len_lpfilt + len_hpfilt) / 2;
	int len_sig = 2 * (int)ceil((double)signal.size() / 2.0);

	per_ext(signal, len_avg / 2); // Periodic Extension

	std::vector<double> cA_undec;
	// convolving signal with lpd, Low Pass Filter, and O/P is stored in cA_undec
	convfft(signal, lpd, cA_undec);
	int D = 2; // Downsampling Factor is 2
	cA_undec.erase(cA_undec.begin(), cA_undec.begin() + len_avg - 1);
	cA_undec.erase(cA_undec.end() - len_avg + 1, cA_undec.end());
	cA_undec.erase(cA_undec.begin() + len_sig, cA_undec.end());
	cA_undec.erase(cA_undec.begin());


	// Downsampling by 2 gives cA
	downsamp(cA_undec, D, cA);

	std::vector<double> cD_undec;
	// convolving signal with lpd, Low Pass Filter, and O/P is stored in cA_undec
	convfft(signal, hpd, cD_undec);
	cD_undec.erase(cD_undec.begin(), cD_undec.begin() + len_avg - 1);
	cD_undec.erase(cD_undec.end() - len_avg + 1, cD_undec.end());
	cD_undec.erase(cD_undec.begin() + len_sig, cD_undec.end());
	cD_undec.erase(cD_undec.begin());

	// Downsampling Factor is 2

	// Downsampling by 2 gives cA
	downsamp(cD_undec, D, cD);

	filtcoef(wname, lpd, hpd, lpr, hpr);

	return 0;
}

void* dwt1_m(std::string wname, std::vector<double> &signal, std::vector<double> &cA, std::vector<double> &cD) {

	std::vector<double> lpd, hpd, lpr, hpr;

	filtcoef(wname, lpd, hpd, lpr, hpr);

	int len_lpfilt = lpd.size();
	int len_hpfilt = hpd.size();
	int len_avg = (len_lpfilt + len_hpfilt) / 2;
	int len_sig = 2 * (int)ceil((double)signal.size() / 2.0);

	// cout << len_lpfilt << "Filter" << endl;
	per_ext(signal, len_avg / 2); // Periodic Extension
								  // computations designed to deal with boundary distortions

								  // Low Pass Filtering Operations in the Analysis Filter Bank Section
								  //		int len_cA =(int)  floor(double (len_sig + len_lpfilt -1) / double (2));
	std::vector<double> cA_undec;
	// convolving signal with lpd, Low Pass Filter, and O/P is stored in cA_undec
	convfftm(signal, lpd, cA_undec);
	int D = 2; // Downsampling Factor is 2
	cA_undec.erase(cA_undec.begin(), cA_undec.begin() + len_avg - 1);
	cA_undec.erase(cA_undec.end() - len_avg + 1, cA_undec.end());
	cA_undec.erase(cA_undec.begin() + len_sig, cA_undec.end());
	cA_undec.erase(cA_undec.begin());


	// Downsampling by 2 gives cA
	downsamp(cA_undec, D, cA);

	//     cA.erase(cA.begin(),cA.begin()+len_avg/2);
	//      cA.erase(cA.end()-len_avg/2,cA.end());

	// High Pass Filtering Operations in the Analysis Filter Bank Section
	//		int len_cA =(int)  floor(double (len_sig + len_lpfilt -1) / double (2));

	std::vector<double> cD_undec;
	// convolving signal with lpd, Low Pass Filter, and O/P is stored in cA_undec
	convfftm(signal, hpd, cD_undec);
	cD_undec.erase(cD_undec.begin(), cD_undec.begin() + len_avg - 1);
	cD_undec.erase(cD_undec.end() - len_avg + 1, cD_undec.end());
	cD_undec.erase(cD_undec.begin() + len_sig, cD_undec.end());
	cD_undec.erase(cD_undec.begin());

	// Downsampling Factor is 2

	// Downsampling by 2 gives cA
	downsamp(cD_undec, D, cD);

	//            cD.erase(cD.begin(),cD.begin()+len_avg/2);
	//          cD.erase(cD.end()-len_avg/2,cD.end());

	filtcoef(wname, lpd, hpd, lpr, hpr);

	return 0;
}


void* dyadic_zpad_1d(std::vector<double> &signal) {
	unsigned int N = signal.size();
	double M = log10(static_cast<double> (N)) / log10(2.0);
	int D = (int)ceil(M);
	double int_val = pow(2.0, double(D)) - pow(2.0, M);

	int z = (int)int_val;
	std::vector<double>::iterator a_it;
	a_it = signal.end();
	double val = signal[N - 1];
	//  double val = 0;
	signal.insert(a_it, z, val);
	return 0;

}


void* idwt(std::vector<double> &dwtop, std::vector<double> &flag, std::string nm,
	std::vector<double> &idwt_output, std::vector<int> &length) {

	int J = (int)flag[1];
	//       int zpad =(int) flag[0];


	std::vector<double> app;
	std::vector<double> detail;
	unsigned int app_len = length[0];
	unsigned int det_len = length[1];

	std::vector<double>::iterator dwt;
	dwt = dwtop.begin();
	app.assign(dwt, dwtop.begin() + app_len);
	detail.assign(dwtop.begin() + app_len, dwtop.begin() + 2 * app_len);

	for (int i = 0; i < J; i++) {

		idwt1(nm, idwt_output, app, detail);
		app_len += det_len;
		app.clear();
		detail.clear();
		if (i < J - 1) {
			det_len = length[i + 2];
			for (unsigned int l = 0; l < det_len;l++) {
				double temp = dwtop[app_len + l];
				detail.push_back(temp);
			}
			app = idwt_output;

			if (app.size() >= detail.size()) {
				int t = app.size() - detail.size();
				int lent = (int)floor((double)t / 2.0);
				app.erase(app.begin() + detail.size() + lent, app.end());
				app.erase(app.begin(), app.begin() + lent);
			}
		}


	}


	// Remove ZeroPadding

	int zerop = (int)flag[0];
	idwt_output.erase(idwt_output.end() - zerop, idwt_output.end());

	return 0;
}

void* idwt1_m(std::string wname, std::vector<double> &X, std::vector<double> &cA, std::vector<double> &cD) {
	std::vector<double> lpd1, hpd1, lpr1, hpr1;

	filtcoef(wname, lpd1, hpd1, lpr1, hpr1);
	int len_lpfilt = lpr1.size();
	int len_hpfilt = hpr1.size();
	int len_avg = (len_lpfilt + len_hpfilt) / 2;
	unsigned int N = 2 * cD.size();
	int U = 2; // Upsampling Factor

			   // Operations in the Low Frequency branch of the Synthesis Filter Bank

	std::vector<double> cA_up;
	std::vector<double> X_lp;
	// int len1 = cA_up.size();
	upsamp(cA, U, cA_up);

	per_ext(cA_up, len_avg / 2);


	convfftm(cA_up, lpr1, X_lp);


	// Operations in the High Frequency branch of the Synthesis Filter Bank

	std::vector<double> cD_up;
	std::vector<double> X_hp;
	upsamp(cD, U, cD_up);
	per_ext(cD_up, len_avg / 2);


	convfftm(cD_up, hpr1, X_hp);


	X_lp.erase(X_lp.begin() + N + len_avg - 1, X_lp.end());
	X_lp.erase(X_lp.begin(), X_lp.begin() + len_avg - 1);

	X_hp.erase(X_hp.begin() + N + len_avg - 1, X_hp.end());
	X_hp.erase(X_hp.begin(), X_hp.begin() + len_avg - 1);


	vecsum(X_lp, X_hp, X);


	return 0;
}

void* idwt1(std::string wname, std::vector<double> &X, std::vector<double> &cA, std::vector<double> &cD) {
	std::vector<double> lpd1, hpd1, lpr1, hpr1;

	filtcoef(wname, lpd1, hpd1, lpr1, hpr1);
	int len_lpfilt = lpr1.size();
	int len_hpfilt = hpr1.size();
	int len_avg = (len_lpfilt + len_hpfilt) / 2;
	unsigned int N = 2 * cD.size();
	int U = 2; // Upsampling Factor

			   // Operations in the Low Frequency branch of the Synthesis Filter Bank

	std::vector<double> cA_up;
	std::vector<double> X_lp;
	// int len1 = cA_up.size();
	upsamp(cA, U, cA_up);

	per_ext(cA_up, len_avg / 2);


	convfft(cA_up, lpr1, X_lp);


	// Operations in the High Frequency branch of the Synthesis Filter Bank

	std::vector<double> cD_up;
	std::vector<double> X_hp;
	upsamp(cD, U, cD_up);
	per_ext(cD_up, len_avg / 2);


	convfft(cD_up, hpr1, X_hp);

	// Remove periodic extension

	//   X.erase(X.begin(),X.begin()+len_avg+len_avg/2-1);
	//   X.erase(X.end()-len_avg-len_avg/2,X.end());


	X_lp.erase(X_lp.begin() + N + len_avg - 1, X_lp.end());
	X_lp.erase(X_lp.begin(), X_lp.begin() + len_avg - 1);

	X_hp.erase(X_hp.begin() + N + len_avg - 1, X_hp.end());
	X_hp.erase(X_hp.begin(), X_hp.begin() + len_avg - 1);


	vecsum(X_lp, X_hp, X);


	return 0;
}

int sign(int X) {
	if (X >= 0)
		return 1;
	else
		return -1;
}

void upsamp(std::vector<double> &sig, int M, std::vector<double> &sig_u) {
	int len = sig.size();
	double len_n = ceil((double)len * (double)M);

	for (int i = 0; i < (int)len_n; i++) {
		if (i % M == 0) {
			double temp = sig[i / M];
			sig_u.push_back(temp);

		}
		else
		{
			sig_u.push_back(0);
		}

	}



}

double op_sum(double i, double j) {
	return (i + j);
}

int vecsum(std::vector<double> &a, std::vector<double> &b, std::vector<double> &c) {


	c.resize(a.size());
	transform(a.begin(), a.end(), b.begin(), b.begin(), op_sum);
	c = b;
	return 0;
}

void* getcoeff2d(std::vector<std::vector<double> > &dwtoutput, std::vector<std::vector<double> > &cH,
	std::vector<std::vector<double> > &cV, std::vector<std::vector<double> > &cD, std::vector<double> &flag, int &N) {
	if (N > flag[2]) {
	//	cout << "Signal is decimated only up to " << flag[2] << " levels" << endl;
		exit(1);
	}
	int rows = dwtoutput.size();
	int cols = dwtoutput[0].size();
	// Getting Horizontal Coefficients
	int r = (int)ceil((double)rows / pow(2.0, N));
	int c = (int)ceil((double)cols / pow(2.0, N));

	for (int i = 0; i < (int)ceil((double)rows / pow(2.0, N)); i++) {
		for (int j = 0; j < (int)ceil((double)cols / pow(2.0, N)); j++) {
			cH[i][j] = dwtoutput[i][c + j];
		}
	}


	for (int i = 0; i < (int)ceil((double)rows / pow(2.0, N)); i++) {
		for (int j = 0; j < (int)ceil((double)cols / pow(2.0, N)); j++) {
			cV[i][j] = dwtoutput[i + r][j];
		}
	}

	for (int i = 0; i < (int)ceil((double)rows / pow(2.0, N)); i++) {
		for (int j = 0; j < (int)ceil((double)cols / pow(2.0, N)); j++) {
			cD[i][j] = dwtoutput[i + r][c + j];
		}
	}

	return 0;
}

void* zero_remove(std::vector<std::vector<double> > &input, std::vector<std::vector<double> > &output) {
	int zero_rows = output.size() - input.size();
	int zero_cols = output[0].size() - input[0].size();

	std::vector<std::vector<double> >::iterator row = output.end() - zero_rows;


	unsigned int ousize = output.size();
	for (unsigned int i = input.size(); i < ousize; i++) {
		output.erase(row);
		row++;

	}

	//	unsigned int ousize2 = output[0].size();


	for (unsigned int i = 0; i < ousize; i++) {
		std::vector<double> ::iterator col = output[i].end() - zero_cols;

		output[i].erase(col, output[i].end());

	}
	return 0;
}

void* dwt_output_dim(std::vector<std::vector<double> >&signal, int &r, int &c) {
	int rows = signal.size();
	int cols = signal[0].size();

	double Mr = log10(static_cast<double> (rows)) / log10(2.0);
	int Dr = (int)ceil(Mr);
	double int_val_row = pow(2.0, double(Dr));
	int r1 = (int)int_val_row;

	double Mc = log10(static_cast<double> (cols)) / log10(2.0);
	int Dc = (int)ceil(Mc);
	double int_val_cols = pow(2.0, double(Dc));
	int c1 = (int)int_val_cols;
	r = (r1 > c1) ? r1 : c1;
	c = (r1 > c1) ? r1 : c1;

	return 0;

}

void* dyadic_zpad_2d(std::vector<std::vector<double> > &signal, std::vector<std::vector<double> > &mod) {
	int rows = signal.size();
	int cols = signal[0].size();

	for (int i = 0; i < rows; i++) {
		for (int j = 0; j < cols; j++) {
			mod[i][j] = signal[i][j];
		}

	}
	// Zeropadding the columns

	double Mr = log10(static_cast<double> (rows)) / log10(2.0);
	int Dr = (int)ceil(Mr);
	double int_val_row = pow(2.0, double(Dr)) - pow(2.0, Mr);

	int zeros_row = (int)int_val_row;

	double Mc = log10(static_cast<double> (cols)) / log10(2.0);
	int Dc = (int)ceil(Mc);
	double int_val_cols = pow(2.0, double(Dc)) - pow(2.0, Mc);

	int zeros_cols = (int)int_val_cols;

	for (int i = 0; i < rows + zeros_row; i++) {
		for (int j = cols; j < cols + zeros_cols; j++) {

			mod[i][j] = 0;
		}

	}

	for (int i = rows; i < rows + zeros_row; i++) {
		for (int j = 0; j < cols + zeros_cols; j++) {
			mod[i][j] = 0;
		}

	}

	return 0;

}

void* idwt_2d(std::vector<double>  &dwtop, std::vector<double> &flag, std::string nm,
	std::vector<std::vector<double> > &idwt_output, std::vector<int> &length) {
	int J = (int)flag[0];
	int rows = length[0];
	int cols = length[1];

	int sum_coef = 0;
	std::vector<double> lp1, hp1, lp2, hp2;
	filtcoef(nm, lp1, hp1, lp2, hp2);
	std::vector<std::vector<double> >  cLL(rows, std::vector<double>(cols));


	for (int iter = 0; iter < J; iter++) {

		int rows_n = length[2 * iter];
		int cols_n = length[2 * iter + 1];

		std::vector<std::vector<double> >  cLH(rows_n, std::vector<double>(cols_n));
		std::vector<std::vector<double> >  cHL(rows_n, std::vector<double>(cols_n));
		std::vector<std::vector<double> >  cHH(rows_n, std::vector<double>(cols_n));

		for (int i = 0; i < rows_n; i++) {
			for (int j = 0; j < cols_n; j++) {
				if (iter == 0) {
					cLL[i][j] = dwtop[sum_coef + i * cols_n + j];

					cLH[i][j] = dwtop[sum_coef + rows_n * cols_n + i * cols_n + j];

					cHL[i][j] = dwtop[sum_coef + 2 * rows_n * cols_n + i * cols_n + j];

					cHH[i][j] = dwtop[sum_coef + 3 * rows_n * cols_n + i * cols_n + j];
				}
				else {

					cLH[i][j] = dwtop[sum_coef + i * cols_n + j];

					cHL[i][j] = dwtop[sum_coef + rows_n * cols_n + i * cols_n + j];

					cHH[i][j] = dwtop[sum_coef + 2 * rows_n * cols_n + i * cols_n + j];

				}
			}
		}


		//      temp_A = cLL;
		//  	idwt2_sym(nm,idwt_output2, cA, cH,cV,cD);

		unsigned int len_x = cLH.size();
		unsigned int len_y = cLH[0].size();

		// Row Upsampling and Column Filtering at the first LP Stage
		std::vector<std::vector<double> > cL(2 * len_x, std::vector<double>(len_y));
		std::vector<std::vector<double> > cH(2 * len_x, std::vector<double>(len_y));

		if (iter == 0) {
			for (unsigned int j = 0; j < len_y; j++) {

				std::vector<double> sigLL, sigLH, oup;

				for (unsigned int i = 0;i < len_x;i++) {

					double temp1 = cLL[i][j];
					double temp2 = cLH[i][j];
					sigLL.push_back(temp1);
					sigLH.push_back(temp2);
				}
				idwt1_m(nm, oup, sigLL, sigLH);

				for (int i = 0;i < (int)oup.size();i++) {
					cL[i][j] = oup[i];
				}

			}
		}
		else {
			unsigned int rows1 = cLH.size();
			unsigned int cols1 = cLH[0].size();

			for (unsigned int j = 0; j < cols1;j++) {
				std::vector<double> temp_L1, temp_L2, oup;
				for (unsigned int i = 0; i < rows1; i++) {
					double temp = cLL[i][j];
					temp_L1.push_back(temp);

					double temp2 = cLH[i][j];
					temp_L2.push_back(temp2);
				}
				idwt1_m(nm, oup, temp_L1, temp_L2);

				for (unsigned int i = 0; i < oup.size(); i++) {
					cL[i][j] = oup[i];
				}

			}
		}


		for (unsigned int j = 0; j < len_y; j++) {
			std::vector<double> sigHL, sigHH, oup2;
			for (unsigned int i = 0;i < len_x;i++) {
				double temp3 = cHL[i][j];
				double temp4 = cHH[i][j];
				sigHL.push_back(temp3);
				sigHH.push_back(temp4);
			}
			idwt1_m(nm, oup2, sigHL, sigHH);

			for (int i = 0;i < (int)oup2.size();i++) {
				cH[i][j] = oup2[i];
			}

		}

		std::vector<std::vector<double> > signal(2 * len_x, std::vector<double>(2 * len_y));
		for (unsigned int i = 0; i < 2 * len_x; i++) {
			std::vector<double> sigL, sigH, oup;
			for (unsigned int j = 0;j < len_y;j++) {
				double temp5 = cL[i][j];
				double temp6 = cH[i][j];
				sigL.push_back(temp5);
				sigH.push_back(temp6);
			}
			idwt1_m(nm, oup, sigL, sigH);

			for (int j = 0;j < (int)oup.size();j++) {
				signal[i][j] = oup[j];
			}

		}

		idwt_output = signal;



		if (iter == 0) {
			sum_coef += 4 * rows_n * cols_n;
		}
		else {
			sum_coef += 3 * rows_n * cols_n;
		}
		cLL = signal;


	}


	return 0;
}



void* dwt_2d(std::vector<std::vector<double> > &origsig, int J, std::string nm, std::vector<double> &dwt_output
	, std::vector<double> &flag, std::vector<int> &length) {
	// flag will contain

	std::vector<std::vector<double> >  sig = origsig;
	int rows_n = sig.size(); // No. of rows
	int cols_n = sig[0].size(); //No. of columns
	std::vector<std::vector<double> > original_copy(rows_n, std::vector<double>(cols_n));

	original_copy = sig;
	int Max_Iter;
	int temp1 = (int)ceil(log(double(sig.size())) / log(2.0));
	int temp2 = (int)ceil(log(double(sig[0].size())) / log(2.0));
	Max_Iter = (temp1 > temp2) ? temp1 : temp2;
	if (Max_Iter < J) {
	//	cout << J << " Iterations are not possible with signals of this dimension " << endl;
		exit(1);
	}
	std::vector<double> lp1, hp1, lp2, hp2;

	flag.push_back(double(J));
	flag.push_back(0);


	length.insert(length.begin(), cols_n);
	length.insert(length.begin(), rows_n);


	int sum_coef = 0;
	for (int iter = 0; iter < J; iter++) {
		filtcoef(nm, lp1, hp1, lp2, hp2);

		rows_n = (int)ceil((double)rows_n / 2.0);
		cols_n = (int)ceil((double)cols_n / 2.0);
		length.insert(length.begin(), cols_n);
		length.insert(length.begin(), rows_n);

		std::vector<std::vector<double> >  cA(rows_n, std::vector<double>(cols_n));
		std::vector<std::vector<double> >  cH(rows_n, std::vector<double>(cols_n));
		std::vector<std::vector<double> >  cV(rows_n, std::vector<double>(cols_n));
		std::vector<std::vector<double> >  cD(rows_n, std::vector<double>(cols_n));

		if (iter == 0) {
			dwt2(nm, original_copy, cA, cH, cV, cD);
		}
		else {
			dwt2(nm, original_copy, cA, cH, cV, cD);

		}
		std::vector<double>   temp_sig2;

		original_copy = cA;
		if (iter == J - 1) {
			for (int i = 0; i < rows_n; i++) {
				for (int j = 0; j < cols_n; j++) {
					double temp = cA[i][j];
					temp_sig2.push_back(temp);
				}
			}
		}
		for (int i = 0; i < rows_n; i++) {
			for (int j = cols_n; j < cols_n * 2; j++) {
				double temp = cH[i][j - cols_n];
				temp_sig2.push_back(temp);
			}
		}

		for (int i = rows_n; i < rows_n * 2; i++) {
			for (int j = 0; j < cols_n; j++) {
				double temp = cV[i - rows_n][j];
				temp_sig2.push_back(temp);
			}
		}

		for (int i = rows_n; i < rows_n * 2; i++) {
			for (int j = cols_n; j < cols_n * 2; j++) {
				double temp = cD[i - rows_n][j - cols_n];
				temp_sig2.push_back(temp);
			}
		}

		dwt_output.insert(dwt_output.begin(), temp_sig2.begin(), temp_sig2.end());
		sum_coef += 4 * rows_n * cols_n;



	}

	return 0;

}



void* branch_lp_hp_up(std::string wname, std::vector<double> &cA, std::vector<double> &cD, std::vector<double> &X) {
	std::vector<double> lpd1, hpd1, lpr1, hpr1;

	filtcoef(wname, lpd1, hpd1, lpr1, hpr1);
	int len_lpfilt = lpr1.size();
	int len_hpfilt = hpr1.size();
	int len_avg = (len_lpfilt + len_hpfilt) / 2;
	//unsigned int N = 2 * cA.size();
	int U = 2; // Upsampling Factor

			   // Operations in the Low Frequency branch of the Synthesis Filter Bank

	std::vector<double> cA_up;
	std::vector<double> X_lp;
	per_ext(cA, len_avg / 2);

	upsamp(cA, U, cA_up);
	convfftm(cA_up, lpr1, X_lp);


	// Operations in the High Frequency branch of the Synthesis Filter Bank

	std::vector<double> cD_up;
	std::vector<double> X_hp;
	per_ext(cD, len_avg / 2);
	upsamp(cD, U, cD_up);
	convfftm(cD_up, hpr1, X_hp);




	vecsum(X_lp, X_hp, X);
	// Remove periodic extension

	X.erase(X.begin(), X.begin() + len_avg + len_avg / 2 - 1);
	X.erase(X.end() - len_avg - len_avg / 2, X.end());

	return 0;
}

void* branch_hp_dn(std::string wname, std::vector<double> &signal, std::vector<double> &sigop) {

	std::vector<double> lpd, hpd, lpr, hpr;

	filtcoef(wname, lpd, hpd, lpr, hpr);
	//		for (unsigned int i = 0;  i < signal.size(); i++) {
	//		cout << signal[i] <<  endl;
	//		out2 << signal[i] <<endl;
	//		}

	unsigned int temp_len = signal.size();

	if ((temp_len % 2) != 0) {
		double temp = signal[temp_len - 1];
		signal.push_back(temp);
	}

	int len_lpfilt = lpd.size();
	int len_hpfilt = hpd.size();
	int len_avg = (len_lpfilt + len_hpfilt) / 2;

	// cout << len_lpfilt << "Filter" << endl;
	per_ext(signal, len_avg / 2); // Periodic Extension
								  // computations designed to deal with boundary distortions

								  // Low Pass Filtering Operations in the Analysis Filter Bank Section
								  //		int len_cA =(int)  floor(double (len_sig + len_lpfilt -1) / double (2));
	std::vector<double> cA_undec;
	// convolving signal with lpd, Low Pass Filter, and O/P is stored in cA_undec
	convfftm(signal, hpd, cA_undec);
	int D = 2; // Downsampling Factor is 2

			   // Downsampling by 2 gives cA
	downsamp(cA_undec, D, sigop);

	sigop.erase(sigop.begin(), sigop.begin() + len_avg / 2);
	sigop.erase(sigop.end() - len_avg / 2, sigop.end());
	return 0;



}
void* branch_lp_dn(std::string wname, std::vector<double> &signal, std::vector<double> &sigop) {

	std::vector<double> lpd, hpd, lpr, hpr;

	filtcoef(wname, lpd, hpd, lpr, hpr);
	//		for (unsigned int i = 0;  i < signal.size(); i++) {
	//		cout << signal[i] <<  endl;
	//		out2 << signal[i] <<endl;
	//		}

	unsigned int temp_len = signal.size();

	if ((temp_len % 2) != 0) {
		double temp = signal[temp_len - 1];
		signal.push_back(temp);
	}

	int len_lpfilt = lpd.size();
	int len_hpfilt = hpd.size();
	int len_avg = (len_lpfilt + len_hpfilt) / 2;

	// cout << len_lpfilt << "Filter" << endl;
	per_ext(signal, len_avg / 2); // Periodic Extension
								  // computations designed to deal with boundary distortions

								  // Low Pass Filtering Operations in the Analysis Filter Bank Section
								  //		int len_cA =(int)  floor(double (len_sig + len_lpfilt -1) / double (2));
	std::vector<double> cA_undec;
	// convolving signal with lpd, Low Pass Filter, and O/P is stored in cA_undec
	convfftm(signal, lpd, cA_undec);
	int D = 2; // Downsampling Factor is 2

			   // Downsampling by 2 gives cA
	downsamp(cA_undec, D, sigop);

	sigop.erase(sigop.begin(), sigop.begin() + len_avg / 2);
	sigop.erase(sigop.end() - len_avg / 2, sigop.end());


	return 0;

}

void* idwt2(std::string name, std::vector<std::vector<double> > &signal, std::vector<std::vector<double> >  &cLL,
	std::vector<std::vector<double> >  &cLH, std::vector<std::vector<double> >  &cHL, std::vector<std::vector<double> > &cHH) {
	// Synthesis
	int rows = cLL.size();
	int cols = cLL[0].size();
	int rows_n = 2 * rows;
	// Row Upsampling and Column Filtering at the first LP Stage
	std::vector<std::vector<double> > cL(rows_n, std::vector<double>(cols));
	std::vector<std::vector<double> > cH(rows_n, std::vector<double>(cols));

	for (int j = 0; j < cols; j++) {

		std::vector<double> sigLL;
		std::vector<double> sigLH;
		for (int i = 0;i < rows;i++) {

			double temp1 = cLL[i][j];
			double temp2 = cLH[i][j];
			sigLL.push_back(temp1);
			sigLH.push_back(temp2);
		}
		std::vector<double> oup;

		branch_lp_hp_up(name, sigLL, sigLH, oup);
		sigLL.clear();
		sigLH.clear();
		for (int i = 0;i < (int)oup.size();i++) {
			cL[i][j] = oup[i];
		}

	}

	for (int j = 0; j < cols; j++) {
		std::vector<double> sigHL;
		std::vector<double> sigHH;
		for (int i = 0;i < rows;i++) {
			double temp3 = cHL[i][j];
			double temp4 = cHH[i][j];
			sigHL.push_back(temp3);
			sigHH.push_back(temp4);
		}
		std::vector<double> oup2;
		branch_lp_hp_up(name, sigHL, sigHH, oup2);
		sigHL.clear();
		sigHH.clear();

		for (int i = 0;i < (int)oup2.size();i++) {
			cH[i][j] = oup2[i];
		}

	}

	for (int i = 0; i < rows_n; i++) {
		std::vector<double> sigL;
		std::vector<double> sigH;
		for (int j = 0;j < cols;j++) {
			double temp5 = cL[i][j];\
				double temp6 = cH[i][j];
			sigL.push_back(temp5);
			sigH.push_back(temp6);
		}
		std::vector<double> oup3;
		branch_lp_hp_up(name, sigL, sigH, oup3);
		sigL.clear();
		sigH.clear();

		for (int j = 0;j < (int)oup3.size();j++) {
			signal[i][j] = oup3[j];
		}

	}
	return 0;
}

void* dwt2(std::string name, std::vector<std::vector<double> > &signal, std::vector<std::vector<double> >  &cLL,
	std::vector<std::vector<double> >  &cLH, std::vector<std::vector<double> >  &cHL, std::vector<std::vector<double> > &cHH) {
	//Analysis
	int rows = signal.size();
	int cols = signal[0].size();
	int cols_lp1 = cLL[0].size();
	int cols_hp1 = cLL[0].size();
	std::vector<double> lp1, hp1, lp2, hp2;
	filtcoef(name, lp1, hp1, lp2, hp2);
	std::vector<std::vector<double> > lp_dn1(rows, std::vector<double>(cols_lp1));
	std::vector<std::vector<double> > hp_dn1(rows, std::vector<double>(cols_hp1));

	// Implementing row filtering and column downsampling in each branch.
	for (int i = 0; i < rows; i++) {
		std::vector<double> temp_row, oup_lp, oup_hp;
		for (int j = 0;j < cols;j++) {
			double temp = signal[i][j];
			temp_row.push_back(temp);
		}
		dwt1_m(name, temp_row, oup_lp, oup_hp);

		for (int j = 0;j < (int)oup_lp.size();j++) {
			lp_dn1[i][j] = oup_lp[j];
			hp_dn1[i][j] = oup_hp[j];

		}

	}


	cols = cols_lp1;
	// Implementing column filtering and row downsampling in Low Pass branch.

	for (int j = 0; j < cols; j++) {
		std::vector<double> temp_row3, oup_lp, oup_hp;
		for (int i = 0;i < rows;i++) {
			double temp = lp_dn1[i][j];
			temp_row3.push_back(temp);
		}
		dwt1_m(name, temp_row3, oup_lp, oup_hp);

		for (int i = 0;i < (int)oup_lp.size();i++) {
			cLL[i][j] = oup_lp[i];
			cLH[i][j] = oup_hp[i];

		}


	}



	// Implementing column filtering and row downsampling in High Pass branch.

	for (int j = 0; j < cols; j++) {
		std::vector<double> temp_row5, oup_lp, oup_hp;
		for (int i = 0;i < rows;i++) {
			double temp = hp_dn1[i][j];
			temp_row5.push_back(temp);
		}
		dwt1_m(name, temp_row5, oup_lp, oup_hp);

		for (int i = 0;i < (int)oup_lp.size();i++) {
			cHL[i][j] = oup_lp[i];
			cHH[i][j] = oup_hp[i];

		}


	}
	return 0;
}


void* downsamp2(std::vector<std::vector<double> > & vec1, std::vector<std::vector<double> > & vec2, int rows_dn, int cols_dn) {

	int rows = vec1.size();
	int cols = vec1[0].size();
	double rows_n = ceil((double)rows / (double)rows_dn);
	double cols_n = ceil((double)cols / (double)cols_dn);
	for (int i = 0; i < (int)rows_n; i++) {
		for (int j = 0; j< (int)cols_n; j++) {

			vec2[i][j] = vec1[i * rows_dn][j*cols_dn];
		}
	}

	return 0;
}

void* upsamp2(std::vector<std::vector<double> > & vec1, std::vector<std::vector<double> > & vec2, int rows_up, int cols_up) {

	int rows = vec1.size();
	int cols = vec1[0].size();
	int rows_n = rows * rows_up;
	int cols_n = cols * cols_up;
	for (int i = 0; i < rows_n; i++) {
		for (int j = 0; j < cols_n; j++) {
			if (i % rows_up == 0 && j % cols_up == 0) {
				vec2[i][j] = vec1[(int)(i / rows_up)][(int)(j / cols_up)];
			}
			else {
				vec2[i][j] = 0;
			}
		}
	}
	return 0;
}


int filtcoef(std::string name, std::vector<double> &lp1, std::vector<double> &hp1, std::vector<double> &lp2,
	std::vector<double> &hp2) {
	if (name == "haar" || name == "db1") {
		lp1.push_back(0.7071);lp1.push_back(0.7071);
		hp1.push_back(-0.7071);hp1.push_back(0.7071);
		lp2.push_back(0.7071);lp2.push_back(0.7071);
		hp2.push_back(0.7071);hp2.push_back(-0.7071);
		//  	cout << lp2[1] << endl;
		//    	hpd = {-0.7071, 0.7071};
		//    	lpr = {0.7071, 0.7071};
		//    	hpr = {0.7071, -0.7071};
		return 0;
	}
	else if (name == "db2") {
		double lp1_a[] = { -0.12940952255092145, 0.22414386804185735, 0.83651630373746899,
			0.48296291314469025 };
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { -0.48296291314469025, 0.83651630373746899, -0.22414386804185735,
			-0.12940952255092145 };
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.48296291314469025, 0.83651630373746899, 0.22414386804185735,
			-0.12940952255092145 };
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { -0.12940952255092145, -0.22414386804185735, 0.83651630373746899,
			-0.48296291314469025 };
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}

	else if (name == "db3") {
		double lp1_a[] = { 0.035226291882100656, -0.085441273882241486, -0.13501102001039084,
			0.45987750211933132, 0.80689150931333875, 0.33267055295095688 };
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { -0.33267055295095688, 0.80689150931333875, -0.45987750211933132,
			-0.13501102001039084, 0.085441273882241486, 0.035226291882100656 };
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.33267055295095688, 0.80689150931333875, 0.45987750211933132,
			-0.13501102001039084, -0.085441273882241486, 0.035226291882100656 };
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { 0.035226291882100656, 0.085441273882241486, -0.13501102001039084,
			-0.45987750211933132, 0.80689150931333875, -0.33267055295095688 };
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}

	else if (name == "db4") {
		double lp1_a[] = { -0.010597401784997278, 0.032883011666982945, 0.030841381835986965,
			-0.18703481171888114, -0.027983769416983849, 0.63088076792959036,
			0.71484657055254153, 0.23037781330885523 };
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { -0.23037781330885523, 0.71484657055254153, -0.63088076792959036,
			-0.027983769416983849, 0.18703481171888114, 0.030841381835986965,
			-0.032883011666982945, -0.010597401784997278 };
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.23037781330885523, 0.71484657055254153, 0.63088076792959036,
			-0.027983769416983849, -0.18703481171888114, 0.030841381835986965,
			0.032883011666982945, -0.010597401784997278 };
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { -0.010597401784997278, -0.032883011666982945, 0.030841381835986965,
			0.18703481171888114, -0.027983769416983849, -0.63088076792959036,
			0.71484657055254153, -0.23037781330885523 };
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}

	else if (name == "db5") {
		double lp1_a[] = { 0.0033357252850015492, -0.012580751999015526, -0.0062414902130117052,
			0.077571493840065148, -0.03224486958502952, -0.24229488706619015,
			0.13842814590110342, 0.72430852843857441, 0.60382926979747287,
			0.16010239797412501 };
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { -0.16010239797412501, 0.60382926979747287, -0.72430852843857441,
			0.13842814590110342, 0.24229488706619015, -0.03224486958502952,
			-0.077571493840065148, -0.0062414902130117052, 0.012580751999015526,
			0.0033357252850015492 };
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.16010239797412501, 0.60382926979747287, 0.72430852843857441,
			0.13842814590110342, -0.24229488706619015, -0.03224486958502952,
			0.077571493840065148, -0.0062414902130117052, -0.012580751999015526,
			0.0033357252850015492 };
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { 0.0033357252850015492, 0.012580751999015526, -0.0062414902130117052,
			-0.077571493840065148, -0.03224486958502952, 0.24229488706619015,
			0.13842814590110342, -0.72430852843857441, 0.60382926979747287,
			-0.16010239797412501 };
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}

	else if (name == "db6") {
		double lp1_a[] = { -0.0010773010849955799,
			0.0047772575110106514,
			0.0005538422009938016,
			-0.031582039318031156,
			0.027522865530016288,
			0.097501605587079362,
			-0.12976686756709563,
			-0.22626469396516913,
			0.3152503517092432,
			0.75113390802157753,
			0.49462389039838539,
			0.11154074335008017
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { -0.11154074335008017,
			0.49462389039838539,
			-0.75113390802157753,
			0.3152503517092432,
			0.22626469396516913,
			-0.12976686756709563,
			-0.097501605587079362,
			0.027522865530016288,
			0.031582039318031156,
			0.0005538422009938016,
			-0.0047772575110106514,
			-0.0010773010849955799
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.11154074335008017,
			0.49462389039838539,
			0.75113390802157753,
			0.3152503517092432,
			-0.22626469396516913,
			-0.12976686756709563,
			0.097501605587079362,
			0.027522865530016288,
			-0.031582039318031156,
			0.0005538422009938016,
			0.0047772575110106514,
			-0.0010773010849955799
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { -0.0010773010849955799,
			-0.0047772575110106514,
			0.0005538422009938016,
			0.031582039318031156,
			0.027522865530016288,
			-0.097501605587079362,
			-0.12976686756709563,
			0.22626469396516913,
			0.3152503517092432,
			-0.75113390802157753,
			0.49462389039838539,
			-0.11154074335008017
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}

	else if (name == "db7") {
		double lp1_a[] = { 0.00035371380000103988,
			-0.0018016407039998328,
			0.00042957797300470274,
			0.012550998556013784,
			-0.01657454163101562,
			-0.038029936935034633,
			0.080612609151065898,
			0.071309219267050042,
			-0.22403618499416572,
			-0.14390600392910627,
			0.4697822874053586,
			0.72913209084655506,
			0.39653931948230575,
			0.077852054085062364
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { -0.077852054085062364,
			0.39653931948230575,
			-0.72913209084655506,
			0.4697822874053586,
			0.14390600392910627,
			-0.22403618499416572,
			-0.071309219267050042,
			0.080612609151065898,
			0.038029936935034633,
			-0.01657454163101562,
			-0.012550998556013784,
			0.0004295779730047027,
			0.0018016407039998328,
			0.00035371380000103988
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.077852054085062364,
			0.39653931948230575,
			0.72913209084655506,
			0.4697822874053586,
			-0.14390600392910627,
			-0.22403618499416572,
			0.071309219267050042,
			0.080612609151065898,
			-0.038029936935034633,
			-0.01657454163101562,
			0.012550998556013784,
			0.00042957797300470274,
			-0.0018016407039998328,
			0.00035371380000103988
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { 0.00035371380000103988,
			0.0018016407039998328,
			0.00042957797300470274,
			-0.01255099855601378,
			-0.01657454163101562,
			0.038029936935034633,
			0.080612609151065898,
			-0.071309219267050042,
			-0.22403618499416572,
			0.14390600392910627,
			0.4697822874053586,
			-0.72913209084655506,
			0.39653931948230575,
			-0.077852054085062364
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}

	else if (name == "db8") {
		double lp1_a[] = { -0.00011747678400228192,
			0.00067544940599855677,
			-0.00039174037299597711,
			-0.0048703529930106603,
			0.0087460940470156547,
			0.013981027917015516,
			-0.044088253931064719,
			-0.017369301002022108,
			0.12874742662018601,
			0.00047248457399797254,
			-0.28401554296242809,
			-0.015829105256023893,
			0.58535468365486909,
			0.67563073629801285,
			0.31287159091446592,
			0.054415842243081609
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { -0.054415842243081609,
			0.31287159091446592,
			-0.67563073629801285,
			0.58535468365486909,
			0.015829105256023893,
			-0.28401554296242809,
			-0.00047248457399797254,
			0.12874742662018601,
			0.017369301002022108,
			-0.044088253931064719,
			-0.013981027917015516,
			0.0087460940470156547,
			0.0048703529930106603,
			-0.00039174037299597711,
			-0.00067544940599855677,
			-0.00011747678400228192
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.054415842243081609,
			0.31287159091446592,
			0.67563073629801285,
			0.58535468365486909,
			-0.015829105256023893,
			-0.28401554296242809,
			0.00047248457399797254,
			0.12874742662018601,
			-0.017369301002022108,
			-0.044088253931064719,
			0.013981027917015516,
			0.0087460940470156547,
			-0.0048703529930106603,
			-0.00039174037299597711,
			0.00067544940599855677,
			-0.00011747678400228192
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { -0.00011747678400228192,
			-0.00067544940599855677,
			-0.00039174037299597711,
			0.0048703529930106603,
			0.0087460940470156547,
			-0.013981027917015516,
			-0.044088253931064719,
			0.017369301002022108,
			0.12874742662018601,
			-0.00047248457399797254,
			-0.28401554296242809,
			0.015829105256023893,
			0.58535468365486909,
			-0.67563073629801285,
			0.31287159091446592,
			-0.054415842243081609
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}

	else if (name == "db9") {
		double lp1_a[] = { 3.9347319995026124e-05,
			-0.00025196318899817888,
			0.00023038576399541288,
			0.0018476468829611268,
			-0.0042815036819047227,
			-0.004723204757894831,
			0.022361662123515244,
			0.00025094711499193845,
			-0.067632829059523988,
			0.030725681478322865,
			0.14854074933476008,
			-0.096840783220879037,
			-0.29327378327258685,
			0.13319738582208895,
			0.65728807803663891,
			0.6048231236767786,
			0.24383467463766728,
			0.038077947363167282
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { -0.038077947363167282,
			0.24383467463766728,
			-0.6048231236767786,
			0.65728807803663891,
			-0.13319738582208895,
			-0.29327378327258685,
			0.096840783220879037,
			0.14854074933476008,
			-0.030725681478322865,
			-0.067632829059523988,
			-0.00025094711499193845,
			0.022361662123515244,
			0.004723204757894831,
			-0.0042815036819047227,
			-0.0018476468829611268,
			0.00023038576399541288,
			0.00025196318899817888,
			3.9347319995026124e-05
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.038077947363167282,
			0.24383467463766728,
			0.6048231236767786,
			0.65728807803663891,
			0.13319738582208895,
			-0.29327378327258685,
			-0.096840783220879037,
			0.14854074933476008,
			0.030725681478322865,
			-0.067632829059523988,
			0.00025094711499193845,
			0.022361662123515244,
			-0.004723204757894831,
			-0.0042815036819047227,
			0.0018476468829611268,
			0.00023038576399541288,
			-0.00025196318899817888,
			3.9347319995026124e-05
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { 3.9347319995026124e-05,
			0.00025196318899817888,
			0.00023038576399541288,
			-0.0018476468829611268,
			-0.0042815036819047227,
			0.004723204757894831,
			0.022361662123515244,
			-0.00025094711499193845,
			-0.067632829059523988,
			-0.030725681478322865,
			0.14854074933476008,
			0.096840783220879037,
			-0.29327378327258685,
			-0.13319738582208895,
			0.65728807803663891,
			-0.6048231236767786,
			0.24383467463766728,
			-0.038077947363167282
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}

	else if (name == "db10") {
		double lp1_a[] = { -1.3264203002354869e-05,
			9.3588670001089845e-05,
			-0.0001164668549943862,
			-0.00068585669500468248,
			0.0019924052949908499,
			0.0013953517469940798,
			-0.010733175482979604,
			0.0036065535669883944,
			0.033212674058933238,
			-0.029457536821945671,
			-0.071394147165860775,
			0.093057364603806592,
			0.12736934033574265,
			-0.19594627437659665,
			-0.24984642432648865,
			0.28117234366042648,
			0.68845903945259213,
			0.52720118893091983,
			0.18817680007762133,
			0.026670057900950818
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { -0.026670057900950818,
			0.18817680007762133,
			-0.52720118893091983,
			0.68845903945259213,
			-0.28117234366042648,
			-0.24984642432648865,
			0.19594627437659665,
			0.12736934033574265,
			-0.093057364603806592,
			-0.071394147165860775,
			0.029457536821945671,
			0.033212674058933238,
			-0.0036065535669883944,
			-0.010733175482979604,
			-0.0013953517469940798,
			0.0019924052949908499,
			0.00068585669500468248,
			-0.0001164668549943862,
			-9.3588670001089845e-05,
			-1.3264203002354869e-05
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.026670057900950818,
			0.18817680007762133,
			0.52720118893091983,
			0.68845903945259213,
			0.28117234366042648,
			-0.24984642432648865,
			-0.19594627437659665,
			0.12736934033574265,
			0.093057364603806592,
			-0.071394147165860775,
			-0.029457536821945671,
			0.033212674058933238,
			0.0036065535669883944,
			-0.010733175482979604,
			0.0013953517469940798,
			0.0019924052949908499,
			-0.00068585669500468248,
			-0.0001164668549943862,
			9.3588670001089845e-05,
			-1.3264203002354869e-05
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { -1.3264203002354869e-05,
			-9.3588670001089845e-05,
			-0.0001164668549943862,
			0.00068585669500468248,
			0.0019924052949908499,
			-0.0013953517469940798,
			-0.010733175482979604,
			-0.0036065535669883944,
			0.033212674058933238,
			0.029457536821945671,
			-0.071394147165860775,
			-0.093057364603806592,
			0.12736934033574265,
			0.19594627437659665,
			-0.24984642432648865,
			-0.28117234366042648,
			0.68845903945259213,
			-0.52720118893091983,
			0.18817680007762133,
			-0.026670057900950818
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}

	else if (name == "db12") {
		double lp1_a[] = { -1.5290717580684923e-06,
			1.2776952219379579e-05,
			-2.4241545757030318e-05,
			-8.8504109208203182e-05,
			0.00038865306282092672,
			6.5451282125215034e-06,
			-0.0021795036186277044,
			0.0022486072409952287,
			0.0067114990087955486,
			-0.012840825198299882,
			-0.01221864906974642,
			0.041546277495087637,
			0.010849130255828966,
			-0.09643212009649671,
			0.0053595696743599965,
			0.18247860592758275,
			-0.023779257256064865,
			-0.31617845375277914,
			-0.044763885653777619,
			0.51588647842780067,
			0.65719872257929113,
			0.37735513521420411,
			0.10956627282118277,
			0.013112257957229239
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { -0.013112257957229239,
			0.10956627282118277,
			-0.37735513521420411,
			0.65719872257929113,
			-0.51588647842780067,
			-0.044763885653777619,
			0.31617845375277914,
			-0.023779257256064865,
			-0.18247860592758275,
			0.0053595696743599965,
			0.09643212009649671,
			0.010849130255828966,
			-0.041546277495087637,
			-0.01221864906974642,
			0.012840825198299882,
			0.0067114990087955486,
			-0.0022486072409952287,
			-0.0021795036186277044,
			-6.5451282125215034e-06,
			0.00038865306282092672,
			8.8504109208203182e-05,
			-2.4241545757030318e-05,
			-1.2776952219379579e-05,
			-1.5290717580684923e-06
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.013112257957229239,
			0.10956627282118277,
			0.37735513521420411,
			0.65719872257929113,
			0.51588647842780067,
			-0.044763885653777619,
			-0.31617845375277914,
			-0.023779257256064865,
			0.18247860592758275,
			0.0053595696743599965,
			-0.09643212009649671,
			0.010849130255828966,
			0.041546277495087637,
			-0.01221864906974642,
			-0.012840825198299882,
			0.0067114990087955486,
			0.0022486072409952287,
			-0.0021795036186277044,
			6.5451282125215034e-06,
			0.00038865306282092672,
			-8.8504109208203182e-05,
			-2.4241545757030318e-05,
			1.2776952219379579e-05,
			-1.5290717580684923e-06
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { -1.5290717580684923e-06,
			-1.2776952219379579e-05,
			-2.4241545757030318e-05,
			8.8504109208203182e-05,
			0.00038865306282092672,
			-6.5451282125215034e-06,
			-0.0021795036186277044,
			-0.0022486072409952287,
			0.0067114990087955486,
			0.012840825198299882,
			-0.01221864906974642,
			-0.041546277495087637,
			0.010849130255828966,
			0.09643212009649671,
			0.0053595696743599965,
			-0.18247860592758275,
			-0.023779257256064865,
			0.31617845375277914,
			-0.044763885653777619,
			-0.51588647842780067,
			0.65719872257929113,
			-0.37735513521420411,
			0.10956627282118277,
			-0.013112257957229239
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}
	else if (name == "db13") {
		double lp1_a[] = { 5.2200350984547998e-07,
			-4.7004164793608082e-06,
			1.0441930571407941e-05,
			3.0678537579324358e-05,
			-0.00016512898855650571,
			4.9251525126285676e-05,
			0.00093232613086724904,
			-0.0013156739118922766,
			-0.002761911234656831,
			0.0072555894016171187,
			0.0039239414487955773,
			-0.023831420710327809,
			0.0023799722540522269,
			0.056139477100276156,
			-0.026488406475345658,
			-0.10580761818792761,
			0.072948933656788742,
			0.17947607942935084,
			-0.12457673075080665,
			-0.31497290771138414,
			0.086985726179645007,
			0.58888957043121193,
			0.61105585115878114,
			0.31199632216043488,
			0.082861243872901946,
			0.0092021335389622788
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { -0.0092021335389622788,
			0.082861243872901946,
			-0.31199632216043488,
			0.61105585115878114,
			-0.58888957043121193,
			0.086985726179645007,
			0.31497290771138414,
			-0.12457673075080665,
			-0.17947607942935084,
			0.072948933656788742,
			0.10580761818792761,
			-0.026488406475345658,
			-0.056139477100276156,
			0.0023799722540522269,
			0.023831420710327809,
			0.0039239414487955773,
			-0.0072555894016171187,
			-0.002761911234656831,
			0.0013156739118922766,
			0.00093232613086724904,
			-4.9251525126285676e-05,
			-0.00016512898855650571,
			-3.0678537579324358e-05,
			1.0441930571407941e-05,
			4.7004164793608082e-06,
			5.2200350984547998e-07
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.0092021335389622788,
			0.082861243872901946,
			0.31199632216043488,
			0.61105585115878114,
			0.58888957043121193,
			0.086985726179645007,
			-0.31497290771138414,
			-0.12457673075080665,
			0.17947607942935084,
			0.072948933656788742,
			-0.10580761818792761,
			-0.026488406475345658,
			0.056139477100276156,
			0.0023799722540522269,
			-0.023831420710327809,
			0.0039239414487955773,
			0.0072555894016171187,
			-0.002761911234656831,
			-0.0013156739118922766,
			0.00093232613086724904,
			4.9251525126285676e-05,
			-0.00016512898855650571,
			3.0678537579324358e-05,
			1.0441930571407941e-05,
			-4.7004164793608082e-06,
			5.2200350984547998e-07
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { 5.2200350984547998e-07,
			4.7004164793608082e-06,
			1.0441930571407941e-05,
			-3.0678537579324358e-05,
			-0.00016512898855650571,
			-4.9251525126285676e-05,
			0.00093232613086724904,
			0.0013156739118922766,
			-0.002761911234656831,
			-0.0072555894016171187,
			0.0039239414487955773,
			0.023831420710327809,
			0.0023799722540522269,
			-0.056139477100276156,
			-0.026488406475345658,
			0.10580761818792761,
			0.072948933656788742,
			-0.17947607942935084,
			-0.12457673075080665,
			0.31497290771138414,
			0.086985726179645007,
			-0.58888957043121193,
			0.61105585115878114,
			-0.31199632216043488,
			0.082861243872901946,
			-0.0092021335389622788
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}

	else if (name == "db11") {
		double lp1_a[] = { 4.4942742772363519e-06,
			-3.4634984186983789e-05,
			5.4439074699366381e-05,
			0.00024915252355281426,
			-0.00089302325066623663,
			-0.00030859285881515924,
			0.0049284176560587777,
			-0.0033408588730145018,
			-0.015364820906201324,
			0.020840904360180039,
			0.031335090219045313,
			-0.066438785695020222,
			-0.04647995511667613,
			0.14981201246638268,
			0.066043588196690886,
			-0.27423084681792875,
			-0.16227524502747828,
			0.41196436894789695,
			0.68568677491617847,
			0.44989976435603013,
			0.14406702115061959,
			0.018694297761470441
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { -0.018694297761470441,
			0.14406702115061959,
			-0.44989976435603013,
			0.68568677491617847,
			-0.41196436894789695,
			-0.16227524502747828,
			0.27423084681792875,
			0.066043588196690886,
			-0.14981201246638268,
			-0.04647995511667613,
			0.066438785695020222,
			0.031335090219045313,
			-0.020840904360180039,
			-0.015364820906201324,
			0.0033408588730145018,
			0.0049284176560587777,
			0.00030859285881515924,
			-0.00089302325066623663,
			-0.00024915252355281426,
			5.4439074699366381e-05,
			3.4634984186983789e-05,
			4.4942742772363519e-06
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.018694297761470441,
			0.14406702115061959,
			0.44989976435603013,
			0.68568677491617847,
			0.41196436894789695,
			-0.16227524502747828,
			-0.27423084681792875,
			0.066043588196690886,
			0.14981201246638268,
			-0.04647995511667613,
			-0.066438785695020222,
			0.031335090219045313,
			0.020840904360180039,
			-0.015364820906201324,
			-0.0033408588730145018,
			0.0049284176560587777,
			-0.00030859285881515924,
			-0.00089302325066623663,
			0.00024915252355281426,
			5.4439074699366381e-05,
			-3.4634984186983789e-05,
			4.4942742772363519e-06
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { 4.4942742772363519e-06,
			3.4634984186983789e-05,
			5.4439074699366381e-05,
			-0.00024915252355281426,
			-0.00089302325066623663,
			0.00030859285881515924,
			0.0049284176560587777,
			0.0033408588730145018,
			-0.015364820906201324,
			-0.020840904360180039,
			0.031335090219045313,
			0.066438785695020222,
			-0.04647995511667613,
			-0.14981201246638268,
			0.066043588196690886,
			0.27423084681792875,
			-0.16227524502747828,
			-0.41196436894789695,
			0.68568677491617847,
			-0.44989976435603013,
			0.14406702115061959,
			-0.018694297761470441
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}

	else if (name == "db14") {
		double lp1_a[] = { -1.7871399683109222e-07,
			1.7249946753674012e-06,
			-4.3897049017804176e-06,
			-1.0337209184568496e-05,
			6.875504252695734e-05,
			-4.1777245770370672e-05,
			-0.00038683194731287514,
			0.00070802115423540481,
			0.001061691085606874,
			-0.003849638868019787,
			-0.00074621898926387534,
			0.012789493266340071,
			-0.0056150495303375755,
			-0.030185351540353976,
			0.026981408307947971,
			0.05523712625925082,
			-0.071548955503983505,
			-0.086748411568110598,
			0.13998901658445695,
			0.13839521386479153,
			-0.21803352999321651,
			-0.27168855227867705,
			0.21867068775886594,
			0.63118784910471981,
			0.55430561794077093,
			0.25485026779256437,
			0.062364758849384874,
			0.0064611534600864905
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { -0.0064611534600864905,
			0.062364758849384874,
			-0.25485026779256437,
			0.55430561794077093,
			-0.63118784910471981,
			0.21867068775886594,
			0.27168855227867705,
			-0.21803352999321651,
			-0.13839521386479153,
			0.13998901658445695,
			0.086748411568110598,
			-0.071548955503983505,
			-0.05523712625925082,
			0.026981408307947971,
			0.030185351540353976,
			-0.0056150495303375755,
			-0.012789493266340071,
			-0.00074621898926387534,
			0.003849638868019787,
			0.001061691085606874,
			-0.00070802115423540481,
			-0.00038683194731287514,
			4.1777245770370672e-05,
			6.875504252695734e-05,
			1.0337209184568496e-05,
			-4.3897049017804176e-06,
			-1.7249946753674012e-06,
			-1.7871399683109222e-07
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.0064611534600864905,
			0.062364758849384874,
			0.25485026779256437,
			0.55430561794077093,
			0.63118784910471981,
			0.21867068775886594,
			-0.27168855227867705,
			-0.21803352999321651,
			0.13839521386479153,
			0.13998901658445695,
			-0.086748411568110598,
			-0.071548955503983505,
			0.05523712625925082,
			0.026981408307947971,
			-0.030185351540353976,
			-0.0056150495303375755,
			0.012789493266340071,
			-0.00074621898926387534,
			-0.003849638868019787,
			0.001061691085606874,
			0.00070802115423540481,
			-0.00038683194731287514,
			-4.1777245770370672e-05,
			6.875504252695734e-05,
			-1.0337209184568496e-05,
			-4.3897049017804176e-06,
			1.7249946753674012e-06,
			-1.7871399683109222e-07
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { -1.7871399683109222e-07,
			-1.7249946753674012e-06,
			-4.3897049017804176e-06,
			1.0337209184568496e-05,
			6.875504252695734e-05,
			4.1777245770370672e-05,
			-0.00038683194731287514,
			-0.00070802115423540481,
			0.001061691085606874,
			0.003849638868019787,
			-0.00074621898926387534,
			-0.012789493266340071,
			-0.0056150495303375755,
			0.030185351540353976,
			0.026981408307947971,
			-0.05523712625925082,
			-0.071548955503983505,
			0.086748411568110598,
			0.13998901658445695,
			-0.13839521386479153,
			-0.21803352999321651,
			0.27168855227867705,
			0.21867068775886594,
			-0.63118784910471981,
			0.55430561794077093,
			-0.25485026779256437,
			0.062364758849384874,
			-0.0064611534600864905
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}
	else if (name == "db15") {
		double lp1_a[] = { 6.1333599133037138e-08,
			-6.3168823258794506e-07,
			1.8112704079399406e-06,
			3.3629871817363823e-06,
			-2.8133296266037558e-05,
			2.579269915531323e-05,
			0.00015589648992055726,
			-0.00035956524436229364,
			-0.00037348235413726472,
			0.0019433239803823459,
			-0.00024175649075894543,
			-0.0064877345603061454,
			0.0051010003604228726,
			0.015083918027862582,
			-0.020810050169636805,
			-0.025767007328366939,
			0.054780550584559995,
			0.033877143923563204,
			-0.11112093603713753,
			-0.039666176555733602,
			0.19014671400708816,
			0.065282952848765688,
			-0.28888259656686216,
			-0.19320413960907623,
			0.33900253545462167,
			0.64581314035721027,
			0.49263177170797529,
			0.20602386398692688,
			0.046743394892750617,
			0.0045385373615773762
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { -0.0045385373615773762,
			0.046743394892750617,
			-0.20602386398692688,
			0.49263177170797529,
			-0.64581314035721027,
			0.33900253545462167,
			0.19320413960907623,
			-0.28888259656686216,
			-0.065282952848765688,
			0.19014671400708816,
			0.039666176555733602,
			-0.11112093603713753,
			-0.033877143923563204,
			0.054780550584559995,
			0.025767007328366939,
			-0.020810050169636805,
			-0.015083918027862582,
			0.0051010003604228726,
			0.0064877345603061454,
			-0.00024175649075894543,
			-0.0019433239803823459,
			-0.00037348235413726472,
			0.00035956524436229364,
			0.00015589648992055726,
			-2.579269915531323e-05,
			-2.8133296266037558e-05,
			-3.3629871817363823e-06,
			1.8112704079399406e-06,
			6.3168823258794506e-07,
			6.1333599133037138e-08
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.0045385373615773762,
			0.046743394892750617,
			0.20602386398692688,
			0.49263177170797529,
			0.64581314035721027,
			0.33900253545462167,
			-0.19320413960907623,
			-0.28888259656686216,
			0.065282952848765688,
			0.19014671400708816,
			-0.039666176555733602,
			-0.11112093603713753,
			0.033877143923563204,
			0.054780550584559995,
			-0.025767007328366939,
			-0.020810050169636805,
			0.015083918027862582,
			0.0051010003604228726,
			-0.0064877345603061454,
			-0.00024175649075894543,
			0.0019433239803823459,
			-0.00037348235413726472,
			-0.00035956524436229364,
			0.00015589648992055726,
			2.579269915531323e-05,
			-2.8133296266037558e-05,
			3.3629871817363823e-06,
			1.8112704079399406e-06,
			-6.3168823258794506e-07,
			6.1333599133037138e-08
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { 6.1333599133037138e-08,
			6.3168823258794506e-07,
			1.8112704079399406e-06,
			-3.3629871817363823e-06,
			-2.8133296266037558e-05,
			-2.579269915531323e-05,
			0.00015589648992055726,
			0.00035956524436229364,
			-0.00037348235413726472,
			-0.0019433239803823459,
			-0.00024175649075894543,
			0.0064877345603061454,
			0.0051010003604228726,
			-0.015083918027862582,
			-0.020810050169636805,
			0.025767007328366939,
			0.054780550584559995,
			-0.033877143923563204,
			-0.11112093603713753,
			0.039666176555733602,
			0.19014671400708816,
			-0.065282952848765688,
			-0.28888259656686216,
			0.19320413960907623,
			0.33900253545462167,
			-0.64581314035721027,
			0.49263177170797529,
			-0.20602386398692688,
			0.046743394892750617,
			-0.0045385373615773762
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}
	else if (name == "bior1.1") {
		double lp1_a[] = { 0.70710678118654757,
			0.70710678118654757
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { -0.70710678118654757,
			0.70710678118654757
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.70710678118654757,
			0.70710678118654757
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { 0.70710678118654757,
			-0.70710678118654757
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}

	else if (name == "bior1.3") {
		double lp1_a[] = { -0.088388347648318447,
			0.088388347648318447,
			0.70710678118654757,
			0.70710678118654757,
			0.088388347648318447,
			-0.088388347648318447,
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { 0.0,
			0.0,
			-0.70710678118654757,
			0.70710678118654757,
			0.0,
			0.0
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.0,
			0.0,
			0.70710678118654757,
			0.70710678118654757,
			0.0,
			0.0
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { -0.088388347648318447,
			-0.088388347648318447,
			0.70710678118654757,
			-0.70710678118654757,
			0.088388347648318447,
			0.088388347648318447
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}

	else if (name == "bior1.5") {
		double lp1_a[] = { 0.01657281518405971,
			-0.01657281518405971,
			-0.12153397801643787,
			0.12153397801643787,
			0.70710678118654757,
			0.70710678118654757,
			0.12153397801643787,
			-0.12153397801643787,
			-0.01657281518405971,
			0.01657281518405971
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { 0.0,
			0.0,
			0.0,
			0.0,
			-0.70710678118654757,
			0.70710678118654757,
			0.0,
			0.0,
			0.0,
			0.0
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.0,
			0.0,
			0.0,
			0.0,
			0.70710678118654757,
			0.70710678118654757,
			0.0,
			0.0,
			0.0,
			0.0
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { 0.01657281518405971,
			0.01657281518405971,
			-0.12153397801643787,
			-0.12153397801643787,
			0.70710678118654757,
			-0.70710678118654757,
			0.12153397801643787,
			0.12153397801643787,
			-0.01657281518405971,
			-0.01657281518405971
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}

	else if (name == "bior2.2") {
		double lp1_a[] = { 0.0,
			-0.17677669529663689,
			0.35355339059327379,
			1.0606601717798214,
			0.35355339059327379,
			-0.17677669529663689
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { 0.0,
			0.35355339059327379,
			-0.70710678118654757,
			0.35355339059327379,
			0.0,
			0.0
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.0,
			0.35355339059327379,
			0.70710678118654757,
			0.35355339059327379,
			0.0,
			0.0
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { 0.0,
			0.17677669529663689,
			0.35355339059327379,
			-1.0606601717798214,
			0.35355339059327379,
			0.17677669529663689

		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}

	else if (name == "bior2.4") {
		double lp1_a[] = { 0.0,
			0.033145630368119419,
			-0.066291260736238838,
			-0.17677669529663689,
			0.4198446513295126,
			0.99436891104358249,
			0.4198446513295126,
			-0.17677669529663689,
			-0.066291260736238838,
			0.033145630368119419
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { 0.0,
			0.0,
			0.0,
			0.35355339059327379,
			-0.70710678118654757,
			0.35355339059327379,
			0.0,
			0.0,
			0.0,
			0.0

		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.0,
			0.0,
			0.0,
			0.35355339059327379,
			0.70710678118654757,
			0.35355339059327379,
			0.0,
			0.0,
			0.0,
			0.0

		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { 0.0,
			-0.033145630368119419,
			-0.066291260736238838,
			0.17677669529663689,
			0.4198446513295126,
			-0.99436891104358249,
			0.4198446513295126,
			0.17677669529663689,
			-0.066291260736238838,
			-0.033145630368119419
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}

	else if (name == "bior2.6") {
		double lp1_a[] = { 0.0,
			-0.0069053396600248784,
			0.013810679320049757,
			0.046956309688169176,
			-0.10772329869638811,
			-0.16987135563661201,
			0.44746600996961211,
			0.96674755240348298,
			0.44746600996961211,
			-0.16987135563661201,
			-0.10772329869638811,
			0.046956309688169176,
			0.013810679320049757,
			-0.0069053396600248784
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { 0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			0.35355339059327379,
			-0.70710678118654757,
			0.35355339059327379,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			0.35355339059327379,
			0.70710678118654757,
			0.35355339059327379,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { 0.0,
			0.0069053396600248784,
			0.013810679320049757,
			-0.046956309688169176,
			-0.10772329869638811,
			0.16987135563661201,
			0.44746600996961211,
			-0.96674755240348298,
			0.44746600996961211,
			0.16987135563661201,
			-0.10772329869638811,
			-0.046956309688169176,
			0.013810679320049757,
			0.0069053396600248784
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}
	else if (name == "bior2.8") {
		double lp1_a[] = { 0.0,
			0.0015105430506304422,
			-0.0030210861012608843,
			-0.012947511862546647,
			0.028916109826354178,
			0.052998481890690945,
			-0.13491307360773608,
			-0.16382918343409025,
			0.46257144047591658,
			0.95164212189717856,
			0.46257144047591658,
			-0.16382918343409025,
			-0.13491307360773608,
			0.052998481890690945,
			0.028916109826354178,
			-0.012947511862546647,
			-0.0030210861012608843,
			0.0015105430506304422
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { 0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			0.35355339059327379,
			-0.70710678118654757,
			0.35355339059327379,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			0.35355339059327379,
			0.70710678118654757,
			0.35355339059327379,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { 0.0,
			-0.0015105430506304422,
			-0.0030210861012608843,
			0.012947511862546647,
			0.028916109826354178,
			-0.052998481890690945,
			-0.13491307360773608,
			0.16382918343409025,
			0.46257144047591658,
			-0.95164212189717856,
			0.46257144047591658,
			0.16382918343409025,
			-0.13491307360773608,
			-0.052998481890690945,
			0.028916109826354178,
			0.012947511862546647,
			-0.0030210861012608843,
			-0.0015105430506304422
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}

	else if (name == "bior3.1") {
		double lp1_a[] = { -0.35355339059327379,
			1.0606601717798214,
			1.0606601717798214,
			-0.35355339059327379
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { -0.17677669529663689,
			0.53033008588991071,
			-0.53033008588991071,
			0.17677669529663689
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.17677669529663689,
			0.53033008588991071,
			0.53033008588991071,
			0.17677669529663689
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { -0.35355339059327379,
			-1.0606601717798214,
			1.0606601717798214,
			0.35355339059327379
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}
	else if (name == "bior3.3") {
		double lp1_a[] = { 0.066291260736238838,
			-0.19887378220871652,
			-0.15467960838455727,
			0.99436891104358249,
			0.99436891104358249,
			-0.15467960838455727,
			-0.19887378220871652,
			0.066291260736238838
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { 0.0,
			0.0,
			-0.17677669529663689,
			0.53033008588991071,
			-0.53033008588991071,
			0.17677669529663689,
			0.0,
			0.0
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.0,
			0.0,
			0.17677669529663689,
			0.53033008588991071,
			0.53033008588991071,
			0.17677669529663689,
			0.0,
			0.0
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { 0.066291260736238838,
			0.19887378220871652,
			-0.15467960838455727,
			-0.99436891104358249,
			0.99436891104358249,
			0.15467960838455727,
			-0.19887378220871652,
			-0.066291260736238838
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}
	else if (name == "bior3.5") {
		double lp1_a[] = { -0.013810679320049757,
			0.041432037960149271,
			0.052480581416189075,
			-0.26792717880896527,
			-0.071815532464258744,
			0.96674755240348298,
			0.96674755240348298,
			-0.071815532464258744,
			-0.26792717880896527,
			0.052480581416189075,
			0.041432037960149271,
			-0.013810679320049757
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { 0.0,
			0.0,
			0.0,
			0.0,
			-0.17677669529663689,
			0.53033008588991071,
			-0.53033008588991071,
			0.17677669529663689,
			0.0,
			0.0,
			0.0,
			0.0
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.0,
			0.0,
			0.0,
			0.0,
			0.17677669529663689,
			0.53033008588991071,
			0.53033008588991071,
			0.17677669529663689,
			0.0,
			0.0,
			0.0,
			0.0
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { -0.013810679320049757,
			-0.041432037960149271,
			0.052480581416189075,
			0.26792717880896527,
			-0.071815532464258744,
			-0.96674755240348298,
			0.96674755240348298,
			0.071815532464258744,
			-0.26792717880896527,
			-0.052480581416189075,
			0.041432037960149271,
			0.013810679320049757
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}

	else if (name == "bior3.7") {
		double lp1_a[] = { 0.0030210861012608843,
			-0.0090632583037826529,
			-0.016831765421310641,
			0.074663985074019001,
			0.031332978707362888,
			-0.301159125922835,
			-0.026499240945345472,
			0.95164212189717856,
			0.95164212189717856,
			-0.026499240945345472,
			-0.301159125922835,
			0.031332978707362888,
			0.074663985074019001,
			-0.016831765421310641,
			-0.0090632583037826529,
			0.0030210861012608843
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { 0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			-0.17677669529663689,
			0.53033008588991071,
			-0.53033008588991071,
			0.17677669529663689,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			0.17677669529663689,
			0.53033008588991071,
			0.53033008588991071,
			0.17677669529663689,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { 0.0030210861012608843,
			0.0090632583037826529,
			-0.016831765421310641,
			-0.074663985074019001,
			0.031332978707362888,
			0.301159125922835,
			-0.026499240945345472,
			-0.95164212189717856,
			0.95164212189717856,
			0.026499240945345472,
			-0.301159125922835,
			-0.031332978707362888,
			0.074663985074019001,
			0.016831765421310641,
			-0.0090632583037826529,
			-0.0030210861012608843
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}
	else if (name == "bior3.9") {
		double lp1_a[] = { -0.00067974437278369901,
			0.0020392331183510968,
			0.0050603192196119811,
			-0.020618912641105536,
			-0.014112787930175846,
			0.09913478249423216,
			0.012300136269419315,
			-0.32019196836077857,
			0.0020500227115698858,
			0.94212570067820678,
			0.94212570067820678,
			0.0020500227115698858,
			-0.32019196836077857,
			0.012300136269419315,
			0.09913478249423216,
			-0.014112787930175846,
			-0.020618912641105536,
			0.0050603192196119811,
			0.0020392331183510968,
			-0.00067974437278369901
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { 0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			-0.17677669529663689,
			0.53033008588991071,
			-0.53033008588991071,
			0.17677669529663689,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			0.17677669529663689,
			0.53033008588991071,
			0.53033008588991071,
			0.17677669529663689,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0,
			0.0
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { -0.00067974437278369901,
			-0.0020392331183510968,
			0.0050603192196119811,
			0.020618912641105536,
			-0.014112787930175846,
			-0.09913478249423216,
			0.012300136269419315,
			0.32019196836077857,
			0.0020500227115698858,
			-0.94212570067820678,
			0.94212570067820678,
			-0.0020500227115698858,
			-0.32019196836077857,
			-0.012300136269419315,
			0.09913478249423216,
			0.014112787930175846,
			-0.020618912641105536,
			-0.0050603192196119811,
			0.0020392331183510968,
			0.00067974437278369901
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}
	else if (name == "bior4.4") {
		double lp1_a[] = { 0.0,
			0.03782845550726404,
			-0.023849465019556843,
			-0.11062440441843718,
			0.37740285561283066,
			0.85269867900889385,
			0.37740285561283066,
			-0.11062440441843718,
			-0.023849465019556843,
			0.03782845550726404
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { 0.0,
			-0.064538882628697058,
			0.040689417609164058,
			0.41809227322161724,
			-0.7884856164055829,
			0.41809227322161724,
			0.040689417609164058,
			-0.064538882628697058,
			0.0,
			0.0
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.0,
			-0.064538882628697058,
			-0.040689417609164058,
			0.41809227322161724,
			0.7884856164055829,
			0.41809227322161724,
			-0.040689417609164058,
			-0.064538882628697058,
			0.0,
			0.0
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { 0.0,
			-0.03782845550726404,
			-0.023849465019556843,
			0.11062440441843718,
			0.37740285561283066,
			-0.85269867900889385,
			0.37740285561283066,
			0.11062440441843718,
			-0.023849465019556843,
			-0.03782845550726404
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}
	else if (name == "bior5.5") {
		double lp1_a[] = { 0.0,
			0.0,
			0.03968708834740544,
			0.0079481086372403219,
			-0.054463788468236907,
			0.34560528195603346,
			0.73666018142821055,
			0.34560528195603346,
			-0.054463788468236907,
			0.0079481086372403219,
			0.03968708834740544,
			0.0
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { -0.013456709459118716,
			-0.0026949668801115071,
			0.13670658466432914,
			-0.093504697400938863,
			-0.47680326579848425,
			0.89950610974864842,
			-0.47680326579848425,
			-0.093504697400938863,
			0.13670658466432914,
			-0.0026949668801115071,
			-0.013456709459118716,
			0.0
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.013456709459118716,
			-0.0026949668801115071,
			-0.13670658466432914,
			-0.093504697400938863,
			0.47680326579848425,
			0.89950610974864842,
			0.47680326579848425,
			-0.093504697400938863,
			-0.13670658466432914,
			-0.0026949668801115071,
			0.013456709459118716,
			0.0
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { 0.0,
			0.0,
			0.03968708834740544,
			-0.0079481086372403219,
			-0.054463788468236907,
			-0.34560528195603346,
			0.73666018142821055,
			-0.34560528195603346,
			-0.054463788468236907,
			-0.0079481086372403219,
			0.03968708834740544,
			0.0
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}
	else if (name == "bior6.8") {
		double lp1_a[] = { 0.0,
			0.0019088317364812906,
			-0.0019142861290887667,
			-0.016990639867602342,
			0.01193456527972926,
			0.04973290349094079,
			-0.077263173167204144,
			-0.09405920349573646,
			0.42079628460982682,
			0.82592299745840225,
			0.42079628460982682,
			-0.09405920349573646,
			-0.077263173167204144,
			0.04973290349094079,
			0.01193456527972926,
			-0.016990639867602342,
			-0.0019142861290887667,
			0.0019088317364812906
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { 0.0,
			0.0,
			0.0,
			0.014426282505624435,
			-0.014467504896790148,
			-0.078722001062628819,
			0.040367979030339923,
			0.41784910915027457,
			-0.75890772945365415,
			0.41784910915027457,
			0.040367979030339923,
			-0.078722001062628819,
			-0.014467504896790148,
			0.014426282505624435,
			0.0,
			0.0,
			0.0,
			0.0
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.0,
			0.0,
			0.0,
			0.014426282505624435,
			0.014467504896790148,
			-0.078722001062628819,
			-0.040367979030339923,
			0.41784910915027457,
			0.75890772945365415,
			0.41784910915027457,
			-0.040367979030339923,
			-0.078722001062628819,
			0.014467504896790148,
			0.014426282505624435,
			0.0,
			0.0,
			0.0,
			0.0
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { 0.0,
			-0.0019088317364812906,
			-0.0019142861290887667,
			0.016990639867602342,
			0.01193456527972926,
			-0.04973290349094079,
			-0.077263173167204144,
			0.09405920349573646,
			0.42079628460982682,
			-0.82592299745840225,
			0.42079628460982682,
			0.09405920349573646,
			-0.077263173167204144,
			-0.04973290349094079,
			0.01193456527972926,
			0.016990639867602342,
			-0.0019142861290887667,
			-0.0019088317364812906
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}

	else if (name == "coif1") {
		double lp1_a[] = { -0.01565572813546454,
			-0.072732619512853897,
			0.38486484686420286,
			0.85257202021225542,
			0.33789766245780922,
			-0.072732619512853897
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { 0.072732619512853897,
			0.33789766245780922,
			-0.85257202021225542,
			0.38486484686420286,
			0.072732619512853897,
			-0.01565572813546454
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { -0.072732619512853897,
			0.33789766245780922,
			0.85257202021225542,
			0.38486484686420286,
			-0.072732619512853897,
			-0.01565572813546454
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { -0.01565572813546454,
			0.072732619512853897,
			0.38486484686420286,
			-0.85257202021225542,
			0.33789766245780922,
			0.072732619512853897
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}
	else if (name == "coif2") {
		double lp1_a[] = { -0.00072054944536451221,
			-0.0018232088707029932,
			0.0056114348193944995,
			0.023680171946334084,
			-0.059434418646456898,
			-0.076488599078306393,
			0.41700518442169254,
			0.81272363544554227,
			0.38611006682116222,
			-0.067372554721963018,
			-0.041464936781759151,
			0.016387336463522112
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { -0.016387336463522112,
			-0.041464936781759151,
			0.067372554721963018,
			0.38611006682116222,
			-0.81272363544554227,
			0.41700518442169254,
			0.076488599078306393,
			-0.059434418646456898,
			-0.023680171946334084,
			0.0056114348193944995,
			0.0018232088707029932,
			-0.00072054944536451221
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.016387336463522112,
			-0.041464936781759151,
			-0.067372554721963018,
			0.38611006682116222,
			0.81272363544554227,
			0.41700518442169254,
			-0.076488599078306393,
			-0.059434418646456898,
			0.023680171946334084,
			0.0056114348193944995,
			-0.0018232088707029932,
			-0.00072054944536451221
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { -0.00072054944536451221,
			0.0018232088707029932,
			0.0056114348193944995,
			-0.023680171946334084,
			-0.059434418646456898,
			0.076488599078306393,
			0.41700518442169254,
			-0.81272363544554227,
			0.38611006682116222,
			0.067372554721963018,
			-0.041464936781759151,
			-0.016387336463522112
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}
	else if (name == "coif3") {
		double lp1_a[] = { -3.4599772836212559e-05,
			-7.0983303138141252e-05,
			0.00046621696011288631,
			0.0011175187708906016,
			-0.0025745176887502236,
			-0.0090079761366615805,
			0.015880544863615904,
			0.034555027573061628,
			-0.082301927106885983,
			-0.071799821619312018,
			0.42848347637761874,
			0.79377722262562056,
			0.4051769024096169,
			-0.061123390002672869,
			-0.0657719112818555,
			0.023452696141836267,
			0.0077825964273254182,
			-0.0037935128644910141
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { 0.0037935128644910141,
			0.0077825964273254182,
			-0.023452696141836267,
			-0.0657719112818555,
			0.061123390002672869,
			0.4051769024096169,
			-0.79377722262562056,
			0.42848347637761874,
			0.071799821619312018,
			-0.082301927106885983,
			-0.034555027573061628,
			0.015880544863615904,
			0.0090079761366615805,
			-0.0025745176887502236,
			-0.0011175187708906016,
			0.00046621696011288631,
			7.0983303138141252e-05,
			-3.4599772836212559e-05
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { -0.0037935128644910141,
			0.0077825964273254182,
			0.023452696141836267,
			-0.0657719112818555,
			-0.061123390002672869,
			0.4051769024096169,
			0.79377722262562056,
			0.42848347637761874,
			-0.071799821619312018,
			-0.082301927106885983,
			0.034555027573061628,
			0.015880544863615904,
			-0.0090079761366615805,
			-0.0025745176887502236,
			0.0011175187708906016,
			0.00046621696011288631,
			-7.0983303138141252e-05,
			-3.4599772836212559e-05
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { -3.4599772836212559e-05,
			7.0983303138141252e-05,
			0.00046621696011288631,
			-0.0011175187708906016,
			-0.0025745176887502236,
			0.0090079761366615805,
			0.015880544863615904,
			-0.034555027573061628,
			-0.082301927106885983,
			0.071799821619312018,
			0.42848347637761874,
			-0.79377722262562056,
			0.4051769024096169,
			0.061123390002672869,
			-0.0657719112818555,
			-0.023452696141836267,
			0.0077825964273254182,
			0.0037935128644910141
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}
	else if (name == "coif4") {
		double lp1_a[] = { -1.7849850030882614e-06,
			-3.2596802368833675e-06,
			3.1229875865345646e-05,
			6.2339034461007128e-05,
			-0.00025997455248771324,
			-0.00058902075624433831,
			0.0012665619292989445,
			0.0037514361572784571,
			-0.0056582866866107199,
			-0.015211731527946259,
			0.025082261844864097,
			0.039334427123337491,
			-0.096220442033987982,
			-0.066627474263425038,
			0.4343860564914685,
			0.78223893092049901,
			0.41530840703043026,
			-0.056077313316754807,
			-0.081266699680878754,
			0.026682300156053072,
			0.016068943964776348,
			-0.0073461663276420935,
			-0.0016294920126017326,
			0.00089231366858231456
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { -0.00089231366858231456,
			-0.0016294920126017326,
			0.0073461663276420935,
			0.016068943964776348,
			-0.026682300156053072,
			-0.081266699680878754,
			0.056077313316754807,
			0.41530840703043026,
			-0.78223893092049901,
			0.4343860564914685,
			0.066627474263425038,
			-0.096220442033987982,
			-0.039334427123337491,
			0.025082261844864097,
			0.015211731527946259,
			-0.0056582866866107199,
			-0.0037514361572784571,
			0.0012665619292989445,
			0.00058902075624433831,
			-0.00025997455248771324,
			-6.2339034461007128e-05,
			3.1229875865345646e-05,
			3.2596802368833675e-06,
			-1.7849850030882614e-06
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.00089231366858231456,
			-0.0016294920126017326,
			-0.0073461663276420935,
			0.016068943964776348,
			0.026682300156053072,
			-0.081266699680878754,
			-0.056077313316754807,
			0.41530840703043026,
			0.78223893092049901,
			0.4343860564914685,
			-0.066627474263425038,
			-0.096220442033987982,
			0.039334427123337491,
			0.025082261844864097,
			-0.015211731527946259,
			-0.0056582866866107199,
			0.0037514361572784571,
			0.0012665619292989445,
			-0.00058902075624433831,
			-0.00025997455248771324,
			6.2339034461007128e-05,
			3.1229875865345646e-05,
			-3.2596802368833675e-06,
			-1.7849850030882614e-06
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { -1.7849850030882614e-06,
			3.2596802368833675e-06,
			3.1229875865345646e-05,
			-6.2339034461007128e-05,
			-0.00025997455248771324,
			0.00058902075624433831,
			0.0012665619292989445,
			-0.0037514361572784571,
			-0.0056582866866107199,
			0.015211731527946259,
			0.025082261844864097,
			-0.039334427123337491,
			-0.096220442033987982,
			0.066627474263425038,
			0.4343860564914685,
			-0.78223893092049901,
			0.41530840703043026,
			0.056077313316754807,
			-0.081266699680878754,
			-0.026682300156053072,
			0.016068943964776348,
			0.0073461663276420935,
			-0.0016294920126017326,
			-0.00089231366858231456
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}
	else if (name == "coif5") {
		double lp1_a[] = { -9.517657273819165e-08,
			-1.6744288576823017e-07,
			2.0637618513646814e-06,
			3.7346551751414047e-06,
			-2.1315026809955787e-05,
			-4.1340432272512511e-05,
			0.00014054114970203437,
			0.00030225958181306315,
			-0.00063813134304511142,
			-0.0016628637020130838,
			0.0024333732126576722,
			0.0067641854480530832,
			-0.0091642311624818458,
			-0.019761778942572639,
			0.032683574267111833,
			0.041289208750181702,
			-0.10557420870333893,
			-0.062035963962903569,
			0.43799162617183712,
			0.77428960365295618,
			0.42156620669085149,
			-0.052043163176243773,
			-0.091920010559696244,
			0.02816802897093635,
			0.023408156785839195,
			-0.010131117519849788,
			-0.004159358781386048,
			0.0021782363581090178,
			0.00035858968789573785,
			-0.00021208083980379827
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { 0.00021208083980379827,
			0.00035858968789573785,
			-0.0021782363581090178,
			-0.004159358781386048,
			0.010131117519849788,
			0.023408156785839195,
			-0.02816802897093635,
			-0.091920010559696244,
			0.052043163176243773,
			0.42156620669085149,
			-0.77428960365295618,
			0.43799162617183712,
			0.062035963962903569,
			-0.10557420870333893,
			-0.041289208750181702,
			0.032683574267111833,
			0.019761778942572639,
			-0.0091642311624818458,
			-0.0067641854480530832,
			0.0024333732126576722,
			0.0016628637020130838,
			-0.00063813134304511142,
			-0.00030225958181306315,
			0.00014054114970203437,
			4.1340432272512511e-05,
			-2.1315026809955787e-05,
			-3.7346551751414047e-06,
			2.0637618513646814e-06,
			1.6744288576823017e-07,
			-9.517657273819165e-08
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { -0.00021208083980379827,
			0.00035858968789573785,
			0.0021782363581090178,
			-0.004159358781386048,
			-0.010131117519849788,
			0.023408156785839195,
			0.02816802897093635,
			-0.091920010559696244,
			-0.052043163176243773,
			0.42156620669085149,
			0.77428960365295618,
			0.43799162617183712,
			-0.062035963962903569,
			-0.10557420870333893,
			0.041289208750181702,
			0.032683574267111833,
			-0.019761778942572639,
			-0.0091642311624818458,
			0.0067641854480530832,
			0.0024333732126576722,
			-0.0016628637020130838,
			-0.00063813134304511142,
			0.00030225958181306315,
			0.00014054114970203437,
			-4.1340432272512511e-05,
			-2.1315026809955787e-05,
			3.7346551751414047e-06,
			2.0637618513646814e-06,
			-1.6744288576823017e-07,
			-9.517657273819165e-08
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { -9.517657273819165e-08,
			1.6744288576823017e-07,
			2.0637618513646814e-06,
			-3.7346551751414047e-06,
			-2.1315026809955787e-05,
			4.1340432272512511e-05,
			0.00014054114970203437,
			-0.00030225958181306315,
			-0.00063813134304511142,
			0.0016628637020130838,
			0.0024333732126576722,
			-0.0067641854480530832,
			-0.0091642311624818458,
			0.019761778942572639,
			0.032683574267111833,
			-0.041289208750181702,
			-0.10557420870333893,
			0.062035963962903569,
			0.43799162617183712,
			-0.77428960365295618,
			0.42156620669085149,
			0.052043163176243773,
			-0.091920010559696244,
			-0.02816802897093635,
			0.023408156785839195,
			0.010131117519849788,
			-0.004159358781386048,
			-0.0021782363581090178,
			0.00035858968789573785,
			0.00021208083980379827
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}

	else if (name == "sym2") {
		double lp1_a[] = { -0.12940952255092145,
			0.22414386804185735,
			0.83651630373746899,
			0.48296291314469025
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { -0.48296291314469025,
			0.83651630373746899,
			-0.22414386804185735,
			-0.12940952255092145
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.48296291314469025,
			0.83651630373746899,
			0.22414386804185735,
			-0.12940952255092145
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { -0.12940952255092145,
			-0.22414386804185735,
			0.83651630373746899,
			-0.48296291314469025

		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}

	else if (name == "sym3") {
		double lp1_a[] = { 0.035226291882100656,
			-0.085441273882241486,
			-0.13501102001039084,
			0.45987750211933132,
			0.80689150931333875,
			0.33267055295095688

		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { -0.33267055295095688,
			0.80689150931333875,
			-0.45987750211933132,
			-0.13501102001039084,
			0.085441273882241486,
			0.035226291882100656
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.33267055295095688,
			0.80689150931333875,
			0.45987750211933132,
			-0.13501102001039084,
			-0.085441273882241486,
			0.035226291882100656
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { 0.035226291882100656,
			0.085441273882241486,
			-0.13501102001039084,
			-0.45987750211933132,
			0.80689150931333875,
			-0.33267055295095688
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}

	else if (name == "sym4") {
		double lp1_a[] = { -0.075765714789273325,
			-0.02963552764599851,
			0.49761866763201545,
			0.80373875180591614,
			0.29785779560527736,
			-0.099219543576847216,
			-0.012603967262037833,
			0.032223100604042702
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { -0.032223100604042702,
			-0.012603967262037833,
			0.099219543576847216,
			0.29785779560527736,
			-0.80373875180591614,
			0.49761866763201545,
			0.02963552764599851,
			-0.075765714789273325
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.032223100604042702,
			-0.012603967262037833,
			-0.099219543576847216,
			0.29785779560527736,
			0.80373875180591614,
			0.49761866763201545,
			-0.02963552764599851,
			-0.075765714789273325
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { -0.075765714789273325,
			0.02963552764599851,
			0.49761866763201545,
			-0.80373875180591614,
			0.29785779560527736,
			0.099219543576847216,
			-0.012603967262037833,
			-0.032223100604042702
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}

	else if (name == "sym5") {
		double lp1_a[] = { 0.027333068345077982,
			0.029519490925774643,
			-0.039134249302383094,
			0.1993975339773936,
			0.72340769040242059,
			0.63397896345821192,
			0.016602105764522319,
			-0.17532808990845047,
			-0.021101834024758855,
			0.019538882735286728
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { -0.019538882735286728,
			-0.021101834024758855,
			0.17532808990845047,
			0.016602105764522319,
			-0.63397896345821192,
			0.72340769040242059,
			-0.1993975339773936,
			-0.039134249302383094,
			-0.029519490925774643,
			0.027333068345077982
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.019538882735286728,
			-0.021101834024758855,
			-0.17532808990845047,
			0.016602105764522319,
			0.63397896345821192,
			0.72340769040242059,
			0.1993975339773936,
			-0.039134249302383094,
			0.029519490925774643,
			0.027333068345077982

		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { 0.027333068345077982,
			-0.029519490925774643,
			-0.039134249302383094,
			-0.1993975339773936,
			0.72340769040242059,
			-0.63397896345821192,
			0.016602105764522319,
			0.17532808990845047,
			-0.021101834024758855,
			-0.019538882735286728
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}

	else if (name == "sym6") {
		double lp1_a[] = { 0.015404109327027373,
			0.0034907120842174702,
			-0.11799011114819057,
			-0.048311742585632998,
			0.49105594192674662,
			0.787641141030194,
			0.3379294217276218,
			-0.072637522786462516,
			-0.021060292512300564,
			0.044724901770665779,
			0.0017677118642428036,
			-0.007800708325034148
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { 0.007800708325034148,
			0.0017677118642428036,
			-0.044724901770665779,
			-0.021060292512300564,
			0.072637522786462516,
			0.3379294217276218,
			-0.787641141030194,
			0.49105594192674662,
			0.048311742585632998,
			-0.11799011114819057,
			-0.0034907120842174702,
			0.015404109327027373
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { -0.007800708325034148,
			0.0017677118642428036,
			0.044724901770665779,
			-0.021060292512300564,
			-0.072637522786462516,
			0.3379294217276218,
			0.787641141030194,
			0.49105594192674662,
			-0.048311742585632998,
			-0.11799011114819057,
			0.0034907120842174702,
			0.015404109327027373
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { 0.015404109327027373,
			-0.0034907120842174702,
			-0.11799011114819057,
			0.048311742585632998,
			0.49105594192674662,
			-0.787641141030194,
			0.3379294217276218,
			0.072637522786462516,
			-0.021060292512300564,
			-0.044724901770665779,
			0.0017677118642428036,
			0.007800708325034148
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}

	else if (name == "sym7") {
		double lp1_a[] = { 0.0026818145682578781,
			-0.0010473848886829163,
			-0.01263630340325193,
			0.03051551316596357,
			0.067892693501372697,
			-0.049552834937127255,
			0.017441255086855827,
			0.5361019170917628,
			0.76776431700316405,
			0.28862963175151463,
			-0.14004724044296152,
			-0.10780823770381774,
			0.0040102448715336634,
			0.010268176708511255
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { -0.010268176708511255,
			0.0040102448715336634,
			0.10780823770381774,
			-0.14004724044296152,
			-0.28862963175151463,
			0.76776431700316405,
			-0.5361019170917628,
			0.017441255086855827,
			0.049552834937127255,
			0.067892693501372697,
			-0.03051551316596357,
			-0.01263630340325193,
			0.0010473848886829163,
			0.0026818145682578781

		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.010268176708511255,
			0.0040102448715336634,
			-0.10780823770381774,
			-0.14004724044296152,
			0.28862963175151463,
			0.76776431700316405,
			0.5361019170917628,
			0.017441255086855827,
			-0.049552834937127255,
			0.067892693501372697,
			0.03051551316596357,
			-0.01263630340325193,
			-0.0010473848886829163,
			0.0026818145682578781
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { 0.0026818145682578781,
			0.0010473848886829163,
			-0.01263630340325193,
			-0.03051551316596357,
			0.067892693501372697,
			0.049552834937127255,
			0.017441255086855827,
			-0.5361019170917628,
			0.76776431700316405,
			-0.28862963175151463,
			-0.14004724044296152,
			0.10780823770381774,
			0.0040102448715336634,
			-0.010268176708511255
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}

	else if (name == "sym8") {
		double lp1_a[] = { -0.0033824159510061256,
			-0.00054213233179114812,
			0.031695087811492981,
			0.0076074873249176054,
			-0.14329423835080971,
			-0.061273359067658524,
			0.48135965125837221,
			0.77718575170052351,
			0.3644418948353314,
			-0.051945838107709037,
			-0.027219029917056003,
			0.049137179673607506,
			0.0038087520138906151,
			-0.014952258337048231,
			-0.0003029205147213668,
			0.0018899503327594609
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { -0.0018899503327594609,
			-0.0003029205147213668,
			0.014952258337048231,
			0.0038087520138906151,
			-0.049137179673607506,
			-0.027219029917056003,
			0.051945838107709037,
			0.3644418948353314,
			-0.77718575170052351,
			0.48135965125837221,
			0.061273359067658524,
			-0.14329423835080971,
			-0.0076074873249176054,
			0.031695087811492981,
			0.00054213233179114812,
			-0.0033824159510061256
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.0018899503327594609,
			-0.0003029205147213668,
			-0.014952258337048231,
			0.0038087520138906151,
			0.049137179673607506,
			-0.027219029917056003,
			-0.051945838107709037,
			0.3644418948353314,
			0.77718575170052351,
			0.48135965125837221,
			-0.061273359067658524,
			-0.14329423835080971,
			0.0076074873249176054,
			0.031695087811492981,
			-0.00054213233179114812,
			-0.0033824159510061256
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { -0.0033824159510061256,
			0.00054213233179114812,
			0.031695087811492981,
			-0.0076074873249176054,
			-0.14329423835080971,
			0.061273359067658524,
			0.48135965125837221,
			-0.77718575170052351,
			0.3644418948353314,
			0.051945838107709037,
			-0.027219029917056003,
			-0.049137179673607506,
			0.0038087520138906151,
			0.014952258337048231,
			-0.0003029205147213668,
			-0.0018899503327594609
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}

	else if (name == "sym9") {
		double lp1_a[] = { 0.0014009155259146807,
			0.00061978088898558676,
			-0.013271967781817119,
			-0.01152821020767923,
			0.03022487885827568,
			0.00058346274612580684,
			-0.054568958430834071,
			0.238760914607303,
			0.717897082764412,
			0.61733844914093583,
			0.035272488035271894,
			-0.19155083129728512,
			-0.018233770779395985,
			0.06207778930288603,
			0.0088592674934004842,
			-0.010264064027633142,
			-0.00047315449868008311,
			0.0010694900329086053
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { -0.0010694900329086053,
			-0.00047315449868008311,
			0.010264064027633142,
			0.0088592674934004842,
			-0.06207778930288603,
			-0.018233770779395985,
			0.19155083129728512,
			0.035272488035271894,
			-0.61733844914093583,
			0.717897082764412,
			-0.238760914607303,
			-0.054568958430834071,
			-0.00058346274612580684,
			0.03022487885827568,
			0.01152821020767923,
			-0.013271967781817119,
			-0.00061978088898558676,
			0.0014009155259146807
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { 0.0010694900329086053,
			-0.00047315449868008311,
			-0.010264064027633142,
			0.0088592674934004842,
			0.06207778930288603,
			-0.018233770779395985,
			-0.19155083129728512,
			0.035272488035271894,
			0.61733844914093583,
			0.717897082764412,
			0.238760914607303,
			-0.054568958430834071,
			0.00058346274612580684,
			0.03022487885827568,
			-0.01152821020767923,
			-0.013271967781817119,
			0.00061978088898558676,
			0.0014009155259146807
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { 0.0014009155259146807,
			-0.00061978088898558676,
			-0.013271967781817119,
			0.01152821020767923,
			0.03022487885827568,
			-0.00058346274612580684,
			-0.054568958430834071,
			-0.238760914607303,
			0.717897082764412,
			-0.61733844914093583,
			0.035272488035271894,
			0.19155083129728512,
			-0.018233770779395985,
			-0.06207778930288603,
			0.0088592674934004842,
			0.010264064027633142,
			-0.00047315449868008311,
			-0.0010694900329086053
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}

	else if (name == "sym10") {
		double lp1_a[] = { 0.00077015980911449011,
			9.5632670722894754e-05,
			-0.0086412992770224222,
			-0.0014653825813050513,
			0.045927239231092203,
			0.011609893903711381,
			-0.15949427888491757,
			-0.070880535783243853,
			0.47169066693843925,
			0.7695100370211071,
			0.38382676106708546,
			-0.035536740473817552,
			-0.0319900568824278,
			0.049994972077376687,
			0.0057649120335819086,
			-0.02035493981231129,
			-0.00080435893201654491,
			0.0045931735853118284,
			5.7036083618494284e-05,
			-0.00045932942100465878
		};
		lp1.assign(lp1_a, lp1_a + sizeof(lp1_a) / sizeof(double));

		double hp1_a[] = { 0.00045932942100465878,
			5.7036083618494284e-05,
			-0.0045931735853118284,
			-0.00080435893201654491,
			0.02035493981231129,
			0.0057649120335819086,
			-0.049994972077376687,
			-0.0319900568824278,
			0.035536740473817552,
			0.38382676106708546,
			-0.7695100370211071,
			0.47169066693843925,
			0.070880535783243853,
			-0.15949427888491757,
			-0.011609893903711381,
			0.045927239231092203,
			0.0014653825813050513,
			-0.0086412992770224222,
			-9.5632670722894754e-05,
			0.00077015980911449011
		};
		hp1.assign(hp1_a, hp1_a + sizeof(hp1_a) / sizeof(double));

		double lp2_a[] = { -0.00045932942100465878,
			5.7036083618494284e-05,
			0.0045931735853118284,
			-0.00080435893201654491,
			-0.02035493981231129,
			0.0057649120335819086,
			0.049994972077376687,
			-0.0319900568824278,
			-0.035536740473817552,
			0.38382676106708546,
			0.7695100370211071,
			0.47169066693843925,
			-0.070880535783243853,
			-0.15949427888491757,
			0.011609893903711381,
			0.045927239231092203,
			-0.0014653825813050513,
			-0.0086412992770224222,
			9.5632670722894754e-05,
			0.00077015980911449011
		};
		lp2.assign(lp2_a, lp2_a + sizeof(lp2_a) / sizeof(double));

		double hp2_a[] = { 0.00077015980911449011,
			-9.5632670722894754e-05,
			-0.0086412992770224222,
			0.0014653825813050513,
			0.045927239231092203,
			-0.011609893903711381,
			-0.15949427888491757,
			0.070880535783243853,
			0.47169066693843925,
			-0.7695100370211071,
			0.38382676106708546,
			0.035536740473817552,
			-0.0319900568824278,
			-0.049994972077376687,
			0.0057649120335819086,
			0.02035493981231129,
			-0.00080435893201654491,
			-0.0045931735853118284,
			5.7036083618494284e-05,
			0.00045932942100465878
		};
		hp2.assign(hp2_a, hp2_a + sizeof(hp2_a) / sizeof(double));
		return 0;
	}


	else {
		return 0;
		/*cout << "Filter Not in Database" << endl;
		return -1;*/
	}

}