Entraînez-vous sur les limites, la dérivation et découvrez des applications concrètes en informatique pour votre BTS CIEL. Utilisez Xcas pour vérifier vos résultats.
Calculez $ \lim_{t \to +\infty} (2t + 1)e^{-t} $
Aide Xcas : limit((2*t+1)*exp(-t), t, infinity)
Calculez $ \lim_{t \to -\infty} (t^2 - 3t + 2)e^{t} $
Aide Xcas : limit((t^2-3*t+2)*exp(t), t, -infinity)
Calculez $ \lim_{t \to 0} \frac{e^{3t} - 1}{t} $
Aide Xcas : limit((exp(3*t)-1)/t, t, 0)
Calculez $ \lim_{t \to 0} \frac{e^{4t} - e^{t}}{t} $
Aide Xcas : limit((exp(4*t)-exp(t))/t, t, 0)
Calculez la dérivée de $f(t) = (3t - 2)e^{4t}$
Aide Xcas : diff((3*t-2)*exp(4*t), t)
Calculez la dérivée de $g(t) = (t^2 + 1)e^{-2t}$
Aide Xcas : diff((t^2+1)*exp(-2*t), t)
Calculez la dérivée de $ h(t) = \frac{e^{3t}}{t + 1} $, pour $t > -1$.
Aide Xcas : diff(exp(3*t)/(t+1), t)
Trouvez la dérivée seconde de $f(t) = (4t - 1)e^{-t}$.
Aide Xcas : diff((4*t-1)*exp(-t), t, 2)
L'utilisation de la mémoire (en Go) d'un serveur en fonction du temps t (en heures) est modélisée par : M(t) = (0.5t + 2)e-0.1t + 4
Partie A : Analyse de l'Utilisation de la Mémoire
Aide Xcas : diff((0.5*t+2)*exp(-0.1*t) + 4, t)
Aide Xcas : limit((0.5*t+2)*exp(-0.1*t) + 4, t, infinity)
Partie B : Définition d'un Seuil d'Alerte
Aide Xcas : plot((0.5*t+2)*exp(-0.1*t) + 4)
puis utiliser l'outil graphique pour estimer l'intersection avec la droite y=5.
Aide Xcas : fsolve((0.5*t+2)*exp(-0.1*t) + 4 = 5, t)
La charge d'un serveur Web (en pourcentage de sa capacité maximale) en fonction du temps t (en heures) après le début d'une campagne publicitaire est modélisé par: C(t) = (10t + 5) * exp(-0.2t) + 15
Partie A : Analyse de la charge du serveur
Aide Xcas : diff((10*t + 5)*exp(-0.2*t) + 15, t)
Aide Xcas : limit((10*t + 5)*exp(-0.2*t) + 15, t, infinity)
Partie B : Gestion de la capacité du serveur
Aide Xcas : subst((10*t + 5)*exp(-0.2*t) + 15, t=...)
en remplaçant ... par la valeur trouvée à la question précédente.
Aide Xcas : fsolve((10*t + 5)*exp(-0.2*t) + 15 = 70, t)
Aide Xcas : fsolve((10*t + 5)*exp(-0.2*t) + 15 = 20, t)
La taille S(t) (en To) d'une base de données en fonction du temps t (en mois) après sa création est modélisée par : S(t) = (2t + 1)e-0.05t + 10
Partie A: Analyse de la croissance
Aide Xcas : diff((2*t + 1)*exp(-0.05*t) + 10, t)
Aide Xcas : subst((2*t + 1)*exp(-0.05*t) + 10, t=0)
Aide Xcas : limit((2*t + 1)*exp(-0.05*t) + 10, t, infinity)
Partie B: Gestion de l'espace disque
Aide Xcas : Substituer la valeur de t trouvée en B.1 dans S(t)
Aide Xcas : D'abord trouver la taille limite (cf A.5). Puis, calculer 95% de cette taille. Enfin, utiliser fsolve
pour trouver t tel que S(t) est égal à cette valeur.
Le nombre d'utilisateurs (en milliers) d'une plateforme en ligne en fonction du temps t (en semaines) après son lancement est modélisé par : U(t) = (5t + 10) * exp(-0.1t) + 5
Partie A: Analyse de la Croissance
Aide Xcas : diff((5*t + 10)*exp(-0.1*t) + 5, t)
Aide Xcas : subst((5*t + 10)*exp(-0.1*t) + 5, t=0)
Aide Xcas : limit((5*t + 10)*exp(-0.1*t) + 5, t, infinity)
Partie B: Stratégie Marketing
Aide Xcas : Convertir 6000 en milliers (6), puis utiliser `fsolve`.
Aide Xcas : Calculer 90% de la limite trouvée en A.5, puis utiliser `fsolve`.
Le temps de réponse moyen R(t) (en millisecondes) d'un service cloud en fonction du temps t (en minutes) après une mise à jour est modélisée par : R(t) = (0.1t + 2)e0.02t + 5
Partie A : Analyse du Temps de Réponse
Aide Xcas : diff((0.1*t + 2)*exp(0.02*t) + 5, t)
Aide Xcas : subst((0.1*t + 2)*exp(0.02*t) + 5, t=0)
Partie B : Optimisation du Service
Aide Xcas : fsolve((0.1*t + 2)*exp(0.02*t) + 5 = 10, t)
La disponibilité D(t) (en pourcentage) d'un service en ligne après une maintenance, en fonction du temps t (en heures), est modélisée par: D(t) = 100 - (t + 5)e-0.5t
Partie A : Analyse de la Disponibilité
Aide Xcas : diff(100 - (t + 5)*exp(-0.5*t), t)
Aide Xcas : subst(100 - (t + 5)*exp(-0.5*t), t=0)
Aide Xcas : limit(100 - (t + 5)*exp(-0.5*t), t, infinity)
Partie B : Objectifs de Disponibilité
Aide Xcas : Substituer la valeur de t trouvée en B.1 dans D(t)
Aide Xcas : fsolve(100 - (t + 5)*exp(-0.5*t) = 99, t)
Le trafic T(t) (en Gb/s) sur un lien réseau en fonction du temps t (en heures) au cours d'une journée est modélisé par : T(t) = (2t + 5)e-0.2t + 10
Partie A: Analyse du Trafic
Aide Xcas : diff((2*t+5)*exp(-0.2*t) + 10, t)
Aide Xcas : limit((2*t+5)*exp(-0.2*t) + 10, t, infinity)
Partie B: Capacité du Réseau
Aide Xcas : Substituer la valeur de t trouvée en B.1 dans T(t).
Aide Xcas : fsolve((2*t+5)*exp(-0.2*t) + 10 = 16, t)
. Il peut y avoir plusieurs solutions. Considérer l'intervalle de temps entre les solutions pertinentes.
Aide Xcas : subst((2*t+5)*exp(-0.2*t) + 10, t=0)
La température T(t) (en degrés Celsius) d'un composant électronique en fonction du temps t (en secondes) après sa mise en marche est modélisée par : T(t) = (0.5t + 10)e-0.01t + 20
Partie A : Analyse Thermique
Aide Xcas : diff((0.5*t + 10)*exp(-0.01*t) + 20, t)
Aide Xcas : subst((0.5*t + 10)*exp(-0.01*t) + 20, t=0)
Aide Xcas : limit((0.5*t + 10)*exp(-0.01*t) + 20, t, infinity)
Partie B: Prévention de la Surchauffe
Aide Xcas : Substituer la valeur de t trouvée en B.1 dans T(t).
Aide Xcas : fsolve((0.5*t + 10)*exp(-0.01*t) + 20 = 60, t)
. Attention, il peut n'y avoir *aucune* solution.
Le nombre de requêtes R(t) (en milliers) qu'un serveur de base de données reçoit par heure, t heures après le début de la journée, est modélisé par : R(t) = (4t + 8)e-0.25t + 2
Partie A : Analyse du nombre de requêtes
Aide Xcas : diff((4*t + 8)*exp(-0.25*t) + 2, t)
Aide Xcas : limit((4*t + 8)*exp(-0.25*t) + 2, t, infinity)
Partie B : Gestion des Ressources
Aide Xcas : Substituer la valeur de t trouvée en B.1 dans R(t)
Aide Xcas : fsolve((4*t + 8)*exp(-0.25*t) + 2 = 15, t)
. Il y aura deux solutions. La période de surcharge est l'intervalle entre ces deux solutions.
Aide Xcas : subst((4*t + 8)*exp(-0.25*t) + 2, t=0)
La consommation de bande passante C(t) (en Gb/s) d'un data center en fonction du temps t (en heures), est modélisée par la fonction : C(t) = (3t + 2)e-0.1t + 5
Partie A : Analyse de la Consommation
Aide Xcas : diff((3*t + 2)*exp(-0.1*t) + 5, t)
Aide Xcas : limit((3*t + 2)*exp(-0.1*t) + 5, t, infinity)
Partie B: Gestion de la Capacité
Aide Xcas : Substituer la valeur de t trouvé en B.1 dans C(t).
Aide Xcas : 80% de 20 Gb/s est 16 Gb/s. Résoudre C(t) = 16 avec `fsolve`. Il y aura deux solutions. La réponse est l'intervalle de temps entre ces deux solutions.
La fiabilité R(t) (en pourcentage) d'un système de sauvegarde en fonction du temps t (en jours) après sa mise en service est modélisée par : R(t) = 95 - (0.2t + 1)e-0.1t
Partie A : Analyse de la Fiabilité
Aide Xcas : diff(95 - (0.2*t + 1)*exp(-0.1*t), t)
Aide Xcas : subst(95 - (0.2*t + 1)*exp(-0.1*t), t=0)
Aide Xcas : limit(95 - (0.2*t + 1)*exp(-0.1*t), t, infinity)
Partie B : Maintenance Préventive
Aide Xcas : fsolve(95 - (0.2*t + 1)*exp(-0.1*t) = 90, t)
La charge CPU (en pourcentage) d'un serveur en fonction du temps t (en minutes) est modélisée par la fonction :
CPU(t) = $(2t + 5) * exp(-0.05t) + 30$
Partie A: Analyse de la Charge CPU
Aide Xcas : diff((2*t+5)*exp(-0.05*t) + 30, t)
Aide Xcas : limit((2*t+5)*exp(-0.05*t) + 30, t, infinity)
Partie B: Gestion des Performances
Aide Xcas : Substituer la valeur de t trouvée en B.1 dans CPU(t)
Aide Xcas : fsolve((2*t + 5)*exp(-0.05*t) + 30 = 75, t)
. Il y aura potentiellement deux solutions; considérez le temps *avant* la première solution.
Aide Xcas : subst((2*t+5)*exp(-0.05*t) + 30, t=0)
Le taux d'erreur TE(t) (en pourcentage) lors d'une transmission de données en fonction du temps t (en secondes) est modélisé par : TE(t) = (0.1t + 0.5)e-0.2t + 0.1
Partie A : Analyse du Taux d'Erreur
Aide Xcas : diff((0.1*t + 0.5)*exp(-0.2*t) + 0.1, t)
Aide Xcas : limit((0.1*t + 0.5)*exp(-0.2*t) + 0.1, t, infinity)
Partie B : Amélioration de la Transmission
Aide Xcas : Substituer la valeur de t trouvée en B.1 dans TE(t).
Aide Xcas : fsolve((0.1*t + 0.5)*exp(-0.2*t) + 0.1 = 1.5, t)
. Il peut y avoir plusieurs solutions, ou aucune. Interprétez correctement.
Le nombre de connexions simultanées C(t) (en milliers) qu'un serveur peut gérer, t heures après une mise à jour, est modélisé par : C(t) = (t + 10)e-0.1t + 20
Partie A: Analyse des Connexions
Aide Xcas : diff((t+10)*exp(-0.1*t) + 20, t)
Aide Xcas : limit((t+10)*exp(-0.1*t) + 20, t, infinity)
Partie B: Capacité du Serveur
Aide Xcas : Substituer la valeur de t trouvée en B.1 dans C(t).
Aide Xcas : 25000 connexions = 25 milliers. Utiliser `fsolve` pour résoudre C(t) = 25. Il y aura deux solutions, ou aucune.
Aide Xcas : subst((t+10)*exp(-0.1*t) + 20, t=0)
Le nombre de machines virtuelles (VM) N(t) (en centaines) en fonction du temps t (en jours) dans un cloud est modélisé par : N(t) = (0.5t + 4)e-0.02t + 10
Partie A: Analyse de la Croissance
Aide Xcas : diff((0.5*t + 4)*exp(-0.02*t) + 10, t)
Aide Xcas : limit((0.5*t + 4)*exp(-0.02*t) + 10, t, infinity)
Partie B: Capacité du Cloud
Aide Xcas : Substituer la valeur de t trouvée en B.1 dans N(t)
Aide Xcas : 1800 VM = 18 centaines de VM. Utiliser `fsolve` pour résoudre N(t) = 18. Il pourrait ne pas y avoir de solution, auquel cas la capacité est *toujours* suffisante.
Le taux de complétion TC(t) (en pourcentage) des téléchargements sur un serveur en fonction du temps t (en secondes) après le début du téléchargement est modélisé par : TC(t) = 100 - (0.5t + 2) * exp(-0.1t)
Partie A : Analyse du Taux de Complétion
Aide Xcas : diff(100 - (0.5*t + 2)*exp(-0.1*t), t)
Aide Xcas : limit(100 - (0.5*t + 2)*exp(-0.1*t), t, infinity)
Partie B : Amélioration du Service
Aide Xcas : fsolve(100 - (0.5*t + 2)*exp(-0.1*t) = 99, t)
Le temps de compilation T(n) (en secondes) d'un programme en fonction de la taille n (en milliers de lignes de code) est modélisé par : T(n) = (0.05n + 0.1)e0.01n + 0.5
Partie A : Analyse du temps de compilation
Aide Xcas : diff((0.05*n+0.1)*exp(0.01*n) + 0.5, n)
Partie B: Optimisation du code
Aide Xcas : fsolve((0.05*n+0.1)*exp(0.01*n) + 0.5 = 5, n)
L'espace disque utilisé U(t) (en To) sur un serveur en fonction du temps t (en semaines) est modélisé par la fonction: U(t) = (t + 5)e-0.02t + 2
Partie A : Analyse de l'utilisation du disque
Aide Xcas : diff((t + 5)*exp(-0.02*t) + 2, t)
Aide Xcas : limit((t + 5)*exp(-0.02*t) + 2, t, infinity)
Partie B: Gestion de l'Espace Disque
Aide Xcas : Substituer la valeur de t trouvée en B.1 dans U(t)
Aide Xcas : fsolve((t + 5)*exp(-0.02*t) + 2 = 10, t)
. Il peut n'y avoir *aucune* solution.
Aide Xcas : subst((t + 5)*exp(-0.02*t) + 2, t=0)
La qualité de service R(t) (en pourcentage) d'une API en fonction du temps t (en heures) après une mise à jour est modélisée par: R(t) = 99 - (0.1t + 1)e-0.2t
Partie A : Analyse de la Qualité de Service
Aide Xcas : diff(99 - (0.1*t + 1)*exp(-0.2*t), t)
Aide Xcas : limit(99 - (0.1*t + 1)*exp(-0.2*t), t, infinity)
Partie B: Surveillance et Alertes
Le pourcentage de requêtes réussies augmente avec le temps, car, comme nous l'avons vu dans la partie A, $R'(t) > 0$ pour tout $t \ge 0$.
On cherche $t$ tel que $R(t) = 95$. On utilise Xcas pour la résolution numérique : fsolve(99 - (0.1*t + 1)*exp(-0.2*t) = 95, t)
. Xcas donne une solution négative (environ -1.72), ce qui n'a pas de sens dans notre contexte (temps négatif).
Comme la fonction $R(t)$ est strictement croissante, et que $R(0) = 99 - (0.1(0) + 1)e^0 = 99-1=98$, le pourcentage de requêtes réussies est *toujours* supérieur à 95%. L'alerte ne sera donc jamais déclenchée.
Oui, il existe un pourcentage de requêtes réussies minimal. Comme $R(t)$ est strictement croissante, le minimum est atteint en $t=0$, qui vaut $R(0) = 98\%$.
Le temps T(n) (en millisecondes) nécessaire pour chiffrer un message de n Ko avec un algorithme de chiffrement est modélisé par : T(n) = (0.01n + 0.2)e0.005n + 1
Partie A : Analyse du Temps de Chiffrement
Aide Xcas : diff((0.01*n + 0.2)*exp(0.005*n) + 1, n)
Partie B : Limitations de l'Algorithme
Aide Xcas : fsolve((0.01*n + 0.2)*exp(0.005*n) + 1 = 10, n)
La latence L(n) (en millisecondes) d'un réseau en fonction du nombre de requêtes simultanées n est modélisée par : L(n) = (0.05n + 1)e0.01n + 4
Partie A : Analyse de la latence
Aide Xcas : diff((0.05*n + 1)*exp(0.01*n) + 4, n)
Partie B : Optimisation des performances
Aide Xcas : fsolve((0.05*n + 1)*exp(0.01*n) + 4 = 15, n)
Le nombre d'abonnés A(t) (en milliers) à un service en ligne en fonction du temps t (en mois) après son lancement est modélisé par : A(t) = (3t + 6)e-0.15t + 2
Partie A : Analyse du nombre d'abonnés
Aide Xcas : diff((3*t + 6)*exp(-0.15*t) + 2, t)
Aide Xcas : limit((3*t + 6)*exp(-0.15*t) + 2, t, infinity)
Partie B : Stratégie de croissance
Aide Xcas : Substituer la valeur de t trouvée en B.1 dans A(t)
Aide Xcas : 5000 abonnés = 5 milliers d'abonnés. Utiliser `fsolve` pour résoudre A(t) = 5. Il peut y avoir plusieurs solutions, ou aucune.
Aide Xcas : subst((3*t + 6)*exp(-0.15*t) + 2, t=0)
La consommation de RAM, R(t) (en Go), d'une application en fonction du temps t (en minutes) après son lancement est modélisée par : R(t) = (0.2t + 1)e-0.05t + 4
Partie A : Analyse de la consommation RAM
Aide Xcas : diff((0.2*t + 1)*exp(-0.05*t) + 4, t)
Aide Xcas : limit((0.2*t + 1)*exp(-0.05*t) + 4, t, infinity)
Partie B: Optimisation et seuils
Aide Xcas : Substituer la valeur de t trouvée en B.1 dans R(t)
Aide Xcas : Utiliser `fsolve` pour résoudre R(t) = 8.
Aide Xcas : subst((0.2*t + 1)*exp(-0.05*t) + 4, t=0)
La fiabilité R(t) (en pourcentage) d'un système RAID en fonction du temps t (en mois) après sa mise en service est modélisée par : R(t) = 98 - (0.1t + 0.5)e-0.1t
Partie A : Analyse de la Fiabilité
Aide Xcas : diff(98 - (0.1*t + 0.5)*exp(-0.1*t), t)
Aide Xcas : limit(98 - (0.1*t + 0.5)*exp(-0.1*t), t, infinity)
Aide Xcas : subst(98 - (0.1*t + 0.5)*exp(-0.1*t), t=0)
Partie B : Maintenance et Remplacement
Aide Xcas : fsolve(98 - (0.1*t + 0.5)*exp(-0.1*t) = 90, t)
La bande passante disponible B(t) (en Gb/s) d'une connexion fibre optique en fonction du temps t (en heures) après l'installation est modélisée par la fonction : B(t) = (t + 20)e-0.01t + 40
Partie A : Analyse de la Bande Passante
Aide Xcas : diff((t + 20)*exp(-0.01*t) + 40, t)
Aide Xcas : limit((t + 20)*exp(-0.01*t) + 40, t, infinity)
Aide Xcas : subst((t + 20)*exp(-0.01*t) + 40, t=0)
Partie B: Optimisation et seuils
Aide Xcas : Substituer la valeur de t trouvée en B.1 dans B(t).
Aide Xcas : Utiliser `fsolve` pour résoudre B(t) = 50. Il peut y avoir plusieurs solutions, ou aucune.