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_Parallelogramme():
    A = rand_pt()
    B = rand_pt()
    C = rand_pt()
    p = Parallelogramme(A, B, C)
    D = p.sommets[3]
    assertEqual(Vecteur(A, B), Vecteur(D, C))

def test_Decim():
    expr = S.One*Decim('0.3')
    assert isinstance(expr,  Decim), type(expr)
    expr = Decim('0.3')*x
    assert isinstance(expr.args[0],  Decim), type(expr.args[0])
    assertEqual(repr(Decim(1, 2)*x + Decim(1, 5)), '0.5*x + 0.2')
    assertEqual(repr(Decim(1, 2)*Rational(1, 5)), '0.1')

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_Droite_equation():
    a = randint(50) - randint(50) + 0.1  # afin que a ne soit pas nul
    b = randint(50) - randint(50) + random()
    c = randint(50) - randint(50) + random()
    d, e, f = Droite_equation(a, b, c).equation
    assertAlmostEqual((e / d, f / d), (b / a, c / a))
    assertEqual(Droite_equation(a, 0, 0).equation[1:], (0, 0))
    assertEqual((Droite_equation(0, a, 0).equation[0], Droite_equation(
        0, a, 0).equation[2]), (0, 0))
    assert (not Droite_equation(0, 0, 0).existe)
    d = Droite_equation("y=-5/2x-3/2")
    assert (Point(0, -1.5) in d)
    assert (Point(-1, 1) in d)
    d = Droite_equation("x=2*10**2")
    assert (Point(200, -1000) in d)
    assert (Point(100, -1000) not in d)
    d = Droite_equation("2*x+2*y=1")
    assert (Point(0.5, 0) in d)
    assert (Point(1, -0.5) in d)
    d = Droite_equation("x+y=1")
    assert (Point(0, 1) in d)
    assert (Point(1, 0) in d)
    d = Droite_equation("x+2y=-2")
    assert (Point(0, -1) in d)
    assert (Point(-2, 0) in d)

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_conversion_chaine_ensemble():
    chaine = '{-(-216*2^(2/3)+4*(-3616+64*sqrt(8113))^(1/3)+2^(1/3)' \
             '*(-3616+64*sqrt(8113))^(2/3))/(16*(-3616+64*sqrt(8113))^(1/3))}'
    attendu = "Ensemble('{(-2^(1/3)*(-3616 + 64*sqrt(8113))^(2/3) " \
               "- 4*(-3616 + 64*sqrt(8113))^(1/3) + 216*2^(2/3))" \
               "/(16*(-3616 + 64*sqrt(8113))^(1/3))}')"
    resultat = repr(conversion_chaine_ensemble(chaine, utiliser_sympy=True))
    assertEqual(resultat, attendu)

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_Representant():
    A=Point(1,2)
    B=Point(2,4)
    v=Vecteur(A, B)
    w = Representant(v,  B)
    assert(w.x == v.x and w.y == v.y and w.z == v.z)
    assert(w.origine == v.point2)
    assertEqual(type(w.coordonnees),  tuple)
    assertAlmostEqual(w.extremite.coordonnees, (3, 6))
    assert(w._hierarchie < w.extremite._hierarchie < w._hierarchie + 1)

def test_Point_final():
    A = Point(random(),random())
    C = Point(random(),random())
    u = Vecteur_libre(random(),random())
    v = Vecteur(Point(random(),  random()),  Point(random(),  random()))
    w = Representant(Vecteur(Point(random(),  random()),  Point(random(),  random())),  A)
    F = Point_final(C,  (u, v, w), (-2, 1.5, 4))
    assertEqual(type(F.coordonnees),  tuple)
    assertAlmostEqual(F.x,  C.x -2*u.x+1.5*v.x+4*w.x)
    assertAlmostEqual(F.y,  C.y -2*u.y+1.5*v.y+4*w.y)

def test_Milieu():
    A = Point(1,2)
    B = Point(2,4)
    I = Milieu(A,B)
    assert(I.x == (A.x+B.x)/2 and I.y == (A.y+B.y)/2)
    assertEqual(type(I.coordonnees),  tuple)
    C = Point('1/3', '1')
    D = Point('1', '1')
    J = Milieu(C, D)
    assert(J.x == symp('2/3'))

def test_Vecteur():
    A=Point(1,2)
    B=Point(2,4)
    v=Vecteur(A, B)
    assert(isinstance(v.etiquette, Label_vecteur))
    assert(v.x == 1 and v.y == 2)
    assertEqual(v.norme,  sqrt(5))
    assertEqual(type(v.coordonnees),  tuple)
    # Test du typage dynamique :
    assert(isinstance(Vecteur(1, 3), Vecteur_libre))
    assert(Vecteur(1, 3).coordonnees == (1, 3))

def test_Somme_vecteurs():
    A=Point(1,2)
    B=Point(2,4)
    v=Vecteur(A, B)
    w=Vecteur_libre(-4, 5)
    u=Representant(v, Point(1, 2))
    vec = 2*u+1*v
    vec -= 5*w
    assert(tuple(vec.coordonnees) == (23, -19))
    assertEqual(type(vec.coordonnees),  tuple)
    assertEqual(vec.coordonnees,  Somme_vecteurs((u, v, w), (2, 1, -5)).coordonnees)

def test_sauvegarde():
    f1 = Feuille(titre="Ma feuille")
    o = f1.objets
    o.A = (1, 2)
    o.B = (-1, 3)
    o.k = 7
    o.s = Segment(o.A, o.B)
    sauvegarde = f1.sauvegarder()
    f2 = Feuille(titre="Nouvelle feuille")
    f2.charger(sauvegarde)
    assertEqual(f2.objets.noms, set(['A', 'B', 'k', 's', 'dpy', 'dpx',
                                     'xmax', 'xmin', 'ymin', 'ymax']))

def test_sympy():
    x = Symbol('x', real=True)
    assert -oo < oo
    assert not(-1.5 < -oo)
    assert (1 - exp(x)).is_negative is None
    assert Matrix([[1, 2], [3, 4]])**Integer(2) == Matrix([[7, 10], [15, 22]])
    assertAlmostEqual(E._evalf(50), math.e)
    assert solve(1/x, x) == [] # issue 1694
    assert solve(-(1 + x)/(2 + x)**2 + 1/(2 + x), x) == [] # issue 1694
    assert limit(1 + 1/x, x, 0, dir='-') == -oo
    assert limit(1/x**2, x, 0, dir='-') == oo
    assert sympify('45') == 45 # issue 2508
    assertEqual(solve((2*x + 8)*exp(-6*x), x), [-4]) # issue 10391 (FS#319)

def test_Glisseur_segment():
    A = rand_pt()
    B = rand_pt()
    s = Segment(A, B)
    M = Glisseur_segment(s)
    assert(M in s)
    M.k = 0
    assertEqual(M.k, 0)
    assertAlmostEqual(M.coordonnees, A.coordonnees)
    P = Point(*M.coordonnees)
    M.k = 1
    assertEqual(M.k, 1)
    assertAlmostEqual(M.coordonnees, B.coordonnees)
    M.k = 2
    assertEqual(M.k, 1) # 0<=k<=1 pour un segment
    assert(M in s)
    M.k = -1
    assertEqual(M.k, 0) # 0<=k<=1 pour un segment
    assert(M in s)
    M.k = 1
    Q = Point(*M.coordonnees)
    assertAlmostEqual(Droite(P, Q).equation_reduite, s.equation_reduite)
    M.k = 1.7
    M(*M.coordonnees)
    assertAlmostEqual(M.k, 1)

def test_Point():
    A = Point(1, 2)
    assert(isinstance(A.etiquette, Label_point))
    assertEqual(A.x, 1)
    assertEqual(A.y, 2)
    assertEqual(type(A.coordonnees),  tuple)
    A.x = 5
    A.y = 7
    assertEqual(A.coordonnees, (5, 7))
    assert(A.mode_affichage == NOM)
    # Test du typage dynamique
    d = Droite(rand_pt(), rand_pt())
    B = Point(d)
    assert(isinstance(B, Glisseur_droite))
    c = Cercle(A, 3)
    C = Point(c)
    assert(isinstance(C, Glisseur_cercle))
    d = Demidroite(rand_pt(), rand_pt())
    B = Point(d)
    assert(isinstance(B, Glisseur_demidroite))
    s = Segment(rand_pt(), rand_pt())
    B = Point(s)
    assert(isinstance(B, Glisseur_segment))
    a = Arc_points(Point(), Point(1, 1),  Point(1, 2))
    B = Point(a)
    assert(isinstance(B, Glisseur_arc_cercle))

def test_Projete_arc_cercle():
    O = Point(23.15, -12.75)
    A = Point(-12.5, 7.14)
    B = Point(7.15, 8.64)
    a = Arc_cercle(O, A, B)
    M = rand_pt()
    P = Projete_arc_cercle(M, a)
    assert(P in a)
    M.coordonnees = a.centre.coordonnees
    assert(not P.existe)
    M.coordonnees = -17.826266675199999, 11.760911186
    assert(type(P.coordonnees) is tuple)
    assertAlmostEqual(A.coordonnees, P.coordonnees)
    assertEqual(A, P)

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_Segment():
    A = Point(4.5,  7.3)
    B = Point(4,  2.1)
    s = Segment(A,  B)
    assert(isinstance(s.etiquette, Label_segment))
    assertAlmostEqual(s.longueur, sqrt((B.x - A.x)**2 + (B.y - A.y)**2))
    I = Milieu(s.point1,  s.point2)
    assertEqual(I.coordonnees,  ((A.x+B.x)/2, (A.y+B.y)/2))
    M = Barycentre((A,  1),  (B,  -2))
    N = Barycentre((A,  -2),  (B,  1))
    assert(I in s)
    assert(M not in s)
    assert(N not in s)
    assert(s.style("legende") == RIEN)