Voici une astuce qui pourra sans doute servir à plusieurs d’entre vous.
Une fonction peut quelques fois devoir prendre un nombre variable d’arguments. Par exemple, si l’on souhaite calculer le PGCD de plusieurs nombres, on aimerait que la fonction PGCD (par exemple) accepte 2, 3, 4, … arguments.
Voici sur un exemple comment faire:
def pgcd(*n): def _pgcd(a,b): while b!=0: a,b = b,a%b return a p = _pgcd(n[0],n[1]) for x in n[2:]: p = _pgcd(p,x) return p print(pgcd(165,515,225,65))
Alors ? On kiffe ?
L’ensemble de Julia est, pour un nombre complexe c donné, l’ensemble des points d’affixes \(z_0\) tels que la suite définie pour tout entier naturel n par \(z_{n+1}=z_n^2+c\) est bornée.
Selon les valeurs de c, on peut obtenir des ensembles plutôt jolis:
Pour les personnes abonnées à mathweb.fr, vous trouverez un code Python ainsi que les 10 images (sans marquage) sur cette page.
Pour la faire courte, l’ensemble de Mandelbrot est l’ensemble des points du plan complexe d’affixe c tels que la suite définie par \( \left\lbrace\begin{array}{l} z_0=0\\z_{n+1}=z_n^2+c\end{array}\right. \) est bornée.
Cet ensemble peut être construit à l’aide de Python, et de son module pygame. La vitesse à laquelle l’ensemble est construit est remarquable! Sur mon ordinateur (16 Mo RAM, sous Windows, processeur Intel Core i5), cela ne met pas plus de 10 secondes pour afficher ceci:
Avec une autre suite, j’ai obtenu:
Je vous l’accorde, elle est nettement moins esthétique que la première, mais je ne suis pas Julia, ni Fatou 🙂
Les abonné.e.s de mathweb.fr trouveront les codes Python de ces deux fractales sur cette page.
Je ne suis pas très fan du module turtle, car je préfère la programmation numérique, mais il faut bien avouer que ce module est pratique pour dessiner des schémas récursifs, comme les fractales.
Je me suis donc mis à la recherche d’un code donnant un tel schéma pour tenter de me familiariser avec le module. J’avais une idée bien précise : celle d’un arbre fractal, que j’avais vu quelque part.
Après quelques recherches, je suis enfin tombé sur le code suivant (que je me suis permis de commenter):
from turtle import *
angle = 30
color('#3f1905')
def arbre(n,longueur):
if n==0:
color('green')
forward(longueur) # avance
backward(longueur) # recule
color('#3f1905')
else:
width(n)
forward(longueur/3) #avance
left(angle) # tourne vers la gauche de angle degrés
arbre(n-1,longueur*2/3)
right(2*angle) # tourne vers la droite de angle degrés
arbre(n-1,longueur*2/3)
left(angle) # tourne vers la gauche de angle degrés
backward(longueur/3) # recule
hideturtle() # cache la tortue
up() # lève le stylo
right(90) # tourne de 90 degrés vers la droite
forward(300) # avance de 300 pixels
left(180) # fait un demi-tour
down() # pose le stylo
arbre(11,700) # exécute la macro
showturtle() # affiche la tortue
mainloop()
qui donne ceci:
Mais attention… Le dessin met un certain temps avant d’être fini (par exemple, sur mon ordinateur 16 Mo de RAM, processeur Intel Core i5, il met une vingtaine de minutes… arf !)
Si on modifie l’angle (disons pour le mettre à 50°), on obtient ceci:
Et avec un angle de 110° :
N’est-il pas choupinou ? 🙂
Vous pouvez remarquer dans le code la fonction récursive : c’est une notion que l’on verra en NSI (nouveau lycée)… mais prévue en cycle de maturité (en Terminale quoi !)… même si je n’ai pas pu résister à l’envie d’en mettre dans mon livre d’exercices corrigés qui sortira en version papier pour la rentrée 2019.
Une fonction récursive est une fonction qui fait appel à elle-même dans sa définition. On retrouve ce genre de fonction par exemple pour calculer le pgcd de deux nombres:
def pgcd(a,b):
if b==0:
return a
else:
r=a%b
return pgcd(b,r)
print(pgcd(56,42))
Ici, la récursivité s’appuie sur la propriété du pgcd qui stipule que:$$\text{pgcd}(a,b)=\text{pgcd}(b,r)$$où \(a = bq + r,\ 0\leq r < b\).
Les mathématiques sont donc très importantes pour construire des algorithmes (et par suite des programmes) performants. En effet, on aurait très bien pu calculer le pgcd de la manière suivante:
def pgcd(a,b):
while b<>0:
r=a%b
a,b=b,r
return a
print(pgcd(56,42))
Pour comparer deux algorithmes, on parle souvent de complexité. Cet article ne parle pas de cette notion, mais sachez tout de même que la complexité d’une fonction récursive est donnée par une suite arithmético-géométrique. Dans la fonction pgcd, il y a 2 instructions élémentaires (le test sur b et l’affectation de r). La complexité \(C_n\) est donc égale à \(2+C_{n-1}\), où \(C_{n-1}\) est celle de la fonction pgcd(b,r). On démontre alors que la complexité de la fonction récursive est de l’ordre de O(n) [complexité linéaire]. En fait, la complexité est linaire dans le pire des cas (quand a et b sont deux nombres successifs de la suite de Fibonacci), car dans les autres cas, la complexité est logarithmique [O(ln(n))].
L’évaluation moyenne de la complexité de l’algorithme d’Euclide version récursive est assez compliquée. Le nombre d’appels moyen de la fonction pgcd est:$$\frac{12\ln(2\ln n)}{\pi^2}+1,47.$$
http://imss-www.upmf-grenoble.fr/prevert/Prog/Complexite/euclide.html
La complexité de l’algorithme non récursif est quasi-identique à sa version récursive.
https://www.labri.fr/perso/betrema/deug/poly/euclide.html
La version récursive de l’algorithme d’Euclide est peut-être un peu plus facile à écrire que la version itérative. Les deux versions ont fondamentalement la même complexité, avec un petit avantage à la version itérative, car l’appel d’une fonction n’est pas gratuit.
Mais là, je m’égare… Saint-Lazare !
Cet article est accessible aux élèves de lycée dès la classe de Terminale.
Vous savez ce qu’est un polynôme ? C’est une expression de la forme:$$P(x)=\sum_{k=0}^n a_kx^k=a_nx^n+a_{n-1}x^{n-1}+\cdots+a_1x+a_0.$$
Vous savez ce qu’est une racine d’un polynôme ? C’est une valeur r telle que P(r)=0.
Vous savez ce que sont les nombres complexes ? Ce sont des nombres qui s’écrivent sous la forme a + ib, où i² = -1. Ce sont des nombres imaginaires.
La formule de Viète, du nom du mathématicien français du XVIème siècle François Viète, nous dit que la somme des racines complexes du polynôme P est égale à \(-\frac{a_{n-1}}{a_n}\).
La démonstration de cette formule est assez simple si l’on connaît le théorème de Gauss stipulant que tout polynôme de degré n admet exactement n racines complexes. Ainsi, tout polynôme de degré n peut se factoriser sous la forme : $$P(x)=a_n(x-r_1)(x-r_2)(x-r_3)\cdots(x-r_{n-1})(x-r_n)$$ où \(r_1,\ r_2,\ \ldots,\ r_n\) représentent les n racines complexes du polynôme.
En développant partiellement la forme factorisée, on obtient:$$P(x)=a_nx^n-a_n(r_1+r_2+\cdots+r_n)x^{n-1}+\cdots+(-1)^na_nr_1r_2\cdots r_n.$$Par identification avec la forme développée:$$P(x)=a_nx^n+a_{n-1}x^{n-1}+\cdots+a_1x+a_0,$$les coefficients des \(x^{n-1}\) doivent être égaux, et donc:$$a_{n-1}=-a_n(r_1+r_2+\cdots+r_n)$$ce qui donne:$$r_1+r_2+\cdots+r_n=-\frac{a_{n-1}}{a_n}.$$
On peut même affirmer de la même façon que:$$a_0=(-1)^na_nr_1r_2\cdots r_n$$soit:$$r_1r_2\cdots r_n=(-1)^n\frac{a_0}{a_n}.$$
Voici un article qui est abordable dès le lycée.
Imaginons une suite de nombre qui commence par “1” et “1”.
On souhaite que le nombre qui vient juste après soit égal à la somme des deux derniers nombres. Ainsi, le 3ème nombre est égal à 1+1, soit “2”. Après “2”, il y a 2+1=3, puis après ce “3”, il y a 3+2=5.
Comprenez-vous maintenant comment on calcul les termes de cette suite de nombres ? On prend toujours les deux derniers, on les ajoute et ça nous donne le suivant.
Comme ce procédé est répétitif, on va pouvoir utiliser un programme pour trouver tous les nombres de cette suite. En Python, cela donne :
F = [1,1]
for n in range(30):
F.extend([F[n+1]+F[n]])
print(F)
La première ligne définie une liste (de nombres) que l’on initialise avec les deux nombres desquels on part (donc ici, “1” et “1”). On a ainsi F[0]=1 et F[1]=1 (le premier item d’une liste est toujours indicé à 0).
Ensuite, on créé une boucle “Pour” afin de calculer ici 30 termes de plus : quand on écrit “for n in range(30)“, cela signifie que la variable n va prendre 30 valeurs entières en partant de 0.
Dans cette boucle, on calcule la somme des deux derniers termes de la liste L, puis on ajoute le résultat à la liste (c’est la méthode extend : on étend la liste avec la valeur trouvée).
Une fois sorti.e.s de la boucle, on affiche la liste, ce qui nous donne:
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040, 1346269, 2178309]
Maintenant, comme je suis quelqu’un de très bizarre (no comment, thanks!), j’ai envie de calculer les quotients successifs de deux termes consécutifs de cette suite. Je vais utiliser le code suivant:
for n in range(31):
print(F[n+1]/F[n])
ce qui m’affiche:
1.0
2.0
1.5
1.6666666666666667
1.6
1.625
1.6153846153846154
1.619047619047619
1.6176470588235294
1.6181818181818182
1.6179775280898876
1.6180555555555556
1.6180257510729614
1.6180371352785146
1.618032786885246
1.618034447821682
1.6180338134001253
1.618034055727554
1.6180339631667064
1.6180339985218033
1.618033985017358
1.6180339901755971
1.618033988205325
1.618033988957902
1.6180339886704431
1.6180339887802426
1.618033988738303
1.6180339887543225
1.6180339887482036
1.6180339887505408
1.6180339887496482
Ne remarquez-vous pas quelque chose ? Ces quotients semblent se rapprocher d’un nombre, dont la valeur approchée au millième est 1,618. C’est ce nombre que l’on appelle le nombre d’or.
Dans la mesure où Python affiche 16 décimales, je me demande à partir de quel rang j’obtiendrai une valeur approchée du nombre d’or avec une précision de \(10^{-16}\). Je vais utiliser ce code:
F = [1,1,2,3]
n = 3
while (abs(F[n-2]/F[n-3]-F[n]/F[n-1])>10**(-16)):
u = F[n]+F[n-1]
F.extend([u])
n +=1
print(F[n]/F[n-1])
Je demande ici à calculer les termes successifs de la suite de Fibonacci tant que la valeur absolue de la différence de deux quotients consécutifs est supérieure à \(10^{-16}\).
Ainsi, la valeur affichée sera une valeur approchée du dernier quotient calculé, qui sera aussi une valeur approchée du nombre d’or.
On obtient ici:
1.618033988749895
Ce nombre d’or est noté par la lettre grecque: \[ \varphi \approx 1,618033988749895.\]
On peut dire beaucoup de choses sur le nombre d’or, mais on peut aussi préciser qu’il existe un nombre d’argent (appelé ainsi par Gilles HAINRY, professeur à l’université du Mans à l’époque des faits, donc en 1996). Dans un cas général, on parle de nombres de métal.
Pour en savoir plus, je vous invite à regarder l’excellent ouvrage “Ainsi de suites”, écrit par…. Oh tiens ! Ecrit par moi 🙂 ! Il est téléchargeable gratuitement sur ce site sur la page suivante :https://www.mathweb.fr/euclide/ouvrages-personnels-de-mathematiques/
Il arrive parfois qu’un nombre s’écrive de manière très condensée mais que le nombre de chiffres qui le compose soit très grand.
Par exemple, le nombre \(9^{8^7}\) ne s’affiche même pas avec Xcas… tellement le nombre de chiffres qui le composent est grand. Mais comment savoir ce nombre de chiffres ?
Notons:$$N=\sum_{k=0}^{n-1}a_k\times10^k.$$
Ce nombre est composé de \(n\) chiffres : \(a_0,\ a_1,\ a_2,\ \ldots,\ a_{n-1}\). On l’écrit:$$N=\overline{a_{n-1}a_{n-2}\cdots a_2a_1a_0}^{10}.$$Un nombre à \(n\) chiffres est nécessairement compris entre \(10^{n-1}\) et \(10^n\), donc:$$10^{n-1}\leq N < 10^n.$$En composant par le logarithme décimal, on obtient l’encadrement:$$\log(10^{n-1}) \leq \log(N) < \log(10^n),$$soit:$$(n-1)\log(10)\leq\ln(N)<n\log(10).$$Or, par définition, \(\log(10)=1\) d’où finalement:$$n-1\leq\log(N)<n.$$On en déduit alors que \(n\) est l’entier immédiatement supérieur (ou égal) à \(\log(N)\).
Par exemple, $$\log\left(9^{8^7}\right)=8^7\log(9)\approx4607913,91681$$ donc le nombre de chiffres de \(9^{8^7}\) est 4607914.
Le principe est le même. On considère un nombre:$$N=\overline{a_{n-1}\cdots a_1a_0}^{2}=\sum_{k=0}^{n-1}a_k\times2^k\,,\,\ a_{n-1}\neq0.$$Alors, pour \(N\) exprimé en décimal, $$2^{n-1} \leq N< 2^n$$ soit: $$\frac{\ln(2^{n-1})}{\ln2} \leq \frac{\ln(N)}{\ln2} < \frac{\ln(2^n)}{\ln2},$$ d’où: $$n-1 \leq \frac{\ln(N)}{\ln2} < n.$$ Ainsi, le nombre \(n\) de chiffres (en binaire) du nombre \(N\) est-il égal à l’entier immédiatement supérieur (ou égal) à \( \frac{\ln(N)}{\ln2} \).
Par exemple, \( \overline{1101}^{2}=\overline{13}^{10}\), et \( ENT\left( \frac{\ln(13)}{\ln2}\right)+1 =4\). Il y a bien 4 chiffres dans le nombre binaire correspondant à 13 (en base décimale).
On peut bien entendu généraliser cette formule en disant que si \(N\) est un nombre décimal alors le nombre de chiffres du nombre en base \(a\) correspondant est égal à:$$n=ENT\left(\frac{\ln(N)}{\ln(a)}\right)+1.$$
Une fois n’est pas coutume, je vous propose un défi !
Exprimer en fonction de R et r l’aire de la partie colorée.
Les réponses pourront m’être envoyées sur Twitter sous forme d’image ou avec un lien. Pas de lien ici car j’aimerais que chacun cherche de son côté.
Les plus belles démonstrations seront publiées dans un autre article.
Nous allons encore une fois parler cryptographie dans cet article. Dans l’article précédent, je vous parlais du chiffrement affine, le chiffrement le plus nul après le chiffrement de César, mais cette fois-ci, on va lever le niveau…
Pour chiffrer un message avec cette méthode, il nous faudra connaître les matrices ainsi que les opérations de base qui s’y rapportent, mais aussi la notion de modulo…
Nous allons nous basé sur un alphabet (un ensemble constitué d’un certain nombre de caractères). Pour ma part, j’ai pris :
alphabet=["A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z",'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z',"'","ù","é","è","à","ç","-","ê"," ","."]
De plus, comme il y a pas mal de calculs d’algèbre linéaires, j’utilise le module numpy.
La clé de chiffrement est une matrice. Pour pouvoir chiffrer, et surtout déchiffrer, il faut que le déterminant de cette matrice ait un inverse modulo le nombre de caractères de notre alphabet. Il faut donc, après saisie de la matrice, tester cette condition. Rappelons que le déterminant (que je vais noter d) est inversible modulo n s’il existe un entier x compris entre 0 et n-1 tel que dx = 1 mod n.
De plus, le message à chiffrer doit comporter un nombre de caractères multiple de la dimension de la matrice (qui doit être carrée). Donc ici, deux possibilités :
C’est la seconde solution que j’utilise.
Pour faire simple, je vais prendre une matrice \(2\times2\), par exemple : $$A=\begin{pmatrix}3&7\\2&13\end{pmatrix}$$et un mot de deux lettres, par exemple “MA”.
J’attribue à chaque lettre de mon mot un nombre (le rang de la lettre dans l’alphabet). Donc ici, “M” correspond à 12 et “A”, à “0”. Je créé ainsi un vecteur:$$V=\begin{pmatrix}12\\0\end{pmatrix}.$$
Je multiplie la matrice-clé par le vecteur ainsi obtenu:$$\begin{pmatrix}3&7\\2&13\end{pmatrix}\begin{pmatrix}12\\0\end{pmatrix}=\begin{pmatrix}36\\24\end{pmatrix}.$$
Je prend les coefficients du résultat modulo le nombre de caractères dans l’alphabet. Comme ici c’est 62, ça ne change rien aux nombres obtenus.
Je convertis les nombres en caractères en prenant les lettres qui correspondent aux rangs obtenus. Ici, 36 correspond au caractère “k”, et 24 à la lettre “Y”.
Le message chiffré est alors : “kY”.
Il est le même que celui du chiffrement, en prenant comme matrice l’inverse modulo n de la matrice de chiffrement.
On calcule le déterminant de la matrice de chiffrement A. Pour mon exemple, on trouve :$$\det A=25.$$
Ensuite, on exprime la matrice inverse sous la forme :$$A^{-1}=\frac{1}{\det A}B$$où \(B\) doit être trouvée. Pour nous,$$A^{-1}=\frac{1}{25}\begin{pmatrix}13&-7\\-2&3\end{pmatrix}.$$
On cherche l’inverse du déterminant modulo le nombre de caractères dans l’alphabet. On cherche donc ici l’inverse de 25 modulo 62. On trouve 5 car \(25\times5=125=1\mod 62\).
Donc on peut écrire:$$A^{-1}=5\begin{pmatrix}13&-7\\-2&3\end{pmatrix}.$$
On calcule modulo le nombre de caractères dans l’alphabet les coefficients de la matrice inverse. Ici, on obtiens :$$A^{-1}=\begin{pmatrix}65&-35\\-10&15\end{pmatrix}\equiv\begin{pmatrix}3&27\\52&15\end{pmatrix}\mod62.$$
On chiffre le message chiffré à l’aide de la matrice inverse. Donc ici, si on part du message “kY”, qui correspond au vecteur \(\binom{36}{24}\), on a :$$\begin{pmatrix}3&27\\52&15\end{pmatrix}\begin{pmatrix}36\\24\end{pmatrix}=\begin{pmatrix}756\\2232\end{pmatrix}\equiv\begin{pmatrix}12\\0\end{pmatrix}\mod62.$$On retrouve bien le rang des lettres “M” et “A”.
J’ai ici converti en fichier exécutable le programme Python, et voici les captures d’écran:
Pour les abonné.e.s de mathweb.fr, j’ai mis tous les fichiers dans un ZIP sur cette page. Pour exécuter directement le programme, double-cliquez sur le fichier Hill.py.
La réforme du lycée s’accompagne de son lot de nouveautés. En mathématiques, des bruits courent sur la réapparition des équations différentielles dans le programme de la classe de maturité (Terminale).
Ceci me donne l’occasion de faire une brève (?) introduction de cette notion.
Dans équation différentielle, il y a d’abord “équation”. Par conséquent, il va y avoir au moins une inconnue (il n’y en a qu’une seule pour commencer). Cette inconnue, c’est une fonction. Elle est souvent désignée par la lettre y.
Ensuite, il y a le mot “différentielle”, ce qui signifie que notre fonction inconnue va apparaître sous diverses formes dans notre équation en termes de différentiation, ce qui veut dire qu’il peut y avoir la fonction elle-même (y), mais aussi sa dérivée (y’) ainsi que sa dérivée seconde (y”), etc. Au lycée, on s’arrête à la dérivée seconde.
Si y” apparaît dans l’équation, on dira que l’on a affaire à une équation différentielle d’ordre 2.
Si tel n’est pas le cas mais que y’ apparaît, on dire que l’équation est d’ordre 1.
Les coefficients de y, y’ et y” sont au lycée des constantes, mais ils peuvent aussi être des fonctions.
De plus, les équations différentielles seront linéaires, c’est-à-dire qu’il n’y aura pas d’exposant aux inconnues (donc, par exemple, pas de y²).
Nous allons avant tout nous pencher sur cette équation, qui est la plus simple (ou presque).
Il ne faut jamais oublier que y représente une fonction (ce que l’on oublie assez souvent au début car nous avions affaire jusqu’à présent qu’à des équations dont les inconnues étaient des nombres).$$\begin{align}y’=ay & \iff \frac{y’}{y}=a\\ & \iff \int_{\mathbb{R}}\frac{y’}{y}\text{d}x=\int_{\mathbb{R}} a\text{d}x\\&\iff \ln\big|y(x)\big|=ax+k,\ k\in\mathbb{R}\\&\iff y(x)=\text{e}^{ax+k}=\text{e}^k\times\text{e}^{ax}\\&\iff y(x)=C\text{e}^{ax},\ c\in\mathbb{R}.\end{align}$$
Précisions : à la deuxième ligne, on cherche les primitives de \(\frac{y’}{y}\), qui est de la forme \(\frac{u’}{u}\), et les primitives de \(\frac{u’}{u}\) sont les fonctions \(\ln|u|\).
L’équation \( y’=-5y\) admet pour solutions les fonctions: $$y(x)=C\text{e}^{5x},\ C\in\mathbb{R}.$$Il y a donc une infinité de solutions.
Cette équation se résout en deux temps.
L’équation homogène associée à cette équation est y‘ – 3y = 0, admettant \(y_0(x)=C\text{e}^{3x}\, C\in\mathbb{R}\) comme solutions.
De plus, le second membre de l’équation différentielle étant un polynôme de degré 2, une solution particulière peut être un polynôme de degré 3 (car une fois dérivé, cela donnera un polynôme de degré 2).
Posons alors \(y_p(x)=ax^3+bx^2+cx+d\); ainsi, \(y_p^\prime(x)=3ax^2+2bx+c\). Donc:$$\begin{align} & y_p^\prime(x)-3y_p(x)=x^2\\\iff& 3ax^2+2bx+c-3(ax^3+bx^2+cx+d)=x^2\\\iff& -3ax^3+(3a-3b)x^2+(2b-3c)x+c-3d=x^2\\\iff&\begin{cases} -3a=0\\3a-3b=1\\ 2b-3c=0\\c-3d=0\end{cases}\\\iff&a=0,\ b=-\frac{1}{3},\ c=-\frac{2}{9},\ d=-\frac{2}{27}.\end{align}$$Donc \(y_p(x)=-\frac{1}{3}x^2-\frac{2}{9}x-\frac{2}{27}\).
Ainsi, les solutions de l’équation différentielle initiale sont:$$y(x)=
-\frac{1}{3}x^2-\frac{2}{9}x-\frac{2}{27} + C\text{e}^{3x}\, C\in\mathbb{R}.$$
Ce genre d’équation différentielle est souvent accompagné de son équation caractéristique. Pour obtenir l’équation caractéristique, on remplace y” par r² et y par r; on obtient alors ar²+br+c=0, équation du second degré bien connue. On arrive alors à démontrer que les solutions de l’équation différentielles sont de la forme \( A\text{e}^{r_1x} +B\text{e}^{r_2x}\), où \(r_1\) et \(r_2\) sont les solutions (réelles ou complexes) de l’équation caractéristique.
On obtient ainsi le théorème suivant.
Les solutions sont, d’après le théorème vu précédemment:$$y(x)=A\cos(\omega x)+B\sin(\omega x).$$
Si l’équation est de la forme ay” + by + c = f(x) alors pour la résoudre, on fera la même chose que pour les équations du premier ordre : somme des solutions de l’équation homogène associée et d’une solution particulière.
Considérons une culture de bactéries en milieu clos. La loi de Malthus est un modèle d’évolution disant que la vitesse d’accroissement des bactéries est proportionnelle au nombre de bactéries présentes. Ainsi, y‘ = ay, où y(t) représente le nombre de bactéries à l’instant t.
Dans la pratique, ce modèle n’est pas vraisemblable. On lui préférera le modèle de Verhulst:$$y’=ay(M-y)$$mais cette équation n’étant pas linéaire, je n’en parlerai pas ici (peut-être dans un autre article).
On considère un circuit électrique où u(t) est la tension électrique aux bornes d’un condensateur C alimenté à travers une résistance R sous une tension constante E.
Les lois de l’électricité indiquent que:$$RCu’+u=E.$$Ainsi, pour trouver la tension, on doit résoudre une équation différentielle.
Considérons une masse m suspendue à un ressort de constante de raideur k. x désigne la position de la masse par rapport à sa position d’équilibre. Le frottement est supposé proportionnel à la vitesse v = x’(t). λ est le coefficient de frottement (λ>0).
Les lois de la mécanique du mouvement nous indiquent que:$$m⋅x’’(t) + λ⋅x’(t) + k⋅x(t) = 0.$$Ainsi, pour trouver la position de la masse, il faut résoudre une équation différentielle.