AbstractVariable interface; allow variables to carry constraints (#358)

* Add `AbstractVariable` interface

Docs fixes

Tweak types

* Remove type parametrization from variables

* Add `_value` accessor

* Update NEWS.md

* Fix rebase

* Fix typo

* Add some tests

* Loosen error types in tests for 1.0 compat

* only run CI on PRs, master, and tags

Author: ericphanson

.travis.yml

@@ -6,6 +6,7 @@ os:
 julia:
   - 1.0
   - 1.4
+if: branch = master OR tag IS present OR type = pull_request
 notifications:
   email: false
 jobs:

NEWS.md

@@ -1,3 +1,27 @@
+# Changes in v0.13.4
+
+* You can now create your own variable types by subtyping `AbstractVariable`.
+  See the
+  [docs](https://www.juliaopt.org/Convex.jl/dev/advanced/#Custom-Variable-Types-1)
+  for more information. You can also add constraints directly to a variable
+  using `add_constraint!`. ([#358](https://github.com/JuliaOpt/Convex.jl/pull/358))
+* Accessors `vexity(x::Variable)`, `sign(x::Variable)`, and
+  `evaluate(x::Variable)` should now be the preferred way to access properties
+  of a variable; likewise use `set_value!` to set the initial value of a
+  variable. ([#358](https://github.com/JuliaOpt/Convex.jl/pull/358))
+* To create integer or binary constraints, use the `VarType` enum (e.g.
+  `Variable(BinVar)`). Access or set this via `vartype` and `vartype!`.
+  ([#358](https://github.com/JuliaOpt/Convex.jl/pull/358))
+
+# Changes in v0.13.3
+
+* Make [`add_constraint!`](https://github.com/jump-dev/Convex.jl/pull/381)
+  actually add the constraint to the problem.
+
+# Changes in v0.13.2
+
+* Add [`Convex.MAXDIGITS`](https://github.com/jump-dev/Convex.jl/pull/379)
+
 # Changes in v0.13.1
 
 * Allow disabling DCP warnings ([#372](https://github.com/JuliaOpt/Convex.jl/pull/372))

Project.toml

@@ -1,6 +1,6 @@
 name = "Convex"
 uuid = "f65535da-76fb-5f13-bab9-19810c17039a"
-version = "0.13.3"
+version = "0.13.4"
 
 [deps]
 AbstractTrees = "1520ce14-60c1-5f80-bbc7-55ef81b5835c"

docs/examples_literate/general_examples/basic_usage.jl

@@ -34,7 +34,7 @@ p.constraints += [x >= 1; x <= 10; x[2] <= 5; x[1] + x[4] - x[2] <= 10]
 solve!(p, solver)
 
 println(round(p.optval, digits=2))
-println(round.(x.value, digits=2))
+println(round.(evaluate(x), digits=2))
 println(evaluate(x[1] + x[4] - x[2]))
 
 # ### Matrix Variables and promotions
@@ -55,8 +55,8 @@ y = Variable()
 ## X is a 2 x 2 variable, and y is scalar. X' + y promotes y to a 2 x 2 variable before adding them
 p = minimize(norm(X) + y, 2 * X <= 1, X' + y >= 1, X >= 0, y >= 0)
 solve!(p, solver)
-println(round.(X.value, digits=2))
-println(y.value)
+println(round.(evaluate(X), digits=2))
+println(evaluate(y))
 p.optval
 
 # ### Norm, exponential and geometric mean
@@ -75,7 +75,7 @@ x = Variable(4)
 p = satisfy(norm(x) <= 100, exp(x[1]) <= 5, x[2] >= 7, geomean(x[3], x[4]) >= x[2])
 solve!(p, solver)
 println(p.status)
-x.value
+evaluate(x)
 
 # ### SDP cone and Eigenvalues
 
@@ -92,7 +92,7 @@ y = Variable((2, 2))
 ## SDP constraints
 p = minimize(x + y[1, 1], isposdef(y), x >= 1, y[2, 1] == 1)
 solve!(p, solver)
-y.value
+evaluate(y)
 
 # ### Mixed integer program
 #
@@ -109,6 +109,5 @@ using GLPK
 x = Variable(4, :Int)
 p = minimize(sum(x), x >= 0.5)
 solve!(p, GLPK.Optimizer)
-x.value
-
+evaluate(x)
 #-

docs/examples_literate/general_examples/chebyshev_center.jl

@@ -36,5 +36,5 @@ plot(x, x -> -x * a1[1] / a1[2] + b[1] / a1[2])
 plot!(x, x -> -x * a2[1]/ a2[2] + b[2] / a2[2])
 plot!(x, x -> -x * a3[1]/ a3[2] + b[3] / a3[2])
 plot!(x, x -> -x * a4[1]/ a4[2] + b[4] / a4[2])
-plot!(x_c.value[1] .+ r.value * cos.(theta), x_c.value[2] .+ r.value * sin.(theta), linewidth = 2)
+plot!(evaluate(x_c)[1] .+ evaluate(r) * cos.(theta), evaluate(x_c)[2] .+ evaluate(r) * sin.(theta), linewidth = 2)
 plot!(title ="Largest Euclidean ball lying in a 2D polyhedron", legend = nothing)

docs/examples_literate/general_examples/logistic_regression.jl

@@ -28,6 +28,6 @@ solve!(problem, () -> SCS.Optimizer(verbose=false))
 # Let's see how well the model fits.
 using Plots
 logistic(x::Real) = inv(exp(-x) + one(x))
-perm = sortperm(vec(X*beta.value))
+perm = sortperm(vec(X*evaluate(beta)))
 plot(1:n, (Y[perm] .+ 1)/2, st=:scatter)
-plot!(1:n, logistic.(X*beta.value)[perm])
+plot!(1:n, logistic.(X*evaluate(beta))[perm])

docs/examples_literate/general_examples/max_entropy.jl

@@ -28,4 +28,4 @@ problem.optval
 
 #-
 
-x.value
+evaluate(x)

docs/examples_literate/mixed_integer/aux_files/antidiag.jl

@@ -9,8 +9,7 @@
 # Please read expressions.jl first.
 #############################################################################
 import Convex.sign, Convex.monotonicity, Convex.curvature, Convex.evaluate, Convex.conic_form!
-using Convex: AbstractExpr, Nondecreasing, ConstVexity, UniqueConicForms, has_conic_form, cache_conic_form!, get_conic_form
-using LinearAlgebra, SparseArrays
+using Convex: AbstractExpr, ConstVexity, Nondecreasing, has_conic_form, cache_conic_form, get_conic_form
 export antidiag
 
 ### Diagonal
@@ -67,7 +66,7 @@ antidiag(x::AbstractExpr, k::Int=0) = AntidiagAtom(x, k)
 # 3. We populate coeff with 1s at the correct indices
 # The canonical form will then be:
 # coeff * x - d = 0
-function conic_form!(x::AntidiagAtom, unique_conic_forms::UniqueConicForms=UniqueConicForms())
+function conic_form!(x::AntidiagAtom, unique_conic_forms::Convex.UniqueConicForms)
   if !has_conic_form(unique_conic_forms, x)
     (num_rows, num_cols) = x.children[1].size
     k = x.k

docs/examples_literate/optimization_with_complex_variables/phase_recovery_using_MaxCut.jl

@@ -70,12 +70,13 @@ c1 = diag(U) == 1
 c2 = U in :SDP
 p = minimize(objective,c1,c2)
 solve!(p, () -> SCS.Optimizer(verbose=0))
-U.value
+evaluate(U)
+
 
 #-
 
 # Verify if the rank of $U$ is 1:
-B, C = eigen(U.value);
+B, C = eigen(evaluate(U));
 length([e for e in B if(abs(real(e))>1e-4)])
 
 #- 

docs/examples_literate/optimization_with_complex_variables/power_flow_optimization.jl

@@ -36,12 +36,12 @@ output = matopen("Res.mat")
 names(output)
 outputData = read(output, "Wres");
 Wres = outputData
-real_diff = real(W.value) - real(Wres);
-imag_diff = imag(W.value) - imag(Wres);
+real_diff = real(evaluate(W)) - real(Wres);
+imag_diff = imag(evaluate(W)) - imag(Wres);
 @test real_diff ≈ zeros(n, n) atol = TOL
 @test imag_diff ≈ zeros(n, n) atol = TOL
 
-real_diff = real(W.value) - (real(W.value))';
-imag_sum = imag(W.value) + (imag(W.value))';
+real_diff = real(evaluate(W)) - (real(evaluate(W)))';
+imag_sum = imag(evaluate(W)) + (imag(evaluate(W)))';
 @test real_diff ≈ zeros(n, n) atol = TOL
 @test imag_diff ≈ zeros(n, n) atol = TOL