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_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_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_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_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 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(): 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 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_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_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_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_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_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_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_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_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}$")
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}$')