This commit was manufactured by cvs2svn to create tag

'Version_1_34_1'. [SVN r38286]
Correct testing bugs:
2026-01-25 06:22:10 +00:00 · 2007-07-24 19:28:14 +00:00 · 2007-02-25 15:28:02 +00:00 · 2006-11-07 19:27:00 +00:00 · 2006-11-06 17:10:46 +00:00 · 2006-06-30 15:14:08 +00:00
26 changed files with 836 additions and 705 deletions
--- a/doc/reference.html
+++ b/doc/reference.html
--- a/doc/user.html
+++ b/doc/user.html
@@ -70,6 +70,8 @@ available (and described below).

      <li><a href="#sec_reshape">Changing an Array's Shape</a>

+      <li><a href="#sec_resize">Resizing an Array</a>
+
      <li><a href="#sec_concepts">MultiArray Concept</a>

      <li><a href="#sec_testcases">Test Cases</a>
@@ -154,22 +156,20 @@ main () {
 <a name="sec_components"></a>
 <h2>MultiArray Components</h2>

-Boost.MultiArray provides three user-level class templates:
+Boost.MultiArray's implementation (boost/multi_array.hpp) provides three user-level class templates:

 <ol>
-      <li><a href="./reference.html#multi_array"><tt>multi_array</tt></a> -
-      defined in "boost/multi_array.hpp",
+      <li><a href="./reference.html#multi_array"><tt>multi_array</tt></a>, 

-      <li><a href="./reference.html#multi_array_ref"><tt>multi_array_ref</tt></a> -
-      defined in "boost/multi_array_ref.hpp", and
+      <li><a href="./reference.html#multi_array_ref"><tt>multi_array_ref</tt></a>, and 

-      <li><a href="./reference.html#const_multi_array_ref"><tt>const_multi_array_ref</tt></a>  -
-      defined in "boost/multi_array_ref.hpp"
+      <li><a href="./reference.html#const_multi_array_ref"><tt>const_multi_array_ref</tt></a>  
 </ol>

 <tt>multi_array</tt> is a container template.  When instantiated, it
 allocates space for the number of elements corresponding to the
-dimensions specified at construction time.  
+dimensions specified at construction time.  A <tt>multi_array</tt> may
+also be default constructed and resized as needed.

 <p>
 <tt>multi_array_ref</tt> adapts an existing array of data to provide
@@ -185,8 +185,8 @@ thus wrap pointers of type <i>T const*</i>.
 The three components exhibit very similar behavior.  Aside from
 constructor parameters, <tt>multi_array</tt> and
 <tt>multi_array_ref</tt> export the same interface.
-<tt>const_multi_array_ref</tt> provides only the const portions
-of the <tt>multi_array_ref</tt> interface.
+<tt>const_multi_array_ref</tt> provides only the constness-preserving
+portions of the <tt>multi_array_ref</tt> interface.

 <a name="sec_assignment"></a>
 <h2>Construction and Assignment</h2>
@@ -232,8 +232,9 @@ void my_function() {

 <a name="sec_dimensions"></a>
 <h2>Specifying Array Dimensions</h2>
-When creating one of the Boost.MultiArray components, it is necessary
-to specify both the number of dimensions and the extent of each.
+When creating most of the Boost.MultiArray components, it is necessary
+to specify both the number of dimensions and the extent of each
+(<tt>boost::multi_array</tt> also provides a default constructor).
 Though the number of dimensions is always specified as a template
 parameter, two separate mechanisms have been provided to specify the
 extent of each.
@@ -300,6 +301,14 @@ from the Collection for the N dimensions of the container.
 This can be useful for writing dimension-independent code, and under
 some compilers may yield higher performance than <tt>operator[].</tt>

+<p>
+By default, both of the above element access methods perform range
+checking.  If a supplied index is out of the range defined for an
+array, an assertion will abort the program.  To disable range
+checking (for performance reasons in production releases), define
+the <tt>BOOST_DISABLE_ASSERTS</tt> preprocessor macro prior to
+including multi_array.hpp in your application.
+
 <a name="sec_views"></a>
 <h2>Creating Views</h2>
 Boost.MultiArray provides the facilities for creating a sub-view of an 
@@ -551,6 +560,36 @@ elements contained remains the same.
 <p>
 Note that reshaping an array does not affect the indexing.

+<a name="sec_resize"></a>
+<h2>Resizing an Array</h2>
+
+The <tt>boost::multi_array</tt> class provides an element-preserving
+resize operation.  The number of dimensions must remain the same, but
+the extent of each dimension may be increased and decreased as
+desired.  When an array is made strictly larger, the existing elements
+will be preserved by copying them into the new underlying memory and
+subsequently destructing the elements in the old underlying memory.
+Any new elements in the array are default constructed.  However, if
+the new array size shrinks some of the dimensions, some elements will
+no longer be available.
+
+<h3>Example</h3>
+<blockquote>
+<pre>
+  typedef boost::multi_array&lt;int, 3&gt; array_type;
+  typedef array_type::extent_range range;
+
+  array_type::extent_gen extents;
+  array_type A(extents[3][3][3]);
+  A[0][0][0] = 4;
+  A[2][2][2] = 5;
+  A.resize(extents[2][3][4]);
+  assert(A[0][0][0] == 4);
+  // A[2][2][2] is no longer valid.
+</pre>
+</blockquote>
+
+
 <a name="sec_concepts"></a>
 <h2>MultiArray Concept</h2>
 Boost.MultiArray defines and uses the 
@@ -582,7 +621,7 @@ cases can be found <a href="./test_cases.html">here</a>.
    arrays.

 This library is analogous to 
-<a href="">boost::array</a> in that it augments C style N-dimensional
+<a href="../../array/index.html">boost::array</a> in that it augments C style N-dimensional
 arrays, as <tt>boost::array</tt> does for C one-dimensional arrays.


@@ -624,9 +663,7 @@ arrays, as <tt>boost::array</tt> does for C one-dimensional arrays.
 <a href="mailto:garcia@.cs.indiana.edu">Ronald Garcia</a>
 </address>
 <!-- Created: Fri Jun 29 10:53:07 EST 2001 -->
-<!-- hhmts start -->
-Last modified: Tue Sep 10 11:14:15 EST 2002
-<!-- hhmts end -->
+<!-- hhmts start -->Last modified: Tue Feb  7 17:15:50 EST 2006 <!-- hhmts end -->

 </body>
 </html>
--- a/doc/xml/MultiArray.xml
+++ b/doc/xml/MultiArray.xml
@@ -124,8 +124,8 @@ to describe the MultiArray interface.</para>
 </entry>
 	    </row>
 	    <row>
-	      <entry><literal>a</literal></entry>
-	      <entry>An object of type <literal>A</literal></entry>
+	      <entry><literal>a,b</literal></entry>
+	      <entry>Objects of type <literal>A</literal></entry>
 	    </row>
 	    <row>
 	      <entry><literal>NumDims</literal></entry>
--- a/doc/xml/const_multi_array_ref.xml
+++ b/doc/xml/const_multi_array_ref.xml
@@ -38,21 +38,21 @@ class const_multi_array_ref {
 public:
 // types:
  typedef ValueType                             element;
-  typedef *implementation-defined*              value_type;
-  typedef *implementation-defined*              reference;
-  typedef *implementation-defined*              const_reference;
-  typedef *implementation-defined*              difference_type;
-  typedef *implementation-defined*              iterator;
-  typedef *implementation-defined*              const_iterator;
-  typedef *implementation-defined*              reverse_iterator;
-  typedef *implementation-defined*              const_reverse_iterator;
+  typedef *unspecified*                         value_type;
+  typedef *unspecified*                         reference;
+  typedef *unspecified*                         const_reference;
+  typedef *unspecified*                         difference_type;
+  typedef *unspecified*                         iterator;
+  typedef *unspecified*                         const_iterator;
+  typedef *unspecified*                         reverse_iterator;
+  typedef *unspecified*                         const_reverse_iterator;
  typedef multi_array_types::size_type          size_type;
  typedef multi_array_types::index              index;
  typedef multi_array_types::index_gen          index_gen;
  typedef multi_array_types::index_range        index_range;
  typedef multi_array_types::extent_gen         extent_gen;
  typedef multi_array_types::extent_range       extent_range;
-  typedef *implementation-defined*              storage_order_type;
+  typedef *unspecified*                         storage_order_type;
  
  // template typedefs
  template <std::size_t Dims> struct            subarray;
--- a/doc/xml/main.xml
+++ b/doc/xml/main.xml
@@ -1,71 +0,0 @@
-<?xml version='1.0' encoding="ISO-Latin-1" ?>
-<!DOCTYPE article 
-  PUBLIC  "-//OASIS//DTD DocBook XML MathML V4.1.2//EN" 
-  "/u/garcia/docbook-xml/docbookx.dtd"
->
-
-<article>
-  <articleinfo>
-    <title>Class template <literal>multi_array</literal></title>
-    <author>
-      <surname>Garcia</surname><firstname>Ronald</firstname>
-      <affiliation>
-	<orgname>Indiana University</orgname>
-	<orgdiv>Open Systems Lab</orgdiv>
-      </affiliation>
-    </author>
-    <orgname>BOOST</orgname>
-    <copyright>
-      <year>2002</year>
-      <holder>Ronald Garcia</holder>
-    </copyright>
-    <legalnotice>
-      <para>blah blah legal blah blah</para>
-    </legalnotice>
-    <revhistory>
-      <revision>
-	<revnumber>1</revnumber>
-	<date>1/18/2002</date>
-	<revdescription>
-	  <simpara>Initial Revision.</simpara>
-	</revdescription>
-      </revision>
-    </revhistory>
-  </articleinfo>
-
-
-Boost.MultiArray
-
-Headers boost/multi_array.hpp and
-boost/multi_array_ref.hpp
-
-
-Motivation
-Examples
-Tutorial
-Reference Manual
-Comparison to Other Libraries
-Performance
-Portability
-Design Rationale
-Acknowledgements
-FAQ
-
-
-Motivation
-
-Examples
-
-*Insert examples here*
-
-
-(External Tutorial)
-(External Reference Manual)
-
-
-Comparison to Other Libraries
-Performance
-Portability
-Design Rationale
-Acknowledgements
-FAQ
--- a/doc/xml/multi_array.xml
+++ b/doc/xml/multi_array.xml
@@ -36,21 +36,21 @@ class multi_array {
 public:
 // types:
  typedef ValueType                             element;
-  typedef *implementation-defined*              value_type;
-  typedef *implementation-defined*              reference;
-  typedef *implementation-defined*              const_reference;
-  typedef *implementation-defined*              difference_type;
-  typedef *implementation-defined*              iterator;
-  typedef *implementation-defined*              const_iterator;
-  typedef *implementation-defined*              reverse_iterator;
-  typedef *implementation-defined*              const_reverse_iterator;
+  typedef *unspecified*                         value_type;
+  typedef *unspecified*                         reference;
+  typedef *unspecified*                         const_reference;
+  typedef *unspecified*                         difference_type;
+  typedef *unspecified*                         iterator;
+  typedef *unspecified*                         const_iterator;
+  typedef *unspecified*                         reverse_iterator;
+  typedef *unspecified*                         const_reverse_iterator;
  typedef multi_array_types::size_type          size_type;
  typedef multi_array_types::index              index;
  typedef multi_array_types::index_gen          index_gen;
  typedef multi_array_types::index_range        index_range;
  typedef multi_array_types::extent_gen         extent_gen;
  typedef multi_array_types::extent_range       extent_range;
-  typedef *implementation-defined*              storage_order_type;
+  typedef *unspecified*                         storage_order_type;
  

  // template typedefs
@@ -136,7 +136,9 @@ public:
  template <typename SizeList>
    void			reshape(const SizeList& sizes)
  template <typename BaseList>	void reindex(const BaseList& values);
-  void				reindex(index value);
+    void			reindex(index value);
+  template <typename ExtentList>
+    multi_array&		resize(const ExtentList& extents);
  multi_array&                  resize(extents_tuple& extents);
 };
 ]]>
@@ -327,15 +329,20 @@ O(<literal>this->num_elements()</literal>) calls to

 <varlistentry>
 <term>
-<programlisting><![CDATA[multi_array& resize(extent_gen::gen_type<NumDims>::type ranges);]]>
+<programlisting><![CDATA[multi_array& resize(extent_gen::gen_type<NumDims>::type extents);
+template <typename ExtentList>
+  multi_array& resize(const ExtentList& extents);
+]]>
 </programlisting></term> 
 <listitem>
 <para>
-This function resizes an array to the shape specified by 
-<literal>ranges</literal>. The contents of the array are preserved 
-whenever possible; if the new array size is smaller, then some data will 
-be lost. Any new elements created by resizing the array are initialized with 
-the <literal>element</literal> default constructor.
+This function resizes an array to the shape specified by
+<literal>extents</literal>, which is either a generated list of
+extents or a model of the <literal>Collection</literal> concept. The
+contents of the array are preserved whenever possible; if the new
+array size is smaller, then some data will be lost. Any new elements
+created by resizing the array are initialized with the
+<literal>element</literal> default constructor.
 </para>
 </listitem>
 </varlistentry> 
--- a/doc/xml/reference.xml
+++ b/doc/xml/reference.xml
@@ -50,13 +50,13 @@ brings the following declarations into scope:</para>
 <![CDATA[namespace boost {
  
  namespace multi_array_types {
-    typedef *implementation-defined* index;
-    typedef *implementation-defined* size_type;
-    typedef *implementation-defined* difference_type;
-    typedef *implementation-defined* index_range;
-    typedef *implementation-defined* extent_range;
-    typedef *implementation-defined* index_gen;
-    typedef *implementation-defined* extent_gen;
+    typedef *unspecified* index;
+    typedef *unspecified* size_type;
+    typedef *unspecified* difference_type;
+    typedef *unspecified* index_range;
+    typedef *unspecified* extent_range;
+    typedef *unspecified* index_gen;
+    typedef *unspecified* extent_gen;
  }

  template <typename ValueType, 
@@ -343,13 +343,13 @@ std::count_if(this->index_bases(),this->index_bases()+this->num_dimensions(),

 <programlisting>
 <![CDATA[namespace multi_array_types {
-  typedef *implementation-defined* index;
-  typedef *implementation-defined* size_type;
-  typedef *implementation-defined* difference_type;
-  typedef *implementation-defined* index_range;
-  typedef *implementation-defined* extent_range;
-  typedef *implementation-defined* index_gen;
-  typedef *implementation-defined* extent_gen;
+  typedef *unspecified* index;
+  typedef *unspecified* size_type;
+  typedef *unspecified* difference_type;
+  typedef *unspecified* index_range;
+  typedef *unspecified* extent_range;
+  typedef *unspecified* index_gen;
+  typedef *unspecified* extent_gen;
 }]]>
 </programlisting>

@@ -779,6 +779,20 @@ order in which dimensions are stored.
 </para>  

 </sect3>
+</sect2>
+
+<sect2 id="range_checking">
+<title>Range Checking</title>
+<para>
+By default, the array access methods <literal>operator()</literal> and
+<literal>operator[]</literal> perform range
+checking.  If a supplied index is out of the range defined for an
+array, an assertion will abort the program.  To disable range
+checking (for performance reasons in production releases), define
+the <literal>BOOST_DISABLE_ASSERTS</literal> preprocessor macro prior to
+including multi_array.hpp in an application.
+</para>
+
 </sect2>
 </sect1>

--- a/include/boost/multi_array.hpp
+++ b/include/boost/multi_array.hpp
@@ -42,9 +42,10 @@ namespace boost {

      struct populate_index_ranges {
        multi_array_types::index_range
+        // RG: underscore on extent_ to stifle strange MSVC warning.
        operator()(multi_array_types::index base,
-                   multi_array_types::size_type extent) {
-          return multi_array_types::index_range(base,base+extent);
+                   multi_array_types::size_type extent_) {
+          return multi_array_types::index_range(base,base+extent_);
        }
      };

@@ -379,12 +380,30 @@ public:
  }


+  template <typename ExtentList>
+  multi_array& resize(const ExtentList& extents) {
+    boost::function_requires<
+      detail::multi_array::CollectionConcept<ExtentList> >();
+
+    typedef detail::multi_array::extent_gen<NumDims> gen_type;
+    gen_type ranges;
+
+    for (int i=0; i != NumDims; ++i) {
+      typedef typename gen_type::range range_type;
+      ranges.ranges_[i] = range_type(0,extents[i]);
+    }
+    
+    return this->resize(ranges);
+  }
+
+
+
  multi_array& resize(const detail::multi_array
                      ::extent_gen<NumDims>& ranges) {


    // build a multi_array with the specs given
-    multi_array new_array(ranges);
+    multi_array new_array(ranges,this->storage_order());


    // build a view of tmp with the minimum extents
--- a/include/boost/multi_array/base.hpp
+++ b/include/boost/multi_array/base.hpp
@@ -25,6 +25,7 @@
 #include "boost/multi_array/storage_order.hpp"
 #include "boost/multi_array/types.hpp"
 #include "boost/config.hpp"
+#include "boost/multi_array/concept_checks.hpp" //for ignore_unused_...
 #include "boost/mpl/eval_if.hpp"
 #include "boost/mpl/if.hpp"
 #include "boost/mpl/size_t.hpp"
@@ -32,7 +33,7 @@
 #include "boost/iterator/reverse_iterator.hpp"
 #include "boost/static_assert.hpp"
 #include "boost/type.hpp"
-#include <cassert>
+#include "boost/assert.hpp"
 #include <cstddef>
 #include <memory>

@@ -129,11 +130,13 @@ protected:
  Reference access(boost::type<Reference>,index idx,TPtr base,
                   const size_type* extents,
                   const index* strides,
-                   const index* index_base) const {
+                   const index* index_bases) const {

+    BOOST_ASSERT(idx - index_bases[0] >= 0);
+    BOOST_ASSERT(size_type(idx - index_bases[0]) < extents[0]);
    // return a sub_array<T,NDims-1> proxy object
    TPtr newbase = base + idx * strides[0];
-    return Reference(newbase,extents+1,strides+1,index_base+1);
+    return Reference(newbase,extents+1,strides+1,index_bases+1);

  }

@@ -165,9 +168,14 @@ protected:
  // used by array operator[] and iterators to get reference types.
  template <typename Reference, typename TPtr>
  Reference access(boost::type<Reference>,index idx,TPtr base,
-                   const size_type*,
+                   const size_type* extents,
                   const index* strides,
-                   const index*) const {
+                   const index* index_bases) const {
+
+    ignore_unused_variable_warning(index_bases);
+    ignore_unused_variable_warning(extents);
+    BOOST_ASSERT(idx - index_bases[0] >= 0);
+    BOOST_ASSERT(size_type(idx - index_bases[0]) < extents[0]);
    return *(base + idx * strides[0]);
  }

@@ -201,7 +209,7 @@ struct value_accessor_generator {
  >::type type;
 };

-#if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)

 struct eti_value_accessor
 {
@@ -251,7 +259,7 @@ struct associated_types
 template <typename T, std::size_t NumDims>
 class multi_array_impl_base
  :
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
      public mpl::aux::msvc_eti_base<
          typename value_accessor_generator<T,mpl::size_t<NumDims> >::type
       >::type
@@ -307,9 +315,22 @@ protected:

  // Used by operator() in our array classes
  template <typename Reference, typename IndexList, typename TPtr>
-  Reference access_element(boost::type<Reference>, TPtr base,
+  Reference access_element(boost::type<Reference>,
                           const IndexList& indices,
-                           const index* strides) const {
+                           TPtr base,
+                           const size_type* extents,
+                           const index* strides,
+                           const index* index_bases) const {
+
+    ignore_unused_variable_warning(index_bases);
+    ignore_unused_variable_warning(extents);
+#if !defined(NDEBUG) && !defined(BOOST_DISABLE_ASSERTS)
+    for (size_type i = 0; i != NumDims; ++i) {
+      BOOST_ASSERT(indices[i] - index_bases[i] >= 0);
+      BOOST_ASSERT(size_type(indices[i] - index_bases[i]) < extents[i]);
+    }
+#endif
+
    index offset = 0;
    for (size_type n = 0; n != NumDims; ++n) 
      offset += indices[n] * strides[n];
@@ -418,6 +439,12 @@ protected:
      index index_factor = current_range.stride();
      index len = (finish - start + (index_factor - 1)) / index_factor;

+      BOOST_ASSERT(index_bases[n] <= start &&
+                   start <= index_bases[n]+index(extents[n]));
+      BOOST_ASSERT(index_bases[n] <= finish &&
+                   finish <= index_bases[n]+index(extents[n]));
+      BOOST_ASSERT(index_factor > 0);
+
      // the array data pointer is modified to account for non-zero
      // bases during slicing (see [Garcia] for the math involved)
      offset += start * strides[n];
@@ -433,7 +460,7 @@ protected:
        ++dim;
      }
    }
-    assert (dim == NDims);
+    BOOST_ASSERT(dim == NDims);

    return
      ArrayRef(base+offset,
--- a/include/boost/multi_array/extent_gen.hpp
+++ b/include/boost/multi_array/extent_gen.hpp
@@ -29,8 +29,8 @@ class extent_gen {
 public:
  typedef boost::detail::multi_array::index index;
  typedef boost::detail::multi_array::size_type size_type;
-private:
  typedef extent_range<index,size_type> range;
+private:
  typedef typename range_list_generator<range,NumRanges>::type range_list;
 public:
  template <std::size_t Ranges>
--- a/include/boost/multi_array/index_gen.hpp
+++ b/include/boost/multi_array/index_gen.hpp
@@ -28,9 +28,9 @@ namespace multi_array {
 template <int NumRanges, int NumDims>
 struct index_gen {
 private:
-  typedef ::boost::detail::multi_array::index Index;
-  typedef std::size_t SizeType;
-  typedef index_range<Index,SizeType> range;
+  typedef ::boost::detail::multi_array::index index;
+  typedef ::boost::detail::multi_array::size_type size_type;
+  typedef index_range<index,size_type> range;
 public:
  template <int Dims, int Ranges>
  struct gen_type {
@@ -44,27 +44,27 @@ public:

  template <int ND>
  explicit index_gen(const index_gen<NumRanges-1,ND>& rhs,
-            const index_range<Index,SizeType>& range)
+            const range& r)
  {
    std::copy(rhs.ranges_.begin(),rhs.ranges_.end(),ranges_.begin());
-    *ranges_.rbegin() = range;
+    *ranges_.rbegin() = r;
  }

  index_gen<NumRanges+1,NumDims+1>
-  operator[](const index_range<Index,SizeType>& range) const
+  operator[](const range& r) const
  {
    index_gen<NumRanges+1,NumDims+1> tmp;
    std::copy(ranges_.begin(),ranges_.end(),tmp.ranges_.begin());
-    *tmp.ranges_.rbegin() = range;
+    *tmp.ranges_.rbegin() = r;
    return tmp;
  }

  index_gen<NumRanges+1,NumDims>
-  operator[](Index idx) const
+  operator[](index idx) const
  {
    index_gen<NumRanges+1,NumDims> tmp;
    std::copy(ranges_.begin(),ranges_.end(),tmp.ranges_.begin());
-    *tmp.ranges_.rbegin() = index_range<Index,SizeType>(idx);
+    *tmp.ranges_.rbegin() = range(idx);
    return tmp;
  }    

--- a/include/boost/multi_array/index_range.hpp
+++ b/include/boost/multi_array/index_range.hpp
@@ -35,6 +35,15 @@ namespace multi_array {
    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();
@@ -46,7 +55,7 @@ namespace multi_array {
    explicit index_range(index pos)
    {
      start_ = pos;
-      finish_ = pos;
+      finish_ = pos+1;
      stride_ = 1;
      degenerate_ = true;
    }
@@ -60,13 +69,13 @@ namespace multi_array {
    // These are for chaining assignments to an index_range
    index_range& start(index s) {
      start_ = s;
-      degenerate_ = (start_ == finish_);
+      degenerate_ = false;
      return *this;
    }

    index_range& finish(index f) {
      finish_ = f;
-      degenerate_ = (start_ == finish_);
+      degenerate_ = false;
      return *this;
    }

@@ -77,7 +86,7 @@ namespace multi_array {
      return start_; 
    }

-    index get_start(index low_index_range = 0) const
+    index get_start(index low_index_range = index_range::from_start()) const
    { 
      if (start_ == from_start())
        return low_index_range;
@@ -89,28 +98,15 @@ namespace multi_array {
      return finish_;
    }

-    index get_finish(index high_index_range = 0) const
+    index get_finish(index high_index_range = index_range::to_end()) const
    {
      if (finish_ == to_end())
        return high_index_range;
      return finish_;
    }

-    size_type size(index recommended_length = 0) const
-    {
-      if ((start_ == from_start()) || (finish_ == to_end()))
-        return recommended_length;
-      else 
-        return (finish_ - start_) / stride_;
-    }
-
    index stride() const { return stride_; }

-    bool is_ascending_contiguous() const
-    {
-      return (start_ < finish_) && is_unit_stride();
-    }
-
    void set_index_range(index start, index finish, index stride=1)
    {
      start_ = start;
@@ -121,9 +117,6 @@ namespace multi_array {
    static index_range all() 
    { return index_range(from_start(), to_end(), 1); }

-    bool is_unit_stride() const
-    { return stride_ == 1; }
-
    bool is_degenerate() const { return degenerate_; }

    index_range operator-(index shift) const
@@ -148,12 +141,6 @@ namespace multi_array {

    // add conversion to std::slice?

-  private:
-    static index from_start()
-      { return (std::numeric_limits<index>::min)(); }
-
-    static index to_end()
-      { return (std::numeric_limits<index>::max)(); }
  public:
    index start_, finish_, stride_;
    bool degenerate_;
--- a/include/boost/multi_array/iterator.hpp
+++ b/include/boost/multi_array/iterator.hpp
@@ -21,6 +21,7 @@
 #include "boost/multi_array/base.hpp"
 #include "boost/iterator/iterator_facade.hpp"
 #include "boost/mpl/aux_/msvc_eti_base.hpp"
+#include <algorithm>
 #include <cstddef>
 #include <iterator>

@@ -56,11 +57,11 @@ class array_iterator
      , Reference
    >
    , private
-#if BOOST_WORKAROUND(BOOST_MSVC,==1200)
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
      mpl::aux::msvc_eti_base<typename 
 #endif 
          value_accessor_generator<T,NumDims>::type
-#if BOOST_WORKAROUND(BOOST_MSVC,==1200)
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
      >::type
 #endif 
 {
@@ -137,11 +138,15 @@ public:

  template <class IteratorAdaptor>
  bool equal(IteratorAdaptor& rhs) const {
+    const std::size_t N = NumDims::value;
    return (idx_ == rhs.idx_) &&
      (base_ == rhs.base_) &&
-      (extents_ == rhs.extents_) &&
-      (strides_ == rhs.strides_) &&
-      (index_base_ == rhs.index_base_);
+      ( (extents_ == rhs.extents_) ||
+        std::equal(extents_,extents_+N,rhs.extents_) ) &&
+      ( (strides_ == rhs.strides_) ||
+        std::equal(strides_,strides_+N,rhs.strides_) ) &&
+      ( (index_base_ == rhs.index_base_) ||
+        std::equal(index_base_,index_base_+N,rhs.index_base_) );
  }

  template <class DifferenceType>
--- a/include/boost/multi_array/multi_array_ref.hpp
+++ b/include/boost/multi_array/multi_array_ref.hpp
@@ -25,6 +25,7 @@
 #include "boost/multi_array/subarray.hpp"
 #include "boost/multi_array/view.hpp"
 #include "boost/multi_array/algorithm.hpp"
+#include "boost/type_traits/is_integral.hpp"
 #include "boost/array.hpp"
 #include "boost/concept_check.hpp"
 #include "boost/functional.hpp"
@@ -137,7 +138,13 @@ public:
  }

  template <class BaseList>
-  void reindex(const BaseList& values) {
+#ifdef BOOST_NO_SFINAE
+  void
+#else
+  typename
+  disable_if<typename boost::is_integral<BaseList>::type,void >::type
+#endif // BOOST_NO_SFINAE
+  reindex(const BaseList& values) {
    boost::function_requires<
      detail::multi_array::CollectionConcept<BaseList> >();
    boost::detail::multi_array::
@@ -206,8 +213,8 @@ public:
    boost::function_requires<
      detail::multi_array::CollectionConcept<IndexList> >();
    return super_type::access_element(boost::type<const element&>(),
-                                      origin(),
-                                      indices,strides());
+                                      indices,origin(),
+                                      shape(),strides(),index_bases());
  }

  // Only allow const element access
@@ -503,11 +510,12 @@ public:

  template <class IndexList>
  element& operator()(const IndexList& indices) {
-  boost::function_requires<
-    detail::multi_array::CollectionConcept<IndexList> >();
-  return super_type::access_element(boost::type<element&>(),
-                                      origin(),
-                                      indices,this->strides());
+    boost::function_requires<
+      detail::multi_array::CollectionConcept<IndexList> >();
+    return super_type::access_element(boost::type<element&>(),
+                                      indices,origin(),
+                                      this->shape(),this->strides(),
+                                      this->index_bases());
  }


--- a/include/boost/multi_array/subarray.hpp
+++ b/include/boost/multi_array/subarray.hpp
@@ -79,9 +79,11 @@ public:
  
  template <typename IndexList>
  const element& operator()(const IndexList& indices) const {
+    boost::function_requires<
+      detail::multi_array::CollectionConcept<IndexList> >();
    return super_type::access_element(boost::type<const element&>(),
-                                      origin(),
-                                      indices,strides());
+                                      indices,origin(),
+                                      shape(),strides(),index_bases());
  }

  // see generate_array_view in base.hpp
@@ -284,9 +286,12 @@ public:

  template <class IndexList>
  element& operator()(const IndexList& indices) {
+    boost::function_requires<
+      detail::multi_array::CollectionConcept<IndexList> >();
    return super_type::access_element(boost::type<element&>(),
-                                      origin(),
-                                      indices,this->strides());
+                                      indices,origin(),
+                                      this->shape(),this->strides(),
+                                      this->index_bases());
  }

  iterator begin() {
@@ -316,6 +321,8 @@ public:

  template <class IndexList>
  const element& operator()(const IndexList& indices) const {
+    boost::function_requires<
+      detail::multi_array::CollectionConcept<IndexList> >();
    return super_type::operator()(indices);
  }

--- a/include/boost/multi_array/types.hpp
+++ b/include/boost/multi_array/types.hpp
@@ -26,7 +26,7 @@ namespace multi_array{

 // needed typedefs
 typedef std::size_t size_type;
-typedef int index;
+typedef std::ptrdiff_t index;

 } // namespace multi_array
 } // namespace detail
--- a/include/boost/multi_array/view.hpp
+++ b/include/boost/multi_array/view.hpp
@@ -23,6 +23,7 @@
 #include "boost/multi_array/storage_order.hpp"
 #include "boost/multi_array/subarray.hpp"
 #include "boost/multi_array/algorithm.hpp"
+#include "boost/type_traits/is_integral.hpp"
 #include "boost/array.hpp"
 #include "boost/limits.hpp"
 #include <algorithm>
@@ -72,7 +73,15 @@ public:


  template <class BaseList>
-  void reindex(const BaseList& values) {
+#ifdef BOOST_NO_SFINAE
+  void
+#else
+  typename
+  disable_if<typename boost::is_integral<BaseList>::type,void >::type
+#endif
+  reindex(const BaseList& values) {
+    boost::function_requires<
+      detail::multi_array::CollectionConcept<BaseList> >();
    boost::detail::multi_array::
      copy_n(values.begin(),num_dimensions(),index_base_list_.begin());
    origin_offset_ =
@@ -109,9 +118,11 @@ public:

  template <typename IndexList>
  const element& operator()(IndexList indices) const {
+    boost::function_requires<
+      detail::multi_array::CollectionConcept<IndexList> >();
    return super_type::access_element(boost::type<const element&>(),
-                                      origin(),
-                                      indices,strides());
+                                      indices,origin(),
+                                      shape(),strides(),index_bases());
  }

  // Only allow const element access
@@ -318,9 +329,12 @@ public:

  template <class IndexList>
  element& operator()(const IndexList& indices) {
+    boost::function_requires<
+      detail::multi_array::CollectionConcept<IndexList> >();
    return super_type::access_element(boost::type<element&>(),
-                                      origin(),
-                                      indices,this->strides());
+                                      indices,origin(),
+                                      this->shape(),this->strides(),
+                                      this->index_bases());
  }


@@ -379,6 +393,8 @@ public:

  template <class IndexList>
  const element& operator()(const IndexList& indices) const {
+    boost::function_requires<
+      detail::multi_array::CollectionConcept<IndexList> >();
    return super_type::operator()(indices);
  }

--- a/index.html
+++ b/index.html
@@ -4,6 +4,10 @@
 </head>
 <body>
 Automatic redirection failed, please go to
-<a href="doc/index.html">doc/index.html</a>.
+<a href="doc/index.html">doc/index.html</a>.&nbsp;<hr>
+<p>© Copyright Beman Dawes, 2001</p>
+<p>Distributed under the Boost Software License, Version 1.0. (See accompanying 
+file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy 
+at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
 </body>
 </html>
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -1,51 +0,0 @@
-# Copyright David Abrahams 2003. Permission to copy, use,
-# modify, sell and distribute this software is granted provided this
-# copyright notice appears in all copies. This software is provided
-# "as is" without express or implied warranty, and with no claim as
-# to its suitability for any purpose.
-
-subproject libs/multi_array/test ;
-
-import testing ;
-
-test-suite multi_array
-    : 
-      [ compile-fail fail_cbracket.cpp ]
-      [ compile-fail fail_cdata.cpp ]
-      [ compile-fail fail_citerator.cpp ]
-      [ compile-fail fail_cparen.cpp ]
-      [ compile-fail fail_criterator.cpp ]
-      [ compile-fail fail_csubarray.cpp ]
-      [ compile-fail fail_csubarray2.cpp ]
-      [ compile-fail fail_csubarray3.cpp ]
-      [ compile-fail fail_cview.cpp ]
-      [ compile-fail fail_cview2.cpp ]
-      [ compile-fail fail_cview3.cpp ]
-      [ compile-fail fail_ref_cbracket.cpp ]
-      [ compile-fail fail_ref_cdata.cpp ]
-      [ compile-fail fail_ref_citerator.cpp ]
-      [ compile-fail fail_ref_cparen.cpp ]
-      [ compile-fail fail_ref_criterator.cpp ]
-      [ compile-fail fail_ref_csubarray.cpp ]
-      [ compile-fail fail_ref_csubarray2.cpp ]
-      [ compile-fail fail_ref_csubarray3.cpp ]
-      [ compile-fail fail_ref_cview.cpp ]
-      [ compile-fail fail_ref_cview2.cpp ]
-      [ compile-fail fail_ref_cview3.cpp ]
-  
-      [ run constructors.cpp ]
-      [ run access.cpp ]
-      [ run compare.cpp ]
-      [ run iterators.cpp ]
-      [ run slice.cpp ]
-      [ run assign.cpp ]
-      [ run assign_to_array.cpp ]
-      [ run index_bases.cpp ]
-      [ run storage_order.cpp ]
-      [ run reshape.cpp ]
-      [ run range1.cpp  ]
-      [ run idxgen1.cpp ]
-      [ run stl_interaction.cpp ]
-      [ run resize.cpp ]
-      [ compile concept_checks.cpp ]
-    ;
--- a/test/access.cpp
+++ b/test/access.cpp
@@ -47,9 +47,9 @@ void access(Array& A, const const_array_tag&) {
      }

  // operator()
-  for (index i2 = 0; i2 != 2; ++i2)
-    for (index j2 = 0; j2 != 3; ++j2)
-      for (index k2 = 0; k2 != 4; ++k2) {
+  for (index i2 = idx0; i2 != idx0+2; ++i2)
+    for (index j2 = idx1; j2 != idx1+3; ++j2)
+      for (index k2 = idx2; k2 != idx2+4; ++k2) {
        boost::array<index,ndims> indices;
        indices[0] = i2; indices[1] = j2; indices[2] = k2;
        BOOST_CHECK(A(indices) == A[i2][j2][k2]);
--- a/test/generative_tests.hpp
+++ b/test/generative_tests.hpp
@@ -49,6 +49,7 @@

 #include "boost/test/minimal.hpp"

+#include <boost/config.hpp> /* BOOST_NO_SFINAE */
 #include <algorithm>
 #include <iostream>
 #include <vector>
@@ -238,7 +239,14 @@ struct null_modifier {

 struct set_index_base_modifier {
  template <typename Array>
-  void modify(Array& A) const { A.reindex(1); }
+  void modify(Array& A) const {
+#ifdef BOOST_NO_SFINAE
+    typedef boost::multi_array_types::index index;
+    A.reindex(index(1));
+#else
+    A.reindex(1);
+#endif 
+  }
 };

 struct reindex_modifier {
--- a/test/idxgen1.cpp
+++ b/test/idxgen1.cpp
@@ -16,21 +16,20 @@

 #include "boost/multi_array/index_gen.hpp"
 #include "boost/multi_array/index_range.hpp"
-
+#include "boost/multi_array/types.hpp"
 #include "boost/test/minimal.hpp"

 #include "boost/array.hpp"
-#include <cstddef>

+typedef boost::detail::multi_array::index index_type;
+typedef boost::detail::multi_array::size_type size_type;
+typedef boost::detail::multi_array::index_range<index_type,size_type> range;

 template <int NumRanges, int NumDims>
 void check(const boost::detail::multi_array::
           index_gen<NumRanges,NumDims>&) { }

-bool operator==(const boost::detail::multi_array::
-                index_range<int,std::size_t>& lhs,
-                const boost::detail::multi_array::
-                index_range<int,std::size_t>& rhs) {
+bool operator==(const range& lhs,const range& rhs) {  
  return lhs.start_ == rhs.start_ &&
    lhs.finish_ == rhs.finish_ &&
    lhs.stride_ == rhs.stride_ &&
@@ -40,7 +39,6 @@ bool operator==(const boost::detail::multi_array::
 int
 test_main(int,char*[])
 {
-  typedef boost::detail::multi_array::index_range<int,std::size_t> range;

  boost::detail::multi_array::index_gen<0,0> indices;

--- a/test/index_bases.cpp
+++ b/test/index_bases.cpp
@@ -62,7 +62,7 @@ test_main(int,char*[])
    boost::array<int,3> bases = { { 1, 2, 3 } };
    for (size_type a = 0; a < A.shape()[0]; ++a)
      for (size_type b = 0; b < A.shape()[1]; ++b)
-        for (size_type c = 0; c < A[b].size(); ++c) {
+        for (size_type c = 0; c < A.shape()[2]; ++c) {
          BOOST_CHECK(A[a+bases[0]][b+bases[1]][c+bases[2]] == B[a][b][c]);
          BOOST_CHECK(C[a+bases[0]][b+bases[1]][c+bases[2]] == B[a][b][c]);
          BOOST_CHECK(D[a+bases[0]][b+bases[1]][c+bases[2]] == B[a][b][c]);
@@ -126,10 +126,18 @@ test_main(int,char*[])
    B.assign(vals.begin(),vals.end());
    C.assign(vals.begin(),vals.end());

+#ifdef BOOST_NO_SFINAE
+    typedef boost::multi_array_types::index index;
+    A.reindex(index(1));
+    C.reindex(index(1));
+    D.reindex(index(1));
+    E.reindex(index(1));
+#else
    A.reindex(1);
    C.reindex(1);
    D.reindex(1);
    E.reindex(1);
+#endif

    for (size_type a = 0; a < A.shape()[0]; ++a)
      for (size_type b = 0; b < A.shape()[1]; ++b)
--- a/test/range1.cpp
+++ b/test/range1.cpp
@@ -50,7 +50,7 @@ test_main(int,char*[])
    // degenerate creation
    range r3(5);
    BOOST_CHECK(r3.start() == 5);
-    BOOST_CHECK(r3.finish() == 5);
+    BOOST_CHECK(r3.finish() == 6);
    BOOST_CHECK(r3.stride() == 1);
    BOOST_CHECK(r3.is_degenerate());
  }
--- a/test/resize.cpp
+++ b/test/resize.cpp
@@ -35,13 +35,6 @@ int test_main(int,char*[]) {
    20,21,22,23
  };

-
-  marray A(boost::extents[2][3][4]);
-
-  A.assign(A_data,A_data+(2*3*4));
-
-  A.resize(boost::extents[4][3][2]);
-  
  int A_resize[] = {
    0,1,
    4,5,
@@ -60,14 +53,67 @@ int test_main(int,char*[]) {
    0,0
  };

-  BOOST_CHECK(std::equal(A_resize,A_resize+(4*3*2),A.data()));
+  // resize through the extent_gen interface
+  {
+    marray A(boost::extents[2][3][4]);
+    A.assign(A_data,A_data+(2*3*4));
+    A.resize(boost::extents[4][3][2]);
+    BOOST_CHECK(std::equal(A_resize,A_resize+(4*3*2),A.data()));
+  }  

+  // resize through the Collection
+  {
+    marray A(boost::extents[2][3][4]);
+    A.assign(A_data,A_data+(2*3*4));
+    boost::array<int,3> new_extents = {{4,3,2}};
+    A.resize(new_extents);
+    BOOST_CHECK(std::equal(A_resize,A_resize+(4*3*2),A.data()));
+  }  

+  // default construct all the new elements (in this case, all elements)
  {
    marray defaultA;
    defaultA.resize(boost::extents[2][3][4]);
    BOOST_CHECK(std::accumulate(defaultA.data(),
                               defaultA.data()+(2*3*4),0) == 0);
  }
+
+
+
+  // verify the preservation of storage order
+  {
+    int tiling_graph_storage_order[] = {2, 0, 1}; 
+    bool tiling_graph_index_order[] = {true, true, true};
+  
+    marray A(boost::extents[3][4][2],
+             boost::general_storage_order<3>(tiling_graph_storage_order,
+                                             tiling_graph_index_order)); 
+
+
+    int value = 0;
+    for (int i = 0; i < 3; i++) {
+      for (int j = 0; j < 4; j++) {
+        for (int k = 0; k < 2; k++) {
+          *(A.data() + value) = value;
+          ++value;
+        }
+      }
+    }
+
+    // "Resize" to the same size
+    A.resize(boost::extents[3][4][2]);
+
+    int check = 0;
+    for (int x = 0; x < 3; x++) { 
+      for (int y = 0; y < 4; y++) {
+        for (int z = 0; z < 2; z++) {
+          BOOST_CHECK(*(A.data() + check) == check);
+          ++check;
+        }
+      }
+    }
+  }
+
+
  return boost::exit_success;
 }
--- a/test/storage_order_convert.cpp
+++ b/test/storage_order_convert.cpp
@@ -35,5 +35,5 @@ test_main(int,char*[]) {
  BOOST_TEST(fortran_storage ==
             (general_storage_order<5>) fortran_storage_order());

-  return boost::exit_success;
+  return boost::report_errors();
 }
Author	SHA1	Message	Date
nobody	06b076cd3e	This commit was manufactured by cvs2svn to create tag 'Version_1_34_1'. [SVN r38286]	2007-07-24 19:28:14 +00:00
Dave Abrahams	618aae50a3	Correct testing bugs: either changing assert(...) or BOOST_ASSERT(...) to BOOST_TEST (in my code only) or adding "return boost::report_errors();" where it was clearly missing (and a pure bug, in anyone's code). or changing BOOST_TEST to BOOST_CHECK where the integer library was clearly using Boost.Test and not returning report_errors(). [SVN r37063]	2007-02-25 15:28:02 +00:00
Beman Dawes	e5b2e16a7f	Merged copyright and license addition [SVN r35907]	2006-11-07 19:27:00 +00:00
Rene Rivera	d8b3172696	Remove obsolete Boost.Build v1 files. [SVN r35880]	2006-11-06 17:10:46 +00:00
Ronald Garcia	3cb8546302	CW 8.3 workaround. [SVN r34433]	2006-06-30 15:14:08 +00:00
Ronald Garcia	9398e7799a	Backpatching fixes to the documentation from HEAD. [SVN r34410]	2006-06-26 16:58:28 +00:00
Ronald Garcia	24bc73dfae	Applied patch broke MSVC 7.1 and 8.0 [SVN r34409]	2006-06-26 16:40:21 +00:00
Joaquín M. López Muñoz	1d0a63035d	merged from trunk to branch [SVN r34407]	2006-06-26 06:49:50 +00:00
Ronald Garcia	d4f813c882	Changed variable names for vc-6_5. [SVN r34199]	2006-06-06 18:15:33 +00:00
Ronald Garcia	cd0639452c	Merging iterator bug fix into 1.34 release. [SVN r34130]	2006-05-31 20:59:58 +00:00
nobody	a212ac088d	This commit was manufactured by cvs2svn to create branch 'RC_1_34_0'. [SVN r33417]	2006-03-21 02:26:31 +00:00
Ronald Garcia	9c71529cb5	Added support to resize multi_array objects by passing in a Collection. [SVN r33262]	2006-03-07 22:27:34 +00:00
Ronald Garcia	59733752f3	Fixed a bug in resize. It was losing storage order. [SVN r33239]	2006-03-06 20:57:48 +00:00
Ronald Garcia	150fcf9a59	Added another test for resize preserving storage order. [SVN r33238]	2006-03-06 20:57:23 +00:00
Ronald Garcia	ecf3435632	Fix for codewarrior. [SVN r33205]	2006-03-02 21:30:15 +00:00
Ronald Garcia	96cb60865f	Fix for MSVC 6.5. [SVN r33029]	2006-02-20 17:13:01 +00:00
Ronald Garcia	60b55bea12	Cleaned up index_range implementation a bit. [SVN r32968]	2006-02-16 17:42:30 +00:00
Ronald Garcia	b8c8674369	forgot to account for empty arrays (used during resizing). [SVN r32929]	2006-02-14 19:53:38 +00:00
Ronald Garcia	e977bb77b5	Added range checking to the view creation code. [SVN r32928]	2006-02-14 19:26:11 +00:00
Ronald Garcia	fc92cffda8	irrelevant file erased. [SVN r32899]	2006-02-13 17:53:56 +00:00
Ronald Garcia	4d01fb2637	Added mention of BOOST_DISABLE_ASSERT and range checking. [SVN r32898]	2006-02-13 17:53:13 +00:00
Ronald Garcia	9ddbd961ec	Added mention of BOOST_DISABLE_ASSERT and range checking. Fixed a reference to multi_array_ref.hpp, which is not a public interface to multi_array (though it could be made one if so desired). [SVN r32897]	2006-02-13 17:51:58 +00:00
Ronald Garcia	3996cb45cb	Suppressed some type warnings put out by g++ -Wall. [SVN r32715]	2006-02-07 17:54:27 +00:00
Ronald Garcia	5aefc55aac	Added range checking and missing concept checks for operator(). [SVN r32689]	2006-02-07 05:29:47 +00:00
Ronald Garcia	98794627a1	Switched to boost/assert.hpp and BOOST_ASSERT. Added range checking for operator[]. [SVN r32683]	2006-02-07 00:28:09 +00:00
Ronald Garcia	d1146d39cd	Fixed a nasty bug. [SVN r32682]	2006-02-07 00:27:19 +00:00
Ronald Garcia	00495c17c2	Don't use SFINAE (disable_if) on compilers that don't support it. [SVN r32405]	2006-01-24 17:58:20 +00:00
Ronald Garcia	e85dd4e2f6	Crazy ole' error in this test. Interesting that it has been hiding for this long... [SVN r32360]	2006-01-19 19:16:42 +00:00
Ronald Garcia	2462238fb1	Fix and adjustment for CW 9.4. [SVN r32002]	2005-12-12 17:15:26 +00:00
Ronald Garcia	267aecae3a	Fix for reindes on CW 9.4 (thanks to Doug Gregor). [SVN r31957]	2005-12-08 18:41:53 +00:00
Ronald Garcia	f1f715704e	undid an inadequate fix. [SVN r31956]	2005-12-08 17:56:37 +00:00
Douglas Gregor	66ae68443a	Merged from Version_1_33_1 [SVN r31949]	2005-12-08 03:23:02 +00:00
Ronald Garcia	cbf71de34c	Another modification for CW 9.4. [SVN r31939]	2005-12-06 19:35:12 +00:00
Ronald Garcia	3e75330914	Yet another attempted fix to CW 9.4. [SVN r31938]	2005-12-06 19:20:18 +00:00
Ronald Garcia	b776b66525	centralized typedef. [SVN r31921]	2005-12-05 19:58:16 +00:00
Ronald Garcia	120eed3ff4	possibly fixed bugs appearing under CW9.4 [SVN r31920]	2005-12-05 19:55:20 +00:00
Ronald Garcia	2c61720da5	possible fix for metrowerks CW9.4 problem. [SVN r31835]	2005-11-30 18:35:08 +00:00
Ronald Garcia	5c325606df	Generalized the definition of index. This has been pointed out in the past as a problem for 64-bit architectures. [SVN r31636]	2005-11-13 17:21:02 +00:00
Ronald Garcia	a32899d543	Added documentation for resizing multi_array. [SVN r31630]	2005-11-12 15:12:04 +00:00
John Maddock	c6cb294daf	Large patch from Ulrich Eckhardt to fix support for EVC++ 4. [SVN r30670]	2005-08-25 16:27:28 +00:00
Douglas Gregor	b80f97c842	Merged from 1.33.0 release [SVN r30540]	2005-08-12 13:02:37 +00:00