FixedShapedSolver

.gitignore

@@ -22,3 +22,4 @@ docs/site/
 # committed for packages, but should be committed for applications that require a static
 # environment.
 Manifest.toml
+

Project.toml

@@ -1,16 +1,18 @@
 name = "HerbConstraints"
 uuid = "1fa96474-3206-4513-b4fa-23913f296dfc"
 authors = ["Jaap de Jong <[email protected]>"]
-version = "0.1.0"
+version = "0.2.0"
 
 [deps]
-HerbGrammar = "4ef9e186-2fe5-4b24-8de7-9f7291f24af7"
+DataStructures = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
 HerbCore = "2b23ba43-8213-43cb-b5ea-38c12b45bd45"
+HerbGrammar = "4ef9e186-2fe5-4b24-8de7-9f7291f24af7"
+MLStyle = "d8e11817-5142-5d16-987a-aa16d5891078"
 
 [compat]
-julia = "1.8"
-HerbCore = "0.1.0"
-HerbGrammar = "0.1.0"
+HerbCore = "^0.2.0"
+HerbGrammar = "^0.2.1"
+julia = "^1.8"
 
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"

src/HerbConstraints.jl

@@ -2,110 +2,135 @@ module HerbConstraints
 
 using HerbCore
 using HerbGrammar
+using DataStructures
+using MLStyle
 
 """
-    PropagatorConstraint <: Constraint
+    abstract type GrammarConstraint <: Constraint
 
-Abstract type representing all propagator constraints.
-Each propagator constraint has an implementation of a [`propagate`](@ref)-function that takes
-
-- the [`PropagatorConstraint`](@ref)
-- a [`Grammar`](@ref)
-- a [`GrammarContext`](@ref), which most importantly contains the tree and the location 
-  in the tree where propagation should take place.
-- The `domain` which the [`propagate`](@ref)-function prunes. 
-
-The [`propagate`](@ref)-function returns a tuple containing
-
-- The pruned `domain`
-- A list of new [`LocalConstraint`](@ref)s
+Abstract type representing all user-defined constraints.
+Each grammar constraint has a related [LocalConstraint](@ref) that is responsible for propagating the constraint at a specific location in the tree.
+Grammar constraints should implement `on_new_node` to post a [`LocalConstraint`](@ref) at that new node
 """
-abstract type PropagatorConstraint <: Constraint end
+abstract type GrammarConstraint <: Constraint end
 
 """
     abstract type LocalConstraint <: Constraint
 
 Abstract type representing all local constraints.
 Local constraints correspond to a specific (partial) [`AbstractRuleNode`](@ref) tree.
-Each local constraint contains a `path` to a specific location in the tree.  
-Each local constraint has an implementation of a [`propagate`](@ref)-function that takes
-
-- the [`LocalConstraint`](@ref)
-- a [`Grammar`](@ref)
-- a [`GrammarContext`](@ref), which most importantly contains the tree and the location 
-  in the tree where propagation should take place.
-- The `domain` which the [`propagate`](@ref)-function prunes. 
+Each local constraint contains a `path` that points to a specific location in the tree.
+The constraint is propagated on any tree manipulation at or below that `path`.
 
-The [`propagate`](@ref)-function returns a tuple containing
-
-- The pruned `domain`
-- A list of new [`LocalConstraint`](@ref)s
+Each local constraint should implement a [`propagate!`](@ref)-function.
+Inside the [`propagate!`](@ref) function, the constraint can use the following solver functions:
+- `remove!`: Elementary tree manipulation. Removes a value from a domain. (other tree manipulations are: `remove_above!`, `remove_below!`, `remove_all_but!`)
+- `deactivate!`: Prevent repropagation. Call this as soon as the constraint is satisfied.
+- `mark_infeasible!`: Report a non-trivial inconsistency. Call this if the constraint can never be satisfied. An empty domain is considered a trivial inconsistency, such inconsistencies are already handled by tree manipulations.
+- `isfeasible`: Check if the current tree is still feasible. Return from the propagate function, as soon as infeasibility is detected.
 
 !!! warning
     By default, [`LocalConstraint`](@ref)s are only propagated once.
-    Constraints that have to be propagated more frequently should return 
-    themselves in the list of new local constraints.
+    Constraints that have to be propagated more frequently should subscribe to an event. This part of the solver is still WIP.
+    Currently, the solver supports only one type of subscription: `propagate_on_tree_manipulation!`.
 """
 abstract type LocalConstraint <: Constraint end
 
-@enum PropagateFailureReason unchanged_domain=1
-PropagatedDomain = Union{PropagateFailureReason, Vector{Int}}
+include("csg_annotated/csg_annotated.jl")
 
-include("matchfail.jl")
-include("matchnode.jl")
-include("context.jl")
-include("patternmatch.jl")
-include("rulenodematch.jl")
+include("varnode.jl")
+include("domainrulenode.jl")
 
-include("csg_annotated/csg_annotated.jl")
+include("solver/solver.jl")
+include("solver/solverstatistics.jl")
+include("solver/generic_solver/state.jl")
+include("solver/generic_solver/generic_solver.jl")
+include("solver/generic_solver/treemanipulations.jl")
 
-include("propagatorconstraints/comesafter.jl")
-include("propagatorconstraints/forbidden_path.jl")
-include("propagatorconstraints/require_on_left.jl")
-include("propagatorconstraints/forbidden.jl")
-include("propagatorconstraints/ordered.jl")
-include("propagatorconstraints/condition.jl")
-include("propagatorconstraints/one_of.jl")
+include("solver/fixed_shaped_solver/state_manager.jl")
+include("solver/fixed_shaped_solver/state_sparse_set.jl")
+include("solver/fixed_shaped_solver/state_fixed_shaped_hole.jl")
+include("solver/fixed_shaped_solver/fixed_shaped_solver.jl")
+include("solver/fixed_shaped_solver/fixed_shaped_solver_treemanipulations.jl")
+include("solver/domainutils.jl")
+
+include("patternmatch.jl")
+include("lessthanorequal.jl")
 
 include("localconstraints/local_forbidden.jl")
 include("localconstraints/local_ordered.jl")
-include("localconstraints/local_condition.jl")
-include("localconstraints/local_one_of.jl")
-
-export
-    AbstractMatchNode,
-    MatchNode,
-    MatchVar,
-    matchnode2expr,
+include("localconstraints/local_contains.jl")
 
-    GrammarContext,
-    addparent!,
-    copy_and_insert,
+include("grammarconstraints/forbidden.jl")
+include("grammarconstraints/ordered.jl")
+include("grammarconstraints/contains.jl")
 
-    contains_var,
 
-    PropagatorConstraint,
+export
+    GrammarConstraint,
     LocalConstraint,
-    PropagateFailureReason,
-    PropagatedDomain,
 
-    propagate,
+    DomainRuleNode,
+    VarNode,
+    pattern_match,
     check_tree,
-
-    generateconstraints!,
-
-    ComesAfter,
-    ForbiddenPath,
-    RequireOnLeft,
+
+    #grammar constraints
     Forbidden,
     Ordered,
-    Condition,
-    OneOf,
+    Contains,
 
+    #local constraints
     LocalForbidden,
     LocalOrdered,
-    LocalCondition
-    LocalOrdered,
-    LocalOneOf
+    LocalContains,
+
+    #public solver functions
+    GenericSolver,
+    Solver,
+    State,
+    new_state!,
+    save_state!,
+    load_state!,
+    isfeasible,
+    get_state,
+    get_tree,
+    get_grammar,
+    get_state,
+    get_node_at_location,
+    get_hole_at_location,
+    get_max_depth,
+    get_max_size,
+    get_tree_size,
+
+    #tree manipulations
+    remove!,
+    remove_all_but!,
+    substitute!,
+
+    #domainutils
+    is_subdomain,
+    partition,
+    are_disjoint,
+    get_intersection,
+
+    #solverstatistics
+    track!,
+
+    #functions related to stateful objects
+    restore!,
+    StateInt,
+    get_value,
+    set_value!,
+    increment!,
+    decrement!,
+
+    #fixed shaped solver
+    next_solution!,
+    FixedShapedSolver,
+
+    #state fixed shaped hole
+    StateFixedShapedHole,
+    statefixedshapedhole2rulenode
 
 end # module HerbConstraints

src/csg_annotated/csg_annotated.jl

@@ -38,7 +38,7 @@ end
 ```
 """
 macro csgrammar_annotated(expression)
-	# collect and remove labels
+    # collect and remove labels
     labels = _get_labels!(expression)
 
     # parse rules, get constraints from annotations
@@ -92,19 +92,21 @@ macro csgrammar_annotated(expression)
 
     # determine parameters
     alltypes = collect(keys(bytype))
-	is_terminal = [isterminal(rule, alltypes) for rule ∈ rules]
-	is_eval = [iseval(rule) for rule ∈ rules]
-	childtypes = [get_childtypes(rule, alltypes) for rule ∈ rules]
-	domains = Dict(type => BitArray(r ∈ bytype[type] for r ∈ 1:length(rules)) for type ∈ alltypes)
+    is_terminal = [isterminal(rule, alltypes) for rule ∈ rules]
+    is_eval = [iseval(rule) for rule ∈ rules]
+    childtypes = [get_childtypes(rule, alltypes) for rule ∈ rules]
+    bychildtypes = [BitVector([childtypes[i1] == childtypes[i2] for i2 ∈ 1:length(rules)]) for i1 ∈ 1:length(rules)]
+    domains = Dict(type => BitArray(r ∈ bytype[type] for r ∈ 1:length(rules)) for type ∈ alltypes)
 
     return ContextSensitiveGrammar(
         rules,
         types,
         is_terminal,
         is_eval,
         bytype,
-		domains,
+        domains,
         childtypes,
+        bychildtypes,
         nothing,
         constraints
     )

src/domainrulenode.jl

@@ -0,0 +1,17 @@
+"""
+    struct DomainRuleNode <: AbstractRuleNode
+
+Matches any 1 rule in its domain.
+Example usage:
+
+    DomainRuleNode(Bitvector((0, 0, 1, 1)), [RuleNode(1), RuleNode(1)])
+
+This matches `RuleNode(3, [RuleNode(1), RuleNode(1)])` and `RuleNode(4, [RuleNode(1), RuleNode(1)])` and `Hole({3, 4}, [RuleNode(1), RuleNode(1)])`
+"""
+struct DomainRuleNode <: AbstractRuleNode
+    domain::BitVector
+    children::Vector{AbstractRuleNode}
+end
+
+#DomainRuleNode(get_domain(grammar, sym), [])
+DomainRuleNode(domain::BitVector) = DomainRuleNode(domain, [])

src/grammarconstraints/contains.jl

@@ -0,0 +1,26 @@
+"""
+Contains <: GrammarConstraint
+This [`GrammarConstraint`] enforces that a given `rule` appears in the program tree at least once.
+"""
+struct Contains <: GrammarConstraint
+    rule::Int
+end
+
+function on_new_node(solver::Solver, contraint::Contains, path::Vector{Int})
+    if length(path) == 0
+        #only post a local constraint at the root
+        post!(solver, LocalContains(path, contraint.rule))
+    end
+end
+
+"""
+    check_tree(c::Forbidden, g::AbstractGrammar, tree::RuleNode)::Bool
+
+Checks if the given [`AbstractRuleNode`](@ref) tree abides the [`Forbidden`](@ref) constraint.
+"""
+function check_tree(contraint::Contains, tree::AbstractRuleNode)::Bool
+    if get_rule(tree) == contraint.rule
+        return true
+    end
+    return any(check_tree(contraint, child) for child ∈ get_children(tree))
+end