int main(int argc, char** argv) {
Timer total;
if (argc == 1)
return usage();
AvailableModularityBInstances id(static_cast<AvailableModularityBInstances>(atoi(argv[1]) - 1));
RegisteredModularityBInstance instance(id);
// int id_node(0);
// std::string file_name;
// do {
// file_name = GetStr("node/", instance.name(), "_node_", id_node);
// ++id_node;
// } while (std::remove(file_name.c_str()) == 0);
instance.out();
// oracles creation
VnsGenerator vnsOracle(&instance);
instance.setVnsOracle(&vnsOracle);
BinaryDecompositionOracle bMilpOracle(&instance);
instance.setExactOracle(&bMilpOracle);
ModularityBPartition p(instance, instance.nV());
p.score() = p.computeScore();
// std::cout << "DIVISIVE STARTED" << std::endl;
// bipartite::Divisive divisive(instance, p);
// divisive.run();
//std::cout << "VNS STARTED" << std::endl;
//bipartite::VnsLabelPropagation vns(instance, p, 20, 5);
//vns.run();
std::cout << "B&B STARTED" << std::endl;
BranchAndBound branchAndBound(instance);
int nColumnGeneratorNumberByIte(10);
if (argc > 2) {
nColumnGeneratorNumberByIte = atoi(argv[2]);
}
std::cout << "nColumnGeneratorNumberByIte : " << nColumnGeneratorNumberByIte << std::endl;
branchAndBound._columnGenerator.setNumberByIte(nColumnGeneratorNumberByIte);
branchAndBound.init();
branchAndBound.master().addSingleton();
branchAndBound.master().add(p);
branchAndBound.setOutput();
branchAndBound.run();
// branchAndBound.writeSolution();
std::cout << "program run in " << std::setprecision(10) << total.elapsed() << std::endl;
std::cout << "Solution is " << branchAndBound.bestFeasible() << std::endl;
// instance.cps("toto");
return 0;
}
static void buttonCalculerBranchAndBound( GtkWidget *widget,gpointer data ){
if(g == NULL)
afficherMessage("Erreur: Aucun graphe charge",data);
else{
if(choix == -1)
afficherMessage("Aucune ville de depart sélectionnée\n",data);
else
branchAndBound(g, choix);
}
}
int main(void) {
int i, j;
printf("end %d\n", maze[endI][endJ]);
print_maze();
// if(norecursive(startI, startJ) == 0)
// printf("\nfail\n");
// else {
// printf("\nok\n");
// print_maze();
// }
{
Postion start = {0}; Postion end = {0};
start.x = startJ;
start.y = startI;
end.x = endJ;
end.y = endI;
branchAndBound(maze, start, end);
print_maze();
}
return 0;
}
int main(int argc, char* argv[])
{
if (argc != 5)
{
cout << "\t./p5exe N K A directory\n";
exit(1);
}
// Data structures
hash_map<string, int> wordMap;
hash_map<string, int> index;
vector <pair<string, vector<bool> > > bitVectors;
vector<pair<int, pair<string,string> > > clust;
vector<string> files;
vector<vector<string> > clusters;
vector<vector<int> > matrix(26, vector<int> (26, 0));
int numElts = 0,
algorithm = atoi(argv[3]);
// Read files in directory and create bitVectors
readDir(atoi(argv[1]), argv[4], wordMap, numElts, bitVectors);
removeUnused(numElts, bitVectors);
// Print similarity matrix
simMatrix(numElts, bitVectors, clust, index, matrix, files);
greedy(atoi(argv[2]), bitVectors, clust, index, matrix, clusters);
if (algorithm == 2)
{
simulatedAnnealing(clusters, matrix, index);
}
if (algorithm == 3) // i don't consider if the solution returns less than/greater than k clusters
{
vector<int> diameters;
int maxDiam = 0;
for (int i = 0; i < clusters.size(); i++)
{
int diam = 0;
for (int j = 0; j < clusters.at(i).size(); j++)
{
for (int k = j; k < clusters.at(i).size(); k++)
{
hash_map <string, int>::iterator It1 = index.find(clusters.at(i).at(j));
hash_map <string, int>::iterator It2 = index.find(clusters.at(i).at(k));
int tmpDist = matrix.at(It1 -> second).at(It2 -> second);
if (tmpDist > diam)
{
diam = tmpDist;
}
}
}
diameters.push_back(diam);
if (diam > maxDiam)
{
maxDiam = diam;
}
}
vector<vector<string> > empty;
int curDiam = 0;
branchAndBound(files, clusters, empty, maxDiam, curDiam, matrix, index, atoi(argv[2]));
}
sortClustering(clusters);
printClusteredMatrix(clusters, matrix, index);
return 0;
}
int main(int argc, char** argv)
{
/*==================================================*/
/* Variables */
data d;
int* M;
/* GLPK */
int *ia, *ja;
double *ar;
double z;
double *x;
int notZeroCount;
/* Misc */
int i, pos;
/* Check up */
if(argc != 2)
{
printf("ERROR : no data file !\n");
exit(1);
}
/* Initialization */
filereader(argv[1], &d);
if(d.nbjour < 1)
{
printf("Obvious...\n");
return 0;
}
M = (int*) malloc ((d.nbjour +1)* sizeof(int));
M[d.nbjour] = d.d[d.nbjour];
for (i = d.nbjour-1; i >=0; --i)
{
M[i] = d.d[i] + M[i+1];
}
/* Problem creation*/
glp_prob *prob;
prob = glp_create_prob();
glp_set_prob_name(prob, "ULS");
glp_set_obj_dir(prob, GLP_MIN);
glp_smcp parm;
glp_init_smcp(&parm);
parm.msg_lev = GLP_MSG_OFF;
glp_iocp parmip;
glp_init_iocp(&parmip);
parmip.msg_lev = GLP_MSG_OFF;
/* Number of constraints : 2 * nbjour +2 */
glp_add_rows(prob, 2*d.nbjour +2);
for (i = 1; i <= d.nbjour; ++i)
{
glp_set_row_bnds(prob, i, GLP_FX, d.d[i], d.d[i]);
}
for (i = d.nbjour+1; i <= 2*d.nbjour; ++i)
{
glp_set_row_bnds(prob, i, GLP_LO, 0, 0);
}
glp_set_row_bnds(prob, 2*d.nbjour+1, GLP_FX, 0.0, 0.0);
glp_set_row_bnds(prob, 2*d.nbjour+2, GLP_FX, 0.0, 0.0);
/* Number of variables : 3*(nbjour +1)*/
glp_add_cols(prob, 3*(d.nbjour+1));
for (i = 0; i < d.nbjour +1; ++i)
{
glp_set_col_bnds(prob, i*3 +1, GLP_LO, 0.0, 0.0);
glp_set_col_bnds(prob, i*3 +2, GLP_LO, 0.0, 0.0);
glp_set_col_bnds(prob, i*3 +3, GLP_DB, 0.0, 1.0);
}
for (i = 1; i <= 3*(d.nbjour+1); ++i)
{
glp_set_col_kind(prob, i, GLP_CV);
}
/* Coefficients of the economic function */
glp_set_obj_coef(prob, 1, 0);
glp_set_obj_coef(prob, 2, 0);
glp_set_obj_coef(prob, 3, 0);
for (i = 1; i <=d.nbjour; ++i)
{
glp_set_obj_coef(prob, 3*i+1, d.p[i]);
glp_set_obj_coef(prob, 3*i+2, d.h[i]);
glp_set_obj_coef(prob, 3*i+3, d.f[i]);
}
/* Matrix */
notZeroCount = 5 * d.nbjour + 2;
ia = (int *) malloc ((1+notZeroCount) * sizeof(int));
ja = (int *) malloc ((1+notZeroCount) * sizeof(int));
ar = (double *) malloc ((1+notZeroCount) * sizeof(double));
pos = 1;
for (i = 1; i <= d.nbjour; ++i)
{
ia[pos] = i;
ia[pos+1] = i;
ia[pos+2] = i;
ja[pos] = i*3-1;
ja[pos+1] = i*3+1;
ja[pos+2] = i*3+2;
ar[pos] = 1.0;
ar[pos+1] = 1.0;
ar[pos+2] = -1.0;
pos += 3;
}
for (i = 1; i <= d.nbjour; ++i)
{
ia[pos] = i + d.nbjour;
ia[pos+1] = i + d.nbjour;
ja[pos] = i*3+1;
ja[pos+1] = i*3+3;
ar[pos] = -1.0;
ar[pos+1] = M[i];
pos += 2;
}
ia[pos] = 2*d.nbjour +1;
ia[pos+1] = 2 * d.nbjour+2;
ja[pos] = 3*(d.nbjour+1)-1;
ja[pos+1] = 2;
ar[pos] = 1.0;
ar[pos+1] = 1.0;
pos += 2;
glp_load_matrix(prob, notZeroCount, ia, ja , ar);
/* Writing in a file */
glp_write_lp(prob, NULL, "ULS.lp");
/* Branch and bound */
node* res = branchAndBound(prob);
displayNode(res);
}
