#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <time.h>
#include <fstream>

#define N 2000			//Numero de agentes
#define delta_teta 0.015	//Variacion de sensibilidad
#define r 1900.0		//Factor de multiplicacion
#define cant 1.000		
#define alpha 1.0		//Peso de la norma
#define ciclos 25000		//Número de ciclos en actualización asíncrona
#define umbral 4.0000		//con 0.0 habrá un 100% de cooperadores iniciales y con 10.0 un 0%
#define X 2.5			//SENSIBILIDAD MAXIMA, LA SENSIBILIDAD ESTARA EN EL INTERVALO [0,X] CON X:(Xentera+Xdecimal)
#define Max 3			//Max=Xentera+1

using namespace std;

/*
ESTRUCTURA INDIVIDUO
*/
struct individuo
{
	double u;		//resultado de la función de utilidad indivdual
	double trib;		//variable "booleana" que indica si el individuo contribuye o no
	double teta;		//sensibilidad hacia la norma
};

/*
FUNCIONES
*/

//FUNCION PARA INICIALIZAR ".teta"
double p_decimal()
{
	double c;
	double d;
	
	c=1+(rand()%1000);
	d=c/1000;
	return d;
}
void inicializar_teta(struct individuo u[],int tam)
{
	double Num;
	double Numd;//parte decimal, nuestro numero es un decimal Num(Nume,Numd)
	double Nume;//parte entera
	
	//tenemos un limite X(Xe,Xd), (parte entera,parte decimal)
	for (int cont=0;cont<tam;cont++)
	{
		Nume=(rand()%Max);
		Numd=p_decimal();
		Num=Nume+Numd;
		if (Num>X) {Num=X*Num/Max;}		//HISTOGRAMA A DERECHAS	  [0, 2.5](Dominio de potenciales agentes cooperadores)
		
	/*	if (Num>X)						//HISTOGRAMA A IZQUIERDAS [0, 2.5](Dominio de potenciales agentes defectores)
		{
			Num=X*Num/Max;
			Num=Num-2.0;
		}					
	*/	
	/*	if (Num>X) {Num=Num-1;}			//HISTOGRAMA CENTRADO [0, 1.5]	(Dominio de agentes indecisos)
		if (Num>X) {Num=13*Num/28;}		//HISTOGRAMA CENTRADO [0, 3.5]	(Dominio de agentes indecisos)
		if (Num>X) {Num=5*Num/11;}		//HISTOGRAMA CENTRADO [0, 2.5]	(Dominio de agentes indecisos)
	*/	u[cont].teta=Num;		
		
	}
}

//FUNCION PARA INICIALIZAR EL VECTOR DE INDIVIDUOS
void inicializar_vector(struct individuo w[], int tam)
{ 
	int cont;
	double aux1=0.0;
	double aux2=0.0;
	double aux=0.0;

	//INICIALIZACION DE ".trib" 
	for (cont=0;cont<tam;cont++)
		{	
			aux1=rand()%(10);
			aux2=p_decimal();
			aux=aux1+aux2;
			if (aux>umbral)
				w[cont].trib=1.0;
				else
					w[cont].trib=0.0;
		}
	inicializar_teta (w,tam);
}

//FUNCION QUE CALCULA EL NUMERO DE CONTRIBUYENTES
int contribuyentes (struct individuo w[], int tam)
{
	int cont;
	int nc;
	nc=0;

	
	
	for (cont=0;cont<tam;cont++)
	{
		if ((w[cont].trib)==1)
			nc=nc+1;
	}
	return nc;
}

//FUNCION QUE CALCULA LA UTILIDAD INDIVIDUAL
double utilidad_individual(struct individuo w,int nc,double norm)
{
	double u;
	u=0;
	u=(-((cant)*(w.trib)));
	u=u+((r/N)*(nc))+(((w.trib)-1)*(w.teta)*norm);
	return u;
}

//FUNCION QUE CALCULA LA UTILIDAD DE TODOS LOS INDIVIDUOS 
void funcion_utilidad(struct individuo w[], int tam, int nc, double norm)
{
	int cont;
	for (cont=0;cont<tam;cont++)
	{
		(w[cont].u)=utilidad_individual(w[cont],nc,norm);
	}
}

//FUNCION QUE CALCULA LOS CAMBIOS
//void calcular_variacion(struct individuo w[], int num_trib)//!!!CABECERA DE ACTUALIZACION ASINCRONA
void calcular_variacion(struct individuo w[],int num_trib,int b) //!!!CABECERA DE ACTUALIZACION SINCRONA (PARALELOS)
{	
	int nc;
	double norma;
	struct individuo aux;
	/*int b;			//Hay que comentarlo para hacer la actualización en paralelos
	b=0;			//Hay que comentarlo para hacer la actualización en paralelos
	b=rand()%N;		//Hay que comentarlo para hacer la actualización en paralelos*/

	aux.teta=w[b].teta;
	aux.trib=w[b].trib;
	aux.u=w[b].u;

	if ((w[b].trib)==1.0)
		{
		aux.trib=0.0;
		nc=num_trib-1;
		}
	else 
		{
		aux.trib=1.0;
		nc=num_trib+1;
		}
	

	norma=alpha*nc/N;

	aux.u=utilidad_individual(aux,nc,norma);

	//CAMBIOS
	if (((aux.u)<(w[b].u))&&(aux.trib==0.0))
	{
		w[b].teta=(w[b].teta)+delta_teta;
	}

	if (((aux.u)>(w[b].u))&&(aux.trib==0.0))
	{
		w[b].teta=(w[b].teta)-delta_teta;
		w[b].trib=0.0;
	}

	if (((aux.u)<(w[b].u))&&(aux.trib==1.0))
	{
		w[b].teta=(w[b].teta)-delta_teta;
	}

	if (((aux.u)>(w[b].u))&&(aux.trib==1.0))
	{
		w[b].teta=(w[b].teta)+delta_teta;
		w[b].trib=1.0;
	}

}


/*
FUNCION PRINCIPAL
*/
void main()
{

	/* 
		- REPRESENTAR GRAFICAMENTE LOS RESULTADOS
	*/
	ofstream sout("contr.txt");
	ofstream hist1("sensi.txt");
	ofstream hist2("sensf.txt");
	ofstream fout("salida.txt");
	struct individuo v[N];	
	struct individuo w[N];
	double sens_media;	
	int *a;
	int cont; //PARA RECORRER EL ARRAY
	double num_trib; //NUMERO DE CONTRIBUYENTES
	double norma;
	
	srand(time(NULL));

	//INICIALIZACION DE CONDICIONES DE PARTIDA
	inicializar_vector(v,N);
	num_trib=contribuyentes(v,N);
	norma=alpha*(num_trib)/N;
	funcion_utilidad(v,N,num_trib,norma);
	
	for (cont=0;cont<N;cont++)
	{
		w[cont].teta=v[cont].teta;
		w[cont].trib=v[cont].trib;
		w[cont].u=v[cont].u;
	}
	
	cout<<"INDIVIDUOS:	"<<N<<endl;
	cout<<"CICLOS:	"<<ciclos<<endl;
	cout<<"ALPHA: "<<alpha<<endl;
	cout<<"FACTOR DE MULTIPLICACION (r):	"<<r<<endl;
	cout<<"CONTRIBUYENTES INICIALES: "<<num_trib<<endl;
	sens_media=0.0;
	for (cont=0;cont<N;cont++)
		sens_media=(v[cont].teta)+sens_media;

	sens_media=sens_media/N;
	cout<<"SENSIBILIDAD MEDIA INICIAL: "<<sens_media<<endl<<endl;

	for(cont=0;cont<N;cont++)
	{
		hist1<<v[cont].teta<<endl;
	}

	//AHORA CALCULAMOS LAS VARIACIONES

	//CON ACTUALIZACION EN PARALELOS
	for (int cont3=0;cont3<100;cont3++)
	{	
		num_trib=contribuyentes(v,N);										
		norma=alpha*num_trib/N;					
		funcion_utilidad(v,N,num_trib,norma);
		for (cont=0;cont<N;cont++)
		{			
			calcular_variacion(v,num_trib,cont);		
		}

		sens_media=0.0;
		for (int cont2=0;cont2<N;cont2++)
			sens_media=(v[cont2].teta)+sens_media;

		sens_media=sens_media/N;
		
		sout<<cont3<<"	"<<num_trib<<endl;	
		fout<<cont3<<"	"<<sens_media<<endl;
		
	}

	/*//CON ACTUALIZACION ASÍNCRONA
	for (cont=0;cont<ciclos;cont++)
	{
		num_trib=contribuyentes(v,N);										
		norma=alpha*num_trib/N;					
		funcion_utilidad(v,N,num_trib,norma);			
		calcular_variacion(v,num_trib);		
				
		sens_media=0.0;
		for (int cont2=0;cont2<N;cont2++)
			sens_media=(v[cont2].teta)+sens_media;

		sens_media=sens_media/N;
		
		sout<<cont<<"	"<<num_trib<<endl;	
		fout<<cont<<"	"<<sens_media<<endl;
		
		
	}
	*/
	//AHORA CALCULAMOS EL NUMERO DE VARIACIONES
	int caux;
	caux=0;
	for (cont=0;cont<N;cont++)
	{
		if ((w[cont].trib)!=(v[cont].trib))
		{
			caux=caux+1;
		}
	}
	
	cout<<"CAMBIOS: "<<caux<<endl<<endl;//ESTE ES EL NUMERO DE VARIACIONES TOTALES
	
	a=(int*)malloc(caux*sizeof(int));
	cont=0;
	int i;
	i=0;
	
	//AHORA REGISTRAMOS LAS POSICIONES EN LAS QUE HA HABIDO UNA VARIACION
	for (cont=0;cont<N;cont++)
	{
		if ((w[cont].trib)!=(v[cont].trib))
		{
			a[i]=cont;
			i=i++;
		}
	}
	
	num_trib=contribuyentes(v,N);
	cout<<"CONTRIBUYENTES FINALES: "<<num_trib<<endl;

	sens_media=0.0;
	for (cont=0;cont<N;cont++)
		sens_media=(v[cont].teta)+sens_media;

	sens_media=sens_media/N;
	cout<<"SENSIBILIDAD MEDIA FINAL: "<<sens_media<<endl<<endl;
	
	for(cont=0;cont<N;cont++)
	{
		hist2<<v[cont].teta<<endl;
	}

	int b;
	
	cout<<"INTRODUZCA UN NUMERO PARA CERRAR"<<endl<<endl;
	cin>>b;
	
	fout.close();
	sout.close();
	hist1.close();
	hist2.close();
	free (a);
}