filtered_rational_traits.h

很多二维 三维几何计算算法 C++ 类库

// Copyright (c) 2005  Stanford University (USA).
// All rights reserved.
//
// This file is part of CGAL (www.cgal.org); you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; version 2.1 of the License.
// See the file LICENSE.LGPL 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.3-branch/Kinetic_data_structures/include/CGAL/Polynomial/internal/Filtered_rational/Filtered_rational_traits.h $
// $Id: Filtered_rational_traits.h 28567 2006-02-16 14:30:13Z lsaboret $
// 
//
// Author(s)     : Daniel Russel <[e-mail]>

#ifndef CGAL_POLYNOMIAL_INTERNAL_FILTERED_RATIONAL_TRAITS_H
#define CGAL_POLYNOMIAL_INTERNAL_FILTERED_RATIONAL_TRAITS_H
#include <CGAL/Polynomial/basic.h>

#include <CGAL/Polynomial/internal/Filtered_function.h>
#include <CGAL/Polynomial/internal/Rational/Rational_traits_base.h>

#include <CGAL/Polynomial/internal/Filtered_rational/Construct_filtered_function.h>
#include <CGAL/Polynomial/internal/Filtered_rational/Filtered_are_negations.h>
#include <CGAL/Polynomial/internal/Filtered_rational/Filtered_sign_at_rational.h>
#include <CGAL/Polynomial/internal/Filtered_rational/Filtered_root_bound_evaluator.h>
#include <CGAL/Polynomial/internal/Filtered_rational/Filtered_rational_multiplicity.h>
#include <CGAL/Polynomial/internal/Rational/Sign_above_rational.h>
#include <CGAL/Polynomial/internal/Rational/Sign_below_rational.h>

#define CGAL_DF_UNARY_CONSTRUCTION(UCName, lcname) class UCName {\
    typedef typename Exact_traits::UCName ED;\
    typedef typename Interval_traits::UCName ID;\
    typedef Filtered_function_node_unary_transform< Filtering_traits, ED, ID> Node;\
    public:\
        UCName(const This &k): ed_(k.exact_traits_object().lcname##_object()),\
        id_(k.interval_traits_object().lcname##_object()){} \
        typedef Function result_type;\
        typedef result_type argument_type;\
        result_type operator()(const argument_type &f) const \
        { \
            return result_type(new Node(f.tree(), ed_, id_));\
        }\
        protected:\
            ED ed_;\
            ID id_;\
        };\
        UCName lcname##_object() const \
        { \
            return UCName(*this);\
        }

// std::cout << "UCName of " << f << std::endl;

#define CGAL_DF_UNARY_CONSTRUCTION_DATA(UCName, lcname, data_type) class UCName {\
    typedef typename Exact_traits::UCName ED;\
    typedef typename Interval_traits::UCName ID;\
    typedef Filtered_function_node_unary_transform< Filtering_traits, ED, ID> Node;\
    public:\
        UCName(const typename ED::NT& d, const This &k): ed_(k.exact_traits_object().lcname##_object(d)),\
        id_(k.interval_traits_object().lcname##_object(CGAL_POLYNOMIAL_NS::To_interval<typename ED::NT>()(d))){} \
        UCName(double d, const This &k): ed_(k.exact_traits_object().lcname##_object(typename ED::NT(d))),\
        id_(k.interval_traits_object().lcname##_object(CGAL_POLYNOMIAL_NS::To_interval<double>()(d))){} \
        UCName(int d, const This &k): ed_(k.exact_traits_object().lcname##_object(d)),\
        id_(k.interval_traits_object().lcname##_object(d)){} \
        typedef Function result_type;\
        typedef result_type argument_type;\
        result_type operator()(const argument_type &f) const \
        { \
            return result_type(new Node(f.tree(), ed_, id_));\
        }\
        protected:\
            ED ed_;\
            ID id_;\
        };\
        UCName lcname##_object(data_type d) const \
        { \
            return UCName(d, *this);\
        }

//std::cout << "UCName of " << f << std::endl;

#define CGAL_DF_UNARY_CONSTRUCTION_DATA_2(UCName, lcname, data_type) class UCName {\
    typedef typename Exact_traits::UCName ED;\
    typedef typename Interval_traits::UCName ID;\
    typedef Filtered_function_node_unary_transform< Filtering_traits, ED, ID> Node;\
    public:\
        UCName(const typename ED::NT& a, const typename ED::NT& b, const This &k): ed_(k.exact_traits_object().lcname##_object(a,b)),\
        id_(k.interval_traits_object().lcname##_object(CGAL_POLYNOMIAL_NS::To_interval<typename ED::NT>()(a,b))){} \
        typedef Function result_type;\
        typedef result_type argument_type;\
        result_type operator()(const argument_type &f) const \
        { \
            return result_type(new Node(f.tree(), ed_, id_));\
        }\
        protected:\
            ED ed_;\
            ID id_;\
        };\
        UCName lcname##_object(data_type a, data_type b) const \
        { \
            return UCName(a, b, *this);\
        }

#define CGAL_DF_BINARY_CONSTRUCTION(UCName, lcname) class UCName {\
    typedef typename Exact_traits::UCName ED;\
    typedef typename Interval_traits::UCName ID;\
    typedef Filtered_function_node_binary_transform< Filtering_traits, ED, ID> Node;\
    public:\
        UCName(const This &k): ed_(k.exact_traits_object().lcname##_object()),\
        id_(k.interval_traits_object().lcname##_object()){} \
        typedef Function result_type;\
        typedef result_type first_argument_type;\
        typedef result_type second_argument_type;\
        result_type operator()(const first_argument_type &f, const second_argument_type &fp) const \
        { \
            return result_type(new Node(f.tree(), fp.tree(), ed_, id_));\
        }\
        protected:\
            ED ed_;\
            ID id_;\
        };\
        UCName lcname##_object() const \
        { \
            return UCName(*this);\
        }

//std::cout << "UCName of " << f << " and " << fp << std::endl;

                                CGAL_POLYNOMIAL_BEGIN_INTERNAL_NAMESPACE

                                template <class Filter_traits_t, template<class Fn> class Rational_traits = internal::Rational_traits_base>
                                class Filtered_rational_traits
                                {
                                    typedef Filtered_rational_traits<Filter_traits_t> This;
                                    public:
                                        typedef Filter_traits_t Filtering_traits;
                                        typedef Filtered_function<Filtering_traits> Function;
                                        typedef typename Filtering_traits::Exact_to_interval_converter Exact_to_interval_converter;
                                        typedef typename Function::NT NT;

                                        typedef Rational_traits<typename Filtering_traits::Exact_function> Exact_traits;
                                        typedef Rational_traits<typename Filtering_traits::Interval_function> Interval_traits;

                                        Filtered_rational_traits(){}

                                        CGAL_DF_UNARY_CONSTRUCTION(Differentiate, differentiate);