BWAPI
Classes | Namespaces | Defines | Functions
SPAR/AIModule/BWTA/vendors/CGAL/CGAL/Lazy_exact_nt.h File Reference
#include <CGAL/number_type_basic.h>
#include <boost/iterator/transform_iterator.hpp>
#include <boost/static_assert.hpp>
#include <boost/operators.hpp>
#include <CGAL/Interval_nt.h>
#include <CGAL/Handle.h>
#include <CGAL/NT_converter.h>
#include <CGAL/Profile_counter.h>
#include <CGAL/Lazy.h>
Include dependency graph for Lazy_exact_nt.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  Lazy_exact_nt_rep< ET >
struct  Lazy_exact_Int_Cst< ET >
struct  Lazy_exact_Cst< ET >
struct  Lazy_exact_Ex_Cst< ET >
class  Lazy_lazy_exact_Cst< ET, ET1 >
struct  Lazy_exact_unary< ET >
struct  Lazy_exact_binary< ET, ET1, ET2 >
struct  Lazy_exact_Min< ET >
struct  Lazy_exact_Max< ET >
class  Lazy_exact_nt< ET_ >
struct  INTERN_LAZY_EXACT_NT::Simplify_selector< NT, Functor >
struct  INTERN_LAZY_EXACT_NT::Simplify_selector< NT, Functor >::Simplify
struct  INTERN_LAZY_EXACT_NT::Simplify_selector< NT, Null_functor >
struct  INTERN_LAZY_EXACT_NT::Unit_part_selector< NT, Functor >
struct  INTERN_LAZY_EXACT_NT::Unit_part_selector< NT, Functor >::Unit_part
struct  INTERN_LAZY_EXACT_NT::Unit_part_selector< NT, Null_functor >
struct  INTERN_LAZY_EXACT_NT::Is_zero_selector< NT, Functor >
struct  INTERN_LAZY_EXACT_NT::Is_zero_selector< NT, Functor >::Is_zero
struct  INTERN_LAZY_EXACT_NT::Is_zero_selector< NT, Null_functor >
struct  INTERN_LAZY_EXACT_NT::Is_one_selector< NT, Functor >
struct  INTERN_LAZY_EXACT_NT::Is_one_selector< NT, Functor >::Is_one
struct  INTERN_LAZY_EXACT_NT::Is_one_selector< NT, Null_functor >
struct  INTERN_LAZY_EXACT_NT::Square_selector< NT, Functor >
struct  INTERN_LAZY_EXACT_NT::Square_selector< NT, Functor >::Square
struct  INTERN_LAZY_EXACT_NT::Square_selector< NT, Null_functor >
struct  INTERN_LAZY_EXACT_NT::Integral_division_selector< NT, Functor >
struct  INTERN_LAZY_EXACT_NT::Integral_division_selector< NT, Functor >::Integral_division
struct  INTERN_LAZY_EXACT_NT::Integral_division_selector< NT, Null_functor >
struct  INTERN_LAZY_EXACT_NT::Is_square_selector< NT, Functor >
struct  INTERN_LAZY_EXACT_NT::Is_square_selector< NT, Functor >::Is_square
struct  INTERN_LAZY_EXACT_NT::Is_square_selector< NT, Null_functor >
struct  INTERN_LAZY_EXACT_NT::Sqrt_selector< NT, AlgebraicStructureTag >
struct  INTERN_LAZY_EXACT_NT::Sqrt_selector< NT, AlgebraicStructureTag >::Sqrt
struct  INTERN_LAZY_EXACT_NT::Sqrt_selector< NT, Null_functor >
struct  INTERN_LAZY_EXACT_NT::Kth_root_selector< NT, Functor >
struct  INTERN_LAZY_EXACT_NT::Kth_root_selector< NT, Functor >::Kth_root
struct  INTERN_LAZY_EXACT_NT::Kth_root_selector< NT, Null_functor >
struct  INTERN_LAZY_EXACT_NT::Root_of_selector< NT, Functor >
struct  INTERN_LAZY_EXACT_NT::Root_of_selector< NT, Functor >::Cast
struct  INTERN_LAZY_EXACT_NT::Root_of_selector< NT, Functor >::Root_of
struct  INTERN_LAZY_EXACT_NT::Root_of_selector< NT, Null_functor >
struct  INTERN_LAZY_EXACT_NT::Gcd_selector< NT, Functor >
struct  INTERN_LAZY_EXACT_NT::Gcd_selector< NT, Functor >::Gcd
struct  INTERN_LAZY_EXACT_NT::Gcd_selector< NT, Null_functor >
struct  INTERN_LAZY_EXACT_NT::Div_selector< NT, Functor >
struct  INTERN_LAZY_EXACT_NT::Div_selector< NT, Functor >::Div
struct  INTERN_LAZY_EXACT_NT::Div_selector< NT, Null_functor >
struct  INTERN_LAZY_EXACT_NT::Mod_selector< NT, Functor >
struct  INTERN_LAZY_EXACT_NT::Mod_selector< NT, Functor >::Mod
struct  INTERN_LAZY_EXACT_NT::Mod_selector< NT, Null_functor >
struct  INTERN_LAZY_EXACT_NT::Div_mod_selector< NT, Functor >
struct  INTERN_LAZY_EXACT_NT::Div_mod_selector< NT, Functor >::Div_mod
struct  INTERN_LAZY_EXACT_NT::Div_mod_selector< NT, Null_functor >
class  Algebraic_structure_traits< Lazy_exact_nt< ET > >
class  Real_embeddable_traits< Lazy_exact_nt< ET > >
class  Real_embeddable_traits< Lazy_exact_nt< ET > >::Abs
class  Real_embeddable_traits< Lazy_exact_nt< ET > >::Sgn
class  Real_embeddable_traits< Lazy_exact_nt< ET > >::Compare
class  Real_embeddable_traits< Lazy_exact_nt< ET > >::To_double
class  Real_embeddable_traits< Lazy_exact_nt< ET > >::To_interval
class  Real_embeddable_traits< Lazy_exact_nt< ET > >::Is_finite
class  Lazy_exact_nt_coercion_traits_base< ET1, ET2, F >
class  Lazy_exact_nt_coercion_traits_base< Lazy_exact_nt< ET1 >, Lazy_exact_nt< ET2 >, Tag_true >
class  Lazy_exact_nt_coercion_traits_base< Lazy_exact_nt< ET1 >, Lazy_exact_nt< ET2 >, Tag_true >::Cast
struct  Coercion_traits< Lazy_exact_nt< ET1 >, Lazy_exact_nt< ET2 > >
class  INTERN_LAZY_EXACT_NT::Fraction_traits_base< Lazy_exact_nt< ET >, CGAL::Tag_false >
class  INTERN_LAZY_EXACT_NT::Fraction_traits_base< Lazy_exact_nt< ET >, CGAL::Tag_true >
struct  INTERN_LAZY_EXACT_NT::Fraction_traits_base< Lazy_exact_nt< ET >, CGAL::Tag_true >::Common_factor
struct  INTERN_LAZY_EXACT_NT::Fraction_traits_base< Lazy_exact_nt< ET >, CGAL::Tag_true >::Compose
struct  INTERN_LAZY_EXACT_NT::Fraction_traits_base< Lazy_exact_nt< ET >, CGAL::Tag_true >::Decompose
class  Fraction_traits< Lazy_exact_nt< ET > >
struct  Min< Lazy_exact_nt< ET > >
struct  Max< Lazy_exact_nt< ET > >
class  Is_valid< Lazy_exact_nt< ET > >
struct  NT_converter< Lazy_exact_nt< ET >, ET >
struct  Lazy_exact_ro2< ET >
struct  Root_of_traits< Lazy_exact_nt< NT > >
struct  Root_of_traits< Lazy_exact_nt< NT > >::Make_root_of_2
class  INTERN_LAZY_EXACT_NT::Modular_traits_base< ET, Tag >
class  INTERN_LAZY_EXACT_NT::Modular_traits_base< ET, Tag_true >
struct  INTERN_LAZY_EXACT_NT::Modular_traits_base< ET, Tag_true >::Modular_image
struct  INTERN_LAZY_EXACT_NT::Modular_traits_base< ET, Tag_true >::Modular_image_representative
class  Modular_traits< Lazy_exact_nt< ET > >

Namespaces

namespace  INTERN_LAZY_EXACT_NT

Defines

#define CGAL_int(T)   typename First_if_different<int, T>::Type
#define CGAL_double(T)   typename First_if_different<double, T>::Type
#define CGAL_To_interval(T)   To_interval<T>
#define CGAL_LAZY_UNARY_OP(OP, NAME)
#define CGAL_LAZY_BINARY_OP(OP, NAME)
#define CGAL_COERCION_TRAITS_LAZY_EXACT(NTX)

Functions

template<typename ET1 , typename ET2 >
bool operator< (const Lazy_exact_nt< ET1 > &a, const Lazy_exact_nt< ET2 > &b)
template<typename ET1 , typename ET2 >
bool operator== (const Lazy_exact_nt< ET1 > &a, const Lazy_exact_nt< ET2 > &b)
template<typename ET1 , typename ET2 >
bool operator> (const Lazy_exact_nt< ET1 > &a, const Lazy_exact_nt< ET2 > &b)
template<typename ET1 , typename ET2 >
bool operator>= (const Lazy_exact_nt< ET1 > &a, const Lazy_exact_nt< ET2 > &b)
template<typename ET1 , typename ET2 >
bool operator<= (const Lazy_exact_nt< ET1 > &a, const Lazy_exact_nt< ET2 > &b)
template<typename ET1 , typename ET2 >
bool operator!= (const Lazy_exact_nt< ET1 > &a, const Lazy_exact_nt< ET2 > &b)
template<typename ET >
Lazy_exact_nt< ET > operator% (const Lazy_exact_nt< ET > &a, const Lazy_exact_nt< ET > &b)
template<typename ET >
bool operator< (const Lazy_exact_nt< ET > &a, int b)
template<typename ET >
bool operator> (const Lazy_exact_nt< ET > &a, int b)
template<typename ET >
bool operator== (const Lazy_exact_nt< ET > &a, int b)
template<typename ET >
bool operator< (const Lazy_exact_nt< ET > &a, double b)
template<typename ET >
bool operator> (const Lazy_exact_nt< ET > &a, double b)
template<typename ET >
bool operator== (const Lazy_exact_nt< ET > &a, double b)
template<typename ET1 , typename ET2 >
Lazy_exact_nt< typename
Coercion_traits< ET1, ET2 >
::Type > 		operator+ (const Lazy_exact_nt< ET1 > &a, const Lazy_exact_nt< ET2 > &b)
template<typename ET1 , typename ET2 >
Lazy_exact_nt< typename
Coercion_traits< ET1, ET2 >
::Type > 		operator- (const Lazy_exact_nt< ET1 > &a, const Lazy_exact_nt< ET2 > &b)
template<typename ET1 , typename ET2 >
Lazy_exact_nt< typename
Coercion_traits< ET1, ET2 >
::Type > 		operator* (const Lazy_exact_nt< ET1 > &a, const Lazy_exact_nt< ET2 > &b)
template<typename ET1 , typename ET2 >
Lazy_exact_nt< typename
Coercion_traits< ET1, ET2 >
::Type > 		operator/ (const Lazy_exact_nt< ET1 > &a, const Lazy_exact_nt< ET2 > &b)
 CGAL_COERCION_TRAITS_LAZY_EXACT (int)
 CGAL_COERCION_TRAITS_LAZY_EXACT (short)
 CGAL_COERCION_TRAITS_LAZY_EXACT (double)
 CGAL_COERCION_TRAITS_LAZY_EXACT (float)
template<typename ET >
Lazy_exact_nt< ET > min BOOST_PREVENT_MACRO_SUBSTITUTION (const Lazy_exact_nt< ET > &x, const Lazy_exact_nt< ET > &y)
template<typename ET >
std::ostream & operator<< (std::ostream &os, const Lazy_exact_nt< ET > &a)
template<typename ET >
std::istream & operator>> (std::istream &is, Lazy_exact_nt< ET > &a)
template<typename ET >
bool fit_in_double (const Lazy_exact_nt< ET > &l, double &r)
template<typename RT >
CGAL::Root_of_traits
< CGAL::Lazy_exact_nt< RT >
>::RootOf_2 		make_sqrt (const CGAL::Lazy_exact_nt< RT > &r)
template<typename RT >
void print (std::ostream &os, const CGAL::Lazy_exact_nt< Root_of_2< RT > > &r)

Define Documentation

#define CGAL_COERCION_TRAITS_LAZY_EXACT (   NTX)
Value:
template<class ET>                                                  \
    struct Coercion_traits< NTX, Lazy_exact_nt<ET> >{                   \
    private:                                                            \
        typedef Coercion_traits<NTX,ET> CT;                             \
        typedef Lazy_exact_nt<ET> NT;                                   \
    public:                                                             \
        typedef typename CT::Are_explicit_interoperable                 \
        Are_explicit_interoperable;                                     \
        typedef typename CT::Are_implicit_interoperable                 \
        Are_implicit_interoperable;                                     \
    private:                                                            \
        static const  bool interoperable                                \
        =boost::is_same< Are_implicit_interoperable, Tag_false>::value; \
    public:                                                             \
        typedef typename boost::mpl::if_c <interoperable,Null_tag,NT>   \
        ::type  Type;                                          \
        typedef typename boost::mpl::if_c <interoperable, Null_functor, \
    INTERN_CT::Cast_from_to<NTX,NT> >::type Cast;                       \
    };                                                                  \
                                                                        \
    template<class ET>                                                  \
    struct Coercion_traits< Lazy_exact_nt<ET>, NTX >                    \
        :public Coercion_traits<NTX, Lazy_exact_nt<ET> >{};             \
#define CGAL_double (   T)    typename First_if_different<double, T>::Type
#define CGAL_int (   T)    typename First_if_different<int, T>::Type
#define CGAL_LAZY_BINARY_OP (   OP,
  NAME 
)
Value:
template <typename ET, typename ET1 = ET, typename ET2 = ET>             \
struct NAME : public Lazy_exact_binary<ET, ET1, ET2>                     \
{                                                                        \
  typedef typename Lazy_exact_binary<ET,ET1,ET2>::AT::Protector P;       \
  NAME (const Lazy_exact_nt<ET1> &a, const Lazy_exact_nt<ET2> &b)        \
    : Lazy_exact_binary<ET, ET1, ET2>((P(), a.approx() OP b.approx()), a, b) {} \
                                                                         \
  void update_exact()                                                    \
  {                                                                      \
    this->et = new ET(this->op1.exact() OP this->op2.exact());           \
    if (!this->approx().is_point())                                      \
      this->approx() = CGAL_NTS to_interval(*(this->et));                \
    this->prune_dag();                                                   \
   }                                                                     \
};
#define CGAL_LAZY_UNARY_OP (   OP,
  NAME 
)
Value:
template <typename ET>                                                   \
struct NAME : public Lazy_exact_unary<ET>                                \
{                                                                        \
  typedef typename Lazy_exact_unary<ET>::AT::Protector P;                \
  NAME (const Lazy_exact_nt<ET> &a)                                      \
      : Lazy_exact_unary<ET>((P(), OP(a.approx())), a) {}                \
                                                                         \
  void update_exact()                                                    \
  {                                                                      \
    this->et = new ET(OP(this->op1.exact()));                            \
    if (!this->approx().is_point())                                      \
      this->approx() = CGAL_NTS to_interval(*(this->et));                \
    this->prune_dag();                                                   \
   }                                                                     \
};
#define CGAL_To_interval (   T)    To_interval<T>

Function Documentation

template<typename ET >
Lazy_exact_nt< ET > max BOOST_PREVENT_MACRO_SUBSTITUTION ( const Lazy_exact_nt< ET > &  x,
const Lazy_exact_nt< ET > &  y 
) [inline]
CGAL_COERCION_TRAITS_LAZY_EXACT ( int  )
CGAL_COERCION_TRAITS_LAZY_EXACT ( short  )
CGAL_COERCION_TRAITS_LAZY_EXACT ( double  )
CGAL_COERCION_TRAITS_LAZY_EXACT ( float  )
template<typename ET >
bool fit_in_double ( const Lazy_exact_nt< ET > &  l,
double &  r 
) [inline]

Here is the call graph for this function:

template<typename RT >
CGAL::Root_of_traits<CGAL::Lazy_exact_nt<RT> >::RootOf_2 make_sqrt ( const CGAL::Lazy_exact_nt< RT > &  r)

Here is the call graph for this function:

template<typename ET1 , typename ET2 >
bool operator!= ( const Lazy_exact_nt< ET1 > &  a,
const Lazy_exact_nt< ET2 > &  b 
) [inline]
template<typename ET >
Lazy_exact_nt<ET> operator% ( const Lazy_exact_nt< ET > &  a,
const Lazy_exact_nt< ET > &  b 
) [inline]
template<typename ET1 , typename ET2 >
Lazy_exact_nt< typename Coercion_traits<ET1, ET2>::Type > operator* ( const Lazy_exact_nt< ET1 > &  a,
const Lazy_exact_nt< ET2 > &  b 
)
template<typename ET1 , typename ET2 >
Lazy_exact_nt< typename Coercion_traits<ET1, ET2>::Type > operator+ ( const Lazy_exact_nt< ET1 > &  a,
const Lazy_exact_nt< ET2 > &  b 
)
template<typename ET1 , typename ET2 >
Lazy_exact_nt< typename Coercion_traits<ET1, ET2>::Type > operator- ( const Lazy_exact_nt< ET1 > &  a,
const Lazy_exact_nt< ET2 > &  b 
)
template<typename ET1 , typename ET2 >
Lazy_exact_nt< typename Coercion_traits<ET1, ET2>::Type > operator/ ( const Lazy_exact_nt< ET1 > &  a,
const Lazy_exact_nt< ET2 > &  b 
)
template<typename ET1 , typename ET2 >
bool operator< ( const Lazy_exact_nt< ET1 > &  a,
const Lazy_exact_nt< ET2 > &  b 
)

Here is the call graph for this function:

template<typename ET >
bool operator< ( const Lazy_exact_nt< ET > &  a,
int  b 
)

Here is the call graph for this function:

template<typename ET >
bool operator< ( const Lazy_exact_nt< ET > &  a,
double  b 
)

Here is the call graph for this function:

template<typename ET >
std::ostream& operator<< ( std::ostream &  os,
const Lazy_exact_nt< ET > &  a 
)

Here is the call graph for this function:

template<typename ET1 , typename ET2 >
bool operator<= ( const Lazy_exact_nt< ET1 > &  a,
const Lazy_exact_nt< ET2 > &  b 
) [inline]
template<typename ET1 , typename ET2 >
bool operator== ( const Lazy_exact_nt< ET1 > &  a,
const Lazy_exact_nt< ET2 > &  b 
)

Here is the call graph for this function:

template<typename ET >
bool operator== ( const Lazy_exact_nt< ET > &  a,
int  b 
)

Here is the call graph for this function:

template<typename ET >
bool operator== ( const Lazy_exact_nt< ET > &  a,
double  b 
)

Here is the call graph for this function:

template<typename ET1 , typename ET2 >
bool operator> ( const Lazy_exact_nt< ET1 > &  a,
const Lazy_exact_nt< ET2 > &  b 
) [inline]
template<typename ET >
bool operator> ( const Lazy_exact_nt< ET > &  a,
int  b 
)

Here is the call graph for this function:

template<typename ET >
bool operator> ( const Lazy_exact_nt< ET > &  a,
double  b 
)

Here is the call graph for this function:

template<typename ET1 , typename ET2 >
bool operator>= ( const Lazy_exact_nt< ET1 > &  a,
const Lazy_exact_nt< ET2 > &  b 
) [inline]
template<typename ET >
std::istream& operator>> ( std::istream &  is,
Lazy_exact_nt< ET > &  a 
)
template<typename RT >
void print ( std::ostream &  os,
const CGAL::Lazy_exact_nt< Root_of_2< RT > > &  r 
)

Here is the call graph for this function:

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
Generated on Sat Feb 25 2012 21:23:02 for BWAPI by   doxygen 1.7.6.1