Programmation

Algorithmie et programmation

Pourquoi la programmation ?

Prenons l'exemple du calcul de l'argument d'un nombre complexe de la page précédente, si cette fonctionnalité n'existe pas il faut analyser les valeurs avant d'appliquer la formule adaptée. On remarque que le calcul dépend des domaines de définitions ainsi que de certaines valeurs particulières des parties réelle et imaginaires. Ensuite en prenant en compte ces hypothèses, on utilise la calculatrice pour effectuer le calcul.
Afin de pouvoir confier le calcul complet à la calculatrice en fonction des hypothèses, on va analyser l'ensemble de ces hypothèses avec le calcul qui correspond, écrire un algorithme, écrire le programme, pour ensuite confier le caclul de l'argument à ce programme.
Choisir le calcul en fonction des conditions sur les valeurs, cela s'appelle un traitement conditionnel.
Ce raisonnement peut également s'appliquer au calcul du signe d'un nombre réel afin de prendre en compte le cas où ce nombre est nul.

L'autre exemple est celui de la formule de Viète présentée également sur la page précédente. Cette formule est une suite de calculs, qu'il faut répéter un certain nombre de fois. Pourquoi ne pas confier cette tâche répétitive à un programme qui donnerait le résultat final. On appelle cela un traitement itératif. Bien sûr avant de créer le programme, il faut trouver le moyen de transformer cette formule en une suite de calculs. Pour cela on va commencer par écrire cette suite, avant d'en déduire l'algorithme du programme, puis écrire le programme.

On écrit généralement le programme dans un langage qui est indépendant de la machine, que l'on appelle le pseudo-code, ensuite on traduit ce pseudo-code dans le langage utilisé par la calculatrice qui peut être, par exemple, le langage python.

Traitement conditionnel

Exemple 1, calcul du signe d'un nombre $\displaystyle y=signe(x)$

Analyse du calcul de la fonction signe(x)

\left\{\begin{array}[]{rcl}x\neq 0,&y=\frac{x}{|x|}\\ x=0,&y=0\\ \end{array}\right.

On a donc un traitement conditionnel qui dépend du fait que x soit nul ou non, si il est différent de 0 on effectue le calcul sinon le résultat vaut 0.
C'est cette analyse qui nous permet de passer à l'écriture du pseudo-code.

Pseudo-code de la fonction signe(x)
La fonction de calcul effectue le calcul à partir de la valeur contenu dans la variable x pour donner le résultat dans la variable y. On dit que cette fonction possède un paramètre d'entrée : x et un paramètre de sortie y. Ceci va être précisé dans le pseudo-code avant d'écrire le traitement que l'on encadre entre les mots clés "Debut traitement" et "Fin traitement". Il est également important de préciser le types des variables x et y qui, ici, sont réelles.

Remarque : Le pseudo-code n'est pas unique, il peut exister différentes variantes et syntaxes

Fonction signe
Paramètres en entrée : x (réel)
Paramètres en sortie : y (réel)
Debut traitement
Si x!=0 Alors
y = x/abs(x)
Sinon
y = 0
FinSi
Retourner y
Fin traitement

Exemple 2, calcul de l'argument d'un nombre complexe $\displaystyle z=a+ib$

Analyse de la fonction argument(z) de calcul de l'argument d'un nombre complexe en étudiant toutes les hypotèses afin d'obtenir un angle

\displaystyle\left\{\begin{array}[]{rcl}a=0,&b>0,&\theta=\frac{\pi}{2}\\ a=0,&b<0,&\theta=-\frac{\pi}{2}\\ a=0,&b=0,&\theta=0\\ a>0&\forall b,&\theta=\arctan\left(\frac{b}{a}\right)\\ a<0&b>=0,&\theta=\arctan\left(\frac{b}{a}\right)+\pi\\ a<0&b<0,&\theta=\arctan\left(\frac{b}{a}\right)-\pi\\ \end{array}\right.

Cette fois, on remarque des hypothèses qui dépendent d'autres hypothèses, le premier groupe d'hypothèses qui dépend de a, puis un second groupe d'hypothéses qui dépend de b et aussi de a. Cela va donc donner des traitements conditionnels imbriqués.

Pseudo-code de la fonction argument(z)
La fonction de calcul de l'argument admet en entrée la partie réelle (a) et la partie imaginaire (b) du nombre complexe (z) et retourne en sortie l'angle qui correspond à l'argument. Elle doit ensuite traiter tous les cas décrits.

Remarque
Ce code est très éloigné de la façon d'écrire correctement un programme, en effet, il y a beaucoup de traitements conditionnels imbriqués, dans ce cas on doit revenir à l'analye pour trouver un algorithme de meilleure qualité.

Lorsque l'on analyse un problème, on le décompose en problèmes plus simples que l'on résoud séparément avant de tout regrouper pour résoudre le problème complet.
Dans cette optique, on aura remarqué que l'on peut utiliser la solution de l'exercice 4 de la page précédente.

Fonction argument
Paramètres en entrée : a,b (réels)
Paramètres en sortie : angle (réel) en radians
Debut traitement
Si a==0 Alors
  Si b>0 Alors
    angle=π/2
   Sinon
    Si b<0 Alors
      angle=-π/2
     Sinon
      angle=0
    FinSi
  FinSi
Sinon
  Si a>0 Alors
    angle=arctan(b/a)
   Sinon
    Si b>=0 Alors
      angle=arctan(b/a)+π
     Sinon
      angle=arctan(b/a)-π
    FinSi
  FinSi
FinSi
Retourner angle
Fin traitement

Proposer un nouvel algorithme

Faire l'analyse, puis écrire le pseudo-code de la nouvelle fonction argument améliorée.

Traitement itératif

Calcul de la formule de Viète $\displaystyle 2\times\frac{2}{\sqrt{2}}\times\frac{2}{\sqrt{2+\sqrt{2}}}\times% \frac{2}{\sqrt{2+\sqrt{2+\sqrt{2}}}}\times...$

Analyse du programme de calcul de la formule de Viète.
On remarque que le dénominateur de chaque élément du produit peut s'écrire en fonction du dénominateur du produit précédent : $\displaystyle D_{n+1}=\sqrt{2+D_{n}}$ avec $\displaystyle D_{0}=\sqrt{2}$
Ce qui donne :
$\displaystyle\left\{\begin{array}[]{rcl}U_{0}=2&\&&U_{n+1}=\frac{2\times U_{n}% }{V_{n}}\\ V_{0}=\sqrt{2}&\&&V_{n+1}=\sqrt{2+V_{n}}\\ \end{array}\right.$

Pseudo-code du programme de calcul de la formule de Viète
La fonction viete calcule la valeur de l'expression pour un nombre d'itérations donné. Ce nombre est le paramètre d'entrée de cette fonction.

Fonction viete
Paramètres en entrée : n (entier)
Paramètres en sortie : un (réel)
Variables locales : un,vn (réels), i (entier)
Debut traitement
un=2
vn=racine(2)
Pour i de 1 à n faire
un=2×un/vn
vn=racine(2+vn)
FinPour
Retourner un
Fin traitement

Programmation en Python

Il existe des sites pour apprendre la programmation en python, on peut trouver des informations sur la programmation en python. On peut trouver également de l'aide pour la programmation en python sur calculatrice, on peut également trouver de la documentation sur le site qui correspond à la calculatrice.

Traitement conditionnel

Traduction en python du pseudo-code précédent de calcul du signe et de l'argument

from math import *

def signe(x):
	if x!=0:
		y=x/abs(x)
	else:
		y=0
	return y

def argument(a,b):
	if a==0:
		angle = signe(b)*pi
	else:
		angle = atan(b/a)+((1-signe(a))*signe(b)*pi)/2
	return angle

Exemple d'utilisation sur la calculatrice, en utilisant directement la fonction :

>>> argument(2,3)
0.982793723247329
>>>

from math import *

def signe(x):
	if x!=0:
		y=x/abs(x)
	else:
		y=0
	return y

def argument(a,b):
	if a==0:
		angle = signe(b)*pi
	else:
		angle = atan(b/a)+((1-signe(a))*signe(b)*pi)/2
	return angle		

a=float(input("a? "))
b=float(input("b? "))
angle=argument(a,b)
print(angle)

Exemple d'utilisation sur la calculatrice en utilisant la saisie séparée des valeurs.

a? 2
b? 3
0.982793723247329
>>>

Traitement itératif

Traduction en python du pseudo-code précédent de la formule de Viète

from math import *

def viete(n=10):
  den=sqrt(2)
  un=2
  for i in range(0,n):
    un=un*2/den
    den=sqrt(2+den)
  print(un)

>>> viete(20)
3.141592653588619
>>>

from math import *

def viete(n=10):
  den=sqrt(2)
  un=2
  for i in range(0,n):
    un=un*2/den
    den=sqrt(2+den)
  print(un)

n=int(input("n? "))
viete(n)