Add README.

Author: samuelsonric

.gitignore

@@ -0,0 +1,2 @@
+*.swp
+Manifest.toml

README.md

@@ -0,0 +1,58 @@
+# MathOptChordalDecomposition.jl
+
+MathOptChordalDecomposition.jl is a [MathOptInterface.jl](https://github.com/jump-dev/MathOptInterface.jl) layer that implements chordal decomposition of
+sparse semidefinite constraints.
+
+## Basic Usage
+
+The `sdplib` directory contains three semidefinite programming problems from the [SDPLIB library](https://github.com/vsdp/SDPLIB). The function `construct_model`, defined below, reads one of the problems and constructs a [JuMP.jl](https://github.com/jump-dev/JuMP.jl) model.
+
+```julia-repl
+julia> using FileIO, LinearAlgebra, JuMP
+
+julia> import MathOptChordalDecomposition, MosekTools, Mosek
+
+julia> function construct_model(f, name::String)
+           # load data
+           data = load("./sdplib/$name.jld2");
+           F = data["F"]
+           c = data["c"]
+           m = data["m"]
+           n = data["n"]
+    
+           # construct model
+           model = JuMP.Model(f)
+           set_silent(model)
+           @variable(model, x[1:m])
+           @objective(model, Min, c' * x)
+           @constraint(model, con1,  Symmetric(-Matrix(F[1]) + sum(Matrix(F[k + 1]) .* x[k] for k in 1:m)) in JuMP.PSDCone())
+           return model
+       end
+construct_model (generic function with 1 method)
+```
+
+Solve the problem using the [Mosek.jl](https://github.com/MOSEK/Mosek.jl) optimizer.
+
+```julia-repl
+julia> model = construct_model(Mosek.Optimizer, "mcp124-1");
+
+julia> @time JuMP.optimize!(model)
+  6.005076 seconds (2.53 k allocations: 515.859 KiB)
+
+julia> MOI.get(model, MOI.ObjectiveValue())
+141.9904770422396
+```
+
+Solve the problem using [Mosek.jl](https://github.com/MOSEK/Mosek.jl) and MathOptChordalDecomposition.jl.
+
+```julia-repl
+julia> model = construct_model("mcp124-1") do
+           MathOptChordalDecomposition.Optimizer(Mosek.Optimizer)
+       end;
+
+julia> @time JuMP.optimize!(model)
+  0.041175 seconds (230.72 k allocations: 11.800 MiB)
+
+julia> MOI.get(model.moi_backend.optimizer.model.inner, MOI.ObjectiveValue())
+141.99047611570586
+```

sdplib/mcp124-1.jld2

@@ -298,23 +298,11 @@ function MOI.get(
     return # ???
 end
 
-function idx(i::Int, j::Int)
-    @assert i <= j
-    x = i + j * (j - 1) ÷ 2
-    return x
-end
-
-function col(x::Int)
-    j = ceil(Int, (sqrt(1 + 8x) - 1.0) / 2)
-    return j
-end
-
-function row(x::Int)
-    j = col(x)
-    i = x - j * (j - 1) ÷ 2
-    return i
-end
+# Utilities
 
+# `(V, A, b) = decode(f, S)` satisfies
+#    f(Vᵢ) = Aᵢ + b
+# for all 1 ≤ i ≤ n.
 function decode(f::MOI.VectorAffineFunction{T}, S::MOI.PositiveSemidefiniteConeTriangle) where {T}
     n = S.side_dimension
     index = Dict{MOI.VariableIndex, Int}()
@@ -365,10 +353,32 @@ function decode(f::MOI.VectorAffineFunction{T}, S::MOI.PositiveSemidefiniteConeT
     return V, A, b
 end
 
+# `S = sparsitypattern(A)` is a binary matrix with the same
+# sparsity pattern as A.
 function sparsitypattern(A::AbstractMatrix{T}) where {T}
     S = sparse(Symmetric(A, :U))
     nonzeros(S) .= one(T)
     return S
 end
 
+# upper triangular indices
+# idx ∘ (row, col) = id
+# (row, col) ∘ idx = id
+function idx(i::Int, j::Int)
+    @assert i <= j
+    x = i + j * (j - 1) ÷ 2
+    return x
+end
+
+function col(x::Int)
+    j = ceil(Int, (sqrt(1 + 8x) - 1.0) / 2)
+    return j
+end
+
+function row(x::Int)
+    j = col(x)
+    i = x - j * (j - 1) ÷ 2
+    return i
+end
+
 end