SPAR/AIModule/BWTA/vendors/CGAL/CGAL/Arr_counting_traits_2.h

Go to the documentation of this file.

// Copyright (c) 2005  Tel-Aviv University (Israel).
// All rights reserved.
//
// This file is part of CGAL (www.cgal.org); you may redistribute it under
// the terms of the Q Public License version 1.0.
// See the file LICENSE.QPL distributed with CGAL.
//
// Licensees holding a valid commercial license may use this file in
// accordance with the commercial license agreement provided with the software.
//
// 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: svn+ssh://scm.gforge.inria.fr/svn/cgal/branches/CGAL-3.5-branch/Arrangement_on_surface_2/include/CGAL/Arr_counting_traits_2.h $
// $Id: Arr_counting_traits_2.h 50366 2009-07-05 12:56:48Z efif $
//
// Author(s)     : Efi Fogel    <efif@post.tau.ac.il>

#ifndef CGAL_ARR_COUNTING_TRAITS_H
#define CGAL_ARR_COUNTING_TRAITS_H

#include <iostream>
#include <string.h>

#include <CGAL/basic.h>
#include <CGAL/Arr_enums.h>

CGAL_BEGIN_NAMESPACE

template <class Base_traits>
class Arr_counting_traits_2 : public Base_traits {
public:
  enum Operation_id {
    COMPARE_X_OP = 0,
    COMPARE_XY_OP,
    CONSTRUCT_MIN_VERTEX_OP,
    CONSTRUCT_MAX_VERTEX_OP,
    IS_VERTICAL_OP,
    COMPARE_Y_AT_X_OP,
    EQUAL_POINTS_OP,
    EQUAL_CURVES_OP,
    COMPARE_Y_AT_X_LEFT_OP,
    COMPARE_Y_AT_X_RIGHT_OP,
    MAKE_X_MONOTONE_OP,
    SPLIT_OP,
    INTERSECT_OP,
    ARE_MERGEABLE_OP,
    MERGE_OP,
    CONSTRUCT_OPPOSITE_OP,
    COMPARE_ENDPOINTS_XY_OP,

    PARAMETER_SPACE_IN_X_CURVE_END_OP,
    PARAMETER_SPACE_IN_X_POINT_OP,
    PARAMETER_SPACE_IN_X_CURVE_OP,
    COMPARE_Y_NEAR_BOUNDARY_OP,
    COMPARE_Y_ON_BOUNDARY_OP,
    IS_ON_X_IDENTIFICATION_POINT_OP,
    IS_ON_X_IDENTIFICATION_CURVE_OP,

    PARAMETER_SPACE_IN_Y_CURVE_END_OP,
    PARAMETER_SPACE_IN_Y_POINT_OP,
    PARAMETER_SPACE_IN_Y_CURVE_OP,
    COMPARE_X_NEAR_BOUNDARY_POINT_CURVE_END_OP,
    COMPARE_X_NEAR_BOUNDARY_CURVE_ENDS_OP,
    COMPARE_X_ON_BOUNDARY_OP,
    IS_ON_Y_IDENTIFICATION_POINT_OP,
    IS_ON_Y_IDENTIFICATION_CURVE_OP,
    
    NUMBER_OF_OPERATIONS
  };

  typedef Base_traits                           Base;
  typedef Arr_counting_traits_2<Base>           Self;

  Arr_counting_traits_2() : Base()
  {
    clear_counters();
    increment();
  }

  Arr_counting_traits_2(Arr_counting_traits_2 & other) : Base(other)
  {
    clear_counters();
    increment();
  }
  
  unsigned int count(Operation_id id) const
  { return m_counters[id]; }

  unsigned int count_compare_x() const
  { return m_counters[COMPARE_X_OP]; }
  
  unsigned int count_compare_xy() const
  { return m_counters[COMPARE_XY_OP]; }

  unsigned int count_construct_min_vertex() const
  { return m_counters[CONSTRUCT_MIN_VERTEX_OP]; }
  
  unsigned int count_construct_max_vertex() const
  { return m_counters[CONSTRUCT_MAX_VERTEX_OP]; }

  unsigned int count_is_vertical() const
  { return m_counters[IS_VERTICAL_OP]; }
  
  unsigned int count_compare_y_at_x() const
  { return m_counters[COMPARE_Y_AT_X_OP]; }
  
  unsigned int count_equal_points() const
  { return m_counters[EQUAL_POINTS_OP]; }
  
  unsigned int count_equal_curves() const
  { return m_counters[EQUAL_CURVES_OP]; }
  
  unsigned int count_compare_y_at_x_left() const
  { return m_counters[COMPARE_Y_AT_X_LEFT_OP]; }
  
  unsigned int count_compare_y_at_x_right() const
  { return m_counters[COMPARE_Y_AT_X_RIGHT_OP]; }
  
  unsigned int count_make_x_monotone() const
  { return m_counters[MAKE_X_MONOTONE_OP]; }
  
  unsigned int count_split() const
  { return m_counters[SPLIT_OP]; }
  
  unsigned int count_intersect() const
  { return m_counters[INTERSECT_OP]; }
  
  unsigned int count_are_mergeable() const
  { return m_counters[ARE_MERGEABLE_OP]; }
  
  unsigned int count_merge() const
  { return m_counters[MERGE_OP]; }
  
  unsigned int count_construct_opposite() const
  { return m_counters[CONSTRUCT_OPPOSITE_OP]; }
  
  unsigned int count_compare_endpoints_xy() const
  { return m_counters[COMPARE_ENDPOINTS_XY_OP]; }

  // left-right
  
  unsigned int count_parameter_space_in_x_curve_end() const
  { return m_counters[PARAMETER_SPACE_IN_X_CURVE_END_OP]; }

  unsigned int count_parameter_space_in_x_curve() const
  { return m_counters[PARAMETER_SPACE_IN_X_CURVE_OP]; }

  unsigned int count_parameter_space_in_x_point() const
  { return m_counters[PARAMETER_SPACE_IN_X_POINT_OP]; }
  
  unsigned int count_compare_y_near_boundary() const
  { return m_counters[COMPARE_Y_NEAR_BOUNDARY_OP]; }

    unsigned int count_compare_y_on_boundary() const
  { return m_counters[COMPARE_Y_ON_BOUNDARY_OP]; }

  // bottom-top

  unsigned int count_parameter_space_in_y_curve_end() const
  { return m_counters[PARAMETER_SPACE_IN_Y_CURVE_END_OP]; }

  unsigned int count_parameter_space_in_y_curve() const
  { return m_counters[PARAMETER_SPACE_IN_Y_CURVE_OP]; }

  unsigned int count_parameter_space_in_y_point() const
  { return m_counters[PARAMETER_SPACE_IN_Y_POINT_OP]; }

  unsigned int count_compare_x_near_boundary_point_curve_end() const
  { return m_counters[COMPARE_X_NEAR_BOUNDARY_POINT_CURVE_END_OP]; }

  unsigned int count_compare_x_near_boundary_curve_ends() const
  { return m_counters[COMPARE_X_NEAR_BOUNDARY_CURVE_ENDS_OP]; }
  
  unsigned int count_compare_x_on_boundary() const
  { return m_counters[COMPARE_X_ON_BOUNDARY_OP]; }



  // Traits types:
  typedef typename Base::Has_left_category      Has_left_category;
  typedef typename Base::Has_merge_category     Has_merge_category;

  typedef typename CGALi::Arr_complete_left_side_tag< Base >::Tag
                                                Arr_left_side_tag;
  typedef typename CGALi::Arr_complete_bottom_side_tag< Base >::Tag
                                                Arr_bottom_side_tag;
  typedef typename CGALi::Arr_complete_top_side_tag< Base >::Tag
                                                Arr_top_side_tag;
  typedef typename CGALi::Arr_complete_right_side_tag< Base >::Tag
                                                Arr_right_side_tag;
  
  typedef typename Base::Point_2                Point_2;
  typedef typename Base::X_monotone_curve_2     X_monotone_curve_2;
  typedef typename Base::Curve_2                Curve_2;

  class Compare_x_2 {
  private:
    typename Base::Compare_x_2 m_object;
    unsigned int & m_counter;

  public:
    Compare_x_2(const Base * base, unsigned int & counter) :
      m_object(base->compare_x_2_object()), m_counter(counter) {}

    Comparison_result operator()(const Point_2 & p1, const Point_2 & p2) const
    { ++m_counter; return m_object(p1, p2); }
  };

  class Compare_xy_2 {
  private:
    typename Base::Compare_xy_2 m_object;
    mutable unsigned int & m_counter;

  public:
    Compare_xy_2(const Base * base, unsigned int & counter) :
      m_object(base->compare_xy_2_object()), m_counter(counter) {}

    Comparison_result operator()(const Point_2 & p1, const Point_2 & p2) const
    { ++m_counter; return m_object(p1, p2); }
  };

  class Construct_min_vertex_2 {
  private:
    typename Base::Construct_min_vertex_2 m_object;
    unsigned int & m_counter;

  public:
    Construct_min_vertex_2(const Base * base, unsigned int & counter) :
      m_object(base->construct_min_vertex_2_object()), m_counter(counter) {}

    const Point_2 operator()(const X_monotone_curve_2 & xc) const
    { ++m_counter; return m_object(xc); }
  };

  class Construct_max_vertex_2 {
  private:
    typename Base::Construct_max_vertex_2 m_object;
    unsigned int & m_counter;

  public:
    Construct_max_vertex_2(const Base * base, unsigned int & counter) :
      m_object(base->construct_max_vertex_2_object()), m_counter(counter) {}

    const Point_2 operator()(const X_monotone_curve_2 & xc) const
    { ++m_counter; return m_object(xc); }
  };
  
  class Is_vertical_2 {
  private:
    typename Base::Is_vertical_2 m_object;
    unsigned int & m_counter;

  public:
    Is_vertical_2(const Base * base, unsigned int & counter) :
      m_object(base->is_vertical_2_object()), m_counter(counter) {}

    bool operator()(const X_monotone_curve_2 & xc) const
    { ++m_counter; return m_object(xc); }
  };
  
  class Compare_y_at_x_2 {
  private:
    typename Base::Compare_y_at_x_2 m_object;
    unsigned int & m_counter;

  public:
    Compare_y_at_x_2(const Base * base, unsigned int & counter) :
      m_object(base->compare_y_at_x_2_object()), m_counter(counter) {}

    Comparison_result operator()(const Point_2 & p,
                                 const X_monotone_curve_2 & xc) const
    { ++m_counter; return m_object(p, xc); }
  };
  
  class Equal_2 {
  private:
    typename Base::Equal_2 m_object;
    unsigned int & m_counter1;
    unsigned int & m_counter2;

  public:
    Equal_2(const Base * base,
            unsigned int & counter1, unsigned int & counter2) :
      m_object(base->equal_2_object()),
      m_counter1(counter1), m_counter2(counter2)
    {}

    bool operator()(const X_monotone_curve_2 & xc1,
                    const X_monotone_curve_2 & xc2) const
    { ++m_counter1; return m_object(xc1, xc2); }

    bool operator()(const Point_2 & p1, const Point_2 & p2) const
    { ++m_counter2; return m_object(p1, p2); }    
  };

  class Compare_y_at_x_left_2 {
  private:
    typename Base::Compare_y_at_x_left_2 m_object;
    unsigned int & m_counter;

  public:
    Compare_y_at_x_left_2(const Base * base, unsigned int & counter) :
      m_object(base->compare_y_at_x_left_2_object()), m_counter(counter) {}

    Comparison_result operator()(const X_monotone_curve_2 & xc1,
                                 const X_monotone_curve_2 & xc2,
                                 const Point_2 & p) const
    { ++m_counter; return m_object(xc1, xc2, p); }
  };

  class Compare_y_at_x_right_2 {
  private:
    typename Base::Compare_y_at_x_right_2 m_object;
    unsigned int & m_counter;

  public:
    Compare_y_at_x_right_2(const Base * base, unsigned int & counter) :
      m_object(base->compare_y_at_x_right_2_object()), m_counter(counter) {}

    Comparison_result operator()(const X_monotone_curve_2 & xc1,
                                 const X_monotone_curve_2 & xc2,
                                 const Point_2 & p) const
    { ++m_counter; return m_object(xc1, xc2, p); }
  };
  
  class Make_x_monotone_2 {
  private:
    typename Base::Make_x_monotone_2 m_object;
    unsigned int & m_counter;

  public:
    Make_x_monotone_2(const Base * base, unsigned int & counter) :
      m_object(base->make_x_monotone_2_object()), m_counter(counter) {}

    template<class OutputIterator>
    OutputIterator operator()(const Curve_2 & cv, OutputIterator oi) const
    { ++m_counter; return m_object(cv, oi); }
  };

  class Split_2 {
  private:
    typename Base::Split_2 m_object;
    unsigned int & m_counter;

  public:
    Split_2(const Base * base, unsigned int & counter) :
      m_object(base->split_2_object()), m_counter(counter) {}

    void operator()(const X_monotone_curve_2 & xc, const Point_2 & p,
                    X_monotone_curve_2 & xc1, X_monotone_curve_2 & xc2) const
    { ++m_counter; m_object(xc, p, xc1, xc2); }
  };

  class Intersect_2 {
  private:
    typename Base::Intersect_2 m_object;
    unsigned int & m_counter;

  public:
    Intersect_2(const Base * base, unsigned int & counter) :
      m_object(base->intersect_2_object()), m_counter(counter) {}

    template<class OutputIterator>
    OutputIterator operator()(const X_monotone_curve_2 & xc1,
                              const X_monotone_curve_2 & xc2,
                              OutputIterator oi) const
    { ++m_counter; return m_object(xc1, xc2, oi); }
  };

  class Are_mergeable_2 {
  private:
    typename Base::Are_mergeable_2 m_object;
    unsigned int & m_counter;

  public:
    Are_mergeable_2(const Base * base, unsigned int & counter) :
      m_object(base->are_mergeable_2_object()), m_counter(counter) {}

    bool operator()(const X_monotone_curve_2 & xc1,
                    const X_monotone_curve_2 & xc2) const
    { ++m_counter; return m_object(xc1, xc2); }
  };

  class Merge_2 {
  private:
    typename Base::Merge_2 m_object;
    unsigned int & m_counter;

  public:
    Merge_2(const Base * base, unsigned int & counter) :
      m_object(base->merge_2_object()), m_counter(counter) {}

    void operator()(const X_monotone_curve_2 & xc1,
                    const X_monotone_curve_2 & xc2,
                    X_monotone_curve_2 & xc) const
    { ++m_counter; m_object(xc1, xc2, xc); }
  };

  class Construct_opposite_2 {
  private:
    typename Base::Construct_opposite_2 m_object;
    unsigned int & m_counter;

  public:
    Construct_opposite_2(const Base * base, unsigned int & counter) :
      m_object(base->construct_opposite_2_object()), m_counter(counter) {}

    X_monotone_curve_2 operator()(const X_monotone_curve_2 & xc)
    { ++m_counter; return m_object(xc); }
  };

  class Compare_endpoints_xy_2 {
  private:
    typename Base::Compare_endpoints_xy_2 m_object;
    unsigned int & m_counter;

  public:
    Compare_endpoints_xy_2(const Base * base, unsigned int & counter) :
      m_object(base->compare_endpoints_xy_2_object()), m_counter(counter) {}

    Comparison_result operator()(const X_monotone_curve_2 & xc)
    { ++m_counter; return m_object(xc); }
  };

  // left-right

  class Parameter_space_in_x_2 {
  private:
    typename Base::Parameter_space_in_x_2 m_object;
    mutable unsigned int & m_counter1;
    mutable unsigned int & m_counter2;
    mutable unsigned int & m_counter3;

  public:
    Parameter_space_in_x_2(const Base * base, 
                           unsigned int & counter1,
                           unsigned int & counter2,
                           unsigned int & counter3) :
      m_object(base->parameter_space_in_x_2_object()), 
      m_counter1(counter1),
      m_counter2(counter2),
      m_counter3(counter3) {}

    Arr_parameter_space operator()(const X_monotone_curve_2 & xc,
                             Arr_curve_end ce) const
    { ++m_counter1; return m_object(xc, ce); }


    Arr_parameter_space operator()(const Point_2 & p) const
    { ++m_counter2; return m_object(p); }


    Arr_parameter_space operator()(const X_monotone_curve_2 & xc) const
    { ++m_counter3; return m_object(xc); }

  };

  class Compare_y_near_boundary_2 {
  private:
    typename Base::Compare_y_near_boundary_2 m_object;
    unsigned int & m_counter;

  public:
    Compare_y_near_boundary_2(const Base * base, unsigned int & counter) :
      m_object(base->compare_y_near_boundary_2_object()), m_counter(counter) {}

    Comparison_result operator()(const X_monotone_curve_2 & xc1,
                                 const X_monotone_curve_2 & xc2, 
                                 Arr_curve_end ce) const
    { ++m_counter; return m_object(xc1, xc2, ce); }
  };

  class Compare_y_on_boundary_2 {
  private:
    typename Base::Compare_y_on_boundary_2 m_object;
    unsigned int & m_counter;

  public:
    Compare_y_on_boundary_2(const Base * base, unsigned int & counter) :
      m_object(base->compare_y_on_boundary_2_object()),
      m_counter(counter)
    {}

    Comparison_result operator()(const Point_2 & p1,
                                 const Point_2 & p2) const
    { ++m_counter; return m_object(p1, p2); }
  };
  
  // TODO Is_on_x_identification_2
  
  // bottom-top


  class Parameter_space_in_y_2 {
  private:
    typename Base::Parameter_space_in_y_2 m_object;
    mutable unsigned int & m_counter1;
    mutable unsigned int & m_counter2;
    mutable unsigned int & m_counter3;

  public:
    Parameter_space_in_y_2(const Base * base, 
                           unsigned int & counter1,
                           unsigned int & counter2,
                           unsigned int & counter3) :
      m_object(base->parameter_space_in_y_2_object()), 
      m_counter1(counter1),
      m_counter2(counter2),
      m_counter3(counter3) {}

    Arr_parameter_space operator()(const X_monotone_curve_2 & xc,
                                   Arr_curve_end ce) const
    { ++m_counter1; return m_object(xc, ce); }

    Arr_parameter_space operator()(const Point_2 & p) const
    { ++m_counter2; return m_object(p); }

    Arr_parameter_space operator()(const X_monotone_curve_2 & xc) const
    { ++m_counter3; return m_object(xc); }
    
  };

  class Compare_x_near_boundary_2 {
  private:
    typename Base::Compare_x_near_boundary_2 m_object;
    unsigned int & m_counter1;
    unsigned int & m_counter2;

  public:
    Compare_x_near_boundary_2(const Base * base, 
                              unsigned int & counter1,
                              unsigned int & counter2) :
      m_object(base->compare_x_near_boundary_2_object()), 
      m_counter1(counter1),
      m_counter2(counter2) {}

    Comparison_result operator()(const Point_2 & p,
                                 const X_monotone_curve_2 & xc,
                                 Arr_curve_end ce) const
    { ++m_counter1; return m_object(p, xc, ce); }

    Comparison_result operator()(const X_monotone_curve_2 & xc1,
                                 Arr_curve_end ce1,
                                 const X_monotone_curve_2 & xc2,
                                 Arr_curve_end ce2) const
    { ++m_counter2; return m_object(xc1, ce1, xc2, ce2); }
  };


  class Compare_x_on_boundary_2 {
  private:
    typename Base::Compare_x_on_boundary_2 m_object;
    unsigned int & m_counter;

  public:
    Compare_x_on_boundary_2(const Base * base, unsigned int & counter) :
      m_object(base->compare_x_on_boundary_2_object()),
      m_counter(counter)
    {}

    Comparison_result operator()(const Point_2 & p1,
                                 const Point_2 & p2) const
    { ++m_counter; return m_object(p1, p2); }
  };

  
  // TODO Is_on_y_identification_2






  Compare_x_2 compare_x_2_object() const
  { return Compare_x_2(this, m_counters[COMPARE_X_OP]); }
  
  Compare_xy_2 compare_xy_2_object() const
  { return Compare_xy_2(this, m_counters[COMPARE_XY_OP]); }

  Construct_min_vertex_2 construct_min_vertex_2_object() const
  { return Construct_min_vertex_2(this, m_counters[CONSTRUCT_MIN_VERTEX_OP]); }

  Construct_max_vertex_2 construct_max_vertex_2_object() const
  { return Construct_max_vertex_2(this, m_counters[CONSTRUCT_MAX_VERTEX_OP]); }
  
  Is_vertical_2 is_vertical_2_object() const
  { return Is_vertical_2(this, m_counters[IS_VERTICAL_OP]); }
  
  Compare_y_at_x_2 compare_y_at_x_2_object() const
  { return Compare_y_at_x_2(this, m_counters[COMPARE_Y_AT_X_OP]); }
  
  Equal_2 equal_2_object() const
  {
    return Equal_2(this, m_counters[EQUAL_POINTS_OP],
                   m_counters[EQUAL_CURVES_OP]);
  }

  Compare_y_at_x_left_2 compare_y_at_x_left_2_object() const
  { return Compare_y_at_x_left_2(this, m_counters[COMPARE_Y_AT_X_LEFT_OP]); }

  Compare_y_at_x_right_2 compare_y_at_x_right_2_object() const
  { return Compare_y_at_x_right_2(this, m_counters[COMPARE_Y_AT_X_RIGHT_OP]); }
  
  Make_x_monotone_2 make_x_monotone_2_object() const
  { return Make_x_monotone_2(this, m_counters[MAKE_X_MONOTONE_OP]); }

  Split_2 split_2_object() const
  { return Split_2(this, m_counters[SPLIT_OP]); }

  Intersect_2 intersect_2_object() const
  { return Intersect_2(this, m_counters[INTERSECT_OP]); }

  Are_mergeable_2 are_mergeable_2_object() const
  { return Are_mergeable_2(this, m_counters[ARE_MERGEABLE_OP]); }

  Merge_2 merge_2_object() const
  { return Merge_2(this, m_counters[MERGE_OP]); }

  Construct_opposite_2 construct_opposite_2_object() const
  { return Construct_opposite_2(this, m_counters[CONSTRUCT_OPPOSITE_OP]); }

  Compare_endpoints_xy_2 compare_endpoints_xy_2_object() const
  { return Compare_endpoints_xy_2(this, m_counters[COMPARE_ENDPOINTS_XY_OP]); }

  // left-right
  Parameter_space_in_x_2 parameter_space_in_x_2_object() const
  { return Parameter_space_in_x_2(
        this, 
        m_counters[PARAMETER_SPACE_IN_X_CURVE_END_OP],
        m_counters[PARAMETER_SPACE_IN_X_POINT_OP],
        m_counters[PARAMETER_SPACE_IN_X_CURVE_OP]
    ); 
  }
  
  // bottom-top
  Parameter_space_in_y_2 parameter_space_in_y_2_object() const
  { return Parameter_space_in_y_2(
        this, 
        m_counters[PARAMETER_SPACE_IN_Y_CURVE_END_OP],
        m_counters[PARAMETER_SPACE_IN_Y_POINT_OP],
        m_counters[PARAMETER_SPACE_IN_Y_CURVE_OP]
    ); 
  }



  static unsigned int increment(bool doit = true)
  {
    static unsigned int counter = 0;
    if (doit) ++counter;
    return counter;
  }

  void clear_counters()
  { memset(m_counters, 0, sizeof(m_counters)); }

private:
  mutable unsigned int m_counters[NUMBER_OF_OPERATIONS];
};

template <class Out_stream, class Base_traits>
inline
Out_stream & operator<<(Out_stream & os,
                        const Arr_counting_traits_2<Base_traits> & traits)
{
  typedef Arr_counting_traits_2<Base_traits>            Traits;
  unsigned int sum = 0;
  unsigned int i;
  for (i = 0; i < Traits::NUMBER_OF_OPERATIONS; ++i)
    sum += traits.count(static_cast<typename Traits::Operation_id>(i));
  os << "# of COMPARE_X operation = "
     << traits.count_compare_x() << std::endl
     << "# of COMPARE_XY operation = "
     << traits.count_compare_xy() << std::endl
     << "# of CONSTRUCT_MIN_VERTEX operation = "
     << traits.count_construct_min_vertex() << std::endl
     << "# of CONSTRUCT_MAX_VERTEX operation = "
     << traits.count_construct_max_vertex() << std::endl
     << "# of IS_VERTICAL operation = "
     << traits.count_is_vertical() << std::endl
     << "# of COMPARE_Y_AT_X operation = "
     << traits.count_compare_y_at_x() << std::endl
     << "# of EQUAL_POINTS operation = "
     << traits.count_equal_points() << std::endl
     << "# of EQUAL_CURVES operation = "
     << traits.count_equal_curves() << std::endl
     << "# of COMPARE_Y_AT_X_LEFT operation = "
     << traits.count_compare_y_at_x_left() << std::endl
     << "# of COMPARE_Y_AT_X_RIGHT operation = "
     << traits.count_compare_y_at_x_right() << std::endl
     << "# of MAKE_X_MONOTONE operation = "
     << traits.count_make_x_monotone() << std::endl
     << "# of SPLIT operation = "
     << traits.count_split() << std::endl
     << "# of INTERSECT operation = "
     << traits.count_intersect() << std::endl
     << "# of ARE_MERGEABLE operation = "
     << traits.count_are_mergeable() << std::endl
     << "# of MERGE operation = "
     << traits.count_merge() << std::endl
     << "# of CONSTRUCT_OPPOSITE operation = "
     << traits.count_construct_opposite() << std::endl
     << "# of COMPARE_ENDPOINTS_XY operation = "
     << traits.count_compare_endpoints_xy() << std::endl
    // left-right
     << "# of PARAMETER_SPACE_IN_X curve-end operation = "
     << traits.count_parameter_space_in_x_curve_end() << std::endl
     << "# of PARAMETER_SPACE_IN_X point operation = "
     << traits.count_parameter_space_in_x_point() << std::endl
     << "# of PARAMETER_SPACE_IN_X curve operation = "
     << traits.count_parameter_space_in_x_curve() << std::endl
     << "# of COMPARE_Y_NEAR_BOUNDARY operation = "
     << traits.count_compare_y_near_boundary() << std::endl
     << "# of COMPARE_Y_ON_BOUNDARY operation = "
     << traits.count_compare_y_on_boundary() << std::endl
    // bottom-top
     << "# of PARAMETER_SPACE_IN_Y curve-end operation = "
     << traits.count_parameter_space_in_y_curve_end() << std::endl
     << "# of PARAMETER_SPACE_IN_Y point operation = "
     << traits.count_parameter_space_in_y_point() << std::endl
     << "# of PARAMETER_SPACE_IN_Y curve operation = "
     << traits.count_parameter_space_in_y_curve() << std::endl
     << "# of COMPARE_X_NEAR_BOUNDARY point/curve-end operation = "
     << traits.count_compare_x_near_boundary_point_curve_end() << std::endl
     << "# of COMPARE_X_NEAR_BOUNDARY curve-ends operation = "
     << traits.count_compare_x_near_boundary_curve_ends() << std::endl
     << "# of COMPARE_X_ON_BOUNDARY operation = "
     << traits.count_compare_x_on_boundary() << std::endl

     << "total # = " << sum << std::endl
     << "# of traits constructed = " << Traits::increment(false)
     << std::endl;
  return os;
}

CGAL_END_NAMESPACE

#endif