Add missing methods and tests (#7)

* add missing methods

* add tests

* drop julia 0.7 support

* add NLPModelsIpopt to dependencies

* fix indentation

* fix indentation mistakes

* small corrections

* fix mistake in objective value test

* now using NLPs Counter and changes how functions are overwritten

* Order jac and hess functions

* separate imports in test and fix indentation

* put imports in alphabetical order

Author: RenanOD

.appveyor.yml

@@ -1,7 +1,8 @@
 environment:
   matrix:
-  - julia_version: 0.7
   - julia_version: 1
+  - julia_version: 1.1
+  - julia_version: 1.2
   - julia_version: nightly
 
 platform:

Project.toml

@@ -8,6 +8,7 @@ FastClosures = "9aa1b823-49e4-5ca5-8b0f-3971ec8bab6a"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 LinearOperators = "5c8ed15e-5a4c-59e4-a42b-c7e8811fb125"
 NLPModels = "a4795742-8479-5a88-8948-cc11e1c8c1a6"
+NLPModelsIpopt = "f4238b75-b362-5c4c-b852-0801c9a21d71"
 Requires = "ae029012-a4dd-5104-9daa-d747884805df"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"

src/QuadraticModels.jl

@@ -1,15 +1,16 @@
 module QuadraticModels
 
-using FastClosures
-using LinearOperators
-using NLPModels
-using Requires
+# stdlib
+using LinearAlgebra, SparseArrays
 
-using LinearAlgebra
-using SparseArrays
+# our packages
+using LinearOperators, NLPModels
+
+# auxiliary packages
+using FastClosures, Requires
 
 import NLPModels:
-    objgrad, objgrad!, obj,grad, grad!,
+    objgrad, objgrad!, obj, grad, grad!,
     hess_coord, hess, hess_op, hprod,
     cons, cons!,
     jac_coord, jac, jac_op, jprod, jtprod

src/qpmodel.jl

@@ -1,31 +1,27 @@
-mutable struct QPData
-    c0::Float64                 # constant term in objective
-    c::AbstractVector{Float64}  # linear term
-    H::AbstractMatrix{Float64}  # quadratic term
-    opH::AbstractLinearOperator # assumed with preallocation!
-    A::AbstractMatrix{Float64}  # constraint matrix
-end
+# override some NLPModels functions
+export jac_structure!, hess_structure!, jac_coord!, hess_coord!
 
-mutable struct QPCounters
-    neval_hprod::Int  # number of products with H
-    neval_jprod::Int  # number of products with A
-    neval_jtprod::Int # number of products with A'
-    QPCounters() = new(0, 0, 0)
+mutable struct QPData
+    c0  :: Float64                  # constant term in objective
+    c   :: AbstractVector{Float64}  # linear term
+    H   :: AbstractMatrix{Float64}  # quadratic term
+    opH :: AbstractLinearOperator   # assumed with preallocation!
+    A   :: AbstractMatrix{Float64}  # constraint matrix
 end
 
 abstract type AbstractQuadraticModel <: AbstractNLPModel end
 
 mutable struct QuadraticModel <: AbstractQuadraticModel
-  meta::NLPModelMeta
-  counters::QPCounters
-  data::QPData
-
-  function QuadraticModel(c::AbstractVector{Float64}, H::AbstractMatrix{Float64},
-                          opH::AbstractLinearOperator,
-                          A::AbstractMatrix{Float64},
-                          lcon::AbstractVector{Float64}, ucon::AbstractVector{Float64},
-                          lvar::AbstractVector{Float64}, uvar::AbstractVector{Float64};
-                          c0::Float64=0.0, kwargs...)
+    meta     :: NLPModelMeta
+    counters :: Counters
+    data     :: QPData
+
+  function QuadraticModel(c :: AbstractVector{Float64}, H :: AbstractMatrix{Float64},
+                          opH :: AbstractLinearOperator,
+                          A :: AbstractMatrix{Float64},
+                          lcon :: AbstractVector{Float64}, ucon :: AbstractVector{Float64},
+                          lvar :: AbstractVector{Float64}, uvar :: AbstractVector{Float64};
+                          c0 :: Float64=0.0, kwargs...)
     ncon, nvar = size(A)
     nnzh = issparse(H) ? nnz(H) : (nvar * (nvar + 1) / 2)
     nnzj = issparse(A) ? nnz(A) : (nvar * ncon)
@@ -35,12 +31,12 @@ mutable struct QuadraticModel <: AbstractQuadraticModel
                      nnzj=nnzj,
                      nnzh=nnzh,
                      lin=1:ncon, nln=Int[], islp=(ncon == 0); kwargs...),
-        QPCounters(),
+        Counters(),
         QPData(c0, c, H, opH, A))
   end
 end
 
-function QuadraticModel(model::AbstractNLPModel)
+function QuadraticModel(model :: AbstractNLPModel)
     nvar = model.meta.nvar
     ncon = model.meta.ncon
     z = zeros(nvar)
@@ -54,76 +50,108 @@ end
 
 linobj(qp::AbstractQuadraticModel, args...) = qp.data.c
 
-function objgrad(qp::AbstractQuadraticModel, x::AbstractVector)
+function objgrad(qp :: AbstractQuadraticModel, x :: AbstractVector)
     g = Vector{eltype(x)}(length(x))
     objgrad!(qp, x, g)
 end
 
-function objgrad!(qp::AbstractQuadraticModel, x::AbstractVector, g::AbstractVector)
+function objgrad!(qp :: AbstractQuadraticModel, x :: AbstractVector, g :: AbstractVector)
     v = qp.data.opH * x
     @. g = qp.data.c + v
     f = qp.data.c0 + dot(qp.data.c, x) + 0.5 * dot(v, x)
     qp.counters.neval_hprod += 1
     (f, g)
 end
 
-function obj(qp::AbstractQuadraticModel, x::AbstractVector)
+function obj(qp :: AbstractQuadraticModel, x :: AbstractVector)
     v = qp.data.opH * x
     f = qp.data.c0 + dot(qp.data.c, x) + 0.5 * dot(v, x)
     qp.counters.neval_hprod += 1
     f
 end
 
-function grad(qp::AbstractQuadraticModel, x::AbstractVector)
+function grad(qp :: AbstractQuadraticModel, x :: AbstractVector)
     g = Vector{eltype(x)}(undef, qp.meta.nvar)
     grad!(qp, x, g)
 end
 
-function grad!(qp::AbstractQuadraticModel, x::AbstractVector, g::AbstractVector)
+function grad!(qp :: AbstractQuadraticModel, x :: AbstractVector, g :: AbstractVector)
     v = qp.data.opH * x
     @. g = qp.data.c + v
     qp.counters.neval_hprod += 1
     g
 end
 
-hess_coord(qp::AbstractQuadraticModel, ::AbstractVector; kwargs...) = findnz(qp.data.H)
+hess(qp :: AbstractQuadraticModel, ::AbstractVector; kwargs...) = qp.data.H
+
+hess_op(qp :: AbstractQuadraticModel, ::AbstractVector; kwargs...) = qp.data.opH
+
+hess_coord(qp :: AbstractQuadraticModel, ::AbstractVector; kwargs...) = findnz(qp.data.H)
+
+"""
+Return the structure of the Lagrangian Hessian in sparse coordinate format in place.
+"""
+function NLPModels.hess_structure!(qp :: QuadraticModel, rows :: Vector{<: Integer}, cols :: Vector{<: Integer}; kwargs...)
+    rows .= qp.data.H.rowval
+    cols .= findnz(qp.data.H)[2]
+end
+
+"""
+Evaluate the Lagrangian Hessian at `x` in sparse coordinate format. Only the lower triangle is returned.
+"""
+function NLPModels.hess_coord!(qp :: QuadraticModel, :: AbstractVector, rows :: AbstractVector{<: Integer},
+                               cols :: AbstractVector{<: Integer}, vals :: Vector{<: AbstractFloat}; kwargs...)
+    vals .= findnz(qp.data.H)[3]
+end
 
-hess(qp::AbstractQuadraticModel, ::AbstractVector; kwargs...) = qp.data.H
+jac(qp :: AbstractQuadraticModel, ::AbstractVector; kwargs...) = qp.data.A
 
-hess_op(qp::AbstractQuadraticModel, ::AbstractVector; kwargs...) = qp.data.opH
+jac_op(qp :: AbstractQuadraticModel, ::AbstractVector; kwargs...) = LinearOperator(qp.data.A)
 
-function cons(qp::AbstractQuadraticModel, x::AbstractVector)
+jac_coord(qp :: AbstractQuadraticModel, ::AbstractVector; kwargs...) = findnz(qp.data.A)
+
+"""
+Return the structure of the constraints Jacobian in sparse coordinate format in place.
+"""
+function NLPModels.jac_structure!(qp :: QuadraticModel, rows :: Vector{<: Integer}, cols :: Vector{<: Integer}; kwargs...)
+    rows .= qp.data.A.rowval
+    cols .= findnz(qp.data.A)[2]
+end
+
+"""
+Return the structure of the constraints Jacobian in sparse coordinate format in place.
+"""
+function NLPModels.jac_coord!(qp :: QuadraticModel, x :: AbstractVector, rows :: Vector{<: Integer},
+                              cols :: Vector{<: Integer}, vals :: Vector{<: AbstractFloat}; kwargs...)
+    vals .= findnz(qp.data.A)[3]
+end
+
+function cons(qp::AbstractQuadraticModel, x :: AbstractVector)
     c = Vector{eltype(x)}(undef, qp.meta.ncon)
     cons!(qp, x, c)
 end
 
-function cons!(qp::AbstractQuadraticModel, x::AbstractVector, c::AbstractVector)
+function cons!(qp :: AbstractQuadraticModel, x :: AbstractVector, c :: AbstractVector)
     mul!(c, qp.data.A, x)
     qp.counters.neval_jprod += 1
     c
 end
 
-jac_coord(qp::AbstractQuadraticModel, ::AbstractVector; kwargs...) = findnz(qp.data.A)
-
-jac(qp::AbstractQuadraticModel, ::AbstractVector; kwargs...) = qp.data.A
-
-jac_op(qp::AbstractQuadraticModel, ::AbstractVector; kwargs...) = LinearOperator(qp.data.A)
-
-function hprod(qp::AbstractQuadraticModel, ::AbstractVector; kwargs...)
+function hprod(qp :: AbstractQuadraticModel, ::AbstractVector; kwargs...)
     @closure v -> begin
         qp.counters.neval_hprod += 1
         qp.data.opH * v
     end
 end
 
-function jprod(qp::AbstractQuadraticModel, ::AbstractVector; kwargs...)
+function jprod(qp :: AbstractQuadraticModel, ::AbstractVector; kwargs...)
     @closure v -> begin
         qp.counters.neval_jprod += 1
         qp.data.A * v
     end
 end
 
-function jtprod(qp::AbstractQuadraticModel, ::AbstractVector; kwargs...)
+function jtprod(qp :: AbstractQuadraticModel, ::AbstractVector; kwargs...)
     @closure v -> begin
         qp.counters.neval_jtprod += 1
         qp.data.A' * v

test/runtests.jl

@@ -1,3 +1,25 @@
-using QuadraticModels
+# stdlib
+using SparseArrays, Test
 
-true
+# our packages
+using LinearOperators, NLPModels, NLPModelsIpopt, QuadraticModels
+
+@testset "QuadraticModelsTests" begin
+	c0        = 0.0
+	c         = [1.5; -2.0]
+	Q         = sparse([1; 2; 2], [1; 1; 2], [8.0; 2.0; 10.0])
+	A         = sparse([1; 2; 1; 2], [1; 1; 2; 2], [2.0; -1.0; 1.0; 2.0])
+	lcon      = [2.0; -Inf]
+	ucon      = [Inf; 6.0]
+	uvar      = [20; Inf]
+	lvar      = [0.0; 0.0]
+	objective = 4.3718750e+00
+
+	qp     = QuadraticModel(c, Q, opHermitian(Q), A, lcon, ucon, lvar, uvar, c0 = c0)
+	output = ipopt(qp, print_level = 0)
+
+	@test output.dual_feas                      < 1e-6
+	@test output.primal_feas                    < 1e-6
+	@test abs(output.objective - objective)     < 1e-6
+
+end # testset