PROGRAM NEWTON(INPUT,OUTPUT);                     
(* BERECHNE INVERSE MATRIX ITERATIV NACH DEM    *)
(* NEWTON-VERFAHREN.                            *)
(* REELLE ARITHMETIK IN PASCAL 2.0              *)
                                                  
 CONST N=4;                                       
       MAXCOUNT = 10;                             
                                                  
 TYPE MATRIX = ARRAY[1..N,1..N] OF REAL;          
                                                  
 VAR I, J         : INTEGER;                      
     COUNT        : INTEGER;                      
     R, XT, XT1, A: MATRIX;                       
                                                  
 PROCEDURE MAL(VAR A,B,C:MATRIX);                 
 (* MATRIXMULTIPLIKATION C:= A * B              *)
  VAR I,J,K:INTEGER;                              
      S    :REAL;                                 
 BEGIN                                            
  FOR I:=1 TO N DO                                
   FOR J:=1 TO N DO                               
    BEGIN S:=0;                                   
     FOR K:=1 TO N DO                             
      S:=S+A[I,K]*B[K,J];                         
     C[I,J]:=S                                    
    END;                                          
 END; (* MAL *)                                   
                                                  
 PROCEDURE ZEIGE(VAR A:MATRIX);                   
  VAR I,J:INTEGER; C:CHAR;                        
 BEGIN                                            
  FOR I:=1 TO N DO                                
   BEGIN                                          
    FOR J:=1 TO N DO                              
     WRITE(A[I,J]:8:4);                           
    WRITELN                                       
   END;                                           
  READLN(C);                                      
 END; (* ZEIGE *)                                 
                                                  
BEGIN                                             
  WRITELN('GEBEN SIE BITTE DIE ZU INVERTIERENDE');
  WRITELN('4*4 MATRIX ZEILENWEISE EIN:');         
  WRITELN('Z.B.      5  4  1  1');                
  WRITELN('          4  5  1  1');                
  WRITELN('          1  1  4  2');                
  WRITELN('          1  1  2  4');                
                                                  
 (* ZEILENWEISE A EINLESEN *)                     
 FOR I:=1 TO N DO                                 
  BEGIN                                           
   FOR J:=1 TO N DO READ(A[I,J]);                 
   READLN                                         
  END;                                            
                                                  
 (* ANFANGSNAEHERUNG IN XT *)                     
 FOR I:=1 TO N DO                                 
  FOR J:=1 TO N DO XT[I,J]:=ORD(I=J)/20;          
 ZEIGE(XT);                                       
                                                  
 FOR COUNT:= 1 TO MAXCOUNT DO                     
  BEGIN                (* ITERATION NACH NEWTON *)
   MAL(A,XT,R);                                   
   FOR I:=1 TO N DO                               
     FOR J:=1 TO N DO                             
       IF I=J THEN R[I,J]:=2.0-R[I,J]             
              ELSE R[I,J]:=   -R[I,J];            
   MAL(XT,R,XT1);                                 
   XT:=XT1;                                       
   ZEIGE(XT);                                     
  END;                                            
END.