Member ABSL_FLAG (bool, lp_dump_to_proto_file, false, "Tells whether do dump the problem to a protobuf file.")

(user): abstract this in some way to the port directory.

Member ABSL_FLAG (int64_t, min_cost_flow_alpha, 5, "Divide factor for epsilon at each refine step.")

(user): Remove these flags and expose the parameters in the API. New clients, please do not use these flags!

Member ABSL_FLAG (std::string, input, "", "Input file of the problem.")

(user): move this DIMACS parser to its own class, like the ones in routing/. This change would improve searchability of the parser.

Member ABSL_FLAG (int, max_hs_strategy, 0, "MaxHsStrategy: 0 extract only objective variable, 1 extract all variables " "colocated with objective variables, 2 extract all variables in the " "linearization")

(user): Remove this flag when experiments are stable.

Class CycleTimer

(user): implement it.

Member DCHECK_ROW_BOUNDS (row)

(user): Remove this function.

Namespace gtl

(user): Broaden the scope and rename to "stream_util.h"

Member main (int argc, char **argv)

(user): improve code to convert many files.

Class MPSReaderTemplate< DataWrapper >

(b/284163180): The current behavior is that in free format header lines do not start with white space, and data lines must start with at least one white space.

(b/284163180): Fix handling of sections and data in free_form. / Returns true if the line defines a new section. bool IsNewSection() const { return line_[0] != '\0' && line_[0] != ' '; }

Member MPSReaderTemplate< DataWrapper >::MPSReaderTemplate ()

(user): Support 'SI' (semi integer).

Namespace operations_research

(user): refine this toplevel comment when this file settles.

(user): base this code on LinearSumAssignment.

: it could be even faster than that when the values are in [0..N) for a known value N that's significantly lower than the max integer value.

(user): Move all existing routing search code here.

(user): Clean up to match other first solution strategies.

(user) : treat optional intervals

(user) : Call DecisionVisitor and pass name of variable

(user): Determine whether any of these would bring any benefit:

S.C. Eisenstat and J.W.H. Liu, "The theory of elimination trees for sparse unsymmetric matrices," SIAM J. Matrix Anal. Appl., 26:686-705, January 2005
S.C. Eisenstat and J.W.H. Liu. "Algorithmic aspects of elimination trees for sparse unsymmetric matrices," SIAM J. Matrix Anal. Appl., 29:1363-1381, January 2008.
http://perso.ens-lyon.fr/~bucar/papers/kauc.pdf

(user) although it is already possible, using the GroupForwardArcsByFunctor method, to group all the outgoing (resp. incoming) arcs of a node, the iterator logic could still be improved to allow traversing the outgoing (resp. incoming) arcs in O(out_degree(node)) (resp. O(in_degree(node))) instead of O(degree(node)).

(user) it is possible to implement arc deletion and garbage collection in an efficient (relatively) manner. For the time being we haven't seen an application for this.

(user): implement pruning procedures on top of the Held-Karp algorithm.

(user): implement Lawler's modification: https://pubsonline.informs.org/doi/abs/10.1287/mnsc.18.7.401

(user): implement the above active node choice rule.

(user): an alternative would be to evaluate: A.V. Goldberg, "The Partial Augment-Relabel Algorithm for the Maximum Flow Problem.” In Proceedings of Algorithms ESA, LNCS 5193:466-477, Springer 2008. http://www.springerlink.com/index/5535k2j1mt646338.pdf \anchor _todo000698 (user): See whether the following can bring any improvements on real-life problems. R.K. Ahuja, A.V. Goldberg, J.B. Orlin, and R.E. Tarjan, "Finding minimum-cost flows by double scaling," Mathematical Programming, (1992) 53:243-266. http://www.springerlink.com/index/gu7404218u6kt166.pdf \anchor _todo000721 (user): This is a work in progress. The algo is not fully implemented yet. The initial version is closer to Blossom IV since we update the dual values for all trees at once with the same delta. \anchor _todo000748 (user): either implement with SCIP constraint handlers or use a solver independent implementation. \anchor _todo000782 (user): handle timeouts, compute row and column statuses. \anchor _todo000788 (user): post c++ 14, instead use std::pair<MPSolver::OptimizationProblemType, const absl::string_view> once pair gets a constexpr constructor. \anchor _todo000922 (b/180617976): change this behavior. \anchor _todo000952 (b/180024054): add tests for: * threads * heuristics * scaling * lp_algorithm, differentiate between primal and dual simplex. E.g. find a problem with LP relaxation that is both infeasible and dual infeasible, disable presolve, and solve. When using primal simplex, we should get termination reason kInfeasible, but dual simplex should give kInfeasibleOrUnbounded. * (b/272268188): test the interaction between cutoff and primal + dual infeasibility. \anchor _todo000957 (b/180024054): the following parameters are not tested: * time_limit * threads * scaling \anchor _todo000961 (user): These tests are incomplete in a few ways; see mip_tests.cc (user): Expand tests so they check primal, dual and/or primal-dual infeasible cases as appropriate. \anchor _todo002260 (user): for now it is mainly presolve, but the idea is to call these function during the search so they should be as incremental as possible. That is avoid doing work that is not useful because nothing changed or exploring parts that were not done during the last round. \anchor _todo002303 (user): Expand. \anchor _todo002462 (user): make this implementation the default everywhere. (user): investigate the code generated by MSVC. </dd> <dt> \_setscope operations_research::@146 Namespace \_internalref namespaceoperations__research_1_1_0d146 "operations_research::@146" </dt><dd> \anchor _todo000215 (user): improve code when assume_paths is false (currently does an expensive n^2 loop). </dd> <dt> \_setscope operations_research::AdaptiveParameterValue Class \_internalref classoperations__research_1_1AdaptiveParameterValue "operations_research::AdaptiveParameterValue" </dt><dd> \anchor _todo002441 (user): The current logic work well in practice, but has no strong theoretical foundation. We should be able to come up with a better understood formula that converge way faster. It will also be nice to generalize the 0.5 above to a target probability p. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#a93bd93f028c18a4b55b30056ef60df44 "operations_research::AddOverflows" (int64_t x, int64_t y)</dt><dd> \anchor _todo002463 (user): consider making some operations overflow-sticky, some others not, but make an explicit choice throughout. </dd> <dt> \_setscope operations_research::AffineRelation Class \_internalref classoperations__research_1_1AffineRelation "operations_research::AffineRelation" </dt><dd> \anchor _todo002442 (user): it might be possible to do something fancier and drop less relations if all the affine relations are given before hand. </dd> <dt> \_setscope operations_research::AffineRelation Member \_internalref classoperations__research_1_1AffineRelation#a42c79bfbcf36db0e14d942a6079a8564 "operations_research::AffineRelation::TryAdd" (int x, int y, int64_t coeff, int64_t offset, bool allow_rep_x, bool allow_rep_y)</dt><dd> \anchor _todo002443 (user): It should be possible to optimize this code block a bit, for instance depending on the magnitude of new_coeff vs coeff_x, we may already know that one of the two merge is not possible. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#a38cd9519fdea9ef6c87480955852a8c7 "operations_research::ApplyMipPresolveSteps" (const glop::GlopParameters &glop_params, MPModelProto *model, std::vector< std::unique_ptr< glop::Preprocessor > > *for_postsolve, SolverLogger *logger)</dt><dd> \anchor _todo000820 (user): General constraints are currently not supported. \anchor _todo000821 (user): Remove this back and forth conversion. We could convert the LinearProgram directly to a CpModelProto, or we could have a custom implementation of these presolve steps. \anchor _todo000822 (user): transform the hint instead of disabling presolve. \anchor _todo000823 (user): Usually it is good to run the ImpliedFreePreprocessor before this one. However this seems to cause problem on atm20-100.mps. Moreover, for the conversion, it is better to have tight bounds even if the bound propagator is supposed to undo what this presolve would have done. </dd> <dt> \_setscope operations_research::ArcWithLength Struct \_internalref structoperations__research_1_1ArcWithLength "operations_research::ArcWithLength" </dt><dd> \anchor _todo000633 (b/332475231): extend to non-floating lengths. (b/332476147): extend to allow for length functor. </dd> <dt> \_setscope operations_research::Assignment Member \_internalref classoperations__research_1_1Assignment#ad6ab5aff03cb66b05fcbdff43dde169a "operations_research::Assignment::CopyIntersection" (const Assignment *assignment)</dt><dd> \anchor _todo000136 (user): The current behavior is to copy the objective "prefix" which fits the notion of lexicographic objectives well. Reconsider if multiple objectives are used in another context. </dd> <dt> \_setscope operations_research::Assignment Member \_internalref classoperations__research_1_1Assignment#aa4afa275944d2cc69a7a252bafc1e311 "operations_research::Assignment::IntVarContainer" () const</dt><dd> \anchor _todo000165 (user): Add element iterators to avoid exposing container class. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#a270548116df8ad74e03d376c40025566 "operations_research::AutomaticFirstSolutionStrategy" (bool has_pickup_deliveries, bool has_node_precedences, bool has_single_vehicle_node)</dt><dd> \anchor _todo000366 (user): Make this smarter. </dd> <dt> \_setscope operations_research::BaseInactiveNodeToPathOperator Member \_internalref classoperations__research_1_1BaseInactiveNodeToPathOperator#a609668ce9159e0233d2ea4a6c97f9569 "operations_research::BaseInactiveNodeToPathOperator::BaseInactiveNodeToPathOperator" (const std::vector< IntVar * > &vars, const std::vector< IntVar * > &secondary_vars, int number_of_base_nodes, std::function< int(int64_t)> start_empty_path_class, std::function< const std::vector< int > &(int, int)> get_neighbors=nullptr)</dt><dd> \anchor _todo000250 (user): Activate skipping optimal paths. </dd> <dt> \_setscope operations_research::BinCapacities Member \_internalref classoperations__research_1_1BinCapacities#ad0a24566a2366a002297ce9fa809fb4b "operations_research::BinCapacities::CheckAdditionsFeasibility" (const std::vector< int > &items, int bin) const</dt><dd> \anchor _todo000389 (user): try to reorder on failure, so that tight dimensions are checked first. </dd> <dt> \_setscope operations_research::Bitmap Member \_internalref classoperations__research_1_1Bitmap#a10079c77d15fd313c09b89b46756d4e3 "operations_research::Bitmap::Resize" (uint32_t size, bool fill=false)</dt><dd> \anchor _todo000078 (user) : optimize next loop. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#ab7253ffd8b7aba4b7cb5f981c7627526 "operations_research::BitPos64" (uint64_t pos)</dt><dd> \anchor _todo002445 (user): rename BitPos and BitOffset to something more understandable. </dd> <dt> \_setscope operations_research::Bitset64 Member \_internalref classoperations__research_1_1Bitset64#adde7d1500621913ae1f3e71cda4fb502 "operations_research::Bitset64< IndexType >::ClearAndResize" (IndexType size)</dt><dd> \anchor _todo002446 (user): Ideally if a realloc happens, we don't need to copy the old data... </dd> <dt> \_setscope operations_research::BlossomGraph Class \_internalref classoperations__research_1_1BlossomGraph "operations_research::BlossomGraph" </dt><dd> \anchor _todo000722 (user): For now this class does not maintain a second graph of edges between the trees nor does it maintains priority queue of edges. \anchor _todo000723 (user): For now we use CHECKs in many places to facilitate development. Switch them to DCHECKs for speed once the code is more stable. </dd> <dt> \_setscope operations_research::BlossomGraph Member \_internalref classoperations__research_1_1BlossomGraph#a1cc997de6330ea47db84ebfbc97c3855 "operations_research::BlossomGraph::Augment" (EdgeIndex e)</dt><dd> \anchor _todo000715 (user): Check all dual/slack same after primal op? \anchor _todo000716 (user): It seems that we may waste some computation since the part of the tree not in the path between roots can lead to the same Grow() operations later when one of its node is ratched to a new root. \anchor _todo000717 (user): Reduce this O(num_nodes) complexity. We might be able to even do O(num_node_in_path) with lazy updates. Note that this operation will only be performed at most num_initial_unmatched_nodes / 2 times though. \anchor _todo000718 (user): This could probably be optimized if needed. But we do usually iterate a lot more over it than we update it. Note that as long as we use the same delta for all trees, this is not even needed. </dd> <dt> \_setscope operations_research::BlossomGraph Member \_internalref classoperations__research_1_1BlossomGraph#a2efd43d890e6d53cbab9f160b5ecd745 "operations_research::BlossomGraph::ComputeMaxCommonTreeDualDeltaAndResetPrimalEdgeQueue" ()</dt><dd> \anchor _todo000712 (user): Avoid this linear loop. </dd> <dt> \_setscope operations_research::BlossomGraph::Edge Member \_internalref structoperations__research_1_1BlossomGraph_1_1Edge#a152f6be1dfb3d3057d875f9371da5a29 "operations_research::BlossomGraph::Edge::tail" </dt><dd> \anchor _todo000729 (user): Consider using node_a/node_b instead to remove the "directed" meaning. I do need to think a bit more about it though. </dd> <dt> \_setscope operations_research::BlossomGraph Member \_internalref classoperations__research_1_1BlossomGraph#a23c2ea31a1b81f23e929abdc839f9153 "operations_research::BlossomGraph::ExpandAllBlossoms" ()</dt><dd> \anchor _todo000720 (user): remove duplication with expand? </dd> <dt> \_setscope operations_research::BlossomGraph Member \_internalref classoperations__research_1_1BlossomGraph#aea1e702f3161c4bd45d69ac7ef50d562 "operations_research::BlossomGraph::Initialize" ()</dt><dd> \anchor _todo000707 (user): Code the more advanced "Fractional matching initialization" heuristic. \anchor _todo000708 (user): Add a preprocessing step that performs the 'forced' matches? \anchor _todo000709 (user): We might be able to do better for odd min_cost, but then we might need to scale by 4? think about it. \anchor _todo000710 (user): Optimize by merging this loop with the one above? \anchor _todo000711 (user): Reduce the number of loops we do in the initialization. We could likely just scale the edge cost as we fill them. </dd> <dt> \_setscope operations_research::BlossomGraph Member \_internalref classoperations__research_1_1BlossomGraph#a4e57765af9aa45f409d540937922cb15 "operations_research::BlossomGraph::PrimalUpdates" ()</dt><dd> \anchor _todo000713 (user): avoid adding duplicates? \anchor _todo000714 (user): Avoid doing a O(num_nodes). Also expand all blossom recursively? I am not sure it is a good heuristic to expand all possible blossom before trying the other operations though. </dd> <dt> \_setscope operations_research::BlossomGraph Member \_internalref classoperations__research_1_1BlossomGraph#af8800c5729866189248b48ea006f2787 "operations_research::BlossomGraph::Shrink" (EdgeIndex e)</dt><dd> \anchor _todo000719 (user): It would be nicer to not to have to read the memory of the other node at all. It might be possible once we store the parent edge instead of the parent node since then we will only need to know if this edges point to a new-internal node or not. </dd> <dt> \_setscope operations_research::bop::AssignmentAndConstraintFeasibilityMaintainer Member \_internalref classoperations__research_1_1bop_1_1AssignmentAndConstraintFeasibilityMaintainer#a74b09c69f37b7aee6c511622f13ff935 "operations_research::bop::AssignmentAndConstraintFeasibilityMaintainer::DebugString" () const</dt><dd> \anchor _todo000106 (user): show the backtrack levels. </dd> <dt> \_setscope operations_research::bop::AssignmentAndConstraintFeasibilityMaintainer Member \_internalref classoperations__research_1_1bop_1_1AssignmentAndConstraintFeasibilityMaintainer#ab9b52ed71802a8f4ae56d61b3e6f42ea "operations_research::bop::AssignmentAndConstraintFeasibilityMaintainer::PotentialOneFlipRepairs" ()</dt><dd> \anchor _todo000105 (user): If this starts to show-up in a performance profile, we can easily maintain this hash incrementally. </dd> <dt> \_setscope operations_research::bop::BopOptimizerBase Member \_internalref classoperations__research_1_1bop_1_1BopOptimizerBase#a881ed93d8f98879bbbfddf21807fff63ab5cd6094ad1ef99cfb1c8e77da1f59b1 "operations_research::bop::BopOptimizerBase::INFORMATION_FOUND" </dt><dd> \anchor _todo000085 (user): replace by learned_info->IsEmpty()? but we will need to clear the BopSolution there first. </dd> <dt> \_setscope operations_research::bop::BopOptimizerBase Member \_internalref classoperations__research_1_1bop_1_1BopOptimizerBase#a881ed93d8f98879bbbfddf21807fff63 "operations_research::bop::BopOptimizerBase::Status" </dt><dd> \anchor _todo000084 (user): To redesign, some are not needed anymore thanks to the problem state, e.g. IsOptimal(). </dd> <dt> \_setscope operations_research::bop::BopRandomFirstSolutionGenerator Class \_internalref classoperations__research_1_1bop_1_1BopRandomFirstSolutionGenerator "operations_research::bop::BopRandomFirstSolutionGenerator" </dt><dd> \anchor _todo000092 (user): Coupled with some Local Search it might be used to diversify the solutions. To try. </dd> <dt> \_setscope operations_research::bop Member \_internalref namespaceoperations__research_1_1bop#aa5e7fc23cf65709ac2894d88db807c57 "operations_research::bop::DEFINE_STRONG_INDEX_TYPE" (SparseIndex)</dt><dd> \anchor _todo000121 (user): Remove. </dd> <dt> \_setscope operations_research::bop::IntegralSolver Member \_internalref classoperations__research_1_1bop_1_1IntegralSolver#ade95d98b233882c2b9004ec144ded32e "operations_research::bop::IntegralSolver::Solve" (const glop::LinearProgram &linear_problem, const glop::DenseRow &user_provided_initial_solution)</dt><dd> \anchor _todo000133 (user): Change the API to accept a partial solution instead since the underlying solver supports it. </dd> <dt> \_setscope operations_research::bop::LinearRelaxation Member \_internalref classoperations__research_1_1bop_1_1LinearRelaxation#ae7b5dc2f2554218d68e6013b9a3c10d8 "operations_research::bop::LinearRelaxation::ShouldBeRun" (const ProblemState &problem_state) const override</dt><dd> \anchor _todo000088 (user): also deal with problem_already_solved_ </dd> <dt> \_setscope operations_research::bop::LocalSearchAssignmentIterator Member \_internalref classoperations__research_1_1bop_1_1LocalSearchAssignmentIterator#a8b33fbbde1b28b4f19eac558f3bcc968 "operations_research::bop::LocalSearchAssignmentIterator::deterministic_time" () const</dt><dd> \anchor _todo000108 (user): The 1.2 multiplier is an approximation only based on the time spent in the SAT wrapper. So far experiments show a good correlation with real time, but we might want to be more accurate. </dd> <dt> \_setscope operations_research::bop::LocalSearchAssignmentIterator Member \_internalref classoperations__research_1_1bop_1_1LocalSearchAssignmentIterator#abba388e3e639729c28998d52ecea6a19 "operations_research::bop::LocalSearchAssignmentIterator::NextAssignment" ()</dt><dd> \anchor _todo000107 (user): Perform more experiments with this. </dd> <dt> \_setscope operations_research::bop::OneFlipConstraintRepairer Member \_internalref classoperations__research_1_1bop_1_1OneFlipConstraintRepairer#a07e60997ff23293fa7f3b9d21765fb32 "operations_research::bop::OneFlipConstraintRepairer::OneFlipConstraintRepairer" (const sat::LinearBooleanProblem &problem, const AssignmentAndConstraintFeasibilityMaintainer &maintainer, const sat::VariablesAssignment &sat_assignment)</dt><dd> \anchor _todo000112 (user): maybe merge the two classes? maintaining this implicit indices convention between the two classes sounds like a bad idea. </dd> <dt> \_setscope operations_research::bop::OptimizerSelector Member \_internalref classoperations__research_1_1bop_1_1OptimizerSelector#a39afee83d9f173f951fd8bef5668d1cc "operations_research::bop::OptimizerSelector::SelectOptimizer" ()</dt><dd> \anchor _todo000119 (user): Remove this recursive call, even if in practice it's safe because the max depth is the number of optimizers. </dd> <dt> \_setscope operations_research::bop::OptimizerSelector Member \_internalref classoperations__research_1_1bop_1_1OptimizerSelector#a90899a835ba61dd5404514594bac26d1 "operations_research::bop::OptimizerSelector::SetOptimizerRunnability" (OptimizerIndex optimizer_index, bool runnable)</dt><dd> \anchor _todo000120 (user): Maybe we should simply have the notion of selectability here and let the client handle the logic to decide what optimizer are selectable or not. </dd> <dt> \_setscope operations_research::bop::PortfolioOptimizer Member \_internalref classoperations__research_1_1bop_1_1PortfolioOptimizer#a80a6069365c385e427e6e5a1c08d1757 "operations_research::bop::PortfolioOptimizer::Optimize" (const BopParameters &parameters, const ProblemState &problem_state, LearnedInfo *learned_info, TimeLimit *time_limit) override</dt><dd> \anchor _todo000115 (user): Is 1 the right value? It might be better to use a percentage of the gap, or use the same gain as for the second solution. \anchor _todo000116 (user): don't penalize the SatCoreBasedOptimizer or the LinearRelaxation when they improve the lower bound. \anchor _todo000117 \anchor _todo000118 (user): Do we want to re-order the optimizers in the selector when the status is BopOptimizerBase::INFORMATION_FOUND? </dd> <dt> \_setscope operations_research::bop::ProblemState Member \_internalref classoperations__research_1_1bop_1_1ProblemState#a559199c417440cd27d38fc73ce4eb3f0 "operations_research::bop::ProblemState::GetLearnedInfo" () const</dt><dd> \anchor _todo000086 (user): In the current implementation the learned information only contains binary clauses added since the last call to SynchronizationDone(). Add an iterator on the sat::BinaryClauseManager. </dd> <dt> \_setscope operations_research::bop::ProblemState Member \_internalref classoperations__research_1_1bop_1_1ProblemState#a66e1a0e14cfd6b3310237e4243df1295 "operations_research::bop::ProblemState::MergeLearnedInfo" (const LearnedInfo &learned_info, BopOptimizerBase::Status optimization_status)</dt><dd> \anchor _todo000083 (user): refactor this to not rely on the optimization status. All the information can be encoded in the learned_info bounds. </dd> <dt> \_setscope operations_research::bop::RelationGraphBasedNeighborhood Member \_internalref classoperations__research_1_1bop_1_1RelationGraphBasedNeighborhood#a325429e8a64a26196122aa1b0e430cdb "operations_research::bop::RelationGraphBasedNeighborhood::RelationGraphBasedNeighborhood" (const sat::LinearBooleanProblem &problem, absl::BitGenRef random)</dt><dd> \anchor _todo000097 (user): Factor this out with the similar factor in ConstraintBasedNeighborhood? also maybe a better approach is to order the constraint, and stop the neighborhood extension without considering all of them. </dd> <dt> \_setscope operations_research::bop::SatCoreBasedOptimizer Class \_internalref classoperations__research_1_1bop_1_1SatCoreBasedOptimizer "operations_research::bop::SatCoreBasedOptimizer" </dt><dd> \anchor _todo000123 (user): Merge this with the code in sat/optimization.cc </dd> <dt> \_setscope operations_research::bop::SatCoreBasedOptimizer Member \_internalref classoperations__research_1_1bop_1_1SatCoreBasedOptimizer#aa4bc0effba94384800ed5500479d4e6a "operations_research::bop::SatCoreBasedOptimizer::Optimize" (const BopParameters &parameters, const ProblemState &problem_state, LearnedInfo *learned_info, TimeLimit *time_limit) override</dt><dd> \anchor _todo000122 (user): Check that this cannot fail because of the conflict limit. </dd> <dt> \_setscope operations_research::bop::SatWrapper Class \_internalref classoperations__research_1_1bop_1_1SatWrapper "operations_research::bop::SatWrapper" </dt><dd> \anchor _todo000111 (user): remove? the meat of the logic is used in just one place, so I am not sure having this extra layer improve the readability. </dd> <dt> \_setscope operations_research::BopInterface Member \_internalref classoperations__research_1_1BopInterface#ada6578145939501210ef6b92ca38158d "operations_research::BopInterface::ExtractNewConstraints" () override</dt><dd> \anchor _todo000754 (user): remove duplication with GlopInterface. </dd> <dt> \_setscope operations_research::BopInterface Member \_internalref classoperations__research_1_1BopInterface#a7aaa64ff52a59fb3e02dde9e52897ace "operations_research::BopInterface::ExtractNewVariables" () override</dt><dd> \anchor _todo000753 (user): remove duplication with GlopInterface. </dd> <dt> \_setscope operations_research::BopInterface Member \_internalref classoperations__research_1_1BopInterface#a9bd4d93025988cd4a244584d930b8ff8 "operations_research::BopInterface::ExtractObjective" () override</dt><dd> \anchor _todo000755 (user): remove duplication with GlopInterface. </dd> <dt> \_setscope operations_research::BopInterface Member \_internalref classoperations__research_1_1BopInterface#ac52f933217a15933ccc9d816712e85f7 "operations_research::BopInterface::SetPresolveMode" (int value) override</dt><dd> \anchor _todo000756 (user): add this to BopParameters. \anchor _todo000757 (user): add this to BopParameters. </dd> <dt> \_setscope operations_research::BopInterface Member \_internalref classoperations__research_1_1BopInterface#afd586dcfbf76c853a9331113cea5ad2f "operations_research::BopInterface::Solve" (const MPSolverParameters &param) override</dt><dd> \anchor _todo000750 (user): Implement the column status. \anchor _todo000751 (user): Implement the row status. </dd> <dt> \_setscope operations_research::BopInterface Member \_internalref classoperations__research_1_1BopInterface#a8055a5ae37344bb12601db78c75336ca "operations_research::BopInterface::SolverVersion" () const override</dt><dd> \anchor _todo000752 (user): Decide how to version bop. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#aacf1f78a82fb54975d703e8f079cafa2 "operations_research::BuildKruskalMinimumSpanningTreeFromSortedArcs" (const Graph &graph, absl::Span< const typename Graph::ArcIndex > sorted_arcs)</dt><dd> \anchor _todo000702 (user): Add a global Minimum Spanning Tree API automatically switching between Prim and Kruskal depending on problem size. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#adfcad7c607afe2de123ac91fcd2b87c0 "operations_research::CapProdGeneric" (int64_t x, int64_t y)</dt><dd> \anchor _todo002464 (user): avoid this by writing function Log2(a) with Log2(0) == -1. </dd> <dt> \_setscope operations_research::CBCInterface Member \_internalref classoperations__research_1_1CBCInterface#af820a38fd9b79c6bccdf806ff44df433 "operations_research::CBCInterface::ExtractModel" ()</dt><dd> \anchor _todo000759 (user): separate the solve from the model extraction. </dd> <dt> \_setscope operations_research::CBCInterface Member \_internalref classoperations__research_1_1CBCInterface#abe31f5b2faa04f2e7d0a82b2f7c56eba "operations_research::CBCInterface::SetVariableInteger" (int var_index, bool integer) override</dt><dd> \anchor _todo000758 (user) : Check if this is actually a change. </dd> <dt> \_setscope operations_research::CBCInterface Member \_internalref classoperations__research_1_1CBCInterface#aff8df81038ade1c6d8ff118dbcf92ff2 "operations_research::CBCInterface::underlying_solver" () override</dt><dd> \anchor _todo000760 (user): Maybe we should expose the CbcModel build from osi_ instead, but a new CbcModel is built every time Solve is called, so it is not possible right now. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#a6a5db12c8eb55529c5717db21d40f856 "operations_research::CeilRatio" (int64_t value, int64_t positive_coeff)</dt><dd> \anchor _todo002465 (user): Use MathUtil::CeilOfRatio / FloorOfRatio instead. </dd> <dt> \_setscope operations_research::CheapestInsertionFilteredHeuristic Member \_internalref classoperations__research_1_1CheapestInsertionFilteredHeuristic#aabcdb4b93d8aed00bc35f8f04a3c5f0a "operations_research::CheapestInsertionFilteredHeuristic::ComputeStartEndDistanceForVehicles" (const std::vector< int > &vehicles)</dt><dd> \anchor _todo000368 (user): consider checking search limits. </dd> <dt> \_setscope operations_research::CheapestInsertionFilteredHeuristic Member \_internalref classoperations__research_1_1CheapestInsertionFilteredHeuristic#a1a109ae320b663d295dfdfc68f608810 "operations_research::CheapestInsertionFilteredHeuristic::GetInsertionCostForNodeAtPosition" (int64_t node_to_insert, int64_t insert_after, int64_t insert_before, int vehicle) const</dt><dd> \anchor _todo000385 (user): Replace 'insert_before' and 'insert_after' by 'predecessor' and 'successor' in the code. </dd> <dt> \_setscope operations_research::ChristofidesFilteredHeuristic Member \_internalref classoperations__research_1_1ChristofidesFilteredHeuristic#a30f60a5304f5bd801ece16fb0868b0fb "operations_research::ChristofidesFilteredHeuristic::BuildSolutionInternal" () override</dt><dd> \anchor _todo000376 (user): Support pickup & delivery. \anchor _todo000377 (user): Add robustness to fixed arcs by collapsing them into meta- nodes. \anchor _todo000378 (user): Investigate if ChristofidesPathSolver should not return a status to bail out fast in case of problem. \anchor _todo000379 (user): Investigate if sorting paths per cost improves solutions. </dd> <dt> \_setscope operations_research::ChristofidesPathSolver Member \_internalref classoperations__research_1_1ChristofidesPathSolver#a76c636e1d48da64087686dd06bc45519 "operations_research::ChristofidesPathSolver< CostType, ArcIndex, NodeIndex, CostFunction >::SetMatchingAlgorithm" (MatchingAlgorithm matching)</dt><dd> \anchor _todo000631 (user): Change the default when minimum matching gets faster. </dd> <dt> \_setscope operations_research::ChristofidesPathSolver Member \_internalref classoperations__research_1_1ChristofidesPathSolver#a0fd40e5b4dd3c4d2eec044aafc9cdc7a "operations_research::ChristofidesPathSolver< CostType, ArcIndex, NodeIndex, CostFunction >::Solve" ()</dt><dd> \anchor _todo000629 (user): Make this code available as an independent algorithm. \anchor _todo000630 (user): Cost caching was added and can gain up to 20% but increases memory usage; see if we can avoid caching. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#a784189c728d17f91325cd8dfd86f324e "operations_research::ClearMostCoveredElements" (absl::Span< const SubsetIndex > focus, std::size_t num_subsets, SetCoverInvariant *inv)</dt><dd> \anchor _todo000043 (user):find another algorithm if necessary. \anchor _todo000044 (user): find another algorithm if necessary. </dd> <dt> \_setscope operations_research::CLPInterface Member \_internalref classoperations__research_1_1CLPInterface#adbecc3c53101ed075d7078a7ea8f3e19 "operations_research::CLPInterface::ExtractNewVariables" () override</dt><dd> \anchor _todo000762 (user): This could perhaps be made slightly faster by iterating through old constraints, constructing by hand the column-major representation of the addition to them and call clp_->addColumns. But this is good enough for now. Create new variables. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#a53bf12f941f978cc1b1b985816c1fbdf "operations_research::ComputeMinimumWeightMatchingWithMIP" (const GraphType &graph, const WeightFunctionType &weight)</dt><dd> \anchor _todo000628 (user): Handle infeasible cases if this algorithm is used outside of Christofides. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#a25f46b686d6f253f53dc77ac9f52b4b6 "operations_research::ConvertFlowModelToDimacs" (const FlowModelProto &flow_model, std::string *dimacs)</dt><dd> \anchor _todo000735 (user): This currently only works for min cost flow problem. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#ad3af7b57bcf2344c6378fbec1b59b96e "operations_research::ConvertStatusOrMPSolutionResponse" (bool log_error, absl::StatusOr< MPSolutionResponse > response)</dt><dd> \anchor _todo000815 (user): All SolveWithProto() should just fill the appropriate response instead. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#acb9df89a57d7e6c160136db67b224b88 "operations_research::ConvexMinimum" (absl::Span< const Point > sorted_points, std::function< Value(Point)> f)</dt><dd> \anchor _todo000001 (user): Some relevant optimizations: - Abort early if we know a lower bound on the min. - Seed with a starting point if we know one. - We technically do not need the points to be sorted and can use linear-time median computation to speed this up. \anchor _todo000002 (user): replace std::function by absl::FunctionRef here and in BinarySearch(). </dd> <dt> \_setscope operations_research::CplexInterface Member \_internalref classoperations__research_1_1CplexInterface#a6dfd72260599acdb0d30d0eb612a9b2c "operations_research::CplexInterface::ExtractNewVariables" ()</dt><dd> \anchor _todo000764 : Use a bitarray to flag the constraints that actually intersect new variables? </dd> <dt> \_setscope operations_research::CplexInterface Member \_internalref classoperations__research_1_1CplexInterface#ade9838d567be0055711f0d0246878123 "operations_research::CplexInterface::SetScalingMode" (int value)</dt><dd> \anchor _todo000765 : 0 is equilibrium scaling (the default), CPLEX also supports </dd> <dt> \_setscope operations_research::CplexInterface Member \_internalref classoperations__research_1_1CplexInterface#a6f29640b71cf1b2be18d08c4888d654f "operations_research::CplexInterface::SetVariableInteger" (int var_index, bool integer)</dt><dd> \anchor _todo000763 : Should we check the current type and don't do anything in case the type does not change? </dd> <dt> \_setscope operations_research::Cross Member \_internalref classoperations__research_1_1Cross#aebc322e8525f142b40271ce61f2db26f "operations_research::Cross::MakeNeighbor" () override</dt><dd> \anchor _todo000231 (user): When neighbors are considered, explore if having two versions of Cross makes sense, one exchanging path starts, the other path ends. Rationale: neighborhoods might not be symmetric. In practice, in particular when used through RoutingModel, neighborhoods are actually symmetric. </dd> <dt> \_setscope operations_research::CVRPToursParser Member \_internalref classoperations__research_1_1CVRPToursParser#aa36bf9878697f417c237563de888fe97 "operations_research::CVRPToursParser::LoadFile" (const std::string &file_name)</dt><dd> \anchor _todo001070 (user): Return false when issues were encountered while parsing the file. </dd> <dt> \_setscope operations_research::DemonProfiler Member \_internalref classoperations__research_1_1DemonProfiler#a7b7c6355eb1daf5a3db8f0d575947ed2 "operations_research::DemonProfiler::CurrentTime" () const</dt><dd> \anchor _todo000178 (user): rename and return nanoseconds. </dd> <dt> \_setscope operations_research::DimensionChecker Member \_internalref classoperations__research_1_1DimensionChecker#a0f3d75f9157801c9a32ab3e5d9bdc23e "operations_research::DimensionChecker::DimensionChecker" (const PathState *path_state, std::vector< Interval > path_capacity, std::vector< int > path_class, std::vector< std::function< Interval(int64_t, int64_t)> > demand_per_path_class, std::vector< Interval > node_capacity, int min_range_size_for_riq=kOptimalMinRangeSizeForRIQ)</dt><dd> \anchor _todo000174 (user): the addition of kMinRangeSizeForRIQ slowed down Check(). See if using a template parameter makes it faster. </dd> <dt> \_setscope operations_research::DimensionCumulOptimizerCore Member \_internalref classoperations__research_1_1DimensionCumulOptimizerCore#a124f8416552eec51fea7c3f0f47d722b "operations_research::DimensionCumulOptimizerCore::Optimize" (const std::function< int64_t(int64_t)> &next_accessor, const std::vector< RouteDimensionTravelInfo > &dimension_travel_info_per_route, RoutingLinearSolverWrapper *solver, std::vector< int64_t > *cumul_values, std::vector< int64_t > *break_values, std::vector< std::vector< int > > *resource_indices_per_group, int64_t *cost_without_transits, int64_t *transit_cost, bool clear_lp=true, bool optimize_resource_assignment=true)</dt><dd> \anchor _todo000341 (user): In case the status is RELAXED_OPTIMAL_ONLY, check we can safely avoid filling variable and cost values. </dd> <dt> \_setscope operations_research::DimensionCumulOptimizerCore Member \_internalref classoperations__research_1_1DimensionCumulOptimizerCore#a5a239314a69e35f6411905cd4bebb6d8 "operations_research::DimensionCumulOptimizerCore::OptimizeAndPack" (const std::function< int64_t(int64_t)> &next_accessor, const std::vector< RouteDimensionTravelInfo > &dimension_travel_info_per_route, RoutingLinearSolverWrapper *solver, std::vector< int64_t > *cumul_values, std::vector< int64_t > *break_values)</dt><dd> \anchor _todo000342 (user): In case the status is RELAXED_OPTIMAL_ONLY, check we can safely avoid filling variable values. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#ad0b44ed99c3501d7a797dfa6ac52714f "operations_research::DisplayPlan" (const operations_research::RoutingIndexManager &manager, const operations_research::RoutingModel &routing, const operations_research::Assignment &plan, bool use_same_vehicle_costs, int64_t max_nodes_per_group, int64_t same_vehicle_cost, const operations_research::RoutingDimension &capacity_dimension, const operations_research::RoutingDimension &time_dimension)</dt><dd> \anchor _todo001065 (user): Move the display code to the routing library. </dd> <dt> \_setscope operations_research::DistributionStat Member \_internalref classoperations__research_1_1DistributionStat#a68349bcba1db1a5a68ebd1d855bdd078 "operations_research::DistributionStat::StdDeviation" () const</dt><dd> \anchor _todo002475 (user): We could also use on top the Kahan summation algorithm to be even more precise but a bit slower too. </dd> <dt> \_setscope operations_research::Domain Member \_internalref classoperations__research_1_1Domain#a714a1473bb78dab3195bd5cd5e90af42 "operations_research::Domain::AdditionWith" (const Domain &domain) const</dt><dd> \anchor _todo002468 (user): Use a better algorithm. </dd> <dt> \_setscope operations_research::Domain Member \_internalref classoperations__research_1_1Domain#afea26857db7d2e50a267c9d9d5ceb661 "operations_research::Domain::ClosestValue" (int64_t wanted) const</dt><dd> \anchor _todo002466 (user): Use std::upper_bound() like in ValueAtOrBefore() ? </dd> <dt> \_setscope operations_research::Domain Member \_internalref classoperations__research_1_1Domain#a8de91c6ec98c4eaa9ec6c7e1f5e26d71 "operations_research::Domain::Distance" (int64_t value) const</dt><dd> \anchor _todo002467 (user): Deal with overflow. </dd> <dt> \_setscope operations_research::DynamicPartition Class \_internalref classoperations__research_1_1DynamicPartition "operations_research::DynamicPartition" </dt><dd> \anchor _todo000007 (user): rename this to BacktrackableSplittingPartition. </dd> <dt> \_setscope operations_research::DynamicPartition Member \_internalref classoperations__research_1_1DynamicPartition#ae0789ce355b93a5161e63666b4467e67 "operations_research::DynamicPartition::DynamicPartition" (const std::vector< int > &initial_part_of_element)</dt><dd> \anchor _todo000003 (user): either remove this or factor it out if it can be used elsewhere. </dd> <dt> \_setscope operations_research::DynamicPartition Member \_internalref classoperations__research_1_1DynamicPartition#ab82a2915429e5c6626c9187ed85e7064 "operations_research::DynamicPartition::Refine" (absl::Span< const int > distinguished_subset)</dt><dd> \anchor _todo000004 (user): optimize the common singleton case. \anchor _todo000005 (user): automatically switch to an O(N) sort when it's faster than this one, which is O(K log K) with K = tmp_affected_parts_.size(). \anchor _todo000008 (user): the graph symmetry finder could probably benefit a lot from keeping track of one additional bit of information for each part that remains unchanged by a Refine() operation: was that part entirely in the distinguished subset or entirely out? </dd> <dt> \_setscope operations_research::DynamicPermutation Member \_internalref classoperations__research_1_1DynamicPermutation#a529b7a5b760666c049da283212991a5b "operations_research::DynamicPermutation::LooseEnds" () const</dt><dd> \anchor _todo000009 (user): use a faster underlying container like SparseBitSet, and tweak this API accordingly. </dd> <dt> \_setscope operations_research::EbertGraphBase Member \_internalref classoperations__research_1_1EbertGraphBase#a7adcbbf1af098a96abf7a3397246304d "operations_research::EbertGraphBase< NodeIndexType, ArcIndexType, DerivedGraph >::GroupForwardArcsByFunctor" (const ArcIndexTypeStrictWeakOrderingFunctor &compare, PermutationCycleHandler< ArcIndexType > *annotation_handler)</dt><dd> \anchor _todo000639 (user): Configure SWIG to handle the GroupForwardArcsByFunctor member template and the CycleHandlerForAnnotatedArcs class. </dd> <dt> \_setscope operations_research::ElementDegreeSolutionGenerator Member \_internalref classoperations__research_1_1ElementDegreeSolutionGenerator#abbe235864c43f519c5ac9c0de3d870f4 "operations_research::ElementDegreeSolutionGenerator::NextSolution" ()</dt><dd> \anchor _todo000051 (user): Add time-outs and exit with a partial solution. </dd> <dt> \_setscope operations_research::ElementIterator Class \_internalref classoperations__research_1_1ElementIterator "operations_research::ElementIterator< Set >" </dt><dd> \anchor _todo000653 (user): Move the Set-related classbelow to util/bitset.h Iterates over the elements of a set represented as an unsigned integer, starting from the smallest element. (See the class Set<Integer> below.) </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#ab0da8bffc5e8eafc798d8b3b1750f05b "operations_research::FillPathEvaluation" (const std::vector< int64_t > &path, const RoutingModel::TransitCallback2 &evaluator, std::vector< int64_t > *values)</dt><dd> \anchor _todo000297 (user): Apply -pointer-following. </dd> <dt> \_setscope operations_research::FilteredHeuristicLocalSearchOperator Class \_internalref classoperations__research_1_1FilteredHeuristicLocalSearchOperator "operations_research::FilteredHeuristicLocalSearchOperator" </dt><dd> \anchor _todo000338 (user): Put these methods in an object with helper methods instead of adding a layer to the class hierarchy. </dd> <dt> \_setscope operations_research::FilteredHeuristicLocalSearchOperator Member \_internalref classoperations__research_1_1FilteredHeuristicLocalSearchOperator#a27a42fcdb24320190aa6760ab0aa2c7a "operations_research::FilteredHeuristicLocalSearchOperator::model_" </dt><dd> \anchor _todo000339 (user): Remove the dependency from RoutingModel by storing an IntVarFilteredHeuristic here instead and storing information on path start/ends like PathOperator does (instead of relying on the model). </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#ae4ee4d82cf625670cdc1f52197454654 "operations_research::FindFeasibilityErrorInSolutionHint" (const MPModelProto &model, double tolerance)</dt><dd> \anchor _todo000802 (user): Add a general FindFeasibilityErrorInSolution() and factor out the common code. </dd> <dt> \_setscope operations_research::FindOneNeighbor Member \_internalref classoperations__research_1_1FindOneNeighbor#ae778e45052fc69775bc50b2d12294a4c "operations_research::FindOneNeighbor::FindOneNeighbor" (Assignment *assignment, IntVar *objective, SolutionPool *pool, LocalSearchOperator *ls_operator, DecisionBuilder *sub_decision_builder, const RegularLimit *limit, LocalSearchFilterManager *filter_manager)</dt><dd> \anchor _todo000241 (user): Support skipping neighborhood checks for limits accepting more than one solution (e.g. best accept). For now re-enabling systematic checks. \anchor _todo000242 (user): Support skipping neighborhood checks with LNS (at least on the non-LNS operators). </dd> <dt> \_setscope operations_research::FindOneNeighbor Member \_internalref classoperations__research_1_1FindOneNeighbor#a25667f46f98b5158a6d89bcf93a07b46 "operations_research::FindOneNeighbor::Next" (Solver *solver) override</dt><dd> \anchor _todo000243 (user) : SyncNeed(assignment_) ? \anchor _todo000244 (user): Don't call both if no filter is incremental and one of them returned false. \anchor _todo000245 (user): support the case were limit_ accepts more than one solution (e.g. best accept). \anchor _todo000246 (user): Restore state of local search operators to make sure we are exploring neighbors in the same order. This can affect the local optimum found. \anchor _todo000247 (user): Compare assignments in addition to their cost. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#a108e0d0f765ed56abc079b49c521915b "operations_research::FormatStatistic" (absl::string_view name, T value, RoutingOutputFormat format)</dt><dd> \anchor _todo001068 (user): think about using an enum instead of names (or even a full-fledged struct/class) for the various types of fields. </dd> <dt> \_setscope operations_research::ForwardStaticGraph::CycleHandlerForAnnotatedArcs Class \_internalref classoperations__research_1_1ForwardStaticGraph_1_1CycleHandlerForAnnotatedArcs "operations_research::ForwardStaticGraph< NodeIndexType, ArcIndexType >::CycleHandlerForAnnotatedArcs" </dt><dd> \anchor _todo000637 (user): Configure SWIG to handle the CycleHandlerForAnnotatedArcs class. </dd> <dt> \_setscope operations_research::ForwardStaticGraph Member \_internalref classoperations__research_1_1ForwardStaticGraph#a299d30373ebbfcb70fc84ecc66d95b92 "operations_research::ForwardStaticGraph< NodeIndexType, ArcIndexType >::ForwardStaticGraph" (const NodeIndexType num_nodes, const ArcIndexType num_arcs, const bool sort_arcs_by_head, std::vector< std::pair< NodeIndexType, NodeIndexType > > *client_input_arcs, operations_research::PermutationCycleHandler< ArcIndexType > *const client_cycle_handler)</dt><dd> \anchor _todo000638 (user): For some reason, SWIG breaks if the operations_research namespace is not explicit in the following argument declaration. </dd> <dt> \_setscope operations_research::fz::Constraint Member \_internalref structoperations__research_1_1fz_1_1Constraint#a4d53b3107ef0dbfb3e99a52a2f4c0d42 "operations_research::fz::Constraint::MarkAsInactive" ()</dt><dd> \anchor _todo000422 (user): Reclaim arguments and memory. </dd> <dt> \_setscope operations_research::fz::Domain Struct \_internalref structoperations__research_1_1fz_1_1Domain "operations_research::fz::Domain" </dt><dd> \anchor _todo000424 (user): Rework domains, all int64_t should be kintmin..kint64max. It is a bit tricky though as we must take care of overflows. If is_a_set is true, then this domain has a set semantics. For a set variable, any subset of the initial set of values is a valid assignment, instead of exactly one value. </dd> <dt> \_setscope operations_research::fz::Domain Member \_internalref structoperations__research_1_1fz_1_1Domain#ac4d428774d29f823cc82a1e9094f1926 "operations_research::fz::Domain::HasOneValue" () const</dt><dd> \anchor _todo000426 (user): Do we need SetOfFloats() ? </dd> <dt> \_setscope operations_research::fz::Domain Member \_internalref structoperations__research_1_1fz_1_1Domain#ae0c523fec5cdb2c506835d037c78557c "operations_research::fz::Domain::IntersectWithListOfIntegers" (absl::Span< const int64_t > integers)</dt><dd> \anchor _todo000420 (user): Investigate faster code for small arrays. </dd> <dt> \_setscope operations_research::fz::Domain Member \_internalref structoperations__research_1_1fz_1_1Domain#ae4c771e4304fd0443a538c84d3c62870 "operations_research::fz::Domain::OverlapsIntList" (const std::vector< int64_t > &vec) const</dt><dd> \anchor _todo000421 (user): Better algorithm, sort and compare increasingly. </dd> <dt> \_setscope operations_research::fz::LexerInfo Struct \_internalref structoperations__research_1_1fz_1_1LexerInfo "operations_research::fz::LexerInfo" </dt><dd> \anchor _todo000434 (user): Use std::unique_ptr<vector< >> to ease memory management. </dd> <dt> \_setscope operations_research::fz Member \_internalref namespaceoperations__research_1_1fz#a0d0d1d18eea7879af81671f8395b8b1d "operations_research::fz::Lookup" (const std::vector< T > &v, int index)</dt><dd> \anchor _todo000433 (user): replace this by a macro for better logging. </dd> <dt> \_setscope operations_research::fz::Model Member \_internalref classoperations__research_1_1fz_1_1Model#affdfad9a0c88744ef4cfe7c80adc4fb1 "operations_research::fz::Model::AddConstant" (int64_t value)</dt><dd> \anchor _todo000423 (user): Create only once constant per value. </dd> <dt> \_setscope operations_research::fz::ModelStatistics Class \_internalref classoperations__research_1_1fz_1_1ModelStatistics "operations_research::fz::ModelStatistics" </dt><dd> \anchor _todo000425 (user): Clean up API to pass a Model* in argument. </dd> <dt> \_setscope operations_research::fz::Presolver Class \_internalref classoperations__research_1_1fz_1_1Presolver "operations_research::fz::Presolver" </dt><dd> \anchor _todo000438 (user): Error reporting of unfeasible models. </dd> <dt> \_setscope operations_research::GenericMaxFlow Member \_internalref classoperations__research_1_1GenericMaxFlow#a92fbc9576b457ceddeb21395181b3273 "operations_research::GenericMaxFlow< Graph >::check_result_" </dt><dd> \anchor _todo000689 (user): Make the check more exhaustive by checking the optimality? </dd> <dt> \_setscope operations_research::GenericMaxFlow Member \_internalref classoperations__research_1_1GenericMaxFlow#ad7892ad5aa8338015f320267fb7f298f "operations_research::GenericMaxFlow< Graph >::GetSinkSideMinCut" (std::vector< NodeIndex > *result)</dt><dd> \anchor _todo000688 (user): In the two-phases algorithm, we can get this minimum cut without doing the second phase. Add an option for this if there is a need to, note that the second phase is pretty fast so the gain will be small. </dd> <dt> \_setscope operations_research::GenericMaxFlow Member \_internalref classoperations__research_1_1GenericMaxFlow#ad3925f2137b18b1555563ed149ada740 "operations_research::GenericMaxFlow< Graph >::GlobalUpdate" ()</dt><dd> \anchor _todo000674 (user): By using more memory we can speed this up quite a bit by avoiding to take the opposite arc here, too options: - if (residual_arc_capacity_[arc] != arc_capacity_[arc]) - if (opposite_arc_is_admissible_[arc]) ///< need updates. Experiment with the first option shows more than 10% gain on this function running time, which is the bottleneck on many instances. \anchor _todo000675 (user): Investigate more and maybe write a publication :) \anchor _todo000676 (user): This is another argument for another anti-overflow algorithm. </dd> <dt> \_setscope operations_research::GenericMaxFlow Member \_internalref classoperations__research_1_1GenericMaxFlow#a20139b839cd5764939afc8df968a2484 "operations_research::GenericMaxFlow< Graph >::InitializePreflow" ()</dt><dd> \anchor _todo000673 (user): find a way to make the re-solving incremental (not an obvious task, and there has not been a lot of literature on the subject.) </dd> <dt> \_setscope operations_research::GenericMaxFlow Member \_internalref classoperations__research_1_1GenericMaxFlow#aa96647a33c0a0898055642bd6d039f83 "operations_research::GenericMaxFlow< Graph >::kMaxFlowQuantity" </dt><dd> \anchor _todo000681 (user): moves this code out of a .cc file and include it at the end of the header so it can work with any graph implementation ? </dd> <dt> \_setscope operations_research::GenericMaxFlow Member \_internalref classoperations__research_1_1GenericMaxFlow#a1c31c96effb1f91f800895be2339045b "operations_research::GenericMaxFlow< Graph >::PushFlow" (FlowQuantity flow, ArcIndex arc)</dt><dd> \anchor _todo000677 (user): Do not allow a zero flow after fixing the UniformMaxFlow code. </dd> <dt> \_setscope operations_research::GenericMaxFlow Member \_internalref classoperations__research_1_1GenericMaxFlow#a1061c1ce94ccc0d379390b8542bfaa23 "operations_research::GenericMaxFlow< Graph >::Refine" ()</dt><dd> \anchor _todo000678 (user): This may not be the most efficient algorithm if we need to loop many times. An alternative may be to handle the source like the other nodes in the algorithm, initially putting an excess of kMaxFlowQuantity on it, and making the source active like any other node with positive excess. To investigate. \anchor _todo000679 (user): The code below is buggy when more than kMaxFlowQuantity can be pushed out of the source (i.e. when we loop more than once in the while()). This is not critical, since this code is not used in the default algorithm computation. The issue is twofold: - InitializeActiveNodeContainer() doesn't push the nodes in the correct order. - PushFlowExcessBackToSource() may break the node potential properties, and we will need a call to GlobalUpdate() to fix that. </dd> <dt> \_setscope operations_research::GenericMaxFlow Member \_internalref classoperations__research_1_1GenericMaxFlow#a91d754521a7d43dd215e5d6200ec1062 "operations_research::GenericMaxFlow< Graph >::RefineWithGlobalUpdate" ()</dt><dd> \anchor _todo000680 (user): This should be graph_->num_nodes(), but ebert graph does not have a correct size if the highest index nodes have no arcs. </dd> <dt> \_setscope operations_research::GenericMaxFlow Member \_internalref classoperations__research_1_1GenericMaxFlow#a05f2661c573eb445212f4eddd694fc2f "operations_research::GenericMaxFlow< Graph >::SetArcCapacity" (ArcIndex arc, FlowQuantity new_capacity)</dt><dd> \anchor _todo000672 (user): The easiest is probably to allow negative node excess in other places than the source, but the current implementation does not deal with this. </dd> <dt> \_setscope operations_research::GenericMinCostFlow Class \_internalref classoperations__research_1_1GenericMinCostFlow "operations_research::GenericMinCostFlow< Graph, ArcFlowType, ArcScaledCostType >" </dt><dd> \anchor _todo000700 (user): Avoid using the globally defined type CostValue and FlowQuantity. Also uses the Arc*Type where there is no risk of overflow in more places. </dd> <dt> \_setscope operations_research::GenericMinCostFlow Member \_internalref classoperations__research_1_1GenericMinCostFlow#a342b29b5fe3d4a96bfc0c7d850e05d46 "operations_research::GenericMinCostFlow< Graph, ArcFlowType, ArcScaledCostType >::CheckFeasibility" (std::vector< NodeIndex > *infeasible_supply_node, std::vector< NodeIndex > *infeasible_demand_node)</dt><dd> \anchor _todo000691 (user): make it possible to share a graph by MaxFlow and MinCostFlow. For this it is necessary to make StarGraph resizable. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#af8b64e33d94a43d071d6faeedf8a9305 "operations_research::GetBestScalingOfDoublesToInt64" (absl::Span< const double > input, int64_t max_absolute_sum, double *scaling_factor, double *max_relative_coeff_error)</dt><dd> \anchor _todo002450 (user): incorporate the gcd computation here? The issue is that I am not sure if I just do factor /= gcd that round(x * factor) will be the same. </dd> <dt> \_setscope operations_research::GlobalCheapestInsertionFilteredHeuristic Member \_internalref classoperations__research_1_1GlobalCheapestInsertionFilteredHeuristic#abe76b53e07ae6db10cda5c6fd70d0001 "operations_research::GlobalCheapestInsertionFilteredHeuristic::BuildSolutionInternal" () override</dt><dd> \anchor _todo000369 (user): Adapt the pair insertions to also support seed and sequential insertion. </dd> <dt> \_setscope operations_research::glop Member \_internalref namespaceoperations__research_1_1glop#aeacc29c42c7fddda875937d3bdfc7e08 "operations_research::glop::ABSL_DEPRECATED" ("Use the direct methods instead") MPSReader</dt><dd> \anchor _todo000874 (user): Remove the MPSReader class. </dd> <dt> \_setscope operations_research::glop::AddSlackVariablesPreprocessor Class \_internalref classoperations__research_1_1glop_1_1AddSlackVariablesPreprocessor "operations_research::glop::AddSlackVariablesPreprocessor" </dt><dd> \anchor _todo000528 (user): Do not require this step to talk to the revised simplex. On large LPs like supportcase11.mps, this step alone can add 1.5 GB to the solver peak memory for no good reason. The internal matrix representation used in glop is a lot more efficient, and there is no point keeping the slacks in LinearProgram. It is also bad for incrementaly modifying the LP. </dd> <dt> \_setscope operations_research::glop Member \_internalref namespaceoperations__research_1_1glop#acf14406acccf01da7c2dd2fa1c66425e "operations_research::glop::ApplyPermutation" (const Permutation< IndexType > &perm, const ITIVectorType &b, ITIVectorType *result)</dt><dd> \anchor _todo000882 (user): Try to restrict this method to using the same integer type in the permutation and for the vector indices, i.e. IndexType == ITIVectorType::IndexType. Some client code will need to be refactored. </dd> <dt> \_setscope operations_research::glop Member \_internalref namespaceoperations__research_1_1glop#aac6525bf47674e01c5d51e956ce13a63 "operations_research::glop::AreFirstColumnsAndRowsExactlyEquals" (RowIndex num_rows, ColIndex num_cols, const SparseMatrix &matrix_a, const CompactSparseMatrix &matrix_b)</dt><dd> \anchor _todo000871 (user): Also DCHECK() that matrix_b is ordered by rows. </dd> <dt> \_setscope operations_research::glop::BasisFactorization Member \_internalref classoperations__research_1_1glop_1_1BasisFactorization#a370b080a5be3e81960457e53261e7cd5 "operations_research::glop::BasisFactorization::ComputeInitialBasis" (const std::vector< ColIndex > &candidates)</dt><dd> \anchor _todo000443 (user): This "double" factorization is a bit inefficient, and we should probably Initialize() right away the factorization with the new basis, but more code is needed for that. It is also not that easy also because we want to permute all the added slack first. </dd> <dt> \_setscope operations_research::glop::BasisFactorization Member \_internalref classoperations__research_1_1glop_1_1BasisFactorization#af2eba683b05901eb982dcade3fda53d3 "operations_research::glop::BasisFactorization::ComputeInverseOneNorm" () const</dt><dd> \anchor _todo000441 (user): try to merge the computation of the norm of inverses with that of MatrixView. Maybe use a wrapper class for InverseMatrix. </dd> <dt> \_setscope operations_research::glop::BasisFactorization Member \_internalref classoperations__research_1_1glop_1_1BasisFactorization#a90e327f8ea7f4594bab0686230735287 "operations_research::glop::BasisFactorization::RightSolveForProblemColumn" (ColIndex col, ScatteredColumn *d) const</dt><dd> \anchor _todo000440 (user): if right_pool_mapping_[col] != kInvalidCol, we can reuse it and just apply the last rank one update since it was computed. </dd> <dt> \_setscope operations_research::glop::BasisState Struct \_internalref structoperations__research_1_1glop_1_1BasisState "operations_research::glop::BasisState" </dt><dd> \anchor _todo000623 (user): Introduce another state class to store a complete state of the solver. Using this state and the original linear program, the solver can be restarted with as little time overhead as possible. This is especially useful for strong branching in a MIP context. </dd> <dt> \_setscope operations_research::glop::BasisState Member \_internalref structoperations__research_1_1glop_1_1BasisState#a8403627807a2ba65e69b8fb58061293f "operations_research::glop::BasisState::statuses" </dt><dd> \anchor _todo000624 (user): A MIP solver will potentially store a lot of BasisStates so memory usage is important. It is possible to use only 2 bits for one VariableStatus enum. To achieve this, the FIXED_VALUE status can be converted to either AT_LOWER_BOUND or AT_UPPER_BOUND and decoded properly later since this will be used with a given linear program. This way we can even encode more information by using the reduced cost sign to choose to which bound the fixed status correspond. </dd> <dt> \_setscope operations_research::glop::ColumnView Member \_internalref classoperations__research_1_1glop_1_1ColumnView#a37aadf4689cf83d4e92724df18788c26 "operations_research::glop::ColumnView::LookUpCoefficient" (RowIndex index) const</dt><dd> \anchor _todo000897 (user): investigate whether an optimized version of LookUpCoefficient for "clean" columns yields speed-ups. </dd> <dt> \_setscope operations_research::glop::CompactSparseMatrix Member \_internalref classoperations__research_1_1glop_1_1CompactSparseMatrix#aa5613aefbe167b3a7060c47adbc18257 "operations_research::glop::CompactSparseMatrix::CompactSparseMatrix" (const SparseMatrix &matrix)</dt><dd> \anchor _todo000892 (user): If this is needed in production code, it can be done faster. </dd> <dt> \_setscope operations_research::glop::DataWrapper< MPModelProto > Member \_internalref classoperations__research_1_1glop_1_1DataWrapper_3_01MPModelProto_01_4#ae847ea2baa71fe069259a785a2f793ba "operations_research::glop::DataWrapper< MPModelProto >::CleanUp" ()</dt><dd> \anchor _todo000873 (user): Experiment with the switch constant. </dd> <dt> \_setscope operations_research::glop Member \_internalref namespaceoperations__research_1_1glop#a02a36a3bb1bee8ca88e9d07f4e914ad2 "operations_research::glop::Density" (const DenseRow &row)</dt><dd> \anchor _todo000868 (user): Take a Scattered row/col instead. This is only used to report stats, but we should still have a sparse version to do it faster. </dd> <dt> \_setscope operations_research::glop::DoubletonEqualityRowPreprocessor Member \_internalref classoperations__research_1_1glop_1_1DoubletonEqualityRowPreprocessor#a417519507dabcad60034e4b158755bf5 "operations_research::glop::DoubletonEqualityRowPreprocessor::RecoverSolution" (ProblemSolution *solution) const final</dt><dd> \anchor _todo000517 (user): We can probably use something better than a vector of set, but the number of entry is really sparse though. And the size of a set<int> is 24 bytes, same as a std::vector<int>. </dd> <dt> \_setscope operations_research::glop::DoubletonEqualityRowPreprocessor Member \_internalref classoperations__research_1_1glop_1_1DoubletonEqualityRowPreprocessor#aee8ab3fb7503d6267c9a09854ecd7a2d "operations_research::glop::DoubletonEqualityRowPreprocessor::Run" (LinearProgram *lp) final</dt><dd> \anchor _todo000512 (user): Get rid of the FIXED status instead to avoid spending time/memory for no good reason here. \anchor _todo000513 (user): There is probably some more robust ways. \anchor _todo000514 (user): make a smarter choice of which column to delete, and swap col[] and coeff[] accordingly. \anchor _todo000515 (user): consider skipping the problematic rows in this preprocessor, or trying harder to avoid the under/overflow. \anchor _todo000516 (user): rename that method to reflect the fact that it also updates the objective offset, in the other direction. </dd> <dt> \_setscope operations_research::glop::DoubletonFreeColumnPreprocessor Member \_internalref classoperations__research_1_1glop_1_1DoubletonFreeColumnPreprocessor#ab64cfa1fb6ff03f45291fcb60f506963 "operations_research::glop::DoubletonFreeColumnPreprocessor::Run" (LinearProgram *lp) final</dt><dd> \anchor _todo000496 (user): Impact? </dd> <dt> \_setscope operations_research::glop::DualEdgeNorms Member \_internalref classoperations__research_1_1glop_1_1DualEdgeNorms#ab9c06f7b3b7e0337da531ca86c3fd43c "operations_research::glop::DualEdgeNorms::UpdateBeforeBasisPivot" (ColIndex entering_col, RowIndex leaving_row, const ScatteredColumn &direction, const ScatteredRow &unit_row_left_inverse)</dt><dd> \anchor _todo000444 (user): use a more precise lower bound depending on the column norm? We can do that with Cauchy-Swartz inequality: (edge . leaving_column)^2 = 1.0 < |<tt>edge</tt>|^2 * |<tt>leaving_column</tt>|^2 </dd> <dt> \_setscope operations_research::glop::DualizerPreprocessor Member \_internalref classoperations__research_1_1glop_1_1DualizerPreprocessor#afb190878213f1da31a0daa0f03b9e017 "operations_research::glop::DualizerPreprocessor::Run" (LinearProgram *lp) final</dt><dd> \anchor _todo000518 (user): This effect can be lowered if we use some of the extra variables as slack variable which we are not doing at this point. \anchor _todo000519 (user): This will break if PopulateFromDual() is changed. so document the convention or make the function fill these vectors? \anchor _todo000520 (user): There are two different ways to deal with ranged rows when taking the dual. The default way is to duplicate such rows, see PopulateFromDual() for details. Another way is to call lp->AddSlackVariablesForFreeAndBoxedRows() before calling PopulateFromDual(). Adds an option to switch between the two as this may change the running time?</dd> <dt> \_setscope operations_research::glop::DynamicMaximum Member \_internalref classoperations__research_1_1glop_1_1DynamicMaximum#a5a1cf0bc9507c1dfcef22b8d89d2d9f0 "operations_research::glop::DynamicMaximum< Index >::GetMaximum" ()</dt><dd> \anchor _todo000535 (user): Add a mode when we do not maintain the TopK for small sizes (like n < 1000) ? The gain might not be worth the extra code though. </dd> <dt> \_setscope operations_research::glop::EnteringVariable Member \_internalref classoperations__research_1_1glop_1_1EnteringVariable#a3c3a0b006ecdc59714cd1c66f50e7cff "operations_research::glop::EnteringVariable::DeterministicTime" () const</dt><dd> \anchor _todo000448 (user): Be exhausitive and more precise. </dd> <dt> \_setscope operations_research::glop::EnteringVariable Member \_internalref classoperations__research_1_1glop_1_1EnteringVariable#a863b59030d198656afffb23fcd533948 "operations_research::glop::EnteringVariable::DualChooseEnteringColumn" (bool nothing_to_recompute, const UpdateRow &update_row, Fractional cost_variation, std::vector< ColIndex > *bound_flip_candidates, ColIndex *entering_col)</dt><dd> \anchor _todo000445 (user): It is unclear if this is a good idea, but the primal simplex have pretty good/stable behavior with a similar logic. Experiment seems to show that this works well with the dual too. \anchor _todo000446 (user): We want to maximize both the ratio (objective improvement) and the coeff_magnitude (stable pivot), so we have to make some trade-offs. Investigate alternative strategies. </dd> <dt> \_setscope operations_research::glop::EnteringVariable Member \_internalref classoperations__research_1_1glop_1_1EnteringVariable#ad20764201d083354bdf18a8def790e4a "operations_research::glop::EnteringVariable::DualPhaseIChooseEnteringColumn" (bool nothing_to_recompute, const UpdateRow &update_row, Fractional cost_variation, ColIndex *entering_col)</dt><dd> \anchor _todo000447 (user): This is the same in DualChooseEnteringColumn(), remove duplication? </dd> <dt> \_setscope operations_research::glop Member \_internalref namespaceoperations__research_1_1glop#aed75af61dbbe6d3c628c274f271f9000 "operations_research::glop::FindProportionalColumns" (const SparseMatrix &matrix, Fractional tolerance)</dt><dd> \anchor _todo000870 (user): Derive precise bounds on what this tolerance should be so that no proportional columns are missed. </dd> <dt> \_setscope operations_research::glop Member \_internalref namespaceoperations__research_1_1glop#ac55fddbd6cdae02b8a88e2c845f0d4d7 "operations_research::glop::FixConstraintWithFixedStatuses" (const DenseColumn &row_lower_bounds, const DenseColumn &row_upper_bounds, ProblemSolution *solution)</dt><dd> \anchor _todo000526 (user): A better solution would simply be to get rid of the FIXED status altogether, it is better to simply use AT_LOWER_BOUND/AT_UPPER_BOUND depending on the constraining bound in the optimal solution. Note that we can always at the end transform any variable/constraint with a fixed domain to FIXED_VALUE if needed to keep the same external API. </dd> <dt> \_setscope operations_research::glop::ImpliedFreePreprocessor Class \_internalref classoperations__research_1_1glop_1_1ImpliedFreePreprocessor "operations_research::glop::ImpliedFreePreprocessor" </dt><dd> \anchor _todo000525 (user): Only process doubleton columns so we have more chance in the later passes to create more doubleton columns? Such columns lead to a smaller problem thanks to the DoubletonFreeColumnPreprocessor. </dd> <dt> \_setscope operations_research::glop::ImpliedFreePreprocessor Member \_internalref classoperations__research_1_1glop_1_1ImpliedFreePreprocessor#a22a4d717e6ac86260356defc467e980e "operations_research::glop::ImpliedFreePreprocessor::Run" (LinearProgram *lp) final</dt><dd> \anchor _todo000491 (user) : Replace SumWithNegativeInfiniteAndOneMissing and SumWithPositiveInfiniteAndOneMissing with IntervalSumWithOneMissing. \anchor _todo000492 (user): Only process degree-two so in subsequent passes more degree-two columns could be made free. And only when no other reduction can be applied, process the higher degree column? \anchor _todo000493 (user): Be smarter about the order that maximizes the number of free column. For instance if we have 3 doubleton columns that use the rows (1,2) (2,3) and (3,4) then it is better not to make (2,3) free so the two other two can be made free. \anchor _todo000494 (user): As of July 2013, with our preprocessors this case is never triggered on the Netlib. Note however that if it appears it can have a big impact since by fixing the variable, the two involved constraints are forcing and can be removed too (with all the variables they touch). The postsolve step is quite involved though. \anchor _todo000495 (user): This trick is already used in the DualizerPreprocessor, maybe we should just have a preprocessor that shifts all the variables bounds to have at least one of them at 0.0, will that improve precision and speed of the simplex? One advantage is that we can compute the new constraint bounds with better precision using AccurateSum. </dd> <dt> \_setscope operations_research::glop Member \_internalref namespaceoperations__research_1_1glop#a451faba66f544c02438a3ce062b69900 "operations_research::glop::KahanSum" </dt><dd> \anchor _todo000866 (user): For some Fractional types, it may not gain much (or even nothing if we are in infinite precision) to use this sum. A solution is to templatize this class and specialize it to a normal sum for the Fractional type we want so in this case the PreciseXXX() functions below will become equivalent to their normal version. </dd> <dt> \_setscope operations_research::glop Member \_internalref namespaceoperations__research_1_1glop#abbaca14cc7f5a0f3aaeb027fef37e0ca "operations_research::glop::kNonPivotal" (-1)</dt><dd> \anchor _todo000896 (user): Consider using kInvalidRow for this? </dd> <dt> \_setscope operations_research::glop::LinearProgram Member \_internalref classoperations__research_1_1glop_1_1LinearProgram#a65b22be15b4caa784b8d7c690e2418ae "operations_research::glop::LinearProgram::AddSlackVariablesWhereNecessary" (bool detect_integer_constraints)</dt><dd> \anchor _todo000861 (user): investigate the impact on the running time. It seems low because we almost never iterate on fixed variables. </dd> <dt> \_setscope operations_research::glop::LinearProgram Member \_internalref classoperations__research_1_1glop_1_1LinearProgram#ab7e81c6d3e23deb4d58662661bf07f70 "operations_research::glop::LinearProgram::Dump" () const</dt><dd> \anchor _todo000856 (user): if needed provide similar output for binary variables. </dd> <dt> \_setscope operations_research::glop::LinearProgram Member \_internalref classoperations__research_1_1glop_1_1LinearProgram#a8eb71b2feea025093caf9ee0ecaa1bc5 "operations_research::glop::LinearProgram::FindOrCreateVariable" (absl::string_view variable_id)</dt><dd> \anchor _todo000858 (user): Move these and the two corresponding hash_table into a new LinearProgramBuilder class to simplify the code of some functions like DeleteColumns() here and make the behavior on copy clear? or simply remove them as it is almost as easy to maintain a hash_table on the client side. </dd> <dt> \_setscope operations_research::glop::LinearProgram Member \_internalref classoperations__research_1_1glop_1_1LinearProgram#abdf54cae5dbc76354d86e34108dcb3f3 "operations_research::glop::LinearProgram::GetNonZeroStats" () const</dt><dd> \anchor _todo000860 (user): Theses are statistics about the underlying matrix and should be moved to SparseMatrix. </dd> <dt> \_setscope operations_research::glop::LinearProgram Member \_internalref classoperations__research_1_1glop_1_1LinearProgram#a8c6c53f53e930c90d42930e648946ec6 "operations_research::glop::LinearProgram::IsVariableBinary" (ColIndex col) const</dt><dd> \anchor _todo000855 (user): bounds of binary variables (and of integer ones) should be integer. Add a preprocessor for that. </dd> <dt> \_setscope operations_research::glop::LinearProgram Member \_internalref classoperations__research_1_1glop_1_1LinearProgram#afdef8d3fad551379c138ea96f9b695d3 "operations_research::glop::LinearProgram::PopulateFromDual" (const LinearProgram &dual, RowToColMapping *duplicated_rows)</dt><dd> \anchor _todo000862 (user): Do not interpret as a minimization problem? </dd> <dt> \_setscope operations_research::glop::LinearProgram Member \_internalref classoperations__research_1_1glop_1_1LinearProgram#a8c83436c29274ad2930e716a0032d708 "operations_research::glop::LinearProgram::ScaleObjective" (GlopParameters::CostScalingAlgorithm method)</dt><dd> \anchor _todo000863 (user): Another more aggressive idea is to set the median/mean/geomean of the magnitudes to one. Investigate if this leads to better results. It does look more robust.</dd> <dt> \_setscope operations_research::glop::LinearProgram Member \_internalref classoperations__research_1_1glop_1_1LinearProgram#aafd3e53a18570f0757a0a58f666b88c8 "operations_research::glop::LinearProgram::SetVariableName" (ColIndex col, absl::string_view name)</dt><dd> \anchor _todo000859 (user): Add PopulateIdsFromNames() so names added via Set{Variable|Constraint}Name() can be found. </dd> <dt> \_setscope operations_research::glop::LPSolver Member \_internalref classoperations__research_1_1glop_1_1LPSolver#a9546370ee7138da64e3fb67577230bad "operations_research::glop::LPSolver::DeterministicTime" () const</dt><dd> \anchor _todo000466 (user): Currently, this is only modified when the simplex code is executed. \anchor _todo000467 (user): Improve the correlation with the running time. </dd> <dt> \_setscope operations_research::glop::LPSolver Member \_internalref classoperations__research_1_1glop_1_1LPSolver#ae525d5598b932514635be5f0329610a4 "operations_research::glop::LPSolver::LoadAndVerifySolution" (const LinearProgram &lp, const ProblemSolution &solution)</dt><dd> \anchor _todo000453 (user): Try to also check the precision of an INFEASIBLE or UNBOUNDED return status. \anchor _todo000454 (user): the name is not really consistent since in practice those are the "residual" since the primal/dual infeasibility are zero when parameters_.provide_strong_optimal_guarantee() is true. </dd> <dt> \_setscope operations_research::glop::LPSolver Member \_internalref classoperations__research_1_1glop_1_1LPSolver#adb7f0e515ab9d9503a454e05904c0376 "operations_research::glop::LPSolver::MayHaveMultipleOptimalSolutions" () const</dt><dd> \anchor _todo000465 (user): Test this behavior extensively if a client relies on it. </dd> <dt> \_setscope operations_research::glop::LPSolver Member \_internalref classoperations__research_1_1glop_1_1LPSolver#ac1d303dc79dae9cefd6185fda6c60e33 "operations_research::glop::LPSolver::SolveWithTimeLimit" (const LinearProgram &lp, TimeLimit *time_limit)</dt><dd> \anchor _todo000451 (user): Unfortunately we are not really helpful with the error message here. We could do a better job. However most client should talk to glop via an input protocol buffer which should have better validation messages. \anchor _todo000452 (user): If speed matter, we could do that as we copy the program. </dd> <dt> \_setscope operations_research::glop::LuFactorization Member \_internalref classoperations__research_1_1glop_1_1LuFactorization#ab7b32a56a250336b4f954ad707f24b90 "operations_research::glop::LuFactorization::ComputeLowerTimesUpper" (SparseMatrix *product) const</dt><dd> \anchor _todo000470 (user): avoid the matrix conversion by multiplying TriangularMatrix directly. </dd> <dt> \_setscope operations_research::glop::LuFactorization Member \_internalref classoperations__research_1_1glop_1_1LuFactorization#a9af5d602c804b0b6b64ace6d1b61f169 "operations_research::glop::LuFactorization::ComputeOneNormConditionNumber" (const CompactSparseMatrixView &matrix) const</dt><dd> \anchor _todo000469 (user): separate this from LuFactorization. </dd> <dt> \_setscope operations_research::glop::MainLpPreprocessor Member \_internalref classoperations__research_1_1glop_1_1MainLpPreprocessor#a2d3237c0758f6628b102fcbe5b2002c8 "operations_research::glop::MainLpPreprocessor::Run" (LinearProgram *lp) final</dt><dd> \anchor _todo000485 (user): Run them in the loop above if the effect on the running time is good. This needs more investigation. \anchor _todo000486 (user): We probably want to scale the costs before and after this preprocessor so that the rhs/objective of the dual are with a good magnitude. </dd> <dt> \_setscope operations_research::glop::Markowitz Member \_internalref classoperations__research_1_1glop_1_1Markowitz#a57adb2bec33795ce391f871a1acbf761 "operations_research::glop::Markowitz::ComputeRowAndColumnPermutation" (const CompactSparseMatrixView &basis_matrix, RowPermutation *row_perm, ColumnPermutation *col_perm)</dt><dd> \anchor _todo000471 (user): If we don't need L and U, we can abort when the residual matrix becomes dense (i.e. when its density factor is above a certain threshold). The residual size is 'end_index - index' and the density can either be computed exactly or estimated from min_markowitz. \anchor _todo000472 (user): This step can be skipped, once a fully dense matrix is obtained. But note that permuted_lower_column_needs_solve_ needs to be updated. \anchor _todo000473 (user): Note that in some rare cases, because of numerical cancellation, the column degree may actually be smaller than pivot_col_degree. Exploit that better? </dd> <dt> \_setscope operations_research::glop::MatrixEntry Struct \_internalref structoperations__research_1_1glop_1_1MatrixEntry "operations_research::glop::MatrixEntry" </dt><dd> \anchor _todo000524 (user): Generalize the design used in this preprocessor to a general "propagation" framework in order to apply as many reductions as possible in an efficient manner. </dd> <dt> \_setscope operations_research::glop::MatrixNonZeroPattern Member \_internalref classoperations__research_1_1glop_1_1MatrixNonZeroPattern#acba2eb03de47fb8c7cabe51848d04612 "operations_research::glop::MatrixNonZeroPattern::Update" (RowIndex pivot_row, ColIndex pivot_col, const SparseColumn &column)</dt><dd> \anchor _todo000480 (user): Special case if row_non_zero_[pivot_row].size() == 1? \anchor _todo000481 (user): Add unit tests before using this. </dd> <dt> \_setscope operations_research::glop Member \_internalref namespaceoperations__research_1_1glop#af8a64136c69a6dfc1b38c22c754cbe65 "operations_research::glop::MPModelProtoToLinearProgram" (const MPModelProto &input, LinearProgram *output)</dt><dd> \anchor _todo000883 (user): clean up loops to use natural range iteration. \anchor _todo000884 (user): implement strong proto validation in the linear solver server and re-use it here. </dd> <dt> \_setscope operations_research::glop::Preprocessor Class \_internalref classoperations__research_1_1glop_1_1Preprocessor "operations_research::glop::Preprocessor" </dt><dd> \anchor _todo000523 (user): On most preprocessors, calling Run() more than once will not work as expected. Fix? or document and crash in debug if this happens. </dd> <dt> \_setscope operations_research::glop::Preprocessor Member \_internalref classoperations__research_1_1glop_1_1Preprocessor#ab755069ed133ea14ffec0bba56930559 "operations_research::glop::Preprocessor::IsSmallerWithinPreprocessorZeroTolerance" (Fractional a, Fractional b) const</dt><dd> \anchor _todo000529 (user): use an absolute tolerance here to be even more defensive? </dd> <dt> \_setscope operations_research::glop::PrimalPrices Class \_internalref classoperations__research_1_1glop_1_1PrimalPrices "operations_research::glop::PrimalPrices" </dt><dd> \anchor _todo000547 (user): Not high priority but should probably be moved to its own file. </dd> <dt> \_setscope operations_research::glop::PrimalPrices Member \_internalref classoperations__research_1_1glop_1_1PrimalPrices#ab2a479cbb008b8ae4b9ec2d294f79c07 "operations_research::glop::PrimalPrices::PrimalPrices" (absl::BitGenRef random, const VariablesInfo &variables_info, PrimalEdgeNorms *primal_edge_norms, ReducedCosts *reduced_costs)</dt><dd> \anchor _todo000549 (user): Switch to a model based API like in CP-SAT. </dd> <dt> \_setscope operations_research::glop::ProportionalColumnPreprocessor Member \_internalref classoperations__research_1_1glop_1_1ProportionalColumnPreprocessor#afdfcacb0413c8aefe02ff1b9eae0ac68 "operations_research::glop::ProportionalColumnPreprocessor::Run" (LinearProgram *lp) final</dt><dd> \anchor _todo000488 (user): Change FindProportionalColumns for this? </dd> <dt> \_setscope operations_research::glop::ProportionalRowPreprocessor Member \_internalref classoperations__research_1_1glop_1_1ProportionalRowPreprocessor#adddaa59a5bbb8b300795e6f2b9287d3c "operations_research::glop::ProportionalRowPreprocessor::Run" (LinearProgram *lp) final</dt><dd> \anchor _todo000489 (user): Already return such a mapping from FindProportionalColumns()? \anchor _todo000490 (user): if the bounds are equal, use the largest row in magnitude? </dd> <dt> \_setscope operations_research::glop::RandomAccessSparseColumn Member \_internalref classoperations__research_1_1glop_1_1RandomAccessSparseColumn#a59461735207f0d09b1175d3522762f2a "operations_research::glop::RandomAccessSparseColumn::PopulateSparseColumn" (SparseColumn *sparse_column) const</dt><dd> \anchor _todo000895 (user): Do that only if (value != 0.0) ? </dd> <dt> \_setscope operations_research::glop::RankOneUpdateFactorization Member \_internalref classoperations__research_1_1glop_1_1RankOneUpdateFactorization#a3b877b20ffaa0ba743da5c3cb7fa7744 "operations_research::glop::RankOneUpdateFactorization::DeterministicTimeSinceLastReset" () const</dt><dd> \anchor _todo000544 (user): This is quite precise. However we overcount a bit, because in each elementary solves, if the scalar product involved is zero, we skip some of the operations counted here. Is it worth spending a bit more time to be more precise here? </dd> <dt> \_setscope operations_research::glop::RankOneUpdateFactorization Member \_internalref classoperations__research_1_1glop_1_1RankOneUpdateFactorization#af68318310cfb9859c6d98a3e31ccafac "operations_research::glop::RankOneUpdateFactorization::RankOneUpdateFactorization" ()</dt><dd> \anchor _todo000543 (user): make the 5% a parameter and share it between all the places that switch between a sparse/dense version. </dd> <dt> \_setscope operations_research::glop::RevisedSimplex Member \_internalref classoperations__research_1_1glop_1_1RevisedSimplex#a642656ecb53b31a499007ad1d033652a "operations_research::glop::RevisedSimplex::ComputeDictionary" (const DenseRow *column_scales)</dt><dd> \anchor _todo000605 (user): Use row scales as well. </dd> <dt> \_setscope operations_research::glop::RevisedSimplex Member \_internalref classoperations__research_1_1glop_1_1RevisedSimplex#ada2f59f7b385068f27d172f1f9bff72a "operations_research::glop::RevisedSimplex::DeterministicTime" () const</dt><dd> \anchor _todo000560 (user): Count what is missing. </dd> <dt> \_setscope operations_research::glop::RevisedSimplex Member \_internalref classoperations__research_1_1glop_1_1RevisedSimplex#a4a7567f5c243a6e56d0e48d6ed70e0de "operations_research::glop::RevisedSimplex::LoadStateForNextSolve" (const BasisState &state)</dt><dd> \anchor _todo000551 (user): Add comparison operator. </dd> <dt> \_setscope operations_research::glop::RevisedSimplex Member \_internalref classoperations__research_1_1glop_1_1RevisedSimplex#ac08f8edb988e06b034fa6f9516913368 "operations_research::glop::RevisedSimplex::Solve" (const LinearProgram &lp, TimeLimit *time_limit)</dt><dd> \anchor _todo000552 (user): Avoid doing the first phase checks when we know from the incremental solve that the solution is already dual or primal feasible. \anchor _todo000553 (user): Not ideal in an incremental setting. \anchor _todo000554 (user): Note that if there was cost shifts, we just keep them until the end of the optim. \anchor _todo000555 (user): What if slightly infeasible? we shouldn't really stop. Call primal ? use higher tolerance ? It seems we can always kind of continue and deal with the issue later. Find a way other than this + 1e-6 hack. \anchor _todo000556 (user): We should also confirm the PRIMAL_UNBOUNDED or DUAL_UNBOUNDED status by checking with the other phase I that the problem is really DUAL_INFEASIBLE or PRIMAL_INFEASIBLE. For instance we currently report PRIMAL_UNBOUNDED with the primal on the problem l30.mps instead of OPTIMAL and the dual does not have issues on this problem. \anchor _todo000557 (user): There is another issue on infeas/qual.mps. I think we should just check the dual ray, not really the current solution dual feasibility. \anchor _todo000558 (user): we currently skip the DUAL_INFEASIBLE status because the quantities are not up to date in this case. \anchor _todo000559 (user): We should re-check for feasibility at this point and apply clean-up as needed. </dd> <dt> \_setscope operations_research::glop::RevisedSimplexDictionary Member \_internalref classoperations__research_1_1glop_1_1RevisedSimplexDictionary#a23359894a725f27972fc3a3b6b919db9 "operations_research::glop::RevisedSimplexDictionary::GetBasicColumnForRow" (RowIndex r) const</dt><dd> \anchor _todo000609 (user): This function is a better fit for the future custom iterator. </dd> <dt> \_setscope operations_research::glop::RevisedSimplexDictionary Member \_internalref classoperations__research_1_1glop_1_1RevisedSimplexDictionary#a79cca8bd83c2bde1691dd782335d767e "operations_research::glop::RevisedSimplexDictionary::RevisedSimplexDictionary" (const DenseRow *col_scales, RevisedSimplex *revised_simplex)</dt><dd> \anchor _todo000608 (user): Overload this to take RevisedSimplex* alone when the caller would normally pass a nullptr for col_scales so this and ComputeDictionary can take a const& argument. </dd> <dt> \_setscope operations_research::glop Member \_internalref namespaceoperations__research_1_1glop#a46935a48ea28abfec1c2569fe4aea70f "operations_research::glop::ScalarProduct" (const DenseRowOrColumn &u, const SparseColumn &v)</dt><dd> \anchor _todo000867 (user): Optimize this more (SSE or unroll with two sums). Another option is to skip the u[col] that are 0.0 rather than fetching the coeff and doing a Fractional multiplication. </dd> <dt> \_setscope operations_research::glop::ScatteredVector Struct \_internalref structoperations__research_1_1glop_1_1ScatteredVector "operations_research::glop::ScatteredVector< Index, Iterator >" </dt><dd> \anchor _todo000885 (user): This should be changed from struct to class. </dd> <dt> \_setscope operations_research::glop::ScatteredVector Member \_internalref structoperations__research_1_1glop_1_1ScatteredVector#a1863a881c8165a5b4217f58e70dcbc97 "operations_research::glop::ScatteredVector< Index, Iterator >::kDefaultRatioForUsingDenseIteration" </dt><dd> \anchor _todo000886 (user): The constant should depend on what algorithm is used. Clearing a dense vector is a lot more efficient than doing more complex stuff. Clean this up by extracting all the currently used constants in one place with meaningful names. </dd> <dt> \_setscope operations_research::glop::ShiftVariableBoundsPreprocessor Class \_internalref classoperations__research_1_1glop_1_1ShiftVariableBoundsPreprocessor "operations_research::glop::ShiftVariableBoundsPreprocessor" </dt><dd> \anchor _todo000527 (user): Having for each variable one of their bounds at zero is a requirement for the DualizerPreprocessor and for the implied free column in the ImpliedFreePreprocessor. However, shifting a variable with a domain like [-1e10, 1e10] may introduce numerical issues. Relax the definition of a free variable so that only having a domain containing 0.0 is enough? </dd> <dt> \_setscope operations_research::glop::ShiftVariableBoundsPreprocessor Member \_internalref classoperations__research_1_1glop_1_1ShiftVariableBoundsPreprocessor#aaa5aa6fd0a5ab4229ab8b8f1ca6f638c "operations_research::glop::ShiftVariableBoundsPreprocessor::Run" (LinearProgram *lp) final</dt><dd> \anchor _todo000521 (user): This would not be needed, if we always make the bound of an integer variable integer before applying this preprocessor. </dd> <dt> \_setscope operations_research::glop::SingletonPreprocessor Member \_internalref classoperations__research_1_1glop_1_1SingletonPreprocessor#ad57922a716f7058c76b5f524950b8953 "operations_research::glop::SingletonPreprocessor::Run" (LinearProgram *lp) final</dt><dd> \anchor _todo000510 (user): It seems better to process all the singleton columns with a cost of zero first. \anchor _todo000511 (user): We should be able to restrict the variable bounds with the ones of the constraint all the time. However, some situation currently break the presolve, and it seems hard to fix in a 100% safe way. </dd> <dt> \_setscope operations_research::glop::SparseMatrixScaler Member \_internalref classoperations__research_1_1glop_1_1SparseMatrixScaler#abe05dd74a745d50bce6f9b6f14ab0bbc "operations_research::glop::SparseMatrixScaler::Scale" (GlopParameters::ScalingAlgorithm method)</dt><dd> \anchor _todo000869 (user): Decide precisely for which value of dynamic range we should cut off geometric scaling. </dd> <dt> \_setscope operations_research::glop::SparseRow Class \_internalref classoperations__research_1_1glop_1_1SparseRow "operations_research::glop::SparseRow" </dt><dd> \anchor _todo000898 (user): Use this class where appropriate, i.e. when a SparseColumn is used to store a row vector (by means of RowIndex to ColIndex casting). </dd> <dt> \_setscope operations_research::glop::SparseVector Class \_internalref classoperations__research_1_1glop_1_1SparseVector "operations_research::glop::SparseVector< IndexType, IteratorType >" </dt><dd> \anchor _todo000899 (user): un-expose this type to client; by getting rid of the index-based APIs and leveraging iterator-based APIs; if possible. </dd> <dt> \_setscope operations_research::glop::SparseVector Member \_internalref classoperations__research_1_1glop_1_1SparseVector#a281b1ceefbefc14e321958f139dd8ea3 "operations_research::glop::SparseVector< IndexType, IteratorType >::AllEntryIndices" () const</dt><dd> \anchor _todo000904 (user): consider removing this, in favor of the natural range iteration. </dd> <dt> \_setscope operations_research::glop::SparseVector Member \_internalref classoperations__research_1_1glop_1_1SparseVector#afb0952c189b9c921d79526b96295a2c8 "operations_research::glop::SparseVector< IndexType, IteratorType >::CleanUp" ()</dt><dd> \anchor _todo000900 (user): Implement in-place sorting of the entries and cleanup. The current version converts the data to an array-of-pairs representation that can be sorted easily with std::stable_sort, and the converts the sorted data back to the struct-of-arrays implementation. The current version is ~20% slower than the in-place sort on the array-of-struct representation. It is not visible on GLOP benchmarks, but it increases peak memory usage by ~8%. Implementing in-place search will require either implementing a custom sorting code, or custom iterators that abstract away the internal representation. </dd> <dt> \_setscope operations_research::glop::SparseVector Member \_internalref classoperations__research_1_1glop_1_1SparseVector#afbae873b1b6a1f33cac11606834b6d0e "operations_research::glop::SparseVector< IndexType, IteratorType >::LookUpCoefficient" (Index index) const</dt><dd> \anchor _todo000903 (user): investigate whether an optimized version of LookUpCoefficient for "clean" columns yields speed-ups. </dd> <dt> \_setscope operations_research::glop::SparseVector Member \_internalref classoperations__research_1_1glop_1_1SparseVector#ac8066cbc5d5b7f8e794677b027cd96a2 "operations_research::glop::SparseVector< IndexType, IteratorType >::MoveTaggedEntriesTo" (const IndexPermutation &index_perm, SparseVector *output)</dt><dd> \anchor _todo000902 (user): In the way we use this function, we know that will not happen, but it is better to be careful so we can check that properly in debug mode. </dd> <dt> \_setscope operations_research::glop::StrictITISpan Member \_internalref classoperations__research_1_1glop_1_1StrictITISpan#a567f91a908d6143535f19afba8b2066b "operations_research::glop::StrictITISpan< IntType, T >::begin" () const</dt><dd> \anchor _todo000865 (user): This should probably be a strictly typed iterator too, but <tt>StrongVector::begin()</tt> already suffers from this problem. </dd> <dt> \_setscope operations_research::glop::StrictITIVector Class \_internalref classoperations__research_1_1glop_1_1StrictITIVector "operations_research::glop::StrictITIVector< IntType, T, Alloc >" </dt><dd> \anchor _todo000864 (user): This should probably move to StrongVector, but note that this version is stricter and does not allow any other size types. </dd> <dt> \_setscope operations_research::glop::TriangularMatrix Member \_internalref classoperations__research_1_1glop_1_1TriangularMatrix#ad5f38322fa7495d265b8a9d165e04661 "operations_research::glop::TriangularMatrix::AddAndNormalizeTriangularColumn" (const SparseColumn &column, RowIndex diagonal_row, Fractional diagonal_coefficient)</dt><dd> \anchor _todo000888 (user): use division by a constant using multiplication. </dd> <dt> \_setscope operations_research::glop::TriangularMatrix Member \_internalref classoperations__research_1_1glop_1_1TriangularMatrix#a73b763db84bea0b037a221f4f0a8b341 "operations_research::glop::TriangularMatrix::ComputeRowsToConsiderInSortedOrder" (RowIndexVector *non_zero_rows) const</dt><dd> \anchor _todo000891 (user): Investigate the best thresholds. </dd> <dt> \_setscope operations_research::glop::TriangularMatrix Member \_internalref classoperations__research_1_1glop_1_1TriangularMatrix#adbf1ad02396e91500821d368dcd2ed4a "operations_research::glop::TriangularMatrix::ComputeRowsToConsiderWithDfs" (RowIndexVector *non_zero_rows) const</dt><dd> \anchor _todo000890 (user): Investigate the best thresholds. </dd> <dt> \_setscope operations_research::glop::TriangularMatrix Member \_internalref classoperations__research_1_1glop_1_1TriangularMatrix#accd27fcf09dbc70b99c5ff3420df68ab "operations_research::glop::TriangularMatrix::PermutedLowerSparseSolve" (const ColumnView &rhs, const RowPermutation &row_perm, SparseColumn *lower, SparseColumn *upper)</dt><dd> \anchor _todo000889 (user): The size of lower is exact, so we could be slighly faster here. </dd> <dt> \_setscope operations_research::glop::UnconstrainedVariablePreprocessor Member \_internalref classoperations__research_1_1glop_1_1UnconstrainedVariablePreprocessor#a85bc81777e98efdcf8e96566dc7b34b5 "operations_research::glop::UnconstrainedVariablePreprocessor::RecoverSolution" (ProblemSolution *solution) const final</dt><dd> \anchor _todo000503 (user): In presence of free row, we must move them to 0. </dd> <dt> \_setscope operations_research::glop::UnconstrainedVariablePreprocessor Member \_internalref classoperations__research_1_1glop_1_1UnconstrainedVariablePreprocessor#ab9d32efc837e15a7512083c4e450d459 "operations_research::glop::UnconstrainedVariablePreprocessor::RemoveZeroCostUnconstrainedVariable" (ColIndex col, Fractional target_bound, LinearProgram *lp)</dt><dd> \anchor _todo000497 (user): Here, we may render the row free, so subsequent columns processed by the columns loop in Run() have more chance to be removed. However, we need to be more careful during the postsolve() if we do that. </dd> <dt> \_setscope operations_research::glop::UnconstrainedVariablePreprocessor Member \_internalref classoperations__research_1_1glop_1_1UnconstrainedVariablePreprocessor#a59fa9c1508a94256ea5cb1d79597d170 "operations_research::glop::UnconstrainedVariablePreprocessor::Run" (LinearProgram *lp) final</dt><dd> \anchor _todo000498 (user): Expose it as a parameter. We could rename both to preprocessor_low_tolerance and preprocessor_high_tolerance. \anchor _todo000499 (user): expose this as a parameter? IMO it isn't really needed as we shouldn't reach this limit except in corner cases. \anchor _todo000500 (user): deal with the more generic case. \anchor _todo000501 (user): this also works if the variable is integer, but we must choose an integer value during the post-solve. Implement this. \anchor _todo000502 (user): It should probably work with only small modification, investigate. </dd> <dt> \_setscope operations_research::glop::UpdateRow Member \_internalref classoperations__research_1_1glop_1_1UpdateRow#a83458aab35755e7f4e0f1a2b38c912c2 "operations_research::glop::UpdateRow::ComputeUnitRowLeftInverse" (RowIndex leaving_row)</dt><dd> \anchor _todo000610 (user): Refactorize if the estimated accuracy is above a threshold. </dd> <dt> \_setscope operations_research::glop::UpdateRow Member \_internalref classoperations__research_1_1glop_1_1UpdateRow#a87bff95c808ef1850684ba48f3bf044f "operations_research::glop::UpdateRow::ComputeUpdateRow" (RowIndex leaving_row)</dt><dd> \anchor _todo000611 (user): So far we didn't generalize the use of drop tolerances everywhere in the solver, so we make sure to not modify unit_row_left_inverse_ that is also used elsewhere. However, because of that, we will not get the exact same result depending on the algortihm used below because the ComputeUpdatesColumnWise() will still use these small entries (no complexity changes). \anchor _todo000612 (user): The impact is not as high as I hopped though, so not too important. \anchor _todo000613 (user): automate the computation of these constants at run-time? </dd> <dt> \_setscope operations_research::glop::UpdateRow Member \_internalref classoperations__research_1_1glop_1_1UpdateRow#a0574601e3d61bdd8bafbd8996c78516b "operations_research::glop::UpdateRow::GetCoefficients" () const</dt><dd> \anchor _todo000615 (user): Consider returning a packed vector of coefficient parallel to GetNonZeroPositions() instead. It should be fast to compute and iteration later should be quicker. </dd> <dt> \_setscope operations_research::glop::VariablesInfo Member \_internalref classoperations__research_1_1glop_1_1VariablesInfo#ad86973493f57542e9a1e926b2e1f5198 "operations_research::glop::VariablesInfo::EndDualPhaseI" (Fractional dual_feasibility_tolerance, DenseRow::ConstView reduced_costs)</dt><dd> \anchor _todo000622 (user): When there is a choice, use the previous status that might have been warm-started ? but then this is not high priority since warm-starting with a non-dual feasible basis seems unfrequent. </dd> <dt> \_setscope operations_research::glop::VariablesInfo Member \_internalref classoperations__research_1_1glop_1_1VariablesInfo#a2b7789e59bf13941d89cc6accd874fe1 "operations_research::glop::VariablesInfo::TransformToDualPhaseIProblem" (Fractional dual_feasibility_tolerance, DenseRow::ConstView reduced_costs)</dt><dd> \anchor _todo000625 (user): Shall we re-add the bound when the variable is moved out of the base? it is not needed, but might allow for more bound flips? </dd> <dt> \_setscope operations_research::glop::VariablesInfo Member \_internalref classoperations__research_1_1glop_1_1VariablesInfo#aa6ae2139d9427d7dc458a93e2f8b5588 "operations_research::glop::VariablesInfo::UpdateToBasicStatus" (ColIndex col)</dt><dd> \anchor _todo000618 (user): A bit annoying that we need to test this even if we don't use the dual. But the cost is minimal. </dd> <dt> \_setscope operations_research::glop::VariableValues Member \_internalref classoperations__research_1_1glop_1_1VariableValues#ab0a189867045312e53d3f0c88974e81e "operations_research::glop::VariableValues::RecomputeDualPrices" (bool put_more_importance_on_norm=false)</dt><dd> \anchor _todo000616 (user): On some problem like stp3d.mps or pds-100.mps, using different price like abs(infeasibility) / squared_norms give better result. Some solver switch according to a criteria like all entry are +1/-1, the column have no more than 24 non-zero and the average column size is no more than 6! Understand and implement some variant of this? I think the gain is mainly because of using sparser vectors? </dd> <dt> \_setscope operations_research::GLOPInterface Member \_internalref classoperations__research_1_1GLOPInterface#ac495bd550d8588e457e6998d9af89b53 "operations_research::GLOPInterface::SetDualTolerance" (double value) override</dt><dd> \anchor _todo000767 (user): Modify parameters_ with the correct value. The problem is that this is set by default by the wrapper to 1e-7 and for now we want to use higher default tolerances in Glop. </dd> <dt> \_setscope operations_research::GLOPInterface Member \_internalref classoperations__research_1_1GLOPInterface#a5e4f4b2a7b1140077d676a179a349dc3 "operations_research::GLOPInterface::SetPrimalTolerance" (double value) override</dt><dd> \anchor _todo000766 (user): Modify parameters_ with the correct value. The problem is that this is set by default by the wrapper to 1e-7 and for now we want to use higher default tolerances in Glop. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#a8244072bcb5c3ae1038d9c3f7be4bb8b "operations_research::GlopSolveProto" (LazyMutableCopy< MPModelRequest > request, std::atomic< bool > *interrupt_solve, std::function< void(const std::string &)> logging_callback)</dt><dd> \anchor _todo000807 (user): We do not support all the parameters here. In particular the logs before the solver is called will not be appended to the response. Fix that, and remove code duplication for the logger config. One way should be to not touch/configure anything if the logger is already created while calling SolveCpModel() and call a common config function from here or from inside Solve()? </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#a09ec441521b625aa6d45620f6b26d781 "operations_research::GlopToMPSolverResultStatus" (glop::ProblemStatus s)</dt><dd> \anchor _todo000768 (user): We could argue that it is infeasible to find the optimal of an unbounded problem. So it might just be simpler to completely get rid of the MpSolver::UNBOUNDED status that seems to never be used programmatically. </dd> <dt> \_setscope operations_research::GLPKInterface Member \_internalref classoperations__research_1_1GLPKInterface#a2a1e883d9de9f8d855a561dea457c8a4 "operations_research::GLPKInterface::ComputeExactConditionNumber" () const override</dt><dd> \anchor _todo000769 (user): support MIP. </dd> <dt> \_setscope operations_research::GraphSymmetryFinder Member \_internalref classoperations__research_1_1GraphSymmetryFinder#a42c71ed3bac0344dfe9964839806566b "operations_research::GraphSymmetryFinder::FindSymmetries" (std::vector< int > *node_equivalence_classes_io, std::vector< std::unique_ptr< SparsePermutation > > *generators, std::vector< int > *factorized_automorphism_group_size, TimeLimit *time_limit=nullptr)</dt><dd> \anchor _todo000011 (user): experiment with, and briefly describe the results of various algorithms for picking the invariant node: - random selection - highest/lowest degree first - enumerate by part index; or by part size - etc. \anchor _todo000012 (user): better elect the representative of each equivalence class in order to reduce the permutation support down the line \anchor _todo000013 \anchor _todo000014 (user): Don't build a list; but instead use direct, inline iteration on the representatives in the while() loop below, to benefit from the incremental merging of the equivalence classes. \anchor _todo000015 (user): better, more complete explanation. \anchor _todo000026 (user): verify the minimality in unit tests.</dd> <dt> \_setscope operations_research::GraphSymmetryFinder Member \_internalref classoperations__research_1_1GraphSymmetryFinder#af670a8f7f325e3a7431f2723c52ec25d "operations_research::GraphSymmetryFinder::GraphSymmetryFinder" (const Graph &graph, bool is_undirected)</dt><dd> \anchor _todo000025 (user): support multi-arcs. </dd> <dt> \_setscope operations_research::GraphSymmetryFinder Member \_internalref classoperations__research_1_1GraphSymmetryFinder#a70544105d8f21edcbed63fdd7f6d34ab "operations_research::GraphSymmetryFinder::RecursivelyRefinePartitionByAdjacency" (int first_unrefined_part_index, DynamicPartition *partition)</dt><dd> \anchor _todo000010 (user): We are really imprecise in our counting, but it is fine. We just need a way to enforce a deterministic limit on the computation effort. </dd> <dt> \_setscope operations_research::GreedySolutionGenerator Member \_internalref classoperations__research_1_1GreedySolutionGenerator#a0317564caf6b4d3d860bb635ff02c56e "operations_research::GreedySolutionGenerator::NextSolution" (const std::vector< SubsetIndex > &focus, const SubsetCostVector &costs)</dt><dd> \anchor _todo000039 (user): research more about the best value for Arity. </dd> <dt> \_setscope operations_research::GreedySolutionGenerator Member \_internalref classoperations__research_1_1GreedySolutionGenerator#ab50373b232711b27f49e7802c206d581 "operations_research::GreedySolutionGenerator::NextSolution" ()</dt><dd> \anchor _todo000050 (user): Add time-outs and exit with a partial solution. </dd> <dt> \_setscope operations_research::GScipConstraintHandlerContext Class \_internalref classoperations__research_1_1GScipConstraintHandlerContext "operations_research::GScipConstraintHandlerContext" </dt><dd> \anchor _todo000743 (user): Add support for branching. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#a8fbf8182ca5ad94ee75198ac1885d798 "operations_research::GScipCreateMaximum" (GScip *gscip, const GScipLinearExpr &resultant, const std::vector< GScipLinearExpr > &terms, absl::string_view name)</dt><dd> \anchor _todo000747 (user): it may be better to write this in terms of the disjuntive constraint, we need to support disjunctions in gscip.h to do this.</dd> <dt> \_setscope operations_research::GScipEventHandler Member \_internalref classoperations__research_1_1GScipEventHandler#a55733bd35aafd3ae06df04760d7fe05d "operations_research::GScipEventHandler::CatchEvent" (SCIP_EVENTTYPE event_type)</dt><dd> \anchor _todo000745 (user): Support Var and Row events. \anchor _todo000746 (user): Support registering events in the EVENTINITSOL callback, which would cause them to be trapped only after presolve. </dd> <dt> \_setscope operations_research::GScipLinearExpr Struct \_internalref structoperations__research_1_1GScipLinearExpr "operations_research::GScipLinearExpr" </dt><dd> \anchor _todo000749 (user): delete this type and the methods below, use a generic version templated on the variable type that supports operator overloads. </dd> <dt> \_setscope operations_research::GuidedTabuSearch Member \_internalref classoperations__research_1_1GuidedTabuSearch#a130652dacbe5fae193481444dcc4354f "operations_research::GuidedTabuSearch::NextSolution" (absl::Span< const SubsetIndex > focus, int num_iterations)</dt><dd> \anchor _todo000042 (user): make the cost computation incremental. </dd> <dt> \_setscope operations_research::GuidedTabuSearch Member \_internalref classoperations__research_1_1GuidedTabuSearch#a276460a461462ece00e2b69a4ba0cc75 "operations_research::GuidedTabuSearch::SetLagrangianFactor" (double factor)</dt><dd> \anchor _todo000053 (user): re-introduce this is the code. It was used to favor subsets with the same marginal costs but that would cover more elements. But first, see if it makes sense to compute it. </dd> <dt> \_setscope operations_research::GurobiInterface Member \_internalref classoperations__research_1_1GurobiInterface#a47ea0f16d10d18c841917b6ab3695094 "operations_research::GurobiInterface::ClearConstraint" (MPConstraint *constraint) override</dt><dd> \anchor _todo000774 (user): this is difficult to make incremental, like SetConstraintBounds(), because of the auxiliary Gurobi variables that range constraints introduce. </dd> <dt> \_setscope operations_research::GurobiInterface Member \_internalref classoperations__research_1_1GurobiInterface#a80f01ad50450397a74e29c3db67ff69c "operations_research::GurobiInterface::ComputeExactConditionNumber" () const override</dt><dd> \anchor _todo000777 (user): Not yet working. </dd> <dt> \_setscope operations_research::GurobiInterface Member \_internalref classoperations__research_1_1GurobiInterface#abdc377748278a3c5c35a847bfd146a31 "operations_research::GurobiInterface::NextSolution" () override</dt><dd> \anchor _todo000776 (user): This reset may not be necessary, investigate. </dd> <dt> \_setscope operations_research::GurobiInterface Member \_internalref classoperations__research_1_1GurobiInterface#a7862478121ae29647bf0a12ff9ef5ed7 "operations_research::GurobiInterface::Reset" () override</dt><dd> \anchor _todo000771 - b/328604189: Fix logging issue upstream, switch to a different API for copying parameters, or avoid calling Reset() in more places. </dd> <dt> \_setscope operations_research::GurobiInterface Member \_internalref classoperations__research_1_1GurobiInterface#a3151b55e2c525025b89ce0c01cdf52be "operations_research::GurobiInterface::SetCoefficient" (MPConstraint *constraint, const MPVariable *variable, double new_value, double old_value) override</dt><dd> \anchor _todo000773 (user): investigate if this has bad performance. </dd> <dt> \_setscope operations_research::GurobiInterface Member \_internalref classoperations__research_1_1GurobiInterface#a937c9e7503e0bc746f8fa40c7591f16a "operations_research::GurobiInterface::SetConstraintBounds" (int row_index, double lb, double ub) override</dt><dd> \anchor _todo000772 (user): this is nontrivial to make incremental: 1. Make sure it is a linear constraint (not an indicator or indicator range constraint). 2. Check if the sense of the constraint changes. If it was previously a range constraint, we can do nothing, and if it becomes a range constraint, we can do nothing. We could support range constraints if we tracked the auxiliary variable that is added with range constraints. </dd> <dt> \_setscope operations_research::GurobiInterface Member \_internalref classoperations__research_1_1GurobiInterface#a3fdaaef4033cbc2f6e0ef07ade784682 "operations_research::GurobiInterface::Solve" (const MPSolverParameters &param) override</dt><dd> \anchor _todo000775 (user): We could introduce our own "infeasible or unbounded" status. </dd> <dt> \_setscope operations_research::HamiltonianPathSolver Member \_internalref classoperations__research_1_1HamiltonianPathSolver#a3f13afbdf8f0e7c748ba80de7859e803 "operations_research::HamiltonianPathSolver< CostType, CostFunction >::Integer" </dt><dd> \anchor _todo000660 (user): remove this limitation by using pruning techniques. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#aee1401375b23909949cce272a3b787db "operations_research::Hash1" (uint64_t value)</dt><dd> \anchor _todo000166 (user): use murmurhash. </dd> <dt> \_setscope operations_research::HighsInterface Member \_internalref classoperations__research_1_1HighsInterface#aa0445eec4920c34b74fb03b837ff15b0 "operations_research::HighsInterface::column_status" (int variable_index) const override</dt><dd> \anchor _todo000780 (user): While basis status isn't well defined for PDLP, we could guess statuses that might be useful. </dd> <dt> \_setscope operations_research::HighsInterface Member \_internalref classoperations__research_1_1HighsInterface#a0b4fdd0d963276c0deca473d6b4b36a5 "operations_research::HighsInterface::row_status" (int constraint_index) const override</dt><dd> \anchor _todo000779 (user): While basis status isn't well defined for PDLP, we could guess statuses that might be useful. </dd> <dt> \_setscope operations_research::HighsInterface Member \_internalref classoperations__research_1_1HighsInterface#a9423aab732ca4e92e3640bd534e92023 "operations_research::HighsInterface::underlying_solver" () override</dt><dd> \anchor _todo000781 (user): Consider returning the SolveLog here, as it could be essential for interpreting the PDLP solution. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#a977d36998909629c22521663e46a33ce "operations_research::HighsSolveProto" (LazyMutableCopy< MPModelRequest > request)</dt><dd> \anchor _todo000809 (user): Set model name. \anchor _todo000810 (user): Support variable names. \anchor _todo000811 \anchor _todo000812 (user): Support hints. \anchor _todo000813 (user): Support constraint names. \anchor _todo000814 (user): report feasible status. </dd> <dt> \_setscope operations_research::InsertionSequenceContainer Member \_internalref classoperations__research_1_1InsertionSequenceContainer#a2d8c1748584bee64a6e1963605863c6b "operations_research::InsertionSequenceContainer::RemoveIf" (const std::function< bool(const InsertionSequence &)> &p)</dt><dd> \anchor _todo000386 (user): Benchmark this against std::swap(). </dd> <dt> \_setscope operations_research::InsertionSequenceContainer Member \_internalref classoperations__research_1_1InsertionSequenceContainer#a7d4b83eb22546e3c1079283001dfe0d3 "operations_research::InsertionSequenceContainer::Sort" ()</dt><dd> \anchor _todo000387 (user): benchmark this against other ways to get insertion sequence in order, for instance sorting by index, separating {cost, index}, making a heap. </dd> <dt> \_setscope operations_research::IntegerPriorityQueue Member \_internalref classoperations__research_1_1IntegerPriorityQueue#a660816e2b5398fc18dd92a58327f630c "operations_research::IntegerPriorityQueue< Element, Compare >::Clear" ()</dt><dd> \anchor _todo002451 (user): we could make this sparse if it is needed. </dd> <dt> \_setscope operations_research::internal Namespace \_internalref namespaceoperations__research_1_1internal "operations_research::internal" </dt><dd> \anchor _todo000034 (user): Support arbitrary types with an int() or other numerical getter. (user): Support the user providing already-allocated memory buffers for the radix counts and/or for the temporary vector<T> copy. \anchor _todo000667 (user): introduce an enum to choose the algorithm. It's useless as long as this file only provides Yen. </dd> <dt> \_setscope operations_research::IntersectingSubsetsIterator Class \_internalref classoperations__research_1_1IntersectingSubsetsIterator "operations_research::IntersectingSubsetsIterator" </dt><dd> \anchor _todo000071 (user): Add the possibility for range-for loops. </dd> <dt> \_setscope operations_research::IntVar Member \_internalref classoperations__research_1_1IntVar#af3c6b509b9279db09301192b57dfb3cd "operations_research::IntVar::RemoveValues" (const std::vector< int64_t > &values)</dt><dd> \anchor _todo000199 (user): Check and maybe inline this code. \anchor _todo000200 (user) : Sort values! </dd> <dt> \_setscope operations_research::IntVar Member \_internalref classoperations__research_1_1IntVar#a3b3b2ee0dc78430a3008c0894531196f "operations_research::IntVar::SetValues" (const std::vector< int64_t > &values)</dt><dd> \anchor _todo000201 (user): use a clean and safe SortedUniqueCopy() class that uses a global, static shared (and locked) storage. \anchor _todo000202 \anchor _todo000203 (user): [optional] consider porting STLSortAndRemoveDuplicates from ortools/base/stl_util.h to the existing base/stl_util.h and using it here. \anchor _todo000204 \anchor _todo000205 (user): We could filter out values not in the var. \anchor _todo000206 (user) : We could find the first position >= vmin by dichotomy. </dd> <dt> \_setscope operations_research::IntVarFilteredDecisionBuilder Class \_internalref classoperations__research_1_1IntVarFilteredDecisionBuilder "operations_research::IntVarFilteredDecisionBuilder" </dt><dd> \anchor _todo000384 (user): Eventually move this to the core CP solver library when the code is mature enough. </dd> <dt> \_setscope operations_research::IntVarLocalSearchOperator Member \_internalref classoperations__research_1_1IntVarLocalSearchOperator#ac8bc688def85b27b6aa66e1f099050a4 "operations_research::IntVarLocalSearchOperator::MakeOneNeighbor" ()</dt><dd> \anchor _todo000168 (user): make it pure virtual, implies porting all apps overriding MakeNextNeighbor() in a subclass of IntVarLocalSearchOperator. \anchor _todo000229 (user): Make this a pure virtual. </dd> <dt> \_setscope operations_research::KnapsackAssignment Struct \_internalref structoperations__research_1_1KnapsackAssignment "operations_research::KnapsackAssignment" </dt><dd> \anchor _todo000031 (user): Add a new propagator class for conflict constraint. (user): Add a new propagator class used as a guide when the problem has several dimensions. </dd> <dt> \_setscope operations_research::KnapsackBruteForceSolver Member \_internalref classoperations__research_1_1KnapsackBruteForceSolver#a0b4c315873262155800b2645fdab0535 "operations_research::KnapsackBruteForceSolver::Init" (const std::vector< int64_t > &profits, const std::vector< std::vector< int64_t > > &weights, const std::vector< int64_t > &capacities) override</dt><dd> \anchor _todo000030 (user): Implement multi-dimensional brute force solver. </dd> <dt> \_setscope operations_research::KnapsackCapacityPropagator Member \_internalref classoperations__research_1_1KnapsackCapacityPropagator#af1d7d1e175e652c64962af490ab42247 "operations_research::KnapsackCapacityPropagator::ComputeProfitBounds" () override</dt><dd> \anchor _todo000029 (user): Make it more incremental, by saving the break item in a search node for instance. </dd> <dt> \_setscope operations_research::KnapsackGenericSolver Class \_internalref classoperations__research_1_1KnapsackGenericSolver "operations_research::KnapsackGenericSolver" </dt><dd> \anchor _todo000032 (user): In the case of a multi-dimensional knapsack problem, implement an aggregated propagator to combine all dimensions and give a better guide to select the next item (see, for instance, Dobson's aggregated efficiency). </dd> <dt> \_setscope operations_research::KnapsackInterface Member \_internalref classoperations__research_1_1KnapsackInterface#ac5b423c249b7d295b22cd367d60a915a "operations_research::KnapsackInterface::column_status" (int variable_index) const override</dt><dd> \anchor _todo000785 (user): set properly. </dd> <dt> \_setscope operations_research::KnapsackInterface Member \_internalref classoperations__research_1_1KnapsackInterface#a91cb6e2a4e0c037e5ce12887e13d5a11 "operations_research::KnapsackInterface::row_status" (int constraint_index) const override</dt><dd> \anchor _todo000784 (user): set properly. </dd> <dt> \_setscope operations_research::KnapsackInterface Member \_internalref classoperations__research_1_1KnapsackInterface#ad8e2065e33ed1870e473b6f296a93cba "operations_research::KnapsackInterface::Solve" (const MPSolverParameters &param) override</dt><dd> \anchor _todo000783 (user): Refine Analysis of the model to choose better solvers. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#ab9fe416cbd44278b17d42994d948b84d "operations_research::kSetCoverAlignmentInBytes" </dt><dd> \anchor _todo000070 (user): improve the code to make it possible to use unaligned memory. </dd> <dt> \_setscope operations_research::KShortestPaths Member \_internalref structoperations__research_1_1KShortestPaths#a48077b0ff26a88c2df6d985eb2a8b6f7 "operations_research::KShortestPaths::paths" </dt><dd> \anchor _todo000671 (user): what about vectors of arcs? That might be faster (potentially, add a function to transform it into a vector of nodes if the user really needs it). It would also have the nice benefit of removing the need for <tt>distances</tt> (compute it on the fly), with a reference to the graph and the costs. </dd> <dt> \_setscope operations_research::KShortestPathsOnDagWrapper Member \_internalref classoperations__research_1_1KShortestPathsOnDagWrapper#a2ceb0df92d0ba23cb3496ef96475dfa3 "operations_research::KShortestPathsOnDagWrapper< GraphType >::KShortestPathsOnDagWrapper" (const GraphType *graph, const std::vector< double > *arc_lengths, absl::Span< const NodeIndex > topological_order, int path_count)</dt><dd> \anchor _todo000635 (b/332475713): Optimize if reverse graph is already provided in <tt>GraphType</tt>. </dd> <dt> \_setscope operations_research::LatticeMemoryManager Member \_internalref classoperations__research_1_1LatticeMemoryManager#af1eb6109d2fbc58a4f9709fc12472100 "operations_research::LatticeMemoryManager< Set, CostType >::BaseOffset" (int card, Set s) const</dt><dd> \anchor _todo000654 (user): Evaluate the interest of the above. There are 'card' f(set, j) to store. That is why we need to multiply local_offset by card before adding it to the corresponding base_offset_. \anchor _todo000659 (user): Investigate how to compute BaseOffset(card - 1, s \ { n }) from BaseOffset(card, n) to speed up the DP iteration. </dd> <dt> \_setscope operations_research::LightPairRelocateOperator Class \_internalref classoperations__research_1_1LightPairRelocateOperator "operations_research::LightPairRelocateOperator" </dt><dd> \anchor _todo000357 (user): Add a version which inserts the first node before the other pair's first node; there are many redundant neighbors if done blindly. </dd> <dt> \_setscope operations_research::LightPairRelocateOperator Member \_internalref classoperations__research_1_1LightPairRelocateOperator#ab5a8f9eadcc60ebb142f301ad0206f45 "operations_research::LightPairRelocateOperator::MakeNeighbor" () override</dt><dd> \anchor _todo000350 (user): extend to relocating before the start of sub-tours (when all pairs have been matched). \anchor _todo000351 (user): Add support for lifo for neighbor-based move. </dd> <dt> \_setscope operations_research::LinearExpr Member \_internalref classoperations__research_1_1LinearExpr#ac387e7f248b39ad0c52ad355fa646696 "operations_research::LinearExpr::ToString" () const</dt><dd> \anchor _todo000786 (user): support optionally cropping long strings. </dd> <dt> \_setscope operations_research::LocalCheapestInsertionFilteredHeuristic Member \_internalref classoperations__research_1_1LocalCheapestInsertionFilteredHeuristic#a17ef6d7c3d54257ff4089b5d131a65e3 "operations_research::LocalCheapestInsertionFilteredHeuristic::LocalCheapestInsertionFilteredHeuristic" (RoutingModel *model, std::function< bool()> stop_search, std::function< int64_t(int64_t, int64_t, int64_t)> evaluator, RoutingSearchParameters::PairInsertionStrategy pair_insertion_strategy, LocalSearchFilterManager *filter_manager, BinCapacities *bin_capacities=nullptr, std::function< bool(const std::vector< RoutingModel::VariableValuePair > &, std::vector< RoutingModel::VariableValuePair > *)> optimize_on_insertion=nullptr)</dt><dd> \anchor _todo000373 (user): Add support for penalty costs. </dd> <dt> \_setscope operations_research::LocalDimensionCumulOptimizer Member \_internalref classoperations__research_1_1LocalDimensionCumulOptimizer#a30f6536c9b12eb7d0c6bcba75c50b158 "operations_research::LocalDimensionCumulOptimizer::LocalDimensionCumulOptimizer" (const RoutingDimension *dimension, RoutingSearchParameters::SchedulingSolver solver_type)</dt><dd> \anchor _todo000340 (user): Instead of passing false, detect if the relaxation will always violate the MIPL constraints. </dd> <dt> \_setscope operations_research::LocalSearch Member \_internalref classoperations__research_1_1LocalSearch#a60a6c0d04aae31557a3f80a43e578c1d "operations_research::LocalSearch::LocalSearch" (const std::vector< IntVar * > &vars, IntVar *objective, SolutionPool *pool, DecisionBuilder *first_solution, LocalSearchOperator *ls_operator, DecisionBuilder *sub_decision_builder, RegularLimit *limit, LocalSearchFilterManager *filter_manager)</dt><dd> \anchor _todo000253 (user): find a way to not have to pass vars here: redundant with variables in operators </dd> <dt> \_setscope operations_research::LocalSearch Member \_internalref classoperations__research_1_1LocalSearch#aad8272c1b2ace102d8ee023e3dbbc92e "operations_research::LocalSearch::Next" (Solver *solver) override</dt><dd> \anchor _todo000248 (user): abstract this from the local search part (user): handle the case where the tree depth is not enough to hold all solutions. \anchor _todo000249 (user): Find a way to make this balancing invisible to the user (no increase in branch or fail counts for instance). </dd> <dt> \_setscope operations_research::LocalSearchFilter Member \_internalref classoperations__research_1_1LocalSearchFilter#a7ba0d3a0fab70da68c44fcc603b29bc9 "operations_research::LocalSearchFilter::Accept" (const Assignment *delta, const Assignment *deltadelta, int64_t objective_min, int64_t objective_max)=0</dt><dd> \anchor _todo000172 (user): Remove arguments when there are no more need for those. </dd> <dt> \_setscope operations_research::LocalSearchFilterManager Member \_internalref classoperations__research_1_1LocalSearchFilterManager#af14f814b5f03c25c7a5c34ea2e850931 "operations_research::LocalSearchFilterManager::Accept" (LocalSearchMonitor *monitor, const Assignment *delta, const Assignment *deltadelta, int64_t objective_min, int64_t objective_max)</dt><dd> \anchor _todo000239 (user): the behaviour of Accept relies on the initial order of filters having at most one filter with negative objective values, this could be fixed by having filters return their general bounds. \anchor _todo000240 (user): handle objective min. </dd> <dt> \_setscope operations_research::LocalSearchMonitor Member \_internalref classoperations__research_1_1LocalSearchMonitor#a0c4974eabff96027f2732bd11aa6acb8 "operations_research::LocalSearchMonitor::LocalSearchMonitor" (Solver *solver)</dt><dd> \anchor _todo000173 (user): Add monitoring of local search filters. </dd> <dt> \_setscope operations_research::LocalSearchOperator Class \_internalref classoperations__research_1_1LocalSearchOperator "operations_research::LocalSearchOperator" </dt><dd> \anchor _todo000167 (user): rename Start to Synchronize ? (user): decouple the iterating from the defining of a neighbor. </dd> <dt> \_setscope operations_research::LocalSearchState Member \_internalref classoperations__research_1_1LocalSearchState#ab21fa79fdab637a71137bfb392c3bc42 "operations_research::LocalSearchState::Commit" ()</dt><dd> \anchor _todo000238 (user): When the class has more users, find a threshold ratio of saved/total domains under which a sparse clear would be more efficient for both Commit() and Revert(). </dd> <dt> \_setscope operations_research::LocationContainer Member \_internalref classoperations__research_1_1LocationContainer#ad936b94007fe596c6ac61668da043262 "operations_research::LocationContainer::SameLocationFromIndex" (int64_t node1, int64_t node2) const</dt><dd> \anchor _todo001064 (user): Fetch proper indices from routing model. </dd> <dt> \_setscope operations_research::MakeActiveOperator Member \_internalref classoperations__research_1_1MakeActiveOperator#a7600694afcf25f72395f32bfea5b0b6d "operations_research::MakeActiveOperator::MakeNeighbor" () override</dt><dd> \anchor _todo000232 (user): Add support for neighbors of inactive nodes; would require having a version without base nodes (probably not a PathOperator). </dd> <dt> \_setscope operations_research::MakePairActiveOperator Class \_internalref classoperations__research_1_1MakePairActiveOperator "operations_research::MakePairActiveOperator" </dt><dd> \anchor _todo000356 (user): Add option to prune neighbords where the order of node pairs is violated (ie precedence between pickup and delivery nodes). (user): Move this to local_search.cc if it's generic enough. (user): Detect pairs automatically by parsing the constraint model; we could then get rid of the pair API in the RoutingModel class. </dd> <dt> \_setscope operations_research::MakeRelocateNeighborsOperator Class \_internalref classoperations__research_1_1MakeRelocateNeighborsOperator "operations_research::MakeRelocateNeighborsOperator" </dt><dd> \anchor _todo000354 (user): Consider merging with standard Relocate in local_search.cc. </dd> <dt> \_setscope operations_research::MakeRelocateNeighborsOperator Member \_internalref classoperations__research_1_1MakeRelocateNeighborsOperator#a68fcef23cc239d8bc9f7864595a05d5e "operations_research::MakeRelocateNeighborsOperator::MakeNeighbor" () override</dt><dd> \anchor _todo000349 (user): Add a parameter to either return false or break here, depending if we want to permutate nodes within the same chain. </dd> <dt> \_setscope operations_research::math_opt Namespace \_internalref namespaceoperations__research_1_1math__opt "operations_research::math_opt" </dt><dd> \anchor _todo000964 (b/178702980): this should not be needed IWYU pragma: no_include <type_traits> \anchor _todo001000 (b/272767311): initial basis, more precise returned basis. * Starting solution * (b/271104776): Returning rays </dd> <dt> \_setscope operations_research::math_opt Member \_internalref namespaceoperations__research_1_1math__opt#ab2cf3d362a53b88af5478096e7b70534 "operations_research::math_opt::≤" (variable bounds) TEST_P(InfeasibleSubsystemTest</dt><dd> \anchor _todo000950 (b/227217735): Test ranged quadratic constraints when supported. </dd> <dt> \_setscope operations_research::math_opt Member \_internalref namespaceoperations__research_1_1math__opt#ae492beecf00c5bcfab49f0eb64bd5467 "operations_research::math_opt::ApplyAllFilters" (const ModelSolveParametersProto &model_solve_params, SolutionProto &solution)</dt><dd> \anchor _todo000914 (b/261603235): this function is not very efficient, decide if this matters. </dd> <dt> \_setscope operations_research::math_opt::BaseSolver Class \_internalref classoperations__research_1_1math__opt_1_1BaseSolver "operations_research::math_opt::BaseSolver" </dt><dd> \anchor _todo000910 : b/350984134 - Rename <tt>Solver</tt> into <tt>InProcessSolver</tt> and then rename <tt>BaseSolver</tt> into <tt>Solver</tt>. </dd> <dt> \_setscope operations_research::math_opt Member \_internalref namespaceoperations__research_1_1math__opt#abd2e26542d0c64cb9bdb653e943cd892 "operations_research::math_opt::CheckIdsSubset" (absl::Span< const int64_t > ids, const IdNameBiMap &universe, std::optional< int64_t > upper_bound)</dt><dd> \anchor _todo001033 (b/232526223): try merge this with the CheckIdsSubset overload below, or at least have one call the other. </dd> <dt> \_setscope operations_research::math_opt Member \_internalref namespaceoperations__research_1_1math__opt#a614c1a306a138f7593f4ae84dbf034c9 "operations_research::math_opt::FeasibleTerminationProto" (const bool is_maximize, const LimitProto limit, const double primal_objective, const std::optional< double > optional_dual_objective, const absl::string_view detail)</dt><dd> \anchor _todo000917 (b/290359402): Consider improving to require a finite dual bound when dual feasible solutions are returned. </dd> <dt> \_setscope operations_research::math_opt Member \_internalref namespaceoperations__research_1_1math__opt#ad41bc1edd376b9ab7c3182d9a7b35e87 "operations_research::math_opt::FilterSparseVector" (const SparseDoubleVectorProto &input, const SparseVectorFilterProto &filter)</dt><dd> \anchor _todo000913 (b/261603235): this function is not very efficient, decide if this matters. </dd> <dt> \_setscope operations_research::math_opt Member \_internalref namespaceoperations__research_1_1math__opt#a635b90e2d284268536fc4bd2a4ce2ac4 "operations_research::math_opt::GetObjectiveBounds" (const SolveResultProto &solve_result)</dt><dd> \anchor _todo000911 (b/290091715): Remove once solve_stats.best_primal/dual_bound is removed and we know termination.objective_bounds will always be present. </dd> <dt> \_setscope operations_research::math_opt Member \_internalref namespaceoperations__research_1_1math__opt#a5e3e49ddac3e4cb09a02f02e4fe83019 "operations_research::math_opt::GetProblemStatus" (const SolveResultProto &solve_result)</dt><dd> \anchor _todo000912 (b/290091715): Remove once solve_stats.problem_status is removed and we know termination.problem_status will always be present. </dd> <dt> \_setscope operations_research::math_opt::GlpkSolver Member \_internalref classoperations__research_1_1math__opt_1_1GlpkSolver#a862eb62a5ed02916d9ae0ddabe46ac08 "operations_research::math_opt::GlpkSolver::Solve" (const SolveParametersProto &parameters, const ModelSolveParametersProto &model_parameters, MessageCallback message_cb, const CallbackRegistrationProto &callback_registration, Callback cb, const SolveInterrupter *interrupter) override</dt><dd> \anchor _todo000970 (b/187027049): glp_intopt with presolve off requires an optional solution of the relaxed problem. Here we simply always enable pre-solve but we should support disabling the presolve and call glp_simplex() in that case. \anchor _todo000971 (b/259557110): the emptiness is tested by glp_interior() after some pre-processing (including removing fixed variables). The current IsEmpty() is thus not good enough to deal with all cases. \anchor _todo000972 (b/187027049): add solver specific parameters for glp_iptcp.ord_alg. \anchor _todo000973 (b/187027049): add option to use glp_exact(). \anchor _todo000974 (b/187027049): compute the dual value when the dual is feasible (or problem optimal for interior point) based on the bounds and the dual values for LPs. </dd> <dt> \_setscope operations_research::math_opt::GScipSolver Member \_internalref classoperations__research_1_1math__opt_1_1GScipSolver#a91f57e875b852057eeaf6eeb837d1613 "operations_research::math_opt::GScipSolver::Update" (const ModelUpdateProto &model_update) override</dt><dd> \anchor _todo000982 (b/215722113): maybe we could use SCIPaddCoefLinear() for sub-matrix 1. </dd> <dt> \_setscope operations_research::math_opt::GurobiSolver Member \_internalref classoperations__research_1_1math__opt_1_1GurobiSolver#af25c8f69567b57e9e04f737af5937e84 "operations_research::math_opt::GurobiSolver::ComputeInfeasibleSubsystem" (const SolveParametersProto &parameters, MessageCallback message_cb, const SolveInterrupter *interrupter) override</dt><dd> \anchor _todo000997 (b/277339044): Remove code duplication with GurobiSolver::Solve(). \anchor _todo000998 (b/277246682): ensure that resetting parameters does not degrade incrementalism performance. </dd> <dt> \_setscope operations_research::math_opt::GurobiSolver Member \_internalref classoperations__research_1_1math__opt_1_1GurobiSolver#aa521c1122a7faae79b63abea4a039cd2 "operations_research::math_opt::GurobiSolver::Solve" (const SolveParametersProto &parameters, const ModelSolveParametersProto &model_parameters, MessageCallback message_cb, const CallbackRegistrationProto &callback_registration, Callback cb, const SolveInterrupter *interrupter) override</dt><dd> \anchor _todo000996 (b/277246682): ensure that resetting parameters does not degrade incrementalism performance. </dd> <dt> \_setscope operations_research::math_opt::HighsSolver Member \_internalref classoperations__research_1_1math__opt_1_1HighsSolver#a2ae5ff0de74ce55a8dc383175021d11b "operations_research::math_opt::HighsSolver::New" (const ModelProto &model, const InitArgs &init_args)</dt><dd> \anchor _todo001003 (b/271595607): once HiGHS is updated, check if the unrounded bounds cross instead. \anchor _todo001004 (b/271595607): once HiGHS is updated, pass the original bound, not the rounded bound. </dd> <dt> \_setscope operations_research::math_opt::HighsSolver Member \_internalref classoperations__research_1_1math__opt_1_1HighsSolver#a379b28def41c16cfc6c404dac890ddbe "operations_research::math_opt::HighsSolver::Solve" (const SolveParametersProto &parameters, const ModelSolveParametersProto &model_parameters, MessageCallback message_cb, const CallbackRegistrationProto &callback_registration, Callback cb, const SolveInterrupter *interrupter) override</dt><dd> \anchor _todo001005 (b/271595607): delete this code once we upgrade HiGHS, if HiGHS does return a proper infeasibility status for models with empty integer bounds. </dd> <dt> \_setscope operations_research::math_opt::internal Member \_internalref namespaceoperations__research_1_1math__opt_1_1internal#aa5b5865fba481a062135fc78e632b85c "operations_research::math_opt::internal::CheckIdsRangeAndStrictlyIncreasing2" (absl::Span< const int64_t > ids)</dt><dd> \anchor _todo000919 (b/232526223): this is an exact copy of CheckIdsRangeAndStrictlyIncreasing from ids_validator.h, find a way to share the code. </dd> <dt> \_setscope operations_research::math_opt::internal::IncrementalSolverImpl Member \_internalref classoperations__research_1_1math__opt_1_1internal_1_1IncrementalSolverImpl#a378d81b16d667bc8b2f534c6549000b2 "operations_research::math_opt::internal::IncrementalSolverImpl::ComputeInfeasibleSubsystem" (const ComputeInfeasibleSubsystemArguments &arguments) override</dt><dd> \anchor _todo000933 : b/260337466 - Add permanent errors and concurrency protection. </dd> <dt> \_setscope operations_research::math_opt::internal::IncrementalSolverImpl Member \_internalref classoperations__research_1_1math__opt_1_1internal_1_1IncrementalSolverImpl#ae411aebc76f692bbca9c93ed22ab25d7 "operations_research::math_opt::internal::IncrementalSolverImpl::ComputeInfeasibleSubsystemWithoutUpdate" (const ComputeInfeasibleSubsystemArguments &arguments) const override</dt><dd> \anchor _todo000936 : b/260337466 - Add permanent errors and concurrency protection. </dd> <dt> \_setscope operations_research::math_opt::internal::IncrementalSolverImpl Member \_internalref classoperations__research_1_1math__opt_1_1internal_1_1IncrementalSolverImpl#a07dcb34f0dd810e54bb83f85bb60b58c "operations_research::math_opt::internal::IncrementalSolverImpl::Solve" (const SolveArguments &arguments) override</dt><dd> \anchor _todo000932 : b/260337466 - Add permanent errors and concurrency protection. </dd> <dt> \_setscope operations_research::math_opt::internal::IncrementalSolverImpl Member \_internalref classoperations__research_1_1math__opt_1_1internal_1_1IncrementalSolverImpl#a54daa57285b6a528ca4a7ee8175a254a "operations_research::math_opt::internal::IncrementalSolverImpl::SolveWithoutUpdate" (const SolveArguments &arguments) const override</dt><dd> \anchor _todo000935 : b/260337466 - Add permanent errors and concurrency protection. </dd> <dt> \_setscope operations_research::math_opt::internal::IncrementalSolverImpl Member \_internalref classoperations__research_1_1math__opt_1_1internal_1_1IncrementalSolverImpl#a36a242cc2d29b0ab2f0316b5b8f469be "operations_research::math_opt::internal::IncrementalSolverImpl::Update" () override</dt><dd> \anchor _todo000934 : b/260337466 - Add permanent errors and concurrency protection. </dd> <dt> \_setscope operations_research::math_opt::InvalidInputTest Class \_internalref classoperations__research_1_1math__opt_1_1InvalidInputTest "operations_research::math_opt::InvalidInputTest" </dt><dd> \anchor _todo000951 (b/172553545): this test should not be repeated for each solver since it tests that the Solver class validates the model before calling the interface. </dd> <dt> \_setscope operations_research::math_opt Member \_internalref namespaceoperations__research_1_1math__opt#af9843a1d7731647c94c6a7ae14cdd2da "operations_research::math_opt::IsOptimal" (const std::optional< double > expected_primal_objective, const double tolerance)</dt><dd> \anchor _todo000925 (b/309658404): Note the bounds should be at least finite once we validate this. </dd> <dt> \_setscope operations_research::math_opt Member \_internalref namespaceoperations__research_1_1math__opt#a290702c59542e55a40bc415231596028 "operations_research::math_opt::LimitIs" (Limit limit, testing::Matcher< std::string > detail_matcher=testing::_)</dt><dd> \anchor _todo000924 : b/343234961 - Maybe change the name and sync the signatures/features. </dd> <dt> \_setscope operations_research::math_opt Member \_internalref namespaceoperations__research_1_1math__opt#ac307abe62a9d26ff0eac456704d950b6 "operations_research::math_opt::LimitTerminationProto" (LimitProto limit, const double primal_objective, const double dual_objective, const bool claim_dual_feasible_solution_exists, const absl::string_view detail)</dt><dd> \anchor _todo000918 (b/290359402): Consider improving to require a finite dual bound when dual feasible solutions are returned. </dd> <dt> \_setscope operations_research::math_opt::LinearExpression Class \_internalref classoperations__research_1_1math__opt_1_1LinearExpression "operations_research::math_opt::LinearExpression" </dt><dd> \anchor _todo000943 (b/169415098): add a function to remove zero terms. (b/169415834): study if exact zeros should be automatically removed. (b/169415103): add tests that some expressions don't compile. </dd> <dt> \_setscope operations_research::math_opt::LpIncompleteSolveTestParams Struct \_internalref structoperations__research_1_1math__opt_1_1LpIncompleteSolveTestParams "operations_research::math_opt::LpIncompleteSolveTestParams" </dt><dd> \anchor _todo000956 (b/195295177): Consider splitting LpIncompleteSolveTest into simplex and non-simplex tests to avoid repetition and need to input irrelevant bools from LpIncompleteSolveTestParams when instantiating tests. </dd> <dt> \_setscope operations_research::math_opt Member \_internalref namespaceoperations__research_1_1math__opt#a5d8c9048c51c1bc6685751a7cb8514fe "operations_research::math_opt::MathOptModelToMPModelProto" (const ::operations_research::math_opt::ModelProto &model)</dt><dd> \anchor _todo000945 (user): use the constraint iterator from scip_solver.cc here. </dd> <dt> \_setscope operations_research::math_opt::Model Member \_internalref classoperations__research_1_1math__opt_1_1Model#a06cd12d3df5d04b34fde1050692bc46a "operations_research::math_opt::Model::storage" () const</dt><dd> \anchor _todo000929 (user): expose a way to efficiently iterate through the nonzeros of the linear constraint matrix. </dd> <dt> \_setscope operations_research::math_opt::Model Member \_internalref classoperations__research_1_1math__opt_1_1Model#a737b42a14db864ac3afa891ecb212688 "operations_research::math_opt::Model::ValidateExistingLinearConstraintOfThisModel" (LinearConstraint linear_constraint) const</dt><dd> \anchor _todo000928 (b/239810718): use << for LinearConstraint once it does not CHECK. </dd> <dt> \_setscope operations_research::math_opt::Model Member \_internalref classoperations__research_1_1math__opt_1_1Model#ae3a2f02a80238331fcdb90fc410682df "operations_research::math_opt::Model::ValidateExistingVariableOfThisModel" (Variable variable) const</dt><dd> \anchor _todo000927 (b/239810718): use << for Variable once it does not CHECK. </dd> <dt> \_setscope operations_research::math_opt::ModelSolveParameters Member \_internalref structoperations__research_1_1math__opt_1_1ModelSolveParameters#a7f2865236a76bb6d14d3ac4accae433c "operations_research::math_opt::ModelSolveParameters::Proto" () const</dt><dd> \anchor _todo000930 : b/315974557 - Return an error if a RepeatedField is too long. </dd> <dt> \_setscope operations_research::math_opt Member \_internalref namespaceoperations__research_1_1math__opt#afa94d25b431c19de213fd01276bda3bf "operations_research::math_opt::MoveVariablesToTheirBestFeasibleValue" (const Model &model, const VariableMap< double > &input_solution, absl::Span< const Variable > variables, const MoveVariablesToTheirBestFeasibleValueOptions &options)</dt><dd> \anchor _todo000946 (b/193121090): here we build the proto as the APIs of MathOpt only works with the proto and can't use the C++ Model (or ModelStorage). </dd> <dt> \_setscope operations_research::math_opt Member \_internalref namespaceoperations__research_1_1math__opt#a647b24c008c0cab90f59e848a507c244 "operations_research::math_opt::NoSolutionFoundTerminationProto" (const bool is_maximize, const LimitProto limit, const std::optional< double > optional_dual_objective, const absl::string_view detail)</dt><dd> \anchor _todo000916 (b/290359402): Consider improving to require a finite dual bound when dual feasible solutions are returned. </dd> <dt> \_setscope operations_research::math_opt::ObjectiveStorage::Diff Member \_internalref structoperations__research_1_1math__opt_1_1ObjectiveStorage_1_1Diff#a269e380e623c1a8a281290585bb0c24f "operations_research::math_opt::ObjectiveStorage::Diff::objective_diffs" </dt><dd> \anchor _todo001018 (b/259109678): Consider storing primary objective separately (like in <tt>ObjectiveStorage</tt>) if hashing is a noticeable bottleneck. </dd> <dt> \_setscope operations_research::math_opt Member \_internalref namespaceoperations__research_1_1math__opt#a529b5def5ea854858d5e3a6c094a0988 "operations_research::math_opt::operator<<" (std::ostream &ostr, const IndicatorConstraint &constraint)</dt><dd> \anchor _todo000905 (b/170992529): handle quoting of invalid characters in the name. </dd> <dt> \_setscope operations_research::math_opt Member \_internalref namespaceoperations__research_1_1math__opt#af7ba8f15f41011f5b8109d7bef66511f "operations_research::math_opt::operator<<" (std::ostream &ostr, const QuadraticConstraint &constraint)</dt><dd> \anchor _todo000906 (b/170992529): handle quoting of invalid characters in the name. </dd> <dt> \_setscope operations_research::math_opt Member \_internalref namespaceoperations__research_1_1math__opt#a96a74dc7a0e6aa81c2279481c4c1e678 "operations_research::math_opt::operator<<" (std::ostream &ostr, const SecondOrderConeConstraint &constraint)</dt><dd> \anchor _todo000907 (b/170992529): handle quoting of invalid characters in the name. </dd> <dt> \_setscope operations_research::math_opt Member \_internalref namespaceoperations__research_1_1math__opt#a1a9e610368627bfdb61a92bc85274327 "operations_research::math_opt::operator<<" (std::ostream &ostr, const Sos1Constraint &constraint)</dt><dd> \anchor _todo000908 (b/170992529): handle quoting of invalid characters in the name. </dd> <dt> \_setscope operations_research::math_opt Member \_internalref namespaceoperations__research_1_1math__opt#af810f3a175629e517744c9f265470b61 "operations_research::math_opt::operator<<" (std::ostream &ostr, const Sos2Constraint &constraint)</dt><dd> \anchor _todo000909 (b/170992529): handle quoting of invalid characters in the name. </dd> <dt> \_setscope operations_research::math_opt Member \_internalref namespaceoperations__research_1_1math__opt#a99d303a9027f99623639c132198aa097 "operations_research::math_opt::operator<<" (std::ostream &ostr, const LinearConstraint &linear_constraint)</dt><dd> \anchor _todo000923 (b/170992529): handle quoting of invalid characters in the name. </dd> <dt> \_setscope operations_research::math_opt Member \_internalref namespaceoperations__research_1_1math__opt#a5db056654e1d14286315339c41c1bff0 "operations_research::math_opt::operator<<" (std::ostream &ostr, const Objective &objective)</dt><dd> \anchor _todo000931 (b/170992529): handle quoting of invalid characters in the name. </dd> <dt> \_setscope operations_research::math_opt Member \_internalref namespaceoperations__research_1_1math__opt#ab1d61842701172037b05e011df664d90 "operations_research::math_opt::operator<<" (std::ostream &ostr, const LinearExpression &expression)</dt><dd> \anchor _todo000941 (b/169415597): improve linear expression format: - make sure to quote the variable name so that we support: </dd> <dt> \_setscope operations_research::math_opt Member \_internalref namespaceoperations__research_1_1math__opt#a9019e3ceb6908ea58dee5e0ea0e627f9 "operations_research::math_opt::operator<<" (std::ostream &ostr, const QuadraticExpression &expr)</dt><dd> \anchor _todo000942 (b/169415597): improve quadratic expression formatting. See b/170991498 for desired improvements for LinearExpression streaming which are also applicable here. </dd> <dt> \_setscope operations_research::math_opt Member \_internalref namespaceoperations__research_1_1math__opt#ae8f450a61d6f3613fa723a717c3cbca3 "operations_research::math_opt::operator<<" (std::ostream &ostr, const Variable &variable)</dt><dd> \anchor _todo000944 (b/170992529): handle quoting of invalid characters in the name. </dd> <dt> \_setscope operations_research::math_opt Member \_internalref namespaceoperations__research_1_1math__opt#a3f1deb6f9bb763a7c2635992bec9dcf9 "operations_research::math_opt::OptimalTerminationProto" (const double finite_primal_objective, const double dual_objective, const absl::string_view detail)</dt><dd> \anchor _todo000915 (b/290359402): additionally require dual_objective to be finite. </dd> <dt> \_setscope operations_research::math_opt::PdlpBridge Member \_internalref classoperations__research_1_1math__opt_1_1PdlpBridge#a5be3dbbc95b4b889956096613a822e40 "operations_research::math_opt::PdlpBridge::PrimalVariablesToProto" (const Eigen::VectorXd &primal_values, const SparseVectorFilterProto &variable_filter) const</dt><dd> \anchor _todo001014 (b/183616124): we need to support the inverse of these methods for warm start. </dd> <dt> \_setscope operations_research::math_opt::SimpleMipTestParameters Member \_internalref structoperations__research_1_1math__opt_1_1SimpleMipTestParameters#ac01adb283c3825d2dc482c74306d2766 "operations_research::math_opt::SimpleMipTestParameters::report_unboundness_correctly" </dt><dd> \anchor _todo000962 (b/202159173): remove this when we start using the direct CP-SAT API and thus will be able to get proper details. </dd> <dt> \_setscope operations_research::math_opt::Solver Member \_internalref classoperations__research_1_1math__opt_1_1Solver#a9aa036d5c842854ba6702ee9d55276b6 "operations_research::math_opt::Solver::Solve" (const SolveArgs &arguments) override</dt><dd> \anchor _todo000920 (b/168037341): we should validate the result maths. Since the result can be filtered, this should be included in the solver_interface implementations. \anchor _todo000921 (b/290091715): Remove once language specific structs can use new messages. </dd> <dt> \_setscope operations_research::math_opt::SolveResultMatcherOptions Member \_internalref structoperations__research_1_1math__opt_1_1SolveResultMatcherOptions#ae41b54030c8d6d4345348e188263eb7b "operations_research::math_opt::SolveResultMatcherOptions::check_solutions_if_inf_or_unbounded" </dt><dd> \anchor _todo000926 (b/201099290): this is perhaps not a good default. Gurobi as implemented is returning primal solutions for both unbounded and infeasible problems. We need to add unit tests that inspect this value and turn them on one solver at a time with a new parameter on SimpleLpTestParameters. </dd> <dt> \_setscope operations_research::math_opt::SparseMatrix Member \_internalref classoperations__research_1_1math__opt_1_1SparseMatrix#a1ef6c0a7d0962256e329df83b34a3668 "operations_research::math_opt::SparseMatrix< RowId, ColumnId >::column" (ColumnId column_id) const</dt><dd> \anchor _todo001029 (b/233630053): expose an iterator based API to avoid making a copy. </dd> <dt> \_setscope operations_research::math_opt::SparseMatrix Member \_internalref classoperations__research_1_1math__opt_1_1SparseMatrix#a5b93353672b48d531e16f26eeb6c1238 "operations_research::math_opt::SparseMatrix< RowId, ColumnId >::ColumnTerms" (ColumnId col_id) const</dt><dd> \anchor _todo001031 (b/233630053): expose an iterator based API to avoid making a copy. </dd> <dt> \_setscope operations_research::math_opt::SparseMatrix Member \_internalref classoperations__research_1_1math__opt_1_1SparseMatrix#a35c2edd872d547e250e828a62e65ce71 "operations_research::math_opt::SparseMatrix< RowId, ColumnId >::row" (RowId row_id) const</dt><dd> \anchor _todo001028 (b/233630053): expose an iterator based API to avoid making a copy. </dd> <dt> \_setscope operations_research::math_opt::SparseMatrix Member \_internalref classoperations__research_1_1math__opt_1_1SparseMatrix#af45684890602a0abd734552aef5b53eb "operations_research::math_opt::SparseMatrix< RowId, ColumnId >::RowTerms" (RowId row_id) const</dt><dd> \anchor _todo001030 (b/233630053): expose an iterator based API to avoid making a copy. </dd> <dt> \_setscope operations_research::math_opt::SparseMatrix Member \_internalref classoperations__research_1_1math__opt_1_1SparseMatrix#a6aca40055cfa8c9e5767ce467f5c89ae "operations_research::math_opt::SparseMatrix< RowId, ColumnId >::Terms" () const</dt><dd> \anchor _todo001032 (b/233630053): expose an iterator based API to avoid making a copy. </dd> <dt> \_setscope operations_research::math_opt::SparseMatrix Member \_internalref classoperations__research_1_1math__opt_1_1SparseMatrix#a346f0dd1bc945b8a3f6acce2f868b0f3 "operations_research::math_opt::SparseMatrix< RowId, ColumnId >::Update" (const absl::flat_hash_set< RowId > &deleted_rows, absl::Span< const RowId > new_rows, const absl::flat_hash_set< ColumnId > &deleted_columns, absl::Span< const ColumnId > new_columns, const absl::flat_hash_set< std::pair< RowId, ColumnId > > &dirty) const</dt><dd> \anchor _todo001021 (b/233630053): use iterator API. \anchor _todo001022 (b/233630053) use iterator API. </dd> <dt> \_setscope operations_research::math_opt::SparseSymmetricMatrix Member \_internalref classoperations__research_1_1math__opt_1_1SparseSymmetricMatrix#ae7fd3ba62ed1002264117fa864e7144f "operations_research::math_opt::SparseSymmetricMatrix::Proto" () const</dt><dd> \anchor _todo001019 (b/233630053): reuse the allocation once an iterator API is supported. </dd> <dt> \_setscope operations_research::math_opt::SparseSymmetricMatrix Member \_internalref classoperations__research_1_1math__opt_1_1SparseSymmetricMatrix#a43ee2fbaa504f90f7690b0bf87861c97 "operations_research::math_opt::SparseSymmetricMatrix::RelatedVariables" (VariableId variable) const</dt><dd> \anchor _todo001024 (b/233630053): expose an iterator based API to avoid making a copy. </dd> <dt> \_setscope operations_research::math_opt::SparseSymmetricMatrix Member \_internalref classoperations__research_1_1math__opt_1_1SparseSymmetricMatrix#a5daadc06a91ff1edeb4871b1801b84f9 "operations_research::math_opt::SparseSymmetricMatrix::Terms" (VariableId variable) const</dt><dd> \anchor _todo001025 (b/233630053): expose an iterator based API to avoid making a copy. </dd> <dt> \_setscope operations_research::math_opt::SparseSymmetricMatrix Member \_internalref classoperations__research_1_1math__opt_1_1SparseSymmetricMatrix#a4568f0449320e9203ed9969bad5d26dd "operations_research::math_opt::SparseSymmetricMatrix::Terms" () const</dt><dd> \anchor _todo001026 (b/233630053): expose an iterator based API to avoid making a copy. </dd> <dt> \_setscope operations_research::math_opt::SparseSymmetricMatrix Member \_internalref classoperations__research_1_1math__opt_1_1SparseSymmetricMatrix#a007fc8188b348177988fb88dffe12f3f "operations_research::math_opt::SparseSymmetricMatrix::Update" (const absl::flat_hash_set< VariableId > &deleted_variables, absl::Span< const VariableId > new_variables, const absl::flat_hash_set< std::pair< VariableId, VariableId > > &dirty) const</dt><dd> \anchor _todo001020 (b/233630053): do not allocate here. </dd> <dt> \_setscope operations_research::math_opt::SparseSymmetricMatrix Member \_internalref classoperations__research_1_1math__opt_1_1SparseSymmetricMatrix#a6297413386fb1ed24d1a6087c3f900cb "operations_research::math_opt::SparseSymmetricMatrix::values" () const</dt><dd> \anchor _todo001027 (b/233630053): do not expose values_ directly, instead offer a way to iterate over all the nonzero entries. </dd> <dt> \_setscope operations_research::math_opt::SparseSymmetricMatrix Member \_internalref classoperations__research_1_1math__opt_1_1SparseSymmetricMatrix#a89e72a700578de83bbd4eb42102bdc7a "operations_research::math_opt::SparseSymmetricMatrix::Variables" () const</dt><dd> \anchor _todo001023 (b/233630053): expose an iterator based API to avoid making a copy. </dd> <dt> \_setscope operations_research::math_opt::Termination Member \_internalref structoperations__research_1_1math__opt_1_1Termination#a09bb061e1a745c607004cbd2de7500fb "operations_research::math_opt::Termination::best_primal_solution" () const</dt><dd> \anchor _todo000938 (b/290359402): Consider improving to require a finite dual bound when / dual feasible solutions are returned. static Termination NoSolutionFound( bool is_maximize, Limit limit, std::optional<double> optional_dual_objective = std::nullopt, std::string detail = {}); \anchor _todo000939 (b/290359402): Consider improving to require a finite dual bound when / dual feasible solutions are returned. static Termination Feasible( bool is_maximize, Limit limit, double finite_primal_objective, std::optional<double> optional_dual_objective = std::nullopt, std::string detail = {}); \anchor _todo000940 (b/231134639): investigate removing the oneof from the proto. absl::StatusOr<SolveResultProto> Proto() const;</dd> <dt> \_setscope operations_research::math_opt Member \_internalref namespaceoperations__research_1_1math__opt#ac51b998f0ab120a1855bd589f2553fad "operations_research::math_opt::ValidateResult" (const SolveResultProto &result, const ModelSolveParametersProto &parameters, const ModelSummary &model_summary)</dt><dd> \anchor _todo001035 (b/290091715): Remove once problem_status and objective bounds are removed from solve_stats and their presence is guaranteed in termination. \anchor _todo001036 (b/290091715): Replace by TerminationProto termination = result.termination(); once problem_status and objective bounds are removed from solve_stats and their presence is guaranteed in termination. </dd> <dt> \_setscope operations_research::math_opt Member \_internalref namespaceoperations__research_1_1math__opt#aa782b35203234b683975688b30f3110f "operations_research::math_opt::ValidateSolution" (const SolutionProto &solution, const ModelSolveParametersProto &parameters, const ModelSummary &model_summary)</dt><dd> \anchor _todo001038 (b/204457524): consider checking equality of statuses for single-sided LPs. </dd> <dt> \_setscope operations_research::math_opt Member \_internalref namespaceoperations__research_1_1math__opt#add23cecedb126522044aca6764532ce3 "operations_research::math_opt::ValidateSolutions" (const google::protobuf::RepeatedPtrField< SolutionProto > &solutions, const ModelSolveParametersProto &parameters, const ModelSummary &model_summary)</dt><dd> \anchor _todo001034 (b/204457524): check objective ordering when possible. </dd> <dt> \_setscope operations_research::math_opt Member \_internalref namespaceoperations__research_1_1math__opt#af099801286ce760f79dda3ce9b7be78d "operations_research::math_opt::ValidateSolveParameters" (const SolveParametersProto &parameters)</dt><dd> \anchor _todo001040 (b/213697045): some parameters are still not validated. </dd> <dt> \_setscope operations_research::MaxFlow Class \_internalref classoperations__research_1_1MaxFlow "operations_research::MaxFlow" </dt><dd> \anchor _todo000685 (user): Modify this code and remove it. </dd> <dt> \_setscope operations_research::MinCostFlowBase Member \_internalref classoperations__research_1_1MinCostFlowBase#ae5cad0c7d9c3eddbc7c3aefbee060457a41523b94852c3cb55c86ce0e291e3719 "operations_research::MinCostFlowBase::BAD_COST_RANGE" </dt><dd> \anchor _todo000701 (user): this is not always properly checked and probably deserve a different return status. - Since we scale cost, each arc unit cost times (num_nodes + 1) should not overflow. We detect that at the beginning of the Solve(). - This is however not sufficient as the node potential depends on the minimum cost of sending 1 unit of flow through the residual graph. If the maximum arc unit cost is smaller than kint64max / (2 * n ^ 2) then one shouldn't run into any overflow. But in pratice this bound is quite loose. So it is possible to try with higher cost, and the algorithm will detect if an overflow actually happen and return BAD_COST_RANGE, so we can retry with smaller cost.</dd> <dt> \_setscope operations_research::MinCostPerfectMatching Member \_internalref classoperations__research_1_1MinCostPerfectMatching#a6f94ee8ea8298d25de3607ed56d2d94e "operations_research::MinCostPerfectMatching::AddEdgeWithCost" (int tail, int head, int64_t cost)</dt><dd> \anchor _todo000726 (user): We can easily shift all costs if negative costs are needed. \anchor _todo000727 (user): We could just presolve them away. </dd> <dt> \_setscope operations_research::MinCostPerfectMatching Member \_internalref classoperations__research_1_1MinCostPerfectMatching#a4d798c6f197b745924e4e0ca184c3642 "operations_research::MinCostPerfectMatching::MinCostPerfectMatching" ()</dt><dd> \anchor _todo000724 (user): For now we ask the number of nodes at construction, but we could automatically infer it from the added edges if needed. </dd> <dt> \_setscope operations_research::MinCostPerfectMatching Member \_internalref classoperations__research_1_1MinCostPerfectMatching#a5f89c8890f72a582d15baf027b9cfeb9 "operations_research::MinCostPerfectMatching::Reset" (int num_nodes)</dt><dd> \anchor _todo000725 (user): Eventually, we may support incremental Solves(). Or at least memory reuse if one wants to solve many problems in a row. </dd> <dt> \_setscope operations_research::MinCostPerfectMatching Member \_internalref classoperations__research_1_1MinCostPerfectMatching#acce484fd341b33e5c371f0a1046821ed "operations_research::MinCostPerfectMatching::Solve" ()</dt><dd> \anchor _todo000705 (user): Improve the overflow detection if needed. The current one seems ok though. \anchor _todo000706 (user): Maybe there is a faster/better way to recover the mapping in the presence of blossoms. </dd> <dt> \_setscope operations_research::ModelSolverHelper Member \_internalref classoperations__research_1_1ModelSolverHelper#a0a3942146394eec75729ef0d79319237 "operations_research::ModelSolverHelper::Solve" (const ModelBuilderHelper &model)</dt><dd> \anchor _todo000837 (user): Enable log_callback support. \anchor _todo000838 \anchor _todo000839 (user): Enable interrupt_solve. \anchor _todo000840 (user): Enable log_callback support. \anchor _todo000841 \anchor _todo000842 (user): Enable interrupt_solve. </dd> <dt> \_setscope operations_research::MPSolver Member \_internalref classoperations__research_1_1MPSolver#a84aec4c6ee3b17edc9979b12ecdb5f63 "operations_research::MPSolver::ComputeConstraintActivities" () const</dt><dd> \anchor _todo000793 (user): test this failure case. </dd> <dt> \_setscope operations_research::MPSolver Member \_internalref classoperations__research_1_1MPSolver#a9c8cc8b3c36fe9c08d8e0eefbc98b774 "operations_research::MPSolver::ExportModelToProto" (MPModelProto *output_model) const</dt><dd> \anchor _todo000789 (user): Add option to avoid filling the var name to avoid overly large protocol buffers. \anchor _todo000790 (user): remove this step. </dd> <dt> \_setscope operations_research::MPSolver Member \_internalref classoperations__research_1_1MPSolver#aae2800c3df9ebf5f1e3c21cd5af3c9a9 "operations_research::MPSolver::LoadSolutionFromProto" (const MPSolutionResponse &response, double tolerance=std::numeric_limits< double >::infinity())</dt><dd> \anchor _todo000791 (user): Use parameter when they become available in this class. </dd> <dt> \_setscope operations_research::MPSolver Member \_internalref classoperations__research_1_1MPSolver#a9f2efb3304b325430e46e848574d63e5 "operations_research::MPSolver::Solve" (const MPSolverParameters &param)</dt><dd> \anchor _todo000792 (user): replace this by model extraction to proto + proto validation (the proto has very low overhead compared to the wrapper, both in performance and memory, so it's ok). </dd> <dt> \_setscope operations_research::MPSolver Member \_internalref classoperations__research_1_1MPSolver#a2a4a0234b5830d4ea82d549b3b6b5baf "operations_research::MPSolver::VerifySolution" (double tolerance, bool log_errors) const</dt><dd> \anchor _todo000794 (user): split. </dd> <dt> \_setscope operations_research::MPSolverInterface Member \_internalref classoperations__research_1_1MPSolverInterface#ac11b5863b3866e251564de9a5dcfb92e "operations_research::MPSolverInterface::MPSolverInterface" (MPSolver *solver)</dt><dd> \anchor _todo000795 (user): Initialize objective value and bound to +/- inf (depending on optimization direction). </dd> <dt> \_setscope operations_research::MPSolverInterface Member \_internalref classoperations__research_1_1MPSolverInterface#a3fd73560f782eaf5093a435c61783d09 "operations_research::MPSolverInterface::ResetExtractionInformation" ()</dt><dd> \anchor _todo000796 (user): remove this method. </dd> <dt> \_setscope operations_research::MPSolverInterface Member \_internalref classoperations__research_1_1MPSolverInterface#ad237855fa79fc36fbf9baedce589384c "operations_research::MPSolverInterface::SetCommonParameters" (const MPSolverParameters &param)</dt><dd> \anchor _todo000797 (user): Overhaul the code that sets parameters to enable changing GLOP parameters without issuing warnings. By default, we let GLOP keep its own default tolerance, much more accurate than for the rest of the solvers. \anchor _todo000798 (user): In the future, we could distinguish between the algorithm to solve the root LP and the algorithm to solve node LPs. Not sure if underlying solvers support it. </dd> <dt> \_setscope operations_research::NearestNeighbors Member \_internalref classoperations__research_1_1NearestNeighbors#af61cd5ece87302a1054745def342cf71 "operations_research::NearestNeighbors::Initialize" ()</dt><dd> \anchor _todo000234 (user): recompute if node changes path ? </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#a9618712e8edff7ae775417c7e2763062 "operations_research::NodePathImpliedBy" (absl::Span< const typename GraphType::ArcIndex > arc_path, const GraphType &graph)</dt><dd> \anchor _todo000634 (b/332475804): If <tt>ArcPathTo</tt> and/or <tt>NodePathTo</tt> functions become bottlenecks: (1) have the class preallocate a buffer of size <tt>num_nodes</tt> (2) assign into an index rather than with push_back (3) return by absl::Span (or return a copy) with known size. </dd> <dt> \_setscope operations_research::ObjectiveMonitor Member \_internalref classoperations__research_1_1ObjectiveMonitor#abfce94c7e8c5e81991ad9d744ecf7f3e "operations_research::ObjectiveMonitor::ObjectiveMonitor" (Solver *solver, const std::vector< bool > &maximize, std::vector< IntVar * > vars, std::vector< int64_t > steps)</dt><dd> \anchor _todo000397 (user): Remove optimization direction from solver or expose it for each OptimizeVar variable. Note that Solver::optimization_direction() is not used anywhere, only passed as information for the user. Direction set based on highest level as of 02/2023. </dd> <dt> \_setscope operations_research::Pack Member \_internalref classoperations__research_1_1Pack#af13898c8553d217fa3d52c6e2b504f8d "operations_research::Pack::OneDomain" (int var_index)</dt><dd> \anchor _todo000254 (user): We know var ranges from 0 to bins_. There are lots of simplifications possible. </dd> <dt> \_setscope operations_research::PairExchangeOperator Member \_internalref classoperations__research_1_1PairExchangeOperator#abe5bdb5b47972a06326d2e9ab802faf4 "operations_research::PairExchangeOperator::MakeNeighbor" () override</dt><dd> \anchor _todo000352 (user): Support alternatives with neighbors. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#ad269bb3141acc83c2ebe88b1f57b1f95 "operations_research::ParseAndSolve" (const std::string &filename, absl::string_view solver, const std::string &params)</dt><dd> \anchor _todo001043 (user): Move naming code to parser. </dd> <dt> \_setscope operations_research::PathContainerImpl Class \_internalref classoperations__research_1_1PathContainerImpl "operations_research::PathContainerImpl" </dt><dd> \anchor _todo000730 (user): Currently using StarGraph::kNilNode until the new Ebert graphs appear; switch to kNilNode on the base Ebert graph class when available. </dd> <dt> \_setscope operations_research::PathLns Member \_internalref classoperations__research_1_1PathLns#a869e1cdf41f26c362721696997202bf7 "operations_research::PathLns::MakeNeighbor" () override</dt><dd> \anchor _todo000235 (user): make this more efficient. </dd> <dt> \_setscope operations_research::PathOperator Member \_internalref classoperations__research_1_1PathOperator#adbd9065c5b91dde20b8f4c0759233971 "operations_research::PathOperator::OnSamePathAsPreviousBase" (int64_t base_index)</dt><dd> \anchor _todo000171 (user): ideally this should be OnSamePath(int64_t node1, int64_t node2); it's currently way more complicated to implement. </dd> <dt> \_setscope operations_research::PathOperator Member \_internalref classoperations__research_1_1PathOperator#a6580d6cdf003656019a25f7e9f2d8496 "operations_research::PathOperator::RestartAtPathStartOnSynchronize" ()</dt><dd> \anchor _todo000170 (user): remove this when automatic detection of such cases in done. </dd> <dt> \_setscope operations_research::PathOperator Member \_internalref classoperations__research_1_1PathOperator#a13fc3f3cb8f8de7198d1b16338df06ad "operations_research::PathOperator::SkipUnchanged" (int index) const override</dt><dd> \anchor _todo000169 (user): Make the following methods protected. </dd> <dt> \_setscope operations_research::pdlp Member \_internalref namespaceoperations__research_1_1pdlp#a7bd16384c5572b001a57e9987bf5b0e9 "operations_research::pdlp::FindScalingFactor" (const DiagonalTrustRegionProblem &problem, const Sharder &sharder, const double target_radius, const double solve_tol)</dt><dd> \anchor _todo001062 (user): figure out what accuracy is useful to callers and redo the stopping criterion accordingly. </dd> <dt> \_setscope operations_research::pdlp::internal Member \_internalref namespaceoperations__research_1_1pdlp_1_1internal#a0d1a488cd88b2db320196184c8a60713 "operations_research::pdlp::internal::ComputeInitialUndecidedComponents" (const TrustRegionProblem &problem, int64_t start_index, int64_t end_index, std::vector< int64_t > &undecided_components)</dt><dd> \anchor _todo001063 (user): Evaluate dropping this <tt>reserve()</tt>, since it wastes space if many components are decided. </dd> <dt> \_setscope operations_research::pdlp Member \_internalref namespaceoperations__research_1_1pdlp#a898c0c776a5736cf1931036d0d370724 "operations_research::pdlp::ProjectToDualVariableBounds" (const ShardedQuadraticProgram &sharded_qp, VectorXd &dual)</dt><dd> \anchor _todo001059 (user): Investigate whether it is more efficient to use .cwiseMax() + .cwiseMin() with unaryExpr(s) that map upper_bound_shard and lower_bound_shard to appropriate values. </dd> <dt> \_setscope operations_research::pdlp Member \_internalref namespaceoperations__research_1_1pdlp#a80b7dc41ed788020cbaf942674f623d9 "operations_research::pdlp::ReadQuadraticProgramOrDie" (const std::string &filename, bool include_names)</dt><dd> \anchor _todo001057 (user): Update internal helper functions to use references instead of pointers. </dd> <dt> \_setscope operations_research::pdlp::ShardedWeightedAverage Member \_internalref classoperations__research_1_1pdlp_1_1ShardedWeightedAverage#a832ecd48fecace426aeb1c32f0322fbb "operations_research::pdlp::ShardedWeightedAverage::ComputeAverage" () const</dt><dd> \anchor _todo001058 (user): consider returning a reference to avoid this copy. </dd> <dt> \_setscope operations_research::PdlpInterface Member \_internalref classoperations__research_1_1PdlpInterface#aeba91f0ed5437b1264431fc6562ff094 "operations_research::PdlpInterface::column_status" (int variable_index) const override</dt><dd> \anchor _todo000805 (user): While basis status isn't well defined for PDLP, we could guess statuses that might be useful. </dd> <dt> \_setscope operations_research::PdlpInterface Member \_internalref classoperations__research_1_1PdlpInterface#aecba606519ca8ae9dfb6493a4653cbfc "operations_research::PdlpInterface::row_status" (int constraint_index) const override</dt><dd> \anchor _todo000804 (user): While basis status isn't well defined for PDLP, we could guess statuses that might be useful. </dd> <dt> \_setscope operations_research::PdlpInterface Member \_internalref classoperations__research_1_1PdlpInterface#a22fcf7b9b53475d97d46e1eb057d1b87 "operations_research::PdlpInterface::underlying_solver" () override</dt><dd> \anchor _todo000806 (user): Consider returning the SolveLog here, as it could be essential for interpreting the PDLP solution. </dd> <dt> \_setscope operations_research::PiecewiseLinearExpr Member \_internalref classoperations__research_1_1PiecewiseLinearExpr#a29f2fd207e34ba398b1b772d21852f33 "operations_research::PiecewiseLinearExpr::Accept" (ModelVisitor *const visitor) const override</dt><dd> \anchor _todo000214 (user): Implement visitor. </dd> <dt> \_setscope operations_research::PiecewiseLinearFunction Member \_internalref classoperations__research_1_1PiecewiseLinearFunction#adb77fb211d172324d3d02e974af56c5b "operations_research::PiecewiseLinearFunction::Value" (int64_t x) const</dt><dd> \anchor _todo002454 (user): Allow the user to specify the undefined value and use kint64max as the default. </dd> <dt> \_setscope operations_research::Preprocessor Class \_internalref classoperations__research_1_1Preprocessor "operations_research::Preprocessor" </dt><dd> \anchor _todo000046 (user): make the different algorithms concurrent, solving independent subproblems in different threads. </dd> <dt> \_setscope operations_research::Preprocessor Member \_internalref classoperations__research_1_1Preprocessor#a1d2eb2c3fd278870a969507c76636844 "operations_research::Preprocessor::NextSolution" ()</dt><dd> \anchor _todo000048 (user): Add time-outs and exit with a partial solution. This seems unlikely, though. </dd> <dt> \_setscope operations_research::PruningHamiltonianSolver Member \_internalref classoperations__research_1_1PruningHamiltonianSolver#a1400c5c64142a6b8faa3c6c0c235ff93 "operations_research::PruningHamiltonianSolver< CostType, CostFunction >::Integer" </dt><dd> \anchor _todo000662 (user): Use generic map-based cache instead of lattice-based one. (user): Use SaturatedArithmetic for better precision. </dd> <dt> \_setscope operations_research::Queue Member \_internalref classoperations__research_1_1Queue#a014c7261e4c1b40cd8d81d22e22c3e94 "operations_research::Queue::ProcessConstraints" ()</dt><dd> \anchor _todo000143 (user): Make to_add_ a queue to make the behavior more obvious. \anchor _todo000144 (user): Add profiling to initial propagation </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#ad9e6cb141794cea6160e283e70c283c7 "operations_research::RadixSort" (absl::Span< T > values)</dt><dd> \anchor _todo000038 (user): Expose an API that takes the "max value" as argument, for users who want to take advantage of that knowledge to reduce the number of passes. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#ab5ef2e157c0cb5fad29b2b6db644f8a0 "operations_research::RadixSortTpl" (absl::Span< T > values)</dt><dd> \anchor _todo000035 : remove the if constexpr so that compilation catches the bad cases. \anchor _todo000036 (user): See if this is faster than memcpy + std::reverse(). \anchor _todo000037 (user): See if memcpy everything + memcpy here is faster than memmove(). </dd> <dt> \_setscope operations_research::RandomSolutionGenerator Class \_internalref classoperations__research_1_1RandomSolutionGenerator "operations_research::RandomSolutionGenerator" </dt><dd> \anchor _todo000047 (user): make it possible to use other random generators. Idea: bias the generator towards the columns with the least marginal costs. </dd> <dt> \_setscope operations_research::RangeIntToIntFunction Member \_internalref classoperations__research_1_1RangeIntToIntFunction#a95dc968eea4874e0099cc74f38bd4aca "operations_research::RangeIntToIntFunction::Query" (int64_t argument) const =0</dt><dd> \anchor _todo002456 (user): Rename to Run </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#a9dc92cf61d5051e6ec16fa5dc7e371ae "operations_research::RationalApproximation" (const double x, const double precision)</dt><dd> \anchor _todo002457 (user): make a parameterized template with integer and floating-point type parameters. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#a02563c6a9501a9306b8a52fd459b7e8c "operations_research::ReadBeasleySetCoverProblem" (absl::string_view filename)</dt><dd> \anchor _todo000074 (user): add proper error handling. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#a1bd9bbb304a58211dee6405bc7fc4056 "operations_research::ReadQapProblemOrDie" (absl::string_view filepath)</dt><dd> \anchor _todo002455 (user): Unit test cases when the function dies, or return (and test) a status instead. </dd> <dt> \_setscope operations_research::RelocateAndMakeActiveOperator Class \_internalref classoperations__research_1_1RelocateAndMakeActiveOperator "operations_research::RelocateAndMakeActiveOperator" </dt><dd> \anchor _todo000233 (user): Naming is close to MakeActiveAndRelocate but this one is correct; rename MakeActiveAndRelocate if it is actually used. </dd> <dt> \_setscope operations_research::RevBitMatrix Member \_internalref classoperations__research_1_1RevBitMatrix#ae2bcb32bc27553f598733168bbc46fd2 "operations_research::RevBitMatrix::IsCardinalityOne" (int row) const</dt><dd> \anchor _todo000412 (user) : Optimize this one. </dd> <dt> \_setscope operations_research::RevVector Member \_internalref classoperations__research_1_1RevVector#a576b88e9d92029753f73f012e2b57599 "operations_research::RevVector< IndexType, T >::MutableRef" (IndexType index)</dt><dd> \anchor _todo002459 (user): Maybe we could have also used the [] operator, but it is harder to be 100% sure that the mutable version is only called when we modify the vector. And I had performance bug because of that. </dd> <dt> \_setscope operations_research::RoutingFilteredHeuristic Member \_internalref classoperations__research_1_1RoutingFilteredHeuristic#a7bb79a29267b7b9153447234897a7949 "operations_research::RoutingFilteredHeuristic::MakeUnassignedNodesUnperformed" ()</dt><dd> \anchor _todo000367 (user): check that delta_ is empty. </dd> <dt> \_setscope operations_research::RoutingGlopWrapper Member \_internalref classoperations__research_1_1RoutingGlopWrapper#a6e9afdf1ffb0dba256ae65a29dcc3e64 "operations_research::RoutingGlopWrapper::PrintModel" () const override</dt><dd> \anchor _todo000348 (user): Improve output readability. </dd> <dt> \_setscope operations_research::RoutingGlopWrapper Member \_internalref classoperations__research_1_1RoutingGlopWrapper#ae230124d932c4d9f0da5d5b9538b88ba "operations_research::RoutingGlopWrapper::SetVariableDisjointBounds" (int index, const std::vector< int64_t > &starts, const std::vector< int64_t > &ends) override</dt><dd> \anchor _todo000347 (user): Investigate if we can avoid rebuilding the interval list each time (we could keep a reference to the forbidden interval list in RoutingDimension but we would need to store cumul offsets and use them when checking intervals). </dd> <dt> \_setscope operations_research::RoutingIndexManager Member \_internalref classoperations__research_1_1RoutingIndexManager#a148a071cb5a92fe73501c7c299ed5eb1 "operations_research::RoutingIndexManager::num_unique_depots" () const</dt><dd> \anchor _todo000337 (user) Add unit tests for NodesToIndices and IndicesToNodes. (user): Remove when removal of NodeIndex from RoutingModel is complete. </dd> <dt> \_setscope operations_research::RoutingModelInspector Member \_internalref classoperations__research_1_1RoutingModelInspector#a84dbe032f5cce5e2e3acc042382b1f85 "operations_research::RoutingModelInspector::EndVisitModel" (const std::string &) override</dt><dd> \anchor _todo000303 (user): Perform transitive closure of dimension precedence graphs. \anchor _todo000304 \anchor _todo000305 (user): Have a single annotated precedence graph. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#aac65f6cb5816150efa463314f16ee1cd "operations_research::RunSeparation" (internal::ScipCallbackRunner *runner, const ScipConstraintHandlerContext &context, absl::Span< SCIP_CONS * > constraints, bool is_integral)</dt><dd> \anchor _todo000827 (user): when infeasible is true, it better to have the scip return status be cutoff instead of cutting plane added (e.g. see cs/scip/src/scip/cons_knapsack.c). However, as we use SCIPaddRow(), it isn't clear this will even happen. \anchor _todo000828 (user): Maybe it is better to expose more of these options, potentially through user_suggested_constraint. </dd> <dt> \_setscope operations_research::sat::ActivityBoundHelper Class \_internalref classoperations__research_1_1sat_1_1ActivityBoundHelper "operations_research::sat::ActivityBoundHelper" </dt><dd> \anchor _todo002149 (user): Use better algorithm. The problem is the same as finding upper bound to the classic problem: maximum-independent set in a graph. We also only use at most ones, but we could use the more general binary implication graph. </dd> <dt> \_setscope operations_research::sat::ActivityBoundHelper Member \_internalref classoperations__research_1_1sat_1_1ActivityBoundHelper#a0597d8e2ff729931de6b9e1e7df34298 "operations_research::sat::ActivityBoundHelper::AddAllAtMostOnes" (const CpModelProto &proto)</dt><dd> \anchor _todo002144 (user): Add long ones first, or at least the ones of size 2 after. </dd> <dt> \_setscope operations_research::sat::ActivityBoundHelper Member \_internalref classoperations__research_1_1sat_1_1ActivityBoundHelper#a7569741972c7325665407db889dc36af "operations_research::sat::ActivityBoundHelper::ComputeMaxActivity" (absl::Span< const std::pair< int, int64_t > > terms, std::vector< std::array< int64_t, 2 > > *conditional=nullptr)</dt><dd> \anchor _todo002152 (user): Indicate when the bounds are trivial (i.e. not intersection with any amo) so that we don't waste more time processing the result? </dd> <dt> \_setscope operations_research::sat::ActivityBoundHelper Member \_internalref classoperations__research_1_1sat_1_1ActivityBoundHelper#ad71179e60a9659f4899d68ad8472b679 "operations_research::sat::ActivityBoundHelper::PresolveEnforcement" (absl::Span< const int > refs, ConstraintProto *ct, absl::flat_hash_set< int > *literals_at_true)</dt><dd> \anchor _todo002146 (user): Ideally these amo should not be added to this class. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a9de52a1eb284f2cf6e20a2a0e713f092 "operations_research::sat::AdaptGlobalParameters" (const CpModelProto &model_proto, Model *model)</dt><dd> \anchor _todo001509 (user): for now this is not deterministic so we disable it on interleave search. Fix. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#af6541cdba8310f4fcbc8d8737cd29afa "operations_research::sat::AddConditionalSum2LowerOrEqual" (absl::Span< const Literal > enforcement_literals, IntegerVariable a, IntegerVariable b, int64_t ub, Model *model)</dt><dd> \anchor _todo002109 (user): Refactor to be sure we do not miss any level zero relations. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#ad3913e8754c767cf5b0be9282bd4c6fe "operations_research::sat::AddConditionalSum3LowerOrEqual" (absl::Span< const Literal > enforcement_literals, IntegerVariable a, IntegerVariable b, IntegerVariable c, int64_t ub, Model *model)</dt><dd> \anchor _todo002110 (user): Use level zero bounds to infer binary precedence relations? </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a799cf49d8b3bb7f3ede756a639e6662c "operations_research::sat::AddCumulativeRelaxation" (const AffineExpression &capacity, SchedulingConstraintHelper *helper, SchedulingDemandHelper *demands, const std::optional< AffineExpression > &makespan, Model *model, LinearRelaxation *relaxation)</dt><dd> \anchor _todo001965 (user): We could use (capacity / demands_gcd) * demands_gcd. \anchor _todo001966 (user): Implement demands_gcd != 1 && capacity is fixed. \anchor _todo001967 (user): In some cases, we could have only one task that can be first. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a9ab304db27f5c4170f35583c69269394 "operations_research::sat::AddDisjunctive" (const std::vector< IntervalVariable > &intervals, Model *model)</dt><dd> \anchor _todo001629 (user): create them dynamically instead? \anchor _todo001650 (user): This is not completely true for empty intervals (start == end). Make sure such intervals are ignored by the constraint. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#abf0e8ef0b1ad01ad3a9aae0a009e5f13 "operations_research::sat::AddLinMaxCutGenerator" (const ConstraintProto &ct, Model *m, LinearRelaxation *relaxation)</dt><dd> \anchor _todo001976 (user): Support linearization of general target expression. \anchor _todo001977 (user): Move this out of here.</dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a655ba5ead1144bc1feff8146e421bffb "operations_research::sat::AddLPConstraints" (bool objective_need_to_be_tight, const CpModelProto &model_proto, Model *m)</dt><dd> \anchor _todo001489 (user): look into biconnected components. \anchor _todo001490 (user): Optimize memory layout. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a919cb1a74305a95883f51e95343ac474 "operations_research::sat::AddWeightedSumLowerOrEqual" (absl::Span< const Literal > enforcement_literals, absl::Span< const IntegerVariable > vars, absl::Span< const int64_t > coefficients, int64_t upper_bound, Model *model)</dt><dd> \anchor _todo001766 (user): Deal with the case with no enforcement literal, in case the presolve was turned off? </dd> <dt> \_setscope operations_research::sat::AffineExpression Member \_internalref structoperations__research_1_1sat_1_1AffineExpression#ae2df741604041f566520f58d28482eef "operations_research::sat::AffineExpression::var" </dt><dd> \anchor _todo001729 (user): Make this private to enforce the invariant that coeff cannot be negative. </dd> <dt> \_setscope operations_research::sat::AllDifferentBoundsPropagator Class \_internalref classoperations__research_1_1sat_1_1AllDifferentBoundsPropagator "operations_research::sat::AllDifferentBoundsPropagator" </dt><dd> \anchor _todo001076 (user): It might be difficult to find something faster than what is implemented here. Some related reference: https://cs.uwaterloo.ca/~vanbeek/Publications/ijcai03_TR.pdf </dd> <dt> \_setscope operations_research::sat::AllDifferentBoundsPropagator Member \_internalref classoperations__research_1_1sat_1_1AllDifferentBoundsPropagator#abcd3b5d1133bde855025a642745ca3b6 "operations_research::sat::AllDifferentBoundsPropagator::Propagate" () final</dt><dd> \anchor _todo001075 (user): investigate the impact. </dd> <dt> \_setscope operations_research::sat::AllDifferentConstraint Member \_internalref classoperations__research_1_1sat_1_1AllDifferentConstraint#a59e041a85cd31545fe5d7e0e3907d3a4 "operations_research::sat::AllDifferentConstraint::AllDifferentConstraint" (std::vector< IntegerVariable > variables, IntegerEncoder *encoder, Trail *trail, IntegerTrail *integer_trail)</dt><dd> \anchor _todo001073 (user): Prune now, ignore these variables during solving. </dd> <dt> \_setscope operations_research::sat::AllDifferentConstraint Member \_internalref classoperations__research_1_1sat_1_1AllDifferentConstraint#a1adb3a2f02ebc277b22879cd01e994b2 "operations_research::sat::AllDifferentConstraint::Propagate" () final</dt><dd> \anchor _todo001074 (user): If needed, there are several ways performance could be improved. If copying the variable state is too costly, it could be maintained instead. If the propagator has too many fruitless calls (without failing/pruning), we can remember the O(n) arcs used in the matching and the SCC decomposition, and guard calls to Propagate() if these arcs are still valid. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#afc1129274beafb17b41ac2fa278de60c "operations_research::sat::AllValuesInDomain" (const ProtoWithDomain &proto)</dt><dd> \anchor _todo001539 (user): work directly on the Domain class instead. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a43f4e0c653d01e67ff65ec40eb96e2e5 "operations_research::sat::AnalyzeIntervals" (bool transpose, absl::Span< const int > local_boxes, absl::Span< const Rectangle > rectangles, absl::Span< const IntegerValue > rectangle_energies, IntegerValue *x_threshold, IntegerValue *y_threshold, Rectangle *conflict)</dt><dd> \anchor _todo001625 (user): If the number of unique x_max is smaller than the number of unique x_min, it is better to do it the other way around. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#ac506719ca656893d93a2a6c940999265 "operations_research::sat::AppendBoolAndRelaxation" (const ConstraintProto &ct, Model *model, LinearRelaxation *relaxation, ActivityBoundHelper *activity_helper)</dt><dd> \anchor _todo001960 (user): These constraints can be many, and if they are not regrouped in big at most ones, then they should probably only added lazily as cuts. Regroup this with future clique-cut separation logic. \anchor _todo001961 (user): More generally, do not miss the same structure if the bool_and was expanded into many clauses! \anchor _todo001962 (user): It is not 100% clear that just not adding one constraint is worse. Relaxation is worse, but then we have less constraint. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a99c02b5f23ff755783f84c851f8dcbb2 "operations_research::sat::AppendElementEncodingRelaxation" (Model *m, LinearRelaxation *relaxation)</dt><dd> \anchor _todo001978 (user): We can do something similar with just an at most one, however it is harder to detect that if all literal are false then none of the implied value can be taken. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a42d3ac4927f1adbca821091239fc06c7 "operations_research::sat::AppendLinearConstraintRelaxation" (const ConstraintProto &ct, bool linearize_enforced_constraints, Model *model, LinearRelaxation *relaxation, ActivityBoundHelper *activity_helper)</dt><dd> \anchor _todo001970 (user): In LoadLinearConstraint() we already created intermediate Booleans for each disjoint interval, we should reuse them here if possible. \anchor _todo001971 (user): process the "at most one" part of a == 1 separately? \anchor _todo001972 (user): Use cleaner "already loaded" logic, and mark as such constraint already encoded by code like AppendRelaxationForEqualityEncoding(). </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a87160f650c0f35013f055fb81b3dfd30 "operations_research::sat::AppendLinMaxRelaxationPart1" (const ConstraintProto &ct, Model *model, LinearRelaxation *relaxation)</dt><dd> \anchor _todo001986 (user): Support linear expression as target. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#aab775ea3151335d5d07e4071e38a4687 "operations_research::sat::AppendLinMaxRelaxationPart2" (IntegerVariable target, const std::vector< Literal > &alternative_literals, const std::vector< LinearExpression > &exprs, Model *model, LinearRelaxation *relaxation)</dt><dd> \anchor _todo001969 (user): Remove hash_map ? </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a9d126152f7618c43746d3f56577b803e "operations_research::sat::AppendMaxAffineRelaxation" (const ConstraintProto &ct, Model *model, LinearRelaxation *relaxation)</dt><dd> \anchor _todo001968 (user): experiment with: 1) remove this code 2) keep this code 3) remove this code and create the cut generator at level 1. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#af8a1aaff5bb36f1dfaf3daea8d5a076e "operations_research::sat::AppendRelaxationForEqualityEncoding" (IntegerVariable var, const Model &model, LinearRelaxation *relaxation, int *num_tight, int *num_loose)</dt><dd> \anchor _todo001959 (user): PartialDomainEncoding() filter pair corresponding to literal set to false, however the initial variable Domain is not always updated. As a result, these min/max can be larger than in reality. Try to fix this even if in practice this is a rare occurrence, as the presolve should have propagated most of what we can. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#abd42a035a99f910066d0a0356eff9ed6 "operations_research::sat::AppendSquareRelaxation" (const ConstraintProto &ct, Model *m, LinearRelaxation *relaxation)</dt><dd> \anchor _todo001975 (user): We could add all or some below_hyperplans. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a1133b1086a2b84ebae1661a744df5a50 "operations_research::sat::ApplyLiteralMappingToBooleanProblem" (const util_intops::StrongVector< LiteralIndex, LiteralIndex > &mapping, LinearBooleanProblem *problem)</dt><dd> \anchor _todo001084 (user): The names is currently all scrambled. Do something about it so that non-fixed variables keep their names. </dd> <dt> \_setscope operations_research::sat::ArcGraphNeighborhoodGenerator Member \_internalref classoperations__research_1_1sat_1_1ArcGraphNeighborhoodGenerator#a23331202e80d1f0b6439fac92b7e2e92 "operations_research::sat::ArcGraphNeighborhoodGenerator::Generate" (const CpSolverResponse &initial_solution, double difficulty, absl::BitGenRef random) final</dt><dd> \anchor _todo001206 (user): should we compress it or use a different representation ? </dd> <dt> \_setscope operations_research::sat::AssignmentInfo Member \_internalref structoperations__research_1_1sat_1_1AssignmentInfo#a2c118b72a43ea721d8c724184e7c54f6 "operations_research::sat::AssignmentInfo::level" </dt><dd> \anchor _todo002193 (user): We may be able to get rid of that for faster enqueues. Most of the code only need to know if this is 0 or the highest level, and for the LBD computation, the literal of the conflict are already ordered by level, so we could do it fairly efficiently. \anchor _todo002194 (user): We currently don't support more than 2^28 decision levels. That should be enough for most practical problem, but we should fail properly if this limit is reached. </dd> <dt> \_setscope operations_research::sat::BasicKnapsackSolver Member \_internalref classoperations__research_1_1sat_1_1BasicKnapsackSolver#abf8b154951fbb851e98a619ff969b0ef "operations_research::sat::BasicKnapsackSolver::Solve" (const std::vector< Domain > &domains, const std::vector< int64_t > &coeffs, const std::vector< int64_t > &costs, const Domain &rhs)</dt><dd> \anchor _todo002394 (user): We can also solve efficiently if max_activity - rhs.Min() is small. Implement. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#ae35ceb34b6366add1981140f6a173339 "operations_research::sat::BasicOrbitopeExtraction" (absl::Span< const std::unique_ptr< SparsePermutation > > generators)</dt><dd> \anchor _todo002356 (user): We could grow each and keep the real maximum. \anchor _todo002357 (user): Detect more than one orbitope? Note that once detected, the structure can be exploited efficiently, but for now, a more "generic" algorithm based on stabilizator should achieve the same preprocessing power, so I don't know how hard we need to invest in orbitope detection. \anchor _todo002358 (user): The heuristic is quite limited for now, but this works on graph20-20-1rand.mps.gz. I suspect the generators provided by the detection code follow our preconditions. </dd> <dt> \_setscope operations_research::sat::BinaryImplicationGraph Class \_internalref classoperations__research_1_1sat_1_1BinaryImplicationGraph "operations_research::sat::BinaryImplicationGraph" </dt><dd> \anchor _todo001124 (user): Most of the note below are done, but we currently only applies the reduction before the solve. We should consider doing more in-processing. The code could probably still be improved too.</dd> <dt> \_setscope operations_research::sat::BinaryImplicationGraph Member \_internalref classoperations__research_1_1sat_1_1BinaryImplicationGraph#ae18864358e7e3f0d4c9c7cf81e3757de "operations_research::sat::BinaryImplicationGraph::AddAtMostOne" (absl::Span< const Literal > at_most_one)</dt><dd> \anchor _todo001128 (user): Our algorithm could generalize easily to at_most_ones + a list of literals that will be false if one of the literal in the amo is at one. It is a way to merge common list of implications.</dd> <dt> \_setscope operations_research::sat::BinaryImplicationGraph Member \_internalref classoperations__research_1_1sat_1_1BinaryImplicationGraph#a76cf257e080c0b1fa5fd4b76f908e51c "operations_research::sat::BinaryImplicationGraph::AddBinaryClause" (Literal a, Literal b)</dt><dd> \anchor _todo001101 (user): Not all of the solver knows about representative literal, do use them here to maintains invariant? Explore this when we start cleaning our clauses using equivalence during search. We can easily do it for every conflict we learn instead of here. \anchor _todo001102 (user): Like this we will duplicate all binary clause from the problem. However this leads to a simpler API (since we don't need to special case the loading of the original clauses) and we mainly use drat proof for testing anyway. </dd> <dt> \_setscope operations_research::sat::BinaryImplicationGraph Member \_internalref classoperations__research_1_1sat_1_1BinaryImplicationGraph#a07e88e219614208bf02f4bed078504f9 "operations_research::sat::BinaryImplicationGraph::ComputeTransitiveReduction" (bool log_info=false)</dt><dd> \anchor _todo001112 (user): Track which literal have new implications, and only process the antecedants of these. \anchor _todo001113 (user): the situation with fixed variable is not really "clean". Simplify the code so we are sure we don't run into issue or have to deal with any of that here. \anchor _todo001114 (user): We should be able to reuse some propagation like it is done for tree-look. Once a node is processed, we just need to process a node that implies it. Test if we can make this faster. Alternatively, only clear a part of is_marked_ (after the first child of root in reverse topo order). \anchor _todo001115 (user): Can we exploit the fact that the implication graph is a skew-symmetric graph (isomorphic to its transposed) so that we do less work? \anchor _todo001116 (user): Another optim we can do is that we never need to expand any node with a reverse topo order smaller or equal to the min of the ones in this list. </dd> <dt> \_setscope operations_research::sat::BinaryImplicationGraph Member \_internalref classoperations__research_1_1sat_1_1BinaryImplicationGraph#aa80bafd5aaf59cc6c7a67176c6304239 "operations_research::sat::BinaryImplicationGraph::DetectEquivalences" (bool log_info=false)</dt><dd> \anchor _todo001111 (user): We could just do it directly though. \anchor _todo001129 (user): Completely get rid of such literal instead? it might not be reasonable code-wise to remap our literals in all of our constraints though. </dd> <dt> \_setscope operations_research::sat::BinaryImplicationGraph Member \_internalref classoperations__research_1_1sat_1_1BinaryImplicationGraph#ab589014979b15460c0cb295527097731 "operations_research::sat::BinaryImplicationGraph::DirectImplications" (Literal literal)</dt><dd> \anchor _todo001122 (user): lazy cleanup the lists on is_removed_? (user): Mark fixed variable as is_removed_ for faster iteration? </dd> <dt> \_setscope operations_research::sat::BinaryImplicationGraph Member \_internalref classoperations__research_1_1sat_1_1BinaryImplicationGraph#af82f4ac499358536858b414345c0b13e "operations_research::sat::BinaryImplicationGraph::EnableSharing" (bool enable)</dt><dd> \anchor _todo001127 (user): this is meant to share clause between workers, hopefully the contention will not be too high. Double check and maybe add a batch version were we keep new implication and add them in batches. </dd> <dt> \_setscope operations_research::sat::BinaryImplicationGraph Member \_internalref classoperations__research_1_1sat_1_1BinaryImplicationGraph#a2735353cc3b14a2ef6574ad9f52c06b7 "operations_research::sat::BinaryImplicationGraph::ExtractAllBinaryClauses" (Output *out) const</dt><dd> \anchor _todo001132 (user): When extracting to cp_model.proto we could be more efficient by extracting bool_and constraint with many lhs terms. \anchor _todo001133 (user): Ideally we should just never have duplicate clauses in this class. But it seems we do in some corner cases, so lets not output them twice. </dd> <dt> \_setscope operations_research::sat::BinaryImplicationGraph Member \_internalref classoperations__research_1_1sat_1_1BinaryImplicationGraph#aba4f40564f3adae0c9b904663bf62637 "operations_research::sat::BinaryImplicationGraph::GenerateAtMostOnesWithLargeWeight" (const std::vector< Literal > &literals, const std::vector< double > &lp_values)</dt><dd> \anchor _todo001130 (user): Refine the heuristic and unit test! </dd> <dt> \_setscope operations_research::sat::BinaryImplicationGraph Member \_internalref classoperations__research_1_1sat_1_1BinaryImplicationGraph#af1d6fe0884e39f01edd6512ea6a7ce1c "operations_research::sat::BinaryImplicationGraph::HeuristicAmoPartition" (std::vector< Literal > *literals)</dt><dd> \anchor _todo001119 (user): Use deterministic limit. (user): Explore the graph instead of just looking at full amo, especially since we expand small ones. \anchor _todo001131 (user): Add a limit to make sure this do not take too much time. </dd> <dt> \_setscope operations_research::sat::BinaryImplicationGraph Member \_internalref classoperations__research_1_1sat_1_1BinaryImplicationGraph#aa37e2a622549d733c3bbb8b340f3c473 "operations_research::sat::BinaryImplicationGraph::MinimizeConflictExperimental" (const Trail &trail, std::vector< Literal > *c)</dt><dd> \anchor _todo001108 (user): Also consider at most one? </dd> <dt> \_setscope operations_research::sat::BinaryImplicationGraph Member \_internalref classoperations__research_1_1sat_1_1BinaryImplicationGraph#ab5846564f39bf6ba28ecdced8429d492 "operations_research::sat::BinaryImplicationGraph::MinimizeConflictFirst" (const Trail &trail, std::vector< Literal > *c, SparseBitset< BooleanVariable > *marked)</dt><dd> \anchor _todo001107 (user): if this is false, then we actually have a conflict of size 2. This can only happen if the binary clause was not propagated properly if for instance we do chronological bactracking without re-enqueing the consequence of a binary clause. </dd> <dt> \_setscope operations_research::sat::BinaryImplicationGraph Member \_internalref classoperations__research_1_1sat_1_1BinaryImplicationGraph#a3cbe67b46860621bfa57c87f5247a385 "operations_research::sat::BinaryImplicationGraph::MinimizeConflictWithReachability" (std::vector< Literal > *c)</dt><dd> \anchor _todo001105 (user): Also consider at most one? \anchor _todo001106 (user): This sounds like a good idea, but somehow it seems better not to do that even though it is almost for free. Investigate more.</dd> <dt> \_setscope operations_research::sat::BinaryImplicationGraph Member \_internalref classoperations__research_1_1sat_1_1BinaryImplicationGraph#a7e4e6130c59dffa6ab52a1cff24400a2 "operations_research::sat::BinaryImplicationGraph::RemoveFixedVariables" ()</dt><dd> \anchor _todo001109 (user): This might not be true if we remove implication by transitive reduction and the process was aborted due to the computation limit. I think it will be good to maintain that invariant though, otherwise fixed literals might never be removed from these lists... \anchor _todo001110 (user): This might be a bit slow. Do not call all the time if needed, this shouldn't change the correctness of the code. </dd> <dt> \_setscope operations_research::sat::BinaryImplicationGraph Member \_internalref classoperations__research_1_1sat_1_1BinaryImplicationGraph#a4a7ae378f427890ed11dfa8efb7c1db7 "operations_research::sat::BinaryImplicationGraph::TransformIntoMaxCliques" (std::vector< std::vector< Literal > > *at_most_ones, int64_t max_num_explored_nodes=1e8)</dt><dd> \anchor _todo001117 (user): Shall we presolve it here? \anchor _todo001118 (user): Detect on the fly is superset already exist. </dd> <dt> \_setscope operations_research::sat::BlockedClauseSimplifier Class \_internalref classoperations__research_1_1sat_1_1BlockedClauseSimplifier "operations_research::sat::BlockedClauseSimplifier" </dt><dd> \anchor _todo002264 (user): This requires that l only appear in clauses and not in the integer part of CP-SAT. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#ac341ac6090ff0bed8ad2231c94cd3bfc "operations_research::sat::BooleanLinearConstraint" (int64_t lower_bound, int64_t upper_bound, std::vector< LiteralWithCoeff > *cst)</dt><dd> \anchor _todo002305 (user): move them in another file, and unit-test them. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a937ae99fd6f6c445a8aad34f04222a1a "operations_research::sat::BooleanLinearExpressionIsCanonical" (absl::Span< const LiteralWithCoeff > cst)</dt><dd> \anchor _todo002047 (user): Also check for no duplicates literals + unit tests. </dd> <dt> \_setscope operations_research::sat::BooleanOrIntegerVariable Struct \_internalref structoperations__research_1_1sat_1_1BooleanOrIntegerVariable "operations_research::sat::BooleanOrIntegerVariable" </dt><dd> \anchor _todo001811 (user): This is currently quadratic as we scan all variables to find the first unassigned one. Fix. Note that this is also the case in many other heuristics and should be fixed. </dd> <dt> \_setscope operations_research::sat::BooleanXorPropagator Class \_internalref classoperations__research_1_1sat_1_1BooleanXorPropagator "operations_research::sat::BooleanXorPropagator" </dt><dd> \anchor _todo001153 (user): By using a two watcher mechanism, we can propagate this a lot faster. </dd> <dt> \_setscope operations_research::sat::BoolRLTCutHelper Member \_internalref classoperations__research_1_1sat_1_1BoolRLTCutHelper#a06106288eec90bbe9cf46ac3712de757 "operations_research::sat::BoolRLTCutHelper::TrySimpleSeparation" (const CutData &input_ct)</dt><dd> \anchor _todo001589 (user): do less work, add more stats. \anchor _todo001590 (user): detect earlier that a factor is not worth checking because we already loose too much with the DROP/MC_CORMICK cases ? Filter more ? I think we can probably evaluate the factor efficiency during the first loop which usually have a small complexity compared to num_factor_to_try times num filtered terms. \anchor _todo001591 (user): we never use factor with lp value < 1e-4, but we could use a factor equal to 1.0 I think. Double check. \anchor _todo001592 (user): We could keep for each factor the max gain, so that we can decided if it is not even worth trying a factor. \anchor _todo001593 (user): Avoid constructing the cut just to evaluate its efficacy. </dd> <dt> \_setscope operations_research::sat::BoundedVariableElimination Member \_internalref classoperations__research_1_1sat_1_1BoundedVariableElimination#a8d5a5e9f809d97c6dc3cbc5d948f4a51 "operations_research::sat::BoundedVariableElimination::DoOneRound" (bool log_info)</dt><dd> \anchor _todo002250 (user): but we shouldn't keep clauses containing removed literals. It is still valid to do so, but it should be less efficient. \anchor _todo002251 (user): add a local dtime limit for the corner case where this take too much time. We can adapt the limit depending on how much we want to spend on inprocessing. \anchor _todo002252 (user): we might also find new equivalent variable l => var => l here, but for now we ignore those. </dd> <dt> \_setscope operations_research::sat::CachedTaskBounds Struct \_internalref structoperations__research_1_1sat_1_1CachedTaskBounds "operations_research::sat::CachedTaskBounds" </dt><dd> \anchor _todo001822 (user): Experiment caching more value. In particular TaskByIncreasingShiftedStartMin() could tie break task for better heuristics? </dd> <dt> \_setscope operations_research::sat::CanonicalBooleanLinearProblem Class \_internalref classoperations__research_1_1sat_1_1CanonicalBooleanLinearProblem "operations_research::sat::CanonicalBooleanLinearProblem" </dt><dd> \anchor _todo002061 (user): Simplify further the constraints. \anchor _todo002062 (user): Remove the duplication between this and what the sat solver is doing in AddLinearConstraint() which is basically the same. \anchor _todo002063 (user): Remove duplicate constraints? some problems have them, and this is not ideal for the symmetry computation since it leads to a lot of symmetries of the associated graph that are not useful. </dd> <dt> \_setscope operations_research::sat::CanonicalBooleanLinearProblem Member \_internalref classoperations__research_1_1sat_1_1CanonicalBooleanLinearProblem#ad91fdf3c0b3d6b5f52ab35e1ea1cfd31 "operations_research::sat::CanonicalBooleanLinearProblem::AddLinearConstraint" (bool use_lower_bound, Coefficient lower_bound, bool use_upper_bound, Coefficient upper_bound, std::vector< LiteralWithCoeff > *cst)</dt><dd> \anchor _todo002065 (user): Use a return status to distinguish errors if needed. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#acf2e86d1933cd807c30272b12a81848e "operations_research::sat::CanonicalizeLinearExpressionInternal" (absl::Span< const int > enforcements, ProtoWithVarsAndCoeffs *proto, int64_t *offset, std::vector< std::pair< int, int64_t > > *tmp_terms, PresolveContext *context)</dt><dd> \anchor _todo002136 (user): Add a quick pass to skip most of the work below if the constraint is already in canonical form? \anchor _todo002137 (user): Avoid the quadratic loop for the corner case of many enforcement literal (this should be pretty rare though). </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a3f5064fe335d0bd2f67a8c9e3e132b4f "operations_research::sat::CeilSquareRoot" (int64_t a)</dt><dd> \anchor _todo002393 (user): Find better implementation? </dd> <dt> \_setscope operations_research::sat::CircuitCoveringPropagator Class \_internalref classoperations__research_1_1sat_1_1CircuitCoveringPropagator "operations_research::sat::CircuitCoveringPropagator" </dt><dd> \anchor _todo001093 (user): Make distinguished nodes an array of Boolean variables, so this can be used for facility location problems. </dd> <dt> \_setscope operations_research::sat::CircuitPropagator Member \_internalref classoperations__research_1_1sat_1_1CircuitPropagator#a54823f9c1557fcb9ee85d3c28c329bf0 "operations_research::sat::CircuitPropagator::Propagate" () final</dt><dd> \anchor _todo001087 (user): both this and the loop on must_be_in_cycle_ might take some time on large graph. Optimize if this become an issue. \anchor _todo001088 (user): we can fail early in more case, like no more possible path to any of the mandatory node. </dd> <dt> \_setscope operations_research::sat::CircuitPropagator Member \_internalref classoperations__research_1_1sat_1_1CircuitPropagator#a05dbff53ce702fea3c1b8dbd913a3228 "operations_research::sat::CircuitPropagator::RegisterWith" (GenericLiteralWatcher *watcher)</dt><dd> \anchor _todo001086 (user): come up with a test that fail when this is not here. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a445ddafc05cd8e1a75db81c1c4426179 "operations_research::sat::ClauseIsEnforcementImpliesLiteral" (absl::Span< const int > clause, absl::Span< const int > enforcement, int literal)</dt><dd> \anchor _todo002150 (user): For the same complexity, we do not need to specify literal and can recover it. </dd> <dt> \_setscope operations_research::sat::ClauseManager Member \_internalref classoperations__research_1_1sat_1_1ClauseManager#a65d15a1a1d08387cb9f9e58e0e153540 "operations_research::sat::ClauseManager::DeleteRemovedClauses" ()</dt><dd> \anchor _todo001100 (user): If more indices are needed, generalize the code to a vector of indices. </dd> <dt> \_setscope operations_research::sat::ClauseManager Member \_internalref classoperations__research_1_1sat_1_1ClauseManager#a4bb2615bf56f39aa7a070d8f4b2b8d03 "operations_research::sat::ClauseManager::Detach" (SatClause *clause)</dt><dd> \anchor _todo001125 (user): It might be better to have a "slower" mode in PropagateOnFalse() that deal with detached clauses in the watcher list and is activated until the next CleanUpWatchers() calls. </dd> <dt> \_setscope operations_research::sat::ClauseManager Member \_internalref classoperations__research_1_1sat_1_1ClauseManager#a00f87aaf6e3bf62d2de2f2c21f3f9d0b "operations_research::sat::ClauseManager::InprocessingAddClause" (absl::Span< const Literal > new_clause)</dt><dd> \anchor _todo001099 (user): We should return false... </dd> <dt> \_setscope operations_research::sat::ClauseManager Member \_internalref classoperations__research_1_1sat_1_1ClauseManager#ad50ac50e7697b1f7dbbaa750fd94cffa "operations_research::sat::ClauseManager::InprocessingFixLiteral" (Literal true_literal)</dt><dd> \anchor _todo001097 (user): remove the test when the DRAT issue with fixed literal is resolved. </dd> <dt> \_setscope operations_research::sat::ClauseManager Member \_internalref classoperations__research_1_1sat_1_1ClauseManager#a19e5abfaaedf626fcfd0d44dd827fc24 "operations_research::sat::ClauseManager::InprocessingRemoveClause" (SatClause *clause)</dt><dd> \anchor _todo001098 (user): We could do something slower if the clauses are attached like we do for InprocessingRewriteClause(). </dd> <dt> \_setscope operations_research::sat::ClauseManager Member \_internalref classoperations__research_1_1sat_1_1ClauseManager#a2615c732b9c2b3c898f353fd68892c38 "operations_research::sat::ClauseManager::NextClauseToMinimize" ()</dt><dd> \anchor _todo001126 (user): If more indices are needed, switch to a generic API. </dd> <dt> \_setscope operations_research::sat::CombinedDisjunctive Member \_internalref classoperations__research_1_1sat_1_1CombinedDisjunctive#ac88bd295048bf30b8726c9f600587287 "operations_research::sat::CombinedDisjunctive< time_direction >::Propagate" () final</dt><dd> \anchor _todo001631 (user): AddEntry() and ComputeEndMin() could be combined. \anchor _todo001632 (user): Maybe factor out the code? It does require a function with a lot of arguments though. \anchor _todo001633 (user): Refactor the code to use the same algo as in DisjunctiveDetectablePrecedences, it is superior and do not need this function. </dd> <dt> \_setscope operations_research::sat::CompiledNoOverlap2dConstraint Member \_internalref classoperations__research_1_1sat_1_1CompiledNoOverlap2dConstraint#a10a4629693ae0553eacd5b7e28f2bb54 "operations_research::sat::CompiledNoOverlap2dConstraint::ComputeViolation" (absl::Span< const int64_t > solution) override</dt><dd> \anchor _todo001144 (user): Experiment with violation += std::max(std::min(NoOverlapMinRepairDistance(x_i, x_j, solution), NoOverlapMinRepairDistance(y_i, y_j, solution)), int64_t{0}); Currently, the effect is unclear on 2d packing problems. </dd> <dt> \_setscope operations_research::sat::CompiledReservoirConstraint Member \_internalref classoperations__research_1_1sat_1_1CompiledReservoirConstraint#a2821a81e871d03153a3d610090648043 "operations_research::sat::CompiledReservoirConstraint::PerformMove" (int, int64_t, absl::Span< const int64_t > solution_with_new_value) final</dt><dd> \anchor _todo001149 (user): we could probably be more incremental here, but it is a bit tricky to get right and not too important since the time is dominated by evaluating moves, not taking them. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a34cc8829256ea003a3f538b06d3a3a74 "operations_research::sat::ComputeLinearRelaxation" (const CpModelProto &model_proto, Model *m)</dt><dd> \anchor _todo001979 (user): Should we add them to the LP anyway? this isn't clear as we can sometimes create a lot of Booleans like this. \anchor _todo001980 (user): This is similar to AppendRelaxationForEqualityEncoding() above. Investigate if we can merge the code. \anchor _todo001981 (user): I am not sure this is still needed. Investigate and explain why or remove. \anchor _todo001982 (user): compute connected components of the original problem and split these cuts accordingly. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#ac47959359a009b02531ab19f206cdd54 "operations_research::sat::ComputeTrueObjectiveLowerBound" (const CpModelProto &model_proto_with_floating_point_objective, const CpObjectiveProto &integer_objective, const int64_t inner_integer_objective_lower_bound)</dt><dd> \anchor _todo002000 (user): Code a custom algo with more precision guarantee? </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#aa56689b779202c61f0f782b3e6545e73 "operations_research::sat::ConditionalWeightedSumLowerOrEqual" (const std::vector< Literal > &enforcement_literals, const std::vector< IntegerVariable > &vars, const std::vector< int64_t > &coefficients, int64_t upper_bound)</dt><dd> \anchor _todo001767 (user): Delete once Telamon use new function. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a08ac4c44a4524b21806a1ae9839bc5bd "operations_research::sat::ConfigureSearchHeuristics" (Model *model)</dt><dd> \anchor _todo001798 (user): We might want to restart if external info is available. Code a custom restart for this? </dd> <dt> \_setscope operations_research::sat::ConstraintPropagationOrder Member \_internalref classoperations__research_1_1sat_1_1ConstraintPropagationOrder#a71728e275e36bbedaaa8007d56131730 "operations_research::sat::ConstraintPropagationOrder::NextId" ()</dt><dd> \anchor _todo001957 (user): fix quadratic algo? We can use var_to_ids_func_() to maintain the degree. But note that with the start_ optim and because we expect mainly degree zero, this seems to be faster. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a807f0da8a99a471e809213176132588f "operations_research::sat::ConstructHeuristicSearchStrategy" (const CpModelProto &cp_model_proto, Model *model)</dt><dd> \anchor _todo001443 (user): Implement a routing search. \anchor _todo001444 (user): Alternatively, support creation of SatPropagator at positive level. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a92a908deada7d4dc2b1d0dbfb427e040 "operations_research::sat::ConstructIntegerCompletionSearchStrategy" (const std::vector< IntegerVariable > &variable_mapping, IntegerVariable objective_var, Model *model)</dt><dd> \anchor _todo001445 (user): we could also fix terms of the objective in the right direction. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#ab621abdbab919d365ca747aebdd2ff74 "operations_research::sat::ConstructUserSearchStrategy" (const CpModelProto &cp_model_proto, Model *model)</dt><dd> \anchor _todo001442 (user): Improve the complexity if this becomes an issue which may be the case if we do a fixed_search. </dd> <dt> \_setscope operations_research::sat::ContinuousProber Member \_internalref classoperations__research_1_1sat_1_1ContinuousProber#a1e83f97c78745b456678edb911c2147c "operations_research::sat::ContinuousProber::ContinuousProber" (const CpModelProto &model_proto, Model *model)</dt><dd> \anchor _todo001807 (user): Ideally, we should scan the internal model. But there can be a large blowup of variables during loading, which slows down the probing part. Using model variables is a good heuristic to select 'impactful' Boolean variables. </dd> <dt> \_setscope operations_research::sat::ContinuousProber Member \_internalref classoperations__research_1_1sat_1_1ContinuousProber#a1de4d4b22a2717e58b2444683a806d22 "operations_research::sat::ContinuousProber::Probe" ()</dt><dd> \anchor _todo001808 (user): - sort variables before the iteration (statically or dynamically) - compress clause databases regularly (especially the implication graph) - better interleaving of the probing and shaving phases - move the shaving code directly in the probing class - probe all variables and not just the model ones \anchor _todo001809 (user): Probe optional variables. \anchor _todo001810 (user): Currently, the heuristics is that we alternate shaving and not shaving, unless use_shaving_in_probing_search is false. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#ac9c41d8a7687386839ef94182e3badb9 "operations_research::sat::ConvertCpModelProtoToMPModelProto" (const CpModelProto &input, MPModelProto *output)</dt><dd> \anchor _todo001992 (user): Support more constraints with enforcement. \anchor _todo001999 (user): This first version do not even handle basic Boolean constraint. Support more constraints as needed. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a2d32bfb7e130364f3dd94087b686b6f5 "operations_research::sat::ConvertMPModelProtoToCpModelProto" (const SatParameters &params, const MPModelProto &mp_model, CpModelProto *cp_model, SolverLogger *logger)</dt><dd> \anchor _todo001990 (user): This could be made larger if needed, so be smarter if we have MIP problem that we cannot "convert" because of this. Note however than we cannot go that much further because we need to make sure we will not run into overflow if we add a big linear combination of such variables. It should always be possible for a user to scale its problem so that all relevant quantities are a couple of millions. A LP/MIP solver have a similar condition in disguise because problem with a difference of more than 6 magnitudes between the variable values will likely run into numeric trouble. \anchor _todo001991 (user): We could avoid these cases by shifting the domain of all variables to contain zero. This should also lead to a better scaling, but it has some complications with integer variables and require some post-solve. </dd> <dt> \_setscope operations_research::sat::CoreBasedOptimizer Member \_internalref classoperations__research_1_1sat_1_1CoreBasedOptimizer#ab0a342f8fad2c4262b0ddec85b98bdf8 "operations_research::sat::CoreBasedOptimizer::Optimize" ()</dt><dd> \anchor _todo002028 (user): Try to understand exactly why and merge both code path. \anchor _todo002029 (user): It might be interesting to redo this kind of presolving once high cost booleans have been fixed as we might have more at most one between literal in the objective by then. \anchor _todo002030 (user): The core is returned in the same order as the assumptions, so we don't really need this map, we could just do a linear scan to recover which node are part of the core. This however needs to be properly unit tested before usage. \anchor _todo002031 (user): This always resets the solver to level zero. Because of that we don't resume a solve in "chunk" perfectly. Fix. \anchor _todo002032 (user): If the search is aborted during this phase and we solve in "chunk", we don't resume perfectly from where it was. Fix. \anchor _todo002033 (user): These can be simply removed from the list. \anchor _todo002034 (user): we could keep an objective offset instead. \anchor _todo002035 (user): We can probably be smarter about the cost of the assumptions though. \anchor _todo002036 (user): If the "search" is interrupted while computing cores, we currently do not resume it flawlessly. We however add any cores we found before aborting. \anchor _todo002037 (user): Maybe the solver should do it right away. \anchor _todo002042 (user): Change the algo slighlty to allow resuming from the last aborted position. Currently, the search is "resumable", but it will restart some of the work already done, so it might just never find anything. </dd> <dt> \_setscope operations_research::sat::CoreBasedOptimizer Member \_internalref classoperations__research_1_1sat_1_1CoreBasedOptimizer#a5a4a53c17d32408e49285f11171673fa "operations_research::sat::CoreBasedOptimizer::OptimizeWithSatEncoding" (absl::Span< const Literal > literals, absl::Span< const IntegerVariable > vars, absl::Span< const Coefficient > coefficients, Coefficient offset)</dt><dd> \anchor _todo002021 (user): We could create EncodingNode out of IntegerVariable. \anchor _todo002022 (user): It could still be beneficial to add one. Experiments. \anchor _todo002023 (user): This might not be ideal if there are holes in the domain. It should work by adding duplicates literal, but we should be able to be more efficient. \anchor _todo002024 (user): Find multiple core like in the "main" algorithm. This is just trying to solve with assumptions not involving the newly found core. \anchor _todo002025 (user): With stratification, sometime we just spend too much time trying to find a feasible solution/prove infeasibility and we could instead just use stratification=0 to find easty core and improve lower bound. \anchor _todo002043 (user): - Support resuming for interleaved search. - Implement all core heurisitics. </dd> <dt> \_setscope operations_research::sat::CoverCutHelper Member \_internalref classoperations__research_1_1sat_1_1CoverCutHelper#a29be1489d397a5d646a838946a85a225 "operations_research::sat::CoverCutHelper::TrySimpleKnapsack" (const CutData &input_ct, ImpliedBoundsProcessor *ib_processor=nullptr)</dt><dd> \anchor _todo001577 (user): we don't have to pick max_coeff_in_cover and could use the coefficient of the most fractional variable. Or like in the MIR code try a few of them. Currently, the cut in the test is worse if we don't take the max_coeff_in_cover though, so we need more understanding. \anchor _todo001578 (user): It seems we could use a more advanced lifting function described later in the paper. Investigate. \anchor _todo001579 (user): Experiment without this line that basically disable scoring. \anchor _todo001580 (user): experiment with different value of scaling and param t. </dd> <dt> \_setscope operations_research::sat::CoverCutHelper Member \_internalref classoperations__research_1_1sat_1_1CoverCutHelper#abf54256e1bd003c568c2efd55d75fdd6 "operations_research::sat::CoverCutHelper::TrySingleNodeFlow" (const CutData &input_ct, ImpliedBoundsProcessor *ib_processor=nullptr)</dt><dd> \anchor _todo001581 (user): Change the heuristic to depends on the lp_value of the implied bounds. This way we can exactly match what happen in the old FlowCoverCutHelper. \anchor _todo001582 (user): Shouldn't we just use rounding f() with maximum coeff to allows lift of all other terms? but then except for the heuristic the cut is really similar to the cover cut. \anchor _todo001583 (user): If the Mir*() function is used, we don't need to extend that much the period. Fix. \anchor _todo001584 (user): do exact binary search to find highest x in [-max_neg_magnitude, 0] such that f(x) == f(-max_neg_magnitude) ? not really needed though since we know that we have this equality: </dd> <dt> \_setscope operations_research::sat::CoverCutHelper Member \_internalref classoperations__research_1_1sat_1_1CoverCutHelper#a82f509c2f8c4ea40561f572f6a612ebd "operations_research::sat::CoverCutHelper::TryWithLetchfordSouliLifting" (const CutData &input_ct, ImpliedBoundsProcessor *ib_processor=nullptr)</dt><dd> \anchor _todo001585 (user): Merge Boolean terms that are complement of each other. \anchor _todo001586 (user): we currently only deal with Boolean in the cover. Fix. \anchor _todo001587 (user): compute this in an overflow-safe way. \anchor _todo001588 (user): For exact multiple of p/q we can increase the coeff by 1/2. See section in the paper on getting maximal super additive function. \anchor _todo001610 (user): Generalize to non-Boolean, or use a different cover heuristic for this: - We want a Boolean only cover currently. - We can always use implied bound for this, since there is more chance for a Bool only cover. - Also, f() should be super additive on the value <= rhs, i.e. f(a + b) >= f(a) + f(b), so it is always good to use implied bounds of the form X = bound * B + Slack. </dd> <dt> \_setscope operations_research::sat::CpModelMapping Member \_internalref classoperations__research_1_1sat_1_1CpModelMapping#a58809f5b0a739fa62cf923b2ed919df5 "operations_research::sat::CpModelMapping::Affine" (const LinearExpressionProto &exp) const</dt><dd> \anchor _todo001246 (user): We could "easily" create an intermediate variable for more complex linear expression. We could also identify duplicate expressions to not create two identical integer variable. </dd> <dt> \_setscope operations_research::sat::CpModelPresolver Class \_internalref classoperations__research_1_1sat_1_1CpModelPresolver "operations_research::sat::CpModelPresolver" </dt><dd> \anchor _todo001436 (user): Identify disconnected components and returns a vector of presolved model? If we go this route, it may be nicer to store the indices inside the model. We can add a IntegerVariableProto::initial_index; </dd> <dt> \_setscope operations_research::sat::CpModelPresolver Member \_internalref classoperations__research_1_1sat_1_1CpModelPresolver#a4eea655cfbd484263d86d3d89af42bf5 "operations_research::sat::CpModelPresolver::Presolve" ()</dt><dd> \anchor _todo001420 (user): move in the context. \anchor _todo001421 (user): We should probably try to delay this even more. For that we just need to isolate more the "dual" reduction that usually need to look at the objective. \anchor _todo001422 (user): The presolve transformations we do after this is called might result in even more presolve if we were to call this again! improve the code. See for instance plusexample_6_sat.fzn were represolving the presolved problem reduces it even more. \anchor _todo001423 (user): Make sure we can't have duplicate in these constraint. These are due to ExpandCpModel() were we create such constraint with duplicate. The problem is that some code assumes these are presolved before being called. \anchor _todo001424 (user): Decide where is the best place for this. \anchor _todo001425 (user): try not to break symmetry in our clique extension or other more advanced presolve rule? Ideally we could even exploit them. But in this case, it is still good to compute them early. \anchor _todo001426 (user): more generally if we do some probing, the same relation will be detected (and more). Also add an option to turn this off? \anchor _todo001427 (user): instead of extracting at most one, extract pairwise conflicts and add them to bool_and clauses? this is some sort of small scale probing, but good for sat presolve and clique later? \anchor _todo001428 (user): revisit when different transformation appear. \anchor _todo001429 \anchor _todo001430 (user): merge these code instead of doing many passes? \anchor _todo001431 (user): try to be smarter and avoid looping again if little changed. </dd> <dt> \_setscope operations_research::sat::CpModelView Class \_internalref classoperations__research_1_1sat_1_1CpModelView "operations_research::sat::CpModelView" </dt><dd> \anchor _todo001455 (user): For now it uses proto indices of the loaded model. We will need to add a mapping to use proto indices of the non-presolved model to allow for a client custom search with presolve. The main API shouldn't change though and the change will be transparent. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#af443c47f14a044d69553b02337b5dc52 "operations_research::sat::CpSolverResponseStats" (const CpSolverResponse &response, bool has_objective)</dt><dd> \anchor _todo001456 (user): This is probably better named "binary_propagation", but we just output "propagations" to be consistent with sat/analyze.sh. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#ae3fd4466b012022bab0c5c1839c77890 "operations_research::sat::CreateAlternativeLiteralsWithView" (int num_literals, Model *model, LinearRelaxation *relaxation)</dt><dd> \anchor _todo001963 (user): We shouldn't need to create this view ideally. Even better, we should be able to handle Literal natively in the linear relaxation, but that is a lot of work. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a55cafa81679ac10c971927ca17ec7f2e "operations_research::sat::CreateCumulativeEnergyCutGenerator" (SchedulingConstraintHelper *helper, SchedulingDemandHelper *demands_helper, const AffineExpression &capacity, const std::optional< AffineExpression > &makespan, Model *model)</dt><dd> \anchor _todo002320 (user): use level 0 bounds ? </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a88677d1180474733727feff2bbca0d31 "operations_research::sat::CreateFlowCutGenerator" (int num_nodes, const std::vector< int > &tails, const std::vector< int > &heads, const std::vector< AffineExpression > &arc_capacities, std::function< void(const std::vector< bool > &in_subset, IntegerValue *min_incoming_flow, IntegerValue *min_outgoing_flow)> get_flows, Model *model)</dt><dd> \anchor _todo002189 (user): Support general linear expression for capacities. (user): Some model applies the same capacity to both an arc and its reverse. Also support this case. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a5453ae22e516e4fb4216ea56bab9d860 "operations_research::sat::CreateNoOverlap2dCompletionTimeCutGenerator" (SchedulingConstraintHelper *x_helper, SchedulingConstraintHelper *y_helper, Model *model)</dt><dd> \anchor _todo001621 (user): Use demands_helper and decomposed energy. \anchor _todo001622 (user): It might be possible/better to use some shifted value here, but for now this code is not in the hot spot, so better be defensive and only do connected components on really disjoint rectangles. \anchor _todo001623 (user): Use improved energy from demands helper. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#ae19357ee0ddd4752e39f7bbf6cb3ae05 "operations_research::sat::CreateNoOverlap2dEnergyCutGenerator" (SchedulingConstraintHelper *x_helper, SchedulingConstraintHelper *y_helper, SchedulingDemandHelper *x_demands_helper, SchedulingDemandHelper *y_demands_helper, const std::vector< std::vector< LiteralValueValue > > &energies, Model *model)</dt><dd> \anchor _todo001617 (user): It might be possible/better to use some shifted value here, but for now this code is not in the hot spot, so better be defensive and only do connected components on really disjoint rectangles. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a28abd2fe9199829f0c98ade48cfe459c "operations_research::sat::CreatePositiveMultiplicationCutGenerator" (AffineExpression z, AffineExpression x, AffineExpression y, int linearization_level, Model *model)</dt><dd> \anchor _todo001597 (user): As the bounds change monotonically, these cuts dominate any previous one. try to keep a reference to the cut and replace it. Alternatively, add an API for a level-zero bound change callback. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a692069c042245ee1df0d7e2631fe9a39 "operations_research::sat::Cumulative" (const std::vector< IntervalVariable > &vars, const std::vector< AffineExpression > &demands, AffineExpression capacity, SchedulingConstraintHelper *helper)</dt><dd> \anchor _todo001540 (user): Change that since we have optional interval for this. \anchor _todo001541 (user): We need to exclude intervals that can be of size zero because the disjunctive do not "ignore" them like the cumulative does. That is, the interval [2,2) will be assumed to be in disjunction with [1, 3) for instance. We need to uniformize the handling of interval with size zero. \anchor _todo001542 (user): Do proper experiments to see how beneficial this is, the disjunctive will propagate more but is also using slower algorithms. That said, this is more a question of optimizing the disjunctive propagation code. \anchor _todo001543 (user): Another "known" idea is to detect pair of tasks that must be in disjunction and to create a Boolean to indicate which one is before the other. It shouldn't change the propagation, but may result in a faster one with smaller explanations, and the solver can also take decision on such Boolean. \anchor _todo001544 (user): A better place for stuff like this could be in the presolver so that it is easier to disable and play with alternatives. \anchor _todo001545 (user): Models that include the makespan as a special interval might be better, but then not everyone does that. In particular this code allows to have decent lower bound on the large cumulative minizinc instances. \anchor _todo001546 (user): this require the precedence constraints to be already loaded, and there is no guarantee of that currently. Find a more robust way. \anchor _todo001547 (user): There is a bit of code duplication with the disjunctive precedence propagator. Abstract more? \anchor _todo001548 (user): Handle generic affine relation? \anchor _todo001549 (user): This can lead to many constraints. By analyzing a bit more the precedences, we could restrict that. In particular for cases were the cumulative is always (bunch of tasks B), T, (bunch of tasks A) and task T always in the middle, we never need to explicit list the precedence of a task in B with a task in A. \anchor _todo001550 (user): If more than one variable are after the same set of intervals, we should regroup them in a single constraint rather than having two independent constraint doing the same propagation. </dd> <dt> \_setscope operations_research::sat::CumulativeDualFeasibleEnergyConstraint Member \_internalref classoperations__research_1_1sat_1_1CumulativeDualFeasibleEnergyConstraint#a214c101bb659b1243cc9a5c2c0882a1f "operations_research::sat::CumulativeDualFeasibleEnergyConstraint::Propagate" () final</dt><dd> \anchor _todo001559 (user): explore with using Theta-trees with a multi-valued energy value. </dd> <dt> \_setscope operations_research::sat::CumulativeEnergyConstraint Member \_internalref classoperations__research_1_1sat_1_1CumulativeEnergyConstraint#a1058cbb9c9572113e896f5c7c471eacc "operations_research::sat::CumulativeEnergyConstraint::Propagate" () final</dt><dd> \anchor _todo001551 (user): just keep the current direction? \anchor _todo001552 (user): force capacity_max >= 0, fail/remove optionals when 0. \anchor _todo001553 (user): We do not need the capacity max in the reason, but by using a lower one, we could maybe have propagated more the minimum capacity. investigate. \anchor _todo001554 (user): This could be done lazily. \anchor _todo001555 \anchor _todo001556 (user): the same required task can have its energy pruned several times, making this algorithm O(n^2 log n). Is there a way to get the best pruning in one go? This looks like edge-finding not being able to converge in one pass, so it might not be easy. \anchor _todo001557 (user): Improve window_end using envelope of critical event. </dd> <dt> \_setscope operations_research::sat::CumulativeIsAfterSubsetConstraint Class \_internalref classoperations__research_1_1sat_1_1CumulativeIsAfterSubsetConstraint "operations_research::sat::CumulativeIsAfterSubsetConstraint" </dt><dd> \anchor _todo001560 (user): I am not sure this is the best way, but it does at least push the level zero bound on the large cumulative instances. </dd> <dt> \_setscope operations_research::sat::CumulativeIsAfterSubsetConstraint Member \_internalref classoperations__research_1_1sat_1_1CumulativeIsAfterSubsetConstraint#a9d0445b319d93772786a042918c970c2 "operations_research::sat::CumulativeIsAfterSubsetConstraint::Propagate" () final</dt><dd> \anchor _todo001558 (user): actually, we will push using the last task, and the reason will be non-optimal, fix. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#af421daf12e0e45a0bb3cc7655cd443cc "operations_research::sat::CumulativePrecedenceSearchHeuristic" (Model *model)</dt><dd> \anchor _todo001787 (user): tie-break tasks not fitting in the profile smartly. \anchor _todo001788 (user): If the two box cannot overlap because of high demand, use repo.CreateDisjunctivePrecedenceLiteral() instead. \anchor _todo001789 (user): Add heuristic ordering for creating interesting precedence first. \anchor _todo001790 (user): We need to add the reason for demand_min and capacity_max. \anchor _todo001791 \anchor _todo001792 (user): unfortunately we can't report it from here. \anchor _todo001793 (user): add heuristic criteria, right now we stop at first one. See above. </dd> <dt> \_setscope operations_research::sat::CutDataBuilder Member \_internalref classoperations__research_1_1sat_1_1CutDataBuilder#a6c27f24f411983fa4e7333dcadb9fd55 "operations_research::sat::CutDataBuilder::ConvertToLinearConstraint" (const CutData &cut, LinearConstraint *output)</dt><dd> \anchor _todo001561 (user): Divide by gcd first to avoid possible overflow in the conversion? it is however unlikely given that our coeffs should be small. </dd> <dt> \_setscope operations_research::sat::CutTerm Member \_internalref structoperations__research_1_1sat_1_1CutTerm#a302409b0ad6af0cc718fab498bcdadde "operations_research::sat::CutTerm::expr_offset" </dt><dd> \anchor _todo001609 (user): We might want to store that elsewhere, as sorting CutTerm is a bit slow and we don't need to look at that in most places. Same for the cached_implied_lb/ub below. </dd> <dt> \_setscope operations_research::sat::DebugSolution Member \_internalref structoperations__research_1_1sat_1_1DebugSolution#a5cff986a172f5615625e27f2c084fc07 "operations_research::sat::DebugSolution::ivar_has_value" </dt><dd> \anchor _todo001730 (user): When this happen we should be able to infer the value of these derived variable in the solution. For now, we only do that for the objective variable. </dd> <dt> \_setscope operations_research::sat::DecompositionGraphNeighborhoodGenerator Class \_internalref classoperations__research_1_1sat_1_1DecompositionGraphNeighborhoodGenerator "operations_research::sat::DecompositionGraphNeighborhoodGenerator" </dt><dd> \anchor _todo001217 (user): Doing the full heuristic treewidth decomposition is probably better because when we grow the current neighborhood, just using local connection to the current candidate is probably not enough to orient the search towards a good final neighborhood. </dd> <dt> \_setscope operations_research::sat::DecompositionGraphNeighborhoodGenerator Member \_internalref classoperations__research_1_1sat_1_1DecompositionGraphNeighborhoodGenerator#af329eaefae094534e41a135a9b6443af "operations_research::sat::DecompositionGraphNeighborhoodGenerator::Generate" (const CpSolverResponse &initial_solution, double difficulty, absl::BitGenRef random) final</dt><dd> \anchor _todo001207 (user): Does starting by a constraint make sense too? </dd> <dt> \_setscope operations_research::sat::DelayedRootLevelDeduction Struct \_internalref structoperations__research_1_1sat_1_1DelayedRootLevelDeduction "operations_research::sat::DelayedRootLevelDeduction" </dt><dd> \anchor _todo001724 (user): If we change the logic to not restart right away, we probably need to remove duplicates bounds for the same variable. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a3423c28a2a00161e74d9c6e0174bcbf6 "operations_research::sat::DetectAndExploitSymmetriesInPresolve" (PresolveContext *context)</dt><dd> \anchor _todo001514 (user): Doing that is not always good, on cod105.mps, fixing variables instead of letting the inner solver handle Boolean symmetries make the problem unsolvable instead of easily solved. This is probably because this fixing do not exploit the full structure of these symmeteries. Note however that the fixing via propagation above close cod105 even more efficiently. \anchor _todo001515 (user): The same effect could be achieved by adding symmetry breaking constraints of the form "a >= b " between Booleans and let the presolve do the reduction. This might be less code, but it is also less efficient. Similarly, when we cannot just fix variables to break symmetries, we could add these constraints, but it is unclear if we should do it all the time or not. \anchor _todo001516 (user): code the generic approach with orbits and stabilizer. \anchor _todo001517 (user): generalize somehow. See if we can exploit this in lb_tree_search directly. We also have a lot more structure than just the objective can be ordered. Like if the objective is a max, we can still do that. \anchor _todo001518 (user): Actually the constraint we add is really just breaking the orbitope symmetry on one line. But this line being the objective is key. We can also explicitly look for a full permutation group of the objective terms directly instead of finding the largest orbitope first. \anchor _todo001519 (user): Compute the stabilizer under the only non-fixed element and iterate! \anchor _todo001520 (user): The code below requires that no variable appears twice in the same at most one. In particular lit and not(lit) cannot appear in the same at most one. \anchor _todo001521 (user): for 1/ and 2/ we could add an at most one constraint on the full row if it is not already there! \anchor _todo001522 (user): if the same at most one touch more than one row, we can deduce more. It is a bit tricky and maybe not frequent enough to make a big difference. Also, as we start to fix things, at most one might propagate by themselves. \anchor _todo001523 (user): We could remove these rows from the orbitope. Note that currently this never happen on the miplib (maybe in LNS though). \anchor _todo001524 (user): This is probably not needed if we add lexicographic constraint instead of just breaking a single row below. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a753e3aea07903c667891eb57036d26de "operations_research::sat::DetectImpliedIntegers" (MPModelProto *mp_model, SolverLogger *logger)</dt><dd> \anchor _todo001987 (user): be smarter! we should be able to handle these cases. \anchor _todo001988 (user): If we scale more we migth be able to turn it into an integer. \anchor _todo001998 (user): Actually implement the offset part. This currently only happens on the 3 neos-46470* miplib problems where we have a non-integer rhs. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a825c5b32096a00edc3e2e3fd78c7d541 "operations_research::sat::DetectMakespan" (const std::vector< IntervalVariable > &intervals, const std::vector< AffineExpression > &demands, const AffineExpression &capacity, Model *model)</dt><dd> \anchor _todo001964 (user): Supports variable capacity. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a3216f11aeb59c8cd63d2a1e8cdc6d47b "operations_research::sat::DetectOptionalVariables" (const CpModelProto &model_proto, Model *m)</dt><dd> \anchor _todo001237 (user): This deals with the simplest cases, but we could try to detect literals that implies all the constraints in which a variable appear to false. This can be done with a LCA computation in the tree of Boolean implication (once the presolve remove cycles). Not sure if we can properly exploit that afterwards though. Do some research! </dd> <dt> \_setscope operations_research::sat::DisjunctiveOverloadChecker Member \_internalref classoperations__research_1_1sat_1_1DisjunctiveOverloadChecker#a201afdaa7c1eb9776d9fd66837cd8fed "operations_research::sat::DisjunctiveOverloadChecker::Propagate" () final</dt><dd> \anchor _todo001634 (user): Actually, we just infered a "not last" so we could check for relevant_size > 2 potential propagation? \anchor _todo001635 (user): Can we detect and propagate all such relations easily and do a pass before this maybe? On a related note, because this propagator is not instantiated in both direction, we might miss some easy propag. \anchor _todo001636 (user): Shall we keep propagating? we know the prefix didn't change, so we could be faster here. On another hand, it might be better to propagate all the linear constraints before returning here. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a33798fe85208035f149a5c124b89b7b4 "operations_research::sat::DisjunctivePrecedenceSearchHeuristic" (Model *model)</dt><dd> \anchor _todo001783 (user): tie break by size/start-max \anchor _todo001784 \anchor _todo001785 (user): Use conditional lower bounds? note that in automatic search all precedence will be fixed before this is called though. In fixed search maybe we should use the other SchedulingSearchHeuristic(). \anchor _todo001786 (Fdid): Also compare the second part of the precedence in PrecedenceIsBetter() and not just the interval before? </dd> <dt> \_setscope operations_research::sat::DisjunctiveWithTwoItems Member \_internalref classoperations__research_1_1sat_1_1DisjunctiveWithTwoItems#aded29605fb1b5e0a55697fabdc9797ae "operations_research::sat::DisjunctiveWithTwoItems::Propagate" () final</dt><dd> \anchor _todo001630 (user): For optional interval whose presence in unknown and without optional variable, the end-min may not be propagated to at least (start_min + size_min). Consider that into the computation so we may decide the interval forced absence? Same for the start-max. </dd> <dt> \_setscope operations_research::sat::DivisionPropagator Class \_internalref classoperations__research_1_1sat_1_1DivisionPropagator "operations_research::sat::DivisionPropagator" </dt><dd> \anchor _todo001764 (user): Deal with overflow. </dd> <dt> \_setscope operations_research::sat::DivisionPropagator Member \_internalref classoperations__research_1_1sat_1_1DivisionPropagator#ac89f35a696a3d291bfafae382a1332ca "operations_research::sat::DivisionPropagator::Propagate" () final</dt><dd> \anchor _todo001758 (user): We can propagate more, especially in the case where denom spans across 0. (user): We can propagate a bit more if min_div = 0: (min_num > -min_denom). </dd> <dt> \_setscope operations_research::sat::DomainDeductions Class \_internalref classoperations__research_1_1sat_1_1DomainDeductions "operations_research::sat::DomainDeductions" </dt><dd> \anchor _todo002147 (user): Also use these "deductions" in the solver directly. This is done in good MIP solvers, and we should exploit them more. \anchor _todo002148 (user): Also propagate implicit clauses (lit, not(lit)). Maybe merge that with probing code? it might be costly to store all deduction done by probing though, but I think this is what MIP solver do. </dd> <dt> \_setscope operations_research::sat::DomainDeductions Member \_internalref classoperations__research_1_1sat_1_1DomainDeductions#a90eec97bf72d63f4c921156b3f31c5a4 "operations_research::sat::DomainDeductions::ProcessClause" (absl::Span< const int > clause)</dt><dd> \anchor _todo002151 (user): We could probably be even more efficient. We could also compute exactly what clauses need to be "waked up" as new deductions are added. </dd> <dt> \_setscope operations_research::sat::DratProofHandler Member \_internalref classoperations__research_1_1sat_1_1DratProofHandler#a8ceaa4570135a1216539fccb736088ca "operations_research::sat::DratProofHandler::ApplyMapping" (const util_intops::StrongVector< BooleanVariable, BooleanVariable > &mapping)</dt><dd> \anchor _todo001653 (user): This is exactly the same mecanism as in the SatPostsolver class. Factor out the code. </dd> <dt> \_setscope operations_research::sat::DualBoundStrengthening Class \_internalref classoperations__research_1_1sat_1_1DualBoundStrengthening "operations_research::sat::DualBoundStrengthening" </dt><dd> \anchor _todo002432 (user): This is actually an important step to do before scaling as it can usually reduce really large bounds! </dd> <dt> \_setscope operations_research::sat::DualBoundStrengthening Member \_internalref classoperations__research_1_1sat_1_1DualBoundStrengthening#aa3f78681f549714a6bcfabc007aa985d "operations_research::sat::DualBoundStrengthening::CannotDecrease" (absl::Span< const int > refs, int ct_index=-1)</dt><dd> \anchor _todo002411 (user): No need to set locking_ct_index_[var] if num_locks_[var] > 1 </dd> <dt> \_setscope operations_research::sat::DualBoundStrengthening Member \_internalref classoperations__research_1_1sat_1_1DualBoundStrengthening#a162bcb064138a579ee8192ffb9c244cb "operations_research::sat::DualBoundStrengthening::Strengthen" (PresolveContext *context)</dt><dd> \anchor _todo002412 (user): Cover all the cases. \anchor _todo002413 (user): Fix variable right away rather than waiting for next call. \anchor _todo002414 (user): We can also deal with more than one enforcement. \anchor _todo002415 (user): Generalize to non-Boolean. Also for Boolean, we might miss some possible reduction if replacing X by 1 - X make a constraint near-duplicate of another. \anchor _todo002416 (user): We can generalize to non-linear constraint. \anchor _todo002417 (user): Make sure implication graph is transitively reduced to not miss such reduction. More generally, this might only use the graph rather than the encoding into bool_and / at_most_one ? Basically if a => all_direct_deduction, we can transform it into a <=> all_direct_deduction if that is interesting. This could always be done on a max-2sat problem in one of the two direction. Also think about max-2sat specific presolve. </dd> <dt> \_setscope operations_research::sat::EncodingNode Member \_internalref classoperations__research_1_1sat_1_1EncodingNode#a4db8bdd99cd1c21623273512082cd8a6 "operations_research::sat::EncodingNode::GenericNode" (int lb, int ub, std::function< Literal(int x)> create_lit, Coefficient weight)</dt><dd> \anchor _todo001655 (user): Not ideal, we should probably just provide index in the original objective for sorting purpose. </dd> <dt> \_setscope operations_research::sat::EncodingNode Member \_internalref classoperations__research_1_1sat_1_1EncodingNode#a93fd5b911e64c63ed4b1b32dc42a571d "operations_research::sat::EncodingNode::TransformToBoolean" (SatSolver *solver)</dt><dd> \anchor _todo001656 (user): Avoid creating a Boolean just to fix it! </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#ac32fa78e911692fae246c73675cc3970 "operations_research::sat::ExactlyOnePerRowAndPerColumn" (const std::vector< std::vector< Literal > > &graph)</dt><dd> \anchor _todo001094 (user): Change to a sparse API like for the function above. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a265b8cf37f58fb2c78b247a6412ce519 "operations_research::sat::ExploitDominanceRelations" (const VarDomination &var_domination, PresolveContext *context)</dt><dd> \anchor _todo002424 (user): More generally, combine with probing? if a dominated variable implies one of its dominant to zero, then it can be set to zero. It seems adding the implication below should have the same effect? but currently it requires a lot of presolve rounds. \anchor _todo002425 (user): if both variable are in a bool_or, this will allow us to remove the dominated variable. Maybe we should exploit that to decide which implication we add. Or just remove such variable and not add the implications? \anchor _todo002426 (user): generalize to non Booleans? \anchor _todo002427 (user): It look like testing this is not really necessary. The reduction done by this class seem to be order independent. \anchor _todo002428 (user): Is this needed? \anchor _todo002429 (user): maybe the last point can be improved. \anchor _todo002430 (user): We should probably be able to do something with this. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a97b2ab4ecaa7da4d40522982c3e221e4 "operations_research::sat::ExtractAllSubsetsFromForest" (const std::vector< int > &parent, std::vector< int > *subset_data, std::vector< absl::Span< const int > > *subsets, int node_limit)</dt><dd> \anchor _todo002188 (user): This also allocate O(n) memory internally, we could reuse it from call to call if needed. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a89efb582832622f508e29d0c32f56ca9 "operations_research::sat::ExtractElementEncoding" (const CpModelProto &model_proto, Model *m)</dt><dd> \anchor _todo001234 (user): It should be safe otherwise the exactly_one will have duplicate literal, but I am not sure that if presolve is off we can assume that. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#afa73e23a5cfae0eaf253c2e2518e05e7 "operations_research::sat::ExtractEncoding" (const CpModelProto &model_proto, Model *m)</dt><dd> \anchor _todo001226 (user): Regroup/presolve two encoding like b => x > 2 and the same Boolean b => x > 5. These shouldn't happen if we merge linear constraints. \anchor _todo001227 (user): Debug what makes it unsat at this point. \anchor _todo001228 (user): We will re-add the same implied bounds during probing, so it might not be necessary to do that here. Also, it might be too early if some of the literal view used in the LP are created later, but that should be fixable via calls to implied_bounds->NotifyNewIntegerView(). \anchor _todo001229 (user): In these cases, we could fix the enforcement literal right away or ignore the constraint. Note that it will be done later anyway though. \anchor _todo001230 (user): Fully encode variable that are almost fully encoded? \anchor _todo001231 (user): Try to remove it. Normally we caught UNSAT above, but tests are very flaky (it only happens in parallel). Keeping it there for the time being. \anchor _todo001232 (user): delay this after PropagateEncodingFromEquivalenceRelations()? Otherwise we might create new Boolean variables for no reason. Note however, that in the presolve, we should only use the "representative" in linear constraints, so we should be fine. \anchor _todo001233 (user): It is not 100% clear what is the best encoding and if we should create equivalent literal or rely on propagator instead to push bounds. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#ac9d08e5135a1ae71b571b14fbff3381b "operations_research::sat::FailedLiteralProbingRound" (ProbingOptions options, Model *model)</dt><dd> \anchor _todo002158 (user): Instead of minimizing index in topo order (which might be nice for binary extraction), we could try to maximize reusability in some way. \anchor _todo002159 (user): Can we be smarter here? Maybe we can still fix the literal without going back to level zero by simply enqueuing it with no reason? it will be backtracked over, but we will still lazily fix it later. \anchor _todo002160 (user): We could be slightly more generic and subsume some clauses that do not contains last_decision.Negated(). \anchor _todo002161 (user): Think about trying to extract clause that will not get removed by transitive reduction later. If we can both extract a => c and b => c , ideally we don't want to extract a => c first if we already know that a => b. \anchor _todo002162 (user): Similar to previous point, we could find the LCA of all literals in the reason for this propagation. And use this as a reason for later hyber binary resolution. Like we do when this clause subsume the reason. \anchor _todo002163 (user): We might just want to do that even more lazily by checking for detached clause while propagating here? and do a big cleanup at the end. </dd> <dt> \_setscope operations_research::sat::FeasibilityJumpSolver Class \_internalref classoperations__research_1_1sat_1_1FeasibilityJumpSolver "operations_research::sat::FeasibilityJumpSolver" </dt><dd> \anchor _todo001674 (user): If we have more than one of these solver, we might want to share the evaluator memory between them. Right now we basically keep a copy of the model and its transpose for each FeasibilityJumpSolver. </dd> <dt> \_setscope operations_research::sat::FeasibilityJumpSolver Member \_internalref classoperations__research_1_1sat_1_1FeasibilityJumpSolver#adc255845d619b5cf9077d19faecb8762 "operations_research::sat::FeasibilityJumpSolver::GenerateTask" (int64_t) final</dt><dd> \anchor _todo001665 (user): Tune the improvement constant, maybe use luby. \anchor _todo001666 (user): Find better names. DeterministicTime() is maintained by this class while deterministic_time() is the one saved in the SubSolver base class). </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a300f624fabbec583376b6e87dcb6fbda "operations_research::sat::FillSolveStatsInResponse" (Model *model, CpSolverResponse *response)</dt><dd> \anchor _todo002361 (user): find a way to clear all stats fields that might be set by one of the callback. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a078949f573405fc4dbedc484093b1826 "operations_research::sat::FindBestScalingAndComputeErrors" (const std::vector< double > &coefficients, absl::Span< const double > lower_bounds, absl::Span< const double > upper_bounds, int64_t max_absolute_activity, double wanted_absolute_activity_precision, double *relative_coeff_error, double *scaled_sum_error)</dt><dd> \anchor _todo001989 (user): Make this faster. \anchor _todo001996 (user): unit test this and move to fp_utils. (user): Ideally the lower/upper should be int64_t so that we can have an exact definition for the max_absolute_activity allowed. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#ae16bafcf3c5377ed905021a96f93bdcf "operations_research::sat::FindCpModelSymmetries" (const SatParameters &params, const CpModelProto &problem, std::vector< std::unique_ptr< SparsePermutation > > *generators, double deterministic_limit, SolverLogger *logger)</dt><dd> \anchor _todo001513 (user): Change the API to not return an error when the time limit is reached. \anchor _todo001536 (user): On SAT problems it is more powerful to detect permutations also involving the negation of the problem variables. So that we could find a symmetry x <-> not(y) for instance. \anchor _todo001537 (user): As long as we only exploit symmetry involving only Boolean variables we can make this code more efficient by not detecting symmetries involing integer variable. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a2e4999dc16f55afa8c5d30a733a26e3d "operations_research::sat::FindDuplicateConstraints" (const CpModelProto &model_proto, bool ignore_enforcement)</dt><dd> \anchor _todo001432 (user): we could delete duplicate identical interval, but we need to make sure reference to them are updated. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a75271e8da6c6cb4c5c87226e150d47d7 "operations_research::sat::FindLinearBooleanProblemSymmetries" (const LinearBooleanProblem &problem, std::vector< std::unique_ptr< SparsePermutation > > *generators)</dt><dd> \anchor _todo001082 (user): inject the appropriate time limit here. \anchor _todo001083 (user): Remove them beforehand? </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a7492392221bdfcc832cce2d93c9b681c "operations_research::sat::FingerprintModel" (const CpModelProto &model, uint64_t seed=kDefaultFingerprintSeed)</dt><dd> \anchor _todo001538 (user): Should we fingerprint decision strategies? </dd> <dt> \_setscope operations_research::sat::FirstFewValues Class \_internalref classoperations__research_1_1sat_1_1FirstFewValues "operations_research::sat::FirstFewValues< n >" </dt><dd> \anchor _todo002401 (user): Maybe modulo some prime number we can keep more info. (user): Another common case is a bunch of really small values and larger ones, so we could bound the sum of the small values and keep the first few reachable by the big ones. This is similar to some presolve transformations. </dd> <dt> \_setscope operations_research::sat::FirstFewValues Member \_internalref classoperations__research_1_1sat_1_1FirstFewValues#afb10d079fe78aa99d7256c85f6d24bde "operations_research::sat::FirstFewValues< n >::Add" (const int64_t positive_value)</dt><dd> \anchor _todo002406 (user): Implement Add() with an upper bound on the multiplicity. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a8c72a9619e1961d1434170437536cff6 "operations_research::sat::FirstUnassignedVarAtItsMinHeuristic" (const std::vector< IntegerVariable > &vars, Model *model)</dt><dd> \anchor _todo001773 (user): the complexity caused by the linear scan in this heuristic and the one below is ok when search_branching is set to SAT_SEARCH because it is not executed often, but otherwise it is done for each search decision, which seems expensive. Improve. </dd> <dt> \_setscope operations_research::sat::FixedCapacityVector Class \_internalref classoperations__research_1_1sat_1_1FixedCapacityVector "operations_research::sat::FixedCapacityVector< T >" </dt><dd> \anchor _todo002400 (user): Add more functions and unit-test. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a392d70cc768a13de271f87123513acf2 "operations_research::sat::FloorSquareRoot" (int64_t a)</dt><dd> \anchor _todo002392 (user): Find better implementation? In pratice passing via double is almost always correct, but the CapProd() might be a bit slow. However this is only called when we do propagate something. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a36bf1351ffa74960b3040a96ddc37468 "operations_research::sat::FullyCompressTuples" (absl::Span< const int64_t > domain_sizes, std::vector< std::vector< int64_t > > *tuples)</dt><dd> \anchor _todo002396 (user): We can probably reuse the tuples memory always and never create new one. We should also be able to code an iterative version of this. Note however that the recursion level is bounded by the number of coluns which should be small. \anchor _todo002402 (user): To reduce memory, we could return some absl::Span in the last layer instead of vector. \anchor _todo002403 (user): The final compression is depend on the order of the variables. For instance the table (1,1)(1,2)(1,3),(1,4),(2,3) can either be compressed as (1,*)(2,3) or (1,{1,2,4})({1,3},3). More experiment are needed to devise a better heuristic. It might for example be good to call CompressTuples() first. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a0f8cabd3d98b36018d409338a6875acc "operations_research::sat::GenerateCompletionTimeCutsWithEnergy" (absl::string_view cut_name, std::vector< CtEvent > events, IntegerValue capacity_max, bool skip_low_sizes, Model *model, LinearConstraintManager *manager)</dt><dd> \anchor _todo002322 (user): merge with Packing cuts. \anchor _todo002323 (user): Check overflow and ignore if too big. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#ad9f2b16f4c1689aa6e197a46cb009320 "operations_research::sat::GenerateCumulativeEnergeticCuts" (const std::string &cut_name, const util_intops::StrongVector< IntegerVariable, double > &lp_values, std::vector< EnergyEvent > events, const AffineExpression &capacity, TimeLimit *time_limit, Model *model, LinearConstraintManager *manager)</dt><dd> \anchor _todo002319 (user): We could reduce this set. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a79c07c2911bf5d9a1225cd3789ff0499 "operations_research::sat::GenerateCumulativeEnergeticCutsWithMakespanAndFixedCapacity" (absl::string_view cut_name, const util_intops::StrongVector< IntegerVariable, double > &lp_values, std::vector< EnergyEvent > events, IntegerValue capacity, AffineExpression makespan, TimeLimit *time_limit, Model *model, LinearConstraintManager *manager)</dt><dd> \anchor _todo002316 (user): We could reduce this set. \anchor _todo002317 \anchor _todo002318 (user): we can compute the max usage between makespan_min and makespan_max. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#af2a840612629fd37d42870c23e183609 "operations_research::sat::GenerateGraphForSymmetryDetection" (const LinearBooleanProblem &problem, std::vector< int > *initial_equivalence_classes)</dt><dd> \anchor _todo001081 (user): reserve the memory for the graph? not sure it is worthwhile since it would require some linear scan of the problem though. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#aef4b159d28945ac73ef965c2db5c18d5 "operations_research::sat::GenerateNoOvelap2dCompletionTimeCutsWithEnergy" (absl::string_view cut_name, std::vector< DiffnCtEvent > events, bool use_lifting, bool skip_low_sizes, Model *model, LinearConstraintManager *manager)</dt><dd> \anchor _todo001618 (user): merge with Packing cuts. \anchor _todo001619 (user): Use dynamic programming to compute all possible values for the sum of demands as long as the involved numbers are small or the number of tasks are small. \anchor _todo001620 (user): Check overflow and ignore if too big. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a53c4d8406e1afd37e5a99ed333207f32 "operations_research::sat::GenerateShortCompletionTimeCutsWithExactBound" (const std::string &cut_name, std::vector< CtEvent > events, IntegerValue capacity_max, Model *model, LinearConstraintManager *manager)</dt><dd> \anchor _todo002321 (user): Improve performance - detect disjoint tasks (no need to crossover to the second part) - better caching of explored states </dd> <dt> \_setscope operations_research::sat::GenericLiteralWatcher Class \_internalref classoperations__research_1_1sat_1_1GenericLiteralWatcher "operations_research::sat::GenericLiteralWatcher" </dt><dd> \anchor _todo001726 (user): Move this to its own file. Add unit tests! </dd> <dt> \_setscope operations_research::sat::GenericLiteralWatcher Member \_internalref classoperations__research_1_1sat_1_1GenericLiteralWatcher#ad53c31fda5130ffda98dbb242faf3145 "operations_research::sat::GenericLiteralWatcher::GenericLiteralWatcher" (Model *model)</dt><dd> \anchor _todo001719 (user): This propagator currently needs to be last because it is the only one enforcing that a fix-point is reached on the integer variables. Figure out a better interaction between the sat propagation loop and this one. </dd> <dt> \_setscope operations_research::sat::GenericLiteralWatcher Member \_internalref classoperations__research_1_1sat_1_1GenericLiteralWatcher#a23370d30fab5bc955f314d3ced9add4a "operations_research::sat::GenericLiteralWatcher::Propagate" (Trail *trail) final</dt><dd> \anchor _todo001720 (user): The queue will not be emptied, but I am not sure the solver will be left in an usable state. Fix if it become needed to resume the solve from the last time it was interrupted. In particular, we might want to call UpdateCallingNeeds()? \anchor _todo001721 (user): Maybe just provide one function Propagate(watch_indices) ? \anchor _todo001722 (user): However, on some problem, it seems to work better to not do that. One possible reason is that the reason of a "natural" propagation might be better than one we learned. </dd> <dt> \_setscope operations_research::sat::GenericLiteralWatcher Member \_internalref classoperations__research_1_1sat_1_1GenericLiteralWatcher#ab3993b47fa18e5a83198e062ded08bb7 "operations_research::sat::GenericLiteralWatcher::Register" (PropagatorInterface *propagator)</dt><dd> \anchor _todo001723 (user): This initial propagation does not respect any later priority settings. Fix this. Maybe we should force users to pass the priority at registration. For now I didn't want to change the interface because there are plans to implement a kind of "dynamic" priority, and if it works we may want to get rid of this altogether. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a2d3beb2acf8977c52500de3ebe170d24 "operations_research::sat::GetFullWorkerParameters" (const SatParameters &base_params, const CpModelProto &cp_model, int num_already_present, SubsolverNameFilter *filter)</dt><dd> \anchor _todo001448 (user): For scheduling, this is important to find good first solution but afterwards it is not really great and should probably be replaced by a LNS worker. \anchor _todo001449 (user): Avoid launching two strategies if they are the same, like if there is no lp, or everything is already linearized at level 1. \anchor _todo001450 (user): Enable probing_search in deterministic mode. Currently it timeouts on small problems as the deterministic time limit never hits the sharding limit. \anchor _todo001451 (user): Enable shaving search in interleave mode. Currently it do not respect ^C, and has no per chunk time limit. \anchor _todo001452 (user): Enable lb_tree_search in deterministic mode. \anchor _todo001453 (user): Actually make sure the gap num_workers <-> num_heuristics is contained. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#ae2f0522b87e92a3a69cd92fe98af4be7 "operations_research::sat::GetNamedParameters" (SatParameters base_params)</dt><dd> \anchor _todo001446 (user): Do more experiments, the LP with core could be useful, but we probably need to incorporate the newly created integer variables from the core algorithm into the LP. \anchor _todo001447 (user): Experiment with search_random_variable_pool_size. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#aa8cc7ff53b39b6a28e821bc428dcb331 "operations_research::sat::GetOrbits" (int n, absl::Span< const std::unique_ptr< SparsePermutation > > generators)</dt><dd> \anchor _todo002359 (user): We could reuse the internal memory if needed. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a0c9697a77db1ba2b0a9055c7a71fe666 "operations_research::sat::GetSolutionValues" (const CpModelProto &model_proto, const Model &model)</dt><dd> \anchor _todo001488 (user): Checks against initial model. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#afa1020b89b12f653b1ea0dd0d595557e "operations_research::sat::GetSuperAdditiveRoundingFunction" (IntegerValue rhs_remainder, IntegerValue divisor, IntegerValue t, IntegerValue max_scaling)</dt><dd> \anchor _todo001562 (user): Use everywhere a two step computation to avoid overflow? First divide by divisor, then multiply by t. For now, we limit t so that we never have an overflow instead. \anchor _todo001563 (user): This function is not always maximal when size % (max_scaling - 1) == 0. Improve? </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a7876cef7b031a084f24b5c5898c9710c "operations_research::sat::GetSuperAdditiveStrengtheningFunction" (IntegerValue positive_rhs, IntegerValue min_magnitude)</dt><dd> \anchor _todo001564 (user): Limit the number of value used with scaling like above. \anchor _todo001565 (user): we might want to intoduce some step to reduce the final magnitude of the cut. \anchor _todo001607 (user): Extend it for ci >= max_magnitude, we can probaly "lift" such coefficient. </dd> <dt> \_setscope operations_research::sat::GreaterThanAtLeastOneOfDetector Class \_internalref classoperations__research_1_1sat_1_1GreaterThanAtLeastOneOfDetector "operations_research::sat::GreaterThanAtLeastOneOfDetector" </dt><dd> \anchor _todo002108 (user): Shall we do that on the main thread before the workers are spawned? note that the probing version need the model to be loaded though. </dd> <dt> \_setscope operations_research::sat::GreaterThanAtLeastOneOfDetector Member \_internalref classoperations__research_1_1sat_1_1GreaterThanAtLeastOneOfDetector#a54971ccb8359a6ce699b946840ac5b0a "operations_research::sat::GreaterThanAtLeastOneOfDetector::AddGreaterThanAtLeastOneOfConstraints" (Model *model, bool auto_detect_clauses=false)</dt><dd> \anchor _todo002104 (user): Do more extensive experiment. Remove the second approach as it is more time consuming? or identify when it make sense. Note that the first approach also allows to use "incomplete" at least one between arcs. \anchor _todo002105 (user): This does not take into account clause of size 2 since they are stored in the BinaryImplicationGraph instead. Some ideas specific to size 2: - There can be a lot of such clauses, but it might be nice to consider them. we need to experiments. - The automatic clause detection might be a better approach and it could be combined with probing. \anchor _todo002120 (user): This can be quite slow, add some kind of deterministic limit so that we can use it all the time. </dd> <dt> \_setscope operations_research::sat::GreaterThanAtLeastOneOfPropagator Member \_internalref classoperations__research_1_1sat_1_1GreaterThanAtLeastOneOfPropagator#a11ee2dab5b47a3c04564b44d74c55ed3 "operations_research::sat::GreaterThanAtLeastOneOfPropagator::Explain" (int id, IntegerValue propagation_slack, IntegerVariable var_to_explain, int trail_index, std::vector< Literal > *literals_reason, std::vector< int > *trail_indices_reason) final</dt><dd> \anchor _todo001150 (user): We could also skip this if we already have the reason for the expression being high enough in the current conflict. </dd> <dt> \_setscope operations_research::sat::GreaterThanAtLeastOneOfPropagator Member \_internalref classoperations__research_1_1sat_1_1GreaterThanAtLeastOneOfPropagator#a3b3ae77e1959c1da3c086669f8c28062 "operations_research::sat::GreaterThanAtLeastOneOfPropagator::Propagate" () final</dt><dd> \anchor _todo001151 (user): In case of a conflict, we could push one of them to false if it is the only one. \anchor _todo001152 (user): This could be optimized by keeping more info from the last Propagate() calls. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#af6433b3a01c71cd754d3d710f345b4c0 "operations_research::sat::GreedyFastDecreasingGcd" (const absl::Span< const int64_t > coeffs)</dt><dd> \anchor _todo001627 (user): The following is a heuristic to make drop the GCD as fast as possible. It might be suboptimal in general (as we could miss two coprime coefficients for instance). </dd> <dt> \_setscope operations_research::sat::HittingSetOptimizer Class \_internalref classoperations__research_1_1sat_1_1HittingSetOptimizer "operations_research::sat::HittingSetOptimizer" </dt><dd> \anchor _todo002011 (user): This class requires linking with the SCIP MIP solver which is quite big, maybe we should find a way not to do that. </dd> <dt> \_setscope operations_research::sat::HittingSetOptimizer Member \_internalref classoperations__research_1_1sat_1_1HittingSetOptimizer#a82f11613372a6a2909c2dc75bcd6216b "operations_research::sat::HittingSetOptimizer::Optimize" ()</dt><dd> \anchor _todo002003 (user): remove code duplication with MinimizeWithCoreAndLazyEncoding(); \anchor _todo002004 (user): Even though we keep the same solver, currently the solve is not really done incrementally. It might be hard to improve though. \anchor _todo002005 (user): deal with time limit. \anchor _todo002006 (user): C^c is broken when using SCIP. \anchor _todo002007 (user): It is actually easy to use a FEASIBLE result. If when passing it to SAT it is no feasbile, we can still create cores. If it is feasible, we have a solution, but we cannot increase the lower bound. \anchor _todo002008 (user): Use the real weights and exploit the extra cores. \anchor _todo002009 \anchor _todo002010 (user): If we extract more than the objective variables, we could use the solution values from the MPModel as hints to the SAT model. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a5ca12ac764578209e7eaa692a9029635 "operations_research::sat::Implication" (absl::Span< const Literal > enforcement_literals, IntegerLiteral i)</dt><dd> \anchor _todo001727 (user): This is one of the rare case where it is better to use Equality() rather than two Implications(). Maybe we should modify our internal implementation to use half-reified encoding? that is do not propagate the direction integer-bound => literal, but just literal => integer-bound? This is the same as using different underlying variable for an integer literal and its negation. \anchor _todo001728 (user): Double check what happen when we associate a trivially true or false literal. </dd> <dt> \_setscope operations_research::sat::ImpliedBounds Class \_internalref classoperations__research_1_1sat_1_1ImpliedBounds "operations_research::sat::ImpliedBounds" </dt><dd> \anchor _todo001690 (user): This can quickly use up too much memory. Add some limit in place. In particular, each time we have literal => integer_literal we should avoid storing the same integer_literal for all other_literal for which other_literal => literal. For this we need to interact with the BinaryImplicationGraph. \anchor _todo001691 (user): This is a bit of a duplicate with the Literal <=> IntegerLiteral stored in the IntegerEncoder class. However we only need one side here. \anchor _todo001692 (user): Do like in the DomainDeductions class and allow to process clauses (or store them) to perform more level zero deductions. Note that this is again a slight duplicate with what we do there (except that we work at the Domain level in that presolve class). \anchor _todo001693 (user): Add an implied bound cut generator to add these simple constraints to the LP when needed. </dd> <dt> \_setscope operations_research::sat::ImpliedBounds Member \_internalref classoperations__research_1_1sat_1_1ImpliedBounds#accac5e129274770ef3d646e15aa13b1c "operations_research::sat::ImpliedBounds::Add" (Literal literal, IntegerLiteral integer_literal)</dt><dd> \anchor _todo001680 (user): Check that this never happen? it shouldn't. \anchor _todo001681 (user): Like in probing, we can also create hole in the domain if there is some implied bounds for (literal.NegatedIndex, NegagtionOf(var)) that crosses integer_literal.bound. </dd> <dt> \_setscope operations_research::sat::ImpliedBounds Member \_internalref classoperations__research_1_1sat_1_1ImpliedBounds#ace9f6e200fff7933263a014bb9d62fb8 "operations_research::sat::ImpliedBounds::GetImpliedBounds" (IntegerVariable var)</dt><dd> \anchor _todo001682 (user): Check no duplicate and remove old entry if the enforcement is tighter. </dd> <dt> \_setscope operations_research::sat::ImpliedBoundsProcessor Member \_internalref classoperations__research_1_1sat_1_1ImpliedBoundsProcessor#aa292900f68528b54007deb7cdb6f4aec "operations_research::sat::ImpliedBoundsProcessor::DecomposeWithImpliedLowerBound" (const CutTerm &term, IntegerValue factor_t, CutTerm &bool_term, CutTerm &slack_term)</dt><dd> \anchor _todo001599 (user): Ignore if bound_diff == 1 ? But we can still merge B with another entry if it exists, so it can still be good in this case. \anchor _todo001600 (user): Only do it if coeff_b > 0 ? But again we could still merge B with an existing Boolean for a better cut even if coeff_b == 0. </dd> <dt> \_setscope operations_research::sat::ImpliedBoundsProcessor Member \_internalref classoperations__research_1_1sat_1_1ImpliedBoundsProcessor#ad649c6a32bb8aeec245204ebd3c6fe15 "operations_research::sat::ImpliedBoundsProcessor::PostprocessWithImpliedBound" (const std::function< IntegerValue(IntegerValue)> &f, IntegerValue factor_t, CutData *cut, CutDataBuilder *builder)</dt><dd> \anchor _todo001601 (user): Note that while the violation might be higher, if the slack becomes large this will result in a less powerfull cut. Shall we do that? It is a bit the same problematic with complementing. \anchor _todo001602 (user): If the slack is close to zero, then this transformation will always increase the violation. So we could potentially do it in Before our divisor selection heuristic. But the norm of the final cut will increase too. </dd> <dt> \_setscope operations_research::sat::ImpliedBoundsProcessor Member \_internalref classoperations__research_1_1sat_1_1ImpliedBoundsProcessor#ace0dba418106eaaeca69f6adac3fff3e "operations_research::sat::ImpliedBoundsProcessor::TryToExpandWithLowerImpliedbound" (IntegerValue factor_t, int i, bool complement, CutData *cut, CutDataBuilder *builder)</dt><dd> \anchor _todo001603 (user): Because of merges, we might have entry with a coefficient of zero than are not useful. Remove them. </dd> <dt> \_setscope operations_research::sat::InclusionDetector Member \_internalref classoperations__research_1_1sat_1_1InclusionDetector#ac5767e6b32e020c4e95dd254ab768620 "operations_research::sat::InclusionDetector< Storage >::DetectInclusions" (const std::function< void(int subset, int superset)> &process)</dt><dd> \anchor _todo001700 (user): Alternatively, we could clean is_in_superset_ in the call to StopProcessingCurrentSuperset() and force client to call it before altering the superset content. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#ad715c4b2444c3b6fb162bc2382a2248e "operations_research::sat::IncreaseNodeSize" (EncodingNode *node, SatSolver *solver)</dt><dd> \anchor _todo001657 (user): Experiment more. </dd> <dt> \_setscope operations_research::sat::Inprocessing Class \_internalref classoperations__research_1_1sat_1_1Inprocessing "operations_research::sat::Inprocessing" </dt><dd> \anchor _todo002262 (user): Some algorithms here use the normal SAT propagation engine. However we might want to temporarily disable activities/phase saving and so on if we want to run them as in-processing steps so that they do not "pollute" the normal SAT search. \anchor _todo002263 (user): For the propagation, this depends on the SatSolver class, which mean we cannot really use it without some refactoring as an in-processing from the SatSolver::Solve() function. So we do need a special InprocessingSolve() that lives outside SatSolver. Alternatively, we can extract the propagation main loop and conflict analysis from SatSolver. </dd> <dt> \_setscope operations_research::sat::Inprocessing Member \_internalref classoperations__research_1_1sat_1_1Inprocessing#a3ab413def8a2242915ef31ff717baa17 "operations_research::sat::Inprocessing::DetectEquivalencesAndStamp" (bool use_transitive_reduction, bool log_info)</dt><dd> \anchor _todo002214 (user): consider doing the transitive reduction after each SCC. It might be slow but we could try to make it more incremental to compensate and it should allow further reduction. </dd> <dt> \_setscope operations_research::sat::Inprocessing Member \_internalref classoperations__research_1_1sat_1_1Inprocessing#aa0797dfc25a5c609254b61fe67828c11 "operations_research::sat::Inprocessing::InprocessingRound" ()</dt><dd> \anchor _todo002209 (user): Tune the heuristic, in particular, with the current code we start some inprocessing before the first search. \anchor _todo002210 (user): The LP and incremental structure will still be called though, which can take some time, try to disable it more cleanly. \anchor _todo002211 (user): We should probably also disable the variable/clauses activity updates. \anchor _todo002212 (user): Add a small wrapper function to time this. \anchor _todo002213 (user): try to enable these? The problem is that we can only remove variables not used the non-pure SAT part of a model. </dd> <dt> \_setscope operations_research::sat::Inprocessing Member \_internalref classoperations__research_1_1sat_1_1Inprocessing#a67d25dadf7669215ab5b27b4d8046e18 "operations_research::sat::Inprocessing::PresolveLoop" (SatPresolveOptions options)</dt><dd> \anchor _todo002205 (user): This should/could be integrated with the stamping since it seems better to do just one loop instead of two over all clauses. Because of memory access. it isn't that clear though. \anchor _todo002206 (user): Combine the two? this way we don't create a full literal <-> clause graph twice. It might make sense to reach the BCE fix point which is unique before each variable elimination. \anchor _todo002207 (user): this break some binary graph invariant. Fix! \anchor _todo002208 (user): Maintain the total number of literals in the watched clauses. </dd> <dt> \_setscope operations_research::sat::Inprocessing Member \_internalref classoperations__research_1_1sat_1_1Inprocessing#a5e0f39f14f9c6d947181e7185d6ed865 "operations_research::sat::Inprocessing::RemoveFixedAndEquivalentVariables" (bool log_info)</dt><dd> \anchor _todo002215 (user): The level zero is required because we remove fixed variables but if we split this into two functions, we could rewrite clause at any level. \anchor _todo002216 (user): If only new fixed variables are there, we can use a faster function. We should also merge the code with the deletion code in sat_solver_.cc, but that require some refactoring of the dependence between files. \anchor _todo002217 (user): we should output literal to the proof right away, currently if we remove clauses before fixing literal the proof is wrong. \anchor _todo002218 (user): find a way to auto-tune that after a run on borg... </dd> <dt> \_setscope operations_research::sat::Inprocessing Member \_internalref classoperations__research_1_1sat_1_1Inprocessing#a2fbf49af4f2bef7419f9eff0fc4847b2 "operations_research::sat::Inprocessing::SubsumeAndStrenghtenRound" (bool log_info)</dt><dd> \anchor _todo002219 (user): Use better work limits, see SAT09.CRAFTED.ramseycube.Q3inK12 \anchor _todo002220 (user): Be more incremental, each time a clause is added/reduced track which literal are impacted? Also try to do orthogonal reductions from one round to the next. \anchor _todo002221 (user): We could do that only if we do some reduction, but this is quite fast though. \anchor _todo002222 (user): probably faster without the size indirection. \anchor _todo002223 (user): Storing signatures here might be faster? \anchor _todo002224 (user): Better abort limit. We could also limit the watcher sizes and never look at really long clauses. Note that for an easier incrementality, it is better to reach some kind of completion so we know what new stuff need to be done. \anchor _todo002225 (user): Do some reduction using binary clauses. Note that only clause that never propagated since last round need to be checked for binary subsumption. \anchor _todo002226 (user): remove first and see if other still removable. Alternatively use a "removed" marker and redo a check for each clause that simplifies this one? Or just remove the first one, and wait for next round. \anchor _todo002227 (user): No need to add this clause if we know it cannot subsume any new clause since last round. i.e. unchanged clause that do not contains any literals of newly added clause do not need to be added here. We can track two bitset in LiteralWatchers via a register mechanism: - literal of newly watched clauses since last clear. - literal of reduced clauses since last clear. \anchor _todo002228 (user): We could/should sort the literal in this clause by using literals that appear in a small number of clauses first so that we maximize the chance of early abort in the critical loops above. \anchor _todo002229 (user): We could also move the watched literal first so we always skip it. \anchor _todo002230 (user): tune the deterministic time. </dd> <dt> \_setscope operations_research::sat::IntegerEncoder Class \_internalref classoperations__research_1_1sat_1_1IntegerEncoder "operations_research::sat::IntegerEncoder" </dt><dd> \anchor _todo001725 (user): We could also lazily create precedences Booleans between two arbitrary IntegerVariable. This is better done in the PrecedencesPropagator though. </dd> <dt> \_setscope operations_research::sat::IntegerEncoder Member \_internalref classoperations__research_1_1sat_1_1IntegerEncoder#a1a4e1df43e180231715e6fde6b4d0a8d "operations_research::sat::IntegerEncoder::Canonicalize" (IntegerLiteral i_lit) const</dt><dd> \anchor _todo001732 (user): This is linear in the domain "complexity", we can do better if needed. </dd> <dt> \_setscope operations_research::sat::IntegerEncoder Member \_internalref classoperations__research_1_1sat_1_1IntegerEncoder#a44f7926d822f4f2f659be6f503090ac4 "operations_research::sat::IntegerEncoder::FullyEncodeVariable" (IntegerVariable var)</dt><dd> \anchor _todo001702 (user): Maybe we can optimize the literal creation order and their polarity as our default SAT heuristics initially depends on this. \anchor _todo001703 (user): Currently, in some corner cases, GetOrCreateLiteralAssociatedToEquality() might trigger some propagation that update the domain of var, so we need to cache the values to not read garbage. Note that it is okay to call the function on values no longer reachable, as this will just do nothing. \anchor _todo001731 (user): It is currently only possible to call that at the decision level zero because we cannot add ternary clause in the middle of the search (for now). This is Checked. </dd> <dt> \_setscope operations_research::sat::IntegerEncoder Member \_internalref classoperations__research_1_1sat_1_1IntegerEncoder#acb0b1234e31f51f99e14860cd628cde2 "operations_research::sat::IntegerEncoder::GetAssociatedLiteral" (IntegerLiteral i_lit) const</dt><dd> \anchor _todo001708 (user): Canonicalization might be slow. </dd> <dt> \_setscope operations_research::sat::IntegerEncoder Member \_internalref classoperations__research_1_1sat_1_1IntegerEncoder#a86897b73c47086f4bc261f9424b47de7 "operations_research::sat::IntegerEncoder::GetOrCreateAssociatedLiteral" (IntegerLiteral i_lit)</dt><dd> \anchor _todo001706 (user): on some problem this happens. We should probably make sure that we don't create extra fixed Boolean variable for no reason. </dd> <dt> \_setscope operations_research::sat::IntegerEncoder Member \_internalref classoperations__research_1_1sat_1_1IntegerEncoder#af0a2aeea649e70334c5b44dca14a5ae2 "operations_research::sat::IntegerEncoder::GetOrCreateLiteralAssociatedToEquality" (IntegerVariable var, IntegerValue value)</dt><dd> \anchor _todo001707 (user): this happens on some problem. We should probably make sure that we don't create extra fixed Boolean variable for no reason. </dd> <dt> \_setscope operations_research::sat::IntegerEncoder Member \_internalref classoperations__research_1_1sat_1_1IntegerEncoder#a575c98a8e638de20b5a3a5861263c732 "operations_research::sat::IntegerEncoder::GetTrueLiteral" ()</dt><dd> \anchor _todo001733 (user): Make sure we abort right away on unsat! </dd> <dt> \_setscope operations_research::sat::IntegerEncoder Member \_internalref classoperations__research_1_1sat_1_1IntegerEncoder#a7c648e8ec1bcd260e3d4ed64b293bb28 "operations_research::sat::IntegerEncoder::ReserveSpaceForNumVariables" (int num_vars)</dt><dd> \anchor _todo001701 (user): Reserve vector index by literals? It is trickier, as we might not know beforehand how many we will need. Consider alternatives to not waste space like using dequeue. </dd> <dt> \_setscope operations_research::sat::IntegerEncoder Member \_internalref classoperations__research_1_1sat_1_1IntegerEncoder#a59abe9efe4246f146066483c1955e602 "operations_research::sat::IntegerEncoder::VariableIsFullyEncoded" (IntegerVariable var) const</dt><dd> \anchor _todo001704 (user): Cache result as long as equality_by_var_[index] is unchanged? It might not be needed since if the variable is not fully encoded, then PartialDomainEncoding() will filter unreachable values, and so the size check will be false until further value have been encoded. \anchor _todo001705 (user): Comparing the size might be enough, but we want to be always valid even if either (*domains_[var]) or PartialDomainEncoding(var) are not properly synced because the propagation is not finished. </dd> <dt> \_setscope operations_research::sat::IntegerRoundingCutHelper Member \_internalref classoperations__research_1_1sat_1_1IntegerRoundingCutHelper#a55348bee0f2fe5505e28cc64ddfb1404 "operations_research::sat::IntegerRoundingCutHelper::ComputeCut" (RoundingOptions options, const CutData &base_ct, ImpliedBoundsProcessor *ib_processor=nullptr)</dt><dd> \anchor _todo001569 (user): This is slow, 50% of run time on a2c1s1.pb.gz. Optimize! \anchor _todo001570 (user): We assume that this is called with and without the option use_ib_before_heuristic, so that we can abort if no IB has been applied since then we will redo the computation. This is not really clean. \anchor _todo001571 (user): Experiment for the best value of this initial violation threshold. Note also that we use the l2 norm on the restricted position here. Maybe we should change that? On that note, the L2 norm usage seems a bit weird to me since it grows with the number of term in the cut. And often, we already have a good cut, and we make it stronger by adding extra terms that do not change its activity. \anchor _todo001572 (user): If the rhs is small and close to zero, we might want to consider different way of complementing the variables. \anchor _todo001573 (user): Avoid quadratic algorithm? Note that we are quadratic in relevant positions not the full cut size, but this is still too much on some problems. \anchor _todo001574 (user): It is still unclear if we have a * X + b * (1 - X) <= rhs for a Boolean X, what is the best way to apply f and if we should merge the terms. If there is no other terms, best is probably f(rhs - a) * X + f(rhs - b) * (1 - X). </dd> <dt> \_setscope operations_research::sat::IntegerSearchHelper Member \_internalref classoperations__research_1_1sat_1_1IntegerSearchHelper#a48a2360caaae5ab4fb4d19f88a769fb6 "operations_research::sat::IntegerSearchHelper::GetDecisionLiteral" (const BooleanOrIntegerLiteral &decision)</dt><dd> \anchor _todo001799 (user): Ideally it would be cool to delay the creation even more until we have a conflict with these decisions, but it is currently hard to do so. \anchor _todo001800 (user): It would be nicer if this can never happen. For now, it does because of the Propagate() not reaching the fixed point as mentioned in a \anchor _todo001801 \anchor _todo001802 above. As a work-around, we display a message but do not crash and recall the decision heuristic. </dd> <dt> \_setscope operations_research::sat::IntegerSearchHelper Member \_internalref classoperations__research_1_1sat_1_1IntegerSearchHelper#aee604e664f5122db61cd4c73f437be2a "operations_research::sat::IntegerSearchHelper::SolveIntegerProblem" ()</dt><dd> \anchor _todo001804 (user): We have the issue that at level zero. calling the propagation loop more than once can propagate more! This is because we call the LP again and again on each level zero propagation. This is causing some CHECKs() to fail in multithread (rarely) because when we associate new literals to integer ones, Propagate() is indirectly called. Not sure yet how to fix. \anchor _todo001805 (user): Experiment more around dynamically changing the threshold for storing LP solutions in the pool. Alternatively expose this as parameter so this can be tuned later. \anchor _todo001806 (user): Avoid adding the same solution many time if the LP didn't change. Avoid adding solution that are too deep in the tree (most variable fixed). Also use a callback rather than having this here, we don't want this file to depend on cp_model.proto. </dd> <dt> \_setscope operations_research::sat::IntegerSearchHelper Member \_internalref classoperations__research_1_1sat_1_1IntegerSearchHelper#a2e2faa726399df6f91e4dc89d9ed5117 "operations_research::sat::IntegerSearchHelper::TakeDecision" (Literal decision)</dt><dd> \anchor _todo001803 (user): on some problems, this function can be quite long. Expand so that we can check the time limit at each step? </dd> <dt> \_setscope operations_research::sat::IntegerTrail Member \_internalref classoperations__research_1_1sat_1_1IntegerTrail#a6e9beefb349f99c5af795d1b6f793b4e "operations_research::sat::IntegerTrail::AddAllGreaterThanConstantReason" (absl::Span< AffineExpression > exprs, IntegerValue target_min, std::vector< int > *indices) const</dt><dd> \anchor _todo001742 (user): This might better lives together with the propagation code, but it does need access to data about the reason/conflict being currently computed. Also for speed we do need all the code here in on block. Given than we have just a few "lazy integer reason", we might not really want a generic code in any case. </dd> <dt> \_setscope operations_research::sat::IntegerTrail Member \_internalref classoperations__research_1_1sat_1_1IntegerTrail#a528e39b17cbbdccc58f61b4db9fd4141 "operations_research::sat::IntegerTrail::AppendNewBoundsFrom" (int base_index, std::vector< IntegerLiteral > *output) const</dt><dd> \anchor _todo001718 (user): Implement a dense version if there is more trail entries than variables! </dd> <dt> \_setscope operations_research::sat::IntegerTrail Member \_internalref classoperations__research_1_1sat_1_1IntegerTrail#a07f3c5bf9ad7390cb25efb3f6a0de3b3 "operations_research::sat::IntegerTrail::ConditionalEnqueue" (Literal lit, IntegerLiteral i_lit, std::vector< Literal > *literal_reason, std::vector< IntegerLiteral > *integer_reason)</dt><dd> \anchor _todo001711 (user): We could even keep the reason and maybe do some reasoning using at_least_one constraint on a set of the Boolean used here. </dd> <dt> \_setscope operations_research::sat::IntegerTrail Member \_internalref classoperations__research_1_1sat_1_1IntegerTrail#ad5b56d63f8471e66f6a23c28660d1d1a "operations_research::sat::IntegerTrail::Enqueue" (IntegerLiteral i_lit)</dt><dd> \anchor _todo001740 (user): If the given bound is equal to the current bound, maybe the new reason is better? how to decide and what to do in this case? to think about it. Currently we simply don't do anything. </dd> <dt> \_setscope operations_research::sat::IntegerTrail Member \_internalref classoperations__research_1_1sat_1_1IntegerTrail#a8db6515dea5128a088044e4604d60440 "operations_research::sat::IntegerTrail::Enqueue" (IntegerLiteral i_lit, absl::Span< const Literal > literal_reason, absl::Span< const IntegerLiteral > integer_reason, int trail_index_with_same_reason)</dt><dd> \anchor _todo001741 (user): This currently cannot refer to a trail_index with a lazy reason. Fix or at least check that this is the case. </dd> <dt> \_setscope operations_research::sat::IntegerTrail Member \_internalref classoperations__research_1_1sat_1_1IntegerTrail#ae3ea8da78f7a6ec038887174bbad6ceb "operations_research::sat::IntegerTrail::Propagate" (Trail *trail) final</dt><dd> \anchor _todo001709 (user): refactor the interaction IntegerTrail <-> IntegerEncoder so that we can just push right away such literal. Unfortunately, this is is a big chunk of work. </dd> <dt> \_setscope operations_research::sat::IntegerTrail Member \_internalref classoperations__research_1_1sat_1_1IntegerTrail#a08821cc13b185da58f8a0c7f1c4b30e6 "operations_research::sat::IntegerTrail::Reason" (const Trail &trail, int trail_index, int64_t conflict_id) const final</dt><dd> \anchor _todo001717 (user): If this is called many time on the same variables, it could be made faster by using some caching mechanism. </dd> <dt> \_setscope operations_research::sat::IntegerTrail Member \_internalref classoperations__research_1_1sat_1_1IntegerTrail#a3f82268fd6c91332511a3d8765d6d07f "operations_research::sat::IntegerTrail::RelaxLinearReason" (IntegerValue slack, absl::Span< const IntegerValue > coeffs, std::vector< IntegerLiteral > *reason) const</dt><dd> \anchor _todo001710 (user): Get rid of this function and only keep the trail index one? \anchor _todo001737 (user): Requiring all initial literal to be at their current bound is not really clean. Maybe we can change the API to only take IntegerVariable and produce the reason directly. \anchor _todo001738 (user): change API so that this work is performed during the conflict analysis where we can be smarter in how we relax the reason. Note however that this function is mainly used when we have a conflict, so this is not really high priority. \anchor _todo001739 (user): Test that the code work in the presence of integer overflow. </dd> <dt> \_setscope operations_research::sat::IntegerTrail Member \_internalref classoperations__research_1_1sat_1_1IntegerTrail#a86dbd554c727e96c1ce6e33a54a73235 "operations_research::sat::IntegerTrail::UpdateInitialDomain" (IntegerVariable var, Domain domain)</dt><dd> \anchor _todo001736 (user): There is some memory inefficiency if this is called many time because of the underlying data structure we use. In practice, when used with a presolve, this is not often used, so that is fine though. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a4f8e9410f7631560e2efea8f401e5aa1 "operations_research::sat::IntegerValueSelectionHeuristic" (std::function< BooleanOrIntegerLiteral()> var_selection_heuristic, Model *model)</dt><dd> \anchor _todo001779 (user): Experiment more with value selection heuristics. </dd> <dt> \_setscope operations_research::sat::IntervalsRepository Member \_internalref classoperations__research_1_1sat_1_1IntervalsRepository#a62f30977af214764af573b8a9da295d6 "operations_research::sat::IntervalsRepository::CreateDisjunctivePrecedenceLiteral" (IntervalVariable a, IntervalVariable b)</dt><dd> \anchor _todo001813 (user): also add the reverse like start_b + 1 <= end_a if negated? </dd> <dt> \_setscope operations_research::sat::IntervalsRepository Member \_internalref classoperations__research_1_1sat_1_1IntervalsRepository#a89d4a8a4b1575bb7a0d793402c82e099 "operations_research::sat::IntervalsRepository::CreatePrecedenceLiteral" (IntervalVariable a, IntervalVariable b)</dt><dd> \anchor _todo001814 (user): Also add {{y_plus_one, x}, x_before_y.Negated()} ? </dd> <dt> \_setscope operations_research::sat::IntervalsRepository Member \_internalref classoperations__research_1_1sat_1_1IntervalsRepository#ae9f8653f78ec2416053ba12305b3b2a7 "operations_research::sat::IntervalsRepository::GetOrCreateHelper" (const std::vector< IntervalVariable > &variables, bool register_as_disjunctive_helper=false)</dt><dd> \anchor _todo001815 (user): Ideally we should sort the vector of variables, but right now we cannot since we often use this with a parallel vector of demands. So this "sorting" should happen in the presolver so we can share as much as possible. </dd> <dt> \_setscope operations_research::sat::LazyReasonInterface Member \_internalref classoperations__research_1_1sat_1_1LazyReasonInterface#adc031164213fd9db6f79e99441240ded "operations_research::sat::LazyReasonInterface::Explain" (int id, IntegerValue propagation_slack, IntegerVariable var_to_explain, int trail_index, std::vector< Literal > *literals_reason, std::vector< int > *trail_indices_reason)=0</dt><dd> \anchor _todo001735 (user): {id, propagation_slack, var_to_explain, trail_index} is just a generic "payload" and we should probably rename it as such so that each implementation can store different things. </dd> <dt> \_setscope operations_research::sat::LbTreeSearch Class \_internalref classoperations__research_1_1sat_1_1LbTreeSearch "operations_research::sat::LbTreeSearch" </dt><dd> \anchor _todo001853 (user): What this is doing is really similar to asking a SAT solver if the current objective lower bound is reachable by solving a SAT problem. However, this code handle on the side all the "conflict" of the form objective > current_lb. As a result, when it is UNSAT, we can bump the lower bound by a bigger amount than one. We also do not completely loose everything learned so far for the next iteration. </dd> <dt> \_setscope operations_research::sat::LbTreeSearch Member \_internalref classoperations__research_1_1sat_1_1LbTreeSearch#ab578e3dd57e9e2c0daff912371d19dc2 "operations_research::sat::LbTreeSearch::LbTreeSearch" (Model *model)</dt><dd> \anchor _todo001830 (user): Starts with an initial variable score for all variable in the objective at their minimum value? this should emulate the first step of the core approach and gives a similar bound. \anchor _todo001831 (user): if we have many independent LP, this will find nothing. </dd> <dt> \_setscope operations_research::sat::LbTreeSearch Member \_internalref classoperations__research_1_1sat_1_1LbTreeSearch#ab5eed5bfd114852c086831f49823d8ba "operations_research::sat::LbTreeSearch::Search" (const std::function< void()> &feasible_solution_observer)</dt><dd> \anchor _todo001834 (user): a strong branching initial start, or allowing a few decision per nodes might be a better approach. \anchor _todo001835 (user): It would also be cool to exploit the reason for the LB increase even more. \anchor _todo001836 (user): This is slightly different than bumping each time we push a decision that result in an LB increase. This is also called on backjump for instance. \anchor _todo001837 (user): We also need to update pseudo cost on conflict. \anchor _todo001838 (user): No point checking that if the objective lb wasn't assigned at this level. \anchor _todo001839 (user): Exploit the reasons further. \anchor _todo001840 (user): If we remember how far we can backjump for both true/false branch, we could be more efficient. \anchor _todo001841 (user): If we have new information and our current objective bound is higher than any bound in a whole subtree, we might want to just restart this subtree exploration? \anchor _todo001842 (user): The code is hard to follow. Fix and merge that with test below. \anchor _todo001843 (user): In multithread, this change the behavior a lot since we dive until we beat the best shared bound. Maybe we shouldn't do that. \anchor _todo001844 (user): We sometimes branch on the objective variable, this should probably be avoided. \anchor _todo001845 (user): it would be nice to mark some node as infeasible if this is the case. However this could happen after many decision and we realize with the lp that one of them should have been fixed earlier, without any infeasibility in the current branch. \anchor _todo001846 (user): Try to minimize the number of decisions? \anchor _todo001847 (user): We should probably save the basis in more cases. \anchor _todo001848 (user): Uses old optimal constraint that we just potentially backtracked over? \anchor _todo001849 (user): We could do all at once rather than in O(#decision * #size). </dd> <dt> \_setscope operations_research::sat::LevelZeroEquality Member \_internalref classoperations__research_1_1sat_1_1LevelZeroEquality#a6f4c89def00ad8b950b31383f59ba094 "operations_research::sat::LevelZeroEquality::Propagate" () final</dt><dd> \anchor _todo001753 (user): We could go even further than just the GCD, and do more arithmetic to tighten the target bounds. See for instance a problem like ej.mps.gz that we don't solve easily, but has just 3 variables! the goal is to minimize X, given 31013 X - 41014 Y - 51015 Z = -31013 (all >=0, Y and Z bounded with high values). I know some MIP solvers have a basic linear diophantine equation support. \anchor _todo001754 (user): Once the GCD is not 1, we could at any level make sure the objective is of the correct form. For now, this only happen in a few miplib problem that we close quickly, so I didn't add the extra code yet. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a18679d8902d037df4ad5371ab25ad435 "operations_research::sat::LinearBooleanProblemToCnfString" (const LinearBooleanProblem &problem)</dt><dd> \anchor _todo001080 (user): implement this trick. </dd> <dt> \_setscope operations_research::sat::LinearConstraintBuilder Class \_internalref classoperations__research_1_1sat_1_1LinearConstraintBuilder "operations_research::sat::LinearConstraintBuilder" </dt><dd> \anchor _todo001857 (user): Rename to LinearExpressionBuilder? </dd> <dt> \_setscope operations_research::sat::LinearConstraintBuilder Member \_internalref classoperations__research_1_1sat_1_1LinearConstraintBuilder#ae7f3237b747cd3a0ae75daf2f77e19d8 "operations_research::sat::LinearConstraintBuilder::AddDecomposedProduct" (absl::Span< const LiteralValueValue > product)</dt><dd> \anchor _todo001854 (user): Checks the value of literals. </dd> <dt> \_setscope operations_research::sat::LinearConstraintBuilder Member \_internalref classoperations__research_1_1sat_1_1LinearConstraintBuilder#a00685724ff7957bd0b8dbb337b2eacd6 "operations_research::sat::LinearConstraintBuilder::AddQuadraticLowerBound" (AffineExpression left, AffineExpression right, IntegerTrail *integer_trail, bool *is_quadratic=nullptr)</dt><dd> \anchor _todo001859 (user): We could use (max - delta) instead of (min + delta) for each expression instead. This would depend on the LP value of the left and right. </dd> <dt> \_setscope operations_research::sat::LinearConstraintBuilder Member \_internalref classoperations__research_1_1sat_1_1LinearConstraintBuilder#a2b9598a931a588949a8b5f5af8304ead "operations_research::sat::LinearConstraintBuilder::Build" ()</dt><dd> \anchor _todo001860 (user): this doesn't invalidate the builder object, but if one wants to do a lot of dynamic editing to the constraint, then then underlying algorithm needs to be optimized for that. </dd> <dt> \_setscope operations_research::sat::LinearConstraintBuilder Member \_internalref classoperations__research_1_1sat_1_1LinearConstraintBuilder#a029e8c7ac32054484a98093c2ad7629a "operations_research::sat::LinearConstraintBuilder::LinearConstraintBuilder" ()</dt><dd> \anchor _todo001858 (user): Have a subclass so we can enforce that a caller using AddLiteralTerm() must construct the Builder with an encoder. </dd> <dt> \_setscope operations_research::sat::LinearConstraintManager Member \_internalref classoperations__research_1_1sat_1_1LinearConstraintManager#a7ed5d2e7a9f57fe18d3962de8ee08815 "operations_research::sat::LinearConstraintManager::AddCut" (LinearConstraint ct, std::string type_name, std::string extra_info="")</dt><dd> \anchor _todo001862 (user): We could prevent overflow by dividing more. Note that mainly happen with super large variable domain since we usually restrict the size of the generated coefficients in our cuts. So it shouldn't be that important. \anchor _todo001863 (user): Use better heuristic here for detecting good cuts and mark them undeletable. </dd> <dt> \_setscope operations_research::sat::LinearConstraintManager Member \_internalref classoperations__research_1_1sat_1_1LinearConstraintManager#a6736aa5d3e7f0a44c29023b2bc85a453 "operations_research::sat::LinearConstraintManager::ChangeLp" (glop::BasisState *solution_state, int *num_new_constraints=nullptr)</dt><dd> \anchor _todo001867 (user): Because we simplified this constraint, it is possible that it is now a duplicate of another one. Merge them. \anchor _todo001868 (user): This blowup factor could be adaptative w.r.t. the constraint limit. \anchor _todo001869 (user): find better algo, this does 1000 * 4000 scalar product! \anchor _todo001870 (user): Experiment with different weights or different functions for computing score. \anchor _todo001871 (user): Instead of comparing num_deletable_constraints with cut limit, compare number of deletable constraints not in lp against the limit. </dd> <dt> \_setscope operations_research::sat::LinearConstraintManager::ConstraintInfo Member \_internalref structoperations__research_1_1sat_1_1LinearConstraintManager_1_1ConstraintInfo#a466661f3078984c94567ad58040edb6e "operations_research::sat::LinearConstraintManager::ConstraintInfo::inactive_count" </dt><dd> \anchor _todo001873 (user): This is the number of time the constraint was consecutively inactive, and go up to 100 with the default param, so we could optimize the space used more. </dd> <dt> \_setscope operations_research::sat::LinearConstraintManager::ConstraintInfo Member \_internalref structoperations__research_1_1sat_1_1LinearConstraintManager_1_1ConstraintInfo#abdf73acb15ffe53b95a4131d9ba9aac9 "operations_research::sat::LinearConstraintManager::ConstraintInfo::is_deletable" </dt><dd> \anchor _todo001875 (user): We can have a better heuristics. Some generated good cuts can be marked undeletable and some unused problem specified constraints can be marked deletable. </dd> <dt> \_setscope operations_research::sat::LinearConstraintManager::ConstraintInfo Member \_internalref structoperations__research_1_1sat_1_1LinearConstraintManager_1_1ConstraintInfo#af933df23d6da0e5b34f2f92696b70800 "operations_research::sat::LinearConstraintManager::ConstraintInfo::objective_parallelism_computed" </dt><dd> \anchor _todo001874 (user): Pack bool and in general optimize the memory of this class. </dd> <dt> \_setscope operations_research::sat::LinearConstraintPropagator Class \_internalref classoperations__research_1_1sat_1_1LinearConstraintPropagator "operations_research::sat::LinearConstraintPropagator< use_int128 >" </dt><dd> \anchor _todo001759 (user): Technically we could still have an int128 overflow since we sum n terms that cannot overflow but can still be pretty close to the limit. Make sure this never happens! For most problem though, because the variable bounds will be smaller than 10^9, we are pretty safe. \anchor _todo001760 (user): If one has many such constraint, it will be more efficient to propagate all of them at once rather than doing it one at the time. \anchor _todo001761 (user): Explore tree structure to get a log(n) complexity. \anchor _todo001762 (user): When the variables are Boolean, use directly the pseudo-Boolean constraint implementation. But we do need support for enforcement literals there. </dd> <dt> \_setscope operations_research::sat::LinearConstraintPropagator Member \_internalref classoperations__research_1_1sat_1_1LinearConstraintPropagator#a53f0cc28cdfafb5721ce374d3c16a973 "operations_research::sat::LinearConstraintPropagator< use_int128 >::ConditionalLb" (IntegerLiteral integer_literal, IntegerVariable target_var) const</dt><dd> \anchor _todo001748 (user): If there is a conflict (negative slack) we can be more precise. </dd> <dt> \_setscope operations_research::sat::LinearConstraintPropagator Member \_internalref classoperations__research_1_1sat_1_1LinearConstraintPropagator#ace49b8f6c8907a190c3aee7d359791fd "operations_research::sat::LinearConstraintPropagator< use_int128 >::LinearConstraintPropagator" (absl::Span< const Literal > enforcement_literals, absl::Span< const IntegerVariable > vars, absl::Span< const IntegerValue > coeffs, IntegerValue upper_bound, Model *model)</dt><dd> \anchor _todo001745 (user): deal with this corner case. </dd> <dt> \_setscope operations_research::sat::LinearConstraintPropagator Member \_internalref classoperations__research_1_1sat_1_1LinearConstraintPropagator#abd5b6d0682d0018f82fdce4233f6f576 "operations_research::sat::LinearConstraintPropagator< use_int128 >::LinearConstraintPropagator" (LinearConstraint ct, Model *model)</dt><dd> \anchor _todo001746 (user): Avoid duplication with other constructor. \anchor _todo001747 (user): deal with this corner case. </dd> <dt> \_setscope operations_research::sat::LinearConstraintPropagator Member \_internalref classoperations__research_1_1sat_1_1LinearConstraintPropagator#ae4ae154271da65071742b6a7dbe2d460 "operations_research::sat::LinearConstraintPropagator< use_int128 >::Propagate" () final</dt><dd> \anchor _todo001749 (user): If the new ub fall into an hole of the variable, we can actually relax the reason more by computing a better slack. \anchor _todo001750 (user): this is never supposed to happen since if we didn't have a conflict above, we should be able to reduce the upper bound. It might indicate an issue with our Boolean <-> integer encoding. </dd> <dt> \_setscope operations_research::sat::LinearConstraintPropagator Member \_internalref classoperations__research_1_1sat_1_1LinearConstraintPropagator#afb899d80eaee9952f8076176b345ee15 "operations_research::sat::LinearConstraintPropagator< use_int128 >::PropagateAtLevelZero" ()</dt><dd> \anchor _todo001751 (user): Deal with enforcements. It is just a bit of code to read the value of the literals at level zero. </dd> <dt> \_setscope operations_research::sat::LinearConstraintPropagator Member \_internalref classoperations__research_1_1sat_1_1LinearConstraintPropagator#acb9913bc77648b9229d90f8ebc306939 "operations_research::sat::LinearConstraintPropagator< use_int128 >::RegisterWith" (GenericLiteralWatcher *watcher)</dt><dd> \anchor _todo001752 (user): if there is more than one, maybe we should watch more to propagate a "conflict" as soon as only one is unassigned? </dd> <dt> \_setscope operations_research::sat::LinearIncrementalEvaluator Member \_internalref classoperations__research_1_1sat_1_1LinearIncrementalEvaluator#ad15e855847e8e9fd85eb17774c2fe277 "operations_research::sat::LinearIncrementalEvaluator::PrecomputeCompactView" (absl::Span< const int64_t > var_max_variation)</dt><dd> \anchor _todo001143 (user): We could delete them before. But at the time of this optimization, I didn't want to change the behavior of the algorithm at all. </dd> <dt> \_setscope operations_research::sat::LinearIncrementalEvaluator Member \_internalref classoperations__research_1_1sat_1_1LinearIncrementalEvaluator#aed1038acba7b405fb9c01417e3a1f05f "operations_research::sat::LinearIncrementalEvaluator::SlopeBreakpoints" (int var, int64_t current_value, const Domain &var_domain) const</dt><dd> \anchor _todo001142 (user): Deal with holes? </dd> <dt> \_setscope operations_research::sat::LinearIncrementalEvaluator Member \_internalref classoperations__research_1_1sat_1_1LinearIncrementalEvaluator#a099aa35ca98c88c59a3ea7269c34e704 "operations_research::sat::LinearIncrementalEvaluator::UpdateScoreOnWeightUpdate" (int c, absl::Span< const int64_t > jump_deltas, absl::Span< double > var_to_score_change)</dt><dd> \anchor _todo001137 (user): optimize even more for one sided constraints. Note(user): I tried to factor the two usage of this, but it is slower. </dd> <dt> \_setscope operations_research::sat::LinearIncrementalEvaluator Member \_internalref classoperations__research_1_1sat_1_1LinearIncrementalEvaluator#a201fdc143b0a225b578f5a5d123ef53a "operations_research::sat::LinearIncrementalEvaluator::WeightedViolationDelta" (absl::Span< const double > weights, int var, int64_t delta) const</dt><dd> \anchor _todo001141 (user): We can safely abort early if we know that delta will be >= 0. (user): Maybe we can compute an absolute value instead of removing old_distance. </dd> <dt> \_setscope operations_research::sat::LinearModel Member \_internalref classoperations__research_1_1sat_1_1LinearModel#a8c594ce81043440f547bf1320674a829 "operations_research::sat::LinearModel::LinearModel" (const CpModelProto &model_proto)</dt><dd> \anchor _todo001876 (user): Do we use the loader code to detect full encodings and element encodings. \anchor _todo001877 (user): Deal with/Check double insertion. </dd> <dt> \_setscope operations_research::sat::LinearProgrammingConstraint Member \_internalref classoperations__research_1_1sat_1_1LinearProgrammingConstraint#ac0030221b056d71c560de62bd9d57a09 "operations_research::sat::LinearProgrammingConstraint::IncrementalPropagate" (const std::vector< int > &watch_indices) override</dt><dd> \anchor _todo001890 (user): The saved lp solution is still valid given the current variable bounds, so the LP optimal didn't change. However we might still want to add new cuts or new lazy constraints? \anchor _todo001891 (user): Propagate the last optimal_constraint? Note that we need to be careful since the reversible int in IntegerSumLE are not registered. However, because we delete "optimalconstraints" on backtrack, we might not care. \anchor _todo001892 (user): We might still have problem at level zero. </dd> <dt> \_setscope operations_research::sat::LinearProgrammingConstraint Member \_internalref classoperations__research_1_1sat_1_1LinearProgrammingConstraint#ac305ae4d90e003c68c190a412f9879de "operations_research::sat::LinearProgrammingConstraint::LinearProgrammingConstraint" (Model *model, absl::Span< const IntegerVariable > vars)</dt><dd> \anchor _todo001878 (user): make SatParameters singleton too, otherwise changing them after a constraint was added will have no effect on this class. </dd> <dt> \_setscope operations_research::sat::LinearProgrammingConstraint Member \_internalref classoperations__research_1_1sat_1_1LinearProgrammingConstraint#a7ff29ebe58aca89b537dc833cc1c45de "operations_research::sat::LinearProgrammingConstraint::Propagate" () override</dt><dd> \anchor _todo001920 (user): It seems the time we loose by not stopping early might be worth it because we end up with a better explanation at optimality. \anchor _todo001921 (user): Refactor so that they are just normal cut generators? </dd> <dt> \_setscope operations_research::sat::LinearProgrammingConstraint Member \_internalref classoperations__research_1_1sat_1_1LinearProgrammingConstraint#a6f4001652e985a2165ad4d6602eae29b "operations_research::sat::LinearProgrammingConstraint::SetLevel" (int level) override</dt><dd> \anchor _todo001885 (user): Keep all optimal solution in the current branch? \anchor _todo001886 \anchor _todo001887 (user): Still try to add cuts/constraints though! \anchor _todo001888 \anchor _todo001889 (user): Reload the basis? This might cause issue with the basis saving/loading code in lb_tree_search. </dd> <dt> \_setscope operations_research::sat::LinearPropagator Class \_internalref classoperations__research_1_1sat_1_1LinearPropagator "operations_research::sat::LinearPropagator" </dt><dd> \anchor _todo001956 (user): This is a work in progress and is currently incomplete: - Lack more incremental support for faster propag. - Lack detection and propagation of at least one of these linear is true which can be used to propagate more bound if a variable appear in all these constraint. </dd> <dt> \_setscope operations_research::sat::LinearPropagator Member \_internalref classoperations__research_1_1sat_1_1LinearPropagator#a6b4adf9e4a241637f5dee4cc9ea43adc "operations_research::sat::LinearPropagator::AddConstraint" (absl::Span< const Literal > enforcement_literals, absl::Span< const IntegerVariable > vars, absl::Span< const IntegerValue > coeffs, IntegerValue upper_bound)</dt><dd> \anchor _todo001938 (user): we still waste the space in coeffs_buffer_ so that the start are aligned with the variables_buffer_. \anchor _todo001939 (user): With some care, when we cannot propagate or the constraint is not enforced, we could leave in_queue_[] at true but not put the constraint in the queue. \anchor _todo001940 (user): Shall we register root level precedence from here rather than separately? \anchor _todo001941 (user): Shall we decide on some ordering here? maybe big coeff first so that we get the largest change in slack? the idea being to propagate large change first in case of cycles. \anchor _todo001942 (user): Do we want to do that? </dd> <dt> \_setscope operations_research::sat::LinearPropagator Member \_internalref classoperations__research_1_1sat_1_1LinearPropagator#a615cc74a74066501e840dcc2343738ec "operations_research::sat::LinearPropagator::LinearPropagator" (Model *model)</dt><dd> \anchor _todo001933 (user): When we start to push too much (Cycle?) we should see what other propagator says before repropagating this one, system for call later? </dd> <dt> \_setscope operations_research::sat::LinearPropagator Member \_internalref classoperations__research_1_1sat_1_1LinearPropagator#a74432b1f2031ef1a7257cf98913c7390 "operations_research::sat::LinearPropagator::Propagate" () final</dt><dd> \anchor _todo001934 (user): More than the propagation speed, I think it is important to have proper explanation, so if A pushes B, but later on the queue we have C that push A that push B again, that might be bad? We can try to avoid this even further, by organizing the queue in passes: - Scan all relevant constraints, remember who pushes but DO NOT push yet! - If no cycle, do not pushes constraint whose slack will changes due to other pushes. - consider the new constraint that need to be scanned and repeat. I think it is okay to scan twice the constraints that push something in order to get better explanation. We tend to diverge from the class shortest path algo in this regard. \anchor _todo001935 (user): If we push the idea further, can we first compute the fix point without pushing anything, then compute a good order of constraints for the explanations? what is tricky is that we might need to "scan" more than once a constraint I think. ex: Y, Z, T >=0 - 2 * Y + Z + T <= 11 ==> Y <= 5, Z <= 11, T <= 11 (1) - Z + Y >= 6 ==> Z >= 1 - (1) again to push T <= 10 and reach the propagation fixed point. \anchor _todo001936 (user): Maybe we should "update" explanation if we have a shorter one to be less reliant on the propagation order. \anchor _todo001937 (user): This do not seems always good, especially since we pushed Boolean with a really small explanation, maybe we want to push more of these rather than go back to pure-binary propagation. </dd> <dt> \_setscope operations_research::sat::Literal Member \_internalref classoperations__research_1_1sat_1_1Literal#a3b27485970070e73266f5530d2a7f55c "operations_research::sat::Literal::operator LiteralIndex" () const</dt><dd> \anchor _todo002192 (user): LiteralIndex might not even be needed, but because of the signed value business, it is still safer with it. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a277ebf478f1fa693dd01867071080203 "operations_research::sat::LoadAndSolveCpModelForTest" (const CpModelProto &model_proto, Model *model)</dt><dd> \anchor _todo001487 (user): Clean this up. Solves a CpModelProto without any processing. Only used for unit tests. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a1efa4af8efff3dc82feb1add05075c63 "operations_research::sat::LoadBaseModel" (const CpModelProto &model_proto, Model *model)</dt><dd> \anchor _todo001494 (user): The core algo and symmetries seems to be problematic in some cases. See for instance: neos-691058.mps.gz. This is probably because as we modify the model, our symmetry might be wrong? investigate. \anchor _todo001495 (user): More generally, we cannot load the symmetry if we create new Booleans and constraints that link them to some Booleans of the model. Creating Booleans related to integer variable is fine since we only deal with Boolean only symmetry here. It is why we disable this when we have linear relaxation as some of them create new constraints. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a0df7b56e0026b783deeeff20487de7cf "operations_research::sat::LoadBooleanProblem" (const LinearBooleanProblem &problem, SatSolver *solver)</dt><dd> \anchor _todo001079 (user): Currently, the sat solver can load without any issue constraints with duplicate variables, so we just output a warning if the problem is not "valid". Make this a strong check once we have some preprocessing step to remove duplicates variable in the constraints. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a64c230730625662a2a2032da620b6c6e "operations_research::sat::LoadBooleanSymmetries" (const CpModelProto &model_proto, Model *m)</dt><dd> \anchor _todo001225 (user): We could add these extra Boolean during expansion/presolve so that we have the symmetry involing them. Or maybe comes up with a different solution. \anchor _todo001243 (user): We currently only have the code for Booleans, it is why we currently ignore symmetries involving integer variables. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a4b4da650bfcb86c00bee1df0ab0cc953 "operations_research::sat::LoadConditionalLinearConstraint" (const absl::Span< const Literal > enforcement_literals, const LinearConstraint &cst, Model *model)</dt><dd> \anchor _todo001768 (user): Remove the conversion! </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#ad81c56ee655b074e6d565cd223a70024 "operations_research::sat::LoadCpModel" (const CpModelProto &model_proto, Model *model)</dt><dd> \anchor _todo001496 (user): We don't have a good deterministic time on all constraints, so this might take more time than wanted. \anchor _todo001497 (user): This might still create intermediate variables to decompose the objective for no reason. Just deal directly with the objective domain in the core algo by forbidding bad assumptions? Alternatively, just ignore the core solution if it is "too" good and rely on other solvers? \anchor _todo001498 (user): Support objective bounds import in LNS and Core based search. \anchor _todo001499 (user): Remove code duplication with the solution_observer in SolveLoadedCpModel(). </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#ade08c3522dfce173ee1fd50fab3bd3c0 "operations_research::sat::LoadLinearConstraint" (const ConstraintProto &ct, Model *m)</dt><dd> \anchor _todo001239 (user): Actually this should never be called since we process linear1 in ExtractEncoding(). \anchor _todo001240 (user): Reuse ComputeLinearBounds()? but then we need another loop to detect if we only have Booleans. \anchor _todo001241 (user): we should probably also implement an half-reified version of this constraint. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a23861bab6341cfcfeeff90c2b3e3ab7e "operations_research::sat::LoadLinMaxConstraint" (const ConstraintProto &ct, Model *m)</dt><dd> \anchor _todo001242 (user): Consider replacing the min propagator by max. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a0f015dd7f088e0a586993ec925a94ced "operations_research::sat::LoadModelForProbing" (PresolveContext *context, Model *local_model)</dt><dd> \anchor _todo002133 (user): The model we load does not contain affine relations! But ideally we should be able to remove all of them once we allow more complex constraints to contains linear expression. \anchor _todo002134 (user): remove code duplication with cp_model_solver. Here we also do not run the heuristic to decide which variable to fully encode. \anchor _todo002135 (user): Maybe do not load slow to propagate constraints? for instance we do not use any linear relaxation here. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a47e5d5cb3e7eb43191d094fc4752b5c6 "operations_research::sat::LoadVariables" (const CpModelProto &model_proto, bool view_all_booleans_as_integers, Model *m)</dt><dd> \anchor _todo001224 (user): Fix the constant variable situation. An optional interval with constant start/end or size cannot share the same constant variable if it is used in non-optional situation. </dd> <dt> \_setscope operations_research::sat::LocalBranchingLpBasedNeighborhoodGenerator Member \_internalref classoperations__research_1_1sat_1_1LocalBranchingLpBasedNeighborhoodGenerator#aa12eefb1663a627e6519658d87dc3f19 "operations_research::sat::LocalBranchingLpBasedNeighborhoodGenerator::Generate" (const CpSolverResponse &initial_solution, double difficulty, absl::BitGenRef random) final</dt><dd> \anchor _todo001208 (user): Extend to integer variables. </dd> <dt> \_setscope operations_research::sat::LocalBranchingLpBasedNeighborhoodGenerator Member \_internalref classoperations__research_1_1sat_1_1LocalBranchingLpBasedNeighborhoodGenerator#a965d1a7c6cd024de0b2e7a9bf8642f30 "operations_research::sat::LocalBranchingLpBasedNeighborhoodGenerator::LocalBranchingLpBasedNeighborhoodGenerator" (NeighborhoodGeneratorHelper const *helper, absl::string_view name, std::function< void(CpModelProto, Model *)> solve_callback, ModelSharedTimeLimit *const global_time_limit)</dt><dd> \anchor _todo001223 (user): Restructure code so that we avoid circular dependency with solving functions. For now, we use solve_callback. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#ae9ec04c047ef7bfe5cfa06c17ff0c76d "operations_research::sat::LpPseudoCostHeuristic" (Model *model)</dt><dd> \anchor _todo001774 (user): Use strong branching when not reliable. \anchor _todo001775 \anchor _todo001776 (user): do not branch on integer lp? however it seems better to do that !? Maybe this is because if it has a high pseudo cost average, it is good anyway? \anchor _todo001777 (user): investigate. </dd> <dt> \_setscope operations_research::sat::LsEvaluator Class \_internalref classoperations__research_1_1sat_1_1LsEvaluator "operations_research::sat::LsEvaluator" </dt><dd> \anchor _todo001147 (user): Ideas for constraint generated moves or sequences of moves? </dd> <dt> \_setscope operations_research::sat::LsEvaluator Member \_internalref classoperations__research_1_1sat_1_1LsEvaluator#a55666b5aee7e751b4bc51f963c2fbaa3 "operations_research::sat::LsEvaluator::DeterministicTime" () const</dt><dd> \anchor _todo001148 (user): Properly account all big time consumers. </dd> <dt> \_setscope operations_research::sat::LsEvaluator Member \_internalref classoperations__research_1_1sat_1_1LsEvaluator#ac2c554a2c06db8258745c13c4c33ee5b "operations_research::sat::LsEvaluator::WeightedViolationDelta" (bool linear_only, absl::Span< const double > weights, int var, int64_t delta, absl::Span< int64_t > mutable_solution) const</dt><dd> \anchor _todo001145 (user): refine on a per constraint basis. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#af004193a12bf9ed78b295e7f7cb51e6f "operations_research::sat::MinimizeCore" (SatSolver *solver, std::vector< Literal > *core)</dt><dd> \anchor _todo002304 (user): One should use MinimizeCoreWithPropagation() instead. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a4d6ba15542ec5d59958de53c92279b2a "operations_research::sat::MinimizeCoreWithPropagation" (TimeLimit *limit, SatSolver *solver, std::vector< Literal > *core)</dt><dd> \anchor _todo002040 (user): Avoid spending too much time trying to minimize a core. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a56ad40efdac4d337987b0ca306aa7bd6 "operations_research::sat::MinimizeCoreWithSearch" (TimeLimit *limit, SatSolver *solver, std::vector< Literal > *core)</dt><dd> \anchor _todo002015 (user): tune. \anchor _todo002016 (user): Properly use the node depth instead. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a633a2eb5447b0e49f8958cb4bb4b7a44 "operations_research::sat::MinimizeL1DistanceWithHint" (const CpModelProto &model_proto, Model *model)</dt><dd> \anchor _todo001505 (user): As of now the repair hint doesn't support when enumerate_all_solutions is set since the solution is created on a different model. \anchor _todo001506 (user): For boolean variables we can avoid creating new variables. </dd> <dt> \_setscope operations_research::sat::MinPropagator Class \_internalref classoperations__research_1_1sat_1_1MinPropagator "operations_research::sat::MinPropagator" </dt><dd> \anchor _todo001763 (user): Implement a more efficient algorithm when the need arise. </dd> <dt> \_setscope operations_research::sat::MinPropagator Member \_internalref classoperations__research_1_1sat_1_1MinPropagator#aa5ab4a97c4fe03823494846846b5accd "operations_research::sat::MinPropagator::Propagate" () final</dt><dd> \anchor _todo001755 (user): Not sure this code is useful since this will be detected by the fact that the [lb, ub] of the min is empty. It depends on the propagation order though, but probably the precedences propagator would propagate before this one. So change this to a CHECK? </dd> <dt> \_setscope operations_research::sat::Model Member \_internalref classoperations__research_1_1sat_1_1Model#ad025b208280b29fc3cfe2b7d3d61c8f9 "operations_research::sat::Model::GetOrCreate" ()</dt><dd> \anchor _todo002013 (user): directly store std::unique_ptr<> in singletons_? </dd> <dt> \_setscope operations_research::sat::ModelCopy Member \_internalref classoperations__research_1_1sat_1_1ModelCopy#ac6485d6a1464dec0bb052ecbf1db3da9 "operations_research::sat::ModelCopy::ImportAndSimplifyConstraints" (const CpModelProto &in_model, bool first_copy=false, std::function< bool(int)> active_constraints=nullptr)</dt><dd> \anchor _todo001411 (user): Merge with the phase 1 of the presolve code. \anchor _todo001412 (user): It seems easy to forget to update this if any new constraint contains an interval or if we add a field to an existing constraint. Find a way to remind contributor to not forget this. \anchor _todo001413 (user): if ignore_names is false, we should make sure the name are properly copied by all these functions. Or we should never copy name and have a separate if (!ignore_name) copy the name... \anchor _todo001414 (user): find a better way than copy then clear_name()? </dd> <dt> \_setscope operations_research::sat::ModelRandomGenerator Member \_internalref classoperations__research_1_1sat_1_1ModelRandomGenerator#a94be5f7295c63407b5efb55e55724391 "operations_research::sat::ModelRandomGenerator::LogSalt" () const</dt><dd> \anchor _todo002405 (user): I didn't find a cleaner way to log this. </dd> <dt> \_setscope operations_research::sat::MutableUpperBoundedLinearConstraint Member \_internalref classoperations__research_1_1sat_1_1MutableUpperBoundedLinearConstraint#a4a9b63c72d02a80a8f76efbb0f020a3f "operations_research::sat::MutableUpperBoundedLinearConstraint::ClearAll" ()</dt><dd> \anchor _todo002050 (user): We could be more efficient and have only one loop here. </dd> <dt> \_setscope operations_research::sat::MutableUpperBoundedLinearConstraint Member \_internalref classoperations__research_1_1sat_1_1MutableUpperBoundedLinearConstraint#a56db11b9d396d13e4cff87b74b086d81 "operations_research::sat::MutableUpperBoundedLinearConstraint::ComputeSlackForTrailPrefix" (const Trail &trail, int trail_index) const</dt><dd> \anchor _todo002052 (user): Keep this for DCHECK(), but maintain the slack incrementally instead of recomputing it. </dd> <dt> \_setscope operations_research::sat::MutableUpperBoundedLinearConstraint Member \_internalref classoperations__research_1_1sat_1_1MutableUpperBoundedLinearConstraint#a467eaf21318efb233670a0035a2eae34 "operations_research::sat::MutableUpperBoundedLinearConstraint::ReduceCoefficients" ()</dt><dd> \anchor _todo002051 (user): Also reduce the trivially false literal when coeff > rhs_ ? </dd> <dt> \_setscope operations_research::sat::MutableUpperBoundedLinearConstraint Member \_internalref classoperations__research_1_1sat_1_1MutableUpperBoundedLinearConstraint#a2d8ea04aaae8c892a39770e35eced029 "operations_research::sat::MutableUpperBoundedLinearConstraint::ReduceCoefficientsAndComputeSlackForTrailPrefix" (const Trail &trail, int trail_index)</dt><dd> \anchor _todo002066 (user): Ideally the slack should be maitainable incrementally. </dd> <dt> \_setscope operations_research::sat::Neighborhood Member \_internalref structoperations__research_1_1sat_1_1Neighborhood#a9d77507f928ca9524da987bfbf75eee8 "operations_research::sat::Neighborhood::id" </dt><dd> \anchor _todo001218 (user): Make sure that the id is unique for each generated neighborhood for each generator. </dd> <dt> \_setscope operations_research::sat::NeighborhoodGenerator Member \_internalref classoperations__research_1_1sat_1_1NeighborhoodGenerator#ac8a7ed70ccae23b555deecf09756273f "operations_research::sat::NeighborhoodGenerator::Synchronize" ()</dt><dd> \anchor _todo001202 (user): Weight more recent data. degrade the current average to forget old learnings. \anchor _todo001203 (user): experiment with resetting the time limit if a solution is found. </dd> <dt> \_setscope operations_research::sat::NeighborhoodGeneratorHelper Member \_internalref classoperations__research_1_1sat_1_1NeighborhoodGeneratorHelper#a4853fe1b4ccd3d76f67706efd11a0698 "operations_research::sat::NeighborhoodGeneratorHelper::FixGivenVariables" (const CpSolverResponse &base_solution, const absl::flat_hash_set< int > &variables_to_fix) const</dt><dd> \anchor _todo001198 (user): Maybe relax all variables in the objective when the number is small or negligible compared to the number of variables. \anchor _todo001199 (user): If there is just one component, we can skip some computation. \anchor _todo001200 (user): We could handle some complex domain (size > 2). \anchor _todo001201 (user): force better objective? Note that this is already done when the hint above is successfully loaded (i.e. if it passes the presolve correctly) since the solver will try to find better solution than the current one. </dd> <dt> \_setscope operations_research::sat::NeighborhoodGeneratorHelper Member \_internalref classoperations__research_1_1sat_1_1NeighborhoodGeneratorHelper#aca0952c56878d9ecc6a8557bd42d170e "operations_research::sat::NeighborhoodGeneratorHelper::GetSchedulingPrecedences" (const absl::flat_hash_set< int > &ignored_intervals, const CpSolverResponse &initial_solution, absl::BitGenRef random) const</dt><dd> \anchor _todo001196 (user): We could scan for model precedences and add them to the list of precedences. This could enable more simplifications in the transitive reduction phase. \anchor _todo001197 (user): Reduce precedence graph </dd> <dt> \_setscope operations_research::sat::NeighborhoodGeneratorHelper Member \_internalref classoperations__research_1_1sat_1_1NeighborhoodGeneratorHelper#aebc02302feafecf7907a5fcc097b7486 "operations_research::sat::NeighborhoodGeneratorHelper::graph_mutex_" </dt><dd> \anchor _todo001219 (user): Refactor the class to be thread-safe instead, it should be safer and more easily maintainable. Some complication with accessing the variable<->constraint graph efficiently though. </dd> <dt> \_setscope operations_research::sat::NeighborhoodGeneratorHelper Member \_internalref classoperations__research_1_1sat_1_1NeighborhoodGeneratorHelper#a83668c50ed54cfcd6b559374579eeca7 "operations_research::sat::NeighborhoodGeneratorHelper::Synchronize" () override</dt><dd> \anchor _todo001183 (user): We could set the optional literal to false directly in the bound sharing manager. We do have to be careful that all the different solvers have the same optionality definition though. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a10700832ca6bc420f2931eb707957b0b "operations_research::sat::NewSatParameters" (const std::string &params)</dt><dd> \anchor _todo001457 (user): Support it on android. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a4bd54ab16ebc1bd6fa80d1e23ab79adc "operations_research::sat::NewSatParameters" (const sat::SatParameters &parameters)</dt><dd> \anchor _todo001458 (user): A notable exception to this is the TimeLimit which is currently not initializing itself from the SatParameters in the model. It will also starts counting from the time of its creation. It will be good to find a solution that is less error prone. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#ad8af8f787d40f2ccb96beb5306c913c5 "operations_research::sat::NewWeightedSum" (const VectorInt &coefficients, const std::vector< IntegerVariable > &vars)</dt><dd> \anchor _todo001769 (user): invert the coefficients/vars arguments. \anchor _todo001770 (user): deal with overflow here too! </dd> <dt> \_setscope operations_research::sat::NoCyclePropagator Member \_internalref classoperations__research_1_1sat_1_1NoCyclePropagator#a8114b6f2c07e82698969a873461784ec "operations_research::sat::NoCyclePropagator::NoCyclePropagator" (int num_nodes, const std::vector< int > &tails, const std::vector< int > &heads, const std::vector< Literal > &literals, Model *model)</dt><dd> \anchor _todo001089 (user): Uniformize this across propagator. Sometimes it is nice not to register them, but most of them can be registered right away. </dd> <dt> \_setscope operations_research::sat::NoCyclePropagator Member \_internalref classoperations__research_1_1sat_1_1NoCyclePropagator#a0751bd29114a60910d7626a21eb88b94 "operations_research::sat::NoCyclePropagator::Propagate" () final</dt><dd> \anchor _todo001090 (user): only explore node with newly added arcs. \anchor _todo001091 (user): We could easily re-index the graph so that only nodes with arcs are used. Because right now we are in O(num_nodes) even if the graph is empty. \anchor _todo001092 (user): We could be more efficient here, but this is only executed on conflicts. We should at least make sure we return a single cycle even though if this is called often enough, we shouldn't have a lot more than this. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a7ab66b40d6b1168f1a5a47fcf16636ac "operations_research::sat::NonDeterministicLoop" (std::vector< std::unique_ptr< SubSolver > > &subsolvers, const int num_threads)</dt><dd> \anchor _todo002349 (user): We could also directly register callback to set stopping Boolean to false in a few places. </dd> <dt> \_setscope operations_research::sat::NonOverlappingRectanglesEnergyPropagator Member \_internalref classoperations__research_1_1sat_1_1NonOverlappingRectanglesEnergyPropagator#a62a25736327376f2887d657c9885ee4b "operations_research::sat::NonOverlappingRectanglesEnergyPropagator::Propagate" () final</dt><dd> \anchor _todo001611 (user): double-check/revisit the algo for box of variable sizes. </dd> <dt> \_setscope operations_research::sat::ObjectiveEncoder Member \_internalref classoperations__research_1_1sat_1_1ObjectiveEncoder#aba8bf46b2a10fabd82ffd3dbf2f0e174 "operations_research::sat::ObjectiveEncoder::nodes" () const</dt><dd> \anchor _todo001663 (user): Remove mutable version once refactoring is done. </dd> <dt> \_setscope operations_research::sat::ObjectiveEncoder Member \_internalref classoperations__research_1_1sat_1_1ObjectiveEncoder#aea57787b48ca659a4962d5b674a72762 "operations_research::sat::ObjectiveEncoder::ProcessCore" (absl::Span< const Literal > core, Coefficient min_weight, Coefficient gap, std::string *info)</dt><dd> \anchor _todo001659 (user): propagate proper ub first. \anchor _todo001660 (user): this node is closed and can be removed from the core. \anchor _todo001661 (user): If assignment.LiteralIsTrue(bool_nodes[j]) We can minimize the core here by removing bool_nodes[i] from it. Note however that since we already minimized the core, this is unlikely to happen. \anchor _todo001662 (user): If we infered the exactly one from the binary implication graph, there is no need to add the amo since it is already there. </dd> <dt> \_setscope operations_research::sat::ObjectiveShavingSolver Member \_internalref classoperations__research_1_1sat_1_1ObjectiveShavingSolver#a7885d03789e15398197965ce723c3d59 "operations_research::sat::ObjectiveShavingSolver::Synchronize" () override</dt><dd> \anchor _todo002324 (user): Also stop if we have enough newly fixed / improved root level bounds so that we think it is worth represolving and restarting. </dd> <dt> \_setscope operations_research::sat::PbConstraints Member \_internalref classoperations__research_1_1sat_1_1PbConstraints#a09190309faf157e3b7187403cfcb514c "operations_research::sat::PbConstraints::AddConstraint" (const std::vector< LiteralWithCoeff > &cst, Coefficient rhs, Trail *trail)</dt><dd> \anchor _todo002058 (user): This is relatively slow. Take the "transpose" all at once, and maybe put small constraints first on the to_update_ lists. \anchor _todo002059 (user): the index is needed to give the correct thresholds_ entry to InitializeRhs() below, but this linear scan is not super efficient. </dd> <dt> \_setscope operations_research::sat::PbConstraints Member \_internalref classoperations__research_1_1sat_1_1PbConstraints#a9474a3e975c9c26b00740c514d82c373 "operations_research::sat::PbConstraints::BumpActivity" (UpperBoundedLinearConstraint *constraint)</dt><dd> \anchor _todo002071 (user): Remove duplication with other activity update functions. </dd> <dt> \_setscope operations_research::sat::PbConstraints Member \_internalref classoperations__research_1_1sat_1_1PbConstraints#a38e94ac484dcbd409e942d4e6f51d585 "operations_research::sat::PbConstraints::ClearConflictingConstraint" ()</dt><dd> \anchor _todo002070 (user): This is a hack to get the PB conflict, because the rest of the solver API assume only clause conflict. Find a cleaner way? </dd> <dt> \_setscope operations_research::sat::PostsolveClauses Struct \_internalref structoperations__research_1_1sat_1_1PostsolveClauses "operations_research::sat::PostsolveClauses" </dt><dd> \anchor _todo002261 (user): Use a flat memory structure instead. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a1951d3606d9c0c92204c310b911bf0e7 "operations_research::sat::PostsolveLinear" (const ConstraintProto &ct, std::vector< Domain > *domains)</dt><dd> \anchor _todo001247 (user): I am not 100% that the algo here might cover all the presolve case, so if this fail, it might indicate an issue here and not in the presolve/solver code. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a3e2be878d255ed853ce6a36d52c899dd "operations_research::sat::PostsolveResponse" (const int64_t num_variables_in_original_model, const CpModelProto &mapping_proto, const std::vector< int > &postsolve_mapping, std::vector< int64_t > *solution)</dt><dd> \anchor _todo001248 (user): We could use the search strategy to fix free variables to some chosen values? The feature might never be needed though. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a5baef3581c3189a7843edd238f14dba0 "operations_research::sat::PostsolveResponseWithFullSolver" (int num_variables_in_original_model, CpModelProto mapping_proto, const std::vector< int > &postsolve_mapping, std::vector< int64_t > *solution)</dt><dd> \anchor _todo001507 (user): If this ever shows up in the profile, we could avoid copying the mapping_proto if we are careful about how we modify the variable domain before postsolving it. Note that 'num_variables_in_original_model' refers to the model before presolve. \anchor _todo001508 (user): this problem is usually trivial, but we may still want to impose a time limit or copy some of the parameters passed by the user. </dd> <dt> \_setscope operations_research::sat::PrecedenceRelations Class \_internalref classoperations__research_1_1sat_1_1PrecedenceRelations "operations_research::sat::PrecedenceRelations" </dt><dd> \anchor _todo002106 (user): Support conditional relation. (user): Support non-DAG like graph. (user): Support variable offset that can be updated as search progress. </dd> <dt> \_setscope operations_research::sat::PrecedenceRelations Member \_internalref classoperations__research_1_1sat_1_1PrecedenceRelations#a4ca1b54209b1598460d8ef4eee99221b "operations_research::sat::PrecedenceRelations::Add" (IntegerVariable tail, IntegerVariable head, IntegerValue offset)</dt><dd> \anchor _todo002073 (user): Return infeasible if tail == head and offset > 0. \anchor _todo002074 \anchor _todo002075 (user): if tail = Negation(head) also update Domain. \anchor _todo002076 (user): AddInternal() only returns true if this is the first relation between head and tail. But we can still avoid an extra lookup. \anchor _todo002077 (user): Alternatively, force caller to do a Resize(). </dd> <dt> \_setscope operations_research::sat::PrecedenceRelations Member \_internalref classoperations__research_1_1sat_1_1PrecedenceRelations#a95dab1b3432098f1e966ec42fb3a26f3 "operations_research::sat::PrecedenceRelations::Build" ()</dt><dd> \anchor _todo002078 (user): Support negative offset? \anchor _todo002079 (user): This can fail if we don't have a DAG. We could just skip Bad edges instead, and have a sub-DAG as an heuristic. Or analyze the arc weight and make sure cycle are not an issue. We can also start with arcs with strictly positive weight. \anchor _todo002080 (user): Only explore the sub-graph reachable from "vars". \anchor _todo002081 (user): Also do that if we don't have a DAG? \anchor _todo002115 (user): Be more dynamic as we start to add relations during search. </dd> <dt> \_setscope operations_research::sat::PrecedenceRelations Member \_internalref classoperations__research_1_1sat_1_1PrecedenceRelations#acc266b82a08891d9278284b41a66a9ce "operations_research::sat::PrecedenceRelations::ComputeFullPrecedences" (absl::Span< const IntegerVariable > vars, std::vector< FullIntegerPrecedence > *output)</dt><dd> \anchor _todo002082 (user): use vector of fixed size. \anchor _todo002083 (user): optimize when needed. \anchor _todo002084 (user): Release the memory right away. \anchor _todo002111 (user): generalize. \anchor _todo002112 (user): Put some work limit in place, as this can be slow. Complexity is in O(vars.size()) * num_arcs. \anchor _todo002113 (user): Since we don't need ALL precedences, we could just work on a sub-DAG of the full precedence graph instead of aborting. Or we can just support the general non-DAG cases. \anchor _todo002114 (user): Many relations can be redundant. Filter them. </dd> <dt> \_setscope operations_research::sat::PrecedencesPropagator Class \_internalref classoperations__research_1_1sat_1_1PrecedencesPropagator "operations_research::sat::PrecedencesPropagator" </dt><dd> \anchor _todo002107 (user): We could easily generalize the code to support any relation of the form a*X + b*Y + c*Z >= rhs (or <=). Do that since this class should be a lot faster at propagating small linear inequality than the generic propagator and the overhead of supporting coefficient should not be too bad. </dd> <dt> \_setscope operations_research::sat::PrecedencesPropagator Member \_internalref classoperations__research_1_1sat_1_1PrecedencesPropagator#a15a72ea359f6b0297496d690fb35d81a "operations_research::sat::PrecedencesPropagator::AddPrecedenceWithOffsetIfNew" (IntegerVariable i1, IntegerVariable i2, IntegerValue offset)</dt><dd> \anchor _todo002092 (user): Modify arc in place! </dd> <dt> \_setscope operations_research::sat::PrecedencesPropagator Member \_internalref classoperations__research_1_1sat_1_1PrecedencesPropagator#a68e6ed997752f220d4571c5faa136ce5 "operations_research::sat::PrecedencesPropagator::Propagate" () final</dt><dd> \anchor _todo002085 (user): Because of our code to deal with InPropagationLoop(), this is not always true. Find a cleaner way to DCHECK() while not failing in this corner case. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a7a3e424a9963561cbd837b7a293b416e "operations_research::sat::PresolveBooleanLinearExpression" (std::vector< Literal > *literals, std::vector< Coefficient > *coefficients, Coefficient *offset)</dt><dd> \anchor _todo002041 (user): Merge this with similar code like ComputeBooleanLinearExpressionCanonicalForm(). </dd> <dt> \_setscope operations_research::sat::PresolveContext Member \_internalref classoperations__research_1_1sat_1_1PresolveContext#a5670894aad056fc4452807432b031858 "operations_research::sat::PresolveContext::AddImplyInDomain" (int b, int x, const Domain &domain)</dt><dd> \anchor _todo002121 (user): Find the best way to create such small proto. </dd> <dt> \_setscope operations_research::sat::PresolveContext Member \_internalref classoperations__research_1_1sat_1_1PresolveContext#a0e57a4d478e6619ec142e1c0e3da51a3 "operations_research::sat::PresolveContext::CanonicalizeObjective" (bool simplify_domain=true)</dt><dd> \anchor _todo002130 (user): This is a bit duplicated with the presolve linear code. We also do not propagate back any domain restriction from the objective to the variables if any. </dd> <dt> \_setscope operations_research::sat::PresolveContext Member \_internalref classoperations__research_1_1sat_1_1PresolveContext#a2ccc5bf972c4cfe911eb430e97dd3c57 "operations_research::sat::PresolveContext::CanonicalizeVariable" (int ref)</dt><dd> \anchor _todo002141 (user): When we can always get rid of affine relation, it might be good to do a final pass to canonicalize all domains in a model after presolve. </dd> <dt> \_setscope operations_research::sat::PresolveContext Member \_internalref classoperations__research_1_1sat_1_1PresolveContext#acfa9e96fd82123e73419f70c85690153 "operations_research::sat::PresolveContext::ConstraintVariableUsageIsConsistent" ()</dt><dd> \anchor _todo002123 (user): Also test var_to_constraints_ !! </dd> <dt> \_setscope operations_research::sat::PresolveContext Member \_internalref classoperations__research_1_1sat_1_1PresolveContext#ac5377b5320ad26e469e680b7d3bab02b "operations_research::sat::PresolveContext::InsertVarValueEncoding" (int literal, int var, int64_t value)</dt><dd> \anchor _todo002142 (user): This function is not always correct if !context->DomainOf(var).contains(value), we could make it correct but it might be a bit expansive to do so. For now we just have a DCHECK(). </dd> <dt> \_setscope operations_research::sat::PresolveContext Member \_internalref classoperations__research_1_1sat_1_1PresolveContext#a6e1524915705b3272bab45c634fb5a37 "operations_research::sat::PresolveContext::IsFullyEncoded" (int ref) const</dt><dd> \anchor _todo002143 (user): If the domain was shrunk, we can have a false positive. Still it means that the number of values removed is greater than the number of values not encoded. </dd> <dt> \_setscope operations_research::sat::PresolveContext Member \_internalref classoperations__research_1_1sat_1_1PresolveContext#a38e2f15d439243fcc447d48fe120624e "operations_research::sat::PresolveContext::NewIntVar" (const Domain &domain)</dt><dd> \anchor _todo002139 (user): We should control more how this is called so we can update a solution hint accordingly. </dd> <dt> \_setscope operations_research::sat::PresolveContext Member \_internalref classoperations__research_1_1sat_1_1PresolveContext#a3ee008e9272dbcc3132a667eefc41923 "operations_research::sat::PresolveContext::NotifyThatModelIsUnsat" (absl::string_view message="")</dt><dd> \anchor _todo002140 (user): Report any explanation for the client in a nicer way? </dd> <dt> \_setscope operations_research::sat::PresolveContext Member \_internalref classoperations__research_1_1sat_1_1PresolveContext#a392085a404b28b5e5a405c4e115e5332 "operations_research::sat::PresolveContext::ShiftCostInExactlyOne" (absl::Span< const int > exactly_one, int64_t shift)</dt><dd> \anchor _todo002131 (user): Be more precise with this objective_overflow_detection_ and always keep it up to date on each offset / coeff change. \anchor _todo002132 (user): This is a bit hacky, find a nicer way. </dd> <dt> \_setscope operations_research::sat::PresolveContext Member \_internalref classoperations__research_1_1sat_1_1PresolveContext#aa087429f5cddf5be6c225890f614b4f1 "operations_research::sat::PresolveContext::StoreAffineRelation" (int ref_x, int ref_y, int64_t coeff, int64_t offset, bool debug_no_recursion=false)</dt><dd> \anchor _todo002124 (user): Do we implement a rounding to closest instead of routing towards 0. \anchor _todo002125 (user): I am not 100% sure why, but sometimes the representative is fixed but that is not propagated to ref_x or ref_y and this causes issues. \anchor _todo002126 (user): we can do better for overflow by not always choosing the min at zero, do the best things if it becomes needed. \anchor _todo002127 (user): can we force the rep and remove GetAffineRelation()? \anchor _todo002128 (user): I am not sure this is needed given the propagation above. </dd> <dt> \_setscope operations_research::sat::PresolveContext Member \_internalref classoperations__research_1_1sat_1_1PresolveContext#ab43f7366b32b2ac40cc0f7f668040c49 "operations_research::sat::PresolveContext::UpdateRuleStats" (const std::string &name, int num_times=1)</dt><dd> \anchor _todo002122 rules as this is used to decide if we loop again. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a76af37fab5c93f2f256ff65457866fb4 "operations_research::sat::ProbeAndFindEquivalentLiteral" (SatSolver *solver, SatPostsolver *postsolver, DratProofHandler *drat_proof_handler, util_intops::StrongVector< LiteralIndex, LiteralIndex > *mapping, SolverLogger *logger)</dt><dd> \anchor _todo002339 (user): Add some constraint so that it does? \anchor _todo002340 (user): check compatibility? if x ~ not(x) => unsat. but probably, the solver would have found this too? not sure... \anchor _todo002341 (user): Fixing a variable might fix more of them by propagation, so we might not fix everything possible with these loops. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a60a37142e38a0a290d70b030405db801 "operations_research::sat::ProbeAndSimplifyProblem" (SatPostsolver *postsolver, LinearBooleanProblem *problem)</dt><dd> \anchor _todo001085 (user): expose the number of iterations as a parameter. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a98f7eb19b1030f3da667a3914c7ba666 "operations_research::sat::ProbeLiteral" (Literal assumption, SatSolver *solver)</dt><dd> \anchor _todo002017 (user): Still use it if the problem is Boolean only. </dd> <dt> \_setscope operations_research::sat::Prober Member \_internalref classoperations__research_1_1sat_1_1Prober#ab1e9d80c7f62d666ad8a3ec5a14f3c13 "operations_research::sat::Prober::ProbeBooleanVariables" (double deterministic_time_limit, absl::Span< const BooleanVariable > bool_vars)</dt><dd> \anchor _todo002156 (user): Instead of an hard deterministic limit, we should probably use a lower one, but reset it each time we have found something useful. </dd> <dt> \_setscope operations_research::sat::Prober Member \_internalref classoperations__research_1_1sat_1_1Prober#a2127d7db0f3c791613c92c8177e02432 "operations_research::sat::Prober::ProbeBooleanVariables" (double deterministic_time_limit)</dt><dd> \anchor _todo002164 (user): For now we process the Boolean in their natural order, this is not the most efficient. \anchor _todo002165 (user): This might generate a lot of new direct implications. We might not want to add them directly to the BinaryImplicationGraph and could instead use them directly to detect equivalent literal like in ProbeAndFindEquivalentLiteral(). The situation is not clear. \anchor _todo002166 (user): More generally, we might want to register any literal => bound in the IntegerEncoder. This would allow to remember them and use them in other part of the solver (cuts, lifting, ...). \anchor _todo002167 (user): Rename to include Integer in the name and distinguish better from FailedLiteralProbing() below. </dd> <dt> \_setscope operations_research::sat::Prober Member \_internalref classoperations__research_1_1sat_1_1Prober#a530c77d3421958a676e67d4463b2c1a1 "operations_research::sat::Prober::ProbeDnf" (absl::string_view name, absl::Span< const std::vector< Literal > > dnf)</dt><dd> \anchor _todo002157 (user): Can we use the callback_? </dd> <dt> \_setscope operations_research::sat::ProbingOptions Member \_internalref structoperations__research_1_1sat_1_1ProbingOptions#a0ad34d874b506bc2be329d5cc4f8e185 "operations_research::sat::ProbingOptions::deterministic_limit" </dt><dd> \anchor _todo002168 (user): We can also provide a middle ground and probe all failed literal but do not extract all binary clauses. \anchor _todo002169 (user): The fix point is not yet reached since we don't currently simplify non-binary clauses with these equivalence, but we will. </dd> <dt> \_setscope operations_research::sat::ProbingOptions Member \_internalref structoperations__research_1_1sat_1_1ProbingOptions#af5a82baa2dc19e7fe7e018b63c499042 "operations_research::sat::ProbingOptions::extract_binary_clauses" </dt><dd> \anchor _todo002170 (user): Note that adding binary clause before/during the SAT presolve is currently not always a good idea. This is because we don't simplify the other clause as much as we could. Also, there can be up to a quadratic number of clauses added this way, which might slow down things a lot. But then because of the deterministic limit, we usually cannot add too much clauses, even for huge problems, since we will reach the limit before that. </dd> <dt> \_setscope operations_research::sat::ProbingOptions Member \_internalref structoperations__research_1_1sat_1_1ProbingOptions#ab4df2ae2f59c5cb13fe680c9580fc64f "operations_research::sat::ProbingOptions::use_queue" </dt><dd> \anchor _todo002171 (user): Decide which one is better, currently the difference seems small but the queue seems slightly faster. </dd> <dt> \_setscope operations_research::sat::ProductDecomposer Member \_internalref classoperations__research_1_1sat_1_1ProductDecomposer#a45c18f04782c89b35181121f284b5ceb "operations_research::sat::ProductDecomposer::TryToLinearize" (const AffineExpression &left, const AffineExpression &right, LinearConstraintBuilder *builder)</dt><dd> \anchor _todo001685 (user): Experiment with x * x where constants = 0, x is fully encoded, and the domain is small. </dd> <dt> \_setscope operations_research::sat::ProductDetector Member \_internalref classoperations__research_1_1sat_1_1ProductDetector#ace823645f22af035730ca72f27174de9 "operations_research::sat::ProductDetector::InitializeBooleanRLTCuts" (const absl::flat_hash_map< IntegerVariable, glop::ColIndex > &lp_vars, const util_intops::StrongVector< IntegerVariable, double > &lp_values)</dt><dd> \anchor _todo001688 (user): limit work if too many ternary. \anchor _todo001689 (user): Maybe we shouldn't reconstruct this every time, but it is hard in case of multiple lps to make sure we don't use variables not in the lp otherwise. </dd> <dt> \_setscope operations_research::sat::ProductDetector Member \_internalref classoperations__research_1_1sat_1_1ProductDetector#a3a17220935c42077613be222734fef7a "operations_research::sat::ProductDetector::LinearizeProduct" (IntegerVariable a, IntegerVariable b)</dt><dd> \anchor _todo001698 (user): Implement! </dd> <dt> \_setscope operations_research::sat::ProductDetector Member \_internalref classoperations__research_1_1sat_1_1ProductDetector#af7fe2b019ee2556cd2b2813b34877945 "operations_research::sat::ProductDetector::ProcessBinaryClause" (absl::Span< const Literal > binary_clause)</dt><dd> \anchor _todo001686 (user): As product are discovered, we could remove entries from our hash maps! </dd> <dt> \_setscope operations_research::sat::ProductDetector Member \_internalref classoperations__research_1_1sat_1_1ProductDetector#a7473e11336cf79ccf7f4a54a890625fc "operations_research::sat::ProductDetector::ProcessConditionalEquality" (Literal l, IntegerVariable x, IntegerVariable y)</dt><dd> \anchor _todo001687 (user): Linear scan can be bad if b => X = many other variables. Hopefully this will not be common. \anchor _todo001697 (user): Generalize to a * X + b = l * (Y + c) since these are also easy to linearize if we see l * Y. </dd> <dt> \_setscope operations_research::sat::ProductDetector Member \_internalref classoperations__research_1_1sat_1_1ProductDetector#a308ee96e864c4e4fac744ac329ecac39 "operations_research::sat::ProductDetector::ProductLowerBound" (IntegerVariable a, IntegerVariable b)</dt><dd> \anchor _todo001699 (user): Implement! </dd> <dt> \_setscope operations_research::sat::ProductPropagator Member \_internalref classoperations__research_1_1sat_1_1ProductPropagator#a1a947c821f05a6e347602ffaa4162d1d "operations_research::sat::ProductPropagator::Propagate" () final</dt><dd> \anchor _todo001757 (user): In the reasons, including all 4 bounds is always correct, but we might be able to relax some of them. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#ad8873d5bb4db4affe6faa2da6553882a "operations_research::sat::PropagateAutomaton" (const AutomatonConstraintProto &proto, const PresolveContext &context, std::vector< absl::flat_hash_set< int64_t > > *states, std::vector< absl::flat_hash_set< int64_t > > *labels)</dt><dd> \anchor _todo001159 (user): Note that if we have duplicate variables controlling different time point, this might not reach the fixed point. Fix? it is not that important as the expansion take care of this case anyway. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#ad1ebf465eb7ccee4f79a5b8cfccfe7d9 "operations_research::sat::PropagateEncodingFromEquivalenceRelations" (const CpModelProto &model_proto, Model *m)</dt><dd> \anchor _todo001235 (user): This is not supposed to happen, but apparently it did on once on routing_GCM_0001_sat.fzn. Investigate and fix. \anchor _todo001236 (user): This is similar to LoadEquivalenceAC() for unreified constraints, but when the later is called, more encoding might have taken place. \anchor _todo001244 (user): In an ideal world, all affine relations like this should be removed in the presolve. </dd> <dt> \_setscope operations_research::sat::ProtoTrail Class \_internalref classoperations__research_1_1sat_1_1ProtoTrail "operations_research::sat::ProtoTrail" </dt><dd> \anchor _todo002436 (user): It'd be good to store an earlier level at which implications may be propagated. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a7bb3adbf30215f4aafac3f24caf00f84 "operations_research::sat::PseudoCost" (Model *model)</dt><dd> \anchor _todo001781 (user): This will be overridden by the value decision heuristic in almost all cases. </dd> <dt> \_setscope operations_research::sat::PseudoCosts Member \_internalref classoperations__research_1_1sat_1_1PseudoCosts#a21a08a0f912507d4cdcb1b9fea5e1297 "operations_research::sat::PseudoCosts::AfterTakingDecision" (bool conflict=false)</dt><dd> \anchor _todo002172 (user): tune that. \anchor _todo002173 (user): Handle this case. </dd> <dt> \_setscope operations_research::sat::PseudoCosts Member \_internalref classoperations__research_1_1sat_1_1PseudoCosts#a78be0e06d6c1f84281b45b79cb946d92 "operations_research::sat::PseudoCosts::GetBestDecisionVar" ()</dt><dd> \anchor _todo002174 (user): Supports search randomization tolerance. (user): Implement generic class to choose the randomized solution, and supports sub-linear variable selection. \anchor _todo002175 (user): Avoid the O(num_relevant_variable) loop. In practice since a variable only become relevant after 100 records, this list might be small compared to the number of variable though. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#ab37f2f037c1a414988b378b00ae80dcf "operations_research::sat::QuickSolveWithHint" (const CpModelProto &model_proto, Model *model)</dt><dd> \anchor _todo001504 (user): This is fixable, but then do we need the hint when optimizing with core? </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#ac2b9ed2c9fd55af7cfd4effe1ad5a5d6 "operations_research::sat::RandomizeOnRestartHeuristic" (bool lns_mode, Model *model)</dt><dd> \anchor _todo001794 (user): Add other policies and perform more experiments. \anchor _todo001795 (user): Do more experiments to find better distribution. \anchor _todo001796 (user): These distribution values are just guessed values. They need to be tuned. \anchor _todo001797 (user): Also use LP value as assignment like in Bop. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a774bb7b95d0309e6e4448b044b88c456 "operations_research::sat::RecordLPRelaxationValues" (Model *model)</dt><dd> \anchor _todo002177 (user): The default of ::infinity() for variable for which we do not have any LP solution is weird and inconsistent with ModelLpValues default which is zero. Fix. Note that in practice, at linearization level 2, all variable will eventually have an lp relaxation value, so it shoulnd't matter much to just use zero in RINS/RENS. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a4c7c0126948e1cf811fc9fe8519915e5 "operations_research::sat::ReduceNodes" (Coefficient upper_bound, Coefficient *lower_bound, std::vector< EncodingNode * > *nodes, SatSolver *solver)</dt><dd> \anchor _todo001658 (user): with DEFAULT_ASSUMPTION_ORDER, this will lead to a somewhat weird behavior, since we will reverse the nodes at each iteration... </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a08069ab2a59ea9cf0307873a9746b535 "operations_research::sat::ReduceNumberofBoxes" (std::vector< Rectangle > *mandatory_rectangles, std::vector< Rectangle > *optional_rectangles)</dt><dd> \anchor _todo001072 (user): improve</dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#ae9354f9bc95baa7e65765e065b38fefc "operations_research::sat::RegisterClausesLevelZeroImport" (int id, SharedClausesManager *shared_clauses_manager, Model *model)</dt><dd> \anchor _todo001493 (user): Can we import them in the core worker ? \anchor _todo001512 (user): Can we import them in the core worker ? </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#aceadbdc1d18fb949cc787a53e656d65a "operations_research::sat::RegisterVariableBoundsLevelZeroExport" (const CpModelProto &, SharedBoundsManager *shared_bounds_manager, Model *model)</dt><dd> \anchor _todo001491 (user): We could imagine an API based on atomic<int64_t> that could preemptively check if this new bounds are improving. \anchor _todo001492 (user): Find a better way? It seems nicer to register this before any variable is modified. But then we don't want to call it each time we reach level zero during probing. It should be better to only call it when a new variable has been fixed. </dd> <dt> \_setscope operations_research::sat::RelaxationInducedNeighborhoodGenerator Member \_internalref classoperations__research_1_1sat_1_1RelaxationInducedNeighborhoodGenerator#aa4724e62d610d139a8ae7197f1004823 "operations_research::sat::RelaxationInducedNeighborhoodGenerator::Generate" (const CpSolverResponse &initial_solution, double difficulty, absl::BitGenRef random) final</dt><dd> \anchor _todo001209 (user): Instead of aborting, pick the closest point in the domain? </dd> <dt> \_setscope operations_research::sat::RelaxRandomConstraintsGenerator Class \_internalref classoperations__research_1_1sat_1_1RelaxRandomConstraintsGenerator "operations_research::sat::RelaxRandomConstraintsGenerator" </dt><dd> \anchor _todo001216 (user): In the presence of connected components, this should just work on one of them. </dd> <dt> \_setscope operations_research::sat::RelaxRandomConstraintsGenerator Member \_internalref classoperations__research_1_1sat_1_1RelaxRandomConstraintsGenerator#a3e22fc48cf6041968e6f6119e642cf64 "operations_research::sat::RelaxRandomConstraintsGenerator::Generate" (const CpSolverResponse &initial_solution, double difficulty, absl::BitGenRef random) final</dt><dd> \anchor _todo001204 (user): Clean-up when target_size == 0. \anchor _todo001205 (user): randomize order of variable addition when close to the limit. </dd> <dt> \_setscope operations_research::sat::RelaxRandomVariablesGenerator Class \_internalref classoperations__research_1_1sat_1_1RelaxRandomVariablesGenerator "operations_research::sat::RelaxRandomVariablesGenerator" </dt><dd> \anchor _todo001215 (user): In the presence of connected components, this should just work on one of them. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a89dc2fa5d4896cd17270cf7d40099e08 "operations_research::sat::ReportEnergyConflict" (Rectangle bounding_box, absl::Span< const int > boxes, SchedulingConstraintHelper *x, SchedulingConstraintHelper *y)</dt><dd> \anchor _todo001624 (user): Also relax the box if possible. \anchor _todo001626 (user): relax the bounding box dimension to have a relaxed explanation. We can also minimize the number of required intervals. </dd> <dt> \_setscope operations_research::sat::RestartPolicy Member \_internalref classoperations__research_1_1sat_1_1RestartPolicy#a52594750ea119a9ac928e3f09b77f140 "operations_research::sat::RestartPolicy::Reset" ()</dt><dd> \anchor _todo002176 (user): for some reason, strategies_.assign() does not work as the returned type of the proto enum iterator is int ?! </dd> <dt> \_setscope operations_research::sat::RoundingOptions Struct \_internalref structoperations__research_1_1sat_1_1RoundingOptions "operations_research::sat::RoundingOptions" </dt><dd> \anchor _todo001608 (user): There is a bunch of heuristic involved here, and we could spend more effort tuning them. In particular, one can try many heuristics and keep the best looking cut (or more than one). This is not on the critical code path, so we can spend more effort in finding good cuts. </dd> <dt> \_setscope operations_research::sat::SatDecisionPolicy Member \_internalref classoperations__research_1_1sat_1_1SatDecisionPolicy#a118a1b216d1e79a4b9c250f3030adda7 "operations_research::sat::SatDecisionPolicy::AllPreferences" () const</dt><dd> \anchor _todo002199 (user): we currently assume that if the tie_breaker is zero then no preference was set (which is not 100% correct). Fix that. </dd> <dt> \_setscope operations_research::sat::SatDecisionPolicy Member \_internalref classoperations__research_1_1sat_1_1SatDecisionPolicy#ad02a374fc46af7a8ed8112257438dbc1 "operations_research::sat::SatDecisionPolicy::NextBranch" ()</dt><dd> \anchor _todo002200 (user): This may not be super efficient if almost all the variables are assigned. </dd> <dt> \_setscope operations_research::sat::SatDecisionPolicy Member \_internalref classoperations__research_1_1sat_1_1SatDecisionPolicy#a9f05bb03afa86725c194d50e613f2593 "operations_research::sat::SatDecisionPolicy::Untrail" (int target_trail_index)</dt><dd> \anchor _todo002201 (user): avoid looping twice over the trail? \anchor _todo002202 (user): Expose parameters for these values. \anchor _todo002203 (user): This heuristic can make this code quite slow because all the untrailed variable will cause a priority queue update. </dd> <dt> \_setscope operations_research::sat::SatPostsolver Member \_internalref classoperations__research_1_1sat_1_1SatPostsolver#a3336b2762049c2d81e2bd255e9c9ecc8 "operations_research::sat::SatPostsolver::Clause" (int i) const</dt><dd> \anchor _todo002346 (user): we could avoid the copy here, but because clauses_literals_ is a deque, we do need a special return class and cannot juste use absl::Span<Literal> for instance. </dd> <dt> \_setscope operations_research::sat::SatPostsolver Member \_internalref classoperations__research_1_1sat_1_1SatPostsolver#ad351af493e5b70fc12534bc0806cc444 "operations_research::sat::SatPostsolver::FixVariable" (Literal x)</dt><dd> \anchor _todo002345 (user): this as almost the same effect as adding an unit clause, and we should probably remove this to simplify the code. </dd> <dt> \_setscope operations_research::sat::SatPresolveOptions Member \_internalref structoperations__research_1_1sat_1_1SatPresolveOptions#a99051170412df0832ce84112ddd314c0 "operations_research::sat::SatPresolveOptions::use_transitive_reduction" </dt><dd> \anchor _todo002265 (user): Doing that before the current SAT presolve also change the possible reduction. This shouldn't matter if we use the binary implication graph and its reachability instead of just binary clause though. </dd> <dt> \_setscope operations_research::sat::SatPresolver Class \_internalref classoperations__research_1_1sat_1_1SatPresolver "operations_research::sat::SatPresolver" </dt><dd> \anchor _todo002342 (user): Interact more with a SAT solver to reuse its propagation logic. \anchor _todo002343 (user): Forbid the removal of some variables. This way we can presolve only the clause part of a general Boolean problem by not removing variables appearing in pseudo-Boolean constraints. </dd> <dt> \_setscope operations_research::sat::SatPresolver Member \_internalref classoperations__research_1_1sat_1_1SatPresolver#a670988de72965600bed15b192faa433a "operations_research::sat::SatPresolver::ClauseIndex" </dt><dd> \anchor _todo002347 (user): use IntType! </dd> <dt> \_setscope operations_research::sat::SatPresolver Member \_internalref classoperations__research_1_1sat_1_1SatPresolver#a4b58b71a43c02cbec8fefb126f0a61cb "operations_research::sat::SatPresolver::CrossProduct" (Literal x)</dt><dd> \anchor _todo002336 (user): Choose if we use x or x.Negated() depending on the list sizes? The function achieve the same if x = x.Negated(), however the loops are not done in the same order which may change this incomplete "blocked" clause detection. \anchor _todo002337 (user): We could only update the priority queue once for each variable instead of doing it many times. \anchor _todo002338 (user): At this point x.Variable() is added back to the priority queue. Avoid doing that. </dd> <dt> \_setscope operations_research::sat::SatPresolver Member \_internalref classoperations__research_1_1sat_1_1SatPresolver#adb7846ae7bbe4ca2e07a1dba94fe686e "operations_research::sat::SatPresolver::Presolve" (const std::vector< bool > &var_that_can_be_removed)</dt><dd> \anchor _todo002325 (user): When a clause is strengthened, add it to a queue so it can be processed again? </dd> <dt> \_setscope operations_research::sat::SatPresolver Member \_internalref classoperations__research_1_1sat_1_1SatPresolver#a32df98e6426d1e7a18247a18207717f1 "operations_research::sat::SatPresolver::Presolve" ()</dt><dd> \anchor _todo002348 (user): Add support for a time limit and some kind of iterations limit so that this can never take too much time. </dd> <dt> \_setscope operations_research::sat::SatPresolver Member \_internalref classoperations__research_1_1sat_1_1SatPresolver#af7e0881274e8e8cec31c85429900b42a "operations_research::sat::SatPresolver::PresolveWithBva" ()</dt><dd> \anchor _todo002326 (user): Put work limit in place ! </dd> <dt> \_setscope operations_research::sat::SatPresolver Member \_internalref classoperations__research_1_1sat_1_1SatPresolver#a8d8418b2601e61829de5e7b3f4df122b "operations_research::sat::SatPresolver::ProcessClauseToSimplifyOthers" (ClauseIndex clause_index)</dt><dd> \anchor _todo002333 (user): Binary clauses are really common, and we can probably do this more efficiently for them. For instance, we could just take the intersection of two sorted lists to get the simplified clauses. \anchor _todo002334 (user): not super optimal since we could abort earlier if opposite_literal is not the negation of shortest_list. Note that this applies to the second call to ProcessClauseToSimplifyOthersUsingLiteral() above too. \anchor _todo002335 (user): remove the old clauses_[ci] afterwards. </dd> <dt> \_setscope operations_research::sat::SatPropagator Member \_internalref classoperations__research_1_1sat_1_1SatPropagator#a2bde4f8c3d7c6326050ac164391bf2a7 "operations_research::sat::SatPropagator::PropagatePreconditionsAreSatisfied" (const Trail &trail) const</dt><dd> \anchor _todo002190 (user): A few of these method should be moved in a .cc </dd> <dt> \_setscope operations_research::sat::SatPropagator Member \_internalref classoperations__research_1_1sat_1_1SatPropagator#a5f04df27e81298743cf658683344b0a0 "operations_research::sat::SatPropagator::Untrail" (const Trail &, int trail_index)</dt><dd> \anchor _todo002196 (user): Currently this is called at each Backtrack(), but we could bundle the calls in case multiple conflict one after the other are detected even before the Propagate() call of a SatPropagator is called. \anchor _todo002197 (user): It is not yet 100% the case, but this can be guaranteed to be called with a trail index that will always be the start of a new decision level. </dd> <dt> \_setscope operations_research::sat::SatSolver Member \_internalref classoperations__research_1_1sat_1_1SatSolver#a8b9ba983bd9f911d0605f7615ebf3725 "operations_research::sat::SatSolver::AddClauseDuringSearch" (absl::Span< const Literal > literals)</dt><dd> \anchor _todo002270 (user): We generate in some corner cases clauses with literals[0].Variable() == literals[1].Variable(). Avoid doing that and adding such binary clauses to the graph? \anchor _todo002313 (user): Backjump and propagate on a falsified clause? this is currently not needed. </dd> <dt> \_setscope operations_research::sat::SatSolver Member \_internalref classoperations__research_1_1sat_1_1SatSolver#a098038f8e0409a8243ff3f7eafb517f8 "operations_research::sat::SatSolver::AddLinearConstraint" (bool use_lower_bound, Coefficient lower_bound, bool use_upper_bound, Coefficient upper_bound, std::vector< LiteralWithCoeff > *cst)</dt><dd> \anchor _todo002309 (user): Instead of failing, implement an error handling code. </dd> <dt> \_setscope operations_research::sat::SatSolver Member \_internalref classoperations__research_1_1sat_1_1SatSolver#a2613df5393b4e2285789856150543b70 "operations_research::sat::SatSolver::AddProblemClause" (absl::Span< const Literal > literals, bool is_safe=true)</dt><dd> \anchor _todo002308 (user): Rename this to AddClause(), also get rid of the specialized AddUnitClause(), AddBinaryClause() and AddTernaryClause() since they just end up calling this? </dd> <dt> \_setscope operations_research::sat::SatSolver Member \_internalref classoperations__research_1_1sat_1_1SatSolver#a7c0c2912da716e49c8b5d84108e463d7 "operations_research::sat::SatSolver::Backtrack" (int target_level)</dt><dd> \anchor _todo002280 (user): The backtrack method should not be called when the model is unsat. Add a DCHECK to prevent that, but before fix the bop::BopOptimizerBase architecture. </dd> <dt> \_setscope operations_research::sat::SatSolver Member \_internalref classoperations__research_1_1sat_1_1SatSolver#a1ac88207c0228d80d19751186955240f "operations_research::sat::SatSolver::deterministic_time" () const</dt><dd> \anchor _todo002269 (user): Find a better procedure to fix the weight than just educated guess. </dd> <dt> \_setscope operations_research::sat::SatSolver Member \_internalref classoperations__research_1_1sat_1_1SatSolver#a0174fd7221118d81a925d32aaed1cc79 "operations_research::sat::SatSolver::ExtractClauses" (Output *out)</dt><dd> \anchor _todo002312 (user): also copy the removable clauses? </dd> <dt> \_setscope operations_research::sat::SatSolver Member \_internalref classoperations__research_1_1sat_1_1SatSolver#ad4458486171153c1793c28e2091140d9 "operations_research::sat::SatSolver::FinishPropagation" ()</dt><dd> \anchor _todo002274 (user): Exiting like this might cause issue since the propagation is not "finished" but some code might assume it is. However since we already might repropagate in the LP constraint, most of the code should support "not finished propagation". </dd> <dt> \_setscope operations_research::sat::SatSolver Member \_internalref classoperations__research_1_1sat_1_1SatSolver#a84e27e6cb848b3176ab5680292d116a8 "operations_research::sat::SatSolver::IsModelUnsat" () const</dt><dd> \anchor _todo002310 (user): remove this function. </dd> <dt> \_setscope operations_research::sat::SatSolver Member \_internalref classoperations__research_1_1sat_1_1SatSolver#a5420a6d871314779beeac0c074241c1a "operations_research::sat::SatSolver::model" ()</dt><dd> \anchor _todo002306 (user): Remove. This is temporary for accessing the model deep within some old code that didn't use the Model object. </dd> <dt> \_setscope operations_research::sat::SatSolver Member \_internalref classoperations__research_1_1sat_1_1SatSolver#a3afed23ec8289b170f0a25ec4b10dd84 "operations_research::sat::SatSolver::ProcessCurrentConflict" ()</dt><dd> \anchor _todo002275 (user): We might still want to "learn" the clause, especially if it reduces to only one literal in which case we can just fix it. \anchor _todo002276 (user): Note that we use the clause above to update the variable activities and not the pb conflict. Experiment. \anchor _todo002277 (user): This is error prone, find a better way? \anchor _todo002278 (user): It is unclear what the best heuristic is here. Both the current trail index or the trail before the current decision perform well, but using the full trail seems slightly better even though it will contain the current conflicting literal. \anchor _todo002279 (user): Either remove that algorithm or support subsumption by just checking if it is okay to do so, or doing it on the fly while computing the first UIP. </dd> <dt> \_setscope operations_research::sat::SatSolver Member \_internalref classoperations__research_1_1sat_1_1SatSolver#a9188c70cc1096900a623a26319a1d4b8 "operations_research::sat::SatSolver::Propagate" ()</dt><dd> \anchor _todo002290 (user): Support propagating only the "first" propagators. That can be useful for probing/in-processing, so we can control if we do only the SAT part or the full integer part... \anchor _todo002291 (user): This might not really be needed. </dd> <dt> \_setscope operations_research::sat::SatSolver Member \_internalref classoperations__research_1_1sat_1_1SatSolver#a50484f243bcc0ec12ed3919d84dc38ad "operations_research::sat::SatSolver::SetAssignmentPreference" (Literal literal, float weight)</dt><dd> \anchor _todo002311 (user): Clean this up by making clients directly talk to SatDecisionPolicy. </dd> <dt> \_setscope operations_research::sat::SatSolver Member \_internalref classoperations__research_1_1sat_1_1SatSolver#ae8f40548efeb9f6bde6ff1cd872acc38 "operations_research::sat::SatSolver::SetNumVariables" (int num_variables)</dt><dd> \anchor _todo002307 (user): Rename to IncreaseNumVariablesTo() until we support removing variables... </dd> <dt> \_setscope operations_research::sat::SavedVariable Class \_internalref classoperations__research_1_1sat_1_1SavedVariable "operations_research::sat::SavedVariable" </dt><dd> \anchor _todo002138 (user): get rid of this, we don't have the notion of equivalent variable anymore, but the more general affine relation one. We just need to support general affine for the linear1 involving an absolute value. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#ad6d384c7c56f3027894875278e4b9526 "operations_research::sat::ScaleContinuousVariables" (double scaling, double max_bound, MPModelProto *mp_model)</dt><dd> \anchor _todo001997 (user): Also scale the solution hint if any. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#ab5275984bb2d64275b69e881316b7f34 "operations_research::sat::ScanModelForDominanceDetection" (PresolveContext &context, VarDomination *var_domination)</dt><dd> \anchor _todo002418 (user): Maybe we should avoid recomputing that here. \anchor _todo002419 (user): Handle enforcement better here. \anchor _todo002420 (user): the way we process that is a bit restrictive. By working on the implication graph we could detect more dominance relations. Since if a => b we say that a++ can only be paired with b–, but it could actually be paired with any variables that when dereased implies b = 0. This is a bit mitigated by the fact that we regroup when we can such implications into big at most ones. \anchor _todo002421 (user): We might be able to detect that nothing can be done earlier during the constraint scanning. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a7b440ecab00a601d5643f21df87c7cc6 "operations_research::sat::ScanModelForDualBoundStrengthening" (const PresolveContext &context, DualBoundStrengthening *dual_bound_strengthening)</dt><dd> \anchor _todo002422 (user): Maybe we should avoid recomputing that here. \anchor _todo002423 (user): Handle enforcement better here. </dd> <dt> \_setscope operations_research::sat::ScatteredIntegerVector Member \_internalref classoperations__research_1_1sat_1_1ScatteredIntegerVector#a5d028844e2ffb568bbc68185f7cb6260 "operations_research::sat::ScatteredIntegerVector::ConvertToLinearConstraint" (absl::Span< const IntegerVariable > integer_variables, IntegerValue upper_bound, std::optional< std::pair< IntegerVariable, IntegerValue > > extra_term=std::nullopt)</dt><dd> \anchor _todo001930 (user): Ideally we should convert to IntegerVariable as late as possible. Prefer to use GetTerms(). </dd> <dt> \_setscope operations_research::sat::SccGraph Member \_internalref classoperations__research_1_1sat_1_1SccGraph#aee95126bcb16bb7a70ab00218a15fd7f "operations_research::sat::SccGraph::operator[]" (int32_t node) const</dt><dd> \anchor _todo001123 (user): avoid looping more than twice on the same at most one constraints? Note that the second time we loop we have x => y => not(x), so we can already detect that x must be false which we detect below. </dd> <dt> \_setscope operations_research::sat::SchedulingConstraintHelper Member \_internalref classoperations__research_1_1sat_1_1SchedulingConstraintHelper#acbf45814a5a4f7554173a02e61970fa8 "operations_research::sat::SchedulingConstraintHelper::GetCurrentMinDistanceBetweenTasks" (int a, int b, bool add_reason_if_after=false)</dt><dd> \anchor _todo001817 (user): be more precise when we know a and b are in disjunction. we really just need start_b > start_a, or even >= if duration is non-zero. </dd> <dt> \_setscope operations_research::sat::SchedulingConstraintHelper Member \_internalref classoperations__research_1_1sat_1_1SchedulingConstraintHelper#a648ff007cfc81bd0a4369701a7048a27 "operations_research::sat::SchedulingConstraintHelper::GetEnergyProfile" ()</dt><dd> \anchor _todo001819 (user): Avoid recomputing it if nothing changed. </dd> <dt> \_setscope operations_research::sat::SchedulingConstraintHelper Member \_internalref classoperations__research_1_1sat_1_1SchedulingConstraintHelper#a98e816cae622855fe8eae0766b4e0aaf "operations_research::sat::SchedulingConstraintHelper::InPropagationLoop" () const</dt><dd> \anchor _todo001826 (user): Change the propagation loop code so that we don't stop pushing in the middle of the propagation as more advanced propagator do not handle this correctly. </dd> <dt> \_setscope operations_research::sat::SchedulingConstraintHelper Member \_internalref classoperations__research_1_1sat_1_1SchedulingConstraintHelper#a4f2023a21c5e1475e6468be2147b6e14 "operations_research::sat::SchedulingConstraintHelper::PropagatePrecedence" (int a, int b)</dt><dd> \anchor _todo001818 (user): Adding new constraint during propagation might not be the best idea as it can create some complication. </dd> <dt> \_setscope operations_research::sat::SchedulingConstraintHelper Member \_internalref classoperations__research_1_1sat_1_1SchedulingConstraintHelper#a230beffeb33f166d27bc233bed77237a "operations_research::sat::SchedulingConstraintHelper::SchedulingConstraintHelper" (int num_tasks, Model *model)</dt><dd> \anchor _todo001824 (user): Remove this. It is a hack because the disjunctive class needs to fetch the maximum possible number of task at construction. </dd> <dt> \_setscope operations_research::sat::SchedulingConstraintHelper Member \_internalref classoperations__research_1_1sat_1_1SchedulingConstraintHelper#a0829ed1b078db163e11c4114f71758c3 "operations_research::sat::SchedulingConstraintHelper::TaskByIncreasingStartMin" ()</dt><dd> \anchor _todo001825 (user): we could merge the first loop of IncrementalSort() with the loop that fill TaskTime.time at each call. </dd> <dt> \_setscope operations_research::sat::SchedulingDemandHelper Class \_internalref classoperations__research_1_1sat_1_1SchedulingDemandHelper "operations_research::sat::SchedulingDemandHelper" </dt><dd> \anchor _todo001823 (user): Cache energy min and reason for the non O(1) cases. </dd> <dt> \_setscope operations_research::sat::SchedulingDemandHelper Member \_internalref classoperations__research_1_1sat_1_1SchedulingDemandHelper#a8b7226d12b17723e0174250fd2024f46 "operations_research::sat::SchedulingDemandHelper::AddEnergyMinInWindowReason" (int t, IntegerValue window_start, IntegerValue window_end)</dt><dd> \anchor _todo001821 (user): only include the one we need? </dd> <dt> \_setscope operations_research::sat::SchedulingDemandHelper Member \_internalref classoperations__research_1_1sat_1_1SchedulingDemandHelper#a9019a263126e78ddf332f696649fda87 "operations_research::sat::SchedulingDemandHelper::CacheAllEnergyValues" ()</dt><dd> \anchor _todo001828 (user): this is error prone, maybe we should revisit. But if there is many alternatives, we don't want to rescan the list more than a linear number of time per propagation. \anchor _todo001829 (user): Add more complex EnergyMinBefore(time) once we also support expressing the interval as a set of alternatives.</dd> <dt> \_setscope operations_research::sat::SchedulingDemandHelper Member \_internalref classoperations__research_1_1sat_1_1SchedulingDemandHelper#ad690f09e6894f8f9e9b01642fa1fc822 "operations_research::sat::SchedulingDemandHelper::DecreaseEnergyMax" (int t, IntegerValue value)</dt><dd> \anchor _todo001820 (user): Propagate if possible. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a85b41013bb2f7709a99765d5c491f381 "operations_research::sat::SchedulingSearchHeuristic" (Model *model)</dt><dd> \anchor _todo001782 (user): we should also precompute fixed precedences and only fix interval that have all their predecessors fixed. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#ab771e6d4ef64d782505e2abdc6c0dbe3 "operations_research::sat::SeparateFlowInequalities" (int num_nodes, absl::Span< const int > tails, absl::Span< const int > heads, absl::Span< const AffineExpression > arc_capacities, std::function< void(const std::vector< bool > &in_subset, IntegerValue *min_incoming_flow, IntegerValue *min_outgoing_flow)> get_flows, const util_intops::StrongVector< IntegerVariable, double > &lp_values, LinearConstraintManager *manager, Model *model)</dt><dd> \anchor _todo002181 (user): Alternatively, try MIR heuristics if the coefficients in the capacities are not all the same. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a2b655336dd6b108cddff7ff5e87360d3 "operations_research::sat::SeparateSubtourInequalities" (int num_nodes, const std::vector< int > &tails, const std::vector< int > &heads, const std::vector< Literal > &literals, absl::Span< const int64_t > demands, int64_t capacity, LinearConstraintManager *manager, Model *model)</dt><dd> \anchor _todo002179 (user): Currently if we add too many not so relevant cuts, our generic MIP cut heuritic are way too slow on TSP/VRP problems. \anchor _todo002180 (user): I had an older version that tried the n-cuts generated during the course of the algorithm. This could also be interesting. But it is hard to tell with our current benchmark setup. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a4accab74442b986ddcc870636b232756 "operations_research::sat::SequentialValueSelection" (std::vector< std::function< IntegerLiteral(IntegerVariable)> > value_selection_heuristics, std::function< BooleanOrIntegerLiteral()> var_selection_heuristic, Model *model)</dt><dd> \anchor _todo001778 (user): we will likely stop at the first non-fixed variable. </dd> <dt> \_setscope operations_research::sat::SharedBoundsManager Member \_internalref classoperations__research_1_1sat_1_1SharedBoundsManager#aa52efbe166740ce4b1f22c820a64ffc6 "operations_research::sat::SharedBoundsManager::FixVariablesFromPartialSolution" (const std::vector< int64_t > &solution, const std::vector< int > &variables_to_fix)</dt><dd> \anchor _todo002365 (user): Because we look at the non-synchronized and up to date bounds, this break determinism if two solution for the same subpart comes at the same time. </dd> <dt> \_setscope operations_research::sat::SharedClausesManager Member \_internalref classoperations__research_1_1sat_1_1SharedClausesManager#a3ebbcf2be803ef7f2cbad87a044dc4ec "operations_research::sat::SharedClausesManager::Synchronize" ()</dt><dd> \anchor _todo002366 (user): We could cleanup binary clauses that have been consumed. </dd> <dt> \_setscope operations_research::sat::SharedResponseManager Member \_internalref classoperations__research_1_1sat_1_1SharedResponseManager#adbf9c545bd1e91d71d36638ca7c1acfd "operations_research::sat::SharedResponseManager::NewSolution" (absl::Span< const int64_t > solution_values, const std::string &solution_info, Model *model=nullptr)</dt><dd> \anchor _todo002364 (user): Remove this code and the need for model in this function. Use search log callbacks instead. </dd> <dt> \_setscope operations_research::sat::SharedResponseManager Member \_internalref classoperations__research_1_1sat_1_1SharedResponseManager#af4876e4857461716fabf61e3df652bd6 "operations_research::sat::SharedResponseManager::UpdateInnerObjectiveBounds" (const std::string &update_info, IntegerValue lb, IntegerValue ub)</dt><dd> \anchor _todo002362 (user): A thread might not be notified right away that the new bounds that it is pushing make the problem infeasible. Fix that. For now we just abort early here to avoid logging the "#Done" message multiple times. </dd> <dt> \_setscope operations_research::sat::SharedSolutionRepository Class \_internalref classoperations__research_1_1sat_1_1SharedSolutionRepository "operations_research::sat::SharedSolutionRepository< ValueType >" </dt><dd> \anchor _todo002367 (user): Maybe add some criteria to only keep solution with an objective really close to the best solution. </dd> <dt> \_setscope operations_research::sat::SharedSolutionRepository Member \_internalref classoperations__research_1_1sat_1_1SharedSolutionRepository#a5c764f4976d30e6f103b76a929402c87 "operations_research::sat::SharedSolutionRepository< ValueType >::GetRandomBiasedSolution" (absl::BitGenRef random) const</dt><dd> \anchor _todo002368 (user): Experiments on the best distribution. </dd> <dt> \_setscope operations_research::sat::SharedSolutionRepository::Solution Member \_internalref structoperations__research_1_1sat_1_1SharedSolutionRepository_1_1Solution#a1e89b8e75d0f5d4196f9cc06abbfa689 "operations_research::sat::SharedSolutionRepository< ValueType >::Solution::rank" </dt><dd> \anchor _todo002370 (user): Some LNS code assume that for the SharedSolutionRepository this rank is actually the unscaled internal minimization objective. Remove this assumptions by simply recomputing this value since it is not too costly to do so. </dd> <dt> \_setscope operations_research::sat::SharedSolutionRepository Member \_internalref classoperations__research_1_1sat_1_1SharedSolutionRepository#a902c7f2bb1e91b85d85bad84726bf89b "operations_research::sat::SharedSolutionRepository< ValueType >::Synchronize" ()</dt><dd> \anchor _todo002369 (user): Introduce a notion of orthogonality to diversify the pool? </dd> <dt> \_setscope operations_research::sat::SharedTreeManager Member \_internalref classoperations__research_1_1sat_1_1SharedTreeManager#a98c561c89b5bc43b4aa0debbcef4200e "operations_research::sat::SharedTreeManager::ProposeSplit" (ProtoTrail &path, ProtoLiteral decision)</dt><dd> \anchor _todo002433 (user): Need to write up the shape this creates. This rule will allow twice as many leaves in the preferred subtree. </dd> <dt> \_setscope operations_research::sat::SharedTreeManager Member \_internalref classoperations__research_1_1sat_1_1SharedTreeManager#aa6d71bb864a47eaeb3edb91b97819686 "operations_research::sat::SharedTreeManager::ReplaceTree" (ProtoTrail &path)</dt><dd> \anchor _todo002434 (user): Investigate assigning a random leaf so workers can still improve shared tree bounds. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a4bfc95b7fb811709c6763963bee970a4 "operations_research::sat::ShaveObjectiveLb" (Model *model)</dt><dd> \anchor _todo001780 (user): Do we need a mechanism to reduce the range of possible gaps when nothing gets proven? This could be a parameter or some adaptative code. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a0479a7ca6dd22cbabccdf623aea07315 "operations_research::sat::SimplifyCanonicalBooleanLinearConstraint" (std::vector< LiteralWithCoeff > *cst, Coefficient *rhs)</dt><dd> \anchor _todo002048 (user): Use more complex simplification like dividing by the gcd of everyone and using less different coefficients if possible. \anchor _todo002049 (user): It is probably better to remove these literals and have other constraint setting them to false from the symmetry finder perspective. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#ab649ca11fd81e049dc7a8c0dd1104b5b "operations_research::sat::SimplifyClause" (const std::vector< Literal > &a, std::vector< Literal > *b, LiteralIndex *opposite_literal, int64_t *num_inspected_literals)</dt><dd> \anchor _todo002344 (user): when a.size() << b.size(), we should use binary search instead of scanning b linearly. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a336d2faa10d80d646232f5e6d91891d4 "operations_research::sat::SolutionIsFeasible" (const CpModelProto &model, absl::Span< const int64_t > variable_values, const CpModelProto *mapping_proto, const std::vector< int > *postsolve_mapping)</dt><dd> \anchor _todo001156 (user): This is not really a "feasibility" question, but we should probably check that the response objective matches with the one we can compute here. This might better be done in another function though. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a9d67b9c66f1cb9c1dcc3415cd5af11bf "operations_research::sat::SolveCpModel" (const CpModelProto &model_proto, Model *model)</dt><dd> \anchor _todo001459 (user): We currently reuse the MODEL_INVALID status even though it is not the best name for this. Maybe we can add a PARAMETERS_INVALID when it become needed. Or rename to INVALID_INPUT ? \anchor _todo001460 (user): provide an option to skip this step for speed? \anchor _todo001461 (user): Change status to IMPRECISE? \anchor _todo001462 (user): reduce this function size and find a better place for this? \anchor _todo001463 (user): We could try to dump our linear relaxation too. \anchor _todo001464 (user): Even for an optimization, if we load the solution right away, we might not have the same behavior as the initial search that follow the hint will be infeasible, so the activities of the variables will be different. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a43a3828d1897a92ece5fd4f6018fe3da "operations_research::sat::SolveDiophantine" (absl::Span< const int64_t > coeffs, int64_t rhs, absl::Span< const int64_t > var_lbs, absl::Span< const int64_t > var_ubs)</dt><dd> \anchor _todo001628 (user): look if there is a natural improvement. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#aa4dae45317363a09e5f5f5ac22394f74 "operations_research::sat::SolveFzWithCpModelProto" (const fz::Model &fz_model, const fz::FlatzincSatParameters &p, const std::string &sat_params, SolverLogger *logger, SolverLogger *solution_logger)</dt><dd> \anchor _todo000417 (user): Supports setting the number of workers to 0, which will then query the number of cores available. This is complex now as we need to still support the expected behabior (no flags -> 1 thread fixed search, -f -> 1 thread free search). </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a11198d99e855837fa730eb6a5097a801 "operations_research::sat::SolveLoadedCpModel" (const CpModelProto &model_proto, Model *model)</dt><dd> \anchor _todo001500 (user): This should be transformed so that it can be called many times and resume from the last search state as if it wasn't interrupted. That would allow use to easily interleave different heuristics in the same thread. \anchor _todo001501 (user): This doesn't work with splitting in chunk for now. It shouldn't be too hard to fix. \anchor _todo001502 (user): This parameter breaks the splitting in chunk of a Solve(). It should probably be moved into another SubSolver altogether. \anchor _todo001503 (user): Remove the weird translation INFEASIBLE->FEASIBLE in the function above? \anchor _todo001511 (user): This should be transformed so that it can be called many times and resume from the last search state as if it wasn't interrupted. That would allow use to easily interleave different heuristics in the same thread. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a2af162f5376a8d8234b9287b5c8163c1 "operations_research::sat::SplitAndLoadIntermediateConstraints" (bool lb_required, bool ub_required, std::vector< IntegerVariable > *vars, std::vector< int64_t > *coeffs, Model *m)</dt><dd> \anchor _todo001238 (user): We could use a smarter way to determine buckets, like putting everyone with the same coeff together if possible and the split is ok. \anchor _todo001245 (user): Alternatively, we could use a O(num_changes) propagation (a bit tricky to implement), or a decomposition into a tree with more than one level. Both requires experimentations. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a5154a61154ff9b3522e0c0eba7ed0319 "operations_research::sat::SplitAroundLpValue" (IntegerVariable var, Model *model)</dt><dd> \anchor _todo001771 (user): Depending if we branch up or down, this might not exclude the LP value, which is potentially a bad thing. \anchor _todo001772 (user): Why is the reduced cost doing things differently? </dd> <dt> \_setscope operations_research::sat::SquarePropagator Class \_internalref classoperations__research_1_1sat_1_1SquarePropagator "operations_research::sat::SquarePropagator" </dt><dd> \anchor _todo001765 (user): Only works for x nonnegative. </dd> <dt> \_setscope operations_research::sat::StampingSimplifier Member \_internalref classoperations__research_1_1sat_1_1StampingSimplifier#a2e92cf06868589083c5369b049fc5a26 "operations_research::sat::StampingSimplifier::ComputeStampsForNextRound" (bool log_info)</dt><dd> \anchor _todo002232 (user): compute some dtime, it is always zero currently. </dd> <dt> \_setscope operations_research::sat::StampingSimplifier Member \_internalref classoperations__research_1_1sat_1_1StampingSimplifier#abf4ca83561578670ef702769097d29fd "operations_research::sat::StampingSimplifier::DoOneRound" (bool log_info)</dt><dd> \anchor _todo002231 (user): We could probably deal with it if needed so that we don't need to do equivalence detection each time we want to run this. \anchor _todo002267 (user): To save one scan over all the clauses, we could do the fixed and equivalence variable cleaning here too. </dd> <dt> \_setscope operations_research::sat::StampingSimplifier Member \_internalref classoperations__research_1_1sat_1_1StampingSimplifier#adeaa7bc64c667a667195ba5f6161f8c1 "operations_research::sat::StampingSimplifier::ProcessClauses" ()</dt><dd> \anchor _todo002236 below. \anchor _todo002237 (user): Note that it is okay to still use top_entry, but we might miss the removal of b if b => c. Also the paper do things differently. Make sure we don't miss any simplification opportunites by not changing top_entry. Same in the other branches. </dd> <dt> \_setscope operations_research::sat::StampingSimplifier Member \_internalref classoperations__research_1_1sat_1_1StampingSimplifier#ab4ed798d7a5c1b5957e4f9605963174e "operations_research::sat::StampingSimplifier::SampleTreeAndFillParent" ()</dt><dd> \anchor _todo002233 (user): Better algo to not select redundant parent. \anchor _todo002234 (user): if parents_[x] = y, try not to have parents_[not(y)] = not(x) because this is not as useful for the simplification power. \anchor _todo002235 (user): More generally, we could sample a parent while probing so that we consider all hyper binary implications (in the case we don't add them to the implication graph already). </dd> <dt> \_setscope operations_research::sat::SubSolver Member \_internalref classoperations__research_1_1sat_1_1SubSolver#a4edf090e6f497b612dab8bfc4b53cd4c "operations_research::sat::SubSolver::DeterministicTimingInfo" () const</dt><dd> \anchor _todo002352 (user): remove trailing "
" from ValueAsString(). </dd> <dt> \_setscope operations_research::sat::SubSolver Member \_internalref classoperations__research_1_1sat_1_1SubSolver#a68765bc7ed07ce93ffeddbe61ad40d65 "operations_research::sat::SubSolver::GenerateTask" (int64_t task_id)=0</dt><dd> \anchor _todo002350 (user): We could use a more complex selection logic and pass in the deterministic time limit this subtask should run for. Unclear at this stage.</dd> <dt> \_setscope operations_research::sat::SubSolver Member \_internalref classoperations__research_1_1sat_1_1SubSolver#a03147f5723fa17d3ce80ace93578af57 "operations_research::sat::SubSolver::TimingInfo" () const</dt><dd> \anchor _todo002351 (user): remove trailing "
" from ValueAsString() or just build the table line directly. </dd> <dt> \_setscope operations_research::sat::SymmetryPropagator Class \_internalref classoperations__research_1_1sat_1_1SymmetryPropagator "operations_research::sat::SymmetryPropagator" </dt><dd> \anchor _todo002354 (user): Implement the optimizations mentioned in the paper? (user): Instrument and see if the code can be optimized. </dd> <dt> \_setscope operations_research::sat::SymmetryPropagator Member \_internalref classoperations__research_1_1sat_1_1SymmetryPropagator#a020a35d3244af33a45a416f037529459 "operations_research::sat::SymmetryPropagator::AddSymmetry" (std::unique_ptr< SparsePermutation > permutation)</dt><dd> \anchor _todo002355 (user): Currently this can only be called before PropagateNext() is called (DCHECKed). Not sure if we need more incrementality though. </dd> <dt> \_setscope operations_research::sat::TimeTablingPerTask Class \_internalref classoperations__research_1_1sat_1_1TimeTablingPerTask "operations_research::sat::TimeTablingPerTask" </dt><dd> \anchor _todo002381 (user): Use SchedulingDemandHelper. In particular, if we know the task is from a set of fixed alternatives, we might be able to push it more. </dd> <dt> \_setscope operations_research::sat::TimeTablingPerTask Member \_internalref classoperations__research_1_1sat_1_1TimeTablingPerTask#a3e048be6a5e38900071af4c347b0dff9 "operations_research::sat::TimeTablingPerTask::TimeTablingPerTask" (AffineExpression capacity, SchedulingConstraintHelper *helper, SchedulingDemandHelper *demands, Model *model)</dt><dd> \anchor _todo002376 (user): This usually correspond to a makespan interval. We should just detect and propagate it separately as it would result in a faster propagation. </dd> <dt> \_setscope operations_research::sat::TopN Class \_internalref classoperations__research_1_1sat_1_1TopN "operations_research::sat::TopN< Element, Score >" </dt><dd> \anchor _todo002404 (user): We could use gtl::TopN when/if it gets open sourced. Note that we might be slighlty faster here since we use an indirection and don't move the Element class around as much. </dd> <dt> \_setscope operations_research::sat::TopN Member \_internalref classoperations__research_1_1sat_1_1TopN#aab2091998d8295f6ecc5fd5f2beeebbb "operations_research::sat::TopN< Element, Score >::Add" (Element e, Score score)</dt><dd> \anchor _todo002407 (user): We could delay that on the n + 1 push. </dd> <dt> \_setscope operations_research::sat::TopNCuts Class \_internalref classoperations__research_1_1sat_1_1TopNCuts "operations_research::sat::TopNCuts" </dt><dd> \anchor _todo001872 (user): Avoid computing efficacity twice. (user): We don't use any orthogonality consideration here. (user): Detect duplicate cuts? </dd> <dt> \_setscope operations_research::sat::Trail Member \_internalref classoperations__research_1_1sat_1_1Trail#af94a42301fbeb5da23fdfd2c914f2a01 "operations_research::sat::Trail::Resize" (int num_variables)</dt><dd> \anchor _todo002191 (user): these vectors are not always used. Initialize them dynamically. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a8fc9e60de9ebec04b0d8e62c0bcd7aa1 "operations_research::sat::TransformToGeneratorOfStabilizer" (int to_stabilize, std::vector< std::unique_ptr< SparsePermutation > > *generators)</dt><dd> \anchor _todo002360 (user): Implement! </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a7e710c5266505c51982912036c840755 "operations_research::sat::TryToLinearizeConstraint" (const CpModelProto &model_proto, const ConstraintProto &ct, int linearization_level, Model *model, LinearRelaxation *relaxation, ActivityBoundHelper *helper=nullptr)</dt><dd> \anchor _todo001973 (user): In full generality, we could encode all the constraint as an LP. (user): Add unit tests for this method. (user): Remove and merge with model loading. \anchor _todo001974 (user): Use the same pattern as the other 2 scheduling methods: - single function - generate helpers once</dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#aa5783ecb0b6b7f12fc2ea70339ec7acd "operations_research::sat::TryToReconcileEncodings" (const AffineExpression &size2_affine, const AffineExpression &affine, absl::Span< const ValueLiteralPair > affine_var_encoding, bool put_affine_left_in_result, IntegerEncoder *integer_encoder)</dt><dd> \anchor _todo001683 (user): Consider removing this once we are more complete in our implied bounds repository. Because if we can reconcile an encoding, then any of the literal in the at most one should imply a value on the boolean view use in the size2 affine. \anchor _todo001684 (user): I am not sure how this can happen since size2_affine is supposed to be non-fixed. Maybe we miss some propag. Investigate. </dd> <dt> \_setscope operations_research::sat::UpperBoundedLinearConstraint Member \_internalref classoperations__research_1_1sat_1_1UpperBoundedLinearConstraint#a67f3b45ddd9ba6330059295e6258e4e6 "operations_research::sat::UpperBoundedLinearConstraint::AddToConflict" (MutableUpperBoundedLinearConstraint *conflict)</dt><dd> \anchor _todo002068 (user): Provides instead an easy to use iterator over an UpperBoundedLinearConstraint and move this function to MutableUpperBoundedLinearConstraint. </dd> <dt> \_setscope operations_research::sat::UpperBoundedLinearConstraint Member \_internalref classoperations__research_1_1sat_1_1UpperBoundedLinearConstraint#a7e533d8923312b0d052abae98cab81b8 "operations_research::sat::UpperBoundedLinearConstraint::FillReason" (const Trail &trail, int source_trail_index, BooleanVariable propagated_variable, std::vector< Literal > *reason)</dt><dd> \anchor _todo002067 (user): Maybe it is possible to derive a better reason by using more information. For instance one could use the mask of literals that are better to use during conflict minimization (namely the one already in the 1-UIP conflict). </dd> <dt> \_setscope operations_research::sat::UpperBoundedLinearConstraint Member \_internalref classoperations__research_1_1sat_1_1UpperBoundedLinearConstraint#ab83a887ed56694501b3e60f573db6d74 "operations_research::sat::UpperBoundedLinearConstraint::InitializeRhs" (Coefficient rhs, int trail_index, Coefficient *threshold, Trail *trail, PbConstraintsEnqueueHelper *helper)</dt><dd> \anchor _todo002053 (user): The source trail index for the propagation reason (i.e. max_relevant_trail_index) may be higher than necessary (for some of the propagated literals). Currently this works with FillReason(), but it was a source of a really nasty bug (see CL 68906167) because of the (rhs == 1) optim. Find a good way to test the logic. </dd> <dt> \_setscope operations_research::sat::UpperBoundedLinearConstraint Member \_internalref classoperations__research_1_1sat_1_1UpperBoundedLinearConstraint#a0d48dc8a24a03dea028d9f0e62ee257f "operations_research::sat::UpperBoundedLinearConstraint::ResolvePBConflict" (const Trail &trail, BooleanVariable var, MutableUpperBoundedLinearConstraint *conflict, Coefficient *conflict_slack)</dt><dd> \anchor _todo002054 (user): Investigate if this is a good idea. It doesn't happen often, but does happened. Maybe we can detect this before in Propagate()? The setup is: - At a given trail_index, var is propagated and added on the trail. - There is some constraint literals assigned to true with a trail index in (trail_index, var.trail_index). - Their sum is high enough to cause a conflict. - But individually, their coefficients are too small to be propagated, so the conflict is not yet detected. It will be when these variables are processed by PropagateNext(). \anchor _todo002055 (user): If there is more "cancelation" than the min_coeffs below when we add the two constraints, the resulting slack may be even lower. Taking that into account is probably good. \anchor _todo002056 (user): The best will be to relax as little as possible. \anchor _todo002057 (user): track the cancelation here so we can update *conflict_slack properly. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a2eec7d4958da587ee893e334ab7756cc "operations_research::sat::ValidateCpModel" (const CpModelProto &model, bool after_presolve)</dt><dd> \anchor _todo001157 (user): Add any needed overflow validation because we are far from exhaustive. We could also run a small presolve that tighten variable bounds before the overflow check to facilitate the lives of our users, but it is a some work to put in place. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a2073b9c892ac56b197b31cb583e25f3d "operations_research::sat::ValidateInputCpModel" (const SatParameters &params, const CpModelProto &model)</dt><dd> \anchor _todo001158 (user): Ideally we would have just one ValidateCpModel() function but this was introduced after many users already use ValidateCpModel() without parameters. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#ad582c9543b77917ac1084bbfda601f5e "operations_research::sat::ValidateLinearConstraintForOverflow" (const LinearConstraint &constraint, const IntegerTrail &integer_trail)</dt><dd> \anchor _todo001855 (user): Avoid duplication with PossibleIntegerOverflow() in the checker? At least make sure the code is the same. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a80f1b6bbf960239725bec385f09a5b14 "operations_research::sat::ValidateParameters" (const SatParameters &params)</dt><dd> \anchor _todo002046 (user): Consider using annotations directly in the proto for these validation. It is however not open sourced. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a007d129b4917935f84c9ae0823c2cb11 "operations_research::sat::VarDebugString" (const CpModelProto &proto, int index)</dt><dd> \anchor _todo001154 (user): unfortunately, we need this indirection to get a DebugString() in a const way from an index. Because building an IntVar is non-const. \anchor _todo001155 (user): Use domain pretty print function. </dd> <dt> \_setscope operations_research::sat::VarDomination Class \_internalref classoperations__research_1_1sat_1_1VarDomination "operations_research::sat::VarDomination" </dt><dd> \anchor _todo002431 (user): We have a lot of benchmarks and tests that shows that we don't report wrong relations, but we lack unit test that make sure we don't miss any. Try to improve the situation. </dd> <dt> \_setscope operations_research::sat::VarDomination Member \_internalref classoperations__research_1_1sat_1_1VarDomination#ab03b7579b6f0728fd7c98fccae5196ed "operations_research::sat::VarDomination::EndFirstPhase" ()</dt><dd> \anchor _todo002408 (user): Use more heuristics to not miss as much dominance relation when we crop initial lists. \anchor _todo002409 (user): Tune the initial size, 50 might be a bit large, since our complexity is borned by this number times the number of entries in the constraints. Still we should in most situation be a lot lower than that. \anchor _todo002410 (user): Maybe we should do that with all lists in case the input function are called with duplicates too. </dd> <dt> \_setscope operations_research::sat::VariableWithSameReasonIdentifier Class \_internalref classoperations__research_1_1sat_1_1VariableWithSameReasonIdentifier "operations_research::sat::VariableWithSameReasonIdentifier" </dt><dd> \anchor _todo002064 (user): With the new SAME_REASON_AS mechanism, this is more general so move out of pb_constraint. </dd> <dt> \_setscope operations_research::sat::ZeroHalfCutHelper Member \_internalref classoperations__research_1_1sat_1_1ZeroHalfCutHelper#a58a0ce20218c3abd705302dd4de5474f "operations_research::sat::ZeroHalfCutHelper::AddOneConstraint" (glop::RowIndex, absl::Span< const glop::ColIndex > cols, absl::Span< const IntegerValue > coeffs, IntegerValue lb, IntegerValue ub)</dt><dd> \anchor _todo002437 (user): experiment with the best value. probably only tight rows are best? and we could use the basis status rather than recomputing the activity for that. \anchor _todo002438 (user): Avoid adding duplicates and just randomly pick one. Note that we should also remove duplicate in a generic way. </dd> <dt> \_setscope operations_research::sat::ZeroHalfCutHelper Member \_internalref classoperations__research_1_1sat_1_1ZeroHalfCutHelper#a67c63ecc26af5761893b5b5e93e7c5dd "operations_research::sat::ZeroHalfCutHelper::ProcessVariables" (const std::vector< double > &lp_values, absl::Span< const IntegerValue > lower_bounds, absl::Span< const IntegerValue > upper_bounds)</dt><dd> \anchor _todo002440 (user): This is a first implementation, both the heuristic and the code performance can probably be improved uppon. </dd> <dt> \_setscope operations_research::sat::ZeroHalfCutHelper Member \_internalref classoperations__research_1_1sat_1_1ZeroHalfCutHelper#a263bfb5f369c64ebc8abba96d2e69d63 "operations_research::sat::ZeroHalfCutHelper::SymmetricDifference" (absl::Span< const int > a, std::vector< int > *b)</dt><dd> \anchor _todo002439 (user): optim by doing that at the end? </dd> <dt> \_setscope operations_research::SatInterface Member \_internalref classoperations__research_1_1SatInterface#aa26cae7629efd16954fcc84081c98410 "operations_research::SatInterface::SetPresolveMode" (int value) override</dt><dd> \anchor _todo000824 (user): Implement me. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#a01d1829b304f98e931c8bd5f3ccdcc42 "operations_research::SatSolveProto" (LazyMutableCopy< MPModelRequest > request, std::atomic< bool > *interrupt_solve, std::function< void(const std::string &)> logging_callback, std::function< void(const MPSolution &)> solution_callback)</dt><dd> \anchor _todo000816 (user): We do not support all the parameters here. In particular the logs before the solver is called will not be appended to the response. Fix that, and remove code duplication for the logger config. One way should be to not touch/configure anything if the logger is already created while calling SolveCpModel() and call a common config function from here or from inside Solve()? \anchor _todo000817 (user): We put the INFEASIBLE_OR_UNBOUNBED case here since there is no return status that exactly matches it. \anchor _todo000818 (user): Implement the row and column status. \anchor _todo000819 (user): Remove the postsolve hack of copying to a response. </dd> <dt> \_setscope operations_research::SavingsFilteredHeuristic::SavingsContainer Member \_internalref classoperations__research_1_1SavingsFilteredHeuristic_1_1SavingsContainer#aaaec4a18edcb597c52f8084e47e7f206 "operations_research::SavingsFilteredHeuristic::SavingsContainer< S >::Sort" ()</dt><dd> \anchor _todo000381 (user): Also do this when reiterating on next_savings_. </dd> <dt> \_setscope operations_research::ScipConstraintHandlerContext Member \_internalref classoperations__research_1_1ScipConstraintHandlerContext#ae4b686d5d1040fcf4db709e98a2022af "operations_research::ScipConstraintHandlerContext::is_pseudo_solution" () const</dt><dd> \anchor _todo000830 (user): maybe this can be abstracted away. </dd> <dt> \_setscope operations_research::ScipConstraintHandlerDescription Struct \_internalref structoperations__research_1_1ScipConstraintHandlerDescription "operations_research::ScipConstraintHandlerDescription" </dt><dd> \anchor _todo000829 (user): no effort has been made to optimize the default values of enforcement_priority, feasibility_check_priority, eager_frequency, or separation_priority. </dd> <dt> \_setscope operations_research::SCIPInterface Member \_internalref classoperations__research_1_1SCIPInterface#a8682d7f525de8a5c389cf5e1b495f1ac "operations_research::SCIPInterface::Solve" (const MPSolverParameters &param) override</dt><dd> \anchor _todo000831 (user): Is that still true now (2018) ? \anchor _todo000832 (user): I more or less copied this from the SCIPreadSol() code that reads a solution from a file. I am not sure what SCIPisTransformed() is or what is the difference between the try and add version. In any case this seems to always call SCIPaddSolFree() for now and it works. \anchor _todo000833 (user): We could introduce our own "infeasible or unbounded" status. </dd> <dt> \_setscope operations_research::ScopedFloatingPointEnv Class \_internalref classoperations__research_1_1ScopedFloatingPointEnv "operations_research::ScopedFloatingPointEnv" </dt><dd> \anchor _todo002449 (user): Make it work on 32 bits. (user): Make it work on msvc, currently calls to _controlfp crash. </dd> <dt> \_setscope operations_research::SequenceVar Member \_internalref classoperations__research_1_1SequenceVar#a9858103573f2d43dda6714eacfc2b76b "operations_research::SequenceVar::ComputePossibleFirstsAndLasts" (std::vector< int > *possible_firsts, std::vector< int > *possible_lasts)</dt><dd> \anchor _todo000392 (user): use domain iterator. </dd> <dt> \_setscope operations_research::SequenceVar Member \_internalref classoperations__research_1_1SequenceVar#ac6537f9c14b5450c8e44ec475bce71c7 "operations_research::SequenceVar::SequenceVar" (Solver *s, const std::vector< IntervalVar * > &intervals, const std::vector< IntVar * > &nexts, const std::string &name)</dt><dd> \anchor _todo000391 (user): Add better class invariants, in particular checks that ranked_first, ranked_last, and unperformed are truly disjoint. </dd> <dt> \_setscope operations_research::SetCoverInvariant Member \_internalref classoperations__research_1_1SetCoverInvariant#a11ab8b9645323b91c44a1cb9967e55f2 "operations_research::SetCoverInvariant::ComputeIsRedundant" (SubsetIndex subset) const</dt><dd> \anchor _todo000055 (user): Implement this using AVX-512? </dd> <dt> \_setscope operations_research::SetCoverLagrangian Member \_internalref classoperations__research_1_1SetCoverLagrangian#aeae68a824e917a294697ff76b2811e7a "operations_research::SetCoverLagrangian::ComputeGap" (const SubsetCostVector &reduced_costs, const SubsetBoolVector &solution, const ElementCostVector &multipliers) const</dt><dd> \anchor _todo000064 (user): Parallelize this, if need be. </dd> <dt> \_setscope operations_research::SetCoverLagrangian Member \_internalref classoperations__research_1_1SetCoverLagrangian#adaab24db67d2771d15bb343171af0aff "operations_research::SetCoverLagrangian::InitializeLagrangeMultipliers" () const</dt><dd> \anchor _todo000056 (user): Parallelize this. \anchor _todo000057 (user): Parallelize this. \anchor _todo000058 (user): use std::min_element on rows[element] with a custom comparator that gets marginal_costs[subset]. Check performance. </dd> <dt> \_setscope operations_research::SetCoverLagrangian Member \_internalref classoperations__research_1_1SetCoverLagrangian#a3c9602adfa3dbf354e8788d3eb4ae42a "operations_research::SetCoverLagrangian::NextSolution" ()</dt><dd> \anchor _todo000068 (user): Add time-outs and exit with a partial solution. This seems unlikely, though. </dd> <dt> \_setscope operations_research::SetCoverLagrangian Member \_internalref classoperations__research_1_1SetCoverLagrangian#a895b3ee915078aa7e4797380dc48f9cd "operations_research::SetCoverLagrangian::ParallelComputeReducedCosts" (const SubsetCostVector &costs, const ElementCostVector &multipliers) const</dt><dd> \anchor _todo000059 (user): compute a close-to-optimal k-subset partitioning. \anchor _todo000060 (user): check how costly it is to create a new ThreadPool. \anchor _todo000061 \anchor _todo000062 (user): use a queue of subsets to process? instead of a fixed range. </dd> <dt> \_setscope operations_research::SetCoverLagrangian Member \_internalref classoperations__research_1_1SetCoverLagrangian#a5cf44bc52b80fcd2298c7bb19a2134e4 "operations_research::SetCoverLagrangian::ParallelComputeSubgradient" (const SubsetCostVector &reduced_costs) const</dt><dd> \anchor _todo000063 (user): it may be better to split the elements among the threads, although this might be less well-balanced. </dd> <dt> \_setscope operations_research::SetCoverMip Member \_internalref classoperations__research_1_1SetCoverMip#a001442db41cffab6e77f01a2de737956 "operations_research::SetCoverMip::NextSolution" (bool use_integers, double time_limit_in_seconds)</dt><dd> \anchor _todo000069 (user): Add time-outs and exit with a partial solution. This seems unlikely, though. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#a759cbf01a64672ed6d944df33e681bc7 "operations_research::setobjoffset" (const XPRSprob &mLp, double value)</dt><dd> \anchor _todo000844 detect xpress version </dd> <dt> \_setscope operations_research::SimpleLinearSumAssignment Member \_internalref classoperations__research_1_1SimpleLinearSumAssignment#a613c560fdd07ae94350736adaf2dab56 "operations_research::SimpleLinearSumAssignment::Solve" ()</dt><dd> \anchor _todo000626 (user): Improve the LinearSumAssignment api to clearly define the error cases. </dd> <dt> \_setscope operations_research::SimpleMaxFlow Class \_internalref classoperations__research_1_1SimpleMaxFlow "operations_research::SimpleMaxFlow" </dt><dd> \anchor _todo000684 (user): If the need arises, extend this interface to support warm start. </dd> <dt> \_setscope operations_research::SimpleMaxFlow Member \_internalref classoperations__research_1_1SimpleMaxFlow#a8a7acde49c4d55f2eb42e2b6869cdb3da18a3ff25435f10be68329d4b39de4700 "operations_research::SimpleMaxFlow::POSSIBLE_OVERFLOW" </dt><dd> \anchor _todo000687 (user): rename POSSIBLE_OVERFLOW to INT_OVERFLOW and modify our clients. </dd> <dt> \_setscope operations_research::SimpleMaxFlow Member \_internalref classoperations__research_1_1SimpleMaxFlow#a57296b653813abdd8d711048e87d1212 "operations_research::SimpleMaxFlow::SetArcCapacity" (ArcIndex arc, FlowQuantity capacity)</dt><dd> \anchor _todo000686 (user): Support incrementality in the max flow implementation. </dd> <dt> \_setscope operations_research::SimpleMinCostFlow Class \_internalref classoperations__research_1_1SimpleMinCostFlow "operations_research::SimpleMinCostFlow" </dt><dd> \anchor _todo000699 (user): If the need arises, extend this interface to support warm start and incrementality between solves. Note that this is already supported by the GenericMinCostFlow<> interface. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#ae1b6e8c0d3d27218470118e9182605ed "operations_research::SolveModelWithSat" (RoutingModel *model, const RoutingSearchParameters &search_parameters, const Assignment *initial_solution, Assignment *solution)</dt><dd> \anchor _todo000358 (user): Check that performance is acceptable. \anchor _todo000359 (user): Check that performance is acceptable. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#a1874495370d2fab28ba9487e2f845b81 "operations_research::SolveMPModel" (LazyMutableCopy< MPModelRequest > request, const SolveInterrupter *interrupter)</dt><dd> \anchor _todo000836 (b/311704821): this function should not delegate to MPSolver, also true for the functions below. </dd> <dt> \_setscope operations_research::Solver Member \_internalref classoperations__research_1_1Solver#a4b71e8c5bbd90a2bcee8b0570328f91a "operations_research::Solver::Action" </dt><dd> \anchor _todo000146 (user): wrap in swig. </dd> <dt> \_setscope operations_research::Solver Member \_internalref classoperations__research_1_1Solver#a38d14a90db2f0ae3bc1563d453e4f93e "operations_research::Solver::AddPropagationMonitor" (PropagationMonitor *monitor)</dt><dd> \anchor _todo000142 (user): Check solver state? </dd> <dt> \_setscope operations_research::Solver Member \_internalref classoperations__research_1_1Solver#aa290140ba6c4d6ef672c792a63bad57c "operations_research::Solver::ClearNeighbors" ()</dt><dd> \anchor _todo000148 (user): Find a workaround to avoid exposing this. </dd> <dt> \_setscope operations_research::Solver Member \_internalref classoperations__research_1_1Solver#a00ddb4cf5be5463ec6b494808bc8f192 "operations_research::Solver::DefaultSolverParameters" ()</dt><dd> \anchor _todo000147 (user): Move to constraint_solver_parameters.h. </dd> <dt> \_setscope operations_research::Solver Member \_internalref classoperations__research_1_1Solver#ae3b660d3dece402d0ca5448d127c0f6f "operations_research::Solver::GetOrCreateLocalSearchState" ()</dt><dd> \anchor _todo000164 (user): Investigate if this should be moved to Search. </dd> <dt> \_setscope operations_research::Solver Member \_internalref classoperations__research_1_1Solver#aeb2e6947882d148bfaece200f5c6b131 "operations_research::Solver::InstrumentsDemons" () const</dt><dd> \anchor _todo000137 (user): remove this complex logic. We need the double test because parameters are set too late when using python in the open source. This is the cheapest work-around. </dd> <dt> \_setscope operations_research::Solver Member \_internalref classoperations__research_1_1Solver#ae63acd77b8c2ee40387795051298f659 "operations_research::Solver::IntValueStrategy" </dt><dd> \anchor _todo000145 (user): add HIGHEST_MIN and LOWEST_MAX. </dd> <dt> \_setscope operations_research::Solver Member \_internalref classoperations__research_1_1Solver#a64fd8adbc00c3bed16bf4b824dfd3e2b "operations_research::Solver::LocalSearchProfile" () const</dt><dd> \anchor _todo000162 (user): Merge demon and local search profiles. </dd> <dt> \_setscope operations_research::Solver Member \_internalref classoperations__research_1_1Solver#a579ddb4232150f04e17c0852fc8e1c60 "operations_research::Solver::MakeCircuit" (const std::vector< IntVar * > &nexts)</dt><dd> \anchor _todo000216 (user): Merge NoCycle and Circuit. </dd> <dt> \_setscope operations_research::Solver Member \_internalref classoperations__research_1_1Solver#aa1b2edf76ef068b3d1cc8b56f7e7af23 "operations_research::Solver::MakeDelayedPathCumul" (const std::vector< IntVar * > &nexts, const std::vector< IntVar * > &active, const std::vector< IntVar * > &cumuls, const std::vector< IntVar * > &transits)</dt><dd> \anchor _todo000153 (user): Merge with other path-cumuls constraints. </dd> <dt> \_setscope operations_research::Solver Member \_internalref classoperations__research_1_1Solver#a0132207ac0371c18971693c8a6d9b29c "operations_research::Solver::MakeDistribute" (const std::vector< IntVar * > &vars, const std::vector< int64_t > &values, const std::vector< IntVar * > &cards)</dt><dd> \anchor _todo000177 (user) : we can sort values (and cards) before doing the test. </dd> <dt> \_setscope operations_research::Solver Member \_internalref classoperations__research_1_1Solver#a0ceffed2d421a344403f5a8366baa136 "operations_research::Solver::MakeDiv" (IntExpr *expr, int64_t value)</dt><dd> \anchor _todo000197 (user) : implement special case. </dd> <dt> \_setscope operations_research::Solver Member \_internalref classoperations__research_1_1Solver#a0ab2b02352f4ab51aeb392314d7b60a5 "operations_research::Solver::MakeIsEqualCstCt" (IntExpr *var, int64_t value, IntVar *boolvar)</dt><dd> \anchor _todo000192 (user) : what happens if the constraint is not posted? The cache becomes tainted. </dd> <dt> \_setscope operations_research::Solver Member \_internalref classoperations__research_1_1Solver#a10c9da29e0f571f2fac430761d133016 "operations_research::Solver::MakeLexicalLess" (const std::vector< IntVar * > &left, const std::vector< IntVar * > &right)</dt><dd> \anchor _todo000151 (user): Add void MakeSortedArray( const std::vector<IntVar*>& vars, std::vector<IntVar*>* const sorted); </dd> <dt> \_setscope operations_research::Solver Member \_internalref classoperations__research_1_1Solver#a79d9441a76ca41dce4b28ff9be616363 "operations_research::Solver::MakeLocalSearchPhase" (Assignment *assignment, LocalSearchPhaseParameters *parameters)</dt><dd> \anchor _todo000161 (user): Make a variant which runs a local search after each solution found in a DFS. </dd> <dt> \_setscope operations_research::Solver Member \_internalref classoperations__research_1_1Solver#aa8c0e8504dd5125dd200e9e3d9ef1e75 "operations_research::Solver::MakeNoCycle" (const std::vector< IntVar * > &nexts, const std::vector< IntVar * > &active, IndexFilter1 sink_handler=nullptr)</dt><dd> \anchor _todo000152 (user): Implement MakeAllNullIntersect taking an array of variable vectors. </dd> <dt> \_setscope operations_research::Solver Member \_internalref classoperations__research_1_1Solver#af6c9a69ab6f3bf11e703e91812d34223 "operations_research::Solver::MakeNotBetweenCt" (IntExpr *expr, int64_t l, int64_t u)</dt><dd> \anchor _todo000193 (user): Add back simplification code if expr is constant * other_expr. </dd> <dt> \_setscope operations_research::Solver Member \_internalref classoperations__research_1_1Solver#ac78afa51e3d5d28e84916a6fc47375de "operations_research::Solver::MakeOperator" (const std::vector< IntVar * > &vars, IndexEvaluator3 evaluator, EvaluatorLocalSearchOperators op)</dt><dd> \anchor _todo000160 (user): Make the callback an IndexEvaluator2 when there are no secondary variables. </dd> <dt> \_setscope operations_research::Solver Member \_internalref classoperations__research_1_1Solver#abe4d40de1cffbeed5d0bbd8a875a83b1 "operations_research::Solver::MakeOperator" (const std::vector< IntVar * > &vars, LocalSearchOperators op, std::function< const std::vector< int > &(int, int)> get_neighbors=nullptr)</dt><dd> \anchor _todo000236 (user): Remove (parts of) the following methods as they are mostly redundant with the MakeLocalSearchOperatorWithNeighbors and MakeLocalSearchOperator functions. </dd> <dt> \_setscope operations_research::Solver Member \_internalref classoperations__research_1_1Solver#a0456a638eb3c86b7e3c6bbcc6f1a961c "operations_research::Solver::MakePathConnected" (std::vector< IntVar * > nexts, std::vector< int64_t > sources, std::vector< int64_t > sinks, std::vector< IntVar * > status)</dt><dd> \anchor _todo000154 (user): Only does checking on WhenBound events on next variables. Check whether more propagation is needed. </dd> <dt> \_setscope operations_research::Solver Member \_internalref classoperations__research_1_1Solver#a793b6001916186ac1d7041a10fdd41d6 "operations_research::Solver::MakePathPrecedenceConstraint" (std::vector< IntVar * > nexts, const std::vector< std::pair< int, int > > &precedences)</dt><dd> \anchor _todo000155 (user): This constraint does not make holes in variable domains; the implementation can easily be modified to do that; evaluate the impact on models solved with local search. </dd> <dt> \_setscope operations_research::Solver Member \_internalref classoperations__research_1_1Solver#a66461677e91be7682f36b8660889fd2f "operations_research::Solver::MakePhase" (const std::vector< IntVar * > &vars, IntVarStrategy var_str, IntValueStrategy val_str)</dt><dd> \anchor _todo000159 (user): name each of them differently, and document them (and do that for all other functions that have several homonyms in this .h). </dd> <dt> \_setscope operations_research::Solver Member \_internalref classoperations__research_1_1Solver#a039ebfef32db8ee5641b25328954cce9 "operations_research::Solver::MakePhase" (const std::vector< IntVar * > &vars, IndexEvaluator2 eval, IndexEvaluator1 tie_breaker, EvaluatorStrategy str)</dt><dd> \anchor _todo000396 (user): support tie breaker </dd> <dt> \_setscope operations_research::Solver Member \_internalref classoperations__research_1_1Solver#a84584b7705a787a70e09341e4a0e30f5 "operations_research::Solver::MakePiecewiseLinearExpr" (IntExpr *expr, const PiecewiseLinearFunction &f)</dt><dd> \anchor _todo000149 (user): Investigate if we can merge all three piecewise linear expressions. </dd> <dt> \_setscope operations_research::Solver Member \_internalref classoperations__research_1_1Solver#ac9865c3135d8b9b3f7de73c92dac53a4 "operations_research::Solver::MakeSearchLog" (int branch_period)</dt><dd> \anchor _todo000157 (user): DEPRECATE API of MakeSearchLog(.., IntVar* var,..). </dd> <dt> \_setscope operations_research::Solver Member \_internalref classoperations__research_1_1Solver#afbef3a751ed2de0600ef603df8dbc16f "operations_research::Solver::MakeSemiContinuousExpr" (IntExpr *expr, int64_t fixed_charge, int64_t step)</dt><dd> \anchor _todo000198 (user) : benchmark with virtualization of PosIntDivDown and PosIntDivUp - or function pointers. </dd> <dt> \_setscope operations_research::Solver Member \_internalref classoperations__research_1_1Solver#acdd432e2ef445bb100f999ebb36e8d9c "operations_research::Solver::MakeSimulatedAnnealing" (bool maximize, IntVar *v, int64_t step, int64_t initial_temperature)</dt><dd> \anchor _todo000156 (user): document behavior </dd> <dt> \_setscope operations_research::Solver Member \_internalref classoperations__research_1_1Solver#a0d6603ccdf190d08e5eb55a383cb7f42 "operations_research::Solver::MakeSortingConstraint" (const std::vector< IntVar * > &vars, const std::vector< IntVar * > &sorted)</dt><dd> \anchor _todo000150 (user): Do we need a version with an array of escape values. </dd> <dt> \_setscope operations_research::Solver Member \_internalref classoperations__research_1_1Solver#a4c57adb4aa21bbbb303282a2fb12a546 "operations_research::Solver::NewSearch" (DecisionBuilder *db, const std::vector< SearchMonitor * > &monitors)</dt><dd> \anchor _todo000139 (user) : reset statistics \anchor _todo000140 (user): delete top level search after EndSearch(). \anchor _todo000141 (user): Check if these two lines are still necessary. </dd> <dt> \_setscope operations_research::Solver Member \_internalref classoperations__research_1_1Solver#afa66a85cec14980401bb16d4f4a84aa1 "operations_research::Solver::SetUseFastLocalSearch" (bool use_fast_local_search)</dt><dd> \anchor _todo000163 (user): Get rid of the following methods once fast local search is enabled for metaheuristics. Disables/enables fast local search. </dd> <dt> \_setscope operations_research::Solver Member \_internalref classoperations__research_1_1Solver#a904f4c25cf6302fc577889db54b240cc "operations_research::Solver::Try" (DecisionBuilder *db1, DecisionBuilder *db2)</dt><dd> \anchor _todo000158 (user): The search tree can be balanced by using binary "Try"-builders "recursively". For instance, Try(a,b,c,d) will give a tree unbalanced to the right, whereas Try(Try(a,b), Try(b,c)) will give a balanced tree. Investigate if we should only provide the binary version and/or if we should balance automatically. </dd> <dt> \_setscope operations_research::SolverLogger Member \_internalref classoperations__research_1_1SolverLogger#a596c5e6e999145f99d9afdb60ef52c84 "operations_research::SolverLogger::FlushPendingThrottledLogs" (bool ignore_rates=false)</dt><dd> \anchor _todo002452 (user): If this is called too often, we could optimize it and do nothing if there are no skipped logs. </dd> <dt> \_setscope operations_research::SortedDisjointIntervalList Class \_internalref classoperations__research_1_1SortedDisjointIntervalList "operations_research::SortedDisjointIntervalList" </dt><dd> \anchor _todo002472 (user): Templatize the class on the type of the bounds. </dd> <dt> \_setscope operations_research::SortedDisjointIntervalList Member \_internalref classoperations__research_1_1SortedDisjointIntervalList#a53aa27777a48b981046ad09b97bded60 "operations_research::SortedDisjointIntervalList::InsertInterval" (int64_t start, int64_t end)</dt><dd> \anchor _todo002469 (user): tune the algorithm below if it proves to be a bottleneck. For example, one could try to avoid an insertion if it's not needed (when the interval merges with a single existing interval or is fully contained by one). </dd> <dt> \_setscope operations_research::SortedDisjointIntervalList Member \_internalref classoperations__research_1_1SortedDisjointIntervalList#ad937d5864aa7a209f5c565a49daad904 "operations_research::SortedDisjointIntervalList::InsertIntervals" (const std::vector< int > &starts, const std::vector< int > &ends)</dt><dd> \anchor _todo002470 (user): treat kint32min and kint32max as their kint64 variants. </dd> <dt> \_setscope operations_research::SortedDisjointIntervalList Member \_internalref classoperations__research_1_1SortedDisjointIntervalList#a592c99d8ddbc2a357683903882c437ba "operations_research::SortedDisjointIntervalList::SortedDisjointIntervalList" (const std::vector< int64_t > &starts, const std::vector< int64_t > &ends)</dt><dd> \anchor _todo002473 (user): Explain why we favored this API to the more natural input std::vector<ClosedInterval> or std::vector<std::pair<int, int>>. </dd> <dt> \_setscope operations_research::SparsePermutation Member \_internalref classoperations__research_1_1SparsePermutation#a9fc0ca5752b5ad6cc2a78ff7c512b22a "operations_research::SparsePermutation::LastElementInCycle" (int i) const</dt><dd> \anchor _todo000077 (user): Provide a full iterator for this? Note that we have more information with the loop above. Not sure it is needed though. </dd> <dt> \_setscope operations_research::SparsePermutation Member \_internalref classoperations__research_1_1SparsePermutation#a1190fc1695811df74812b7fb1051f3bc "operations_research::SparsePermutation::RemoveCycles" (absl::Span< const int > cycle_indices)</dt><dd> \anchor _todo000075 (user): make this a class member to avoid allocation if the complexity becomes an issue. In this case, also optimize the loop below by not copying the first cycles. </dd> <dt> \_setscope operations_research::SparsePermutation Member \_internalref classoperations__research_1_1SparsePermutation#aff385d18c768ffa364c5dccb5fb35c0a "operations_research::SparsePermutation::Size" () const</dt><dd> \anchor _todo000076 (user): complete the reader API. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#a93f8f72c3931f60faed67abfe9b85f3e "operations_research::splitMyString" (const std::string &str, Container &cont, char delim=' ')</dt><dd> \anchor _todo000851 useless ? </dd> <dt> \_setscope operations_research::SteepestSearch Member \_internalref classoperations__research_1_1SteepestSearch#a7b76a69a07f9abf4e7cd0ff88925208d "operations_research::SteepestSearch::NextSolution" (int num_iterations)</dt><dd> \anchor _todo000052 (user): Add time-outs and exit with a partial solution. </dd> <dt> \_setscope operations_research::SwapActiveToShortestPathOperator Class \_internalref classoperations__research_1_1SwapActiveToShortestPathOperator "operations_research::SwapActiveToShortestPathOperator" </dt><dd> \anchor _todo000355 (user): Support vehicle-class-dependent arc_evaluators. </dd> <dt> \_setscope operations_research::SymmetryManager Member \_internalref classoperations__research_1_1SymmetryManager#a6f8f0310d17cfdf227de35d5eaeb6ec2 "operations_research::SymmetryManager::CheckSymmetries" (int index)</dt><dd> \anchor _todo000405 (user) : Improve speed, cache previous min and build them incrementally. </dd> <dt> \_setscope operations_research::TimeDistribution Class \_internalref classoperations__research_1_1TimeDistribution "operations_research::TimeDistribution" </dt><dd> \anchor _todo002474 (user): Since we inherit from DistributionStat, we currently store the sum of CPU cycles as a double internally. A better option is to use int64_t because with the 53 bits of precision of a double, we will run into an issue if the sum of times reaches 52 days for a 2GHz processor. </dd> <dt> \_setscope operations_research::TimeLimit Class \_internalref classoperations__research_1_1TimeLimit "operations_research::TimeLimit" </dt><dd> \anchor _todo002476 (user): The expression "deterministic time" should be replaced with "number of operations" to avoid confusion with "real" time. </dd> <dt> \_setscope operations_research::TrivialSolutionGenerator Member \_internalref classoperations__research_1_1TrivialSolutionGenerator#a72b5cae65519e7893e32e217ef056384 "operations_research::TrivialSolutionGenerator::NextSolution" ()</dt><dd> \anchor _todo000049 (user): Add time-outs and exit with a partial solution. This seems unlikely, though. </dd> <dt> \_setscope operations_research::TspLibTourParser Member \_internalref classoperations__research_1_1TspLibTourParser#a35c4ff768d130b7f9303bc1a2f96a0d7 "operations_research::TspLibTourParser::LoadFile" (const std::string &file_name)</dt><dd> \anchor _todo001069 (user): Return false when issues were encountered while parsing the file. </dd> <dt> \_setscope operations_research::XpressInterface Member \_internalref classoperations__research_1_1XpressInterface#a16607e74836faff69fe760ced72898ce "operations_research::XpressInterface::AddRowConstraint" (MPConstraint *ct) override</dt><dd> \anchor _todo000847 Make new constraints basic (rowstat[jrow]=1) Try not to delete basic variables, or non-basic constraints. </dd> <dt> \_setscope operations_research::XpressInterface Member \_internalref classoperations__research_1_1XpressInterface#aa8856606b3e293087775ce7725e1dd99 "operations_research::XpressInterface::AddVariable" (MPVariable *var) override</dt><dd> \anchor _todo000848 Make new variables non-basic at their lower bound (colstat[icol]=0), unless a variable has an infinite lower bound and a finite upper bound, in which case make the variable non-basic at its upper bound (colstat[icol]=2) Try not to delete basic variables, or non-basic constraints. </dd> <dt> \_setscope operations_research::XpressInterface Member \_internalref classoperations__research_1_1XpressInterface#a19631de62b2acb1c83d926ebea3c8e09 "operations_research::XpressInterface::ComputeExactConditionNumber" () const override</dt><dd> \anchor _todo000853 (user): Not yet working. </dd> <dt> \_setscope operations_research::XpressInterface Member \_internalref classoperations__research_1_1XpressInterface#a99b8c52ba056e774c77c291506de3da1 "operations_research::XpressInterface::ExtractNewVariables" () override</dt><dd> \anchor _todo000849 : Use a bitarray to flag the constraints that actually intersect new variables? </dd> <dt> \_setscope operations_research::XpressInterface Member \_internalref classoperations__research_1_1XpressInterface#ada4d7eb4cf0ff57af8f2585fe4dfbdf6 "operations_research::XpressInterface::SetVariableInteger" (int var_index, bool integer) override</dt><dd> \anchor _todo000845 : Should we check the current type and don't do anything in case the type does not change? </dd> <dt> \_setscope operations_research::XpressInterface Member \_internalref classoperations__research_1_1XpressInterface#a6d7d562bf9d60d8006799f9f14d89afd "operations_research::XpressInterface::Solve" (MPSolverParameters const &param) override</dt><dd> \anchor _todo000850 : check number of variables / constraints </dd> <dt> \_setscope operations_research::XpressMPCallbackContext Member \_internalref classoperations__research_1_1XpressMPCallbackContext#a7aa4754c5d84c3a8eb47a8f1384bc29f "operations_research::XpressMPCallbackContext::SuggestSolution" (const absl::flat_hash_map< const MPVariable *, double > &solution) override</dt><dd> \anchor _todo000852 : remove this workaround when it is handled in XPRESS </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#aab95dca44c4ffd09a71ba4f9293dad44 "operations_research::YenKShortestPaths" (const GraphType &graph, const std::vector< PathDistance > &arc_lengths, NodeIndex source, NodeIndex destination, unsigned k)</dt><dd> \anchor _todo000666 (user): relax to "no negative-weight cycles" (no Dijkstra). - The graphs might have loops. \anchor _todo000668 (user): Yen's algorithm can work with negative weights, but Dijkstra cannot. \anchor _todo000669 (user): think about adding parallelism for this loop to improve running times. This is not a priority as long as the algorithm is faster than the one in <tt>shortest_paths.h</tt>. \anchor _todo000670 (user): would it be faster to fingerprint the paths and filter by fingerprints? Due to the probability of error with fingerprints, still use this slow-but-exact code, but after filtering. </dd> <dt> Member \_internalref scip__callback_8cc#a55103a9413973772f122a9c3dfef5030 "SCIP_DECL_CONSENFOPS" (EnforcePseudoSolutionC)</dt><dd> \anchor _todo000825 (user): are we sure the pseudo solution is LP feasible? It seems like it doesn't need to be. The code in RunSeparation might assume this? </dd> <dt> Member \_internalref scip__callback_8cc#a2e5ec3c32f1a6cde27f8a3538ea801bd "SCIP_DECL_CONSLOCK" (VariableRoundingLockC)</dt><dd> \anchor _todo000826 (user): this could be a little better, but we would need to add another method to override on ScipConstraintHandler<ConstraintData>. </dd> <dt> Member \_internalref routing_8cc#a9f7fbf98fe796946fe0be2ca5c8b4e50 "start_equivalence_class" </dt><dd> \anchor _todo000302 (user): Find equivalent start/end nodes wrt dimensions and callbacks. </dd> <dt> \_setscope StronglyConnectedComponentsFinder Class \_internalref classStronglyConnectedComponentsFinder "StronglyConnectedComponentsFinder< NodeIndex, Graph, SccOutput >" </dt><dd> \anchor _todo000736 (user): Possible optimizations: - Try to reserve the vectors which sizes are bounded by num_nodes. - Use an index rather than doing push_back(), pop_back() on them. </dd> <dt> Member \_internalref timer_8h#a430398fcce7a0820817d8dae9c226d00 "UserTimer" </dt><dd> \anchor _todo000080 (user): implement it properly. </dd> <dt> \_setscope util::BaseGraph Member \_internalref classutil_1_1BaseGraph#a92ffd852b2ab2e5241f9832e71a2de71 "util::BaseGraph< NodeIndexType, ArcIndexType, HasReverseArcs >::arc_capacity" () const</dt><dd> \anchor _todo000642 (user): Same questions as the ones in node_capacity(). </dd> <dt> \_setscope util::BaseGraph Member \_internalref classutil_1_1BaseGraph#aa3bd051d1e141b09dda17aa9b5f24f69 "util::BaseGraph< NodeIndexType, ArcIndexType, HasReverseArcs >::FreezeCapacities" ()</dt><dd> \anchor _todo000643 (user): Only define this in debug mode at the cost of having a lot of ifndef NDEBUG all over the place? remove the function completely ? </dd> <dt> \_setscope util::BaseGraph Member \_internalref classutil_1_1BaseGraph#a07214b96597069d781e27b1dd17ef83e "util::BaseGraph< NodeIndexType, ArcIndexType, HasReverseArcs >::GroupForwardArcsByFunctor" (const A &a, B *b)</dt><dd> \anchor _todo000645 (user): remove the public functions below. They are just here during the transition from the old ebert_graph api to this new graph api. </dd> <dt> \_setscope util::BaseGraph Member \_internalref classutil_1_1BaseGraph#a463d57480c9563a7a707c5d0928c9946 "util::BaseGraph< NodeIndexType, ArcIndexType, HasReverseArcs >::node_capacity" () const</dt><dd> \anchor _todo000641 (user): Is it needed? remove completely? return the real capacities at the cost of having a different implementation for each graphs? </dd> <dt> \_setscope util Member \_internalref namespaceutil#a628255019800e5a053d08b1f0c5a05f2 "util::EqualRange" (MultiMap &multi_map, const typename MultiMap::key_type &key)</dt><dd> \anchor _todo000664 (user): go further and expose only the values, not the pairs (key, values) since the caller already knows the key. </dd> <dt> \_setscope util::graph Member \_internalref namespaceutil_1_1graph#a440afdf238e5a752bbe4e1bcc8878fe7 "util::graph::FindCycleInGraph" (const AdjacencyLists &adj)</dt><dd> \anchor _todo000737 (user): Caching adj[cur_state->node] in a local stack to improve locality and so that the [] operator is called exactly once per node. </dd> <dt> \_setscope util Member \_internalref namespaceutil#a9470623ca7db3c4a62ce3b326c6b07d8 "util::PermuteWithExplicitElementType" (const IntVector &permutation, Array *array_to_permute, ElementType unused)</dt><dd> \anchor _todo000640 (user): consider slower but more memory efficient implementations that follow the cycles of the permutation and use a bitmap to indicate what has been permuted or to mark the beginning of each cycle. </dd> <dt> \_setscope util Member \_internalref namespaceutil#a06fa201576c927d92657e090fa86bfdb "util::RemoveCyclesFromPath" (const Graph &graph, std::vector< int > *arc_path)</dt><dd> \anchor _todo000738 (user): In some cases, there is more than one possible solution. We could take some arc costs and return the cheapest path instead. Or return the shortest path in term of number of arcs. </dd> <dt> \_setscope util::ReverseArcMixedGraph Member \_internalref classutil_1_1ReverseArcMixedGraph#a5ebe11f2abcd78ad1f5606e27d1688bb "util::ReverseArcMixedGraph< NodeIndexType, ArcIndexType >::Head" (ArcIndexType arc) const</dt><dd> \anchor _todo000647 (user): support Head() and Tail() before Build(), like StaticGraph<>. </dd> <dt> \_setscope util::ReverseArcMixedGraph::OutgoingArcIterator Member \_internalref classutil_1_1ReverseArcMixedGraph_1_1OutgoingArcIterator#ac265893b8e1a6db1380522442bf66c84 "util::ReverseArcMixedGraph< NodeIndexType, ArcIndexType >::OutgoingArcIterator::DEFINE_STL_ITERATOR_FUNCTIONS" (OutgoingArcIterator)</dt><dd> \anchor _todo000651 (user): we lose a bit by returning a BeginEndWrapper<> on top of this iterator rather than a simple IntegerRange on the arc indices. </dd> <dt> \_setscope util::ReverseArcStaticGraph Member \_internalref classutil_1_1ReverseArcStaticGraph#a590ee70b96ce87433ba89b067495aa5f "util::ReverseArcStaticGraph< NodeIndexType, ArcIndexType >::Build" (std::vector< ArcIndexType > *permutation)</dt><dd> \anchor _todo000644 (user): the 0 is wasted here, but minor optimisation. </dd> <dt> \_setscope util::ReverseArcStaticGraph Member \_internalref classutil_1_1ReverseArcStaticGraph#a72e8ed03fe3f8ff27d156622a86900aa "util::ReverseArcStaticGraph< NodeIndexType, ArcIndexType >::Head" (ArcIndexType arc) const</dt><dd> \anchor _todo000646 (user): support Head() and Tail() before Build(), like StaticGraph<>. </dd> <dt> \_setscope util::ReverseArcStaticGraph::OutgoingArcIterator Member \_internalref classutil_1_1ReverseArcStaticGraph_1_1OutgoingArcIterator#a4f7501971b3fcc6ab34772a93c449ac6 "util::ReverseArcStaticGraph< NodeIndexType, ArcIndexType >::OutgoingArcIterator::DEFINE_STL_ITERATOR_FUNCTIONS" (OutgoingArcIterator)</dt><dd> \anchor _todo000650 (user): we lose a bit by returning a BeginEndWrapper<> on top of this iterator rather than a simple IntegerRange on the arc indices. </dd> <dt> \_setscope util::SVector Member \_internalref classutil_1_1SVector#a287f9791ba2e68e137d53fc038bbe432 "util::SVector< T >::reserve" (int n)</dt><dd> \anchor _todo000648 (user): in C++17 we could use std::uninitialized_move instead of this loop. </dd> <dt> Member \_internalref parser_8tab_8cc#ad3cdc959806aba1ada0fd7e5d4184f88 "yyparse" (operations_research::fz::ParserContext *context, operations_research::fz::Model *model, bool *ok, void *scanner)

(user): Check that the assignment is included in the domain.

(user): CHECK all values within domain.

(user): check that all assignments are included in the domain.