Discussion :

[bourgui78]

Bonjour,

j'ai écris un prog qui fonctionne seulement si le nombre de boucle est limitée.
Je m'explique.
Voici le code au complet :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
#!/usr/bin/python
# -*- coding:Latin-1 *-*
 
from mst.GUM.complex.gum import *
from math import pi
 
import sys
import os
import numpy
import Tkinter
import tkFileDialog
import win32com.client
 
class messageOk(Tkinter.Tk):
  def __init__(self,parent,message):
    Tkinter.Tk.__init__(self,parent)
    self.parent = parent
    Tkinter.Label(self,text=message).grid(column=0,row=0)
    Tkinter.Button(self,text=u"Ok",command=self.ButtonOkClick).grid(column=0,row=1)
 
  def ButtonOkClick(self):
    self.destroy()
 
#------------------------------------------------------------------------------------
# Sélection des fichiers de mesure des diamètres et sélection du répertoire
# d'enregistrement des résultats de la matrice S de la ligne
#------------------------------------------------------------------------------------
if __name__ == "__main__":
  app = messageOk(None,message="""Si vous avez choisi les fichiers correspondant aux petits
  et grands diamètres, alors cliquer sur Ok """)
  filePetitDiam = tkFileDialog.askopenfilename(filetypes = [("Fichier texte", "*.txt"),("Fichier Texte","*.txt")],
                                               title = 'Sélection du fichier des petits diamètres')
  #print filePetitDiam
  fileGrandDiam = tkFileDialog.askopenfilename(filetypes = [("Txt", "*.txt"),("Fichier Texte","*.txt")],
                                               title = 'Sélection du fichier des grands diamètres')
  #print fileGrandDiam
  directMatS = tkFileDialog.asksaveasfilename(initialdir='T:\Mesure dimensionnelle Paramètre S\Programme Python',
                                             filetypes = [("Txt", "*.txt"),("Fichier Texte","*.txt")],
                                             title = "Sélection du fichier pour l'enregistrement de la matrice S de la ligne")
  #print directMatS
  app.title('Choix des fichiers')
  app.mainloop()
#------------------------------------------------------------------------------------
#Gestion du fichiers des enregistrements des données de la matrice S de la ligne
#------------------------------------------------------------------------------------
 
try :
  os.remove(directMatS) # Suppression du fichier s'il existe
  print u"le fichier a été supprimé"
except :
  print u"erreur de suppression du fichier ou fichier n'existe pas ", directMatS
try:
  matSFile = open(directMatS,'a') # Création du fichier et ouverture en mode ajout
  print u"le fichier a été créé"
except:
  print u"erreur de création du fichier ", directMatS
print ""
#------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------
# Programme général
#------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------
ex = Context()
_J_ = ex.constant(0+1j)
#------------------------------------------------------------------------------------
# Gestion des fichiers des mesures des diamètres
#------------------------------------------------------------------------------------
diamAFile = open(filePetitDiam,'r')
diamBFile = open(fileGrandDiam,'r')
diamAListe = diamAFile.readlines() #données extraites du fichier des petits diamètres
listeDiamA = map(float,diamAListe)
diamBListe = diamBFile.readlines() #données extraites du fichier des grands diamètres
listeDiamB = map(float,diamBListe)
diamListe =[]
diamListe.append(listeDiamA)
diamListe.append(listeDiamB)
 
 
#------------------------------------------------------------------------------------
# Caractéristique de la ligne
#------------------------------------------------------------------------------------
valLongueur = raw_input("QUELLE EST LA LONGUEUR DE LA LIGNE A CARACTERISER EN CM ?")
clongueur = float(valLongueur)*1e-2
print ""
valdeltaL = raw_input("QUELLE EST LA DISTANCE ENTRE CHAQUE MESURE DE DIAMETRE EN MM ?")
cdeltaL = float(valdeltaL)*1e-3
print ""
#------------------------------------------------------------------------------------
# Question de configuration de la mesure
#------------------------------------------------------------------------------------
print u"Entrer les valeurs des fréquences, svp."
print ""
startF = raw_input('FREQUENCE DE DEPART : ( cliquer sur <ENTER> pour valider ) ')
print ""
stopF = raw_input('FREQUENCE DE FIN : ( cliquer sur <ENTER> pour valider ) ')
print ""
pasF = raw_input('INTERVALLE ENTRE CHAQUE FREQUENCE : ( cliquer sur <ENTER> pour valider ) ')
print ""
#---------------------------------------------------------------
# Transformation ou non des données entrèe en float
#---------------------------------------------------------------
listechglobal = ['k','m','g']
#---------------------------------------------------------------
#       Fréquence de départ
#---------------------------------------------------------------
lcStartF = len(startF)-1
try:
    startF = float(startF)
    valFdeb = startF
except ValueError:
    valFdeb = float(startF[:-1])*(10**( 3*(listechglobal.index(startF[-1].lower())+1)) ) \
              if startF[-1].lower() in listechglobal else 'Erreur en entrée'
 
#---------------------------------------------------------------
#       Fréquence de fin
#---------------------------------------------------------------
lcStopF = len(stopF)-1
try:
    stopF = float(stopF)
    valFfin = stopF
except ValueError:
    valFfin = float(stopF[:-1])*(10**( 3*(listechglobal.index(stopF[-1].lower())+1)) ) \
              if stopF[-1].lower() in listechglobal else 'Erreur en entrée'
 
#---------------------------------------------------------------
#       Pas de la mesure
#---------------------------------------------------------------
lcPasF = len(pasF)-1
try:
    pasF = float(pasF)
    valFpas = pasF
except ValueError:
    valFpas = float(pasF[:-1])*(10**( 3*(listechglobal.index(pasF[-1].lower())+1)) ) \
              if pasF[-1].lower() in listechglobal else 'Erreur en entrée'
 
#---------------------------------------------------------------
#       Bilan des fréquences
#---------------------------------------------------------------
if valFdeb > valFfin :
    print u'La fréquence de départ est supérieure à la fréquence de fin donc le programme inverse les deux fréquences.'
    valStartF = valFfin
    valStopF = valFdeb
else :
    valStartF = valFdeb
    valStopF = valFfin
 
nbMesure = int(((valStopF-valStartF)/valFpas)) + 1
 
print u'Valeur de la fréquence de départ :', valStartF, u'Hz.'
print u'Valeur de la fréquence de fin :', valStopF, u'Hz.'
print u'Valeur du pas de la mesure :', valFpas, u'Hz.', u'Il y aura ', nbMesure, u'points de mesures.'
 
espcol = ""
espcol = "\n"
gamStopF = valStopF + valFpas # gamme (début, fin(valeur non atteinte, pas)
gammeF = range(int(valStartF),int(gamStopF),int(valFpas))
#-----------------------------------------------------------------------------------
# Calcul de la matrice S d'une ligne 
# et enregistrement de ces données dans le fichier d'enregistrement
#------------------------------------------------------------------------------------
matSFile.write(espcol)
nomcol = ""
valcol = ""
nomcol = 'Fréquence en Hz' + "\t" + 'Matrice S11' + "\t" + 'Matrice S12' + "\t" + 'Matrice S21' + "\t" + 'Matrice S22' + "\n"
matSFile.write(nomcol)
raw_input ('POUR CONTINUER : ( cliquer sur <ENTER> ) ')
#------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------
# Calcul des caractéristiques d'une ligne à air
# avec pertes en fonction de la fréquence
#------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------
print ""
print u'Le calcul de la matrice S par fréquence va commencer.'
print ""
for f in gammeF:
  print u'La fréquence en cours est :', f, u'Hz'
  print ""
  # ----------------------------------------------------------------------------------
  # Détermination de la matrice identité de départ pour les calculs de la matrice ABCD
  # ----------------------------------------------------------------------------------    
  ind = numpy.matrix([[1,0],[0,1]])
  matprec = ind
 
  # ------------------------------------------------------------------------------------
  # Boucle à partir des données extraites des fichiers (calculs en fonction des diamètres)
  # ------------------------------------------------------------------------------------
  for vdiamA,vdiamB in zip(listeDiamA,listeDiamB):    
    #------------------------------------------------------------------------------------
    # Données mesurées pour les calculs qui suivent
    #------------------------------------------------------------------------------------
    diamA = ex.gaussian(vdiamA*1e-3, uAbsolute(0.02e-3)) # Petit diamètre
    diamB = ex.gaussian(vdiamB*1e-3, uAbsolute(0.02e-3)) # Grand diamètre
    deltaL = ex.gaussian(cdeltaL, uAbsolute(0.5e-3)) # Pas de mesure
    #------------------------------------------------------------------------------------
    # Calcul des caractéristiques d'une ligne à air sans pertes
    #------------------------------------------------------------------------------------
    a = diamA/2 # Petit rayon
    b = diamB/2 # Grand rayon
    c = 299792458 # Célérité
    mu = ex.constant(4*pi*1e-7) # Perméabilité
    E0 = 1/mu/c**2 # Permittivité dans le vide
    E = 1.000649*E0 # Permittivité dans le matériau
    rho = ex.constant(22e-9) # Résistivité
    r = b/a # Rapport des rayons
    F1 = (r**2-1)/(2*log(r))
    F2 = (r)*log(r)/(r+1)
    F0 = F1-F2-0.5*(r+1)
    L0 = mu*log(r)/2/pi # Inductance linéique sans perte
    C0 = 2*pi*E/log(r) # Capacité linéique sans perte
    Z0 = sqrt(L0/C0) # Impédance Z0
    #------------------------------------------------------------------------------------
    # Calcul des caractéristiques d'une ligne à air avec pertes
    #------------------------------------------------------------------------------------
    w = 2*pi*f              #pulsation
    #print 'w =',value(w)
    k = w*sqrt(L0*C0)      #nombre d'onde angulaire
    #print 'k =',result(k)
    d1 = 2*rho/w/mu
    #print 'd1 =', result(d1)
    d2 = sqrt(d1)
    #print 'd2 =',result (d2)
    ds = sqrt(2*rho/w/mu)   #épaisseur de peau
    #print 'épaisseur de peau de ligne : ds=',result(ds)
    d0 = ds*(1+r)/(4*b*log(r))
    #print "d0 = ", result(d0)
    R = 2*w*L0*d0*(1-k**2*a**2*F0/2)     #résistance linéique
    #print 'Résistance linéique R =', result(R)
    L = L0*(1+2*d0*(1-k**2*a**2*F0/2))   #inductance linéique
    #print 'Inductance linéique L =',result(L)
    G = w*C0*d0*k**2*a**2*F0             #conductance linéique
    #print 'Conductance linéique G =',result(G)
    C = C0*(1+d0*k**2*a**2*F0)           #capacité linéique
    #print 'Capacité linéique C=',result(C)
    Zc = sqrt((R+((L*w)*1j))/(G+((C*w)*1j)))     #impédance caractéristique
    #print 'Impédance caractéristique Zc =',result(Zc)
    gamma = sqrt((R+((L*w)*1j))*(G+((C*w)*1j)))  #constante de propagation
    #print 'Constante de propagation Gamma =',result(gamma)
    #------------------------------------------------------------------------------------
    # Détermination de la Matrice ABCD de la ligne
    #------------------------------------------------------------------------------------
    coef = gamma*deltaL
    A = cosh(coef)
    B = sinh(coef)*Zc
    C = sinh(coef)/Zc
    D = cosh(coef)
    ABCDprec = numpy.matrix([[A,B],[C,D]]) #Création de la matrice ABCD d'un élément de la ligne
    ABCD = matprec*ABCDprec
    matprec = ABCD
    #print 'ABCD=',value(ABCD)
  #-----------------------------------------------------------------------------------------
  # Calcul de la matrice S de la ligne à partir de la matrice ABCD de la ligne
  #-----------------------------------------------------------------------------------------
  Zref = 50
  Afinal = ABCD[0,0]
  Bfinal = ABCD[0,1]
  Cfinal = ABCD[1,0]
  Dfinal = ABCD[1,1]
  Scoef = 1/((Bfinal+Cfinal*Zref*Zref)+(Afinal*Zref+Dfinal*Zref))
  print 'Scoef pour la matrice S=',value(Scoef)
  tempS11 = Bfinal-Cfinal*Zref*Zref+Afinal*Zref-Dfinal*Zref
  tempS12 = 2*Zref*(Afinal*Dfinal-Bfinal*Cfinal)
  tempS21 = 2*Zref
  tempS22 = Bfinal-Cfinal*Zref*Zref-Afinal*Zref+Dfinal*Zref
  #-----------------------------------------------------------------------------------------
  # Calcul des valeurs de la matrice S
  #-----------------------------------------------------------------------------------------
  matS11 =Scoef*tempS11
  matS12 =Scoef*tempS12
  matS21 =Scoef*tempS21
  matS22 =Scoef*tempS22
  matS = numpy.matrix([[matS11,matS12],[matS21,matS22]]) # Création de la matrice S sans la multiplication par le coef
  #-----------------------------------------------------------------------------------------
#  print 'Résultat de la matrice S de la ligne'
  #-----------------------------------------------------------------------------------------
  print 'matS_11 finale = ', result(matS[0,0])
  print 'matS_12 finale = ', result(matS[0,1])
  print 'matS_21 finale = ', result(matS[1,0])
  print 'matS_22 finale = ', result(matS[1,1])
  print '                                 -------------------------------                       '
  #-----------------------------------------------------------------------------------------
  # Formatage de l'écriture en sortie
  #-----------------------------------------------------------------------------------------
 
  valcol = str(value(f)) + "\t" + str(value(matS11)) + str(numpy.array2string(numpy.array(ex.uncertainty(matS11)).ravel())) \
           + "\t" + str(value(matS12))  + str(numpy.array2string(numpy.array(ex.uncertainty(matS12)).ravel())) + "\t" + \
           str(value(matS21))  + str(numpy.array2string(numpy.array(ex.uncertainty(matS21)).ravel())) + "\t" + \
           str(value(matS22))  + str(numpy.array2string(numpy.array(ex.uncertainty(matS22)).ravel())) + "\n"
  matSFile.write(valcol)
 
matSFile.close()
MiseEnPage = raw_input('Les calculs sont finis. Cliquer sur <ENTER> pour Lancer la mise en page du fichier.')
macroExcelFile = 'T:\Mesure dimensionnelle Paramètre S\Programme Python\Test Macro.xls'
 
filepath = os.path.abspath(macroExcelFile) # Always make sure you use an absolute path !
 
excel = win32com.client.Dispatch('Excel.Application')
excel.Visible = True
workbook = excel.Workbooks.Open(filepath)
finMiseEnPage = raw_input('Quand la macro est finie, cliquer sur <ENTER>.')
excel.Quit()

vDiamA et vDiamB comportent 125 valeurs chacunes, j'ai donc 125 boucles (si =5 ça fonctionne)
en fait j'ai ajouté de l'affichage pour voir où le programme ralentissait.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

print 'Scoef pour la matrice S=',value(Scoef)

: affichage ok

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 print 'matS_11 finale = ', result(matS[0,0])

: Affichage de matS_11 finale, mais pas de la valeur.
et au bout d'un certain temps... le programme se ferme, sans avoir rien fait.
D'où cela peut-il venir ? j'ai essayé sur 3 pc, dont les ram sont différentes, j'utilise 1.5g de ram soit 25%, et ça plante encore
merci pour votre aide.

Patricia

[eyquem]

On veut bien être sympa, mais c'est limite moquerie ce genre de post.
Ce n'est pas évident de comprendre ce que fait un programme à partir de son code, tu réalises ?
On ne peut pas avoir une explication préalable, une visite guidée d'introduction, des petites remarques judicieuses ? C'est trop difficile à faire ?
Tiens, au passage, tu as mis combien de temps par exemple pour écrire ton programme tel qu'il est là ?
Je veux bien regarder ça, mais il faudrait aider un peu quand même, faut pas pousser.

[bourgui78]

je ne voulais pas t'énerver ! je multiplie 125 matrices entre elles d'où le numpy.matrix
pour plus de clarté voici la partie qui plante

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
for f in gammeF:
  print u'La fréquence en cours est :', f, u'Hz'
  print ""
  # ----------------------------------------------------------------------------------
  # Détermination de la matrice identité de départ pour les calculs de la matrice ABCD
  # ----------------------------------------------------------------------------------    
  ind = numpy.matrix([[1,0],[0,1]])
  matprec = ind
 
  # ------------------------------------------------------------------------------------
  # Boucle à partir des données extraites des fichiers (calculs en fonction des diamètres)
  # ------------------------------------------------------------------------------------
  for vdiamA,vdiamB in zip(listeDiamA,listeDiamB):    
    #------------------------------------------------------------------------------------
    # Données mesurées pour les calculs qui suivent
    #------------------------------------------------------------------------------------
    diamA = ex.gaussian(vdiamA*1e-3, uAbsolute(0.02e-3)) # Petit diamètre
    diamB = ex.gaussian(vdiamB*1e-3, uAbsolute(0.02e-3)) # Grand diamètre
    deltaL = ex.gaussian(cdeltaL, uAbsolute(0.5e-3)) # Pas de mesure
    #------------------------------------------------------------------------------------
    # Calcul des caractéristiques d'une ligne à air sans pertes
    #------------------------------------------------------------------------------------
    a = diamA/2 # Petit rayon
    b = diamB/2 # Grand rayon
    c = 299792458 # Célérité
    mu = ex.constant(4*pi*1e-7) # Perméabilité
    E0 = 1/mu/c**2 # Permittivité dans le vide
    E = 1.000649*E0 # Permittivité dans le matériau
    rho = ex.constant(22e-9) # Résistivité
    r = b/a # Rapport des rayons
    F1 = (r**2-1)/(2*log(r))
    F2 = (r)*log(r)/(r+1)
    F0 = F1-F2-0.5*(r+1)
    L0 = mu*log(r)/2/pi # Inductance linéique sans perte
    C0 = 2*pi*E/log(r) # Capacité linéique sans perte
    Z0 = sqrt(L0/C0) # Impédance Z0
    #------------------------------------------------------------------------------------
    # Calcul des caractéristiques d'une ligne à air avec pertes
    #------------------------------------------------------------------------------------
    w = 2*pi*f              #pulsation
    #print 'w =',value(w)
    k = w*sqrt(L0*C0)      #nombre d'onde angulaire
    #print 'k =',result(k)
    d1 = 2*rho/w/mu
    #print 'd1 =', result(d1)
    d2 = sqrt(d1)
    #print 'd2 =',result (d2)
    ds = sqrt(2*rho/w/mu)   #épaisseur de peau
    #print 'épaisseur de peau de ligne : ds=',result(ds)
    d0 = ds*(1+r)/(4*b*log(r))
    #print "d0 = ", result(d0)
    R = 2*w*L0*d0*(1-k**2*a**2*F0/2)     #résistance linéique
    #print 'Résistance linéique R =', result(R)
    L = L0*(1+2*d0*(1-k**2*a**2*F0/2))   #inductance linéique
    #print 'Inductance linéique L =',result(L)
    G = w*C0*d0*k**2*a**2*F0             #conductance linéique
    #print 'Conductance linéique G =',result(G)
    C = C0*(1+d0*k**2*a**2*F0)           #capacité linéique
    #print 'Capacité linéique C=',result(C)
    Zc = sqrt((R+((L*w)*1j))/(G+((C*w)*1j)))     #impédance caractéristique
    #print 'Impédance caractéristique Zc =',result(Zc)
    gamma = sqrt((R+((L*w)*1j))*(G+((C*w)*1j)))  #constante de propagation
    #print 'Constante de propagation Gamma =',result(gamma)
    #------------------------------------------------------------------------------------
    # Détermination de la Matrice ABCD de la ligne
    #------------------------------------------------------------------------------------
    coef = gamma*deltaL
    A = cosh(coef)
    B = sinh(coef)*Zc
    C = sinh(coef)/Zc
    D = cosh(coef)
    ABCDprec = numpy.matrix([[A,B],[C,D]]) #Création de la matrice ABCD d'un élément de la ligne
    ABCD = matprec*ABCDprec
    matprec = ABCD
    #print 'ABCD=',value(ABCD)
  #-----------------------------------------------------------------------------------------
  # Calcul de la matrice S de la ligne à partir de la matrice ABCD de la ligne
  #-----------------------------------------------------------------------------------------
  Zref = 50
  Afinal = ABCD[0,0]
  Bfinal = ABCD[0,1]
  Cfinal = ABCD[1,0]
  Dfinal = ABCD[1,1]
  Scoef = 1/((Bfinal+Cfinal*Zref*Zref)+(Afinal*Zref+Dfinal*Zref))
  print 'Scoef pour la matrice S=',value(Scoef)
  tempS11 = Bfinal-Cfinal*Zref*Zref+Afinal*Zref-Dfinal*Zref
  tempS12 = 2*Zref*(Afinal*Dfinal-Bfinal*Cfinal)
  tempS21 = 2*Zref
  tempS22 = Bfinal-Cfinal*Zref*Zref-Afinal*Zref+Dfinal*Zref
  #-----------------------------------------------------------------------------------------
  # Calcul des valeurs de la matrice S
  #-----------------------------------------------------------------------------------------
  matS11 =Scoef*tempS11
  print 'matS11 = ', result(matS11)
  matS12 =Scoef*tempS12
  matS21 =Scoef*tempS21
  matS22 =Scoef*tempS22
  matS = numpy.matrix([[matS11,matS12],[matS21,matS22]]) # Création de la matrice S sans la multiplication par le coef
  #-----------------------------------------------------------------------------------------

et pour info je ne suis pas du genre à me foutre du monde, donc tu pouvais dire la même chose en utilisant un ton plus "neutre".

Merci pour ton éventuel aide

Patricia

[eyquem]

Salut,

J'ai compté rapidement les nombres d'opérations réalisées pour un tour de la boucle for vdiamA,vdiamB in zip(listeDiamA,listeDiamB): , c'est à dire pour 1 valeur de couple vdiamA,vdiamB:

- diamA,diamB,deltaL:
3 recours à une fonction ex.gaussian

- ligne à air sans pertes:
21 opérations élémentaires et 5 recours à des fonctions dans 9 calculs
(3 opérations élémentaires et 1 recours à la fonction log pour F2 = (r)*log(r)/(r+1) par exemple)
5 affectations de valeurs constantes

- ligne à air avec pertes:
2 opérations élémentaires pour 1 affectation de valeur constante w = 2*pi*f
62 opérations élémentaires et 6 recours à des fonctions dans 11 calculs

- Matrice ABCD de la ligne:
3 opérations élémentaires et 4 recours à une fonction dans 5 calculs
1 création de matrice ABCDprec = numpy.matrix([[A,B],[C,D]])
12 opérations élémentaires dans 4 calculs pour une multiplication de 2 matrices 2lignesx2colonnes

- calculs pour matrice S :
1 affectation de valeur constante
4 affectations de valeurs
32 opérations élémentaires dans 8 calculs
1 création de matrice matS = numpy.matrix([[matS11,matS12],[matS21,matS22]])

Soit au total:
132 opérations élémentaires et 18 fonctions dans 37 calculs
7 affectations de valeurs constantes
4 affectations de valeurs
2 créations de matrice

Ça ne me semble pas un volume énorme d'opérations pour un tour de boucle. Ça devrait prendre sensiblement le même temps de calcul pour chaque tour. Or ce temps semble de plus en plus long pour chaque tour supplémentaire puisqu'au delà de 5 tours ça rame sérieusement, c'est bien ça ?

Je pense que tu devrais truffer ton code d'instructions pour décompter les temps d'exécution de certaines lignes de calcul ou groupes de lignes. L'utilisation de clock() n'est pas très précise mais pour une première évaluation pour un ralentissement aussi marqué que dans ton cas, je pense que c'est suffisant.
Par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
t1 = clock()
F1 = (r**2-1)/(2*log(r))
t2 = clock()
print t2 -t1
F2 = (r)*log(r)/(r+1)
t3 = clock()
print t3 - t2
F0 = F1-F2-0.5*(r+1)
t4 = clock()
print t4 - t3
print t4 - t1

[eyquem]

1- Je vois des instructions
_J_ = ex.constant(0+1j)
et
Zc = sqrt((R+((L*w)*1j))/(G+((C*w)*1j)))
gamma = sqrt((R+((L*w)*1j))*(G+((C*w)*1j)))
dans lesquelles il y a (C*w)*1j

Ça me fait penser à des nombres complexes. Y a-t-il des calculs sur des complexes dans ton programme ? Il me semble que tout le reste représente des calculs de variables bateaux.


2- Dans quelle plage de valeurs possibles de f sont susceptibles de se trouver valStartF et gamStopF ? C'est à dire quel est l'intervalle de définition (valStartF,gamStopF) habituel de la grandeur f ?

Quel ordre de grandeur pour valFpas ?

La question étant en fait: quel est le nombre approximatif de valeurs dans le range gammeF ?


3- Que font les lignes suivantes ? ex est Context(), mais qu'est ce que Context() ? C'est encore un truc qui se trouve dans mst.GUM.complex.gum ?

diamA = ex.gaussian(vdiamA*1e-3, uAbsolute(0.02e-3)) # Petit diamètre
diamB = ex.gaussian(vdiamB*1e-3, uAbsolute(0.02e-3)) # Grand diamètre
deltaL = ex.gaussian(cdeltaL, uAbsolute(0.5e-3)) # Pas de mesure

[eyquem]

1- Tu pourrais avantageusement, je crois, remplacer

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
if valFdeb > valFfin :
    print u'La fréquence de départ est supérieure à la fréquence de fin'
    print ' donc le programme inverse les deux fréquences.'
    valStartF = valFfin
    valStopF = valFdeb
else :
    valStartF = valFdeb
    valStopF = valFfin

par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

valStartF,valStopF = sorted( [valFdeb, valFfin] )

Je crois qu'il y a une autre façon de faire, avec une fonction spécialement destinée à trouver min et max dans une liste directement par une seule instruction, mais je ne l'ai pas retrouvée, et je ne suis pas mécontent de ma petite trouvaille...


2-

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
print   
# même résultat que
print ""

Pour ajouter une ligne vide, il suffit aussi d'ajouter \n:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

print u'La fréquence en cours est :', f, u'Hz\n'

3- Tu peux remplacer

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
diamAFile = open(filePetitDiam,'r')
diamBFile = open(fileGrandDiam,'r')
 
diamAListe = diamAFile.readlines() 
listeDiamA = map(float,diamAListe)
 
diamBListe = diamBFile.readlines() 
listeDiamB = map(float,diamBListe)
 
for vdiamA,vdiamB in zip(listeDiamA,listeDiamB):
    ....instructions....

par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
diamAFile = open(filePetitDiam,'r')
diamBFile = open(fileGrandDiam,'r')
Z = zip( [ float(x) for diamAFile ] , [float(x) for x in diamBFile ] )
for vdiamA,vdiamB in  Z:
    ....instructions....

4- Ça marche même encore si on écrit

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
Z = zip( [ float(x) for open(filePetitDiam,'r') ] , [float(x) for x in open(fileGrandDiam,'r') ] )
for vdiamA,vdiamB in Z:
....instructions....

la concision Python, c'est dingue !

mais ça ne me plait pas car dans ce cas je ne sais pas comment on peut fermer les objets-fichiers open(filePetitDiam,'r') et open(fileGrandDiam,'r') qui ont été ouverts.

D'ailleurs, soit dit en passant, dans ton code il y a
diamAFile = open(filePetitDiam,'r') qui ouvre filePetitDiam
mais il manque l'instruction
diamAFile.close() qui le ferme.


5-

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
diamAFile = open(filePetitDiam,'r')
diamBFile = open(fileGrandDiam,'r')
Z = zip( [ float(x) for diamAFile ] , [float(x) for x in diamBFile ] )
for vdiamA,vdiamB in Z:
    ....instructions....

c'est utilisable si les fichiers filePetitDiam et fileGrandDiam ne sont pas trop grands.
Si deux fichiers A et B sont grands au point de trop pomper sur la ressource RAM, il faudrait écrire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
f = open(A,'r')
g = open(B,'r')
a,b = 'go','go'
while a!=''and b!='':
    a,b = f.readline(),g.readline()
    vdiamA,vdiamB = float(a),float(b)
    ...instructions...

6- En réalité, ton code est:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
diamAFile = open(filePetitDiam,'r')
diamBFile = open(fileGrandDiam,'r')
....instructions....
for f in gammeF:
    ind = numpy.matrix([[1,0],[0,1]])
    matprec = ind
    for vdiamA,vdiamB in zip(listeDiamA,listeDiamB):
        ....instructions....

C'est à dire qu'il me semble que la liste zip(listeDiamA,listeDiamB) est recréée pour chaque valeur de f.
Il vaudrait mieux définir zipliste = zip(listeDiamA,listeDiamB) avant d'entrer dans le bouclage sur les valeurs f,
puis boucler avec for vdiamA,vdiamB in zipliste: après l'instruction for f in gammeF:


7- Il y a la même imperfection avec des valeurs de constantes qui sont répétitivement réaffectées à chaque tour de boucle vdiamA,vdiamB:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
    c = 299792458 # Célérité
    mu = ex.constant(4*pi*1e-7) # Perméabilité
    E0 = 1/mu/c**2 # Permittivité dans le vide
    E = 1.000649*E0 # Permittivité dans le matériau
    rho = ex.constant(22e-9) # Résistivité
    w = 2*pi*f              #pulsation
    Zref = 50

Ça fait travailler '125 x nombre de valeurs f ' fois le programme à écrire 7 constantes, qui pourraient être définies une fois pour toutes avant le bouclage sur f.


8- Dans le même esprit, j'écrirais personnellement

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
vtemp = d0*(1-k**2*a**2*F0/2)
R =   2*w*L0* vtemp)     #résistance linéique
L = L0*( 1+2* vtemp)  )   #inductance linéique

ou peut être mieux:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
kacarre = k**2*a**2
R = 2*w*L0*d0*(1-   kacarre   *F0/2)     #résistance linéique
L = L0*(1+2*d0*(1-  kacarre   *F0/2))   #inductance linéique
G = w*C0*d0*    kacarre      *F0             #conductance linéique
C = C0*(1+d0*   kacarre      *F0)           #capacité linéique

et

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
x =  (R+  ((L*w)*1j))
y = (G+((C*w)*1j))
Zc =        sqrt( x  /  y ) 
gamma = sqrt( x  *  y )

Mais je ne suis pas sûr que ça change beaucoup la vitesse d'exécution. Il faut voir.

[bourgui78]

pour toute ton aide, je regarderai ça demain, car je vais en entretien d'embauche là...
oui effectivement mes calculs sont des complexes, c'est peut-être ça le plus long

je te dis demain ce qu'il en est de toutes ces modif

Merci encore

Patricia

[bourgui78]

et je n'ai toujours pas testé tes propositions.

Pour ce qui concerne la partie calcul
Pour info, en fait toutes mes valeurs sont associées à une incertitude, donc quand j'ai une matrice, chaque paramètre de ma matrice à une matrice d'incertitude, ce qui peut ralentir sensiblement mon programme

Pour tes quesions avec indice orange
Oui je gère des nombres complexes, avec des puissance 10e-8
Mes frèquences vont de 100mHz à 18 GHz avec des pas de 100mHz soit 180 fréquences
Oui Context() fait partie du mst.GUM.complex.gum, c'est une classe de calcul de propagation des incertitudes, en fait le programme pour une formule calcule la dérivée partielle, et les moindres carrées par rapport à l'incertitude d'origine qui est ici mes mesures de diamètre diamA et diamB.
Pour plus d'explication tu peux te regarder la norme NF ENV 13005, du guide de l'expression de l'incertitude de mesure

maintenant je vais tester tes suggestion.

Merci encore

Patricia

[bourgui78]

tu écris ce code là

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
f = open(A,'r')
g = open(B,'r')
a,b = 'go','go'
while a!=''and b!='':
    a,b = f.readline(),g.readline()
    vdiamA,vdiamB = float(a),float(b)
    ...instructions...

quand je fais ce truc, il me met l'erreur suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

value error : empty string for float

or ce sont bien des flottants, mes valeurs dans mon fichier sont : 1.51 1.515 1.52 1.525 1.53
et pour l'autre fichier : 3.51 3.515 3.52 3.525 3.53

je ne comprends plus rien

Pour info merci pour le sorted ça marche bien !

Merci encore

Patricia

[airod]

moi ca me fait penser a une saturation de la RAM....
as tu regardé ce qui se passe coté ram, quand tu lance ton prog?
par hasard, est ce que le script ne pomperai pas toute la ram, jusqu'a épuisement, ce qui le fait planter?

Juste comme ca, pour voir!

[eyquem]

À la fin du bouclage, il se passe ceci:

- partons du moment où le programme a fini un tour de boucle au début duquel a, b, vdiamA, vdiamB ont pris les valeurs '1.525' , '3.525' , 1.525 , 3.525
et au cours duquel on été exécutées les ...instructions...

- le programme vérifie d'abord que a!=''and b!=''
comme c'est le cas (puisque a=='1.525' et b=='3.525') il rentre donc dans le tour de boucle supplémentaire dans lequel
a prend la valeur "1.53", b prend la valeur "3.53"
puis
vdiamA devient 1.53 , vdiamB devient 3.53
et le programme exécute les ...instructions...

- il réattaque un tour de boucle en vérifiant que a!='' et b!=''
le programme rentre donc dans le tour de boucle
a=f.readline() affecte la valeur '' à a, b prend aussi la valeur ''
puis le programme essaye d'exécuter vdiamA = float(a) c'est à dire vdiamA = float(''): float de 'rien', ça ne marche pas.


Ce bout de code est mal fait !!

Il ne faut pas que a et b prennent de nouvelles valeurs entre le test a!=''and b!='' et la ligne vdiamA,vdiamB = float(a),float(b):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
while a!=''and b!='':
    vdiamA,vdiamB = float(a),float(b)
    ...instructions...
    a,b = f.readline(),g.readline()

donc initialiser a et b différemment avant la boucle

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
a,b = f.readline(),g.readline()
while a!=''and b!='':
    vdiamA,vdiamB = float(a),float(b)
    ...instructions...
    a,b = f.readline(),g.readline()

Soit dit en passant, comme je le disais dans un autre message, en reprenant ce code après coup, j'ai vu qu'on peut le rendre plus concis encore:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
a,b = f.readline(),g.readline()
while a and b:
    vdiamA,vdiamB = float(a),float(b)
    ...instructions...
    a,b = f.readline(),g.readline()

NB

Comme je le disais, ce code est à utiliser (en tous cas je ne sais pas faire autrement) quand des fichiers A et B sont trop grands pour pouvoir d'abord les lire et créer des listes dans lesquels on place leurs données avant d'itérer dans les listes pour exploiter les données.
Si un fichier A est trop grand et qu'on le lit en entier d'un coup pour mettre ses données dans une liste, celle ci va occuper une place mémoire considérable.
Tandis que si on lit un très grand fichier ligne par ligne, on ne sature pas la RAM.

Ce n'est pas ton cas puisque tes fichiers filePetitDiam et fileGrandDiam ne comportent chacun que 125 nombres si j'ai bien compris. Mais c'était à titre informatif.

[eyquem]

Plus efficace que mes maigres conseils, je pense que tu ferais mieux d'aller dans le forum Image/Calcul scientifique :
http://www.developpez.net/forums/f92...-scientifique/

[eyquem]

Je résume ce qui se passe dans ton programme:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
ind = numpy.matrix([[1,0],[0,1]])
matprec = ind
 
for vdiamA,vdiamB in zip(listeDiamA,listeDiamB):
    ...calculs ---> valeurs de  coeff  et  Zc 
    A = cosh(coef)
    B = sinh(coef)*Zc
    C = sinh(coef)/Zc
    D = cosh(coef)
    ABCDprec = numpy.matrix([[A,B],[C,D]])
    ABCD = matprec*ABCDprec
    matprec = ABCD
 
après la boucle sur les vdiam: utilisation des valeurs de la matrice ABCD

------

Il me semble qu'il y a un certain nombre de choses qui ne vont pas.


1-

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
ind = numpy.matrix([[1,0],[0,1]])
matprec = ind

Écrire directement:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

matprec = numpy.matrix([[1,0],[0,1]])

2-

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
A = cosh(coef)
B = sinh(coef)*Zc
C = sinh(coef)/Zc
D = cosh(coef)
ABCDprec = numpy.matrix([[A,B],[C,D]])

trop lourd ! il faut être plus concis:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
A = cosh(coef)
S = sinh(coef)
ABCDprec = numpy.matrix(  [  [A , S*Zc] , [ S/Zc , A] ] )

3-

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
ABCD = matprec*ABCDprec
matprec = ABCD

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
matprec = matprec*ABCDprec
# ça marche

4- on rassemble 2 et 3

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
A = cosh(coef)
S = sinh(coef)
matprec = matprec*numpy.matrix(  [  [A , S*Zc] , [ S/Zc , A] ] )

On rassemble tout

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
matprec = numpy.matrix([[1,0],[0,1]])
 
for vdiamA,vdiamB in zip(listeDiamA,listeDiamB):
    ...calculs ---> valeurs de  Zc , A , S
    matprec = matprec*numpy.matrix(  [  [A , S*Zc] , [ S/Zc , A] ] )
 
après la boucle sur les vdiam: utilisation des valeurs de la matrice matprec

==============================================

Ensuite, j'ai regardé
ce qui se passe du point de vue algorithmique.

matprec = numpy.matrix([[1,0],[0,1]])
pour moi, matprec est pour le moment la matrice identite

1er couple de valeurs vdiam:
...calculs de Zc0 , A0 , S0
matprec0 = identite*numpy.matrix( [ [A0 , S0*Zc0] , [ S0/Zc0 , A0] ] )

donc matprec0 se retrouve égale à numpy.matrix( [ [A0 , S0*Zc0] , [ S0/Zc0 , A0] ] )

2iéme couple de valeurs vdiam
...calculs de Zc1 , A1 , S1
matprec1 = matprec0*numpy.matrix( [ [A1 , S1*Zc1] , [ S1/Zc1 , A1] ] )

3ième couple de valeurs vdiam
...calculs de Zc2 , A2 , S2
matprec2 = matprec1*numpy.matrix( [ [A2 , S2*Zc2] , [ S2/Zc2 , A2] ] )

etc....


J'écrirais donc plutôt:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
Z = zip(listeDiamA,listeDiamB)
 
vdiamA,vdiamB = Z[0]
...calculs de Zc0 , A0 , S0
matprec0 = numpy.matrix(  [  [A0 , S0*Zc0] , [ S0/Zc0 , A0] ] )
 
for vdiamA,vdiamB in Z[1:]:
    ...calculs de Zc , A , S
    matprec = matprec * numpy.matrix(  [  [A , S*Zc] , [ S/Zc , A] ] )
 
après la boucle sur les vdiam: utilisation des valeurs de la matrice matprec

Pas besoin d'une matrice identité au début.
EDIT: enfin si, c'est pas mal, c'est plus concis... c'est comme on préfère quoi....

[eyquem]

ex = Context()

que produit ex.constant() ?

vu dans
_J_ = ex.constant(0+1j)
mu = ex.constant(4*pi*1e-7)
rho = ex.constant(22e-9)


que produit ex.gaussian() ?

vu dans
diamA = ex.gaussian(vdiamA*1e-3, uAbsolute(0.02e-3)) # Petit diamètre
diamB = ex.gaussian(vdiamB*1e-3, uAbsolute(0.02e-3)) # Grand diamètre
deltaL = ex.gaussian(cdeltaL, uAbsolute(0.5e-3)) # Pas de mesure


que produit ex.uncertainty() ?

vu dans
ex.uncertainty(matS12)
etc


Est-ce que les grandeurs produites sont des complexes ?

[bourgui78]

oui effectivement saturation de la Ram, mais même sur un pc qui à 8Go et pourtant je n'utilise "que" 1.8Go

Patricia

[bourgui78]

Merci encore de ton aide, je vais regarder ce que tu me propose aujourd'hui.

Pour ex.constant, c'est en faire pour dire au programme que cette valeur n'a aucune incertitude.
Ex.uncertainty, c'est la valeur de l'incertitude. C'est une matrice 2x2 pour chaque valeur de la matrice S.

ex.gaussian est une valeur qui a une représentativité de type loi Normale.

Ce sont des stats.

L'auteur de cela est B.D. HALL Rapport :" 'byCum' : A Python software package for calculating measurement uncertainty"

Je regarde plus tard ce que tu me proposes... j'ai réunion

merci encore

Patricia

[eyquem]

Mes messages précédents ne sont que des remarques d'écriture. Je ne crois pas que le fond de ton problème sera résolu par ces remarques. Il faudrait quand même commencer à comprendre à quoi est dûe la lenteur de ton programme et pour cela avoir des mesures de temps d'exécution.

Mais il faut savoir où placer des prises de temps dans le programme.

À cet égard, je me suis aperçu que j'avais mal compris le problème. Je croyais que l'exécution de la boucle
for vdiamA,vdiamB in zip(listeDiamA,listeDiamB):
était de plus en plus lente, c'est à dire que l'exécution des instructions pour une valeur donnée du couple vdiamA,vdiamB , c'est à dire un tour de la boucle, était plus longue que pour le tour précédent, et que la boucle, pour plus de 5 couples vdiam, n'arrivait pas au bout.



En fait, après avoir relu ton premier message, il me semble que la boucle

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
for vdiamA,vdiamB in zip(listeDiamA,listeDiamB):
    ...instructions...

est bien exécutée entièrement, même pour 125 couples vdiam,
puisque la ligne

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

print 'Scoef pour la matrice S=',value(Scoef)

qui est située après cette boucle, est exécutée.


Pour être sûr de bien comprendre, peux tu confirmer qu'en lançant ton programme avec 125 couples vdiam, tu observes une fois, et une fois seulement, l'écriture de
'Scoef pour la matrice S=',value(Scoef)
Ce qui correspond à une seule valeur de f.
C'est bien ça ??



Car si c'est cela, le problème n'est pas dans les calculs qui précèdent mais entre
print 'Scoef pour la matrice S=',value(Scoef)
et
print 'matS_11 finale = ', result(matS[0,0])
et plus particulièrement l'expression result(matS[0,0])

Finalement, result( ) c'est quoi ce machin ? Je ne connais pas le module numpy, alors je pensais que c'était lié à lui mais après quelques recherches, il ne me semble pas.
Est ce que result() ne serait pas plutôt une fonction de gum, encore?

[eyquem]

Une RAM de 8 GO ? Ça me semble énorme, c'est une taille de RAM de serveur.
Et le chiffre de 1,8 Go utilisés pendant que ça tourne, il vient d'où, comment as-tu fait pour le connaître ?
Tu ne confondrais pas avec la taille du disque dur ??

[bourgui78]

oui effectivement les 125 calculs se font mais je modifie tout de même le programme car je pense que ça allègera au final le calcul de la matrice S.
Oui Result dépend de gaussian, c'est pour cette raison que je n'ai pas précisé la fonction numpy avant.
En fait result donne le résulat la valeur + la matrice d'incertitude associée.

Non non je ne confond pas avec un DD, c'est bien la Ram, c'est un PC dédié à la simulation est il faut beaucoup de Ram pour faire tourner la bécane et les 1.8 je les vois dans le gestionnaire des tâches partie processus. j'utilise "que" 25% de la Ram.

je te dis ce qui en est des modifs que j'ai faite et je viens de penser à qqchose et j'essaie et je te donne des news

@+

Merci encore

Patricia

[eyquem]

Les 125 calculs d'un tour se font, OK, mais ils se font combien de fois ? C'était ça ma question. C'est à dire: il y a bien un seul tour de boucle effectué , n'est ce pas, c'est à dire les calculs pour le premier couple vdiamA,vdiamB , et puis ça n'attaque pas les calculs pour le deuxième couple parce qu'en fait ça bloque sur result(matS[0,0]) qui ne s'inscrit pas ? C'est bien ça ?

Comme je pense que c'est bien ainsi,
et que tu as dit aussi que result() est lié à gaussian qui est dans Context() qui est lui même dans gum,
il me parait clair que ton problème de lenteur est lié au bidule mst.GUM.complex.gum.
Soit ce bidule est mal fichu en lui même , soit c'est la manière dont il intervient dans ton programme qui est mal réglée.

En tous cas, utilisation de 25% de RAM, je n'appelle pas ça une saturation de RAM.

Si le programme bloque sur result(matS[0,0]) , ça me donne plutôt l'impresion d'une boucle qui serait mal conçue, qui bouclerait à l'infini, et pour cela il faut que result() relance des calculs, ce qui semble contradictoire avec son nom.

Je serais toi, je regarderais de près ce que fabrique result().