import numpy as np
import matplotlib.pyplot as plt



def f(a,x):
    return .............



# d'abord on a une fonction qui calcule la liste des termes de la suite

def liste_termes(a,u0,N):
    .................
    
a=2.3
u0=0.6

# définition de la liste des abscisses
X = np.linspace(...,...,...)
plt.plot(...,...) # tracé de la bissectrice
# courbe de f
Y = f(a,X) # opérations composante par composante sur les np.array
plt.plot(...,...)


### premier segment ###
u = u0
v = ... # v vaut maintenant u1
plt.plot(...,...)

### segments suivants ###
N = ... # mettre la valeur de votre choix, c'est le nombre de termes à dessiner
for k in range(N): # avant la nème itération u vaut u_(n-1) et v vaut u_n
    plt.plot([...,...,...],[...,...,...])
    # et on "passe au rang suivant"
    u = v
    v = f(a,v)
plt.grid() # affichage d'une grille pour la lisibilité
plt.show() # affichage



# escalier - escargot : 
# on regroupe toutes les étapes précédentes dans une fonction

def trace(a,u0,N):
    plt.figure(dpi=600)
 	# tracé de la courbe et de la droite
    X = np.linspace(...,...,...)
    plt.plot(...,...,color='black',linewidth=0.7) # tracé de la bissectrice
    # Y = [f(a,x) for x in X]
    Y = f(a,X)
    plt.plot(...,...,color='black',linewidth=0.7)
    ### tracé de la ligne brisée
 	## premier segment
    u = u0
    v = ... # v vaut u_1
    plt.plot(...,...,color='blue',linewidth=1.5)
    
    # tracé de la ligne brisée sur n étapes
    for k in range(N): # avant la kème itération u vaut u_(k-1) et v vaut u_k
        plt.plot([...,...,...],[...,...,...],color='blue',linewidth=1.5)
        u = v
        v = f(a,v) # on "passe au rang suivant"
        
    plt.axis([0,1,0,f(a,0.5)+0.1])
    plt.grid() # affichage d'une grille pour la lisibilité
    # plt.savefig('esc.png')
    plt.show() # affichage
    
    

    
##### tracé du diagramme de bifurcation



# pour zapper le régime transitoire on omet les m premiers termes de la suite


def liste_termes_asympt(a,u0,m,N):
    ........

 
 
# diagramme de bifurcation


def bifurc(a_min,a_max,nb_a,m,N,u0):
    plt.figure(dpi=400) # pour une figure à résolution élevée
    for a in .............. :
        plt.scatter( ...... , liste_termes_asympt(...,...,...,...),
		            s=0.01,color='blue',marker='.')
    plt.show()


bifurc(2.4,4,1000,100,100,0.3)



# escalier - escargot en zappant le régime transitoire
# il suffit pour cela d'invoquer la fonction trace, en remplacant
# u_0 par u_m
    
def trace_asympt(a,u0,m,N):
    # on calcule u_m en itérant f m fois
    ......
    # puis on trace l'escalier / escargot à partir de ce terme
    trace(...,...,...)