mirror of https://github.com/CGAL/cgal
code coverage tests for Algebraic Curve Kernel
This commit is contained in:
Pavel Emeliyanenko
parent
191ecbafda
commit
161a2185a0
|
|
@ -281,6 +281,7 @@ Algebraic_kernel_d/test/Algebraic_kernel_d/Algebraic_kernel_1.cpp -text
|
|||
Algebraic_kernel_d/test/Algebraic_kernel_d/Algebraic_real_pure.cpp -text
|
||||
Algebraic_kernel_d/test/Algebraic_kernel_d/Bitstream_descartes.cpp -text
|
||||
Algebraic_kernel_d/test/Algebraic_kernel_d/Descartes.cpp -text
|
||||
Algebraic_kernel_d/test/Algebraic_kernel_d/include/CGAL/_test_algebraic_curve_kernel_2.h -text
|
||||
Algebraic_kernel_d/test/Algebraic_kernel_d/include/CGAL/_test_algebraic_kernel_1.h -text
|
||||
Algebraic_kernel_d/test/Algebraic_kernel_d/include/CGAL/_test_real_comparable.h -text
|
||||
Algebraic_kernel_d/test/Algebraic_kernel_d/include/CGAL/_test_real_root_isolator.h -text
|
||||
|
|
|
|||
|
|
@ -4,297 +4,50 @@
|
|||
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
||||
//
|
||||
// $URL:$
|
||||
// $Id: Algebraic_curve_kernel_2.C,v 1.2 2007/10/12 11:43:30 emeliyan Exp $
|
||||
// $Id: $
|
||||
//
|
||||
//
|
||||
// Author(s) : Pavel Emeliyanenko <asm@mpi-sb.mpg.de>
|
||||
//
|
||||
// ============================================================================
|
||||
|
||||
// Benchmark for Algebraic_curve_kernel_2::Solve_2
|
||||
// code coverage test for Algebraic_curve_kernel_2
|
||||
|
||||
#include <CGAL/basic.h>
|
||||
|
||||
#include <CGAL/Benchmark/Benchmark.hpp>
|
||||
#include <CGAL/Benchmark/Option_parser.hpp>
|
||||
|
||||
// reqiured for Kernel_2::decompose tests
|
||||
#define AcX_CHECK_POLYNOMIALS_FOR_COPRIMABILITY
|
||||
|
||||
#include <NiX/Arithmetic_traits.h>
|
||||
#include <NiX/NT_traits.h>
|
||||
#include <AcX/Algebraic_curve_2.h>
|
||||
#include <AcX/Algebraic_curve_pair_2.h>
|
||||
|
||||
#include <CGAL/Algebraic_kernel_1.h>
|
||||
#include <CGAL/Algebraic_curve_kernel_2.h>
|
||||
#include <CGAL/_test_algebraic_curve_kernel_2.h>
|
||||
|
||||
template <class Integer>
|
||||
struct Max_bit_size
|
||||
{
|
||||
template <class X>
|
||||
int operator()(const NiX::Polynomial<X>& p) const
|
||||
{
|
||||
typename NiX::Polynomial<X>::const_iterator it = p.begin();
|
||||
Max_bit_size<Integer> max_bit_size;
|
||||
int max = max_bit_size(*it);
|
||||
while(++it != p.end())
|
||||
max = std::max(max, max_bit_size(*it));
|
||||
return max;
|
||||
}
|
||||
|
||||
int operator()(const Integer& x) const
|
||||
{ return CGAL::CGALi::ceil_log2_abs(x); }
|
||||
};
|
||||
//#include <CGAL/Arithmetic_kernel.h>
|
||||
|
||||
struct Benchmark_result {
|
||||
int number_of_polys;
|
||||
double bits;
|
||||
int number_of_real_roots_found;
|
||||
int degree_of_polys;
|
||||
|
||||
float solve_time;
|
||||
float sort_time;
|
||||
float total_time;
|
||||
};
|
||||
template< class ArithmeticTraits >
|
||||
void test_algebraic_curve_kernel_2() {
|
||||
|
||||
std::ostream& operator <<(std::ostream& os, const Benchmark_result& res) {
|
||||
typedef ArithmeticTraits AT;
|
||||
typedef typename AT::Integer Coefficient;
|
||||
|
||||
typedef AcX::Algebraic_curve_2<AT> Curve_2;
|
||||
typedef AcX::Algebraic_curve_pair_2<Curve_2> Curve_pair_2;
|
||||
|
||||
typedef CGAL::Algebraic_kernel_1<Coefficient> Kernel_1;
|
||||
typedef CGAL::Algebraic_curve_kernel_2<Curve_pair_2, Kernel_1>
|
||||
Kernel_2;
|
||||
|
||||
os << "n polys: " << res.number_of_polys << "\tn_bits: " << res.bits
|
||||
<< "\tn_real_roots: " << res.number_of_real_roots_found
|
||||
<< "\tdegre of polys: " << res.degree_of_polys << "\tsolve time: " <<
|
||||
res.solve_time << "\tsort time: " << res.sort_time <<
|
||||
"\t total time: " << res.total_time << std::endl;
|
||||
return os;
|
||||
CGAL::CGALi::test_algebraic_curve_kernel_2<Kernel_2>();
|
||||
}
|
||||
|
||||
template< class AlgebraicCurveKernel_2 >
|
||||
class Bench_solve_2 {
|
||||
|
||||
public:
|
||||
//! this instance's first template argument
|
||||
typedef AlgebraicCurveKernel_2 AK_2;
|
||||
//! in this setting Curve_2 == Polynomial_2
|
||||
typedef typename AK_2::Curve_2 Curve_2;
|
||||
//! type of result (bivariate polynomials solution)
|
||||
typedef typename AK_2::Xy_coordinate_2 Xy_coordinate_2;
|
||||
|
||||
// shall we pass as a parameter internal polynomials instead of curves ?
|
||||
//! container of input curves
|
||||
typedef std::vector<Curve_2> Curve_vector;
|
||||
//! container of resulting solutions
|
||||
typedef std::vector<Xy_coordinate_2> Root_vector;
|
||||
//! container of multiplicities
|
||||
typedef std::vector<int> Mult_vector;
|
||||
|
||||
public:
|
||||
|
||||
void setup(Curve_vector curves) {
|
||||
// typename Root_vector::iterator roots_,
|
||||
// typename Mult_vector::iterator mults_) {
|
||||
_m_curves.clear();
|
||||
_m_curves = curves;
|
||||
_m_roots.clear();
|
||||
_m_mults.clear();
|
||||
}
|
||||
|
||||
Root_vector& get_roots() {
|
||||
return _m_roots;
|
||||
}
|
||||
|
||||
Mult_vector& get_multiplicities() {
|
||||
return _m_mults;
|
||||
}
|
||||
|
||||
int init() { return 0; }
|
||||
void clean() {}
|
||||
void sync() {}
|
||||
|
||||
void op()
|
||||
{
|
||||
int n = static_cast<int>(_m_curves.size());
|
||||
if(n < 2)
|
||||
return;
|
||||
|
||||
_m_roots.clear();
|
||||
_m_mults.clear();
|
||||
typename AK_2::Solve_2 solve_2;
|
||||
|
||||
std::cout << "number of curves: " << n << std::endl;
|
||||
for(int i = 0; i < n-1; i++)
|
||||
for(int j = i+1; j < n; j++) {
|
||||
std::cout << "i = " << i << "; j = " << j << "\n";
|
||||
|
||||
// CGAL::remove_scalar_factor( poly ); ??
|
||||
solve_2(_m_curves[i], _m_curves[j], std::back_inserter(_m_roots),
|
||||
std::back_inserter(_m_mults));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
Curve_vector _m_curves;
|
||||
Root_vector _m_roots;
|
||||
Mult_vector _m_mults;
|
||||
};
|
||||
|
||||
template< class AlgebraicCurveKernel_2 >
|
||||
class Bench_sort {
|
||||
|
||||
public:
|
||||
//! this instance's first template argument
|
||||
typedef AlgebraicCurveKernel_2 AK_2;
|
||||
//! in this setting Curve_2 == Polynomial_2
|
||||
typedef typename AK_2::Curve_2 Curve_2;
|
||||
//! type of result (bivariate polynomials solution)
|
||||
typedef typename AK_2::Xy_coordinate_2 Xy_coordinate_2;
|
||||
|
||||
// shall we pass as a parameter internal polynomials instead of curves ?
|
||||
//! container of input curves
|
||||
typedef std::vector<Curve_2> Curve_vector;
|
||||
//! container of resulting solutions
|
||||
typedef std::vector<Xy_coordinate_2> Root_vector;
|
||||
//! container of multiplicities
|
||||
typedef std::vector<int> Mult_vector;
|
||||
|
||||
public:
|
||||
|
||||
void setup(Root_vector *p_roots) {
|
||||
|
||||
CGAL_precondition(p_roots != NULL);
|
||||
_m_proots = p_roots;
|
||||
}
|
||||
|
||||
int init() { return 0; }
|
||||
void clean() {}
|
||||
void sync() {}
|
||||
|
||||
Root_vector *get_proots(){
|
||||
return _m_proots;
|
||||
}
|
||||
|
||||
void op()
|
||||
{
|
||||
// sort them out
|
||||
std::sort(_m_proots->begin(), _m_proots->end());
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
Root_vector *_m_proots;
|
||||
};
|
||||
|
||||
|
||||
template<class AlgebraicCurveKernel_2>
|
||||
Benchmark_result do_benchmark(std::string filename, int n_samples = 5)
|
||||
{
|
||||
typedef AlgebraicCurveKernel_2 AK_2;
|
||||
|
||||
typedef typename AK_2::Xy_coordinate_2 Xy_coordinate_2;
|
||||
|
||||
typedef typename AK_2::Curve_2 Curve_2;
|
||||
typedef typename Curve_2::Poly_d Internal_polynomial_2;
|
||||
typedef typename NiX::Polynomial_traits<Internal_polynomial_2>::
|
||||
Innermost_coefficient Integer;
|
||||
|
||||
typedef Bench_solve_2<AK_2> Bench_solve_ak_2;
|
||||
typedef typename Bench_solve_ak_2::Curve_vector Curve_vector;
|
||||
typedef typename Bench_solve_ak_2::Root_vector Root_vector;
|
||||
typedef typename Bench_solve_ak_2::Mult_vector Mult_vector;
|
||||
|
||||
Benchmark_result result;
|
||||
|
||||
CGAL::benchmark::Benchmark<Bench_solve_ak_2>
|
||||
bench_solve_2(filename, 0, true);
|
||||
|
||||
CGAL::benchmark::Benchmark<Bench_sort<AK_2> >
|
||||
bench_sort(filename, 0, true);
|
||||
|
||||
bench_solve_2.set_samples(n_samples);
|
||||
bench_sort.set_samples(n_samples);
|
||||
|
||||
// read in the polynomials for testing
|
||||
std::ifstream file(filename.c_str());
|
||||
CGAL_assertion_msg(file,
|
||||
(std::string("File not found: ") + filename).c_str());
|
||||
|
||||
int n_polys;
|
||||
file >> n_polys;
|
||||
|
||||
AK_2 kernel_2;
|
||||
Curve_vector curves;
|
||||
Internal_polynomial_2 tmp;
|
||||
for(int i = 0; i < n_polys; i++) {
|
||||
file >> tmp;
|
||||
// CGAL::remove_scalar_factor(poly); ??
|
||||
Curve_2 c = kernel_2.construct_curve_2_object()(
|
||||
NiX::canonicalize_polynomial(tmp));
|
||||
curves.push_back(c);
|
||||
CGAL_assertion(!file.eof());
|
||||
}
|
||||
file.close();
|
||||
|
||||
result.number_of_polys = n_polys;
|
||||
result.degree_of_polys = curves.front().f().degree();
|
||||
|
||||
Max_bit_size<Integer> max_bit_size;
|
||||
double total_bits = 0.0;
|
||||
for(typename Curve_vector::iterator it = curves.begin();
|
||||
it != curves.end(); it++)
|
||||
total_bits += max_bit_size(it->f());
|
||||
|
||||
result.bits = total_bits / n_polys;
|
||||
|
||||
bench_solve_2.get_benchable().setup(curves);
|
||||
bench_solve_2();
|
||||
result.solve_time = bench_solve_2.get_period() / n_samples;
|
||||
|
||||
Root_vector& roots = bench_solve_2.get_benchable().get_roots();
|
||||
Mult_vector& mults = bench_solve_2.get_benchable().get_multiplicities();
|
||||
result.number_of_real_roots_found = roots.size();
|
||||
|
||||
bench_sort.get_benchable().setup(&roots);
|
||||
bench_sort();
|
||||
result.sort_time = bench_sort.get_period() / n_samples;
|
||||
|
||||
::CGAL::set_mode(std::cout, ::CGAL::IO::PRETTY);
|
||||
std::cout << "Roots in ascending order: \n";
|
||||
int i = 0;
|
||||
typename Root_vector::const_iterator rit;
|
||||
typename Mult_vector::const_iterator mit;
|
||||
for(rit = roots.begin(), mit = mults.begin(); rit != roots.end();
|
||||
rit++, mit++) {
|
||||
typedef typename Xy_coordinate_2::Boundary Boundary;
|
||||
typedef typename Xy_coordinate_2::Boundary_interval Boundary_interval;
|
||||
Boundary_interval x_iv = rit->get_approximation_x(),
|
||||
y_iv = rit->get_approximation_y();
|
||||
while(x_iv.upper() - x_iv.lower() > Boundary(1,10000)) {
|
||||
rit->refine_x();
|
||||
x_iv = rit->get_approximation_x();
|
||||
}
|
||||
while(y_iv.upper() - y_iv.lower() > Boundary(1,10000)) {
|
||||
rit->refine_y();
|
||||
y_iv = rit->get_approximation_y();
|
||||
}
|
||||
std::cout << i++ << ": " << std::flush;
|
||||
std::cout << " ( " << std::flush;
|
||||
std::cout << NiX::to_double((x_iv.upper() + x_iv.lower())/2)
|
||||
<< std::flush;
|
||||
std::cout << ", " << std::flush;
|
||||
std::cout << NiX::to_double((y_iv.upper() + y_iv.lower())/2)
|
||||
<< std::flush;
|
||||
std::cout << " ) " << std::flush;
|
||||
std::cout << "; multiplicity: " << *mit << std::endl << std::endl;
|
||||
}
|
||||
|
||||
result.total_time = result.solve_time + result.sort_time;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
int main( int argc, char** argv ) {
|
||||
|
||||
if(argc > 1) {
|
||||
CGAL_assertion(argc >= 2);
|
||||
int n_samples = (argc >= 3) ? std::atoi(argv[2]) : 5;
|
||||
int main() {
|
||||
|
||||
#ifdef LiS_HAVE_CORE
|
||||
typedef NiX::CORE_arithmetic_traits AT;
|
||||
|
|
@ -303,20 +56,8 @@ int main( int argc, char** argv ) {
|
|||
typedef NiX::LEDA_arithmetic_traits AT;
|
||||
#endif
|
||||
#endif
|
||||
typedef AT::Integer Coefficient;
|
||||
|
||||
typedef AcX::Algebraic_curve_2<AT> Curve_2;
|
||||
typedef AcX::Algebraic_curve_pair_2<Curve_2> Curve_pair_2;
|
||||
|
||||
typedef CGAL::Algebraic_kernel_1<Coefficient> Kernel_1;
|
||||
typedef CGAL::Algebraic_curve_kernel_2<Curve_pair_2, Kernel_1>
|
||||
Kernel_2;
|
||||
|
||||
std::cerr << do_benchmark<Kernel_2>(argv[1], n_samples);
|
||||
|
||||
test_algebraic_curve_kernel_2<AT>();
|
||||
|
||||
} else {
|
||||
std::cerr << "No parameters found" << std::endl;
|
||||
}
|
||||
|
||||
return 0;
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,271 @@
|
|||
// TODO: Add licence
|
||||
//
|
||||
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
|
||||
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
||||
//
|
||||
// $URL:$
|
||||
// $Id: $
|
||||
//
|
||||
//
|
||||
// Author(s) : Pavel Emeliyanenko <asm@mpi-sb.mpg.de>
|
||||
//
|
||||
// ============================================================================
|
||||
|
||||
#include <CGAL/basic.h>
|
||||
#include <CGAL/Testsuite/assert.h>
|
||||
|
||||
//#include <CGAL/Algebraic_kernel_1.h>
|
||||
|
||||
//#include <CGAL/_test_basic.h>
|
||||
|
||||
#ifndef CGAL_TEST_ALGEBRAIC_CURVE_KERNEL_2_H
|
||||
#define CGAL_TEST_ALGEBRAIC_CURVE_KERNEL_2_H
|
||||
|
||||
CGAL_BEGIN_NAMESPACE
|
||||
|
||||
namespace CGALi {
|
||||
|
||||
static const char *ACK_2_ascii_polys[] = {
|
||||
|
||||
"P[12(0,P[12(0,-403)(1,445)(2,-244)(3,-261)(4,182)(5,-284)(6,321)(7,-150)(8,-312)(9,-395)(10,451)(11,166)(12,-268)])(1,P[11(0,-149)(1,-194)(2,190)(3,397)(4,-423)(5,507)(6,-321)(7,215)(8,-459)(9,-112)(10,35)(11,-296)])(2,P[10(0,326)(1,296)(2,-461)(3,-175)(4,-123)(5,432)(6,195)(7,447)(8,-135)(9,-87)(10,8)])(3,P[9(0,299)(1,10)(2,-494)(3,192)(4,269)(5,-177)(6,-418)(7,461)(8,352)(9,23)])(4,P[8(0,193)(1,-357)(2,-187)(3,-140)(4,-126)(5,195)(6,-178)(7,-156)(8,-118)])(5,P[7(0,-11)(1,-205)(2,-357)(3,-157)(4,-321)(5,295)(6,-120)(7,-72)])(6,P[6(0,322)(1,443)(2,-26)(3,-29)(4,196)(5,-188)(6,132)])(7,P[5(0,372)(1,-15)(2,-184)(3,-4)(4,453)(5,-134)])(8,P[4(0,26)(1,131)(2,-170)(3,256)(4,282)])(9,P[3(0,198)(1,-424)(2,134)(3,350)])(10,P[2(0,-49)(1,-445)(2,343)])(11,P[1(0,86)(1,417)])(12,P[0(0,-295)])]", // 0
|
||||
|
||||
"P[6(0,P[6(0,132371318621897968)(1,62063386199148599600)(2,-151639931559080760922)(3,93583844480566235832)(4,-83154766543076124512)(5,-35432091262507130904)(6,227271934222282896800)])(1,P[5(0,-71827641993430936816)(1,368348281512476672028)(2,-286334917753887437776)(3,204520624662741644980)(4,-153426196026247710960)(5,-806483254283204758968)])(2,P[4(0,-207823824331267897258)(1,407437416975079236352)(2,-109980596108783730996)(3,560473260289176309328)(4,707425975812414448406)])(3,P[3(0,-229793885496425988888)(1,-16258161769731113484)(2,-225314637374518033384)(3,390228626765477166248)])(4,P[2(0,30511269636646463220)(1,-323492766503557473768)(2,-917252466360862051372)])(5,P[1(0,159815596286749757976)(1,567591812420861278704)])(6,P[0(0,-148967343686356735666)])]", // 1
|
||||
|
||||
"P[2(0,P[2(0,35204645504740)(1,18690431343280)(2,-33659097374560)])(1,P[1(0,-5878113292740)(1,25167512604160)])(2,P[0(0,41597705375085)])]", // 2
|
||||
|
||||
"P[6(0,P[6(0,-4041376884475638882353)(1,7050387367979191249572)(2,13657295334099123447165)(3,25540501499116672333266)(4,35818873525049083535243)(5,5246125427237612693902)(6,14604340604186011880149)])(1,P[5(0,6901581474556480012157)(1,-7529175981573515299061)(2,-11055581988553126878879)(3,12006542139536462689689)(4,14452481220936855448204)(5,13877670792372320318222)])(2,P[4(0,-11020699216485230516718)(1,-17311543433158205744767)(2,-31286655398777064659338)(3,-31056714506153479404652)(4,4356717231425141453473)])(3,P[3(0,3592444310543685259781)(1,6258214164280712933460)(2,-21871202396326925470570)(3,-7534603152074886821296)])(4,P[2(0,9063109123142130614750)(1,7920859532025064873268)(2,-6296939225750115900496)])(5,P[1(0,5169051546475000208976)(1,893576149924111317664)])(6,P[0(0,973644041162690858383)])]", // 3
|
||||
|
||||
"P[3(0,P[3(0,1)(1,3)(2,3)(3,1)])(1,P[2(0,-3)(1,-6)(2,-3)])(2,P[1(0,3)(1,3)])(3,P[0(0,-1)])]", // (x-y+1)^3 // 4
|
||||
|
||||
"P[1(0,P[1(1,1)])(1,P[0(0,-1)])]", // (x-y) // 5
|
||||
|
||||
"P[2(0,P[2(2,1)])(2,P[0(0,-1)])]" // x^2-y^2 // 6
|
||||
};
|
||||
|
||||
|
||||
|
||||
static const int ACK_2_n_polys = 7;
|
||||
|
||||
template< class AlgebraicCurveKernel_2 >
|
||||
void test_algebraic_curve_kernel_2() {
|
||||
|
||||
typedef AlgebraicCurveKernel_2 AK_2;
|
||||
|
||||
/* BOOST_STATIC_ASSERT( (::boost::is_same<
|
||||
Algebraic_real_1, typename AK::Algebraic_real_1 >::value) );
|
||||
|
||||
BOOST_STATIC_ASSERT((::boost::is_same<
|
||||
Isolator,
|
||||
typename AK::Isolator >::value) );
|
||||
|
||||
BOOST_STATIC_ASSERT((::boost::is_same<
|
||||
Coefficient,
|
||||
typename AK::Coefficient >::value));
|
||||
|
||||
BOOST_STATIC_ASSERT((::boost::is_same<
|
||||
Polynomial_1,
|
||||
typename AK::Polynomial_1 >::value));*/
|
||||
|
||||
typedef typename AK_2::Curve_2 Curve_2;
|
||||
typedef typename Curve_2::Poly_d Internal_poly_2;
|
||||
typedef typename AK_2::Curve_analysis_2 Curve_analysis_2;
|
||||
typedef typename Curve_analysis_2::Curve_vertical_line_1
|
||||
Curve_vertical_line_1;
|
||||
|
||||
typedef typename AK_2::X_coordinate_1 X_coordinate_1;
|
||||
typedef typename AK_2::Xy_coordinate_2 Xy_coordinate_2;
|
||||
|
||||
Internal_poly_2 polys[ACK_2_n_polys];
|
||||
|
||||
::CGAL::set_mode(std::cerr, ::CGAL::IO::PRETTY);
|
||||
|
||||
std::cerr << "constructing curves..\n";
|
||||
for(int i = 0; i < ACK_2_n_polys; i++) {
|
||||
istringstream in(ACK_2_ascii_polys[i]);
|
||||
in >> polys[i];
|
||||
}
|
||||
|
||||
///////// testing curve construction //////////
|
||||
|
||||
AK_2 kernel_2;
|
||||
Curve_2 c0 = kernel_2.construct_curve_2_object()(polys[0]),
|
||||
// make it decomposable
|
||||
c1 = kernel_2.construct_curve_2_object()(polys[1]*polys[2]),
|
||||
c2 = kernel_2.construct_curve_2_object()(polys[2]),
|
||||
c3 = kernel_2.construct_curve_2_object()(polys[3]),
|
||||
c5 = kernel_2.construct_curve_2_object()(polys[5]),
|
||||
c6 = kernel_2.construct_curve_2_object()(polys[6]);
|
||||
std::cerr << "done..\n";
|
||||
|
||||
Curve_analysis_2 ca0(c0), ca1(c1);
|
||||
Curve_vertical_line_1 line1, line2;
|
||||
Xy_coordinate_2 xy1, xy2, xy3;
|
||||
|
||||
///////// testing comparison predicates //////////
|
||||
|
||||
line1 = ca0.vertical_line_of_interval(0);
|
||||
xy1 = line1.get_algebraic_real_2(1);
|
||||
line2 = ca1.vertical_line_at_event(1);
|
||||
xy2 = line2.get_algebraic_real_2(2);
|
||||
xy3 = line2.get_algebraic_real_2(1);
|
||||
|
||||
CGAL_test_assert(kernel_2.compare_x_2_object()(xy1, xy2) == CGAL::SMALLER);
|
||||
CGAL_test_assert(kernel_2.compare_x_2_object()(xy2, xy3) == CGAL::EQUAL);
|
||||
CGAL_test_assert(kernel_2.compare_xy_2_object()(xy1, xy2) ==
|
||||
CGAL::SMALLER);
|
||||
CGAL_test_assert(kernel_2.compare_xy_2_object()(xy2, xy3) ==
|
||||
CGAL::LARGER);
|
||||
|
||||
/////// testing squarefreeness and coprimality /////////
|
||||
|
||||
/*CGAL_test_assert(
|
||||
kernel_2.has_finite_number_of_self_intersections_2_object()
|
||||
(polys[0]));
|
||||
CGAL_test_assert(
|
||||
!kernel_2.has_finite_number_of_self_intersections_2_object()
|
||||
(polys[4])); // non-squarefree*/
|
||||
|
||||
CGAL_test_assert(
|
||||
kernel_2.has_finite_number_of_intersections_2_object()
|
||||
(c2, c3)); // coprime
|
||||
|
||||
CGAL_test_assert(
|
||||
!kernel_2.has_finite_number_of_intersections_2_object()
|
||||
(c1, c2)); // non-coprime
|
||||
|
||||
CGAL_test_assert(
|
||||
!kernel_2.has_finite_number_of_intersections_2_object()
|
||||
(c5, c6)); // non-coprime
|
||||
|
||||
//////// testing decompose ///////////
|
||||
|
||||
CGAL_test_assert((kernel_2.decompose_2_object()(polys[4])) !=
|
||||
polys[4]); // non-squarefree
|
||||
|
||||
CGAL_test_assert((kernel_2.decompose_2_object()(polys[3])) ==
|
||||
polys[3]);
|
||||
|
||||
typedef std::vector<Curve_2> Curves_2;
|
||||
typedef std::vector<int> Int_vector;
|
||||
Curves_2 parts;
|
||||
Int_vector mults;
|
||||
typename Curves_2::const_iterator cit;
|
||||
typename Int_vector::const_iterator iit;
|
||||
|
||||
std::cerr << "n_factors: " << kernel_2.decompose_2_object()(c1,
|
||||
std::back_inserter(parts), std::back_inserter(mults));
|
||||
|
||||
for(cit = parts.begin(), iit = mults.begin(); cit != parts.end();
|
||||
cit++, iit++) {
|
||||
//std::cerr << "part: " << cit->f() << "; mult: " << *iit << "\n";
|
||||
}
|
||||
|
||||
parts.clear();
|
||||
mults.clear();
|
||||
|
||||
std::cerr << "n_factors :" <<
|
||||
kernel_2.decompose_2_object()(c3, std::back_inserter(parts),
|
||||
std::back_inserter(mults));
|
||||
for(cit = parts.begin(), iit = mults.begin(); cit != parts.end();
|
||||
cit++, iit++) {
|
||||
//std::cerr << "part: " << cit->f() << "; mult: " << *iit << "\n";
|
||||
}
|
||||
|
||||
Curves_2 fgs, fs, gs;
|
||||
|
||||
CGAL_test_assert(kernel_2.decompose_2_object()(c5, c6,
|
||||
std::back_inserter(fs), std::back_inserter(gs),
|
||||
std::back_inserter(fgs))); // must have a common part
|
||||
|
||||
CGAL_test_assert(fgs.size() == 1);
|
||||
CGAL_test_assert(fs.size() == 0);
|
||||
CGAL_test_assert(gs.size() == 1);
|
||||
|
||||
/*std::cerr << "common: " << fgs.size() << "; " <<
|
||||
fs.size() << "; " << gs.size() << "\n";*/
|
||||
|
||||
fgs.clear();
|
||||
fs.clear();
|
||||
gs.clear();
|
||||
CGAL_test_assert(!kernel_2.decompose_2_object()(c2, c3,
|
||||
std::back_inserter(fs), std::back_inserter(gs),
|
||||
std::back_inserter(fgs))); // must be coprime
|
||||
|
||||
CGAL_test_assert(fgs.size() == 0);
|
||||
CGAL_test_assert(fs.size() == 1);
|
||||
CGAL_test_assert(gs.size() == 1);
|
||||
|
||||
/*std::cerr << "coprime: " << fgs.size() << "; " <<
|
||||
fs.size() << "; " << gs.size() << "\n";*/
|
||||
|
||||
///////// testing derivation //////////
|
||||
|
||||
typename AK_2::NiX2CGAL_converter cvt;
|
||||
typename AK_2::CGAL2NiX_converter cvt_back;
|
||||
|
||||
cvt_back(kernel_2.derivative_x_2_object()(cvt(polys[0])));
|
||||
|
||||
cvt_back(kernel_2.derivative_y_2_object()(cvt(polys[0])));
|
||||
|
||||
//////// testing x/y-critical points ////////
|
||||
|
||||
typedef std::vector<Xy_coordinate_2> Xy_coords;
|
||||
|
||||
Xy_coords points;
|
||||
typename Xy_coords::const_iterator xyit;
|
||||
kernel_2.x_critical_points_2_object()(c0, std::back_inserter(points));
|
||||
|
||||
CGAL_test_assert(points.size() == 10);
|
||||
//std::cerr << "testing x-critical points: " << points.size() << "\n";
|
||||
|
||||
points.clear();
|
||||
kernel_2.y_critical_points_2_object()(c0, std::back_inserter(points));
|
||||
|
||||
CGAL_test_assert(points.size() == 10);
|
||||
|
||||
///////// testing sign_2 //////////////
|
||||
|
||||
Curve_vertical_line_1 line;
|
||||
Xy_coordinate_2 xy;
|
||||
|
||||
int n_lines = ca0.number_of_vertical_lines_with_event(), ii, jj,
|
||||
n_events;
|
||||
for(ii = 0; ii < n_lines; ii++) {
|
||||
|
||||
line = ca0.vertical_line_at_event(ii);
|
||||
n_events = line.number_of_events();
|
||||
std::cout << ii << "pts at event: \n";
|
||||
for(jj = 0; jj < n_events; jj++) {
|
||||
xy = line.get_algebraic_real_2(jj);
|
||||
std::cout << "sign 2: " <<
|
||||
kernel_2.sign_at_2_object()(c1, xy) << "\n\n";
|
||||
}
|
||||
|
||||
std::cout << ii << "pts over interval: \n";
|
||||
line = ca0.vertical_line_of_interval(ii);
|
||||
n_events = line.number_of_events();
|
||||
for(jj = 0; jj < n_events; jj++) {
|
||||
xy = line.get_algebraic_real_2(jj);
|
||||
std::cout << " sign 2: " <<
|
||||
kernel_2.sign_at_2_object()(c1, xy) << "\n\n";
|
||||
}
|
||||
}
|
||||
|
||||
///////////// testing solve_2 /////////////
|
||||
|
||||
points.clear();
|
||||
mults.clear();
|
||||
kernel_2.solve_2_object()(c2, c3, std::back_inserter(points),
|
||||
std::back_inserter(mults));
|
||||
|
||||
for(xyit = points.begin(), iit = mults.begin(); xyit != points.end();
|
||||
xyit++, iit++) {
|
||||
//std::cerr << "pt: " << *xyit << "; mult: " << *iit << "\n";
|
||||
}
|
||||
}
|
||||
|
||||
} //namespace CGALi
|
||||
|
||||
CGAL_END_NAMESPACE
|
||||
|
||||
#endif // CGAL_TEST_ALGEBRAIC_CURVE_KERNEL_2_H
|
||||
Loading…
Reference in New Issue