Python en Mathématiques - Niveau 2

Tracé de courbes avec matplotlib

Affine par morceaux

  1. Écrire un script (programme) Python pour obtenir le graphique suivant :
    zigzag
  2. Écrire une fonction Python nommée f() permettant d'obtenir un tel graphique sur l'intervalle [m ; M], où m et M sont des entiers relatifs passés en paramètres.
  3. Écrire une fonction Python nommée g() qui renvoie l'image du réel $x$ où $x \in [m ; M]$, $m$ et $M$ sont des entiers relatifs, et dont le graphe est celui de la question précédente.
  • Question 1
  • Question 2
  • Question 3

from matplotlib.pyplot import *
  
X = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Y = [ 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]

# construction du graphique :
plot(X, Y, 'g-', linewidth=4)
# pour imposer repère orthonormé :
axis('equal')
# tracé d'une grille en fond :
grid()
# pour voir le résultat :
show()

from matplotlib.pyplot import *

def f(m, M) :

	X = list(range(m, M+1)) 		# équivalent de X = [ k for k in range(m,M+1) ] 
	Y = [ n%2 for n in X ]

	# construction du graphique :
	plot(X, Y, 'g-', linewidth=4)

	# pour imposer repère orthonormé :
	axis('equal')

	# tracé d'une grille en fond :
	grid()

	# pour voir le résultat :
	show()

##----- Appel de la fonction sur l'intervalle [-5 ; 6] -----##
f(-5, 6)

Un code possible :


from matplotlib.pyplot import *
from math import floor          # floor : fonction partie entière
# from numpy import arange

def f(x) :
    if floor(x)%2 == 0 :
        return x-floor(x)
    else :
        return -x+ floor(x)+1


###############################################
#  Graphique pour vérification de la formule  :
###############################################
m = -5
M = 6

X = [m+i/10 for i in range(10*(M-m)+1)]     # liste [m, m+0.1, m+0.2, m+0.3, m+0.4, ..., M]
                                            #  arange(m, M+0.1, 0.1) en important le module numpy
Y = [ f(x)  for x  in X ]

# construction du graphique :
plot(X, Y, 'g-', linewidth=4)
# pour imposer repère orthonormé :
axis('equal')
# tracé d'une grille en fond :
grid()
# pour voir le résultat :
show()

Encore de l'affine par morceaux

  1. Écrire une fonction Python nommée somme_des_impairs() et qui respecte les spécifications suivantes :
    Paramètre : un entier naturel n non nul
    Valeur renvoyée : la somme des n premiers entiers impairs.
  2. Conjecturer une formule exprimant la somme des $n$ premiers entiers impairs à l'aide du programme précédent.
  3. A l'aide de la conjecture précédente, conjecturer une formule exprimant la somme des $n$ premiers entiers pairs (non nuls).
  4. En s'aidant des formules conjecturées, écrire une fonction Python de paramètre l'entier n strictement positif correspondant au nombre de« motifs » et réalisant un graphique tel que les suivants :
    • Avec n = 3 : graphique 3 motifs
    • Avec n = 4: graphique 4 motifs
    • Avec n = 5: graphique 5 motifs

    A vous de comprendre la construction...
  • Question 1
  • Question 2
  • Question 3
  • Question 4

			
			

On conjecture que la somme des $n$ premiers entiers impairs est égale à $n^2$.

La somme des $n$ premiers entiers pairs non nuls est obtenue en ajoutant 1 à chacun des entiers qui intervient dans la somme des $n$ premiers entiers impairs. La formule serait donc $n^2 + n = n(n+1)$.


from pylab import plot, show, axis, grid, subplots
import numpy

def graphe(n) :
    X = [0]
    Y = [0]
    for k in range(1, n+1):
        X.append(k*k)
        Y.append(k)
        X.append(k*(k+1))
        Y.append(0)

    # numérotation sur les axes :
    ax = subplots()[1]
    ax.set_xticks(list(range(0, (n+1)**2, 2)))
    ax.set_yticks(list(range(0, n+1, 1)))

    # construction du graphique :
    plot(X, Y, 'r-', linewidth=2)
    # tracé d'une grille en fond :
    grid()
    # pour voir le résultat :
    show()

##----- Graphique test -----##
graphe(5)

Une fonction du second degré

Tracer la courbe représentative de $ f : x \longmapsto 2 x^2 -3 x +1 $ sur l'intervalle $[-10 ; 10]$.

  • Liste d'abscisses
  • Courbe

Pour la fonction affine par morceaux précédente, il suffisait de disposer des extrémités des segments.

Pour une fonction quelconque, on cherchera à disposer de découpages plus fins des intervalles.

Première méthode : une boucle


			
			

Seconde méthode : numpy

Le module numpy propose la fonction arange() qui est une « extension » de la fonction range() avec des paramètres flottants :


from numpy import arange
 
debut, fin, pas = -2, 2, 0.2 
liste_abscisses = arange(debut, fin, pas)
print(liste_abscisses)

ce qui donne :

	[ -2.00000000e+00  -1.80000000e+00  -1.60000000e+00  -1.40000000e+00
  -1.20000000e+00  -1.00000000e+00  -8.00000000e-01  -6.00000000e-01
  -4.00000000e-01  -2.00000000e-01  -4.44089210e-16   2.00000000e-01
   4.00000000e-01   6.00000000e-01   8.00000000e-01   1.00000000e+00
   1.20000000e+00   1.40000000e+00   1.60000000e+00   1.80000000e+00]

On constate notamment un arrêt de la liste avant fin (analogue à ce qu'il se passe pour range()).

Le même module numpy propose également :


from numpy import linspace
 
debut, fin, nombre_de_valeurs = -2, 2, 10 
liste_abscisses = linspace(debut, fin, nombre_de_valeurs)
print(liste_abscisses)

ce qui donne :

[-2.         -1.55555556 -1.11111111 -0.66666667 -0.22222222  0.22222222
  0.66666667  1.11111111  1.55555556  2.        ]

Tracé de la courbe :


from matplotlib.pyplot import *

#----- Définition des fonctions -----##
def creation_liste_abscisses(debut, fin, pas) :
	liste_abscisses = []
	valeur = debut
	while valeur <= fin :
		liste_abscisses.append(valeur)
		valeur += pas
	return liste_abscisses


def f(x) :
	return 2*x**2-3*x+1 

##----- Tracé du graphique -----##

liste_abscisses =  creation_liste_abscisses(-10, 10, 0.1)
liste_ordonnees = [ f(x)  for x  in liste_abscisses]

# construction du graphique :
plot(liste_abscisses, liste_ordonnees, 'g-', linewidth=2)


# tracé d'une grille en fond :
grid()

# pour voir le résultat :
show()

On obtient :

parabole

Avec linspace, la liste des ordonnées peut être déterminée encore plus directement avec le code f(liste_abscisses) :


from matplotlib.pyplot import *
from numpy import linspace

#----- Définition des fonctions -----##
def f(x) :
	return 2*x**2-3*x+1


##----- Tracé du graphique -----##

liste_abscisses = linspace(-10, 10, 40)

# construction du graphique :
plot(liste_abscisses, f(liste_abscisses), 'g-', linewidth=2)

# tracé d'une grille en fond :
grid()

# pour voir le résultat :
show()

Il en va de même avec arange() :


from matplotlib.pyplot import *
from numpy import arange

#----- Définition des fonctions -----##
def f(x) :
	return 2*x**2-3*x+1


##----- Tracé du graphique -----##
liste_abscisses = arange(-10, 10, 0.1)

# construction du graphique :
plot(liste_abscisses, f(liste_abscisses), 'g-', linewidth=2)

# tracé d'une grille en fond :
grid()

# pour voir le résultat :
show()