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.

Member ABSL_FLAG (bool, cp_model_use_max_hs, false, "Use max_hs in search portfolio.")

(user): remove this when the code is stable and does not use SCIP anymore.

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 (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!

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.

Namespace operations_research

(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): 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.

(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): handle timeouts, compute row and column statuses.

(user): either implement with SCIP constraint handlers or use a solver independent implementation.

(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 _todo000035 : 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. \anchor _todo002191 (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 _todo000033 (user): Merge this code with algorithms/knapsack_solver. \anchor _todo000350 (user): Move all existing routing search code here. \anchor _todo000769 (user): post c++ 14, instead use std::pair<MPSolver::OptimizationProblemType, const absl::string_view> once pair gets a constexpr constructor. \anchor _todo000028 (user): base this code on LinearSumAssignment. \anchor _todo000637 (user): implement pruning procedures on top of the Held-Karp algorithm. \anchor _todo000893 (b/180617976): change this behavior. \anchor _todo000676 (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 _todo000929 (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 _todo000378 (user) : treat optional intervals (user) : Call DecisionVisitor and pass name of variable \anchor _todo000925 (b/180024054): the following parameters are not tested: * time_limit * threads * scaling \anchor _todo000920 (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 _todo000660 (user): implement the above active node choice rule. \anchor _todo002387 (user): make this implementation the default everywhere. (user): investigate the code generated by MSVC. \anchor _todo000006 (user): refine this toplevel comment when this file settles. \anchor _todo000365 (user): Clean up to match other first solution strategies. \anchor _todo000847 (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. \anchor _todo002234 (user): Expand. </dd> <dt> \_setscope operations_research::@142 Namespace \_internalref namespaceoperations__research_1_1_0d142 "operations_research::@142" </dt><dd> \anchor _todo000200 (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 _todo002366 (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 _todo002388 (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 _todo002367 (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 _todo002368 (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 _todo000794 (user): General constraints are currently not supported. \anchor _todo000795 (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 _todo000796 (user): transform the hint instead of disabling presolve. \anchor _todo000797 (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 _todo000619 (user): extend to non-floating lengths. (user): extend to allow for length functor. (user): extend to k-shortest paths for k > 1. </dd> <dt> \_setscope operations_research::Assignment Member \_internalref classoperations__research_1_1Assignment#ad6ab5aff03cb66b05fcbdff43dde169a "operations_research::Assignment::CopyIntersection" (const Assignment *assignment)</dt><dd> \anchor _todo000121 (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 _todo000150 (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 _todo000351 (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 _todo000235 (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 _todo000374 (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 _todo000063 (user) : optimize next loop. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#ab7253ffd8b7aba4b7cb5f981c7627526 "operations_research::BitPos64" (uint64_t pos)</dt><dd> \anchor _todo002370 (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 _todo002371 (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 _todo000700 (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 _todo000701 (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 _todo000693 (user): Check all dual/slack same after primal op? \anchor _todo000694 (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 _todo000695 (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 _todo000696 (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 _todo000690 (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 _todo000707 (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 _todo000698 (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 _todo000685 (user): Code the more advanced "Fractional matching initialization" heuristic. \anchor _todo000686 (user): Add a preprocessing step that performs the 'forced' matches? \anchor _todo000687 (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 _todo000688 (user): Optimize by merging this loop with the one above? \anchor _todo000689 (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 _todo000691 (user): avoid adding duplicates? \anchor _todo000692 (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 _todo000697 (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 _todo000091 (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 _todo000090 (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 _todo000070 (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 _todo000069 (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 _todo000077 (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 _todo000106 (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 _todo000118 (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 _todo000073 (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 _todo000093 (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 _todo000092 (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 _todo000097 (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 _todo000104 (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 _todo000105 (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 _todo000100 (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 _todo000101 (user): don't penalize the SatCoreBasedOptimizer or the LinearRelaxation when they improve the lower bound. \anchor _todo000102 \anchor _todo000103 (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 _todo000071 (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 _todo000068 (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 _todo000082 (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 _todo000108 (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 _todo000107 (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 _todo000096 (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 _todo000736 (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 _todo000735 (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 _todo000737 (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 _todo000738 (user): add this to BopParameters. \anchor _todo000739 (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 _todo000733 (user): Implement the row status. \anchor _todo000732 (user): Implement the column status. </dd> <dt> \_setscope operations_research::BopInterface Member \_internalref classoperations__research_1_1BopInterface#a8055a5ae37344bb12601db78c75336ca "operations_research::BopInterface::SolverVersion" () const override</dt><dd> \anchor _todo000734 (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 _todo000680 (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 _todo002389 (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 _todo000741 (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 _todo000740 (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 _todo000742 (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 _todo002390 (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 _todo000353 (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 _todo000370 (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 _todo000364 (user): Investigate if sorting paths per cost improves solutions. \anchor _todo000363 (user): Investigate if ChristofidesPathSolver should not return a status to bail out fast in case of problem. \anchor _todo000361 (user): Support pickup & delivery. \anchor _todo000362 (user): Add robustness to fixed arcs by collapsing them into meta- nodes. </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 _todo000615 (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 _todo000613 (user): Make this code available as an independent algorithm. \anchor _todo000614 (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::CLPInterface Member \_internalref classoperations__research_1_1CLPInterface#adbecc3c53101ed075d7078a7ea8f3e19 "operations_research::CLPInterface::ExtractNewVariables" () override</dt><dd> \anchor _todo000744 (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 _todo000612 (user): Handle infeasible cases if this algorithm is used outside of Christofides. </dd> <dt> \_setscope operations_research::ConstrainedShortestPathsOnDagWrapper Member \_internalref classoperations__research_1_1ConstrainedShortestPathsOnDagWrapper#a99484695ce9be38a707ce339c47060c5 "operations_research::ConstrainedShortestPathsOnDagWrapper< GraphType >::RunConstrainedShortestPathOnDag" ()</dt><dd> \anchor _todo000617 (b/314756645): Include lower bound on the resources to increase pruning. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#a25f46b686d6f253f53dc77ac9f52b4b6 "operations_research::ConvertFlowModelToDimacs" (const FlowModelProto &flow_model, std::string *dimacs)</dt><dd> \anchor _todo000713 (user): This currently only works for min cost flow problem. </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 _todo000002 (user): replace std::function by absl::FunctionRef here and in BinarySearch(). \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.</dd> <dt> \_setscope operations_research::CplexInterface Member \_internalref classoperations__research_1_1CplexInterface#a6dfd72260599acdb0d30d0eb612a9b2c "operations_research::CplexInterface::ExtractNewVariables" ()</dt><dd> \anchor _todo000746 : 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 _todo000747 : 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 _todo000745 : 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 _todo000216 (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 _todo001025 (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 _todo000163 (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 _todo000159 (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 _todo000326 (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 _todo000327 (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 _todo001020 (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 _todo002400 (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 _todo002393 (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 _todo002391 (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 _todo002392 (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 _todo000624 (user): Configure SWIG to handle the GroupForwardArcsByFunctor member template and the CycleHandlerForAnnotatedArcs class. </dd> <dt> \_setscope operations_research::ElementIterator Class \_internalref classoperations__research_1_1ElementIterator "operations_research::ElementIterator< Set >" </dt><dd> \anchor _todo000638 (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 _todo000282 (user): Apply -pointer-following. </dd> <dt> \_setscope operations_research::FilteredHeuristicLocalSearchOperator Class \_internalref classoperations__research_1_1FilteredHeuristicLocalSearchOperator "operations_research::FilteredHeuristicLocalSearchOperator" </dt><dd> \anchor _todo000323 (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 _todo000324 (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 _todo000783 (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 _todo000227 (user): Support skipping neighborhood checks with LNS (at least on the non-LNS operators). \anchor _todo000226 (user): Support skipping neighborhood checks for limits accepting more than one solution (e.g. best accept). For now re-enabling systematic checks. </dd> <dt> \_setscope operations_research::FindOneNeighbor Member \_internalref classoperations__research_1_1FindOneNeighbor#a25667f46f98b5158a6d89bcf93a07b46 "operations_research::FindOneNeighbor::Next" (Solver *solver) override</dt><dd> \anchor _todo000231 (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 _todo000228 (user) : SyncNeed(assignment_) ? \anchor _todo000229 (user): Don't call both if no filter is incremental and one of them returned false. \anchor _todo000232 (user): Compare assignments in addition to their cost. \anchor _todo000230 (user): support the case were limit_ accepts more than one solution (e.g. best accept). </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#a108e0d0f765ed56abc079b49c521915b "operations_research::FormatStatistic" (absl::string_view name, T value, RoutingOutputFormat format)</dt><dd> \anchor _todo001023 (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 _todo000622 (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 _todo000623 (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 _todo000407 (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 _todo000409 (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 _todo000411 (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 _todo000405 (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 _todo000406 (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 _todo000419 (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 _todo000418 (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 _todo000408 (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 _todo000410 (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 _todo000423 (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 _todo000667 (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 _todo000666 (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 _todo000653 (user): Investigate more and maybe write a publication :) \anchor _todo000654 (user): This is another argument for another anti-overflow algorithm. \anchor _todo000652 (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. </dd> <dt> \_setscope operations_research::GenericMaxFlow Member \_internalref classoperations__research_1_1GenericMaxFlow#a20139b839cd5764939afc8df968a2484 "operations_research::GenericMaxFlow< Graph >::InitializePreflow" ()</dt><dd> \anchor _todo000651 (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 _todo000659 (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 _todo000655 (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 _todo000657 (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. \anchor _todo000656 (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.</dd> <dt> \_setscope operations_research::GenericMaxFlow Member \_internalref classoperations__research_1_1GenericMaxFlow#a91d754521a7d43dd215e5d6200ec1062 "operations_research::GenericMaxFlow< Graph >::RefineWithGlobalUpdate" ()</dt><dd> \anchor _todo000658 (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 _todo000650 (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 _todo000678 (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 _todo000669 (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#a838df3808f198b2cbc781e426a601b29 "operations_research::GetBestScalingOfDoublesToInt64" (const std::vector< double > &input, int64_t max_absolute_sum, double *scaling_factor, double *max_relative_coeff_error)</dt><dd> \anchor _todo002375 (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 _todo000354 (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 _todo000846 (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 _todo000513 (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 _todo000854 (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 _todo000843 (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 _todo000428 (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 _todo000426 (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 _todo000425 (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 _todo000607 (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 _todo000608 (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 _todo000869 (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 _todo000864 (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 _todo000845 (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 _todo000840 (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 _todo000502 (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 _todo000497 (user): Get rid of the FIXED status instead to avoid spending time/memory for no good reason here. \anchor _todo000498 (user): There is probably some more robust ways. \anchor _todo000499 (user): make a smarter choice of which column to delete, and swap col[] and coeff[] accordingly. \anchor _todo000500 (user): consider skipping the problematic rows in this preprocessor, or trying harder to avoid the under/overflow. \anchor _todo000501 (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 _todo000481 (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 _todo000429 (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 _todo000503 (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 _todo000504 (user): This will break if PopulateFromDual() is changed. so document the convention or make the function fill these vectors? \anchor _todo000505 (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 _todo000520 (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 _todo000433 (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 _todo000431 (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. \anchor _todo000430 (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. </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 _todo000432 (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 _todo000842 (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 _todo000511 (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 _todo000510 (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 _todo000477 (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 _todo000478 (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 _todo000476 (user) : Replace SumWithNegativeInfiniteAndOneMissing and SumWithPositiveInfiniteAndOneMissing with IntervalSumWithOneMissing. \anchor _todo000479 (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 _todo000480 (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 _todo000838 (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 _todo000868 (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 _todo000833 (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 _todo000828 (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 _todo000830 (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 _todo000832 (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 _todo000827 (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 _todo000834 (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 _todo000835 (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 _todo000831 (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 _todo000451 (user): Currently, this is only modified when the simplex code is executed. \anchor _todo000452 (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 _todo000438 (user): Try to also check the precision of an INFEASIBLE or UNBOUNDED return status. \anchor _todo000439 (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 _todo000450 (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 _todo000436 (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 _todo000437 (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 _todo000455 (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 _todo000454 (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 _todo000470 (user): Run them in the loop above if the effect on the running time is good. This needs more investigation. \anchor _todo000471 (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 _todo000456 (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 _todo000457 (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 _todo000458 (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 _todo000509 (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 _todo000465 (user): Special case if row_non_zero_[pivot_row].size() == 1? \anchor _todo000466 (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 _todo000856 (user): implement strong proto validation in the linear solver server and re-use it here. \anchor _todo000855 (user): clean up loops to use natural range iteration. </dd> <dt> \_setscope operations_research::glop::Preprocessor Class \_internalref classoperations__research_1_1glop_1_1Preprocessor "operations_research::glop::Preprocessor" </dt><dd> \anchor _todo000508 (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 _todo000514 (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 _todo000532 (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 _todo000534 (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 _todo000473 (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 _todo000474 (user): Already return such a mapping from FindProportionalColumns()? \anchor _todo000475 (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 _todo000867 (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 _todo000529 (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 _todo000528 (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#ac81a24729018987c4d0668b7dc92b7c7 "operations_research::glop::RevisedSimplex::ComputeDictionary" (const DenseRow *column_scales)</dt><dd> \anchor _todo000589 (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 _todo000544 (user): Count what is missing. </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 _todo000543 (user): We should re-check for feasibility at this point and apply clean-up as needed. \anchor _todo000542 (user): we currently skip the DUAL_INFEASIBLE status because the quantities are not up to date in this case. \anchor _todo000541 (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 _todo000540 (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 _todo000539 (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 _todo000538 (user): Note that if there was cost shifts, we just keep them until the end of the optim. \anchor _todo000537 (user): Not ideal in an incremental setting. \anchor _todo000536 (user): Avoid doing the first phase checks when we know from the incremental solve that the solution is already dual or primal feasible. </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 _todo000593 (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 _todo000592 (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 _todo000839 (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 _todo000857 (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 _todo000858 (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 _todo000512 (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 _todo000506 (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 _todo000495 (user): It seems better to process all the singleton columns with a cost of zero first. \anchor _todo000496 (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 _todo000841 (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 _todo000870 (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 _todo000871 (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 _todo000876 (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 _todo000872 (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 _todo000875 (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 _todo000874 (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 _todo000837 (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 >" </dt><dd> \anchor _todo000836 (user): This should probably move into ITIVector, but note that this version is more strict 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 _todo000860 (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 _todo000863 (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 _todo000862 (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 _todo000861 (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 _todo000488 (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 _todo000482 (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 _todo000487 (user): It should probably work with only small modification, investigate. \anchor _todo000486 (user): this also works if the variable is integer, but we must choose an integer value during the post-solve. Implement this. \anchor _todo000485 (user): deal with the more generic case. \anchor _todo000484 (user): expose this as a parameter? IMO it isn't really needed as we shouldn't reach this limit except in corner cases. \anchor _todo000483 (user): Expose it as a parameter. We could rename both to preprocessor_low_tolerance and preprocessor_high_tolerance. </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 _todo000594 (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 _todo000597 (user): automate the computation of these constants at run-time? \anchor _todo000596 (user): The impact is not as high as I hopped though, so not too important. \anchor _todo000595 (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). </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 _todo000599 (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 _todo000606 (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 _todo000609 (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 _todo000602 (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 _todo000600 (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 _todo000749 (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 _todo000748 (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#a1ee695f58f621e16b25ee9e437ac26b2 "operations_research::GlopSolveProto" (MPModelRequest request, std::atomic< bool > *interrupt_solve, std::function< void(const std::string &)> logging_callback)</dt><dd> \anchor _todo000788 (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 _todo000750 (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 _todo000751 (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 _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 _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 _todo000026 (user): verify the minimality in unit tests. \anchor _todo000015 (user): better, more complete explanation. </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#ab50373b232711b27f49e7802c206d581 "operations_research::GreedySolutionGenerator::NextSolution" ()</dt><dd> \anchor _todo000047 (user): Add time-outs and exit with a partial solution. </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 _todo000041 (user): build in O(N) instead of O(n lg(N)). </dd> <dt> \_setscope operations_research::GScip Member \_internalref classoperations__research_1_1GScip#ab7136ff892af60a8dd914f5953f39e9b "operations_research::GScip::SetBranchingPriority" (SCIP_VAR *var, int priority)</dt><dd> \anchor _todo000722 (user): Add support for BranchingFactor as well, this is typically more useful. </dd> <dt> \_setscope operations_research::GScip Member \_internalref classoperations__research_1_1GScip#ab1e8e1eb53b45e5a8199f9085b99e601 "operations_research::GScip::SetLb" (SCIP_VAR *var, double lb)</dt><dd> \anchor _todo000720 (b/246342145): A crash may occur if you attempt to set a lb <= -1.0 on a binary variable. SCIP can also silently change the vartype of a variable after construction, so you should check it via <tt>VarType()</tt>. </dd> <dt> \_setscope operations_research::GScip Member \_internalref classoperations__research_1_1GScip#afbb8ce39eb848e6f1ad16e1846bab991 "operations_research::GScip::SetLinearConstraintCoef" (SCIP_CONS *constraint, SCIP_VAR *var, double value)</dt><dd> \anchor _todo000718 (user): this operation is slow (linear in the nnz in the constraint). It would be better to just use a bulk operation, but there doesn't appear to be any? </dd> <dt> \_setscope operations_research::GScip Member \_internalref classoperations__research_1_1GScip#ad8b6b87e1106371b67be3c718c9bc8b8 "operations_research::GScip::SetUb" (SCIP_VAR *var, double ub)</dt><dd> \anchor _todo000721 (b/246342145): A crash may occur if you attempt to set an ub >= 2.0 on a binary variable. SCIP can also silently change the vartype of a variable after construction, so you should check it via <tt>VarType()</tt>. </dd> <dt> \_setscope operations_research::GScip Member \_internalref classoperations__research_1_1GScip#abd814a95231026c9313c8dc2284ac4a5 "operations_research::GScip::Solve" (const GScipParameters &params=GScipParameters(), absl::string_view legacy_params="", GScipMessageHandler message_handler=nullptr, const Interrupter *interrupter=nullptr)</dt><dd> \anchor _todo000719 (user): refactor this into a new method. </dd> <dt> \_setscope operations_research::GScipConstraintHandlerContext Class \_internalref classoperations__research_1_1GScipConstraintHandlerContext "operations_research::GScipConstraintHandlerContext" </dt><dd> \anchor _todo000725 (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 _todo000729 (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 _todo000727 (user): Support Var and Row events. \anchor _todo000728 (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 _todo000731 (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::GScipQuadraticRange Member \_internalref structoperations__research_1_1GScipQuadraticRange#a625a69d159292a2c717436158af9bece "operations_research::GScipQuadraticRange::quadratic_variables1" </dt><dd> \anchor _todo000723 (user): investigate, the documentation seems to suggest that when linear_variables[i] == quadratic_variables1[i] == quadratic_variables2[i] there is some advantage. </dd> <dt> \_setscope operations_research::GuidedTabuSearch Member \_internalref classoperations__research_1_1GuidedTabuSearch#a3b432dccc848e7c957cfe8e4ebb3919a "operations_research::GuidedTabuSearch::NextSolution" (const std::vector< 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 _todo000049 (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 _todo000755 (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 _todo000758 (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 _todo000757 (user): This reset may not be necessary, investigate. </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 _todo000754 (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 _todo000753 (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 _todo000756 (user): We could introduce our own "infeasible or unbounded" status. </dd> <dt> \_setscope operations_research::HamiltonianPathSolver Member \_internalref classoperations__research_1_1HamiltonianPathSolver#ab7380d5367176d7d567876433d1dd918 "operations_research::HamiltonianPathSolver< CostType, CostFunction >::Integer" </dt><dd> \anchor _todo000645 (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 _todo000151 (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 _todo000761 (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 _todo000760 (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 _todo000762 (user): Consider returning the SolveLog here, as it could be essential for interpreting the PDLP solution. </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 _todo000371 (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 _todo000372 (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 _todo002376 (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 _todo000036 (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. </dd> <dt> \_setscope operations_research::internal::MPSLineInfo Member \_internalref classoperations__research_1_1internal_1_1MPSLineInfo#a86c8ac962db03549a6a2ae20911e8c23 "operations_research::internal::MPSLineInfo::IsNewSection" () const</dt><dd> \anchor _todo000853 (b/284163180): Fix handling of sections and data in <tt>free_form</tt>. Returns true if the line defines a new section. </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 _todo000184 (user): Check and maybe inline this code. \anchor _todo000185 (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 _todo000186 (user): use a clean and safe SortedUniqueCopy() class that uses a global, static shared (and locked) storage. \anchor _todo000187 \anchor _todo000188 (user): [optional] consider porting STLSortAndRemoveDuplicates from ortools/base/stl_util.h to the existing base/stl_util.h and using it here. \anchor _todo000189 \anchor _todo000190 (user): We could filter out values not in the var. \anchor _todo000191 (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 _todo000369 (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 _todo000153 (user): make it pure virtual, implies porting all apps overriding MakeNextNeighbor() in a subclass of IntVarLocalSearchOperator. \anchor _todo000214 (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 _todo000766 (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 _todo000765 (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 _todo000764 (user): Refine Analysis of the model to choose better solvers. </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 _todo000639 (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 _todo000644 (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 _todo000342 (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 _todo000335 (user): extend to relocating before the start of sub-tours (when all pairs have been matched). \anchor _todo000336 (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 _todo000767 (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 _todo000358 (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 _todo000325 (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 _todo000238 (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 _todo000233 (user): abstract this from the local search part (user): handle the case where the tree depth is not enough to hold all solutions. \anchor _todo000234 (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 _todo000157 (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 _todo000224 (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 _todo000225 (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 _todo000158 (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 _todo000152 (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 _todo000223 (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 _todo001019 (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 _todo000217 (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 _todo000341 (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 _todo000339 (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 _todo000334 (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 _todo000932 (b/178702980): this should not be needed IWYU pragma: no_include <type_traits> </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 _todo000918 (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 _todo000885 (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#abd2e26542d0c64cb9bdb653e943cd892 "operations_research::math_opt::CheckIdsSubset" (absl::Span< const int64_t > ids, const IdNameBiMap &universe, std::optional< int64_t > upper_bound)</dt><dd> \anchor _todo000988 (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 _todo000888 (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 _todo000884 (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 _todo000882 (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 _todo000883 (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#ae0dd8a4b4d2f341b1300cf539b74bcda "operations_research::math_opt::GlpkSolver::Solve" (const SolveParametersProto &parameters, const ModelSolveParametersProto &model_parameters, MessageCallback message_cb, const CallbackRegistrationProto &callback_registration, Callback cb, SolveInterrupter *interrupter) override</dt><dd> \anchor _todo000942 (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. \anchor _todo000940 (b/187027049): add solver specific parameters for glp_iptcp.ord_alg. \anchor _todo000938 (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 _todo000939 (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 _todo000941 (b/187027049): add option to use glp_exact(). </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 _todo000950 (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#ab38e5151045e42072028984828eeefc5 "operations_research::math_opt::GurobiSolver::ComputeInfeasibleSubsystem" (const SolveParametersProto &parameters, MessageCallback message_cb, SolveInterrupter *interrupter) override</dt><dd> \anchor _todo000967 (b/277246682): ensure that resetting parameters does not degrade incrementalism performance. \anchor _todo000966 (b/277339044): Remove code duplication with GurobiSolver::Solve(). </dd> <dt> \_setscope operations_research::math_opt::GurobiSolver Member \_internalref classoperations__research_1_1math__opt_1_1GurobiSolver#a26f4dd4213100e750b8253e394abf91a "operations_research::math_opt::GurobiSolver::Solve" (const SolveParametersProto &parameters, const ModelSolveParametersProto &model_parameters, MessageCallback message_cb, const CallbackRegistrationProto &callback_registration, Callback cb, SolveInterrupter *interrupter) override</dt><dd> \anchor _todo000965 (b/277246682): ensure that resetting parameters does not degrade incrementalism performance. </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 _todo000890 (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::InvalidInputTest Class \_internalref classoperations__research_1_1math__opt_1_1InvalidInputTest "operations_research::math_opt::InvalidInputTest" </dt><dd> \anchor _todo000919 (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 _todo000895 (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#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 _todo000889 (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 _todo000911 (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 _todo000924 (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 _todo000913 (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 _todo000899 (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 _todo000898 (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 _todo000897 (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 _todo000900 : b/315974557 - Return an error if a RepeatedField is too long. \anchor _todo000901 (b/183616124): consolidate code. Probably best to add an export_to_proto to IdMap </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 _todo000914 (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 _todo000887 (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 _todo000973 (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#af7ba8f15f41011f5b8109d7bef66511f "operations_research::math_opt::operator<<" (std::ostream &ostr, const QuadraticConstraint &constraint)</dt><dd> \anchor _todo000878 (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 _todo000894 (b/170992529): handle quoting of invalid characters in the name. </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 _todo000912 (b/170992529): handle quoting of invalid characters in the name. </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 _todo000877 (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 _todo000902 (b/170992529): handle quoting of invalid characters in the name. </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 _todo000910 (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#ab1d61842701172037b05e011df664d90 "operations_research::math_opt::operator<<" (std::ostream &ostr, const LinearExpression &expression)</dt><dd> \anchor _todo000909 (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#af810f3a175629e517744c9f265470b61 "operations_research::math_opt::operator<<" (std::ostream &ostr, const Sos2Constraint &constraint)</dt><dd> \anchor _todo000881 (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 _todo000879 (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 _todo000880 (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 _todo000886 (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 _todo000969 (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 _todo000930 (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#aa9c5136714d04b0c012116a57d64585f "operations_research::math_opt::Solver::Solve" (const SolveArgs &arguments)</dt><dd> \anchor _todo000892 (b/290091715): Remove once language specific structs can use new messages. \anchor _todo000891 (b/168037341): we should validate the result maths. Since the result can be filtered, this should be included in the solver_interface implementations. </dd> <dt> \_setscope operations_research::math_opt::SolveResult Member \_internalref structoperations__research_1_1math__opt_1_1SolveResult#a2f2ad92942a8f4f841234b15c911f472 "operations_research::math_opt::SolveResult::FromProto" (const ModelStorage *model, const SolveResultProto &solve_result_proto)</dt><dd> \anchor _todo000905 (b/290091715): Remove once solve_stats proto no longer has best_primal/dual_bound/problem_status and problem_status/objective_bounds are guaranteed to be present in termination proto. </dd> <dt> \_setscope operations_research::math_opt::SolveResult Member \_internalref structoperations__research_1_1math__opt_1_1SolveResult#af140dea39dec0ce602200f2d2b0cc2e9 "operations_research::math_opt::SolveResult::Proto" () const</dt><dd> \anchor _todo000908 (b/231134639): investigate removing the oneof from the proto. </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 _todo000896 (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 _todo000984 (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 _todo000986 (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 _todo000983 (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 _todo000985 (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 _todo000987 (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 _todo000977 (b/233630053) use iterator API. \anchor _todo000976 (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 _todo000974 (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 _todo000979 (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 _todo000981 (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 _todo000980 (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 _todo000975 (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 _todo000982 (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 _todo000978 (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#af377d01c6b7a7ccfa6b9e01da924eecf "operations_research::math_opt::Termination::Feasible" (bool is_maximize, Limit limit, double finite_primal_objective, std::optional< double > optional_dual_objective=std::nullopt, std::string detail={})</dt><dd> \anchor _todo000907 (b/290359402): Consider improving to require a finite dual bound when dual feasible solutions are returned. </dd> <dt> \_setscope operations_research::math_opt::Termination Member \_internalref structoperations__research_1_1math__opt_1_1Termination#ad5e9dd557955e70d58d64666170ae6e8 "operations_research::math_opt::Termination::NoSolutionFound" (bool is_maximize, Limit limit, std::optional< double > optional_dual_objective=std::nullopt, std::string detail={})</dt><dd> \anchor _todo000906 (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#ac51b998f0ab120a1855bd589f2553fad "operations_research::math_opt::ValidateResult" (const SolveResultProto &result, const ModelSolveParametersProto &parameters, const ModelSummary &model_summary)</dt><dd> \anchor _todo000990 (b/290091715): Remove once problem_status and objective bounds are removed from solve_stats and their presence is guaranteed in termination. \anchor _todo000991 (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 _todo000993 (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 _todo000989 (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 _todo000995 (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 _todo000663 (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 _todo000679 (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 _todo000704 (user): We can easily shift all costs if negative costs are needed. \anchor _todo000705 (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 _todo000702 (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 _todo000703 (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 _todo000683 (user): Improve the overflow detection if needed. The current one seems ok though. \anchor _todo000684 (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 _todo000813 (user): Enable interrupt_solve. \anchor _todo000812 \anchor _todo000811 (user): Enable log_callback support. </dd> <dt> \_setscope operations_research::MPSolver Member \_internalref classoperations__research_1_1MPSolver#a84aec4c6ee3b17edc9979b12ecdb5f63 "operations_research::MPSolver::ComputeConstraintActivities" () const</dt><dd> \anchor _todo000774 (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 _todo000771 (user): remove this step. \anchor _todo000770 (user): Add option to avoid filling the var name to avoid overly large protocol buffers. </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 _todo000772 (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 _todo000773 (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 _todo000775 (user): split. </dd> <dt> \_setscope operations_research::MPSolverInterface Member \_internalref classoperations__research_1_1MPSolverInterface#ac11b5863b3866e251564de9a5dcfb92e "operations_research::MPSolverInterface::MPSolverInterface" (MPSolver *solver)</dt><dd> \anchor _todo000776 (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 _todo000777 (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 _todo000778 (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 _todo000779 (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::MPSReaderTemplate Member \_internalref classoperations__research_1_1MPSReaderTemplate#a869ef12982e257cfc432773dae4b3d6a "operations_research::MPSReaderTemplate< DataWrapper >::MPSReaderTemplate" ()</dt><dd> \anchor _todo000852 (user): Support 'SI' (semi integer). </dd> <dt> \_setscope operations_research::NearestNeighbors Member \_internalref classoperations__research_1_1NearestNeighbors#af61cd5ece87302a1054745def342cf71 "operations_research::NearestNeighbors::Initialize" ()</dt><dd> \anchor _todo000219 (user): recompute if node changes path ? </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 _todo000382 (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 _todo000239 (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 _todo000337 (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 _todo000998 (user): Move naming code to parser. </dd> <dt> \_setscope operations_research::PathContainerImpl Class \_internalref classoperations__research_1_1PathContainerImpl "operations_research::PathContainerImpl" </dt><dd> \anchor _todo000708 (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 _todo000220 (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 _todo000156 (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 _todo000155 (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 _todo000154 (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 _todo001017 (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 _todo001018 (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 _todo001014 (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 _todo001012 (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 _todo001013 (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 _todo000786 (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 _todo000785 (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 _todo000787 (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 _todo000199 (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 _todo002379 (user): Allow the user to specify the undefined value and use kint64max as the default. </dd> <dt> \_setscope operations_research::PruningHamiltonianSolver Member \_internalref classoperations__research_1_1PruningHamiltonianSolver#aee868e1ea38d845f3da2cb0d38ad6d3f "operations_research::PruningHamiltonianSolver< CostType, CostFunction >::Integer" </dt><dd> \anchor _todo000647 (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 _todo000129 (user): Add profiling to initial propagation \anchor _todo000128 (user): Make to_add_ a queue to make the behavior more obvious. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#ad9e6cb141794cea6160e283e70c283c7 "operations_research::RadixSort" (absl::Span< T > values)</dt><dd> \anchor _todo000040 (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 _todo000039 (user): See if memcpy everything + memcpy here is faster than memmove(). \anchor _todo000037 : remove the if constexpr so that compilation catches the bad cases. \anchor _todo000038 (user): See if this is faster than memcpy + std::reverse(). </dd> <dt> \_setscope operations_research::RandomSolutionGenerator Class \_internalref classoperations__research_1_1RandomSolutionGenerator "operations_research::RandomSolutionGenerator" </dt><dd> \anchor _todo000045 (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 _todo002381 (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 _todo002382 (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 _todo000058 (user): add proper error handling. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#a69a780b033f05ccd016fa3ce547f90f5 "operations_research::ReadQapProblemOrDie" (const std::string &filepath)</dt><dd> \anchor _todo002380 (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 _todo000218 (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 _todo000397 (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 _todo002384 (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 _todo000352 (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 _todo000333 (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 _todo000332 (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 _todo000322 (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 _todo000288 (user): Perform transitive closure of dimension precedence graphs. \anchor _todo000289 \anchor _todo000290 (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 _todo000801 (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 _todo000802 (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 _todo002083 (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 _todo002078 (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 _todo002086 (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 _todo002080 (user): Ideally these amo should not be added to this class. </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 _todo001902 (user): We could use (capacity / demands_gcd) * demands_gcd. \anchor _todo001904 (user): In some cases, we could have only one task that can be first. \anchor _todo001903 (user): Implement demands_gcd != 1 && capacity is fixed. </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 _todo001606 (user): This is not completely true for empty intervals (start == end). Make sure such intervals are ignored by the constraint. \anchor _todo001588 (user): create them dynamically instead? </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 _todo001914 (user): Move this out of here. \anchor _todo001913 (user): Support linearization of general target expression. </dd> <dt> \_setscope operations_research::sat::AffineExpression Member \_internalref structoperations__research_1_1sat_1_1AffineExpression#ae2df741604041f566520f58d28482eef "operations_research::sat::AffineExpression::var" </dt><dd> \anchor _todo001686 (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 _todo001029 (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 _todo001028 (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 _todo001026 (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 _todo001027 (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 _todo001493 (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 _todo001584 (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 _todo001898 (user): More generally, do not miss the same structure if the bool_and was expanded into many clauses! \anchor _todo001899 (user): It is not 100% clear that just not adding one constraint is worse. Relaxation is worse, but then we have less constraint. \anchor _todo001897 (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.</dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a99c02b5f23ff755783f84c851f8dcbb2 "operations_research::sat::AppendElementEncodingRelaxation" (Model *m, LinearRelaxation *relaxation)</dt><dd> \anchor _todo001915 (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 _todo001907 (user): In LoadLinearConstraint() we already created intermediate Booleans for each disjoint interval, we should reuse them here if possible. \anchor _todo001908 (user): process the "at most one" part of a == 1 separately? \anchor _todo001909 (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 _todo001923 (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 _todo001906 (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 _todo001905 (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 _todo001896 (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 _todo001912 (user): We could add all or some below_hyperplans. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#ab3f18aece2e354382532b24b02e0ca81 "operations_research::sat::ApplyLiteralMappingToBooleanProblem" (const absl::StrongVector< LiteralIndex, LiteralIndex > &mapping, LinearBooleanProblem *problem)</dt><dd> \anchor _todo001037 (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 _todo001150 (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 _todo002126 (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. \anchor _todo002125 (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.</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 _todo002324 (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 _todo002287 (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 _todo002286 (user): We could grow each and keep the real maximum. \anchor _todo002288 (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 _todo001077 (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 _todo001081 (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 _todo001054 (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 _todo001055 (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 _todo001065 (user): Track which literal have new implications, and only process the antecedants of these. \anchor _todo001066 (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 _todo001069 (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. \anchor _todo001067 (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 _todo001068 (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? </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 _todo001064 (user): We could just do it directly though. \anchor _todo001082 (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 _todo001075 (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 _todo001080 (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 _todo001086 (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. \anchor _todo001085 (user): When extracting to cp_model.proto we could be more efficient by extracting bool_and constraint with many lhs terms. </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 _todo001083 (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 _todo001084 (user): Add a limit to make sure this do not take too much time. \anchor _todo001072 (user): Use deterministic limit. (user): Explore the graph instead of just looking at full amo, especially since we expand small ones. </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 _todo001061 (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 _todo001060 (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 _todo001059 (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. \anchor _todo001058 (user): Also consider at most one? </dd> <dt> \_setscope operations_research::sat::BinaryImplicationGraph Member \_internalref classoperations__research_1_1sat_1_1BinaryImplicationGraph#a7e4e6130c59dffa6ab52a1cff24400a2 "operations_research::sat::BinaryImplicationGraph::RemoveFixedVariables" ()</dt><dd> \anchor _todo001063 (user): This might be a bit slow. Do not call all the time if needed, this shouldn't change the correctness of the code. \anchor _todo001062 (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... </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 _todo001071 (user): Detect on the fly is superset already exist. \anchor _todo001070 (user): Shall we presolve it here? </dd> <dt> \_setscope operations_research::sat::BlockedClauseSimplifier Class \_internalref classoperations__research_1_1sat_1_1BlockedClauseSimplifier "operations_research::sat::BlockedClauseSimplifier" </dt><dd> \anchor _todo002195 (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#abf22a8b8635128f673b91dd5bc577544 "operations_research::sat::BooleanLinearConstraint" )(int64_t lower_bound, int64_t upper_bound, std::vector< LiteralWithCoeff > *cst)</dt><dd> \anchor _todo002236 (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 _todo001984 (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 _todo001764 (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 _todo001100 (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 _todo001546 (user): Avoid constructing the cut just to evaluate its efficacy. \anchor _todo001542 (user): do less work, add more stats. \anchor _todo001543 (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 _todo001544 (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 _todo001545 (user): We could keep for each factor the max gain, so that we can decided if it is not even worth trying a factor. </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 _todo002183 (user): we might also find new equivalent variable l => var => l here, but for now we ignore those. \anchor _todo002182 (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 _todo002181 (user): but we shouldn't keep clauses containing removed literals. It is still valid to do so, but it should be less efficient. </dd> <dt> \_setscope operations_research::sat::CanonicalBooleanLinearProblem Class \_internalref classoperations__research_1_1sat_1_1CanonicalBooleanLinearProblem "operations_research::sat::CanonicalBooleanLinearProblem" </dt><dd> \anchor _todo001998 (user): Simplify further the constraints. \anchor _todo001999 (user): Remove the duplication between this and what the sat solver is doing in AddLinearConstraint() which is basically the same. \anchor _todo002000 (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 _todo002002 (user): Use a return status to distinguish errors if needed. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a3f5064fe335d0bd2f67a8c9e3e132b4f "operations_research::sat::CeilSquareRoot" (int64_t a)</dt><dd> \anchor _todo002323 (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 _todo001046 (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 _todo001041 (user): we can fail early in more case, like no more possible path to any of the mandatory node. \anchor _todo001040 (user): both this and the loop on must_be_in_cycle_ might take some time on large graph. Optimize if this become an issue. </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 _todo001039 (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 _todo002084 (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 _todo001053 (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 _todo001078 (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 _todo001052 (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 _todo001050 (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 _todo001051 (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 _todo001079 (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 _todo001590 (user): AddEntry() and ComputeEndMin() could be combined. \anchor _todo001591 (user): Maybe factor out the code? It does require a function with a lot of arguments though. \anchor _todo001592 (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::CompiledConstraint Class \_internalref classoperations__research_1_1sat_1_1CompiledConstraint "operations_research::sat::CompiledConstraint" </dt><dd> \anchor _todo001095 (user): Do we add a Update(solution, var, new_value) method ? (user): Do we want to support Update(solutions, vars, new_values) ? </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 _todo001919 (user): compute connected components of the original problem and split these cuts accordingly. \anchor _todo001918 (user): I am not sure this is still needed. Investigate and explain why or remove. \anchor _todo001917 (user): This is similar to AppendRelaxationForEqualityEncoding() above. Investigate if we can merge the code. \anchor _todo001916 (user): Should we add them to the LP anyway? this isn't clear as we can sometimes create a lot of Booleans like this. </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 _todo001937 (user): Code a custom algo with more precision guarantee? </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a08ac4c44a4524b21806a1ae9839bc5bd "operations_research::sat::ConfigureSearchHeuristics" (Model *model)</dt><dd> \anchor _todo001751 (user): We might want to restart if external info is available. Code a custom restart for this? </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 _todo001388 (user): Implement a routing search. \anchor _todo001389 (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 _todo001390 (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 _todo001387 (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 _todo001760 (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 _todo001762 (user): Probe optional variables. \anchor _todo001761 (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 _todo001763 (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 _todo001929 (user): Support more constraints with enforcement. \anchor _todo001936 (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 _todo001928 (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. \anchor _todo001927 (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. </dd> <dt> \_setscope operations_research::sat::CoreBasedOptimizer Member \_internalref classoperations__research_1_1sat_1_1CoreBasedOptimizer#ab0a342f8fad2c4262b0ddec85b98bdf8 "operations_research::sat::CoreBasedOptimizer::Optimize" ()</dt><dd> \anchor _todo001966 (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 _todo001965 (user): Try to understand exactly why and merge both code path. \anchor _todo001973 (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 _todo001967 (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 _todo001968 (user): This always resets the solver to level zero. Because of that we don't resume a solve in "chunk" perfectly. Fix. \anchor _todo001969 (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 _todo001970 (user): These can be simply removed from the list. \anchor _todo001971 (user): we could keep an objective offset instead. \anchor _todo001979 (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. \anchor _todo001974 (user): Maybe the solver should do it right away. \anchor _todo001972 (user): We can probably be smarter about the cost of the assumptions though. </dd> <dt> \_setscope operations_research::sat::CoreBasedOptimizer Member \_internalref classoperations__research_1_1sat_1_1CoreBasedOptimizer#a0484eb61f8e25adf3dbbcd05e39c7924 "operations_research::sat::CoreBasedOptimizer::OptimizeWithSatEncoding" (const std::vector< Literal > &literals, const std::vector< IntegerVariable > &vars, const std::vector< Coefficient > &coefficients, Coefficient offset)</dt><dd> \anchor _todo001980 (user): - Support resuming for interleaved search. - Implement all core heurisitics. \anchor _todo001958 (user): We could create EncodingNode out of IntegerVariable. \anchor _todo001962 (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 _todo001961 (user): Find multiple core like in the "main" algorithm. This is just trying to solve with assumptions not involving the newly found core. \anchor _todo001960 (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 _todo001959 (user): It could still be beneficial to add one. Experiments. </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 _todo001530 (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 _todo001531 (user): It seems we could use a more advanced lifting function described later in the paper. Investigate. \anchor _todo001532 (user): Experiment without this line that basically disable scoring. \anchor _todo001533 (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 _todo001536 (user): If the Mir*() function is used, we don't need to extend that much the period. Fix. \anchor _todo001534 (user): Change the heuristic to depends on the lp_value of the implied bounds. This way we can exactly match what happen in FlowCoverCutHelper and remove the code there. \anchor _todo001535 (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 _todo001537 (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 _todo001541 (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 _todo001540 (user): compute this in an overflow-safe way. \anchor _todo001538 (user): Merge Boolean terms that are complement of each other. \anchor _todo001539 (user): we currently only deal with Boolean in the cover. Fix. \anchor _todo001569 (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 _todo001190 (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 _todo001380 (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 _todo001366 (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 _todo001365 (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 _todo001363 (user): move in the context. \anchor _todo001367 (user): Decide where is the best place for this. \anchor _todo001368 (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 _todo001364 (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 _todo001369 (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 _todo001373 (user): merge these code instead of doing many passes? \anchor _todo001372 \anchor _todo001374 (user): try to be smarter and avoid looping again if little changed. \anchor _todo001371 (user): revisit when different transformation appear. \anchor _todo001370 (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? </dd> <dt> \_setscope operations_research::sat::CpModelView Class \_internalref classoperations__research_1_1sat_1_1CpModelView "operations_research::sat::CpModelView" </dt><dd> \anchor _todo001402 (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 _todo001403 (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 _todo001900 (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 _todo002251 (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 _todo002121 (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 _todo001582 (user): Use improved energy from demands helper. \anchor _todo001581 (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 _todo001580 (user): Use demands_helper and decomposed energy. </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 _todo001576 (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 _todo001550 (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#ac42512151ce09329c676c59296f4ab6a "operations_research::sat::Cumulative" )(const std::vector< IntervalVariable > &vars, const std::vector< AffineExpression > &demands, AffineExpression capacity, SchedulingConstraintHelper *helper)</dt><dd> \anchor _todo001498 (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 _todo001504 (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. \anchor _todo001503 (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 _todo001502 (user): Handle generic affine relation? \anchor _todo001501 (user): There is a bit of code duplication with the disjunctive precedence propagator. Abstract more? \anchor _todo001500 (user): this require the precedence constraints to be already loaded, and there is no guarantee of that currently. Find a more robust way. \anchor _todo001499 (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 _todo001497 (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 _todo001496 (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 _todo001495 (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 _todo001494 (user): Change that since we have optional interval for this. </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 _todo001511 (user): Improve window_end using envelope of critical event. \anchor _todo001510 (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 _todo001509 \anchor _todo001508 (user): This could be done lazily. \anchor _todo001507 (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 _todo001506 (user): force capacity_max >= 0, fail/remove optionals when 0. \anchor _todo001505 (user): just keep the current direction? </dd> <dt> \_setscope operations_research::sat::CumulativeIsAfterSubsetConstraint Class \_internalref classoperations__research_1_1sat_1_1CumulativeIsAfterSubsetConstraint "operations_research::sat::CumulativeIsAfterSubsetConstraint" </dt><dd> \anchor _todo001513 (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 _todo001512 (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 _todo001744 \anchor _todo001745 (user): unfortunately we can't report it from here. \anchor _todo001746 (user): add heuristic criteria, right now we stop at first one. See above. \anchor _todo001743 (user): We need to add the reason for demand_min and capacity_max. \anchor _todo001742 (user): Add heuristic ordering for creating interesting precedence first. \anchor _todo001741 (user): If the two box cannot overlap because of high demand, use repo.CreateDisjunctivePrecedenceLiteral() instead. \anchor _todo001740 (user): tie-break tasks not fitting in the profile smartly. </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 _todo001514 (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::DebugSolution Member \_internalref structoperations__research_1_1sat_1_1DebugSolution#a75a5eb5425c964642cf9be0cfb6b6c7b "operations_research::sat::DebugSolution::ivar_has_value" </dt><dd> \anchor _todo001687 (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 _todo001161 (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 _todo001151 (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 _todo001681 (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 _todo001474 (user): We could remove these rows from the orbitope. Note that currently this never happen on the miplib (maybe in LNS though). \anchor _todo001475 (user): We don't have any at most one relation on this orbitope, but we could still add symmetry breaking inequality by picking any matrix entry and making it the largest/lowest value on its row. This also work for non-Booleans. \anchor _todo001473 (user): maybe we should simplify the constraint using the variable we fix before choosing the next row to break symmetry on. If there are multiple row involved, we could also take the intersection instead of probably counting the same constraints more than once. \anchor _todo001472 (user): for 2/ and 3/ we could add an at most one constraint on the full orbit if it is not already there! \anchor _todo001476 (user): All choices should be equivalent, but double check? \anchor _todo001471 (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 _todo001470 (user): Compute the stabilizer under the only non-fixed element and iterate! \anchor _todo001469 (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 _todo001468 (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 _todo001467 (user): code the generic approach with orbits and stabilizer. \anchor _todo001465 (user): Doing that is not always good, on cod105.mps, fixing variables instead of letting the innner 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 _todo001466 (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.</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 _todo001925 (user): If we scale more we migth be able to turn it into an integer. \anchor _todo001924 (user): be smarter! we should be able to handle these cases. \anchor _todo001935 (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 _todo001901 (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 _todo001181 (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 Member \_internalref namespaceoperations__research_1_1sat#a33798fe85208035f149a5c124b89b7b4 "operations_research::sat::DisjunctivePrecedenceSearchHeuristic" (Model *model)</dt><dd> \anchor _todo001739 (Fdid): Also compare the second part of the precedence in PrecedenceIsBetter() and not just the interval before? \anchor _todo001738 (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 _todo001737 \anchor _todo001736 (user): tie break by size/start-max </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 _todo001589 (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 _todo001719 (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 _todo001713 (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 _todo002082 (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. \anchor _todo002081 (user): Also use these "deductions" in the solver directly. This is done in good MIP solvers, and we should exploit them more.</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 _todo002085 (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#a024232f8972a7dcb6cbf91ec8fe36fb0 "operations_research::sat::DratProofHandler::ApplyMapping" (const absl::StrongVector< BooleanVariable, BooleanVariable > &mapping)</dt><dd> \anchor _todo001609 (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 _todo002357 (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 _todo002340 (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 _todo002343 (user): We can also deal with more than one enforcement. \anchor _todo002344 (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 _todo002345 (user): We can generalize to non-linear constraint. \anchor _todo002346 (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. \anchor _todo002342 (user): Fix variable right away rather than waiting for next call. \anchor _todo002341 (user): Cover all the cases. </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 _todo001611 (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 _todo001612 (user): Avoid creating a Boolean just to fix it! </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a7a06f4fc45a6ed31a2afe1e20b6ed652 "operations_research::sat::ExactlyOnePerRowAndPerColumn" )(const std::vector< std::vector< Literal > > &graph)</dt><dd> \anchor _todo001047 (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 _todo002354 (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 _todo002355 (user): generalize to non Booleans? \anchor _todo002353 (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. </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 _todo002120 (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 _todo001178 (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 _todo001172 (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 _todo001171 (user): Debug what makes it unsat at this point. \anchor _todo001170 (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 _todo001173 (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 _todo001174 (user): Fully encode variable that are almost fully encoded? \anchor _todo001175 (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 _todo001176 (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 _todo001177 (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 _todo002092 (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 _todo002097 (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. \anchor _todo002093 (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 _todo002094 (user): We could be slightly more generic and subsume some clauses that do not contains last_decision.Negated(). \anchor _todo002095 (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 _todo002096 (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. </dd> <dt> \_setscope operations_research::sat::FeasibilityJumpSolver Class \_internalref classoperations__research_1_1sat_1_1FeasibilityJumpSolver "operations_research::sat::FeasibilityJumpSolver" </dt><dd> \anchor _todo001630 (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 _todo001624 (user): Maybe have one worker with very low restart rate. \anchor _todo001623 \anchor _todo001622 (user): Ideally batch should use deterministic time too so we can just use number of batch for the luby restart. \anchor _todo001621 (user): Tune the improvement constant, maybe use luby. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a300f624fabbec583376b6e87dcb6fbda "operations_research::sat::FillSolveStatsInResponse" (Model *model, CpSolverResponse *response)</dt><dd> \anchor _todo002291 (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#a76d6dd44958673bb83ac31e970539135 "operations_research::sat::FindBestScalingAndComputeErrors" (const std::vector< double > &coefficients, const std::vector< double > &lower_bounds, const std::vector< double > &upper_bounds, int64_t max_absolute_activity, double wanted_absolute_activity_precision, double *relative_coeff_error, double *scaled_sum_error)</dt><dd> \anchor _todo001933 (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. \anchor _todo001926 (user): Make this faster. </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 _todo001464 (user): Change the API to not return an error when the time limit is reached. \anchor _todo001490 (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 _todo001491 (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 _todo001375 (user): we could delete duplicate identical interval, but we need to make sure reference to them are updated. \anchor _todo001376 (user): This is not particularly efficient. </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 _todo001036 (user): Remove them beforehand? \anchor _todo001035 (user): inject the appropriate time limit here. </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 _todo001492 (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 _todo002330 (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 _todo002335 (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 _todo001730 (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 Member \_internalref namespaceoperations__research_1_1sat#a529a0a81c6633bad7cfc0500457497a6 "operations_research::sat::FixedWeightedSumReif" )(Literal is_eq, const std::vector< IntegerVariable > &vars, const VectorInt &coefficients, int64_t value)</dt><dd> \anchor _todo001724 (user): Simplify if the constant is at the edge of the possible values. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a392d70cc768a13de271f87123513acf2 "operations_research::sat::FloorSquareRoot" (int64_t a)</dt><dd> \anchor _todo002322 (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::FlowCoverCutHelper Member \_internalref classoperations__research_1_1sat_1_1FlowCoverCutHelper#af7fca0dc3ced6d077248ca695664ec7c "operations_research::sat::FlowCoverCutHelper::GenerateCut" (const SingleNodeFlow &data)</dt><dd> \anchor _todo001558 (user): Support int128 demand. \anchor _todo001559 (user): Also try to generate the extended generalized flow cover inequality (EGFCI). \anchor _todo001560 (user): Lift the cut. </dd> <dt> \_setscope operations_research::sat::FlowInfo Struct \_internalref structoperations__research_1_1sat_1_1FlowInfo "operations_research::sat::FlowInfo" </dt><dd> \anchor _todo001565 (user): Altough the cut should still be correct, we might use the same Boolean more than once in the implied bound. Or this Boolean might already appear in the constraint. Not sure if we can do something smarter here. \anchor _todo001564 (user): cover case 3/. We loose a lot of relaxation here, except if the variable is at is upper/lower bound.</dd> <dt> \_setscope operations_research::sat::FlowInfo Member \_internalref structoperations__research_1_1sat_1_1FlowInfo#aa410b7d167f57e67a443c0adc2c6db20 "operations_research::sat::FlowInfo::flow_lp_value" </dt><dd> \anchor _todo001568 (user): We don't use this in the heuristic currently. </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 _todo002326 (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 _todo002331 (user): To reduce memory, we could return some absl::Span in the last layer instead of vector. \anchor _todo002332 (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#a40a7dc0d395ce5d73a04705001e71627 "operations_research::sat::GenerateCompletionTimeCutsWithEnergy" (const std::string &cut_name, std::vector< CtEvent > events, IntegerValue capacity_max, bool skip_low_sizes, Model *model, LinearConstraintManager *manager)</dt><dd> \anchor _todo002253 (user): merge with Packing cuts. \anchor _todo002254 (user): Check overflow and ignore if too big. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a5639ced88667030a20e68a36dc849a43 "operations_research::sat::GenerateCumulativeEnergeticCuts" (const std::string &cut_name, const absl::StrongVector< IntegerVariable, double > &lp_values, std::vector< EnergyEvent > events, const AffineExpression &capacity, TimeLimit *time_limit, Model *model, LinearConstraintManager *manager)</dt><dd> \anchor _todo002250 (user): We could reduce this set. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a6517c71e66173c1ac5c27bad82353081 "operations_research::sat::GenerateCumulativeEnergeticCutsWithMakespanAndFixedCapacity" (absl::string_view cut_name, const absl::StrongVector< IntegerVariable, double > &lp_values, std::vector< EnergyEvent > events, IntegerValue capacity, AffineExpression makespan, TimeLimit *time_limit, Model *model, LinearConstraintManager *manager)</dt><dd> \anchor _todo002247 (user): We could reduce this set. \anchor _todo002248 \anchor _todo002249 (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 _todo001034 (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 _todo001578 (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 _todo001577 (user): merge with Packing cuts. \anchor _todo001579 (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 _todo002252 (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 _todo001683 (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 _todo001676 (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 _todo001679 (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. \anchor _todo001678 (user): Maybe just provide one function Propagate(watch_indices) ? \anchor _todo001677 (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. </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 _todo001680 (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#a5da173a94bec567c831df465aae5c5e4 "operations_research::sat::GetDiverseSetOfParameters" (const SatParameters &base_params, const CpModelProto &cp_model)</dt><dd> \anchor _todo001399 (user): Actually make sure the gap num_workers <-> num_heuristics is contained. \anchor _todo001393 (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 _todo001394 (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 _todo001395 (user): Enable probing_search in deterministic mode. Currently it timeouts on small problems as the deterministic time limit never hits the sharding limit. \anchor _todo001396 (user): Enable shaving search in interleave mode. Currently it do not respect ^C, and has no per chunk time limit. \anchor _todo001397 (user): Enable lb_tree_search in deterministic mode. \anchor _todo001398 (user): Find a better randomization for the seed so that changing random_seed() has more impact? </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#aac3a6347c9f942af0cdca5180a9da297 "operations_research::sat::GetNamedParameters" (const SatParameters &base_params)</dt><dd> \anchor _todo001392 (user): Experiment with search_random_variable_pool_size. \anchor _todo001391 (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. </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 _todo002289 (user): We could reuse the internal memory if needed. </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 _todo001516 (user): This function is not always maximal when size % (max_scaling - 1) == 0. Improve? \anchor _todo001515 (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. </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 _todo001517 (user): Limit the number of value used with scaling like above. \anchor _todo001518 (user): we might want to intoduce some step to reduce the final magnitude of the cut. \anchor _todo001566 (user): Extend it for ci >= max_magnitude, we can probaly "lift" such coefficient. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a20a09de9399643ba3302d007c4663ea2 "operations_research::sat::GetWorkSharingParams" (const SatParameters &base_params, const CpModelProto &cp_model, int num_params_to_generate)</dt><dd> \anchor _todo001400 (user): We could support assumptions, it's just not implemented. </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 _todo001099 (user): This could be optimized by keeping more info from the last Propagate() calls. \anchor _todo001098 (user): In case of a conflict, we could push one of them to false if it is the only one. </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 _todo001586 (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 _todo001948 (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 _todo001947 (user): If we extract more than the objective variables, we could use the solution values from the MPModel as hints to the SAT model. \anchor _todo001940 (user): remove code duplication with MinimizeWithCoreAndLazyEncoding(); \anchor _todo001941 (user): Even though we keep the same solver, currently the solve is not really done incrementally. It might be hard to improve though. \anchor _todo001946 \anchor _todo001942 (user): deal with time limit. \anchor _todo001943 (user): C^c is broken when using SCIP. \anchor _todo001945 (user): Use the real weights and exploit the extra cores. \anchor _todo001944 (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. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#ab3e33c3cfd5add0c1b5cc68be5fe2ab5 "operations_research::sat::Implication" )(const std::vector< Literal > &enforcement_literals, IntegerLiteral i)</dt><dd> \anchor _todo001684 (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 _todo001685 (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 _todo001648 (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 _todo001647 (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 _todo001646 (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 _todo001649 (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 _todo001637 (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. \anchor _todo001636 (user): Check that this never happen? it shouldn't. </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 _todo001638 (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 _todo001553 (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. \anchor _todo001552 (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.</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 _todo001555 (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. \anchor _todo001554 (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.</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 _todo001556 (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 _todo001656 (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 _todo001613 (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 _todo002193 (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 _todo002194 (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 _todo002145 (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 _todo002144 (user): try to enable these? The problem is that we can only remove variables not used the non-pure SAT part of a model. \anchor _todo002143 (user): Add a small wrapper function to time this. \anchor _todo002141 (user): The LP and incremental structure will still be called though, which can take some time, try to disable it more cleanly. \anchor _todo002142 (user): We should probably also disable the variable/clauses activity updates. </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 _todo002139 (user): this break some binary graph invariant. Fix! \anchor _todo002137 (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 _todo002140 (user): Maintain the total number of literals in the watched clauses. \anchor _todo002138 (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. </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 _todo002149 (user): find a way to auto-tune that after a run on borg... \anchor _todo002147 (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 _todo002148 (user): we should output literal to the proof right away, currently if we remove clauses before fixing literal the proof is wrong. \anchor _todo002146 (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. </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 _todo002160 (user): We could also move the watched literal first so we always skip it. \anchor _todo002161 (user): tune the deterministic time. \anchor _todo002159 (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 _todo002158 (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 _todo002157 (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 _todo002156 (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 _todo002150 (user): Use better work limits, see SAT09.CRAFTED.ramseycube.Q3inK12 \anchor _todo002151 (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 _todo002152 (user): We could do that only if we do some reduction, but this is quite fast though. \anchor _todo002153 (user): probably faster without the size indirection. \anchor _todo002154 (user): Storing signatures here might be faster? \anchor _todo002155 (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. </dd> <dt> \_setscope operations_research::sat::IntegerEncoder Class \_internalref classoperations__research_1_1sat_1_1IntegerEncoder "operations_research::sat::IntegerEncoder" </dt><dd> \anchor _todo001682 (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 _todo001689 (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 _todo001659 (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 _todo001688 (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. \anchor _todo001658 (user): Maybe we can optimize the literal creation order and their polarity as our default SAT heuristics initially depends on this.</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 _todo001664 (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 _todo001662 (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 _todo001663 (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 _todo001690 (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 _todo001657 (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 _todo001660 (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 _todo001661 (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 _todo001527 (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). \anchor _todo001526 (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 _todo001525 (user): If the rhs is small and close to zero, we might want to consider different way of complementing the variables. \anchor _todo001522 (user): This is slow, 50% of run time on a2c1s1.pb.gz. Optimize! \anchor _todo001523 (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 _todo001524 (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.</dd> <dt> \_setscope operations_research::sat::IntegerSearchHelper Member \_internalref classoperations__research_1_1sat_1_1IntegerSearchHelper#ac2d4796c1f43982c5c9f31174be82908 "operations_research::sat::IntegerSearchHelper::GetDecision" (const std::function< BooleanOrIntegerLiteral()> &f, LiteralIndex *decision)</dt><dd> \anchor _todo001753 (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 _todo001754 \anchor _todo001755 above. As a work-around, we display a message but do not crash and recall the decision heuristic. \anchor _todo001752 (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. </dd> <dt> \_setscope operations_research::sat::IntegerSearchHelper Member \_internalref classoperations__research_1_1sat_1_1IntegerSearchHelper#aee604e664f5122db61cd4c73f437be2a "operations_research::sat::IntegerSearchHelper::SolveIntegerProblem" ()</dt><dd> \anchor _todo001757 (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 _todo001758 (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 _todo001759 (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 _todo001756 (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#a528e39b17cbbdccc58f61b4db9fd4141 "operations_research::sat::IntegerTrail::AppendNewBoundsFrom" (int base_index, std::vector< IntegerLiteral > *output) const</dt><dd> \anchor _todo001675 (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 _todo001667 (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#aa5f3f24dfc832d45939478360f2a9ef1 "operations_research::sat::IntegerTrail::Enqueue" (IntegerLiteral i_lit, absl::Span< const Literal > literal_reason, absl::Span< const IntegerLiteral > integer_reason)</dt><dd> \anchor _todo001696 (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#ae5d98735536061f5c38f91ddd6a0b073 "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 _todo001697 (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 _todo001665 (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#a090881ffd3442b49e6e858dd6cc9f433 "operations_research::sat::IntegerTrail::Reason" (const Trail &trail, int trail_index) const final</dt><dd> \anchor _todo001674 (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 _todo001693 (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 _todo001694 (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 _todo001695 (user): Test that the code work in the presence of integer overflow. \anchor _todo001666 (user): Get rid of this function and only keep the trail index one? </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 _todo001692 (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 _todo001732 (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 _todo001766 (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 _todo001767 (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 _todo001768 (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::LbTreeSearch Class \_internalref classoperations__research_1_1sat_1_1LbTreeSearch "operations_research::sat::LbTreeSearch" </dt><dd> \anchor _todo001799 (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 _todo001783 (user): if we have many independent LP, this will find nothing. \anchor _todo001782 (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. </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 _todo001784 (user): a strong branching initial start, or allowing a few decision per nodes might be a better approach. \anchor _todo001785 (user): It would also be cool to exploit the reason for the LB increase even more. \anchor _todo001786 (user): No point checking that if the objective lb wasn't assigned at this level. \anchor _todo001787 (user): Exploit the reasons further. \anchor _todo001795 (user): We could do all at once rather than in O(#decision * #size). \anchor _todo001794 (user): Uses old optimal constraint that we just potentially backtracked over? \anchor _todo001793 (user): Try to minimize the number of decisions? \anchor _todo001792 (user): We sometimes branch on the objective variable, this should probably be avoided. \anchor _todo001791 (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 _todo001790 (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 _todo001789 (user): If we remember how far we can backjump for both true/false branch, we could be more efficient. \anchor _todo001788 (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. </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 _todo001708 (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 _todo001709 (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 _todo001033 (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 _todo001803 (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 _todo001800 (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 _todo001805 (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 _todo001806 (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 _todo001804 (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 _todo001808 (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 _todo001809 (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 _todo001816 (user): Experiment with different weights or different functions for computing score. \anchor _todo001817 (user): Instead of comparing num_deletable_constraints with cut limit, compare number of deletable constraints not in lp against the limit. \anchor _todo001815 (user): find better algo, this does 1000 * 4000 scalar product! \anchor _todo001814 (user): This blowup factor could be adaptative w.r.t. the constraint limit. \anchor _todo001813 (user): Because we simplified this constraint, it is possible that it is now a duplicate of another one. Merge them. </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 _todo001819 (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 _todo001821 (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 _todo001820 (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 _todo001717 (user): When the variables are Boolean, use directly the pseudo-Boolean constraint implementation. But we do need support for enforcement literals there. \anchor _todo001716 (user): Explore tree structure to get a log(n) complexity. \anchor _todo001715 (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 _todo001714 (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.</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 _todo001703 (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#abd5b6d0682d0018f82fdce4233f6f576 "operations_research::sat::LinearConstraintPropagator< use_int128 >::LinearConstraintPropagator" (LinearConstraint ct, Model *model)</dt><dd> \anchor _todo001702 (user): deal with this corner case. \anchor _todo001701 (user): Avoid duplication with other constructor. </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 _todo001700 (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 _todo001704 (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 _todo001705 (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 _todo001706 (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 _todo001707 (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 _todo001094 (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 _todo001093 (user): Deal with holes? </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 _todo001092 (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 _todo001823 (user): Deal with/Check double insertion. \anchor _todo001822 (user): Do we use the loader code to detect full encodings and element encodings. </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 _todo001834 (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 _todo001835 (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. </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 _todo001824 (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 _todo001863 (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 _todo001864 (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 _todo001833 (user): Still try to add cuts/constraints though! \anchor _todo001832 \anchor _todo001831 (user): Keep all optimal solution in the current branch? </dd> <dt> \_setscope operations_research::sat::LinearPropagator Class \_internalref classoperations__research_1_1sat_1_1LinearPropagator "operations_research::sat::LinearPropagator" </dt><dd> \anchor _todo001893 (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 _todo001879 (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 _todo001877 (user): we still waste the space in coeffs_buffer_ so that the start are aligned with the variables_buffer_. \anchor _todo001878 (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. </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 _todo001876 (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::Literal Member \_internalref classoperations__research_1_1sat_1_1Literal#a3b27485970070e73266f5530d2a7f55c "operations_research::sat::Literal::operator LiteralIndex" () const</dt><dd> \anchor _todo002124 (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 _todo001463 (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#a0df7b56e0026b783deeeff20487de7cf "operations_research::sat::LoadBooleanProblem" (const LinearBooleanProblem &problem, SatSolver *solver)</dt><dd> \anchor _todo001032 (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 _todo001187 (user): We currently only have the code for Booleans, it is why we currently ignore symmetries involving integer variables. \anchor _todo001169 (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. </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 _todo001722 (user): Remove the conversion! \anchor _todo001723 (user): Remove the conversion! </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 _todo001184 (user): Reuse ComputeLinearBounds()? but then we need another loop to detect if we only have Booleans. \anchor _todo001183 (user): Actually this should never be called since we process linear1 in ExtractEncoding(). </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a899896953b6215b01cb0b85caa96bebe "operations_research::sat::LoadLinearConstraint" (const LinearConstraint &cst, Model *model)</dt><dd> \anchor _todo001721 (user): Remove the conversion! </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 _todo001185 (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 _todo001186 (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 _todo002069 (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 _todo002070 (user): remove code duplication with cp_model_solver. Here we also do not run the heuristic to decide which variable to fully encode. \anchor _todo002071 (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 _todo001168 (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 _todo001152 (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 _todo001167 (user): Restructure code so that we avoid circular dependency with solving functions. For now, we use solve_callback. </dd> <dt> \_setscope operations_research::sat::LsEvaluator Class \_internalref classoperations__research_1_1sat_1_1LsEvaluator "operations_research::sat::LsEvaluator" </dt><dd> \anchor _todo001096 (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 _todo001097 (user): Properly account all big time consumers. </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 _todo002235 (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 _todo001977 (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 _todo001952 (user): tune. \anchor _todo001953 (user): Properly use the node depth instead. </dd> <dt> \_setscope operations_research::sat::MinPropagator Class \_internalref classoperations__research_1_1sat_1_1MinPropagator "operations_research::sat::MinPropagator" </dt><dd> \anchor _todo001718 (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 _todo001710 (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 _todo001950 (user): directly store std::unique_ptr<> in singletons_? </dd> <dt> \_setscope operations_research::sat::ModelCopy Member \_internalref classoperations__research_1_1sat_1_1ModelCopy#aa71276685b3bdc30f73c319014c8ce26 "operations_research::sat::ModelCopy::ImportAndSimplifyConstraints" (const CpModelProto &in_model, bool first_copy=false)</dt><dd> \anchor _todo001354 (user): Merge with the phase 1 of the presolve code. \anchor _todo001357 (user): find a better way than copy then clear_name()? \anchor _todo001356 (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 _todo001355 (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. </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 _todo002334 (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 _todo001987 (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 _todo001989 (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 _todo001988 (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 _todo002003 (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 _todo001162 (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 _todo001147 (user): experiment with resetting the time limit if a solution is found. \anchor _todo001146 (user): Weight more recent data. degrade the current average to forget old learnings. </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 _todo001145 (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. \anchor _todo001142 (user): Maybe relax all variables in the objective when the number is small or negligible compared to the number of variables. \anchor _todo001143 (user): If there is just one component, we can skip some computation. \anchor _todo001144 (user): We could handle some complex domain (size > 2). </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 _todo001140 (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 _todo001141 (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 _todo001163 (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 _todo001127 (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#a8778e9db6fac31eddd2d7308e11e30df "operations_research::sat::NewSatParameters" )(const std::string &params)</dt><dd> \anchor _todo001404 (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 _todo001405 (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#a2de97100bfce300a12937775dd890a59 "operations_research::sat::NewWeightedSum" )(const VectorInt &coefficients, const std::vector< IntegerVariable > &vars)</dt><dd> \anchor _todo001726 (user): invert the coefficients/vars arguments. \anchor _todo001727 (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 _todo001042 (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 _todo001043 (user): only explore node with newly added arcs. \anchor _todo001044 (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 _todo001045 (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 _todo002279 (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 _todo001570 (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 _todo001619 (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 _todo001616 (user): this node is closed and can be removed from the core. \anchor _todo001617 (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 _todo001618 (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. \anchor _todo001615 (user): propagate proper ub first. </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 _todo001995 (user): This is relatively slow. Take the "transpose" all at once, and maybe put small constraints first on the to_update_ lists. \anchor _todo001996 (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 _todo002008 (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 _todo002007 (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 _todo002192 (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 _todo001191 (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 _todo001192 (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::PrecedenceRelations Class \_internalref classoperations__research_1_1sat_1_1PrecedenceRelations "operations_research::sat::PrecedenceRelations" </dt><dd> \anchor _todo002046 (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#ae6ba26762d06d3260f9974270d02375b "operations_research::sat::PrecedenceRelations::Add" (IntegerVariable tail, IntegerVariable head, IntegerValue offset)</dt><dd> \anchor _todo002012 (user): if tail = Negation(head) also update Domain. \anchor _todo002010 (user): Return infeasible if tail == head and offset > 0. \anchor _todo002011 \anchor _todo002013 (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 _todo002014 (user): Support negative offset? \anchor _todo002016 (user): Only explore the sub-graph reachable from "vars". \anchor _todo002015 (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 _todo002052 (user): Be more dynamic as we start to add relations during search. \anchor _todo002017 (user): Also do that if we don't have a DAG? </dd> <dt> \_setscope operations_research::sat::PrecedenceRelations Member \_internalref classoperations__research_1_1sat_1_1PrecedenceRelations#af1bbb310cdf18b3d7faad6e15f99bbca "operations_research::sat::PrecedenceRelations::ComputeFullPrecedences" (const std::vector< IntegerVariable > &vars, std::vector< FullIntegerPrecedence > *output)</dt><dd> \anchor _todo002019 (user): optimize when needed. \anchor _todo002051 (user): Many relations can be redundant. Filter them. \anchor _todo002050 (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 _todo002049 (user): Put some work limit in place, as this can be slow. Complexity is in O(vars.size()) * num_arcs. \anchor _todo002048 (user): generalize. \anchor _todo002020 (user): Release the memory right away. \anchor _todo002018 (user): use vector of fixed size. </dd> <dt> \_setscope operations_research::sat::PrecedencesPropagator Class \_internalref classoperations__research_1_1sat_1_1PrecedencesPropagator "operations_research::sat::PrecedencesPropagator" </dt><dd> \anchor _todo002047 (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#a3a76b9c2a7fae816a7bf98ceb157c658 "operations_research::sat::PrecedencesPropagator::AddGreaterThanAtLeastOneOfConstraints" (Model *model)</dt><dd> \anchor _todo002045 (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 _todo002044 (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 _todo002053 (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::PrecedencesPropagator Member \_internalref classoperations__research_1_1sat_1_1PrecedencesPropagator#a15a72ea359f6b0297496d690fb35d81a "operations_research::sat::PrecedencesPropagator::AddPrecedenceWithOffsetIfNew" (IntegerVariable i1, IntegerVariable i2, IntegerValue offset)</dt><dd> \anchor _todo002030 (user): Modify arc in place! </dd> <dt> \_setscope operations_research::sat::PrecedencesPropagator Member \_internalref classoperations__research_1_1sat_1_1PrecedencesPropagator#a21632ee0a6911bfee9b9cac2cc739584 "operations_research::sat::PrecedencesPropagator::ComputePrecedences" (const std::vector< IntegerVariable > &vars, std::vector< IntegerPrecedences > *output)</dt><dd> \anchor _todo002025 (user): use an order that is always topological? This is not clear since it may be slower to compute and not worth it because the order below is more natural and may work better. \anchor _todo002024 (user): it seems better to ignore negative min offset as we will often have relation of the form interval_start >= interval_end - offset, and such relation are usually not useful. Revisit this in case we see problems where we can propagate more without this test. </dd> <dt> \_setscope operations_research::sat::PrecedencesPropagator Member \_internalref classoperations__research_1_1sat_1_1PrecedencesPropagator#acd56eb01eb354e825014a18a6f2ed1fd "operations_research::sat::PrecedencesPropagator::GetConditionalOffset" (IntegerVariable a, IntegerVariable b)</dt><dd> \anchor _todo002054 (user): Support list of literals, it isn't that much harder. </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 _todo002021 (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 _todo001978 (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 _todo002058 (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 _todo002066 (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 _todo002075 (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 _todo002060 (user): Also test var_to_constraints_ !! </dd> <dt> \_setscope operations_research::sat::PresolveContext Member \_internalref classoperations__research_1_1sat_1_1PresolveContext#ae773a841f916d3caf1eb74caf23aa43b "operations_research::sat::PresolveContext::InsertVarValueEncoding" (int literal, int ref, int64_t value)</dt><dd> \anchor _todo002076 (user): This function is not always correct if !context->DomainOf(ref).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 _todo002077 (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 _todo002073 (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 _todo002074 (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 _todo002068 (user): This is a bit hacky, find a nicer way. \anchor _todo002067 (user): Be more precise with this objective_overflow_detection_ and always keep it up to date on each offset / coeff change. </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 _todo002061 (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 _todo002062 (user): we can do better for overflow by not always choosing the min at zero, do the best things if it becomes needed. \anchor _todo002063 (user): can we force the rep and remove GetAffineRelation()? \anchor _todo002064 (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 _todo002059 rules as this is used to decide if we loop again. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#aa9cd7652ef26e6d69565e1e7e1db3f07 "operations_research::sat::ProbeAndFindEquivalentLiteral" (SatSolver *solver, SatPostsolver *postsolver, DratProofHandler *drat_proof_handler, absl::StrongVector< LiteralIndex, LiteralIndex > *mapping, SolverLogger *logger)</dt><dd> \anchor _todo002271 (user): Fixing a variable might fix more of them by propagation, so we might not fix everything possible with these loops. \anchor _todo002270 (user): check compatibility? if x ~ not(x) => unsat. but probably, the solver would have found this too? not sure... \anchor _todo002269 (user): Add some constraint so that it does?</dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a60a37142e38a0a290d70b030405db801 "operations_research::sat::ProbeAndSimplifyProblem" (SatPostsolver *postsolver, LinearBooleanProblem *problem)</dt><dd> \anchor _todo001038 (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 _todo001954 (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 _todo002090 (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 _todo002101 (user): Rename to include Integer in the name and distinguish better from FailedLiteralProbing() below. \anchor _todo002100 (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 _todo002099 (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 _todo002098 (user): For now we process the Boolean in their natural order, this is not the most efficient.</dd> <dt> \_setscope operations_research::sat::Prober Member \_internalref classoperations__research_1_1sat_1_1Prober#a1323e15e0e075b7a73f7a56e81e42a61 "operations_research::sat::Prober::ProbeDnf" (absl::string_view name, const std::vector< std::vector< Literal > > &dnf)</dt><dd> \anchor _todo002091 (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 _todo002103 (user): The fix point is not yet reached since we don't currently simplify non-binary clauses with these equivalence, but we will. \anchor _todo002102 (user): We can also provide a middle ground and probe all failed literal but do not extract all binary clauses.</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 _todo002104 (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 _todo002105 (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 _todo001641 (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#a93e9dea2213cbcd19a3261b4ab6ad7fd "operations_research::sat::ProductDetector::InitializeBooleanRLTCuts" (const absl::flat_hash_map< IntegerVariable, glop::ColIndex > &lp_vars, const absl::StrongVector< IntegerVariable, double > &lp_values)</dt><dd> \anchor _todo001644 (user): limit work if too many ternary. \anchor _todo001645 (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 _todo001654 (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 _todo001642 (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 _todo001653 (user): Generalize to a * X + b = l * (Y + c) since these are also easy to linearize if we see l * Y. \anchor _todo001643 (user): Linear scan can be bad if b => X = many other variables. Hopefully this will not be common. </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 _todo001655 (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 _todo001712 (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 _todo001106 (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 _todo001180 (user): This is similar to LoadEquivalenceAC() for unreified constraints, but when the later is called, more encoding might have taken place. \anchor _todo001188 (user): In an ideal world, all affine relations like this should be removed in the presolve. \anchor _todo001179 (user): This is not supposed to happen, but apparently it did on once on routing_GCM_0001_sat.fzn. Investigate and fix. </dd> <dt> \_setscope operations_research::sat::ProtoTrail Class \_internalref classoperations__research_1_1sat_1_1ProtoTrail "operations_research::sat::ProtoTrail" </dt><dd> \anchor _todo002361 (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 _todo001734 (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#a78be0e06d6c1f84281b45b79cb946d92 "operations_research::sat::PseudoCosts::GetBestDecisionVar" ()</dt><dd> \anchor _todo002107 (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. \anchor _todo002106 (user): Supports search randomization tolerance. (user): Implement generic class to choose the randomized solution, and supports sub-linear variable selection. </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 _todo001747 (user): Add other policies and perform more experiments. \anchor _todo001749 (user): These distribution values are just guessed values. They need to be tuned. \anchor _todo001750 (user): Also use LP value as assignment like in Bop. \anchor _todo001748 (user): Do more experiments to find better distribution. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a774bb7b95d0309e6e4448b044b88c456 "operations_research::sat::RecordLPRelaxationValues" (Model *model)</dt><dd> \anchor _todo002109 (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 _todo001614 (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::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 _todo001153 (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 _todo001160 (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 _todo001148 (user): Clean-up when target_size == 0. \anchor _todo001149 (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 _todo001159 (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 _todo001585 (user): relax the bounding box dimension to have a relaxed explanation. We can also minimize the number of required intervals. \anchor _todo001583 (user): Also relax the box if possible. </dd> <dt> \_setscope operations_research::sat::RestartPolicy Member \_internalref classoperations__research_1_1sat_1_1RestartPolicy#a52594750ea119a9ac928e3f09b77f140 "operations_research::sat::RestartPolicy::Reset" ()</dt><dd> \anchor _todo002108 (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 _todo001567 (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 _todo002131 (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 _todo002132 (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 _todo002133 (user): avoid looping twice over the trail? \anchor _todo002135 (user): This heuristic can make this code quite slow because all the untrailed variable will cause a priority queue update. \anchor _todo002134 (user): Expose parameters for these values. </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 _todo002276 (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 _todo002275 (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 _todo002196 (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 _todo002273 (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. \anchor _todo002272 (user): Interact more with a SAT solver to reuse its propagation logic.</dd> <dt> \_setscope operations_research::sat::SatPresolver Member \_internalref classoperations__research_1_1sat_1_1SatPresolver#a48d43c858e789a63bf76da7414b55a5f "operations_research::sat::SatPresolver::ClauseIndex" </dt><dd> \anchor _todo002277 (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 _todo002266 (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 _todo002268 (user): At this point x.Variable() is added back to the priority queue. Avoid doing that. \anchor _todo002267 (user): We could only update the priority queue once for each variable instead of doing it many times. </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 _todo002255 (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 _todo002278 (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 _todo002256 (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 _todo002263 (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 _todo002265 (user): remove the old clauses_[ci] afterwards. \anchor _todo002264 (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. </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 _todo002122 (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#a68acada7af835c9c6870ceb876dc2d9c "operations_research::sat::SatPropagator::Untrail" (const Trail &trail, int trail_index)</dt><dd> \anchor _todo002129 (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. \anchor _todo002128 (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.</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 _todo002201 (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 _todo002244 (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 _todo002240 (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 _todo002239 (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 _todo002211 (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 _todo002200 (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 _todo002243 (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 _todo002205 (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 _todo002241 (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 _todo002237 (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 _todo002206 (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 _todo002207 (user): Note that we use the clause above to update the variable activities and not the pb conflict. Experiment. \anchor _todo002208 (user): This is error prone, find a better way? \anchor _todo002209 (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 _todo002210 (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 _todo002221 (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 _todo002222 (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 _todo002242 (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 _todo002238 (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 _todo002072 (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 _todo001934 (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 _todo002347 (user): Maybe we should avoid recomputing that here. \anchor _todo002348 (user): Handle enforcement better here. \anchor _todo002349 (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 _todo002350 (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 _todo002351 (user): Maybe we should avoid recomputing that here. \anchor _todo002352 (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 _todo001873 (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 _todo001076 (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 _todo001771 (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 _todo001772 (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 _todo001778 (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#a230beffeb33f166d27bc233bed77237a "operations_research::sat::SchedulingConstraintHelper::SchedulingConstraintHelper" (int num_tasks, Model *model)</dt><dd> \anchor _todo001776 (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#aac6715a4e5f01196e19399a749218d13 "operations_research::sat::SchedulingConstraintHelper::SetLevel" (int level) final</dt><dd> \anchor _todo001769 (user): We could be smarter here, but then this is not visible in our cpu_profile since we call many times IncrementalPropagate() for each new decision, but just call Propagate() once after each Untrail(). </dd> <dt> \_setscope operations_research::sat::SchedulingConstraintHelper Member \_internalref classoperations__research_1_1sat_1_1SchedulingConstraintHelper#a0829ed1b078db163e11c4114f71758c3 "operations_research::sat::SchedulingConstraintHelper::TaskByIncreasingStartMin" ()</dt><dd> \anchor _todo001777 (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 _todo001775 (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 _todo001774 (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 _todo001780 (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 _todo001781 (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 _todo001773 (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 _todo001735 (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#a8a9624d210768499700918aa0c4eecf2 "operations_research::sat::SeparateFlowInequalities" (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, const absl::StrongVector< IntegerVariable, double > &lp_values, LinearConstraintManager *manager, Model *model)</dt><dd> \anchor _todo002113 (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 _todo002111 (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 _todo002112 (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 _todo001731 (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 _todo002295 (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 _todo002296 (user): We could cleanup added_binary_clauses_ periodically. </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 _todo002294 (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 _todo002292 (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 _todo002297 (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 _todo002298 (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 _todo002300 (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 _todo002299 (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 _todo002358 (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 _todo002359 (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 _todo001733 (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 _todo001985 (user): Use more complex simplification like dividing by the gcd of everyone and using less different coefficients if possible. \anchor _todo001986 (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 _todo002274 (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 _todo001103 (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 _todo001406 (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 _todo001409 (user): Change status to IMPRECISE? \anchor _todo001408 (user): At this point, the model is trivial, but we could exit early. \anchor _todo001407 (user): provide an option to skip this step for speed? \anchor _todo001410 (user): for now, we just use the domain inferred during presolve. \anchor _todo001411 (user): We could try to dump our linear relaxation too. \anchor _todo001412 (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. \anchor _todo001413 (user): Reuse a Subsolver to get the same display as for the parallel case. Right now we don't have as much stats for single thread! </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 _todo001587 (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 _todo000402 (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#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 _todo001189 (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. \anchor _todo001182 (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. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a5154a61154ff9b3522e0c0eba7ed0319 "operations_research::sat::SplitAroundLpValue" (IntegerVariable var, Model *model)</dt><dd> \anchor _todo001729 (user): Why is the reduced cost doing things differently? \anchor _todo001728 (user): Depending if we branch up or down, this might not exclude the LP value, which is potentially a bad thing.</dd> <dt> \_setscope operations_research::sat::SquarePropagator Class \_internalref classoperations__research_1_1sat_1_1SquarePropagator "operations_research::sat::SquarePropagator" </dt><dd> \anchor _todo001720 (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 _todo002163 (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 _todo002162 (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 _todo002198 (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 _todo002168 (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. \anchor _todo002167 below. </dd> <dt> \_setscope operations_research::sat::StampingSimplifier Member \_internalref classoperations__research_1_1sat_1_1StampingSimplifier#ab4ed798d7a5c1b5957e4f9605963174e "operations_research::sat::StampingSimplifier::SampleTreeAndFillParent" ()</dt><dd> \anchor _todo002166 (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). \anchor _todo002165 (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 _todo002164 (user): Better algo to not select redundant parent.</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 _todo002282 (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 _todo002280 (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 _todo002281 (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 _todo002284 (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 _todo002285 (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 _todo002311 (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 _todo002306 (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 _todo002333 (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 _todo002336 (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 _todo001818 (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 _todo002123 (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 _todo002290 (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 _todo001911 (user): Use the same pattern as the other 2 scheduling methods: - single function - generate helpers once \anchor _todo001910 (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. </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 _todo001640 (user): I am not sure how this can happen since size2_affine is supposed to be non-fixed. Maybe we miss some propag. Investigate. \anchor _todo001639 (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. </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 _todo002005 (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 _todo002004 (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 _todo001990 (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 _todo001994 (user): track the cancelation here so we can update *conflict_slack properly. \anchor _todo001993 (user): The best will be to relax as little as possible. \anchor _todo001992 (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 _todo001991 (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(). </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 _todo001104 (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 _todo001105 (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 _todo001801 (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 _todo001983 (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 _todo001101 (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 _todo001102 (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 _todo002356 (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 _todo002337 (user): Use more heuristics to not miss as much dominance relation when we crop initial lists. \anchor _todo002338 (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 _todo002339 (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 _todo002001 (user): With the new SAME_REASON_AS mechanism, this is more general so move out of pb_constraint. </dd> <dt> \_setscope operations_research::sat Member \_internalref namespaceoperations__research_1_1sat#a7eda39f480a5f8b2fca3c10db2045a13 "operations_research::sat::WeightedSumNotEqual" )(const std::vector< IntegerVariable > &vars, const VectorInt &coefficients, int64_t value)</dt><dd> \anchor _todo001725 (user): Simplify if the constant is at the edge of the possible values. </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 _todo002363 (user): Avoid adding duplicates and just randomly pick one. Note that we should also remove duplicate in a generic way. \anchor _todo002362 (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.</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 _todo002365 (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#a33f87ee16f3556183d93b891e7f21fe1 "operations_research::sat::ZeroHalfCutHelper::SymmetricDifference" (const std::vector< int > &a, std::vector< int > *b)</dt><dd> \anchor _todo002364 (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 _todo000798 (user): Implement me. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#a50184e31fae8568937f4d891a7f6582b "operations_research::SatSolveProto" (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 _todo000790 (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 _todo000793 (user): Remove the postsolve hack of copying to a response. \anchor _todo000792 (user): Implement the row and column status. \anchor _todo000791 (user): We put the INFEASIBLE_OR_UNBOUNBED case here since there is no return status that exactly matches it. </dd> <dt> \_setscope operations_research::SavingsFilteredHeuristic::SavingsContainer Member \_internalref classoperations__research_1_1SavingsFilteredHeuristic_1_1SavingsContainer#a540b8ac71e4a7b1341ec7451e0a3df83 "operations_research::SavingsFilteredHeuristic::SavingsContainer< Saving >::Sort" ()</dt><dd> \anchor _todo000366 (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 _todo000804 (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 _todo000803 (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 _todo000807 (user): We could introduce our own "infeasible or unbounded" status. \anchor _todo000806 (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 _todo000805 (user): Is that still true now (2018) ? </dd> <dt> \_setscope operations_research::ScopedFloatingPointEnv Class \_internalref classoperations__research_1_1ScopedFloatingPointEnv "operations_research::ScopedFloatingPointEnv" </dt><dd> \anchor _todo002374 (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 _todo000377 (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 _todo000376 (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#aae2ad7cdc8baaeee65c58c4647899e0f "operations_research::SetCoverInvariant::ComputeImpactedSubsets" (SubsetIndex subset) const</dt><dd> \anchor _todo000054 (user): is it worth to precompute this? </dd> <dt> \_setscope operations_research::SetCoverInvariant Member \_internalref classoperations__research_1_1SetCoverInvariant#a3bf18bb03aa9822dd27b8db515a2097b "operations_research::SetCoverInvariant::RecomputeIsRemovable" ()</dt><dd> \anchor _todo000053 (user): reconsider exposing this. </dd> <dt> \_setscope operations_research::SetCoverMip Member \_internalref classoperations__research_1_1SetCoverMip#a67b99346dad8d9963a7e511760401bcb "operations_research::SetCoverMip::NextSolution" ()</dt><dd> \anchor _todo000055 (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 _todo000815 detect xpress version </dd> <dt> \_setscope operations_research::ShortestPathsOnDagWrapper Member \_internalref classoperations__research_1_1ShortestPathsOnDagWrapper#a9c283a125273e20ec98fc78c29c075c1 "operations_research::ShortestPathsOnDagWrapper< GraphType >::ArcPathTo" (NodeIndex node) const</dt><dd> \anchor _todo000620 (user): 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::SimpleLinearSumAssignment Member \_internalref classoperations__research_1_1SimpleLinearSumAssignment#a613c560fdd07ae94350736adaf2dab56 "operations_research::SimpleLinearSumAssignment::Solve" ()</dt><dd> \anchor _todo000610 (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 _todo000662 (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 _todo000665 (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 _todo000664 (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 _todo000677 (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 _todo000344 (user): Check that performance is acceptable. \anchor _todo000343 (user): Check that performance is acceptable. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#a7e046b2bebd1a0d36b25ec6a97a0ee4e "operations_research::SolveMPModel" (const MPModelRequest &model_request, std::atomic< bool > *interrupt)</dt><dd> \anchor _todo000810 (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#a7b45e72a8b9152d7ac862a2ed80bc749 "operations_research::Solver::Action" )</dt><dd> \anchor _todo000131 (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 _todo000127 (user): Check solver state? </dd> <dt> \_setscope operations_research::Solver Member \_internalref classoperations__research_1_1Solver#aa290140ba6c4d6ef672c792a63bad57c "operations_research::Solver::ClearNeighbors" ()</dt><dd> \anchor _todo000133 (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 _todo000132 (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 _todo000149 (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 _todo000122 (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 _todo000130 (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 _todo000147 (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 _todo000201 (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 _todo000138 (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 _todo000162 (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 _todo000182 (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 _todo000177 (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 _todo000136 (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 _todo000146 (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 _todo000137 (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 _todo000178 (user): Add back simplification code if expr is constant * other_expr. </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 _todo000221 (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#ac78afa51e3d5d28e84916a6fc47375de "operations_research::Solver::MakeOperator" (const std::vector< IntVar * > &vars, IndexEvaluator3 evaluator, EvaluatorLocalSearchOperators op)</dt><dd> \anchor _todo000145 (user): Make the callback an IndexEvaluator2 when there are no secondary variables. </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 _todo000139 (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 _todo000140 (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#a039ebfef32db8ee5641b25328954cce9 "operations_research::Solver::MakePhase" (const std::vector< IntVar * > &vars, IndexEvaluator2 eval, IndexEvaluator1 tie_breaker, EvaluatorStrategy str)</dt><dd> \anchor _todo000381 (user): support tie breaker </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 _todo000144 (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#a84584b7705a787a70e09341e4a0e30f5 "operations_research::Solver::MakePiecewiseLinearExpr" (IntExpr *expr, const PiecewiseLinearFunction &f)</dt><dd> \anchor _todo000134 (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 _todo000142 (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 _todo000183 (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 _todo000141 (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 _todo000135 (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 _todo000125 (user): delete top level search after EndSearch(). \anchor _todo000126 (user): Check if these two lines are still necessary. \anchor _todo000124 (user) : reset statistics </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 _todo000148 (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 _todo000143 (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 _todo002377 (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 _todo002397 (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 _todo002394 (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 _todo002395 (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 _todo002398 (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 _todo000062 (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 _todo000060 (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 _todo000061 (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 _todo000823 useless ? </dd> <dt> \_setscope operations_research::SteepestSearch Member \_internalref classoperations__research_1_1SteepestSearch#a7b76a69a07f9abf4e7cd0ff88925208d "operations_research::SteepestSearch::NextSolution" (int num_iterations)</dt><dd> \anchor _todo000048 (user): Add time-outs and exit with a partial solution. </dd> <dt> \_setscope operations_research Member \_internalref namespaceoperations__research#a4f740c94953f253d0a3b27ae3996e001 "operations_research::SubsetCostVector" </dt><dd> \anchor _todo000056 (user): consider replacing with StrongVectors, which behave differently. The return type for size() is a simple size_t and not an Index as in StrictITIVector, which makes the code less elegant. </dd> <dt> \_setscope operations_research::SubsetPriorityQueue Member \_internalref classoperations__research_1_1SubsetPriorityQueue#afc15acdd067fd3c289892500bd43e83b "operations_research::SubsetPriorityQueue::ChangePriority" (SubsetIndex subset, Cost priority)</dt><dd> \anchor _todo000059 (user): see if the reference to inv_ can be removed. </dd> <dt> \_setscope operations_research::SwapActiveToShortestPathOperator Class \_internalref classoperations__research_1_1SwapActiveToShortestPathOperator "operations_research::SwapActiveToShortestPathOperator" </dt><dd> \anchor _todo000340 (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 _todo000390 (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 _todo002399 (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 _todo002401 (user): The expression "deterministic time" should be replaced with "number of operations" to avoid confusion with "real" time. </dd> <dt> \_setscope operations_research::TrivialSolutionGenerator Class \_internalref classoperations__research_1_1TrivialSolutionGenerator "operations_research::TrivialSolutionGenerator" </dt><dd> \anchor _todo000044 (user): make the different algorithms concurrent, solving independent subproblems in different threads.</dd> <dt> \_setscope operations_research::TrivialSolutionGenerator Member \_internalref classoperations__research_1_1TrivialSolutionGenerator#a72b5cae65519e7893e32e217ef056384 "operations_research::TrivialSolutionGenerator::NextSolution" ()</dt><dd> \anchor _todo000046 (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 _todo001024 (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 _todo000818 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 _todo000819 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 _todo000825 (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 _todo000821 fixme Writing all names worsen the performance significantly if (have_names) { CHECK_STATUS(XPRSaddnames(mLp, XPRS_NAMES_COLUMN, col_names.data(), 0, new_col_count - 1)); } \anchor _todo000820 : 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 _todo000816 : 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 _todo000822 : 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 _todo000824 : remove this workaround when it is handled in XPRESS </dd> <dt> Member \_internalref scip__callback_8cc#a55103a9413973772f122a9c3dfef5030 "SCIP_DECL_CONSENFOPS" (EnforcePseudoSolutionC)</dt><dd> \anchor _todo000799 (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 _todo000800 (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 _todo000287 (user): Find equivalent start/end nodes wrt dimensions and callbacks. </dd> <dt> \_setscope StronglyConnectedComponentsFinder Class \_internalref classStronglyConnectedComponentsFinder "StronglyConnectedComponentsFinder< NodeIndex, Graph, SccOutput >" </dt><dd> \anchor _todo000714 (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 _todo000065 (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 _todo000627 (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 _todo000628 (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 _todo000630 (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 _todo000626 (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 _todo000649 (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 _todo000715 (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 _todo000625 (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 _todo000716 (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 _todo000632 (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 _todo000636 (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 _todo000629 (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 _todo000631 (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 _todo000635 (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 _todo000633 (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 all values within domain.

(user): CHECK all values within domain.

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

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