mirror of https://github.com/CGAL/cgal
172 lines
6.7 KiB
TeX
172 lines
6.7 KiB
TeX
% =============================================================================
|
|
% The CGAL Reference Manual
|
|
% Chapter: Geometric Optimisation
|
|
% Section: Smallest Enclosing Sphere
|
|
% =============================================================================
|
|
|
|
\begin{ccRefClass}{QP_pricing_strategy<Traits>}
|
|
\ccIndexSubitem[t]{sphere}{smallest enclosing sphere of spheres}
|
|
\ccIndexSubitem[t]{smallest enclosing}{sphere of spheres}
|
|
\ccIndexSubitem[t]{bounding volumes}{smallest enclosing sphere of spheres}
|
|
\ccIndexSubitemSeeAlso[t]{circle}{smallest enclosing sphere of spheres}
|
|
|
|
% -----------------------------------------------------------------------------
|
|
\ccDefinition The class \ccRefName\ is the base class for the
|
|
ready-to-use and for the user-defined, customized pricing strategies.
|
|
The pricing step of the algorithm consists of determining whether the
|
|
current solution is optimal. If not, the pricing step determines an
|
|
\emph{entering variable}. The pricing strategy is the part of the
|
|
solver's pricing step that selects a variable among the nonbasic
|
|
variables, denoted by $N$, that qualify as entering variables. A
|
|
nonbasic variable $x_{j}$ qualifies as an entering variable iff its
|
|
associated number $\mu_{j}$, which coincides with the notion of
|
|
reduced cost in the linear case, is strictly negative.\footnote{This
|
|
only holds for the standard-form case; I, Kaspar, suggest to drop
|
|
support for user-defined pricing-strategies as this is really
|
|
low-level stuff that requires a deeper knowledge of the solver's
|
|
internals.}
|
|
|
|
%Two basic strategies are \emph{filtered pricing} and \emph{partial pricing}.
|
|
%With filtered pricing the $\mu_{j}$, $j \in N$, where $N$ denotes the set of
|
|
%currently nonbasic variables, are approximated by $\tilde{\mu}_{j}$, $j \in N$
|
|
%with a fast (compared to \ccc{ET}) floating point number type at the beginning
|
|
%of the pricing step.
|
|
%If the exact check of the nonbasic variable with the smallest
|
|
%approximated $\tilde{\mu}_{j}$ succeeds, that is if $\mu_{j_{0}} < 0$, where
|
|
%$j_{0} =\arg\min_{j \in N}\tilde{\mu}_{j}$, then $x_{j_{0}}$ is the
|
|
%entering variable. Otherwise the nonnegativity for a part of the
|
|
%nonbasic variables is assured by the use of an error bound $b$ on
|
|
%$\left|\tilde{\mu}_{j} - \mu_{j}\right|$.
|
|
%If $\tilde{\mu}_{j} \geq b$ then $\mu_{j}$ is known to
|
|
%be nonnegative. The $\tilde{\mu}_{j}$, $j \in N$ whose exact $\mu_{j}$ values
|
|
%cannot be determined to be nonnegative by this \emph{floating point filter}
|
|
%are then evaluated
|
|
%using exact arithmetic. The error bound actually consists of two bounds, one
|
|
%that does not depend on $j \in N$ and one that does depend on $j$. Note that
|
|
%the bounds themselves can be evaluated with floating point arithmetic.
|
|
|
|
User provided pricing strategies may use \ccRefName\ as a base class directly
|
|
or inherit from the class \ccc{QP__filtered_base} or from the class
|
|
\ccc{QP__partial_base} or both.
|
|
|
|
|
|
\ccInclude{CGAL/QP_solver.h}
|
|
|
|
|
|
\ccRequirements
|
|
\ccIndexRequirements
|
|
|
|
The class \ccRefName\ expects a model of the concept
|
|
\ccc{QPSolverTraits} as its template argument.
|
|
|
|
|
|
\ccTypes \ccIndexClassTypes
|
|
|
|
%\ccNestedType{ET}{a typedef to \ccc{Traits::ET}. \ccc{ET} is a model for the
|
|
%CGAL concept \ccc{RingNumberType} and has to support addition, subtraction and
|
|
%multiplication. Division is only required in cases where the remainder is zero.}
|
|
|
|
%\ccNestedType{QP_solver}{a typedef to \ccc{CGAL::QP_solver<Traits>}.}
|
|
|
|
|
|
\ccCreation
|
|
\ccIndexClassCreation
|
|
\ccCreationVariable{ps}
|
|
|
|
%\ccConstructor{( const std::string& strategy_name);}
|
|
%{creates a variable of type \ccRefName\ and solves the quadratic program.
|
|
%\ccRequire $(m,n)$ is the dimension of the constraint matrix $A$.
|
|
%}
|
|
|
|
\ccUnchecked
|
|
|
|
\ccAccessFunctions
|
|
\begin{ccIndexMemberFunctions}
|
|
\ccIndexMemberFunctionGroup{access}
|
|
|
|
%\ccMemberFunction{virtual int pricing() const =0;}{performs the actual pricing
|
|
%step and is called by the ambient solver. Returns either the index of the
|
|
%entering variable or $-1$ to indicate optimality. Has to be reimplemented by
|
|
%derived pricing strategy classes.}
|
|
|
|
%\ccMemberFunction{const QP_solver& solver() const;}{returns a reference to the
|
|
%ambient solver.}
|
|
|
|
%\ccMemberFunction{ET mu_j(int j) const;}{returns exact value of $\mu_{j}$.}
|
|
|
|
|
|
|
|
% -----------------------------------------------------------------------------
|
|
%\ccPredicates
|
|
%\ccIndexMemberFunctionGroup{predicates}
|
|
|
|
|
|
% -----------------------------------------------------------------------------
|
|
\ccModifiers
|
|
\ccIndexMemberFunctionGroup{modifiers}
|
|
|
|
%\ccMemberFunction{ void init(int dummy);}{may be used for initialization
|
|
%of this class.}
|
|
|
|
%\ccMemberFunction{ void set(const QP_solver& solver);}{sets the reference to
|
|
%the ambient solver.}
|
|
|
|
%\ccMemberFunction{ virtual void init();}{may be used for initialization of
|
|
%derived classes.}
|
|
|
|
%\ccMemberFunction{ virtual void set();}{may be used for initialization of
|
|
%derived classes.}
|
|
|
|
%\ccMemberFunction{virtual int pricing() const =0;}{performs the actual pricing
|
|
%step and is called by the ambient solver. Returns either the index of the
|
|
%entering variable or $-1$ to indicate optimality. Has to be reimplemented by
|
|
%derived pricing strategy classes.}
|
|
|
|
|
|
%\ccMemberFunction{ virtual void transition();}{is called by the ambient solver
|
|
%and notifies the pricing strategy if the solver switches from phaseI to
|
|
%phaseII.}
|
|
|
|
%\ccMemberFunction{ virtual void leave_basis( int i );}{is called by the ambient
|
|
%solver and notifies the pricing strategy if a basic varaible is leaving the
|
|
%basis.}
|
|
|
|
|
|
% -----------------------------------------------------------------------------
|
|
%\ccHeading{Validity Check}
|
|
%\ccIndexMemberFunctionGroup{validity check}
|
|
|
|
% -----------------------------------------------------------------------------
|
|
\ccHeading{Miscellaneous}
|
|
\ccIndexMemberFunctionGroup{miscellaneous}
|
|
|
|
%\def\ccTagRmConstRefPair{\ccFalse}
|
|
%\ccMemberFunction{ const Traits& traits( ) const;}{
|
|
% returns a const reference to the traits class object.}
|
|
% \def\ccTagRmConstRefPair{\ccTrue}
|
|
\end{ccIndexMemberFunctions}
|
|
|
|
|
|
% -----------------------------------------------------------------------------
|
|
\ccSeeAlso
|
|
%
|
|
\ccRefIdfierPage{CGAL::QP_full_exact_pricing<Traits>}\\
|
|
\ccRefIdfierPage{CGAL::QP_full_filtered_pricing<Traits>}\\
|
|
\ccRefIdfierPage{CGAL::QP_partial_exact_pricing<Traits>}\\
|
|
\ccRefIdfierPage{CGAL::QP_partial_filtered_pricing<Traits>}\\
|
|
% -----------------------------------------------------------------------------
|
|
|
|
\ccImplementation
|
|
\ccIndexImplementation
|
|
%\ccIndexSubitem[t]{incremental algorithm}{\ccc{Min_sphere_of_spheres_d}}
|
|
%\ccIndexSubitem[t]{farthest-first heuristic}{\ccc{Min_sphere_of_spheres_d}}
|
|
|
|
|
|
\ccExample
|
|
%\ccIncludeVerbatim{Min_sphere_of_spheres_d/min_sphere_of_spheres_d_example_d.C}
|
|
|
|
\end{ccRefClass}
|
|
|
|
% ===== EOF ===================================================================
|
|
|