#!/usr/bin/env python
#-*- coding: iso8859-15 -*-
##########################################################
#               LIBRERIA MATEMATICA v1.0                 #
##########################################################
# Autor: Juan Miguel Taboada Godoy                       #
# Fecha: Malaga, 16 de noviembre de 2006                 #
# Descripción: Contiene todos las funciones matematicas  #
# Versión: 2007060300                                    #
#                                                        #
# Codigo fuente bajo licencia GNU/GPL                    #
# Centrologic (Computational Logistic Center)            #
# http://www.centrologic.com - info@centrologic.com      #
##########################################################

## \defgroup MATH_GRA MATH_GRA: Libreria con funciones matematicas generales y calculadora de senales
## \version 06/03/2007 1605 Szczecin

# Librerías {{{1
import time
import datetime
import math
# from TAD import Stack
# }}}1

# Funcion para completar los digitos esperados de un numero {{{1
## \ingroup MATH_GRA
## \internal
## Asegura los digitos de una cadena de texto
## \param numero Numero al que se le desea asegurar n-digitos
## \param digitos Numero de digitos a asegurar en la cadena
## \return Devuelve una cadena con un numero que contiene n-digitos. Ej: numero 5, con 3 digitos, devuelve "005"
def digitos(numero,digitos):
	# Mientras el número sea demasiado pequeño
	while (len(str(numero))<digitos):
		# Añado un cero
		numero="%s%s" % ('0',numero)
	# Devuelvo el número
	return numero
# }}}1
# Funcion para normalizar un valor a flotante {{{1
## \ingroup MATH_GRA
## \internal
## Normaliza un valor a flotante
## \param valor Numero a normalizar
## \return Devuelve el numero en float() o bien None si el valor original era None
def normalizar_float(valor):
	if (valor==None):
		return None
	else:
		return float(valor)
# }}}1
# Calculadora {{{1
## \ingroup MATH_GRA
## Calculadora de uso general: \n
## "AAA BBB CCC ...": donde cada valor es computado segun su previo valor, es decir se calcula AAA y su resultado es calculado con BBB y su resultado con CCC, etc... \n
##
## AAA,BBB,CCC,... pueden ser: "valor" o "operador" teniendo en cuenta que el operador debe estar precedido de algun resultado sobre el que operar y que si el operador es unario sera suficiente con poner el operador, pero si es binario necesitara un segundo valor después del operador, siempre separados por espacios. \n
##
## operador puede ser: \n
## operadores basicos soportados por python \n
## "sqrt": para la raiz cuadrada (operador unario) \n
## "^": para el operador elevar a (operador binario), equivalente a "**" en python \n
##
## numero: puede ser un numero \n
## numero+caracter: puede ser un numero seguido de una unidad ("s":segundos, "m":minutos, "h":horas, "d":dias, "k":kilo, "M":Mega, "G":Giga, "T":Tera) \n
## "ahora" o "now": este mismo instante \n
## "fecha:XXX" o "date:XXX": indica que en XXX viene una fecha que hay que computar \n
##
## XXX pueder ser: \n
## YYY: indica una fecha (YYY) \n
## YYY_ZZZ: indica una fecha (YYY) y una hora (ZZZ) \n
##
## YYY puede ser: \n
## "hoy" o "today": indica la fecha de hoy \n
## "ayer" o "yesterday": indica la fecha de ayer \n
## "DD/MM/AAAA": indica el dia (DD), el mes (MM) y el anyo (AAAA) \n
##
## ZZZ puede ser: \n
## "hh:mm:ss": indica la hora (hh), los minutos (mm) y los segundos (ss) \n
##
## Ejemplos validos: \n
## "date:ayer + 6h": fecha de ayer a las 06:00:00 de la mañana \n
## "date:22/08/2006_07:15:00": fecha del 22/08/2006 a las 07:15:00 de la mañana los formatos interpretados por la calculadora aun no han sido insertados en la documentacion
## \param cadena Contiene una cadena de texto que separa a los valores y a sus operadores con espacios
## \param viaje_temporal Esta funcion permite viaje_temporal para la traslaccion de datos en el eje X
## \return Devuelve el resultado de computar la cadena
def calculadora(cadena,viaje_temporal=None):
	# Inicializo los datos
	if (viaje_temporal==None):
		timeahora=time.time()
	else:
		timeahora=viaje_temporal
	acumulador=0
	operador="+"
	flag_dato=True
	# Parto la cadena
	particion=cadena.split(" ")
	# Para todos los elementos
	for trozo in particion:
		# Decide si se está leyendo un dato o un operando
		if (flag_dato):
			# Cambio el valor del flag
			flag_dato=False
			# Interpreto el trozo
			if ((trozo=="now") or (trozo=="ahora")):
				# Pongo el momento actual
				if (viaje_temporal==None):
					valor=timeahora
				else:
					valor=viaje_temporal
			elif ((trozo[0:4]=="date") or (trozo[0:5]=="fecha")):
				if (trozo[0:4]=="date"):
					fechahora=trozo[5:]
				else:
					fechahora=trozo[6:]
				fechapartida=fechahora.split("_")
				if (len(fechapartida)==2):
					fecha=fechapartida[0]
					hora=fechapartida[1]
				else:
					fecha=fechapartida[0]
					hora=None
				if ((fecha=="today") or (fecha=="hoy")):
					# Construyo la fecha de hoy
					if (viaje_temporal==None):
						stamp=timeahora
					else:
						stamp=viaje_temporal
					hoy=datetime.datetime.fromtimestamp(stamp)
					fecha_hoy=hoy.timetuple()
					dia=fecha_hoy[2]
					mes=fecha_hoy[1]
					anyo=fecha_hoy[0]
				elif ((fecha=="yesterday") or (fecha=="ayer")):
					# Construyo la fecha de ayer
					stamp=timeahora-86400
					ayer=datetime.datetime.fromtimestamp(stamp)
					fecha_ayer=ayer.timetuple()
					dia=fecha_ayer[2]
					mes=fecha_ayer[1]
					anyo=fecha_ayer[0]
				else:
					# Recojo la fecha indicada
					(dia,mes,anyo)=fecha.split("/")
				if (hora!=None):
					(hora,minuto,segundo)=hora.split(":")
					fecha_res=datetime.datetime(int(anyo),int(mes),int(dia),int(hora),int(minuto),int(segundo))
				else:
					fecha_res=datetime.datetime(int(anyo),int(mes),int(dia))
				valor=int(time.mktime(fecha_res.timetuple()))
			else:
				# Es un dato normal, analizo su fuerza
				fuerza=trozo[-1]
				if (fuerza=="s"):	# Segundos
					valor=trozo[:-1]
				elif (fuerza=="m"):	# Minutos
					valor=eval("%s*%s" % (60,trozo[:-1]))
				elif (fuerza=="h"):	# Horas
					valor=eval("%s*%s" % (3600,trozo[:-1]))
				elif (fuerza=="d"):	# Dias
					valor=eval("%s*%s" % (86400,trozo[:-1]))
				elif ((fuerza=="S") or (fuerza=="W")):	# Semanas
					valor=eval("%s*%s" % (86400*7,trozo[:-1]))
				elif (fuerza=="M"):	# Meses
					valor=eval("%s*%s" % (86400*30,trozo[:-1]))
				elif ((fuerza=="A") or (fuerza=="Y")):	# Anyos
					valor=eval("%s*%s" % (86400*365,trozo[:-1]))
				else:
					valor=trozo
			# Calcula el resultado
			acumulador=eval("%s %s %s" % (acumulador,operador,valor))
		else:
			# Recojo el operador
			operador=trozo
			# Interpreto el operador por si acaso es un operador unario
			if (operador=="sqrt"):
				# Aplico el operador unario sobre el acumulador
				acumulador=math.sqrt(acumulador)
			elif (operador=="^"):
				# Adaptación para compatibilizar con otros lenguajes
				operador="**"
			else:
				# Cambio el valor del flag para que lea un dato (el operador no es unario reconocido)
				flag_dato=True
	# Devuelvo el resultado acumulado
	return acumulador
# }}}1