ortools lib error solved

libs/or-tools-src-ubuntu/README.md

+# Introduction
+This file describes how to install the OR-Tools C++, Java and .Net binary archive.
+
+OR-Tools is located at https://developers.google.com/optimization
+
+These modules have been tested under:
+  - Ubuntu 14.04, 16.04, 17.10 and 18.04 (64-bit).
+  - macOS 10.13 High Sierra with Xcode 9.4 (64 bit).
+  - Microsoft Windows with Visual Studio 2015 and 2017 (64-bit)
+
+Upon decompressing the archive, you will get the following structure:
+
+```
+or-tools/
+  LICENSE-2.0.txt <- Apache 2.0 License
+  README.md       <- This file
+  Makefile        <- Main Makefile for C++,Java and .Net
+  examples/       <- C++, Java and .Net examples
+  include/        <- all include files
+  objs/           <- directory containing C++ compiled object files (*.o)
+  classes/        <- directory containing Java class files.
+  packages/       <- directory containing .Net nuget packages.
+  lib/            <- directory containing libraries and jar files.
+  bin/            <- directory containing executable files
+```
+
+# C++
+
+Running the examples will involve compiling them, then running them.
+We have provided a makefile target to help you.
+
+Use Makefile:
+```shell
+make run SOURCE=examples/cpp/golomb.cc
+```
+
+**OR** this is equivalent to compiling and running
+`examples/cpp/golomb.cc`.
+- on Unix:
+  ```shell
+  make bin/golomb
+  ./bin/golomb
+  ```
+- on Windows:
+  ```shell
+  make bin\\golomb.exe
+  bin\\golomb.exe
+  ```
+
+# Java
+
+Running the examples will involve compiling them, then running them.
+We have provided a makefile target to help you. You need to have the
+java and javac tools accessible from the command line.
+
+Use Makefile:
+```shell
+make run SOURCE=examples/java/RabbitsPheasants.java
+```
+
+**OR** this is equivalent to compiling and running
+`examples/java/RabbitsPheasants.java`.
+- on Unix:
+  ```shell
+  javac -d classes/RabbitsPheasants -cp lib/com.google.ortools.jar:lib/protobuf.jar examples/java/RabbitsPheasants.java
+  jar cvf lib/RabbitsPheasants.jar -C classes/RabbitsPheasants .
+  java -Djava.library.path=lib -cp lib/RabbitsPheasants.jar:lib/com.google.ortools.jar:lib/protobuf.jar RabbitsPheasants
+  ```
+- on Windows:
+  ```shell
+  javac -d class/RabbitsPheasants -cp lib/com.google.ortools.jar;lib/protobuf.jar examples/java/RabbitsPheasants.java
+  jar cvf lib/RabbitsPheasants.jar -C classes/RabbitsPheasants .
+  java -Djava.library.path=lib -cp lib/RabbitPheasants.jar;lib/com.google.ortools.jar;lib/protobuf.jar RabbitsPheasants
+  ```
+
+# .Net
+
+Running the examples will involve compiling them, then running them.
+We have provided a makefile target to help you. You need to have the
+dotnet/cli tools accessible from the command line.
+
+Use Makefile:
+```shell
+make run SOURCE=examples/dotnet/csflow.cs
+```
+
+**OR** this is equivalent to compiling and running
+`examples/dotnet/csflow.cs`.
+- on Unix:
+  ```shell
+  dotnet build examples/dotnet/csflow.csproj
+  dotnet run --no-build --project examples/dotnet/csflow.csproj
+  ```
+- on Windows:
+  ```shell
+  dotnet build examples\dotnet\csflow.csproj
+  dotnet run --no-build --project examples\dotnet\csflow.csproj
+  ```

libs/or-tools-src-ubuntu/bin/gflags_completions.sh

+#!/bin/bash
+
+# Copyright (c) 2008, Google Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# ---
+# Author: Dave Nicponski
+#
+# This script is invoked by bash in response to a matching compspec.  When
+# this happens, bash calls this script using the command shown in the -C
+# block of the complete entry, but also appends 3 arguments.  They are:
+#   - The command being used for completion
+#   - The word being completed
+#   - The word preceding the completion word.
+#
+# Here's an example of how you might use this script:
+# $ complete -o bashdefault -o default -o nospace -C                         \
+#   '/usr/local/bin/gflags_completions.sh --tab_completion_columns $COLUMNS' \
+#   time  env  binary_name  another_binary  [...]
+
+# completion_word_index gets the index of the (N-1)th argument for
+# this command line.  completion_word gets the actual argument from
+# this command line at the (N-1)th position
+completion_word_index="$(($# - 1))"
+completion_word="${!completion_word_index}"
+
+# TODO(user): Replace this once gflags_completions.cc has
+# a bool parameter indicating unambiguously to hijack the process for
+# completion purposes.
+if [ -z "$completion_word" ]; then
+  # Until an empty value for the completion word stops being misunderstood
+  # by binaries, don't actually execute the binary or the process
+  # won't be hijacked!
+  exit 0
+fi
+
+# binary_index gets the index of the command being completed (which bash
+# places in the (N-2)nd position.  binary gets the actual command from
+# this command line at that (N-2)nd position
+binary_index="$(($# - 2))"
+binary="${!binary_index}"
+
+# For completions to be universal, we may have setup the compspec to
+# trigger on 'harmless pass-through' commands, like 'time' or 'env'.
+# If the command being completed is one of those two, we'll need to
+# identify the actual command being executed.  To do this, we need
+# the actual command line that the <TAB> was pressed on.  Bash helpfully
+# places this in the $COMP_LINE variable.
+if [ "$binary" == "time" ] || [ "$binary" == "env" ]; then
+  # we'll assume that the first 'argument' is actually the
+  # binary
+
+
+  # TODO(user): This is not perfect - the 'env' command, for instance,
+  #   is allowed to have options between the 'env' and 'the command to
+  #   be executed'.  For example, consider:
+  # $ env FOO="bar"  bin/do_something  --help<TAB>
+  # In this case, we'll mistake the FOO="bar" portion as the binary.
+  #   Perhaps we should continuing consuming leading words until we
+  #   either run out of words, or find a word that is a valid file
+  #   marked as executable.  I can't think of any reason this wouldn't
+  #   work.
+
+  # Break up the 'original command line' (not this script's command line,
+  # rather the one the <TAB> was pressed on) and find the second word.
+  parts=( ${COMP_LINE} )
+  binary=${parts[1]}
+fi
+
+# Build the command line to use for completion.  Basically it involves
+# passing through all the arguments given to this script (except the 3
+# that bash added), and appending a '--tab_completion_word "WORD"' to
+# the arguments.
+params=""
+for ((i=1; i<=$(($# - 3)); ++i)); do 
+  params="$params \"${!i}\"";
+done
+params="$params --tab_completion_word \"$completion_word\""
+
+# TODO(user): Perhaps stash the output in a temporary file somewhere
+# in /tmp, and only cat it to stdout if the command returned a success
+# code, to prevent false positives
+
+# If we think we have a reasonable command to execute, then execute it
+# and hope for the best.
+candidate=$(type -p "$binary")
+if [ ! -z "$candidate" ]; then
+  eval "$candidate 2>/dev/null $params"
+elif [ -f "$binary" ] && [ -x "$binary" ]; then
+  eval "$binary 2>/dev/null $params"
+fi

libs/or-tools-src-ubuntu/examples/cpp/README.md

+# C++ examples
+The following examples showcase how to use the different Operations Research libraries.
+
+## Examples list
+- Constraint Solver examples:
+  - cryptarithm.cc Demonstrates the use of basic modeling objects
+    (integer variables, arithmetic constraints and expressions,
+    simple search).
+  - golomb.cc Demonstrates how to handle objective functions and collect
+    solutions found during the search.
+  - magic_square.cc Shows how to use the automatic search to solve your
+    problem.
+  - costas_array.cc Solves the problem of Costas Array (a constrained
+    assignment problem used for radars) with two version. On version is
+    a feasibility version with hard constraints, the other version is
+    an optimization version with soft constraints and violation costs.
+  - jobshop.cc Demonstrates scheduling of jobs on different machines.
+  - jobshop_ls.cc Demonstrates scheduling of jobs on different machines with
+    a search using Local Search and Large Neighorhood Search.
+  - nqueens.cc Solves the n-queen problem. It also demonstrates how to break
+    symmetries during search.
+  - network_routing.cc Solves a multicommodity mono-routing
+    problem with capacity constraints and a max usage cost structure.
+  - sports_scheduling.cc Finds a soccer championship schedule. Its uses an
+    original approach where all constraints attached to either one team,
+    or one week are regrouped into one global 'AllowedAssignment' constraints.
+  - dobble_ls.cc Shows how to write Local Search operators and Local Search
+    filters in a context of an assignment/partitioning problem. It also
+    shows how to write a simple constraint.
+
+- Routing examples:
+  - tsp.cc    Travelling Salesman Problem.
+  - cvrptw.cc Capacitated Vehicle Routing Problem with Time Windows.
+  - pdptw.cc  Pickup and Delivery Problem with Time Windows.
+
+- Graph examples:
+  - flow_api.cc Demonstrates how to use Min-Cost Flow and Max-Flow api.
+  - linear_assignment_api.cc Demonstrates how to use the Linear Sum
+    Assignment solver.
+  - dimacs_assignment.cc Solves DIMACS challenge on assignment
+    problems.
+
+- Linear and integer programming examples:
+  - linear_programming.cc Demonstrates how to use the linear solver
+    wrapper API to solve Linear Programming problems.
+  - integer_programming.cc Demonstrates how to use the linear solver
+    wrapper API to solve Integer Programming problems.
+  - linear_solver_protocol_buffers.cc Demonstrates how protocol
+    buffers can be used as input and output to the linear solver wrapper.
+  - strawberry_fields_with_column_generation.cc Complex example that
+    demonstrates how to use dynamic column generation to solve a 2D
+    covering problem.
+
+- Utilities
+  - model_util.cc A utility to manipulate model files (.cp) dumped by the
+    solver.
+
+# Execution
+Running the examples will involve building them, then running them.   
+You can run the following command from the **top** directory:
+```shell
+make build SOURCE=examples/cpp/<example>.cc
+make run SOURCE=examples/cpp/<example>.cc
+```

libs/or-tools-src-ubuntu/examples/cpp/assignment_sat.cc

+// Copyright 2010-2018 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// [START program]
+// [START import]
+#include "ortools/sat/cp_model.h"
+// [END import]
+namespace operations_research {
+namespace sat {
+
+void IntegerProgrammingExample() {
+  // Data
+  // [START data_model]
+  const std::vector<std::vector<double>> costs{
+      {90, 80, 75, 70},   {35, 85, 55, 65},   {125, 95, 90, 95},
+      {45, 110, 95, 115}, {50, 100, 90, 100},
+  };
+  const int num_workers = costs.size();
+  const int num_tasks = costs[0].size();
+  // [END data_model]
+
+  // Model
+  // [START model]
+  CpModelBuilder cp_model;
+  // [END model]
+
+  // Variables
+  // [START variables]
+  // x[i][j] is an array of Boolean variables. x[i][j] is true
+  // if worker i is assigned to task j.
+  std::vector<std::vector<BoolVar>> x(num_workers,
+                                      std::vector<BoolVar>(num_tasks));
+  for (int i = 0; i < num_workers; ++i) {
+    for (int j = 0; j < num_tasks; ++j) {
+      x[i][j] = cp_model.NewBoolVar();
+    }
+  }
+  // [END variables]
+
+  // Constraints
+  // [START constraints]
+  // Each worker is assigned to at most one task.
+  for (int i = 0; i < num_workers; ++i) {
+    LinearExpr worker_sum;
+    for (int j = 0; j < num_tasks; ++j) {
+      worker_sum.AddTerm(x[i][j], 1);
+    }
+    cp_model.AddLessOrEqual(worker_sum, 1);
+  }
+  // Each task is assigned to exactly one worker.
+  for (int j = 0; j < num_tasks; ++j) {
+    LinearExpr task_sum;
+    for (int i = 0; i < num_workers; ++i) {
+      task_sum.AddTerm(x[i][j], 1);
+    }
+    cp_model.AddEquality(task_sum, 1);
+  }
+  // [END constraints]
+
+  // Objective
+  // [START objective]
+  LinearExpr total_cost;
+  for (int i = 0; i < num_workers; ++i) {
+    for (int j = 0; j < num_tasks; ++j) {
+      total_cost.AddTerm(x[i][j], costs[i][j]);
+    }
+  }
+  cp_model.Minimize(total_cost);
+  // [END objective]
+
+  // Solve
+  // [START solve]
+  const CpSolverResponse response = Solve(cp_model.Build());
+  // [END solve]
+
+  // Print solution.
+  // [START print_solution]
+  if (response.status() == CpSolverStatus::INFEASIBLE) {
+    LOG(FATAL) << "No solution found.";
+  }
+
+  LOG(INFO) << "Total cost: " << response.objective_value();
+  LOG(INFO);
+  for (int i = 0; i < num_workers; ++i) {
+    for (int j = 0; j < num_tasks; ++j) {
+      if (SolutionBooleanValue(response, x[i][j])) {
+        LOG(INFO) << "Task " << i << " assigned to worker " << j
+                  << ".  Cost: " << costs[i][j];
+      }
+    }
+  }
+  // [END print_solution]
+}
+}  // namespace sat
+}  // namespace operations_research
+
+int main(int argc, char** argv) {
+  operations_research::sat::IntegerProgrammingExample();
+  return EXIT_SUCCESS;
+}

libs/or-tools-src-ubuntu/examples/cpp/bin_packing_mip.cc

+// Copyright 2010-2018 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// [START program]
+// [START import]
+#include <iostream>
+#include <numeric>
+#include <vector>
+
+#include "ortools/linear_solver/linear_expr.h"
+#include "ortools/linear_solver/linear_solver.h"
+// [END import]
+
+// [START program_part1]
+namespace operations_research {
+// [START data_model]
+struct DataModel {
+  const std::vector<double> weights = {48, 30, 19, 36, 36, 27,
+                                       42, 42, 36, 24, 30};
+  const int num_items = weights.size();
+  const int num_bins = weights.size();
+  const int bin_capacity = 100;
+};
+// [END data_model]
+
+void BinPackingMip() {
+  // [START data]
+  DataModel data;
+  // [END data]
+  // [END program_part1]
+
+  // [START solver]
+  // Create the mip solver with the CBC backend.
+  MPSolver solver("bin_packing_mip",
+                  MPSolver::CBC_MIXED_INTEGER_PROGRAMMING);
+  // [END solver]
+
+  // [START program_part2]
+  // [START variables]
+  std::vector<std::vector<const MPVariable*>> x(
+      data.num_items, std::vector<const MPVariable*>(data.num_bins));
+  for (int i = 0; i < data.num_items; ++i) {
+    for (int j = 0; j < data.num_bins; ++j) {
+      x[i][j] = solver.MakeIntVar(0.0, 1.0, "");
+    }
+  }
+  // y[j] = 1 if bin j is used.
+  std::vector<const MPVariable*> y(data.num_bins);
+  for (int j = 0; j < data.num_bins; ++j) {
+    y[j] = solver.MakeIntVar(0.0, 1.0, "");
+  }
+  // [END variables]
+
+  // [START constraints]
+  // Create the constraints.
+  // Each item is in exactly one bin.
+  for (int i = 0; i < data.num_items; ++i) {
+    LinearExpr sum;
+    for (int j = 0; j < data.num_bins; ++j) {
+      sum += x[i][j];
+    }
+    solver.MakeRowConstraint(sum == 1.0);
+  }
+  // For each bin that is used, the total packed weight can be at most
+  // the bin capacity.
+  for (int j = 0; j < data.num_bins; ++j) {
+    LinearExpr weight;
+    for (int i = 0; i < data.num_items; ++i) {
+      weight += data.weights[i] * LinearExpr(x[i][j]);
+    }
+    solver.MakeRowConstraint(weight <= LinearExpr(y[j]) * data.bin_capacity);
+  }
+  // [END constraints]
+
+  // [START objective]
+  // Create the objective function.
+  MPObjective* const objective = solver.MutableObjective();
+  LinearExpr num_bins_used;
+  for (int j = 0; j < data.num_bins; ++j) {
+    num_bins_used += y[j];
+  }
+  objective->MinimizeLinearExpr(num_bins_used);
+  // [END objective]
+
+  // [START solve]
+  const MPSolver::ResultStatus result_status = solver.Solve();
+  // [END solve]
+
+  // [START print_solution]
+  // Check that the problem has an optimal solution.
+  if (result_status != MPSolver::OPTIMAL) {
+    std::cerr << "The problem does not have an optimal solution!";
+    return;
+  }
+  std::cout << "Number of bins used: " << objective->Value() << std::endl
+            << std::endl;
+  double total_weight = 0;
+  for (int j = 0; j < data.num_bins; ++j) {
+    if (y[j]->solution_value() == 1) {
+      std::cout << "Bin " << j << std::endl << std::endl;
+      double bin_weight = 0;
+      for (int i = 0; i < data.num_items; ++i) {
+        if (x[i][j]->solution_value() == 1) {
+          std::cout << "Item " << i << " - Weight: " << data.weights[i]
+                    << std::endl;
+          bin_weight += data.weights[i];
+        }
+      }
+      std::cout << "Packed bin weight: " << bin_weight << std::endl
+                << std::endl;
+      total_weight += bin_weight;
+    }
+  }
+  std::cout << "Total packed weight: " << total_weight << std::endl;
+  // [END print_solution]
+}
+}  // namespace operations_research
+
+int main(int argc, char** argv) {
+  operations_research::BinPackingMip();
+  return EXIT_SUCCESS;
+}
+// [END program_part2]
+// [END program]

libs/or-tools-src-ubuntu/examples/cpp/binpacking_problem_sat.cc

+// Copyright 2010-2018 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ortools/sat/cp_model.h"
+
+namespace operations_research {
+namespace sat {
+
+void BinpackingProblemSat() {
+  // Data.
+  const int kBinCapacity = 100;
+  const int kSlackCapacity = 20;
+  const int kNumBins = 5;
+
+  const std::vector<std::vector<int>> items = {
+      {20, 6}, {15, 6}, {30, 4}, {45, 3}};
+  const int num_items = items.size();
+
+  // Model.
+  CpModelBuilder cp_model;
+
+  // Main variables.
+  std::vector<std::vector<IntVar>> x(num_items);
+  for (int i = 0; i < num_items; ++i) {
+    const int num_copies = items[i][1];
+    for (int b = 0; b < kNumBins; ++b) {
+      x[i].push_back(cp_model.NewIntVar({0, num_copies}));
+    }
+  }
+
+  // Load variables.
+  std::vector<IntVar> load(kNumBins);
+  for (int b = 0; b < kNumBins; ++b) {
+    load[b] = cp_model.NewIntVar({0, kBinCapacity});
+  }
+
+  // Slack variables.
+  std::vector<BoolVar> slacks(kNumBins);
+  for (int b = 0; b < kNumBins; ++b) {
+    slacks[b] = cp_model.NewBoolVar();
+  }
+
+  // Links load and x.
+  for (int b = 0; b < kNumBins; ++b) {
+    LinearExpr expr;
+    for (int i = 0; i < num_items; ++i) {
+      expr.AddTerm(x[i][b], items[i][0]);
+    }
+    cp_model.AddEquality(expr, load[b]);
+  }
+
+  // Place all items.
+  for (int i = 0; i < num_items; ++i) {
+    cp_model.AddEquality(LinearExpr::Sum(x[i]), items[i][1]);
+  }
+
+  // Links load and slack through an equivalence relation.
+  const int safe_capacity = kBinCapacity - kSlackCapacity;
+  for (int b = 0; b < kNumBins; ++b) {
+    // slack[b] => load[b] <= safe_capacity.
+    cp_model.AddLessOrEqual(load[b], safe_capacity).OnlyEnforceIf(slacks[b]);
+    // not(slack[b]) => load[b] > safe_capacity.
+    cp_model.AddGreaterThan(load[b], safe_capacity)
+        .OnlyEnforceIf(Not(slacks[b]));
+  }
+
+  // Maximize sum of slacks.
+  cp_model.Maximize(LinearExpr::BooleanSum(slacks));
+
+  // Solving part.
+  const CpSolverResponse response = Solve(cp_model.Build());
+  LOG(INFO) << CpSolverResponseStats(response);
+}
+
+}  // namespace sat
+}  // namespace operations_research
+
+int main() {
+  operations_research::sat::BinpackingProblemSat();
+
+  return EXIT_SUCCESS;
+}

libs/or-tools-src-ubuntu/examples/cpp/bool_or_sample_sat.cc

+// Copyright 2010-2018 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ortools/sat/cp_model.h"
+
+namespace operations_research {
+namespace sat {
+
+void BoolOrSampleSat() {
+  CpModelBuilder cp_model;
+
+  const BoolVar x = cp_model.NewBoolVar();
+  const BoolVar y = cp_model.NewBoolVar();
+  cp_model.AddBoolOr({x, Not(y)});
+}
+
+}  // namespace sat
+}  // namespace operations_research
+
+int main() {
+  operations_research::sat::BoolOrSampleSat();
+
+  return EXIT_SUCCESS;
+}

libs/or-tools-src-ubuntu/examples/cpp/channeling_sample_sat.cc

+// Copyright 2010-2018 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ortools/sat/cp_model.h"
+#include "ortools/sat/model.h"
+#include "ortools/sat/sat_parameters.pb.h"
+
+namespace operations_research {
+namespace sat {
+
+void ChannelingSampleSat() {
+  // Create the CP-SAT model.
+  CpModelBuilder cp_model;
+
+  // Declare our two primary variables.
+  const IntVar x = cp_model.NewIntVar({0, 10});
+  const IntVar y = cp_model.NewIntVar({0, 10});
+
+  // Declare our intermediate boolean variable.
+  const BoolVar b = cp_model.NewBoolVar();
+
+  // Implement b == (x >= 5).
+  cp_model.AddGreaterOrEqual(x, 5).OnlyEnforceIf(b);
+  cp_model.AddLessThan(x, 5).OnlyEnforceIf(Not(b));
+
+  // Create our two half-reified constraints.
+  // First, b implies (y == 10 - x).
+  cp_model.AddEquality(LinearExpr::Sum({x, y}), 10).OnlyEnforceIf(b);
+  // Second, not(b) implies y == 0.
+  cp_model.AddEquality(y, 0).OnlyEnforceIf(Not(b));
+
+  // Search for x values in increasing order.
+  cp_model.AddDecisionStrategy({x}, DecisionStrategyProto::CHOOSE_FIRST,
+                               DecisionStrategyProto::SELECT_MIN_VALUE);
+
+  // Create a solver and solve with a fixed search.
+  Model model;
+  SatParameters parameters;
+  parameters.set_search_branching(SatParameters::FIXED_SEARCH);
+  parameters.set_enumerate_all_solutions(true);
+  model.Add(NewSatParameters(parameters));
+  model.Add(NewFeasibleSolutionObserver([&](const CpSolverResponse& r) {
+    LOG(INFO) << "x=" << SolutionIntegerValue(r, x)
+              << " y=" << SolutionIntegerValue(r, y)
+              << " b=" << SolutionBooleanValue(r, b);
+  }));
+  SolveCpModel(cp_model.Build(), &model);
+}
+
+}  // namespace sat
+}  // namespace operations_research
+
+int main() {
+  operations_research::sat::ChannelingSampleSat();
+
+  return EXIT_SUCCESS;
+}

libs/or-tools-src-ubuntu/examples/cpp/cp_is_fun_sat.cc

+// Copyright 2010-2018 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// [START program]
+// Cryptarithmetic puzzle
+//
+// First attempt to solve equation CP + IS + FUN = TRUE
+// where each letter represents a unique digit.
+//
+// This problem has 72 different solutions in base 10.
+
+#include <vector>
+
+#include "ortools/sat/cp_model.h"
+#include "ortools/sat/model.h"
+#include "ortools/sat/sat_parameters.pb.h"
+
+namespace operations_research {
+namespace sat {
+
+void CPIsFunSat() {
+  // Instantiate the solver.
+  CpModelBuilder cp_model;
+
+  // [START variables]
+  const int64 kBase = 10;
+
+  // Define decision variables.
+  Domain digit(0, kBase - 1);
+  Domain non_zero_digit(1, kBase - 1);
+
+  IntVar c = cp_model.NewIntVar(non_zero_digit).WithName("C");
+  IntVar p = cp_model.NewIntVar(digit).WithName("P");
+  IntVar i = cp_model.NewIntVar(non_zero_digit).WithName("I");
+  IntVar s = cp_model.NewIntVar(digit).WithName("S");
+  IntVar f = cp_model.NewIntVar(non_zero_digit).WithName("F");
+  IntVar u = cp_model.NewIntVar(digit).WithName("U");
+  IntVar n = cp_model.NewIntVar(digit).WithName("N");
+  IntVar t = cp_model.NewIntVar(non_zero_digit).WithName("T");
+  IntVar r = cp_model.NewIntVar(digit).WithName("R");
+  IntVar e = cp_model.NewIntVar(digit).WithName("E");
+  // [END variables]
+
+  // [START constraints]
+  // Define constraints.
+  cp_model.AddAllDifferent({c, p, i, s, f, u, n, t, r, e});
+
+  // CP + IS + FUN = TRUE
+  cp_model.AddEquality(
+      LinearExpr::ScalProd({c, p, i, s, f, u, n},
+                           {kBase, 1, kBase, 1, kBase * kBase, kBase, 1}),
+      LinearExpr::ScalProd({t, r, u, e},
+                           {kBase * kBase * kBase, kBase * kBase, kBase, 1}));
+  // [END constraints]
+
+  // [START solution_printing]
+  Model model;
+  int num_solutions = 0;
+  model.Add(NewFeasibleSolutionObserver([&](const CpSolverResponse& response) {
+    LOG(INFO) << "Solution " << num_solutions;
+    LOG(INFO) << "C=" << SolutionIntegerValue(response, c) << " "
+              << "P=" << SolutionIntegerValue(response, p) << " "
+              << "I=" << SolutionIntegerValue(response, i) << " "
+              << "S=" << SolutionIntegerValue(response, s) << " "
+              << "F=" << SolutionIntegerValue(response, f) << " "
+              << "U=" << SolutionIntegerValue(response, u) << " "
+              << "N=" << SolutionIntegerValue(response, n) << " "
+              << "T=" << SolutionIntegerValue(response, t) << " "
+              << "R=" << SolutionIntegerValue(response, r) << " "
+              << "E=" << SolutionIntegerValue(response, e);
+    num_solutions++;
+  }));
+  // [END solution_printing]
+
+  // [START solve]
+  // Tell the solver to enumerate all solutions.
+  SatParameters parameters;
+  parameters.set_enumerate_all_solutions(true);
+  model.Add(NewSatParameters(parameters));
+
+  const CpSolverResponse response = SolveCpModel(cp_model.Build(), &model);
+  LOG(INFO) << "Number of solutions found: " << num_solutions;
+  // [END solve]
+}
+
+}  // namespace sat
+}  // namespace operations_research
+
+// ----- MAIN -----
+int main(int argc, char** argv) {
+  operations_research::sat::CPIsFunSat();
+
+  return EXIT_SUCCESS;
+}
+// [END program]

libs/or-tools-src-ubuntu/examples/cpp/cvrp_disjoint_tw.cc

+// Copyright 2010-2018 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//
+// Capacitated Vehicle Routing Problem with Disjoint Time Windows (and optional
+// orders).
+// A description of the problem can be found here:
+// http://en.wikipedia.org/wiki/Vehicle_routing_problem.
+// The variant which is tackled by this model includes a capacity dimension,
+// disjoint time windows and optional orders, with a penalty cost if orders are
+// not performed. For the sake of simplicty, orders are randomly located and
+// distances are computed using the Manhattan distance. Distances are assumed
+// to be in meters and times in seconds.
+
+#include <vector>
+
+#include "examples/cpp/cvrptw_lib.h"
+#include "google/protobuf/text_format.h"
+#include "ortools/base/commandlineflags.h"
+#include "ortools/base/integral_types.h"
+#include "ortools/base/logging.h"
+#include "ortools/constraint_solver/routing.h"
+#include "ortools/constraint_solver/routing_index_manager.h"
+#include "ortools/constraint_solver/routing_parameters.h"
+#include "ortools/constraint_solver/routing_parameters.pb.h"
+
+using operations_research::ACMRandom;
+using operations_research::Assignment;
+using operations_research::DefaultRoutingSearchParameters;
+using operations_research::GetSeed;
+using operations_research::LocationContainer;
+using operations_research::RandomDemand;
+using operations_research::RoutingDimension;
+using operations_research::RoutingIndexManager;
+using operations_research::RoutingModel;
+using operations_research::RoutingNodeIndex;
+using operations_research::RoutingSearchParameters;
+using operations_research::ServiceTimePlusTransition;
+using operations_research::Solver;
+
+DEFINE_int32(vrp_orders, 100, "Nodes in the problem.");
+DEFINE_int32(vrp_vehicles, 20, "Size of Traveling Salesman Problem instance.");
+DEFINE_int32(vrp_windows, 5, "Number of disjoint windows per node.");
+DEFINE_bool(vrp_use_deterministic_random_seed, false,
+            "Use deterministic random seeds.");
+DEFINE_bool(vrp_use_same_vehicle_costs, false,
+            "Use same vehicle costs in the routing model");
+DEFINE_string(routing_search_parameters, "",
+              "Text proto RoutingSearchParameters (possibly partial) that will "
+              "override the DefaultRoutingSearchParameters()");
+
+const char* kTime = "Time";
+const char* kCapacity = "Capacity";
+const int64 kMaxNodesPerGroup = 10;
+const int64 kSameVehicleCost = 1000;
+
+int main(int argc, char** argv) {
+  gflags::ParseCommandLineFlags(&argc, &argv, true);
+  CHECK_LT(0, FLAGS_vrp_orders) << "Specify an instance size greater than 0.";
+  CHECK_LT(0, FLAGS_vrp_vehicles) << "Specify a non-null vehicle fleet size.";
+  // VRP of size FLAGS_vrp_size.
+  // Nodes are indexed from 0 to FLAGS_vrp_orders, the starts and ends of
+  // the routes are at node 0.
+  const RoutingIndexManager::NodeIndex kDepot(0);
+  RoutingIndexManager manager(FLAGS_vrp_orders + 1, FLAGS_vrp_vehicles, kDepot);
+  RoutingModel routing(manager);
+
+  // Setting up locations.
+  const int64 kXMax = 100000;
+  const int64 kYMax = 100000;
+  const int64 kSpeed = 10;
+  LocationContainer locations(kSpeed, FLAGS_vrp_use_deterministic_random_seed);
+  for (int location = 0; location <= FLAGS_vrp_orders; ++location) {
+    locations.AddRandomLocation(kXMax, kYMax);
+  }
+
+  // Setting the cost function.
+  const int vehicle_cost =
+      routing.RegisterTransitCallback([&locations, &manager](int64 i, int64 j) {
+        return locations.ManhattanDistance(manager.IndexToNode(i),
+                                           manager.IndexToNode(j));
+      });
+  routing.SetArcCostEvaluatorOfAllVehicles(vehicle_cost);
+
+  // Adding capacity dimension constraints.
+  const int64 kVehicleCapacity = 40;
+  const int64 kNullCapacitySlack = 0;
+  RandomDemand demand(manager.num_nodes(), kDepot,
+                      FLAGS_vrp_use_deterministic_random_seed);
+  demand.Initialize();
+  routing.AddDimension(
+      routing.RegisterTransitCallback([&demand, &manager](int64 i, int64 j) {
+        return demand.Demand(manager.IndexToNode(i), manager.IndexToNode(j));
+      }),
+      kNullCapacitySlack, kVehicleCapacity,
+      /*fix_start_cumul_to_zero=*/true, kCapacity);
+
+  // Adding time dimension constraints.
+  const int64 kTimePerDemandUnit = 300;
+  const int64 kHorizon = 24 * 3600;
+  ServiceTimePlusTransition time(
+      kTimePerDemandUnit,
+      [&demand](RoutingNodeIndex i, RoutingNodeIndex j) {
+        return demand.Demand(i, j);
+      },
+      [&locations](RoutingNodeIndex i, RoutingNodeIndex j) {
+        return locations.ManhattanTime(i, j);
+      });
+  routing.AddDimension(
+      routing.RegisterTransitCallback([&time, &manager](int64 i, int64 j) {
+        return time.Compute(manager.IndexToNode(i), manager.IndexToNode(j));
+      }),
+      kHorizon, kHorizon, /*fix_start_cumul_to_zero=*/false, kTime);
+  const RoutingDimension& time_dimension = routing.GetDimensionOrDie(kTime);
+
+  // Adding disjoint time windows.
+  Solver* solver = routing.solver();
+  ACMRandom randomizer(GetSeed(FLAGS_vrp_use_deterministic_random_seed));
+  for (int order = 1; order < manager.num_nodes(); ++order) {
+    std::vector<int64> forbid_points(2 * FLAGS_vrp_windows, 0);
+    for (int i = 0; i < forbid_points.size(); ++i) {
+      forbid_points[i] = randomizer.Uniform(kHorizon);
+    }
+    std::sort(forbid_points.begin(), forbid_points.end());
+    std::vector<int64> forbid_starts(1, 0);
+    std::vector<int64> forbid_ends;
+    for (int i = 0; i < forbid_points.size(); i += 2) {
+      forbid_ends.push_back(forbid_points[i]);
+      forbid_starts.push_back(forbid_points[i + 1]);
+    }
+    forbid_ends.push_back(kHorizon);
+    solver->AddConstraint(solver->MakeNotMemberCt(
+        time_dimension.CumulVar(order), forbid_starts, forbid_ends));
+  }
+
+  // Adding penalty costs to allow skipping orders.
+  const int64 kPenalty = 10000000;
+  const RoutingIndexManager::NodeIndex kFirstNodeAfterDepot(1);
+  for (RoutingIndexManager::NodeIndex order = kFirstNodeAfterDepot;
+       order < manager.num_nodes(); ++order) {
+    std::vector<int64> orders(1, manager.NodeToIndex(order));
+    routing.AddDisjunction(orders, kPenalty);
+  }
+
+  // Adding same vehicle constraint costs for consecutive nodes.
+  if (FLAGS_vrp_use_same_vehicle_costs) {
+    std::vector<int64> group;
+    for (RoutingIndexManager::NodeIndex order = kFirstNodeAfterDepot;
+         order < manager.num_nodes(); ++order) {
+      group.push_back(manager.NodeToIndex(order));
+      if (group.size() == kMaxNodesPerGroup) {
+        routing.AddSoftSameVehicleConstraint(group, kSameVehicleCost);
+        group.clear();
+      }
+    }
+    if (!group.empty()) {
+      routing.AddSoftSameVehicleConstraint(group, kSameVehicleCost);
+    }
+  }
+
+  // Solve, returns a solution if any (owned by RoutingModel).
+  RoutingSearchParameters parameters = DefaultRoutingSearchParameters();
+  CHECK(google::protobuf::TextFormat::MergeFromString(
+      FLAGS_routing_search_parameters, &parameters));
+  const Assignment* solution = routing.SolveWithParameters(parameters);
+  if (solution != nullptr) {
+    DisplayPlan(manager, routing, *solution, FLAGS_vrp_use_same_vehicle_costs,
+                kMaxNodesPerGroup, kSameVehicleCost,
+                routing.GetDimensionOrDie(kCapacity),
+                routing.GetDimensionOrDie(kTime));
+  } else {
+    LOG(INFO) << "No solution found.";
+  }
+  return EXIT_SUCCESS;
+}

libs/or-tools-src-ubuntu/examples/cpp/cvrptw.cc

+// Copyright 2010-2018 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//
+// Capacitated Vehicle Routing Problem with Time Windows (and optional orders).
+// A description of the problem can be found here:
+// http://en.wikipedia.org/wiki/Vehicle_routing_problem.
+// The variant which is tackled by this model includes a capacity dimension,
+// time windows and optional orders, with a penalty cost if orders are not
+// performed. For the sake of simplicty, orders are randomly located and
+// distances are computed using the Manhattan distance. Distances are assumed
+// to be in meters and times in seconds.
+
+#include <vector>
+
+#include "examples/cpp/cvrptw_lib.h"
+#include "google/protobuf/text_format.h"
+#include "ortools/base/commandlineflags.h"
+#include "ortools/base/integral_types.h"
+#include "ortools/base/logging.h"
+#include "ortools/base/random.h"
+#include "ortools/constraint_solver/routing.h"
+#include "ortools/constraint_solver/routing_index_manager.h"
+#include "ortools/constraint_solver/routing_parameters.h"
+#include "ortools/constraint_solver/routing_parameters.pb.h"
+
+using operations_research::ACMRandom;
+using operations_research::Assignment;
+using operations_research::DefaultRoutingSearchParameters;
+using operations_research::GetSeed;
+using operations_research::LocationContainer;
+using operations_research::RandomDemand;
+using operations_research::RoutingDimension;
+using operations_research::RoutingIndexManager;
+using operations_research::RoutingModel;
+using operations_research::RoutingNodeIndex;
+using operations_research::RoutingSearchParameters;
+using operations_research::ServiceTimePlusTransition;
+
+DEFINE_int32(vrp_orders, 100, "Nodes in the problem.");
+DEFINE_int32(vrp_vehicles, 20, "Size of Traveling Salesman Problem instance.");
+DEFINE_bool(vrp_use_deterministic_random_seed, false,
+            "Use deterministic random seeds.");
+DEFINE_bool(vrp_use_same_vehicle_costs, false,
+            "Use same vehicle costs in the routing model");
+DEFINE_string(routing_search_parameters, "",
+              "Text proto RoutingSearchParameters (possibly partial) that will "
+              "override the DefaultRoutingSearchParameters()");
+
+const char* kTime = "Time";
+const char* kCapacity = "Capacity";
+const int64 kMaxNodesPerGroup = 10;
+const int64 kSameVehicleCost = 1000;
+
+int main(int argc, char** argv) {
+  gflags::ParseCommandLineFlags(&argc, &argv, true);
+  CHECK_LT(0, FLAGS_vrp_orders) << "Specify an instance size greater than 0.";
+  CHECK_LT(0, FLAGS_vrp_vehicles) << "Specify a non-null vehicle fleet size.";
+  // VRP of size FLAGS_vrp_size.
+  // Nodes are indexed from 0 to FLAGS_vrp_orders, the starts and ends of
+  // the routes are at node 0.
+  const RoutingIndexManager::NodeIndex kDepot(0);
+  RoutingIndexManager manager(FLAGS_vrp_orders + 1, FLAGS_vrp_vehicles, kDepot);
+  RoutingModel routing(manager);
+
+  // Setting up locations.
+  const int64 kXMax = 100000;
+  const int64 kYMax = 100000;
+  const int64 kSpeed = 10;
+  LocationContainer locations(kSpeed, FLAGS_vrp_use_deterministic_random_seed);
+  for (int location = 0; location <= FLAGS_vrp_orders; ++location) {
+    locations.AddRandomLocation(kXMax, kYMax);
+  }
+
+  // Setting the cost function.
+  const int vehicle_cost =
+      routing.RegisterTransitCallback([&locations, &manager](int64 i, int64 j) {
+        return locations.ManhattanDistance(manager.IndexToNode(i),
+                                           manager.IndexToNode(j));
+      });
+  routing.SetArcCostEvaluatorOfAllVehicles(vehicle_cost);
+
+  // Adding capacity dimension constraints.
+  const int64 kVehicleCapacity = 40;
+  const int64 kNullCapacitySlack = 0;
+  RandomDemand demand(manager.num_nodes(), kDepot,
+                      FLAGS_vrp_use_deterministic_random_seed);
+  demand.Initialize();
+  routing.AddDimension(
+      routing.RegisterTransitCallback([&demand, &manager](int64 i, int64 j) {
+        return demand.Demand(manager.IndexToNode(i), manager.IndexToNode(j));
+      }),
+      kNullCapacitySlack, kVehicleCapacity,
+      /*fix_start_cumul_to_zero=*/true, kCapacity);
+
+  // Adding time dimension constraints.
+  const int64 kTimePerDemandUnit = 300;
+  const int64 kHorizon = 24 * 3600;
+  ServiceTimePlusTransition time(
+      kTimePerDemandUnit,
+      [&demand](RoutingNodeIndex i, RoutingNodeIndex j) {
+        return demand.Demand(i, j);
+      },
+      [&locations](RoutingNodeIndex i, RoutingNodeIndex j) {
+        return locations.ManhattanTime(i, j);
+      });
+  routing.AddDimension(
+      routing.RegisterTransitCallback([&time, &manager](int64 i, int64 j) {
+        return time.Compute(manager.IndexToNode(i), manager.IndexToNode(j));
+      }),
+      kHorizon, kHorizon, /*fix_start_cumul_to_zero=*/true, kTime);
+  const RoutingDimension& time_dimension = routing.GetDimensionOrDie(kTime);
+
+  // Adding time windows.
+  ACMRandom randomizer(GetSeed(FLAGS_vrp_use_deterministic_random_seed));
+  const int64 kTWDuration = 5 * 3600;
+  for (int order = 1; order < manager.num_nodes(); ++order) {
+    const int64 start = randomizer.Uniform(kHorizon - kTWDuration);
+    time_dimension.CumulVar(order)->SetRange(start, start + kTWDuration);
+  }
+
+  // Adding penalty costs to allow skipping orders.
+  const int64 kPenalty = 10000000;
+  const RoutingIndexManager::NodeIndex kFirstNodeAfterDepot(1);
+  for (RoutingIndexManager::NodeIndex order = kFirstNodeAfterDepot;
+       order < manager.num_nodes(); ++order) {
+    std::vector<int64> orders(1, manager.NodeToIndex(order));
+    routing.AddDisjunction(orders, kPenalty);
+  }
+
+  // Adding same vehicle constraint costs for consecutive nodes.
+  if (FLAGS_vrp_use_same_vehicle_costs) {
+    std::vector<int64> group;
+    for (RoutingIndexManager::NodeIndex order = kFirstNodeAfterDepot;
+         order < manager.num_nodes(); ++order) {
+      group.push_back(manager.NodeToIndex(order));
+      if (group.size() == kMaxNodesPerGroup) {
+        routing.AddSoftSameVehicleConstraint(group, kSameVehicleCost);
+        group.clear();
+      }
+    }
+    if (!group.empty()) {
+      routing.AddSoftSameVehicleConstraint(group, kSameVehicleCost);
+    }
+  }
+
+  // Solve, returns a solution if any (owned by RoutingModel).
+  RoutingSearchParameters parameters = DefaultRoutingSearchParameters();
+  CHECK(google::protobuf::TextFormat::MergeFromString(
+      FLAGS_routing_search_parameters, &parameters));
+  const Assignment* solution = routing.SolveWithParameters(parameters);
+  if (solution != nullptr) {
+    DisplayPlan(manager, routing, *solution, FLAGS_vrp_use_same_vehicle_costs,
+                kMaxNodesPerGroup, kSameVehicleCost,
+                routing.GetDimensionOrDie(kCapacity),
+                routing.GetDimensionOrDie(kTime));
+  } else {
+    LOG(INFO) << "No solution found.";
+  }
+  return EXIT_SUCCESS;
+}

libs/or-tools-src-ubuntu/examples/cpp/cvrptw_with_breaks.cc

+// Copyright 2010-2018 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//
+// Capacitated Vehicle Routing Problem with Time Windows and Breaks.
+// A description of the Capacitated Vehicle Routing Problem with Time Windows
+// can be found here:
+// http://en.wikipedia.org/wiki/Vehicle_routing_problem.
+// The variant which is tackled by this model includes a capacity dimension,
+// time windows and optional orders, with a penalty cost if orders are not
+// performed. For the sake of simplicty, orders are randomly located and
+// distances are computed using the Manhattan distance. Distances are assumed
+// to be in meters and times in seconds.
+// This variant also includes vehicle breaks which must happen during the day
+// with two alternate breaks schemes: either a long break in the middle of the
+// day or two smaller ones which can be taken during a longer period of the day.
+
+#include <vector>
+
+#include "absl/strings/str_cat.h"
+#include "examples/cpp/cvrptw_lib.h"
+#include "google/protobuf/text_format.h"
+#include "ortools/base/commandlineflags.h"
+#include "ortools/base/integral_types.h"
+#include "ortools/base/logging.h"
+#include "ortools/base/random.h"
+#include "ortools/constraint_solver/routing.h"
+#include "ortools/constraint_solver/routing_enums.pb.h"
+#include "ortools/constraint_solver/routing_index_manager.h"
+#include "ortools/constraint_solver/routing_parameters.h"
+#include "ortools/constraint_solver/routing_parameters.pb.h"
+
+using operations_research::ACMRandom;
+using operations_research::Assignment;
+using operations_research::DefaultRoutingSearchParameters;
+using operations_research::FirstSolutionStrategy;
+using operations_research::GetSeed;
+using operations_research::IntervalVar;
+using operations_research::LocationContainer;
+using operations_research::RandomDemand;
+using operations_research::RoutingDimension;
+using operations_research::RoutingIndexManager;
+using operations_research::RoutingModel;
+using operations_research::RoutingNodeIndex;
+using operations_research::RoutingSearchParameters;
+using operations_research::ServiceTimePlusTransition;
+using operations_research::Solver;
+
+DEFINE_int32(vrp_orders, 100, "Nodes in the problem.");
+DEFINE_int32(vrp_vehicles, 20, "Size of Traveling Salesman Problem instance.");
+DEFINE_bool(vrp_use_deterministic_random_seed, false,
+            "Use deterministic random seeds.");
+DEFINE_string(routing_search_parameters, "",
+              "Text proto RoutingSearchParameters (possibly partial) that will "
+              "override the DefaultRoutingSearchParameters()");
+
+const char* kTime = "Time";
+const char* kCapacity = "Capacity";
+
+int main(int argc, char** argv) {
+  gflags::ParseCommandLineFlags(&argc, &argv, true);
+  CHECK_LT(0, FLAGS_vrp_orders) << "Specify an instance size greater than 0.";
+  CHECK_LT(0, FLAGS_vrp_vehicles) << "Specify a non-null vehicle fleet size.";
+  // VRP of size FLAGS_vrp_size.
+  // Nodes are indexed from 0 to FLAGS_vrp_orders, the starts and ends of
+  // the routes are at node 0.
+  const RoutingIndexManager::NodeIndex kDepot(0);
+  RoutingIndexManager manager(FLAGS_vrp_orders + 1, FLAGS_vrp_vehicles, kDepot);
+  RoutingModel routing(manager);
+  RoutingSearchParameters parameters = DefaultRoutingSearchParameters();
+  CHECK(google::protobuf::TextFormat::MergeFromString(
+      FLAGS_routing_search_parameters, &parameters));
+  parameters.set_first_solution_strategy(
+      FirstSolutionStrategy::PARALLEL_CHEAPEST_INSERTION);
+
+  // Setting up locations.
+  const int64 kXMax = 100000;
+  const int64 kYMax = 100000;
+  const int64 kSpeed = 10;
+  LocationContainer locations(kSpeed, FLAGS_vrp_use_deterministic_random_seed);
+  for (int location = 0; location <= FLAGS_vrp_orders; ++location) {
+    locations.AddRandomLocation(kXMax, kYMax);
+  }
+
+  // Setting the cost function.
+  const int vehicle_cost =
+      routing.RegisterTransitCallback([&locations, &manager](int64 i, int64 j) {
+        return locations.ManhattanDistance(manager.IndexToNode(i),
+                                           manager.IndexToNode(j));
+      });
+  routing.SetArcCostEvaluatorOfAllVehicles(vehicle_cost);
+
+  // Adding capacity dimension constraints.
+  const int64 kVehicleCapacity = 40;
+  const int64 kNullCapacitySlack = 0;
+  RandomDemand demand(manager.num_nodes(), kDepot,
+                      FLAGS_vrp_use_deterministic_random_seed);
+  demand.Initialize();
+  routing.AddDimension(
+      routing.RegisterTransitCallback([&demand, &manager](int64 i, int64 j) {
+        return demand.Demand(manager.IndexToNode(i), manager.IndexToNode(j));
+      }),
+      kNullCapacitySlack, kVehicleCapacity,
+      /*fix_start_cumul_to_zero=*/true, kCapacity);
+
+  // Adding time dimension constraints.
+  const int64 kTimePerDemandUnit = 300;
+  const int64 kHorizon = 24 * 3600;
+  ServiceTimePlusTransition time(
+      kTimePerDemandUnit,
+      [&demand](RoutingNodeIndex i, RoutingNodeIndex j) {
+        return demand.Demand(i, j);
+      },
+      [&locations](RoutingNodeIndex i, RoutingNodeIndex j) {
+        return locations.ManhattanTime(i, j);
+      });
+  routing.AddDimension(
+      routing.RegisterTransitCallback([&time, &manager](int64 i, int64 j) {
+        return time.Compute(manager.IndexToNode(i), manager.IndexToNode(j));
+      }),
+      kHorizon, kHorizon, /*fix_start_cumul_to_zero=*/false, kTime);
+  RoutingDimension* const time_dimension = routing.GetMutableDimension(kTime);
+
+  // Adding time windows.
+  ACMRandom randomizer(GetSeed(FLAGS_vrp_use_deterministic_random_seed));
+  const int64 kTWDuration = 5 * 3600;
+  for (int order = 1; order < manager.num_nodes(); ++order) {
+    const int64 start = randomizer.Uniform(kHorizon - kTWDuration);
+    time_dimension->CumulVar(order)->SetRange(start, start + kTWDuration);
+    routing.AddToAssignment(time_dimension->SlackVar(order));
+  }
+
+  // Minimize time variables.
+  for (int i = 0; i < routing.Size(); ++i) {
+    routing.AddVariableMinimizedByFinalizer(time_dimension->CumulVar(i));
+  }
+  for (int j = 0; j < FLAGS_vrp_vehicles; ++j) {
+    routing.AddVariableMinimizedByFinalizer(
+        time_dimension->CumulVar(routing.Start(j)));
+    routing.AddVariableMinimizedByFinalizer(
+        time_dimension->CumulVar(routing.End(j)));
+  }
+
+  // Adding vehicle breaks:
+  // - 40min breaks between 11:00am and 1:00pm
+  // or
+  // - 2 x 30min breaks between 10:00am and 3:00pm, at least 1h apart
+  // First, fill service time vector.
+  std::vector<int64> service_times(routing.Size());
+  for (int node = 0; node < routing.Size(); node++) {
+    if (node >= routing.nodes()) {
+      service_times[node] = 0;
+    } else {
+      const RoutingIndexManager::NodeIndex index(node);
+      service_times[node] = kTimePerDemandUnit * demand.Demand(index, index);
+    }
+  }
+  const std::vector<std::vector<int>> break_data = {
+      {/*start_min*/ 11, /*start_max*/ 13, /*duration*/ 2400},
+      {/*start_min*/ 10, /*start_max*/ 15, /*duration*/ 1800},
+      {/*start_min*/ 10, /*start_max*/ 15, /*duration*/ 1800}};
+  Solver* const solver = routing.solver();
+  for (int vehicle = 0; vehicle < FLAGS_vrp_vehicles; ++vehicle) {
+    std::vector<IntervalVar*> breaks;
+    for (int i = 0; i < break_data.size(); ++i) {
+      IntervalVar* const break_interval = solver->MakeFixedDurationIntervalVar(
+          break_data[i][0] * 3600, break_data[i][1] * 3600, break_data[i][2],
+          true, absl::StrCat("Break ", i, " on vehicle ", vehicle));
+      breaks.push_back(break_interval);
+    }
+    // break1 performed iff break2 performed
+    solver->AddConstraint(solver->MakeEquality(breaks[1]->PerformedExpr(),
+                                               breaks[2]->PerformedExpr()));
+    // break2 start 1h after break1.
+    solver->AddConstraint(solver->MakeIntervalVarRelationWithDelay(
+        breaks[2], Solver::STARTS_AFTER_END, breaks[1], 3600));
+    // break0 performed iff break2 unperformed
+    solver->AddConstraint(solver->MakeNonEquality(breaks[0]->PerformedExpr(),
+                                                  breaks[2]->PerformedExpr()));
+
+    time_dimension->SetBreakIntervalsOfVehicle(std::move(breaks), vehicle,
+                                               service_times);
+  }
+
+  // Adding penalty costs to allow skipping orders.
+  const int64 kPenalty = 10000000;
+  const RoutingIndexManager::NodeIndex kFirstNodeAfterDepot(1);
+  for (RoutingIndexManager::NodeIndex order = kFirstNodeAfterDepot;
+       order < routing.nodes(); ++order) {
+    std::vector<int64> orders(1, manager.NodeToIndex(order));
+    routing.AddDisjunction(orders, kPenalty);
+  }
+
+  // Solve, returns a solution if any (owned by RoutingModel).
+  const Assignment* solution = routing.SolveWithParameters(parameters);
+  if (solution != nullptr) {
+    LOG(INFO) << "Breaks: ";
+    for (const auto& break_interval :
+         solution->IntervalVarContainer().elements()) {
+      if (break_interval.PerformedValue() == 1) {
+        LOG(INFO) << break_interval.Var()->name() << " "
+                  << break_interval.DebugString();
+      } else {
+        LOG(INFO) << break_interval.Var()->name() << " unperformed";
+      }
+    }
+    DisplayPlan(manager, routing, *solution, false, 0, 0,
+                routing.GetDimensionOrDie(kCapacity),
+                routing.GetDimensionOrDie(kTime));
+  } else {
+    LOG(INFO) << "No solution found.";
+  }
+  return EXIT_SUCCESS;
+}

libs/or-tools-src-ubuntu/examples/cpp/cvrptw_with_refueling.cc

+// Copyright 2010-2018 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Capacitated Vehicle Routing Problem with Time Windows and refueling
+// constraints.
+// This is an extension to the model in cvrptw.cc so refer to that file for
+// more information on the common part of the model. The model implemented here
+// takes into account refueling constraints using a specific dimension: vehicles
+// must visit certain nodes (refueling nodes) before the quantity of fuel
+// reaches zero. Fuel consumption is proportional to the distance traveled.
+
+#include <vector>
+
+#include "examples/cpp/cvrptw_lib.h"
+#include "google/protobuf/text_format.h"
+#include "ortools/base/commandlineflags.h"
+#include "ortools/base/integral_types.h"
+#include "ortools/base/logging.h"
+#include "ortools/base/random.h"
+#include "ortools/constraint_solver/routing.h"
+#include "ortools/constraint_solver/routing_index_manager.h"
+#include "ortools/constraint_solver/routing_parameters.h"
+#include "ortools/constraint_solver/routing_parameters.pb.h"
+
+using operations_research::ACMRandom;
+using operations_research::Assignment;
+using operations_research::DefaultRoutingSearchParameters;
+using operations_research::GetSeed;
+using operations_research::LocationContainer;
+using operations_research::RandomDemand;
+using operations_research::RoutingDimension;
+using operations_research::RoutingIndexManager;
+using operations_research::RoutingModel;
+using operations_research::RoutingNodeIndex;
+using operations_research::RoutingSearchParameters;
+using operations_research::ServiceTimePlusTransition;
+
+DEFINE_int32(vrp_orders, 100, "Nodes in the problem.");
+DEFINE_int32(vrp_vehicles, 20, "Size of Traveling Salesman Problem instance.");
+DEFINE_bool(vrp_use_deterministic_random_seed, false,
+            "Use deterministic random seeds.");
+DEFINE_string(routing_search_parameters, "",
+              "Text proto RoutingSearchParameters (possibly partial) that will "
+              "override the DefaultRoutingSearchParameters()");
+
+const char* kTime = "Time";
+const char* kCapacity = "Capacity";
+const char* kFuel = "Fuel";
+
+// Returns true if node is a refueling node (based on node / refuel node ratio).
+bool IsRefuelNode(int64 node) {
+  const int64 kRefuelNodeRatio = 10;
+  return (node % kRefuelNodeRatio == 0);
+}
+
+int main(int argc, char** argv) {
+  gflags::ParseCommandLineFlags(&argc, &argv, true);
+  CHECK_LT(0, FLAGS_vrp_orders) << "Specify an instance size greater than 0.";
+  CHECK_LT(0, FLAGS_vrp_vehicles) << "Specify a non-null vehicle fleet size.";
+  // VRP of size FLAGS_vrp_size.
+  // Nodes are indexed from 0 to FLAGS_vrp_orders, the starts and ends of
+  // the routes are at node 0.
+  const RoutingIndexManager::NodeIndex kDepot(0);
+  RoutingIndexManager manager(FLAGS_vrp_orders + 1, FLAGS_vrp_vehicles, kDepot);
+  RoutingModel routing(manager);
+
+  // Setting up locations.
+  const int64 kXMax = 100000;
+  const int64 kYMax = 100000;
+  const int64 kSpeed = 10;
+  LocationContainer locations(kSpeed, FLAGS_vrp_use_deterministic_random_seed);
+  for (int location = 0; location <= FLAGS_vrp_orders; ++location) {
+    locations.AddRandomLocation(kXMax, kYMax);
+  }
+
+  // Setting the cost function.
+  const int vehicle_cost =
+      routing.RegisterTransitCallback([&locations, &manager](int64 i, int64 j) {
+        return locations.ManhattanDistance(manager.IndexToNode(i),
+                                           manager.IndexToNode(j));
+      });
+  routing.SetArcCostEvaluatorOfAllVehicles(vehicle_cost);
+
+  // Adding capacity dimension constraints.
+  const int64 kVehicleCapacity = 40;
+  const int64 kNullCapacitySlack = 0;
+  RandomDemand demand(manager.num_nodes(), kDepot,
+                      FLAGS_vrp_use_deterministic_random_seed);
+  demand.Initialize();
+  routing.AddDimension(
+      routing.RegisterTransitCallback([&demand, &manager](int64 i, int64 j) {
+        return demand.Demand(manager.IndexToNode(i), manager.IndexToNode(j));
+      }),
+      kNullCapacitySlack, kVehicleCapacity,
+      /*fix_start_cumul_to_zero=*/true, kCapacity);
+
+  // Adding time dimension constraints.
+  const int64 kTimePerDemandUnit = 300;
+  const int64 kHorizon = 24 * 3600;
+  ServiceTimePlusTransition time(
+      kTimePerDemandUnit,
+      [&demand](RoutingNodeIndex i, RoutingNodeIndex j) {
+        return demand.Demand(i, j);
+      },
+      [&locations](RoutingNodeIndex i, RoutingNodeIndex j) {
+        return locations.ManhattanTime(i, j);
+      });
+  routing.AddDimension(
+      routing.RegisterTransitCallback([&time, &manager](int64 i, int64 j) {
+        return time.Compute(manager.IndexToNode(i), manager.IndexToNode(j));
+      }),
+      kHorizon, kHorizon, /*fix_start_cumul_to_zero=*/true, kTime);
+  const RoutingDimension& time_dimension = routing.GetDimensionOrDie(kTime);
+  // Adding time windows.
+  ACMRandom randomizer(GetSeed(FLAGS_vrp_use_deterministic_random_seed));
+  const int64 kTWDuration = 5 * 3600;
+  for (int order = 1; order < manager.num_nodes(); ++order) {
+    if (!IsRefuelNode(order)) {
+      const int64 start = randomizer.Uniform(kHorizon - kTWDuration);
+      time_dimension.CumulVar(order)->SetRange(start, start + kTWDuration);
+    }
+  }
+
+  // Adding fuel dimension. This dimension consumes a quantity equal to the
+  // distance traveled. Only refuel nodes can make the quantity of dimension
+  // increase by letting slack variable replenish the fuel.
+  const int64 kFuelCapacity = kXMax + kYMax;
+  routing.AddDimension(
+      routing.RegisterTransitCallback([&locations, &manager](int64 i, int64 j) {
+        return locations.NegManhattanDistance(manager.IndexToNode(i),
+                                              manager.IndexToNode(j));
+      }),
+      kFuelCapacity, kFuelCapacity, /*fix_start_cumul_to_zero=*/false, kFuel);
+  const RoutingDimension& fuel_dimension = routing.GetDimensionOrDie(kFuel);
+  for (int order = 0; order < routing.Size(); ++order) {
+    // Only let slack free for refueling nodes.
+    if (!IsRefuelNode(order) || routing.IsStart(order)) {
+      fuel_dimension.SlackVar(order)->SetValue(0);
+    }
+    // Needed to instantiate fuel quantity at each node.
+    routing.AddVariableMinimizedByFinalizer(fuel_dimension.CumulVar(order));
+  }
+
+  // Adding penalty costs to allow skipping orders.
+  const int64 kPenalty = 100000;
+  const RoutingIndexManager::NodeIndex kFirstNodeAfterDepot(1);
+  for (RoutingIndexManager::NodeIndex order = kFirstNodeAfterDepot;
+       order < routing.nodes(); ++order) {
+    std::vector<int64> orders(1, manager.NodeToIndex(order));
+    routing.AddDisjunction(orders, kPenalty);
+  }
+
+  // Solve, returns a solution if any (owned by RoutingModel).
+  RoutingSearchParameters parameters = DefaultRoutingSearchParameters();
+  CHECK(google::protobuf::TextFormat::MergeFromString(
+      FLAGS_routing_search_parameters, &parameters));
+  const Assignment* solution = routing.SolveWithParameters(parameters);
+  if (solution != nullptr) {
+    DisplayPlan(manager, routing, *solution, /*use_same_vehicle_costs=*/false,
+                /*max_nodes_per_group=*/0, /*same_vehicle_cost=*/0,
+                routing.GetDimensionOrDie(kCapacity),
+                routing.GetDimensionOrDie(kTime));
+  } else {
+    LOG(INFO) << "No solution found.";
+  }
+  return EXIT_SUCCESS;
+}

libs/or-tools-src-ubuntu/examples/cpp/cvrptw_with_resources.cc

+// Copyright 2010-2018 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Capacitated Vehicle Routing Problem with Time Windows and capacitated
+// resources.
+// This is an extension to the model in cvrptw.cc so refer to that file for
+// more information on the common part of the model. The model implemented here
+// limits the number of vehicles which can simultaneously leave or enter the
+// depot due to limited resources (or capacity) available.
+// TODO(user): The current model consumes resources even for vehicles with
+// empty routes; fix this when we have an API on the cumulative constraints
+// with variable demands.
+
+#include <vector>
+
+#include "examples/cpp/cvrptw_lib.h"
+#include "google/protobuf/text_format.h"
+#include "ortools/base/commandlineflags.h"
+#include "ortools/base/integral_types.h"
+#include "ortools/base/logging.h"
+#include "ortools/base/random.h"
+#include "ortools/constraint_solver/routing.h"
+#include "ortools/constraint_solver/routing_index_manager.h"
+#include "ortools/constraint_solver/routing_parameters.h"
+#include "ortools/constraint_solver/routing_parameters.pb.h"
+
+using operations_research::ACMRandom;
+using operations_research::Assignment;
+using operations_research::DefaultRoutingSearchParameters;
+using operations_research::GetSeed;
+using operations_research::IntervalVar;
+using operations_research::IntVar;
+using operations_research::LocationContainer;
+using operations_research::RandomDemand;
+using operations_research::RoutingDimension;
+using operations_research::RoutingIndexManager;
+using operations_research::RoutingModel;
+using operations_research::RoutingNodeIndex;
+using operations_research::RoutingSearchParameters;
+using operations_research::ServiceTimePlusTransition;
+using operations_research::Solver;
+
+DEFINE_int32(vrp_orders, 100, "Nodes in the problem.");
+DEFINE_int32(vrp_vehicles, 20, "Size of Traveling Salesman Problem instance.");
+DEFINE_bool(vrp_use_deterministic_random_seed, false,
+            "Use deterministic random seeds.");
+DEFINE_string(routing_search_parameters, "",
+              "Text proto RoutingSearchParameters (possibly partial) that will "
+              "override the DefaultRoutingSearchParameters()");
+
+const char* kTime = "Time";
+const char* kCapacity = "Capacity";
+
+int main(int argc, char** argv) {
+  gflags::ParseCommandLineFlags(&argc, &argv, true);
+  CHECK_LT(0, FLAGS_vrp_orders) << "Specify an instance size greater than 0.";
+  CHECK_LT(0, FLAGS_vrp_vehicles) << "Specify a non-null vehicle fleet size.";
+  // VRP of size FLAGS_vrp_size.
+  // Nodes are indexed from 0 to FLAGS_vrp_orders, the starts and ends of
+  // the routes are at node 0.
+  const RoutingIndexManager::NodeIndex kDepot(0);
+  RoutingIndexManager manager(FLAGS_vrp_orders + 1, FLAGS_vrp_vehicles, kDepot);
+  RoutingModel routing(manager);
+
+  // Setting up locations.
+  const int64 kXMax = 100000;
+  const int64 kYMax = 100000;
+  const int64 kSpeed = 10;
+  LocationContainer locations(kSpeed, FLAGS_vrp_use_deterministic_random_seed);
+  for (int location = 0; location <= FLAGS_vrp_orders; ++location) {
+    locations.AddRandomLocation(kXMax, kYMax);
+  }
+
+  // Setting the cost function.
+  const int vehicle_cost =
+      routing.RegisterTransitCallback([&locations, &manager](int64 i, int64 j) {
+        return locations.ManhattanDistance(manager.IndexToNode(i),
+                                           manager.IndexToNode(j));
+      });
+  routing.SetArcCostEvaluatorOfAllVehicles(vehicle_cost);
+
+  // Adding capacity dimension constraints.
+  const int64 kVehicleCapacity = 40;
+  const int64 kNullCapacitySlack = 0;
+  RandomDemand demand(manager.num_nodes(), kDepot,
+                      FLAGS_vrp_use_deterministic_random_seed);
+  demand.Initialize();
+  routing.AddDimension(
+      routing.RegisterTransitCallback([&demand, &manager](int64 i, int64 j) {
+        return demand.Demand(manager.IndexToNode(i), manager.IndexToNode(j));
+      }),
+      kNullCapacitySlack, kVehicleCapacity,
+      /*fix_start_cumul_to_zero=*/true, kCapacity);
+
+  // Adding time dimension constraints.
+  const int64 kTimePerDemandUnit = 300;
+  const int64 kHorizon = 24 * 3600;
+  ServiceTimePlusTransition time(
+      kTimePerDemandUnit,
+      [&demand](RoutingNodeIndex i, RoutingNodeIndex j) {
+        return demand.Demand(i, j);
+      },
+      [&locations](RoutingNodeIndex i, RoutingNodeIndex j) {
+        return locations.ManhattanTime(i, j);
+      });
+  routing.AddDimension(
+      routing.RegisterTransitCallback([&time, &manager](int64 i, int64 j) {
+        return time.Compute(manager.IndexToNode(i), manager.IndexToNode(j));
+      }),
+      kHorizon, kHorizon, /*fix_start_cumul_to_zero=*/false, kTime);
+  const RoutingDimension& time_dimension = routing.GetDimensionOrDie(kTime);
+
+  // Adding time windows.
+  ACMRandom randomizer(GetSeed(FLAGS_vrp_use_deterministic_random_seed));
+  const int64 kTWDuration = 5 * 3600;
+  for (int order = 1; order < manager.num_nodes(); ++order) {
+    const int64 start = randomizer.Uniform(kHorizon - kTWDuration);
+    time_dimension.CumulVar(order)->SetRange(start, start + kTWDuration);
+  }
+
+  // Adding resource constraints at the depot (start and end location of
+  // routes).
+  std::vector<IntVar*> start_end_times;
+  for (int i = 0; i < FLAGS_vrp_vehicles; ++i) {
+    start_end_times.push_back(time_dimension.CumulVar(routing.End(i)));
+    start_end_times.push_back(time_dimension.CumulVar(routing.Start(i)));
+  }
+  // Build corresponding time intervals.
+  const int64 kVehicleSetup = 180;
+  Solver* const solver = routing.solver();
+  std::vector<IntervalVar*> intervals;
+  solver->MakeFixedDurationIntervalVarArray(start_end_times, kVehicleSetup,
+                                            "depot_interval", &intervals);
+  // Constrain the number of maximum simultaneous intervals at depot.
+  const int64 kDepotCapacity = 5;
+  std::vector<int64> depot_usage(start_end_times.size(), 1);
+  solver->AddConstraint(
+      solver->MakeCumulative(intervals, depot_usage, kDepotCapacity, "depot"));
+  // Instantiate route start and end times to produce feasible times.
+  for (int i = 0; i < start_end_times.size(); ++i) {
+    routing.AddVariableMinimizedByFinalizer(start_end_times[i]);
+  }
+
+  // Adding penalty costs to allow skipping orders.
+  const int64 kPenalty = 100000;
+  const RoutingIndexManager::NodeIndex kFirstNodeAfterDepot(1);
+  for (RoutingIndexManager::NodeIndex order = kFirstNodeAfterDepot;
+       order < manager.num_nodes(); ++order) {
+    std::vector<int64> orders(1, manager.NodeToIndex(order));
+    routing.AddDisjunction(orders, kPenalty);
+  }
+
+  // Solve, returns a solution if any (owned by RoutingModel).
+  RoutingSearchParameters parameters = DefaultRoutingSearchParameters();
+  CHECK(google::protobuf::TextFormat::MergeFromString(
+      FLAGS_routing_search_parameters, &parameters));
+  const Assignment* solution = routing.SolveWithParameters(parameters);
+  if (solution != nullptr) {
+    DisplayPlan(manager, routing, *solution, /*use_same_vehicle_costs=*/false,
+                /*max_nodes_per_group=*/0, /*same_vehicle_cost=*/0,
+                routing.GetDimensionOrDie(kCapacity),
+                routing.GetDimensionOrDie(kTime));
+  } else {
+    LOG(INFO) << "No solution found.";
+  }
+  return EXIT_SUCCESS;
+}

libs/or-tools-src-ubuntu/examples/cpp/cvrptw_with_stop_times_and_resources.cc

+// Copyright 2010-2018 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Capacitated Vehicle Routing Problem with Time Windows, fixed stop times and
+// capacitated resources. A stop is defined as consecutive nodes at the same
+// location.
+// This is an extension to the model in cvrptw.cc so refer to that file for
+// more information on the common part of the model. The model implemented here
+// limits the number of vehicles which can simultaneously leave or enter a node
+// to one.
+
+#include <vector>
+
+#include "absl/strings/str_cat.h"
+#include "examples/cpp/cvrptw_lib.h"
+#include "google/protobuf/text_format.h"
+#include "ortools/base/commandlineflags.h"
+#include "ortools/base/integral_types.h"
+#include "ortools/base/logging.h"
+#include "ortools/base/random.h"
+#include "ortools/constraint_solver/routing.h"
+#include "ortools/constraint_solver/routing_index_manager.h"
+#include "ortools/constraint_solver/routing_parameters.h"
+#include "ortools/constraint_solver/routing_parameters.pb.h"
+
+using operations_research::ACMRandom;
+using operations_research::Assignment;
+using operations_research::DefaultRoutingSearchParameters;
+using operations_research::GetSeed;
+using operations_research::IntervalVar;
+using operations_research::IntVar;
+using operations_research::LocationContainer;
+using operations_research::RandomDemand;
+using operations_research::RoutingDimension;
+using operations_research::RoutingIndexManager;
+using operations_research::RoutingModel;
+using operations_research::RoutingNodeIndex;
+using operations_research::RoutingSearchParameters;
+using operations_research::Solver;
+using operations_research::StopServiceTimePlusTransition;
+
+DEFINE_int32(vrp_stops, 25, "Stop locations in the problem.");
+DEFINE_int32(vrp_orders_per_stop, 5, "Nodes for each stop.");
+DEFINE_int32(vrp_vehicles, 20, "Size of Traveling Salesman Problem instance.");
+DEFINE_bool(vrp_use_deterministic_random_seed, false,
+            "Use deterministic random seeds.");
+DEFINE_string(routing_search_parameters, "",
+              "Text proto RoutingSearchParameters (possibly partial) that will "
+              "override the DefaultRoutingSearchParameters()");
+
+const char* kTime = "Time";
+const char* kCapacity = "Capacity";
+
+int main(int argc, char** argv) {
+  gflags::ParseCommandLineFlags(&argc, &argv, true);
+  CHECK_LT(0, FLAGS_vrp_stops) << "Specify an instance size greater than 0.";
+  CHECK_LT(0, FLAGS_vrp_orders_per_stop)
+      << "Specify an instance size greater than 0.";
+  CHECK_LT(0, FLAGS_vrp_vehicles) << "Specify a non-null vehicle fleet size.";
+  const int vrp_orders = FLAGS_vrp_stops * FLAGS_vrp_orders_per_stop;
+  // Nodes are indexed from 0 to vrp_orders, the starts and ends of the routes
+  // are at node 0.
+  const RoutingIndexManager::NodeIndex kDepot(0);
+  RoutingIndexManager manager(vrp_orders + 1, FLAGS_vrp_vehicles, kDepot);
+  RoutingModel routing(manager);
+
+  // Setting up locations.
+  const int64 kXMax = 100000;
+  const int64 kYMax = 100000;
+  const int64 kSpeed = 10;
+  LocationContainer locations(kSpeed, FLAGS_vrp_use_deterministic_random_seed);
+  for (int stop = 0; stop <= FLAGS_vrp_stops; ++stop) {
+    const int num_orders = stop == 0 ? 1 : FLAGS_vrp_orders_per_stop;
+    locations.AddRandomLocation(kXMax, kYMax, num_orders);
+  }
+
+  // Setting the cost function.
+  const int vehicle_cost =
+      routing.RegisterTransitCallback([&locations, &manager](int64 i, int64 j) {
+        return locations.ManhattanDistance(manager.IndexToNode(i),
+                                           manager.IndexToNode(j));
+      });
+  routing.SetArcCostEvaluatorOfAllVehicles(vehicle_cost);
+
+  // Adding capacity dimension constraints.
+  const int64 kVehicleCapacity = 40;
+  const int64 kNullCapacitySlack = 0;
+  RandomDemand demand(manager.num_nodes(), kDepot,
+                      FLAGS_vrp_use_deterministic_random_seed);
+  demand.Initialize();
+  routing.AddDimension(
+      routing.RegisterTransitCallback([&demand, &manager](int64 i, int64 j) {
+        return demand.Demand(manager.IndexToNode(i), manager.IndexToNode(j));
+      }),
+      kNullCapacitySlack, kVehicleCapacity,
+      /*fix_start_cumul_to_zero=*/true, kCapacity);
+
+  // Adding time dimension constraints.
+  const int64 kStopTime = 300;
+  const int64 kHorizon = 24 * 3600;
+  StopServiceTimePlusTransition time(
+      kStopTime, locations,
+      [&locations](RoutingNodeIndex i, RoutingNodeIndex j) {
+        return locations.ManhattanTime(i, j);
+      });
+  routing.AddDimension(
+      routing.RegisterTransitCallback([&time, &manager](int64 i, int64 j) {
+        return time.Compute(manager.IndexToNode(i), manager.IndexToNode(j));
+      }),
+      kHorizon, kHorizon, /*fix_start_cumul_to_zero=*/false, kTime);
+  const RoutingDimension& time_dimension = routing.GetDimensionOrDie(kTime);
+
+  // Adding time windows, for the sake of simplicty same for each stop.
+  ACMRandom randomizer(GetSeed(FLAGS_vrp_use_deterministic_random_seed));
+  const int64 kTWDuration = 5 * 3600;
+  for (int stop = 0; stop < FLAGS_vrp_stops; ++stop) {
+    const int64 start = randomizer.Uniform(kHorizon - kTWDuration);
+    for (int stop_order = 0; stop_order < FLAGS_vrp_orders_per_stop;
+         ++stop_order) {
+      const int order = stop * FLAGS_vrp_orders_per_stop + stop_order + 1;
+      time_dimension.CumulVar(order)->SetRange(start, start + kTWDuration);
+    }
+  }
+
+  // Adding resource constraints at order locations.
+  Solver* const solver = routing.solver();
+  std::vector<IntervalVar*> intervals;
+  for (int stop = 0; stop < FLAGS_vrp_stops; ++stop) {
+    std::vector<IntervalVar*> stop_intervals;
+    for (int stop_order = 0; stop_order < FLAGS_vrp_orders_per_stop;
+         ++stop_order) {
+      const int order = stop * FLAGS_vrp_orders_per_stop + stop_order + 1;
+      IntervalVar* const interval = solver->MakeFixedDurationIntervalVar(
+          0, kHorizon, kStopTime, true, absl::StrCat("Order", order));
+      intervals.push_back(interval);
+      stop_intervals.push_back(interval);
+      // Link order and interval.
+      IntVar* const order_start = time_dimension.CumulVar(order);
+      solver->AddConstraint(
+          solver->MakeIsEqualCt(interval->SafeStartExpr(0), order_start,
+                                interval->PerformedExpr()->Var()));
+      // Make interval performed iff corresponding order has service time.
+      // An order has no service time iff it is at the same location as the
+      // next order on the route.
+      IntVar* const is_null_duration =
+          solver
+              ->MakeElement(
+                  [&locations, order](int64 index) {
+                    return locations.SameLocationFromIndex(order, index);
+                  },
+                  routing.NextVar(order))
+              ->Var();
+      solver->AddConstraint(
+          solver->MakeNonEquality(interval->PerformedExpr(), is_null_duration));
+      routing.AddIntervalToAssignment(interval);
+      // We are minimizing route durations by minimizing route ends; so we can
+      // maximize order starts to pack them together.
+      routing.AddVariableMaximizedByFinalizer(order_start);
+    }
+    // Only one order can happen at the same time at a given location.
+    std::vector<int64> location_usage(stop_intervals.size(), 1);
+    solver->AddConstraint(solver->MakeCumulative(
+        stop_intervals, location_usage, 1, absl::StrCat("Client", stop)));
+  }
+  // Minimizing route duration.
+  for (int vehicle = 0; vehicle < manager.num_vehicles(); ++vehicle) {
+    routing.AddVariableMinimizedByFinalizer(
+        time_dimension.CumulVar(routing.End(vehicle)));
+  }
+
+  // Adding penalty costs to allow skipping orders.
+  const int64 kPenalty = 100000;
+  const RoutingIndexManager::NodeIndex kFirstNodeAfterDepot(1);
+  for (RoutingIndexManager::NodeIndex order = kFirstNodeAfterDepot;
+       order < routing.nodes(); ++order) {
+    std::vector<int64> orders(1, manager.NodeToIndex(order));
+    routing.AddDisjunction(orders, kPenalty);
+  }
+
+  // Solve, returns a solution if any (owned by RoutingModel).
+  RoutingSearchParameters parameters = DefaultRoutingSearchParameters();
+  CHECK(google::protobuf::TextFormat::MergeFromString(
+      FLAGS_routing_search_parameters, &parameters));
+  const Assignment* solution = routing.SolveWithParameters(parameters);
+  if (solution != nullptr) {
+    DisplayPlan(manager, routing, *solution, /*use_same_vehicle_costs=*/false,
+                /*max_nodes_per_group=*/0, /*same_vehicle_cost=*/0,
+                routing.GetDimensionOrDie(kCapacity),
+                routing.GetDimensionOrDie(kTime));
+    LOG(INFO) << "Stop intervals:";
+    for (IntervalVar* const interval : intervals) {
+      if (solution->PerformedValue(interval)) {
+        LOG(INFO) << interval->name() << ": " << solution->StartValue(interval);
+      }
+    }
+  } else {
+    LOG(INFO) << "No solution found.";
+  }
+  return EXIT_SUCCESS;
+}

libs/or-tools-src-ubuntu/examples/cpp/dimacs_assignment.cc

+// Copyright 2010-2018 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <algorithm>
+#include <cmath>
+#include <cstdlib>
+#include <string>
+#include <vector>
+#include "absl/container/flat_hash_map.h"
+
+#include "absl/strings/str_format.h"
+#include "examples/cpp/parse_dimacs_assignment.h"
+#include "examples/cpp/print_dimacs_assignment.h"
+#include "ortools/algorithms/hungarian.h"
+#include "ortools/base/commandlineflags.h"
+#include "ortools/base/logging.h"
+#include "ortools/base/timer.h"
+#include "ortools/graph/ebert_graph.h"
+#include "ortools/graph/linear_assignment.h"
+
+DEFINE_bool(assignment_compare_hungarian, false,
+            "Compare result and speed against Hungarian method.");
+DEFINE_string(assignment_problem_output_file, "",
+              "Print the problem to this file in DIMACS format (after layout "
+              "is optimized, if applicable).");
+DEFINE_bool(assignment_reverse_arcs, false,
+            "Ignored if --assignment_static_graph=true. Use StarGraph "
+            "if true, ForwardStarGraph if false.");
+DEFINE_bool(assignment_static_graph, true,
+            "Use the ForwardStarStaticGraph representation, "
+            "otherwise ForwardStarGraph or StarGraph according "
+            "to --assignment_reverse_arcs.");
+
+namespace operations_research {
+
+typedef ForwardStarStaticGraph GraphType;
+
+template <typename GraphType>
+CostValue BuildAndSolveHungarianInstance(
+    const LinearSumAssignment<GraphType>& assignment) {
+  const GraphType& graph = assignment.Graph();
+  typedef std::vector<double> HungarianRow;
+  typedef std::vector<HungarianRow> HungarianProblem;
+  HungarianProblem hungarian_cost;
+  hungarian_cost.resize(assignment.NumLeftNodes());
+  // First we have to find the biggest cost magnitude so we can
+  // initialize the arc costs that aren't really there.
+  CostValue largest_cost_magnitude = 0;
+  for (typename GraphType::ArcIterator arc_it(graph); arc_it.Ok();
+       arc_it.Next()) {
+    ArcIndex arc = arc_it.Index();
+    CostValue cost_magnitude = std::abs(assignment.ArcCost(arc));
+    largest_cost_magnitude = std::max(largest_cost_magnitude, cost_magnitude);
+  }
+  double missing_arc_cost = static_cast<double>(
+      (assignment.NumLeftNodes() * largest_cost_magnitude) + 1);
+  for (HungarianProblem::iterator row = hungarian_cost.begin();
+       row != hungarian_cost.end(); ++row) {
+    row->resize(assignment.NumNodes() - assignment.NumLeftNodes(),
+                missing_arc_cost);
+  }
+  // We're using a graph representation without forward arcs, so in
+  // order to use the generic GraphType::ArcIterator we would
+  // need to increase our memory footprint by building the array of
+  // arc tails (since we need tails to build the input to the
+  // hungarian algorithm). We opt for the alternative of iterating
+  // over hte arcs via adjacency lists, which gives us the arc tails
+  // implicitly.
+  for (typename GraphType::NodeIterator node_it(graph); node_it.Ok();
+       node_it.Next()) {
+    NodeIndex node = node_it.Index();
+    NodeIndex tail = (node - GraphType::kFirstNode);
+    for (typename GraphType::OutgoingArcIterator arc_it(graph, node);
+         arc_it.Ok(); arc_it.Next()) {
+      ArcIndex arc = arc_it.Index();
+      NodeIndex head =
+          (graph.Head(arc) - assignment.NumLeftNodes() - GraphType::kFirstNode);
+      double cost = static_cast<double>(assignment.ArcCost(arc));
+      hungarian_cost[tail][head] = cost;
+    }
+  }
+  absl::flat_hash_map<int, int> result;
+  absl::flat_hash_map<int, int> wish_this_could_be_null;
+  WallTimer timer;
+  VLOG(1) << "Beginning Hungarian method.";
+  timer.Start();
+  MinimizeLinearAssignment(hungarian_cost, &result, &wish_this_could_be_null);
+  double elapsed = timer.GetInMs() / 1000.0;
+  LOG(INFO) << "Hungarian result computed in " << elapsed << " seconds.";
+  double result_cost = 0.0;
+  for (int i = 0; i < assignment.NumLeftNodes(); ++i) {
+    int mate = result[i];
+    result_cost += hungarian_cost[i][mate];
+  }
+  return static_cast<CostValue>(result_cost);
+}
+
+template <typename GraphType>
+void DisplayAssignment(const LinearSumAssignment<GraphType>& assignment) {
+  for (typename LinearSumAssignment<GraphType>::BipartiteLeftNodeIterator
+           node_it(assignment);
+       node_it.Ok(); node_it.Next()) {
+    const NodeIndex left_node = node_it.Index();
+    const ArcIndex matching_arc = assignment.GetAssignmentArc(left_node);
+    const NodeIndex right_node = assignment.Head(matching_arc);
+    VLOG(5) << "assigned (" << left_node << ", " << right_node
+            << "): " << assignment.ArcCost(matching_arc);
+  }
+}
+
+template <typename GraphType>
+int SolveDimacsAssignment(int argc, char* argv[]) {
+  std::string error_message;
+  // Handle on the graph we will need to delete because the
+  // LinearSumAssignment object does not take ownership of it.
+  GraphType* graph = nullptr;
+  DimacsAssignmentParser<GraphType> parser(argv[1]);
+  LinearSumAssignment<GraphType>* assignment =
+      parser.Parse(&error_message, &graph);
+  if (assignment == nullptr) {
+    LOG(FATAL) << error_message;
+  }
+  if (!FLAGS_assignment_problem_output_file.empty()) {
+    // The following tail array management stuff is done in a generic
+    // way so we can plug in different types of graphs for which the
+    // TailArrayManager template can be instantiated, even though we
+    // know the type of the graph explicitly. In this way, the type of
+    // the graph can be switched just by changing the graph type in
+    // this file and making no other changes to the code.
+    TailArrayManager<GraphType> tail_array_manager(graph);
+    PrintDimacsAssignmentProblem<GraphType>(
+        *assignment, tail_array_manager, FLAGS_assignment_problem_output_file);
+    tail_array_manager.ReleaseTailArrayIfForwardGraph();
+  }
+  CostValue hungarian_cost = 0.0;
+  bool hungarian_solved = false;
+  if (FLAGS_assignment_compare_hungarian) {
+    hungarian_cost = BuildAndSolveHungarianInstance(*assignment);
+    hungarian_solved = true;
+  }
+  WallTimer timer;
+  timer.Start();
+  bool success = assignment->ComputeAssignment();
+  double elapsed = timer.GetInMs() / 1000.0;
+  if (success) {
+    CostValue cost = assignment->GetCost();
+    DisplayAssignment(*assignment);
+    LOG(INFO) << "Cost of optimum assignment: " << cost;
+    LOG(INFO) << "Computed in " << elapsed << " seconds.";
+    LOG(INFO) << assignment->StatsString();
+    if (hungarian_solved && (cost != hungarian_cost)) {
+      LOG(ERROR) << "Optimum cost mismatch: " << cost << " vs. "
+                 << hungarian_cost << ".";
+    }
+  } else {
+    LOG(WARNING) << "Given problem is infeasible.";
+  }
+  delete assignment;
+  delete graph;
+  return EXIT_SUCCESS;
+}
+}  // namespace operations_research
+
+static const char* const kUsageTemplate = "usage: %s <filename>";
+
+using ::operations_research::ForwardStarGraph;
+using ::operations_research::ForwardStarStaticGraph;
+using ::operations_research::SolveDimacsAssignment;
+using ::operations_research::StarGraph;
+
+int main(int argc, char* argv[]) {
+  std::string usage;
+  if (argc < 1) {
+    usage = absl::StrFormat(kUsageTemplate, "solve_dimacs_assignment");
+  } else {
+    usage = absl::StrFormat(kUsageTemplate, argv[0]);
+  }
+  gflags::SetUsageMessage(usage);
+  gflags::ParseCommandLineFlags(&argc, &argv, true);
+
+  if (argc < 2) {
+    LOG(FATAL) << usage;
+  }
+
+  if (FLAGS_assignment_static_graph) {
+    return SolveDimacsAssignment<ForwardStarStaticGraph>(argc, argv);
+  } else if (FLAGS_assignment_reverse_arcs) {
+    return SolveDimacsAssignment<StarGraph>(argc, argv);
+  } else {
+    return SolveDimacsAssignment<ForwardStarGraph>(argc, argv);
+  }
+}

libs/or-tools-src-ubuntu/examples/cpp/earliness_tardiness_cost_sample_sat.cc

+// Copyright 2010-2018 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ortools/sat/cp_model.h"
+#include "ortools/sat/model.h"
+#include "ortools/sat/sat_parameters.pb.h"
+
+namespace operations_research {
+namespace sat {
+
+void EarlinessTardinessCostSampleSat() {
+  const int64 kEarlinessDate = 5;
+  const int64 kEarlinessCost = 8;
+  const int64 kLatenessDate = 15;
+  const int64 kLatenessCost = 12;
+
+  // Create the CP-SAT model.
+  CpModelBuilder cp_model;
+
+  // Declare our primary variable.
+  const IntVar x = cp_model.NewIntVar({0, 20});
+
+  // Create the expression variable and implement the piecewise linear function.
+  //
+  //  \        /
+  //   \______/
+  //   ed    ld
+  //
+  const int64 kLargeConstant = 1000;
+  const IntVar expr = cp_model.NewIntVar({0, kLargeConstant});
+
+  // First segment.
+  const IntVar s1 = cp_model.NewIntVar({-kLargeConstant, kLargeConstant});
+  cp_model.AddEquality(s1, LinearExpr::ScalProd({x}, {-kEarlinessCost})
+                               .AddConstant(kEarlinessCost * kEarlinessDate));
+
+  // Second segment.
+  const IntVar s2 = cp_model.NewConstant(0);
+
+  // Third segment.
+  const IntVar s3 = cp_model.NewIntVar({-kLargeConstant, kLargeConstant});
+  cp_model.AddEquality(s3, LinearExpr::ScalProd({x}, {kLatenessCost})
+                               .AddConstant(-kLatenessCost * kLatenessDate));
+
+  // Link together expr and x through s1, s2, and s3.
+  cp_model.AddMaxEquality(expr, {s1, s2, s3});
+
+  // Search for x values in increasing order.
+  cp_model.AddDecisionStrategy({x}, DecisionStrategyProto::CHOOSE_FIRST,
+                               DecisionStrategyProto::SELECT_MIN_VALUE);
+
+  // Create a solver and solve with a fixed search.
+  Model model;
+  SatParameters parameters;
+  parameters.set_search_branching(SatParameters::FIXED_SEARCH);
+  parameters.set_enumerate_all_solutions(true);
+  model.Add(NewSatParameters(parameters));
+  model.Add(NewFeasibleSolutionObserver([&](const CpSolverResponse& r) {
+    LOG(INFO) << "x=" << SolutionIntegerValue(r, x) << " expr"
+              << SolutionIntegerValue(r, expr);
+  }));
+  SolveCpModel(cp_model.Build(), &model);
+}
+
+}  // namespace sat
+}  // namespace operations_research
+
+int main() {
+  operations_research::sat::EarlinessTardinessCostSampleSat();
+
+  return EXIT_SUCCESS;
+}

libs/or-tools-src-ubuntu/examples/cpp/fap_model_printer.h

+// Copyright 2010-2018 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//
+// Prints a model of Frequency Assignment Problem.
+// Format: http://www.inra.fr/mia/T/schiex/Doc/CELAR.shtml#synt
+//
+
+#ifndef OR_TOOLS_EXAMPLES_FAP_MODEL_PRINTER_H_
+#define OR_TOOLS_EXAMPLES_FAP_MODEL_PRINTER_H_
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "absl/strings/str_format.h"
+#include "examples/cpp/fap_parser.h"
+
+namespace operations_research {
+
+// Prints the instance of the Frequency Assignment Problem.
+class FapModelPrinter {
+ public:
+  FapModelPrinter(const std::map<int, FapVariable>& variables,
+                  const std::vector<FapConstraint>& constraints,
+                  const std::string& objective, const std::vector<int>& values);
+  ~FapModelPrinter();
+
+  void PrintFapObjective();
+  void PrintFapVariables();
+  void PrintFapConstraints();
+  void PrintFapValues();
+
+ private:
+  const std::map<int, FapVariable> variables_;
+  const std::vector<FapConstraint> constraints_;
+  const std::string objective_;
+  const std::vector<int> values_;
+  DISALLOW_COPY_AND_ASSIGN(FapModelPrinter);
+};
+
+FapModelPrinter::FapModelPrinter(const std::map<int, FapVariable>& variables,
+                                 const std::vector<FapConstraint>& constraints,
+                                 const std::string& objective,
+                                 const std::vector<int>& values)
+    : variables_(variables),
+      constraints_(constraints),
+      objective_(objective),
+      values_(values) {}
+
+FapModelPrinter::~FapModelPrinter() {}
+
+void FapModelPrinter::PrintFapVariables() {
+  LOG(INFO) << "Variable File:";
+  for (const auto& it : variables_) {
+    std::string domain = "{";
+    for (const int value : it.second.domain) {
+      absl::StrAppendFormat(&domain, "%d ", value);
+    }
+    domain.append("}");
+
+    std::string hard = " ";
+    if (it.second.hard) {
+      hard = " hard";
+    }
+
+    LOG(INFO) << "Variable " << absl::StrFormat("%3d: ", it.first)
+              << absl::StrFormat("(degree: %2d) ", it.second.degree)
+              << absl::StrFormat("%3d", it.second.domain_index)
+              << absl::StrFormat("%3d", it.second.initial_position)
+              << absl::StrFormat("%3d", it.second.mobility_index)
+              << absl::StrFormat("%8d", it.second.mobility_cost)
+              << absl::StrFormat(" (%2d) ", it.second.domain_size) << domain
+              << hard;
+  }
+}
+
+void FapModelPrinter::PrintFapConstraints() {
+  LOG(INFO) << "Constraint File:";
+  for (const FapConstraint& ct : constraints_) {
+    std::string hard = " ";
+    if (ct.hard) {
+      hard = " hard";
+    }
+
+    LOG(INFO) << absl::StrFormat("%3d ", ct.variable1)
+              << absl::StrFormat("%3d ", ct.variable2) << ct.type << " "
+              << ct.operation << " " << absl::StrFormat("%3d", ct.value)
+              << absl::StrFormat("%3d", ct.weight_index)
+              << absl::StrFormat("%8d", ct.weight_cost) << hard;
+  }
+}
+
+void FapModelPrinter::PrintFapObjective() {
+  LOG(INFO) << "Objective: " << objective_;
+}
+
+void FapModelPrinter::PrintFapValues() {
+  LOG(INFO) << absl::StrFormat("Values(%d): ", values_.size());
+  std::string domain = " ";
+  for (const int value : values_) {
+    absl::StrAppendFormat(&domain, "%d ", value);
+  }
+  LOG(INFO) << domain;
+}
+
+}  // namespace operations_research
+#endif  // OR_TOOLS_EXAMPLES_FAP_MODEL_PRINTER_H_

libs/or-tools-src-ubuntu/examples/cpp/flow_api.cc

+// Copyright 2010-2018 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ortools/base/commandlineflags.h"
+#include "ortools/base/logging.h"
+#include "ortools/graph/ebert_graph.h"
+#include "ortools/graph/max_flow.h"
+#include "ortools/graph/min_cost_flow.h"
+
+namespace operations_research {
+
+// ----- Min Cost Flow -----
+
+// Test on a 4x4 matrix. Example taken from
+// http://www.ee.oulu.fi/~mpa/matreng/eem1_2-1.htm
+void MinCostFlowOn4x4Matrix() {
+  LOG(INFO) << "Min Cost Flow on 4x4 Matrix";
+  const int kNumSources = 4;
+  const int kNumTargets = 4;
+  const CostValue kCost[kNumSources][kNumTargets] = {{90, 75, 75, 80},
+                                                     {35, 85, 55, 65},
+                                                     {125, 95, 90, 105},
+                                                     {45, 110, 95, 115}};
+  const CostValue kExpectedCost = 275;
+  StarGraph graph(kNumSources + kNumTargets, kNumSources * kNumTargets);
+  MinCostFlow min_cost_flow(&graph);
+  for (NodeIndex source = 0; source < kNumSources; ++source) {
+    for (NodeIndex target = 0; target < kNumTargets; ++target) {
+      ArcIndex arc = graph.AddArc(source, kNumSources + target);
+      min_cost_flow.SetArcUnitCost(arc, kCost[source][target]);
+      min_cost_flow.SetArcCapacity(arc, 1);
+    }
+  }
+  for (NodeIndex source = 0; source < kNumSources; ++source) {
+    min_cost_flow.SetNodeSupply(source, 1);
+  }
+  for (NodeIndex target = 0; target < kNumTargets; ++target) {
+    min_cost_flow.SetNodeSupply(kNumSources + target, -1);
+  }
+  CHECK(min_cost_flow.Solve());
+  CHECK_EQ(MinCostFlow::OPTIMAL, min_cost_flow.status());
+  CostValue total_flow_cost = min_cost_flow.GetOptimalCost();
+  CHECK_EQ(kExpectedCost, total_flow_cost);
+}
+
+// ----- Max Flow -----
+
+void MaxFeasibleFlow() {
+  LOG(INFO) << "Max Feasible Flow";
+  const int kNumNodes = 6;
+  const int kNumArcs = 9;
+  const NodeIndex kTail[kNumArcs] = {0, 0, 0, 0, 1, 2, 3, 3, 4};
+  const NodeIndex kHead[kNumArcs] = {1, 2, 3, 4, 3, 4, 4, 5, 5};
+  const FlowQuantity kCapacity[kNumArcs] = {5, 8, 5, 3, 4, 5, 6, 6, 4};
+  const FlowQuantity kExpectedFlow[kNumArcs] = {1, 1, 5, 3, 1, 1, 0, 6, 4};
+  const FlowQuantity kExpectedTotalFlow = 10;
+  StarGraph graph(kNumNodes, kNumArcs);
+  MaxFlow max_flow(&graph, 0, kNumNodes - 1);
+  for (int i = 0; i < kNumArcs; ++i) {
+    ArcIndex arc = graph.AddArc(kTail[i], kHead[i]);
+    max_flow.SetArcCapacity(arc, kCapacity[i]);
+  }
+  CHECK(max_flow.Solve());
+  CHECK_EQ(MaxFlow::OPTIMAL, max_flow.status());
+  FlowQuantity total_flow = max_flow.GetOptimalFlow();
+  CHECK_EQ(total_flow, kExpectedTotalFlow);
+  for (int i = 0; i < kNumArcs; ++i) {
+    CHECK_EQ(kExpectedFlow[i], max_flow.Flow(i)) << " i = " << i;
+  }
+}
+}  // namespace operations_research
+
+int main(int argc, char** argv) {
+  gflags::ParseCommandLineFlags(&argc, &argv, true);
+  operations_research::MinCostFlowOn4x4Matrix();
+  operations_research::MaxFeasibleFlow();
+  return EXIT_SUCCESS;
+}

libs/or-tools-src-ubuntu/examples/cpp/interval_sample_sat.cc

+// Copyright 2010-2018 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ortools/sat/cp_model.h"
+
+namespace operations_research {
+namespace sat {
+
+void IntervalSampleSat() {
+  CpModelBuilder cp_model;
+  const int kHorizon = 100;
+
+  const Domain horizon(0, kHorizon);
+  const IntVar start_var = cp_model.NewIntVar(horizon).WithName("start");
+  const IntVar duration_var = cp_model.NewConstant(10);
+  const IntVar end_var = cp_model.NewIntVar(horizon).WithName("end");
+
+  const IntervalVar interval_var =
+      cp_model.NewIntervalVar(start_var, duration_var, end_var)
+          .WithName("interval");
+  LOG(INFO) << "start_var = " << start_var
+            << ", duration_var = " << duration_var << ", end_var = " << end_var
+            << ", interval_var = " << interval_var;
+}
+
+}  // namespace sat
+}  // namespace operations_research
+
+int main() {
+  operations_research::sat::IntervalSampleSat();
+
+  return EXIT_SUCCESS;
+}