def creerPolydegre2(nb_racines=2, rac_radical=True, rac_quotient=False):
if nb_racines == 2:
redo = True
while redo:
a = randrange(1, 4) * (-1) ** randrange(2)
alpha = randrange(1, 10) * (-1) ** randrange(2)
beta = randrange(1, 10)
gamma = [1, randrange(1, 6)][rac_radical]
if rac_quotient:
den = randrange(2, 6)
while pgcd(alpha, den) != 1 or pgcd(beta, den) != 1:
den = randrange(2, 6)
alpha = Fraction(alpha, den)
beta = Fraction(beta, den)
b = -2 * alpha * a
c = a * (alpha ** 2 - gamma * beta ** 2)
if abs(c) <= 10 and c != 0 and not factoriser(repr(Polynome([[a, 2], [b, 1], [c, 0]]))): redo = False
if c.denominator != 1:
c = 'Fraction(%s, %s)' % (c.numerator, c.denominator)
else:
c = c.numerator
if b.denominator != 1:
b = 'Fraction(%s, %s)' % (b.numerator, b.denominator)
else:
b = b.numerator
return Polynome([[a, 2], [b, 1], [c, 0]])
elif nb_racines == 1:
a, b = valeur_alea(-9, 9), valeur_alea(-9, 9)
return Polynome([[a ** 2, 2], [2 * a * b, 1], [b ** 2, 0]])
else:
pol = [[valeur_alea(-9, 9), 2 - dummy] for dummy in range(3)]
while pol[1][0] ** 2 - 4 * pol[0][0] * pol[2][0] >= 0:
pol = [[valeur_alea(-9, 9), 2 - dummy] for dummy in range(3)]
return Polynome(pol)
def __init__(self):
val = [valeur_alea(-9, 9), valeur_alea(-9, 9)]
val.append(Fraction(valeur_alea(-9, 9), val[0]))
while val[2].d == 1:
val = [valeur_alea(-9, 9), valeur_alea(-9, 9)]
val.append(Fraction(valeur_alea(-9, 9), val[0]))
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]]
shuffle(pol)
exercice = [[list(pol), val[1], val[2]]]
pol = [creerPolydegre2(nb_racines=0).monomes]
pol.append(creerPolydegre2(nb_racines=1).monomes)
a, b = valeur_alea(-9, 9), valeur_alea(-9, 9)
sgn = [1, -1][randrange(2)]
pol.append([[sgn * a ** 2, 2], [-sgn * b ** 2, 0]])
a, b = valeur_alea(-9, 9), valeur_alea(-9, 9)
pol.append([[a, 2], [b, 1]])
a, b = valeur_alea(-9, 9), valeur_alea(-9, 9)
while abs(pgcd(a, b)) != 1:
a, b = valeur_alea(-9, 9), valeur_alea(-9, 9)
pol.append([[a, 2], [b, 0]])
pol.pop(randrange(1, len(pol)))
pol.pop(randrange(1, len(pol)))
pol.pop(randrange(1, len(pol)))
shuffle(pol)
exercice.append(pol)
self.exercice = exercice
def __init__(self):
pol = [[valeur_alea(-9, 9), 2 - dummy] for dummy in range(3)]
while pol[1][0] ** 2 - 4 * pol[0][0] * pol[2][0] >= 0:
pol = [[valeur_alea(-9, 9), 2 - dummy] for dummy in range(3)]
exercice = [list(pol)]
val = [valeur_alea(-9, 9), valeur_alea(-9, 9)]
val.append(Fraction(valeur_alea(-9, 9), val[0]))
while val[2].d == 1:
val = [valeur_alea(-9, 9), valeur_alea(-9, 9)]
val.append(Fraction(valeur_alea(-9, 9), val[0]))
sgn = -val[0] / abs(val[0])
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]]
shuffle(pol)
exercice.append([pol, val[1], val[2]])
val = [sgn * valeur_alea(-9, 9), valeur_alea(-9, 9)]
val.append(Fraction(valeur_alea(-9, 9), val[0]).simplifie())
while isinstance(val[2], int) or val[2].d == 1:
val = [sgn * valeur_alea(-9, 9), valeur_alea(-9, 9)]
val.append(Fraction(valeur_alea(-9, 9), val[0]))
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]]
shuffle(pol)
exercice.append([pol, val[1], val[2]])
self.exercice = exercice
def id_rem(self, a, b, sgn):
etapes = [['Polynome("%sx%s%s")' % (a, sgn, b), '**', '2']]
if a != 1:
etapes.append(['(', '%s' % a, '*', 'Polynome("x%sFraction(%s, %s)")' % (sgn, b, a), ')', '**', '2' ])
frac = Fraction(b, a).simplifie()
etapes.append(['%s' % (a ** 2), '*', 'Polynome("x%s%r")' % (sgn, frac), '**', '2'])
return etapes
def __init__(self):
m = [[1, 2], [2 * randrange(1, 10) * (-1) ** randrange(2), 1], [randrange(1, 10) * (-1) ** randrange(2), 0]]
pol = [[['Polynome(%s, "x", details=0)' % m]]]
pol[0].extend(self.resolution(m))
m = [[1, 2], [(2 * randrange(1, 6) + 1) * (-1) ** randrange(2), 1], [randrange(1, 10) * (-1) ** randrange(2), 0]]
pol.append([['Polynome(%s, "x", details=0)' % m]])
pol[1].extend(self.resolution(m))
a, b = randrange(1, 10), randrange(1, 10)
m = [[a ** 2, 2], [2 * a * b * (-1) ** randrange(2), 1], [b ** 2, 0]]
pol.append([['Polynome(%s, "x", details=0)' % m]])
if m[1][0] < 0: pol[2].extend(self.id_rem(a, b, '-'))
else: pol[2].extend(self.id_rem(a, b, '+'))
m = [[randrange(2, 6) * (-1) ** randrange(2), 2], [randrange(1, 10) * (-1) ** randrange(2), 1], [randrange(1, 10) * (-1) ** randrange(2), 0]]
pol.append([['Polynome(%s, "x", details=0)' % m]])
fracb = Fraction(m[1][0], m[0][0]).simplifie()
# if fracb.d == 1: fracb = fracb.n
fracc = Fraction(m[2][0], m[0][0]).simplifie()
# if fracc.d == 1: fracc = fracc.n
pol[3].append(['%s' % m[0][0], '*', '(', 'Polynome(%s, "x", details=0)' % [[1, 2], [fracb, 1], [fracc, 0]], ')'])
pol[3].extend(self.resolution([[1, 2], [fracb, 1], [fracc, 0]], ['%s' % m[0][0], '*', '('], [')']))
shuffle(pol)
self.exercice = pol
def __init__(self):
[a, b, c, d] = [randrange(-5, 6) for dummy in range(4)]
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:
[a, b, c, d] = [randrange(-5, 6) for dummy in range(4)]
p1 = str(Polynome([[a, 1], [b, 0]], "m"))
p2 = str(Polynome([[c, 1], [d, 0]], "m"))
pol = [Polynome([[1, 2], [p1, 1], [p2, 0]]), randrange(3)]
exercice = [list(pol)]
v = [randrange(-4, 5) for dummy in range(6)]
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:
v = [randrange(-4, 5) for dummy in range(6)]
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)]
pol = Polynome([[lp[0], 2], [lp[1], 1], [lp[2], 0]])
vi = Fraction(-v[1], v[0])
racine = randrange(-4, 5)
while racine == vi or racine == 0:
racine = randrange(-4, 5)
if vi.d == 1 : vi = str(vi.n)
else: vi = str(vi)
exercice.append([list(pol), vi, racine])
self.exercice = exercice
def tex_answer(self):
exo = [r'\exercice*']
exo.append(_(u'Déterminer les racines des polynômes :\\par'))
noms = [r'P\,(x) &= ', r'Q\,(x) &= ', r'R\,(x) &= ']
r = ''
question = [[], [], []]
for i in range(3):
p = []
m = Polynome(list(self.exercice[i])).ordonne()
if factoriser('%r' % Polynome(m)):
p = [factoriser('%r' % Polynome(m))]
while factoriser(p[-1]):
p.append(factoriser(p[-1]))
if p and eval(Priorites3.splitting(p[-1])[0]).degre() > 0:
tmp = Priorites3.texify([Priorites3.splitting(p[j]) for j in range(len(p))])
question[i].append('{$\\! \\begin{aligned}')
question[i].append(noms[i] + str(Polynome(m, 'x')) + r'\\')
question[i].append('\\\\\n'.join(['&=%s' % (tmp[j]) for j in range(len(tmp))]))
question[i].append(r'\end{aligned}$}\par')
lp = Priorites3.splitting(p[-1])
racines = []
for e in lp:
if e[:9] == 'Polynome(':
e = eval(e)
if len(e) == 2:
racines.append(str(Fraction(-e[1][0], e[0][0]).simplifie()))
else:
racines.append('0')
if len(racines) > 1:
question[i].append(_(u'\\underline{Les racines de $%s$ sont }\\fbox{$%s$}') % (noms[i].rstrip(r' &= '), '$}\\underline{ et }\\fbox{$'.join(racines)))
elif len(racines) == 1:
question[i].append(_(u'\\underline{L\'unique racine de $%s$ est }\\fbox{$%s$}') % (noms[i].rstrip(r' &= '), racines[0]))
elif len(m) == 2 and m[0][1] == 2 and m[1][1] == 0 and m[0][0] * m[1][0] > 0:
question[i].append('$' + noms[i] + str(Polynome(m, 'x')) + r'$\par')
question[i][-1] = question[i][-1].replace('&', '')
if m[1][0] > 0: question[i].append('$' + noms[i][:7] + ' \\geqslant %r$' % m[1][0])
else: question[i].append('$' + noms[i][:7] + ' \\leqslant %r$' % m[1][0])
question[i].append(_(u'car un carré est toujours positif.\\par\n\\underline{$%s$ n\'a donc pas de racine.}') % (noms[i].rstrip(r' &= ')))
else:
question[i].append('$' + noms[i] + str(Polynome(m, 'x')) + r'\quad$')
question[i][-1] = question[i][-1].replace('&', '')
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]))
question[i].append(r'\begin{tabularx}{\linewidth}[t]{XXX}')
question[i].append(r'{$\! \begin{aligned}')
if m[1][0]>0:
sol = [[str(m[1][0]), '**', '2', '-', '4', '*', str(m[0][0]), '*', str(m[2][0])]]
sol.extend(Priorites3.priorites('%s**2-4*%s*%s' % (m[1][0], m[0][0], m[2][0])))
else:
sol = [['(', str(m[1][0]), ')', '**', '2', '-', '4', '*', str(m[0][0]), '*', str(m[2][0])]]
sol.extend(Priorites3.priorites('(%s)**2-4*%s*%s' % (m[1][0], m[0][0], m[2][0])))
solTeX = Priorites3.texify(sol)
for s in solTeX:
question[i].append(u'\\Delta &= %s\\\\' % s)
question[i].append(r'\end{aligned}$}')
question[i].append(r'&')
question[i].append(r'{$\! \begin{aligned}')
delta = sol[-1][0]
print(sol)
sol = [['Fraction(SquareRoot([[%s, None], [-1, %s]]),\'2*%s\')' % (-m[1][0], delta, m[0][0])]]
sol.extend(Priorites3.priorites(sol[0][0]))
sol = Priorites3.texify(sol)
for s in sol:
question[i].append(u'x_1 &= %s\\\\' % s)
racines = [sol[-1]]
question[i].append(r'\end{aligned}$}')
question[i].append(r'&')
question[i].append(r'{$\! \begin{aligned}')
sol = [['Fraction(SquareRoot([[%s, None], [1, %s]]),\'2*%s\')' % (-m[1][0], delta, m[0][0])]]
sol.extend(Priorites3.priorites(sol[0][0]))
sol = Priorites3.texify(sol)
for s in sol:
question[i].append(u'x_2 &= %s\\\\' % s)
racines.append(sol[-1])
question[i].append(r'\end{aligned}$}')
question[i].append(r'\end{tabularx}\par')
question[i].append(_(u'\\underline{Les racines de $%s$ sont }\\fbox{$%s$}') % (noms[i].rstrip(r' &= '), _('$}\\underline{ et }\\fbox{$').join(racines)))
if i == 1: question.append(question[1])
if len(question) == 4:
question.pop(1)
if question[0][0][-6:] == r'\quad$':
question[1].insert(0, r'\par\medskip\begin{tabularx}{\linewidth}[t]{XX}')
question[2].insert(0, r'&')
question[2].append(r'\end{tabularx}\par\medskip')
else:
question[0].insert(0, r'\begin{tabularx}{\linewidth}[t]{XX}')
question[1].insert(0, r'&')
question[1].append(r'\end{tabularx}\par\medskip')
for i in range(3): exo.extend(question[i])
return exo
def effectue_calcul(calcul):
"""**effectue_calcul**\ (*calcul*)
Effectue une étape du calcul en respectant les priorités
:param calcul: le calcul à traiter
:type calcul: list
>>> from pyromaths.outils import Priorites3
>>> Priorites3.effectue_calcul(['-5', '-', '(', '(-6)', '-', '1', '+', '(-3)', ')', '*', '(-1)'])
['-5', '-', '(', '-7', '-', '3', ')', '*', '(-1)']
>>> Priorites3.effectue_calcul(['-5', '-', '(', '-7', '-', '3', ')', '*', '(-1)'])
['-5', '-', '-10', '*', '(-1)']
>>> Priorites3.effectue_calcul(['-5', '-', '-10', '*', '(-1)'])
['-5', '-', '10']
>>> Priorites3.effectue_calcul(['-5', '-', '10'])
['-15']
>>> Priorites3.effectue_calcul(['-', 'Polynome("x-1")', '*', '2'])
['-', '(', 'Polynome([[2, 1]], "x", 0)', '+', 'Polynome([[-2, 0]], "x", 0)', ')']
>>> Priorites3.effectue_calcul(['4', '*', 'Polynome("x+1")', '**', '2'])
['4', '*', '(', 'Polynome([[1, 1]], "x", 0)', '**', '2', '+', '2', '*', 'Polynome([[1, 1]], "x", 0)', '*', 'Polynome([[1, 0]], "x", 0)', '+', 'Polynome([[1, 0]], "x", 0)', '**', '2', ')']
:rtype: list
"""
from pyromaths.classes.PolynomesCollege import Polynome
from pyromaths.classes.Fractions import Fraction
from pyromaths.classes.SquareRoot import SquareRoot
serie = (recherche_parentheses, recherche_puissance, recherche_produit,
recherche_neg, recherche_somme)
result, post, break_somme = [], "", False
for recherche in serie:
if break_somme and recherche == recherche_somme: break
if calcul: test = recherche(calcul)
else: test = None
while test:
pre = calcul[:test[0]]
calc = calcul[test[0]:test[1]]
post = calcul[test[1]:]
# On essaie d'utiliser les priorités sur la première partie du
# calcul pour raccourcir la résolution de l'expression
if test != recherche_neg and pre:
# Si on simplifie les écritures, on n'essaie pas les sommes
tmp = effectue_calcul(pre)
if tmp and result and result[-1] not in "+-**/(" and tmp[0][0]\
not in "+-*/)":
# un signe + si l'expression en a besoin
result.append("+")
# On ajoute le résultat ou l'expression
if tmp: result.extend(tmp)
else: result.extend(pre)
else:
result.extend(pre)
if recherche == recherche_parentheses:
# On supprime les parenthèses autour de l'expression
calc = calc[1:-1]
# On réduit directement les calculs numériques dans une
# expression littérale
"Effectue les calculs entre parenthèses et remet les parenthèses si l'expression est de longueur supérieure à 1"
sol = effectue_calcul(calc)
if len(sol) > 1:
sol.insert(0, "(")
sol.append(")")
elif sol and isinstance(eval(sol[0]), (int, float, Fraction)) and post and post[0] == "*" and \
_('Polynome(') in post[1] and len(eval(post[1])) == 1 and eval(post[1])[0][0] == 1:
# Sans doute une factorisation de sommes de polynômes
sol = [repr(eval(sol[0]) * eval(post[1]))]
post = post[2:]
# Suppression des parenthèses autour de ((9.0-80.0)*Polynome("x")) devenu (Polynome("-71.0x"))
if post and result and post[0] == ")" and result[-1] == "(" :
result, post = result[:-1], post[1:]
else:
if recherche == recherche_somme:
# Permet les cas 1 + Fraction(1, 2) + 1
# ou 3 + Polynome("5x") + 4
frac, poly, nombres = False, False, []
for i in range(0, len(calc), 2):
nombres.append(eval(calc[i]))
if isinstance(nombres[-1], Fraction): frac = True
elif isinstance(nombres[-1], Polynome): poly, var, details = True, nombres[-1].var, nombres[-1].details
if poly: nombres = [(Polynome([[i, 0]], var, details) , i)[isinstance(i, Polynome)] for i in nombres]
elif frac: nombres = [(Fraction(i, 1), i)[isinstance(i, Fraction)] for i in nombres]
if poly: classe = Polynome
elif frac: classe = Fraction
if poly or frac:
if calc[1] == '+': operation = classe.__add__
else: operation = classe.__sub__
if isinstance(nombres[0], (int, float)):
sol = operation(classe(nombres[0]), *nombres[1:])
else:
sol = operation(nombres[0], *nombres[1:])
else: sol = eval("".join(calc))
elif recherche == recherche_produit and calc[1] == "*":
frac, poly, nombres = False, False, []
for i in range(0, len(calc), 2):
nombres.append(eval(calc[i]))
if isinstance(nombres[-1], Fraction): frac = True
elif isinstance(nombres[-1], Polynome): poly, var, details = True, nombres[-1].var, nombres[-1].details
if poly: nombres = [(Polynome([[i, 0]], var, details) , i)[isinstance(i, Polynome)] for i in nombres]
elif frac: nombres = [(Fraction(i, 1), i)[isinstance(i, Fraction)] for i in nombres]
if poly: classe = Polynome
elif frac: classe = Fraction
if poly or frac:
if isinstance(nombres[0], (int, float)):
sol = classe.__mul__(classe(nombres[0]), *nombres[1:])
else:
sol = classe.__mul__(nombres[0], *nombres[1:])
else: sol = eval("".join(calc))
elif recherche == recherche_puissance:
sol = eval('(' + calc[0] + ')**' + calc[2])
else:
sol = eval("".join(calc))
if isinstance(sol, basestring): sol = splitting(sol)
elif isinstance(sol, (int, float)): sol = [str(sol)]
elif isinstance(sol, (Polynome, Fraction, SquareRoot)): sol = [repr(sol)]
else :
raise ValueError(_(u"Le résultat %s a un format inattendu") % sol)
if recherche == recherche_neg and (pre or result):
# Ajoute le "+" ou sépare le "-":
# "1-(-9)" => "1 + 9" et "1+(-9)" => "1 - 9"
if sol[0][0] == "-": sol = ["-", sol[0][1:]]
else: sol = ["+", sol[0]]
#===================================================================
# if recherche == recherche_produit and len(sol) > 1:
# # Ajoute les parenthèses si produit précédé d'un "-" ou "*"
# # ou suivi d'un "*"
#===================================================================
if len(sol) > 1 and sol[0] != "(" and sol[-1] != ")":
# Ajoute les parenthèses si le résultat est précédé d'un "-" ou "*"
# ou suivi d'un "*"
if (result and result[-1] in "*-") or (pre and pre[-1] in "*-") or (post and post[0] == "*"):
sol.insert(0, "(")
sol.append(")")
# Si @sol est négatif et @result se termine par un "+", on l'enlève
if result and result[-1] == "+" and sol and sol[0][0] == "-":
result[-1] = "-"
sol[0] = sol[0].lstrip("-")
result.extend(sol)
calcul = post
if calcul: test = recherche(calcul)
else: test = None
if post and recherche == recherche_neg: break_somme = True
result.extend(post)
if not result: result = calcul
return result
def texify(liste_calculs):
r"""**texify**\ (*liste_calculs*)
Convertit la liste de chaînes de caractères `liste_calculs` contenant
des polynômes en liste de chaînes de caractères au format TeX
**TODO :** intégrer cela dans :mod:`outils.Affichage` et gérer l'ensemble des
classes de Pyromaths.
:param calcul: le calcul à traiter
:type calcul: string
>>> from pyromaths.outils import Priorites3
>>> from pyromaths.classes.PolynomesCollege import Polynome
>>> l = [['4', '+', '5', '-', '6'], ['9', '-', '6'], ['3']]
>>> Priorites3.texify(l)
['4+5-6', '9-6', '3']
>>> Priorites3.texify(Priorites3.priorites('(-7)+8-Polynome([[-4, 1], [-9, 2], [-5, 0]], "x")'))
['1-\\left( -4\\,x-9\\,x^{2}-5\\right) ', '1+4\\,x+9\\,x^{2}+5', '9\\,x^{2}+4\\,x+6']
>>> Priorites3.texify([['Fraction(5,6)', '**', '2']])
['\\left( \\dfrac{5}{6} \\right) ^{2}']
:rtype: list
"""
from pyromaths.classes.PolynomesCollege import Polynome
from pyromaths.classes.Fractions import Fraction
from pyromaths.classes.SquareRoot import SquareRoot
from Affichage import decimaux
ls = []
enluminures = {'indice': r'_{', 'cancel':r'\cancel{'}
isEnlumine = {'indice': False, 'cancel':False}
for calcul in liste_calculs:
if isinstance(calcul, basestring): calcul = splitting(calcul)
s = ""
puiss = 0
for index in range(len(calcul)):
el = calcul[index]
for cle in isEnlumine.keys():
if isEnlumine[cle] and (not isinstance(el, list) or el[1] != cle):
s += '}'
isEnlumine[cle] = False
if isinstance(el, list):
if not isEnlumine[el[1]]:
s += enluminures[el[1]]
isEnlumine[el[1]] = True
el = el[0]
if el[:9] == "Polynome(":
# Doit-on entourer ce polynôme de parenthèses ?
p = eval(el)
if index + 1 < len(calcul): q = calcul[index + 1]
else: q = ""
""" 3 cas :
* {*,-}(2x+3) ou {*,-}(-2x)
* (2x+3)*...
* (2x+1)**2"""
if (s and s[-1] in "*-" and (len(p) > 1 or p.monomes[0][0] < 0)) \
or (q and q == "*" and len(p) > 1) \
or ((len(p) > 1 or (p.monomes[0][0] != 1 and p.monomes[0][1] > 0) or \
p.monomes[0][0] < 0 or \
(p.monomes[0][0] != 1 and isinstance(p.monomes[0][0], Fraction) and p.monomes[0][0].d != 1)) and q and q == "**"):
s += "(" + str(p) + ")"
elif s and s[-1] == "+" and p.monomes[0][0] < 0:
s = s[:-1]
s += str(p)
else:
s += str(p)
elif el[:9] == "Fraction(":
# Doit-on entourer cette fraction de parenthèses ?
p = splitting(el[9:-1])
# Gère le cas ou la fraction comprend des objets SquareRoot
t = [""]
for i in range(len(p)):
if p[i] == ',': t.append("")
else: t[-1] += p[i]
p = t
if len(p) == 2:
# texfrac = str(Fraction(eval(p[0]), eval(p[1])))
texfrac = str(Fraction(p[0], p[1]))
else:
texfrac = str(Fraction(p[0], p[1], p[2]))
if index + 1 < len(calcul): q = calcul[index + 1]
else: q = ""
if (eval(p[0]) < 0 or p[1] != "1") and q == "**":
s += "( " + texfrac + " )"
else:
s += texfrac
elif el[:11] == "SquareRoot(":
p = eval(el)
if index + 1 < len(calcul): q = calcul[index + 1]
else: q = ""
""" 3 cas :
* {*,-}(2x+3) ou {*,-}(-2x)
* (2x+3)*...
* (2x+1)**2"""
if (s and s[-1] in "*-" and (len(p) > 1 or p[0][0] < 0)) \
or (q and q == "*" and len(p) > 1) \
or ((len(p) > 1 or (p[0][0] != 1 and p[0][1] > 0) or \
p[0][0] < 0 or \
(p[0][0] != 1 and isinstance(p[0][0], Fraction) and p[0][0].d != 1)) and q and q == "**"):
s += "(" + str(p) + ")"
elif s and s[-1] == "+" and p[0][0] < 0:
s = s[:-1]
s += str(p)
else:
s += str(p)
elif EstNombre(el):
if index + 1 < len(calcul): q = calcul[index + 1]
else: q = ""
if el[0] == "(": s += "(" + decimaux(el[1:-1]) + ")"
elif el[0] == '-' and ((s and s[-1] in "+/*-") \
or (q and q == "**")):
s += "(" + decimaux(el) + ")"
else: s += decimaux(el)
elif el == "**":
s += "**{"
puiss = 1
elif el == "(":
if puiss: puiss += 1
s += "("
elif el == ")":
if puiss: puiss -= 1
s += ")"
else :
# "+", "-", "*", "/"
s += el
if puiss == 1 and s[-1] != r"{":
puiss = 0
s += "}"
for cle in isEnlumine.keys():
if isEnlumine[cle] and (not isinstance(el, list) or el[1] != cle):
s += '}'
s = s.replace("**{", "^{")
s = s.replace("(", "\\left( ")
s = s.replace(")", "\\right) ")
s = s.replace("\\left\\left", "\\left ")
s = s.replace("\\right\\right", "\\right ")
s = s.replace("*", "\\times ")
s = s.replace("/", "\\div ")
if not ls or s != ls[-1]:
ls.append(s)
return ls
def coefdir(A, B):
# donne le coefficient directeur x/y sous forme de liste [x,y]
# Si y=1 on ecrira x sinon on écrira la fraction x/y
return Fraction.simplifie(Fraction(B[1] - A[1], B[0] - A[0]))
def proba(exo, cor):
couleur = ['bleue', 'rouge', 'jaune', 'verte', 'marron', 'orange']
initiale = ['B', 'R', 'J', 'V', 'M', 'O']
# Choix des 3 couleurs et du nombre de boule
rg = random.randrange(0, 4)
c1, i1, n1 = couleur[rg], initiale[rg], random.randrange(
1, 6) # 1ere couleur, son initiale et le nombre
# 2e couleur diférente de la première
rg2 = (rg + random.randrange(1, 5)) % 6
c2, i2, n2 = couleur[rg2], initiale[rg2], random.randrange(1, 6)
# 3e couleur différente des précédentes
c3, i3, n3 = couleur[(rg2 + 1) % 6], initiale[(rg2 + 1) %
6], random.randrange(1, 6)
if n1 > 1:
plur1 = "s"
else:
plur1 = ""
if n2 > 1:
plur2 = "s"
else:
plur2 = ""
if n3 > 1:
plur3 = "s"
else:
plur3 = ""
exos = [
u"Dans une urne, il y a %s boule%s %s%s (%s), %s boule%s %s%s (%s) et %s boule%s %s%s (%s), indiscernables au toucher. On tire successivement et sans remise deux boules."
% (n1, plur1, c1, plur1, i1, n2, plur2, c2, plur2, i2, n3, plur3, c3,
plur3, i3), "\\begin{enumerate}",
u"\\item Quelle est la probabilité de tirer une boule %s au premier tirage ?"
% c2,
u"\\item Construire un arbre des probabilités décrivant l'expérience aléatoire.",
u"\\item Quelle est la probabilité que la première boule soit %s et la deuxième soit %s ?"
% (c3, c2),
u"\\item Quelle est la probabilité que la deuxième boule soit %s ?" %
c1, "\\end{enumerate}"
]
tot = n1 + n2 + n3
# calculs intermédiaires pour la question 4
p41 = "\\dfrac{%s}{%s}\\times \\dfrac{%s}{%s}+" % (n1, tot, n1 - 1,
tot - 1)
p42 = "\\dfrac{%s}{%s}\\times \\dfrac{%s}{%s}+" % (n2, tot, n1, tot - 1)
p43 = "\\dfrac{%s}{%s}\\times \\dfrac{%s}{%s}=" % (n3, tot, n1, tot - 1)
result4 = "\\dfrac{%s}{%s}" % (n1 * (n1 - 1 + n2 + n3), tot * (tot - 1)
) # resultat non simplifié de la question 4
cors = [u"Dans une urne, il y a %s boule%s %s%s (%s), %s boule%s %s%s (%s) et %s boule%s %s%s (%s), indiscernables au toucher. On tire successivement et sans remise deux boules." % (n1, plur1, c1, plur1, i1, n2, plur2, c2, plur2, i2, n3, plur3, c3, plur3, i3),
"\\begin{enumerate}",
u"\\item Quelle est la probabilité de tirer une boule %s au premier tirage ?\\par " % c2,
"Il y a %s boules dans l'urne dont %s boule%s %s%s. \\par" % (tot, n2, plur2, c2, plur2),
u" La probabilité de tirer une boule %s au premier tirage est donc $\\dfrac{%s}{%s}$." % (c2, n2, tot),
u"\\item Construire un arbre des probabilités décrivant l'expérience aléatoire.\\\ [0,3cm] ",
"\\psset{unit=1 mm}",
"\\psset{linewidth=0.3,dotsep=1,hatchwidth=0.3,hatchsep=1.5,shadowsize=1,dimen=middle}",
"\\psset{dotsize=0.7 2.5,dotscale=1 1,fillcolor=black}",
"\\psset{arrowsize=1 2,arrowlength=1,arrowinset=0.25,tbarsize=0.7 5,bracketlength=0.15,rbracketlength=0.15}",
"\\begin{pspicture}(0,0)(80,53)",
"\\psline(0,3)(10,23)",
"\\psline(10,3)(10,23)",
"\\psline(20,3)(10,23)",
"\\psline(30,3)(40,23)",
"\\psline(40,3)(40,23)",
"\\psline(50,3)(40,23)",
"\\psline(60,3)(70,23)",
"\\psline(80,3)(70,23)",
"\\psline(70,3)(70,23)",
"\\psline(15,28)(40,53)",
"\\psline(40,53)(65,28)",
"\\psline(40,53)(40,28)",
"\\rput(20,40){$\\dfrac{%s}{%s}$} \\rput(37,40){$\\dfrac{%s}{%s}$} \\rput(60,40){$\\dfrac{%s}{%s}$}" % (n1, tot, n2, tot, n3, tot),
"\\rput(10,26){%s} \\rput(40,26){%s} \\rput(70,26){%s}" % (i1, i2, i3),
"\\rput(0,10){$\\dfrac{%s}{%s}$} \\rput(7,10){$\\dfrac{%s}{%s}$} \\rput(20,10){$\\dfrac{%s}{%s}$}" % (n1 - 1, tot - 1, n2, tot - 1, n3, tot - 1),
"\\rput(0,0){%s} \\rput(10,0){%s} \\rput(20,0){%s}" % (i1, i2, i3),
"\\rput(30,10){$\\dfrac{%s}{%s}$} \\rput(37,10){$\\dfrac{%s}{%s}$} \\rput(50,10){$\\dfrac{%s}{%s}$}" % (n1, tot - 1, n2 - 1, tot - 1, n3, tot - 1),
"\\rput(30,0){%s} \\rput(40,0){%s} \\rput(50,0){%s}" % (i1, i2, i3),
"\\rput(60,10){$\\dfrac{%s}{%s}$} \\rput(67,10){$\\dfrac{%s}{%s}$} \\rput(80,10){$\\dfrac{%s}{%s}$}" % (n1, tot - 1, n2, tot - 1, n3 - 1, tot - 1),
"\\rput(60,0){%s} \\rput(70,0){%s} \\rput(80,0){%s}" % (i1, i2, i3),
"\\end{pspicture}",
"\\vspace{0.3cm}",
u"\\item Quelle est la probabilité que la première boule soit %s et la deuxième soit %s ?\\par" % (c3, c2),
u"On note $(\\mathrm %s~,~\\mathrm %s)$ l'évènement: \\og{}la première boule tirée est %s et la deuxième tirée est %s\\fg{} et " % (i3,i2,c3,c2),
u"on utilise l'arbre construit précédemment.\\par",
"$p\\,(\\mathrm %s~,~\\mathrm %s)=%s \\times %s = %s$\\par" % \
(i3, i2, str(Fraction(n3, tot)),
str(Fraction(n2, tot - 1)),
str(Fraction(n3 * n2, tot * (tot - 1)))),
u"La probabilité que la première boule soit %s et la deuxième soit %s est égale à $\\dfrac{%s}{%s}$." % (c3, c2, n3 * n2, tot * (tot - 1)),
u"\\item Quelle est la probabilité que la deuxième boule soit %s ?\\par" % c1,
u"On note $(?~,~\\mathrm %s)$ l'évènement: \\og{}la deuxième boule tirée est %s\\fg{}. \\par" % (i1, c1),
"$p\\,(?~,~\\mathrm %s)=p\\,(\\mathrm %s~,~\\mathrm %s)+p\\,(\\mathrm %s~,~\\mathrm %s)+p\\,(\\mathrm %s~,~\\mathrm %s)=" % (i1, i1, i1, i2, i1, i3, i1) + p41 + p42 + p43 + result4 + "$",
"\\end{enumerate}"]
for st in exos:
exo.append(st)
for st in cors:
cor.append(st)
def TeX(nombre, parenthese=False, terme=False, fractex="\\dfrac"):
r"""**TeX**\ (*nombre*\ [, *parenthese*\ [, *terme*\ [, *fractex*\ ]]])
Permet l'affichage de nombres au format TeX. Fait en partie double emploi avec tex_coef. Permet
* d'écrire un nombre (décimal, rationnel ou radical) au format TeX
* d'écrire l'infini au format TeX
* d'ajouter un `+` devant `3` pour écrire `+3` avec `terme`
* de mettre des parenthèses autour de `3` avec `parenthese`
* de changer la commande d'écriture des fractions en TeX avec fractex
:param nombre: est le nombre à écrire
:type nombre: integer, Fractions, RacineDegre2
:param parenthese: si vrai, il faut écrire des parenthèses autour de `nombre`
:type parenthese: boolean
:param terme: Ajoute un `+` devant nombre s'il est positif.
:type terme: boolean
:param fractex: commande à utiliser pour créer une fraction sous TeX
:type fractex: string
>>> from pyromaths.outils import Affichage
>>> from pyromaths.classes.Fractions import Fraction
>>> Affichage.TeX(Fraction(7,3)).strip()
\dfrac{7}{3}
>>> Affichage.TeX(Fraction(7,3),fractex='\\frac').strip()
\frac{7}{3}
:rtype: string
"""
strTeX = finTeX = ""
# Affichage simplifié des racines ou fractions
if isinstance(nombre, Racine.RacineDegre2) and nombre.radicande == 0:
# Affiche la RacineDegre2 comme une Fractions
nombre = Fraction(nombre.numerateur, nombre.denominateur)
if isinstance(nombre, Fraction) and nombre.d == 1:
# Affiche la Fractions comme un entier
nombre = nombre.n
# parentheses des fractions
if parenthese and (
isinstance(nombre, Racine.RacineDegre2)
and nombre.denominateur == 1 and (nombre.numerateur or nombre.coeff < 0)
# RacineDegre2 avec radicande nécessairement grâce au tri
or isinstance(nombre, Fraction) and nombre.n < 0
or isinstance(nombre, int) and nombre < 0
or isinstance(nombre, float) and nombre < 0):
strTeX = "\\left("
finTeX = "\\right)"
elif terme and (isinstance(nombre, Racine.RacineDegre2) and
(nombre.d != 1 or (nombre.n > 0 or nombre.n == 0 and nombre.coeff >= 0))
or nombre >= 0) :
strTeX = "+"
finTeX = ""
# #Affichage
if isinstance(nombre, (int, float)) and nombre == float("inf"):
return "+\\infty "
elif isinstance(nombre, (int, float)) and nombre == float("-inf"):
return "-\\infty "
elif isinstance(nombre, int) or isinstance(nombre, float):
return strTeX + decimaux(nombre) + finTeX
elif isinstance(nombre, Fraction):
if nombre.n < 0:
strTeX += "-" + fractex + "{" + decimaux(-nombre.n) + "}{" + decimaux(nombre.d) + "} "
else:
strTeX += fractex + "{" + decimaux(nombre.n) + "}{" + decimaux(nombre.d) + "} "
strTeX += finTeX
return strTeX
elif isinstance(nombre, Racine.RacineDegre2):
return strTeX + str(nombre) + finTeX
else:
return strTeX + str(nombre) + finTeX
def exprfonc(f, i, A, B):
# Génère la 3e question.
# A est sur l'axe des ordonnées, f est le nom de la fonction
u = coefdir(A, B)
if isinstance(u, int): u = Fraction(u, 1)
Polynome([[u, 1], [A[1], 0]], "x")(B[0])
#===========================================================================
# if A[1] >= 0:
# b = '+' + decimaux(str(A[1]))
# else:
# b = decimaux(str(A[1]))
# if u.d == 1:
# coef = decimaux(str(u.n))
# if u.n == -1:
# coef = '-' # utilisé dans l'expression de la fonction
# if u.n == 1:
# coef = ''
# coefres = decimaux(str(u.n)) # résultat utilisé pour a
# else:
# if u.n > 0:
# coef = '\\dfrac{' + decimaux(str(u.n)) + '}{' + decimaux(str(u.d)) + '}'
# else:
# coef = '-\\dfrac{' + decimaux(str(abs(u.n))) + '}{' + decimaux(str(u.d)) + '}'
# coefres = coef
#===========================================================================
if A[1] - B[1] > 0:
deltay = '+' + decimaux(str(A[1] - B[1]))
else:
deltay = decimaux(str(A[1] - B[1]))
if A[0] - B[0] > 0:
deltax = '+' + decimaux(str(A[0] - B[0]))
else:
deltax = decimaux(str(A[0] - B[0]))
if float(B[0]) < 0:
mid11 = float(B[0]) - 0.75
mid12 = float((B[1] + A[1])) / 2 # milieu de la flèche verticale
else:
mid11 = float(B[0]) + 0.75
mid12 = float((B[1] + A[1])) / 2
if float(B[0]) * float(u.d / u.n) > 0:
mid21 = float((A[0] + B[0])) / 2
mid22 = A[1] - 0.6 # milieu de la flèche horizontale
else:
mid21 = float((A[0] + B[0])) / 2
mid22 = A[1] + 0.5
if mid12 < 0 and mid12 > -0.8:
mid12 = -1
if mid12 >= 0 and mid12 < 0.5:
mid12 = 0.5
if mid11 < 0 and mid11 > -0.8:
mid11 = -1
if mid11 >= 0 and mid11 < 0.5:
mid11 = 0.5
if mid21 < 0 and mid21 > -0.8:
mid21 = -1
if mid21 >= 0 and mid21 < 0.5:
mid21 = 0.5
if mid22 < 0 and mid22 > -0.8:
mid22 = -1
if mid22 >= 0 and mid22 < 0.5:
mid22 = 0.5
mid1 = (mid11, mid12)
mid2 = (mid21, mid22)
l = [
u'Déterminer l\'expression de la fonction $' + f +
u'$ représentée ci-contre par la droite ($d_' + str(i) + '$).',
u'On lit l\'ordonnée à l\'origine et le coefficient de la fonction affine sur le graphique.\\\ ',
'$' + f + '(x)=a\\,x+b$ ' + 'avec $b=' + decimaux(str(A[1])) +
'$ et $a=' + '\\dfrac{' + deltay + '}{' + deltax + '}=' + str(u) +
'$.\\\ ', 'L\'expression de la fonction $' + f + '$ est $' + f +
'(x)=' + str(Polynome([[u, 1], [A[1], 0]], "x")) + '$.',
doublefleche(B, (B[0], A[1])),
doublefleche((B[0], A[1]),
A), '\\rput' + str(mid1) + '{(' + deltay + ')}',
'\\rput' + str(mid2) + '{(' + deltax + ')}'
]
return l
def coefdir(A, B):
# donne le coefficient directeur x/y sous forme de liste [x,y]
# Si y=1 on ecrira x sinon on écrira la fraction x/y
return Fraction.simplifie(Fraction(B[1] - A[1], B[0] - A[0]))