Année universitaire 2017-2018

Proposition de corrigé pour le CCP informatique session 2016

Matière Nombre de pages nombre d’heures Classes
Informatique 14 4h 2ième Cycle préparatoire

I
Enseignant Houcemeddine FILALI

AL
1 Introduction
2 Acquisition d’images par l’imageur VIMS et compression des
données

IL
2.1 Présentation
Un cube de données hyperspectrales peut être modélisé par une liste de matrices où chaque matrice est

F
à son tour une liste de listes. Avec des listes filles formées par des entiers codés sur 12 bits.
ne
di
ed
m
u ce

Figure 1 – Structure d’un cube de données.

Ho

Si img est un cube image, alors pour un triplet :

— lambda_i dans {0 . . . 351}.

— x_i dans {0 . . . 63}.
— y_i de {0 . . . 63}.
img[lambda_i][x_i][y_i] donne une valeur entière dans {0 . . . 212 − 1} indiquant le nombre moyen de
photons reçus par le capteur VIMS au point de coordonnées (x_i,y_i) sur la longueur d’onde lambda_i.
 La fonction suivante permet de générer aléatoirement un cube de données qui respecte les spécifications
de l’énoncé :

def cube_aléatoire(nx = 64, ny = 64, nlambda = 352):

from random import randint
return [ [ [randint(0,2**12-1) for x in range(nx)] for y in range(ny)] for l in range(nlambda)]
Contrainte de transfert : taille d’un cube doit être ≤ 1 méga-octet. Solution = compression des données.
Q-1)
Taille d’un pixel = 12bits.

I
AL
Solution: Taille d’un cube = largeur du spectre × hauteur (dimension spatiale x) × largeur (di-
mension spatiale y) × taille d’un pixel = 352 × 64 × 64 × 12 bits = 2162688octets = 2112 kilo-octets
= 2.0625 méga-octets.

Le taux de compression est donnée par :

IL
(
T − Tc T taille des données avant compression.
τ= où
T Tc taille des données après compression.

F
Cas limites :
— Aucune compression : T = Tc ⇒ τ = 0.
— Réduction totale Tc = 0 ⇒ τ = 1.
⇒ τ ∈ [0, 1[.
ne
Q-2)
di
Solution: Contraintes de transfert ⇒ taille maximale d’un cube = 1 méga-octets = Tc .
Taille d’un cube avant compression = 2.0625 méga-octets = T .
ed

T − Tc
τ= = 0.515 ⇒ Il faut réduire 51.51% de la taille du cube pour respecter le cahier des charges.
T
m

2.2 Principe de la compression des données

ce

Q-3)
Pour v une valeur entière (non signée) qui s’écrit sur k bits :
u

. . 0})2 ≤ n < (1 |0 .{z

(1 |0 .{z . . 0})2
k−1× k×
Ho

2k−1 ≤ n < 2k
⇒ k − 1 ≤ log2 n < k
⇒ k ≤ log2 (n) + 1 < k + 1
⇒ k = blog2 (n) + 1c = nombre de bits nécessaire pour coder n une valeur entière non signée
Par exemple, il faudra blog2 (8) + 1c = 4 bits pour représenter les valeurs de la séquence Sn = 4 − 5 −
7 − 0 − 7 − 8 − 4 − 1 − 7 − 4..
L’idée de la compression entropique est de représenter une valeur avec un code dont la longueur est
inversement proportionnelle à la fréquence de la valeur dans la séquence à compresser.

Page 2
 2.3 Limite du taux de compression
L’entropie de Shannon d’une séquence de valeurs Sn est donnée par la formule :
Nv
(
X Nv nombre de valeurs distinctes dans la série Sn
H(Sn ) = − pi log2 (pi ) avec
i=1
p i probabilité d’apparition de la valeur vi dans la séquence Sn

L’entropie donne la longueur moyenne du code optimal permettant de représenter les valeurs de la série
Sn .
Cas limites de H(Sn ) :

I
— Séquence homogène : ∃!vi tel que pi = 1 et ∀vj 6= vi pj = 0. ⇒ H(Sn ) = 0.

AL
— Équiprobabilité : ∀vi pi = |N1v | ⇒ H(Sn ) = log2 (|Nv |).

Solution: Le script suivant permet de calculer l’entropie de la série Sn = 4 − 5 − 7 − 0 − 7 − 8 −

4 − 1 − 7 − 4.

IL
from math import log2
prob = [0.3] * 2 + [0.1] * 4 #les probabilités d’apparition
h = -sum(p * log2(p) for p in prob)
print(h)

F
Le script affiche la valeur 2.3709505944546687 ≈ 2.4 bits par valeur.

Q-4)
Q-5)
ne
Q-6)
di
Solution: La fonction suivante permet de calculer l’entropie de Shannon d’une séquence s :
ed

def entropie(s):
from math import log2
#Q4-Calculer l’ensemble des valeurs distinctes len(vals) == Nv
m

vals = set(s)
#Q5-Calcul de la probabilité d’apparition pour les valeurs distinctes
prob = [[Link](v)/len(s) for v in vals]
#Q6-calcul de l’entropie de Shannon
ce

return -sum(p*log2(p) for p in prob)

Q-7)
u
Ho

Solution:

from random import randint

n = 64
bloc_image = [randint(0,2**12-1) for i in range(n)] #génération aléatoire d’une séquence
t = len(bloc_image) * 12 #12 bits par valeur*nbre de valeurs
tc = len(bloc_image) * entropie(bloc_image) #logueur moyenne optimale*nbre de valeur
tau = (t-tc)/t
print("tau = ",tau)

Page 3
 2.4 Prétraitement des données avant compression
Les données brutes sont traitées par blocs de 64 colonnes (dimension spatiale y) par 32 lignes (dimension
spectrale) pixels codés sur 12bits. Cette matrice est représentée par une liste de listes. Pour 0 ≤ nl < 32
et0 ≤ y < 64, donnees_brutes[nl][y] permet de récupérer le pixel situé à la ligne nl, colonne y. Pour
tester l’efficacité de l’étape des prétraitements, nous utilisons la fonction suivante pour générer un bloc
de données aléatoirement.
def donnes_brutes_alea(nlambda = 32, ny = 64):
"""

I
Permets de générer un bloc de données brutes aléatoirement

AL
La fonction retourne une matrice (une liste de listes)
La listes filles reperésentent les lignes de la matrice
(toutes de taille ny = 64 = dimension spatiale). La liste mère contient
nlambda listes filles (dimension spectrale).
"""

IL
import random as rnd
return [[[Link](0,2**12-1) for y in range(ny)] for nl in range(nlambda)]
Le prétraitement vise à réduire l’entropie de la matrice des données brutes afin de minimaliser le nombre

F
de bits nécessaires pour coder les données. Les étapes de cette phase sont décrites ci-dessous :
1. Calculer le vecteur de luminance moyenne, c’est une liste de 64 float contenant la moyenne des 4
1 X
lignes suivantes de la matrice donnees_brutes : luminance_moy = donnees_brutes[i].
4 i=1,11,21,31
ne
2. identification du pixel de luminance maximale dans la liste des moyennes précédente :
— luminance_max = max(luminance_moy)
di
— j_max = luminance_moy.index(luminance_max)
3. Extraction du vecteur colonne spectre_max (une liste de taille 32) contenant la colonne (y = j_max)
de la matrice donnees_brutes :
ed

spectre_max = ( donnees_brutes[i][j_max] )0≤i<32 .

spectre_max
4. Normaliser la vecteur spectre_max : spectre_max = .
luminance_max
5. Construction de la matrice modèle (une liste de listes 32 × 64) en effectuant le produit matriciel
m

suivant :
matrice_modele = spectre_max × luminance_moy
| {z } | {z } | {z }
32×64
ce

32×1 1×64

⇒ La matrice_modele est soustraite à la matrice des données brutes pour construire la matrice des
données prétraitées : matrice_pretraitee = donnees_brutes - matrice_modele. Cette matrice
à une entropie plus réduite que celle des données brutes.
u

Q-8)
Ho

Solution:

def pretraitement12(donnees_brutes):
"""
Permets d’effectuer les étapes 1&2 de la chaine des prétraitements
renvoie le triplet
-luminance_moy
-luminance_max

Page 4
 -j_max
"""
luminance_moy = [sum(donnees_brutes[i][j] for i in range(1,32,10))/4 for j in range(64)]
j_max = 0
for y in range(1, len(luminance_moy)):
if luminance_moy[y] > luminance_moy[j_max]:
j_max = y
return luminance_moy, luminance_moy[j_max], j_max

Complexité calculatoire : m = nombre de colonnes et n = nombre de lignes de la matrice source

I
donnees_brutes.

AL
— Coût du calcul du vecteur luminance_moy =
— Coût de calcul d’un élément de luminance_moy = 8 (4 × 2) indexages + 4 additions + 1
division = 13 opérations.
⇒ Coût du remplissage du vecteur luminance_moy = 13× nombre de colonnes = 13 m.

IL
— Calcul de y_max :
— Coût d’une itération = 1 comparaison + 1 affectation + 2 indexages = 4 opérations.
⇒ Coût total = 4× nombre de colonnes = 4 m

F
⇒ Coût total de la fonction pretraitements12 = 17 m = O(m) donc linéaire en fonction du
nombre de colonnes.

Q-9)
ne
Solution:
di
def pretraitement34(donnees_brutes, luminance_max, j_max):
"""
ed

Permets d’effectuer les étapes 3&4 de la chaine des prétraitements

renvoie un vecteur colonne (une liste) de 32 floats contenant le vecteur
colonne d’indice j_max normalisé par la valeur luminance_max
"""
m

return [donnees_brutes[i][j_max]/luminance_max for i in range(32)]

Complexité calculatoire en fonction de n = nombre de lignes et m = nombre de colonnes de la

matrice donnees_brutes.
ce

— Coût du calcul d’un seul élément du vecteur résultant : 2 indexages + 1 division = 3 opérations.
⇒ Coût global = 3× nombre de lignes = 3 n = O(n) donc linéaire par rapport au nombre de
lignes.
u
Ho

Q-10)

Solution:

def pretraitement5(luminance_moy, spectre_max):

"""
Permets d’effectuer l’étape 5 de la chaine des prétraitements
renvoie une matrice (liste de liste) résultant du produit matriciel
spectre_max * luminance_moy

Page 5
 """
return [ [spectre_max[i] * luminance_moy[j] for j in range(len(luminance_moy))] for i
,→ in range(len(spectre_max))]

Complexité calculatoire en fonction de n = nombre de lignes et m = nombre de colonnes de la

matrice donnees_brutes :
— Coût de calcul d’un seul élément de la matrice résultante = 2 indexages + 1 multiplication =
3 opérations.
⇒ Coût du remplissage d’une ligne = 3n.

I
⇒ Coût total = 3nm = O(n m).

AL
Q-11)

IL
Solution:

def pretraitement(donnees_brutes):
"""

F
Permets d’effectuer la chaine des prétraitements et retourne la matrice prétraitée
ayant une entropie plus réduite que celle de la matrice source
"""
lmoy, lmax, jmax = pretraitement12(donnees_brutes)
ne
spmax = pretraitement34(donnees_brutes, lmax, jmax)
matrice_modele = pretraitement5(lmoy, spmax)
return [[donnees_brutes[i][j]- matrice_modele[i][j] for j in range(64)] for i in
,→ range(32)]
di
Coût calculatoire de la chaine des prétraitments :
+ Coût pretraitement12 = 17m.
ed

+ Coût pretraitement34 = 3n.

+ Coût pretraitement5 = 3nm.
+ Coût de la soustraction des matrices :
m

— Coût d’une itération = 4 indexages + 1 soustraction = 5 opérations.

⇒ Coût total = 5nm
⇒ Coût total des prétraitements = 17m + 3n + 3nm + 5nm = 17m + 3n + 8nm = O(nm).
ce

2.5 Compression des données

u

2.5.1 Prédiction-mappage
Ho

Figure 2 – Architecture fonctionnelle d’un compresseur

Page 6
 — Le compresseur prend en entrée un paquet x de données (une liste de 32 valeurs entières codées sur
12bits).
— Le premier échantillon x0 est un échantillon de référence sur lequel se base le prédicteur pour déduire
xˆk = xk−1 ∀k ≥ 1.
— La prédiction est effectuée ici, en prenant la valeur de xk−1 . L’erreur de la prédiction ∆k = xk − xˆk =
xk − xk−1 est mesurée ∀k ≥ 1.
— Le Mappeur fait correspondre chaque erreur de prédiction ∆k à un entier δk non signé par la
fonction mappage suivante : Pour θk = min(xˆk − xmin , xmax − xˆk )

I

2∆k
 si 0 ≤ ∆k ≤ θk

AL
δk = 2|∆k | − 1 si − θk ≤ ∆k < 0

θk + |∆k | sinon.


L’encodeur entropique réalise le codage sans perte des valeurs delta.

IL
Q-12)

Solution:

F
def prediction(x):
"""
Calcule l’erreur de prédiction pour une série de données
"""
ne
return [x[i]-x[i-1] for i in range(1, len(x))]
di
Q-13)
ed

Solution:

def mappage(erreur, x):

"""
m

Calcule le mappage des erreurs de prédiction rangées dans la liste erreur

"""
x_min = min(x)
ce

x_max = max(x)
delta = list()
for k in range(len(erreur)):
u

theta = min(x[k]-x_min , x_max - x[k])

if 0 <= erreur[k] <= theta:
[Link](2 * erreur[k])
Ho

elif -theta <= erreur[k] < 0:

[Link](2 * abs(erreur[k]) -1)
else:
[Link](theta + abs(erreur[k]))
return delta

Page 7
 2.5.2 Codage entropique - Algorithme de Rice

Codage de Rice :
Entrées :
1. N un entier non signé à coder.
2. p un paramètre de l’algorithme.
Procédé :
1. q ← N div 2p

I
2. q1 ← codage unaire de q.

AL
3. r ← N mod 2p noter que r < 2p .
4. r2 ← codage binaire de r sur p bits.
Sortie : concaténation de q1 et r2 .
Q-14)
p = 3, δ = [4, 10, 18, 18, 6, 1, 3] et d = 2p = 8.

IL
Solution:
δk q q1 r r2 résultat

F
4 0 0 4 100 0 100
10 1 10 2 010 10 010
18 2 110 2 010 110 010
6
1
0
0
ne 0
0
6
1
110
001
0 110
0 001
3 0 0 3 011 0 011
di
Q-15)
ed

Solution:

def codage1(delta, p_opt):

m

"""
Permets d’effectuer le codage unaire du quotient de chaque
élément de delta par 2^p_opt
"""
ce

d = 2**p_opt
return ["1" * (n//d) + "0" for n in delta]
u

Q-16)
Ho

Solution:

def codage(delta, p_opt):

"""
Permets de calculer le code de Rice
d’une série de données stockées dans delta
"""
#codes unaires du quotient

Page 8
 d = 2**p_opt
code1 = codage1(delta, p_opt)
#code binaire du reste (sur k <= p_opt bits)
code2 = [bin(n%d)[2:] for n in delta] #slicing pour éliminer le préfixe 0b
#s’assurer que le code binaire s’écrit sur p_opt bits
code2 = ["0" * (p_opt - len(c)) + c for c in code2]
return [c1 + c2 for c1, c2 in zip(code1, code2)] #concaténation des codes

I
3 Mise en orbite de la sonde autour de Saturne

AL
3.1 Présentation
Phénomène d’assistance gravitationnelle = utiliser le champ de gravitation d’un astre afin de fournir une
accélération supplémentaire à la sonde.

IL
3.2 Modélisation du mouvement de la sonde lors de la phase d’assistance
gravitationnelle

F
Simuler le mouvement de la sonde = Estimer la fonction de son déplacement r(t) ∀t ≥ t0 .
Hypothèses :
H1 Référentiel héliocentrique (O, →
−
x,→
−
y ) ⇒ O = centre d’inertie du soleil.
ne
H2 La sonde est repérée par son centre d’inertie G, auquel sont associés :
−−→
le vecteur → −
(
r (t) = OG
di
l’angle θ(t).

H3 La planète Vénus est repérée par son centre d’inertie Gv auquel sont associés :
ed

−−→
le vecteur → −
(
rv (t) = OGv
l’angle θv (t).
m

H4 Le propulseur de la sonde n’étant pas utilisé lors du survol de Vénus.

H5 Seul le Soleil on et Vénus ont une influence gravitationnelle significative sur la trajectoire de la
ce

sonde.
H6 Trajectoire de la sonde et de Vénus sont considérées comme coplanaires :
   
→
− x(t) →
− xv (t)
u

r (t) = et rv (t) =
y(t) yv (t)
Ho

H7 L’orbite de Vénus autour du soleil est considérée comme quasiment circulaire :


11
  rv = 1.08209 × 10 m

→
− xv (t) = rv cos(Ωt + Φ)
rv (t) = avec Ω = θ̇(t) = 3.23639 × 10−7 rad s−1
yv (t) = rv sin(Ωt + Φ) 
Φ = Position angulaire initiale de vénus ≈ π rad


Page 9
 Deuxième loi de Newton ou principe fondamental de la dynamique de translation (PFD) :
Soit un corps de masse m (constante) : l’accélération subie par ce corps dans un référentiel galiléen est
proportionnelle à la résultante des forces qu’il subit, et inversement proportionnelle à sa masse m. Ceci
est souvent récapitulé dans l’équation 1.

~
1 X~ Fi désigne les forces extérieures exercées sur l’objet,

~a = Fi avec m est sa masse, et (1)
m i 
~a correspond à l’accélération de son centre d’inertie G.


I
AL
La modélisation d’Isaac Newton de la gravitation :

Dans l’écriture vectorielle de la force gravitationnelle s’énonce comme suit :

F~12

force gravitationnelle exercée par le corps 1 sur le corps 2 en N ou m kg s−2 ,

IL


constante gravitationnelle 6.6742 × 10−11 N m2 kg −2 ,

G




m1 m2 m et m masses des deux corps en présence (en kilogrammes) ,
1 2
F~12 = −G · 2
~u12 avec
d d distance entre les 2 corps (en mètres) ,

F



~u12



 vecteur unitaire dirigé du corps 1 vers le corps 2 ,

le signe – indique que le corps 2 est attiré par le corps 1.

(2)
ne
Q-17)
L’équation du mouvement de la sonde :
di
d2 →
−
r (t) →
−
r (t) →
−
r (t) − →
−
rv (t)
2
= −Gms →
− 3 − Gm v →
− →
− 3 (3)
dt k r (t)k k r (t) − rv (t)k
ed

Avec

G, constante universelle de gravitation

Gms = 1.32724×1020 N m2 kg et Gmv = 3.24916×1014 N m2 kg
m

ms , masse du soleil

mv , masse de vénus

ce

Solution: On dénote par m la masse de la sonde. À partir de l’équation 2, il est possible de déduire
les influences gravitationnelles du soleil et de vénus sur la sonde que nous dénotons respectivement
−
→ − →
u

par Fs et Fv explicitées ci-dessous.

−
→ ms m
Fs = −G · 2 ~us
Ho

ds
2
~ 2
Or d2s = OG = k~r(t)k voir figure 3

~
OG ~r(t)
us = =
~
OG k~r(t)k

→
−
r (t)
⇒ F~s = −Gms m →
− 3 (4)
k r (t)k

Page 10
 De même
mv m
F~v = −G · 2 u~v
dv
2 2
2
Or d2v = G~v G ~ v + OG
= −OG ~ = k~r(t) − r~v (t)k voir figure 3

G~v G ~r(t) − r~v (t)

uv = =
~
Gv G k~r(t) − r~v (t)k

I
~r(t) − r~v (t)
⇒ F~v = −Gmv m (5)

AL
3
k~r(t) − r~v (t)k
Étant donnée l’hypothèque que le mouvement de la sonde est régit par les influences gravitationnelles
du soleil et de vénus uniquement. En appliquant la PDF donnée par l’équation 1 nous obtenons :

d2 →
−
r (t) 1 X~ 1 ~ ~
 →
−
r (t) →
−
r (t) − →
−
rv (t)

IL
~a = 2
= Fi = F s + F v = −Gm s →
− 3 − Gmv →
− →
− 3 (6)
dt m i m k r (t)k k r (t) − rv (t)k

F
ne
di
ed
m
u ce

~ et OG
~v
Ho

Figure 3 – Relation entre les vecteurs OG

Q-18)
L’équation précédente peut se mettre sous la forme :
 d2 x(t)
 dt2 = Sx (x(t), y(t), t)

(7)
 d2 y(t)

dt2 = Sy (x(t), y(t), t)

Page 11
 Solution:
 2 
d ~x(t)    
→
− x(t) x(t) − rv cos(Ωt + Φ)
d2 r (t)  dt  2
−Gms  − Gm v
= = →
− 3 →
− →
− 3
 
dt2 2 k r (t)k k r (t) − rv (t)k
d ~y (t)
2
y(t) y(t) − rv sin(Ωt + Φ)
dt

def eval_sm(x, y, t):

"""
Permets de calculer les coordonnées de l’accéleration a_x(t) , a_y(t)

I
à l’instant t en fonction des coordonnées actuels de la sonde x(t) et y(t)

AL
"""
from math import sin, cos, pi
gms= 1.32724e20
gmv = 3.24916e14
rv = 1.08209e11

IL
omega = 3.23639e-7
phi = pi
xv = rv * cos(omega * t + phi)
yv = rv * sin(omega * t + phi)

F
d3 = (x**2+y**2)**(3/2)
dsv3 = ((x-xv)**2 + (y-yv)**2)**(3/2)
sx = -gms/d3 * x - gmv/dsv3 * (x-xv)
sy = -gms/d3 * y - gmv/dsv3 * (y-yv)
return sx, sy
ne
di
3.3 Résolution numérique
3.3.1 Méthode numérique
ed

Q-19)
La fonction vitesse de la sonde est dénotée par :
 dx(t)   
v (t)
m

d~r(t)  dt   x 
v(t) = = =
dt dy(t) vy (t)
dt
ce

Temps discret (ti )i≥0 : ∆t = ti+1 − ti . On note par vx (ti ) = ui , vy (ti ) = vi , x(ti ) = xi et y(ti ) = yi .

Solution:
u

vx (ti+1 ) − vx (ti ) ui+1 − ui ui+1 − ui

x00 (ti ) = vx0 (ti ) ≈ = = = Sx (x(t), y(t), t) = Sx (xi , yi , ti )
Ho

ti+1 − ti ti+1 − ti ∆t

⇒ ui+1 = ∆t · Sx (xi , yi , ti ) + ui (8)

vy (ti+1 ) − vy (ti ) vi+1 − vi vi+1 − vi

y 00 (ti ) = vy0 (ti ) ≈ = = = Sy (x(ti ), y(ti ), ti ) = Sy (xi , yi , ti )
ti+1 − ti ti+1 − ti ∆t

⇒ vi+1 = ∆t · Sy (xi , yi , ti ) + vi (9)

Page 12
Q-20)

Solution:
x(ti+1 ) − x(ti ) xi+1 − xi xi+1 − xi
ui = vx (ti ) = x0 (ti ) ≈ = =
ti+1 − ti ti+1 − ti ∆t
⇒ xi+1 = ∆t · ui + xi (10)

y(ti+1 ) − y(ti ) yi+1 − yi yi+1 − yi

I
vi = vy (ti ) = y 0 (ti ) ≈ = =
ti+1 − ti ti+1 − ti ∆t

AL
⇒ yi+1 = ∆t · vi + yi (11)

3.3.2 Le programme de résolution

IL
Q-21)

F
Solution:

#variables globales supposées définies

t0 = ...
x0 = ...
ne
y0 = ...
u0 = ...
di
v0 = ...
deltaT = ...
n = ...
ed

#Q21
x = [x0]
y = [y0]
u = [u0]
m

v = [v0]
t = [t0 + i * deltaT for i in range(n)]
ce

Q-22)
Étant donné un état de départ (x0 , y0 , u0 , v0 ) et une séquence (ti )i≥0 alors il est possible d’induire les
valeurs (xi , yi , ui , vi )∀ti en utilisant les 4 relations de récurrence :
u

ui+1 = ∆t · Sx (xi , yi , ti ) + ui
Ho

vi+1 = ∆t · Sy (xi , yi , ti ) + vi
xi+1 = ∆t · ui + xi
yi+1 = ∆t · vi + yi

Page 13
 Solution:

#Q22
for ti in t[:-1]:
sx, sy = eval_sm(x[-1],y[-1],ti)
[Link](deltaT * u[-1] + x[-1])
[Link](deltaT* v[-1] + y[-1])
[Link](deltaT* sx + u[-1])
[Link](deltaT * sy + v[-1])

I
AL
Q-23)
Étant donné qu’un float est codé sur 8 octets.

Solution: Durée de la simulation 30 jours, avec ∆t = 1seconde ⇒ n = 30 × 24 × 60 × 60 = 2592000.

La simulation nécessite 5 listes (x, y, t, u et v) de float de taille n. ⇒ Quantité de mémoire nécessaire

IL
= n×5×8 octets = 103680000 octets = 101250 kilo-octets = 98.876953125 méga-octets. ⇒ Faisable.

F
3.4 Évolution de la vitesse
Q-24) ne
Solution:

def vitesse_sonde(t, u, v):

di
"""
Permets de tracer l’évolution de la norme de la vistesse en fonction du temps :
-t : vecteurs contenant les ti exprimés en secondes (liste)
ed

-u = v_x(t) en m s-1 pour toutes les valeurs de ti (liste)

-v = v_y(t) en m s-1 pour touts les valeurs de ti (liste)
"""
import [Link] as plt
m

mv = [(ui**2 + vi ** 2)**(1/2)/1000 for ui, vi in zip(u, v) ]

[Link](t, mv)
[Link]("temps en secondes")
ce

[Link]("norme de la vitesse en km s-1")

[Link]("evolution de la norme de la vistesse en fonction du temps")
[Link]()
u
Ho

Page 14