diff --git a/examples/cpp/constraint_programming_cp.cc b/examples/cpp/constraint_programming_cp.cc index 160555f65c..ad7aafd59d 100644 --- a/examples/cpp/constraint_programming_cp.cc +++ b/examples/cpp/constraint_programming_cp.cc @@ -20,7 +20,7 @@ namespace operations_research { void RunConstraintProgrammingExample() { // Instantiate the solver. Solver solver("ConstraintProgrammingExample"); - const int64 numVals = 3; + const int64_t numVals = 3; // Define decision variables. IntVar* const x = solver.MakeIntVar(0, numVals - 1, "x"); diff --git a/examples/cpp/costas_array_sat.cc b/examples/cpp/costas_array_sat.cc index 22bbc052d0..265716b574 100644 --- a/examples/cpp/costas_array_sat.cc +++ b/examples/cpp/costas_array_sat.cc @@ -22,6 +22,7 @@ // uses hard constraints, whereas CostasSoft() uses a minimizer to // minimize the number of duplicates. +#include #include #include #include @@ -47,7 +48,7 @@ namespace operations_research { namespace sat { // Checks that all pairwise distances are unique and returns all violators -void CheckConstraintViolators(const std::vector& vars, +void CheckConstraintViolators(const std::vector& vars, std::vector* const violators) { int dim = vars.size(); @@ -79,7 +80,7 @@ void CheckConstraintViolators(const std::vector& vars, } // Check that all pairwise differences are unique -bool CheckCostas(const std::vector& vars) { +bool CheckCostas(const std::vector& vars) { std::vector violators; CheckConstraintViolators(vars, &violators); @@ -123,11 +124,11 @@ void CostasHard(const int dim) { const CpSolverResponse response = SolveCpModel(cp_model.Build(), &model); if (response.status() == CpSolverStatus::OPTIMAL) { - std::vector costas_matrix; + std::vector costas_matrix; std::string output; for (int n = 0; n < dim; ++n) { - const int64 v = SolutionIntegerValue(response, vars[n]); + const int64_t v = SolutionIntegerValue(response, vars[n]); costas_matrix.push_back(v); absl::StrAppendFormat(&output, "%3lld", v); } @@ -190,7 +191,7 @@ void CostasBool(const int dim) { const CpSolverResponse response = SolveCpModel(cp_model.Build(), &model); if (response.status() == CpSolverStatus::OPTIMAL) { - std::vector costas_matrix; + std::vector costas_matrix; std::string output; for (int n = 0; n < dim; ++n) { @@ -272,7 +273,7 @@ void CostasBoolSoft(const int dim) { const CpSolverResponse response = SolveCpModel(cp_model.Build(), &model); if (response.status() == CpSolverStatus::OPTIMAL) { - std::vector costas_matrix; + std::vector costas_matrix; std::string output; for (int n = 0; n < dim; ++n) { diff --git a/examples/cpp/cvrp_disjoint_tw.cc b/examples/cpp/cvrp_disjoint_tw.cc index d83b15e2e4..9f33fd111a 100644 --- a/examples/cpp/cvrp_disjoint_tw.cc +++ b/examples/cpp/cvrp_disjoint_tw.cc @@ -64,8 +64,8 @@ ABSL_FLAG(std::string, routing_search_parameters, "", const char* kTime = "Time"; const char* kCapacity = "Capacity"; -const int64 kMaxNodesPerGroup = 10; -const int64 kSameVehicleCost = 1000; +const int64_t kMaxNodesPerGroup = 10; +const int64_t kSameVehicleCost = 1000; int main(int argc, char** argv) { google::InitGoogleLogging(argv[0]); @@ -83,9 +83,9 @@ int main(int argc, char** argv) { RoutingModel routing(manager); // Setting up locations. - const int64 kXMax = 100000; - const int64 kYMax = 100000; - const int64 kSpeed = 10; + const int64_t kXMax = 100000; + const int64_t kYMax = 100000; + const int64_t kSpeed = 10; LocationContainer locations( kSpeed, absl::GetFlag(FLAGS_vrp_use_deterministic_random_seed)); for (int location = 0; location <= absl::GetFlag(FLAGS_vrp_orders); @@ -95,28 +95,28 @@ int main(int argc, char** argv) { // Setting the cost function. const int vehicle_cost = - routing.RegisterTransitCallback([&locations, &manager](int64 i, int64 j) { + routing.RegisterTransitCallback([&locations, &manager](int64_t i, int64_t 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; + const int64_t kVehicleCapacity = 40; + const int64_t kNullCapacitySlack = 0; RandomDemand demand(manager.num_nodes(), kDepot, absl::GetFlag(FLAGS_vrp_use_deterministic_random_seed)); demand.Initialize(); routing.AddDimension( - routing.RegisterTransitCallback([&demand, &manager](int64 i, int64 j) { + routing.RegisterTransitCallback([&demand, &manager](int64_t i, int64_t 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; + const int64_t kTimePerDemandUnit = 300; + const int64_t kHorizon = 24 * 3600; ServiceTimePlusTransition time( kTimePerDemandUnit, [&demand](RoutingNodeIndex i, RoutingNodeIndex j) { @@ -126,7 +126,7 @@ int main(int argc, char** argv) { return locations.ManhattanTime(i, j); }); routing.AddDimension( - routing.RegisterTransitCallback([&time, &manager](int64 i, int64 j) { + routing.RegisterTransitCallback([&time, &manager](int64_t i, int64_t j) { return time.Compute(manager.IndexToNode(i), manager.IndexToNode(j)); }), kHorizon, kHorizon, /*fix_start_cumul_to_zero=*/false, kTime); @@ -137,13 +137,13 @@ int main(int argc, char** argv) { std::mt19937 randomizer( GetSeed(absl::GetFlag(FLAGS_vrp_use_deterministic_random_seed))); for (int order = 1; order < manager.num_nodes(); ++order) { - std::vector forbid_points(2 * absl::GetFlag(FLAGS_vrp_windows), 0); + std::vector forbid_points(2 * absl::GetFlag(FLAGS_vrp_windows), 0); for (int i = 0; i < forbid_points.size(); ++i) { forbid_points[i] = absl::Uniform(randomizer, 0, kHorizon); } std::sort(forbid_points.begin(), forbid_points.end()); - std::vector forbid_starts(1, 0); - std::vector forbid_ends; + std::vector forbid_starts(1, 0); + std::vector 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]); @@ -154,17 +154,17 @@ int main(int argc, char** argv) { } // Adding penalty costs to allow skipping orders. - const int64 kPenalty = 10000000; + const int64_t kPenalty = 10000000; const RoutingIndexManager::NodeIndex kFirstNodeAfterDepot(1); for (RoutingIndexManager::NodeIndex order = kFirstNodeAfterDepot; order < manager.num_nodes(); ++order) { - std::vector orders(1, manager.NodeToIndex(order)); + std::vector orders(1, manager.NodeToIndex(order)); routing.AddDisjunction(orders, kPenalty); } // Adding same vehicle constraint costs for consecutive nodes. if (absl::GetFlag(FLAGS_vrp_use_same_vehicle_costs)) { - std::vector group; + std::vector group; for (RoutingIndexManager::NodeIndex order = kFirstNodeAfterDepot; order < manager.num_nodes(); ++order) { group.push_back(manager.NodeToIndex(order)); diff --git a/examples/cpp/cvrptw.cc b/examples/cpp/cvrptw.cc index 686453bb78..7ceb34fc87 100644 --- a/examples/cpp/cvrptw.cc +++ b/examples/cpp/cvrptw.cc @@ -93,7 +93,7 @@ int main(int argc, char** argv) { // Setting the cost function. const int vehicle_cost = - routing.RegisterTransitCallback([&locations, &manager](int64 i, int64 j) { + routing.RegisterTransitCallback([&locations, &manager](int64_t i, int64_t j) { return locations.ManhattanDistance(manager.IndexToNode(i), manager.IndexToNode(j)); }); @@ -106,7 +106,7 @@ int main(int argc, char** argv) { absl::GetFlag(FLAGS_vrp_use_deterministic_random_seed)); demand.Initialize(); routing.AddDimension( - routing.RegisterTransitCallback([&demand, &manager](int64 i, int64 j) { + routing.RegisterTransitCallback([&demand, &manager](int64_t i, int64_t j) { return demand.Demand(manager.IndexToNode(i), manager.IndexToNode(j)); }), kNullCapacitySlack, kVehicleCapacity, @@ -124,7 +124,7 @@ int main(int argc, char** argv) { return locations.ManhattanTime(i, j); }); routing.AddDimension( - routing.RegisterTransitCallback([&time, &manager](int64 i, int64 j) { + routing.RegisterTransitCallback([&time, &manager](int64_t i, int64_t j) { return time.Compute(manager.IndexToNode(i), manager.IndexToNode(j)); }), kHorizon, kHorizon, /*fix_start_cumul_to_zero=*/true, kTime); diff --git a/examples/cpp/cvrptw_lib.h b/examples/cpp/cvrptw_lib.h index 885f04963c..c4490b2f2d 100644 --- a/examples/cpp/cvrptw_lib.h +++ b/examples/cpp/cvrptw_lib.h @@ -26,7 +26,7 @@ namespace operations_research { -typedef std::function +typedef std::function RoutingNodeEvaluator2; // Random seed generator. @@ -36,38 +36,38 @@ int32 GetSeed(bool deterministic); // Manhattan distances/times between locations. class LocationContainer { public: - LocationContainer(int64 speed, bool use_deterministic_seed); - void AddLocation(int64 x, int64 y) { locations_.push_back(Location(x, y)); } - void AddRandomLocation(int64 x_max, int64 y_max); - void AddRandomLocation(int64 x_max, int64 y_max, int duplicates); - int64 ManhattanDistance(RoutingIndexManager::NodeIndex from, + LocationContainer(int64_t speed, bool use_deterministic_seed); + void AddLocation(int64_t x, int64_t y) { locations_.push_back(Location(x, y)); } + void AddRandomLocation(int64_t x_max, int64_t y_max); + void AddRandomLocation(int64_t x_max, int64_t y_max, int duplicates); + int64_t ManhattanDistance(RoutingIndexManager::NodeIndex from, RoutingIndexManager::NodeIndex to) const; - int64 NegManhattanDistance(RoutingIndexManager::NodeIndex from, + int64_t NegManhattanDistance(RoutingIndexManager::NodeIndex from, RoutingIndexManager::NodeIndex to) const; - int64 ManhattanTime(RoutingIndexManager::NodeIndex from, + int64_t ManhattanTime(RoutingIndexManager::NodeIndex from, RoutingIndexManager::NodeIndex to) const; bool SameLocation(RoutingIndexManager::NodeIndex node1, RoutingIndexManager::NodeIndex node2) const; - int64 SameLocationFromIndex(int64 node1, int64 node2) const; + int64_t SameLocationFromIndex(int64_t node1, int64_t node2) const; private: class Location { public: Location(); - Location(int64 x, int64 y); - int64 DistanceTo(const Location& location) const; + Location(int64_t x, int64_t y); + int64_t DistanceTo(const Location& location) const; bool IsAtSameLocation(const Location& location) const; private: - static int64 Abs(int64 value); + static int64_t Abs(int64_t value); - int64 x_; - int64 y_; + int64_t x_; + int64_t y_; }; MTRandom randomizer_; - const int64 speed_; + const int64_t speed_; absl::StrongVector locations_; }; @@ -77,11 +77,11 @@ class RandomDemand { RandomDemand(int size, RoutingIndexManager::NodeIndex depot, bool use_deterministic_seed); void Initialize(); - int64 Demand(RoutingIndexManager::NodeIndex from, + int64_t Demand(RoutingIndexManager::NodeIndex from, RoutingIndexManager::NodeIndex to) const; private: - std::unique_ptr demand_; + std::unique_ptr demand_; const int size_; const RoutingIndexManager::NodeIndex depot_; const bool use_deterministic_seed_; @@ -90,14 +90,14 @@ class RandomDemand { // Service time (proportional to demand) + transition time callback. class ServiceTimePlusTransition { public: - ServiceTimePlusTransition(int64 time_per_demand_unit, + ServiceTimePlusTransition(int64_t time_per_demand_unit, RoutingNodeEvaluator2 demand, RoutingNodeEvaluator2 transition_time); - int64 Compute(RoutingIndexManager::NodeIndex from, + int64_t Compute(RoutingIndexManager::NodeIndex from, RoutingIndexManager::NodeIndex to) const; private: - const int64 time_per_demand_unit_; + const int64_t time_per_demand_unit_; RoutingNodeEvaluator2 demand_; RoutingNodeEvaluator2 transition_time_; }; @@ -105,14 +105,14 @@ class ServiceTimePlusTransition { // Stop service time + transition time callback. class StopServiceTimePlusTransition { public: - StopServiceTimePlusTransition(int64 stop_time, + StopServiceTimePlusTransition(int64_t stop_time, const LocationContainer& location_container, RoutingNodeEvaluator2 transition_time); - int64 Compute(RoutingIndexManager::NodeIndex from, + int64_t Compute(RoutingIndexManager::NodeIndex from, RoutingIndexManager::NodeIndex to) const; private: - const int64 stop_time_; + const int64_t stop_time_; const LocationContainer& location_container_; RoutingNodeEvaluator2 demand_; RoutingNodeEvaluator2 transition_time_; @@ -124,7 +124,7 @@ void DisplayPlan( const operations_research::RoutingIndexManager& manager, const operations_research::RoutingModel& routing, const operations_research::Assignment& plan, bool use_same_vehicle_costs, - int64 max_nodes_per_group, int64 same_vehicle_cost, + int64_t max_nodes_per_group, int64_t same_vehicle_cost, const operations_research::RoutingDimension& capacity_dimension, const operations_research::RoutingDimension& time_dimension); @@ -138,34 +138,34 @@ int32 GetSeed(bool deterministic) { } } -LocationContainer::LocationContainer(int64 speed, bool use_deterministic_seed) +LocationContainer::LocationContainer(int64_t speed, bool use_deterministic_seed) : randomizer_(GetSeed(use_deterministic_seed)), speed_(speed) { CHECK_LT(0, speed_); } -void LocationContainer::AddRandomLocation(int64 x_max, int64 y_max) { +void LocationContainer::AddRandomLocation(int64_t x_max, int64_t y_max) { AddRandomLocation(x_max, y_max, 1); } -void LocationContainer::AddRandomLocation(int64 x_max, int64 y_max, +void LocationContainer::AddRandomLocation(int64_t x_max, int64_t y_max, int duplicates) { - const int64 x = randomizer_.Uniform(x_max + 1); - const int64 y = randomizer_.Uniform(y_max + 1); + const int64_t x = randomizer_.Uniform(x_max + 1); + const int64_t y = randomizer_.Uniform(y_max + 1); for (int i = 0; i < duplicates; ++i) { AddLocation(x, y); } } -int64 LocationContainer::ManhattanDistance(NodeIndex from, NodeIndex to) const { +int64_t LocationContainer::ManhattanDistance(NodeIndex from, NodeIndex to) const { return locations_[from].DistanceTo(locations_[to]); } -int64 LocationContainer::NegManhattanDistance(NodeIndex from, +int64_t LocationContainer::NegManhattanDistance(NodeIndex from, NodeIndex to) const { return -ManhattanDistance(from, to); } -int64 LocationContainer::ManhattanTime(NodeIndex from, NodeIndex to) const { +int64_t LocationContainer::ManhattanTime(NodeIndex from, NodeIndex to) const { return ManhattanDistance(from, to) / speed_; } @@ -175,7 +175,7 @@ bool LocationContainer::SameLocation(NodeIndex node1, NodeIndex node2) const { } return false; } -int64 LocationContainer::SameLocationFromIndex(int64 node1, int64 node2) const { +int64_t LocationContainer::SameLocationFromIndex(int64_t node1, int64_t node2) const { // The direct conversion from constraint model indices to routing model // nodes is correct because the depot is node 0. // TODO(user): Fetch proper indices from routing model. @@ -184,9 +184,9 @@ int64 LocationContainer::SameLocationFromIndex(int64 node1, int64 node2) const { LocationContainer::Location::Location() : x_(0), y_(0) {} -LocationContainer::Location::Location(int64 x, int64 y) : x_(x), y_(y) {} +LocationContainer::Location::Location(int64_t x, int64_t y) : x_(x), y_(y) {} -int64 LocationContainer::Location::DistanceTo(const Location& location) const { +int64_t LocationContainer::Location::DistanceTo(const Location& location) const { return Abs(x_ - location.x_) + Abs(y_ - location.y_); } @@ -195,7 +195,7 @@ bool LocationContainer::Location::IsAtSameLocation( return x_ == location.x_ && y_ == location.y_; } -int64 LocationContainer::Location::Abs(int64 value) { +int64_t LocationContainer::Location::Abs(int64_t value) { return std::max(value, -value); } @@ -208,9 +208,9 @@ RandomDemand::RandomDemand(int size, NodeIndex depot, } void RandomDemand::Initialize() { - const int64 kDemandMax = 5; - const int64 kDemandMin = 1; - demand_ = absl::make_unique(size_); + const int64_t kDemandMax = 5; + const int64_t kDemandMin = 1; + demand_ = absl::make_unique(size_); MTRandom randomizer(GetSeed(use_deterministic_seed_)); for (int order = 0; order < size_; ++order) { if (order == depot_) { @@ -222,29 +222,29 @@ void RandomDemand::Initialize() { } } -int64 RandomDemand::Demand(NodeIndex from, NodeIndex /*to*/) const { +int64_t RandomDemand::Demand(NodeIndex from, NodeIndex /*to*/) const { return demand_[from.value()]; } ServiceTimePlusTransition::ServiceTimePlusTransition( - int64 time_per_demand_unit, RoutingNodeEvaluator2 demand, + int64_t time_per_demand_unit, RoutingNodeEvaluator2 demand, RoutingNodeEvaluator2 transition_time) : time_per_demand_unit_(time_per_demand_unit), demand_(std::move(demand)), transition_time_(std::move(transition_time)) {} -int64 ServiceTimePlusTransition::Compute(NodeIndex from, NodeIndex to) const { +int64_t ServiceTimePlusTransition::Compute(NodeIndex from, NodeIndex to) const { return time_per_demand_unit_ * demand_(from, to) + transition_time_(from, to); } StopServiceTimePlusTransition::StopServiceTimePlusTransition( - int64 stop_time, const LocationContainer& location_container, + int64_t stop_time, const LocationContainer& location_container, RoutingNodeEvaluator2 transition_time) : stop_time_(stop_time), location_container_(location_container), transition_time_(std::move(transition_time)) {} -int64 StopServiceTimePlusTransition::Compute(NodeIndex from, +int64_t StopServiceTimePlusTransition::Compute(NodeIndex from, NodeIndex to) const { return location_container_.SameLocation(from, to) ? 0 @@ -254,7 +254,7 @@ int64 StopServiceTimePlusTransition::Compute(NodeIndex from, void DisplayPlan( const RoutingIndexManager& manager, const RoutingModel& routing, const operations_research::Assignment& plan, bool use_same_vehicle_costs, - int64 max_nodes_per_group, int64 same_vehicle_cost, + int64_t max_nodes_per_group, int64_t same_vehicle_cost, const operations_research::RoutingDimension& capacity_dimension, const operations_research::RoutingDimension& time_dimension) { // Display plan cost. @@ -262,7 +262,7 @@ void DisplayPlan( // Display dropped orders. std::string dropped; - for (int64 order = 0; order < routing.Size(); ++order) { + for (int64_t order = 0; order < routing.Size(); ++order) { if (routing.IsStart(order) || routing.IsEnd(order)) continue; if (plan.Value(routing.NextVar(order)) == order) { if (dropped.empty()) { @@ -280,9 +280,9 @@ void DisplayPlan( if (use_same_vehicle_costs) { int group_size = 0; - int64 group_same_vehicle_cost = 0; + int64_t group_same_vehicle_cost = 0; std::set visited; - for (int64 order = 0; order < routing.Size(); ++order) { + for (int64_t order = 0; order < routing.Size(); ++order) { if (routing.IsStart(order) || routing.IsEnd(order)) continue; ++group_size; visited.insert(plan.Value(routing.VehicleVar(order))); @@ -303,7 +303,7 @@ void DisplayPlan( // Display actual output for each vehicle. for (int route_number = 0; route_number < routing.vehicles(); ++route_number) { - int64 order = routing.Start(route_number); + int64_t order = routing.Start(route_number); absl::StrAppendFormat(&plan_output, "Route %d: ", route_number); if (routing.IsEnd(plan.Value(routing.NextVar(order)))) { plan_output += "Empty\n"; diff --git a/examples/cpp/cvrptw_with_breaks.cc b/examples/cpp/cvrptw_with_breaks.cc index a2dcad2030..43413f891d 100644 --- a/examples/cpp/cvrptw_with_breaks.cc +++ b/examples/cpp/cvrptw_with_breaks.cc @@ -90,9 +90,9 @@ int main(int argc, char** argv) { FirstSolutionStrategy::PARALLEL_CHEAPEST_INSERTION); // Setting up locations. - const int64 kXMax = 100000; - const int64 kYMax = 100000; - const int64 kSpeed = 10; + const int64_t kXMax = 100000; + const int64_t kYMax = 100000; + const int64_t kSpeed = 10; LocationContainer locations( kSpeed, absl::GetFlag(FLAGS_vrp_use_deterministic_random_seed)); for (int location = 0; location <= absl::GetFlag(FLAGS_vrp_orders); @@ -102,28 +102,28 @@ int main(int argc, char** argv) { // Setting the cost function. const int vehicle_cost = - routing.RegisterTransitCallback([&locations, &manager](int64 i, int64 j) { + routing.RegisterTransitCallback([&locations, &manager](int64_t i, int64_t 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; + const int64_t kVehicleCapacity = 40; + const int64_t kNullCapacitySlack = 0; RandomDemand demand(manager.num_nodes(), kDepot, absl::GetFlag(FLAGS_vrp_use_deterministic_random_seed)); demand.Initialize(); routing.AddDimension( - routing.RegisterTransitCallback([&demand, &manager](int64 i, int64 j) { + routing.RegisterTransitCallback([&demand, &manager](int64_t i, int64_t 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; + const int64_t kTimePerDemandUnit = 300; + const int64_t kHorizon = 24 * 3600; ServiceTimePlusTransition time( kTimePerDemandUnit, [&demand](RoutingNodeIndex i, RoutingNodeIndex j) { @@ -133,7 +133,7 @@ int main(int argc, char** argv) { return locations.ManhattanTime(i, j); }); routing.AddDimension( - routing.RegisterTransitCallback([&time, &manager](int64 i, int64 j) { + routing.RegisterTransitCallback([&time, &manager](int64_t i, int64_t j) { return time.Compute(manager.IndexToNode(i), manager.IndexToNode(j)); }), kHorizon, kHorizon, /*fix_start_cumul_to_zero=*/false, kTime); @@ -142,9 +142,9 @@ int main(int argc, char** argv) { // Adding time windows. std::mt19937 randomizer( GetSeed(absl::GetFlag(FLAGS_vrp_use_deterministic_random_seed))); - const int64 kTWDuration = 5 * 3600; + const int64_t kTWDuration = 5 * 3600; for (int order = 1; order < manager.num_nodes(); ++order) { - const int64 start = + const int64_t start = absl::Uniform(randomizer, 0, kHorizon - kTWDuration); time_dimension->CumulVar(order)->SetRange(start, start + kTWDuration); routing.AddToAssignment(time_dimension->SlackVar(order)); @@ -166,7 +166,7 @@ int main(int argc, char** argv) { // or // - 2 x 30min breaks between 10:00am and 3:00pm, at least 1h apart // First, fill service time vector. - std::vector service_times(routing.Size()); + std::vector service_times(routing.Size()); for (int node = 0; node < routing.Size(); node++) { if (node >= routing.nodes()) { service_times[node] = 0; @@ -204,11 +204,11 @@ int main(int argc, char** argv) { } // Adding penalty costs to allow skipping orders. - const int64 kPenalty = 10000000; + const int64_t kPenalty = 10000000; const RoutingIndexManager::NodeIndex kFirstNodeAfterDepot(1); for (RoutingIndexManager::NodeIndex order = kFirstNodeAfterDepot; order < routing.nodes(); ++order) { - std::vector orders(1, manager.NodeToIndex(order)); + std::vector orders(1, manager.NodeToIndex(order)); routing.AddDisjunction(orders, kPenalty); } diff --git a/examples/cpp/cvrptw_with_refueling.cc b/examples/cpp/cvrptw_with_refueling.cc index 7a590a8812..684b507555 100644 --- a/examples/cpp/cvrptw_with_refueling.cc +++ b/examples/cpp/cvrptw_with_refueling.cc @@ -60,8 +60,8 @@ 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; +bool IsRefuelNode(int64_t node) { + const int64_t kRefuelNodeRatio = 10; return (node % kRefuelNodeRatio == 0); } @@ -81,9 +81,9 @@ int main(int argc, char** argv) { RoutingModel routing(manager); // Setting up locations. - const int64 kXMax = 100000; - const int64 kYMax = 100000; - const int64 kSpeed = 10; + const int64_t kXMax = 100000; + const int64_t kYMax = 100000; + const int64_t kSpeed = 10; LocationContainer locations( kSpeed, absl::GetFlag(FLAGS_vrp_use_deterministic_random_seed)); for (int location = 0; location <= absl::GetFlag(FLAGS_vrp_orders); @@ -93,28 +93,28 @@ int main(int argc, char** argv) { // Setting the cost function. const int vehicle_cost = - routing.RegisterTransitCallback([&locations, &manager](int64 i, int64 j) { + routing.RegisterTransitCallback([&locations, &manager](int64_t i, int64_t 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; + const int64_t kVehicleCapacity = 40; + const int64_t kNullCapacitySlack = 0; RandomDemand demand(manager.num_nodes(), kDepot, absl::GetFlag(FLAGS_vrp_use_deterministic_random_seed)); demand.Initialize(); routing.AddDimension( - routing.RegisterTransitCallback([&demand, &manager](int64 i, int64 j) { + routing.RegisterTransitCallback([&demand, &manager](int64_t i, int64_t 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; + const int64_t kTimePerDemandUnit = 300; + const int64_t kHorizon = 24 * 3600; ServiceTimePlusTransition time( kTimePerDemandUnit, [&demand](RoutingNodeIndex i, RoutingNodeIndex j) { @@ -124,7 +124,7 @@ int main(int argc, char** argv) { return locations.ManhattanTime(i, j); }); routing.AddDimension( - routing.RegisterTransitCallback([&time, &manager](int64 i, int64 j) { + routing.RegisterTransitCallback([&time, &manager](int64_t i, int64_t j) { return time.Compute(manager.IndexToNode(i), manager.IndexToNode(j)); }), kHorizon, kHorizon, /*fix_start_cumul_to_zero=*/true, kTime); @@ -136,10 +136,10 @@ int main(int argc, char** argv) { // performance: I got good performance for about 10% of the seeds. std::mt19937 randomizer( 144 + GetSeed(absl::GetFlag(FLAGS_vrp_use_deterministic_random_seed))); - const int64 kTWDuration = 5 * 3600; + const int64_t kTWDuration = 5 * 3600; for (int order = 1; order < manager.num_nodes(); ++order) { if (!IsRefuelNode(order)) { - const int64 start = + const int64_t start = absl::Uniform(randomizer, 0, kHorizon - kTWDuration); time_dimension.CumulVar(order)->SetRange(start, start + kTWDuration); } @@ -148,9 +148,9 @@ int main(int argc, char** argv) { // 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; + const int64_t kFuelCapacity = kXMax + kYMax; routing.AddDimension( - routing.RegisterTransitCallback([&locations, &manager](int64 i, int64 j) { + routing.RegisterTransitCallback([&locations, &manager](int64_t i, int64_t j) { return locations.NegManhattanDistance(manager.IndexToNode(i), manager.IndexToNode(j)); }), @@ -166,11 +166,11 @@ int main(int argc, char** argv) { } // Adding penalty costs to allow skipping orders. - const int64 kPenalty = 100000; + const int64_t kPenalty = 100000; const RoutingIndexManager::NodeIndex kFirstNodeAfterDepot(1); for (RoutingIndexManager::NodeIndex order = kFirstNodeAfterDepot; order < routing.nodes(); ++order) { - std::vector orders(1, manager.NodeToIndex(order)); + std::vector orders(1, manager.NodeToIndex(order)); routing.AddDisjunction(orders, kPenalty); } diff --git a/examples/cpp/cvrptw_with_resources.cc b/examples/cpp/cvrptw_with_resources.cc index 9ef33a0f99..f4539fbb2b 100644 --- a/examples/cpp/cvrptw_with_resources.cc +++ b/examples/cpp/cvrptw_with_resources.cc @@ -79,9 +79,9 @@ int main(int argc, char** argv) { RoutingModel routing(manager); // Setting up locations. - const int64 kXMax = 100000; - const int64 kYMax = 100000; - const int64 kSpeed = 10; + const int64_t kXMax = 100000; + const int64_t kYMax = 100000; + const int64_t kSpeed = 10; LocationContainer locations( kSpeed, absl::GetFlag(FLAGS_vrp_use_deterministic_random_seed)); for (int location = 0; location <= absl::GetFlag(FLAGS_vrp_orders); @@ -91,28 +91,28 @@ int main(int argc, char** argv) { // Setting the cost function. const int vehicle_cost = - routing.RegisterTransitCallback([&locations, &manager](int64 i, int64 j) { + routing.RegisterTransitCallback([&locations, &manager](int64_t i, int64_t 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; + const int64_t kVehicleCapacity = 40; + const int64_t kNullCapacitySlack = 0; RandomDemand demand(manager.num_nodes(), kDepot, absl::GetFlag(FLAGS_vrp_use_deterministic_random_seed)); demand.Initialize(); routing.AddDimension( - routing.RegisterTransitCallback([&demand, &manager](int64 i, int64 j) { + routing.RegisterTransitCallback([&demand, &manager](int64_t i, int64_t 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; + const int64_t kTimePerDemandUnit = 300; + const int64_t kHorizon = 24 * 3600; ServiceTimePlusTransition time( kTimePerDemandUnit, [&demand](RoutingNodeIndex i, RoutingNodeIndex j) { @@ -122,7 +122,7 @@ int main(int argc, char** argv) { return locations.ManhattanTime(i, j); }); routing.AddDimension( - routing.RegisterTransitCallback([&time, &manager](int64 i, int64 j) { + routing.RegisterTransitCallback([&time, &manager](int64_t i, int64_t j) { return time.Compute(manager.IndexToNode(i), manager.IndexToNode(j)); }), kHorizon, kHorizon, /*fix_start_cumul_to_zero=*/false, kTime); @@ -131,9 +131,9 @@ int main(int argc, char** argv) { // Adding time windows. std::mt19937 randomizer( GetSeed(absl::GetFlag(FLAGS_vrp_use_deterministic_random_seed))); - const int64 kTWDuration = 5 * 3600; + const int64_t kTWDuration = 5 * 3600; for (int order = 1; order < manager.num_nodes(); ++order) { - const int64 start = + const int64_t start = absl::Uniform(randomizer, 0, kHorizon - kTWDuration); time_dimension.CumulVar(order)->SetRange(start, start + kTWDuration); } @@ -146,14 +146,14 @@ int main(int argc, char** argv) { start_end_times.push_back(time_dimension.CumulVar(routing.Start(i))); } // Build corresponding time intervals. - const int64 kVehicleSetup = 180; + const int64_t kVehicleSetup = 180; Solver* const solver = routing.solver(); std::vector 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 depot_usage(start_end_times.size(), 1); + const int64_t kDepotCapacity = 5; + std::vector 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. @@ -162,11 +162,11 @@ int main(int argc, char** argv) { } // Adding penalty costs to allow skipping orders. - const int64 kPenalty = 100000; + const int64_t kPenalty = 100000; const RoutingIndexManager::NodeIndex kFirstNodeAfterDepot(1); for (RoutingIndexManager::NodeIndex order = kFirstNodeAfterDepot; order < manager.num_nodes(); ++order) { - std::vector orders(1, manager.NodeToIndex(order)); + std::vector orders(1, manager.NodeToIndex(order)); routing.AddDisjunction(orders, kPenalty); } diff --git a/examples/cpp/cvrptw_with_stop_times_and_resources.cc b/examples/cpp/cvrptw_with_stop_times_and_resources.cc index 1a9436f05f..e6dda0d84a 100644 --- a/examples/cpp/cvrptw_with_stop_times_and_resources.cc +++ b/examples/cpp/cvrptw_with_stop_times_and_resources.cc @@ -82,9 +82,9 @@ int main(int argc, char** argv) { RoutingModel routing(manager); // Setting up locations. - const int64 kXMax = 100000; - const int64 kYMax = 100000; - const int64 kSpeed = 10; + const int64_t kXMax = 100000; + const int64_t kYMax = 100000; + const int64_t kSpeed = 10; LocationContainer locations( kSpeed, absl::GetFlag(FLAGS_vrp_use_deterministic_random_seed)); for (int stop = 0; stop <= absl::GetFlag(FLAGS_vrp_stops); ++stop) { @@ -95,35 +95,35 @@ int main(int argc, char** argv) { // Setting the cost function. const int vehicle_cost = - routing.RegisterTransitCallback([&locations, &manager](int64 i, int64 j) { + routing.RegisterTransitCallback([&locations, &manager](int64_t i, int64_t 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; + const int64_t kVehicleCapacity = 40; + const int64_t kNullCapacitySlack = 0; RandomDemand demand(manager.num_nodes(), kDepot, absl::GetFlag(FLAGS_vrp_use_deterministic_random_seed)); demand.Initialize(); routing.AddDimension( - routing.RegisterTransitCallback([&demand, &manager](int64 i, int64 j) { + routing.RegisterTransitCallback([&demand, &manager](int64_t i, int64_t 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; + const int64_t kStopTime = 300; + const int64_t 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) { + routing.RegisterTransitCallback([&time, &manager](int64_t i, int64_t j) { return time.Compute(manager.IndexToNode(i), manager.IndexToNode(j)); }), kHorizon, kHorizon, /*fix_start_cumul_to_zero=*/false, kTime); @@ -132,9 +132,9 @@ int main(int argc, char** argv) { // Adding time windows, for the sake of simplicty same for each stop. std::mt19937 randomizer( GetSeed(absl::GetFlag(FLAGS_vrp_use_deterministic_random_seed))); - const int64 kTWDuration = 5 * 3600; + const int64_t kTWDuration = 5 * 3600; for (int stop = 0; stop < absl::GetFlag(FLAGS_vrp_stops); ++stop) { - const int64 start = + const int64_t start = absl::Uniform(randomizer, 0, kHorizon - kTWDuration); for (int stop_order = 0; stop_order < absl::GetFlag(FLAGS_vrp_orders_per_stop); ++stop_order) { @@ -168,7 +168,7 @@ int main(int argc, char** argv) { IntVar* const is_null_duration = solver ->MakeElement( - [&locations, order](int64 index) { + [&locations, order](int64_t index) { return locations.SameLocationFromIndex(order, index); }, routing.NextVar(order)) @@ -181,7 +181,7 @@ int main(int argc, char** argv) { routing.AddVariableMaximizedByFinalizer(order_start); } // Only one order can happen at the same time at a given location. - std::vector location_usage(stop_intervals.size(), 1); + std::vector location_usage(stop_intervals.size(), 1); solver->AddConstraint(solver->MakeCumulative( stop_intervals, location_usage, 1, absl::StrCat("Client", stop))); } @@ -192,11 +192,11 @@ int main(int argc, char** argv) { } // Adding penalty costs to allow skipping orders. - const int64 kPenalty = 100000; + const int64_t kPenalty = 100000; const RoutingIndexManager::NodeIndex kFirstNodeAfterDepot(1); for (RoutingIndexManager::NodeIndex order = kFirstNodeAfterDepot; order < routing.nodes(); ++order) { - std::vector orders(1, manager.NodeToIndex(order)); + std::vector orders(1, manager.NodeToIndex(order)); routing.AddDisjunction(orders, kPenalty); } diff --git a/examples/cpp/dobble_ls.cc b/examples/cpp/dobble_ls.cc index 536960b6cd..ce5df3cd94 100644 --- a/examples/cpp/dobble_ls.cc +++ b/examples/cpp/dobble_ls.cc @@ -473,7 +473,7 @@ class DobbleFilter : public IntVarLocalSearchFilter { // which is the difference between the current delta and the last // delta that was given to Accept() -- but we don't use it here. bool Accept(const Assignment* delta, const Assignment* unused_deltadelta, - int64 objective_min, int64 objective_max) override { + int64_t objective_min, int64_t objective_max) override { const Assignment::IntContainer& solution_delta = delta->IntVarContainer(); const int solution_delta_size = solution_delta.Size(); @@ -573,7 +573,7 @@ class DobbleFilter : public IntVarLocalSearchFilter { const int solution_delta_size = solution_delta.Size(); const int kUnassigned = -1; for (int index = 0; index < solution_delta_size; ++index) { - int64 touched_var = kUnassigned; + int64_t touched_var = kUnassigned; FindIndex(solution_delta.Element(index).Var(), &touched_var); CHECK_NE(touched_var, kUnassigned); const int card = touched_var / num_symbols_; diff --git a/examples/cpp/fap_utilities.h b/examples/cpp/fap_utilities.h index 98344b95e4..a5f1981030 100644 --- a/examples/cpp/fap_utilities.h +++ b/examples/cpp/fap_utilities.h @@ -47,7 +47,7 @@ bool CheckVariablePosition(const std::map& data_variables, int NumberOfAssignedValues(const std::vector& variables); // Prints the duration of the solving process. -void PrintElapsedTime(const int64 time1, const int64 time2); +void PrintElapsedTime(const int64_t time1, const int64_t time2); // Prints the solution found by the Hard Solver for feasible instances. void PrintResultsHard(SolutionCollector* const collector, @@ -125,7 +125,7 @@ int NumberOfAssignedValues(const std::vector& variables) { return static_cast(assigned.size()); } -void PrintElapsedTime(const int64 time1, const int64 time2) { +void PrintElapsedTime(const int64_t time1, const int64_t time2) { LOG(INFO) << "End of solving process."; LOG(INFO) << "The Solve method took " << (time2 - time1) / 1000.0 << " seconds."; diff --git a/examples/cpp/frequency_assignment_problem.cc b/examples/cpp/frequency_assignment_problem.cc index de0d4ef266..cb4a4aea48 100644 --- a/examples/cpp/frequency_assignment_problem.cc +++ b/examples/cpp/frequency_assignment_problem.cc @@ -332,12 +332,12 @@ bool ConstraintImpactComparator(FapConstraint constraint1, return (constraint1.impact > constraint2.impact); } -int64 ValueEvaluator( - absl::flat_hash_map>* value_evaluator_map, - int64 variable_index, int64 value) { +int64_t ValueEvaluator( + absl::flat_hash_map>* value_evaluator_map, + int64_t variable_index, int64_t value) { CHECK(value_evaluator_map != nullptr); // Evaluate the choice. Smaller ranking denotes a better choice. - int64 ranking = -1; + int64_t ranking = -1; for (const auto& it : *value_evaluator_map) { if ((it.first != variable_index) && (it.second.first == value)) { ranking = -2; @@ -346,12 +346,12 @@ int64 ValueEvaluator( } // Update the history of assigned values and their rankings of each variable. - absl::flat_hash_map>::iterator it; - int64 new_value = value; - int64 new_ranking = ranking; + absl::flat_hash_map>::iterator it; + int64_t new_value = value; + int64_t new_ranking = ranking; if ((it = value_evaluator_map->find(variable_index)) != value_evaluator_map->end()) { - std::pair existing_value_ranking = it->second; + std::pair existing_value_ranking = it->second; // Replace only if the current choice for this variable has smaller // ranking or same ranking but smaller value of the existing choice. if (!(existing_value_ranking.second > ranking || @@ -361,7 +361,7 @@ int64 ValueEvaluator( new_ranking = existing_value_ranking.second; } } - std::pair new_value_ranking = + std::pair new_value_ranking = std::make_pair(new_value, new_ranking); gtl::InsertOrUpdate(value_evaluator_map, variable_index, new_value_ranking); @@ -370,12 +370,12 @@ int64 ValueEvaluator( // The variables which participate in more constraints and have the // smaller domain should be in higher priority for assignment. -int64 VariableEvaluator(const std::vector& key_from_index, +int64_t VariableEvaluator(const std::vector& key_from_index, const std::map& data_variables, - int64 variable_index) { + int64_t variable_index) { FapVariable variable = gtl::FindOrDie(data_variables, key_from_index[variable_index]); - int64 result = -(variable.degree * 100 / variable.domain_size); + int64_t result = -(variable.degree * 100 / variable.domain_size); return result; } @@ -583,11 +583,11 @@ void HardFapSolver(const std::map& data_variables, ChooseVariableStrategy(&variable_strategy); // Choose the value selection strategy. DecisionBuilder* db; - absl::flat_hash_map> history; + absl::flat_hash_map> history; if (absl::GetFlag(FLAGS_value_evaluator) == "value_evaluator") { LOG(INFO) << "Using ValueEvaluator for value selection strategy."; - Solver::IndexEvaluator2 index_evaluator2 = [&history](int64 var, - int64 value) { + Solver::IndexEvaluator2 index_evaluator2 = [&history](int64_t var, + int64_t value) { return ValueEvaluator(&history, var, value); }; LOG(INFO) << "Using ValueEvaluator for value selection strategy."; @@ -611,9 +611,9 @@ void HardFapSolver(const std::map& data_variables, // Solve. LOG(INFO) << "Solving..."; - const int64 time1 = solver.wall_time(); + const int64_t time1 = solver.wall_time(); solver.Solve(final_db, monitors); - const int64 time2 = solver.wall_time(); + const int64_t time2 = solver.wall_time(); // Display Time. if (absl::GetFlag(FLAGS_display_time)) { @@ -785,7 +785,7 @@ int SoftFapSolver(const std::map& data_variables, LOG(INFO) << "Using VariableEvaluator for variable selection strategy and " "Solver::ASSIGN_MIN_VALUE for value selection strategy."; Solver::IndexEvaluator1 var_evaluator = [&key_from_index, - &data_variables](int64 index) { + &data_variables](int64_t index) { return VariableEvaluator(key_from_index, data_variables, index); }; db = solver.MakePhase(variables, var_evaluator, Solver::ASSIGN_MIN_VALUE); @@ -809,9 +809,9 @@ int SoftFapSolver(const std::map& data_variables, // Solve. LOG(INFO) << "Solving..."; - const int64 time1 = solver.wall_time(); + const int64_t time1 = solver.wall_time(); solver.Solve(final_db, monitors); - const int64 time2 = solver.wall_time(); + const int64_t time2 = solver.wall_time(); int violation_sum = collector->Value(collector->solution_count() - 1, objective_var); diff --git a/examples/cpp/golomb_sat.cc b/examples/cpp/golomb_sat.cc index 5ac64bbab6..7530cc4c5f 100644 --- a/examples/cpp/golomb_sat.cc +++ b/examples/cpp/golomb_sat.cc @@ -57,7 +57,7 @@ void GolombRuler(int size) { std::vector ticks(size); ticks[0] = cp_model.NewConstant(0); - const int64 max = size * size; + const int64_t max = size * size; Domain domain(1, max); for (int i = 1; i < size; ++i) { ticks[i] = cp_model.NewIntVar(domain); @@ -98,8 +98,8 @@ void GolombRuler(int size) { const CpSolverResponse response = SolveCpModel(cp_model.Build(), &model); if (response.status() == CpSolverStatus::OPTIMAL) { - const int64 result = SolutionIntegerValue(response, ticks.back()); - const int64 num_failures = response.num_conflicts(); + const int64_t result = SolutionIntegerValue(response, ticks.back()); + const int64_t num_failures = response.num_conflicts(); absl::PrintF("N = %d, optimal length = %d (conflicts:%d, time=%f s)\n", size, result, num_failures, response.wall_time()); if (size - 1 < kKnownSolutions) { @@ -107,7 +107,7 @@ void GolombRuler(int size) { } if (absl::GetFlag(FLAGS_print)) { for (int i = 0; i < size; ++i) { - const int64 tick = SolutionIntegerValue(response, ticks[i]); + const int64_t tick = SolutionIntegerValue(response, ticks[i]); printf("%d ", static_cast(tick)); } printf("\n"); diff --git a/examples/cpp/jobshop_sat.cc b/examples/cpp/jobshop_sat.cc index 70d34afb4f..d41599ad02 100644 --- a/examples/cpp/jobshop_sat.cc +++ b/examples/cpp/jobshop_sat.cc @@ -62,10 +62,10 @@ namespace operations_research { namespace sat { // Compute a valid horizon from a problem. -int64 ComputeHorizon(const JsspInputProblem& problem) { - int64 sum_of_durations = 0; - int64 max_latest_end = 0; - int64 max_earliest_start = 0; +int64_t ComputeHorizon(const JsspInputProblem& problem) { + int64_t sum_of_durations = 0; + int64_t max_latest_end = 0; + int64_t max_earliest_start = 0; for (const Job& job : problem.jobs()) { if (job.has_latest_end()) { max_latest_end = std::max(max_latest_end, job.latest_end().value()); @@ -77,8 +77,8 @@ int64 ComputeHorizon(const JsspInputProblem& problem) { std::max(max_earliest_start, job.earliest_start().value()); } for (const Task& task : job.tasks()) { - int64 max_duration = 0; - for (int64 d : task.duration()) { + int64_t max_duration = 0; + for (int64_t d : task.duration()) { max_duration = std::max(max_duration, d); } sum_of_durations += max_duration; @@ -86,12 +86,12 @@ int64 ComputeHorizon(const JsspInputProblem& problem) { } const int num_jobs = problem.jobs_size(); - int64 sum_of_transitions = 0; + int64_t sum_of_transitions = 0; for (const Machine& machine : problem.machines()) { if (!machine.has_transition_time_matrix()) continue; const TransitionTimeMatrix& matrix = machine.transition_time_matrix(); for (int i = 0; i < num_jobs; ++i) { - int64 max_transition = 0; + int64_t max_transition = 0; for (int j = 0; j < num_jobs; ++j) { max_transition = std::max(max_transition, matrix.transition_time(i * num_jobs + j)); @@ -125,7 +125,7 @@ struct AlternativeTaskData { // Create the job structure as a chain of tasks. Fills in the job_to_tasks // vector. -void CreateJobs(const JsspInputProblem& problem, int64 horizon, +void CreateJobs(const JsspInputProblem& problem, int64_t horizon, std::vector>& job_to_tasks, bool& has_variable_duration_tasks, CpModelBuilder& cp_model) { const int num_jobs = problem.jobs_size(); @@ -135,9 +135,9 @@ void CreateJobs(const JsspInputProblem& problem, int64 horizon, const int num_tasks_in_job = job.tasks_size(); std::vector& task_data = job_to_tasks[j]; - const int64 hard_start = + const int64_t hard_start = job.has_earliest_start() ? job.earliest_start().value() : 0L; - const int64 hard_end = + const int64_t hard_end = job.has_latest_end() ? job.latest_end().value() : horizon; for (int t = 0; t < num_tasks_in_job; ++t) { @@ -146,9 +146,9 @@ void CreateJobs(const JsspInputProblem& problem, int64 horizon, CHECK_EQ(num_alternatives, task.duration_size()); // Add the "main" task interval. - std::vector durations; - int64 min_duration = task.duration(0); - int64 max_duration = task.duration(0); + std::vector durations; + int64_t min_duration = task.duration(0); + int64_t max_duration = task.duration(0); durations.push_back(task.duration(0)); for (int a = 1; a < num_alternatives; ++a) { min_duration = std::min(min_duration, task.duration(a)); @@ -179,7 +179,7 @@ void CreateJobs(const JsspInputProblem& problem, int64 horizon, // main task of the job. void CreateAlternativeTasks( const JsspInputProblem& problem, - const std::vector>& job_to_tasks, int64 horizon, + const std::vector>& job_to_tasks, int64_t horizon, std::vector>>& job_task_to_alternatives, CpModelBuilder& cp_model) { @@ -192,9 +192,9 @@ void CreateAlternativeTasks( job_task_to_alternatives[j].resize(num_tasks_in_job); const std::vector& tasks = job_to_tasks[j]; - const int64 hard_start = + const int64_t hard_start = job.has_earliest_start() ? job.earliest_start().value() : 0L; - const int64 hard_end = + const int64_t hard_end = job.has_latest_end() ? job.latest_end().value() : horizon; for (int t = 0; t < num_tasks_in_job; ++t) { @@ -204,7 +204,7 @@ void CreateAlternativeTasks( std::vector& alt_data = job_task_to_alternatives[j][t]; - absl::flat_hash_map> duration_supports; + absl::flat_hash_map> duration_supports; duration_supports[task.duration(0)].push_back(0); for (int a = 1; a < num_alternatives; ++a) { duration_supports[task.duration(a)].push_back(a); @@ -253,7 +253,7 @@ void CreateAlternativeTasks( // Implement supporting literals for the duration of the main interval. if (duration_supports.size() > 1) { // duration is not fixed. for (const auto& duration_alternative_indices : duration_supports) { - const int64 value = duration_alternative_indices.first; + const int64_t value = duration_alternative_indices.first; const BoolVar duration_eq_value = cp_model.NewBoolVar(); // duration_eq_value <=> duration == value. @@ -301,7 +301,7 @@ struct MachineTaskData { IntervalVar interval; int job; IntVar start; - int64 duration; + int64_t duration; IntVar end; BoolVar presence; }; @@ -370,7 +370,7 @@ void CreateMachines( circuit.AddArc(i + 1, i + 1, Not(machine_to_tasks[m][i].presence)); } else { const int job_j = machine_to_tasks[m][i].job; - const int64 transition = + const int64_t transition = transitions.transition_time(job_i * num_jobs + job_j); const BoolVar lit = cp_model.NewBoolVar(); const IntVar start = machine_to_tasks[m][j].start; @@ -393,10 +393,10 @@ void CreateObjective( const std::vector>& job_to_tasks, const std::vector>>& job_task_to_alternatives, - int64 horizon, IntVar makespan, CpModelBuilder& cp_model) { - int64 objective_offset = 0; + int64_t horizon, IntVar makespan, CpModelBuilder& cp_model) { + int64_t objective_offset = 0; std::vector objective_vars; - std::vector objective_coeffs; + std::vector objective_coeffs; const int num_jobs = problem.jobs_size(); for (int j = 0; j < num_jobs; ++j) { @@ -418,9 +418,9 @@ void CreateObjective( } // Job lateness cost. - const int64 lateness_penalty = job.lateness_cost_per_time_unit(); + const int64_t lateness_penalty = job.lateness_cost_per_time_unit(); if (lateness_penalty != 0L) { - const int64 due_date = job.late_due_date(); + const int64_t due_date = job.late_due_date(); const IntVar job_end = job_to_tasks[j].back().end; if (due_date == 0) { objective_vars.push_back(job_end); @@ -436,9 +436,9 @@ void CreateObjective( } // Job earliness cost. - const int64 earliness_penalty = job.earliness_cost_per_time_unit(); + const int64_t earliness_penalty = job.earliness_cost_per_time_unit(); if (earliness_penalty != 0L) { - const int64 due_date = job.early_due_date(); + const int64_t due_date = job.early_due_date(); const IntVar job_end = job_to_tasks[j].back().end; if (due_date > 0) { @@ -582,7 +582,7 @@ void Solve(const JsspInputProblem& problem) { CpModelBuilder cp_model; // Compute an over estimate of the horizon. - const int64 horizon = absl::GetFlag(FLAGS_horizon) != -1 + const int64_t horizon = absl::GetFlag(FLAGS_horizon) != -1 ? absl::GetFlag(FLAGS_horizon) : ComputeHorizon(problem); @@ -712,9 +712,9 @@ void Solve(const JsspInputProblem& problem) { return; // Check cost, recompute it from scratch. - int64 final_cost = 0; + int64_t final_cost = 0; if (problem.makespan_cost_per_time_unit() != 0) { - int64 makespan = 0; + int64_t makespan = 0; for (const std::vector& tasks : job_to_tasks) { const IntVar job_end = tasks.back().end; makespan = std::max(makespan, SolutionIntegerValue(response, job_end)); @@ -723,11 +723,11 @@ void Solve(const JsspInputProblem& problem) { } for (int j = 0; j < num_jobs; ++j) { - const int64 early_due_date = problem.jobs(j).early_due_date(); - const int64 late_due_date = problem.jobs(j).late_due_date(); - const int64 early_penalty = problem.jobs(j).earliness_cost_per_time_unit(); - const int64 late_penalty = problem.jobs(j).lateness_cost_per_time_unit(); - const int64 end = + const int64_t early_due_date = problem.jobs(j).early_due_date(); + const int64_t late_due_date = problem.jobs(j).late_due_date(); + const int64_t early_penalty = problem.jobs(j).earliness_cost_per_time_unit(); + const int64_t late_penalty = problem.jobs(j).lateness_cost_per_time_unit(); + const int64_t end = SolutionIntegerValue(response, job_to_tasks[j].back().end); if (end < early_due_date && early_penalty != 0) { final_cost += (early_due_date - end) * early_penalty; diff --git a/examples/cpp/magic_sequence_sat.cc b/examples/cpp/magic_sequence_sat.cc index 29d5791a03..31781419a5 100644 --- a/examples/cpp/magic_sequence_sat.cc +++ b/examples/cpp/magic_sequence_sat.cc @@ -50,7 +50,7 @@ void MagicSequence(int size) { } // The number of variables equal to j shall be the value of vars[j]. - std::vector values(size); + std::vector values(size); std::iota(values.begin(), values.end(), 0); // [0, 1, 2, .., size - 1] std::vector vars_equal_to_j; diff --git a/examples/cpp/multi_knapsack_sat.cc b/examples/cpp/multi_knapsack_sat.cc index 353dda4c3a..6f3a15ca4c 100644 --- a/examples/cpp/multi_knapsack_sat.cc +++ b/examples/cpp/multi_knapsack_sat.cc @@ -65,9 +65,9 @@ void MultiKnapsackSat(int scaling, const std::string& params) { } // Fill up scaled values, weights, volumes; - std::vector values(num_items); - std::vector weights(num_items); - std::vector volumes(num_items); + std::vector values(num_items); + std::vector weights(num_items); + std::vector volumes(num_items); for (int i = 0; i < num_items; ++i) { const int index = i % kNumItems; weights[i] = kItemsWeights[index]; diff --git a/examples/cpp/network_routing_sat.cc b/examples/cpp/network_routing_sat.cc index 6f79fbb6cf..fa7d974294 100644 --- a/examples/cpp/network_routing_sat.cc +++ b/examples/cpp/network_routing_sat.cc @@ -86,7 +86,7 @@ ABSL_FLAG(std::string, params, "", "Sat parameters."); namespace operations_research { namespace sat { // ---------- Data and Data Generation ---------- -static const int64 kDisconnectedDistance = -1LL; +static const int64_t kDisconnectedDistance = -1LL; // ----- Data ----- // Contains problem data. It assumes capacities are symmetrical: @@ -440,7 +440,7 @@ class NetworkRoutingSolver { return num_paths; } - void AddArcData(int64 source, int64 destination, int arc_id) { + void AddArcData(int64_t source, int64_t destination, int arc_id) { arcs_data_.push_back({source, destination, arc_id}); } @@ -488,9 +488,9 @@ class NetworkRoutingSolver { return total_demand; } - int64 InitShortestPaths(const NetworkRoutingData& data) { + int64_t InitShortestPaths(const NetworkRoutingData& data) { const int num_demands = data.num_demands(); - int64 total_cumulated_traffic = 0; + int64_t total_cumulated_traffic = 0; all_min_path_lengths_.clear(); std::vector paths; for (int demand_index = 0; demand_index < num_demands; ++demand_index) { @@ -537,7 +537,7 @@ class NetworkRoutingSolver { InitArcInfo(data); const int total_demand = InitDemandInfo(data); - const int64 total_cumulated_traffic = InitShortestPaths(data); + const int64_t total_cumulated_traffic = InitShortestPaths(data); const int num_paths = InitPaths(data, extra_hops, max_paths); // ----- Report Problem Sizes ----- @@ -554,7 +554,7 @@ class NetworkRoutingSolver { // ----- Callback for Dijkstra Shortest Path ----- - int64 HasArc(int i, int j) { + int64_t HasArc(int i, int j) { if (capacity_[i][j] > 0) { return 1; } else { @@ -564,7 +564,7 @@ class NetworkRoutingSolver { // ----- Main Solve routine ----- - int64 Solve() { + int64_t Solve() { LOG(INFO) << "Solving model"; const int num_demands = demands_array_.size(); const int num_arcs = count_arcs(); @@ -582,7 +582,7 @@ class NetworkRoutingSolver { TableConstraint path_ct = cp_model.AddAllowedAssignments(path_vars[demand_index]); for (const auto& one_path : all_paths_[demand_index]) { - std::vector tuple(count_arcs(), 0); + std::vector tuple(count_arcs(), 0); for (const int arc : one_path) { tuple[arc] = 1; } @@ -593,9 +593,9 @@ class NetworkRoutingSolver { std::vector traffic_vars(num_arcs); std::vector normalized_traffic_vars(num_arcs); std::vector comfortable_traffic_vars(num_arcs); - int64 max_normalized_traffic = 0; + int64_t max_normalized_traffic = 0; for (int arc_index = 0; arc_index < num_arcs; ++arc_index) { - int64 sum_of_traffic = 0; + int64_t sum_of_traffic = 0; LinearExpr traffic_expr; for (int i = 0; i < path_vars.size(); ++i) { sum_of_traffic += demands_array_[i].traffic; @@ -606,7 +606,7 @@ class NetworkRoutingSolver { traffic_vars[arc_index] = traffic_var; cp_model.AddEquality(traffic_expr, traffic_var); - const int64 capacity = arc_capacity_[arc_index]; + const int64_t capacity = arc_capacity_[arc_index]; IntVar scaled_traffic = cp_model.NewIntVar(Domain(0, sum_of_traffic * 1000)); cp_model.AddEquality(LinearExpr::ScalProd({traffic_var}, {1000}), @@ -619,8 +619,8 @@ class NetworkRoutingSolver { cp_model.NewConstant(capacity)); normalized_traffic_vars[arc_index] = normalized_traffic; const BoolVar comfort = cp_model.NewBoolVar(); - const int64 safe_capacity = - static_cast(capacity * absl::GetFlag(FLAGS_comfort_zone)); + const int64_t safe_capacity = + static_cast(capacity * absl::GetFlag(FLAGS_comfort_zone)); cp_model.AddGreaterThan(traffic_var, safe_capacity) .OnlyEnforceIf(comfort); cp_model.AddLessOrEqual(traffic_var, safe_capacity) @@ -668,11 +668,11 @@ class NetworkRoutingSolver { private: int count_arcs() const { return arcs_data_.size() / 2; } - std::vector> arcs_data_; + std::vector> arcs_data_; std::vector arc_capacity_; std::vector demands_array_; int num_nodes_; - std::vector all_min_path_lengths_; + std::vector all_min_path_lengths_; std::vector> capacity_; std::vector> all_paths_; }; diff --git a/examples/cpp/nqueens.cc b/examples/cpp/nqueens.cc index 8bf95292c4..23e2284b35 100644 --- a/examples/cpp/nqueens.cc +++ b/examples/cpp/nqueens.cc @@ -85,7 +85,7 @@ class SX : public NQueenSymmetry { : NQueenSymmetry(s, vars) {} ~SX() override {} - void VisitSetVariableValue(IntVar* const var, int64 value) override { + void VisitSetVariableValue(IntVar* const var, int64_t value) override { const int index = Index(var); IntVar* const other_var = Var(symmetric(index)); AddIntegerVariableEqualValueClause(other_var, value); @@ -99,7 +99,7 @@ class SY : public NQueenSymmetry { : NQueenSymmetry(s, vars) {} ~SY() override {} - void VisitSetVariableValue(IntVar* const var, int64 value) override { + void VisitSetVariableValue(IntVar* const var, int64_t value) override { AddIntegerVariableEqualValueClause(var, symmetric(value)); } }; @@ -111,7 +111,7 @@ class SD1 : public NQueenSymmetry { : NQueenSymmetry(s, vars) {} ~SD1() override {} - void VisitSetVariableValue(IntVar* const var, int64 value) override { + void VisitSetVariableValue(IntVar* const var, int64_t value) override { const int index = Index(var); IntVar* const other_var = Var(value); AddIntegerVariableEqualValueClause(other_var, index); @@ -125,7 +125,7 @@ class SD2 : public NQueenSymmetry { : NQueenSymmetry(s, vars) {} ~SD2() override {} - void VisitSetVariableValue(IntVar* const var, int64 value) override { + void VisitSetVariableValue(IntVar* const var, int64_t value) override { const int index = Index(var); IntVar* const other_var = Var(symmetric(value)); AddIntegerVariableEqualValueClause(other_var, symmetric(index)); @@ -139,7 +139,7 @@ class R90 : public NQueenSymmetry { : NQueenSymmetry(s, vars) {} ~R90() override {} - void VisitSetVariableValue(IntVar* const var, int64 value) override { + void VisitSetVariableValue(IntVar* const var, int64_t value) override { const int index = Index(var); IntVar* const other_var = Var(value); AddIntegerVariableEqualValueClause(other_var, symmetric(index)); @@ -153,7 +153,7 @@ class R180 : public NQueenSymmetry { : NQueenSymmetry(s, vars) {} ~R180() override {} - void VisitSetVariableValue(IntVar* const var, int64 value) override { + void VisitSetVariableValue(IntVar* const var, int64_t value) override { const int index = Index(var); IntVar* const other_var = Var(symmetric(index)); AddIntegerVariableEqualValueClause(other_var, symmetric(value)); @@ -167,7 +167,7 @@ class R270 : public NQueenSymmetry { : NQueenSymmetry(s, vars) {} ~R270() override {} - void VisitSetVariableValue(IntVar* const var, int64 value) override { + void VisitSetVariableValue(IntVar* const var, int64_t value) override { const int index = Index(var); IntVar* const other_var = Var(symmetric(value)); AddIntegerVariableEqualValueClause(other_var, index); diff --git a/examples/cpp/opb_reader.h b/examples/cpp/opb_reader.h index e35f47ee5b..d02a6ed272 100644 --- a/examples/cpp/opb_reader.h +++ b/examples/cpp/opb_reader.h @@ -82,7 +82,7 @@ class OpbReader { num_variables_ = std::max(num_variables_, literal); objective->add_literals(literal); } else { - int64 value; + int64_t value; CHECK(absl::SimpleAtoi(word, &value)); objective->add_coefficients(value); } @@ -99,13 +99,13 @@ class OpbReader { CHECK(!word.empty()); if (word == ">=") { CHECK_LT(i + 1, words.size()); - int64 value; + int64_t value; CHECK(absl::SimpleAtoi(words[i + 1], &value)); constraint->set_lower_bound(value); break; } else if (word == "=") { CHECK_LT(i + 1, words.size()); - int64 value; + int64_t value; CHECK(absl::SimpleAtoi(words[i + 1], &value)); constraint->set_upper_bound(value); constraint->set_lower_bound(value); @@ -117,7 +117,7 @@ class OpbReader { num_variables_ = std::max(num_variables_, literal); constraint->add_literals(literal); } else { - int64 value; + int64_t value; CHECK(absl::SimpleAtoi(words[i], &value)); constraint->add_coefficients(value); } diff --git a/examples/cpp/pdptw.cc b/examples/cpp/pdptw.cc index 9d04d66f9e..da2c28706a 100644 --- a/examples/cpp/pdptw.cc +++ b/examples/cpp/pdptw.cc @@ -73,7 +73,7 @@ namespace operations_research { // Scaling factor used to scale up distances, allowing a bit more precision // from Euclidean distances. -const int64 kScalingFactor = 1000; +const int64_t kScalingFactor = 1000; // Vector of (x,y) node coordinates, *unscaled*, in some imaginary planar, // metric grid. @@ -81,20 +81,20 @@ typedef std::vector > Coordinates; // Returns the scaled Euclidean distance between two nodes, coords holding the // coordinates of the nodes. -int64 Travel(const Coordinates* const coords, +int64_t Travel(const Coordinates* const coords, RoutingIndexManager::NodeIndex from, RoutingIndexManager::NodeIndex to) { DCHECK(coords != nullptr); const int xd = coords->at(from.value()).first - coords->at(to.value()).first; const int yd = coords->at(from.value()).second - coords->at(to.value()).second; - return static_cast(kScalingFactor * + return static_cast(kScalingFactor * std::sqrt(1.0L * xd * xd + yd * yd)); } // Returns the scaled service time at a given node, service_times holding the // service times. -int64 ServiceTime(const std::vector* const service_times, +int64_t ServiceTime(const std::vector* const service_times, RoutingIndexManager::NodeIndex node) { return kScalingFactor * service_times->at(node.value()); } @@ -103,10 +103,10 @@ int64 ServiceTime(const std::vector* const service_times, // holding the coordinates of the nodes and service_times holding the service // times. // The service time is the time spent to execute a delivery or a pickup. -int64 TravelPlusServiceTime(const RoutingIndexManager& manager, +int64_t TravelPlusServiceTime(const RoutingIndexManager& manager, const Coordinates* const coords, - const std::vector* const service_times, - int64 from_index, int64 to_index) { + const std::vector* const service_times, + int64_t from_index, int64_t to_index) { const RoutingIndexManager::NodeIndex from = manager.IndexToNode(from_index); const RoutingIndexManager::NodeIndex to = manager.IndexToNode(to_index); return ServiceTime(service_times, from) + Travel(coords, from, to); @@ -144,13 +144,13 @@ std::string VerboseOutput(const RoutingModel& routing, const RoutingIndexManager& manager, const Assignment& assignment, const Coordinates& coords, - const std::vector& service_times) { + const std::vector& service_times) { std::string output; const RoutingDimension& time_dimension = routing.GetDimensionOrDie("time"); const RoutingDimension& load_dimension = routing.GetDimensionOrDie("demand"); for (int i = 0; i < routing.vehicles(); ++i) { absl::StrAppendFormat(&output, "Vehicle %d: ", i); - int64 index = routing.Start(i); + int64_t index = routing.Start(i); if (routing.IsEnd(assignment.Value(routing.NextVar(index)))) { output.append("empty"); } else { @@ -166,7 +166,7 @@ std::string VerboseOutput(const RoutingModel& routing, const IntVar* load = load_dimension.CumulVar(index); absl::StrAppendFormat(&output, "Load(%d..%d) ", assignment.Min(load), assignment.Max(load)); - const int64 next_index = assignment.Value(routing.NextVar(index)); + const int64_t next_index = assignment.Value(routing.NextVar(index)); absl::StrAppendFormat( &output, "Transit(%d) ", TravelPlusServiceTime(manager, &coords, &service_times, index, @@ -192,9 +192,9 @@ namespace { // An inefficient but convenient method to parse a whitespace-separated list // of integers. Returns true iff the input string was entirely valid and parsed. bool SafeParseInt64Array(const std::string& str, - std::vector* parsed_int) { + std::vector* parsed_int) { std::istringstream input(str); - int64 x; + int64_t x; parsed_int->clear(); while (input >> x) parsed_int->push_back(x); return input.eof(); @@ -211,7 +211,7 @@ bool LoadAndSolve(const std::string& pdp_file, { std::string contents; CHECK_OK(file::GetContents(pdp_file, &contents, file::Defaults())); - const int64 kMaxInputFileSize = 1 << 30; // 1GB + const int64_t kMaxInputFileSize = 1 << 30; // 1GB if (contents.size() >= kMaxInputFileSize) { LOG(WARNING) << "Input file '" << pdp_file << "' is too large (>" << kMaxInputFileSize << " bytes)."; @@ -225,7 +225,7 @@ bool LoadAndSolve(const std::string& pdp_file, return false; } // Parse file header. - std::vector parsed_int; + std::vector parsed_int; if (!SafeParseInt64Array(lines[0], &parsed_int) || parsed_int.size() != 3 || parsed_int[0] < 0 || parsed_int[1] < 0 || parsed_int[2] < 0) { LOG(WARNING) << "Malformed header: " << lines[0]; @@ -234,19 +234,19 @@ bool LoadAndSolve(const std::string& pdp_file, const int num_vehicles = absl::GetFlag(FLAGS_pdp_force_vehicles) > 0 ? absl::GetFlag(FLAGS_pdp_force_vehicles) : parsed_int[0]; - const int64 capacity = parsed_int[1]; + const int64_t capacity = parsed_int[1]; // We do not care about the 'speed' field, in third position. // Parse order data. std::vector customer_ids; std::vector > coords; - std::vector demands; - std::vector open_times; - std::vector close_times; - std::vector service_times; + std::vector demands; + std::vector open_times; + std::vector close_times; + std::vector service_times; std::vector pickups; std::vector deliveries; - int64 horizon = 0; + int64_t horizon = 0; RoutingIndexManager::NodeIndex depot(0); for (int line_index = 1; line_index < lines.size(); ++line_index) { if (!SafeParseInt64Array(lines[line_index], &parsed_int) || @@ -260,10 +260,10 @@ bool LoadAndSolve(const std::string& pdp_file, const int customer_id = parsed_int[0]; const int x = parsed_int[1]; const int y = parsed_int[2]; - const int64 demand = parsed_int[3]; - const int64 open_time = parsed_int[4]; - const int64 close_time = parsed_int[5]; - const int64 service_time = parsed_int[6]; + const int64_t demand = parsed_int[3]; + const int64_t open_time = parsed_int[4]; + const int64_t close_time = parsed_int[5]; + const int64_t service_time = parsed_int[6]; const int pickup = parsed_int[7]; const int delivery = parsed_int[8]; customer_ids.push_back(customer_id); @@ -285,19 +285,19 @@ bool LoadAndSolve(const std::string& pdp_file, RoutingIndexManager manager(num_nodes, num_vehicles, depot); RoutingModel routing(manager, model_parameters); const int vehicle_cost = - routing.RegisterTransitCallback([&coords, &manager](int64 i, int64 j) { + routing.RegisterTransitCallback([&coords, &manager](int64_t i, int64_t j) { return Travel(const_cast(&coords), manager.IndexToNode(i), manager.IndexToNode(j)); }); routing.SetArcCostEvaluatorOfAllVehicles(vehicle_cost); - RoutingTransitCallback2 demand_evaluator = [&](int64 from_index, - int64 to_index) { + RoutingTransitCallback2 demand_evaluator = [&](int64_t from_index, + int64_t to_index) { return demands[manager.IndexToNode(from_index).value()]; }; routing.AddDimension(routing.RegisterTransitCallback(demand_evaluator), 0, capacity, /*fix_start_cumul_to_zero=*/true, "demand"); - RoutingTransitCallback2 time_evaluator = [&](int64 from_index, - int64 to_index) { + RoutingTransitCallback2 time_evaluator = [&](int64_t from_index, + int64_t to_index) { return TravelPlusServiceTime(manager, &coords, &service_times, from_index, to_index); }; @@ -307,10 +307,10 @@ bool LoadAndSolve(const std::string& pdp_file, const RoutingDimension& time_dimension = routing.GetDimensionOrDie("time"); Solver* const solver = routing.solver(); for (int node = 0; node < num_nodes; ++node) { - const int64 index = + const int64_t index = manager.NodeToIndex(RoutingIndexManager::NodeIndex(node)); if (pickups[node] == 0 && deliveries[node] != 0) { - const int64 delivery_index = manager.NodeToIndex(deliveries[node]); + const int64_t delivery_index = manager.NodeToIndex(deliveries[node]); solver->AddConstraint(solver->MakeEquality( routing.VehicleVar(index), routing.VehicleVar(delivery_index))); solver->AddConstraint( @@ -352,10 +352,10 @@ bool LoadAndSolve(const std::string& pdp_file, } // Adding penalty costs to allow skipping orders. - const int64 kPenalty = 10000000; + const int64_t kPenalty = 10000000; for (RoutingIndexManager::NodeIndex order(1); order < routing.nodes(); ++order) { - std::vector orders(1, manager.NodeToIndex(order)); + std::vector orders(1, manager.NodeToIndex(order)); routing.AddDisjunction(orders, kPenalty); } diff --git a/examples/cpp/random_tsp.cc b/examples/cpp/random_tsp.cc index 3ef8a1232d..b0d0e57e9d 100644 --- a/examples/cpp/random_tsp.cc +++ b/examples/cpp/random_tsp.cc @@ -66,7 +66,7 @@ int32 GetSeed() { // Cost/distance functions. // Sample function. -int64 MyDistance(RoutingIndexManager::NodeIndex from, +int64_t MyDistance(RoutingIndexManager::NodeIndex from, RoutingIndexManager::NodeIndex to) { // Put your distance code here. return (from + to).value(); // for instance @@ -77,8 +77,8 @@ class RandomMatrix { public: explicit RandomMatrix(int size) : size_(size) {} void Initialize() { - matrix_ = absl::make_unique(size_ * size_); - const int64 kDistanceMax = 100; + matrix_ = absl::make_unique(size_ * size_); + const int64_t kDistanceMax = 100; ACMRandom randomizer(GetSeed()); for (RoutingIndexManager::NodeIndex from(0); from < size_; ++from) { for (RoutingIndexManager::NodeIndex to(0); to < size_; ++to) { @@ -90,17 +90,17 @@ class RandomMatrix { } } } - int64 Distance(RoutingIndexManager::NodeIndex from, + int64_t Distance(RoutingIndexManager::NodeIndex from, RoutingIndexManager::NodeIndex to) const { return matrix_[MatrixIndex(from, to)]; } private: - int64 MatrixIndex(RoutingIndexManager::NodeIndex from, + int64_t MatrixIndex(RoutingIndexManager::NodeIndex from, RoutingIndexManager::NodeIndex to) const { return (from * size_ + to).value(); } - std::unique_ptr matrix_; + std::unique_ptr matrix_; const int size_; }; @@ -120,31 +120,31 @@ void Tsp() { // Setting the cost function. // Put a permanent callback to the distance accessor here. The callback - // has the following signature: ResultCallback2. + // has the following signature: ResultCallback2. // The two arguments are the from and to node inidices. RandomMatrix matrix(absl::GetFlag(FLAGS_tsp_size)); if (absl::GetFlag(FLAGS_tsp_use_random_matrix)) { matrix.Initialize(); const int vehicle_cost = routing.RegisterTransitCallback( - [&matrix, &manager](int64 i, int64 j) { + [&matrix, &manager](int64_t i, int64_t j) { return matrix.Distance(manager.IndexToNode(i), manager.IndexToNode(j)); }); routing.SetArcCostEvaluatorOfAllVehicles(vehicle_cost); } else { const int vehicle_cost = - routing.RegisterTransitCallback([&manager](int64 i, int64 j) { + routing.RegisterTransitCallback([&manager](int64_t i, int64_t j) { return MyDistance(manager.IndexToNode(i), manager.IndexToNode(j)); }); routing.SetArcCostEvaluatorOfAllVehicles(vehicle_cost); } // Forbid node connections (randomly). ACMRandom randomizer(GetSeed()); - int64 forbidden_connections = 0; + int64_t forbidden_connections = 0; while (forbidden_connections < absl::GetFlag(FLAGS_tsp_random_forbidden_connections)) { - const int64 from = randomizer.Uniform(absl::GetFlag(FLAGS_tsp_size) - 1); - const int64 to = + const int64_t from = randomizer.Uniform(absl::GetFlag(FLAGS_tsp_size) - 1); + const int64_t to = randomizer.Uniform(absl::GetFlag(FLAGS_tsp_size) - 1) + 1; if (routing.NextVar(from)->Contains(to)) { LOG(INFO) << "Forbidding connection " << from << " -> " << to; @@ -161,12 +161,12 @@ void Tsp() { // Only one route here; otherwise iterate from 0 to routing.vehicles() - 1 const int route_number = 0; std::string route; - for (int64 node = routing.Start(route_number); !routing.IsEnd(node); + for (int64_t node = routing.Start(route_number); !routing.IsEnd(node); node = solution->Value(routing.NextVar(node))) { absl::StrAppend(&route, manager.IndexToNode(node).value(), " (", node, ") -> "); } - const int64 end = routing.End(route_number); + const int64_t end = routing.End(route_number); absl::StrAppend(&route, manager.IndexToNode(end).value(), " (", end, ")"); LOG(INFO) << route; } else { diff --git a/examples/cpp/sat_cnf_reader.h b/examples/cpp/sat_cnf_reader.h index c36cc4ad71..b36896c16f 100644 --- a/examples/cpp/sat_cnf_reader.h +++ b/examples/cpp/sat_cnf_reader.h @@ -58,13 +58,13 @@ struct LinearBooleanProblemWrapper { } } - void AddObjectiveTerm(int literal, int64 value) { + void AddObjectiveTerm(int literal, int64_t value) { CHECK_GE(literal, 0) << "Negative literal not supported."; problem->mutable_objective()->add_literals(literal); problem->mutable_objective()->add_coefficients(value); } - void SetObjectiveOffset(int64 offset) { + void SetObjectiveOffset(int64_t offset) { problem->mutable_objective()->set_offset(offset); } @@ -100,13 +100,13 @@ struct CpModelProtoWrapper { } } - void AddObjectiveTerm(int literal, int64 value) { + void AddObjectiveTerm(int literal, int64_t value) { CHECK_GE(literal, 0) << "Negative literal not supported."; problem->mutable_objective()->add_vars(LiteralToRef(literal)); problem->mutable_objective()->add_coeffs(value); } - void SetObjectiveOffset(int64 offset) { + void SetObjectiveOffset(int64_t offset) { problem->mutable_objective()->set_offset(offset); } @@ -166,7 +166,7 @@ class SatCnfReader { // Fill the objective. if (!positive_literal_to_weight_.empty()) { - for (const std::pair p : positive_literal_to_weight_) { + for (const std::pair p : positive_literal_to_weight_) { if (p.second != 0) { problem->AddObjectiveTerm(p.first, p.second); } @@ -192,8 +192,8 @@ class SatCnfReader { return problem_name; } - int64 StringPieceAtoi(absl::string_view input) { - int64 value; + int64_t StringPieceAtoi(absl::string_view input) { + int64_t value; // Hack: data() is not null terminated, but we do know that it points // inside a string where numbers are separated by " " and since SimpleAtoi // will stop at the first invalid char, this works. @@ -236,11 +236,11 @@ class SatCnfReader { auto splitter = absl::StrSplit(line, kWordDelimiters, absl::SkipEmpty()); tmp_clause_.clear(); - int64 weight = (!is_wcnf_ && interpret_cnf_as_max_sat_) ? 1 : hard_weight_; + int64_t weight = (!is_wcnf_ && interpret_cnf_as_max_sat_) ? 1 : hard_weight_; bool first = true; bool end_marker_seen = false; for (const absl::string_view word : splitter) { - const int64 signed_value = StringPieceAtoi(word); + const int64_t signed_value = StringPieceAtoi(word); if (first && is_wcnf_) { // Mathematically, a soft clause of weight 0 can be removed. if (signed_value == 0) { @@ -315,14 +315,14 @@ class SatCnfReader { // We stores the objective in a map because we want the variables to appear // only once in the LinearObjective proto. - std::map positive_literal_to_weight_; - int64 objective_offset_; + std::map positive_literal_to_weight_; + int64_t objective_offset_; // Used for the wcnf format. bool is_wcnf_; // Some files have text after %. This indicates if we have seen the '%'. bool end_marker_seen_; - int64 hard_weight_; + int64_t hard_weight_; int num_slack_variables_; int num_skipped_soft_clauses_; diff --git a/examples/cpp/sat_runner.cc b/examples/cpp/sat_runner.cc index b86f21bafc..c0431c9742 100644 --- a/examples/cpp/sat_runner.cc +++ b/examples/cpp/sat_runner.cc @@ -285,7 +285,7 @@ int Run() { } } auto strtoint64 = [](const std::string& word) { - int64 value = 0; + int64_t value = 0; if (!word.empty()) CHECK(absl::SimpleAtoi(word, &value)); return value; }; diff --git a/examples/cpp/solve.cc b/examples/cpp/solve.cc index 75ed4b3c41..e841858bd6 100644 --- a/examples/cpp/solve.cc +++ b/examples/cpp/solve.cc @@ -44,7 +44,7 @@ ABSL_FLAG(std::string, params_file, "", "Solver specific parameters file. " "If this flag is set, the --params flag is ignored."); ABSL_FLAG(std::string, params, "", "Solver specific parameters"); -ABSL_FLAG(int64, time_limit_ms, 0, +ABSL_FLAG(int64_t, time_limit_ms, 0, "If strictly positive, specifies a limit in ms on the solving " "time. Otherwise, no time limit will be imposed."); @@ -177,7 +177,7 @@ bool Run() { &error_message); if (request_proto.has_solver_time_limit_seconds()) { solver.set_time_limit( - static_cast(1000.0 * request_proto.solver_time_limit_seconds())); + static_cast(1000.0 * request_proto.solver_time_limit_seconds())); } // Note, the underlying MPSolver treats time limit equal to 0 as no limit. if (absl::GetFlag(FLAGS_time_limit_ms) >= 0) { diff --git a/examples/cpp/weighted_tardiness_sat.cc b/examples/cpp/weighted_tardiness_sat.cc index b9448b1bc5..c1bd20087e 100644 --- a/examples/cpp/weighted_tardiness_sat.cc +++ b/examples/cpp/weighted_tardiness_sat.cc @@ -42,9 +42,9 @@ namespace operations_research { namespace sat { // Solve a single machine problem with weighted tardiness cost. -void Solve(const std::vector& durations, - const std::vector& due_dates, - const std::vector& weights) { +void Solve(const std::vector& durations, + const std::vector& due_dates, + const std::vector& weights) { const int num_tasks = durations.size(); CHECK_EQ(due_dates.size(), num_tasks); CHECK_EQ(weights.size(), num_tasks); @@ -60,14 +60,14 @@ void Solve(const std::vector& durations, // An simple heuristic solution: We choose the tasks from last to first, and // always take the one with smallest cost. std::vector is_taken(num_tasks, false); - int64 heuristic_bound = 0; - int64 end = horizon; + int64_t heuristic_bound = 0; + int64_t end = horizon; for (int i = 0; i < num_tasks; ++i) { int next_task = -1; - int64 next_cost; + int64_t next_cost; for (int j = 0; j < num_tasks; ++j) { if (is_taken[j]) continue; - const int64 cost = weights[j] * std::max(0, end - due_dates[j]); + const int64_t cost = weights[j] * std::max(0, end - due_dates[j]); if (next_task == -1 || cost < next_cost) { next_task = j; next_cost = cost; @@ -101,7 +101,7 @@ void Solve(const std::vector& durations, tardiness_vars[i] = task_ends[i]; } else { tardiness_vars[i] = cp_model.NewIntVar( - Domain(0, std::max(0, horizon - due_dates[i]))); + Domain(0, std::max(0, horizon - due_dates[i]))); // tardiness_vars >= end - due_date cp_model.AddGreaterOrEqual(tardiness_vars[i], @@ -174,11 +174,11 @@ void Solve(const std::vector& durations, // variable might be fixed before the end date, and we just have a >= // relation. - int64 objective = 0; + int64_t objective = 0; for (int i = 0; i < num_tasks; ++i) { - const int64 end = SolutionIntegerMin(r, task_ends[i]); + const int64_t end = SolutionIntegerMin(r, task_ends[i]); CHECK_EQ(end, SolutionIntegerMax(r, task_ends[i])); - objective += weights[i] * std::max(int64{0}, end - due_dates[i]); + objective += weights[i] * std::max(int64_t{0}, end - due_dates[i]); } LOG(INFO) << "Cost " << objective; @@ -196,7 +196,7 @@ void Solve(const std::vector& durations, std::string solution = "0"; int end = 0; for (const int i : sorted_tasks) { - const int64 cost = weights[i] * SolutionIntegerMin(r, tardiness_vars[i]); + const int64_t cost = weights[i] * SolutionIntegerMin(r, tardiness_vars[i]); absl::StrAppend(&solution, "| #", i, " "); if (cost > 0) { // Display the cost in red. @@ -237,13 +237,13 @@ void ParseAndSolve() { // The order in a wt file is: duration, tardiness weights and then due_dates. int index = (absl::GetFlag(FLAGS_n) - 1) * instance_size; - std::vector durations; + std::vector durations; for (int j = 0; j < absl::GetFlag(FLAGS_size); ++j) durations.push_back(numbers[index++]); - std::vector weights; + std::vector weights; for (int j = 0; j < absl::GetFlag(FLAGS_size); ++j) weights.push_back(numbers[index++]); - std::vector due_dates; + std::vector due_dates; for (int j = 0; j < absl::GetFlag(FLAGS_size); ++j) due_dates.push_back(numbers[index++]); diff --git a/examples/data/roadef_challenge_2011/solution_checker/solution_checker.cc b/examples/data/roadef_challenge_2011/solution_checker/solution_checker.cc index c531ab351f..e882c95ffd 100644 --- a/examples/data/roadef_challenge_2011/solution_checker/solution_checker.cc +++ b/examples/data/roadef_challenge_2011/solution_checker/solution_checker.cc @@ -53,7 +53,7 @@ void RemainingCapacities::Consume(const Requirements& requirements) { CHECK_EQ(num_resources, ResourceIndex(requirements.size())); for (ResourceIndex resource_id(0); resource_id < num_resources; ++resource_id) { - const int64 consumption = requirements.at(resource_id); + const int64_t consumption = requirements.at(resource_id); remaining_capacities_.at(resource_id) -= consumption; transient_remaining_capacities_.at(resource_id) -= consumption; } @@ -64,7 +64,7 @@ void RemainingCapacities::UndoConsumption(const Requirements& requirements) { CHECK_EQ(num_resources, ResourceIndex(requirements.size())); for (ResourceIndex resource_id(0); resource_id < num_resources; ++resource_id) { - const int64 consumption = requirements.at(resource_id); + const int64_t consumption = requirements.at(resource_id); remaining_capacities_.at(resource_id) += consumption; const Resource& resource = resources(resource_id); if (!resource.is_transient) { @@ -73,35 +73,35 @@ void RemainingCapacities::UndoConsumption(const Requirements& requirements) { } } -int64 RemainingCapacities::GetMinTransientValue() const { +int64_t RemainingCapacities::GetMinTransientValue() const { return *std::min_element(transient_remaining_capacities_.begin(), transient_remaining_capacities_.end()); } -int64 RemainingCapacities::GetLoadCost( +int64_t RemainingCapacities::GetLoadCost( const Capacities& safety_remaining_capacities) const { - int64 load_cost = 0; + int64_t load_cost = 0; const ResourceIndex num_resources = GetNumberOfResources(); CHECK_EQ(num_resources, ResourceIndex(safety_remaining_capacities.size())); for (ResourceIndex resource_id(0); resource_id < num_resources; ++resource_id) { const int load_cost_weight = resources_.at(resource_id).load_cost_weight; - const int64 delta = safety_remaining_capacities.at(resource_id) - + const int64_t delta = safety_remaining_capacities.at(resource_id) - remaining_capacities_.at(resource_id); - load_cost += load_cost_weight * std::max(delta, int64{0}); + load_cost += load_cost_weight * std::max(delta, int64_t{0}); } return load_cost; } -int64 RemainingCapacities::GetBalanceCost( +int64_t RemainingCapacities::GetBalanceCost( const BalanceCost& balance_cost) const { - const int64 remaining_on_target = + const int64_t remaining_on_target = balance_cost.target * remaining_capacities_.at(balance_cost.first_resource_id); - const int64 remaining = + const int64_t remaining = remaining_capacities_.at(balance_cost.second_resource_id); return balance_cost.weight * - std::max(int64{0}, remaining_on_target - remaining); + std::max(int64_t{0}, remaining_on_target - remaining); } // -------------------------------------------------------- @@ -173,11 +173,11 @@ bool Machine::HasNegativeRemainingCapacity() const { remaining_capacities_.GetMinTransientValue() < 0; } -int64 Machine::GetLoadCost() const { +int64_t Machine::GetLoadCost() const { return remaining_capacities_.GetLoadCost(safety_remaining_capacities_); } -int64 Machine::GetBalanceCost(const BalanceCost& balance_cost) const { +int64_t Machine::GetBalanceCost(const BalanceCost& balance_cost) const { return remaining_capacities_.GetBalanceCost(balance_cost); } @@ -245,13 +245,13 @@ bool SolutionChecker::Check() const { CheckSpreadConstraints() && CheckDependencyConstraints(); } -int64 SolutionChecker::GetObjectiveCost() const { - const int64 load_cost = GetLoadCost(); - const int64 balance_cost = GetBalanceCost(); - const int64 process_move_cost = GetProcessMoveCost(); - const int64 service_move_cost = GetServiceMoveCost(); - const int64 machine_move_cost = GetMachineMoveCost(); - const int64 total_cost = load_cost + balance_cost + process_move_cost + +int64_t SolutionChecker::GetObjectiveCost() const { + const int64_t load_cost = GetLoadCost(); + const int64_t balance_cost = GetBalanceCost(); + const int64_t process_move_cost = GetProcessMoveCost(); + const int64_t service_move_cost = GetServiceMoveCost(); + const int64_t machine_move_cost = GetMachineMoveCost(); + const int64_t total_cost = load_cost + balance_cost + process_move_cost + service_move_cost + machine_move_cost; return total_cost; } @@ -417,8 +417,8 @@ bool SolutionChecker::CheckDependencyConstraints() const { return true; } -int64 SolutionChecker::GetLoadCost() const { - int64 cost = 0; +int64_t SolutionChecker::GetLoadCost() const { + int64_t cost = 0; const MachineIndex num_machines = GetNumberOfMachines(); for (MachineIndex machine_id(0); machine_id < num_machines; ++machine_id) { const Machine& machine = machines(machine_id); @@ -427,8 +427,8 @@ int64 SolutionChecker::GetLoadCost() const { return cost; } -int64 SolutionChecker::GetBalanceCost() const { - int64 cost = 0; +int64_t SolutionChecker::GetBalanceCost() const { + int64_t cost = 0; const MachineIndex num_machines = GetNumberOfMachines(); const BalanceCostIndex num_balance_costs(balance_costs_.size()); for (BalanceCostIndex balance_id(0); balance_id < num_balance_costs; @@ -442,8 +442,8 @@ int64 SolutionChecker::GetBalanceCost() const { return cost; } -int64 SolutionChecker::GetProcessMoveCost() const { - int64 cost = 0; +int64_t SolutionChecker::GetProcessMoveCost() const { + int64_t cost = 0; const ProcessIndex num_processes = GetNumberOfProcesses(); for (ProcessIndex process_id(0); process_id < num_processes; ++process_id) { const Process& process = processes(process_id); @@ -454,7 +454,7 @@ int64 SolutionChecker::GetProcessMoveCost() const { return process_move_cost_weight_ * cost; } -int64 SolutionChecker::GetServiceMoveCost() const { +int64_t SolutionChecker::GetServiceMoveCost() const { int max_num_moves = 0; const ServiceIndex num_services = GetNumberOfServices(); for (ServiceIndex service_id(0); service_id < num_services; ++service_id) { @@ -473,8 +473,8 @@ int64 SolutionChecker::GetServiceMoveCost() const { return service_move_cost_weight_ * max_num_moves; } -int64 SolutionChecker::GetMachineMoveCost() const { - int64 cost = 0; +int64_t SolutionChecker::GetMachineMoveCost() const { + int64_t cost = 0; const ProcessIndex num_processes = GetNumberOfProcesses(); for (ProcessIndex process_id(0); process_id < num_processes; ++process_id) { const MachineIndex initial_machine_id = initial_assignments_.at(process_id); diff --git a/examples/data/roadef_challenge_2011/solution_checker/solution_checker.h b/examples/data/roadef_challenge_2011/solution_checker/solution_checker.h index b455b617ee..2ba777d673 100644 --- a/examples/data/roadef_challenge_2011/solution_checker/solution_checker.h +++ b/examples/data/roadef_challenge_2011/solution_checker/solution_checker.h @@ -20,7 +20,7 @@ #include "assert.h" using namespace std; -typedef long long int int64; +typedef long long int int64_t; namespace roadef_challenge { @@ -35,7 +35,7 @@ typedef int NumberOfLocations; typedef int BalanceCostIndex; typedef int DependencyIndex; -typedef std::vector Capacities; +typedef std::vector Capacities; typedef std::vector Requirements; typedef std::vector ProcessAssignments; typedef std::vector MoveToMachineCosts; @@ -109,13 +109,13 @@ class RemainingCapacities { void UndoConsumption(const Requirements& requirements); // Returns the smallest capacity of the transient remaining capacities. - int64 GetMinTransientValue() const; + int64_t GetMinTransientValue() const; // Returns the weighted sum of load costs of all resources. - int64 GetLoadCost(const Capacities& safety_remaining_capacities) const; + int64_t GetLoadCost(const Capacities& safety_remaining_capacities) const; // Returns the weighted sum of balance costs of all resources. - int64 GetBalanceCost(const BalanceCost& balance_cost) const; + int64_t GetBalanceCost(const BalanceCost& balance_cost) const; ResourceIndex GetNumberOfResources() const { return VectorSize(resources_); } @@ -217,10 +217,10 @@ class Machine { bool HasNegativeRemainingCapacity() const; // Returns the weighted load cost of the machine. - int64 GetLoadCost() const; + int64_t GetLoadCost() const; // Returns the weighted balance cost of the machine. - int64 GetBalanceCost(const BalanceCost& balance_cost) const; + int64_t GetBalanceCost(const BalanceCost& balance_cost) const; MachineIndex id() const { return id_; } LocationIndex location_id() const { return location_id_; } @@ -266,7 +266,7 @@ class SolutionChecker { // Returns the total objective cost as defined in the problem description // document. Note this method assumes all hard constraints are satisfied. - int64 GetObjectiveCost() const; + int64_t GetObjectiveCost() const; private: // Returns true if process doesn't run on the same machine in the @@ -320,19 +320,19 @@ class SolutionChecker { const Service& service) const; // Returns the weigthed sum of all load costs. - int64 GetLoadCost() const; + int64_t GetLoadCost() const; // Returns the weighted sum of all balance costs. - int64 GetBalanceCost() const; + int64_t GetBalanceCost() const; // Returns the weighted sum of all process move costs. - int64 GetProcessMoveCost() const; + int64_t GetProcessMoveCost() const; // Returns the weighted sum of all service move costs. - int64 GetServiceMoveCost() const; + int64_t GetServiceMoveCost() const; // Returns the weighted sum of all machine move costs. - int64 GetMachineMoveCost() const; + int64_t GetMachineMoveCost() const; const Machines& machines_; const Services& services_; diff --git a/examples/data/roadef_challenge_2011/solution_checker/solution_checker_run.cc b/examples/data/roadef_challenge_2011/solution_checker/solution_checker_run.cc index 122c99da04..aafc616b90 100644 --- a/examples/data/roadef_challenge_2011/solution_checker/solution_checker_run.cc +++ b/examples/data/roadef_challenge_2011/solution_checker/solution_checker_run.cc @@ -74,7 +74,7 @@ int main(int argc, char** argv) { data.new_assignments()); if (solution_checker.Check()) { - const int64 objective_cost = solution_checker.GetObjectiveCost(); + const int64_t objective_cost = solution_checker.GetObjectiveCost(); LOG(INFO) << "Solution is valid. Total objective cost is " << objective_cost << std::endl; } else { diff --git a/examples/dotnet/cstsp.cs b/examples/dotnet/cstsp.cs index 37246b38fe..396c6f1df9 100644 --- a/examples/dotnet/cstsp.cs +++ b/examples/dotnet/cstsp.cs @@ -51,7 +51,7 @@ class Tsp // Setting the cost function. // Put a permanent callback to the distance accessor here. The callback - // has the following signature: ResultCallback2. + // has the following signature: ResultCallback2. // The two arguments are the from and to node inidices. RandomManhattan distances = new RandomManhattan(manager, size, seed); routing.SetArcCostEvaluatorOfAllVehicles(routing.RegisterTransitCallback(distances.Call)); diff --git a/examples/java/RandomTsp.java b/examples/java/RandomTsp.java index 193a4b1609..bfee2aeca2 100644 --- a/examples/java/RandomTsp.java +++ b/examples/java/RandomTsp.java @@ -66,7 +66,7 @@ public class RandomTsp { // Setting the cost function. // Put a permanent callback to the distance accessor here. The callback - // has the following signature: ResultCallback2. + // has the following signature: ResultCallback2. // The two arguments are the from and to node inidices. LongBinaryOperator distances = new RandomManhattan(manager, size, seed); routing.setArcCostEvaluatorOfAllVehicles(routing.registerTransitCallback(distances)); diff --git a/examples/tests/bug_fz1.cc b/examples/tests/bug_fz1.cc index b81648612a..549c225d87 100644 --- a/examples/tests/bug_fz1.cc +++ b/examples/tests/bug_fz1.cc @@ -28,12 +28,12 @@ void ShoppingBasketBug() { IntVar* const is2 = s.MakeIsEqualCstVar(x18, 2); IntVar* const is_less = s.MakeIsLessOrEqualCstVar( s.MakeSum(s.MakeProd(is1, 2), s.MakeProd(is2, 2)), 1); - std::vector values1; + std::vector values1; values1.push_back(10); values1.push_back(2); values1.push_back(12); IntVar* const elem1 = s.MakeElement(values1, x15)->Var(); - std::vector values2; + std::vector values2; values2.push_back(2); values2.push_back(10); values2.push_back(5); @@ -42,7 +42,7 @@ void ShoppingBasketBug() { vars.push_back(elem1); vars.push_back(is_less); vars.push_back(elem2); - std::vector coefs; + std::vector coefs; coefs.push_back(1); coefs.push_back(90); coefs.push_back(1); diff --git a/examples/tests/forbidden_intervals_test.cc b/examples/tests/forbidden_intervals_test.cc index b8934b0387..eb02dc982c 100644 --- a/examples/tests/forbidden_intervals_test.cc +++ b/examples/tests/forbidden_intervals_test.cc @@ -105,7 +105,7 @@ class ForbiddenIntervalTestMultipleReductionsOnMax : public DecisionBuilder { class ForbiddenIntervalTest { public: - void SetUp(std::vector& starts, std::vector& ends) { + void SetUp(std::vector& starts, std::vector& ends) { solver_.reset(new Solver("ForbiddenIntervalTest")); var_ = solver_->MakeIntVar(0, 1000, "var"); CHECK_EQ(starts.size(), ends.size()); @@ -119,8 +119,8 @@ class ForbiddenIntervalTest { void TestSimpleReductionOnBothSide() { std::cout << "TestSimpleReductionOnBothSide" << std::endl; - std::vector starts = {0, 900}; - std::vector ends = {100, 1000}; + std::vector starts = {0, 900}; + std::vector ends = {100, 1000}; SetUp(starts, ends); CHECK(solver_->Solve(solver_->RevAlloc( new ForbiddenIntervalTestSimpleReductionOnBothSide(var_)))); @@ -129,8 +129,8 @@ class ForbiddenIntervalTest { void TestMultipleReductionsOnMin() { std::cout << "TestMultipleReductionsOnMin" << std::endl; - std::vector starts = {10, 500, 800}; - std::vector ends = {20, 510, 900}; + std::vector starts = {10, 500, 800}; + std::vector ends = {20, 510, 900}; SetUp(starts, ends); CHECK(solver_->Solve(solver_->RevAlloc( new ForbiddenIntervalTestMultipleReductionsOnMin(var_)))); @@ -139,8 +139,8 @@ class ForbiddenIntervalTest { void TestMultipleReductionsOnMax() { std::cout << "TestMultipleReductionsOnMax" << std::endl; - std::vector starts = {10, 500, 800}; - std::vector ends = {20, 510, 900}; + std::vector starts = {10, 500, 800}; + std::vector ends = {20, 510, 900}; SetUp(starts, ends); CHECK(solver_->Solve(solver_->RevAlloc( new ForbiddenIntervalTestMultipleReductionsOnMax(var_)))); diff --git a/examples/tests/remote/tsp.cc b/examples/tests/remote/tsp.cc index 3a30ef8e9e..585eb82a6b 100644 --- a/examples/tests/remote/tsp.cc +++ b/examples/tests/remote/tsp.cc @@ -59,7 +59,7 @@ int32 GetSeed() { // Cost/distance functions. // Sample function. -int64 MyDistance(RoutingModel::NodeIndex from, RoutingModel::NodeIndex to) { +int64_t MyDistance(RoutingModel::NodeIndex from, RoutingModel::NodeIndex to) { // Put your distance code here. return (from + to).value(); // for instance } @@ -69,8 +69,8 @@ class RandomMatrix { public: explicit RandomMatrix(int size) : size_(size) {} void Initialize() { - matrix_.reset(new int64[size_ * size_]); - const int64 kDistanceMax = 100; + matrix_.reset(new int64_t[size_ * size_]); + const int64_t kDistanceMax = 100; ACMRandom randomizer(GetSeed()); for (RoutingModel::NodeIndex from = RoutingModel::kFirstNode; from < size_; ++from) { @@ -84,17 +84,17 @@ class RandomMatrix { } } } - int64 Distance(RoutingModel::NodeIndex from, + int64_t Distance(RoutingModel::NodeIndex from, RoutingModel::NodeIndex to) const { return matrix_[MatrixIndex(from, to)]; } private: - int64 MatrixIndex(RoutingModel::NodeIndex from, + int64_t MatrixIndex(RoutingModel::NodeIndex from, RoutingModel::NodeIndex to) const { return (from * size_ + to).value(); } - std::unique_ptr matrix_; + std::unique_ptr matrix_; const int size_; }; @@ -113,7 +113,7 @@ int main(int argc, char** argv) { // Setting the cost function. // Put a permanent callback to the distance accessor here. The callback - // has the following signature: ResultCallback2. + // has the following signature: ResultCallback2. // The two arguments are the from and to node inidices. RandomMatrix matrix(absl::GetFlag(FLAGS_tsp_size)); if (absl::GetFlag(FLAGS_tsp_use_random_matrix)) { @@ -126,11 +126,11 @@ int main(int argc, char** argv) { } // Forbid node connections (randomly). ACMRandom randomizer(GetSeed()); - int64 forbidden_connections = 0; + int64_t forbidden_connections = 0; while (forbidden_connections < absl::GetFlag(FLAGS_tsp_random_forbidden_connections)) { - const int64 from = randomizer.Uniform(absl::GetFlag(FLAGS_tsp_size) - 1); - const int64 to = + const int64_t from = randomizer.Uniform(absl::GetFlag(FLAGS_tsp_size) - 1); + const int64_t to = randomizer.Uniform(absl::GetFlag(FLAGS_tsp_size) - 1) + 1; if (routing.NextVar(from)->Contains(to)) { LOG(INFO) << "Forbidding connection " << from << " -> " << to; @@ -147,7 +147,7 @@ int main(int argc, char** argv) { // Only one route here; otherwise iterate from 0 to routing.vehicles() - 1 const int route_number = 0; std::string route; - for (int64 node = routing.Start(route_number); !routing.IsEnd(node); + for (int64_t node = routing.Start(route_number); !routing.IsEnd(node); node = solution->Value(routing.NextVar(node))) { route = StrCat(route, StrCat(node, " -> ")); }