Class: BoolExpr

Remarks

A class that represents a boolean expression in the model. The expression may depend on one or more variables; therefore, its value may be unknown until a solution is found.

Examples

For example, the following code creates two interval variables, x and y and a boolean expression precedes that is true if x ends before y starts, that is, if the end of x is less than or equal to the start of y:

See IntExpr.le for the comparison method.

let model = new CP.Model();
let x = model.intervalVar({ length: 10, name: "x" });
let y = model.intervalVar({ length: 20, name: "y" });
let precedes = x.end().le(y.start());
let result = await model.solve();

Boolean expressions can be used to create constraints using Model.enforce. In the example above, we may require that precedes is true or absent:

model.enforce(precedes);

Optional boolean expressions

OptalCP is using 3-value logic: a boolean expression can be true, false or absent. Typically, the expression is absent only if one or more underlying variables are absent. The value absent means that the expression doesn't have a meaning because one or more underlying variables are absent (not part of the solution).

Difference between constraints and boolean expressions

Boolean expressions can take arbitrary value (true, false, or absent) and can be combined into composed expressions (e.g., using BoolExpr.and or BoolExpr.or).

Constraints can only be true or absent (in a solution) and cannot be combined into composed expressions.

Some functions create constraints directly, e.g. Model.noOverlap. It is not possible to combine constraints using logical operators like or.

Let's consider a similar example to the one above but with an optional interval variables a and b:

let model = new CP.Model();
let a = model.intervalVar({ length: 10, name: "a", optional: true });
let b = model.intervalVar({ length: 20, name: "b", optional: true });
let precedes = a.end().le(b.start());
model.enforce(precedes);
let result = await model.solve();

Adding a boolean expression as a constraint requires that the expression cannot be false in a solution. It could be absent though. Therefore, in our example, there are four kinds of solutions:

1. Both a and b are present, and a ends before b starts.
2. Only a is present, and b is absent.
3. Only b is present, and a is absent.
4. Both a and b are absent.

In case 1, the expression precedes is true. In all the other cases precedes is absent as at least one of the variables a and b is absent, and then precedes doesn't have a meaning.

Boolean expressions as integer expressions

Class BoolExpr derives from IntExpr. Therefore, boolean expressions can be used as integer expressions. In this case, true is equal to 1, false is equal to 0, and absent remains absent.

Extends

• IntExpr

Extended by

• BoolVar

Accessors

name

Get Signature

get name(): undefined | string

The name assigned to this model element.

Remarks

The name is optional and primarily useful for debugging purposes. When set, it helps identify the element in solver logs, error messages, and when inspecting solutions.

Names can be assigned to any model element including variables, expressions, and constraints.

Example

import * as CP from "optalcp";

const model = new CP.Model();

// Name a variable at creation
const task = model.intervalVar({ length: 10, name: "assembly" });

// Or set name later
const x = model.intVar({ min: 0, max: 100 });
x.name = "quantity";

console.log(task.name);  // "assembly"
console.log(x.name);     // "quantity"

Returns

undefined | string

Set Signature

set name(value: string): void

Parameters

Parameter	Type
value	string

Returns

void

Inherited from

IntExpr.name

Constructors

new BoolExpr()

new BoolExpr(): BoolExpr

Returns

BoolExpr

Inherited from

IntExpr.constructor

Methods

abs()

abs(): IntExpr

Creates an integer expression which is absolute value of the expression.

Returns

IntExpr

The resulting integer expression

Remarks

If the expression has value absent, the resulting expression also has value absent.

Same as Model.abs.

Inherited from

IntExpr.abs

---

and()

and(rhs: boolean | BoolExpr): BoolExpr

Returns logical AND of the expression and arg.

Parameters

Parameter	Type	Description
rhs	boolean | BoolExpr	The second boolean expression.

Returns

BoolExpr

The resulting Boolean expression

Remarks

If the expression or arg has value absent, then the resulting expression has also value absent.

Same as Model.and.

---

div()

div(rhs: number | IntExpr): IntExpr

Returns integer division of the expression arg. The division rounds towards zero.

Parameters

Parameter	Type	Description
rhs	number | IntExpr	The second integer expression.

Returns

IntExpr

The resulting integer expression

Remarks

If the expression or arg has value absent, then the resulting expression has also value absent.

Same as Model.div.

Inherited from

IntExpr.div

---

enforce()

enforce(): void

Adds this boolean expression as a constraint to the model.

Returns

void

Remarks

This method adds the boolean expression as a constraint to the model. It provides a fluent-style alternative to Model.enforce.

A constraint is satisfied if it is not false. In other words, a constraint is satisfied if it is true or absent.

A boolean expression that is not added as a constraint can have arbitrary value in a solution (true, false, or absent). Once added as a constraint, it can only be true or absent in the solution.

See

• Model.enforce for the Model-centric style of adding constraints.
• BoolExpr for more about boolean expressions.

Example

import * as CP from "optalcp";

const model = new CP.Model();
const x = model.intVar({ min: 0, max: 10, name: "x" });
const y = model.intVar({ min: 0, max: 10, name: "y" });

// Enforce constraint using fluent style
x.plus(y).le(15).enforce();

// Equivalent to:
// model.enforce(x.plus(y).le(15));

const result = await model.solve();

---

eq()

eq(rhs: number | IntExpr): BoolExpr

Create an equality constraint.

Parameters

Parameter	Type	Description
rhs	number | IntExpr	The expression or constant to compare against.

Returns

BoolExpr

A boolean expression that is true when self equals rhs.

Remarks

Returns a BoolExpr representing self == other.

If either operand has value absent, the result is also absent.

See

• IntExpr.ne for inequality comparison.
• Model.eq for the Model-centric style.

import * as CP from "optalcp";

const model = new CP.Model();
const x = model.intVar({ min: 0, max: 10, name: "x" });
const y = model.intVar({ min: 0, max: 10, name: "y" });

// IntExpr.eq(IntExpr)
model.enforce(x.eq(y));

// IntExpr.eq(constant)
model.enforce(x.eq(5));

Inherited from

IntExpr.eq

---

ge()

ge(rhs: number | IntExpr): BoolExpr

Create a greater-than-or-equal constraint.

Parameters

Parameter	Type	Description
rhs	number | IntExpr	The expression or constant to compare against.

Returns

BoolExpr

A boolean expression that is true when self is greater than or equal to rhs.

Remarks

Returns a BoolExpr representing self >= other.

If either operand has value absent, the result is also absent.

See

• IntExpr.gt for strict greater-than comparison.
• IntExpr.le for less-than-or-equal comparison.
• Model.ge for the Model-centric style.

import * as CP from "optalcp";

const model = new CP.Model();
const x = model.intVar({ min: 0, max: 10, name: "x" });
const y = model.intVar({ min: 0, max: 10, name: "y" });

// IntExpr.ge(IntExpr)
model.enforce(x.ge(y));

// IntExpr.ge(constant)
model.enforce(x.ge(5));

Inherited from

IntExpr.ge

---

gt()

gt(rhs: number | IntExpr): BoolExpr

Create a greater-than constraint.

Parameters

Parameter	Type	Description
rhs	number | IntExpr	The expression or constant to compare against.

Returns

BoolExpr

A boolean expression that is true when self is greater than rhs.

Remarks

Returns a BoolExpr representing self > other.

If either operand has value absent, the result is also absent.

See

• IntExpr.ge for greater-than-or-equal comparison.
• IntExpr.lt for less-than comparison.
• Model.gt for the Model-centric style.

import * as CP from "optalcp";

const model = new CP.Model();
const x = model.intVar({ min: 0, max: 10, name: "x" });
const y = model.intVar({ min: 0, max: 10, name: "y" });

// IntExpr.gt(IntExpr)
model.enforce(x.gt(y));

// IntExpr.gt(constant)
model.enforce(x.gt(5));

Inherited from

IntExpr.gt

---

guard()

guard(absentValue: number): IntExpr

Creates an expression that replaces value absent by a constant.

Parameters

Parameter	Type	Default value	Description
absentValue	number	0	The value to use when the expression is absent.

Returns

IntExpr

The resulting integer expression

Remarks

The resulting expression is:

• equal to the expression if the expression is present
• and equal to absentValue otherwise (i.e. when the expression is absent).

The default value of absentValue is 0.

The resulting expression is never absent.

Same as Model.guard.

Inherited from

IntExpr.guard

---

identity()

identity(rhs: number | IntExpr): Constraint

Constrains two expressions to be identical, including their presence status.

Parameters

Parameter	Type	Description
rhs	number | IntExpr	The second integer expression.

Returns

Constraint

The constraint object

Remarks

Identity is different than equality. For example, if x is absent, then x == 0 is absent, but x.identity(0) is false.

Same as Model.identity.

Inherited from

IntExpr.identity

---

implies()

implies(rhs: boolean | BoolExpr): BoolExpr

Returns implication between the expression and arg.

Parameters

Parameter	Type	Description
rhs	boolean | BoolExpr	The second boolean expression.

Returns

BoolExpr

The resulting Boolean expression

Remarks

If the expression or arg has value absent, then the resulting expression has also value absent.

Same as Model.implies.

---

inRange()

inRange(lb: number, ub: number): BoolExpr

Creates Boolean expression lb ≤ this ≤ ub.

Parameters

Parameter	Type	Description
lb	number	The lower bound of the range.
ub	number	The upper bound of the range.

Returns

BoolExpr

The resulting Boolean expression

Remarks

If the expression has value absent, then the resulting expression has also value absent.

Use Model.enforce to add this expression as a constraint to the model.

Same as Model.inRange.

Inherited from

IntExpr.inRange

---

le()

le(rhs: number | IntExpr): BoolExpr

Create a less-than-or-equal constraint.

Parameters

Parameter	Type	Description
rhs	number | IntExpr	The expression or constant to compare against.

Returns

BoolExpr

A boolean expression that is true when self is less than or equal to rhs.

Remarks

Returns a BoolExpr representing self <= other.

If either operand has value absent, the result is also absent.

See

• IntExpr.lt for strict less-than comparison.
• IntExpr.ge for greater-than-or-equal comparison.
• Model.le for the Model-centric style.

import * as CP from "optalcp";

const model = new CP.Model();
const x = model.intVar({ min: 0, max: 10, name: "x" });
const y = model.intVar({ min: 0, max: 10, name: "y" });

// IntExpr.le(IntExpr)
model.enforce(x.le(y));

// IntExpr.le(constant)
model.enforce(x.le(5));

Inherited from

IntExpr.le

---

lt()

lt(rhs: number | IntExpr): BoolExpr

Create a less-than constraint.

Parameters

Parameter	Type	Description
rhs	number | IntExpr	The expression or constant to compare against.

Returns

BoolExpr

A boolean expression that is true when self is less than rhs.

Remarks

Returns a BoolExpr representing self < other.

If either operand has value absent, the result is also absent.

See

• IntExpr.le for less-than-or-equal comparison.
• IntExpr.gt for greater-than comparison.
• Model.lt for the Model-centric style.

import * as CP from "optalcp";

const model = new CP.Model();
const x = model.intVar({ min: 0, max: 10, name: "x" });
const y = model.intVar({ min: 0, max: 10, name: "y" });

// IntExpr.lt(IntExpr)
model.enforce(x.lt(y));

// IntExpr.lt(constant)
model.enforce(x.lt(5));

Inherited from

IntExpr.lt

---

max2()

max2(rhs: number | IntExpr): IntExpr

Creates an integer expression which is the maximum of the expression and arg.

Parameters

Parameter	Type	Description
rhs	number | IntExpr	The second integer expression.

Returns

IntExpr

The resulting integer expression

Remarks

If the expression or arg has value absent, then the resulting expression has also value absent.

Same as Model.max2. See Model.max for n-ary maximum.

Inherited from

IntExpr.max2

---

maximize()

maximize(): Objective

Creates a maximization objective for this expression.

Returns

Objective

An Objective that maximizes this expression.

Remarks

Creates an objective to maximize the value of this integer expression. A model can have at most one objective. New objective replaces the old one.

This is a fluent-style alternative to Model.maximize that allows creating objectives directly from expressions.

Example

import * as CP from "optalcp";

const model = new CP.Model();
const x = model.intervalVar({start: [0, 100], length: 10, name: "x"});

// Fluent style - maximize the start of x
x.start().maximize();

// Equivalent Model.maximize() style:
model.maximize(x.start());

See

• Model.maximize for Model-centric maximization.
• IntExpr.minimize for minimization.

Inherited from

IntExpr.maximize

---

min2()

min2(rhs: number | IntExpr): IntExpr

Creates an integer expression which is the minimum of the expression and arg.

Parameters

Parameter	Type	Description
rhs	number | IntExpr	The second integer expression.

Returns

IntExpr

The resulting integer expression

Remarks

If the expression or arg has value absent, then the resulting expression has also value absent.

Same as Model.min2. See Model.min for the n-ary minimum.

Inherited from

IntExpr.min2

---

minimize()

minimize(): Objective

Creates a minimization objective for this expression.

Returns

Objective

An Objective that minimizes this expression.

Remarks

Creates an objective to minimize the value of this integer expression. A model can have at most one objective. New objective replaces the old one.

This is a fluent-style alternative to Model.minimize that allows creating objectives directly from expressions.

Example

import * as CP from "optalcp";

const model = new CP.Model();
const x = model.intervalVar({length: 10, name: "x"});
const y = model.intervalVar({length: 20, name: "y"});

// Fluent style - minimize the end of y
y.end().minimize();

// Equivalent Model.minimize() style:
model.minimize(y.end());

See

• Model.minimize for Model-centric minimization.
• IntExpr.maximize for maximization.

Inherited from

IntExpr.minimize

---

minus()

minus(rhs: number | IntExpr): IntExpr

Returns subtraction of the expression and arg.

Parameters

Parameter	Type	Description
rhs	number | IntExpr	The second integer expression.

Returns

IntExpr

The resulting integer expression

Remarks

If the expression or arg has value absent, then the resulting expression has also value absent.

Same as Model.minus.

Inherited from

IntExpr.minus

---

ne()

ne(rhs: number | IntExpr): BoolExpr

Create an inequality constraint.

Parameters

Parameter	Type	Description
rhs	number | IntExpr	The expression or constant to compare against.

Returns

BoolExpr

A boolean expression that is true when self does not equal rhs.

Remarks

Returns a BoolExpr representing self != other.

If either operand has value absent, the result is also absent.

See

• IntExpr.eq for equality comparison.
• Model.ne for the Model-centric style.

import * as CP from "optalcp";

const model = new CP.Model();
const x = model.intVar({ min: 0, max: 10, name: "x" });
const y = model.intVar({ min: 0, max: 10, name: "y" });

// IntExpr.ne(IntExpr)
model.enforce(x.ne(y));

// IntExpr.ne(constant)
model.enforce(x.ne(5));

Inherited from

IntExpr.ne

---

neg()

neg(): IntExpr

Returns negation of the expression.

Returns

IntExpr

The resulting integer expression

Remarks

If the expression has value absent then the resulting expression has also value absent.

Same as Model.neg.

Inherited from

IntExpr.neg

---

not()

not(): BoolExpr

Returns negation of the expression.

Returns

BoolExpr

The resulting Boolean expression

Remarks

If the expression has value absent then the resulting expression has also value absent.

Same as Model.not.

---

or()

or(rhs: boolean | BoolExpr): BoolExpr

Returns logical OR of the expression and arg.

Parameters

Parameter	Type	Description
rhs	boolean | BoolExpr	The second boolean expression.

Returns

BoolExpr

The resulting Boolean expression

Remarks

If the expression or arg has value absent then the resulting expression has also value absent.

Same as Model.or.

---

plus()

plus(rhs: number | IntExpr): IntExpr

Returns addition of the expression and the argument.

Parameters

Parameter	Type	Description
rhs	number | IntExpr	The second integer expression.

Returns

IntExpr

The resulting integer expression

Remarks

If the expression or arg has value absent, then the resulting expression has also value absent.

Same as Model.plus.

Inherited from

IntExpr.plus

---

presence()

presence(): BoolExpr

Returns an expression which is true if the expression is present and false when it is absent.

Returns

BoolExpr

The resulting Boolean expression

Remarks

The resulting expression is never absent.

Same as Model.presence.

Inherited from

IntExpr.presence

---

times()

times(rhs: number | IntExpr): IntExpr

Returns multiplication of the expression and arg.

Parameters

Parameter	Type	Description
rhs	number | IntExpr	The second integer expression.

Returns

IntExpr

The resulting integer expression

Remarks

If the expression or arg has value absent, then the resulting expression has also value absent.

Same as Model.times.

Inherited from

IntExpr.times

Properties

Property	Modifier	Type	Inherited from
__boolExprBrand	readonly	"BoolExpr"	-
__floatExprBrand	readonly	"FloatExpr"	IntExpr.__floatExprBrand
__intExprBrand	readonly	"IntExpr"	IntExpr.__intExprBrand