TP 7 (Info) (Z / 2Z, Hamming)

from math import *
from copy import deepcopy
from random import *
#from fractions import Fraction

class Matrice:
    def __init__(self,Coeff) :
        self.Coeff = Coeff

    def __repr__(self):
        chaine=""
        for i in range(0,len(self.Coeff)):
            chaine+="("+" "
            for k in self.Coeff[i]:
                chaine+=str(k)+" "
            chaine+=")"+"\n"
        return(chaine)
    def NL(self):
        return(len(self.Coeff))
    def NC(self):
        return(len(self.Coeff[0]))
    def trace(self):
        somme=0
        for i in range(min(self.NL(),self.NC())):
            somme+=self.Coeff[i][i]
        return(somme)

    def __eq__(self,Mat2):
        if len(self.Coeff)==len(Mat2.Coeff):
            for i in range(0,len(self.Coeff)):
                if self.Coeff[i]!=Mat2.Coeff[i]:
                    return(False)
            return(True)
        else:
            return(False)

    def __add__(self,Mat2):
        if (self.NL() == Mat2.NL()) and (self.NC() == Mat2.NC()):
            A=[]
            for x in range(self.NL()):
                A.append([])
                for y in range(self.NC()):
                    A[x].append(self.Coeff[x][y]+Mat2.Coeff[x][y])
            return(Matrice(A))
    def __sub__(self,Mat2):
        if (self.NL() == Mat2.NL()) and (self.NC() == Mat2.NC()):
            A=[]
            for x in range(self.NL()):
                A.append([])
                for y in range(self.NC()):
                    A[x].append(self.Coeff[x][y]-Mat2.Coeff[x][y])
            return(Matrice(A))

    def __mul__(self,Mat2):
        if type(Mat2)!=Matrice:
            return(Mat2*self)
        if self.NC() == Mat2.NL():
            A=[]
            """for numero in range(0,Mat2.NC()):
                A.append([])
                for ligne1 in range(0,self.NL()):
                    if type(self.Coeff[0][0])==int:
                        somme=0
                    else:
                        somme=F2(0)
                    for colonne1 in range(0,self.NC()):
                        somme+=self.Coeff[numero][colonne1] * Mat2.Coeff[colonne1][ligne1]
                    A[numero].append(somme)"""

            for i in range(0,self.NL()):
                A.append([])
                for j in range(0,Mat2.NC()):
                    somme=self.Coeff[i][0]*Mat2.Coeff[0][j]
                    for k in range(1,self.NC()):
                        somme+=self.Coeff[i][k]*Mat2.Coeff[k][j]
                    A[i].append(somme)
            return(Matrice(A))
        else:
            return("error")

    def __rmul__(self,reel):
        A=self.Coeff[:]
        for x in range(self.NL()):
            for y in range(self.NC()):
                A[x][y]*=reel
        return(Matrice(A))


    def puissance(self,n):
        if self.NL()==self.NC():
            if n!=0:
                Mat=self
                for i in range(1,n):
                    self=self*Mat
                return(self)
            else:
                self=0*self
                for x in range(self.NL()):
                    self.Coeff[x][x]=1
                return(self)

    def transpo(self):
            A=[]
            for i in range(0,self.NC()):
                A.append([])
                for j in range(0,self.NL()):
                    A[i].append(self.Coeff[j][i])
            return(Matrice(A))

def m_frac(liste):
    for k in liste:
        for i in range(len(k)):
            k[i]=F2(k[i])
    return(Matrice(liste))

class F2 :
    def __init__(self,value):
        self.value = value%2

    def __repr__(self):
        return(str(self.value))

    def __add__(self, b):
        return(F2((self.value + b.value)%2))

    def __mul__(self,b):
        return(F2(self.value*b.value))

    def __eq__(self,b):
        return(self.value==b.value)

def to_binaire(nbr):
    L=""
    a=nbr
    while a!=0:
        L=str(a%2)+L
        a= a//2
    return(L)

def to_nombre(bin):
    nbr=0
    i=len(bin)-1
    for k in range(0,len(bin)):
        nbr+=int(bin[k])*2**(i)
        i=i-1
    return(nbr)

def decoupage(texte,n):
    L=[]
    for c in texte:
        s=bin(ord(c))[2:].zfill(8)
        for b in s:
            L.append(F2(int(b)))
    def bloc2column(li):
        Li=[]
        for x in li:
            Li.append([x])
        return(Matrice(Li))
    R=[]
    l=len(L)
    k=0
    while k+n<=l:
        bloc=L[k:k+n]
        R.append(bloc2column(bloc))
        k+=n
    if k<l:
        bloc=L[k:]+[F2(0)]*(k+n-l)
        R.append(bloc2column(bloc))
    return(R)


def coefficients_join(liste):
    nbr=""
    for element in liste:
        nbr+=element[0]
    return(nbr)

def reconstitution(liste,n):
    L=[]
    for mat in liste:
        co=mat.Coeff
        for ligne in co:
            L.append(str(ligne[0]))
    R=[]
    l=len(L)
    k=0
    while k+8<=l:
        bloc=L[k:k+8]
        R.append(chr(int("".join(bloc),2)))
        k+=8
    return("".join(R))



# Ne marche que pour k=4
def ik_hamming47():
    k=4
    I=[]
    for i in range(1,k+1):
        I.append([0]*k)
    I=I+[[1,1,1,0],[1,1,0,1],[1,0,1,1]]
    I=Matrice(I)
    for i in range(0,k):
        I.Coeff[i][i]=1
    coefficients_transform(I)
    return(I)

def coefficients_transform(matrice):

    for k in range(0,matrice.NL()):
        for i in range(0,matrice.NC()):
            matrice.Coeff[k][i]=F2( int( matrice.Coeff[k][i]) )
    return(matrice)


def CodageHamming(m):

    G=Matrice([[F2(1),F2(1),F2(1),F2(0)],[F2(1),F2(1),F2(0),F2(1)],[F2(1),F2(0),F2(1),F2(1)]])


    return(Matrice(m.Coeff + (G*m).Coeff))


def MotHamming(M):
    return( (M.Coeff[4][0] == M.Coeff[0][0] + M.Coeff[1][0] + M.Coeff[2][0]) and (M.Coeff[5][0] == M.Coeff[0][0] + M.Coeff[1][0] + M.Coeff[3][0]) and (M.Coeff[6][0] == M.Coeff[0][0] + M.Coeff[2][0] + M.Coeff[3][0]))


def DecodageHamming(M):
    if MotHamming(M):
        a=Matrice(M.Coeff[0:4])
        return(a)
    else:
        return(Matrice(Plus_Petite_Difference(M).Coeff[0:4]))

# donne toutes les matrices qui vérifient la relation de Hamming
def Liste_aux_Hamming():
    L = []
    for i in range(0,2):
        for j in range(0,2):
            for k in range(0,2):
                for l in range(0,2):
                    L.append(CodageHamming(Matrice([[F2(i)],[F2(j)],[F2(k)],[F2(l)]])))
    return(L)

def Differences_Hamming(A,B):
    difference=0
    for i in range(0,7):
        if A.Coeff[i][0] != B.Coeff[i][0]:
            difference+=1
    return(difference)

def Plus_Petite_Difference(A):
    best=7
    L=[]
    ListeHamming=Liste_aux_Hamming()
    for element in ListeHamming:
        dif=Differences_Hamming(A,element)
        if dif<best:
            best=dif
            a=element
        elif dif==best:
            L.append([element,dif])
    #print("best différence :",best)
    return(a)


def Random_Errors_Into_Liste_of_Matrice(liste,proba):


    for element in liste:
        L=[randint(0,100),randint(0,100),randint(0,100),randint(0,100),randint(0,100),randint(0,100),randint(0,100)]

        if L[0]<proba :
            element.Coeff[0][0]+=F2(1)
        if L[1]<proba :
            element.Coeff[1][0]+=F2(1)
        if L[2]<proba :
            element.Coeff[2][0]+=F2(1)
        if L[3]<proba :
            element.Coeff[3][0]+=F2(1)
        if L[4]<proba :
            element.Coeff[4][0]+=F2(1)
        if L[5]<proba :
            element.Coeff[5][0]+=F2(1)
        if L[6]<proba :
            element.Coeff[6][0]+=F2(1)

    return(liste)


def JouerAvecHamming(proba,texte=""):
    if texte=="":
        userinput=str(input("Entrez un message \n>"))
    else:
        userinput=texte

    Liste_Message=decoupage(userinput,4)
    L=[]
    for element in Liste_Message:
        L.append(CodageHamming(element))
    # L_initial=deepcopy(L)
    L2=Random_Errors_Into_Liste_of_Matrice(L,proba)

    templist1=[]
    for element in L2:
        templist1.append(Matrice(element.Coeff[0:4]))
    premier_troncage=reconstitution(templist1,4)

    templist2=[]
    for element in L2:
        templist2.append(Matrice(DecodageHamming(element).Coeff[0:4]))
    deuxieme_troncage=reconstitution(templist2,4)
    print("Premier troncage naif: ",premier_troncage,"\nDeuxieme troncage decodé : ",deuxieme_troncage)



M=CodageHamming(decoupage("0",4)[0])
#A=coefficients_transform(decoupage("A",4)[0])
#A = F2(3)
#B = F2(4)

G=Matrice([[F2(1),F2(1),F2(1),F2(0)],[F2(1),F2(1),F2(0),F2(1)],[F2(1),F2(0),F2(1),F2(1)]])
#G=m_frac(G)

X=Matrice([[1,3,5,1],[2,4,6,1],[4,5,8,7]])
#X=m_frac(X)

Texte="Alors Jesus levant les yeux sur ces disciples dit : heureux, vous qui êtes pauvre car le royaume de Dieu est à vous. Heureux vous qui avez faim maintenant car vous serez rassasiés. Heureux vous qui pleurez maintenant car vous serez dans la joie. Heureux serez vous lorsque les hommes vous haïrons lorsquon vous chassera, vous outrageras et quon rejetera votre nom comme infame. A cause du fils de lhomme, rejouiseez vous en ce jour là et tresaillez dallegresse car votre recompense sera grande dans le ciel."

Texte2="Avancez, Lysandre. Et celui-ci, mon gracieux duc, a ensorcelé le coeur de mon enfant. C.est toi, c.est toi, Lysandre, qui lui as donné des vers et qui as échangé avec ma fille des gages d.amour. Tu as, à la clarté de la lune, chanté sous sa fenêtre, avec une voix trompeuse, des vers d.un amour trompeur : tu as surpris son imagination avec des bracelets de tes cheveux, avec des bagues, des bijoux, des hochets, des colifichets, des bouquets, des friandises, messagers d.un ascendant puissant sur la tendre jeunesse ! Tu as dérobé avec adresse le coeur de ma fille, et changé l.obéissance qu.elle doit à son père en un âpre entêtement. Ainsi, gracieux duc, dans le cas où elle oserait refuser ici devant Votre Altesse de consentir à épouser Démétrius, je réclame l.ancien privilége d.Athènes. Comme elle est à moi, je puis disposer d.elle ; et ce sera pour la livrer à ce jeune homme ou à la mort, en vertu de notre loi"