// ============================================================================
//
// Copyright (c) 1997-2003 The CGAL Consortium
//
// This software and related documentation is part of an INTERNAL release
// of the Computational Geometry Algorithms Library (CGAL). It is not
// intended for general use.
//
// ----------------------------------------------------------------------------
//
// release       : $CGAL_Revision: CGAL-I $
// release_date  : $CGAL_Date$
//
// file          : include/CGAL/QPE_solver.h
// package       : $CGAL_Package: QP_engine $
// chapter       : Quadratic Programming Engine
//
// revision      : 3.0alpha
// revision_date : 2003/07
//
// author(s)     : Sven Schönherr <sven@inf.ethz.ch>
// coordinator   : ETH Zürich (Bernd Gärtner <gaertner@inf.ethz.ch>)
//
// implementation: Quadratic Programming Engine - Solver
// ============================================================================

#ifndef CGAL_QPE_SOLVER_H
#define CGAL_QPE_SOLVER_H

// includes
#ifndef CGAL_QP_ENGINE_BASIC_H
#include <CGAL/QP_engine/basic.h>
#endif
#ifndef CGAL_QP_ENGINE_ITERATOR_H
#include <CGAL/QP_engine/iterator.h>
#endif
#ifndef CGAL_QP_ENGINE_FUNCTORS_H
#include <CGAL/QP_engine/functors.h>
#endif
#ifndef CGAL_QP_ENGINE_QPE_BASIS_INVERSE_H
#include <CGAL/QP_engine/QPE_basis_inverse.h>
#endif
#ifndef CGAL_QP_ENGINE_QPE_PRICING_STRATEGY_H
#include <CGAL/QP_engine/QPE_pricing_strategy.h>
#endif

#include <CGAL/Function_objects/Value_by_basic_index.h>

#ifndef CGAL_IO_VERBOSE_OSTREAM_H
#include <CGAL/IO/Verbose_ostream.h>
#endif

#ifndef CGAL_PROTECT_VECTOR
#  define CGAL_PROTECT_VECTOR
#  include <vector>
#endif
#ifndef CGAL_PROTECT_NUMERIC
#  define CGAL_PROTECT_NUMERIC
#  include <numeric>
#endif
#ifndef CGAL_PROTECT_ALGORITHM
#  define CGAL_PROTECT_ALGORITHM
#  include <algorithm>
#endif

CGAL_BEGIN_NAMESPACE

// =================
// class declaration
// =================
template < class Rep_ >
class QPE_solver;

// ===============
// class interface
// ===============
template < class Rep_ >
class QPE_solver {

  public:

    // self
    typedef  Rep_                       Rep;
    typedef  QPE_solver<Rep>            Self;

    // types from the representation class
    typedef  typename Rep::ET           ET;

    typedef  typename Rep::A_iterator   A_iterator;
    typedef  typename Rep::B_iterator   B_iterator;
    typedef  typename Rep::C_iterator   C_iterator;
    typedef  typename Rep::D_iterator   D_iterator;

    typedef  typename Rep::Row_type     Row_type;
    typedef  typename Rep::Row_type_iterator
                                        Row_type_iterator;

    typedef  typename Rep::Is_linear    Is_linear;
    typedef  typename Rep::Is_symmetric Is_symmetric;
    typedef  typename Rep::Has_no_inequalities
                                        Has_no_inequalities;

  private:

    // private types
    // -------------
    // types of original problem
    typedef  typename std::iterator_traits<A_iterator>::value_type  A_column;
    typedef  typename std::iterator_traits<D_iterator>::value_type  D_row;

    typedef  typename std::iterator_traits<A_column  >::value_type  A_entry;
    typedef  typename std::iterator_traits<B_iterator>::value_type  B_entry;
    typedef  typename std::iterator_traits<C_iterator>::value_type  C_entry;
    typedef  typename std::iterator_traits<D_row     >::value_type  D_entry;

    // slack columns
    typedef  std::pair<int,bool>        Slack_column;
    typedef  std::vector<Slack_column>  A_slack;

    // artificial columns
    typedef  std::pair<int,bool>        Art_column;
    typedef  std::vector<Art_column>    A_art;
    typedef  std::vector<A_entry>       S_art;

    // auxiliary objective vector
    typedef  std::vector<C_entry>       C_aux;
    

    // indices (variables and constraints)
    typedef  std::vector<int>           Indices;
    typedef  Indices::const_iterator    Index_iterator;

    // values (variables' numerators)
    typedef  std::vector<ET>            Values;
    typedef  typename Values::iterator  Value_iterator;
    typedef  typename Values::const_iterator
                                        Value_const_iterator;

    // quotient functor
    typedef  Creator_2< ET, ET, Quotient<ET> >
                                        Quotient_creator;
    typedef  std::binder2nd< Quotient_creator >
                                        Quotient_maker;
    
    // access values by basic index functor
    typedef  Value_by_basic_index<Value_const_iterator>
                                        Value_by_basic_index;

    // access to original problem by basic variable/constraint index
    typedef  QPE_vector_accessor<
		 typename std::iterator_traits<A_iterator>::value_type,
		 false, false >         A_by_index_accessor;
    typedef  QPE_transform_iterator_1< Index_iterator, A_by_index_accessor >
                                        A_by_index_iterator;

    typedef  QPE_vector_accessor< B_iterator, false, false >
                                        B_by_index_accessor;
    typedef  QPE_transform_iterator_1< Index_iterator, B_by_index_accessor >
                                        B_by_index_iterator;

    typedef  QPE_vector_accessor< C_iterator, false, false >
                                        C_by_index_accessor;
    typedef  QPE_transform_iterator_1< Index_iterator, C_by_index_accessor >
                                        C_by_index_iterator;

    typedef  QPE_vector_accessor<
		 typename std::iterator_traits<D_iterator>::value_type,
		 false, false >         D_by_index_accessor;
    typedef  QPE_transform_iterator_1< Index_iterator, D_by_index_accessor >
                                        D_by_index_iterator;

    typedef  QPE_matrix_accessor< A_iterator, false, true, false, false>
                                        A_accessor;
    typedef  std::binder2nd< A_accessor >
                                        A_row_by_index_accessor;
    typedef  QPE_transform_iterator_1<
		 Index_iterator, A_row_by_index_accessor >
                                        A_row_by_index_iterator;

    typedef  QPE_matrix_pairwise_accessor< D_iterator, Is_symmetric >
                                        D_pairwise_accessor;
    typedef  QPE_transform_iterator_1< Index_iterator, D_pairwise_accessor >
                                        D_pairwise_iterator;

    // access to special artificial column by basic constraint index
    typedef  QPE_vector_accessor< typename S_art::const_iterator, false, false>
                                        S_by_index_accessor;
    typedef  QPE_transform_iterator_1< Index_iterator, S_by_index_accessor >
                                        S_by_index_iterator;

  public:

    // public types
    enum Status { UPDATE, INFEASIBLE, UNBOUNDED, OPTIMAL };
    
    typedef  typename A_slack::const_iterator
                                        A_slack_iterator;

    typedef  typename A_art::const_iterator
                                        A_artificial_iterator;
    
    typedef  typename C_aux::const_iterator
                                        C_auxiliary_iterator;

    typedef  QPE_transform_iterator_1<
                 Index_iterator, Value_by_basic_index >
                                        Variable_numerator_iterator;
    typedef  QPE_transform_iterator_1<
                 Variable_numerator_iterator, Quotient_maker >
                                        Variable_value_iterator;
    /*
    typedef  Variable_numerator_iterator
                                        Working_variable_numerator_iterator;
    typedef  Variable_value_iterator    Working_variable_value_iterator;
    */

    typedef  Index_iterator             Basic_variable_index_iterator;
    typedef  Value_const_iterator       Basic_variable_numerator_iterator;
    typedef  QPE_transform_iterator_1<
                 Basic_variable_numerator_iterator, Quotient_maker >
                                        Basic_variable_value_iterator;
    
    typedef  Index_iterator             Basic_constraint_index_iterator;
    
    typedef  Value_const_iterator       Lambda_numerator_iterator;
    typedef  QPE_transform_iterator_1<
                 Lambda_numerator_iterator, Quotient_maker >
                                        Lambda_value_iterator;
    
    typedef  QPE_pricing_strategy<Rep>  Pricing_strategy;

  private:

    // some constants
    const ET                 et0, et1, et2;

    // verbose output streams
    Verbose_ostream          vout;      // used for any  diagnostic output
    Verbose_ostream          vout1;     // used for some diagnostic output
    Verbose_ostream          vout2;     // used for more diagnostic output
    Verbose_ostream          vout3;     // used for full diagnostic output
    Verbose_ostream          vout4;     // used for output of basis inverse
    
    // pricing strategy
    Pricing_strategy*        strategyP;
    
    // given QP
    int                      qp_n;      // number of variables
    int                      qp_m;      // number of constraints
    
    A_iterator               qp_A;      // constraint matrix
    B_iterator               qp_b;      // right-hand-side vector
    C_iterator               qp_c;      // objective vector
    D_iterator               qp_D;      // objective matrix
    Row_type_iterator        qp_r;      // row-types of constraints

    A_slack                  slack_A;   // slack part of constraint matrix

    // auxiliary problem    
    A_art                    art_A;     // artificial part of constraint matrix
    S_art                    art_s;     // special artificial column for slacks
    int                      art_s_i;   // index of special artificial column
    int                      art_basic; // number of basic artificial variables
    
    // current status
    Indices                  B_O;       // basis (original variables)
    Indices                  B_S;       // basis (   slack variables)
    
    Indices                  C;         //    basic constraints ( C = E+S_N )
    Indices                  S_B;       // nonbasic constraints ( S_B '=' B_S)
    
    QPE_basis_inverse<ET,Is_linear>
                             inv_M_B;   // inverse of basis matrix

    const ET&                d;         // reference to `inv_M_B.denominator()'
    
    Values                   x_B_O;     // basic variables (original)
    Values                   x_B_S;     // basic variables (slack)
    Values                   lambda;    // lambda (from KKT conditions)
    
    int                      m_phase;   // phase of the Simplex method
    Status                   m_status;  // status of last pivot step
    int                      m_pivots;  // number of pivot steps
    
    bool                     is_phaseI; // flag indicating phase I
    bool                     is_phaseII;// flag indicating phase II

    const bool               is_LP;     // flag indicating a linear    program
    const bool               is_QP;     // flag indicating a quadratic program
    const bool                no_ineq;  // flag indicating no ineq. constraits
    const bool               has_ineq;  // flag indicating    ineq. constraits

    // additional variables
    int                      l;         // minimum of 'qp_n' and 'qp_m'
    
    Indices                  in_B;      // variable   in basis, -1 if non-basic
    Indices                  in_C;      // constraint in basis, -1 if non-basic

    Values                   b_C;       // exact version of `qp_b'
                                        // restricted to basic constraints C
    Values                   minus_c_B; // exact version of `-qp_c'
                                        // restricted to basic variables B_O

    Values                   A_Cj;      // exact version of j-th column of A
                                        // restricted to basic constraints C
    Values                   two_D_Bj;  // exact version of twice the j-th
                                        // column of D restricted to B_O
    
    int                      j;         // index of entering variable `x_j'
    
    int                      i;         // index of leaving variable `x_i'
    ET                       x_i;       // numerator of leaving variable `x_i'
    ET                       q_i;       // corresponding `q_i'

    ET                       mu;        //   numerator of `t_j'
    ET                       nu;        // denominator of `t_j'
    
    Values                   q_lambda;  // 
    Values                   q_x_O;     // used in the ratio test & update
    Values                   q_x_S;     // 

    Values                   tmp_l;     // temporary vector of size l
    Values                   tmp_x;     // temporary vector of s. >= B_O.size()

  public:

    /*
     * Note: Some member functions below are suffixed with '_'. They
     * are member templates and their declaration is "hidden", because
     * they are also implemented in the class interface. This is a
     * workaround for M$-VC++, which otherwise fails to instantiate
     * them correctly.
     */

    // creation & initialization
    // -------------------------
    // creation
    QPE_solver( );

    // set-up of QP
    void  set( int n, int m,
	       A_iterator A, B_iterator b, C_iterator c, D_iterator D,
	       Row_type_iterator r
	           = QPE_const_value_iterator<Row_type>( Rep::EQUAL));

    // initialization (of phase I)
    void  init( );
    
    // initialization (of phase II)
    /*
    template < class InputIterator >
    void  init( InputIterator  basic_variables_first,
                InputIterator  basic_variables_beyond);
    */
    
    // operations
    // ----------
    // pivot step
    Status  pivot( )
        { CGAL_qpe_precondition( phase() > 0);
          CGAL_qpe_precondition( phase() < 3);
          pivot_step();
          return status(); }

    // solve QP
    Status  solve( )
        { CGAL_qpe_precondition( phase() > 0);
          while ( phase() < 3) { pivot_step(); }
          return status(); }

    // access
    // ------
    // access to QP
    int  number_of_variables  ( ) const { return qp_n; }
    int  number_of_constraints( ) const { return qp_m; }
    
    A_iterator  a_begin( ) const { return qp_A;      }
    A_iterator  a_end  ( ) const { return qp_A+qp_n; }
    
    B_iterator  b_begin( ) const { return qp_b;      }
    B_iterator  b_end  ( ) const { return qp_b+qp_m; }
    
    C_iterator  c_begin( ) const { return qp_c;      }
    C_iterator  c_end  ( ) const { return qp_c+qp_n; }
    
    D_iterator  d_begin( ) const { return qp_D;      }
    D_iterator  d_end  ( ) const { return qp_D+qp_n; }
    
    Row_type_iterator  row_type_begin( ) const { return qp_r;      }
    Row_type_iterator  row_type_end  ( ) const { return qp_r+qp_m; }

    // access to current status
    int     phase     ( ) const { return m_phase;  }
    Status  status    ( ) const { return m_status; }
    int     iterations( ) const { return m_pivots; }
    
    // access to common denominator
    const ET&  variables_common_denominator( ) const { return d; }

    // access to current solution
    ET  solution_numerator( ) const;
    
    Quotient<ET>  solution( ) const
        { return Quotient<ET>( solution_numerator(), d*d); }

    // access to original variables
    int  number_of_original_variables( ) const { return qp_n; }

    Variable_numerator_iterator
    variables_numerator_begin( ) const
        { return Variable_numerator_iterator( in_B.begin(),
                   Value_by_basic_index( x_B_O.begin(), qp_n, x_B_S.begin()));}
    
    Variable_numerator_iterator
    variables_numerator_end  ( ) const
        { return Variable_numerator_iterator( in_B.end  (),
                   Value_by_basic_index( x_B_O.begin(), qp_n, x_B_S.begin()));}
    
    Variable_value_iterator
    variables_value_begin( ) const
        { return Variable_value_iterator(
                     variables_numerator_begin(),
                     Quotient_maker( Quotient_creator(), d)); }
    
    Variable_value_iterator
    variables_value_end  ( ) const
        { return Variable_value_iterator(
                     variables_numerator_end  (),
                     Quotient_maker( Quotient_creator(), d)); }
    
    // access to slack variables
    int  number_of_slack_variables( ) const { return slack_A.size(); }

    // access to artificial variables
    int  number_of_artificial_variables( ) const { return art_A.size(); }

    // access to basic variables
    int  number_of_basic_variables( ) const { return B_O.size()+B_S.size(); }
    int  number_of_basic_original_variables( ) const { return B_O.size(); }
    int  number_of_basic_slack_variables( ) const { return B_S.size(); }

    Basic_variable_index_iterator
    basic_original_variables_index_begin( ) const { return B_O.begin(); }
    Basic_variable_index_iterator
    basic_original_variables_index_end  ( ) const { return B_O.end(); }
    
    Basic_variable_numerator_iterator
    basic_original_variables_numerator_begin( ) const { return x_B_O.begin(); }
    Basic_variable_numerator_iterator
    basic_original_variables_numerator_end  ( ) const { return x_B_O.begin()
							       + B_O.size(); }
    Basic_variable_value_iterator
    basic_original_variables_value_begin( ) const
        { return Basic_variable_value_iterator(
                     basic_original_variables_numerator_begin(),
                     Quotient_maker( Quotient_creator(), d)); }
    Basic_variable_value_iterator
    basic_original_variables_value_end  ( ) const
        { return Basic_variable_value_iterator(
                     basic_original_variables_numerator_end  (),
                     Quotient_maker( Quotient_creator(), d)); }

    Basic_variable_index_iterator
    basic_slack_variables_index_begin( ) const { return B_S.begin(); }
    Basic_variable_index_iterator
    basic_slack_variables_index_end  ( ) const { return B_S.end(); }
    
    Basic_variable_numerator_iterator
    basic_slack_variables_numerator_begin( ) const { return x_B_S.begin(); }
    Basic_variable_numerator_iterator
    basic_slack_variables_numerator_end  ( ) const { return x_B_S.begin()
							    + B_S.size(); }
    Basic_variable_value_iterator
    basic_slack_variables_value_begin( ) const
        { return Basic_variable_value_iterator(
                     basic_slack_variables_numerator_begin(),
                     Quotient_maker( Quotient_creator(), d)); }
    Basic_variable_value_iterator
    basic_slack_variables_value_end  ( ) const
        { return Basic_variable_value_iterator(
                     basic_slack_variables_numerator_end  (),
                     Quotient_maker( Quotient_creator(), d)); }

    // access to working variables
    int  number_of_working_variables( ) const { return in_B.size(); }

    bool  is_basic( int j) const
        { CGAL_qpe_precondition( j >= 0);
          CGAL_qpe_precondition( j < number_of_working_variables());
          return ( in_B[ j] >= 0); }

    // access to lambda
    Lambda_numerator_iterator
    lambda_numerator_begin( ) const { return lambda.begin(); }
    
    Lambda_numerator_iterator
    lambda_numerator_end  ( ) const { return lambda.begin() + C.size(); }

    Lambda_value_iterator
    lambda_value_begin( ) const
        { return Lambda_value_iterator(
                     lambda_numerator_begin(),
                     Quotient_maker( Quotient_creator(), d)); }
    
    Lambda_value_iterator
    lambda_value_end  ( ) const
        { return Lambda_value_iterator(
                     lambda_numerator_end  (),
                     Quotient_maker( Quotient_creator(), d)); }

    // miscellaneous
    // -------------
    // altering the pricing strategy
    void  set_pricing_strategy( Pricing_strategy& strategy);

    // diagnostic output
    void  set_verbosity( int verbose = 0, std::ostream& stream = std::cout);

    // access to indices of basic constraints
    int  number_of_basic_constraints( ) const { return C.size(); }

    Basic_constraint_index_iterator
    basic_constraints_index_begin( ) const { return C.begin(); }
    Basic_constraint_index_iterator
    basic_constraints_index_end  ( ) const { return C.end(); }

    // helper functions
    template < class RndAccIt1, class RndAccIt2, class NT >  
    NT  mu_j_( int j, RndAccIt1 lambda_it, RndAccIt2 x_it, const NT& dd) const;

    ET  dual_variable( int i)
    {
	for ( int j = 0; j < qp_m; ++j) {
	    tmp_x[ j] = inv_M_B.entry( j, i);
	}
	return std::inner_product( tmp_x.begin(), tmp_x.begin()+qp_m,
				   minus_c_B.begin(), et0);
    }

  private:    

    // private member functions
    // ------------------------
    // initialization
    void  init_basis( );
    void  init_basis__slack_variables( int s_i, Tag_true  has_no_inequalities);
    void  init_basis__slack_variables( int s_i, Tag_false has_no_inequalities);
    void  init_basis__constraints    ( int s_i, Tag_true  has_no_inequalities);
    void  init_basis__constraints    ( int s_i, Tag_false has_no_inequalities);

    void  init_solution( );
    void  init_solution__b_C( Tag_true  has_no_inequalities);
    void  init_solution__b_C( Tag_false has_no_inequalities);

    void  init_additional_variables( );// rename: data_members

    // transition (to phase II)
    void  transition( );
    void  transition( Tag_true  is_linear);
    void  transition( Tag_false is_linear);
    
    // pivot step
    void  pivot_step( );

    // pricing
    void  pricing( );

    template < class NT, class It >
    void  mu_j__linear_part_( NT& mu_j, int j, It lambda_it,
			      Tag_true  has_no_inequalities) const;
    template < class NT, class It >
    void  mu_j__linear_part_( NT& mu_j, int j, It lambda_it,
			      Tag_false has_no_inequalities) const;

    template < class NT, class It >
    void  mu_j__quadratic_part_( NT& mu_j, int j, It x_it,
				 Tag_true  is_linear) const;
    template < class NT, class It >
    void  mu_j__quadratic_part_( NT& mu_j, int j, It x_it,
				 Tag_false is_linear) const;
    template < class NT, class It >
    void  mu_j__quadratic_part_( NT& mu_j, int j, It x_it,
				 Tag_false is_linear,
				 Tag_true  is_symmetric) const;
    template < class NT, class It >
    void  mu_j__quadratic_part_( NT& mu_j, int j, It x_it,
				 Tag_false is_linear,
				 Tag_false is_symmetric) const;

    template < class NT, class It >
    void  mu_j__slack_or_artificial_( NT& mu_j, int j, It lambda_it,
				      Tag_true  has_no_inequalities) const;
    template < class NT, class It >
    void  mu_j__slack_or_artificial_( NT& mu_j, int j, It lambda_it,
				      Tag_false has_no_inequalities) const;

    // ratio test
    void  ratio_test_init( );
    void  ratio_test_init__A_Cj( Value_iterator A_Cj_it, int j,
				 Tag_true  has_no_inequalities);
    void  ratio_test_init__A_Cj( Value_iterator A_Cj_it, int j,
				 Tag_false has_no_inequalities);
    void  ratio_test_init__2_D_Bj( Value_iterator two_D_Bj_it, int j,
				   Tag_true  is_linear);
    void  ratio_test_init__2_D_Bj( Value_iterator two_D_Bj_it, int j,
				   Tag_false is_linear);
    void  ratio_test_init__2_D_Bj( Value_iterator two_D_Bj_it, int j,
				   Tag_false is_linear,
				   Tag_true  has_no_inequalities);
    void  ratio_test_init__2_D_Bj( Value_iterator two_D_Bj_it, int j,
				   Tag_false is_linear,
				   Tag_false has_no_inequalities);

    void  ratio_test_1( );
    void  ratio_test_1__q_x_O( Tag_true  is_linear);
    void  ratio_test_1__q_x_O( Tag_false is_linear);
    void  ratio_test_1__q_x_S( Tag_true  has_no_inequalities);
    void  ratio_test_1__q_x_S( Tag_false has_no_inequalities);
    void  ratio_test_1__t_i( Index_iterator i_it, Index_iterator end_it,
			     Value_iterator x_it, Value_iterator   q_it,
			     Tag_true  no_check);
    void  ratio_test_1__t_i( Index_iterator i_it, Index_iterator end_it,
			     Value_iterator x_it, Value_iterator   q_it,
			     Tag_false  no_check);
    void  ratio_test_1__t_j( Tag_true  is_linear);
    void  ratio_test_1__t_j( Tag_false is_linear);

    void  ratio_test_2( Tag_true  is_linear);
    void  ratio_test_2( Tag_false is_linear);

    // update
    void  update_1( );
    void  update_1( Tag_true  is_linear);
    void  update_1( Tag_false is_linear);

    void  update_2( Tag_true  is_linear);
    void  update_2( Tag_false is_linear);

    void  replace_variable( );
    void  replace_variable( Tag_true  is_linear);
    void  replace_variable( Tag_false is_linear);
    void  replace_variable_original_original( );
    void  replace_variable_original_slack( );
    void  replace_variable_slack_original( );
    void  replace_variable_slack_slack( );

    void  enter_variable( );
    void  leave_variable( );

    bool  basis_matrix_stays_regular( );

    // current solution
    void  compute_solution( );

    void  compute__x_B_S( Tag_true  has_no_inequalities);
    void  compute__x_B_S( Tag_false has_no_inequalities);
    void  multiply__A_S_BxB_O( Value_iterator in, Value_iterator out) const;

    // check basis inverse
    bool  check_basis_inverse( );
    bool  check_basis_inverse( Tag_true  is_linear);
    bool  check_basis_inverse( Tag_false is_linear);

    // diagnostic output
    void  print_program ( );
    void  print_basis   ( );
    void  print_solution( );

    const char*  variable_type( int k) const;

// ----------------------------------------------------------------------------

// ===============================
// class implementation (template)
// ===============================

  public:

    // pricing
    // -------
    template < class RndAccIt1, class RndAccIt2, class NT >  
    NT
    mu_j( int j, RndAccIt1 lambda_it, RndAccIt2 x_it, const NT& dd) const
    {
	NT  mu_j;

	if ( j < qp_n) {                                // original variable

	    // [c_j +] A_Cj^T * lambda_C
	    mu_j = ( is_phaseI ? NT( 0) : dd * qp_c[ j]);
	    mu_j__linear_part( mu_j, j, lambda_it, Has_no_inequalities());

	    // ... + 2 D_Bj^T * x_B
	    mu_j__quadratic_part( mu_j, j, x_it, Is_linear());

	} else {                                        // slack or artificial

	    mu_j__slack_or_artificial( mu_j, j, lambda_it,
				       Has_no_inequalities());

	}

	return mu_j;
    }

  private:

    // pricing (private helper functions)
    // ----------------------------------
    template < class NT, class It > inline                      // no ineq.
    void
    mu_j__linear_part( NT& mu_j, int j, It lambda_it, Tag_true) const
    {
	mu_j += inv_M_B.inner_product_l( lambda_it, qp_A[ j]);
    }

    template < class NT, class It > inline                      // has ineq.
    void
    mu_j__linear_part( NT& mu_j, int j, It lambda_it, Tag_false) const
    {
	mu_j += inv_M_B.inner_product_l( lambda_it,
					 A_by_index_iterator( C.begin(),
					     A_by_index_accessor( qp_A[ j])));
    }

    template < class NT, class It > inline                      // LP case
    void
    mu_j__quadratic_part( NT&, int, It, Tag_true) const
    {
	// nop
    }

    template < class NT, class It > inline                      // QP case
    void
    mu_j__quadratic_part( NT& mu_j, int j, It x_it, Tag_false) const
    {
	if ( is_phaseII) {
	    mu_j__quadratic_part( mu_j, j, x_it, Tag_false(), Is_symmetric());
	}
    }

    template < class NT, class It >  inline                     // QP, D sym.
    void
    mu_j__quadratic_part( NT& mu_j, int j, It x_it, Tag_false, Tag_true) const
    {
	// 2 D_Bj^T * x_B
	mu_j += inv_M_B.inner_product_x( x_it,
					 D_by_index_iterator( B_O.begin(),
					     D_by_index_accessor( qp_D[ j])))
	        * NT( 2);
    }

    template < class NT, class It >  inline                     // QP, D no-sym
    void
    mu_j__quadratic_part( NT& mu_j, int j, It x_it, Tag_false, Tag_false) const
    {
	// ( D_Bj^T + D_jB) * x_B
	mu_j += inv_M_B.inner_product_x( x_it,
					 D_pairwise_iterator( B_O.begin(),
					     D_pairwise_accessor( qp_D, j)));
    }

    template < class NT, class It >  inline                     // no ineq.
    void
    mu_j__slack_or_artificial( NT& mu_j, int j, It lambda_it, Tag_true) const
    {
	j -= qp_n;
                                                        // artificial variable
	// A_j^T * lambda
	mu_j = lambda_it[ j];
	if ( art_A[ j].second) mu_j = -mu_j;

	// c_j + ...
	mu_j += NT( 1);
    }

    template < class NT, class It >  inline                     // has ineq.
    void
    mu_j__slack_or_artificial( NT& mu_j, int j, It lambda_it, Tag_false) const
    {
	j -= qp_n;

	if ( j < (int)slack_A.size()) {                 // slack variable

	    // A_Cj^T * lambda_C
	    mu_j = lambda_it[ in_C[ slack_A[ j].first]];
	    if ( slack_A[ j].second) mu_j = -mu_j;

	} else {                                        // artificial variable
	    j -= slack_A.size();

	    // A_Cj^T * lambda_C
	    mu_j = lambda_it[ in_C[ art_A[ j].first]];
	    if ( art_A[ j].second) mu_j = -mu_j;

	    // c_j + ...
	    mu_j += NT( 1);
	}
    }

};

// ----------------------------------------------------------------------------

// =============================
// class implementation (inline)
// =============================

// initialization
// --------------
template < class Rep_ >  inline                                 // no ineq.
void  QPE_solver<Rep_>::
init_basis__slack_variables( int, Tag_true)
{
    // nop
}

template < class Rep_ >  inline                                 // no ineq.
void  QPE_solver<Rep_>::
init_basis__constraints( int, Tag_true)
{
    // create 'm' dummy entries in 'C'
    if ( ! C.empty()) C.clear();         // --> move to 'init_basis()'?
    C.reserve( qp_m);
    for ( i = 0; i < qp_m; ++i) C.push_back( i);
}

template < class Rep_ >  inline                                 // no ineq.
void  QPE_solver<Rep_>::
init_solution__b_C( Tag_true)
{
    b_C.reserve( qp_m);
    std::copy( qp_b, qp_b+qp_m, std::back_inserter( b_C));
}

template < class Rep_ >  inline                                 // has ineq.
void  QPE_solver<Rep_>::
init_solution__b_C( Tag_false)
{ 
    b_C.insert( b_C.end(), l, et0);
    B_by_index_accessor  b_accessor( qp_b);
    std::copy( B_by_index_iterator( C.begin(), b_accessor),
	       B_by_index_iterator( C.end  (), b_accessor),
	       b_C.begin());
}

// transition
// ----------
template < class Rep_ >  inline                                 // QP case
void  QPE_solver<Rep_>::
transition( Tag_false)
{
    typedef  Creator_2< D_iterator, int, 
	         D_pairwise_accessor >  D_transition_creator_accessor;

    typedef  Creator_2< Index_iterator, D_pairwise_accessor,
	         D_pairwise_iterator >  D_transition_creator_iterator;

    typedef  QPE_transform_iterator_1< Index_iterator, std::binder1st<
	         Binary_compose_2< D_transition_creator_iterator,
	             Identity< Index_iterator >,
	             std::binder1st< D_transition_creator_accessor > > > >
	                                twice_D_transition_iterator;

    inv_M_B.transition( twice_D_transition_iterator( B_O.begin(),
	std::bind1st( compose2_2( D_transition_creator_iterator(),
	    Identity<Index_iterator>(), std::bind1st(
		D_transition_creator_accessor(), qp_D)), B_O.begin())));
}

template < class Rep_ >  inline                                 // LP case
void  QPE_solver<Rep_>::
transition( Tag_true)
{
    inv_M_B.transition();
}

// ratio test
// ----------
template < class Rep_ > inline                                  // LP case
void  QPE_solver<Rep_>::
ratio_test_init__2_D_Bj( Value_iterator, int, Tag_true)
{
    // nop
}

template < class Rep_ > inline                                  // QP case
void  QPE_solver<Rep_>::
ratio_test_init__2_D_Bj( Value_iterator two_D_Bj_it, int j_, Tag_false)
{
    if ( is_phaseII) {
	ratio_test_init__2_D_Bj( two_D_Bj_it, j_,
				 Tag_false(), Has_no_inequalities());
    }
}

template < class Rep_ > inline                                  // QP, no ineq.
void  QPE_solver<Rep_>::
ratio_test_init__2_D_Bj( Value_iterator two_D_Bj_it, int j_, Tag_false,
			                                     Tag_true )
{
    // store exact version of `2 D_{B_O,j}'
    D_pairwise_accessor  d_accessor( qp_D, j_);
    std::copy( D_pairwise_iterator( B_O.begin(), d_accessor),
	       D_pairwise_iterator( B_O.end  (), d_accessor),
	       two_D_Bj_it);
}

template < class Rep_ > inline                                  // QP, has ineq
void  QPE_solver<Rep_>::
ratio_test_init__2_D_Bj( Value_iterator two_D_Bj_it, int j_, Tag_false,
			                                     Tag_false)
{
    // store exact version of `2 D_{B_O,j}'
    if ( j_ < qp_n) {                               // original variable
	ratio_test_init__2_D_Bj( two_D_Bj_it, j_, Tag_false(), Tag_true());
    } else {                                        // slack variable
	std::fill_n( two_D_Bj_it, B_O.size(), et0);
    }
}

template < class Rep_ >  inline                                 // LP case
void  QPE_solver<Rep_>::
ratio_test_1__q_x_O( Tag_true)
{
    inv_M_B.multiply_x( A_Cj.begin(), q_x_O.begin());
}

template < class Rep_ >  inline                                 // QP case
void  QPE_solver<Rep_>::
ratio_test_1__q_x_O( Tag_false)
{
    if ( is_phaseI) {                                   // phase I
	inv_M_B.multiply_x(     A_Cj.begin(),    q_x_O.begin());
    } else {                                            // phase II
	inv_M_B.multiply  (     A_Cj.begin(), two_D_Bj.begin(),
			    q_lambda.begin(),    q_x_O.begin());
    }
}

template < class Rep_ >  inline                                 // no ineq.
void  QPE_solver<Rep_>::
ratio_test_1__q_x_S( Tag_true)
{
    // nop
}

template < class Rep_ >  inline                                 // has ineq.
void  QPE_solver<Rep_>::
ratio_test_1__q_x_S( Tag_false)
{
    // A_S_BxB_O * q_x_O
    multiply__A_S_BxB_O( q_x_O.begin(), q_x_S.begin());

    // ( A_S_BxB_O * x_B_O) - A_S_Bxj
    if ( j < qp_n) {
	std::transform( q_x_S.begin(),
			q_x_S.begin()+S_B.size(),
			A_by_index_iterator( S_B.begin(),
					     A_by_index_accessor( qp_A[ j])),
			q_x_S.begin(),
			compose2_2( std::minus<ET>(),
				    std::identity<ET>(),
				    std::bind1st( std::multiplies<ET>(), d)));
    }

    // q_x_S = -+ ( A_S_BxB_O * x_B_O - A_S_Bxj)
    Value_iterator  q_it = q_x_S.begin();
    Index_iterator  i_it;
    for ( i_it = B_S.begin(); i_it != B_S.end(); ++i_it, ++q_it) {
	if ( ! slack_A[ *i_it - qp_n].second) *q_it = -(*q_it);
    }
}

template < class Rep_ >  inline                                 // no check
void  QPE_solver<Rep_>::
ratio_test_1__t_i( Index_iterator, Index_iterator,
		   Value_iterator, Value_iterator, Tag_true)
{
    // nop
}

template < class Rep_ >  inline                                 // check
void  QPE_solver<Rep_>::
ratio_test_1__t_i( Index_iterator i_it, Index_iterator end_it,
		   Value_iterator x_it, Value_iterator   q_it, Tag_false)
{
    // check `t_i's
    for ( ; i_it != end_it; ++i_it, ++x_it, ++q_it) {
	if ( ( *q_it > et0) && ( ( *x_it * q_i) < ( x_i * *q_it))) {
	    i = *i_it; x_i = *x_it; q_i = *q_it;
	}
    }
}

template < class Rep_ >  inline                                 // LP case
void  QPE_solver<Rep_>::
ratio_test_1__t_j( Tag_true)
{
    // nop
}

template < class Rep_ >  inline                                 // QP case
void  QPE_solver<Rep_>::
ratio_test_1__t_j( Tag_false)
{
    if ( is_phaseII) {

	// compute `nu' and `mu_j' 
	mu = inv_M_B.inner_product(     A_Cj.begin(), two_D_Bj.begin(),
				      lambda.begin(),    x_B_O.begin());
	nu = inv_M_B.inner_product(     A_Cj.begin(), two_D_Bj.begin(),
				    q_lambda.begin(),    q_x_O.begin());
	if ( j < qp_n) {                                // original variable
	    mu +=     d*ET( qp_c[ j]);
	    nu -= et2*d*ET( qp_D[ j][ j]);
	}

	// check `t_j'
	if ( ( nu < et0) && ( ( mu * q_i) > ( x_i * nu))) {
	    i = -1; q_i = et1;
	}
    }
}

template < class Rep_ >  inline                                 // LP case
void  QPE_solver<Rep_>::
ratio_test_2( Tag_true)
{
    // nop
}

// update
// ------
template < class Rep_ >  inline                                 // LP case
void  QPE_solver<Rep_>::
update_1( Tag_true)
{
    // replace leaving with entering variable
    replace_variable();
}

template < class Rep_ >  inline                                 // QP case
void  QPE_solver<Rep_>::
update_1( Tag_false)
{
    if ( is_phaseI) {                                   // phase I

	// replace leaving with entering variable
	replace_variable();

    } else {                                            // phase II

	// enter variable into basis, if
	// - no leaving variable was found  or
	// - basis matrix would become singular when variable i leaves
	bool  stays_regular = basis_matrix_stays_regular();
	if ( ( i < 0) || ( ! stays_regular)) enter_variable();

	// leave variable from basis, if
	// - some leaving variable was found  and
	// - basis matrix stays regular
	if ( ( i >= 0) && stays_regular) leave_variable();

    }
}

template < class Rep_ >  inline                                 // LP case
void  QPE_solver<Rep_>::
update_2( Tag_true)
{
    // nop
}

template < class Rep_ >  inline                                 // no ineq.
void  QPE_solver<Rep_>::
replace_variable( Tag_true)
{
    replace_variable_original_original();
    strategyP->leaving_basis( i);
}

template < class Rep_ >  inline                                 // has ineq.
void  QPE_solver<Rep_>::
replace_variable( Tag_false)
{
    // determine type of variables
    bool  enter_original = ( (j < qp_n) || (j >= (int)( qp_n+slack_A.size())));
    bool  leave_original = ( (i < qp_n) || (i >= (int)( qp_n+slack_A.size())));

    // update basis & basis inverse
    if ( leave_original) {
	if ( enter_original) {                              // orig  <--> orig
	    replace_variable_original_original();
	} else {                                            // slack <--> orig
	    replace_variable_slack_original();
	}

	// special artificial variable removed?
	if ( is_phaseI && ( i == art_s_i)) {
	    art_s_i = -art_A.back().first;
	    art_A.pop_back();
	} else {
	    strategyP->leaving_basis( i);
	}
    } else {
	if ( enter_original) {                              // orig  <--> slack
	    replace_variable_original_slack();
	} else {                                            // slack <--> slack
	    replace_variable_slack_slack();
	}
	strategyP->leaving_basis( i);
    }
}

template < class Rep_ >  inline
bool  QPE_solver<Rep_>::
basis_matrix_stays_regular()
{
    /* ToDo: handling of slack variable
    // slack variable?
    if ( has_ineq && ( i >= qp_n)) return true;
    */

    // check original variable
    int k = l+in_B[ i];
    return ( inv_M_B.entry( k, k) != et0);
}

// current solution
// ----------------
template < class Rep_ >  inline                                 // no ineq.
void  QPE_solver<Rep_>::
compute__x_B_S( Tag_true)
{
    // nop
}

template < class Rep_ >  inline                                // has ineq.
void  QPE_solver<Rep_>::
compute__x_B_S( Tag_false)
{
    // A_S_BxB_O * x_B_O
    multiply__A_S_BxB_O( x_B_O.begin(), x_B_S.begin());

    // b_S_B - ( A_S_BxB_O * x_B_O)
    B_by_index_accessor  b_accessor( qp_b);
    std::transform( B_by_index_iterator( S_B.begin(), b_accessor),
		    B_by_index_iterator( S_B.end  (), b_accessor),
		    x_B_S.begin(),
		    x_B_S.begin(),
		    compose2_2( std::minus<ET>(),
				std::bind1st( std::multiplies<ET>(), d),
				std::identity<ET>()));

    // x_B_S = +- ( b_S_B - A_S_BxB_O * x_B_O)
    Value_iterator  x_it = x_B_S.begin();
    Index_iterator  i_it;
    for ( i_it = B_S.begin(); i_it != B_S.end(); ++i_it, ++x_it) {
	if ( slack_A[ *i_it - qp_n].second) *x_it = -(*x_it);
    }
}

CGAL_END_NAMESPACE

#ifdef CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION
#  include <CGAL/QPE_solver.C>
#endif

#endif // CGAL_QPE_SOLVER_H

// ===== EOF ==================================================================