Informatique tronc commun DM 1

(1)

Informatique tronc commun DM 1

16 octobre 2013

Note : ce devoir est à faire de façon individuelle pour le mercredi 13 novembre 2013.

Pour cette date, vous devez avoir renvoyé à votre enseignant le fichier python contenant la réponse à la deuxième partie, ainsi qu’un document, au format PDF, contenant les réponses aux questions posées et les graphiques demandés.

1 Exponentiation rapide

1.1 Contexte mathématique

La justification de cette partie sera (partiellement) donnée dans le cours de mathéma- tiques dans quelques temps. On demande de l’admettre pour la suite.

Le test de Fermat de base2permet de tester si un nombre est (probablement) premier.

Plus précisément, on dira qu’un entierp >2 estprobablement premier si et seulement si a^p−1et1sont congrus modulop(ce qu’on notea^p−1 = 1[p]et qui signifie que la différence a^p−1est divisible parp), où aest égal à2.

Sip est premier alors il est nécessairement probablement premier. La réciproque n’est pas vraie mais les nombresprobablement premiersqui ne sont pas premiers sont très rares quand on a affaire à de grands nombres.

On admettra pour la suite les propriétés suivantes des congruences :

1. La congruence modulopest une relation d’équivalence : pour tout triplet d’entiers (x, y, z) on a x = x[p], de plus x = y[p] implique y = x[p] et enfin x = y[p] et y=z[p]implique x=z[p].

2. L’addition est compatible avec la congruence modulop. Plus précisément, pour tout quadruplet (x, x⁰, y, y⁰) d’entiers, six=x⁰[p]ety=y⁰[p], alors x+y=x⁰+y⁰[p].

3. De même, le produit est compatible avec la congruence modulo p.

4. La mise à la puissance est compatible avec la congruence modulo p. Plus précisé- ment pour tout triplet(x, x⁰, n) d’entiers, six=x⁰[p], alors xⁿ=x⁰ⁿ[p].

1.2 Une première implantation du test de Fermat

On se donne le programme ci-dessous (le source peut être téléchargé depuis le site de la classe).

(2)

# −∗− c o d i n g : u t f−8 −∗−

import timeit import gc import pylab

from math import log, exp K = 1000

# nb de r é p é t i t i o n s de c h a q u e t e s t pour mesurer l e temps REPEAT=3

# nb de p o i n t s pour l e t r a c é N = 100

a = 2

def premierprobable1(p) : y = 1

f o r i in range(p−1 ) : y ∗= a

return (y % p == 1 ) def premierprobable2(p) :

y = 1

f o r i in range(p−1 ) : y = (y ∗ a) % p return (y == 1 )

def premierprobable3(p) : y = 1

x = a n = p−1 while n > 0 :

i f n % 2 != 0 : y = (y ∗ x) % p n = n − 1

x = (x ∗ x) % p n = n // 2 return (y == 1 )

def args(start, end) : s = log(start)

(3)

e = log(end)

return [ int(exp( ( (N−i)∗s + i∗e) / N) ) f o r i in range(N+1) ] def duree(f, x) :

# c a l c u l e l e temps mis pour c a l c u l e r f ( x ) .

# on t e s t e REPEAT f o i s e t on g a r d e l a v a l e u r l a p l u s p e t i t e t = timeit.Timer(stmt=lambda : f(x) )

time = min(t.repeat(REPEAT, number=1)) return time

def bench(f, start=100 , end= 1 0 0 0 0 0 ) : f o r i in args(start, end) :

pylab.scatter( [float(i) ] , [duree(f, i) ] ) pylab.draw( )

pylab.xlim(xmin=0) pylab.ylim(ymin=0)

def fig(name, f, start=100 , end=100000 , yscale= ’ l o g ’ , axis= ’ e q u a l ’ ) : pylab.clf( )

pylab.xscale( ’ l o g ’ ) pylab.yscale( ’ l o g ’ ) pylab.grid( )

pylab.axis( ’ e q u a l ’ )

bench(f, start=start, end=end)

pylab.savefig( " { 0 } . png " .format(name) )

def main( ) :

fig( ’ p r e m i e r p r o b a b l e 1 ’ , premierprobable1, start=100 , end=1000000) fig( ’ p r e m i e r p r o b a b l e 2 ’ , premierprobable2, start=100 , end=1000000) fig( ’ p r e m i e r p r o b a b l e 3 ’ , premierprobable3, start=100 , end=10∗∗100) pylab.axis( ’ image ’ )

pylab.yscale( ’ l i n e a r ’ )

pylab.savefig( ’ p r e m i e r p r o b a b l e 3−s e m i l o g . png ’ ) main( )

1. Montrer que pour tout entierp,premierprobable1(p) retourne un booléen valant vrai si et seulement sip est probablement premier (au sens de la définition donnée plus haut).

2. On note t(p) le temps mis pour le calcul depremierprobable1(p). Déterminer la complexité (théorique) en temps de l’appelpremierprobable1(p) en fonction dep.

On comptera que la multiplication a un coût unitaire.

(4)

3. On donne figure 1 le tracé expérimental obtenu pour t(p) pour des valeurs de p allant de10²à10⁶. L’échelle est une échelle logarithmique (le temps est exprimé en secondes). On peut remarquer qu’avec cette échelle logarithmique, les points sont grossièrement répartis le long d’une droite. En mesurant sur la figure, déterminer la relation expérimentale qu’on peut ainsi obtenir entre logp etlogt(p).

4. En déduire une relation expérimentale entre le temps de calculp ett(p).

5. Conclusion ?

6. Indiquer approximativement jusqu’à quel nombre on peut tester pour que le temps de calcul soit inférieur à 1h.

1.3 Seconde implantation

Mêmes questions pour premierprobable2(p), dont on trouvera un tracé expérimental figure 2.

1.4 Troisième implantation

Même questions pour premierprobable3(p), dont on trouvera un tracé expérimental figure 3. Attention, cette fois-ci l’échelle pour le temps n’est plus logarithmique.

Pour justifier la terminaison depremierprobable3(p), on pourra prendre pour variant blog₂nc.

Pour ce qui est de la complexité théorique, on se contentera de montrer que l’exécution demande un temps en O(lnp) (indication :lnetlog₂ sont proportionnels).

2 Optimisation boursière

Pour cette partie, il s’agira de rendre un fichier d01m-nom-prenom.py contenant votre programme. NB : nom et prénom doivent être renseignés en minuscules et tout accent doit être supprimé dans le nom du fichier.

On s’intéresse au problème suivant : on suppose donné un entier n et un tableau t, indexé par des entiers de [[0, n[[, donnant, pour tout i∈[[0, n[[, la valeur du cours d’une action en bourse à la datei.

On cherche à trouver à quelle date il aurait fallu acheter puis vendre pour maximiser ses pertes, autrement dit, on cherche deux entiers i et j appartenant à [[0, n[[ vérifiant i≤j et maximisantt[i]−t[j]. Remarquez qu’il ne suffit pas de trouver à quelle date le cours est maximum et à quelle date il est minimum : on ne peut vendre qu’après avoir acheté, d’où la contrainte i≤j.

2.1 Première version

1. Écrire une fonctiondate_vente_optimale(t,i) retournant un entierjsupérieur ou égal àimaximisant t[i]−t[j].

Quelle est la complexité de cette fonction dans le cas le pire ? dans le cas le meilleur ? (en fonction den eti).

(5)

Figure1:Résultatsexpérimentauxpourpremierprobable1

(6)

(7)

(8)

2. Écrire une fonction optimise_vente(t) retournant un couple (i, j) avec i ≤ j et maximisant t[i]−t[j]. Quelle est la complexité théorique de optimise_vente(t) (en fonction den) ?

3. En vous inspirant (et en réutilisant si vous le désirez) le code utilisé pour tester les fonctionspremierprobable, testez expérimentalement et tracez les graphes expérimentaux pour des tableaux de tailles 100, 200, . . . , 10 000. Ces résultats confirment-ils votre étude théorique ?

2.2 Une version plus raffinée

1. Écrire une fonction max_cumules(t) retournant un couple (m, p), où m et p sont des tableaux de taille n tels que pour tout i ∈ [[0, n[[, m[i] contient le maximum dest[k]pour k ≤ietp[i]contient un indice pour lequel ce maximum est atteint, c’est-à-dire un entierj≤ivérifiant t[j] =m[i].

2. Quelle est la complexité demax_cumules(t) en fonction den?

3. En déduire une fonction optimise_vente2(t) retournant un couple (i, j), aveci≤ j, maximisantt[i]−t[j].

4. Quelle est la complexité deoptimise_vente2(t) en fonction den?

5. Testez expérimentalement votre code et tracez les graphes expérimentaux pour des tableaux de tailles100,200, . . . 10 000. Confirment-ils l’étude théorique ?