## TP 10 : représentation de nombres

## Représentation de nombres

def bin_vers_dix(liste:list) :
    '''
    Calcule en base 10 le nombre représenté en base 2 par la liste de 0 et 1, avec la convention du TP : lecture de droite à gauche
    '''
    s = 0
    for k in range(len(liste)) :
        s = s+liste[k]*(2**k)
    return s

def base_b_vers_dix(b:int,liste:list) :
    '''
    Calcule en base 10 le nombre représenté en base b par la liste de nombres entre 0 et b-1, avec la convention du TP : lecture de droite à gauche
    '''
    s = 0
    for k in range(len(liste)) :
        s = s+liste[k]*(b**k)
    return s

def horner_b_dix(b,liste):
    '''
    Calcule en base 10 le nombre représenté en base b par la liste de nombres entre 0 et b-1, avec la convention du TP : lecture de droite à gauche. Utilise la méthode de Hörner.
    '''
    n = len(liste)
    s = 0
    for i in range(n):
        s = s*b + liste[n-i-1]
    return s

def lettre_hexa_vers_dix(u:str) :
    if u == 'A' :
        return 10
    elif u == 'B' :
        return 11
    elif u == 'C' :
        return 12
    elif u== 'D' :
        return 13
    elif u == 'E' :
        return 14
    elif u == 'F' :
        return 15
    else :
        return u

def hexa_vers_dix(liste:list) :
    '''
    Calcule en base 10 le nombre représenté hexadécimal par la liste des chiffres/lettres avec la convention du TP : lecture de droite à gauche.
    '''
    s = 0
    for k in range(len(liste)) :
        chiffre = lettre_hexa_vers_dix(liste[k])
        s = s+chiffre*(16**k)
    return s

## Opérations en binaire
def ajuste_longueur(liste1:list,liste2:list) :
    '''
    Renvoie deux listes de même longueur, en ajoutant des zéros à la fin de la liste la plus courte.
    '''
    n = len(liste1)
    m = len(liste2)
    li1 = liste1.copy()
    li2 = liste2.copy()

    if n<m :
        for i in range(m-n):
            li1.append(0)
    elif n>m :
        for i in range(n-m):
            li2.append(0)
    return (li1,li2)

def somme_bin(li1:list,li2:list):
    '''
    Calcule la liste des chiffres binaires de la somme des deux nombres représentés.
    '''
    liste1 , liste2 = ajuste_longueur(li1,li2)
    somme = []

    retenue = 0

    for k in range(len(liste1)) :
        s = retenue + liste1[k] + liste2[k]
        if s == 0 :
            somme.append(0)
            retenue = 0
        elif s == 1 :
            somme.append(1)
            retenue = 0
        elif s == 2 :
            somme.append(0)
            retenue = 1
        elif s == 3 :
            somme.append(1)
            retenue = 1

    if retenue == 1 :
        somme.append(1)

    return somme

def produit(liste1:list,liste2:list):
    '''
    Calcule la liste des chiffres binaires du produit des deux nombres représentés.
    '''
    if liste2 == [] :
        return [0]
    elif liste2[0] == 0 :
        return [0]+produit(liste1,liste2[1:])
    elif liste2[0] == 1 :
        return somme_bin(liste1, [0]+produit(liste1,liste2[1:]))


## Flottants et approximations
def suite1(n:int) :
    u = 1/12
    for k in range(n):
        u = 13*u-1
    return u

def suite2(n:int):
    if n == 0 :
        return 1/12
    else :
        return 13*suite2(n-1) -1

for k in range(30):
    print (suite1(k),suite2(k))

import fractions

def suite3(n:int):
    if n == 0 :
        return fractions.Fraction(1,12)
    else :
        return 13*suite3(n-1) -1

def briggs(x:float) :
    n = 0
    while abs(x-1) > 0.0001 :
        x = x**0.5
        n = n+1
    y = x-1
    return y* 2**n

##
# Boucle mystère
x = 1
n = 0
while x/2 > 0:
    n = n+1
    x = x/2
print(n,x)