gecoder 0.8.3 → 0.9.0

data/lib/gecoder/interface/constraints/set_enum/selection.rb

@@ -1,217 +0,0 @@
-module Gecode::SetEnumMethods
-  # This adds the adder for the methods in the modules including it. The 
-  # reason for doing it so indirect is that the first #[] won't be defined 
-  # before the module that this is mixed into is mixed into an enum.
-  def self.included(mod) #:nodoc:
-    mod.module_eval do
-      # Now we enter the module that the module possibly defining #[] 
-      # is mixed into.
-      if instance_methods.include?('[]') and 
-          not instance_methods.include?('pre_selection_access')
-        alias_method :pre_selection_access, :[]
-      end
-    
-      def [](*vars)
-        # Hook in an element constraint if a variable is used for array 
-        # access.
-        if vars.first.kind_of? Gecode::FreeIntVar
-          params = {:lhs => self, :index => vars.first}
-          Gecode::Constraints::SetEnum::Selection::SelectExpressionStub.new(
-            @model, params)
-        elsif vars.first.kind_of? Gecode::FreeSetVar
-          params = {:lhs => self, :indices => vars.first}
-          Gecode::Constraints::SetEnum::Selection::SetAccessStub.new(
-            @model, params)
-        else
-          pre_selection_access(*vars) if respond_to? :pre_selection_access
-        end
-      end
-    end
-  end
-end
-
-# A module that gathers the classes and modules used by selection constraints.
-module Gecode::Constraints::SetEnum::Selection #:nodoc:
-  # Describes an expression stub started with a set var enum followed with an
-  # array access using a set variable.
-  class SetAccessStub < Gecode::Constraints::ExpressionStub #:nodoc:
-    include Gecode::Constraints::LeftHandSideMethods
-    
-    # Starts a union selection constraint on the selected sets.
-    def union
-      UnionExpressionStub.new(@model, @params)
-    end
-    
-    # Starts a intersection selection constraint on the selected sets. The 
-    # option :with may optionally be specified, in which case the value should
-    # be an enumeration of the elements in the universe.
-    def intersection(options = {})
-      unless options.empty? 
-        unless options.size == 1 and options.has_key?(:with)
-          raise ArgumentError, "Expected option key :with, got #{options.keys}."
-        else
-          universe = options[:with]
-          unless universe.kind_of?(Enumerable) and 
-              universe.all?{ |element| element.kind_of? Fixnum }
-            raise TypeError, "Expected the universe to be specified as " + 
-              "an enumeration of fixnum, got #{universe.class}."
-          end
-          @params.update(:universe => universe)
-        end
-      end
-      
-      IntersectionExpressionStub.new(@model, @params)
-    end
-    
-    private
-    
-    # Produces an expression with position for the lhs module.
-    def expression(params)
-      SetAccessExpression.new(@model, @params.update(params))
-    end
-  end
-  
-  # Describes an expression that starts with an set variable enum followed with
-  # an array access using a set variable followed by some form of must.
-  class SetAccessExpression < Gecode::Constraints::Set::Expression #:nodoc:
-    # Constrains the selected sets to be disjoint.
-    def disjoint
-      if @params[:negate]
-        raise Gecode::MissingConstraintError, 'A negated set selection ' + 
-          'disjoint is not implemented.'
-      end
-      
-      @model.add_constraint DisjointConstraint.new(@model, @params)
-    end
-  end
-
-  # Describes a CompositeStub for the set select constraint, which constrains 
-  # the set in a position specified by an integer variable in an enumeration of 
-  # set variable.
-  # 
-  # == Examples
-  # 
-  #   # The set at the position described by the integer variable 
-  #   # +singleton_zero_position+ in the enumeration +sets+ of set variables 
-  #   # must equal [0].
-  #   sets[singleton_zero_position].must == 0
-  #   
-  #   # The set at the position described by the integer variable +position+ in 
-  #   # the enumeration +sets+ of set variables must be a subset of +set+.
-  #   sets[position].must_be.subset_of set
-  #   
-  #   # The same as above, but reified with the boolean variable +bool+.
-  #   sets[position].must_be.subset_of(set, :reify => bool)
-  class SelectExpressionStub < Gecode::Constraints::Set::CompositeStub
-    def constrain_equal(variable, params, constrain)
-      enum, index = @params.values_at(:lhs, :index)
-      if constrain
-        variable.must_be.subset_of enum.upper_bound_range
-      end
-
-      Gecode::Raw::selectSet(@model.active_space, enum.to_set_var_array, 
-        index.bind, variable.bind)
-    end
-  end
-  
-  # Describes a CompositeStub for the set union selection constraint, 
-  # which constrains the union of sets located at the positions 
-  # specified by a set variable in an enumeration of set variables.
-  # 
-  # == Examples
-  # 
-  #   # The sets in the enumeration set variable +sets+ located at the positions
-  #   # described by the set variable +selected_sets+ must have a union that's
-  #   # a superset of [0,4,17]. 
-  #   sets[selected_sets].union.must_be.superset_of [0,4,17]
-  #   
-  #   # The sets in the enumeration set variable +sets+ located at the positions
-  #   # described by the set variable +selected_sets+ must have a union that's
-  #   # disjoint with the set variable +set+.
-  #   sets[selected_sets].union.must_be.disjoint_with set
-  #   
-  #   # The same as above but reified with the boolean variable 
-  #   # +union_is_disjoint+.
-  #   sets[selected_sets].union.must_be.disjoint_with(set, 
-  #     :reify => union_is_disjoin)
-  class UnionExpressionStub < Gecode::Constraints::Set::CompositeStub
-    def constrain_equal(variable, params, constrain)
-      enum, indices = @params.values_at(:lhs, :indices)
-      if constrain
-        variable.must_be.subset_of enum.upper_bound_range
-      end
-      
-      Gecode::Raw::selectUnion(@model.active_space, enum.to_set_var_array,
-        indices.bind, variable.bind)
-    end
-  end
-  
-  # Describes a CompositeStub for the set intersection selection constraint, 
-  # which constrains the intersection of sets located at the positions 
-  # specified by a set variable in an enumeration of set variables.
-  # 
-  # Optionally a universe may also be specified.
-  # 
-  # == Examples
-  # 
-  #   # The sets in the enumeration set variable +sets+ located at the positions
-  #   # described by the set variable +selected_sets+ must have an intersection 
-  #   # that's a superset of [0,4,17]. 
-  #   sets[selected_sets].intersection.must_be.superset_of [0,4,17]
-  #   
-  #   # The sets in the enumeration set variable +sets+ located at the positions
-  #   # described by the set variable +selected_sets+ must have an intersection
-  #   # that's disjoint with the set variable +set+.
-  #   sets[selected_sets].intersection.must_be.disjoint_with set
-  #   
-  #   # The sets in the enumeration set variable +sets+ located at the positions
-  #   # described by the set variable +selected_sets+ must have an intersection
-  #   # that's disjoint with the set variable +set+ inside the universe 0..17.
-  #   sets[selected_sets].intersection(:with => 0..17).must_be.disjoint_with set
-  #   
-  #   # The sets in the enumeration set variable +sets+ located at the positions
-  #   # described by the set variable +selected_sets+ must have an intersection
-  #   # that's disjoint with the set variable +set+ inside the universe 
-  #   # described by the set variable +universe+.
-  #   sets[selected_sets].intersection(:with => universe).must_be.disjoint_with set
-  #   
-  #   
-  #   # The same as above but reified with the boolean variable 
-  #   # +intersection_is_disjoint+.
-  #   sets[selected_sets].intersection(:with => universe).must_be.disjoint_with(
-  #     set, :reifty => intersection_is_disjoin)
-  class IntersectionExpressionStub < Gecode::Constraints::Set::CompositeStub
-    def constrain_equal(variable, params, constrain)
-      enum, indices, universe = @params.values_at(:lhs, :indices, :universe)
-      # We can't do any useful constraining here since the empty intersection
-      # is the universe.
-      
-      if universe.nil?
-        Gecode::Raw::selectInter(@model.active_space, enum.to_set_var_array,
-          indices.bind, variable.bind)
-      else
-        Gecode::Raw::selectInterIn(@model.active_space, enum.to_set_var_array,
-          indices.bind, variable.bind, 
-          Gecode::Constraints::Util.constant_set_to_int_set(universe))
-      end
-    end
-  end
-  
-  # Describes a disjoint constraint, which constrains all set variable is an
-  # enumeration, at the position specified by a set variable, to be disjoint.
-  # 
-  # Does not support negation nor reification.
-  # 
-  # == Examples
-  # 
-  #   # The set variable located in the enumeration +sets+ at positions 
-  #   # described by +disjoint_set_positions+ must be disjoint.
-  #   sets[disjoint_set_positions].must_be.disjoint 
-  class DisjointConstraint < Gecode::Constraints::Constraint
-    def post
-      enum, indices = @params.values_at(:lhs, :indices)
-      Gecode::Raw.selectDisjoint(@model.active_space, enum.to_set_var_array,
-        indices.bind)
-    end
-  end
-end

data/specs/constraints/arithmetic.rb

@@ -1,351 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-require File.dirname(__FILE__) + '/constraint_helper'
-
-class ArithmeticSampleProblem < Gecode::Model
-  attr :numbers
-  attr :var
-  attr :var2
-  attr :var3
-  
-  def initialize
-    @numbers = int_var_array(4, 0..9)
-    @var = int_var(-9..9)
-    @var2 = int_var(0..9)
-    @var3 = int_var(0..9)
-    branch_on @numbers
-    branch_on wrap_enum([@var, @var2, @var3])
-  end
-end
-
-# Construct a method placing expectations for an arithmetic constraint with the 
-# specified arity (number of variables before must) and the specified name in 
-# Gecode.   
-def arithmetic_expectation(gecode_name, arity)
-  lambda do |relation, rhs, strength, kind, reif_var, negated|
-    # Construct the arguments expected to be passed to the Gecode variant of 
-    # the constraint.
-    rhs = an_instance_of(Gecode::Raw::IntVar) if rhs.respond_to? :bind
-    expected_gecode_arguments = [an_instance_of(Gecode::Raw::Space)]
-    arity.times do
-      expected_gecode_arguments << an_instance_of(Gecode::Raw::IntVar)
-    end
-    can_use_single_gecode_constraint = reif_var.nil? && !negated && 
-      relation == Gecode::Raw::IRT_EQ && !rhs.kind_of?(Fixnum)
-    if can_use_single_gecode_constraint
-      expected_gecode_arguments << rhs
-    else
-      expected_gecode_arguments << an_instance_of(Gecode::Raw::IntVar)
-    end
-    expected_gecode_arguments.concat([strength, kind])
-    
-    # Create the actual method producing the expectation.
-    @model.allow_space_access do
-      if reif_var.nil?
-        if can_use_single_gecode_constraint
-          Gecode::Raw.should_receive(gecode_name).once.with(
-            *expected_gecode_arguments)
-          Gecode::Raw.should_receive(:rel).exactly(0).times
-        else
-          Gecode::Raw.should_receive(gecode_name).once.with(
-            *expected_gecode_arguments)
-          Gecode::Raw.should_receive(:rel).once.with(
-            an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::IntVar), 
-            relation, rhs, strength, kind)
-        end
-      else
-        Gecode::Raw.should_receive(gecode_name).once.with(
-          *expected_gecode_arguments)
-        Gecode::Raw.should_receive(:rel).once.with(
-          an_instance_of(Gecode::Raw::Space), 
-          an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
-          an_instance_of(Gecode::Raw::BoolVar),
-          strength, kind)
-      end
-    end
-  end
-end
-
-# Requires @stub, @target, @model and @expect.
-describe 'arithmetic constraint', :shared => true do
-  before do
-    # For constraint option spec.
-    @invoke_options = lambda do |hash| 
-      @stub.must_be.greater_than(@target, hash) 
-      @model.solve!
-    end
-    @expect_options = option_expectation do |strength, kind, reif_var|
-      @expect.call(Gecode::Raw::IRT_GR, @target, strength, kind, reif_var, 
-        false)
-    end
-    
-    # For composite spec.
-    @invoke_relation = lambda do |relation, target, negated|
-      if negated
-        @stub.must_not.send(relation, target)
-      else
-        @stub.must.send(relation, target)
-      end
-      @model.solve!
-    end
-    @expect_relation = lambda do |relation, target, negated|
-      @expect.call(relation, target, Gecode::Raw::ICL_DEF, Gecode::Raw::PK_DEF,
-        nil, negated)
-    end
-  end
-  
-  it 'should translate reification when using equality' do
-    bool_var = @model.bool_var
-    @expect.call(Gecode::Raw::IRT_EQ, @target, Gecode::Raw::ICL_DEF, 
-      Gecode::Raw::PK_DEF, bool_var, false)
-    @stub.must_be.equal_to(@target, :reify => bool_var)
-    @model.solve!
-  end
-  
-  it_should_behave_like 'composite constraint'
-  it_should_behave_like 'reifiable constraint'
-end
-
-describe Gecode::Constraints::IntEnum::Arithmetic, ' (max)' do
-  before do
-    @model = ArithmeticSampleProblem.new
-    @numbers = @model.numbers
-    @target = @var = @model.var
-    @stub = @numbers.max
-    
-    # Creates an expectation corresponding to the specified input.
-    @expect = lambda do |relation, rhs, strength, kind, reif_var, negated|
-      @model.allow_space_access do
-        rhs = an_instance_of(Gecode::Raw::IntVar) if rhs.respond_to? :bind
-        if reif_var.nil?
-          if !negated and relation == Gecode::Raw::IRT_EQ and 
-              !rhs.kind_of? Fixnum
-            Gecode::Raw.should_receive(:max).once.with(
-              an_instance_of(Gecode::Raw::Space), 
-              an_instance_of(Gecode::Raw::IntVarArray), 
-              rhs, strength, kind)
-            Gecode::Raw.should_receive(:rel).exactly(0).times
-          else
-            Gecode::Raw.should_receive(:max).once.with(
-              an_instance_of(Gecode::Raw::Space), 
-              an_instance_of(Gecode::Raw::IntVarArray), 
-              an_instance_of(Gecode::Raw::IntVar), 
-              strength, kind)
-            Gecode::Raw.should_receive(:rel).once.with(
-              an_instance_of(Gecode::Raw::Space), 
-              an_instance_of(Gecode::Raw::IntVar), 
-              relation, rhs, strength, kind)
-          end
-        else
-          Gecode::Raw.should_receive(:max).once.with(
-            an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::IntVarArray), 
-            an_instance_of(Gecode::Raw::IntVar), 
-            strength, kind)
-          Gecode::Raw.should_receive(:rel).once.with(
-            an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
-            an_instance_of(Gecode::Raw::BoolVar),
-            strength, kind)
-        end
-      end
-    end
-  end
-  
-  it 'should constrain the maximum value' do
-    @numbers.max.must > 5
-    @model.solve!.numbers.values.max.should > 5
-  end
-  
-  it_should_behave_like 'arithmetic constraint'
-end
-
-describe Gecode::Constraints::IntEnum::Arithmetic, ' (min)' do
-  before do
-    @model = ArithmeticSampleProblem.new
-    @numbers = @model.numbers
-    @target = @var = @model.var
-    @stub = @numbers.min
-    
-    # Creates an expectation corresponding to the specified input.
-    @expect = lambda do |relation, rhs, strength, kind, reif_var, negated|
-      @model.allow_space_access do
-        rhs = an_instance_of(Gecode::Raw::IntVar) if rhs.respond_to? :bind
-       if reif_var.nil?
-          if !negated and relation == Gecode::Raw::IRT_EQ and 
-              !rhs.kind_of? Fixnum
-            Gecode::Raw.should_receive(:min).once.with(
-              an_instance_of(Gecode::Raw::Space), 
-              an_instance_of(Gecode::Raw::IntVarArray), 
-              rhs, strength, kind)
-            Gecode::Raw.should_receive(:rel).exactly(0).times
-          else
-            Gecode::Raw.should_receive(:min).once.with(
-              an_instance_of(Gecode::Raw::Space), 
-              an_instance_of(Gecode::Raw::IntVarArray), 
-              an_instance_of(Gecode::Raw::IntVar), 
-              strength, kind)
-            Gecode::Raw.should_receive(:rel).once.with(
-              an_instance_of(Gecode::Raw::Space), 
-              an_instance_of(Gecode::Raw::IntVar), 
-              relation, rhs, strength, kind)
-          end
-        else
-          Gecode::Raw.should_receive(:min).once.with(
-            an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::IntVarArray), 
-            an_instance_of(Gecode::Raw::IntVar), 
-            strength, kind)
-          Gecode::Raw.should_receive(:rel).once.with(
-            an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
-            an_instance_of(Gecode::Raw::BoolVar),
-            strength, kind)
-        end
-      end
-    end
-  end
-  
-  it 'should constrain the minimum value' do
-    @numbers.min.must > 5
-    @model.solve!.numbers.values.min.should > 5
-  end
-  
-  it_should_behave_like 'arithmetic constraint'
-end
-
-describe Gecode::Constraints::Int::Arithmetic, ' (abs)' do
-  before do
-    @model = ArithmeticSampleProblem.new
-    @var = @model.var
-    @target = @model.var2
-    @stub = @var.abs
-    
-    # Creates an expectation corresponding to the specified input.
-    @expect = lambda do |relation, rhs, strength, kind, reif_var, negated|
-      @model.allow_space_access do
-        rhs = an_instance_of(Gecode::Raw::IntVar) if rhs.respond_to? :bind
-        if reif_var.nil?
-          if !negated and relation == Gecode::Raw::IRT_EQ and 
-              !rhs.kind_of? Fixnum
-            Gecode::Raw.should_receive(:abs).once.with(
-              an_instance_of(Gecode::Raw::Space),
-              an_instance_of(Gecode::Raw::IntVar), 
-              rhs, strength, kind)
-            Gecode::Raw.should_receive(:rel).exactly(0).times
-          else
-            Gecode::Raw.should_receive(:abs).once.with(
-              an_instance_of(Gecode::Raw::Space),
-              an_instance_of(Gecode::Raw::IntVar), 
-              an_instance_of(Gecode::Raw::IntVar), 
-              strength, kind)
-            Gecode::Raw.should_receive(:rel).once.with(
-              an_instance_of(Gecode::Raw::Space), 
-              an_instance_of(Gecode::Raw::IntVar), 
-              relation, rhs, strength, kind)
-          end
-        else
-          Gecode::Raw.should_receive(:abs).once.with(
-            an_instance_of(Gecode::Raw::Space),
-            an_instance_of(Gecode::Raw::IntVar), 
-            an_instance_of(Gecode::Raw::IntVar), 
-            strength, kind)
-          Gecode::Raw.should_receive(:rel).once.with(
-            an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
-            an_instance_of(Gecode::Raw::BoolVar), 
-            strength, kind)
-        end
-      end
-    end
-  end
-  
-  it 'should constrain the absolute value' do
-    @var.must < 0
-    @var.abs.must == 5
-    @model.solve!.var.value.should == -5
-  end
-  
-  it_should_behave_like 'arithmetic constraint'
-end
-
-describe Gecode::Constraints::Int::Arithmetic, ' (multiplication)' do
-  before do
-    @model = ArithmeticSampleProblem.new
-    @var = @model.var
-    @var2 = @model.var2
-    @stub = @var * @var2
-    @target = @model.var3
-    
-    @expect = arithmetic_expectation(:mult, 2)
-  end
-  
-  it 'should constrain the value of the multiplication' do
-    (@var * @var2).must == 56
-    sol = @model.solve!
-    [sol.var.value, sol.var2.value].sort.should == [7, 8]
-  end
-  
-  it 'should not interfere with other defined multiplication methods' do
-    (@var * :foo).should be_nil
-  end
-  
-  it_should_behave_like 'arithmetic constraint'
-end
-
-describe Gecode::Constraints::Int::Arithmetic, ' (squared)' do
-  before do
-    @model = ArithmeticSampleProblem.new
-    @var = @model.var
-    @stub = @var.squared
-    @target = @model.var2
-    
-    @expect = arithmetic_expectation(:sqr, 1)
-  end
-  
-  it 'should constrain the value of the variable squared' do
-    @var.squared.must == 9
-    sol = @model.solve!
-    sol.var.value.abs.should == 3
-  end
-  
-  it_should_behave_like 'arithmetic constraint'
-end
-
-describe Gecode::Constraints::Int::Arithmetic, ' (square root)' do
-  before do
-    @model = ArithmeticSampleProblem.new
-    @var = @model.var
-    @stub = @var.square_root
-    @target = @model.var2
-    
-    @expect = arithmetic_expectation(:sqrt, 1)
-  end
-  
-  it 'should constrain the square root of the variable' do
-    @var.square_root.must == 3
-    sol = @model.solve!
-    Math.sqrt(sol.var.value).floor.should == 3
-  end
-  
-  it 'should constrain the square root of the variable (2)' do
-    @var.square_root.must == 0
-    sol = @model.solve!
-    Math.sqrt(sol.var.value).floor.should == 0
-  end
-  
-  it 'should constrain the square root of the variable (3)' do
-    @var.must < 0
-    @var.square_root.must == 0
-    @model.solve!.should be_nil
-  end
-  
-  it 'should round down the square root' do
-    @var.must > 4
-    @var.square_root.must == 2
-    sol = @model.solve!
-    sol.var.value.should be_between(5,8)
-  end
-  
-  it_should_behave_like 'arithmetic constraint'
-end