interval_profil.h

Go to the documentation of this file.

// Interval Wrapper Class for PROFIL -*- C++ -*-

// $Id: interval_profil.h 347 2008-02-06 15:20:01Z schilly $
// Copyright (C) 2006 Christian Keil
//
// This file is part of the COCONUT API.  This library
// is free software; you can redistribute it and/or modify it under the
// terms of the Library GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// Library GNU General Public License for more details.

// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the Library GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the Library GNU General Public License.

#ifndef _INTERVAL_PROFIL_H_
#define _INTERVAL_PROFIL_H_

#include <iostream>
#include <Interval.h>

namespace coco
{

#define coconut_init_interval()

// data type
class interval;


struct interval_st
{
  double l, u;

  interval_st& operator=(const interval& __i);
};


class interval : public INTERVAL
{
private:
  typedef INTERVAL        __Base;

public:
  interval(double lo, double up) : __Base(lo, up) {}
  interval(double d = 0) : __Base(d) {}
  interval(int d) : __Base((double) d) {}
  interval(unsigned d) : __Base((double) d) {}
  interval(long d) : __Base((double) d) {}
  interval(unsigned long d) : __Base((double) d) {}
  explicit interval(const __Base& x) : __Base(x) {}
  interval(const interval& x) : __Base(x) {}
  interval(const interval_st& x) : __Base(x.l, x.u) {}

  void set(double lo, double up)
  {
    *this = interval(lo, up);
  }
  
  __Base base() const {return *this;}

  /* Im Moment gibts keine leeren Intervalle in Profil, wird ueber Rueckgaben angezeigt */
  static interval EMPTY() {return interval(__Base::EMPTY());}

  bool empty() const {return __Base::isEmpty();}
  bool is_empty() const {return __Base::isEmpty();}

  bool is_thin() const {return Sup(__Base) == Inf(__Base);}

  /* CK wo kommt COCO_INF / -COCO_INF her? "besser" als BiasPosInf/BiasNegInf */
  bool is_unbounded_below() const {return Inf(__Base) == BiasNegInf;}
  bool is_unbounded_above() const {return Sup(__Base) == BiasPosInf;}
  bool is_entire() const {return Inf(__Base) == BiasNegInf && sup() == BiasPosInf;}
  bool is_bounded() const
        {return !is_unbounded_below() && !is_unbounded_above();}
  bool subset (const interval& x) const
        {return __Base <= x;}
  bool superset (const interval& x) const
        {return x <= __Base;}
  bool proper_subset (const interval& x) const
        {return __Base < x;}
  bool proper_superset (const interval& x) const
        {return x < __Base;}
  bool disjoint (const interval& x) const
        {INTERVAL dummy;
         return Intersection(dummy, __Base, x) == 0;}


  double rel_width() const;

  interval& intersect(const interval& x)
  {
    INTERVAL t;
    Intersection(t, __Base, x);
    return *this = t;
  }

  interval& hull(const interval& x)
  {
    return *this = __Base::hull(x);
  }

  interval& hulldiff(const interval& x)
  {
    if(subset(x))
      *this = EMPTY();
    else if(!superset(x))
    {
      if(x.contains(inf()))
        *this = interval(x.sup(), sup());
      else
        *this = interval(inf(), x.inf());
    }
    return *this;
  }

  bool contains(const interval& x) const
  {
    if(inf() <= x.inf() && sup() >= x.sup())
      return true;
    else
      return false;
  }

  void setpair(double& lo, double& up) const {lo = inf(); up = sup();}
  void get_bounds(double& a, double& b) const {a = inf(); b = sup();}
  void set_bounds(double a, double b) {INF = a; SUP = b;}
  void set_lb(double d) {INF = d;}
  void set_ub(double d) {SUP = d;}


  interval& operator=(double d) {INF = SUP = d; return *this;}
  interval& operator=(int d) {INF = SUP = d; return *this;}
  interval& operator=(unsigned d) {INF = SUP = d; return *this;}
  interval& operator=(long d) {INF = SUP = d; return *this;}
  interval& operator=(unsigned long d) {INF = SUP = d; return *this;}

  interval& operator=(const __Base& _x)
          {INF = _x.inf(); SUP = _x.sup(); return *this;}

  interval operator-() const {return interval(__Base::operator-());}

  interval& ipow(int n);
  interval& imin(const interval& x);
  interval& imax(const interval& x);

  interval& intersect_div(const interval& __i, const interval& __j);
  interval& intersect_power(const interval& __i, int __n);
  interval& intersect_invsqr_wc(const interval& __i, double __l, double __d);
  interval& intersect_invpower_wc(const interval& __i, double __l, int __n);
  interval& intersect_invsin_wc(const interval& __i, double __l, double __d);
  interval& intersect_invcos_wc(const interval& __i, double __l, double __d);
  interval& intersect_invgauss_wc(const interval& __i, double __l, double __m,
                                  double __s);

  double project(double __d) const;

  //--------------------------------------------------------------------------
  // FUNCTIONS THAT NEED TO BE PUT IN CPP FILE
  //--------------------------------------------------------------------------

  interval& operator+=(const interval& a);

  interval& operator+=(double a);

  interval& operator-=(const interval& a);

  interval& operator-=(double a);

  interval& operator*=(const interval& a);

  interval& operator*=(double a);

  interval& operator/=(const interval& a);

  interval& operator/=(double a);

  double mid() const;


  double diam() const;
  double width() const;

  double relDiam() const;

  double rad() const;

  double mig() const;

  double mag() const;

  double dist(const interval& x) const;

  double safeguarded_mid() const;

  static int const & precision();
  static int precision(int const & p);
};
// end of interval class


//------------------------------------------------------------------------------
// INLINE FUNCTIONS
//------------------------------------------------------------------------------

inline double safeguarded_mid(const interval& __i)
        {return __i.safeguarded_mid();}
interval ipow(const interval& x, int n);
interval gauss(const interval& x);
interval atan2(const interval& y, const interval& x);
double absmin(const interval& __i);
double gainfactor(const interval& _old, const interval& _new);


bool operator==(const interval& __i, const interval& __d);
template <class _TC>
bool operator==(const interval& __i, const _TC& __d);


bool operator!=(const interval& __i, const interval& __d);
template <class _TC>
bool operator!=(const interval& __i, const _TC& __d);


//------------------------------------------------------------------------------
// FUNCTIONS TO BE HIDDEN FROM USERS TO AVOID THE OPTIMIZATION OF COMPILER
//------------------------------------------------------------------------------

double downward_plus(const double&  a, const double& b);
double upward_plus(const double&  a, const double& b);
double downward_minus(const double&  a, const double& b);
double upward_minus(const double&  a, const double& b);
double downward_multiplies(const double&  a, const double& b);
double upward_multiplies(const double&  a, const double& b);
double downward_divides(const double&  a, const double& b);
double upward_divides(const double&  a, const double& b);


inline bool operator<(const interval& a, const interval& b){return a.sup() < b.inf();}
inline bool operator<(const interval& a, double b){return a.sup() < b;}
inline bool operator<(double a, const interval& b){return a < b.inf();}


interval operator+(const interval& a, const interval& b);
interval operator+(const interval& a, double b);
interval operator+(double b, const interval& a);


interval operator-(const interval& a, const interval& b);
interval operator-(const interval& a, double b);
interval operator-(double a, const interval& b);
interval cancel(const interval& a, const interval& b);

interval operator*(const interval& a, const interval& b);
interval operator*(const interval& a, double b);
interval operator*(double a, const interval& b);


interval operator/(const interval& a, const interval& b);
interval operator/(const interval& a, double b);
interval operator/(double a, const interval& b);


interval division_part1(const interval& x, const interval& y, bool& b);

interval division_part2(const interval& x, const interval& y, bool b = true);

double mid(const interval&);
double diam(const interval&);
double width(const interval&);
double relDiam(const interval&);
double rad(const interval&);
double mig(const interval&);
double mag(const interval&);
double dist(const interval& x, const interval& y);

interval acos(const interval& x);

interval abs(const interval& x);

interval acosh(const interval& x);

interval acot(const interval& x);

interval acoth(const interval& x);

interval asin(const interval& x);

interval asinh(const interval& x);

interval atan(const interval& x);

interval atanh(const interval& x);

interval cos(const interval& x);

interval cosh(const interval& x);

interval cot(const interval& x);

interval coth(const interval& x);

interval exp(const interval& x);

interval exp10(const interval& x);

interval exp2(const interval& x);

interval expm1(const interval& x);

interval log(const interval& x);

interval log10(const interval& x);

interval log1p(const interval& x);

interval log2(const interval& x);

interval power(const interval& x, int n);

interval pow(const interval& x, const interval& y);

interval sin(const interval& x);

interval sinh(const interval& x);

interval sqr(const interval& x);

interval sqrt(const interval& x);

interval tan(const interval& x);

interval tanh(const interval& x);

interval imax(const interval& x, const interval& y);

interval imin(const interval& x, const interval& y);


//------------------------------------------------------------------------------
// INLINE IMPLEMENTAION
//------------------------------------------------------------------------------

inline
interval_st& interval_st::operator=(const interval& x)
{ 
  l = x.inf();
  u = x.sup();
  return *this;
}


// elementary functions for intervals
inline
interval ipow(const interval& x, int n)
{
  return power(x, n);
}


inline
interval gauss(const interval& x)
{
  return exp(-sqr(x));
}


inline
interval atan2(const interval& y, const interval& x)
{
  return atan(y/x);
}


inline
double absmin(const interval& __i)
{
  if(__i.contains(0.))
    return 0.;
  else if(__i.inf() > 0)
    return __i.inf();
  else
    return __i.sup();
}


inline
double gainfactor(const interval& _old, const interval& _new)
{
  if(_old.is_thin())
    return 1.;
  if(_old.is_bounded() && _new.is_bounded())
    return _new.width()/_old.width();
  if((_new.sup() != COCO_INF && _old.sup() == COCO_INF) ||
     (_new.inf() != -COCO_INF && _old.inf() == -COCO_INF))
    return 0.;
  return 1.;
}

inline
bool operator==(const interval& __i, const interval& __d)
{
  return filib::operator==(__i, __d);
}

template <class _TC>
inline
bool operator==(const interval& __i, const _TC& __d)
{
  return filib::operator==(__i, interval(__d));
}

inline
bool operator!=(const interval& __i, const interval& __d)
{
  return filib::operator!=(__i, __d);
}


template <class _TC>
inline
bool operator!=(const interval& __i, const _TC& __d)
{
  return filib::operator!=(__i, interval(__d));
}


// special additional functions
inline
double interval::project(double __d) const
{
  if(__d < inf())
    return inf();
  else if(__d > sup())
    return sup();
  else
    return __d;
}


} // end of namespace coco


#endif // _COCONUT_INTERVAL_H_

---