EXECUTE "RESTORE " + v$

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

float determinant(float[25][25],float);
void cofactor(float[25][25],float);
void transpose(float[25][25],float[25][25],float);

int main()
{
   float matrix[25][25],size,d;
   int i,j;

   printf("\n\n  1 - Size of Matrix : ");
   scanf("%f",&size);
   printf("\n  2 - Enter the elements of the Matrix : \n");
   for (i=0;i<size;i++)>
   {
       for (j=0;j<size;j++)>
       {
            printf("\n\t[ %d , %d ] = ",i,j);
            scanf("%f",&matrix[i][j]);
       }
       printf("\n");
   }
   d=determinant(matrix,size);
   printf("\n\n\tDeterminant of the Matrix = %6.2f",d);
   if (d==0)
   {
       printf("\n\tInverse does not exsist\n\n");
   }
   else
       cofactor(matrix,size);
   getch();
}

/*For calculating Determinant of the Matrix . this function is recursive*/
float determinant(float matrix[25][25],float size)
{
   float s=1,det=0,m_minor[25][25];
   int i,j,m,n,c;
   if (size==1)
   {
       return (matrix[0][0]);
   }
   else
   {
       det=0;
       for (c=0;c<size;c++)>
       {
           m=0;
           n=0;
           for (i=0;i<size;i++)>
           {
               for (j=0;j<size;j++)>
               {
                   m_minor[i][j]=0;
                   if (i != 0 && j != c)
                   {
                      m_minor[m][n]=matrix[i][j];
                      if (n<(size-2))
                         n++;
                      else
                      {
                          n=0;
                          m++;
                      }
                   }
               }
           }
           det=det + s * (matrix[0][c] * determinant(m_minor,size-1));
           s=-1 * s;
       }
   }

   return (det);
}

/*calculate cofactor of matrix*/
void cofactor(float matrix[25][25],float size)
{
    float m_cofactor[25][25],matrix_cofactor[25][25];
    int p,q,m,n,i,j;
    for (q=0;q<size;q++)>
    {
        for (p=0;p<size;p++)>
        {
            m=0;
            n=0;
            for (i=0;i<size;i++)>
            {
                for (j=0;j<size;j++)>
                {
                    if (i != q && j != p)
                    {
                       m_cofactor[m][n]=matrix[i][j];
                       if (n<(size-2))
                          n++;
                       else
                       {
                           n=0;
                           m++;
                       }
                    }
                }
            }
            matrix_cofactor[q][p]=pow(-1,q + p) * determinant(m_cofactor,size-1);
        }
    }
    transpose(matrix,matrix_cofactor,size);
}

/*Finding transpose of cofactor of matrix*/
void transpose(float matrix[25][25],float matrix_cofactor[25][25],float size)
{
    int i,j;
    float m_transpose[25][25],m_inverse[25][25],d;

    for (i=0;i<size;i++)>
    {
        for (j=0;j<size;j++)>
        {
            m_transpose[i][j]=matrix_cofactor[j][i];
        }
    }
    d=determinant(matrix,size);
    for (i=0;i<size;i++)>
    {
        for (j=0;j<size;j++)>
        {
            m_inverse[i][j]=m_transpose[i][j] / d;
        }
    }
    printf("\n\n\tThe inverse of matrix is : \n\n");

    for (i=0;i<size;i++)>
    {
        for (j=0;j<size;j++)>
        {
            printf("\t%3.2f",m_inverse[i][j]);
        }
        printf("\n\n");
    }
}

#include<stdio.h>
#include<math.h>
float determinant(float [][25], float);
void cofactor(float [][25], float);
void transpose(float [][25], float [][25], float);
int main()
{
 float a[25][25], k, d;
 int i, j;
 printf("Enter the order of the Matrix : ");
 scanf("%f", &k);
 printf("Enter the elements of %.0fX%.0f Matrix : \n", k, k);
 for (i = 0;i < k; i++)
   {
    for (j = 0;j < k; j++)
      {
       scanf("%f", &a[i][j]);
       }
   }
 d = determinant(a, k);

 if (d == 0)
  printf("\nInverse of Entered Matrix is not possible\n");
 else{
  printf("\nDeterminant of Matrix is %4f : ",d);
  cofactor(a, k);}
}

/*For calculating Determinant of the Matrix */
float determinant(float a[25][25], float k)
{
 float s = 1, det = 0, b[25][25];
 int i, j, m, n, c;
 if (k == 1)
   {
    return (a[0][0]);
   }
 else
   {
    det = 0;
    for (c = 0; c < k; c++)
      {
       m = 0;
       n = 0;
       for (i = 0;i < k; i++)
         {
           for (j = 0 ;j < k; j++)
             {
               b[i][j] = 0;
               if (i != 0 && j != c)
                {
                  b[m][n] = a[i][j];
                  if (n < (k - 2))
                   n++;
                  else
                   {
                    n = 0;
                    m++;
                    }
                  }
              }
            }
         det = det + s * (a[0][c] * determinant(b, k - 1));
         s = -1 * s;
         }
   }

   return (det);
}

void cofactor(float num[25][25], float f)
{
float b[25][25], fac[25][25];
int p, q, m, n, i, j;
for (q = 0;q < f; q++)
{
  for (p = 0;p < f; p++)
   {
    m = 0;
    n = 0;
    for (i = 0;i < f; i++)
    {
      for (j = 0;j < f; j++)
       {
         if (i != q && j != p)
         {
           b[m][n] = num[i][j];
           if (n < (f - 2))
            n++;
           else
            {
              n = 0;
              m++;
              }
           }
       }
     }
     fac[q][p] = pow(-1, q + p) * determinant(b, f - 1);
   }
 }
 transpose(num, fac, f);
}
/*Finding transpose of matrix*/
void transpose(float num[25][25], float fac[25][25], float r)
{
 int i, j;
 float b[25][25], inverse[25][25], d;

 for (i = 0;i < r; i++)
   {
    for (j = 0;j < r; j++)
      {
        b[i][j] = fac[j][i];
       }
   }
 d = determinant(num, r);
 for (i = 0;i < r; i++)
   {
    for (j = 0;j < r; j++)
      {
       inverse[i][j] = b[i][j] / d;
       }
   }
  printf("\n\n\nThe inverse of matrix is : \n");

  for (i = 0;i < r; i++)
   {
    for (j = 0;j < r; j++)
      {
        printf("\t%f", inverse[i][j]);
       }
   printf("\n");
    }
}

static MMFLOAT* alloc1df (int n)
{
//    int i;
   MMFLOAT* array;
   if ((array = (MMFLOAT*) GetMemory(n * sizeof(MMFLOAT))) == NULL) {
       error("Unable to allocate memory for 1D float array...\n");
       exit(0);
   }

//    for (i = 0; i < n; i++) {
//        array[i] = 0.0;
//    }

   return array;
}

static MMFLOAT** alloc2df (int m, int n)
{
   int i;
   MMFLOAT** array;
   if ((array = (MMFLOAT **) GetMemory(m * sizeof(MMFLOAT*))) == NULL) {
       error("Unable to allocate memory for 2D float array...\n");
       exit(0);
   }

   for (i = 0; i < m; i++) {
       array[i] = alloc1df(n);
   }

   return array;
}

static void dealloc2df (MMFLOAT** array, int m, int n)
{
   int i;
   for (i = 0; i < m; i++) {
       FreeMemorySafe((void *)&array[i]);
   }

   FreeMemorySafe((void *)&array);
}

/*Finding transpose of cofactor of matrix*/
void transpose(MMFLOAT **matrix,MMFLOAT **matrix_cofactor,MMFLOAT **newmatrix, int size)
{
   int i,j;
   MMFLOAT d;
MMFLOAT **m_transpose=alloc2df(size,size);

   for (i=0;i<size;i++)
   {
       for (j=0;j<size;j++)
       {
           m_transpose[i][j]=matrix_cofactor[j][i];
       }
   }
   d=determinant(matrix,size);
   for (i=0;i<size;i++)
   {
       for (j=0;j<size;j++)
       {
           newmatrix[i][j]=m_transpose[i][j] / d;
       }
   }

dealloc2df(m_transpose,size,size);
}
/*calculate cofactor of matrix*/
void cofactor(MMFLOAT **matrix,MMFLOAT **newmatrix,int size)
{
MMFLOAT **m_cofactor=alloc2df(size,size);
MMFLOAT **matrix_cofactor=alloc2df(size,size);
   int p,q,m,n,i,j;
   for (q=0;q<size;q++)
   {
       for (p=0;p<size;p++)
       {
           m=0;
           n=0;
           for (i=0;i<size;i++)
           {
               for (j=0;j<size;j++)
               {
                   if (i != q && j != p)
                   {
                      m_cofactor[m][n]=matrix[i][j];
                      if (n<(size-2))
                         n++;
                      else
                      {
                          n=0;
                          m++;
                      }
                   }
               }
           }
           matrix_cofactor[q][p]=pow(-1,q + p) * determinant(m_cofactor,size-1);
       }
   }
   transpose(matrix, matrix_cofactor, newmatrix, size);
dealloc2df(m_cofactor,size,size);
dealloc2df(matrix_cofactor,size,size);

}
/*For calculating Determinant of the Matrix . this function is recursive*/
MMFLOAT determinant(MMFLOAT **matrix,int size)
{
  MMFLOAT s=1,det=0;
  MMFLOAT **m_minor=alloc2df(size,size);
  int i,j,m,n,c;
  if (size==1)
  {
      return (matrix[0][0]);
  }
  else
  {
      det=0;
      for (c=0;c<size;c++)
      {
          m=0;
          n=0;
          for (i=0;i<size;i++)
          {
              for (j=0;j<size;j++)
              {
                  m_minor[i][j]=0;
                  if (i != 0 && j != c)
                  {
                     m_minor[m][n]=matrix[i][j];
                     if (n<(size-2))
                        n++;
                     else
                     {
                         n=0;
                         m++;
                     }
                  }
              }
          }
          det=det + s * (matrix[0][c] * determinant(m_minor,size-1));
          s=-1 * s;
      }
  }
  dealloc2df(m_minor,size,size);
  return (det);
}
tp = checkstring(cmdline, "M_INVERSE");
if(tp){
void *ptr1 = NULL;
void *ptr2 = NULL;
int i, j, n, numcols=0, numrows=0;
MMFLOAT *a1float=NULL, *a2float=NULL,det;
getargs(&tp, 3,",");
if(!(argc == 3)) error("Argument count");
ptr1 = findvar(argv[0], V_FIND | V_EMPTY_OK | V_NOFIND_ERR);
if(vartbl[VarIndex].type & T_NBR) {
if(vartbl[VarIndex].dims[2] != 0) error("Invalid variable");
if(vartbl[VarIndex].dims[1] <= 0) { // Not an array
error("Argument 1 must be a numerical 2D array");
}
if(vartbl[VarIndex].dims[0] <= 0) { // Not an array
error("Argument 1 must be a numerical 2D array");
}
numcols=vartbl[VarIndex].dims[0] - OptionBase;
numrows=vartbl[VarIndex].dims[1] - OptionBase;
a1float = (MMFLOAT *)ptr1;
if((uint32_t)ptr1!=(uint32_t)vartbl[VarIndex].val.s)error("Syntax");
} else error("Argument 1 must be a numerical 2D array");
ptr2 = findvar(argv[2], V_FIND | V_EMPTY_OK | V_NOFIND_ERR);
if(vartbl[VarIndex].type & T_NBR) {
if(vartbl[VarIndex].dims[2] != 0) error("Invalid variable");
if(vartbl[VarIndex].dims[1] <= 0) { // Not an array
error("Argument 2 must be a numerical 2D array");
}
if(vartbl[VarIndex].dims[0] <= 0) { // Not an array
error("Argument 2 must be a numerical 2D array");
}
if(numcols!=vartbl[VarIndex].dims[0] - OptionBase)error("array size mismatch");
if(numrows!=vartbl[VarIndex].dims[1] - OptionBase)error("array size mismatch");
a2float = (MMFLOAT *)ptr2;
if((uint32_t)ptr2!=(uint32_t)vartbl[VarIndex].val.s)error("Syntax");
} else error("Argument 2 must be a numerical 2D array");
if(numcols!=numrows)error("Array must be square");
n=numrows+1;
MMFLOAT **matrix=alloc2df(n,n);
for(i=0;i<n;i++){ //load the matrix
for(j=0;j<n;j++){
matrix[j][i]=*a1float++;
}
}
det=determinant(matrix,n);
if(det==0.0){
dealloc2df(matrix,numcols,numrows);
error("Determinant of array is zero");
}
MMFLOAT **matrix1=alloc2df(n,n);
cofactor(matrix, matrix1, n);
for(i=0;i<n;i++){ //load the matrix
for(j=0;j<n;j++){
*a2float++=matrix1[j][i];
}
}
dealloc2df(matrix,numcols,numrows);
dealloc2df(matrix1,numcols,numrows);

return;
}