Add a structure LinearModel

Author: amontoison

ext/QuadraticModelsQPSReaderExt.jl

@@ -21,4 +21,19 @@ function QuadraticModels.QuadraticModel(qps::QPSReader.QPSData, x0 = zeros(qps.n
   )
 end
 
+function QuadraticModels.LinearModel(qps::QPSReader.QPSData, x0 = zeros(qps.nvar))
+  QuadraticModels.LinearModel(
+    qps.c,
+    Arows = qps.arows,
+    Acols = qps.acols,
+    Avals = qps.avals,
+    lcon = qps.lcon,
+    ucon = qps.ucon,
+    lvar = qps.lvar,
+    uvar = qps.uvar,
+    c0 = qps.c0,
+    x0 = x0,
+  )
+end
+
 end

src/QuadraticModels.jl

@@ -27,10 +27,11 @@ import NLPModelsModifiers: SlackModel, slack_meta
 
 import Base.convert
 
-export AbstractQuadraticModel, QuadraticModel, presolve, postsolve, postsolve!, QMSolution
+export AbstractQuadraticModel, LinearModel, QuadraticModel, presolve, postsolve, postsolve!, QMSolution
 
 include("linalg_utils.jl")
 include("qpmodel.jl")
+include("lpmodel.jl")
 include("presolve/presolve.jl")
 
 end # module

src/lpmodel.jl

@@ -0,0 +1,210 @@
+"""
+    lp = LinearModel(c; Arows = Arows, Acols = Acols, Avals = Avals,
+                     lcon = lcon, ucon = ucon, lvar = lvar, uvar = uvar, c0=c0, sortcols = false)
+
+    lp = LinearModel(c; A = A, lcon = lcon, ucon = ucon, lvar = lvar, uvar = uvar, c0 = c0)
+
+Create a Linear model ``min ~c^T x + c_0`` with optional bounds
+`lvar ≦ x ≦ uvar` and optional linear constraints `lcon ≦ Ax ≦ ucon`.
+
+With the first constructor, if `sortcols = true`, then `Acols` is sorted in ascending order 
+(`Arows` and `Avals` are then sorted accordingly).
+
+You can also use [`QPSReader.jl`](https://github.com/JuliaSmoothOptimizers/QPSReader.jl) to
+create a Linear model from a QPS file:
+
+    using QPSReader
+    qps = readqps("QAFIRO.SIF")
+    lp = LinearModel(qps)
+"""
+mutable struct LinearModel{T, S, M1, M2} <: AbstractQuadraticModel{T, S}
+  meta::NLPModelMeta{T, S}
+  counters::Counters
+  data::QPData{T, S, M1, M2}
+end
+
+function LinearModel(
+  c::S;
+  Arows::AbstractVector{<:Integer} = Int[],
+  Acols::AbstractVector{<:Integer} = Int[],
+  Avals::S = S(undef, 0),
+  lcon::S = S(undef, 0),
+  ucon::S = S(undef, 0),
+  lvar::S = fill!(S(undef, length(c)), eltype(c)(-Inf)),
+  uvar::S = fill!(S(undef, length(c)), eltype(c)(Inf)),
+  c0::T = zero(eltype(c)),
+  sortcols::Bool = false,
+  kwargs...,
+) where {T, S}
+  @assert all(lvar .≤ uvar)
+  @assert all(lcon .≤ ucon)
+  nnzh = 0
+  nnzj = length(Avals)
+  if !(nnzj == length(Arows) == length(Acols))
+    error("The length of Arows, Acols and Avals must be the same")
+  end
+  ncon = length(lcon)
+  if ncon != length(ucon)
+    error("The length of lcon and ucon must be the same")
+  end
+  nvar = length(c)
+  if !(nvar == length(lvar) == length(uvar))
+    error("The length of c, lvar and uvar must be the same")
+  end
+  if sortcols
+    pA = sortperm(Acols)
+    permute!(Arows, pA)
+    permute!(Acols, pA)
+    permute!(Avals, pA)
+  end
+  LinearModel(
+    NLPModelMeta{T, S}(
+      length(c),
+      lvar = lvar,
+      uvar = uvar,
+      ncon = ncon,
+      lcon = lcon,
+      ucon = ucon,
+      nnzj = nnzj,
+      lin_nnzj = nnzj,
+      nln_nnzj = 0,
+      nnzh = nnzh,
+      lin = 1:ncon,
+      islp = true;
+      kwargs...,
+    ),
+    Counters(),
+    QPData(
+      c0,
+      c,
+      SparseMatrixCOO(0, nvar, similar(Arows, 0), similar(Acols, 0), similar(Avals, 0)),
+      SparseMatrixCOO(ncon, nvar, Arows, Acols, Avals),
+    ),
+  )
+end
+
+function LinearModel(
+  c::S;
+  A::Union{AbstractMatrix{T}, AbstractLinearOperator{T}} = SparseMatrixCOO(0, length(c), Int[], Int[], T[]),
+  lcon::S = S(undef, 0),
+  ucon::S = S(undef, 0),
+  lvar::S = fill!(S(undef, length(c)), T(-Inf)),
+  uvar::S = fill!(S(undef, length(c)), T(Inf)),
+  c0::T = zero(T),
+  kwargs...,
+) where {T, S}
+  @assert all(lvar .≤ uvar)
+  @assert all(lcon .≤ ucon)
+  ncon, nvar = size(A)
+  nnzh = 0
+  nnzj = nnz(A)
+  H = similar_empty_matrix(A, length(c))
+  data = QPData(c0, c, H, A)
+
+  LinearModel(
+    NLPModelMeta{T, S}(
+      nvar,
+      lvar = lvar,
+      uvar = uvar,
+      ncon = ncon,
+      lcon = lcon,
+      ucon = ucon,
+      nnzj = nnzj,
+      lin_nnzj = nnzj,
+      nln_nnzj = 0,
+      nnzh = nnzh,
+      lin = 1:ncon,
+      islp = (ncon == 0);
+      kwargs...,
+    ),
+    Counters(),
+    data,
+  )
+end
+
+"""
+    LinearModel(nlp, x)
+
+Creates a linear Taylor model of `nlp` around `x`.
+"""
+function LinearModel(model::AbstractNLPModel{T, S}, x::AbstractVector; kwargs...) where {T, S}
+  nvar = model.meta.nvar
+  ncon = model.meta.ncon
+  c0 = obj(model, x)
+  g = grad(model, x)
+  if model.meta.ncon > 0
+    c = cons(model, x)
+    Arows, Acols = jac_structure(model)
+    Avals = jac_coord(model, x)
+    LinearModel(
+      g,
+      c0 = c0,
+      Arows = Arows,
+      Acols = Acols,
+      Avals = Avals,
+      lcon = model.meta.lcon .- c,
+      ucon = model.meta.ucon .- c,
+      lvar = model.meta.lvar .- x,
+      uvar = model.meta.uvar .- x,
+      x0 = fill!(S(undef, model.meta.nvar), zero(T)),
+    )
+  else
+    LinearModel(
+      g,
+      c0 = c0,
+      lvar = model.meta.lvar .- x,
+      uvar = model.meta.uvar .- x,
+      x0 = fill!(S(undef, model.meta.nvar), zero(T)),
+    )
+  end
+end
+
+function NLPModels.objgrad!(qp::LinearModel, x::AbstractVector, g::AbstractVector)
+  NLPModels.increment!(qp, :neval_obj)
+  NLPModels.increment!(qp, :neval_grad)
+  f = qp.data.c0 + dot(qp.data.c, x)
+  g .+= qp.data.c
+  return f, g
+end
+
+function NLPModels.obj(qp::LinearModel, x::AbstractVector)
+  NLPModels.increment!(qp, :neval_obj)
+  return qp.data.c0 + dot(qp.data.c, x)
+end
+
+function NLPModels.grad!(qp::LinearModel, x::AbstractVector, g::AbstractVector)
+  NLPModels.increment!(qp, :neval_grad)
+  g .= qp.data.c
+  return g
+end
+
+function NLPModels.hess_structure!(
+  lp::LinearModel,
+  rows::AbstractVector{<:Integer},
+  cols::AbstractVector{<:Integer},
+)
+  return rows, cols
+end
+
+function NLPModels.hess_coord!(
+  lp::LinearModel,
+  x::AbstractVector,
+  vals::AbstractVector;
+  obj_weight::Real = one(eltype(x)),
+)
+  NLPModels.increment!(lp, :neval_hess)
+  fill!(vals, zero(eltype(x)))
+  return vals
+end
+
+function NLPModels.hprod!(
+  lp::LinearModel,
+  x::AbstractVector,
+  v::AbstractVector,
+  Hv::AbstractVector;
+  obj_weight::Real = one(eltype(x)),
+)
+  NLPModels.increment!(lp, :neval_hprod)
+  fill!(Hv, zero(eltype(x)))
+  return Hv
+end

src/qpmodel.jl

@@ -13,7 +13,7 @@ mutable struct QPData{
   A::M2
 end
 
-@inline QPData(c0, c, H, A) = QPData(c0, c, similar(c), H, A)
+QPData(c0, c, H, A) = QPData(c0, c, similar(c), H, A)
 isdense(data::QPData{T, S, M1, M2}) where {T, S, M1, M2} = M1 <: DenseMatrix || M2 <: DenseMatrix
 
 function Base.convert(
@@ -33,9 +33,9 @@ abstract type AbstractQuadraticModel{T, S} <: AbstractNLPModel{T, S} end
 
 """
     qp = QuadraticModel(c, Hrows, Hcols, Hvals; Arows = Arows, Acols = Acols, Avals = Avals, 
-                        lcon = lcon, ucon = ucon, lvar = lvar, uvar = uvar, sortcols = false)
+                        lcon = lcon, ucon = ucon, lvar = lvar, uvar = uvar, c0 = c0, sortcols = false)
 
-    qp = QuadraticModel(c, H; A = A, lcon = lcon, ucon = ucon, lvar = lvar, uvar = uvar)
+    qp = QuadraticModel(c, H; A = A, lcon = lcon, ucon = ucon, lvar = lvar, uvar = uvar, c0 = c0)
 
 Create a Quadratic model ``min ~\\tfrac{1}{2} x^T H x + c^T x + c_0`` with optional bounds
 `lvar ≦ x ≦ uvar` and optional linear constraints `lcon ≦ Ax ≦ ucon`.
@@ -137,7 +137,7 @@ function QuadraticModel(
       nln_nnzj = 0,
       nnzh = nnzh,
       lin = 1:ncon,
-      islp = (ncon == 0);
+      islp = (nnzh == 0);
       kwargs...,
     ),
     Counters(),
@@ -184,7 +184,7 @@ function QuadraticModel(
       nvar,
       lvar = lvar,
       uvar = uvar,
-      ncon = size(A, 1),
+      ncon = ncon,
       lcon = lcon,
       ucon = ucon,
       nnzj = nnzj,
@@ -247,22 +247,22 @@ end
 
 linobj(qp::AbstractQuadraticModel, args...) = qp.data.c
 
-function NLPModels.objgrad!(qp::AbstractQuadraticModel, x::AbstractVector, g::AbstractVector)
+function NLPModels.objgrad!(qp::QuadraticModel, x::AbstractVector, g::AbstractVector)
   NLPModels.increment!(qp, :neval_obj)
   NLPModels.increment!(qp, :neval_grad)
   mul!(g, Symmetric(qp.data.H, :L), x)
   f = qp.data.c0 + dot(qp.data.c, x) + dot(g, x) / 2
-  @. g .+= qp.data.c
+  g .+= qp.data.c
   return f, g
 end
 
-function NLPModels.obj(qp::AbstractQuadraticModel{T, S}, x::AbstractVector) where {T, S}
+function NLPModels.obj(qp::QuadraticModel, x::AbstractVector)
   NLPModels.increment!(qp, :neval_obj)
   mul!(qp.data.v, Symmetric(qp.data.H, :L), x)
   return qp.data.c0 + dot(qp.data.c, x) + dot(qp.data.v, x) / 2
 end
 
-function NLPModels.grad!(qp::AbstractQuadraticModel, x::AbstractVector, g::AbstractVector)
+function NLPModels.grad!(qp::QuadraticModel, x::AbstractVector, g::AbstractVector)
   NLPModels.increment!(qp, :neval_grad)
   mul!(g, Symmetric(qp.data.H, :L), x)
   g .+= qp.data.c
@@ -363,7 +363,7 @@ function NLPModels.hess_coord!(
 end
 
 NLPModels.hess_coord!(
-  qp::QuadraticModel,
+  qp::AbstractQuadraticModel,
   x::AbstractVector,
   y::AbstractVector,
   vals::AbstractVector;
@@ -392,7 +392,7 @@ function NLPModels.jac_lin_structure!(
 end
 
 function NLPModels.jac_lin_structure!(
-  qp::QuadraticModel{T, S, M1, M2},
+  qp::AbstractQuadraticModel{T, S, M1, M2},
   rows::AbstractVector{<:Integer},
   cols::AbstractVector{<:Integer},
 ) where {T, S, M1, M2 <: Matrix}
@@ -409,7 +409,7 @@ function NLPModels.jac_lin_structure!(
 end
 
 function NLPModels.jac_lin_coord!(
-  qp::QuadraticModel{T, S, M1, M2},
+  qp::AbstractQuadraticModel{T, S, M1, M2},
   x::AbstractVector,
   vals::AbstractVector,
 ) where {T, S, M1, M2 <: SparseMatrixCOO}
@@ -421,7 +421,7 @@ function NLPModels.jac_lin_coord!(
 end
 
 function NLPModels.jac_lin_coord!(
-  qp::QuadraticModel{T, S, M1, M2},
+  qp::AbstractQuadraticModel{T, S, M1, M2},
   x::AbstractVector,
   vals::AbstractVector,
 ) where {T, S, M1, M2 <: SparseMatrixCSC}
@@ -433,7 +433,7 @@ function NLPModels.jac_lin_coord!(
 end
 
 function NLPModels.jac_lin_coord!(
-  qp::QuadraticModel{T, S, M1, M2},
+  qp::AbstractQuadraticModel{T, S, M1, M2},
   x::AbstractVector,
   vals::AbstractVector,
 ) where {T, S, M1, M2 <: Matrix}
@@ -451,7 +451,7 @@ function NLPModels.jac_lin_coord!(
 end
 
 function NLPModels.jac_lin(
-  qp::QuadraticModel{T, S, M1, M2},
+  qp::AbstractQuadraticModel{T, S, M1, M2},
   x::AbstractVector,
 ) where {T, S, M1 <: AbstractLinearOperator, M2 <: AbstractLinearOperator}
   @lencheck qp.meta.nvar x
@@ -468,7 +468,7 @@ function NLPModels.cons_lin!(qp::AbstractQuadraticModel, x::AbstractVector, c::A
 end
 
 function NLPModels.hprod!(
-  qp::AbstractQuadraticModel,
+  qp::QuadraticModel,
   x::AbstractVector,
   v::AbstractVector,
   Hv::AbstractVector;
@@ -504,19 +504,6 @@ function NLPModels.jprod_lin!(
   return Av
 end
 
-function NLPModels.jtprod!(
-  qp::AbstractQuadraticModel,
-  x::AbstractVector,
-  v::AbstractVector,
-  Atv::AbstractVector,
-)
-  @lencheck qp.meta.nvar x Atv
-  @lencheck qp.meta.ncon v
-  NLPModels.increment!(qp, :neval_jtprod)
-  mul!(Atv, transpose(qp.data.A), v)
-  return Atv
-end
-
 function NLPModels.jtprod_lin!(
   qp::AbstractQuadraticModel,
   x::AbstractVector,