# module Gecode::Set::SetOperand

A SetOperand is a combination of operands on which the constraints defined in SetConstraintReceiver can be placed.

Set operands can be created either by using Gecode::Mixin#set_var et al, or by using properties that produce set operands. The operands, no matter how they were created, all respond to the properties defined by SetOperand.

#### Examples ¶ ↑

Produces a single set operand (more specifically a SetVar), with greatest lower bound {0} and least upper bound {0, 1, 2}, inside a problem formulation, using Gecode::Mixin#set_var:

```set_operand = set_var(0, 0..2)
```

Uses the #union property to produce a new set operand representing the union between `set_operand1` and `set_operand2`:

```new_set_operand = set_operand1.union(set_operand2)
```

Uses the SetEnumOperand#union property to produce a new set operand representing the union of the set operands in the enumeration `set_enum`:

```new_set_operand = set_enum.union
```

Uses the SetEnumOperand#[] property to produce a new set operand representing the set operand at the index decided by `int_operand` (which can change during search) in the enumeration `set_enum`:

```new_set_operand = set_enum[int_operand]
```

### Public Instance Methods

disjoint_union(set_operand_or_constant_set) click to toggle source

Produces a new SetOperand representing the disjoint union between this operand and `set_operand_or_constant_set`. The disjoint union is the union of the disjoint parts of the sets.

#### Examples ¶ ↑

```# The disjoint union between +set1+ and +set2+.
set1.disjoint_union set2

# The disjoint union between +set+ and {1, 3, 5}.
set.disjoint_union [1,3,5]
```
```# File lib/gecoder/interface/constraints/set/operation.rb, line 28
def disjoint_union(set_operand_or_constant_set)
set_operation(:disjoint_union, set_operand_or_constant_set)
end```
elements() click to toggle source

Produces a SetElementsOperand on which relation constraints can be placed that constrain all elements in the set.

#### Examples ¶ ↑

```# The elements of +set+.
set.elements
```
```# File lib/gecoder/interface/constraints/set_elements_constraints.rb, line 91
def elements
Gecode::SetElements::SetElementsOperand.new(self)
end```
intersection(set_operand_or_constant_set) click to toggle source

Produces a new SetOperand representing the intersection between this operand and `set_operand_or_constant_set`.

#### Examples ¶ ↑

```# The intersection between +set1+ and +set2+.
set1.intersection set2

# The intersection between +set+ and {1, 3, 5}.
set.intersection [1,3,5]
```
```# File lib/gecoder/interface/constraints/set/operation.rb, line 42
def intersection(set_operand_or_constant_set)
set_operation(:intersection, set_operand_or_constant_set)
end```
max() click to toggle source

Produces an IntOperand representing the maximum of the set.

#### Examples ¶ ↑

```# The maximum of +set+.
set.max
```
```# File lib/gecoder/interface/constraints/set/connection.rb, line 19
def max
Connection::SetMaxOperand.new(@model, self)
end```
min() click to toggle source

Produces an IntOperand representing the minimum of the set.

#### Examples ¶ ↑

```# The minimum of +set+.
set.min
```
```# File lib/gecoder/interface/constraints/set/connection.rb, line 9
def min
Connection::SetMinOperand.new(@model, self)
end```
minus(set_operand_or_constant_set) click to toggle source

Produces a new SetOperand representing this operand minus `set_operand_or_constant_set`.

#### Examples ¶ ↑

```# +set1+ minus +set2+.
set1.minus set2

# +set+ minus {1, 3, 5}.
set.minus [1,3,5]
```
```# File lib/gecoder/interface/constraints/set/operation.rb, line 56
def minus(set_operand_or_constant_set)
set_operation(:minus, set_operand_or_constant_set)
end```
size() click to toggle source

Produces an IntOperand representing the size of the set.

#### Examples ¶ ↑

```# The size of +set+.
set.size
```
```# File lib/gecoder/interface/constraints/set/cardinality.rb, line 9
def size
Cardinality::SetSizeOperand.new(@model, self)
end```
sum(options = {:weights => weights = Hash.new(1)}) click to toggle source

Produces an IntOperand representing the sum of the values in the set. One of the following options may also be given:

:weights

Produces the weighted sum using the specified hash of weights. The hash should map each value to that value’s weight.

:substitutions

Produces the sum of the set with all elements replaced according to the hash.

Elements not included in the weights or substitutions hash are removed from the upper bound of the set.

#### Examples ¶ ↑

```# The sum of +set+.
set.sum

# The sum of +set+ with primes < 10 given twice the weight.
set.sum(:weights => {2 => 2, 3 => 2, 5 => 2, 7 => 2})

# The sum of +set+ with odd values in [1,6] being counted as 1.
set.sum(:substitutions => {1 => 1, 3 => 1, 5 => 1})
```
```# File lib/gecoder/interface/constraints/set/connection.rb, line 44
def sum(options = {:weights => weights = Hash.new(1)})
if options.empty? or options.keys.size > 1
raise ArgumentError, 'At most one of the options :weights and ' +
':substitutions may be specified.'
end

case options.keys.first
when :substitutions
subs = options[:substitutions]
when :weights
weights = options[:weights]
subs = Hash.new do |hash, key|
if weights[key].nil?
hash[key] = nil
else
hash[key] = key * weights[key]
end
end
else raise ArgumentError, "Unrecognized option #{options.keys.first}."
end
Connection::SetSumOperand.new(@model, self, subs)
end```
union(set_operand_or_constant_set) click to toggle source

Produces a new SetOperand representing the union between this operand and `set_operand_or_constant_set`.

#### Examples ¶ ↑

```# The union between +set1+ and +set2+.
set1.union set2

# The union between +set+ and {1, 3, 5}.
set.union [1,3,5]
```
```# File lib/gecoder/interface/constraints/set/operation.rb, line 13
def union(set_operand_or_constant_set)
set_operation(:union, set_operand_or_constant_set)
end```