filtered_rational_traits.h

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

                                        CGAL_DF_UNARY_CONSTRUCTION(Invert_variable, invert_variable);

                                        CGAL_DF_UNARY_CONSTRUCTION_DATA(Rational_translate_zero, rational_translate_zero, NT);

                                        CGAL_DF_UNARY_CONSTRUCTION_DATA(Shift_power, shift_power, int);

                                        CGAL_DF_UNARY_CONSTRUCTION(Negate_variable, negate_variable);

                                        CGAL_DF_BINARY_CONSTRUCTION(Quotient, quotient);

                                        CGAL_DF_BINARY_CONSTRUCTION(Remainder, remainder);

                                        CGAL_DF_BINARY_CONSTRUCTION(Pseudo_quotient, pseudo_quotient);

                                        CGAL_DF_BINARY_CONSTRUCTION(Pseudo_remainder, pseudo_remainder);

                                        CGAL_DF_BINARY_CONSTRUCTION(Quotient_remainder, quotient_remainder);

                                        CGAL_DF_UNARY_CONSTRUCTION_DATA_2(Map_rational_interval_to_positive_2, map_rational_interval_to_positive_2, NT);

                                        class Standard_sequence
                                        {
                                            public:
                                                Standard_sequence(const Function& d, const This &k):
                                                ss_(k.exact_traits_object().standard_sequence_object(d.exact_function())){}
                                                Standard_sequence(){}
                                                typedef unsigned int result_type;
                                                typedef NT argument_type;

                                                template<class T>
                                                    unsigned int
                                                    number_of_real_roots(const T& a, const T& b) const
                                                {
                                                    return ss_.number_of_real_roots_base(a, b);
                                                }
                                            protected:
                                                typename Exact_traits::Standard_sequence ss_;
                                        };
                                        Standard_sequence standard_sequence_object(Function d) const
                                        {
                                            return Standard_sequence(d, *this);
                                        }

                                        class Sturm_sequence: public Exact_traits::Sturm_sequence
                                        {
                                            public:
                                                Sturm_sequence(const Function& a, const Function& b, const This &k):
                                                Exact_traits::Sturm_sequence(k.exact_traits_object().Sturm_sequence_object(a.exact_function(),
                                                    b.exact_function())){}
                                                Sturm_sequence(){}
                                        };
                                        Sturm_sequence Sturm_sequence_object(const Function &a, const Function &b) const
                                        {
//std::cout << "Stur of " << a << " and " << b << std::endl;
                                            return Sturm_sequence(a,b, *this);
                                        }

                                        typedef Filtered_root_bound_evaluator<This> Root_bound;
                                        Root_bound root_bound_object(bool pow_of_2=false) const
                                        {
                                            return Root_bound(pow_of_2, *this);
                                        }

                                        typedef internal::Sign_above_rational<This> Sign_above;
                                        Sign_above sign_above_object(const Function &f) const
                                        {
//std::cout << "Sign above of " << f << std::endl;
                                            return Sign_above(f, *this);
                                        }

                                        typedef internal::Sign_below_rational<This> Sign_below;
                                        Sign_below sign_below_object(const Function &f) const
                                        {
//std::cout << "Sign below of " << f << std::endl;
                                            return Sign_below(f, *this);
                                        }

                                        typedef Filtered_sign_at_rational<Function> Sign_at;
                                        Sign_at sign_at_object(const Function &f) const
                                        {
//std::cout << "Sign at of " << f << std::endl;
                                            return Sign_at(f);
                                        }

                                        typedef Filtered_are_negations<Function> Are_negations;
                                        Are_negations are_negations_object() const
                                        {
                                            return Are_negations();
                                        }

                                        typedef Filtered_rational_multiplicity<This> Multiplicity;
                                        Multiplicity multiplicity_object(const Function &f) const
                                        {
//std::cout << "Multiplicity of " << f << std::endl;
                                            return Multiplicity(f, *this);
                                        }

                                        const Exact_traits &exact_traits_object() const
                                        {
                                            return et_;
                                        }

                                        const Interval_traits &interval_traits_object() const
                                        {
                                            return it_;
                                        }

                                        const Exact_to_interval_converter exact_to_interval_converter_object() const
                                        {
                                            return efc_;
                                        }

                                        typedef internal::Construct_filtered_function<Function> Construct_function;
                                        Construct_function construct_function_object() const
                                        {
                                            return Construct_function(exact_to_interval_converter_object());
                                        }

                                        struct Compare_isolated_roots_in_interval
                                        {
                                            Compare_isolated_roots_in_interval(Function a, Function b, const This &k):
                                            pred_(k.exact_traits_object().compare_isolated_roots_in_interval_object(a.exact_function(), b.exact_function())) {
//std::cout << "Compare ir of " << a << " and " << b << std::endl;
                                            }

                                            typedef Comparison_result result_type;
                                            typedef NT first_argument_type;
                                            typedef NT second_argument_type;

                                            Comparison_result operator()(const NT &a, const NT &b) const
                                            {
                                                return pred_(a,b);
                                            }

                                            typename Exact_traits::Compare_isolated_roots_in_interval pred_;
                                        };

                                        Compare_isolated_roots_in_interval compare_isolated_roots_in_interval_object(Function a, Function b) const
                                        {
                                            return Compare_isolated_roots_in_interval(a,b, *this);
                                        }

                                    protected:
                                        Exact_traits et_;
                                        Interval_traits it_;
                                        Exact_to_interval_converter efc_;
                                };

                                CGAL_POLYNOMIAL_END_INTERNAL_NAMESPACE
//#undef DF_UNARY_CONSTUCTION
#endif