winston 0.0.2 → 0.1.0

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