Projet Fortran90 [ERREUR DE SEGMENTATION)

Bonjour,
Mon binome et moi sommes sur un projet (écrit en fortran 90). Le but est de résoudre Ax=b, tout en fesant varier b afin de trouver le minimum et le maximum d'un vecteur égal aux 15 premières valeurs du vecteur x.
Le programme compile mais à l'execution le résultat est incohérent (Tmin > Tmax) en particulier lors que j varie de -50 à 50...
De plus, une erreur de segmentation ne cesse de s'afficher à la fin de l'execution (alors que l'allocation et la désallocation ont réussi).
Pouvez vous nous aidez? C'est assez urgent, voici le programme et le module:
Merci d'avance en tout cas!
Bonne journée :lol:

Programme:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
 
Program etude_libre
use grue_mod
	Implicit none
 
	integer:: n=18,h=15, m=7
	real::c,N1,N2,N3,N4,N5,N6,N7,N8,N9, Fx,Fy,Ry,Sx,Sy, omega, eps=1.E-4, Nmax, Nmin
	integer:: i,j,k,kmax=10, p
	real, dimension(:,:), allocatable ::A,L,U
	real, dimension(:), allocatable::b,x,y,r,e,tension, Tmax, Tmin
 
 
	allocate (A(n,n), L(n,n),U(n,n),b(n),y(n),x(n),tension(n),Tmax(n),Tmin(n), r(n), e(n))
	b=(/Fx,Fy,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0./)
	c=sqrt(2.)/2.	
	!Fy
	b(2)=-1000	
 
!Affichage de A
	!print*
	!print*,'Matrice A'
	A=0
	A(1,1)=1; A(3,3)=1; A(4,4)=1; A(5,3)=1; A(6,6)=1; A(9,9)=1; A(11,11)=1; A(13,11)=1; 
	A(12,12)=1; A(16,12)=1; A(14,14)=1; A(18,14)=1; A(15,15)=1
	A(17,15)=1; A(16,16)=1; A(17,17)=1; A(18,18)=1;
 
	A(12,9)=-1; A(6,1)=-1; A(7,4)=-1; A(10,6)=-1;
 
	A(1,2)=c; A(2,2)=c; A(3,2)=c; A(5,5)=c; A(6,5)=c; A(7,7)=c; A(9,7)=c; A(7,8)=c; 
	A(8,8)=c; A(9,10)=c; A(10,10)=c; A(13,13)=c; A(14,13)=c;
	A(15,13)=c; A(16,13)=c; A(13,10)=c
 
	A(4,2)=-c; A(7,5)=-c; A(8,5)=-c; A(8,7)=-c; A(10,7)=-c; A(11,8)=-c; A(12,8)=-c; A(14,10)=-c
 
	!do i=1,n
		!write(*,fmt='(20f8.2)') (A(i,j),j=1,n)
		!print*
	!end do
 
 
 
	do j=-50,50
 
		b(1)=j
 
!Décomposition
		!print*, "----------Décomposition LU----------"
 
		CALL DECOMPOSITION(n,A,L,U)
		!print*, 'Matrice L'
		!do i=1,n 
			!write(*,fmt='(20f8.2)')(L(i,p),p=1,n)
			!print*
		!end do
 
 
		!print*	
		!print*, 'Matrice U'
		!do i=1,n
			!write(*,fmt='(20f8.2)')(U(i,j),j=1,n)
			!print*
		!end do
 
!Descente
		!print*, "----------Descente pour obtenir le vecteur de passage----------"		
		CALL DESCENTE(n,L,b,y)
		!print*, 'vecteur y=(', y, ')' 
		!print*
		!print*
 
 
!Remontée
 
		!print*,"----------Remontée pour obtenir le vecteur cherché----------"
		CALL REMONTEE(n,U,Y,x)
		!print*, 'On obtient le vecteur x:'
		!print*
 
 
 
		do i=1,n
			print*, x(i)
		end do
 
		print*
		print*, 'VECTEUR TENSION'
 
		do i=1,15
			tension(i)=x(i)
			print*, tension(i)
		end do
 
		Tmax(j)= maxval(x)
		Tmin(j)= minval(x)
		print*
		print*, "valeurs tmax(" ,j,")", Tmax(j)
		print*, "valeurs tmin(" ,j,")",Tmin(j)
 
	end do
 
 
	print*, "Tmax"
	do i=1,n
		write(*,fmt='(20f8.2)')(Tmax(i))
	end do
 
	print*
	print*, "Tmin"
	do i=1,n
		write(*,fmt='(20f8.2)')(Tmin(i))
	end do
 
	print*
	Nmax=maxval(Tmax)
	Nmin=minval(Tmin)
 
	print*, 'Nmax=', Nmax
	print*, 'Nmin=', Nmin
 
 
	deallocate(A,L,U)
	deallocate(b, y, x, r, tension, Tmax, Tmin, r, e)	
 
end program etude_libre

MODULE

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
MODULE grue_mod
 
	IMPLICIT NONE
	CONTAINS
 
	SUBROUTINE DECOMPOSITION(n,A,L,U)
		INTEGER, INTENT(IN)::n
		REAL, DIMENSION(n,n),INTENT(IN)::A
		REAL, DIMENSION(n,n),INTENT(OUT)::L
		REAL, DIMENSION(n,n),INTENT(OUT)::U
		REAL::s
		INTEGER::i,j,k
 
			DO j=1,n
			L(j,j)=1.
				DO i=1,j
					s=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
 
				DO i=j+1,n
					s=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
			END DO
	END SUBROUTINE DECOMPOSITION
 
 
	SUBROUTINE DESCENTE(n,L,b,y)
		INTEGER, INTENT(IN)::n
		REAL, DIMENSION(n,n),INTENT(IN)::L
		REAL, DIMENSION(n), INTENT(IN)::b
		REAL, DIMENSION(n), INTENT(OUT)::y
		REAL::s
		INTEGER::i,j
 
			DO i=1,n
				s=0.
				DO j=1,i-1
					s=s+L(i,j)*y(j)
				END DO
				y(i)=(b(i)-s)/L(i,i)
			END DO
	END SUBROUTINE DESCENTE
 
 
	SUBROUTINE REMONTEE(n,U,y,x)
		INTEGER, INTENT(IN)::n
		REAL, DIMENSION(n,n),INTENT(IN)::U
		REAL, DIMENSION(n), INTENT(IN)::y
		REAL, DIMENSION(n), INTENT(OUT)::x
		REAL::s
		INTEGER::i,j
 
			DO i=n,1,-1
				s=0.
				DO j=i+1,n
					s=s+U(i,j)*x(j)
				END DO
				x(i)=(y(i)-s)/U(i,i)
			END DO
	END SUBROUTINE REMONTEE
 
 
 
 
	real function norme1(r)
		real,dimension(:),intent(in)::r
 
		norme1=sum(abs(r))
 
	end function norme1
 
 
 
	SUBROUTINE SOR(omega,A,r,e)
		REAL,INTENT(IN) ::omega
		REAL,DIMENSION(:,:), INTENT(IN) ::A
		REAL,DIMENSION(:), INTENT(IN) :: r
		REAL,DIMENSION(:), INTENT(OUT) :: e
 
		REAL:: s
		INTEGER:: i,j,n
 
		n=SIZE(A,1)
		DO I=1,N
			s=0.
			DO j=1,i-1
				s=s+A(i,j)*e(j)
			END DO
		e(i)=omega*(r(i)-s)/A(i,i)
		END DO
	END SUBROUTINE SOR
 
 
 
 
 
 
END MODULE grue_mod

EXECUTION:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
valeurs tmax( 50 ) 2600.
 valeurs tmin( 50 ) -2550.
 Tmax
 2502.00
 2504.00
 2506.00
 2508.00
 2510.00
 2512.00
 2514.00
 2516.00
 2518.00
 2520.00
 2522.00
 2524.00
 2526.00
 2528.00
 2530.00
 2532.00
 2534.00
 2536.00
 
 Tmin
 2550.00
 2552.00
 2554.00
 2556.00
 2558.00
 2560.00
 2562.00
 2564.00
 2566.00
 2568.00
 2570.00
 2572.00
 2574.00
 2576.00
 2578.00
 2580.00
 2582.00
 2584.00
 
 Nmax= 2536.
 Nmin= 2550.
Erreur de segmentation