123 Eng

Engineering the engineers™


Latest Jobs   Forum Map

 


Home
Source Codes
Engineering Colleges

Training  Reports
Seminar Reports
Placement Papers

Forums

   Computer Science / IT
   Electronics
   Electrical
   Mechanical
   Chemical
   Civil

   CAT / MBA

   GMAT / Foreign MBA
Latest Jobs

Engineering Jobs / Technical Jobs
Management Jobs

Sitemap
Terms of use

Displaying  Source Code(s)  
 

 
Determinant of matrix

--------------------------------------------------------------------------------

Description : Program to calculate the determinant of a matrix of any order using a recursive function.

#include <stdio.h>
#include <conio.h>
#include <math.h>

// A square matrix struct
typedef struct
{
int order;
int **array;

} SQRMATRIX;

// Function declarations
int CreateMatrix( SQRMATRIX *p, int order );
void DisplayMatrix( SQRMATRIX *p );
void InputMatrix( SQRMATRIX *p );
int CalcMinor( SQRMATRIX *p, SQRMATRIX *minor, int row, int col );
int CalcDeterminant( SQRMATRIX *p );
void DestroyMatrix( SQRMATRIX *p );

// main( )
int main( )
{
SQRMATRIX p;
int order;

printf("Enter order of matrix: ");
scanf("%d", &order );

if( !CreateMatrix( &p, order ))
{
printf("Matrix couldn't be created.");
return 0;
}

printf("Matrix created.
<BR>);
InputMatrix( &p );

printf("
The matrix is:<BR>);
DisplayMatrix( &p );

printf("
The determinant of the matrix is: %d", CalcDeterminant( &p
));

getch( );
return 0;
}

// Create matrix of specified order
int CreateMatrix( SQRMATRIX *p, int order )
{
int i;

if( order < 1 )
return 0;

p->order = order;
p->array = (int**) malloc( order * sizeof( int* )); // Allocate space
for
each row

if( !p->array )
return 0;

for( i=0; i < order; i++ )
{
p->array[i] = (int*) malloc( order* sizeof( int )); // Allocate
space
for each column
if( !p->array )
return 0;
}
return 1;
}

// Print matrix in proper format
void DisplayMatrix( SQRMATRIX *p )
{
int i,j;

if( p->order < 1 )
return;

for( i = 0; i < p->order; i++ )
{
for( j = 0; j < p->order; j++ )
printf("%5d ", p->array[i][j] );

printf("<BR>);
}
}

// Input matrix from user
void InputMatrix( SQRMATRIX *p )
{
int i,j;

for( i = 0; i < p->order; i++ )
for( j = 0; j < p->order; j++ )
{
printf("Enter element at ( %d, %d ): ", i+1, j+1 );
scanf("%d", &p->array[i][j] );
}
}

/* Calculate the 'minor' of the given matrix at given position.
The minor is the matrix formed by deleting the specified row
and column from the matrix.
*/

int CalcMinor( SQRMATRIX *p, SQRMATRIX *minor, int row, int col )
{
int i,j,a,b;

if( p->order <= 1 )
return 0;

if( row >= p->order || col >= p->order )
return 0;

if( !CreateMatrix( minor, p->order-1 ))
return 0;

a = b = 0;

for( i = 0; i < p->order; i++ )
{
if( i != row )
{
b = 0;
for( j = 0; j < p->order; j++ )
{
if( j != col )
{
minor->array[a][b] = p->array[i][j];
b++; // Increase column-count of minor
}
}
a++; // Increase row-count of minor
}
}

return 1;
}

/* Calculate the determinant recursively.
The recursive definition is :
det( m ) = Summation( i = 0 to order ) [ (-1)^i * m[0][i] * det(
minor( m[0][i] ))]
*/
int CalcDeterminant( SQRMATRIX *p )
{
int i, result = 0, temp;
SQRMATRIX minor;

if( p->order < 1 )
{
printf("CalcDeterminant( ) : Invalid matrix.");
return 0;
}

// The 'stopping' condition
if( p->order == 1 )
return p->array[0][0];

for( i = 0; i < p->order; i++ )
{
if( !CalcMinor( p, &minor, 0, i ))
{
printf("CalcDeterminant( ) : Memory allocation failed.");
return 0;
}

result += ( pow( -1, i ) * p->array[0][i] * CalcDeterminant( &minor
));

DestroyMatrix( &minor );
}

return result;
}
// Release allocated memory
void DestroyMatrix( SQRMATRIX *p )
{
int i;

if( p->order < 1 )
return;

for( i = 0; i < p->order; i++ )
free( p->array[i] ); // free each columns

free( p->array ); // free each row
p->order = 0;
}
 

 

 

Contribute content or training reports / feedback / Comments
job placement papers
All rights reserved copyright 123ENG