08.10.2022

k20:k20.6:k20.6.1:start

Project 2 is based on the following task: calculating the adjoints of a (square) matrix via Laplace's evolution theorem.

This solution idea was developed: When calculating the adjoints of a matrix - as transpose of the co-factor matrix - a large number of sub-determinants (minors) must be calculated, which generally have nothing to do with each other. The task is broken down into n subtasks for calculating sub-determinants.

This proposal for implementation arose from the solution idea:

- List itemIn the task class, a Main() function is declared where the same algorithm can be used for all calculations of the sub-determinants:

Public Function Main() As Variant '-- Calculate array of sub-determinants... Return aFloatArray End

- In the (main) programme, a separate task is started in each case in a FOR-NEXT control structure, in which n sub-determinants are calculated. The processing of the n sub-tasks is delegated to one task each! The individual tasks are started sequentially, but then all run in parallel. Unfortunately, this will hardly be noticed in practice because the calculations - even for a matrix of dimension 30 - are so short on modern computers.
- If all n sub-determinants are calculated, then the adjoints are calculated from the n partial solutions and output.

The following specifications apply:

- 2 arguments are passed to each of the tasks.
- The tasks are passed both the matrix on which they are to work and the specific row in which all co-factors are to be determined as arguments when they are created (_new() in the task class).
- Only the function value of the main method (data type Variant) in the Task_Kill() event is read out with LAST.Value after the automatic termination of the tasks and temporarily stored in a matrix.

The source texts for the task class and the main programme are given in full. The above solution idea is implemented in them. First, the content of the task class is presented - stored in the file TaskMinors.class:

' Gambas class file '-- This class calculates the minors of the specified matrix when the specified row has been deleted. '-- The function value is an appropriately sized float array of the individual determinants. Inherits Task Property Tag As Variant Private $hMatrix As Matrix Private $vTag As Variant Private $iRow As Integer Public Sub _new({Matrix} As Matrix, Row As Integer) $hMatrix = {Matrix} $iRow = Row End ' _new(..) Public Function Main() As Variant Dim hMinor As New Matrix($hMatrix.Width - 1, $hMatrix.Width - 1) Dim iRemCol, iSrcRow, iSrcCol, iDstRow, iDstCol As Integer Dim aFloatArray As New Float[] For iRemCol = 0 To hMinor.Width '-- Untermatrix aufbauen iDstRow = 0 For iSrcRow = 0 To hMinor.Height If iSrcRow = $iRow Then Continue iDstCol = 0 For iSrcCol = 0 To hMinor.Width If iSrcCol = iRemCol Then Continue hMinor[iDstRow, iDstCol] = $hMatrix[iSrcRow, iSrcCol] Inc iDstCol Next Inc iDstRow Next aFloatArray.Add(hMinor.Det()) Next Return aFloatArray '-- The function value is of the data type float array End Private Function Tag_Read() As Variant Return $vTag End Private Sub Tag_Write(Value As Variant) $vTag = Value End

File MMain.module:

' Gambas module file ' -- Dimension of a random square matrix (d > 1) Const Dimension As Integer = 15 '-- Maximum 30 Private $hMatrix As Matrix Private $hAdjugate As Matrix Private $iTasks As Integer Public Sub Main() Dim iRow, iCol As Integer Dim hDet As TaskMinors Dim hOther As Matrix '-- Create matrix of the given dimension with random elements $hMatrix = RandomMatrix() Print "Matrix:";; $hMatrix.ToString() $hAdjugate = New Matrix($hMatrix.Width, $hMatrix.Height) $iTasks = 0 For iRow = 0 To $hMatrix.Height – 1 '-- k task are created For iCol = 0 To $hMatrix.Width - 1 '-- Calculate all minors when deleting row iRow hDet = New TaskMinors($hMatrix, iRow) As "TaskMinors" hDet.Tag = iRow Inc $iTasks '-- Counts the started tasks Next '-- The tasks are started after their instantiation at the next call of the event loop. So that '-- not to start them all at once, let each individual task start via WAIT. Wait Next '-- Wait for the calculation of the adjoints (-->> Minor_Kill()) While $iTasks '-- As long as calculations are still being made ... Wait 0.001 '-- ...wait 0.001 seconds Wend Print "Adjunkte adj(A):";; $hAdjugate.ToString() '-- Display adjuncts End Public Sub TaskMinors_Kill() Dim iRow, iCol As Integer Dim aDet As Float[] = Last.Value iRow = Last.Tag For iCol = 0 To aDet.Max '-- The adjoints is the transpose of the co-factor matrix. $hAdjugate[iCol, iRow] = IIf(Even(iRow + iCol), 1, -1) * aDet[iCol] Next Dec $iTasks '-- Decrease the number of tasks by 1 End Public Function RandomMatrix() As Matrix Dim hMatrix As New Matrix(Dimension, Dimension, False) Dim iRow, iCol As Integer For iRow = 0 To hMatrix.Height - 2 hMatrix[iRow, 0] = Rnd(0, hMatrix.Height + 1) For iCol = 1 To hMatrix.Width - 1 hMatrix[iRow, iCol] = IIf(iRow = iCol, iRow + 1, hMatrix.Height) Next Next For iCol = 0 To hMatrix.Width - 1 hMatrix[hMatrix.Height - 1, iCol] = Rnd(0, hMatrix.Width + 1) Next Return hMatrix '-- Provide matrix with random elements End

This was output to the IDE console for a calculation with dimension 3:

Matrix:

[[0.13973 | 3 | 3] ; [0.60071 | 2 | 3] ; [2.73226 | 0.28943 | 2.89609]]

Adjunkte adj(A):

[[4.92387 | -7.81996 | 3] ; [6.45708 | -7.79211 | 1.38293] ; [-5.29066 | 8.15636 | -1.52266]]

Note that with matrices of higher dimension (>10) rounding errors already have a very strong effect on the result. The identity adj(A) = det(A)∙A^(-1) provides a more precise calculation of the adjoints.

The website uses a temporary session cookie. This technically necessary cookie is deleted when the browser is closed. You can find information on cookies in our privacy policy.

k20/k20.6/k20.6.1/start.txt · Last modified: 22.10.2023 by emma

Except where otherwise noted, content on this wiki is licensed under the following license: CC Attribution-Noncommercial 3.0 Unported