IH/iihmsp13/exp/outilsBase.py

   1 #-*- coding:utf-8 -*-
   2 import string
   3 from numpy import *
   4 from copy import deepcopy
   5 from suite import *
   6
   7 LSCs=[1]
   8 ITFACTOR = 0.1
   9
  10 """
  11
  12 def f(L):
  13     assert len(L)%4 == 1
  14     n = len(L)/4
  15     retour = [int(not L[k]) for k in xrange(n)]
  16     retour.extend([L[k-n] for k in xrange(n,2*n)])
  17     retour.extend([int(L[k-2*n])*int(not L[k+1]) for k in xrange(2*n,4*n)])
  18     retour.extend([int(not L[2*n])])
  19     return retour
  20
  21
  22
  23
  24 def f(L):
  25     retour = [int(not L[0])]
  26     retour.extend([L[k-1] for k in xrange(1,len(L))])
  27     return retour
  28
  29
  30
  31
  32 def f(x):
  33     rl=[]
  34     k = 1
  35     for el in x:
  36         if k%2 != 0 :
  37             rl.append(int(not el))
  38         else:
  39             rl.append(0 if sum(x[k-2:k])%2==0 else 1 )
  40         k+=1
  41     return rl
  42
  43 def f(i,x):
  44     r = 0
  45     if i%2 == 0 :
  46         r = int(not x[i])
  47     else:
  48         r = 0 if sum(x[i-1:i+1])%2==0 else 1
  49     return r
  50
  51 """
  52 def f(i,L):
  53     return int(not L[i])
  54
  55
  56
  57
  58 def arrondi_en_entier(mat):
  59     (l,c) = mat.shape
  60     return array([[round(mat[i][j]) for j in range(c)]for i in range(l)])
  61
  62
  63 def matrice_lscs(matrice):
  64     lscs = LSCs
  65     '''
  66     Matrice est une liste de listes, lscs est une liste.
  67
  68     A partir d'une  matrice de coefficients binaires, vus comme
  69     des chaines de caractères, extrait les bits dont les positions
  70     sont données par la liste lscs.
  71
  72     Dans la liste lscs, un entier positif signifie devant la virgule,
  73     un entier négatif signifie derrière. Le premier bit devant la
  74     virgule est le bit 1, le premier bit derrière la virgule est le -1.
  75
  76     Le retour est une liste de bits (entiers).
  77     '''
  78     m,n = len(matrice), len(matrice[0])
  79     retour = []
  80     for l in range(m):
  81         for c in range(n):
  82             #num = str(round(float(matrice[l][c]),2))
  83             num = matrice[l][c]
  84
  85             if '.' not in num:
  86                 ent,dec = num.replace('-',''),'0'
  87             else:
  88                 ent,dec = num.replace('-','').split('.')
  89             ent,dec = list(ent),list(dec)
  90             ent.reverse()
  91             for lsc in lscs:
  92                 if lsc > 0 and len(ent)>=lsc:
  93                     retour.append(ent[lsc-1])
  94                 elif lsc<0 and len(dec)>=abs(lsc):
  95                     retour.append(dec[abs(lsc)-1])
  96                 else:
  97                     retour.append('0')
  98     return [int(k) for k in retour][:-3]
  99
 100 def matrice_to_bits(matrice):
 101     '''
 102     Renvoie la matrice des écritures binaires de matrice.
 103     Les coefficients floants deviennent des chaînes (str) de bits.
 104     '''
 105     (m,n) = matrice.shape
 106     retour = []
 107     for l in range(m):
 108         ligne = []
 109         for c in range(n):
 110             ligne.append(conversion(str(matrice[l,c]),2))
 111         retour.append(ligne)
 112     return retour
 113
 114 def embarque2(liste,matrice):
 115     lscs = LSCs
 116     m,n = len(matrice), len(matrice[0])
 117     #print m,n,liste,matrice,lscs
 118     retour = deepcopy(matrice)
 119     cpt = 0
 120     for l in xrange(m):
 121         for c in xrange(n):
 122             for lsc in lscs:
 123                 try:
 124                     retour[l,c] = setBit(str(retour[l,c]),lsc, liste[cpt])
 125                     cpt += 1
 126                 except:
 127                     pass
 128     return retour
 129
 130
 131 def differences(mat1,mat2):
 132     lm=len(mat1)
 133     cpt = 0
 134     for k in range(lm):
 135         if mat1[k] != mat2[k] :
 136             cpt +=1
 137             #print mat1[k],mat2[k]
 138     return float(100)*cpt/lm
 139
 140
 141
 142 def conversion(nombre, base, epsilon = 0.00001 ):
 143     ''' Soit nombre écrit en base 10, le retourne en base base'''
 144     if not 2 <= base <= 36:
 145         raise ValueError, "La base doit être entre 2 et 36"
 146     if not base == 2 and '.' in str(nombre):
 147         raise ValueError, "La partie décimale n'est pas gérée pour les bases\
 148                            différentes de 2."
 149     # IMPROVE : Convertir aussi la partie décimale, quand la base n'est pas égale
 150     # à 2.
 151     abc = string.digits + string.letters
 152     result = ''
 153     nb = str(nombre)
 154     if '-' in nb:
 155         nb = nb.replace('-','')
 156         sign = '-'
 157     else:
 158         sign = ''
 159     if '.' in str(nb):
 160         entier,decimal = int(nb.split('.')[0]),\
 161                          float('.'+nb.split('.')[1])
 162     else:
 163         entier,decimal = int(nb),0
 164     while entier !=0 :
 165         entier, rdigit = divmod( entier, base )
 166         result = abc[rdigit] + result
 167     flotante, decimalBin = 1./float(base),''
 168     while flotante > epsilon :
 169         if decimal >= flotante:
 170             decimalBin+='1'
 171             decimal-=flotante
 172         else :
 173             decimalBin+='0'
 174         flotante = flotante/float(base)
 175     if '1' in decimalBin :
 176         reste = '.'+decimalBin
 177         while reste[-1]=='0':
 178             reste = reste[:-1]
 179     else :
 180         reste = ''
 181     if result == '':
 182         result = '0'
 183     #print "bin",sign + result + reste
 184     return sign + result + reste
 185
 186
 187 def getBit(X,pos):
 188
 189     '''Récupère le bit en position pos de X.
 190     Par exemple, getBit(8,1) = 0, puisque le bit le plus à droite de 8 = 1000 est 0.
 191     On fera attention à ce que :
 192         - on compte à partir du point,
 193         - l'élément juste à gauche du point est en position 1,
 194         - celui juste à droite est en position -1.'''
 195     assert pos != 0
 196     #print "avant",X
 197     entier = conversion(X,2)
 198
 199     #print "entier", entier
 200     if '.' in entier:
 201         entier, decimal = entier.split('.')
 202         if decimal == '0':
 203             decimal = ''
 204     else:
 205         decimal = ''
 206     if '-' in entier:
 207         entier = entier.replace('-','')
 208     entier  = entier.zfill(abs(pos))
 209     decimal = (decimal+'0'*abs(pos))[:max(len(decimal),abs(pos))]
 210
 211     return int(entier[len(entier)-pos]) if pos >0 else int(decimal[-pos-1])
 212
 213
 214 def setBit(X,pos,y):
 215     '''Fixe le bit pos de X à la valeur y.
 216     Le fonctionnement est similaire à getBit :
 217         - on compte à partir du point,
 218         - l'élément juste à gauche du point est en position 1,
 219         - celui juste à droite est en position -1.'''
 220     assert pos != 0
 221     entier = conversion(X,2)
 222     if '.' in entier:
 223         entier, decimal = entier.split('.')
 224     else:
 225         decimal = ''
 226     entier  = list(entier.zfill(abs(pos)))
 227     decimal = list((decimal+'0'*abs(pos))[:max(len(decimal),abs(pos))])
 228     if pos>0:
 229         entier[len(entier)-pos]=str(int(y))
 230     else:
 231         decimal[-pos-1] = str(int(y))
 232     if decimal == []:
 233         return int(''.join(entier),2)
 234     else:
 235         S=0
 236         for k in range(len(decimal)):
 237             S += 1./2**(k+1)*int(decimal[k])
 238         return float(str(int(''.join(entier),2))+'.'+str(S).split('.')[1])
 239
 240
 241 def ci2_watermark(initiale_matrice,marque,ni=-1):
 242
 243     #recuperer la marque comme un vecteur de 0,1 et pas de nombres binaires
 244     lm = len(marque)
 245     msg_init = [x for x in marque]
 246
 247
 248     initiale_lscs = matrice_lscs(matrice_to_bits(initiale_matrice))
 249     initiale_lscs_a_iterer = deepcopy(initiale_lscs)
 250
 251     # Nb LSCs
 252     lh = len(initiale_lscs)
 253     print "taille de de N", lh
 254     if ni == -1 :
 255         nbit = int(ITFACTOR*lh)
 256     else:
 257         nbit = int(ni*lh)
 258
 259     # generation des strategies
 260     ciis_p = CIIS(random(),random(),random()/2,lh-1,2*lh)._genere()
 261     ciis_m = CIIS(random(),random(),random()/2,lm-1,lh)._genere()
 262     cip = CIIS(random(),random(),random()/2,lm-1,lh)._genere()
 263     S_p,S_m=[],[]
 264     S_c= [cip.next() for _ in xrange(nbit)]
 265
 266     date_m=[0]*lh
 267     for k in xrange(nbit):
 268         p = ciis_p.next()
 269         m = ciis_m.next()
 270         S_p += [p]
 271         S_m += [m]
 272
 273     #pour garantir Sp doit avoir au moins lm differentes valeurs
 274     dates_modif_suff = sample(xrange(1,nbit),lm)
 275     valeur_des_modifs=sample(xrange(lh),lm)
 276
 277     for i,e in enumerate(dates_modif_suff):
 278         S_p[e]=valeur_des_modifs[i]
 279
 280     for k in xrange(nbit):
 281         date_m[S_p[k]]=k
 282
 283
 284     #pour garantir que le message est present a la fin on modifie la strategie
 285     date_m=set(date_m)-set([0])
 286     m = sample(date_m,lm)
 287     for el in xrange(lm):
 288         d=m[el]
 289         S_c[d]= el
 290
 291     # les iterations a proprement parler
 292     for k in xrange(nbit):
 293         initiale_lscs_a_iterer[S_p[k]] = msg_init[S_c[k]]
 294         msg_init[S_m[k]] = f(S_m[k],msg_init)
 295
 296
 297     marquee_matrice = embarque2(initiale_lscs_a_iterer,
 298                                 initiale_matrice)
 299
 300     return (marquee_matrice,S_p,S_c,S_m)