About RobPratt

RobPratt · ‎12-13-2021

OK, it looks like the MILP presolver was already doing something like the fixing of that variable. In both cases, you get: NOTE: The presolved problem has 2612 variables, 2579 constraints, and 35204 constraint coefficients. The small changes in the BestBound value are typical of the branch-and-cut algorithm, which improves the linear programming bound by branching and adding cutting planes. The MILP solver also has a decomposition algorithm that can sometimes yield dramatic performance improvements over branch-and-cut. The simplest invocation involves just adding the DECOMP keyword to the SOLVE WITH MILP statement options. If you can provide the code and data, I'll see if I can recommend anything else.

RobPratt · ‎12-13-2021

You should be fixing that station USL000 to only one orientation (one FIX statement). What you tried violates the CHI_constraint for that station.

RobPratt · ‎12-13-2021

For the station with a fixed orientation, you are introducing symmetry, which is usually bad news for a MILP solver. I recommend using a FIX statement to fix the CHI[station,a,e] variable to 1 for that specific <station,a,e>. Please rerun and show the new log.

RobPratt · ‎12-08-2021

You can use a WHERE clause in the READ DATA statement: read data STDOPT.RATES(where=(Rate ne 0)) into [PortSource Transit LSP RateMatchDest] InboundLinehaul=Rate;

RobPratt · ‎12-07-2021

You can use sparse index sets of tuples as follows: set <str,str> PD; num Containers {PD} init 0; read data STDOPT.Data into PD=[PortSource RateMatchDest] Containers=FEU; set <str,str,str,str> PTCD; num InboundLinehaul {PTCD}; read data STDOPT.RATES into PTCD=[PortSource Transit LSP RateMatchDest] InboundLinehaul=Rate; Please see SAS Help Center: Sparse Modeling for another example.

RobPratt · ‎12-02-2021

One approach to modify the car painting example to handle the different setup times is to first create a data set: data setup_time_data; do from = 1 to 4; do to = 1 to 4; if from ne to then do; if from = 1 and to = 3 then setup_time = 20; else setup_time = 10; output; end; end; end; run; And then replace the IsPurge and ReifyCon declarations, as shown in the following code: proc optmodel; set CARS; /* color of each car */ num car_color {CARS}; read data car_data into CARS=[_N_] car_color=color; num nCars = card(CARS); /* a car is identified by its original slots */ set SLOTS = CARS; /* maximum reshuffling of any car on the line */ num maxMove init 3; /* which car is in slot i */ var CarInSlot {i in SLOTS} integer >= max(1, i - maxMove) <= min(nCars, i + maxMove); /* color of car in slot i */ num nColors = max {car in CARS} car_color[car]; var ColorInSlot {SLOTS} integer >= 1 <= nColors; /* ColorInSlot[i] = car_color[CarInSlot[i]] */ con ElementCon {i in SLOTS}: element(CarInSlot[i], car_color, ColorInSlot[i]); /* each car can be painted only once */ con PaintOnlyOnce: alldiff(CarInSlot); set <num,num> PAIRS; num setup_time {PAIRS}; read data setup_time_data into PAIRS=[from to] setup_time; /* whether there is a purge after slot i, from color j to color k */ var IsPurge {SLOTS diff {nCars}, PAIRS} binary; set COLORS = setof {car in CARS} car_color[car]; var IsColorInSlot {SLOTS, COLORS} binary; con ReifyColor {i in SLOTS, c in COLORS}: reify(IsColorInSlot[i,c], ColorInSlot[i] = c); /* IsPurge[i,j,k] = 1 if and only if ColorInSlot[i] = j and ColorInSlot[i+1] = k */ con ReifyPurge {i in SLOTS diff {nCars}, <j,k> in PAIRS}: reify(IsPurge[i,j,k], IsColorInSlot[i,j] + IsColorInSlot[i+1,k] = 2); /* minimize the total time */ min TotalTime = sum {i in SLOTS diff {nCars}, <j,k> in PAIRS} setup_time[j,k] * IsPurge[i,j,k]; /* call CLP solver */ solve; /* write solution to data set */ create data car_ds from {i in SLOTS} <col('S'||i)=CarInSlot[i]> {i in SLOTS} <col('C'||i)=ColorInSlot[i]>; quit; The resulting optimal solution has objective value 50, with 5 purges, none of which are from red to green.

RobPratt · ‎11-30-2021

The scheduling side of PROC CLP does not support such sequence-dependent transition times, although you can use the standard CSP side, as in this example: SAS Help Center: Car Painting Problem Also in the CLP solver in PROC OPTMODEL: SAS Help Center: Example 6.5 Car Painting Problem Yes, you can solve the problem with MILP, but I have a simpler and faster alternative: model this as a traveling salesman problem (TSP) in a directed graph with a dummy depot node and use the TSP algorithm in the network solver. The orders are the nodes, and the origin-destination pairs are the arcs. In solving the TSP, you can omit the production times because they do not depend on the tour. Alternatively, you can absorb them into the arc weights, as shown in the following code: data ProductionOrdersTable; input Order $ ProductionTime; datalines; A 10 B 20 C 30 ; data SetupTable; input Origin $ Destination $ ChangeTime; datalines; A A 0 A B 10 A C 20 B B 0 B A 10 B C 20 C C 0 C A 20 C B 20 ; proc optmodel; set <str> NODES; num ProductionTime {NODES} init 0; read data ProductionOrdersTable into NODES=[Order] ProductionTime; set <str,str> ARCS; num ChangeTime {ARCS} init 0; read data SetupTable(where=(Origin ne Destination)) into ARCS=[Origin Destination] ChangeTime; str depot = 'depot'; ARCS = ARCS union ({depot} cross NODES) union (NODES cross {depot}); NODES = NODES union {depot}; num weight {<i,j> in ARCS} = ProductionTime[i] + ChangeTime[i,j]; print weight; set <str,str> TOUR; num order {NODES}; solve with network / tsp direction=directed links=(weight=weight) out=(tour=TOUR order=order); print {<i,j> in TOUR} weight; print order; quit; weight A B C depot A 20 30 10 B 30 40 20 C 50 50 30 depot 0 0 0 Problem Summary Number of Nodes 4 Number of Links 12 Graph Direction Directed Problem Type Traveling Salesman Problem Solution Summary Solver Network Problem Type Traveling Salesman Problem Solution Status Optimal Objective Value 90 Relative Gap 0 Absolute Gap 0 Primal Infeasibility 0 Bound Infeasibility 0 Integer Infeasibility 0 Best Bound 90 Nodes 1 Iterations 12 Solution Time 0.01 [1] [2] weight A B 20 B C 40 C depot 30 depot A 0 [1] order A 1 B 2 C 3 depot 4

RobPratt · ‎11-29-2021

Here are three approaches. In all three, note that w is an implicit variable (rather than a number) because it depends on the variable t. The first approach declares y as an implicit variable and minimizes dv: /* impvar y, min dv */ proc optmodel; set OBS; number ET{OBS}; number EST{OBS}; read data mydata into OBS=[_n_] ET EST; var t >= 0; impvar w{i in OBS} = 1/(EST[i]+t); impvar y = (sum{i in OBS} w[i]*ET[i]) / (sum{i in OBS} w[i]); impvar t0 = sum{i in OBS} w[i]*(ET[i]-y)**2 - (card(OBS)-1); con t0Con: t0 >= 0; min dv = t0 / (sum{i in OBS}((w[i]**2)*((ET[i]-y)**2))); solve; t = t0 + dv; put ET[*]; put EST[*]; put w[*]; print y ET w t0 t; quit; The solver yields an optimal objective value close to zero, but the resulting solution differs from your Excel spreadsheet: Solution Summary Solver NLP Algorithm Interior Point Direct Objective Function dv Solution Status Optimal Objective Value 9.0027692E-8 Optimality Error 9.0880058E-8 Infeasibility 0 Iterations 10 Presolve Time 0.00 Solution Time 0.00 y -0.17114 [1] ET w 1 0.208718 10.3286 2 -0.598677 12.0514 3 -0.020166 8.1409 t0 t 1.8787 0.0000011299 The second approach declares y as a variable, imposes a constraint, and minimizes dv: /* var y, min dv */ proc optmodel; set OBS; number ET{OBS}; number EST{OBS}; read data mydata into OBS=[_n_] ET EST; var y init 0; var t >= 0; impvar w{i in OBS} = 1/(EST[i]+t); impvar t0 = sum{i in OBS} w[i]*(ET[i]-y)**2 - (card(OBS)-1); t = t0; con t0Con: t0 >= 0; con yCon: y * sum{i in OBS} w[i] = sum{i in OBS} w[i] * ET[i]; min dv = t0 / (sum{i in OBS}((w[i]**2)*((ET[i]-y)**2))); solve; t = t0 + dv; put ET[*]; put EST[*]; put w[*]; print y ET w t0 t; quit; The solver again yields an optimal objective value close to zero, but the resulting solution differs from your Excel spreadsheet, except that the y value now matches: Solution Summary Solver NLP Algorithm Interior Point Direct Objective Function dv Solution Status Optimal Objective Value 9.002769E-8 Optimality Error 9.0880059E-8 Infeasibility 2.751088E-11 Iterations 14 Presolve Time 0.00 Solution Time 0.01 y -0.15463 [1] ET w 1 0.208718 10.3286 2 -0.598677 12.0514 3 -0.020166 8.1409 t0 t 1.887 0.0000011299 The third approach declares y as an implicit variable, enforces equation (5) as a constraint, and uses no objective: /* impvar y, no objective */ proc optmodel; set OBS; number ET{OBS}; number EST{OBS}; read data mydata into OBS=[_n_] ET EST; var t >= 0; impvar w{i in OBS} = 1/(EST[i]+t); impvar y = (sum{i in OBS} w[i]*ET[i]) / (sum{i in OBS} w[i]); con Equation5: sum{i in OBS} w[i]*(ET[i]-y)**2 / (card(OBS)-1) = 1; solve noobj; put ET[*]; put EST[*]; put w[*]; print y ET w t; quit; The resulting solution matches your Excel spreadsheet: Solution Summary Solver NLP Algorithm Interior Point Direct Objective Function (0) Solution Status Optimal Objective Value 0 Optimality Error 9.0909091E-8 Infeasibility 4.440892E-16 Iterations 6 Presolve Time 0.00 Solution Time 0.00 y -0.15463 [1] ET w 1 0.208718 5.5346 2 -0.598677 5.9938 3 -0.020166 4.8380 t 0.083863

RobPratt · ‎11-23-2021

ORIENTATION_STRING is a set of strings, but you are trying to use it as the second subscript of matrix[], which expects a single string. The following statement uses the string concatenation operator || to construct the desired string from the <a,e> pair: impvar XIT{target in TARGETS} = sum{station in STATIONS, <a,e> in ORIENTATIONS} matrix[station, a||'/'||e, target] * Chi[station,a,e];

RobPratt · ‎11-23-2021

ORIENTATIONS is now a set of pairs of numbers <a,e> rather than a set of strings. You need to change orientation in ORIENTATIONS to <a,e> in ORIENTATIONS. Also, CHI now has three subscripts instead of two, so change CHI[station,orientation] to CHI[station,a,e].

RobPratt · ‎11-23-2021

You can use the INPUT and SCAN functions to do this, either in the DATA step or in PROC OPTMODEL. Here's the latter approach: set MY_STRINGS = /'45/35' '90/35' '135/35' '180/35' '225/35' '270/35' '315/35' '360/35'/; set ORIENTATIONS = setof {s in MY_STRINGS} <input(scan(s,1,'/'),best.),input(scan(s,2,'/'),best.)>; put ORIENTATIONS=; The PUT statement yields the following in the log: ORIENTATIONS={<45,35>,<90,35>,<135,35>,<180,35>,<225,35>,<270,35>,<315,35>,<360,35>}

RobPratt · ‎11-23-2021

Here's one approach, where I have replaced the strings with pairs of numbers: proc optmodel; set STATIONS = /A B C D/; /* set ORIENTATIONS = /'45/35' '90/35' '135/35' '180/35' '225/35' '270/35' '315/35' '360/35'/;*/ set ORIENTATIONS = {<45,35>, <90,35>, <135,35>, <180,35>, <225,35>, <270,35>, <315,35>, <360,35>}; var CHI {STATIONS, ORIENTATIONS} binary; set STATION_PAIRS = {<'A','B'>, <'C','D'>}; set AZIMUTHS = setof {<a,e> in ORIENTATIONS} a; put AZIMUTHS=; set AZIMUTH_PAIRS = {a1 in AZIMUTHS, a2 in AZIMUTHS: mod(a1-a2+360,360) <= 45}; put AZIMUTH_PAIRS=; con NotAdjacentAzimuths {<s1,s2> in STATION_PAIRS, <a1,a2> in AZIMUTH_PAIRS}: sum {<a,e> in ORIENTATIONS: a in {a1,a2}} (CHI[s1,a,e] + CHI[s2,a,e]) <= 1; expand; quit; Note that this "clique" constraint subsumes the "conflict" constraint (from my answer to your previous question) that prevents identical azimuths from being assigned to both stations in a pair.

RobPratt · ‎11-19-2021

If I understand correctly, you want to include the following "conflict" constraints that prohibit both binary variables from taking the value 1 simultaneously: set STATION_PAIRS = {<'A','B'>, <'C','D'>}; con NotSameOrientation {<s1,s2> in STATION_PAIRS, o in ORIENTATIONS}: CHI[s1,o] + CHI[s2,o] <= 1;

RobPratt · ‎11-10-2021

A heuristic idea is to keep the optimization model the same but modify the input data to split demands across multiple copies of the existing nodes. For example, the following DATA step splits nodes 8 and 17 in the input: data vrpdata; input node x y demand; datalines; 1 145 215 0 2 151 264 1100 3 159 261 700 4 130 254 800 5 128 252 1400 6 163 247 2100 7 146 246 400 8.1 161 242 400 8.2 161 242 400 9 142 239 100 10 163 236 500 11 148 232 600 12 128 231 1200 13 156 217 1300 14 129 214 1300 15 146 208 300 16 164 208 900 17.1 141 206 500 17.2 141 206 500 17.3 141 206 500 17.4 141 206 500 17.5 141 206 100 18 147 193 1000 19 164 193 900 20 129 189 2500 21 155 185 1800 22 139 182 700 ; The resulting optimal solution has optimal objective value 585 instead of 603. If you instead want the solver to determine the best way to split the demands, you can keep the original data and replace the FlowBalance constraints as follows: * con FlowBalance {i in NODES diff {depot}, k in VEHICLES}: sum {<j,(i)> in ARCS} Flow[j,i,k] - sum {<(i),j> in ARCS} Flow[i,j,k] = demand[i] * UseNode[i,k]; var DemandSatisfied {NODES diff {depot}, VEHICLES} >= 0 <= capacity; con FlowBalance {i in NODES diff {depot}, k in VEHICLES}: sum {<j,(i)> in ARCS} Flow[j,i,k] - sum {<(i),j> in ARCS} Flow[i,j,k] = DemandSatisfied[i,k]; con DemandSatisfaction {i in NODES diff {depot}}: sum {k in VEHICLES} DemandSatisfied[i,k] = demand[i];

RobPratt · ‎11-09-2021

Do you want to allow splitting of each demand into two equal demands, or do you want to allow arbitrary splits into two or more not necessarily equal demands?

Online Status	Offline
Date Last Visited	Friday