수다닷컴

행렬을 입력 받아서
행렬을 절대값,
lowertrigangular 행렬,
upper triangular 행렬,
lowertrigangular행렬 곱하기 upper triangular행렬,
주어진 행렬의 역행렬을 구하는 프로그램입니다.

잘될 때도 있는대 가끔 오버 플로우가 뜨고요
지금은 n by n인데
3by3, 4by4으로 어떻게 바꾸나요???

#include stdio.h
#include stdlib.h static double
Determinant(double** matrixA, int uesrN);static int
LUFactorization(double** matrixA, double** matrixB, int userN);static int
MultiplicationMatrix(double** matrixA, double** matrixB, double** resultMatrix,
int userN);static int
FindMatrixD(double** matrixL, double* matrixD, int count, int userN);static int
FindMatrixX(double** matrixU, double* matrixD, double* matrixX, int userN);int
main(void)
{
int userN = 0;
int userM = 0;
int row = 0;
int column = 0;double determinantResult = 0;double* matrixD;
double* matrixX;double** matrixA;
double** matrixL = 0;
double** matrixM = 0;
double** matrixInverseA = 0;printf(n by n = );
scanf(%d, &userN);userM = userN - 1;matrixD = (double*)malloc(sizeof(double) * userN);
matrixX = (double*)malloc(sizeof(double) * userN);matrixA = (double**)malloc(sizeof(double*) * userN);
matrixL = (double**)malloc(sizeof(double*) * userN);
matrixM = (double**)malloc(sizeof(double*) * userN);
matrixInverseA = (double**)malloc(sizeof(double*) * userN);for (row = 0; row userN; row++)
{
matrixA[row] = (double*)malloc(sizeof(double) * userN);
matrixL[row] = (double*)malloc(sizeof(double) * userN);
matrixM[row] = (double*)malloc(sizeof(double) * userN);
matrixInverseA[row] = (double*)malloc(sizeof(double) * userN);
} for (row = 0; row userN; row++)
{
matrixL[row][row] = 1;
}for (row = 0; row userN; row++)
{
for (column = 0; column userN; column++)
{
printf(%d , %d =, row, column);
scanf(%lf, &matrixA[row][column]);
}
}
printf(\nA =\n);for (row = 0; row userN; row++)
{
for (column = 0; column userN; column++)
{
printf(%10.5lf , matrixA[row][column]);
if (column % userN == userM)
{
printf(\n);
}
}
}determinantResult = Determinant(matrixA, userN);
printf(\n|A| = %.5g\n, determinantResult);if (!determinantResult)
{
printf(\nNo determinant(A)\n);
}
else
{
LUFactorization(matrixA, matrixL, userN ); printf(\nL =\n);
for (row = 0; row userN; row++)
{
for (column = 0; column userN; column++)
{
printf(%10.5lf , matrixL[row][column]);
if(column % userN == userM)
{
printf(\n);
}
}
} printf(\nU =\n);
for (row = 0; row userN; row++)
{
for (column = 0; column userN; column++)
{
printf(%10.5lf , matrixA[row][column]);
if(column % userN == userM)
{
printf(\n);
}
}
}
MultiplicationMatrix(matrixL, matrixA, matrixM, userN);
printf(\nLU =\n);
for (row = 0; row userN; row++)
{
for (column = 0; column userN; column++)
{
printf(%10.5lf , matrixM[row][column]);
if(column % userN == userM)
{
printf(\n);
}
}
} for(row = 0; row userN; row ++)
{
FindMatrixD(matrixL, matrixD, row, userN);
FindMatrixX(matrixA, matrixD, matrixX, userN);
for (column = 0; column userN; column++)
{
matrixInverseA[column][row] = matrixX[column];
}
} printf(\ninv(A) =\n);
for (row = 0; row userN; row++)
{
for (column = 0; column userN; column++)
{
printf(%10.5lf , matrixInverseA[row][column]);
if (column % userN == userM)
{
printf(\n);
}
}
}
} for (row = 0; row userN; row++)
{
free(matrixA[row]);
free(matrixL[row]);
free(matrixM[row]);
free(matrixInverseA[row]);
}free(matrixA);
free(matrixL);
free(matrixM);
free(matrixInverseA);return 0;
}
static double
Determinant (double** matrixA, int userN)
{
int userM = 0;
int counter = 0;
int determinantACheck = 0;
int determinantARow = 0;
int determinantAColumn = 0;
int sign = 1;double determinantResult = 0;
double** matrixDeterminantA;userM = userN - 1;matrixDeterminantA = (double**)malloc(sizeof(double*) * userM);
for (counter = 0; counter userM; counter++)
{
matrixDeterminantA[counter] = (doub = (double*)malloc(sizeof(double) * userM);
} if (userN == 2)
{
determinantResult = (matrixA[0][0] * matrixA[1][1]) -
(matrixA[0][1] * matrixA[1][0]);
}else
{
for (counter = 0; counter userN; counter++)
{
for (determinantARow = 0; determinantARow userM;
determinantARow++)
{
determinantACheck = 0;
for (determinantAColumn = 0; determinantAColumn userM;
determinantAColumn++)
{
if (determinantAColumn == counter)
{
determinantACheck++;
}
matrixDeterminantA[determinantARow][determinantAColumn] =
matrixA[determinantARow + 1][determinantACheck];
determinantACheck++;
}
} if (counter % 2 == 1)
{
sign = -1;
}
else
{
sign = 1;
} determinantResult += sign * matrixA[0][counter] *
Determinant(matrixDeterminantA,userM);
}
}
for(counter = 0; counter userM; counter++)
{
free(matrixDeterminantA[counter]);
}
free(matrixDeterminantA);return determinantResult;
}
static int
LUFactorization(double** matrixU, double** matrixL, int userN)
{
int row = 0;
int column = 0;
int count = 0;
double division=0;//
for (count = 0; count (userN - 1); count++)
{
for (row = count; row (userN -1); row++)
{
division = matrixU[row + 1][count] / matrixU[count][count];
for (column = 0; column userN; column++)
{
matrixU[row + 1][column] -= division * matrixU[count][column];
}
matrixL[row + 1][count] = division;
}
} return 0;
}static int
MultiplicationMatrix(double** matrixA, double** matrixB, double** resultMatrix,
int userN)
{
int row = 0;
int column = 0;
int check = 0;for (row = 0; row userN; row++)
{
for (column = 0; column userN; column++)
{
for (check = 0; check userN; check++)
{
resultMatrix[row][column] += matrixA[row][check] *
matrixB[check][column];
}
}
} return 0;
}static int
FindMatrixD(double** matrixL, double* matrixD,int count, int userN)
{
int row = 0;
int column = 0;double sum = 0;
double* matrixI = 0;matrixI = (double*)malloc(sizeof(double) * userN);
matrixI[count] = 1;matrixD[0] = matrixI[0] / matrixL[0][0];for (row = 1; row userN; row++)
{
sum = matrixI[row];
for (column = 0 ; column row; column++)
{
sum -= ( matrixL[row][column] * matrixD[column] );
}
matrixD[row] = sum / matrixL[row][row];
}return 0;
}
static int
FindMatrixX(double** matrixU, double* matrixD, double* matrixX, int userN)
{
int row = 0;
int column = 0;double sum = 0;matrixX[userN - 1] = matrixD[userN - 1] / matrixU[userN - 1][userN - 1];for (row = (userN - 2); row = 0; row--)
{
sum = matrixD[row];
for (column = (userN - 1); column row; column--)
{
sum -= (matrixU[row][column] * matrixX[column]);
}
matrixX[row] = sum / matrixU[row][row];
}
return 0;
}

신청하기