Boolean Operands

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

Examples of Boolean Operands

The simplest boolean operands, boolean variables, can be created using Mixin#bool_var.

bool_operand = bool_var

A couple of examples of properties that produce boolean operands include the BoolOperand#& property, which produces a new boolean operand representing the AND operation applied to two boolean operands:

new_bool_operand = bool_operand1 + bool_operand2

The BoolEnumOperand#conjunction property produces a new boolean operand representing the conjunction of all boolean operands in an enumeration:

new_bool_operand = bool_enum.conjunction

Constraints

true

true(options = {})

Constrains the boolean operand to be true.

Examples
# +b1+ and +b2+ must be true.
(b1 & b2).must_be.true

# (+b1+ implies +b2+) and (+b3+ implies +b2+) must be true.
((b1.implies b2) & (b3.implies b2)).must_be.true

# +b1+ and +b2+ must be true. We reify it with +bool+ and select the
# strength +domain+.
(b1 & b2).must_be.true(:reify => bool, :strength => :domain)

false

false(options = {})

Constrains the boolean operand to be false.

Examples
# +b1+ and +b2+ must be false.
(b1 & b2).must_be.false

# (+b1+ implies +b2+) and (+b3+ implies +b2+) must be false.
((b1.implies b2) & (b3.implies b2)).must_be.false

# +b1+ and +b2+ must be false. We reify it with +bool+ and select the
# strength +domain+.
(b1 & b2).must_be.false(:reify => bool, :strength => :domain)

==

==(bool_op, options = {})

Constrains the boolean operand to be equal to bool_op. Any of ==, equal and equal_to may be used for equality.

Examples
# +b1+ and +b2+ must equal +b1+ or +b2+.
(b1 & b2).must == (b1 | b2)

# +b1+ and +b2+ must not equal +b3+. We reify it with +bool+ and select
# the strength +domain+.
(b1 & b2).must_not.equal(b3, :reify => bool, :select => :domain)

imply

imply(bool_op, options = {})

Constrains the boolean operand to imply bool_op.

Examples
# +b1+ must imply +b2+
b1.must.imply b2

# +b1+ and +b2+ must not imply +b3+. We reify it with +bool+ and select
# +domain+ as strength.
(b1 & b2).must_not.imply(b3, :reify => bool, :strength => :domain)

Properties

Generated from BoolOperand.

&

&(bool_op)

Produces a new BoolOperand representing this operand AND bool_op.

Examples
# (+b1+ and +b2+) or +b3+
(b1 & b1) | b3

|

|(bool_op)

Produces a new BoolOperand representing this operand OR bool_op.

# +b1+ and +b2+
b1 & b2

^

^(bool_op)

Produces a new BoolOperand representing this operand XOR bool_op.

Examples
# (+b1+ and +b2+) or (+b3+ exclusive or +b1+)
(b1 & b2) | (b3 ^ b1)

implies

implies(bool_op)

Produces a new BoolOperand representing that this operand implies bool_op.

Examples
# (+b1+ implies +b2+) and (+b3+ implies +b2+)
(b1.implies b2) & (b3.implies b2)

+

+(op2)

Produces an IntOperand representing the value of this boolean operand (0 or 1) plus op2.

Examples
# +bool1+ plus +bool2+
bool1 + bool2

-

-(op2)

Produces an IntOperand representing the value of this boolean operand (0 or 1) minus op2.

Examples
# +bool1+ minus +bool2+
bool1 - bool2

*

*(fixnum)

Produces an IntOperand representing the value of this boolean operand (0 or 1) times a constant.

Examples
# +bool+ times 17
bool * 17