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

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

add sources from pyromaths 15.10

File size: 25.5 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
25import math
26
27
28def nodesep(ligne):
29    """
30    Défini les valeurs nodesep : 0 pour une extrémité, -0.5 pour une continuité
31    @param ligne: droite, demi-droite, segment
32    @type ligne: string
33    """
34
35    if ligne == 'une droite':
36        retour = ['-6', '-6']
37    elif ligne == 'une demi-droite':
38        retour = ['0', '-6']
39    else:
40        retour = ['0', '0']
41    return retour
42
43
44def choix_points(n):
45    """
46    choisit n points parmi A, B, C, ..., Z
47    @param n: nombre de points à choisir
48    @type n: integer
49    """
50
51    points = [chr(i + 65) for i in range(26)]
52    liste = []
53    for i in range(n):
54        liste.append(points.pop(random.randrange(len(points))))
55    return liste
56
57
58def choix_ligne(n):
59    """
60    Retourne n propositions parmi droite, segment et demi-droite
61    @param n: nombre de propositions
62    @type n: interger
63    """
64
65    lignes = ['une droite', 'une demi-droite', 'un segment']
66    (liste_lignes, retour) = ([], [])
67    for dummy in range((n - 1) // len(lignes) + 1):
68        liste_lignes.extend(lignes)
69    for dummy in range(n):
70        retour.append(liste_lignes.pop(random.randrange(len(liste_lignes))))
71    return retour
72
73
74def symboles(ligne):
75    """
76    Retourne les couples (), [] ou [) correspondant au type de ligne
77    @param ligne: droite, demi-droite ou segment
78    @type ligne: string
79    """
80
81    if ligne == 'une droite':
82        retour = ['(', ')']
83    elif ligne == 'une demi-droite':
84        retour = ['[', ')']
85    else:
86        retour = ['[', ']']
87    return retour
88
89
90def prepare_tuple(lpoints, ligne):
91    """
92    Prepare deux tuples pour permettre l'affichage de la question et
93    de la solution
94    @param lpoints: les points de la figure
95    @type lpoints: liste de lettres
96    @param ligne: droite, demi-droite ou segment
97    @type ligne: string
98    """
99
100    (retour_exo, retour_sol) = ([], [])
101
102    # choix des deux points permettant de tracer la ligne :
103
104    templist = [i for i in range(len(lpoints))]
105    deuxpoints = []
106    for i in range(2):
107        deuxpoints.append(lpoints[templist.pop(random.randrange(len(templist)))])
108
109    # choix des symbole correspondant à la ligne :
110
111    lsymboles = symboles(ligne)
112    retour_sol.append(lsymboles[0])
113    retour_sol.extend(deuxpoints)
114    retour_sol.append(lsymboles[1])
115    retour_sol.append(ligne)
116
117    # choix des trous pour l'exercice :
118
119    alea = random.randrange(3)
120    if alea > 1:
121        retour_exo = ['\\ldots', '\\ldots', '\\ldots', '\\ldots',
122                      '\\dotfill']
123    elif alea > 0:
124        retour_exo = ['\\ldots']
125        retour_exo.extend(retour_sol[1:3])
126        retour_exo.extend(['\\ldots', retour_sol[4]])
127    else:
128        retour_exo = retour_sol[:4]
129        retour_exo.append('\\dotfill')
130    return (tuple(retour_exo), tuple(retour_sol))
131
132
133def tex_figure(liste, lpoints, points_coord, nodesep=0):
134    """
135    Écrit dans un fichier tex la construction de 3 points et éventuellement
136    une droite, une demi-droite ou un segment.
137    @param liste: liste d'exos ou corrigés
138    @type liste: liste
139    @param lpoints: liste de 3 points
140    @type lpoints: liste de 3 strings
141    @param nodesep: liste des dépassements pour pstricks
142    @type nodesep: liste de 2 strings
143    """
144    liste.append('\\begin{pspicture*}(-0.5,0.2)(4.5,2.2)')
145    liste.append('\\psset{PointSymbol=x}')
146    liste.append('\\pstGeonode[PosAngle=90](0.5,%s){%s}(2,%s){%s}(3.5,%s){%s}' % 
147               points_coord)
148    if nodesep:
149        liste.append('\\pstLineAB[nodesepA=%s, nodesepB=%s]{%s}{%s}' % 
150                   tuple(nodesep))
151    liste.append('\\end{pspicture*}\\tabularnewline')
152
153def coord_points(lpoints):
154    """Définit les ordonnées de trois points nommés dont les noms sont dans lpoints"""
155    ordonnees = [random.randrange(5, 16) / 10.for i in range(3)]
156    while abs(2 * ordonnees[1] - ordonnees[0] - ordonnees[2]) < .5:
157        ordonnees = [random.randrange(5, 16) / 10.for i in range(3)]
158    random.shuffle(ordonnees)
159    for i in range(3):
160        ordonnees.insert(2 * i + 1, lpoints[i])
161    return tuple(ordonnees)
162
163def tex_ligne_tableau(exo, cor, ligne):
164    """
165    Écrit une ligne de tableau dans un fichier tex
166    @param exo: fichier d'exercices
167    @type exo: file
168    @param cor: fichier de corrections
169    @type cor: file
170    @param ligne: droite, demi-droite ou segment
171    @type ligne: string
172    """
173
174    lpoints = choix_points(3)
175    (exer, solution) = prepare_tuple(lpoints, ligne)
176    exo.append('$%s %s%s %s$ est %s &' % 
177             exer)
178    cor.append('$%s %s%s %s$ est %s &' % 
179             solution)
180    lnodesep = nodesep(ligne)
181    lnodesep.extend(solution[1:3])
182    points_coord = coord_points(lpoints)
183    if exer != ('\\ldots', '\\ldots', '\\ldots', '\\ldots', '\\dotfill'):
184        tex_figure(exo, lpoints, points_coord)
185    else:
186        tex_figure(exo, lpoints, points_coord, lnodesep)
187    tex_figure(cor, lpoints, points_coord, lnodesep)
188    exo.append('\\hline')
189    cor.append('\\hline')
190
191
192def Droites():
193    """
194    Écrit les 5 lignes du tableau
195    @param exo: fichier d'exercices
196    @type exo: file
197    @param cor: fichier de corrections
198    @type cor: file
199    """
200    exo = ["\\exercice", u"Compléter les pointillés et les figures :\\par",
201            '\\renewcommand{\\tabularxcolumn}[1]{m{#1}}',
202            '\\begin{tabularx}{\\linewidth}{|X|>{\\centering}m{5cm}|}',
203            '\\hline',
204            u'\\textbf{phrase} & \\textbf{Figure} \\tabularnewline \\hline']
205    cor = ["\\exercice*", u"Compléter les pointillés et les figures :\\par",
206            '\\renewcommand{\\tabularxcolumn}[1]{m{#1}}',
207            '\\begin{tabularx}{\\linewidth}{|X|>{\\centering}m{5cm}|}',
208            '\\hline',
209            u'\\textbf{Phrase} & \\textbf{Figure} \\tabularnewline \\hline']
210
211    line = choix_ligne(5)
212    for i in range(5):
213        tex_ligne_tableau(exo, cor, line[i])
214
215    exo.append('\\end{tabularx}')
216    cor.append('\\end{tabularx}')
217    return (exo, cor)
218
219Droites.description = u'Droites, demi-droites, segments'
220
221
222#------------------------------------------------------------------------------
223# Parallèles et perpendiculaires
224#------------------------------------------------------------------------------
225# perp à (ac) passant par b => val2=('a', 'c', 'a', 'c', 'b', 'b', 'b', 'a'
226# para à (ab) passant apr d => val2=('a', 'b', 'a', 'b', 'd', 'd')
227
228
229def fig_perp(points, coor, solution=0, per=[], par=[]):
230    val_enonce = (
231        points[0], points[1], coor[0], coor[1], coor[2], coor[3],
232        points[2], points[3], coor[4], coor[5], coor[6], coor[7],)
233    pts = ('a', 'b', 'c', 'd')
234    text = \
235        """  \\begin{pspicture*}(-4,-4)(4,4)
236    \psset{PointSymbol=x}
237    \pstGeonode[PointName={%s,%s}](%s;%s){a}(%s;%s){b}
238    \pstGeonode[PointName={%s,%s}](%s; %s){c}(%s; %s){d}""" % \
239        val_enonce
240    if solution:
241        val_soluce = (
242            pts[per[0]], pts[per[1]], pts[per[0]], pts[per[1]],
243            pts[per[2]], pts[per[2]], pts[per[2]], pts[per[0]],
244            pts[par[0]], pts[par[1]], pts[par[0]], pts[par[1]],
245            pts[par[2]], pts[par[2]])
246
247        text = text + \
248            """    \pstLineAB[nodesep=-4, linecolor=DarkBlue]{%s}{%s}
249    \pstProjection[PointName=none]{%s}{%s}{%s}[e]\pstLineAB[nodesep=-7, linecolor=DarkBlue]{%s}{e}
250    \pstRightAngle[, linecolor=DarkBlue]{%s}{e}{%s}
251    \pstLineAB[nodesep=-4, linecolor=DarkRed]{%s}{%s}
252    \pstTranslation[PointName=none,PointSymbol=none]{%s}{%s}{%s}[f]
253    \pstLineAB[nodesep=-7, linecolor=DarkRed]{%s}{f}
254  \end{pspicture*}""" % \
255            val_soluce
256    return text
257
258
259def noms_sommets(nb):  # renvoie nb noms de sommets
260    (listenb, listepts) = ([], [])
261    for i in range(26):
262        listenb.append(i + 65)
263    for i in range(nb):
264        listepts.append(chr(listenb.pop(random.randrange(26 - i))))
265    listepts.sort()
266    return tuple(listepts)
267
268
269def cree_coordonnees(longueur=3):
270    from math import floor
271    alpha = random.randrange(180)
272    k0 = random.randrange(50, 100) / 100.0
273    a0 = alpha + random.randrange(30, 120)
274    k1 = random.randrange(50, 100) / 100.0
275    a1 = alpha + random.randrange(210, 300)
276    return (longueur,alpha, longueur, alpha + 180, floor((k0* 10) * longueur) / 
277            10.0, a0, floor((k1 * 10) * longueur) / 10.0, a1)
278
279
280def enonce_perp(exo, cor):
281    coor = cree_coordonnees(3)
282    noms = noms_sommets(4)
283    par, per = [], []
284    lval = [0, 1, 2, 3]
285    for dummy in range(3):
286        par.append(lval.pop(random.randrange(len(lval))))
287    while per == [] or (par[0], par[1]) == (per[0], per[1]) or \
288            (par[0], par[1]) == (per[1], per[0]) :
289        lval = [0, 1, 2, 3]
290        per = []
291        for dummy in range(3):
292            per.append(lval.pop(random.randrange(len(lval))))
293    exo.append(fig_perp(noms, coor))
294    cor.append(fig_perp(noms, coor, 1, per, par))
295    exo.append('\end{pspicture*}\\par\n\\begin{enumerate}')
296    cor.append('\\par\n\\begin{enumerate}')
297    s_per = u"\\item Tracer la droite perpendiculaire à la droite $(%s%s)$ passant par $%s$"
298    s_par = u"\\item Tracer la droite parallèle à la droite $(%s%s)$ passant par $%s$"
299    s_per = s_per % (noms[per[0]], noms[per[1]], noms[per[2]])
300    s_par = s_par % (noms[par[0]], noms[par[1]], noms[par[2]])
301    if random.randrange(2):
302        exo.append(s_par)
303        cor.append(s_par)
304        exo.append(s_per)
305        cor.append(s_per)
306    else:
307        exo.append(s_per)
308        cor.append(s_per)
309        exo.append(s_par)
310        cor.append(s_par)
311    exo.append('\\end{enumerate}')
312    cor.append('\\end{enumerate}')
313
314
315def Perpendiculaires():
316    exo = ["\\exercice", u"Réaliser les figures suivantes :\\par", '\\begin{multicols}{2}']
317    cor = ["\\exercice*", u"Réaliser les figures suivantes :\\par", '\\begin{multicols}{2}']
318
319    enonce_perp(exo, cor)
320
321    exo.append('\\columnbreak')
322    cor.append('\\columnbreak')
323
324    enonce_perp(exo, cor)
325
326    exo.append('\\end{multicols}')
327    cor.append('\\end{multicols}')
328    return (exo, cor)
329
330Perpendiculaires.description = u'Droites perpendiculaires et parallèles'
331
332
333#------------------------------------------------------------------------------
334# Propriétés
335#------------------------------------------------------------------------------
336
337
338def fonction(angle, xa, ya, dist=0, droite='par'):
339    """
340    Retourne une fonction à utiliser avec psplot
341    @param angle: compris entre 1 et 89° ou 91 et 179°. Angle entre la droite et l'axe des abscisses
342    @type angle:
343    @param xa: abscisse d'un point de la droite
344    @type xa:
345    @param ya: ordonnée d'un point de la droite
346    @type ya:
347    @param dist: distance entre l'origine et la droite
348    @type dist:
349    @param droite: 'par' pour une parallèle et 'per' pour une perpendiculaire
350    """
351
352    angle_rad = (angle * math.pi) / 180
353    if droite == 'par':
354        coef = math.floor(math.tan(angle_rad) * 1000) / 1000.0
355        ord_or = math.floor(((ya - xa * math.tan(angle_rad)) - dist / 
356                            math.cos(angle_rad)) * 1000) / 1000.0
357        return '{x %s mul %s add}' % (coef, ord_or)
358    else:
359        coef = math.floor(-1000 / math.tan(angle_rad)) / 1000.0
360        return '{x %s mul}' % coef
361
362
363def PointInter(angle, xa, ya, dist=0):
364    angle_rad = (angle * math.pi) / 180
365    coef1 = math.floor(math.tan(angle_rad) * 1000) / 1000.0
366    ord_or1 = math.floor(((ya - xa * math.tan(angle_rad)) - dist / math.cos(angle_rad)) * 
367                         1000) / 1000.0
368    coef2 = math.floor(-1000 / math.tan(angle_rad)) / 1000.0
369    x = ord_or1 / (coef2 - coef1)
370    y = x * coef2
371    return ',PosAngle=%s](%s,%s)' % (45 + angle, math.floor(x * 1000) / 
372            1000.0, math.floor(y * 1000) / 1000.0)
373
374
375def Points(angle, xa, ya, dist=0):
376    angle_rad = (angle * math.pi) / 180
377    coef = math.floor(math.tan(angle_rad) * 1000) / 1000.0
378    ord_or = math.floor(((ya - xa * math.tan(angle_rad)) - dist / math.cos(angle_rad)) * 
379                        1000) / 1000.0
380    lpos = []
381    if -1.5 < -2 * coef + ord_or < 1.5:
382        x = -1.5
383        y = math.floor((x * coef + ord_or) * 1000) / 1000.0
384        lpos.append('(%s,%s)' % (x, y))
385    if -1.5 < 2 * coef + ord_or < 1.5:
386        x = 1.5
387        y = math.floor((x * coef + ord_or) * 1000) / 1000.0
388        lpos.append('(%s,%s)' % (x, y))
389    if -2.1 < (1.5 - ya + dist / math.cos(angle_rad) + xa * math.tan(angle_rad)) / \
390        math.tan(angle_rad) < 2.1:
391        y = 1.1
392        x = math.floor(((y - ya + dist / math.cos(angle_rad) + xa * math.tan(angle_rad)) / 
393                       math.tan(angle_rad)) * 1000) / 1000.0
394        lpos.append('(%s,%s)' % (x, y))
395    if -2.1 < (-1.5 - ya + dist / math.cos(angle_rad) + xa * math.tan(angle_rad)) / \
396        math.tan(angle_rad) < 2.1:
397        y = -1.1
398        x = math.floor(((y - ya + dist / math.cos(angle_rad) + xa * math.tan(angle_rad)) / 
399                       math.tan(angle_rad)) * 1000) / 1000.0
400        lpos.append('(%s,%s)' % (x, y))
401    return lpos
402
403
404def figure(angle, xa, ya, dist, lpoints, noms, par_per, dist2=0):
405    """
406
407    @param angle:
408    @param xa:
409    @param ya:
410    @param dist:
411    @param lpoints:
412    @param noms: 1: nomme la droite (AB)
413                 2: nomme la droite (d1)
414    @param par_per: 1: parallèles + perpendiculaires
415                    2: 3 parallèles
416                    3: 2 perpendiculaires
417    """
418
419    ltxt = []
420    ltxt.append('\\begin{pspicture*}[shift=-1.5](-2.1,-1.6)(2.1,1.6)')
421    ltxt.append('\\footnotesize')
422    if par_per < 3:
423        ltxt.append('\\psplot[linewidth=1.5\\pslinewidth]{-2.1}{2.1}%s' % 
424                    fonction(angle, xa, ya))
425        ltxt.append('\\psplot[linewidth=1.5\\pslinewidth]{-2.1}{2.1}%s' % 
426                    fonction(angle, xa, ya, dist))
427    else:
428        ltxt.append('\\psplot{-2.1}{2.1}%s' % fonction(angle, xa, ya))
429        ltxt.append('\\psplot{-2.1}{2.1}%s' % fonction(angle, xa, ya,
430                    dist))
431    if par_per == 2:
432        ltxt.append('\\psplot[linewidth=1.5\\pslinewidth]{-2.1}{2.1}%s' % 
433                    fonction(angle, xa, ya, dist2))
434    else:
435        ltxt.append('\\psplot{-2.1}{2.1}%s' % fonction(angle, xa, ya,
436                    droite='per'))
437    if noms:  # nomme les droites par deux points
438        if par_per != 2:  # 2 points d'intersection
439            ltxt.append('\\pstGeonode[PointSymbol={none,x},PointName={%s,%s} %s{i1}%s{a1}' % 
440                        (lpoints[0], lpoints[1], PointInter(angle, xa,
441                        ya), Points(angle, xa, ya)[0]))
442            ltxt.append('\\pstGeonode[PointSymbol={none,x},PointName={%s,%s} %s{i2}%s{b1}' % 
443                        (lpoints[2], lpoints[3], PointInter(angle, xa,
444                        ya, dist), Points(angle, xa, ya, dist)[0]))
445            ltxt.append('\\pstGeonode[PointSymbol=none,PointName=none]%s{c1}%s{c2}' % 
446                        (Points(angle + 90, 0, 0)[0], Points(angle + 90,
447                        0, 0)[1]))
448        else:
449
450                # pas de point d'intersection
451
452            pts = Points(angle, xa, ya)
453            ltxt.append('\\pstGeonode[PointSymbol=x,PosAngle=%s,PointName={%s,%s}]%s{a1}%s{a2}' % 
454                        (angle + 45, lpoints[0], lpoints[1], pts[0], pts[1]))
455            pts = Points(angle, xa, ya, dist)
456            ltxt.append('\\pstGeonode[PointSymbol=x,PosAngle=%s,PointName={%s,%s}]%s{b1}%s{b2}' % 
457                        (angle - (45.0 * dist) / abs(dist), lpoints[2],
458                        lpoints[3], pts[0], pts[1]))
459            pts = Points(angle, xa, ya, dist2)
460            ltxt.append('\\pstGeonode[PointSymbol=x,PosAngle=%s,PointName={%s,%s}]%s{c1}%s{c2}' % 
461                        (angle - (45.0 * dist2) / abs(dist2), lpoints[4],
462                        lpoints[5], pts[0], pts[1]))
463    else:
464
465        # nomme les droites (d_1), ...
466
467        if par_per != 2:  # 2 points d'intersection
468            ltxt.append('\\pstGeonode[PointSymbol=none,PointName={none,%s} %s{i1}%s{a1}' % 
469                        (lpoints[0], PointInter(angle, xa, ya), Points(angle,
470                        xa, ya)[0]))
471            ltxt.append('\\pstGeonode[PointSymbol=none,PointName={none,%s} %s{i2}%s{b1}' % 
472                        (lpoints[1], PointInter(angle, xa, ya, dist),
473                        Points(angle, xa, ya, dist)[0]))
474            ltxt.append('\\pstGeonode[PointSymbol=none,PointName={none,%s}]%s{c1}%s{c2}' % 
475                        (lpoints[2], Points(angle + 90, 0, 0)[0], Points(angle + 
476                        90, 0, 0)[1]))
477        else:
478            pts = Points(angle, xa, ya)
479            ltxt.append('\\pstGeonode[PointSymbol=none,PosAngle=%s,PointName={%s,none}]%s{a1}%s{a2}' % 
480                        (angle + 45, lpoints[0], pts[0], pts[1]))
481            pts = Points(angle, xa, ya, dist)
482            ltxt.append('\\pstGeonode[PointSymbol=none,PosAngle=%s,PointName={%s,none}]%s{b1}%s{b2}' % 
483                        (angle - (45.0 * dist) / abs(dist), lpoints[1],
484                        pts[0], pts[1]))
485                        # FIXME list index out of range
486            pts = Points(angle, xa, ya, dist2)
487            ltxt.append('\\pstGeonode[PointSymbol=none,PosAngle=%s,PointName={%s,none}]%s{c1}%s{c2}' % 
488                        (angle - (45.0 * dist2) / abs(dist2), lpoints[2],
489                        pts[0], pts[1]))
490    if par_per != 2:
491        if angle < 90:
492            ltxt.append('\\pstRightAngle[RightAngleSize=.2]{c1}{i1}{a1}')
493        else:
494            ltxt.append('\\pstRightAngle[RightAngleSize=.2]{c2}{i1}{a1}')
495    if par_per == 3:
496        if angle < 90:
497            ltxt.append('\\pstRightAngle[RightAngleSize=.2]{c1}{i2}{b1}')
498        else:
499            ltxt.append('\\pstRightAngle[RightAngleSize=.2]{c2}{i2}{b1}')
500    ltxt.append('\\end{pspicture*}')
501    return ltxt
502
503
504def valeurs_figures(par_per):
505    noms = random.randrange(2)
506    if noms:
507        lpoints = noms_sommets(6)
508    else:
509        lindices = [1, 2, 3]
510        lpoints = []
511        for dummy in range(3):
512            lpoints.append('(d_%s)' % lindices.pop(random.randrange(len(lindices))))
513    angle = random.randrange(1, 90) + 90 * random.randrange(2)
514    xa = random.randrange(-5, 5) / 10.0
515    ya = random.randrange(-3, 3) / 10.0
516    if random.randrange(2):
517        dist = random.randrange(4, 9) / 10.0
518    else:
519        dist = -random.randrange(4, 9) / 10.0
520    if par_per == 2:
521        if dist > 0:
522            dist2 = -random.randrange(4, 9) / 10.0
523        else:
524            dist2 = random.randrange(4, 9) / 10.0
525        return (angle, xa, ya, dist, lpoints, noms, dist2)
526    else:
527        return (angle, xa, ya, dist, lpoints, noms)
528
529
530def enonce_prop(exo, cor):
531    exo.append('\\renewcommand{\\tabularxcolumn}[1]{m{#1}}')
532    exo.append('\\begin{tabularx}{\\textwidth}[t]{|m{3cm}|m{4cm}|X|m{3cm}|}')
533    exo.append('\\hline')
534    exo.append(u'\\multicolumn{1}{|c|}{\\bf Données} & \\multicolumn{1}{|c|}{\\bf Figure codée}')
535    exo.append(u'& \\multicolumn{1}{|c|}{\\bf Propriété} & \\multicolumn{1}{|c|}{\\bf Conclusion}\\\\')
536    cor.append('\\renewcommand{\\tabularxcolumn}[1]{m{#1}}')
537    cor.append('\\begin{tabularx}{\\textwidth}[t]{|m{3cm}|m{4cm}|X|m{3cm}|}')
538    cor.append('\\hline')
539    cor.append(u'\\multicolumn{1}{|c|}{\\bf Données} & \\multicolumn{1}{|c|}{\\bf Figure codée}')
540    cor.append(u'& \\multicolumn{1}{|c|}{\\bf Propriété} & \\multicolumn{1}{|c|}{\\bf Conclusion}\\\\')
541    ltypes = [1, 2, 3]
542    lexos = []
543    for i in range(3):
544        lexos.append(ltypes.pop(random.randrange(len(ltypes))))
545    for i in range(3):
546        exo.append('\\hline')
547        cor.append('\\hline')
548        v = valeurs_figures(lexos[i])
549        if lexos[i] == 2:
550            if v[5]:  # noms de la forme (AB), on ajoute des parenthèses
551                exo.append('''$(%s%s)//(%s%s)$\\par et\\par $(%s%s)//(%s%s)$ &
552\\begin{pspicture*}[shift=-1.5](-2.1,-1.6)(2.1,1.6)
553\\end{pspicture*}
554& & \\\\''' % 
555                         (v[4][0], v[4][1], v[4][2], v[4][3], v[4][0], v[4][1],
556                         v[4][4], v[4][5]))
557                cor.append('$(%s%s)//(%s%s)$\\par et\\par $(%s%s)//(%s%s)$ & ' % 
558                         (v[4][0], v[4][1], v[4][2], v[4][3], v[4][0], v[4][1],
559                         v[4][4], v[4][5]))
560            else:
561                exo.append('''$%s//%s$\\par et\\par $%s//%s$ &
562\\begin{pspicture*}[shift=-1.5](-2.1,-1.6)(2.1,1.6)
563\\end{pspicture*}
564& & \\\\''' % 
565                         (v[4][0], v[4][1], v[4][0], v[4][2]))
566                cor.append('$%s//%s$\\par et\\par $%s//%s$ & ' % (v[4][0],
567                         v[4][1], v[4][0], v[4][2]))
568            cor.append('%s & ' % ('\n').join(figure(v[0], v[1], v[2],
569                     v[3], v[4], v[5], lexos[i], v[6])))  # eror out of range in figure
570            cor.append(u'Si deux droites sont parallèles, alors toute parallèle à l\'une est parallèle à l\'autre. &')
571            if v[5]:
572                cor.append('$(%s%s)//(%s%s)$ \\\\\n  \\hline' % (v[4][2],
573                         v[4][3], v[4][4], v[4][5]))
574            else:
575                cor.append('$%s//%s$ \\\\\n  \\hline' % (v[4][1], v[4][2]))
576        else:
577
578            fig = random.randrange(2)
579            if lexos[i] == 1:
580                if v[5]:
581                    if not fig:
582                        exo.append('''$(%s%s)//(%s%s)$\\par et\\par $(%s%s)\\perp(%s%s)$ &
583\\begin{pspicture*}[shift=-1.5](-2.1,-1.6)(2.1,1.6)
584\\end{pspicture*}
585& & \\\\''' % 
586                                 (v[4][0], v[4][1], v[4][2], v[4][3], v[4][0],
587                                 v[4][1], v[4][0], v[4][2]))
588                    cor.append('$(%s%s)//(%s%s)$\\par et\\par $(%s%s)\\perp(%s%s)$ &' % 
589                             (v[4][0], v[4][1], v[4][2], v[4][3], v[4][0],
590                             v[4][1], v[4][0], v[4][2]))
591                else:
592                    if not fig:
593                        exo.append('''$%s//%s$\\par et\\par $%s\perp%s$ &
594\\begin{pspicture*}[shift=-1.5](-2.1,-1.6)(2.1,1.6)
595\\end{pspicture*}
596& & \\\\''' % 
597                                 (v[4][0], v[4][1], v[4][0], v[4][2]))
598                    cor.append('$%s//%s$\\par et\\par $%s\perp%s$ &' % 
599                             (v[4][0], v[4][1], v[4][0], v[4][2]))
600                if fig:
601                    exo.append('& %s & & \\\\' % ('\n').join(figure(v[0],
602                             v[1], v[2], v[3], v[4], v[5], lexos[i])))
603                cor.append('%s & ' % ('\n').join(figure(v[0], v[1], v[2],
604                         v[3], v[4], v[5], lexos[i])))
605                cor.append(u'Si deux droites sont parallèles, alors toute perpendiculaire à l\'une est perpendiculaire à l\'autre. &')
606                if v[5]:
607                    cor.append('$(%s%s)\\perp(%s%s)$ \\\\\n  \\hline' % 
608                             (v[4][2], v[4][3], v[4][0], v[4][2]))
609                else:
610                    cor.append('$%s\perp%s$ \\\\\n  \\hline' % (v[4][1],
611                             v[4][2]))
612            else:
613                if v[5]:
614                    if not fig:
615                        exo.append('''$(%s%s)\\perp(%s%s)$\\par et\\par $(%s%s)\\perp(%s%s)$ &
616\\begin{pspicture*}[shift=-1.5](-2.1,-1.6)(2.1,1.6)
617\\end{pspicture*}
618& & \\\\''' % 
619                                 (v[4][0], v[4][1], v[4][0], v[4][2], v[4][2],
620                                 v[4][3], v[4][0], v[4][2]))
621                    cor.append('$(%s%s)\\perp(%s%s)$\\par et\\par $(%s%s)\\perp(%s%s)$ &' % 
622                             (v[4][0], v[4][1], v[4][0], v[4][2], v[4][2],
623                             v[4][3], v[4][0], v[4][2]))
624                else:
625                    if not fig:
626                        exo.append('''$%s\\perp%s$\\par et\\par $%s\perp%s$ &
627\\begin{pspicture*}[shift=-1.5](-2.1,-1.6)(2.1,1.6)
628\\end{pspicture*}
629& & \\\\''' % 
630                                 (v[4][0], v[4][2], v[4][1], v[4][2]))
631                    cor.append('$%s\\perp%s$\\par et\\par $%s\perp%s$ &' % 
632                             (v[4][0], v[4][2], v[4][1], v[4][2]))
633                if fig:
634                    exo.append('& %s & & \\\\' % ('\n').join(figure(v[0],
635                             v[1], v[2], v[3], v[4], v[5], lexos[i])))
636                cor.append('%s &' % ('\n').join(figure(v[0], v[1], v[2],
637                         v[3], v[4], v[5], lexos[i])))
638                cor.append(u'Si deux droites sont perpendiculaires à une même troisième alors elles sont parallèles entre elles. &')
639                if v[5]:
640                    cor.append('$(%s%s)//(%s%s)$ \\\\\n  \\hline' % (v[4][0],
641                             v[4][1], v[4][2], v[4][3]))
642                else:
643                    cor.append('$%s//%s$ \\\\\n  \\hline' % (v[4][0],
644                             v[4][1]))
645    exo.append('''\\hline
646\\end{tabularx}
647''')
648    cor.append('\\end{tabularx}')
649
650
651def Proprietes():
652    exo = ["\\exercice", u"Compléter le tableau suivant :\\par Les droites en gras sont parallèles.\\par """]
653    cor = ["\\exercice*", u"Compléter le tableau suivant :\\par Les droites en gras sont parallèles.\\par """]
654
655    enonce_prop(exo, cor)
656    return (exo, cor)
657
658Proprietes.description = u'Propriétés sur les droites'
Note: See TracBrowser for help on using the repository browser.