Module: Gecode::FixnumEnum::FixnumEnumOperand
- Includes:
- Operand
- Included in:
- Dummy, Gecode::FixnumEnumMethods
- Defined in:
- lib/gecoder/interface/constraints/fixnum_enum_constraints.rb,
lib/gecoder/interface/constraints/fixnum_enum/element.rb,
lib/gecoder/interface/constraints/fixnum_enum/operation.rb
Overview
A FixnumEnumOperand is a enumeration of Fixnum on which the constraints defined in FixnumEnumConstraintReceiver can be placed. They typically service as constant arrays or constant sets.
The fixnum enumeration operands are created by wrapping an enumeration of fixnum Gecode::Mixin#wrap_enum. The enumerations created that way all respond to the properties defined by FixnumEnumOperand.
Examples
Uses Gecode::Mixin#wrap_enum inside a problem formulation to create a FixnumEnumOperand from an existing enumeration of Fixnum:
fixnum_enum = wrap_enum([3, 5, 7])
– Classes that mix in FixnumEnumOperand must define #model.
Class Method Summary collapse
-
.included(enum_mod) ⇒ Object
This adds the adder for the methods in the modules including it.
Instance Method Summary collapse
-
#disjoint_union(set_operand) ⇒ Object
Produces a new SetOperand representing the disjoint union between this operand, interpreted as a constant set, and
set_operand
. -
#intersection(set_operand) ⇒ Object
Produces a new SetOperand representing the intersection between this operand, interpreted as a constant set, and
set_operand
. -
#method_missing(method, *args) ⇒ Object
:nodoc:.
-
#minus(set_operand) ⇒ Object
Produces a new SetOperand representing this operand, interpreted as a constant set, minus
set_operand
. -
#union(set_operand) ⇒ Object
Produces a new SetOperand representing the union between this operand, interpreted as a constant set, and
set_operand
.
Methods included from Operand
Dynamic Method Handling
This class handles dynamic methods through the method_missing method
#method_missing(method, *args) ⇒ Object
:nodoc:
24 25 26 27 28 29 30 31 |
# File 'lib/gecoder/interface/constraints/fixnum_enum_constraints.rb', line 24 def method_missing(method, *args) #:nodoc: if Gecode::FixnumEnum::Dummy.instance_methods.include? method.to_s # Delegate to the fixnum enum. to_fixnum_enum.method(method).call(*args) else super end end |
Class Method Details
.included(enum_mod) ⇒ Object
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.
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
# File 'lib/gecoder/interface/constraints/fixnum_enum/element.rb', line 6 def self.included(enum_mod) #:nodoc: enum_mod.module_eval do # Now we enter the module FixnumEnumOperands is mixed into. class << self alias_method :pre_element_included, :included def included(mod) #:nodoc: mod.module_eval do if instance_methods.include? '[]' alias_method :pre_element_access, :[] end # Produces an IntOperand representing the # i:th constant integer in the enumeration, where i is the # value of the integer operand used as index. Think of it # as array access in the world of constraint programming. # # ==== Examples # # # The price of +selected_item+ as described by +prices+ . # prices = wrap_enum([500, 24, 4711, 412, 24]) # prices[selected_item] # def [](*vars) if vars.first.respond_to? :to_int_var return Element::ElementIntOperand.new( self, vars.first, model) else pre_element_access(*vars) if respond_to? :pre_element_access end end end pre_element_included(mod) end end end end |
Instance Method Details
#disjoint_union(set_operand) ⇒ Object
Produces a new SetOperand representing the disjoint union between this operand, interpreted as a constant set, and set_operand
. The disjoint union is the union of the disjoint parts of the sets.
Examples
# The disjoint union between +fixnum_enum+ and +set+.
fixnum_enum.disjoint_union set
23 24 25 |
# File 'lib/gecoder/interface/constraints/fixnum_enum/operation.rb', line 23 def disjoint_union(set_operand) set_operation(:disjoint_union, set_operand) end |
#intersection(set_operand) ⇒ Object
Produces a new SetOperand representing the intersection between this operand, interpreted as a constant set, and set_operand
.
Examples
# The intersection between +fixnum_enum+ and +set+.
fixnum_enum.intersection set
35 36 37 |
# File 'lib/gecoder/interface/constraints/fixnum_enum/operation.rb', line 35 def intersection(set_operand) set_operation(:intersection, set_operand) end |
#minus(set_operand) ⇒ Object
Produces a new SetOperand representing this operand, interpreted as a constant set, minus set_operand
.
Examples
# +fixnum_enum+ minus +set+.
fixnum_enum.minus set
46 47 48 |
# File 'lib/gecoder/interface/constraints/fixnum_enum/operation.rb', line 46 def minus(set_operand) set_operation(:minus, set_operand) end |
#union(set_operand) ⇒ Object
Produces a new SetOperand representing the union between this operand, interpreted as a constant set, and set_operand
.
Examples
# The union between +fixnum_enum+ and +set+.
fixnum_enum.union set
10 11 12 |
# File 'lib/gecoder/interface/constraints/fixnum_enum/operation.rb', line 10 def union(set_operand) set_operation(:union, set_operand) end |