#ifndef _MATRIX_H
#define _MATRIX_H
#include<stdlib.h>
#include<stdio.h>
#include<malloc.h>
#include "time.h"
#define CLASS double
#define CLASS2 int
struct matrix{
	int row;
	int col;
	CLASS **p;
};
void initial( struct  matrix *MAT){
	int i;
	int row,col;
	row=MAT->row;
	col=MAT->col;
	if(row<0){
		printf("the row of matrix <0\n");
		MAT->row=0;
	}
	if(col<0){
		printf("the col of matrix <0\n");
		MAT->col=0;
	}
	
	MAT->p=(CLASS**)malloc(MAT->row*sizeof(CLASS));
	for(i=0;i<MAT->row;i++){
		MAT->p[i]=(CLASS*)malloc(MAT->col*sizeof(CLASS));
	}
}
int size(struct  matrix *MAT,int NUM){
	if(NUM==1){
    return(MAT->row);
  }
  else if(NUM==2){
  	return(MAT->col);
  }
  else{
  	printf("the second parameter must be 1or 2\n");
  	return(0);
  }
}
void free_matrix(struct  matrix *MAT){
     int row=size(MAT,1);
     int i;
     for(i=0;i<row;i++){
          free (MAT->p[i]);
     }
     MAT->row=0;MAT->col=0;
     MAT->p=(NULL);
}
int get_row(struct  matrix *MAT){
    return(MAT->row);
}
int get_col(struct  matrix *MAT){
    return(MAT->col);
}

void disp(  struct  matrix *MAT){
	int m,n;
	int i,j;
	m=get_row(MAT);
	n=get_col(MAT);
	if(m<=0||n<=0){
		printf("the matrix is no mean\n");
	}
	else{
		for(i=0;i<m;i++){
			for(j=0;j<n;j++){
				printf("%lf  ",MAT->p[i][j]);
			}
			printf("\n");
		}
		printf("\n");
	}
}
struct  matrix sum(	struct  matrix *MAT1,struct  matrix *MAT2){
	int row1,row2,col1,col2;
	int i,j;
	struct  matrix MAT3;
	row1=get_row(MAT1);row2=get_row(MAT2);
	col1=get_col(MAT1);col2=get_col(MAT2);
	if(row1==row2&&col1==col2&&row1>0&&col1>0){
		MAT3.row=row1;
		MAT3.col=col1;
		initial(&MAT3);
		for(i=0;i<row1;i++){
			for(j=0;j<col1;j++){
				MAT3.p[i][j]=MAT1->p[i][j]+MAT2->p[i][j];
			}
		}
	}
	else{
		printf("the matrix1 is no equal to the matrix2,sum cannot finish\n");
		MAT3.row=0;
		MAT3.col=0;
	}
	return(MAT3);
}
struct  matrix sub(	struct  matrix *MAT1,struct  matrix *MAT2){
	int row1,row2,col1,col2;
	int i,j;
	struct  matrix MAT3;
	row1=get_row(MAT1);row2=get_row(MAT2);
	col1=get_col(MAT1);col2=get_col(MAT2);
	if(row1==row2&&col1==col2&&row1>0&&col1>0){
		MAT3.row=row1;
		MAT3.col=col1;
		initial(&MAT3);
		for(i=0;i<row1;i++){
			for(j=0;j<col1;j++){
				MAT3.p[i][j]=MAT1->p[i][j]-MAT2->p[i][j];
			}
		}
	}
	else{
		printf("the matrix1 is no equal to the matrix2,sub cannot finish\n");
		MAT3.row=0;
		MAT3.col=0;
	}
	return(MAT3);
}
struct  matrix dot_multi(	struct  matrix *MAT1,struct  matrix *MAT2){
	int row1,row2,col1,col2;
	int i,j;
	struct  matrix MAT3;
	row1=get_row(MAT1);row2=get_row(MAT2);
	col1=get_col(MAT1);col2=get_col(MAT2);
	if(row1==row2&&col1==col2&&row1>0&&col1>0){
		MAT3.row=row1;
		MAT3.col=col1;
		initial(&MAT3);
		for(i=0;i<row1;i++){
			for(j=0;j<col1;j++){
				MAT3.p[i][j]=MAT1->p[i][j]*MAT2->p[i][j];
			}
		}
	}
	else{
		printf("the matrix1 is no equal to the matrix2,dot_multi cannot finish\n");
		MAT3.row=0;
		MAT3.col=0;
	}
	return(MAT3);
}
struct  matrix dot_div(	struct  matrix *MAT1,struct  matrix *MAT2){
	int row1,row2,col1,col2;
	int i,j;
	struct  matrix MAT3;
	row1=get_row(MAT1);row2=get_row(MAT2);
	col1=get_col(MAT1);col2=get_col(MAT2);
	if(row1==row2&&col1==col2&&row1>0&&col1>0){
		MAT3.row=row1;
		MAT3.col=col1;
		initial(&MAT3);
		for(i=0;i<row1;i++){
			for(j=0;j<col1;j++){
				if(MAT2->p[i][j]!=0){
					MAT3.p[i][j]=MAT1->p[i][j]/MAT2->p[i][j];
				}
				else{
					MAT3.p[i][j]=RAND_MAX;
                }
			}
		}
	}
	else{
		printf("the matrix1 is no equal to the matrix2,dot_div cannot finish\n");
		MAT3.row=0;
		MAT3.col=0;
	}
	return(MAT3);
}
struct  matrix multi(	struct  matrix *MAT1,struct  matrix *MAT2){
	int row1,row2,col1,col2;
	int i,j,k;
	struct  matrix MAT3;
	row1=get_row(MAT1);row2=get_row(MAT2);
	col1=get_col(MAT1);col2=get_col(MAT2);
	if(col1==row2&&row1>0&&col1>0&&col2>0){
		MAT3.row=row1;
		MAT3.col=col2;
		initial(&MAT3);
		for(i=0;i<row1;i++){
			for(j=0;j<col2;j++){
                MAT3.p[i][j]=0;                
				for(k=0;k<col1;k++){
					MAT3.p[i][j]=MAT3.p[i][j]+MAT1->p[i][k]*MAT2->p[k][j];
				}
			}
		}
	}
	else{
		printf("the matrixs cannot be multi\n");
		MAT3.row=0;
		MAT3.col=0;
	}
	return(MAT3);
}

struct  matrix sum_const(	struct  matrix *MAT1,CLASS2 NUM ){
	int row1,col1;
	int i,j;
	struct  matrix MAT3;
	row1=get_row(MAT1);
	col1=get_col(MAT1);
	if(row1>0&&col1>0){
		MAT3.row=row1;
		MAT3.col=col1;
		initial(&MAT3);
		for(i=0;i<row1;i++){
			for(j=0;j<col1;j++){
				MAT3.p[i][j]=MAT1->p[i][j]+(CLASS)(NUM);
			}
		}
	}
	else{
		printf("the matrixs is no mean\n");
		MAT3.row=0;
		MAT3.col=0;
	}
	return(MAT3);
}
struct  matrix sub_const(	struct  matrix *MAT1,CLASS2 NUM ){
	int row1,col1;
	int i,j;
	struct  matrix MAT3;
	row1=get_row(MAT1);
	col1=get_col(MAT1);
	if(row1>0&&col1>0){
		MAT3.row=row1;
		MAT3.col=col1;
		initial(&MAT3);
		for(i=0;i<row1;i++){
			for(j=0;j<col1;j++){
				MAT3.p[i][j]=MAT1->p[i][j]-(CLASS)(NUM);
			}
		}
	}
	else{
		printf("the matrixs is no mean\n");
		MAT3.row=0;
		MAT3.col=0;
	}
	return(MAT3);
}
struct  matrix muti_const(	struct  matrix *MAT1,CLASS2 NUM ){
	int row1,col1;
	int i,j;
	struct  matrix MAT3;
	row1=get_row(MAT1);
	col1=get_col(MAT1);
	if(row1>0&&col1>0){
		MAT3.row=row1;
		MAT3.col=col1;
		initial(&MAT3);
		for(i=0;i<row1;i++){
			for(j=0;j<col1;j++){
				MAT3.p[i][j]=MAT1->p[i][j]*(CLASS)(NUM);
			}
		}
	}
	else{
		printf("the matrixs is no mean\n");
		MAT3.row=0;
		MAT3.col=0;
	}
	return(MAT3);
}
struct  matrix div_const(	struct  matrix *MAT1,CLASS2 NUM ){
	int row1,col1;
	int i,j;
	struct  matrix MAT3;
	row1=get_row(MAT1);
	col1=get_col(MAT1);
	if(row1>0&&col1>0){
		MAT3.row=row1;
		MAT3.col=col1;
		initial(&MAT3);
		for(i=0;i<row1;i++){
			for(j=0;j<col1;j++){
				if(NUM==0){
					printf("the NUM is zero\n");
					MAT3.p[i][j]=RAND_MAX;
				}
				else{
					MAT3.p[i][j]=MAT1->p[i][j]/(CLASS)(NUM);
				}
			}
		}
	}
	else if(!(row1>0&&col1>0)){
		printf("the matrixs is no mean\n");
		MAT3.row=0;
		MAT3.col=0;
	}
	return(MAT3);
}
struct  matrix transport(	struct  matrix *MAT1){
	int row1,col1;
	int i,j;
	struct  matrix MAT3;
	row1=get_row(MAT1);
	col1=get_col(MAT1);
	if(row1>0&&col1>0){
		MAT3.row=col1;
		MAT3.col=row1;
		initial(&MAT3);
		for(i=0;i<MAT3.row;i++){
			for(j=0;j<MAT3.col;j++){
				MAT3.p[i][j]=MAT1->p[j][i];
			}
		}
	}
	else{
		printf("the matrixs is no mean\n");
		MAT3.row=0;
		MAT3.col=0;
	}
	return(MAT3);
}
struct  matrix delete_row(	struct  matrix *MAT1,int NUM ){
	int row1,col1;
	int i,j;
	struct  matrix MAT3;
	row1=get_row(MAT1);
	col1=get_col(MAT1);
	if(row1>0&&col1>0){
		if(NUM<row1&&NUM>=0){
			MAT3.row=row1-1;
			MAT3.col=col1;
			initial(&MAT3);
			for(i=0;i<MAT3.row;i++){
				for(j=0;j<MAT3.col;j++){
					if(i<NUM){
						MAT3.p[i][j]=MAT1->p[i][j];
					}
					else{
						MAT3.p[i][j]=MAT1->p[i+1][j];
					}
				}
			}
		}
		else{
			printf("the row you want to delete  is out\n");
			MAT3.row=0;
			MAT3.col=0;
		}
	}
	else{
		printf("the matrixs is no mean\n");
		MAT3.row=0;
		MAT3.col=0;
	}
	return(MAT3);
}
struct  matrix delete_col(	struct  matrix *MAT1,int NUM ){
	struct  matrix MAT3=transport(MAT1);
	struct  matrix MAT4=delete_row(&MAT3,NUM);
	struct  matrix MAT5=transport(&MAT4);
	free_matrix(&MAT3);
	free_matrix(&MAT4);
	return(MAT5);
	
}

struct  matrix ones(	int row,int col ){
	struct  matrix MAT3;
	int i,j;
	if(row>0&&col>0){
		MAT3.row=row;
		MAT3.col=col;
		initial(&MAT3);
		for(i=0;i<row;i++){
			for(j=0;j<col;j++){
				MAT3.p[i][j]=1;
			}
		}
	}
	else{
		printf("the index of matrix is wrong ,can not initial ones matrix\n");
		MAT3.row=0;
		MAT3.col=0;
	}
	return(MAT3);
}
struct  matrix zeros(	int row,int col ){
	struct  matrix MAT3;
	int i,j;
	if(row>0&&col>0){
		MAT3.row=row;
		MAT3.col=col;
		initial(&MAT3);
		for(i=0;i<row;i++){
			for(j=0;j<col;j++){
				MAT3.p[i][j]=0;
			}
		}
	}
	else{
		printf("the index of matrix is wrong ,can not initial zeros matrix\n");
		MAT3.row=0;
		MAT3.col=0;
	}
	return(MAT3);
}
struct  matrix rands(int row,int col ){
	struct  matrix MAT3;
	int i,j;
	if(row>0&&col>0){
		MAT3.row=row;
		MAT3.col=col;
		initial(&MAT3);
		srand((unsigned)time(NULL));
		for(i=0;i<row;i++){
			for(j=0;j<col;j++){
				MAT3.p[i][j]=(CLASS)((rand()%100)/100.0);
			}
		}
	}
	else{
		printf("the index of matrix is wrong ,can not initial rands matrix\n");
		MAT3.row=0;
		MAT3.col=0;
	}
	return(MAT3);
}
struct  matrix eye(	int row,int col ){
	struct  matrix MAT3;
	int i,j;
	if(row>0&&col>0&&row==col){
		MAT3.row=row;
		MAT3.col=col;
		initial(&MAT3);
		for(i=0;i<row;i++){
			for(j=0;j<col;j++){
				if(i==j){MAT3.p[i][j]=1;}
				else    {MAT3.p[i][j]=0;}
			}
		}
	}
	else{
		printf("the index of matrix is wrong ,can not initial eye matrix\n");
		MAT3.row=0;
		MAT3.col=0;
	}
	return(MAT3);
}
struct  matrix copy(struct  matrix *MAT ){
	struct  matrix MAT3;
	int i,j;
	if(MAT->row>0&&MAT->col>0){
		MAT3.row=MAT->row;
		MAT3.col=MAT->col;
		initial(&MAT3);
		for(i=0;i<MAT3.row;i++){
			for(j=0;j<MAT3.col;j++){
				MAT3.p[i][j]=MAT->p[i][j];
			}
		}
	}
	else{
		printf("the index of matrix is wrong ,can not initial eye matrix\n");
		MAT3.row=0;
		MAT3.col=0;
	}
	return(MAT3);
}
struct  matrix repmat(struct  matrix *MAT,int m,int n ){
	struct  matrix MAT3;
	int i,j,itemp,jtemp;
	if(MAT->row>0&&MAT->col>0&&m>0&&n>0){
		MAT3.row=(MAT->row)*m;
		MAT3.col=(MAT->col)*n;
		initial(&MAT3);
		for(i=0;i<MAT3.row;i++){
			for(j=0;j<MAT3.col;j++){
				itemp=i%(MAT->row);jtemp=j%(MAT->col);
				MAT3.p[i][j]=MAT->p[itemp][jtemp];
			}
		}
	}
	else if(!(m>0&&n>0)){
		printf("the parameter shouble be a number >0\n");
		MAT3.row=0;
		MAT3.col=0;
	}
	else{
		printf("the index of matrix is wrong ,can not initial eye matrix\n");
		MAT3.row=0;
		MAT3.col=0;
	}
	return(MAT3);
}
struct  matrix col_rep(struct  matrix *MAT, struct  matrix *MAT1){
	struct  matrix MAT3;
	int i,j;
	if(MAT->row==MAT1->row&&MAT->col>0&&MAT1->col>0){
		MAT3.row=(MAT->row);
		MAT3.col=(MAT->col)+(MAT1->col);
		initial(&MAT3);
		for(i=0;i<MAT3.row;i++){
			for(j=0;j<MAT3.col;j++){
				if(j<MAT->col){MAT3.p[i][j]=MAT->p[i][j];}
				else          {MAT3.p[i][j]=MAT1->p[i][j-MAT->col];}
			}
		}
	}
	else if(MAT->row!=MAT1->row){
		printf("the two matrix can not col_rep\n");
		MAT3.row=0;
		MAT3.col=0;
	}
	else{
		printf("the index of matrix is wrong ,can not initial eye matrix\n");
		MAT3.row=0;
		MAT3.col=0;
	}
	return(MAT3);
}
struct  matrix row_rep(struct  matrix *MAT, struct  matrix *MAT1){
	struct  matrix MAT3;
	int i,j;
	if(MAT->col==MAT1->col&&MAT->row>0&&MAT1->row>0){
		MAT3.col=(MAT->col);
		MAT3.row=(MAT->row)+(MAT1->row);
		initial(&MAT3);
		for(i=0;i<MAT3.row;i++){
			for(j=0;j<MAT3.col;j++){
				if(i<MAT->row){MAT3.p[i][j]=MAT->p[i][j];}
				else          {MAT3.p[i][j]=MAT1->p[i-MAT->row][j];}
			}
		}
	}
	else if(MAT->col!=MAT1->col){
		printf("the two matrix can not row_rep\n");
		MAT3.row=0;
		MAT3.col=0;
	}
	else{
		printf("the index of matrix is wrong ,can not initial eye matrix\n");
		MAT3.row=0;
		MAT3.col=0;
	}
	return(MAT3);
}
struct  matrix suba(struct  matrix *MAT, int m1,int n1,int m2,int n2){
	struct  matrix MAT3;
	int i,j;
	if(MAT->col>0&&MAT->row>0&&m1>=0&&n1>=0&&m2>=m1&&n2>=n1&&n1<MAT->col&&n2<MAT->col&&m1<MAT->row&&m2<MAT->row){
		MAT3.row=m2-m1+1;
		MAT3.col=n2-n1+1;
		initial(&MAT3);
		for(i=0;i<MAT3.row;i++){
			for(j=0;j<MAT3.col;j++){
				MAT3.p[i][j]=MAT->p[m1+i][n1+j];
			}
		}
	}
	else if(!(m1>=0&&n1>=0&&m2>=m1&&n2>=n1)){
		printf("the parameters matrix is wrong to fetch\n");
		MAT3.row=0;
		MAT3.col=0;
	}
	else{
		printf("the index of matrix is wrong ,can not initial eye matrix\n");
		MAT3.row=0;
		MAT3.col=0;
	}
	return(MAT3);
}	
struct matrix r_ch(struct  matrix *MAT){
  int i,j,k,h;
  int row=size(MAT,1),col=size(MAT,2);
  int min_row=row<col?row:col;
  CLASS s,index;
  struct  matrix result,array,array2,result_temp;
  if (row<=0||col<=0){
  	printf("the matrix's index is <0\n");
  	result_temp.row=0;
  	result_temp.col=0;
  	initial(&result_temp);
  	return(result_temp);
  }
  result=copy(MAT);
  for(i=0;i<min_row;i++){
  	if(result.p[i][i]!=0){
  		loop1: array=suba(&result,i,0,i,result.col-1);
  			for(j=0;j<col;j++){
  				array.p[0][j]=array.p[0][j]/result.p[i][i];
  			}
  			for( j=0;j<col;j++){
  				result.p[i][j]=array.p[0][j];
  			}
  			for(k=0;k<row;k++){
  				if (k==i){ continue;}
  				else{
  					array2=suba(&result,k,0,k,result.col-1);
  					s=array2.p[0][i]/array.p[0][i];
  					for(j=0;j<array2.col;j++){
  						array2.p[0][j]=array2.p[0][j]-array.p[0][j]*s;
  					}
  					for( j=0;j<col;j++){
  						result.p[k][j]=array2.p[0][j];
  					}
  				}
  			}
  	}
  	else if(i+1<row){
  		for(k=i+1;k<row;k++){
  			if(k!=row-1&&result.p[k][i]!=0){
  				for(j=0;j<col;j++){
  					index=result.p[i][j];
  					result.p[i][j]=result.p[k][j];
  					result.p[k][j]=index;
  				}
  				goto loop1;
  			}
  			else if(k==row-1){ continue;}
  		}
  	}
  }
  result_temp=copy(MAT);
  for(i=0;i<row;i++){
  	for(j=0;j<col;j++){
  		result_temp.p[i][j]=0;
  	}
  }
  for(k=0;k<row;k++){
  	for( j=0;j<col;j++){
  		for( i=0;i<row;i++){
  			if(result.p[i][j]!=0){
  				for( h=0;h<col;h++){
  					result_temp.p[k][h]=result.p[i][h];
  					result.p[i][h]=0;
  				}
  			goto loop2;
  		}
  	}
  }
 loop2:continue;
}
 return(result_temp);
}
struct matrix c_ch(struct  matrix *MAT1){
	struct  matrix shift_p=transport(MAT1);
	struct  matrix result_temp=r_ch(&shift_p);
	struct  matrix result=transport(&result_temp);
	return( result);
}
int rank(struct  matrix *MAT){
  int i,j,sum;
  int row=size(MAT,1),col=size(MAT,2);
  int rank=row>col?col:row;
  int rank1,rank2,tag1=0,tag2=0;
  struct  matrix row_shift;
  struct  matrix col_shift;
  if (rank>1){