SPAR/AIModule/BWTA/vendors/CGAL/CGAL/CORE/CoreAux.h

Go to the documentation of this file.

/****************************************************************************
 * Core Library Version 1.7, August 2004
 * Copyright (c) 1995-2004 Exact Computation Project
 * All rights reserved.
 *
 * This file is part of CORE (http://cs.nyu.edu/exact/core/); you may
 * redistribute it under the terms of the Q Public License version 1.0.
 * See the file LICENSE.QPL distributed with CORE.
 *
 * 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.
 *
 *
 * File: CoreAux.h
 * Synopsis:
 *      Auxilliary functions
 *
 * Written by 
 *       Chee Yap <yap@cs.nyu.edu>
 *       Chen Li <chenli@cs.nyu.edu>
 *       Zilin Du <zilin@cs.nyu.edu>
 *
 * WWW URL: http://cs.nyu.edu/exact/
 * Email: exact@cs.nyu.edu
 *
 * $URL: svn+ssh://scm.gforge.inria.fr/svn/cgal/branches/CGAL-3.5-branch/Core/include/CGAL/CORE/CoreAux.h $
 * $Id: CoreAux.h 37060 2007-03-13 18:10:39Z reichel $
 ***************************************************************************/

#ifndef _CORE_COREAUX_H_
#define _CORE_COREAUX_H_

#include <iostream>
#include <fstream>
#include "CGAL/CORE/Impl.h"

CORE_BEGIN_NAMESPACE

#ifndef LONG_BIT // such as in Linux
  #define LONG_BIT (sizeof(long) * 8)
#endif

// NOTES:
// (1) CORE_EPS is used in our Floating Point Filter (Filter.h)
// (2) 2^{-53} is called "unit roundoff" and
//      is the roundoff error for numbers in the range [1,2).
//      "Machine epsilon" is 2*CORE_EPS = 2^{-52}.  It is the
//      smallest gap between two normal machine numbers  --Chee 8/2003
//
// const double eps = (ldexp(1.0, -53)); // fails to link on SunPro
#define CORE_EPS ((1.0/(1<<30))/(1<<23))
// 
#define CORE_MACHINE_EPS ((1.0/(1<<30))/(1<<22))

const double relEps = (1.0 + std::ldexp(1.0, -52));

extern const char* CORE_DIAGFILE;

template <class T>
inline const T& core_max(const T& a, const T& b) {
  return ((a > b) ? a : b);
}

template <class T>
inline const T& core_min(const T& a, const T& b) {
  return ((a < b) ? a : b);
}

template <class T>
inline const T& core_max(const T& a, const T& b, const T& c) {
  return ((a > b) ? core_max(a, c) : core_max(b, c));
}

template <class T>
inline  void core_swap(T& a, T& b) {
  T tmp;
  tmp = a;
  a = b;
  b = tmp;
}

template <class T>
inline  void core_rotate(T& a, T& b, T& c) {
  T tmp;
  tmp = a;
  a = b;
  b = c;
  c = tmp;
}

template <class T>
inline const T& core_min(const T& a, const T& b, const T& c) {
  return ((a < b) ? core_min(a, c) : core_min(b, c));
}

template <class T>
inline const T core_abs(const T& a) {
  return ((a < T(0)) ? -a : a);
}


int flrLg(long x);


int flrLg(unsigned long x);


int clLg(long x);


int clLg(unsigned long x);

long gcd(long m, long n);

inline int abs(int x) {
  return (x>=0) ? x : (-x);
}

inline long abs(long x) {
  return (x>=0) ? x : (-x);
}

inline int sign(int x) {
  return (x==0) ? 0 : ((x>0) ? 1 : (-1));
}

inline long sign(long x) {
  return (x==0) ? 0 : ((x>0) ? 1 : (-1));
}

inline std::ostream& operator<< (std::ostream& o, const std::string& s) {
  o << s.c_str();
  return o;
}

//      (See CORE_PATH/progs/ieee/frexp.cpp for details)
double IntMantissa(double d);

//      (See CORE_PATH/progs/ieee/frexp.cpp for details)
int IntExponent(double d);


void core_error(std::string msg, std::string file, int lineno, bool err);
inline void core_debug(std::string msg){
  std::cout << __FILE__ << "::" << __LINE__ << ": " << msg
            << std::endl;
}


CORE_END_NAMESPACE
#endif // _CORE_COREAUX_H_