Hoe matrices werken in numerieke berekeningen en hoe ze te manipuleren met Fortran

In numerieke berekeningen speelt het werken met matrices een cruciale rol, vooral bij het oplossen van lineaire algebraïsche problemen. Matrices worden vaak gebruikt voor het representeren van gegevens, het uitvoeren van lineaire transformaties en het oplossen van systemen van lineaire vergelijkingen. In dit hoofdstuk zullen we enkele basisbewerkingen met matrices behandelen, zoals transponeren, vermenigvuldigen en het genereren van identiteitsmatrices, evenals de implementatie van deze bewerkingen in Fortran.

fortran
Copy code
PROGRAM TransposeMatrix
  INTEGER A(10,10), B(10,10)
  WRITE(*,*)'ENTER THE NO.OF ROWS(M) & COLUMNS(N)'
  READ(*,*)M,N
  WRITE(*,*)'ENTER THE MATRIX(ROW WISE)'
  DO I=1,M
    READ(*,*)(A(I,J),J=1,N)
  END DO
  WRITE(*,*)'THE MATRIX IS'
  DO I=1,M
    WRITE(*,*)(A(I,J),J=1,N)
  END DO
  DO I=1,N
    DO J=1,M
      B(I,J)=A(J,I)  ! Interchanging rows and columns
    END DO
  END DO
  WRITE(*,*)'THE TRANSPOSE MATRIX IS'
  DO I=1,N
    WRITE(*,*)(B(I,J),J=1,M)  ! Displaying the transposed matrix
  END DO
  STOP
END

Een andere veelgebruikte bewerking met matrices is matrixvermenigvuldiging. Bij matrixvermenigvuldiging moeten we ervoor zorgen dat het aantal kolommen in de eerste matrix gelijk is aan het aantal rijen in de tweede matrix. Het resultaat van de vermenigvuldiging is een nieuwe matrix waarvan de dimensies afhangen van de invoermatrices.

Stel dat matrix A een dimensie heeft van m × n en matrix B een dimensie van n × l. Het resultaat van A × B is een matrix C met dimensies m × l. Om de elementen van de matrix C te berekenen, gebruiken we de volgende formule:

Dit betekent dat elk element van de matrix C wordt berekend door de overeenkomstige rij van A te vermenigvuldigen met de overeenkomstige kolom van B en de producten op te tellen. Het volgende Fortran-programma implementeert deze vermenigvuldiging:

fortran
Copy code
PROGRAM MatrixMultiplication
  INTEGER A(10,10), B(10,10), C(10,10)
  WRITE(*,*)'ENTER ROW & COLUMN NOS OF THE 1ST MATRIX'
  READ(*,*)N1,M1
  WRITE(*,*)'ENTER ROW & COLUMN NOS OF THE 2ND MATRIX'
  READ(*,*)N2,M2
  WRITE(*,*)'ENTER THE 1ST MATRIX'
  DO I=1,N1
    READ(*,*)(A(I,J),J=1,M1)
  END DO
  WRITE(*,*)'ENTER THE 2ND MATRIX'
  DO I=1,N2
    READ(*,*)(B(I,J),J=1,M2)
  END DO
  WRITE(*,*)'THE PRODUCT IS'
  DO I=1,N1
    DO J=1,M2
      C(I,J)=0
      DO K=1,M1
        C(I,J) = C(I,J) + A(I,K) * B(K,J)
      END DO
    END DO
  END DO
  DO I=1,N1
    WRITE(*,*)(C(I,J),J=1,M2)
  END DO
  STOP
END

Naast transponeren en vermenigvuldigen van matrices is het ook vaak nodig om een identiteitsmatrix te genereren. Dit is een vierkante matrix waarvan de diagonale elementen gelijk zijn aan 1, en alle andere elementen gelijk zijn aan 0. De identiteitsmatrix speelt een belangrijke rol bij het oplossen van lineaire systemen en het berekenen van de inverse van een matrix. Hieronder volgt een eenvoudig Fortran-programma om een identiteitsmatrix te genereren:

fortran
Copy code
PROGRAM IdentityMatrix
  INTEGER A(3,3)
  DO I=1,3
    DO J=1,3
      A(I,J) = 0
    END DO
    A(I,I) = 1
  END DO
  WRITE(*,*)'An identity matrix'
  DO I=1,3
    WRITE(*,*) (A(I,J),J=1,3)
  END DO
  STOP
END

Wanneer we werken met numerieke berekeningen, kunnen er kleine rekenfouten optreden, vooral bij het werken met matrices die zijn verkregen uit numerieke methoden. Bij het controleren of een matrix de identiteitsmatrix is, moet men rekening houden met rekenfouten. Dit kan bijvoorbeeld door een kleine tolerantiewaarde in te stellen, zodat getallen die heel dicht bij 1 of 0 liggen, maar niet exact, nog steeds als respectievelijk 1 of 0 worden beschouwd.

De limieten van matrixdimensies in Fortran hangen af van de compiler en de beschikbare geheugenruimte. Hoewel Fortran in staat is om zeer grote matrices te verwerken, wordt het belangrijk om de limieten van de hardware te begrijpen. Het programma kan maximaal 7 dimensies verwerken, maar bij het werken met grote matrices kunnen de prestaties en de verwerkingstijd een beperking vormen.

Wat verder van belang is bij het werken met matrices in Fortran, is dat de manier waarop gegevens worden ingevoerd belangrijk kan zijn voor de efficiëntie van de bewerkingen. Het is bijvoorbeeld essentieel te begrijpen hoe matrices op het geheugen van de computer worden opgeslagen, bijvoorbeeld row-major of column-major order. Dit heeft invloed op de snelheid van toegang en manipulatie van de matrixelementen.

Hoe kunnen complexe wortels van een polynoom worden gevonden met behulp van de Bairstow-methode?

De Bairstow-methode is een krachtige techniek voor het vinden van complexe wortels van een polynoom. In het bijzonder is deze methode handig voor polynomen van hogere graad, waarbij de wortels niet gemakkelijk direct kunnen worden berekend. De methode maakt gebruik van een iteratief proces, waarbij de polynoom wordt gefactoriseerd in een product van quadratische factoren, zodat de wortels systematisch kunnen worden bepaald.

Bij het toepassen van de Bairstow-methode wordt de oorspronkelijke polynoom $p(x)$ gerepresenteerd als het product van een quadratische factor $(x^2 - ux - v)$ en een andere polynoom $q(x)$ van lagere graad. Het doel is om de parameters $u$ en $v$ van deze quadratische factor te berekenen, zodat de factorisatie correct is.

De iteratie gaat als volgt: eerst worden de coëfficiënten van het quotientenpolynoom $q(x)$ berekend, op basis van de oorspronkelijke coëfficiënten van de polynoom en de waarden van $u$ en $v$. Vervolgens worden de coëfficiënten van de afgeleiden van dit quotientenpolynoom $b_i$ en $c_i$ gebruikt om de correcties $\Delta u$ en $\Delta v$ te berekenen. Na elke iteratie worden de waarden van $u$ en $v$ aangepast en gecontroleerd of ze voldoende zijn geconvergeerd. Dit iteratieve proces wordt herhaald totdat de waarden van $u$ en $v$ niet langer significant veranderen, wat betekent dat de juiste waarden voor de wortels zijn gevonden.