Diba.S Ответов: 2

C программа для вычисления обратной матрицы (n*n)

Всем привет
Я пишу этот код для инверсии матрицы на языке Си .
но есть ошибка в детерминантной функции, которая говорит: "не удается преобразовать 'float' в 'float(*)[20]' для аргумента '1' в 'float determinant(float(*)[20])' "

кто-нибудь знает , в чем проблема, чтобы помочь мне?
спасибо


/* a program to calculate inverse of matrix (n*n)*/
//actually one of the way to calculate inverse of matrix is : A^(-1) = 1/|A| * C(t)     that A is matrix and c(t) is taranahade A

#include <stdio.h>;
#include <conio.h>;
#include <string.h>;
#include <stdlib.h>;

const int max=20;
int i , j , n , k , size=0 , row , column ;
float num , det=0 , inverse_matrix[max][max] , matrix[max][max] , new_mat[max][max] , m_minor[max][max] , m_Transpose[max][max];

float determinant(float matrix[max][max]);
float minor(float matrix[max][max],int k);
float Transpose(float matrix[max][max]);

int main()
{
      printf("\n What is degree of your matrix?");
      scanf("%d",&n);
      printf("\n Please entre your matrix's rooms:");

      for(i=1;i<=n;i++)
      {
         for(j=1;j<=n;j++)
         {
             printf("\n\t[ %d , %d ] = ",i,j);
             scanf("%d",&matrix[i][j]);
         }
         printf("\n");
      }
      size=n;
      det=determinant(matrix);

      if(det==0)
      {
          printf("\n\t* * * * * * * * * * * * * * * * * * * * * * * *\n\tINVERSE DOESN'T EXSIT");
          getch();
          return 0;
      }
      else
      {
          num=1/det;
          m_Transpose[n][n]=Transpose(matrix);
          printf("\n\t* * * * * * * * * * * * * * * * * * * * * * * *\n\tMATRIX REVERSE IS:\n\n\t");
          /*complex of determinant with Transpose*/
          for(i=1;i<=n;i++)
          {
               for(j=1;j<=n;j++)
               {
                    inverse_matrix[i][j]=num*m_Transpose[i][j];
                    if(inverse_matrix[i][j]&gt;=0)
                        printf("     %d",inverse_matrix[i][j]);
                    else
                        printf("     %d",inverse_matrix[i][j]);
               }
               printf("\n\t");
          }
      }


      getch();
      return 0;
}

/* calculate determinate of matrix */
float determinant(float matrix[][max])
{
      if(n==1)
             return matrix[1][1];
      else if(n==2)
           return (matrix[1][1] * matrix[2][2] - matrix[1][2] * matrix[2][1]);
      else
      {
          for(k=1;k<=n;k++)
          {
              det+=((-1)^(1+k))*matrix[1][k]*determinant(minor(matrix,k)); //error
              n=size;
          }
          return det;
      }
}

/*calculate minor of matrix and return to determinant's function*/
float minor(float matrix[][max],int k)
{
      int m=1 , p , r , c , row=1 , column;
      column=k;
      for(r=2;r<=n;r++)
      {
          p=1;
          for(c=1;c<=n;c++)
          {
              if(r!=row &amp;&amp; c!=column)
              {
                  new_mat[m][p]=matrix[r][c];
                  p++;
              }
          }
          if(r!=row)
             m++;
      }
      n--;
      return new_mat[m][p];

}

/*calculate Transpose*/
float Transpose(float matrix[][max])
{
    for(int i=1;i<=n;i++)
       for(j=1;j<=n;j++)
          m_Transpose[i][j]=matrix[j][i];
    return m_Transpose[n][n];
}

Sergey Alexandrovich Kryukov

Видимо нельзя :-). По крайней мере, добавьте комментарий к строке, где вы это делаете. Компилятор говорит вам об этом.
—СА

2 Ответов

Рейтинг:
5

Diba.S 

#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("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *");
    printf("\n* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *");
    printf("\n* * * * * *                                                       * * * * * * *");
    printf("\n* * * * * * THIS PROGRAM CALCULATE THE REVERSE OF SQUARE MATRIX ! * * * * * * *");
    printf("\n* * * * * *                                                       * * * * * * *");
    printf("\n* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *");
    printf("\n* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *");
    printf("\n\n  1 - Enter size of Matrix : ");
    scanf("%f",&size);
    printf("\n  2 - Enter the elements of  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    * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n\n\tDeterminant of the Matrix = %6.2f",d);
    if (d==0)
    {
        printf("\n\n    * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n\n\tInverse not exsist\n\n");
        printf("\n* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *");
        printf("\n* * * * * * * * * * * * * * * * * THE END * * * * * * * * * * * * * * * * * * *");
        printf("\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\t* * * * * * * * * * * * * * * * * * * * * * * \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");
     }
     printf("\n\n* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *");
     printf("\n* * * * * * * * * * * * * * * * * THE END * * * * * * * * * * * * * * * * * * *");
     printf("\n* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *");
}

Member 12480890

я делаю эту программу на c++.
и я сделал класс с именем matrix, но есть какая-то проблема с возвратом детерминанта, и я не могу понять, что это за мой код.

Member 12480890

мой код слишком велик, чтобы его можно было разместить здесь.Может кто-нибудь, пожалуйста, пришлите мне туда электронный идентификатор.
для связи со мной мой электронный идентификатор является:
junirobert21@gmail.com

Рейтинг:
0

OriginalGriff

Смотреть здесь:

float determinant(float matrix[][max])
...
det+=((-1)^(1+k))*matrix[1][k]*determinant(minor(matrix,k)); //error
...
float minor(float matrix[][max],int k)
minor возвращает float. determinant не принимает float как это параметр - вам либо придется что-то менять minor возвращает или повторно упаковывает результат во что-то determinant может принять.

Diba.S

спасибо.
но что вы имеете в виду?
незначительные возврата поплавка new_mat[][] и ввода фактором является матрица поплавок [][]

OriginalGriff

- Вы уверены?
Посмотрите на код еще раз... :смеяться:
И мы все это делаем: мы читаем то, что хотели написать...

Diba.S

:| хорошо,я вижу, что вы говорите, но не могу хорошо понять.
Итак,как насчет этого алгоритма?:
могу ли я понять проблему (и исправить ее) таким образом?!

float det1=((-1)^(1+k))*матрица[1][k];
new_mat[n][n]=минор(матрица,k);
float det2=определитель(new_mat);
det+=det1*det2;

во всяком случае, у этого способа тоже есть проблема! для всех матриц det==0 и show inverse не существует !