diff options
Diffstat (limited to 'thirdparty/linux/include/coin1/IpAugSystemSolver.hpp')
| -rw-r--r-- | thirdparty/linux/include/coin1/IpAugSystemSolver.hpp | 200 |
1 files changed, 200 insertions, 0 deletions
diff --git a/thirdparty/linux/include/coin1/IpAugSystemSolver.hpp b/thirdparty/linux/include/coin1/IpAugSystemSolver.hpp new file mode 100644 index 0000000..1396ce4 --- /dev/null +++ b/thirdparty/linux/include/coin1/IpAugSystemSolver.hpp @@ -0,0 +1,200 @@ +// Copyright (C) 2004, 2006 International Business Machines and others. +// All Rights Reserved. +// This code is published under the Eclipse Public License. +// +// $Id: IpAugSystemSolver.hpp 2269 2013-05-05 11:32:40Z stefan $ +// +// Authors: Carl Laird, Andreas Waechter IBM 2004-08-13 + +#ifndef __IP_AUGSYSTEMSOLVER_HPP__ +#define __IP_AUGSYSTEMSOLVER_HPP__ + +#include "IpSymMatrix.hpp" +#include "IpSymLinearSolver.hpp" +#include "IpAlgStrategy.hpp" + +namespace Ipopt +{ + DECLARE_STD_EXCEPTION(FATAL_ERROR_IN_LINEAR_SOLVER); + + /** Base class for Solver for the augmented system. This is the + * base class for linear solvers that solve the augmented system, + * which is defined as + * + * \f$\left[\begin{array}{cccc} + * W + D_x + \delta_xI & 0 & J_c^T & J_d^T\\ + * 0 & D_s + \delta_sI & 0 & -I \\ + * J_c & 0 & D_c - \delta_cI & 0\\ + * J_d & -I & 0 & D_d - \delta_dI + * \end{array}\right] + * \left(\begin{array}{c}sol_x\\sol_s\\sol_c\\sol_d\end{array}\right)= + * \left(\begin{array}{c}rhs_x\\rhs_s\\rhs_c\\rhs_d\end{array}\right)\f$ + * + * Since this system might be solved repeatedly for different right + * hand sides, it is desirable to step the factorization of a + * direct linear solver if possible. + */ + class AugSystemSolver: public AlgorithmStrategyObject + { + public: + /**@name Constructors/Destructors */ + //@{ + /** Default constructor. */ + AugSystemSolver() + {} + /** Default destructor */ + virtual ~AugSystemSolver() + {} + //@} + + /** overloaded from AlgorithmStrategyObject */ + virtual bool InitializeImpl(const OptionsList& options, + const std::string& prefix) = 0; + + /** Set up the augmented system and solve it for a given right hand + * side. If desired (i.e. if check_NegEVals is true), then the + * solution is only computed if the number of negative eigenvalues + * matches numberOfNegEVals. + * + * The return value is the return value of the linear solver object. + */ + virtual ESymSolverStatus Solve( + const SymMatrix* W, + double W_factor, + const Vector* D_x, + double delta_x, + const Vector* D_s, + double delta_s, + const Matrix* J_c, + const Vector* D_c, + double delta_c, + const Matrix* J_d, + const Vector* D_d, + double delta_d, + const Vector& rhs_x, + const Vector& rhs_s, + const Vector& rhs_c, + const Vector& rhs_d, + Vector& sol_x, + Vector& sol_s, + Vector& sol_c, + Vector& sol_d, + bool check_NegEVals, + Index numberOfNegEVals) + { + std::vector<SmartPtr<const Vector> > rhs_xV(1); + rhs_xV[0] = &rhs_x; + std::vector<SmartPtr<const Vector> > rhs_sV(1); + rhs_sV[0] = &rhs_s; + std::vector<SmartPtr<const Vector> > rhs_cV(1); + rhs_cV[0] = &rhs_c; + std::vector<SmartPtr<const Vector> > rhs_dV(1); + rhs_dV[0] = &rhs_d; + std::vector<SmartPtr<Vector> > sol_xV(1); + sol_xV[0] = &sol_x; + std::vector<SmartPtr<Vector> > sol_sV(1); + sol_sV[0] = &sol_s; + std::vector<SmartPtr<Vector> > sol_cV(1); + sol_cV[0] = &sol_c; + std::vector<SmartPtr<Vector> > sol_dV(1); + sol_dV[0] = &sol_d; + return MultiSolve(W, W_factor, D_x, delta_x, D_s, delta_s, J_c, D_c, delta_c, + J_d, D_d, delta_d, rhs_xV, rhs_sV, rhs_cV, rhs_dV, + sol_xV, sol_sV, sol_cV, sol_dV, check_NegEVals, + numberOfNegEVals); + } + + /** Like Solve, but for multiple right hand sides. The inheriting + * class has to be overload at least one of Solve and + * MultiSolve. */ + virtual ESymSolverStatus MultiSolve( + const SymMatrix* W, + double W_factor, + const Vector* D_x, + double delta_x, + const Vector* D_s, + double delta_s, + const Matrix* J_c, + const Vector* D_c, + double delta_c, + const Matrix* J_d, + const Vector* D_d, + double delta_d, + std::vector<SmartPtr<const Vector> >& rhs_xV, + std::vector<SmartPtr<const Vector> >& rhs_sV, + std::vector<SmartPtr<const Vector> >& rhs_cV, + std::vector<SmartPtr<const Vector> >& rhs_dV, + std::vector<SmartPtr<Vector> >& sol_xV, + std::vector<SmartPtr<Vector> >& sol_sV, + std::vector<SmartPtr<Vector> >& sol_cV, + std::vector<SmartPtr<Vector> >& sol_dV, + bool check_NegEVals, + Index numberOfNegEVals) + { + // Solve for one right hand side after the other + Index nrhs = (Index)rhs_xV.size(); + DBG_ASSERT(nrhs>0); + DBG_ASSERT(nrhs==(Index)rhs_sV.size()); + DBG_ASSERT(nrhs==(Index)rhs_cV.size()); + DBG_ASSERT(nrhs==(Index)rhs_dV.size()); + DBG_ASSERT(nrhs==(Index)sol_xV.size()); + DBG_ASSERT(nrhs==(Index)sol_sV.size()); + DBG_ASSERT(nrhs==(Index)sol_cV.size()); + DBG_ASSERT(nrhs==(Index)sol_dV.size()); + + ESymSolverStatus retval=SYMSOLVER_SUCCESS; + for (Index i=0; i<nrhs; i++) { + retval = Solve(W, W_factor, D_x, delta_x, D_s, delta_s, J_c, D_c, delta_c, + J_d, D_d, delta_d, + *rhs_xV[i], *rhs_sV[i], *rhs_cV[i], *rhs_dV[i], + *sol_xV[i], *sol_sV[i], *sol_cV[i], *sol_dV[i], + check_NegEVals, numberOfNegEVals); + if (retval!=SYMSOLVER_SUCCESS) { + break; + } + } + return retval; + } + + /** Number of negative eigenvalues detected during last + * solve. Returns the number of negative eigenvalues of + * the most recent factorized matrix. This must not be called if + * the linear solver does not compute this quantities (see + * ProvidesInertia). + */ + virtual Index NumberOfNegEVals() const =0; + + /** Query whether inertia is computed by linear solver. + * Returns true, if linear solver provides inertia. + */ + virtual bool ProvidesInertia() const =0; + + /** Request to increase quality of solution for next solve. Ask + * underlying linear solver to increase quality of solution for + * the next solve (e.g. increase pivot tolerance). Returns + * false, if this is not possible (e.g. maximal pivot tolerance + * already used.) + */ + virtual bool IncreaseQuality() =0; + + private: + /**@name Default Compiler Generated Methods + * (Hidden to avoid implicit creation/calling). + * These methods are not implemented and + * we do not want the compiler to implement + * them for us, so we declare them private + * and do not define them. This ensures that + * they will not be implicitly created/called. */ + //@{ + /** Copy Constructor */ + AugSystemSolver(const AugSystemSolver&); + + /** Overloaded Equals Operator */ + void operator=(const AugSystemSolver&); + //@} + + }; + +} // namespace Ipopt + +#endif |