Étude du cas particulier a=2

Comme le minimum 2-2ln(2) est strictement positif, la fonction est strictement positive sur R :

Le script ayant représenté graphiquement cette fonction est le suivant :

a = 2

f = (x) -> exp(x)-a*x
dessineFonction f, 0, 2, 0, 4

Étude du cas général où a est un réel strictement positif

Pour connaître les limites de f_a en ∞ et -∞, le script suivant ne convient pas :

a = 2
f = (x) -> exp(x)-a*x
affiche f(Infinity)
affiche f(-Infinity)

En effet, s’il conclut bien par le fait que la limite en -∞ est +∞, il commence par afficher qu’en +∞ il y a une forme indéterminée (signification du NaN) :

Algorithme lancé
NaN
Infinity

Algorithme exécuté en 28 millisecondes

Pour lever l’indétermination, il ne reste plus qu’à utiliser le cours...

L’étude de la famille de fonctions f_a révèle que le nombre de points d’intersection est 1 lorsque a=e [1] :

a = Math.E

f = (x) -> exp(x)-a*x
dessineFonction f, 0, 2, 0, 2

On voit que dans ce cas il y a contact avec l’axe des abscisses :

Et pour a plus grand que e, par exemple a=3, on voit deux points d’intersection avec l’axe des abscisses :

a = 3

f = (x) -> exp(x)-a*x
dessineFonction f, 0, 2, 0, 4

Pour les probabilités conditionnelles, on utilise l’arbre pondéré.

• comme 5% des puces présentent un défaut, on met le curseur en bas à gauche sur 0,05 (ce qui a pour effet de mettre le curseur en haut sur 0,95 : 95% des puces sont livrées) ;
• comme 2% des puces livrées ont une durée de vie courte, on met le curseur en haut à droite sur 0,02.

On lit en bas de l’arbre : 0,931. Ensuite ?

Ah tiens, c’est la probabilité du contraire de l’évènement précédent : 1-0,931=0,069...

Pour calculer les probabilités exponentielles, on utilise le calculateur ; mais d’abord alcoffeethmique pour avoir une valeur approchée du paramètre :

affiche -ln(0.98)/1000

On copie-colle les 0.000020202707317519467 obtenus dans le cadre destiné à entrer le paramètre.

• si on entre 10000 et 20000 pour les bornes, on lit en bas que « La probabilité qu’elle soit supérieure à 10000 est 0.8171 » ;
• si on entre 20000 et 30000 comme bornes, on lit en haut le résultat « 0.1221 (à 0,0001 près) »

Pour le calcul de probabilités binomiales, on utilise alcoffeethmique :

affiche laSommeDe (binomiale 15000, 0.003, k for k in [40..50])

L’affichage obtenu est

Algorithme lancé
0.5886001161667217

Algorithme exécuté en 24 millisecondes

On définit les droites D₁ et D₂ par point et vecteur directeur, et on redéfinit le point A₂ ; pour savoir s’il est sur la droite D₂, on fait

A1 = $V [0,2,-1]
u1 = $V [1,2,3]
D1 = $L A1, u1
A2 = $V [1,0,2]
u2 = $V [1,-2,0]
D2 = $L A2, u2
A2 = $V [-1,4,2]
affiche D2.contains A2

Le résultat affiché est que oui :

Algorithme lancé
true

Algorithme exécuté en 69 millisecondes

Pour vérifier que les droites D₁ et D₂ ne sont pas coplanaires, on vérifie qu’elles ne sont ni parallèles, ni sécantes :

A1 = $V [0,2,-1]
u1 = $V [1,2,3]
D1 = $L A1, u1
A2 = $V [1,0,2]
u2 = $V [1,-2,0]
D2 = $L A2, u2
A2 = $V [-1,4,2]
affiche D1.isParallelTo D2
affiche D1.intersects D2

Le résultat est qu’effectivement D₁ et D₂ ne sont pas coplanaires :

Algorithme lancé
false
false

Algorithme exécuté en 75 millisecondes

Pour vérifier que Δ₁ et D₁ sont perpendiculaires, on vérifie que leurs vecteurs directeurs le sont :

A1 = $V [0,2,-1]
u1 = $V [1,2,3]
D1 = $L A1, u1
A2 = $V [1,0,2]
u2 = $V [1,-2,0]
D2 = $L A2, u2
A2 = $V [-1,4,2]
v = $V [-6,-3,4]
Δ1 = $L A1, v
Δ2 = $L A2, v
affiche Δ1.direction.isPerpendicularTo D1.direction

Ah tiens oui, ils le sont :

Algorithme lancé
true

Algorithme exécuté en 34 millisecondes

Pour vérifier que n est normal à P₁, on vérifie qu’il est perpendiculaire à deux vecteurs de P₁, non colinéaires entre eux :

A1 = $V [0,2,-1]
u1 = $V [1,2,3]
D1 = $L A1, u1
A2 = $V [1,0,2]
u2 = $V [1,-2,0]
D2 = $L A2, u2
A2 = $V [-1,4,2]
v = $V [-6,-3,4]
Δ1 = $L A1, v
Δ2 = $L A2, v

n = $V [17,-22,9]
affiche n.isPerpendicularTo u1
affiche n.isPerpendicularTo v

On confirme que n est normal à P₁ :

Algorithme lancé
true
true

Algorithme exécuté en 60 millisecondes

On va maintenant définir P₁ par un de ses points (l’intersection de Δ₁ et D₁) et son vecteur normal n. Pour P₂ on fait pareil sauf qu’on ne connaît pas de vecteur normal. Alors on le construit avec « cross », appliqué à deux vecteurs non colinéaires de P₂. On se demande si les deux plans sont sécants ou parallèles :

A1 = $V [0,2,-1]
u1 = $V [1,2,3]
D1 = $L A1, u1
A2 = $V [1,0,2]
u2 = $V [1,-2,0]
D2 = $L A2, u2
A2 = $V [-1,4,2]
v = $V [-6,-3,4]
Δ1 = $L A1, v
Δ2 = $L A2, v
n = $V [17,-22,9]
P1 = $P (Δ1.intersectionWith D1), n
P2 = $P (Δ2.intersectionWith D2), (u2.cross v)

affiche P1.isParallelTo P2

La réponse

Algorithme lancé
false

Algorithme exécuté en 80 millisecondes

est qu’ils ne sont pas parallèles. Ce qui signifie donc qu’ils sont sécants !

Alors on définit leur intersection Δ :

A1 = $V [0,2,-1]
u1 = $V [1,2,3]
D1 = $L A1, u1
A2 = $V [1,0,2]
u2 = $V [1,-2,0]
D2 = $L A2, u2
A2 = $V [-1,4,2]
v = $V [-6,-3,4]
Δ1 = $L A1, v
Δ2 = $L A2, v
n = $V [17,-22,9]
P1 = $P (Δ1.intersectionWith D1), n
P2 = $P (Δ2.intersectionWith D2), (u2.cross v)

Δ = P1.intersectionWith P2
affiche Δ.direction.isPerpendicularTo D1.direction
affiche Δ.direction.isPerpendicularTo D2.direction

Une fois qu’on a Δ, il est temps de se rappeler que

Or le script précédent dit que Δ convient :

Algorithme lancé
true
true

Algorithme exécuté en 32 millisecondes

On constate qu’effectivement la droite joignant M à N a pour vecteur directeur, le vecteur v de l’énoncé :

A1 = $V [0,2,-1]
u1 = $V [1,2,3]
D1 = $L A1, u1
A2 = $V [1,0,2]
u2 = $V [1,-2,0]
D2 = $L A2, u2
v = $V [-6,-3,4]
M = D1.pointClosestTo D2
N = D2.pointClosestTo D1

affiche (N.subtract M).isParallelTo v

Remarque :

On peut calculer les coordonnées de deux points de la droite Δ sans calculer Δ elle-même : En effet elle passe par

• Le point M de D₁ qui est le plus proche possible de D₂ ;
• Le point N de D₂ qui est le plus proche possible de D₁

Le script suivant calcule ces points, qui définissent Δ :

A1 = $V [0,2,-1]
u1 = $V [1,2,3]
D1 = $L A1, u1
A2 = $V [1,0,2]
u2 = $V [1,-2,0]
D2 = $L A2, u2
M = D1.pointClosestTo D2
N = D2.pointClosestTo D1
affiche M.inspect()
affiche N.inspect()

On trouve alors ces coordonnées :

Algorithme lancé
[0.7377049180327868, 3.4754098360655736, 1.2131147540983607]
[-0.4426229508196722, 2.8852459016393444, 2]

Algorithme exécuté en 25 millisecondes

Pour ceux qui ont suivi l’enseignement de spécialité, l’exercice porte sur les puissances d’une matrice : En notant V_n le vecteur de coordonnées (u_n ;v_n), on a V_n+1=MV_n où M est une matrice. Alors le vecteur V est initialisé à la valeur (1 ;0) et l’algorithme devient

rac3 = racine 3
V = $V [1, 0]
M = $M [[rac3,-1],[1,rac3]]
for k in [1..2]
    V = M.x V
    affiche V.inspect() 

(remplacer 2 par une autre valeur si on veut aller plus loin que l’énoncé).

Pour ceux qui ont suivi l’enseignement obligatoire, l’algorithme devient

rac3 = racine 3
[u,v] = [1,0]
for n in [1..2]
    [u,v] = [rac3*u-v,u+rac3*v]
    affiche [u,v]

Mais l’énoncé décrivait l’algorithme dans un langage ne permettant pas l’affectation « simultanée » et il fallait utiliser ce genre d’astuce pour répondre à la question...

Cette variante représente graphiquement la suite (u) :

rac3 = racine 3
[u,v] = [1,0]
suite = [u]
for n in [1..20]
    [u,v] = [rac3*u-v,u+rac3*v]
    suite.push u
dessineSuite suite, 12, 0, 5000

On voit que la suite n’est pas convergente :

Voilà comment on peut vérifier numériquement l’égalité complexe de l’énoncé :

z = new Complexe 1
a = new Complexe racine(3), 1
for k in [1..10]
    z = z.fois a
    affiche z

Cela permet de voir que les suites (u) et (v) sont la partie réelle et la partie imaginaire d’une suite géométrique de raison a=2 e^iπ/6 ; d’où les exrpressions analytiques de u_n et v_n...