source: pyromaths/trunk/fuentes/src/pyromaths/ex/lycee/SecondDegre.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: 26.3 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#
23from pyromaths import ex
24from math import sqrt
25from random import shuffle, randrange
26from pyromaths.outils import Priorites3
27from pyromaths.classes.Fractions import Fraction
28from pyromaths.classes.PolynomesCollege import Polynome, factoriser
29from pyromaths.classes.SquareRoot import SquareRoot
30from pyromaths.outils.Arithmetique import carrerise, pgcd, valeur_alea
31
32def creerPolydegre2(nb_racines=2, rac_radical=True, rac_quotient=False):
33    if nb_racines == 2:
34        redo = True
35        while redo:
36            a = randrange(1, 4) * (-1) ** randrange(2)
37            alpha = randrange(1, 10) * (-1) ** randrange(2)
38            beta = randrange(1, 10)
39            gamma = [1, randrange(1, 6)][rac_radical]
40            if rac_quotient:
41                den = randrange(2, 6)
42                while pgcd(alpha, den) != 1 or pgcd(beta, den) != 1:
43                    den = randrange(2, 6)
44                alpha = Fraction(alpha, den)
45                beta = Fraction(beta, den)
46            b = -2 * alpha * a
47            c = a * (alpha ** 2 - gamma * beta ** 2)
48            if abs(c) <= 10 and c != 0 and not factoriser(repr(Polynome([[a, 2], [b, 1], [c, 0]]))): redo = False
49            if c.denominator != 1:
50                c = 'Fraction(%s, %s)' % (c.numerator, c.denominator)
51            else:
52                c = c.numerator
53            if b.denominator != 1:
54                b = 'Fraction(%s, %s)' % (b.numerator, b.denominator)
55            else:
56                b = b.numerator
57        return Polynome([[a, 2], [b, 1], [c, 0]])
58    elif nb_racines == 1:
59        a, b = valeur_alea(-9, 9), valeur_alea(-9, 9)
60        return Polynome([[a ** 2, 2], [2 * a * b, 1], [b ** 2, 0]])
61    else:
62        pol = [[valeur_alea(-9, 9), 2 - dummy] for dummy in range(3)]
63        while pol[1][0] ** 2 - 4 * pol[0][0] * pol[2][0] >= 0:
64            pol = [[valeur_alea(-9, 9), 2 - dummy] for dummy in range(3)]
65        return Polynome(pol)
66
67class Sd1FormeCanonique(ex.TexExercise):
68
69    description = _(u'Forme canonique')
70    level = _(u"1.1èreS")
71
72    def __init__(self):
73        m = [[1, 2], [2 * randrange(1, 10) * (-1) ** randrange(2), 1], [randrange(1, 10) * (-1) ** randrange(2), 0]]
74        pol = [[['Polynome(%s, "x", details=0)' % m]]]
75        pol[0].extend(self.resolution(m))
76        m = [[1, 2], [(2 * randrange(1, 6) + 1) * (-1) ** randrange(2), 1], [randrange(1, 10) * (-1) ** randrange(2), 0]]
77        pol.append([['Polynome(%s, "x", details=0)' % m]])
78        pol[1].extend(self.resolution(m))
79        a, b = randrange(1, 10), randrange(1, 10)
80        m = [[a ** 2, 2], [2 * a * b * (-1) ** randrange(2), 1], [b ** 2, 0]]
81        pol.append([['Polynome(%s, "x", details=0)' % m]])
82        if m[1][0] < 0: pol[2].extend(self.id_rem(a, b, '-'))
83        else: pol[2].extend(self.id_rem(a, b, '+'))
84        m = [[randrange(2, 6) * (-1) ** randrange(2), 2], [randrange(1, 10) * (-1) ** randrange(2), 1], [randrange(1, 10) * (-1) ** randrange(2), 0]]
85        pol.append([['Polynome(%s, "x", details=0)' % m]])
86        fracb = Fraction(m[1][0], m[0][0]).simplifie()
87#        if fracb.d == 1: fracb = fracb.n
88        fracc = Fraction(m[2][0], m[0][0]).simplifie()
89#        if fracc.d == 1: fracc = fracc.n
90        pol[3].append(['%s' % m[0][0], '*', '(', 'Polynome(%s, "x", details=0)' % [[1, 2], [fracb, 1], [fracc, 0]], ')'])
91        pol[3].extend(self.resolution([[1, 2], [fracb, 1], [fracc, 0]], ['%s' % m[0][0], '*', '('], [')']))
92        shuffle(pol)
93        self.exercice = pol
94
95    def resolution(self, m, pre=[], post=[]):
96        sgn = '+-'[m[1][0] < 0]
97        if isinstance(m[1][0], Fraction):
98            b = Priorites3.priorites(abs(m[1][0]) / 2)[-1][0]
99        elif m[1][0] % 2:
100            b = 'Fraction(%s, 2)' % abs(m[1][0])
101        else:
102            b = abs(m[1][0]) / 2
103        fc = ['Polynome("%sx%s%s")' % (m[0][0], sgn, b), '**', '2']
104        reste = ['-']
105        if m[2][0] > 0 or isinstance(m[2][0], Fraction):
106            reste.extend(Priorites3.splitting('%s**2+%r' % (b, m[2][0])))
107        else:
108            reste.extend(Priorites3.splitting('%s**2%r' % (b, m[2][0])))
109        etapes = list(pre)
110        etapes.extend(fc)
111        etapes.extend(reste)
112        etapes.extend(post)
113        etapes = [etapes]
114        for unreste in Priorites3.priorites(''.join(reste)):
115            calcul = list(pre)
116            calcul.extend(fc)
117            if unreste[0][0] != '-':
118                calcul.append('+')
119            else:
120                calcul.append('-')
121                unreste[0] = unreste[0][1:]
122            calcul.extend(unreste)
123            calcul.extend(post)
124            etapes.append(calcul)
125        if isinstance(b, str):  # On supprime deux étapes trop détaillée UGLY
126            # TODO: Corriger la classe Fractions pour qu'elle gère plusieurs niveaux de détails.
127            etapes.pop(1)
128            etapes.pop(1)
129        if pre:
130            calcul = pre[0:-1]
131            calcul.extend(fc)
132            fc = list(calcul)
133            reste = Priorites3.priorites(''.join(reste))[-1]
134            reste.extend(['*', pre[0]])
135            for unreste in Priorites3.priorites(''.join(reste)):
136                calcul = list(fc)
137                if unreste[0][0] != '-':
138                    calcul.append('+')
139                else:
140                    calcul.append('-')
141                    unreste[0] = unreste[0][1:]
142                calcul.extend(unreste)
143                etapes.append(calcul)
144        return etapes
145
146    def id_rem(self, a, b, sgn):
147        etapes = [['Polynome("%sx%s%s")' % (a, sgn, b), '**', '2']]
148        if a != 1:
149            etapes.append(['(', '%s' % a, '*', 'Polynome("x%sFraction(%s, %s)")' % (sgn, b, a), ')', '**', '2' ])
150            frac = Fraction(b, a).simplifie()
151            etapes.append(['%s' % (a ** 2), '*', 'Polynome("x%s%r")' % (sgn, frac), '**', '2'])
152        return etapes
153
154    def tex_statement(self):
155        exo = [r'\exercice']
156        exo.append(_(u'Donner la forme canonique des polynômes $P$ , $Q$ , $R$ et $S$ .'))
157        exo.append(r'\begin{align*}')
158        noms = [r'P\,(x) &= ', r'Q\,(x) &= ', r'R\,(x) &= ', r'S\,(x) &= ']
159        exercice = list(self.exercice)
160        sol = ''
161        for i in range(len(exercice)):
162            exercice[i][0] = Priorites3.texify(exercice[i][0])
163            sol += noms[i] + exercice[i][0][0]
164            if i < len(exercice) - 1: sol += r' & '
165            else: sol += r' \\ '
166        exo.append(sol)
167        exo.append(r'\end{align*}')
168        return exo
169
170    def tex_answer(self):
171        exo = [r'\exercice*']
172        exo.append(_(u'Donner la forme canonique des polynômes $P$ , $Q$ , $R$ et $S$ .'))
173        noms = [r'P\,(x) &= ', r'Q\,(x) &= ', r'R\,(x) &= ', r'S\,(x) &= ']
174        exercice = list(self.exercice)
175        for i in range(len(exercice)):
176            exercice[i] = Priorites3.texify(exercice[i])
177            exercice[i][0] = noms[i] + exercice[i][0]  # [0]
178            for j in range(1, len(exercice[i]) - 1):
179                exercice[i][j] = r' &= ' + exercice[i][j]
180            exercice[i][-1] = r'\Aboxed{' + noms[i] + exercice[i][-1] + r'}'
181        tri = []
182        for i in range(len(exercice)):
183            tri.append((i, len(exercice[i])))
184        tri = sorted(tri, key=lambda nblgn: nblgn[1])
185        if tri[0][0] < tri[1][0]:
186            exercice[tri[0][0]].extend(exercice.pop(tri[1][0]))
187        else:
188            exercice[tri[1][0]].extend(exercice.pop(tri[0][0]))
189        exo.append(r'\begin{align*}')
190        for j in range(max(len(exercice[0]), len(exercice[1]), len(exercice[2]))):
191            sol = ''
192            for i in range(3):
193                if j < len(exercice[i]):
194                    sol += exercice[i][j]
195                else:
196                    sol += r'& '
197                if i == 2:
198                    sol += r'\\'
199                else:
200                    sol += r' & '
201            exo.append(sol)
202        exo.append(r'\end{align*}')
203        return exo
204
205class Sd2aRacines(ex.TexExercise):
206    description = _(u'Racines d\'un polynôme de degré 2')
207    level = _(u"1.1èreS")
208    def __init__(self):
209        pol = [creerPolydegre2(nb_racines=2, rac_radical=True, rac_quotient=False)]
210        pol.append(creerPolydegre2(nb_racines=1))
211        a, b = valeur_alea(-9, 9), valeur_alea(-9, 9)
212        pol.append([[a ** 2, 2], [-b ** 2, 0]])
213        a, b = valeur_alea(-9, 9), valeur_alea(-9, 9)
214        while a * b == -64:
215            # sqrt{8} est trop long à décomposer en une demi-ligne
216            a, b = valeur_alea(-9, 9), valeur_alea(-9, 9)
217        pol.append([[a, 2], [b, 0]])
218        a, b = valeur_alea(-9, 9), valeur_alea(-9, 9)
219        pol.append([[a, 2], [b, 1]])
220        pol.pop(randrange(1, len(pol)))
221        pol.pop(randrange(1, len(pol)))
222        shuffle(pol)
223        for i in range(3):
224            m = list(pol[i])
225            shuffle(m)
226            pol[i] = m
227        self.exercice = pol
228
229    def tex_statement(self):
230        exo = [r'\exercice']
231        exo.append(_(u'Déterminer les racines des polynômes :'))
232        exo.append('\\begin{align*}')
233        noms = [r'P\,(x) &= ', r'Q\,(x) &= ', r'R\,(x) &= ']
234        r = ''
235        for i in range(3):
236            r += noms[i] + str(Polynome(self.exercice[i], 'x'))
237            if i < 2: r += ' & '
238        exo.append(r)
239        exo.append('\\end{align*}')
240        return exo
241
242    def tex_answer(self):
243        exo = [r'\exercice*']
244        exo.append(_(u'Déterminer les racines des polynômes :\\par'))
245        noms = [r'P\,(x) &= ', r'Q\,(x) &= ', r'R\,(x) &= ']
246        r = ''
247        question = [[], [], []]
248        for i in range(3):
249            p = []
250            m = Polynome(list(self.exercice[i])).ordonne()
251            if factoriser('%r' % Polynome(m)):
252                p = [factoriser('%r' % Polynome(m))]
253                while factoriser(p[-1]):
254                    p.append(factoriser(p[-1]))
255            if p and eval(Priorites3.splitting(p[-1])[0]).degre() > 0:
256                tmp = Priorites3.texify([Priorites3.splitting(p[j]) for j in range(len(p))])
257                question[i].append('{$\\! \\begin{aligned}')
258                question[i].append(noms[i] + str(Polynome(m, 'x')) + r'\\')
259                question[i].append('\\\\\n'.join(['&=%s' % (tmp[j]) for j in range(len(tmp))]))
260                question[i].append(r'\end{aligned}$}\par')
261                lp = Priorites3.splitting(p[-1])
262                racines = []
263                for e in lp:
264                    if e[:9] == 'Polynome(':
265                        e = eval(e)
266                        if len(e) == 2:
267                            racines.append(str(Fraction(-e[1][0], e[0][0]).simplifie()))
268                        else:
269                            racines.append('0')
270                if len(racines) > 1:
271                    question[i].append(_(u'\\underline{Les racines de $%s$ sont }\\fbox{$%s$}') % (noms[i].rstrip(r' &= '), '$}\\underline{ et }\\fbox{$'.join(racines)))
272                elif len(racines) == 1:
273                    question[i].append(_(u'\\underline{L\'unique racine de $%s$ est }\\fbox{$%s$}') % (noms[i].rstrip(r' &= '), racines[0]))
274            elif len(m) == 2 and m[0][1] == 2 and m[1][1] == 0 and m[0][0] * m[1][0] > 0:
275                question[i].append('$' + noms[i] + str(Polynome(m, 'x')) + r'$\par')
276                question[i][-1] = question[i][-1].replace('&', '')
277                if m[1][0] > 0: question[i].append('$' + noms[i][:7] + ' \\ge %r$' % m[1][0])
278                else: question[i].append('$' + noms[i][:7] + ' \\le %r$' % m[1][0])
279                question[i].append(_(u'car un carré est toujours positif.\\par\n\\underline{$%s$ n\'a donc pas de racine.}') % (noms[i].rstrip(r' &= ')))
280            else:
281                question[i].append('$' + noms[i] + str(Polynome(m, 'x')) + r'\quad$')
282                question[i][-1] = question[i][-1].replace('&', '')
283                question[i].append(_(u'On calcule le discriminant de $%s$ avec $a=%s$, $b=%s$ et $c=%s$ :\\par\\medskip') % (noms[i].rstrip(r' &= '), m[0][0], m[1][0], m[2][0]))
284                question[i].append(r'\begin{tabularx}{\linewidth}[t]{XXX}')
285                question[i].append(r'{$\! \begin{aligned}')
286                sol = [[str(m[1][0]), '**', '2', '-', '4', '*', str(m[0][0]), '*', str(m[2][0])]]
287                sol.extend(Priorites3.priorites('%s**2-4*%s*%s' % (m[1][0], m[0][0], m[2][0])))
288                solTeX = Priorites3.texify(sol)
289                for s in solTeX:
290                    question[i].append(u'\\Delta &= %s\\\\' % s)
291                question[i].append(r'\end{aligned}$}')
292                question[i].append(r'&')
293                question[i].append(r'{$\! \begin{aligned}')
294                delta = sol[-1][0]
295                sol = [['Fraction(SquareRoot([[%s, None], [-1, %s]]),\'2*%s\')' % (-m[1][0], delta, m[0][0])]]
296                sol.extend(Priorites3.priorites(sol[0][0]))
297                sol = Priorites3.texify(sol)
298                for s in sol:
299                    question[i].append(u'x_1 &= %s\\\\' % s)
300                racines = [sol[-1]]
301                question[i].append(r'\end{aligned}$}')
302                question[i].append(r'&')
303                question[i].append(r'{$\! \begin{aligned}')
304                sol = [['Fraction(SquareRoot([[%s, None], [1, %s]]),\'2*%s\')' % (-m[1][0], delta, m[0][0])]]
305                sol.extend(Priorites3.priorites(sol[0][0]))
306                sol = Priorites3.texify(sol)
307                for s in sol:
308                    question[i].append(u'x_2 &= %s\\\\' % s)
309                racines.append(sol[-1])
310                question[i].append(r'\end{aligned}$}')
311                question[i].append(r'\end{tabularx}\par')
312                question[i].append(_(u'\\underline{Les racines de $%s$ sont }\\fbox{$%s$}') % (noms[i].rstrip(r' &= '), _('$}\\underline{ et }\\fbox{$').join(racines)))
313                if i == 1: question.append(question[1])
314        if len(question) == 4:
315            question.pop(1)
316        if question[0][0][-6:] == r'\quad$':
317            question[1].insert(0, r'\par\medskip\begin{tabularx}{\linewidth}[t]{XX}')
318            question[2].insert(0, r'&')
319            question[2].append(r'\end{tabularx}\par\medskip')
320        else:
321            question[0].insert(0, r'\begin{tabularx}{\linewidth}[t]{XX}')
322            question[1].insert(0, r'&')
323            question[1].append(r'\end{tabularx}\par\medskip')
324        for i in range(3): exo.extend(question[i])
325        return exo
326
327class Sd2bEquations(ex.TexExercise):
328    # description = u'Équations et polynômes de degré 2'
329    level = _(u"1.1èreS")
330    def __init__(self):
331        pol = [creerPolydegre2(nb_racines=2, rac_radical=False, rac_quotient=False)]
332        pol.append(creerPolydegre2(nb_racines=1))
333        a, b = valeur_alea(-9, 9), valeur_alea(-9, 9)
334        pol.append([[a ** 2, 2], [-b ** 2, 0]])
335        a, b = valeur_alea(-9, 9), valeur_alea(-9, 9)
336        pol.append([[a, 2], [b, 1]])
337        a, b = valeur_alea(-9, 9), valeur_alea(-9, 9)
338        pol.append([[a, 2], [b, 0]])
339        pol.pop(randrange(1, len(pol)))
340        pol.pop(randrange(1, len(pol)))
341        pol.pop(randrange(1, len(pol)))
342        shuffle(pol)
343        exercice = [pol]
344        lval = [[[randrange(2, 10) * (-1) ** randrange(2), 1], [randrange(2, 10) * (-1) ** randrange(2), 0]] for dummy in range(3)]
345        a, b, c = -lval[2][0][0] * lval[1][0][0], lval[0][0][0] - lval[2][0][0] * lval[1][1][0] - lval[2][1][0] * lval[1][0][0], lval[0][1][0] - lval[2][1][0] * lval[1][1][0]
346        delta = b ** 2 - 4 * a * c
347        while delta < 0 or carrerise(delta) != 1:
348            lval = [[[randrange(2, 10) * (-1) ** randrange(2), 1], [randrange(2, 10) * (-1) ** randrange(2), 0]] for dummy in range(3)]
349            a, b, c = -lval[2][0][0] * lval[1][0][0], lval[0][0][0] - lval[2][0][0] * lval[1][1][0] - lval[2][1][0] * lval[1][0][0], lval[0][1][0] - lval[2][1][0] * lval[1][1][0]
350            delta = b ** 2 - 4 * a * c
351        # print delta, Polynome([[a, 2], [b, 1], [c, 0]]), '\cfrac{%s}{%s}' % (-b - sqrt(delta), 2 * a), '\cfrac{%s}{%s}' % (-b + sqrt(delta), 2 * a)
352        exercice.append(lval)
353        shuffle(exercice)
354        self.exercice = exercice
355
356    def tex_statement(self):
357        exo = [r'\exercice']
358        exo.append(_(u'Résoudre les équations :'))
359        exo.append('\\begin{align*}')
360        for e in self.exercice:
361            if len(e) == 2:
362                exo.append(Priorites3.texify([[repr(Polynome(e[0])), '*', repr(Polynome(e[1]))]])[0] + ' &= 0 & ')
363            else:
364                exo.append(r'\cfrac{%s}{%s} &= %s & ' % (Polynome(e[0]), Polynome(e[1]), Polynome(e[2])))
365        exo[-1] = exo[-1][:-3]  # Suppression du dernier  " &"
366        exo.append('\\end{align*}')
367        return exo
368
369class Sd3aSigne(ex.TexExercise):
370    # description = u'Signe d\'un polynôme de degré 2'
371    level = _(u"1.1èreS")
372    def __init__(self):
373        pol = [[valeur_alea(-9, 9), 2 - dummy] for dummy in range(3)]
374        while pol[1][0] ** 2 - 4 * pol[0][0] * pol[2][0] >= 0:
375            pol = [[valeur_alea(-9, 9), 2 - dummy] for dummy in range(3)]
376        exercice = [list(pol)]
377
378        val = [valeur_alea(-9, 9), valeur_alea(-9, 9)]
379        val.append(Fraction(valeur_alea(-9, 9), val[0]))
380        while val[2].d == 1:
381            val = [valeur_alea(-9, 9), valeur_alea(-9, 9)]
382            val.append(Fraction(valeur_alea(-9, 9), val[0]))
383        sgn = -val[0] / abs(val[0])
384        pol = [[val[0], 2], [(-val[0] * (val[1] * val[2].d + val[2].n)) / val[2].d, 1], [(val[0] * val[1] * val[2].n) / val[2].d, 0]]
385        shuffle(pol)
386        exercice.append([pol, val[1], val[2]])
387
388        val = [sgn * valeur_alea(-9, 9), valeur_alea(-9, 9)]
389        val.append(Fraction(valeur_alea(-9, 9), val[0]).simplifie())
390        while isinstance(val[2], int) or val[2].d == 1:
391            val = [sgn * valeur_alea(-9, 9), valeur_alea(-9, 9)]
392            val.append(Fraction(valeur_alea(-9, 9), val[0]))
393        pol = [[val[0], 2], [(-val[0] * (val[1] * val[2].d + val[2].n)) / val[2].d, 1], [(val[0] * val[1] * val[2].n) / val[2].d, 0]]
394        shuffle(pol)
395        exercice.append([pol, val[1], val[2]])
396
397        self.exercice = exercice
398
399    def tex_statement(self):
400        exo = [r'\exercice']
401        exo.append(r'\begin{enumerate}')
402        exo.append(_(u'\\item Déterminer le signe du polynôme $P\\,(x) = %s$') % Polynome(self.exercice[0]))
403        exo.append(_(u'\\item Le polynôme $Q\\,(x) = %s$ admet deux racines $%s$ et $%s\\,$. Dresser son tableau de signes.') \
404            % (Polynome(self.exercice[1][0]), self.exercice[1][1], self.exercice[1][2]))
405        exo.append(_(u'\\item Le polynôme $R\\,(x) = %s$ admet deux racines $%s$ et $%s\\,$. Dresser son tableau de signes.') \
406            % (Polynome(self.exercice[2][0]), self.exercice[2][1], self.exercice[2][2]))
407        exo.append('\\end{enumerate}')
408        return exo
409
410class Sd3bInequations(ex.TexExercise):
411    # description = u'Inéquations et polynômes de degré 2'
412    level = _(u"1.1èreS")
413    def __init__(self):
414        pol = creerPolydegre2(nb_racines=2, rac_radical=False, rac_quotient=False).monomes
415        pol2 = [[valeur_alea(-9, 9), 1], [valeur_alea(-9, 9), 0]]
416        shuffle(pol)
417        shuffle(pol2)
418        p = [pol, pol2]
419        shuffle(p)
420        p.append(['<', '>', '\\le', '\\ge'][randrange(4)])
421        self.exercice = p
422
423    def tex_statement(self):
424        exo = [r'\exercice']
425        exo.append(_(u'Résoudre l\'inéquation : $\qquad \\cfrac{%s}{%s} %s 0$') % (Polynome(self.exercice[0]),
426                                                                                  Polynome(self.exercice[1]),
427                                                                                  self.exercice[2]))
428        return exo
429
430class Sd4Factorisation(ex.TexExercise):
431    # description = u'Racines et factorisation d\'un polynôme de degré 2'
432    level = _(u"1.1èreS")
433    def __init__(self):
434        val = [valeur_alea(-9, 9), valeur_alea(-9, 9)]
435        val.append(Fraction(valeur_alea(-9, 9), val[0]))
436        while val[2].d == 1:
437            val = [valeur_alea(-9, 9), valeur_alea(-9, 9)]
438            val.append(Fraction(valeur_alea(-9, 9), val[0]))
439
440        pol = [[val[0], 2], [(-val[0] * (val[1] * val[2].d + val[2].n)) / val[2].d, 1], [(val[0] * val[1] * val[2].n) / val[2].d, 0]]
441        shuffle(pol)
442        exercice = [[list(pol), val[1], val[2]]]
443
444        pol = [creerPolydegre2(nb_racines=0).monomes]
445        pol.append(creerPolydegre2(nb_racines=1).monomes)
446        a, b = valeur_alea(-9, 9), valeur_alea(-9, 9)
447        sgn = [1, -1][randrange(2)]
448        pol.append([[sgn * a ** 2, 2], [-sgn * b ** 2, 0]])
449        a, b = valeur_alea(-9, 9), valeur_alea(-9, 9)
450        pol.append([[a, 2], [b, 1]])
451        a, b = valeur_alea(-9, 9), valeur_alea(-9, 9)
452        while abs(pgcd(a, b)) != 1:
453            a, b = valeur_alea(-9, 9), valeur_alea(-9, 9)
454        pol.append([[a, 2], [b, 0]])
455        pol.pop(randrange(1, len(pol)))
456        pol.pop(randrange(1, len(pol)))
457        pol.pop(randrange(1, len(pol)))
458        shuffle(pol)
459        exercice.append(pol)
460
461        self.exercice = exercice
462
463    def tex_statement(self):
464        exo = [r'\exercice']
465        exo.append(r'\begin{enumerate}')
466        exo.append(_(u'\\item Le polynôme $\\quad P\\,(x) = %s \\quad$ admet deux racines $%s$ et $%s\\,$. Donner sa forme factorisée.\n') \
467            % (Polynome(self.exercice[0][0]), self.exercice[0][1], self.exercice[0][2]))
468        exo.append(_(u'\\item Factoriser si possible les polynômes $\quad Q\\,(x) = %s\\quad$ et $\\quad R\\,(x) = %s$.\n') % (Polynome(self.exercice[1][0]), Polynome(self.exercice[1][1])))
469        exo.append(r'\end{enumerate}')
470
471        return exo
472
473class Sd5Caracteristiques(ex.TexExercise):
474    # description = u'Caractéristiques d\'une parabole'
475    level = _(u"1.1èreS")
476    def __init__(self):
477        val = [valeur_alea(-9, 9), valeur_alea(-9, 9) , valeur_alea(-9, 9)]
478        pol = Polynome([[val[0], 2], [(-val[0] * (val[1] + val[2])), 1], [(val[0] * val[1] * val[2]), 0]])
479        while val[2] == val[1] or abs(val[0] * val[1] * val[2]) > 10 or abs(eval(pol((val[1] + val[2]) / 2.))) > 10:
480            val = [valeur_alea(-9, 9), valeur_alea(-9, 9) , valeur_alea(-9, 9)]
481            pol = Polynome([[val[0], 2], [(-val[0] * (val[1] + val[2])), 1], [(val[0] * val[1] * val[2]), 0]])
482        val = [[val[0], 2], [(-val[0] * (val[1] + val[2])), 1], [(val[0] * val[1] * val[2]), 0]]
483        shuffle(val)
484        lp = [Polynome(val)]
485
486        val = [[valeur_alea(-9, 9), 2 - dummy] for dummy in range(3)]
487        val[1][0] = valeur_alea(-9, 9) * val[0][0]
488        pol = Polynome(val)
489        while val[1][0] ** 2 - 4 * val[0][0] * val[2][0] >= 0 or abs(eval(pol(-val[1][0] / 2. / val[0][0]))) > 10:
490            val = [[valeur_alea(-9, 9), 2 - dummy] for dummy in range(3)]
491            val[1][0] = valeur_alea(-9, 9) * val[0][0]
492            pol = Polynome(val)
493        shuffle(val)
494        pol = Polynome(val)
495        lp.append(pol)
496        shuffle(lp)
497
498        self.exercice = lp
499
500    def tex_statement(self):
501        exo = [r'\exercice']
502        exo.append(_(u'On donne les polynômes $\\quad p\\,(x) = %s \\quad$ et $\\quad Q\\,(x) = %s$.') % (self.exercice[0], self.exercice[1]))
503        exo.append(r'\begin{enumerate}')
504        exo.append(_(u'\\item Donner les caractéristiques de leurs courbes respectives (sommet, intersections avec les axes du repère).'))
505        exo.append(_(u'\\item Tracer l’allure de ces deux courbes sur un même graphique.'))
506        exo.append(r'\end{enumerate}')
507
508        return exo
509
510class Sd6Parametre(ex.TexExercise):
511    # description = u'Polynôme paramétré de degré 2'
512    level = _(u"1.1èreS")
513    def __init__(self):
514        [a, b, c, d] = [randrange(-5, 6) for dummy in range(4)]
515        while a == 0 or c == 0 or a ** 2 * d - a * b * c + c ** 2 < 0 or carrerise(a ** 2 * d - a * b * c + c ** 2) != 1:
516            [a, b, c, d] = [randrange(-5, 6) for dummy in range(4)]
517        p1 = str(Polynome([[a, 1], [b, 0]], "m"))
518        p2 = str(Polynome([[c, 1], [d, 0]], "m"))
519        pol = [Polynome([[1, 2], [p1, 1], [p2, 0]]), randrange(3)]
520        exercice = [list(pol)]
521
522        v = [randrange(-4, 5) for dummy in range(6)]
523        while v[0] == 0 or v[2] == v[4] == 0 or reduce(lambda x, y: x * y, v) != 0 or v[2] == v[3] == 0 or v[4] == v[5] == 0:
524            v = [randrange(-4, 5) for dummy in range(6)]
525        lp = [str(Polynome([[v[2 * i] / pgcd(v[2 * i], v[2 * i + 1]), 1], [v[2 * i + 1] / pgcd(v[2 * i], v[2 * i + 1]), 0]], "a")) for i in range(3)]
526        pol = Polynome([[lp[0], 2], [lp[1], 1], [lp[2], 0]])
527        vi = Fraction(-v[1], v[0])
528        racine = randrange(-4, 5)
529        while racine == vi or racine == 0:
530            racine = randrange(-4, 5)
531        if vi.d == 1 : vi = str(vi.n)
532        else: vi = str(vi)
533        exercice.append([list(pol), vi, racine])
534        self.exercice = exercice
535
536    def tex_statement(self):
537        exo = [r'\exercice']
538        exo.append(r'\begin{enumerate}')
539        exo.append(_(u'\\item On donne le polynôme $\\quad P\\,(x) = %s\\quad$ où $m$ est un réel.\\par') % self.exercice[0][0])
540        # TODO: Affichage des paramètres et parenthèses
541        exo.append(_(u'Quelles sont les valeurs de $m$ pour lesquelles $P$ %s ?\n') % [_('a une seule racine'), _('n\'a pas de racine'),
542                _('a deux racines distinctes')][self.exercice[0][1]])
543        # exo.append(u'\\par Solution : Polynôme en m : $%s$\\par\n' % (Polynome([[a ** 2, 2], [2 * a * b - 4 * c, 1], [b ** 2 - 4 * d, 0]], "m"))
544        # exo.append( u'Solution : discriminant $\\Delta_m = %s$\\par\n' % (16 * (a ** 2 * d - a * b * c + c ** 2))
545        exo.append(_(u'\\item Soit $a$ un réel différent de $%s$. On donne $Q\\,(x) = %s$.\\par\n') % (self.exercice[1][1], Polynome(self.exercice[1][0])))
546        exo.append(_(u'Déterminer $a$ pour que $%s$ soit une racine de $Q$.\n') % self.exercice[1][2])
547        exo.append(r'\end{enumerate}')
548
549        return exo
Note: See TracBrowser for help on using the repository browser.