Global constraint ensuring that all the values of a given configuration are unique.

@constraint(model, X in AllDifferent())

Global constraint ensuring that all the values of X are all equal.

@constraint(model, X in AllEqual())

Constraint ensuring that the number of occurrences of the values in vals in x is at least val.

@constraint(model, X in AtLeast(val, vals))

Constraint ensuring that the number of occurrences of the values in vals in x is at most val.

@constraint(model, X in AtMost(val, vals))

Global constraint ensuring that the tuple x does not match any configuration listed within the conflict set pair_vars. This constraint, originating from the extension model, stipulates that x must avoid all configurations defined as conflicts: x ∉ pair_vars. It is useful for specifying tuples that are explicitly forbidden and should be excluded from the solution space.

@constraint(model, X in Conflicts(; pair_vars))

Global constraint ensuring that the number of occurrences of val in X is equal to count.

@constraint(model, X in Count(count, val, vals))

Global constraint ensuring that the cumulative sum of the heights of the tasks is less than or equal to val.

@constraint(model, X in Cumulative(; pair_vars, op, val))

DiscreteSet(values)

Create a discrete set of values.

Arguments

• values::Vector{T}: A vector of values to include in the set.

Returns

• DiscreteSet{T}: A discrete set containing the specified values.

A constraint ensuring that the distances between marks on the ruler are unique. Specifically, it checks that the distance between x[1] and x[2], and the distance between x[3] and x[4], are different. This constraint is fundamental in ensuring the validity of a Golomb ruler, where no two pairs of marks should have the same distance between them.

Global constraint ensuring that the value of X at index id is equal to val.

@constraint(model, X in Element(; id = nothing, op = ==, val = 0))

Error{F <: Function} <: JuMP.AbstractVectorSet

The solver will compute a straightforward error function based on the concept. To run the solver efficiently, it is possible to provide an error function err instead of concept. err must return a nonnegative real number.

@constraint(model, X in Error(err))

Constraint ensuring that the number of occurrences of the values in vals in x is exactly val.

@constraint(model, X in Exactly(val, vals))

Global constraint enforcing that the tuple x matches a configuration within the supports set pair_vars[1] or does not match any configuration within the conflicts set pair_vars[2]. It embodies the logic: x ∈ pair_vars[1] || x ∉ pair_vars[2], providing a comprehensive way to define valid (supported) and invalid (conflicted) tuples for constraint satisfaction problems. This constraint is versatile, allowing for the explicit delineation of both acceptable and unacceptable configurations.

The instantiation constraint is a global constraint used in constraint programming that ensures that a list of variables takes on a specific set of values in a specific order.

Intention{F <: Function} <: JuMP.AbstractVectorSet

Represents an intention set in the model.

Arguments

• f::F: A function representing the intention.

Multi-valued Decision Diagram (MDD) constraint.

The MDD constraint is a constraint that can be used to model a wide range of problems. It is a directed graph where each node is labeled with a value and each edge is labeled with a value. The constraint is satisfied if there is a path from the first node to the last node such that the sequence of edge labels is a valid sequence of the value labels.

@constraint(model, X in MDDConstraint(; language))

MOIAllDifferent <: MOI.AbstractVectorSet

DOCSTRING

MOIAllEqual <: MOI.AbstractVectorSet

DOCSTRING

MOIConflicts{T <: Number, V <: Vector{Vector{T}}} <: MOI.AbstractVectorSet

DOCSTRING

MOICumulative{F <: Function, T1 <: Number, T2 <: Number} <: MOI.AbstractVectorSet

DOCSTRING

MOIDistDifferent <: MOI.AbstractVectorSet

DOCSTRING

MOIElement{I <: Integer, F <: Function, T <: Union{Nothing, Number}} <: MOI.AbstractVectorSet

DOCSTRING

MOIError{F <: Function} <: MOI.AbstractVectorSet

DOCSTRING

Arguments:

• f::F: DESCRIPTION
• dimension::Int: DESCRIPTION
• MOIError(f, dim = 0) = begin #= none:5 =# new{typeof(f)}(f, dim) end: DESCRIPTION

MOIExtension{T <: Number, V <: Union{Vector{Vector{T}}, Tuple{Vector{T}, Vector{T}}}} <: MOI.AbstractVectorSet

DOCSTRING

MOIInstantiation{T <: Number, V <: Vector{T}} <: MOI.AbstractVectorSet

DOCSTRING

MOIIntention{F <: Function} <: MOI.AbstractVectorSet

Represents an intention set in the model.

Arguments

• f::F: A function representing the intention.
• dimension::Int: The dimension of the vector set.

MOIMaximum {F <: Function, T <: Number} <: MOI.AbstractVectorSet

DOCSTRING

MOIMinimum {F <: Function, T <: Number} <: MOI.AbstractVectorSet

DOCSTRING

MOIMultivaluedDecisionDiagram{L <: ConstraintCommons.AbstractMultivaluedDecisionDiagram} <: AbstractVectorSet

DOCSTRING

MOINValues{F <: Function, T1 <: Number, T2 <: Number, V <: Vector{T2}} <: MOI.AbstractVectorSet

DOCSTRING

MOINoOverlap{I <: Integer, T <: Number, V <: Vector{T}} <: MOI.AbstractVectorSet

DOCSTRING

MOIOrdered{F <: Function, T <: Number, V <: Vector{T}} <: MOI.AbstractVectorSet

DOCSTRING

MOIRegular{L <: ConstraintCommons.AbstractAutomaton} <: AbstractVectorSet

DOCSTRING

MOISum{F <: Function, T1 <: Number, T2 <: Number, V <: Number} <: MOI.AbstractVectorSet

DOCSTRING

MOISupports{T <: Number, V <: Vector{Vector{T}}} <: MOI.AbstractVectorSet

DOCSTRING

Global constraint ensuring that the maximum value in the tuple x satisfies the condition op(x) val. This constraint is useful for specifying that the maximum value in the tuple must satisfy a certain condition.

@constraint(model, X in Maximum(; op = ==, val))

Global constraint ensuring that the minimum value in the tuple x satisfies the condition op(x) val. This constraint is useful for specifying that the minimum value in the tuple must satisfy a certain condition.

@constraint(model, X in Minimum(; op = ==, val))

Global constraint ensuring that the number of distinct values in X satisfies the given condition.

Global constraint ensuring that the tuple x does not overlap with any configuration listed within the pair set pair_vars. This constraint, originating from the extension model, stipulates that x must avoid all configurations defined as pairs: x ∩ pair_vars = ∅. It is useful for specifying tuples that are explicitly forbidden and should be excluded from the solution space.

@constraint(model, X in NoOverlap(; bool = true, dim = 1, pair_vars = nothing))

Optimizer(model = Model(); options = Options())

Create an instance of the Optimizer.

Arguments

• model: The model to be optimized.
• options::Options: Options for configuring the solver.

Returns

• Optimizer: An instance of the optimizer.

Optimizer <: MOI.AbstractOptimizer

Defines an optimizer for CBLS.

Fields

• solver::LS.MainSolver: The main solver used for local search.
• int_vars::Set{Int}: Set of integer variables.
• compare_vars::Set{Int}: Set of variables to compare.

Global constraint ensuring that the variables are ordered according to op.

Predicate{F <: Function} <: JuMP.AbstractVectorSet

Deprecated: Use Intention instead.

Represents a predicate set in the model.

Arguments

• f::F: A function representing the predicate.

Ensures that a sequence x (interpreted as a word) is accepted by the regular language represented by a given automaton. This constraint verifies the compliance of x with the language rules encoded within the automaton parameter, which must be an instance of <:AbstractAutomaton.

@constraint(model, X in RegularConstraint(; language))

ScalarFunction{F <: Function, V <: Union{Nothing, VOV}} <: MOI.AbstractScalarFunction

A container to express any function with real value in JuMP syntax. Used with the @objective macro.

Arguments:

• f::F: function to be applied to X
• X::V: a subset of the variables of the model.

Given a model, and some (collection of) variables X to optimize. an objective function f can be added as follows. Note that only Min for minimization us currently defined. Max will come soon.

# Applies to all variables in order of insertion.
# Recommended only when the function argument order does not matter.
@objective(model, ScalarFunction(f))

# Generic use
@objective(model, ScalarFunction(f, X))

Global constraint ensuring that the sum of the variables in x satisfies a given condition.

Global constraint ensuring that the tuple x matches a configuration listed within the support set pair_vars. This constraint is derived from the extension model, specifying that x must be one of the explicitly defined supported configurations: x ∈ pair_vars. It is utilized to directly declare the tuples that are valid and should be included in the solution space.

@constraint(model, X in Supports(; pair_vars))

Base.copy(set::MOIError) = begin

DOCSTRING

Base.copy(set::MOIIntention)

Copy an intention set.

Arguments

• set::MOIIntention: The intention set to be copied.

Returns

• MOIIntention: A copy of the intention set.

Base.copy(set::DiscreteSet)

Copy a discrete set.

Arguments

• set::DiscreteSet: The discrete set to be copied.

Returns

• DiscreteSet: A copy of the discrete set.

Base.copy(op::F) where {F <: Function}

Copy a function.

Arguments

• op::F: The function to be copied.

Returns

• F: The copied function.

Base.copy(::Nothing)

Copy a Nothing value.

Arguments

• ::Nothing: The Nothing value to be copied.

Returns

• Nothing: The copied Nothing value.

JuMP.build_variable(::Function, info::JuMP.VariableInfo, set::T) where T <: MOI.AbstractScalarSet

Create a variable constrained by a scalar set.

Arguments

• info::JuMP.VariableInfo: Information about the variable to be created.
• set::T where T <: MOI.AbstractScalarSet: The set defining the constraints on the variable.

Returns

• JuMP.VariableConstrainedOnCreation: A variable constrained by the specified set.

JuMP.moi_set(set::Intention, dim::Int) -> MOIIntention

Convert an Intention set to a MOIIntention set.

Arguments

• set::Intention: The intention set to be converted.
• dim::Int: The dimension of the vector set.

Returns

• MOIIntention: The converted MOIIntention set.

JuMP.moi_set(set::Predicate, dim::Int) -> MOIIntention

Convert a Predicate set to a MOIIntention set.

Arguments

• set::Predicate: The predicate set to be converted.
• dim::Int: The dimension of the vector set.

Returns

• MOIIntention: The converted MOIIntention set.

MOI.add_constraint(optimizer::Optimizer, vars::MOI.VectorOfVariables, set::MOIError)

DOCSTRING

Arguments:

• optimizer: DESCRIPTION
• vars: DESCRIPTION
• set: DESCRIPTION

MOI.add_constraint(optimizer::Optimizer, vars::MOI.VectorOfVariables, set::MOIIntention{F}) where {F <: Function}

Add an intention constraint to the optimizer.

Arguments

• optimizer::Optimizer: The optimizer instance.
• vars::MOI.VectorOfVariables: The variables for the constraint.
• set::MOIIntention{F}: The intention set defining the constraint.

Returns

• CI{VOV, MOIIntention{F}}: The constraint index.

MOI.add_constraint(optimizer::Optimizer, v::VI, set::DiscreteSet{T}) where T <: Number

DOCSTRING

Arguments:

• optimizer: DESCRIPTION
• v: DESCRIPTION
• set: DESCRIPTION

MOI.add_variable(model::Optimizer) = begin

DOCSTRING

MOI.copy_to(model::Optimizer, src::MOI.ModelLike)

Copy the source model to the optimizer.

Arguments

• model::Optimizer: The optimizer instance.
• src::MOI.ModelLike: The source model to be copied.

Returns

• Nothing

MOI.empty!(opt)

Empty the optimizer.

Arguments

• opt::Optimizer: The optimizer instance.

Returns

• Nothing

MOI.get(::Optimizer, ::MOI.SolverName)

Get the name of the solver.

Arguments

• ::Optimizer: The optimizer instance.

Returns

• String: The name of the solver.

Moi.get(::Optimizer, ::MOI.SolverVersion)

Get the version of the solver, here LocalSearchSolvers.jl.

MOI.is_empty(model::Optimizer)

Check if the model is empty.

Arguments

• model::Optimizer: The optimizer instance.

Returns

• Bool: True if the model is empty, false otherwise.

MOI.is_valid(optimizer::Optimizer, index::CI{VI, MOI.Integer})

Check if an index is valid for the optimizer.

Arguments

• optimizer::Optimizer: The optimizer instance.
• index::CI{VI, MOI.Integer}: The index to be checked.

Returns

• Bool: True if the index is valid, false otherwise.

MOI.optimize!(model::Optimizer)

Optimize the model using the optimizer.

Arguments

• model::Optimizer: The optimizer instance.

Returns

• Nothing

MOI.set(::Optimizer, ::MOI.Silent, bool = true)

Set the verbosity of the solver.

Arguments

• ::Optimizer: The optimizer instance.
• ::MOI.Silent: The silent option for the solver.
• bool::Bool: Whether to set the solver to silent mode.

Returns

• Nothing

MOI.set(model::Optimizer, p::MOI.RawOptimizerAttribute, value)

Set a RawOptimizerAttribute to value

MOI.set(model::Optimizer, ::MOI.TimeLimitSec, value::Union{Nothing,Float64})

Set the time limit

MOI.supports_constraint(::Optimizer, ::Type{VOV}, ::Type{MOIError}) = begin

DOCSTRING

Arguments:

• ``: DESCRIPTION
• ``: DESCRIPTION
• ``: DESCRIPTION

MOI.supports_constraint(::Optimizer, ::Type{VOV}, ::Type{MOIIntention{F}}) where {F <: Function}

Check if the optimizer supports a given intention constraint.

Arguments

• ::Optimizer: The optimizer instance.
• ::Type{VOV}: The type of the variable.
• ::Type{MOIIntention{F}}: The type of the intention.

Returns

• Bool: True if the optimizer supports the constraint, false otherwise.

MOI.supports_incremental_interface(::Optimizer)

Check if the optimizer supports incremental interface.

Arguments

• ::Optimizer: The optimizer instance.

Returns

• Bool: True if the optimizer supports incremental interface, false otherwise.