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 ;
}
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 ;
}
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;
}
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);
}
/*
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;
}
