You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

139 lines
5.6 KiB

// This file is part of libigl, a simple c++ geometry processing library.
//
// Copyright (C) 2013 Alec Jacobson <alecjacobson@gmail.com>
//
// This Source Code Form is subject to the terms of the Mozilla Public License
// v. 2.0. If a copy of the MPL was not distributed with this file, You can
// obtain one at http://mozilla.org/MPL/2.0/.
#ifndef IGL_MOSEK_MOSEK_QUADPROG_H
#define IGL_MOSEK_MOSEK_QUADPROG_H
#include "../igl_inline.h"
#include <vector>
#include <map>
#include <mosek.h>
#define EIGEN_YES_I_KNOW_SPARSE_MODULE_IS_NOT_STABLE_YET
#include <Eigen/Dense>
#include <Eigen/Sparse>
namespace igl
{
namespace mosek
{
/// Structure for holding MOSEK data for solving a quadratic program
struct MosekData
{
/// Integer parameters
std::map<MSKiparame,int> intparam;
/// Double parameters
std::map<MSKdparame,double> douparam;
/// Default values
IGL_INLINE MosekData();
};
// Solve a convex quadratic optimization problem with linear and constant
// bounds. Given in the form:
//
// Minimize: ½ * xT * Q⁰ * x + cT * x + cf
//
// Subject to: lc ≤ Ax ≤ uc
// lx ≤ x ≤ ux
//
// where we are trying to find the optimal vector of values x.
//
// \note Q⁰ must be symmetric
//
// \note Because of how MOSEK accepts different parts of the system, Q
// should be stored in IJV (aka Coordinate) format and should only include
// entries in the lower triangle. A should be stored in Column compressed
// (aka Harwell Boeing) format. As described:
// http://netlib.org/linalg/html_templates/node92.html
// or
// http://en.wikipedia.org/wiki/Sparse_matrix
// #Compressed_sparse_column_.28CSC_or_CCS.29
//
//
// @tparam Index type for index variables
// @tparam Scalar type for floating point variables (gets cast to double?)
// @param[in] n number of variables, i.e. size of x
// @param[in] Qi vector of qnnz row indices of non-zeros in LOWER TRIANGLE ONLY of
// Q⁰
// @param[in] Qj vector of qnnz column indices of non-zeros in LOWER TRIANGLE ONLY
// of Q⁰
// @param[in] Qv vector of qnnz values of non-zeros in LOWER TRIANGLE ONLY of Q⁰,
// such that:
//
// Q⁰(Qi[k],Qj[k]) = Qv[k] for k ∈ [0,Qnnz-1], where Qnnz is the
//
// number of non-zeros in Q⁰
// @param[in] c (optional) vector of n values of c, transpose of coefficient row
// vector of linear terms, EMPTY means c == 0
// @param[in] cf (ignored) value of constant term in objective, 0 means cf == 0, so
// optional only in the sense that it is mandatory
// @param[in] m number of constraints, therefore also number of rows in linear
// constraint coefficient matrix A, and in linear constraint bound
// vectors lc and uc
// @param[in] Av vector of non-zero values of A, in column compressed order
// @param[in] Ari vector of row indices corresponding to non-zero values of A,
// @param[in] Acp vector of indices into Ari and Av of the first entry for each
// column of A, size(Acp) = (# columns of A) + 1 = n + 1
// @param[in] lc vector of m linear constraint lower bounds
// @param[in] uc vector of m linear constraint upper bounds
// @param[in] lx vector of n constant lower bounds
// @param[in] ux vector of n constant upper bounds
// @param[out] x vector of size n to hold output of optimization
// @return true only if optimization was successful with no errors
//
// \note All indices are 0-based
template <typename Index, typename Scalar>
IGL_INLINE bool mosek_quadprog(
const Index n,
/* mosek won't allow this to be const*/ std::vector<Index> & Qi,
/* mosek won't allow this to be const*/ std::vector<Index> & Qj,
/* mosek won't allow this to be const*/ std::vector<Scalar> & Qv,
const std::vector<Scalar> & c,
const Scalar cf,
const Index m,
/* mosek won't allow this to be const*/ std::vector<Scalar> & Av,
/* mosek won't allow this to be const*/ std::vector<Index> & Ari,
const std::vector<Index> & Acp,
const std::vector<Scalar> & lc,
const std::vector<Scalar> & uc,
const std::vector<Scalar> & lx,
const std::vector<Scalar> & ux,
MosekData & mosek_data,
std::vector<Scalar> & x);
/// \overload
///
/// @param[in] Q n by n square quadratic coefficients matrix **only lower triangle
/// is used**.
/// @param[in] c n-long vector of linear coefficients
/// @param[in] cf constant coefficient
/// @param[in] A m by n square linear coefficienst matrix of inequality constraints
/// @param[in] lc m-long vector of lower bounds for linear inequality constraints
/// @param[in] uc m-long vector of upper bounds for linear inequality constraints
/// @param[in] lx n-long vector of lower bounds
/// @param[in] ux n-long vector of upper bounds
/// @param[in] mosek_data parameters struct
/// @param[out] x n-long solution vector
/// @return true only if optimization finishes without error
///
IGL_INLINE bool mosek_quadprog(
const Eigen::SparseMatrix<double> & Q,
const Eigen::VectorXd & c,
const double cf,
const Eigen::SparseMatrix<double> & A,
const Eigen::VectorXd & lc,
const Eigen::VectorXd & uc,
const Eigen::VectorXd & lx,
const Eigen::VectorXd & ux,
MosekData & mosek_data,
Eigen::VectorXd & x);
}
}
#ifndef IGL_STATIC_LIBRARY
# include "mosek_quadprog.cpp"
#endif
#endif