SPAR/AIModule/BWTA/vendors/CGAL/CGAL/Polynomial/basic.h

Go to the documentation of this file.

// 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.5-branch/Kinetic_data_structures/include/CGAL/Polynomial/basic.h $
// $Id: basic.h 35766 2007-01-20 21:39:01Z drussel $
// 
//
// Author(s)     : Daniel Russel <drussel@alumni.princeton.edu>

#ifndef CGAL_POLYNOMIAL_BASIC_H
#define CGAL_POLYNOMIAL_BASIC_H

#include <CGAL/Polynomial/internal/config.h>
#include <CGAL/Polynomial/internal/Statistics.h>
#include <boost/static_assert.hpp>
#ifdef CGAL_USE_GMP
#ifndef CGAL_POLYNOMIAL_USE_CGAL
#define CGAL_POLYNOMIAL_USE_CGAL
#endif
#endif

#include <CGAL/Polynomial/internal/macros.h>

#ifdef CGAL_POLYNOMIAL_USE_CGAL
/*
  When CGAL is present
*/
#include <CGAL/basic.h>

#ifdef CGAL_USE_GMP
#include <CGAL/Gmpq.h>
CGAL_POLYNOMIAL_BEGIN_NAMESPACE
typedef CGAL::Gmpq Default_field_nt;
CGAL_POLYNOMIAL_END_NAMESPACE
#else
#include <CGAL/MP_Float.h>
CGAL_POLYNOMIAL_BEGIN_NAMESPACE
typedef CGAL::MP_Float Default_field_nt;
CGAL_POLYNOMIAL_END_NAMESPACE
#endif

CGAL_POLYNOMIAL_BEGIN_NAMESPACE

/*typedef CGAL::Sign Sign;
static const Sign ZERO= CGAL::ZERO;
static const Sign POSITIVE= CGAL::POSITIVE;
static const Sign NEGATIVE= CGAL::NEGATIVE;*/
/*typedef int Comparison_result;
static const int EQUAL= CGAL::EQUAL;
static const int SMALLER= CGAL::SMALLER;
static const int LARGER = CGAL::LARGER;*/
static const int UNKNOWN = -3;
typedef int Order;
static const int STRICTLY_BELOW = -3;
static const int BELOW=-2;
static const int CONTAINED=-1;
static const int CONTAINS=1;
static const int ABOVE=2;
static const int STRICTLY_ABOVE=3;
//typedef enum Sign {ZERO=CGAL::ZERO, POSITIVE=CGAL::POSITIVE, NEGATIVE=CGAL::NEGATIVE} Sign;

//typedef CGAL::Comparison_result Comparison_result;

/*template <class NT>
Sign sign(const NT &nt)
{
    return CGAL::sign(nt);
    }*/


/*typedef ::CGAL::Integral_domain_without_division_tag             Integral_domain_without_division_tag;
typedef ::CGAL::Euclidean_ring_tag   Euclidean_ring_tag;
typedef ::CGAL::Field_tag            Field_tag;
typedef ::CGAL::Field_with_sqrt_tag       Field_with_sqrt_tag;*/

CGAL_POLYNOMIAL_END_NAMESPACE

#define CGAL_POLYNOMIAL_TO_DOUBLE(d) CGAL::to_double(d)

#define CGAL_POLYNOMIAL_TO_INTERVAL(d) CGAL::to_interval(d)

#else
/*
  When no CGAL is present
*/

CGAL_POLYNOMIAL_BEGIN_NAMESPACE

typedef int Sign;
static const int ZERO =0;
static const int POSITIVE=1;
static const int NEGATIVE=-1;
typedef int Comparison_result;
static const int EQUAL= 0;
static const int SMALLER= -1;
static const int LARGER = 1;

template <class NT>
Sign sign(const NT &nt)
{
    if (nt >0) return POSITIVE;
    else if (nt <0) return NEGATIVE;
    else return ZERO;
}


struct Integral_domain_without_division_tag {};
struct Euclidean_ring_tag {};
struct Field_tag {};
struct Field_with_sqrt_tag {};

CGAL_POLYNOMIAL_END_NAMESPACE
#endif

#include <limits>

/*
  Shared
*/

CGAL_POLYNOMIAL_BEGIN_NAMESPACE

typedef enum Extended_sign
{
    EXTENDED_NEGATIVE=NEGATIVE, EXTENDED_ZERO=ZERO,
    EXTENDED_POSITIVE=POSITIVE, EXTENDED_UNKNOWN=2
} Extended_sign;


template <class NT>
inline Extended_sign extended_sign(const NT &nt)
{
  // for VC
  switch(CGAL::sign(nt)) {
        case ZERO: return EXTENDED_ZERO;
        case POSITIVE: return EXTENDED_POSITIVE;
        default: return EXTENDED_NEGATIVE;
    };
}


template <class Rt>
inline Rt infinity()
{
  //BOOST_STATIC_ASSERT(std::numeric_limits<Rt>::is_specialized);
    if (std::numeric_limits<Rt>::has_infinity) return std::numeric_limits<Rt>::infinity();
    else return (std::numeric_limits<Rt>::max)();
}


CGAL_POLYNOMIAL_END_NAMESPACE

/*
CGAL_POLYNOMIAL_BEGIN_NAMESPACE

struct Descartes_tag {};
struct Sturm_tag {};
struct Bezier_tag {};

CGAL_POLYNOMIAL_END_NAMESPACE
*/

#ifdef CGAL_POLYNOMIAL_NO_LIMITS
#include <CGAL/Polynomial/internal/limits.h>
#else
#include <limits>
#endif
#endif