From 9d3b0d03271a7d7f9870090b6dc2f07b9a91cb38 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bernd=20G=C3=A4rtner?= Date: Tue, 3 Apr 2007 10:04:21 +0000 Subject: [PATCH] - added sparse MPS readers - documented MPS format --- .gitattributes | 3 + .../QP_solver_ref/Linear_program_from_mps.tex | 33 +++- QP_solver/doc_tex/QP_solver_ref/MPSFormat.tex | 148 ++++++++++++++++++ .../Quadratic_program_from_mps.tex | 36 ++++- .../Sparse_linear_program_from_mps.tex | 72 +++++++++ .../Sparse_quadratic_program_from_mps.tex | 78 +++++++++ QP_solver/doc_tex/QP_solver_ref/intro.tex | 22 ++- QP_solver/doc_tex/QP_solver_ref/main.tex | 3 + 8 files changed, 385 insertions(+), 10 deletions(-) create mode 100644 QP_solver/doc_tex/QP_solver_ref/MPSFormat.tex create mode 100644 QP_solver/doc_tex/QP_solver_ref/Sparse_linear_program_from_mps.tex create mode 100644 QP_solver/doc_tex/QP_solver_ref/Sparse_quadratic_program_from_mps.tex diff --git a/.gitattributes b/.gitattributes index fd16a76f8d6..de7dd2aa953 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1827,6 +1827,7 @@ QP_solver/doc_tex/QP_solver_ref/Linear_program.tex -text QP_solver/doc_tex/QP_solver_ref/Linear_program_from_iterators.tex -text QP_solver/doc_tex/QP_solver_ref/Linear_program_from_mps.tex -text QP_solver/doc_tex/QP_solver_ref/Linear_program_from_pointers.tex -text +QP_solver/doc_tex/QP_solver_ref/MPSFormat.tex -text QP_solver/doc_tex/QP_solver_ref/Nonnegative_linear_program.tex -text QP_solver/doc_tex/QP_solver_ref/Nonnegative_linear_program_from_iterators.tex -text QP_solver/doc_tex/QP_solver_ref/Nonnegative_linear_program_from_pointers.tex -text @@ -1836,6 +1837,8 @@ QP_solver/doc_tex/QP_solver_ref/Nonnegative_quadratic_program_from_pointers.tex QP_solver/doc_tex/QP_solver_ref/Quadratic_program.tex -text QP_solver/doc_tex/QP_solver_ref/Quadratic_program_from_mps.tex -text QP_solver/doc_tex/QP_solver_ref/Quadratic_program_from_pointers.tex -text +QP_solver/doc_tex/QP_solver_ref/Sparse_linear_program_from_mps.tex -text +QP_solver/doc_tex/QP_solver_ref/Sparse_quadratic_program_from_mps.tex -text QP_solver/examples/QP_solver/double_qp_solver.cin -text QP_solver/examples/QP_solver/double_qp_solver.data -text QP_solver/examples/QP_solver/integer_qp_solver.cin -text diff --git a/QP_solver/doc_tex/QP_solver_ref/Linear_program_from_mps.tex b/QP_solver/doc_tex/QP_solver_ref/Linear_program_from_mps.tex index 6ddfd671b6d..5a816c225d5 100644 --- a/QP_solver/doc_tex/QP_solver_ref/Linear_program_from_mps.tex +++ b/QP_solver/doc_tex/QP_solver_ref/Linear_program_from_mps.tex @@ -6,7 +6,7 @@ An object of class \ccRefName\ describes a linear program of the form %% \begin{eqnarray*} -\mbox{(QP)}& \mbox{minimize} & x^{T}Dx+c^{T}x+c_0 \\ +\mbox{(QP)}& \mbox{minimize} & c^{T}x+c_0 \\ &\mbox{subject to} & Ax\qprel b, \\ & & l \leq x \leq u \end{eqnarray*} @@ -27,7 +27,21 @@ $x$, \item $c_0$ is a constant. \end{itemize} -This class reads the program data from a file in MPS format. +The program data are read from an input stream in \ccc{MPSFormat}. This is +a commonly used format for encoding linear and quadratic programs that +is understood by many solvers. + +\textbf{Note:} The space required to store the program is $\Theta(nm + +n^2)$, even if these matrix $A$ is very sparse. This might be +prohibitive. In this case, you may use the model +\ccc{Sparse_linear_program_from_mps} whose space requirements +are bounded by the number of nonzero entries in the program +description. In this latter model, access to the iterators in +\ccc{LinearProgramInterface} will be a little slower, though. + +As a rule of thumb, however, if there is a need for the sparse model, +then \cgal's linear programming solver will probably not be able to +solve it anyway. \ccIsModel \ccc{LinearProgramInterface} @@ -36,9 +50,22 @@ This class reads the program data from a file in MPS format. \ccIndexClassCreation \ccCreationVariable{lp} -\ccConstructor{Linear_program_from_mps(std::istream& in)} {reads \ccVar\ fromthe stream \ccc{in}.} +\ccConstructor{Sparse_linear_program_from_mps(std::istream& in)} {reads \ccVar\ from the input stream \ccc{in}.} + +\ccOperations + +\ccMethod{bool is_valid() const;}{returns \ccc{true} if and only if an +MPS-encoded linear program could be extracted from the input stream.} + +\ccMethod{const std::string& name_of_variable (int i) const;} {returns the name of the $i$-th variable.\ccPrecond \ccVar\ccc{.is_valid()}} + +\ccMethod{bool is_nonnegative() const;}{returns \ccc{true} if and only if the linear program read into \ccVar\ is a nonnegative program +\ccPrecond \ccVar\ccc{.is_valid()}.} + +\ccMethod{const std::string& error() const;}{returns an error message explaining why the input is not in MPS format \ccPrecond \ccc{!} \ccVar\ccc{.is_valid()}} \ccSeeAlso +\ccc{Sparse_linear_program_from_mps}\\ \ccc{Linear_program}\\ \ccc{Linear_program_from_iterators}\\ \ccc{Linear_program_from_pointers} diff --git a/QP_solver/doc_tex/QP_solver_ref/MPSFormat.tex b/QP_solver/doc_tex/QP_solver_ref/MPSFormat.tex new file mode 100644 index 00000000000..ae7cc4f81eb --- /dev/null +++ b/QP_solver/doc_tex/QP_solver_ref/MPSFormat.tex @@ -0,0 +1,148 @@ +\begin{ccRefConcept}{MPSFormat} + +MPS is a commonly used file format for storing linear and quadratic +programs according to the concepts \ccc{LinearProgramInterface} and +\ccc{QuadraticProgramInterface}. \cgal\ supports a large subset of +this format, but there are MPS files around that we cannot read (for +example, files that encode integrality constraints on the variables). +Also, there might be some other MPS-based solvers that will not be able +to read the MPS files written by \cgal, since we do not strictly +adhere to the very rigid layout requirements of the original MPS +format. + +Let's look at an example first. The quadratic program + +\[ +\begin{array}{lrcl} +\mbox{minimize} & x^2 + 4(y-4)^2 &(=& x^2 + 4y^2 - 32y + 64) \\ +\mbox{subject to} & x + y &\leq& 7 \\ + & -x + 2y &\leq& 4 \\ + & x &\geq& 0 \\ + & y &\geq& 0 \\ + & y &\leq& 4 +\end{array} +\] + +has the following description in MPS format. + +\begin{verbatim} +NAME MY_MPS +ROWS + N obj + L c0 + L c1 +COLUMNS + x0 c0 1 + x0 c1 -1 + x1 obj -32 + x1 c0 1 + x1 c1 2 +RHS + rhs obj -64 + rhs c0 7 + rhs c1 4 +BOUNDS + UP BND x1 4 +QMATRIX + x0 x0 2 + x1 x1 8 +ENDATA +\end{verbatim} + +Here comes a semiformal description of the format in general. + +\section*{NAME section} +This (mandatory) section consists of a single line +starting with \texttt{NAME}. Everything starting from the +first non-whitespace after that until the end of the line +constitutes the name of the problem. + +\section*{ROWS section} +In the (mandatory) \texttt{ROW} section, you find one line for every +constraint, where the letter \texttt{L} indicates relation $\leq$, +letter \texttt{G} stands for $\geq$, and \texttt{E} for $=$. In +addition, there is a row for the linear objective function (indicated +by letter \texttt{N}). In that section, names are asigned to the +constraints (here: \texttt{c0, c1}) and the objective function (here: +\texttt{obj}). An MPS file may encode several linear objective +functions by using several rows starting with \texttt{N}, but we ignore +all but the first. + +\section*{COLUMNS section} +The (mandatory) \texttt{COLUMNS} section encodes the constraint matrix +$A$ and the linear objective function vector $c$. Every line consists +of one or two sequences of three tokens $j i val$, where $j$ is the +name of a variable (here, we have variables \texttt{x0,x1}), $i$ is +the name of a constraint or the objective function, and $val$ is the +value $A_{ij}$ (if $i$ names a constraint), or $c_j$ (if $i$ names the +linear objective function). Values that are not specified in this +section default to $0$. + +\section*{RHS section} +This (mandatory) section encodes the right-hand side vector $b$ and +the constant term $c_0$ in the objective function. The first token in +every line is an identifier (here: \texttt{rhs}). An MPS file may +encode several right-hand sides $b$ by using several such identifiers, +but we ignore all lines having an identifier different from that of +the first line. + +The second token $i$ in every line names a constraint or the linear +objective function, and the third token $val$ is the value $b_i$ (if +$i$ names a constraint), or $-c_0$ (if $i$ names the linear objective +function). Values that are not specified in this section default to $0$. + +\section*{BOUNDS section} +This (optional) section encodes the lower and upper bound vectors $l$ +and $u$ for the variables. The default bounds for any variable $x_j$ are +$0\leq x_j\leq \infty$; the +\texttt{BOUNDS} section is used to override these defaults. In particular, +if there is no \texttt{BOUNDS} section, the program is nonnegative and +actually a model of the concept \ccc{NonnegativeQuadraticProgramInterface} +or \ccc{NonnegativeLinearProgramInterface}. + +The first token in every line is succeeded by an (optional) identifier +(here: \texttt{BND}). An MPS file may encode several bound vectors $l$ +and $u$ by using several such identifiers, but we ignore all lines +having an identifier different from that of the first line. The first +token $t$ itself determines the type of the bound, and the token $j$ +after the bound identifier names the variable to which the bound applies +In case of bound types \texttt{FX}, \texttt{LO}, and +\texttt{UP}, there is another token $val$ that specifices the bound +value. Here is how bound type and value determine a bound for variable +$x_j$. There may be several bound specifications for a single variable, and +they are processed in order of appearance. + +\begin{tabular}{l|l} +bound type & resulting bound \\ \hline +FX & $x_j \leq val$ (lower bound remains unchanged) \\ +LO & $x_j \geq val$ (upper bound remains unchanged) \\ +UP & $x_j \leq val$ (lower bound remains unchanged, except if $val<0$; then, +a zero lower bound is reset to $-\infty$)\\ +FR & $-\infty \leq x_j\leq\infty$ (previous bounds are discarded)\\ +MI & $x_j\geq -\infty$ (upper bound remains unchanged)\\ +PL & $x_j\leq \infty$ (lower bound remains unchanged) +\end{tabular} + +\section*{QMATRIX / QUADOBJ / DMATRIX section} +This (optional) section encodes the quadratic objective +function matrix $D$. Every line is a sequence $i j val$ of +three tokens, where both $i$ and $j$ name variables, and +$val$ is the value $2D_{i,j}$ (in case of \texttt{QMATRIX} +or \texttt{QUADOBJ}), or $D_{ij}$ (in case of \texttt{DMATRIX}). + +In case of \texttt{QMATRIX} and \texttt{DMATRIX}, \emph{all} nonzero +entries must be specified: if there is a line $i j val$, then there +must also be a line $j i val$, since $D$ is required to be symmetric. +In case of \texttt{QUADOBJ}, only the entries of $2D$ on or below the +diagonal must be specified, and the entries above the diagonal are +deduced from symmetry. + +If this seftion is missing or does not contain nonzero values, the +program is a model of the concept \ccc{LinearProgramInterface}. + +\section*{Miscellaneous} +Our MPS format also supports an (optional) \texttt{RANGES} section, +but we won't explain this here. + + +\end{ccRefConcept} diff --git a/QP_solver/doc_tex/QP_solver_ref/Quadratic_program_from_mps.tex b/QP_solver/doc_tex/QP_solver_ref/Quadratic_program_from_mps.tex index 4277438f5aa..e31152e731d 100644 --- a/QP_solver/doc_tex/QP_solver_ref/Quadratic_program_from_mps.tex +++ b/QP_solver/doc_tex/QP_solver_ref/Quadratic_program_from_mps.tex @@ -29,7 +29,23 @@ $x$, \item $c_0$ is a constant. \end{itemize} -This class reads the program data from a file in extended MPS format. +The program data are read from an input stream in \ccc{MPSFormat}. This is +a commonly used format for encoding linear and quadratic programs that +is understood by many solvers. + +\textbf{Note:} +The space required to store the matrices +$A$ and $D$ is $\Theta(nm + n^2)$, even if these matrices are very sparse. This +might be prohibitive (for example, if there are many variables, but only +few of them are involved in the quadratic objective function). In this +case, you may use the model \ccc{Sparse_quadratic_program_from_mps} +whose space requirements are bounded by the number of nonzero entries +in the program description. In this latter model, access to the iterators +in \ccc{QuadraticProgramInterface} will be a little slower, though. + +As a rule of thumb, however, if there is a need for the sparse model +\emph{because both $m$ and $n$ are large}, then \cgal's quadratic +programming solver will probably not be able to solve it anyway. \ccIsModel \ccc{QuadraticProgramInterface} @@ -38,9 +54,25 @@ This class reads the program data from a file in extended MPS format. \ccIndexClassCreation \ccCreationVariable{qp} -\ccConstructor{Quadratic_program_from_mps(std::istream& in)} {reads \ccVar\ fromthe stream \ccc{in}.} +\ccConstructor{Quadratic_program_from_mps(std::istream& in)} {reads \ccVar\ fromthe input stream \ccc{in}.} + +\ccOperations + +\ccMethod{bool is_valid() const;}{returns \ccc{true} if and only if an +MPS-encoded program could be extracted from the input stream.} + +\ccMethod{const std::string& name_of_variable (int i) const;} {returns the name of the $i$-th variable.\ccPrecond \ccVar\ccc{.is_valid()}} + +\ccMethod{bool is_linear() const;}{returns \ccc{true} if and only if the quadratic program read into \ccVar\ is a linear program. +\ccPrecond \ccVar\ccc{.is_valid()}} + +\ccMethod{bool is_nonnegative() const;}{returns \ccc{true} if and only if the quadratic program read into \ccVar\ is a nonnegative program +\ccPrecond \ccVar\ccc{.is_valid()}.} + +\ccMethod{const std::string& error() const;}{returns an error message explaining why the input is not in MPS format \ccPrecond \ccc{!} \ccVar\ccc{.is_valid()}} \ccSeeAlso +\ccc{Sparse_quadratic_program_from_mps}\\ \ccc{Quadratic_program}\\ \ccc{Quadratic_program_from_iterators}\\ \ccc{Quadratic_program_from_pointers} diff --git a/QP_solver/doc_tex/QP_solver_ref/Sparse_linear_program_from_mps.tex b/QP_solver/doc_tex/QP_solver_ref/Sparse_linear_program_from_mps.tex new file mode 100644 index 00000000000..3c46dd10220 --- /dev/null +++ b/QP_solver/doc_tex/QP_solver_ref/Sparse_linear_program_from_mps.tex @@ -0,0 +1,72 @@ +\begin{ccRefClass}{Sparse_linear_program_from_mps} + +\ccInclude{CGAL/QP_models.h} + +\ccDefinition +An object of class \ccRefName\ describes a linear program of the form +%% +\begin{eqnarray*} +\mbox{(QP)}& \mbox{minimize} & c^{T}x+c_0 \\ +&\mbox{subject to} & Ax\qprel b, \\ +& & l \leq x \leq u +\end{eqnarray*} +%% +in $n$ real variables $x=(x_0,\ldots,x_{n-1})$. +Here, +\begin{itemize} +\item $A$ is an $m\times n$ matrix (the constraint matrix), +\item $b$ is an $m$-dimensional vector (the right-hand side), +\item $\qprel$ is an $m$-dimensional vector of relations +from $\{\leq, =, \geq\}$, +\item $l$ is an $n$-dimensional vector of lower +bounds for $x$, +\item $u$ is an $n$-dimensional vector of upper bounds for +$x$, +\item $c$ is an $n$-dimensional vector (the linear objective + function), and +\item $c_0$ is a constant. +\end{itemize} + +The program data are read from an input stream in \ccc{MPSFormat}. This is +a commonly used format for encoding linear and quadratic programs that +is understood by many solvers. + +\textbf{Note:} +The space requirements are bounded by the number of nonzero entries +in the program description. However, if you can afford space +$\Theta(nm)$, the model \ccc{Linear_program_from_mps} +might be preferrable, since in the latter model, access to the +iterators in \ccc{LinearProgramInterface} will be faster. + +As a rule of thumb, if there is a need for this sparse model, +then \cgal's linear programming solver will probably not be able to +solve it anyway. +\ccIsModel +\ccc{LinearProgramInterface} + +\ccCreation +\ccIndexClassCreation +\ccCreationVariable{lp} + +\ccConstructor{Sparse_linear_program_from_mps(std::istream& in)} {reads \ccVar\ from the input stream \ccc{in}.} + +\ccOperations + +\ccMethod{bool is_valid() const;}{returns \ccc{true} if and only if an +MPS-encoded linear program could be extracted from the input stream.} + +\ccMethod{const std::string& name_of_variable (int i) const;} {returns the name of the $i$-th variable.\ccPrecond \ccVar\ccc{.is_valid()}} + +\ccMethod{bool is_nonnegative() const;}{returns \ccc{true} if and only if the linear program read into \ccVar\ is a nonnegative program +\ccPrecond \ccVar\ccc{.is_valid()}.} + +\ccMethod{const std::string& error() const;}{returns an error message explaining why the input is not in MPS format \ccPrecond \ccc{!} \ccVar\ccc{.is_valid()}} + +\ccSeeAlso +\ccc{Linear_program_from_mps}\\ +\ccc{Linear_program}\\ +\ccc{Linear_program_from_iterators}\\ +\ccc{Linear_program_from_pointers} + + +\end{ccRefClass} diff --git a/QP_solver/doc_tex/QP_solver_ref/Sparse_quadratic_program_from_mps.tex b/QP_solver/doc_tex/QP_solver_ref/Sparse_quadratic_program_from_mps.tex new file mode 100644 index 00000000000..f02720a22c1 --- /dev/null +++ b/QP_solver/doc_tex/QP_solver_ref/Sparse_quadratic_program_from_mps.tex @@ -0,0 +1,78 @@ +\begin{ccRefClass}{Sparse_quadratic_program_from_mps} + +\ccInclude{CGAL/QP_models.h} + +\ccDefinition +An object of class \ccRefName\ describes a convex quadratic program of the form +%% +\begin{eqnarray*} +\mbox{(QP)}& \mbox{minimize} & x^{T}Dx+c^{T}x+c_0 \\ +&\mbox{subject to} & Ax\qprel b, \\ +& & l \leq x \leq u +\end{eqnarray*} +%% +in $n$ real variables $x=(x_0,\ldots,x_{n-1})$. +Here, +\begin{itemize} +\item $A$ is an $m\times n$ matrix (the constraint matrix), +\item $b$ is an $m$-dimensional vector (the right-hand side), +\item $\qprel$ is an $m$-dimensional vector of relations +from $\{\leq, =, \geq\}$, +\item $l$ is an $n$-dimensional vector of lower +bounds for $x$, +\item $u$ is an $n$-dimensional vector of upper bounds for +$x$, +\item $D$ is a symmetric positive-semidefinite $n\times n$ matrix (the + quadratic objective function), +\item $c$ is an $n$-dimensional vector (the linear objective + function), and +\item $c_0$ is a constant. +\end{itemize} + +The program data are read from an input stream in \ccc{MPSFormat}. This is +a commonly used format for encoding linear and quadratic programs that +is understood by many solvers. + +\textbf{Note:} +The space requirements are bounded by the number of nonzero entries +in the program description. However, if you can afford space +$\Theta(nm + n^2)$, the model \ccc{Quadratic_program_from_mps} +might be preferrable, since in the latter model, access to the iterators +in \ccc{QuadraticProgramInterface} will be faster. + +As a rule of thumb, if there is a need for the sparse model +\emph{because both $m$ and $n$ are large}, then \cgal's quadratic +programming solver will probably not be able to solve it anyway. + +\ccIsModel +\ccc{QuadraticProgramInterface} + +\ccCreation +\ccIndexClassCreation +\ccCreationVariable{qp} + +\ccConstructor{Sparse_quadratic_program_from_mps(std::istream& in)} {reads \ccVar\ from the input stream \ccc{in}.} + +\ccOperations + +\ccMethod{bool is_valid() const;}{returns \ccc{true} if and only if an +MPS-encoded program could be extracted from the input stream.} + +\ccMethod{const std::string& name_of_variable (int i) const;} {returns the name of the $i$-th variable.\ccPrecond \ccVar\ccc{.is_valid()}} + +\ccMethod{bool is_linear() const;}{returns \ccc{true} if and only if the quadratic program read into \ccVar\ is a linear program. +\ccPrecond \ccVar\ccc{.is_valid()}} + +\ccMethod{bool is_nonnegative() const;}{returns \ccc{true} if and only if the quadratic program read into \ccVar\ is a nonnegative program +\ccPrecond \ccVar\ccc{.is_valid()}.} + +\ccMethod{const std::string& error() const;}{returns an error message explaining why the input is not in MPS format \ccPrecond \ccc{!} \ccVar\ccc{.is_valid()}} + +\ccSeeAlso +\ccc{Quadratic_program_from_mps}\\ +\ccc{Quadratic_program}\\ +\ccc{Quadratic_program_from_iterators}\\ +\ccc{Quadratic_program_from_pointers} + + +\end{ccRefClass} diff --git a/QP_solver/doc_tex/QP_solver_ref/intro.tex b/QP_solver/doc_tex/QP_solver_ref/intro.tex index 0324d615177..7ee6c9ace09 100644 --- a/QP_solver/doc_tex/QP_solver_ref/intro.tex +++ b/QP_solver/doc_tex/QP_solver_ref/intro.tex @@ -7,14 +7,18 @@ \ccHeading{Concepts} \ccRefConceptPage{QuadraticProgramInterface}\\ -$\quad$ (for quadratic programs with variable bounds $\mathbf{l} \leq x \leq \mathbf{u}$) \\ +$\quad$ (for quadratic programs with variable bounds $l\leq x \leq u$) \\ \ccRefConceptPage{LinearProgramInterface} \\ -$\quad$(for linear programs with variable bounds $\mathbf{l} \leq x \leq \mathbf{u}$)\\ +$\quad$(for linear programs with variable bounds $l\leq x \leq u$)\\ \ccRefConceptPage{NonnegativeQuadraticProgramInterface}\\ $\quad$ (for quadratic programs with variable bounds $x\geq\mathbf{0}$) \\ \ccRefConceptPage{NonnegativeLinearProgramInterface}\\ $\quad$ (for linear programs with variable bounds $x\geq\mathbf{0}$) +\ccRefConceptPage{MPSFormat}\\ +$\quad$ (the format used for reading and writing linear and quadratic +programs) + \ccHeading{Classes} There is one major class that represents the solution of a program @@ -42,7 +46,12 @@ $\quad$ (for quadratic programs with no variable bounds, wrapping given iterator \ccc{Free_quadratic_program_from_pointers}\\ $\quad$ (for quadratic programs with no variable bounds, wrapping given pointers)\\ \ccc{Quadratic_program_from_mps}\\ -$\quad$ (for quadratic programs copied from an input stream) +$\quad$ (for quadratic programs copied from an input stream in +\ccc{MPSFormat})\\ +\ccc{Sparse_quadratic_program_from_mps}\\ +$\quad$ (for sparse quadratic programs copied from an input stream in +\ccc{MPSFormat}) + These are the models for \ccc{LinearProgramInterface}. @@ -63,8 +72,11 @@ iterators)\\ $\quad$ (for linear programs with no variable bounds, wrapping given pointers)\\ \ccc{Linear_program_from_mps}\\ -$\quad$ (for linear programs copied from an input stream) - +$\quad$ (for linear programs copied from an input stream in +\ccc{MPSFormat})\\ +\ccc{Sparse_linear_program_from_mps}\\ +$\quad$ (for sparse linear programs copied from an input stream in +\ccc{MPSFormat}) For \ccc{NonnegativeQuadraticProgramInterface}, we offer these three models. diff --git a/QP_solver/doc_tex/QP_solver_ref/main.tex b/QP_solver/doc_tex/QP_solver_ref/main.tex index 67d42d67687..85a6e5ee1c2 100644 --- a/QP_solver/doc_tex/QP_solver_ref/main.tex +++ b/QP_solver/doc_tex/QP_solver_ref/main.tex @@ -10,6 +10,7 @@ \input{QP_solver_ref/NonnegativeQuadraticProgramInterface} \input{QP_solver_ref/LinearProgramInterface} \input{QP_solver_ref/NonnegativeLinearProgramInterface} +\input{QP_solver_ref/MPSFormat} \input{QP_solver_ref/Quadratic_program} \input{QP_solver_ref/Quadratic_program_from_iterators} @@ -18,6 +19,7 @@ \input{QP_solver_ref/Free_quadratic_program_from_iterators} \input{QP_solver_ref/Free_quadratic_program_from_pointers} \input{QP_solver_ref/Quadratic_program_from_mps} +\input{QP_solver_ref/Sparse_quadratic_program_from_mps} \input{QP_solver_ref/Linear_program} \input{QP_solver_ref/Linear_program_from_iterators} @@ -26,6 +28,7 @@ \input{QP_solver_ref/Free_linear_program_from_iterators} \input{QP_solver_ref/Free_linear_program_from_pointers} \input{QP_solver_ref/Linear_program_from_mps} +\input{QP_solver_ref/Sparse_linear_program_from_mps} \input{QP_solver_ref/Nonnegative_quadratic_program} \input{QP_solver_ref/Nonnegative_quadratic_program_from_iterators}