Chapitre 17 – Calcul et algorithmique

x ← 5
y ← 3.14
z ← x + y          // z prend la valeur 8,14
compteur ← 0
compteur ← compteur + 1  // incrémentation : compteur vaut 1
nom ← "Alice"
valide ← VRAI

Algorithme ConversionTemperature
Variables :
    celsius, fahrenheit : réel
Début
    Afficher("Entrez la température en °C : ")
    Saisir(celsius)
    fahrenheit ← celsius * 9 / 5 + 32
    Afficher("Température en °F : ", fahrenheit)
Fin

Algorithme ControleQualite
Variables :
    diametre : réel
Début
    Afficher("Diamètre mesuré (mm) : ")
    Saisir(diametre)
    SI (diametre >= 49.95) ET (diametre <= 50.05) ALORS
        Afficher("Pièce ACCEPTÉE")
    SINON SI diametre < 49.95 ALORS
        Afficher("Pièce REJETÉE — sous-dimensionnée")
    SINON
        Afficher("Pièce REJETÉE — sur-dimensionnée")
    FIN SI
Fin

Algorithme SommeEntiers
Variables :
    n, i : entier
    somme : entier
Début
    Saisir(n)
    somme ← 0
    POUR i DE 1 A n FAIRE
        somme ← somme + i
    FIN POUR
    Afficher("Somme = ", somme)
    // Vérification : formule close n(n+1)/2
Fin

Algorithme MoyenneMesures
Variables :
    n, i : entier
    T : tableau de réels
    somme, moyenne : réel
Début
    Saisir(n)
    POUR i DE 1 A n FAIRE
        Afficher("Mesure ", i, " : ")
        Saisir(T[i])
    FIN POUR
    somme ← 0
    POUR i DE 1 A n FAIRE
        somme ← somme + T[i]
    FIN POUR
    moyenne ← somme / n
    Afficher("Moyenne = ", moyenne)
Fin

Algorithme SaisiePression
Variables :
    pression : réel
Début
    pression ← -1
    TANT QUE pression < 0 FAIRE
        Afficher("Pression (Pa, valeur > 0) : ")
        Saisir(pression)
        SI pression < 0 ALORS
            Afficher("Erreur : la pression doit être positive.")
        FIN SI
    FIN TANT QUE
    Afficher("Pression enregistrée : ", pression, " Pa")
Fin

Fonction Factorielle(n : entier) : entier
Variables :
    i, resultat : entier
Début
    resultat ← 1
    POUR i DE 2 A n FAIRE
        resultat ← resultat * i
    FIN POUR
    RETOURNER resultat
Fin

// Programme principal :
k ← Factorielle(6)    // k = 6! = 720
Afficher(k)            // affiche 720

Fonction FactoriellRec(n : entier) : entier
Début
    SI n <= 1 ALORS
        RETOURNER 1                          // cas de base
    SINON
        RETOURNER n * FactoriellRec(n - 1)  // cas récursif
    FIN SI
Fin

FactoriellRec(4) = 4 × FactoriellRec(3)
                = 4 × 3 × FactoriellRec(2)
                = 4 × 3 × 2 × FactoriellRec(1)
                = 4 × 3 × 2 × 1 = 24

Fonction Fibonacci(n : entier) : entier
Début
    SI n = 0 ALORS RETOURNER 0
    SINON SI n = 1 ALORS RETOURNER 1
    SINON RETOURNER Fibonacci(n-1) + Fibonacci(n-2)
    FIN SI
Fin

Fonction IntegraleRectangles(a, b : réel ; n : entier) : réel
Variables :
    h, somme, x : réel
    k : entier
Début
    h ← (b - a) / n
    somme ← 0
    POUR k DE 0 A n-1 FAIRE
        x ← a + k * h
        somme ← somme + f(x)     // f est une fonction définie par ailleurs
    FIN POUR
    RETOURNER h * somme
Fin

Fonction IntegraleTrapèzes(a, b : réel ; n : entier) : réel
Variables :
    h, somme, x : réel
    k : entier
Début
    h ← (b - a) / n
    somme ← f(a) + f(b)
    POUR k DE 1 A n-1 FAIRE
        x ← a + k * h
        somme ← somme + 2 * f(x)
    FIN POUR
    RETOURNER (h / 2) * somme
Fin

Algorithme Newton
Variables :
    x0, x1, epsilon : réel
Début
    Saisir(x0)
    epsilon ← 1e-8
    x1 ← x0 - f(x0) / f_prime(x0)
    TANT QUE |x1 - x0| >= epsilon FAIRE
        x0 ← x1
        x1 ← x0 - f(x0) / f_prime(x0)
    FIN TANT QUE
    Afficher("Racine approchée : ", x1)
Fin

Algorithme Dichotomie
Variables :
    a, b, m, epsilon : réel
Début
    Saisir(a, b, epsilon)
    TANT QUE (b - a) / 2 >= epsilon FAIRE
        m ← (a + b) / 2
        SI f(m) = 0 ALORS
            a ← m  ;  b ← m   // racine exacte trouvée
        SINON SI f(a) * f(m) < 0 ALORS
            b ← m              // racine dans [a, m]
        SINON
            a ← m              // racine dans [m, b]
        FIN SI
    FIN TANT QUE
    Afficher("Racine ≈ ", (a + b) / 2)
Fin

Procédure TriBulles(T : tableau d'entiers ; n : entier)
Variables :
    i, j, temp : entier
    echange : booléen
Début
    POUR i DE 1 A n-1 FAIRE
        echange ← FAUX
        POUR j DE 1 A n-i FAIRE
            SI T[j] > T[j+1] ALORS
                temp   ← T[j]
                T[j]   ← T[j+1]
                T[j+1] ← temp
                echange ← VRAI
            FIN SI
        FIN POUR
        SI NON echange ALORS
            Sortir de la boucle   // tableau déjà trié
        FIN SI
    FIN POUR
Fin

Procédure TriSelection(T : tableau d'entiers ; n : entier)
Variables :
    i, j, i_min, temp : entier
Début
    POUR i DE 1 A n-1 FAIRE
        i_min ← i
        POUR j DE i+1 A n FAIRE
            SI T[j] < T[i_min] ALORS
                i_min ← j
            FIN SI
        FIN POUR
        SI i_min ≠ i ALORS
            temp      ← T[i]
            T[i]      ← T[i_min]
            T[i_min]  ← temp
        FIN SI
    FIN POUR
Fin

# Python détecte automatiquement le type
temperature = 20.5       # flottant (réel)
compteur = 0             # entier
nom = "Maxime"           # chaîne de caractères
actif = True             # booléen (True/False)

# Affichage
print("Température :", temperature, "°C")
print(f"Bonjour {nom}, compteur = {compteur}")  # f-string

# Saisie utilisateur
valeur = float(input("Entrez une valeur : "))

diametre = float(input("Diamètre mesuré (mm) : "))

if 49.95 <= diametre <= 50.05:
    print("Pièce ACCEPTÉE")
elif diametre < 49.95:
    print("Pièce REJETÉE — sous-dimensionnée")
else:
    print("Pièce REJETÉE — sur-dimensionnée")

n = int(input("Entrez n : "))
somme = 0
for i in range(1, n + 1):   # range(1, n+1) génère 1, 2, ..., n
    somme += i
print(f"Somme des {n} premiers entiers = {somme}")
print(f"Vérification formule n(n+1)/2 = {n*(n+1)//2}")

pression = -1
while pression < 0:
    try:
        pression = float(input("Pression (Pa, > 0) : "))
    except ValueError:
        print("Veuillez entrer un nombre.")
    if pression < 0:
        print("Erreur : valeur négative.")
print(f"Pression enregistrée : {pression} Pa")

def factorielle(n):
    """Calcule n! de façon itérative."""
    resultat = 1
    for i in range(2, n + 1):
        resultat *= i
    return resultat

def fibonacci(n):
    """Retourne F(n) de façon itérative (efficace)."""
    if n == 0:
        return 0
    a, b = 0, 1
    for _ in range(1, n):
        a, b = b, a + b
    return b

# Tests
for k in range(8):
    print(f"F({k}) = {fibonacci(k)}")
print(f"10! = {factorielle(10)}")

import math

def integrale_trapèzes(f, a, b, n):
    """Intègre f sur [a,b] par la méthode des trapèzes avec n sous-intervalles."""
    h = (b - a) / n
    somme = f(a) + f(b)
    for k in range(1, n):
        somme += 2 * f(a + k * h)
    return (h / 2) * somme

# Exemple : ∫₀^π sin(x)dx = 2 (exact)
result = integrale_trapèzes(math.sin, 0, math.pi, 1000)
print(f"∫₀^π sin(x)dx ≈ {result:.8f}  (exact = 2)")
# Affiche : ∫₀^π sin(x)dx ≈ 1.99999836  (exact = 2)

def newton_raphson(f, df, x0, epsilon=1e-8, max_iter=100):
    """
    Résout f(x) = 0 par Newton-Raphson.
    f       : fonction dont on cherche la racine
    df      : dérivée de f
    x0      : approximation initiale
    epsilon : précision souhaitée
    """
    x = x0
    for i in range(max_iter):
        fx = f(x)
        if abs(fx) < epsilon:
            print(f"Convergé en {i} itérations")
            return x
        dfx = df(x)
        if abs(dfx) < 1e-14:
            raise ValueError("Dérivée nulle — méthode ne converge pas")
        x = x - fx / dfx
    print("Avertissement : nombre max d'itérations atteint")
    return x

# Calcul de sqrt(2) : résoudre x² - 2 = 0
f  = lambda x: x**2 - 2
df = lambda x: 2*x
racine = newton_raphson(f, df, x0=1.5)
print(f"√2 ≈ {racine:.10f}")

import math

print(math.pi)              # 3.141592653589793
print(math.e)               # 2.718281828459045
print(math.sqrt(144))       # 12.0
print(math.log(100, 10))    # 2.0  — log base 10
print(math.log(math.e))     # 1.0  — log naturel
print(math.sin(math.pi/6))  # 0.5  — sin(30°)
print(math.cos(math.pi/3))  # 0.5  — cos(60°)
print(math.factorial(6))    # 720
print(math.gcd(12, 8))      # 4    — PGCD
print(math.ceil(3.2))       # 4    — arrondi supérieur
print(math.floor(3.9))      # 3    — arrondi inférieur

import numpy as np

# Création de tableaux
temperatures = np.array([18.5, 20.1, 22.3, 19.8, 21.0])
print("Tableau :", temperatures)
print("Moyenne :", np.mean(temperatures))         # 20.34
print("Écart-type :", np.std(temperatures))       # 1.27
print("Maximum :", np.max(temperatures))          # 22.3

# Génération de points
t = np.linspace(0, 24, 97)    # 96 intervalles de 15 min sur 24h
puissance = 2.5 * np.sin(np.pi * t / 12) + 3.0  # kW — modèle sinusoïdal

# Intégrale numérique avec np.trapz
energie_kWh = np.trapz(puissance, t)
print(f"Énergie consommée : {energie_kWh:.2f} kWh")

# Opérations matricielles
A = np.array([[2, 1], [1, 3]])
b = np.array([5, 10])
x = np.linalg.solve(A, b)   # résolution du système Ax = b
print("Solution :", x)

Algorithme RegulationPID
Variables :
    Kp, Ki, Kd, Te : réels
    consigne, mesure, e, e_prec, somme_e, u : réels
Début
    Kp ← 2.0 ; Ki ← 0.5 ; Kd ← 0.1 ; Te ← 0.1
    somme_e ← 0 ; e_prec ← 0

    TANT QUE VRAI FAIRE
        LireConsigne(consigne)
        LireCapteur(mesure)
        e ← consigne - mesure
        somme_e ← somme_e + e * Te
        u ← Kp * e + Ki * somme_e + Kd * (e - e_prec) / Te
        u ← MAX(0, MIN(100, u))      // saturation 0–100 %
        AppliquerCommande(u)
        e_prec ← e
        Attendre(Te)
    FIN TANT QUE
Fin

class PID:
    """Régulateur PID numérique à pas fixe Te."""

    def __init__(self, Kp, Ki, Kd, Te, u_min=0, u_max=100):
        self.Kp = Kp
        self.Ki = Ki
        self.Kd = Kd
        self.Te = Te
        self.u_min = u_min
        self.u_max = u_max
        self._somme_e = 0.0
        self._e_prec  = 0.0

    def calculer(self, consigne, mesure):
        """Calcule la commande u pour un instant d'échantillonnage."""
        e = consigne - mesure
        self._somme_e += e * self.Te
        derivee = (e - self._e_prec) / self.Te
        u = self.Kp * e + self.Ki * self._somme_e + self.Kd * derivee
        u = max(self.u_min, min(self.u_max, u))
        self._e_prec = e
        return u

    def reset(self):
        """Réinitialise l'état interne (ex. : changement de consigne)."""
        self._somme_e = 0.0
        self._e_prec  = 0.0


# --- Simulation de la régulation de température ---
pid = PID(Kp=2.0, Ki=0.5, Kd=0.1, Te=0.1)
consigne   = 60.0     # °C cible
temperature = 20.0    # °C initiale (ambiance)

print(f"{'t(s)':>5} | {'Mesure °C':>9} | {'Erreur':>7} | {'Commande u':>10}")
print("-" * 40)
for k in range(25):
    u = pid.calculer(consigne, temperature)
    # Modèle thermique du premier ordre simplifié
    temperature += u * 0.05 - 0.02 * (temperature - 20.0)
    t = k * 0.1
    print(f"{t:>5.1f} | {temperature:>9.2f} | {consigne-temperature:>7.2f} | {u:>10.2f}")