Public

_set_domain!(m::Model, x, values)

DOCSTRING

Arguments:

• m: DESCRIPTION
• x: DESCRIPTION
• values: DESCRIPTION

mts = - get_time_stamp(model)

return TimeStamps(mts, mts, mts, mts, mts, mts, mts) end

add!(m::M, x) where M <: Union{Model, AbstractSolver}
add!(m::M, c) where M <: Union{Model, AbstractSolver}
add!(m::M, o) where M <: Union{Model, AbstractSolver}

Add a variable x, a constraint c, or an objective o to m.

add_value!(m::M, x, val) where M <: Union{Model, AbstractSolver}

Add val to x domain.

add_var_to_cons!(m::M, c, x) where M <: Union{Model, AbstractSolver}

Add x to the constraint c list of restricted variables.

constraint!(m::M, func, vars) where M <: Union{Model, AbstractSolver}

Add a constraint with an error function func defined over variables vars.

constraint(f, vars)

DOCSTRING

constriction(m::M, x) where M <: Union{Model, AbstractSolver}

Return the constriction of variable x.

delete_value(m::M, x, val) where M <: Union{Model, AbstractSolver}

Delete val from x domain.

delete_var_from_cons(m::M, c, x) where M <: Union{Model, AbstractSolver}

Delete x from the constraint c list of restricted variables.

describe(m::M) where M <: Union{Model, AbstractSolver}

Describe the model.

draw(m::M, x) where M <: Union{Model, AbstractSolver}

Draw a random value of x domain.

get_cons_from_var(m::M, x) where M <: Union{Model, AbstractSolver}

Access the constraints restricting variable x.

get_constraint(m::M, c) where M <: Union{Model, AbstractSolver}

Access the constraint c.

get_constraints(m::M) where M <: Union{Model, AbstractSolver}

Access the constraints of m.

get_domain(m::M, x) where M <: Union{Model, AbstractSolver}

Access the domain of variable x.

get_name(m::M, x) where M <: Union{Model, AbstractSolver}

Access the name of variable x.

get_objective(m::M, o) where M <: Union{Model, AbstractSolver}

Access the objective o.

get_objectives(m::M) where M <: Union{Model, AbstractSolver}

Access the objectives of m.

get_variable(m::M, x) where M <: Union{Model, AbstractSolver}

Access the variable x.

get_variables(m::M) where M <: Union{Model, AbstractSolver}

Access the variables of m.

get_vars_from_cons(m::M, c) where M <: Union{Model, AbstractSolver}

Access the variables restricted by constraint c.

is_sat(m::M) where M <: Union{Model, AbstractSolver}

Return true if m is a satisfaction model.

length_cons(m::M, c) where M <: Union{Model, AbstractSolver}

Return the length of constraint c.

length_cons(m::M) where M <: Union{Model, AbstractSolver}

Return the number of constraints in m.

length_var(m::M, x) where M <: Union{Model, AbstractSolver}

Return the domain length of variable x.

max_domains_size(m::Model, vars) = begin

DOCSTRING

model()

Construct a _Model, empty by default. It is recommended to add the constraints, variables, and objectives from an empty _Model. The following keyword arguments are available,

• vars=Dictionary{Int,Variable}(): collection of variables
• cons=Dictionary{Int,Constraint}(): collection of cosntraints
• objs=Dictionary{Int,Objective}(): collection of objectives
• kind=:generic: the kind of problem modeled (useful for specialized methods such as pretty printing)

dist_extrema(values::T...) where {T <: Number}

Computes the distance between extrema in an ordered set.

o_mincut(graph, values; interdiction = 0)

Compute the capacity of a cut (determined by the state of the solver) with a possible interdiction on the highest capacited links.

objective!(m::M, func) where M <: Union{Model, AbstractSolver}

Add an objective evaluated by func.

objective(func, name)

Construct an objective with a function func that should be applied to a collection of variables.

solution(s)

Return the only/best known solution of a satisfaction/optimization model.

specialize!(solver)

Replace the model of solver by one with specialized types (variables, constraints, objectives).

specialize(m::M) where M <: Union{Model, AbstractSolver}

Specialize the structure of a model to avoid dynamic type attribution at runtime.

status(solver)

Return the status of a MainSolver.

variable!(m::M, d) where M <: Union{Model, AbstractSolver}

Add a variable with domain d to m.

variable(values::AbstractVector{T}, name::AbstractString; domain = :set) where T <: Number
variable(domain::AbstractDomain, name::AbstractString) where D <: AbstractDomain

Construct a variable with discrete domain. See the domain method for other options.

d = domain([1,2,3,4], types = :indices)
x1 = variable(d, "x1")
x2 = variable([-89,56,28], "x2", domain = :indices)