From c4c94cbfa72095f27ec2be5a4d8008655d355a4c Mon Sep 17 00:00:00 2001 From: Imko Marijnissen Date: Tue, 16 Dec 2025 09:07:20 +0100 Subject: [PATCH 1/6] refactor: create crate for propagators and constraints --- Cargo.lock | 23 ++++ pumpkin-crates/constraints/Cargo.toml | 19 +++ .../src/constraints/all_different.rs | 7 +- .../src/constraints/arithmetic/equality.rs | 25 ++-- .../src/constraints/arithmetic/inequality.rs | 17 +-- .../src/constraints/arithmetic/mod.rs | 15 ++- .../src/constraints/boolean.rs | 17 +-- .../src/constraints/clause.rs | 12 +- .../src/constraints/cumulative.rs | 28 ++--- .../src/constraints/disjunctive_strict.rs | 23 ++-- .../src/constraints/element.rs | 8 +- .../constraints/src/constraints/mod.rs | 46 +++++++ .../src/constraints/table.rs | 16 +-- pumpkin-crates/constraints/src/lib.rs | 2 + pumpkin-crates/core/src/api/mod.rs | 12 +- pumpkin-crates/core/src/api/solver.rs | 2 +- .../src/basic_types/propagation_status_cp.rs | 2 +- pumpkin-crates/core/src/constraints/mod.rs | 54 +------- .../core/src/containers/keyed_vec.rs | 10 +- pumpkin-crates/core/src/containers/mod.rs | 2 +- .../core/src/containers/sparse_set.rs | 34 ++--- pumpkin-crates/core/src/engine/mod.rs | 1 + .../domain_events.rs | 2 +- .../core/src/propagation/constructor.rs | 4 +- .../core/src/propagation/domains.rs | 7 ++ .../src/propagators/arithmetic/binary/mod.rs | 5 - pumpkin-crates/core/src/propagators/mod.rs | 21 +--- .../src/propagators/reified_propagator.rs | 8 +- pumpkin-crates/propagators/Cargo.toml | 21 ++++ pumpkin-crates/propagators/clippy.toml | 7 ++ pumpkin-crates/propagators/src/lib.rs | 2 + .../propagators/arithmetic/absolute_value.rs | 41 +++--- .../arithmetic/binary/binary_equals.rs | 68 +++++----- .../arithmetic/binary/binary_not_equals.rs | 46 ++++--- .../src/propagators/arithmetic/binary/mod.rs | 5 + .../arithmetic/integer_division.rs | 44 +++---- .../arithmetic/integer_multiplication.rs | 46 +++---- .../arithmetic/linear_less_or_equal.rs | 58 ++++----- .../arithmetic/linear_not_equal.rs | 60 +++++---- .../src/propagators/arithmetic/maximum.rs | 42 +++---- .../src/propagators/arithmetic/mod.rs | 8 ++ .../src/propagators/cumulative/mod.rs | 7 +- .../src/propagators/cumulative/options.rs | 14 +-- .../time_table/explanations/big_step.rs | 13 +- .../cumulative/time_table/explanations/mod.rs | 8 +- .../time_table/explanations/naive.rs | 13 +- .../time_table/explanations/pointwise.rs | 23 ++-- .../propagators/cumulative/time_table/mod.rs | 10 +- .../checks.rs | 3 +- .../debug.rs | 13 +- .../insertion.rs | 7 +- .../mod.rs | 2 +- .../removal.rs | 3 +- .../synchronisation.rs | 13 +- .../time_table_over_interval_incremental.rs | 47 +++---- .../per_point_incremental_propagator/mod.rs | 2 +- .../synchronisation.rs | 16 +-- .../time_table_per_point_incremental.rs | 51 ++++---- .../time_table/propagation_handler.rs | 47 ++++--- .../time_table/time_table_over_interval.rs | 49 ++++---- .../time_table/time_table_per_point.rs | 45 +++---- .../cumulative/time_table/time_table_util.rs | 22 ++-- .../src/propagators/cumulative/utils/mod.rs | 1 + .../structs/mandatory_part_adjustments.rs | 0 .../cumulative/utils/structs/mod.rs | 2 +- .../cumulative/utils/structs/parameters.rs | 3 +- .../utils/structs/resource_profile.rs | 3 +- .../cumulative/utils/structs/task.rs | 12 +- .../utils/structs/updatable_structures.rs | 11 +- .../utils/structs/updated_task_info.rs | 0 .../src/propagators/cumulative/utils/util.rs | 14 +-- .../disjunctive/disjunctive_propagator.rs | 42 ++++--- .../disjunctive/disjunctive_task.rs | 2 +- .../src/propagators/disjunctive/mod.rs | 4 +- .../disjunctive/theta_lambda_tree.rs | 22 ++-- .../src/propagators/disjunctive/theta_tree.rs | 15 +-- .../src/propagators/element.rs | 49 ++++---- .../propagators/src/propagators/mod.rs | 18 +++ pumpkin-solver-py/Cargo.toml | 1 + pumpkin-solver-py/src/constraints/globals.rs | 5 +- pumpkin-solver/Cargo.toml | 2 + .../flatzinc/compiler/post_constraints.rs | 119 +++++++++--------- .../src/bin/pumpkin-solver/flatzinc/mod.rs | 2 +- pumpkin-solver/src/bin/pumpkin-solver/main.rs | 6 +- 84 files changed, 864 insertions(+), 747 deletions(-) create mode 100644 pumpkin-crates/constraints/Cargo.toml rename pumpkin-crates/{core => constraints}/src/constraints/all_different.rs (83%) rename pumpkin-crates/{core => constraints}/src/constraints/arithmetic/equality.rs (91%) rename pumpkin-crates/{core => constraints}/src/constraints/arithmetic/inequality.rs (90%) rename pumpkin-crates/{core => constraints}/src/constraints/arithmetic/mod.rs (86%) rename pumpkin-crates/{core => constraints}/src/constraints/boolean.rs (89%) rename pumpkin-crates/{core => constraints}/src/constraints/clause.rs (92%) rename pumpkin-crates/{core => constraints}/src/constraints/cumulative.rs (94%) rename pumpkin-crates/{core => constraints}/src/constraints/disjunctive_strict.rs (83%) rename pumpkin-crates/{core => constraints}/src/constraints/element.rs (73%) create mode 100644 pumpkin-crates/constraints/src/constraints/mod.rs rename pumpkin-crates/{core => constraints}/src/constraints/table.rs (95%) create mode 100644 pumpkin-crates/constraints/src/lib.rs delete mode 100644 pumpkin-crates/core/src/propagators/arithmetic/binary/mod.rs create mode 100644 pumpkin-crates/propagators/Cargo.toml create mode 100644 pumpkin-crates/propagators/clippy.toml create mode 100644 pumpkin-crates/propagators/src/lib.rs rename pumpkin-crates/{core => propagators}/src/propagators/arithmetic/absolute_value.rs (90%) rename pumpkin-crates/{core => propagators}/src/propagators/arithmetic/binary/binary_equals.rs (91%) rename pumpkin-crates/{core => propagators}/src/propagators/arithmetic/binary/binary_not_equals.rs (87%) create mode 100644 pumpkin-crates/propagators/src/propagators/arithmetic/binary/mod.rs rename pumpkin-crates/{core => propagators}/src/propagators/arithmetic/integer_division.rs (93%) rename pumpkin-crates/{core => propagators}/src/propagators/arithmetic/integer_multiplication.rs (93%) rename pumpkin-crates/{core => propagators}/src/propagators/arithmetic/linear_less_or_equal.rs (89%) rename pumpkin-crates/{core => propagators}/src/propagators/arithmetic/linear_not_equal.rs (92%) rename pumpkin-crates/{core => propagators}/src/propagators/arithmetic/maximum.rs (89%) rename pumpkin-crates/{core => propagators}/src/propagators/arithmetic/mod.rs (53%) rename pumpkin-crates/{core => propagators}/src/propagators/cumulative/mod.rs (95%) rename pumpkin-crates/{core => propagators}/src/propagators/cumulative/options.rs (84%) rename pumpkin-crates/{core => propagators}/src/propagators/cumulative/time_table/explanations/big_step.rs (95%) rename pumpkin-crates/{core => propagators}/src/propagators/cumulative/time_table/explanations/mod.rs (97%) rename pumpkin-crates/{core => propagators}/src/propagators/cumulative/time_table/explanations/naive.rs (95%) rename pumpkin-crates/{core => propagators}/src/propagators/cumulative/time_table/explanations/pointwise.rs (96%) rename pumpkin-crates/{core => propagators}/src/propagators/cumulative/time_table/mod.rs (95%) rename pumpkin-crates/{core => propagators}/src/propagators/cumulative/time_table/over_interval_incremental_propagator/checks.rs (99%) rename pumpkin-crates/{core => propagators}/src/propagators/cumulative/time_table/over_interval_incremental_propagator/debug.rs (97%) rename pumpkin-crates/{core => propagators}/src/propagators/cumulative/time_table/over_interval_incremental_propagator/insertion.rs (96%) rename pumpkin-crates/{core => propagators}/src/propagators/cumulative/time_table/over_interval_incremental_propagator/mod.rs (67%) rename pumpkin-crates/{core => propagators}/src/propagators/cumulative/time_table/over_interval_incremental_propagator/removal.rs (99%) rename pumpkin-crates/{core => propagators}/src/propagators/cumulative/time_table/over_interval_incremental_propagator/synchronisation.rs (96%) rename pumpkin-crates/{core => propagators}/src/propagators/cumulative/time_table/over_interval_incremental_propagator/time_table_over_interval_incremental.rs (97%) rename pumpkin-crates/{core => propagators}/src/propagators/cumulative/time_table/per_point_incremental_propagator/mod.rs (53%) rename pumpkin-crates/{core => propagators}/src/propagators/cumulative/time_table/per_point_incremental_propagator/synchronisation.rs (96%) rename pumpkin-crates/{core => propagators}/src/propagators/cumulative/time_table/per_point_incremental_propagator/time_table_per_point_incremental.rs (98%) rename pumpkin-crates/{core => propagators}/src/propagators/cumulative/time_table/propagation_handler.rs (97%) rename pumpkin-crates/{core => propagators}/src/propagators/cumulative/time_table/time_table_over_interval.rs (97%) rename pumpkin-crates/{core => propagators}/src/propagators/cumulative/time_table/time_table_per_point.rs (97%) rename pumpkin-crates/{core => propagators}/src/propagators/cumulative/time_table/time_table_util.rs (98%) rename pumpkin-crates/{core => propagators}/src/propagators/cumulative/utils/mod.rs (91%) rename pumpkin-crates/{core => propagators}/src/propagators/cumulative/utils/structs/mandatory_part_adjustments.rs (100%) rename pumpkin-crates/{core => propagators}/src/propagators/cumulative/utils/structs/mod.rs (93%) rename pumpkin-crates/{core => propagators}/src/propagators/cumulative/utils/structs/parameters.rs (97%) rename pumpkin-crates/{core => propagators}/src/propagators/cumulative/utils/structs/resource_profile.rs (96%) rename pumpkin-crates/{core => propagators}/src/propagators/cumulative/utils/structs/task.rs (89%) rename pumpkin-crates/{core => propagators}/src/propagators/cumulative/utils/structs/updatable_structures.rs (97%) rename pumpkin-crates/{core => propagators}/src/propagators/cumulative/utils/structs/updated_task_info.rs (100%) rename pumpkin-crates/{core => propagators}/src/propagators/cumulative/utils/util.rs (90%) rename pumpkin-crates/{core => propagators}/src/propagators/disjunctive/disjunctive_propagator.rs (94%) rename pumpkin-crates/{core => propagators}/src/propagators/disjunctive/disjunctive_task.rs (92%) rename pumpkin-crates/{core => propagators}/src/propagators/disjunctive/mod.rs (51%) rename pumpkin-crates/{core => propagators}/src/propagators/disjunctive/theta_lambda_tree.rs (97%) rename pumpkin-crates/{core => propagators}/src/propagators/disjunctive/theta_tree.rs (94%) rename pumpkin-crates/{core => propagators}/src/propagators/element.rs (92%) create mode 100644 pumpkin-crates/propagators/src/propagators/mod.rs diff --git a/Cargo.lock b/Cargo.lock index 80f55a0be..a26ae1130 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -735,6 +735,15 @@ dependencies = [ "thiserror", ] +[[package]] +name = "pumpkin-constraints" +version = "0.2.2" +dependencies = [ + "clap", + "pumpkin-core", + "pumpkin-propagators", +] + [[package]] name = "pumpkin-core" version = "0.2.2" @@ -773,6 +782,17 @@ dependencies = [ "syn", ] +[[package]] +name = "pumpkin-propagators" +version = "0.2.2" +dependencies = [ + "bitfield-struct", + "clap", + "convert_case 0.6.0", + "enumset", + "pumpkin-core", +] + [[package]] name = "pumpkin-solver" version = "0.2.2" @@ -783,8 +803,10 @@ dependencies = [ "flatzinc", "log", "pumpkin-checker", + "pumpkin-constraints", "pumpkin-core", "pumpkin-macros", + "pumpkin-propagators", "regex", "signal-hook", "stringcase", @@ -796,6 +818,7 @@ dependencies = [ name = "pumpkin-solver-py" version = "0.2.2" dependencies = [ + "pumpkin-constraints", "pumpkin-solver", "pyo3", "pyo3-build-config", diff --git a/pumpkin-crates/constraints/Cargo.toml b/pumpkin-crates/constraints/Cargo.toml new file mode 100644 index 000000000..4f51b77f3 --- /dev/null +++ b/pumpkin-crates/constraints/Cargo.toml @@ -0,0 +1,19 @@ +[package] +name = "pumpkin-constraints" +version = "0.2.2" +repository.workspace = true +edition.workspace = true +license.workspace = true +authors.workspace = true +description = "The constraints of the Pumpkin constraint programming solver." + +[lints] +workspace = true + +[dependencies] +pumpkin-core = { version = "0.2.2", path = "../core" } +pumpkin-propagators = {version = "0.2.2", path="../propagators", features = ["clap"]} +clap = { version = "4.5.40", optional = true } + +[features] +clap = ["dep:clap"] diff --git a/pumpkin-crates/core/src/constraints/all_different.rs b/pumpkin-crates/constraints/src/constraints/all_different.rs similarity index 83% rename from pumpkin-crates/core/src/constraints/all_different.rs rename to pumpkin-crates/constraints/src/constraints/all_different.rs index dadedc952..e7a2d1d9f 100644 --- a/pumpkin-crates/core/src/constraints/all_different.rs +++ b/pumpkin-crates/constraints/src/constraints/all_different.rs @@ -1,7 +1,8 @@ -use super::Constraint; +use pumpkin_core::constraints::Constraint; +use pumpkin_core::proof::ConstraintTag; +use pumpkin_core::variables::IntegerVariable; + use super::binary_not_equals; -use crate::proof::ConstraintTag; -use crate::variables::IntegerVariable; /// Creates the [`Constraint`] that enforces that all the given `variables` are distinct. pub fn all_different( diff --git a/pumpkin-crates/core/src/constraints/arithmetic/equality.rs b/pumpkin-crates/constraints/src/constraints/arithmetic/equality.rs similarity index 91% rename from pumpkin-crates/core/src/constraints/arithmetic/equality.rs rename to pumpkin-crates/constraints/src/constraints/arithmetic/equality.rs index 8ffdddad1..6b1230aac 100644 --- a/pumpkin-crates/core/src/constraints/arithmetic/equality.rs +++ b/pumpkin-crates/constraints/src/constraints/arithmetic/equality.rs @@ -1,16 +1,17 @@ +use pumpkin_core::ConstraintOperationError; +use pumpkin_core::Solver; +use pumpkin_core::constraints::Constraint; +use pumpkin_core::constraints::NegatableConstraint; +use pumpkin_core::options::ReifiedPropagatorArgs; +use pumpkin_core::proof::ConstraintTag; +use pumpkin_core::variables::IntegerVariable; +use pumpkin_core::variables::Literal; +use pumpkin_core::variables::TransformableVariable; +use pumpkin_propagators::propagators::BinaryEqualsPropagatorArgs; +use pumpkin_propagators::propagators::BinaryNotEqualsPropagatorArgs; +use pumpkin_propagators::propagators::LinearNotEqualPropagatorArgs; + use super::less_than_or_equals; -use crate::ConstraintOperationError; -use crate::Solver; -use crate::constraints::Constraint; -use crate::constraints::NegatableConstraint; -use crate::proof::ConstraintTag; -use crate::propagators::ReifiedPropagatorArgs; -use crate::propagators::binary::BinaryEqualsPropagatorArgs; -use crate::propagators::binary::BinaryNotEqualsPropagatorArgs; -use crate::propagators::linear_not_equal::LinearNotEqualPropagatorArgs; -use crate::variables::IntegerVariable; -use crate::variables::Literal; -use crate::variables::TransformableVariable; struct EqualConstraint { terms: Box<[Var]>, diff --git a/pumpkin-crates/core/src/constraints/arithmetic/inequality.rs b/pumpkin-crates/constraints/src/constraints/arithmetic/inequality.rs similarity index 90% rename from pumpkin-crates/core/src/constraints/arithmetic/inequality.rs rename to pumpkin-crates/constraints/src/constraints/arithmetic/inequality.rs index 1c9212381..f98620630 100644 --- a/pumpkin-crates/core/src/constraints/arithmetic/inequality.rs +++ b/pumpkin-crates/constraints/src/constraints/arithmetic/inequality.rs @@ -1,10 +1,11 @@ -use crate::ConstraintOperationError; -use crate::Solver; -use crate::constraints::Constraint; -use crate::constraints::NegatableConstraint; -use crate::proof::ConstraintTag; -use crate::propagators::linear_less_or_equal::LinearLessOrEqualPropagatorArgs; -use crate::variables::IntegerVariable; +use pumpkin_core::ConstraintOperationError; +use pumpkin_core::Solver; +use pumpkin_core::constraints::Constraint; +use pumpkin_core::constraints::NegatableConstraint; +use pumpkin_core::proof::ConstraintTag; +use pumpkin_core::variables::IntegerVariable; +use pumpkin_core::variables::Literal; +use pumpkin_propagators::propagators::LinearLessOrEqualPropagatorArgs; /// Create the [`NegatableConstraint`] `\sum terms_i <= rhs`. /// @@ -118,7 +119,7 @@ impl Constraint for Inequality { fn implied_by( self, solver: &mut Solver, - reification_literal: crate::variables::Literal, + reification_literal: Literal, ) -> Result<(), ConstraintOperationError> { LinearLessOrEqualPropagatorArgs { x: self.terms, diff --git a/pumpkin-crates/core/src/constraints/arithmetic/mod.rs b/pumpkin-crates/constraints/src/constraints/arithmetic/mod.rs similarity index 86% rename from pumpkin-crates/core/src/constraints/arithmetic/mod.rs rename to pumpkin-crates/constraints/src/constraints/arithmetic/mod.rs index e710ec6ca..8674bdcf6 100644 --- a/pumpkin-crates/core/src/constraints/arithmetic/mod.rs +++ b/pumpkin-crates/constraints/src/constraints/arithmetic/mod.rs @@ -3,14 +3,13 @@ mod inequality; pub use equality::*; pub use inequality::*; - -use super::Constraint; -use crate::proof::ConstraintTag; -use crate::propagators::absolute_value::AbsoluteValueArgs; -use crate::propagators::integer_division::DivisionArgs; -use crate::propagators::integer_multiplication::IntegerMultiplicationArgs; -use crate::propagators::maximum::MaximumArgs; -use crate::variables::IntegerVariable; +use pumpkin_core::constraints::Constraint; +use pumpkin_core::proof::ConstraintTag; +use pumpkin_core::variables::IntegerVariable; +use pumpkin_propagators::propagators::AbsoluteValueArgs; +use pumpkin_propagators::propagators::DivisionArgs; +use pumpkin_propagators::propagators::IntegerMultiplicationArgs; +use pumpkin_propagators::propagators::MaximumArgs; /// Creates the [`Constraint`] `a + b = c`. pub fn plus( diff --git a/pumpkin-crates/core/src/constraints/boolean.rs b/pumpkin-crates/constraints/src/constraints/boolean.rs similarity index 89% rename from pumpkin-crates/core/src/constraints/boolean.rs rename to pumpkin-crates/constraints/src/constraints/boolean.rs index 07b752106..2ae06de96 100644 --- a/pumpkin-crates/core/src/constraints/boolean.rs +++ b/pumpkin-crates/constraints/src/constraints/boolean.rs @@ -1,13 +1,14 @@ -use super::Constraint; +use pumpkin_core::ConstraintOperationError; +use pumpkin_core::Solver; +use pumpkin_core::constraints::Constraint; +use pumpkin_core::proof::ConstraintTag; +use pumpkin_core::variables::AffineView; +use pumpkin_core::variables::DomainId; +use pumpkin_core::variables::Literal; +use pumpkin_core::variables::TransformableVariable; + use super::equals; use super::less_than_or_equals; -use crate::ConstraintOperationError; -use crate::Solver; -use crate::proof::ConstraintTag; -use crate::variables::AffineView; -use crate::variables::DomainId; -use crate::variables::Literal; -use crate::variables::TransformableVariable; /// Creates the [`Constraint`] `\sum weights_i * bools_i <= rhs`. pub fn boolean_less_than_or_equals( diff --git a/pumpkin-crates/core/src/constraints/clause.rs b/pumpkin-crates/constraints/src/constraints/clause.rs similarity index 92% rename from pumpkin-crates/core/src/constraints/clause.rs rename to pumpkin-crates/constraints/src/constraints/clause.rs index a90137488..aadc282bb 100644 --- a/pumpkin-crates/core/src/constraints/clause.rs +++ b/pumpkin-crates/constraints/src/constraints/clause.rs @@ -1,9 +1,9 @@ -use super::Constraint; -use super::NegatableConstraint; -use crate::ConstraintOperationError; -use crate::Solver; -use crate::proof::ConstraintTag; -use crate::variables::Literal; +use pumpkin_core::ConstraintOperationError; +use pumpkin_core::Solver; +use pumpkin_core::constraints::Constraint; +use pumpkin_core::constraints::NegatableConstraint; +use pumpkin_core::proof::ConstraintTag; +use pumpkin_core::variables::Literal; /// Creates the [`NegatableConstraint`] `\/ literal` /// diff --git a/pumpkin-crates/core/src/constraints/cumulative.rs b/pumpkin-crates/constraints/src/constraints/cumulative.rs similarity index 94% rename from pumpkin-crates/core/src/constraints/cumulative.rs rename to pumpkin-crates/constraints/src/constraints/cumulative.rs index 519fd5cbc..8fe5b1b7d 100644 --- a/pumpkin-crates/core/src/constraints/cumulative.rs +++ b/pumpkin-crates/constraints/src/constraints/cumulative.rs @@ -1,19 +1,19 @@ use std::fmt::Debug; -use super::Constraint; -use crate::ConstraintOperationError; -use crate::Solver; -use crate::constraint_arguments::CumulativePropagationMethod; -use crate::proof::ConstraintTag; -use crate::propagators::ArgTask; -use crate::propagators::CumulativeOptions; -use crate::propagators::TimeTableOverIntervalIncrementalPropagator; -use crate::propagators::TimeTableOverIntervalPropagator; -use crate::propagators::TimeTablePerPointIncrementalPropagator; -use crate::propagators::TimeTablePerPointPropagator; -use crate::pumpkin_assert_simple; -use crate::variables::IntegerVariable; -use crate::variables::Literal; +use pumpkin_core::ConstraintOperationError; +use pumpkin_core::Solver; +use pumpkin_core::asserts::pumpkin_assert_simple; +use pumpkin_core::constraints::Constraint; +use pumpkin_core::proof::ConstraintTag; +use pumpkin_core::variables::IntegerVariable; +use pumpkin_core::variables::Literal; +use pumpkin_propagators::propagators::ArgTask; +use pumpkin_propagators::propagators::CumulativeOptions; +use pumpkin_propagators::propagators::CumulativePropagationMethod; +use pumpkin_propagators::propagators::TimeTableOverIntervalIncrementalPropagator; +use pumpkin_propagators::propagators::TimeTableOverIntervalPropagator; +use pumpkin_propagators::propagators::TimeTablePerPointIncrementalPropagator; +use pumpkin_propagators::propagators::TimeTablePerPointPropagator; /// Creates the [Cumulative](https://sofdem.github.io/gccat/gccat/Ccumulative.html) [`Constraint`]. /// diff --git a/pumpkin-crates/core/src/constraints/disjunctive_strict.rs b/pumpkin-crates/constraints/src/constraints/disjunctive_strict.rs similarity index 83% rename from pumpkin-crates/core/src/constraints/disjunctive_strict.rs rename to pumpkin-crates/constraints/src/constraints/disjunctive_strict.rs index bd7434170..81f020a9c 100644 --- a/pumpkin-crates/core/src/constraints/disjunctive_strict.rs +++ b/pumpkin-crates/constraints/src/constraints/disjunctive_strict.rs @@ -1,9 +1,12 @@ -use crate::constraints::Constraint; -use crate::proof::ConstraintTag; -use crate::propagators::disjunctive_propagator::DisjunctiveConstructor; -use crate::propagators::disjunctive_task::ArgDisjunctiveTask; -use crate::variables::IntegerVariable; -use crate::variables::TransformableVariable; +use pumpkin_core::ConstraintOperationError; +use pumpkin_core::Solver; +use pumpkin_core::constraints::Constraint; +use pumpkin_core::proof::ConstraintTag; +use pumpkin_core::variables::IntegerVariable; +use pumpkin_core::variables::Literal; +use pumpkin_core::variables::TransformableVariable; +use pumpkin_propagators::propagators::ArgDisjunctiveTask; +use pumpkin_propagators::propagators::DisjunctiveConstructor; /// Creates the [Disjunctive](https://sofdem.github.io/gccat/gccat/Cdisjunctive.html) [`Constraint`] (also called the `NoOverlap` Constraint or the `Unary Resource` Constraint). /// @@ -37,7 +40,7 @@ struct DisjunctiveConstraint { } impl Constraint for DisjunctiveConstraint { - fn post(self, solver: &mut crate::Solver) -> Result<(), crate::ConstraintOperationError> { + fn post(self, solver: &mut Solver) -> Result<(), ConstraintOperationError> { // We post both the propagator on the lower-bound and the propagator on the upper-bound. DisjunctiveConstructor::new(self.tasks.clone(), self.constraint_tag).post(solver)?; DisjunctiveConstructor::new( @@ -54,9 +57,9 @@ impl Constraint for DisjunctiveConstraint { fn implied_by( self, - solver: &mut crate::Solver, - reification_literal: crate::variables::Literal, - ) -> Result<(), crate::ConstraintOperationError> { + solver: &mut Solver, + reification_literal: Literal, + ) -> Result<(), ConstraintOperationError> { // We post both the propagator on the lower-bound and the propagator on the upper-bound. DisjunctiveConstructor::new(self.tasks.clone(), self.constraint_tag) .implied_by(solver, reification_literal)?; diff --git a/pumpkin-crates/core/src/constraints/element.rs b/pumpkin-crates/constraints/src/constraints/element.rs similarity index 73% rename from pumpkin-crates/core/src/constraints/element.rs rename to pumpkin-crates/constraints/src/constraints/element.rs index c1b911774..949a4851b 100644 --- a/pumpkin-crates/core/src/constraints/element.rs +++ b/pumpkin-crates/constraints/src/constraints/element.rs @@ -1,7 +1,7 @@ -use super::Constraint; -use crate::proof::ConstraintTag; -use crate::propagators::element::ElementArgs; -use crate::variables::IntegerVariable; +use pumpkin_core::constraints::Constraint; +use pumpkin_core::proof::ConstraintTag; +use pumpkin_core::variables::IntegerVariable; +use pumpkin_propagators::propagators::ElementArgs; /// Creates the [element](https://sofdem.github.io/gccat/gccat/Celement.html) [`Constraint`] which states that `array[index] = rhs`. pub fn element( diff --git a/pumpkin-crates/constraints/src/constraints/mod.rs b/pumpkin-crates/constraints/src/constraints/mod.rs new file mode 100644 index 000000000..7d7dd105a --- /dev/null +++ b/pumpkin-crates/constraints/src/constraints/mod.rs @@ -0,0 +1,46 @@ +//! Defines the constraints that Pumpkin provides out of the box which can be added to the +//! [`Solver`]. +//! +//! A constraint is a relation over variables. In the solver, constraints are enforced through +//! propagators, and therefore constraints can be viewed as a collection of propagators. +//! +//! # Example +//! ``` +//! # use pumpkin_core::constraints; +//! # use pumpkin_core::Solver; +//! let mut solver = Solver::default(); +//! +//! let a = solver.new_bounded_integer(0, 3); +//! let b = solver.new_bounded_integer(0, 3); +//! +//! // All constraints require a constraint tag. +//! let constraint_tag = solver.new_constraint_tag(); +//! +//! solver +//! .add_constraint(constraints::equals([a, b], 0, constraint_tag)) +//! .post(); +//! ``` +//! +//! # Note +//! At the moment, the API for posting propagators is not yet publicly accessible as it is +//! unstable. Consumers of the Pumpkin library can therefore only define constraints by +//! decomposing them into the constraints that are predefined in the library. Once the +//! propagator API is stabilized, it will become part of the public API. + +mod all_different; +mod arithmetic; +mod boolean; +mod clause; +mod cumulative; +mod disjunctive_strict; +mod element; +mod table; + +pub use all_different::*; +pub use arithmetic::*; +pub use boolean::*; +pub use clause::*; +pub use cumulative::*; +pub use disjunctive_strict::*; +pub use element::*; +pub use table::*; diff --git a/pumpkin-crates/core/src/constraints/table.rs b/pumpkin-crates/constraints/src/constraints/table.rs similarity index 95% rename from pumpkin-crates/core/src/constraints/table.rs rename to pumpkin-crates/constraints/src/constraints/table.rs index a18f52745..abc6364d9 100644 --- a/pumpkin-crates/core/src/constraints/table.rs +++ b/pumpkin-crates/constraints/src/constraints/table.rs @@ -1,13 +1,13 @@ use std::collections::BTreeMap; -use super::Constraint; -use super::NegatableConstraint; -use crate::ConstraintOperationError; -use crate::Solver; -use crate::predicate; -use crate::proof::ConstraintTag; -use crate::variables::IntegerVariable; -use crate::variables::Literal; +use pumpkin_core::ConstraintOperationError; +use pumpkin_core::Solver; +use pumpkin_core::constraints::Constraint; +use pumpkin_core::constraints::NegatableConstraint; +use pumpkin_core::predicate; +use pumpkin_core::proof::ConstraintTag; +use pumpkin_core::variables::IntegerVariable; +use pumpkin_core::variables::Literal; /// Create a table constraint over the variables `xs`. /// diff --git a/pumpkin-crates/constraints/src/lib.rs b/pumpkin-crates/constraints/src/lib.rs new file mode 100644 index 000000000..5d81d2051 --- /dev/null +++ b/pumpkin-crates/constraints/src/lib.rs @@ -0,0 +1,2 @@ +mod constraints; +pub use constraints::*; diff --git a/pumpkin-crates/core/src/api/mod.rs b/pumpkin-crates/core/src/api/mod.rs index 9973e073b..00d5b8477 100644 --- a/pumpkin-crates/core/src/api/mod.rs +++ b/pumpkin-crates/core/src/api/mod.rs @@ -25,6 +25,7 @@ pub mod results { pub use crate::api::outputs::SolutionReference; pub use crate::api::outputs::solution_iterator; pub use crate::api::outputs::unsatisfiable; + pub use crate::basic_types::PropagationStatusCP; pub use crate::basic_types::Solution; #[cfg(doc)] use crate::results::unsatisfiable::UnsatisfiableUnderAssumptions; @@ -48,6 +49,7 @@ pub mod variables { //! [`Solver`]. A [`Literal`] can be created using [`Solver::new_literal`]. #[cfg(doc)] use crate::Solver; + pub use crate::engine::Reason; pub use crate::engine::variables::AffineView; pub use crate::engine::variables::DomainId; pub use crate::engine::variables::IntegerVariable; @@ -55,15 +57,6 @@ pub mod variables { pub use crate::engine::variables::TransformableVariable; } -pub mod constraint_arguments { - //! Contains inputs to constraints. - - pub use crate::propagators::ArgDisjunctiveTask; - pub use crate::propagators::CumulativeExplanationType; - pub use crate::propagators::CumulativeOptions; - pub use crate::propagators::CumulativePropagationMethod; -} - pub mod options { //! Contains the options which can be passed to the [`Solver`]. //! @@ -78,6 +71,7 @@ pub mod options { pub use crate::engine::RestartOptions; pub use crate::engine::SatisfactionSolverOptions as SolverOptions; pub use crate::propagators::nogoods::LearningOptions; + pub use crate::propagators::reified_propagator::ReifiedPropagatorArgs; } pub mod termination { diff --git a/pumpkin-crates/core/src/api/solver.rs b/pumpkin-crates/core/src/api/solver.rs index 9278963f9..422efba36 100644 --- a/pumpkin-crates/core/src/api/solver.rs +++ b/pumpkin-crates/core/src/api/solver.rs @@ -143,7 +143,7 @@ impl Solver { self.satisfaction_solver.get_solution_reference() } - pub(crate) fn is_logging_proof(&self) -> bool { + pub fn is_logging_proof(&self) -> bool { self.satisfaction_solver.is_logging_proof() } } diff --git a/pumpkin-crates/core/src/basic_types/propagation_status_cp.rs b/pumpkin-crates/core/src/basic_types/propagation_status_cp.rs index 8296d647c..870709d1e 100644 --- a/pumpkin-crates/core/src/basic_types/propagation_status_cp.rs +++ b/pumpkin-crates/core/src/basic_types/propagation_status_cp.rs @@ -5,7 +5,7 @@ use crate::state::Conflict; /// The result of invoking a constraint programming propagator. The propagation can either succeed /// or identify a conflict. The necessary conditions for the conflict must be captured in the error /// variant, i.e. a propositional conjunction. -pub(crate) type PropagationStatusCP = Result<(), Conflict>; +pub type PropagationStatusCP = Result<(), Conflict>; /// A conflict stated by a propagator. A propagator that identifies a conflict that is _not_ an /// empty domain, describes that conflict with this type. diff --git a/pumpkin-crates/core/src/constraints/mod.rs b/pumpkin-crates/core/src/constraints/mod.rs index a0b0f53b0..101ead5fb 100644 --- a/pumpkin-crates/core/src/constraints/mod.rs +++ b/pumpkin-crates/core/src/constraints/mod.rs @@ -1,58 +1,12 @@ -//! Defines the constraints that Pumpkin provides out of the box which can be added to the -//! [`Solver`]. -//! -//! A constraint is a relation over variables. In the solver, constraints are enforced through -//! propagators, and therefore constraints can be viewed as a collection of propagators. -//! -//! # Example -//! ``` -//! # use pumpkin_core::constraints; -//! # use pumpkin_core::Solver; -//! let mut solver = Solver::default(); -//! -//! let a = solver.new_bounded_integer(0, 3); -//! let b = solver.new_bounded_integer(0, 3); -//! -//! // All constraints require a constraint tag. -//! let constraint_tag = solver.new_constraint_tag(); -//! -//! solver -//! .add_constraint(constraints::equals([a, b], 0, constraint_tag)) -//! .post(); -//! ``` -//! -//! # Note -//! At the moment, the API for posting propagators is not yet publicly accessible as it is -//! unstable. Consumers of the Pumpkin library can therefore only define constraints by -//! decomposing them into the constraints that are predefined in the library. Once the -//! propagator API is stabilized, it will become part of the public API. - -mod all_different; -mod arithmetic; -mod boolean; -mod clause; -mod constraint_poster; -mod cumulative; -mod disjunctive_strict; -mod element; -mod table; - -pub use all_different::*; -pub use arithmetic::*; -pub use boolean::*; -pub use clause::*; -pub use constraint_poster::*; -pub use cumulative::*; -pub use disjunctive_strict::*; -pub use element::*; -pub use table::*; - use crate::ConstraintOperationError; use crate::Solver; use crate::propagation::PropagatorConstructor; -use crate::propagators::ReifiedPropagatorArgs; +use crate::propagators::reified_propagator::ReifiedPropagatorArgs; use crate::variables::Literal; +mod constraint_poster; +pub use constraint_poster::ConstraintPoster; + /// A [`Constraint`] is a relation over variables. It disqualifies certain partial assignments of /// making it into a solution of the problem. /// diff --git a/pumpkin-crates/core/src/containers/keyed_vec.rs b/pumpkin-crates/core/src/containers/keyed_vec.rs index 84c34122b..654db58d8 100644 --- a/pumpkin-crates/core/src/containers/keyed_vec.rs +++ b/pumpkin-crates/core/src/containers/keyed_vec.rs @@ -42,11 +42,11 @@ impl KeyedVec { } impl KeyedVec { - pub(crate) fn get(&self, key: Key) -> Option<&Value> { + pub fn get(&self, key: Key) -> Option<&Value> { self.elements.get(key.index()) } - pub(crate) fn len(&self) -> usize { + pub fn len(&self) -> usize { self.elements.len() } @@ -121,17 +121,17 @@ impl KeyedVec { } impl KeyedVec { - pub(crate) fn accomodate(&mut self, key: Key, default_value: Value) { + pub fn accomodate(&mut self, key: Key, default_value: Value) { if key.index() >= self.elements.len() { self.elements.resize(key.index() + 1, default_value) } } - pub(crate) fn resize(&mut self, new_len: usize, value: Value) { + pub fn resize(&mut self, new_len: usize, value: Value) { self.elements.resize(new_len, value) } - pub(crate) fn clear(&mut self) { + pub fn clear(&mut self) { self.elements.clear(); } } diff --git a/pumpkin-crates/core/src/containers/mod.rs b/pumpkin-crates/core/src/containers/mod.rs index f0abaef64..39343eb44 100644 --- a/pumpkin-crates/core/src/containers/mod.rs +++ b/pumpkin-crates/core/src/containers/mod.rs @@ -8,7 +8,7 @@ use fnv::FnvBuildHasher; pub use key_generator::*; pub use key_value_heap::*; pub use keyed_vec::*; -pub(crate) use sparse_set::*; +pub use sparse_set::*; /// [`std::collections::HashMap`] that defaults to a deterministic hasher. #[allow(clippy::disallowed_types, reason = "this is how we define our HashMap")] diff --git a/pumpkin-crates/core/src/containers/sparse_set.rs b/pumpkin-crates/core/src/containers/sparse_set.rs index e9d2928e0..b75b7135c 100644 --- a/pumpkin-crates/core/src/containers/sparse_set.rs +++ b/pumpkin-crates/core/src/containers/sparse_set.rs @@ -42,7 +42,7 @@ use crate::pumpkin_assert_simple; /// implementation’, in CP workshop on Techniques foR Implementing Constraint programming Systems /// (TRICS), 2013, pp. 1–10. #[derive(Debug, Clone)] -pub(crate) struct SparseSet { +pub struct SparseSet { /// The number of elements which are currently in the domain size: usize, /// The current state of the domain, this structure guarantees that the first @@ -61,7 +61,7 @@ impl SparseSet { /// Assumption: It is assumed that `mapping` is a bijective function which /// will return an index which is in the range [0, |D_{original}|) (where D_{original} is /// the initial domain before any operations have been performed). - pub(crate) fn new(input: Vec, mapping: fn(&T) -> usize) -> Self { + pub fn new(input: Vec, mapping: fn(&T) -> usize) -> Self { let input_len = input.len(); SparseSet { size: input_len, @@ -71,25 +71,29 @@ impl SparseSet { } } - pub(crate) fn set_to_empty(&mut self) { + pub fn set_to_empty(&mut self) { self.indices = vec![usize::MAX; self.indices.len()]; self.domain.clear(); self.size = 0; } + pub fn restore_temporarily_removed(&mut self) { + self.size = self.domain.len(); + } + /// Determines whether the domain represented by the [`SparseSet`] is empty - pub(crate) fn is_empty(&self) -> bool { + pub fn is_empty(&self) -> bool { self.size == 0 } /// Returns how many elements are part of the domain - pub(crate) fn len(&self) -> usize { + pub fn len(&self) -> usize { self.size } /// Returns the `index`th element in the domain; if `index` is larger than or equal to /// [`SparseSet::len`] then this method will panic. - pub(crate) fn get(&self, index: usize) -> &T { + pub fn get(&self, index: usize) -> &T { pumpkin_assert_simple!(index < self.size); &self.domain[index] } @@ -104,7 +108,7 @@ impl SparseSet { /// Remove the value of `to_remove` from the domain; if the value is not in the domain then this /// method does not perform any operations. - pub(crate) fn remove(&mut self, to_remove: &T) { + pub fn remove(&mut self, to_remove: &T) { if self.indices[(self.mapping)(to_remove)] < self.size { // The element is part of the domain and should be removed self.size -= 1; @@ -130,7 +134,7 @@ impl SparseSet { } } - pub(crate) fn remove_temporarily(&mut self, to_remove: &T) { + pub fn remove_temporarily(&mut self, to_remove: &T) { if self.indices[(self.mapping)(to_remove)] < self.size { // The element is part of the domain and should be removed self.size -= 1; @@ -138,18 +142,14 @@ impl SparseSet { } } - pub(crate) fn restore_temporarily_removed(&mut self) { - self.size = self.domain.len(); - } - /// Determines whehter the `element` is contained in the domain of the sparse-set. - pub(crate) fn contains(&self, element: &T) -> bool { + pub fn contains(&self, element: &T) -> bool { (self.mapping)(element) < self.indices.len() && self.indices[(self.mapping)(element)] < self.size } /// Accomodates the `element`. - pub(crate) fn accommodate(&mut self, element: &T) { + pub fn accommodate(&mut self, element: &T) { let index = (self.mapping)(element); if self.indices.len() <= index { self.indices.resize(index + 1, usize::MAX); @@ -157,7 +157,7 @@ impl SparseSet { } /// Inserts the element if it is not already contained in the sparse set. - pub(crate) fn insert(&mut self, element: T) { + pub fn insert(&mut self, element: T) { if !self.contains(&element) { self.accommodate(&element); @@ -169,11 +169,11 @@ impl SparseSet { } /// Returns an iterator which goes over the values in the domain of the sparse-set - pub(crate) fn iter(&self) -> impl Iterator { + pub fn iter(&self) -> impl Iterator { self.domain[..self.size].iter() } - pub(crate) fn out_of_domain(&self) -> impl Iterator { + pub fn out_of_domain(&self) -> impl Iterator { self.domain[self.size..].iter() } } diff --git a/pumpkin-crates/core/src/engine/mod.rs b/pumpkin-crates/core/src/engine/mod.rs index 5760b910e..e070cf595 100644 --- a/pumpkin-crates/core/src/engine/mod.rs +++ b/pumpkin-crates/core/src/engine/mod.rs @@ -22,6 +22,7 @@ pub(crate) use cp::*; pub(crate) use debug_helper::DebugDyn; pub(crate) use debug_helper::DebugHelper; pub(crate) use literal_block_distance::Lbd; +pub use reason::Reason; pub use restart_strategy::RestartOptions; pub(crate) use restart_strategy::RestartStrategy; pub(crate) use solver_statistics::SolverStatistics; diff --git a/pumpkin-crates/core/src/engine/notifications/domain_event_notification/domain_events.rs b/pumpkin-crates/core/src/engine/notifications/domain_event_notification/domain_events.rs index 2b428f7bc..1b0064e7a 100644 --- a/pumpkin-crates/core/src/engine/notifications/domain_event_notification/domain_events.rs +++ b/pumpkin-crates/core/src/engine/notifications/domain_event_notification/domain_events.rs @@ -31,7 +31,7 @@ impl DomainEvents { } impl DomainEvents { - pub(crate) const fn new(int_events: EnumSet) -> DomainEvents { + pub const fn new(int_events: EnumSet) -> DomainEvents { DomainEvents { events: Some(int_events), } diff --git a/pumpkin-crates/core/src/propagation/constructor.rs b/pumpkin-crates/core/src/propagation/constructor.rs index 290f625fc..2837bad7f 100644 --- a/pumpkin-crates/core/src/propagation/constructor.rs +++ b/pumpkin-crates/core/src/propagation/constructor.rs @@ -141,7 +141,7 @@ impl PropagatorConstructorContext<'_> { /// Create a new [`InferenceCode`]. These codes are required to identify specific propagations /// in the solver and the proof. - pub(crate) fn create_inference_code( + pub fn create_inference_code( &mut self, constraint_tag: ConstraintTag, inference_label: impl InferenceLabel, @@ -158,7 +158,7 @@ impl PropagatorConstructorContext<'_> { /// Reborrow the current context to a new value with a shorter lifetime. Should be used when /// passing `Self` to another function that takes ownership, but the value is still needed /// afterwards. - pub(crate) fn reborrow(&mut self) -> PropagatorConstructorContext<'_> { + pub fn reborrow(&mut self) -> PropagatorConstructorContext<'_> { PropagatorConstructorContext { propagator_id: self.propagator_id, next_local_id: match &mut self.next_local_id { diff --git a/pumpkin-crates/core/src/propagation/domains.rs b/pumpkin-crates/core/src/propagation/domains.rs index 1f67c341d..1a86a9d6c 100644 --- a/pumpkin-crates/core/src/propagation/domains.rs +++ b/pumpkin-crates/core/src/propagation/domains.rs @@ -136,6 +136,9 @@ pub trait ReadDomains { /// Assigns the provided [`TrailedInteger`] to the provided `value`. fn write_trailed_integer(&mut self, trailed_integer: TrailedInteger, value: i64); + + /// Returns the current checkpoint. + fn get_checkpoint(&self) -> usize; } impl ReadDomains for T { @@ -222,4 +225,8 @@ impl ReadDomains for T { fn write_trailed_integer(&mut self, trailed_integer: TrailedInteger, value: i64) { self.trailed_values_mut().assign(trailed_integer, value); } + + fn get_checkpoint(&self) -> usize { + self.assignments().get_checkpoint() + } } diff --git a/pumpkin-crates/core/src/propagators/arithmetic/binary/mod.rs b/pumpkin-crates/core/src/propagators/arithmetic/binary/mod.rs deleted file mode 100644 index 3e1da48aa..000000000 --- a/pumpkin-crates/core/src/propagators/arithmetic/binary/mod.rs +++ /dev/null @@ -1,5 +0,0 @@ -pub(crate) mod binary_equals; -pub(crate) mod binary_not_equals; - -pub(crate) use binary_equals::*; -pub(crate) use binary_not_equals::*; diff --git a/pumpkin-crates/core/src/propagators/mod.rs b/pumpkin-crates/core/src/propagators/mod.rs index c87277c4d..6f8b77661 100644 --- a/pumpkin-crates/core/src/propagators/mod.rs +++ b/pumpkin-crates/core/src/propagators/mod.rs @@ -1,20 +1,3 @@ -//! Contains propagator implementations that are used in Pumpkin. -//! -//! See the [`propagation`] for info on propagators. -#[cfg(doc)] -use crate::propagation; - -pub(crate) mod arithmetic; -mod cumulative; -mod disjunctive; -pub(crate) mod element; pub(crate) mod nogoods; -mod reified_propagator; -pub(crate) use arithmetic::*; -pub use cumulative::CumulativeExplanationType; -pub use cumulative::CumulativeOptions; -pub use cumulative::CumulativePropagationMethod; -pub(crate) use cumulative::*; -pub use disjunctive::disjunctive_task::ArgDisjunctiveTask; -pub(crate) use disjunctive::*; -pub(crate) use reified_propagator::*; +pub(crate) mod reified_propagator; + diff --git a/pumpkin-crates/core/src/propagators/reified_propagator.rs b/pumpkin-crates/core/src/propagators/reified_propagator.rs index e4387f3ae..bc690d086 100644 --- a/pumpkin-crates/core/src/propagators/reified_propagator.rs +++ b/pumpkin-crates/core/src/propagators/reified_propagator.rs @@ -19,9 +19,9 @@ use crate::variables::Literal; /// A [`PropagatorConstructor`] for the [`ReifiedPropagator`]. #[derive(Clone, Debug)] -pub(crate) struct ReifiedPropagatorArgs { - pub(crate) propagator: WrappedArgs, - pub(crate) reification_literal: Literal, +pub struct ReifiedPropagatorArgs { + pub propagator: WrappedArgs, + pub reification_literal: Literal, } impl PropagatorConstructor for ReifiedPropagatorArgs @@ -66,7 +66,7 @@ where /// be used to propagate `r` to false. If that method is not implemented, `r` will never be /// propagated to false. #[derive(Clone, Debug)] -pub(crate) struct ReifiedPropagator { +pub struct ReifiedPropagator { propagator: WrappedPropagator, reification_literal: Literal, /// The formatted name of the propagator. diff --git a/pumpkin-crates/propagators/Cargo.toml b/pumpkin-crates/propagators/Cargo.toml new file mode 100644 index 000000000..2ec97354c --- /dev/null +++ b/pumpkin-crates/propagators/Cargo.toml @@ -0,0 +1,21 @@ +[package] +name = "pumpkin-propagators" +version = "0.2.2" +repository.workspace = true +edition.workspace = true +license.workspace = true +authors.workspace = true +description = "The propagators of the Pumpkin constraint programming solver." + +[lints] +workspace = true + +[dependencies] +pumpkin-core = { version = "0.2.2", path = "../core" } +enumset = "1.1.2" +bitfield-struct = "0.9.2" +convert_case = "0.6.0" +clap = { version = "4.5.40", optional = true } + +[features] +clap = ["dep:clap"] diff --git a/pumpkin-crates/propagators/clippy.toml b/pumpkin-crates/propagators/clippy.toml new file mode 100644 index 000000000..9d3ca24f5 --- /dev/null +++ b/pumpkin-crates/propagators/clippy.toml @@ -0,0 +1,7 @@ +disallowed-types = [ + { path = "std::collections::HashSet", reason = "use pumpkin_solver::containers::HashSet" }, + { path = "std::collections::HashMap", reason = "use pumpkin_solver::containers::HashMap" }, + { path = "rand::RngCore", reason = "use pumpkin_solver::basic_types::Random" }, + { path = "rand::Rng", reason = "use pumpkin_solver::basic_types::Random" }, + { path = "rand::SeedableRng", reason = "use pumpkin_solver::basic_types::Random" }, +] diff --git a/pumpkin-crates/propagators/src/lib.rs b/pumpkin-crates/propagators/src/lib.rs new file mode 100644 index 000000000..b3e9d2b83 --- /dev/null +++ b/pumpkin-crates/propagators/src/lib.rs @@ -0,0 +1,2 @@ +pub mod propagators; + diff --git a/pumpkin-crates/core/src/propagators/arithmetic/absolute_value.rs b/pumpkin-crates/propagators/src/propagators/arithmetic/absolute_value.rs similarity index 90% rename from pumpkin-crates/core/src/propagators/arithmetic/absolute_value.rs rename to pumpkin-crates/propagators/src/propagators/arithmetic/absolute_value.rs index f7cb232cf..d67d2c440 100644 --- a/pumpkin-crates/core/src/propagators/arithmetic/absolute_value.rs +++ b/pumpkin-crates/propagators/src/propagators/arithmetic/absolute_value.rs @@ -1,26 +1,26 @@ -use crate::basic_types::PropagationStatusCP; -use crate::conjunction; -use crate::declare_inference_label; -use crate::engine::variables::IntegerVariable; -use crate::predicate; -use crate::proof::ConstraintTag; -use crate::proof::InferenceCode; -use crate::propagation::DomainEvents; -use crate::propagation::LocalId; -use crate::propagation::Priority; -use crate::propagation::PropagationContext; -use crate::propagation::Propagator; -use crate::propagation::PropagatorConstructor; -use crate::propagation::PropagatorConstructorContext; -use crate::propagation::ReadDomains; +use pumpkin_core::conjunction; +use pumpkin_core::declare_inference_label; +use pumpkin_core::predicate; +use pumpkin_core::proof::ConstraintTag; +use pumpkin_core::proof::InferenceCode; +use pumpkin_core::propagation::DomainEvents; +use pumpkin_core::propagation::LocalId; +use pumpkin_core::propagation::Priority; +use pumpkin_core::propagation::PropagationContext; +use pumpkin_core::propagation::Propagator; +use pumpkin_core::propagation::PropagatorConstructor; +use pumpkin_core::propagation::PropagatorConstructorContext; +use pumpkin_core::propagation::ReadDomains; +use pumpkin_core::results::PropagationStatusCP; +use pumpkin_core::variables::IntegerVariable; declare_inference_label!(AbsoluteValue); #[derive(Clone, Debug)] -pub(crate) struct AbsoluteValueArgs { - pub(crate) signed: VA, - pub(crate) absolute: VB, - pub(crate) constraint_tag: ConstraintTag, +pub struct AbsoluteValueArgs { + pub signed: VA, + pub absolute: VB, + pub constraint_tag: ConstraintTag, } impl PropagatorConstructor for AbsoluteValueArgs @@ -55,7 +55,7 @@ where /// The propagator is bounds consistent wrt signed. That means that if `signed \in {-2, -1, 1, 2}`, /// the propagator will not propagate `[absolute >= 1]`. #[derive(Clone, Debug)] -pub(crate) struct AbsoluteValuePropagator { +pub struct AbsoluteValuePropagator { signed: VA, absolute: VB, inference_code: InferenceCode, @@ -149,7 +149,6 @@ where #[cfg(test)] mod tests { use super::*; - use crate::engine::test_solver::TestSolver; #[test] fn absolute_bounds_are_propagated_at_initialise() { diff --git a/pumpkin-crates/core/src/propagators/arithmetic/binary/binary_equals.rs b/pumpkin-crates/propagators/src/propagators/arithmetic/binary/binary_equals.rs similarity index 91% rename from pumpkin-crates/core/src/propagators/arithmetic/binary/binary_equals.rs rename to pumpkin-crates/propagators/src/propagators/arithmetic/binary/binary_equals.rs index e2e1b867a..7eea2a7c0 100644 --- a/pumpkin-crates/core/src/propagators/arithmetic/binary/binary_equals.rs +++ b/pumpkin-crates/propagators/src/propagators/arithmetic/binary/binary_equals.rs @@ -1,46 +1,44 @@ #![allow(clippy::double_parens, reason = "originates inside the bitfield macro")] - use std::slice; use bitfield_struct::bitfield; - -use crate::basic_types::PropagationStatusCP; -use crate::basic_types::PropagatorConflict; -use crate::conjunction; -use crate::containers::HashSet; -use crate::declare_inference_label; -use crate::engine::EmptyDomainConflict; -use crate::engine::notifications::DomainEvent; -use crate::engine::notifications::OpaqueDomainEvent; -use crate::engine::variables::IntegerVariable; -use crate::predicate; -use crate::predicates::Predicate; -use crate::predicates::PredicateConstructor; -use crate::predicates::PredicateType; -use crate::proof::ConstraintTag; -use crate::proof::InferenceCode; -use crate::propagation::DomainEvents; -use crate::propagation::Domains; -use crate::propagation::EnqueueDecision; -use crate::propagation::ExplanationContext; -use crate::propagation::LocalId; -use crate::propagation::NotificationContext; -use crate::propagation::Priority; -use crate::propagation::PropagationContext; -use crate::propagation::Propagator; -use crate::propagation::PropagatorConstructor; -use crate::propagation::PropagatorConstructorContext; -use crate::propagation::ReadDomains; -use crate::pumpkin_assert_advanced; +use pumpkin_core::asserts::pumpkin_assert_advanced; +use pumpkin_core::conjunction; +use pumpkin_core::containers::HashSet; +use pumpkin_core::declare_inference_label; +use pumpkin_core::predicate; +use pumpkin_core::predicates::Predicate; +use pumpkin_core::predicates::PredicateConstructor; +use pumpkin_core::predicates::PredicateType; +use pumpkin_core::proof::ConstraintTag; +use pumpkin_core::proof::InferenceCode; +use pumpkin_core::propagation::DomainEvent; +use pumpkin_core::propagation::DomainEvents; +use pumpkin_core::propagation::Domains; +use pumpkin_core::propagation::EnqueueDecision; +use pumpkin_core::propagation::ExplanationContext; +use pumpkin_core::propagation::LocalId; +use pumpkin_core::propagation::NotificationContext; +use pumpkin_core::propagation::OpaqueDomainEvent; +use pumpkin_core::propagation::Priority; +use pumpkin_core::propagation::PropagationContext; +use pumpkin_core::propagation::Propagator; +use pumpkin_core::propagation::PropagatorConstructor; +use pumpkin_core::propagation::PropagatorConstructorContext; +use pumpkin_core::propagation::ReadDomains; +use pumpkin_core::results::PropagationStatusCP; +use pumpkin_core::state::EmptyDomainConflict; +use pumpkin_core::state::PropagatorConflict; +use pumpkin_core::variables::IntegerVariable; declare_inference_label!(BinaryEquals); /// The [`PropagatorConstructor`] for the [`BinaryEqualsPropagator`]. #[derive(Clone, Debug)] -pub(crate) struct BinaryEqualsPropagatorArgs { - pub(crate) a: AVar, - pub(crate) b: BVar, - pub(crate) constraint_tag: ConstraintTag, +pub struct BinaryEqualsPropagatorArgs { + pub a: AVar, + pub b: BVar, + pub constraint_tag: ConstraintTag, } impl PropagatorConstructor for BinaryEqualsPropagatorArgs @@ -78,7 +76,7 @@ where /// Propagator for the constraint `a = b`. #[derive(Clone, Debug)] -pub(crate) struct BinaryEqualsPropagator { +pub struct BinaryEqualsPropagator { a: AVar, b: BVar, diff --git a/pumpkin-crates/core/src/propagators/arithmetic/binary/binary_not_equals.rs b/pumpkin-crates/propagators/src/propagators/arithmetic/binary/binary_not_equals.rs similarity index 87% rename from pumpkin-crates/core/src/propagators/arithmetic/binary/binary_not_equals.rs rename to pumpkin-crates/propagators/src/propagators/arithmetic/binary/binary_not_equals.rs index 43298ea1e..3be8868d1 100644 --- a/pumpkin-crates/core/src/propagators/arithmetic/binary/binary_not_equals.rs +++ b/pumpkin-crates/propagators/src/propagators/arithmetic/binary/binary_not_equals.rs @@ -1,29 +1,29 @@ -use crate::basic_types::PropagationStatusCP; -use crate::basic_types::PropagatorConflict; -use crate::conjunction; -use crate::declare_inference_label; -use crate::engine::variables::IntegerVariable; -use crate::predicate; -use crate::proof::ConstraintTag; -use crate::proof::InferenceCode; -use crate::propagation::DomainEvents; -use crate::propagation::Domains; -use crate::propagation::LocalId; -use crate::propagation::Priority; -use crate::propagation::PropagationContext; -use crate::propagation::Propagator; -use crate::propagation::PropagatorConstructor; -use crate::propagation::PropagatorConstructorContext; -use crate::propagation::ReadDomains; +use pumpkin_core::conjunction; +use pumpkin_core::declare_inference_label; +use pumpkin_core::predicate; +use pumpkin_core::proof::ConstraintTag; +use pumpkin_core::proof::InferenceCode; +use pumpkin_core::propagation::DomainEvents; +use pumpkin_core::propagation::Domains; +use pumpkin_core::propagation::LocalId; +use pumpkin_core::propagation::Priority; +use pumpkin_core::propagation::PropagationContext; +use pumpkin_core::propagation::Propagator; +use pumpkin_core::propagation::PropagatorConstructor; +use pumpkin_core::propagation::PropagatorConstructorContext; +use pumpkin_core::propagation::ReadDomains; +use pumpkin_core::results::PropagationStatusCP; +use pumpkin_core::state::PropagatorConflict; +use pumpkin_core::variables::IntegerVariable; declare_inference_label!(BinaryNotEquals); /// The [`PropagatorConstructor`] for the [`BinaryNotEqualsPropagator`]. #[derive(Clone, Debug)] -pub(crate) struct BinaryNotEqualsPropagatorArgs { - pub(crate) a: AVar, - pub(crate) b: BVar, - pub(crate) constraint_tag: ConstraintTag, +pub struct BinaryNotEqualsPropagatorArgs { + pub a: AVar, + pub b: BVar, + pub constraint_tag: ConstraintTag, } impl PropagatorConstructor for BinaryNotEqualsPropagatorArgs @@ -55,7 +55,7 @@ where /// Propagator for the constraint `a != b`. #[derive(Clone, Debug)] -pub(crate) struct BinaryNotEqualsPropagator { +pub struct BinaryNotEqualsPropagator { a: AVar, b: BVar, @@ -170,8 +170,6 @@ where #[cfg(test)] mod tests { - use crate::engine::test_solver::TestSolver; - use crate::propagation::EnqueueDecision; use crate::propagators::binary::BinaryNotEqualsPropagatorArgs; #[test] diff --git a/pumpkin-crates/propagators/src/propagators/arithmetic/binary/mod.rs b/pumpkin-crates/propagators/src/propagators/arithmetic/binary/mod.rs new file mode 100644 index 000000000..8d3c6bbb8 --- /dev/null +++ b/pumpkin-crates/propagators/src/propagators/arithmetic/binary/mod.rs @@ -0,0 +1,5 @@ +pub(crate) mod binary_equals; +pub(crate) mod binary_not_equals; + +pub use binary_equals::*; +pub use binary_not_equals::*; diff --git a/pumpkin-crates/core/src/propagators/arithmetic/integer_division.rs b/pumpkin-crates/propagators/src/propagators/arithmetic/integer_division.rs similarity index 93% rename from pumpkin-crates/core/src/propagators/arithmetic/integer_division.rs rename to pumpkin-crates/propagators/src/propagators/arithmetic/integer_division.rs index 33e308e71..d90ed78d2 100644 --- a/pumpkin-crates/core/src/propagators/arithmetic/integer_division.rs +++ b/pumpkin-crates/propagators/src/propagators/arithmetic/integer_division.rs @@ -1,27 +1,27 @@ -use crate::basic_types::PropagationStatusCP; -use crate::conjunction; -use crate::declare_inference_label; -use crate::engine::variables::IntegerVariable; -use crate::predicate; -use crate::proof::ConstraintTag; -use crate::proof::InferenceCode; -use crate::propagation::DomainEvents; -use crate::propagation::LocalId; -use crate::propagation::Priority; -use crate::propagation::PropagationContext; -use crate::propagation::Propagator; -use crate::propagation::PropagatorConstructor; -use crate::propagation::PropagatorConstructorContext; -use crate::propagation::ReadDomains; -use crate::pumpkin_assert_simple; +use pumpkin_core::asserts::pumpkin_assert_simple; +use pumpkin_core::conjunction; +use pumpkin_core::declare_inference_label; +use pumpkin_core::predicate; +use pumpkin_core::proof::ConstraintTag; +use pumpkin_core::proof::InferenceCode; +use pumpkin_core::propagation::DomainEvents; +use pumpkin_core::propagation::LocalId; +use pumpkin_core::propagation::Priority; +use pumpkin_core::propagation::PropagationContext; +use pumpkin_core::propagation::Propagator; +use pumpkin_core::propagation::PropagatorConstructor; +use pumpkin_core::propagation::PropagatorConstructorContext; +use pumpkin_core::propagation::ReadDomains; +use pumpkin_core::results::PropagationStatusCP; +use pumpkin_core::variables::IntegerVariable; /// The [`PropagatorConstructor`] for the [`DivisionPropagator`]. #[derive(Clone, Debug)] -pub(crate) struct DivisionArgs { - pub(crate) numerator: VA, - pub(crate) denominator: VB, - pub(crate) rhs: VC, - pub(crate) constraint_tag: ConstraintTag, +pub struct DivisionArgs { + pub numerator: VA, + pub denominator: VB, + pub rhs: VC, + pub constraint_tag: ConstraintTag, } const ID_NUMERATOR: LocalId = LocalId::from(0); @@ -73,7 +73,7 @@ where /// /// The implementation is ported from [OR-tools](https://github.com/google/or-tools/blob/870edf6f7bff6b8ff0d267d936be7e331c5b8c2d/ortools/sat/integer_expr.cc#L1209C1-L1209C19). #[derive(Clone, Debug)] -pub(crate) struct DivisionPropagator { +pub struct DivisionPropagator { numerator: VA, denominator: VB, rhs: VC, diff --git a/pumpkin-crates/core/src/propagators/arithmetic/integer_multiplication.rs b/pumpkin-crates/propagators/src/propagators/arithmetic/integer_multiplication.rs similarity index 93% rename from pumpkin-crates/core/src/propagators/arithmetic/integer_multiplication.rs rename to pumpkin-crates/propagators/src/propagators/arithmetic/integer_multiplication.rs index 1bacc65b7..e84d9cc76 100644 --- a/pumpkin-crates/core/src/propagators/arithmetic/integer_multiplication.rs +++ b/pumpkin-crates/propagators/src/propagators/arithmetic/integer_multiplication.rs @@ -1,30 +1,30 @@ -use crate::basic_types::PropagationStatusCP; -use crate::basic_types::PropagatorConflict; -use crate::conjunction; -use crate::declare_inference_label; -use crate::engine::variables::IntegerVariable; -use crate::predicate; -use crate::proof::ConstraintTag; -use crate::proof::InferenceCode; -use crate::propagation::DomainEvents; -use crate::propagation::LocalId; -use crate::propagation::Priority; -use crate::propagation::PropagationContext; -use crate::propagation::Propagator; -use crate::propagation::PropagatorConstructor; -use crate::propagation::PropagatorConstructorContext; -use crate::propagation::ReadDomains; -use crate::pumpkin_assert_simple; +use pumpkin_core::asserts::pumpkin_assert_simple; +use pumpkin_core::conjunction; +use pumpkin_core::declare_inference_label; +use pumpkin_core::predicate; +use pumpkin_core::proof::ConstraintTag; +use pumpkin_core::proof::InferenceCode; +use pumpkin_core::propagation::DomainEvents; +use pumpkin_core::propagation::LocalId; +use pumpkin_core::propagation::Priority; +use pumpkin_core::propagation::PropagationContext; +use pumpkin_core::propagation::Propagator; +use pumpkin_core::propagation::PropagatorConstructor; +use pumpkin_core::propagation::PropagatorConstructorContext; +use pumpkin_core::propagation::ReadDomains; +use pumpkin_core::results::PropagationStatusCP; +use pumpkin_core::state::PropagatorConflict; +use pumpkin_core::variables::IntegerVariable; declare_inference_label!(IntegerMultiplication); /// The [`PropagatorConstructor`] for [`IntegerMultiplicationPropagator`]. #[derive(Clone, Debug)] -pub(crate) struct IntegerMultiplicationArgs { - pub(crate) a: VA, - pub(crate) b: VB, - pub(crate) c: VC, - pub(crate) constraint_tag: ConstraintTag, +pub struct IntegerMultiplicationArgs { + pub a: VA, + pub b: VB, + pub c: VC, + pub constraint_tag: ConstraintTag, } impl PropagatorConstructor for IntegerMultiplicationArgs @@ -60,7 +60,7 @@ where /// (currently) only propagates the signs of the variables, the case where a, b, c >= 0, and detects /// a conflict if the variables are fixed. #[derive(Clone, Debug)] -pub(crate) struct IntegerMultiplicationPropagator { +pub struct IntegerMultiplicationPropagator { a: VA, b: VB, c: VC, diff --git a/pumpkin-crates/core/src/propagators/arithmetic/linear_less_or_equal.rs b/pumpkin-crates/propagators/src/propagators/arithmetic/linear_less_or_equal.rs similarity index 89% rename from pumpkin-crates/core/src/propagators/arithmetic/linear_less_or_equal.rs rename to pumpkin-crates/propagators/src/propagators/arithmetic/linear_less_or_equal.rs index 5eefca4ee..86d424f67 100644 --- a/pumpkin-crates/core/src/propagators/arithmetic/linear_less_or_equal.rs +++ b/pumpkin-crates/propagators/src/propagators/arithmetic/linear_less_or_equal.rs @@ -1,36 +1,36 @@ -use crate::basic_types::PropagationStatusCP; -use crate::basic_types::PropagatorConflict; -use crate::basic_types::PropositionalConjunction; -use crate::declare_inference_label; -use crate::engine::TrailedInteger; -use crate::engine::notifications::OpaqueDomainEvent; -use crate::engine::variables::IntegerVariable; -use crate::predicate; -use crate::predicates::Predicate; -use crate::proof::ConstraintTag; -use crate::proof::InferenceCode; -use crate::propagation::DomainEvents; -use crate::propagation::Domains; -use crate::propagation::EnqueueDecision; -use crate::propagation::ExplanationContext; -use crate::propagation::LocalId; -use crate::propagation::NotificationContext; -use crate::propagation::Priority; -use crate::propagation::PropagationContext; -use crate::propagation::Propagator; -use crate::propagation::PropagatorConstructor; -use crate::propagation::PropagatorConstructorContext; -use crate::propagation::ReadDomains; -use crate::pumpkin_assert_simple; +use pumpkin_core::asserts::pumpkin_assert_simple; +use pumpkin_core::declare_inference_label; +use pumpkin_core::predicate; +use pumpkin_core::predicates::Predicate; +use pumpkin_core::predicates::PropositionalConjunction; +use pumpkin_core::proof::ConstraintTag; +use pumpkin_core::proof::InferenceCode; +use pumpkin_core::propagation::DomainEvents; +use pumpkin_core::propagation::Domains; +use pumpkin_core::propagation::EnqueueDecision; +use pumpkin_core::propagation::ExplanationContext; +use pumpkin_core::propagation::LocalId; +use pumpkin_core::propagation::NotificationContext; +use pumpkin_core::propagation::OpaqueDomainEvent; +use pumpkin_core::propagation::Priority; +use pumpkin_core::propagation::PropagationContext; +use pumpkin_core::propagation::Propagator; +use pumpkin_core::propagation::PropagatorConstructor; +use pumpkin_core::propagation::PropagatorConstructorContext; +use pumpkin_core::propagation::ReadDomains; +use pumpkin_core::propagation::TrailedInteger; +use pumpkin_core::results::PropagationStatusCP; +use pumpkin_core::state::PropagatorConflict; +use pumpkin_core::variables::IntegerVariable; declare_inference_label!(LinearBounds); /// The [`PropagatorConstructor`] for the [`LinearLessOrEqualPropagator`]. #[derive(Clone, Debug)] -pub(crate) struct LinearLessOrEqualPropagatorArgs { - pub(crate) x: Box<[Var]>, - pub(crate) c: i32, - pub(crate) constraint_tag: ConstraintTag, +pub struct LinearLessOrEqualPropagatorArgs { + pub x: Box<[Var]>, + pub c: i32, + pub constraint_tag: ConstraintTag, } impl PropagatorConstructor for LinearLessOrEqualPropagatorArgs @@ -74,7 +74,7 @@ where /// Propagator for the constraint `\sum x_i <= c`. #[derive(Clone, Debug)] -pub(crate) struct LinearLessOrEqualPropagator { +pub struct LinearLessOrEqualPropagator { x: Box<[Var]>, c: i32, diff --git a/pumpkin-crates/core/src/propagators/arithmetic/linear_not_equal.rs b/pumpkin-crates/propagators/src/propagators/arithmetic/linear_not_equal.rs similarity index 92% rename from pumpkin-crates/core/src/propagators/arithmetic/linear_not_equal.rs rename to pumpkin-crates/propagators/src/propagators/arithmetic/linear_not_equal.rs index 9e3f26abb..be09af1f5 100644 --- a/pumpkin-crates/core/src/propagators/arithmetic/linear_not_equal.rs +++ b/pumpkin-crates/propagators/src/propagators/arithmetic/linear_not_equal.rs @@ -1,43 +1,41 @@ use std::rc::Rc; use enumset::enum_set; - -use crate::basic_types::PropagationStatusCP; -use crate::basic_types::PropagatorConflict; -use crate::basic_types::PropositionalConjunction; -use crate::declare_inference_label; -use crate::engine::notifications::DomainEvent; -use crate::engine::notifications::OpaqueDomainEvent; -use crate::engine::variables::IntegerVariable; -use crate::predicate; -use crate::proof::ConstraintTag; -use crate::proof::InferenceCode; -use crate::propagation::DomainEvents; -use crate::propagation::Domains; -use crate::propagation::EnqueueDecision; -use crate::propagation::LocalId; -use crate::propagation::NotificationContext; -use crate::propagation::Priority; -use crate::propagation::PropagationContext; -use crate::propagation::Propagator; -use crate::propagation::PropagatorConstructor; -use crate::propagation::PropagatorConstructorContext; -use crate::propagation::ReadDomains; -use crate::pumpkin_assert_extreme; -use crate::pumpkin_assert_moderate; -use crate::pumpkin_assert_simple; - +use pumpkin_core::asserts::pumpkin_assert_extreme; +use pumpkin_core::asserts::pumpkin_assert_moderate; +use pumpkin_core::asserts::pumpkin_assert_simple; +use pumpkin_core::declare_inference_label; +use pumpkin_core::predicate; +use pumpkin_core::predicates::PropositionalConjunction; +use pumpkin_core::proof::ConstraintTag; +use pumpkin_core::proof::InferenceCode; +use pumpkin_core::propagation::DomainEvent; +use pumpkin_core::propagation::DomainEvents; +use pumpkin_core::propagation::Domains; +use pumpkin_core::propagation::EnqueueDecision; +use pumpkin_core::propagation::LocalId; +use pumpkin_core::propagation::NotificationContext; +use pumpkin_core::propagation::OpaqueDomainEvent; +use pumpkin_core::propagation::Priority; +use pumpkin_core::propagation::PropagationContext; +use pumpkin_core::propagation::Propagator; +use pumpkin_core::propagation::PropagatorConstructor; +use pumpkin_core::propagation::PropagatorConstructorContext; +use pumpkin_core::propagation::ReadDomains; +use pumpkin_core::results::PropagationStatusCP; +use pumpkin_core::state::PropagatorConflict; +use pumpkin_core::variables::IntegerVariable; declare_inference_label!(LinearNotEquals); /// The [`PropagatorConstructor`] for the [`LinearNotEqualPropagator`]. #[derive(Clone, Debug)] -pub(crate) struct LinearNotEqualPropagatorArgs { +pub struct LinearNotEqualPropagatorArgs { /// The terms of the sum - pub(crate) terms: Rc<[Var]>, + pub terms: Rc<[Var]>, /// The right-hand side of the sum - pub(crate) rhs: i32, + pub rhs: i32, /// The constraint tag of the constraint this propagator is propagating for. - pub(crate) constraint_tag: ConstraintTag, + pub constraint_tag: ConstraintTag, } impl PropagatorConstructor for LinearNotEqualPropagatorArgs @@ -81,7 +79,7 @@ where /// Propagator for the constraint `\sum x_i != rhs`, where `x_i` are /// integer variables and `rhs` is an integer constant. #[derive(Clone, Debug)] -pub(crate) struct LinearNotEqualPropagator { +pub struct LinearNotEqualPropagator { /// The terms of the sum terms: Rc<[Var]>, /// The right-hand side of the sum diff --git a/pumpkin-crates/core/src/propagators/arithmetic/maximum.rs b/pumpkin-crates/propagators/src/propagators/arithmetic/maximum.rs similarity index 89% rename from pumpkin-crates/core/src/propagators/arithmetic/maximum.rs rename to pumpkin-crates/propagators/src/propagators/arithmetic/maximum.rs index ad71bb01a..f6f6aef0a 100644 --- a/pumpkin-crates/core/src/propagators/arithmetic/maximum.rs +++ b/pumpkin-crates/propagators/src/propagators/arithmetic/maximum.rs @@ -1,25 +1,25 @@ -use crate::basic_types::PropagationStatusCP; -use crate::basic_types::PropositionalConjunction; -use crate::conjunction; -use crate::declare_inference_label; -use crate::engine::variables::IntegerVariable; -use crate::predicate; -use crate::proof::ConstraintTag; -use crate::proof::InferenceCode; -use crate::propagation::DomainEvents; -use crate::propagation::LocalId; -use crate::propagation::Priority; -use crate::propagation::PropagationContext; -use crate::propagation::Propagator; -use crate::propagation::PropagatorConstructor; -use crate::propagation::PropagatorConstructorContext; -use crate::propagation::ReadDomains; +use pumpkin_core::conjunction; +use pumpkin_core::declare_inference_label; +use pumpkin_core::predicate; +use pumpkin_core::predicates::PropositionalConjunction; +use pumpkin_core::proof::ConstraintTag; +use pumpkin_core::proof::InferenceCode; +use pumpkin_core::propagation::DomainEvents; +use pumpkin_core::propagation::LocalId; +use pumpkin_core::propagation::Priority; +use pumpkin_core::propagation::PropagationContext; +use pumpkin_core::propagation::Propagator; +use pumpkin_core::propagation::PropagatorConstructor; +use pumpkin_core::propagation::PropagatorConstructorContext; +use pumpkin_core::propagation::ReadDomains; +use pumpkin_core::results::PropagationStatusCP; +use pumpkin_core::variables::IntegerVariable; #[derive(Clone, Debug)] -pub(crate) struct MaximumArgs { - pub(crate) array: Box<[ElementVar]>, - pub(crate) rhs: Rhs, - pub(crate) constraint_tag: ConstraintTag, +pub struct MaximumArgs { + pub array: Box<[ElementVar]>, + pub rhs: Rhs, + pub constraint_tag: ConstraintTag, } declare_inference_label!(Maximum); @@ -61,7 +61,7 @@ where /// Bounds-consistent propagator which enforces `max(array) = rhs`. Can be constructed through /// [`MaximumConstructor`]. #[derive(Clone, Debug)] -pub(crate) struct MaximumPropagator { +pub struct MaximumPropagator { array: Box<[ElementVar]>, rhs: Rhs, inference_code: InferenceCode, diff --git a/pumpkin-crates/core/src/propagators/arithmetic/mod.rs b/pumpkin-crates/propagators/src/propagators/arithmetic/mod.rs similarity index 53% rename from pumpkin-crates/core/src/propagators/arithmetic/mod.rs rename to pumpkin-crates/propagators/src/propagators/arithmetic/mod.rs index b5972b038..675514622 100644 --- a/pumpkin-crates/core/src/propagators/arithmetic/mod.rs +++ b/pumpkin-crates/propagators/src/propagators/arithmetic/mod.rs @@ -5,3 +5,11 @@ pub(crate) mod integer_multiplication; pub(crate) mod linear_less_or_equal; pub(crate) mod linear_not_equal; pub(crate) mod maximum; + +pub use absolute_value::*; +pub use binary::*; +pub use integer_division::*; +pub use integer_multiplication::*; +pub use linear_less_or_equal::*; +pub use linear_not_equal::*; +pub use maximum::*; diff --git a/pumpkin-crates/core/src/propagators/cumulative/mod.rs b/pumpkin-crates/propagators/src/propagators/cumulative/mod.rs similarity index 95% rename from pumpkin-crates/core/src/propagators/cumulative/mod.rs rename to pumpkin-crates/propagators/src/propagators/cumulative/mod.rs index 8f1ce41d6..a310d9582 100644 --- a/pumpkin-crates/core/src/propagators/cumulative/mod.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/mod.rs @@ -117,9 +117,14 @@ //! ``` mod time_table; pub use time_table::CumulativeExplanationType; -pub(crate) use time_table::*; mod options; pub use options::*; +pub use time_table::TimeTableOverIntervalIncrementalPropagator; +pub use time_table::TimeTableOverIntervalPropagator; +pub use time_table::TimeTablePerPointIncrementalPropagator; +pub use time_table::TimeTablePerPointPropagator; +pub(crate) use time_table::*; +pub use utils::ArgTask; mod utils; pub(crate) use utils::*; diff --git a/pumpkin-crates/core/src/propagators/cumulative/options.rs b/pumpkin-crates/propagators/src/propagators/cumulative/options.rs similarity index 84% rename from pumpkin-crates/core/src/propagators/cumulative/options.rs rename to pumpkin-crates/propagators/src/propagators/cumulative/options.rs index 1b7d4f2bc..d602ec9e9 100644 --- a/pumpkin-crates/core/src/propagators/cumulative/options.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/options.rs @@ -3,18 +3,18 @@ use super::CumulativeExplanationType; use crate::constraints; #[derive(Debug, Default, Clone, Copy)] -pub(crate) struct CumulativePropagatorOptions { +pub struct CumulativePropagatorOptions { /// Specifies whether it is allowed to create holes in the domain; if this parameter is set to /// false then it will only adjust the bounds when appropriate rather than removing values from /// the domain - pub(crate) allow_holes_in_domain: bool, + pub allow_holes_in_domain: bool, /// The type of explanation which is used by the cumulative to explain propagations and /// conflicts. - pub(crate) explanation_type: CumulativeExplanationType, + pub explanation_type: CumulativeExplanationType, /// Determines whether a sequence of profiles is generated when explaining a propagation. - pub(crate) generate_sequence: bool, + pub generate_sequence: bool, /// Determines whether to incrementally backtrack or to calculate from scratch - pub(crate) incremental_backtracking: bool, + pub incremental_backtracking: bool, } /// The options provided to the [`constraints::cumulative`] constraints. @@ -23,9 +23,9 @@ pub struct CumulativeOptions { /// The propagation method which is used for the cumulative constraints; currently all of them /// are variations of time-tabling. The default is incremental time-tabling reasoning over /// intervals. - pub(crate) propagation_method: CumulativePropagationMethod, + pub propagation_method: CumulativePropagationMethod, /// The options which are passed to the propagator itself - pub(crate) propagator_options: CumulativePropagatorOptions, + pub propagator_options: CumulativePropagatorOptions, } impl CumulativeOptions { diff --git a/pumpkin-crates/core/src/propagators/cumulative/time_table/explanations/big_step.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/big_step.rs similarity index 95% rename from pumpkin-crates/core/src/propagators/cumulative/time_table/explanations/big_step.rs rename to pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/big_step.rs index 45b150cd0..f8ecce797 100644 --- a/pumpkin-crates/core/src/propagators/cumulative/time_table/explanations/big_step.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/big_step.rs @@ -1,14 +1,15 @@ use std::cmp::max; use std::rc::Rc; -use crate::predicate; -use crate::predicates::Predicate; -use crate::predicates::PropositionalConjunction; -use crate::propagation::Domains; -use crate::propagation::ReadDomains; +use pumpkin_core::predicate; +use pumpkin_core::predicates::Predicate; +use pumpkin_core::predicates::PropositionalConjunction; +use pumpkin_core::propagation::Domains; +use pumpkin_core::propagation::ReadDomains; +use pumpkin_core::variables::IntegerVariable; + use crate::propagators::ResourceProfile; use crate::propagators::Task; -use crate::variables::IntegerVariable; /// Creates the propagation explanation using the big-step approach (see /// [`CumulativeExplanationType::BigStep`]) diff --git a/pumpkin-crates/core/src/propagators/cumulative/time_table/explanations/mod.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/mod.rs similarity index 97% rename from pumpkin-crates/core/src/propagators/cumulative/time_table/explanations/mod.rs rename to pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/mod.rs index cc96aae27..c4f05a91f 100644 --- a/pumpkin-crates/core/src/propagators/cumulative/time_table/explanations/mod.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/mod.rs @@ -10,13 +10,13 @@ use naive::create_naive_predicate_propagating_task_lower_bound_propagation; use naive::create_naive_predicate_propagating_task_upper_bound_propagation; use pointwise::create_pointwise_predicate_propagating_task_lower_bound_propagation; use pointwise::create_pointwise_predicate_propagating_task_upper_bound_propagation; +use pumpkin_core::predicates::Predicate; +use pumpkin_core::predicates::PropositionalConjunction; +use pumpkin_core::propagation::Domains; +use pumpkin_core::variables::IntegerVariable; -use crate::predicates::Predicate; -use crate::predicates::PropositionalConjunction; -use crate::propagation::Domains; use crate::propagators::ResourceProfile; use crate::propagators::Task; -use crate::variables::IntegerVariable; /// Determines what type of explanation is used for the cumulative constraint based on the /// explanations described in Section 4.5.1 and 4.5.2 of \[1\]. diff --git a/pumpkin-crates/core/src/propagators/cumulative/time_table/explanations/naive.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/naive.rs similarity index 95% rename from pumpkin-crates/core/src/propagators/cumulative/time_table/explanations/naive.rs rename to pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/naive.rs index c92f6b2b0..d61b6b783 100644 --- a/pumpkin-crates/core/src/propagators/cumulative/time_table/explanations/naive.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/naive.rs @@ -1,13 +1,14 @@ use std::rc::Rc; -use crate::predicate; -use crate::predicates::Predicate; -use crate::predicates::PropositionalConjunction; -use crate::propagation::Domains; -use crate::propagation::ReadDomains; +use pumpkin_core::predicate; +use pumpkin_core::predicates::Predicate; +use pumpkin_core::predicates::PropositionalConjunction; +use pumpkin_core::propagation::Domains; +use pumpkin_core::propagation::ReadDomains; +use pumpkin_core::variables::IntegerVariable; + use crate::propagators::ResourceProfile; use crate::propagators::Task; -use crate::variables::IntegerVariable; /// Creates the propagation explanation using the naive approach (see /// [`CumulativeExplanationType::Naive`]) diff --git a/pumpkin-crates/core/src/propagators/cumulative/time_table/explanations/pointwise.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/pointwise.rs similarity index 96% rename from pumpkin-crates/core/src/propagators/cumulative/time_table/explanations/pointwise.rs rename to pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/pointwise.rs index e6cf85914..d061467a5 100644 --- a/pumpkin-crates/core/src/propagators/cumulative/time_table/explanations/pointwise.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/pointwise.rs @@ -1,20 +1,21 @@ use std::rc::Rc; -use crate::constraint_arguments::CumulativeExplanationType; -use crate::engine::EmptyDomainConflict; -use crate::predicate; -use crate::predicates::Predicate; -use crate::predicates::PropositionalConjunction; -use crate::proof::InferenceCode; -use crate::propagation::PropagationContext; -use crate::propagation::ReadDomains; +use pumpkin_core::asserts::pumpkin_assert_extreme; +use pumpkin_core::asserts::pumpkin_assert_simple; +use pumpkin_core::predicate; +use pumpkin_core::predicates::Predicate; +use pumpkin_core::predicates::PropositionalConjunction; +use pumpkin_core::proof::InferenceCode; +use pumpkin_core::propagation::PropagationContext; +use pumpkin_core::propagation::ReadDomains; +use pumpkin_core::state::EmptyDomainConflict; +use pumpkin_core::variables::IntegerVariable; + +use crate::propagators::CumulativeExplanationType; use crate::propagators::ResourceProfile; use crate::propagators::Task; use crate::propagators::cumulative::time_table::explanations::add_propagating_task_predicate_lower_bound; use crate::propagators::cumulative::time_table::explanations::add_propagating_task_predicate_upper_bound; -use crate::pumpkin_assert_extreme; -use crate::pumpkin_assert_simple; -use crate::variables::IntegerVariable; pub(crate) fn propagate_lower_bounds_with_pointwise_explanations( context: &mut PropagationContext, diff --git a/pumpkin-crates/core/src/propagators/cumulative/time_table/mod.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/mod.rs similarity index 95% rename from pumpkin-crates/core/src/propagators/cumulative/time_table/mod.rs rename to pumpkin-crates/propagators/src/propagators/cumulative/time_table/mod.rs index 9bb65ce5e..f8c5618ab 100644 --- a/pumpkin-crates/core/src/propagators/cumulative/time_table/mod.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/mod.rs @@ -77,12 +77,12 @@ mod time_table_over_interval; mod time_table_per_point; mod time_table_util; pub use explanations::CumulativeExplanationType; -pub(crate) use over_interval_incremental_propagator::*; -pub(crate) use per_point_incremental_propagator::*; -pub(crate) use time_table_over_interval::*; -pub(crate) use time_table_per_point::*; +pub use over_interval_incremental_propagator::*; +pub use per_point_incremental_propagator::*; +use pumpkin_core::declare_inference_label; +pub use time_table_over_interval::*; +pub use time_table_per_point::*; -use crate::declare_inference_label; #[cfg(doc)] use crate::propagators::Task; #[cfg(doc)] diff --git a/pumpkin-crates/core/src/propagators/cumulative/time_table/over_interval_incremental_propagator/checks.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/checks.rs similarity index 99% rename from pumpkin-crates/core/src/propagators/cumulative/time_table/over_interval_incremental_propagator/checks.rs rename to pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/checks.rs index 59ff17cc0..9eacfa978 100644 --- a/pumpkin-crates/core/src/propagators/cumulative/time_table/over_interval_incremental_propagator/checks.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/checks.rs @@ -5,10 +5,11 @@ use std::cmp::min; use std::ops::Range; use std::rc::Rc; +use pumpkin_core::variables::IntegerVariable; + use crate::propagators::OverIntervalTimeTableType; use crate::propagators::ResourceProfile; use crate::propagators::Task; -use crate::variables::IntegerVariable; /// Determines whether the added mandatory part causes a new profile before the first overapping /// profile. diff --git a/pumpkin-crates/core/src/propagators/cumulative/time_table/over_interval_incremental_propagator/debug.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/debug.rs similarity index 97% rename from pumpkin-crates/core/src/propagators/cumulative/time_table/over_interval_incremental_propagator/debug.rs rename to pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/debug.rs index 6c542aba8..88a8f6b58 100644 --- a/pumpkin-crates/core/src/propagators/cumulative/time_table/over_interval_incremental_propagator/debug.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/debug.rs @@ -1,16 +1,17 @@ /// Contains functions related to debugging use std::ops::Range; -use crate::containers::HashSet; -use crate::proof::InferenceCode; -use crate::propagation::Domains; +use pumpkin_core::asserts::pumpkin_assert_extreme; +use pumpkin_core::asserts::pumpkin_assert_simple; +use pumpkin_core::containers::HashSet; +use pumpkin_core::proof::InferenceCode; +use pumpkin_core::propagation::Domains; +use pumpkin_core::variables::IntegerVariable; + use crate::propagators::CumulativeParameters; use crate::propagators::OverIntervalTimeTableType; use crate::propagators::ResourceProfile; use crate::propagators::create_time_table_over_interval_from_scratch; -use crate::pumpkin_assert_extreme; -use crate::pumpkin_assert_simple; -use crate::variables::IntegerVariable; /// Determines whether the provided `time_table` is the same as the one creatd from scratch /// using the following checks: diff --git a/pumpkin-crates/core/src/propagators/cumulative/time_table/over_interval_incremental_propagator/insertion.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/insertion.rs similarity index 96% rename from pumpkin-crates/core/src/propagators/cumulative/time_table/over_interval_incremental_propagator/insertion.rs rename to pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/insertion.rs index 0347256a8..8cfbacd3e 100644 --- a/pumpkin-crates/core/src/propagators/cumulative/time_table/over_interval_incremental_propagator/insertion.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/insertion.rs @@ -3,13 +3,14 @@ use std::ops::Range; use std::rc::Rc; +use pumpkin_core::asserts::pumpkin_assert_extreme; +use pumpkin_core::asserts::pumpkin_assert_moderate; +use pumpkin_core::variables::IntegerVariable; + use crate::propagators::OverIntervalTimeTableType; use crate::propagators::ResourceProfile; use crate::propagators::Task; use crate::propagators::cumulative::time_table::over_interval_incremental_propagator::checks; -use crate::pumpkin_assert_extreme; -use crate::pumpkin_assert_moderate; -use crate::variables::IntegerVariable; /// The new mandatory part added by `updated_task` (spanning `update_range`) overlaps with the /// profiles in `[start_index, end_index]`. This function calculates the added, and updated diff --git a/pumpkin-crates/core/src/propagators/cumulative/time_table/over_interval_incremental_propagator/mod.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/mod.rs similarity index 67% rename from pumpkin-crates/core/src/propagators/cumulative/time_table/over_interval_incremental_propagator/mod.rs rename to pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/mod.rs index d38501a99..8f7afcf98 100644 --- a/pumpkin-crates/core/src/propagators/cumulative/time_table/over_interval_incremental_propagator/mod.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/mod.rs @@ -5,4 +5,4 @@ mod removal; mod synchronisation; mod time_table_over_interval_incremental; -pub(crate) use time_table_over_interval_incremental::*; +pub use time_table_over_interval_incremental::*; diff --git a/pumpkin-crates/core/src/propagators/cumulative/time_table/over_interval_incremental_propagator/removal.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/removal.rs similarity index 99% rename from pumpkin-crates/core/src/propagators/cumulative/time_table/over_interval_incremental_propagator/removal.rs rename to pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/removal.rs index dc9dfa4af..7098ece26 100644 --- a/pumpkin-crates/core/src/propagators/cumulative/time_table/over_interval_incremental_propagator/removal.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/removal.rs @@ -5,10 +5,11 @@ use std::cmp::min; use std::ops::Range; use std::rc::Rc; +use pumpkin_core::variables::IntegerVariable; + use crate::propagators::OverIntervalTimeTableType; use crate::propagators::ResourceProfile; use crate::propagators::Task; -use crate::variables::IntegerVariable; /// The reduced mandatory part of `updated_task` (spanning `update_range`) overlaps with the /// profiles in `[start_index, end_index]`. This function calculates the added, and updated diff --git a/pumpkin-crates/core/src/propagators/cumulative/time_table/over_interval_incremental_propagator/synchronisation.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/synchronisation.rs similarity index 96% rename from pumpkin-crates/core/src/propagators/cumulative/time_table/over_interval_incremental_propagator/synchronisation.rs rename to pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/synchronisation.rs index 2decdf04c..dfcb3cd1c 100644 --- a/pumpkin-crates/core/src/propagators/cumulative/time_table/over_interval_incremental_propagator/synchronisation.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/synchronisation.rs @@ -1,11 +1,14 @@ use std::rc::Rc; +use pumpkin_core::proof::InferenceCode; +use pumpkin_core::propagation::Domains; +use pumpkin_core::propagation::ReadDomains; +use pumpkin_core::results::PropagationStatusCP; +use pumpkin_core::state::Conflict; +use pumpkin_core::variables::IntegerVariable; + use super::debug::are_mergeable; use super::debug::merge_profiles; -use crate::basic_types::PropagationStatusCP; -use crate::proof::InferenceCode; -use crate::propagation::Domains; -use crate::propagation::ReadDomains; use crate::propagators::CumulativeParameters; use crate::propagators::OverIntervalTimeTableType; use crate::propagators::ResourceProfile; @@ -13,8 +16,6 @@ use crate::propagators::ResourceProfile; use crate::propagators::TimeTableOverIntervalPropagator; use crate::propagators::create_time_table_over_interval_from_scratch; use crate::propagators::cumulative::time_table::propagation_handler::create_conflict_explanation; -use crate::state::Conflict; -use crate::variables::IntegerVariable; /// Finds the conflicting profile which would have been found by the /// [`TimeTableOverIntervalPropagator`]; this is the first conflicting profile in terms of start diff --git a/pumpkin-crates/core/src/propagators/cumulative/time_table/over_interval_incremental_propagator/time_table_over_interval_incremental.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/time_table_over_interval_incremental.rs similarity index 97% rename from pumpkin-crates/core/src/propagators/cumulative/time_table/over_interval_incremental_propagator/time_table_over_interval_incremental.rs rename to pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/time_table_over_interval_incremental.rs index 522c04179..429502f51 100644 --- a/pumpkin-crates/core/src/propagators/cumulative/time_table/over_interval_incremental_propagator/time_table_over_interval_incremental.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/time_table_over_interval_incremental.rs @@ -2,25 +2,30 @@ use std::fmt::Debug; use std::ops::Range; use std::rc::Rc; +use pumpkin_core::asserts::pumpkin_assert_advanced; +use pumpkin_core::asserts::pumpkin_assert_extreme; +use pumpkin_core::asserts::pumpkin_assert_simple; +use pumpkin_core::conjunction; +use pumpkin_core::proof::ConstraintTag; +use pumpkin_core::proof::InferenceCode; +use pumpkin_core::propagation::DomainEvent; +use pumpkin_core::propagation::Domains; +use pumpkin_core::propagation::EnqueueDecision; +use pumpkin_core::propagation::LocalId; +use pumpkin_core::propagation::NotificationContext; +use pumpkin_core::propagation::OpaqueDomainEvent; +use pumpkin_core::propagation::Priority; +use pumpkin_core::propagation::PropagationContext; +use pumpkin_core::propagation::Propagator; +use pumpkin_core::propagation::PropagatorConstructor; +use pumpkin_core::propagation::PropagatorConstructorContext; +use pumpkin_core::results::PropagationStatusCP; +use pumpkin_core::state::Conflict; +use pumpkin_core::state::PropagatorConflict; +use pumpkin_core::variables::IntegerVariable; + use super::insertion; use super::removal; -use crate::basic_types::PropagationStatusCP; -use crate::basic_types::PropagatorConflict; -use crate::conjunction; -use crate::engine::notifications::OpaqueDomainEvent; -use crate::engine::notifications::DomainEvent; -use crate::propagation::Priority; -use crate::propagation::PropagatorConstructorContext; -use crate::propagation::NotificationContext; -use crate::propagation::PropagatorConstructor; -use crate::propagation::EnqueueDecision; -use crate::propagation::LocalId; -use crate::propagation::Domains; -use crate::propagation::PropagationContext; -use crate::propagation::Propagator; -use crate::engine::variables::IntegerVariable; -use crate::proof::ConstraintTag; -use crate::proof::InferenceCode; use crate::propagators::create_time_table_over_interval_from_scratch; use crate::propagators::cumulative::time_table::over_interval_incremental_propagator::debug; use crate::propagators::cumulative::time_table::over_interval_incremental_propagator::synchronisation::check_synchronisation_conflict_explanation_over_interval; @@ -50,10 +55,6 @@ use crate::propagators::TimeTableOverIntervalPropagator; #[cfg(doc)] use crate::propagators::TimeTablePerPointPropagator; use crate::propagators::UpdatableStructures; -use crate::pumpkin_assert_advanced; -use crate::pumpkin_assert_extreme; -use crate::pumpkin_assert_simple; -use crate::state::Conflict; /// [`Propagator`] responsible for using time-table reasoning to propagate the [Cumulative](https://sofdem.github.io/gccat/gccat/Ccumulative.html) constraint /// where a time-table is a structure which stores the mandatory resource usage of the tasks at @@ -75,7 +76,7 @@ use crate::state::Conflict; /// \[1\] A. Schutt, Improving scheduling by learning. University of Melbourne, Department of /// Computer Science and Software Engineering, 2011. #[derive(Clone, Debug)] -pub(crate) struct TimeTableOverIntervalIncrementalPropagator { +pub struct TimeTableOverIntervalIncrementalPropagator { /// The key `t` (representing a time-point) holds the mandatory resource consumption of /// [`Task`]s at that time (stored in a [`ResourceProfile`]); the [`ResourceProfile`]s are /// sorted based on start time and they are assumed to be non-overlapping @@ -131,7 +132,7 @@ impl PropagatorConstruc impl TimeTableOverIntervalIncrementalPropagator { - pub(crate) fn new( + pub fn new( arg_tasks: &[ArgTask], capacity: i32, cumulative_options: CumulativePropagatorOptions, diff --git a/pumpkin-crates/core/src/propagators/cumulative/time_table/per_point_incremental_propagator/mod.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/per_point_incremental_propagator/mod.rs similarity index 53% rename from pumpkin-crates/core/src/propagators/cumulative/time_table/per_point_incremental_propagator/mod.rs rename to pumpkin-crates/propagators/src/propagators/cumulative/time_table/per_point_incremental_propagator/mod.rs index bf43dc9a2..edc5325c3 100644 --- a/pumpkin-crates/core/src/propagators/cumulative/time_table/per_point_incremental_propagator/mod.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/per_point_incremental_propagator/mod.rs @@ -1,4 +1,4 @@ mod synchronisation; mod time_table_per_point_incremental; -pub(crate) use time_table_per_point_incremental::*; +pub use time_table_per_point_incremental::*; diff --git a/pumpkin-crates/core/src/propagators/cumulative/time_table/per_point_incremental_propagator/synchronisation.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/per_point_incremental_propagator/synchronisation.rs similarity index 96% rename from pumpkin-crates/core/src/propagators/cumulative/time_table/per_point_incremental_propagator/synchronisation.rs rename to pumpkin-crates/propagators/src/propagators/cumulative/time_table/per_point_incremental_propagator/synchronisation.rs index c5a0fec47..dffac26e5 100644 --- a/pumpkin-crates/core/src/propagators/cumulative/time_table/per_point_incremental_propagator/synchronisation.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/per_point_incremental_propagator/synchronisation.rs @@ -1,17 +1,18 @@ use std::rc::Rc; -use crate::basic_types::PropagationStatusCP; -use crate::proof::InferenceCode; -use crate::propagation::Domains; +use pumpkin_core::asserts::pumpkin_assert_moderate; +use pumpkin_core::proof::InferenceCode; +use pumpkin_core::propagation::Domains; +use pumpkin_core::results::PropagationStatusCP; +use pumpkin_core::state::Conflict; +use pumpkin_core::variables::IntegerVariable; + use crate::propagators::CumulativeParameters; use crate::propagators::PerPointTimeTableType; use crate::propagators::ResourceProfile; use crate::propagators::Task; use crate::propagators::create_time_table_per_point_from_scratch; use crate::propagators::cumulative::time_table::propagation_handler::create_conflict_explanation; -use crate::pumpkin_assert_moderate; -use crate::state::Conflict; -use crate::variables::IntegerVariable; /// Returns whether the synchronised conflict explanation created by /// [`TimeTablePerPointIncrementalPropgator`] is the same as that created by @@ -164,9 +165,10 @@ fn sort_profile_based_on_id(profile: &mut Resour mod tests { use std::rc::Rc; + use pumpkin_core::propagation::LocalId; + use super::find_synchronised_conflict; use crate::engine::test_solver::TestSolver; - use crate::propagation::LocalId; use crate::propagators::CumulativeParameters; use crate::propagators::CumulativePropagatorOptions; use crate::propagators::PerPointTimeTableType; diff --git a/pumpkin-crates/core/src/propagators/cumulative/time_table/per_point_incremental_propagator/time_table_per_point_incremental.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/per_point_incremental_propagator/time_table_per_point_incremental.rs similarity index 98% rename from pumpkin-crates/core/src/propagators/cumulative/time_table/per_point_incremental_propagator/time_table_per_point_incremental.rs rename to pumpkin-crates/propagators/src/propagators/cumulative/time_table/per_point_incremental_propagator/time_table_per_point_incremental.rs index b717db86f..7504dc20f 100644 --- a/pumpkin-crates/core/src/propagators/cumulative/time_table/per_point_incremental_propagator/time_table_per_point_incremental.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/per_point_incremental_propagator/time_table_per_point_incremental.rs @@ -3,23 +3,27 @@ use std::collections::btree_map::Entry; use std::fmt::Debug; use std::rc::Rc; -use crate::basic_types::PropagationStatusCP; -use crate::basic_types::PropagatorConflict; -use crate::conjunction; -use crate::engine::notifications::DomainEvent; -use crate::engine::notifications::OpaqueDomainEvent; -use crate::engine::variables::IntegerVariable; -use crate::proof::ConstraintTag; -use crate::proof::InferenceCode; -use crate::propagation::Domains; -use crate::propagation::EnqueueDecision; -use crate::propagation::LocalId; -use crate::propagation::NotificationContext; -use crate::propagation::Priority; -use crate::propagation::PropagationContext; -use crate::propagation::Propagator; -use crate::propagation::PropagatorConstructor; -use crate::propagation::PropagatorConstructorContext; +use pumpkin_core::asserts::pumpkin_assert_advanced; +use pumpkin_core::asserts::pumpkin_assert_extreme; +use pumpkin_core::conjunction; +use pumpkin_core::proof::ConstraintTag; +use pumpkin_core::proof::InferenceCode; +use pumpkin_core::propagation::DomainEvent; +use pumpkin_core::propagation::Domains; +use pumpkin_core::propagation::EnqueueDecision; +use pumpkin_core::propagation::LocalId; +use pumpkin_core::propagation::NotificationContext; +use pumpkin_core::propagation::OpaqueDomainEvent; +use pumpkin_core::propagation::Priority; +use pumpkin_core::propagation::PropagationContext; +use pumpkin_core::propagation::Propagator; +use pumpkin_core::propagation::PropagatorConstructor; +use pumpkin_core::propagation::PropagatorConstructorContext; +use pumpkin_core::results::PropagationStatusCP; +use pumpkin_core::state::Conflict; +use pumpkin_core::state::PropagatorConflict; +use pumpkin_core::variables::IntegerVariable; + use crate::propagators::ArgTask; use crate::propagators::CumulativeParameters; use crate::propagators::CumulativePropagatorOptions; @@ -46,9 +50,6 @@ use crate::propagators::util::check_bounds_equal_at_propagation; use crate::propagators::util::create_tasks; use crate::propagators::util::register_tasks; use crate::propagators::util::update_bounds_task; -use crate::pumpkin_assert_advanced; -use crate::pumpkin_assert_extreme; -use crate::state::Conflict; /// [`Propagator`] responsible for using time-table reasoning to propagate the [Cumulative](https://sofdem.github.io/gccat/gccat/Ccumulative.html) constraint /// where a time-table is a structure which stores the mandatory resource usage of the tasks at @@ -71,7 +72,7 @@ use crate::state::Conflict; /// Computer Science and Software Engineering, 2011. #[derive(Debug, Clone)] -pub(crate) struct TimeTablePerPointIncrementalPropagator { +pub struct TimeTablePerPointIncrementalPropagator { /// The key `t` (representing a time-point) holds the mandatory resource consumption of /// [`Task`]s at that time (stored in a [`ResourceProfile`]); the [`ResourceProfile`]s are /// sorted based on start time and they are assumed to be non-overlapping @@ -121,7 +122,7 @@ impl Propagator impl TimeTablePerPointIncrementalPropagator { - pub(crate) fn new( + pub fn new( arg_tasks: &[ArgTask], capacity: i32, cumulative_options: CumulativePropagatorOptions, @@ -554,13 +555,13 @@ impl Propagator /// Contains functions related to debugging mod debug { + use pumpkin_core::proof::InferenceCode; + use pumpkin_core::propagation::Domains; + use pumpkin_core::variables::IntegerVariable; - use crate::proof::InferenceCode; - use crate::propagation::Domains; use crate::propagators::CumulativeParameters; use crate::propagators::PerPointTimeTableType; use crate::propagators::create_time_table_per_point_from_scratch; - use crate::variables::IntegerVariable; /// Determines whether the provided `time_table` is the same as the one creatd from scratch /// using the following checks: diff --git a/pumpkin-crates/core/src/propagators/cumulative/time_table/propagation_handler.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/propagation_handler.rs similarity index 97% rename from pumpkin-crates/core/src/propagators/cumulative/time_table/propagation_handler.rs rename to pumpkin-crates/propagators/src/propagators/cumulative/time_table/propagation_handler.rs index 882dc3b07..58dbe1da7 100644 --- a/pumpkin-crates/core/src/propagators/cumulative/time_table/propagation_handler.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/propagation_handler.rs @@ -3,6 +3,20 @@ use std::cmp::max; use std::cmp::min; use std::rc::Rc; +use pumpkin_core::asserts::pumpkin_assert_advanced; +use pumpkin_core::asserts::pumpkin_assert_extreme; +use pumpkin_core::asserts::pumpkin_assert_simple; +use pumpkin_core::predicate; +use pumpkin_core::predicates::Predicate; +use pumpkin_core::predicates::PropositionalConjunction; +use pumpkin_core::proof::InferenceCode; +use pumpkin_core::propagation::Domains; +use pumpkin_core::propagation::PropagationContext; +use pumpkin_core::propagation::ReadDomains; +use pumpkin_core::state::EmptyDomainConflict; +use pumpkin_core::state::PropagatorConflict; +use pumpkin_core::variables::IntegerVariable; + use super::CumulativeExplanationType; use super::explanations::add_propagating_task_predicate_lower_bound; use super::explanations::add_propagating_task_predicate_upper_bound; @@ -14,23 +28,9 @@ use super::explanations::naive::create_naive_conflict_explanation; use super::explanations::naive::create_naive_propagation_explanation; use super::explanations::pointwise::create_pointwise_conflict_explanation; use super::explanations::pointwise::create_pointwise_propagation_explanation; -use crate::basic_types::PropagatorConflict; -use crate::engine::EmptyDomainConflict; -use crate::predicate; -use crate::predicates::Predicate; -use crate::predicates::PropositionalConjunction; -use crate::proof::InferenceCode; -use crate::propagation::Domains; -use crate::propagation::HasAssignments; -use crate::propagation::PropagationContext; -use crate::propagation::ReadDomains; use crate::propagators::ResourceProfile; use crate::propagators::Task; use crate::propagators::cumulative::time_table::explanations::pointwise; -use crate::pumpkin_assert_advanced; -use crate::pumpkin_assert_extreme; -use crate::pumpkin_assert_simple; -use crate::variables::IntegerVariable; /// Structure for handling the creation of propagations and their explanations. pub(crate) struct CumulativePropagationHandler { @@ -48,18 +48,16 @@ fn check_explanation( explanation: &PropositionalConjunction, context: Domains, ) -> bool { - let all_predicates_hold = explanation - .iter() - .all(|&predicate| context.assignments().is_predicate_satisfied(predicate)); + let all_predicates_hold = explanation.iter().all(|&predicate| { + context + .evaluate_predicate(predicate) + .is_some_and(|value| value) + }); if !all_predicates_hold { eprintln!("Not all predicates hold in the explanation for {explained_predicate:?}") } let at_least_one_element_from_current_level = explanation.iter().any(|&predicate| { - context - .assignments() - .get_checkpoint_for_predicate(&predicate) - .unwrap() - == context.assignments().get_checkpoint() + context.get_checkpoint_for_predicate(predicate).unwrap() == context.get_checkpoint() }); if !at_least_one_element_from_current_level { eprintln!( @@ -479,6 +477,9 @@ where pub(crate) mod test_propagation_handler { use std::rc::Rc; + use pumpkin_core::propagation::Domains; + use pumpkin_core::propagation::LocalId; + use super::CumulativeExplanationType; use super::CumulativePropagationHandler; use super::create_conflict_explanation; @@ -491,9 +492,7 @@ pub(crate) mod test_propagation_handler { use crate::predicates::Predicate; use crate::predicates::PropositionalConjunction; use crate::proof::InferenceCode; - use crate::propagation::Domains; use crate::propagation::ExplanationContext; - use crate::propagation::LocalId; use crate::propagation::PropagationContext; use crate::propagation::PropagatorId; use crate::propagation::store::PropagatorStore; diff --git a/pumpkin-crates/core/src/propagators/cumulative/time_table/time_table_over_interval.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/time_table_over_interval.rs similarity index 97% rename from pumpkin-crates/core/src/propagators/cumulative/time_table/time_table_over_interval.rs rename to pumpkin-crates/propagators/src/propagators/cumulative/time_table/time_table_over_interval.rs index 3e25450f0..0f0086004 100644 --- a/pumpkin-crates/core/src/propagators/cumulative/time_table/time_table_over_interval.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/time_table_over_interval.rs @@ -1,26 +1,31 @@ use std::rc::Rc; +use pumpkin_core::asserts::pumpkin_assert_extreme; +use pumpkin_core::asserts::pumpkin_assert_moderate; +use pumpkin_core::asserts::pumpkin_assert_simple; +use pumpkin_core::conjunction; +use pumpkin_core::proof::ConstraintTag; +use pumpkin_core::proof::InferenceCode; +use pumpkin_core::propagation::DomainEvent; +use pumpkin_core::propagation::Domains; +use pumpkin_core::propagation::EnqueueDecision; +use pumpkin_core::propagation::LocalId; +use pumpkin_core::propagation::NotificationContext; +use pumpkin_core::propagation::OpaqueDomainEvent; +use pumpkin_core::propagation::Priority; +use pumpkin_core::propagation::PropagationContext; +use pumpkin_core::propagation::Propagator; +use pumpkin_core::propagation::PropagatorConstructor; +use pumpkin_core::propagation::PropagatorConstructorContext; +use pumpkin_core::propagation::ReadDomains; +use pumpkin_core::results::PropagationStatusCP; +use pumpkin_core::state::Conflict; +use pumpkin_core::state::PropagatorConflict; +use pumpkin_core::variables::IntegerVariable; + use super::TimeTable; use super::time_table_util::propagate_based_on_timetable; use super::time_table_util::should_enqueue; -use crate::basic_types::PropagationStatusCP; -use crate::basic_types::PropagatorConflict; -use crate::conjunction; -use crate::engine::notifications::DomainEvent; -use crate::engine::notifications::OpaqueDomainEvent; -use crate::engine::variables::IntegerVariable; -use crate::proof::ConstraintTag; -use crate::proof::InferenceCode; -use crate::propagation::Domains; -use crate::propagation::EnqueueDecision; -use crate::propagation::LocalId; -use crate::propagation::NotificationContext; -use crate::propagation::Priority; -use crate::propagation::PropagationContext; -use crate::propagation::Propagator; -use crate::propagation::PropagatorConstructor; -use crate::propagation::PropagatorConstructorContext; -use crate::propagation::ReadDomains; use crate::propagators::ArgTask; use crate::propagators::CumulativeParameters; use crate::propagators::CumulativePropagatorOptions; @@ -33,10 +38,6 @@ use crate::propagators::cumulative::time_table::propagation_handler::create_conf use crate::propagators::util::create_tasks; use crate::propagators::util::register_tasks; use crate::propagators::util::update_bounds_task; -use crate::pumpkin_assert_extreme; -use crate::pumpkin_assert_moderate; -use crate::pumpkin_assert_simple; -use crate::state::Conflict; /// An event storing the start and end of mandatory parts used for creating the time-table #[derive(Debug)] @@ -61,7 +62,7 @@ pub(crate) struct Event { /// \[1\] A. Schutt, Improving scheduling by learning. University of Melbourne, Department of /// Computer Science and Software Engineering, 2011. #[derive(Debug, Clone)] -pub(crate) struct TimeTableOverIntervalPropagator { +pub struct TimeTableOverIntervalPropagator { /// Stores whether the time-table is empty is_time_table_empty: bool, /// Stores the input parameters to the cumulative constraint @@ -81,7 +82,7 @@ pub(crate) struct TimeTableOverIntervalPropagator { pub(crate) type OverIntervalTimeTableType = Vec>; impl TimeTableOverIntervalPropagator { - pub(crate) fn new( + pub fn new( arg_tasks: &[ArgTask], capacity: i32, cumulative_options: CumulativePropagatorOptions, diff --git a/pumpkin-crates/core/src/propagators/cumulative/time_table/time_table_per_point.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/time_table_per_point.rs similarity index 97% rename from pumpkin-crates/core/src/propagators/cumulative/time_table/time_table_per_point.rs rename to pumpkin-crates/propagators/src/propagators/cumulative/time_table/time_table_per_point.rs index d555ba75f..c22a96faf 100644 --- a/pumpkin-crates/core/src/propagators/cumulative/time_table/time_table_per_point.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/time_table_per_point.rs @@ -5,27 +5,30 @@ use std::collections::BTreeMap; use std::rc::Rc; +use pumpkin_core::asserts::pumpkin_assert_extreme; +use pumpkin_core::conjunction; +use pumpkin_core::proof::ConstraintTag; +use pumpkin_core::proof::InferenceCode; +use pumpkin_core::propagation::DomainEvent; +use pumpkin_core::propagation::Domains; +use pumpkin_core::propagation::EnqueueDecision; +use pumpkin_core::propagation::LocalId; +use pumpkin_core::propagation::NotificationContext; +use pumpkin_core::propagation::OpaqueDomainEvent; +use pumpkin_core::propagation::Priority; +use pumpkin_core::propagation::PropagationContext; +use pumpkin_core::propagation::Propagator; +use pumpkin_core::propagation::PropagatorConstructor; +use pumpkin_core::propagation::PropagatorConstructorContext; +use pumpkin_core::propagation::ReadDomains; +use pumpkin_core::results::PropagationStatusCP; +use pumpkin_core::state::Conflict; +use pumpkin_core::state::PropagatorConflict; +use pumpkin_core::variables::IntegerVariable; + use super::TimeTable; use super::time_table_util::propagate_based_on_timetable; use super::time_table_util::should_enqueue; -use crate::basic_types::PropagationStatusCP; -use crate::basic_types::PropagatorConflict; -use crate::conjunction; -use crate::engine::notifications::DomainEvent; -use crate::engine::notifications::OpaqueDomainEvent; -use crate::engine::variables::IntegerVariable; -use crate::proof::ConstraintTag; -use crate::proof::InferenceCode; -use crate::propagation::Domains; -use crate::propagation::EnqueueDecision; -use crate::propagation::LocalId; -use crate::propagation::NotificationContext; -use crate::propagation::Priority; -use crate::propagation::PropagationContext; -use crate::propagation::Propagator; -use crate::propagation::PropagatorConstructor; -use crate::propagation::PropagatorConstructorContext; -use crate::propagation::ReadDomains; use crate::propagators::ArgTask; use crate::propagators::CumulativeParameters; use crate::propagators::CumulativePropagatorOptions; @@ -35,8 +38,6 @@ use crate::propagators::cumulative::time_table::propagation_handler::create_conf use crate::propagators::util::create_tasks; use crate::propagators::util::register_tasks; use crate::propagators::util::update_bounds_task; -use crate::pumpkin_assert_extreme; -use crate::state::Conflict; /// [`Propagator`] responsible for using time-table reasoning to propagate the [Cumulative](https://sofdem.github.io/gccat/gccat/Ccumulative.html) constraint /// where a time-table is a structure which stores the mandatory resource usage of the tasks at @@ -51,7 +52,7 @@ use crate::state::Conflict; /// \[1\] A. Schutt, Improving scheduling by learning. University of Melbourne, Department of /// Computer Science and Software Engineering, 2011. #[derive(Debug, Clone)] -pub(crate) struct TimeTablePerPointPropagator { +pub struct TimeTablePerPointPropagator { /// Stores whether the time-table is empty is_time_table_empty: bool, /// Stores the input parameters to the cumulative constraint @@ -74,7 +75,7 @@ pub(crate) struct TimeTablePerPointPropagator { pub(crate) type PerPointTimeTableType = BTreeMap>; impl TimeTablePerPointPropagator { - pub(crate) fn new( + pub fn new( arg_tasks: &[ArgTask], capacity: i32, cumulative_options: CumulativePropagatorOptions, diff --git a/pumpkin-crates/core/src/propagators/cumulative/time_table/time_table_util.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/time_table_util.rs similarity index 98% rename from pumpkin-crates/core/src/propagators/cumulative/time_table/time_table_util.rs rename to pumpkin-crates/propagators/src/propagators/cumulative/time_table/time_table_util.rs index d2531d77c..925602d70 100644 --- a/pumpkin-crates/core/src/propagators/cumulative/time_table/time_table_util.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/time_table_util.rs @@ -5,22 +5,23 @@ use std::cmp::min; use std::rc::Rc; -use crate::basic_types::PropagationStatusCP; -use crate::engine::variables::IntegerVariable; -use crate::proof::InferenceCode; -use crate::propagation::Domains; -use crate::propagation::EnqueueDecision; -use crate::propagation::PropagationContext; +use pumpkin_core::asserts::pumpkin_assert_extreme; +use pumpkin_core::proof::InferenceCode; +use pumpkin_core::propagation::Domains; +use pumpkin_core::propagation::EnqueueDecision; +use pumpkin_core::propagation::PropagationContext; +use pumpkin_core::propagation::ReadDomains; +use pumpkin_core::results::PropagationStatusCP; +use pumpkin_core::variables::IntegerVariable; + #[cfg(doc)] use crate::propagation::Propagator; -use crate::propagation::ReadDomains; use crate::propagators::CumulativeParameters; use crate::propagators::ResourceProfile; use crate::propagators::Task; use crate::propagators::UpdatableStructures; use crate::propagators::UpdatedTaskInfo; use crate::propagators::cumulative::time_table::propagation_handler::CumulativePropagationHandler; -use crate::pumpkin_assert_extreme; /// The result of [`should_enqueue`], contains the [`EnqueueDecision`] whether the propagator should /// currently be enqueued and potentially the updated [`Task`] (in the form of a @@ -780,11 +781,12 @@ pub(crate) fn backtrack_update( mod tests { use std::rc::Rc; + use pumpkin_core::propagation::Domains; + use pumpkin_core::propagation::LocalId; + use super::find_profiles_which_propagate_lower_bound; use crate::engine::Assignments; use crate::engine::TrailedValues; - use crate::propagation::Domains; - use crate::propagation::LocalId; use crate::propagators::ResourceProfile; use crate::propagators::Task; use crate::propagators::cumulative::time_table::time_table_util::find_profiles_which_propagate_upper_bound; diff --git a/pumpkin-crates/core/src/propagators/cumulative/utils/mod.rs b/pumpkin-crates/propagators/src/propagators/cumulative/utils/mod.rs similarity index 91% rename from pumpkin-crates/core/src/propagators/cumulative/utils/mod.rs rename to pumpkin-crates/propagators/src/propagators/cumulative/utils/mod.rs index 411609aeb..a5babedd1 100644 --- a/pumpkin-crates/core/src/propagators/cumulative/utils/mod.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/utils/mod.rs @@ -3,6 +3,7 @@ //! propagators mod structs; +pub use structs::ArgTask; pub(crate) use structs::*; pub(crate) mod util; diff --git a/pumpkin-crates/core/src/propagators/cumulative/utils/structs/mandatory_part_adjustments.rs b/pumpkin-crates/propagators/src/propagators/cumulative/utils/structs/mandatory_part_adjustments.rs similarity index 100% rename from pumpkin-crates/core/src/propagators/cumulative/utils/structs/mandatory_part_adjustments.rs rename to pumpkin-crates/propagators/src/propagators/cumulative/utils/structs/mandatory_part_adjustments.rs diff --git a/pumpkin-crates/core/src/propagators/cumulative/utils/structs/mod.rs b/pumpkin-crates/propagators/src/propagators/cumulative/utils/structs/mod.rs similarity index 93% rename from pumpkin-crates/core/src/propagators/cumulative/utils/structs/mod.rs rename to pumpkin-crates/propagators/src/propagators/cumulative/utils/structs/mod.rs index 03d40a593..2522d1ecf 100644 --- a/pumpkin-crates/core/src/propagators/cumulative/utils/structs/mod.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/utils/structs/mod.rs @@ -8,6 +8,6 @@ mod updated_task_info; pub(crate) use mandatory_part_adjustments::*; pub(crate) use parameters::*; pub(crate) use resource_profile::*; -pub(crate) use task::*; +pub use task::*; pub(crate) use updatable_structures::*; pub(crate) use updated_task_info::*; diff --git a/pumpkin-crates/core/src/propagators/cumulative/utils/structs/parameters.rs b/pumpkin-crates/propagators/src/propagators/cumulative/utils/structs/parameters.rs similarity index 97% rename from pumpkin-crates/core/src/propagators/cumulative/utils/structs/parameters.rs rename to pumpkin-crates/propagators/src/propagators/cumulative/utils/structs/parameters.rs index e11075741..7fc1d6387 100644 --- a/pumpkin-crates/core/src/propagators/cumulative/utils/structs/parameters.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/utils/structs/parameters.rs @@ -1,8 +1,9 @@ use std::rc::Rc; +use pumpkin_core::variables::IntegerVariable; + use super::Task; use crate::propagators::CumulativePropagatorOptions; -use crate::variables::IntegerVariable; /// Holds the data for the cumulative constraint; more specifically it holds: /// - The tasks diff --git a/pumpkin-crates/core/src/propagators/cumulative/utils/structs/resource_profile.rs b/pumpkin-crates/propagators/src/propagators/cumulative/utils/structs/resource_profile.rs similarity index 96% rename from pumpkin-crates/core/src/propagators/cumulative/utils/structs/resource_profile.rs rename to pumpkin-crates/propagators/src/propagators/cumulative/utils/structs/resource_profile.rs index fc3be6708..9997c8377 100644 --- a/pumpkin-crates/core/src/propagators/cumulative/utils/structs/resource_profile.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/utils/structs/resource_profile.rs @@ -1,8 +1,9 @@ use std::fmt::Debug; use std::rc::Rc; +use pumpkin_core::variables::IntegerVariable; + use super::Task; -use crate::variables::IntegerVariable; /// Structures used for storing the data related to resource profiles; /// A [`ResourceProfile`] represents a rectangle where the height is the cumulative mandatory diff --git a/pumpkin-crates/core/src/propagators/cumulative/utils/structs/task.rs b/pumpkin-crates/propagators/src/propagators/cumulative/utils/structs/task.rs similarity index 89% rename from pumpkin-crates/core/src/propagators/cumulative/utils/structs/task.rs rename to pumpkin-crates/propagators/src/propagators/cumulative/utils/structs/task.rs index ba87ef1d8..ef2934347 100644 --- a/pumpkin-crates/core/src/propagators/cumulative/utils/structs/task.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/utils/structs/task.rs @@ -2,8 +2,8 @@ use std::fmt::Debug; use std::hash::Hash; use std::rc::Rc; -use crate::propagation::LocalId; -use crate::variables::IntegerVariable; +use pumpkin_core::propagation::LocalId; +use pumpkin_core::variables::IntegerVariable; /// Structure which stores the variables related to a task; for now, only the start times are /// assumed to be variable @@ -50,12 +50,12 @@ impl Eq for Task {} /// The task which is passed as argument #[derive(Clone, Debug)] -pub(crate) struct ArgTask { +pub struct ArgTask { /// The [`IntegerVariable`] representing the start time of a task - pub(crate) start_time: Var, + pub start_time: Var, /// The processing time of the [`start_time`][ArgTask::start_time] (also referred to as /// duration of a task) - pub(crate) processing_time: i32, + pub processing_time: i32, /// How much of the resource the given task uses during its non-preemptive execution - pub(crate) resource_usage: i32, + pub resource_usage: i32, } diff --git a/pumpkin-crates/core/src/propagators/cumulative/utils/structs/updatable_structures.rs b/pumpkin-crates/propagators/src/propagators/cumulative/utils/structs/updatable_structures.rs similarity index 97% rename from pumpkin-crates/core/src/propagators/cumulative/utils/structs/updatable_structures.rs rename to pumpkin-crates/propagators/src/propagators/cumulative/utils/structs/updatable_structures.rs index 404501128..00a667395 100644 --- a/pumpkin-crates/core/src/propagators/cumulative/utils/structs/updatable_structures.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/utils/structs/updatable_structures.rs @@ -1,13 +1,14 @@ use std::rc::Rc; +use pumpkin_core::asserts::pumpkin_assert_moderate; +use pumpkin_core::containers::SparseSet; +use pumpkin_core::propagation::Domains; +use pumpkin_core::propagation::ReadDomains; +use pumpkin_core::variables::IntegerVariable; + use super::CumulativeParameters; use super::Task; use super::UpdatedTaskInfo; -use crate::containers::SparseSet; -use crate::propagation::Domains; -use crate::propagation::ReadDomains; -use crate::pumpkin_assert_moderate; -use crate::variables::IntegerVariable; /// Structures which are adjusted during search; either due to incrementality or to keep track of /// bounds. diff --git a/pumpkin-crates/core/src/propagators/cumulative/utils/structs/updated_task_info.rs b/pumpkin-crates/propagators/src/propagators/cumulative/utils/structs/updated_task_info.rs similarity index 100% rename from pumpkin-crates/core/src/propagators/cumulative/utils/structs/updated_task_info.rs rename to pumpkin-crates/propagators/src/propagators/cumulative/utils/structs/updated_task_info.rs diff --git a/pumpkin-crates/core/src/propagators/cumulative/utils/util.rs b/pumpkin-crates/propagators/src/propagators/cumulative/utils/util.rs similarity index 90% rename from pumpkin-crates/core/src/propagators/cumulative/utils/util.rs rename to pumpkin-crates/propagators/src/propagators/cumulative/utils/util.rs index b02e200c1..7e9bb18f2 100644 --- a/pumpkin-crates/core/src/propagators/cumulative/utils/util.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/utils/util.rs @@ -4,14 +4,14 @@ use std::rc::Rc; use enumset::enum_set; +use pumpkin_core::propagation::DomainEvent; +use pumpkin_core::propagation::DomainEvents; +use pumpkin_core::propagation::Domains; +use pumpkin_core::propagation::LocalId; +use pumpkin_core::propagation::PropagatorConstructorContext; +use pumpkin_core::propagation::ReadDomains; +use pumpkin_core::variables::IntegerVariable; -use crate::engine::notifications::DomainEvent; -use crate::engine::variables::IntegerVariable; -use crate::propagation::DomainEvents; -use crate::propagation::Domains; -use crate::propagation::LocalId; -use crate::propagation::PropagatorConstructorContext; -use crate::propagation::ReadDomains; use crate::propagators::ArgTask; use crate::propagators::Task; diff --git a/pumpkin-crates/core/src/propagators/disjunctive/disjunctive_propagator.rs b/pumpkin-crates/propagators/src/propagators/disjunctive/disjunctive_propagator.rs similarity index 94% rename from pumpkin-crates/core/src/propagators/disjunctive/disjunctive_propagator.rs rename to pumpkin-crates/propagators/src/propagators/disjunctive/disjunctive_propagator.rs index 567a9d9aa..82eae298e 100644 --- a/pumpkin-crates/core/src/propagators/disjunctive/disjunctive_propagator.rs +++ b/pumpkin-crates/propagators/src/propagators/disjunctive/disjunctive_propagator.rs @@ -1,27 +1,28 @@ use std::cmp::Reverse; use std::cmp::min; +use pumpkin_core::asserts::pumpkin_assert_simple; +use pumpkin_core::containers::StorageKey; +use pumpkin_core::predicate; +use pumpkin_core::predicates::PropositionalConjunction; +use pumpkin_core::proof::ConstraintTag; +use pumpkin_core::proof::InferenceCode; +use pumpkin_core::propagation::DomainEvents; +use pumpkin_core::propagation::LocalId; +use pumpkin_core::propagation::PropagationContext; +use pumpkin_core::propagation::Propagator; +use pumpkin_core::propagation::PropagatorConstructor; +use pumpkin_core::propagation::PropagatorConstructorContext; +use pumpkin_core::propagation::ReadDomains; +use pumpkin_core::results::PropagationStatusCP; +use pumpkin_core::state::Conflict; +use pumpkin_core::state::PropagatorConflict; +use pumpkin_core::variables::IntegerVariable; + use super::disjunctive_task::ArgDisjunctiveTask; use super::disjunctive_task::DisjunctiveTask; use super::theta_lambda_tree::ThetaLambdaTree; -use crate::basic_types::PropagationStatusCP; -use crate::basic_types::PropagatorConflict; -use crate::containers::StorageKey; -use crate::predicate; -use crate::predicates::PropositionalConjunction; -use crate::proof::ConstraintTag; -use crate::proof::InferenceCode; -use crate::propagation::DomainEvents; -use crate::propagation::LocalId; -use crate::propagation::PropagationContext; -use crate::propagation::Propagator; -use crate::propagation::PropagatorConstructor; -use crate::propagation::PropagatorConstructorContext; -use crate::propagation::ReadDomains; use crate::propagators::disjunctive::DisjunctiveEdgeFinding; -use crate::pumpkin_assert_simple; -use crate::state::Conflict; -use crate::variables::IntegerVariable; /// [`Propagator`] responsible for using disjunctive reasoning to propagate the [Disjunctive](https://sofdem.github.io/gccat/gccat/Cdisjunctive.html) constraint. /// @@ -42,7 +43,7 @@ use crate::variables::IntegerVariable; /// - \[2\] R. A. Vasile, ‘Evaluating the Impact of Explanations on the Performance of an /// Edge-Finding Propagator’. #[derive(Debug, Clone)] -pub(crate) struct DisjunctivePropagator { +pub struct DisjunctivePropagator { /// The tasks which serve as the input to the disjunctive constraint tasks: Box<[DisjunctiveTask]>, /// An additional list of tasks which allows us to sort them (we require [`Disjunctive::tasks`] @@ -56,13 +57,14 @@ pub(crate) struct DisjunctivePropagator { inference_code: InferenceCode, } -pub(crate) struct DisjunctiveConstructor { +#[derive(Debug)] +pub struct DisjunctiveConstructor { constraint_tag: ConstraintTag, tasks: Vec>, } impl DisjunctiveConstructor { - pub(crate) fn new( + pub fn new( tasks: impl IntoIterator>, constraint_tag: ConstraintTag, ) -> Self { diff --git a/pumpkin-crates/core/src/propagators/disjunctive/disjunctive_task.rs b/pumpkin-crates/propagators/src/propagators/disjunctive/disjunctive_task.rs similarity index 92% rename from pumpkin-crates/core/src/propagators/disjunctive/disjunctive_task.rs rename to pumpkin-crates/propagators/src/propagators/disjunctive/disjunctive_task.rs index 658d70c4e..4af07e860 100644 --- a/pumpkin-crates/core/src/propagators/disjunctive/disjunctive_task.rs +++ b/pumpkin-crates/propagators/src/propagators/disjunctive/disjunctive_task.rs @@ -2,7 +2,7 @@ use std::fmt::Debug; #[cfg(doc)] use crate::constraints; -use crate::propagation::LocalId; +use pumpkin_core::propagation::LocalId; /// Defines the input of the [`constraints::disjunctive_strict`] constraint. /// diff --git a/pumpkin-crates/core/src/propagators/disjunctive/mod.rs b/pumpkin-crates/propagators/src/propagators/disjunctive/mod.rs similarity index 51% rename from pumpkin-crates/core/src/propagators/disjunctive/mod.rs rename to pumpkin-crates/propagators/src/propagators/disjunctive/mod.rs index 4cf320ddd..37937002a 100644 --- a/pumpkin-crates/core/src/propagators/disjunctive/mod.rs +++ b/pumpkin-crates/propagators/src/propagators/disjunctive/mod.rs @@ -1,8 +1,10 @@ -use crate::declare_inference_label; +use pumpkin_core::declare_inference_label; pub(crate) mod disjunctive_propagator; pub(crate) mod disjunctive_task; mod theta_lambda_tree; mod theta_tree; +pub use disjunctive_propagator::DisjunctiveConstructor; +pub use disjunctive_propagator::DisjunctivePropagator; declare_inference_label!(DisjunctiveEdgeFinding); diff --git a/pumpkin-crates/core/src/propagators/disjunctive/theta_lambda_tree.rs b/pumpkin-crates/propagators/src/propagators/disjunctive/theta_lambda_tree.rs similarity index 97% rename from pumpkin-crates/core/src/propagators/disjunctive/theta_lambda_tree.rs rename to pumpkin-crates/propagators/src/propagators/disjunctive/theta_lambda_tree.rs index 45e8631b6..4c42cd4ac 100644 --- a/pumpkin-crates/core/src/propagators/disjunctive/theta_lambda_tree.rs +++ b/pumpkin-crates/propagators/src/propagators/disjunctive/theta_lambda_tree.rs @@ -1,14 +1,15 @@ use std::cmp::max; +use pumpkin_core::asserts::pumpkin_assert_moderate; +use pumpkin_core::asserts::pumpkin_assert_simple; +use pumpkin_core::containers::KeyedVec; +use pumpkin_core::containers::StorageKey; +use pumpkin_core::propagation::Domains; +use pumpkin_core::propagation::LocalId; +use pumpkin_core::propagation::ReadDomains; +use pumpkin_core::variables::IntegerVariable; + use super::disjunctive_task::DisjunctiveTask; -use crate::containers::KeyedVec; -use crate::containers::StorageKey; -use crate::propagation::Domains; -use crate::propagation::LocalId; -use crate::propagation::ReadDomains; -use crate::pumpkin_assert_moderate; -use crate::pumpkin_assert_simple; -use crate::variables::IntegerVariable; // A node in the [`ThetaTree`] which keeps track of the ECT and sum of processing times of its // children @@ -375,9 +376,10 @@ impl ThetaLambdaTree { #[cfg(test)] mod tests { + use pumpkin_core::propagation::Domains; + use pumpkin_core::propagation::LocalId; + use crate::engine::test_solver::TestSolver; - use crate::propagation::Domains; - use crate::propagation::LocalId; use crate::propagators::disjunctive::theta_lambda_tree::Node; use crate::propagators::disjunctive::theta_lambda_tree::ThetaLambdaTree; use crate::propagators::disjunctive_task::DisjunctiveTask; diff --git a/pumpkin-crates/core/src/propagators/disjunctive/theta_tree.rs b/pumpkin-crates/propagators/src/propagators/disjunctive/theta_tree.rs similarity index 94% rename from pumpkin-crates/core/src/propagators/disjunctive/theta_tree.rs rename to pumpkin-crates/propagators/src/propagators/disjunctive/theta_tree.rs index 77c895117..68f0234f7 100644 --- a/pumpkin-crates/core/src/propagators/disjunctive/theta_tree.rs +++ b/pumpkin-crates/propagators/src/propagators/disjunctive/theta_tree.rs @@ -1,13 +1,14 @@ use std::cmp::max; +use pumpkin_core::asserts::pumpkin_assert_simple; +use pumpkin_core::containers::KeyedVec; +use pumpkin_core::containers::StorageKey; +use pumpkin_core::propagation::Domains; +use pumpkin_core::propagation::LocalId; +use pumpkin_core::propagation::ReadDomains; +use pumpkin_core::variables::IntegerVariable; + use super::disjunctive_task::DisjunctiveTask; -use crate::containers::KeyedVec; -use crate::containers::StorageKey; -use crate::propagation::Domains; -use crate::propagation::LocalId; -use crate::propagation::ReadDomains; -use crate::pumpkin_assert_simple; -use crate::variables::IntegerVariable; // A node in the [`ThetaTree`] which keeps track of the ECT and sum of processing times of its // children diff --git a/pumpkin-crates/core/src/propagators/element.rs b/pumpkin-crates/propagators/src/propagators/element.rs similarity index 92% rename from pumpkin-crates/core/src/propagators/element.rs rename to pumpkin-crates/propagators/src/propagators/element.rs index 351a423ea..d034b7e49 100644 --- a/pumpkin-crates/core/src/propagators/element.rs +++ b/pumpkin-crates/propagators/src/propagators/element.rs @@ -1,32 +1,31 @@ #![allow(clippy::double_parens, reason = "originates inside the bitfield macro")] use bitfield_struct::bitfield; - -use crate::basic_types::PropagationStatusCP; -use crate::conjunction; -use crate::declare_inference_label; -use crate::engine::reason::Reason; -use crate::engine::variables::IntegerVariable; -use crate::predicate; -use crate::predicates::Predicate; -use crate::proof::ConstraintTag; -use crate::proof::InferenceCode; -use crate::propagation::DomainEvents; -use crate::propagation::ExplanationContext; -use crate::propagation::LocalId; -use crate::propagation::Priority; -use crate::propagation::PropagationContext; -use crate::propagation::Propagator; -use crate::propagation::PropagatorConstructor; -use crate::propagation::PropagatorConstructorContext; -use crate::propagation::ReadDomains; +use pumpkin_core::conjunction; +use pumpkin_core::declare_inference_label; +use pumpkin_core::predicate; +use pumpkin_core::predicates::Predicate; +use pumpkin_core::proof::ConstraintTag; +use pumpkin_core::proof::InferenceCode; +use pumpkin_core::propagation::DomainEvents; +use pumpkin_core::propagation::ExplanationContext; +use pumpkin_core::propagation::LocalId; +use pumpkin_core::propagation::Priority; +use pumpkin_core::propagation::PropagationContext; +use pumpkin_core::propagation::Propagator; +use pumpkin_core::propagation::PropagatorConstructor; +use pumpkin_core::propagation::PropagatorConstructorContext; +use pumpkin_core::propagation::ReadDomains; +use pumpkin_core::results::PropagationStatusCP; +use pumpkin_core::variables::IntegerVariable; +use pumpkin_core::variables::Reason; #[derive(Clone, Debug)] -pub(crate) struct ElementArgs { - pub(crate) array: Box<[VX]>, - pub(crate) index: VI, - pub(crate) rhs: VE, - pub(crate) constraint_tag: ConstraintTag, +pub struct ElementArgs { + pub array: Box<[VX]>, + pub index: VI, + pub rhs: VE, + pub constraint_tag: ConstraintTag, } declare_inference_label!(Element); @@ -81,7 +80,7 @@ const ID_X_OFFSET: u32 = 2; /// /// Note that this propagator is 0-indexed #[derive(Clone, Debug)] -pub(crate) struct ElementPropagator { +pub struct ElementPropagator { array: Box<[VX]>, index: VI, rhs: VE, diff --git a/pumpkin-crates/propagators/src/propagators/mod.rs b/pumpkin-crates/propagators/src/propagators/mod.rs new file mode 100644 index 000000000..4f71d69f7 --- /dev/null +++ b/pumpkin-crates/propagators/src/propagators/mod.rs @@ -0,0 +1,18 @@ +//! Contains propagator implementations that are used in Pumpkin. +//! +//! See the [`propagation`] for info on propagators. +#[cfg(doc)] +use crate::propagation; + +pub(crate) mod arithmetic; +mod cumulative; +mod disjunctive; +pub(crate) mod element; +pub use arithmetic::*; +pub use cumulative::CumulativeExplanationType; +pub use cumulative::CumulativeOptions; +pub use cumulative::CumulativePropagationMethod; +pub use cumulative::*; +pub use disjunctive::disjunctive_task::ArgDisjunctiveTask; +pub use disjunctive::*; +pub use element::*; diff --git a/pumpkin-solver-py/Cargo.toml b/pumpkin-solver-py/Cargo.toml index 22daabf4d..88c485731 100644 --- a/pumpkin-solver-py/Cargo.toml +++ b/pumpkin-solver-py/Cargo.toml @@ -17,6 +17,7 @@ doc = false [dependencies] pyo3 = { version = "0.25.1", features= ["extension-module"] } pumpkin-solver = { version = "0.2.2", path = "../pumpkin-solver" } +pumpkin-constraints = { version = "0.2.2", path = "../pumpkin-crates/constraints", features=["clap"] } [build-dependencies] pyo3-build-config = "0.25.1" diff --git a/pumpkin-solver-py/src/constraints/globals.rs b/pumpkin-solver-py/src/constraints/globals.rs index ab553579a..8d8d88c5a 100644 --- a/pumpkin-solver-py/src/constraints/globals.rs +++ b/pumpkin-solver-py/src/constraints/globals.rs @@ -1,5 +1,4 @@ use pumpkin_solver::constraints::Constraint; -use pumpkin_solver::constraints::{self}; use pyo3::pyclass; use pyo3::pymethods; @@ -32,7 +31,7 @@ macro_rules! python_constraint { solver: &mut pumpkin_solver::Solver, variable_map: &VariableMap, ) -> Result<(), pumpkin_solver::ConstraintOperationError> { - constraints::$constraint_func( + pumpkin_constraints::$constraint_func( $(<$type as super::arguments::PythonConstraintArg>::to_solver_constraint_argument(self.$field, variable_map)),+ , self.constraint_tag.0, ).post(solver) @@ -44,7 +43,7 @@ macro_rules! python_constraint { reification_literal: pumpkin_solver::variables::Literal, variable_map: &VariableMap, ) -> Result<(), pumpkin_solver::ConstraintOperationError> { - constraints::$constraint_func( + pumpkin_constraints::$constraint_func( $(<$type as super::arguments::PythonConstraintArg>::to_solver_constraint_argument(self.$field, variable_map)),+ , self.constraint_tag.0, ).implied_by(solver, reification_literal) diff --git a/pumpkin-solver/Cargo.toml b/pumpkin-solver/Cargo.toml index c68706f57..6ba8a9195 100644 --- a/pumpkin-solver/Cargo.toml +++ b/pumpkin-solver/Cargo.toml @@ -14,6 +14,8 @@ env_logger = "0.10.0" flatzinc = "0.3.21" log = "0.4.27" pumpkin-core = { version = "0.2.2", path = "../pumpkin-crates/core/", features = ["clap"] } +pumpkin-constraints = {version = "0.2.2", path = "../pumpkin-crates/constraints/"} +pumpkin-propagators = {version = "0.2.2", path = "../pumpkin-crates/propagators/"} signal-hook = "0.3.18" thiserror = "2.0.12" diff --git a/pumpkin-solver/src/bin/pumpkin-solver/flatzinc/compiler/post_constraints.rs b/pumpkin-solver/src/bin/pumpkin-solver/flatzinc/compiler/post_constraints.rs index cf49dbe57..414eba8f3 100644 --- a/pumpkin-solver/src/bin/pumpkin-solver/flatzinc/compiler/post_constraints.rs +++ b/pumpkin-solver/src/bin/pumpkin-solver/flatzinc/compiler/post_constraints.rs @@ -2,8 +2,7 @@ use std::rc::Rc; -use pumpkin_core::constraint_arguments::ArgDisjunctiveTask; -use pumpkin_solver::constraints; +use pumpkin_propagators::propagators::ArgDisjunctiveTask; use pumpkin_solver::constraints::Constraint; use pumpkin_solver::constraints::NegatableConstraint; use pumpkin_solver::predicate; @@ -39,7 +38,7 @@ pub(crate) fn run( annos, "int_max", constraint_tag, - |a, b, c, constraint_tag| constraints::maximum([a, b], c, constraint_tag), + |a, b, c, constraint_tag| pumpkin_constraints::maximum([a, b], c, constraint_tag), )?, "int_min" => compile_ternary_int_predicate( context, @@ -47,7 +46,7 @@ pub(crate) fn run( annos, "int_min", constraint_tag, - |a, b, c, constraint_tag| constraints::minimum([a, b], c, constraint_tag), + |a, b, c, constraint_tag| pumpkin_constraints::minimum([a, b], c, constraint_tag), )?, // We rewrite `array_int_element` to `array_var_int_element`. @@ -62,7 +61,7 @@ pub(crate) fn run( annos, "int_eq_imp", constraint_tag, - constraints::binary_equals, + pumpkin_constraints::binary_equals, )?, "int_ge_imp" => compile_binary_int_imp( context, @@ -70,7 +69,7 @@ pub(crate) fn run( annos, "int_ge_imp", constraint_tag, - constraints::binary_greater_than_or_equals, + pumpkin_constraints::binary_greater_than_or_equals, )?, "int_gt_imp" => compile_binary_int_imp( context, @@ -78,7 +77,7 @@ pub(crate) fn run( annos, "int_gt_imp", constraint_tag, - constraints::binary_greater_than, + pumpkin_constraints::binary_greater_than, )?, "int_le_imp" => compile_binary_int_imp( context, @@ -86,7 +85,7 @@ pub(crate) fn run( annos, "int_le_imp", constraint_tag, - constraints::binary_less_than_or_equals, + pumpkin_constraints::binary_less_than_or_equals, )?, "int_lt_imp" => compile_binary_int_imp( context, @@ -94,7 +93,7 @@ pub(crate) fn run( annos, "int_lt_imp", constraint_tag, - constraints::binary_less_than, + pumpkin_constraints::binary_less_than, )?, "int_ne_imp" => compile_binary_int_imp( context, @@ -102,7 +101,7 @@ pub(crate) fn run( annos, "int_ne_imp", constraint_tag, - constraints::binary_not_equals, + pumpkin_constraints::binary_not_equals, )?, "int_lin_eq_imp" => compile_int_lin_imp_predicate( @@ -111,7 +110,7 @@ pub(crate) fn run( annos, "int_lin_eq_imp", constraint_tag, - constraints::equals, + pumpkin_constraints::equals, )?, "int_lin_ge_imp" => compile_int_lin_imp_predicate( context, @@ -119,7 +118,7 @@ pub(crate) fn run( annos, "int_lin_ge_imp", constraint_tag, - constraints::greater_than_or_equals, + pumpkin_constraints::greater_than_or_equals, )?, "int_lin_gt_imp" => compile_int_lin_imp_predicate( context, @@ -127,7 +126,7 @@ pub(crate) fn run( annos, "int_lin_gt_imp", constraint_tag, - constraints::greater_than, + pumpkin_constraints::greater_than, )?, "int_lin_le_imp" => compile_int_lin_imp_predicate( context, @@ -135,7 +134,7 @@ pub(crate) fn run( annos, "int_lin_le_imp", constraint_tag, - constraints::less_than_or_equals, + pumpkin_constraints::less_than_or_equals, )?, "int_lin_lt_imp" => compile_int_lin_imp_predicate( context, @@ -143,7 +142,7 @@ pub(crate) fn run( annos, "int_lin_lt_imp", constraint_tag, - constraints::less_than, + pumpkin_constraints::less_than, )?, "int_lin_ne_imp" => compile_int_lin_imp_predicate( context, @@ -151,7 +150,7 @@ pub(crate) fn run( annos, "int_lin_ne_imp", constraint_tag, - constraints::not_equals, + pumpkin_constraints::not_equals, )?, "int_lin_ne" => compile_int_lin_predicate( @@ -160,7 +159,7 @@ pub(crate) fn run( annos, "int_lin_ne", constraint_tag, - constraints::not_equals, + pumpkin_constraints::not_equals, )?, "int_lin_ne_reif" => compile_reified_int_lin_predicate( context, @@ -168,7 +167,7 @@ pub(crate) fn run( annos, "int_lin_ne_reif", constraint_tag, - constraints::not_equals, + pumpkin_constraints::not_equals, )?, "int_lin_le" => compile_int_lin_predicate( context, @@ -176,7 +175,7 @@ pub(crate) fn run( annos, "int_lin_le", constraint_tag, - constraints::less_than_or_equals, + pumpkin_constraints::less_than_or_equals, )?, "int_lin_le_reif" => compile_reified_int_lin_predicate( context, @@ -184,7 +183,7 @@ pub(crate) fn run( annos, "int_lin_le_reif", constraint_tag, - constraints::less_than_or_equals, + pumpkin_constraints::less_than_or_equals, )?, "int_lin_eq" => compile_int_lin_predicate( context, @@ -192,7 +191,7 @@ pub(crate) fn run( annos, "int_lin_eq", constraint_tag, - constraints::equals, + pumpkin_constraints::equals, )?, "int_lin_eq_reif" => compile_reified_int_lin_predicate( context, @@ -200,7 +199,7 @@ pub(crate) fn run( annos, "int_lin_eq_reif", constraint_tag, - constraints::equals, + pumpkin_constraints::equals, )?, "int_ne" => compile_binary_int_predicate( context, @@ -208,7 +207,7 @@ pub(crate) fn run( annos, "int_ne", constraint_tag, - constraints::binary_not_equals, + pumpkin_constraints::binary_not_equals, )?, "int_ne_reif" => compile_reified_binary_int_predicate( context, @@ -216,7 +215,7 @@ pub(crate) fn run( annos, "int_ne_reif", constraint_tag, - constraints::binary_not_equals, + pumpkin_constraints::binary_not_equals, )?, "int_eq" => compile_binary_int_predicate( context, @@ -224,7 +223,7 @@ pub(crate) fn run( annos, "int_eq", constraint_tag, - constraints::binary_equals, + pumpkin_constraints::binary_equals, )?, "int_eq_reif" => compile_reified_binary_int_predicate( context, @@ -232,7 +231,7 @@ pub(crate) fn run( annos, "int_eq_reif", constraint_tag, - constraints::binary_equals, + pumpkin_constraints::binary_equals, )?, "int_le" => compile_binary_int_predicate( context, @@ -240,7 +239,7 @@ pub(crate) fn run( annos, "int_le", constraint_tag, - constraints::binary_less_than_or_equals, + pumpkin_constraints::binary_less_than_or_equals, )?, "int_le_reif" => compile_reified_binary_int_predicate( context, @@ -248,7 +247,7 @@ pub(crate) fn run( annos, "int_le_reif", constraint_tag, - constraints::binary_less_than_or_equals, + pumpkin_constraints::binary_less_than_or_equals, )?, "int_lt" => compile_binary_int_predicate( context, @@ -256,7 +255,7 @@ pub(crate) fn run( annos, "int_lt", constraint_tag, - constraints::binary_less_than, + pumpkin_constraints::binary_less_than, )?, "int_lt_reif" => compile_reified_binary_int_predicate( context, @@ -264,7 +263,7 @@ pub(crate) fn run( annos, "int_lt_reif", constraint_tag, - constraints::binary_less_than, + pumpkin_constraints::binary_less_than, )?, "int_plus" => compile_ternary_int_predicate( @@ -273,7 +272,7 @@ pub(crate) fn run( annos, "int_plus", constraint_tag, - constraints::plus, + pumpkin_constraints::plus, )?, "int_times" => compile_ternary_int_predicate( @@ -282,7 +281,7 @@ pub(crate) fn run( annos, "int_times", constraint_tag, - constraints::times, + pumpkin_constraints::times, )?, "int_div" => compile_ternary_int_predicate( context, @@ -290,7 +289,7 @@ pub(crate) fn run( annos, "int_div", constraint_tag, - constraints::division, + pumpkin_constraints::division, )?, "int_abs" => compile_binary_int_predicate( context, @@ -298,7 +297,7 @@ pub(crate) fn run( annos, "int_abs", constraint_tag, - constraints::absolute, + pumpkin_constraints::absolute, )?, "pumpkin_all_different" => { @@ -381,7 +380,7 @@ fn compile_disjunctive_strict( assert_eq!(start_times.len(), durations.len()); - let post_result = constraints::disjunctive_strict( + let post_result = pumpkin_constraints::disjunctive_strict( start_times .iter() .zip(durations.iter()) @@ -408,7 +407,7 @@ fn compile_cumulative( let resource_requirements = context.resolve_array_integer_constants(&exprs[2])?; let resource_capacity = context.resolve_integer_constant_from_expr(&exprs[3])?; - let post_result = constraints::cumulative_with_options( + let post_result = pumpkin_constraints::cumulative_with_options( start_times.iter().copied(), durations.iter().copied(), resource_requirements.iter().copied(), @@ -431,7 +430,7 @@ fn compile_array_int_maximum( let array = context.resolve_integer_variable_array(&exprs[1])?; Ok( - constraints::maximum(array.as_ref().to_owned(), rhs, constraint_tag) + pumpkin_constraints::maximum(array.as_ref().to_owned(), rhs, constraint_tag) .post(context.solver) .is_ok(), ) @@ -448,7 +447,7 @@ fn compile_array_int_minimum( let array = context.resolve_integer_variable_array(&exprs[1])?; Ok( - constraints::minimum(array.as_ref().to_owned(), rhs, constraint_tag) + pumpkin_constraints::minimum(array.as_ref().to_owned(), rhs, constraint_tag) .post(context.solver) .is_ok(), ) @@ -520,7 +519,7 @@ fn compile_set_in_reif( }) .collect::>(); - constraints::clause(clause, constraint_tag) + pumpkin_constraints::clause(clause, constraint_tag) .reify(context.solver, reif) .is_ok() } @@ -541,7 +540,7 @@ fn compile_array_var_int_element( let rhs = context.resolve_integer_variable(&exprs[2])?; Ok( - constraints::element(index, array.as_ref().to_owned(), rhs, constraint_tag) + pumpkin_constraints::element(index, array.as_ref().to_owned(), rhs, constraint_tag) .post(context.solver) .is_ok(), ) @@ -561,7 +560,7 @@ fn compile_bool_not( let a = context.resolve_bool_variable(&exprs[0])?; let b = context.resolve_bool_variable(&exprs[1])?; - Ok(constraints::binary_not_equals(a, b, constraint_tag) + Ok(pumpkin_constraints::binary_not_equals(a, b, constraint_tag) .post(context.solver) .is_ok()) } @@ -577,7 +576,7 @@ fn compile_bool_eq_reif( let b = context.resolve_bool_variable(&exprs[1])?; let r = context.resolve_bool_variable(&exprs[2])?; - Ok(constraints::binary_equals(a, b, constraint_tag) + Ok(pumpkin_constraints::binary_equals(a, b, constraint_tag) .reify(context.solver, r) .is_ok()) } @@ -594,7 +593,7 @@ fn compile_bool_eq( let a = context.resolve_bool_variable(&exprs[0])?; let b = context.resolve_bool_variable(&exprs[1])?; - Ok(constraints::binary_equals(a, b, constraint_tag) + Ok(pumpkin_constraints::binary_equals(a, b, constraint_tag) .post(context.solver) .is_ok()) } @@ -630,7 +629,7 @@ fn compile_bool_and( let b = context.resolve_bool_variable(&exprs[1])?; let r = context.resolve_bool_variable(&exprs[2])?; - Ok(constraints::conjunction([a, b], constraint_tag) + Ok(pumpkin_constraints::conjunction([a, b], constraint_tag) .reify(context.solver, r) .is_ok()) } @@ -650,7 +649,7 @@ fn compile_bool2int( let b = context.resolve_integer_variable(&exprs[1])?; Ok( - constraints::binary_equals(a.get_integer_variable(), b.scaled(1), constraint_tag) + pumpkin_constraints::binary_equals(a.get_integer_variable(), b.scaled(1), constraint_tag) .post(context.solver) .is_ok(), ) @@ -666,7 +665,7 @@ fn compile_bool_or( let clause = context.resolve_bool_variable_array(&exprs[0])?; let r = context.resolve_bool_variable(&exprs[1])?; - Ok(constraints::clause(clause.as_ref(), constraint_tag) + Ok(pumpkin_constraints::clause(clause.as_ref(), constraint_tag) .reify(context.solver, r) .is_ok()) } @@ -702,16 +701,16 @@ fn compile_bool_xor_reif( let b = context.resolve_bool_variable(&exprs[1])?; let r = context.resolve_bool_variable(&exprs[2])?; - let c1 = constraints::clause([!a, !b, !r], constraint_tag) + let c1 = pumpkin_constraints::clause([!a, !b, !r], constraint_tag) .post(context.solver) .is_ok(); - let c2 = constraints::clause([!a, b, r], constraint_tag) + let c2 = pumpkin_constraints::clause([!a, b, r], constraint_tag) .post(context.solver) .is_ok(); - let c3 = constraints::clause([a, !b, r], constraint_tag) + let c3 = pumpkin_constraints::clause([a, !b, r], constraint_tag) .post(context.solver) .is_ok(); - let c4 = constraints::clause([a, b, !r], constraint_tag) + let c4 = pumpkin_constraints::clause([a, b, !r], constraint_tag) .post(context.solver) .is_ok(); @@ -731,7 +730,7 @@ fn compile_array_var_bool_element( let rhs = context.resolve_bool_variable(&exprs[2])?; Ok( - constraints::element(index, array.iter().cloned(), rhs, constraint_tag) + pumpkin_constraints::element(index, array.iter().cloned(), rhs, constraint_tag) .post(context.solver) .is_ok(), ) @@ -748,7 +747,7 @@ fn compile_array_bool_and( let r = context.resolve_bool_variable(&exprs[1])?; Ok( - constraints::conjunction(conjunction.as_ref(), constraint_tag) + pumpkin_constraints::conjunction(conjunction.as_ref(), constraint_tag) .reify(context.solver, r) .is_ok(), ) @@ -906,7 +905,7 @@ fn compile_bool_lin_eq_predicate( let bools = context.resolve_bool_variable_array(&exprs[1])?; let rhs = context.resolve_integer_variable(&exprs[2])?; - Ok(constraints::boolean_equals( + Ok(pumpkin_constraints::boolean_equals( weights.as_ref().to_owned(), bools.as_ref().to_owned(), rhs, @@ -927,7 +926,7 @@ fn compile_bool_lin_le_predicate( let bools = context.resolve_bool_variable_array(&exprs[1])?; let rhs = context.resolve_integer_constant_from_expr(&exprs[2])?; - Ok(constraints::boolean_less_than_or_equals( + Ok(pumpkin_constraints::boolean_less_than_or_equals( weights.as_ref().to_owned(), bools.as_ref().to_owned(), rhs, @@ -946,9 +945,11 @@ fn compile_all_different( check_parameters!(exprs, 1, "fzn_all_different"); let variables = context.resolve_integer_variable_array(&exprs[0])?.to_vec(); - Ok(constraints::all_different(variables, constraint_tag) - .post(context.solver) - .is_ok()) + Ok( + pumpkin_constraints::all_different(variables, constraint_tag) + .post(context.solver) + .is_ok(), + ) } fn compile_table( @@ -964,7 +965,7 @@ fn compile_table( let flat_table = context.resolve_array_integer_constants(&exprs[1])?; let table = create_table(flat_table, variables.len()); - Ok(constraints::table(variables, table, constraint_tag) + Ok(pumpkin_constraints::table(variables, table, constraint_tag) .post(context.solver) .is_ok()) } @@ -984,7 +985,7 @@ fn compile_table_reif( let reified = context.resolve_bool_variable(&exprs[2])?; - Ok(constraints::table(variables, table, constraint_tag) + Ok(pumpkin_constraints::table(variables, table, constraint_tag) .reify(context.solver, reified) .is_ok()) } diff --git a/pumpkin-solver/src/bin/pumpkin-solver/flatzinc/mod.rs b/pumpkin-solver/src/bin/pumpkin-solver/flatzinc/mod.rs index 9b0dfef67..cacd20da3 100644 --- a/pumpkin-solver/src/bin/pumpkin-solver/flatzinc/mod.rs +++ b/pumpkin-solver/src/bin/pumpkin-solver/flatzinc/mod.rs @@ -14,10 +14,10 @@ use pumpkin_core::branching::branchers::alternating::AlternatingBrancher; use pumpkin_core::branching::branchers::alternating::every_x_restarts::EveryXRestarts; use pumpkin_core::branching::branchers::alternating::until_solution::UntilSolution; use pumpkin_core::statistics::log_statistic; +use pumpkin_propagators::propagators::CumulativeOptions; use pumpkin_solver::Solver; use pumpkin_solver::branching::Brancher; use pumpkin_solver::branching::branchers::dynamic_brancher::DynamicBrancher; -use pumpkin_solver::constraint_arguments::CumulativeOptions; #[cfg(doc)] use pumpkin_solver::constraints::cumulative; use pumpkin_solver::optimisation::OptimisationDirection; diff --git a/pumpkin-solver/src/bin/pumpkin-solver/main.rs b/pumpkin-solver/src/bin/pumpkin-solver/main.rs index a68025574..b9f6b6cef 100644 --- a/pumpkin-solver/src/bin/pumpkin-solver/main.rs +++ b/pumpkin-solver/src/bin/pumpkin-solver/main.rs @@ -24,9 +24,9 @@ use maxsat::PseudoBooleanEncoding; use parsers::dimacs::SolverArgs; use parsers::dimacs::SolverDimacsSink; use parsers::dimacs::parse_cnf; -use pumpkin_core::constraint_arguments::CumulativeExplanationType; -use pumpkin_core::constraint_arguments::CumulativeOptions; -use pumpkin_core::constraint_arguments::CumulativePropagationMethod; +use pumpkin_propagators::propagators::CumulativeExplanationType; +use pumpkin_propagators::propagators::CumulativeOptions; +use pumpkin_propagators::propagators::CumulativePropagationMethod; use pumpkin_solver::Solver; use pumpkin_solver::convert_case::Case; use pumpkin_solver::optimisation::OptimisationStrategy; From ef141a3ce7133817616fe31b82df9198b66bbcdb Mon Sep 17 00:00:00 2001 From: Imko Marijnissen Date: Tue, 16 Dec 2025 12:20:23 +0100 Subject: [PATCH 2/6] refactor: further fix refactoring --- Cargo.lock | 2 + .../constraints/src/constraints/cumulative.rs | 4 +- .../constraints/src/constraints/mod.rs | 2 +- pumpkin-crates/core/Cargo.toml | 3 + .../core/src/api/outputs/unsatisfiable.rs | 2 +- pumpkin-crates/core/src/api/solver.rs | 3 +- .../engine/constraint_satisfaction_solver.rs | 92 ++++++------ .../core/src/engine/cp/assignments.rs | 10 +- .../core/src/engine/cp/test_solver.rs | 58 ++++---- .../core/src/engine/notifications/mod.rs | 15 +- pumpkin-crates/core/src/engine/state.rs | 16 ++ pumpkin-crates/core/src/lib.rs | 1 + .../core/src/propagation/domains.rs | 2 +- pumpkin-crates/core/src/propagation/mod.rs | 2 - pumpkin-crates/propagators/Cargo.toml | 3 + .../propagators/arithmetic/absolute_value.rs | 2 + .../arithmetic/binary/binary_equals.rs | 5 +- .../arithmetic/binary/binary_not_equals.rs | 3 + .../arithmetic/integer_division.rs | 2 +- .../arithmetic/integer_multiplication.rs | 5 +- .../arithmetic/linear_less_or_equal.rs | 5 +- .../arithmetic/linear_not_equal.rs | 9 +- .../src/propagators/arithmetic/maximum.rs | 2 +- .../src/propagators/cumulative/mod.rs | 4 +- .../src/propagators/cumulative/options.rs | 4 +- .../time_table/explanations/big_step.rs | 5 +- .../time_table/explanations/naive.rs | 5 +- .../time_table/explanations/pointwise.rs | 5 +- .../time_table_over_interval_incremental.rs | 15 +- .../synchronisation.rs | 2 +- .../time_table_per_point_incremental.rs | 28 ++-- .../time_table/propagation_handler.rs | 137 ++++++------------ .../time_table/time_table_over_interval.rs | 13 +- .../time_table/time_table_per_point.rs | 13 +- .../cumulative/time_table/time_table_util.rs | 30 ++-- .../disjunctive/disjunctive_propagator.rs | 2 +- .../disjunctive/disjunctive_task.rs | 4 +- .../disjunctive/theta_lambda_tree.rs | 17 +-- .../propagators/src/propagators/element.rs | 5 +- .../propagators/src/propagators/mod.rs | 2 +- pumpkin-solver/examples/bibd.rs | 9 +- .../examples/disjunctive_scheduling.rs | 5 +- pumpkin-solver/examples/nqueens.rs | 9 +- pumpkin-solver/src/lib.rs | 14 +- pumpkin-solver/tests/iteration_test.rs | 5 +- pumpkin-solver/tests/solver_test.rs | 21 ++- 46 files changed, 285 insertions(+), 317 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index a26ae1130..1a237fd57 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -765,6 +765,7 @@ dependencies = [ "log", "num", "once_cell", + "pumpkin-constraints", "rand", "thiserror", "wasm-bindgen-test", @@ -790,6 +791,7 @@ dependencies = [ "clap", "convert_case 0.6.0", "enumset", + "pumpkin-constraints", "pumpkin-core", ] diff --git a/pumpkin-crates/constraints/src/constraints/cumulative.rs b/pumpkin-crates/constraints/src/constraints/cumulative.rs index 8fe5b1b7d..ff7de423b 100644 --- a/pumpkin-crates/constraints/src/constraints/cumulative.rs +++ b/pumpkin-crates/constraints/src/constraints/cumulative.rs @@ -43,7 +43,7 @@ use pumpkin_propagators::propagators::TimeTablePerPointPropagator; /// # use pumpkin_core::results::SatisfactionResult; /// # use pumpkin_core::constraints; /// # use pumpkin_core::constraints::Constraint; -/// # use crate::pumpkin_core::results::ProblemSolution; +/// # use pumpkin_core::results::ProblemSolution; /// let solver = Solver::default(); /// /// let mut solver = Solver::default(); @@ -60,7 +60,7 @@ use pumpkin_propagators::propagators::TimeTablePerPointPropagator; /// let resource_capacity = 2; /// /// solver -/// .add_constraint(constraints::cumulative( +/// .add_constraint(pumpkin_constraints::cumulative( /// start_times.clone(), /// durations.clone(), /// resource_requirements.clone(), diff --git a/pumpkin-crates/constraints/src/constraints/mod.rs b/pumpkin-crates/constraints/src/constraints/mod.rs index 7d7dd105a..675f9ca6d 100644 --- a/pumpkin-crates/constraints/src/constraints/mod.rs +++ b/pumpkin-crates/constraints/src/constraints/mod.rs @@ -17,7 +17,7 @@ //! let constraint_tag = solver.new_constraint_tag(); //! //! solver -//! .add_constraint(constraints::equals([a, b], 0, constraint_tag)) +//! .add_constraint(pumpkin_constraints::equals([a, b], 0, constraint_tag)) //! .post(); //! ``` //! diff --git a/pumpkin-crates/core/Cargo.toml b/pumpkin-crates/core/Cargo.toml index 7521d8355..a6d639ea5 100644 --- a/pumpkin-crates/core/Cargo.toml +++ b/pumpkin-crates/core/Cargo.toml @@ -30,6 +30,9 @@ indexmap = "2.10.0" dyn-clone = "1.0.20" flate2 = { version = "1.1.2" } +[dev-dependencies] +pumpkin-constraints = { version = "0.2.2", path = "../constraints", features=["clap"] } + [target.'cfg(target_arch = "wasm32")'.dependencies] web-time = "1.1" getrandom = { version = "0.2", features = ["js"] } diff --git a/pumpkin-crates/core/src/api/outputs/unsatisfiable.rs b/pumpkin-crates/core/src/api/outputs/unsatisfiable.rs index d646eac97..ad7aee0f8 100644 --- a/pumpkin-crates/core/src/api/outputs/unsatisfiable.rs +++ b/pumpkin-crates/core/src/api/outputs/unsatisfiable.rs @@ -64,7 +64,7 @@ impl<'solver, 'brancher, B: Brancher> UnsatisfiableUnderAssumptions<'solver, 'br /// let constraint_tag = solver.new_constraint_tag(); /// /// // We create the all-different constraint - /// solver.add_constraint(constraints::all_different(vec![x, y, z], constraint_tag)).post(); + /// solver.add_constraint(pumpkin_constraints::all_different(vec![x, y, z], constraint_tag)).post(); /// /// // We create a termination condition which allows the solver to run indefinitely /// let mut termination = Indefinite; diff --git a/pumpkin-crates/core/src/api/solver.rs b/pumpkin-crates/core/src/api/solver.rs index 422efba36..b2e9069fa 100644 --- a/pumpkin-crates/core/src/api/solver.rs +++ b/pumpkin-crates/core/src/api/solver.rs @@ -453,7 +453,6 @@ impl Solver { /// /// # Example /// ``` - /// # use pumpkin_core::constraints; /// # use pumpkin_core::Solver; /// let mut solver = Solver::default(); /// @@ -463,7 +462,7 @@ impl Solver { /// let constraint_tag = solver.new_constraint_tag(); /// /// solver - /// .add_constraint(constraints::equals([a, b], 0, constraint_tag)) + /// .add_constraint(pumpkin_constraints::equals([a, b], 0, constraint_tag)) /// .post(); /// ``` pub fn add_constraint( diff --git a/pumpkin-crates/core/src/engine/constraint_satisfaction_solver.rs b/pumpkin-crates/core/src/engine/constraint_satisfaction_solver.rs index 851d6a8a1..e76655abe 100644 --- a/pumpkin-crates/core/src/engine/constraint_satisfaction_solver.rs +++ b/pumpkin-crates/core/src/engine/constraint_satisfaction_solver.rs @@ -1197,13 +1197,13 @@ declare_inference_label!(pub(crate) NogoodLabel, "nogood"); #[cfg(test)] mod tests { + use super::ConstraintSatisfactionSolver; use super::CoreExtractionResult; use crate::DefaultBrancher; use crate::basic_types::CSPSolverExecutionFlag; use crate::predicate; use crate::predicates::Predicate; - use crate::propagators::linear_not_equal::LinearNotEqualPropagatorArgs; use crate::termination::Indefinite; use crate::variables::TransformableVariable; @@ -1395,34 +1395,34 @@ mod tests { ); } - #[test] - fn core_extraction_equality_assumption() { - let mut solver = ConstraintSatisfactionSolver::default(); - - let x = solver.create_new_integer_variable(0, 10, None); - let y = solver.create_new_integer_variable(0, 10, None); - let z = solver.create_new_integer_variable(0, 10, None); - - let constraint_tag = solver.new_constraint_tag(); - - let result = solver.add_propagator(LinearNotEqualPropagatorArgs { - terms: [x.scaled(1), y.scaled(-1)].into(), - rhs: 0, - constraint_tag, - }); - assert!(result.is_ok()); - run_test( - solver, - vec![ - predicate!(x >= 5), - predicate!(z != 10), - predicate!(y == 5), - predicate!(x <= 5), - ], - CSPSolverExecutionFlag::Infeasible, - CoreExtractionResult::Core(vec![predicate!(x == 5), predicate!(y == 5)]), - ) - } + // #[test] + // fn core_extraction_equality_assumption() { + // let mut solver = ConstraintSatisfactionSolver::default(); + // + // let x = solver.create_new_integer_variable(0, 10, None); + // let y = solver.create_new_integer_variable(0, 10, None); + // let z = solver.create_new_integer_variable(0, 10, None); + // + // let constraint_tag = solver.new_constraint_tag(); + // + // let result = solver.add_propagator(LinearNotEqualPropagatorArgs { + // terms: [x.scaled(1), y.scaled(-1)].into(), + // rhs: 0, + // constraint_tag, + // }); + // assert!(result.is_ok()); + // run_test( + // solver, + // vec![ + // predicate!(x >= 5), + // predicate!(z != 10), + // predicate!(y == 5), + // predicate!(x <= 5), + // ], + // CSPSolverExecutionFlag::Infeasible, + // CoreExtractionResult::Core(vec![predicate!(x == 5), predicate!(y == 5)]), + // ) + // } #[test] fn new_domain_with_negative_lower_bound() { @@ -1464,21 +1464,21 @@ mod tests { ); } - #[test] - fn check_can_compute_1uip_with_propagator_initialisation_conflict() { - let mut solver = ConstraintSatisfactionSolver::default(); - - let x = solver.create_new_integer_variable(1, 1, None); - let y = solver.create_new_integer_variable(2, 2, None); - - let constraint_tag = solver.new_constraint_tag(); - - let propagator = LinearNotEqualPropagatorArgs { - terms: vec![x, y].into(), - rhs: 3, - constraint_tag, - }; - let result = solver.add_propagator(propagator); - assert!(result.is_err()); - } + // #[test] + // fn check_can_compute_1uip_with_propagator_initialisation_conflict() { + // let mut solver = ConstraintSatisfactionSolver::default(); + // + // let x = solver.create_new_integer_variable(1, 1, None); + // let y = solver.create_new_integer_variable(2, 2, None); + // + // let constraint_tag = solver.new_constraint_tag(); + // + // let propagator = LinearNotEqualPropagatorArgs { + // terms: vec![x, y].into(), + // rhs: 3, + // constraint_tag, + // }; + // let result = solver.add_propagator(propagator); + // assert!(result.is_err()); + // } } diff --git a/pumpkin-crates/core/src/engine/cp/assignments.rs b/pumpkin-crates/core/src/engine/cp/assignments.rs index fa54b3065..94fcccc40 100644 --- a/pumpkin-crates/core/src/engine/cp/assignments.rs +++ b/pumpkin-crates/core/src/engine/cp/assignments.rs @@ -797,8 +797,8 @@ impl Assignments { } } -#[cfg(test)] impl Assignments { + #[deprecated] pub(crate) fn get_reason_for_predicate_brute_force(&self, predicate: Predicate) -> ReasonRef { self.trail .iter() @@ -1424,7 +1424,7 @@ mod tests { #[test] fn jump_in_bound_change_lower_and_upper_bound_event_backtrack() { - let mut notification_engine = NotificationEngine::default(); + let mut notification_engine = NotificationEngine::test_default(); let mut assignment = Assignments::default(); let d1 = assignment.grow(1, 5); notification_engine.grow(); @@ -1452,7 +1452,7 @@ mod tests { #[test] fn jump_in_bound_change_assign_event_backtrack() { - let mut notification_engine = NotificationEngine::default(); + let mut notification_engine = NotificationEngine::test_default(); let mut assignment = Assignments::default(); let d1 = assignment.grow(1, 5); notification_engine.grow(); @@ -1490,7 +1490,7 @@ mod tests { #[test] fn jump_in_bound_change_upper_bound_event_backtrack() { - let mut notification_engine = NotificationEngine::default(); + let mut notification_engine = NotificationEngine::test_default(); let mut assignment = Assignments::default(); let d1 = assignment.grow(1, 5); notification_engine.grow(); @@ -1520,7 +1520,7 @@ mod tests { #[test] fn jump_in_bound_change_lower_bound_event_backtrack() { - let mut notification_engine = NotificationEngine::default(); + let mut notification_engine = NotificationEngine::test_default(); let mut assignment = Assignments::default(); let d1 = assignment.grow(1, 5); notification_engine.grow(); diff --git a/pumpkin-crates/core/src/engine/cp/test_solver.rs b/pumpkin-crates/core/src/engine/cp/test_solver.rs index f683543c2..28b897ba4 100644 --- a/pumpkin-crates/core/src/engine/cp/test_solver.rs +++ b/pumpkin-crates/core/src/engine/cp/test_solver.rs @@ -1,4 +1,3 @@ -#![cfg(any(test, doc))] //! This module exposes helpers that aid testing of CP propagators. The [`TestSolver`] allows //! setting up specific scenarios under which to test the various operations of a propagator. use std::fmt::Debug; @@ -30,10 +29,11 @@ use crate::state::PropagatorHandle; /// A container for CP variables, which can be used to test propagators. #[derive(Debug)] -pub(crate) struct TestSolver { - pub(crate) state: State, +#[deprecated] +pub struct TestSolver { + pub state: State, constraint_tags: KeyGenerator, - pub(crate) nogood_handle: PropagatorHandle, + pub nogood_handle: PropagatorHandle, } impl Default for TestSolver { @@ -55,20 +55,20 @@ impl Default for TestSolver { } impl TestSolver { - pub(crate) fn new_variable(&mut self, lb: i32, ub: i32) -> DomainId { + pub fn new_variable(&mut self, lb: i32, ub: i32) -> DomainId { self.state.new_interval_variable(lb, ub, None) } - pub(crate) fn new_sparse_variable(&mut self, values: Vec) -> DomainId { + pub fn new_sparse_variable(&mut self, values: Vec) -> DomainId { self.state.new_sparse_variable(values, None) } - pub(crate) fn new_literal(&mut self) -> Literal { + pub fn new_literal(&mut self) -> Literal { let domain_id = self.new_variable(0, 1); Literal::new(domain_id) } - pub(crate) fn new_propagator( + pub fn new_propagator( &mut self, constructor: Constructor, ) -> Result @@ -82,15 +82,15 @@ impl TestSolver { .map(|_| handle.propagator_id()) } - pub(crate) fn contains(&self, var: Var, value: i32) -> bool { + pub fn contains(&self, var: Var, value: i32) -> bool { var.contains(&self.state.assignments, value) } - pub(crate) fn lower_bound(&self, var: DomainId) -> i32 { + pub fn lower_bound(&self, var: DomainId) -> i32 { self.state.assignments.get_lower_bound(var) } - pub(crate) fn remove_and_notify( + pub fn remove_and_notify( &mut self, propagator: PropagatorId, var: DomainId, @@ -117,7 +117,7 @@ impl TestSolver { } } - pub(crate) fn increase_lower_bound_and_notify( + pub fn increase_lower_bound_and_notify( &mut self, propagator: PropagatorId, _local_id: u32, @@ -145,7 +145,7 @@ impl TestSolver { } } - pub(crate) fn decrease_upper_bound_and_notify( + pub fn decrease_upper_bound_and_notify( &mut self, propagator: PropagatorId, _local_id: u32, @@ -173,28 +173,24 @@ impl TestSolver { } } - pub(crate) fn is_literal_false(&self, literal: Literal) -> bool { + pub fn is_literal_false(&self, literal: Literal) -> bool { self.state .assignments .evaluate_predicate(literal.get_true_predicate()) .is_some_and(|truth_value| !truth_value) } - pub(crate) fn upper_bound(&self, var: DomainId) -> i32 { + pub fn upper_bound(&self, var: DomainId) -> i32 { self.state.assignments.get_upper_bound(var) } - pub(crate) fn remove(&mut self, var: DomainId, value: i32) -> Result<(), EmptyDomain> { + pub fn remove(&mut self, var: DomainId, value: i32) -> Result<(), EmptyDomain> { let _ = self.state.post(predicate!(var != value))?; Ok(()) } - pub(crate) fn set_literal( - &mut self, - literal: Literal, - truth_value: bool, - ) -> Result<(), EmptyDomain> { + pub fn set_literal(&mut self, literal: Literal, truth_value: bool) -> Result<(), EmptyDomain> { let _ = match truth_value { true => self.state.assignments.post_predicate( literal.get_true_predicate(), @@ -211,7 +207,7 @@ impl TestSolver { Ok(()) } - pub(crate) fn propagate(&mut self, propagator: PropagatorId) -> Result<(), Conflict> { + pub fn propagate(&mut self, propagator: PropagatorId) -> Result<(), Conflict> { let context = PropagationContext::new( &mut self.state.trailed_values, &mut self.state.assignments, @@ -222,7 +218,7 @@ impl TestSolver { self.state.propagators[propagator].propagate(context) } - pub(crate) fn propagate_until_fixed_point( + pub fn propagate_until_fixed_point( &mut self, propagator: PropagatorId, ) -> Result<(), Conflict> { @@ -249,7 +245,7 @@ impl TestSolver { Ok(()) } - pub(crate) fn notify_propagator(&mut self, _propagator: PropagatorId) { + pub fn notify_propagator(&mut self, _propagator: PropagatorId) { self.state .notification_engine .notify_propagators_about_domain_events_test( @@ -260,7 +256,7 @@ impl TestSolver { ); } - pub(crate) fn get_reason_int(&mut self, predicate: Predicate) -> PropositionalConjunction { + pub fn get_reason_int(&mut self, predicate: Predicate) -> PropositionalConjunction { let reason_ref = self .state .assignments @@ -283,7 +279,7 @@ impl TestSolver { PropositionalConjunction::from(predicates) } - pub(crate) fn get_reason_bool( + pub fn get_reason_bool( &mut self, literal: Literal, truth_value: bool, @@ -295,7 +291,7 @@ impl TestSolver { self.get_reason_int(predicate) } - pub(crate) fn assert_bounds(&self, var: DomainId, lb: i32, ub: i32) { + pub fn assert_bounds(&self, var: DomainId, lb: i32, ub: i32) { let actual_lb = self.lower_bound(var); let actual_ub = self.upper_bound(var); @@ -306,11 +302,11 @@ impl TestSolver { ); } - pub(crate) fn new_constraint_tag(&mut self) -> ConstraintTag { + pub fn new_constraint_tag(&mut self) -> ConstraintTag { self.constraint_tags.next_key() } - pub(crate) fn new_inference_code(&mut self) -> InferenceCode { + pub fn new_inference_code(&mut self) -> InferenceCode { self.state.inference_codes.push(( ConstraintTag::from_non_zero( NonZero::try_from(1 + self.state.inference_codes.len() as u32).unwrap(), @@ -319,11 +315,11 @@ impl TestSolver { )) } - pub(crate) fn new_checkpoint(&mut self) { + pub fn new_checkpoint(&mut self) { self.state.new_checkpoint(); } - pub(crate) fn synchronise(&mut self, level: usize) { + pub fn synchronise(&mut self, level: usize) { let _ = self .state .assignments diff --git a/pumpkin-crates/core/src/engine/notifications/mod.rs b/pumpkin-crates/core/src/engine/notifications/mod.rs index 5e92af65c..dd00a3660 100644 --- a/pumpkin-crates/core/src/engine/notifications/mod.rs +++ b/pumpkin-crates/core/src/engine/notifications/mod.rs @@ -46,7 +46,6 @@ pub(crate) struct NotificationEngine { backtrack_events: EventSink, } -#[cfg(not(test))] impl Default for NotificationEngine { fn default() -> Self { let mut result = Self { @@ -63,9 +62,9 @@ impl Default for NotificationEngine { } } -#[cfg(test)] -impl Default for NotificationEngine { - fn default() -> Self { +impl NotificationEngine { + #[cfg(test)] + pub(crate) fn test_default() -> Self { let watch_list_domain_events = WatchListDomainEvents { watchers: Default::default(), is_watching_anything: true, @@ -84,9 +83,7 @@ impl Default for NotificationEngine { result.grow(); result } -} -impl NotificationEngine { pub(crate) fn debug_empty_clone(&self, capacity: usize) -> Self { let mut result = Self { predicate_notifier: self.predicate_notifier.debug_empty_clone(), @@ -389,21 +386,21 @@ impl NotificationEngine { let _ = self.events.drain(); } - #[cfg(test)] + #[deprecated] pub(crate) fn drain_backtrack_domain_events( &mut self, ) -> impl Iterator + '_ { self.backtrack_events.drain() } - #[cfg(test)] + #[deprecated] pub(crate) fn drain_domain_events( &mut self, ) -> impl Iterator + '_ { self.events.drain() } - #[cfg(test)] + #[deprecated] /// Process the stored domain events that happens as a result of decision/propagation predicates /// to the trail. Propagators are notified and enqueued if needed about the domain events. pub(crate) fn notify_propagators_about_domain_events_test( diff --git a/pumpkin-crates/core/src/engine/state.rs b/pumpkin-crates/core/src/engine/state.rs index a69743b33..11b67ab76 100644 --- a/pumpkin-crates/core/src/engine/state.rs +++ b/pumpkin-crates/core/src/engine/state.rs @@ -982,3 +982,19 @@ impl State { } } } + +impl State { + pub fn get_domains(&mut self) -> Domains<'_> { + Domains::new(&self.assignments, &mut self.trailed_values) + } + + pub fn get_propagation_context(&mut self) -> PropagationContext<'_> { + PropagationContext::new( + &mut self.trailed_values, + &mut self.assignments, + &mut self.reason_store, + &mut self.notification_engine, + PropagatorId(0), + ) + } +} diff --git a/pumpkin-crates/core/src/lib.rs b/pumpkin-crates/core/src/lib.rs index af2544699..2e2046ada 100644 --- a/pumpkin-crates/core/src/lib.rs +++ b/pumpkin-crates/core/src/lib.rs @@ -39,3 +39,4 @@ pub use crate::basic_types::ConstraintOperationError; pub use crate::basic_types::Duration; pub use crate::basic_types::Instant; pub use crate::basic_types::Random; +pub use crate::engine::test_solver::TestSolver; diff --git a/pumpkin-crates/core/src/propagation/domains.rs b/pumpkin-crates/core/src/propagation/domains.rs index 1a86a9d6c..c9c4d3c66 100644 --- a/pumpkin-crates/core/src/propagation/domains.rs +++ b/pumpkin-crates/core/src/propagation/domains.rs @@ -18,7 +18,7 @@ pub struct Domains<'a> { } impl<'a> Domains<'a> { - pub(crate) fn new(assignments: &'a Assignments, trailed_values: &'a mut TrailedValues) -> Self { + pub fn new(assignments: &'a Assignments, trailed_values: &'a mut TrailedValues) -> Self { Domains { assignments, trailed_values, diff --git a/pumpkin-crates/core/src/propagation/mod.rs b/pumpkin-crates/core/src/propagation/mod.rs index 68b3d6113..4df84097c 100644 --- a/pumpkin-crates/core/src/propagation/mod.rs +++ b/pumpkin-crates/core/src/propagation/mod.rs @@ -106,6 +106,4 @@ use crate::engine::variables::IntegerVariable; #[cfg(doc)] use crate::propagators; #[cfg(doc)] -use crate::propagators::linear_less_or_equal::LinearLessOrEqualPropagator; -#[cfg(doc)] use crate::state::State; diff --git a/pumpkin-crates/propagators/Cargo.toml b/pumpkin-crates/propagators/Cargo.toml index 2ec97354c..fac80d086 100644 --- a/pumpkin-crates/propagators/Cargo.toml +++ b/pumpkin-crates/propagators/Cargo.toml @@ -17,5 +17,8 @@ bitfield-struct = "0.9.2" convert_case = "0.6.0" clap = { version = "4.5.40", optional = true } +[dev-dependencies] +pumpkin-constraints = { version = "0.2.2", path = "../constraints" } + [features] clap = ["dep:clap"] diff --git a/pumpkin-crates/propagators/src/propagators/arithmetic/absolute_value.rs b/pumpkin-crates/propagators/src/propagators/arithmetic/absolute_value.rs index d67d2c440..6dd6904d5 100644 --- a/pumpkin-crates/propagators/src/propagators/arithmetic/absolute_value.rs +++ b/pumpkin-crates/propagators/src/propagators/arithmetic/absolute_value.rs @@ -148,6 +148,8 @@ where #[cfg(test)] mod tests { + use pumpkin_core::TestSolver; + use super::*; #[test] diff --git a/pumpkin-crates/propagators/src/propagators/arithmetic/binary/binary_equals.rs b/pumpkin-crates/propagators/src/propagators/arithmetic/binary/binary_equals.rs index 7eea2a7c0..157edd334 100644 --- a/pumpkin-crates/propagators/src/propagators/arithmetic/binary/binary_equals.rs +++ b/pumpkin-crates/propagators/src/propagators/arithmetic/binary/binary_equals.rs @@ -385,8 +385,9 @@ struct BinaryEqualsPropagation { #[cfg(test)] mod tests { - use crate::engine::test_solver::TestSolver; - use crate::propagation::EnqueueDecision; + use pumpkin_core::TestSolver; + use pumpkin_core::propagation::EnqueueDecision; + use crate::propagators::binary::BinaryEqualsPropagatorArgs; #[test] diff --git a/pumpkin-crates/propagators/src/propagators/arithmetic/binary/binary_not_equals.rs b/pumpkin-crates/propagators/src/propagators/arithmetic/binary/binary_not_equals.rs index 3be8868d1..ca89a8832 100644 --- a/pumpkin-crates/propagators/src/propagators/arithmetic/binary/binary_not_equals.rs +++ b/pumpkin-crates/propagators/src/propagators/arithmetic/binary/binary_not_equals.rs @@ -170,6 +170,9 @@ where #[cfg(test)] mod tests { + use pumpkin_core::TestSolver; + use pumpkin_core::propagation::EnqueueDecision; + use crate::propagators::binary::BinaryNotEqualsPropagatorArgs; #[test] diff --git a/pumpkin-crates/propagators/src/propagators/arithmetic/integer_division.rs b/pumpkin-crates/propagators/src/propagators/arithmetic/integer_division.rs index d90ed78d2..f31ac2b07 100644 --- a/pumpkin-crates/propagators/src/propagators/arithmetic/integer_division.rs +++ b/pumpkin-crates/propagators/src/propagators/arithmetic/integer_division.rs @@ -380,7 +380,7 @@ fn propagate_signs i32 { #[cfg(test)] mod tests { + use pumpkin_core::TestSolver; + use super::*; - use crate::conjunction; - use crate::engine::test_solver::TestSolver; - use crate::predicate; #[test] fn bounds_of_a_and_b_propagate_bounds_c() { diff --git a/pumpkin-crates/propagators/src/propagators/arithmetic/linear_less_or_equal.rs b/pumpkin-crates/propagators/src/propagators/arithmetic/linear_less_or_equal.rs index 86d424f67..e45d1ab36 100644 --- a/pumpkin-crates/propagators/src/propagators/arithmetic/linear_less_or_equal.rs +++ b/pumpkin-crates/propagators/src/propagators/arithmetic/linear_less_or_equal.rs @@ -273,9 +273,10 @@ where #[cfg(test)] mod tests { + use pumpkin_core::TestSolver; + use pumpkin_core::conjunction; + use super::*; - use crate::conjunction; - use crate::engine::test_solver::TestSolver; #[test] fn test_bounds_are_propagated() { diff --git a/pumpkin-crates/propagators/src/propagators/arithmetic/linear_not_equal.rs b/pumpkin-crates/propagators/src/propagators/arithmetic/linear_not_equal.rs index be09af1f5..2fd2c75d9 100644 --- a/pumpkin-crates/propagators/src/propagators/arithmetic/linear_not_equal.rs +++ b/pumpkin-crates/propagators/src/propagators/arithmetic/linear_not_equal.rs @@ -360,11 +360,12 @@ impl LinearNotEqualPropagator { #[cfg(test)] mod tests { + use pumpkin_core::TestSolver; + use pumpkin_core::conjunction; + use pumpkin_core::state::Conflict; + use pumpkin_core::variables::TransformableVariable; + use super::*; - use crate::conjunction; - use crate::engine::test_solver::TestSolver; - use crate::engine::variables::TransformableVariable; - use crate::state::Conflict; #[test] fn test_value_is_removed() { diff --git a/pumpkin-crates/propagators/src/propagators/arithmetic/maximum.rs b/pumpkin-crates/propagators/src/propagators/arithmetic/maximum.rs index f6f6aef0a..d0ff5110d 100644 --- a/pumpkin-crates/propagators/src/propagators/arithmetic/maximum.rs +++ b/pumpkin-crates/propagators/src/propagators/arithmetic/maximum.rs @@ -173,7 +173,7 @@ impl Prop #[cfg(test)] mod tests { use super::*; - use crate::engine::test_solver::TestSolver; + use pumpkin_core::TestSolver; #[test] fn upper_bound_of_rhs_matches_maximum_upper_bound_of_array_at_initialise() { diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/mod.rs b/pumpkin-crates/propagators/src/propagators/cumulative/mod.rs index a310d9582..41b8e1c21 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/mod.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/mod.rs @@ -43,7 +43,7 @@ //! # use pumpkin_core::results::SatisfactionResult; //! # use pumpkin_core::constraints; //! # use pumpkin_core::constraints::Constraint; -//! # use crate::pumpkin_core::results::ProblemSolution; +//! # use pumpkin_core::results::ProblemSolution; //! let mut solver = Solver::default(); //! //! let start_0 = solver.new_bounded_integer(0, 4); @@ -57,7 +57,7 @@ //! //! let c1 = solver.new_constraint_tag(); //! solver -//! .add_constraint(constraints::cumulative( +//! .add_constraint(pumpkin_constraints::cumulative( //! start_times.clone(), //! durations.clone(), //! resource_requirements.clone(), diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/options.rs b/pumpkin-crates/propagators/src/propagators/cumulative/options.rs index d602ec9e9..ac41e1825 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/options.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/options.rs @@ -1,6 +1,4 @@ use super::CumulativeExplanationType; -#[cfg(doc)] -use crate::constraints; #[derive(Debug, Default, Clone, Copy)] pub struct CumulativePropagatorOptions { @@ -48,7 +46,7 @@ impl CumulativeOptions { } } -/// The approach used for propagating the [`constraints::cumulative`] constraint. +/// The approach used for propagating the Cumulative constraint. #[derive(Debug, Default, Clone, Copy)] #[cfg_attr(feature = "clap", derive(clap::ValueEnum))] pub enum CumulativePropagationMethod { diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/big_step.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/big_step.rs index f8ecce797..f26306c42 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/big_step.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/big_step.rs @@ -73,8 +73,9 @@ where #[cfg(test)] mod tests { - use crate::predicate; - use crate::predicates::PropositionalConjunction; + use pumpkin_core::predicate; + use pumpkin_core::predicates::PropositionalConjunction; + use crate::propagators::CumulativeExplanationType; use crate::propagators::cumulative::time_table::propagation_handler::test_propagation_handler::TestPropagationHandler; diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/naive.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/naive.rs index d61b6b783..981af67f4 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/naive.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/naive.rs @@ -83,8 +83,9 @@ where #[cfg(test)] mod tests { - use crate::predicate; - use crate::predicates::PropositionalConjunction; + use pumpkin_core::predicate; + use pumpkin_core::predicates::PropositionalConjunction; + use crate::propagators::CumulativeExplanationType; use crate::propagators::cumulative::time_table::propagation_handler::test_propagation_handler::TestPropagationHandler; diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/pointwise.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/pointwise.rs index d061467a5..e55f09edc 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/pointwise.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/pointwise.rs @@ -311,8 +311,9 @@ where #[cfg(test)] mod tests { - use crate::predicate; - use crate::predicates::PropositionalConjunction; + use pumpkin_core::predicate; + use pumpkin_core::predicates::PropositionalConjunction; + use crate::propagators::CumulativeExplanationType; use crate::propagators::cumulative::time_table::propagation_handler::test_propagation_handler::TestPropagationHandler; diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/time_table_over_interval_incremental.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/time_table_over_interval_incremental.rs index 429502f51..ce238ff43 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/time_table_over_interval_incremental.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/time_table_over_interval_incremental.rs @@ -627,17 +627,18 @@ fn find_overlapping_profile( #[cfg(test)] mod tests { - use crate::conjunction; - use crate::engine::predicates::predicate::Predicate; - use crate::engine::test_solver::TestSolver; - use crate::predicate; - use crate::propagation::EnqueueDecision; + use pumpkin_core::TestSolver; + use pumpkin_core::conjunction; + use pumpkin_core::predicate; + use pumpkin_core::predicates::Predicate; + use pumpkin_core::propagation::EnqueueDecision; + use pumpkin_core::state::Conflict; + use pumpkin_core::variables::DomainId; + use crate::propagators::ArgTask; use crate::propagators::CumulativeExplanationType; use crate::propagators::CumulativePropagatorOptions; use crate::propagators::TimeTableOverIntervalIncrementalPropagator; - use crate::state::Conflict; - use crate::variables::DomainId; #[test] fn propagator_propagates_from_profile() { diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/per_point_incremental_propagator/synchronisation.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/per_point_incremental_propagator/synchronisation.rs index dffac26e5..6385d9f8b 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/per_point_incremental_propagator/synchronisation.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/per_point_incremental_propagator/synchronisation.rs @@ -168,7 +168,7 @@ mod tests { use pumpkin_core::propagation::LocalId; use super::find_synchronised_conflict; - use crate::engine::test_solver::TestSolver; + use pumpkin_core::TestSolver; use crate::propagators::CumulativeParameters; use crate::propagators::CumulativePropagatorOptions; use crate::propagators::PerPointTimeTableType; diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/per_point_incremental_propagator/time_table_per_point_incremental.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/per_point_incremental_propagator/time_table_per_point_incremental.rs index 7504dc20f..f0149cb8b 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/per_point_incremental_propagator/time_table_per_point_incremental.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/per_point_incremental_propagator/time_table_per_point_incremental.rs @@ -624,19 +624,19 @@ mod debug { #[cfg(test)] mod tests { - use crate::conjunction; - use crate::engine::predicates::predicate::Predicate; - use crate::engine::test_solver::TestSolver; - use crate::predicate; - use crate::predicates::PredicateConstructor; - use crate::propagation::EnqueueDecision; + use pumpkin_core::TestSolver; + use pumpkin_core::conjunction; + use pumpkin_core::predicate; + use pumpkin_core::predicates::Predicate; + use pumpkin_core::propagation::EnqueueDecision; + use pumpkin_core::state::Conflict; + use pumpkin_core::variables::DomainId; + use crate::propagators::ArgTask; use crate::propagators::CumulativeExplanationType; use crate::propagators::CumulativePropagatorOptions; use crate::propagators::TimeTablePerPointIncrementalPropagator; use crate::propagators::TimeTablePerPointPropagator; - use crate::state::Conflict; - use crate::variables::DomainId; #[test] fn propagator_propagates_from_profile() { @@ -1599,8 +1599,8 @@ mod tests { let result = solver.propagate(propagator); assert!(result.is_ok()); assert_eq!(solver.lower_bound(s3), 7); - let reason_scratch = solver_scratch.get_reason_int(s3_scratch.lower_bound_predicate(7)); - let reason = solver.get_reason_int(s3.lower_bound_predicate(7)); + let reason_scratch = solver_scratch.get_reason_int(predicate!(s3_scratch >= 7)); + let reason = solver.get_reason_int(predicate!(s3 >= 7)); assert_eq!( reason_scratch.iter().collect::>(), reason.iter().collect::>() @@ -1695,8 +1695,8 @@ mod tests { assert!(result.is_ok()); assert_eq!(solver.lower_bound(s3), 7); - let reason_scratch = solver_scratch.get_reason_int(s3_scratch.lower_bound_predicate(7)); - let reason = solver.get_reason_int(s3.lower_bound_predicate(7)); + let reason_scratch = solver_scratch.get_reason_int(predicate!(s3_scratch >= 7)); + let reason = solver.get_reason_int(predicate!(s3 >= 7)); assert_ne!( reason_scratch.iter().collect::>(), reason.iter().collect::>() @@ -1811,8 +1811,8 @@ mod tests { println!("{explanation_vec:?}"); println!("{explanation_scratch_vec:?}"); - assert!(explanation_vec.contains(&s2.lower_bound_predicate(5))); - assert!(!explanation_scratch_vec.contains(&s2.lower_bound_predicate(5))); + assert!(explanation_vec.contains(&predicate!(s2 >= 5))); + assert!(!explanation_scratch_vec.contains(&predicate!(s2 >= 5))); } else { panic!("Incorrect result") } diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/propagation_handler.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/propagation_handler.rs index 58dbe1da7..428abe28b 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/propagation_handler.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/propagation_handler.rs @@ -477,35 +477,28 @@ where pub(crate) mod test_propagation_handler { use std::rc::Rc; + use pumpkin_core::containers::StorageKey; + use pumpkin_core::predicate; + use pumpkin_core::predicates::Predicate; + use pumpkin_core::predicates::PropositionalConjunction; + use pumpkin_core::proof::InferenceCode; use pumpkin_core::propagation::Domains; use pumpkin_core::propagation::LocalId; + use pumpkin_core::state::CurrentNogood; + use pumpkin_core::state::PropagatorId; + use pumpkin_core::state::State; + use pumpkin_core::variables::DomainId; use super::CumulativeExplanationType; use super::CumulativePropagationHandler; use super::create_conflict_explanation; - use crate::containers::StorageKey; - use crate::engine::Assignments; - use crate::engine::TrailedValues; - use crate::engine::notifications::NotificationEngine; - use crate::engine::reason::ReasonStore; - use crate::predicate; - use crate::predicates::Predicate; - use crate::predicates::PropositionalConjunction; - use crate::proof::InferenceCode; - use crate::propagation::ExplanationContext; - use crate::propagation::PropagationContext; - use crate::propagation::PropagatorId; - use crate::propagation::store::PropagatorStore; use crate::propagators::ResourceProfile; use crate::propagators::Task; - use crate::variables::DomainId; pub(crate) struct TestPropagationHandler { propagation_handler: CumulativePropagationHandler, - notification_engine: NotificationEngine, - reason_store: ReasonStore, - assignments: Assignments, - trailed_values: TrailedValues, + state: State, + reason_buffer: Vec, } impl TestPropagationHandler { @@ -515,22 +508,16 @@ pub(crate) mod test_propagation_handler { InferenceCode::create_from_index(0), ); - let reason_store = ReasonStore::default(); - let assignments = Assignments::default(); - let trailed_values = TrailedValues::default(); - let notification_engine = NotificationEngine::default(); + let state = State::default(); Self { propagation_handler, - notification_engine, - reason_store, - assignments, - trailed_values, + state, + reason_buffer: Default::default(), } } pub(crate) fn set_up_conflict_example(&mut self) -> (PropositionalConjunction, DomainId) { - let y = self.assignments.grow(15, 16); - self.notification_engine.grow(); + let y = self.state.new_interval_variable(15, 16, None); let profile_task = Task { start_variable: y, @@ -547,7 +534,7 @@ pub(crate) mod test_propagation_handler { }; let reason = create_conflict_explanation( - Domains::new(&self.assignments, &mut self.trailed_values), + self.state.get_domains(), self.propagation_handler.inference_code, &profile, self.propagation_handler.explanation_type, @@ -559,10 +546,8 @@ pub(crate) mod test_propagation_handler { pub(crate) fn set_up_example_lower_bound( &mut self, ) -> (PropositionalConjunction, DomainId, DomainId) { - let x = self.assignments.grow(11, 20); - let y = self.assignments.grow(15, 16); - self.notification_engine.grow(); - self.notification_engine.grow(); + let x = self.state.new_interval_variable(11, 20, None); + let y = self.state.new_interval_variable(15, 16, None); let propagating_task = Task { start_variable: x, @@ -588,18 +573,12 @@ pub(crate) mod test_propagation_handler { let result = self .propagation_handler .propagate_lower_bound_with_explanations( - &mut PropagationContext::new( - &mut self.trailed_values, - &mut self.assignments, - &mut self.reason_store, - &mut self.notification_engine, - PropagatorId(0), - ), + &mut self.state.get_propagation_context(), &profile, &Rc::new(propagating_task), ); assert!(result.is_ok()); - assert_eq!(self.assignments.get_lower_bound(x), 19); + assert_eq!(self.state.lower_bound(x), 19); let reason = self.get_reason_for(predicate!(x >= 19)); @@ -609,12 +588,9 @@ pub(crate) mod test_propagation_handler { pub(crate) fn set_up_example_sequence_lower_bound( &mut self, ) -> (PropositionalConjunction, DomainId, DomainId, DomainId) { - let x = self.assignments.grow(11, 25); - let y = self.assignments.grow(15, 16); - let z = self.assignments.grow(15, 19); - self.notification_engine.grow(); - self.notification_engine.grow(); - self.notification_engine.grow(); + let x = self.state.new_interval_variable(11, 25, None); + let y = self.state.new_interval_variable(15, 16, None); + let z = self.state.new_interval_variable(15, 19, None); let propagating_task = Task { start_variable: x, @@ -652,18 +628,12 @@ pub(crate) mod test_propagation_handler { let result = self .propagation_handler .propagate_chain_of_lower_bounds_with_explanations( - &mut PropagationContext::new( - &mut self.trailed_values, - &mut self.assignments, - &mut self.reason_store, - &mut self.notification_engine, - PropagatorId(0), - ), + &mut self.state.get_propagation_context(), &[&profile_y, &profile_z], &Rc::new(propagating_task), ); assert!(result.is_ok()); - assert_eq!(self.assignments.get_lower_bound(x), 22); + assert_eq!(self.state.lower_bound(x), 22); let reason = self.get_reason_for(predicate!(x >= 22)); @@ -673,10 +643,8 @@ pub(crate) mod test_propagation_handler { pub(crate) fn set_up_example_upper_bound( &mut self, ) -> (PropositionalConjunction, DomainId, DomainId) { - let x = self.assignments.grow(5, 16); - let y = self.assignments.grow(15, 16); - self.notification_engine.grow(); - self.notification_engine.grow(); + let x = self.state.new_interval_variable(5, 16, None); + let y = self.state.new_interval_variable(15, 16, None); let propagating_task = Task { start_variable: x, @@ -702,18 +670,12 @@ pub(crate) mod test_propagation_handler { let result = self .propagation_handler .propagate_upper_bound_with_explanations( - &mut PropagationContext::new( - &mut self.trailed_values, - &mut self.assignments, - &mut self.reason_store, - &mut self.notification_engine, - PropagatorId(0), - ), + &mut self.state.get_propagation_context(), &profile, &Rc::new(propagating_task), ); assert!(result.is_ok()); - assert_eq!(self.assignments.get_upper_bound(x), 10); + assert_eq!(self.state.upper_bound(x), 10); let reason = self.get_reason_for(predicate!(x <= 10)); @@ -723,12 +685,9 @@ pub(crate) mod test_propagation_handler { pub(crate) fn set_up_example_sequence_upper_bound( &mut self, ) -> (PropositionalConjunction, DomainId, DomainId, DomainId) { - let x = self.assignments.grow(0, 16); - let y = self.assignments.grow(15, 16); - let z = self.assignments.grow(7, 9); - self.notification_engine.grow(); - self.notification_engine.grow(); - self.notification_engine.grow(); + let x = self.state.new_interval_variable(0, 16, None); + let y = self.state.new_interval_variable(15, 16, None); + let z = self.state.new_interval_variable(7, 9, None); let propagating_task = Task { start_variable: x, @@ -766,18 +725,12 @@ pub(crate) mod test_propagation_handler { let result = self .propagation_handler .propagate_chain_of_upper_bounds_with_explanations( - &mut PropagationContext::new( - &mut self.trailed_values, - &mut self.assignments, - &mut self.reason_store, - &mut self.notification_engine, - PropagatorId(0), - ), + &mut self.state.get_propagation_context(), &[&profile_z, &profile_y], &Rc::new(propagating_task), ); assert!(result.is_ok()); - assert_eq!(self.assignments.get_upper_bound(x), 3); + assert_eq!(self.state.upper_bound(x), 3); let reason = self.get_reason_for(predicate!(x <= 3)); @@ -785,23 +738,15 @@ pub(crate) mod test_propagation_handler { } pub(crate) fn get_reason_for(&mut self, predicate: Predicate) -> PropositionalConjunction { - let reason_ref = self - .assignments - .get_reason_for_predicate_brute_force(predicate); - let mut propagator_store = PropagatorStore::default(); - let mut reason = vec![]; - let _ = self.reason_store.get_or_compute( - reason_ref, - ExplanationContext::without_working_nogood( - &self.assignments, - self.assignments.get_trail_position(&predicate).unwrap(), - &mut self.notification_engine, - ), - &mut propagator_store, - &mut reason, + let _ = self.state.get_propagation_reason( + predicate, + &mut self.reason_buffer, + CurrentNogood::empty(), ); - reason.into() + let result = self.reason_buffer.clone().into(); + self.reason_buffer.clear(); + result } } } diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/time_table_over_interval.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/time_table_over_interval.rs index 0f0086004..7d45bb99d 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/time_table_over_interval.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/time_table_over_interval.rs @@ -472,16 +472,17 @@ pub(crate) fn propagate_from_scratch_time_table_interval( #[cfg(test)] mod tests { - use crate::engine::test_solver::TestSolver; + use pumpkin_core::TestSolver; use crate::propagators::disjunctive_propagator::DisjunctiveConstructor; use crate::propagators::disjunctive_task::ArgDisjunctiveTask; diff --git a/pumpkin-crates/propagators/src/propagators/disjunctive/disjunctive_task.rs b/pumpkin-crates/propagators/src/propagators/disjunctive/disjunctive_task.rs index 4af07e860..e5204716f 100644 --- a/pumpkin-crates/propagators/src/propagators/disjunctive/disjunctive_task.rs +++ b/pumpkin-crates/propagators/src/propagators/disjunctive/disjunctive_task.rs @@ -1,10 +1,8 @@ use std::fmt::Debug; -#[cfg(doc)] -use crate::constraints; use pumpkin_core::propagation::LocalId; -/// Defines the input of the [`constraints::disjunctive_strict`] constraint. +/// Defines the input of the Disjunctive constraint. /// /// Each task has a variable starting time and a constant processing time. #[derive(Debug, Clone)] diff --git a/pumpkin-crates/propagators/src/propagators/disjunctive/theta_lambda_tree.rs b/pumpkin-crates/propagators/src/propagators/disjunctive/theta_lambda_tree.rs index 4c42cd4ac..0401b33b9 100644 --- a/pumpkin-crates/propagators/src/propagators/disjunctive/theta_lambda_tree.rs +++ b/pumpkin-crates/propagators/src/propagators/disjunctive/theta_lambda_tree.rs @@ -376,10 +376,10 @@ impl ThetaLambdaTree { #[cfg(test)] mod tests { + use pumpkin_core::TestSolver; use pumpkin_core::propagation::Domains; use pumpkin_core::propagation::LocalId; - use crate::engine::test_solver::TestSolver; use crate::propagators::disjunctive::theta_lambda_tree::Node; use crate::propagators::disjunctive::theta_lambda_tree::ThetaLambdaTree; use crate::propagators::disjunctive_task::DisjunctiveTask; @@ -416,21 +416,12 @@ mod tests { let mut tree = ThetaLambdaTree::new(&tasks); - tree.update(Domains::new( - &solver.state.assignments, - &mut solver.state.trailed_values, - )); + tree.update(solver.state.get_domains()); for task in tasks.iter() { - tree.add_to_theta( - task, - Domains::new(&solver.state.assignments, &mut solver.state.trailed_values), - ); + tree.add_to_theta(task, solver.state.get_domains()); } tree.remove_from_theta(&tasks[2]); - tree.add_to_lambda( - &tasks[2], - Domains::new(&solver.state.assignments, &mut solver.state.trailed_values), - ); + tree.add_to_lambda(&tasks[2], solver.state.get_domains()); assert_eq!( tree.nodes[6], diff --git a/pumpkin-crates/propagators/src/propagators/element.rs b/pumpkin-crates/propagators/src/propagators/element.rs index d034b7e49..bd00e7b39 100644 --- a/pumpkin-crates/propagators/src/propagators/element.rs +++ b/pumpkin-crates/propagators/src/propagators/element.rs @@ -295,10 +295,9 @@ struct RightHandSideReason { #[cfg(test)] mod tests { + use pumpkin_core::TestSolver; + use super::*; - use crate::conjunction; - use crate::engine::test_solver::TestSolver; - use crate::predicate; #[test] fn elements_from_array_with_disjoint_domains_to_rhs_are_filtered_from_index() { diff --git a/pumpkin-crates/propagators/src/propagators/mod.rs b/pumpkin-crates/propagators/src/propagators/mod.rs index 4f71d69f7..27f107071 100644 --- a/pumpkin-crates/propagators/src/propagators/mod.rs +++ b/pumpkin-crates/propagators/src/propagators/mod.rs @@ -2,7 +2,7 @@ //! //! See the [`propagation`] for info on propagators. #[cfg(doc)] -use crate::propagation; +use pumpkin_core::propagation; pub(crate) mod arithmetic; mod cumulative; diff --git a/pumpkin-solver/examples/bibd.rs b/pumpkin-solver/examples/bibd.rs index 17e6449b0..2b4ae42c4 100644 --- a/pumpkin-solver/examples/bibd.rs +++ b/pumpkin-solver/examples/bibd.rs @@ -14,7 +14,6 @@ //! Hence, the problem is defined in terms of v, k, and l. use pumpkin_solver::Solver; -use pumpkin_solver::constraints; use pumpkin_solver::results::ProblemSolution; use pumpkin_solver::results::SatisfactionResult; use pumpkin_solver::termination::Indefinite; @@ -97,7 +96,7 @@ fn main() { // Enforce the row sum. for row in matrix.iter() { let _ = solver - .add_constraint(constraints::equals( + .add_constraint(pumpkin_constraints::equals( row.clone(), bibd.row_sum as i32, constraint_tag, @@ -108,7 +107,7 @@ fn main() { // Enforce the column sum. for row in transpose(&matrix) { let _ = solver - .add_constraint(constraints::equals( + .add_constraint(pumpkin_constraints::equals( row, bibd.column_sum as i32, constraint_tag, @@ -126,7 +125,7 @@ fn main() { for r2 in r1 + 1..bibd.rows as usize { for col in 0..bibd.columns as usize { let _ = solver - .add_constraint(constraints::times( + .add_constraint(pumpkin_constraints::times( matrix[r1][col], matrix[r2][col], pairwise_product[r1][r2][col], @@ -136,7 +135,7 @@ fn main() { } let _ = solver - .add_constraint(constraints::less_than_or_equals( + .add_constraint(pumpkin_constraints::less_than_or_equals( pairwise_product[r1][r2].clone(), bibd.max_dot_product as i32, constraint_tag, diff --git a/pumpkin-solver/examples/disjunctive_scheduling.rs b/pumpkin-solver/examples/disjunctive_scheduling.rs index 603a7b1a5..e5d84284b 100644 --- a/pumpkin-solver/examples/disjunctive_scheduling.rs +++ b/pumpkin-solver/examples/disjunctive_scheduling.rs @@ -9,9 +9,8 @@ //! To ensure that one of these occurs, we create two Boolean variables, l_xy and l_yx, to signify //! the two possibilities, and then post the constraint (l_xy \/ l_yx). +use pumpkin_core::constraints::NegatableConstraint; use pumpkin_solver::Solver; -use pumpkin_solver::constraints; -use pumpkin_solver::constraints::NegatableConstraint; use pumpkin_solver::results::ProblemSolution; use pumpkin_solver::results::SatisfactionResult; use pumpkin_solver::termination::Indefinite; @@ -69,7 +68,7 @@ fn main() { // equivelent to literal <=> (s_x - s_y <= -p_x) // So the variables are -s_y and s_x, and the rhs is -p_x let variables = vec![start_variables[y].scaled(-1), start_variables[x].scaled(1)]; - let _ = constraints::less_than_or_equals( + let _ = pumpkin_constraints::less_than_or_equals( variables, -(processing_times[x] as i32), constraint_tag, diff --git a/pumpkin-solver/examples/nqueens.rs b/pumpkin-solver/examples/nqueens.rs index d656162ff..4247ff50b 100644 --- a/pumpkin-solver/examples/nqueens.rs +++ b/pumpkin-solver/examples/nqueens.rs @@ -61,7 +61,10 @@ fn main() { .collect::>(); let _ = solver - .add_constraint(constraints::all_different(variables.clone(), c1_tag)) + .add_constraint(pumpkin_constraints::all_different( + variables.clone(), + c1_tag, + )) .post(); let diag1 = variables @@ -78,10 +81,10 @@ fn main() { .collect::>(); let _ = solver - .add_constraint(constraints::all_different(diag1, c2_tag)) + .add_constraint(pumpkin_constraints::all_different(diag1, c2_tag)) .post(); let _ = solver - .add_constraint(constraints::all_different(diag2, c3_tag)) + .add_constraint(pumpkin_constraints::all_different(diag2, c3_tag)) .post(); let mut brancher = solver.default_brancher(); diff --git a/pumpkin-solver/src/lib.rs b/pumpkin-solver/src/lib.rs index e02317206..c88725131 100644 --- a/pumpkin-solver/src/lib.rs +++ b/pumpkin-solver/src/lib.rs @@ -55,7 +55,7 @@ //! // x + y + z = 17 //! let c1 = solver.new_constraint_tag(); //! solver -//! .add_constraint(constraints::equals(vec![x, y, z], 17, c1)) +//! .add_constraint(pumpkin_constraints::equals(vec![x, y, z], 17, c1)) //! .post(); //! ``` //! @@ -87,7 +87,7 @@ //! # let y = solver.new_bounded_integer(-3, 15); //! # let z = solver.new_bounded_integer(7, 25); //! # let c1 = solver.new_constraint_tag(); -//! # solver.add_constraint(constraints::equals(vec![x, y, z], 17, c1)).post(); +//! # solver.add_constraint(pumpkin_constraints::equals(vec![x, y, z], 17, c1)).post(); //! # let mut termination = Indefinite; //! # let mut brancher = solver.default_brancher(); //! // Then we find a solution to the problem @@ -124,7 +124,7 @@ //! // We add a constraint which specifies the value of the objective //! let c1 = solver.new_constraint_tag(); //! solver -//! .add_constraint(constraints::maximum(vec![x, y, z], objective, c1)) +//! .add_constraint(pumpkin_constraints::maximum(vec![x, y, z], objective, c1)) //! .post(); //! ``` //! @@ -148,8 +148,8 @@ //! # let z = solver.new_bounded_integer(7, 25); //! # let objective = solver.new_bounded_integer(-10, 30); //! # let c1 = solver.new_constraint_tag(); -//! # solver.add_constraint(constraints::equals(vec![x, y, z], 17, c1)).post(); -//! # solver.add_constraint(constraints::maximum(vec![x, y, z], objective, c1)).post(); +//! # solver.add_constraint(pumpkin_constraints::equals(vec![x, y, z], 17, c1)).post(); +//! # solver.add_constraint(pumpkin_constraints::maximum(vec![x, y, z], objective, c1)).post(); //! # let mut termination = Indefinite; //! # let mut brancher = solver.default_brancher(); //! // Then we solve to optimality @@ -203,7 +203,7 @@ //! //! // We create the all-different constraint //! let c1 = solver.new_constraint_tag(); -//! solver.add_constraint(constraints::all_different(vec![x, y, z], c1)).post(); +//! solver.add_constraint(pumpkin_constraints::all_different(vec![x, y, z], c1)).post(); //! //! // We create a termination condition which allows the solver to run indefinitely //! let mut termination = Indefinite; @@ -269,7 +269,7 @@ //! //! // We create the all-different constraint //! let c1 = solver.new_constraint_tag(); -//! solver.add_constraint(constraints::all_different(vec![x, y, z], c1)).post(); +//! solver.add_constraint(pumpkin_constraints::all_different(vec![x, y, z], c1)).post(); //! //! // We create a termination condition which allows the solver to run indefinitely //! let mut termination = Indefinite; diff --git a/pumpkin-solver/tests/iteration_test.rs b/pumpkin-solver/tests/iteration_test.rs index deb14a2f7..f351c721b 100644 --- a/pumpkin-solver/tests/iteration_test.rs +++ b/pumpkin-solver/tests/iteration_test.rs @@ -20,7 +20,10 @@ fn iterator_finds_all_solutions() { // We create the all-different constraint let _ = solver - .add_constraint(constraints::all_different(vec![x, y, z], constraint_tag)) + .add_constraint(pumpkin_constraints::all_different( + vec![x, y, z], + constraint_tag, + )) .post(); // We create a termination condition which allows the solver to run indefinitely diff --git a/pumpkin-solver/tests/solver_test.rs b/pumpkin-solver/tests/solver_test.rs index 60165f584..5ad1f5618 100644 --- a/pumpkin-solver/tests/solver_test.rs +++ b/pumpkin-solver/tests/solver_test.rs @@ -3,7 +3,6 @@ use std::path::PathBuf; use pumpkin_solver::Solver; -use pumpkin_solver::constraints; use pumpkin_solver::options::SolverOptions; use pumpkin_solver::predicate; use pumpkin_solver::proof::ProofLog; @@ -23,12 +22,16 @@ fn proof_with_reified_literals() { let literal = solver.new_literal_for_predicate(predicate![variable == 5], constraint_tag); solver - .add_constraint(constraints::clause(vec![literal], constraint_tag)) + .add_constraint(pumpkin_constraints::clause(vec![literal], constraint_tag)) .post() .expect("no error"); let _ = solver - .add_constraint(constraints::not_equals([variable], 5, constraint_tag)) + .add_constraint(pumpkin_constraints::not_equals( + [variable], + 5, + constraint_tag, + )) .post() .expect_err("unsat"); @@ -50,12 +53,20 @@ fn proof_with_equality_unit_nogood_step() { let x1 = solver.new_named_bounded_integer(1, 2, "x1"); let x2 = solver.new_named_bounded_integer(1, 1, "x2"); solver - .add_constraint(constraints::binary_not_equals(x1, x2, constraint_tag)) + .add_constraint(pumpkin_constraints::binary_not_equals( + x1, + x2, + constraint_tag, + )) .post() .expect("no conflict"); let _ = solver - .add_constraint(constraints::less_than_or_equals([x1], 1, constraint_tag)) + .add_constraint(pumpkin_constraints::less_than_or_equals( + [x1], + 1, + constraint_tag, + )) .post() .expect_err("conflict"); From 4ea32a18c71b00d5cfdee16b078114f3adf3ab10 Mon Sep 17 00:00:00 2001 From: Imko Marijnissen Date: Tue, 16 Dec 2025 12:41:32 +0100 Subject: [PATCH 3/6] fix: fix the clippy warnings --- pumpkin-crates/core/src/containers/keyed_vec.rs | 4 ++++ .../core/src/engine/constraint_satisfaction_solver.rs | 1 - pumpkin-crates/core/src/engine/cp/test_solver.rs | 7 ++++++- pumpkin-crates/core/src/engine/notifications/mod.rs | 4 ++-- pumpkin-crates/core/src/lib.rs | 1 + pumpkin-crates/core/src/propagation/domains.rs | 2 +- pumpkin-crates/core/src/propagators/mod.rs | 1 - .../core/src/propagators/nogoods/nogood_propagator.rs | 3 ++- .../core/src/propagators/reified_propagator.rs | 3 ++- pumpkin-crates/propagators/src/lib.rs | 1 - .../src/propagators/arithmetic/absolute_value.rs | 1 + .../propagators/arithmetic/binary/binary_equals.rs | 1 + .../arithmetic/binary/binary_not_equals.rs | 1 + .../src/propagators/arithmetic/integer_division.rs | 4 +++- .../propagators/arithmetic/integer_multiplication.rs | 1 + .../propagators/arithmetic/linear_less_or_equal.rs | 1 + .../src/propagators/arithmetic/linear_not_equal.rs | 1 + .../propagators/src/propagators/arithmetic/maximum.rs | 6 ++++-- .../propagators/src/propagators/cumulative/options.rs | 2 +- .../time_table_over_interval_incremental.rs | 1 + .../synchronisation.rs | 3 ++- .../time_table_per_point_incremental.rs | 1 + .../cumulative/time_table/propagation_handler.rs | 2 -- .../cumulative/time_table/time_table_over_interval.rs | 1 + .../cumulative/time_table/time_table_per_point.rs | 1 + .../cumulative/time_table/time_table_util.rs | 1 - .../propagators/disjunctive/disjunctive_propagator.rs | 2 ++ .../src/propagators/disjunctive/theta_lambda_tree.rs | 2 +- pumpkin-crates/propagators/src/propagators/element.rs | 1 + pumpkin-solver/examples/nqueens.rs | 1 - pumpkin-solver/src/lib.rs | 11 ++++++----- pumpkin-solver/tests/iteration_test.rs | 1 - 32 files changed, 48 insertions(+), 25 deletions(-) diff --git a/pumpkin-crates/core/src/containers/keyed_vec.rs b/pumpkin-crates/core/src/containers/keyed_vec.rs index 654db58d8..3e2915e4e 100644 --- a/pumpkin-crates/core/src/containers/keyed_vec.rs +++ b/pumpkin-crates/core/src/containers/keyed_vec.rs @@ -50,6 +50,10 @@ impl KeyedVec { self.elements.len() } + pub fn is_empty(&self) -> bool { + self.elements.is_empty() + } + /// Add a new value to the vector. /// /// Returns the key for the inserted value. diff --git a/pumpkin-crates/core/src/engine/constraint_satisfaction_solver.rs b/pumpkin-crates/core/src/engine/constraint_satisfaction_solver.rs index e76655abe..6fcffa158 100644 --- a/pumpkin-crates/core/src/engine/constraint_satisfaction_solver.rs +++ b/pumpkin-crates/core/src/engine/constraint_satisfaction_solver.rs @@ -1205,7 +1205,6 @@ mod tests { use crate::predicate; use crate::predicates::Predicate; use crate::termination::Indefinite; - use crate::variables::TransformableVariable; fn is_same_core(core1: &[Predicate], core2: &[Predicate]) -> bool { core1.len() == core2.len() && core2.iter().all(|lit| core1.contains(lit)) diff --git a/pumpkin-crates/core/src/engine/cp/test_solver.rs b/pumpkin-crates/core/src/engine/cp/test_solver.rs index 28b897ba4..7c0063299 100644 --- a/pumpkin-crates/core/src/engine/cp/test_solver.rs +++ b/pumpkin-crates/core/src/engine/cp/test_solver.rs @@ -29,7 +29,6 @@ use crate::state::PropagatorHandle; /// A container for CP variables, which can be used to test propagators. #[derive(Debug)] -#[deprecated] pub struct TestSolver { pub state: State, constraint_tags: KeyGenerator, @@ -54,6 +53,7 @@ impl Default for TestSolver { } } +#[deprecated] impl TestSolver { pub fn new_variable(&mut self, lb: i32, ub: i32) -> DomainId { self.state.new_interval_variable(lb, ub, None) @@ -102,6 +102,7 @@ impl TestSolver { "The provided value to `increase_lower_bound` caused an empty domain, generally the propagator should not be notified of this change!" ); let mut propagator_queue = PropagatorQueue::new(4); + #[allow(deprecated, reason = "Will be refactored in the future")] self.state .notification_engine .notify_propagators_about_domain_events_test( @@ -130,6 +131,7 @@ impl TestSolver { "The provided value to `increase_lower_bound` caused an empty domain, generally the propagator should not be notified of this change!" ); let mut propagator_queue = PropagatorQueue::new(4); + #[allow(deprecated, reason = "Will be refactored in the future")] self.state .notification_engine .notify_propagators_about_domain_events_test( @@ -158,6 +160,7 @@ impl TestSolver { "The provided value to `increase_lower_bound` caused an empty domain, generally the propagator should not be notified of this change!" ); let mut propagator_queue = PropagatorQueue::new(4); + #[allow(deprecated, reason = "Will be refactored in the future")] self.state .notification_engine .notify_propagators_about_domain_events_test( @@ -246,6 +249,7 @@ impl TestSolver { } pub fn notify_propagator(&mut self, _propagator: PropagatorId) { + #[allow(deprecated, reason = "Will be refactored in the future")] self.state .notification_engine .notify_propagators_about_domain_events_test( @@ -257,6 +261,7 @@ impl TestSolver { } pub fn get_reason_int(&mut self, predicate: Predicate) -> PropositionalConjunction { + #[allow(deprecated, reason = "Will be refactored in the future")] let reason_ref = self .state .assignments diff --git a/pumpkin-crates/core/src/engine/notifications/mod.rs b/pumpkin-crates/core/src/engine/notifications/mod.rs index dd00a3660..1d65bc17a 100644 --- a/pumpkin-crates/core/src/engine/notifications/mod.rs +++ b/pumpkin-crates/core/src/engine/notifications/mod.rs @@ -386,14 +386,14 @@ impl NotificationEngine { let _ = self.events.drain(); } - #[deprecated] + #[cfg(test)] pub(crate) fn drain_backtrack_domain_events( &mut self, ) -> impl Iterator + '_ { self.backtrack_events.drain() } - #[deprecated] + #[cfg(test)] pub(crate) fn drain_domain_events( &mut self, ) -> impl Iterator + '_ { diff --git a/pumpkin-crates/core/src/lib.rs b/pumpkin-crates/core/src/lib.rs index 2e2046ada..36138d519 100644 --- a/pumpkin-crates/core/src/lib.rs +++ b/pumpkin-crates/core/src/lib.rs @@ -39,4 +39,5 @@ pub use crate::basic_types::ConstraintOperationError; pub use crate::basic_types::Duration; pub use crate::basic_types::Instant; pub use crate::basic_types::Random; +#[allow(deprecated, reason = "Will be refactored in the future")] pub use crate::engine::test_solver::TestSolver; diff --git a/pumpkin-crates/core/src/propagation/domains.rs b/pumpkin-crates/core/src/propagation/domains.rs index c9c4d3c66..1a86a9d6c 100644 --- a/pumpkin-crates/core/src/propagation/domains.rs +++ b/pumpkin-crates/core/src/propagation/domains.rs @@ -18,7 +18,7 @@ pub struct Domains<'a> { } impl<'a> Domains<'a> { - pub fn new(assignments: &'a Assignments, trailed_values: &'a mut TrailedValues) -> Self { + pub(crate) fn new(assignments: &'a Assignments, trailed_values: &'a mut TrailedValues) -> Self { Domains { assignments, trailed_values, diff --git a/pumpkin-crates/core/src/propagators/mod.rs b/pumpkin-crates/core/src/propagators/mod.rs index 6f8b77661..6f7842ca0 100644 --- a/pumpkin-crates/core/src/propagators/mod.rs +++ b/pumpkin-crates/core/src/propagators/mod.rs @@ -1,3 +1,2 @@ pub(crate) mod nogoods; pub(crate) mod reified_propagator; - diff --git a/pumpkin-crates/core/src/propagators/nogoods/nogood_propagator.rs b/pumpkin-crates/core/src/propagators/nogoods/nogood_propagator.rs index 7cfe1cfbb..0ff84ac4e 100644 --- a/pumpkin-crates/core/src/propagators/nogoods/nogood_propagator.rs +++ b/pumpkin-crates/core/src/propagators/nogoods/nogood_propagator.rs @@ -51,7 +51,7 @@ use crate::state::PropagatorHandle; /// The idea for propagation is the two-watcher scheme; this is achieved by internally keeping /// track of watch lists. #[derive(Clone, Debug)] -pub(crate) struct NogoodPropagator { +pub struct NogoodPropagator { /// The [`PredicateId`]s of the nogoods. nogood_predicates: ArenaAllocator, /// The information corresponding to each nogood; including activity, and LBD. @@ -1279,6 +1279,7 @@ impl NogoodPropagator { } } +#[allow(deprecated, reason = "Will be refactored")] #[cfg(test)] mod tests { use super::NogoodPropagator; diff --git a/pumpkin-crates/core/src/propagators/reified_propagator.rs b/pumpkin-crates/core/src/propagators/reified_propagator.rs index bc690d086..2cecbc1a8 100644 --- a/pumpkin-crates/core/src/propagators/reified_propagator.rs +++ b/pumpkin-crates/core/src/propagators/reified_propagator.rs @@ -17,7 +17,7 @@ use crate::pumpkin_assert_simple; use crate::state::Conflict; use crate::variables::Literal; -/// A [`PropagatorConstructor`] for the [`ReifiedPropagator`]. +/// A [`PropagatorConstructor`] for the reified propagator. #[derive(Clone, Debug)] pub struct ReifiedPropagatorArgs { pub propagator: WrappedArgs, @@ -221,6 +221,7 @@ impl ReifiedPropagator { } } +#[allow(deprecated, reason = "Will be refactored")] #[cfg(test)] mod tests { use super::*; diff --git a/pumpkin-crates/propagators/src/lib.rs b/pumpkin-crates/propagators/src/lib.rs index b3e9d2b83..ac925ee1c 100644 --- a/pumpkin-crates/propagators/src/lib.rs +++ b/pumpkin-crates/propagators/src/lib.rs @@ -1,2 +1 @@ pub mod propagators; - diff --git a/pumpkin-crates/propagators/src/propagators/arithmetic/absolute_value.rs b/pumpkin-crates/propagators/src/propagators/arithmetic/absolute_value.rs index 6dd6904d5..529bfedfc 100644 --- a/pumpkin-crates/propagators/src/propagators/arithmetic/absolute_value.rs +++ b/pumpkin-crates/propagators/src/propagators/arithmetic/absolute_value.rs @@ -146,6 +146,7 @@ where } } +#[allow(deprecated, reason = "Will be refactored")] #[cfg(test)] mod tests { use pumpkin_core::TestSolver; diff --git a/pumpkin-crates/propagators/src/propagators/arithmetic/binary/binary_equals.rs b/pumpkin-crates/propagators/src/propagators/arithmetic/binary/binary_equals.rs index 157edd334..ef063f261 100644 --- a/pumpkin-crates/propagators/src/propagators/arithmetic/binary/binary_equals.rs +++ b/pumpkin-crates/propagators/src/propagators/arithmetic/binary/binary_equals.rs @@ -383,6 +383,7 @@ struct BinaryEqualsPropagation { __: u16, } +#[allow(deprecated, reason = "Will be refactored")] #[cfg(test)] mod tests { use pumpkin_core::TestSolver; diff --git a/pumpkin-crates/propagators/src/propagators/arithmetic/binary/binary_not_equals.rs b/pumpkin-crates/propagators/src/propagators/arithmetic/binary/binary_not_equals.rs index ca89a8832..3e0c98693 100644 --- a/pumpkin-crates/propagators/src/propagators/arithmetic/binary/binary_not_equals.rs +++ b/pumpkin-crates/propagators/src/propagators/arithmetic/binary/binary_not_equals.rs @@ -168,6 +168,7 @@ where } } +#[allow(deprecated, reason = "Will be refactored")] #[cfg(test)] mod tests { use pumpkin_core::TestSolver; diff --git a/pumpkin-crates/propagators/src/propagators/arithmetic/integer_division.rs b/pumpkin-crates/propagators/src/propagators/arithmetic/integer_division.rs index f31ac2b07..5dd5365c0 100644 --- a/pumpkin-crates/propagators/src/propagators/arithmetic/integer_division.rs +++ b/pumpkin-crates/propagators/src/propagators/arithmetic/integer_division.rs @@ -377,11 +377,13 @@ fn propagate_signs i32 { numerator / denominator + (numerator % denominator).signum() } +#[allow(deprecated, reason = "Will be refactored")] #[cfg(test)] mod tests { use pumpkin_core::TestSolver; diff --git a/pumpkin-crates/propagators/src/propagators/arithmetic/linear_less_or_equal.rs b/pumpkin-crates/propagators/src/propagators/arithmetic/linear_less_or_equal.rs index e45d1ab36..d42f37866 100644 --- a/pumpkin-crates/propagators/src/propagators/arithmetic/linear_less_or_equal.rs +++ b/pumpkin-crates/propagators/src/propagators/arithmetic/linear_less_or_equal.rs @@ -271,6 +271,7 @@ where } } +#[allow(deprecated, reason = "Will be refactored")] #[cfg(test)] mod tests { use pumpkin_core::TestSolver; diff --git a/pumpkin-crates/propagators/src/propagators/arithmetic/linear_not_equal.rs b/pumpkin-crates/propagators/src/propagators/arithmetic/linear_not_equal.rs index 2fd2c75d9..522a97ae4 100644 --- a/pumpkin-crates/propagators/src/propagators/arithmetic/linear_not_equal.rs +++ b/pumpkin-crates/propagators/src/propagators/arithmetic/linear_not_equal.rs @@ -358,6 +358,7 @@ impl LinearNotEqualPropagator { } } +#[allow(deprecated, reason = "Will be refactored")] #[cfg(test)] mod tests { use pumpkin_core::TestSolver; diff --git a/pumpkin-crates/propagators/src/propagators/arithmetic/maximum.rs b/pumpkin-crates/propagators/src/propagators/arithmetic/maximum.rs index d0ff5110d..33d3ff38a 100644 --- a/pumpkin-crates/propagators/src/propagators/arithmetic/maximum.rs +++ b/pumpkin-crates/propagators/src/propagators/arithmetic/maximum.rs @@ -59,7 +59,7 @@ where } /// Bounds-consistent propagator which enforces `max(array) = rhs`. Can be constructed through -/// [`MaximumConstructor`]. +/// [`MaximumArgs`]. #[derive(Clone, Debug)] pub struct MaximumPropagator { array: Box<[ElementVar]>, @@ -170,11 +170,13 @@ impl Prop } } +#[allow(deprecated, reason = "Will be refactored")] #[cfg(test)] mod tests { - use super::*; use pumpkin_core::TestSolver; + use super::*; + #[test] fn upper_bound_of_rhs_matches_maximum_upper_bound_of_array_at_initialise() { let mut solver = TestSolver::default(); diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/options.rs b/pumpkin-crates/propagators/src/propagators/cumulative/options.rs index ac41e1825..b54a94e74 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/options.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/options.rs @@ -15,7 +15,7 @@ pub struct CumulativePropagatorOptions { pub incremental_backtracking: bool, } -/// The options provided to the [`constraints::cumulative`] constraints. +/// The options provided to the Cumulative constraint. #[derive(Debug, Copy, Clone, Default)] pub struct CumulativeOptions { /// The propagation method which is used for the cumulative constraints; currently all of them diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/time_table_over_interval_incremental.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/time_table_over_interval_incremental.rs index ce238ff43..931465d7f 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/time_table_over_interval_incremental.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/time_table_over_interval_incremental.rs @@ -625,6 +625,7 @@ fn find_overlapping_profile( }) } +#[allow(deprecated, reason = "Will be refactored")] #[cfg(test)] mod tests { use pumpkin_core::TestSolver; diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/per_point_incremental_propagator/synchronisation.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/per_point_incremental_propagator/synchronisation.rs index 6385d9f8b..a92520e20 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/per_point_incremental_propagator/synchronisation.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/per_point_incremental_propagator/synchronisation.rs @@ -161,14 +161,15 @@ fn sort_profile_based_on_id(profile: &mut Resour .sort_by(|a, b| a.id.unpack().cmp(&b.id.unpack())); } +#[allow(deprecated, reason = "Will be refactored")] #[cfg(test)] mod tests { use std::rc::Rc; + use pumpkin_core::TestSolver; use pumpkin_core::propagation::LocalId; use super::find_synchronised_conflict; - use pumpkin_core::TestSolver; use crate::propagators::CumulativeParameters; use crate::propagators::CumulativePropagatorOptions; use crate::propagators::PerPointTimeTableType; diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/per_point_incremental_propagator/time_table_per_point_incremental.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/per_point_incremental_propagator/time_table_per_point_incremental.rs index f0149cb8b..aec9a1e16 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/per_point_incremental_propagator/time_table_per_point_incremental.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/per_point_incremental_propagator/time_table_per_point_incremental.rs @@ -622,6 +622,7 @@ mod debug { } } +#[allow(deprecated, reason = "Will be refactored")] #[cfg(test)] mod tests { use pumpkin_core::TestSolver; diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/propagation_handler.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/propagation_handler.rs index 428abe28b..6ce36e045 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/propagation_handler.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/propagation_handler.rs @@ -482,10 +482,8 @@ pub(crate) mod test_propagation_handler { use pumpkin_core::predicates::Predicate; use pumpkin_core::predicates::PropositionalConjunction; use pumpkin_core::proof::InferenceCode; - use pumpkin_core::propagation::Domains; use pumpkin_core::propagation::LocalId; use pumpkin_core::state::CurrentNogood; - use pumpkin_core::state::PropagatorId; use pumpkin_core::state::State; use pumpkin_core::variables::DomainId; diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/time_table_over_interval.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/time_table_over_interval.rs index 7d45bb99d..64a42534f 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/time_table_over_interval.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/time_table_over_interval.rs @@ -470,6 +470,7 @@ pub(crate) fn propagate_from_scratch_time_table_interval( mod tests { use std::rc::Rc; - use pumpkin_core::propagation::Domains; use pumpkin_core::propagation::LocalId; use pumpkin_core::state::State; diff --git a/pumpkin-crates/propagators/src/propagators/disjunctive/disjunctive_propagator.rs b/pumpkin-crates/propagators/src/propagators/disjunctive/disjunctive_propagator.rs index 497575004..388f01159 100644 --- a/pumpkin-crates/propagators/src/propagators/disjunctive/disjunctive_propagator.rs +++ b/pumpkin-crates/propagators/src/propagators/disjunctive/disjunctive_propagator.rs @@ -400,9 +400,11 @@ fn create_propagation_explanation<'a, Var: IntegerVariable>( explanation.into() } +#[allow(deprecated, reason = "Will be refactored")] #[cfg(test)] mod tests { use pumpkin_core::TestSolver; + use crate::propagators::disjunctive_propagator::DisjunctiveConstructor; use crate::propagators::disjunctive_task::ArgDisjunctiveTask; diff --git a/pumpkin-crates/propagators/src/propagators/disjunctive/theta_lambda_tree.rs b/pumpkin-crates/propagators/src/propagators/disjunctive/theta_lambda_tree.rs index 0401b33b9..65d6bd652 100644 --- a/pumpkin-crates/propagators/src/propagators/disjunctive/theta_lambda_tree.rs +++ b/pumpkin-crates/propagators/src/propagators/disjunctive/theta_lambda_tree.rs @@ -374,10 +374,10 @@ impl ThetaLambdaTree { } } +#[allow(deprecated, reason = "Will be refactored")] #[cfg(test)] mod tests { use pumpkin_core::TestSolver; - use pumpkin_core::propagation::Domains; use pumpkin_core::propagation::LocalId; use crate::propagators::disjunctive::theta_lambda_tree::Node; diff --git a/pumpkin-crates/propagators/src/propagators/element.rs b/pumpkin-crates/propagators/src/propagators/element.rs index bd00e7b39..dbe4eadc0 100644 --- a/pumpkin-crates/propagators/src/propagators/element.rs +++ b/pumpkin-crates/propagators/src/propagators/element.rs @@ -293,6 +293,7 @@ struct RightHandSideReason { value: i32, } +#[allow(deprecated, reason = "Will be refactored")] #[cfg(test)] mod tests { use pumpkin_core::TestSolver; diff --git a/pumpkin-solver/examples/nqueens.rs b/pumpkin-solver/examples/nqueens.rs index 4247ff50b..c8c1c285d 100644 --- a/pumpkin-solver/examples/nqueens.rs +++ b/pumpkin-solver/examples/nqueens.rs @@ -2,7 +2,6 @@ use std::path::PathBuf; use clap::Parser; use pumpkin_solver::Solver; -use pumpkin_solver::constraints; use pumpkin_solver::options::SolverOptions; use pumpkin_solver::proof::ProofLog; use pumpkin_solver::results::ProblemSolution; diff --git a/pumpkin-solver/src/lib.rs b/pumpkin-solver/src/lib.rs index c88725131..7539be810 100644 --- a/pumpkin-solver/src/lib.rs +++ b/pumpkin-solver/src/lib.rs @@ -8,12 +8,13 @@ //! A unique feature of Pumpkin is that it can produce a _certificate of unsatisfiability_. See [our CP’24 paper](https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.CP.2024.11) for more details. //! //! The solver currently supports integer variables and a number of (global) constraints: -//! * [Cumulative global constraint][crate::constraints::cumulative]. -//! * [Element global constraint][crate::constraints::element]. +//! * [Cumulative global constraint][pumpkin_constraints::cumulative]. +//! * [Element global constraint][pumpkin_constraints::element]. //! * Arithmetic constraints: [linear integer -//! (in)equalities][crate::constraints::less_than_or_equals], [integer -//! division][crate::constraints::division], [integer multiplication][crate::constraints::times], -//! [maximum][crate::constraints::maximum], [absolute value][crate::constraints::absolute]. +//! (in)equalities][pumpkin_constraints::less_than_or_equals], [integer +//! division][pumpkin_constraints::division], [integer +//! multiplication][pumpkin_constraints::times], [maximum][pumpkin_constraints::maximum], +//! [absolute value][pumpkin_constraints::absolute]. //! * [Clausal constraints][Solver::add_clause]. //! //! We are actively developing Pumpkin and would be happy to hear from you should you have any diff --git a/pumpkin-solver/tests/iteration_test.rs b/pumpkin-solver/tests/iteration_test.rs index f351c721b..e4946175d 100644 --- a/pumpkin-solver/tests/iteration_test.rs +++ b/pumpkin-solver/tests/iteration_test.rs @@ -1,7 +1,6 @@ #![cfg(test)] // workaround for https://github.com/rust-lang/rust-clippy/issues/11024 use pumpkin_solver::Solver; -use pumpkin_solver::constraints; use pumpkin_solver::results::ProblemSolution; use pumpkin_solver::results::solution_iterator::IteratedSolution; use pumpkin_solver::termination::Indefinite; From 303ccff0cad2a296311f069697b69c6df3f4f0c9 Mon Sep 17 00:00:00 2001 From: Imko Marijnissen Date: Tue, 16 Dec 2025 14:15:17 +0100 Subject: [PATCH 4/6] docs: update docs --- .../src/constraints/arithmetic/equality.rs | 6 +-- .../src/constraints/arithmetic/inequality.rs | 2 +- .../src/constraints/arithmetic/mod.rs | 8 ++-- .../constraints/src/constraints/cumulative.rs | 14 +++--- .../src/constraints/disjunctive_strict.rs | 4 +- .../constraints/src/constraints/element.rs | 2 +- pumpkin-crates/constraints/src/lib.rs | 4 ++ .../core/src/engine/cp/test_solver.rs | 2 +- pumpkin-crates/core/src/lib.rs | 2 +- pumpkin-crates/core/src/propagation/mod.rs | 2 - pumpkin-crates/propagators/src/lib.rs | 7 ++- .../arithmetic/binary/binary_equals.rs | 2 +- .../arithmetic/binary/binary_not_equals.rs | 2 +- .../src/propagators/arithmetic/mod.rs | 1 + .../src/propagators/cumulative/mod.rs | 37 +++++++-------- .../src/propagators/cumulative/options.rs | 2 +- .../time_table/explanations/big_step.rs | 6 +-- .../cumulative/time_table/explanations/mod.rs | 4 +- .../time_table/explanations/naive.rs | 6 +-- .../time_table/explanations/pointwise.rs | 8 ++-- .../propagators/cumulative/time_table/mod.rs | 41 ++++++----------- .../checks.rs | 6 +-- .../debug.rs | 8 ++-- .../insertion.rs | 6 +-- .../removal.rs | 6 +-- .../synchronisation.rs | 12 ++--- .../time_table_over_interval_incremental.rs | 38 +++++++-------- .../synchronisation.rs | 20 ++++---- .../time_table_per_point_incremental.rs | 46 +++++++++---------- .../time_table/propagation_handler.rs | 8 ++-- .../time_table/time_table_over_interval.rs | 28 +++++------ .../time_table/time_table_per_point.rs | 24 +++++----- .../cumulative/time_table/time_table_util.rs | 14 +++--- .../cumulative/utils/structs/parameters.rs | 2 +- .../src/propagators/cumulative/utils/util.rs | 4 +- .../disjunctive/disjunctive_propagator.rs | 4 +- .../src/propagators/disjunctive/mod.rs | 4 ++ .../disjunctive/theta_lambda_tree.rs | 2 +- .../propagators/src/propagators/element.rs | 2 + .../propagators/src/propagators/mod.rs | 16 ++----- .../flatzinc/compiler/post_constraints.rs | 2 +- .../src/bin/pumpkin-solver/flatzinc/mod.rs | 2 +- pumpkin-solver/src/bin/pumpkin-solver/main.rs | 6 +-- pumpkin-solver/src/lib.rs | 8 ++-- 44 files changed, 208 insertions(+), 222 deletions(-) diff --git a/pumpkin-crates/constraints/src/constraints/arithmetic/equality.rs b/pumpkin-crates/constraints/src/constraints/arithmetic/equality.rs index 6b1230aac..9c7e49a09 100644 --- a/pumpkin-crates/constraints/src/constraints/arithmetic/equality.rs +++ b/pumpkin-crates/constraints/src/constraints/arithmetic/equality.rs @@ -7,9 +7,9 @@ use pumpkin_core::proof::ConstraintTag; use pumpkin_core::variables::IntegerVariable; use pumpkin_core::variables::Literal; use pumpkin_core::variables::TransformableVariable; -use pumpkin_propagators::propagators::BinaryEqualsPropagatorArgs; -use pumpkin_propagators::propagators::BinaryNotEqualsPropagatorArgs; -use pumpkin_propagators::propagators::LinearNotEqualPropagatorArgs; +use pumpkin_propagators::arithmetic::BinaryEqualsPropagatorArgs; +use pumpkin_propagators::arithmetic::BinaryNotEqualsPropagatorArgs; +use pumpkin_propagators::arithmetic::LinearNotEqualPropagatorArgs; use super::less_than_or_equals; diff --git a/pumpkin-crates/constraints/src/constraints/arithmetic/inequality.rs b/pumpkin-crates/constraints/src/constraints/arithmetic/inequality.rs index 68c46cd75..c7aa7e250 100644 --- a/pumpkin-crates/constraints/src/constraints/arithmetic/inequality.rs +++ b/pumpkin-crates/constraints/src/constraints/arithmetic/inequality.rs @@ -5,7 +5,7 @@ use pumpkin_core::constraints::NegatableConstraint; use pumpkin_core::proof::ConstraintTag; use pumpkin_core::variables::IntegerVariable; use pumpkin_core::variables::Literal; -use pumpkin_propagators::propagators::LinearLessOrEqualPropagatorArgs; +use pumpkin_propagators::arithmetic::LinearLessOrEqualPropagatorArgs; /// Create the [`NegatableConstraint`] `\sum terms_i <= rhs`. /// diff --git a/pumpkin-crates/constraints/src/constraints/arithmetic/mod.rs b/pumpkin-crates/constraints/src/constraints/arithmetic/mod.rs index 8674bdcf6..fe41b4721 100644 --- a/pumpkin-crates/constraints/src/constraints/arithmetic/mod.rs +++ b/pumpkin-crates/constraints/src/constraints/arithmetic/mod.rs @@ -6,10 +6,10 @@ pub use inequality::*; use pumpkin_core::constraints::Constraint; use pumpkin_core::proof::ConstraintTag; use pumpkin_core::variables::IntegerVariable; -use pumpkin_propagators::propagators::AbsoluteValueArgs; -use pumpkin_propagators::propagators::DivisionArgs; -use pumpkin_propagators::propagators::IntegerMultiplicationArgs; -use pumpkin_propagators::propagators::MaximumArgs; +use pumpkin_propagators::arithmetic::AbsoluteValueArgs; +use pumpkin_propagators::arithmetic::DivisionArgs; +use pumpkin_propagators::arithmetic::IntegerMultiplicationArgs; +use pumpkin_propagators::arithmetic::MaximumArgs; /// Creates the [`Constraint`] `a + b = c`. pub fn plus( diff --git a/pumpkin-crates/constraints/src/constraints/cumulative.rs b/pumpkin-crates/constraints/src/constraints/cumulative.rs index ff7de423b..b1022dbc6 100644 --- a/pumpkin-crates/constraints/src/constraints/cumulative.rs +++ b/pumpkin-crates/constraints/src/constraints/cumulative.rs @@ -7,13 +7,13 @@ use pumpkin_core::constraints::Constraint; use pumpkin_core::proof::ConstraintTag; use pumpkin_core::variables::IntegerVariable; use pumpkin_core::variables::Literal; -use pumpkin_propagators::propagators::ArgTask; -use pumpkin_propagators::propagators::CumulativeOptions; -use pumpkin_propagators::propagators::CumulativePropagationMethod; -use pumpkin_propagators::propagators::TimeTableOverIntervalIncrementalPropagator; -use pumpkin_propagators::propagators::TimeTableOverIntervalPropagator; -use pumpkin_propagators::propagators::TimeTablePerPointIncrementalPropagator; -use pumpkin_propagators::propagators::TimeTablePerPointPropagator; +use pumpkin_propagators::cumulative::ArgTask; +use pumpkin_propagators::cumulative::options::CumulativeOptions; +use pumpkin_propagators::cumulative::options::CumulativePropagationMethod; +use pumpkin_propagators::cumulative::time_table::TimeTableOverIntervalIncrementalPropagator; +use pumpkin_propagators::cumulative::time_table::TimeTableOverIntervalPropagator; +use pumpkin_propagators::cumulative::time_table::TimeTablePerPointIncrementalPropagator; +use pumpkin_propagators::cumulative::time_table::TimeTablePerPointPropagator; /// Creates the [Cumulative](https://sofdem.github.io/gccat/gccat/Ccumulative.html) [`Constraint`]. /// diff --git a/pumpkin-crates/constraints/src/constraints/disjunctive_strict.rs b/pumpkin-crates/constraints/src/constraints/disjunctive_strict.rs index 81f020a9c..c857d3456 100644 --- a/pumpkin-crates/constraints/src/constraints/disjunctive_strict.rs +++ b/pumpkin-crates/constraints/src/constraints/disjunctive_strict.rs @@ -5,8 +5,8 @@ use pumpkin_core::proof::ConstraintTag; use pumpkin_core::variables::IntegerVariable; use pumpkin_core::variables::Literal; use pumpkin_core::variables::TransformableVariable; -use pumpkin_propagators::propagators::ArgDisjunctiveTask; -use pumpkin_propagators::propagators::DisjunctiveConstructor; +use pumpkin_propagators::disjunctive::ArgDisjunctiveTask; +use pumpkin_propagators::disjunctive::DisjunctiveConstructor; /// Creates the [Disjunctive](https://sofdem.github.io/gccat/gccat/Cdisjunctive.html) [`Constraint`] (also called the `NoOverlap` Constraint or the `Unary Resource` Constraint). /// diff --git a/pumpkin-crates/constraints/src/constraints/element.rs b/pumpkin-crates/constraints/src/constraints/element.rs index 949a4851b..2b6c14fca 100644 --- a/pumpkin-crates/constraints/src/constraints/element.rs +++ b/pumpkin-crates/constraints/src/constraints/element.rs @@ -1,7 +1,7 @@ use pumpkin_core::constraints::Constraint; use pumpkin_core::proof::ConstraintTag; use pumpkin_core::variables::IntegerVariable; -use pumpkin_propagators::propagators::ElementArgs; +use pumpkin_propagators::element::ElementArgs; /// Creates the [element](https://sofdem.github.io/gccat/gccat/Celement.html) [`Constraint`] which states that `array[index] = rhs`. pub fn element( diff --git a/pumpkin-crates/constraints/src/lib.rs b/pumpkin-crates/constraints/src/lib.rs index 5d81d2051..a844b390a 100644 --- a/pumpkin-crates/constraints/src/lib.rs +++ b/pumpkin-crates/constraints/src/lib.rs @@ -1,2 +1,6 @@ +//! Contains certain constraints which can be used by the Pumpkin solver. +//! +//! A constraint enforces a relationship between variables. It is defined by one or more +//! propagators (see [`pumpkin_propagators`]). mod constraints; pub use constraints::*; diff --git a/pumpkin-crates/core/src/engine/cp/test_solver.rs b/pumpkin-crates/core/src/engine/cp/test_solver.rs index 7c0063299..8507c3c26 100644 --- a/pumpkin-crates/core/src/engine/cp/test_solver.rs +++ b/pumpkin-crates/core/src/engine/cp/test_solver.rs @@ -53,7 +53,7 @@ impl Default for TestSolver { } } -#[deprecated] +#[deprecated = "Will be replaced by the state API"] impl TestSolver { pub fn new_variable(&mut self, lb: i32, ub: i32) -> DomainId { self.state.new_interval_variable(lb, ub, None) diff --git a/pumpkin-crates/core/src/lib.rs b/pumpkin-crates/core/src/lib.rs index 36138d519..244d6755a 100644 --- a/pumpkin-crates/core/src/lib.rs +++ b/pumpkin-crates/core/src/lib.rs @@ -16,7 +16,7 @@ pub mod constraints; pub mod optimisation; pub mod proof; pub mod propagation; -pub mod propagators; +pub(crate) mod propagators; pub mod statistics; pub use convert_case; diff --git a/pumpkin-crates/core/src/propagation/mod.rs b/pumpkin-crates/core/src/propagation/mod.rs index 4df84097c..7c4b5b02b 100644 --- a/pumpkin-crates/core/src/propagation/mod.rs +++ b/pumpkin-crates/core/src/propagation/mod.rs @@ -38,8 +38,6 @@ //! definition) and it can be assumed that if a propagator is not at fix-point after propagating, //! that it will be called again by the solver until no further propagations happen. //! -//! See the [`propagators`] folder for concrete propagator implementations. -//! //! # How to implement a new propagator? //! //! We recommend the following workflow: diff --git a/pumpkin-crates/propagators/src/lib.rs b/pumpkin-crates/propagators/src/lib.rs index ac925ee1c..b78a60169 100644 --- a/pumpkin-crates/propagators/src/lib.rs +++ b/pumpkin-crates/propagators/src/lib.rs @@ -1 +1,6 @@ -pub mod propagators; +//! Contains the propagators used by Pumpkin. +//! +//! If you want to implement your own propagator then we recommend following the guide in +//! [`pumpkin_core::propagation`]. +mod propagators; +pub use propagators::*; diff --git a/pumpkin-crates/propagators/src/propagators/arithmetic/binary/binary_equals.rs b/pumpkin-crates/propagators/src/propagators/arithmetic/binary/binary_equals.rs index ef063f261..e3abb42b3 100644 --- a/pumpkin-crates/propagators/src/propagators/arithmetic/binary/binary_equals.rs +++ b/pumpkin-crates/propagators/src/propagators/arithmetic/binary/binary_equals.rs @@ -389,7 +389,7 @@ mod tests { use pumpkin_core::TestSolver; use pumpkin_core::propagation::EnqueueDecision; - use crate::propagators::binary::BinaryEqualsPropagatorArgs; + use crate::propagators::arithmetic::BinaryEqualsPropagatorArgs; #[test] fn test_propagation_of_bounds() { diff --git a/pumpkin-crates/propagators/src/propagators/arithmetic/binary/binary_not_equals.rs b/pumpkin-crates/propagators/src/propagators/arithmetic/binary/binary_not_equals.rs index 3e0c98693..c10b6820f 100644 --- a/pumpkin-crates/propagators/src/propagators/arithmetic/binary/binary_not_equals.rs +++ b/pumpkin-crates/propagators/src/propagators/arithmetic/binary/binary_not_equals.rs @@ -174,7 +174,7 @@ mod tests { use pumpkin_core::TestSolver; use pumpkin_core::propagation::EnqueueDecision; - use crate::propagators::binary::BinaryNotEqualsPropagatorArgs; + use crate::propagators::arithmetic::BinaryNotEqualsPropagatorArgs; #[test] fn detects_conflict() { diff --git a/pumpkin-crates/propagators/src/propagators/arithmetic/mod.rs b/pumpkin-crates/propagators/src/propagators/arithmetic/mod.rs index 675514622..21fc6eb9a 100644 --- a/pumpkin-crates/propagators/src/propagators/arithmetic/mod.rs +++ b/pumpkin-crates/propagators/src/propagators/arithmetic/mod.rs @@ -1,3 +1,4 @@ +//! Contains a number of propagators for a variety of arithmetic constraints. pub(crate) mod absolute_value; pub(crate) mod binary; pub(crate) mod integer_division; diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/mod.rs b/pumpkin-crates/propagators/src/propagators/cumulative/mod.rs index 41b8e1c21..19c9ff00e 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/mod.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/mod.rs @@ -1,15 +1,17 @@ //! Contains the propagators for the [Cumulative](https://sofdem.github.io/gccat/gccat/Ccumulative.html) -//! constraint, currently it contains solely time-tabling propagators (see -//! [`crate::propagators::cumulative::time_table`] for an explanation). +//! constraint. +//! +//! Currently it contains solely time-tabling propagators (see +//! [`crate::cumulative::time_table`] for an explanation). //! //! # Theoretical //! -//! The cumulative constraint reasons over a set of [`Task`]s over a single resource -//! with a capacity. Each [`Task`] consists of the following parameters: -//! - A variable `s_i` representing the start time of the [`Task`] -//! - The duration of the [`Task`] `p_i` (which is the same for all resources) which cannot be +//! The cumulative constraint reasons over a set of tasks over a single resource +//! with a capacity. Each task consists of the following parameters: +//! - A variable `s_i` representing the start time of the task +//! - The duration of the task `p_i` (which is the same for all resources) which cannot be //! interruped -//! - The constant resource usage `r_i` of the [`Task`] (which can differ for different resources) +//! - The constant resource usage `r_i` of the task (which can differ for different resources) //! //! Oftentimes the following notation is used to denote certain significant time points: //! - `EST_i` - The earliest starting time, equal to `lb(s_i)` @@ -17,10 +19,10 @@ //! - `LST_i` - The latest start time, equal to `ub(s_i)` //! - `LCT_i` - The latest completion time, equal to `ub(s_i) + p_i` //! -//! A [`Task`] is said to execute at time point *t* if it holds that `s_i <= t < s_i + p_i`. The +//! A task is said to execute at time point *t* if it holds that `s_i <= t < s_i + p_i`. The //! constraint then ensures that at no time point *t* in the horizon (the latest time at which -//! any [`Task`] can execute) there is an overflow of the resource capacity by the cumulative -//! resource usage of the [`Task`]s which are being processed at point *t*. +//! any task can execute) there is an overflow of the resource capacity by the cumulative +//! resource usage of the tasks which are being processed at point *t*. //! //! A common problem which makes use of the Cumulative constraint is the [RCPSP](https://www.projectmanagement.ugent.be/research/project_scheduling/rcpsp) //! problem. Which uses a combination of [Precedence](https://sofdem.github.io/gccat/gccat/Cprecedence.html) @@ -28,8 +30,8 @@ //! //! # Practical //! -//! The following example shows how one of the propagators for the Cumulative constraint -//! ([`TimeTablePerPointPropagator`]) can be used: +//! The following example shows how one of the propagators for the Cumulative constraint can be +//! used: //! //! ```rust //! // We construct three tasks for a resource with capacity 2: @@ -115,15 +117,8 @@ //! ); //! } //! ``` -mod time_table; -pub use time_table::CumulativeExplanationType; -mod options; -pub use options::*; -pub use time_table::TimeTableOverIntervalIncrementalPropagator; -pub use time_table::TimeTableOverIntervalPropagator; -pub use time_table::TimeTablePerPointIncrementalPropagator; -pub use time_table::TimeTablePerPointPropagator; -pub(crate) use time_table::*; +pub mod options; +pub mod time_table; pub use utils::ArgTask; mod utils; diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/options.rs b/pumpkin-crates/propagators/src/propagators/cumulative/options.rs index b54a94e74..41d432f15 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/options.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/options.rs @@ -1,4 +1,4 @@ -use super::CumulativeExplanationType; +use crate::cumulative::time_table::CumulativeExplanationType; #[derive(Debug, Default, Clone, Copy)] pub struct CumulativePropagatorOptions { diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/big_step.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/big_step.rs index f26306c42..d40af0da0 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/big_step.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/big_step.rs @@ -8,8 +8,8 @@ use pumpkin_core::propagation::Domains; use pumpkin_core::propagation::ReadDomains; use pumpkin_core::variables::IntegerVariable; -use crate::propagators::ResourceProfile; -use crate::propagators::Task; +use crate::cumulative::ResourceProfile; +use crate::cumulative::Task; /// Creates the propagation explanation using the big-step approach (see /// [`CumulativeExplanationType::BigStep`]) @@ -76,7 +76,7 @@ mod tests { use pumpkin_core::predicate; use pumpkin_core::predicates::PropositionalConjunction; - use crate::propagators::CumulativeExplanationType; + use crate::cumulative::time_table::CumulativeExplanationType; use crate::propagators::cumulative::time_table::propagation_handler::test_propagation_handler::TestPropagationHandler; #[test] diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/mod.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/mod.rs index c4f05a91f..c9b87f8bc 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/mod.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/mod.rs @@ -15,8 +15,8 @@ use pumpkin_core::predicates::PropositionalConjunction; use pumpkin_core::propagation::Domains; use pumpkin_core::variables::IntegerVariable; -use crate::propagators::ResourceProfile; -use crate::propagators::Task; +use crate::cumulative::ResourceProfile; +use crate::cumulative::Task; /// Determines what type of explanation is used for the cumulative constraint based on the /// explanations described in Section 4.5.1 and 4.5.2 of \[1\]. diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/naive.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/naive.rs index 981af67f4..60693f908 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/naive.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/naive.rs @@ -7,8 +7,8 @@ use pumpkin_core::propagation::Domains; use pumpkin_core::propagation::ReadDomains; use pumpkin_core::variables::IntegerVariable; -use crate::propagators::ResourceProfile; -use crate::propagators::Task; +use crate::cumulative::ResourceProfile; +use crate::cumulative::Task; /// Creates the propagation explanation using the naive approach (see /// [`CumulativeExplanationType::Naive`]) @@ -86,7 +86,7 @@ mod tests { use pumpkin_core::predicate; use pumpkin_core::predicates::PropositionalConjunction; - use crate::propagators::CumulativeExplanationType; + use crate::cumulative::time_table::CumulativeExplanationType; use crate::propagators::cumulative::time_table::propagation_handler::test_propagation_handler::TestPropagationHandler; #[test] diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/pointwise.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/pointwise.rs index e55f09edc..cdaec708b 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/pointwise.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/explanations/pointwise.rs @@ -11,9 +11,9 @@ use pumpkin_core::propagation::ReadDomains; use pumpkin_core::state::EmptyDomainConflict; use pumpkin_core::variables::IntegerVariable; -use crate::propagators::CumulativeExplanationType; -use crate::propagators::ResourceProfile; -use crate::propagators::Task; +use crate::cumulative::ResourceProfile; +use crate::cumulative::Task; +use crate::cumulative::time_table::CumulativeExplanationType; use crate::propagators::cumulative::time_table::explanations::add_propagating_task_predicate_lower_bound; use crate::propagators::cumulative::time_table::explanations::add_propagating_task_predicate_upper_bound; @@ -314,7 +314,7 @@ mod tests { use pumpkin_core::predicate; use pumpkin_core::predicates::PropositionalConjunction; - use crate::propagators::CumulativeExplanationType; + use crate::cumulative::time_table::CumulativeExplanationType; use crate::propagators::cumulative::time_table::propagation_handler::test_propagation_handler::TestPropagationHandler; #[test] diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/mod.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/mod.rs index f8c5618ab..30a4d2c77 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/mod.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/mod.rs @@ -3,31 +3,30 @@ //! //! # Theoretical //! -//! These time-table propagators reason about something called the **mandatory part** of a [`Task`]; -//! informally, the mandatory part of a [`Task`] is the time points in which a [`Task`] *has* to +//! These time-table propagators reason about something called the **mandatory part** of a task; +//! informally, the mandatory part of a task is the time points in which a task *has* to //! execute given its current bounds. Mathematically (see [`crate::propagators::cumulative`] for -//! notation details), the mandatory part of a [`Task`] *i* is the interval `[LST_i, ECT_i)` +//! notation details), the mandatory part of a task *i* is the interval `[LST_i, ECT_i)` //! (i.e. the time points between the latest start time of a task and its earliest completion time). //! //! The so-called **time-table** is a data-structure which are used to track the cumulative -//! mandatory parts at different time-points. Our time-tables consist of [`ResourceProfile`]s which -//! represent the cumulative resource usage ([`height`][ResourceProfile::height]) across an interval -//! (\[[`start`][ResourceProfile::start], [`end`][ResourceProfile::end]\]) of a set of [`Task`]s -//! ([`profile_tasks`][ResourceProfile::profile_tasks]). +//! mandatory parts at different time-points. Our time-tables consist of resource profiles which +//! represent the cumulative resource usage across an interval +//! (\[start, end\]) of a set of tasks. //! -//! Propagation oftentimes uses these time-tables to either update the bounds of the [`Task`]s or to -//! remove values from the domain. If a time-table has been built then for any [`Task`] which -//! overflows the resource capacity if it overlaps with a [`ResourceProfile`] (and is not part of -//! it) all start times which cause this task to overlap with any part of the [`ResourceProfile`] +//! Propagation oftentimes uses these time-tables to either update the bounds of the tasks or to +//! remove values from the domain. If a time-table has been built then for any task which +//! overflows the resource capacity if it overlaps with a resource profile (and is not part of +//! it) all start times which cause this task to overlap with any part of the resource profile //! can be removed from the domain. //! //! The simplest example of this is if we have a resource with capacity 1 and we have the following -//! two [`Task`]s: +//! two tasks: //! - Task 1: Start times: [0, 5], Processing time: 4, Resource usage: 1 //! - Task 2: Start times: [3, 3], Processing time: 2, Resource usage: 1 //! -//! In this case the time-table would consist of a single [`ResourceProfile`] with -//! [`start`][ResourceProfile::start] 3 and [`end`][ResourceProfile::end] 4 signifying that Task 2 +//! In this case the time-table would consist of a single resource profile with +//! `start` 3 and `end` 4 signifying that Task 2 //! executes in the interval `[3, 4]` for 2 units of time. It can be seen that if Task 1 is //! scheduled at the earliest possible starting time of 0 that there would be an overflow of the //! resource, we could thus propagate the lower-bound on the start time of Task 1 to be 5. @@ -40,18 +39,6 @@ //! [Sections 4.2.1, 4.5.2 and 4.6.1-4.6.3 of \[1\]](http://cp2013.a4cp.org/sites/default/files/andreas_schutt_-_improving_scheduling_by_learning.pdf) //! for more information about time-table reasoning //! -//! # Practical -//! -//! Certain common functions are stored in -//! [`crate::propagators::cumulative::time_table::time_table_util`] such as -//! [`should_enqueue`] which determines whether a time-table propagator has seen sufficient changes -//! to warrant being scheduled once more or [`propagate_based_on_timetable`] which goes over all -//! profiles and tasks and determines whether a propagation can take place and performs it if this -//! is the case. It should be noted that these methods assume that the provided [`ResourceProfile`]s -//! are maximal (i.e. there is no [`ResourceProfile`] adjacent to it with the same -//! [`ResourceProfile::profile_tasks`]) and that they are sorted in increasing order of start time; -//! not adhering to these guidelines could result in missed propagations. -//! //! # Bibliography //! //! \[1\] A. Schutt, Improving scheduling by learning. University of Melbourne, Department of @@ -84,7 +71,7 @@ pub use time_table_over_interval::*; pub use time_table_per_point::*; #[cfg(doc)] -use crate::propagators::Task; +use crate::cumulative::Task; #[cfg(doc)] use crate::propagators::cumulative::time_table::time_table_util::*; diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/checks.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/checks.rs index 9eacfa978..421c252fe 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/checks.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/checks.rs @@ -7,9 +7,9 @@ use std::rc::Rc; use pumpkin_core::variables::IntegerVariable; -use crate::propagators::OverIntervalTimeTableType; -use crate::propagators::ResourceProfile; -use crate::propagators::Task; +use crate::cumulative::ResourceProfile; +use crate::cumulative::Task; +use crate::cumulative::time_table::OverIntervalTimeTableType; /// Determines whether the added mandatory part causes a new profile before the first overapping /// profile. diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/debug.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/debug.rs index 88a8f6b58..84f9ed367 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/debug.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/debug.rs @@ -8,10 +8,10 @@ use pumpkin_core::proof::InferenceCode; use pumpkin_core::propagation::Domains; use pumpkin_core::variables::IntegerVariable; -use crate::propagators::CumulativeParameters; -use crate::propagators::OverIntervalTimeTableType; -use crate::propagators::ResourceProfile; -use crate::propagators::create_time_table_over_interval_from_scratch; +use crate::cumulative::CumulativeParameters; +use crate::cumulative::ResourceProfile; +use crate::cumulative::time_table::OverIntervalTimeTableType; +use crate::cumulative::time_table::create_time_table_over_interval_from_scratch; /// Determines whether the provided `time_table` is the same as the one creatd from scratch /// using the following checks: diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/insertion.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/insertion.rs index 8cfbacd3e..e96c59f36 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/insertion.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/insertion.rs @@ -7,9 +7,9 @@ use pumpkin_core::asserts::pumpkin_assert_extreme; use pumpkin_core::asserts::pumpkin_assert_moderate; use pumpkin_core::variables::IntegerVariable; -use crate::propagators::OverIntervalTimeTableType; -use crate::propagators::ResourceProfile; -use crate::propagators::Task; +use crate::cumulative::ResourceProfile; +use crate::cumulative::Task; +use crate::cumulative::time_table::OverIntervalTimeTableType; use crate::propagators::cumulative::time_table::over_interval_incremental_propagator::checks; /// The new mandatory part added by `updated_task` (spanning `update_range`) overlaps with the diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/removal.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/removal.rs index 7098ece26..623d9f677 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/removal.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/removal.rs @@ -7,9 +7,9 @@ use std::rc::Rc; use pumpkin_core::variables::IntegerVariable; -use crate::propagators::OverIntervalTimeTableType; -use crate::propagators::ResourceProfile; -use crate::propagators::Task; +use crate::cumulative::ResourceProfile; +use crate::cumulative::Task; +use crate::cumulative::time_table::OverIntervalTimeTableType; /// The reduced mandatory part of `updated_task` (spanning `update_range`) overlaps with the /// profiles in `[start_index, end_index]`. This function calculates the added, and updated diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/synchronisation.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/synchronisation.rs index dfcb3cd1c..3b53051b3 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/synchronisation.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/synchronisation.rs @@ -9,13 +9,11 @@ use pumpkin_core::variables::IntegerVariable; use super::debug::are_mergeable; use super::debug::merge_profiles; -use crate::propagators::CumulativeParameters; -use crate::propagators::OverIntervalTimeTableType; -use crate::propagators::ResourceProfile; -#[cfg(doc)] -use crate::propagators::TimeTableOverIntervalPropagator; -use crate::propagators::create_time_table_over_interval_from_scratch; -use crate::propagators::cumulative::time_table::propagation_handler::create_conflict_explanation; +use crate::cumulative::CumulativeParameters; +use crate::cumulative::ResourceProfile; +use crate::cumulative::time_table::OverIntervalTimeTableType; +use crate::cumulative::time_table::create_time_table_over_interval_from_scratch; +use crate::cumulative::time_table::propagation_handler::create_conflict_explanation; /// Finds the conflicting profile which would have been found by the /// [`TimeTableOverIntervalPropagator`]; this is the first conflicting profile in terms of start diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/time_table_over_interval_incremental.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/time_table_over_interval_incremental.rs index 931465d7f..a426e0a16 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/time_table_over_interval_incremental.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/over_interval_incremental_propagator/time_table_over_interval_incremental.rs @@ -26,7 +26,16 @@ use pumpkin_core::variables::IntegerVariable; use super::insertion; use super::removal; -use crate::propagators::create_time_table_over_interval_from_scratch; +use crate::cumulative::options::CumulativePropagatorOptions; +use crate::cumulative::time_table::create_time_table_over_interval_from_scratch; +use crate::cumulative::time_table::propagate_from_scratch_time_table_interval; +use crate::cumulative::util::check_bounds_equal_at_propagation; +use crate::cumulative::util::create_tasks; +use crate::cumulative::util::register_tasks; +use crate::cumulative::util::update_bounds_task; +use crate::cumulative::ArgTask; +use crate::cumulative::MandatoryPartAdjustments; +use crate::cumulative::UpdatableStructures; use crate::propagators::cumulative::time_table::over_interval_incremental_propagator::debug; use crate::propagators::cumulative::time_table::over_interval_incremental_propagator::synchronisation::check_synchronisation_conflict_explanation_over_interval; use crate::propagators::cumulative::time_table::over_interval_incremental_propagator::synchronisation::create_synchronised_conflict_explanation; @@ -39,22 +48,13 @@ use crate::propagators::cumulative::time_table::time_table_util::insert_update; use crate::propagators::cumulative::time_table::time_table_util::propagate_based_on_timetable; use crate::propagators::cumulative::time_table::time_table_util::should_enqueue; use crate::propagators::cumulative::time_table::TimeTable; -use crate::propagators::propagate_from_scratch_time_table_interval; -use crate::propagators::util::check_bounds_equal_at_propagation; -use crate::propagators::util::create_tasks; -use crate::propagators::util::register_tasks; -use crate::propagators::util::update_bounds_task; -use crate::propagators::ArgTask; -use crate::propagators::CumulativeParameters; -use crate::propagators::CumulativePropagatorOptions; -use crate::propagators::MandatoryPartAdjustments; -use crate::propagators::OverIntervalTimeTableType; -use crate::propagators::Task; +use crate::cumulative::CumulativeParameters; +use crate::cumulative::time_table::OverIntervalTimeTableType; +use crate::cumulative::Task; #[cfg(doc)] -use crate::propagators::TimeTableOverIntervalPropagator; +use crate::cumulative::time_table::TimeTableOverIntervalPropagator; #[cfg(doc)] -use crate::propagators::TimeTablePerPointPropagator; -use crate::propagators::UpdatableStructures; +use crate::cumulative::time_table::TimeTablePerPointPropagator; /// [`Propagator`] responsible for using time-table reasoning to propagate the [Cumulative](https://sofdem.github.io/gccat/gccat/Ccumulative.html) constraint /// where a time-table is a structure which stores the mandatory resource usage of the tasks at @@ -636,10 +636,10 @@ mod tests { use pumpkin_core::state::Conflict; use pumpkin_core::variables::DomainId; - use crate::propagators::ArgTask; - use crate::propagators::CumulativeExplanationType; - use crate::propagators::CumulativePropagatorOptions; - use crate::propagators::TimeTableOverIntervalIncrementalPropagator; + use crate::cumulative::ArgTask; + use crate::cumulative::options::CumulativePropagatorOptions; + use crate::cumulative::time_table::CumulativeExplanationType; + use crate::cumulative::time_table::TimeTableOverIntervalIncrementalPropagator; #[test] fn propagator_propagates_from_profile() { diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/per_point_incremental_propagator/synchronisation.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/per_point_incremental_propagator/synchronisation.rs index a92520e20..320abd00b 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/per_point_incremental_propagator/synchronisation.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/per_point_incremental_propagator/synchronisation.rs @@ -7,11 +7,11 @@ use pumpkin_core::results::PropagationStatusCP; use pumpkin_core::state::Conflict; use pumpkin_core::variables::IntegerVariable; -use crate::propagators::CumulativeParameters; -use crate::propagators::PerPointTimeTableType; -use crate::propagators::ResourceProfile; -use crate::propagators::Task; -use crate::propagators::create_time_table_per_point_from_scratch; +use crate::cumulative::CumulativeParameters; +use crate::cumulative::ResourceProfile; +use crate::cumulative::Task; +use crate::cumulative::time_table::PerPointTimeTableType; +use crate::cumulative::time_table::create_time_table_per_point_from_scratch; use crate::propagators::cumulative::time_table::propagation_handler::create_conflict_explanation; /// Returns whether the synchronised conflict explanation created by @@ -170,11 +170,11 @@ mod tests { use pumpkin_core::propagation::LocalId; use super::find_synchronised_conflict; - use crate::propagators::CumulativeParameters; - use crate::propagators::CumulativePropagatorOptions; - use crate::propagators::PerPointTimeTableType; - use crate::propagators::ResourceProfile; - use crate::propagators::Task; + use crate::cumulative::CumulativeParameters; + use crate::cumulative::ResourceProfile; + use crate::cumulative::Task; + use crate::cumulative::options::CumulativePropagatorOptions; + use crate::cumulative::time_table::PerPointTimeTableType; #[test] fn test_correct_conflict_returned() { diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/per_point_incremental_propagator/time_table_per_point_incremental.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/per_point_incremental_propagator/time_table_per_point_incremental.rs index aec9a1e16..ae860f402 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/per_point_incremental_propagator/time_table_per_point_incremental.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/per_point_incremental_propagator/time_table_per_point_incremental.rs @@ -24,17 +24,22 @@ use pumpkin_core::state::Conflict; use pumpkin_core::state::PropagatorConflict; use pumpkin_core::variables::IntegerVariable; -use crate::propagators::ArgTask; -use crate::propagators::CumulativeParameters; -use crate::propagators::CumulativePropagatorOptions; -use crate::propagators::MandatoryPartAdjustments; -use crate::propagators::PerPointTimeTableType; -use crate::propagators::ResourceProfile; -use crate::propagators::Task; +use crate::cumulative::ArgTask; +use crate::cumulative::CumulativeParameters; +use crate::cumulative::MandatoryPartAdjustments; +use crate::cumulative::ResourceProfile; +use crate::cumulative::Task; +use crate::cumulative::UpdatableStructures; +use crate::cumulative::options::CumulativePropagatorOptions; +use crate::cumulative::time_table::PerPointTimeTableType; #[cfg(doc)] -use crate::propagators::TimeTablePerPointPropagator; -use crate::propagators::UpdatableStructures; -use crate::propagators::create_time_table_per_point_from_scratch; +use crate::cumulative::time_table::TimeTablePerPointPropagator; +use crate::cumulative::time_table::create_time_table_per_point_from_scratch; +use crate::cumulative::time_table::propagate_from_scratch_time_table_point; +use crate::cumulative::util::check_bounds_equal_at_propagation; +use crate::cumulative::util::create_tasks; +use crate::cumulative::util::register_tasks; +use crate::cumulative::util::update_bounds_task; use crate::propagators::cumulative::time_table::TimeTable; use crate::propagators::cumulative::time_table::per_point_incremental_propagator::synchronisation::check_synchronisation_conflict_explanation_per_point; use crate::propagators::cumulative::time_table::per_point_incremental_propagator::synchronisation::create_synchronised_conflict_explanation; @@ -45,11 +50,6 @@ use crate::propagators::cumulative::time_table::time_table_util::backtrack_updat use crate::propagators::cumulative::time_table::time_table_util::insert_update; use crate::propagators::cumulative::time_table::time_table_util::propagate_based_on_timetable; use crate::propagators::cumulative::time_table::time_table_util::should_enqueue; -use crate::propagators::propagate_from_scratch_time_table_point; -use crate::propagators::util::check_bounds_equal_at_propagation; -use crate::propagators::util::create_tasks; -use crate::propagators::util::register_tasks; -use crate::propagators::util::update_bounds_task; /// [`Propagator`] responsible for using time-table reasoning to propagate the [Cumulative](https://sofdem.github.io/gccat/gccat/Ccumulative.html) constraint /// where a time-table is a structure which stores the mandatory resource usage of the tasks at @@ -559,9 +559,9 @@ mod debug { use pumpkin_core::propagation::Domains; use pumpkin_core::variables::IntegerVariable; - use crate::propagators::CumulativeParameters; - use crate::propagators::PerPointTimeTableType; - use crate::propagators::create_time_table_per_point_from_scratch; + use crate::cumulative::CumulativeParameters; + use crate::cumulative::time_table::PerPointTimeTableType; + use crate::cumulative::time_table::create_time_table_per_point_from_scratch; /// Determines whether the provided `time_table` is the same as the one creatd from scratch /// using the following checks: @@ -633,11 +633,11 @@ mod tests { use pumpkin_core::state::Conflict; use pumpkin_core::variables::DomainId; - use crate::propagators::ArgTask; - use crate::propagators::CumulativeExplanationType; - use crate::propagators::CumulativePropagatorOptions; - use crate::propagators::TimeTablePerPointIncrementalPropagator; - use crate::propagators::TimeTablePerPointPropagator; + use crate::cumulative::ArgTask; + use crate::cumulative::options::CumulativePropagatorOptions; + use crate::cumulative::time_table::CumulativeExplanationType; + use crate::cumulative::time_table::TimeTablePerPointIncrementalPropagator; + use crate::cumulative::time_table::TimeTablePerPointPropagator; #[test] fn propagator_propagates_from_profile() { diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/propagation_handler.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/propagation_handler.rs index 6ce36e045..d1da49e9e 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/propagation_handler.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/propagation_handler.rs @@ -28,8 +28,8 @@ use super::explanations::naive::create_naive_conflict_explanation; use super::explanations::naive::create_naive_propagation_explanation; use super::explanations::pointwise::create_pointwise_conflict_explanation; use super::explanations::pointwise::create_pointwise_propagation_explanation; -use crate::propagators::ResourceProfile; -use crate::propagators::Task; +use crate::cumulative::ResourceProfile; +use crate::cumulative::Task; use crate::propagators::cumulative::time_table::explanations::pointwise; /// Structure for handling the creation of propagations and their explanations. @@ -490,8 +490,8 @@ pub(crate) mod test_propagation_handler { use super::CumulativeExplanationType; use super::CumulativePropagationHandler; use super::create_conflict_explanation; - use crate::propagators::ResourceProfile; - use crate::propagators::Task; + use crate::cumulative::ResourceProfile; + use crate::cumulative::Task; pub(crate) struct TestPropagationHandler { propagation_handler: CumulativePropagationHandler, diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/time_table_over_interval.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/time_table_over_interval.rs index 64a42534f..fdbdb14cc 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/time_table_over_interval.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/time_table_over_interval.rs @@ -26,18 +26,18 @@ use pumpkin_core::variables::IntegerVariable; use super::TimeTable; use super::time_table_util::propagate_based_on_timetable; use super::time_table_util::should_enqueue; -use crate::propagators::ArgTask; -use crate::propagators::CumulativeParameters; -use crate::propagators::CumulativePropagatorOptions; -use crate::propagators::ResourceProfile; -use crate::propagators::Task; +use crate::cumulative::ArgTask; +use crate::cumulative::CumulativeParameters; +use crate::cumulative::ResourceProfile; +use crate::cumulative::Task; +use crate::cumulative::UpdatableStructures; +use crate::cumulative::options::CumulativePropagatorOptions; #[cfg(doc)] -use crate::propagators::TimeTablePerPointPropagator; -use crate::propagators::UpdatableStructures; +use crate::cumulative::time_table::TimeTablePerPointPropagator; +use crate::cumulative::util::create_tasks; +use crate::cumulative::util::register_tasks; +use crate::cumulative::util::update_bounds_task; use crate::propagators::cumulative::time_table::propagation_handler::create_conflict_explanation; -use crate::propagators::util::create_tasks; -use crate::propagators::util::register_tasks; -use crate::propagators::util::update_bounds_task; /// An event storing the start and end of mandatory parts used for creating the time-table #[derive(Debug)] @@ -480,10 +480,10 @@ mod tests { use pumpkin_core::propagation::EnqueueDecision; use pumpkin_core::state::Conflict; - use crate::propagators::ArgTask; - use crate::propagators::CumulativeExplanationType; - use crate::propagators::CumulativePropagatorOptions; - use crate::propagators::TimeTableOverIntervalPropagator; + use crate::cumulative::ArgTask; + use crate::cumulative::options::CumulativePropagatorOptions; + use crate::cumulative::time_table::CumulativeExplanationType; + use crate::cumulative::time_table::TimeTableOverIntervalPropagator; #[test] fn propagator_propagates_from_profile() { diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/time_table_per_point.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/time_table_per_point.rs index 43997a727..30890b922 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/time_table_per_point.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/time_table_per_point.rs @@ -29,15 +29,15 @@ use pumpkin_core::variables::IntegerVariable; use super::TimeTable; use super::time_table_util::propagate_based_on_timetable; use super::time_table_util::should_enqueue; -use crate::propagators::ArgTask; -use crate::propagators::CumulativeParameters; -use crate::propagators::CumulativePropagatorOptions; -use crate::propagators::ResourceProfile; -use crate::propagators::UpdatableStructures; +use crate::cumulative::ArgTask; +use crate::cumulative::CumulativeParameters; +use crate::cumulative::ResourceProfile; +use crate::cumulative::UpdatableStructures; +use crate::cumulative::options::CumulativePropagatorOptions; +use crate::cumulative::util::create_tasks; +use crate::cumulative::util::register_tasks; +use crate::cumulative::util::update_bounds_task; use crate::propagators::cumulative::time_table::propagation_handler::create_conflict_explanation; -use crate::propagators::util::create_tasks; -use crate::propagators::util::register_tasks; -use crate::propagators::util::update_bounds_task; /// [`Propagator`] responsible for using time-table reasoning to propagate the [Cumulative](https://sofdem.github.io/gccat/gccat/Ccumulative.html) constraint /// where a time-table is a structure which stores the mandatory resource usage of the tasks at @@ -284,10 +284,10 @@ mod tests { use pumpkin_core::propagation::EnqueueDecision; use pumpkin_core::state::Conflict; - use crate::propagators::ArgTask; - use crate::propagators::CumulativeExplanationType; - use crate::propagators::CumulativePropagatorOptions; - use crate::propagators::TimeTablePerPointPropagator; + use crate::cumulative::ArgTask; + use crate::cumulative::options::CumulativePropagatorOptions; + use crate::cumulative::time_table::CumulativeExplanationType; + use crate::cumulative::time_table::TimeTablePerPointPropagator; #[test] fn propagator_propagates_from_profile() { diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/time_table_util.rs b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/time_table_util.rs index 51a83ac1c..3f387fc9b 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/time_table/time_table_util.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/time_table/time_table_util.rs @@ -14,11 +14,11 @@ use pumpkin_core::propagation::ReadDomains; use pumpkin_core::results::PropagationStatusCP; use pumpkin_core::variables::IntegerVariable; -use crate::propagators::CumulativeParameters; -use crate::propagators::ResourceProfile; -use crate::propagators::Task; -use crate::propagators::UpdatableStructures; -use crate::propagators::UpdatedTaskInfo; +use crate::cumulative::CumulativeParameters; +use crate::cumulative::ResourceProfile; +use crate::cumulative::Task; +use crate::cumulative::UpdatableStructures; +use crate::cumulative::UpdatedTaskInfo; use crate::propagators::cumulative::time_table::propagation_handler::CumulativePropagationHandler; /// The result of [`should_enqueue`], contains the [`EnqueueDecision`] whether the propagator should @@ -783,8 +783,8 @@ mod tests { use pumpkin_core::state::State; use super::find_profiles_which_propagate_lower_bound; - use crate::propagators::ResourceProfile; - use crate::propagators::Task; + use crate::cumulative::ResourceProfile; + use crate::cumulative::Task; use crate::propagators::cumulative::time_table::time_table_util::find_profiles_which_propagate_upper_bound; #[test] diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/utils/structs/parameters.rs b/pumpkin-crates/propagators/src/propagators/cumulative/utils/structs/parameters.rs index 7fc1d6387..e4ad7df7d 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/utils/structs/parameters.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/utils/structs/parameters.rs @@ -3,7 +3,7 @@ use std::rc::Rc; use pumpkin_core::variables::IntegerVariable; use super::Task; -use crate::propagators::CumulativePropagatorOptions; +use crate::cumulative::options::CumulativePropagatorOptions; /// Holds the data for the cumulative constraint; more specifically it holds: /// - The tasks diff --git a/pumpkin-crates/propagators/src/propagators/cumulative/utils/util.rs b/pumpkin-crates/propagators/src/propagators/cumulative/utils/util.rs index 7e9bb18f2..03d18b744 100644 --- a/pumpkin-crates/propagators/src/propagators/cumulative/utils/util.rs +++ b/pumpkin-crates/propagators/src/propagators/cumulative/utils/util.rs @@ -12,8 +12,8 @@ use pumpkin_core::propagation::PropagatorConstructorContext; use pumpkin_core::propagation::ReadDomains; use pumpkin_core::variables::IntegerVariable; -use crate::propagators::ArgTask; -use crate::propagators::Task; +use crate::cumulative::ArgTask; +use crate::cumulative::Task; /// Based on the [`ArgTask`]s which are passed, it creates and returns [`Task`]s which have been /// registered for [`DomainEvents`]. diff --git a/pumpkin-crates/propagators/src/propagators/disjunctive/disjunctive_propagator.rs b/pumpkin-crates/propagators/src/propagators/disjunctive/disjunctive_propagator.rs index 388f01159..27519eaa1 100644 --- a/pumpkin-crates/propagators/src/propagators/disjunctive/disjunctive_propagator.rs +++ b/pumpkin-crates/propagators/src/propagators/disjunctive/disjunctive_propagator.rs @@ -405,8 +405,8 @@ fn create_propagation_explanation<'a, Var: IntegerVariable>( mod tests { use pumpkin_core::TestSolver; - use crate::propagators::disjunctive_propagator::DisjunctiveConstructor; - use crate::propagators::disjunctive_task::ArgDisjunctiveTask; + use crate::disjunctive::ArgDisjunctiveTask; + use crate::disjunctive::DisjunctiveConstructor; #[test] fn propagator_propagates_lower_bound() { diff --git a/pumpkin-crates/propagators/src/propagators/disjunctive/mod.rs b/pumpkin-crates/propagators/src/propagators/disjunctive/mod.rs index 37937002a..2b2de5801 100644 --- a/pumpkin-crates/propagators/src/propagators/disjunctive/mod.rs +++ b/pumpkin-crates/propagators/src/propagators/disjunctive/mod.rs @@ -1,3 +1,6 @@ +//! Contains the propagator for the [Disjunctive](https://sofdem.github.io/gccat/gccat/Cdisjunctive.html) constraint. +//! +//! Currently, it contains only an edge-finding propagator. use pumpkin_core::declare_inference_label; pub(crate) mod disjunctive_propagator; @@ -6,5 +9,6 @@ mod theta_lambda_tree; mod theta_tree; pub use disjunctive_propagator::DisjunctiveConstructor; pub use disjunctive_propagator::DisjunctivePropagator; +pub use disjunctive_task::ArgDisjunctiveTask; declare_inference_label!(DisjunctiveEdgeFinding); diff --git a/pumpkin-crates/propagators/src/propagators/disjunctive/theta_lambda_tree.rs b/pumpkin-crates/propagators/src/propagators/disjunctive/theta_lambda_tree.rs index 65d6bd652..b631e7688 100644 --- a/pumpkin-crates/propagators/src/propagators/disjunctive/theta_lambda_tree.rs +++ b/pumpkin-crates/propagators/src/propagators/disjunctive/theta_lambda_tree.rs @@ -380,9 +380,9 @@ mod tests { use pumpkin_core::TestSolver; use pumpkin_core::propagation::LocalId; + use crate::disjunctive::theta_lambda_tree::DisjunctiveTask; use crate::propagators::disjunctive::theta_lambda_tree::Node; use crate::propagators::disjunctive::theta_lambda_tree::ThetaLambdaTree; - use crate::propagators::disjunctive_task::DisjunctiveTask; #[test] fn tree_built_correctly() { diff --git a/pumpkin-crates/propagators/src/propagators/element.rs b/pumpkin-crates/propagators/src/propagators/element.rs index dbe4eadc0..1f5e84838 100644 --- a/pumpkin-crates/propagators/src/propagators/element.rs +++ b/pumpkin-crates/propagators/src/propagators/element.rs @@ -1,3 +1,5 @@ +//! Contains the propagator for the [Element](https://sofdem.github.io/gccat/gccat/Celement.html) +//! constraint. #![allow(clippy::double_parens, reason = "originates inside the bitfield macro")] use bitfield_struct::bitfield; diff --git a/pumpkin-crates/propagators/src/propagators/mod.rs b/pumpkin-crates/propagators/src/propagators/mod.rs index 27f107071..f29a87a30 100644 --- a/pumpkin-crates/propagators/src/propagators/mod.rs +++ b/pumpkin-crates/propagators/src/propagators/mod.rs @@ -4,15 +4,7 @@ #[cfg(doc)] use pumpkin_core::propagation; -pub(crate) mod arithmetic; -mod cumulative; -mod disjunctive; -pub(crate) mod element; -pub use arithmetic::*; -pub use cumulative::CumulativeExplanationType; -pub use cumulative::CumulativeOptions; -pub use cumulative::CumulativePropagationMethod; -pub use cumulative::*; -pub use disjunctive::disjunctive_task::ArgDisjunctiveTask; -pub use disjunctive::*; -pub use element::*; +pub mod arithmetic; +pub mod cumulative; +pub mod disjunctive; +pub mod element; diff --git a/pumpkin-solver/src/bin/pumpkin-solver/flatzinc/compiler/post_constraints.rs b/pumpkin-solver/src/bin/pumpkin-solver/flatzinc/compiler/post_constraints.rs index 414eba8f3..35c1f6524 100644 --- a/pumpkin-solver/src/bin/pumpkin-solver/flatzinc/compiler/post_constraints.rs +++ b/pumpkin-solver/src/bin/pumpkin-solver/flatzinc/compiler/post_constraints.rs @@ -2,7 +2,7 @@ use std::rc::Rc; -use pumpkin_propagators::propagators::ArgDisjunctiveTask; +use pumpkin_propagators::disjunctive::ArgDisjunctiveTask; use pumpkin_solver::constraints::Constraint; use pumpkin_solver::constraints::NegatableConstraint; use pumpkin_solver::predicate; diff --git a/pumpkin-solver/src/bin/pumpkin-solver/flatzinc/mod.rs b/pumpkin-solver/src/bin/pumpkin-solver/flatzinc/mod.rs index cacd20da3..41d92fb92 100644 --- a/pumpkin-solver/src/bin/pumpkin-solver/flatzinc/mod.rs +++ b/pumpkin-solver/src/bin/pumpkin-solver/flatzinc/mod.rs @@ -14,7 +14,7 @@ use pumpkin_core::branching::branchers::alternating::AlternatingBrancher; use pumpkin_core::branching::branchers::alternating::every_x_restarts::EveryXRestarts; use pumpkin_core::branching::branchers::alternating::until_solution::UntilSolution; use pumpkin_core::statistics::log_statistic; -use pumpkin_propagators::propagators::CumulativeOptions; +use pumpkin_propagators::cumulative::options::CumulativeOptions; use pumpkin_solver::Solver; use pumpkin_solver::branching::Brancher; use pumpkin_solver::branching::branchers::dynamic_brancher::DynamicBrancher; diff --git a/pumpkin-solver/src/bin/pumpkin-solver/main.rs b/pumpkin-solver/src/bin/pumpkin-solver/main.rs index b9f6b6cef..bf31ece3e 100644 --- a/pumpkin-solver/src/bin/pumpkin-solver/main.rs +++ b/pumpkin-solver/src/bin/pumpkin-solver/main.rs @@ -24,9 +24,9 @@ use maxsat::PseudoBooleanEncoding; use parsers::dimacs::SolverArgs; use parsers::dimacs::SolverDimacsSink; use parsers::dimacs::parse_cnf; -use pumpkin_propagators::propagators::CumulativeExplanationType; -use pumpkin_propagators::propagators::CumulativeOptions; -use pumpkin_propagators::propagators::CumulativePropagationMethod; +use pumpkin_propagators::cumulative::options::CumulativeOptions; +use pumpkin_propagators::cumulative::options::CumulativePropagationMethod; +use pumpkin_propagators::cumulative::time_table::CumulativeExplanationType; use pumpkin_solver::Solver; use pumpkin_solver::convert_case::Case; use pumpkin_solver::optimisation::OptimisationStrategy; diff --git a/pumpkin-solver/src/lib.rs b/pumpkin-solver/src/lib.rs index 7539be810..3c289cf85 100644 --- a/pumpkin-solver/src/lib.rs +++ b/pumpkin-solver/src/lib.rs @@ -10,10 +10,10 @@ //! The solver currently supports integer variables and a number of (global) constraints: //! * [Cumulative global constraint][pumpkin_constraints::cumulative]. //! * [Element global constraint][pumpkin_constraints::element]. -//! * Arithmetic constraints: [linear integer -//! (in)equalities][pumpkin_constraints::less_than_or_equals], [integer -//! division][pumpkin_constraints::division], [integer -//! multiplication][pumpkin_constraints::times], [maximum][pumpkin_constraints::maximum], +//! * Arithmetic constraints: +//! [linearinteger(in)equalities][pumpkin_constraints::less_than_or_equals], +//! [integerdivision][pumpkin_constraints::division], +//! [integermultiplication][pumpkin_constraints::times], [maximum][pumpkin_constraints::maximum], //! [absolute value][pumpkin_constraints::absolute]. //! * [Clausal constraints][Solver::add_clause]. //! From b8754efd9c860ae171ceb3e68aa4503101480276 Mon Sep 17 00:00:00 2001 From: Imko Marijnissen Date: Tue, 16 Dec 2025 15:59:35 +0100 Subject: [PATCH 5/6] fix: adjust clap feature passing --- Cargo.lock | 1 - pumpkin-crates/constraints/Cargo.toml | 5 ++--- pumpkin-crates/core/Cargo.toml | 2 +- pumpkin-crates/propagators/Cargo.toml | 4 ++-- pumpkin-solver/Cargo.toml | 2 +- 5 files changed, 6 insertions(+), 8 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 1a237fd57..d667a5e7b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -739,7 +739,6 @@ dependencies = [ name = "pumpkin-constraints" version = "0.2.2" dependencies = [ - "clap", "pumpkin-core", "pumpkin-propagators", ] diff --git a/pumpkin-crates/constraints/Cargo.toml b/pumpkin-crates/constraints/Cargo.toml index 4f51b77f3..4c160bd23 100644 --- a/pumpkin-crates/constraints/Cargo.toml +++ b/pumpkin-crates/constraints/Cargo.toml @@ -12,8 +12,7 @@ workspace = true [dependencies] pumpkin-core = { version = "0.2.2", path = "../core" } -pumpkin-propagators = {version = "0.2.2", path="../propagators", features = ["clap"]} -clap = { version = "4.5.40", optional = true } +pumpkin-propagators = {version = "0.2.2", path="../propagators"} [features] -clap = ["dep:clap"] +clap = ["pumpkin-core/clap", "pumpkin-propagators/clap"] diff --git a/pumpkin-crates/core/Cargo.toml b/pumpkin-crates/core/Cargo.toml index a6d639ea5..94d304d59 100644 --- a/pumpkin-crates/core/Cargo.toml +++ b/pumpkin-crates/core/Cargo.toml @@ -25,7 +25,7 @@ itertools = "0.13.0" bitfield-struct = "0.9.2" num = "0.4.3" enum-map = "2.7.3" -clap = { version = "4.5.40", optional = true } +clap = { version = "4.5.40", optional = true, features=["derive"] } indexmap = "2.10.0" dyn-clone = "1.0.20" flate2 = { version = "1.1.2" } diff --git a/pumpkin-crates/propagators/Cargo.toml b/pumpkin-crates/propagators/Cargo.toml index fac80d086..4c7e40f4a 100644 --- a/pumpkin-crates/propagators/Cargo.toml +++ b/pumpkin-crates/propagators/Cargo.toml @@ -15,10 +15,10 @@ pumpkin-core = { version = "0.2.2", path = "../core" } enumset = "1.1.2" bitfield-struct = "0.9.2" convert_case = "0.6.0" -clap = { version = "4.5.40", optional = true } +clap = { version = "4.5.40", optional = true, features=["derive"]} [dev-dependencies] pumpkin-constraints = { version = "0.2.2", path = "../constraints" } [features] -clap = ["dep:clap"] +clap = ["dep:clap", "pumpkin-core/clap"] diff --git a/pumpkin-solver/Cargo.toml b/pumpkin-solver/Cargo.toml index 6ba8a9195..e31497273 100644 --- a/pumpkin-solver/Cargo.toml +++ b/pumpkin-solver/Cargo.toml @@ -15,7 +15,7 @@ flatzinc = "0.3.21" log = "0.4.27" pumpkin-core = { version = "0.2.2", path = "../pumpkin-crates/core/", features = ["clap"] } pumpkin-constraints = {version = "0.2.2", path = "../pumpkin-crates/constraints/"} -pumpkin-propagators = {version = "0.2.2", path = "../pumpkin-crates/propagators/"} +pumpkin-propagators = {version = "0.2.2", path = "../pumpkin-crates/propagators/", features=["clap"]} signal-hook = "0.3.18" thiserror = "2.0.12" From 72ba8fdeedd7ebf62ba43ae87756dfb0ce9c8153 Mon Sep 17 00:00:00 2001 From: Imko Marijnissen Date: Wed, 7 Jan 2026 10:02:59 +0100 Subject: [PATCH 6/6] docs: update docs to be a bit more clear --- .../src/constraints/arithmetic/equality.rs | 4 ++-- .../src/constraints/arithmetic/inequality.rs | 16 ++++++++-------- .../constraints/src/constraints/boolean.rs | 4 ++-- .../constraints/src/constraints/cumulative.rs | 2 +- .../constraints/src/constraints/table.rs | 4 ++-- 5 files changed, 15 insertions(+), 15 deletions(-) diff --git a/pumpkin-crates/constraints/src/constraints/arithmetic/equality.rs b/pumpkin-crates/constraints/src/constraints/arithmetic/equality.rs index 9c7e49a09..9660a541d 100644 --- a/pumpkin-crates/constraints/src/constraints/arithmetic/equality.rs +++ b/pumpkin-crates/constraints/src/constraints/arithmetic/equality.rs @@ -19,7 +19,7 @@ struct EqualConstraint { constraint_tag: ConstraintTag, } -/// Creates the [`NegatableConstraint`] `\sum terms_i = rhs`. +/// Creates the [`NegatableConstraint`] `∑ terms_i = rhs`. /// /// Its negation is [`not_equals`]. pub fn equals( @@ -55,7 +55,7 @@ struct NotEqualConstraint { constraint_tag: ConstraintTag, } -/// Create the [`NegatableConstraint`] `\sum terms_i != rhs`. +/// Create the [`NegatableConstraint`] `∑ terms_i != rhs`. /// /// Its negation is [`equals`]. pub fn not_equals( diff --git a/pumpkin-crates/constraints/src/constraints/arithmetic/inequality.rs b/pumpkin-crates/constraints/src/constraints/arithmetic/inequality.rs index c7aa7e250..5f928e358 100644 --- a/pumpkin-crates/constraints/src/constraints/arithmetic/inequality.rs +++ b/pumpkin-crates/constraints/src/constraints/arithmetic/inequality.rs @@ -7,9 +7,9 @@ use pumpkin_core::variables::IntegerVariable; use pumpkin_core::variables::Literal; use pumpkin_propagators::arithmetic::LinearLessOrEqualPropagatorArgs; -/// Create the [`NegatableConstraint`] `\sum terms_i <= rhs`. +/// Create the [`NegatableConstraint`] `∑ terms_i <= rhs`. /// -/// Its negation is `\sum terms_i > rhs` +/// Its negation is `∑ terms_i > rhs` pub fn less_than_or_equals( terms: impl Into>, rhs: i32, @@ -22,9 +22,9 @@ pub fn less_than_or_equals( } } -/// Create the [`NegatableConstraint`] `\sum terms_i < rhs`. +/// Create the [`NegatableConstraint`] `∑ terms_i < rhs`. /// -/// Its negation is `\sum terms_i <= rhs` +/// Its negation is `∑ terms_i <= rhs` pub fn less_than( terms: impl Into>, rhs: i32, @@ -33,9 +33,9 @@ pub fn less_than( less_than_or_equals(terms, rhs - 1, constraint_tag) } -/// Create the [`NegatableConstraint`] `\sum terms_i > rhs`. +/// Create the [`NegatableConstraint`] `∑ terms_i > rhs`. /// -/// Its negation is `\sum terms_i <= rhs` +/// Its negation is `∑ terms_i <= rhs` pub fn greater_than( terms: impl Into>, rhs: i32, @@ -44,9 +44,9 @@ pub fn greater_than( greater_than_or_equals(terms, rhs + 1, constraint_tag) } -/// Create the [`NegatableConstraint`] `\sum terms_i >= rhs`. +/// Create the [`NegatableConstraint`] `∑ terms_i >= rhs`. /// -/// Its negation is `\sum terms_i < rhs` +/// Its negation is `∑ terms_i < rhs` pub fn greater_than_or_equals( terms: impl Into>, rhs: i32, diff --git a/pumpkin-crates/constraints/src/constraints/boolean.rs b/pumpkin-crates/constraints/src/constraints/boolean.rs index 2ae06de96..32539f39b 100644 --- a/pumpkin-crates/constraints/src/constraints/boolean.rs +++ b/pumpkin-crates/constraints/src/constraints/boolean.rs @@ -10,7 +10,7 @@ use pumpkin_core::variables::TransformableVariable; use super::equals; use super::less_than_or_equals; -/// Creates the [`Constraint`] `\sum weights_i * bools_i <= rhs`. +/// Creates the [`Constraint`] `∑ weights_i * bools_i <= rhs`. pub fn boolean_less_than_or_equals( weights: impl Into>, bools: impl Into>, @@ -25,7 +25,7 @@ pub fn boolean_less_than_or_equals( } } -/// Creates the [`Constraint`] `\sum weights_i * bools_i == rhs`. +/// Creates the [`Constraint`] `∑ weights_i * bools_i == rhs`. pub fn boolean_equals( weights: impl Into>, bools: impl Into>, diff --git a/pumpkin-crates/constraints/src/constraints/cumulative.rs b/pumpkin-crates/constraints/src/constraints/cumulative.rs index b1022dbc6..7854a44ff 100644 --- a/pumpkin-crates/constraints/src/constraints/cumulative.rs +++ b/pumpkin-crates/constraints/src/constraints/cumulative.rs @@ -149,7 +149,7 @@ where ) } -/// Creates the [Cumulative](https://sofdem.github.io/gccat/gccat/Ccumulative.html) constraint +/// Creates the [Cumulative](https://sofdem.github.io/gccat/gccat/Ccumulative.html) [`Constraint`] /// with the provided [`CumulativeOptions`]. /// /// See the documentation of [`cumulative`] for more information about the constraint. diff --git a/pumpkin-crates/constraints/src/constraints/table.rs b/pumpkin-crates/constraints/src/constraints/table.rs index abc6364d9..5aabda02c 100644 --- a/pumpkin-crates/constraints/src/constraints/table.rs +++ b/pumpkin-crates/constraints/src/constraints/table.rs @@ -9,7 +9,7 @@ use pumpkin_core::proof::ConstraintTag; use pumpkin_core::variables::IntegerVariable; use pumpkin_core::variables::Literal; -/// Create a table constraint over the variables `xs`. +/// Create the [table](https://sofdem.github.io/gccat/gccat/Cin_relation.html#uid22830) [`NegatableConstraint`]. /// /// A table constraint constrains a tuple of variables to have pre-defined values. For example: /// ```ignore @@ -32,7 +32,7 @@ pub fn table( } } -/// Create a negative table constraint over the variables `xs`. +/// Create the negative [table](https://sofdem.github.io/gccat/gccat/Cin_relation.html#uid22830) [`NegatableConstraint`]. /// /// A negative table is essentially a set of conflicts over the given variables. For example: /// ```ignore