void seleciona_propagandas(int n, double C, double V[N], double P[N], double w[N][N], int S[N], double *UpperBound, long maxtime) {
GRBVar y[N][N];
GRBVar x[N];
int seed=0;
GRBEnv env = GRBEnv();
GRBModel model = GRBModel(env);
model.getEnv().set(GRB_IntParam_Seed, seed);
model.set(GRB_StringAttr_ModelName, "Alocacao Propaganda"); // prob. name
model.set(GRB_IntAttr_ModelSense, GRB_MAXIMIZE); // is a minimization problem
for(int i = 0; i < n; i++) {
char name[100];
sprintf(name,"x_%d",i);
x[i] = model.addVar(0.0, 1.0, V[i],GRB_BINARY, name);
}
for( int i = 0; i < n; i++) {
for(int j = i+1; j < n; j++) {
char name[100];
sprintf(name,"y_%d_%d",i, j);
y[i][j] = model.addVar(0.0, 1.0, w[i][j], GRB_BINARY, name);
}
}
model.update();
GRBLinExpr expr;
for(int i = 0; i < n; i++) {
expr += (x[i] * P[i]);
}
model.addConstr(expr <= C);
model.update();
for(int i = 0; i < n; i++) {
for(int j =i+1; j < n; j++) {
model.addConstr(y[i][j] <= x[i]);
model.addConstr(y[i][j] <= x[j]);
model.addConstr(x[i] + x[j] <= (y[i][j] + 1));
}
}
model.update();
model.write("model.lp");
model.optimize();
*UpperBound = model.get(GRB_DoubleAttr_ObjVal);
}
void AlignmentLP::ConstructLP(SpeechSolution *proposal) {
try {
GRBEnv env = GRBEnv();
GRBModel model = GRBModel(env);
//model.set(GRB_IntAttr_ModelSense, GRB_MINIMIZE);
// Create all the variables.
s.resize(cs_.problems_size());
s2.resize(cs_.problems_size());
//position_var.resize(cs_.problems_size());
// Create the hmms.
for (uint u = 0; u < s.size(); ++u) {
const ClusterProblem &problem = cs_.problem(u);
int M = problem.num_steps;
s[u].resize(M);
s2[u].resize(M);
//position_var.resize(M);
for (int m = 0; m < M; ++m) {
s[u][m].resize(problem.num_states);
s2[u][m].resize(problem.num_states);
for (uint n = 0; n < s[u][m].size(); ++n) {
s[u][m][n].resize(cs_.num_hidden(0));
{
stringstream buf;
buf << "s2_" << u << "_" << m << "_" << n;
s2[u][m][n] =
model.addVar(0.0, 1.0, 0.0,
VAR_TYPE, buf.str());
}
for (uint o = 0; o < s[u][m][n].size(); ++o) {
s[u][m][n][o].resize(3);
for (uint f = 0; f <= 2; ++f) {
stringstream buf;
buf << "s_" << u << "_" << m << "_" << n << "_" << o << "_" << f;
double score = distances_[u]->get_distance(m, o);
s[u][m][n][o][f] =
model.addVar(0.0, 1.0, score,
VAR_TYPE, buf.str());
}
}
}
// position_var[u][m].resize(cs_.num_types());
// for (uint l = 0; l < position_var[u][m].size(); ++l) {
// position_var[u][m][l].resize(cs_.num_hidden(0));
// for (uint o = 0; o < position_var[u][m][l].size(); ++o) {
// stringstream buf;
// buf << "position_" << u << "_" << m << "_" << l << "_" << o;
// position_var[u][m][l][o] =
// model.addVar(0.0, 1.0, 0.0,
// VAR_TYPE, buf.str());
// }
// }
}
}
r.resize(cs_.num_types());
for (uint l = 0; l < r.size(); ++l) {
r[l].resize(cs_.num_hidden(0));
for (uint o = 0; o < r[l].size(); ++o) {
stringstream buf;
buf << "r_" << l << "_" << o;
r[l][o] =
model.addVar(0.0, 1.0, 0.0,
VAR_TYPE, buf.str());
}
}
t.resize(cs_.problems_size());
for (uint u = 0; u < t.size(); ++u) {
const ClusterProblem &problem = cs_.problem(u);
t[u].resize(problem.num_states);
for (uint n = 0; n < t[u].size(); ++n) {
t[u][n].resize(cs_.num_hidden(0));
for (uint o = 0; o < t[u][n].size(); ++o) {
stringstream buf;
buf << "t_" << u << "_" << n << "_" << o;
t[u][n][o] =
model.addVar(0.0, 1.0, 0.0,
VAR_TYPE, buf.str());
}
}
}
model.update();
// Make constraints.
// Constraint for M
// for all l, sum_q r(l,o) = 1
for (int l = 0; l < cs_.num_types(); ++l) {
// Sum out o's.
GRBLinExpr sum;
for (int o = 0; o < cs_.num_hidden(0); ++o) {
sum += r[l][o];
}
// Equal to 1.
model.addConstr(sum == 1);
}
cerr << "Done Constraint 1" << endl;
// Constraint for N
// for all m,n,o, i, s(u, m, n, o) = s(m-1, n, o, 0) +
// s(m-1, n, o, 1)
for (int u = 0; u < cs_.problems_size(); ++u) {
const ClusterProblem &problem = cs_.problem(u);
int M = problem.num_steps;
int N = problem.num_states;
for (int m = 0; m < M; ++m) {
for (int n = 0; n < N; ++n) {
for (int o = 0; o < cs_.num_hidden(0); ++o) {
if (m != 0 && n != 0) {
GRBLinExpr sum;
model.addConstr(s[u][m][n][o][0] +
s[u][m][n][o][2] ==
s[u][m - 1][n][o][0] +
s[u][m - 1][n][o][1], "incoming");
}
if (m != M - 1 && n != N - 1) {
model.addConstr(s[u][m][n][o][0] +
s[u][m][n][o][1] ==
s[u][m + 1][n][o][0] +
s[u][m + 1][n][o][2], "Outgoing");
}
GRBLinExpr sum, sum2;
for (int o2 = 0; o2 < cs_.num_hidden(0); ++o2) {
sum += s[u][m][n][o2][1];
sum2 += s[u][m][n][o2][2];
}
model.addConstr(s2[u][m][n] == sum, "Outgoing");
if (m != M - 1 && n != N - 1) {
model.addConstr(sum2 ==
s2[u][m + 1][n + 1], "Outgoing");
}
}
}
}
{
GRBLinExpr sum;
for (int o = 0; o < cs_.num_hidden(0); ++o) {
sum += s[u][0][0][o][1];
}
model.addConstr(sum == 1, "Starting");
}
{
GRBLinExpr sum;
for (int o = 0; o < cs_.num_hidden(0); ++o) {
sum += s[u][problem.num_steps - 1][problem.num_states - 1][o][0];
}
model.addConstr(sum == 1);
}
}
// Tying constraints 3.
// forall n, o, r(y_n, o) = t(n,o)
for (int u = 0; u < cs_.problems_size(); ++u) {
const ClusterProblem &problem = cs_.problem(u);
for (int n = 0; n < problem.num_states; ++n) {
GRBLinExpr sum;
for (int o = 0; o < cs_.num_hidden(0); ++o) {
sum += t[u][n][o];
}
model.addConstr(sum == 1);
}
for (int n = 0; n < problem.num_states; ++n) {
int l = problem.MapState(n);
for (int o = 0; o < cs_.num_hidden(0); ++o) {
model.addConstr(r[l][o] == t[u][n][o]);
GRBLinExpr sum;
for (int m = 0; m < problem.num_steps; ++m) {
sum += s[u][m][n][o][1];
}
model.addConstr(sum == t[u][n][o]);
}
}
}
cerr << "Done Constraint 3" << endl;
if (true) {
for (int u = 0; u < cs_.problems_size(); ++u) {
const ClusterProblem &problem = cs_.problem(u);
int M = problem.num_steps;
int N = problem.num_states;
for (int m = 0; m < M; ++m) {
for (uint l = 0; l < r.size(); ++l) {
vector <int> locations;
for (int n = 0; n < N; ++n) {
if ((int)l == problem.MapState(n)) {
locations.push_back(n);
}
}
for (int o = 0; o < cs_.num_hidden(0); ++o) {
GRBLinExpr sum;
for (uint occ_index = 0; occ_index < locations.size(); ++occ_index) {
int n = locations[occ_index];
sum += s[u][m][n][o][0] + s[u][m][n][o][1] + s[u][m][n][o][2];
}
//model.addConstr(position_var[u][m][l][o] == sum);
model.addConstr(sum <= r[l][o]);
}
}
}
}
}
// model.addConstr(r[7][2] == 0.5);
// model.addConstr(r[7][3] == 0.5);
// model.addConstr(r[0][1] == 0.5);
// model.addConstr(r[0][6] == 0.5);
// model.addConstr(r[13][4] == 0.5);
// model.addConstr(r[13][9] == 0.5);
model.update();
//model.write("temp.lp");
//
// // Done!
model.optimize();
if (model.get(GRB_IntAttr_Status) != GRB_OPTIMAL) {
model.computeIIS();
model.write("temp.ilp");
}
vector<double> costs;
for (uint u = 0; u < s.size(); ++u) {
SpeechAlignment *align = proposal->mutable_alignment(u);
const ClusterProblem &problem = cs_.problem(u);
vector<int> *state_hidden = align->mutable_hidden_alignment();
vector<int> *state_align = align->mutable_alignment();
state_hidden->resize(problem.num_steps);
state_align->resize(problem.num_steps);
int M = problem.num_steps;
int N = 0;
for (int m = 0; m < M; ++m) {
N = s[u][m].size();
costs.resize(s[u][m].size());
for (uint n = 0; n < s[u][m].size(); ++n) {
for (uint o = 0; o < s[u][m][n].size(); ++o) {
for (uint f = 0; f <= 2; ++f) {
if (s[u][m][n][o][f].get(GRB_DoubleAttr_X) != 0) {
(*state_hidden)[m] = o;
(*state_align)[m] = problem.MapState(n);
string position;
if (f == 0) {
position = "I";
} else if (f == 1) {
position = "B";
} else {
position = "O";
}
cerr << "s " << m << " " << n << " " << o << " " << position << " "
<< s[u][m][n][o][f].get(GRB_DoubleAttr_X)
<< " " << s[u][m][n][o][f].get(GRB_DoubleAttr_Obj)
<< " " << problem.MapState(n) << endl;
costs[n] += s[u][m][n][o][f].get(GRB_DoubleAttr_X)
* s[u][m][n][o][f].get(GRB_DoubleAttr_Obj);
}
}
}
}
}
for (int n = 0; n < N; ++n) {
cerr << n << " " << costs[n] << endl;
}
}
for (uint u = 0; u < t.size(); ++u) {
for (uint n = 0; n < t[u].size(); ++n) {
for (uint o = 0; o < t[u][n].size(); ++o) {
if (t[u][n][o].get(GRB_DoubleAttr_X) != 0) {
cerr << "t " << n << " " << o << " " <<
t[u][n][o].get(GRB_DoubleAttr_X) << endl;
}
}
}
}
for (uint l = 0; l < r.size(); ++l) {
for (uint o = 0; o < r[l].size(); ++o) {
if (r[l][o].get(GRB_DoubleAttr_X) != 0) {
cerr << "r " << l << " " << o << " " <<
r[l][o].get(GRB_DoubleAttr_X) << endl;
}
}
}
} catch(GRBException e) {
cout << "Error code = " << e.getErrorCode() << endl;
cout << e.getMessage() << endl;
} catch(...) {
cout << "Exception during optimization" << endl;
}
}
int
main(int argc,
char *argv[])
{
if (argc < 2)
{
cout << "Usage: feasopt_c++ filename" << endl;
return 1;
}
GRBEnv* env = 0;
GRBConstr* c = 0;
try
{
env = new GRBEnv();
GRBModel feasmodel = GRBModel(*env, argv[1]);
// Create a copy to use FeasRelax feature later */
GRBModel feasmodel1 = GRBModel(feasmodel);
// clear objective
feasmodel.setObjective(GRBLinExpr(0.0));
// add slack variables
c = feasmodel.getConstrs();
for (int i = 0; i < feasmodel.get(GRB_IntAttr_NumConstrs); ++i)
{
char sense = c[i].get(GRB_CharAttr_Sense);
if (sense != '>')
{
double coef = -1.0;
feasmodel.addVar(0.0, GRB_INFINITY, 1.0, GRB_CONTINUOUS, 1,
&c[i], &coef, "ArtN_" +
c[i].get(GRB_StringAttr_ConstrName));
}
if (sense != '<')
{
double coef = 1.0;
feasmodel.addVar(0.0, GRB_INFINITY, 1.0, GRB_CONTINUOUS, 1,
&c[i], &coef, "ArtP_" +
c[i].get(GRB_StringAttr_ConstrName));
}
}
feasmodel.update();
// optimize modified model
feasmodel.write("feasopt.lp");
feasmodel.optimize();
// use FeasRelax feature */
feasmodel1.feasRelax(GRB_FEASRELAX_LINEAR, true, false, true);
feasmodel1.write("feasopt1.lp");
feasmodel1.optimize();
}
catch (GRBException e)
{
cout << "Error code = " << e.getErrorCode() << endl;
cout << e.getMessage() << endl;
}
catch (...)
{
cout << "Error during optimization" << endl;
}
delete[] c;
delete env;
return 0;
}
int
main(int argc,
char *argv[])
{
try {
GRBEnv env = GRBEnv();
GRBModel model = GRBModel(env);
GRBVar vars[n][n][n];
int i, j, v;
// Create 3-D array of model variables
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
for (v = 0; v < n; v++) {
string s = "G_" + itos(i) + "_" + itos(j) + "_" + itos(v);
vars[i][j][v] = model.addVar(0.0, 1.0, 0.0, GRB_BINARY, s);
}
}
}
// Integrate variables into model
model.update();
// Add constraints
// Each cell must take one value
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
GRBLinExpr expr = 0;
for (v = 0; v < n; v++)
expr += vars[i][j][v];
string s = "V_" + itos(i) + "_" + itos(j);
model.addConstr(expr, GRB_EQUAL, 1.0, s);
}
}
// Each value appears once per row
for (i = 0; i < n; i++) {
for (v = 0; v < n; v++) {
GRBLinExpr expr = 0;
for (j = 0; j < n; j++)
expr += vars[i][j][v];
string s = "R_" + itos(i) + "_" + itos(v);
model.addConstr(expr == 1.0, s);
}
}
// Each value appears once per column
for (j = 0; j < n; j++) {
for (v = 0; v < n; v++) {
GRBLinExpr expr = 0;
for (i = 0; i < n; i++)
expr += vars[i][j][v];
string s = "C_" + itos(j) + "_" + itos(v);
model.addConstr(expr == 1.0, s);
}
}
// Each value appears once per sub-grid
for (v = 0; v < n; v++) {
for (int i0 = 0; i0 < sd; i0++) {
for (int j0 = 0; j0 < sd; j0++) {
GRBLinExpr expr = 0;
for (int i1 = 0; i1 < sd; i1++) {
for (int j1 = 0; j1 < sd; j1++) {
expr += vars[i0*sd+i1][j0*sd+j1][v];
}
}
string s = "Sub_" + itos(v) + "_" + itos(i0) + "_" + itos(j0);
model.addConstr(expr == 1.0, s);
}
}
}
// Fix variables associated with pre-specified cells
char input[10];
for (i = 0; i < n; i++) {
cin >> input;
for (j = 0; j < n; j++) {
int val = (int) input[j] - 48 - 1; // 0-based
if (val >= 0)
vars[i][j][val].set(GRB_DoubleAttr_LB, 1.0);
}
}
// Optimize model
model.optimize();
// Write model to file
model.write("sudoku.lp");
cout << endl;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
for (v = 0; v < n; v++) {
if (vars[i][j][v].get(GRB_DoubleAttr_X) > 0.5)
cout << v+1;
}
}
cout << endl;
}
cout << endl;
} catch(GRBException e) {
cout << "Error code = " << e.getErrorCode() << endl;
cout << e.getMessage() << endl;
} catch (...) {
cout << "Error during optimization" << endl;
}
return 0;
}
int main(int argc,char *argv[]) {
srand48(1);
if (argc!=2) {cout<<endl<<"Usage: "<< argv[0]<<" <filename>"<< endl << endl;
cout << "Example: " << argv[0] << " arq1.in" << endl << endl; exit(0);}
ifstream ifile;
ifile.open(argv[1]); if (!ifile) return(false);
int n, m;
ifile >> n; ifile >> m;
vector<double> jobsize(n);
vector<double> machinespeed(m);
for(int i=0; i<n; i++) ifile >> jobsize[i];
for(int i=0; i<m; i++) ifile >> machinespeed[i];
ifile.close();
cout << endl;
cout << "Numero de tarefas: " << n << endl;
cout << "Tamanho das tarefas" << endl;
for(int i=0; i<n; i++)
cout << "T_" << i << ": " << jobsize[i] << endl;
cout << "Velocidade das maquinas" << endl;
for(int i=0; i<m; i++)
cout << "M_" << i << ": " << machinespeed[i] << endl;
cout << endl << endl;
try {
/*--------------------------------------------------------------------------------- */
/*--------------------------- ALTERE DAQUI PARA ABAIXO ---------------------------- */
/*--------------------------------------------------------------------------------- */
// Voce deve atualizar esta variavel com valores 0 e 1 de tal forma que
// tarefa_maquina[i][j] = 1 SE_E_SOMENTE_SE a tarefa i foi escalonada na maq. j
vector<vector<int> > tarefa_maquina(n, vector<int>(m));
// mais abaixo eh feito um escalonamento aleatorio.
// Nao se esqueca de alterar a geracao do escalonamento aleatorio para o
// escalonamento obtido pelo seu programa linear inteiro
// cabecalho comum para os programas lineares (descomente)
int seed=0;
GRBEnv env = GRBEnv();
GRBModel model = GRBModel(env);
model.getEnv().set(GRB_IntParam_Seed, seed);
model.set(GRB_StringAttr_ModelName, "Escalonamento de Tarefas"); // prob. name
model.set(GRB_IntAttr_ModelSense, GRB_MINIMIZE); // is a minimization problem
GRBVar min;
GRBVar x[m][n];
min = model.addVar(0, 30000, 1 , GRB_CONTINUOUS, "min");
int i,j;
for(i=0;i<m;i++){
for(j=0;j<n;j++) {
char name[100];
sprintf(name,"I%dM%d",i,j);
x[i][j] = model.addVar(0, 1, 0 , GRB_BINARY, name);
}
}
model.update();
//cada tarefa em 1 máquina
for (int i=0; i<n; i++){
GRBLinExpr sum2;
for (int j=0; j<m; j++){
sum2= sum2 + x[j][i];
}
model.addConstr(sum2 == 1);
}
//min eh pior caso
for(int j=0; j<m; j++){
GRBLinExpr sum3;
for (i=0; i<n ; i++) {
sum3 = sum3 + jobsize[i]*x[j][i]/ machinespeed[j];
}
model.addConstr(min >= sum3);
}
model.update();
model.write("model.lp");
system("cat model.lp");
model.optimize();
// Verifica se obteve solucao otima
if (model.get(GRB_IntAttr_Status) != GRB_OPTIMAL) {
cout << "Erro, sistema impossivel" << endl;
exit(1);
}
for (int i=0; i<n; i++){
for (int j=0; j<m; j++){
if(x[j][i].get(GRB_DoubleAttr_X)>0.999)
tarefa_maquina[i][j] = 1;
else
tarefa_maquina[i][j] = 0;
}
}
/*--------------------------------------------------------------------------------- */
/*--------------------------- ALTERE DAQUI PARA CIMA ------------------------------ */
/*--------------------------------------------------------------------------------- */
cout << "\n\n";
double makespan=0;
cout << "Escalonamento obtido das tarefas nas maquinas\n";
cout << "Notacao para tarefas : T_id(tamanho_original)\n";
cout << "Notacao para maquinas: M_id(velocidade)\n\n";
for (int j=0; j<m; j++) {
double tmaq=0.0;
cout << "M_"<<j<<"("<< machinespeed[j] << ") : ";
for(int i=0; i<n; i++) {
if (tarefa_maquina[i][j] == 1) {
cout << "T_" << i << "(" << jobsize[i] << ") ";
tmaq += jobsize[i] / machinespeed[j];
}
}
cout << endl << "Tempo gasto pela maquina M_" <<j << ": " << tmaq << endl<<endl;
if (tmaq>makespan) makespan = tmaq;
}
cout << "\nTempo para completar todas as tarefas: " << makespan << "s\n\n";
// } else cout << "No solution" << "\n";
}
// catch (GRBException e) {
// cout << "Error code = " << e.getErrorCode() << endl;
// cout << e.getMessage() << endl;
// }
catch (...) {
cout << "Exception during optimization" << endl;
}
return 0;
}
int main(int argc, char *argv[])
{
GRBEnv* env = 0;
GRBVar* covered = 0; // we want to maximize demand covered
GRBVar* facility = 0;
int max_n_Facilities = 10;
try
{
const string filename = "/Users/katarzyna/Dropbox/matlab/2015-05 PKITS/aij_matrix.txt";
std::vector<std::vector<long int> > aij_matrix;
readMatrix_aij(filename, aij_matrix);
std::cout << "matrix size "<< aij_matrix.size() <<" x "<< aij_matrix[0].size() << std::endl;
// Model
env = new GRBEnv();
GRBModel model = GRBModel(*env);
model.set(GRB_StringAttr_ModelName, "minimize number of facilities");
// Demand coverage decision variable, covered[i] == 1 if demand is covered
covered = model.addVars(aij_matrix.size(), GRB_BINARY);
model.update();
// Facility open variables: facility[j] == 1 if facility j is open.
facility = model.addVars(aij_matrix.size(), GRB_BINARY);
model.update();
// Set the objective to maximize the demand covered
for (unsigned int i = 0; i < aij_matrix.size(); ++i)
{
ostringstream vname;
vname << "Demand " << i;
covered[i].set(GRB_DoubleAttr_Obj, 1);
covered[i].set(GRB_StringAttr_VarName, vname.str());
}
for (unsigned int i = 0; i < aij_matrix.size(); ++i)
{
ostringstream vname;
vname << "Open " << i;
facility[i].set(GRB_DoubleAttr_Obj, 0);
facility[i].set(GRB_StringAttr_VarName, vname.str());
}
// The objective is to maximize the total demand covered
model.set(GRB_IntAttr_ModelSense, 0);
// Update model
model.update();
// Constraints
// If demand i is covered by at least one station, then covered[i] == 1
for (unsigned int i = 0; i < aij_matrix.size(); ++i)
{
GRBLinExpr demand_is_covered = 0;
for (unsigned int j = 0; j < aij_matrix.size(); ++j)
{
demand_is_covered += aij_matrix[i][j] * facility[j];
}
ostringstream cname;
cname << "Demand_i_is_covered " << i;
model.addConstr(demand_is_covered >= covered[i], cname.str());
}
// We allow no more than n facilities
GRBLinExpr facilities_to_open = 0;
for (unsigned int j = 0; j < aij_matrix.size(); ++j) {
facilities_to_open += facility[j];
}
ostringstream vname;
vname << "Max facility... ";
model.addConstr(facilities_to_open <= max_n_Facilities);
model.update();
// Solve
model.optimize();
model.write("/Users/katarzyna/Dropbox/matlab/2015-05 PKITS/output.lp");
// Print solution
cout << "\nTOTAL COSTS: " << model.get(GRB_DoubleAttr_ObjVal) << endl;
cout << "SOLUTION:" << endl;
int sum_d = 0;
for (unsigned int i = 0; i < aij_matrix.size(); ++i)
{
if (covered[i].get(GRB_DoubleAttr_X) == 1.0)
{
//cout << "Demand " << i << " covered." << endl;
sum_d += 1;
}
}
int sum_f = 0;
for (unsigned int i = 0; i < aij_matrix.size(); ++i)
{
if (facility[i].get(GRB_DoubleAttr_X) == 1.0)
{
cout << "Facility " << i << " is opened." << endl;
sum_f += 1;
}
}
cout << sum_f << " facilities is open." << endl;
cout << sum_d << " customers is covered." << endl;
} catch (GRBException e)
{
cout << "Error code = " << e.getErrorCode() << endl;
cout << e.getMessage() << endl;
} catch (...)
{
cout << "Exception during optimization" << endl;
}
}
int main(int argc,char *argv[]) {
srand48(1);
if (argc!=2) {cout<<endl<<"Usage: "<< argv[0]<<" <filename>"<< endl << endl;
cout << "Example: " << argv[0] << " arq1.in" << endl << endl; exit(0);}
ifstream ifile;
ifile.open(argv[1]); if (!ifile) return(false);
int n, m;
ifile >> n; ifile >> m;
vector<double> jobsize(n);
vector<double> machinespeed(m);
for(int i=0; i<n; i++) ifile >> jobsize[i];
for(int i=0; i<m; i++) ifile >> machinespeed[i];
ifile.close();
cout << endl;
cout << "Numero de tarefas: " << n << endl;
cout << "Tamanho das tarefas" << endl;
for(int i=0; i<n; i++)
cout << "T_" << i << ": " << jobsize[i] << endl;
cout << "Velocidade das maquinas" << endl;
for(int i=0; i<m; i++)
cout << "M_" << i << ": " << machinespeed[i] << endl;
cout << endl << endl;
try {
/*--------------------------------------------------------------------------------- */
/*--------------------------- ALTERE DAQUI PARA ABAIXO ---------------------------- */
/*--------------------------------------------------------------------------------- */
// Voce deve atualizar esta variavel com valores 0 e 1 de tal forma que
// tarefa_maquina[i][j] = 1 SE_E_SOMENTE_SE a tarefa i foi escalonada na maq. j
vector<vector<int> > tarefa_maquina(n, vector<int>(m));
// mais abaixo eh feito um escalonamento aleatorio.
// Nao se esqueca de alterar a geracao do escalonamento aleatorio para o
// escalonamento obtido pelo seu programa linear inteiro
// cabecalho comum para os programas lineares (descomente)
int seed=0;
GRBEnv env = GRBEnv();
GRBModel model = GRBModel(env);
model.getEnv().set(GRB_IntParam_Seed, seed);
model.set(GRB_StringAttr_ModelName, "Escalonamento de Tarefas"); // prob. name
model.set(GRB_IntAttr_ModelSense, GRB_MINIMIZE); // is a minimization problem
// Lembretes e sintaxes de alguns comandos:
// GRBVar = nome do tipo das variaveis do Gurobi
//
//vector<GRBVar> x[m];
double TP[m][n];
GRBVar max = model.addVar(0,10000,1,GRB_CONTINUOUS,"max");
// Para inserir uma variavel:
// <variavel_do_tipo_GRBVar> =
// model.addVar(<lower_bound>,
// <upper_bound> ,
// <valor_na_funcao_objetivo>,
// <GRB_CONTINUOUS ou GRB_BINARY GRB_INTEGER>
// <string_do_nome_da_variavel>);
//
// Este comando deve ser executado depois de inserir todas as variaveis e antes de
// inserir as restricoes.
model.update();
//
// Para declarar variavel que armazena expressoes
// for(int i = 0; i<n; i++) { //para cada maquina
// GRBLinExpr expr;
// for(int j = 0; j<m;j++) { //para cada tarefa
// expr+=x[m*i+j];
// }
// model.addConstr(expr >= 0);
// }
//
// Para inserir uma restricao linear:
// model.addConstr( <restricao_linear> );
//
// Comando para escrever o modelo produzido em um arquivo texto (apenas para debugar)
model.update(); //Tem que dar update de novo pra ver as restricoes
model.write("model.lp"); system("cat model.lp");
//
// Depois que construiu seu programa linear / linear inteiro, execute este comando
// para resolver o programa linear
model.optimize();
//
// Verifica se obteve solucao otima
if (model.get(GRB_IntAttr_Status) != GRB_OPTIMAL) {
cout << "Erro, sistema impossivel" << endl;
exit(1);
}
//
// Para obter o valor da variavel do programa linear/linear inteiro
// deve ser executado apos o model.optimize()
// <variavel_do_tipo_GRBVar>.get(GRB_DoubleAttr_X)
// Faz um escalonamento aleatorio.
// Remova esta parte e coloque o escalonamento
// gerado pelo seu programa linear inteiro.
for (int i=0; i<n; i++)
for (int j=0; j<m; j++)
tarefa_maquina[i][j] = 0; // deixa cada maq. sem atribuicao
// for (int i=0; i<n; i++)
// for (int j=0; j<m; j++)
// //if(x[j][i].get(GRB_DoubleAttr_X) >= 0.999) {
// // cout << j << " " << i << endl;
// tarefa_maquina[i][j] = 1;
// }
/*--------------------------------------------------------------------------------- */
/*--------------------------- ALTERE DAQUI PARA CIMA ------------------------------ */
/*--------------------------------------------------------------------------------- */
cout << "\n\n";
double makespan=0;
cout << "Escalonamento obtido das tarefas nas maquinas\n";
cout << "Notacao para tarefas : T_id(tamanho_original)\n";
cout << "Notacao para maquinas: M_id(velocidade)\n\n";
for (int j=0; j<m; j++) {
double tmaq=0.0;
cout << "M_"<<j<<"("<< machinespeed[j] << ") : ";
for(int i=0; i<n; i++) {
if (tarefa_maquina[i][j] == 1) {
cout << "T_" << i << "(" << jobsize[i] << ") ";
tmaq += jobsize[i] / machinespeed[j];
}
}
cout << endl << "Tempo gasto pela maquina M_" <<j << ": " << tmaq << endl<<endl;
if (tmaq>makespan) makespan = tmaq;
}
cout << "\nTempo para completar todas as tarefas: " << makespan << "s\n\n";
// } else cout << "No solution" << "\n";
}
// catch (GRBException e) {
// cout << "Error code = " << e.getErrorCode() << endl;
// cout << e.getMessage() << endl;
// }
catch (...) {
cout << "Exception during optimization" << endl;
}
return 0;
}
int main (int argc, char * argv[]) {
chrono :: steady_clock :: time_point tBegin = chrono :: steady_clock :: now();
string I ("0");
ulint timeLimit = 10;
if (argc >= 2) {
I = string (argv[1]);
}
if (argc >= 3) {
timeLimit = atoi(argv[2]);
}
ulint nComplete, k, t, n, m, root;
double d;
cin >> nComplete >> d >> k >> t >> n >> m >> root;
vector <ulint> penalty (nComplete); // vector with de penalties of each vectex
vector < list < pair <ulint, ulint> > > adj (nComplete); // adjacency lists for the graph
for (ulint v = 0; v < nComplete; v++) {
cin >> penalty[v];
}
vector <ulint> solutionV (nComplete, 0);
// reading solution vertices
for (ulint i = 0; i < n; i++) {
ulint v;
cin >> v;
solutionV[v] = 1;
}
vector < pair < pair <ulint, ulint> , ulint> > E (m); // vector of edges with the format ((u, v), w)
map < pair <ulint, ulint>, ulint> mE; // map an edge to its ID
vector < vector <ulint> > paths (m);
// reading graph
for (ulint e = 0; e < m; e++) {
ulint u, v, w, pathSize;
cin >> u >> v >> w >> pathSize;
adj[u].push_back(make_pair(v, w));
adj[v].push_back(make_pair(u, w));
E[e] = make_pair(make_pair(u, v), w);
mE[make_pair(u, v)] = e;
mE[make_pair(v, u)] = e;
paths[e] = vector <ulint> (pathSize);
for (ulint i = 0; i < pathSize; i++) {
cin >> paths[e][i];
}
}
try {
string N = itos(nComplete);
stringstream ssD;
ssD << fixed << setprecision(1) << d;
string D = ssD.str();
D.erase(remove(D.begin(), D.end(), '.'), D.end());
string K = itos(k);
string T = itos(t);
ifstream remainingTimeFile ("./output/N" + N + "D" + D + "K" + K + "T" + T + "I" + I + "/remainingTime.txt");
lint remainingTime = 0;
if (remainingTimeFile.is_open()) {
remainingTimeFile >> remainingTime;
}
if (remainingTime > 0) {
timeLimit += remainingTime;
}
GRBEnv env = GRBEnv();
env.set(GRB_IntParam_LazyConstraints, 1);
env.set(GRB_IntParam_LogToConsole, 0);
env.set(GRB_StringParam_LogFile, "./output/N" + N + "D" + D + "K" + K + "T" + T + "I" + I + "/log2.txt");
env.set(GRB_DoubleParam_TimeLimit, ((double) timeLimit));
GRBModel model = GRBModel(env);
model.getEnv().set(GRB_IntParam_LazyConstraints, 1);
model.getEnv().set(GRB_IntParam_LogToConsole, 0);
model.getEnv().set(GRB_StringParam_LogFile, "./output/N" + N + "D" + D + "K" + K + "T" + T + "I" + I + "/log2.txt");
model.getEnv().set(GRB_DoubleParam_TimeLimit, ((double) timeLimit));
vector <GRBVar> y (nComplete);
// ∀ v ∈ V
for (ulint v = 0; v < nComplete; v++) {
// y_v ∈ {0.0, 1.0}
y[v] = model.addVar(0.0, 1.0, 0.0, GRB_BINARY, "y_" + itos(v));
}
vector <GRBVar> x (m);
// ∀ e ∈ E
for (ulint e = 0; e < m; e++) {
ulint u, v;
u = E[e].first.first;
v = E[e].first.second;
// y_e ∈ {0.0, 1.0}
x[e] = model.addVar(0.0, 1.0, 0.0, GRB_BINARY, "x_" + itos(u) + "_" + itos(v));
}
model.update();
GRBLinExpr obj = 0.0;
// obj = ∑ ce * xe
for (ulint e = 0; e < m; e++) {
ulint w;
w = E[e].second;
obj += w * x[e];
}
// obj += ∑ πv * (1 - yv)
for (ulint v = 0; v < nComplete; v++) {
obj += penalty[v] * (1.0 - y[v]);
}
model.setObjective(obj, GRB_MINIMIZE);
// yu == 1
model.addConstr(y[root] == 1.0, "c_0");
// dominance
// ∀ v ∈ V
for (ulint v = 0; v < nComplete; v++) {
if (solutionV[v] == 1) {
GRBLinExpr constr = 0.0;
constr += y[v];
model.addConstr(constr == 1, "c_1_" + itos(v));
}
}
// each vertex must have exactly two edges adjacent to itself
// ∀ v ∈ V
for (ulint v = 0; v < nComplete; v++) {
// ∑ xe == 2 * yv , e ∈ δ({v})
GRBLinExpr constr = 0.0;
for (list < pair <ulint, ulint> > :: iterator it = adj[v].begin(); it != adj[v].end(); it++) {
ulint w = (*it).first; // destination
ulint e = mE[make_pair(v, w)];
constr += x[e];
}
model.addConstr(constr == 2.0 * y[v], "c_2_" + itos(v));
}
subtourelim cb = subtourelim(y, x, nComplete, m, E, mE, root);
model.setCallback(&cb);
model.optimize();
if (model.get(GRB_IntAttr_SolCount) > 0) {
ulint solutionCost = 0;
set <ulint> solutionVectices;
vector < pair <ulint, ulint> > solutionEdges;
solutionCost = round(model.get(GRB_DoubleAttr_ObjVal));
for (ulint v = 0; v < nComplete; v++) {
if (y[v].get(GRB_DoubleAttr_X) >= 0.5) {
solutionVectices.insert(v);
}
}
for (ulint e = 0; e < m; e++) {
if (x[e].get(GRB_DoubleAttr_X) >= 0.5) {
for (ulint i = 0; i < paths[e].size() - 1; i++) {
pair <ulint, ulint> edge;
if (paths[e][i] < paths[e][i + 1]) {
edge.first = paths[e][i];
edge.second = paths[e][i + 1];
} else {
edge.first = paths[e][i + 1];
edge.second = paths[e][i];
}
solutionEdges.push_back(edge);
}
}
}
cout << solutionVectices.size() << ' ' << solutionEdges.size() << ' ' << solutionCost << endl;
for (set <ulint> :: iterator it = solutionVectices.begin(); it != solutionVectices.end(); it++) {
ulint v = *it;
cout << v << endl;
}
for (vector < pair <ulint, ulint> > :: iterator it = solutionEdges.begin(); it != solutionEdges.end(); it++) {
pair <ulint, ulint> e = *it;
cout << e.first << " " << e.second << endl;
}
} else {
cout << "0 0 0" << endl;
}
// exporting model
model.write("./output/N" + N + "D" + D + "K" + K + "T" + T + "I" + I + "/model2.lp");
ofstream objValFile ("./output/N" + N + "D" + D + "K" + K + "T" + T + "I" + I + "/objVal2.txt", ofstream :: out);
objValFile << model.get(GRB_DoubleAttr_ObjVal);
objValFile.close();
ofstream gapFile ("./output/N" + N + "D" + D + "K" + K + "T" + T + "I" + I + "/gap2.txt", ofstream :: out);
gapFile << model.get(GRB_DoubleAttr_MIPGap);
gapFile.close();
chrono :: steady_clock :: time_point tEnd = chrono :: steady_clock :: now();
chrono :: nanoseconds elapsedTime = chrono :: duration_cast <chrono :: nanoseconds> (tEnd - tBegin);
ofstream elapsedTimeFile ("./output/N" + N + "D" + D + "K" + K + "T" + T + "I" + I + "/elapsedTime2.txt", ofstream :: out);
elapsedTimeFile << elapsedTime.count();
elapsedTimeFile.close();
} catch (GRBException e) {
int main(int argc, char *argv[]) {
// do we want to force integer solution?
// if false, we solve a linear program without the integrity constraint
bool integer_solution = false;
// if objective_min_N is true then we solve the problem which minimizes total
// number of vehicles in the simulation.
// Otherwise, we minimize number of rebalancing trips
bool objective_min_N = true;
GRBEnv* env = 0; //< gurobi env
GRBVar** rij = 0; // number of empty vehicles traveling between stations
GRBVar** vi = 0; // number of vehicles available at station i
// stations coordinates
std::vector<std::vector<double> > stations;
// distances or cost of traveling between the stations
// internal vector stores "to where" and external vector stores "from where"
std::vector<std::vector<double> > cost;
// origin counts, size of n_rebalancing_periods x n_stations
std::vector<std::vector<double> > origin_counts;
// destination counts, size of n_rebalancing_periods x n_stations
std::vector<std::vector<double> > dest_counts;
// counts of vehicles in transit to each station, size of n_rebalancing_periods x n_stations
std::vector<std::vector<double> > in_transit_counts;
// cost of one idle vehicle in the system, when objective minimizes # vehicles, then set cost to 1,
// when objective minimizes number of rebalancing vehicles then set cost to a huge number
// (to make sure that this is always more expensive that rebalancing as it adds more vehicles to the system)
double cost_of_veh = 1.0;
double rebalancing_cost = 1.0;
// what constraints do you want to take into account
// input and output files declaration
// simple_model
// bool simple_model = true;
// const string stationsFile = "/home/kasia/Dropbox/matlab/2015-09_FleetSizeEstimation/sampleFiles/stationsXY.txt";
// const string costMatrixFile = "/home/kasia/Dropbox/matlab/2015-09_FleetSizeEstimation/sampleFiles/costM3x3TT.txt";
// const string originCountsFile = "/home/kasia/Dropbox/matlab/2015-09_FleetSizeEstimation/sampleFiles/origCounts3x3TT.txt";
// const string destinationCountsFile = "/home/kasia/Dropbox/matlab/2015-09_FleetSizeEstimation/sampleFiles/destCounts3x3TT.txt";
// const string inTransitCountsFile = "/home/kasia/Dropbox/matlab/2015-09_FleetSizeEstimation/sampleFiles/inTransit3x3TT.txt";
// const string modelOutput = "rebalancing_formulation_simple.lp";
// const string solutionOutput = "rebalancing_solution_simple.sol";
// // simmobility files
// // ubuntu
bool simple_model = false;
const string stationsFile = "/home/kasia/Dropbox/matlab/2016-03-Demand_generation/facility_location/stations_ecbd34.txt";
const string costMatrixFile = "/home/kasia/Dropbox/matlab/2015-09_FleetSizeEstimation/RebTimeInSecs34Stations.txt";
const string originCountsFile = "/home/kasia/Dropbox/matlab/2015-09_FleetSizeEstimation/origCounts_rebEvery900_stations34.txt";
const string destinationCountsFile = "/home/kasia/Dropbox/matlab/2015-09_FleetSizeEstimation/destCounts_rebEvery900_stations34.txt";
const string inTransitCountsFile = "/home/kasia/Dropbox/matlab/2015-09_FleetSizeEstimation/inTransitReb900Stations34";
const string modelOutput = "formulation_rebalancing.lp";
const string solutionOutput = "rebalancing_solution.sol";
// mac
// stationsFile = "/Users/katarzyna/Dropbox/matlab/2016-03-Demand_generation/facility_location/stations_ecbd34.txt";
// costMatrixFile = "/Users/katarzyna/Dropbox/matlab/2015-09_FleetSizeEstimation/RebTime34Stations.txt";
// originCountsFile = "/Users/katarzyna/Dropbox/matlab/2015-09_FleetSizeEstimation/origCounts_rebEvery900_stations34.txt";
// destinationCountsFile = "/Users/katarzyna/Dropbox/matlab/2015-09_FleetSizeEstimation/destCounts_rebEvery900_stations34.txt";
//readFiles(stationsFile, stations);
readFiles(costMatrixFile, cost);
readFiles(originCountsFile, origin_counts);
readFiles(destinationCountsFile, dest_counts);
readFiles(inTransitCountsFile, in_transit_counts);
//round cost of traveling between stations to be a multiple of the rebalancing period
int reb_period = 1;
if(!simple_model) {
reb_period = 900; // in minutes, output from costOfRebalancing.m is in secs
}
int rounded_cost[cost.size()][cost.size()];
for (unsigned int i = 0; i < cost.size(); i++){
for (unsigned int j = 0; j < cost[0].size(); j++){
if (i != j) {
// cost in seconds from the beginning of the simulation
rounded_cost[i][j] = roundUp((int)cost[i][j], reb_period);
//std::cout << "roundUp((int)cost[" << i <<"][" << j << "] = " << rounded_cost[i][j] << std::endl;
} else {
rounded_cost[i][j] = 99999999; // 0
}
}
}
try {
// number of stations in the network
const int nStations = cost.size();
const int nStSquare = pow (nStations, 2);
//number of rebalancing periods = number of rows in the origin and destination counts, size of the first vector
const int nRebPeriods = origin_counts.size();
/***********************************************************************************
* Station matrix
***********************************************************************************/
// station matrix to access the elements of cost/rebalancing vectors
// matrix form stores the indices of the cost vector i.e., for 3 stations [[0,1,2],[3,4,5],[6,7,8]]
int stationMatrix [nStations][nStations];
int indxCounter = 0;
for(int i = 0; i < nStations; ++i) {
for (int k = 0; k < nStations; ++k) {
stationMatrix[i][k] = indxCounter;
//std::cout << "stationMatrix["<< i<< "][" << k << "] = " << indxCounter << endl;
indxCounter++;
}
}
/***********************************************************************************
* Model
***********************************************************************************/
env = new GRBEnv();
GRBModel model = GRBModel(*env);
model.set(GRB_StringAttr_ModelName, "rebalancing");
/***********************************************************************************
* Decision variables
***********************************************************************************/
int station;
int time_;
div_t divresult;
// Number of vehicles available (idle) at each period of time and each station
vi = new GRBVar* [nRebPeriods];
// Number of empty vehicles traveling between stations
rij = new GRBVar* [nRebPeriods];
for ( time_ = 0; time_ < nRebPeriods; ++time_) {
if (integer_solution) {
vi[time_] = model.addVars(nStations, GRB_INTEGER);
rij[time_] = model.addVars(nStSquare, GRB_INTEGER);
} else {
vi[time_] = model.addVars(nStations);
rij[time_] = model.addVars(nStSquare);
}
model.update();
}
// Objective: minimize number of rebalancing trips
if (!objective_min_N) {
for ( time_ = 0; time_ < nRebPeriods; ++time_) {
for (station = 0; station < nStations; ++station) {
ostringstream cname;
cname << "v_ti," << time_ << "," << station << ",0";
// not minimized in the objective
vi[time_][station].set(GRB_DoubleAttr_Obj, 0.0);
vi[time_][station].set(GRB_StringAttr_VarName, cname.str());
}
}
model.update();
for ( time_ = 0; time_ < nRebPeriods; ++time_) {
for(int depSt = 0; depSt < nStations; ++depSt){
// std::cout << "departure station: " << depSt << std::endl;
for (int arrSt = 0; arrSt < nStations; ++arrSt) {
int idx = stationMatrix[depSt][arrSt];
ostringstream vname;
vname << "r_tij," << time_ << "," << depSt << ","<< arrSt;
//std::cout << "nEmptyVhsTime." << time_ << "." << depSt << "."<< arrSt << "."<< idx << std::endl;
if (depSt == arrSt) {
// origin == destination
// this variable should not exist because we do not send vehicles within the same station
rij[time_][idx].set(GRB_DoubleAttr_Obj, 0.0);
rij[time_][idx].set(GRB_StringAttr_VarName, vname.str());
continue;
}
// std::cout << "nEmptyVhsTime." << time_ << ".indx." << station << ".from."<< divresult.quot << ".to." << divresult.rem << std:: endl;
rij[time_][idx].set(GRB_DoubleAttr_Obj, rebalancing_cost * rounded_cost[depSt][arrSt]); // rebalancing_cost
rij[time_][idx].set(GRB_StringAttr_VarName, vname.str());
}
}
}
} else { // Objective: minimize the total number of vehicles at time_ == 0
// integer constraint relaxed
ostringstream cname;
ostringstream vname;
for ( time_ = 0; time_ < nRebPeriods; ++time_) {
for(int depSt = 0; depSt < nStations; ++depSt){
cname.str("");
cname.clear();
cname << "v_ti," << time_ <<"," << depSt << ",0";
if (time_ != 0) {
cost_of_veh = 0.0;
} else {
cost_of_veh = 1.0;
}
vi[time_][depSt].set(GRB_DoubleAttr_Obj, cost_of_veh);
vi[time_][depSt].set(GRB_StringAttr_VarName, cname.str());
model.update();
for (int arrSt = 0; arrSt < nStations; ++arrSt) {
vname.str("");
vname.clear();
vname << "r_tij," << time_ << "," << depSt << ","<< arrSt;
// std::cout << "Adding variable: r_tij," << time_ << "," << depSt << ","<< arrSt << " = \n" << std::flush;
int idx = stationMatrix[depSt][arrSt];
if (depSt == arrSt) {
rij[time_][idx].set(GRB_DoubleAttr_Obj, 0.0);
rij[time_][idx].set(GRB_StringAttr_VarName, vname.str());
// std::cout << "vname = " << vname.str() << "\n" << std::flush;
// std::cout << "vname after clear= " << vname.str() << "\n" << std::flush;
// std::cout << "Added variable: r_tij," << time_ << "," << depSt << ","<< arrSt << " = 0.0\n" << std::flush;
continue;
}
if (time_ != 0) {
rebalancing_cost = 0.0;
} else {
rebalancing_cost = 1.0;
}
int travel_time = (int) (rounded_cost[arrSt][depSt]/reb_period);
// divresult.rem is start time of the arriving trips
divresult = div (nRebPeriods + time_ - travel_time, nRebPeriods);
// to prevent overwriting if there is sth already assigned to this variable
if (rij[divresult.rem][idx].get(GRB_DoubleAttr_Obj) > 0) {
if (travel_time > 1) {
for (int k = 1; k < travel_time; ++k) {
divresult = div (nRebPeriods + time_ - travel_time + k, nRebPeriods);
// to prevent overwriting if there is sth already assigned to this variable
if (rij[divresult.rem][idx].get(GRB_DoubleAttr_Obj) > 0) {
continue;
}
rij[divresult.rem][idx].set(GRB_DoubleAttr_Obj, rebalancing_cost);
vname.str("");
vname.clear();
vname << "r_tij," << divresult.rem << "," << depSt << ","<< arrSt;
rij[divresult.rem][idx].set(GRB_StringAttr_VarName, vname.str());
//std::cout << "Added variable: r_tij," << divresult.rem << "," << depSt << ","<< arrSt << " = " << rebalancing_cost << "\n" << std::flush;
}
}
continue;
}
rij[divresult.rem][idx].set(GRB_DoubleAttr_Obj, rebalancing_cost);
vname.str("");
vname.clear();
vname << "r_tij," << divresult.rem << "," << depSt << ","<< arrSt;
rij[divresult.rem][idx].set(GRB_StringAttr_VarName, vname.str());
//std::cout << "Added variable: r_tij," << divresult.rem << "," << depSt << ","<< arrSt << " = " << rebalancing_cost << "\n" << std::flush;
if (travel_time > 1) {
for (int k = 1; k < travel_time; ++k) {
divresult = div (nRebPeriods + time_ - travel_time + k, nRebPeriods);
// to prevent overwriting if there is sth already assigned to this variable
if (rij[divresult.rem][idx].get(GRB_DoubleAttr_Obj) > 0) {
continue;
}
rij[divresult.rem][idx].set(GRB_DoubleAttr_Obj, rebalancing_cost);
vname.str("");
vname.clear();
vname << "r_tij," << divresult.rem << "," << depSt << ","<< arrSt;
rij[divresult.rem][idx].set(GRB_StringAttr_VarName, vname.str());
//std::cout << "Added variable: r_tij," << divresult.rem << "," << depSt << ","<< arrSt << " = " << rebalancing_cost << "\n" << std::flush;
}
}
}
}
}
}
model.update();
/***********************************************************************************
* Objective function
***********************************************************************************/
// The objective is to minimize the number of vehicles traveling in the network (and cost associated with it)
// Optimization sense: The default +1.0 value indicates that the objective is to minimize the
// objective. Setting this attribute to -1 changes the sense to maximization
model.set(GRB_IntAttr_ModelSense, 1);
model.update();
/***********************************************************************************
* Constraint 1: The number of vehicles must be sufficient to serve the demand
***********************************************************************************/
// This constraint is set to ensure that the number of vehicles available at each station i
// is sufficient to serve the demand within this station.
// If there is not enough vehicles, then we do rebalancing to make sure we can serve the trips
for ( time_ = 0; time_ < nRebPeriods; ++time_) {
// Current demand
int booking_requests[nStations];
for (int i = 0; i < nStations; ++i) {
// booking_requests = departing_vehicles - arriving_vehicles (how many more vehicles do we need)
booking_requests[i] = origin_counts[time_][i] - dest_counts[time_][i];
// std::cout << origin_counts[time_][i] << " - " << dest_counts[time_][i] << " = " << dem_curr[i] << std::endl;
}
GRBLinExpr reb_dep = 0;
GRBLinExpr reb_arr = 0;
for(int depSt = 0; depSt < nStations; ++depSt){
// std::cout << "departure station: " << depSt << std::endl;
for (int arrSt = 0; arrSt < nStations; ++arrSt) {
if (depSt != arrSt) {
int idx = stationMatrix[depSt][arrSt];
int idx2 = stationMatrix[arrSt][depSt];
reb_dep += rij[time_][idx];
// std::cout << "rounded_cost = " << (int)rounded_cost[depSt][arrSt]/reb_period -1 << std::endl;
// cost is expressed in the number of reb periods, i.e., 1,2,3,...nRebPeriods
int travel_cost = (int) (rounded_cost[depSt][arrSt]/reb_period); // maybe ceil would be better than just int
// ceil version of the above line
// int travel_cost = (int) ceil((rounded_cost[depSt][arrSt]/reb_period));
if (travel_cost > time_) {
int dep_time = nRebPeriods + time_ - travel_cost;
reb_arr += rij[dep_time][idx2];
} else {
int dep_time = time_ - travel_cost;
reb_arr += rij[dep_time][idx2];
}
}
}
ostringstream cname;
cname << "demand_ti" << time_ << "." << depSt;
model.addConstr(vi[time_][depSt] + reb_arr - reb_dep >= booking_requests[depSt], cname.str());
//std::cout << "Constraint 1 demand: " << time_ << "." << depSt << std::endl;
reb_arr.clear();
reb_dep.clear();
}
}
model.update();
std::cout << "Constraint set 1 added." << std::endl;
/***********************************************************************************
* Constraint 2: Constant number of vehicles over time
***********************************************************************************/
// This constraint is set to ensure that the total number of vehicles in the system does not change
// over time
// the total number of vehicles in the system is equal to the sum of the vehicles owned by each station
// vehicles owned by station i: available_veh + cust_arriving + cust_in_transit_to_station + empty_arr + empty_in_transit
int cust_balance_at[nStations];
int cust_vhs_at_t[time_];
for ( time_ = 0; time_ < nRebPeriods; ++time_) {
cust_vhs_at_t[time_] = 0;
for (int i = 0; i < nStations; ++i) {
// vhs_owned is the number of vehicles owned by station i
// this number does not account for rebalancing vehicles
// vhs_owned = arriving_costomers + in_transit_to_station
cust_balance_at[i] = dest_counts[time_][i] + in_transit_counts[time_][i];
// std::cout << "vhs_owned[" << i << "] = " << vhs_owned[i] << std::endl;
cust_vhs_at_t[time_] += cust_balance_at[i];
}
if (time_ == 0) { // one print function to validate the above loop
std::cout << "cust_vhs_at_t[" << time_ << "] = " << cust_vhs_at_t[time_] << std::endl;
}
}
GRBLinExpr idle_veh = 0; // Gurobi Linear Expression, total number of idle vehicles now
GRBLinExpr reb_arr = 0; // Gurobi Linear Expression, total number of rebalancing vehicles arriving and in transit to station i
GRBLinExpr idle_veh_prev = 0; // Gurobi Linear Expression, total number of idle vehicles at previous interval
GRBLinExpr reb_arr_prev = 0; // Gurobi Linear Expression, total number of rebalancing vehicles arriving and in transit to station i at previous time
for ( time_ = 0; time_ < nRebPeriods; ++time_) {
std::cout << "time_ = " << time_ << std::endl;
// adding variables at current time t
for(int i = 0; i < nStations; ++i) {
// idle vehicles at station i at time t
idle_veh += vi[time_][i];
for(int j = 0; j < nStations; ++j) {
if (i != j) {
// travel_time is expressed in the number of reb periods, i.e., 1,2,3,...nRebPeriods
// travel_time for trips arriving to i from j
int travel_time = (int) (rounded_cost[j][i]/reb_period);
// index of vehicles arriving at i from j (departed from j to i travel_time ago)
int idx_arr = stationMatrix[j][i];
// divresult.rem is start time of the arriving trips
divresult = div (nRebPeriods + time_ - travel_time, nRebPeriods);
// std::cout << "Current time = " << time_ << ", travel_time = " << travel_time << ", divresult.rem = " << divresult.rem << ", idx_arr = "<< idx_arr << std::endl;
reb_arr += rij[divresult.rem][idx_arr];
// empty trips in transit (not arriving yet)
// if tt > 1 -> all trips started after divresult.rem and before time_
if (travel_time > 1) {
for (int k = 1; k < travel_time; ++k) {
divresult = div (nRebPeriods + time_ - travel_time + k, nRebPeriods);
// std::cout << "if travel_time > 1 => " << time_ << ", travel_time = " << travel_time << ", divresult.rem = " << divresult.rem << ", idx_arr = "<< idx_arr << std::endl;
reb_arr += rij[divresult.rem][idx_arr];
}
}
}
}
}
// adding variables at time (t-1)
for(int i = 0; i < nStations; ++i) {
// idle vehicles at station i at time (t - 1)
divresult = div (nRebPeriods + time_ - 1, nRebPeriods);
idle_veh_prev += vi[divresult.rem][i];
for(int j = 0; j < nStations; ++j) {
if (i != j) {
// travel_time is expressed in the number of reb periods, i.e., 1,2,3,...nRebPeriods
// travel_time for trips arriving to i from j
int travel_time = (int) (rounded_cost[j][i]/reb_period);
// index of vehicles arriving at i from j (departed from j to i travel_time ago)
int idx_arr = stationMatrix[j][i];
// divresult.rem is start time of the arriving trips
divresult = div (nRebPeriods + time_ - 1 - travel_time, nRebPeriods);
// std::cout << "Previous time = " << nRebPeriods + time_ - 1 << ", travel_time = " << travel_time << ", divresult.rem = " << divresult.rem << ", idx_arr = "<< idx_arr << std::endl;
reb_arr_prev += rij[divresult.rem][idx_arr];
// empty trips in transit (not arriving yet)
// if tt > 1 -> all trips started after divresult.rem and before time_
if (travel_time > 1) {
for (int k = 1; k < travel_time; ++k) {
divresult = div (nRebPeriods + time_ - 1 - travel_time + k, nRebPeriods);
reb_arr_prev += rij[divresult.rem][idx_arr];
}
}
}
}
}
// add constraints
ostringstream cname;
cname << "supply_t" << time_ ;
// total number of vehicles at time t == total number of vehicles at time (t-1)
divresult = div (nRebPeriods + time_ - 1, nRebPeriods);
model.addConstr(idle_veh + reb_arr + cust_vhs_at_t[time_] == idle_veh_prev + reb_arr_prev + cust_vhs_at_t[divresult.rem], cname.str());
model.update();
idle_veh.clear();
idle_veh_prev.clear();
reb_arr.clear();
reb_arr_prev.clear();
} // end constraints loop: for ( time_ = 0; time_ < nRebPeriods; ++time_)
std::cout << "Constraint set 2 added." << std::endl;
/***********************************************************************************
* Constraint 3: Flow conservation at station i
***********************************************************************************/
// This constraint is set to ensure that the number of vehicles available at station i at time t
// is equal to the number of vehicles available at this station in previous time interval
// plus whatever has arrived minus whatever has departed
for ( time_ = 0; time_ < nRebPeriods; ++time_) {
// Current demand
int dem_curr[nStations];
for (int i = 0; i < nStations; ++i) {
// current demand = arriving_vehicles - departing_vehicles
dem_curr[i] = dest_counts[time_][i] - origin_counts[time_][i];
// std::cout << origin_counts[time_][i] << " - " << dest_counts[time_][i] << " = " << dem_curr[i] << std::endl;
}
GRBLinExpr reb_dep = 0;
GRBLinExpr reb_arr = 0;
for(int depSt = 0; depSt < nStations; ++depSt){
// std::cout << "departure station: " << depSt << std::endl;
for (int arrSt = 0; arrSt < nStations; ++arrSt) {
if (depSt != arrSt) {
int idx = stationMatrix[depSt][arrSt];
int idx2 = stationMatrix[arrSt][depSt];
reb_dep += rij[time_][idx];
// std::cout << "rounded_cost = " << (int)rounded_cost[depSt][arrSt]/reb_period -1 << std::endl;
int travel_cost = (int) (rounded_cost[depSt][arrSt]/reb_period);
if (travel_cost > time_) {
int dep_time = nRebPeriods + time_ - travel_cost;
reb_arr += rij[dep_time][idx2];
} else {
int dep_time = time_ - travel_cost;
reb_arr += rij[dep_time][idx2];
}
}
}
ostringstream cname;
cname << "flow_ti" << time_ << "." << depSt;
if (time_ != nRebPeriods - 1) {
model.addConstr(vi[time_ + 1][depSt] ==
vi[time_][depSt] + reb_arr - reb_dep + dem_curr[depSt], cname.str());
} else {
// if we are in the last interval then we compare against the first interval of the next day
// here: vi(t=0) == vi(t=Tp)
model.addConstr(vi[0][depSt] ==
vi[time_][depSt] + reb_arr - reb_dep + dem_curr[depSt], cname.str());
}
//std::cout << "Constraint 1 vi @: " << time_ << "." << depSt << std::endl;
reb_arr.clear();
reb_dep.clear();
}
}
model.update();
std::cout << "Constraint set 3 added." << std::endl;
/***********************************************************************************
* Solve the problem and print solution to the console and to the file
***********************************************************************************/
model.optimize();
model.write(modelOutput);
int total_demand = 0;
int dem_curr[nStations];
for (int i = 0; i < nStations; ++i) {
dem_curr[i] = dest_counts[0][i] + in_transit_counts[0][i];
total_demand += dem_curr[i];
}
double numOfVeh = model.get(GRB_DoubleAttr_ObjVal) + total_demand; //plus rebalancing counts
cout << "\nTOTAL NUMBER OF VEHICLES: " << numOfVeh << std::endl;
cout << "\nTOTAL NUMBER OF AVAILABLE VEH AT TIME 0: " << model.get(GRB_DoubleAttr_ObjVal) << std::endl;
// cout << "SOLUTION:" << endl;
//
// for (time_ = 0; time_ < nRebPeriods; ++time_){
//
// for(int depSt = 0; depSt < nStations; ++depSt){
// for (int arrSt = 0; arrSt < nStations; ++arrSt) {
// if(depSt != arrSt) {
// int idx = stationMatrix[depSt][arrSt];
// cout << "At time " << time_ << ", rebalancing from station " << depSt <<
// " to station " << arrSt << " send " <<
// empty_veh[time_][idx].get(GRB_DoubleAttr_X) << " vehicles." << std::endl;
// }
// }
// }
// }
//
// for (time_ = 0; time_ < nRebPeriods; ++time_){
// for(int arrSt = 0; arrSt < nStations; ++arrSt){
// cout << "At time " << time_ << " at station " << arrSt <<
// " number of available vehicles: " << vhs_st_i[time_][arrSt].get(GRB_DoubleAttr_X) << std::endl;
// }
// cout << "At time " << time_ << " number of vehicles in transit: "
// << in_transit[time_].get(GRB_DoubleAttr_X) << std::endl;
// }
model.write(solutionOutput);
} catch(GRBException e) {
cout << "Error code = " << e.getErrorCode() << std::endl;
cout << e.getMessage() << std::endl;
} catch(...) {
cout << "Exception during optimization" << std::endl;
}
return 0;
}
int
main(int argc,
char *argv[])
{
GRBEnv* env = 0;
GRBVar* open = 0;
GRBVar** transport = 0;
int transportCt = 0;
try
{
// Number of plants and warehouses
const int nPlants = 5;
const int nWarehouses = 4;
// Warehouse demand in thousands of units
double Demand[] = { 15, 18, 14, 20 };
// Plant capacity in thousands of units
double Capacity[] = { 20, 22, 17, 19, 18 };
// Fixed costs for each plant
double FixedCosts[] =
{ 12000, 15000, 17000, 13000, 16000 };
// Transportation costs per thousand units
double TransCosts[][nPlants] = {
{ 4000, 2000, 3000, 2500, 4500 },
{ 2500, 2600, 3400, 3000, 4000 },
{ 1200, 1800, 2600, 4100, 3000 },
{ 2200, 2600, 3100, 3700, 3200 }
};
// Model
env = new GRBEnv();
GRBModel model = GRBModel(*env);
model.set(GRB_StringAttr_ModelName, "facility");
// Plant open decision variables: open[p] == 1 if plant p is open.
open = model.addVars(nPlants, GRB_BINARY);
model.update();
for (int p = 0; p < nPlants; ++p)
{
ostringstream vname;
vname << "Open" << p;
open[p].set(GRB_DoubleAttr_Obj, FixedCosts[p]);
open[p].set(GRB_StringAttr_VarName, vname.str());
}
// Transportation decision variables: how much to transport from
// a plant p to a warehouse w
transport = new GRBVar* [nWarehouses];
for (int w = 0; w < nWarehouses; ++w)
{
transport[w] = model.addVars(nPlants);
transportCt++;
model.update();
for (int p = 0; p < nPlants; ++p)
{
ostringstream vname;
vname << "Trans" << p << "." << w;
transport[w][p].set(GRB_DoubleAttr_Obj, TransCosts[w][p]);
transport[w][p].set(GRB_StringAttr_VarName, vname.str());
}
}
// The objective is to minimize the total fixed and variable costs
model.set(GRB_IntAttr_ModelSense, 1);
// Update model to integrate new variables
model.update();
model.write("prob.lp");
// Production constraints
// Note that the right-hand limit sets the production to zero if
// the plant is closed
for (int p = 0; p < nPlants; ++p)
{
GRBLinExpr ptot = 0;
for (int w = 0; w < nWarehouses; ++w)
{
ptot += transport[w][p];
}
ostringstream cname;
cname << "Capacity" << p;
model.addConstr(ptot <= Capacity[p] * open[p], cname.str());
}
// Demand constraints
for (int w = 0; w < nWarehouses; ++w)
{
GRBLinExpr dtot = 0;
for (int p = 0; p < nPlants; ++p)
{
dtot += transport[w][p];
}
ostringstream cname;
cname << "Demand" << w;
model.addConstr(dtot == Demand[w], cname.str());
}
// Guess at the starting point: close the plant with the highest
// fixed costs; open all others
// First, open all plants
for (int p = 0; p < nPlants; ++p)
{
open[p].set(GRB_DoubleAttr_Start, 1.0);
}
// Now close the plant with the highest fixed cost
cout << "Initial guess:" << endl;
double maxFixed = -GRB_INFINITY;
for (int p = 0; p < nPlants; ++p)
{
if (FixedCosts[p] > maxFixed)
{
maxFixed = FixedCosts[p];
}
}
for (int p = 0; p < nPlants; ++p)
{
if (FixedCosts[p] == maxFixed)
{
open[3].set(GRB_DoubleAttr_Start, 0.0);
cout << "Closing plant " << p << endl << endl;
break;
}
}
// Use barrier to solve root relaxation
model.getEnv().set(GRB_IntParam_Method, GRB_METHOD_BARRIER);
// Solve
model.optimize();
// Print solution
cout << "\nTOTAL COSTS: " << model.get(GRB_DoubleAttr_ObjVal) << endl;
cout << "SOLUTION:" << endl;
for (int p = 0; p < nPlants; ++p)
{
if (open[p].get(GRB_DoubleAttr_X) == 1.0)
{
cout << "Plant " << p << " open:" << endl;
for (int w = 0; w < nWarehouses; ++w)
{
if (transport[w][p].get(GRB_DoubleAttr_X) > 0.0001)
{
cout << " Transport " <<
transport[w][p].get(GRB_DoubleAttr_X) <<
" units to warehouse " << w << endl;
}
}
}
else
{
cout << "Plant " << p << " closed!" << endl;
}
}
}
catch (GRBException e)
{
cout << "Error code = " << e.getErrorCode() << endl;
cout << e.getMessage() << endl;
}
catch (...)
{
cout << "Exception during optimization" << endl;
}
delete[] open;
for (int i = 0; i < transportCt; ++i) {
delete[] transport[i];
}
delete[] transport;
delete env;
return 0;
}
int main(int argc, char *argv[])
{
int time_limit;
char name[1000];
ListGraph g;
EdgeWeight lpvar(g);
EdgeWeight weight(g);
NodeName vname(g);
ListGraph::NodeMap<double> posx(g),posy(g);
string filename;
int seed=1;
// uncomment one of these lines to change default pdf reader, or insert new one
//set_pdfreader("open"); // pdf reader for Mac OS X
//set_pdfreader("xpdf"); // pdf reader for Linux
//set_pdfreader("evince"); // pdf reader for Linux
srand48(seed);
time_limit = 3600; // solution must be obtained within time_limit seconds
if (argc!=2) {cout<< endl << "Usage: "<< argv[0]<<" <graph_filename>"<<endl << endl <<
"Example: " << argv[0] << " gr_berlin52" << endl <<
" " << argv[0] << " gr_att48" << endl << endl; exit(0);}
else if (!FileExists(argv[1])) {cout<<"File "<<argv[1]<<" does not exist."<<endl; exit(0);}
filename = argv[1];
// Read the graph
if (!ReadListGraph(filename,g,vname,weight,posx,posy))
{cout<<"Error reading graph file "<<argv[1]<<"."<<endl;exit(0);}
TSP_Data tsp(g,vname,posx,posy,weight);
ListGraph::EdgeMap<GRBVar> x(g);
GRBEnv env = GRBEnv();
GRBModel model = GRBModel(env);
#if GUROBI_NEWVERSION
model.getEnv().set(GRB_IntParam_LazyConstraints, 1);
model.getEnv().set(GRB_IntParam_Seed, seed);
#else
model.getEnv().set(GRB_IntParam_DualReductions, 0); // Dual reductions must be disabled when using lazy constraints
#endif
model.set(GRB_StringAttr_ModelName, "Emparelhamento perfeito with GUROBI");
// name to the problem
model.set(GRB_IntAttr_ModelSense, GRB_MAXIMIZE); // is a minimization problem
// Add one binary variable for each edge and also sets its cost in
//the objective function
for (ListGraph::EdgeIt e(g); e!=INVALID; ++e) {
sprintf(name,"x_%s_%s",vname[g.u(e)].c_str(),vname[g.v(e)].c_str());
x[e] = model.addVar(0.0, 1.0, weight[e],GRB_BINARY,name);
}
model.update(); // run update to use model inserted variables
// Add degree constraint for each node (sum of solution edges incident to a node is 2)
for (ListGraph::NodeIt v(g); v!=INVALID; ++v) {
GRBLinExpr expr;
for (ListGraph::IncEdgeIt e(g,v); e!=INVALID; ++e) expr += x[e];
//aqui model.addConstr(expr == 2 ); what? ignorou!
model.addConstr(expr == 1);
}
try {
model.update(); // Process any pending model modifications.
if (time_limit >= 0) model.getEnv().set(GRB_DoubleParam_TimeLimit,time_limit);
model.update(); // Process any pending model modifications.
model.write("model.lp");
system("cat model.lp");
model.optimize();
double soma=0.0;
int i = 0;
for (ListGraph::EdgeIt e(g); e!=INVALID; ++e) {
lpvar[e] = x[e].get(GRB_DoubleAttr_X);
if (lpvar[e] > 1-BC_EPS ) {
soma += weight[e];
cout << "Achei, x("<< vname[g.u(e)] << " , " << vname[g.v(e)] << ") = " << lpvar[e] <<"\n";
tsp.BestCircuit[i] = g.u(e);
tsp.BestCircuit[i+1] = g.v(e);
i = i+2;
}
}
cout << "Solution cost = "<< soma << endl;
ViewTspCircuit(tsp);
}catch (...) {
if (tsp.BestCircuitValue < DBL_MAX) {
cout << "Heuristic obtained optimum solution" << endl;
ViewTspCircuit(tsp);
return 0;
}else {
cout << "Graph is infeasible" << endl;
return 1;
}
}
}
