home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 449b.lha / Matrix_v1.0 / src / PAL / MatrixI.c < prev   
Encoding:
C/C++ Source or Header  |  1990-12-02  |  5.7 KB  |  230 lines
  1.  /********************************************************************/
  2.  /****                                                            ****/
  3.  /****                                                            ****/
  4.  /****    Program          : MatrixI.c                            ****/
  5.  /****                                                            ****/
  6.  /****    Version          : 01.00                                ****/
  7.  /****                                                            ****/
  8.  /****    Erstversion      : 01.07.1990                           ****/
  9.  /****                                                            ****/
  10.  /****    Letzte Änderung  : 08.08.1990                           ****/
  11.  /****                                                            ****/
  12.  /****    Compiliert mit   : siehe MAKEFILE                       ****/
  13.  /****                                                            ****/
  14.  /****    Gelinkt mit      : siehe MAKEFILE                       ****/
  15.  /****                                                            ****/
  16.  /********************************************************************/
  17.  /****                                                            ****/
  18.  /****                                                            ****/
  19.  /****               Copyright by Rüdiger Dreier                  ****/
  20.  /****                                                            ****/
  21.  /****                                                            ****/
  22.  /********************************************************************/
  23.  
  24.  /* Einbinden der Include-Files */
  25.  #include <exec/types.h>
  26.  #include <string.h>
  27.  #include <stdlib.h>
  28.  #include <stdio.h>
  29.  #include <math.h>
  30.  
  31.  LONG Zeilen,MZeilen;
  32.  LONG Spalten,MSpalten;
  33.  
  34.  DOUBLE Zeile[20];
  35.  DOUBLE MatrixE[20][20];
  36.  DOUBLE MatrixL[20][20];
  37.  DOUBLE MatrixA[20][20];
  38.  char NULLSpalte[20];
  39.  
  40.  SHORT Loesen(VOID)
  41.   {
  42.    SHORT i,l,Loesbarkeit,Ziel=0;
  43.    
  44.    MZeilen=Zeilen;
  45.    MSpalten=0;
  46.    
  47.    /* Erster Schritt: Alle NullSpalten eliminieren und merken */
  48.    for(i=0;i<Spalten;i++)
  49.     {
  50.      if(!NullSpalte(i))
  51.       {
  52.        NULLSpalte[i]=0;
  53.        for(l=0;l<Zeilen;l++)
  54.         {
  55.          MatrixL[l][MSpalten]=MatrixE[l][i];
  56.         }
  57.        MSpalten++;
  58.       }
  59.      else
  60.       {
  61.        NULLSpalte[i]=1;
  62.       }
  63.     }
  64.    
  65.    /* Zweiter Schritt: Lösen */
  66.    Loesbarkeit=MLoesen();
  67.    
  68.    for(i=0;i<Spalten;i++)
  69.     {
  70.      for(l=0;l<Zeilen;l++)
  71.       {
  72.        MatrixA[l][i]=0.0; /* Löschen */
  73.       }
  74.     }
  75.    /* Dritter Schritt: NullSpalten wieder herstellen */
  76.    for(i=0;i<MSpalten;i++)
  77.     {
  78.      if(NULLSpalte[i])
  79.       {
  80.        Ziel++;
  81.       }
  82.      for(l=0;l<Zeilen;l++)
  83.       {
  84.        MatrixA[l][Ziel]=MatrixL[l][i];
  85.       }
  86.      Ziel++;
  87.     }
  88.    return(Loesbarkeit);
  89.   }
  90.  
  91.  SHORT MLoesen(VOID)
  92.   {
  93.    SHORT k,flag=0,i,akt,mn;
  94.    DOUBLE HILFE,HILFE2;
  95.    
  96.    mn=min(MZeilen,MSpalten-1)-1;
  97.    for(k=0;k<mn;k++)
  98.     {
  99.      if(MatrixL[k][k]==NULL)flag=Tauschen(k);
  100.      
  101.      if(MatrixL[k][k]!=NULL)
  102.       {
  103.        /* Alle weiteren MZeilen in der aktuellen Spalte auf NULL bringen */
  104.        HILFE =MatrixL[k][k];
  105.        for(akt=0;akt<MZeilen;akt++)
  106.         {
  107.          if(akt!=k)
  108.           {
  109.            HILFE2=MatrixL[akt][k];
  110.            for(i=0;i<MSpalten;i++)
  111.             {
  112.              MatrixL[akt][i]=MatrixL[akt][i]*HILFE-MatrixL[k][i]*HILFE2;
  113.             }
  114.           }
  115.         }
  116.       }
  117.     }
  118.    if(MatrixL[k][k]==NULL)Tauschen(k);
  119.    
  120.    if(MatrixL[k][k]!=NULL)
  121.     {
  122.      HILFE =MatrixL[k][k];
  123.      for(akt=0;akt<MZeilen;akt++)
  124.       {
  125.        if(akt!=k)
  126.         {
  127.          HILFE2=MatrixL[akt][k];
  128.          for(i=0;i<MSpalten;i++)
  129.           {
  130.            MatrixL[akt][i]=MatrixL[akt][i]*HILFE-MatrixL[k][i]*HILFE2;
  131.           }
  132.         }
  133.       }
  134.     }
  135.    /* Diagonale auf 1 bringen */
  136.    for(k=0;k<MZeilen;k++)
  137.     {
  138.      if(MatrixL[k][k]!=NULL)
  139.       {
  140.        for(i=k+1;i<MSpalten;i++)
  141.         {
  142.          MatrixL[k][i]/=MatrixL[k][k];
  143.         }
  144.        MatrixL[k][k]=1.00;
  145.       }
  146.     }
  147.    /* Die Gleichung ohne NullSpalten ist evt. eindeutig lösbar, */
  148.    /* die mit Nullspalten aber auf gar keinen Fall              */
  149.    if(MZeilen>=MSpalten-1)
  150.     {
  151.      flag=NULL;
  152.     }
  153.    else 
  154.     {
  155.      flag=2; /* Nicht eindeutig lösbar */
  156.     }
  157.    if(MSpalten<Spalten)flag=2; /* Es gab NullSpalten */
  158.    
  159.    mn=min(MZeilen+1,MSpalten)-1;
  160.    for(k=0;k<mn;k++)
  161.     {
  162.      SHORT flag2;
  163.      flag2=1;
  164.      if(MatrixL[k][k]==NULL && MatrixL[k][MSpalten-1]!=NULL)
  165.       {
  166.        for(i=k+1;i<MSpalten-1;i++)
  167.         {
  168.          /* Das Diagonalelement kann zwar NULL sein, es kann aber sein, daß */
  169.          /* noch ein weiteres Element != NULL vorhanden ist.                */
  170.          if(MatrixL[k][i]!=NULL)
  171.           {
  172.            flag2=2;
  173.           }
  174.         }
  175.        flag=flag2; /* DiagonalElement der Matrix 0, Element des LösungsVektor !=0 */
  176.        if(flag==1)break; /* Nicht mehr lösbar */
  177.       }
  178.      if(MatrixL[k][k]==NULL && MatrixL[k][MSpalten-1]==NULL)
  179.       {
  180.        flag= 2; /* Beide Elemente = 0 */
  181.       }
  182.     }
  183.    for(k=mn;k<MZeilen;k++)
  184.     {
  185.      /* Alle Zeilen, die nicht mehr in der Diagonalen enthalten sind, */
  186.      /* müssen ganz NULL sein, sonst nicht lösbar.                    */
  187.      if(MatrixL[k][MSpalten-2]==NULL && MatrixL[k][MSpalten-1]!=NULL)
  188.       {
  189.        flag= 1;
  190.       }
  191.     }
  192.    return(flag);
  193.   }
  194.  
  195.  
  196.  SHORT Tauschen(SHORT k)
  197.   {
  198.    SHORT flag,l,i;
  199.    DOUBLE HILFE;
  200.    /* Tauschen */
  201.    flag=1;
  202.    
  203.    for(l=k+1;l<MZeilen;l++)
  204.     {
  205.      if(MatrixL[l][k]!=NULL)
  206.       {
  207.        for(i=0;i<MSpalten;i++)
  208.         {
  209.          HILFE=MatrixL[l][i];
  210.          MatrixL[l][i]=MatrixL[k][i];
  211.          MatrixL[k][i]=HILFE;
  212.          flag=0;
  213.         }
  214.        l=MZeilen;
  215.       }
  216.     }
  217.    return(flag);
  218.   }
  219.  
  220.  SHORT NullSpalte(SHORT k)
  221.   {
  222.    SHORT i,fl=1;
  223.    for(i=0;i<Zeilen;i++)
  224.     {
  225.      if(MatrixE[i][k]!=0.0)fl=0;
  226.     }
  227.    return(fl);
  228.   }
  229.  
  230.