public void should_have_correct_number_of_unique_solutions(int n, int numSolutions) { var solver = new Solver(n); var results = solver.Solve(); Assert.AreEqual(numSolutions, results.Count); }
public FltGenerate( Solver solver, FltVar[] list, FltVarSelector.Select select, FltSearch search ) : base(solver) { m_FltVarList = list; m_SelectVar = select; m_Search = search; }
public FltGenerate( Solver solver, FltVar[] list ) : base(solver) { m_FltVarList = list; m_SelectVar = FltVarSelector.CardinalityMin; m_Search = new FltSearchDichotomize(); }
public static void Main(String[] args) { String problem = "ft10"; long timeout = 1000 * 60 * 10; String[] solverNames = new String[] { "sa", "ibb", "taboo" }; int i = 0; if (i < args.Length) problem = args[i++]; if (i < args.Length) timeout = Int32.Parse(args[i++]) * 1000; if (i < args.Length) { solverNames = new String[args.Length - i]; int j = 0; for (; i < args.Length; i++) { solverNames[j++] = args[i]; } } Network network = (new JSSPProblem(problem)).network(); if (network == null) return; //int opt = Solver.MINIMIZE | Solver.BETTER; int opt = Solver.Default; Solver[] solvers = new Solver[solverNames.Length]; for (i = 0; i < solvers.Length; i++) { String name = solverNames[i]; if (name.Equals("sa")) { solvers[i] = new SimulatedAnneallingSearch((Network)network.Clone(), opt, name); } else if (name.Equals("ibb")) { solvers[i] = new IterativeBranchAndBoundSearch((Network)network.Clone(), opt, name); } else if (name.Equals("taboo") || name.Equals("tabu")) { solvers[i] = new TabooSearch((Network)network.Clone(), opt, name); } else if (name.Equals("rw")) { solvers[i] = new LocalSearch((Network)network.Clone(), opt, name); } else { Console.Out.WriteLine("Unknown solver name " + name); solvers[i] = null; } } Solver all = new ParallelSolver(solvers); //Monitor monitor = new Monitor(); //monitor.setX(0, (int)(timeout/1000)); //all.setMonitor(monitor); //SolutionHandler sh=null; Solution solution = all.FindBest(timeout); Console.Out.WriteLine(solution); Console.In.ReadLine(); }
public static int Main() { for ( ; ; ) { int n = int.Parse(ReadLine()); if (n == 0) break; IList<string> stopWords = Enumerable.Range(0, n) .Select(_ => ReadLine().ToLowerInvariant()) .ToArray(); var testCases = Enumerable.Range(0, int.MaxValue) .Select(_ => ReadLine().ToLowerInvariant()) .TakeWhile(s => s != null && s != "last case") .Select(s => s.Split(new[]{ ' ' }, StringSplitOptions.RemoveEmptyEntries)) .Select(words => new { Acronym = words[0], Definition = words.Skip(1).Except(stopWords) }) .ToArray(); foreach (var testCase in testCases) { int solution = new Solver(testCase.Acronym, testCase.Definition).Solve(); if (solution == 0) WriteLine($"{testCase.Acronym.ToUpperInvariant()} is not a valid abbreviation"); else WriteLine($"{testCase.Acronym.ToUpperInvariant()} can be formed in {solution} ways"); } } return 0; }
public void Test_no_solution() { var value = 4; var capacities = new[] { 3, 5 }; var pouringGeneratorFactory = MockRepository.GenerateStrictMock<IPouringGeneratorFactory>(); var pouringGenerator = MockRepository.GenerateStrictMock<IPouringGenerator>(); var solver = new Solver( pouringGeneratorFactory ); pouringGeneratorFactory .Expect(f => f.Create(capacities.Length)) .Return(pouringGenerator); pouringGenerator .Stub(g => g.GetNextGeneration(null)) .IgnoreArguments() .Return(Enumerable.Empty<Pouring>()); var solutions = solver .SolutionSequence(value, capacities) .ToArray(); Assert.AreEqual(0, solutions.Length); }
/** * * A simple propagator for modulo constraint. * * This implementation is based on the ECLiPSe version * mentioned in "A Modulo propagator for ECLiPSE" * http://www.hakank.org/constraint_programming_blog/2010/05/a_modulo_propagator_for_eclips.html * The ECLiPSe Prolog source code: * http://www.hakank.org/eclipse/modulo_propagator.ecl * */ public static void MyMod(Solver solver, IntVar x, IntVar y, IntVar r) { long lbx = x.Min(); long ubx = x.Max(); long ubx_neg = -ubx; long lbx_neg = -lbx; int min_x = (int)Math.Min(lbx, ubx_neg); int max_x = (int)Math.Max(ubx, lbx_neg); IntVar d = solver.MakeIntVar(min_x, max_x, "d"); // r >= 0 solver.Add(r >= 0); // x*r >= 0 solver.Add( x*r >= 0); // -abs(y) < r solver.Add(-y.Abs() < r); // r < abs(y) solver.Add(r < y.Abs()); // min_x <= d, i.e. d > min_x solver.Add(d > min_x); // d <= max_x solver.Add(d <= max_x); // x == y*d+r solver.Add(x - (y*d + r) == 0); }
public static void minus(Solver solver, IntVar x, IntVar y, IntVar z) { solver.Add(z == (x - y).Abs()); }
/** * * Secret Santa problem in Google CP Solver. * * From Ruby Quiz Secret Santa * http://www.rubyquiz.com/quiz2.html * """ * Honoring a long standing tradition started by my wife's dad, my friends * all play a Secret Santa game around Christmas time. We draw names and * spend a week sneaking that person gifts and clues to our identity. On the * last night of the game, we get together, have dinner, share stories, and, * most importantly, try to guess who our Secret Santa was. It's a crazily * fun way to enjoy each other's company during the holidays. * * To choose Santas, we use to draw names out of a hat. This system was * tedious, prone to many 'Wait, I got myself...' problems. This year, we * made a change to the rules that further complicated picking and we knew * the hat draw would not stand up to the challenge. Naturally, to solve * this problem, I scripted the process. Since that turned out to be more * interesting than I had expected, I decided to share. * * This weeks Ruby Quiz is to implement a Secret Santa selection script. * * Your script will be fed a list of names on STDIN. * ... * Your script should then choose a Secret Santa for every name in the list. * Obviously, a person cannot be their own Secret Santa. In addition, my friends * no longer allow people in the same family to be Santas for each other and your * script should take this into account. * """ * * Comment: This model skips the file input and mail parts. We * assume that the friends are identified with a number from 1..n, * and the families is identified with a number 1..num_families. * * Also see http://www.hakank.org/or-tools/secret_santa.py * Also see http://www.hakank.org/or-tools/secret_santa2.cs * */ private static void Solve() { Solver solver = new Solver("SecretSanta"); int[] family = {1,1,1,1, 2, 3,3,3,3,3, 4,4}; int n = family.Length; Console.WriteLine("n = {0}", n); IEnumerable<int> RANGE = Enumerable.Range(0, n); // // Decision variables // IntVar[] x = solver.MakeIntVarArray(n, 0, n-1, "x"); // // Constraints // solver.Add(x.AllDifferent()); // Can't be one own"s Secret Santa // (i.e. ensure that there are no fix-point in the array.) foreach(int i in RANGE) { solver.Add(x[i] != i); } // No Secret Santa to a person in the same family foreach(int i in RANGE) { solver.Add(solver.MakeIntConst(family[i]) != family.Element(x[i])); } // // Search // DecisionBuilder db = solver.MakePhase(x, Solver.INT_VAR_SIMPLE, Solver.INT_VALUE_SIMPLE); solver.NewSearch(db); while (solver.NextSolution()) { Console.Write("x: "); foreach(int i in RANGE) { Console.Write(x[i].Value() + " "); } Console.WriteLine(); } Console.WriteLine("\nSolutions: {0}", solver.Solutions()); Console.WriteLine("WallTime: {0}ms", solver.WallTime()); Console.WriteLine("Failures: {0}", solver.Failures()); Console.WriteLine("Branches: {0} ", solver.Branches()); solver.EndSearch(); }
static void TestVarOperator() { Console.WriteLine("Running TestVarOperator"); Solver solver = new Solver("TestVarOperator", Solver.CLP_LINEAR_PROGRAMMING); Variable x = solver.MakeNumVar(0.0, 100.0, "x"); Constraint ct1 = solver.Add(x >= 1); Constraint ct2 = solver.Add(x <= 1); Constraint ct3 = solver.Add(x == 1); Constraint ct4 = solver.Add(1 >= x); Constraint ct5 = solver.Add(1 <= x); Constraint ct6 = solver.Add(1 == x); CheckDoubleEq(ct1.GetCoefficient(x), 1.0, "test1"); CheckDoubleEq(ct2.GetCoefficient(x), 1.0, "test2"); CheckDoubleEq(ct3.GetCoefficient(x), 1.0, "test3"); CheckDoubleEq(ct4.GetCoefficient(x), 1.0, "test4"); CheckDoubleEq(ct5.GetCoefficient(x), 1.0, "test5"); CheckDoubleEq(ct6.GetCoefficient(x), 1.0, "test6"); CheckDoubleEq(ct1.Lb(), 1.0, "test7"); CheckDoubleEq(ct1.Ub(), double.PositiveInfinity, "test8"); CheckDoubleEq(ct2.Lb(), double.NegativeInfinity, "test9"); CheckDoubleEq(ct2.Ub(), 1.0, "test10"); CheckDoubleEq(ct3.Lb(), 1.0, "test11"); CheckDoubleEq(ct3.Ub(), 1.0, "test12"); CheckDoubleEq(ct4.Lb(), double.NegativeInfinity, "test13"); CheckDoubleEq(ct4.Ub(), 1.0, "test14"); CheckDoubleEq(ct5.Lb(), 1.0, "test15"); CheckDoubleEq(ct5.Ub(), double.PositiveInfinity, "test16"); CheckDoubleEq(ct6.Lb(), 1.0, "test17"); CheckDoubleEq(ct6.Ub(), 1.0, "test18"); }
public void SolveBackPackProblemWith16RandomItems() { const int tests = 10; double bfFitness = 0.0; double gsFitness = 0.0; for (int n = 0; n < tests; n++) { var backPack = new BackPack(2000); var items = BackPackEnvironmentTest.RandomItems(16, backPack.Volume, 200); var environment = new BackPackEnvironment(backPack, items, 100); var solver = new Solver<BackPackIndividual>(environment); solver.Start(() => solver.CurrentGeneration > 10); var bf = BruteForce(environment); var gs = solver.CurrentOptimum; Console.WriteLine(environment.RateFitness(bf)); Console.WriteLine(environment.RateFitness(gs)); bfFitness += environment.RateFitness(bf); gsFitness += environment.RateFitness(gs); } // Should be atleast 90% of BF'ed fitness Console.WriteLine(gsFitness / bfFitness); Assert.IsTrue(bfFitness * 0.9 <= gsFitness); }
public void FillCellWithIntersectionOfKey() { IList<Line> columns = new List<Line> { new Line( new List<Clue>() ), new Line( new List<Clue>{new Clue( 2 )}), new Line( new List<Clue>{new Clue( 3 )}), new Line( new List<Clue>{new Clue( 1 )}), new Line( new List<Clue>() ) }; IList<Line> rows = new List<Line> { new Line( new List<Clue>() ), new Line( new List<Clue>{new Clue( 2 )}), new Line( new List<Clue>{new Clue( 3 )}), new Line( new List<Clue>{new Clue( 1 )}), new Line( new List<Clue>() ) }; var newField = new Field( columns, rows ); var solver = new Solver( columns, rows ); bool res = solver.CheckFilled( newField.Cells[2, 2] ); Assert.AreEqual( res, true ); res = solver.CheckFilled( newField.Cells[1, 2] ); Assert.AreEqual( res, false ); }
public void NotResolveEmptyPosition() { Position position = new Position(); Solver solver = new Solver(); Assert.IsNull(solver.Resolve(position)); }
public ActionResult Index(int k = 0) { int?[,] numbers = new int?[9, 9]; for (int i = 0; i < 9; i++) { for (int j = 0; j < 9; j++) { string key = string.Format("f{0}{1}", i, j); int number; if (int.TryParse(Request[key], out number)) numbers[i, j] = number; } } Game game = new Game(numbers); Solver solver = new Solver(); try { DateTime start = DateTime.Now; solver.Solve(game); DateTime end = DateTime.Now; ViewBag.Interval = string.Format("Solved in {0} ms.", end.Subtract(start).Milliseconds); } catch (InvalidGameException) { ViewBag.Message = "Invalid entry. There is no solution for the game!"; } ViewBag.Numbers = game.Numbers; return View(); }
/* * Decompositon of cumulative. * * Inspired by the MiniZinc implementation: * http://www.g12.csse.unimelb.edu.au/wiki/doku.php?id=g12:zinc:lib:minizinc:std:cumulative.mzn&s[]=cumulative * The MiniZinc decomposition is discussed in the paper: * A. Schutt, T. Feydy, P.J. Stuckey, and M. G. Wallace. * "Why cumulative decomposition is not as bad as it sounds." * Download: * http://www.cs.mu.oz.au/%7Epjs/rcpsp/papers/cp09-cu.pdf * http://www.cs.mu.oz.au/%7Epjs/rcpsp/cumu_lazyfd.pdf * * * Parameters: * * s: start_times assumption: IntVar[] * d: durations assumption: int[] * r: resources assumption: int[] * b: resource limit assumption: IntVar or int * * */ static void MyCumulative(Solver solver, IntVar[] s, int[] d, int[] r, IntVar b) { int[] tasks = (from i in Enumerable.Range(0, s.Length) where r[i] > 0 && d[i] > 0 select i).ToArray(); int times_min = tasks.Min(i => (int)s[i].Min()); int d_max = d.Max(); int times_max = tasks.Max(i => (int)s[i].Max() + d_max); for(int t = times_min; t <= times_max; t++) { ArrayList bb = new ArrayList(); foreach(int i in tasks) { bb.Add(((s[i] <= t) * (s[i] + d[i]> t) * r[i]).Var()); } solver.Add((bb.ToArray(typeof(IntVar)) as IntVar[]).Sum() <= b); } // Somewhat experimental: // This constraint is needed to constrain the upper limit of b. if (b is IntVar) { solver.Add(b <= r.Sum()); } }
public void SolverCanWinGamesButNotAll(string title, int rowStart, int colStart, GameState finalState, int rows, int cols, int[] minedCellsPositions) { var minedCells = new List<MineCell>(); for (int i = 0; i < minedCellsPositions.Length; i += 2) { minedCells.Add(new MineCell(minedCellsPositions[i], minedCellsPositions[i + 1])); } var mineField = new MineField(rows, cols, minedCells.ToArray()); var solver = new Solver(mineField); mineField.UncoverCell(rowStart, colStart); solver.UncoverGrid(); Assert.Equal(mineField.GameState, finalState); mineField.Reset(true); mineField.UncoverCell(rowStart, colStart); for (var i = 0; i < 100 && mineField.GameState == GameState.InProgress; i++) { solver.PlayNextStep(); } Assert.Equal(finalState, mineField.GameState); }
public void SolveCaseLarge() { Solver solver = new Solver(); solver.Solve(1091.73252, 0.2, 15.44421, 656.09352); solver.Solve(1.03291, 0.2, 99.49224, 99999.91210); }
public void SanityCheck_GivenInsaneDataDueToWrongNumberOfBlackAndWhiteSquares_ReturnsFalse() { // Arrange var board = new Board(TestBoardSize); var solver = new Solver(); var bogusPieceD = new Piece( new[] { // B // W // WW new Square(0, 0, Colour.White), new Square(1, 0, Colour.White), new Square(1, 1, Colour.White), new Square(1, 2, Colour.Black) }, 'D'); var pieceFeeder = new PieceFeeder(Piece.TestPieceA, Piece.TestPieceB, Piece.TestPieceC, bogusPieceD); // Act var actual = solver.SanityCheck(board, pieceFeeder); // Assert Assert.That(actual, Is.False); }
/** * * Solve the Least diff problem * For more info, see http://www.hakank.org/google_or_tools/least_diff.py * */ private static void Solve() { Solver solver = new Solver("LeastDiff"); // // Decision variables // IntVar A = solver.MakeIntVar(0, 9, "A"); IntVar B = solver.MakeIntVar(0, 9, "B"); IntVar C = solver.MakeIntVar(0, 9, "C"); IntVar D = solver.MakeIntVar(0, 9, "D"); IntVar E = solver.MakeIntVar(0, 9, "E"); IntVar F = solver.MakeIntVar(0, 9, "F"); IntVar G = solver.MakeIntVar(0, 9, "G"); IntVar H = solver.MakeIntVar(0, 9, "H"); IntVar I = solver.MakeIntVar(0, 9, "I"); IntVar J = solver.MakeIntVar(0, 9, "J"); IntVar[] all = new IntVar[] {A,B,C,D,E,F,G,H,I,J}; int[] coeffs = {10000,1000,100,10,1}; IntVar x = new IntVar[]{A,B,C,D,E}.ScalProd(coeffs).Var(); IntVar y = new IntVar[]{F,G,H,I,J}.ScalProd(coeffs).Var(); IntVar diff = (x - y).VarWithName("diff"); // // Constraints // solver.Add(all.AllDifferent()); solver.Add(A > 0); solver.Add(F > 0); solver.Add(diff > 0); // // Objective // OptimizeVar obj = diff.Minimize(1); // // Search // DecisionBuilder db = solver.MakePhase(all, Solver.CHOOSE_PATH, Solver.ASSIGN_MIN_VALUE); solver.NewSearch(db, obj); while (solver.NextSolution()) { Console.WriteLine("{0} - {1} = {2} ({3}",x.Value(), y.Value(), diff.Value(), diff.ToString()); } Console.WriteLine("\nSolutions: {0}", solver.Solutions()); Console.WriteLine("WallTime: {0}ms", solver.WallTime()); Console.WriteLine("Failures: {0}", solver.Failures()); Console.WriteLine("Branches: {0} ", solver.Branches()); solver.EndSearch(); }
public IntGenerate( Solver solver, IntVar[] list, IntVarSelector.Select select, IntSearch search ) : base(solver) { m_IntVarList = list; m_SelectVar = select; m_Search = search; m_Depth = new RevValue<double>( solver.StateStack, 1 ); }
public IntGenerate( Solver solver, IntVar[] list ) : base(solver) { m_IntVarList = list; m_SelectVar = IntVarSelector.CardinalityMin; m_Search = new IntSearchDichotomize(); m_Depth = new RevValue<double>( solver.StateStack, 1 ); }
// We don't need helper functions here // Csharp syntax is easier than C++ syntax! private static void CPisFun (int kBase) { // Constraint Programming engine Solver solver = new Solver ("CP is fun!"); // Decision variables IntVar c = solver.MakeIntVar (1, kBase - 1, "C"); IntVar p = solver.MakeIntVar (0, kBase - 1, "P"); IntVar i = solver.MakeIntVar (1, kBase - 1, "I"); IntVar s = solver.MakeIntVar (0, kBase - 1, "S"); IntVar f = solver.MakeIntVar (1, kBase - 1, "F"); IntVar u = solver.MakeIntVar (0, kBase - 1, "U"); IntVar n = solver.MakeIntVar (0, kBase - 1, "N"); IntVar t = solver.MakeIntVar (1, kBase - 1, "T"); IntVar r = solver.MakeIntVar (0, kBase - 1, "R"); IntVar e = solver.MakeIntVar (0, kBase - 1, "E"); // We need to group variables in a vector to be able to use // the global constraint AllDifferent IntVar[] letters = new IntVar[] { c, p, i, s, f, u, n, t, r, e}; // Check if we have enough digits if (kBase < letters.Length) { throw new Exception("kBase < letters.Length"); } // Constraints solver.Add (letters.AllDifferent ()); // CP + IS + FUN = TRUE solver.Add (p + s + n + kBase * (c + i + u) + kBase * kBase * f == e + kBase * u + kBase * kBase * r + kBase * kBase * kBase * t); SolutionCollector all_solutions = solver.MakeAllSolutionCollector(); // Add the interesting variables to the SolutionCollector all_solutions.Add(c); all_solutions.Add(p); // Create the variable kBase * c + p IntVar v1 = solver.MakeSum(solver.MakeProd(c, kBase), p).Var(); // Add it to the SolutionCollector all_solutions.Add(v1); // Decision Builder: hot to scour the search tree DecisionBuilder db = solver.MakePhase (letters, Solver.CHOOSE_FIRST_UNBOUND, Solver.ASSIGN_MIN_VALUE); solver.Solve(db, all_solutions); // Retrieve the solutions int numberSolutions = all_solutions.SolutionCount(); Console.WriteLine ("Number of solutions: " + numberSolutions); for (int index = 0; index < numberSolutions; ++index) { Assignment solution = all_solutions.Solution(index); Console.WriteLine ("Solution found:"); Console.WriteLine ("v1=" + solution.Value(v1)); } }
// // Decomposition of alldifferent_except_0 // public static void AllDifferentExcept0(Solver solver, IntVar[] a) { int n = a.Length; for(int i = 0; i < n; i++) { for(int j = 0; j < i; j++) { solver.Add((a[i] != 0) * (a[j] != 0) <= (a[i] != a[j])); } } }
public static IntVar[] subset_sum(Solver solver, int[] values, int total) { int n = values.Length; IntVar[] x = solver.MakeIntVarArray(n, 0, n, "x"); solver.Add(x.ScalProd(values) == total); return x; }
public FltVarMatrix( Solver solver, int rowCount, int colCount, FltDomain domain ) : base(solver) { m_VarList = null; m_RowCount = rowCount; m_ColCount = colCount; InitMatrix( domain ); }
/** * * Implements the all interval problem. * See http://www.hakank.org/google_or_tools/all_interval.py * */ private static void Solve(int n=12) { Solver solver = new Solver("AllInterval"); // // Decision variables // IntVar[] x = solver.MakeIntVarArray(n, 0, n-1, "x"); IntVar[] diffs = solver.MakeIntVarArray(n-1, 1, n-1, "diffs"); // // Constraints // solver.Add(x.AllDifferent()); solver.Add(diffs.AllDifferent()); for(int k = 0; k < n - 1; k++) { // solver.Add(diffs[k] == (x[k + 1] - x[k]).Abs()); solver.Add(diffs[k] == (x[k + 1] - x[k].Abs())); } // symmetry breaking solver.Add(x[0] < x[n - 1]); solver.Add(diffs[0] < diffs[1]); // // Search // DecisionBuilder db = solver.MakePhase(x, Solver.CHOOSE_FIRST_UNBOUND, Solver.ASSIGN_MIN_VALUE); solver.NewSearch(db); while (solver.NextSolution()) { Console.Write("x: "); for(int i = 0; i < n; i++) { Console.Write("{0} ", x[i].Value()); } Console.Write(" diffs: "); for(int i = 0; i < n-1; i++) { Console.Write("{0} ", diffs[i].Value()); } Console.WriteLine(); } Console.WriteLine("\nSolutions: {0}", solver.Solutions()); Console.WriteLine("WallTime: {0}ms", solver.WallTime()); Console.WriteLine("Failures: {0}", solver.Failures()); Console.WriteLine("Branches: {0} ", solver.Branches()); solver.EndSearch(); }
/** * Ensure that the sum of the segments * in cc == res * */ public static void calc(Solver solver, int[] cc, IntVar[,] x, int res) { int ccLen = cc.Length; if (ccLen == 4) { // for two operands there's // a lot of possible variants IntVar a = x[cc[0]-1, cc[1]-1]; IntVar b = x[cc[2]-1, cc[3]-1]; IntVar r1 = a + b == res; IntVar r2 = a * b == res; IntVar r3 = a * res == b; IntVar r4 = b * res == a; IntVar r5 = a - b == res; IntVar r6 = b - a == res; solver.Add(r1+r2+r3+r4+r5+r6 >= 1); } else { // For length > 2 then res is either the sum // the the product of the segment // sum the numbers int len = cc.Length / 2; IntVar[] xx = (from i in Enumerable.Range(0, len) select x[cc[i*2]-1,cc[i*2+1]-1]).ToArray(); // Sum IntVar this_sum = xx.Sum() == res; // Product // IntVar this_prod = (xx.Prod() == res).Var(); // don't work IntVar this_prod; if (xx.Length == 3) { this_prod = (x[cc[0]-1,cc[1]-1] * x[cc[2]-1,cc[3]-1] * x[cc[4]-1,cc[5]-1]) == res; } else { this_prod = ( x[cc[0]-1,cc[1]-1] * x[cc[2]-1,cc[3]-1] * x[cc[4]-1,cc[5]-1] * x[cc[6]-1,cc[7]-1]) == res; } solver.Add(this_sum + this_prod >= 1); } }
/** * * Scheduling speakers problem * * From Rina Dechter, Constraint Processing, page 72 * Scheduling of 6 speakers in 6 slots. * * See http://www.hakank.org/google_or_tools/scheduling_speakers.py * */ private static void Solve() { Solver solver = new Solver("SchedulingSpeakers"); // number of speakers int n = 6; // slots available to speak int[][] available = { // Reasoning: new int[] {3,4,5,6}, // 2) the only one with 6 after speaker F -> 1 new int[] {3,4}, // 5) 3 or 4 new int[] {2,3,4,5}, // 3) only with 5 after F -> 1 and A -> 6 new int[] {2,3,4}, // 4) only with 2 after C -> 5 and F -> 1 new int[] {3,4}, // 5) 3 or 4 new int[] {1,2,3,4,5,6} // 1) the only with 1 }; // // Decision variables // IntVar[] x = solver.MakeIntVarArray(n, 1, n, "x"); // // Constraints // solver.Add(x.AllDifferent()); for(int i = 0; i < n; i++) { solver.Add(x[i].Member(available[i])); } // // Search // DecisionBuilder db = solver.MakePhase(x, Solver.CHOOSE_FIRST_UNBOUND, Solver.ASSIGN_MIN_VALUE); solver.NewSearch(db); while (solver.NextSolution()) { Console.WriteLine(string.Join(",", (from i in x select i.Value()))); } Console.WriteLine("\nSolutions: {0}", solver.Solutions()); Console.WriteLine("WallTime: {0}ms", solver.WallTime()); Console.WriteLine("Failures: {0}", solver.Failures()); Console.WriteLine("Branches: {0} ", solver.Branches()); solver.EndSearch(); }
/* * Global constraint regular * * This is a translation of MiniZinc's regular constraint (defined in * lib/zinc/globals.mzn), via the Comet code refered above. * All comments are from the MiniZinc code. * """ * The sequence of values in array 'x' (which must all be in the range 1..S) * is accepted by the DFA of 'Q' states with input 1..S and transition * function 'd' (which maps (1..Q, 1..S) -> 0..Q)) and initial state 'q0' * (which must be in 1..Q) and accepting states 'F' (which all must be in * 1..Q). We reserve state 0 to be an always failing state. * """ * * x : IntVar array * Q : number of states * S : input_max * d : transition matrix * q0: initial state * F : accepting states * */ static void MyRegular(Solver solver, IntVar[] x, int Q, int S, int[,] d, int q0, int[] F) { Debug.Assert(Q > 0, "regular: 'Q' must be greater than zero"); Debug.Assert(S > 0, "regular: 'S' must be greater than zero"); // d2 is the same as d, except we add one extra transition for // each possible input; each extra transition is from state zero // to state zero. This allows us to continue even if we hit a // non-accepted input. int[][] d2 = new int[Q+1][]; for(int i = 0; i <= Q; i++) { int[] row = new int[S]; for(int j = 0; j < S; j++) { if (i == 0) { row[j] = 0; } else { row[j] = d[i-1,j]; } } d2[i] = row; } int[] d2_flatten = (from i in Enumerable.Range(0, Q+1) from j in Enumerable.Range(0, S) select d2[i][j]).ToArray(); // If x has index set m..n, then a[m-1] holds the initial state // (q0), and a[i+1] holds the state we're in after processing // x[i]. If a[n] is in F, then we succeed (ie. accept the // string). int m = 0; int n = x.Length; IntVar[] a = solver.MakeIntVarArray(n+1-m, 0,Q+1, "a"); // Check that the final state is in F solver.Add(a[a.Length-1].Member(F)); // First state is q0 solver.Add(a[m] == q0); for(int i = 0; i < n; i++) { solver.Add(x[i] >= 1); solver.Add(x[i] <= S); // Determine a[i+1]: a[i+1] == d2[a[i], x[i]] solver.Add(a[i+1] == d2_flatten.Element(((a[i]*S)+(x[i]-1)))); } }
public static void Main(string[] args) { Stream inputStream = Console.OpenStandardInput(); InputReader inp = new InputReader(inputStream); Stream outputStream = Console.OpenStandardOutput(); OutputWriter outp = new OutputWriter(outputStream); Solver algorithm = new Solver(); algorithm.solve(inp, outp); outp.close(); }
/** * * Solves a set covering deployment problem. * See See http://www.hakank.org/or-tools/set_covering_deployment.py * */ private static void Solve() { Solver solver = new Solver("SetCoveringDeployment"); // // data // // From http://mathworld.wolfram.com/SetCoveringDeployment.html string[] countries = { "Alexandria", "Asia Minor", "Britain", "Byzantium", "Gaul", "Iberia", "Rome", "Tunis" }; int n = countries.Length; // the incidence matrix (neighbours) int[,] mat = { { 0, 1, 0, 1, 0, 0, 1, 1 }, { 1, 0, 0, 1, 0, 0, 0, 0 }, { 0, 0, 0, 0, 1, 1, 0, 0 }, { 1, 1, 0, 0, 0, 0, 1, 0 }, { 0, 0, 1, 0, 0, 1, 1, 0 }, { 0, 0, 1, 0, 1, 0, 1, 1 }, { 1, 0, 0, 1, 1, 1, 0, 1 }, { 1, 0, 0, 0, 0, 1, 1, 0 } }; // // Decision variables // // First army IntVar[] x = solver.MakeIntVarArray(n, 0, 1, "x"); // Second (reserve) army IntVar[] y = solver.MakeIntVarArray(n, 0, 1, "y"); // total number of armies IntVar num_armies = (x.Sum() + y.Sum()).Var(); // // Constraints // // // Constraint 1: There is always an army in a city // (+ maybe a backup) // Or rather: Is there a backup, there // must be an an army // for (int i = 0; i < n; i++) { solver.Add(x[i] >= y[i]); } // // Constraint 2: There should always be an backup // army near every city // for (int i = 0; i < n; i++) { IntVar[] count_neighbours = ( from j in Enumerable.Range(0, n) where mat[i, j] == 1 select(y[j])).ToArray(); solver.Add((x[i] + count_neighbours.Sum()) >= 1); } // // objective // OptimizeVar objective = num_armies.Minimize(1); // // Search // DecisionBuilder db = solver.MakePhase(x, Solver.INT_VAR_DEFAULT, Solver.INT_VALUE_DEFAULT); solver.NewSearch(db, objective); while (solver.NextSolution()) { Console.WriteLine("num_armies: " + num_armies.Value()); for (int i = 0; i < n; i++) { if (x[i].Value() == 1) { Console.Write("Army: " + countries[i] + " "); } if (y[i].Value() == 1) { Console.WriteLine(" Reverse army: " + countries[i]); } } Console.WriteLine("\n"); } Console.WriteLine("\nSolutions: {0}", solver.Solutions()); Console.WriteLine("WallTime: {0}ms", solver.WallTime()); Console.WriteLine("Failures: {0}", solver.Failures()); Console.WriteLine("Branches: {0} ", solver.Branches()); solver.EndSearch(); }
public void InitializeDamage(Solver solver, bool areaEffect, int range, MagicSchool magicSchool, SpellData spellData, float hitProcs, float castProcs, float dotDuration) { InitializeDamage(solver, areaEffect, range, magicSchool, spellData.Cost, spellData.MinDamage, spellData.MaxDamage, spellData.SpellDamageCoefficient, spellData.PeriodicDamage, spellData.DotDamageCoefficient, hitProcs, castProcs, dotDuration); }
public void InitializeEffectDamage(Solver solver, MagicSchool magicSchool, float minDamage, float maxDamage) { Stats baseStats = solver.BaseStats; MageTalents mageTalents = solver.MageTalents; CalculationOptionsMage calculationOptions = solver.CalculationOptions; //AreaEffect = areaEffect; //BaseCost = cost - (int)baseStats.SpellsManaReduction; MagicSchool = magicSchool; BaseMinDamage = minDamage; BaseMaxDamage = maxDamage; //BasePeriodicDamage = periodicDamage; //SpellDamageCoefficient = spellDamageCoefficient; //Ticks = 1; //CastProcs = 0; //CastProcs2 = 0; //DotDamageCoefficient = dotDamageCoefficient; //DotDuration = dotDuration; BaseDirectDamageModifier = 1.0f; BaseDotDamageModifier = 1.0f; BaseCostModifier = 1.0f; //Range = range; /*float baseCostAmplifier = calculationOptions.EffectCostMultiplier; * baseCostAmplifier *= (1.0f - 0.01f * mageTalents.Precision); * if (mageTalents.FrostChanneling > 0) baseCostAmplifier *= (1.0f - 0.01f - 0.03f * mageTalents.FrostChanneling); * if (MagicSchool == MagicSchool.Arcane) baseCostAmplifier *= (1.0f - 0.01f * mageTalents.ArcaneFocus); * BaseCostAmplifier = baseCostAmplifier;*/ /*float baseInterruptProtection = baseStats.InterruptProtection; * if (MagicSchool == MagicSchool.Fire || MagicSchool == MagicSchool.FrostFire) * { * baseInterruptProtection += 0.35f * mageTalents.BurningSoul; * AffectedByFlameCap = true; * } * BaseInterruptProtection = baseInterruptProtection;*/ float realResistance; switch (MagicSchool) { case MagicSchool.Arcane: BaseSpellModifier = solver.BaseArcaneSpellModifier; BaseAdditiveSpellModifier = solver.BaseArcaneAdditiveSpellModifier; BaseCritRate = solver.BaseArcaneCritRate; CritBonus = solver.BaseArcaneCritBonus; HitRate = solver.BaseArcaneHitRate; ThreatMultiplier = solver.ArcaneThreatMultiplier; realResistance = calculationOptions.ArcaneResist; break; case MagicSchool.Fire: BaseSpellModifier = solver.BaseFireSpellModifier; BaseAdditiveSpellModifier = solver.BaseFireAdditiveSpellModifier; BaseCritRate = solver.BaseFireCritRate; CritBonus = solver.BaseFireCritBonus; HitRate = solver.BaseFireHitRate; ThreatMultiplier = solver.FireThreatMultiplier; realResistance = calculationOptions.FireResist; BaseDotDamageModifier = 1.0f + solver.FlashburnBonus; break; case MagicSchool.FrostFire: BaseSpellModifier = solver.BaseFrostFireSpellModifier; BaseAdditiveSpellModifier = solver.BaseFrostFireAdditiveSpellModifier; BaseCritRate = solver.BaseFrostFireCritRate; CritBonus = solver.BaseFrostFireCritBonus; HitRate = solver.BaseFrostFireHitRate; ThreatMultiplier = solver.FrostFireThreatMultiplier; if (calculationOptions.FireResist == -1) { realResistance = calculationOptions.FrostResist; } else if (calculationOptions.FrostResist == -1) { realResistance = calculationOptions.FireResist; } else { realResistance = Math.Min(calculationOptions.FireResist, calculationOptions.FrostResist); } BaseDotDamageModifier = 1.0f + solver.FlashburnBonus; break; case MagicSchool.Frost: BaseSpellModifier = solver.BaseFrostSpellModifier; BaseAdditiveSpellModifier = solver.BaseFrostAdditiveSpellModifier; BaseCritRate = solver.BaseFrostCritRate; CritBonus = solver.BaseFrostCritBonus; HitRate = solver.BaseFrostHitRate; ThreatMultiplier = solver.FrostThreatMultiplier; realResistance = calculationOptions.FrostResist; break; case MagicSchool.Nature: BaseSpellModifier = solver.BaseNatureSpellModifier; BaseAdditiveSpellModifier = solver.BaseNatureAdditiveSpellModifier; BaseCritRate = solver.BaseNatureCritRate; CritBonus = solver.BaseNatureCritBonus; HitRate = solver.BaseNatureHitRate; ThreatMultiplier = solver.NatureThreatMultiplier; realResistance = calculationOptions.NatureResist; break; case MagicSchool.Shadow: BaseSpellModifier = solver.BaseShadowSpellModifier; BaseAdditiveSpellModifier = solver.BaseShadowAdditiveSpellModifier; BaseCritRate = solver.BaseShadowCritRate; CritBonus = solver.BaseShadowCritBonus; HitRate = solver.BaseShadowHitRate; ThreatMultiplier = solver.ShadowThreatMultiplier; realResistance = calculationOptions.ShadowResist; break; case MagicSchool.Holy: default: BaseSpellModifier = solver.BaseHolySpellModifier; BaseAdditiveSpellModifier = solver.BaseHolyAdditiveSpellModifier; BaseCritRate = solver.BaseHolyCritRate; CritBonus = solver.BaseHolyCritBonus; HitRate = solver.BaseHolyHitRate; ThreatMultiplier = solver.HolyThreatMultiplier; realResistance = calculationOptions.HolyResist; break; } NonHSCritRate = baseStats.SpellCritOnTarget; IgniteFactor = 0; int playerLevel = calculationOptions.PlayerLevel; int targetLevel = calculationOptions.TargetLevel; /*if (areaEffect) * { * targetLevel = calculationOptions.AoeTargetLevel; * float hitRate = ((targetLevel <= playerLevel + 2) ? (0.96f - (targetLevel - playerLevel) * 0.01f) : (0.94f - (targetLevel - playerLevel - 2) * 0.11f)) + calculations.BaseSpellHit; * if (MagicSchool == MagicSchool.Arcane) hitRate += 0.01f * mageTalents.ArcaneFocus; * if (hitRate > Spell.MaxHitRate) hitRate = Spell.MaxHitRate; * HitRate = hitRate; * } * else * { * targetLevel = calculationOptions.TargetLevel; * }*/ RealResistance = realResistance; PartialResistFactor = (realResistance == -1) ? 0 : (1 - StatConversion.GetAverageResistance(playerLevel, targetLevel, realResistance, baseStats.SpellPenetration)); }
/** * * Sicherman Dice. * * From http://en.wikipedia.org/wiki/Sicherman_dice * "" * Sicherman dice are the only pair of 6-sided dice which are not normal dice, * bear only positive integers, and have the same probability distribution for * the sum as normal dice. * * The faces on the dice are numbered 1, 2, 2, 3, 3, 4 and 1, 3, 4, 5, 6, 8. * "" * * I read about this problem in a book/column by Martin Gardner long * time ago, and got inspired to model it now by the WolframBlog post * "Sicherman Dice": http://blog.wolfram.com/2010/07/13/sicherman-dice/ * * This model gets the two different ways, first the standard way and * then the Sicherman dice: * * x1 = [1, 2, 3, 4, 5, 6] * x2 = [1, 2, 3, 4, 5, 6] * ---------- * x1 = [1, 2, 2, 3, 3, 4] * x2 = [1, 3, 4, 5, 6, 8] * * * Extra: If we also allow 0 (zero) as a valid value then the * following two solutions are also valid: * * x1 = [0, 1, 1, 2, 2, 3] * x2 = [2, 4, 5, 6, 7, 9] * ---------- * x1 = [0, 1, 2, 3, 4, 5] * x2 = [2, 3, 4, 5, 6, 7] * * These two extra cases are mentioned here: * http://mathworld.wolfram.com/SichermanDice.html * * * Also see http://www.hakank.org/or-tools/sicherman_dice.py * */ private static void Solve() { Solver solver = new Solver("SichermanDice"); // // Data // int n = 6; int m = 10; int lowest_value = 0; // standard distribution int[] standard_dist = { 1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1 }; IEnumerable <int> RANGE = Enumerable.Range(0, n); IEnumerable <int> RANGE1 = Enumerable.Range(0, n - 1); // // Decision variables // IntVar[] x1 = solver.MakeIntVarArray(n, lowest_value, m, "x1"); IntVar[] x2 = solver.MakeIntVarArray(n, lowest_value, m, "x2"); // // Constraints // for (int k = 0; k < standard_dist.Length; k++) { solver.Add((from i in RANGE from j in RANGE select x1[i] + x2[j] == k + 2 ).ToArray().Sum() == standard_dist[k]); } // symmetry breaking foreach (int i in RANGE1) { solver.Add(x1[i] <= x1[i + 1]); solver.Add(x2[i] <= x2[i + 1]); solver.Add(x1[i] <= x2[i]); } // // Search // DecisionBuilder db = solver.MakePhase(x1.Concat(x2).ToArray(), Solver.INT_VAR_DEFAULT, Solver.INT_VALUE_DEFAULT); solver.NewSearch(db); while (solver.NextSolution()) { Console.Write("x1: "); foreach (int i in RANGE) { Console.Write(x1[i].Value() + " "); } Console.Write("\nx2: "); foreach (int i in RANGE) { Console.Write(x2[i].Value() + " "); } Console.WriteLine("\n"); } Console.WriteLine("\nSolutions: {0}", solver.Solutions()); Console.WriteLine("WallTime: {0}ms", solver.WallTime()); Console.WriteLine("Failures: {0}", solver.Failures()); Console.WriteLine("Branches: {0} ", solver.Branches()); solver.EndSearch(); }
protected void Button1_Click(object sender, EventArgs e) { Solver.CeroDivision(); TextBox1.Text = "Se guardo una nueva excepcion en: " + WebConfigurationManager.AppSettings["Exeptions"]; }
protected IntVarExpr(Solver solver, Variable[] varList) : base(solver, varList) { }
public object SolvePart1() { return(Solver.TreesCount(_cells, 3, 1)); }
public Individual <List <Genome>, Problem, Fitness> CrossOver( Solver <List <Genome>, Problem, Fitness> solver, Individual <List <Genome>, Problem, Fitness> parent1, Individual <List <Genome>, Problem, Fitness> parent2) { throw new NotImplementedException("Not re-implemented after refactoring GA"); //List<Genome> genomes = null; //Individual new_individual = new Individual(); //List<Genome> parent1_genomes = parent1.Copy().Genomes; //List<Genome> parent2_genomes = parent2.Copy().Genomes; //// select the 'best' genomes. //genomes = new List<Genome>(); //while (parent1_genomes.Count > 0 || parent2_genomes.Count > 0) //{ // // try from parent 1 // Genome genome = null; // if (parent1_genomes.Count > 0) // { // genome = parent1_genomes[StaticRandomGenerator.Get().Generate(parent1_genomes.Count)]; // if (!IndividualHelper.Overlaps(genomes, genome)) // { // genomes.Add(genome); // } // parent1_genomes.Remove(genome); // } // if (parent2_genomes.Count > 0) // { // genome = parent2_genomes[StaticRandomGenerator.Get().Generate(parent2_genomes.Count)]; // if (!IndividualHelper.Overlaps(genomes, genome)) // { // genomes.Add(genome); // } // parent2_genomes.Remove(genome); // } //} //// list the rest of the cities and divide them into new routes. //List<int> rest = new List<int>(); //for (int city_to_place = 0; city_to_place < solver.Problem.Cities; city_to_place++) //{ // if (!IndividualHelper.Overlaps(genomes, city_to_place)) // { // rest.Add(city_to_place); // } //} //// create the new individual. //new_individual.Initialize(genomes); //new_individual.CalculateFitness( // solver.Problem, // solver.FitnessCalculator, // false); //// TODO: place the rest of the cities in existing rounds. //List<int> failed = new List<int>(); //while (rest.Count > 0) //{ // // select random from current. // int current_city = rest[StaticRandomGenerator.Get().Generate( // rest.Count)]; // rest.Remove(current_city); // // make a list of potential targets. // List<Genome> potential_genomes = new List<Genome>(); // for (int round_idx = 0; round_idx < genomes.Count; round_idx++) // { // if (new_individual.Fitness.LargestRoundCategories[round_idx] == 0) // { // potential_genomes.Add(new_individual.Genomes[round_idx]); // } // } // // try to place the current city in one of the targets. // bool succes = false; // while (potential_genomes.Count > 0) // { // int random_idx = StaticRandomGenerator.Get().Generate(potential_genomes.Count); // Genome current = potential_genomes[random_idx]; // int genome_idx = new_individual.Genomes.IndexOf(current); // current = new Genome(current); // potential_genomes.RemoveAt(random_idx); // Individual<List<Genome>, Problem, Fitness> copy = new_individual.Copy(); // OsmSharp.Math.VRP.MultiSalesman.Genetic.Helpers.BestPlacementHelper.BestPlacementResult result = // BestPlacementHelper.CalculateBestPlacementInGenome( // solver.Problem, // solver.FitnessCalculator as FitnessCalculator, // current, // current_city); // // do the placement. // IndividualHelper.PlaceInGenome( // current, // result.CityIdx, // result.City); // // re-calculate fitness // copy.Genomes[genome_idx] = current; // copy.CalculateFitness(solver.Problem, solver.FitnessCalculator, false); // // if the round is still not too big; keep the result. // if (copy.Fitness.LargestRoundCategories[genome_idx] == 0) // { // new_individual = (copy as Individual); // succes = true; // break; // } // } // // add to failed if not succesfull // if (!succes) // { // failed.Add(current_city); // } //} //rest = failed; //bool new_round = true; //Genome current_round = null; //double previous_time = 0; //while (rest.Count > 0) //{ // // create a new round if needed. // int city; // int city_idx; // // force placement if less than half of the average round size remains. // int size = solver.Problem.Cities / new_individual.Genomes.Count; // if (new_round && rest.Count < size / 2) // { // new_individual = BestPlacementHelper.DoFast( // solver.Problem, // solver.FitnessCalculator as FitnessCalculator, // new_individual, // rest); // rest.Clear(); // break; // } // if (new_round) // { // new_round = false; // current_round = new Genome(); // new_individual.Genomes.Add(current_round); // // select a random city to place. // city_idx = StaticRandomGenerator.Get().Generate(rest.Count); // city = rest[city_idx]; // rest.RemoveAt(city_idx); // current_round.Add(city); // previous_time = solver.Problem.TargetTime.Value; // } // if (rest.Count > 0) // { // // find the best city to place next. // // calculate the best position to place the next city. // BestPlacementHelper.BestPlacementResult new_position_to_place = // BestPlacementHelper.CalculateBestPlacementInGenome( // solver.Problem, // solver.FitnessCalculator as FitnessCalculator, // current_round, // rest); // city = new_position_to_place.City; // // remove the node from the source list. // rest.Remove(city); // // place the node. // current_round.Insert(new_position_to_place.CityIdx, new_position_to_place.City); // // calculate the time. // double time = (solver.FitnessCalculator as FitnessCalculator).CalculateTime( // solver.Problem, current_round); // if (solver.Problem.TargetTime.Value < time) // { // time limit has been reached. // double diff_average = time - solver.Problem.TargetTime.Value; // double diff_previous = solver.Problem.TargetTime.Value - previous_time; // if (diff_average > diff_previous) // { // remove the last added city. // current_round.Remove(city); // rest.Add(city); // } // else // { // keep the last city. // } // // keep the generated round. // new_round = true; // } // previous_time = time; // } //} //new_individual.CalculateFitness( // solver.Problem, // solver.FitnessCalculator); //return new_individual; }
public static void Main(String[] args) { // Instantiate the solver. // [START solver] Solver solver = new Solver("CP is fun!"); // [END solver] // [START variables] const int kBase = 10; // Decision variables. IntVar c = solver.MakeIntVar(1, kBase - 1, "C"); IntVar p = solver.MakeIntVar(0, kBase - 1, "P"); IntVar i = solver.MakeIntVar(1, kBase - 1, "I"); IntVar s = solver.MakeIntVar(0, kBase - 1, "S"); IntVar f = solver.MakeIntVar(1, kBase - 1, "F"); IntVar u = solver.MakeIntVar(0, kBase - 1, "U"); IntVar n = solver.MakeIntVar(0, kBase - 1, "N"); IntVar t = solver.MakeIntVar(1, kBase - 1, "T"); IntVar r = solver.MakeIntVar(0, kBase - 1, "R"); IntVar e = solver.MakeIntVar(0, kBase - 1, "E"); // Group variables in a vector so that we can use AllDifferent. IntVar[] letters = new IntVar[] { c, p, i, s, f, u, n, t, r, e }; // Verify that we have enough digits. if (kBase < letters.Length) { throw new Exception("kBase < letters.Length"); } // [END variables] // Define constraints. // [START constraints] solver.Add(letters.AllDifferent()); // CP + IS + FUN = TRUE solver.Add(p + s + n + kBase * (c + i + u) + kBase * kBase * f == e + kBase * u + kBase * kBase * r + kBase * kBase * kBase * t); // [END constraints] // [START solve] int SolutionCount = 0; // Create the decision builder to search for solutions. DecisionBuilder db = solver.MakePhase(letters, Solver.CHOOSE_FIRST_UNBOUND, Solver.ASSIGN_MIN_VALUE); solver.NewSearch(db); while (solver.NextSolution()) { Console.Write("C=" + c.Value() + " P=" + p.Value()); Console.Write(" I=" + i.Value() + " S=" + s.Value()); Console.Write(" F=" + f.Value() + " U=" + u.Value()); Console.Write(" N=" + n.Value() + " T=" + t.Value()); Console.Write(" R=" + r.Value() + " E=" + e.Value()); Console.WriteLine(); // Is CP + IS + FUN = TRUE? if (p.Value() + s.Value() + n.Value() + kBase * (c.Value() + i.Value() + u.Value()) + kBase * kBase * f.Value() != e.Value() + kBase * u.Value() + kBase * kBase * r.Value() + kBase * kBase * kBase * t.Value()) { throw new Exception("CP + IS + FUN != TRUE"); } SolutionCount++; } solver.EndSearch(); Console.WriteLine($"Number of solutions found: {SolutionCount}"); // [END solve] }
/** * * Combinatorial auction. * * This is a more general model for the combinatorial example * in the Numberjack Tutorial, pages 9 and 24 (slides 19/175 and * 51/175). * * See http://www.hakank.org/or-tools/combinatorial_auction2.py * * The original and more talkative model is here: * http://www.hakank.org/numberjack/combinatorial_auction.py * */ private static void Solve() { Solver solver = new Solver("CombinatorialAuction2"); // // Data // int n = 5; // the items for each bid int[][] items = { new int[] { 0, 1 }, // A,B new int[] { 0, 2 }, // A, C new int[] { 1, 3 }, // B,D new int[] { 1,2, 3 }, // B,C,D new int[] { 0 } // A }; int[] bid_ids = { 0, 1, 2, 3 }; int[] bid_amount = { 10, 20, 30, 40, 14 }; // // Decision variables // IntVar[] x = solver.MakeIntVarArray(n, 0, 1, "x"); IntVar z = x.ScalProd(bid_amount).VarWithName("z"); // // Constraints // foreach (int bid_id in bid_ids) { var tmp2 = (from item in Enumerable.Range(0, n) from i in Enumerable.Range(0, items[item].Length) where items [item] [i] == bid_id select x[item]); solver.Add(tmp2.ToArray().Sum() <= 1); } // // Objective // OptimizeVar obj = z.Maximize(1); // // Search // DecisionBuilder db = solver.MakePhase(x, Solver.CHOOSE_FIRST_UNBOUND, Solver.ASSIGN_MIN_VALUE); solver.NewSearch(db, obj); while (solver.NextSolution()) { Console.Write("z: {0,2} x: ", z.Value()); for (int i = 0; i < n; i++) { Console.Write(x[i].Value() + " "); } Console.WriteLine(); } Console.WriteLine("\nSolutions: {0}", solver.Solutions()); Console.WriteLine("WallTime: {0}ms", solver.WallTime()); Console.WriteLine("Failures: {0}", solver.Failures()); Console.WriteLine("Branches: {0} ", solver.Branches()); solver.EndSearch(); }
/** * * Solves the N-Queens problem. * * Syntax: nqueens.exe n num print * where * n : size of board * num : number of solutions to calculate * print: print the results (if > 0) * */ private static void Solve(int n = 8, int num = 0, int print = 1) { Solver solver = new Solver("N-Queens"); // // Decision variables // IntVar[] q = solver.MakeIntVarArray(n, 0, n - 1, "q"); // // Constraints // solver.Add(q.AllDifferent()); IntVar[] q1 = new IntVar[n]; IntVar[] q2 = new IntVar[n]; for (int i = 0; i < n; i++) { q1[i] = (q[i] + i).Var(); q2[i] = (q[i] - i).Var(); } solver.Add(q1.AllDifferent()); solver.Add(q2.AllDifferent()); // Alternative version: it works as well but are not that clear /* * solver.Add((from i in Enumerable.Range(0, n) * select (q[i] + i).Var()).ToArray().AllDifferent()); * * solver.Add((from i in Enumerable.Range(0, n) * select (q[i] - i).Var()).ToArray().AllDifferent()); */ // // Search // DecisionBuilder db = solver.MakePhase(q, Solver.CHOOSE_MIN_SIZE_LOWEST_MAX, Solver.ASSIGN_CENTER_VALUE); solver.NewSearch(db); int c = 0; while (solver.NextSolution()) { if (print > 0) { for (int i = 0; i < n; i++) { Console.Write("{0} ", q[i].Value()); } Console.WriteLine(); } c++; if (num > 0 && c >= num) { break; } } Console.WriteLine("\nSolutions: {0}", solver.Solutions()); Console.WriteLine("WallTime: {0}ms", solver.WallTime()); Console.WriteLine("Failures: {0}", solver.Failures()); Console.WriteLine("Branches: {0} ", solver.Branches()); solver.EndSearch(); }
static void Main(string[] args) { Solver s = new Solver(); s.Solve(); }
///<summary> /// Removes a space object from the simulation. ///</summary> ///<param name="spaceObject">Space object to remove.</param> public void Remove(ISpaceObject spaceObject) { if (spaceObject.Space != this) { throw new ArgumentException("The object does not belong to this space; cannot remove it."); } SimulationIslandMember simulationIslandMember = spaceObject as SimulationIslandMember; if (simulationIslandMember != null) { DeactivationManager.Remove(simulationIslandMember); } ISimulationIslandMemberOwner simulationIslandMemberOwner = spaceObject as ISimulationIslandMemberOwner; if (simulationIslandMemberOwner != null) { DeactivationManager.Remove(simulationIslandMemberOwner.ActivityInformation); } //Go through each stage, removing the space object from it if necessary. IForceUpdateable velocityUpdateable = spaceObject as IForceUpdateable; if (velocityUpdateable != null) { ForceUpdater.Remove(velocityUpdateable); } MobileCollidable boundingBoxUpdateable = spaceObject as MobileCollidable; if (boundingBoxUpdateable != null) { BoundingBoxUpdater.Remove(boundingBoxUpdateable); } BroadPhaseEntry broadPhaseEntry = spaceObject as BroadPhaseEntry; if (broadPhaseEntry != null) { BroadPhase.Remove(broadPhaseEntry); } //Entites own collision proxies, but are not entries themselves. IBroadPhaseEntryOwner broadPhaseEntryOwner = spaceObject as IBroadPhaseEntryOwner; if (broadPhaseEntryOwner != null) { BroadPhase.Remove(broadPhaseEntryOwner.Entry); boundingBoxUpdateable = broadPhaseEntryOwner.Entry as MobileCollidable; if (boundingBoxUpdateable != null) { BoundingBoxUpdater.Remove(boundingBoxUpdateable); } } SolverUpdateable solverUpdateable = spaceObject as SolverUpdateable; if (solverUpdateable != null) { Solver.Remove(solverUpdateable); } IPositionUpdateable integrable = spaceObject as IPositionUpdateable; if (integrable != null) { PositionUpdater.Remove(integrable); } Entity entity = spaceObject as Entity; if (entity != null) { BufferedStates.Remove(entity); } IDeferredEventCreator deferredEventCreator = spaceObject as IDeferredEventCreator; if (deferredEventCreator != null) { DeferredEventDispatcher.RemoveEventCreator(deferredEventCreator); } IDeferredEventCreatorOwner deferredEventCreatorOwner = spaceObject as IDeferredEventCreatorOwner; if (deferredEventCreatorOwner != null) { DeferredEventDispatcher.RemoveEventCreator(deferredEventCreatorOwner.EventCreator); } //Updateable stages. IDuringForcesUpdateable duringForcesUpdateable = spaceObject as IDuringForcesUpdateable; if (duringForcesUpdateable != null) { DuringForcesUpdateables.Remove(duringForcesUpdateable); } IBeforeNarrowPhaseUpdateable beforeNarrowPhaseUpdateable = spaceObject as IBeforeNarrowPhaseUpdateable; if (beforeNarrowPhaseUpdateable != null) { BeforeNarrowPhaseUpdateables.Remove(beforeNarrowPhaseUpdateable); } IBeforeSolverUpdateable beforeSolverUpdateable = spaceObject as IBeforeSolverUpdateable; if (beforeSolverUpdateable != null) { BeforeSolverUpdateables.Remove(beforeSolverUpdateable); } IBeforePositionUpdateUpdateable beforePositionUpdateUpdateable = spaceObject as IBeforePositionUpdateUpdateable; if (beforePositionUpdateUpdateable != null) { BeforePositionUpdateUpdateables.Remove(beforePositionUpdateUpdateable); } IEndOfTimeStepUpdateable endOfStepUpdateable = spaceObject as IEndOfTimeStepUpdateable; if (endOfStepUpdateable != null) { EndOfTimeStepUpdateables.Remove(endOfStepUpdateable); } IEndOfFrameUpdateable endOfFrameUpdateable = spaceObject as IEndOfFrameUpdateable; if (endOfFrameUpdateable != null) { EndOfFrameUpdateables.Remove(endOfFrameUpdateable); } spaceObject.Space = null; spaceObject.OnRemovalFromSpace(this); }
internal ReceiveAssignmentEventArgs(Solver solver) : base(solver) { }
/** * * Secret Santa problem in Google CP Solver. * * From Ruby Quiz Secret Santa * http://www.rubyquiz.com/quiz2.html * """ * Honoring a long standing tradition started by my wife's dad, my friends * all play a Secret Santa game around Christmas time. We draw names and * spend a week sneaking that person gifts and clues to our identity. On the * last night of the game, we get together, have dinner, share stories, and, * most importantly, try to guess who our Secret Santa was. It's a crazily * fun way to enjoy each other's company during the holidays. * * To choose Santas, we use to draw names out of a hat. This system was * tedious, prone to many 'Wait, I got myself...' problems. This year, we * made a change to the rules that further complicated picking and we knew * the hat draw would not stand up to the challenge. Naturally, to solve * this problem, I scripted the process. Since that turned out to be more * interesting than I had expected, I decided to share. * * This weeks Ruby Quiz is to implement a Secret Santa selection script. * * Your script will be fed a list of names on STDIN. * ... * Your script should then choose a Secret Santa for every name in the list. * Obviously, a person cannot be their own Secret Santa. In addition, my friends * no longer allow people in the same family to be Santas for each other and your * script should take this into account. * """ * * Comment: This model skips the file input and mail parts. We * assume that the friends are identified with a number from 1..n, * and the families is identified with a number 1..num_families. * * Also see http://www.hakank.org/or-tools/secret_santa.py * Also see http://www.hakank.org/or-tools/secret_santa2.cs * */ private static void Solve() { Solver solver = new Solver("SecretSanta"); int[] family = { 1, 1, 1, 1, 2, 3, 3, 3, 3, 3, 4, 4 }; int n = family.Length; Console.WriteLine("n = {0}", n); IEnumerable <int> RANGE = Enumerable.Range(0, n); // // Decision variables // IntVar[] x = solver.MakeIntVarArray(n, 0, n - 1, "x"); // // Constraints // solver.Add(x.AllDifferent()); // Can't be one own"s Secret Santa // (i.e. ensure that there are no fix-point in the array.) foreach (int i in RANGE) { solver.Add(x[i] != i); } // No Secret Santa to a person in the same family foreach (int i in RANGE) { solver.Add(solver.MakeIntConst(family[i]) != family.Element(x[i])); } // // Search // DecisionBuilder db = solver.MakePhase(x, Solver.INT_VAR_SIMPLE, Solver.INT_VALUE_SIMPLE); solver.NewSearch(db); while (solver.NextSolution()) { Console.Write("x: "); foreach (int i in RANGE) { Console.Write(x[i].Value() + " "); } Console.WriteLine(); } Console.WriteLine("\nSolutions: {0}", solver.Solutions()); Console.WriteLine("WallTime: {0}ms", solver.WallTime()); Console.WriteLine("Failures: {0}", solver.Failures()); Console.WriteLine("Branches: {0} ", solver.Branches()); solver.EndSearch(); }
internal ReceiveAssignmentEventArgs(Solver solver, Assignment assignment) : base(solver) { Assignment = assignment; }
/** * * Ski assignment in Google CP Solver. * * From Jeffrey Lee Hellrung, Jr.: * PIC 60, Fall 2008 Final Review, December 12, 2008 * http://www.math.ucla.edu/~jhellrun/course_files/Fall%25202008/PIC%252060%2520-%2520Data%2520Structures%2520and%2520Algorithms/final_review.pdf * """ * 5. Ski Optimization! Your job at Snapple is pleasant but in the winter * you've decided to become a ski bum. You've hooked up with the Mount * Baldy Ski Resort. They'll let you ski all winter for free in exchange * for helping their ski rental shop with an algorithm to assign skis to * skiers. Ideally, each skier should obtain a pair of skis whose height * matches his or her own height exactly. Unfortunately, this is generally * not possible. We define the disparity between a skier and his or her * skis to be the absolute value of the difference between the height of * the skier and the pair of skis. Our objective is to find an assignment * of skis to skiers that minimizes the sum of the disparities. * ... * Illustrate your algorithm by explicitly filling out the A[i, j] table * for the following sample data: * - Ski heights : 1, 2, 5, 7, 13, 21. * - Skier heights: 3, 4, 7, 11, 18. * """ * * Also see http://www.hakank.org/or-tools/ski_assignment.py * * */ private static void Solve() { Solver solver = new Solver("SkiAssignment"); // // Data // int num_skis = 6; int num_skiers = 5; int[] ski_heights = { 1, 2, 5, 7, 13, 21 }; int[] skier_heights = { 3, 4, 7, 11, 18 }; // // Decision variables // IntVar[] x = solver.MakeIntVarArray(num_skiers, 0, num_skis - 1, "x"); // // Constraints // solver.Add(x.AllDifferent()); IntVar[] z_tmp = new IntVar[num_skiers]; for (int i = 0; i < num_skiers; i++) { z_tmp[i] = (ski_heights.Element(x[i]) - skier_heights[i]).Abs().Var(); } // IntVar z = solver.MakeIntVar(0, ski_heights.Sum(), "z"); // solver.Add(z_tmp.Sum() == z); // The direct cast from IntExpr to IntVar is potentially faster than // the above code. IntVar z = z_tmp.Sum().VarWithName("z"); // // Objective // OptimizeVar obj = z.Minimize(1); // // Search // DecisionBuilder db = solver.MakePhase(x, Solver.CHOOSE_FIRST_UNBOUND, Solver.INT_VALUE_DEFAULT); solver.NewSearch(db, obj); while (solver.NextSolution()) { Console.Write("z: {0} x: ", z.Value()); for (int i = 0; i < num_skiers; i++) { Console.Write(x[i].Value() + " "); } Console.WriteLine(); } Console.WriteLine("\nSolutions: {0}", solver.Solutions()); Console.WriteLine("WallTime: {0}ms", solver.WallTime()); Console.WriteLine("Failures: {0}", solver.Failures()); Console.WriteLine("Branches: {0} ", solver.Branches()); solver.EndSearch(); }
public void Part1(string data, string newLine, int result) { var groups = Parser.ParseGroups(data, newLine); Assert.That(Solver.Part1(groups), Is.EqualTo(result)); }
/** * * Post office problem. * * Problem statement: * http://www-128.ibm.com/developerworks/linux/library/l-glpk2/ * * From Winston 'Operations Research: Applications and Algorithms': * """ * A post office requires a different number of full-time employees working * on different days of the week [summarized below]. Union rules state that * each full-time employee must work for 5 consecutive days and then receive * two days off. For example, an employee who works on Monday to Friday * must be off on Saturday and Sunday. The post office wants to meet its * daily requirements using only full-time employees. Minimize the number * of employees that must be hired. * * To summarize the important information about the problem: * * Every full-time worker works for 5 consecutive days and takes 2 days off * - Day 1 (Monday): 17 workers needed * - Day 2 : 13 workers needed * - Day 3 : 15 workers needed * - Day 4 : 19 workers needed * - Day 5 : 14 workers needed * - Day 6 : 16 workers needed * - Day 7 (Sunday) : 11 workers needed * * The post office needs to minimize the number of employees it needs * to hire to meet its demand. * """ * * Also see http://www.hakank.org/or-tools/post_office_problem2.py * */ private static void Solve() { Solver solver = new Solver("PostOfficeProblem2"); // // Data // // days 0..6, monday 0 int n = 7; int[] need = { 17, 13, 15, 19, 14, 16, 11 }; // Total cost for the 5 day schedule. // Base cost per day is 100. // Working saturday is 100 extra // Working sunday is 200 extra. int[] cost = { 500, 600, 800, 800, 800, 800, 700 }; // // Decision variables // // No. of workers starting at day i IntVar[] x = solver.MakeIntVarArray(n, 0, 100, "x"); IntVar total_cost = x.ScalProd(cost).Var(); IntVar num_workers = x.Sum().Var(); // // Constraints // for (int i = 0; i < n; i++) { IntVar s = (from j in Enumerable.Range(0, n) where j != (i + 5) % n && j != (i + 6) % n select x[j]) .ToArray() .Sum() .Var(); solver.Add(s >= need[i]); } // Add a limit for the cost solver.Add(total_cost <= 20000); // // objective // // OptimizeVar obj = total_cost.Minimize(100); // // Search // DecisionBuilder db = solver.MakePhase(x, Solver.CHOOSE_MIN_SIZE_LOWEST_MIN, Solver.ASSIGN_MIN_VALUE); solver.NewSearch(db, obj); while (solver.NextSolution()) { Console.WriteLine("num_workers: {0}", num_workers.Value()); Console.WriteLine("total_cost: {0}", total_cost.Value()); Console.Write("x: "); for (int i = 0; i < n; i++) { Console.Write(x[i].Value() + " "); } Console.WriteLine("\n"); } Console.WriteLine("\nSolutions: {0}", solver.Solutions()); Console.WriteLine("WallTime: {0}ms", solver.WallTime()); Console.WriteLine("Failures: {0}", solver.Failures()); Console.WriteLine("Branches: {0} ", solver.Branches()); solver.EndSearch(); }
// [END data_model] public static void Main() { // [START data] DataModel data = new DataModel(); // [END data] // [END program_part1] // [START solver] // Create the linear solver with the CBC backend. Solver solver = Solver.CreateSolver("MultipleKnapsackMip", "CBC"); // [END solver] // [START program_part2] // [START variables] Variable[,] x = new Variable[data.NumItems, data.NumBins]; for (int i = 0; i < data.NumItems; i++) { for (int j = 0; j < data.NumBins; j++) { x[i, j] = solver.MakeIntVar(0, 1, $"x_{i}_{j}"); } } // [END variables] // [START constraints] for (int i = 0; i < data.NumItems; ++i) { Constraint constraint = solver.MakeConstraint(0, 1, ""); for (int j = 0; j < data.NumBins; ++j) { constraint.SetCoefficient(x[i, j], 1); } } for (int j = 0; j < data.NumBins; ++j) { Constraint constraint = solver.MakeConstraint(0, data.BinCapacities[j], ""); for (int i = 0; i < data.NumItems; ++i) { constraint.SetCoefficient(x[i, j], DataModel.Weights[i]); } } // [END constraints] // [START objective] Objective objective = solver.Objective(); for (int i = 0; i < data.NumItems; ++i) { for (int j = 0; j < data.NumBins; ++j) { objective.SetCoefficient(x[i, j], DataModel.Values[i]); } } objective.SetMaximization(); // [END objective] // [START solve] Solver.ResultStatus resultStatus = solver.Solve(); // [END solve] // [START print_solution] // Check that the problem has an optimal solution. if (resultStatus != Solver.ResultStatus.OPTIMAL) { Console.WriteLine("The problem does not have an optimal solution!"); return; } Console.WriteLine("Total packed value: " + solver.Objective().Value()); double TotalWeight = 0.0; for (int j = 0; j < data.NumBins; ++j) { double BinWeight = 0.0; double BinValue = 0.0; Console.WriteLine("Bin " + j); for (int i = 0; i < data.NumItems; ++i) { if (x[i, j].SolutionValue() == 1) { Console.WriteLine($"Item {i} weight: {DataModel.Weights[i]} values: {DataModel.Values[i]}"); BinWeight += DataModel.Weights[i]; BinValue += DataModel.Values[i]; } } Console.WriteLine("Packed bin weight: " + BinWeight); Console.WriteLine("Packed bin value: " + BinValue); TotalWeight += BinWeight; } Console.WriteLine("Total packed weight: " + TotalWeight); // [END print_solution] }
static void Main(string[] args) { Solver solver = Solver.CreateSolver("SimpleLpProgram", "GLOP_LINEAR_PROGRAMMING"); //Variables x, y > 0 Variable x = solver.MakeNumVar(0.0, double.PositiveInfinity, "x"); Variable y = solver.MakeNumVar(0.0, double.PositiveInfinity, "y"); Console.WriteLine("Liczba zmiennych = " + solver.NumVariables()); // Constraints: // 6x + 3y >= 120 // x + 3y >= 60 // 9x + y >= 36 // 6x + 6y >= 180 Constraint ct1a = solver.MakeConstraint(120, double.PositiveInfinity, "ct1a"); ct1a.SetCoefficient(x, 6); ct1a.SetCoefficient(y, 3); Constraint ct2a = solver.MakeConstraint(60, double.PositiveInfinity, "ct2a"); ct2a.SetCoefficient(x, 1); ct2a.SetCoefficient(y, 3); Constraint ct3a = solver.MakeConstraint(36, double.PositiveInfinity, "ct3a"); ct3a.SetCoefficient(x, 9); ct3a.SetCoefficient(y, 1); Constraint ct4a = solver.MakeConstraint(180, double.PositiveInfinity, "ct4a"); ct4a.SetCoefficient(x, 6); ct4a.SetCoefficient(y, 6); Console.WriteLine("Liczba ograniczeń = " + solver.NumConstraints()); // Objective function: 1.2x + 1.8y => min Objective objectiveA = solver.Objective(); objectiveA.SetCoefficient(x, 1.2); objectiveA.SetCoefficient(y, 1.8); objectiveA.SetMinimization(); solver.Solve(); Console.WriteLine("-----------------------"); Console.WriteLine("Rozwiązanie punkt 1:"); Console.WriteLine("Wartość funkcji celu: = " + solver.Objective().Value()); Console.WriteLine("Nalezy wyprodukowac = " + (int)Math.Ceiling(x.SolutionValue()) + " P1 produktow"); Console.WriteLine("Nalezy wyprodukowac = " + (int)Math.Ceiling(y.SolutionValue()) + " P2 produktow"); Console.WriteLine("-----------------------"); Console.WriteLine("Rozwiazanie punkt 2:"); // Constraints: // 6x + 3y < 240 // x + 3y >= 60 // 9x + y >= 36 // 6x + 6y >= 180 Constraint ct1b = solver.MakeConstraint(double.NegativeInfinity, 240, "ct1b"); ct1b.SetCoefficient(x, 6); ct1b.SetCoefficient(y, 3); Constraint ct2b = solver.MakeConstraint(60, double.PositiveInfinity, "ct2b"); ct2b.SetCoefficient(x, 1); ct2b.SetCoefficient(y, 3); Constraint ct3b = solver.MakeConstraint(36, double.PositiveInfinity, "ct3b"); ct3b.SetCoefficient(x, 9); ct3b.SetCoefficient(y, 1); Constraint ct4b = solver.MakeConstraint(180, double.PositiveInfinity, "ct4b"); ct4b.SetCoefficient(x, 6); ct4b.SetCoefficient(y, 6); // Objective function: 1.2x + 1.8y => min Objective objectiveB = solver.Objective(); objectiveB.SetCoefficient(x, 1.2); objectiveB.SetCoefficient(y, 1.8); objectiveB.SetMinimization(); solver.Solve(); Console.WriteLine("Nalezy wyprodukowac = " + (int)Math.Ceiling(x.SolutionValue()) + " P1 produktow"); Console.WriteLine("Nalezy wyprodukowac = " + (int)Math.Ceiling(y.SolutionValue()) + " P2 produktow"); Console.WriteLine("Nie zmieni sie rozwiazanie, jezeli nie mozna podawac wiecej niz 240 jednostek witaminy A"); Console.WriteLine("-----------------------"); }
public void InitializeDamage(Solver solver, bool areaEffect, int range, MagicSchool magicSchool, SpellData spellData) { InitializeDamage(solver, areaEffect, range, magicSchool, spellData, 1, 1, 0); }
public void InitializeDamage(Solver solver, bool areaEffect, int range, MagicSchool magicSchool, int cost, float minDamage, float maxDamage, float spellDamageCoefficient, float periodicDamage, float dotDamageCoefficient, float hitProcs, float castProcs, float dotDuration) { Stats baseStats = solver.BaseStats; MageTalents mageTalents = solver.MageTalents; CalculationOptionsMage calculationOptions = solver.CalculationOptions; AreaEffect = areaEffect; AreaEffectDot = areaEffect; MaximumAOETargets = 10; int manaReduction = (int)baseStats.SpellsManaCostReduction; if (manaReduction == 405) { // Shard of Woe hax manaReduction = 205; } BaseCost = Math.Max(cost - manaReduction, 0); MagicSchool = magicSchool; Ticks = hitProcs; CastProcs = castProcs; CastProcs2 = castProcs; BaseMinDamage = minDamage; BaseMaxDamage = maxDamage; SpellDamageCoefficient = spellDamageCoefficient; BasePeriodicDamage = periodicDamage; DotDamageCoefficient = dotDamageCoefficient; DotDuration = dotDuration; BaseDirectDamageModifier = 1.0f; BaseDotDamageModifier = 1.0f; BaseCostModifier = 1.0f; float baseCostAmplifier = calculationOptions.EffectCostMultiplier; if (mageTalents.EnduringWinter > 0) { BaseCostModifier -= 0.03f * mageTalents.EnduringWinter + (mageTalents.EnduringWinter == 3 ? 0.01f : 0.00f); } BaseCostAmplifier = baseCostAmplifier; float baseInterruptProtection = baseStats.InterruptProtection; baseInterruptProtection += 0.23f * mageTalents.BurningSoul + (mageTalents.BurningSoul == 3 ? 0.01f : 0.0f); BaseInterruptProtection = baseInterruptProtection; float realResistance; switch (MagicSchool) { case MagicSchool.Arcane: BaseSpellModifier = solver.BaseArcaneSpellModifier; BaseAdditiveSpellModifier = solver.BaseArcaneAdditiveSpellModifier; BaseCritRate = solver.BaseArcaneCritRate; CritBonus = solver.BaseArcaneCritBonus; HitRate = solver.BaseArcaneHitRate; ThreatMultiplier = solver.ArcaneThreatMultiplier; realResistance = calculationOptions.ArcaneResist; IgniteFactor = 0; break; case MagicSchool.Fire: BaseSpellModifier = solver.BaseFireSpellModifier; BaseAdditiveSpellModifier = solver.BaseFireAdditiveSpellModifier; BaseCritRate = solver.BaseFireCritRate; CritBonus = solver.BaseFireCritBonus; HitRate = solver.BaseFireHitRate; ThreatMultiplier = solver.FireThreatMultiplier; realResistance = calculationOptions.FireResist; IgniteFactor = solver.IgniteFactor; break; case MagicSchool.FrostFire: BaseSpellModifier = solver.BaseFrostFireSpellModifier; BaseAdditiveSpellModifier = solver.BaseFrostFireAdditiveSpellModifier; BaseCritRate = solver.BaseFrostFireCritRate; CritBonus = solver.BaseFrostFireCritBonus; HitRate = solver.BaseFrostFireHitRate; ThreatMultiplier = solver.FrostFireThreatMultiplier; if (calculationOptions.FireResist == -1) { realResistance = calculationOptions.FrostResist; } else if (calculationOptions.FrostResist == -1) { realResistance = calculationOptions.FireResist; } else { realResistance = Math.Min(calculationOptions.FireResist, calculationOptions.FrostResist); } Range = range; IgniteFactor = solver.IgniteFactor; break; case MagicSchool.Frost: BaseSpellModifier = solver.BaseFrostSpellModifier; BaseAdditiveSpellModifier = solver.BaseFrostAdditiveSpellModifier; BaseCritRate = solver.BaseFrostCritRate; CritBonus = solver.BaseFrostCritBonus; HitRate = solver.BaseFrostHitRate; ThreatMultiplier = solver.FrostThreatMultiplier; realResistance = calculationOptions.FrostResist; IgniteFactor = 0; break; case MagicSchool.Nature: BaseSpellModifier = solver.BaseNatureSpellModifier; BaseAdditiveSpellModifier = solver.BaseNatureAdditiveSpellModifier; BaseCritRate = solver.BaseNatureCritRate; CritBonus = solver.BaseNatureCritBonus; HitRate = solver.BaseNatureHitRate; ThreatMultiplier = solver.NatureThreatMultiplier; realResistance = calculationOptions.NatureResist; Range = range; IgniteFactor = 0; break; case MagicSchool.Shadow: BaseSpellModifier = solver.BaseShadowSpellModifier; BaseAdditiveSpellModifier = solver.BaseShadowAdditiveSpellModifier; BaseCritRate = solver.BaseShadowCritRate; CritBonus = solver.BaseShadowCritBonus; HitRate = solver.BaseShadowHitRate; ThreatMultiplier = solver.ShadowThreatMultiplier; realResistance = calculationOptions.ShadowResist; Range = range; IgniteFactor = 0; break; case MagicSchool.Holy: default: BaseSpellModifier = solver.BaseHolySpellModifier; BaseAdditiveSpellModifier = solver.BaseHolyAdditiveSpellModifier; BaseCritRate = solver.BaseHolyCritRate; CritBonus = solver.BaseHolyCritBonus; HitRate = solver.BaseHolyHitRate; ThreatMultiplier = solver.HolyThreatMultiplier; realResistance = calculationOptions.HolyResist; Range = range; IgniteFactor = 0; break; } NonHSCritRate = baseStats.SpellCritOnTarget; int playerLevel = calculationOptions.PlayerLevel; int targetLevel; if (areaEffect) { targetLevel = calculationOptions.AoeTargetLevel; float hitRate = ((targetLevel <= playerLevel + 2) ? (0.96f - (targetLevel - playerLevel) * 0.01f) : (0.94f - (targetLevel - playerLevel - 2) * 0.11f)) + solver.BaseSpellHit; if (hitRate > Spell.MaxHitRate) { hitRate = Spell.MaxHitRate; } HitRate = hitRate; } else { targetLevel = calculationOptions.TargetLevel; } RealResistance = realResistance; PartialResistFactor = (realResistance == -1) ? 0 : (1 - StatConversion.GetAverageResistance(playerLevel, targetLevel, realResistance, baseStats.SpellPenetration)); }
/** * * Solves the Quasigroup Completion problem. * See http://www.hakank.org/or-tools/quasigroup_completion.py * */ private static void Solve() { Solver solver = new Solver("QuasigroupCompletion"); // // data // Console.WriteLine("Problem:"); for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { Console.Write(problem[i, j] + " "); } Console.WriteLine(); } Console.WriteLine(); // // Decision variables // IntVar[,] x = solver.MakeIntVarMatrix(n, n, 1, n, "x"); IntVar[] x_flat = x.Flatten(); // // Constraints // for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { if (problem[i, j] > X) { solver.Add(x[i, j] == problem[i, j]); } } } // // rows and columns must be different // // rows for (int i = 0; i < n; i++) { IntVar[] row = new IntVar[n]; for (int j = 0; j < n; j++) { row[j] = x[i, j]; } solver.Add(row.AllDifferent()); } // columns for (int j = 0; j < n; j++) { IntVar[] col = new IntVar[n]; for (int i = 0; i < n; i++) { col[i] = x[i, j]; } solver.Add(col.AllDifferent()); } // // Search // DecisionBuilder db = solver.MakePhase(x_flat, Solver.INT_VAR_SIMPLE, Solver.ASSIGN_MIN_VALUE); solver.NewSearch(db); int sol = 0; while (solver.NextSolution()) { sol++; Console.WriteLine("Solution #{0} ", sol + " "); for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { Console.Write("{0} ", x[i, j].Value()); } Console.WriteLine(); } Console.WriteLine(); } Console.WriteLine("\nSolutions: {0}", solver.Solutions()); Console.WriteLine("WallTime: {0}ms", solver.WallTime()); Console.WriteLine("Failures: {0}", solver.Failures()); Console.WriteLine("Branches: {0} ", solver.Branches()); solver.EndSearch(); }
/** * * Rogo puzzle solver. * * From http://www.rogopuzzle.co.nz/ * """ * The object is to collect the biggest score possible using a given * number of steps in a loop around a grid. The best possible score * for a puzzle is given with it, so you can easily check that you have * solved the puzzle. Rogo puzzles can also include forbidden squares, * which must be avoided in your loop. * """ * * Also see Mike Trick: * "Operations Research, Sudoko, Rogo, and Puzzles" * http://mat.tepper.cmu.edu/blog/?p=1302 * * * Also see, http://www.hakank.org/or-tools/rogo2.py * though this model differs in a couple of central points * which makes it much faster: * * - it use a table ( * AllowedAssignments) with the valid connections * - instead of two coordinates arrays, it use a single path array * */ private static void Solve() { Solver solver = new Solver("Rogo2"); Console.WriteLine("\n"); Console.WriteLine("**********************************************"); Console.WriteLine(" {0}", problem_name); Console.WriteLine("**********************************************\n"); // // Data // int B = -1; Console.WriteLine("Rows: {0} Cols: {1} Max Steps: {2}", rows, cols, max_steps); int[] problem_flatten = problem.Cast <int>().ToArray(); int max_point = problem_flatten.Max(); int max_sum = problem_flatten.Sum(); Console.WriteLine("max_point: {0} max_sum: {1} best: {2}", max_point, max_sum, best); IEnumerable <int> STEPS = Enumerable.Range(0, max_steps); IEnumerable <int> STEPS1 = Enumerable.Range(0, max_steps - 1); // the valid connections, to be used with AllowedAssignments IntTupleSet valid_connections = ValidConnections(rows, cols); // // Decision variables // IntVar[] path = solver.MakeIntVarArray(max_steps, 0, rows * cols - 1, "path"); IntVar[] points = solver.MakeIntVarArray(max_steps, 0, best, "points"); IntVar sum_points = points.Sum().VarWithName("sum_points"); // // Constraints // foreach (int s in STEPS) { // calculate the points (to maximize) solver.Add(points[s] == problem_flatten.Element(path[s])); // ensure that there are no black cells in // the path solver.Add(problem_flatten.Element(path[s]) != B); } solver.Add(path.AllDifferent()); // valid connections foreach (int s in STEPS1) { solver.Add(new IntVar[] { path[s], path[s + 1] }.AllowedAssignments(valid_connections)); } // around the corner solver.Add(new IntVar[] { path[max_steps - 1], path[0] }.AllowedAssignments(valid_connections)); // Symmetry breaking for (int s = 1; s < max_steps; s++) { solver.Add(path[0] < path[s]); } // // Objective // OptimizeVar obj = sum_points.Maximize(1); // // Search // DecisionBuilder db = solver.MakePhase(path, Solver.INT_VAR_DEFAULT, Solver.INT_VALUE_DEFAULT); solver.NewSearch(db, obj); while (solver.NextSolution()) { Console.WriteLine("sum_points: {0}", sum_points.Value()); Console.Write("path: "); foreach (int s in STEPS) { Console.Write("{0} ", path[s].Value()); } Console.WriteLine(); Console.WriteLine("(Adding 1 to coords...)"); int[,] sol = new int[rows, cols]; foreach (int s in STEPS) { int p = (int)path[s].Value(); int x = (int)(p / cols); int y = (int)(p % cols); Console.WriteLine("{0,2},{1,2} ({2} points)", x + 1, y + 1, points[s].Value()); sol[x, y] = 1; } Console.WriteLine("\nThe path is marked by 'X's:"); for (int i = 0; i < rows; i++) { for (int j = 0; j < cols; j++) { String p = sol[i, j] == 1 ? "X" : " "; String q = problem[i, j] == B ? "B" : problem[i, j] == 0 ? "." : problem[i, j].ToString(); Console.Write("{0,2}{1} ", q, p); } Console.WriteLine(); } Console.WriteLine(); } Console.WriteLine("\nSolutions: {0}", solver.Solutions()); Console.WriteLine("WallTime: {0}ms", solver.WallTime()); Console.WriteLine("Failures: {0}", solver.Failures()); Console.WriteLine("Branches: {0} ", solver.Branches()); solver.EndSearch(); }
/** * * Simple regular expression. * * My last name (Kjellerstrand) is quite often misspelled * in ways that this regular expression shows: * k(je|ä)ll(er|ar)?(st|b)r?an?d * * This model generates all the words that can be construed * by this regular expression. * * * Also see http://www.hakank.org/or-tools/regex.py * */ private static void Solve(int n, List <String> res) { Solver solver = new Solver("RegexGeneration"); Console.WriteLine("\nn: {0}", n); // The DFS (for regular) int n_states = 11; int input_max = 12; int initial_state = 1; // 0 is for the failing state int[] accepting_states = { 12 }; // The DFA int[,] transition_fn = { // 1 2 3 4 5 6 7 8 9 0 1 2 // { 0, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 1 k { 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0 }, // 2 je { 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0 }, // 3 ä { 0, 0, 0, 0, 5, 6, 7, 8, 0, 0, 0, 0 }, // 4 ll { 0, 0, 0, 0, 0, 0, 7, 8, 0, 0, 0, 0 }, // 5 er { 0, 0, 0, 0, 0, 0, 7, 8, 0, 0, 0, 0 }, // 6 ar { 0, 0, 0, 0, 0, 0, 0, 0, 9, 10, 0, 0 }, // 7 st { 0, 0, 0, 0, 0, 0, 0, 0, 9, 10, 0, 0 }, // 8 b { 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0 }, // 9 r { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 12 }, // 10 a { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12 }, // 11 n // 12 d }; // Name of the states String[] s = { "k", "je", "ä", "ll", "er", "ar", "st", "b", "r", "a", "n", "d" }; // // Decision variables // IntVar[] x = solver.MakeIntVarArray(n, 1, input_max, "x"); // // Constraints // MyRegular(solver, x, n_states, input_max, transition_fn, initial_state, accepting_states); // // Search // DecisionBuilder db = solver.MakePhase(x, Solver.CHOOSE_FIRST_UNBOUND, Solver.ASSIGN_MIN_VALUE); solver.NewSearch(db); while (solver.NextSolution()) { List <String> res2 = new List <String>(); // State 1 (the start state) is not included in the // state array (x) so we add it first. res2.Add(s[0]); for (int i = 0; i < n; i++) { res2.Add(s[x[i].Value() - 1]); } res.Add(String.Join("", res2.ToArray())); } Console.WriteLine("\nSolutions: {0}", solver.Solutions()); Console.WriteLine("WallTime: {0}ms", solver.WallTime()); Console.WriteLine("Failures: {0}", solver.Failures()); Console.WriteLine("Branches: {0} ", solver.Branches()); solver.EndSearch(); }
/// <summary> /// 24通りから任意のロジック組み合わせを取得 /// </summary> /// <param name="solver"></param> /// <returns></returns> public LogicDelegates[] GetLogicCombination(Solver solver) { LogicDelegates[] logics = new LogicDelegates[4]; logics[0] = solver.ShareCandLogic; logics[1] = solver.PairLogic; logics[2] = solver.CrossLogic; logics[3] = solver.TripleLogic; switch (combinationNo) { case 1: logics[0] = solver.PairLogic; //双子 logics[1] = solver.ShareCandLogic; //共有 logics[2] = solver.TripleLogic; //三つ子 logics[3] = solver.CrossLogic; //対角 break; case 2: logics[0] = solver.PairLogic; //双子 logics[1] = solver.ShareCandLogic; //共有 logics[2] = solver.CrossLogic; //対角 logics[3] = solver.TripleLogic; //三つ子 break; case 3: logics[0] = solver.PairLogic; //双子 logics[1] = solver.TripleLogic; //三つ子 logics[2] = solver.ShareCandLogic; //共有 logics[3] = solver.CrossLogic; //対角 break; case 4: logics[0] = solver.PairLogic; //双子 logics[1] = solver.TripleLogic; //三つ子 logics[2] = solver.CrossLogic; //対角 logics[3] = solver.ShareCandLogic; //共有 break; case 5: logics[0] = solver.PairLogic; //双子 logics[1] = solver.CrossLogic; //対角 logics[2] = solver.ShareCandLogic; //共有 logics[3] = solver.TripleLogic; //三つ子 break; case 6: logics[0] = solver.PairLogic; //双子 logics[1] = solver.CrossLogic; //対角 logics[2] = solver.TripleLogic; //三つ子 logics[3] = solver.ShareCandLogic; //共有 break; case 7: logics[0] = solver.ShareCandLogic; //共有 logics[1] = solver.PairLogic; //双子 logics[2] = solver.TripleLogic; //三つ子 logics[3] = solver.CrossLogic; //対角 break; case 8: logics[0] = solver.ShareCandLogic; //共有 logics[1] = solver.PairLogic; //双子 logics[2] = solver.CrossLogic; //対角 logics[3] = solver.TripleLogic; //三つ子 break; case 9: logics[0] = solver.ShareCandLogic; //共有 logics[1] = solver.TripleLogic; //三つ子 logics[2] = solver.PairLogic; //双子 logics[3] = solver.CrossLogic; //対角 break; case 10: logics[0] = solver.ShareCandLogic; //共有 logics[1] = solver.TripleLogic; //三つ子 logics[2] = solver.CrossLogic; //対角 logics[3] = solver.PairLogic; //双子 break; case 11: logics[0] = solver.ShareCandLogic; //共有 logics[1] = solver.CrossLogic; //対角 logics[2] = solver.PairLogic; //双子 logics[3] = solver.TripleLogic; //三つ子 break; case 12: logics[0] = solver.ShareCandLogic; //共有 logics[1] = solver.CrossLogic; //対角 logics[2] = solver.TripleLogic; //三つ子 logics[3] = solver.PairLogic; //双子 break; case 13: logics[0] = solver.TripleLogic; //三つ子 logics[1] = solver.PairLogic; //双子 logics[2] = solver.ShareCandLogic; //共有 logics[3] = solver.CrossLogic; //対角 break; case 14: logics[0] = solver.TripleLogic; //三つ子 logics[1] = solver.PairLogic; //双子 logics[2] = solver.CrossLogic; //対角 logics[3] = solver.ShareCandLogic; //共有 break; case 15: logics[0] = solver.TripleLogic; //三つ子 logics[1] = solver.ShareCandLogic; //共有 logics[2] = solver.PairLogic; //双子 logics[3] = solver.CrossLogic; //対角 break; case 16: logics[0] = solver.TripleLogic; //三つ子 logics[1] = solver.ShareCandLogic; //共有 logics[2] = solver.CrossLogic; //対角 logics[3] = solver.PairLogic; //双子 break; case 17: logics[0] = solver.TripleLogic; //三つ子 logics[1] = solver.CrossLogic; //対角 logics[2] = solver.PairLogic; //双子 logics[3] = solver.ShareCandLogic; //共有 break; case 18: logics[0] = solver.TripleLogic; //三つ子 logics[1] = solver.CrossLogic; //対角 logics[2] = solver.ShareCandLogic; //共有 logics[3] = solver.PairLogic; //双子 break; case 19: logics[0] = solver.CrossLogic; //対角 logics[1] = solver.PairLogic; //双子 logics[2] = solver.ShareCandLogic; //共有 logics[3] = solver.TripleLogic; //三つ子 break; case 20: logics[0] = solver.CrossLogic; //対角 logics[1] = solver.PairLogic; //双子 logics[2] = solver.TripleLogic; //三つ子 logics[3] = solver.ShareCandLogic; //共有 break; case 21: logics[0] = solver.CrossLogic; //対角 logics[1] = solver.ShareCandLogic; //共有 logics[2] = solver.PairLogic; //双子 logics[3] = solver.TripleLogic; //三つ子 break; case 22: logics[0] = solver.CrossLogic; //対角 logics[1] = solver.ShareCandLogic; //共有 logics[2] = solver.TripleLogic; //三つ子 logics[3] = solver.PairLogic; //双子 break; case 23: logics[0] = solver.CrossLogic; //対角 logics[1] = solver.TripleLogic; //三つ子 logics[2] = solver.PairLogic; //双子 logics[3] = solver.ShareCandLogic; //共有 break; case 24: logics[0] = solver.CrossLogic; //対角 logics[1] = solver.TripleLogic; //三つ子 logics[2] = solver.ShareCandLogic; //共有 logics[3] = solver.PairLogic; //双子 break; } return(logics); }
public Tuple <double, ItemList> getOre(double refineRate, int trit, int pyer, int mex, int iso, int nocx, int zyd, int mega, int morph) { Solver solver = new Solver("Ore Solver", Solver.GLOP_LINEAR_PROGRAMMING); Dictionary <Variable, ore> vars = new Dictionary <Variable, ore>(); foreach (ore ore in Prices.Keys) { vars.Add(solver.MakeIntVar(0.0, double.PositiveInfinity, ore.name), ore); } Objective end = solver.Objective(); end.SetMinimization(); foreach (KeyValuePair <Variable, ore> var in vars) { end.SetCoefficient(var.Key, Prices[var.Value]); } Constraint tritConst = solver.MakeConstraint((double)trit, double.PositiveInfinity); foreach (KeyValuePair <Variable, ore> var in vars) { tritConst.SetCoefficient(var.Key, var.Value.Tritanium * refineRate); } Constraint pyerConst = solver.MakeConstraint((double)pyer, double.PositiveInfinity); foreach (KeyValuePair <Variable, ore> var in vars) { pyerConst.SetCoefficient(var.Key, var.Value.Pyerite * refineRate); } Constraint mexConst = solver.MakeConstraint((double)mex, double.PositiveInfinity); foreach (KeyValuePair <Variable, ore> var in vars) { mexConst.SetCoefficient(var.Key, var.Value.Mexallon * refineRate); } Constraint isoConst = solver.MakeConstraint((double)iso, double.PositiveInfinity); foreach (KeyValuePair <Variable, ore> var in vars) { isoConst.SetCoefficient(var.Key, var.Value.Isogen * refineRate); } Constraint nocxConst = solver.MakeConstraint((double)nocx, double.PositiveInfinity); foreach (KeyValuePair <Variable, ore> var in vars) { nocxConst.SetCoefficient(var.Key, var.Value.Nocxium * refineRate); } Constraint zydConst = solver.MakeConstraint((double)zyd, double.PositiveInfinity); foreach (KeyValuePair <Variable, ore> var in vars) { zydConst.SetCoefficient(var.Key, var.Value.Zydrine * refineRate); } Constraint megaConst = solver.MakeConstraint((double)mega, double.PositiveInfinity); foreach (KeyValuePair <Variable, ore> var in vars) { megaConst.SetCoefficient(var.Key, var.Value.Megacyte * refineRate); } Constraint morphConst = solver.MakeConstraint((double)morph, double.PositiveInfinity); foreach (KeyValuePair <Variable, ore> var in vars) { morphConst.SetCoefficient(var.Key, var.Value.Morphite * refineRate); } solver.Solve(); double price = end.Value(); ItemList list = new ItemList(); foreach (KeyValuePair <Variable, ore> var in vars) { if (var.Key.SolutionValue() > 0) { list.Add(var.Value.invType, (int)var.Key.SolutionValue()); } } return(new Tuple <double, ItemList>(price, list)); }
public static void TestPacket(Options options) { Console.WriteLine("Parsing firewall rules..."); WindowsFirewall firewall = new WindowsFirewall { BlockByDefault = options.FirewallBlockByDefault, Rules = WindowsFirewallRuleParser.Parse(File.ReadAllText(options.FirewallFilepath), '\t').ToList() }; int protocolNumber; bool anyProtocol = false; if (!NetworkProtocol.TryGetProtocolNumber(options.Protocol, out protocolNumber)) { if (string.Equals("Any", options.Protocol, StringComparison.InvariantCultureIgnoreCase)) { anyProtocol = true; } else { protocolNumber = int.Parse(options.Protocol); } } WindowsFirewallPacket packet = new WindowsFirewallPacket { SourceAddress = IPAddress.Parse(options.SourceAddress), SourcePort = string.Equals("Any", options.SourcePort, StringComparison.InvariantCultureIgnoreCase) ? null : (int?)int.Parse(options.SourcePort), DestinationPort = string.Equals("Any", options.DestinationPort, StringComparison.InvariantCultureIgnoreCase) ? null : (int?)int.Parse(options.DestinationPort), Protocol = anyProtocol ? null : (int?)protocolNumber }; Console.WriteLine("Checking action of firewall on packet..."); using (var ctx = new Context()) { Solver s = ctx.MkSolver(); var packetVars = new WindowsFirewallPacketVariables(ctx); s.Assert(packet.Matches(ctx, packetVars)); s.Check(); if (s.Model.Eval(firewall.Allows(ctx, packetVars)).IsTrue) { Console.ForegroundColor = ConsoleColor.Green; Console.WriteLine("Packet is allowed by firewall."); Console.ResetColor(); } else { Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine("Packet is NOT allowed by firewall."); Console.ResetColor(); } List <WindowsFirewallRule> ruleMatches = firewall.GetMatches(ctx, packetVars, s.Model).ToList(); if (!ruleMatches.Any()) { Console.WriteLine("No firewall rules match the test packet."); return; } Console.WriteLine(); Console.WriteLine("Firewall rules matching the test packet:"); Console.WriteLine("-------------------------------------------------------------------------"); Console.WriteLine("| Action | Rule Name |"); Console.WriteLine("-------------------------------------------------------------------------"); foreach (WindowsFirewallRule rule in ruleMatches) { Console.WriteLine( $"| {(rule.Allow ? "Allow" : "Block"), 6} " + $"| {rule.Name.Substring(0, Math.Min(rule.Name.Length, 60)), -60} |"); } Console.WriteLine("-------------------------------------------------------------------------"); } }
static void Main() { // Data. // [START data_model] int[,] costs = { { 90, 80, 75, 70 }, { 35, 85, 55, 65 }, { 125, 95, 90, 95 }, { 45, 110, 95, 115 }, { 50, 100, 90, 100 }, }; int numWorkers = costs.GetLength(0); int numTasks = costs.GetLength(1); // [END data_model] // Model. // [START model] Solver solver = Solver.CreateSolver("SCIP"); // [END model] // Variables. // [START variables] // x[i, j] is an array of 0-1 variables, which will be 1 // if worker i is assigned to task j. Variable[,] x = new Variable[numWorkers, numTasks]; for (int i = 0; i < numWorkers; ++i) { for (int j = 0; j < numTasks; ++j) { x[i, j] = solver.MakeIntVar(0, 1, $"worker_{i}_task_{j}"); } } // [END variables] // Constraints // [START constraints] // Each worker is assigned to at most one task. for (int i = 0; i < numWorkers; ++i) { Constraint constraint = solver.MakeConstraint(0, 1, ""); for (int j = 0; j < numTasks; ++j) { constraint.SetCoefficient(x[i, j], 1); } } // Each task is assigned to exactly one worker. for (int j = 0; j < numTasks; ++j) { Constraint constraint = solver.MakeConstraint(1, 1, ""); for (int i = 0; i < numWorkers; ++i) { constraint.SetCoefficient(x[i, j], 1); } } // [END constraints] // Objective // [START objective] Objective objective = solver.Objective(); for (int i = 0; i < numWorkers; ++i) { for (int j = 0; j < numTasks; ++j) { objective.SetCoefficient(x[i, j], 1); } } objective.SetMinimization(); // [END objective] // Solve // [START solve] Solver.ResultStatus resultStatus = solver.Solve(); // [END solve] // Print solution. // [START print_solution] // Check that the problem has a feasible solution. if (resultStatus == Solver.ResultStatus.OPTIMAL || resultStatus == Solver.ResultStatus.FEASIBLE) { Console.WriteLine($"Total cost: {solver.Objective().Value()}\n"); for (int i = 0; i < numWorkers; ++i) { for (int j = 0; j < numTasks; ++j) { // Test if x[i, j] is 0 or 1 (with tolerance for floating point // arithmetic). if (x[i, j].SolutionValue() > 0.5) { Console.WriteLine($"Worker {i} assigned to task {j}. Cost: {costs[i, j]}"); } } } } else { Console.WriteLine("No solution found."); } // [END print_solution] }