*(Matr + i) = 0;
		}
	}
}

void CMatrixOper::MatrPoinJudgeBig(double*Matr,int row,int colum,double range)
{
	for(int i = 0;i < row*colum;i++)
	{	
		if (*(Matr + i) >= range) 
		{
			*(Matr + i) = 1;
		}
		else
		{
			*(Matr + i) = 0;
		}
	}
}

void CMatrixOper::MatrMul(double*Matr1,int row1,int colum1,int colum2,int colum,double*Matr2,double*Matr)
{	
	double Temp = 0;
	for(int i = 0;i < row1;i++)
	{
		for (int n = 0;n < colum2;n++)
		{
			for (int j = 0;j < colum1;j++)
			{
		
				Temp = Temp + *(Matr1 + colum1*i + j) * *(Matr2 + colum2*j + n);
			}
			*(Matr + colum*i + n) = Temp;
			Temp = 0;
		}
	}	
}

void CMatrixOper::MatrMulre(double*Matr1,int row1,int colum1,int colum2,int colum,double*Matr2,COMPLEX*Matr)
{	
	double Temp = 0;
	for(int i = 0;i < row1;i++)
	{
		for (int n = 0;n < colum2;n++)
		{
			for (int j = 0;j < colum1;j++)
			{
		
				Temp = Temp + *(Matr1 + colum1*i + j) * *(Matr2 + colum2*j + n);
			}
			(*(Matr + colum*i + n)).re = Temp;
			Temp = 0;
		}
	}	
}

void CMatrixOper::MatrMulim(double*Matr1,int row1,int colum1,int colum2,int colum,double*Matr2,COMPLEX*Matr)
{	
	double Temp = 0;
	for(int i = 0;i < row1;i++)
	{
		for (int n = 0;n < colum2;n++)
		{
			for (int j = 0;j < colum1;j++)
			{
		
				Temp = Temp + *(Matr1 + colum1*i + j) * *(Matr2 + colum2*j + n);
			}
			(*(Matr + colum*i + n)).im = Temp ;
			Temp = 0;
		}
	}	
}

void CMatrixOper::MatrZerosCreat(double*Matr,int row,int colum)
{
	for(int i = 0;i < row*colum;i++)
	{
		*(Matr + i) = 0;
	}
}

void CMatrixOper::MatrCOMZerosCreat(COMPLEX*Matr,int row,int colum)
{
	for(int i = 0;i < row*colum;i++)
	{
		(*(Matr + i)).re = 0;
		(*(Matr + i)).im = 0;
	}
}

void CMatrixOper::MatrOnesCreat(double*Matr,int row,int colum)
{
	for(int i = 0;i < row*colum;i++)
	{
		*(Matr + i) = 1;
	}
}

void CMatrixOper::MatrFloor(double*Matr,int row,int colum)
{
	double temp;
	for(int i = 0;i < row*colum;i++)
	{
		temp = *(Matr + i);
		if (temp >= 0)
		{
			*(Matr + i) = (int)temp;
		} 
		else
		{
			temp = -temp + 1;
			*(Matr + i) = (int)temp;
		}
	}
}

void CMatrixOper::MatrRotate(double*Matr1,int row,int colum,double*Matr)
{
	for (int i = 0;i < row;i++) 
	{
		for (int j = 0;j < colum;j++) 
		{
			*(Matr + j*row +i) = *(Matr1 + colum*i + j);
		}
	}
}

void CMatrixOper::MatrRotateEx(COMPLEX*Matr1,int row,int colum,COMPLEX*Matr)
{
	for (int i = 0;i < row;i++) 
	{
		for (int j = 0;j < colum;j++) 
		{
			(*(Matr + row*j + i)).re = (*(Matr1 + colum*i + j)).re;
			(*(Matr + row*j + i)).im = (*(Matr1 + colum*i + j)).im;				
		}
	}
}

int CMatrixOper::VectorCreat(double*Vector,double a,double b,double deta) 
{
	int count = int((b-a)/deta) + 1;
	for (int i = 0;i < count;i++) 
	{
		Vector[i] = a + ((double)i)*deta;
	}
	return count;
}

double CMatrixOper::Min(double*Matr,int row,int colum)
{
	double Temp = *(Matr);
	for (int i = 1;i < row*colum;i++) 
	{
		if (Temp > *(Matr + i)) 
		{
			Temp = *(Matr + i);
		}
	}
	return Temp;
}

double CMatrixOper::Max(double*Matr,int row,int colum)
{
	double Temp = *(Matr);
	for (int i = 1;i < row*colum;i++) 
	{
		if (Temp <= *(Matr + i)) 
		{
			Temp = *(Matr + i);
		}
	}
	return Temp;
}
void CMatrixOper::Abs(double*Matr1,int row,int colum,double*Matr)
{
	for(int i = 0;i < row*colum;i++)
	{
		if (*(Matr1 + i) >= 0) 
		{
			*(Matr + i) = *(Matr1 + i);
		}
		else
		{
			*(Matr + i) = -*(Matr1 + i);
		}
	}
}
void CMatrixOper::fftshift(COMPLEX*Matr,int row,int colum)
{
	COMPLEX temp;
	temp.im = 0;
	temp.re = 0;
	int i,j;
	for (i = 0;i < row;i++) 
	{
		if (fmod(colum,2)) 
		{
			for (j = 0;j < (colum-1)/2;j++) 
			{			
				temp.re = (*(Matr + colum*i + (colum+1)/2+j)).re;
				temp.im = (*(Matr + colum*i + (colum+1)/2+j)).im;
				(*(Matr + colum*i + (colum+1)/2+j)).re = (*(Matr + colum*i + j)).re;
				(*(Matr + colum*i + (colum+1)/2+j)).im = (*(Matr + colum*i + j)).im;
				(*(Matr + colum*i + j)).re = temp.re;
				(*(Matr + colum*i + j)).im = temp.im;
			}
			for (j = (colum-1)/2;j<colum-1;j++) 
			{
				temp.re = (*(Matr + colum*i + j)).re;
				temp.im = (*(Matr + colum*i + j)).im;
				(*(Matr + colum*i + j)).re = (*(Matr + colum*i + j + 1)).re;
				(*(Matr + colum*i + j)).im = (*(Matr + colum*i + j + 1)).im;
				(*(Matr + colum*i + j + 1)).re = temp.re;
				(*(Matr + colum*i + j + 1)).im = temp.im;
			}
		}
		else
		{
			for (j = 0;j < colum/2;j++)
			{
				temp.re = (*(Matr + colum*i + colum/2+j)).re;
				temp.im = (*(Matr + colum*i + colum/2+j)).im;
				(*(Matr + colum*i + colum/2+j)).re = (*(Matr + colum*i + j)).re;
				(*(Matr + colum*i + colum/2+j)).im = (*(Matr + colum*i + j)).im;
				(*(Matr + colum*i + j)).re = temp.re;
				(*(Matr + colum*i + j)).im = temp.im;
			}
		}
	}
	for (j = 0;j < colum;j++) 
	{
		if (fmod(row,2)) 
		{
			for (i = 0;i < (row-1)/2;i++)
			{
				temp.re = (*(Matr + colum*i + (row+1)*colum/2+j)).re;
				temp.im = (*(Matr + colum*i + (row+1)*colum/2+j)).im;
				(*(Matr + colum*i + (row+1)*colum/2+j)).re = (*(Matr + colum*i + j)).re;
				(*(Matr + colum*i + (row+1)*colum/2+j)).im = (*(Matr + colum*i + j)).im;
				(*(Matr + colum*i + j)).re = temp.re;
				(*(Matr + colum*i + j)).im = temp.im;
			}
				for (i = (row-1)/2;i<row-1;i++) 
			{
				temp.re = (*(Matr + colum*i + j)).re;
				temp.im = (*(Matr + colum*i + j)).im;
				(*(Matr + colum*i + j)).re = (*(Matr + colum*(i+1) + j)).re;
				(*(Matr + colum*i + j)).im = (*(Matr + colum*(i+1) + j)).im;
				(*(Matr + colum*(i+1) + j)).re = temp.re;
				(*(Matr + colum*(i+1) + j)).im = temp.im;
			}
		}
		else
		{
			for (i = 0;i < row/2;i++)
			{
				temp.re = (*(Matr + colum*i + row*colum/2+j)).re;
				temp.im = (*(Matr + colum*i + row*colum/2+j)).im;
				(*(Matr + colum*i + row*colum/2+j)).re = (*(Matr + colum*i + j)).re;
				(*(Matr + colum*i + row*colum/2+j)).im = (*(Matr + colum*i + j)).im;
				(*(Matr + colum*i + j)).re = temp.re;
				(*(Matr + colum*i + j)).im = temp.im;
			}
		}
	}
}
void CMatrixOper::VectorMul(double*Vector,int n,double a)
{	
	for (int i = 0;i < n;i++)
	{
		Vector[i] = a*Vector[i];
	}
}
void CMatrixOper::VectorTan(double*Vector,int n)
{
	for (int i = 0;i < n;i++)
	{
		Vector[i] = tan(Vector[i]);
	}
}

void CMatrixOper::VectoraTan(double*Vector,int n)
{
	for (int i = 0;i < n;i++)
	{
		Vector[i] = atan(Vector[i]);
	}
}

void CMatrixOper::VectorAddNum(double*Vector,int n,double Num)
{
	for (int i = 0;i < n;i++)
	{
		Vector[i] = Vector[i] + Num;
	}
}

void CMatrixOper::VectorEqu(double*Vector,int n,double *Vector1)
{
	for (int i = 0;i < n;i++)
	{
		Vector1[i] = Vector[i];
	}
}

void CMatrixOper::VectorZerosCreat(double*Vector,int n)
{
	for (int i = 0;i < n;i++)
	{
		Vector[i] = 0;
	}
}

void CMatrixOper::VectorOnesCreat(double*Vector,int n)
{
	for (int i = 0;i < n;i++)
	{
		Vector[i] = 1;
	}
}

void CMatrixOper::VectorPointDiv(double*Vector1,int n,double *Vector2,double *Vector)
{	
	for (int i = 0;i < n;i++)
	{
		Vector[i] = Vector1[i]/Vector2[i];
	}
}

void CMatrixOper::VectorAsin(double*Vector,int n)
{
	for (int i = 0;i < n;i++)
	{
		Vector[i] = asin(Vector[i]);
	}
}
void CMatrixOper::VectorConve(double*Vector1,int n,double*Matr)
{
	for (int i = 0;i < n;i++)
	{
		*(Matr + i ) = Vector1[i];
	}
}

double CMatrixOper::MatrPointGet(double*Matr,int row,int colum,int i,int j)
{
	return *(Matr + i*colum +j);
}
void CMatrixOper::MatrPointSet(double*Matr,int row,int colum,int i,int j,double a)
{
	 *(Matr + i*colum +j) = a;
}

double CMatrixOper::MatrPointGetre(COMPLEX*Matr,int row,int colum,int i,int j)
{
	return (*(Matr + i*colum +j)).re;
}

double CMatrixOper::MatrPointGetim(COMPLEX*Matr,int row,int colum,int i,int j)
{
	return (*(Matr + i*colum +j)).im;
}