Feat: TST somme suite programmation

différentielles

TST/09_Somme_suites/1I_boucle_accumulateurs.ipynb

@@ -0,0 +1,261 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Boucles et accumulateurs\n",
+    "\n",
+    "\n",
+    "Dans ce TP, nous allons travailler la boucle `for` puis nous allons voir comment les utiliser pour faire des **accumulateurs**."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## La boucle `for`\n",
+    "\n",
+    "Nous les avons déjà rencontré. Voici l'exemple le plus simple que l'on puisse imaginer."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for i in range(10):\n",
+    "    print(i)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "1. Lancer le programme pour expliquer ce qu'il fait. Que représente `i`? Que fait la commande `range(10)`?\n",
+    "\n",
+    "2. Ci-dessous, vous trouverez un nouveau programme. Avant de l'exécuter, faire le tableau des variables pour deviner ce qu'il fait."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a = 0\n",
+    "for i in range(4):\n",
+    "    print(i**2)\n",
+    "    a = a + i\n",
+    "print(a)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "3. Même question pour le programme ci-dessous."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "u = 10\n",
+    "for i in range(3):\n",
+    "    print(u)\n",
+    "    u = u * 1.2\n",
+    "print(u)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Pour un affichage plus pratique, on peut le réécrire."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "u = 10\n",
+    "for i in range(3):\n",
+    "    print(\"u\", i, \" = \", u)\n",
+    "    u = u * 1.2\n",
+    "print(\"u\", i, \" = \", u)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "4. Soit $u_n$ une suite géométrique de raison $q=2$ et de premier terme $u_0=1$. Écrire une programme qui calcule $u_{100}$ en utilisant une boucle `for`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "5. Soit $u_n$ une suite définie par la relation de récurence $u_{n+1} = 0.9u_n + 10$ et de premier terme $u_0 = 200$. Écrire un programme qui calcule $u_{50}$ en utilisant une boucle `for`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Accumulateur\n",
+    "\n",
+    "Il arrive que l'on ne s'intéresse non pas à une valeur particulière mais à l'accumulation de toutes les valeurs précédentes. Pour programmer cela, on utilise un accumulateur comme présenter dans le programme suivant."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "u = 10\n",
+    "S = u\n",
+    "for i in range(4):\n",
+    "    u = u * 0.5\n",
+    "    S = S + u\n",
+    "print(S)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "1. Faire le tableau des valeurs pour le programme précédent et vérifier que vous obtenez bien le même résultat.\n",
+    "2. Soit $u_n$ une suite géométrique de raison $q=2$ et de premier terme $u_0=1$. Écrire une programme qui ajoute toutes les valeurs de $u_n$ jusqu'à $u_{10}$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "3. Écrire une programme qui ajoute le carré des nombres de 1 à 100."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "4. Écrire un programme qui ajoute l'inverse des nombres entre 1 et 500."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Dossier en groupe\n",
+    "\n",
+    "Les cellules ci-dessous sont libres. Vous pouvez les utiliser pour écrire des programmes qui vous semblent pertinents pour le sénario choisi.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

TST/09_Somme_suites/index.rst

@@ -2,7 +2,7 @@ Somme suites
 ############
 
 :date: 2021-02-07
-:modified: 2021-03-04
+:modified: 2021-03-06
 :authors: Benjamin Bertrand
 :tags: Suites, Analyse, Tableur, Python
 :category: TST
@@ -22,7 +22,6 @@ Comparaison de deux situations (arithmétique et géométrique) où il faudra no
 
 Séance de programmation où l'on va travailler sur les boucles et les accumulateurs pour calculer des sommes. On invitera les élèves à utiliser une feuille de papier pour vérifier les calculs faits par l'ordinateur.
 
-Les élèves retrouveront les scénarios de l'étape 1 pour faire les calculs avec l'outil de programmation.
 
 Bilan: algorithme d'accumulations et symbole somme
 

TST_sti2d/07_Equation_differentielle/exercises.tex

@@ -81,6 +81,29 @@
 \end{exercise}
 
 \begin{exercise}[subtitle={Résolution d'équations différentielles}, step={4}, origin={Création}, topics={Équation differentielle}, tags={analyse, exponentiel, dérivation}]
+    Déterminer la solution unique des équations différentielles suivantes
+    \begin{multicols}{3}
+        \begin{enumerate}
+            \item 
+                \begin{cases}
+                    y' = 0.1 y \\
+                    f(0) = 2
+                \end{cases}
+            \item 
+                \begin{cases}
+                    y' = 2 y + 4\\
+                    f(0) = 2
+                \end{cases}
+            \item 
+                \begin{cases}
+                    y' = 0.1 y \\
+                    f(0) = 2
+                \end{cases}
+        \end{enumerate}
+    \end{multicols}
+\end{exercise}
+
+\begin{exercise}[subtitle={Chutte d'objets}, step={4}, origin={Création}, topics={Équation differentielle}, tags={analyse, exponentiel, dérivation}]
     On veut étudier la chute d'un objet dû à l'attraction terrestre. On lâché l'objet à $t=0$ avec une vitesse nulle.
     \begin{enumerate}
         \item On suppose que que l'objet ne subit pas de frottement. Il est donc uniquement soumis à l'attraction terrestre et donc le bilan des forces donne l'équation différentielle suivante