Comment générer deux ou plusieurs tableaux dans une fonction fortran?

Question

J'écris un programme qui calcule la décomposition LU d'une matrice, avec pivotement partiel, et je voudrais que la fonction produise plusieurs (2 ou 3) matrices sans exécuter le programme plusieurs fois pour sortir chacune individuellement, ce qui est un perte de temps car cela me procure tout ce que je veux en un seul passage. Y-a-t'il une façon de le faire? Par exemple, voici ma fonction utilisant l'algorithme de Doolittle, pour une matrice carrée qui n'a pas besoin de pivoter. Je veux que ma sortie soit matricielle et numérique à la fois, mais je ne connais aucun moyen de le faire.

function lu_d(aa) result(l) 

real, dimension (:,:) :: aa !input matrix 
real, dimension (size(aa,1), size(aa,2)) :: a !keeping input variable intact 
real, dimension (size(a,1), size(a,2)) :: l , u !lower and upper matrices 
integer :: i,j,k !index 
real :: s !auxiliar variable 

a=aa 

do j=1 , size(a,2) 
    u(1,j)=a(1,j) 
end do 

l(1,1)=1 

do j=2, size(a,2) 
    l(1,j)=0 
end do 

do i=2, size(a,1) 

    l(i,1)=a(i,1)/u(1,1) 
    u(i,1)=0 

    do j=2, i-1 

    s=0 
    u(i,j)=0 

    do k=1, j-1 
     s=s+l(i,k)*u(k,j) 
    end do 

    l(i,j)=(a(i,j)-s)/u(j,j) 

    end do 

    l(i,i)=1 

    do j=i, size(a,2) 

    s=0 
    l(i,j)=0 

    do k=1, i-1 
     s=s+l(i,k)*u(k,j) 
    end do 

    u(i,j)=a(i,j)-s 

    end do 

end do 

end function 

Answer 1

Vous pouvez passer de l'utilisation d'une fonction à l'utilisation d'un sous-programme. De cette façon, vous pouvez afficher des valeurs pour plusieurs tableaux dans la liste des arguments. De plus en utilisant la INTENT définition lors de la déclaration des variables dans le sous-programme, par exemple:

REAL,INTENT(IN)::a déclare un et ne permet pas ses valeurs à modifier l'intérieur de la sous-routine/fonction

REAL,INTENT(OUT)::b déclare b et ne tient pas compte des valeurs qu'elle a venir dans la sous-routine/fonction

REAL,INTENT(INOUT)::c c'est le cas par défaut, si vous n'écrivez rien.

Je suppose que vous avez besoin de la sortie pour être l et u (plutôt que m), auquel cas la structure ressemblerait à celle ci-dessous. Notez que l et m doivent soit être déclarés dans le programme principal et leur taille définie par rapport à aa (comme dans le premier cas illustré ci-dessous) OU déclarés avec une taille allocatable dans le programme principal, transmis au sous-programme sans être alloués et alloués dans le sous-programme (deuxième exemple). Ce dernier peut vous obliger à placer le sous-programme dans un module afin que les interfaces soient gérées correctement.

Premier exemple:

SUBROUTINE lu_d(aa,l,m) 
implicit none 
real,intent(in):: a(:,:) 
real,intent(out):: l(:,:), m(:,:) 
integer:: i,j,k 
real:: s 

<operations> 

RETURN 
END SUBROUTINE lud_d 

Deuxième exemple:

SUBROUTINE lu_d(aa,l,m) 
implicit none 
real,intent(in):: a(:,:) 
real,allocatable,intent(out):: l(:,:), m(:,:) 
integer:: i,j,k,size_a1,size_a2 
real:: s 

size_a1=size(aa,1) 
size_a2=size(aa,2) 
allocate(l(size_a1,size_a2), m(size_a1,size_a2)) 

<operations> 

RETURN 
END SUBROUTINE lud_d