// To populate by row, we first create the variables, and then use them to
// create the range constraints and objective. The model we create is:
//
// Minimize
// obj: - 0.5 (-3 * xˆ2 - 3 * yˆ2 - 1 * x * y)
// Subject To
// c1: -x + y >= 0
// c2: x + y >= 0
// Bounds
// -1 <= x <= 1
// 0 <= y <= 1
// End
internal static ILPMatrix PopulateByRow(IMPModeler model)
{
ILPMatrix lp = model.AddLPMatrix();
double[] lb = { -1.0, 0.0 };
double[] ub = { 1.0, 1.0 };
INumVar[] x = model.NumVarArray(model.ColumnArray(lp, 2), lb, ub);
double[] lhs = { 0.0, 0.0 };
double[] rhs = { System.Double.MaxValue, System.Double.MaxValue };
double[][] val = { new double[] { -1.0, 1.0 },
new double[] { 1.0, 1.0 } };
int[][] ind = { new int[] { 0, 1 },
new int[] { 0, 1 } };
lp.AddRows(lhs, rhs, ind, val);
INumExpr x00 = model.Prod(-3.0, x[0], x[0]);
INumExpr x11 = model.Prod(-3.0, x[1], x[1]);
INumExpr x01 = model.Prod(-1.0, x[0], x[1]);
INumExpr Q = model.Prod(0.5, model.Sum(x00, x11, x01));
model.Add(model.Minimize(Q));
return(lp);
}
public static Cplex BuildLPModel(IFTMDP Ida)
{
Cplex model = new Cplex();
INumVar[][] v = new INumVar[Ida.TimeHorizon][]; //V(t,x)
for (int t = 0; t < Ida.TimeHorizon; t++)
{
v[t] = model.NumVarArray(Ida.SS.Count, -double.MaxValue, double.MaxValue);
}
IObjective RevenueUB = model.AddMinimize(model.Prod(1, v[0][Ida.SS.IndexOf(Ida.InitialState)]));
//time->State->Active-> Expression
for (int t = 0; t < Ida.TimeHorizon; t++)
{
foreach (IMDPState s in Ida.SS)
{
foreach (IMDPDecision a in Ida.GenDecisionSpace(s))
{
INumExpr expr = v[t][Ida.SS.IndexOf(s)];
if (t < Ida.TimeHorizon - 1)
{
foreach (IMDPState k in Ida.GenStateSpace(s, a))
{
expr = model.Sum(expr,
model.Prod(-Ida.Prob(t, s, k, a), v[t + 1][Ida.SS.IndexOf(k)]));
}
}
model.AddGe(expr, Ida.Reward(t, s, a));
}
}
}
//model.SetOut(null);
return(model);
}
internal static ILPMatrix PopulateByRow(IMPModeler model)
{
ILPMatrix lp = model.AddLPMatrix();
double[] lb = { 0.0, 0.0, 0.0 };
double[] ub = { 40.0, System.Double.MaxValue, System.Double.MaxValue };
INumVar[] x = model.NumVarArray(model.ColumnArray(lp, 3), lb, ub);
// - x0 + x1 + x2 <= 20
// x0 - 3*x1 + x2 <= 30
double[] lhs = { -System.Double.MaxValue, -System.Double.MaxValue };
double[] rhs = { 20.0, 30.0 };
double[][] val = { new double[] { -1.0, 1.0, 1.0 },
new double[] { 1.0, -3.0, 1.0 } };
int[][] ind = { new int[] { 0, 1, 2 },
new int[] { 0, 1, 2 } };
lp.AddRows(lhs, rhs, ind, val);
// Q = 0.5 ( 33*x0*x0 + 22*x1*x1 + 11*x2*x2 - 12*x0*x1 - 23*x1*x2 )
INumExpr x00 = model.Prod(33.0, model.Square(x[0]));
INumExpr x11 = model.Prod(22.0, model.Square(x[1]));
INumExpr x22 = model.Prod(11.0, model.Square(x[2]));
INumExpr x01 = model.Prod(-12.0, model.Prod(x[0], x[1]));
INumExpr x12 = model.Prod(-23.0, model.Prod(x[1], x[2]));
INumExpr Q = model.Prod(0.5, model.Sum(x00, x11, x22, x01, x12));
// maximize x0 + 2*x1 + 3*x2 + Q
double[] objvals = { 1.0, 2.0, 3.0 };
model.Add(model.Maximize(model.Diff(model.ScalProd(x, objvals), Q)));
return(lp);
}
private void AddCplexLEqual(Cplex model, dc_FGPair fg, INumVar slack)
{
INumExpr fi = fg.f.AddExpression(model);
INumExpr gi = fg.g.Minorize(model);
model.AddLe(fi, model.Sum(gi, slack));
}
protected void AddConstraint(int t, IALPDecision a)//Add a column into RMP model
{
if (constraints[t].ContainsKey(a))
{
return;
}
INumExpr exp1 = RMPModel.NumExpr();
if (t < Data.TimeHorizon - 1)
{
exp1 = RMPModel.Sum(Var2[t], RMPModel.Prod(-1, Var2[t + 1]));
foreach (IALPResource re in Data.RS)
{
if (a.UseResource(re))
{
exp1 = RMPModel.Sum(exp1, Var1[t][Data.RS.IndexOf(re)], RMPModel.Prod(Data.Qti(t, re, a) - 1, Var1[t + 1][Data.RS.IndexOf(re)]));
}
}
}
else
{
exp1 = RMPModel.Sum(exp1, Var2[t]);
foreach (IALPResource re in Data.RS)
{
if (a.UseResource(re))
{
exp1 = RMPModel.Sum(exp1, Var1[t][Data.RS.IndexOf(re)]);
}
}
}
constraints[t].Add(a, RMPModel.AddGe(exp1, Data.Rt(t, a)));
}
private void GenSubModelObj(int t)//Generate the objective expression for the submodel
{
if (t >= m_CurrentTime)
{
INumExpr expr = SubModel.NumExpr();
foreach (IALPResource i in Data.RS)
{
expr = SubModel.Sum(expr,
SubModel.Prod(-DualValue1[t][Data.RS.IndexOf(i)], r[Data.RS.IndexOf(i)]));
if (t < Data.TimeHorizon - 1)
{
expr = SubModel.Sum(expr,
SubModel.Prod(DualValue1[t + 1][Data.RS.IndexOf(i)], r[Data.RS.IndexOf(i)]));
}
}
foreach (IMDPDecision a in Data.DS)
{
double temp = 0;
if (t < Data.TimeHorizon - 1)
{
temp += Data.RS.Sum(i => - DualValue1[t + 1][Data.RS.IndexOf(i)] * Data.Qti(t, i, a));
expr = SubModel.Sum(expr,
SubModel.Prod(temp, h[Data.DS.IndexOf(a)]));//t 还是t-1
}
}
expr = SubModel.Sum(expr, -DualValue2[t]);
subObject[1][t] = SubModel.Sum(subObject[0][t], expr);
SubModel.Delete(expr);
}
}
private void initializeArbitraryBooleanConstraints(Cplex cplex, VariabilityModel vm,
Dictionary <BinaryOption, INumVar> optsToCplex)
{
foreach (string booleanConstraint in vm.BinaryConstraints)
{
string[] cnfParts = booleanConstraint.Split('&');
foreach (string cnfPart in cnfParts)
{
string[] variables = cnfPart.Split('|');
INumExpr[] logicOrConstr = new INumExpr[variables.Length];
for (int i = 0; i < variables.Length; i++)
{
string var = variables[i].Trim();
// In binary domain (1 - x) equals the negation of x
if (var.StartsWith("!") || var.StartsWith("-"))
{
logicOrConstr[i] = cplex.Sum(1, cplex.Negative((optsToCplex[vm.getBinaryOption(var.Substring(1))])));
}
else
{
logicOrConstr[i] = optsToCplex[vm.getBinaryOption(var)];
}
}
// Since we use cnf notation, it is enough to check if the sum of a single clause is
// greater or equal 1
cplex.AddGe(cplex.Sum(logicOrConstr), one);
}
}
}
public void BuildRMP(List <Pairing> initialPathSet)
{
//GetCoverMatrix()
INumExpr obj_expr = RMP.NumExpr();
foreach (Pairing path in initialPathSet)
{
if (path.Route.Count <= 2)
{
continue;
}
ColumnPool.Add(path);
//create obj function
INumVar x = RMP.NumVar(0, 1, NumVarType.Float);
DvarSet.Add(x);
obj_expr = RMP.Sum(obj_expr, RMP.Prod(path.Cost_with_penalty, x));
CoverMatrix.Add(path.CoverAaray);
}
RMP.AddObjective(ObjectiveSense.Minimize, obj_expr);
//s.t
for (int i = 0; i < num_task; i++)
{
INumExpr ct = RMP.NumExpr();
for (int j = 0; j < DvarSet.Count; j++)
{
ct = RMP.Sum(ct,
RMP.Prod(CoverMatrix[j][i], DvarSet[j]));
}
constraints[i] = RMP.AddGe(ct, 1);
}
}
internal static INumVar[] populateByRow(IMPModeler model,
IRange[] row)
{
double[] lb = { 0.0, 0.0, 0.0 };
double[] ub = { 40.0, System.Double.MaxValue, System.Double.MaxValue };
INumVar[] x = model.NumVarArray(3, lb, ub);
// - x0 + x1 + x2 <= 20
// x0 - 3*x1 + x2 <= 30
double[][] val = { new double[] { -1.0, 1.0, 1.0 },
new double[] { 1.0, -3.0, 1.0 } };
row[0] = model.AddLe(model.ScalProd(val[0], x), 20.0);
row[1] = model.AddLe(model.ScalProd(val[1], x), 30.0);
// x0*x0 + x1*x1 + x2*x2 <= 1.0
row[2] = model.AddLe(model.Sum(model.Prod(x[0], x[0]),
model.Prod(x[1], x[1]),
model.Prod(x[2], x[2])), 1.0);
// Q = 0.5 ( 33*x0*x0 + 22*x1*x1 + 11*x2*x2 - 12*x0*x1 - 23*x1*x2 )
INumExpr x00 = model.Prod(33.0, x[0], x[0]);
INumExpr x11 = model.Prod(22.0, x[1], x[1]);
INumExpr x22 = model.Prod(11.0, x[2], x[2]);
INumExpr x01 = model.Prod(-12.0, x[0], x[1]);
INumExpr x12 = model.Prod(-23.0, x[1], x[2]);
INumExpr Q = model.Prod(0.5, model.Sum(x00, x11, x22, x01, x12));
// maximize x0 + 2*x1 + 3*x2 + Q
double[] objvals = { 1.0, 2.0, 3.0 };
model.Add(model.Maximize(model.Diff(model.ScalProd(x, objvals), Q)));
return(x);
}
public override void StepFoward()
{
alpha -= step;
//Delete Agg constraint(s)
foreach (var a in Aggconstraints)
{
RMPModel.Remove(a.Value);
}
List <IALPDecision> list = Aggconstraints.Keys.ToList();
Aggconstraints.Clear();
//Add DisAgg variables and constraint(s)
for (int i = alpha + 1; i <= alpha + step; i++)
{
constraints.Add(i, new Dictionary <IALPDecision, IRange>());
Var1.Add(i, RMPModel.NumVarArray(Data.RS.Count, 0, double.MaxValue));
Var2.Add(i, RMPModel.NumVar(0, double.MaxValue));
V.Add(i, new double[Data.RS.Count]);
Sita.Add(i, 0);
}
for (int t = alpha + 1; t <= alpha + step; t++)
{
if (t < Data.TimeHorizon - 1)
{
foreach (IALPResource re in Data.RS)
{
INumExpr exp2 = RMPModel.Sum(Var1[t][Data.RS.IndexOf(re)], RMPModel.Prod(-1, Var1[t + 1][Data.RS.IndexOf(re)]));
RMPModel.AddGe(exp2, 0);
}
INumExpr exp3 = RMPModel.Sum(Var2[t], RMPModel.Prod(-1, Var2[t + 1]));
RMPModel.AddGe(exp3, 0);
}
}
foreach (IALPResource re in Data.RS)
{
INumExpr exp6 = RMPModel.NumExpr();
exp6 = RMPModel.Sum(AggVar1[Data.RS.IndexOf(re)], RMPModel.Prod(-1, Var1[alpha + 1][Data.RS.IndexOf(re)]));
RMPModel.AddGe(exp6, 0);
}
INumExpr exp4 = RMPModel.NumExpr();
exp4 = RMPModel.Sum(exp4, AggVar2, RMPModel.Prod(-1, Var2[alpha + 1]));
RMPModel.AddGe(exp4, 0);
foreach (IALPDecision de in list)
{
AddConstraint1(de);
}
Decision d = _ds[0] as Decision;
for (int t = alpha + 1; t <= alpha + step; t++)
{
AddConstraint2(t, d);
}
}
private void InitRCGModel()
{
SubModel.ClearModel();
h = SubModel.NumVarArray(Data.DS.Count, 0, double.MaxValue);
r = SubModel.NumVarArray(Data.RS.Count, 0, double.MaxValue);
constraint_sub2 = new IRange[Data.RS.Count];
subObject[0] = new INumExpr[Data.TimeHorizon];
subObject[1] = new INumExpr[Data.TimeHorizon];
#region 生成约束
//第一、四种约束
INumExpr expr1 = SubModel.NumExpr();
foreach (IMDPDecision d in Data.DS)
{
expr1 = SubModel.Sum(expr1, h[Data.DS.IndexOf(d)]);//SubModel.AddGe(h[aff.DS.IndexOf(d)], 0);
}
SubModel.AddEq(expr1, 1);
//第二、三种约束
foreach (IALPResource re in Data.RS)
{
constraint_sub2[Data.RS.IndexOf(re)] = SubModel.AddLe(r[Data.RS.IndexOf(re)], (Data.InitialState as IALPState)[re]);
INumExpr expr2 = SubModel.NumExpr();
foreach (IALPDecision a in Data.DS)
{
if (a.UseResource(re))
{
expr2 = SubModel.Sum(expr2, h[Data.DS.IndexOf(a)]);
}
}
expr2 = SubModel.Sum(expr2, SubModel.Prod(-1, r[Data.RS.IndexOf(re)]));
SubModel.AddLe(expr2, 0);
}
#endregion
#region 初始化目标函数第一部分
//Parallel.For(0, Data.TimeHorizon, t =>
for (int t = 0; t < Data.TimeHorizon; t++)
{
int iteration = t;
Task ta = factory.StartNew(() =>
{
subObject[0][iteration] = SubModel.NumExpr();
foreach (IMDPDecision a in Data.DS)
{
subObject[0][iteration] = SubModel.Sum(subObject[0][iteration],
SubModel.Prod(Data.Rt(iteration, a), h[Data.DS.IndexOf(a)]));
}
}, cts.Token);
tasks.Add(ta);
}
#endregion
Task.WaitAll(tasks.ToArray());
tasks.Clear();
SubModel.SetOut(null);
}
// NOTE: CPLEX does not provide a function to directly get the dual
// multipliers for second order cone constraint.
// Example QCPDual.cs illustrates how the dual multipliers for a
// quadratic constraint can be computed from that constraint's
// slack.
// However, for SOCP we can do something simpler: we can read those
// multipliers directly from the dual slacks for the
// cone head variables. For a second order cone constraint
// x[1] >= |(x[2], ..., x[n])|
// the dual multiplier is the dual slack value for x[1].
/// <summary>
/// Compute dual multipliers for second order cone constraints.
/// Returns a dictionary with a dual multiplier for each second order cone
/// constraint.
/// </summary>
/// <remarks>
/// <c>cplex</c> is the Cplex instance with the optimal solution.
/// <c>vars</c> is a collection with <em>all</em> variables in the model.
/// <c>rngs</c> is a collection with <em>all</em> constraints in the
/// model.
/// <c>dslack</c> is a dictionary in which the function will store the full
/// dual slack, provided the argument is not <c>null</c>.
/// </remarks>
private static IDictionary <IRange, System.Double> Getsocpconstrmultipliers(Cplex cplex, ICollection <INumVar> vars, ICollection <IRange> rngs, IDictionary <INumVar, System.Double> dslack)
{
// Compute full dual slack.
IDictionary <INumVar, System.Double> dense = new SortedDictionary <INumVar, System.Double>(NumVarComparator);
foreach (INumVar v in vars)
{
dense[v] = cplex.GetReducedCost(v);
}
foreach (IRange r in rngs)
{
INumExpr e = r.Expr;
if ((e is IQuadNumExpr) && ((IQuadNumExpr)e).GetQuadEnumerator().MoveNext())
{
// Quadratic constraint: pick up dual slack vector
for (ILinearNumExprEnumerator it = cplex.GetQCDSlack(r).GetLinearEnumerator(); it.MoveNext(); /* nothing */)
{
dense[it.NumVar] = dense[it.NumVar] + it.Value;
}
}
}
// Find the cone head variables and pick up the dual slacks for them.
IDictionary <IRange, System.Double> socppi = new SortedDictionary <IRange, System.Double>(RangeComparator);
foreach (IRange r in rngs)
{
INumExpr e = r.Expr;
if ((e is IQuadNumExpr) && ((IQuadNumExpr)e).GetQuadEnumerator().MoveNext())
{
// Quadratic constraint: pick up dual slack vector
for (IQuadNumExprEnumerator it = ((IQuadNumExpr)e).GetQuadEnumerator(); it.MoveNext(); /* nothing */)
{
if (it.Value < 0)
{
socppi[r] = dense[it.NumVar1];
break;
}
}
}
}
// Fill in the dense slack if the user asked for it.
if (dslack != null)
{
dslack.Clear();
foreach (INumVar v in dense.Keys)
{
dslack[v] = dense[v];
}
}
return(socppi);
}
public CplexVariable(IMilpManager manager, Domain domain, INumExpr var, string name)
{
_milpManager = manager;
Domain = domain;
Var = var;
Name = name;
if (Var is CpxNumVar)
{
// We need to store variable index in order to be able to deserialize the problem later
Index = (CplexIndex) IndexField.GetValue(Var);
}
}
public static void Main(String[] args)
{
try {
cp = new CP();
cost = cp.NumExpr();
List <IIntervalVar> allTasks = new List <IIntervalVar>();
List <IIntervalVar> joeTasks = new List <IIntervalVar>();
List <IIntervalVar> jimTasks = new List <IIntervalVar>();
List <Int32> joeLocations = new List <Int32>();
List <Int32> jimLocations = new List <Int32>();
MakeHouse(allTasks, joeTasks, jimTasks, joeLocations, jimLocations, 0, 0, 120, 100.0);
MakeHouse(allTasks, joeTasks, jimTasks, joeLocations, jimLocations, 1, 0, 212, 100.0);
MakeHouse(allTasks, joeTasks, jimTasks, joeLocations, jimLocations, 2, 151, 304, 100.0);
MakeHouse(allTasks, joeTasks, jimTasks, joeLocations, jimLocations, 3, 59, 181, 200.0);
MakeHouse(allTasks, joeTasks, jimTasks, joeLocations, jimLocations, 4, 243, 425, 100.0);
ITransitionDistance tt = cp.TransitionDistance(5);
for (int i = 0; i < 5; ++i)
{
for (int j = 0; j < 5; ++j)
{
tt.SetValue(i, j, Math.Abs(i - j));
}
}
IIntervalSequenceVar joe = cp.IntervalSequenceVar(joeTasks.ToArray(), joeLocations.ToArray(), "Joe");
IIntervalSequenceVar jim = cp.IntervalSequenceVar(jimTasks.ToArray(), jimLocations.ToArray(), "Jim");
cp.Add(cp.NoOverlap(joe, tt));
cp.Add(cp.NoOverlap(jim, tt));
cp.Add(cp.Minimize(cost));
cp.SetParameter(CP.IntParam.FailLimit, 50000);
/* EXTRACTING THE MODEL AND SOLVING. */
if (cp.Solve())
{
for (int i = 0; i < allTasks.Count; ++i)
{
Console.WriteLine(cp.GetDomain(allTasks[i]));
}
}
else
{
Console.WriteLine("No solution found.");
}
} catch (ILOG.Concert.Exception e) {
Console.WriteLine(" ERROR: " + e);
}
}
/// <summary>建立最初的RMP
/// 依据初始解
/// </summary>
/// <param name="IS"></param>
public void Build_RMP(InitialSolution IS)
{
initialPath_num = IS.PathSet.Count;
trip_num = TripList.Count;
realistic_trip_num = NetWork.num_Physical_trip;
DvarSet = new List <INumVar>();
CoefSet = new List <double>();
A_Matrix = new List <int[]>();
PathSet = new List <Pairing>();
//virtualVarSet = new List<INumVar>();
//for (int virtual_x = 0; virtual_x < realistic_trip_num; virtual_x++) {
// virtualVarSet.Add(masterModel.NumVar(0, 1, NumVarType.Float));
//}
CoefSet = IS.Coefs;
A_Matrix = IS.A_Matrix;
PathSet = IS.PathSet;
foreach (var p in PathSet)
{
ColumnPool.Add(p);
}
int i, j;
Obj = masterModel.AddMinimize();
Constraint = new IRange[realistic_trip_num];
/**按行建模**/
//vars and obj function
for (j = 0; j < initialPath_num; j++)
{
INumVar var = masterModel.NumVar(0, 1, NumVarType.Float);
DvarSet.Add(var);
Obj.Expr = masterModel.Sum(Obj.Expr, masterModel.Prod(CoefSet[j], DvarSet[j]));
}
//constraints
for (i = 0; i < realistic_trip_num; i++)
{
INumExpr expr = masterModel.NumExpr();
for (j = 0; j < initialPath_num; j++)
{
expr = masterModel.Sum(expr,
masterModel.Prod(A_Matrix[j][i], DvarSet[j]));//在从初始解传值给A_Matrix，已经针对网络复制作了处理
}
Constraint[i] = masterModel.AddGe(expr, 1);
}
}
private void InitRCGModel()
{
SubModel.ClearModel();
h = SubModel.NumVarArray(Data.DS.Count, 0, double.MaxValue);
r = SubModel.NumVarArray(Data.RS.Count, 0, double.MaxValue);
constraint_sub2 = new IRange[Data.RS.Count];
subObject[0] = new INumExpr[Data.TimeHorizon];
subObject[1] = new INumExpr[Data.TimeHorizon];
#region 生成约束
//第一、四种约束
INumExpr expr1 = SubModel.NumExpr();
foreach (IMDPDecision d in Data.DS)
{
expr1 = SubModel.Sum(expr1, h[Data.DS.IndexOf(d)]);//SubModel.AddGe(h[aff.DS.IndexOf(d)], 0);
}
SubModel.AddEq(expr1, 1);
//第二、三种约束
foreach (IALPResource re in Data.RS)
{
constraint_sub2[Data.RS.IndexOf(re)] = SubModel.AddLe(r[Data.RS.IndexOf(re)], (Data.InitialState as IALPState)[re]);
INumExpr expr2 = SubModel.NumExpr();
foreach (IALPDecision a in Data.DS)
{
if (a.UseResource(re))
{
expr2 = SubModel.Sum(expr2, h[Data.DS.IndexOf(a)]);
}
}
expr2 = SubModel.Sum(expr2, SubModel.Prod(-1, r[Data.RS.IndexOf(re)]));
SubModel.AddLe(expr2, 0);
}
#endregion
#region 初始化目标函数第一部分
Parallel.For(0, Data.TimeHorizon, t =>
//for (int t = 0; t < Data.TimeHorizon; t++)
{
subObject[0][t] = SubModel.NumExpr();
foreach (IMDPDecision a in Data.DS)
{
subObject[0][t] = SubModel.Sum(subObject[0][t],
SubModel.Prod(Data.Rt(t, a), h[Data.DS.IndexOf(a)]));
}
});
#endregion
SubModel.SetOut(null);
}
public INumExpr AddExpression(Cplex model)
{
if (m_inputs == null || m_inputs.Length == 0)
{
return(LocalExpression(model, null));
}
INumExpr[] input = new INumExpr[m_inputs.Length];
for (int i = 0; i < m_inputs.Length; i++)
{
input[i] = m_inputs[i].AddExpression(model);
}
return(LocalExpression(model, input));
}
public INumExpr Minorize(Cplex model, double delta)
{
if (m_inputs == null || m_inputs.Length == 0)
{
return(model.Prod(delta, model.Diff(AddExpression(model), m_lastValue)));
}
INumExpr[] exps = new INumExpr[m_inputs.Length];
for (int i = 0; i < m_inputs.Length; i++)
{
exps[i] = m_inputs[i].Minorize(model, delta * m_lastGradient[i]);
}
return(model.Sum(exps));
}
protected void InitRMPModel()
{
Var1 = new INumVar[Data.TimeHorizon][];
V = new double[Data.TimeHorizon][];
Var2 = RMPModel.NumVarArray(Data.TimeHorizon, 0, double.MaxValue);
Sita = new double[Data.TimeHorizon];
constraints = new Dictionary <IALPDecision, IRange> [Data.TimeHorizon];
#region //////////////生成变量//////////////
for (int i = 0; i < Data.TimeHorizon; i++)
{
constraints[i] = new Dictionary <IALPDecision, IRange>();
Var1[i] = RMPModel.NumVarArray(Data.RS.Count, 0, double.MaxValue);// new INumVar[aff.DS.Count];
V[i] = new double[Data.RS.Count];
}
#endregion
#region //////////////生成目标//////////////
INumExpr exp5 = RMPModel.NumExpr();
exp5 = RMPModel.Sum(exp5, Var2[0]);
foreach (IALPResource re in Data.RS)
{
exp5 = RMPModel.Sum(exp5, RMPModel.Prod((Data.InitialState as IALPState)[re], Var1[0][Data.RS.IndexOf(re)]));
}
IObjective cost = RMPModel.AddMinimize(exp5);
#endregion
#region //////////////生成基本约束//////////////
for (int t = 0; t < Data.TimeHorizon; t++)
{
if (t < Data.TimeHorizon - 1)
{
foreach (IALPResource re in Data.RS)
{
INumExpr exp2 = RMPModel.NumExpr();
exp2 = RMPModel.Sum(Var1[t][Data.RS.IndexOf(re)], RMPModel.Prod(-1, Var1[t + 1][Data.RS.IndexOf(re)]));
RMPModel.AddGe(exp2, 0);
}
INumExpr exp3 = RMPModel.NumExpr();
exp3 = RMPModel.Sum(exp3, Var2[t], RMPModel.Prod(-1, Var2[t + 1]));
RMPModel.AddGe(exp3, 0);
}
}
#endregion
RMPModel.SetOut(this.SolverTextWriter);
}
private void GenSubModelObj()
{
print("--------{0}生成子问题目标函数开始--------", System.DateTime.Now.ToLongTimeString());
//Parallel.For(CurrentTime, Data.TimeHorizon, t =>
for (int t = 0; t < Data.TimeHorizon; t++)
{
int iteration = t;
Task ta = factory.StartNew(() =>
{
#region 生成目标函数
if (iteration >= m_CurrentTime)
{
INumExpr expr = SubModel.NumExpr();
foreach (IALPResource i in Data.RS)
{
expr = SubModel.Sum(expr,
SubModel.Prod(-DualValue1[iteration][Data.RS.IndexOf(i)], r[Data.RS.IndexOf(i)]));
if (iteration < Data.TimeHorizon - 1)
{
expr = SubModel.Sum(expr,
SubModel.Prod(DualValue1[iteration + 1][Data.RS.IndexOf(i)], r[Data.RS.IndexOf(i)]));
}
}
foreach (IMDPDecision a in Data.DS)
{
double temp = 0;
if (iteration < Data.TimeHorizon - 1)
{
temp += Data.RS.Sum(i => - DualValue1[iteration + 1][Data.RS.IndexOf(i)] * Data.Qti(iteration, i, a));
expr = SubModel.Sum(expr,
SubModel.Prod(temp, h[Data.DS.IndexOf(a)]));//t 还是t-1
}
}
expr = SubModel.Sum(expr, -DualValue2[iteration]);
subObject[1][iteration] = SubModel.Sum(subObject[0][iteration], expr);
SubModel.Delete(expr);
}
#endregion
}, cts.Token);
tasks.Add(ta);
}
;
Task.WaitAll(tasks.ToArray());
tasks.Clear();
print("--------{0}生成子问题目标函数结束--------", System.DateTime.Now.ToLongTimeString());
}
public static void Main(String[] args)
{
int nbHouses = 5;
int deadline = 318;
skill = cp.IntExpr();
List <IIntervalVar> allTasks = new List <IIntervalVar>();
List <IIntervalVar>[] workerTasks = new List <IIntervalVar> [nbWorkers];
for (int w = 0; w < nbWorkers; w++)
{
workerTasks[w] = new List <IIntervalVar>();
}
for (int h = 0; h < nbHouses; h++)
{
MakeHouse(allTasks, workerTasks, h, deadline);
}
for (int w = 0; w < nbWorkers; w++)
{
IIntervalSequenceVar seq = cp.IntervalSequenceVar(workerTasks[w].ToArray(), workerNames[w]);
cp.Add(cp.NoOverlap(seq));
}
cp.Add(cp.Maximize(skill));
/* EXTRACTING THE MODEL AND SOLVING. */
cp.SetParameter(CP.IntParam.FailLimit, 10000);
if (cp.Solve())
{
Console.WriteLine("Solution with objective " + cp.ObjValue + ":");
for (int i = 0; i < allTasks.Count; i++)
{
IIntervalVar var = (IIntervalVar)allTasks[i];
if (cp.IsPresent(allTasks[i]))
{
Console.WriteLine(cp.GetDomain((IIntervalVar)allTasks[i]));
}
}
}
else
{
Console.WriteLine("No solution found. ");
}
}
public void formNewList(INumExpr expr)
{
newDict = new Dictionary<GRBVar, double>();
for (int i = 0; i < expr.expr.Size; i++)
{
GRBVar var = expr.expr.GetVar(i);
double val = expr.expr.GetCoeff(i);
if (newDict.ContainsKey(var))
{
newDict[var] += val;
}
else
{
newDict[var] = val;
}
}
}
protected void AddConstraint1(IALPDecision a)
{
if (Aggconstraints.ContainsKey(a))
{
return;
}
lock (RMPModel)
{
INumExpr exp1 = RMPModel.NumExpr();
exp1 = RMPModel.Sum(AggVar2, RMPModel.Prod(-1, Var2[alpha + 1]));
foreach (IALPResource re in Data.RS)
{
if (a.UseResource(re))
{
exp1 = RMPModel.Sum(exp1,
RMPModel.Prod((alpha + 1) * Data.Qti(alpha, re, a), AggVar1[Data.RS.IndexOf(re)]));
}
}
Aggconstraints.Add(a, RMPModel.AddGe(exp1, (alpha + 1) * Data.Rt(alpha, a)));
}
}
static void Main(string[] args)
{
String filename;
if (args.Length > 0)
{
filename = args[0];
}
else
{
filename = "../../../../examples/data/plant_location.data";
}
DataReader data = new DataReader(filename);
int nbCustomer = data.Next();
int nbLocation = data.Next();
int[][] cost = new int[nbCustomer][];
for (int c = 0; c < nbCustomer; c++)
{
cost[c] = new int[nbLocation];
for (int l = 0; l < nbLocation; l++)
{
cost[c][l] = data.Next();
}
}
int[] demand = new int[nbCustomer];
int totalDemand = 0;
for (int c = 0; c < nbCustomer; c++)
{
demand[c] = data.Next();
totalDemand += demand[c];
}
int[] fixedCost = new int[nbLocation];
for (int l = 0; l < nbLocation; l++)
{
fixedCost[l] = data.Next();
}
int[] capacity = new int[nbLocation];
for (int l = 0; l < nbLocation; l++)
{
capacity[l] = data.Next();
}
CP cp = new CP();
IIntVar[] cust = new IIntVar[nbCustomer];
for (int c = 0; c < nbCustomer; c++)
{
cust[c] = cp.IntVar(0, nbLocation - 1);
}
IIntVar[] open = new IIntVar[nbLocation];
IIntVar[] load = new IIntVar[nbLocation];
for (int l = 0; l < nbLocation; l++)
{
open[l] = cp.IntVar(0, 1);
load[l] = cp.IntVar(0, capacity[l]);
}
for (int l = 0; l < nbLocation; l++)
{
cp.Add(cp.Eq(open[l], cp.Gt(load[l], 0)));
}
cp.Add(cp.Pack(load, cust, demand));
IIntExpr obj = cp.Prod(open, fixedCost);
for (int c = 0; c < nbCustomer; c++)
{
obj = cp.Sum(obj, cp.Element(cost[c], cust[c]));
}
cp.Add(cp.Minimize(obj));
cp.AddKPI(cp.Quot(totalDemand, cp.ScalProd(open, capacity)), "Mean occupancy");
INumExpr[] usage = new INumExpr[nbLocation];
for (int w = 0; w < nbLocation; w++)
{
usage[w] = cp.Sum(cp.Quot(load[w], capacity[w]), cp.Diff(1, open[w]));
}
cp.AddKPI(cp.Min(usage), "Min occupancy");
int[] custValues =
{
19, 0, 11, 8, 29, 9, 29, 28, 17, 15, 7, 9, 18, 15, 1, 17, 25, 18, 17, 27,
22, 1, 26, 3, 22, 2, 20, 27, 2, 16, 1, 16, 12, 28, 19, 2, 20, 14, 13, 27,
3, 9, 18, 0, 13, 19, 27, 14, 12, 1, 15, 14, 17, 0, 7, 12, 11, 0, 25, 16,
22, 13, 16, 8, 18, 27, 19, 23, 26, 13, 11, 11, 19, 22, 28, 26, 23, 3, 18, 23,
26, 14, 29, 18, 9, 7, 12, 27, 8, 20
};
ISolution sol = cp.Solution();
for (int c = 0; c < nbCustomer; c++)
{
sol.SetValue(cust[c], custValues[c]);
}
cp.SetStartingPoint(sol);
cp.SetParameter(CP.DoubleParam.TimeLimit, 10);
cp.SetParameter(CP.IntParam.LogPeriod, 10000);
cp.Solve();
}
public static void MakeHouse(List<IIntervalVar> allTasks,
List<IIntervalVar>[] workerTasks,
int id,
int deadline)
{
/* CREATE THE INTERVAL VARIABLES. */
String name;
IIntervalVar[] tasks = new IIntervalVar[nbTasks];
IIntervalVar[,] taskMatrix = new IIntervalVar[nbTasks, nbWorkers];
for (int i = 0; i < nbTasks; i++)
{
name = "H" + id + "-" + taskNames[i];
tasks[i] = cp.IntervalVar(taskDurations[i], name);
/* ALLOCATING TASKS TO WORKERS. */
List<IIntervalVar> alttasks = new List<IIntervalVar>();
for (int w = 0; w < nbWorkers; w++)
{
if (HasSkill(w, i))
{
name = "H" + id + "-" + taskNames[i] + "-" + workerNames[w];
IIntervalVar wtask = cp.IntervalVar(taskDurations[i], name);
wtask.SetOptional();
alttasks.Add(wtask);
taskMatrix[i, w] = wtask;
workerTasks[w].Add(wtask);
allTasks.Add(wtask);
/* DEFINING MAXIMIZATION OBJECTIVE. */
skill = cp.Sum(skill, cp.Prod(SkillLevel(w, i), cp.PresenceOf(wtask)));
}
}
cp.Add(cp.Alternative(tasks[i], alttasks.ToArray()));
}
/* ADDING PRECEDENCE CONSTRAINTS. */
tasks[moving].EndMax = deadline;
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[carpentry]));
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[plumbing]));
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[ceiling]));
cp.Add(cp.EndBeforeStart(tasks[carpentry], tasks[roofing]));
cp.Add(cp.EndBeforeStart(tasks[ceiling], tasks[painting]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[windows]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[facade]));
cp.Add(cp.EndBeforeStart(tasks[plumbing], tasks[facade]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[garden]));
cp.Add(cp.EndBeforeStart(tasks[plumbing], tasks[garden]));
cp.Add(cp.EndBeforeStart(tasks[windows], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[facade], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[garden], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[painting], tasks[moving]));
/* ADDING SAME-WORKER CONSTRAINTS. */
cp.Add(cp.Add(cp.Equiv(cp.PresenceOf(taskMatrix[masonry, joe]),
cp.PresenceOf(taskMatrix[carpentry, joe]))));
cp.Add(cp.Add(cp.Equiv(cp.PresenceOf(taskMatrix[roofing, jack]),
cp.PresenceOf(taskMatrix[facade, jack]))));
cp.Add(cp.Add(cp.Equiv(cp.PresenceOf(taskMatrix[carpentry, joe]),
cp.PresenceOf(taskMatrix[roofing, joe]))));
cp.Add(cp.Add(cp.Equiv(cp.PresenceOf(taskMatrix[garden, jim]),
cp.PresenceOf(taskMatrix[moving, jim]))));
}
public INumExpr Prod(double coef, INumVar var)
{
INumExpr result = new INumExpr();
result.expr += coef * var.var;
return result;
}
public static void MakeHouse(
List<IIntervalVar> allTasks,
List<IIntervalVar> joeTasks,
List<IIntervalVar> jimTasks,
List<Int32> joeLocations,
List<Int32> jimLocations,
int loc,
int rd,
int dd,
double weight)
{
/* CREATE THE TIME-INTERVALS. */
String name = "H" + loc;
IIntervalVar[] tasks = new IIntervalVar[nbTasks];
for (int i = 0; i < nbTasks; i++ ) {
name = "H" + loc + "-" + taskNames[i];
tasks[i] = cp.IntervalVar(taskDurations[i], name);
allTasks.Add(tasks[i]);
}
/* SPAN CONSTRAINT */
IIntervalVar house = cp.IntervalVar(name);
cp.Add(cp.Span(house, tasks));
/* ADDING TEMPORAL CONSTRAINTS. */
house.StartMin = rd;
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[carpentry]));
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[plumbing]));
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[ceiling]));
cp.Add(cp.EndBeforeStart(tasks[carpentry], tasks[roofing]));
cp.Add(cp.EndBeforeStart(tasks[ceiling], tasks[painting]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[windows]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[facade]));
cp.Add(cp.EndBeforeStart(tasks[plumbing], tasks[facade]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[garden]));
cp.Add(cp.EndBeforeStart(tasks[plumbing], tasks[garden]));
cp.Add(cp.EndBeforeStart(tasks[windows], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[facade], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[garden], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[painting], tasks[moving]));
/* ALLOCATING TASKS TO WORKERS */
joeTasks.Add(tasks[masonry]);
joeLocations.Add(loc);
joeTasks.Add(tasks[carpentry]);
joeLocations.Add(loc);
jimTasks.Add(tasks[plumbing]);
jimLocations.Add(loc);
jimTasks.Add(tasks[ceiling]);
jimLocations.Add(loc);
joeTasks.Add(tasks[roofing]);
joeLocations.Add(loc);
jimTasks.Add(tasks[painting]);
jimLocations.Add(loc);
jimTasks.Add(tasks[windows]);
jimLocations.Add(loc);
joeTasks.Add(tasks[facade]);
joeLocations.Add(loc);
joeTasks.Add(tasks[garden]);
joeLocations.Add(loc);
jimTasks.Add(tasks[moving]);
jimLocations.Add(loc);
/* DEFINING MINIMIZATION OBJECTIVE */
cost = cp.Sum(cost, tardinessCost(house, dd, weight));
cost = cp.Sum(cost, cp.LengthOf(house));
}
public IRange AddLe(INumExpr expr, double rhs, string name)
{
Range result = new Range(_model, System.Double.MinValue, expr, rhs, name);
return result;
}
public IConstraint AddEq(INumExpr lhs, INumVar var, string name)
{
Constraint result = new Constraint();
result.constr = _model.AddConstr(lhs.expr, GRB.EQUAL, var.var, name);
return result;
}
public IRange AddEq(INumExpr expr, double rhs, string name)
{
Range result = new Range(_model, rhs, expr, rhs, name);
return result;
}
public IObjective(GRBModel model, INumExpr expr, int sense)
: base(expr.expr)
{
this.model = model;
this.sense = sense;
}
public IObjective(GRBModel model, INumExpr expr)
: base(expr.expr)
{
this.model = model;
this.sense = GRB.MINIMIZE; // default
}
/* Test KKT conditions on the solution.
* The function returns true if the tested KKT conditions are satisfied
* and false otherwise.
*/
private static bool Checkkkt(Cplex cplex,
IObjective obj,
ICollection <INumVar> vars,
ICollection <IRange> rngs,
IDictionary <INumVar, IRange> cone,
double tol)
{
System.IO.TextWriter error = cplex.Output();
System.IO.TextWriter output = cplex.Output();
IDictionary <INumVar, System.Double> dslack = new SortedDictionary <INumVar, System.Double>(NumVarComparator);
IDictionary <INumVar, System.Double> x = new SortedDictionary <INumVar, System.Double>(NumVarComparator);
IDictionary <IRange, System.Double> pi = new SortedDictionary <IRange, System.Double>(RangeComparator);
IDictionary <IRange, System.Double> slack = new SortedDictionary <IRange, System.Double>(RangeComparator);
// Read primal and dual solution information.
foreach (INumVar v in vars)
{
x[v] = cplex.GetValue(v);
}
pi = Getsocpconstrmultipliers(cplex, vars, rngs, dslack);
foreach (IRange r in rngs)
{
slack[r] = cplex.GetSlack(r);
INumExpr e = r.Expr;
if (!(e is IQuadNumExpr) || !((IQuadNumExpr)e).GetQuadEnumerator().MoveNext())
{
// Linear constraint: get the dual value
pi[r] = cplex.GetDual(r);
}
}
// Print out the data we just fetched.
output.Write("x = [");
foreach (INumVar v in vars)
{
output.Write(" {0,7:0.000}", x[v]);
}
output.WriteLine(" ]");
output.Write("dslack = [");
foreach (INumVar v in vars)
{
output.Write(" {0,7:0.000}", dslack[v]);
}
output.WriteLine(" ]");
output.Write("pi = [");
foreach (IRange r in rngs)
{
output.Write(" {0,7:0.000}", pi[r]);
}
output.WriteLine(" ]");
output.Write("slack = [");
foreach (IRange r in rngs)
{
output.Write(" {0,7:0.000}", slack[r]);
}
output.WriteLine(" ]");
// Test primal feasibility.
// This example illustrates the use of dual vectors returned by CPLEX
// to verify dual feasibility, so we do not test primal feasibility
// here.
// Test dual feasibility.
// We must have
// - for all <= constraints the respective pi value is non-negative,
// - for all >= constraints the respective pi value is non-positive,
// - the dslack value for all non-cone variables must be non-negative.
// Note that we do not support ranged constraints here.
foreach (INumVar v in vars)
{
if (cone[v] == NOT_IN_CONE && dslack[v] < -tol)
{
error.WriteLine("Dual multiplier for " + v + " is not feasible: " + dslack[v]);
return(false);
}
}
foreach (IRange r in rngs)
{
if (System.Math.Abs(r.LB - r.UB) <= tol)
{
// Nothing to check for equality constraints.
}
else if (r.LB > -System.Double.MaxValue && pi[r] > tol)
{
error.WriteLine("Dual multiplier " + pi[r] + " for >= constraint");
error.WriteLine(" " + r);
error.WriteLine("not feasible.");
return(false);
}
else if (r.UB < System.Double.MaxValue && pi[r] < -tol)
{
error.WriteLine("Dual multiplier " + pi[r] + " for <= constraint");
error.WriteLine(" " + r);
error.WriteLine("not feasible.");
return(false);
}
}
// Test complementary slackness.
// For each constraint either the constraint must have zero slack or
// the dual multiplier for the constraint must be 0. We must also
// consider the special case in which a variable is not explicitly
// contained in a second order cone constraint.
foreach (INumVar v in vars)
{
if (cone[v] == NOT_IN_CONE)
{
if (System.Math.Abs(x[v]) > tol && dslack[v] > tol)
{
error.WriteLine("Invalid complementary slackness for " + v + ":");
error.WriteLine(" " + x[v] + " and " + dslack[v]);
return(false);
}
}
}
foreach (IRange r in rngs)
{
if (System.Math.Abs(slack[r]) > tol && System.Math.Abs(pi[r]) > tol)
{
error.WriteLine("Invalid complementary slackness for");
error.WriteLine(" " + r);
error.WriteLine(" " + slack[r] + " and " + pi[r]);
return(false);
}
}
// Test stationarity.
// We must have
// c - g[i]'(X)*pi[i] = 0
// where c is the objective function, g[i] is the i-th constraint of the
// problem, g[i]'(x) is the derivate of g[i] with respect to x and X is the
// optimal solution.
// We need to distinguish the following cases:
// - linear constraints g(x) = ax - b. The derivative of such a
// constraint is g'(x) = a.
// - second order constraints g(x[1],...,x[n]) = -x[1] + |(x[2],...,x[n])|
// the derivative of such a constraint is
// g'(x) = (-1, x[2]/|(x[2],...,x[n])|, ..., x[n]/|(x[2],...,x[n])|
// (here |.| denotes the Euclidean norm).
// - bound constraints g(x) = -x for variables that are not explicitly
// contained in any second order cone constraint. The derivative for
// such a constraint is g'(x) = -1.
// Note that it may happen that the derivative of a second order cone
// constraint is not defined at the optimal solution X (this happens if
// X=0). In this case we just skip the stationarity test.
IDictionary <INumVar, System.Double> sum = new SortedDictionary <INumVar, System.Double>(NumVarComparator);
foreach (INumVar v in vars)
{
sum[v] = 0.0;
}
for (ILinearNumExprEnumerator it = ((ILinearNumExpr)cplex.GetObjective().Expr).GetLinearEnumerator(); it.MoveNext(); /* nothing */)
{
sum[it.NumVar] = it.Value;
}
foreach (INumVar v in vars)
{
if (cone[v] == NOT_IN_CONE)
{
sum[v] = sum[v] - dslack[v];
}
}
foreach (IRange r in rngs)
{
INumExpr e = r.Expr;
if ((e is IQuadNumExpr) && ((IQuadNumExpr)e).GetQuadEnumerator().MoveNext())
{
double norm = 0.0;
for (IQuadNumExprEnumerator q = ((IQuadNumExpr)e).GetQuadEnumerator(); q.MoveNext(); /* nothing */)
{
if (q.Value > 0)
{
norm += x[q.NumVar1] * x[q.NumVar1];
}
}
norm = System.Math.Sqrt(norm);
if (System.Math.Abs(norm) <= tol)
{
cplex.Warning().WriteLine("Cannot check stationarity at non-differentiable point");
return(true);
}
for (IQuadNumExprEnumerator q = ((IQuadNumExpr)e).GetQuadEnumerator(); q.MoveNext(); /* nothing */)
{
INumVar v = q.NumVar1;
if (q.Value < 0)
{
sum[v] = sum[v] - pi[r];
}
else if (q.Value > 0)
{
sum[v] = sum[v] + pi[r] * x[v] / norm;
}
}
}
else if (e is ILinearNumExpr)
{
for (ILinearNumExprEnumerator it = ((ILinearNumExpr)e).GetLinearEnumerator(); it.MoveNext(); /* nothing */)
{
INumVar v = it.NumVar;
sum[v] = sum[v] - pi[r] * it.Value;
}
}
}
// Now test that all elements in sum[] are 0.
foreach (INumVar v in vars)
{
if (System.Math.Abs(sum[v]) > tol)
{
error.WriteLine("Invalid stationarity " + sum[v] + " for " + v);
return(false);
}
}
return(true);
}
public IConstraint AddLe(INumVar var, INumExpr expr)
{
Constraint result = new Constraint();
result.constr = _model.AddConstr(var.var, GRB.LESS_EQUAL, expr.expr, null);
return result;
}
public INumExpr ScalProd(double[] coefs, INumVar[] vars)
{
INumExpr result = new INumExpr();
for (int i = 0; i < vars.Length; i++)
{
result.expr += coefs[i] * vars[i].var;
}
return result;
}
public static Cplex Build_CLP1_Model(IALPFTMDP aff)
{
Cplex model = new Cplex();
INumVar[][] Var1 = new INumVar[aff.TimeHorizon][];
INumVar[] Var2 = model.NumVarArray(aff.TimeHorizon, 0, double.MaxValue);
#region //////////////生成变量//////////////
for (int i = 0; i < aff.TimeHorizon; i++)
{
Var1[i] = model.NumVarArray(aff.RS.Count, 0, double.MaxValue);// new INumVar[aff.DS.Count];
}
#endregion
#region //////////////生成约束//////////////
for (int t = 0; t < aff.TimeHorizon; t++)
{
foreach (IALPDecision a in aff.DS)
{
INumExpr exp1 = model.NumExpr();
if (t < aff.TimeHorizon - 1)
{
exp1 = model.Sum(Var2[t], model.Prod(-1, Var2[t + 1]));
foreach (IALPResource re in aff.RS)
{
if (a.UseResource(re))
{
exp1 = model.Sum(exp1, Var1[t][aff.RS.IndexOf(re)], model.Prod(aff.Qti(t, re, a) - 1, Var1[t + 1][aff.RS.IndexOf(re)]));
}
}
}
else
{
exp1 = model.Sum(exp1, Var2[t]);
foreach (IALPResource re in aff.RS)
{
if (a.UseResource(re))
{
exp1 = model.Sum(exp1, Var1[t][aff.RS.IndexOf(re)]);
}
}
}
model.AddGe(exp1, aff.Rt(t, a));
}
if (t < aff.TimeHorizon - 1)
{
foreach (IALPResource re in aff.RS)
{
INumExpr exp2 = model.NumExpr();
exp2 = model.Sum(Var1[t][aff.RS.IndexOf(re)], model.Prod(-1, Var1[t + 1][aff.RS.IndexOf(re)]));
model.AddGe(exp2, 0);
}
INumExpr exp3 = model.NumExpr();
exp3 = model.Sum(exp3, Var2[t], model.Prod(-1, Var2[t + 1]));
model.AddGe(exp3, 0);
}
}
#endregion
#region //////////////生成目标//////////////
INumExpr exp5 = model.NumExpr();
exp5 = model.Sum(exp5, Var2[0]);
foreach (IALPResource re in aff.RS)
{
exp5 = model.Sum(exp5, model.Prod((aff.InitialState as IALPState)[re], Var1[0][aff.RS.IndexOf(re)]));
}
IObjective cost = model.AddMinimize(exp5);
#endregion
return(model);
}
public static void Main(String[] args)
{
int nbHouses = 5;
int deadline = 318;
skill = cp.IntExpr();
List<IIntervalVar> allTasks = new List<IIntervalVar>();
List<IIntervalVar>[] workerTasks = new List<IIntervalVar>[nbWorkers];
for (int w = 0; w < nbWorkers; w++)
{
workerTasks[w] = new List<IIntervalVar>();
}
for (int h = 0; h < nbHouses; h++)
{
MakeHouse(allTasks, workerTasks, h, deadline);
}
for (int w = 0; w < nbWorkers; w++)
{
IIntervalSequenceVar seq = cp.IntervalSequenceVar(workerTasks[w].ToArray(), workerNames[w]);
cp.Add(cp.NoOverlap(seq));
}
cp.Add(cp.Maximize(skill));
/* EXTRACTING THE MODEL AND SOLVING. */
cp.SetParameter(CP.IntParam.FailLimit, 10000);
if (cp.Solve())
{
Console.WriteLine("Solution with objective " + cp.ObjValue + ":");
for (int i = 0; i < allTasks.Count; i++)
{
IIntervalVar var = (IIntervalVar)allTasks[i];
if (cp.IsPresent(allTasks[i]))
Console.WriteLine(cp.GetDomain((IIntervalVar)allTasks[i]));
}
}
else
{
Console.WriteLine("No solution found. ");
}
}
public void RangeSetup(GRBModel model, double lb, INumExpr expr, double ub, string name)
{
this.model = model;
this.LB = lb;
this.UB = ub;
this._name = name;
if (expr == null)
{
_expr = new INumExpr();
}
else
{
_expr = expr;
}
this.constr = null;
if (lb > -System.Double.MaxValue && ub < System.Double.MaxValue)
{
// "lb < expr < ub" --> " expr - newvar = lb, 0 < newvar < ub - lb"
GRBVar var = model.AddVar(0, ub - lb, 0, GRB.CONTINUOUS, null);
GRBLinExpr modExpr = Expr.expr - var;
this.constr = model.AddConstr(modExpr, GRB.EQUAL, lb, name);
}
else if (lb > -System.Double.MaxValue)
{
this.constr = model.AddConstr(Expr.expr, GRB.GREATER_EQUAL, lb, name);
}
else
{
this.constr = model.AddConstr(Expr.expr, GRB.LESS_EQUAL, ub, name);
}
}
public Range(GRBModel model, double lb, INumExpr expr, double ub)
{
RangeSetup(model, lb, expr, ub, null);
}
public Range(GRBModel model, double lb, INumExpr expr, double ub, string name)
{
RangeSetup(model, lb, expr, ub, name);
}
public IObjective Maximize(INumExpr expr)
{
return AddMaximize(expr);
}
public INumExpr Sum(INumVar var, params INumExpr[] les)
{
INumExpr result = new INumExpr();
result.expr = var.var + Sum(les).expr;
return result;
}
public static void MakeHouse(List <IIntervalVar> allTasks,
List <IIntervalVar>[] workerTasks,
int id,
int deadline)
{
/* CREATE THE INTERVAL VARIABLES. */
String name;
IIntervalVar[] tasks = new IIntervalVar[nbTasks];
IIntervalVar[,] taskMatrix = new IIntervalVar[nbTasks, nbWorkers];
for (int i = 0; i < nbTasks; i++)
{
name = "H" + id + "-" + taskNames[i];
tasks[i] = cp.IntervalVar(taskDurations[i], name);
/* ALLOCATING TASKS TO WORKERS. */
List <IIntervalVar> alttasks = new List <IIntervalVar>();
for (int w = 0; w < nbWorkers; w++)
{
if (HasSkill(w, i))
{
name = "H" + id + "-" + taskNames[i] + "-" + workerNames[w];
IIntervalVar wtask = cp.IntervalVar(taskDurations[i], name);
wtask.SetOptional();
alttasks.Add(wtask);
taskMatrix[i, w] = wtask;
workerTasks[w].Add(wtask);
allTasks.Add(wtask);
/* DEFINING MAXIMIZATION OBJECTIVE. */
skill = cp.Sum(skill, cp.Prod(SkillLevel(w, i), cp.PresenceOf(wtask)));
}
}
cp.Add(cp.Alternative(tasks[i], alttasks.ToArray()));
}
/* ADDING PRECEDENCE CONSTRAINTS. */
tasks[moving].EndMax = deadline;
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[carpentry]));
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[plumbing]));
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[ceiling]));
cp.Add(cp.EndBeforeStart(tasks[carpentry], tasks[roofing]));
cp.Add(cp.EndBeforeStart(tasks[ceiling], tasks[painting]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[windows]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[facade]));
cp.Add(cp.EndBeforeStart(tasks[plumbing], tasks[facade]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[garden]));
cp.Add(cp.EndBeforeStart(tasks[plumbing], tasks[garden]));
cp.Add(cp.EndBeforeStart(tasks[windows], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[facade], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[garden], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[painting], tasks[moving]));
/* ADDING SAME-WORKER CONSTRAINTS. */
cp.Add(cp.Add(cp.Equiv(cp.PresenceOf(taskMatrix[masonry, joe]),
cp.PresenceOf(taskMatrix[carpentry, joe]))));
cp.Add(cp.Add(cp.Equiv(cp.PresenceOf(taskMatrix[roofing, jack]),
cp.PresenceOf(taskMatrix[facade, jack]))));
cp.Add(cp.Add(cp.Equiv(cp.PresenceOf(taskMatrix[carpentry, joe]),
cp.PresenceOf(taskMatrix[roofing, joe]))));
cp.Add(cp.Add(cp.Equiv(cp.PresenceOf(taskMatrix[garden, jim]),
cp.PresenceOf(taskMatrix[moving, jim]))));
}
public INumExpr Sum(params INumExpr[] les)
{
INumExpr result = new INumExpr();
for (int i = 0; i < les.Length; i++)
{
result.expr += les[i].expr;
}
return result;
}
public static void Main(String[] args)
{
String filename = "../../../../examples/data/learningeffect_default.data";
int nbJobs, nbMachines;
if (args.Length > 0)
{
filename = args[0];
}
CP cp = new CP();
DataReader data = new DataReader(filename);
nbJobs = data.Next();
nbMachines = data.Next();
IIntExpr[] ends = new IIntExpr[nbJobs];
IIntervalVar[][] machines = new IIntervalVar[nbMachines][];
int[][] sizes = new int[nbMachines][];
for (int j = 0; j < nbMachines; j++)
{
machines[j] = new IIntervalVar[nbJobs];
sizes[j] = new int[nbJobs];
}
for (int i = 0; i < nbJobs; i++)
{
IIntervalVar prec = cp.IntervalVar();
for (int j = 0; j < nbMachines; j++)
{
int m, d;
m = data.Next();
d = data.Next();
IIntervalVar ti = cp.IntervalVar(0, d);
machines[m][i] = ti;
sizes[m][i] = d;
if (j > 0)
{
cp.Add(cp.EndBeforeStart(prec, ti));
}
prec = ti;
}
ends[i] = cp.EndOf(prec);
}
for (int j = 0; j < nbMachines; j++)
{
double alpha = data.Next() / ((double)100);
IIntervalVar[] chain = new IIntervalVar[nbJobs];
IIntervalVar prec = cp.IntervalVar();
IIntExpr[] indices = new IIntExpr[nbJobs];
for (int i = 0; i < nbJobs; i++)
{
IIntervalVar syncti = cp.IntervalVar();
if (i > 0)
{
cp.Add(cp.EndBeforeStart(prec, syncti));
}
prec = syncti;
chain[i] = syncti;
IIntExpr index = cp.IntVar(0, nbJobs - 1);
indices[i] = index;
// Learning effect captured by the decreasing function
// of the position (0 <= alpha <= 1).
// At first position, in the sequence index = 0; there is no
// learning effect and duration of the task is its nominal duration
INumExpr floatDur = cp.Prod(sizes[j][i], cp.Power(alpha, index));
cp.Add(cp.Le(
cp.Abs(cp.Diff(floatDur, cp.SizeOf(machines[j][i]))),
0.5)
);
}
cp.Add(cp.Isomorphism(chain, machines[j], indices, nbJobs));
// The no-overlap is a redundant constraint in this quite
// simple model - it is used only to provide stronger inference.
cp.Add(cp.NoOverlap(machines[j]));
}
IObjective objective = cp.Minimize(cp.Max(ends));
cp.Add(objective);
cp.SetParameter(CP.IntParam.LogPeriod, 10000);
Console.WriteLine("Instance \t: " + filename);
if (cp.Solve())
{
Console.WriteLine("Makespan \t: " + cp.ObjValue);
}
else
{
Console.WriteLine("No solution found.");
}
}
public INumExpr Sum(INumVar[] vars)
{
INumExpr result = new INumExpr();
for (int i = 0; i < vars.Length; i++)
{
result.expr += vars[i].var;
}
return result;
}
private void initializeExclusionConstraint(Cplex cplex, BinaryOption currentBinOpt, INumVar current,
List <ConfigurationOption> notAllowed, INumExpr trigger)
{
INumVar[] excluded = populateArray(current, notAllowed);
// If there is some kind of exclusiion then the sum of the group has to be one if the
// trigger(either the parent for alternative groups or the current option for cross tree exclusions)
// is selected
cplex.Add(cplex.IfThen(
cplex.Eq(one, trigger),
cplex.Eq(one, cplex.Sum(excluded))
));
}
public INumExpr Sum(INumExpr expr, INumVar var)
{
INumExpr result = new INumExpr();
result.expr = expr.expr + var.var;
return result;
}
public List <BinaryOption> GenerateConfigurationFromBucket(VariabilityModel vm, int numberSelectedFeatures, Dictionary <List <BinaryOption>, int> featureWeight, Configuration lastSampledConfiguration)
{
Cplex plex;
List <BinaryOption> solution = new List <BinaryOption>();
if (!cplexCache.ContainsKey(numberSelectedFeatures))
{
plex = initCplex(vm);
countConstraint(plex, vm.BinaryOptions, numberSelectedFeatures);
// Set intensity to store only litte information to generate few configurations fast
plex.SetParam(Cplex.Param.MIP.Pool.Intensity, 1);
plex.SetParam(Cplex.Param.MIP.Pool.Capacity, numberSelectedFeatures < 31 ? (int)Math.Pow(2, numberSelectedFeatures) : 2100000000);
// Set replacement to FIFO
plex.SetParam(Cplex.Param.MIP.Pool.Replace, 1);
cplexCache[numberSelectedFeatures] = plex;
}
else
{
plex = cplexCache[numberSelectedFeatures];
if (lastSampledConfiguration != null)
{
IConstraint[] blacklistConf = new IConstraint[GlobalState.varModel.BinaryOptions.Count];
int i = 0;
foreach (BinaryOption option in GlobalState.varModel.BinaryOptions)
{
if (lastSampledConfiguration.BinaryOptions.ContainsKey(option) && lastSampledConfiguration.BinaryOptions[option] == BinaryOption.BinaryValue.Selected)
{
blacklistConf[i] = plex.Eq(0, binOptsToCplexVars[option]);
}
else
{
blacklistConf[i] = plex.Eq(1, binOptsToCplexVars[option]);
}
i++;
}
plex.Add(plex.Or(blacklistConf));
}
if (objCache.ContainsKey(numberSelectedFeatures))
{
plex.Remove(objCache[numberSelectedFeatures]);
}
}
// Solution pool will take care of the last sampled configuration and try to generate new configurations
if (featureWeight != null)
{
List <List <BinaryOption> > features = featureWeight.Keys.ToList();
double[] weights = new double[features.Count];
INumExpr linearSum = null;
for (int i = 0; i < features.Count; i++)
{
List <BinaryOption> feature = features.ElementAt(i);
INumExpr previousMul = null;
weights[i] = featureWeight[feature];
foreach (BinaryOption option in feature)
{
if (previousMul == null)
{
previousMul = binOptsToCplexVars[option];
}
else
{
previousMul = plex.Prod(previousMul, binOptsToCplexVars[option]);
}
}
previousMul = plex.Prod(featureWeight[feature], previousMul);
if (linearSum == null)
{
linearSum = previousMul;
}
else
{
linearSum = plex.Sum(previousMul, linearSum);
}
}
IObjective obj = plex.Objective(ObjectiveSense.Minimize, linearSum);
plex.Add(obj);
objCache[numberSelectedFeatures] = obj;
}
if (plex.Solve())
{
foreach (BinaryOption binOpt in vm.BinaryOptions)
{
int nSolns = plex.GetSolnPoolNsolns();
if (plex.GetValue(binOptsToCplexVars[binOpt], nSolns - 1) > EPSILON_THRESHOLD)
{
solution.Add(binOpt);
}
}
}
return(solution);
}
public INumExpr Diff(double val, INumExpr expr)
{
INumExpr result = new INumExpr();
result.expr = val - expr.expr;
return result;
}
public IRange AddGe(INumExpr expr, double lhs, string name)
{
Range result = new Range(_model, lhs, expr, System.Double.MaxValue, name);
return result;
}
public static void Main(String[] args)
{
try {
cp = new CP();
cost = cp.NumExpr();
List<IIntervalVar> allTasks = new List<IIntervalVar>();
List<IIntervalVar> joeTasks = new List<IIntervalVar>();
List<IIntervalVar> jimTasks = new List<IIntervalVar>();
List<Int32> joeLocations = new List<Int32>();
List<Int32> jimLocations = new List<Int32>();
MakeHouse( allTasks, joeTasks, jimTasks, joeLocations, jimLocations, 0, 0, 120, 100.0);
MakeHouse( allTasks, joeTasks, jimTasks, joeLocations, jimLocations, 1, 0, 212, 100.0);
MakeHouse( allTasks, joeTasks, jimTasks, joeLocations, jimLocations, 2, 151, 304, 100.0);
MakeHouse( allTasks, joeTasks, jimTasks, joeLocations, jimLocations, 3, 59, 181, 200.0);
MakeHouse( allTasks, joeTasks, jimTasks, joeLocations, jimLocations, 4, 243, 425, 100.0);
ITransitionDistance tt = cp.TransitionDistance(5);
for (int i = 0; i < 5; ++i)
for (int j = 0; j < 5; ++j)
tt.SetValue(i, j, Math.Abs(i - j));
IIntervalSequenceVar joe = cp.IntervalSequenceVar(joeTasks.ToArray(), joeLocations.ToArray(), "Joe");
IIntervalSequenceVar jim = cp.IntervalSequenceVar(jimTasks.ToArray(), jimLocations.ToArray(), "Jim");
cp.Add(cp.NoOverlap(joe, tt));
cp.Add(cp.NoOverlap(jim, tt));
cp.Add(cp.Minimize(cost));
cp.SetParameter(CP.IntParam.FailLimit, 50000);
/* EXTRACTING THE MODEL AND SOLVING. */
if (cp.Solve()) {
for (int i = 0; i < allTasks.Count; ++i)
Console.WriteLine(cp.GetDomain(allTasks[i]));
} else {
Console.WriteLine("No solution found.");
}
} catch (ILOG.Concert.Exception e) {
Console.WriteLine(" ERROR: " + e);
}
}
static void Main(string[] args)
{
try {
string filename = "../../../../examples/data/etsp.dat";
if (args.Length > 0)
{
filename = args[0];
}
Data data = new Data(filename);
Cplex cplex = new Cplex();
// Create start variables
INumVar[][] s = new INumVar[data.nJobs][];
for (int j = 0; j < data.nJobs; j++)
{
s[j] = cplex.NumVarArray(data.nResources, 0.0, Horizon);
}
// State precedence constraints
for (int j = 0; j < data.nJobs; j++)
{
for (int i = 1; i < data.nResources; i++)
{
cplex.AddGe(s[j][i], cplex.Sum(s[j][i - 1], data.duration[j][i - 1]));
}
}
// State disjunctive constraints for each resource
for (int i = 0; i < data.nResources; i++)
{
int end = data.nJobs - 1;
for (int j = 0; j < end; j++)
{
int a = data.activityOnResource[i][j];
for (int k = j + 1; k < data.nJobs; k++)
{
int b = data.activityOnResource[i][k];
cplex.Add(cplex.Or(
cplex.Ge(s[j][a], cplex.Sum(s[k][b], data.duration[k][b])),
cplex.Ge(s[k][b], cplex.Sum(s[j][a], data.duration[j][a]))
));
}
}
}
// The cost is the sum of earliness or tardiness costs of each job
int last = data.nResources - 1;
INumExpr costSum = cplex.NumExpr();
for (int j = 0; j < data.nJobs; j++)
{
double[] points = { data.dueDate[j] };
double[] slopes = { -data.earlinessCost[j],
data.tardinessCost[j] };
costSum = cplex.Sum(costSum,
cplex.PiecewiseLinear(
cplex.Sum(s[j][last], data.duration[j][last]),
points, slopes, data.dueDate[j], 0)
);
}
cplex.AddMinimize(costSum);
cplex.SetParam(Cplex.Param.Emphasis.MIP, 4);
if (cplex.Solve())
{
System.Console.WriteLine("Solution status = " + cplex.GetStatus());
System.Console.WriteLine(" Optimal Value = " + cplex.ObjValue);
}
cplex.End();
}
catch (ILOG.Concert.Exception e) {
System.Console.WriteLine("Concert exception caught: " + e);
}
catch (InputDataReader.InputDataReaderException ex) {
System.Console.WriteLine("Data Error: " + ex);
}
catch (System.IO.IOException ex) {
System.Console.WriteLine("IO Error: " + ex);
}
}
public IRange AddRange(double lb, INumExpr expr, double ub)
{
return new Range(_model, lb, expr, ub);
}
public static void Main(String[] args)
{
CP cp = new CP();
/* CREATE THE TIME-INTERVALS. */
IIntervalVar masonry = cp.IntervalVar(35, "masonry ");
IIntervalVar carpentry = cp.IntervalVar(15, "carpentry ");
IIntervalVar plumbing = cp.IntervalVar(40, "plumbing ");
IIntervalVar ceiling = cp.IntervalVar(15, "ceiling ");
IIntervalVar roofing = cp.IntervalVar(5, "roofing ");
IIntervalVar painting = cp.IntervalVar(10, "painting ");
IIntervalVar windows = cp.IntervalVar(5, "windows ");
IIntervalVar facade = cp.IntervalVar(10, "facade ");
IIntervalVar garden = cp.IntervalVar(5, "garden ");
IIntervalVar moving = cp.IntervalVar(5, "moving ");
/* ADDING TEMPORAL CONSTRAINTS. */
cp.Add(cp.EndBeforeStart(masonry, carpentry));
cp.Add(cp.EndBeforeStart(masonry, plumbing));
cp.Add(cp.EndBeforeStart(masonry, ceiling));
cp.Add(cp.EndBeforeStart(carpentry, roofing));
cp.Add(cp.EndBeforeStart(ceiling, painting));
cp.Add(cp.EndBeforeStart(roofing, windows));
cp.Add(cp.EndBeforeStart(roofing, facade));
cp.Add(cp.EndBeforeStart(plumbing, facade));
cp.Add(cp.EndBeforeStart(roofing, garden));
cp.Add(cp.EndBeforeStart(plumbing, garden));
cp.Add(cp.EndBeforeStart(windows, moving));
cp.Add(cp.EndBeforeStart(facade, moving));
cp.Add(cp.EndBeforeStart(garden, moving));
cp.Add(cp.EndBeforeStart(painting, moving));
/* DEFINING MINIMIZATION OBJECTIVE */
int useFunction = 1;
INumExpr cost = cp.NumExpr();
cost = cp.Sum(cost, EarlinessCost(masonry, 25, 200.0, useFunction));
cost = cp.Sum(cost, EarlinessCost(carpentry, 75, 300.0, useFunction));
cost = cp.Sum(cost, EarlinessCost(ceiling, 75, 100.0, useFunction));
cost = cp.Sum(cost, TardinessCost(moving, 100, 400.0, useFunction));
cp.Add(cp.Minimize(cost));
/* SOLVING. */
if (cp.Solve())
{
Console.WriteLine("Optimal Value: " + cp.ObjValue);
Console.WriteLine(cp.GetDomain(masonry));
Console.WriteLine(cp.GetDomain(carpentry));
Console.WriteLine(cp.GetDomain(plumbing));
Console.WriteLine(cp.GetDomain(ceiling));
Console.WriteLine(cp.GetDomain(roofing));
Console.WriteLine(cp.GetDomain(painting));
Console.WriteLine(cp.GetDomain(windows));
Console.WriteLine(cp.GetDomain(facade));
Console.WriteLine(cp.GetDomain(garden));
Console.WriteLine(cp.GetDomain(moving));
}
else
{
Console.WriteLine("No solution found. ");
}
}
public IObjective AddMaximize(INumExpr expr)
{
IObjective result = new IObjective(this._model, expr, GRB.MAXIMIZE);
_model.SetObjective(result.expr, result.sense);
return result;
}
