## SCS.jl

Julia Wrapper for SCS (https://github.com/cvxgrp/scs)
Popularity
75 Stars
Updated Last
10 Months Ago
Started In
May 2014

# SCS.jl

SCS.jl is a wrapper for the SCS splitting cone solver.

SCS can solve linear programs, second-order cone programs, semidefinite programs, exponential cone programs, and power cone programs.

## Affiliation

This wrapper is maintained by the JuMP community and is not a project of the SCS developers.

`SCS.jl` is licensed under the MIT License.

## Installation

Install SCS.jl using the Julia package manager:

```import Pkg

In addition to installing the `SCS.jl` package, this will also download and install the SCS binaries. (You do not need to install SCS separately.)

To use a custom binary, read the Custom solver binaries section of the JuMP documentation.

## Use with Convex.jl

This example shows how we can model a simple knapsack problem with Convex and use SCS to solve it.

```using Convex, SCS
items  = [:Gold, :Silver, :Bronze]
values = [5.0, 3.0, 1.0]
weights = [2.0, 1.5, 0.3]

# Define a variable of size 3, each index representing an item
x = Variable(3)
p = maximize(x' * values, 0 <= x, x <= 1, x' * weights <= 3)
solve!(p, SCS.Optimizer)
println([items x.value])
# [:Gold 0.9999971880377178
#  :Silver 0.46667637765641057
#  :Bronze 0.9999998036351865]```

## Use with JuMP

This example shows how we can model a simple knapsack problem with JuMP and use SCS to solve it.

```using JuMP, SCS
items  = [:Gold, :Silver, :Bronze]
values = Dict(:Gold => 5.0,  :Silver => 3.0,  :Bronze => 1.0)
weight = Dict(:Gold => 2.0,  :Silver => 1.5,  :Bronze => 0.3)

model = Model(SCS.Optimizer)
@variable(model, 0 <= take[items] <= 1)  # Define a variable for each item
@objective(model, Max, sum(values[item] * take[item] for item in items))
@constraint(model, sum(weight[item] * take[item] for item in items) <= 3)
optimize!(model)
println(value.(take))
# 1-dimensional DenseAxisArray{Float64,1,...} with index sets:
#     Dimension 1, Symbol[:Gold, :Silver, :Bronze]
# And data, a 3-element Array{Float64,1}:
#  1.0000002002226671
#  0.4666659513182934
#  1.0000007732744878```

## MathOptInterface API

The SCS optimizer supports the following constraints and attributes.

List of supported objective functions:

List of supported variable types:

List of supported constraint types:

List of supported model attributes:

## Options

All SCS solver options can be set through `Convex.jl` or `MathOptInterface.jl`.

For example:

```model = Model(optimizer_with_attributes(SCS.Optimizer, "max_iters" => 10))

# via MathOptInterface:
optimizer = SCS.Optimizer()
MOI.set(optimizer, MOI.RawOptimizerAttribute("max_iters"), 10)
MOI.set(optimizer, MOI.RawOptimizerAttribute("verbose"), 0)```

Common options are:

• `max_iters`: the maximum number of iterations to take
• `verbose`: turn printing on (`1`) or off (`0`) See the `glbopts.h` header for other options.

## Linear solvers

`SCS` uses a linear solver internally, see this section of `SCS` documentation. `SCS.jl` ships with

• `SCS.DirectSolver` (sparse direct, the default) and
• `SCS.LinearSolver` (sparse indirect, by conjugate gradient) enabled.

The find currently available linear solvers one can inspect `SCS.available_solvers`:

```julia> using SCS

julia> SCS.available_solvers
2-element Vector{DataType}:
SCS.DirectSolver
SCS.IndirectSolver```

To select the linear solver of choice:

### SCS with MKL Pardiso linear solver

To enable the MKL Pardiso (direct sparse) solver one needs to load `MKL_jll` before `SCS`:

```julia> import Pkg

julia> Pkg.add(Pkg.PackageSpec(name = "MKL_jll", version = "2022.2"))

julia> using MKL_jll    # This must be called before `using SCS`.

julia> using SCS

julia> SCS.available_solvers
3-element Vector{DataType}:
SCS.DirectSolver
SCS.IndirectSolver
SCS.MKLDirectSolver```

The `MKLDirectSolver` is available on `Linux x86_64` platform only.

### SCS with Sparse GPU indirect solver (CUDA only)

To enable the indirect linear solver on GPU one needs to load `CUDA_jll` before `SCS`:

```julia> import Pkg

julia> Pkg.add(Pkg.PackageSpec(name = "CUDA_jll", version = "10.1"))

julia> using CUDA_jll  # This must be called before `using SCS`.

julia> using SCS

julia> SCS.available_solvers
3-element Array{DataType,1}:
SCS.DirectSolver
SCS.IndirectSolver
SCS.GpuIndirectSolver```

The `GpuIndirectSolver` is available on `Linux x86_64` platform only.

## Low-level wrapper

SCS.jl provides a low-level interface to solve a problem directly, without interfacing through MathOptInterface.

This is an advanced interface with a risk of incorrect usage. For new users, we recommend that you use the JuMP or Convex interfaces instead.

SCS solves a problem of the form:

``````minimize        1/2 * x' * P * x + c' * x
subject to      A * x + s = b
s in K
``````

where `K` is a product cone of:

• zero cone
• positive orthant `{ x | x ≥ 0 }`
• box cone `{ (t,x) | t*l ≤ x ≤ t*u}`
• second-order cone (SOC) `{ (t,x) | ||x||_2 ≤ t }`
• semi-definite cone (SDC) `{ X | X is psd }`
• exponential cone `{ (x,y,z) | y e^(x/y) ≤ z, y>0 }`
• power cone `{ (x,y,z) | x^a * y^(1-a) ≥ |z|, x ≥ 0, y ≥ 0 }`
• dual power cone `{ (u,v,w) | (u/a)^a * (v/(1-a))^(1-a) ≥ |w|, u ≥ 0, v ≥ 0 }`.

To solve this problem with SCS, call `SCS.scs_solve`; see the docstring for details.

### Required Packages

View all packages