comparison DEPENDENCIES/generic/include/boost/multi_array/index_range.hpp @ 16:2665513ce2d3

Add boost headers

+// Copyright 2002 The Trustees of Indiana University.
+
+// Use, modification and distribution is subject to the Boost Software 
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  Boost.MultiArray Library
+//  Authors: Ronald Garcia
+//           Jeremy Siek
+//           Andrew Lumsdaine
+//  See http://www.boost.org/libs/multi_array for documentation.
+
+#ifndef BOOST_INDEX_RANGE_RG071801_HPP
+#define BOOST_INDEX_RANGE_RG071801_HPP
+
+#include <boost/config.hpp>
+#include <utility>
+#include <boost/limits.hpp>
+
+// For representing intervals, also with stride.
+// A degenerate range is a range with one element.
+
+// Thanks to Doug Gregor for the really cool idea of using the
+// comparison operators to express various interval types!
+
+// Internally, we represent the interval as half-open.
+
+namespace boost {
+namespace detail {
+namespace multi_array {
+
+  template <typename Index,typename SizeType>
+  class index_range {
+  public:
+    typedef Index index;
+    typedef SizeType size_type;
+
+  private:
+    static index from_start()
+      { return (std::numeric_limits<index>::min)(); }
+
+    static index to_end()
+      { return (std::numeric_limits<index>::max)(); }
+
+  public:
+
+    index_range()
+    {
+      start_ = from_start();
+      finish_ = to_end();
+      stride_ = 1;
+      degenerate_ = false;
+    }
+
+    explicit index_range(index pos)
+    {
+      start_ = pos;
+      finish_ = pos+1;
+      stride_ = 1;
+      degenerate_ = true;
+    }
+
+    explicit index_range(index start, index finish, index stride=1)
+      : start_(start), finish_(finish), stride_(stride),
+        degenerate_(false)
+    { }
+
+
+    // These are for chaining assignments to an index_range
+    index_range& start(index s) {
+      start_ = s;
+      degenerate_ = false;
+      return *this;
+    }
+
+    index_range& finish(index f) {
+      finish_ = f;
+      degenerate_ = false;
+      return *this;
+    }
+
+    index_range& stride(index s) { stride_ = s; return *this; }
+
+    index start() const
+    { 
+      return start_; 
+    }
+
+    index get_start(index low_index_range = index_range::from_start()) const
+    { 
+      if (start_ == from_start())
+        return low_index_range;
+      return start_; 
+    }
+
+    index finish() const
+    {
+      return finish_;
+    }
+
+    index get_finish(index high_index_range = index_range::to_end()) const
+    {
+      if (finish_ == to_end())
+        return high_index_range;
+      return finish_;
+    }
+
+    index stride() const { return stride_; }
+
+    void set_index_range(index start, index finish, index stride=1)
+    {
+      start_ = start;
+      finish_ = finish;
+      stride_ = stride;
+    }
+
+    static index_range all() 
+    { return index_range(from_start(), to_end(), 1); }
+
+    bool is_degenerate() const { return degenerate_; }
+
+    index_range operator-(index shift) const
+    { 
+      return index_range(start_ - shift, finish_ - shift, stride_); 
+    }
+
+    index_range operator+(index shift) const
+    { 
+      return index_range(start_ + shift, finish_ + shift, stride_); 
+    }
+
+    index operator[](unsigned i) const
+    {
+      return start_ + i * stride_;
+    }
+
+    index operator()(unsigned i) const
+    {
+      return start_ + i * stride_;
+    }
+
+    // add conversion to std::slice?
+
+  public:
+    index start_, finish_, stride_;
+    bool degenerate_;
+  };
+
+  // Express open and closed interval end-points using the comparison
+  // operators.
+
+  // left closed
+  template <typename Index, typename SizeType>
+  inline index_range<Index,SizeType>
+  operator<=(Index s, const index_range<Index,SizeType>& r)
+  {
+    return index_range<Index,SizeType>(s, r.finish(), r.stride());
+  }
+
+  // left open
+  template <typename Index, typename SizeType>
+  inline index_range<Index,SizeType>
+  operator<(Index s, const index_range<Index,SizeType>& r)
+  {
+    return index_range<Index,SizeType>(s + 1, r.finish(), r.stride());
+  }
+
+  // right open
+  template <typename Index, typename SizeType>
+  inline index_range<Index,SizeType>
+  operator<(const index_range<Index,SizeType>& r, Index f)
+  {
+    return index_range<Index,SizeType>(r.start(), f, r.stride());
+  }
+
+  // right closed
+  template <typename Index, typename SizeType>
+  inline index_range<Index,SizeType>
+  operator<=(const index_range<Index,SizeType>& r, Index f)
+  {
+    return index_range<Index,SizeType>(r.start(), f + 1, r.stride());
+  }
+
+} // namespace multi_array
+} // namespace detail  
+} // namespace boost
+
+#endif // BOOST_INDEX_RANGE_RG071801_HPP