TP : implanter la fonction exponentielle (1/5)

TP : implanter la fonction exponentielle (1/5)#

Imaginez que vous développez la nouvelle librairie de fonctions mathématiques de Python. Au départ, les seules opérations auxquelles vous avez le droit sont les opérations arithmétiques usuelles telles que + * / %. Notre but aujourd’hui est d’écrire la fonction qui calcule \(e^x\).

Pour cela, on utilise la définition de \(e^x\) en tant que série (somme infinie) :

\[e^x = \sum_{n=0}^{+\infty} \frac{x^n}{n!} = 1 + x + \frac{x^2}{2!} + \frac{x^3}{3!} +\cdots+\frac{x^n}{n!}+\cdots\]

On remarque que l’on a besoin en particulier de calculer \(x^n\) ainsi que \(n!\). Ce sera l’objet de la première partie. Dans la deuxième partie, on calculera une approximation de la fonction exponentielle en la tronquant à un nombre fixé de termes; par exemple : \(e^x \simeq 1+\frac{x^2}{2!}+\frac{x^3}{3!}\)

La précision d’une telle approximation dépend beaucoup de la valeur de \(x\). Dans la partie 4 on utilisera une méthode adaptative : on fixera cette fois la précision relative souhaitée et on calculera autant de termes que nécessaire pour atteindre cette précision. Pour cela on aura préalablement défini – et implanté ! – dans la partie 3 ce que l’on entend par précision relative.

Partie 1 : fonctions puissance et factorielle#

Le but de cette partie est d’écrire les fonctions factorielle et puissance et de vérifier que l’on obtient bien les résultats attendus. Complétez la fonction factorielle ci-dessous puis vérifiez les résultats des cellules suivantes :

Astuce

Indication

Utilisez une boucle for avec un compteur et un accumulateur: initialisez l’accumulateur à \(1.0\), puis comptez de \(1\) à \(10\) en multipliant à chaque fois l’accumulateur par la valeur du compteur.

Rappel : si vous le souhaitez, vous pouvez utiliser le raccourci r *= i pour r = r * i.

À faire

  • Choisir et homogénéiser la syntaxe pour les docstrings.

Avertissement

Attention au type du résultat

On veut que les fonctions nous renvoient des nombres à virgule flottante (float). En effet, les divisions dans la série exponentielle nécessitent des nombres décimaux pour éviter des erreurs d’arrondi. De plus, les factorielles deviennent vite énormes \((10! = 3 628 800)\), et un float permet de mieux gérer ces grands nombres. On peut faire en sorte que le résultat soit un float dès son initialisation : resultat = 1.0.

def factorielle(n):
    """ Factorielle
      @param n un entier positif ou nul
      @return la valeur n! en tant que nombre à virgule flottante (float)
    """
    ### BEGIN SOLUTION
    r = 1.0
    for i in range(1, n+1):
        r *= i    # Rappel: c'est équivalent à r = r * i
    return r
    ### END SOLUTION

factorielle(5)

120.0

assert( factorielle(0) == 1   )   # Par convention mathématique
assert( factorielle(3) == 6   )
assert( factorielle(4) == 24  )
assert( factorielle(5) == 120 )
assert( type(factorielle(0)) == float )
### BEGIN HIDDEN TESTS
assert( factorielle(8) == 40320)
### END HIDDEN TESTS

Vérifiez l’ordre de grandeur du calcul suivant. Si la valeur est aberrante, vérifiez l’utilisation du type double à toutes les étapes du calcul.

factorielle(100)

9.33262154439441e+157

Complétez la fonction puissance ci-dessous, puis vérifiez les résultats des cellules suivantes :

Note

En python, on peut utiliser directement l”opérateur puissance **, mais on souhaite ici réimplanter la fonction à titre d’exercice pédagogique.

def puissance( x, n):
    """ Puissance
      @param x un nombre de type float
      @param n un entier positif ou nul
      @return le nombre x^n de type float
    """
    ### BEGIN SOLUTION
    r = 1
    for i in range(n):
        r *= x
    return r
    ### END SOLUTION

puissance(2, 4)

16

assert( puissance(1,  10) == 1     )
assert( puissance(2,   5) == 32    )
assert( puissance(1.5, 3) == 3.375 )

Ajoutez des tests (toujours avec assert) pour vérifier les cas limites : vérifiez (pour une valeur de \(x\) de votre choix) que \(x^0\) vaut \(1\), que \(0^r\) vaut \(0\) pour \(r\) non nul, et que \(0^0\) vaut \(1\) :

### BEGIN SOLUTION
assert( puissance(3, 0) == 1 )
assert( puissance(0, 3) == 0 )
assert( puissance(0, 0) == 1 )
### END SOLUTION

Bilan de la partie 1#

Vous avez maintenant les prérequis pour implanter la fonction exponentielle. Vous pouvez maintenant passer à la partie 2.

Contenu