Free cookie consent management tool by TermsFeed Policy Generator

source: trunk/HeuristicLab.ExactOptimization/3.3/LinearProgramming/Algorithms/LinearSolverExtensions.cs @ 17530

Last change on this file since 17530 was 17180, checked in by swagner, 5 years ago

#2875: Removed years in copyrights
File size: 32.2 KB
RevLine 
[16417]1#region License Information
2/* HeuristicLab
[17180]3 * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
[16417]4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22using Google.OrTools.LinearSolver;
23
[16582]24namespace HeuristicLab.ExactOptimization.LinearProgramming {
[16417]25
26  public static class LinearSolverExtensions {
27
28    public static bool[] GetSolutionBoolVarArray(this Solver solver, int count, string name) {
29      var array = new bool[count];
30      for (var d1 = 0; d1 < count; d1++) {
31        var varName = $"{name}{d1}";
32        array[d1] = (int)solver.LookupVariableOrNull(varName).SolutionValue() != 0;
33      }
34
35      return array;
36    }
37
38    public static bool[,] GetSolutionBoolVarArray(this Solver solver, int rows, int cols, string name) {
39      var array = new bool[rows, cols];
40      for (var d1 = 0; d1 < rows; d1++) {
41        for (var d2 = 0; d2 < cols; d2++) {
42          var varName = $"{name}[{d1}, {d2}]";
43          array[d1, d2] = (int)solver.LookupVariableOrNull(varName).SolutionValue() != 0;
44        }
45      }
46
47      return array;
48    }
49
50    public static bool[,,] GetSolutionBoolVarArray(this Solver solver, int rows, int cols, int dim3, string name) {
51      var array = new bool[rows, cols, dim3];
52      for (var d1 = 0; d1 < rows; d1++) {
53        for (var d2 = 0; d2 < cols; d2++) {
54          for (var d3 = 0; d3 < cols; d3++) {
55            var varName = $"{name}[{d1}, {d2}, {d3}]";
56            array[d1, d2, d3] = (int)solver.LookupVariableOrNull(varName).SolutionValue() != 0;
57          }
58        }
59      }
60
61      return array;
62    }
63
64    public static bool[,,,] GetSolutionBoolVarArray(this Solver solver,
65        int rows, int cols, int dim3, int dim4, string name) {
66      var array = new bool[rows, cols, dim3, dim4];
67      for (var d1 = 0; d1 < rows; d1++) {
68        for (var d2 = 0; d2 < cols; d2++) {
69          for (var d3 = 0; d3 < cols; d3++) {
70            for (var d4 = 0; d4 < cols; d4++) {
71              var varName = $"{name}[{d1}, {d2}, {d3}, {d4}]";
72              array[d1, d2, d3, d4] = (int)solver.LookupVariableOrNull(varName).SolutionValue() != 0;
73            }
74          }
75        }
76      }
77
78      return array;
79    }
80
81    public static bool[,,,,] GetSolutionBoolVarArray(this Solver solver,
82        int rows, int cols, int dim3, int dim4, int dim5, string name) {
83      var array = new bool[rows, cols, dim3, dim4, dim5];
84      for (var d1 = 0; d1 < rows; d1++) {
85        for (var d2 = 0; d2 < cols; d2++) {
86          for (var d3 = 0; d3 < cols; d3++) {
87            for (var d4 = 0; d4 < cols; d4++) {
88              for (var d5 = 0; d5 < cols; d5++) {
89                var varName = $"{name}[{d1}, {d2}, {d3}, {d4}, {d5}]";
90                array[d1, d2, d3, d4, d5] = (int)solver.LookupVariableOrNull(varName).SolutionValue() != 0;
91              }
92            }
93          }
94        }
95      }
96
97      return array;
98    }
99
100    public static bool[,,,,,] GetSolutionBoolVarArray(this Solver solver,
101        int rows, int cols, int dim3, int dim4, int dim5, int dim6, string name) {
102      var array = new bool[rows, cols, dim3, dim4, dim5, dim6];
103      for (var d1 = 0; d1 < rows; d1++) {
104        for (var d2 = 0; d2 < cols; d2++) {
105          for (var d3 = 0; d3 < cols; d3++) {
106            for (var d4 = 0; d4 < cols; d4++) {
107              for (var d5 = 0; d5 < cols; d5++) {
108                for (var d6 = 0; d6 < cols; d6++) {
109                  var varName = $"{name}[{d1}, {d2}, {d3}, {d4}, {d5}, {d6}]";
110                  array[d1, d2, d3, d4, d5, d6] = (int)solver.LookupVariableOrNull(varName).SolutionValue() != 0;
111                }
112              }
113            }
114          }
115        }
116      }
117
118      return array;
119    }
120
121    public static bool[,] GetSolutionBoolVarMatrix(this Solver solver, int rows, int cols, string name) =>
122      solver.GetSolutionBoolVarArray(rows, cols, name);
123
124    public static int[] GetSolutionIntVarArray(this Solver solver, int count, string name) {
125      var array = new int[count];
126      for (var d1 = 0; d1 < count; d1++) {
127        var varName = $"{name}{d1}";
128        array[d1] = (int)solver.LookupVariableOrNull(varName).SolutionValue();
129      }
130
131      return array;
132    }
133
134    public static int[,] GetSolutionIntVarArray(this Solver solver, int rows, int cols, string name) {
135      var array = new int[rows, cols];
136      for (var d1 = 0; d1 < rows; d1++) {
137        for (var d2 = 0; d2 < cols; d2++) {
138          var varName = $"{name}[{d1}, {d2}]";
139          array[d1, d2] = (int)solver.LookupVariableOrNull(varName).SolutionValue();
140        }
141      }
142
143      return array;
144    }
145
146    public static int[,,] GetSolutionIntVarArray(this Solver solver, int rows, int cols, int dim3, string name) {
147      var array = new int[rows, cols, dim3];
148      for (var d1 = 0; d1 < rows; d1++) {
149        for (var d2 = 0; d2 < cols; d2++) {
150          for (var d3 = 0; d3 < cols; d3++) {
151            var varName = $"{name}[{d1}, {d2}, {d3}]";
152            array[d1, d2, d3] = (int)solver.LookupVariableOrNull(varName).SolutionValue();
153          }
154        }
155      }
156
157      return array;
158    }
159
160    public static int[,,,] GetSolutionIntVarArray(this Solver solver,
161        int rows, int cols, int dim3, int dim4, string name) {
162      var array = new int[rows, cols, dim3, dim4];
163      for (var d1 = 0; d1 < rows; d1++) {
164        for (var d2 = 0; d2 < cols; d2++) {
165          for (var d3 = 0; d3 < cols; d3++) {
166            for (var d4 = 0; d4 < cols; d4++) {
167              var varName = $"{name}[{d1}, {d2}, {d3}, {d4}]";
168              array[d1, d2, d3, d4] = (int)solver.LookupVariableOrNull(varName).SolutionValue();
169            }
170          }
171        }
172      }
173
174      return array;
175    }
176
177    public static int[,,,,] GetSolutionIntVarArray(this Solver solver,
178        int rows, int cols, int dim3, int dim4, int dim5, string name) {
179      var array = new int[rows, cols, dim3, dim4, dim5];
180      for (var d1 = 0; d1 < rows; d1++) {
181        for (var d2 = 0; d2 < cols; d2++) {
182          for (var d3 = 0; d3 < cols; d3++) {
183            for (var d4 = 0; d4 < cols; d4++) {
184              for (var d5 = 0; d5 < cols; d5++) {
185                var varName = $"{name}[{d1}, {d2}, {d3}, {d4}, {d5}]";
186                array[d1, d2, d3, d4, d5] = (int)solver.LookupVariableOrNull(varName).SolutionValue();
187              }
188            }
189          }
190        }
191      }
192
193      return array;
194    }
195
196    public static int[,,,,,] GetSolutionIntVarArray(this Solver solver,
197        int rows, int cols, int dim3, int dim4, int dim5, int dim6, string name) {
198      var array = new int[rows, cols, dim3, dim4, dim5, dim6];
199      for (var d1 = 0; d1 < rows; d1++) {
200        for (var d2 = 0; d2 < cols; d2++) {
201          for (var d3 = 0; d3 < cols; d3++) {
202            for (var d4 = 0; d4 < cols; d4++) {
203              for (var d5 = 0; d5 < cols; d5++) {
204                for (var d6 = 0; d6 < cols; d6++) {
205                  var varName = $"{name}[{d1}, {d2}, {d3}, {d4}, {d5}, {d6}]";
206                  array[d1, d2, d3, d4, d5, d6] = (int)solver.LookupVariableOrNull(varName).SolutionValue();
207                }
208              }
209            }
210          }
211        }
212      }
213
214      return array;
215    }
216
217    public static int[,] GetSolutionIntVarMatrix(this Solver solver, int rows, int cols, string name) =>
218      solver.GetSolutionIntVarArray(rows, cols, name);
219
220    public static double[] GetSolutionNumVarArray(this Solver solver, int count, string name) {
221      var array = new double[count];
222      for (var d1 = 0; d1 < count; d1++) {
223        var varName = $"{name}{d1}";
224        array[d1] = solver.LookupVariableOrNull(varName).SolutionValue();
225      }
226
227      return array;
228    }
229
230    public static double[,] GetSolutionNumVarArray(this Solver solver, int rows, int cols, string name) {
231      var array = new double[rows, cols];
232      for (var d1 = 0; d1 < rows; d1++) {
233        for (var d2 = 0; d2 < cols; d2++) {
234          var varName = $"{name}[{d1}, {d2}]";
235          array[d1, d2] = solver.LookupVariableOrNull(varName).SolutionValue();
236        }
237      }
238
239      return array;
240    }
241
242    public static double[,,] GetSolutionNumVarArray(this Solver solver, int rows, int cols, int dim3, string name) {
243      var array = new double[rows, cols, dim3];
244      for (var d1 = 0; d1 < rows; d1++) {
245        for (var d2 = 0; d2 < cols; d2++) {
246          for (var d3 = 0; d3 < cols; d3++) {
247            var varName = $"{name}[{d1}, {d2}, {d3}]";
248            array[d1, d2, d3] = solver.LookupVariableOrNull(varName).SolutionValue();
249          }
250        }
251      }
252
253      return array;
254    }
255
256    public static double[,,,] GetSolutionNumVarArray(this Solver solver,
257      int rows, int cols, int dim3, int dim4, string name) {
258      var array = new double[rows, cols, dim3, dim4];
259      for (var d1 = 0; d1 < rows; d1++) {
260        for (var d2 = 0; d2 < cols; d2++) {
261          for (var d3 = 0; d3 < cols; d3++) {
262            for (var d4 = 0; d4 < cols; d4++) {
263              var varName = $"{name}[{d1}, {d2}, {d3}, {d4}]";
264              array[d1, d2, d3, d4] = solver.LookupVariableOrNull(varName).SolutionValue();
265            }
266          }
267        }
268      }
269
270      return array;
271    }
272
273    public static double[,,,,] GetSolutionNumVarArray(this Solver solver,
274      int rows, int cols, int dim3, int dim4, int dim5, string name) {
275      var array = new double[rows, cols, dim3, dim4, dim5];
276      for (var d1 = 0; d1 < rows; d1++) {
277        for (var d2 = 0; d2 < cols; d2++) {
278          for (var d3 = 0; d3 < cols; d3++) {
279            for (var d4 = 0; d4 < cols; d4++) {
280              for (var d5 = 0; d5 < cols; d5++) {
281                var varName = $"{name}[{d1}, {d2}, {d3}, {d4}, {d5}]";
282                array[d1, d2, d3, d4, d5] = solver.LookupVariableOrNull(varName).SolutionValue();
283              }
284            }
285          }
286        }
287      }
288
289      return array;
290    }
291
292    public static double[,,,,,] GetSolutionNumVarArray(this Solver solver,
293      int rows, int cols, int dim3, int dim4, int dim5, int dim6, string name) {
294      var array = new double[rows, cols, dim3, dim4, dim5, dim6];
295      for (var d1 = 0; d1 < rows; d1++) {
296        for (var d2 = 0; d2 < cols; d2++) {
297          for (var d3 = 0; d3 < cols; d3++) {
298            for (var d4 = 0; d4 < cols; d4++) {
299              for (var d5 = 0; d5 < cols; d5++) {
300                for (var d6 = 0; d6 < cols; d6++) {
301                  var varName = $"{name}[{d1}, {d2}, {d3}, {d4}, {d5}, {d6}]";
302                  array[d1, d2, d3, d4, d5, d6] = solver.LookupVariableOrNull(varName).SolutionValue();
303                }
304              }
305            }
306          }
307        }
308      }
309
310      return array;
311    }
312
313    public static double[,] GetSolutionNumVarMatrix(this Solver solver, int rows, int cols, string name) =>
314      solver.GetSolutionNumVarArray(rows, cols, name);
315
316    public static Variable[,] MakeBoolVarArray(this Solver solver, int rows, int cols) =>
317      solver.MakeBoolVarMatrix(rows, cols);
318
319    public static Variable[,] MakeBoolVarArray(this Solver solver, int rows, int cols, string name) =>
320      solver.MakeBoolVarMatrix(rows, cols, name);
321
322    public static Variable[,,] MakeBoolVarArray(this Solver solver, int rows, int cols, int dim3) {
323      var array = new Variable[rows, cols, dim3];
324      for (var d1 = 0; d1 < rows; d1++) {
325        for (var d2 = 0; d2 < cols; d2++) {
326          for (var d3 = 0; d3 < cols; d3++) {
327            array[d1, d2, d3] = solver.MakeBoolVar("");
328          }
329        }
330      }
331
332      return array;
333    }
334
335    public static Variable[,,] MakeBoolVarArray(this Solver solver, int rows, int cols, int dim3, string name) {
336      var array = new Variable[rows, cols, dim3];
337      for (var d1 = 0; d1 < rows; d1++) {
338        for (var d2 = 0; d2 < cols; d2++) {
339          for (var d3 = 0; d3 < cols; d3++) {
340            var varName = $"{name}[{d1}, {d2}, {d3}]";
341            array[d1, d2, d3] = solver.MakeBoolVar(varName);
342          }
343        }
344      }
345
346      return array;
347    }
348
349    public static Variable[,,,] MakeBoolVarArray(this Solver solver,
350      int rows, int cols, int dim3, int dim4) {
351      var array = new Variable[rows, cols, dim3, dim4];
352      for (var d1 = 0; d1 < rows; d1++) {
353        for (var d2 = 0; d2 < cols; d2++) {
354          for (var d3 = 0; d3 < cols; d3++) {
355            for (var d4 = 0; d4 < cols; d4++) {
356              array[d1, d2, d3, d4] = solver.MakeBoolVar("");
357            }
358          }
359        }
360      }
361
362      return array;
363    }
364
365    public static Variable[,,,] MakeBoolVarArray(this Solver solver,
366      int rows, int cols, int dim3, int dim4, string name) {
367      var array = new Variable[rows, cols, dim3, dim4];
368      for (var d1 = 0; d1 < rows; d1++) {
369        for (var d2 = 0; d2 < cols; d2++) {
370          for (var d3 = 0; d3 < cols; d3++) {
371            for (var d4 = 0; d4 < cols; d4++) {
372              var varName = $"{name}[{d1}, {d2}, {d3}, {d4}]";
373              array[d1, d2, d3, d4] = solver.MakeBoolVar(varName);
374            }
375          }
376        }
377      }
378
379      return array;
380    }
381
382    public static Variable[,,,,] MakeBoolVarArray(this Solver solver,
383      int rows, int cols, int dim3, int dim4, int dim5) {
384      var array = new Variable[rows, cols, dim3, dim4, dim5];
385      for (var d1 = 0; d1 < rows; d1++) {
386        for (var d2 = 0; d2 < cols; d2++) {
387          for (var d3 = 0; d3 < cols; d3++) {
388            for (var d4 = 0; d4 < cols; d4++) {
389              for (var d5 = 0; d5 < cols; d5++) {
390                array[d1, d2, d3, d4, d5] = solver.MakeBoolVar("");
391              }
392            }
393          }
394        }
395      }
396
397      return array;
398    }
399
400    public static Variable[,,,,] MakeBoolVarArray(this Solver solver,
401      int rows, int cols, int dim3, int dim4, int dim5, string name) {
402      var array = new Variable[rows, cols, dim3, dim4, dim5];
403      for (var d1 = 0; d1 < rows; d1++) {
404        for (var d2 = 0; d2 < cols; d2++) {
405          for (var d3 = 0; d3 < cols; d3++) {
406            for (var d4 = 0; d4 < cols; d4++) {
407              for (var d5 = 0; d5 < cols; d5++) {
408                var varName = $"{name}[{d1}, {d2}, {d3}, {d4}, {d5}]";
409                array[d1, d2, d3, d4, d5] = solver.MakeBoolVar(varName);
410              }
411            }
412          }
413        }
414      }
415
416      return array;
417    }
418
419    public static Variable[,,,,,] MakeBoolVarArray(this Solver solver,
420      int rows, int cols, int dim3, int dim4, int dim5, int dim6) {
421      var array = new Variable[rows, cols, dim3, dim4, dim5, dim6];
422      for (var d1 = 0; d1 < rows; d1++) {
423        for (var d2 = 0; d2 < cols; d2++) {
424          for (var d3 = 0; d3 < cols; d3++) {
425            for (var d4 = 0; d4 < cols; d4++) {
426              for (var d5 = 0; d5 < cols; d5++) {
427                for (var d6 = 0; d6 < cols; d6++) {
428                  array[d1, d2, d3, d4, d5, d6] = solver.MakeBoolVar("");
429                }
430              }
431            }
432          }
433        }
434      }
435
436      return array;
437    }
438
439    public static Variable[,,,,,] MakeBoolVarArray(this Solver solver,
440      int rows, int cols, int dim3, int dim4, int dim5, int dim6, string name) {
441      var array = new Variable[rows, cols, dim3, dim4, dim5, dim6];
442      for (var d1 = 0; d1 < rows; d1++) {
443        for (var d2 = 0; d2 < cols; d2++) {
444          for (var d3 = 0; d3 < cols; d3++) {
445            for (var d4 = 0; d4 < cols; d4++) {
446              for (var d5 = 0; d5 < cols; d5++) {
447                for (var d6 = 0; d6 < cols; d6++) {
448                  var varName = $"{name}[{d1}, {d2}, {d3}, {d4}, {d5}, {d6}]";
449                  array[d1, d2, d3, d4, d5, d6] = solver.MakeBoolVar(varName);
450                }
451              }
452            }
453          }
454        }
455      }
456
457      return array;
458    }
459
460    public static Variable[,] MakeIntVarArray(this Solver solver,
461      int rows, int cols, double lb, double ub) => solver.MakeIntVarMatrix(rows, cols, lb, ub);
462
463    public static Variable[,] MakeIntVarArray(this Solver solver,
464      int rows, int cols, double lb, double ub, string name) => solver.MakeIntVarMatrix(rows, cols, lb, ub, name);
465
466    public static Variable[,,] MakeIntVarArray(this Solver solver,
467      int rows, int cols, int dim3, double lb, double ub) {
468      var array = new Variable[rows, cols, dim3];
469      for (var d1 = 0; d1 < rows; d1++) {
470        for (var d2 = 0; d2 < cols; d2++) {
471          for (var d3 = 0; d3 < cols; d3++) {
472            array[d1, d2, d3] = solver.MakeIntVar(lb, ub, "");
473          }
474        }
475      }
476
477      return array;
478    }
479
480    public static Variable[,,] MakeIntVarArray(this Solver solver,
481      int rows, int cols, int dim3, double lb, double ub, string name) {
482      var array = new Variable[rows, cols, dim3];
483      for (var d1 = 0; d1 < rows; d1++) {
484        for (var d2 = 0; d2 < cols; d2++) {
485          for (var d3 = 0; d3 < cols; d3++) {
486            var varName = $"{name}[{d1}, {d2}, {d3}]";
487            array[d1, d2, d3] = solver.MakeIntVar(lb, ub, varName);
488          }
489        }
490      }
491
492      return array;
493    }
494
495    public static Variable[,,,] MakeIntVarArray(this Solver solver,
496      int rows, int cols, int dim3, int dim4, double lb, double ub) {
497      var array = new Variable[rows, cols, dim3, dim4];
498      for (var d1 = 0; d1 < rows; d1++) {
499        for (var d2 = 0; d2 < cols; d2++) {
500          for (var d3 = 0; d3 < cols; d3++) {
501            for (var d4 = 0; d4 < cols; d4++) {
502              array[d1, d2, d3, d4] = solver.MakeIntVar(lb, ub, "");
503            }
504          }
505        }
506      }
507
508      return array;
509    }
510
511    public static Variable[,,,] MakeIntVarArray(this Solver solver,
512      int rows, int cols, int dim3, int dim4, double lb, double ub, string name) {
513      var array = new Variable[rows, cols, dim3, dim4];
514      for (var d1 = 0; d1 < rows; d1++) {
515        for (var d2 = 0; d2 < cols; d2++) {
516          for (var d3 = 0; d3 < cols; d3++) {
517            for (var d4 = 0; d4 < cols; d4++) {
518              var varName = $"{name}[{d1}, {d2}, {d3}, {d4}]";
519              array[d1, d2, d3, d4] = solver.MakeIntVar(lb, ub, varName);
520            }
521          }
522        }
523      }
524
525      return array;
526    }
527
528    public static Variable[,,,,] MakeIntVarArray(this Solver solver,
529      int rows, int cols, int dim3, int dim4, int dim5, double lb, double ub) {
530      var array = new Variable[rows, cols, dim3, dim4, dim5];
531      for (var d1 = 0; d1 < rows; d1++) {
532        for (var d2 = 0; d2 < cols; d2++) {
533          for (var d3 = 0; d3 < cols; d3++) {
534            for (var d4 = 0; d4 < cols; d4++) {
535              for (var d5 = 0; d5 < cols; d5++) {
536                array[d1, d2, d3, d4, d5] = solver.MakeIntVar(lb, ub, "");
537              }
538            }
539          }
540        }
541      }
542
543      return array;
544    }
545
546    public static Variable[,,,,] MakeIntVarArray(this Solver solver,
547      int rows, int cols, int dim3, int dim4, int dim5, double lb, double ub, string name) {
548      var array = new Variable[rows, cols, dim3, dim4, dim5];
549      for (var d1 = 0; d1 < rows; d1++) {
550        for (var d2 = 0; d2 < cols; d2++) {
551          for (var d3 = 0; d3 < cols; d3++) {
552            for (var d4 = 0; d4 < cols; d4++) {
553              for (var d5 = 0; d5 < cols; d5++) {
554                var varName = $"{name}[{d1}, {d2}, {d3}, {d4}, {d5}]";
555                array[d1, d2, d3, d4, d5] = solver.MakeIntVar(lb, ub, varName);
556              }
557            }
558          }
559        }
560      }
561
562      return array;
563    }
564
565    public static Variable[,,,,,] MakeIntVarArray(this Solver solver,
566      int rows, int cols, int dim3, int dim4, int dim5, int dim6, double lb, double ub) {
567      var array = new Variable[rows, cols, dim3, dim4, dim5, dim6];
568      for (var d1 = 0; d1 < rows; d1++) {
569        for (var d2 = 0; d2 < cols; d2++) {
570          for (var d3 = 0; d3 < cols; d3++) {
571            for (var d4 = 0; d4 < cols; d4++) {
572              for (var d5 = 0; d5 < cols; d5++) {
573                for (var d6 = 0; d6 < cols; d6++) {
574                  array[d1, d2, d3, d4, d5, d6] = solver.MakeIntVar(lb, ub, "");
575                }
576              }
577            }
578          }
579        }
580      }
581
582      return array;
583    }
584
585    public static Variable[,,,,,] MakeIntVarArray(this Solver solver,
586      int rows, int cols, int dim3, int dim4, int dim5, int dim6, double lb, double ub, string name) {
587      var array = new Variable[rows, cols, dim3, dim4, dim5, dim6];
588      for (var d1 = 0; d1 < rows; d1++) {
589        for (var d2 = 0; d2 < cols; d2++) {
590          for (var d3 = 0; d3 < cols; d3++) {
591            for (var d4 = 0; d4 < cols; d4++) {
592              for (var d5 = 0; d5 < cols; d5++) {
593                for (var d6 = 0; d6 < cols; d6++) {
594                  var varName = $"{name}[{d1}, {d2}, {d3}, {d4}, {d5}, {d6}]";
595                  array[d1, d2, d3, d4, d5, d6] = solver.MakeIntVar(lb, ub, varName);
596                }
597              }
598            }
599          }
600        }
601      }
602
603      return array;
604    }
605
606    public static Variable[,] MakeNumVarArray(this Solver solver,
607      int rows, int cols, double lb, double ub) => solver.MakeNumVarMatrix(rows, cols, lb, ub);
608
609    public static Variable[,] MakeNumVarArray(this Solver solver,
610      int rows, int cols, double lb, double ub, string name) =>
611      solver.MakeNumVarMatrix(rows, cols, lb, ub, name);
612
613    public static Variable[,,] MakeNumVarArray(this Solver solver,
614      int rows, int cols, int dim3, double lb, double ub) {
615      var array = new Variable[rows, cols, dim3];
616      for (var d1 = 0; d1 < rows; d1++) {
617        for (var d2 = 0; d2 < cols; d2++) {
618          for (var d3 = 0; d3 < cols; d3++) {
619            array[d1, d2, d3] = solver.MakeNumVar(lb, ub, "");
620          }
621        }
622      }
623
624      return array;
625    }
626
627    public static Variable[,,] MakeNumVarArray(this Solver solver,
628      int rows, int cols, int dim3, double lb, double ub, string name) {
629      var array = new Variable[rows, cols, dim3];
630      for (var d1 = 0; d1 < rows; d1++) {
631        for (var d2 = 0; d2 < cols; d2++) {
632          for (var d3 = 0; d3 < cols; d3++) {
633            var varName = $"{name}[{d1}, {d2}, {d3}]";
634            array[d1, d2, d3] = solver.MakeNumVar(lb, ub, varName);
635          }
636        }
637      }
638
639      return array;
640    }
641
642    public static Variable[,,,] MakeNumVarArray(this Solver solver,
643      int rows, int cols, int dim3, int dim4, double lb, double ub) {
644      var array = new Variable[rows, cols, dim3, dim4];
645      for (var d1 = 0; d1 < rows; d1++) {
646        for (var d2 = 0; d2 < cols; d2++) {
647          for (var d3 = 0; d3 < cols; d3++) {
648            for (var d4 = 0; d4 < cols; d4++) {
649              array[d1, d2, d3, d4] = solver.MakeNumVar(lb, ub, "");
650            }
651          }
652        }
653      }
654
655      return array;
656    }
657
658    public static Variable[,,,] MakeNumVarArray(this Solver solver,
659      int rows, int cols, int dim3, int dim4, double lb, double ub, string name) {
660      var array = new Variable[rows, cols, dim3, dim4];
661      for (var d1 = 0; d1 < rows; d1++) {
662        for (var d2 = 0; d2 < cols; d2++) {
663          for (var d3 = 0; d3 < cols; d3++) {
664            for (var d4 = 0; d4 < cols; d4++) {
665              var varName = $"{name}[{d1}, {d2}, {d3}, {d4}]";
666              array[d1, d2, d3, d4] = solver.MakeNumVar(lb, ub, varName);
667            }
668          }
669        }
670      }
671
672      return array;
673    }
674
675    public static Variable[,,,,] MakeNumVarArray(this Solver solver,
676      int rows, int cols, int dim3, int dim4, int dim5, double lb, double ub) {
677      var array = new Variable[rows, cols, dim3, dim4, dim5];
678      for (var d1 = 0; d1 < rows; d1++) {
679        for (var d2 = 0; d2 < cols; d2++) {
680          for (var d3 = 0; d3 < cols; d3++) {
681            for (var d4 = 0; d4 < cols; d4++) {
682              for (var d5 = 0; d5 < cols; d5++) {
683                array[d1, d2, d3, d4, d5] = solver.MakeNumVar(lb, ub, "");
684              }
685            }
686          }
687        }
688      }
689
690      return array;
691    }
692
693    public static Variable[,,,,] MakeNumVarArray(this Solver solver,
694      int rows, int cols, int dim3, int dim4, int dim5, double lb, double ub, string name) {
695      var array = new Variable[rows, cols, dim3, dim4, dim5];
696      for (var d1 = 0; d1 < rows; d1++) {
697        for (var d2 = 0; d2 < cols; d2++) {
698          for (var d3 = 0; d3 < cols; d3++) {
699            for (var d4 = 0; d4 < cols; d4++) {
700              for (var d5 = 0; d5 < cols; d5++) {
701                var varName = $"{name}[{d1}, {d2}, {d3}, {d4}, {d5}]";
702                array[d1, d2, d3, d4, d5] = solver.MakeNumVar(lb, ub, varName);
703              }
704            }
705          }
706        }
707      }
708
709      return array;
710    }
711
712    public static Variable[,,,,,] MakeNumVarArray(this Solver solver,
713      int rows, int cols, int dim3, int dim4, int dim5, int dim6, double lb, double ub) {
714      var array = new Variable[rows, cols, dim3, dim4, dim5, dim6];
715      for (var d1 = 0; d1 < rows; d1++) {
716        for (var d2 = 0; d2 < cols; d2++) {
717          for (var d3 = 0; d3 < cols; d3++) {
718            for (var d4 = 0; d4 < cols; d4++) {
719              for (var d5 = 0; d5 < cols; d5++) {
720                for (var d6 = 0; d6 < cols; d6++) {
721                  array[d1, d2, d3, d4, d5, d6] = solver.MakeNumVar(lb, ub, "");
722                }
723              }
724            }
725          }
726        }
727      }
728
729      return array;
730    }
731
732    public static Variable[,,,,,] MakeNumVarArray(this Solver solver,
733      int rows, int cols, int dim3, int dim4, int dim5, int dim6, double lb, double ub, string name) {
734      var array = new Variable[rows, cols, dim3, dim4, dim5, dim6];
735      for (var d1 = 0; d1 < rows; d1++) {
736        for (var d2 = 0; d2 < cols; d2++) {
737          for (var d3 = 0; d3 < cols; d3++) {
738            for (var d4 = 0; d4 < cols; d4++) {
739              for (var d5 = 0; d5 < cols; d5++) {
740                for (var d6 = 0; d6 < cols; d6++) {
741                  var varName = $"{name}[{d1}, {d2}, {d3}, {d4}, {d5}, {d6}]";
742                  array[d1, d2, d3, d4, d5, d6] = solver.MakeNumVar(lb, ub, varName);
743                }
744              }
745            }
746          }
747        }
748      }
749
750      return array;
751    }
752
753    public static Variable[,] MakeVarArray(this Solver solver,
754      int rows, int cols, double lb, double ub, bool integer) =>
755      solver.MakeVarMatrix(rows, cols, lb, ub, integer);
756
757    public static Variable[,] MakeVarArray(this Solver solver,
758      int rows, int cols, double lb, double ub, bool integer, string name) =>
759      solver.MakeVarMatrix(rows, cols, lb, ub, integer, name);
760
761    public static Variable[,,] MakeVarArray(this Solver solver,
762      int rows, int cols, int dim3, double lb, double ub, bool integer) {
763      var array = new Variable[rows, cols, dim3];
764      for (var d1 = 0; d1 < rows; d1++) {
765        for (var d2 = 0; d2 < cols; d2++) {
766          for (var d3 = 0; d3 < cols; d3++) {
767            array[d1, d2, d3] = solver.MakeVar(lb, ub, integer, "");
768          }
769        }
770      }
771
772      return array;
773    }
774
775    public static Variable[,,] MakeVarArray(this Solver solver,
776      int rows, int cols, int dim3, double lb, double ub, bool integer, string name) {
777      var array = new Variable[rows, cols, dim3];
778      for (var d1 = 0; d1 < rows; d1++) {
779        for (var d2 = 0; d2 < cols; d2++) {
780          for (var d3 = 0; d3 < cols; d3++) {
781            var varName = $"{name}[{d1}, {d2}, {d3}]";
782            array[d1, d2, d3] = solver.MakeVar(lb, ub, integer, varName);
783          }
784        }
785      }
786
787      return array;
788    }
789
790    public static Variable[,,,] MakeVarArray(this Solver solver,
791      int rows, int cols, int dim3, int dim4, double lb, double ub, bool integer) {
792      var array = new Variable[rows, cols, dim3, dim4];
793      for (var d1 = 0; d1 < rows; d1++) {
794        for (var d2 = 0; d2 < cols; d2++) {
795          for (var d3 = 0; d3 < cols; d3++) {
796            for (var d4 = 0; d4 < cols; d4++) {
797              array[d1, d2, d3, d4] = solver.MakeVar(lb, ub, integer, "");
798            }
799          }
800        }
801      }
802
803      return array;
804    }
805
806    public static Variable[,,,] MakeVarArray(this Solver solver,
807      int rows, int cols, int dim3, int dim4, double lb, double ub, bool integer, string name) {
808      var array = new Variable[rows, cols, dim3, dim4];
809      for (var d1 = 0; d1 < rows; d1++) {
810        for (var d2 = 0; d2 < cols; d2++) {
811          for (var d3 = 0; d3 < cols; d3++) {
812            for (var d4 = 0; d4 < cols; d4++) {
813              var varName = $"{name}[{d1}, {d2}, {d3}, {d4}]";
814              array[d1, d2, d3, d4] = solver.MakeVar(lb, ub, integer, varName);
815            }
816          }
817        }
818      }
819
820      return array;
821    }
822
823    public static Variable[,,,,] MakeVarArray(this Solver solver,
824      int rows, int cols, int dim3, int dim4, int dim5, double lb, double ub, bool integer) {
825      var array = new Variable[rows, cols, dim3, dim4, dim5];
826      for (var d1 = 0; d1 < rows; d1++) {
827        for (var d2 = 0; d2 < cols; d2++) {
828          for (var d3 = 0; d3 < cols; d3++) {
829            for (var d4 = 0; d4 < cols; d4++) {
830              for (var d5 = 0; d5 < cols; d5++) {
831                array[d1, d2, d3, d4, d5] = solver.MakeVar(lb, ub, integer, "");
832              }
833            }
834          }
835        }
836      }
837
838      return array;
839    }
840
841    public static Variable[,,,,] MakeVarArray(this Solver solver,
842      int rows, int cols, int dim3, int dim4, int dim5, double lb, double ub, bool integer, string name) {
843      var array = new Variable[rows, cols, dim3, dim4, dim5];
844      for (var d1 = 0; d1 < rows; d1++) {
845        for (var d2 = 0; d2 < cols; d2++) {
846          for (var d3 = 0; d3 < cols; d3++) {
847            for (var d4 = 0; d4 < cols; d4++) {
848              for (var d5 = 0; d5 < cols; d5++) {
849                var varName = $"{name}[{d1}, {d2}, {d3}, {d4}, {d5}]";
850                array[d1, d2, d3, d4, d5] = solver.MakeVar(lb, ub, integer, varName);
851              }
852            }
853          }
854        }
855      }
856
857      return array;
858    }
859
860    public static Variable[,,,,,] MakeVarArray(this Solver solver,
861      int rows, int cols, int dim3, int dim4, int dim5, int dim6, double lb, double ub, bool integer) {
862      var array = new Variable[rows, cols, dim3, dim4, dim5, dim6];
863      for (var d1 = 0; d1 < rows; d1++) {
864        for (var d2 = 0; d2 < cols; d2++) {
865          for (var d3 = 0; d3 < cols; d3++) {
866            for (var d4 = 0; d4 < cols; d4++) {
867              for (var d5 = 0; d5 < cols; d5++) {
868                for (var d6 = 0; d6 < cols; d6++) {
869                  array[d1, d2, d3, d4, d5, d6] = solver.MakeVar(lb, ub, integer, "");
870                }
871              }
872            }
873          }
874        }
875      }
876
877      return array;
878    }
879
880    public static Variable[,,,,,] MakeVarArray(this Solver solver,
881      int rows, int cols, int dim3, int dim4, int dim5, int dim6, double lb, double ub, bool integer, string name) {
882      var array = new Variable[rows, cols, dim3, dim4, dim5, dim6];
883      for (var d1 = 0; d1 < rows; d1++) {
884        for (var d2 = 0; d2 < cols; d2++) {
885          for (var d3 = 0; d3 < cols; d3++) {
886            for (var d4 = 0; d4 < cols; d4++) {
887              for (var d5 = 0; d5 < cols; d5++) {
888                for (var d6 = 0; d6 < cols; d6++) {
889                  var varName = $"{name}[{d1}, {d2}, {d3}, {d4}, {d5}, {d6}]";
890                  array[d1, d2, d3, d4, d5, d6] = solver.MakeVar(lb, ub, integer, varName);
891                }
892              }
893            }
894          }
895        }
896      }
897
898      return array;
899    }
900  }
901}
Note: See TracBrowser for help on using the repository browser.