mirror of https://github.com/CGAL/cgal
113 lines
4.7 KiB
TeX
113 lines
4.7 KiB
TeX
\ccRefChapter{Linear and Quadratic Programming Solver}
|
|
\label{chapter:QPsolver}
|
|
\ccChapterAuthor{Kaspar Fischer \and Bernd G{\"a}rtner \and Sven Sch{\"o}nherr
|
|
\and Frans Wessendorp}
|
|
|
|
\section{Classified Reference Pages}
|
|
|
|
\ccHeading{Concepts}
|
|
\ccRefConceptPage{QuadraticProgramInterface}\\
|
|
$\quad$ (for quadratic programs with variable bounds $l\leq x \leq u$) \\
|
|
\ccRefConceptPage{LinearProgramInterface} \\
|
|
$\quad$(for linear programs with variable bounds $l\leq x \leq u$)\\
|
|
\ccRefConceptPage{NonnegativeQuadraticProgramInterface}\\
|
|
$\quad$ (for quadratic programs with variable bounds $x\geq 0$) \\
|
|
\ccRefConceptPage{NonnegativeLinearProgramInterface}\\
|
|
$\quad$ (for linear programs with variable bounds $x\geq 0$)
|
|
|
|
\ccRefConceptPage{MPSFormat}\\
|
|
$\quad$ (the format used for reading and writing linear and quadratic
|
|
programs)
|
|
|
|
\ccHeading{Classes}
|
|
|
|
There is a class that represents the solution of a linear
|
|
or quadratic program. An instance of this class is returned by any of
|
|
the solution functions below.
|
|
|
|
%\ccRefIdfierPage{Quadratic_program_solution}
|
|
|
|
We offer a number of predefined models for the program concepts. These
|
|
construct linear or quadratic programs from iterators, or from streams.
|
|
|
|
Here are the models that conform to the concept
|
|
\ccc{QuadraticProgramInterface}.
|
|
|
|
\ccc{Quadratic_program<NT>}\\
|
|
$\quad$ (for quadratic programs that own their data and are built entry-wise; probably the most useful model)\\
|
|
\ccc{Quadratic_program_from_iterators<A_it, B_it, R_it, FL_it, L_it, FU_it, U_it, D_it, C_it>}\\
|
|
$\quad$ (for quadratic programs that wrap given iterators, without copying
|
|
data) \\
|
|
\ccc{Quadratic_program_from_pointers<NT>}\\
|
|
$\quad$ (for quadratic programs that wrap given pointers, without copying
|
|
data) \\
|
|
\ccc{Quadratic_program_from_mps<NT>}\\
|
|
$\quad$ (for quadratic programs read from an input stream in
|
|
\ccc{MPSFormat}; the constructed program can be manipulate entry-wise)
|
|
|
|
These are the models for \ccc{LinearProgramInterface}.
|
|
|
|
\ccc{Linear_program<NT>}\\
|
|
$\quad$ (for linear programs that own their data and are built entry-wise; probably the most useful model)\\
|
|
\ccc{Linear_program_from_iterators<A_it, B_it, R_it, FL_it, L_it, FU_it, U_it, C_it>}\\
|
|
$\quad$ (for linear programs that wrap given iterators, without copying
|
|
data) \\
|
|
\ccc{Linear_program_from_pointers<NT>}\\
|
|
$\quad$ (for linear programs that wrap given pointers, without copying
|
|
data) \\
|
|
\ccc{Linear_program_from_mps<NT>}\\
|
|
$\quad$ (for linear programs read from an input stream in
|
|
\ccc{MPSFormat}; the constructed program can be manipulate entry-wise)
|
|
|
|
For \ccc{NonnegativeQuadraticProgramInterface}, we offer these
|
|
four models.
|
|
|
|
\ccc{Nonnegative_quadratic_program<NT>}\\
|
|
$\quad$ (for nonnegative quadratic programs that own their data and are built entry-wise; probably the most useful model)\\
|
|
\ccc{Nonnegative_quadratic_program_from_iterators<A_it, B_it, R_it, D_it, C_it>}\\
|
|
$\quad$ (for nonnegative quadratic programs, wrapping given iterators)\\
|
|
\ccc{Nonnegative_quadratic_program_from_pointers<NT>}\\
|
|
$\quad$ (for nonnegative quadratic programs, wrapping given pointers)\\
|
|
\ccc{Nonnegative_quadratic_program_from_mps<NT>}\\
|
|
$\quad$ (for nonnegative quadratic programs read from an input stream in
|
|
\ccc{MPSFormat}; the constructed program can be manipulate entry-wise)
|
|
|
|
And finally, the four models for \ccc{NonnegativeLinearProgramInterface}.
|
|
|
|
\ccc{Nonnegative_linear_program<NT>}\\
|
|
$\quad$ (for nonnegative linear programs that own their data and are built entry-wise; probably the most useful model)\\
|
|
\ccc{Nonnegative_linear_program_from_iterators<A_it, B_it, R_it, C_it>}\\
|
|
$\quad$ (for nonnegative linear programs, wrapping given iterators)\\
|
|
\ccc{Nonnegative_linear_program_from_pointers<NT>}\\
|
|
$\quad$ (for nonnegative linear programs, wrapping given pointers)\\
|
|
\ccc{Nonnegative_linear_program_from_mps<NT>}\\
|
|
$\quad$ (for nonnegative linear programs read from an input stream in
|
|
\ccc{MPSFormat}; the constructed programt can be manipulate entry-wise)
|
|
|
|
\ccHeading{Functions}
|
|
|
|
In case you want to construct a program from complicated iterators
|
|
(whose types you don't know, or simply don't want to bother with),
|
|
we provide four makers.
|
|
|
|
\ccc{make_quadratic_program_from_iterators}\\
|
|
\ccc{make_linear_program_from_iterators}\\
|
|
\ccc{make_nonnegative_quadratic_program_from_iterators}\\
|
|
\ccc{make_nonnegative_linear_program_from_iterators}
|
|
|
|
There are four functions to solve a program, one for each program
|
|
concept.
|
|
|
|
\ccc{solve_quadratic_program}\\
|
|
\ccc{solve_linear_program}\\
|
|
\ccc{solve_nonnegative_quadratic_program}\\
|
|
\ccc{solve_nonnegative_linear_program}
|
|
|
|
Programs can be written to an output stream in \ccc{MPSFormat}, using
|
|
one of the following four functions.
|
|
|
|
\ccc{print_quadratic_program}\\
|
|
\ccc{print_linear_program}\\
|
|
\ccc{print_nonnegative_quadratic_program}\\
|
|
\ccc{print_nonnegative_linear_program}
|