# Python

After installing you can import SCS using

```
import scs
```

This module provides the `SCS`

class which is initialized using:

```
solver = scs.SCS(data,
cone,
use_indirect=False,
mkl=False,
gpu=False,
verbose=True,
normalize=True,
max_iters=int(1e5),
scale=0.1,
adaptive_scale=True,
eps_abs=1e-4,
eps_rel=1e-4,
eps_infeas=1e-7,
alpha=1.5,
rho_x=1e-6,
acceleration_lookback=10,
acceleration_interval=10,
time_limit_secs=0,
write_data_filename=None,
log_csv_filename=None)
```

where `data`

is a dict containing `P, A, b, c`

, and `cone`

is
a dict that contains the Cones information. The `cone`

dict
contains keys corresponding to the cone type and values corresponding to either
the cone length or the array that defines the cone (see the third column in
Cones for the keys and what the corresponding values represent). The
`b`

, and `c`

entries must be 1d numpy arrays and the `P`

and
`A`

entries must be scipy sparse matrices in CSC format; if they are not
of the proper format, SCS will attempt to convert them. The
`use_indirect`

setting switches between the sparse direct
Linear System Solver (the default) or the sparse indirect solver. If the MKL
Pardiso direct solver for SCS is installed then it can
be used by setting `mkl=True`

. If the GPU indirect solver for SCS is
installed and a GPU is available then it can be used by
setting `gpu=True`

. The remaining fields are explained in
Settings.

Then to solve the problem call:

```
sol = solver.solve(warm_start=True, x=None, y=None, s=None)
```

where `warm_start`

indicates whether the solve will reuse the previous
solution as a warm-start (if this is the first solve it initializes at zero).
A good warm-start can reduce the overall number of iterations required to solve
a problem. 1d Numpy arrays `x,y,s`

are (optional) warm-start overrides if
you wish to set these manually rather than use solution to the last problem as
the warm-start.

At termination `sol`

is a dict with fields `x, y, s, info`

where
`x, y, s`

contains the primal-dual solution or the
certificate of infeasibility, and `info`

is a dict
containing the solve Return information.

To re-use the workspace and solve a similar problem with new `b`

and / or `c`

data, we can update the solver using:

```
solver.update(b=new_b, c=new_c) # update b and c vectors (can be None)
solver.solve() # solve new problem with updated b and c
```