This commit was manufactured by cvs2svn to create tag

'Version_1_33_1'.

[SVN r31916]

doc/index.html

@@ -24,8 +24,8 @@
     width="277" align="middle" height="86"></td>
     <td><a href="../../../index.htm"><font face="Arial" color="#ffffff"><big>Home</big></font></a></td>
     <td><a href="../../../libs/libraries.htm"><font face="Arial" color="#ffffff"><big>Libraries</big></font></a></td>
-    <td><a href="http://www.boost.org/people/people.htm"><font face="Arial" color="#ffffff"><big>People</big></font></a></td>
-    <td><a href="http://www.boost.org/more/faq.htm"><font face="Arial" color="#ffffff"><big>FAQ</big></font></a></td>
+    <td><a href="../../../people/people.htm"><font face="Arial" color="#ffffff"><big>People</big></font></a></td>
+    <td><a href="../../../more/faq.htm"><font face="Arial" color="#ffffff"><big>FAQ</big></font></a></td>
     <td><a href="../../../more/index.htm"><font face="Arial" color="#ffffff"><big>More</big></font></a></td>
   </tr>
 </tbody></table>
@@ -48,7 +48,7 @@ definition and common implementations of that interface.
 <a href=http://www.osl.iu.edu/~garcia>Ronald Garcia</a>,
  Indiana University (<a
 HREF="mailto:garcia@osl.iu.edu">garcia@osl.iu.edu</a>)<br> 
-<a href="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</a>,
+<a href="../../../people/jeremy_siek.htm">Jeremy Siek</a>,
 Indiana University (<a
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</a>)<br>
 <a href=http://www.osl.iu.edu/~lums>Andrew Lumsdaine</a>,

doc/test_cases.html

@@ -114,13 +114,6 @@ Test re-indexing functionality for the B.M primary components.
 </td>
 </tr>
 
-<tr>
-<td><a href="../test/storage_order_convert.cpp">libs/multi_array/test/storage_order_convert.cpp</a></td>
-<td>
-Test out conversions among the storage orders data types.
-</td>
-</tr>
-
 <tr>
 <td><a href="../test/storage_order.cpp">libs/multi_array/test/storage_order.cpp</a></td>
 <td>
@@ -171,14 +164,6 @@ Ensure that all the array types meet the defined Concepts.
 </td>
 </tr>
 
-<tr>
-<td><a href="../test/assert.cpp">libs/multi_array/test/assert.cpp</a></td>
-<td>
-Ensure that uses of BOOST_ASSERT within the library can be customized
-by library users.
-</td>
-</tr>
-
 <tr>
 <td><a href="../test/generative_tests.hpp">libs/multi_array/test/generative_tests.hpp</a></td>
 <td>
@@ -300,10 +285,10 @@ summary="This table describes the tests in the multi array test suite
 <table summary="Copyright information">
 <tr valign="top">
 <td nowrap>Copyright &copy; 2001</td>
-<td><a href="http://www.boost.org/people/ronald_garcia.htm">Ronald Garcia</a>,
+<td><a href="../../../people/ronald_garcia.htm">Ronald Garcia</a>,
 Indiana University (<a href=
 "mailto:garcia@cs.indiana.edu">garcia@cs.indiana.edu</a>)<br>
-<a href="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</a>, Indiana
+<a href="../../../people/jeremy_siek.htm">Jeremy Siek</a>, Indiana
 University (<a href=
 "mailto:jsiek@cs.indiana.edu">jsiek@cs.indiana.edu</a>)<br>
 <a href="http://www.lsc.nd.edu/~lums">Andrew Lumsdaine</a>, Indiana

doc/user.html

@@ -70,8 +70,6 @@ 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>
@@ -156,20 +154,22 @@ main () {
 <a name="sec_components"></a>
 <h2>MultiArray Components</h2>
 
-Boost.MultiArray's implementation (boost/multi_array.hpp) provides three user-level class templates:
+Boost.MultiArray provides three user-level class templates:
 
 <ol>
-      <li><a href="./reference.html#multi_array"><tt>multi_array</tt></a>, 
+      <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_ref"><tt>multi_array_ref</tt></a>, and 
+      <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#const_multi_array_ref"><tt>const_multi_array_ref</tt></a>  
+      <li><a href="./reference.html#const_multi_array_ref"><tt>const_multi_array_ref</tt></a>  -
+      defined in "boost/multi_array_ref.hpp"
 </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.  A <tt>multi_array</tt> may
-also be default constructed and resized as needed.
+dimensions specified at construction time.  
 
 <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 constness-preserving
-portions of the <tt>multi_array_ref</tt> interface.
+<tt>const_multi_array_ref</tt> provides only the const portions
+of the <tt>multi_array_ref</tt> interface.
 
 <a name="sec_assignment"></a>
 <h2>Construction and Assignment</h2>
@@ -232,9 +232,8 @@ void my_function() {
 
 <a name="sec_dimensions"></a>
 <h2>Specifying Array Dimensions</h2>
-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).
+When creating one of the Boost.MultiArray components, it is necessary
+to specify both the number of dimensions and the extent of each.
 Though the number of dimensions is always specified as a template
 parameter, two separate mechanisms have been provided to specify the
 extent of each.
@@ -255,9 +254,7 @@ useful for writing dimension-independent code.
 </blockquote>
 
 <p>The second method involves passing the constructor an <tt>extent_gen</tt>
-object, specifying the matrix dimensions. The <tt>extent_gen</tt> type
-  is defined in the <tt>multi_array_types</tt> namespace and as a
-  member of every array type, but by default, the library constructs a
+object, specifying the matrix dimensions. By default, the library constructs a
 global <tt>extent_gen</tt> object <tt>boost::extents</tt>.  In case of
 concern about memory used by these objects, defining 
 <tt>BOOST_MULTI_ARRAY_NO_GENERATORS</tt> before including the library
@@ -303,14 +300,6 @@ 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 
@@ -318,17 +307,13 @@ already existing array component.  It allows you to create a sub-view that
 retains the same number of dimensions as the original array or one
 that has less dimensions than the original as well.
 
-<p>Sub-view creation occurs by placing a call to operator[], passing
-it an <tt>index_gen</tt> type.  The <tt>index_gen</tt> is populated by
-passing <tt>index_range</tt> objects to its <tt>operator[]</tt>.
-The <tt>index_range</tt> and <tt>index_gen</tt> types are defined in
-the <tt>multi_array_types</tt> namespace and as nested members of
-every array type.  Similar to <tt>boost::extents</tt>, the library by
-default constructs the object <tt>boost::indices</tt>.  You can
-suppress this object by
-defining <tt>BOOST_MULTI_ARRAY_NO_GENERATORS</tt> before including the
-library header. A simple sub-view creation example follows.
-
+<p>Sub-view creation occurs by placing a call to operator[], passing it 
+an <tt>index_gen</tt> type.  The <tt>index_gen</tt> is populated by
+passing <tt>index_range</tt> objects to its <tt>operator[]</tt>. 
+Similar to <tt>boost::extents</tt>, the library by default constructs
+the object <tt>boost::indices</tt>.  You can suppress this object 
+by defining <tt>BOOST_MULTI_ARRAY_NO_GENERATORS</tt> before 
+including the library header. A simple sub-view creation example follows.
 <h3>Example</h3>
 <blockquote>
 <pre>
@@ -341,8 +326,7 @@ library header. A simple sub-view creation example follows.
   // dim 2: [0,4) (strided by 2), 
   // 
 
-  typedef boost::multi_array_types::index_range range;
-  // OR typedef array_type::index_range range;
+  typedef array_type::index_range range;
   array_type::array_view&lt;3&gt;::type myview =
     myarray[ boost::indices[range(0,2)][range(1,3)][range(0,4,2)] ];
 
@@ -368,7 +352,7 @@ called slicing).
   // [0,1,2), 1, [0,2,4) 
   // 
 
-  typedef boost::multi_array_types::index_range range;
+  typedef array_type::index_range range;
   array_type::index_gen indices;
   array_type::array_view&lt;2&gt;::type myview =
     myarray[ indices[range(0,2)][1][range(0,4,2)] ];
@@ -389,7 +373,7 @@ that specify the same range.
   // [base,stride,bound)
   // [0,2,4) 
 
-  typedef boost::multi_array_types::index_range range;
+  typedef array_type::index_range range;
   range a_range;
   a_range = range(0,4,2);
   a_range = range().start(0).finish(4).stride(2);
@@ -409,7 +393,7 @@ dimension it is used to specify.
 <h3>Example</h3>
 <blockquote>
 <pre>
-  typedef boost::multi_array_types::index_range range;
+  typedef array_type::index_range range;
   range a_range;
 
   // All elements in this dimension
@@ -489,16 +473,13 @@ stored in ascending or descending order.
 In some situations, it may be inconvenient or awkward to use an 
 array that is zero-based.
 the Boost.MultiArray components provide two facilities for changing the
-bases of an array.  One may specify a pair of range values, with
-the <tt>extent_range</tt> type, to
-the <tt>extent_gen</tt> constructor in order to set the base value. 
-
+bases of an array.  One may specify a pair of range values to
+the extent_gen constructor in order to set the base value. 
 <h3>Example</h3>
 <blockquote>
 <pre>
   typedef boost::multi_array&lt;double, 3&gt; array_type;
-  typedef boost::multi_array_types::extent_range range;
-  // OR typedef array_type::extent_range range;
+  typedef array_type::extent_range range;
 
   array_type::extent_gen extents;
  
@@ -517,6 +498,7 @@ reset the bases.  To set all bases to the same value, use the
 <blockquote>
 <pre>
   typedef boost::multi_array&lt;double, 3&gt; array_type;
+  typedef array_type::extent_range range;
 
   array_type::extent_gen extents;
  
@@ -533,6 +515,7 @@ An alternative is to set each base separately using the
 <blockquote>
 <pre>
   typedef boost::multi_array&lt;double, 3&gt; array_type;
+  typedef array_type::extent_range range;
 
   array_type::extent_gen extents;
  
@@ -556,6 +539,7 @@ elements contained remains the same.
 <blockquote>
 <pre>
   typedef boost::multi_array&lt;double, 3&gt; array_type;
+  typedef array_type::extent_range range;
 
   array_type::extent_gen extents;
   array_type A(extents[2][3][4]);
@@ -567,35 +551,6 @@ 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;
-
-  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 
@@ -638,7 +593,7 @@ arrays, as <tt>boost::array</tt> does for C one-dimensional arrays.
       <li><a href="mailto:garcia@osl.iu.edu">Ronald Garcia</a> 
       is the primary author of the library.
 
-      <li><a href="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</a>
+      <li><a href="../../../people/jeremy_siek.htm">Jeremy Siek</a>
       helped with the library and provided a sounding board for ideas,
        advice, and assistance porting to Microsoft Visual C++.
 
@@ -669,7 +624,9 @@ 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 Feb  7 17:15:50 EST 2006 <!-- hhmts end -->
+<!-- hhmts start -->
+Last modified: Wed Nov 30 23:29:03 EST 2005
+<!-- hhmts end -->
 
 </body>
 </html>

doc/xml/MultiArray.xml

@@ -124,8 +124,8 @@ to describe the MultiArray interface.</para>
 </entry>
 	    </row>
 	    <row>
-	      <entry><literal>a,b</literal></entry>
-	      <entry>Objects of type <literal>A</literal></entry>
+	      <entry><literal>a</literal></entry>
+	      <entry>An object of type <literal>A</literal></entry>
 	    </row>
 	    <row>
 	      <entry><literal>NumDims</literal></entry>
@@ -385,13 +385,6 @@ This is the const view type with <literal>Dims</literal> dimensions.
 	  </row>
 	</thead>
 	<tbody>
-	  <row>
-	    <entry><literal>A::dimensionality</literal></entry>
-	    <entry><literal>size_type</literal></entry>
-	    <entry>This compile-time constant represents the number of
-dimensions of the array (note that 
-<literal>A::dimensionality == NumDims</literal>).</entry>
-	  </row>
 	  <row>
 	    <entry><literal>a.shape()</literal></entry>
 	    <entry><literal>const size_type*</literal></entry>

doc/xml/const_multi_array_ref.xml

@@ -33,26 +33,26 @@ namespace boost {
 
 template <typename ValueType, 
           std::size_t NumDims, 
-          typename TPtr = const T*>
+          typename Allocator = std::allocator<ValueType> >
 class const_multi_array_ref {
 public:
 // types:
   typedef ValueType                             element;
-  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 *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 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 *unspecified*                         storage_order_type;
+  typedef *implementation-defined*              storage_order_type;
   
   // template typedefs
   template <std::size_t Dims> struct            subarray;
@@ -64,9 +64,9 @@ public:
   // structors
 
   template <typename ExtentList>
-  explicit const_multi_array_ref(TPtr data, const ExtentList& sizes,
+  explicit const_multi_array_ref(const element* data, const ExtentList& sizes,
                        const storage_order_type& store = c_storage_order());
-  explicit const_multi_array_ref(TPtr data, const extents_tuple& ranges,
+  explicit const_multi_array_ref(const element* data, const extents_tuple& ranges,
                        const storage_order_type& store = c_storage_order());
   const_multi_array_ref(const const_multi_array_ref& x);
   ~const_multi_array_ref();
@@ -122,7 +122,7 @@ public:
 <variablelist>
 <varlistentry>
 <term><programlisting>template &lt;typename ExtentList&gt;
-explicit const_multi_array_ref(TPtr data, 
+explicit const_multi_array_ref(const element* data, 
                      const ExtentList&amp; sizes,
                      const storage_order&amp; store = c_storage_order());
 </programlisting></term>
@@ -151,7 +151,7 @@ dimensions.
 
 <varlistentry>
 <term>
-<programlisting><![CDATA[explicit const_multi_array_ref(TPtr data,
+<programlisting><![CDATA[explicit const_multi_array_ref(const element* data,
                      extent_gen::gen_type<NumDims>::type ranges,
                      const storage_order& store = c_storage_order());]]>
 </programlisting></term> 

doc/xml/main.xml

@@ -0,0 +1,71 @@
+<?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

doc/xml/multi_array.xml

@@ -36,21 +36,21 @@ class multi_array {
 public:
 // types:
   typedef ValueType                             element;
-  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 *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 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 *unspecified*                         storage_order_type;
+  typedef *implementation-defined*              storage_order_type;
   
 
   // template typedefs
@@ -136,9 +136,7 @@ public:
   template <typename SizeList>
     void			reshape(const SizeList& sizes)
   template <typename BaseList>	void reindex(const BaseList& values);
-    void			reindex(index value);
-  template <typename ExtentList>
-    multi_array&		resize(const ExtentList& extents);
+  void				reindex(index value);
   multi_array&                  resize(extents_tuple& extents);
 };
 ]]>
@@ -329,20 +327,15 @@ O(<literal>this->num_elements()</literal>) calls to
 
 <varlistentry>
 <term>
-<programlisting><![CDATA[multi_array& resize(extent_gen::gen_type<NumDims>::type extents);
-template <typename ExtentList>
-  multi_array& resize(const ExtentList& extents);
-]]>
+<programlisting><![CDATA[multi_array& resize(extent_gen::gen_type<NumDims>::type ranges);]]>
 </programlisting></term> 
 <listitem>
 <para>
-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.
+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.
 </para>
 </listitem>
 </varlistentry> 

doc/xml/multi_array_ref.xml

@@ -31,26 +31,27 @@ not described in the <literal>multi_array</literal> reference.
 namespace boost {
 
 template <typename ValueType, 
-          std::size_t NumDims>
+          std::size_t NumDims, 
+          typename Allocator = std::allocator<ValueType> >
 class multi_array_ref {
 public:
 // types:
   typedef ValueType                             element;
-  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 *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 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 *unspecified*                         storage_order_type;
+  typedef *implementation-defined*              storage_order_type;
   
   // template typedefs
   template <std::size_t Dims> struct            subarray;

doc/xml/reference.xml

@@ -50,13 +50,13 @@ brings the following declarations into scope:</para>
 <![CDATA[namespace boost {
   
   namespace multi_array_types {
-    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;
+    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;
   }
 
   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 *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;
+  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;
 }]]>
 </programlisting>
 
@@ -779,20 +779,6 @@ 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>
 

include/boost/multi_array.hpp

@@ -42,10 +42,9 @@ 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);
         }
       };
 
@@ -380,30 +379,12 @@ 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,this->storage_order());
+    multi_array new_array(ranges);
 
 
     // build a view of tmp with the minimum extents
@@ -429,12 +410,12 @@ public:
 
     std::transform(new_array.index_base_list_.begin(),
                    new_array.index_base_list_.end(),
-                   min_extents.begin(),new_idxes.ranges_.begin(),
+                   min_extents.begin(),old_idxes.ranges_.begin(),
                    detail::multi_array::populate_index_ranges());
 
     std::transform(this->index_base_list_.begin(),
                    this->index_base_list_.end(),
-                   min_extents.begin(),old_idxes.ranges_.begin(),
+                   min_extents.begin(),new_idxes.ranges_.begin(),
                    detail::multi_array::populate_index_ranges());
 
     // Build same-shape views of the two arrays

include/boost/multi_array/base.hpp

@@ -25,7 +25,6 @@
 #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"
@@ -33,7 +32,7 @@
 #include "boost/iterator/reverse_iterator.hpp"
 #include "boost/static_assert.hpp"
 #include "boost/type.hpp"
-#include "boost/assert.hpp"
+#include <cassert>
 #include <cstddef>
 #include <memory>
 
@@ -130,13 +129,11 @@ protected:
   Reference access(boost::type<Reference>,index idx,TPtr base,
                    const size_type* extents,
                    const index* strides,
-                   const index* index_bases) const {
+                   const index* index_base) 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_bases+1);
+    return Reference(newbase,extents+1,strides+1,index_base+1);
 
   }
 
@@ -168,14 +165,9 @@ 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* extents,
+                   const size_type*,
                    const index* strides,
-                   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]);
+                   const index*) const {
     return *(base + idx * strides[0]);
   }
 
@@ -209,7 +201,7 @@ struct value_accessor_generator {
   >::type type;
 };
 
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
 
 struct eti_value_accessor
 {
@@ -259,7 +251,7 @@ struct associated_types
 template <typename T, std::size_t NumDims>
 class multi_array_impl_base
   :
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
       public mpl::aux::msvc_eti_base<
           typename value_accessor_generator<T,mpl::size_t<NumDims> >::type
        >::type
@@ -315,22 +307,9 @@ protected:
 
   // Used by operator() in our array classes
   template <typename Reference, typename IndexList, typename TPtr>
-  Reference access_element(boost::type<Reference>,
+  Reference access_element(boost::type<Reference>, TPtr base,
                            const IndexList& indices,
-                           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
-
+                           const index* strides) const {
     index offset = 0;
     for (size_type n = 0; n != NumDims; ++n) 
       offset += indices[n] * strides[n];
@@ -437,16 +416,7 @@ protected:
       index start = current_range.get_start(default_start);
       index finish = current_range.get_finish(default_finish);
       index index_factor = current_range.stride();
-
-      // integral trick for ceiling((finish-start) / index_factor)
-      index shrinkage = index_factor > 0 ? 1 : -1;
-      index len = (finish - start + (index_factor - shrinkage)) / 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);
+      index len = (finish - start + (index_factor - 1)) / index_factor;
 
       // the array data pointer is modified to account for non-zero
       // bases during slicing (see [Garcia] for the math involved)
@@ -463,7 +433,7 @@ protected:
         ++dim;
       }
     }
-    BOOST_ASSERT(dim == NDims);
+    assert (dim == NDims);
 
     return
       ArrayRef(base+offset,

include/boost/multi_array/concept_checks.hpp

@@ -77,7 +77,6 @@ namespace multi_array {
 
       st = a.size();
       st = a.num_dimensions();
-      st = Array::dimensionality;
       st = a.num_elements();
       stp = a.shape();
       idp = a.strides();

include/boost/multi_array/copy_array.hpp

@@ -19,7 +19,7 @@
 // shape
 //
 #include "boost/type.hpp"
-#include "boost/assert.hpp"
+#include <cassert>
 
 namespace boost {
 namespace detail {
@@ -52,8 +52,8 @@ private:
 
 template <typename Array1, typename Array2>
 void copy_array (Array1& source, Array2& dest) {
-  BOOST_ASSERT(std::equal(source.shape(),source.shape()+source.num_dimensions(),
-                          dest.shape()));
+  assert(std::equal(source.shape(),source.shape()+source.num_dimensions(),
+                    dest.shape()));
   // Dispatch to the proper function
   typedef typename Array1::element element_type;
   copy_dispatch<element_type>::

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;
-  typedef extent_range<index,size_type> range;
 private:
+  typedef extent_range<index,size_type> range;
   typedef typename range_list_generator<range,NumRanges>::type range_list;
 public:
   template <std::size_t Ranges>

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 ::boost::detail::multi_array::size_type size_type;
-  typedef index_range<index,size_type> range;
+  typedef ::boost::detail::multi_array::index Index;
+  typedef std::size_t SizeType;
+  typedef index_range<Index,SizeType> 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 range& r)
+            const index_range<Index,SizeType>& range)
   {
     std::copy(rhs.ranges_.begin(),rhs.ranges_.end(),ranges_.begin());
-    *ranges_.rbegin() = r;
+    *ranges_.rbegin() = range;
   }
 
   index_gen<NumRanges+1,NumDims+1>
-  operator[](const range& r) const
+  operator[](const index_range<Index,SizeType>& range) const
   {
     index_gen<NumRanges+1,NumDims+1> tmp;
     std::copy(ranges_.begin(),ranges_.end(),tmp.ranges_.begin());
-    *tmp.ranges_.rbegin() = r;
+    *tmp.ranges_.rbegin() = range;
     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() = range(idx);
+    *tmp.ranges_.rbegin() = index_range<Index,SizeType>(idx);
     return tmp;
   }    
 

include/boost/multi_array/index_range.hpp

@@ -35,15 +35,6 @@ 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();
@@ -55,7 +46,7 @@ namespace multi_array {
     explicit index_range(index pos)
     {
       start_ = pos;
-      finish_ = pos+1;
+      finish_ = pos;
       stride_ = 1;
       degenerate_ = true;
     }
@@ -69,13 +60,13 @@ namespace multi_array {
     // These are for chaining assignments to an index_range
     index_range& start(index s) {
       start_ = s;
-      degenerate_ = false;
+      degenerate_ = (start_ == finish_);
       return *this;
     }
 
     index_range& finish(index f) {
       finish_ = f;
-      degenerate_ = false;
+      degenerate_ = (start_ == finish_);
       return *this;
     }
 
@@ -86,7 +77,7 @@ namespace multi_array {
       return start_; 
     }
 
-    index get_start(index low_index_range = index_range::from_start()) const
+    index get_start(index low_index_range = 0) const
     { 
       if (start_ == from_start())
         return low_index_range;
@@ -98,15 +89,28 @@ namespace multi_array {
       return finish_;
     }
 
-    index get_finish(index high_index_range = index_range::to_end()) const
+    index get_finish(index high_index_range = 0) 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;
@@ -117,6 +121,9 @@ 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
@@ -141,6 +148,12 @@ 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_;

include/boost/multi_array/iterator.hpp

@@ -21,7 +21,6 @@
 #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>
 
@@ -57,11 +56,11 @@ class array_iterator
       , Reference
     >
     , private
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+#if BOOST_WORKAROUND(BOOST_MSVC,==1200)
       mpl::aux::msvc_eti_base<typename 
 #endif 
           value_accessor_generator<T,NumDims>::type
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+#if BOOST_WORKAROUND(BOOST_MSVC,==1200)
       >::type
 #endif 
 {
@@ -138,15 +137,11 @@ 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_) ||
-        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_) );
+      (extents_ == rhs.extents_) &&
+      (strides_ == rhs.strides_) &&
+      (index_base_ == rhs.index_base_);
   }
 
   template <class DifferenceType>

include/boost/multi_array/multi_array_ref.hpp

@@ -25,12 +25,12 @@
 #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"
 #include "boost/limits.hpp"
 #include <algorithm>
+#include <cassert>
 #include <cstddef>
 #include <functional>
 #include <numeric>
@@ -137,13 +137,7 @@ public:
   }
 
   template <class BaseList>
-#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) {
+  void reindex(const BaseList& values) {
     boost::function_requires<
       detail::multi_array::CollectionConcept<BaseList> >();
     boost::detail::multi_array::
@@ -164,9 +158,9 @@ public:
   void reshape(const SizeList& extents) {
     boost::function_requires<
       detail::multi_array::CollectionConcept<SizeList> >();
-    BOOST_ASSERT(num_elements_ ==
-                 std::accumulate(extents.begin(),extents.end(),
-                                 size_type(1),std::multiplies<size_type>()));
+    assert(num_elements_ ==
+           std::accumulate(extents.begin(),extents.end(),
+                            size_type(1),std::multiplies<size_type>()));
 
     std::copy(extents.begin(),extents.end(),extent_list_.begin());
     this->compute_strides(stride_list_,extent_list_,storage_);
@@ -212,8 +206,8 @@ public:
     boost::function_requires<
       detail::multi_array::CollectionConcept<IndexList> >();
     return super_type::access_element(boost::type<const element&>(),
-                                      indices,origin(),
-                                      shape(),strides(),index_bases());
+                                      origin(),
+                                      indices,strides());
   }
 
   // Only allow const element access
@@ -482,9 +476,9 @@ public:
       ConstMultiArrayConcept<ConstMultiArray,NumDims> >();
 
     // make sure the dimensions agree
-    BOOST_ASSERT(other.num_dimensions() == this->num_dimensions());
-    BOOST_ASSERT(std::equal(other.shape(),other.shape()+this->num_dimensions(),
-                            this->shape()));
+    assert(other.num_dimensions() == this->num_dimensions());
+    assert(std::equal(other.shape(),other.shape()+this->num_dimensions(),
+                      this->shape()));
     // iterator-based copy
     std::copy(other.begin(),other.end(),this->begin());
     return *this;
@@ -494,10 +488,9 @@ public:
     if (&other != this) {
       // make sure the dimensions agree
       
-      BOOST_ASSERT(other.num_dimensions() == this->num_dimensions());
-      BOOST_ASSERT(std::equal(other.shape(),
-                              other.shape()+this->num_dimensions(),
-                              this->shape()));
+      assert(other.num_dimensions() == this->num_dimensions());
+      assert(std::equal(other.shape(),other.shape()+this->num_dimensions(),
+                        this->shape()));
       // iterator-based copy
       std::copy(other.begin(),other.end(),this->begin());
     }
@@ -510,12 +503,11 @@ 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&>(),
-                                      indices,origin(),
-                                      this->shape(),this->strides(),
-                                      this->index_bases());
+  boost::function_requires<
+    detail::multi_array::CollectionConcept<IndexList> >();
+  return super_type::access_element(boost::type<element&>(),
+                                      origin(),
+                                      indices,this->strides());
   }
 
 

include/boost/multi_array/subarray.hpp

@@ -79,11 +79,9 @@ 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&>(),
-                                      indices,origin(),
-                                      shape(),strides(),index_bases());
+                                      origin(),
+                                      indices,strides());
   }
 
   // see generate_array_view in base.hpp
@@ -235,9 +233,9 @@ public:
         ConstMultiArray, NumDims> >();
 
     // make sure the dimensions agree
-    BOOST_ASSERT(other.num_dimensions() == this->num_dimensions());
-    BOOST_ASSERT(std::equal(other.shape(),other.shape()+this->num_dimensions(),
-                            this->shape()));
+    assert(other.num_dimensions() == this->num_dimensions());
+    assert(std::equal(other.shape(),other.shape()+this->num_dimensions(),
+                      this->shape()));
     // iterator-based copy
     std::copy(other.begin(),other.end(),begin());
     return *this;
@@ -247,10 +245,9 @@ public:
   sub_array& operator=(const sub_array& other) {
     if (&other != this) {
       // make sure the dimensions agree
-      BOOST_ASSERT(other.num_dimensions() == this->num_dimensions());
-      BOOST_ASSERT(std::equal(other.shape(),
-                              other.shape()+this->num_dimensions(),
-                              this->shape()));
+      assert(other.num_dimensions() == this->num_dimensions());
+      assert(std::equal(other.shape(),other.shape()+this->num_dimensions(),
+                        this->shape()));
       // iterator-based copy
       std::copy(other.begin(),other.end(),begin());
     }
@@ -287,12 +284,9 @@ 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&>(),
-                                      indices,origin(),
-                                      this->shape(),this->strides(),
-                                      this->index_bases());
+                                      origin(),
+                                      indices,this->strides());
   }
 
   iterator begin() {
@@ -322,8 +316,6 @@ public:
 
   template <class IndexList>
   const element& operator()(const IndexList& indices) const {
-    boost::function_requires<
-      detail::multi_array::CollectionConcept<IndexList> >();
     return super_type::operator()(indices);
   }
 

include/boost/multi_array/types.hpp

@@ -26,7 +26,7 @@ namespace multi_array{
 
 // needed typedefs
 typedef std::size_t size_type;
-typedef std::ptrdiff_t index;
+typedef int index;
 
 } // namespace multi_array
 } // namespace detail

include/boost/multi_array/view.hpp

@@ -23,7 +23,6 @@
 #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>
@@ -73,15 +72,7 @@ public:
 
 
   template <class BaseList>
-#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> >();
+  void reindex(const BaseList& values) {
     boost::detail::multi_array::
       copy_n(values.begin(),num_dimensions(),index_base_list_.begin());
     origin_offset_ =
@@ -118,11 +109,9 @@ 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&>(),
-                                      indices,origin(),
-                                      shape(),strides(),index_bases());
+                                      origin(),
+                                      indices,strides());
   }
 
   // Only allow const element access
@@ -244,7 +233,10 @@ public: // should be protected
 
     // Calculate the array size
     num_elements_ = std::accumulate(extent_list_.begin(),extent_list_.end(),
-                                    size_type(1),std::multiplies<size_type>());
+                            size_type(1),std::multiplies<size_type>());
+#if 0
+    assert(num_elements_ != 0);
+#endif
   }
 
   typedef boost::array<size_type,NumDims> size_list;
@@ -301,9 +293,9 @@ public:
       ConstMultiArrayConcept<ConstMultiArray,NumDims> >();
 
     // make sure the dimensions agree
-    BOOST_ASSERT(other.num_dimensions() == this->num_dimensions());
-    BOOST_ASSERT(std::equal(other.shape(),other.shape()+this->num_dimensions(),
-                            this->shape()));
+    assert(other.num_dimensions() == this->num_dimensions());
+    assert(std::equal(other.shape(),other.shape()+this->num_dimensions(),
+                      this->shape()));
     // iterator-based copy
     std::copy(other.begin(),other.end(),begin());
     return *this;
@@ -313,10 +305,9 @@ public:
   multi_array_view& operator=(const multi_array_view& other) {
     if (&other != this) {
       // make sure the dimensions agree
-      BOOST_ASSERT(other.num_dimensions() == this->num_dimensions());
-      BOOST_ASSERT(std::equal(other.shape(),
-                              other.shape()+this->num_dimensions(),
-                              this->shape()));
+      assert(other.num_dimensions() == this->num_dimensions());
+      assert(std::equal(other.shape(),other.shape()+this->num_dimensions(),
+                        this->shape()));
       // iterator-based copy
       std::copy(other.begin(),other.end(),begin());
     }
@@ -327,12 +318,9 @@ 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&>(),
-                                      indices,origin(),
-                                      this->shape(),this->strides(),
-                                      this->index_bases());
+                                      origin(),
+                                      indices,this->strides());
   }
 
 
@@ -391,8 +379,6 @@ public:
 
   template <class IndexList>
   const element& operator()(const IndexList& indices) const {
-    boost::function_requires<
-      detail::multi_array::CollectionConcept<IndexList> >();
     return super_type::operator()(indices);
   }
 

index.html

@@ -4,10 +4,6 @@
 </head>
 <body>
 Automatic redirection failed, please go to
-<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>
+<a href="doc/index.html">doc/index.html</a>.
 </body>
 </html>

test/Jamfile

@@ -0,0 +1,51 @@
+# 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 ]
+    ;

test/Jamfile.v2

@@ -37,13 +37,11 @@ test-suite multi_array
       [ run assign.cpp ../../test/build//boost_test_exec_monitor ]
       [ run assign_to_array.cpp ../../test/build//boost_test_exec_monitor ]
       [ run index_bases.cpp ../../test/build//boost_test_exec_monitor ]
-      [ run storage_order_convert.cpp ../../test/build//boost_test_exec_monitor ]
       [ run storage_order.cpp ../../test/build//boost_test_exec_monitor ]
       [ run reshape.cpp ../../test/build//boost_test_exec_monitor ]
       [ run range1.cpp ../../test/build//boost_test_exec_monitor  ]
       [ run idxgen1.cpp ../../test/build//boost_test_exec_monitor ]
       [ run stl_interaction.cpp ../../test/build//boost_test_exec_monitor ]
       [ run resize.cpp ../../test/build//boost_test_exec_monitor ]
-      [ run assert.cpp ../../test/build//boost_test_exec_monitor ]
       [ compile concept_checks.cpp ]
     ;

test/access.cpp

@@ -47,9 +47,9 @@ void access(Array& A, const const_array_tag&) {
       }
 
   // operator()
-  for (index i2 = idx0; i2 != idx0+2; ++i2)
-    for (index j2 = idx1; j2 != idx1+3; ++j2)
-      for (index k2 = idx2; k2 != idx2+4; ++k2) {
+  for (index i2 = 0; i2 != 2; ++i2)
+    for (index j2 = 0; j2 != 3; ++j2)
+      for (index k2 = 0; k2 != 4; ++k2) {
         boost::array<index,ndims> indices;
         indices[0] = i2; indices[1] = j2; indices[2] = k2;
         BOOST_CHECK(A(indices) == A[i2][j2][k2]);

test/assert.cpp

@@ -1,51 +0,0 @@
-// Copyright 2007 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.
-
-//
-// Using the BOOST.ASSERT mechanism to replace library assertions 
-// with exceptions
-//
-
-#include "boost/test/minimal.hpp"
-
-#define BOOST_ENABLE_ASSERT_HANDLER
-#include "boost/multi_array.hpp" // includes assert.hpp
-
-#include <stdexcept>
-
-namespace boost {
-  void assertion_failed(char const* expr, char const* function,
-                        char const* file, long line) {
-    throw std::runtime_error(expr);
-  }
-} // namespace boost
-
-using namespace boost;
-
-int
-test_main(int,char*[]) {
-
-  typedef multi_array<int,2> array_t;
-
-  array_t A(extents[2][2]);
-
-  array_t B(extents[3][3]);
-
-  try {
-    A = B;
-    BOOST_ERROR("did not throw an exception");
-  } catch (std::runtime_error&) {
-    //...all good
-  }
-
-  return boost::exit_success;
-}

test/concept_checks.cpp

@@ -20,8 +20,8 @@
 #include "boost/multi_array.hpp"
 
 #include "boost/cstdlib.hpp"
-
-#include "boost/test/minimal.hpp"
+#define BOOST_INCLUDE_MAIN
+#include "boost/test/test_tools.hpp"
 
 #include "boost/array.hpp"
 

test/generative_tests.hpp

@@ -49,7 +49,6 @@
 
 #include "boost/test/minimal.hpp"
 
-#include <boost/config.hpp> /* BOOST_NO_SFINAE */
 #include <algorithm>
 #include <iostream>
 #include <vector>
@@ -239,14 +238,7 @@ struct null_modifier {
 
 struct set_index_base_modifier {
   template <typename Array>
-  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 
-  }
+  void modify(Array& A) const { A.reindex(1); }
 };
 
 struct reindex_modifier {

test/idxgen1.cpp

@@ -16,20 +16,21 @@
 
 #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 range& lhs,const range& rhs) {  
+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) {
   return lhs.start_ == rhs.start_ &&
     lhs.finish_ == rhs.finish_ &&
     lhs.stride_ == rhs.stride_ &&
@@ -39,6 +40,7 @@ bool operator==(const range& lhs,const range& rhs) {
 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;
 

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.shape()[2]; ++c) {
+        for (size_type c = 0; c < A[b].size(); ++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,18 +126,10 @@ 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)

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() == 6);
+    BOOST_CHECK(r3.finish() == 5);
     BOOST_CHECK(r3.stride() == 1);
     BOOST_CHECK(r3.is_degenerate());
   }

test/resize.cpp

@@ -35,6 +35,13 @@ 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,
@@ -53,75 +60,14 @@ int test_main(int,char*[]) {
     0,0
   };
 
-  // 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()));
-  }  
+  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;
-        }
-      }
-    }
-  }
-
-  // Resizing that changes index bases too (impl bug caused an assert)
-  {
-      typedef boost::multi_array<int, 1> ar_t;
-      typedef ar_t::extent_range range;
-      ar_t ar;
-      ar.resize(boost::extents[range(-3, 3)]);
-  }
-
-
   return boost::exit_success;
 }

test/slice.cpp

@@ -90,28 +90,6 @@ void test_views(Array& A, const ViewTraits&) {
         BOOST_CHECK(B(elmts) == A[idx0+i][idx1+1][idx2+j*2]);
       }
   }
-
-  // Flip the third dimension
-  {
-    typename ViewTraits::array_view3 B = A[
-      indices[range(idx0+0,idx0+2)]
-             [range(idx1+0,idx1+2)]
-             [range(idx2+2,idx2+0,-1)]
-    ];
-
-    //    typename ViewTraits::array_view3 B =
-    //      A[indices[range(idx0+0,idx0+2)][idx1+1][range(idx2+0,idx2+4,2)]];
-    
-    for (index i = 0; i != 2; ++i)
-      for (index j = 0; j != 2; ++j) 
-        for (index k = 0; k != 2; ++k) {
-        BOOST_CHECK(B[i][j][k] == A[idx0+i][idx1+j][idx2+2-k]);
-        boost::array<index,3> elmts;
-        elmts[0]=i; elmts[1]=j; elmts[2]=k;
-        BOOST_CHECK(B(elmts) == A[idx0+i][idx1+j][idx2+2-k]);
-      }
-  }
-
   ++tests_run;
 }
 

test/storage_order_convert.cpp

@@ -31,8 +31,8 @@ test_main(int,char*[]) {
   general_storage_order<5> fortran_storage(fortran_ordering.begin(),
                                            ascending.begin());
  
-  BOOST_CHECK(c_storage == (general_storage_order<5>) c_storage_order());
-  BOOST_CHECK(fortran_storage ==
+  BOOST_TEST(c_storage == (general_storage_order<5>) c_storage_order());
+  BOOST_TEST(fortran_storage ==
              (general_storage_order<5>) fortran_storage_order());
 
   return boost::exit_success;