Merge branch 'develop'

index_range.size() was missing

.travis.yml

@@ -0,0 +1,234 @@
+# 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

@@ -0,0 +1,48 @@
+# 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

@@ -0,0 +1,15 @@
+# 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/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:2">
+<a name="table:1">
   <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://anubis.dkuug.dk/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://www.open-std.org/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://anubis.dkuug.dk/JTC1/SC22/WG21/docs/lwg-active.html#96">issue 
+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 
 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 
@@ -74,7 +74,7 @@ integers when incremented and dereferenced (see <a href="http://www.boost.org/li
 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://anubis.dkuug.dk/JTC1/SC22/WG21/docs/lwg-active.html#198">Issue 
+<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 
 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. 
@@ -651,8 +651,8 @@ Iterator</a>.
 </h3>The Forward Iterator is an iterator that can be incremented. Also, it is 
 permissible to make multiple passes through the iterator's range. 
 <h3>Refinement of</h3><a href="http://www.boost.org/libs/utility/CopyConstructible.html">Copy 
-Constructible</a>, <a href="http://www.boost.org/libs/utility/Assignable.html">Assignable</a>, <a href="http://www.sgi.com/tech/stl/DefaultConstructible.html">Default 
-Constructible</a>, and <a href="http://www.sgi.com/tech/stl/EqualityComparable.html">Equality 
+Constructible</a>, <a href="http://www.boost.org/libs/utility/Assignable.html">Assignable</a>, <a href="https://www.boost.org/sgi/stl/DefaultConstructible.html">Default 
+Constructible</a>, and <a href="https://www.boost.org/sgi/stl/EqualityComparable.html">Equality 
 Comparable</a> 
 <h3>Associated types</h3>
 <table border="1">
@@ -725,7 +725,7 @@ Traversal Iterator</a>
 Iterator </h3>An iterator that provides constant-time methods for moving forward 
 and backward in arbitrary-sized steps. 
 <h3>Refinement of</h3><a href="#concept_BidirectionalTraversalIterator">Bidirectional 
-Traversal Iterator</a> and <a href="http://www.sgi.com/tech/stl/LessThanComparable.html">Less Than 
+Traversal Iterator</a> and <a href="https://www.boost.org/sgi/stl/LessThanComparable.html">Less Than 
 Comparable</a> where <tt>&lt;</tt> is a total ordering 
 <h3>Associated types</h3>
 <table border="1">
@@ -794,4 +794,4 @@ Comparable</a> where <tt>&lt;</tt> is a total ordering
 
  --><!--  LocalWords:  Postdecrement
 
- --></body></html>
+ --></body></html>

doc/reference.html

@@ -1,4 +1,4 @@
-<html><head><meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"><title>Boost.MultiArray Reference Manual</title><meta name="generator" content="DocBook XSL Stylesheets V1.71.1"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="article" lang="en"><div class="titlepage"><div><div><h1 class="title"><a name="id823342"></a>Boost.MultiArray Reference Manual</h1></div><div><div class="author"><h3 class="author"><span class="firstname">Ronald</span> <span class="surname">Garcia</span></h3><div class="affiliation"><span class="orgname">Indiana University<br></span> <span class="orgdiv">Open Systems Lab<br></span></div></div></div><div><p class="copyright">Copyright © 2002 The Trustees of Indiana University</p></div></div><hr></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="sect1"><a href="#synopsis">Library Synopsis</a></span></dt><dt><span class="sect1"><a href="#MultiArray">MultiArray Concept</a></span></dt><dd><dl><dt><span class="sect2"><a href="#id896773">Notation</a></span></dt><dt><span class="sect2"><a href="#id896941">Associated Types</a></span></dt><dt><span class="sect2"><a href="#id897451">Valid expressions</a></span></dt><dt><span class="sect2"><a href="#id898268">Complexity guarantees</a></span></dt><dt><span class="sect2"><a href="#id898293">Invariants</a></span></dt><dt><span class="sect2"><a href="#view_types">Associated Types for Views</a></span></dt><dt><span class="sect2"><a href="#id899663">Models</a></span></dt></dl></dd><dt><span class="sect1"><a href="#array_types">Array Components</a></span></dt><dd><dl><dt><span class="sect2"><a href="#multi_array"><code class="literal">multi_array</code></a></span></dt><dt><span class="sect2"><a href="#multi_array_ref"><code class="literal">multi_array_ref</code></a></span></dt><dt><span class="sect2"><a href="#const_multi_array_ref"><code class="literal">const_multi_array_ref</code></a></span></dt></dl></dd><dt><span class="sect1"><a href="#auxiliary">Auxiliary Components</a></span></dt><dd><dl><dt><span class="sect2"><a href="#multi_array_types"><code class="literal">multi_array_types</code></a></span></dt><dt><span class="sect2"><a href="#extent_range"><code class="classname">extent_range</code></a></span></dt><dt><span class="sect2"><a href="#extent_gen"><code class="classname">extent_gen</code></a></span></dt><dt><span class="sect2"><a href="#id906792">Global Objects</a></span></dt><dt><span class="sect2"><a href="#generators">View and SubArray Generators</a></span></dt><dt><span class="sect2"><a href="#memory_layout">Memory Layout Specifiers</a></span></dt><dt><span class="sect2"><a href="#range_checking">Range Checking</a></span></dt></dl></dd></dl></div><p>Boost.MultiArray is composed of several components.
+<html><head><meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"><title>Boost.MultiArray Reference Manual</title><meta name="generator" content="DocBook XSL Stylesheets V1.76.1"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="article" title="Boost.MultiArray Reference Manual"><div class="titlepage"><div><div><h2 class="title"><a name="idp2304"></a>Boost.MultiArray Reference Manual</h2></div><div><div class="author"><h3 class="author"><span class="firstname">Ronald</span> <span class="surname">Garcia</span></h3><div class="affiliation"><span class="orgname">Indiana University<br></span> <span class="orgdiv">Open Systems Lab<br></span></div></div></div><div><p class="copyright">Copyright © 2002 The Trustees of Indiana University</p></div></div><hr></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="sect1"><a href="#synopsis">Library Synopsis</a></span></dt><dt><span class="sect1"><a href="#MultiArray">MultiArray Concept</a></span></dt><dd><dl><dt><span class="sect2"><a href="#idp18427760">Notation</a></span></dt><dt><span class="sect2"><a href="#idp18446208">Associated Types</a></span></dt><dt><span class="sect2"><a href="#idp18501744">Valid expressions</a></span></dt><dt><span class="sect2"><a href="#idp18588736">Complexity guarantees</a></span></dt><dt><span class="sect2"><a href="#idp18591264">Invariants</a></span></dt><dt><span class="sect2"><a href="#view_types">Associated Types for Views</a></span></dt><dt><span class="sect2"><a href="#idp18737792">Models</a></span></dt></dl></dd><dt><span class="sect1"><a href="#array_types">Array Components</a></span></dt><dd><dl><dt><span class="sect2"><a href="#multi_array_class"><code class="literal">multi_array</code></a></span></dt><dt><span class="sect2"><a href="#multi_array_ref"><code class="literal">multi_array_ref</code></a></span></dt><dt><span class="sect2"><a href="#const_multi_array_ref"><code class="literal">const_multi_array_ref</code></a></span></dt></dl></dd><dt><span class="sect1"><a href="#auxiliary">Auxiliary Components</a></span></dt><dd><dl><dt><span class="sect2"><a href="#multi_array_types"><code class="literal">multi_array_types</code></a></span></dt><dt><span class="sect2"><a href="#extent_range"><code class="classname">extent_range</code></a></span></dt><dt><span class="sect2"><a href="#extent_gen"><code class="classname">extent_gen</code></a></span></dt><dt><span class="sect2"><a href="#idp19487120">Global Objects</a></span></dt><dt><span class="sect2"><a href="#generators">View and SubArray Generators</a></span></dt><dt><span class="sect2"><a href="#memory_layout">Memory Layout Specifiers</a></span></dt><dt><span class="sect2"><a href="#range_checking">Range Checking</a></span></dt></dl></dd></dl></div><p>Boost.MultiArray is composed of several components.
 The MultiArray concept defines a generic interface to multidimensional
 containers.
 <code class="literal">multi_array</code> is a general purpose container class
@@ -11,7 +11,7 @@ you can manipulate any block of contiguous data as though it were a
 <code class="literal">multi_array_ref</code> 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.</p><div class="sect1" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="synopsis"></a>Library Synopsis</h2></div></div></div><p>To use Boost.MultiArray, you must include the header 
+part of the library interface.</p><div class="sect1" title="Library Synopsis"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="synopsis"></a>Library Synopsis</h2></div></div></div><p>To use Boost.MultiArray, you must include the header 
 <code class="filename">boost/multi_array.hpp</code> in your source. This file
 brings the following declarations into scope:</p><pre class="programlisting">
 namespace boost {
@@ -52,7 +52,7 @@ namespace boost {
   template &lt;std::size_t NumDims&gt; class general_storage_order;
 
 }
-</pre></div><div class="sect1" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="MultiArray"></a>MultiArray Concept</h2></div></div></div><p>The MultiArray
+</pre></div><div class="sect1" title="MultiArray Concept"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="MultiArray"></a>MultiArray Concept</h2></div></div></div><p>The MultiArray
 concept defines an interface to hierarchically nested
 containers.  It specifies operations for accessing elements,
 traversing containers, and creating views
@@ -150,17 +150,23 @@ number of possible element layouts.  For example, the elements of a 2
 dimensional array can be stored by row (i.e., the elements of each row
 are stored contiguously) or by column (i.e., the elements of each
 column are stored contiguously).
-</p><div class="sect2" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="id896773"></a>Notation</h3></div></div></div><p>What follows are the descriptions of symbols that will be used
-to describe the MultiArray interface.</p><div class="table"><a name="id896782"></a><p class="title"><b>Table 1. Notation</b></p><div class="table-contents"><table summary="Notation" border="1"><colgroup><col><col></colgroup><tbody><tr><td><code class="literal">A</code></td><td>A type that is a model of MultiArray
+</p><p>
+Two concept checking classes for the MultiArray concepts
+(<code class="literal">ConstMultiArrayConcept</code> and
+<code class="literal">MutableMultiArrayConcept</code>) are in the namespace
+<code class="literal">boost::multi_array_concepts</code> in
+<code class="literal">&lt;boost/multi_array/concept_checks.hpp&gt;</code>.
+</p><div class="sect2" title="Notation"><div class="titlepage"><div><div><h3 class="title"><a name="idp18427760"></a>Notation</h3></div></div></div><p>What follows are the descriptions of symbols that will be used
+to describe the MultiArray interface.</p><div class="table"><a name="idp18428768"></a><p class="title"><b>Table 1. Notation</b></p><div class="table-contents"><table summary="Notation" border="1"><colgroup><col><col></colgroup><tbody><tr><td><code class="literal">A</code></td><td>A type that is a model of MultiArray
 </td></tr><tr><td><code class="literal">a,b</code></td><td>Objects of type <code class="literal">A</code></td></tr><tr><td><code class="literal">NumDims</code></td><td>The numeric dimension parameter associated with
 <code class="literal">A</code>.</td></tr><tr><td><code class="literal">Dims</code></td><td>Some numeric dimension parameter such that 
 <code class="literal">0&lt;Dims&lt;NumDims</code>.
 </td></tr><tr><td><code class="literal">indices</code></td><td>An object created by some number of chained calls
 to <code class="literal">index_gen::operator[](index_range)</code>.</td></tr><tr><td><code class="literal">index_list</code></td><td>An object whose type models
-<a href="../../utility/Collection.html" target="_top">Collection</a>
+<a class="ulink" href="../../utility/Collection.html" target="_top">Collection</a>
 </td></tr><tr><td><code class="literal">idx</code></td><td>A signed integral value.</td></tr><tr><td><code class="literal">tmp</code></td><td>An object of type
-	      <code class="literal">boost::array&lt;index,NumDims&gt;</code></td></tr></tbody></table></div></div><br class="table-break"></div><div class="sect2" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="id896941"></a>Associated Types</h3></div></div></div><p>
-</p><div class="table"><a name="id896949"></a><p class="title"><b>Table 2. Associated Types</b></p><div class="table-contents"><table summary="Associated Types" border="1"><colgroup><col><col></colgroup><thead><tr><th>Type</th><th>Description</th></tr></thead><tbody><tr><td><code class="literal">value_type</code></td><td>This is the value type of the container.
+	      <code class="literal">boost::array&lt;index,NumDims&gt;</code></td></tr></tbody></table></div></div><br class="table-break"></div><div class="sect2" title="Associated Types"><div class="titlepage"><div><div><h3 class="title"><a name="idp18446208"></a>Associated Types</h3></div></div></div><p>
+</p><div class="table"><a name="idp18447104"></a><p class="title"><b>Table 2. Associated Types</b></p><div class="table-contents"><table summary="Associated Types" border="1"><colgroup><col><col></colgroup><thead><tr><th>Type</th><th>Description</th></tr></thead><tbody><tr><td><code class="literal">value_type</code></td><td>This is the value type of the container.
   If <code class="literal">NumDims == 1</code>, then this is
 <code class="literal">element</code>. Otherwise, this is the value type of the
 immediately nested containers.
@@ -192,15 +198,17 @@ iterators. It is the same type as
 </td></tr><tr><td><code class="literal">iterator</code></td><td>
 This is an iterator over the values of <code class="literal">A</code>.
 If <code class="literal">NumDims == 1</code>, then it models 
-<a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html" target="_top">
+<a class="ulink" href="http://www.boost.org/doc/html/RandomAccessIterator.html" target="_top">
 <code class="literal">Random Access Iterator</code></a>. 
 Otherwise it models 
-<a href="./iterator_categories.html#concept_RandomAccessTraversalIterator" target="_top">
+<a class="ulink" href="./iterator_categories.html#concept_RandomAccessTraversalIterator" target="_top">
 Random Access Traversal Iterator</a>,
-<a href="./iterator_categories.html#concept_ReadableIterator" target="_top">
-Readable Iterator</a>, and
-<a href="./iterator_categories.html#concept_WritableIterator" target="_top">
-Writable Iterator</a>.
+<a class="ulink" href="./iterator_categories.html#concept_ReadableIterator" target="_top">
+Readable Iterator</a>,
+<a class="ulink" href="./iterator_categories.html#concept_WritableIterator" target="_top">
+Writable Iterator</a>, and 
+<a class="ulink" href="http://www.boost.org/doc/html/OutputIterator.html" target="_top">
+<code class="literal">Output Iterator</code></a>.
 </td></tr><tr><td>
 <code class="literal">const_iterator</code>
 </td><td>
@@ -260,7 +268,7 @@ It models MultiArray.
 const_array_view&lt;Dims&gt;::type</code>
 </td><td>
 This is the const view type with <code class="literal">Dims</code> dimensions.
-</td></tr></tbody></table></div></div><br class="table-break"></div><div class="sect2" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="id897451"></a>Valid expressions</h3></div></div></div><div class="table"><a name="id897455"></a><p class="title"><b>Table 3. Valid Expressions</b></p><div class="table-contents"><table summary="Valid Expressions" border="1"><colgroup><col><col><col></colgroup><thead><tr><th>Expression</th><th>Return type</th><th>Semantics</th></tr></thead><tbody><tr><td><code class="literal">A::dimensionality</code></td><td><code class="literal">size_type</code></td><td>This compile-time constant represents the number of
+</td></tr></tbody></table></div></div><br class="table-break"></div><div class="sect2" title="Valid expressions"><div class="titlepage"><div><div><h3 class="title"><a name="idp18501744"></a>Valid expressions</h3></div></div></div><div class="table"><a name="idp18502256"></a><p class="title"><b>Table 3. Valid Expressions</b></p><div class="table-contents"><table summary="Valid Expressions" border="1"><colgroup><col><col><col></colgroup><thead><tr><th>Expression</th><th>Return type</th><th>Semantics</th></tr></thead><tbody><tr><td><code class="literal">A::dimensionality</code></td><td><code class="literal">size_type</code></td><td>This compile-time constant represents the number of
 dimensions of the array (note that 
 <code class="literal">A::dimensionality == NumDims</code>).</td></tr><tr><td><code class="literal">a.shape()</code></td><td><code class="literal">const size_type*</code></td><td>
 This returns a list of <code class="literal">NumDims</code> elements specifying the
@@ -345,26 +353,26 @@ This expression generates a view of the array determined by the
  used to construct <code class="literal">indices</code>.
 </td></tr><tr><td><code class="literal">a == b</code></td><td>bool</td><td>This performs a lexicographical comparison of the
 values of <code class="literal">a</code> and <code class="literal">b</code>.  The element
-type must model <a href="http://www.sgi.com/tech/stl/EqualityComparable.html" target="_top">EqualityComparable</a> for this
+type must model <a class="ulink" href="https://www.boost.org/sgi/stl/EqualityComparable.html" target="_top">EqualityComparable</a> for this
 expression to be valid.</td></tr><tr><td><code class="literal">a &lt; b</code></td><td>bool</td><td>This performs a lexicographical comparison of the
 values of <code class="literal">a</code> and <code class="literal">b</code>.  The element
-type must model <a href="http://www.sgi.com/tech/stl/LessThanComparable.html" target="_top">LessThanComparable</a> for this
+type must model <a class="ulink" href="https://www.boost.org/sgi/stl/LessThanComparable.html" target="_top">LessThanComparable</a> for this
 expression to be valid.</td></tr><tr><td><code class="literal">a &lt;= b</code></td><td>bool</td><td>This performs a lexicographical comparison of the
 values of <code class="literal">a</code> and <code class="literal">b</code>.  The element
-type must model <a href="http://www.sgi.com/tech/stl/EqualityComparable.html" target="_top">EqualityComparable</a> and
-<a href="http://www.sgi.com/tech/stl/LessThanComparable.html" target="_top">LessThanComparable</a> for this
+type must model <a class="ulink" href="https://www.boost.org/sgi/stl/EqualityComparable.html" target="_top">EqualityComparable</a> and
+<a class="ulink" href="https://www.boost.org/sgi/stl/LessThanComparable.html" target="_top">LessThanComparable</a> for this
 expression to be valid.</td></tr><tr><td><code class="literal">a &gt; b</code></td><td>bool</td><td>This performs a lexicographical comparison of the
 values of <code class="literal">a</code> and <code class="literal">b</code>.  The element
-type must model <a href="http://www.sgi.com/tech/stl/EqualityComparable.html" target="_top">EqualityComparable</a> and 
-<a href="http://www.sgi.com/tech/stl/LessThanComparable.html" target="_top">LessThanComparable</a> for this
+type must model <a class="ulink" href="https://www.boost.org/sgi/stl/EqualityComparable.html" target="_top">EqualityComparable</a> and 
+<a class="ulink" href="https://www.boost.org/sgi/stl/LessThanComparable.html" target="_top">LessThanComparable</a> for this
 expression to be valid.</td></tr><tr><td><code class="literal">a &gt;= b</code></td><td>bool</td><td>This performs a lexicographical comparison of the
 values of <code class="literal">a</code> and <code class="literal">b</code>.  The element
-type must model <a href="http://www.sgi.com/tech/stl/LessThanComparable.html" target="_top">LessThanComparable</a> for this
-expression to be valid.</td></tr></tbody></table></div></div><br class="table-break"></div><div class="sect2" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="id898268"></a>Complexity guarantees</h3></div></div></div><code class="literal">begin()</code> and <code class="literal">end()</code> execute in amortized
+type must model <a class="ulink" href="https://www.boost.org/sgi/stl/LessThanComparable.html" target="_top">LessThanComparable</a> for this
+expression to be valid.</td></tr></tbody></table></div></div><br class="table-break"></div><div class="sect2" title="Complexity guarantees"><div class="titlepage"><div><div><h3 class="title"><a name="idp18588736"></a>Complexity guarantees</h3></div></div></div><code class="literal">begin()</code> and <code class="literal">end()</code> execute in amortized
 constant time.
 <code class="literal">size()</code> executes in at most linear time in the 
 MultiArray's size. 
-</div><div class="sect2" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="id898293"></a>Invariants</h3></div></div></div><div class="table"><a name="id898298"></a><p class="title"><b>Table 4. Invariants</b></p><div class="table-contents"><table summary="Invariants" border="1"><colgroup><col><col></colgroup><tbody><tr><td>Valid range</td><td><code class="literal">[a.begin(),a.end())</code> is a valid range.
+</div><div class="sect2" title="Invariants"><div class="titlepage"><div><div><h3 class="title"><a name="idp18591264"></a>Invariants</h3></div></div></div><div class="table"><a name="idp18591904"></a><p class="title"><b>Table 4. Invariants</b></p><div class="table-contents"><table summary="Invariants" border="1"><colgroup><col><col></colgroup><tbody><tr><td>Valid range</td><td><code class="literal">[a.begin(),a.end())</code> is a valid range.
             </td></tr><tr><td>Range size</td><td>
 <code class="literal">a.size() == std::distance(a.begin(),a.end());</code>.
 </td></tr><tr><td>Completeness</td><td>
@@ -375,11 +383,11 @@ Iteration through the range
 Calling <code class="literal">a[a1][a2]...[aN]</code> where <code class="literal">N==NumDims</code>
 yields the same result as calling 
 <code class="literal">a(index_list)</code>, where <code class="literal">index_list</code>
-is a <a href="../../utility/Collection.html" target="_top">Collection</a> containing the values <code class="literal">a1...aN</code>.
-</td></tr></tbody></table></div></div><br class="table-break"></div><div class="sect2" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="view_types"></a>Associated Types for Views</h3></div></div></div><p>The following MultiArray  associated 
+is a <a class="ulink" href="../../utility/Collection.html" target="_top">Collection</a> containing the values <code class="literal">a1...aN</code>.
+</td></tr></tbody></table></div></div><br class="table-break"></div><div class="sect2" title="Associated Types for Views"><div class="titlepage"><div><div><h3 class="title"><a name="view_types"></a>Associated Types for Views</h3></div></div></div><p>The following MultiArray  associated 
 types define the interface for creating views of existing
 MultiArrays. Their interfaces and roles in the
-concept are described below.</p><div class="sect3" lang="en"><div class="titlepage"><div><div><h4 class="title"><a name="index_range"></a><code class="literal">index_range</code></h4></div></div></div><p><code class="literal">index_range</code> objects represent half-open
+concept are described below.</p><div class="sect3" title="index_range"><div class="titlepage"><div><div><h4 class="title"><a name="index_range"></a><code class="literal">index_range</code></h4></div></div></div><p><code class="literal">index_range</code> objects represent half-open
 strided intervals.  They are aggregated (using an
 <code class="literal">index_gen</code> object) and passed to 
 a MultiArray's <code class="literal">operator[]</code>
@@ -403,10 +411,10 @@ operators,  a half open range [5,10) can be specified as follows:
 
 The following describes the
 <code class="literal">index_range</code> interface.
-</p><div class="table"><a name="id898526"></a><p class="title"><b>Table 5. Notation</b></p><div class="table-contents"><table summary="Notation" border="1"><colgroup><col><col></colgroup><tbody><tr><td><code class="literal">i</code></td><td>An object of type <code class="literal">index_range</code>.</td></tr><tr><td><code class="literal">idx,idx1,idx2,idx3</code></td><td>Objects of type <code class="literal">index</code>.</td></tr></tbody></table></div></div><br class="table-break"><div class="table"><a name="id898580"></a><p class="title"><b>Table 6. Associated Types</b></p><div class="table-contents"><table summary="Associated Types" border="1"><colgroup><col><col></colgroup><thead><tr><th>Type</th><th>Description</th></tr></thead><tbody><tr><td><code class="literal">index</code></td><td>This is a signed integral type. It is used to
+</p><div class="table"><a name="idp18614960"></a><p class="title"><b>Table 5. Notation</b></p><div class="table-contents"><table summary="Notation" border="1"><colgroup><col><col></colgroup><tbody><tr><td><code class="literal">i</code></td><td>An object of type <code class="literal">index_range</code>.</td></tr><tr><td><code class="literal">idx,idx1,idx2,idx3</code></td><td>Objects of type <code class="literal">index</code>.</td></tr></tbody></table></div></div><br class="table-break"><div class="table"><a name="idp18620944"></a><p class="title"><b>Table 6. Associated Types</b></p><div class="table-contents"><table summary="Associated Types" border="1"><colgroup><col><col></colgroup><thead><tr><th>Type</th><th>Description</th></tr></thead><tbody><tr><td><code class="literal">index</code></td><td>This is a signed integral type. It is used to
 specify the start, finish, and stride values.</td></tr><tr><td><code class="literal">size_type</code></td><td>This is an unsigned integral type. It is used to
 report the size of the range an <code class="literal">index_range</code> 
-represents.</td></tr></tbody></table></div></div><br class="table-break"><div class="table"><a name="id898642"></a><p class="title"><b>Table 7. Valid Expressions</b></p><div class="table-contents"><table summary="Valid Expressions" border="1"><colgroup><col><col><col></colgroup><thead><tr><th>Expression</th><th>Return type</th><th>Semantics</th></tr></thead><tbody><tr><td><code class="literal">index_range(idx1,idx2,idx3)</code></td><td><code class="literal">index_range</code></td><td>This constructs an <code class="literal">index_range</code>
+represents.</td></tr></tbody></table></div></div><br class="table-break"><div class="table"><a name="idp18627920"></a><p class="title"><b>Table 7. Valid Expressions</b></p><div class="table-contents"><table summary="Valid Expressions" border="1"><colgroup><col><col><col></colgroup><thead><tr><th>Expression</th><th>Return type</th><th>Semantics</th></tr></thead><tbody><tr><td><code class="literal">index_range(idx1,idx2,idx3)</code></td><td><code class="literal">index_range</code></td><td>This constructs an <code class="literal">index_range</code>
 	    representing the interval <code class="literal">[idx1,idx2)</code>
  with stride <code class="literal">idx3</code>.</td></tr><tr><td><code class="literal">index_range(idx1,idx2)</code></td><td><code class="literal">index_range</code></td><td>This constructs an <code class="literal">index_range</code>
 	    representing the interval <code class="literal">[idx1,idx2)</code>
@@ -438,14 +446,14 @@ value. This notation includes
 of <code class="literal">i</code> up by <code class="literal">idx</code>. It is equivalent to 
 <code class="literal">index_range(r.start()+idx1, r.finish()+idx, r.stride())</code></td></tr><tr><td><code class="literal">i - idx</code></td><td><code class="literal">index</code></td><td>This expression shifts the start and finish values
 of <code class="literal">i</code> up by <code class="literal">idx</code>. It is equivalent to 
-<code class="literal">index_range(r.start()-idx1, r.finish()-idx, r.stride())</code></td></tr></tbody></table></div></div><br class="table-break"></div><div class="sect3" lang="en"><div class="titlepage"><div><div><h4 class="title"><a name="index_gen"></a><code class="literal">index_gen</code></h4></div></div></div><p> <code class="literal">index_gen</code> aggregates 
+<code class="literal">index_range(r.start()-idx1, r.finish()-idx, r.stride())</code></td></tr></tbody></table></div></div><br class="table-break"></div><div class="sect3" title="index_gen"><div class="titlepage"><div><div><h4 class="title"><a name="index_gen"></a><code class="literal">index_gen</code></h4></div></div></div><p> <code class="literal">index_gen</code> aggregates 
 <code class="literal">index_range</code> objects in order to specify view
 parameters.  Chained calls to <code class="literal">operator[]</code> store
 range and dimension information used to 
 instantiate a new view into a MultiArray.
-</p><div class="table"><a name="id899309"></a><p class="title"><b>Table 8. Notation</b></p><div class="table-contents"><table summary="Notation" border="1"><colgroup><col><col></colgroup><tbody><tr><td><code class="literal">Dims,Ranges</code></td><td>Unsigned integral values.</td></tr><tr><td><code class="literal">x</code></td><td>An object of type 
+</p><div class="table"><a name="idp18699808"></a><p class="title"><b>Table 8. Notation</b></p><div class="table-contents"><table summary="Notation" border="1"><colgroup><col><col></colgroup><tbody><tr><td><code class="literal">Dims,Ranges</code></td><td>Unsigned integral values.</td></tr><tr><td><code class="literal">x</code></td><td>An object of type 
 <code class="literal">template gen_type&lt;Dims,Ranges&gt;::type</code>.</td></tr><tr><td><code class="literal">i</code></td><td>An object of type 
-<code class="literal">index_range</code>.</td></tr><tr><td><code class="literal">idx</code></td><td>Objects of type <code class="literal">index</code>.</td></tr></tbody></table></div></div><br class="table-break"><div class="table"><a name="id899395"></a><p class="title"><b>Table 9. Associated Types</b></p><div class="table-contents"><table summary="Associated Types" border="1"><colgroup><col><col></colgroup><thead><tr><th>Type</th><th>Description</th></tr></thead><tbody><tr><td><code class="literal">index</code></td><td>This is a signed integral type. It is used to
+<code class="literal">index_range</code>.</td></tr><tr><td><code class="literal">idx</code></td><td>Objects of type <code class="literal">index</code>.</td></tr></tbody></table></div></div><br class="table-break"><div class="table"><a name="idp18709408"></a><p class="title"><b>Table 9. Associated Types</b></p><div class="table-contents"><table summary="Associated Types" border="1"><colgroup><col><col></colgroup><thead><tr><th>Type</th><th>Description</th></tr></thead><tbody><tr><td><code class="literal">index</code></td><td>This is a signed integral type. It is used to
 specify degenerate dimensions.</td></tr><tr><td><code class="literal">size_type</code></td><td>This is an unsigned integral type. It is used to
 report the size of the range an <code class="literal">index_range</code> 
 represents.</td></tr><tr><td>
@@ -456,21 +464,21 @@ represents.</td></tr><tr><td>
 degenerate ranges specified (i.e. calls to
 <code class="literal">operator[](index)</code>). Note that  
 <code class="classname">index_gen</code> and
-<code class="classname">gen_type&lt;0,0&gt;::type</code> are the same type.</td></tr></tbody></table></div></div><br class="table-break"><div class="table"><a name="id899506"></a><p class="title"><b>Table 10. Valid Expressions</b></p><div class="table-contents"><table summary="Valid Expressions" border="1"><colgroup><col><col><col></colgroup><thead><tr><th>Expression</th><th>Return type</th><th>Semantics</th></tr></thead><tbody><tr><td><code class="literal">index_gen()</code></td><td><code class="literal">gen_type&lt;0,0&gt;::type</code></td><td>This constructs an <code class="literal">index_gen</code>
+<code class="classname">gen_type&lt;0,0&gt;::type</code> are the same type.</td></tr></tbody></table></div></div><br class="table-break"><div class="table"><a name="idp18721296"></a><p class="title"><b>Table 10. Valid Expressions</b></p><div class="table-contents"><table summary="Valid Expressions" border="1"><colgroup><col><col><col></colgroup><thead><tr><th>Expression</th><th>Return type</th><th>Semantics</th></tr></thead><tbody><tr><td><code class="literal">index_gen()</code></td><td><code class="literal">gen_type&lt;0,0&gt;::type</code></td><td>This constructs an <code class="literal">index_gen</code>
 object. This object can then be used to generate tuples of
 <code class="literal">index_range</code> values.</td></tr><tr><td><code class="literal">x[i]</code></td><td><code class="literal">gen_type&lt;Dims+1,Ranges+1&gt;::type</code>
 </td><td>Returns a new object containing all previous
 <code class="classname">index_range</code> objects in addition to
 <code class="literal">i.</code> Chained calls to
 <code class="function">operator[]</code> are the means by which
-<code class="classname">index_range</code> objects are aggregated.</td></tr><tr><td><code class="literal">x[idx]</code></td><td><code class="literal">gen_type&lt;Dims,Ranges&gt;::type</code>
+<code class="classname">index_range</code> objects are aggregated.</td></tr><tr><td><code class="literal">x[idx]</code></td><td><code class="literal">gen_type&lt;Dims,Ranges+1&gt;::type</code>
 </td><td>Returns a new object containing all previous
 <code class="classname">index_range</code> objects in addition to a degenerate
 range, <code class="literal">index_range(idx,idx).</code> Note that this is NOT
 equivalent to <code class="literal">x[index_range(idx,idx)].</code>, which will
 return an object of type
 <code class="literal">gen_type&lt;Dims+1,Ranges+1&gt;::type</code>.
-</td></tr></tbody></table></div></div><br class="table-break"></div></div><div class="sect2" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="id899663"></a>Models</h3></div></div></div><div class="itemizedlist"><ul type="disc"><li><code class="literal">multi_array</code></li><li><code class="literal">multi_array_ref</code></li><li><code class="literal">const_multi_array_ref</code></li><li><code class="literal">template array_view&lt;Dims&gt;::type</code></li><li><code class="literal">template const_array_view&lt;Dims&gt;::type</code></li><li><code class="literal">template subarray&lt;Dims&gt;::type</code></li><li><code class="literal">template const_subarray&lt;Dims&gt;::type</code></li></ul></div></div></div><div class="sect1" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="array_types"></a>Array Components</h2></div></div></div><p>
+</td></tr></tbody></table></div></div><br class="table-break"></div></div><div class="sect2" title="Models"><div class="titlepage"><div><div><h3 class="title"><a name="idp18737792"></a>Models</h3></div></div></div><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><code class="literal">multi_array</code></li><li class="listitem"><code class="literal">multi_array_ref</code></li><li class="listitem"><code class="literal">const_multi_array_ref</code></li><li class="listitem"><code class="literal">template array_view&lt;Dims&gt;::type</code></li><li class="listitem"><code class="literal">template const_array_view&lt;Dims&gt;::type</code></li><li class="listitem"><code class="literal">template subarray&lt;Dims&gt;::type</code></li><li class="listitem"><code class="literal">template const_subarray&lt;Dims&gt;::type</code></li></ul></div></div></div><div class="sect1" title="Array Components"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="array_types"></a>Array Components</h2></div></div></div><p>
 Boost.MultiArray defines an array class,
 <code class="literal">multi_array</code>, and two adapter classes,
 <code class="literal">multi_array_ref</code> and 
@@ -487,7 +495,7 @@ 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.
-</p><p><b>Note: Preconditions, Effects, and Implementation. </b>
+</p><p title="Note: Preconditions, Effects, and Implementation"><b>Note: Preconditions, Effects, and Implementation. </b>
 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
@@ -498,7 +506,7 @@ 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. 
-</p><p><b>Queries. </b></p><div class="variablelist"><dl><dt><span class="term"><pre class="programlisting">element* data();
+</p><p title="Queries"><b>Queries. </b></p><div class="variablelist"><dl><dt><span class="term"><pre class="programlisting">element* data();
 const element* data() const;</pre></span></dt><dd><p>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 
@@ -516,7 +524,7 @@ version of this function. (Required by MultiArray)
 <code class="literal">multi_array</code>. (Required by MultiArray)
 </p></dd><dt><span class="term"><code class="function">const size_type* shape();</code></span></dt><dd><p>This returns the shape of the
 <code class="literal">multi_array</code>. (Required by MultiArray)
-</p></dd></dl></div><p><b>Comparators. </b></p><div class="variablelist"><dl><dt><span class="term"><pre class="programlisting">
+</p></dd></dl></div><p title="Comparators"><b>Comparators. </b></p><div class="variablelist"><dl><dt><span class="term"><pre class="programlisting">
 bool operator==(const *array-type*&amp; rhs);
 bool operator!=(const *array-type*&amp; rhs);
 bool operator&lt;(const *array-type*&amp; rhs);
@@ -525,9 +533,9 @@ bool operator&gt;=(const *array-type*&amp; rhs);
 bool operator&lt;=(const *array-type*&amp; rhs);</pre></span></dt><dd><p>Each comparator executes a lexicographical compare over
 the value types of the two arrays.
 (Required by MultiArray)
-</p><p><b>Preconditions. </b><code class="literal">element</code> must support the
+</p><p title="Preconditions"><b>Preconditions. </b><code class="literal">element</code> must support the
 comparator corresponding to that called on
-<code class="literal">multi_array</code>.</p><p><b>Complexity. </b>O(<code class="literal">num_elements()</code>).</p></dd></dl></div><p><b>Modifiers. </b></p><div class="variablelist"><dl><dt><span class="term">
+<code class="literal">multi_array</code>.</p><p title="Complexity"><b>Complexity. </b>O(<code class="literal">num_elements()</code>).</p></dd></dl></div><p title="Modifiers"><b>Modifiers. </b></p><div class="variablelist"><dl><dt><span class="term">
 <pre class="programlisting">
 
 template &lt;typename SizeList&gt;
@@ -537,12 +545,12 @@ void reshape(const SizeList&amp; sizes)
 </span></dt><dd><p>This changes the shape of the <code class="literal">multi_array</code>.  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.</p><p><b><code class="literal">SizeList</code> Requirements. </b><code class="literal">SizeList</code> must model
-<a href="../../utility/Collection.html" target="_top">Collection</a>.</p><p><b>Preconditions. </b>
+change.</p><p title="SizeList Requirements"><b><code class="literal">SizeList</code> Requirements. </b><code class="literal">SizeList</code> must model
+<a class="ulink" href="../../utility/Collection.html" target="_top">Collection</a>.</p><p title="Preconditions"><b>Preconditions. </b>
 </p><pre class="programlisting">
 std::accumulate(sizes.begin(),sizes.end(),size_type(1),std::times&lt;size_type&gt;()) == this-&gt;num_elements();
 sizes.size() == NumDims;
-</pre><p><b>Postconditions. </b>
+</pre><p title="Postconditions"><b>Postconditions. </b>
 <code class="literal">std::equal(sizes.begin(),sizes.end(),this-&gt;shape) == true;</code>
 </p></dd><dt><span class="term">
 <pre class="programlisting">
@@ -552,8 +560,8 @@ void reindex(const BaseList&amp; values);
 
 </pre>
 </span></dt><dd><p>This changes the index bases of the <code class="literal">multi_array</code> to
-correspond to the the values in <code class="literal">values</code>.</p><p><b><code class="literal">BaseList</code> Requirements. </b><code class="literal">BaseList</code> must model
-<a href="../../utility/Collection.html" target="_top">Collection</a>.</p><p><b>Preconditions. </b><code class="literal">values.size() == NumDims;</code></p><p><b>Postconditions. </b><code class="literal">std::equal(values.begin(),values.end(),this-&gt;index_bases());
+correspond to the the values in <code class="literal">values</code>.</p><p title="BaseList Requirements"><b><code class="literal">BaseList</code> Requirements. </b><code class="literal">BaseList</code> must model
+<a class="ulink" href="../../utility/Collection.html" target="_top">Collection</a>.</p><p title="Preconditions"><b>Preconditions. </b><code class="literal">values.size() == NumDims;</code></p><p title="Postconditions"><b>Postconditions. </b><code class="literal">std::equal(values.begin(),values.end(),this-&gt;index_bases());
 </code></p></dd><dt><span class="term">
 <pre class="programlisting">
 
@@ -561,15 +569,15 @@ void reindex(index value);
 
 </pre>
 </span></dt><dd><p>This changes the index bases of all dimensions of the
-<code class="literal">multi_array</code> to <code class="literal">value</code>.</p><p><b>Postconditions. </b>
+<code class="literal">multi_array</code> to <code class="literal">value</code>.</p><p title="Postconditions"><b>Postconditions. </b>
 </p><pre class="programlisting">
 
 std::count_if(this-&gt;index_bases(),this-&gt;index_bases()+this-&gt;num_dimensions(),
               std::bind_2nd(std::equal_to&lt;index&gt;(),value)) == 
               this-&gt;num_dimensions();
 
-</pre><p>
-</p></dd></dl></div><div class="sect2" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="multi_array"></a><code class="literal">multi_array</code></h3></div></div></div><p>
+</pre><p title="Postconditions">
+</p></dd></dl></div><div class="sect2" title="multi_array"><div class="titlepage"><div><div><h3 class="title"><a name="multi_array_class"></a><code class="literal">multi_array</code></h3></div></div></div><p>
 <code class="literal">multi_array</code> is a multi-dimensional container that
 supports random access iteration. Its number of dimensions is
 fixed at compile time, but its shape and the number of elements it
@@ -578,11 +586,11 @@ will remain fixed for the duration of a
 <code class="literal">multi_array</code>'s lifetime, but the shape of the container can
 be changed. A <code class="literal">multi_array</code> manages its data elements
 using a replaceable allocator.
-</p><p><b>Model Of. </b>
-<a href="#MultiArray" title="MultiArray Concept">MultiArray</a>,
-<a href="../../../libs/utility/CopyConstructible.html" target="_top">CopyConstructible</a>. Depending on the element type, 
-it may also model <a href="http://www.sgi.com/tech/stl/EqualityComparable.html" target="_top">EqualityComparable</a> and <a href="http://www.sgi.com/tech/stl/LessThanComparable.html" target="_top">LessThanComparable</a>. 
-</p><p><b>Synopsis. </b></p><pre class="programlisting">
+</p><p title="Model Of."><b>Model Of. </b>
+<a class="link" href="#MultiArray" title="MultiArray Concept">MultiArray</a>,
+<a class="ulink" href="../../../libs/utility/CopyConstructible.html" target="_top">CopyConstructible</a>. Depending on the element type, 
+it may also model <a class="ulink" href="https://www.boost.org/sgi/stl/EqualityComparable.html" target="_top">EqualityComparable</a> and <a class="ulink" href="https://www.boost.org/sgi/stl/LessThanComparable.html" target="_top">LessThanComparable</a>. 
+</p><p title="Synopsis"><b>Synopsis. </b></p><pre class="programlisting">
 
 namespace boost {
 
@@ -608,7 +616,7 @@ public:
   typedef multi_array_types::extent_gen         extent_gen;
   typedef multi_array_types::extent_range       extent_range;
   typedef *unspecified*                         storage_order_type;
-  
+
 
   // template typedefs
   template &lt;std::size_t Dims&gt; struct            subarray;
@@ -617,6 +625,9 @@ public:
   template &lt;std::size_t Dims&gt; struct            const_array_view;
   
 
+  static const std::size_t dimensionality = NumDims;
+  
+
   // constructors and destructors
 
   multi_array();
@@ -699,7 +710,7 @@ public:
   multi_array&amp;                  resize(extents_tuple&amp; extents);
 };
 
-</pre><p><b>Constructors. </b></p><div class="variablelist"><dl><dt><span class="term"><pre class="programlisting">template &lt;typename ExtentList&gt;
+</pre><p title="Constructors"><b>Constructors. </b></p><div class="variablelist"><dl><dt><span class="term"><pre class="programlisting">template &lt;typename ExtentList&gt;
 explicit multi_array(const ExtentList&amp; sizes,
                      const storage_order_type&amp; store = c_storage_order(),
                      const Allocator&amp; alloc = Allocator());
@@ -710,9 +721,9 @@ constructed <code class="literal">multi_array</code>.  <code class="literal">sto
 specifies the storage order or layout in memory of the array
 dimensions.  <code class="literal">alloc</code> is used to
 allocate the contained elements.
-</p><p><b><code class="literal">ExtentList</code> Requirements. </b>
-<code class="literal">ExtentList</code> must model <a href="../../utility/Collection.html" target="_top">Collection</a>.
-</p><p><b>Preconditions. </b><code class="literal">sizes.size() == NumDims;</code></p></dd><dt><span class="term">
+</p><p title="ExtentList Requirements"><b><code class="literal">ExtentList</code> Requirements. </b>
+<code class="literal">ExtentList</code> must model <a class="ulink" href="../../utility/Collection.html" target="_top">Collection</a>.
+</p><p title="Preconditions"><b>Preconditions. </b><code class="literal">sizes.size() == NumDims;</code></p></dd><dt><span class="term">
 <pre class="programlisting">explicit multi_array(extent_gen::gen_type&lt;NumDims&gt;::type ranges,
                      const storage_order_type&amp; store = c_storage_order(),
                      const Allocator&amp; alloc = Allocator());
@@ -736,34 +747,34 @@ multi_array(const subarray&lt;NumDims&gt;::type&amp; x);
 multi_array(const array_view&lt;NumDims&gt;::type&amp; x);
 </pre></span></dt><dd><p>These constructors all constructs a <code class="literal">multi_array</code> and 
 perform a deep copy of <code class="literal">x</code>. 
-</p><p><b>Complexity. </b> This performs O(<code class="literal">x.num_elements()</code>) calls to
+</p><p title="Complexity"><b>Complexity. </b> This performs O(<code class="literal">x.num_elements()</code>) calls to
 <code class="literal">element</code>'s copy 
 constructor.
 </p></dd><dt><span class="term"><pre class="programlisting">
 multi_array();
 </pre></span></dt><dd><p>This constructs a <code class="literal">multi_array</code> whose shape is (0,...,0) and contains no elements.
-</p></dd></dl></div><p><b>Note on Constructors. </b>
+</p></dd></dl></div><p title="Note on Constructors"><b>Note on Constructors. </b>
 The  <code class="literal">multi_array</code> construction expressions,
 </p><pre class="programlisting">
      multi_array&lt;int,3&gt; A(boost::extents[5][4][3]);
-</pre><p>
+</pre><p title="Note on Constructors">
 and
 </p><pre class="programlisting">
      boost::array&lt;multi_array_base::index,3&gt; my_extents = {{5, 4, 3}};
      multi_array&lt;int,3&gt; A(my_extents);
-</pre><p>
+</pre><p title="Note on Constructors">
 are equivalent.
-</p><p><b>Modifiers. </b></p><div class="variablelist"><dl><dt><span class="term"><pre class="programlisting">
+</p><p title="Modifiers"><b>Modifiers. </b></p><div class="variablelist"><dl><dt><span class="term"><pre class="programlisting">
 multi_array&amp; operator=(const multi_array&amp; x);
 template &lt;class Array&gt; multi_array&amp; operator=(const Array&amp; x);
 </pre>
 </span></dt><dd><p>This performs an element-wise copy of <code class="literal">x</code>
-into the current <code class="literal">multi_array</code>.</p><p><b><code class="literal">Array</code> Requirements. </b><code class="literal">Array</code> must model MultiArray. 
-</p><p><b>Preconditions. </b>
+into the current <code class="literal">multi_array</code>.</p><p title="Array Requirements"><b><code class="literal">Array</code> Requirements. </b><code class="literal">Array</code> must model MultiArray. 
+</p><p title="Preconditions"><b>Preconditions. </b>
 </p><pre class="programlisting">std::equal(this-&gt;shape(),this-&gt;shape()+this-&gt;num_dimensions(),
-x.shape());</pre><p><b>Postconditions. </b>
-</p><pre class="programlisting">(*.this) == x;</pre><p>
-</p><p><b>Complexity. </b>The assignment operators perform 
+x.shape());</pre><p title="Postconditions"><b>Postconditions. </b>
+</p><pre class="programlisting">(*.this) == x;</pre><p title="Postconditions">
+</p><p title="Complexity"><b>Complexity. </b>The assignment operators perform 
 O(<code class="literal">x.num_elements()</code>) calls to <code class="literal">element</code>'s 
 copy constructor.</p></dd><dt><span class="term">
 <pre class="programlisting">
@@ -774,8 +785,8 @@ void assign(InputIterator begin, InputIterator end);
 </span></dt><dd><p>This copies the elements in the range 
 <code class="literal">[begin,end)</code> into the array.  It is equivalent to 
 <code class="literal">std::copy(begin,end,this-&gt;data())</code>.
-</p><p><b>Preconditions. </b><code class="literal">std::distance(begin,end) == this-&gt;num_elements();</code>
-</p><p><b>Complexity. </b>
+</p><p title="Preconditions"><b>Preconditions. </b><code class="literal">std::distance(begin,end) == this-&gt;num_elements();</code>
+</p><p title="Complexity"><b>Complexity. </b>
 The <code class="literal">assign</code> member function performs
 O(<code class="literal">this-&gt;num_elements()</code>) calls to
 <code class="literal">ValueType</code>'s copy constructor.
@@ -792,25 +803,25 @@ 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
 <code class="literal">element</code> default constructor.
-</p></dd></dl></div><p><b>Queries. </b></p><div class="variablelist"><dl><dt><span class="term"><pre class="programlisting">
+</p></dd></dl></div><p title="Queries"><b>Queries. </b></p><div class="variablelist"><dl><dt><span class="term"><pre class="programlisting">
 storage_order_type&amp; storage_order() const;
 </pre>
 </span></dt><dd><p>This query returns the storage order object associated with the 
-<code class="literal">multi_array</code> in question.  It can be used to construct a new array with the same storage order.</p></dd></dl></div></div><div class="sect2" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="multi_array_ref"></a><code class="literal">multi_array_ref</code></h3></div></div></div><p>
+<code class="literal">multi_array</code> in question.  It can be used to construct a new array with the same storage order.</p></dd></dl></div></div><div class="sect2" title="multi_array_ref"><div class="titlepage"><div><div><h3 class="title"><a name="multi_array_ref"></a><code class="literal">multi_array_ref</code></h3></div></div></div><p>
 <code class="literal">multi_array_ref</code> is a multi-dimensional container
 adaptor.  It provides the MultiArray interface over any contiguous
 block of elements.  <code class="literal">multi_array_ref</code> exports the
 same interface as <code class="literal">multi_array</code>, with the exception
 of the constructors.
-</p><p><b>Model Of. </b>
+</p><p title="Model Of."><b>Model Of. </b>
 <code class="literal">multi_array_ref</code> models 
-<a href="#MultiArray" title="MultiArray Concept">MultiArray</a>,
-<a href="../../../libs/utility/CopyConstructible.html" target="_top">CopyConstructible</a>.
+<a class="link" href="#MultiArray" title="MultiArray Concept">MultiArray</a>,
+<a class="ulink" href="../../../libs/utility/CopyConstructible.html" target="_top">CopyConstructible</a>.
 and depending on the element type, it may also model
-<a href="http://www.sgi.com/tech/stl/EqualityComparable.html" target="_top">EqualityComparable</a> and <a href="http://www.sgi.com/tech/stl/LessThanComparable.html" target="_top">LessThanComparable</a>. 
+<a class="ulink" href="https://www.boost.org/sgi/stl/EqualityComparable.html" target="_top">EqualityComparable</a> and <a class="ulink" href="https://www.boost.org/sgi/stl/LessThanComparable.html" target="_top">LessThanComparable</a>. 
 Detailed descriptions are provided here only for operations that are
 not described in the <code class="literal">multi_array</code> reference.
-</p><p><b>Synopsis. </b></p><pre class="programlisting">
+</p><p title="Synopsis"><b>Synopsis. </b></p><pre class="programlisting">
 
 namespace boost {
 
@@ -843,7 +854,10 @@ public:
   template &lt;std::size_t Dims&gt; struct            const_array_view;
   
 
-  // structors
+  static const std::size_t dimensionality = NumDims;
+
+
+  // constructors and destructors
 
   template &lt;typename ExtentList&gt;
   explicit multi_array_ref(element* data, const ExtentList&amp; sizes,
@@ -910,7 +924,7 @@ public:
   void				reindex(index value);
 };
 
-</pre><p><b>Constructors. </b></p><div class="variablelist"><dl><dt><span class="term"><pre class="programlisting">template &lt;typename ExtentList&gt;
+</pre><p title="Constructors"><b>Constructors. </b></p><div class="variablelist"><dl><dt><span class="term"><pre class="programlisting">template &lt;typename ExtentList&gt;
 explicit multi_array_ref(element* data, 
                      const ExtentList&amp; sizes,
                      const storage_order&amp; store = c_storage_order(),
@@ -922,9 +936,9 @@ constructed <code class="literal">multi_array_ref</code>.  <code class="literal"
 specifies the storage order or layout in memory of the array
 dimensions.  <code class="literal">alloc</code> is used to
 allocate the contained elements.
-</p><p><b><code class="literal">ExtentList</code> Requirements. </b>
-<code class="literal">ExtentList</code> must model <a href="../../utility/Collection.html" target="_top">Collection</a>.
-</p><p><b>Preconditions. </b><code class="literal">sizes.size() == NumDims;</code></p></dd><dt><span class="term">
+</p><p title="ExtentList Requirements"><b><code class="literal">ExtentList</code> Requirements. </b>
+<code class="literal">ExtentList</code> must model <a class="ulink" href="../../utility/Collection.html" target="_top">Collection</a>.
+</p><p title="Preconditions"><b>Preconditions. </b><code class="literal">sizes.size() == NumDims;</code></p></dd><dt><span class="term">
 <pre class="programlisting">explicit multi_array_ref(element* data,
                      extent_gen::gen_type&lt;NumDims&gt;::type ranges,
                      const storage_order&amp; store = c_storage_order());
@@ -939,36 +953,36 @@ dimensions.
 </p></dd><dt><span class="term"><pre class="programlisting">
 multi_array_ref(const multi_array_ref&amp; x);
 </pre></span></dt><dd><p>This constructs a shallow copy of <code class="literal">x</code>.
-</p><p><b>Complexity. </b> Constant time (for contrast, compare this to
+</p><p title="Complexity"><b>Complexity. </b> Constant time (for contrast, compare this to
 the <code class="literal">multi_array</code> class copy constructor.
-</p></dd></dl></div><p><b>Modifiers. </b></p><div class="variablelist"><dl><dt><span class="term"><pre class="programlisting">
+</p></dd></dl></div><p title="Modifiers"><b>Modifiers. </b></p><div class="variablelist"><dl><dt><span class="term"><pre class="programlisting">
 multi_array_ref&amp; operator=(const multi_array_ref&amp; x);
 template &lt;class Array&gt; multi_array_ref&amp; operator=(const Array&amp; x);
 </pre>
 </span></dt><dd><p>This performs an element-wise copy of <code class="literal">x</code>
-into the current <code class="literal">multi_array_ref</code>.</p><p><b><code class="literal">Array</code> Requirements. </b><code class="literal">Array</code> must model MultiArray. 
-</p><p><b>Preconditions. </b>
+into the current <code class="literal">multi_array_ref</code>.</p><p title="Array Requirements"><b><code class="literal">Array</code> Requirements. </b><code class="literal">Array</code> must model MultiArray. 
+</p><p title="Preconditions"><b>Preconditions. </b>
 </p><pre class="programlisting">std::equal(this-&gt;shape(),this-&gt;shape()+this-&gt;num_dimensions(),
-x.shape());</pre><p><b>Postconditions. </b>
-</p><pre class="programlisting">(*.this) == x;</pre><p>
-</p><p><b>Complexity. </b>The assignment operators perform 
+x.shape());</pre><p title="Postconditions"><b>Postconditions. </b>
+</p><pre class="programlisting">(*.this) == x;</pre><p title="Postconditions">
+</p><p title="Complexity"><b>Complexity. </b>The assignment operators perform 
 O(<code class="literal">x.num_elements()</code>) calls to <code class="literal">element</code>'s 
-copy constructor.</p></dd></dl></div></div><div class="sect2" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="const_multi_array_ref"></a><code class="literal">const_multi_array_ref</code></h3></div></div></div><p>
+copy constructor.</p></dd></dl></div></div><div class="sect2" title="const_multi_array_ref"><div class="titlepage"><div><div><h3 class="title"><a name="const_multi_array_ref"></a><code class="literal">const_multi_array_ref</code></h3></div></div></div><p>
 <code class="literal">const_multi_array_ref</code> is a multi-dimensional container
 adaptor.  It provides the MultiArray interface over any contiguous
 block of elements.  <code class="literal">const_multi_array_ref</code> exports the
 same interface as <code class="literal">multi_array</code>, with the exception
 of the constructors.
-</p><p><b>Model Of. </b>
+</p><p title="Model Of."><b>Model Of. </b>
 <code class="literal">const_multi_array_ref</code> models
-<a href="#MultiArray" title="MultiArray Concept">MultiArray</a>,
-<a href="../../../libs/utility/CopyConstructible.html" target="_top">CopyConstructible</a>.
+<a class="link" href="#MultiArray" title="MultiArray Concept">MultiArray</a>,
+<a class="ulink" href="../../../libs/utility/CopyConstructible.html" target="_top">CopyConstructible</a>.
 and depending on the element type, it may also model
-<a href="http://www.sgi.com/tech/stl/EqualityComparable.html" target="_top">EqualityComparable</a> and <a href="http://www.sgi.com/tech/stl/LessThanComparable.html" target="_top">LessThanComparable</a>. 
+<a class="ulink" href="https://www.boost.org/sgi/stl/EqualityComparable.html" target="_top">EqualityComparable</a> and <a class="ulink" href="https://www.boost.org/sgi/stl/LessThanComparable.html" target="_top">LessThanComparable</a>. 
 
 Detailed descriptions are provided here only for operations that are
 not described in the <code class="literal">multi_array</code> reference.
-</p><p><b>Synopsis. </b></p><pre class="programlisting">
+</p><p title="Synopsis"><b>Synopsis. </b></p><pre class="programlisting">
 
 namespace boost {
 
@@ -1054,7 +1068,7 @@ public:
   void				reindex(index value);
 };
 
-</pre><p><b>Constructors. </b></p><div class="variablelist"><dl><dt><span class="term"><pre class="programlisting">template &lt;typename ExtentList&gt;
+</pre><p title="Constructors"><b>Constructors. </b></p><div class="variablelist"><dl><dt><span class="term"><pre class="programlisting">template &lt;typename ExtentList&gt;
 explicit const_multi_array_ref(TPtr data, 
                      const ExtentList&amp; sizes,
                      const storage_order&amp; store = c_storage_order());
@@ -1064,13 +1078,13 @@ parameters.  <code class="literal">sizes</code> specifies the shape of the
 constructed <code class="literal">const_multi_array_ref</code>.  <code class="literal">store</code>
 specifies the storage order or layout in memory of the array
 dimensions.
-</p><p><b><code class="literal">ExtentList</code> Requirements. </b>
-<code class="literal">ExtentList</code> must model <a href="../../utility/Collection.html" target="_top">Collection</a>.
-</p><p><b>Preconditions. </b><code class="literal">sizes.size() == NumDims;</code></p></dd><dt><span class="term">
+</p><p title="ExtentList Requirements"><b><code class="literal">ExtentList</code> Requirements. </b>
+<code class="literal">ExtentList</code> must model <a class="ulink" href="../../utility/Collection.html" target="_top">Collection</a>.
+</p><p title="Preconditions"><b>Preconditions. </b><code class="literal">sizes.size() == NumDims;</code></p></dd><dt><span class="term">
 <pre class="programlisting">explicit const_multi_array_ref(TPtr data,
                      extent_gen::gen_type&lt;NumDims&gt;::type ranges,
                      const storage_order&amp; store = c_storage_order());
-</pre></span></dt><dd><p><b>Effects. </b>
+</pre></span></dt><dd><p title="Effects"><b>Effects. </b>
 This constructs a <code class="literal">const_multi_array_ref</code> using the specified
     parameters.  <code class="literal">ranges</code> specifies the shape and
 index bases of the constructed const_multi_array_ref. It is the result of 
@@ -1080,8 +1094,8 @@ specifies the storage order or layout in memory of the array
 dimensions. 
 </p></dd><dt><span class="term"><pre class="programlisting">
 const_multi_array_ref(const const_multi_array_ref&amp; x);
-</pre></span></dt><dd><p><b>Effects. </b>This constructs a shallow copy of <code class="literal">x</code>.
-</p></dd></dl></div></div></div><div class="sect1" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="auxiliary"></a>Auxiliary Components</h2></div></div></div><div class="sect2" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="multi_array_types"></a><code class="literal">multi_array_types</code></h3></div></div></div><pre class="programlisting">
+</pre></span></dt><dd><p title="Effects"><b>Effects. </b>This constructs a shallow copy of <code class="literal">x</code>.
+</p></dd></dl></div></div></div><div class="sect1" title="Auxiliary Components"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="auxiliary"></a>Auxiliary Components</h2></div></div></div><div class="sect2" title="multi_array_types"><div class="titlepage"><div><div><h3 class="title"><a name="multi_array_types"></a><code class="literal">multi_array_types</code></h3></div></div></div><pre class="programlisting">
 namespace multi_array_types {
   typedef *unspecified* index;
   typedef *unspecified* size_type;
@@ -1103,14 +1117,14 @@ With the exception of <code class="literal">extent_gen</code> and
 same name required by MultiArray and are described in its
 concept definition.  <code class="literal">extent_gen</code> and
 <code class="literal">extent_range</code> are described below.
-</p></div><div class="sect2" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="extent_range"></a><code class="classname">extent_range</code></h3></div></div></div><p><code class="classname">extent_range</code> objects define half open
+</p></div><div class="sect2" title="extent_range"><div class="titlepage"><div><div><h3 class="title"><a name="extent_range"></a><code class="classname">extent_range</code></h3></div></div></div><p><code class="classname">extent_range</code> objects define half open
 intervals.  They provide shape and index base information to
 <code class="literal">multi_array</code>, <code class="literal">multi_array_ref</code>,
  and <code class="literal">const_multi_array_ref</code> constructors.
 <code class="classname">extent_range</code>s are passed in
 aggregate to an array constructor (see
 <code class="classname">extent_gen</code> for more details).
-</p><p><b>Synopsis. </b></p><pre class="programlisting">
+</p><p title="Synopsis"><b>Synopsis. </b></p><pre class="programlisting">
 class extent_range {
 public:
   typedef multi_array_types::index      index;
@@ -1125,14 +1139,14 @@ public:
   index start();
   index finish();
   size_type size();
-};</pre><p><b>Model Of. </b>DefaultConstructible,CopyConstructible</p><p><b>Methods and Types. </b></p><div class="variablelist"><dl><dt><span class="term"><code class="function">extent_range(index start, index finish)</code></span></dt><dd><p>  This constructor defines the half open interval
+};</pre><p title="Model Of"><b>Model Of. </b>DefaultConstructible,CopyConstructible</p><p title="Methods and Types"><b>Methods and Types. </b></p><div class="variablelist"><dl><dt><span class="term"><code class="function">extent_range(index start, index finish)</code></span></dt><dd><p>  This constructor defines the half open interval
 <code class="literal">[start,finish)</code>. The expression
 <code class="literal">finish</code> must be greater than <code class="literal">start</code>.
 </p></dd><dt><span class="term"><code class="function">extent_range(index finish)</code></span></dt><dd><p>This constructor defines the half open interval
 <code class="literal">[0,finish)</code>. The value of <code class="literal">finish</code>
 must be positive.</p></dd><dt><span class="term"><code class="function">index start()</code></span></dt><dd><p>This function returns the first index represented by the range</p></dd><dt><span class="term"><code class="function">index finish()</code></span></dt><dd><p>This function returns the upper boundary value of the half-open
 interval.  Note that the range does not include this value.</p></dd><dt><span class="term"><code class="function">size_type size()</code></span></dt><dd><p>This function returns the size of the specified range. It is
-equivalent to <code class="literal">finish()-start()</code>.</p></dd></dl></div></div><div class="sect2" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="extent_gen"></a><code class="classname">extent_gen</code></h3></div></div></div><p>The <code class="classname">extent_gen</code> class defines an
+equivalent to <code class="literal">finish()-start()</code>.</p></dd></dl></div></div><div class="sect2" title="extent_gen"><div class="titlepage"><div><div><h3 class="title"><a name="extent_gen"></a><code class="classname">extent_gen</code></h3></div></div></div><p>The <code class="classname">extent_gen</code> class defines an
 interface for aggregating array shape and indexing information to be
 passed to a <code class="literal">multi_array</code>, 
 <code class="literal">multi_array_ref</code>, or <code class="literal">const_multi_array_ref</code>
@@ -1144,7 +1158,7 @@ declared as:
 </p><pre class="programlisting">int A[3][4][5],</pre><p>
 a similar <code class="classname">multi_array</code> would be declared:
 </p><pre class="programlisting">multi_array&lt;int,3&gt; A(extents[3][4][5]).</pre><p>
-</p><p><b>Synopsis. </b></p><pre class="programlisting">
+</p><p title="Synopsis"><b>Synopsis. </b></p><pre class="programlisting">
 template &lt;std::size_t NumRanges&gt;
 class *implementation_defined* {
 public:
@@ -1158,7 +1172,7 @@ public:
 };
 
 typedef *implementation_defined*&lt;0&gt; extent_gen;
-</pre><p><b>Methods and Types. </b></p><div class="variablelist"><dl><dt><span class="term"><code class="function">template gen_type::&lt;Ranges&gt;::type</code></span></dt><dd><p>This type generator is used to specify the result of 
+</pre><p title="Methods and Types"><b>Methods and Types. </b></p><div class="variablelist"><dl><dt><span class="term"><code class="function">template gen_type&lt;Ranges&gt;::type</code></span></dt><dd><p>This type generator is used to specify the result of 
 <code class="literal">Ranges</code> chained calls to
 <code class="literal">extent_gen::operator[].</code> The types
 <code class="classname">extent_gen</code> and
@@ -1172,7 +1186,7 @@ operator[](index idx) const;</code></span></dt><dd><p>This function returns a ne
 <code class="classname">extent_range</code> objects in addition to
 <code class="literal">extent_range(0,idx).</code> This function gives the array
 constructors a similar syntax to traditional C multidimensional array
-declaration.</p></dd></dl></div></div><div class="sect2" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="id906792"></a>Global Objects</h3></div></div></div><p>For syntactic convenience, Boost.MultiArray defines two 
+declaration.</p></dd></dl></div></div><div class="sect2" title="Global Objects"><div class="titlepage"><div><div><h3 class="title"><a name="idp19487120"></a>Global Objects</h3></div></div></div><p>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.
@@ -1180,7 +1194,7 @@ expressions involving them create other objects of interest.
 considered excessive overhead.  Their construction can be prevented by
 defining the preprocessor symbol
 <code class="literal">BOOST_MULTI_ARRAY_NO_GENERATORS</code> before including
-<code class="filename">boost/multi_array.hpp.</code></p><div class="sect3" lang="en"><div class="titlepage"><div><div><h4 class="title"><a name="extents"></a><code class="literal">extents</code></h4></div></div></div><pre class="programlisting">
+<code class="filename">boost/multi_array.hpp.</code></p><div class="sect3" title="extents"><div class="titlepage"><div><div><h4 class="title"><a name="extents"></a><code class="literal">extents</code></h4></div></div></div><pre class="programlisting">
 namespace boost {
   multi_array_base::extent_gen extents;
 }
@@ -1192,7 +1206,7 @@ a 3 by 3 by 3 <code class="classname">multi_array</code> is constructed as follo
 </p><pre class="programlisting">multi_array&lt;int,3&gt; A(extents[3][3][3]);</pre><p>
 The same array could also be created by explicitly declaring an <code class="literal">extent_gen</code> 
 object locally,, but the global object makes this declaration unnecessary.  
-</p></div><div class="sect3" lang="en"><div class="titlepage"><div><div><h4 class="title"><a name="indices"></a><code class="literal">indices</code></h4></div></div></div><pre class="programlisting">
+</p></div><div class="sect3" title="indices"><div class="titlepage"><div><div><h4 class="title"><a name="indices"></a><code class="literal">indices</code></h4></div></div></div><pre class="programlisting">
 namespace boost {
   multi_array_base::index_gen  indices;
 }
@@ -1207,7 +1221,7 @@ a view of an array <code class="literal">A</code> is constructed as follows:
 </p><pre class="programlisting">
 A[indices[index_range(0,5)][2][index_range(2,4)]];
 </pre><p>
-</p></div></div><div class="sect2" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="generators"></a>View and SubArray Generators</h3></div></div></div><p>
+</p></div></div><div class="sect2" title="View and SubArray Generators"><div class="titlepage"><div><div><h3 class="title"><a name="generators"></a>View and SubArray Generators</h3></div></div></div><p>
 Boost.MultiArray provides traits classes, <code class="literal">subarray_gen</code>,
 <code class="literal">const_subarray_gen</code>,
 <code class="literal">array_view_gen</code>,
@@ -1233,7 +1247,7 @@ void my_function() {
 
 In the above example, <code class="literal">view1_t</code> and
 <code class="literal">view2_t</code> have the same type.
-</p></div><div class="sect2" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="memory_layout"></a>Memory Layout Specifiers</h3></div></div></div><p>
+</p></div><div class="sect2" title="Memory Layout Specifiers"><div class="titlepage"><div><div><h3 class="title"><a name="memory_layout"></a>Memory Layout Specifiers</h3></div></div></div><p>
 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 
@@ -1321,7 +1335,7 @@ 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.
-</p><div class="sect3" lang="en"><div class="titlepage"><div><div><h4 class="title"><a name="c_storage_order"></a><code class="literal">c_storage_order</code></h4></div></div></div><pre class="programlisting">
+</p><div class="sect3" title="c_storage_order"><div class="titlepage"><div><div><h4 class="title"><a name="c_storage_order"></a><code class="literal">c_storage_order</code></h4></div></div></div><pre class="programlisting">
 class c_storage_order {
   c_storage_order();
 };
@@ -1329,14 +1343,14 @@ class c_storage_order {
 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.</p></div><div class="sect3" lang="en"><div class="titlepage"><div><div><h4 class="title"><a name="fortran_storage_order"></a><code class="literal">fortran_storage_order</code></h4></div></div></div><pre class="programlisting">
+this library.</p></div><div class="sect3" title="fortran_storage_order"><div class="titlepage"><div><div><h4 class="title"><a name="fortran_storage_order"></a><code class="literal">fortran_storage_order</code></h4></div></div></div><pre class="programlisting">
 class fortran_storage_order {
   fortran_storage_order();
 };
 </pre><p><code class="literal">fortran_storage_order</code> 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.</p></div><div class="sect3" lang="en"><div class="titlepage"><div><div><h4 class="title"><a name="general_storage_order"></a><code class="literal">general_storage_order</code></h4></div></div></div><pre class="programlisting">
+last.</p></div><div class="sect3" title="general_storage_order"><div class="titlepage"><div><div><h4 class="title"><a name="general_storage_order"></a><code class="literal">general_storage_order</code></h4></div></div></div><pre class="programlisting">
 template &lt;std::size_t NumDims&gt; 
 class general_storage_order {
 
@@ -1356,7 +1370,7 @@ convertible to <code class="literal">bool</code>.  A value of
 order while <code class="literal">false</code> means that a dimension is stored
 in descending order.  <code class="literal">OrderingIter</code> specifies the
 order in which dimensions are stored.
-</p></div></div><div class="sect2" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="range_checking"></a>Range Checking</h3></div></div></div><p>
+</p></div></div><div class="sect2" title="Range Checking"><div class="titlepage"><div><div><h3 class="title"><a name="range_checking"></a>Range Checking</h3></div></div></div><p>
 By default, the array access methods <code class="literal">operator()</code> and
 <code class="literal">operator[]</code> perform range
 checking.  If a supplied index is out of the range defined for an

doc/test_cases.html

@@ -179,6 +179,13 @@ by library users.
 </td>
 </tr>
 
+<tr>
+<td><a href="../test/allocators.cpp">libs/multi_array/test/allocators.cpp</a></td>
+<td>
+Test support for custom allocators.
+</td>
+</tr>
+
 <tr>
 <td><a href="../test/generative_tests.hpp">libs/multi_array/test/generative_tests.hpp</a></td>
 <td>

doc/user.html

@@ -459,7 +459,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>
@@ -612,7 +612,7 @@ cases can be found <a href="./test_cases.html">here</a>.
 <h2>Related Work</h2>
 
 <a href="../../array/index.html">boost::array</a>
- and <a href="http://www.sgi.com/tech/stl/Vector.html">std::vector</a> are
+ and <a href="https://www.boost.org/sgi/stl/Vector.html">std::vector</a> are
     one-dimensional containers of user data.  Both manage their own
     memory. <tt>std::valarray</tt> is a low-level 
     C++ Standard Library component
@@ -661,6 +661,11 @@ 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>

doc/xml/Jamfile.v2

@@ -0,0 +1,19 @@
+#   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,6 +110,14 @@ 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
@@ -240,15 +248,17 @@ 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.sgi.com/tech/stl/RandomAccessIterator.html">
+<ulink url="http://www.boost.org/doc/html/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>, and
+Readable Iterator</ulink>,
 <ulink url="./iterator_categories.html#concept_WritableIterator">
-Writable Iterator</ulink>.
+Writable Iterator</ulink>, and 
+<ulink url="http://www.boost.org/doc/html/OutputIterator.html">
+<literal>Output Iterator</literal></ulink>.
 </entry>
 </row>
 
@@ -557,7 +567,7 @@ This expression generates a view of the array determined by the
 	      <entry>bool</entry>
 	      <entry>This performs a lexicographical comparison of the
 values of <literal>a</literal> and <literal>b</literal>.  The element
-type must model <ulink url="http://www.sgi.com/tech/stl/EqualityComparable.html">EqualityComparable</ulink> for this
+type must model <ulink url="https://www.boost.org/sgi/stl/EqualityComparable.html">EqualityComparable</ulink> for this
 expression to be valid.</entry>
 	    </row>
 	    <row>
@@ -565,7 +575,7 @@ expression to be valid.</entry>
 	      <entry>bool</entry>
 	      <entry>This performs a lexicographical comparison of the
 values of <literal>a</literal> and <literal>b</literal>.  The element
-type must model <ulink url="http://www.sgi.com/tech/stl/LessThanComparable.html">LessThanComparable</ulink> for this
+type must model <ulink url="https://www.boost.org/sgi/stl/LessThanComparable.html">LessThanComparable</ulink> for this
 expression to be valid.</entry>
 	    </row>
 	    <row>
@@ -573,8 +583,8 @@ expression to be valid.</entry>
 	      <entry>bool</entry>
 	      <entry>This performs a lexicographical comparison of the
 values of <literal>a</literal> and <literal>b</literal>.  The element
-type must model <ulink url="http://www.sgi.com/tech/stl/EqualityComparable.html">EqualityComparable</ulink> and
-<ulink url="http://www.sgi.com/tech/stl/LessThanComparable.html">LessThanComparable</ulink> for this
+type must model <ulink url="https://www.boost.org/sgi/stl/EqualityComparable.html">EqualityComparable</ulink> and
+<ulink url="https://www.boost.org/sgi/stl/LessThanComparable.html">LessThanComparable</ulink> for this
 expression to be valid.</entry>
 	    </row>
 	    <row>
@@ -582,8 +592,8 @@ expression to be valid.</entry>
 	      <entry>bool</entry>
 	      <entry>This performs a lexicographical comparison of the
 values of <literal>a</literal> and <literal>b</literal>.  The element
-type must model <ulink url="http://www.sgi.com/tech/stl/EqualityComparable.html">EqualityComparable</ulink> and 
-<ulink url="http://www.sgi.com/tech/stl/LessThanComparable.html">LessThanComparable</ulink> for this
+type must model <ulink url="https://www.boost.org/sgi/stl/EqualityComparable.html">EqualityComparable</ulink> and 
+<ulink url="https://www.boost.org/sgi/stl/LessThanComparable.html">LessThanComparable</ulink> for this
 expression to be valid.</entry>
 	    </row>
 	    <row>
@@ -591,7 +601,7 @@ expression to be valid.</entry>
 	      <entry>bool</entry>
 	      <entry>This performs a lexicographical comparison of the
 values of <literal>a</literal> and <literal>b</literal>.  The element
-type must model <ulink url="http://www.sgi.com/tech/stl/LessThanComparable.html">LessThanComparable</ulink> for this
+type must model <ulink url="https://www.boost.org/sgi/stl/LessThanComparable.html">LessThanComparable</ulink> for this
 expression to be valid.</entry>
 	    </row>
     </tbody>
@@ -967,7 +977,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&gt;::type</literal>
+		<entry><literal>gen_type&lt;Dims,Ranges+1&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

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

@@ -17,7 +17,7 @@ of the constructors.
 <link linkend="MultiArray">MultiArray</link>,
 <ulink url="../../../libs/utility/CopyConstructible.html">CopyConstructible</ulink>.
 and depending on the element type, it may also model
-<ulink url="http://www.sgi.com/tech/stl/EqualityComparable.html">EqualityComparable</ulink> and <ulink url="http://www.sgi.com/tech/stl/LessThanComparable.html">LessThanComparable</ulink>. 
+<ulink url="https://www.boost.org/sgi/stl/EqualityComparable.html">EqualityComparable</ulink> and <ulink url="https://www.boost.org/sgi/stl/LessThanComparable.html">LessThanComparable</ulink>. 
 
 Detailed descriptions are provided here only for operations that are
 not described in the <literal>multi_array</literal> reference.

doc/xml/multi_array.xml

@@ -1,4 +1,4 @@
-<sect2 id="multi_array">
+<sect2 id="multi_array_class">
 <title><literal>multi_array</literal></title>
 
 <para>
@@ -18,7 +18,7 @@ using a replaceable allocator.
 <para>
 <link linkend="MultiArray">MultiArray</link>,
 <ulink url="../../../libs/utility/CopyConstructible.html">CopyConstructible</ulink>. Depending on the element type, 
-it may also model <ulink url="http://www.sgi.com/tech/stl/EqualityComparable.html">EqualityComparable</ulink> and <ulink url="http://www.sgi.com/tech/stl/LessThanComparable.html">LessThanComparable</ulink>. 
+it may also model <ulink url="https://www.boost.org/sgi/stl/EqualityComparable.html">EqualityComparable</ulink> and <ulink url="https://www.boost.org/sgi/stl/LessThanComparable.html">LessThanComparable</ulink>. 
 </para>
 </formalpara>
 
@@ -51,7 +51,7 @@ public:
   typedef multi_array_types::extent_gen         extent_gen;
   typedef multi_array_types::extent_range       extent_range;
   typedef *unspecified*                         storage_order_type;
-  
+
 
   // template typedefs
   template <std::size_t Dims> struct            subarray;
@@ -60,9 +60,12 @@ public:
   template <std::size_t Dims> struct            const_array_view;
   
 
+  static const std::size_t dimensionality = NumDims;
+  
+
   // constructors and destructors
 
-  multi_array();
+  multi_array(const Allocator& alloc = Allocator());
 
   template <typename ExtentList>
   explicit multi_array(const ExtentList& sizes,
@@ -72,13 +75,19 @@ 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);
-  multi_array(const const_subarray<NumDims>::type& x);
-  multi_array(const const_array_view<NumDims>::type& 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);
-  multi_array(const subarray<NumDims>::type& x);
-  multi_array(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();
 
@@ -204,12 +213,18 @@ elements.
 <varlistentry>
 <term><programlisting>
 <![CDATA[multi_array(const multi_array& x);
-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);]]>
+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());]]>
 </programlisting></term>
 <listitem>
 <para>These constructors all constructs a <literal>multi_array</literal> and 

doc/xml/multi_array_ref.xml

@@ -17,7 +17,7 @@ of the constructors.
 <link linkend="MultiArray">MultiArray</link>,
 <ulink url="../../../libs/utility/CopyConstructible.html">CopyConstructible</ulink>.
 and depending on the element type, it may also model
-<ulink url="http://www.sgi.com/tech/stl/EqualityComparable.html">EqualityComparable</ulink> and <ulink url="http://www.sgi.com/tech/stl/LessThanComparable.html">LessThanComparable</ulink>. 
+<ulink url="https://www.boost.org/sgi/stl/EqualityComparable.html">EqualityComparable</ulink> and <ulink url="https://www.boost.org/sgi/stl/LessThanComparable.html">LessThanComparable</ulink>. 
 Detailed descriptions are provided here only for operations that are
 not described in the <literal>multi_array</literal> reference.
 </para>
@@ -59,7 +59,10 @@ public:
   template <std::size_t Dims> struct            const_array_view;
   
 
-  // structors
+  static const std::size_t dimensionality = NumDims;
+
+
+  // constructors and destructors
 
   template <typename ExtentList>
   explicit multi_array_ref(element* data, const ExtentList& sizes,

doc/xml/reference.xml

@@ -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

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<Array::element>(),A.begin(),A.end(),xform);
+  for_each(boost::type<typename Array::element>(),A.begin(),A.end(),xform);
 }
 
 

example/resize_from_other.cpp

@@ -0,0 +1,57 @@
+// 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,5 +1,8 @@
 // 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)
@@ -18,6 +21,11 @@
 // 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"
@@ -25,6 +33,8 @@
 #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"
@@ -109,8 +119,10 @@ struct disable_multi_array_impl<int>
 template<typename T, std::size_t NumDims,
   typename Allocator>
 class multi_array :
-  public multi_array_ref<T,NumDims>
+  public multi_array_ref<T,NumDims>,
+  private boost::empty_value<Allocator>
 {
+  typedef boost::empty_value<Allocator> alloc_base;
   typedef multi_array_ref<T,NumDims> super_type;
 public:
   typedef typename super_type::value_type value_type;
@@ -137,22 +149,25 @@ public:
     typedef boost::detail::multi_array::multi_array_view<T,NDims> type;
   };
 
-  explicit multi_array() :
+  explicit multi_array(const Allocator& alloc = Allocator()) :
     super_type((T*)initial_base_,c_storage_order(),
-               /*index_bases=*/0, /*extents=*/0) {
+               /*index_bases=*/0, /*extents=*/0),
+    alloc_base(boost::empty_init_t(),alloc) {
     allocate_space(); 
   }
 
   template <class ExtentList>
   explicit multi_array(
-      ExtentList const& extents
+      ExtentList const& extents,
+      const Allocator& alloc = Allocator()
 #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) {
+    super_type((T*)initial_base_,extents),
+    alloc_base(boost::empty_init_t(),alloc) {
     boost::function_requires<
       detail::multi_array::CollectionConcept<ExtentList> >();
     allocate_space();
@@ -162,7 +177,8 @@ public:
   template <class ExtentList>
   explicit multi_array(ExtentList const& extents,
                        const general_storage_order<NumDims>& so) :
-    super_type((T*)initial_base_,extents,so) {
+    super_type((T*)initial_base_,extents,so),
+    alloc_base(boost::empty_init_t()) {
     boost::function_requires<
       detail::multi_array::CollectionConcept<ExtentList> >();
     allocate_space();
@@ -172,7 +188,8 @@ public:
   explicit multi_array(ExtentList const& extents,
                        const general_storage_order<NumDims>& so,
                        Allocator const& alloc) :
-    super_type((T*)initial_base_,extents,so), allocator_(alloc) {
+    super_type((T*)initial_base_,extents,so),
+    alloc_base(boost::empty_init_t(),alloc) {
     boost::function_requires<
       detail::multi_array::CollectionConcept<ExtentList> >();
     allocate_space();
@@ -180,8 +197,10 @@ public:
 
 
   explicit multi_array(const detail::multi_array
-                       ::extent_gen<NumDims>& ranges) :
-    super_type((T*)initial_base_,ranges) {
+                       ::extent_gen<NumDims>& ranges,
+                       const Allocator& alloc = Allocator()) :
+    super_type((T*)initial_base_,ranges),
+    alloc_base(boost::empty_init_t(),alloc) {
 
     allocate_space();
   }
@@ -190,7 +209,8 @@ 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) {
+    super_type((T*)initial_base_,ranges,so),
+    alloc_base(boost::empty_init_t()) {
 
     allocate_space();
   }
@@ -200,13 +220,15 @@ public:
                        ::extent_gen<NumDims>& ranges,
                        const general_storage_order<NumDims>& so,
                        Allocator const& alloc) :
-    super_type((T*)initial_base_,ranges,so), allocator_(alloc) {
+    super_type((T*)initial_base_,ranges,so),
+    alloc_base(boost::empty_init_t(),alloc) {
 
     allocate_space();
   }
 
   multi_array(const multi_array& rhs) :
-  super_type(rhs), allocator_(rhs.allocator_) {
+  super_type(rhs),
+  alloc_base(static_cast<const alloc_base&>(rhs)) {
     allocate_space();
     boost::detail::multi_array::copy_n(rhs.base_,rhs.num_elements(),base_);
   }
@@ -223,8 +245,10 @@ 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())
-    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
+              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)
   {
     allocate_space();
     // Warning! storage order may change, hence the following copy technique.
@@ -234,8 +258,10 @@ 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())
-    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
+              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)
   {
     allocate_space();
     std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -245,8 +271,10 @@ 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())
-    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
+              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)
   {
     allocate_space();
     std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -256,8 +284,10 @@ public:
   // More limited support for MSVC
 
 
-  multi_array(const const_multi_array_ref<T,NumDims>& rhs)
-    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) 
+  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)
   {
     allocate_space();
     // Warning! storage order may change, hence the following copy technique.
@@ -265,8 +295,10 @@ public:
   }
 
   multi_array(const const_multi_array_ref<T,NumDims>& rhs,
-              const general_storage_order<NumDims>& so)
-    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
+              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)
   {
     allocate_space();
     // Warning! storage order may change, hence the following copy technique.
@@ -274,8 +306,10 @@ public:
   }
 
   multi_array(const detail::multi_array::
-              const_sub_array<T,NumDims>& rhs)
-    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) 
+              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)
   {
     allocate_space();
     std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -283,8 +317,10 @@ public:
 
   multi_array(const detail::multi_array::
               const_sub_array<T,NumDims>& rhs,
-              const general_storage_order<NumDims>& so)
-    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
+              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)
   {
     allocate_space();
     std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -292,8 +328,10 @@ public:
 
 
   multi_array(const detail::multi_array::
-              const_multi_array_view<T,NumDims>& rhs)
-    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) 
+              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)
   {
     allocate_space();
     std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -301,8 +339,10 @@ public:
 
   multi_array(const detail::multi_array::
               const_multi_array_view<T,NumDims>& rhs,
-              const general_storage_order<NumDims>& so)
-    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
+              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)
   {
     allocate_space();
     std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -311,8 +351,10 @@ 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)
-    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) 
+  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)
   {
     allocate_space();
     // Warning! storage order may change, hence the following copy technique.
@@ -320,8 +362,10 @@ public:
   }
 
   multi_array(const multi_array_ref<T,NumDims>& rhs,
-              const general_storage_order<NumDims>& so)
-    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
+              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)
   {
     allocate_space();
     // Warning! storage order may change, hence the following copy technique.
@@ -330,8 +374,10 @@ public:
 
 
   multi_array(const detail::multi_array::
-              sub_array<T,NumDims>& rhs)
-    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) 
+              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)
   {
     allocate_space();
     std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -339,8 +385,10 @@ public:
 
   multi_array(const detail::multi_array::
               sub_array<T,NumDims>& rhs,
-              const general_storage_order<NumDims>& so)
-    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
+              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)
   {
     allocate_space();
     std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -348,8 +396,10 @@ public:
 
 
   multi_array(const detail::multi_array::
-              multi_array_view<T,NumDims>& rhs)
-    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) 
+              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)
   {
     allocate_space();
     std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -357,8 +407,10 @@ public:
     
   multi_array(const detail::multi_array::
               multi_array_view<T,NumDims>& rhs,
-              const general_storage_order<NumDims>& so)
-    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
+              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)
   {
     allocate_space();
     std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -403,7 +455,7 @@ public:
 
 
     // build a multi_array with the specs given
-    multi_array new_array(ranges,this->storage_order());
+    multi_array new_array(ranges,this->storage_order(),allocator());
 
 
     // build a view of tmp with the minimum extents
@@ -449,6 +501,7 @@ 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_);
@@ -456,7 +509,6 @@ 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_);
 
@@ -469,26 +521,43 @@ 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() {
-    typename Allocator::const_pointer no_hint=0;
-    base_ = allocator_.allocate(this->num_elements(),no_hint);
+    base_ = allocator().allocate(this->num_elements());
     this->set_base_ptr(base_);
     allocated_elements_ = this->num_elements();
-    std::uninitialized_fill_n(base_,allocated_elements_,T());
+    detail::multi_array::construct(allocator(),base_,base_+allocated_elements_);
   }
 
   void deallocate_space() {
     if(base_) {
-      for(T* i = base_; i != base_+allocated_elements_; ++i)
-        allocator_.destroy(i);
-      allocator_.deallocate(base_,allocated_elements_);
+      detail::multi_array::destroy(allocator(),base_,base_+allocated_elements_);
+      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};
@@ -496,4 +565,8 @@ 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

@@ -40,7 +40,7 @@
 //  See http://www.boost.org/libs/multi_array for documentation.
 
 
-#include "boost/iterator.hpp"
+#include <iterator>
 
 namespace boost {
 namespace detail {

include/boost/multi_array/allocators.hpp

@@ -0,0 +1,72 @@
+// 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

@@ -29,7 +29,6 @@
 #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"
@@ -65,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.
-#if !BOOST_MULTI_ARRAY_NO_GENERATORS
+#ifndef BOOST_MULTI_ARRAY_NO_GENERATORS
 namespace {
   multi_array_types::extent_gen extents;
   multi_array_types::index_gen indices;
@@ -81,7 +80,8 @@ 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>
+  template <typename T, typename TPtr, typename NumDims, typename Reference,
+            typename IteratorCategory>
 class array_iterator;
 
 template <typename T, std::size_t NumDims, typename TPtr = const T*>
@@ -209,49 +209,28 @@ struct value_accessor_generator {
   >::type type;
 };
 
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-
-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
@@ -259,13 +238,7 @@ struct associated_types
 template <typename T, std::size_t NumDims>
 class multi_array_impl_base
   :
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-      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:
@@ -301,8 +274,16 @@ public:
   //
   // iterator support
   //
-  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;
+#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 ::boost::reverse_iterator<iterator> reverse_iterator;
   typedef ::boost::reverse_iterator<const_iterator> const_reverse_iterator;
@@ -321,7 +302,8 @@ protected:
                            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)
@@ -332,9 +314,15 @@ protected:
 #endif
 
     index offset = 0;
-    for (size_type n = 0; n != NumDims; ++n) 
-      offset += indices[n] * strides[n];
-    
+    {
+      typename IndexList::const_iterator i = indices.begin();
+      size_type n = 0; 
+      while (n != NumDims) {
+        offset += (*i) * strides[n];
+        ++n;
+        ++i;
+      }
+    }
     return base[offset];
   }
 
@@ -431,22 +419,53 @@ 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 index_factor = current_range.stride();
+      index stride = current_range.stride();
+      BOOST_ASSERT(stride != 0);
 
-      // integral trick for ceiling((finish-start) / index_factor)
-      index shrinkage = index_factor > 0 ? 1 : -1;
-      index len = (finish - start + (index_factor - shrinkage)) / index_factor;
+      // 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]));
-      BOOST_ASSERT(index_bases[n] <= finish &&
-                   finish <= index_bases[n]+index(extents[n]));
-      BOOST_ASSERT(index_factor != 0);
+                   ((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
+
 
       // the array data pointer is modified to account for non-zero
       // bases during slicing (see [Garcia] for the math involved)
@@ -454,9 +473,9 @@ protected:
 
       if (!current_range.is_degenerate()) {
 
-        // The index_factor for each dimension is included into the
+        // The stride for each dimension is included into the
         // strides for the array_view (see [Garcia] for the math involved).
-        new_strides[dim] = index_factor * strides[n];
+        new_strides[dim] = stride * strides[n];
         
         // calculate new extents
         new_extents[dim] = len;

include/boost/multi_array/collection_concept.hpp

@@ -17,46 +17,10 @@
 
 namespace boost {
 namespace detail {
-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;
-  };
-
+namespace multi_array { // Old location for this
+  using boost::CollectionConcept;
 }
 }
+
 }
 #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 detail {
-namespace multi_array {
+namespace multi_array_concepts {
 
+namespace detail {
   //
   // idgen_helper -
   //   This is a helper for generating index_gen instantiations with
@@ -39,8 +39,6 @@ namespace multi_array {
 
     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);
     }
   };
@@ -50,12 +48,12 @@ namespace multi_array {
 
     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
@@ -70,10 +68,10 @@ namespace multi_array {
       // RG - a( CollectionArchetype) when available...
       a[ id ];
       // Test slicing, keeping only the first dimension, losing the rest
-      idgen_helper<NumDims-1>::call(a,idgen[range],id);
+      detail::idgen_helper<NumDims-1>::call(a,idgen[range],id);
 
       // Test slicing, keeping all dimensions.
-      idgen_helper<NumDims-1>::call(a,idgen[range],range);
+      detail::idgen_helper<NumDims-1>::call(a,idgen[range],range);
 
       st = a.size();
       st = a.num_dimensions();
@@ -129,15 +127,16 @@ namespace multi_array {
       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
-      idgen_helper<NumDims-1>::call(a,idgen[range],id);
+      detail::idgen_helper<NumDims-1>::call(a,idgen[range],id);
 
       // Test slicing, keeping all dimensions.
-      idgen_helper<NumDims-1>::call(a,idgen[range],range);
+      detail::idgen_helper<NumDims-1>::call(a,idgen[range],range);
 
       st = a.size();
       st = a.num_dimensions();
@@ -158,10 +157,10 @@ namespace multi_array {
       //      value_type vt = a[ id ];
 
       // Test slicing, keeping only the first dimension, losing the rest
-      idgen_helper<NumDims-1>::call(a,idgen[range],id);
+      detail::idgen_helper<NumDims-1>::call(a,idgen[range],id);
 
       // Test slicing, keeping all dimensions.
-      idgen_helper<NumDims-1>::call(a,idgen[range],range);
+      detail::idgen_helper<NumDims-1>::call(a,idgen[range],range);
 
       st = a.size();
       st = a.num_dimensions();
@@ -208,7 +207,14 @@ namespace multi_array {
 
 
 } // namespace multi_array
-} // namespace detail
+
+namespace detail {
+  namespace multi_array { // Old locations for these
+    using boost::multi_array_concepts::ConstMultiArrayConcept;
+    using boost::multi_array_concepts::MutableMultiArrayConcept;
+  }
+}
+
 } // namespace boost
 
 

include/boost/multi_array/index_range.hpp

@@ -107,6 +107,12 @@ namespace multi_array {
 
     index stride() const { return stride_; }
 
+    size_type size(index idx) const
+    {
+      return (start_ == from_start() || finish_ == to_end())
+        ? idx : ((finish_ - start_) / stride_);
+    }
+
     void set_index_range(index start, index finish, index stride=1)
     {
       start_ = start;

include/boost/multi_array/iterator.hpp

@@ -20,7 +20,6 @@
 
 #include "boost/multi_array/base.hpp"
 #include "boost/iterator/iterator_facade.hpp"
-#include "boost/mpl/aux_/msvc_eti_base.hpp"
 #include <algorithm>
 #include <cstddef>
 #include <iterator>
@@ -44,32 +43,28 @@ struct operator_arrow_proxy
   mutable T value_;
 };
 
-template <typename T, typename TPtr, typename NumDims, typename Reference>
+template <typename T, typename TPtr, typename NumDims, typename Reference,
+          typename IteratorCategory>
 class array_iterator;
 
-template <typename T, typename TPtr, typename NumDims, typename Reference>
+template <typename T, typename TPtr, typename NumDims, typename Reference,
+          typename IteratorCategory>
 class array_iterator
   : public
     iterator_facade<
-        array_iterator<T,TPtr,NumDims,Reference>
+        array_iterator<T,TPtr,NumDims,Reference,IteratorCategory>
       , typename associated_types<T,NumDims>::value_type
-      , boost::random_access_traversal_tag
+      , IteratorCategory
       , Reference
     >
     , private
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-      mpl::aux::msvc_eti_base<typename 
-#endif 
           value_accessor_generator<T,NumDims>::type
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-      >::type
-#endif 
 {
-  friend class iterator_core_access;
+  friend class ::boost::iterator_core_access;
   typedef detail::multi_array::associated_types<T,NumDims> access_t;
 
   typedef iterator_facade<
-        array_iterator<T,TPtr,NumDims,Reference>
+            array_iterator<T,TPtr,NumDims,Reference,IteratorCategory>
       , typename detail::multi_array::associated_types<T,NumDims>::value_type
       , boost::random_access_traversal_tag
       , Reference
@@ -79,7 +74,7 @@ class array_iterator
   typedef typename access_t::size_type size_type;
 
 #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-  template <typename, typename, typename, typename>
+  template <typename, typename, typename, typename, typename>
     friend class array_iterator;
 #else
  public:
@@ -105,9 +100,9 @@ public:
     idx_(idx), base_(base), extents_(extents),
     strides_(strides), index_base_(index_base) { }
 
-  template <typename OPtr, typename ORef>
+  template <typename OPtr, typename ORef, typename Cat>
   array_iterator(
-      const array_iterator<T,OPtr,NumDims,ORef>& rhs
+      const array_iterator<T,OPtr,NumDims,ORef,Cat>& rhs
     , typename boost::enable_if_convertible<OPtr,TPtr>::type* = 0
   )
     : idx_(rhs.idx_), base_(rhs.base_), extents_(rhs.extents_),

include/boost/multi_array/multi_array_ref.hpp

@@ -26,6 +26,7 @@
 #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"
@@ -89,7 +90,7 @@ public:
   explicit const_multi_array_ref(TPtr base, const ExtentList& extents) :
     base_(base), storage_(c_storage_order()) {
     boost::function_requires<
-      detail::multi_array::CollectionConcept<ExtentList> >();
+      CollectionConcept<ExtentList> >();
 
     index_base_list_.assign(0);
     init_multi_array_ref(extents.begin());
@@ -100,7 +101,7 @@ public:
                        const general_storage_order<NumDims>& so) : 
     base_(base), storage_(so) {
     boost::function_requires<
-      detail::multi_array::CollectionConcept<ExtentList> >();
+      CollectionConcept<ExtentList> >();
 
     index_base_list_.assign(0);
     init_multi_array_ref(extents.begin());
@@ -145,7 +146,7 @@ public:
 #endif // BOOST_NO_SFINAE
   reindex(const BaseList& values) {
     boost::function_requires<
-      detail::multi_array::CollectionConcept<BaseList> >();
+      CollectionConcept<BaseList> >();
     boost::detail::multi_array::
       copy_n(values.begin(),num_dimensions(),index_base_list_.begin());
     origin_offset_ =
@@ -163,7 +164,7 @@ public:
   template <typename SizeList>
   void reshape(const SizeList& extents) {
     boost::function_requires<
-      detail::multi_array::CollectionConcept<SizeList> >();
+      CollectionConcept<SizeList> >();
     BOOST_ASSERT(num_elements_ ==
                  std::accumulate(extents.begin(),extents.end(),
                                  size_type(1),std::multiplies<size_type>()));
@@ -210,7 +211,7 @@ public:
   template <typename IndexList>
   const element& operator()(IndexList indices) const {
     boost::function_requires<
-      detail::multi_array::CollectionConcept<IndexList> >();
+      CollectionConcept<IndexList> >();
     return super_type::access_element(boost::type<const element&>(),
                                       indices,origin(),
                                       shape(),strides(),index_bases());
@@ -224,11 +225,7 @@ 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)
@@ -448,7 +445,7 @@ public:
   explicit multi_array_ref(T* base, const ExtentList& extents) :
     super_type(base,extents) {
     boost::function_requires<
-      detail::multi_array::CollectionConcept<ExtentList> >();
+      CollectionConcept<ExtentList> >();
   }
 
   template <class ExtentList>
@@ -456,7 +453,7 @@ public:
                            const general_storage_order<NumDims>& so) :
     super_type(base,extents,so) {
     boost::function_requires<
-      detail::multi_array::CollectionConcept<ExtentList> >();
+      CollectionConcept<ExtentList> >();
   }
 
 
@@ -478,7 +475,7 @@ public:
   template <typename ConstMultiArray>
   multi_array_ref& operator=(const ConstMultiArray& other) {
     function_requires< 
-      detail::multi_array::
+      multi_array_concepts::
       ConstMultiArrayConcept<ConstMultiArray,NumDims> >();
 
     // make sure the dimensions agree
@@ -511,7 +508,7 @@ public:
   template <class IndexList>
   element& operator()(const IndexList& indices) {
     boost::function_requires<
-      detail::multi_array::CollectionConcept<IndexList> >();
+      CollectionConcept<IndexList> >();
     return super_type::access_element(boost::type<element&>(),
                                       indices,origin(),
                                       this->shape(),this->strides(),
@@ -528,11 +525,7 @@ 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) {
@@ -578,7 +571,7 @@ public:
   template <class IndexList>
   const element& operator()(const IndexList& indices) const {
     boost::function_requires<
-      detail::multi_array::CollectionConcept<IndexList> >();
+      CollectionConcept<IndexList> >();
     return super_type::operator()(indices);
   }
 
@@ -590,11 +583,7 @@ 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/subarray.hpp

@@ -80,18 +80,14 @@ public:
   template <typename IndexList>
   const element& operator()(const IndexList& indices) const {
     boost::function_requires<
-      detail::multi_array::CollectionConcept<IndexList> >();
+      CollectionConcept<IndexList> >();
     return super_type::access_element(boost::type<const element&>(),
                                       indices,origin(),
                                       shape(),strides(),index_bases());
   }
 
   // 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)
@@ -231,7 +227,7 @@ public:
   // Assignment from other ConstMultiArray types.
   template <typename ConstMultiArray>
   sub_array& operator=(const ConstMultiArray& other) {
-    function_requires< boost::detail::multi_array::ConstMultiArrayConcept< 
+    function_requires< boost::multi_array_concepts::ConstMultiArrayConcept< 
         ConstMultiArray, NumDims> >();
 
     // make sure the dimensions agree
@@ -267,11 +263,7 @@ 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) {
@@ -288,7 +280,7 @@ public:
   template <class IndexList>
   element& operator()(const IndexList& indices) {
     boost::function_requires<
-      detail::multi_array::CollectionConcept<IndexList> >();
+      CollectionConcept<IndexList> >();
     return super_type::access_element(boost::type<element&>(),
                                       indices,origin(),
                                       this->shape(),this->strides(),
@@ -323,7 +315,7 @@ public:
   template <class IndexList>
   const element& operator()(const IndexList& indices) const {
     boost::function_requires<
-      detail::multi_array::CollectionConcept<IndexList> >();
+      CollectionConcept<IndexList> >();
     return super_type::operator()(indices);
   }
 
@@ -332,11 +324,7 @@ 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/view.hpp

@@ -24,6 +24,7 @@
 #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>
@@ -81,7 +82,7 @@ public:
 #endif
   reindex(const BaseList& values) {
     boost::function_requires<
-      detail::multi_array::CollectionConcept<BaseList> >();
+      CollectionConcept<BaseList> >();
     boost::detail::multi_array::
       copy_n(values.begin(),num_dimensions(),index_base_list_.begin());
     origin_offset_ =
@@ -119,7 +120,7 @@ public:
   template <typename IndexList>
   const element& operator()(IndexList indices) const {
     boost::function_requires<
-      detail::multi_array::CollectionConcept<IndexList> >();
+      CollectionConcept<IndexList> >();
     return super_type::access_element(boost::type<const element&>(),
                                       indices,origin(),
                                       shape(),strides(),index_bases());
@@ -134,11 +135,7 @@ 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)
@@ -297,7 +294,7 @@ public:
   template <typename ConstMultiArray>
   multi_array_view& operator=(const ConstMultiArray& other) {
     function_requires< 
-      boost::detail::multi_array::
+      boost::multi_array_concepts::
       ConstMultiArrayConcept<ConstMultiArray,NumDims> >();
 
     // make sure the dimensions agree
@@ -328,7 +325,7 @@ public:
   template <class IndexList>
   element& operator()(const IndexList& indices) {
     boost::function_requires<
-      detail::multi_array::CollectionConcept<IndexList> >();
+      CollectionConcept<IndexList> >();
     return super_type::access_element(boost::type<element&>(),
                                       indices,origin(),
                                       this->shape(),this->strides(),
@@ -345,11 +342,7 @@ 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) {
@@ -392,7 +385,7 @@ public:
   template <class IndexList>
   const element& operator()(const IndexList& indices) const {
     boost::function_requires<
-      detail::multi_array::CollectionConcept<IndexList> >();
+      CollectionConcept<IndexList> >();
     return super_type::operator()(indices);
   }
 
@@ -401,11 +394,7 @@ 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)

meta/libraries.json

@@ -0,0 +1,15 @@
+{
+    "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.v2

@@ -4,46 +4,48 @@
 # "as is" without express or implied warranty, and with no claim as
 # to its suitability for any purpose.
 
-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 ]
+import testing ;
+
+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 ../../test/build//boost_test_exec_monitor ]
-      [ run access.cpp ../../test/build//boost_test_exec_monitor ]
-      [ run compare.cpp ../../test/build//boost_test_exec_monitor ]
-      [ run iterators.cpp ../../test/build//boost_test_exec_monitor ]
-      [ run slice.cpp ../../test/build//boost_test_exec_monitor ]
-      [ run assign.cpp ../../test/build//boost_test_exec_monitor ]
-      [ run assign_to_array.cpp ../../test/build//boost_test_exec_monitor ]
-      [ run index_bases.cpp ../../test/build//boost_test_exec_monitor ]
-      [ run storage_order_convert.cpp ../../test/build//boost_test_exec_monitor ]
-      [ run storage_order.cpp ../../test/build//boost_test_exec_monitor ]
-      [ run reshape.cpp ../../test/build//boost_test_exec_monitor ]
-      [ run range1.cpp ../../test/build//boost_test_exec_monitor  ]
-      [ run idxgen1.cpp ../../test/build//boost_test_exec_monitor ]
-      [ run stl_interaction.cpp ../../test/build//boost_test_exec_monitor ]
-      [ run resize.cpp ../../test/build//boost_test_exec_monitor ]
-      [ run assert.cpp ../../test/build//boost_test_exec_monitor ]
-      [ compile concept_checks.cpp ]
-    ;
+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_convert.cpp ;
+run storage_order.cpp ;
+run reshape.cpp ;
+run range1.cpp  ;
+run idxgen1.cpp ;
+run stl_interaction.cpp ;
+run resize.cpp ;
+run assert.cpp ;
+run reverse_view.cpp ;
+run allocators.cpp ;
+
+compile concept_checks.cpp ;

test/access.cpp

@@ -16,7 +16,7 @@
 //
 
 #include "generative_tests.hpp"
-#include "boost/static_assert.hpp"
+#include <boost/static_assert.hpp>
 
 template <typename Array>
 void access(Array& A, const mutable_array_tag&) {
@@ -42,8 +42,8 @@ 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()
@@ -52,12 +52,12 @@ void access(Array& A, const const_array_tag&) {
       for (index k2 = idx2; k2 != idx2+4; ++k2) {
         boost::array<index,ndims> indices;
         indices[0] = i2; indices[1] = j2; indices[2] = k2;
-        BOOST_CHECK(A(indices) == A[i2][j2][k2]);
-        BOOST_CHECK(CA(indices) == A(indices));
+        BOOST_TEST(A(indices) == A[i2][j2][k2]);
+        BOOST_TEST(CA(indices) == A(indices));
       }
   ++tests_run;
 }
 
-int test_main(int,char*[]) {
+int main() {
   return run_generative_tests();
 }

test/allocators.cpp

@@ -0,0 +1,151 @@
+// Copyright 2019 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)
+
+#include <boost/core/lightweight_test.hpp>
+#include <boost/multi_array.hpp>
+#include <algorithm>
+
+template<class T>
+class creator {
+public:
+  typedef T value_type;
+  typedef T* pointer;
+  typedef std::size_t size_type;
+  typedef std::ptrdiff_t difference_type;
+
+  template<class U>
+  struct rebind {
+    typedef creator<U> other;
+  };
+
+  creator(int state)
+    : state_(state) { }
+
+  template<class U>
+  creator(const creator<U>& other)
+    : state_(other.state()) { }
+
+  T* allocate(std::size_t size) {
+    return static_cast<T*>(::operator new(sizeof(T) * size));
+  }
+
+  void deallocate(T* ptr, std::size_t) {
+    ::operator delete(ptr);
+  }
+
+  int state() const {
+    return state_;
+  }
+
+private:
+  int state_;
+};
+
+template<class T, class U>
+inline bool
+operator==(const creator<T>& a, const creator<U>& b)
+{
+  return a.state() == b.state();
+}
+
+template<class T, class U>
+inline bool
+operator!=(const creator<T>& a, const creator<U>& b)
+{
+  return !(a == b);
+}
+
+void test(const double&, std::size_t*, int*, unsigned)
+{
+}
+
+template<class Array>
+void test(const Array& array, std::size_t* sizes, int* strides,
+    unsigned elements)
+{
+  BOOST_TEST(array.num_elements() == elements);
+  BOOST_TEST(array.size() == *sizes);
+  BOOST_TEST(std::equal(sizes, sizes + array.num_dimensions(), array.shape()));
+  BOOST_TEST(std::equal(strides, strides + array.num_dimensions(),
+    array.strides()));
+  test(array[0], ++sizes, ++strides, elements / array.size());
+}
+
+bool test(const double& a, const double& b)
+{
+  return a == b;
+}
+
+template<class A1, class A2>
+bool test(const A1& a1, const A2& a2)
+{
+  typename A1::const_iterator i1 = a1.begin();
+  typename A2::const_iterator i2 = a2.begin();
+  for (; i1 != a1.end(); ++i1, ++i2) {
+    if (!test(*i1, *i2)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+int main()
+{
+  typedef boost::multi_array<double, 3, creator<double> > type;
+  creator<double> state(1);
+  {
+    type array(state);
+  }
+  boost::array<type::size_type, 3> sizes = { { 3, 3, 3 } };
+  type::size_type elements = 27;
+  {
+    int strides[] = { 9, 3, 1 };
+    type array(sizes, state);
+    test(array, &sizes[0], strides, elements);
+  }
+  {
+    int strides[] = { 1, 3, 9 };
+    type array(sizes, boost::fortran_storage_order(), state);
+    test(array, &sizes[0], strides, elements);
+  }
+  {
+    int strides[] = { 9, 3, 1 };
+    type::extent_gen extents;
+    type array(extents[3][3][3], state);
+    test(array, &sizes[0], strides, elements);
+  }
+  {
+    type array1(sizes, state);
+    std::vector<double> values(elements, 4.5);
+    array1.assign(values.begin(), values.end());
+    type array2(array1);
+    int strides[] = { 9, 3, 1 };
+    test(array2, &sizes[0], strides, elements);
+    BOOST_TEST(test(array1, array2));
+  }
+  {
+    type array1(sizes, state);
+    type array2(sizes, state);
+    std::vector<double> values(elements, 4.5);
+    array1.assign(values.begin(), values.end());
+    array2 = array1;
+    int strides[] = { 9, 3, 1 };
+    test(array2, &sizes[0], strides, elements);
+    BOOST_TEST(test(array1, array2));
+  }
+  {
+    type array1(sizes, state);
+    std::vector<double> values(elements, 4.5);
+    array1.assign(values.begin(), values.end());
+    typedef type::subarray<2>::type other;
+    other array2 = array1[1];
+    other::value_type value = array2[0];
+    BOOST_TEST(test(array1[1][0], value));
+    BOOST_TEST(test(array2[0], value));
+  }
+  return boost::report_errors();
+}

test/assert.cpp

@@ -15,24 +15,32 @@
 // with exceptions
 //
 
-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>
 
 #define BOOST_ENABLE_ASSERT_HANDLER
-#include "boost/multi_array.hpp" // includes assert.hpp
+#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*[]) {
+main() {
 
   typedef multi_array<int,2> array_t;
 
@@ -47,5 +55,5 @@ test_main(int,char*[]) {
     //...all good
   }
 
-  return boost::exit_success;
+  return boost::report_errors();
 }

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,14 +10,14 @@
 //           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"
-#include "boost/multi_array.hpp"
-#include "boost/cstdlib.hpp"
+#include <boost/array.hpp>
+#include <boost/multi_array.hpp>
+#include <boost/cstdlib.hpp>
 #include <algorithm>
 #include <iostream>
 
@@ -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;
 }
 
@@ -68,6 +68,6 @@ void access(Array&, const const_array_tag&) {
 }
 
 
-int test_main(int,char*[]) {
+int main() {
   return run_generative_tests();
 }

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,15 +10,15 @@
 //           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"
-#include "boost/multi_array.hpp"
-#include "boost/cstdlib.hpp"
+#include <boost/array.hpp>
+#include <boost/multi_array.hpp>
+#include <boost/cstdlib.hpp>
 #include <algorithm>
 #include <iostream>
 
@@ -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,11 +50,11 @@ 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;
 }
 
 
-int test_main(int,char*[]) {
+int main() {
   return run_generative_tests();
 }

test/compare.cpp

@@ -12,16 +12,16 @@
 
 
 
-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>
 
-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>
 
 #include <algorithm>
 #include <list>
 
 
 int
-test_main(int, char*[])
+main()
 {
   typedef boost::multi_array<double, 3> array;
   typedef array::size_type size_type;
@@ -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,35 +108,35 @@ 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);
   }
 
 
 
-  return boost::exit_success;
+  return boost::report_errors();
 }
 
 

test/concept_checks.cpp

@@ -15,18 +15,18 @@
 //   make sure the types meet concept requirements
 //
 
-#include "boost/concept_check.hpp"
-#include "boost/multi_array/concept_checks.hpp"
-#include "boost/multi_array.hpp"
+#include <boost/concept_check.hpp>
+#include <boost/multi_array/concept_checks.hpp>
+#include <boost/multi_array.hpp>
 
-#include "boost/cstdlib.hpp"
+#include <boost/cstdlib.hpp>
 
-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>
 
-#include "boost/array.hpp"
+#include <boost/array.hpp>
 
 int
-test_main(int,char*[])
+main()
 {
   const int ndims=3;
   typedef boost::multi_array<int,ndims> array;
@@ -38,28 +38,28 @@ test_main(int,char*[])
   typedef array::const_subarray<ndims>::type const_subarray;
 
 boost::function_requires<
-  boost::detail::multi_array::ConstMultiArrayConcept<array,ndims> >();
+  boost::multi_array_concepts::ConstMultiArrayConcept<array,ndims> >();
 boost::function_requires<
-  boost::detail::multi_array::ConstMultiArrayConcept<array_ref,ndims> >();
+  boost::multi_array_concepts::ConstMultiArrayConcept<array_ref,ndims> >();
 boost::function_requires<
-  boost::detail::multi_array::ConstMultiArrayConcept<const_array_ref,ndims> >();
+  boost::multi_array_concepts::ConstMultiArrayConcept<const_array_ref,ndims> >();
 boost::function_requires<
-  boost::detail::multi_array::ConstMultiArrayConcept<array_view,ndims> >();
+  boost::multi_array_concepts::ConstMultiArrayConcept<array_view,ndims> >();
 boost::function_requires<
-  boost::detail::multi_array::ConstMultiArrayConcept<const_array_view,ndims> >();
+  boost::multi_array_concepts::ConstMultiArrayConcept<const_array_view,ndims> >();
 boost::function_requires<
-  boost::detail::multi_array::ConstMultiArrayConcept<subarray,ndims> >();
+  boost::multi_array_concepts::ConstMultiArrayConcept<subarray,ndims> >();
 boost::function_requires<
-  boost::detail::multi_array::ConstMultiArrayConcept<const_subarray,ndims> >();
+  boost::multi_array_concepts::ConstMultiArrayConcept<const_subarray,ndims> >();
 
 boost::function_requires<
-  boost::detail::multi_array::MutableMultiArrayConcept<array,ndims> >();
+  boost::multi_array_concepts::MutableMultiArrayConcept<array,ndims> >();
 boost::function_requires<
-  boost::detail::multi_array::MutableMultiArrayConcept<array_ref,ndims> >();
+  boost::multi_array_concepts::MutableMultiArrayConcept<array_ref,ndims> >();
 boost::function_requires<
-  boost::detail::multi_array::MutableMultiArrayConcept<array_view,ndims> >();
+  boost::multi_array_concepts::MutableMultiArrayConcept<array_view,ndims> >();
 boost::function_requires<
-  boost::detail::multi_array::MutableMultiArrayConcept<subarray,ndims> >();
+  boost::multi_array_concepts::MutableMultiArrayConcept<subarray,ndims> >();
 
   return 0;
 }

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)
 
@@ -15,9 +15,9 @@
 //
 
 
-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>
 
-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>
 #include <algorithm>
 #include <list>
 
@@ -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,14 +49,14 @@ 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;
 }
 
 
 int
-test_main(int, char*[])
+main()
 {
   typedef boost::multi_array<double, 3>::size_type size_type;
   boost::array<size_type,3> sizes = { { 3, 3, 3 } };
@@ -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,10 +209,10 @@ 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;
+  return boost::report_errors();
 }
 
 

test/dimtest.cpp

@@ -13,9 +13,9 @@
 //
 // Trying to diagnose problems under visual
 
-#include "boost/config.hpp"
-#include "boost/array.hpp"
-#include "boost/limits.hpp"
+#include <boost/config.hpp>
+#include <boost/array.hpp>
+#include <boost/limits.hpp>
 #include <algorithm>
 #include <utility>
 

test/fail_cbracket.cpp

@@ -15,14 +15,14 @@
 //   checking constness of  const operator[].
 //
 
-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>
 
-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>
 
-#include "boost/array.hpp"
+#include <boost/array.hpp>
 
 int
-test_main(int,char*[])
+main()
 {
   const int ndims=3;
   typedef boost::multi_array<int,ndims> array;
@@ -36,5 +36,5 @@ test_main(int,char*[])
   // FAIL! cannot assign to csma.
   csma[0][0][0] = 5;
 
-  return boost::exit_success;
+  return boost::report_errors();
 }

test/fail_cdata.cpp

@@ -15,14 +15,14 @@
 //   Testing data() member function constness.
 //
 
-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>
 
-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>
 
-#include "boost/array.hpp"
+#include <boost/array.hpp>
 
 int
-test_main(int,char*[])
+main()
 {
   const int ndims=3;
   typedef boost::multi_array<int,ndims> array;
@@ -37,5 +37,5 @@ test_main(int,char*[])
 
   // FAIL! data() returns a const int*
   *csma.data() = 0;
-  return boost::exit_success;
+  return boost::report_errors();
 }

test/fail_citerator.cpp

@@ -15,12 +15,12 @@
 //   const_iterator/iterator conversion  test
 //
 
-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>
 
-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>
 
 
-int test_main(int,char*[]) {
+int main() {
   typedef boost::multi_array<int,3> array;
 
   typedef array::iterator iterator1;
@@ -29,5 +29,5 @@ int test_main(int,char*[]) {
   // ILLEGAL conversion from const_iterator to iterator
   iterator1 in = citerator1();
 
-  return boost::exit_success;
+  return boost::report_errors();
 }

test/fail_cparen.cpp

@@ -15,14 +15,14 @@
 //   Testing const operator() constness.
 //
 
-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>
 
-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>
 
-#include "boost/array.hpp"
+#include <boost/array.hpp>
 
 int
-test_main(int,char*[])
+main()
 {
   const int ndims=3;
   typedef boost::multi_array<int,ndims> array;
@@ -40,5 +40,5 @@ test_main(int,char*[])
   // FAIL! Cannot assign to csma
   csma(indices) = 5;
 
-  return boost::exit_success;
+  return boost::report_errors();
 }

test/fail_criterator.cpp

@@ -15,12 +15,12 @@
 //   const_reverse_iterator/reverse_iterator conversion  test
 //
 
-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>
 
-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>
 
 
-int test_main(int,char*[]) {
+int main() {
     typedef boost::multi_array<int,3> array;
 
     typedef array::reverse_iterator riterator1;
@@ -29,5 +29,5 @@ int test_main(int,char*[]) {
     // ILLEGAL conversion from const_reverse_iterator to reverse_iterator
     riterator1 in = criterator1();
 
-    return boost::exit_success;
+    return boost::report_errors();
 }

test/fail_csubarray.cpp

@@ -15,14 +15,14 @@
 //   Testing subarray and const_subarray assignment 
 //
 
-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>
 
-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>
 
-#include "boost/array.hpp"
+#include <boost/array.hpp>
 
 int
-test_main(int,char*[])
+main()
 {
   const int ndims=3;
   typedef boost::multi_array<int,ndims> array;
@@ -42,5 +42,5 @@ test_main(int,char*[])
   // FAIL! Preserve constness (no const_subarray -> subarray conversion).
   array::subarray<ndims-1>::type sba = csba;
 
-  return boost::exit_success;
+  return boost::report_errors();
 }

test/fail_csubarray2.cpp

@@ -15,14 +15,14 @@
 //   Testing constness of subarray operations.
 //
 
-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>
 
-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>
 
-#include "boost/array.hpp"
+#include <boost/array.hpp>
 
 int
-test_main(int,char*[])
+main()
 {
   const int ndims=3;
   typedef boost::multi_array<int,ndims> array;
@@ -41,5 +41,5 @@ test_main(int,char*[])
   // FAIL! preserve constness.
   array::subarray<ndims-1>::type sba = sma_const[0];
 
-  return boost::exit_success;
+  return boost::report_errors();
 }

test/fail_csubarray3.cpp

@@ -15,14 +15,14 @@
 //  Testing constness of subarray operations.
 //
 
-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>
 
-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>
 
-#include "boost/array.hpp"
+#include <boost/array.hpp>
 
 int
-test_main(int,char*[])
+main()
 {
   const int ndims=3;
   typedef boost::multi_array<int,ndims> array;
@@ -45,5 +45,5 @@ test_main(int,char*[])
         // FAIL! sba cannot be assigned to.
         sba[j][k] = num++;
 
-  return boost::exit_success;
+  return boost::report_errors();
 }

test/fail_cview.cpp

@@ -15,15 +15,15 @@
 //   ensure const_array_view doesn't allow element assignment.
 //
 
-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>
 
-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>
 
-#include "boost/array.hpp"
-#include "boost/type.hpp"
+#include <boost/array.hpp>
+#include <boost/type.hpp>
 
 int
-test_main(int,char*[])
+main()
 {
   const int ndims=3;
   typedef boost::multi_array<int,ndims> array;
@@ -54,7 +54,7 @@ test_main(int,char*[])
   // FAIL! const_array_view cannot be assigned to.
   csma2(elmt) = 5;
   
-  return boost::exit_success;
+  return boost::report_errors();
 }
 
 

test/fail_cview2.cpp

@@ -15,16 +15,17 @@
 //   ensure const_array_view cannot be converted to array_view
 //
 
-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>
 
 #define BOOST_INCLUDE_MAIN
-#include "boost/test/test_tools.hpp"
+#include <boost/test/test_tools.hpp>
 
-#include "boost/array.hpp"
-#include "boost/type.hpp"
+#include <boost/array.hpp>
+#include <boost/type.hpp>
+#include <boost/cstdlib.hpp>
 
 int
-test_main(int,char*[])
+main()
 {
   const int ndims=3;
   typedef boost::multi_array<int,ndims> array;
@@ -51,7 +52,7 @@ test_main(int,char*[])
   array::array_view<ndims>::type csma2 =
     csma[indices[range(0,2)][range(1,3)][range(0,4,2)]];
 
-  return boost::exit_success;
+  return boost::report_errors();
 }
 
 

test/fail_cview3.cpp

@@ -15,15 +15,15 @@
 //   ensure const_array_ref doesn't allow assignment.
 //
 
-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>
 
-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>
 
-#include "boost/array.hpp"
-#include "boost/type.hpp"
+#include <boost/array.hpp>
+#include <boost/type.hpp>
 
 int
-test_main(int,char*[])
+main()
 {
   const int ndims=3;
   typedef boost::multi_array<int,ndims> array;
@@ -55,7 +55,7 @@ test_main(int,char*[])
         // FAIL! csma2 cannot be assigned to.
         csma2[i][j][k] = 0;
   
-  return boost::exit_success;
+  return boost::report_errors();
 }
 
 

test/fail_ref_cbracket.cpp

@@ -15,14 +15,14 @@
 //   checking constness of  const operator[].
 //
 
-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>
 
-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>
 
-#include "boost/array.hpp"
+#include <boost/array.hpp>
 
 int
-test_main(int,char*[])
+main()
 {
   const int ndims=3;
   typedef boost::multi_array_ref<int,ndims> array_ref;
@@ -40,5 +40,5 @@ test_main(int,char*[])
   // FAIL! can't assign to const multi_array_ref.
   csma[0][0][0] = 5;
 
-  return boost::exit_success;
+  return boost::report_errors();
 }

test/fail_ref_cdata.cpp

@@ -15,14 +15,14 @@
 //   Testing data() member function constness.
 //
 
-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>
 
-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>
 
-#include "boost/array.hpp"
+#include <boost/array.hpp>
 
 int
-test_main(int,char*[])
+main()
 {
   const int ndims=3;
   typedef boost::multi_array_ref<int,ndims> array_ref;
@@ -36,5 +36,5 @@ test_main(int,char*[])
 
   // FAIL! data() returns const int*.
   *csma.data() = 0;
-  return boost::exit_success;
+  return boost::report_errors();
 }

test/fail_ref_citerator.cpp

@@ -15,12 +15,12 @@
 //   const_iterator/iterator conversion  test
 //
 
-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>
 
-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>
 
 
-int test_main(int,char*[]) {
+int main() {
   typedef boost::multi_array_ref<int,3> array_ref;
 
   typedef array_ref::iterator iterator1;
@@ -29,5 +29,5 @@ int test_main(int,char*[]) {
   // FAIL! ILLEGAL conversion from const_iterator to iterator
   iterator1 in = citerator1();
 
-  return boost::exit_success;
+  return boost::report_errors();
 }

test/fail_ref_cparen.cpp

@@ -15,14 +15,14 @@
 //   Testing const operator() constness. 
 //
 
-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>
 
-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>
 
-#include "boost/array.hpp"
+#include <boost/array.hpp>
 
 int
-test_main(int,char*[])
+main()
 {
   const int ndims=3;
   typedef boost::multi_array_ref<int,ndims> array_ref;
@@ -40,5 +40,5 @@ test_main(int,char*[])
   // FAIL! cannot assign to a const multi_array_ref
   csma(indices) = 5;
 
-  return boost::exit_success;
+  return boost::report_errors();
 }

test/fail_ref_criterator.cpp

@@ -15,12 +15,12 @@
 //   const_reverse_iterator/reverse_iterator conversion  test
 //
 
-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>
 
-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>
 
 
-int test_main(int,char*[]) {
+int main() {
     typedef boost::multi_array_ref<int,3> array_ref;
 
     typedef array_ref::reverse_iterator riterator1;
@@ -29,5 +29,5 @@ int test_main(int,char*[]) {
     // Fail! ILLEGAL conversion from const_reverse_iterator to reverse_iterator
     riterator1 in = criterator1();
 
-    return boost::exit_success;
+    return boost::report_errors();
 }

test/fail_ref_csubarray.cpp

@@ -15,14 +15,14 @@
 //   Testing subarray and const_subarray assignment 
 //
 
-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>
 
-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>
 
-#include "boost/array.hpp"
+#include <boost/array.hpp>
 
 int
-test_main(int,char*[])
+main()
 {
   const int ndims=3;
   typedef boost::multi_array_ref<int,ndims> array_ref;
@@ -44,5 +44,5 @@ test_main(int,char*[])
 
   array_ref::subarray<ndims-1>::type sba = csba; // FAIL! preserve constness.
 
-  return boost::exit_success;
+  return boost::report_errors();
 }

test/fail_ref_csubarray2.cpp

@@ -15,14 +15,14 @@
 //   Testing constness of subarray operations.
 //
 
-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>
 
-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>
 
-#include "boost/array.hpp"
+#include <boost/array.hpp>
 
 int
-test_main(int,char*[])
+main()
 {
   const int ndims=3;
   typedef boost::multi_array_ref<int,ndims> array_ref;
@@ -45,5 +45,5 @@ test_main(int,char*[])
   array_ref::subarray<ndims-1>::type sba = sma_const[0]; // FAIL!
                                                          // preserve constness
 
-  return boost::exit_success;
+  return boost::report_errors();
 }

test/fail_ref_csubarray3.cpp

@@ -15,14 +15,14 @@
 //   Testing constness of subarray operations.
 //
 
-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>
 
-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>
 
-#include "boost/array.hpp"
+#include <boost/array.hpp>
 
 int
-test_main(int,char*[])
+main()
 {
   const int ndims=3;
   typedef boost::multi_array_ref<int,ndims> array_ref;
@@ -48,5 +48,5 @@ test_main(int,char*[])
       for (array_ref::index k = 0; k != 4; ++k)
         sba[j][k] = num++; // FAIL! can't assign to const_subarray.
 
-  return boost::exit_success;
+  return boost::report_errors();
 }

test/fail_ref_cview.cpp

@@ -15,15 +15,15 @@
 //   ensure const_array_view doesn't allow element assignment.
 //
 
-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>
 
-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>
 
-#include "boost/array.hpp"
-#include "boost/type.hpp"
+#include <boost/array.hpp>
+#include <boost/type.hpp>
 
 int
-test_main(int,char*[])
+main()
 {
   const int ndims=3;
   typedef boost::multi_array_ref<int,ndims> array_ref;
@@ -51,7 +51,7 @@ test_main(int,char*[])
 
   csma2(elmt) = 5; // FAIL! csma is read only
   
-  return boost::exit_success;
+  return boost::report_errors();
 }
 
 

test/fail_ref_cview2.cpp

@@ -15,15 +15,15 @@
 //   ensure const_array_view cannot be converted to array_view
 //
 
-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>
 
-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>
 
-#include "boost/array.hpp"
-#include "boost/type.hpp"
+#include <boost/array.hpp>
+#include <boost/type.hpp>
 
 int
-test_main(int,char*[])
+main()
 {
   const int ndims=3;
   typedef boost::multi_array_ref<int,ndims> array_ref;
@@ -52,7 +52,7 @@ test_main(int,char*[])
       for (array_ref::index k = 0; k != 2; ++k)
         csma2[i][j][k] = 0; // FAIL! csma2 is read only
   
-  return boost::exit_success;
+  return boost::report_errors();
 }
 
 

test/fail_ref_cview3.cpp

@@ -15,15 +15,15 @@
 //   ensure const_array_view doesn't allow assignment.
 //
 
-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>
 
-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>
 
-#include "boost/array.hpp"
-#include "boost/type.hpp"
+#include <boost/array.hpp>
+#include <boost/type.hpp>
 
 int
-test_main(int,char*[])
+main()
 {
   const int ndims=3;
   typedef boost::multi_array_ref<int,ndims> array_ref;
@@ -53,7 +53,7 @@ test_main(int,char*[])
       for (array_ref::index k = 0; k != 2; ++k)
         csma2[i][j][k] = 0; // FAIL! csma2 is read only.
   
-  return boost::exit_success;
+  return boost::report_errors();
 }
 
 

test/generative_tests.hpp

@@ -45,9 +45,9 @@
 //
 //  int test_main(int,char*[]) { return run_generative_tests(); }
 //
-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>
 
-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>
 
 #include <boost/config.hpp> /* BOOST_NO_SFINAE */
 #include <algorithm>
@@ -100,7 +100,7 @@ template <typename Array>
 void access(Array& A, const const_array_tag&);
 
 template <typename StorageOrder3,typename StorageOrder4,typename Modifier>
-int run_configuration(const StorageOrder3& so3,
+void run_configuration(const StorageOrder3& so3,
                       const StorageOrder4& so4,
                       const Modifier& modifier) {
   // multi_array
@@ -213,11 +213,10 @@ int run_configuration(const StorageOrder3& so3,
       access(C,const_array_tag());
     }
   }
-  return boost::exit_success;
 }
 
 template <typename ArrayModifier>
-int run_storage_tests(const ArrayModifier& modifier) {
+void run_storage_tests(const ArrayModifier& modifier) {
   run_configuration(boost::c_storage_order(),
                     boost::c_storage_order(),modifier);
   run_configuration(boost::fortran_storage_order(),
@@ -228,8 +227,6 @@ int run_storage_tests(const ArrayModifier& modifier) {
   run_configuration(boost::general_storage_order<3>(ordering,ascending),
                     boost::general_storage_order<4>(ordering,ascending),
                     modifier); 
-
-  return boost::exit_success;
 }
 
 struct null_modifier {
@@ -279,7 +276,7 @@ int run_generative_tests() {
   run_storage_tests(reindex_modifier());
   run_storage_tests(reshape_modifier());
   std::cout << "Total Tests Run: " << tests_run << '\n';
-  return boost::exit_success;
+  return boost::report_errors();
 }
 
 #endif // GENERATIVE_TESTS_RG072001_HPP

test/idxgen1.cpp

@@ -14,12 +14,12 @@
 // idxset1.cpp - testing the code for index_gen
 //
 
-#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/multi_array/index_gen.hpp>
+#include <boost/multi_array/index_range.hpp>
+#include <boost/multi_array/types.hpp>
+#include <boost/core/lightweight_test.hpp>
 
-#include "boost/array.hpp"
+#include <boost/array.hpp>
 
 typedef boost::detail::multi_array::index index_type;
 typedef boost::detail::multi_array::size_type size_type;
@@ -37,7 +37,7 @@ bool operator==(const range& lhs,const range& rhs) {
 }
 
 int
-test_main(int,char*[])
+main()
 {
 
   boost::detail::multi_array::index_gen<0,0> indices;
@@ -62,20 +62,20 @@ 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;
+  return boost::report_errors();
 }
 

test/index_bases.cpp

@@ -14,15 +14,15 @@
 // index_bases - test of the index_base modifying facilities.
 //
 
-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>
 
-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>
 
-#include "boost/array.hpp"
+#include <boost/array.hpp>
 #include <vector>
 #include <iostream>
 int
-test_main(int,char*[])
+main()
 {
   typedef boost::multi_array<double, 3> array;
   typedef boost::multi_array_ref<double, 3> array_ref;
@@ -63,11 +63,11 @@ 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_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]);
         }
   }
 
@@ -142,12 +142,12 @@ 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+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]);
         }
   }
 
-  return boost::exit_success;
+  return boost::report_errors();
 }

test/iterators.cpp

@@ -17,9 +17,9 @@
 
 #define MULTIARRAY_TEST_ASSIGN
 #include "generative_tests.hpp"
-#include "boost/concept_check.hpp" // for ignore_unused_variable_warning
-#include "boost/mpl/if.hpp"
-#include "boost/type_traits/is_same.hpp"
+#include <boost/concept_check.hpp> // for ignore_unused_variable_warning
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_same.hpp>
 
 // iterator-test-specific code
 
@@ -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;
 }
@@ -182,7 +182,7 @@ void access(Array& A, const const_array_tag&) {
 
 
 int
-test_main(int, char*[])
+main()
 {
   return run_generative_tests();
 }

test/range1.cpp

@@ -15,91 +15,100 @@
 //
 
 
-#include "boost/multi_array/index_range.hpp"
+#include <boost/multi_array/index_range.hpp>
 
-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>
 
-#include "boost/array.hpp"
+#include <boost/array.hpp>
 #include <cstddef>
 
 int
-test_main(int,char*[])
+main()
 {
   typedef boost::detail::multi_array::index_range<int,std::size_t> range;
 
   {
     // 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.size(0) == 8);
+    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.size(0) == 4);
+    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() == 6);
+    BOOST_TEST(r3.stride() == 1);
+    BOOST_TEST(r3.size(0) == 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);
+    BOOST_TEST(r4.size(0) == 0);
   }
 
   {
     // 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);
+    BOOST_TEST(r5.size(0) == 5);
   }
 
   // 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);
+    BOOST_TEST(r6.size(0) == 5);
   }
 
   {
     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);
+    BOOST_TEST(r7.size(0) == 10);
   }
 
   // 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);
+    BOOST_TEST(r8.size(0) == 5);
   }
 
   {
     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);
+    BOOST_TEST(r9.size(0) == 5);
   }
 
-  return boost::exit_success;
+  return boost::report_errors();
 }

test/reshape.cpp

@@ -14,15 +14,15 @@
 // reshape.cpp - testing reshaping functionality
 //
 
-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>
 
-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>
 
-#include "boost/array.hpp"
-#include "boost/type.hpp"
+#include <boost/array.hpp>
+#include <boost/type.hpp>
 
 int
-test_main(int,char*[])
+main()
 {
   const int ndims=3;
   typedef boost::multi_array<int,ndims> array;
@@ -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,13 +80,13 @@ 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++);
         }
   }
   
-  return boost::exit_success;
+  return boost::report_errors();
 }
 
 

test/resize.cpp

@@ -14,13 +14,13 @@
 // resize.cpp - Test of resizing multi_arrays
 //
 
-#include "boost/test/minimal.hpp"
-#include "boost/multi_array.hpp"
+#include <boost/core/lightweight_test.hpp>
+#include <boost/multi_array.hpp>
 #include <iostream>
 using namespace std;
 
 
-int test_main(int,char*[]) {
+int main() {
 
   typedef boost::multi_array<int,3> marray;
 
@@ -58,7 +58,7 @@ int test_main(int,char*[]) {
     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
@@ -67,14 +67,14 @@ int test_main(int,char*[]) {
     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()));
+    BOOST_TEST(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);
   }
 
@@ -107,7 +107,7 @@ int test_main(int,char*[]) {
     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);
+          BOOST_TEST(*(A.data() + check) == check);
           ++check;
         }
       }
@@ -123,5 +123,5 @@ int test_main(int,char*[]) {
   }
 
 
-  return boost::exit_success;
+  return boost::report_errors();
 }

test/reverse_view.cpp

@@ -0,0 +1,43 @@
+// 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/core/lightweight_test.hpp>
+#include <boost/array.hpp>
+
+int
+main()
+{
+  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_TEST(B[i] == rdata[i]);
+  }
+  
+  return boost::report_errors();
+}

test/slice.cpp

@@ -15,9 +15,9 @@
 //
 
 #include "generative_tests.hpp"
-#include "boost/array.hpp"
-#include "boost/mpl/if.hpp"
-#include "boost/type_traits/is_same.hpp"
+#include <boost/array.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_same.hpp>
 
 template <typename Array>
 struct view_traits_mutable {
@@ -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,10 +84,10 @@ 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]);
       }
   }
 
@@ -105,10 +105,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][idx2+2-k]);
+        BOOST_TEST(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]);
+        BOOST_TEST(B(elmts) == A[idx0+i][idx1+j][idx2+2-k]);
       }
   }
 
@@ -141,6 +141,6 @@ void access(Array& A, const const_array_tag&) {
 }
 
 
-int test_main(int,char*[]) {
+int main() {
   return run_generative_tests();
 }

test/stl_interaction.cpp

@@ -14,14 +14,14 @@
 // stl_interaction.cpp - Make sure multi_arrays work with STL containers.
 //
 
-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>
 
-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>
 #include <algorithm>
 #include <vector>
 
 int
-test_main(int, char*[])
+main()
 {
   using boost::extents;
   using boost::indices;
@@ -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;
+  return boost::report_errors();
 }

test/storage_order.cpp

@@ -14,14 +14,14 @@
 // storage_order.cpp - testing storage_order-isms.
 //
 
-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>
 
-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>
  
-#include "boost/array.hpp"
+#include <boost/array.hpp>
 
 int
-test_main(int,char*[])
+main()
 {
   const int ndims=3;
   
@@ -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,8 +152,8 @@ 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;
+  return boost::report_errors();
 }

test/storage_order_convert.cpp

@@ -14,12 +14,12 @@
 // test out my new storage_order stuff
 //
 
-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>
 
-#include "boost/multi_array/storage_order.hpp"
+#include <boost/multi_array/storage_order.hpp>
 
 int 
-test_main(int,char*[]) {
+main() {
 
   using namespace boost;
 
@@ -31,9 +31,9 @@ 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;
+  return boost::report_errors();
 }

test/vc_death.cpp

@@ -14,15 +14,15 @@
 // index_bases - test of the index_base modifying facilities.
 //
 
-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>
 
-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>
 
-#include "boost/array.hpp"
+#include <boost/array.hpp>
 #include <vector>
 #include <iostream>
 int
-test_main(int,char*[])
+main()
 {
   typedef boost::multi_array<double, 3> array;
   typedef array::array_view<3>::type array_view;
@@ -40,5 +40,5 @@ test_main(int,char*[])
     array_view E = A[indices[irange(1,2)][irange(1,2)][irange(1,2)]];
 
   }
-  return boost::exit_success;
+  return boost::report_errors();
 }