def test_issue_258():
# Issue: "Le mode approché ne fonctionne pas pour une liste."
i = Interprete(verbose=VERBOSE)
i.evaluer("v(p,n) = (p-1.96*sqrt(p*(1-p))/sqrt(n), p+1.96*sqrt(p*(1-p))/sqrt(n))")
r, l = i.evaluer("v(0.28, 50)", calcul_exact=False)
assertEqual(r, "(0,155543858327521659 ; 0,404456141672478341)")
assertEqual(l, r"$\left(0,155543858327521659;\,0,404456141672478341\right)$")
def test_resolution_avec_fonction():
i = Interprete(verbose=VERBOSE)
i.evaluer("f(x)=a*x+1")
i.evaluer("resoudre(f(3)=7)")
res = i.derniers_resultats[-1]
# Le type du résultat est actuellement un ensemble, mais cela pourrait changer à l'avenir.
assertEqual(res, {S(2)})
def test_systeme():
i = Interprete(verbose = VERBOSE, adapter_separateur=False)
i.evaluer("g(x)=a x^3+b x^2 + c x + d")
i.evaluer("resoudre(g(-3)=2 et g(1)=6 et g(5)=3 et g'(1)=0)")
res = i.derniers_resultats[-1]
assert isinstance(res, dict)
assertEqual(res, {S('a'): S(1)/128, S('b'): -S(31)/128, S('c'): S(59)/128, S('d'): S(739)/128})
def test_systeme():
i = Interprete(verbose=VERBOSE)
i.evaluer("g(x)=a x^3+b x^2 + c x + d")
i.evaluer("resoudre(g(-3)=2 et g(1)=6 et g(5)=3 et g'(1)=0)")
res = i.derniers_resultats[-1]
# Le type du résultat est actuellement un dictionnaire, mais cela pourrait changer à l'avenir.
assert isinstance(res, dict)
assertEqual(res, {S('a'): S(1)/128, S('b'): -S(31)/128, S('c'): S(59)/128, S('d'): S(739)/128})
def test_load_state2():
i = Interprete(verbose=VERBOSE)
etat_interne = \
"""_ = '2.56'
@derniers_resultats = [
"'2.56'",
]"""
i.load_state(etat_interne)
i.evaluer('_')
assertDernier(i, '"2.56"')
def test_issue_206_bis():
i = Interprete(verbose = VERBOSE)
etat_interne = \
u"""_ = 0
@derniers_resultats = [
'Abs(x)',
]"""
i.load_state(etat_interne)
i.evaluer('abs(-24/5 - 2 i/5)')
assertDernier(i, '2*145**(1/2)/5')
def test_issue_206_ter():
i = Interprete(verbose = VERBOSE)
etat_interne = \
u"""_ = 0
@derniers_resultats = [
'atan2(x, y)',
]"""
i.load_state(etat_interne)
i.evaluer('ln(9)-2ln(3)')
assertDernier(i, '0')
def assert_resultat(s, resultat, latex = None, **parametres):
i = Interprete(verbose = VERBOSE, **parametres)
r, l = i.evaluer(s)
if r != resultat:
i = Interprete(verbose = True, **parametres)
r, l = i.evaluer(s)
print "ERREUR (" + s + "): ", r, " != ", resultat
assert(r == resultat)
if latex is not None:
latex = "$" + latex + "$"
if l != latex:
print "ERREUR (" + s + "): ", l, " != ", latex
assert(l == latex)
def test_issue_259():
i = Interprete(verbose=VERBOSE)
# First part.
r, l = i.evaluer("normal(140,1 ; 150,3 ; 100 ; 5)")
# sympy 1.0 : '5,28725822993202*10^-16'
# Wofram Alpha (01/05/2016) : 5/9007199254740992~~5.55112×10^-16
# On teste que ce soit en gros correct, sans se focaliser sur les décimales.
assert re.match("5,[0-9]+\*10\^\-16$", r)
assert re.match(r"\$5,[0-9]+[ ]\\cdot[ ]10\^{-16}\$$", l)
# Second part of the issue (scientific notation handling).
i.calcul_exact = False
r, l = i.evaluer("10,0^-125,0")
assertEqual(r, "1,0*10^-125")
assertEqual(l, r"$10^{-125}$")
def test_ensemble_complexe():
i = Interprete(verbose=VERBOSE, ensemble='C')
r, l = i.evaluer("resoudre(x^2=-1")
assert r in ('{i ; -i}', '{-i ; i}')
assert l in (r'$\left\{- \mathrm{i}\,;\,\mathrm{i}\right\}$',
r'$\left\{\mathrm{i}\,;\,- \mathrm{i}\right\}$')
r, l = i.evaluer("resoudre(2+\i=\dfrac{2\i z}{z-1}")
assertEqual(r, '{3/5 + 4 i/5}')
assertEqual(l, r'$\left\{\frac{3}{5} + \frac{4}{5} \mathrm{i}\right\}$')
r, l = i.evaluer("resoudre(x^2=-1 et 2x=-2i")
assertEqual(r, '{-i}')
assertEqual(l, r'$\left\{- \mathrm{i}\right\}$')
r, l = i.evaluer('factorise(x^2+7x+53)')
assertEqual(r, '(x + 7/2 - sqrt(163)i/2)(x + 7/2 + sqrt(163)i/2)')
assertEqual(l, r'$\left(x + \frac{7}{2} - \frac{\sqrt{163} \mathrm{i}}{2}\right) '
r'\left(x + \frac{7}{2} + \frac{\sqrt{163} \mathrm{i}}{2}\right)$')
def test_issue_270():
"""Bug 270: les décimaux s'affichent parfois en écriture scientifique.
Exemple avec 3 chiffres significatifs:
Calcul n°59 : 160000000000700,4
Résultat : 160000000000700
Calcul n°60 : 16000000000700,4
Résultat : 1,6*10^13
"""
i = Interprete(precision_affichage=3)
r, l = i.evaluer("160000000000700,4")
assert r == "160000000000700" # 1,6*10^14 environ
r, l = i.evaluer("16000000000700,4")
assert r == "16000000000700" # 1,6*10^13 environ
def test_issue_278():
i = Interprete(verbose=VERBOSE)
i.evaluer("delta = 25")
r, l = i.evaluer('delta')
assertEqual(r, '25')
i.evaluer('del delta')
r, l = i.evaluer('delta')
assertEqual(r, 'delta')
def test_issue_206():
i = Interprete(verbose = VERBOSE)
etat_interne = \
u"""_ = 0
@derniers_resultats = [
're(x)',
]"""
i.load_state(etat_interne)
i.evaluer("-1+\i\sqrt{3}")
assertDernier(i, '-1 + 3**(1/2)*I')
i.evaluer('-x**2 + 2*x - 3>>factor')
assertDernier(i, '-x**2 + 2*x - 3')
def test_systeme():
i = Interprete(verbose = VERBOSE, adapter_separateur=False)
i.evaluer("g(x)=a x^3+b x^2 + c x + d")
i.evaluer("resoudre(g(-3)=2 et g(1)=6 et g(5)=3 et g'(1)=0)")
res = i.derniers_resultats[-1]
assert isinstance(res, dict)
assertEqual(res, {S('a'): S(1)/128, S('b'): -S(31)/128, S('c'): S(59)/128, S('d'): S(739)/128})
def test_issue_206():
i = Interprete(verbose = VERBOSE)
etat_interne = \
u"""_ = 0
@derniers_resultats = [
're(x)',
]"""
i.load_state(etat_interne)
i.evaluer("-1+\i\sqrt{3}")
assertDernier(i, '-1 + 3**(1/2)*I')
i.evaluer('-x**2 + 2*x - 3>>factor')
assertDernier(i, '-x**2 + 2*x - 3')
def test_ecriture_fraction_decimaux():
# En interne, les décimaux sont remplacés par des fractions.
# Cela évite la perte de précision inhérente aux calculs avec flottants.
# Ce remplacement doit être autant que possible transparent pour l'utilisateur,
# qui, s'il rentre des décimaux, doit voir des décimaux s'afficher.
i = Interprete(verbose=VERBOSE)
r, l = i.evaluer('0,3+0,8')
assertEqual(r, '1,1')
r, l = i.evaluer('a=1,7')
assertEqual(r, '1,7')
r, l = i.evaluer("f(x)=0,3x+0,7")
assertEqual(r, 'x -> 0,3 x + 0,7')
# Le calcul suivant ne fonctionne pas en utilisant en interne des flottants
# (le coefficient devant le x^2 n'est pas tout à fait nul lorsqu'on développe).
# En utilisant en interne des fractions, par contre, le calcul est exact.
i.evaluer("C(x)=0,003 x^2 + 60 x + 48000")
r, l = i.evaluer("expand(C(x+1)-C(x))")
assertEqual(r, '0,006 x + 60,003')
r, l = i.evaluer('frac(0,5)')
assertEqual(r, '1/2')
r, l = i.evaluer('frac(0,166666666666666667)')
assertEqual(r, '1/6')
r, l = i.evaluer('frac(0,5x+0.3333333333333333)')
assertEqual(r, 'x/2 + 1/3')
def test_load_state():
i = Interprete(verbose=VERBOSE)
etat_interne = \
"""_ = 2/5
@derniers_resultats = [
'x^2',
'2/5',
]"""
i.load_state(etat_interne)
i.evaluer('_')
assertDernier(i, '2/5')
i.evaluer('_1')
assertDernier(i, 'x^2')
def test_issue_206_bis():
i = Interprete(verbose = VERBOSE)
etat_interne = \
u"""_ = 0
@derniers_resultats = [
'Abs(x)',
]"""
i.load_state(etat_interne)
i.evaluer('abs(-24/5 - 2 i/5)')
assertDernier(i, '2*145**(1/2)/5')
def test_issue_206_ter():
i = Interprete(verbose = VERBOSE)
etat_interne = \
u"""_ = 0
@derniers_resultats = [
'atan2(x, y)',
]"""
i.load_state(etat_interne)
i.evaluer('ln(9)-2ln(3)')
assertDernier(i, '0')
def assert_resultat(s, resultat, latex = None, **parametres):
i = Interprete(verbose = VERBOSE, **parametres)
r, l = i.evaluer(s)
if r != resultat:
i = Interprete(verbose = True, **parametres)
r, l = i.evaluer(s)
print "ERREUR (" + s + "): ", r, " != ", resultat
assert(r == resultat)
if latex is not None:
latex = "$" + latex + "$"
if l != latex:
print "ERREUR (" + s + "): ", l, " != ", latex
assert(l == latex)
def test_issue_185():
i = Interprete(verbose = VERBOSE)
i.evaluer("a=1+I")
i.evaluer("a z")
assertDernier(i, 'z*(1 + I)')
def test_issue_185():
i = Interprete(verbose = VERBOSE)
i.evaluer("a=1+I")
i.evaluer("a z")
assertDernier(i, 'z*(1 + I)')
def test_session():
i = Interprete(verbose = VERBOSE)
i.evaluer("1+7")
i.evaluer("x-3")
i.evaluer("ans()+ans(1)")
assertDernier(i, "x + 5")
i.evaluer("f(x, y, z)=2x+3y-z")
i.evaluer("f(-1, 5, a)")
assertDernier(i, "-a + 13")
i.evaluer("f(x)=x^2-7x+3")
i.evaluer("f'(x)")
assertDernier(i, "2*x - 7")
# Noms réservés
assertRaises(NameError, i.evaluer, "e=3")
assertRaises(NameError, i.evaluer, "pi=3")
assertRaises(NameError, i.evaluer, "i=3")
assertRaises(NameError, i.evaluer, "oo=3")
assertRaises(NameError, i.evaluer, "factorise=3")
# Etc.
# Test des générateurs
i.evaluer('f(x)=x+3')
i.evaluer('[f(j) for j in range(1,11)]')
assertDernier(i, '[4, 5, 6, 7, 8, 9, 10, 11, 12, 13]')
i.evaluer('tuple(i for i in range(7))')
assertDernier(i, '(0, 1, 2, 3, 4, 5, 6)')
i.evaluer('[j for j in range(7)]')
assertDernier(i, '[0, 1, 2, 3, 4, 5, 6]')
# _11 is an alias for ans(11)
i.evaluer('_11 == _')
assertDernier(i, 'True')
i.evaluer('_7')
assertDernier(i, "2*x - 7")
# _ is an alias for ans(-1), __ is an alias for ans(-2), and so on.
i.evaluer('_ == -7 + 2*x')
assertDernier(i, 'True')
i.evaluer('__')
assertDernier(i, "2*x - 7")
i.evaluer('______') # ans(-6)
assertDernier(i, '(0, 1, 2, 3, 4, 5, 6)')
# Affichage des chaînes en mode text (et non math)
i.evaluer('"Bonjour !"')
assert i.latex_dernier_resultat == u'\u201CBonjour !\u201D'
i.changer_separateurs = True
resultat, latex = i.evaluer('1,2')
assert resultat == '1,2'
assertAlmostEqual(i.derniers_resultats[-1], 1.2)
resultat, latex = i.evaluer('"1,2"')
assert resultat == '"1,2"'
i.evaluer('?aide')
i.evaluer('aide?')
i.evaluer('aide(aide)')
msg_aide = u"\n== Aide sur aide ==\nRetourne (si possible) de l'aide sur la fonction saisie."
resultats = i.derniers_resultats
assert resultats[-3:] == [msg_aide, msg_aide, msg_aide]
# LaTeX
latex = i.evaluer("gamma(x)")[1]
assert latex == r'$\mathrm{\Gamma}\left(x\right)$'
def test_session():
i = Interprete(verbose=VERBOSE)
i.evaluer("1+7")
i.evaluer("x-3")
i.evaluer("ans()+ans(1)")
assertDernier(i, "x + 5")
i.evaluer("f(x, y, z)=2x+3y-z")
i.evaluer("f(-1, 5, a)")
assertDernier(i, "-a + 13")
i.evaluer("f(x)=x^2-7x+3")
i.evaluer("f'(x)")
assertDernier(i, "2*x - 7")
# Noms réservés
assertRaises(NameError, i.evaluer, "e=3")
assertRaises(NameError, i.evaluer, "pi=3")
assertRaises(NameError, i.evaluer, "i=3")
assertRaises(NameError, i.evaluer, "oo=3")
assertRaises(NameError, i.evaluer, "factorise=3")
# Etc.
# Test des générateurs
i.evaluer('f(x)=x+3')
# La ligne suivante doit simplement s'exécuter sans erreur.
i.evaluer('[f for j in range(1, 11)]')
i.evaluer('[f(j) for j in range(1, 11)]')
assertDernier(i, '[4, 5, 6, 7, 8, 9, 10, 11, 12, 13]')
i.evaluer('tuple(i for i in range(7))')
assertDernier(i, '(0, 1, 2, 3, 4, 5, 6)')
i.evaluer('[j for j in range(7)]')
assertDernier(i, '[0, 1, 2, 3, 4, 5, 6]')
# _12 is an alias for ans(12)
i.evaluer('_12 == _')
assertDernier(i, 'True')
i.evaluer('_7')
assertDernier(i, "2*x - 7")
# _ is an alias for ans(-1), __ is an alias for ans(-2), and so on.
i.evaluer('_ == -7 + 2*x')
assertDernier(i, 'True')
i.evaluer('__')
assertDernier(i, "2*x - 7")
i.evaluer('______') # ans(-6)
assertDernier(i, '(0, 1, 2, 3, 4, 5, 6)')
# Affichage des chaînes en mode text (et non math)
i.evaluer('"Bonjour !"')
assert i.latex_dernier_resultat == '\u201CBonjour !\u201D'
# Virgule comme séparateur décimal
resultat, latex = i.evaluer('1,2')
assert resultat == '1,2'
assertAlmostEqual(i.derniers_resultats[-1], 1.2)
# Avec un espace, c'est une liste (tuple) par contre
resultat, latex = i.evaluer('1, 2')
assertEqual(resultat, '(1 ; 2)')
resultat, latex = i.evaluer('"1.2"')
assert resultat == '"1.2"'
i.evaluer('?aide')
i.evaluer('aide?')
i.evaluer('aide(aide)')
msg_aide = "\n== Aide sur aide ==\nRetourne (si possible) de l'aide sur la fonction saisie."
resultats = i.derniers_resultats
assert resultats[-3:] == [msg_aide, msg_aide, msg_aide]
# LaTeX
latex = i.evaluer("gamma(x)")[1]
assertEqual(latex, r'$\Gamma\left(x\right)$')
# Vérifier qu'on ait bien ln(x) et non log(x) qui s'affiche
resultat, latex = i.evaluer('f(x)=(ln(x)+5)**2')
assertEqual(resultat, 'x -> (ln(x) + 5)^2')
assertEqual(latex, r'$x\mapsto \left(\ln(x) + 5\right)^{2}$')
def _eval2latex(code):
print("code::" + repr(code))
return Interprete(**kw).evaluer(code.strip())[1]
def test_proba_stats_advanced_API():
i = Interprete(verbose=VERBOSE)
r, l = i.evaluer('X = normal()')
r, l = i.evaluer('P(-1 < X < 1)')
r, l = i.evaluer('P(X >= 2)')
r, l = i.evaluer('P(X = 2)')
def test_sous_chaines_intactes():
i = Interprete(verbose=VERBOSE)
sous_chaine = '1.25;2.36,45'
i.evaluer("a='%s'" % sous_chaine)
assertEqual(i.vars['_'], sous_chaine)
def test_session():
i = Interprete(verbose = VERBOSE)
i.evaluer("1+7")
i.evaluer("x-3")
i.evaluer("ans()+ans(1)")
assertDernier(i, "x + 5")
i.evaluer("f(x, y, z)=2x+3y-z")
i.evaluer("f(-1, 5, a)")
assertDernier(i, "-a + 13")
i.evaluer("f(x)=x^2-7x+3")
i.evaluer("f'(x)")
assertDernier(i, "2*x - 7")
# Noms réservés
assertRaises(NameError, i.evaluer, "e=3")
assertRaises(NameError, i.evaluer, "pi=3")
assertRaises(NameError, i.evaluer, "i=3")
assertRaises(NameError, i.evaluer, "oo=3")
assertRaises(NameError, i.evaluer, "factorise=3")
# Etc.
# Test des générateurs
i.evaluer('f(x)=x+3')
i.evaluer('[f(j) for j in range(1,11)]')
assertDernier(i, '[4, 5, 6, 7, 8, 9, 10, 11, 12, 13]')
i.evaluer('tuple(i for i in range(7))')
assertDernier(i, '(0, 1, 2, 3, 4, 5, 6)')
i.evaluer('[j for j in range(7)]')
assertDernier(i, '[0, 1, 2, 3, 4, 5, 6]')
# _11 is an alias for ans(11)
i.evaluer('_11 == _')
assertDernier(i, 'True')
i.evaluer('_7')
assertDernier(i, "2*x - 7")
# _ is an alias for ans(-1), __ is an alias for ans(-2), and so on.
i.evaluer('_ == -7 + 2*x')
assertDernier(i, 'True')
i.evaluer('__')
assertDernier(i, "2*x - 7")
i.evaluer('______') # ans(-6)
assertDernier(i, '(0, 1, 2, 3, 4, 5, 6)')
# Affichage des chaînes en mode text (et non math)
i.evaluer('"Bonjour !"')
assert i.latex_dernier_resultat == u'\u201CBonjour !\u201D'
i.changer_separateurs = True
resultat, latex = i.evaluer('1,2')
assert resultat == '1,2'
assertAlmostEqual(i.derniers_resultats[-1], 1.2)
resultat, latex = i.evaluer('"1,2"')
assert resultat == '"1,2"'
i.evaluer('?aide')
i.evaluer('aide?')
i.evaluer('aide(aide)')
msg_aide = u"\n== Aide sur aide ==\nRetourne (si possible) de l'aide sur la fonction saisie."
resultats = i.derniers_resultats
assert resultats[-3:] == [msg_aide, msg_aide, msg_aide]
# LaTeX
latex = i.evaluer("gamma(x)")[1]
assert latex == r'$\mathrm{\Gamma}\left(x\right)$'
def test_issue_263():
i = Interprete(verbose=VERBOSE)
i.evaluer("A = mat([[1;2];[3;4]])")
i.evaluer("B = mat(2)")
i.evaluer("C = A*B")
assert 'C' in i.vars
r, l = i.evaluer("C")
assertEqual(r, "Matrix([\n[1 ; 2] ; \n[3 ; 4]])")
etat_interne = i.save_state()
i.clear_state()
assert 'C' not in i.vars
i.load_state(etat_interne)
assert 'C' in i.vars
r, l = i.evaluer("C")
assertEqual(r, "Matrix([\n[1 ; 2] ; \n[3 ; 4]])")
i.evaluer("A=[[0,1 ; 0,8]; [0,5; 0,5]]")
r, l = i.evaluer("[[0,3 ; 0,4]]*A")
assertEqual(r, "Matrix([[0,23 ; 0,44]])")
# ou encore [0,23 ; 0,44]
assertEqual(l, r"$\begin{pmatrix}0,23 & 0,44\end{pmatrix}$")
