#include "cplex.h"
#include <algorithm>
using namespace std;

#ifdef DEBUG_CPLEX
#define DEBUG_CPLEX_PRINT(a) std::cout<<a<<std::endl;
#else
#define DEBUG_CPLEX_PRINT(a)
#endif

#ifndef EPSILON
#define EPSILON 1e-5
#endif

/**
 * Constructeur utilisé à des fins de debug
 */
//Cplex::Cplex(int nbCol, int nbCentrales, int nbSem)
Cplex::Cplex(int nbCol, week_t nbSem) : nbColonnes(nbCol), nbSemaines(nbSem) {}

Cplex::Cplex(DualAscent& da)
{
    /* Supprime la colonne fictive liée aux centrales thermiques */
    da.vireColonneThermique();

    /* Traitement des attributs hors clique */
    //Allocation dynamique
    nbColonnes = da.cost.size(); // nombre de colonnes
    nbCentraleNucl = I();
    nbSemaines = H();
    cl = new double[nbColonnes]; //cout des colonnes. Taille = nb colonnes
    ct = new double[nbSemaines]; //cout unitaire prod thermique. Taille = nb semaines
    dt = new double[nbSemaines]; //Demande (vecteur b) ; partie production. Taille = nb semaines
    Mint = new double[nbSemaines]; //Prod thermique min. Taille  = nb semaines
    Maxt = new double[nbSemaines]; // prod thermique max. Taille = nb semaines
    affect = new int*[nbColonnes];
    dlt = new double*[nbColonnes]; //matrice A ; partie production. Taille = nbColonnes x nbSemaines

    //Initialisation
    for ( int i=0 ; i < nbColonnes ; i++ ){
        cl[i] = da.cost[i];
	dlt[i] = new double[nbSemaines];
	affect[i] = new int[I()];
        for( week_t w = (week_t) 0; w<nbSemaines; w=(week_t) (w+1) )
        {
            ct[w] = CInstanceReduite::ThCout(w);
            dt[w] = da.b[w];
            Mint[w] = CInstanceReduite::ThProdMin(w);
            Maxt[w] = CInstanceReduite::ThProdMax(w);
            dlt[i][w] = da.a(i,w);
        }
	for( powerplants2_t cent = (powerplants2_t) 0; cent < I(); cent = (powerplants2_t) (cent+1))
	{
	    affect[i][cent] = (int) da.a(i,H()+cent);
	}
    }

    /* Traitement des cliques */
    //On travaille sur des vector, puis on copiera dans des tableaux pour appeler Cplex
    vector<vector<int> > vclique(nbColonnes);
    vector<int> vbc;
    contrainte14 ( vclique, vbc);
    contrainte15 ( vclique, vbc);
    contrainte16 ( vclique, vbc);
    contrainte17 ( vclique, vbc);
    contrainte18 ( vclique, vbc);
    contrainte19 ( vclique, vbc);
    contrainte20 ( vclique, vbc);
    contrainte21 ( vclique, vbc);


    nbClique = vbc.size(); // Nombre de contraintes de clique
    clique = new int*[nbColonnes]; // Contraintes de clique. Taille = nbColonnes x nbCliques
    for ( int i=0 ; i < nbColonnes ; i++ )
    {
    	clique[i] = new int[nbClique];
    	for ( int j=0 ; j < nbClique ; j++ )
    	{
    		clique[i][j] = vclique[j][i];
    	}
    }
    bc = new int[nbClique]; // Second membre des contraintes de clique. Taille = nbClique
    for ( int i=0 ; i < nbClique ; i++ )
    {
/*        clique[i] = new int[nbColonnes];
        for ( int j=0 ; j < nbColonnes ; j++ )
        {
            clique[i][j] = vclique[i][j];
        }//*/
        bc[i] = vbc[i];
    }
}

void Cplex::contrainte14 (std::vector<std::vector<int> >& vclique, std::vector<int>& vbc)
{
    #ifdef TEST_CC14
    for ( int subset=0 ; subset < 1 ; subset++ )
    #else
    for ( int subset=0 ; subset < CInstance::M((constraint_t) 14) ; subset++ )
    #endif
    {
        #ifdef TEST_CC14
        vector<powerplants2_t> test; test.push_back((powerplants2_t) 0);
        test.push_back((powerplants2_t) 1);test.push_back((powerplants2_t) 2);
        vector<powerplants2_t> centralesDuSubset = test;
        wlen_t Se = (wlen_t) 1;
        #else
        vector<powerplants2_t> centralesDuSubset = CInstance::m_constraints14[subset].C();
        wlen_t Se = CInstance::m_constraints14[subset].Se() ;
        #endif
        int nbCentralesDuSubset = centralesDuSubset.size();

        for ( powerplants2_t i=(powerplants2_t) 0 ; i < nbCentralesDuSubset ; i = (powerplants2_t) (i+1) )
        {
            DEBUG_CPLEX_PRINT("powerplant i "<<i<<"/"<<nbCentralesDuSubset);
            int idx_i = centralesDuSubset[i];
            for ( powerplants2_t iprime= (powerplants2_t) 0 ; iprime < nbCentralesDuSubset ; iprime = (powerplants2_t) (iprime+1) )
            {
                DEBUG_CPLEX_PRINT("\tpowerplant iprime "<<iprime<<"/"<<nbCentralesDuSubset);
                if ( i == iprime ){
                    continue;
                }
                int idx_iprime = centralesDuSubset[iprime];

                for (  int i_colonne=0 ; i_colonne < (int) Clique::annuaire[idx_i].size() ; i_colonne++ )
                {
                    DEBUG_CPLEX_PRINT("\t\tcolonne i "<<i_colonne<<"/"<<Clique::annuaire[idx_i].size());
                    int idx_colonne = Clique::annuaire[idx_i][i_colonne];
                    for (  int i_colonneprime=0 ; i_colonneprime < (int) Clique::annuaire[idx_iprime].size() ; i_colonneprime++ )
                    {
                        DEBUG_CPLEX_PRINT("\t\t\tcolonne iprime "<<i_colonneprime<<"/"<<Clique::annuaire[idx_iprime].size());
                        int idx_colonneprime = Clique::annuaire[idx_iprime][i_colonneprime];
                        DEBUG_CPLEX_PRINT("\t\t\tidx_colonneprime "<<idx_colonneprime<<"/"<<nbColonnes);
                        for ( int k=0 ; k <(int) Clique::dateDebutOutageCampagneK[idx_colonne].size() ; k++ )
                        {
                            DEBUG_CPLEX_PRINT("\t\t\t\tk "<<k<<"/"<<Clique::dateDebutOutageCampagneK[idx_colonne].size());
                            for ( int kprime=0 ; kprime < (int) Clique::dateDebutOutageCampagneK[idx_colonneprime].size() ; kprime++ )
                            {
                                DEBUG_CPLEX_PRINT("\t\t\t\t\tkprime "<<kprime<<"/"<<Clique::dateDebutOutageCampagneK[idx_colonneprime].size());
                                if ( (Clique::dateDebutOutageCampagneK[idx_colonne][k] - Clique::dateFinOutageCampagneK[idx_colonneprime][kprime] < Se)
                                    && (Clique::dateDebutOutageCampagneK[idx_colonneprime][kprime] - Clique::dateFinOutageCampagneK[idx_colonne][k] < Se) )
                                {
                                    DEBUG_CPLEX_PRINT("\t\t\t\t\t Ajout d'une contrainte");
                                    vector<int> contrainte(nbColonnes, 0);
                                    contrainte[idx_colonne] = contrainte[idx_colonneprime] = 1;
                                    vclique.push_back(contrainte);
                                    vbc.push_back(1);
                                    DEBUG_CPLEX_PRINT("\t\t\t\t\t Fin de l'ajout de la contrainte");
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

void Cplex::contrainte15(vector<vector<int> >& vclique, vector<int>& vbc)
{
    for ( int subset=0 ; subset < CInstance::M((constraint_t) 15) ; subset++ )
    {
        vector<powerplants2_t> centralesDuSubset = CInstance::m_constraints15[subset].C();
        wlen_t Se = CInstance::m_constraints15[subset].Se() ;
        week_t IDm = CInstance::m_constraints15[subset].ID() ;
        week_t IFm = CInstance::m_constraints15[subset].IF() ;

        int nbCentralesDuSubset = centralesDuSubset.size();

        for ( powerplants2_t i=(powerplants2_t) 0 ; i < nbCentralesDuSubset ; i = (powerplants2_t) (i+1) )
        {
            int idx_i = centralesDuSubset[i];
            for ( powerplants2_t iprime= (powerplants2_t) 0 ; iprime < nbCentralesDuSubset ; iprime = (powerplants2_t) (iprime+1) )
            {
                if ( i == iprime ){
                    continue;
                }
                int idx_iprime = centralesDuSubset[iprime];

                for (  int i_colonne=0 ; i_colonne < Clique::annuaire[idx_i].size() ; i_colonne++ )
                {
                    int idx_colonne = Clique::annuaire[idx_i][i_colonne];
                    for (  int i_colonneprime=0 ; i_colonneprime < Clique::annuaire[idx_iprime].size() ; i_colonneprime++ )
                    {
                        int idx_colonneprime = Clique::annuaire[idx_iprime][i_colonneprime];
                        for ( int k=0 ; k < Clique::dateDebutOutageCampagneK[idx_colonne].size() ; k++ )
                        {
                            for ( int kprime=0 ; kprime < Clique::dateDebutOutageCampagneK[idx_colonneprime].size() ; kprime++ )
                            {
                                int DAk = CInstance::type2((powerplants2_t) idx_i).DA((campaign_t) k);
                                int DAkprime = CInstance::type2((powerplants2_t) idx_iprime).DA((campaign_t) kprime);
                                // Ajout du test pour valider la contrainte
                                if (    (IDm - DAk+1 <=Clique::dateDebutOutageCampagneK[idx_colonne][k])
                                        &&( Clique::dateDebutOutageCampagneK[idx_colonne][k]<= IFm )
                                        &&(IDm - DAkprime+1 <=Clique::dateDebutOutageCampagneK[idx_colonneprime][kprime])
                                        &&( Clique::dateDebutOutageCampagneK[idx_colonneprime][kprime]<= IFm ) )
                                {
                                    if ( (Clique::dateDebutOutageCampagneK[idx_colonne][k] - Clique::dateFinOutageCampagneK[idx_colonneprime][kprime] < Se)
                                        && (Clique::dateDebutOutageCampagneK[idx_colonneprime][kprime] - Clique::dateFinOutageCampagneK[idx_colonne][k] < Se) )
                                    {
                                        vector<int> contrainte(nbColonnes, 0);
                                        contrainte[idx_colonne] = contrainte[idx_colonneprime] = 1;
                                        vclique.push_back(contrainte);
                                        vbc.push_back(1);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

void Cplex::contrainte16(vector<vector<int> >& vclique, vector<int>& vbc)
{
    for ( int subset=0 ; subset < CInstance::M((constraint_t) 16) ; subset++ )
    {
        vector<powerplants2_t> centralesDuSubset = CInstance::m_constraints16[subset].C();
        wlen_t Se = CInstance::m_constraints16[subset].Se() ;
        int nbCentralesDuSubset = centralesDuSubset.size();

        for ( powerplants2_t i=(powerplants2_t) 0 ; i < nbCentralesDuSubset ; i = (powerplants2_t) (i+1) )
        {
            int idx_i = centralesDuSubset[i];
            for ( powerplants2_t iprime= (powerplants2_t) 0 ; iprime < nbCentralesDuSubset ; iprime = (powerplants2_t) (iprime+1) )
            {
                if ( i == iprime ){
                    continue;
                }
                int idx_iprime = centralesDuSubset[iprime];

                for (  int i_colonne=0 ; i_colonne < Clique::annuaire[idx_i].size() ; i_colonne++ )
                {
                    int idx_colonne = Clique::annuaire[idx_i][i_colonne];
                    for (  int i_colonneprime=0 ; i_colonneprime < Clique::annuaire[idx_iprime].size() ; i_colonneprime++ )
                    {
                        int idx_colonneprime = Clique::annuaire[idx_iprime][i_colonneprime];
                        for ( int k=0 ; k < Clique::dateDebutOutageCampagneK[idx_colonne].size() ; k++ )
                        {
                            for ( int kprime=0 ; kprime < Clique::dateDebutOutageCampagneK[idx_colonneprime].size() ; kprime++ )
                            {
                                if ( abs(Clique::dateDebutOutageCampagneK[idx_colonne][k] - Clique::dateDebutOutageCampagneK[idx_colonneprime][kprime]) < Se)
                                {
                                    vector<int> contrainte(nbColonnes, 0);
                                    contrainte[idx_colonne] = contrainte[idx_colonneprime] = 1;
                                    vclique.push_back(contrainte);
                                    vbc.push_back(1);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

void Cplex::contrainte17(vector<vector<int> >& vclique, vector<int>& vbc)
{
    for ( int subset=0 ; subset < CInstance::M((constraint_t) 17) ; subset++ )
    {
        vector<powerplants2_t> centralesDuSubset = CInstance::m_constraints17[subset].C();
        wlen_t Se = CInstance::m_constraints17[subset].Se() ;
        int nbCentralesDuSubset = centralesDuSubset.size();

        for ( powerplants2_t i=(powerplants2_t) 0 ; i < nbCentralesDuSubset ; i = (powerplants2_t) (i+1) )
        {
            int idx_i = centralesDuSubset[i];
            for ( powerplants2_t iprime= (powerplants2_t) 0 ; iprime < nbCentralesDuSubset ; iprime = (powerplants2_t) (iprime+1) )
            {
                if ( i == iprime ){
                    continue;
                }
                int idx_iprime = centralesDuSubset[iprime];

                for (  int i_colonne=0 ; i_colonne < Clique::annuaire[idx_i].size() ; i_colonne++ )
                {
                    int idx_colonne = Clique::annuaire[idx_i][i_colonne];
                    for (  int i_colonneprime=0 ; i_colonneprime < Clique::annuaire[idx_iprime].size() ; i_colonneprime++ )
                    {
                        int idx_colonneprime = Clique::annuaire[idx_iprime][i_colonneprime];
                        for ( int k=0 ; k < Clique::dateDebutOutageCampagneK[idx_colonne].size() ; k++ )
                        {
                            for ( int kprime=0 ; kprime < Clique::dateDebutOutageCampagneK[idx_colonneprime].size() ; kprime++ )
                            {
                                if ( abs(Clique::dateFinOutageCampagneK[idx_colonne][k] - Clique::dateFinOutageCampagneK[idx_colonneprime][kprime]) < Se)
                                {
                                    vector<int> contrainte(nbColonnes, 0);
                                    contrainte[idx_colonne] = contrainte[idx_colonneprime] = 1;
                                    vclique.push_back(contrainte);
                                    vbc.push_back(1);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}


void Cplex::contrainte18(vector<vector<int> >& vclique, vector<int>& vbc)
{
    for ( int subset=0 ; subset < CInstance::M((constraint_t) 18) ; subset++ )
    {
        vector<powerplants2_t> centralesDuSubset = CInstance::m_constraints18[subset].C();
        wlen_t Se = CInstance::m_constraints18[subset].Se() ;
        int nbCentralesDuSubset = centralesDuSubset.size();

        for ( powerplants2_t i=(powerplants2_t) 0 ; i < nbCentralesDuSubset ; i = (powerplants2_t) (i+1) )
        {
            int idx_i = centralesDuSubset[i];
            for ( powerplants2_t iprime= (powerplants2_t) 0 ; iprime < nbCentralesDuSubset ; iprime = (powerplants2_t) (iprime+1) )
            {
                if ( i == iprime ){
                    continue;
                }
                int idx_iprime = centralesDuSubset[iprime];

                for (  int i_colonne=0 ; i_colonne < Clique::annuaire[idx_i].size() ; i_colonne++ )
                {
                    int idx_colonne = Clique::annuaire[idx_i][i_colonne];
                    for (  int i_colonneprime=0 ; i_colonneprime < Clique::annuaire[idx_iprime].size() ; i_colonneprime++ )
                    {
                        int idx_colonneprime = Clique::annuaire[idx_iprime][i_colonneprime];
                        for ( int k=0 ; k < Clique::dateDebutOutageCampagneK[idx_colonne].size() ; k++ )
                        {
                            for ( int kprime=0 ; kprime < Clique::dateDebutOutageCampagneK[idx_colonneprime].size() ; kprime++ )
                            {
                                if ( abs(Clique::dateFinOutageCampagneK[idx_colonne][k] - Clique::dateDebutOutageCampagneK[idx_colonneprime][kprime]) < Se)
                                {
                                    vector<int> contrainte(nbColonnes, 0);
                                    contrainte[idx_colonne] = contrainte[idx_colonneprime] = 1;
                                    vclique.push_back(contrainte);
                                    vbc.push_back(1);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

void Cplex::contrainte19(vector<vector<int> >& vclique, vector<int>& vbc)
{
    #ifdef TEST_CC19
    for ( int c19=0 ; c19 < 1 ; c19++ )
    #else
    for ( int c19=0 ; c19 < CInstance::M((constraint_t) 19) ; c19++  )
    #endif
    {
        #ifdef TEST_CC19
        vector<powerplants2_t> test; test.push_back((powerplants2_t) 0);
        test.push_back((powerplants2_t) 1);test.push_back((powerplants2_t) 2);
        vector<powerplants2_t> centralesDuSubset = test;
        vector<vector<int> > utilisationRessource (10, vector<int> (Cplex::nbColonnes, 0) ) ;// utilisationRessource[w][c] si la colonne c utilise la ressource
        int nbCentralesDuSubset = centralesDuSubset.size();
        int nbRessources = 2;
        #else
        vector<powerplants2_t> centralesDuSubset = CInstance::m_constraints19[c19].C();
        vector<vector<int> > utilisationRessource (CInstance::H(), vector<int> (Cplex::nbColonnes, 0) ) ;// utilisationRessource[w][c] si la colonne c utilise la ressource
        int nbCentralesDuSubset = centralesDuSubset.size();
        int nbRessources = CInstance::m_constraints19[c19].Q();
        #endif

        for ( int i= 0 ; i < nbCentralesDuSubset ; i++ )
        {
            powerplants2_t idx_i = centralesDuSubset[i];
            for (  int i_colonne=0 ; i_colonne < Clique::annuaire[(int) idx_i].size() ; i_colonne++ )
            {
                int idx_colonne = Clique::annuaire[idx_i][i_colonne];
                for ( campaign_t k=(campaign_t) 0 ; k < Clique::dateDebutOutageCampagneK[idx_colonne].size() ; k=(campaign_t) (k+1) )
                {
                    #ifdef TEST_CC19
                    int start = 0;
                    int duree = 2;
                    #else
                    int start = CInstance::m_constraints19[c19].L(idx_i,k);
                    int duree = CInstance::m_constraints19[c19].TU(idx_i,k);
                    #endif
                    for ( int w=0 ; (w<duree )&& ((w+start+Clique::dateDebutOutageCampagneK[idx_colonne][k])<nbSemaines) ; w++ )
                    {
                        utilisationRessource[w+start+Clique::dateDebutOutageCampagneK[idx_colonne][k]][idx_colonne] = 1;
                    }
                }
            }
        }

#ifdef TEST_CC19
        for ( week_t w=(week_t) 0 ; w < 10 ; w = (week_t) (w+1) )
#else
        for ( week_t w=(week_t) 0 ; w < CInstance::H() ; w = (week_t) (w+1) )
#endif
        {
            int compteur = 0;
            for ( int col=0 ; col < nbColonnes ; col++ )
            {
                compteur += utilisationRessource[w][col];
            }

            //S'il y a une limite à ce pas de temps, ajouter la contrainte à vclique
            if ( compteur > nbRessources )
            {
                vclique.push_back(utilisationRessource[w]);
                vbc.push_back(nbRessources);
            }
        }
    }
}

void Cplex::contrainte20(vector<vector<int> >& vclique, vector<int>& vbc)
{
    #ifdef TEST_CC20
    for ( int c20=0 ; c20 < 1 ; c20++ )
    #else
    for ( int c20=0 ; c20 < CInstance::M((constraint_t) 20) ; c20++  )
    #endif
    {
        #ifdef TEST_CC20
        vector<powerplants2_t> test; test.push_back((powerplants2_t) 0);
        test.push_back((powerplants2_t) 1);test.push_back((powerplants2_t) 2);
        vector<powerplants2_t> centralesDuSubset = test;
        vector<int> centralesAuRepos (Cplex::nbColonnes, 0 ) ;// centralesAuRepos[c] si la colonne c est en outage
        int nbCentralesDuSubset = centralesDuSubset.size();
        int nbOutageMax = 2;
        week_t semaineConsideree = (week_t) 9;
        #else
        vector<powerplants2_t> centralesDuSubset = CInstance::m_constraints20[c20].C();
        vector<int> centralesAuRepos (Cplex::nbColonnes, 0 ) ;// centralesAuRepos[c] si la colonne c est en outage
        int nbCentralesDuSubset = centralesDuSubset.size();
        int nbOutageMax = CInstance::m_constraints20[c20].N();
        week_t semaineConsideree = CInstance::m_constraints20[c20].h();
        #endif

        int compteurCentralesAuRepos = 0;

        for ( int i= 0 ; i < nbCentralesDuSubset ; i++ )
        {
            powerplants2_t idx_i = centralesDuSubset[i];
            for (  int i_colonne=0 ; i_colonne < Clique::annuaire[(int) idx_i].size() ; i_colonne++ )
            {
                int idx_colonne = Clique::annuaire[idx_i][i_colonne];
                for ( campaign_t k=(campaign_t) 0 ; k < Clique::dateDebutOutageCampagneK[idx_colonne].size() ; k=(campaign_t) (k+1) )
                {
                    if (    (Clique::dateDebutOutageCampagneK[idx_colonne][k] <= semaineConsideree)
                            && ( Clique::dateFinOutageCampagneK[idx_colonne][k] > semaineConsideree) )
                    {
                        centralesAuRepos[idx_colonne] =1;
                        compteurCentralesAuRepos++;
                        break;
                    }
                    if ( Clique::dateDebutOutageCampagneK[idx_colonne][k] > semaineConsideree)
                    {
                       break;
                    }
                }

            }
        }
        if (compteurCentralesAuRepos > nbOutageMax)
        {
            vclique.push_back(centralesAuRepos);
            vbc.push_back(nbOutageMax);
        }
    }
}

void Cplex::contrainte21(vector<vector<int> >& vclique, vector<int>& vbc)
{
    #ifdef TEST_CC21
    for ( int c21=0 ; c21 < 1 ; c21++ )
    #else
    for ( int c21=0 ; c21 < CInstance::M((constraint_t) 21) ; c21++  )
    #endif
    {
        #ifdef TEST_CC21
        vector<powerplants2_t> test; test.push_back((powerplants2_t) 0);
        test.push_back((powerplants2_t) 1);test.push_back((powerplants2_t) 2);
        vector<powerplants2_t> centralesDuSubset = test;
        CIntervalle intervalle;
        intervalle.start = (week_t) 2;
        intervalle.end = (week_t) 5 ;
        vector<vector<int> > puissanceAuRepos ((int) (intervalle.end-intervalle.start+1), vector<int> (Cplex::nbColonnes, 0) ) ;// puissanceAuRepos[w-intervalle.start][c] = 0 si la colonne 'c' est utilisée, et sa PMAX sinon,
        int nbCentralesDuSubset = centralesDuSubset.size();
        double puissanceMaxAuRepos = 5.0 ;
        #else
        vector<powerplants2_t> centralesDuSubset = CInstance::m_constraints21[c21].C();
        CIntervalle intervalle = CInstance::m_constraints21[c21].IT();
        vector<vector<int> > puissanceAuRepos ((int) (intervalle.end-intervalle.start+1), vector<int> (Cplex::nbColonnes, 0) ) ;// puissanceAuRepos[w-intervalle.start][c] = 0 si la colonne 'c' est utilisée, et sa PMAX sinon,
        int nbCentralesDuSubset = centralesDuSubset.size();
        double puissanceMaxAuRepos = CInstance::m_constraints21[c21].IMAX();
        #endif

        vector<double> compteur(intervalle.end-intervalle.start+1, 0.0);

        //Boucle sur les centrales du subset
        for ( int i= 0 ; i < nbCentralesDuSubset ; i++ )
        {
            //Boucle sur les colonnes relatives à la centrale courante
            powerplants2_t idx_i = centralesDuSubset[i];
            for (  int i_colonne=0 ; i_colonne < Clique::annuaire[(int) idx_i].size() ; i_colonne++ )
            {
                int idx_colonne = Clique::annuaire[idx_i][i_colonne];
                //Boucle sur les campagnes de la colonne active
                for ( campaign_t k=(campaign_t) 0 ; k < Clique::dateDebutOutageCampagneK[idx_colonne].size() ; k=(campaign_t) (k+1) )
                {
                    if ( Clique::dateFinOutageCampagneK[idx_colonne][k] < intervalle.start )
                    {
                        continue;
                    }

                    for ( week_t w = max(intervalle.start,Clique::dateDebutOutageCampagneK[idx_colonne][k])
                    ; w <= min(intervalle.end, Clique::dateFinOutageCampagneK[idx_colonne][k]) ;w=(week_t) (w+1) )
                    {
                        #ifdef TEST_CC21
                        puissanceAuRepos[w-intervalle.start][idx_colonne] = (int) (2.1 + 0.995);
                        compteur[w-intervalle.start] += 2.1;
                        #else
                        puissanceAuRepos[w-intervalle.start][idx_colonne] = (int) (CInstanceReduite::EMAX(idx_i, w) + 0.995);
                        compteur[w-intervalle.start] += CInstanceReduite::EMAX(idx_i, w);
                        #endif
                    }
                    if ( Clique::dateDebutOutageCampagneK[idx_colonne][k] > intervalle.end )
                    {
                        break;
                    }
                }
            }
        }

        //Ajout éventuel aux contraintes de clique
        for ( int w = 0 ; w < compteur.size() ; w++)
        {
            if ( compteur[w] > puissanceMaxAuRepos )
            // Ajout de la contrainte avec arrondis par passage en int from double
            {
                vclique.push_back(puissanceAuRepos[w]);
                vbc.push_back((int) puissanceMaxAuRepos );
            }
        }
    }
}

/* This simple routine frees up the pointer *ptr, and sets *ptr to NULL */
void Cplex::free_and_null (char **ptr)
{
   if ( *ptr != NULL ) {
      free (*ptr);
      *ptr = NULL;
   }
} /* END free_and_null */

int Cplex::setproblemdata (char **probname_p, int *numcols_p, int *numrows_p,
                int *objsen_p, double **obj_p, double **rhs_p,
                char **sense_p, int **matbeg_p, int **matcnt_p,
                int **matind_p, double **matval_p,
                double **lb_p, double **ub_p, char **ctype_p)
{
   char     *zprobname = NULL;     /* Problem name <= 16 characters */
   double   *zobj = NULL;
   double   *zrhs = NULL;
   char     *zsense = NULL;
   int      *zmatbeg = NULL;
   int      *zmatcnt = NULL;
   int      *zmatind = NULL;
   double   *zmatval = NULL;
   double   *zlb = NULL;
   double   *zub = NULL;
   char     *zctype = NULL;
   int      status = 0;
   int i,j;

   zprobname = (char *) malloc (16 * sizeof(char));
   zobj      = (double *) malloc (NUMCOLS * sizeof(double));
   zrhs      = (double *) malloc (NUMROWS * sizeof(double));
   zsense    = (char *) malloc (NUMROWS * sizeof(char));
   zmatbeg   = (int *) malloc (NUMCOLS * sizeof(int));
   zmatcnt   = (int *) malloc (NUMCOLS * sizeof(int));
   zmatind   = (int *) malloc (NUMNZ * sizeof(int));
   zmatval   = (double *) malloc (NUMNZ * sizeof(double));
   zlb       = (double *) malloc (NUMCOLS * sizeof(double));
   zub       = (double *) malloc (NUMCOLS * sizeof(double));
   zctype    = (char *) malloc (NUMCOLS * sizeof(char));

   if ( zprobname == NULL || zobj    == NULL ||
        zrhs      == NULL || zsense  == NULL ||
        zmatbeg   == NULL || zmatcnt == NULL ||
        zmatind   == NULL || zmatval == NULL ||
        zctype    == NULL ||
        zlb       == NULL || zub     == NULL   )  {
      status = 1;
      goto TERMINATE;
   }

   strcpy (zprobname, "mip");

   /* The code is formatted to make a visual correspondence
      between the mathematical linear program and the specific data
      items.   */
	/* This function fills in the data structures for the linear program: */


   for(i=0;i<NUMNucl;i++)
		zobj[i] = cl[i];
   for(i=NUMNucl;i<NUMCOLS;i++)
		zobj[i] = ct[i-NUMNucl];

//	zobj[0]  = 1.0;  zobj[1]    = 2.0;  zobj[2]    = 3.0;

   for(i=0;i<NUMROWS;i++)
   {
     if (i<NUMTps)
     {
       zsense[i] = 'E'; //mettre 'G' si contrainte >=
       zrhs[i] = dt[i];
     }
     else if(i>=NUMTps && i<(NUMTps+NUMAff))
     {
       zsense[i] = 'E';
       zrhs[i] = 1.0;
     }
     else
     {
       zsense[i] = 'L';
       zrhs[i] = (double)bc[i-(NUMTps+NUMAff)];
     }
   }

   for(i=0;i<NUMCOLS;i++) {
      if (i == 0)
      {
         zmatbeg[i] = 0;
//          printf("1)zmatbeg[%d]=%d\n",i,zmatbeg[i]);
      }
      else
      {
         zmatbeg[i] = zmatbeg[i-1] + zmatcnt[i-1];
//        printf("2)zmatcnt[%d]=%d et zmatbeg[%d]=%d\n",i-1,zmatcnt[i-1],i,zmatbeg[i]);
      }
      if (i<NUMNucl)
      {
         zmatcnt[i] = NUMROWS;
      }
      else
      {
         zmatcnt[i] = NUMROWS;
      }

      for(j=0;j<NUMROWS;j++)
      {
         zmatind[zmatbeg[i]+j] = j;
//          printf("j=%d, zmatbeg[%d]=%d et zmatind[%d]=%d\n",j,i,zmatbeg[i],zmatbeg[i]+j,zmatind[zmatbeg[i]+j]);
	 if(i<NUMNucl && j<NUMTps)
         {
            zmatval[zmatbeg[i]+j] = dlt[i][j];
//             printf("0)i=%d j=%d dlt=%lf zmatbeg=%d zmatval=%lf\n", i, j, dlt[i][j], zmatbeg[i], zmatval[zmatbeg[i]+j]);
         }
	 else if(i<NUMNucl && j>=NUMTps)
         {
            if(j<NUMTps+NUMAff)
            {
               if(affect[i][j-NUMTps]==1)
                  zmatval[zmatbeg[i]+j] = 1.0;
               else
                  zmatval[zmatbeg[i]+j] = 0.0;
            }
            else
            {
//                printf("Pb: i=%d j=%d NUMTps=%d NUMAFF=%d \n", i, j, NUMTps, NUMAff);
               if(clique[i][j-(NUMTps+NUMAff)]>EPSILON)//MODIF pour accepter la contrainte 21
               {
                  zmatval[zmatbeg[i]+j] = clique[i][j-(NUMTps+NUMAff)];// A revoir contrainte 21cl
                  
               }
               else
               {
                  zmatval[zmatbeg[i]+j] = 0.0;
               }
            }
//             printf("1)i=%d j=%d zmatbeg=%d zmatval=%lf\n", i, j, zmatbeg[i], zmatval[zmatbeg[i]+j]);
         }
	 else if(i>=NUMNucl && j<NUMTps)
         {
            if((i-NUMNucl)==j)
            {
               zmatval[zmatbeg[i]+j] = 1.0;
//                printf("2)i=%d j=%d zmatbeg=%d zmatval=%lf\n", i, j, zmatbeg[i], zmatval[zmatbeg[i]+j]);
            }
            else
            {
               zmatval[zmatbeg[i]+j] = 0.0;
//                printf("3)i=%d j=%d zmatbeg=%d zmatval=%lf\n", i, j, zmatbeg[i], zmatval[zmatbeg[i]+j]);
            }
//             printf("2)i=%d j=%d zmatbeg=%d zmatval=%lf\n", i, j, zmatbeg[i], zmatval[zmatbeg[i]+j]);
         }
         else
         {
            zmatval[zmatbeg[i]+j] = 0.0;
//             printf("3)i=%d j=%d zmatbeg=%d zmatval=%lf\n", i, j, zmatbeg[i], zmatval[zmatbeg[i]+j]);
         }
      }
   }
/*
   zmatbeg[0] = 0;    zmatbeg[1] = 2;    zmatbeg[2] = 4;
   zmatcnt[0] = 2;    zmatcnt[1] = 2;    zmatcnt[2] = 2;

   zmatind[0] = 0;    zmatind[2] = 0;    zmatind[4] = 0;    zsense[0] = 'L';
   zmatval[0] = -1.0; zmatval[2] = 1.0;  zmatval[4] = 1.0;  zrhs[0]   = 20.0;

   zmatind[1] = 1;    zmatind[3] = 1;    zmatind[5] = 1;    zsense[1] = 'L';
   zmatval[1] = 1.0;  zmatval[3] = -3.0; zmatval[5] = 1.0;  zrhs[1]   = 30.0;*/

   for(i=0;i<NUMNucl;i++) {
      zlb[i] = 0.0;
      zub[i] = 1.0;
      zctype[i] = 'B';
   }
   for(i=NUMNucl;i<NUMCOLS;i++) {
      zlb[i] = Mint[i-NUMNucl];
      zub[i] = Maxt[i-NUMNucl];
      zctype[i] = 'C';
   }
/*	zlb[0] = 0.0;      zlb[1] = 0.0;          zlb[2] = 0.0;
       zub[0] = 40.0;     zub[1] = CPX_INFBOUND; zub[2] = CPX_INFBOUND;*/

TERMINATE:

   if ( status ) {
      free_and_null ((char **) &zprobname);
      free_and_null ((char **) &zobj);
      free_and_null ((char **) &zrhs);
      free_and_null ((char **) &zsense);
      free_and_null ((char **) &zmatbeg);
      free_and_null ((char **) &zmatcnt);
      free_and_null ((char **) &zmatind);
      free_and_null ((char **) &zmatval);
      free_and_null ((char **) &zlb);
      free_and_null ((char **) &zub);
      free_and_null ((char **) &zctype);
   }
   else {
      *numcols_p   = NUMCOLS;
      *numrows_p   = NUMROWS;
      *objsen_p    = CPX_MIN;   /* The problem is minimization */

      *probname_p  = zprobname;
      *obj_p       = zobj;
      *rhs_p       = zrhs;
      *sense_p     = zsense;
      *matbeg_p    = zmatbeg;
      *matcnt_p    = zmatcnt;
      *matind_p    = zmatind;
      *matval_p    = zmatval;
      *lb_p        = zlb;
      *ub_p        = zub;
      *ctype_p     = zctype;
   }
   return (status);

}  /* END setproblemdata */

vector<double> Cplex::resolution()
{
   /* Declare pointers for the variables and arrays that will contain
      the data which define the LP problem.  The setproblemdata() routine
      allocates space for the problem data.  */

	vector<double> result;
   char     *probname = NULL;
   int      numcols;
   int      numrows;
   int      objsen;
   double   *obj = NULL;
   double   *rhs = NULL;
   char     *sense = NULL;
   int      *matbeg = NULL;
   int      *matcnt = NULL;
   int      *matind = NULL;
   double   *matval = NULL;
   double   *lb = NULL;
   double   *ub = NULL;
   char     *ctype = NULL;

   /* Declare and allocate space for the variables and arrays where we
      will store the optimization results including the status, objective
      value, variable values, dual values, row slacks and variable
      reduced costs. */

//   init();

   NUMNucl = nbColonnes;
   NUMTps = H();
   NUMAff = I();
   NUMCliq = nbClique;

   NUMCOLS = NUMNucl+NUMTps;
   NUMROWS = NUMTps+NUMAff+NUMCliq;
   NUMNZ = NUMROWS * NUMCOLS;

   int      solstat;
   double   objval;
   double   x[NUMCOLS];
   double   pi[NUMROWS];
   double   slack[NUMROWS];
   double   dj[NUMCOLS];


   CPXENVptr     env = NULL;
   CPXLPptr      lp = NULL;
   int           status;
   int           i, j;
   int           cur_numrows, cur_numcols;

   /* Initialize the CPLEX environment */

   env = CPXopenCPLEX (&status);

   /* If an error occurs, the status value indicates the reason for
      failure.  A call to CPXgeterrorstring will produce the text of
      the error message.  Note that CPXopenCPLEX produces no output,
      so the only way to see the cause of the error is to use
      CPXgeterrorstring.  For other CPLEX routines, the errors will
      be seen if the CPX_PARAM_SCRIND indicator is set to CPX_ON.  */

   if ( env == NULL ) {
      char  errmsg[1024];
      fprintf (stderr, "Could not open CPLEX environment.\n");
      CPXgeterrorstring (env, status, errmsg);
      fprintf (stderr, "%s", errmsg);
      goto TERMINATE;
   }

   /* Turn on output to the screen */

   status = CPXsetintparam (env, CPX_PARAM_SCRIND, CPX_ON);
   if ( status ) {
      fprintf (stderr,
               "Failure to turn on screen indicator, error %d.\n", status);
      goto TERMINATE;
   }

   /* Allocate memory and fill in the data for the problem.  */

   status = setproblemdata (&probname, &numcols, &numrows, &objsen,
                            &obj, &rhs, &sense, &matbeg, &matcnt,
                            &matind, &matval, &lb, &ub, &ctype);
   if ( status ) {
      fprintf (stderr, "Failed to build problem data arrays.\n");
      goto TERMINATE;
   }

   /* Create the problem. */

   lp = CPXcreateprob (env, &status, probname);

   /* A returned pointer of NULL may mean that not enough memory
      was available or there was some other problem.  In the case of
      failure, an error message will have been written to the error
      channel from inside CPLEX.  In this example, the setting of
      the parameter CPX_PARAM_SCRIND causes the error message to
      appear on stdout.  */

   if ( lp == NULL ) {
      fprintf (stderr, "Failed to create LP.\n");
      goto TERMINATE;
   }

   /* Now copy the problem data into the lp */

   status = CPXcopylp (env, lp, numcols, numrows, objsen, obj, rhs,
                       sense, matbeg, matcnt, matind, matval,
                       lb, ub, NULL);

   if ( status ) {
      fprintf (stderr, "Failed to copy problem data.\n");
      goto TERMINATE;
   }

   /* Now copy the ctype array */

   status = CPXcopyctype (env, lp, ctype);
   if ( status ) {
      fprintf (stderr, "Failed to copy ctype\n");
      goto TERMINATE;
   }

   /* Finally, write a copy of the problem to a file. */

   status = CPXwriteprob (env, lp, "mip.lp", NULL);
   if ( status ) {
      fprintf (stderr, "Failed to write LP to disk.\n");
      goto TERMINATE;
   }

   /* Optimize the problem and obtain solution. */

   status = CPXmipopt (env, lp);
   if ( status ) {
      fprintf (stderr, "Failed to optimize LP.\n");
      goto TERMINATE;
   }

   solstat = CPXgetstat (env, lp);

   /* Write the output to the screen. */

   printf ("\nSolution status = %d\n", solstat);

   status = CPXgetmipobjval (env, lp, &objval);
   if ( status ) {
      fprintf (stderr,"No MIP objective value available.  Exiting...\n");
      goto TERMINATE;
   }

   printf ("Solution value  = %f\n\n", objval);

   /* The size of the problem should be obtained by asking CPLEX what
      the actual size is, rather than using what was passed to CPXcopylp.
      cur_numrows and cur_numcols store the current number of rows and
      columns, respectively.  */

   cur_numrows = CPXgetnumrows (env, lp);
   cur_numcols = CPXgetnumcols (env, lp);

   status = CPXgetmipx (env, lp, x, 0, cur_numcols-1);
   if ( status ) {
      fprintf (stderr, "Failed to get optimal integer x_cplex.\n");
      goto TERMINATE;
   }

   status = CPXgetmipslack (env, lp, slack, 0, cur_numrows-1);
   if ( status ) {
      fprintf (stderr, "Failed to get optimal slack values.\n");
      goto TERMINATE;
   }

   for (i = 0; i < cur_numrows; i++) {
      printf ("Row %d:  Slack = %10f\n", i, slack[i]);
   }

   for (j = 0; j < cur_numcols; j++) {
      printf ("Column %d:  Value = %10f\n", j, x[j]);
   }

   for ( int i=0 ; i < cur_numcols ; i++ )
   {
   		result.push_back(x[i]);
   }


TERMINATE:

   /* Free up the problem as allocated by CPXcreateprob, if necessary */

   if ( lp != NULL ) {
      status = CPXfreeprob (env, &lp);
      if ( status ) {
         fprintf (stderr, "CPXfreeprob failed, error code %d.\n", status);
      }
   }

   /* Free up the CPLEX environment, if necessary */

   if ( env != NULL ) {
      status = CPXcloseCPLEX (&env);

      /* Note that CPXcloseCPLEX produces no output,
         so the only way to see the cause of the error is to use
         CPXgeterrorstring.  For other CPLEX routines, the errors will
         be seen if the CPX_PARAM_SCRIND indicator is set to CPX_ON. */

      if ( status ) {
         char  errmsg[1024];
         fprintf (stderr, "Could not close CPLEX environment.\n");
         CPXgeterrorstring (env, status, errmsg);
         fprintf (stderr, "%s", errmsg);
      }
   }

   /* Free up the problem data arrays, if necessary. */

   free_and_null ((char **) &probname);
   free_and_null ((char **) &obj);
   free_and_null ((char **) &rhs);
   free_and_null ((char **) &sense);
   free_and_null ((char **) &matbeg);
   free_and_null ((char **) &matcnt);
   free_and_null ((char **) &matind);
   free_and_null ((char **) &matval);
   free_and_null ((char **) &lb);
   free_and_null ((char **) &ub);
   free_and_null ((char **) &ctype);

   return (result);
}


Cplex::~Cplex()
{
#ifndef TEST_CC14
#ifndef TEST_CC19
#ifndef TEST_CC20
#ifndef TEST_CC21
    DEBUG_CPLEX_PRINT("deletage de cl");
    delete[] cl;
    DEBUG_CPLEX_PRINT("deletage de ct");
    delete[] ct;
    DEBUG_CPLEX_PRINT("deletage du contenu de dlt, affect et clique");
    for ( int i=0 ; i < nbColonnes ; i++ ){
        delete[] dlt[i];
        delete[] affect[i];
        delete[] clique[i];
    }
    DEBUG_CPLEX_PRINT("deletage de dlt");
    delete[] dlt;
    DEBUG_CPLEX_PRINT("deletage de affect");
    delete[] affect;
    DEBUG_CPLEX_PRINT("deletage de clique");
    delete[] clique;
    DEBUG_CPLEX_PRINT("deletage de dt");
    delete[] dt;
    DEBUG_CPLEX_PRINT("deletage de Mint");
    delete[] Mint;
    DEBUG_CPLEX_PRINT("deletage de Maxt");
    delete[] Maxt;
    DEBUG_CPLEX_PRINT("deletage de bc");
    delete[] bc;
#endif
#endif
#endif
#endif
}