| 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 | from pyromaths import ex |
|---|
| 24 | from math import sqrt |
|---|
| 25 | from random import shuffle, randrange |
|---|
| 26 | from pyromaths.outils import Priorites3 |
|---|
| 27 | from pyromaths.classes.Fractions import Fraction |
|---|
| 28 | from pyromaths.classes.PolynomesCollege import Polynome, factoriser |
|---|
| 29 | from pyromaths.classes.SquareRoot import SquareRoot |
|---|
| 30 | from pyromaths.outils.Arithmetique import carrerise, pgcd, valeur_alea |
|---|
| 31 | |
|---|
| 32 | def 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 | |
|---|
| 67 | class 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 | |
|---|
| 205 | class 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 | |
|---|
| 327 | class 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 | |
|---|
| 369 | class 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 | |
|---|
| 410 | class 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 | |
|---|
| 430 | class 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 | |
|---|
| 473 | class 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 | |
|---|
| 510 | class 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 | _(u'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 |
|---|
