1
votes

Code de boucle avec: {x_ (n + 1) = x_n * r * (1- x_n)}

Peu de nouveautés ici et toute aide serait appréciée.

Je travaille avec ce code depuis un moment maintenant et je n'arrive pas à comprendre. Je suis assez nouveau en python, donc je ne sais pas ou ne me souviens pas encore de toutes les astuces / compétences.

Donc la question à portée de main:

Équation: {x_ (n + 1 ) = x_n * r * (1- x_n)}

Avec x_n entre (0,1) et r entre (0,4).

Le but ici est de créer une fonction de boucle qui rassemblera une valeur pour 'x_n' et 'r' et crachera l'itération 'n' et l'actuel 'x_n + 1'; c'est-à-dire print (n, x_n + 1), à chaque pas 'n' tout en vérifiant si la nouvelle valeur est à moins de 0,0000001 de l'ancienne valeur.

Si elle s'installe sur un point fixe entre 20 000 (0,0000001 ), imprimez le message final 'n' +. Si ce n'est pas le cas et passe à 20 000, imprimez un autre message.

Tout ce que j'ai jusqu'à présent, c'est:

import math

x_o=float(input("Enter a 'seed' value: "))
r=float(input("Enter an 'r' value: "))
x_a=((x_o + 0) * r * (1-(x_o + 0)))

while x_a != (0.0000001, x_o , 0.0000001):
  for n in range(0,99):
    x_a=((x_o + n) * r * (1-(x_o + n)))
    print(n , x_a)

Je suis presque sûr que ce n'est pas où fermer donc toute aide serait géniale; si vous avez besoin de plus d'informations, faites-le moi savoir.

Très apprécié, Génosphère

python loops while-loop range

0 commentaires

3 Réponses :

0
votes

Vous avez pris un bon départ jusqu'à présent. Vous y réfléchissez peut-être trop.

L'approche suivante essaie simplement de générer cette séquence pour 20 000 termes. À chaque fois, il vérifie si la nouvelle valeur est comprise entre 0,0000001 et la valeur précédente. Si tel est le cas, il sort de la boucle et l'imprime. Sinon, il utilise la construction for / else de python pour afficher une valeur différente. Notez les différents niveaux d'indentation .

x_0 = float(input("enter a 'seed' value: "))
r = float(input("enter an 'r' value: "))

x_m = x_0  # placeholder for 'previous value'
delta = 0.0000001

# Try to calculate 20 thousand terms of this sequence
# We will break out of the loop early if our x_n converges
for _ in range(20000):  
    x_n = x_m * r * (1 - x_m)
    if abs(x_n - x_m) < delta:
        print("Settled on value for x_n: ", x_n)
        break
    else:
        x_m = x_n  # move forward to the next value
else:
  print("x_n did not converge in 20000 terms")

1 commentaires

Je suis très probablement, une mauvaise habitude à moi. Je jetterai un coup d'oeil quand j'aurai une chance. J'apprécie l'aide à ce jour.

1
votes

Il s'agit d'une moyenne mobile pondérée de manière exponentielle. Pandas a une fonction pour cela: https: / /pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.ewm.html

0 commentaires

2
votes

Vous pouvez écrire une fonction de générateur et l'utiliser directement dans votre boucle for. Si vous avez besoin de garder une trace du rang des valeurs intermédiaires, vous pouvez utiliser enumerate sur le générateur.

maxCount = 20000
n,Xn = max(zip(range(maxCount+1),fnIter(lambda x:x*r*(1-x),seed)))

if n < maxCount:
    print(n,Xn)
else:
    print(Xn,"not converging")

sortie:

r    = 2
seed = 0.1
for i,Xn in enumerate(fnIter(lambda x:x*r*(1-x),seed)):
    print(i,Xn)

0 0.1
1 0.18000000000000002
2 0.2952
3 0.41611392
4 0.4859262511644672
5 0.49960385918742867
6 0.49999968614491325
7 0.49999999999980305

Pour implémenter la vérification d'itération maximale, vous pouvez soit ajouter une rupture conditionnelle dans la boucle ou utiliser zip avec une plage:

def fnIter(fn,x,delta=0.000001):
    while True:
        yield x
        prev,x = x,fn(x)
        if abs(x-prev)<delta:break

1 commentaires

Merci, je le regarderai quand j'aurai un moment.