Discussion :

[Aelurus_]

Bonjour à tous,

en guise d'exercice je voudrais tenter de solutionner un carré des moyennes pour simuler un transfert thermique à état stationnaire. Pour cela je souhaiterais essayer de construire une Class avec les méthodes utiles aux différentes fonctions. Voici comment je commence par poser les bases comme cela :

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
class bar:
    """
    Cette classe sert à calculer le transfert thermique à etat stationnaire en deux dimensions
    selon la méthode du carré de Dichelet, ou carré des moyennes d'une tranche longitudinale  d'une barre
    """    
    def __init__(self,t_a,t_d,t_f,longueur,hauteur):
        self.t_ambiante = t_a# t en °C
        self.t_debut = t_d# t en °C
        self.t_fin = t_f# t en °C
        self.longueur = longueur# l en mm
        self.hauteur = hauteur# h en mm        
    def make_bar():
        """
        construction du tableau ou de la matrice à état initiale, à l'état initial
        nous avons la température ambiante et celle des extrémités, la température
        initial de la tranche est défini à 0 ou à la valeur mini des entrées...
        A défini selon des critères non sélectionnés            
 
        Returns
        -------
                   t_a  t_a t_a t_a... t_a   
            t_d    0    0   0   0  ... 0   t_f
            t_d    0    0   0   0  ... 0   t_f
                   t_a  t_a t_a t_a... t_a 
 
        """
 
    def calcul_t():
        """
        
 
        Returns
        -------
        None.
 
        """
    def show_bar():
        """
 
        Returns
        -------
        None.
 
        """
    def graph_t():
        """
        
 
        Returns
        -------
        None.
 
        """

Auriez vous des conseils sur comment commencer ou structurer une class ?

Merci

[Sve@r]

Bonjour

Auriez vous des conseils sur comment commencer ou structurer une class ?

"class" c'est le nom Python pour "objet". Essaye donc de penser à ton truc comme un objet. C'est quoi un objet dans la vie ? C'est un truc qui évolue dans le temps. Un frigo par exemple c'est un objet. Et dans le temps, on peut ouvrir sa porte, la fermer. On peut lui rajouter des aliments, ou en enlever. Etc etc etc. C'est donc un truc qui subit une intéraction avec l'extérieur et cette intéraction se traduit par des méthodes.

Par exemple ton objet à toi c'est une collection de valeurs ok. Mais la méthode make_bar(), a-t-elle vraiment une raison d'être ? Est-ce que si tu l'appelles à 2 moments différents de ton programme elle peut donner 2 résultats différents ? Sinon alors elle devient inutile (tu effectues son travail une seule fois dans le __init__()).

Donc voilà. Le seul conseil que je peux te donner, c'est de créer ton objet de façon minimaliste (juste un __init__()). Et ensuite, c'est en l'utilisant que tu te rendras compte de ce qui lui manque et que tu le rajouteras au fur et à mesure.

[Aelurus_]

Ba oui, mon objet bar n'a pas besoin d'une méthode pour le créer, sur le coup je l'ai trouvé logique car je souhaitais pouvoir afficher l'état de départ.
ok je vais suivre tes conseils.

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
def __init__(self,t_a,t_d,t_f,longueur,hauteur):
        """
        construction du tableau ou de la matrice à état initiale, à l'état initial
        nous avons la température ambiante et celle des extrémités, la température
        initial de la tranche est défini à 0 ou à la valeur mini des entrées...
        A défini selon des critères non sélectionnés            
 
        Returns
        -------
                   t_a  t_a t_a t_a... t_a   
            t_d    0    0   0   0  ... 0   t_f
            t_d    0    0   0   0  ... 0   t_f
                   t_a  t_a t_a t_a... t_a 
 
        """
        bar = list()
        for i in range(hauteur+2):
            if i == 0 or i == hauteur+1:
                bar.append(list(["None"]) + list([t_a]*longueur) + list(["None"]))
            else :
                bar.append(list([t_d]) + list([0]*longueur) + list([t_f])) 
        self.bar = bar

Si je suis ta logique je n'ais plus qu'a faire les méthodes dont j'ai besoins.

[MPython Alaplancha]

Auriez vous des conseils sur comment commencer ou structurer une class ?

Merci

Bonjour,
En ce qui concerne le passage d'argument à ton __init__, tu peux faire:

Code :

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

1
2
def __init__(self, *args):
        t_a, t_d, t_f, longueur, hauteur = args

[Aelurus_]

Merci, hominidé je trouve la démarche surtout si tu dois gérer une tripoté d'arguments

[Sve@r]

Code python :

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

1
2
3
4
if i == 0 or i == hauteur+1:
	bar.append(list(["None"]) + list([t_a]*longueur) + list(["None"]))
else:
	bar.append(list([t_d]) + list([0]*longueur) + list([t_f]))

Alors c'est vrai que j'ai dit que je prenais l'habitude de mettre list() tout le temps... sauf quand le truc placé entre parenthèses est déjà une liste !!!
Soit tu écris [None,] (j'avais aussi précisé que je mettais la virgule tout le temps), soit tu écris list((None,)) signifiant que tu transformes en liiste un truc qui ne l'est pas nativement, mais écrire list([None]) pour le coup là ça ne sert pas à grand chose

Code python :

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

1
2
3
4
if i == 0 or i == hauteur+1:
	bar.append(["None",] + [t_a,]*longueur + ["None",])
else:
	bar.append([t_d,] + [0,]*longueur + [t_f,])

Ensuite, d'un point de vue algo, boucler n+2 fois et tester donc n+2 fois si tu te trouves aux bornes produit donc n tests inutiles qui sont autant de charge inutile. Ce n'est pas parce qu'on fait du Python qu'il ne faut pas prendre soin de son processeur. Quel dommage, toi qui aime tant les listes en intension c'était ici une occasion rêvée de t'en servir avec efficience

Code python :

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

1
2
borne=["None",] + [t_a,]*longueur + ["None",]
self.bar=borne[:] + list(([t_d,] + [0,]*longueur + [t_f,]) for i in range(hauteur)) + borne[:]

Et le borne[:] c'est pour produire une copie de borne en mémoire. Si on écrit bêtement bar=borne + list(...) + borne, alors on n'ajoute que l'adresse de "borne" ce qui fait que bar[0] et bar[hauteur+1] pointent vers la même zone (souci quand on copie des tableaux). Remarque pour le coup là j'aurais pu effectivement mettre bar=list(borne) + list(...) + list(borne) qui aurait produit le même effet et là le cast list() se justifiait pleinement.

Si je suis ta logique je n'ais plus qu'a faire les méthodes dont j'ai besoins.

Exactement.

[Aelurus_]

Salut,

Alors c'est vrai que j'ai dit que je prenais l'habitude de mettre list() tout le temps... sauf quand le truc placé entre parenthèses est déjà une liste !!!
Soit tu écris [None,] (j'avais aussi précisé que je mettais la virgule tout le temps), soit tu écris list((None,)) signifiant que tu transformes en liiste un truc qui ne l'est pas nativement, mais écrire list([None]) pour le coup là ça ne sert pas à grand chose

Code python :

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

1
2
3
4
if i == 0 or i == hauteur+1:
	bar.append(["None",] + [t_a,]*longueur + ["None",])
else:
	bar.append([t_d,] + [0,]*longueur + [t_f,])

Oui trés juste, j'ai zappé la virgule et me suis embrouillé en regardant ce que celà faisait avec les dictionnaire....

Ensuite, d'un point de vue algo, boucler n+2 fois et tester donc n+2 fois si tu te trouves aux bornes produit donc n tests inutiles qui sont autant de charge inutile. Ce n'est pas parce qu'on fait du Python qu'il ne faut pas prendre soin de son processeur. Quel dommage, toi qui aime tant les listes en intension c'était ici une occasion rêvée de t'en servir avec efficience

Looool, oui c'est trés vrai, je me suis forcé à rester avec des listes de base, histoire de .

Code :

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

1
2
3
4
5
6
7
  bar = list()
        for i in range(hauteur+2):
            if i == 0 or i == hauteur+1:
                bar.append(list((t_d,)) + list([t_a]*longueur) + list((t_f,)))
            else :
                bar.append(list((t_d,)) + list([0]*longueur) + list((t_f,))) 
        self.bar = bar

Code python :

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

1
2
borne=["None",] + [t_a,]*longueur + ["None",]
self.bar=borne[:] + list(([t_d,] + [0,]*longueur + [t_f,]) for i in range(hauteur)) + borne[:]

Et le borne[:] c'est pour produire une copie de borne en mémoire. Si on écrit bêtement bar=borne + list(...) + borne, alors on n'ajoute que l'adresse de "borne" ce qui fait que bar[0] et bar[hauteur+1] pointent vers la même zone (souci quand on copie des tableaux). Remarque pour le coup là j'aurais pu effectivement mettre bar=list(borne) + list(...) + list(borne) qui aurait produit le même effet et là le cast list() se justifiait pleinement.

Bon cette partie-là je dois la regarder de plus près dans la console pour mieux appréhender la chose. Là je slice ^^pour le calcul et l'affichage

[13, 13] -- [13, 13]
__________________________
0 | [0, 0, 0, 0, 0, 0] ---- [0, 0, 0, 0, 0, 0] | 30
0 | [0, 0, 0, 0, 0, 0] ---- [0, 0, 0, 0, 0, 0] | 30
0 | [0, 0, 0, 0, 0, 0] ---- [0, 0, 0, 0, 0, 0] | 30
0 | [0, 0, 0, 0, 0, 0] ---- [0, 0, 0, 0, 0, 0] | 30
0 | [0, 0, 0, 0, 0, 0] ---- [0, 0, 0, 0, 0, 0] | 30
0 | [0, 0, 0, 0, 0, 0] ---- [0, 0, 0, 0, 0, 0] | 30
0 | [0, 0, 0, 0, 0, 0] ---- [0, 0, 0, 0, 0, 0] | 30
0 | [0, 0, 0, 0, 0, 0] ---- [0, 0, 0, 0, 0, 0] | 30
0 | [0, 0, 0, 0, 0, 0] ---- [0, 0, 0, 0, 0, 0] | 30
0 | [0, 0, 0, 0, 0, 0] ---- [0, 0, 0, 0, 0, 0] | 30
__________________________
[13, 13] -- [13, 13]

Bon attention au carnage ^^

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
    def calcul_t(self):
        """
        
 
        Returns
        -------
        None.
 
        """
        a = 0
        while a<50:
            for i in range(len(self.bar[:-1])):
                for n in range(len(self.bar[i][:])):
                    if i == 0 or n == 0 or n == self.longueur+1 :
                        None
                    else : 
                        self.bar[i][n] = round((self.bar[i][n-1]+self.bar[i][n+1]+self.bar[i-1][n]+self.bar[i+1][n])/4,1)
            a+=1
 
    def show_bar(self):
        """
 
        Returns
        -------
        None.
 
        """
        print("   ",self.bar[0][1:3],"  --  ",self.bar[0][-3:-1],"  ")
        print("  ","_"*26," ")
        bar=self.bar[1:-1]
        for i in range(len(bar)): 
            print(self.t_debut,"|",bar[i][1:7],"----",bar[i][-7:-1],"|",self.t_fin)
        print("  ","_"*26," ")
        print("   ",self.bar[0][1:3],"  --  ",self.bar[0][-3:-1],"  ")

Pour l'instant c'est juste fonctionnel et je crois que ça fait le taff demandé aussi ^^. C'est quand même super les objets, je trouve cela assez impressionnant. Je suis bien conscient que je dois être dans 1% de son potentiel . Mais rien que cette syntaxe est top :

Code :

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

1
2
3
4
5
c = Bar(13,0,30,30,10)
c.show_bar()
c.calcul_t()
c.show_bar()
c.graph_t()

Bon numpy te revoila ^^, surtout que je voudrais voir à essayer de traiter mes effets de bord avec la température ambiante ce qui risque de bien alourdir le bousin ^^.

Merci

[Aelurus_]

Salut,
mais oui biensur ^^.

Ensuite, d'un point de vue algo, boucler n+2 fois et tester donc n+2 fois si tu te trouves aux bornes produit donc n tests inutiles qui sont autant de charge inutile. Ce n'est pas parce qu'on fait du Python qu'il ne faut pas prendre soin de son processeur. Quel dommage, toi qui aime tant les listes en intension c'était ici une occasion rêvée de t'en servir avec efficience

Code python :

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

1
2
borne=["None",] + [t_a,]*longueur + ["None",]
self.bar=borne[:] + list(([t_d,] + [0,]*longueur + [t_f,]) for i in range(hauteur)) + borne[:]

Et le borne[:] c'est pour produire une copie de borne en mémoire. Si on écrit bêtement bar=borne + list(...) + borne, alors on n'ajoute que l'adresse de "borne" ce qui fait que bar[0] et bar[hauteur+1] pointent vers la même zone (souci quand on copie des tableaux). Remarque pour le coup là j'aurais pu effectivement mettre bar=list(borne) + list(...) + list(borne) qui aurait produit le même effet et là le cast list() se justifiait pleinement.

Par contre j'ai besoin de faire [borne,] comme je veux une liste par ligne.

[Sve@r]

Par contre j'ai besoin de faire [borne,] comme je veux une liste par ligne.

Exact... mais pas tout à fait. Tu as besoin de faire [borne[:],] et non [borne,] car sinon tu ne places que l'adresse de "borne" dans ta nouvelle liste.

Exemple1

Code python :

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

1
2
3
4
5
6
7
8
class toto:
	def __init__(self,t_a,t_d,t_f,longueur,hauteur):
		borne=["None",] + [t_a,]*longueur + ["None",]
		self.bar=[borne,] + list(([t_d,] + [0,]*longueur + [t_f,]) for i in range(hauteur)) + [borne,]
 
a=toto(1, 2, 3, 4, 2)
a.bar[0][0]="xxx"
print(a.bar)

Exemple2

Code python :

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

1
2
3
4
5
6
7
8
class toto:
	def __init__(self,t_a,t_d,t_f,longueur,hauteur):
		borne=["None",] + [t_a,]*longueur + ["None",]
		self.bar=[borne[:],] + list(([t_d,] + [0,]*longueur + [t_f,]) for i in range(hauteur)) + [borne[:],]
 
a=toto(1, 2, 3, 4, 2)
a.bar[0][0]="xxx"
print(a.bar)

C'est un des soucis quand on copie des tableaux. Python travaille à l'économie (ce qui, dans 80% des cas, est suffisant). Mais si tu veux que t2 contienne une duplication de t1, il te faut la demander explicitement.
Remarque peut-être que dans ton cas l'exemple 1 est suffisant mais c'était pour te montrer le danger.

Code python :

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

1
2
3
4
a = 0
while a<50:
	...
	a+=1

Là franchement...

Code python :

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

1
2
for a in range(50):
	...

Code python :

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

1
2
3
4
if i == 0 or n == 0 or n == self.longueur+1 :
	None
else : 
	self.bar[i][n] = round((self.bar[i][n-1]+self.bar[i][n+1]+self.bar[i-1][n]+self.bar[i+1][n])/4,1)

Au-moins t'as cherché et ça c'est bien. En fait, l'instruction neutre c'est pas None mais pass.
Maintenant, d'un point de vue logique, écrire "si ceci alors rien sinon autre" peut s'écrire plus simplement "si pas ceci alors autre" ce qui évite un "then" ne faisant rien et un "else" facultatif devenu obligatoire. Faut juste se rappeler les lois de De Morgan qui sont

• not (a ou b) = not a et not b
• not (a et b)=not a ou not b

Code python :

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

1
2
if i != 0 and n != 0 and n != self.longueur+1 :			# if i != 0 and n not in (0, self.longueur+1)
	self.bar[i][n] = round((self.bar[i][n-1]+self.bar[i][n+1]+self.bar[i-1][n]+self.bar[i+1][n])/4,1)

[Aelurus_]

Oui ^^,
Raaaaa, je commence a comprendre que tu avais un peu de train d'avance sur moi ^^.
Effectivement j'ai un souci de copie de tableau ...
Tans que la borne ou que l'effet de bord n'est regardé la copie de tableau [borne,], avec la même adresse (maintenant je comprends ce que "adresse" veut dire) ne pose pas de problème.
Je viens de passer quelques cycles (dirais-je) à ne pas comprendre les traitements que je récupérais car dès que je touchais à une ligne, 6 changeaient ^^.Comment casser tout son code.

Pour

Code python :

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

1
2
if i != 0 and n != 0 and n != self.longueur+1 :			# if i != 0 and n not in (0, self.longueur+1)
	self.bar[i][n] = round((self.bar[i][n-1]+self.bar[i][n+1]+self.bar[i-1][n]+self.bar[i+1][n])/4,1)

[/QUOTE]

Biensur sauf que cette syntaxe me cause une erreur de traitement que je ne comprend pas. C'est à dire que mes bornes change alors qu'elles ne le doivent pas, Aie oui je viens de comprendre.... i==0 or et i!=0 and .....
Je vais regarder de plus près cette règle De Morgan, car passer de si a == 0 ou b == 0 à si a != 0 et b != 0 me pose un problème de compréhension entre le passage du "et" au "ou". 'est donc pour cela que je n'arrivais pas à écrire la boucle avec !=0.
Bon j'ai encore du taff mais la base est plus propre, au moins un peu ^^ :

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
import matplotlib.pyplot as plt
 
class Bar:
    """
    Cette classe sert à calculer le transfert thermique à etat stationnaire en deux dimensions
    selon la méthode du carré de Dichelet, ou carré des moyennes d'une tranche longitudinale  d'une barre
    """    
    def __init__(self,*args):
        t_a, t_d, t_f, longueur, hauteur = args
        self.t_ambiante = t_a# t en °C
        self.t_debut = t_d# t en °C
        self.t_fin = t_f# t en °C
        self.longueur = longueur# l en mm
        self.hauteur = hauteur# h en mm
        """
        construction du tableau ou de la matrice à état initiale, à l'état initial
        nous avons la température ambiante et celle des extrémités, la température
        initial de la tranche est défini à 0 ou à la valeur mini des entrées...
        A défini selon des critères non sélectionnés            
 
        Returns
        -------
                   t_a  t_a t_a t_a... t_a   
            t_d    0    0   0   0  ... 0   t_f
            t_d    0    0   0   0  ... 0   t_f
                   t_a  t_a t_a t_a... t_a 
 
        """
        borne=[t_a,]*(longueur + 2)
        self.bar=[borne[:],] + list(([t_d,] + [0.,]*longueur + [t_f,]) for i in range(hauteur)) + [borne[:],]      
    def calcul_t(self):
        for i in range(self.longueur*self.hauteur):
            for i in range(len(self.bar[:-1])):
                for n in range(len(self.bar[i])):
                    if i != 0 and n != 0 and n != self.longueur+1 :
                        self.bar[i][n] = round((self.bar[i][n-1]+self.bar[i][n+1]+self.bar[i-1][n]+self.bar[i+1][n])/4,1)
 
    def show_bar(self):
        print(self.t_ambiante,"|",self.bar[0][1:7],"  --  ",self.bar[0][-7:-1],"|",self.t_ambiante)
        print("  ","_"*68," ")
        bar=self.bar[1:-1]
        for i in range(len(bar)): 
            print(self.t_debut,"|",bar[i][1:7],"----",bar[i][-7:-1],"|",self.t_fin)
        print("  ","_"*68," ")
        print(self.t_ambiante,"|",self.bar[self.hauteur+1][1:7],"  --  ",self.bar[self.hauteur+1][-7:-1],"|",self.t_ambiante)
 
    def graph_t(self):
        fig, ax = plt.subplots()
        for i in range(int((len(self.bar[1:]))/2)):
            ax.plot(self.bar[i+1],label = str(i+1)+' [mm]')
        ax.set(xlabel='Longueur [mm]', ylabel='Temperature [°C]',
               title="Transfert thermique à l'état stationnaire\ndans une barre de "+str(self.longueur)+" mm et de "
               +str(self.hauteur)+" mm d'épaisseure")
        ax.grid()
        plt.legend(title='Profondeur:',bbox_to_anchor=(1.05, 1), loc='upper left',ncol=3)
        plt.show()
 
c = Bar(13,0,50,15,4)
c.show_bar()
c.calcul_t()
c.show_bar()
c.graph_t()

[wiztricks]

Tans que la borne ou que l'effet de bord n'est regardé la copie de tableau [borne,], avec la même adresse (maintenant je comprends ce que "adresse" veut dire) ne pose pas de problème.

Ici, çà ne pose aucun problème d'écrire:

Code :

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

1
2
        borne=[t_a,]*(longueur + 2)
        self.bar=[borne] + list(([t_d,] + [0.,]*longueur + [t_f,]) for i in range(hauteur)) + [borne]

car l'algo. ne modifie par les "bornes".
=> çà ne change rien d'avoir le même objet.

Par contre, votre code est incomplet: vous devez itérer les appels à calcul_t jusqu'à ce que la différence entre le tableau obtenu et le tableau calculé soient identiques à un epsilon près.

- W

[Sve@r]

(maintenant je comprends ce que "adresse" veut dire).

Oui, je viens du C donc j'ai des habitudes de vocabulaire issues de ce langage. Ceci dit, je dois pas être loin de la vérité vu que Python a été écrit en C.

Je viens de passer quelques cycles (dirais-je) à ne pas comprendre les traitements que je récupérais car dès que je touchais à une ligne, 6 changeaient ^^

Bon, un exemple analogue mais plus simple

Code python :

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

1
2
3
4
a=[1, 2, 3, 4]
b=a
a[0]="toto"
print(b)

Et son équivalent qui fait bien ce que l'on souhaite (c'est à dire créer b vraie copie indépendante de a)

Code python :

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

1
2
3
4
a=[1, 2, 3, 4]
b=list(a)			# b=a[:]
a[0]="toto"
print(b)

Je vais regarder de plus près cette règle De Morgan, car passer de si a == 0 ou b == 0 à si a != 0 et b != 0 me pose un problème de compréhension entre le passage du "et" au "ou". 'est donc pour cela que je n'arrivais pas à écrire la boucle avec !=0.

Tu peux la démontrer par les tables de vérité
Pour le "et"

• a=0, b=0, a et b=0, non(a et b)=1 => non(a)=1, non(b)=1, non(a) ou non(b)=1
• a=0, b=1, a et b=0, non(a et b)=1 => non(a)=1, non(b)=0, non(a) ou non(b)=1
• a=1, b=0, a et b=0, non(a et b)=1 => non(a)=0, non(b)=1, non(a) ou non(b)=1
• a=1, b=1, a et b=1, non(a et b)=0 => non(a)=0, non(b)=0, non(a) ou non(b)=0

Pour le "ou"

• a=0, b=0, a ou b=0, non(a ou b)=1 => non(a)=1, non(b)=1, non(a) et non(b)=1
• a=0, b=1, a ou b=1, non(a ou b)=0 => non(a)=1, non(b)=0, non(a) et non(b)=0
• a=1, b=0, a ou b=1, non(a ou b)=0 => non(a)=0, non(b)=1, non(a) et non(b)=0
• a=1, b=1, a ou b=1, non(a ou b)=0 => non(a)=0, non(b)=0, non(a) et non(b)=0

Et si on veut un exemple plus "réaliste", on peut prendre l'exemple d'un nombre compris entre 1 et 5 s'il est supérieur à 1 et inférieur à 5. L'inverse sera alors s'il est inféreur à 1 ou supérieur à 5.

Une fois admise, suffit de l'appliquer sans plus se poser de questions. Encore ici c'était facile car c'était p1 ou p2 ou p3 qui, inversées, devient non(p1) et non(p2) et non(p3). Là où ça se complique c'est quand on arrive à des p1 et (p2 ou (p3 et p4))) mais en travaillant étape par étape (des parenthèses les plus centrales vers les plus extériieures) on s'en sort => non(p1) ou (non(p2) et (non(p3) ou non(p4)). Et parfois même ça simplifie l'expression.

[Aelurus_]

Ha logique quand tu nous tiens ^^

Code :

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

1
2
3
4
5
6
 
		si a=0 ou b=0	si a!=0 et b!=0
0	1	Vrai	                 Faux
1	0	Vrai	                 Faux
1	1	Faux	                 Vrai
0	0	Vrai	                 Faux

Je vois aussi bien la différence et surtout la possibilité entre égalité et copie. Quand on dit qu'il ce cache dans les détails ^^.
Merci

[Aelurus_]

Bonjour Wiztricks,
tu as tout à fais raison, tant que je ne modifiais pas les bornes je ne voyais pas la différence.

Ici, çà ne pose aucun problème d'écrire:

Code :

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

1
2
        borne=[t_a,]*(longueur + 2)
        self.bar=[borne] + list(([t_d,] + [0.,]*longueur + [t_f,]) for i in range(hauteur)) + [borne]

car l'algo. ne modifie par les "bornes".
=> çà ne change rien d'avoir le même objet.

Par contre, votre code est incomplet: vous devez itérer les appels à calcul_t jusqu'à ce que la différence entre le tableau obtenu et le tableau calculé soient identiques à un epsilon près.

- W

Je ne suis pas sur de comprendre :

Par contre, votre code est incomplet: vous devez itérer les appels à calcul_t jusqu'à ce que la différence entre le tableau obtenu et le tableau calculé soient identiques à un epsilon près.

- W

Ou alors je le fais de manière détournée avec [C]for i in range(self.longueur*self.hauteur)[/] et en arrondissant au dixième de degrés, je définis le nombre d'itération de manière arbitraire.

Code :

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

1
2
3
4
5
6
    def calcul_t(self):
        for i in range(self.longueur*self.hauteur):
            for i in range(len(self.bar[:-1])):
                for n in range(len(self.bar[i])):
                    if i != 0 and n != 0 and n != self.longueur+1 :
                        self.bar[i][n] = round((self.bar[i][n-1]+self.bar[i][n+1]+self.bar[i-1][n]+self.bar[i+1][n])/4,1)

Donc oui je ne vérifie pas l'arret des itération avec la convergence vers la quel tend le calcul de chaque cellule. Je part du principe que je l'obtient avec un nombre de tour suffisant. Pour arreter les iterations je pense que si t-t(calc)<0.00001 on arrete les itérations.J'ai mit cette partie de cotée en partant du principe que j'aurais automatiquement cette convergence avec un nombre d'iteration suffisante.
Je constat aussi que cette question reviens alors que j'essaye d'integrer dans le calcul les effet de bords en rajoutant x [borne[:],] entre la barre et la borne. Ce x est la aussi mit de maniere arbitraire mais sa valeur pourrait être aussi calculé ....
Pour l'instant je suis sur la prise en compte de x ^^ et je crois que je fais une grosse usine à gaz ^^.

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
import matplotlib.pyplot as plt
 
class Bar:
    """
    Cette classe sert à calculer le transfert thermique à etat stationnaire en deux dimensions
    selon la méthode du carré de Dichelet, ou carré des moyennes d'une tranche longitudinale  d'une barre
    """    
    def __init__(self,*args):
        t_a, t_d, t_f, longueur, hauteur = args
        self.t_ambiante = t_a# t en °C
        self.t_debut = t_d# t en °C
        self.t_fin = t_f# t en °C
        self.longueur = longueur# l en mm
        self.hauteur = hauteur# h en mm
        self.n_eff_bord = 3#nombre de hauteur pour traiter l'effet de bord
        """
        construction du tableau ou de la matrice à état initiale, à l'état initial
        nous avons la température ambiante et celle des extrémités, la température
        initial de la tranche est défini à 0 ou à la valeur mini des entrées...
        A défini selon des critères non sélectionnés            
 
        Returns
        -------
                   t_a  t_a t_a t_a... t_a   
            t_d    0    0   0   0  ... 0   t_f
            t_d    0    0   0   0  ... 0   t_f
                   t_a  t_a t_a t_a... t_a 
 
        """
        borne=[t_a,]*(longueur + 2)
        self.bar=[borne[:],]  + \
            list(([t_a,]*(longueur + 2)) for i in range(2)) +\
            list(([t_d,] + [0.,]*longueur + [t_f,]) for i in range(hauteur)) + \
            list(([t_a,]*(longueur + 2)) for i in range(2)) +\
            [borne[:],]
 
        #for i in range(len(self.bar)):
            #print(i,self.bar[i])
    def calcul_t(self):
        for i in range(self.longueur*self.hauteur+self.longueur*2):
            for i in range(len(self.bar[:-1])):
                for n in range(len(self.bar[i])):
                    if i != 0 and n != 0 and n != self.longueur+1 :
                        self.bar[i][n] = round((self.bar[i][n-1]+self.bar[i][n+1]+self.bar[i-1][n]+self.bar[i+1][n])/4,1)
 
    def show_bar(self):
        for i in range(self.n_eff_bord) : 
            print(i,self.t_ambiante,"|",self.bar[i][1:7],"  --  ",self.bar[i][-7:-1],"|",self.t_ambiante)
        print("  ","_"*68," ")
        for i in range(self.n_eff_bord,len(self.bar)-self.n_eff_bord): 
            print(i,self.t_debut,"|",self.bar[i][1:7],"----",self.bar[i][-7:-1],"|",self.t_fin)
        print("  ","_"*68," ")
        for i in range(self.n_eff_bord-1+self.hauteur+1,len(self.bar)) : 
            print(i,self.t_ambiante,"|",self.bar[i][1:7],"  --  ",self.bar[i][-7:-1],"|",self.t_ambiante)
            #print(i)
        #print(len(self.bar))
    def graph_t(self):
        fig, ax = plt.subplots()
        for i in range(self.n_eff_bord+1,int((len(self.bar[1:])+self.n_eff_bord)/2)):
            print(i)
            ax.plot(self.bar[i],label = str(i-self.n_eff_bord)+' [mm]')
        ax.set(xlabel='Longueur [mm]', ylabel='Temperature [°C]',
               title="Transfert thermique à l'état stationnaire\ndans une barre de "+str(self.longueur)+" mm et de "
               +str(self.hauteur)+" mm d'épaisseure")
        ax.grid()
        plt.legend(title='Profondeur:',bbox_to_anchor=(1.05, 1), loc='upper left',ncol=3)
        plt.show()
 
c = Bar(13,125,550,35,4)
c.show_bar()
c.calcul_t()
c.show_bar()
c.graph_t()

Là il me reste au moins à corriger les épaisseurs que je trace, car je n'ai plus le tracer de la moitier des épaisseurs de la barre.

[wiztricks]

Salut,

Ajouter plusieurs couches de "bords", c'est initialiser un intérieur avec des valeurs différentes de 0...

Et comme pour faire les moyennes, vous avez toujours besoin d'avoir des "bords" qui ne changent pas, il va falloir initialiser les "coins" (des couches de bords qui ne sont pas au bord) avec des règles astucieuses à définir.

Donc oui je ne vérifie pas l'arret des itération avec la convergence vers la quel tend le calcul de chaque cellule. Je part du principe que je l'obtient avec un nombre de tour suffisant.

Si vous voulez mais soit il y a trop d'itérations (dommage) ou soit il n'y en a pas assez (et le résultat pourrait être meilleur).

- W

[Sve@r]

Pour arreter les iterations je pense que si t-t(calc)<0.00001 on arrete les itérations.

Tu peux faire mieux: laisser la machine déterminer elle-même quand arrêter les itérations. Te suffit, à chaque itération, de mémoriser la valeur avant de la modifier. Et tu boucles tant qu'elles sont différentes.
Si tu arrives à un état "ancienne_valeur=nouvelle_valeur" ça signifie que tu as atteint la précision maximale de ton ordi et là tu peux alors arrêter d'itérer.

Bien entendu (j'ai pas vérifié si c'était le cas ici) mais ça ne marche que pour des boucles dont la valeur calculée tend vers une limite finie.

[Aelurus_]

Aie, sous entend tu que ce que j'ai fait à ce niveau la n'est pas correct ?

Salut,

Ajouter plusieurs couches de "bords", c'est initialiser un intérieur avec des valeurs différentes de 0...

Et comme pour faire les moyennes, vous avez toujours besoin d'avoir des "bords" qui ne changent pas, il va falloir initialiser les "coins" (des couches de bords qui ne sont pas au bord) avec des règles astucieuses à définir.

- W

Oui je me fais des entorses de neuronnes pour le mettre en place

Tu peux faire mieux: laisser la machine déterminer elle-même quand arrêter les itérations. Te suffit, à chaque itération, de mémoriser la valeur avant de la modifier. Et tu boucles tant qu'elles sont différentes.
Si tu arrives à un état "ancienne_valeur=nouvelle_valeur" ça signifie que tu as atteint la précision maximale de ton ordi et là tu peux alors arrêter d'itérer.

Bien entendu (j'ai pas vérifié si c'était le cas ici) mais ça ne marche que pour des boucles dont la valeur calculée tend vers une limite finie.

Je crois que

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
    def calcul_t(self):
        for t in range(int((self.longueur*self.hauteur))*50):
 
            for i in range(len(self.bar[:-1])):
 
                for n in range(len(self.bar[i])):
                    if i != 0 and n != 0 and n != self.longueur+1 :
                        self.bar[i][n] = round((self.bar[i][n-1]+self.bar[i][n+1]+self.bar[i-1][n]+self.bar[i+1][n])/4,3)
                    if n == self.longueur and i == int(self.hauteur/2)+self.n_eff_bord+1 :
                        #print(self.bar[i][-2:-1])
                        self.t_verif.append(self.bar[i][-2:-1])
            if t>(self.longueur*self.hauteur)/2 and  self.t_verif[-2:-1] == self.t_verif[-2:-1]:
                #print(t,self.t_verif[-2:-1],self.t_verif[-1:])
                break

Fais le job avec une précision à 0.01 °C ce qui sur un plan physique à mon niveau est largement au-delà de ce que je peux observer ^^. Et pour le coup le nombre de cycles est largement inférieur. Wiztrick, j'entends bien que mathématiquement c'est faux bien que ce soit un calcul qui en soi n'a pas de fin ^^.

J'ai l'impression que c'est pas trop faux, le code est biensur à mon niveau ^^ et largement améliorable .

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
import matplotlib.pyplot as plt
 
class Bar:
    """
    Cette classe sert à calculer le transfert thermique à etat stationnaire en deux dimensions
    selon la méthode du carré de Dichelet, ou carré des moyennes d'une tranche longitudinale  d'une barre
    """    
    def __init__(self,*args):
        t_a, t_d, t_f, longueur, hauteur = args
        self.t_ambiante = t_a# t en °C
        self.t_debut = t_d# t en °C
        self.t_fin = t_f# t en °C
        self.longueur = longueur# l en mm
        self.hauteur = hauteur# h en mm
        self.n_eff_bord = 3#nombre de hauteur pour traiter l'effet de bord
        self.t_verif = list()
        """
        construction du tableau ou de la matrice à état initiale, à l'état initial
        nous avons la température ambiante et celle des extrémités, la température
        initial de la tranche est défini à 0 ou à la valeur mini des entrées...
        A défini selon des critères non sélectionnés            
 
        Returns
        -------
                   t_a  t_a t_a t_a... t_a   
            t_d    0    0   0   0  ... 0   t_f
            t_d    0    0   0   0  ... 0   t_f
                   t_a  t_a t_a t_a... t_a 
 
        """
        borne=[t_a,]*(longueur + 2)
        self.bar=[borne[:],]  + \
            list(([t_a,]*(longueur + 2)) for i in range(2)) +\
            list(([t_d,] + [0.,]*longueur + [t_f,]) for i in range(hauteur)) + \
            list(([t_a,]*(longueur + 2)) for i in range(2)) +\
            [borne[:],]
 
        #for i in range(len(self.bar)):
            #print(i,self.bar[i])
    def calcul_t(self):
        for t in range(int((self.longueur*self.hauteur))*50):                                  
            for i in range(len(self.bar[:-1])):                 
                for n in range(len(self.bar[i])):
                    if i != 0 and n != 0 and n != self.longueur+1 :
                        self.bar[i][n] = round((self.bar[i][n-1]+self.bar[i][n+1]+self.bar[i-1][n]+self.bar[i+1][n])/4,3)
                    if n == self.longueur and i == int(self.hauteur/2)+self.n_eff_bord+1 :
                        #print(self.bar[i][-2:-1])
                        self.t_verif.append(self.bar[i][-2:-1])
            if t>(self.longueur*self.hauteur)/2 and  self.t_verif[-2:-1] == self.t_verif[-2:-1]:
                #print(t,self.t_verif[-2:-1],self.t_verif[-1:])
                break
    def show_bar(self):
        for i in range(self.n_eff_bord) : 
            print(i,self.t_ambiante,"|",self.bar[i][1:4],"  --  ",self.bar[i][-4:-1],"|",self.t_ambiante)
        print("  ","_"*68," ")
        for i in range(self.n_eff_bord,len(self.bar)-self.n_eff_bord): 
            print(i,self.t_debut,"|",self.bar[i][1:4],"----",self.bar[i][-4:-1],"|",self.t_fin)
        print("  ","_"*68," ")
        for i in range(self.n_eff_bord-1+self.hauteur+1,len(self.bar)) : 
            print(i,self.t_ambiante,"|",self.bar[i][1:4],"  --  ",self.bar[i][-4:-1],"|",self.t_ambiante)
            #print(i)
        #print(len(self.bar))
    def graph_t(self):
        fig, ax = plt.subplots()
        #ax.plot(self.t_verif[:])
        #print(self.t_verif[-1:])
        for i in range(self.n_eff_bord,int((len(self.bar[:])+self.n_eff_bord)/2)-1):
            ax.plot(self.bar[i],label = str(i-self.n_eff_bord)+' [mm]')
        ax.set(xlabel='Longueur [mm]', ylabel='Temperature [°C]',
               title="Transfert thermique à l'état stationnaire\ndans une barre de "+str(self.longueur)+" mm et de "
               +str(self.hauteur)+" mm d'épaisseure")
 
        ax.grid()
        plt.legend(title='Profondeur:',bbox_to_anchor=(1.05, 1), loc='upper left',ncol=3)
        plt.show()
 
c = Bar(13,0,250,29,6)
#c.show_bar()
c.calcul_t()
c.show_bar()
c.graph_t()