def test_unitaire_9(visible=False):
print("*** fraction: test_unitaire_9 ***")
a = po.polynome(mo.monome(ra.rationnel(2)))
# if visible: print(a)
b = po.polynome(mo.monome(ra.rationnel(1)))
# if visible: print(b)
c = po.polynome(mo.monome(ra.rationnel(3)))
# if visible: print(c)
d = po.polynome(mo.monome(ra.rationnel(4)))
# if visible: print(d)
f = frac.fraction(a, b)
# if visible: print(f)
g = frac.fraction(c, d)
# if visible: print(g)
r = (f + g) + (f - g) + (f * g) + (f / g)
if visible: print(r)
ok = (r == ra.rationnel(49, 6))
return ok
def test_unitaire_8(visible=False):
print("*** fraction: test_unitaire_8 ***")
a = po.polynome(mo.monome(ra.rationnel(1), "a"))
a = a.joindre(mo.monome(ra.rationnel(1), "b"))
# if visible: print(a)
b = po.polynome(mo.monome(ra.rationnel(3)))
# if visible: print(b)
c = po.polynome(mo.monome(ra.rationnel(5)))
# if visible: print(c)
f = frac.fraction(a, b)
if visible: print(f)
g = frac.fraction(c, po.polynome_un())
if visible: print(g)
r = f**g
if visible:
print(r)
print(r.joli())
ok = (r.lire_num().valuation() == ra.rationnel(1, 243))
return ok
def __neg__(self): """ polynome oppose (inverse pour l'addition) """ if self.__valide: p = polynome() for m in self.iterateur(): t = mo.monome(-m.lire_coeff(), m.lire_indet(), m.est_valide()) p = p.joindre(t) return p return polynome(mo.monome(), None, None, False)
def test_unitaire_2(visible =False):
print("*** monome: test_unitaire_2 ***")
lapin = monome.monome(rationnel.rationnel(5), "lapin")
if visible: print(lapin)
poulet = monome.monome(rationnel.rationnel(5), "poulet")
if visible: print(poulet)
poulet.fixer_coeff(rationnel.rationnel(4))
ok = (lapin < poulet)
return ok
def test_unitaire_3(visible =False):
print("*** monome: test_unitaire_3 ***")
xax = monome.monome(rationnel.rationnel(5), "xax")
if visible: print(xax)
axx = monome.monome(rationnel.rationnel(7), "axx")
if visible:
print(xax)
print(repr(xax))
ok = not (xax == axx) and \
(axx.lire_indet() == xax.lire_indet())
return ok
def test_unitaire_6(visible =False):
print("*** monome: test_unitaire_6 ***")
xaxax = monome.monome(rationnel.rationnel(5), "xaxax")
if visible:
print(xaxax)
print(xaxax.joli())
axxxx = monome.monome(rationnel.rationnel(7), "axxxx")
if visible:
print(axxxx)
print(axxxx.joli())
ok = not (xaxax == axxxx)
return ok
def joindre(self, k): """ ajouter un monome donne un nouveau polynome """ if not k.est_valide: p = polynome() p.fixer_valide(False) return p if k.lire_coeff().est_zero(): p = polynome() u = self.iterateur() for i in u: p.inserer(i) return p p = polynome() u = self.iterateur() trouve = False for i in u: if i.lire_indet() == k.lire_indet(): trouve = True c = i.lire_coeff() + k.lire_coeff() if not c.est_zero(): p.inserer(mo.monome(c, k.lire_indet())) else: p.inserer(i) if not trouve: p.inserer(k) return p
def __pow__(self, autre): """ exponentiation """ if isinstance(autre, int): autre = fraction(po.polynome(mo.monome(ra.rationnel(autre))), \ po.polynome_un()) if isinstance(autre, fraction): if (self.__valide) and (autre.__valide): a = self.__num b = self.__denom p = autre.__num q = autre.__denom pv = p.valuation().lire_num().lire_valeur() qv = q.valuation() if (p.degre() == 0) and (q.degre() == 0): if pv < 0: a, b = b, a p = -p if not qv.est_un(): return fraction(po.polynome_err(), po.polynome_un()) return fraction(a**p, b**p) return fraction(po.polynome_err(), po.polynome_un())
def test_unitaire_5(visible =False):
print("*** monome: test_unitaire_5 ***")
a = monome.monome(rationnel.rationnel(1), "?x")
if visible: print(a)
ok = True
return ok
def fraction_depuis_lettre(lettre): """ construire une fraction rationnelle depuis une lettre """ if lettre in string.ascii_letters: p = po.polynome() p = p.joindre(mo.monome(ra.rationnel(1), str(lettre))) return fraction(p, po.polynome_un()) return fraction_err()
def test_unitaire_10(visible=False):
print("*** fraction: test_unitaire_10 ***")
a = po.polynome(mo.monome(ra.rationnel(1), "a"))
a = a.joindre(mo.monome(ra.rationnel(1), "b"))
# if visible: print(a)
b = po.polynome(mo.monome(ra.rationnel(3)))
# if visible: print(b)
f = frac.fraction(a, b)
if visible: print(f)
r = f**5
if visible: print(r)
ok = (r.lire_denom().valuation().lire_num().lire_valeur() == 243)
return ok
def test_unitaire_2(visible=False):
print("*** fraction: test_unitaire_2 ***")
a = po.polynome(mo.monome(ra.rationnel(1), "a"))
b = po.polynome(mo.monome(ra.rationnel(1), "b"))
c = po.polynome(mo.monome(ra.rationnel(1), "c"))
d = po.polynome(mo.monome(ra.rationnel(1), "d"))
f = frac.fraction(a, b)
g = frac.fraction(c, d)
r = f + g
if visible:
print(r)
print(r.joli())
ok = r.est_valide()
return ok
def __init__(self, monome =mo.monome(), gauche =None, droite =None, valide =True): """ - """ if valide: self.__monome = monome else: self.__monome = None self.__valide = valide and monome.est_valide() self.__gauche = gauche self.__droite = droite
def test_unitaire_0(visible =False):
print("*** monome: test_unitaire_0 ***")
t = monome.monome()
if visible:
print(t)
print(repr(t))
ok = True
return ok
def test_unitaire_4(visible =False):
print("*** monome: test_unitaire_4 ***")
mauvais = monome.monome(rationnel.rationnel(7, -1), "MAUVAIS=", False)
if visible:
print(mauvais)
print(repr(mauvais))
ok = (not mauvais.est_valide())
return ok
def test_unitaire_12(visible=False):
print("*** fraction: test_unitaire_12 ***")
a = po.polynome(mo.monome(ra.rationnel(3)))
if visible: print(a)
b = po.polynome(mo.monome(ra.rationnel(19)))
if visible: print(b)
b = b.joindre(mo.monome(ra.rationnel(1)))
if visible: print(b)
b = b.joindre(mo.monome(ra.rationnel(-20)))
if visible: print(b)
f = frac.fraction(a, b)
if visible: print(f)
ok = (not f.est_valide())
return ok
def __pow__(self, autre): """ exponentiation """ if isinstance(autre, int): autre = polynome(mo.monome(ra.rationnel(autre))) if isinstance(autre, polynome): if (self.__valide) and (autre.__valide): v = autre.valuation() if self.est_polynome_nul() and v.lire_num().est_zero(): return polynome(mo.monome(), None, None, False) n = v.lire_num().lire_valeur() if (self.degre() != 0) and (n < 0): return polynome(mo.monome(), None, None, False) return self.__exponentiation(n) return polynome(mo.monome(), None, None, False)
def test_unitaire_3(visible=False):
print("*** fraction: test_unitaire_3 ***")
a = po.polynome(mo.monome(ra.rationnel(1), "a"))
#
# on provoque volontairement une erreur
#
b = po.polynome(mo.monome(ra.rationnel(1), "b", False))
c = po.polynome(mo.monome(ra.rationnel(1), "c"))
d = po.polynome(mo.monome(ra.rationnel(1), "d"))
f = frac.fraction(a, b)
g = frac.fraction(c, d)
r = f + g
if visible: print(r)
ok = not r.est_valide()
return ok
def test_unitaire_4(visible=False):
print("*** fraction: test_unitaire_4 ***")
a = po.polynome(mo.monome(ra.rationnel(1), "x"))
a = a.joindre(mo.monome(ra.rationnel(1)))
# if visible: print(a)
b = po.polynome(mo.monome(ra.rationnel(1), "x"))
b = b.joindre(mo.monome(ra.rationnel(3)))
# if visible: print(b)
c = po.polynome(mo.monome(ra.rationnel(-1), "xx"))
# if visible: print(c)
d = po.polynome(mo.monome(ra.rationnel(1)))
# if visible: print(d)
f = frac.fraction(a, b)
if visible: print(f)
g = frac.fraction(c, d)
if visible: print(g)
r = f + g
if visible: print(r)
ok = r.est_valide()
return ok
def reduire(self): """ reduction des coefficients """ if self.__valide: n = self.__num.ppcm_denominateurs() m = self.__denom.ppcm_denominateurs() d = ent.pgcd_entiers(n, m) r = ra.rationnel((m * n) // d) p = po.polynome() for k in self.__num.liste_decroissante_monomes(): c = k.lire_coeff() c *= r s = k.lire_indet() p = p.joindre(mo.monome(c, s)) q = po.polynome() for k in self.__denom.liste_decroissante_monomes(): c = k.lire_coeff() c *= r s = k.lire_indet() q = q.joindre(mo.monome(c, s)) if q.degre() == 0: n = q.valuation().lire_num().lire_valeur() m = q.valuation().lire_denom().lire_valeur() r = ra.rationnel(m, n) t = po.polynome() for k in p.liste_decroissante_monomes(): c = k.lire_coeff() c *= r s = k.lire_indet() t = t.joindre(mo.monome(c, s)) p = t q = po.polynome_un() self.__num = p self.__denom = q self.simplifier_coefficients()
def __mul__(self, autre): """ produit de deux polynomes """ if isinstance(autre, polynome): if (self.__valide) and (autre.__valide): p = polynome() for m in self.iterateur(): m_coeff = m.lire_coeff() m_indet = m.lire_indet() for n in autre.iterateur(): n_coeff = n.lire_coeff() n_indet = n.lire_indet() i = utile.reduction(m_indet + n_indet) k = mo.monome(m_coeff * n_coeff, i) p = p.joindre(k) return p return polynome(mo.monome(), None, None, False)
def test_unitaire_1(visible =False):
print("*** monome: test_unitaire_1 ***")
t = monome.monome(rationnel.rationnel(5, -10), "lapin")
if visible: print(t)
t.fixer_coeff(rationnel.rationnel(4))
if visible: print(t)
t.fixer_coeff(rationnel.rationnel(-4))
if visible: print(t)
ok = True
return ok
def __exponentiation(self, n): """ exponentiation (exposant entier naturel) """ p = polynome() a = self p = p.joindre(mo.monome(ra.rationnel(1))) while n > 0: if n % 2 == 1: p *= a n //= 2 a *= a return p
def __add__(self, autre): """ addition """ if isinstance(autre, polynome): if (self.__valide) and (autre.__valide): p = polynome() for m in self.iterateur(): p = p.joindre(m) for m in autre.iterateur(): p = p.joindre(m) return p return polynome(mo.monome(), None, None, False)
def simplifier_coefficients(self): """ simplifier les coefficients (numerateur et denominateur) """ if self.__valide: n = self.__num.pgcd_numerateurs() m = self.__denom.pgcd_numerateurs() d = ent.pgcd_entiers(n, m) r = ra.rationnel(d) p = po.polynome() for k in self.__num.liste_decroissante_monomes(): c = k.lire_coeff() c /= r s = k.lire_indet() p = p.joindre(mo.monome(c, s)) q = po.polynome() for k in self.__denom.liste_decroissante_monomes(): c = k.lire_coeff() c /= r s = k.lire_indet() q = q.joindre(mo.monome(c, s)) self.__num = p self.__denom = q
def fraction_un(): """ fraction unite """ return fraction(po.polynome().joindre(mo.monome(ra.rationnel(1))))
def fraction_depuis_naturel(n): """ construire une fraction rationnelle depuis un entier naturel """ p = po.polynome() p = p.joindre(mo.monome(ra.rationnel(n))) return fraction(p, po.polynome_un())
def polynome_un(): """ polynome unite """ return polynome().joindre(mo.monome(ra.rationnel(1)))
