수다닷컴

질문 제목 : 31차 역행렬 계산질문 내용 : n * n 차 행렬의 역행렬을 구한 후 행렬을 곱한 후 검사하는 프로그램입니다.
고차로 갈수록 det값이 커져서 그런지 9차 이상은 값이 안 나옵니다.
수정 좀 도와주세여
#include stdio.h
#include stdlib.h
#include string.h
#include math.h
#define m_pi 3.14
#define size (31)

typedef struct _squarematrix
{
int m_nsize;
double **m_pdata;
}matrix;
void makematrix ( matrix *pmatrix , int nsize );
void deletematrix ( matrix *pmatrix );
void inputmatrix ( matrix *pmatrix );
void printmatrix ( matrix matrix );
double getdeterminent ( matrix matrix );
matrix gettransposematrix ( matrix matrix );
matrix getadjointmatrix ( matrix matrix );
matrix getminormatrix ( matrix matrix , int ncol , int nrow );
matrix getconfactormatrix ( matrix matrix );
matrix getinversematrix ( matrix matrix );
double table1 [size][1] = {0}; //차수별 고조파의 크기 입력 a_n
double table2 [size][size] ; // 입력 함수 s_n
double table3 [size][1] = {0}; // 차수별 고조파의 크기 출력v_t
double table4 [size][size] ; // s_n의 역행렬
double table5 [size][1] = {0}; // a_n resultint main (void)
{
int i,j,k;

matrix matrix;
matrix inverse;
int nsize;
double fdet;
double fdetinv;
printf ( --==== 역행렬 계산 프로그램 ====--\n\n );
printf ( 행렬의 크기 : );
scanf ( %d , &nsize );

makematrix ( &matrix , nsize );
makematrix ( &inverse , nsize );
inputmatrix ( &matrix );

fdet = getdeterminent ( matrix );
inverse = getinversematrix ( matrix );
fdetinv = getdeterminent ( inverse );
printmatrix ( matrix );
for( i = 0 ; i nsize ; i++)
{
for( j = 0 ; j nsize ; j++)
{
table2[i][j]=matrix.m_pdata[i][j];

}
}

printf ( \n 행렬식 : %2.3f\n , fdet );
printmatrix ( getadjointmatrix ( matrix ) );
printmatrix ( inverse );

printf ( \n 역행렬의 행렬식 : %2.3f\n , fdetinv );
deletematrix ( &matrix );
deletematrix ( &inverse );

printf(\n---------------------------------------------------------------\n);

printf(\n);
printf(각 차수별 고조파의 크기를 넣으세여 \n ); /* a_n 값 입력 */
printf(\n);

for( j = 0 ; j nsize ; j++)
{
for( k = 0 ; k 1 ; k++)
{
printf(%d 차 고조파의 크기 : ,j+1);
scanf(%lf, &table1[j][k]);
}
}
printf(\n);
printf(\n);
printf(**********************\n);
printf( v_t \n);
printf(**********************\n);

for( i = 0 ; i nsize ; i++)
{
for( j= 0 ; j nsize ; j++)
{
for( k = 0 ; k 1 ; k++)
{
table3[i][k] += t[k] += table2[i][j] * table1[j][k];
}
}
}
for( i = 0 ; i nsize; i++)
{
for( k= 0 ; k 1 ; k++)
{
printf(v_t_%d : %.2f \n,i+1, table3[i][k], \n );
}
}
printf(\n);
printf(**********************\n);
printf( a_t result \n);
printf(**********************\n);
for( i = 0 ; i nsize ; i++)
{
for( j= 0 ; j nsize ; j++)
{
for( k=0 ; k 1 ; k++)
{
table5[i][k] += table4[i][j] * table3[j][k];
}
}
}
for( i = 0 ; i nsize; i++)
{
for( k= 0 ; k 1 ; k++)
{
printf(a_t_%d : %.2f \n,i+1, table5[i][k], \n );
}
}

return 0;
}

void makematrix ( matrix *pmatrix , int nsize )
{
int ncnt;
pmatrix-m_pdata = (double **) malloc ( sizeof(double *) * nsize );
for ( ncnt = 0 ; ncnt nsize ; ncnt++ )
{
pmatrix-m_pdata[ncnt] = (double *) malloc ( sizeof(double) * nsize );
}
pmatrix-m_nsize = nsize;
}
void deletematrix ( matrix *pmatrix )
{
int ncnt;
for ( ncnt = 0 ; ncnt pmatrix-m_nsize ; ncnt++ )
{
free ( pmatrix-m_pdata[ncnt] );
}
free ( pmatrix-m_pdata );
}
void inputmatrix ( matrix *pmatrix )
{
int i , j;
double fget;

for ( i = 0 ; i pmatrix-m_nsize ; i++ )
{
for ( j = 0 ; j pmatrix-m_nsize ; j++ )
{
fget = sinl(((double)i+1) * (2 * m_pi) * (((double)j+1) / 32));
pmatrix-m_pdata[i][j] = fget;

}
}

}
void printmatrix ( matrix matrix )
{
int i , j;
printf( \n\n);
for ( i = 0 ; i matrix.m_nsize ; i++ )
{
printf ( );
for ( j = 0 ; j matrix.m_nsize ; j++ )
{
printf ( %2.2f , matrix.m_pdata[i][j] );
}
printf ( \n );
}
}
double getdeterminent ( matrix matrix )
{
int i;
double fdet = 0;
int nsign = 1;
if ( matrix.m_nsize == 2 )
{
fdet = matrix.m_pdata[0][0] * matrix.m_pdata[1][1] -
matrix.m_pdata[1][0] * matrix.m_pdata[0][1];
return fdet;
}
fdet = 0;
for ( i = 0 ; i matrix.m_nsize ; i++ )
{
matrix minor;
makematrix ( &minor , matrix.m_nsize );
minor = getminormatrix ( matrix , 0 , i );
fdet = fdet + nsign * matrix.m_pdata[i][0] * getdeterminent( minor ); //
&nbsbsp; nsign = nsign * (-1);
deletematrix ( &minor );
}
return fdet;
}
matrix gettransposematrix ( matrix matrix )
{
matrix res;
int i , j ;

makematrix ( &res , matrix.m_nsize );
for ( i = 0 ; i matrix.m_nsize ; i++ )
{
for ( j = 0 ; j matrix.m_nsize ; j++ )
{
res.m_pdata[i][j] = matrix.m_pdata[j][i];
}
}
return res;
}
matrix getminormatrix ( matrix matrix , int ncol , int nrow )
{
matrix res;

int i , j;
int nrowindex = 0;
int ncolindex = 0;

makematrix ( &res , matrix.m_nsize - 1 );
for ( i = 0 ; i matrix.m_nsize ; i++ )
{
for ( j = 0 ; j matrix.m_nsize ; j++ )
{
if ( i != nrow && j != ncol )
{
res.m_pdata[nrowindex][ncolindex] = matrix.m_pdata[i][j];
ncolindex++;
}
}
if ( i != nrow && j != ncol )
{
ncolindex = 0;
nrowindex++;
}
}
return res;
}
matrix getconfactormatrix ( matrix matrix )
{
matrix res;
int i , j;

makematrix ( &res , matrix.m_nsize );
for ( i = 0 ; i matrix.m_nsize ; i++ )
{
for ( j = 0 ; j matrix.m_nsize ; j++ )
{
res.m_pdata[j][i] = getdeterminent ( getminormatrix ( matrix , i , j ) );
}
}
return res;
}
matrix getadjointmatrix ( matrix matrix )
{
matrix res;
matrix confactor;
matrix transposed;
int i , j;
double ipow = 1;

makematrix ( &res , matrix.m_nsize );
makematrix ( &confactor , matrix.m_nsize );
makematrix ( &transposed , matrix.m_nsize );
confactor = getconfactormatrix ( matrix );
transposed = gettransposematrix ( confactor );
for ( i = 0 ; i matrix.m_nsize ; i++ )
{
for ( j = 0 ; j matrix.m_nsize ; j++ )
{
ipow = pow (-1, (i+j));
res.m_pdata[i][j] = ipow * transposed.m_pdata[i][j];

}
}
deletematrix ( &confactor );
deletematrix ( &transposed );
return res;
}
matrix getinversematrix ( matrix matrix )
{
matrix res;
matrix temp;
double fdet;
int i , j;
fdet = getdeterminent ( matrix );

makematrix ( &temp , matrix.m_nsize );
makematrix ( &res , matrix.m_nsize );
if(matrix.m_nsize ==2)
{
temp.m_pdata[0][0] = matrix.m_pdata[1][1];
temp.m_pdata[1][1] = matrix.m_pdata[0][0];
temp.m_pdata[0][1] = - (matrix.m_pdata[0][1]);
temp.m_pdata[1][0] = - (matrix.m_pdata[1][0]);
for ( i = 0 ; i matrix.m_nsize ; i++ )
{
for ( j = 0 ; j matrix.m_nsize ; j++ )
{
res.m_pdata[i][j] = (double)((double)1/fdet) * temp.m_pdata[i][j];
table4[i][j]= res.m_pdata[i][j];
}

}
deletematrix ( &temp );
return res;
br /sp;
}

temp = getadjointmatrix ( matrix );
for ( i = 0 ; i matrix.m_nsize ; i++ )
{
for ( j = 0 ; j matrix.m_nsize ; j++ )
{
res.m_pdata[i][j] = (double)((double)1/fdet) * temp.m_pdata[i][j];
table4[i][j]= res.m_pdata[i][j];
}
}

deletematrix ( &temp );
return res;
}

신청하기