예제 #1
0
def comptrig1():
    """ Comparaison graphe convergence de y' = a*y(t) + (1-a)*cos(t) -(1-a)*sin(t)  avec y(0) = 1  pour t dans [0,5] avec les 4 méthodes et a = -1"""

    equations.a = -1.
    t0, y0 = 0., 1.
    T = 5.
    h = np.array([0.5, 0.1, 0.01])

    #Définition de la boucle for
    for i in range(0, 3, 1):
        N = int(T / h[i])  #Nombre d'itérations

        [t, y1] = methodes.euler_explicite(t0, h[i], N, y0, equations.f_trig)
        [t, y2] = methodes.RK2(t0, h[i], N, y0, equations.f_trig)
        [t, y3] = methodes.saute_mouton(t0, h[i], N, y0, equations.f_trig)
        [t, y4] = methodes.trapezePC(t0, h[i], N, y0, equations.f_trig)

        # Solution exacte aux mêmes instants
        z1 = equations.sol_trig(t)

        #Graphe des solutions exactes et approchées
        plt.figure(i)
        plt.plot(t, y1, 'b-+')
        plt.plot(t, y2, 'r-+')
        plt.plot(t, y3, 'g-+')
        plt.plot(t, y4, 'm-+')
        plt.plot(t, z1, 'k')
        plt.xlabel('t')
        plt.ylabel('y')
        plt.title("Comparatif des différentes méthodes pour h =" + str(h[i]))

        # Calcul de l'erreur maximum relative
        e1 = np.max(np.abs((z1 - y1) / z1))
        e2 = np.max(np.abs((z1 - y2) / z1))
        e3 = np.max(np.abs((z1 - y3) / z1))
        e4 = np.max(np.abs((z1 - y4) / z1))

        plt.figure(3)
        plt.plot(h[i], e1, 'b-+', label='Méthode Euler explicite')
        plt.legend()
        plt.plot(h[i], e2, 'r-+', label='Méthode du RK2')
        plt.legend()
        plt.plot(h[i], e3, 'g-+', label='Méthode saute-mouton')
        plt.legend()
        plt.plot(h[i], e4, 'm-+', label='Méthode trapèze PC')
        plt.legend()

    plt.xscale('log')
    plt.yscale('log')
    plt.xlabel('h')
    plt.ylabel('e1,e2,e3,e4')
    plt.title("Erreur en fonction du pas h")
    plt.show()
예제 #2
0
def SM1() :
    """Résolution approchée de y' = 1-y avec y(0) = 5 pour t dans [0,1] avec la méthode saute-mouton"""

    equations.a = -1.
    equations.b = 1.
    t0,y0 = 0.,5.
    T = 1.
    h = 0.2

    print("Valeur de l'erreur en fonction de h")

    #Définition de la boucle for
    for i in range(0,6,1) :
        N = int(T/h) #Nombre d'itérations

        [t,y1] = methodes.saute_mouton(t0,h,N,y0,equations.f_affine)

        # Solution exacte aux mêmes instants
        z1 = equations.sol_affine(t,y0)

        # Calcul de l'erreur maximum relative
        e1 = np.max(np.abs((z1-y1)/z1))

    
        #Graphe des solutions exactes et approchées
        plt.figure(1)
        plt.plot(t,y1,'b-+')
        plt.plot(t,z1,'r')
        plt.xlabel('t')
        plt.ylabel('y')
        plt.title("Méthode de saute mouton")

        # Écriture de l'erreur en fonction de h
        print("{0} | {1}".format(h,e1))
        plt.figure(2)
        plt.plot(h,e1,'b-+',label = 'Pour h = '+ str(h))

        h = h/2

    plt.xscale('log')
    plt.yscale('log')
    plt.xlabel('h')
    plt.ylabel('e1')
    plt.title("Erreur en fonction du pas h")
    plt.legend()
    plt.show()