#!/usr/bin/env python
#-*- coding: iso8859-15 -*-
##########################################################
#       LIBRERIA MATEMATICA BINARIA-HEXADECIMAL v1.0     #
##########################################################
# Autor: Juan Miguel Taboada Godoy                       #
# Fecha: Malaga, 07 de diciembre de 2006                 #
# Descripción: Contiene todos las funciones matematicas  #
# necesarias para hacer transformaciones binaria y       #
# hexadecimales.                                         #
# Versión: 2006120700                                    #
#                                                        #
# Codigo fuente bajo licencia GNU/GPL                    #
# Centrologic (Computational Logistic Center)            #
# http://www.centrologic.com - info@centrologic.com      #
##########################################################

## \internal
## \defgroup MATH_BIN MATH_BIN: Libreria con funciones matematicas para transformaciones binarias y hexadecimales
## \version 07/12/2006 0052 Szczecin

# Librerias que voy a usar {{{1
import struct
# }}}1

# Función para convertir un número decimal a binario {{{1
def dectobin(numero,longitud):
	# Creo la cadena vacía
	binario=""
	# Ajusto la memoria del algoritmo
	memoria=1
	# Si el número es 0
	if (numero==0):
		# El binario es 0
		binario="0"
		# Hay un 0 añadido a la cadena
		contador=1
	else:
		# Inicializo el contador
		contador=0
		# Mientras el número no sea 0
		while (numero!=0):
			# Actualizo la memoria
			memoria=numero % 2
			# Incremento el binario
			binario="%s%s" % (memoria,binario)
			# Incremento el contador
			contador=contador+1
			# Actualizo el número
			numero=numero/2
	# Reviso posibles errores
	if (contador>longitud):
		raise Exception,"SQL ERROR: DECTOBIN fuera de rango"
	# Ajusto el binario a la longitud solicitada
	while (contador<longitud):
		# Cargo un cero al binario
		binario="%s%s" % ("0",binario)
		# Incremento el contador
		contador=contador+1
	# Devuelvo el resultado binario
	return binario
# }}}1
# Función para convertir un caracter Hexadecimal a binario {{{1
## \ingroup MATH_BIN
## \internal
## Convierte un caracter hexadecimal a su equivalente binario
## \param char Caracter hexadecimal a convertir a binario
## \return Cadena ASCII con 0s y 1s
def hex1tobin(char):
	if (char=='0'): return "0000"
	if (char=='1'): return "0001"
	if (char=='2'): return "0010"
	if (char=='3'): return "0011"
	if (char=='4'): return "0100"
	if (char=='5'): return "0101"
	if (char=='6'): return "0110"
	if (char=='7'): return "0111"
	if (char=='8'): return "1000"
	if (char=='9'): return "1001"
	if ((char=='A') or (char=='a')): return "1010"
	if ((char=='B') or (char=='b')): return "1011"
	if ((char=='C') or (char=='c')): return "1100"
	if ((char=='D') or (char=='d')): return "1101"
	if ((char=='E') or (char=='e')): return "1110"
	if ((char=='F') or (char=='f')): return "1111"
	return "xxxx" 
# }}}1
# Función para convertir un caracter Binario a Hexadecimal {{{1
## \ingroup MATH_BIN
## \internal
## Convierte una cadena binario a su equivalente hexadecimal
## \param char Cadena ASCII con 0x y 1s
## \return Caracter hexadecimal equivalente
def bin1tohex(char):
	if (char=='0000'): return "0"
	if (char=='0001'): return "1"
	if (char=='0010'): return "2"
	if (char=='0011'): return "3"
	if (char=='0100'): return "4"
	if (char=='0101'): return "5"
	if (char=='0110'): return "6"
	if (char=='0111'): return "7"
	if (char=='1000'): return "8"
	if (char=='1001'): return "9"
	if (char=='1010'): return "a"
	if (char=='1011'): return "b"
	if (char=='1100'): return "c"
	if (char=='1101'): return "d"
	if (char=='1110'): return "e"
	if (char=='1111'): return "f"
	return "x" 
# }}}1
# Función para convertir una cadena Hexadecimal a una cadena Binaria{{{1
## \ingroup MATH_BIN
## \internal
## Convierte una cadena hexadecimal a su equivalente binario
## \param hexadecimal Cadena hexadecimal en formato ASCII
## \return Cadena binaria en formato ASCII
## \sa hex2bin()
def hextobin(hexadecimal):
	# Comenzamos el proceso
	binary=""
	for hexachar in hexadecimal:
		binary="%s%s" % (binary,hex1tobin(hexachar))
	return binary
# }}}1
# Función para convertir una cadena Binario a una cadena Hexadecimal{{{1
## \ingroup MATH_BIN
## \internal
## Convierte una cadena binario a su equivalente hexadecimal
## \param binario Cadena binaria en formato ASCII
## \return Cadena hexadecimal en formato ASCII
## \sa bin2hex()
def bintohex(binario):
	# Control de longitud
	if ((len(binario)%4)!=0):
		return None
	
	# Comenzamos el proceso
	hexadecimal=""
	i=4
	
	while (i<=len(binario)):
		hexadecimal="%s%s" % (hexadecimal,bin1tohex(binario[i-4:i]))
		i=i+4
	return hexadecimal
# }}}1
# Incrementa un número binario {{{1
## \ingroup MATH_BIN
## \internal
## Dado un numero binario, lo incrementa en 1
## \param binario Cadena binaria en formato ASCII
## \return Cadena binaria en formato ASCII incrementada en 1
## \exception Exception Se produce cuando la cadena se desborda (Ejemplo: se intenta incrementar 1, 11,111,1111,..., no ocurre si se intenta incrementar 01, 001, 01111,...etc
def bin_incrementa(binario):
	# Sumo uno
	acarreo=True
	for i in range(0,len(binario)):
		if (binario[len(binario)-i-1]==0):
			binario[len(binario)-i-1]=1
			acarreo=False
			break
		else:
			binario[len(binario)-i-1]=0
	# Control de desbordamiento
	if (acarreo):
		raise Exception,"Desbordamiento de la cadena, no se puede sumar 1 a esta cadena binaria"
	return binario
# }}}1
# Complemento a 1 {{{1
## \ingroup MATH_BIN
## \internal
## Realiza el complemento a 1 de una cadena binaria
## \param binario Cadena binaria en formato ASCII
## \return Cadena binaria en formato ASCII en complemento a 1
def bin_complementoA1(binario):
	for i in range(0,len(binario)):
		if (binario[i]==1):
			binario[i]=0
		else:
			binario[i]=1
	return binario
# }}}1
# Complemento a 2 {{{1
## \ingroup MATH_BIN
## \internal
## Realiza el complemento a 2 de una cadena binaria
## \param binario Cadena binaria en formato ASCII
## \return Cadena binaria en formato ASCII en complemento a 2
def bin_complementoA2(binario):
	# Hace el complemento a 1
	c1=bin_complementoA1(binario)
	# Incrementa el binario
	c1_inc=bin_incrementa(c1)
	# Devuelve el resultado
	return c1_inc
# }}}1

# zeros: Funcion para poner ceros a la izquierda de un valor {{{2
## \ingroup MATH_BIN
## \internal
## Funcion para poner ceros a la izquierda de un valor
## \param num Numero a tratar
## \param size Tamano (en digitos) del numero
## \return Numero con tantos ceros a la izquierda como sea necesario para hacer que num tenga el tamano size
def zeros(num,size):
	txt=str(num)
	while (len(txt)<size):
		txt="0%s" % (txt)
	return txt
# }}}2
# hex2bin: Para convertir un Hexadecimal a Binario ASCII {{{1
## \ingroup MATH_BIN
## \internal
## Dada una cadena hexadecimal la convierte a Binario (lenguaje maquina) mediante su valor equivalente ASCII
## \param hexa Cadena hexadecimal en ASCII
## \return Cadena Binario ASCII equivalente (lenguaje maquina)
## \sa hextobin()
def hex2bin(hexa):
	bin=""
	i=0
	while (i<len(hexa)):
		hexadecimal=eval("0x%s%s" % (hexa[i],hexa[i+1]))
		bin="%s%s" % (bin,chr(hexadecimal))
		i=i+2
	return bin
# }}}1
# bin2hex: Para convertir un Binario ASCII a Hexadecimal {{{1
## \ingroup MATH_BIN
## \internal
## Dada una cadena Binario ASCII (lenguaje maquina) la convierte a hexadecimal
## \param bin Cadena Binario ASCII (lenguaje maquina)
## \return Cadena hexadecimal en ASCII equivalente
## \sa bintohex()
def bin2hex(bin):
	hexa=""
	i=0
	while (i<len(bin)):
		hexa="%s%s" % (hexa,zeros(hex(ord(bin[i]))[2:],2))
		i=i+1
	return hexa
# }}}1
# Transforma una cadena hexadecimal en coma flotante, en real (float) {{{1
## \ingroup MATH_BIN
## \internal
## Transforma una cadena hexadecimal en coma flotante a real (float)
## \param hexa Cadena hexadecimal en formato ASCII
## \return Valor en formato float equivalente
def hextofloat(hexa):
	# Comprueba la longitud de la cadena
	if (len(hexa)!=8):
		raise Exception,"La longitud de la cadena hexadecimal debe ser de 8 digitos hexadecimales (pudiendo ser cada digito: 0123456789ABCDEF)"
	# Prepara el hexadecimal para ser cortado
	hexadecimal="%s %s %s %s" % (hexa[0:2],hexa[2:4],hexa[4:6],hexa[6:8])
	# Genera los bytes
	bytes = ''.join(chr(int(txt, 16)) for txt in hexadecimal.split())
	# Desempaquete la estructura
	obj=struct.unpack('>f', bytes)
	# Devuelve el resultado
	return obj[0]
# }}}1