ConstraintModels

mutable struct SudokuInstance{T <: Integer} <: AbstractMatrix{T}

A struct for SudokuInstances, which is a subtype of AbstractMatrix.

SudokuInstance(A::AbstractMatrix{T})
SudokuInstance(::Type{T}, n::Int) # fill in blank sudoku of type T
SudokuInstance(n::Int) # fill in blank sudoku of type Int
SudokuInstance(::Type{T}) # fill in "standard" 9×9 sudoku of type T
SudokuInstance() # fill in "standard" 9×9 sudoku of type Int
SudokuInstance(n::Int, P::Pair{Tuple{Int, Int}, T}...) where {T <: Integer} # construct a sudoku given pairs of coordinates and values
SudokuInstance(P::Pair{Tuple{Int, Int}, T}...) # again, default to 9×9 sudoku, constructing given pairs

Constructor functions for the SudokuInstance struct.

SudokuInstance(X::Dictionary)

Construct a SudokuInstance with the values X of a solver as input.

display(io::IO, S::SudokuInstance)
display(S::SudokuInstance) # default to stdout

Displays an $n\times n$ SudokuInstance.

Base.display(X, Val(:sudoku))

Extends Base.display to a sudoku configuration.

Base.display(S::SudokuInstance)

Extends Base.display to SudokuInstance.

Base.display(X::Dictionary)

Extends Base.display to a sudoku configuration.

Base.size(S::SudokuInstance)

Extends Base.size for SudokuInstance.

_format_line(r, M)

Format line of a sudoku grid.

_format_line_segment(r, col_pos, M)

Format line segment of a sudoku grid.

_format_val(a)

Format an integer a into a string for SudokuInstance.

_get_sep_line(s, pos_row, M)

Return a line separator.

chemical_equilibrium(atoms_compounds, elements_weights, standard_free_energy; modeler = :JuMP)

From Wikipedia

In a chemical reaction, chemical equilibrium is the state in which both the reactants and products are present in concentrations which have no further tendency to change with time, so that there is no observable change in the properties of the system. This state results when the forward reaction proceeds at the same rate as the reverse reaction. The reaction rates of the forward and backward reactions are generally not zero, but they are equal. Thus, there are no net changes in the concentrations of the reactants and products. Such a state is known as dynamic equilibrium.

golomb(n, L=n²)

Model the Golomb problem of n marks on the ruler 0:L. The modeler argument accepts :raw, and :JuMP (default), which refer respectively to the solver internal model, the MathOptInterface model, and the JuMP model.

magic_square(n; modeler = :JuMP)

Create a model for the magic square problem of order n. The modeler argument accepts :JuMP (default), which refer to the solver the JuMP model.

mincut(graph; source, sink, interdiction =0, modeler = :JuMP)

Compute the minimum cut of a graph.

Arguments:

• graph: Any matrix <: AbstractMatrix that describes the capacities of the graph
• source: Id of the source node; must be set
• sink: Id of the sink node; must be set
• interdiction: indicates the number of forbidden links
• modeler: Default to :JuMP.

n_queens(n; modeler = :JuMP)

Create a model for the n-queens problem with n queens. The modeler argument accepts :JuMP (default), which refer to the JuMP model.

qap(n, weigths, distances; modeler = :JuMP)

Modelize an instance of the Quadractic Assignment Problem with

• n: number of both facilities and locations
• weights: Matrix of the weights of each pair of facilities
• distances: Matrix of distances between locations
• modeler: Default to :JuMP. No other modeler available for now.

From Wikipedia

There are a set of n facilities and a set of n locations. For each pair of locations, a distance is specified and for each pair of facilities a weight or flow is specified (e.g., the amount of supplies transported between the two facilities). The problem is to assign all facilities to different locations with the goal of minimizing the sum of the distances multiplied by the corresponding flows.

scheduling(processing_time, due_date; modeler=:JuMP)

Create a model for the n-queens problem with n queens. The modeler argument accepts :JuMP (default), which refer to the JuMP model.

sudoku(n; start= Dictionary{Int, Int}(), modeler = :JuMP)

Create a model for the sudoku problem of domain 1:n² with optional starting values. The modeler argument accepts :raw, :MOI, and :JuMP (default), which refer respectively to the solver internal model, the MathOptInterface model, and the JuMP model.

# Construct a JuMP model `m` and its associated matrix `grid` for sudoku 9×9
m, grid = sudoku(3)

# Same with a starting instance
instance = [
    9  3  0  0  0  0  0  4  0
    0  0  0  0  4  2  0  9  0
    8  0  0  1  9  6  7  0  0
    0  0  0  4  7  0  0  0  0
    0  2  0  0  0  0  0  6  0
    0  0  0  0  2  3  0  0  0
    0  0  8  5  3  1  0  0  2
    0  9  0  2  8  0  0  0  0
    0  7  0  0  0  0  0  5  3
]
m, grid = sudoku(3, start = instance)

# Run the solver
optimize!(m)

# Retrieve and display the values
solution = value.(grid)
display(solution, Val(:sudoku))