Convertisseur de bases

BaseK.py

from decimal import Decimal
from attrdict import AttrDict



def d2k(d, k):
	
	"""
	
	d base 10 [int] to [str] base k [int]
		
	"""
	
	
	
	base = ["0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
	
	if type(d) != type(int()) or type(k) != type(int()) or k > len(base):
		
		return None
	
	
	
	r = ""
	
	while d // k != 0:
		
		r = base[d % k] + r
		
		d = d // k
		
	r = base[d % k] + r
		
	return r
	

	
	
def k2d(n, k):
	
	"""
	
	[str] in base k [int] to [int] in base 10
	
	"""
	
	base = ["0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
	
	if k > len(base) or type(n) != type(str()) or type(k) != type(int()):
		
		return None
	
	
	
	
	r = 0
	
	l = len(n)
	
	for i in n:
		
		i = base.index(i)
		
		l -= 1
		
		r += int(i) * k ** (l)
		
		
	return r
	
	
	
def b2b (n, k0, kf):
	
	"""
	
	n [str] in base k0 to [str] in base kf
	
	"""
	
	dec = k2d(n, k0)
	
	return d2k(dec, kf)
	

def s2b(w):
	
	""" w [str] to bits """
	
	w = str(w)
	
	b = ""
	
	ascii = []
	
	for i in w:
		
		ascii.append(ord(i))
		
		x = d2k(ord(i), 2)
		
		while len(x) < 8:
			
			x = '0' + x
		
		b += x
		
	return b
	

def b2s(b):
	
	""" bits to [str]"""
	
	b = str(b)
	
	resultat = ""
	
	s , f = 0 , 8
	
	while f <= len(b):
		
		octet = b[s:f]
		
		dec = k2d(octet, 2)
		
		resultat += (chr(dec))
		
		s +=8
		
		f +=8
	
	return resultat
	
	
def r2k(r, k, n=8):
	
	"""
	
	r relative [int] to base k [int] in n [int] bits
	
	"""
	
	try:
		
		r = int(r)
		
	except:
		
		return None
		
	
	if r > 0 and r > k**(n-1) - 1 or r < 0 and r < - k**(n-1):
		
		return None
		
	if r < 0:
		
		#calcul de l'entier relatif
		
		r = k**n + r
		
		print(r)
	
	
	x = d2k(r, k)
	
	while len(x) < n:
			
		x = '0' + x
		
	return x
		
		

def k2r(m, k, n=8):
	
	"""
	n [int] bits m [str] in base k [int] to real [int] in base 10
		
	"""
	
	try:
		
		m = str(m)
		
		k = abs(int(k))
		
		n = abs(int(n))
		
	except:
		
		return None
		
		
	
	if m[0] == "0":
		
		return k2d(m, k)
		
	elif m[0] == str(k-1):
		
		return  k2d(m, k) - k**n
		
		
		
		


def f2b(f):
	
	"""
	f [float] base 10 to [str] binary IEEE754 32 bits
	
	return AttrDict({'value_stored', 'sign', 'exponent', 'mantissa', 'binary'})
	
	"""
	
	k = 2
	
	try:
		
		f = float(f)
	
	except:
		
		return None
		
		
	# x est la partie en base 10 avant la virgule
	
	x = int(f)
	
	
	# on isole la partie apres la virgule en base 10
		
	y = abs(f) - abs(x)
		
	
	
	
	# conversion de la partie apres la virgule en binaire sur 23 bits
		
	z = ""
	
	while len(z) < 32:
		
		y = (y-int(y)) * k
	
		z += str(y)[0] 
	
	
	# expression binaire avec virgule ex: 101.1010
	
	bv = d2k(abs(x),2) + "." + z
	
	
	
	# calcule de la puissance
	
	if abs(x) != 0:
		
		p = bv.index(".") - 1 + 127
		
	else:
		
		p = -1 * (bv.index("1") - 1) + 127
	
	
	if p >= 255 or p <= -254:
		
		return None
	
	
	
	# expression de la mantisse en binaire
	
	bv = bv.replace(".","")
	
	mantisse = bv[bv.index("1")+1:bv.index("1")+24]
		
	
	# expression de la puissance en binaire sur 8 bits
	
	p = d2k(p, 2) 
	
	while len(p) < 8:
		
		p = "0" + p
	
	
	
	v = Decimal.from_float(f) # valeur en memoire
	
	if f > 0:
		
		return AttrDict({'value_stored':v, 'sign':'0', 'exponent':p, 'mantissa':mantisse, 'binary':"0" + p + mantisse})
		
	
	else:
		
		return AttrDict({'value_stored':v, 'sign':'1', 'exponent':p, 'mantissa':mantisse, 'binary':"1" + p + mantisse})
	
	
def b2f(b):
	
	""" 
	
	b [str] IEEE754 32 bits binary to decimal [float]
	
	"""
	
	try:
		
		b = str(b)
	
	except:
		
		return None
		
	s = int(b[0])
	
	p = k2d(b[1:9], 2) - 127
	
	m = b[9:]
	
	fraction = 1
	
	
	
	for i, j in enumerate(m):
		
		if j == "1":
		
			fraction += 1*(2**-(i+1))
	
	return (-1)**s * fraction * 2**p