Merge pull request #7 from JuliaOptimizationVariationalAnalysis/add-api-test

Add api tests

Author: tmigot

Project.toml

@@ -9,6 +9,7 @@ FastClosures = "9aa1b823-49e4-5ca5-8b0f-3971ec8bab6a"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 Logging = "56ddb016-857b-54e1-b83d-db4d58db5568"
 NLPModels = "a4795742-8479-5a88-8948-cc11e1c8c1a6"
+SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 Stopping = "c4fe5a9e-e7fb-5c3d-89d5-7f405ab2214f"
 
 [compat]

src/VariationalInequalitySolver.jl

@@ -1,6 +1,6 @@
 module VariationalInequalitySolver
 
-using FastClosures, LinearAlgebra, Logging, NLPModels, Stopping
+using FastClosures, LinearAlgebra, Logging, NLPModels, SparseArrays, Stopping
 
 import NLPModels:
   residual!,

src/model/api.jl

@@ -4,13 +4,13 @@ export jtprod_residual, jtprod_residual!, jac_op_residual, jac_op_residual!
 export hess_residual, hess_structure_residual, hess_structure_residual!
 export hess_coord_residual!, hess_coord_residual, jth_hess_residual
 export hprod_residual, hprod_residual!, hess_op_residual, hess_op_residual!
-export project!, project
+export project!, project, get_meta
 
 """
     Fx = residual(model, x)
 Computes ``F(x)``, the residual at x.
 """
-function residual(model::AbstractVIModel{T, S}, x::AbstractVector{T}) where {T, S}
+function NLPModels.residual(model::AbstractVIModel{T, S}, x::AbstractVector{T}) where {T, S}
   @lencheck model.meta.nvar x
   Fx = S(undef, model.meta.nvar)
   residual!(model, x, Fx)
@@ -26,7 +26,7 @@ function residual! end
     Jx = jac_residual(model, x)
 Computes ``J(x)``, the Jacobian of the residual at x.
 """
-function jac_residual(model::AbstractVIModel, x::AbstractVector)
+function NLPModels.jac_residual(model::AbstractVIModel, x::AbstractVector)
   @lencheck model.meta.nvar x
   rows, cols = jac_structure_residual(model)
   vals = jac_coord_residual(model, x)
@@ -43,9 +43,9 @@ function jac_structure_residual! end
     (rows,cols) = jac_structure_residual(model)
 Returns the structure of the constraint's Jacobian in sparse coordinate format.
 """
-function jac_structure_residual(model::AbstractVIModel)
-  rows = Vector{Int}(undef, model.nnzj)
-  cols = Vector{Int}(undef, model.nnzj)
+function NLPModels.jac_structure_residual(model::AbstractVIModel)
+  rows = Vector{Int}(undef, model.meta.nnzj)
+  cols = Vector{Int}(undef, model.meta.nnzj)
   jac_structure_residual!(model, rows, cols)
 end
 
@@ -60,17 +60,17 @@ function jac_coord_residual! end
     (rows,cols,vals) = jac_coord_residual(model, x)
 Computes the Jacobian of the residual at `x` in sparse coordinate format.
 """
-function jac_coord_residual(model::AbstractVIModel, x::AbstractVector)
+function NLPModels.jac_coord_residual(model::AbstractVIModel, x::AbstractVector)
   @lencheck model.meta.nvar x
-  vals = Vector{eltype(x)}(undef, model.nnzj)
+  vals = Vector{eltype(x)}(undef, model.meta.nnzj)
   jac_coord_residual!(model, x, vals)
 end
 
 """
     Jv = jprod_residual(model, x, v)
 Computes the product of the Jacobian of the residual at x and a vector, i.e.,  ``J(x)v``.
 """
-function jprod_residual(
+function NLPModels.jprod_residual(
   model::AbstractVIModel{T, S},
   x::AbstractVector{T},
   v::AbstractVector,
@@ -91,43 +91,25 @@ function jprod_residual! end
 Computes the product of the Jacobian of the residual given by `(rows, cols, vals)`
 and a vector, i.e.,  ``J(x)v``, storing it in `Jv`.
 """
-function jprod_residual!(
+function NLPModels.jprod_residual!(
   model::AbstractVIModel,
   rows::AbstractVector{<:Integer},
   cols::AbstractVector{<:Integer},
   vals::AbstractVector,
   v::AbstractVector,
   Jv::AbstractVector,
 )
-  @lencheck model.nnzj rows cols vals
+  @lencheck model.meta.nnzj rows cols vals
   @lencheck model.meta.nvar v Jv
   increment!(model, :neval_jprod_residual)
   coo_prod!(rows, cols, vals, v, Jv)
 end
 
-"""
-    Jv = jprod_residual!(model, x, rows, cols, v, Jv)
-Computes the product of the Jacobian of the residual at x and a vector, i.e.,  ``J(x)v``, storing it in `Jv`.
-The structure of the Jacobian is given by `(rows, cols)`.
-"""
-function jprod_residual!(
-  model::AbstractVIModel,
-  x::AbstractVector,
-  rows::AbstractVector{<:Integer},
-  cols::AbstractVector{<:Integer},
-  v::AbstractVector,
-  Jv::AbstractVector,
-)
-  @lencheck model.meta.nvar x v Jv
-  @lencheck model.nnzj rows cols
-  jprod_residual!(model, x, v, Jv)
-end
-
 """
     Jtv = jtprod_residual(model, x, v)
 Computes the product of the transpose of the Jacobian of the residual at x and a vector, i.e.,  ``J(x)^Tv``.
 """
-function jtprod_residual(
+function NLPModels.jtprod_residual(
   model::AbstractVIModel{T, S},
   x::AbstractVector{T},
   v::AbstractVector,
@@ -148,104 +130,45 @@ function jtprod_residual! end
 Computes the product of the transpose of the Jacobian of the residual given by `(rows, cols, vals)`
 and a vector, i.e.,  ``J(x)^Tv``, storing it in `Jv`.
 """
-function jtprod_residual!(
+function NLPModels.jtprod_residual!(
   model::AbstractVIModel,
   rows::AbstractVector{<:Integer},
   cols::AbstractVector{<:Integer},
   vals::AbstractVector,
   v::AbstractVector,
   Jtv::AbstractVector,
 )
-  @lencheck model.nnzj rows cols vals
+  @lencheck model.meta.nnzj rows cols vals
   @lencheck model.meta.nvar v Jtv
   increment!(model, :neval_jtprod_residual)
   coo_prod!(cols, rows, vals, v, Jtv)
 end
 
-"""
-    Jtv = jtprod_residual!(model, x, rows, cols, v, Jtv)
-Computes the product of the transpose Jacobian of the residual at x and a vector, i.e.,  ``J(x)^Tv``, storing it in `Jv`.
-The structure of the Jacobian is given by `(rows, cols)`.
-"""
-function jtprod_residual!(
-  model::AbstractVIModel,
-  x::AbstractVector,
-  rows::AbstractVector{<:Integer},
-  cols::AbstractVector{<:Integer},
-  v::AbstractVector,
-  Jtv::AbstractVector,
-)
-  @lencheck model.meta.nvar x v Jtv
-  @lencheck model.nnzj rows cols
-  jtprod_residual!(model, x, v, Jtv)
-end
-
 """
     Jx = jac_op_residual(model, x)
 Computes ``J(x)``, the Jacobian of the residual at x, in linear operator form.
 """
-function jac_op_residual(model::AbstractVIModel{T, S}, x::AbstractVector{T}) where {T, S}
+function NLPModels.jac_op_residual(model::AbstractVIModel{T, S}, x::AbstractVector{T}) where {T, S}
   @lencheck model.meta.nvar x
   Jv = S(undef, model.meta.nvar)
   Jtv = S(undef, model.meta.nvar)
   return jac_op_residual!(model, x, Jv, Jtv)
 end
 
-"""
-    Jx = jac_op_residual!(model, x, Jv, Jtv)
-Computes ``J(x)``, the Jacobian of the residual at x, in linear operator form. The
-vectors `Jv` and `Jtv` are used as preallocated storage for the operations.
-"""
-function jac_op_residual!(
-  model::AbstractVIModel,
-  x::AbstractVector,
-  Jv::AbstractVector,
-  Jtv::AbstractVector,
-)
-  @lencheck model.meta.nvar x Jv Jtv
-  prod! = @closure (res, v, α, β) -> begin
-    jprod_residual!(model, x, v, Jv)
-    if β == 0
-      @. res = α * Jv
-    else
-      @. res = α * Jv + β * res
-    end
-    return res
-  end
-  ctprod! = @closure (res, v, α, β) -> begin
-    jtprod_residual!(model, x, v, Jtv)
-    if β == 0
-      @. res = α * Jtv
-    else
-      @. res = α * Jtv + β * res
-    end
-    return res
-  end
-  return LinearOperator{eltype(x)}(
-    model.meta.nvar,
-    model.meta.nvar,
-    false,
-    false,
-    prod!,
-    ctprod!,
-    ctprod!,
-  )
-end
-
 """
     Jx = jac_op_residual!(model, rows, cols, vals, Jv, Jtv)
 Computes ``J(x)``, the Jacobian of the residual given by `(rows, cols, vals)`, in linear operator form. The
 vectors `Jv` and `Jtv` are used as preallocated storage for the operations.
 """
-function jac_op_residual!(
+function NLPModels.jac_op_residual!(
   model::AbstractVIModel,
   rows::AbstractVector{<:Integer},
   cols::AbstractVector{<:Integer},
   vals::AbstractVector,
   Jv::AbstractVector,
   Jtv::AbstractVector,
 )
-  @lencheck model.nnzj rows cols vals
+  @lencheck model.meta.nnzj rows cols vals
   @lencheck model.meta.nvar Jv Jtv
   prod! = @closure (res, v, α, β) -> begin
     jprod_residual!(model, rows, cols, vals, v, Jv)
@@ -276,34 +199,13 @@ function jac_op_residual!(
   )
 end
 
-"""
-    Jx = jac_op_residual!(model, x, rows, cols, Jv, Jtv)
-Computes ``J(x)``, the Jacobian of the residual at x, in linear operator form. The
-vectors `Jv` and `Jtv` are used as preallocated storage for the operations.
-The structure of the Jacobian should be given by `(rows, cols)`.
-"""
-function jac_op_residual!(
-  model::AbstractVIModel,
-  x::AbstractVector,
-  rows::AbstractVector{<:Integer},
-  cols::AbstractVector{<:Integer},
-  Jv::AbstractVector,
-  Jtv::AbstractVector,
-)
-  @lencheck model.meta.nvar x Jv Jtv
-  @lencheck model.nnzj rows cols
-  vals = jac_coord_residual(model, x)
-  decrement!(model, :neval_jac_residual)
-  return jac_op_residual!(model, rows, cols, vals, Jv, Jtv)
-end
-
 """
     H = hess_residual(model, x, v)
 Computes the linear combination of the Hessians of the residuals at `x` with coefficients
 `v`.
 A `Symmetric` object wrapping the lower triangle is returned.
 """
-function hess_residual(model::AbstractVIModel, x::AbstractVector, v::AbstractVector)
+function NLPModels.hess_residual(model::AbstractVIModel, x::AbstractVector, v::AbstractVector)
   @lencheck model.meta.nvar x v
   rows, cols = hess_structure_residual(model)
   vals = hess_coord_residual(model, x, v)
@@ -314,9 +216,9 @@ end
     (rows,cols) = hess_structure_residual(model)
 Returns the structure of the residual Hessian.
 """
-function hess_structure_residual(model::AbstractVIModel)
-  rows = Vector{Int}(undef, model.nnzh)
-  cols = Vector{Int}(undef, model.nnzh)
+function NLPModels.hess_structure_residual(model::AbstractVIModel)
+  rows = Vector{Int}(undef, model.meta.nnzh)
+  cols = Vector{Int}(undef, model.meta.nnzh)
   hess_structure_residual!(model, rows, cols)
 end
 
@@ -338,17 +240,17 @@ function hess_coord_residual! end
 Computes the linear combination of the Hessians of the residuals at `x` with coefficients
 `v` in sparse coordinate format.
 """
-function hess_coord_residual(model::AbstractVIModel, x::AbstractVector, v::AbstractVector)
+function NLPModels.hess_coord_residual(model::AbstractVIModel, x::AbstractVector, v::AbstractVector)
   @lencheck model.meta.nvar x v
-  vals = Vector{eltype(x)}(undef, model.nnzh)
+  vals = Vector{eltype(x)}(undef, model.meta.nnzh)
   hess_coord_residual!(model, x, v, vals)
 end
 
 """
     Hj = jth_hess_residual(model, x, j)
 Computes the Hessian of the j-th residual at x.
 """
-function jth_hess_residual(model::AbstractVIModel, x::AbstractVector, j::Int)
+function NLPModels.jth_hess_residual(model::AbstractVIModel, x::AbstractVector, j::Int)
   @lencheck model.meta.nvar x
   increment!(model, :neval_jhess_residual)
   decrement!(model, :neval_hess_residual)
@@ -360,7 +262,7 @@ end
     Hiv = hprod_residual(model, x, i, v)
 Computes the product of the Hessian of the i-th residual at x, times the vector v.
 """
-function hprod_residual(
+function NLPModels.hprod_residual(
   model::AbstractVIModel{T, S},
   x::AbstractVector{T},
   i::Int,
@@ -381,38 +283,12 @@ function hprod_residual! end
     Hop = hess_op_residual(model, x, i)
 Computes the Hessian of the i-th residual at x, in linear operator form.
 """
-function hess_op_residual(model::AbstractVIModel{T, S}, x::AbstractVector{T}, i::Int) where {T, S}
+function NLPModels.hess_op_residual(model::AbstractVIModel{T, S}, x::AbstractVector{T}, i::Int) where {T, S}
   @lencheck model.meta.nvar x
   Hiv = S(undef, model.meta.nvar)
   return hess_op_residual!(model, x, i, Hiv)
 end
 
-"""
-    Hop = hess_op_residual!(model, x, i, Hiv)
-Computes the Hessian of the i-th residual at x, in linear operator form. The vector `Hiv` is used as preallocated storage for the operation.
-"""
-function hess_op_residual!(model::AbstractVIModel, x::AbstractVector, i::Int, Hiv::AbstractVector)
-  @lencheck model.meta.nvar x Hiv
-  prod! = @closure (res, v, α, β) -> begin
-    hprod_residual!(model, x, i, v, Hiv)
-    if β == 0
-      @. res = α * Hiv
-    else
-      @. res = α * Hiv + β * res
-    end
-    return res
-  end
-  return LinearOperator{eltype(x)}(
-    model.meta.nvar,
-    model.meta.nvar,
-    true,
-    true,
-    prod!,
-    prod!,
-    prod!,
-  )
-end
-
 get_meta(model::AbstractVIModel) = model.meta
 
 """

test/runtests.jl

@@ -11,3 +11,27 @@ Random.seed!(1234)
   @test project(vi, xr) == xr
   sol = ProjectionVI(vi, xr)
 end
+
+@testset "Test API AbstractVIModel" begin
+  for T in [Float16, Float32, Float64]
+    nls = ADNLSModel(x -> [x[1] - 1; 10 * (x[2] - x[1]^2)], T[-1.2; 1.0], 2)
+    vi = NLSVIModel(nls)
+
+    @test get_meta(vi) == vi.meta
+
+    xr = ones(T, 2)
+    @test residual(vi, xr) == T[0; 0]
+    J = T[ 1 0; -20 10]
+    @test jac_residual(vi, xr) == J
+    v = ones(T, 2)
+    @test jprod_residual(vi, xr, v) == T[1; -10]
+    @test jtprod_residual(vi, xr, v) == T[-19; 10]
+    J = jac_op_residual(vi, xr)
+    @test J * v == T[1; -10]
+    @test J' * v == T[-19; 10]
+    @test hess_residual(vi, xr, xr) == T[-20 0; 0 0]
+    @test hprod_residual(vi, xr, 2, v) == T[-20; 0]
+    H = hess_op_residual(vi, xr, 2)
+    @test H * v == T[-20; 0]
+  end
+end