Julia Constraints

Appearance

CBLS.jl ​

Documentation for CBLS.jl.

CBLS.AllDifferent Type

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

julia
@constraint(model, X in AllDifferent())

source

CBLS.AllEqual Type

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

julia
@constraint(model, X in AllEqual())

source

CBLS.AtLeast Type

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

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

source

CBLS.AtMost Type

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

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

source

CBLS.Conflicts Type

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.

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

source

CBLS.Count Type

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

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

source

CBLS.Cumulative Type

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

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

source

CBLS.DiscreteSet Type
julia
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.

source

CBLS.DistDifferent Type

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.

source

CBLS.Element Type

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

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

source

CBLS.Error Type
julia
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.

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

source

CBLS.Exactly Type

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

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

source

CBLS.Extension Type

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.

source

CBLS.Instantiation Type

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.

source

CBLS.Intention Type
julia
Intention{F <: Function} <: JuMP.AbstractVectorSet

Represents an intention set in the model.

Arguments

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

source

CBLS.MDDConstraint Type

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.

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

source

CBLS.MOIAllDifferent Type
julia
MOIAllDifferent <: MOI.AbstractVectorSet

DOCSTRING

source

CBLS.MOIAllEqual Type
julia
MOIAllEqual <: MOI.AbstractVectorSet

DOCSTRING

source

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

DOCSTRING

source

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

DOCSTRING

source

CBLS.MOIDistDifferent Type
julia
MOIDistDifferent <: MOI.AbstractVectorSet

DOCSTRING

source

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

DOCSTRING

source

CBLS.MOIError Type
julia
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

source

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

DOCSTRING

source

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

DOCSTRING

source

CBLS.MOIIntention Type
julia
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.

source

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

DOCSTRING

source

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

DOCSTRING

source

CBLS.MOIMultivaluedDecisionDiagram Type
julia
MOIMultivaluedDecisionDiagram{L <: ConstraintCommons.AbstractMultivaluedDecisionDiagram} <: AbstractVectorSet

DOCSTRING

source

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

DOCSTRING

source

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

DOCSTRING

source

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

DOCSTRING

source

CBLS.MOIRegular Type
julia
MOIRegular{L <: ConstraintCommons.AbstractAutomaton} <: AbstractVectorSet

DOCSTRING

source

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

DOCSTRING

source

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

DOCSTRING

source

CBLS.Maximum Type

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.

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

source

CBLS.Minimum Type

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.

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

source

CBLS.NValues Type

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

source

CBLS.NoOverlap Type

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.

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

source

CBLS.Optimizer Type
julia
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.

source

CBLS.Optimizer Type
julia
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.

source

CBLS.Ordered Type

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

source

CBLS.Predicate Type
julia
Predicate{F <: Function} <: JuMP.AbstractVectorSet

Deprecated: Use Intention instead.

Represents a predicate set in the model.

Arguments

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

source

CBLS.Regular Type

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.

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

source

CBLS.ScalarFunction Type
julia
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.

julia
# 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))

source

CBLS.Sum Type

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

source

CBLS.Supports Type

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.

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

source

Base.copy Method
julia
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.

source

Base.copy Method
julia
Base.copy(set::MOIError) = begin

DOCSTRING

source

Base.copy Method
julia
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.

source

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

Copy a function.

Arguments

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

Returns

  • F: The copied function.

source

Base.copy Method
julia
Base.copy(::Nothing)

Copy a Nothing value.

Arguments

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

Returns

  • Nothing: The copied Nothing value.

source

JuMP.build_variable Method
julia
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.

source

JuMP.moi_set Method
julia
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.

source

JuMP.moi_set Method
julia
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.

source

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

DOCSTRING

Arguments:

  • optimizer: DESCRIPTION

  • vars: DESCRIPTION

  • set: DESCRIPTION

source

MathOptInterface.add_constraint Method
julia
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.

source

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

DOCSTRING

Arguments:

  • optimizer: DESCRIPTION

  • v: DESCRIPTION

  • set: DESCRIPTION

source

MathOptInterface.add_variable Method
julia
MOI.add_variable(model::Optimizer) = begin

DOCSTRING

source

MathOptInterface.copy_to Method
julia
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

source

MathOptInterface.empty! Method
julia
MOI.empty!(opt)

Empty the optimizer.

Arguments

  • opt::Optimizer: The optimizer instance.

Returns

  • Nothing

source

MathOptInterface.get Method
julia
MOI.get(::Optimizer, ::MOI.SolverName)

Get the name of the solver.

Arguments

  • ::Optimizer: The optimizer instance.

Returns

  • String: The name of the solver.

source

MathOptInterface.get Method
julia
Moi.get(::Optimizer, ::MOI.SolverVersion)

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

source

MathOptInterface.is_empty Method
julia
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.

source

MathOptInterface.is_valid Method
julia
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.

source

MathOptInterface.optimize! Method
julia
MOI.optimize!(model::Optimizer)

Optimize the model using the optimizer.

Arguments

  • model::Optimizer: The optimizer instance.

Returns

  • Nothing

source

MathOptInterface.set Function
julia
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

source

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

Set a RawOptimizerAttribute to value

source

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

Set the time limit

source

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

DOCSTRING

Arguments:

  • ``: DESCRIPTION

  • ``: DESCRIPTION

  • ``: DESCRIPTION

source

MathOptInterface.supports_constraint Method
julia
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.

source

MathOptInterface.supports_incremental_interface Method
julia
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.

source