Limites, Dérivation et Applications - Exercices BTS CIEL

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.

Partie 1 : Limites et Dérivées (Fonctions Exponentielles)

Exercice 1 : Limites de fonctions
  1. Calculez $ \lim_{t \to +\infty} (2t + 1)e^{-t} $

    Aide Xcas : limit((2*t+1)*exp(-t), t, infinity)

  2. Calculez $ \lim_{t \to -\infty} (t^2 - 3t + 2)e^{t} $

    Aide Xcas : limit((t^2-3*t+2)*exp(t), t, -infinity)

  3. Calculez $ \lim_{t \to 0} \frac{e^{3t} - 1}{t} $

    Aide Xcas : limit((exp(3*t)-1)/t, t, 0)

  4. Calculez $ \lim_{t \to 0} \frac{e^{4t} - e^{t}}{t} $

    Aide Xcas : limit((exp(4*t)-exp(t))/t, t, 0)

Exercice 2: Dérivées de Fonctions
  1. Calculez la dérivée de $f(t) = (3t - 2)e^{4t}$

    Aide Xcas : diff((3*t-2)*exp(4*t), t)

  2. Calculez la dérivée de $g(t) = (t^2 + 1)e^{-2t}$

    Aide Xcas : diff((t^2+1)*exp(-2*t), t)

  3. 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)

  4. Trouvez la dérivée seconde de $f(t) = (4t - 1)e^{-t}$.

    Aide Xcas : diff((4*t-1)*exp(-t), t, 2)

Partie 2 : Problèmes d'Application en Informatique

Problème 1 : Surveillance de la Mémoire d'un Serveur

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

  1. Calculez M'(t).

    Aide Xcas : diff((0.5*t+2)*exp(-0.1*t) + 4, t)

  2. Montrez que M'(t) peut s'écrire sous la forme M'(t) = (a - b*t)e-0.1t. Déterminez a et b.
  3. Étudiez le signe de M'(t) et les variations de M(t).
  4. Calculez la limite de M(t) quand t tend vers l'infini. Interprétez.

    Aide Xcas : limit((0.5*t+2)*exp(-0.1*t) + 4, t, infinity)

Partie B : Définition d'un Seuil d'Alerte

  1. On souhaite déclencher une alerte lorsque l'utilisation de la mémoire dépasse 5 Go. Déterminez graphiquement (en utilisant Xcas pour tracer la courbe) à partir de quel moment (approximativement) l'alerte sera déclenchée.

    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.

  2. Pour affiner, résolvez numériquement l'équation M(t) = 5.

    Aide Xcas : fsolve((0.5*t+2)*exp(-0.1*t) + 4 = 5, t)

  3. Quelle est la valeur *maximale* de M(t) ? À quel moment est-elle atteinte ? (Utilisez les résultats de la Partie A).
Problème 2: Modélisation de la charge d'un serveur Web

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

  1. Calculer la dérivée C'(t) de la fonction de charge.

    Aide Xcas : diff((10*t + 5)*exp(-0.2*t) + 15, t)

  2. Montrer que C'(t) peut s'écrire sous la forme C'(t) = (a - b*t) * exp(-0.2t). Déterminer les constantes a et b.
  3. Étudier le signe de C'(t) et en déduire les variations de C(t) (croissante/décroissante).
  4. Calculer la limite de C(t) lorsque t tend vers +∞. Interpréter ce résultat dans le contexte du problème.

    Aide Xcas : limit((10*t + 5)*exp(-0.2*t) + 15, t, infinity)

Partie B : Gestion de la capacité du serveur

  1. Le service informatique souhaite savoir à quel moment la charge du serveur atteindra son maximum. Déterminer ce moment en utilisant les résultats de la Partie A.
  2. Quelle est la charge maximale du serveur (en pourcentage) ?

    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.

  3. Si le serveur est dimensionné pour une charge maximale de 70%, pendant combien de temps (en heures) après le début de la campagne publicitaire, le serveur sera-t-il en surcharge ? (Utiliser Xcas pour résoudre numériquement l'équation C(t) = 70, et arrondir si nécessaire).

    Aide Xcas : fsolve((10*t + 5)*exp(-0.2*t) + 15 = 70, t)

  4. À quel moment la charge du serveur repasse-t-elle en dessous de 20%?

    Aide Xcas : fsolve((10*t + 5)*exp(-0.2*t) + 15 = 20, t)

Problème 3 : Croissance et Saturation d'une Base de Données

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

  1. Calculez la dérivée S'(t).

    Aide Xcas : diff((2*t + 1)*exp(-0.05*t) + 10, t)

  2. Montrez que S'(t) peut s'écrire sous la forme S'(t) = (a - bt)e-0.05t et déterminez a et b.
  3. Étudiez le signe de S'(t) et les variations de S(t).
  4. Quelle est la taille initiale de la base de données (à t=0) ?

    Aide Xcas : subst((2*t + 1)*exp(-0.05*t) + 10, t=0)

  5. Calculez $\lim_{t \to \infty} S(t)$. Interprétez ce résultat.

    Aide Xcas : limit((2*t + 1)*exp(-0.05*t) + 10, t, infinity)

Partie B: Gestion de l'espace disque

  1. À quel moment la base de données atteint-elle sa taille maximale ?
  2. Quelle est cette taille maximale (en To) ?

    Aide Xcas : Substituer la valeur de t trouvée en B.1 dans S(t)

  3. Si le système de stockage a une capacité maximale de 18 To, l'espace disque sera-t-il suffisant à long terme? Justifiez.
  4. Combien de temps faut-il pour que la base de données atteigne 95% de sa taille limite ? (Résolution numérique avec Xcas).

    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.

Problème 4: Évolution du Nombre d'Utilisateurs d'une Plateforme

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

  1. Calculer la dérivée U'(t).

    Aide Xcas : diff((5*t + 10)*exp(-0.1*t) + 5, t)

  2. Montrez que U'(t) peut s'écrire sous la forme U'(t) = (a - b*t) * exp(-0.1t). Déterminer a et b.
  3. Étudier le signe de U'(t) et les variations de U(t).
  4. Quel était le nombre initial d'utilisateurs (à t=0) ?

    Aide Xcas : subst((5*t + 10)*exp(-0.1*t) + 5, t=0)

  5. Calculer la limite de U(t) lorsque t tend vers +∞. Interprétez ce résultat.

    Aide Xcas : limit((5*t + 10)*exp(-0.1*t) + 5, t, infinity)

Partie B: Stratégie Marketing

  1. À quel moment le nombre d'utilisateurs atteint-il son maximum ?
  2. Quel est ce nombre maximal d'utilisateurs (en milliers) ?
  3. L'équipe marketing souhaite relancer une campagne de publicité lorsque le nombre d'utilisateurs passera en dessous de 6000. Déterminer à quel moment (en semaines) cette campagne devra être lancée (résolution numérique avec Xcas).

    Aide Xcas : Convertir 6000 en milliers (6), puis utiliser `fsolve`.

  4. Combien de temps faut-il pour atteindre 90% du nombre limite d'utilisateurs ?

    Aide Xcas : Calculer 90% de la limite trouvée en A.5, puis utiliser `fsolve`.

Problème 5 : Temps de Réponse d'un Service Cloud

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

  1. Calculez R'(t).

    Aide Xcas : diff((0.1*t + 2)*exp(0.02*t) + 5, t)

  2. Montrez que R'(t) peut s'écrire sous la forme R'(t) = (at + b)e0.02t. Déterminez a et b.
  3. Étudiez le signe de R'(t) et les variations de R(t) pour t ≥ 0.
  4. Quel est le temps de réponse initial (à t=0) ?

    Aide Xcas : subst((0.1*t + 2)*exp(0.02*t) + 5, t=0)

Partie B : Optimisation du Service

  1. Le temps de réponse augmente-t-il ou diminue-t-il avec le temps ?
  2. Les ingénieurs souhaitent maintenir le temps de réponse en dessous de 10 ms. Déterminez, en utilisant Xcas, si cet objectif est atteint et, si non, à partir de quel moment il est dépassé.

    Aide Xcas : fsolve((0.1*t + 2)*exp(0.02*t) + 5 = 10, t)

  3. Existe-t-il un temps de réponse maximal? Si oui, donnez une estimation et une justification. Si non, justifiez.
Problème 6 : Disponibilité d'un Service en Ligne

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é

  1. Calculez D'(t).

    Aide Xcas : diff(100 - (t + 5)*exp(-0.5*t), t)

  2. Montrez que D'(t) peut s'écrire (a - b*t)e-0.5t. Déterminer a et b.
  3. Étudiez le signe de D'(t) et les variations de D(t).
  4. Quelle est la disponibilité initiale du service (à t=0)?

    Aide Xcas : subst(100 - (t + 5)*exp(-0.5*t), t=0)

  5. Calculez $\lim_{t \to \infty} D(t)$. Interprétez.

    Aide Xcas : limit(100 - (t + 5)*exp(-0.5*t), t, infinity)

Partie B : Objectifs de Disponibilité

  1. À quel moment la disponibilité atteint-elle son minimum ?
  2. Quelle est cette disponibilité minimale ?

    Aide Xcas : Substituer la valeur de t trouvée en B.1 dans D(t)

  3. L'objectif est d'atteindre une disponibilité de 99%. Déterminez (numériquement, avec Xcas) après combien de temps cet objectif est atteint.

    Aide Xcas : fsolve(100 - (t + 5)*exp(-0.5*t) = 99, t)

Problème 7 : Trafic Réseau et Heures de Pointe

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

  1. Calculez la dérivée T'(t).

    Aide Xcas : diff((2*t+5)*exp(-0.2*t) + 10, t)

  2. Mettre T'(t) sous la forme (a-b*t)e-0.2t.
  3. Étudier les variations de T(t).
  4. Calculer la limite de T(t) quand t tend vers l'infini.

    Aide Xcas : limit((2*t+5)*exp(-0.2*t) + 10, t, infinity)

Partie B: Capacité du Réseau

  1. À quelle heure le trafic est-il maximal?
  2. Quel est ce trafic maximal (en Gb/s) ?

    Aide Xcas : Substituer la valeur de t trouvée en B.1 dans T(t).

  3. Si la capacité du lien réseau est de 16 Gb/s, pendant combien de temps le réseau sera-t-il saturé ? (Utiliser Xcas pour la résolution numérique).

    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.

  4. Quel est le traffic à t=0?

    Aide Xcas : subst((2*t+5)*exp(-0.2*t) + 10, t=0)

Problème 8 : Température d'un Composant Électronique

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

  1. Calculez T'(t).

    Aide Xcas : diff((0.5*t + 10)*exp(-0.01*t) + 20, t)

  2. Montrer que T'(t) est de la forme (a - bt)e-0.01t.
  3. Étudier le signe de T'(t) et les variations de T(t).
  4. Quelle est la température initiale du composant (à t=0) ?

    Aide Xcas : subst((0.5*t + 10)*exp(-0.01*t) + 20, t=0)

  5. Calculer la limite de T(t) quand t tend vers +∞. Interprétez.

    Aide Xcas : limit((0.5*t + 10)*exp(-0.01*t) + 20, t, infinity)

Partie B: Prévention de la Surchauffe

  1. À quel moment la température du composant est-elle maximale ?
  2. Quelle est cette température maximale ?

    Aide Xcas : Substituer la valeur de t trouvée en B.1 dans T(t).

  3. Le composant est équipé d'un système de refroidissement qui se déclenche à 60°C. Déterminez, si ce système se déclenchera, et si oui, après combien de temps (résolution numérique).

    Aide Xcas : fsolve((0.5*t + 10)*exp(-0.01*t) + 20 = 60, t). Attention, il peut n'y avoir *aucune* solution.

Problème 9 : Nombre de requêtes vers un serveur de base de données

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

  1. Calculez R'(t).

    Aide Xcas : diff((4*t + 8)*exp(-0.25*t) + 2, t)

  2. Montrez que R'(t) a la forme (a - bt)e-0.25t.
  3. Étudiez le signe de R'(t) et les variations de R(t). **Indication:** *Il faut factoriser la dérivée pour étudier son signe.*
  4. Vers quelle valeur tend R(t) lorsque t tend vers +∞ ? Interprétez.

    Aide Xcas : limit((4*t + 8)*exp(-0.25*t) + 2, t, infinity)

Partie B : Gestion des Ressources

  1. À quel moment le nombre de requêtes est-il maximal ?
  2. Quel est ce nombre maximal de requêtes (en milliers) ?

    Aide Xcas : Substituer la valeur de t trouvée en B.1 dans R(t)

  3. Le serveur est capable de traiter un maximum de 15 000 requêtes par heure. Déterminez pendant quelle période (en heures) le serveur sera surchargé (résolution numérique avec Xcas).

    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.

  4. Quel est le nombre de requêtes à t=0?

    Aide Xcas : subst((4*t + 8)*exp(-0.25*t) + 2, t=0)

Problème 10 : Modélisation de la consommation d'une bande passante

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

  1. Calculez la dérivée C'(t).

    Aide Xcas : diff((3*t + 2)*exp(-0.1*t) + 5, t)

  2. Montrez que C'(t) peut s'écrire sous la forme C'(t) = (a-bt)e-0.1t.
  3. Étudiez le signe de C'(t), et les variations de C(t). **Indication:** *Il faut factoriser la dérivée pour étudier son signe.*
  4. Calculez la limite de C(t) quand t tend vers +∞.

    Aide Xcas : limit((3*t + 2)*exp(-0.1*t) + 5, t, infinity)

Partie B: Gestion de la Capacité

  1. À quel moment la consommation de bande passante est-elle maximale ?
  2. Quelle est cette consommation maximale ?

    Aide Xcas : Substituer la valeur de t trouvé en B.1 dans C(t).

  3. Si la capacité maximale du data center est de 20 Gb/s, pendant combien de temps (en heures) la consommation dépassera-t-elle 80% de cette capacité maximale ? (Résolution numérique).

    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.

Problème 11 : Fiabilité d'un système de sauvegarde

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é

  1. Calculez R'(t).

    Aide Xcas : diff(95 - (0.2*t + 1)*exp(-0.1*t), t)

  2. Mettez R'(t) sous la forme (a + b*t)e-0.1t. Déterminez a et b.
  3. Étudiez les variations de R(t). **Indication:** *Il faut factoriser la dérivée pour étudier son signe.*
  4. Quelle est la fiabilité initiale du système (à t=0) ?

    Aide Xcas : subst(95 - (0.2*t + 1)*exp(-0.1*t), t=0)

  5. Vers quelle valeur tend R(t) lorsque t tend vers l'infini ?

    Aide Xcas : limit(95 - (0.2*t + 1)*exp(-0.1*t), t, infinity)

Partie B : Maintenance Préventive

  1. La fiabilité augmente-t-elle ou diminue-t-elle avec le temps ?
  2. Une maintenance préventive est recommandée lorsque la fiabilité descend en dessous de 90%. Déterminer après combien de temps cette maintenance doit être effectuée (résolution numérique avec Xcas).

    Aide Xcas : fsolve(95 - (0.2*t + 1)*exp(-0.1*t) = 90, t)

  3. Existe-t-il une fiabilité minimale ? Justifiez.
Problème 12 : Modélisation de la charge CPU

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

  1. Calculez CPU'(t).

    Aide Xcas : diff((2*t+5)*exp(-0.05*t) + 30, t)

  2. Montrez que CPU'(t) peut s'écrire (a-bt)e-0.05t.
  3. Étudier le signe de CPU'(t), et les variations de CPU(t). **Indication :** *Il faut factoriser pour étudier le signe de la dérivée.*
  4. Calculez la limite de CPU(t) quand t tend vers +∞.

    Aide Xcas : limit((2*t+5)*exp(-0.05*t) + 30, t, infinity)

Partie B: Gestion des Performances

  1. À quel moment la charge CPU est-elle maximale?
  2. Quelle est la charge CPU maximale ?

    Aide Xcas : Substituer la valeur de t trouvée en B.1 dans CPU(t)

  3. Si le serveur commence à ralentir lorsque la charge CPU dépasse 75%, pendant combien de temps le serveur fonctionnera-t-il de manière optimale ? (Résolution numérique)

    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.

  4. Quelle est la charge CPU à t=0?

    Aide Xcas : subst((2*t+5)*exp(-0.05*t) + 30, t=0)

Problème 13 : Taux d'erreur dans une transmission de données

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

  1. Calculez TE'(t).

    Aide Xcas : diff((0.1*t + 0.5)*exp(-0.2*t) + 0.1, t)

  2. Montrez que TE'(t) est de la forme (a - bt)e-0.2t.
  3. Étudiez les variations de TE(t). **Indication :** *Factorisez la dérivée pour étudier son signe.*
  4. Vers quelle valeur tend TE(t) quand t tend vers l'infini ? Interprétez.

    Aide Xcas : limit((0.1*t + 0.5)*exp(-0.2*t) + 0.1, t, infinity)

Partie B : Amélioration de la Transmission

  1. À quel moment le taux d'erreur est-il maximal ?
  2. Quel est ce taux d'erreur maximal ?

    Aide Xcas : Substituer la valeur de t trouvée en B.1 dans TE(t).

  3. Un protocole de correction d'erreurs est mis en place si le taux d'erreur dépasse 1.5%. Déterminez si ce protocole sera nécessaire et, si oui, pendant combien de temps (résolution numérique).

    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.

Problème 14 : Nombre de connexions simultanées à un serveur

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

  1. Calculez la dérivée C'(t).

    Aide Xcas : diff((t+10)*exp(-0.1*t) + 20, t)

  2. Mettre C'(t) sous la forme (a-b*t)e-0.1t.
  3. Étudier les variations de C(t). **Indication:** *Il faut factoriser la dérivée pour étudier son signe.*
  4. Calculer $\lim_{t \to +\infty} C(t)$

    Aide Xcas : limit((t+10)*exp(-0.1*t) + 20, t, infinity)

Partie B: Capacité du Serveur

  1. À quel moment le nombre de connexions simultanées est-il maximal ?
  2. Quel est ce nombre maximal de connexions ?

    Aide Xcas : Substituer la valeur de t trouvée en B.1 dans C(t).

  3. Si le serveur est conçu pour gérer un maximum de 25 000 connexions simultanées, pendant combien de temps ce seuil sera-t-il dépassé ? (Résolution numérique)

    Aide Xcas : 25000 connexions = 25 milliers. Utiliser `fsolve` pour résoudre C(t) = 25. Il y aura deux solutions, ou aucune.

  4. Quel est le nombre de connexions simultanées à t=0?

    Aide Xcas : subst((t+10)*exp(-0.1*t) + 20, t=0)

Problème 15 : Croissance du nombre de machines virtuelles

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

  1. Calculez N'(t).

    Aide Xcas : diff((0.5*t + 4)*exp(-0.02*t) + 10, t)

  2. Mettez N'(t) sous la forme (a - bt)e-0.02t.
  3. Étudiez les variations de N(t). **Indication:** *Il faut factoriser la dérivée pour étudier son signe.*
  4. Vers quelle valeur tend N(t) quand t tend vers +∞ ? Interprétez.

    Aide Xcas : limit((0.5*t + 4)*exp(-0.02*t) + 10, t, infinity)

Partie B: Capacité du Cloud

  1. À quel moment le nombre de VM est-il maximal ?
  2. Quel est ce nombre maximal de VM (en centaines) ?

    Aide Xcas : Substituer la valeur de t trouvée en B.1 dans N(t)

  3. Si le cloud peut supporter un maximum de 1800 VM, déterminez pendant combien de temps cette capacité sera suffisante (résolution numérique avec Xcas).

    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.

Problème 16 : Taux de Complétion des Téléchargements

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

  1. Calculez la dérivée TC'(t).

    Aide Xcas : diff(100 - (0.5*t + 2)*exp(-0.1*t), t)

  2. Mettez TC'(t) sous la forme (a + bt) * exp(-0.1t). Déterminer a et b.
  3. Étudier le signe de TC'(t) et les variations de TC(t). **Indication:** *Il faut factoriser la dérivée pour étudier son signe.*
  4. Calculer la limite de TC(t) lorsque t tend vers +∞. Interpréter ce résultat.

    Aide Xcas : limit(100 - (0.5*t + 2)*exp(-0.1*t), t, infinity)

Partie B : Amélioration du Service

  1. Le taux de complétion augmente-t-il ou diminue-t-il avec le temps ?
  2. On considère qu'un téléchargement est réussi lorsque son taux de complétion atteint 99%. Déterminer après combien de temps (en secondes) un téléchargement est considéré comme réussi (résolution numérique).

    Aide Xcas : fsolve(100 - (0.5*t + 2)*exp(-0.1*t) = 99, t)

  3. Existe-t-il un taux de complétion minimal? Justifier.
Problème 17 : Modélisation du temps de compilation

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

  1. Calculez T'(n).

    Aide Xcas : diff((0.05*n+0.1)*exp(0.01*n) + 0.5, n)

  2. Montrez que T'(n) peut s'écrire (an + b)e0.01n. Déterminer a et b.
  3. Étudiez le signe de T'(n) pour n > 0, et les variations de T(n).

Partie B: Optimisation du code

  1. Le temps de compilation augmente-t-il ou diminue-t-il avec la taille du code ?
  2. Si un développeur souhaite maintenir le temps de compilation en dessous de 5 secondes, quelle est la taille maximale (en milliers de lignes de code) du programme qu'il peut écrire ? (Résolution numérique).

    Aide Xcas : fsolve((0.05*n+0.1)*exp(0.01*n) + 0.5 = 5, n)

  3. Existe-t-il un temps de compilation minimal? Si oui, donnez une estimation. Si non, justifiez.
Problème 18 : Modélisation de l'utilisation d'un disque dur

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

  1. Calculez la dérivée U'(t).

    Aide Xcas : diff((t + 5)*exp(-0.02*t) + 2, t)

  2. Montrez que U'(t) peut se mettre sous la forme (a - bt)e-0.02t.
  3. Étudiez le signe de U'(t) et les variations de U(t). **Indication:** *Il faut factoriser la dérivée pour étudier son signe.*
  4. Vers quelle valeur tend U(t) quand t tend vers +∞? Interprétez.

    Aide Xcas : limit((t + 5)*exp(-0.02*t) + 2, t, infinity)

Partie B: Gestion de l'Espace Disque

  1. À quel moment l'espace disque utilisé est-il maximal ?
  2. Quel est cet espace disque maximal (en To) ?

    Aide Xcas : Substituer la valeur de t trouvée en B.1 dans U(t)

  3. Si la capacité totale du serveur est de 10 To, déterminez pendant combien de temps le serveur aura suffisamment d'espace disque disponible (résolution numérique avec Xcas).

    Aide Xcas : fsolve((t + 5)*exp(-0.02*t) + 2 = 10, t). Il peut n'y avoir *aucune* solution.

  4. Quel est l'espace disque utilisé à t=0?

    Aide Xcas : subst((t + 5)*exp(-0.02*t) + 2, t=0)

Problème 19 : Qualité de service d'une API

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

  1. Calculez R'(t).

    Aide Xcas : diff(99 - (0.1*t + 1)*exp(-0.2*t), t)

  2. Mettez R'(t) sous la forme (a + bt)e-0.2t
  3. Étudiez les variations de R(t). **Indication:** *Il faut factoriser la dérivée pour étudier son signe*
  4. Vers quelle valeur tend R(t) quand t tend vers +∞ ?

    Aide Xcas : limit(99 - (0.1*t + 1)*exp(-0.2*t), t, infinity)

<

Partie B: Surveillance et Alertes

  1. 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$.

  2. 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.

  3. 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\%$.

Problème 20 : Performance d'un algorithme de chiffrement

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

  1. Calculez T'(n).

    Aide Xcas : diff((0.01*n + 0.2)*exp(0.005*n) + 1, n)

  2. Montrez que T'(n) peut s'écrire sous la forme (an + b)e0.005n
  3. Étudiez le signe de T'(n) pour n > 0, et les variations de T(n). **Indication:** *Il faut factoriser pour étudier le signe de la dérivée.*

Partie B : Limitations de l'Algorithme

  1. Le temps de chiffrement augmente-t-il ou diminue-t-il avec la taille du message ?
  2. Si l'on souhaite que le chiffrement prenne moins de 10 ms pour des raisons de performance, quelle est la taille maximale du message que l'on peut chiffrer ? (Résolution numérique).

    Aide Xcas : fsolve((0.01*n + 0.2)*exp(0.005*n) + 1 = 10, n)

  3. Existe-t-il un temps de chiffrement minimal ? Si oui, donnez son estimation. Si non, justifiez.
Problème 21 : Modélisation de la latence réseau (bis)

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

  1. Calculez la dérivée L'(n).

    Aide Xcas : diff((0.05*n + 1)*exp(0.01*n) + 4, n)

  2. Montrez que L'(n) peut s'écrire (an + b)e0.01n. Déterminer les constantes a et b.
  3. Étudier le signe de L'(n) pour n > 0, et les variations de L(n). **Indication:** *Il faut factoriser la dérivée pour étudier son signe.*

Partie B : Optimisation des performances

  1. La latence augmente-t-elle ou diminue-t-elle avec le nombre de requêtes ?
  2. Si l'on souhaite maintenir la latence en dessous de 15 ms, quel est le nombre maximal de requêtes simultanées que le réseau peut supporter? (Résolution numérique).

    Aide Xcas : fsolve((0.05*n + 1)*exp(0.01*n) + 4 = 15, n)

  3. Existe-t-il une latence minimale ? Si oui, donnez une estimation. Si non, justifiez.
Problème 22 : Évolution du nombre d'abonnés à un service

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

  1. Calculez A'(t).

    Aide Xcas : diff((3*t + 6)*exp(-0.15*t) + 2, t)

  2. Mettez A'(t) sous la forme (a - bt)e-0.15t. Déterminez a et b.
  3. Étudiez le signe de A'(t) et les variations de A(t). **Indication :** *Factorisez la dérivée.*
  4. Vers quelle valeur tend A(t) quand t tend vers +∞ ? Interprétez.

    Aide Xcas : limit((3*t + 6)*exp(-0.15*t) + 2, t, infinity)

Partie B : Stratégie de croissance

  1. À quel moment le nombre d'abonnés est-il maximal ?
  2. Quel est ce nombre maximal d'abonnés ?

    Aide Xcas : Substituer la valeur de t trouvée en B.1 dans A(t)

  3. L'entreprise vise à atteindre 5000 abonnés. Déterminez si cet objectif sera atteint et, si oui, après combien de temps (résolution numérique).

    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.

  4. Quel est le nombre d'abonnés à t=0?

    Aide Xcas : subst((3*t + 6)*exp(-0.15*t) + 2, t=0)

Problème 23 : Modélisation de la consommation RAM

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

  1. Calculez R'(t).

    Aide Xcas : diff((0.2*t + 1)*exp(-0.05*t) + 4, t)

  2. Mettez R'(t) sous la forme (a-bt)e-0.05t.
  3. Étudier le signe de R'(t), et les variations de R(t). **Indication:** *Factorisez pour étudier le signe de la dérivée.*
  4. Calculez $\lim_{t \to +\infty} R(t)$. Interprétez ce résultat.

    Aide Xcas : limit((0.2*t + 1)*exp(-0.05*t) + 4, t, infinity)

Partie B: Optimisation et seuils

  1. À quel moment la consommation de RAM est-elle maximale ?
  2. Quelle est cette consommation maximale ?

    Aide Xcas : Substituer la valeur de t trouvée en B.1 dans R(t)

  3. Si l'application dispose de 8 Go de RAM au total, déterminez si cette quantité de RAM sera suffisante et, si non, pendant combien de temps elle le sera.

    Aide Xcas : Utiliser `fsolve` pour résoudre R(t) = 8.

  4. Quelle est la consommation de RAM à t=0?

    Aide Xcas : subst((0.2*t + 1)*exp(-0.05*t) + 4, t=0)

Problème 24 : Fiabilité d'un système RAID

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é

  1. Calculez R'(t).

    Aide Xcas : diff(98 - (0.1*t + 0.5)*exp(-0.1*t), t)

  2. Mettez R'(t) sous la forme (a + b*t)e-0.1t. Déterminez a et b.
  3. Étudiez les variations de R(t). **Indication:** *Il faut factoriser la dérivée pour étudier son signe.*
  4. Vers quelle valeur tend R(t) quand t tend vers +∞ ? Interprétez.

    Aide Xcas : limit(98 - (0.1*t + 0.5)*exp(-0.1*t), t, infinity)

  5. Quelle est la fiabilité initiale (à t=0) ?

    Aide Xcas : subst(98 - (0.1*t + 0.5)*exp(-0.1*t), t=0)

Partie B : Maintenance et Remplacement

  1. La fiabilité augmente-t-elle ou diminue-t-elle globalement avec le temps ?
  2. Un remplacement du système est prévu lorsque la fiabilité atteint 90%. Déterminer après combien de temps ce remplacement doit être effectué (résolution numérique).

    Aide Xcas : fsolve(98 - (0.1*t + 0.5)*exp(-0.1*t) = 90, t)

  3. Existe-t-il une fiabilité minimale ? Si oui, quelle est cette valeur et à quel moment est-elle atteinte ?
Problème 25 : Bande passante d'une connexion fibre

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

  1. Calculez la dérivée B'(t).

    Aide Xcas : diff((t + 20)*exp(-0.01*t) + 40, t)

  2. Mettez B'(t) sous la forme (a - bt)e-0.01t. Déterminez a et b.
  3. Étudiez le signe de B'(t) et les variations de B(t). **Indication:** *Il faut factoriser pour étudier le signe de la dérivée.*
  4. Vers quelle valeur tend B(t) quand t tend vers +∞ ? Interprétez ce résultat.

    Aide Xcas : limit((t + 20)*exp(-0.01*t) + 40, t, infinity)

  5. Quelle est la bande passante initiale (à t=0)?

    Aide Xcas : subst((t + 20)*exp(-0.01*t) + 40, t=0)

Partie B: Optimisation et seuils

  1. À quel moment la bande passante disponible est-elle maximale ?
  2. Quelle est cette bande passante maximale ?

    Aide Xcas : Substituer la valeur de t trouvée en B.1 dans B(t).

  3. Si un service nécessite une bande passante minimale de 50 Gb/s, déterminez pendant combien de temps ce service pourra fonctionner correctement après l'installation.

    Aide Xcas : Utiliser `fsolve` pour résoudre B(t) = 50. Il peut y avoir plusieurs solutions, ou aucune.