diff --git a/1ST/03_Nombre_derive_et_tangente/1B.tex b/1ST/03_Nombre_derive_et_tangente/1B.tex new file mode 100644 index 0000000..1f65126 --- /dev/null +++ b/1ST/03_Nombre_derive_et_tangente/1B.tex @@ -0,0 +1,14 @@ +\documentclass[a4paper,10pt]{article} +\usepackage{myXsim} + +\author{Benjamin Bertrand} +\title{Nombre dérivé et tangente - Cours} +\date{novembre 2022} + +\pagestyle{empty} + +\begin{document} + +\maketitle + +\end{document} diff --git a/1ST/03_Nombre_derive_et_tangente/4E_hamster.ipynb b/1ST/03_Nombre_derive_et_tangente/4E_hamster.ipynb new file mode 100644 index 0000000..56bcb0d --- /dev/null +++ b/1ST/03_Nombre_derive_et_tangente/4E_hamster.ipynb @@ -0,0 +1,431 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Mon hamster dans sa roue\n", + "\n", + "Mon hamster court dans sa roue durant toute la journée. J'aime l'étudier et aujourd'hui je voudrait savoir à quelle vitesse il avance dans sa roue.\n", + "\n", + "\n", + "## Distance parcourue\n", + "\n", + "Lors d'anciennes expérimentation, j'ai enregistré sur un jour la position de sa roue. Je peux maintenant y avoir accès par la fonction `position`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from hamster import position, graph" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "graph()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Pour connaître la position de la roue à un moment donné, je dois le renseigner comme paramètre de la fonction.\n", + "\n", + "Par exemple au début de la journée (8h) à `t=0` la position de la roue est à" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "position(0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "À midi, donc `t=4` la position de la route est à" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "position(4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Quelle est la position de la roue à 10h (`t=2`)?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Quelle est la position de la roue à 16h?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Quelle est la position de la roue à 8h30?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Quelle est la position de la roue à 12h30?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Vitesse moyenne\n", + "\n", + "Comme je disais au début, ce n'est pas la position de la roue qui m'interesse mais bien la vitesse de mon hamster.\n", + "\n", + "Quelle est la **vitesse moyenne** de mon hamster entre 8h et 12h?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Quelle est la vitesse moyenne de mon hamster sur la journée entre 8h et 16h?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Entre quelles heures, mon hamster s'est-il montré le plus rapide?" + ] + }, + { + "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": "markdown", + "metadata": {}, + "source": [ + "Comme on commence un peu trop souvent écrire le même calcul, c'est qu'il est temps de programmer une fonction pour le faire à notre place.\n", + "\n", + "Ci-dessous, il y a le début de la définition de la fonction. À toi de compléter les ... pour que cette fonction calcule la vitesse du hamster entre les deux moments `t1` et `t2`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def vitesse(t1,t2):\n", + " return ..." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Utilise ta nouvelle fonction vitesse pour calculer la vitesse moyenne de mon hamster entre 8h et 12h. Tu devrais trouver le même résultat que plus haut." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "vitesse(..., ...)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Calculer la vitesse de mon hamster entre 11h30 et 12h." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Puis entre 12h et 12h30." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Vitesse instantannée\n", + "\n", + "Les voitures ont un compteur de vitesse qui donne la **vitesse instantannée** du véhicule pas la vitesse moyenne entre 2 moments.\n", + "\n", + "J'aimerai connaître la **vitesse instantannée** de mon hamster à 12h.\n", + "\n", + "Pour faire cela, on va calculer la vitesse moyenne un peu avant 12h disons entre 11h45 et 12h puis la vitesse moyenne un peu après entre 12h et 12h15.\n", + "\n", + "Calcule ces deux vitesses moyennes sur 15min." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ensuite on recommence mais cette fois-ci avec une vitesse moyenne sur 5minutes." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Et on continue avec une amplitude de 1min" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Pour avoir la vitesse instantannée, il faudrait continuer ainsi jusqu'à ce que l'amplitude soit nulle. Les vitesses moyennes se rapprocheraient de plus en plus autour d'une valeur que l'on appelle **vitesse instantannée**.\n", + "\n", + "\n", + "À toi de trouver la vitesse instantannée à 13h." + ] + }, + { + "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 (ipykernel)", + "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.10.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/1ST/03_Nombre_derive_et_tangente/exercises.tex b/1ST/03_Nombre_derive_et_tangente/exercises.tex new file mode 100644 index 0000000..a5cc298 --- /dev/null +++ b/1ST/03_Nombre_derive_et_tangente/exercises.tex @@ -0,0 +1,7 @@ +\begin{exercise}[subtitle={<++>}, step={1}, origin={<++>}, topics={ Nombre dérivé et tangente }, tags={ Dérivation }] + <++> +\end{exercise} + +\begin{solution} + <++> +\end{solution} diff --git a/1ST/03_Nombre_derive_et_tangente/hamster.py b/1ST/03_Nombre_derive_et_tangente/hamster.py new file mode 100644 index 0000000..57674fa --- /dev/null +++ b/1ST/03_Nombre_derive_et_tangente/hamster.py @@ -0,0 +1,32 @@ +from math import sin +import matplotlib.pyplot as plt +import numpy as np + +def position(t): + if t < 0: + raise ValueError("t trop petit, le hamster n'est pas encore réveillé avant 8h!") + elif t < 2: + return sin(t) + elif t < 3: + return sin(2) + (t-2)*2 + elif t < 5: + return (sin(2) + 2) + sin(2*(t-3)) - (t-3) + elif t < 5.5: + return sin(2) + 2 + sin(4) - 2 + elif t <= 8: + return (sin(2) + 2 + sin(4) - 2) + sin(3*(t-5.5))/(t-4) + else: + raise ValueError("t trop grand, le hamster dort après 16h!") + +def graph(): + t = np.arange(0, 8, 0.1) + s = np.vectorize(position)(t) + + fig, ax = plt.subplots() + ax.plot(t, s) + + ax.set(xlabel="Temps (en h)", ylabel="Position (en m)", + title="Position de la roue") + ax.grid() + + return ax diff --git a/1ST/03_Nombre_derive_et_tangente/index.rst b/1ST/03_Nombre_derive_et_tangente/index.rst new file mode 100644 index 0000000..fe41a8f --- /dev/null +++ b/1ST/03_Nombre_derive_et_tangente/index.rst @@ -0,0 +1,74 @@ +Nombre dérivé et tangente +######################### + +:date: 2022-11-09 +:modified: 2022-11-09 +:authors: Benjamin Bertrand +:tags: Dérivation +:category: 1ST +:summary: Point de vue local sur la dérivation. + +Éléments du programme +===================== + +Contenus +-------- + +Point de vue local: approche graphique de la notion de nombre dérivé: +- sécantes à une courbe passant par un point donné ; taux de variation en un point ; +- tangente à une courbe en un point, définie comme position limite des sécantes passant par ce point ; +- nombre dérivé en un point défini comme limite du taux de variation en ce point ; +- équation déduite de la tangente en un point + +Capacités attendues +------------------- + +- Interpréter géométriquement le nombre dérivé comme coefficient directeur de la tangente. +- Construire la tangente à une courbe en un point. +- Déterminer l’équation réduite de la tangente à une courbe en un point. + +Commentaires +------------ + +- La notion de nombre dérivé gagne à être illustrée dans des contextes variés : + + - dans le cadre d’un mouvement rectiligne, il est possible d’interpréter le taux de variation de la position du point mobile entre deux instants comme une vitesse moyenne et le nombre dérivé comme une vitesse instantanée ; + - dans un cadre économique, le nombre dérivé est relié au coût marginal. + +- À l’aide d’un logiciel de géométrie dynamique, on visualise la position limite des sécantes à une courbe en un point. +- Il est recommandé de ne pas donner la définition formelle de la notion de limite et de s’en tenir à une approche intuitive à partir d’exemples. Le vocabulaire et la notation correspondants sont introduits à l’occasion du travail sur la notion de nombre dérivé. +- Il est possible de démontrer que la dérivée d’une fonction monotone est de signe + + +Progression +=========== + +Étape 1: Taux d'accroissement +------------------------------ + +Un ensemble de données économiques prises à des intervalles de temps différents. On demande aux élèves de représenter ces données sur un graphique et ils devront proposer une façon de classer les périodes en fonction celles qui ont vu une croissance la plus rapide. + +On demandera ensuite aux élèves de trouver une façon visuelle et une façon calculatoire pour justifier ce classement. + +Bilan: calculs et classement des périodes. Définition du taux d'accroissement et lien avec le calcul d'une vitesse. + +Étape 2: Tangente +----------------- + +Trois exercices où les élèves trouvent des images, tracent des droites et calculent le taux d'accroissement. À chaque fois, on part d'un seul point puis on se rapproche de plus en plus. + +Un exercice se base sur la lecture graphique, le suivant sur une formule et le dernier sur une programme qui calcul des images. + +Bilan: Notion de tangente. + +Étape 3: Les droites +-------------------- + +Partie technique, essentiellement orienté pour les sti2d, les élèves calculent des taux d'accroissement et réutilisent le résultat pour retrouver l'équation d'une droite. + +Étape 4: Programmation et hamster +--------------------------------- + +Activité à ceux qui auront avancés vite. + +`Activité avec de programmation python <./4E_hamster.ipynb>`_ , où l'on reprend un peu tout diff --git a/1ST/03_Nombre_derive_et_tangente/plan_de_travail.tex b/1ST/03_Nombre_derive_et_tangente/plan_de_travail.tex new file mode 100644 index 0000000..72f57c6 --- /dev/null +++ b/1ST/03_Nombre_derive_et_tangente/plan_de_travail.tex @@ -0,0 +1,44 @@ +\documentclass[a4paper,12pt]{article} +\usepackage{myXsim} + +\author{Benjamin Bertrand} +\title{Nombre dérivé et tangente - Plan de travail} +\tribe{1ST} +\date{novembre 2022} + +\pagestyle{empty} + +\DeclareExerciseCollection{banque} +\xsimsetup{ +} + + +\begin{document} +\maketitle + +% Résumé + +\bigskip + +Savoir-faire de la séquence +\begin{itemize} + \item +\end{itemize} + +\bigskip + +Ordre des étapes à respecter + + +\section{} + +\listsectionexercises + + +\pagebreak + +\input{exercises.tex} +\printcollection{banque} + + +\end{document} diff --git a/1ST/03_Nombre_derive_et_tangente/solutions.tex b/1ST/03_Nombre_derive_et_tangente/solutions.tex new file mode 100644 index 0000000..2b7a614 --- /dev/null +++ b/1ST/03_Nombre_derive_et_tangente/solutions.tex @@ -0,0 +1,28 @@ +\documentclass[a4paper,10pt]{article} +\usepackage{myXsim} + +\usetikzlibrary{shapes.geometric} + +\author{Benjamin Bertrand} +\title{Nombre dérivé et tangente - Solutions} +\tribe{1ST} +\date{novembre 2022} + +\DeclareExerciseCollection{banque} +\xsimsetup{ + exercise/print=false, + solution/print=true, +} + +\pagestyle{empty} + + +\begin{document} + +\maketitle + +\input{exercises.tex} +%\printcollection{banque} +%\printsolutions{exercises} + +\end{document} diff --git a/1ST/index.rst b/1ST/index.rst index 3e655b8..b178dbc 100644 --- a/1ST/index.rst +++ b/1ST/index.rst @@ -2,7 +2,7 @@ Tronc commun en première ST ########################### :date: 2022-07-25 -:modified: 2022-10-01 +:modified: 2022-11-09 :authors: Bertrand Benjamin :category: 1ST :tags: Progression @@ -23,13 +23,14 @@ Période 1 :link: ./02_Generalites_sur_les_fonctions/ .. big_button:: - :title: Suites arithmétiques et géométriques + :title: Suites arithmétiques et géométriques (fait par mon remplaçant) Période 2 --------- .. big_button:: :title: Nombre dérivé et tangente + :link: ./03_Nombre_derive_et_tangente/ .. big_button:: :title: Répétition d'expériences