Class: Gecode::Set::SetConstraintReceiver

Inherits:
ConstraintReceiver show all
Defined in:
lib/gecoder/interface/constraints/set_var_constraints.rb,
lib/gecoder/interface/constraints/set/domain.rb,
lib/gecoder/interface/constraints/set/channel.rb,
lib/gecoder/interface/constraints/set/include.rb,
lib/gecoder/interface/constraints/set/relation.rb

Overview

SetConstraintReceiver contains all constraints that can be placed on a SetOperand.

Constraints are placed by calling SetOperand#must (or any other of the variations defined in Operand), which produces a SetConstraintReceiver from which the desired constraint can be used.

Most constraint accept :reify option. See ConstraintReceiver for more information.

Examples

Constrains set_operand to be a subset of 1, 2 using an alias of SetConstraintReceiver#subset:

set_operand.must_be.subset_of 0..2

Constrains the union of set_operand1 and set_operand2 to a subset of 1, 2 using the SetOperand#union property and SetConstraintReceiver#subset:

set_operand1.union(set_operand2).must_be.subset_of 0..2

Constrains the union of the set operands in set_enum to not equal 1, 2 by using the SetEnumOperand#union property and an alias of SetConstraintReceiver#==:

set_enum.union.must_not == 0..2

The same as above, but alsa specifying that the constraint should be reified with bool_operand:

set_enum.union.must_not.equal(0..2, :reify => bool_operand)

Instance Method Summary collapse

Constructor Details

#initialize(model, params) ⇒ SetConstraintReceiver

Raises TypeError unless the left hand side is a set operand.



210
211
212
213
214
215
216
 
# File 'lib/gecoder/interface/constraints/set_var_constraints.rb', line 210

def initialize(model, params) #:nodoc:
  super

  unless params[:lhs].respond_to? :to_set_var
    raise TypeError, 'Must have set operand as left hand side.'
  end
end

Instance Method Details

#==(set_operand, options = {}) ⇒ Object

Constrains the set operand to equal set_operand.

Examples

set1 must equal set2

set1.must == set2

set1 must equal set2. Reify the constraint with the

boolean operand bool.

set1.must.equal(set2, :reify => bool)



16
17
18
 
# File 'lib/gecoder/interface/constraints/set/domain.rb', line 16

def ==(constant_set, options = {})
  add_domain_constraint(:==, constant_set, options)
end

#channel(bool_enum, options = {}) ⇒ Object

Constrains this set to channel bool_enum. The set is constrained to include value i exactly when the operand at index i in the boolean enumeration is true.

Neither reification nor negation is supported. The boolean enum and set can be interchanged.

Examples

Constrains the enumeration of boolean operands called bools to at

least have the first and third operands set to true

set.must_be.superset_of [0, 2] set.must.channel bools

An alternative way of writing the above.

set.must_be.superset_of [0, 2] bools.must.channel set



20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
# File 'lib/gecoder/interface/constraints/set/channel.rb', line 20

def channel(bool_enum, options = {})
  if @params[:negate]
    raise Gecode::MissingConstraintError, 'A negated channel constraint ' + 
      'is not implemented.'
  end
  if options.has_key? :reify
    raise ArgumentError, 'The channel constraint does not support the ' + 
      'reification option.'
  end
  unless bool_enum.respond_to? :to_bool_enum
    raise TypeError, 'Expected an enum of bool operands, ' + 
      "got #{bool_enum.class}."
  end
  
  @params.update(:rhs => bool_enum)
  @params.update Gecode::Set::Util.decode_options(options)
  @model.add_constraint Channel::ChannelConstraint.new(@model, @params)
end

#complement(set_operand, options = {}) ⇒ Object

Constrains the set operand to be the complement of set_operand.

Examples

set1 must be the complement of set2

set1.must_be.complement_of set2

set1 must be the complement of set2. Reify the constraint

with the boolean operand bool.

set1.must_be.complement(set2, :reify => bool)



96
97
98
 
# File 'lib/gecoder/interface/constraints/set/domain.rb', line 96

def complement(constant_set, options = {})
  add_domain_constraint(:complement, constant_set, options)
end

#disjoint(set_operand, options = {}) ⇒ Object

Constrains the set operand to be disjoint with set_operand.

Examples

set1 must be disjoint with set2

set1.must_be.disjoint_with set2

set1 must be disjoint with set2. Reify the constraint

with the boolean operand bool.

set1.must_be.disjoint(set2, :reify => bool)



76
77
78
 
# File 'lib/gecoder/interface/constraints/set/domain.rb', line 76

def disjoint(constant_set, options = {})
  add_domain_constraint(:disjoint, constant_set, options)
end

#include(int_enum) ⇒ Object

Constrains this set to include the values of int_enum.

The constraint has the side effect of sorting the integer operands in a non-descending order. It does not support reification nor negation.

Examples

Constrain set to include the values of all operands in

int_enum.

set.must.include int_enum



13
14
15
16
17
18
19
20
21
22
23
24
 
# File 'lib/gecoder/interface/constraints/set/include.rb', line 13

def include(int_enum)
  unless int_enum.respond_to? :to_int_enum
    raise TypeError, "Expected int var enum, got #{int_enum.class}."
  end
  if @params[:negate]
    raise Gecode::MissingConstraintError, 'A negated include is not ' + 
      'implemented.'
  end
  
  @params.update(:variables => int_enum)
  @model.add_constraint Connection::IncludeConstraint.new(@model, @params)
end

#pre_relation_complement ⇒ Object

Constrains the set operand to be the complement of constant_set.

Examples

set must be the complement of [1,2,5]

set.must_be.complement_of [1,2,5]

set must be the complement of 1..67

set.must_be.complement_of 1..67

set must not be the complement of [0].

set.must_not_be.complement_of 0

set must be the complement of [1,3,5,7]. The constraint is

reified with the boolean operand bool.

set.must_be.complement_of([1.3.5.7], :reify => bool)



79
80
81
 
# File 'lib/gecoder/interface/constraints/set/relation.rb', line 79

def complement(constant_set, options = {})
  add_domain_constraint(:complement, constant_set, options)
end

#pre_relation_disjoint ⇒ Object

Constrains the set operand to be disjoint with constant_set.

Examples

set must be disjoint with [1,2,5]

set.must_be.disjoint_with [1,2,5]

set must be disjoint with 1..67

set.must_be.disjoint_with 1..67

set must not be disjoint with [0].

set.must_not_be.disjoint_with 0

set must be disjoint with [1,3,5,7]. The constraint is reified with

the boolean operand bool.

set.must_be.disjoint_with([1.3.5.7], :reify => bool)



60
61
62
 
# File 'lib/gecoder/interface/constraints/set/relation.rb', line 60

def disjoint(constant_set, options = {})
  add_domain_constraint(:disjoint, constant_set, options)
end

#pre_relation_equality ⇒ Object

Constrains the set operand to have a domain equal to constant_set.

Examples

set must equal [1,2,5]

set.must == [1,2,5]

set must not equal 1..67

set.must_not == 1..67

set must equal the singleton set 0. The constraint is reified with

the boolean operand is_singleton_zero.

set.must.equal(0, :reify => is_singleton_zero)



3
4
5
 
# File 'lib/gecoder/interface/constraints/set/relation.rb', line 3

def ==(constant_set, options = {})
  add_domain_constraint(:==, constant_set, options)
end

#pre_relation_subset ⇒ Object

Constrains the set operand to be a subset of constant_set.

Examples

set must be a subset of [1,2,5]

set.must_be.subset_of [1,2,5]

set must be a subset of 1..67

set.must_be.subset_of 1..67

set must not be a subset of [0].

set.must_not_be.subset_of 0

set must be a subset of [1,3,5,7]. The constraint is reified with

the boolean operand bool.

set.must_be.subset_of([1.3.5.7], :reify => bool)



41
42
43
 
# File 'lib/gecoder/interface/constraints/set/relation.rb', line 41

def subset(constant_set, options = {})
  add_domain_constraint(:subset, constant_set, options)
end

#pre_relation_superset ⇒ Object

Constrains the set operand to be a superset of constant_set.

Examples

set must be a superset of [1,2,5]

set.must_be.superset_of [1,2,5]

set must be a superset of 1..67

set.must_be.superset_of 1..67

set must not be a superset of [0].

set.must_not_be.superset_of 0

set must be a superset of [1,3,5,7]. The constraint is reified with

the boolean operand bool.

set.must_be.superset_of([1.3.5.7], :reify => bool)



22
23
24
 
# File 'lib/gecoder/interface/constraints/set/relation.rb', line 22

def superset(constant_set, options = {})
  add_domain_constraint(:superset, constant_set, options)
end

#subset(set_operand, options = {}) ⇒ Object

Constrains the set operand to be a subeset of set_operand.

Examples

set1 must be a subset of set2

set1.must_be.subset_of == set2

set1 must be a subset of set2. Reify the constraint

with the boolean operand bool.

set1.must_be.subset(set2, :reify => bool)



56
57
58
 
# File 'lib/gecoder/interface/constraints/set/domain.rb', line 56

def subset(constant_set, options = {})
  add_domain_constraint(:subset, constant_set, options)
end

#superset(set_operand, options = {}) ⇒ Object

Constrains the set operand to be a superset of set_operand.

Examples

set1 must be a superset of set2

set1.must_be.superset_of set2

set1 must be a superset of set2. Reify the constraint

with the boolean operand bool.

set1.must_be.superset(set2, :reify => bool)



36
37
38
 
# File 'lib/gecoder/interface/constraints/set/domain.rb', line 36

def superset(constant_set, options = {})
  add_domain_constraint(:superset, constant_set, options)
end