void CPLEX_LP_IMSTSolver_v2::generateFlowVariables() {
EdgeIdx edgeIdCount { };
VertexIdx sourceVertexIdx { };
VertexIdx targetVertexIdx { };
EdgeIF* edge { };
VertexIF* vertex { };
flowVariables = IloNumVarArray(env, 2 * numberOfEdges, 0, IloInfinity);
INFO_NOARG(logger, LogBundleKey::CPLPIMST2_FLOW_GEN);
if (graph->hasAnyVertex(Visibility::VISIBLE)) {
initialVertexIdx = graph->nextVertex()->getVertexIdx();
INFO(logger, LogBundleKey::CPLPIMST2_FLOW_GEN_INIT_NODE,
initialVertexIdx);
flowVariablesMap.insert(
std::make_pair(initialVertexIdx,
IloTargetVertexFlowVarMap { }));
while (graph->hasNextVertex(Visibility::VISIBLE)) {
flowVariablesMap.insert(
std::make_pair(graph->nextVertex()->getVertexIdx(),
IloTargetVertexFlowVarMap { }));
}
edgeIdCount = 0;
graph->beginEdge();
while (graph->hasNextEdge(Connectivity::CONNECTED, Visibility::VISIBLE)) {
edge = graph->nextEdge();
sourceVertexIdx = edge->getSourceVertex()->getVertexIdx();
targetVertexIdx = edge->getTargetVertex()->getVertexIdx();
INFO(logger, LogBundleKey::CPLPIMST2_FLOW_GEN_VAR, sourceVertexIdx,
targetVertexIdx,
getVariableName(flowVariables[edgeIdCount]).c_str());
flowVariablesMap.at(sourceVertexIdx).insert(
std::make_pair(targetVertexIdx,
flowVariables[edgeIdCount]));
edgeIdCount += 1;
INFO(logger, LogBundleKey::CPLPIMST2_FLOW_GEN_VAR, sourceVertexIdx,
targetVertexIdx,
getVariableName(flowVariables[edgeIdCount]).c_str());
flowVariablesMap.at(targetVertexIdx).insert(
std::make_pair(sourceVertexIdx,
flowVariables[edgeIdCount]));
edgeIdCount += 1;
}
}
}
void Instance::ComputeCPLEXRevenue() {
IloEnv env;
IloInt i, j;
IloModel model(env);
IloInt nbImpressions = num_impressions_;
IloInt nbAdvertisers = num_advertisers_;
NumVarMatrix x(env, nbImpressions);
for(i = 0; i < nbImpressions; i++) {
x[i] = IloNumVarArray(env, nbAdvertisers, 0.0, 1.0, ILOFLOAT);
}
// Add impression constraints.
for(i = 0; i < nbImpressions; i++) {
model.add(IloSum(x[i]) <= 1.0);
}
// Add weighted contraint.
for(j = 0; j < nbAdvertisers; j++) {
IloExpr curr_adv_constraint(env);
for (__gnu_cxx::hash_map<int, long double>::iterator iter = bids_matrix_[j].begin();
iter != bids_matrix_[j].end();
++iter) {
curr_adv_constraint += ((double) iter->second) * ((double) weights_[j]) * x[iter->first][j];
}
model.add(curr_adv_constraint <= ((double) budgets_[j]));
}
IloExpr obj_exp(env);
for(i = 0; i < nbImpressions; i++) {
for(j = 0; j < nbAdvertisers; j++) {
obj_exp += ((double) transpose_bids_matrix_[i][j]) * x[i][j];
}
}
model.add(IloMaximize(env, obj_exp));
obj_exp.end();
IloCplex cplex(env);
cplex.setOut(env.getNullStream());
cplex.extract(model);
// Optimize the problem and obtain solution.
if ( !cplex.solve() ) {
env.error() << "Failed to optimize LP" << endl;
throw(-1);
}
cplex.exportModel("/Users/ciocan/Documents/Google/data/example.lp");
cout << "CPLEX opt is " << cplex.getObjValue() << "\n";
env.end();
}
int createVars(const Problem<double>& P, IloEnv& env, IloNumVarMatrix& x, IloNumVarMatrix& y, IloNumVarMatrix& b, IloNumVarMatrix& w){
try{
int i;
const int nbTask=P.nbTask;
const int E= 2*nbTask;
for (i=0;i<nbTask;i++){
x[i]=IloNumVarArray(env, E, 0, 1, ILOINT);
y[i]=IloNumVarArray(env, E, 0, 1, ILOINT);
b[i]=IloNumVarArray(env, E-1, 0, ((P.d(i)-P.r(i))*P.bmax(i)), ILOFLOAT);
w[i]=IloNumVarArray(env, E-1, 0, (P.d(i)-P.r(i))*P.A[i].Fi(P.bmax(i)), ILOFLOAT);
}
return 0;
}
catch (IloException &e){
std::cout << "iloexception in create vars" <<e <<std::endl;
e.end();
return 1;
}
}
void CPLEX_LP_IMSTSolver_v2::createEdgeVariables(GraphIF * const graph,
IloNumVar::Type edgeVariablesType) {
EdgeIdx edgeId { };
VertexIdx sourceVertexIdx { };
VertexIdx targetVertexIdx { };
EdgeIF* edge { };
IteratorId edgeIterator = graph->getEdgeIteratorId();
INFO(logger, LogBundleKey::CPLPIMST2_EDGE_VAR_GEN,
graph->getNumberOfEdges(Visibility::VISIBLE),
EnumUtils::getLPVariableTypeString(
static_cast<unsigned int>(edgeVariablesType)));
edgeVariableArray = IloNumVarArray(env,
graph->getNumberOfEdges(Visibility::VISIBLE), 0, 1,
edgeVariablesType);
model.add(edgeVariableArray);
graph->beginEdge(edgeIterator);
while (graph->hasNextEdge(edgeIterator, Connectivity::CONNECTED,
Visibility::VISIBLE)) {
edge = graph->nextEdge(edgeIterator);
sourceVertexIdx = edge->getSourceVertex()->getVertexIdx();
targetVertexIdx = edge->getTargetVertex()->getVertexIdx();
if (edgeVariableMap.count(sourceVertexIdx) == 0) {
edgeVariableMap.insert(
std::make_pair(sourceVertexIdx,
IloTargetVertexEdgeVarMap()));
}
edgeVariableMap.at(sourceVertexIdx).insert(
std::make_pair(targetVertexIdx,
std::make_pair(edgeVariableArray[edgeId], edge)));
INFO(logger, LogBundleKey::CPLPIMST2_EDGE_VAR_ADD,
LogStringUtils::edgeVisualization(
edgeVariableMap.at(sourceVertexIdx).at(targetVertexIdx).second,
"\t").c_str(), sourceVertexIdx, targetVertexIdx,
getVariableName(
edgeVariableMap.at(sourceVertexIdx).at(targetVertexIdx).first).c_str());
edgeId += 1;
}
graph->removeEdgeIterator(edgeIterator);
}
DataVarNumMatrix::DataVarNumMatrix(string name, double borne, IloEnv env,int n, int m){
this->Matrix = IloArray<IloNumVarArray> (env,n);
for(int i = 0; i < n; i++){
this->Matrix[i] = IloNumVarArray(env,m,0,borne);
for(int j = 0; j < m; j++){
string var_name = name;//attribut à nom de la forme x(i,j) à la variable
var_name += "(";
var_name += U::to_s(i+1);
var_name += ",";
var_name += U::to_s(j+1);
var_name += ")";
this->Matrix[i][j] = IloNumVar(env,0,borne,var_name.c_str());
}
}
this->n = n;
this->m = m;
}
int
main(int argc, char** argv)
{
IloEnv env;
try {
IloInt i, j;
const char* filename;
if (argc > 1)
filename = argv[1];
else
filename = "../../../examples/data/etsp.dat";
ifstream f(filename, ios::in);
if (!f) {
cerr << "No such file: " << filename << endl;
throw(1);
}
IntMatrix activityOnAResource(env);
NumMatrix duration(env);
IloNumArray jobDueDate(env);
IloNumArray jobEarlinessCost(env);
IloNumArray jobTardinessCost(env);
f >> activityOnAResource;
f >> duration;
f >> jobDueDate;
f >> jobEarlinessCost;
f >> jobTardinessCost;
IloInt nbJob = jobDueDate.getSize();
IloInt nbResource = activityOnAResource.getSize();
IloModel model(env);
// Create start variables
NumVarMatrix s(env, nbJob);
for (j = 0; j < nbJob; j++) {
s[j] = IloNumVarArray(env, nbResource, 0.0, Horizon);
}
// State precedence constraints
for (j = 0; j < nbJob; j++) {
for (i = 1; i < nbResource; i++) {
model.add(s[j][i] >= s[j][i-1] + duration[j][i-1]);
}
}
// State disjunctive constraints for each resource
for (i = 0; i < nbResource; i++) {
IloInt end = nbJob - 1;
for (j = 0; j < end; j++) {
IloInt a = activityOnAResource[i][j];
for (IloInt k = j + 1; k < nbJob; k++) {
IloInt b = activityOnAResource[i][k];
model.add(s[j][a] >= s[k][b] + duration[k][b] ||
s[k][b] >= s[j][a] + duration[j][a]);
}
}
}
// The cost is the sum of earliness or tardiness costs of each job
IloInt last = nbResource - 1;
IloExpr costSum(env);
for (j = 0; j < nbJob; j++) {
costSum += IloPiecewiseLinear(s[j][last] + duration[j][last],
IloNumArray(env, 1, jobDueDate[j]),
IloNumArray(env, 2, -jobEarlinessCost[j], jobTardinessCost[j]),
jobDueDate[j], 0);
}
model.add(IloMinimize(env, costSum));
costSum.end();
IloCplex cplex(env);
cplex.extract(model);
cplex.setParam(IloCplex::Param::Emphasis::MIP, 4);
if (cplex.solve()) {
cout << "Solution status: " << cplex.getStatus() << endl;
cout << " Optimal Value = " << cplex.getObjValue() << endl;
}
}
catch (IloException& ex) {
cerr << "Error: " << ex << endl;
}
catch (...) {
cerr << "Error" << endl;
}
env.end();
return 0;
}
int
main(int argc)
{
IloEnv env;
try {
IloModel model(env);
NumVarMatrix varOutput(env, J + current);
NumVar3Matrix varHelp(env, J + current);
Range3Matrix cons(env, J + current);
for (int j = 0; j <J + current; j++){
varOutput[j] = IloNumVarArray(env, K);
varHelp[j] = NumVarMatrix(env, K);
cons[j] = RangeMatrix(env, K);
for (int k = 0; k < K; k++){
varOutput[j][k] = IloNumVar(env, 0.0, IloInfinity);
varHelp[j][k] = IloNumVarArray(env, L);
cons[j][k] = IloRangeArray(env, C);
for (int l = 0; l < L; l++){
varHelp[j][k][l] = IloNumVar(env, 0.0, IloInfinity);
}
if (j > current){
cons[j][k][0] = IloRange(env, 0.0, 0.0);//will be used to express equality of varOutput, constraint (0)
cons[j][k][1] = IloRange(env, 0.0, IloInfinity);// constraint (1)
cons[j][k][2] = IloRange(env, -IloInfinity, T[j] - Tdc - Tblow[j] - Tslack);// constraint (2)
cons[j][k][3] = IloRange(env, Tfd[k], Tfd[k]);// constraint (3)
cons[j][k][4] = IloRange(env, 0.0, IloInfinity);// constraint (4)
cons[j][k][5] = IloRange(env, Tdf[k], IloInfinity);// constraint (5)
cons[j][k][6] = IloRange(env, T[j - a[k]] + Tcd, T[j - a[k]] + Tcd);// constraint (6)
cons[j][k][7] = IloRange(env, TlossD[k], IloInfinity);// constraint (7)
cons[j][k][8] = IloRange(env, TlossF[k], IloInfinity);// constraint (8)
}
}
}
populatebynonzero(model, varOutput, varHelp, cons);
IloCplex cplex(model);
// Optimize the problem and obtain solution.
if (!cplex.solve()) {
env.error() << "Failed to optimize LP" << endl;
throw(-1);
}
IloNumArray vals(env);
IloNumVar val(env);
//vars to save output
double TimeAvailable[J][K];
double TimeInstances[J][K][L];
double LK103[J][2];
env.out() << "Solution status = " << cplex.getStatus() << endl;
env.out() << "Solution value = " << cplex.getObjValue() << endl;
for (int j = current; j < current + J; ++j)
{
cplex.getValues(vals, varOutput[j]);
env.out() << "Seconds for load "<<j<<" = " << vals << endl;
/*for (int k = 0; k < K; k++){
TimeAvailable[j][k] = cplex.getValue(varOutput[j][k]);
}*/
}
for (int j = current; j < current + J; j++){
for (int k = 0; k < K; k++){
cplex.getValues(vals, varHelp[j][k]);
env.out() << "Time instances for spoon "<<k<<" in load "<<j<<" = " << vals << endl;
/*for (int l = 0; l < L; l++){
TimeInstances[j][k][l] = cplex.getValue(varHelp[j][k][l]);
}*/
}
}
for (int j = current + 2; j < J + current; j++){
LK103[j][0] = TimeInstances[j - 2][0][0];
LK103[j][1] = TimeInstances[j][0][5];
env.out() << "LK103, load " << j << " : " << LK103[j][1]-LK103[j][0] << endl;
}
/*cplex.getSlacks(vals, cons);
env.out() << "Slacks = " << vals << endl;
cplex.getDuals(vals, cons);
env.out() << "Duals = " << vals << endl;
cplex.getReducedCosts(vals, varOutput);
env.out() << "Reduced Costs = " << vals << endl;*/
cplex.exportModel("lpex1.lp");
}
catch (IloException& e) {
cerr << "Concert exception caught: " << e << endl;
}
catch (...) {
cerr << "Unknown exception caught" << endl;
}
env.end();
cin.get();
return 0;
} // END main
void kMST_ILP::modelSCF()
{
// single commodity flow model
// flow for each edge
flow_scf = IloNumVarArray(env, edges.getSize());
for (unsigned int i=0; i<flow_scf.getSize(); i++) {
flow_scf[i] = IloNumVar(env, Tools::indicesToString("flow", i).c_str());
// non-zero
model.add(0 <= flow_scf[i]);
// at most k, also ensures that edge is taken if flow is non-zero
model.add(flow_scf[i] <= k*edges[i]);
}
// 0 emits k+1 tokens
{
vector<u_int> outgoingEdgeIds;
getOutgoingEdgeIds(outgoingEdgeIds, 0);
IloExpr outgoingFlowSum(env);
for (unsigned int i=0; i<outgoingEdgeIds.size(); i++) {
outgoingFlowSum += flow_scf[ outgoingEdgeIds[i] ];
}
model.add(outgoingFlowSum == k);
}
// flow conservation, each node, which is taken, eats one (except first)
{
vector<u_int> outgoingEdgeIds;
getOutgoingEdgeIds(outgoingEdgeIds, 0);
for (unsigned int vertex=1; vertex<instance.n_nodes; vertex++) {
vector<u_int> outgoingEdgeIds, incomingEdgeIds;
getIncomingEdgeIds(incomingEdgeIds, vertex);
IloExpr incomingFlowSum(env);
IloExpr incomingEdgesSum(env);
for (unsigned int i=0; i<incomingEdgeIds.size(); i++) {
incomingFlowSum += flow_scf[ incomingEdgeIds[i] ];
incomingEdgesSum += edges[ incomingEdgeIds[i] ];
}
getOutgoingEdgeIds(outgoingEdgeIds, vertex);
IloExpr outgoingFlowSum(env);
for (unsigned int i=0; i<outgoingEdgeIds.size(); i++) {
outgoingFlowSum += flow_scf[ outgoingEdgeIds[i] ];
}
// vertex is part solution if one incoming vertex is used
model.add(incomingFlowSum - outgoingFlowSum == incomingEdgesSum);
incomingFlowSum.end();
incomingEdgesSum.end();
outgoingFlowSum.end();
}
}
}
int main(int argc, char **argv) {
clock_t t1, t2;
t1 = clock();
IloEnv env;
IloModel model(env);
IloCplex cplex(model);
/************************** Defining the parameters ************************************/
IloInt N; //No. of nodes
IloInt M; //No. of calls
Num2DMatrix links(env); //Defines the topology of the network
IloNumArray call_demand(env); //link bandwidth requirement of each call
IloNumArray call_revenue(env); //revenue generated from the call
IloNumArray call_origin(env); //origin node index of each call
IloNumArray call_destination(env); //destination node index of each call
Num2DMatrix Q(env); //Bandwidth capacity of each link
Num2DMatrix sigma(env); //Standard deviation of service times on link (i,j)
Num2DMatrix cv(env); //coefficient of variation of service times on the link (i,j)
IloNum C; //Unit queueing delay cost per unit time
IloNumArray R_approx_init(env);
ifstream fin;
const char* filename = "BPP_data_sample - Copy.txt";
if (argc > 1)
filename = argv[1];
fin.open(filename);
//fin.open("BPP_10node_navneet.txt");
fin >> links >> call_origin >> call_destination >> call_demand >>
call_revenue >> Q >> cv >> R_approx_init >> C ;
cout << "Reading Data from the file - "<<filename<<endl;
N = links.getSize();
M = call_origin.getSize();
IloInt H = R_approx_init.getSize();
Num3DMatrix R_approx(env, N); //The tangential linear function approximation to R.
for (IloInt i=0; i<N; i++) {
R_approx[i] = Num2DMatrix(env, N);
for (IloInt j=0; j<N; j++) {
R_approx[i][j] = IloNumArray(env, H);
for (IloInt h=0; h<H; h++)
R_approx[i][j][h] = R_approx_init[h];
}
}
/************************** Defining the parameters ENDS ************************************/
/************* Defining the variables defined in the model formulation **********************/
IloNumVarArray Y(env, M, 0, 1, ILOINT); //Variable to define whether a call m is routed or not
IloNumArray Y_sol(env, M); //Solution values
NumVar3DMatrix X(env, N); //Variable to define whether a call m is routed along path i-j
Num3DMatrix X_sol(env, N);
for (IloInt i=0; i<N; i++) {
X[i] = NumVar2DMatrix(env, N);
X_sol[i] = Num2DMatrix(env, N);
for (IloInt j=0; j<N; j++) {
X[i][j] = IloNumVarArray(env, M, 0, 1, ILOINT);
X_sol[i][j] = IloNumArray(env, M);
}
}
NumVar3DMatrix W(env, N); //Variable to define whether a call m is routed along path i-j
for (IloInt i=0; i<N; i++) {
W[i] = NumVar2DMatrix(env, N);
for (IloInt j=0; j<N; j++)
W[i][j] = IloNumVarArray(env, M, 0, 1, ILOINT);
}
NumVar2DMatrix R(env, (IloInt)N); //The linearization Variable
for (IloInt i=0; i<N; i++)
R[i] = IloNumVarArray(env, (IloInt)N, 0, IloInfinity, ILOFLOAT);
/************* Defining the variables defined in the model formulation ENDS *****************/
/**************************** Defining the Constraints *******************************/
// Constraint #1 : Flow Conservation Constraint
for (IloInt m=0; m<M; m++) {
for (IloInt i=0; i<N; i++) {
IloExpr constraint1(env);
for (IloInt j=0; j<N; j++) {
if (links[i][j] == 1)
constraint1 += W[i][j][m];
}
for (IloInt j=0; j<N; j++) {
if (links[j][i] == 1)
constraint1 += -W[j][i][m];
}
if (i == call_origin[m])
model.add(constraint1 == Y[m]);
else if (i == call_destination[m])
model.add(constraint1 == -Y[m]);
else
model.add(constraint1 == 0);
constraint1.end();
}
}
// Constraint #2 :
for (IloInt m=0; m<M; m++) {
for (IloInt i=0; i<N; i++) {
for (IloInt j=0; j<N; j++) {
if (links[i][j] == 1)
model.add(W[i][j][m] + W[j][i][m] <= X[i][j][m]);
}
}
}
// Constraint #3 : Link Capacity Constraint
for (IloInt i=0; i<N; i++) {
for (IloInt j=i+1; j<N; j++) {
if (links[i][j] == 1) {
IloExpr constraint3(env);
for (IloInt m=0; m<M; m++)
constraint3 += call_demand[m]*X[i][j][m];
model.add(constraint3 <= Q[i][j]);
constraint3.end();
}
}
}
// Constraint #4 : Defining the constraint for initial values of R_approx,
// Cuts must be added during the iterations whenever the values are updated
for (IloInt i=0; i<N; i++) {
for (IloInt j=i+1; j<N; j++) {
if (links[i][j] == 1) {
for (IloInt h=0; h<H; h++) {
IloExpr constraint4_lhs(env);
IloNum constraint4_rhs = 0;
for (IloInt m=0; m<M; m++)
constraint4_lhs += call_demand[m]*X[i][j][m];
constraint4_lhs -= (Q[i][j]/((1+R_approx[i][j][h])*(1+R_approx[i][j][h])))*R[i][j];
constraint4_rhs = Q[i][j]*((R_approx[i][j][h]/(1+R_approx[i][j][h])) *
(R_approx[i][j][h]/(1+R_approx[i][j][h])));
model.add(constraint4_lhs <= constraint4_rhs);
constraint4_lhs.end();
}
}
}
}
/************************** Defining the Constraints ENDS ****************************/
/************************ Defining the Objective Function ****************************/
IloExpr Objective(env);
IloExpr Obj_expr1(env);
IloExpr Obj_expr2(env);
for (IloInt m=0; m<M; m++)
Obj_expr1 += call_revenue[m]*Y[m];
for (IloInt i=0; i<N; i++) {
for (IloInt j=i+1; j<N; j++) {
if (links[i][j] == 1) {
Obj_expr2 += (1+cv[i][j] * cv[i][j])*R[i][j];
for (IloInt m=0; m<M; m++)
Obj_expr2 += ((1-cv[i][j] * cv[i][j])/Q[i][j])*call_demand[m]*X[i][j][m];
}
}
}
Objective += Obj_expr1 - 0.5*C*Obj_expr2;
model.add(IloMaximize(env, Objective));
//model.add(IloMinimize(env, -Objective));
Objective.end();
Obj_expr1.end();
Obj_expr2.end();
/********************** Defining the Objective Function ENDS **************************/
IloNum eps = cplex.getParam(IloCplex::EpInt);
IloNum UB = IloInfinity;
IloNum LB = -IloInfinity;
/***************** Solve ***********************/
do {
cplex.setParam(IloCplex::MIPInterval, 5);
cplex.setParam(IloCplex::NodeFileInd ,2);
cplex.setOut(env.getNullStream());
cplex.exportModel("BPP_model.lp");
if(!cplex.solve()) {
cout << "Infeasible"<<endl;
system("pause");
}
else {
for (IloInt m=0; m<M; m++) {
if (cplex.getValue(Y[m]) > eps) {
cout << "Call(m) = "<<m+1<<" : "<<call_origin[m]+1<<" --> "<<call_destination[m]+1
<<"; demand = "<<call_demand[m]<<endl;
cout << "Path : ";
for (IloInt i=0; i<N; i++) {
for (IloInt j=i+1; j<N; j++) {
if (links[i][j] == 1) {
if (cplex.getValue(X[i][j][m]) > eps) {
X_sol[i][j][m] = 1;
cout <<i+1<<"-"<<j+1<<"; ";
}
}
}
}
cout << endl << endl;
}
}
//system("pause");
}
UB = min(UB, cplex.getObjValue());
IloNum lbound = 0;
for (IloInt m=0; m<M; m++)
if(cplex.getValue(Y[m]) > eps)
lbound += call_revenue[m];
for (IloInt i=0; i<N; i++) {
for (IloInt j=i+1; j<N; j++) {
if (links[i][j] == 1) {
IloNum lbound_temp1 = 0;
IloNum lbound_temp2 = 0;
for (IloInt m=0; m<M; m++)
lbound_temp1 += call_demand[m]*X_sol[i][j][m];
lbound_temp2 = 0.5*(1+cv[i][j]*cv[i][j]) * (lbound_temp1*lbound_temp1) / (Q[i][j]*(Q[i][j]-lbound_temp1));
lbound_temp2 += lbound_temp1 / Q[i][j];
lbound -= C*lbound_temp2;
}
}
}
LB = max(LB, lbound);
Num2DMatrix R_approx_new(env, N);
for (IloInt i=0; i<N; i++)
R_approx_new[i] = IloNumArray(env, N);
for (IloInt i=0; i<N; i++) {
for (IloInt j=i+1; j<N; j++) {
if (links[i][j] == 1) {
IloExpr cut_lhs(env);
IloNum cut_rhs = 0;
IloNum cut_temp = 0;
for (IloInt m=0; m<M; m++) {
cut_temp += call_demand[m]*X_sol[i][j][m];
}
R_approx_new[i][j] = cut_temp / (Q[i][j] - cut_temp);
//cout << "R_approx_new = "<<R_approx_new<<endl;
for (IloInt m=0; m<M; m++)
cut_lhs += call_demand[m]*X[i][j][m];
cut_lhs -= (Q[i][j]/((1+R_approx_new[i][j])*(1+R_approx_new[i][j])))*R[i][j];
cut_rhs = Q[i][j]*((R_approx_new[i][j]/(1+R_approx_new[i][j])) *
(R_approx_new[i][j]/(1+R_approx_new[i][j])));
model.add(cut_lhs <= cut_rhs);
cut_lhs.end();
}
}
}
cout << "UB = "<<UB<<endl;
cout << "LB = "<<LB<<endl;
cout << "Gap (%) = "<<(UB-LB)*100/LB<<endl;
//system("pause");
}while ((UB-LB)/UB > eps);
t2 = clock();
float secs = (float)t2 - (float)t1;
secs = secs / CLOCKS_PER_SEC;
cout << "CPUTIME = "<<secs <<endl<<endl;
}
void Instance::VerifySolution() {
IloEnv env;
IloInt i, j;
IloModel model(env);
IloInt nbImpressions = num_impressions_;
IloInt nbAdvertisers = num_advertisers_;
NumVarMatrix x(env, nbImpressions);
// NumVarMatrix y(env, nbImpressions);
for(i = 0; i < nbImpressions; i++) {
x[i] = IloNumVarArray(env, nbAdvertisers, 0.0, 1.0, ILOFLOAT);
// y[i] = IloNumVarArray(env, nbAdvertisers, 0.0, 1.0, ILOFLOAT);
}
// Add impression constraints.
for(i = 0; i < nbImpressions; i++) {
model.add(IloSum(x[i]) <= 1.0);
}
// Add weighted contraint.
IloExpr weighted_constraint(env);
for(j = 0; j < nbImpressions; j++) { // demand must meet supply
for(i = 0; i < nbAdvertisers; i++) {
weighted_constraint += ((double) transpose_bids_matrix_[j][i]) * ((double) weights_[i]) * x[j][i];
}
}
model.add(weighted_constraint <= ((double) global_problem_.budget_));
weighted_constraint.end();
IloExpr obj_exp(env);
for(i = 0; i < nbImpressions; i++) {
for(j = 0; j < nbAdvertisers; j++) {
obj_exp += ((double) transpose_bids_matrix_[i][j]) * x[i][j];
}
}
model.add(IloMaximize(env, obj_exp));
obj_exp.end();
IloCplex cplex(env);
cplex.setOut(env.getNullStream());
cplex.extract(model);
// Optimize the problem and obtain solution.
if ( !cplex.solve() ) {
env.error() << "Failed to optimize LP" << endl;
throw(-1);
}
IloNumArray vals(env);
long double sum_b = 0;
for (int a = 0; a < num_advertisers_; ++a) {
//slacks_[a] = 0;
for (i = 0; i < nbImpressions; i++) {
if (cplex.getValue(x[i][a]) > 0) {
//slacks_[a] = slacks_[a] + cplex.getValue(x[i][a]) * bids_matrix_[a].find(i)->second;
sum_b += cplex.getValue(x[i][a]) * bids_matrix_[a].find(i)->second * weights_[a];
}
}
}
cout << "Cplex buget allocation is = ";
cout << sum_b;
cout << "\n";
if (cplex.getObjValue() == CalculateGlobalMWProblemOpt()) {
cout << "Solution checks \n";
} else {
cout << "Solution does not check, Cplex opt is ";
cout << cplex.getObjValue();
cout << "\n";
}
env.end();
}
int
main()
{
IloEnv env;
try {
NumMatrix cost(env, nbMonths);
cost[0]=IloNumArray(env, nbProducts, 110.0, 120.0, 130.0, 110.0, 115.0);
cost[1]=IloNumArray(env, nbProducts, 130.0, 130.0, 110.0, 90.0, 115.0);
cost[2]=IloNumArray(env, nbProducts, 110.0, 140.0, 130.0, 100.0, 95.0);
cost[3]=IloNumArray(env, nbProducts, 120.0, 110.0, 120.0, 120.0, 125.0);
cost[4]=IloNumArray(env, nbProducts, 100.0, 120.0, 150.0, 110.0, 105.0);
cost[5]=IloNumArray(env, nbProducts, 90.0, 100.0, 140.0, 80.0, 135.0);
// Variable definitions
IloNumVarArray produce(env, nbMonths, 0, IloInfinity);
NumVarMatrix use(env, nbMonths);
NumVarMatrix buy(env, nbMonths);
NumVarMatrix store(env, nbMonths);
IloInt i, p;
for (i = 0; i < nbMonths; i++) {
use[i] = IloNumVarArray(env, nbProducts, 0, IloInfinity);
buy[i] = IloNumVarArray(env, nbProducts, 0, IloInfinity);
store[i] = IloNumVarArray(env, nbProducts, 0, 1000);
}
IloExpr profit(env);
IloModel model(env);
// For each type of raw oil we must have 500 tons at the end
for (p = 0; p < nbProducts; p++) {
store[nbMonths-1][p].setBounds(500, 500);
}
// Constraints on each month
for (i = 0; i < nbMonths; i++) {
// Not more than 200 tons of vegetable oil can be refined
model.add(use[i][v1] + use[i][v2] <= 200);
// Not more than 250 tons of non-vegetable oil can be refined
model.add(use[i][o1] + use[i][o2] + use[i][o3] <= 250);
// Constraints on food composition
model.add(3 * produce[i] <=
8.8 * use[i][v1] + 6.1 * use[i][v2] +
2 * use[i][o1] + 4.2 * use[i][o2] + 5 * use[i][o3]);
model.add(8.8 * use[i][v1] + 6.1 * use[i][v2] +
2 * use[i][o1] + 4.2 * use[i][o2] + 5 * use[i][o3]
<= 6 * produce[i]);
model.add(produce[i] == IloSum(use[i]));
// Raw oil can be stored for later use
if (i == 0) {
for (IloInt p = 0; p < nbProducts; p++)
model.add(500 + buy[i][p] == use[i][p] + store[i][p]);
}
else {
for (IloInt p = 0; p < nbProducts; p++)
model.add(store[i-1][p] + buy[i][p] == use[i][p] + store[i][p]);
}
// Logical constraints
// The food cannot use more than 3 oils
// (or at least two oils must not be used)
model.add((use[i][v1] == 0) + (use[i][v2] == 0) + (use[i][o1] == 0) +
(use[i][o2] == 0) + (use[i][o3] == 0) >= 2);
// When an oil is used, the quantity must be at least 20 tons
for (p = 0; p < nbProducts; p++)
model.add((use[i][p] == 0) || (use[i][p] >= 20));
// If products v1 or v2 are used, then product o3 is also used
model.add(IloIfThen(env, (use[i][v1] >= 20) || (use[i][v2] >= 20),
use[i][o3] >= 20));
// Objective function
profit += 150 * produce[i] - IloScalProd(cost[i], buy[i]) -
5 * IloSum(store[i]);
}
// Objective function
model.add(IloMaximize(env, profit));
IloCplex cplex(model);
if (cplex.solve()) {
cout << "Solution status: " << cplex.getStatus() << endl;
cout << " Maximum profit = " << cplex.getObjValue() << endl;
for (IloInt i = 0; i < nbMonths; i++) {
IloInt p;
cout << " Month " << i << " " << endl;
cout << " . buy ";
for (p = 0; p < nbProducts; p++) {
cout << cplex.getValue(buy[i][p]) << "\t ";
}
cout << endl;
cout << " . use ";
for (p = 0; p < nbProducts; p++) {
cout << cplex.getValue(use[i][p]) << "\t ";
}
cout << endl;
cout << " . store ";
for (p = 0; p < nbProducts; p++) {
cout << cplex.getValue(store[i][p]) << "\t ";
}
cout << endl;
}
}
else {
cout << " No solution found" << endl;
}
}
catch (IloException& ex) {
cerr << "Error: " << ex << endl;
}
catch (...) {
cerr << "Error" << endl;
}
env.end();
return 0;
}
ILOSTLBEGIN
int main (int argc, char* argv[]) {
//get instance fileName:
const char* fileName;
if(argc>1)//we passed the filename in arg
fileName=argv[1];
else fileName = "instances/instances_eleves/projet_5_8_1.dat";
//DONNEES DE L INSTANCE
typedef IloArray<IloNumArray> DataMatrix;
IloEnv env;
instance_Cplex instance ;
getData(fileName,env,instance);
cout << "Données récupérées!\n";
int& n(instance.n);
int& m(instance.m);
try {
IloModel model(env);
BoolVarMatrix x(env,m);
for(int i=0;i<m;i++) x[i]=IloBoolVarArray(env,n);
NumVarMatrix u(env,m);
for(int i=0;i<m;i++) u[i]=IloNumVarArray(env,n);
NumVarMatrix v(env,m);
for(int i=0;i<m;i++) v[i]=IloNumVarArray(env,n);
IloRangeArray constraintSet(env);
IloNumVar y(env);
IloNumVar z(env);
cout << "Variables créées!\n";
setdata(model,env, instance, x,u,v,y,z, constraintSet);
cout << " Modèle et contraintes définies!\n";
IloCplex cplex(model);
cplex.solve();
IloInt solutionUnConnex;
solutionUnConnex=cplex.getObjValue();
DataMatrix xUnconnex(env,m) ; //Solution optimale non connexe
for(int i=0;i<m;i++){
xUnconnex[i]=IloNumArray(env,n);
cplex.getValues(xUnconnex[i], x[i]);
}
std::string Method ="MinimizeEdges"; //connexityTree";
if(Method=="connexityTree"){
//We solve a first time the model without the connexity constraints, to get a good max bound of the height max : the value of the solution/2, then we add the connexity constraints :
IloInt hMax;
if(argc>2){ // we gave the hmax in argument/
istringstream (argv[2])>>hMax;
if(hMax==0) hMax=solutionUnConnex/2+1;
} //else we use our upper bound
else hMax=solutionUnConnex/2+1;//(n*m/2+n/2);
bool useCallBack=false;
if(argc>3 && *argv[3]=='1') useCallBack= true;
solveTreeConnexityConstraints(cplex,model,env,instance,x,u,v,y,z,useCallBack,hMax);
}
int
main(int argc, char **argv)
{
IloEnv env;
try {
IloInt i, j;
IloNumArray capacity(env), fixedCost(env);
FloatMatrix cost(env);
IloInt nbLocations;
IloInt nbClients;
const char* filename = "../../../examples/data/facility.dat";
if (argc > 1)
filename = argv[1];
ifstream file(filename);
if (!file) {
cerr << "ERROR: could not open file '" << filename
<< "' for reading" << endl;
cerr << "usage: " << argv[0] << " <file>" << endl;
throw(-1);
}
file >> capacity >> fixedCost >> cost;
nbLocations = capacity.getSize();
nbClients = cost.getSize();
IloBool consistentData = (fixedCost.getSize() == nbLocations);
for(i = 0; consistentData && (i < nbClients); i++)
consistentData = (cost[i].getSize() == nbLocations);
if (!consistentData) {
cerr << "ERROR: data file '"
<< filename << "' contains inconsistent data" << endl;
throw(-1);
}
IloNumVarArray open(env, nbLocations, 0, 1, ILOINT);
NumVarMatrix supply(env, nbClients);
for(i = 0; i < nbClients; i++)
supply[i] = IloNumVarArray(env, nbLocations, 0, 1, ILOINT);
IloModel model(env);
for(i = 0; i < nbClients; i++)
model.add(IloSum(supply[i]) == 1);
for(j = 0; j < nbLocations; j++) {
IloExpr v(env);
for(i = 0; i < nbClients; i++)
v += supply[i][j];
model.add(v <= capacity[j] * open[j]);
v.end();
}
IloExpr obj = IloScalProd(fixedCost, open);
for(i = 0; i < nbClients; i++) {
obj += IloScalProd(cost[i], supply[i]);
}
model.add(IloMinimize(env, obj));
obj.end();
IloCplex cplex(env);
cplex.extract(model);
cplex.solve();
cplex.out() << "Solution status: " << cplex.getStatus() << endl;
IloNum tolerance = cplex.getParam(
IloCplex::Param::MIP::Tolerances::Integrality);
cplex.out() << "Optimal value: " << cplex.getObjValue() << endl;
for(j = 0; j < nbLocations; j++) {
if (cplex.getValue(open[j]) >= 1 - tolerance) {
cplex.out() << "Facility " << j << " is open, it serves clients ";
for(i = 0; i < nbClients; i++) {
if (cplex.getValue(supply[i][j]) >= 1 - tolerance)
cplex.out() << i << " ";
}
cplex.out() << endl;
}
}
}
catch(IloException& e) {
cerr << " ERROR: " << e << endl;
}
catch(...) {
cerr << " ERROR" << endl;
}
env.end();
return 0;
}
ILOBRANCHCALLBACK1(SOSbranch, IloSOS1Array, sos) {
IloNumArray x;
IloNumVarArray var;
try {
IloInt i;
x = IloNumArray(getEnv());
var = IloNumVarArray(getEnv());
IloNum bestx = EPS;
IloInt besti = -1;
IloInt bestj = -1;
IloInt num = sos.getSize();
for (i = 0; i < num; i++) {
if ( getFeasibility(sos[i]) == Infeasible ) {
var.clear();
sos[i].getVariables(var);
getValues(x, var);
IloInt n = var.getSize();
for (IloInt j = 0; j < n; j++) {
IloNum inf = IloAbs(x[j] - IloRound(x[j]));
if ( inf > bestx ) {
bestx = inf;
besti = i;
bestj = j;
}
}
}
}
if ( besti >= 0 ) {
IloCplex::BranchDirectionArray dir;
IloNumArray val;
try {
dir = IloCplex::BranchDirectionArray(getEnv());
val = IloNumArray(getEnv());
var.clear();
sos[besti].getVariables(var);
IloInt n = var.getSize();
for (IloInt j = 0; j < n; j++) {
if ( j != bestj ) {
dir.add(IloCplex::BranchDown);
val.add(0.0);
} else {
dir.add(IloCplex::BranchUp);
val.add(1.0);
}
}
makeBranch(var, val, dir, getObjValue());
makeBranch(var[bestj], 0.0, IloCplex::BranchDown, getObjValue());
}
catch (...) {
dir.end();
val.end();
throw;
}
dir.end();
val.end();
}
}
catch (...) {
var.end();
x.end();
throw;
}
var.end();
x.end();
}
int
main (void)
{
IloEnv env;
try {
IloModel model(env);
IloCplex cplex(env);
IloInt nbWhouses = 4;
IloInt nbLoads = 31;
IloInt w, l;
IloNumVarArray capVars(env, nbWhouses, 0, 10, ILOINT); // Used capacities
IloNumArray capLbs (env, nbWhouses, 2, 3, 5, 7); // Minimum usage level
IloNumArray costs (env, nbWhouses, 1, 2, 4, 6); // Cost per warehouse
// These variables represent the assigninment of a
// load to a warehouse.
IloNumVarArrayArray assignVars(env, nbWhouses);
for (w = 0; w < nbWhouses; w++) {
assignVars[w] = IloNumVarArray(env, nbLoads, 0, 1, ILOINT);
// Links the number of loads assigned to a warehouse with
// the capacity variable of the warehouse.
model.add(IloSum(assignVars[w]) == capVars[w]);
}
// Each load must be assigned to just one warehouse.
for (l = 0; l < nbLoads; l++) {
IloNumVarArray aux(env);
for (w = 0; w < nbWhouses; w++)
aux.add(assignVars[w][l]);
model.add(IloSum(aux) == 1);
aux.end();
}
model.add (IloMinimize(env, IloScalProd(costs, capVars)));
cplex.extract(model);
cplex.setParam(IloCplex::Param::MIP::Strategy::Search, IloCplex::Traditional);
if ( cplex.solve(SemiContGoal(env, capVars, capLbs)) ) {
cout << " --------------------------------------------------" << endl;
cout << "Solution status: " << cplex.getStatus() << endl;
cout << endl << "Solution found:" << endl;
cout << " Objective value = "
<< cplex.getObjValue() << endl << endl;
for (w = 0; w < nbWhouses; w++) {
cout << "Warehouse " << w << ": stored "
<< cplex.getValue(capVars[w]) << " loads" << endl;
for (l = 0; l < nbLoads; l++) {
if ( cplex.getValue(assignVars[w][l]) > 1e-5 )
cout << "Load " << l << " | ";
}
cout << endl << endl;
}
cout << " --------------------------------------------------" << endl;
}
else {
cout << " No solution found " << endl;
}
}
catch (IloException& e) {
cerr << "Concert exception caught: " << e << endl;
}
env.end();
return 0;
} // END main
int
main(int argc, char** argv)
{
if (argc <= 1) {
cerr << "Usage: " << argv[0] << " <model>" << endl;
cerr << " model = 0 -> convex piecewise linear model, " << endl;
cerr << " model = 1 -> concave piecewise linear model. [default]" << endl;
}
IloBool convex;
if (argc <= 1)
convex = IloFalse;
else
convex = atoi(argv[1]) == 0 ? IloTrue : IloFalse;
IloEnv env;
try {
IloInt i, j;
IloModel model(env);
IloInt nbDemand = 4;
IloInt nbSupply = 3;
IloNumArray supply(env, nbSupply, 1000.0, 850.0, 1250.0);
IloNumArray demand(env, nbDemand, 900.0, 1200.0, 600.0, 400.);
NumVarMatrix x(env, nbSupply);
NumVarMatrix y(env, nbSupply);
for(i = 0; i < nbSupply; i++) {
x[i] = IloNumVarArray(env, nbDemand, 0.0, IloInfinity, ILOFLOAT);
y[i] = IloNumVarArray(env, nbDemand, 0.0, IloInfinity, ILOFLOAT);
}
for(i = 0; i < nbSupply; i++) { // supply must meet demand
model.add(IloSum(x[i]) == supply[i]);
}
for(j = 0; j < nbDemand; j++) { // demand must meet supply
IloExpr v(env);
for(i = 0; i < nbSupply; i++)
v += x[i][j];
model.add(v == demand[j]);
v.end();
}
if (convex) {
for(i = 0; i < nbSupply; i++) {
for(j = 0; j < nbDemand; j++) {
model.add(y[i][j] == IloPiecewiseLinear(x[i][j],
IloNumArray(env, 2, 200.0, 400.0),
IloNumArray(env, 3, 30.0, 80.0, 130.0),
0.0, 0.0));
}
}
}
else {
for(i = 0; i < nbSupply; i++) {
for(j = 0; j < nbDemand; j++) {
model.add(y[i][j] == IloPiecewiseLinear(x[i][j],
IloNumArray(env, 2, 200.0, 400.0),
IloNumArray(env, 3, 120.0, 80.0, 50.0),
0.0, 0.0));
}
}
}
IloExpr obj(env);
for(i = 0; i < nbSupply; i++) {
obj += IloSum(y[i]);
}
model.add(IloMinimize(env, obj));
obj.end();
IloCplex cplex(env);
cplex.extract(model);
cplex.exportModel("transport.lp");
cplex.solve();
env.out() << "Solution status: " << cplex.getStatus() << endl;
env.out() << " - Solution: " << endl;
for(i = 0; i < nbSupply; i++) {
env.out() << " " << i << ": ";
for(j = 0; j < nbDemand; j++) {
env.out() << cplex.getValue(x[i][j]) << "\t";
}
env.out() << endl;
}
env.out() << " Cost = " << cplex.getObjValue() << endl;
}
catch (IloException& e) {
cerr << "ERROR: " << e.getMessage() << endl;
}
catch (...) {
cerr << "Error" << endl;
}
env.end();
return 0;
} // END main
