source: pyromaths/trunk/fuentes/src/pyromaths/ex/sixiemes/decimaux.py @ 423

Last change on this file since 423 was 423, checked in by mabarracus, 4 years ago

add sources from pyromaths 15.10

File size: 25.7 KB
Line 
1#!/usr/bin/python
2# -*- coding: utf-8 -*-
3#
4# Pyromaths
5# Un programme en Python qui permet de créer des fiches d'exercices types de
6# mathématiques niveau collège ainsi que leur corrigé en LaTeX.
7# Copyright (C) 2006 -- Jérôme Ortais (jerome.ortais@pyromaths.org)
8#
9# This program is free software; you can redistribute it and/or modify
10# it under the terms of the GNU General Public License as published by
11# the Free Software Foundation; either version 2 of the License, or
12# (at your option) any later version.
13#
14# This program is distributed in the hope that it will be useful,
15# but WITHOUT ANY WARRANTY; without even the implied warranty of
16# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17# GNU General Public License for more details.
18#
19# You should have received a copy of the GNU General Public License
20# along with this program; if not, write to the Free Software
21# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22#
23
24import random
25from pyromaths.outils import Affichage, Arithmetique
26#===============================================================================
27# Écrire un nombre en lettres ou en chiffres
28#===============================================================================
29
30
31def NombreEnLettres(n, France=True):
32    unite = {
33        1: "un",
34        2: 'deux',
35        3: 'trois',
36        4: 'quatre',
37        5: 'cinq',
38        6: 'six',
39        7: 'sept',
40        8: 'huit',
41        9: 'neuf',
42        10: 'dix',
43        11: 'onze',
44        12: 'douze',
45        13: 'treize',
46        14: 'quatorze',
47        15: 'quinze',
48        16: 'seize',
49        17: 'dix-sept',
50        18: 'dix-huit',
51        19: 'dix-neuf',
52        }
53    dizaineF = {2: 'vingt', 3: 'trente', 4: 'quarante', 5: 'cinquante',
54                6: 'soixante', 7: "", 8: 'quatre-vingt', 9: ""}
55    dizaineB = {2: 'vingt', 3: 'trente', 4: 'quarante', 5: 'cinquante',
56                6: 'soixante', 7: 'septante', 8: 'octante', 9: 'nonante'}
57    coefs = {0: 'cent', 1: 'mille', 2: 'million', 3: 'milliard'}
58    result = ""
59
60    # Cas particulier de zéro
61    if n == 0:
62        result = u'zéro'
63    else:
64        coef = 0
65
66        while n > 0:
67
68        # Récupération de l'unité du bloc de trois chiffres en cours
69
70            u = n % 10
71            n = n // 10
72
73        # Récupération de la dizaine du bloc de trois chiffres en cours
74
75            d = n % 10
76            n = n // 10
77        # Traitement des dizaines
78
79            temp = ""
80
81        # Passage sur la dizaine inférieure pour 10 à 19
82        # et pour 70-79 90-99 dans le cas de la France
83
84            if d == 1 or (d == 7 or d == 9) and France:
85                d = d - 1
86                u = u + 10
87            if d > 1:
88                if France:
89                    if n:
90                        temp = '-' + dizaineF[d]
91                    else:
92                        temp = dizaineF[d]
93
94                    # Ajout du cas particulier de 'et' entre la dizaine et 1
95
96                    if d < 8 and (u == 1 or u == 11):
97                        temp = temp + '-et'
98                else:
99                    if n:
100                        temp = '-' + dizaineB[d]
101                    else:
102                        temp = dizaineB[d]
103
104                    # Ajout du cas particulier de 'et' entre la dizaine et 1
105
106                    if u == 1:
107                        temp = temp + '-et'
108
109        # ajout du texte de l'unité
110
111            if u > 0 and (d or n):
112                temp = temp + '-' + unite[u]
113            elif u > 0:
114                temp = unite[u]
115
116        # ajout du 's' à Quatre-vingt si rien ne suit
117        # if (result == '') and (d == 8) and (u == 0) and France : result = 's'
118
119            if d == 8 and u == 0 and France:
120                temp = temp + 's'
121            result = temp + result
122
123
124            # Récupération de la centaine du bloc de trois chiffres en cours
125
126            c = n % 10
127            n = n // 10
128            if c > 0:
129                temp = ""
130                if c > 1 and n:
131                    temp = '-' + unite[c]
132                elif c > 1:
133                    temp = unite[c]
134                if c == 1 and not n:
135                    temp = coefs[0]
136                else:
137                    temp = temp + '-' + coefs[0]
138
139                # Traitement du cas particulier du 's' à cent si rien ne suit
140
141                if result == "" and c > 1:
142                    result = 's'
143                result = temp + result
144
145            # Traitement du prochain groupe de 3 chiffres
146
147            if n > 0:
148                coef = coef + 1
149                i = n % 1000
150                if i > 1 and coef > 1:
151                    result = 's' + result
152
153                # Traitement du cas particulier 'mille' ( non pas 'un mille' )
154
155                if i == 1 and coef == 1:
156                    n = n - 1
157                    result = coefs[coef] + result
158                elif i > 0:
159
160                    result = '-' + coefs[coef] + result
161    return result
162
163def nombreATrouver():
164    """a contient la liste des nombres à créer où il peut ne pas y avoir de
165    centaines, de centaines de milliers, d'unités ou de milliers"""
166
167    a = [random.randrange(100) + random.randrange(1000) * 10 ** 3,
168         random.randrange(1000) + random.randrange(100) * 10 ** 3,
169         random.randrange(1000) * 10 ** 3, random.randrange(1000)]
170    (lnb, liste) = ([], [])
171    for i in range(4):
172        lnb.append(random.randrange(1, 1000) * 10 ** 6 + a[i])
173    for i in range(4):
174        n = a[i]
175        if n % 1000:  # il y a des unités dans le nombre
176            e = random.randrange(1, 4)
177            lnb.append(n * 10 ** (-e))
178        else:
179            e = random.randrange(4, 7)
180            lnb.append(n * 10 ** (-e))
181    for i in range(8):
182        liste.append(lnb.pop(random.randrange(len(lnb))))
183    return liste
184
185def EcritNombreDecimal(n):
186    txt = ""
187    if n != int(n):
188        # n n'est pas un nombre entier
189        (e, d) = str(n).split('.')
190        (e, d) = (int(e), int(d))
191    else:
192        (e, d) = (int(n), 0)
193    if not d:
194        txt = NombreEnLettres(e)
195    elif e:
196        txt = NombreEnLettres(e)
197    if d:
198        partieDec = [u" dixième", u" centième", u" millième"]
199        if txt.rfind("un") == len(txt) - 2:
200
201        # le texte se finit par un. On l'accorde en genre avec unité
202
203            txt = txt + "e"
204        if e == 1:
205            txt = txt + u' unité et '
206        if e > 1:
207            txt = txt + u' unités et '
208        txt = txt + NombreEnLettres(d) + partieDec[len(str(n).split('.')[1]) - 
209                1]
210        if d > 1:
211            txt = txt + 's'
212    return txt
213
214def EcritEnChiffre(exo, cor):
215    lnb = nombreATrouver()
216    for i in range(len(lnb)):
217        exo.append("\\item " + EcritNombreDecimal(lnb[i]) + 
218                 " : \\dotfill")
219        cor.append("\\item " + EcritNombreDecimal(lnb[i]) + " : ")
220        cor.append(Affichage.decimaux(lnb[i], 0) + '')
221
222
223def EcritEnLettre(exo, cor):
224    lnb = nombreATrouver()
225    for i in range(8):
226        exo.append("\\item " + Affichage.decimaux(lnb[i], 0) + 
227                 " : \\dotfill")
228        cor.append("\\item " + Affichage.decimaux(lnb[i], 0) + 
229                " : ")
230        cor.append(EcritNombreDecimal(lnb[i]) + '')
231
232
233def EcrireNombreLettre():
234    exo = ["\\exercice", "\\begin{enumerate}",
235            u'\\item Écrire en chiffres les nombres suivants.',
236            '\\begin{enumerate}']
237    cor = ["\\exercice*", "\\begin{enumerate}",
238            u'\\item Écrire en chiffres les nombres suivants.',
239            '\\begin{enumerate}']
240
241    EcritEnChiffre(exo, cor)
242
243    exo.append('\\end{enumerate}')
244    exo.append(u'\\item Écrire en lettres les nombres suivants (sans utiliser le mot ``virgule").')
245    exo.append('\\begin{enumerate}')
246    cor.append('\\end{enumerate}')
247    cor.append(u'\\item Écrire en lettres les nombres suivants (sans utiliser le mot ``virgule").')
248    cor.append('\\begin{enumerate}')
249
250    EcritEnLettre(exo, cor)
251
252    exo.append('\\end{enumerate}')
253    exo.append('\\end{enumerate}')
254    cor.append('\\end{enumerate}')
255    cor.append('\\end{enumerate}')
256    return (exo, cor)
257
258EcrireNombreLettre.description = u'Écrire un nombre décimal'
259
260
261#===============================================================================
262# Conversions
263#===============================================================================
264
265units = ["L", "m", "g"]
266division = ["k", "h", "da", "", "d", "c", "m"]
267
268# paramétrage des flèches : mofifie le paramétrage par défaut de PSTricks  s'il n'est pas limité par un environnement ou {groupe}
269# # nodesepA = -1.5mm  : décale le départ de la flèche
270# # linewidth = 0.6pt  : épaisseur de la flèches
271# # linestyle = dotted : style pointillé
272# # vref = -0.8mm      : décale la flèche vers le bas, sous les chiffres
273PSSET_FLECHE = '\\psset{nodesepA = -1.5mm, linewidth = 0.6pt, linestyle = dotted, vref = -0.8mm}'
274
275
276def valeurs_units():
277    """
278    renvoie les valeurs pour les conversions d'unités
279    """
280
281    a = Arithmetique.valeur_alea(101, 999)
282    p = random.randrange(-2, 0)
283    unit = random.randrange(3)
284    if unit:
285        # mètres ou grammes, on peut utiliser les k
286        imax = 7
287    else:
288        # Litres, donc pas de kL
289        imax = 6
290
291    div0 = random.randrange(imax + p)
292
293    while 1:
294        div1 = random.randrange(imax)
295        if div0 != div1:
296            break
297
298    if not unit:  # Litres, donc pas de kL donc on décale d'un rang
299        div0, div1 = div0 + 1, div1 + 1
300
301    return (a, p, unit, div0, div1)
302        # 101< a <999 ex a = 245
303        # p = {-2,-1} donne 2,45 ou 24,5
304        # unit = {0, 1, 2} => {L, m, g}
305        # div0 unité 0
306        # div1 unité converti
307
308def tex_units():
309    """
310    Écrit l'exercice sur les conversions d'unités et le corrigé au format
311    LaTeX
312    @param exo: fichier exercices
313    @param cor: fichier corrige
314    """
315
316    exo = ["\\exercice", 'Effectuer les conversions suivantes :',
317            '\\begin{multicols}{3}\\noindent', '\\begin{enumerate}']
318    cor = ["\\exercice*",
319            # paramétrage des flèches, ce paramétrage est limité à l'exercice
320            # et ne modifie pas le paramétrage PSTricks du document car sa portée est limité par le groupe ouvert par "{"
321           "{",
322            PSSET_FLECHE,
323           'Effectuer les conversions suivantes :',
324            '\\begin{multicols}{2}\\noindent', '\\begin{enumerate}']
325
326    # Construit les 6 questions de l'exercice
327    for i in range(6):
328        (a, p, unit, div0, div1) = valeurs_units()
329        if unit:
330            u = tuple([units[unit] for i in range(7)])
331        else:
332            u = tuple([units[unit] for i in range(6)])
333        nb0 = Affichage.decimaux(a * 10 ** p, 0)
334        nb1 = Affichage.decimaux(a * 10 ** ((p + div1) - div0),
335                0)
336        exo.append("\\item %s~%s%s=\dotfill~%s%s" % (nb0, division[div0],
337                 units[unit], division[div1], units[unit]))
338        cor.append("\\item %s~%s%s=%s~%s%s\\par" % (nb0, division[div0],
339                 units[unit], nb1, division[div1], units[unit]))
340        nblist = [nb0[i] for i in range(len(nb0))]
341        if nblist.count(','):
342            chf_unite = nblist.index(',') - 1
343            nblist.pop(chf_unite + 1)
344        else:
345            chf_unite = len(nblist) - 1
346
347        tex_tableau(cor, div0, div1, u, nblist, chf_unite)
348
349        cor.append("\\end{tabular}")
350        cor.append("\\ncline{->}{virg0}{virg1}")
351
352    exo.append('\\end{enumerate}')
353    exo.append('\\end{multicols}')
354    cor.append('\\end{enumerate}')
355    cor.append('\\end{multicols}')
356    # ferme le groupe limitant la portée de PSSET_FLECHE
357    cor.append('{')
358    return (exo, cor)
359
360tex_units.description = u'Conversions unités'
361
362
363def tex_tableau(cor, div0, div1, u, nblist, chf_unite):
364    """tableau de conversion pour les unités simples : L, g ou m"""
365
366    # Si len(u) == 6, on a des Litres, on ne doit pas avoir la colonne kL
367    if len(u) == 6:
368        cor.append("\\begin{tabular}{c|c|c|c|c|c}")
369        cor.append("h%s & da%s & %s & d%s & c%s & m%s \\\\ \\hline" % u)
370        # décale d'une colonne pour supprimer kL
371        delta = 1
372        div0 = div0 - 1
373        div1 = div1 - 1
374
375    else:
376        cor.append("\\begin{tabular}{c|c|c|c|c|c|c}")
377        cor.append("k%s & h%s & da%s & %s & d%s & c%s & m%s \\\\ \\hline" % u)
378        # ne supprime pas le kg, km
379        delta = 0
380    for dummy in range(-div0 + chf_unite):
381        tmp = nblist.pop(0)
382        nblist[0] = tmp + nblist[0]
383
384    for dummy in range(div0 - chf_unite):
385        nblist.insert(0, '0')
386
387
388    for dummy in range(-len(u) + len(nblist)):
389        tmp = nblist.pop(7)
390        nblist[6] = nblist[6] + tmp
391
392    # les zéros à droites des chiffres significatifs
393    for dummy in range(len(u) - len(nblist)):
394        nblist.append('0')
395
396    # place les \nodes et la virgule dans le tableau
397    nblist[div0] = "%s\\Rnode{virg0}{\\ }" % (nblist[div0])
398    nblist[div1] = "{%s\\Rnode{virg1}{\\textcolor{red}{ \\LARGE ,}}}" % (nblist[div1])
399
400    # ajoute au tabular la ligne avec 6 ou 7 colonnes
401    cor.append(("%s " + ("& %s"*(6 - delta))) % tuple(nblist))
402
403
404
405def exo_conversion(exposant):
406    """construit l'exercice de conversion d'unité d'aire ou de volume
407    exposant 2 pour m²
408    exposant 3 pour m³"""
409
410    exo = ["\\exercice", 'Effectuer les conversions suivantes :',
411            '\\begin{multicols}{3}\\noindent', '\\begin{enumerate}']
412    cor = ["\\exercice*",
413            # la portée de \psset est par le group ouvert par "{"
414            "{",
415            PSSET_FLECHE,
416            '\\def\\virgule{\\textcolor{red}{ \\LARGE ,}}',
417            'Effectuer les conversions suivantes :',
418            '\\begin{multicols}{2}\\noindent', '\\begin{enumerate}']
419
420    # ajoute le ² ou ³ si nécessaire
421    str_exposant = (u"^%s" % (exposant)) * (exposant > 1)
422
423    u = tuple([division[i] + "m%s" % str_exposant for i in range(7)])
424    entete_tableau = ((" \\multicolumn{%s}{c|}" % exposant + "{$\\rm %s$} &") * 6 + "\\multicolumn{%s}{c}" % exposant + "{$\\rm %s$}") % u
425    ligne_tab = []
426
427    for i in range(6):
428        # imprime la correction et sauvegarde la ligne et la flèche pour le tableau imprimé ensuite
429        ligne_tab += tex_conversion(exo, cor, exposant, u) + ["\\ncline{->}{virg0}{virg1} \\\\"]
430
431    # ferme la correction et l'énoncé
432    cor.append('\\end{enumerate}')
433    cor.append('\\end{multicols}')
434    exo.append('\\end{enumerate}')
435    exo.append('\\end{multicols}')
436
437    # impression du tableau et des lignes sauvegardées précédemment
438    cor.append("\\begin{tabular}{*{%s}{p{3.5mm}|}p{3.5mm}}" % (exposant * 7 - 1))
439    cor.append(entete_tableau + "\\\\ \\hline")
440    # ajoute les lignes affichant les conversions
441    cor += ligne_tab
442    cor.append("\\end{tabular}")
443    # ferme le groupe dans lequel PSSET_FLECHE portait
444    cor.append("}")
445    # C'est fini
446    return (exo, cor)
447
448def exo_conversion_2d():
449    return exo_conversion(2)
450exo_conversion_2d.description = u"Conversions unités d'aires"
451
452def exo_conversion_3d():
453    return exo_conversion(3)
454exo_conversion_3d.description = u"Conversions unités de volumes"
455
456
457def tex_conversion(exo, cor, exposant, u):
458    """Écrit une question sur les conversions d'unités d'aires ou de volume
459    et le corrigé au format LaTeX
460    @param exo: fichier exercices
461    @param cor: fichier corrige
462    exposant = 2 ou 3 pour les aires ou les volumes
463    """
464
465    a = random.randint(101, 999)
466    p = random.randint(-2, -1)
467    while True:
468        (div0, div1) = (random.randrange(6), random.randrange(7),)
469        # Pas de mm³ par ce que ça sort du tableau
470        if (div0 - div1) in [-2, -1, 1, 2]:
471            # pas trop loin car ça fait de très longs nombres
472            break
473    nb0 = a * 10 ** p
474    nb1 = nb0 * 10 ** (exposant * (div1 - div0))
475
476    exo.append("\\item $\\unit[%s]{%s}=\\unit[\\dotfill]{%s}$" % 
477            (Affichage.decimaux(nb0), u[div0], u[div1]))
478    cor.append("\\item $\\unit[%s]{%s}=\\unit[%s]{%s}$\\vspace{1ex}\\par" % 
479            (Affichage.decimaux(nb0), u[div0],
480                Affichage.decimaux(nb1), u[div1]))
481
482    return tex_tableau_conversion(div0, div1, nb0, u, exposant)
483
484
485def tex_tableau_conversion(div0, div1, nb0, u, exposant):
486    nb_dict = nbre_to_dict(nb0, div0, div1, exposant)
487    nblist = [str(nb_dict.get(i, "")) for i in range(7 * exposant)]
488    nblist[exposant * (div0 + 1) - 1] = "%s\\Rnode{virg0}{\\ }" % nb_dict.get(exposant * (div0 + 1) - 1, "0")
489    nblist[exposant * (div1 + 1) - 1] = "{%s\\Rnode{virg1}{\\virgule}}" % nb_dict.get(exposant * (div1 + 1) - 1, "0")
490    return [("%s " + "& %s"*(7 * exposant - 1)) % tuple(nblist)]
491
492
493def nbre_to_dict(nbre , div0, div1, exposant):
494    # exposant peut être 2 ou 3 pour les m² ou les m³
495    nbre = int(round(nbre * 100))
496    nb_dict = {}
497    for i in range(min(exposant * (div0 + 1), exposant * (div1 + 1)) - 1, max(exposant * (div0 + 1), exposant * (div1 + 1))):
498            nb_dict[i] = "\\textcolor{red}{0}"
499    curseur = 1 + exposant * (div0 + 1)
500    while nbre % 10 == 0:
501        nbre = nbre / 10
502        curseur -= 1
503    while nbre > 0:
504        chiffre = nbre % 10
505        nbre = (nbre - chiffre) / 10
506        nb_dict[curseur] = "\\textcolor{blue}{%s}" % chiffre
507        curseur -= 1
508    return nb_dict
509
510
511#===============================================================================
512# Placer une virgule
513#===============================================================================
514
515valeurs = ["milliers", "centaines", "dizaines", u"unités",
516           u"dixièmes", u"centièmes", u"millièmes"]
517
518
519def valeurs_decimaux():
520    """
521    Choisit les valeurs
522    """
523
524    nb = 0
525    chiffres = [1, 2, 3, 4, 5, 6, 7, 8, 9]
526    for i in range(6):
527        nb = nb + chiffres.pop(random.randrange(len(chiffres))) * 10 ** \
528            i
529    return nb
530
531
532def tex_place_virgule(exo, cor):
533    """
534    Écrit un exercices demandant de placer une virgule dans un nombre.
535    @param exo: fichier exerices
536    @param cor:fichier corrigé
537    """
538
539    valeurs_index = [0, 1, 2, 3, 4, 5, 6]
540    nb = valeurs_decimaux()
541    exo.append(u"Placer une virgule (en ajoutant éventuellement des zéros) dans\
542            le nombre %s de telle sorte que :" % nb)
543    exo.append('\\begin{enumerate}')
544    cor.append(u"Placer une virgule (en ajoutant éventuellement des zéros) dans\
545            le nombre %s de telle sorte que :" % nb)
546    cor.append('\\begin{enumerate}')
547    for i in range(6):
548        dec = [str(nb)[i] for i in range(len(str(nb)))]
549        index_dec = random.randrange(6)
550        index_valeurs = valeurs_index.pop(random.randrange(len(valeurs_index)))
551        exo.append(u"\\item le chiffre %s soit le chiffre des %s : " \
552                 % (dec[index_dec], valeurs[index_valeurs]))
553        cor.append(u"\\item le chiffre %s soit le chiffre des %s : " \
554                 % (dec[index_dec], valeurs[index_valeurs]))
555        resultat = ecrit_nombre_decimal(dec, (index_dec + 4) - 
556                index_valeurs)
557        exo.append('\\dotfill')
558        cor.append(Affichage.decimaux(resultat, 0) + '')
559    exo.append('\\end{enumerate}')
560    cor.append('\\end{enumerate}')
561
562
563def ecrit_nombre_decimal(dec, index):
564    """
565    Renvoie une chaine de caractère représentant le nombre dec avec la
566    virgule à la place index.
567    Ajoute les zéros nécessaires.
568    @param dec: décomposition d'un nombre entier
569    @param index: place de la virgule dans la liste dec
570    """
571
572    if index < 1:
573        dec.insert(0, '0')
574        dec.insert(1, '.')
575        for i in range(-index):
576            dec.insert(2, '0')
577    elif index < len(dec):
578        dec.insert(index, '.')
579    else:
580        for i in range(index - len(dec)):
581            dec.append('0')
582    strnb = ""
583    for i in range(len(dec)):
584        strnb = strnb + dec[i]
585    return strnb
586
587
588def PlaceVirgule():
589    exo = ["\\exercice"]
590    cor = ["\\exercice*"]
591
592    tex_place_virgule(exo, cor)
593    return (exo, cor)
594
595PlaceVirgule.description = u'Placer une virgule'
596
597
598#===============================================================================
599#    Écriture fractionnaire
600#===============================================================================
601
602
603def valeurs_frac():
604    n1 = random.randrange(11, 10000)
605    p1 = random.randrange(1, 4)
606    return (n1, p1)
607
608
609def choix_trou_frac(exo, cor, n1, p1):
610    i = random.randrange(3)
611    p2 = random.randrange(2)  # sert à compliquer un peu l'exercice
612    if i > 1:
613        exo.append('\\item $\\cfrac{%s}{%s}=\\ldots$' % 
614                (Affichage.decimaux(n1 * 10 ** p2),
615                    Affichage.decimaux(10 ** (p1 + p2))))
616        cor.append('\\item $\\cfrac{%s}{%s}=\\mathbf{%s}$' % 
617                (Affichage.decimaux(n1 * 10 ** p2),
618                    Affichage.decimaux(10 ** (p1 + p2)),
619                    Affichage.decimaux(n1 * 10 ** (-p1), 1)))
620    elif i > 0:
621        exo.append('\\item $\\cfrac{%s}{\ldots}=%s$' % 
622                (Affichage.decimaux(n1 * 10 ** p2),
623        Affichage.decimaux(n1 * 10 ** (-p1), 1)))
624        cor.append('\\item $\\cfrac{%s}{\\mathbf{%s}}=%s$' % 
625                (Affichage.decimaux(n1 * 10 ** p2),
626        Affichage.decimaux(10 ** (p1 + p2)), \
627                Affichage.decimaux(n1 * 10 ** (-p1), 1)))
628    else:
629        exo.append('\\item $\\cfrac{\ldots}{%s}=%s$' % 
630                (Affichage.decimaux(10 ** (p1 + p2)),
631        Affichage.decimaux(n1 * 10 ** (-p1), 1)))
632        cor.append('\\item $\\cfrac{\\mathbf{%s}}{%s}=%s$' % 
633                (Affichage.decimaux(n1 * 10 ** p2),
634                    Affichage.decimaux(10 ** (p1 + p2)),
635                    Affichage.decimaux(n1 * 10 ** (-p1), 1)))
636
637def tex_frac(exo, cor):
638    for dummy in range(6):
639        (nombre, puissance) = valeurs_frac()
640        choix_trou_frac(exo, cor, nombre, puissance)
641
642
643def EcritureFractionnaire():
644    exo = ["\\exercice", u"Compléter :", '\\begin{multicols}{3}\\noindent',
645            '\\begin{enumerate}']
646    cor = ["\\exercice*", u"Compléter :", '\\begin{multicols}{3}\\noindent',
647            '\\begin{enumerate}']
648
649    tex_frac(exo, cor)
650
651    exo.append('\\end{enumerate}')
652    exo.append('\\end{multicols}')
653    cor.append('\\end{enumerate}')
654    cor.append('\\end{multicols}')
655    return (exo, cor)
656
657EcritureFractionnaire.description = u'Écriture fractionnaire ou décimale'
658
659
660#===============================================================================
661#    Décomposition des nombres décimaux
662#===============================================================================
663
664
665def valeurs_dec():
666    lpuissances = [3, 2, 1, 0, -1, -2, -3]
667    p = []
668    v = []
669    for dummy in range(3):
670        p.append(lpuissances.pop(random.randrange(len(lpuissances))))
671        v.append(random.randrange(1, 10))
672    return (v, p)
673
674
675def tex_decomposition(v, p):
676    exo, cor = [], []
677    for i in range(3):
678        if p[i] < 0:
679            exo.append('%s\\times \\cfrac{1}{%s}' % (v[i],
680                Affichage.decimaux(10 ** (-p[i]), 1)))
681            cor.append('%s\\times \\cfrac{1}{%s}' % (v[i],
682                Affichage.decimaux(10 ** (-p[i]), 1)))
683        else:
684            exo.append('%s\\times %s' % (v[i], Affichage.decimaux(10 ** 
685                     p[i], 1)))
686            cor.append('%s\\times %s' % (v[i], Affichage.decimaux(10 ** 
687                     p[i], 1)))
688        if i < 2:
689            exo.append('+')
690            cor.append('+')
691        else:
692            exo.append('=')
693            cor.append('=')
694    exo.append('\\dotfill$')
695    cor.append('%s$' % Affichage.decimaux(v[0] * 10 ** p[0] + 
696             v[1] * 10 ** p[1] + v[2] * 10 ** p[2], 1))
697    return " ".join(exo), " ".join(cor)
698
699
700def tex_dec(exo, cor):
701    for dummy in range(6):
702        txt = '\\item $'
703        (chiffres, puissances) = valeurs_dec()
704        txt_exo, txt_cor = tex_decomposition(chiffres, puissances)
705        exo.append(txt + txt_exo)
706        cor.append(txt + txt_cor)
707
708def Decomposition():
709    exo = ["\\exercice", u"Compléter avec un nombre décimal :",
710            '\\begin{multicols}{2}\\noindent', '\\begin{enumerate}']
711    cor = ["\\exercice*", u"Compléter avec un nombre décimal :",
712            '\\begin{multicols}{2}\\noindent', '\\begin{enumerate}']
713
714    tex_dec(exo, cor)
715
716    exo.append('\\end{enumerate}')
717    exo.append('\\end{multicols}')
718    cor.append('\\end{enumerate}')
719    cor.append('\\end{multicols}')
720    return (exo, cor)
721
722Decomposition.description = u'Décomposition de décimaux'
723
724
725#===============================================================================
726# Classer des nombres dans l'ordre
727#===============================================================================
728
729
730def choix_nombres():
731    nb = []
732    unite = random.randrange(10)
733    for i in range(3):
734        n = unite
735        for j in range(i + 1):
736            n = n + random.randrange(1, 10) * 10 ** (-(j + 1))
737        nb.append(n)
738    n = random.randrange(10) + random.randrange(10) / 10.0
739    while n == nb[0]:
740        n = random.randrange(10) + random.randrange(10) / 10.0
741    nb.append(n)
742    return nb
743
744
745def classer(exo, cor):
746    lnb = choix_nombres()
747    random.shuffle(lnb)
748    if random.randrange(2):
749        ordre = "croissant"
750    else:
751        ordre = u"décroissant"
752    exo.append("\\item Classer les nombres suivants dans l'ordre %s.\\par    " % 
753             ordre)
754    cor.append("\\item Classer les nombres suivants dans l'ordre %s.\\par    " % 
755             ordre)
756    phrase = ""
757    for i in range(len(lnb)):
758        if i:
759            phrase += " \\kern1cm ; \\kern1cm "
760        phrase += Affichage.decimaux(lnb[i], 0)
761    exo.append(phrase)
762    cor.append(phrase + "\\par")
763    lnb.sort()
764    if ordre == "croissant":
765        ordre = "\\textless"
766    else:
767        ordre = "\\textgreater"
768        lnb.reverse()
769    phrase = ""
770    for i in range(len(lnb)):
771        if i:
772            phrase += " \\kern1cm %s \\kern1cm " % ordre
773        phrase += Affichage.decimaux(lnb[i], 0)
774    cor.append(phrase)
775
776
777
778def ClasserNombres():
779    exo = ["\\exercice", '\\begin{enumerate}']
780    cor = ["\\exercice*", '\\begin{enumerate}']
781    classer(exo, cor)
782    classer(exo, cor)
783    exo.append('\\end{enumerate}')
784    cor.append('\\end{enumerate}')
785    return (exo, cor)
786
787ClasserNombres.description = u'Classer des nombres décimaux'
Note: See TracBrowser for help on using the repository browser.