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

## \internal
## \defgroup MATH_EV MATH_EV: Libreria matematica para computar ARRAYs Epoch-Valor o ARRAY EV: [(epoch,valor),(epoch,valor),(epoch,valor),...]
## \version 16/11/2006 1647 Szczecin

# Librerias necesarias {{{1
#from MATH_GRA import *
import math
# }}}1

# Función de escalado en X {{{1
## \ingroup MATH_EV
## \internal
## Funcion de escalado en X (eje temporal)
## \param vector ARRAY con los datos en formato EV
## \param minX Nuevo manimo en X
## \param maxX Nuevo maximo en X
## \return Devuelve un ARRAY resultado de escalar el vector a los nuevos maximos y minimos
def escalarX(vector,minX,maxX):
	# Recojo configuracion
	minV=float(vector[0][0])
	maxV=float(vector[-1][0])
	lenvector=maxV-minV
	lenoriginal=float(maxX-minX)
	lencaja=lenvector/lenoriginal
	# Inicializo valores
	nuevo_vector=[]
	# Comienzo el proceso
	for elemento in vector:
		# Obtengo los datos
		epoch=float(elemento[0])
		valor=elemento[1]
		# Genero el nuevo valor
		epoch_new=int((epoch-minV)/lencaja)+minX
		# Genero la nueva terna
		terna=(epoch_new,valor)
		# Inserto la terna en la lista
		nuevo_vector.append(terna)
	# Devuelvo el resultado
	return nuevo_vector
# }}}1
# Función para particionar un array {{{1
## \ingroup MATH_EV
## \internal
## Funcion para particionar un array
## \param vector ARRAY con los datos en formato EV
## \param particiones Numero de particiones a crear
## \return Devuelve una lista de ARRAYs EV como resultado de particiones n-veces
def particionar(vector,particiones):
	# Tamaño del vector
	if (len(vector)==0):
		resultado=[]
	elif (len(vector)==1):
		resultado=[vector]
	else:
		# Calculo el tamano por particion
		minV=float(vector[0][0])
		maxV=float(vector[-1][0])
		tamano_particion=(maxV-minV)/float(particiones)
		contador=1
		particiones=[]
		lista=[]
		old=None
		
		for elemento in vector:
			# Guardo la lista si llego al tamano de caja
			while (elemento[0]>(minV+tamano_particion*contador)):
				# Añado el elemento de corte
				if ((minV+tamano_particion*contador)!=old[0]):
					lista.append((minV+tamano_particion*contador,old[1]))
				# Añado la partición a la lista de particiones
				particiones.append(lista)
				# Comienzo una partición nueva
				lista=[]
				# Añado el elemento de corte
				if (elemento[0]>(minV+tamano_particion*(contador+1))):
					lista.append((minV+tamano_particion*contador,elemento[1]))
				else:
					lista.append((minV+tamano_particion*contador,old[1]))
				# Incremento el contador
				contador=contador+1
			# Anado el elemento a la lista
			lista.append(elemento)
			old=elemento
		if (lista!=[]):
			particiones.append(lista)
		resultado=particiones
		
	return resultado
# }}}1
# Separa un array de datos en 2 según una variable boleana, los valores separados son modificados por este valor {{{1
## \ingroup MATH_EV
## \internal
## Separa un ARRAY EV en 2 segun una variable boleana
## \param acumulador ARRAY con los datos en formato EV
## \param condicion Condicion computable mediante el evaluador the Python
## \param valor Valor de comparacion en la condicion
## \retval Devuelve una tupla que contiene 2 ARRAYS EV: (ARRAY EV con valores que cumplieron la condicion, ARRAY EV con valores que no cumplieron la condicion).
def filtro_limites(acumulador,condicion,valor):
	listain=[]
	listaout=[]
	for dato in acumulador:
		if (eval("%s%s%s" % (dato[1],condicion,valor))):
			listain.append(dato)
		else:
			listaout.append(dato)
	return (listain,listaout)
# }}}1
# Funcion que hace la raiz cuadrada {{{1
## \ingroup MATH_EV
## \internal
## Funcion sqrt
## \param vector ARRAY con los datos en formato EV
## \return Devuelve un ARRAY resultado de hacer la raiz cuadrada
def sqrtEV(vector):
	# Inicializo valores
	nuevo_vector=[]
	# Comienzo el proceso
	for elemento in vector:
		# Obtengo los datos
		(epoch,valor)=elemento
		# Genero el nuevo valor
		valor=math.sqrt(valor)
		# Genero la nueva terna
		terna=(epoch,valor)
		# Inserto la terna en la lista
		nuevo_vector.append(terna)
	# Devuelvo el resultado
	return nuevo_vector
# }}}1