tahoma2d/toonz/sources/include/tinterval.h

#pragma once

#ifndef T_INTERVAL_INCLUDED
#define T_INTERVAL_INCLUDED

#include <assert.h>
#include <limits.h>
#include "tcommon.h"

#undef DVAPI
#undef DVVAR
#ifdef TNZCORE_EXPORTS
#define DVAPI DV_EXPORT_API
#define DVVAR DV_EXPORT_VAR
#else
#define DVAPI DV_IMPORT_API
#define DVVAR DV_IMPORT_VAR
#endif

//=============================================================================

//  class TInterval implementa "Interval Arithmetic" (non vengono computati gli
//  errori macchina):
//  TInterval(min, max) (min <= max) rapresenta l'intervallo reale chiuso [min,
//  max];
//  per m_min == m_max si ottiene l'algebra dei reali;
//  TInterval (m_min = 1, m_max = -1) rappresenta l'intervallo vuoto

class TInterval {
  double m_min, m_max;

public:
  //  costruisce l'intervallo vuoto
  //  TInterval (m_min = 1, m_max = -1) rappresenta l'intervallo vuoto
  TInterval() : m_min(1), m_max(-1) {}
  //-----------------------------------------------------
  //  costruisce gli intervalli degeneri [x, x] che rappresentano i reali
  TInterval(double x) : m_min(x), m_max(x) {}
  //-----------------------------------------------------
  TInterval(double min, double max) {
    assert(min <= max);  //  non vuoto
    m_min = min;
    m_max = max;
  }
  //-----------------------------------------------------
  TInterval(const TInterval &w) {
    assert(w.m_min <= w.m_max ||
           (w.m_min == 1 && w.m_max == -1));  //  intervallo vuoto
    m_min = w.m_min;
    m_max = w.m_max;
  }
  //-----------------------------------------------------
  inline TInterval &operator=(const TInterval &w) {
    assert(w.m_min <= w.m_max ||
           (w.m_min == 1 && w.m_max == -1));  //  intervallo vuoto
    m_min = w.m_min;
    m_max = w.m_max;
    return *this;
  }
  //-----------------------------------------------------
  inline TInterval operator+() const {
    assert(m_min <= m_max);  //  non vuoto
    return *this;
  }
  //-----------------------------------------------------
  inline TInterval operator-() const {
    assert(m_min <= m_max);  //  non vuoto
    return TInterval(-m_max, -m_min);
  }
  //-----------------------------------------------------
  inline TInterval operator+(const TInterval &w) const {
    assert(m_min <= m_max);      //  non vuoto
    assert(w.m_min <= w.m_max);  //  non vuoto
    return TInterval(m_min + w.m_min, m_max + w.m_max);
  }
  //-----------------------------------------------------
  inline TInterval operator-(const TInterval &w) const {
    assert(m_min <= m_max);      //  non vuoto
    assert(w.m_min <= w.m_max);  //  non vuoto
    return TInterval(m_min - w.m_max, m_max - w.m_min);
  }
  //-----------------------------------------------------
  inline TInterval operator*(const TInterval &w) const {
    assert(m_min <= m_max);      //  non vuoto
    assert(w.m_min <= w.m_max);  //  non vuoto
    double value[4];
    value[0]        = m_min * w.m_min;
    value[1]        = m_min * w.m_max;
    value[2]        = m_max * w.m_min;
    value[3]        = m_max * w.m_max;
    double minValue = value[0];
    double maxValue = value[0];
    int i           = 1;
    for (i = 1; i <= 3; ++i) {
      if (value[i] < minValue) minValue = value[i];
      if (value[i] > maxValue) maxValue = value[i];
    }
    return TInterval(minValue, maxValue);
  }
  //-----------------------------------------------------
  inline TInterval operator/(const TInterval &w) const {
    assert(m_min <= m_max);      //  non vuoto
    assert(w.m_min <= w.m_max);  //  non vuoto
    assert((0 < w.m_min && 0 < w.m_max) ||
           (0 > w.m_min && 0 > w.m_max));  //  divisore non nullo
    double value[4];
    value[0]        = m_min / w.m_min;
    value[1]        = m_min / w.m_max;
    value[2]        = m_max / w.m_min;
    value[3]        = m_max / w.m_max;
    double minValue = value[0];
    double maxValue = value[0];
    int i           = 1;
    for (i = 1; i <= 3; ++i) {
      if (value[i] < minValue) minValue = value[i];
      if (value[i] > maxValue) maxValue = value[i];
    }
    return TInterval(minValue, maxValue);
  }
  //-----------------------------------------------------
  inline bool operator==(const TInterval &w) const {
    assert(w.m_min <= w.m_max ||
           (w.m_min == 1 && w.m_max == -1));  //  intervallo vuoto
    return (m_min == w.m_min && m_max == w.m_max);
  }
  //-----------------------------------------------------
  /*  la definizione e' discutibile...
inline bool operator!=(const TInterval &w) const
{return (m_min != w.m_min  ||  m_max != w.m_max);}
*/
  //-----------------------------------------------------
  inline bool operator>(const TInterval &w) const {
    assert(m_min <= m_max);      //  non vuoto
    assert(w.m_min <= w.m_max);  //  non vuoto
    return (m_min > w.m_max);
  }
  //-----------------------------------------------------
  inline bool operator<(const TInterval &w) const {
    assert(m_min <= m_max);      //  non vuoto
    assert(w.m_min <= w.m_max);  //  non vuoto
    return (m_max < w.m_min);
  }
  //-----------------------------------------------------
  /*  la definizione e' discutibile...
//  A >= B
inline bool operator>=(const TInterval &w) const {
assert (m_min <= m_max);  //  non vuoto
assert (w.m_min <= w.m_max);  //  non vuoto
return (m_min >= w.m_min && m_max >= w.m_max);}
//-----------------------------------------------------
//  A <= B
inline bool operator<=(const TInterval &w) const {
assert (m_min <= m_max);  //  non vuoto
assert (w.m_min <= w.m_max);  //  non vuoto
return (m_min <= w.m_min  && m_max <= w.m_max);}
*/
  //-----------------------------------------------------
  inline void setMin(double min) {
    assert(m_min <= m_max);  //  non vuoto
    assert(min <= m_max);    //  non vuoto dopo setMin
    m_min = min;
  }
  //-----------------------------------------------------
  inline void setMax(double max) {
    assert(m_min <= m_max);  //  non vuoto
    assert(m_min <= max);    //  non vuoto dopo setMax
    m_max = max;
  }
  //-----------------------------------------------------
  inline double getMin() const {
    //  isEmpty() => return 1
    return m_min;
  }
  //-----------------------------------------------------
  inline double getMax() const {
    //  isEmpty() => return -1
    return m_max;
  }
  //-----------------------------------------------------
  inline double getLength() const {
    return m_max - m_min;
  }  //  isEmpty() => (getLength() < 0)
  //-----------------------------------------------------
  inline double getCenter() const {
    assert(m_min <= m_max);  //  non vuoto
    return (m_max + m_min) / 2;
  }
  //-----------------------------------------------------
  inline double getRadius() const {
    assert(m_min <= m_max);  //  non vuoto
    return (m_max - m_min) / 2;
  }
  //-----------------------------------------------------
  inline bool isEmpty() const {
    //  TInterval (m_min = 1, m_max = -1) rappresenta l'intervallo vuoto
    assert(m_min <= m_max || (m_min == 1 && m_max == -1));  //  intervallo vuoto
    return (m_min > m_max);
  }

  //-----------------------------------------------------
  inline bool isProper() const {
    //  isProper() <=> !isEmpty() && m_min < m_max (cioe' non degenere)
    //  TInterval (m_min = 1, m_max = -1) rappresenta l'intervallo vuoto
    assert(m_min <= m_max || (m_min == 1 && m_max == -1));  //  intervallo vuoto
    return (m_min < m_max);
  }
  //-----------------------------------------------------
  inline bool contain(double t) const {
    assert(m_min <= m_max || (m_min == 1 && m_max == -1));  //  intervallo vuoto
    return (m_min <= t && t <= m_max);
  }  //  isEmpty() => return false
  //-----------------------------------------------------
  inline bool include(const TInterval &interval) const {
    if (interval.isEmpty())
      return true;
    else if (isEmpty())
      return false;
    else {
      assert(!interval.isEmpty() && !isEmpty());
      return (m_min <= interval.m_min && interval.m_max <= m_max);
    }
  }
  //-----------------------------------------------------
  inline bool isIncluded(const TInterval &interval) const {
    if (isEmpty())
      return true;
    else if (interval.isEmpty())
      return false;
    else {
      assert(!isEmpty() && !interval.isEmpty());
      return (interval.m_min <= m_min && m_max <= interval.m_max);
    }
  }
  //-----------------------------------------------------
  // Friend helper function declarations
  friend TInterval operator*(const double s, const TInterval &w);
  friend TInterval intersection(const TInterval &a, const TInterval &b);
  friend TInterval square(const TInterval &w);
  friend TInterval sqrt(const TInterval &w);
};
//---------------------------------------------------------------------------
// friend functions
inline TInterval operator*(const double s, const TInterval &w) {
  assert(w.m_min <= w.m_max);  //  non vuoto
  if (s >= 0)
    return TInterval(s * w.m_min, s * w.m_max);
  else
    return TInterval(s * w.m_max, s * w.m_min);
}
//---------------------------------------------------------------------------
inline TInterval square(const TInterval &w) {
  //  return w^2
  assert(w.m_min <= w.m_max);  //  non vuoto
  double a = w.m_min * w.m_min;
  double b = w.m_max * w.m_max;
  if (0 <= w.m_min)
    return TInterval(a, b);  //  return [m_min^2, m_max^2]
  else if (w.m_max <= 0)
    return TInterval(b, a);  //  return [m_max^2, m_min^2]
  else {
    assert(w.m_min < 0 && 0 < w.m_max);
    return TInterval(0, std::max(a, b));  //  [0, max(w.m_min^2, w.m_max^2)]
  }
}
//-----------------------------------------------------
inline TInterval sqrt(const TInterval &w) {
  //  return sqrt(w)
  assert(w.m_min <= w.m_max);  //  non vuoto
  assert(0 <= w.m_min);
  return TInterval(sqrt(w.m_min), sqrt(w.m_max));
}  //  [sqrt(w.m_min), sqrt(w.m_max)]
//-----------------------------------------------------
//  helper function
inline TInterval intersection(const TInterval &a, const TInterval &b) {
  //  return a_intersezione_b (insiemistico) se questa e' non vuota, altrimenti
  //  return TInterval() (intervallo vuoto)
  double min = std::max(a.m_min, b.m_min);
  double max = std::min(a.m_max, b.m_max);
  if (min <= max)  //  a.isEmpty() || b.isEmpty() => (min >= 1 && max <= -1) =>
                   //  min > max
    return TInterval(min, max);
  else
    return TInterval();  //  intervallo vuoto
}
//-----------------------------------------------------
inline TInterval createTInterval(double center, double radius) {
  if (radius >= 0)
    return TInterval(center - radius, center + radius);
  else
    return TInterval();  //  intervallo vuoto
}
//-----------------------------------------------------
inline TInterval createErrorTInterval(
    double center, double minError = (std::numeric_limits<double>::min)()) {
  //  type double standard IEEE (1 bit segno + 11 bit esponente + 52 bit
  //  mantissa)
  //  corrisponde ad almeno 15 decimali significativi.
  //  minError serve ad assegnare un errore positivo quando center = 0.
  //  Aumentare 100 volte (da 1e-15 a 1e-13) l'errore relativo serve a
  //  compensare
  //  la propagazione degli errori macchina (TInterval non li computa) ed a
  //  stabilizzare il codice relativamente a processori che potrebbero male
  //  implementare l'artimetica double standard IEEE.
  assert(minError >= 0);
  const double relativeDoubleError = 1e-13;
  double error = std::max(fabs(center) * relativeDoubleError, minError);
  return TInterval(center - error, center + error);
}
//-----------------------------------------------------

#endif  //  __T_INTERVAL_INCLUDED__