Пример #1
0
vector<int> bruteForce(vector<vector<int> > graph, int type){
	int n = graph.size() ;
	vector<int> solution (n);
	vector<int> bestSol (n);

	vector<int> p (n-1);
	for (int i = 0; i < n -1 ; i++)
		p[i] = solution[i] = bestSol[i] = i;
	solution[n-1] = bestSol[n-1] = n-1 ;
	int min = poids(graph, solution, type);

	unsigned int i = 1 ;
	while(i < ((unsigned int) n - 1)){
		--p[i];
		int j = (i % 2 == 1) ? p[i] : 0;
		swap(&solution, i+1, j+1);

		int tmp = poids(graph, solution, type);

		if (tmp < min){
			min = tmp;
			bestSol = solution ;
		}
		i = 1;
		while (i < p.size() && p[i] == 0){
			p[i] = i;
			i++;
		}
	}
	return bestSol ;
}
Пример #2
0
vector<int> backTracking_(vector<vector<int> > graph, int type, vector<int> A, int l, int lengthSoFar, vector<int> Sol) {
	int n = A.size() ;
	int minCost = poids(graph, Sol);
	if(l == n) {
		int newCost = lengthSoFar + graph[A[n-1]][A[0]] ;
		if(newCost < minCost)
			Sol = A ;
	}
	else {
		for(int i = l ; i < n ; i++) {
			swap(&A, l, i) ;
			int newLength = lengthSoFar + graph[A[l-1]][A[l]] ;
			if(newLength <= minCost) {
				vector<int> newSol = backTracking_(graph, type, A, l+1, newLength, Sol) ;
				if(poids(graph, newSol) < minCost) {
					Sol = newSol ;
				}
			}
			swap(&A, l, i) ;
		}
	}

	return Sol ;
}
Пример #3
0
int calib()
{
  double spot;
  double r;
  double q;
  int i;
  int j;
  int n;
  double tmin;
  double sigma0;
  double variance;
  int N;
  double horizon;
  double deltat;
  double W;
  double alpha;
  double rho;
  double beta;
  char * name_in_data;
  char * name_in_parameters;
  int option_volatility;
  int option_step;
  int option_constraint;
  double*G;
  double*K;
  double*T;
  double*P;
  double*w;
  double *tirages=malloc((1+nu*n)*sizeof(double));
  double *proba=malloc((1+nu)*sizeof(double));
 

  name_in_data = "datas.in";
  name_in_parameters = "parameters.in";
  loadParameters(name_in_parameters,&spot, &r, &q, &option_volatility, &option_step,&horizon,&sigma0,&deltat, &N,&alpha,&beta,&rho,&option_constraint );

  
  G=malloc((1+nu*N)*sizeof(double));
  K=malloc((1+N)*sizeof(double));
  T=malloc((1+N)*sizeof(double));
  P=malloc((1+N)*sizeof(double));
  w=malloc((N+1)*sizeof(double));
  loadDataPrices(name_in_data,K,P,T,N);

  for(i=0;i<N;i++){if(i==0){
	tmin=T[0];
  } else {
	
	if(tmin>T[i]){
	  tmin=T[i];
	}
  }
  }
  printf("tmin\n");
  printf("%f\n",tmin);
  
  


  
   n=(int)floor(horizon/deltat);
   
   if(option_volatility==1){
	 sigma0=0;
	 variance=0;
	 rho=0.7;
	 for(i=0;i<N;i++){
	   printf("vol\n");
	   printf("%f\n",volatiliteimplicite(P[i],spot,K[i],r,T[i]));
	   sigma0=sigma0+volatiliteimplicite(P[i],spot,K[i],r,T[i]);
	 variance=variance+volatiliteimplicite(P[i],spot,K[i],r,T[i])*volatiliteimplicite(P[i],spot,K[i],r,T[i]);
	
	 }
	 sigma0=(1/(double) N)*sigma0;
	 variance=(1/(double) N)*variance-sigma0*sigma0;
	 alpha=1;
	 beta=2*sqrt(variance)/(1-exp(-tmin));
	 printf("beta\n");
	 printf("%f\n",beta);
	 printf("sigma0\n");
	 printf("%f\n",sigma0);
	
   }
   if(option_step==1){
	 deltat=0.01;
   }
   
   if(option_constraint==1){
	 for(i=0;i<N;i++){w[i]=1;}
	 tirages=tiragedetrajectoires(alpha,beta,rho,sigma0,spot,r,q,N,deltat,horizon);
	 G=donnees(tirages,spot,sigma0,r,N,deltat,horizon,T,P,K);
	 poids(w,G,proba,tirages,spot,r,N);
   } else {
	 for(i=0;i<N;i++){w[i]=0;}
	 tirages=tiragedetrajectoires(alpha,beta,rho,sigma0,spot,r,q,N,deltat,horizon);
	 G=donnees(tirages,spot,sigma0,r,N,deltat,horizon,T,P,K);
	 poids(w,G,proba,tirages,spot,r,N);
	 
   }
  
   

  
		  for(j=0;j<N;j++){
			 W=0;
			 for(i=0;i<nu;i++){
			  
			W=W+proba[i]*G[j+N*i];
	
	  
	}
		if(fabs(W)>1E-3){
		  printf("%d %g\n",j,W);
		}
		  }

  free(proba);
  free(G);
  free(tirages);
  free(P);
  free(T);
  free(K);
  free(w);
  
	  return 0;
}
Пример #4
0
void lecture(int argc, char *argv[], Sommet **sommets, Arete **aretes,
	     int *nbSommets, int *nbAretes)
{
	int compteur=0,i,j;
	char caracCourant='a',caracPrecedent;
	int buff; //pour données inutile dans fscanf
	
    	FILE *fichier=NULL;
	char nom[TAILLE_NOM_FICHIER];


	if (argc>1)
        	fichier=fopen(argv[1],"r");

	while (fichier==NULL)
	{
		printf("Nom du fichier ?\n\t");
		scanf("%s",nom);
		fichier=fopen(nom,"r");
	}

	fscanf(fichier,"%d",nbSommets);
	
	
	// on compte le nombre de lignes du fichier
	do
	{
		caracPrecedent=caracCourant;
		caracCourant=fgetc(fichier);

		// pour ne pas compter les lignes vides
		if(caracCourant=='\n'&&caracPrecedent!='\n')
			compteur++;
	}
	while(caracCourant!=EOF);
			
	compteur--;//on ne compte pas la première ligne(*nbSommets)
	
	//on se cale apres la taille
	fseek(fichier,2,SEEK_SET);
	
	//sommets indexés à partir de 1
	(*sommets)=(Sommet*)malloc((*nbSommets+1)*sizeof(Sommet));
	
	if(compteur==(*nbSommets))
	// 2 cas (en onction du type de fichier)
	{
		for(i=1 ; i<=(*nbSommets) ; i++)
			fscanf(fichier,"%lf%lf",&(*sommets)[i].x,&(*sommets)[i].y);
	
		*nbAretes=(compteur*(compteur-1))/2;//le graphe est complet

		// idem aretes indexées a partir de 1
		(*aretes)=(Arete *)malloc((*nbAretes+1)*sizeof(Arete));
		
		compteur=1;
		
		for(i=1 ; i<(*nbSommets) ; i++)
			for(j=i+1 ; j<=(*nbSommets) ; j++)
			{
				(*aretes)[compteur].origine=i;
				(*aretes)[compteur].extremite=j;
				(*aretes)[compteur].poids=poids((*sommets)[i],(*sommets)[j]);
				compteur++;
			}	
	}	
	
	else
	{
		for(i=1 ; i<=(*nbSommets) ; i++)
			fscanf(fichier,"%d%lf%lf",&buff,&(*sommets)[i].x,&(*sommets)[i].y);
		
		*nbAretes=compteur-(*nbSommets);
		(*aretes)=(Arete *)malloc((*nbAretes+1)*sizeof(Arete));
		
		for(i=1 ; i<=(*nbAretes) ; i++)
			fscanf(fichier,"%d%d%lf",&(*aretes)[i].origine,
			       &(*aretes)[i].extremite,&(*aretes)[i].poids);

	}
	
	fclose(fichier);	
}
Пример #5
0
/*
  La fonction doit retourner 1 si on peut couper le noeud
  correspondant de l'arbre de recherche,
  c'est-a-dire si celui-ci ne contient pas mieux que la meilleure solution deja rencontree.
  La fonction retourne 0 si la relaxation n'a pas permis de couper ce noeud.
  Une variable globale nommee borne est declaree dans tsp.h
  et definie dans tsp.c. Elle contient la plus petite longueur
  d'un tour rencontre depuis le debut de la methode BB.
  Une fonction poids definie dans tsp.c renvoie le poids d'un un_arbre passe en parametre.
  Une fonction sauvegarde_solution permet de sauvegarder un un_arbre
  passe en parametre dans la variable globale meilleure_solution.
  liste contient les aretes non exclues et non incidentes au sommet 0,
  le nombre de ces aretes vaut nb_liste.
  liste0 contient les aretes non exclues et incidentes au sommet 0,
  le nombre de ces aretes vaut nb_liste0.
  Les variables liste et liste0 n'auront probablement pas besoin
  d'etre manipulees en completant le programme.
  nb_iter donne le nombre maximum d'iterations dans la recherche du maximum de la fonction duale
  Les multiplicateurs de Lagrange sont dans un tableau global nomme lambda.

*/
int relaxation(Arete ** liste, Arete ** liste0, int nb_liste, int nb_liste0) {

  double alpha = alpha_initial;

  for (int i = 0; i < nb_liste; i++) liste_relax[i] = liste[i];
  for (int i = 0; i < nb_liste0; i++) liste0_relax[i] = liste0[i];

  // debut de la  recherche du maximum de la fonction duale
  for (int num_iter = 1; num_iter <= nb_iter; num_iter++) {
	  /* calcul de l'arbre qui minimise la fonction de Lagrange pour les valeurs
		 actuelles des lambdas ; la liste des aretes de cet arbre est dans 
		 un_arbre_relax (variable globale). */
	  meilleur_un_arbre_relax(nb_liste, nb_liste0);

	  // valeur de la fonction duale pour les valeurs actuelles des lambdas
	  double valeur = valeur_fonction_duale();

	  /* Regarder si on peut couper en comparant la valeur de la fonction duale 
		 a la borne ; si oui, sortir ; on raffinera la comparaison en utilisant 
		 le fait que le probleme primal admet une solution entiere, alors que 
		 les valeurs de la fonction duale sont reelles (si la borne vaut 40 et 
		 que valeur vaut 39.001, on ne peut pas faire moins que 40 et on peut 
		 couper). */

	  if(ceil(valeur) >= borne)
		return 1;

	  /* Regarder si un_arbre_relax est un tour en utilisant le tableau global 
		 degres_arbre_relax qui contient les degres des sommets de un_arbre_relax. */

	  int est_ch; // est_ch == n ssi chemin hamiltonien ssi degres == 2 à tout les sommets
	  for(est_ch = 0 ; (est_ch < n) && (degres_arbre_relax[est_ch] <= 2) ; est_ch++);

	  /* S'il s'agit d'un tour :
		 calculer le poids de ce tour ;
		 l'appel de poids(un_arbre_relax) renvoie ce poids.
		 S'il le faut, mettre ce poids dans borne et sauvegarder
		 le tour correspondant par l'instruction
		 sauvegarde_solution(un_arbre_relax).
		 Quitter la fonction relaxation en renvoyant la valeur appropriee.
		 utiliser eventuellement :
		 printf("borne = %d\n", borne);
		 pour voir ou en est la borne.
	  */
	  if(est_ch == n) {
		int poids_1a = poids(un_arbre_relax);
		if(poids_1a < borne) {
		  borne = poids_1a;
		  sauvegarde_solution(un_arbre_relax);
		  printf("borne = %d\n", borne);
		}
		return 0;
	  }

	  if (num_iter == nb_iter) break;
	  /* Si les remarques precedentes n'ont pas permis de conclure,
		 calculer de nouvelles valeurs des lambdas (voir le cours).
	  */

	  double norme_d2 = 0;
	  for(int i = 0 ; i < n ; i++) {
		norme_d2+=(degres_arbre_relax[i]-2)*(degres_arbre_relax[i]-2);
	  }

	  double s = alpha * (borne - valeur)/norme_d2;
	  for (int i = 0 ; i < n ; i++) {
		lambda[i] += s*(degres_arbre_relax[i]-2);
	  }

	  /* Ne pas trop se preoccuper de cette boucle qui sert a eviter  une divergence
		 de la recherche de l'optimum,
		 . */
	  for (int i = 0; i < n; i++) {
		if ((lambda[i] > borne) || (lambda[i] < -borne)) lambda[i] = 0;
	  }

	  /* Faire decroitre la valeur de alpha (on peut eventuellement laisser
		 toujours ce parametre a la valeur alpha_initial) */
	  alpha *= 0.8;

  }
  return 0;
}