How to use the pyromaths.outils.Arithmetique.pgcd function in pyromaths

def valeurs_somme_prod():  #cree 3 fractions et un tuple de signes (+,*)
    while True:
        (base1, base2) = (valeur_alea(-13, 13), valeur_alea(-13, 13))
        lepgcd = pgcd(base1, base2)
        (base1, base2) = (base1 // lepgcd, base2 // lepgcd)
        if base1 != 1 and base2 != 1:
            break
    (n2, d2) = (base1 * valeur_alea(-10, 10), abs(base2 * valeur_alea(2,
                10)))
    lepgcd = pgcd(n2, d2)
    (n2, d2) = (n2 // lepgcd, d2 // lepgcd)
    (n3, d3) = (base2 * valeur_alea(-10, 10), abs(base1 * valeur_alea(2,
                10)))
    lepgcd = pgcd(n3, d3)
    (n3, d3) = (n3 // lepgcd, d3 // lepgcd)
    (n1, d1) = (base1 * valeur_alea(-10, 10), abs(pgcd(d2, base2 *
                valeur_alea(2, 10))))
    lepgcd = pgcd(n1, d1)
    (n1, d1) = (n1 // lepgcd, d1 // lepgcd)
    if randrange(2) == 0:
        s1 = '+'
    else:
        s1 = '-'
    if randrange(2) == 0:
        s2 = '*'
    else:
        s2 = ':'
    if s2 == '*':
        return ((n1, d1), (n2, d2), (n3, d3), (s1, s2))
    else:

def simprad(liste):
    """Simplifie la fraction d'un angle en radians. Le paramètre est une liste d'entiers, pour représenter une fraction."""
    p = pgcd(liste[0],liste[1])
    return [f // p for f in liste]

def valeurs_quotient_frac():  # cree 4 fractions et un tuple de signes (+,+)
    while True:
        (n1, d1) = (valeur_alea(-10, 10), valeur_alea(2, 10))
        lepgcd = pgcd(n1, d1)
        if lepgcd != n1 and lepgcd != d1:
            break
    (n1, d1) = (n1 // lepgcd, d1 // lepgcd)
    while True:
        (n3, d3) = (valeur_alea(-10, 10), valeur_alea(2, 10))
        lepgcd = pgcd(n3, d3)
        if lepgcd != n3 and lepgcd != d3:
            break
    (n3, d3) = (n3 // lepgcd, d3 // lepgcd)
    (n2, n4) = (valeur_alea(1, 10), valeur_alea(1, 10))
    if randrange(2) == 0:
        s1 = '+'
    else:
        s1 = '-'
    if randrange(2) == 0:
        s2 = '+'

def valeurs_produit():
    l = []

    for dummy in range(4):
        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)

        l.append(_('Fraction(%s, %s)*Fraction(%s,%s)') % (n1 * a, d1 * b, n2 * b, d2 * a))

    return l

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 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:

"}{" + decimaux(listenombres[2] / (fauxpgcd * pgcdcompl)) + "}.$")

    ### Question 5

    num = [randint(6,50), randint(6,50)]
    exo.append(u"\\item Calculer $\\dfrac{" + decimaux(num[0]) + "}{" +
            decimaux(listenombres[1]) + "} + \\dfrac{" + decimaux(num[1]) + "}{" +
            decimaux(listenombres[2]) + "}$.")

    mult1 = vraippcm / listenombres[1]
    mult2 = vraippcm / listenombres[2]

    num1 = mult1 * num[0]
    num2 = mult2 * num[1]

    simplfin = pgcd(num1+num2,vraippcm)

    if simplfin != 1:
        simpl = "{\\scriptstyle \\div " + decimaux(simplfin) + "}"
        result = " = \\dfrac{" + decimaux((num1+num2)/simplfin) + "}{" + \
              decimaux((vraippcm)/simplfin) + "}"
    else:
        simpl = ""
        result = ""

    cor.append(u"\\item Il faut mettre les fractions au même dénominateur. Grâce"
            + u"à la question 2), nous avons déjà un dénominateur commun : " +
            u"le PPCM des nombres " + decimaux(listenombres[1]) + " et " +
            decimaux(listenombres[2]) + u", qui est par définition le plus petit"
            + u"multiple commun de ces deux nombres.\\par")
    cor.append(u"$\\dfrac{" + decimaux(num[0]) + "{\\scriptstyle \\times " +
            decimaux(mult1) + "}}{" + decimaux(listenombres[1]) +

# ## Question 1
    exo = ["\\exercice", '\\begin{enumerate}', u"\\item Donner la décomposition" + 
            u" en facteurs premiers des nombres suivants, et préciser quand il" + 
            u" s\'agit d\'un nombre premier :\\par"]
    cor = ["\\exercice*", '\\begin{enumerate}', u"\\item Donner la décomposition"
            + u" en facteurs premiers des nombres suivants, et préciser quand il"
            + u" s\'agit d\'un nombre premier :\\par"]

    prime = premiers[randint(10, 167)]

    fauxpgcd = randint(1, 101)
    fauxpgcdfactor = factoriseTex(fauxpgcd)[0]

    complementaires = [randint(6, 50), randint(6, 50)]
    pgcdcompl = pgcd(complementaires[0], complementaires[1])
    pgcdcomplfact = factoriseTex(pgcdcompl)[0]

    if pgcdcompl != 1:
        facteurs = pgcdcomplfact + fauxpgcdfactor
        facteurs.sort()
    else:
        facteurs = fauxpgcdfactor

    autresnombres = [randint(51, 999), randint(51, 999)]

    listenombres = [prime, complementaires[0] * fauxpgcd, complementaires[1] * 
            fauxpgcd, ] + autresnombres
    melange = [prime, complementaires[0] * fauxpgcd, complementaires[1] * 
            fauxpgcd, ] + autresnombres
    shuffle(melange)

break
    while True:
        (n1, n2) = ((b1 * valeur_alea(2, maxi)) * 10 ** randrange(-emax,
                    emax), (b2 * valeur_alea(2, maxi)) * 10 ** randrange(-emax,
                    emax))
        n3 = ((b1 * b2) * choice((2, 4, 5, 8))) * 10 ** randrange(-emax,
                emax)
        if int(floor(log10(((n1 * n2) * 1.) / n3))) != 0 and n1 != 1 and \
            n2 != 1 and n3 != 1:
            break
    (e1, e2, e3, e4) = (valeur_alea(-10, 10), valeur_alea(-10, 10),
                        valeur_alea(2, 10), valeur_alea(2, 5))
    a = verifie_type((n1, n2, n3, e1, e2, e3, e4))
    while True:
        (b1, b2) = (valeur_alea(2, maxi), valeur_alea(2, maxi))
        (b1, b2) = (b1 / pgcd(b1, b2), b2 / pgcd(b1, b2))
        if b1 != 1 and b2 != 1:
            break
    (n1, n2) = ((b1 * valeur_alea(2, maxi)) * 10 ** randrange(-emax, emax + 
                1), (b2 * valeur_alea(2, maxi)) * 10 ** randrange(-emax,
                emax + 1))
    n3 = ((b1 * b2) * choice((1, 2, 4, 5, 8))) * 10 ** randrange(-emax,
            emax + 1)
    (e1, e2, e3, e4) = (valeur_alea(-10, 10), valeur_alea(-10, 10),
                        valeur_alea(-10, -2), valeur_alea(2, 5))
    b = verifie_type((n1, n2, n3, e1, e2, e3, e4))
    return (a, b)