changed README

Author: nantonel

README.md

@@ -1,82 +1,45 @@
 # StructuredOptimization.jl
 
-Convex and nonconvex regularized least squares in Julia.
+`StructuredOptimization.jl` is a high-level modeling language
+that utilizes a syntax that is very close to
+the mathematical formulation of an optimization problem.
 
-## Installation
-
-From the Julia command line hit `Pkg.clone("https://github.com/nantonel/StructuredOptimization.jl.git")`.
-Once the package is installed you can update it along with the others issuing
-`Pkg.update()` in the command line.
-
-## Usage
+This user-friendly interface
+acts as a parser to utilize
+three different packages:
 
-With StructuredOptimization.jl you can solve problems of the form
+* [`ProximalOperators.jl`](https://github.com/kul-forbes/ProximalOperators.jl)
 
-```
-minimize (1/2)*||L(x) - b||^2 + g(x)
-```
+* [`AbstractOperators.jl`](https://github.com/kul-forbes/ProximalOperators.jl)
 
-Here `L` is a linear operator, `b` is an `Array` of data, and `g` is a regularization
-taken from [ProximalOperators.jl](https://github.com/kul-forbes/ProximalOperators.jl).
-You can use any `AbstractMatrix` object to describe `L`, or any matrix-like object
-implementing the matrix-vector product and transpose operations
-(see for example [LinearOperators.jl](https://github.com/JuliaSmoothOptimizers/LinearOperators.jl)).
-Alternatively, you can provide the direct and adjoint mappings in the form of `Function` objects.
+* [`ProximalAlgorithms.jl`](https://github.com/kul-forbes/ProximalAlgorithms.jl)
 
-```julia
-x, info = solve(L, b, g) # L is a matrix-like object
-x, info = solve(Op, OpAdj, b, g, x0) # Op and OpAdj are of type Function
-```
+`StructuredOptimization.jl` can handle large-scale convex and nonconvex problems with nonsmooth cost functions. 
 
-The dimensions of `b` must match the ones of `L` or `Op` and `OpAdj`.
-Argument `x0` (the initial iterate for the algorithm) is compulsory when
-mappings `Op` and `OpAdj` are provided.
+It supports complex variables as well.
 
-## Example: sparse signal reconstruction
+## Installation
 
-Consider the problem of recovering a sparse signal, observed through a measurement
-matrix `A` which is orthogonal. A random instance of such problem is generated as
-follows, where measurements are affected by Gaussian noise:
+From the Julia command line hit `Pkg.clone("https://github.com/nantonel/StructuredOptimization.jl.git")`.
+Once the package is installed you can update it along with the others issuing `Pkg.update()` in the command line.
 
-```julia
-m, n, k = 1024, 4096, 160 # problem parameters
-B = randn(m, n)
-Q, R = qr(B')
-A = Q' # measurement matrix
-x_orig = sign(randn(n))
-J = randperm(n)
-x_orig[J[k+1:end]] = 0 # generate sparse -1/+1 signal
-sigma = 1e-2
-y = A*x_orig + sigma*randn(m) # add noise to measurement
-```
+## Usage
 
-One way to approximately reconstruct `x_orig` is to solve an L1-regularized
-least squares problem using the `NormL0` function, as in the following snippet
-(parameters here are taken from [this paper](http://ieeexplore.ieee.org/xpls/abs_all.jsp?arnumber=4407767)):
+A *least absolute shrinkage and selection operator* (LASSO) can be solved with only few lines of code:
 
 ```julia
-using StructuredOptimization
-using ProximalOperators
-lambda_max = norm(A'*y, Inf)
-lambda = 0.01*lambda_max # regularization parameter
-x_L1, info = solve(A, y, normL1(lambda), zeros(n))
-```
+julia> using StructuredOptimization
 
-Alternatively, one can use the `indBallL0` regularizer to look for the best
-approximation with a given number of nonzero coefficients:
+julia> n, m = 100, 10;                # define problem size 
 
-```julia
-x_L0c, info = solve(A, y, indBallL0(200), zeros(n))
-```
+julia> A, y = randn(m,n), randn(m);   # random problem data
 
-## References
+julia> x = Variable(n);               # initialize optimization variable
 
-The algorithms implemented in StructuredOptimization.jl are described in the following papers.
+julia> λ = 1e-2*norm(A'*y,Inf);       # define λ    
 
-1. L. Stella, A. Themelis, P. Patrinos, “Forward-backward quasi-Newton methods for nonsmooth optimization problems,” [arXiv:1604.08096](http://arxiv.org/abs/1604.08096) (2016).
+julia> @minimize ls( A*x - y ) + λ*norm(x, 1); # minimize problem
 
-2. A. Themelis, L. Stella, P. Patrinos, “Forward-backward envelope for the sum of two nonconvex functions: Further properties and nonmonotone line-search algorithms,” [arXiv:1606.06256](http://arxiv.org/abs/1606.06256) (2016).
-
-## Credits
+```
 
-StructuredOptimization.jl is developed by [Lorenzo Stella](https://lostella.github.io) and [Niccolò Antonello](http://homes.esat.kuleuven.be/~nantonel/) at [KU Leuven, ESAT/Stadius](https://www.esat.kuleuven.be/stadius/).
+See the [documentation]() for more details about the type of problems `StructuredOptimization.jl` can handle and the [demos]() to check out some examples.

docs/src/index.md

@@ -16,6 +16,12 @@ three different packages:
 
 `StructuredOptimization.jl` can handle large-scale convex and nonconvex problems with nonsmooth cost functions. It supports complex variables as well. See the demos and the [Quick tutorial guide](@ref).
 
+## Installation
+
+From the Julia command line hit `Pkg.clone("https://github.com/nantonel/StructuredOptimization.jl.git")`.
+Once the package is installed you can update it along with the others issuing
+`Pkg.update()` in the command line.
+
 ## Citing
 
 If you use `StructuredOptimization.jl` for published work, we encourage you to cite:

docs/src/tutorial.md

@@ -20,7 +20,7 @@ The *least absolute shrinkage and selection operator* (LASSO) belongs to this cl
 
 Here the squared norm $\tfrac{1}{2} \| \mathbf{A} \mathbf{x} - \mathbf{y} \|^2$ is a *smooth* function $f$ wherelse the $l_1$-norm is a *nonsmooth* function $g$.
 
-This problem can be solved using `StructuredOptimization.jl` using only few lines of code:
+This problem can be solved with only few lines of code:
 
 ```julia
 julia> using StructuredOptimization