---

more/math/interval.h

Go to the documentation of this file.

//  Copyright (C) 2001--2002  Petter Urkedal
//
//  This file is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This file 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
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//  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 GNU General Public
//  License.  This exception does not however invalidate any other
//  reasons why the executable file might be covered by the GNU General
//  Public License.
//
//  $Id: interval.h,v 1.2 2002/08/24 13:52:14 petter_urkedal Exp $


#ifndef MORE_MATH_INTERVAL_H
#define MORE_MATH_INTERVAL_H

#include <functional>
#include <iosfwd>

namespace more {
namespace math {

  /** \class interval_base interval.h more/math/interval.h
      Helper for interval classes. */
  template<typename T>
    struct interval_base
    {
        typedef T element_type;

      protected:
        interval_base() {}
        interval_base(T x, T y) : m_inf(x), m_sup(y) {}

      public:
        T const& inf() const { return m_inf; }
        T const& sup() const { return m_sup; }
        T& inf() { return m_inf; }
        T& sup() { return m_sup; }
        friend T const& inf(interval_base const& I) { return I.m_inf; }
        friend T const& sup(interval_base const& I) { return I.m_sup; }
        void set_inf(T const& x) { m_inf = x; }
        void set_sup(T const& x) { m_sup = x; }

      protected:
        template<typename CharT, typename Traits>
          void print(std::basic_ostream<CharT, Traits>& os, bool, bool) const;
        template<typename CharT, typename Traits>
          void scan(std::basic_istream<CharT, Traits>& is, bool&, bool&);

      private:
        T m_inf, m_sup;
    };

  template<typename T>
    inline T length(interval_base<T> const& I) { return sup(I) - inf(I); }
  template<typename T>
    inline T center(interval_base<T> const& I) { return .5*(sup(I) + inf(I)); }

  template<typename T, typename Less> struct interval;

  /** \class open_internal interval.h more/math/internal.h
      A continuous interval which does not contain its extremums. */
  template<typename T, typename Less = std::less<T> >
    struct open_interval : interval_base<T>
    {
        open_interval() {}
        open_interval(T x, T y) : interval_base<T>(x, y) {}
        open_interval(T x, T y, Less l) : interval_base<T>(x, y), less(l) {}

        bool operator==(open_interval const& rhs) const {
            return inf() == rhs.inf() && sup() == rhs.sup();
        }
        bool operator!=(open_interval const& rhs) const {
            return !(*this == rhs);
        }

        bool is_left_closed() const { return false; }
        bool is_right_closed() const { return false; }

        bool find(T const& v) {
            if (!less(inf(), v)) return false;
            if (!less(v, sup())) return false;
            return true;
        }
      private:
        Less less;
        friend class interval<T, Less>;
    };

  /** \class left_interval interval.h more/math/interval.h
      A continuous interval which contains its infimum but not its
      supremum. */
  template<typename T, typename Less = std::less<T> >
    struct left_interval : interval_base<T>
    {
        left_interval() {}
        left_interval(T x, T y) : interval_base<T>(x, y) {}
        left_interval(T x, T y, Less l) : interval_base<T>(x, y), less(l) {}

        bool operator==(left_interval const& rhs) const {
            return inf() == rhs.inf() && sup() == rhs.sup();
        }
        bool operator!=(left_interval const& rhs) const {
            return !(*this == rhs);
        }

        bool is_left_closed() const { return true; }
        bool is_right_closed() const { return false; }

        bool find(T const& v) {
            if (less(v, inf())) return false;
            if (!less(v, sup())) return false;
            return true;
        }
      private:
        Less less;
        friend class interval<T, Less>;
    };

  /** \class right_interval interval.h more/math/interval.h
      A continuous interval which contains its supremum but not its
      infimum. */
  template<typename T, typename Less = std::less<T> >
    struct right_interval : interval_base<T> {
        right_interval() {}
        right_interval(T x, T y) : interval_base<T>(x, y) {}
        right_interval(T x, T y, Less l) : interval_base<T>(x, y), less(l) {}

        bool operator==(right_interval const& rhs) const {
            return inf() == rhs.inf() && sup() == rhs.sup();
        }
        bool operator!=(right_interval const& rhs) const {
            return !(*this == rhs);
        }

        bool is_left_closed() const { return false; }
        bool is_right_closed() const { return true; }

        bool find(T const& v) {
            if (!less(inf(), v)) return false;
            if (less(sup(), v)) return false;
            return true;
        }
      private:
        Less less;
        friend class interval<T, Less>;
    };

  /** \class closed_interval interval.h more/math/interval.h
      A continuous interval which contains both extremums. */
  template<typename T, typename Less = std::less<T> >
    struct closed_interval : interval_base<T>
    {
        closed_interval() {}
        closed_interval(T x, T y) : interval_base<T>(x, y) {}
        closed_interval(T x, T y, Less l) : interval_base<T>(x, y), less(l) {}

        bool operator==(closed_interval const& rhs) const {
            return inf() == rhs.inf() && sup() == rhs.sup();
        }
        bool operator!=(closed_interval const& rhs) const {
            return !(*this == rhs);
        }

        bool is_left_closed() const { return true; }
        bool is_right_closed() const { return true; }

        bool find(T const& v) {
            if (less(v, inf())) return false;
            if (less(sup(), v)) return false;
            return true;
        }
      private:
        Less less;
        friend class interval<T, Less>;
    };

  /** \class interval interval.h more/math/interval.h
      A continuous interval. That is, connected 1d set of reals.
      \c T should be (quasi-)continuous type, such as a float. */
  template< typename T, typename Less = std::less<T> >
    struct interval : interval_base<T>
    {
        interval() {}
        interval(T const& x, bool has_x, T const& y, bool has_y)
            : interval_base<T>(x, y), bb(has_x + 2*has_y) {}
        interval(T const& x, bool has_x, T const& y, bool has_y, Less l)
            : interval_base<T>(x, y), bb(has_x + 2*has_y), less(l) {}

        interval(open_interval<T, Less> const& I)
            : interval_base<T>(I), bb(0), less(I.less) {}
        interval(left_interval<T, Less> const& I)
            : interval_base<T>(I), bb(1), less(I.less) {}
        interval(right_interval<T, Less> const& I)
            : interval_base<T>(I), bb(2), less(I.less) {}
        interval(closed_interval<T, Less> const& I)
            : interval_base<T>(I), bb(3), less(I.less) {}

        bool operator==(interval const& rhs) const {
            return inf() == rhs.inf() && sup() == rhs.sup() && bb == rhs.bb;
        }
        bool operator!=(interval const& rhs) const { return !(*this == rhs); }

        bool is_left_closed() const { return bb & 1; }
        bool is_right_closed() const { return bb & 2; }

        bool find(T const& v) {
            if (is_left_closed()) {
                if (less(v, inf())) return false;
            } else {
                if (!less(inf(), v)) return false;
            }
            if (is_right_closed()) {
                if (less(sup(), v)) return false;
            } else {
                if (!less(v, sup())) return false;
            }
            return true;
        }

        template<typename CharT, typename Traits>
          friend inline std::basic_ostream<CharT, Traits>&
          operator<<(std::basic_ostream<CharT, Traits>& os,
                     interval const& x) {
              x.print(os, x.is_left_closed(), x.is_right_closed());
              return os;
          }

        template<typename CharT, typename Traits>
          friend inline std::basic_istream<CharT, Traits>&
          operator>>(std::basic_istream<CharT, Traits>& is,
                     interval& x) {
              bool lt_c, rt_c;
              x.scan(is, lt_c, rt_c);
              x.bb = lt_c + 2*rt_c;
              return is;
          }

      private:
        unsigned char bb;
        Less less;
    };

  template<typename T, typename Less>
    interval<T, Less>
    make_interval(T const& x, bool lt,
                  T const& y, bool rt, Less less = std::less<T>())
    {
        return interval<T, Less>(x, lt, y, rt, less);
    }

  template<typename T>
    interval<T>
    make_interval(T const& x, bool lt, T const& y, bool rt)
    {
        return interval<T>(x, lt, y, rt);
    }


}
  using namespace math;
}

#include <more/bits/interval.tcc>
#endif

---