winston 0.0.1 → 0.1.0

data/lib/winston/constraint.rb

@@ -1,19 +1,32 @@
 module Winston
   class Constraint
 
-    def initialize(variables = nil, predicate = nil)
-      @variables = variables || []
+    attr_reader :variables, :predicate, :allow_nil, :global
+
+    def initialize(variables: nil, predicate: nil, allow_nil: false)
+      @variables = [variables].flatten.compact
       @predicate = predicate
+      @allow_nil = allow_nil
       @global = @variables.empty?
     end
 
     def elegible_for?(changed_var, assignments)
-      @global || (@variables.include?(changed_var) && @variables.all? { |v| assignments.key? v })
+      global || (variables.include?(changed_var) && has_required_values?(assignments))
     end
 
     def validate(assignments)
-      return false unless @predicate
-      @predicate.call(*assignments.values_at(*@variables), assignments)
+      return false unless predicate
+      predicate.call(*values_at(assignments), assignments)
+    end
+
+    protected
+
+    def values_at(assignments)
+      assignments.values_at(*variables)
+    end
+
+    def has_required_values?(assignments)
+      allow_nil || variables.all? { |v| assignments.key?(v) }
     end
   end
 end

data/lib/winston/constraints/all_different.rb

@@ -2,7 +2,8 @@ module Winston
   module Constraints
     class AllDifferent < Winston::Constraint
       def validate(assignments)
-        assignments.values.uniq.size == assignments.size
+        values = global ? assignments.values : values_at(assignments).compact
+        values.uniq.size == values.size
       end
     end
   end

data/lib/winston/constraints/not_in_list.rb

@@ -0,0 +1,18 @@
+module Winston
+  module Constraints
+    class NotInList < Winston::Constraint
+
+      attr_reader :list
+
+      def initialize(variables: nil, allow_nil: false, list: [])
+        super(variables: variables, allow_nil: allow_nil)
+        @list = list
+      end
+
+      def validate(assignments)
+        values = global ? assignments.values : values_at(assignments)
+        !values.any? { |v| list.include?(v) }
+      end
+    end
+  end
+end

data/lib/winston/csp.rb

@@ -8,8 +8,12 @@ module Winston
       @constraints = []
     end
 
-    def solve(solver = Backtrack.new(self))
-      solver.search(var_assignments)
+    def solve(solver = nil, **options)
+      initial = var_assignments
+      return false unless validate_initial_assignments(initial)
+
+      solver_instance = build_solver(solver, options)
+      solver_instance.search(initial)
     end
 
     def add_variable(name, value: nil, domain: nil, &block)
@@ -17,8 +21,8 @@ module Winston
       variables[name] = Variable.new(name, value: value, domain: domain)
     end
 
-    def add_constraint(*variables, constraint: nil, &block)
-      constraint ||= Constraint.new(variables, block)
+    def add_constraint(*variables, constraint: nil, allow_nil: false, &block)
+      constraint ||= Constraint.new(variables: variables, allow_nil: allow_nil, predicate: block)
       constraints << constraint
     end
 
@@ -29,6 +33,13 @@ module Winston
       true
     end
 
+    def domain_for(variable_name)
+      variable = variables[variable_name]
+      return [] if variable.nil? || variable.domain.nil?
+
+      variable.domain.values
+    end
+
     private
 
     def var_assignments
@@ -37,5 +48,29 @@ module Winston
         assignments
       end
     end
+
+    def build_solver(solver, options)
+      return solver if solver && !solver.is_a?(Symbol)
+
+      case solver
+      when nil, :backtrack
+        Solvers::Backtrack.new(self, **options)
+      when :mac
+        Solvers::MAC.new(self, **options)
+      when :min_conflicts
+        Solvers::MinConflicts.new(self, **options)
+      else
+        raise ArgumentError, "Unknown solver :#{solver}"
+      end
+    end
+
+    def validate_initial_assignments(assignments)
+      constraints.all? do |constraint|
+        next constraint.validate(assignments) if constraint.global || constraint.allow_nil
+        next true unless constraint.variables.all? { |v| assignments.key?(v) }
+
+        constraint.validate(assignments)
+      end
+    end
   end
 end

data/lib/winston/dsl.rb

@@ -0,0 +1,69 @@
+module Winston
+  class DSL
+    attr_reader :csp
+
+    def initialize(csp = CSP.new)
+      @csp = csp
+      @domains = {}
+    end
+
+    def domain(name, values)
+      @domains[name] = values
+    end
+
+    def var(name, domain: nil, value: nil, &block)
+      resolved_domain = resolve_domain(domain)
+      csp.add_variable(name, value: value, domain: resolved_domain, &block)
+    end
+
+    def constraint(*variables, allow_nil: false, &block)
+      csp.add_constraint(*variables, allow_nil: allow_nil, &block)
+    end
+
+    def use_constraint(name, *variables, allow_nil: false, **options)
+      factory = constraint_factory_for(name)
+      constraint = factory.call(variables, allow_nil, **options)
+      csp.add_constraint(constraint: constraint)
+    end
+
+    private
+
+    def resolve_domain(domain)
+      return domain unless domain.is_a?(Symbol)
+      return @domains[domain] if @domains.key?(domain)
+
+      raise ArgumentError, "Unknown domain :#{domain}"
+    end
+
+    def constraint_factory_for(name)
+      registry = Winston.constraint_registry
+      return registry[name] if registry.key?(name)
+
+      raise ArgumentError, "Unknown constraint :#{name}"
+    end
+  end
+
+  def self.constraint_registry
+    @constraint_registry ||= {
+      all_different: lambda do |variables, allow_nil, **options|
+        Winston::Constraints::AllDifferent.new(variables: variables, allow_nil: allow_nil, **options)
+      end,
+      not_in_list: lambda do |variables, allow_nil, **options|
+        Winston::Constraints::NotInList.new(variables: variables, allow_nil: allow_nil, **options)
+      end
+    }
+  end
+
+  def self.register_constraint(name, factory = nil, &block)
+    factory ||= block
+    raise ArgumentError, "Constraint factory required for :#{name}" unless factory
+
+    constraint_registry[name] = factory
+  end
+
+  def self.define(&block)
+    builder = DSL.new
+    builder.instance_eval(&block) if block
+    builder.csp
+  end
+end

data/lib/winston/heuristics.rb

@@ -0,0 +1,44 @@
+module Winston
+  module Heuristics
+    def self.mrv
+      lambda do |vars, assignments, csp|
+        vars.min_by { |var| remaining_values(var, assignments, csp).size }
+      end
+    end
+
+    def self.lcv
+      lambda do |values, var, assignments, csp|
+        other_vars = vars_without(var, assignments, csp)
+        scored = values.map do |value|
+          score = other_vars.sum do |other|
+            csp.domain_for(other.name).count do |other_value|
+              csp.validate(other.name, assignments.merge(var.name => value, other.name => other_value))
+            end
+          end
+          [value, score]
+        end
+        scored.sort_by { |(_, score)| -score }.map(&:first)
+      end
+    end
+
+    def self.in_order
+      ->(values, _var, _assignments, _csp) { values }
+    end
+
+    def self.forward_checking
+      true
+    end
+
+    def self.remaining_values(var, assignments, csp)
+      csp.domain_for(var.name).select do |value|
+        csp.validate(var.name, assignments.merge(var.name => value))
+      end
+    end
+
+    def self.vars_without(var, assignments, csp)
+      csp.variables.reject { |k, _| assignments.include?(k) || k == var.name }.each_value.to_a
+    end
+
+    private_class_method :remaining_values, :vars_without
+  end
+end

data/lib/winston/solvers/backtrack.rb

@@ -0,0 +1,91 @@
+module Winston
+  module Solvers
+    class Backtrack
+    def initialize(csp, variable_strategy: :first, value_strategy: :in_order, forward_checking: false)
+      @csp = csp
+      @variable_strategy = variable_strategy
+      @value_strategy = value_strategy
+      @forward_checking = forward_checking
+    end
+
+    def search(assignments = {})
+      return assignments if complete?(assignments)
+      var = select_unassigned_variable(assignments)
+      domain_values(var, assignments).each do |value|
+        assigned = assignments.merge(var.name => value)
+        if valid?(var.name, assigned)
+          result = search(assigned)
+          return result if result
+        end
+      end
+      false
+    end
+
+    private
+
+    attr_reader :csp, :variable_strategy, :value_strategy, :forward_checking
+
+    def complete?(assignments)
+      assignments.size == csp.variables.size
+    end
+
+    def valid?(changed, assignments)
+      return false unless csp.validate(changed, assignments)
+      return true unless forward_checking
+
+      forward_check(assignments)
+    end
+
+    def select_unassigned_variable(assignments)
+      vars = unassigned_variables(assignments)
+      return vars.first if variable_strategy == :first
+      return variable_strategy.call(vars, assignments, csp) if variable_strategy.respond_to?(:call)
+      return vars.min_by { |var| remaining_values(var, assignments).size } if variable_strategy == :mrv
+
+      vars.first
+    end
+
+    def domain_values(var, assignments)
+      values = remaining_values(var, assignments)
+      return values if value_strategy == :in_order
+      return value_strategy.call(values, var, assignments, csp) if value_strategy.respond_to?(:call)
+      return order_lcv(values, var, assignments) if value_strategy == :lcv
+
+      values
+    end
+
+    def remaining_values(var, assignments)
+      csp.domain_for(var.name).select do |value|
+        csp.validate(var.name, assignments.merge(var.name => value))
+      end
+    end
+
+    def order_lcv(values, var, assignments)
+      other_vars = unassigned_variables(assignments).reject { |v| v.name == var.name }
+      scored = values.map do |value|
+        score = other_vars.sum do |other|
+          csp.domain_for(other.name).count do |other_value|
+            csp.validate(other.name, assignments.merge(var.name => value, other.name => other_value))
+          end
+        end
+        [value, score]
+      end
+      scored.sort_by { |(_, score)| -score }.map(&:first)
+    end
+
+    def unassigned_variables(assignments)
+      csp.variables.reject { |k, _| assignments.include?(k) }.each_value.to_a
+    end
+
+    def forward_check(assignments)
+      unassigned_variables(assignments).all? do |var|
+        csp.domain_for(var.name).any? do |value|
+          csp.validate(var.name, assignments.merge(var.name => value))
+        end
+      end
+    end
+    end
+  end
+
+  Backtrack = Solvers::Backtrack
+end