trinome.py

Created on September 16, 2020
3.7 KB
from math import *
#-----------
#Classes
#------------

class Fraction:
    '''Classe définissant une fraction avec en paramètre le numérateur et le dénominateur'''

    def __init__(self, num=1, denum=1):

        if denum == 0:
            raise ZeroDivisionError("le dénominateur ne peux pas être 0")


        self.numerateur = num
        self.denominateur = denum
        self.quotient = num/denum


    def simplify(self):
        '''Simplification de la fraction'''
        PGCD = 1
        DivNum = diviseurs(self.numerateur)
        DivDen = diviseurs(self.denominateur)


        #Test fraction n/1
        if self.denominateur == 1:
            return(int(self.numerateur))

        #Test fraction n/n --------------> à généraliser pour tout les entiers
        if self.quotient == 1:
            return(1)

        #Recherche du PGCD et réduction
        if DivDen == False or DivNum == False :
            return("({}/{})".format(self.numerateur, self.denominateur))
        else:
            for i, elt in enumerate(DivNum):
                if elt in DivDen and elt > PGCD:
                    PGCD = DivNum[i]

        self.PGCD = PGCD
        self.numerateur = int(self.numerateur / PGCD)
        self.denominateur = int(self.denominateur / PGCD)


        return("({}/{})".format(self.numerateur, self.denominateur))



    def __add__(self, n):
        n = Fraction(n , 1)
        return Fsomme(self, n)


    def __str__(self):
        '''Affichage'''
        return "({}/{})".format(self.numerateur, self.denominateur)



#-----------------------------------------
#Fonctions manipuations Fractions
#----------------------------------------

def Fsomme(f1,f2):
    if isinstance(f1, Fraction) and isinstance(f2, Fraction):
        NewD = f1.denominateur * f2.denominateur
        NewN = (f1.numerateur*f2.denominateur) + (f2.numerateur*f1.denominateur)
        NewF = Fraction(NewN, NewD)
        return NewF

    else:
        raise ValueError("Fonction prévue pour la somme de 2 fonction")

#---------------------------------------
#Fonctions manipuations numérique
#-----------------------------------

def discriminant(a,b,c):
    return ((b**2) - (4*a*c))


def diviseurs(n):
    '''Liste des diviseurs du nombre n'''
    div = []
    i = 1

    while i <= n :
        if n % i == 0:
            div.append(i)
            div.append(round(n/i))
            i += 1

        else :
            i += 1

    if not div:
        return(False)
    else :
        return div

#------
#Main
#-------



def canon(a,b,c,d=0):
    '''Fonctions renvoyant la forme canonique d'un trinôme du second degrès'''

    if a == 0:
        return("a doit être différent de 0")

    #Calcul des formules
    delta = discriminant(a,b,c)
    alpha = Fraction(-b, (2*a))
    beta = Fraction(-delta,4*a)

    #Simplification si a=1
    if a == 1:
        canonique = str("(x - ({}))2 + ({})").format(alpha.quotient, beta.quotient)
    else :
        canonique = str("{} (x - ({}))2 + ( {} )").format(a,alpha.quotient, beta.quotient)

    #Mode développé noté d
    if d == 1:
        print("--Développement--")
        print(str("{}x2 + {}x + {}").format(a,b,c))
        print(str("{} ( x2 + {}x + {} )").format( a, Fraction(b,a).simplify(), Fraction(c,a).simplify() ) )
        print(str("{} [ ( x + {} )2 - {} + {} ]").format(a, Fraction(b,2*a).simplify(), Fraction(b**2,4*a**2).simplify(), Fraction(4*a*c,4*a**2).simplify() ) )
        print(str("{} [ ( x + {} )2 - {} ]").format(a, Fraction(b,2*a).simplify(), Fraction(delta, 4*a**2).simplify() ))
        print(canonique)


    print("---Version Courte---")
    print("Discriminant =",delta)
    print("Alpha = ",alpha.quotient)
    print("Beta = ",beta.quotient)
    print(canonique)