mirror of https://github.com/CGAL/cgal
200 lines
6.1 KiB
C
200 lines
6.1 KiB
C
// ============================================================================
|
|
//
|
|
// Copyright (c) 1997-2001 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 : test/_QP_solver/test_QP_solver.C
|
|
// package : $CGAL_Package: _QP_solver $
|
|
//
|
|
// revision : 0.2
|
|
// revision_date : 2000/08/21
|
|
//
|
|
// author(s) : Sven Schönherr <sven@inf.ethz.ch>
|
|
// coordinator : ETH Zürich (Bernd Gärtner <gaertner@inf.ethz.ch>)
|
|
//
|
|
// implementation: test program for the QP solver
|
|
// ============================================================================
|
|
|
|
#include <CGAL/QPE_solver.h>
|
|
#include <CGAL/QPE_full_exact_pricing.h>
|
|
#include <CGAL/QPE_partial_exact_pricing.h>
|
|
#include <CGAL/QPE_full_filtered_pricing.h>
|
|
#include <CGAL/QPE_partial_filtered_pricing.h>
|
|
#include <CGAL/_QP_solver/Double.h>
|
|
|
|
#include <functional>
|
|
#include <iostream>
|
|
|
|
typedef std::vector<double> Vector;
|
|
typedef std::vector<Vector> Matrix;
|
|
|
|
struct Begin
|
|
: public CGAL_STD::unary_function< Vector, Vector::const_iterator > {
|
|
result_type operator () ( const Vector& v) const { return v.begin(); }
|
|
};
|
|
|
|
typedef CGAL::QPE_transform_iterator_1< Matrix::const_iterator, Begin>
|
|
Vector_iterator;
|
|
typedef Vector::const_iterator Entry_iterator;
|
|
|
|
struct Rep {
|
|
typedef GMP::Double ET;
|
|
|
|
typedef Vector_iterator A_iterator;
|
|
typedef Entry_iterator B_iterator;
|
|
typedef Entry_iterator C_iterator;
|
|
typedef Vector_iterator D_iterator;
|
|
|
|
enum Row_type { LESS_EQUAL = -1, EQUAL, GREATER_EQUAL};
|
|
typedef Row_type* Row_type_iterator;
|
|
// typedef CGAL::QPE_const_value_iterator<Row_type> Row_type_iterator;
|
|
|
|
|
|
typedef CGAL::Tag_false Is_linear;
|
|
typedef CGAL::Tag_true Is_symmetric;
|
|
typedef CGAL::Tag_true Has_no_inequalities;
|
|
};
|
|
|
|
int
|
|
main( int argc, char** argv)
|
|
{
|
|
int verbose = 0;
|
|
if ( argc > 1) verbose = atoi( argv[ 1]);
|
|
|
|
// {
|
|
// Matrix A( 3);
|
|
// Vector b;
|
|
// Vector c;
|
|
// Matrix D( 3);
|
|
|
|
// A[ 0].push_back( 3); A[ 1].push_back( 2); A[ 2].push_back( 0);
|
|
// A[ 0].push_back( 0); A[ 1].push_back( 2); A[ 2].push_back( 1);
|
|
|
|
// b.push_back( 1);
|
|
// b.push_back( 2);
|
|
|
|
// c.push_back( 1); c.push_back( 2); c.push_back( 3);
|
|
// /*
|
|
// D[ 0].push_back( 3); D[ 0].push_back( 1); D[ 0].push_back( -9);
|
|
// D[ 1].push_back( 1); D[ 1].push_back( -2); D[ 1].push_back( 2);
|
|
// D[ 2].push_back( -9); D[ 2].push_back( 2); D[ 2].push_back( 1);
|
|
// */
|
|
// //*
|
|
// D[ 0].push_back( 2); D[ 0].push_back( -5); D[ 0].push_back( -5);
|
|
// D[ 1].push_back( -5); D[ 1].push_back( 11); D[ 1].push_back( -12);
|
|
// D[ 2].push_back( -5); D[ 2].push_back( -12); D[ 2].push_back( -11);
|
|
// //*/
|
|
|
|
// Rep::Row_type* row_types = new Rep::Row_type[ 2];
|
|
// row_types[ 0] = Rep::EQUAL;
|
|
// row_types[ 1] = Rep::EQUAL;
|
|
|
|
// CGAL::QPE_solver<Rep> solver;
|
|
// solver.set_verbosity( verbose);
|
|
// solver.set( 3, 2,
|
|
// Vector_iterator( A.begin(), Begin()), b.begin(),
|
|
// c.begin(), Vector_iterator( D.begin(), Begin()),
|
|
// row_types);
|
|
// {
|
|
// CGAL::QPE_full_exact_pricing<Rep> strategy;
|
|
// solver.set_pricing_strategy( strategy);
|
|
// solver.init();
|
|
// solver.solve();
|
|
// std::cerr << "-----------------------------------------------------\n";
|
|
// }
|
|
// {
|
|
// CGAL::QPE_partial_exact_pricing<Rep> strategy;
|
|
// solver.set_pricing_strategy( strategy);
|
|
// solver.init();
|
|
// solver.solve();
|
|
// std::cerr << "-----------------------------------------------------\n";
|
|
// }
|
|
// {
|
|
// CGAL::QPE_full_filtered_pricing<Rep> strategy;
|
|
// solver.set_pricing_strategy( strategy);
|
|
// solver.init();
|
|
// solver.solve();
|
|
// std::cerr << "-----------------------------------------------------\n";
|
|
// }
|
|
// {
|
|
// CGAL::QPE_partial_filtered_pricing<Rep> strategy;
|
|
// solver.set_pricing_strategy( strategy);
|
|
// solver.init();
|
|
// solver.solve();
|
|
// std::cerr << "-----------------------------------------------------\n";
|
|
// }
|
|
// }
|
|
|
|
{
|
|
Matrix A( 2);
|
|
Vector b;
|
|
Vector c;
|
|
Matrix D( 2);
|
|
|
|
A[ 0].push_back( 1); A[ 1].push_back( -1);
|
|
|
|
b.push_back( 0);
|
|
|
|
c.push_back( 0); c.push_back( 0);
|
|
/*
|
|
D[ 0].push_back( 3); D[ 0].push_back( 1); D[ 0].push_back( -9);
|
|
D[ 1].push_back( 1); D[ 1].push_back( -2); D[ 1].push_back( 2);
|
|
D[ 2].push_back( -9); D[ 2].push_back( 2); D[ 2].push_back( 1);
|
|
*/
|
|
//*
|
|
D[ 0].push_back( 1); D[ 0].push_back( -1);
|
|
D[ 1].push_back( -1); D[ 1].push_back( 1);
|
|
//*/
|
|
|
|
Rep::Row_type* row_types = new Rep::Row_type[ 1];
|
|
row_types[ 0] = Rep::EQUAL;
|
|
|
|
CGAL::QPE_solver<Rep> solver;
|
|
solver.set_verbosity( verbose);
|
|
solver.set( 2, 1,
|
|
Vector_iterator( A.begin(), Begin()), b.begin(),
|
|
c.begin(), Vector_iterator( D.begin(), Begin()),
|
|
row_types);
|
|
{
|
|
CGAL::QPE_full_exact_pricing<Rep> strategy;
|
|
solver.set_pricing_strategy( strategy);
|
|
solver.init();
|
|
solver.solve();
|
|
std::cerr << "-----------------------------------------------------\n";
|
|
}
|
|
{
|
|
CGAL::QPE_partial_exact_pricing<Rep> strategy;
|
|
solver.set_pricing_strategy( strategy);
|
|
solver.init();
|
|
solver.solve();
|
|
std::cerr << "-----------------------------------------------------\n";
|
|
}
|
|
{
|
|
CGAL::QPE_full_filtered_pricing<Rep> strategy;
|
|
solver.set_pricing_strategy( strategy);
|
|
solver.init();
|
|
solver.solve();
|
|
std::cerr << "-----------------------------------------------------\n";
|
|
}
|
|
{
|
|
CGAL::QPE_partial_filtered_pricing<Rep> strategy;
|
|
solver.set_pricing_strategy( strategy);
|
|
solver.init();
|
|
solver.solve();
|
|
std::cerr << "-----------------------------------------------------\n";
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
// ===== EOF ==================================================================
|