def moins_dec(nombre_min, nombre_max):
    b = Arithmetique.valeur_alea(nombre_min*10, nombre_max*10)
    a = Arithmetique.valeur_alea(nombre_min*10, nombre_max*10)
    if a >=b:
        return (a/10.0, b/10.0)
    else:
        return (b/10.0, a/10.0)
def moins(nombre_min, nombre_max):
    b = Arithmetique.valeur_alea(nombre_min, nombre_max)
    a = Arithmetique.valeur_alea(nombre_min, nombre_max)
    if a >=b:
        return (a, b)
    else:
        return (b, a)
Ejemplo n.º 3
0
def valeurs(nbre_min, nbre_max, nbre_decimal_1, nbre_decimal_2):
    while 1:
        nba = Arithmetique.valeur_alea(nbre_min*10**nbre_decimal_1, nbre_max*10**nbre_decimal_1)
        if nba - (nba // 10) * 10:
            break
    while 1:
        nbb = Arithmetique.valeur_alea(nbre_min*10**nbre_decimal_2, nbre_max*10**nbre_decimal_2)
        if nbb - (nbb // 10) * 10:
            break
    nba = nba * 10 ** -nbre_decimal_1
    nbb = nbb * 10 ** -nbre_decimal_2
    deca = [str(nba)[i] for i in range(len(str(nba)))]
    decb = [str(nbb)[i] for i in range(len(str(nbb)))]
    if deca.count('.'):
        posa = deca.index('.')
    else:
        posa = len(deca)
    if decb.count('.'):
        posb = decb.index('.')
    else:
        posb = len(decb)

    lavtvirg = max(posa, posb)
    laprvirg = max(len(deca) - posa, len(decb) - posb)
    return (nba, nbb, deca, decb, lavtvirg, laprvirg)
def div(nombre_min, nombre_max):
    # on trouve a et b en valeur absolue
    a_absolu = 2
    while Arithmetique.premier(a_absolu):
        a_absolu = abs(Arithmetique.valeur_alea(nombre_min, nombre_max))
    decomposition_a_absolu = Arithmetique.factor(a_absolu)
    nbre_facteur_a_absolu = len(decomposition_a_absolu)
    decomposition_b_absolu = random.sample(decomposition_a_absolu,random.randrange(1,len(decomposition_a_absolu)))
    b_absolu = 1
    for facteur in  decomposition_b_absolu:
        b_absolu = b_absolu * facteur
    # on choisit le signe possible pour a et b
    a_possible = [-a_absolu , a_absolu]
    b_possible = [-b_absolu , b_absolu]

    if a_possible[1] < nombre_max:
        if nombre_min < a_possible[0]:
            a = a_possible[random.randrange(2)]
        else:
            a = a_possible[1]
    else:
        a = a_possible[0]

    if b_possible[1] < nombre_max:
        if nombre_min < b_possible[0]:
            b = b_possible[random.randrange(2)]
        else:
            b = b_possible[1]
    else:
        b = b_possible[0]

    return (a, b)
def valeurs_priorites_fractions(nb, nombre_min, nombre_max, entier=1):  # renvoie les 2 listes contenant les opérateurs et les opérandes.
    listoperateurs = ["+", "*", "-", "/", '(', '(', '(', '(', ')', ')', ')', ')' ]
    loperateurs = []
    loperandes = []
    i = 0  #nombre d'opérateurs créés
    p = 0  #nombre de parenthèses ouvertes
    cpt = 0  #compteur pour éviter que le programme ne boucle.
    while i < nb - 1:
        cpt = cpt + 1
        if cpt > 10:  #On recommence
            (cpt, i, p, loperateurs) = (0, 0, 0, [])
        if p:
            if loperateurs[-1] == '(':  # On n'écrit pas 2 parenthèses à suivre
                operateur = listoperateurs[random.randrange(4)]
            else:
                operateur = listoperateurs[random.randrange(12)]
        elif loperateurs == []:# On ne commence pas par une parenthèse
            operateur = listoperateurs[random.randrange(4)]
        else:
            operateur = listoperateurs[random.randrange(8)]
        if nb > 3:
            test = ('-*/').find(operateur) >= 0 and loperateurs.count(operateur) < 1 or operateur == "+" and loperateurs.count(operateur) < 2
        else:
            test = ('-*/+').find(operateur) >= 0 and loperateurs.count(operateur) < 1
        if test: #On n'accepte pas plus de 1 produit, différence, quotient et de 2 sommes ou parenthèses par calcul.
            if i == 0 or loperateurs[-1] != '(' or ('*/').find(operateur) <  0:  #pas de * ou / dans une parenthèse.
                i = i + 1
                loperateurs.append(operateur)
        elif operateur == '(' and (')+').find(loperateurs[-1]) < 0: #Il ne peut y avoir de ( après une ) ou après un +
            p = p + 1
            loperateurs.append(operateur)
        elif operateur == ')':
            p = p - 1
            loperateurs.append(operateur)
    while p > 0:
        loperateurs.append(')')
        p = p - 1
    loperandes = []
    for i in range(nb):
        (n, d) = (2, 1)
        while  abs(d) == 1:
            n = Arithmetique.valeur_alea(nombre_min, nombre_max)
            d = Arithmetique.valeur_alea(nombre_min, nombre_max)
        loperandes.append(Fractions(n, d))
    exercice = [loperandes[0]]
    i = 1
    j = 0
    while i < len(loperandes) or j < len(loperateurs):
        if j < len(loperateurs):
            exercice.append(loperateurs[j])
            j = j + 1
        while j < len(loperateurs) and (loperateurs[j] == '(' or  loperateurs[j - 1] == ')'):
            exercice.append(loperateurs[j])
            j = j + 1
        if i < len(loperandes):
            exercice.append(loperandes[i])
            i = i + 1
    return exercice
Ejemplo n.º 6
0
def valeurs_quot(nbre_min, nbre_max, nbre_decimal):
    while 1:
        nba = Arithmetique.valeur_alea(nbre_min*10**nbre_decimal, nbre_max*10**nbre_decimal)
        if nba - (nba // 10) * 10:
            break
    puisa = - nbre_decimal
    nbb = Arithmetique.valeur_alea(nbre_min, nbre_max)

    return (nba, nbb, puisa)
def valeurs_prod():
    while 1:
        nba = Arithmetique.valeur_alea(101, 9999)
        if nba - (nba // 10) * 10:
            break
    puisa = Arithmetique.valeur_alea(-3, -1)
    while 1:
        nbb = Arithmetique.valeur_alea(101, 999)
        if nbb - (nbb // 10) * 10:
            break
    puisb = Arithmetique.valeur_alea(-3, -1)
    return (nba, nbb, puisa, puisb)
Ejemplo n.º 8
0
def valeurs_prod(nbre_min, nbre_max, nbre_decimal_1 , nbre_decimal_2):
    while 1:
        nba = Arithmetique.valeur_alea(nbre_min*10**nbre_decimal_1, nbre_max*10**nbre_decimal_1)
        if nba - (nba // 10) * 10:
            break
    puisa = - nbre_decimal_1
    while 1:
        nbb = Arithmetique.valeur_alea(nbre_min*10**nbre_decimal_2, nbre_max*10**nbre_decimal_2)
        if nbb - (nbb // 10) * 10:
            break
    puisb = - nbre_decimal_2
    return (nba, nbb, puisa, puisb)
def div_dec(nombre_min, nombre_max):
    a = 2
    while Arithmetique.premier(a):
        a = Arithmetique.valeur_alea(nombre_min*10, nombre_max*10)

    decomposition_a = Arithmetique.factor(a)
    nbre_facteur_a = len(decomposition_a)
    
    decomposition_b = random.sample(decomposition_a,random.randrange(1,len(decomposition_a)))
    b = 1
    for facteur in  decomposition_b:
        b = b * facteur
    return (a/10.0, b/10.0)
def sommes_fractions(parametre):
    question = ""
    exo = [u"Effectuer les calculs suivants et donner le résultat sous la forme d'une fraction simplifiée :",
           "\\begin{multicols}{4}", "  \\noindent"]
    cor = [u"Effectuer les calculs suivants et donner le résultat sous la forme d'une fraction simplifiée :",
           "\\begin{multicols}{4}", "  \\noindent"]
    for i in range(8):
        if random.randrange(2):
            s = "+"
        else:
            s = "-"
        n = d = c = n2 = 2
        while Arithmetique.pgcd(n, d) > 1:
            n = random.randrange(1, 11)
            d = random.randrange(2, 11)
        while Arithmetique.pgcd(n2, d * c) > 1:
            c = random.randrange(2, 11)
            n2 = random.randrange(2, 11)
        fr1 = Fractions(n, d)
        fr2 = Fractions(n2, d * c)
        if s == "-" and (fr1 - fr2).n * (fr1 - fr2).d < 0 or s == "+" and \
            random.randrange(2):
            (fr1, fr2) = (fr2, fr1)
        exo.append("\\[ \\thenocalcul = %s%s%s \\]" % (Fractions.TeX(fr1),
                   s, Fractions.TeX(fr2)))
        cor.append("\\[ \\thenocalcul = %s%s%s \\]" % (Fractions.TeX(fr1),
                   s, Fractions.TeX(fr2)))
        if fr1.d < fr2.d:
            cor.append("\\[ \\thenocalcul = %s%s%s \\]" % (Fractions.TeX(fr1,
                       coef=c), s, Fractions.TeX(fr2)))
        else:
            cor.append("\\[ \\thenocalcul = %s%s%s \\]" % (Fractions.TeX(fr1),
                       s, Fractions.TeX(fr2, coef=c)))
        if s == "+":
            fr = fr1 + fr2
        else:
            fr = fr1 - fr2
        frs = Fractions.simplifie(fr)
        if frs.d != fr.d:
            cor.append("\\[ \\thenocalcul = %s \\]" % Fractions.TeX(frs,
                       coef=fr.d // frs.d))
            cor.append("\\[ \\boxed{\\thenocalcul = %s} \\]" %
                       Fractions.TeX(frs))
        else:
            cor.append("\\[ \\boxed{\\thenocalcul = %s} \\]" %
                       Fractions.TeX(fr))
        exo.append("\\stepcounter{nocalcul}%")
        cor.append("\\stepcounter{nocalcul}%")
    exo.append("\\end{multicols}\n")
    cor.append("\\end{multicols}\n")
    return (exo, cor, question)
def sommes_fractions_4e(nombre_min, nombre_max, level):
    while True:
        n1 = Arithmetique.valeur_alea(nombre_min, nombre_max)
        d1 = Arithmetique.valeur_alea(nombre_min, nombre_max)
        n2 = Arithmetique.valeur_alea(nombre_min, nombre_max)
        d2 = Arithmetique.valeur_alea(nombre_min, nombre_max)
        # Creation des 2 fractions
        fr1 = Fractions(n1, d1)
        fr2 = Fractions(n2, d2)
        # Sortie de boucle 
        if Arithmetique.pgcd(fr1.n, fr1.d) == 1 and Arithmetique.pgcd(fr2.n, fr2.d) == 1:
            if abs(fr1.d)== abs(fr2.d):
                # Sortie de boucle niveau 1
                if level == 1:
                    break
            else:
                if Arithmetique.pgcd(fr1.d, fr2.d) == abs(fr1.d) or Arithmetique.pgcd(fr1.d, fr2.d) == abs(fr2.d): 
                    # Sortie de boucle niveau 2
                    if level == 2:
                        break
                else: 
                    simplifiable = abs(fr1.d * fr2.d) != abs(Fractions.simplifie(fr1 + fr2).d)
                    if not simplifiable:
                        # Sortie de boucle niveau 3
                        if level == 3:
                            break
                    else:
                        # Sortie de boucle niveau 4
                        if level == 4:
                            break
    l = [fr1, '+', fr2]
    (cor, res, niveau) = OperateurPrioritaire(l, 4, solution=[])
    return ([fr1, '+', fr2], cor, res)
def valeurs(nombre_min, nombre_max, carre_parfait, non_simplifiable):
    iteration = 0
    while True:
        # generation d'un nombre entre nombre_min et nombre_max
        nombre = random.randrange(nombre_min, nombre_max)
        # decomposition en facteur premier
        decomposition = Arithmetique.factor(nombre)
        compte = [(k, decomposition.count(k)) for k in set( decomposition)]
        # les facteurs qui apparaissent 2 fois forment le carré, les autres sont le coefficient   
        (coefficient, carre) = (1, 1)
        for i in range(len(compte)):
            coefficient = coefficient * compte[i][0] ** (compte[i][1] % 2)
            carre = carre * compte[i][0] ** (compte[i][1] / 2)
        #Choix
        if carre_parfait == 1 and non_simplifiable == 0 and coefficient == 1:
            break
        if carre_parfait == 0 and non_simplifiable == 1 and carre == 1:
            break
        if carre_parfait == 0 and non_simplifiable == 0 and coefficient != 1 and carre != 1:
            break
        # Controle du bouclage si l'utilisateur fait un choix de valeur min et max absurde
        if iteration > 10000:
            (coefficient, carre) = (0, 0)
            break
    return coefficient, carre
def valeurs_units():
    """
    renvoie les valeurs pour les conversions d'unités
    """

    a = Arithmetique.valeur_alea(101, 999)
    p = random.randrange(-2, 0)
    unit = random.randrange(3)
    if unit:
        #mètres ou grammes, on peut utiliser les k
        imax = 7
    else:
        #Litres, donc pas de kL
        imax = 6

    div0 = random.randrange(imax + p)

    while 1:
        div1 = random.randrange(imax)
        if div0 != div1:
            break

    if not unit: #Litres, donc pas de kL donc on décale d'un rang
        div0, div1 = div0 + 1, div1 + 1

    return (a, p, unit, div0, div1)
def produits_fractions_4e(nombre_min, nombre_max, level):
    while True:
        n1=Arithmetique.valeur_alea(nombre_min, nombre_max)
        d1=Arithmetique.valeur_alea(nombre_min, nombre_max)
        n2=Arithmetique.valeur_alea(nombre_min, nombre_max)
        d2=Arithmetique.valeur_alea(nombre_min, nombre_max)
        fr1 = Fractions(n1, d1)
        fr2 = Fractions(n2, d2)
        simplifiable = abs(fr1.d * fr2.n) !=   Fractions.simplifie(fr1 / fr2).d
        if not simplifiable:
            if level ==1:
                break
        else:
            if level ==2:
                break
    l = [fr1, '/', fr2]
    (cor, res, niveau) = OperateurPrioritaire(l, 4, solution=[])
    return (l, cor, res)
def valeurs10(nb):  # renvoie nb valeur de chaque type : *10, /10, *0.1
    l = []
    for i in range(nb):
        if random.randrange(0, 1):
            l.append((Arithmetique.valeur_alea(111, 999) * 10 ** random.randrange(-3,
                     0), 10 ** (i + 1), '*'))
        else:
            l.append((10 ** (i + 1), Arithmetique.valeur_alea(111, 999) * 10 **
                     random.randrange(-3, 0), '*'))
    for i in range(nb):
        l.append((Arithmetique.valeur_alea(111, 999) * 10 ** random.randrange(-3,
                 0), 10 ** (i + 1), '/'))
    for i in range(nb):
        if random.randrange(0, 1):
            l.append((Arithmetique.valeur_alea(111, 999) * 10 ** random.randrange(-3,
                     0), 10 ** (-i - 1), '*'))
        else:
            l.append((10 ** (-i - 1), Arithmetique.valeur_alea(111, 999) * 10 **
                     random.randrange(-3, 0), '*'))
    return l
def produits_fractions(parametre):
    question = ""
    exo = [u"Effectuer les calculs suivants et donner le résultat sous la forme d'une fraction simplifiée :",
           "\\begin{multicols}{4}", "  \\noindent"]
    cor = [u"Effectuer les calculs suivants et donner le résultat sous la forme d'une fraction simplifiée :",
           "\\begin{multicols}{4}", "  \\noindent"]
    for i in range(8):
        n1=d1=n2=d2=a=b=2
        while Arithmetique.pgcd(a,b)>1:
            a=random.randrange(1,11)
            b=random.randrange(2,11)
        while Arithmetique.pgcd(n1*a,d1*b)>1:
            n1=random.randrange(1,11)
            d1=random.randrange(2,11)
        while Arithmetique.pgcd(n2*b,d2*a)>1:
            n2=random.randrange(1,11)
            d2=random.randrange(2,11)

        fr1 = Fractions(n1*a, d1*b)
        fr2 = Fractions(n2*b, d2*a)
        exo.append("\\[ \\thenocalcul = %s \\times %s \\]" % (Fractions.TeX(fr1),
                   Fractions.TeX(fr2)))
        cor.append("\\[ \\thenocalcul = %s \\times %s \\]" % (Fractions.TeX(fr1),
                   Fractions.TeX(fr2)))
        fr1s = Fractions.simplifie(fr1)
        fr2s = Fractions.simplifie(fr2)
        if abs(fr1s.d) < abs(fr1.d) or abs(fr2s.d) < abs(fr2.d):
            cor.append("\\[ \\thenocalcul = %s \\times %s \\]" % (Fractions.TeXSimplifie(fr1),
                       Fractions.TeXSimplifie(fr2)))
        fr = fr1s * fr2s
        frs = Fractions.simplifie(fr)
        if abs(frs.d) < abs(fr.d):
            cor.append("\\[ \\thenocalcul = %s \\]" % Fractions.TeXProduit(fr1s,
                       fr2s))
        cor.append("\\[ \\boxed{\\thenocalcul = %s} \\]" % Fractions.TeX(frs))
        exo.append("\\stepcounter{nocalcul}%")
        cor.append("\\stepcounter{nocalcul}%")
    exo.append("\\end{multicols}\n")
    cor.append("\\end{multicols}\n")
    return (exo, cor, question)
def valeurs():
    nba = Arithmetique.valeur_alea(111, 99999)
    while 1:
        nbb = Arithmetique.valeur_alea(111, 99999)
        if nbb - (nbb // 10) * 10:
            break
    puisb = Arithmetique.valeur_alea(-2, 0)
    nbb = nbb * 10 ** puisb
    deca = [str(nba)[i] for i in range(len(str(nba)))]
    decb = [str(nbb)[i] for i in range(len(str(nbb)))]
    if random.randrange(2):
        (nba, deca, nbb, decb) = (nbb, decb, nba, deca)
    if deca.count('.'):
        posa = deca.index('.')
    else:
        posa = len(deca)
    if decb.count('.'):
        posb = decb.index('.')
    else:
        posb = len(decb)

    lavtvirg = max(posa, posb)
    laprvirg = max(len(deca) - posa, len(decb) - posb)
    return (nba, nbb, deca, decb, lavtvirg, laprvirg)
def valeurs_produit(nombre_min, nombre_max):
    iteration = 0
    while True:
        # generation de 2 nombres entre nombre_min et nombre_max
        nombre1 = random.randrange(nombre_min, nombre_max)
        nombre2 = random.randrange(nombre_min, nombre_max)
        # decomposition en facteur premier du produit des 2 nombres
        decomposition = Arithmetique.factor(nombre1*nombre2)
        compte = [(k, decomposition.count(k)) for k in set( decomposition)]
        # les facteurs qui apparaissent 2 fois forment le carré, les autres sont le coefficient   
        (coefficient, carre) = (1, 1)
        for i in range(len(compte)):
            coefficient = coefficient * compte[i][0] ** (compte[i][1] % 2)
            carre = carre * compte[i][0] ** (compte[i][1] / 2)
        #Choix
        if coefficient != 1 and carre != 1:
            break  
        # Controle du bouclage si l'utilisateur fait un choix de valeur min et max absurde
        if iteration > 10000:
            (nombre1, nombre2, coefficient, carre, decomposition) = (0, 0, 0, 0, 0)
            break 
    return nombre1, nombre2, coefficient, carre, decomposition
def valeurs10(operation):  # renvoie nb valeur de chaque type : *10, /10, *0.1, /0.1
    l = []
    for i in range(2):
        if operation == 0:
            if random.randrange(0, 1):
                l.append((Arithmetique.valeur_alea(111, 999) * 10 ** random.randrange(-3,0), 10 ** (i + 1), '*'))
            else:
                l.append((10 ** (i + 1), Arithmetique.valeur_alea(111, 999) * 10 **random.randrange(-3, 0), '*'))
        if operation == 1:
            l.append((Arithmetique.valeur_alea(111, 999) * 10 ** random.randrange(-3,0), 10 ** (i + 1), '/'))
        if operation == 2:
            if random.randrange(0, 1):
                l.append((Arithmetique.valeur_alea(111, 999) * 10 ** random.randrange(-3,0), 10 ** (-i - 1), '*'))
            else:
                l.append((10 ** (-i - 1), Arithmetique.valeur_alea(111, 999) * 10 **random.randrange(-3, 0), '*'))
        if operation == 3:
            l.append((Arithmetique.valeur_alea(111, 999) * 10 ** random.randrange(-3,0), 10 ** (-i - 1), '/'))
    return l
def moins(pyromax):
    (a, b) = (Arithmetique.valeur_alea(-pyromax, pyromax), Arithmetique.valeur_alea(-pyromax,
              pyromax))
    return (a + b, a)
def plus(pyromax):
    (a, b) = (Arithmetique.valeur_alea(-pyromax, pyromax), Arithmetique.valeur_alea(-pyromax,
              pyromax))
    return (a, b)
def plus(valeurmax):
    (a, b) = (Arithmetique.valeur_alea(1, valeurmax), Arithmetique.valeur_alea(1,
              valeurmax))
    return (a, b)
def moins_dec(pyromax):
    (a, b) = (Arithmetique.valeur_alea(-10*pyromax, 10*pyromax)/10.0, Arithmetique.valeur_alea(-10*pyromax, 10*pyromax)/10.0)
    return (a + b, a)
def produits_fractions_4e(op, level):
    '''Choisit des valeurs aléatoires pour effectuer un produit ou un quotient de
    fractions en fonction du niveau de difficulté souhaité (de 1 à 4) et renvoie
    l'énoncé et le corrigé au format TeX

    @param op: '*' ou '/'
    @param level: niveau de difficulté :
                  1- Fractions positives non décomposables
                  2- Fractions avec des nombres relatifs non décomposables
                  3- Fractions positives à décomposer
                  4- Fractions avec des nombres relatifs à décomposer
    '''

    while True:
        (n1, d1, n2, d2) = (2, 2, 2, 2)
        while True:
            n1=d1=n2=d2=a=b=2
            if level == 3 or level == 4:
                while Arithmetique.pgcd(a,b)>1:
                    a=random.randrange(2,11)
                    b=random.randrange(2,11)
            else:
                a, b = 1, 1
            if op == "*":
                if level == 1 or level == 3:
                    while Arithmetique.pgcd(n1*a,d1*b)>1:
                        n1=random.randrange(1,11)
                        d1=random.randrange(2,11)
                    while Arithmetique.pgcd(n2*b,d2*a)>1:
                        n2=random.randrange(1,11)
                        d2=random.randrange(2,11)
                elif level == 2 or level == 4:
                    while True:
                        neg=[(-1,-1,1)[random.randrange(3)] for x in range(4)]
                        if neg[0]<0 or neg[1]<0 or neg[2]<0 or neg[3]<0:
                            break
                    while Arithmetique.pgcd(n1*a,d1*b)>1:
                        n1=random.randrange(1,11)*neg[0]
                        d1=random.randrange(2,11)*neg[1]
                    while Arithmetique.pgcd(n2*b,d2*a)>1:
                        n2=random.randrange(1,11)*neg[2]
                        d2=random.randrange(2,11)*neg[3]
                fr1 = Fractions(n1*a, d1*b)
                fr2 = Fractions(n2*b, d2*a)
                simplifiable = abs(fr1.d * fr2.d) != Fractions.simplifie(fr1 *
                                                                         fr2).d
            else:
                if level == 1 or level == 3:
                    while Arithmetique.pgcd(n1*a,d1*b)>1:
                        n1=random.randrange(1,11)
                        d1=random.randrange(2,11)
                    while Arithmetique.pgcd(n2*a,d2*b)>1:
                        n2=random.randrange(1,11)
                        d2=random.randrange(2,11)
                else:
                    while Arithmetique.pgcd(n1*a,d1*b)>1:
                        n1=random.randrange(-11,11)
                        d1=random.randrange(2,11)*(-1,1)[random.randrange(2)]
                    while Arithmetique.pgcd(n2*a,d2*b)>1:
                        n2=random.randrange(1,11)*(-1,1)[random.randrange(2)]
                        d2=random.randrange(2,11)*(-1,1)[random.randrange(2)]
                fr1 = Fractions(n1*a, d1*b)
                fr2 = Fractions(n2*a, d2*b)
                simplifiable = abs(fr1.d * fr2.n) != \
                                            Fractions.simplifie(fr1 / fr2).d
            if (simplifiable and level>2) or (not simplifiable and level<=2):
                break
        l = [fr1, op, fr2]

        (cor, res, niveau) = OperateurPrioritaire(l, 4, solution=[])
        if niveau >= 4:
            break
    return (l, cor, res)
def moins(valeurmax):
    (a, b) = (Arithmetique.valeur_alea(1, valeurmax), Arithmetique.valeur_alea(1,
              valeurmax))
    return (a + b, a)
def sommes_fractions_4e(op, level):
    '''Choisit des valeurs aléatoires pour effectuer une somme ou une différence
    de fractions en fonction du niveau de difficulté souhaité (de 1 à 4) et renvoie
    l'énoncé et le corrigé au format TeX

    @param op: '+' ou '-'
    @param level: niveau de difficulté :
                  1- Fractions positives et dénominateur de l'une multiple de l'autre
                  2- Fractions positives et dénominateurs non multiples
                  3- Fractions avec des nombres relatifs
                  4- Fractions avec des nombres relatifs et résultats simplifiable
    '''

    while True:
        (n1, d1, n2, d2) = (2, 2, 2, 2)
#        import pdb; pdb.set_trace()
        while True:
            if level == 1:
                n1 = random.randrange(1, 16)
                d1 = random.randrange(1, 9)
                n2 = random.randrange(1, 16)
                d2 = d1*random.randrange(2, 11)
                if random.randrange(2):
                    d1, d2 = d2, d1
            elif level == 2:
                n1 = Arithmetique.valeur_alea(1, 16)
                d1 = Arithmetique.valeur_alea(1, 40)
                n2 = Arithmetique.valeur_alea(1, 16)
                d2 = Arithmetique.valeur_alea(1, 40)
            else:
                while True:
                    neg=[(-1,1)[random.randrange(2)] for x in range(4)]
                    if neg[0]<0 or neg[1]<0 or neg[2]<0 or neg[3]<0:
                        break
                n1 = random.randrange(1, 16)*neg[0]
                d1 = random.randrange(1, 40)*neg[1]
                n2 = random.randrange(1, 16)*neg[2]
                d2 = random.randrange(1, 40)*neg[3]
            fr1 = Fractions(n1, d1)
            fr2 = Fractions(n2, d2)
            if Arithmetique.pgcd(fr1.n, fr1.d) == 1 and \
                Arithmetique.pgcd(fr2.n, fr2.d) == 1 and \
                (level == 1 or (Arithmetique.pgcd(fr1.d, fr2.d) != abs(fr1.d) \
                                and Arithmetique.pgcd(fr1.d, fr2.d) != abs(fr2.d))):
                if op == "+":
                    simplifiable = abs(fr1.d * fr2.d) != \
                                        abs(Fractions.simplifie(fr1 + fr2).d)
                else:
                    simplifiable = abs(fr1.d * fr2.d) != \
                                        abs(Fractions.simplifie(fr1 - fr2).d)
                if level == 1 or (simplifiable and level == 4) or \
                                            (not simplifiable and level < 4):
                    break

        l = [fr1, op, fr2]
        (cor, res, niveau) = OperateurPrioritaire(l, 4, solution=[])
        if niveau >= 4:
            break
    fr1 = Fractions(n1, d1)
    fr2 = Fractions(n2, d2)
    return ([fr1, op, fr2], cor, res)
def div(valeurmax):
    (a, b) = (Arithmetique.valeur_alea(1, valeurmax), Arithmetique.valeur_alea(1,
              valeurmax))
    return (a * b, a)
def div(pyromax):
    (a, b) = (Arithmetique.valeur_alea(-pyromax, pyromax), Arithmetique.valeur_alea(-pyromax,
              pyromax))
    return (a * b, a)
def plus(nombre_min, nombre_max):
    (a, b) = (Arithmetique.valeur_alea(nombre_min, nombre_max), Arithmetique.valeur_alea(nombre_min, nombre_max))
    return (a, b)
def plus_dec(nombre_min, nombre_max):
    (a, b) = (Arithmetique.valeur_alea(nombre_min*10, nombre_max*10), Arithmetique.valeur_alea(nombre_min*10, nombre_max*10))
    return (a/10.0, b/10.0)