Python en Mathématiques - Niveau 2

Fonction en paramètre d'une fonction

En langage Python, les fonctions peuvent être un paramètre d'une autre fonction.

Tableau de valeurs

Écrire une fonction nommée table() qui respecte les spécifications suivantes :

Paramètres d'entrée une fonction f,
un entier a,
un entier b
Effet affichage de la table des images par f des entiers compris entre a et b.
Valeur renvoyée /
  • Une solution

		
		

Les options d'affichage de la fonction .format() utilisées ici :>4 sont détaillées sur la page de documentation de format.

Coefficient du terme de degré 1

Écrire une fonction nommée coeff_degre1() qui respecte les spécifications suivantes :

Paramètre d'entrée une fonction affine f
Valeur renvoyée la valeur du coefficient du terme de degré 1
  • Une solution

		
		

Coefficient du terme de degré 2

Écrire une fonction nommée coeff_degre2() qui respecte les spécifications suivantes :

Paramètre d'entrée une fonction du second degré f
Valeur renvoyée la valeur du coefficient du terme de degré 2
  • Une solution

A la fonction $f : x \longmapsto ax^2+bx+c $, on associe la fonction $ g(x) = f(x)-f(0) $, c'est à dire la fonction $ g : x \longmapsto ax^2+bx $.

On a alors $ g(1) + g(-1) = 2a $.


		
		

Fonction mystere

Que cherche à mettre en évidence la fonction sym() du code ci-dessous ?


from math import isclose

##----- Définition des fonctions -----##
def trinome1(x):
	return x**2 - 5*x + 6
	
	
def trinome2(x):
	return x**2 + x - 30
	
	
def coeff_degre0(trinome):
	return trinome(0)


def coeff_degre2(trinome):
	def g(x):
		return trinome(x)-trinome(0)
	return ( g(1) + g(-1) )/2
	
	
def coeff_degre1(trinome):
	def g(x):
		return trinome(x)-trinome(0)
	return ( g(1) - g(-1) )/2
	

def sym(trinome, x) :
	xsym = - coeff_degre1(trinome) / (2 * coeff_degre2(trinome))
	return isclose(trinome( xsym + x), trinome( xsym - x))
	 
	
##----- Tests et interaction -----##
print(sym(trinome1, 2.1))
  • Une solution

La fonction met en évidence la propriété de symétrie de la courbe représentative d'un polynôme du second degré.

Coefficient du terme de degré 3

Écrire une fonction nommée coeff_degre3() qui respecte les spécifications suivantes :

Paramètre d'entrée une fonction f polynôme de degré 3
Valeur renvoyée la valeur du coefficient du terme de degré 3
  • Une solution

		
		

Comparaison de fonctions

  1. Écrire une fonction nommée compare() qui respecte les spécifications suivantes :
    Paramètres d'entrée une fonction f,
    une fonction g,
    un entier a,
    un entier b
    Sortie True si f(x) $\leqslant$ g(x) pour tout entier x entre a et b, False sinon.
  2. Modifier le script afin qu'il compare f(x) et g(x) pour x entre a et b, avec un pas de 1/10 entre deux valeurs.
  • Question 1
  • Question 2
  • Question 2, autre réponse

		
		

		
		

Le module numpy propose une version de range() qui accepte des float en paramètres.

arange(a, b, pas) renvoie les nombres de l'intervalle [a ; b[ qui s'écrivent a, a+pas, a+2*pas, a+3*pas, ...


from numpy import arange

##----- Définition des fonctions -----##
def compare(f, g, a, b) :
	for x in arange(a, b+0.1, 0.1) :
		if f(x) > g(x) : return False
	return True

		
def carre(x) :
	return x*x
	
def cube(x) :
	return carre(x) * x


##----- Tests et interaction -----##
print( compare(carre, cube, 0, 1) )

Linéaire ou non ?

On considère le script Python suivant :


from math import pi

##----- Définition des fonctions -----##
def test(f, a, b) :
	"""
	f est une fonction.
	a et b sont deux nombres réels du domaine de définition de f.
	"""
	return f(a + b) == f(a) + f(b)
	
	
def carré(x) :
	return x*x
	
def f1(x) :
	return  -2 * x + 4
	
def f2(x) :
	return pi * x
	
def f3(x) :
	return -7.2 * x
	
def inverse(x) :
	return 1/x
	
def opposé(x) :
	return -x
	
	
##----- Tests et interaction -----##
a, b = 3, 5
print("Test avec f1 : ", test(f1, a, b) )
print("Test avec f2 : ",  test(f2, a, b) )
print("Test avec f3 : ",  test(f3, a, b) )
print("Test avec carré : ",  test(carré, a, b) )
print("Test avec inverse : ",  test(inverse, a, b) )
print("Test avec opposé : ",  test(opposé, a, b) )
  1. Quel est le type de la valeur renvoyée par la fonction test() ?
  2. Sans faire tourner le programme, prévoir ce que seront les affichages ?
  3. Les résultats obtenus à l'affichage suffisent-ils à prouver que les fonctions f1(), carré(), inverse() ne sont pas linéaires ?
  4. Les résultats obtenus à l'affichage suffisent-ils à prouver que les fonctions f2(), f3(), opposé() sont linéaires ?
  • Question 1
  • Question 2
  • Question 3
  • Question 4
  • Complément Python
La fonction test() renvoie un booléen (c'est-à-dire True ou False).

Les affichages obtenus :

Test avec f1 :  False
Test avec f2 :  True
Test avec f3 :  True
Test avec carré :  False
Test avec inverse :  False
Test avec opposé :  True
Il s'agit ici de travailler sur la notion de contre-exemple.
Il s'agit ici de retravailler l'idée qu'exemple ne vaut pas preuve. Ce peut-être l'occasion de refaire la démonstration de la linéarité d'une fonction $ x \longmapsto kx $.

Pour éviter de répéter des lignes très proches l'une de l'autre lors des tests, on peut procéder ainsi :


from math import pi

##----- Définition des fonctions -----##
def test(f, a, b) :
	"""
	f est une fonction.
	a et b sont deux nombres réels du domaine de définition de f.
	"""
	return f(a + b) == f(a) + f(b)
	
def affiche_résultat_test(f, a, b) :
	print("Le test avec a = {}, b = {} a donné pour la fonction {} : {}.".format(a,b,f.__name__, test(f,a,b)))
	
	
def carré(x) :
	return x*x
	
def f1(x) :
	return  -2 * x + 4
	
def f2(x) :
	return pi * x
	
def f3(x) :
	return -7.2 * x
	
def inverse(x) :
	return 1/x
	
def opposé(x) :
	return -x
	
	
##----- Tests et interaction -----##
a, b = 3, 5
fonctions = [f1, f2, f3, carré, inverse, opposé]
for f in fonctions :
	affiche_résultat_test(f, a, b)

On obtient :

 
Le test avec a = 3, b = 5 a donné pour la fonction f1 : False.
Le test avec a = 3, b = 5 a donné pour la fonction f2 : True.
Le test avec a = 3, b = 5 a donné pour la fonction f3 : True.
Le test avec a = 3, b = 5 a donné pour la fonction carré : False.
Le test avec a = 3, b = 5 a donné pour la fonction inverse : False.
Le test avec a = 3, b = 5 a donné pour la fonction opposé : True.

Recherche d'une racine par dichotomie

On dispose d'une fonction $f$ continue et strictement monotone sur un intervalle [$a$ ; $b$], telle que $f(a)$ et $f(b)$ soient de signes opposés.

Pour déterminer une racine $\alpha$ de la fonction $f$ à une précision $ε$ (c'est-à-dire déterminer une valeur $x$ telle que $|x - \alpha | < ε$), on procède comme suit (dichotomie) :

  • On détermine le milieu $m$ de l'intervalle $[a ; b]$.
  • On compare le signe de $f(m)$ avec celui de $f(a)$ pour déterminer dans quel intervalle ($[a ; m]$ ou $[m ; b]$) se situe $\alpha$.
  • On affecte à $a$ la valeur de $m$ si $\alpha \in [m ; b]$, sinon on affecte à $b$ la valeur de $m$.
  • On revient au premier point tant que la distance entre $a$ et $b$ est supérieure à $ε$.

Écrire une version Python de cet algorithme.

  • Un code possible
  • Variante syntaxique
  • Un graphique

		
		

		
		

Sans détailler chaque ligne, donnons ici quelques instructions clefs pour la représentation graphique :


import numpy as np
import matplotlib.pyplot as plt

##----- Définition des fonctions -----##
def represente_courbe(f, a, b, n, racine) :
    """ on représente f sur [a,b] en découpant [a;b] en n intervalles
    de même longueur. Place la "racine". """
    liste_abscisses = np.linspace(a, b, n+1)
    liste_ordonnees = [ f(x)  for x in liste_abscisses ]
    plt.plot(liste_abscisses, liste_ordonnees, r, 0, "^")
    plt.grid()
    plt.show()


def g(x) :
    return (x - 2**0.5) * (x + 2**0.5)

def sont_de_signes_opposes(p,q) :
    return p*q < 0

def dichotomie(f, epsilon, a, b) :
    """ f est supposée continue, strictement monotone sur [a;b]
    avec f(a) et f(b) de signes opposés."""

    while abs(b-a) > epsilon :
        m = (a+b)/2
        if f(m) == 0 :
            a = b = m
        if sont_de_signes_opposes(f(a),f(m)):
            (a,b) = (a, m)
        else:
            (a,b) = (m, b)

    return m

##----- Tests et interaction -----##
r = dichotomie(g, 1e-4, 0, 10)
represente_courbe(g, 0, 10, 10, r)	  

On obtient :

courbe