// ============================================================================
//
// Copyright (c) 1998 The CGAL Consortium
//
// This software and related documentation is part of an INTERNAL release
// of the Computational Geometry Algorithms Library (CGAL). It is not
// intended for general use.
//
// ----------------------------------------------------------------------------
//
// release       :
// release_date  :
//
// file          : include/CGAL/Interval_arithmetic.h
// revision      : $Revision$
// revision_date : $Date$
// package       : Interval Arithmetic
// author(s)     : Sylvain Pion <Sylvain.Pion@sophia.inria.fr>
//
// coordinator   : INRIA Sophia-Antipolis (<Mariette.Yvinec@sophia.inria.fr>)
//
// ============================================================================


// This file contains the description of the two classes:
// - CGAL_Interval_nt_advanced  (do the FPU rounding mode changes yourself)
// - CGAL_Interval_nt		("plug-in" version, derived from the other one)
//
// The differences are:
// - The second one is slower.
// - The first one supposes the rounding mode is set -> +infinity before
// nearly all operations, and might set it -> +infinity when leaving, whereas
// the second leaves the rounding -> nearest.

#ifndef CGAL_INTERVAL_ARITHMETIC_H
#define CGAL_INTERVAL_ARITHMETIC_H

#include <iostream.h>
#include <CGAL/assertions.h>
#include <CGAL/double.h>	// For CGAL_is_valid() and CGAL_is_finite().
#include <CGAL/enum.h>  // Because we overload CGAL_{sign,compare,abs,min,max}
#include <CGAL/number_utils.h>  // For CGAL_max(double, double).
#include <CGAL/Interval_arithmetic/_FPU.h>	// FPU rounding mode functions.

struct CGAL_Interval_nt_advanced
{
  typedef CGAL_Interval_nt_advanced IA;
  struct unsafe_comparison{};  // Exception class.
  // Usefull constants.
  static const double min_double, max_double;
  static const CGAL_Interval_nt_advanced largest, smallest;

protected:
  double inf, sup;	// "inf" stores the OPPOSITE of the lower bound.
			// "sup" stores the upper bound of the interval.
private:
  int overlap_action() const throw (unsafe_comparison)
  { throw unsafe_comparison(); }

public:
  friend IA	sqrt     (const IA &);
  friend IA	CGAL_abs (const IA &);
  friend IA	CGAL_min (const IA &, const IA &);
  friend IA	CGAL_max (const IA &, const IA &);
  // friend IA	operator* (const double, const IA &);
  friend double CGAL_to_double (const IA &);
  friend bool   CGAL_is_valid  (const IA &);
  friend bool   CGAL_is_finite (const IA &);
  friend CGAL_Sign CGAL_sign   (const IA &);
  friend CGAL_Comparison_result CGAL_compare (const IA &, const IA &);

  // The constructors.
  CGAL_Interval_nt_advanced() {}

  CGAL_Interval_nt_advanced(const double d)
      : inf(-d), sup(d) {}

  CGAL_Interval_nt_advanced(const double i, const double s)
      : inf(-i), sup(s)
#ifdef CGAL_NO_PRECONDITIONS
      {}
#else
      { CGAL_assertion(i<=s); }
#endif

#if 1
  // The copy constructors/assignment: useless.
  // The default ones are ok, but these are faster...
  CGAL_Interval_nt_advanced(const IA & d)
      : inf(d.inf), sup(d.sup) {}

  IA & operator=(const IA & d)
  { inf = d.inf; sup = d.sup; return *this; }
#endif

  // The operators.
  IA  operator+(const IA & d) const
  { return IA (-(inf + d.inf), sup + d.sup); }
  // { return IA  (d) += *this; }

  IA  operator-(const IA & d) const
  { return IA (-(inf + d.sup), sup + d.inf); }

  // Those 2 ones could be made not inlined.
  IA  operator*(const IA & d) const;
  IA  operator/(const IA & d) const;

  IA  operator-() const
  { return IA (-(sup), inf); }

  IA & operator+=(const IA & d);
  IA & operator-=(const IA & d);
  IA & operator*=(const IA & d);
  IA & operator/=(const IA & d);

  // For speed...
  IA  operator*(const double d) const;

  bool operator<(const IA & d) const
  {
    if (sup  < -d.inf) return true;
    if (-inf >= d.sup) return false;
    return overlap_action();
  }

  bool operator>(const IA & d) const
  { return (d < *this); }

  bool operator<=(const IA & d) const
  {
    if (sup <= -d.inf) return true;
    if (-inf >  d.sup) return false;
    return overlap_action();
  }

  bool operator>=(const IA & d) const
  { return (d <= *this); }

  bool operator==(const IA & d) const
  {
    if ((-d.inf >  sup) || (d.sup  < -inf)) return false;
    if ((-d.inf == sup) && (d.sup == -inf)) return true;
    return overlap_action();
  }

  bool operator!=(const IA & d) const
  { return !(d == *this); }
  
  bool is_same(const IA & d) const
  { return (inf == d.inf) && (sup == d.sup); }

  double lower_bound() const { return -inf; }
  double upper_bound() const { return sup; }
};

// Usefull constants.

// MIN_DOUBLE (subnormal)
const double CGAL_Interval_nt_advanced::min_double =5e-324;

// MAX_DOUBLE
const double CGAL_Interval_nt_advanced::max_double =1.7976931348623157081e+308;

// Smallest interval strictly around zero.
const CGAL_Interval_nt_advanced CGAL_Interval_nt_advanced::smallest
(-CGAL_Interval_nt_advanced::min_double, CGAL_Interval_nt_advanced::min_double);

// [-inf;+inf]
const CGAL_Interval_nt_advanced CGAL_Interval_nt_advanced::largest
(-HUGE_VAL, HUGE_VAL);


inline CGAL_Interval_nt_advanced CGAL_Interval_nt_advanced::operator*
  (const CGAL_Interval_nt_advanced& d) const
{
  if (inf<=0)					/* this>=0 */
  {
    if (d.inf<=0)				/* d>=0 */
      return IA (-((-inf)*d.inf), sup*d.sup);
    else if (d.sup<=0)				/* d<=0 */
      return IA (-(sup*d.inf), (-inf)*d.sup);
    else					/* 0 \in d */
      return IA (-(sup*d.inf), sup*d.sup);
  }
  else if (sup<=0)				/* this<=0 */
  {
    if (d.inf<=0)				/* d>=0 */
      return IA (-(inf*d.sup), sup*(-d.inf));
    else if (d.sup<=0)				/* d<=0 */
      return IA (-((-sup)*d.sup), inf*d.inf);
    else					/* 0 \in d */
      return IA (-(inf*d.sup), inf*d.inf);
  }
  else						/* 0 \in [inf;sup] */
  {
    if (d.inf<=0)				/* d>=0 */
      return IA (-(inf*d.sup), sup*d.sup);
    else if (d.sup<=0)				/* d<=0 */
      return IA (-(sup*d.inf), inf*d.inf);
    else					/* 0 \in d */
    {
      double tmp1, tmp2, tmp3, tmp4;
      tmp1 = inf*d.sup;
      tmp2 = sup*d.inf;
      tmp3 = inf*d.inf;
      tmp4 = sup*d.sup;
      return IA (-CGAL_max(tmp1,tmp2), CGAL_max(tmp3,tmp4));
    };
  };
}

inline CGAL_Interval_nt_advanced CGAL_Interval_nt_advanced::operator*
  (const double d) const
{
  if (d>=0)	return IA (-(inf*d), sup*d);
  else		return IA (-(sup*(-d)), inf*(-d));
}

inline CGAL_Interval_nt_advanced operator*
  (const double d, const CGAL_Interval_nt_advanced &t)
{ return t*d; }

inline CGAL_Interval_nt_advanced CGAL_Interval_nt_advanced::operator/
  (const CGAL_Interval_nt_advanced& d) const
{
  if (d.inf<0.0)				/* d>0 */
  {
    if (inf<=0.0)				/* this>=0 */
      return IA (-(inf/d.sup), sup/(-d.inf));
    else if (sup<=0.0)				/* this<=0 */
      return IA (-(inf/(-d.inf)), sup/d.sup);
    else					/* 0 \in this */
      return IA (-(inf/(-d.inf)), sup/(-d.inf));
  }
  else if (d.sup<0.0)				/* d<0 */
  {
    if (inf<=0.0)				/* this>=0 */
      return IA (-(sup/(-d.sup)), inf/d.inf);
    else if (sup<=0.0)				/* this<=0 */
      return IA (-(sup/d.inf), inf/(-d.sup));
    else					/* 0 \in this */
      return IA (-(sup/(-d.sup)), inf/(-d.sup));
  }
  else						/* 0 \in [d.inf;d.sup] */
    return largest; // IA (-HUGE_VAL, HUGE_VAL);
	   // We could do slightly better -> [0;HUGE_VAL] when d.sup==0,
	   // but is this worth ?
}

inline CGAL_Interval_nt_advanced& CGAL_Interval_nt_advanced::operator+=
  (const CGAL_Interval_nt_advanced& d)
{
  // A pity: this compact "one line" notation is not ok for speed.
  // return *this = *this + d;
  inf += d.inf;
  sup += d.sup;
  return *this;
}

inline CGAL_Interval_nt_advanced& CGAL_Interval_nt_advanced::operator-=
  (const CGAL_Interval_nt_advanced& d)
{ // return *this = *this - d;
  inf += d.sup;
  sup += d.inf;
  return *this;
}

inline CGAL_Interval_nt_advanced& CGAL_Interval_nt_advanced::operator*=
  (const CGAL_Interval_nt_advanced& d)
{ return *this = *this * d; }

inline CGAL_Interval_nt_advanced& CGAL_Interval_nt_advanced::operator/=
  (const CGAL_Interval_nt_advanced& d)
{ return *this = *this / d; }

inline CGAL_Interval_nt_advanced sqrt(const CGAL_Interval_nt_advanced& d)
{
  CGAL_FPU_set_rounding_to_minus_infinity();
  CGAL_Interval_nt_advanced tmp;
  // sqrt([+a,+b]) => [sqrt(+a);sqrt(+b)]
  // sqrt([-a,+b]) => [0;sqrt(+b)] => assumes roundoff error.
  // sqrt([-a,-b]) => [0;sqrt(-b)] => assumes user bug (unspecified result).
  tmp.inf = (d.inf<0) ? -sqrt(-d.inf) : 0;
  CGAL_FPU_set_rounding_to_infinity();
  tmp.sup = sqrt(d.sup);
  return tmp;
}

inline double CGAL_to_double (const CGAL_Interval_nt_advanced& d)
{ return (d.sup-d.inf)*.5; }

inline bool CGAL_is_valid  (const CGAL_Interval_nt_advanced& d)
{ return CGAL_is_valid(d.inf) && CGAL_is_valid(d.sup) && (d.sup >= -d.inf); }

inline bool CGAL_is_finite (const CGAL_Interval_nt_advanced& d)
{ return CGAL_is_finite(d.inf) && CGAL_is_finite(d.sup); }

inline CGAL_Sign CGAL_sign (const CGAL_Interval_nt_advanced& d)
{
    // Benchmark it, and compare with CGAL_compare(d,0).
  if (d.inf < 0) return CGAL_POSITIVE;
  if (d.sup < 0) return CGAL_NEGATIVE;
  if ( (d.inf == 0) && (d.sup == 0) ) return CGAL_ZERO;
  return (CGAL_Sign) d.overlap_action();
}

inline CGAL_Comparison_result CGAL_compare(const CGAL_Interval_nt_advanced& d,
					   const CGAL_Interval_nt_advanced& e)
{
  if (e.sup < -d.inf) return CGAL_LARGER;
  if (-e.inf > d.sup) return CGAL_SMALLER;
  if ( (-d.inf==e.sup) && (-e.inf==d.sup) ) return CGAL_EQUAL;
  return (CGAL_Comparison_result) d.overlap_action();
}

inline CGAL_Interval_nt_advanced CGAL_abs (const CGAL_Interval_nt_advanced& d)
{
  if (d.inf <= 0) return d;
  if (d.sup <= 0) return -d;
  return CGAL_Interval_nt_advanced(0, CGAL_max(d.inf,d.sup));
}

inline CGAL_Interval_nt_advanced CGAL_min (const CGAL_Interval_nt_advanced& d,
					   const CGAL_Interval_nt_advanced& e)
{
  return CGAL_Interval_nt_advanced(-CGAL_max(d.inf, e.inf),
	  			    CGAL_min(d.sup, e.sup));
}

inline CGAL_Interval_nt_advanced CGAL_max (const CGAL_Interval_nt_advanced& d,
					   const CGAL_Interval_nt_advanced& e)
{
  return CGAL_Interval_nt_advanced(-CGAL_min(d.inf, e.inf),
	  			    CGAL_max(d.sup, e.sup));
}

ostream& operator<<(ostream& os, const CGAL_Interval_nt_advanced& d)
{ return os << "[" << d.lower_bound() << ";" << d.upper_bound() << "]"; }


// The non-advanced class.

struct CGAL_Interval_nt : public CGAL_Interval_nt_advanced
{
private:

  // For this one to be overriden, it must be virtual...
#if 0
  int overlap_action() const
  {
#if !defined(CGAL_IA_NO_WARNINGS) && !defined(CGAL_NO_WARNINGS)
     CGAL_warning_msg(false, " Comparison between overlapping intervals");
#endif
     return 0; // Return a "random" value.
  }
#endif

public:

  // Constructors are identical.
  CGAL_Interval_nt()
      {}
  CGAL_Interval_nt(const double d)
      : CGAL_Interval_nt_advanced(d) {}
  CGAL_Interval_nt(const double a, const double b)
      : CGAL_Interval_nt_advanced(a,b) {}

  // Private constructor for casts. (remade public)
  CGAL_Interval_nt(const CGAL_Interval_nt_advanced &d)
      : CGAL_Interval_nt_advanced(d) {}

  typedef CGAL_Interval_nt IA;

  friend IA     sqrt     (const IA &);
  // How to share those definitions ?
  friend IA     CGAL_abs (const IA & d)
    { return CGAL_abs((CGAL_Interval_nt_advanced) d); }
  friend IA     CGAL_min (const IA & d, const IA & e)
    { return CGAL_min((CGAL_Interval_nt_advanced) d,
	              (CGAL_Interval_nt_advanced) e);
    }
  friend IA     CGAL_max (const IA & d, const IA & e)
    { return CGAL_max((CGAL_Interval_nt_advanced) d,
	              (CGAL_Interval_nt_advanced) e);
    }
  // friend IA     operator* (const double &, const IA &);
  friend double CGAL_to_double (const IA &);
  friend bool   CGAL_is_valid  (const IA & d)
    { return CGAL_is_valid((CGAL_Interval_nt_advanced) d); }
  friend bool   CGAL_is_finite (const IA & d)
    { return CGAL_is_finite((CGAL_Interval_nt_advanced) d); }
  friend CGAL_Sign CGAL_sign   (const IA & d)
    { return CGAL_sign((CGAL_Interval_nt_advanced) d); }
  friend CGAL_Comparison_result CGAL_compare (const IA &d, const IA &e)
    { return CGAL_compare((CGAL_Interval_nt_advanced) d,
	                  (CGAL_Interval_nt_advanced) e);
    }

  // This particular one needs to be redefined, a pitty...
  IA operator-() const 
  { return IA(-(sup), inf); }

  // The member functions that have to be protected against rounding mode.
  IA operator+(const IA& d) const ;
  IA operator-(const IA& d) const ;
  IA operator*(const IA& d) const ;
  IA operator/(const IA& d) const ;
  // For speed...
  IA operator*(const double d) const;
  // These have exactly the same code as the advanced class.
  // How can I avoid duplicating the code ?
  IA& operator+=(const IA& d) ;
  IA& operator-=(const IA& d) ;
  IA& operator*=(const IA& d) ;
  IA& operator/=(const IA& d) ;
};

// Here we use the GNU extension of "Named return value".

#ifdef __GNUG__
#  define CGAL_NAMED_RETURN_VALUE_OPT_1 return tmp;
#  define CGAL_NAMED_RETURN_VALUE_OPT_2
#  define CGAL_NAMED_RETURN_VALUE_OPT_3
#else
#  define CGAL_NAMED_RETURN_VALUE_OPT_1
#  define CGAL_NAMED_RETURN_VALUE_OPT_2 CGAL_Interval_nt tmp;
#  define CGAL_NAMED_RETURN_VALUE_OPT_3 return tmp;
#endif

inline CGAL_Interval_nt CGAL_Interval_nt::operator+(const CGAL_Interval_nt& d)
    const CGAL_NAMED_RETURN_VALUE_OPT_1
{
  CGAL_FPU_set_rounding_to_infinity();
  CGAL_NAMED_RETURN_VALUE_OPT_2
  tmp.inf = inf + d.inf;
  tmp.sup = sup + d.sup;
  CGAL_FPU_set_rounding_to_nearest();
  CGAL_NAMED_RETURN_VALUE_OPT_3
}

inline CGAL_Interval_nt CGAL_Interval_nt::operator-(const CGAL_Interval_nt& d)
    const CGAL_NAMED_RETURN_VALUE_OPT_1
{
  CGAL_FPU_set_rounding_to_infinity();
  CGAL_NAMED_RETURN_VALUE_OPT_2
  tmp.inf = inf + d.sup;
  tmp.sup = sup + d.inf;
  CGAL_FPU_set_rounding_to_nearest();
  CGAL_NAMED_RETURN_VALUE_OPT_3
}

inline CGAL_Interval_nt CGAL_Interval_nt::operator*(const CGAL_Interval_nt& d)
    const
{
  CGAL_FPU_set_rounding_to_infinity();
  CGAL_Interval_nt tmp ( CGAL_Interval_nt_advanced::operator*(d) );
  CGAL_FPU_set_rounding_to_nearest();
  return tmp;
}

inline CGAL_Interval_nt CGAL_Interval_nt::operator* (const double d)
    const CGAL_NAMED_RETURN_VALUE_OPT_1
{
  CGAL_FPU_set_rounding_to_infinity();
  CGAL_NAMED_RETURN_VALUE_OPT_2
  if (d>=0) {
      tmp.inf = inf*d;
      tmp.sup = sup*d;
  } else {
      tmp.inf = sup*(-d);
      tmp.sup = inf*(-d);
  }
  CGAL_FPU_set_rounding_to_nearest();
  CGAL_NAMED_RETURN_VALUE_OPT_3
}

inline CGAL_Interval_nt operator*
  (const double d, const CGAL_Interval_nt &t)
{ return t*d; }

inline CGAL_Interval_nt CGAL_Interval_nt::operator/(const CGAL_Interval_nt& d)
    const
{
  CGAL_FPU_set_rounding_to_infinity();
  CGAL_Interval_nt tmp ( CGAL_Interval_nt_advanced::operator/(d) );
  CGAL_FPU_set_rounding_to_nearest();
  return tmp;
}

inline CGAL_Interval_nt &
  CGAL_Interval_nt::operator+=(const CGAL_Interval_nt& d)
{ return *this = *this + d; }

inline CGAL_Interval_nt &
  CGAL_Interval_nt::operator-=(const CGAL_Interval_nt& d)
{ return *this = *this - d; }

inline CGAL_Interval_nt &
  CGAL_Interval_nt::operator*=(const CGAL_Interval_nt& d)
{ return *this = *this * d; }

inline CGAL_Interval_nt &
  CGAL_Interval_nt::operator/=(const CGAL_Interval_nt& d)
{ return *this = *this / d; }

inline CGAL_Interval_nt sqrt(const CGAL_Interval_nt& d)
{
  CGAL_Interval_nt tmp = sqrt( (CGAL_Interval_nt_advanced) d);
  CGAL_FPU_set_rounding_to_nearest();
  return tmp;
}

// Finally we source the CGAL_to_Interval_nt_advanced() "cast" functions from
// other NTs, when necessary.
// CGAL_to_Interval_nt() is templated below, only specialized for double.

#ifdef CGAL_GMPZ_H
#include <CGAL/Interval_arithmetic/IA_Gmpz.h>
#endif

#ifdef CGAL_BIGFLOAT_H
#include <CGAL/Interval_arithmetic/IA_leda_bigfloat.h>
#endif

#ifdef CGAL_INTEGER_H
#include <CGAL/Interval_arithmetic/IA_leda_integer.h>
#endif

#ifdef CGAL_REAL_H
#include <CGAL/Interval_arithmetic/IA_leda_real.h>
#endif

#ifdef CGAL_RATIONAL_H
#include <CGAL/Interval_arithmetic/IA_leda_rational.h>
#endif

inline CGAL_Interval_nt_advanced CGAL_to_Interval_nt_advanced(const double d)
{ return CGAL_Interval_nt_advanced(d); }

template <class FT>
inline CGAL_Interval_nt CGAL_to_Interval_nt(const FT &z)
{
    CGAL_FPU_set_rounding_to_infinity();
    CGAL_Interval_nt tmp(CGAL_to_Interval_nt_advanced(z));
    CGAL_FPU_set_rounding_to_nearest();
    return tmp;
}

inline CGAL_Interval_nt CGAL_to_Interval_nt(const double d)
{ return CGAL_Interval_nt(d); }

#endif // CGAL_INTERVAL_ARITHMETIC_H