Comment programmer cette équation?

Question

Bonjour, Je cherche à programmer une équation mais je ne parviens pas. ça donne toujours des erreurs quand je compile le programme. voici l'équation à programmer:

Le programme en python:

sigmam= 0.43
a= 3.8
tmax= 100
N=150
r= 0,5
P= 75

zi1 = np.zeros(N+2)
zi1[0] = 0.25

for t in range (tmax):
    for i in range(1,N) :   
            S11= []        
            for j in range ((i-P), (i+P)):      
                if j<0:            
                    j=j+N
                if j>=0:                
                    j=j-N    
                S11=S11+((a*zi1[j]*(1-zi1[j]))-(a*zi1[i]*(1-zi1[i])))
            S11=(sigmam/(2*P))*S11
           
x = []
y1= []
for t in range (tmax):
            zi1[t+1]= a*zi1[i]*(1-zi1[i])+S11
            x.append(float(t))
            y1.append(float(zi1[t+1]))
pl.plot(x,y1)

L'erreur affichée

File "/Users/Ahamat/Desktop/untitled5.py", line 49, in <module>
zi1[t+1]= a*zi1[i]*(1-zi1[i])+S11

ValueError: setting an array element with a sequence.

Le resultat attendu de cette équation

jordane45 · Answer

Bonjour

Je n'ai pas regardé en détails.. mais il ne faudrait pas mettre des "t" à la place des "i" ?

Ahamat004 · Answer

@jordane45 bonjour. Même en remplaçant i à la place ça donne toujours des erreurs.

mamiemando · Answer

Bonjour,

Ta fonction est définie de manière récursive mais ni f ni z0 ni sigma ni P ne sont définis dans leur formulation mathématique. Ensuite, ta somme dépend des zjt et des zit et ce serait une bonne idée de mémoriser les termes intermédiaires (voir programmation dynamique) car écrire la fonction récursive telle quelle sera beaucoup plus coûteux.

Vu que t est un paramètre muet, je suppose qu'on peut ignorer t, et voir (z_it) comme une suite (u_i). Est-ce le cas ?

Bonne chance

mamiemando · Answer

Bonjour,

Vu que je ne comprends pas ce que sont a et t dans ce que tu expliques, je vais te montrer comment tu peux faire sur un exemple classique, une suite de Fibonnacci et te laisse l'adapter. C'est quasiment le même sujet que toi puisqu'un le terme à l'index i dépend des termes précédents.

Voici la version récursive :

def fibonacci_rec(i: int, f0: int = 0, f1: int = 1) -> int:
    if i == 0:
        # F_0 = 0
        ret = f0
    elif i == 1:
        # F_1 = 1
        ret = f1
    else:
        # F_n = F_{n-1} + F_{n-2}
        ret = fibonacci_rec(i - 1) + fibonacci_rec(i - 2)
    return ret

def fibonacci(i: int, f0: int = 0, f1: int = 1) -> int:
    return fibonacci_rec(i, f0, f1)

for i in range(0, 16):
    print(f"F_{i} = {fibonacci(i)}")

Voici la version en programmation dynamique : l'idée est d'accumuler les résultats précédents dans un dictionnaire d.

def fibonacci_dp(i: int, d: dict, f0: int = 0, f1: int = 1) -> int:
    ret = d.get(i)
    if ret is None:
        if i == 0:
            # F_0 = 0
            ret = f0
        elif i == 1:
            # F_1 = 1
            ret = f1
        else:
            # F_n = F_{n-1} + F_{n-2}
            ret = fibonacci_dp(i - 1, d) + fibonacci_dp(i - 2, d)
    d[i] = ret
    return ret

def fibonacci(i: int, f0: int = 0, f1: int = 1) -> int:
    d = dict()
    return fibonacci_dp(i, d, f0, f1)

for i in range(0, 16):
    print(f"F_{i} = {fibonacci(i)}")

Comme tu peux le voir le code est extrêmement proche de la version récursive.

Note : pour plus de performances on peut même remplacer les dernières lignes par :

d = dict()
for i in range(0, 16):
    print(f"F_{i} = {fibonacci_dp(i, d)}")

... car comme ça au cours de la boucle for, les calculs intermédiaires sont partagés.

Bonne chance

Comment programmer cette équation?

4 réponses

Discussions similaires

Newsletters