Integer operands are created either by creating integer variables (which are the simplest integer operands) or by using operand properties that produce integer operands.

The simplest integer operands, integer variables, can be created using
`Mixin#int_var`

. The method takes one argument, the domain of the
integer variable. The domain represents the values that the variable can
take. A variable with domain 0..9 can for instance take any value in the
range 0 to 9.

int_operand = int_var(0..9) # Creates an integer variable with domain 0..9.

A couple of examples of properties that produce integer operands include
the `IntOperand#+`

property, which produces a new integer operand
representing the sum of two integer operands:

new_int_operand = int_operand1 + int_operand2

The `IntEnumOperand#max`

property produces a new integer operand
representing the maximum value of the integer operands in an
enumeration:

new_int_operand = int_enum.max

Generated from `IntConstraintReceiver`

.

`==`

`==(int_operand_or_fixnum, options = {})`

Constrains the integer operand to equal `int_operand_or_fixnum`

. #equal and
#equal_to are aliases of this method.

# +int1+ must equal +int2+ int1.must == int2 # +int+ must equal 17 int.must == 17 # +int1+ must equal +int2+. We reify the constraint with # +bool+ and select +domain+ as strength. int1.must.equal(int2, :reify => bool, :strength => :domain)

`>`

`>(int_operand_or_fixnum, options = {})`

Constrains the integer operand to be strictly greater than
`int_operand_or_fixnum`

. #greater and #greater_than are aliases of this
method.

# +int1+ must be strictly greater than +int2+ int1.must > int2 # +int+ must be strictly greater than 17 int.must > 17 # +int1+ must be strictly greater than +int2+. We reify the # constraint with +bool+ and select +domain+ as strength. int1.must_be.greater_than(int2, :reify => bool, :strength => :domain)

`>=`

`>=(int_operand_or_fixnum, options = {})`

Constrains the integer operand to be greater than or equal to
`int_operand_or_fixnum`

. #greater_or_equal and #greater_than_or_equal_to
are aliases of this method.

# +int1+ must be greater than or equal to +int2+ int1.must >= int2 # +int+ must be greater than or equal to 17 int.must >= 17 # +int1+ must be greater than or equal to +int2+. We reify the # constraint with +bool+ and select +domain+ as strength. int1.must.greater_or_equal(int2, :reify => bool, :strength => :domain)

`<`

`<(int_operand_or_fixnum, options = {})`

Constrains the integer operand to be strictly less than
`int_operand_or_fixnum`

. #lesser and #lesser_than are aliases of this
method.

# +int1+ must be strictly less than +int2+ int1.must < int2 # +int+ must be strictly less than 17 int.must < 17 # +int1+ must be strictly less than +int2+. We reify the # constraint with +bool+ and select +domain+ as strength. int1.must_be.less_than(int2, :reify => bool, :strength => :domain)

`<=`

`<=(int_operand_or_fixnum, options = {})`

Constrains the integer operand to be less than or equal to
`int_operand_or_fixnum`

. #less_or_equal and #less_than_or_equal_to are
aliases of this method.

# +int1+ must be less than or equal to +int2+ int1.must <= int2 # +int+ must be less than or equal to 17 int.must <= 17 # +int1+ must be less than or equal to +int2+. We reify the # constraint with +bool+ and select +domain+ as strength. int1.must.less_or_equal(int2, :reify => bool, :strength => :domain)

`in`

`in(domain, options = {})`

Creates a domain constraint using the specified domain, specified as an enumeration of integers. The integer operand is constrained to take a value in the domain. Domains should be specified as ranges if possible.

# +x+ must be in the range 1..10 x.must_be.in 1..10 # +x+ must not be in the range -5...5 x.must_not_be.in -5...5 # Specifies the above, but reifies the constraint with the boolean # operand +bool+ and specified +value+ as strength. x.must_not_be.in(-5...5, :reify => bool, :strength => :value) # +x+ must be in the enumeration [3,5,7]. x.must_be.in [3,5,7] # +x+ must not be in the enumeration [5,6,7,17]. x.must_not_be.in [5,6,7,17] # Specifies the above, but reifies the constraint with the boolean # operand +bool+ and specified +value+ as strength. x.must_not_be.in([5,6,7,17], :reify => bool, :strength => :value)

Generated from `IntOperand`

.

`+`

`+(int_operand_or_fixnum)`

Produces a new IntOperand representing this operand plus
`int_operand_or_fixnum`

.

# +int1+ plus +int2+ int1 + int2 # +int+ plus 17 int + 17

`-`

`-(int_operand_or_fixnum)`

Produces a new IntOperand representing this operand minus
`int_operand_or_fixnum`

.

# +int1+ minus +int2+ int1 - int2 # +int+ minus 17 int - 17

`*`

`*(fixnum)`

Produces a new IntOperand representing this operand times a constant.

# +int+ times 17 int * 17

`*(int_operand)`

Produces a new IntOperand representing this operand times `int_operand`

.

```
# The value of +int_op1+ times +int_op2+.
int_op1 * int_op2
```

`abs`

`abs()`

Produces an IntOperand representing the absolute value of this operand.

```
# The absolute value of +int_op+.
int_op.abs
```

`square_root`

`square_root()`

Produces an IntOperand representing the square root of this operand rounded down.

```
# The square root of +int_op+, rounded down.
int_op.square_root
```

`squared`

`squared()`

Produces an IntOperand representing this operand squared.

```
# The value of +int_op*int_op+.
int_op.squared
```