This commit was manufactured by cvs2svn to create tag

'Version_1_32_0'.

[SVN r26264]

.travis.yml

@@ -1,234 +0,0 @@
-# Copyright 2018 Peter Dimov
-# Distributed under the Boost Software License, Version 1.0.
-
-language: cpp
-
-sudo: false
-
-python: "2.7"
-
-branches:
-  only:
-    - master
-    - develop
-
-env:
-  matrix:
-    - BOGUS_JOB=true
-
-matrix:
-
-  exclude:
-    - env: BOGUS_JOB=true
-
-  include:
-    - os: linux
-      compiler: g++
-      env: TOOLSET=gcc COMPILER=g++ CXXSTD=03,11
-
-    - os: linux
-      compiler: g++-4.4
-      env: TOOLSET=gcc COMPILER=g++-4.4 CXXSTD=98,0x
-      addons:
-        apt:
-          packages:
-            - g++-4.4
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-4.6
-      env: TOOLSET=gcc COMPILER=g++-4.6 CXXSTD=03,0x
-      addons:
-        apt:
-          packages:
-            - g++-4.6
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-4.7
-      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=03,11
-      addons:
-        apt:
-          packages:
-            - g++-4.7
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-4.8
-      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=03,11
-      addons:
-        apt:
-          packages:
-            - g++-4.8
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-4.9
-      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=03,11
-      addons:
-        apt:
-          packages:
-            - g++-4.9
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-5
-      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - g++-5
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-6
-      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - g++-6
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      dist: trusty
-      compiler: g++-7
-      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11,14,17
-      addons:
-        apt:
-          packages:
-            - g++-7
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-8
-      env: TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11,14,17
-      addons:
-        apt:
-          packages:
-            - g++-8
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11
-
-    - os: linux
-      compiler: clang++-3.5
-      env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.5
-            - libstdc++-4.9-dev
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-3.6
-      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.6
-            - libstdc++-4.9-dev
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-3.8
-      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.8
-            - libstdc++-4.9-dev
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-3.9
-      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.9
-            - libstdc++-4.9-dev
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-4.0
-      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-4.0
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-4.0
-
-    - os: linux
-      compiler: clang++-5.0
-      env: TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-5.0
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-5.0
-
-    - os: linux
-      compiler: clang++-6.0
-      env: TOOLSET=clang COMPILER=clang++-6.0 CXXSTD=03,11,14,17
-      addons:
-        apt:
-          packages:
-            - clang-6.0
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-6.0
-
-    - os: linux
-      compiler: clang++-libc++
-      env: TOOLSET=clang COMPILER=clang++-libc++ CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - libc++-dev
-
-    - os: osx
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
-
-install:
-  - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
-  - cd ..
-  - git clone -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost
-  - cd boost
-  - git submodule update --init tools/build
-  - git submodule update --init libs/config
-  - git submodule update --init tools/boostdep
-  - mkdir -p libs/multi_array
-  - cp -r $TRAVIS_BUILD_DIR/* libs/multi_array
-  - python tools/boostdep/depinst/depinst.py multi_array
-  - ./bootstrap.sh
-  - ./b2 headers
-
-script:
-  - |-
-    echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
-  - ./b2 -j 3 libs/multi_array/test toolset=$TOOLSET cxxstd=$CXXSTD
-
-notifications:
-  email:
-    on_success: always

appveyor.yml

@@ -1,48 +0,0 @@
-# Copyright 2018 Peter Dimov
-# Distributed under the Boost Software License, Version 1.0.
-
-version: 1.0.{build}-{branch}
-
-shallow_clone: true
-
-branches:
-  only:
-    - master
-    - develop
-
-environment:
-  matrix:
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-      TOOLSET: msvc-9.0
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-      TOOLSET: msvc-10.0
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-      TOOLSET: msvc-11.0
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-      TOOLSET: msvc-12.0
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      TOOLSET: msvc-14.0
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      TOOLSET: msvc-14.1
-      CXXSTD: 14,17
-
-install:
-  - set BOOST_BRANCH=develop
-  - if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master
-  - cd ..
-  - git clone -b %BOOST_BRANCH% https://github.com/boostorg/boost.git boost
-  - cd boost
-  - git submodule update --init tools/build
-  - git submodule update --init libs/config
-  - git submodule update --init tools/boostdep
-  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\multi_array\
-  - python tools/boostdep/depinst/depinst.py multi_array
-  - cmd /c bootstrap
-  - b2 headers
-
-build: off
-
-test_script:
-  - PATH=%ADDPATH%%PATH%
-  - if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
-  - b2 -j 3 libs/multi_array/test toolset=%TOOLSET% %CXXSTD%

doc/build.jam

@@ -1,15 +0,0 @@
-# Copyright (c) 2016 Rene Rivera
-#
-# Distributed under 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)
-
-###############################################################################
-alias boostdoc
-    : xml/bbref.xml
-    :
-    :
-    : ;
-explicit boostdoc ;
-alias boostrelease ;
-explicit boostrelease ;

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>
@@ -45,13 +45,13 @@ definition and common implementations of that interface.
 <table>
 <tr valign=top>
 <td nowrap>Copyright &copy 2000-2001</td><td>
-<a href="http://www.osl.iu.edu/~garcia">Ronald Garcia</a>,
+<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>,
+<a href=http://www.osl.iu.edu/~lums>Andrew Lumsdaine</a>,
 Indiana University (<a
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</a>)
 </td></tr></table>

doc/iterator_categories.html

@@ -38,7 +38,7 @@ gives a summary of the current dereference return type requirements in the
 iterator categories. 
 <p>
 </p><center>
-<a name="table:1">
+<a name="table:2">
   <b>Table 1.</b> Summary of current dereference return type 
   requirements.</a><table border="1">
   <tbody>
@@ -50,7 +50,7 @@ iterator categories.
     <td><tt>*i</tt> is convertible to <tt>T</tt></td></tr>
   <tr>
     <td>Forward Iterator</td>
-    <td><tt>*i</tt> is <tt>T&amp;</tt> (or <tt>const T&amp;</tt> once <a href="http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-active.html#200">issue 
+    <td><tt>*i</tt> is <tt>T&amp;</tt> (or <tt>const T&amp;</tt> once <a href="http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/lwg-active.html#200">issue 
       200</a> is resolved)</td></tr>
   <tr>
     <td>Random Access Iterator</td>
@@ -61,7 +61,7 @@ iterator categories.
 <p>Because of the mixing of iterator traversal and dereference return type, many 
 useful iterators can not be appropriately categorized. For example, 
 <tt>vector&lt;bool&gt;::iterator</tt> is almost a random access iterator, but 
-the return type is not <tt>bool&amp;</tt> (see <a href="http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-active.html#96">issue 
+the return type is not <tt>bool&amp;</tt> (see <a href="http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/lwg-active.html#96">issue 
 96</a> and Herb Sutter's paper J16/99-0008 = WG21 N1185). Therefore, the 
 iterators only meet the requirements of input iterator and output iterator. This 
 is so nonintuitive that at least one implementation erroneously assigns 
@@ -70,16 +70,16 @@ is so nonintuitive that at least one implementation erroneously assigns
 not return true references: there is the often cited example of disk-based 
 collections. 
 </p><p>Another example is a counting iterator, an iterator the returns a sequence of 
-integers when incremented and dereferenced (see <a href="http://www.boost.org/libs/iterator/doc/counting_iterator.html"><tt>boost::counting_iterator</tt></a>). 
+integers when incremented and dereferenced (see <a href="http://www.boost.org/libs/utility/counting_iterator.htm"><tt>boost::counting_iterator</tt></a>). 
 There are two ways to implement this iterator, 1) make the <tt>reference</tt> 
 type be a true reference (a reference to an integer data member of the counting 
 iterator) or 2) make the <tt>reference</tt> type be the same as the 
-<tt>value_type</tt>. Option 1) runs into the problems discussed in <a href="http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-active.html#198">Issue 
+<tt>value_type</tt>. Option 1) runs into the problems discussed in <a href="http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/lwg-active.html#198">Issue 
 198</a>, the reference will not be valid after the iterator is destroyed. Option 
 2) is therefore a better choice, but then we have a counting iterator that 
 cannot be a random access iterator. 
 </p><p>Yet another example is a transform iterator, an iterator adaptor that applies 
-a unary function object to the dereference value of the wrapped iterator (see <a href="http://www.boost.org/libs/iterator/doc/transform_iterator.html"><tt>boost::transform_iterator</tt></a>). 
+a unary function object to the dereference value of the wrapped iterator (see <a href="http://www.boost.org/libs/utility/transform_iterator.htm"><tt>boost::transform_iterator</tt></a>). 
 For unary functions such as <tt>std::times</tt> the return type of 
 <tt>operator*</tt> clearly needs to be the <tt>result_type</tt> of the function 
 object, which is typically not a reference. However, with the current iterator 
@@ -794,4 +794,4 @@ Comparable</a> where <tt>&lt;</tt> is a total ordering
 
  --><!--  LocalWords:  Postdecrement
 
- --></body></html>
+ --></body></html>

doc/test_cases.html

@@ -20,7 +20,7 @@ Boost.MultiArray: Test Descriptions
 </title>
 </head>
 <body bgcolor="#ffffff" text="#000000">
-<IMG SRC="../../../boost.png" 
+<IMG SRC="http://www.boost.org/boost.png" 
      ALT="C++ Boost" width="277" height="86"> 
 <h1>Boost.MultiArray: Test Descriptions</h1>
 
@@ -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
@@ -459,7 +443,7 @@ indices will remain zero-based.
 <blockquote>
 <pre>
   typedef boost::multi_array&lt;double,3&gt; array_type;
-  array_type A(boost::extents[3][4][2],boost::fortran_storage_order()); 
+  array_type A(boost::extents[3][4][2],boost::fortran_storage_order); 
   call_fortran_function(A.data());
 </pre>
 </blockquote>
@@ -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 
@@ -627,7 +582,7 @@ cases can be found <a href="./test_cases.html">here</a>.
     arrays.
 
 This library is analogous to 
-<a href="../../array/index.html">boost::array</a> in that it augments C style N-dimensional
+<a href="">boost::array</a> in that it augments C style N-dimensional
 arrays, as <tt>boost::array</tt> does for C one-dimensional arrays.
 
 
@@ -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++.
 
@@ -661,11 +616,6 @@ arrays, as <tt>boost::array</tt> does for C one-dimensional arrays.
       <li><a href="mailto:bdawes@acm.org">Beman Dawes</a>
       helped immensely with porting the library to Microsoft Windows
       compilers.
-
-      <li><a href="mailto:glenjofe@gmail.com">Glen Fernandes</a>
-      implemented support for the C++11 allocator model, including
-      support for stateful allocators, minimal allocators, and
-      optimized storage for stateless allocators.
 </ul>
 
 <hr>
@@ -674,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: Tue Sep 10 11:14:15 EST 2002
+<!-- hhmts end -->
 
 </body>
 </html>

doc/xml/Jamfile.v2

@@ -1,19 +0,0 @@
-#   Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
-  
-#   Distributed under 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)
-project multi_array/doc ;
-import boostbook : boostbook ;
-
-path-constant here : . ;
-
-boostbook multi_array-doc 
-    : 
-    bbref.xml 
-    :
-        <xsl:param>boost.root=../../../../..
-        <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
-        <format>pdf:<xsl:param>img.src.path=$(here)/../
-    ;
-

doc/xml/MultiArray.xml

@@ -110,14 +110,6 @@ are stored contiguously) or by column (i.e., the elements of each
 column are stored contiguously).
 </para>
 
-<para>
-Two concept checking classes for the MultiArray concepts
-(<literal>ConstMultiArrayConcept</literal> and
-<literal>MutableMultiArrayConcept</literal>) are in the namespace
-<literal>boost::multi_array_concepts</literal> in
-<literal>&lt;boost/multi_array/concept_checks.hpp&gt;</literal>.
-</para>
-
 
 <sect2><title>Notation</title>
 <para>What follows are the descriptions of symbols that will be used
@@ -132,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>
@@ -248,17 +240,15 @@ iterators. It is the same type as
 <entry>
 This is an iterator over the values of <literal>A</literal>.
 If <literal>NumDims == 1</literal>, then it models 
-<ulink url="http://www.boost.org/doc/html/RandomAccessIterator.html">
+<ulink url="http://www.sgi.com/tech/stl/RandomAccessIterator.html">
 <literal>Random Access Iterator</literal></ulink>. 
 Otherwise it models 
 <ulink url="./iterator_categories.html#concept_RandomAccessTraversalIterator">
 Random Access Traversal Iterator</ulink>,
 <ulink url="./iterator_categories.html#concept_ReadableIterator">
-Readable Iterator</ulink>,
+Readable Iterator</ulink>, and
 <ulink url="./iterator_categories.html#concept_WritableIterator">
-Writable Iterator</ulink>, and 
-<ulink url="http://www.boost.org/doc/html/OutputIterator.html">
-<literal>Output Iterator</literal></ulink>.
+Writable Iterator</ulink>.
 </entry>
 </row>
 
@@ -395,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>
@@ -977,7 +960,7 @@ object. This object can then be used to generate tuples of
 	      </row>
 	      <row>
 		<entry><literal>x[idx]</literal></entry>
-		<entry><literal>gen_type&lt;Dims,Ranges+1&gt;::type</literal>
+		<entry><literal>gen_type&lt;Dims,Ranges&gt;::type</literal>
 </entry>
 	<entry>Returns a new object containing all previous
 <classname>index_range</classname> objects in addition to a degenerate

doc/xml/bbref.xml

@@ -1,806 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
-  "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd" [
- <!ENTITY concepts SYSTEM "MultiArray.xml">
- <!ENTITY multi_array SYSTEM "multi_array.xml">
- <!ENTITY multi_array_ref SYSTEM "multi_array_ref.xml">
- <!ENTITY const_multi_array_ref SYSTEM "const_multi_array_ref.xml">
-]>
-<library name="MultiArray" dirname="multi_array" id="multi_array"
-   xmlns:xi="http://www.w3.org/2001/XInclude"
-   last-revision="$Date$">
-  <libraryinfo>
-    <author>
-      <firstname>Ronald</firstname>
-      <surname>Garcia</surname>
-      <affiliation>
-	<orgname>Indiana University</orgname>
-	<orgdiv>Open Systems Lab</orgdiv>
-      </affiliation>
-    </author>
-    <orgname>BOOST</orgname>
-    <copyright>
-      <year>2002</year>
-      <holder>The Trustees of Indiana University</holder>
-    </copyright>
-       <librarypurpose>Multidimensional containers and adaptors for
-       arrays of contiguous data</librarypurpose>
-       <librarycategory name="category:math"/>
-       <librarycategory name="category:containers"/>
-  </libraryinfo>
-
-<title>Boost.MultiArray Reference Manual</title>
-
-
-<para>Boost.MultiArray is composed of several components.
-The MultiArray concept defines a generic interface to multidimensional
-containers.
-<literal>multi_array</literal> is a general purpose container class
-that models MultiArray. <literal>multi_array_ref</literal>
-and <literal>const_multi_array_ref</literal> are adapter
-classes. Using them, 
-you can manipulate any block of contiguous data as though it were a
-<literal>multi_array</literal>.
-<literal>const_multi_array_ref</literal> differs from
-<literal>multi_array_ref</literal> in that its elements cannot
-be modified through its interface. Finally, several auxiliary classes are used
-to create and specialize arrays and some global objects are defined as
-part of the library interface.</para>
-
-<sect1 id="synopsis">
-<title>Library Synopsis</title>
-    <para>To use Boost.MultiArray, you must include the header 
-<filename>boost/multi_array.hpp</filename> in your source. This file
-brings the following declarations into scope:</para>
-<programlisting>
-<![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;
-  }
-
-  template <typename ValueType, 
-            std::size_t NumDims, 
-            typename Allocator = std::allocator<ValueType> >
-  class multi_array;
-
-  template <typename ValueType, 
-            std::size_t NumDims>
-  class multi_array_ref;
-
-  template <typename ValueType, 
-            std::size_t NumDims> 
-  class const_multi_array_ref;
-
-  multi_array_types::extent_gen extents;
-  multi_array_types::index_gen  indices;
-
-  template <typename Array, int N> class subarray_gen;
-  template <typename Array, int N> class const_subarray_gen;
-  template <typename Array, int N> class array_view_gen;
-  template <typename Array, int N> class const_array_view_gen;
-
-  class c_storage_order; 
-  class fortran_storage_order;
-  template <std::size_t NumDims> class general_storage_order;
-
-}]]>
-</programlisting>
-</sect1>
-
-&concepts;
-
-<sect1 id="array_types">
-<title>Array Components</title>
-<para>
-Boost.MultiArray defines an array class,
-<literal>multi_array</literal>, and two adapter classes,
-<literal>multi_array_ref</literal> and 
-<literal>const_multi_array_ref</literal>. The three classes model 
-MultiArray and so they share a lot of functionality.
-<literal>multi_array_ref</literal> differs from
-<literal>multi_array</literal> in that the
-<literal>multi_array</literal> manages its own memory, while
-<literal>multi_array_ref</literal> is passed a block of memory that it
-expects to be externally managed.
-<literal>const_multi_array_ref</literal> differs from
-<literal>multi_array_ref</literal> in that the underlying elements it
-adapts cannot be modified through its interface, though some array
-properties, including the array shape and index bases, can be altered.
-Functionality the classes have in common is described
-below.
-</para>
-
-<formalpara>
-<title>Note: Preconditions, Effects, and Implementation</title>
-<para>
-Throughout the following sections, small pieces of C++ code are
-used to specify constraints such as preconditions, effects, and
-postconditions.  These do not necessarily describe the underlying
-implementation of array components; rather, they describe the 
-expected input to and
-behavior of the specified operations.  Failure to meet
-preconditions results in undefined behavior. Not all effects
-(i.e. copy constructors, etc.) must be mimicked exactly.  The code
-snippets for effects intend to capture the essence of the described
-operation. 
-</para>
-</formalpara>
-
-<formalpara>
-<title>Queries</title>
-
-<variablelist>
-<varlistentry>
-<term><programlisting>element* data();
-const element* data() const;</programlisting></term>
-<listitem>
-<para>This returns a pointer to the beginning of the
-contiguous block that contains the array's data. If all dimensions of
-the array are 0-indexed and stored in ascending order, this is 
-equivalent to <literal>origin()</literal>. Note that
-<literal>const_multi_array_ref</literal> only provides the const
-version of this function.
-</para>
-</listitem>
-</varlistentry>
-
-<varlistentry>
-<term><programlisting>element* origin();
-const element* origin() const;</programlisting></term>
-<listitem>
-<para>This returns the origin element of the
-<literal>multi_array</literal>. Note that
-<literal>const_multi_array_ref</literal> only provides the const
-version of this function. (Required by MultiArray)
-</para>
-</listitem>
-</varlistentry>
-
-<varlistentry>
-<term><function>const index* index_bases();</function></term>
-<listitem>
-<para>This returns the index bases for the
-<literal>multi_array</literal>. (Required by MultiArray)
-</para>
-</listitem>
-</varlistentry>
-
-<varlistentry>
-<term><function>const index* strides();</function></term>
-<listitem>
-<para>This returns the strides for the
-<literal>multi_array</literal>. (Required by MultiArray)
-</para>
-</listitem>
-</varlistentry>
-
-<varlistentry>
-<term><function>const size_type* shape();</function></term>
-<listitem>
-<para>This returns the shape of the
-<literal>multi_array</literal>. (Required by MultiArray)
-</para>
-</listitem>
-</varlistentry>
-</variablelist>
-
-</formalpara>
-
-<formalpara>
-<title>Comparators</title>
-<variablelist>
-<varlistentry>
-<term><programlisting><![CDATA[
-bool operator==(const *array-type*& rhs);
-bool operator!=(const *array-type*& rhs);
-bool operator<(const *array-type*& rhs);
-bool operator>(const *array-type*& rhs);
-bool operator>=(const *array-type*& rhs);
-bool operator<=(const *array-type*& rhs);]]></programlisting></term>
-
-<listitem>
-<para>Each comparator executes a lexicographical compare over
-the value types of the two arrays.
-(Required by MultiArray)
-</para>
-<formalpara>
-<title>Preconditions</title>
-<para><literal>element</literal> must support the
-comparator corresponding to that called on
-<literal>multi_array</literal>.</para>
-</formalpara>
-
-<formalpara>
-<title>Complexity</title>
-<para>O(<literal>num_elements()</literal>).</para>
-</formalpara>
-
-</listitem>
-</varlistentry>
-
-</variablelist>
-</formalpara>
-
-<formalpara>
-<title>Modifiers</title>
-
-<variablelist>
-
-<varlistentry>
-<term>
-<programlisting>
-<![CDATA[
-template <typename SizeList>
-void reshape(const SizeList& sizes)
-]]>
-</programlisting>
-</term>
-
-<listitem>
-<para>This changes the shape of the <literal>multi_array</literal>.  The
-number of elements and the index bases remain the same, but the number
-of values at each level of the nested container hierarchy may
-change.</para>
-
-<formalpara><title><literal>SizeList</literal> Requirements</title>
-<para><literal>SizeList</literal> must model
-<ulink url="../../utility/Collection.html">Collection</ulink>.</para>
-</formalpara>
-
-<formalpara><title>Preconditions</title>
-<para>
-<programlisting>
-<![CDATA[std::accumulate(sizes.begin(),sizes.end(),size_type(1),std::times<size_type>()) == this->num_elements();
-sizes.size() == NumDims;]]>
-</programlisting></para>
-</formalpara>
-
-
-<formalpara><title>Postconditions</title>
-<para>
-<literal>std::equal(sizes.begin(),sizes.end(),this->shape) == true;</literal>
-</para>
-</formalpara>
-</listitem>
-</varlistentry>
-
-<varlistentry>
-<term>
-<programlisting>
-<![CDATA[
-template <typename BaseList>
-void reindex(const BaseList& values);
-]]>
-</programlisting>
-</term>
-<listitem>
-<para>This changes the index bases of the <literal>multi_array</literal> to
-correspond to the the values in <literal>values</literal>.</para>
-
-<formalpara>
-<title><literal>BaseList</literal> Requirements</title>
-<para><literal>BaseList</literal> must model
-<ulink url="../../utility/Collection.html">Collection</ulink>.</para>
-</formalpara>
-
-<formalpara>
-<title>Preconditions</title>
-<para><literal>values.size() == NumDims;</literal></para>
-</formalpara>
-
-
-<formalpara>
-<title>Postconditions</title>
-<para><literal>std::equal(values.begin(),values.end(),this->index_bases());
-</literal></para>
-</formalpara>
-</listitem>
-</varlistentry>
-
-<varlistentry>
-<term>
-<programlisting>
-<![CDATA[
-void reindex(index value);
-]]>
-</programlisting>
-</term>
-<listitem>
-<para>This changes the index bases of all dimensions of the
-<literal>multi_array</literal> to <literal>value</literal>.</para>
-
-<formalpara>
-<title>Postconditions</title>
-<para>
-<programlisting>
-<![CDATA[
-std::count_if(this->index_bases(),this->index_bases()+this->num_dimensions(),
-              std::bind_2nd(std::equal_to<index>(),value)) == 
-              this->num_dimensions();
-]]>
-</programlisting>
-</para>
-</formalpara>
-</listitem>
-</varlistentry>
-
-</variablelist>
-</formalpara>
-
-&multi_array;
-&multi_array_ref;
-&const_multi_array_ref;
-
-</sect1>
-
-
-<sect1 id="auxiliary">
-    <title>Auxiliary Components</title>
-
-<sect2 id="multi_array_types">
-<title><literal>multi_array_types</literal></title>
-
-<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;
-}]]>
-</programlisting>
-
-<para>Namespace <literal>multi_array_types</literal> defines types
-associated with <literal>multi_array</literal>,
-<literal>multi_array_ref</literal>, and
-<literal>const_multi_array_ref</literal> that are not
-dependent upon template parameters.  These types find common use with
-all Boost.Multiarray components.  They are defined
-in a namespace from which they can be accessed conveniently.
-With the exception of <literal>extent_gen</literal> and 
-<literal>extent_range</literal>, these types fulfill the roles of the
-same name required by MultiArray and are described in its
-concept definition.  <literal>extent_gen</literal> and
-<literal>extent_range</literal> are described below.
-</para>
-</sect2>
-
-
-<sect2 id="extent_range">
-    <title><classname>extent_range</classname></title>
-
-<para><classname>extent_range</classname> objects define half open
-intervals.  They provide shape and index base information to
-<literal>multi_array</literal>, <literal>multi_array_ref</literal>,
- and <literal>const_multi_array_ref</literal> constructors.
-<classname>extent_range</classname>s are passed in
-aggregate to an array constructor (see
-<classname>extent_gen</classname> for more details).
-</para>
-
-<formalpara>
-	<title>Synopsis</title>
-<programlisting><![CDATA[
-class extent_range {
-public:
-  typedef multi_array_types::index      index;
-  typedef multi_array_types::size_type  size_type;
-
-  // Structors
-  extent_range(index start, index finish);
-  extent_range(index finish);
-  ~extent_range();
-
-  // Queries
-  index start();
-  index finish();
-  size_type size();
-};]]></programlisting>
-</formalpara>
-
-      <formalpara>
-	<title>Model Of</title>
-	<para>DefaultConstructible,CopyConstructible</para>
-      </formalpara>
-
-<formalpara><title>Methods and Types</title>
-<variablelist>
-<varlistentry>
-<term><function>extent_range(index start, index finish)</function></term>
-<listitem>
-<para>  This constructor defines the half open interval
-<literal>[start,finish)</literal>. The expression
-<literal>finish</literal> must be greater than <literal>start</literal>.
-</para>
-</listitem>
-</varlistentry>
-
-<varlistentry><term><function>extent_range(index finish)</function></term>
-<listitem>
-<para>This constructor defines the half open interval
-<literal>[0,finish)</literal>. The value of <literal>finish</literal>
-must be positive.</para> 
-</listitem>
-</varlistentry>
-
-<varlistentry><term><function>index start()</function></term>
-<listitem>
-<para>This function returns the first index represented by the range</para>
-</listitem>
-</varlistentry>
-
-<varlistentry><term><function>index finish()</function></term>
-<listitem>
-<para>This function returns the upper boundary value of the half-open
-interval.  Note that the range does not include this value.</para>
-</listitem>
-</varlistentry>
-
-<varlistentry>
-<term><function>size_type size()</function></term>
-<listitem>
-<para>This function returns the size of the specified range. It is
-equivalent to <literal>finish()-start()</literal>.</para>
-</listitem>
-</varlistentry>
-
-</variablelist>
-</formalpara>
-</sect2>
-
-<sect2 id="extent_gen">
-    <title><classname>extent_gen</classname></title>
-    <para>The <classname>extent_gen</classname> class defines an
-interface for aggregating array shape and indexing information to be
-passed to a <literal>multi_array</literal>, 
-<literal>multi_array_ref</literal>, or <literal>const_multi_array_ref</literal>
-constructor. Its interface mimics 
- the syntax used to declare built-in array types
-in C++. For example, while a 3-dimensional array of 
-<classname>int</classname> values in C++ would be
-declared as:
-<programlisting>int A[3][4][5],</programlisting>
-a similar <classname>multi_array</classname> would be declared:
-<programlisting>multi_array&lt;int,3&gt; A(extents[3][4][5]).</programlisting>
-</para>
-
-<formalpara><title>Synopsis</title>
-<programlisting><![CDATA[
-template <std::size_t NumRanges>
-class *implementation_defined* {
-public:
-  typedef multi_array_types::index index;
-  typedef multi_array_types::size_type size_type;
-
-  template <std::size_t NumRanges> class gen_type;
-
-  gen_type<NumRanges+1>::type  operator[](const range& a_range) const;
-  gen_type<NumRanges+1>::type  operator[](index idx) const;
-};
-
-typedef *implementation_defined*<0> extent_gen;
-]]></programlisting>
-</formalpara>
-
-<formalpara><title>Methods and Types</title>
-<variablelist>
-<varlistentry>
-<term><function>template gen_type&lt;Ranges&gt;::type</function></term>
-<listitem>
-<para>This type generator is used to specify the result of 
-<literal>Ranges</literal> chained calls to
-<literal>extent_gen::operator[].</literal> The types
-<classname>extent_gen</classname> and
-<classname>gen_type&lt;0&gt;::type</classname> are the same.</para>
-</listitem>
-</varlistentry>
-
-<varlistentry>
-<term><function>gen_type&lt;NumRanges+1&gt;::type  
-operator[](const extent_range&amp; a_range) const;</function></term>
-<listitem>
-<para>This function returns a new object containing all previous
-<classname>extent_range</classname> objects in addition to
-<literal>a_range.</literal> <classname>extent_range</classname>
-objects are aggregated by chained calls to
-<function>operator[]</function>.</para>
-</listitem>
-</varlistentry>
-
-<varlistentry>
-<term><function>gen_type&lt;NumRanges+1&gt;::type
-operator[](index idx) const;</function></term>
-<listitem>
-<para>This function returns a new object containing all previous
-<classname>extent_range</classname> objects in addition to
-<literal>extent_range(0,idx).</literal> This function gives the array
-constructors a similar syntax to traditional C multidimensional array
-declaration.</para>
-</listitem>
-</varlistentry>
-
-</variablelist>
-</formalpara>      
-</sect2>
-  
-<sect2>
-    <title>Global Objects</title>
-    <para>For syntactic convenience, Boost.MultiArray defines two 
-global objects as part of its
-interface.  These objects play the role of object generators;
-expressions involving them create other objects of interest.
-</para>
-
-    <para> Under some circumstances, the two global objects may be
-considered excessive overhead.  Their construction can be prevented by
-defining the preprocessor symbol
-<literal>BOOST_MULTI_ARRAY_NO_GENERATORS</literal> before including
-<filename>boost/multi_array.hpp.</filename></para>
-
-<sect3 id="extents">
-<title><literal>extents</literal></title>
-
-<programlisting>
-<![CDATA[namespace boost {
-  multi_array_base::extent_gen extents;
-}]]>
-</programlisting>
-
-    <para>Boost.MultiArray's array classes use the
-<literal>extents</literal> global object to specify 
-array shape during their construction. 
-For example,
-a 3 by 3 by 3 <classname>multi_array</classname> is constructed as follows:
-<programlisting>multi_array&lt;int,3&gt; A(extents[3][3][3]);</programlisting>
-The same array could also be created by explicitly declaring an <literal>extent_gen</literal> 
-object locally,, but the global object makes this declaration unnecessary.  
-</para>
-</sect3>
-
-<sect3 id="indices">
-<title><literal>indices</literal></title>
-
-<programlisting>
-<![CDATA[namespace boost {
-  multi_array_base::index_gen  indices;
-}]]>
-</programlisting>
-
-      <para>The MultiArray concept specifies an
-<literal>index_gen</literal> associated type that is used to
-create views.
-<literal>indices</literal> is a global object that serves the role of
-<literal>index_gen</literal> for all array components provided by this
-library and their associated subarrays and views. 
-</para>
-<para>For example, using the <literal>indices</literal> object,
-a view of an array <literal>A</literal> is constructed as follows:
-<programlisting>
-A[indices[index_range(0,5)][2][index_range(2,4)]];
-</programlisting>
-</para>
-</sect3>
-</sect2>
-
-<sect2 id="generators">
-<title>View and SubArray Generators</title>
-<para>
-Boost.MultiArray provides traits classes, <literal>subarray_gen</literal>,
-<literal>const_subarray_gen</literal>,
-<literal>array_view_gen</literal>,
-and <literal>const_array_view_gen</literal>, for naming of
-array associated types within function templates.  
-In general this is no more convenient to use than the nested 
-type generators, but the library author found that some C++ compilers do not 
-properly handle templates nested within function template parameter types. 
-These generators constitute a workaround for this deficit.  
-The following code snippet illustrates
-the correspondence between the <literal>array_view_gen</literal>
-traits class and the <literal>array_view</literal> type associated to
-an array:
-
-<programlisting>
-template &lt;typename Array&gt;
-void my_function() {
-  typedef typename Array::template array_view&lt;3&gt;::type view1_t;
-  typedef typename boost::array_view_gen&lt;Array,3&gt;::type view2_t;
-  // ...
-}
-</programlisting>
-
-In the above example, <literal>view1_t</literal> and
-<literal>view2_t</literal> have the same type.
-</para>
-</sect2>
-
-
-<sect2 id="memory_layout">
-<title>Memory Layout Specifiers</title>
-<para>
-While a multidimensional array represents a hierarchy of containers of
-elements, at some point the elements must be laid out in
-memory.  As a result, a single multidimensional array 
-can be represented in memory more than one way.
-</para>
-
-<para>For example, consider the two dimensional array shown below in
-matrix notation:
-
-<graphic fileref="matrix.gif"/>
-
-Here is how the above array is expressed in C++:
-<programlisting>
-int a[3][4] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
-</programlisting>
-This is an example of row-major storage, where elements of each row
-are stored contiguously.  
-
-While C++ transparently handles accessing elements of an array, you
-can also manage the array and its indexing manually.  One way that 
-this may be expressed in memory is as follows:
-<programlisting>
-int a[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
-int s[] = { 4, 1 };
-</programlisting>
-
-With the latter declaration of <literal>a</literal> and 
-strides <literal>s</literal>, element <literal>a(i,j)</literal>
-of the array can be
-accessed using the expression 
-<programlisting>*a+i*s[0]+j*s[1]</programlisting>.
-</para>
-
-<para>The same two dimensional array could be laid out by column as follows:
-
-<programlisting>
-int a[] = { 0, 4, 8, 1, 5, 9, 2, 6, 10, 3, 7, 11 };
-int s[] = { 3, 1 };
-</programlisting>
-Notice that the strides here are different. As a result,
-The expression given above to access values will work with this pair
-of data and strides as well.
-</para>
-
-<para>In addition to dimension order, it is also possible to
-store any dimension in descending order. For example, returning to the 
-first example, the first dimension of the example array, the 
-rows,  could be stored in 
-reverse, resulting in the following:
-
-<programlisting>
-int data[] = { 8, 9, 10, 11, 4, 5, 6, 7, 0, 1, 2, 3 };
-int *a = data + 8;
-int s[] = { -4, 1 };
-</programlisting>
-
-Note that in this example <literal>a</literal> must be explicitly set
-to the origin. In the previous examples, the
-first element stored in memory was the origin; here this is no longer
-the case. 
-</para>
-
-<para>
-Alternatively, the second dimension, or the columns, could be reversed
-and the rows stored in ascending order:
-
-<programlisting>
-int data[] = { 3, 2, 1, 0,  7, 6, 5, 4, 11, 10, 9, 8 };
-int *a = data + 3;
-int s[] = { 4, -1 };
-</programlisting>
-</para>
-
-<para>
-Finally, both dimensions could be stored in descending order:
-
-<programlisting>
-int data[] = {11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
-int *a = data + 11;
-int s[] = { -4, -1 };
-</programlisting>
-<literal>
-</literal>
-</para>
-
-<para>
-All of the above arrays are equivalent. The expression
-given above for <literal>a(i,j)</literal> will yield the same value
-regardless of the memory layout.
-
-Boost.MultiArray arrays can be created with customized storage
-parameters as described above. Thus, existing data can be adapted
-(with <literal>multi_array_ref</literal> or
-<literal>const_multi_array_ref</literal>) as suited to the array
-abstraction.  A common usage of this feature would be to wrap arrays
-that must interoperate with Fortran routines so they can be
-manipulated naturally at both the C++ and Fortran levels. The
-following sections describe the Boost.MultiArray components used to
-specify memory layout.
-</para>
-
-<sect3 id="c_storage_order">
-<title><literal>c_storage_order</literal></title>
-<programlisting>
-<![CDATA[class c_storage_order {
-  c_storage_order();
-};]]>
-</programlisting>
-
-<para><literal>c_storage_order</literal> is used to specify that an
-array should store its elements using the same layout as that used by
-primitive C++ multidimensional arrays, that is, from last dimension
-to first. This is the default storage order for the arrays provided by
-this library.</para>
-</sect3>
-
-<sect3 id="fortran_storage_order">
-<title><literal>fortran_storage_order</literal></title>
-<programlisting>
-<![CDATA[class fortran_storage_order {
-  fortran_storage_order();
-};]]>
-</programlisting>
-
-<para><literal>fortran_storage_order</literal> is used to specify that
-an array should store its elements using the same memory layout as a
-Fortran multidimensional array would, that is, from first dimension to
-last.</para>
-</sect3>
-
-<sect3 id="general_storage_order">
-<title><literal>general_storage_order</literal></title>
-<programlisting>
-<![CDATA[template <std::size_t NumDims> 
-class general_storage_order {
-
-  template <typename OrderingIter, typename AscendingIter>
-  general_storage_order(OrderingIter ordering, AscendingIter ascending);
-};]]>
-</programlisting>
-
-<para><literal>general_storage_order</literal> allows the user to
-specify an arbitrary memory layout for the contents of an array.  The
-constructed object is passed to the array constructor in order to
-specify storage order.</para>
-
-<para>
-<literal>OrderingIter</literal> and <literal>AscendingIter</literal>
-must model the <literal>InputIterator</literal> concept.  Both
-iterators must refer to a range of <literal>NumDims</literal>
-elements.  <literal>AscendingIter</literal> points to objects
-convertible to <literal>bool</literal>.  A value of
-<literal>true</literal> means that a dimension is stored in ascending
-order while <literal>false</literal> means that a dimension is stored
-in descending order.  <literal>OrderingIter</literal> specifies the
-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>
-
-
-</library>

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

@@ -1,4 +1,4 @@
-<sect2 id="multi_array_class">
+<sect2 id="multi_array">
 <title><literal>multi_array</literal></title>
 
 <para>
@@ -36,22 +36,22 @@ 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
   template <std::size_t Dims> struct            subarray;
@@ -60,12 +60,9 @@ public:
   template <std::size_t Dims> struct            const_array_view;
   
 
-  static const std::size_t dimensionality = NumDims;
-  
-
   // constructors and destructors
 
-  multi_array(const Allocator& alloc = Allocator());
+  multi_array();
 
   template <typename ExtentList>
   explicit multi_array(const ExtentList& sizes,
@@ -75,19 +72,13 @@ public:
                        const storage_order_type& store = c_storage_order(),
 	               const Allocator& alloc = Allocator());
   multi_array(const multi_array& x);
-  multi_array(const const_multi_array_ref<ValueType,NumDims>& x,
-              const Allocator& alloc = Allocator());
-  multi_array(const const_subarray<NumDims>::type& x,
-              const Allocator& alloc = Allocator());
-  multi_array(const const_array_view<NumDims>::type& x,
-              const Allocator& alloc = Allocator());
+  multi_array(const const_multi_array_ref<ValueType,NumDims>& x);
+  multi_array(const const_subarray<NumDims>::type& x);
+  multi_array(const const_array_view<NumDims>::type& x);
 
-  multi_array(const multi_array_ref<ValueType,NumDims>& x,
-              const Allocator& alloc = Allocator());
-  multi_array(const subarray<NumDims>::type& x,
-              const Allocator& alloc = Allocator());
-  multi_array(const array_view<NumDims>::type& x,
-              const Allocator& alloc = Allocator());
+  multi_array(const multi_array_ref<ValueType,NumDims>& x);
+  multi_array(const subarray<NumDims>::type& x);
+  multi_array(const array_view<NumDims>::type& x);
 
   ~multi_array();
 
@@ -145,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);
 };
 ]]>
@@ -213,18 +202,12 @@ elements.
 <varlistentry>
 <term><programlisting>
 <![CDATA[multi_array(const multi_array& x);
-multi_array(const const_multi_array_ref<ValueType,NumDims>& x,
-    const Allocator& alloc = Allocator());
-multi_array(const const_subarray<NumDims>::type& x,
-    const Allocator& alloc = Allocator());
-multi_array(const const_array_view<NumDims>::type& x,
-    const Allocator& alloc = Allocator());
-multi_array(const multi_array_ref<ValueType,NumDims>& x,
-    const Allocator& alloc = Allocator());
-multi_array(const subarray<NumDims>::type& x,
-    const Allocator& alloc = Allocator());
-multi_array(const array_view<NumDims>::type& x,
-    const Allocator& alloc = Allocator());]]>
+multi_array(const const_multi_array_ref<ValueType,NumDims>& x);
+multi_array(const const_subarray<NumDims>::type& x);
+multi_array(const const_array_view<NumDims>::type& x);
+multi_array(const multi_array_ref<ValueType,NumDims>& x);
+multi_array(const subarray<NumDims>::type& x);
+multi_array(const array_view<NumDims>::type& x);]]>
 </programlisting></term>
 <listitem>
 <para>These constructors all constructs a <literal>multi_array</literal> and 
@@ -344,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;
@@ -59,10 +60,7 @@ public:
   template <std::size_t Dims> struct            const_array_view;
   
 
-  static const std::size_t dimensionality = NumDims;
-
-
-  // constructors and destructors
+  // structors
 
   template <typename ExtentList>
   explicit multi_array_ref(element* data, const ExtentList& sizes,

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>
 
@@ -488,7 +488,7 @@ typedef *implementation_defined*<0> extent_gen;
 <formalpara><title>Methods and Types</title>
 <variablelist>
 <varlistentry>
-<term><function>template gen_type&lt;Ranges&gt;::type</function></term>
+<term><function>template gen_type::&lt;Ranges&gt;::type</function></term>
 <listitem>
 <para>This type generator is used to specify the result of 
 <literal>Ranges</literal> chained calls to
@@ -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>
 

example/for_each.hpp

@@ -45,7 +45,7 @@ void for_each (const boost::type<Element>& type_dispatch,
 template <typename Array, typename Functor>
 void for_each (Array& A, Functor xform) {
   // Dispatch to the proper function
-  for_each(boost::type<typename Array::element>(),A.begin(),A.end(),xform);
+  for_each(boost::type<Array::element>(),A.begin(),A.end(),xform);
 }
 
 

example/resize_from_other.cpp

@@ -1,57 +0,0 @@
-// Copyright 2008 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.
-
-//
-// resize_from_other.cpp - an experiment in writing a resize function for
-// multi_arrays that will use the extents from another to build itself.
-//
-
-#include <boost/multi_array.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/array.hpp>
-#include <algorithm>
-
-template <typename T, typename U, std::size_t N>
-void
-resize_from_MultiArray(boost::multi_array<T,N>& marray, U& other) {
-
-  // U must be a model of MultiArray
-  boost::function_requires<
-  boost::multi_array_concepts::ConstMultiArrayConcept<U,U::dimensionality> >();
-  // U better have U::dimensionality == N
-  BOOST_STATIC_ASSERT(U::dimensionality == N);
-
-  boost::array<typename boost::multi_array<T,N>::size_type, N> shape;
-
-  std::copy(other.shape(), other.shape()+N, shape.begin());
-
-  marray.resize(shape);
-  
-}
-
-#include <iostream>
-
-
-int main () {
-
-  boost::multi_array<int,2> A(boost::extents[5][4]), B;
-  boost::multi_array<int,3> C;
-
-  resize_from_MultiArray(B,A);
-
-#if 0
-  resize_from_MultiArray(C,A); // Compile-time error
-#endif
-
-  std::cout << B.shape()[0] << ", " << B.shape()[1] << '\n';
-
-}

include/boost/multi_array.hpp

@@ -1,8 +1,5 @@
 // Copyright 2002 The Trustees of Indiana University.
 
-// Copyright 2018 Glen Joseph Fernandes
-// (glenjofe@gmail.com)
-
 // 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)
@@ -21,11 +18,6 @@
 // declaration and definition
 //
 
-#if defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 406)
-#  pragma GCC diagnostic push
-#  pragma GCC diagnostic ignored "-Wshadow"
-#endif
-
 #include "boost/multi_array/base.hpp"
 #include "boost/multi_array/collection_concept.hpp"
 #include "boost/multi_array/copy_array.hpp"
@@ -33,8 +25,6 @@
 #include "boost/multi_array/subarray.hpp"
 #include "boost/multi_array/multi_array_ref.hpp"
 #include "boost/multi_array/algorithm.hpp"
-#include "boost/multi_array/allocators.hpp"
-#include "boost/core/empty_value.hpp"
 #include "boost/array.hpp"
 #include "boost/mpl/if.hpp"
 #include "boost/type_traits.hpp"
@@ -52,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);
         }
       };
 
@@ -119,10 +108,8 @@ struct disable_multi_array_impl<int>
 template<typename T, std::size_t NumDims,
   typename Allocator>
 class multi_array :
-  public multi_array_ref<T,NumDims>,
-  private boost::empty_value<Allocator>
+  public multi_array_ref<T,NumDims>
 {
-  typedef boost::empty_value<Allocator> alloc_base;
   typedef multi_array_ref<T,NumDims> super_type;
 public:
   typedef typename super_type::value_type value_type;
@@ -149,25 +136,22 @@ public:
     typedef boost::detail::multi_array::multi_array_view<T,NDims> type;
   };
 
-  explicit multi_array(const Allocator& alloc = Allocator()) :
+  explicit multi_array() :
     super_type((T*)initial_base_,c_storage_order(),
-               /*index_bases=*/0, /*extents=*/0),
-    alloc_base(boost::empty_init_t(),alloc) {
+               /*index_bases=*/0, /*extents=*/0) {
     allocate_space(); 
   }
 
   template <class ExtentList>
   explicit multi_array(
-      ExtentList const& extents,
-      const Allocator& alloc = Allocator()
+      ExtentList const& extents
 #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
       , typename mpl::if_<
       detail::multi_array::is_multi_array_impl<ExtentList>,
       int&,int>::type* = 0
 #endif
       ) :
-    super_type((T*)initial_base_,extents),
-    alloc_base(boost::empty_init_t(),alloc) {
+    super_type((T*)initial_base_,extents) {
     boost::function_requires<
       detail::multi_array::CollectionConcept<ExtentList> >();
     allocate_space();
@@ -177,8 +161,7 @@ public:
   template <class ExtentList>
   explicit multi_array(ExtentList const& extents,
                        const general_storage_order<NumDims>& so) :
-    super_type((T*)initial_base_,extents,so),
-    alloc_base(boost::empty_init_t()) {
+    super_type((T*)initial_base_,extents,so) {
     boost::function_requires<
       detail::multi_array::CollectionConcept<ExtentList> >();
     allocate_space();
@@ -188,8 +171,7 @@ public:
   explicit multi_array(ExtentList const& extents,
                        const general_storage_order<NumDims>& so,
                        Allocator const& alloc) :
-    super_type((T*)initial_base_,extents,so),
-    alloc_base(boost::empty_init_t(),alloc) {
+    super_type((T*)initial_base_,extents,so), allocator_(alloc) {
     boost::function_requires<
       detail::multi_array::CollectionConcept<ExtentList> >();
     allocate_space();
@@ -197,10 +179,8 @@ public:
 
 
   explicit multi_array(const detail::multi_array
-                       ::extent_gen<NumDims>& ranges,
-                       const Allocator& alloc = Allocator()) :
-    super_type((T*)initial_base_,ranges),
-    alloc_base(boost::empty_init_t(),alloc) {
+                       ::extent_gen<NumDims>& ranges) :
+    super_type((T*)initial_base_,ranges) {
 
     allocate_space();
   }
@@ -209,8 +189,7 @@ public:
   explicit multi_array(const detail::multi_array
                        ::extent_gen<NumDims>& ranges,
                        const general_storage_order<NumDims>& so) :
-    super_type((T*)initial_base_,ranges,so),
-    alloc_base(boost::empty_init_t()) {
+    super_type((T*)initial_base_,ranges,so) {
 
     allocate_space();
   }
@@ -220,17 +199,15 @@ public:
                        ::extent_gen<NumDims>& ranges,
                        const general_storage_order<NumDims>& so,
                        Allocator const& alloc) :
-    super_type((T*)initial_base_,ranges,so),
-    alloc_base(boost::empty_init_t(),alloc) {
+    super_type((T*)initial_base_,ranges,so), allocator_(alloc) {
 
     allocate_space();
   }
 
   multi_array(const multi_array& rhs) :
-  super_type(rhs),
-  alloc_base(static_cast<const alloc_base&>(rhs)) {
+  super_type(rhs), allocator_(rhs.allocator_) {
     allocate_space();
-    boost::detail::multi_array::copy_n(rhs.base_,rhs.num_elements(),base_);
+    boost::copy_n(rhs.base_,rhs.num_elements(),base_);
   }
 
 
@@ -245,10 +222,8 @@ public:
 #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
   template <typename OPtr>
   multi_array(const const_multi_array_ref<T,NumDims,OPtr>& rhs,
-              const general_storage_order<NumDims>& so = c_storage_order(),
-              const Allocator& alloc = Allocator())
-    : super_type(0,so,rhs.index_bases(),rhs.shape()),
-      alloc_base(boost::empty_init_t(),alloc)
+              const general_storage_order<NumDims>& so = c_storage_order())
+    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
   {
     allocate_space();
     // Warning! storage order may change, hence the following copy technique.
@@ -258,10 +233,8 @@ public:
   template <typename OPtr>
   multi_array(const detail::multi_array::
               const_sub_array<T,NumDims,OPtr>& rhs,
-              const general_storage_order<NumDims>& so = c_storage_order(),
-              const Allocator& alloc = Allocator())
-    : super_type(0,so,rhs.index_bases(),rhs.shape()),
-      alloc_base(boost::empty_init_t(),alloc)
+              const general_storage_order<NumDims>& so = c_storage_order())
+    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
   {
     allocate_space();
     std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -271,10 +244,8 @@ public:
   template <typename OPtr>
   multi_array(const detail::multi_array::
               const_multi_array_view<T,NumDims,OPtr>& rhs,
-              const general_storage_order<NumDims>& so = c_storage_order(),
-              const Allocator& alloc = Allocator())
-    : super_type(0,so,rhs.index_bases(),rhs.shape()),
-      alloc_base(boost::empty_init_t(),alloc)
+              const general_storage_order<NumDims>& so = c_storage_order())
+    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
   {
     allocate_space();
     std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -284,10 +255,8 @@ public:
   // More limited support for MSVC
 
 
-  multi_array(const const_multi_array_ref<T,NumDims>& rhs,
-              const Allocator& alloc = Allocator())
-    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()),
-      alloc_base(boost::empty_init_t(),alloc)
+  multi_array(const const_multi_array_ref<T,NumDims>& rhs)
+    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) 
   {
     allocate_space();
     // Warning! storage order may change, hence the following copy technique.
@@ -295,10 +264,8 @@ public:
   }
 
   multi_array(const const_multi_array_ref<T,NumDims>& rhs,
-              const general_storage_order<NumDims>& so,
-              const Allocator& alloc = Allocator())
-    : super_type(0,so,rhs.index_bases(),rhs.shape()),
-      alloc_base(boost::empty_init_t(),alloc)
+              const general_storage_order<NumDims>& so)
+    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
   {
     allocate_space();
     // Warning! storage order may change, hence the following copy technique.
@@ -306,10 +273,8 @@ public:
   }
 
   multi_array(const detail::multi_array::
-              const_sub_array<T,NumDims>& rhs,
-              const Allocator& alloc = Allocator())
-    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()),
-      alloc_base(boost::empty_init_t(),alloc)
+              const_sub_array<T,NumDims>& rhs)
+    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) 
   {
     allocate_space();
     std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -317,10 +282,8 @@ public:
 
   multi_array(const detail::multi_array::
               const_sub_array<T,NumDims>& rhs,
-              const general_storage_order<NumDims>& so,
-              const Allocator& alloc = Allocator())
-    : super_type(0,so,rhs.index_bases(),rhs.shape()),
-      alloc_base(boost::empty_init_t(),alloc)
+              const general_storage_order<NumDims>& so)
+    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
   {
     allocate_space();
     std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -328,10 +291,8 @@ public:
 
 
   multi_array(const detail::multi_array::
-              const_multi_array_view<T,NumDims>& rhs,
-              const Allocator& alloc = Allocator())
-    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()),
-      alloc_base(boost::empty_init_t(),alloc)
+              const_multi_array_view<T,NumDims>& rhs)
+    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) 
   {
     allocate_space();
     std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -339,10 +300,8 @@ public:
 
   multi_array(const detail::multi_array::
               const_multi_array_view<T,NumDims>& rhs,
-              const general_storage_order<NumDims>& so,
-              const Allocator& alloc = Allocator())
-    : super_type(0,so,rhs.index_bases(),rhs.shape()),
-      alloc_base(boost::empty_init_t(),alloc)
+              const general_storage_order<NumDims>& so)
+    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
   {
     allocate_space();
     std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -351,10 +310,8 @@ public:
 #endif // !BOOST_NO_FUNCTION_TEMPLATE_ORDERING
 
   // Thes constructors are necessary because of more exact template matches.
-  multi_array(const multi_array_ref<T,NumDims>& rhs,
-              const Allocator& alloc = Allocator())
-    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()),
-      alloc_base(boost::empty_init_t(),alloc)
+  multi_array(const multi_array_ref<T,NumDims>& rhs)
+    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) 
   {
     allocate_space();
     // Warning! storage order may change, hence the following copy technique.
@@ -362,10 +319,8 @@ public:
   }
 
   multi_array(const multi_array_ref<T,NumDims>& rhs,
-              const general_storage_order<NumDims>& so,
-              const Allocator& alloc = Allocator())
-    : super_type(0,so,rhs.index_bases(),rhs.shape()),
-      alloc_base(boost::empty_init_t(),alloc)
+              const general_storage_order<NumDims>& so)
+    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
   {
     allocate_space();
     // Warning! storage order may change, hence the following copy technique.
@@ -374,10 +329,8 @@ public:
 
 
   multi_array(const detail::multi_array::
-              sub_array<T,NumDims>& rhs,
-              const Allocator& alloc = Allocator())
-    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()),
-      alloc_base(boost::empty_init_t(),alloc)
+              sub_array<T,NumDims>& rhs)
+    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) 
   {
     allocate_space();
     std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -385,10 +338,8 @@ public:
 
   multi_array(const detail::multi_array::
               sub_array<T,NumDims>& rhs,
-              const general_storage_order<NumDims>& so,
-              const Allocator& alloc = Allocator())
-    : super_type(0,so,rhs.index_bases(),rhs.shape()),
-      alloc_base(boost::empty_init_t(),alloc)
+              const general_storage_order<NumDims>& so)
+    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
   {
     allocate_space();
     std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -396,10 +347,8 @@ public:
 
 
   multi_array(const detail::multi_array::
-              multi_array_view<T,NumDims>& rhs,
-              const Allocator& alloc = Allocator())
-    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()),
-      alloc_base(boost::empty_init_t(),alloc)
+              multi_array_view<T,NumDims>& rhs)
+    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) 
   {
     allocate_space();
     std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -407,10 +356,8 @@ public:
     
   multi_array(const detail::multi_array::
               multi_array_view<T,NumDims>& rhs,
-              const general_storage_order<NumDims>& so,
-              const Allocator& alloc = Allocator())
-    : super_type(0,so,rhs.index_bases(),rhs.shape()),
-      alloc_base(boost::empty_init_t(),alloc)
+              const general_storage_order<NumDims>& so)
+    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
   {
     allocate_space();
     std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -432,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(),allocator());
+    multi_array new_array(ranges);
 
 
     // build a view of tmp with the minimum extents
@@ -481,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
@@ -501,7 +430,6 @@ public:
     using std::swap;
     // Swap the internals of these arrays.
     swap(this->super_type::base_,new_array.super_type::base_);
-    swap(this->allocator(),new_array.allocator());
     swap(this->storage_,new_array.storage_);
     swap(this->extent_list_,new_array.extent_list_);
     swap(this->stride_list_,new_array.stride_list_);
@@ -509,6 +437,7 @@ public:
     swap(this->origin_offset_,new_array.origin_offset_);
     swap(this->directional_offset_,new_array.directional_offset_);
     swap(this->num_elements_,new_array.num_elements_);
+    swap(this->allocator_,new_array.allocator_);
     swap(this->base_,new_array.base_);
     swap(this->allocated_elements_,new_array.allocated_elements_);
 
@@ -521,43 +450,26 @@ public:
   }
 
 private:
-  friend inline bool operator==(const multi_array& a, const multi_array& b) {
-    return a.base() == b.base();
-  }
-
-  friend inline bool operator!=(const multi_array& a, const multi_array& b) {
-    return !(a == b);
-  }
-
-  const super_type& base() const {
-    return *this;
-  }
-
-  const Allocator& allocator() const {
-    return alloc_base::get();
-  }
-
-  Allocator& allocator() {
-    return alloc_base::get();
-  }
-
   void allocate_space() {
-    base_ = allocator().allocate(this->num_elements());
+    typename Allocator::const_pointer no_hint=0;
+    base_ = allocator_.allocate(this->num_elements(),no_hint);
     this->set_base_ptr(base_);
     allocated_elements_ = this->num_elements();
-    detail::multi_array::construct(allocator(),base_,base_+allocated_elements_);
+    std::uninitialized_fill_n(base_,allocated_elements_,T());
   }
 
   void deallocate_space() {
     if(base_) {
-      detail::multi_array::destroy(allocator(),base_,base_+allocated_elements_);
-      allocator().deallocate(base_,allocated_elements_);
+      for(T* i = base_; i != base_+allocated_elements_; ++i)
+        allocator_.destroy(i);
+      allocator_.deallocate(base_,allocated_elements_);
     }
   }
 
   typedef boost::array<size_type,NumDims> size_list;
   typedef boost::array<index,NumDims> index_list;
 
+  Allocator allocator_;
   T* base_;
   size_type allocated_elements_;
   enum {initial_base_ = 0};
@@ -565,8 +477,4 @@ private:
 
 } // namespace boost
 
-#if defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 406)
-#  pragma GCC diagnostic pop
-#endif
-
 #endif // BOOST_MULTI_ARRAY_RG071801_HPP

include/boost/multi_array/algorithm.hpp

@@ -43,8 +43,7 @@
 #include "boost/iterator.hpp"
 
 namespace boost {
-namespace detail {
-namespace multi_array {
+
 //--------------------------------------------------
 // copy_n (not part of the C++ standard)
 #if 1
@@ -96,8 +95,7 @@ copy_n(InputIter first, Size count, OutputIter result) {
 }
 
 #endif // 1
-} // namespace multi_array
-} // namespace detail
+
 } // namespace boost
 
 #endif // BOOST_ALGORITHM_RG071801_HPP

include/boost/multi_array/allocators.hpp

@@ -1,72 +0,0 @@
-// Copyright 2018 Glen Joseph Fernandes
-// (glenjofe@gmail.com)
-//
-// Distributed under 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)
-
-#ifndef BOOST_MULTI_ARRAY_ALLOCATORS_HPP
-#define BOOST_MULTI_ARRAY_ALLOCATORS_HPP
-
-#include <boost/config.hpp>
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-#include <memory>
-#else
-#include <new>
-#endif
-
-namespace boost {
-namespace detail {
-namespace multi_array {
-
-template<class A, class T>
-inline void destroy(A& allocator, T* ptr, T* end)
-{
-  for (; ptr != end; ++ptr) {
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-    std::allocator_traits<A>::destroy(allocator,ptr);
-#else
-    ptr->~T();
-#endif
-  }
-}
-
-template<class A, class T>
-inline void construct(A& allocator, T* ptr)
-{
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-  std::allocator_traits<A>::construct(allocator,ptr);
-#else
-  ::new(static_cast<void*>(ptr)) T();
-#endif
-}
-
-#if !defined(BOOST_NO_EXCEPTIONS)
-template<class A, class T>
-inline void construct(A& allocator, T* ptr, T* end)
-{
-  T* start = ptr;
-  try {
-    for (; ptr != end; ++ptr) {
-      boost::detail::multi_array::construct(allocator,ptr);
-    }
-  } catch (...) {
-    boost::detail::multi_array::destroy(allocator,start,ptr);
-    throw;
-  }
-}
-#else
-template<class A, class T>
-inline void construct(A& allocator, T* ptr, T* end)
-{
-  for (; ptr != end; ++ptr) {
-    boost::detail::multi_array::construct(allocator,ptr);
-  }
-}
-#endif
-
-} // multi_array
-} // detail
-} // boost
-
-#endif

include/boost/multi_array/base.hpp

@@ -25,14 +25,14 @@
 #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"
+#include "boost/mpl/aux_/msvc_eti_base.hpp"
 #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>
 
@@ -64,7 +64,7 @@ namespace multi_array_types {
 // object creation in small-memory environments.  Thus, the objects
 // can be left undefined by defining BOOST_MULTI_ARRAY_NO_GENERATORS 
 // before loading multi_array.hpp.
-#ifndef BOOST_MULTI_ARRAY_NO_GENERATORS
+#if !BOOST_MULTI_ARRAY_NO_GENERATORS
 namespace {
   multi_array_types::extent_gen extents;
   multi_array_types::index_gen indices;
@@ -80,8 +80,7 @@ class sub_array;
 template <typename T, std::size_t NumDims, typename TPtr = const T*>
 class const_sub_array;
 
-  template <typename T, typename TPtr, typename NumDims, typename Reference,
-            typename IteratorCategory>
+template <typename T, typename TPtr, typename NumDims, typename Reference>
 class array_iterator;
 
 template <typename T, std::size_t NumDims, typename TPtr = const T*>
@@ -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,28 +201,49 @@ struct value_accessor_generator {
   >::type type;
 };
 
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
+
+struct eti_value_accessor
+{
+  typedef int index;
+  typedef int size_type;
+  typedef int element;
+  typedef int index_range;
+  typedef int value_type;
+  typedef int reference;
+  typedef int const_reference;
+};
+    
+template <>
+struct value_accessor_generator<int,int>
+{
+  typedef eti_value_accessor type;
+};
+
+template <class T, class NumDims>
+struct associated_types
+  : mpl::aux::msvc_eti_base<
+        typename value_accessor_generator<T,NumDims>::type
+    >::type
+{};
+
+template <>
+struct associated_types<int,int> : eti_value_accessor {};
+
+#else
+
 template <class T, class NumDims>
 struct associated_types
   : value_accessor_generator<T,NumDims>::type
 {};
 
+#endif
+
 //
 // choose value accessor ends
 /////////////////////////////////////////////////////////////////////////
 
-// Due to some imprecision in the C++ Standard, 
-// MSVC 2010 is broken in debug mode: it requires
-// that an Output Iterator have output_iterator_tag in its iterator_category if 
-// that iterator is not bidirectional_iterator or random_access_iterator.
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1600)
-struct mutable_iterator_tag
- : boost::random_access_traversal_tag, std::input_iterator_tag
-{
-  operator std::output_iterator_tag() const {
-    return std::output_iterator_tag();
-  }
-};
-#endif
+
 
 ////////////////////////////////////////////////////////////////////////
 // multi_array_base
@@ -238,7 +251,13 @@ struct mutable_iterator_tag
 template <typename T, std::size_t NumDims>
 class multi_array_impl_base
   :
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
+      public mpl::aux::msvc_eti_base<
+          typename value_accessor_generator<T,mpl::size_t<NumDims> >::type
+       >::type
+#else
       public value_accessor_generator<T,mpl::size_t<NumDims> >::type
+#endif 
 {
   typedef associated_types<T,mpl::size_t<NumDims> > types;
 public:
@@ -274,16 +293,8 @@ public:
   //
   // iterator support
   //
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1600)
-  // Deal with VC 2010 output_iterator_tag requirement
-  typedef array_iterator<T,T*,mpl::size_t<NumDims>,reference,
-                         mutable_iterator_tag> iterator;
-#else
-  typedef array_iterator<T,T*,mpl::size_t<NumDims>,reference,
-                         boost::random_access_traversal_tag> iterator;
-#endif
-  typedef array_iterator<T,T const*,mpl::size_t<NumDims>,const_reference,
-                         boost::random_access_traversal_tag> const_iterator;
+  typedef array_iterator<T,T*,mpl::size_t<NumDims>,reference> iterator;
+  typedef array_iterator<T,T const*,mpl::size_t<NumDims>,const_reference> const_iterator;
 
   typedef ::boost::reverse_iterator<iterator> reverse_iterator;
   typedef ::boost::reverse_iterator<const_iterator> const_reverse_iterator;
@@ -296,33 +307,13 @@ 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 {
-    boost::function_requires<
-      CollectionConcept<IndexList> >();
-    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;
-    {
-      typename IndexList::const_iterator i = indices.begin();
-      size_type n = 0; 
-      while (n != NumDims) {
-        offset += (*i) * strides[n];
-        ++n;
-        ++i;
-      }
-    }
+    for (size_type n = 0; n != NumDims; ++n) 
+      offset += indices[n] * strides[n];
+    
     return base[offset];
   }
 
@@ -419,53 +410,13 @@ protected:
     index offset = 0;
     size_type dim = 0;
     for (size_type n = 0; n != NumDims; ++n) {
-
-      // Use array specs and input specs to produce real specs.
       const index default_start = index_bases[n];
       const index default_finish = default_start+extents[n];
       const index_range& current_range = indices.ranges_[n];
       index start = current_range.get_start(default_start);
       index finish = current_range.get_finish(default_finish);
-      index stride = current_range.stride();
-      BOOST_ASSERT(stride != 0);
-
-      // An index range indicates a half-open strided interval 
-      // [start,finish) (with stride) which faces upward when stride 
-      // is positive and downward when stride is negative, 
-
-      // RG: The following code for calculating length suffers from 
-      // some representation issues: if finish-start cannot be represented as
-      // by type index, then overflow may result.
-
-      index len;
-      if ((finish - start) / stride < 0) {
-        // [start,finish) is empty according to the direction imposed by 
-        // the stride.
-        len = 0;
-      } else {
-        // integral trick for ceiling((finish-start) / stride) 
-        // taking into account signs.
-        index shrinkage = stride > 0 ? 1 : -1;
-        len = (finish - start + (stride - shrinkage)) / stride;
-      }
-
-      // start marks the closed side of the range, so it must lie
-      // exactly in the set of legal indices
-      // with a special case for empty arrays
-      BOOST_ASSERT(index_bases[n] <= start &&
-                   ((start <= index_bases[n]+index(extents[n])) ||
-                     (start == index_bases[n] && extents[n] == 0)));
-
-#ifndef BOOST_DISABLE_ASSERTS
-      // finish marks the open side of the range, so it can go one past
-      // the "far side" of the range (the top if stride is positive, the bottom
-      // if stride is negative).
-      index bound_adjustment = stride < 0 ? 1 : 0;
-      BOOST_ASSERT(((index_bases[n] - bound_adjustment) <= finish) &&
-        (finish <= (index_bases[n] + index(extents[n]) - bound_adjustment)));
-      ignore_unused_variable_warning(bound_adjustment);
-#endif // BOOST_DISABLE_ASSERTS
-
+      index index_factor = current_range.stride();
+      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)
@@ -473,16 +424,16 @@ protected:
 
       if (!current_range.is_degenerate()) {
 
-        // The stride for each dimension is included into the
+        // The index_factor for each dimension is included into the
         // strides for the array_view (see [Garcia] for the math involved).
-        new_strides[dim] = stride * strides[n];
+        new_strides[dim] = index_factor * strides[n];
         
         // calculate new extents
         new_extents[dim] = len;
         ++dim;
       }
     }
-    BOOST_ASSERT(dim == NDims);
+    assert (dim == NDims);
 
     return
       ArrayRef(base+offset,

include/boost/multi_array/collection_concept.hpp

@@ -17,10 +17,46 @@
 
 namespace boost {
 namespace detail {
-namespace multi_array { // Old location for this
-  using boost::CollectionConcept;
-}
-}
+namespace multi_array {
+
+  //===========================================================================
+  // Collection Concept
+
+  template <class Collection>
+  struct CollectionConcept
+  {
+    typedef typename Collection::value_type value_type;
+    typedef typename Collection::iterator iterator;
+    typedef typename Collection::const_iterator const_iterator;
+    typedef typename Collection::reference reference;
+    typedef typename Collection::const_reference const_reference;
+    // typedef typename Collection::pointer pointer;
+    typedef typename Collection::difference_type difference_type;
+    typedef typename Collection::size_type size_type;
+
+    void constraints() {
+      boost::function_requires<boost::InputIteratorConcept<iterator> >();
+      boost::function_requires<boost::InputIteratorConcept<const_iterator> >();
+      boost::function_requires<boost::CopyConstructibleConcept<value_type> >();
+      const_constraints(c);
+      i = c.begin();
+      i = c.end();
+      c.swap(c);
+    }
+    void const_constraints(const Collection& c) {
+      ci = c.begin();
+      ci = c.end();
+      n = c.size();
+      b = c.empty();
+    }
+    Collection c;
+    bool b;
+    iterator i;
+    const_iterator ci;
+    size_type n;
+  };
 
+}
+}
 }
 #endif // COLLECTION_CONCEPT_RG103101_HPP

include/boost/multi_array/concept_checks.hpp

@@ -22,9 +22,9 @@
 #include "boost/iterator/iterator_concepts.hpp"
 
 namespace boost {
-namespace multi_array_concepts {
-
 namespace detail {
+namespace multi_array {
+
   //
   // idgen_helper -
   //   This is a helper for generating index_gen instantiations with
@@ -39,6 +39,8 @@ namespace detail {
 
     template <typename Array, typename IdxGen, typename Call_Type>
     static void call(Array& a, const IdxGen& idgen, Call_Type c) {
+      typedef typename Array::index_range index_range;
+      typedef typename Array::index index;
       idgen_helper<N-1>::call(a,idgen[c],c);
     }
   };
@@ -48,12 +50,12 @@ namespace detail {
 
     template <typename Array, typename IdxGen, typename Call_Type>
     static void call(Array& a, const IdxGen& idgen, Call_Type) {
+      typedef typename Array::index_range index_range;
+      typedef typename Array::index index;
       a[ idgen ];
     }
   };
 
-} // namespace detail
-
 
   template <typename Array, std::size_t NumDims >
   struct ConstMultiArrayConcept
@@ -68,14 +70,13 @@ namespace detail {
       // RG - a( CollectionArchetype) when available...
       a[ id ];
       // Test slicing, keeping only the first dimension, losing the rest
-      detail::idgen_helper<NumDims-1>::call(a,idgen[range],id);
+      idgen_helper<NumDims-1>::call(a,idgen[range],id);
 
       // Test slicing, keeping all dimensions.
-      detail::idgen_helper<NumDims-1>::call(a,idgen[range],range);
+      idgen_helper<NumDims-1>::call(a,idgen[range],range);
 
       st = a.size();
       st = a.num_dimensions();
-      st = Array::dimensionality;
       st = a.num_elements();
       stp = a.shape();
       idp = a.strides();
@@ -127,16 +128,15 @@ namespace detail {
       function_requires< boost_concepts::WritableIteratorConcept<iterator> >();
       function_requires< boost_concepts::ForwardTraversalConcept<const_iterator> >();
       function_requires< boost_concepts::ReadableIteratorConcept<const_iterator> >();
-      function_requires< boost::OutputIterator<iterator,value_type> >();
       
       // RG - a( CollectionArchetype) when available...
       value_type vt = a[ id ];
 
       // Test slicing, keeping only the first dimension, losing the rest
-      detail::idgen_helper<NumDims-1>::call(a,idgen[range],id);
+      idgen_helper<NumDims-1>::call(a,idgen[range],id);
 
       // Test slicing, keeping all dimensions.
-      detail::idgen_helper<NumDims-1>::call(a,idgen[range],range);
+      idgen_helper<NumDims-1>::call(a,idgen[range],range);
 
       st = a.size();
       st = a.num_dimensions();
@@ -157,10 +157,10 @@ namespace detail {
       //      value_type vt = a[ id ];
 
       // Test slicing, keeping only the first dimension, losing the rest
-      detail::idgen_helper<NumDims-1>::call(a,idgen[range],id);
+      idgen_helper<NumDims-1>::call(a,idgen[range],id);
 
       // Test slicing, keeping all dimensions.
-      detail::idgen_helper<NumDims-1>::call(a,idgen[range],range);
+      idgen_helper<NumDims-1>::call(a,idgen[range],range);
 
       st = a.size();
       st = a.num_dimensions();
@@ -207,14 +207,7 @@ namespace detail {
 
 
 } // namespace multi_array
-
-namespace detail {
-  namespace multi_array { // Old locations for these
-    using boost::multi_array_concepts::ConstMultiArrayConcept;
-    using boost::multi_array_concepts::MutableMultiArrayConcept;
-  }
-}
-
+} // namespace detail
 } // namespace boost
 
 

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

@@ -20,7 +20,7 @@
 
 #include "boost/multi_array/base.hpp"
 #include "boost/iterator/iterator_facade.hpp"
-#include <algorithm>
+#include "boost/mpl/aux_/msvc_eti_base.hpp"
 #include <cstddef>
 #include <iterator>
 
@@ -43,28 +43,32 @@ struct operator_arrow_proxy
   mutable T value_;
 };
 
-template <typename T, typename TPtr, typename NumDims, typename Reference,
-          typename IteratorCategory>
+template <typename T, typename TPtr, typename NumDims, typename Reference>
 class array_iterator;
 
-template <typename T, typename TPtr, typename NumDims, typename Reference,
-          typename IteratorCategory>
+template <typename T, typename TPtr, typename NumDims, typename Reference>
 class array_iterator
   : public
     iterator_facade<
-        array_iterator<T,TPtr,NumDims,Reference,IteratorCategory>
+        array_iterator<T,TPtr,NumDims,Reference>
       , typename associated_types<T,NumDims>::value_type
-      , IteratorCategory
+      , boost::random_access_traversal_tag
       , Reference
     >
     , private
+#if BOOST_WORKAROUND(BOOST_MSVC,==1200)
+      mpl::aux::msvc_eti_base<typename 
+#endif 
           value_accessor_generator<T,NumDims>::type
+#if BOOST_WORKAROUND(BOOST_MSVC,==1200)
+      >::type
+#endif 
 {
-  friend class ::boost::iterator_core_access;
+  friend class iterator_core_access;
   typedef detail::multi_array::associated_types<T,NumDims> access_t;
 
   typedef iterator_facade<
-            array_iterator<T,TPtr,NumDims,Reference,IteratorCategory>
+        array_iterator<T,TPtr,NumDims,Reference>
       , typename detail::multi_array::associated_types<T,NumDims>::value_type
       , boost::random_access_traversal_tag
       , Reference
@@ -74,7 +78,7 @@ class array_iterator
   typedef typename access_t::size_type size_type;
 
 #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-  template <typename, typename, typename, typename, typename>
+  template <typename, typename, typename, typename>
     friend class array_iterator;
 #else
  public:
@@ -94,15 +98,15 @@ public:
 
   array_iterator() {}
 
-  array_iterator(index idx, TPtr base, const size_type* extents,
+  array_iterator(int idx, TPtr base, const size_type* extents,
                 const index* strides,
                 const index* index_base) :
     idx_(idx), base_(base), extents_(extents),
     strides_(strides), index_base_(index_base) { }
 
-  template <typename OPtr, typename ORef, typename Cat>
+  template <typename OPtr, typename ORef>
   array_iterator(
-      const array_iterator<T,OPtr,NumDims,ORef,Cat>& rhs
+      const array_iterator<T,OPtr,NumDims,ORef>& rhs
     , typename boost::enable_if_convertible<OPtr,TPtr>::type* = 0
   )
     : idx_(rhs.idx_), base_(rhs.base_), extents_(rhs.extents_),
@@ -133,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,13 +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/utility/enable_if.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>
@@ -90,7 +89,7 @@ public:
   explicit const_multi_array_ref(TPtr base, const ExtentList& extents) :
     base_(base), storage_(c_storage_order()) {
     boost::function_requires<
-      CollectionConcept<ExtentList> >();
+      detail::multi_array::CollectionConcept<ExtentList> >();
 
     index_base_list_.assign(0);
     init_multi_array_ref(extents.begin());
@@ -101,7 +100,7 @@ public:
                        const general_storage_order<NumDims>& so) : 
     base_(base), storage_(so) {
     boost::function_requires<
-      CollectionConcept<ExtentList> >();
+      detail::multi_array::CollectionConcept<ExtentList> >();
 
     index_base_list_.assign(0);
     init_multi_array_ref(extents.begin());
@@ -138,17 +137,10 @@ 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<
-      CollectionConcept<BaseList> >();
-    boost::detail::multi_array::
-      copy_n(values.begin(),num_dimensions(),index_base_list_.begin());
+      detail::multi_array::CollectionConcept<BaseList> >();
+    boost::copy_n(values.begin(),num_dimensions(),index_base_list_.begin());
     origin_offset_ =
       this->calculate_origin_offset(stride_list_,extent_list_,
                               storage_,index_base_list_);
@@ -164,10 +156,10 @@ public:
   template <typename SizeList>
   void reshape(const SizeList& extents) {
     boost::function_requires<
-      CollectionConcept<SizeList> >();
-    BOOST_ASSERT(num_elements_ ==
-                 std::accumulate(extents.begin(),extents.end(),
-                                 size_type(1),std::multiplies<size_type>()));
+      detail::multi_array::CollectionConcept<SizeList> >();
+    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_);
@@ -211,10 +203,10 @@ public:
   template <typename IndexList>
   const element& operator()(IndexList indices) const {
     boost::function_requires<
-      CollectionConcept<IndexList> >();
+      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
@@ -225,7 +217,11 @@ public:
   }
 
   // see generate_array_view in base.hpp
+#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
   template <int NDims>
+#else
+  template <int NumDims, int NDims> // else ICE
+#endif // BOOST_MSVC
   typename const_array_view<NDims>::type 
   operator[](const detail::multi_array::
              index_gen<NumDims,NDims>& indices)
@@ -246,7 +242,7 @@ public:
   }
 
   const_iterator end() const {
-    return const_iterator(*index_bases()+(index)*shape(),origin(),
+    return const_iterator(*index_bases()+*shape(),origin(),
                           shape(),strides(),index_bases());
   }
 
@@ -331,8 +327,7 @@ public:
    // If index_bases or extents is null, then initialize the corresponding
    // private data to zeroed lists.
    if(index_bases) {
-     boost::detail::multi_array::
-       copy_n(index_bases,NumDims,index_base_list_.begin());
+     boost::copy_n(index_bases,NumDims,index_base_list_.begin());
    } else {
      std::fill_n(index_base_list_.begin(),NumDims,0);
    }
@@ -390,12 +385,11 @@ public:
   void init_multi_array_ref(InputIterator extents_iter) {
     boost::function_requires<InputIteratorConcept<InputIterator> >();
 
-    boost::detail::multi_array::
-      copy_n(extents_iter,num_dimensions(),extent_list_.begin());
+    boost::copy_n(extents_iter,num_dimensions(),extent_list_.begin());
 
     // Calculate the array size
     num_elements_ = std::accumulate(extent_list_.begin(),extent_list_.end(),
-                            size_type(1),std::multiplies<size_type>());
+                            1,std::multiplies<index>());
 
     this->compute_strides(stride_list_,extent_list_,storage_);
 
@@ -445,7 +439,7 @@ public:
   explicit multi_array_ref(T* base, const ExtentList& extents) :
     super_type(base,extents) {
     boost::function_requires<
-      CollectionConcept<ExtentList> >();
+      detail::multi_array::CollectionConcept<ExtentList> >();
   }
 
   template <class ExtentList>
@@ -453,7 +447,7 @@ public:
                            const general_storage_order<NumDims>& so) :
     super_type(base,extents,so) {
     boost::function_requires<
-      CollectionConcept<ExtentList> >();
+      detail::multi_array::CollectionConcept<ExtentList> >();
   }
 
 
@@ -475,13 +469,13 @@ public:
   template <typename ConstMultiArray>
   multi_array_ref& operator=(const ConstMultiArray& other) {
     function_requires< 
-      multi_array_concepts::
+      detail::multi_array::
       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;
@@ -491,10 +485,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());
     }
@@ -507,12 +500,11 @@ public:
 
   template <class IndexList>
   element& operator()(const IndexList& indices) {
-    boost::function_requires<
-      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());
   }
 
 
@@ -525,7 +517,11 @@ public:
 
 
   // See note attached to generate_array_view in base.hpp
+#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
   template <int NDims>
+#else
+  template <int NumDims, int NDims> // else ICE
+#endif // BOOST_MSVC
   typename array_view<NDims>::type 
   operator[](const detail::multi_array::
              index_gen<NumDims,NDims>& indices) {
@@ -546,7 +542,7 @@ public:
   }
 
   iterator end() {
-    return iterator(*this->index_bases()+(index)*this->shape(),origin(),
+    return iterator(*this->index_bases()+*this->shape(),origin(),
                     this->shape(),this->strides(),
                     this->index_bases());
   }
@@ -571,7 +567,7 @@ public:
   template <class IndexList>
   const element& operator()(const IndexList& indices) const {
     boost::function_requires<
-      CollectionConcept<IndexList> >();
+      detail::multi_array::CollectionConcept<IndexList> >();
     return super_type::operator()(indices);
   }
 
@@ -583,7 +579,11 @@ public:
   }
 
   // See note attached to generate_array_view in base.hpp
+#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
   template <int NDims>
+#else
+  template <int NumDims, int NDims> // else ICE
+#endif // BOOST_MSVC
   typename const_array_view<NDims>::type 
   operator[](const detail::multi_array::
              index_gen<NumDims,NDims>& indices)

include/boost/multi_array/storage_order.hpp

@@ -36,8 +36,8 @@ namespace boost {
     template <typename OrderingIter, typename AscendingIter>
     general_storage_order(OrderingIter ordering,
                           AscendingIter ascending) {
-      boost::detail::multi_array::copy_n(ordering,NumDims,ordering_.begin());
-      boost::detail::multi_array::copy_n(ascending,NumDims,ascending_.begin());
+      boost::copy_n(ordering,NumDims,ordering_.begin());
+      boost::copy_n(ascending,NumDims,ascending_.begin());
     }
 
     // RG - ideally these would not be necessary, but some compilers

include/boost/multi_array/subarray.hpp

@@ -79,15 +79,17 @@ public:
   
   template <typename IndexList>
   const element& operator()(const IndexList& indices) const {
-    boost::function_requires<
-      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
+#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
   template <int NDims>
+#else
+  template <int NumDims, int NDims> // else ICE
+#endif // BOOST_MSVC
   typename const_array_view<NDims>::type 
   operator[](const boost::detail::multi_array::
              index_gen<NumDims,NDims>& indices)
@@ -140,7 +142,7 @@ public:
   }
 
   const_iterator end() const {
-    return const_iterator(*index_bases()+(index)*shape(),origin(),
+    return const_iterator(*index_bases()+*shape(),origin(),
                           shape(),strides(),index_bases());
   }
 
@@ -227,13 +229,13 @@ public:
   // Assignment from other ConstMultiArray types.
   template <typename ConstMultiArray>
   sub_array& operator=(const ConstMultiArray& other) {
-    function_requires< boost::multi_array_concepts::ConstMultiArrayConcept< 
+    function_requires< boost::detail::multi_array::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;
@@ -243,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());
     }
@@ -263,7 +264,11 @@ public:
   }
 
   // see generate_array_view in base.hpp
+#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
   template <int NDims>
+#else
+  template <int NumDims, int NDims> // else ICE
+#endif // BOOST_MSVC
   typename array_view<NDims>::type 
   operator[](const boost::detail::multi_array::
              index_gen<NumDims,NDims>& indices) {
@@ -279,12 +284,9 @@ public:
 
   template <class IndexList>
   element& operator()(const IndexList& indices) {
-    boost::function_requires<
-      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() {
@@ -293,7 +295,7 @@ public:
   }
 
   iterator end() {
-    return iterator(*this->index_bases()+(index)*this->shape(),origin(),
+    return iterator(*this->index_bases()+*this->shape(),origin(),
                     this->shape(),this->strides(),this->index_bases());
   }
 
@@ -314,8 +316,6 @@ public:
 
   template <class IndexList>
   const element& operator()(const IndexList& indices) const {
-    boost::function_requires<
-      CollectionConcept<IndexList> >();
     return super_type::operator()(indices);
   }
 
@@ -324,7 +324,11 @@ public:
   }
 
   // see generate_array_view in base.hpp
+#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
   template <int NDims>
+#else
+  template <int NumDims, int NDims> // else ICE
+#endif // BOOST_MSVC
   typename const_array_view<NDims>::type 
   operator[](const boost::detail::multi_array::
              index_gen<NumDims,NDims>& 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,8 +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/utility/enable_if.hpp"
 #include "boost/array.hpp"
 #include "boost/limits.hpp"
 #include <algorithm>
@@ -74,17 +72,8 @@ 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<
-      CollectionConcept<BaseList> >();
-    boost::detail::multi_array::
-      copy_n(values.begin(),num_dimensions(),index_base_list_.begin());
+  void reindex(const BaseList& values) {
+    boost::copy_n(values.begin(),num_dimensions(),index_base_list_.begin());
     origin_offset_ =
       this->calculate_indexing_offset(stride_list_,index_base_list_);
   }
@@ -119,11 +108,9 @@ public:
 
   template <typename IndexList>
   const element& operator()(IndexList indices) const {
-    boost::function_requires<
-      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
@@ -135,7 +122,11 @@ public:
   }
 
   // see generate_array_view in base.hpp
+#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
   template <int NDims>
+#else
+  template <int NumDims, int NDims> // else ICE
+#endif // BOOST_MSVC
   typename const_array_view<NDims>::type 
   operator[](const boost::detail::multi_array::
              index_gen<NumDims,NDims>& indices)
@@ -155,7 +146,7 @@ public:
   }
 
   const_iterator end() const {
-    return const_iterator(*index_bases()+(index)*shape(),origin(),
+    return const_iterator(*index_bases()+*shape(),origin(),
                           shape(),strides(),index_bases());
   }
   
@@ -234,14 +225,15 @@ public: // should be protected
     index_base_list_.assign(0);
 
     // Get the extents and strides
-    boost::detail::multi_array::
-      copy_n(extents.begin(),NumDims,extent_list_.begin());
-    boost::detail::multi_array::
-      copy_n(strides.begin(),NumDims,stride_list_.begin());
+    boost::copy_n(extents.begin(),NumDims,extent_list_.begin());
+    boost::copy_n(strides.begin(),NumDims,stride_list_.begin());
 
     // 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;
@@ -294,13 +286,13 @@ public:
   template <typename ConstMultiArray>
   multi_array_view& operator=(const ConstMultiArray& other) {
     function_requires< 
-      boost::multi_array_concepts::
+      boost::detail::multi_array::
       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;
@@ -310,10 +302,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());
     }
@@ -324,12 +315,9 @@ public:
 
   template <class IndexList>
   element& operator()(const IndexList& indices) {
-    boost::function_requires<
-      CollectionConcept<IndexList> >();
     return super_type::access_element(boost::type<element&>(),
-                                      indices,origin(),
-                                      this->shape(),this->strides(),
-                                      this->index_bases());
+                                      origin(),
+                                      indices,this->strides());
   }
 
 
@@ -342,7 +330,11 @@ public:
 
 
   // see generate_array_view in base.hpp
+#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
   template <int NDims>
+#else
+  template <int NumDims, int NDims> // else ICE
+#endif // BOOST_MSVC
   typename array_view<NDims>::type 
   operator[](const boost::detail::multi_array::
              index_gen<NumDims,NDims>& indices) {
@@ -364,7 +356,7 @@ public:
   }
 
   iterator end() {
-    return iterator(*this->index_bases()+(index)*this->shape(),origin(),
+    return iterator(*this->index_bases()+*this->shape(),origin(),
                     this->shape(),this->strides(),
                     this->index_bases());
   }
@@ -384,8 +376,6 @@ public:
 
   template <class IndexList>
   const element& operator()(const IndexList& indices) const {
-    boost::function_requires<
-      CollectionConcept<IndexList> >();
     return super_type::operator()(indices);
   }
 
@@ -394,7 +384,11 @@ public:
   }
 
   // see generate_array_view in base.hpp
+#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
   template <int NDims>
+#else
+  template <int NumDims, int NDims> // else ICE
+#endif // BOOST_MSVC
   typename const_array_view<NDims>::type 
   operator[](const boost::detail::multi_array::
              index_gen<NumDims,NDims>& 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>

meta/libraries.json

@@ -1,15 +0,0 @@
-{
-    "key": "multi_array",
-    "name": "Multi-Array",
-    "authors": [
-        "Ron Garcia"
-    ],
-    "description": "Boost.MultiArray provides a generic N-dimensional array concept definition and common implementations of that interface.",
-    "category": [
-        "Containers",
-        "Math"
-    ],
-    "maintainers": [
-        "Ronald Garcia <garcia -at- osl.iu.edu>"
-    ]
-}

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,15 +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 ]
-      [ run reverse_view.cpp ../../test/build//boost_test_exec_monitor ]
-
       [ compile concept_checks.cpp ]
     ;

test/access.cpp

@@ -42,18 +42,18 @@ void access(Array& A, const const_array_tag&) {
   for (index i = idx0; i != idx0+2; ++i)
     for (index j = idx1; j != idx1+3; ++j)
       for (index k = idx2; k != idx2+4; ++k) {
-        BOOST_CHECK(A[i][j][k] == cnum++);
-        BOOST_CHECK(CA[i][j][k] == A[i][j][k]);
+        BOOST_TEST(A[i][j][k] == cnum++);
+        BOOST_TEST(CA[i][j][k] == A[i][j][k]);
       }
 
   // 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]);
-        BOOST_CHECK(CA(indices) == A(indices));
+        BOOST_TEST(A(indices) == A[i2][j2][k2]);
+        BOOST_TEST(CA(indices) == A(indices));
       }
   ++tests_run;
 }

test/assert.cpp

@@ -1,59 +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);
-  }
-
-  void assertion_failed_msg(char const * expr, char const * msg,
-                            char const * function,
-                            char const * file, long line) {
-    throw std::runtime_error(msg);
-  }
-
-} // 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/assign.cpp

@@ -1,6 +1,6 @@
 // Copyright 2002 The Trustees of Indiana University.
 
-// Use, modification and distribution is subject to the Boost Software
+// 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)
 
@@ -10,9 +10,9 @@
 //           Andrew Lumsdaine
 //  See http://www.boost.org/libs/multi_array for documentation.
 
-//
+// 
 // assign.cpp - Test out operator=() on the different types
-//
+// 
 //
 #include "generative_tests.hpp"
 #include "boost/array.hpp"
@@ -32,7 +32,7 @@ bool equal(const ArrayA& A, const ArrayB& B)
   typename ArrayA::const_iterator ia;
   typename ArrayB::const_iterator ib = B.begin();
   for (ia = A.begin(); ia != A.end(); ++ia, ++ib)
-    if (!::equal(*ia, *ib))
+    if (!equal(*ia, *ib))
       return false;
   return true;
 }
@@ -59,7 +59,7 @@ void access(Array& A, const mutable_array_tag&) {
 
   A = filler;
 
-  BOOST_CHECK(::equal(A,filler));
+  BOOST_TEST(equal(A,filler));
   ++tests_run;
 }
 

test/assign_to_array.cpp

@@ -1,6 +1,6 @@
 // Copyright 2002 The Trustees of Indiana University.
 
-// Use, modification and distribution is subject to the Boost Software
+// 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)
 
@@ -10,10 +10,10 @@
 //           Andrew Lumsdaine
 //  See http://www.boost.org/libs/multi_array for documentation.
 
-//
+// 
 // assign_to_array.cpp - multi_array should be constructible from any other
 // array type in the library.
-//
+// 
 //
 #include "generative_tests.hpp"
 #include "boost/array.hpp"
@@ -33,7 +33,7 @@ bool equal(const ArrayA& A, const ArrayB& B)
   typename ArrayA::const_iterator ia;
   typename ArrayB::const_iterator ib = B.begin();
   for (ia = A.begin(); ia != A.end(); ++ia, ++ib)
-    if (!::equal(*ia, *ib))
+    if (!equal(*ia, *ib))
       return false;
   return true;
 }
@@ -50,7 +50,7 @@ template <typename Array>
 void access(Array& A, const const_array_tag&) {
   typedef boost::multi_array<int,3> array3;
   array3 acopy(A);
-  BOOST_CHECK(::equal(acopy,A));
+  BOOST_TEST(equal(acopy,A));
   ++tests_run;
 }
 

test/compare.cpp

@@ -34,9 +34,9 @@ test_main(int, char*[])
     std::vector<double> vals(num_elements, 4.5);
     A.assign(vals.begin(),vals.end());
     array B(A);
-    BOOST_CHECK(A == B);
-    BOOST_CHECK(B == A);
-    BOOST_CHECK(A[0] == B[0]);
+    BOOST_TEST(A == B);
+    BOOST_TEST(B == A);
+    BOOST_TEST(A[0] == B[0]);
   }
   // Assignment Operator
   {
@@ -44,15 +44,15 @@ test_main(int, char*[])
     std::vector<double> vals(num_elements, 4.5);
     A.assign(vals.begin(),vals.end());
     B = A;
-    BOOST_CHECK(A == B);
-    BOOST_CHECK(B == A);
-    BOOST_CHECK(B[0] == A[0]);
+    BOOST_TEST(A == B);
+    BOOST_TEST(B == A);
+    BOOST_TEST(B[0] == A[0]);
 
     typedef array::index_range range;
     array::index_gen indices;
     array::array_view<2>::type C = A[indices[2][range()][range()]];
     array::array_view<2>::type D = B[indices[2][range()][range()]];
-    BOOST_CHECK(C == D);
+    BOOST_TEST(C == D);
   }
   // Different Arrays
   {
@@ -62,15 +62,15 @@ test_main(int, char*[])
     A.assign(valsA.begin(),valsA.end());
     B.assign(valsB.begin(),valsB.end());
 
-    BOOST_CHECK(A != B);
-    BOOST_CHECK(B != A);
-    BOOST_CHECK(A[0] != B[0]);
+    BOOST_TEST(A != B);
+    BOOST_TEST(B != A);
+    BOOST_TEST(A[0] != B[0]);
 
     typedef array::index_range range;
     array::index_gen indices;
     array::array_view<2>::type C = A[indices[2][range()][range()]];
     array::array_view<2>::type D = B[indices[2][range()][range()]];
-    BOOST_CHECK(C != D);
+    BOOST_TEST(C != D);
   }
 
   // Comparisons galore!
@@ -108,30 +108,30 @@ test_main(int, char*[])
     A.assign(valsA,valsA+num_elements);
     B.assign(valsB,valsB+num_elements);
 
-    BOOST_CHECK(B < A);
-    BOOST_CHECK(A > B);
+    BOOST_TEST(B < A);
+    BOOST_TEST(A > B);
 
-    BOOST_CHECK(B <= A);
-    BOOST_CHECK(A >= B);
+    BOOST_TEST(B <= A);
+    BOOST_TEST(A >= B);
 
-    BOOST_CHECK(B[0] == A[0]);
-    BOOST_CHECK(B[2] < A[2]);
+    BOOST_TEST(B[0] == A[0]);
+    BOOST_TEST(B[2] < A[2]);
 
     array C = A;
     
-    BOOST_CHECK(C <= A);
-    BOOST_CHECK(C >= A);
+    BOOST_TEST(C <= A);
+    BOOST_TEST(C >= A);
 
-    BOOST_CHECK(!(C < A));
-    BOOST_CHECK(!(C > A));
+    BOOST_TEST(!(C < A));
+    BOOST_TEST(!(C > A));
 
     typedef array::index_range range;
     array::index_gen indices;
     array::array_view<2>::type D = A[indices[2][range()][range()]];
     array::array_view<2>::type E = B[indices[2][range()][range()]];
 
-    BOOST_CHECK(E < D);
-    BOOST_CHECK(E <= D);
+    BOOST_TEST(E < D);
+    BOOST_TEST(E <= D);
   }
 
 

test/concept_checks.cpp

@@ -1,6 +1,6 @@
 // Copyright 2002 The Trustees of Indiana University.
 
-// Use, modification and distribution is subject to the Boost Software
+// 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)
 
@@ -10,7 +10,7 @@
 //           Andrew Lumsdaine
 //  See http://www.boost.org/libs/multi_array for documentation.
 
-//
+// 
 // concept_checks.cpp -
 //   make sure the types meet concept requirements
 //
@@ -19,9 +19,8 @@
 #include "boost/multi_array/concept_checks.hpp"
 #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"
 
@@ -38,28 +37,28 @@ test_main(int,char*[])
   typedef array::const_subarray<ndims>::type const_subarray;
 
 boost::function_requires<
-  boost::multi_array_concepts::ConstMultiArrayConcept<array,ndims> >();
+  boost::detail::multi_array::ConstMultiArrayConcept<array,ndims> >();
 boost::function_requires<
-  boost::multi_array_concepts::ConstMultiArrayConcept<array_ref,ndims> >();
+  boost::detail::multi_array::ConstMultiArrayConcept<array_ref,ndims> >();
 boost::function_requires<
-  boost::multi_array_concepts::ConstMultiArrayConcept<const_array_ref,ndims> >();
+  boost::detail::multi_array::ConstMultiArrayConcept<const_array_ref,ndims> >();
 boost::function_requires<
-  boost::multi_array_concepts::ConstMultiArrayConcept<array_view,ndims> >();
+  boost::detail::multi_array::ConstMultiArrayConcept<array_view,ndims> >();
 boost::function_requires<
-  boost::multi_array_concepts::ConstMultiArrayConcept<const_array_view,ndims> >();
+  boost::detail::multi_array::ConstMultiArrayConcept<const_array_view,ndims> >();
 boost::function_requires<
-  boost::multi_array_concepts::ConstMultiArrayConcept<subarray,ndims> >();
+  boost::detail::multi_array::ConstMultiArrayConcept<subarray,ndims> >();
 boost::function_requires<
-  boost::multi_array_concepts::ConstMultiArrayConcept<const_subarray,ndims> >();
+  boost::detail::multi_array::ConstMultiArrayConcept<const_subarray,ndims> >();
 
 boost::function_requires<
-  boost::multi_array_concepts::MutableMultiArrayConcept<array,ndims> >();
+  boost::detail::multi_array::MutableMultiArrayConcept<array,ndims> >();
 boost::function_requires<
-  boost::multi_array_concepts::MutableMultiArrayConcept<array_ref,ndims> >();
+  boost::detail::multi_array::MutableMultiArrayConcept<array_ref,ndims> >();
 boost::function_requires<
-  boost::multi_array_concepts::MutableMultiArrayConcept<array_view,ndims> >();
+  boost::detail::multi_array::MutableMultiArrayConcept<array_view,ndims> >();
 boost::function_requires<
-  boost::multi_array_concepts::MutableMultiArrayConcept<subarray,ndims> >();
-
-  return 0;
+  boost::detail::multi_array::MutableMultiArrayConcept<subarray,ndims> >();
+ 
+  return boost::exit_success;
 }

test/constructors.cpp

@@ -1,6 +1,6 @@
 // Copyright 2002 The Trustees of Indiana University.
 
-// Use, modification and distribution is subject to the Boost Software
+// 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)
 
@@ -25,15 +25,15 @@ void check_shape(const double&, std::size_t*, int*, unsigned int)
 {}
 
 template <class Array>
-void check_shape(const Array& A,
-                 std::size_t* sizes,
+void check_shape(const Array& A, 
+                 std::size_t* sizes, 
                  int* strides,
                  unsigned int num_elements)
 {
-  BOOST_CHECK(A.num_elements() == num_elements);
-  BOOST_CHECK(A.size() == *sizes);
-  BOOST_CHECK(std::equal(sizes, sizes + A.num_dimensions(), A.shape()));
-  BOOST_CHECK(std::equal(strides, strides + A.num_dimensions(), A.strides()));
+  BOOST_TEST(A.num_elements() == num_elements);
+  BOOST_TEST(A.size() == *sizes);
+  BOOST_TEST(std::equal(sizes, sizes + A.num_dimensions(), A.shape()));
+  BOOST_TEST(std::equal(strides, strides + A.num_dimensions(), A.strides()));
   check_shape(A[0], ++sizes, ++strides, num_elements / A.size());
 }
 
@@ -49,7 +49,7 @@ bool equal(const ArrayA& A, const ArrayB& B)
   typename ArrayA::const_iterator ia;
   typename ArrayB::const_iterator ib = B.begin();
   for (ia = A.begin(); ia != A.end(); ++ia, ++ib)
-    if (!::equal(*ia, *ib))
+    if (!equal(*ia, *ib))
       return false;
   return true;
 }
@@ -76,7 +76,7 @@ test_main(int, char*[])
     double* ptr = 0;
     boost::multi_array_ref<double,3> B(ptr,sizes);
     check_shape(B, &sizes[0], strides, num_elements);
-
+    
     const double* cptr = ptr;
     boost::const_multi_array_ref<double,3> C(cptr,sizes);
     check_shape(C, &sizes[0], strides, num_elements);
@@ -132,20 +132,20 @@ test_main(int, char*[])
     A.assign(vals.begin(),vals.end());
     boost::multi_array<double, 3> B(A);
     check_shape(B, &sizes[0], strides, num_elements);
-    BOOST_CHECK(::equal(A, B));
+    BOOST_TEST(equal(A, B));
 
     double ptr[27];
     boost::multi_array_ref<double, 3> C(ptr,sizes);
     A.assign(vals.begin(),vals.end());
     boost::multi_array_ref<double, 3> D(C);
     check_shape(D, &sizes[0], strides, num_elements);
-    BOOST_CHECK(C.data() == D.data());
+    BOOST_TEST(C.data() == D.data());
 
     const double* cptr = ptr;
     boost::const_multi_array_ref<double, 3> E(cptr,sizes);
     boost::const_multi_array_ref<double, 3> F(E);
     check_shape(F, &sizes[0], strides, num_elements);
-    BOOST_CHECK(E.data() == F.data());
+    BOOST_TEST(E.data() == F.data());
   }
 
 
@@ -161,15 +161,15 @@ test_main(int, char*[])
     boost::const_multi_array_ref<double, 3> C(A);
     check_shape(B, &sizes[0], strides, num_elements);
     check_shape(C, &sizes[0], strides, num_elements);
-    BOOST_CHECK(B.data() == A.data());
-    BOOST_CHECK(C.data() == A.data());
+    BOOST_TEST(B.data() == A.data());
+    BOOST_TEST(C.data() == A.data());
 
     double ptr[27];
     boost::multi_array_ref<double, 3> D(ptr,sizes);
     D.assign(vals.begin(),vals.end());
     boost::const_multi_array_ref<double, 3> E(D);
     check_shape(E, &sizes[0], strides, num_elements);
-    BOOST_CHECK(E.data() == D.data());
+    BOOST_TEST(E.data() == D.data());
   }
 
   // Assignment Operator
@@ -182,7 +182,7 @@ test_main(int, char*[])
     A.assign(vals.begin(),vals.end());
     B = A;
     check_shape(B, &sizes[0], strides, num_elements);
-    BOOST_CHECK(::equal(A, B));
+    BOOST_TEST(equal(A, B));
 
     double ptr1[27];
     double ptr2[27];
@@ -190,12 +190,12 @@ test_main(int, char*[])
     C.assign(vals.begin(),vals.end());
     D = C;
     check_shape(D, &sizes[0], strides, num_elements);
-    BOOST_CHECK(::equal(C,D));
+    BOOST_TEST(equal(C,D));
   }
 
 
   // subarray value_type is multi_array
-  {
+  { 
     typedef boost::multi_array<double,3> array;
     typedef array::size_type size_type;
     size_type num_elements = 27;
@@ -209,8 +209,8 @@ test_main(int, char*[])
     subarray::value_type C = B[0];
 
     // should comparisons between the types work?
-    BOOST_CHECK(::equal(A[1][0],C));
-    BOOST_CHECK(::equal(B[0],C));
+    BOOST_TEST(equal(A[1][0],C));
+    BOOST_TEST(equal(B[0],C));
   }
   return boost::exit_success;
 }

test/fail_cview2.cpp

@@ -22,7 +22,6 @@
 
 #include "boost/array.hpp"
 #include "boost/type.hpp"
-#include "boost/cstdlib.hpp"
 
 int
 test_main(int,char*[])

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;
 
@@ -62,18 +64,18 @@ test_main(int,char*[])
   {
     boost::detail::multi_array::index_gen<3,3> is1 =
       indices[range(0,1,2)][range(1,2,3)][range(2,3,4)];
-    BOOST_CHECK(is1.ranges_[0] == range(0,1,2));
-    BOOST_CHECK(is1.ranges_[1] == range(1,2,3));
-    BOOST_CHECK(is1.ranges_[2] == range(2,3,4));
+    BOOST_TEST(is1.ranges_[0] == range(0,1,2));
+    BOOST_TEST(is1.ranges_[1] == range(1,2,3));
+    BOOST_TEST(is1.ranges_[2] == range(2,3,4));
   }
 
   {
     boost::detail::multi_array::index_gen<3,2> is2 = 
       indices[range(0,1,2)][2][range(2,3,4)];
-    BOOST_CHECK(is2.ranges_[0] == range(0,1,2));
-    BOOST_CHECK(is2.ranges_[1] == range(2));
-    BOOST_CHECK(is2.ranges_[1].is_degenerate());
-    BOOST_CHECK(is2.ranges_[2] == range(2,3,4));
+    BOOST_TEST(is2.ranges_[0] == range(0,1,2));
+    BOOST_TEST(is2.ranges_[1] == range(2));
+    BOOST_TEST(is2.ranges_[1].is_degenerate());
+    BOOST_TEST(is2.ranges_[2] == range(2,3,4));
   }
 
   return boost::exit_success;

test/index_bases.cpp

@@ -62,12 +62,12 @@ 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) {
-          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]);
+        for (size_type c = 0; c < A[b].size(); ++c) {
+          BOOST_TEST(A[a+bases[0]][b+bases[1]][c+bases[2]] == B[a][b][c]);
+          BOOST_TEST(C[a+bases[0]][b+bases[1]][c+bases[2]] == B[a][b][c]);
+          BOOST_TEST(D[a+bases[0]][b+bases[1]][c+bases[2]] == B[a][b][c]);
           // Test that E does not inherit A's index_base
-          BOOST_CHECK(E[a][b][c] == B[a][b][c]);
+          BOOST_TEST(E[a][b][c] == B[a][b][c]);
         }
   }
 
@@ -100,10 +100,10 @@ test_main(int,char*[])
     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) {
-          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]);
-          BOOST_CHECK(E[a+bases[0]][b+bases[1]][c+bases[2]] == B[a][b][c]);
+          BOOST_TEST(A[a+bases[0]][b+bases[1]][c+bases[2]] == B[a][b][c]);
+          BOOST_TEST(C[a+bases[0]][b+bases[1]][c+bases[2]] == B[a][b][c]);
+          BOOST_TEST(D[a+bases[0]][b+bases[1]][c+bases[2]] == B[a][b][c]);
+          BOOST_TEST(E[a+bases[0]][b+bases[1]][c+bases[2]] == B[a][b][c]);
         }
   }
 
@@ -126,26 +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)
         for (size_type c = 0; c < A.shape()[2]; ++c) {
-          BOOST_CHECK(A[a+1][b+1][c+1] == B[a][b][c]);
-          BOOST_CHECK(C[a+1][b+1][c+1] == B[a][b][c]);
-          BOOST_CHECK(D[a+1][b+1][c+1] == B[a][b][c]);
-          BOOST_CHECK(E[a+1][b+1][c+1] == B[a][b][c]);
+          BOOST_TEST(A[a+1][b+1][c+1] == B[a][b][c]);
+          BOOST_TEST(C[a+1][b+1][c+1] == B[a][b][c]);
+          BOOST_TEST(D[a+1][b+1][c+1] == B[a][b][c]);
+          BOOST_TEST(E[a+1][b+1][c+1] == B[a][b][c]);
         }
   }
 

test/iterators.cpp

@@ -107,8 +107,8 @@ void test_iterators(Array& A, const IterTraits&) {
     typedef typename IterTraits::iterator3 iterator;
     iterator i1 = A.begin();
     iterator i2 = A.end();
-    BOOST_CHECK(i1 < i2);
-    BOOST_CHECK((i2 - i1) == typename iterator::difference_type(2));
+    BOOST_TEST(i1 < i2);
+    BOOST_TEST((i2 - i1) == typename iterator::difference_type(2));
   }
 
   // Standard Array Iteration
@@ -121,7 +121,7 @@ void test_iterators(Array& A, const IterTraits&) {
     for (iterator3 i = A.begin(); i != A.end(); ++i)
       for(iterator2 ii = (*i).begin(); ii != (*i).end(); ++ii)
         for(iterator1  iii = (*ii).begin(); iii != (*ii).end(); ++iii)
-          BOOST_CHECK(*iii == vals++);
+          BOOST_TEST(*iii == vals++);
   }
 
   // Using operator->() on iterators
@@ -134,7 +134,7 @@ void test_iterators(Array& A, const IterTraits&) {
     for (iterator3 i = A.begin(); i != A.end(); ++i)
       for(iterator2 ii = i->begin(); ii != i->end(); ++ii)
         for(iterator1  iii = ii->begin(); iii != ii->end(); ++iii)
-          BOOST_CHECK(*iii == vals++);
+          BOOST_TEST(*iii == vals++);
   }
 
   // Reverse Iterator Hierarchy Test
@@ -148,7 +148,7 @@ void test_iterators(Array& A, const IterTraits&) {
       for(riterator2 ii = (*i).rbegin(); ii != (riterator2)(*i).rend(); ++ii)
         for(riterator1 iii = (*ii).rbegin(); iii != (riterator1)(*ii).rend();
             ++iii)
-          BOOST_CHECK(*iii == check_iter_val--);
+          BOOST_TEST(*iii == check_iter_val--);
   }
   ++tests_run;
 }

test/range1.cpp

@@ -30,75 +30,75 @@ test_main(int,char*[])
   {
     // typical range creation and extraction
     range r1(-3,5);
-    BOOST_CHECK(r1.start() == -3);
-    BOOST_CHECK(r1.finish() == 5);
-    BOOST_CHECK(r1.stride() == 1);
-    BOOST_CHECK(!r1.is_degenerate());
-    BOOST_CHECK(r1.get_start(0) == -3);
-    BOOST_CHECK(r1.get_finish(100) == 5);
+    BOOST_TEST(r1.start() == -3);
+    BOOST_TEST(r1.finish() == 5);
+    BOOST_TEST(r1.stride() == 1);
+    BOOST_TEST(!r1.is_degenerate());
+    BOOST_TEST(r1.get_start(0) == -3);
+    BOOST_TEST(r1.get_finish(100) == 5);
   }
 
   {
     range r2(-3,5,2);
-    BOOST_CHECK(r2.start() == -3);
-    BOOST_CHECK(r2.finish() == 5);
-    BOOST_CHECK(r2.stride() == 2);
-    BOOST_CHECK(!r2.is_degenerate());
+    BOOST_TEST(r2.start() == -3);
+    BOOST_TEST(r2.finish() == 5);
+    BOOST_TEST(r2.stride() == 2);
+    BOOST_TEST(!r2.is_degenerate());
   }
 
   {
     // degenerate creation
     range r3(5);
-    BOOST_CHECK(r3.start() == 5);
-    BOOST_CHECK(r3.finish() == 6);
-    BOOST_CHECK(r3.stride() == 1);
-    BOOST_CHECK(r3.is_degenerate());
+    BOOST_TEST(r3.start() == 5);
+    BOOST_TEST(r3.finish() == 5);
+    BOOST_TEST(r3.stride() == 1);
+    BOOST_TEST(r3.is_degenerate());
   }
 
   {
     // default range creation
     range r4;
-    BOOST_CHECK(r4.get_start(0) == 0);
-    BOOST_CHECK(r4.get_finish(100) == 100);
-    BOOST_CHECK(r4.stride() == 1);
+    BOOST_TEST(r4.get_start(0) == 0);
+    BOOST_TEST(r4.get_finish(100) == 100);
+    BOOST_TEST(r4.stride() == 1);
   }
 
   {
     // create a range using the setter methods
     range r5 = range().stride(2).start(-3).finish(7);
-    BOOST_CHECK(r5.start() == -3);
-    BOOST_CHECK(r5.stride() == 2);
-    BOOST_CHECK(r5.finish() == 7);
+    BOOST_TEST(r5.start() == -3);
+    BOOST_TEST(r5.stride() == 2);
+    BOOST_TEST(r5.finish() == 7);
   }
 
   // try out all the comparison operators
   {
     range r6 = -3 <= range().stride(2) < 7;
-    BOOST_CHECK(r6.start() == -3);
-    BOOST_CHECK(r6.stride() == 2);
-    BOOST_CHECK(r6.finish() == 7);
+    BOOST_TEST(r6.start() == -3);
+    BOOST_TEST(r6.stride() == 2);
+    BOOST_TEST(r6.finish() == 7);
   }
 
   {
     range r7 = -3 < range() <= 7;
-    BOOST_CHECK(r7.start() == -2);
-    BOOST_CHECK(r7.stride() == 1);
-    BOOST_CHECK(r7.finish() == 8);
+    BOOST_TEST(r7.start() == -2);
+    BOOST_TEST(r7.stride() == 1);
+    BOOST_TEST(r7.finish() == 8);
   }
 
   // arithmetic operators
   {
     range r8 = range(0,5) + 2;
-    BOOST_CHECK(r8.start() == 2);
-    BOOST_CHECK(r8.stride() == 1);
-    BOOST_CHECK(r8.finish() == 7);
+    BOOST_TEST(r8.start() == 2);
+    BOOST_TEST(r8.stride() == 1);
+    BOOST_TEST(r8.finish() == 7);
   }
 
   {
     range r9 = range(0,5) - 2;
-    BOOST_CHECK(r9.start() == -2);
-    BOOST_CHECK(r9.stride() == 1);
-    BOOST_CHECK(r9.finish() == 3);
+    BOOST_TEST(r9.start() == -2);
+    BOOST_TEST(r9.stride() == 1);
+    BOOST_TEST(r9.finish() == 3);
   }
 
   return boost::exit_success;

test/reshape.cpp

@@ -52,9 +52,9 @@ test_main(int,char*[])
     for (array::index i = 0; i != 4; ++i)
       for (array::index j = 0; j != 3; ++j)
         for (array::index k = 0; k != 2; ++k) {
-          BOOST_CHECK(A[i][j][k] == *ptr);
-          BOOST_CHECK(B[i][j][k] == *ptr);
-          BOOST_CHECK(C[i][j][k] == *ptr++);
+          BOOST_TEST(A[i][j][k] == *ptr);
+          BOOST_TEST(B[i][j][k] == *ptr);
+          BOOST_TEST(C[i][j][k] == *ptr++);
         }
   }
 
@@ -80,9 +80,9 @@ test_main(int,char*[])
     for (array::index i = 0; i != 4; ++i)
       for (array::index j = 1; j != 4; ++j)
         for (array::index k = -1; k != 1; ++k) {
-          BOOST_CHECK(A[i][j][k] == *ptr);
-          BOOST_CHECK(B[i][j][k] == *ptr);
-          BOOST_CHECK(C[i][j][k] == *ptr++);
+          BOOST_TEST(A[i][j][k] == *ptr);
+          BOOST_TEST(B[i][j][k] == *ptr);
+          BOOST_TEST(C[i][j][k] == *ptr++);
         }
   }
   

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_TEST(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(),
+    BOOST_TEST(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/reverse_view.cpp

@@ -1,43 +0,0 @@
-// Copyright 2002 The Trustees of Indiana University.
-
-// Use, modification and distribution is subject to the Boost Software 
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-//  Boost.MultiArray Library
-//  Authors: Ronald Garcia
-//           Jeremy Siek
-//           Andrew Lumsdaine
-//  See http://www.boost.org/libs/multi_array for documentation.
-
-//
-// reverse_view.cpp - a small test of creating a view with negative strides
-//
-
-#include "boost/multi_array.hpp"
-#include "boost/test/minimal.hpp"
-#include "boost/array.hpp"
-
-int
-test_main(int,char*[])
-{
-  using namespace boost;
-  
-
-  // One-dimensional array with views
-  double data[] = { 1, 2, 3, 4 };
-  double rdata[] = { 4, 3, 2, 1 };
-
-  typedef multi_array< double, 1 > array;
-  array A(extents[4]);
-  A.assign(data,data+4);
-  
-  typedef array::index_range range;
-  array::array_view<1>::type B = A[indices[range(3, -1, -1)]];
-  
-  for(multi_array_types::size_type i = 0; i != B.size(); ++i) {
-    BOOST_CHECK(B[i] == rdata[i]);
-  }
-  
-  return boost::exit_success;
-}

test/slice.cpp

@@ -71,10 +71,10 @@ void test_views(Array& A, const ViewTraits&) {
     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+1][idx2+k*2]);
+          BOOST_TEST(B[i][j][k] == A[idx0+i][idx1+j+1][idx2+k*2]);
           boost::array<index,3> elmts;
           elmts[0]=i; elmts[1]=j; elmts[2]=k;
-          BOOST_CHECK(B(elmts) == A[idx0+i][idx1+j+1][idx2+k*2]);
+          BOOST_TEST(B(elmts) == A[idx0+i][idx1+j+1][idx2+k*2]);
         }
   }
   // Degenerate dimensions
@@ -84,34 +84,12 @@ void test_views(Array& A, const ViewTraits&) {
     
     for (index i = 0; i != 2; ++i)
       for (index j = 0; j != 2; ++j) {
-        BOOST_CHECK(B[i][j] == A[idx0+i][idx1+1][idx2+j*2]);
+        BOOST_TEST(B[i][j] == A[idx0+i][idx1+1][idx2+j*2]);
         boost::array<index,2> elmts;
         elmts[0]=i; elmts[1]=j;
-        BOOST_CHECK(B(elmts) == A[idx0+i][idx1+1][idx2+j*2]);
+        BOOST_TEST(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/stl_interaction.cpp

@@ -51,7 +51,7 @@ test_main(int, char*[])
   myarray.assign(data,data+data_size);
 
   array3vec myvec(5,myarray);
-  BOOST_CHECK(myarray == myvec[1]);
+  BOOST_TEST(myarray == myvec[1]);
 
   array3::array_view<2>::type myview =
     myarray[indices[1][range(0,2)][range(1,3)]];
@@ -65,8 +65,8 @@ test_main(int, char*[])
 
   myvec.push_back(myarray);
 
-  BOOST_CHECK(myarray != myvec[1]);
-  BOOST_CHECK(myarray == myvec[5]);
+  BOOST_TEST(myarray != myvec[1]);
+  BOOST_TEST(myarray == myvec[5]);
 
   return boost::exit_success;
 }

test/storage_order.cpp

@@ -67,7 +67,7 @@ test_main(int,char*[])
     for (array::index i = 0; i != 2; ++i)
       for (array::index j = 0; j != 3; ++j)
         for (array::index k = 0; k != 4; ++k)
-          BOOST_CHECK(A[i][j][k] == *num++);
+          BOOST_TEST(A[i][j][k] == *num++);
   }
 
   // Mimic fortran_storage_order using
@@ -88,7 +88,7 @@ test_main(int,char*[])
     for (array::index i = 0; i != 2; ++i)
       for (array::index j = 0; j != 3; ++j)
         for (array::index k = 0; k != 4; ++k)
-          BOOST_CHECK(A[i][j][k] == *num++);
+          BOOST_TEST(A[i][j][k] == *num++);
   }
 
   // general_storage_order with arbitrary storage order
@@ -119,7 +119,7 @@ test_main(int,char*[])
     for (array::index i = 0; i != 2; ++i)
       for (array::index j = 0; j != 3; ++j)
         for (array::index k = 0; k != 4; ++k)
-          BOOST_CHECK(A[i][j][k] == *num++);
+          BOOST_TEST(A[i][j][k] == *num++);
   }
 
 
@@ -152,7 +152,7 @@ test_main(int,char*[])
     for (array::index i = 0; i != 2; ++i)
       for (array::index j = 0; j != 3; ++j)
         for (array::index k = 0; k != 4; ++k)
-          BOOST_CHECK(A[i][j][k] == *num++);
+          BOOST_TEST(A[i][j][k] == *num++);
   }
 
   return boost::exit_success;

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;