Release 1.52.0

[SVN r81201]
2026-01-25 18:32:13 +00:00 · 2012-11-05 15:31:58 +00:00
18 changed files with 159 additions and 1378 deletions
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,234 +0,0 @@
-# Copyright 2018 Peter Dimov
-# Distributed under the Boost Software License, Version 1.0.
-
-language: cpp
-
-sudo: false
-
-python: "2.7"
-
-branches:
-  only:
-    - master
-    - develop
-
-env:
-  matrix:
-    - BOGUS_JOB=true
-
-matrix:
-
-  exclude:
-    - env: BOGUS_JOB=true
-
-  include:
-    - os: linux
-      compiler: g++
-      env: TOOLSET=gcc COMPILER=g++ CXXSTD=03,11
-
-    - os: linux
-      compiler: g++-4.4
-      env: TOOLSET=gcc COMPILER=g++-4.4 CXXSTD=98,0x
-      addons:
-        apt:
-          packages:
-            - g++-4.4
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-4.6
-      env: TOOLSET=gcc COMPILER=g++-4.6 CXXSTD=03,0x
-      addons:
-        apt:
-          packages:
-            - g++-4.6
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-4.7
-      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=03,11
-      addons:
-        apt:
-          packages:
-            - g++-4.7
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-4.8
-      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=03,11
-      addons:
-        apt:
-          packages:
-            - g++-4.8
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-4.9
-      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=03,11
-      addons:
-        apt:
-          packages:
-            - g++-4.9
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-5
-      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - g++-5
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-6
-      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - g++-6
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      dist: trusty
-      compiler: g++-7
-      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11,14,17
-      addons:
-        apt:
-          packages:
-            - g++-7
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-8
-      env: TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11,14,17
-      addons:
-        apt:
-          packages:
-            - g++-8
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11
-
-    - os: linux
-      compiler: clang++-3.5
-      env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.5
-            - libstdc++-4.9-dev
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-3.6
-      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.6
-            - libstdc++-4.9-dev
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-3.8
-      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.8
-            - libstdc++-4.9-dev
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-3.9
-      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.9
-            - libstdc++-4.9-dev
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-4.0
-      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-4.0
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-4.0
-
-    - os: linux
-      compiler: clang++-5.0
-      env: TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-5.0
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-5.0
-
-    - os: linux
-      compiler: clang++-6.0
-      env: TOOLSET=clang COMPILER=clang++-6.0 CXXSTD=03,11,14,17
-      addons:
-        apt:
-          packages:
-            - clang-6.0
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-6.0
-
-    - os: linux
-      compiler: clang++-libc++
-      env: TOOLSET=clang COMPILER=clang++-libc++ CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - libc++-dev
-
-    - os: osx
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
-
-install:
-  - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
-  - cd ..
-  - git clone -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost
-  - cd boost
-  - git submodule update --init tools/build
-  - git submodule update --init libs/config
-  - git submodule update --init tools/boostdep
-  - mkdir -p libs/multi_array
-  - cp -r $TRAVIS_BUILD_DIR/* libs/multi_array
-  - python tools/boostdep/depinst/depinst.py multi_array
-  - ./bootstrap.sh
-  - ./b2 headers
-
-script:
-  - |-
-    echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
-  - ./b2 -j 3 libs/multi_array/test toolset=$TOOLSET cxxstd=$CXXSTD
-
-notifications:
-  email:
-    on_success: always
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -1,48 +0,0 @@
-# Copyright 2018 Peter Dimov
-# Distributed under the Boost Software License, Version 1.0.
-
-version: 1.0.{build}-{branch}
-
-shallow_clone: true
-
-branches:
-  only:
-    - master
-    - develop
-
-environment:
-  matrix:
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-      TOOLSET: msvc-9.0
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-      TOOLSET: msvc-10.0
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-      TOOLSET: msvc-11.0
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-      TOOLSET: msvc-12.0
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      TOOLSET: msvc-14.0
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      TOOLSET: msvc-14.1
-      CXXSTD: 14,17
-
-install:
-  - set BOOST_BRANCH=develop
-  - if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master
-  - cd ..
-  - git clone -b %BOOST_BRANCH% https://github.com/boostorg/boost.git boost
-  - cd boost
-  - git submodule update --init tools/build
-  - git submodule update --init libs/config
-  - git submodule update --init tools/boostdep
-  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\multi_array\
-  - python tools/boostdep/depinst/depinst.py multi_array
-  - cmd /c bootstrap
-  - b2 headers
-
-build: off
-
-test_script:
-  - PATH=%ADDPATH%%PATH%
-  - if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
-  - b2 -j 3 libs/multi_array/test toolset=%TOOLSET% %CXXSTD%
--- a/doc/build.jam
+++ b/doc/build.jam
@@ -1,15 +0,0 @@
-# Copyright (c) 2016 Rene Rivera
-#
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
-# http://www.boost.org/LICENSE_1_0.txt)
-
-###############################################################################
-alias boostdoc
-    : xml/bbref.xml
-    :
-    :
-    : ;
-explicit boostdoc ;
-alias boostrelease ;
-explicit boostrelease ;
--- a/doc/iterator_categories.html
+++ b/doc/iterator_categories.html
@@ -50,7 +50,7 @@ iterator categories.
    <td><tt>*i</tt> is convertible to <tt>T</tt></td></tr>
  <tr>
    <td>Forward Iterator</td>
-    <td><tt>*i</tt> is <tt>T&amp;</tt> (or <tt>const T&amp;</tt> once <a href="http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-active.html#200">issue 
+    <td><tt>*i</tt> is <tt>T&amp;</tt> (or <tt>const T&amp;</tt> once <a href="http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/lwg-active.html#200">issue 
      200</a> is resolved)</td></tr>
  <tr>
    <td>Random Access Iterator</td>
@@ -61,7 +61,7 @@ iterator categories.
 <p>Because of the mixing of iterator traversal and dereference return type, many 
 useful iterators can not be appropriately categorized. For example, 
 <tt>vector&lt;bool&gt;::iterator</tt> is almost a random access iterator, but 
-the return type is not <tt>bool&amp;</tt> (see <a href="http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-active.html#96">issue 
+the return type is not <tt>bool&amp;</tt> (see <a href="http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/lwg-active.html#96">issue 
 96</a> and Herb Sutter's paper J16/99-0008 = WG21 N1185). Therefore, the 
 iterators only meet the requirements of input iterator and output iterator. This 
 is so nonintuitive that at least one implementation erroneously assigns 
@@ -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://www.open-std.org/JTC1/SC22/WG21/docs/lwg-active.html#198">Issue 
+<tt>value_type</tt>. Option 1) runs into the problems discussed in <a href="http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/lwg-active.html#198">Issue 
 198</a>, the reference will not be valid after the iterator is destroyed. Option 
 2) is therefore a better choice, but then we have a counting iterator that 
 cannot be a random access iterator. 
--- a/doc/user.html
+++ b/doc/user.html
@@ -661,11 +661,6 @@ arrays, as <tt>boost::array</tt> does for C one-dimensional arrays.
      <li><a href="mailto:bdawes@acm.org">Beman Dawes</a>
      helped immensely with porting the library to Microsoft Windows
      compilers.
-
-      <li><a href="mailto:glenjofe@gmail.com">Glen Fernandes</a>
-      implemented support for the C++11 allocator model, including
-      support for stateful allocators, minimal allocators, and
-      optimized storage for stateless allocators.
 </ul>

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

 <para>
@@ -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,12 +60,9 @@ public:
  template <std::size_t Dims> struct            const_array_view;
  

-  static const std::size_t dimensionality = NumDims;
-  
-
  // constructors and destructors

-  multi_array(const Allocator& alloc = Allocator());
+  multi_array();

  template <typename ExtentList>
  explicit multi_array(const ExtentList& sizes,
@@ -75,19 +72,13 @@ public:
                       const storage_order_type& store = c_storage_order(),
 	               const Allocator& alloc = Allocator());
  multi_array(const multi_array& x);
-  multi_array(const const_multi_array_ref<ValueType,NumDims>& x,
-              const Allocator& alloc = Allocator());
-  multi_array(const const_subarray<NumDims>::type& x,
-              const Allocator& alloc = Allocator());
-  multi_array(const const_array_view<NumDims>::type& x,
-              const Allocator& alloc = Allocator());
+  multi_array(const const_multi_array_ref<ValueType,NumDims>& x);
+  multi_array(const const_subarray<NumDims>::type& x);
+  multi_array(const const_array_view<NumDims>::type& x);

-  multi_array(const multi_array_ref<ValueType,NumDims>& x,
-              const Allocator& alloc = Allocator());
-  multi_array(const subarray<NumDims>::type& x,
-              const Allocator& alloc = Allocator());
-  multi_array(const array_view<NumDims>::type& x,
-              const Allocator& alloc = Allocator());
+  multi_array(const multi_array_ref<ValueType,NumDims>& x);
+  multi_array(const subarray<NumDims>::type& x);
+  multi_array(const array_view<NumDims>::type& x);

  ~multi_array();

@@ -213,18 +204,12 @@ elements.
 <varlistentry>
 <term><programlisting>
 <![CDATA[multi_array(const multi_array& x);
-multi_array(const const_multi_array_ref<ValueType,NumDims>& x,
-    const Allocator& alloc = Allocator());
-multi_array(const const_subarray<NumDims>::type& x,
-    const Allocator& alloc = Allocator());
-multi_array(const const_array_view<NumDims>::type& x,
-    const Allocator& alloc = Allocator());
-multi_array(const multi_array_ref<ValueType,NumDims>& x,
-    const Allocator& alloc = Allocator());
-multi_array(const subarray<NumDims>::type& x,
-    const Allocator& alloc = Allocator());
-multi_array(const array_view<NumDims>::type& x,
-    const Allocator& alloc = Allocator());]]>
+multi_array(const const_multi_array_ref<ValueType,NumDims>& x);
+multi_array(const const_subarray<NumDims>::type& x);
+multi_array(const const_array_view<NumDims>::type& x);
+multi_array(const multi_array_ref<ValueType,NumDims>& x);
+multi_array(const subarray<NumDims>::type& x);
+multi_array(const array_view<NumDims>::type& x);]]>
 </programlisting></term>
 <listitem>
 <para>These constructors all constructs a <literal>multi_array</literal> and 
--- a/doc/xml/multi_array_ref.xml
+++ b/doc/xml/multi_array_ref.xml
@@ -59,10 +59,7 @@ public:
  template <std::size_t Dims> struct            const_array_view;
  

-  static const std::size_t dimensionality = NumDims;
-
-
-  // constructors and destructors
+  // structors

  template <typename ExtentList>
  explicit multi_array_ref(element* data, const ExtentList& sizes,
--- a/include/boost/multi_array.hpp
+++ b/include/boost/multi_array.hpp
@@ -1,8 +1,5 @@
 // Copyright 2002 The Trustees of Indiana University.

-// Copyright 2018 Glen Joseph Fernandes
-// (glenjofe@gmail.com)
-
 // Use, modification and distribution is subject to the Boost Software 
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
@@ -21,11 +18,6 @@
 // declaration and definition
 //

-#if defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 406)
-#  pragma GCC diagnostic push
-#  pragma GCC diagnostic ignored "-Wshadow"
-#endif
-
 #include "boost/multi_array/base.hpp"
 #include "boost/multi_array/collection_concept.hpp"
 #include "boost/multi_array/copy_array.hpp"
@@ -33,8 +25,6 @@
 #include "boost/multi_array/subarray.hpp"
 #include "boost/multi_array/multi_array_ref.hpp"
 #include "boost/multi_array/algorithm.hpp"
-#include "boost/multi_array/allocators.hpp"
-#include "boost/core/empty_value.hpp"
 #include "boost/array.hpp"
 #include "boost/mpl/if.hpp"
 #include "boost/type_traits.hpp"
@@ -119,10 +109,8 @@ struct disable_multi_array_impl<int>
 template<typename T, std::size_t NumDims,
  typename Allocator>
 class multi_array :
-  public multi_array_ref<T,NumDims>,
-  private boost::empty_value<Allocator>
+  public multi_array_ref<T,NumDims>
 {
-  typedef boost::empty_value<Allocator> alloc_base;
  typedef multi_array_ref<T,NumDims> super_type;
 public:
  typedef typename super_type::value_type value_type;
@@ -149,25 +137,22 @@ public:
    typedef boost::detail::multi_array::multi_array_view<T,NDims> type;
  };

-  explicit multi_array(const Allocator& alloc = Allocator()) :
+  explicit multi_array() :
    super_type((T*)initial_base_,c_storage_order(),
-               /*index_bases=*/0, /*extents=*/0),
-    alloc_base(boost::empty_init_t(),alloc) {
+               /*index_bases=*/0, /*extents=*/0) {
    allocate_space(); 
  }

  template <class ExtentList>
  explicit multi_array(
-      ExtentList const& extents,
-      const Allocator& alloc = Allocator()
+      ExtentList const& extents
 #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
      , typename mpl::if_<
      detail::multi_array::is_multi_array_impl<ExtentList>,
      int&,int>::type* = 0
 #endif
      ) :
-    super_type((T*)initial_base_,extents),
-    alloc_base(boost::empty_init_t(),alloc) {
+    super_type((T*)initial_base_,extents) {
    boost::function_requires<
      detail::multi_array::CollectionConcept<ExtentList> >();
    allocate_space();
@@ -177,8 +162,7 @@ public:
  template <class ExtentList>
  explicit multi_array(ExtentList const& extents,
                       const general_storage_order<NumDims>& so) :
-    super_type((T*)initial_base_,extents,so),
-    alloc_base(boost::empty_init_t()) {
+    super_type((T*)initial_base_,extents,so) {
    boost::function_requires<
      detail::multi_array::CollectionConcept<ExtentList> >();
    allocate_space();
@@ -188,8 +172,7 @@ public:
  explicit multi_array(ExtentList const& extents,
                       const general_storage_order<NumDims>& so,
                       Allocator const& alloc) :
-    super_type((T*)initial_base_,extents,so),
-    alloc_base(boost::empty_init_t(),alloc) {
+    super_type((T*)initial_base_,extents,so), allocator_(alloc) {
    boost::function_requires<
      detail::multi_array::CollectionConcept<ExtentList> >();
    allocate_space();
@@ -197,10 +180,8 @@ public:


  explicit multi_array(const detail::multi_array
-                       ::extent_gen<NumDims>& ranges,
-                       const Allocator& alloc = Allocator()) :
-    super_type((T*)initial_base_,ranges),
-    alloc_base(boost::empty_init_t(),alloc) {
+                       ::extent_gen<NumDims>& ranges) :
+    super_type((T*)initial_base_,ranges) {

    allocate_space();
  }
@@ -209,8 +190,7 @@ public:
  explicit multi_array(const detail::multi_array
                       ::extent_gen<NumDims>& ranges,
                       const general_storage_order<NumDims>& so) :
-    super_type((T*)initial_base_,ranges,so),
-    alloc_base(boost::empty_init_t()) {
+    super_type((T*)initial_base_,ranges,so) {

    allocate_space();
  }
@@ -220,15 +200,13 @@ public:
                       ::extent_gen<NumDims>& ranges,
                       const general_storage_order<NumDims>& so,
                       Allocator const& alloc) :
-    super_type((T*)initial_base_,ranges,so),
-    alloc_base(boost::empty_init_t(),alloc) {
+    super_type((T*)initial_base_,ranges,so), allocator_(alloc) {

    allocate_space();
  }

  multi_array(const multi_array& rhs) :
-  super_type(rhs),
-  alloc_base(static_cast<const alloc_base&>(rhs)) {
+  super_type(rhs), allocator_(rhs.allocator_) {
    allocate_space();
    boost::detail::multi_array::copy_n(rhs.base_,rhs.num_elements(),base_);
  }
@@ -245,10 +223,8 @@ public:
 #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
  template <typename OPtr>
  multi_array(const const_multi_array_ref<T,NumDims,OPtr>& rhs,
-              const general_storage_order<NumDims>& so = c_storage_order(),
-              const Allocator& alloc = Allocator())
-    : super_type(0,so,rhs.index_bases(),rhs.shape()),
-      alloc_base(boost::empty_init_t(),alloc)
+              const general_storage_order<NumDims>& so = c_storage_order())
+    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
  {
    allocate_space();
    // Warning! storage order may change, hence the following copy technique.
@@ -258,10 +234,8 @@ public:
  template <typename OPtr>
  multi_array(const detail::multi_array::
              const_sub_array<T,NumDims,OPtr>& rhs,
-              const general_storage_order<NumDims>& so = c_storage_order(),
-              const Allocator& alloc = Allocator())
-    : super_type(0,so,rhs.index_bases(),rhs.shape()),
-      alloc_base(boost::empty_init_t(),alloc)
+              const general_storage_order<NumDims>& so = c_storage_order())
+    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
  {
    allocate_space();
    std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -271,10 +245,8 @@ public:
  template <typename OPtr>
  multi_array(const detail::multi_array::
              const_multi_array_view<T,NumDims,OPtr>& rhs,
-              const general_storage_order<NumDims>& so = c_storage_order(),
-              const Allocator& alloc = Allocator())
-    : super_type(0,so,rhs.index_bases(),rhs.shape()),
-      alloc_base(boost::empty_init_t(),alloc)
+              const general_storage_order<NumDims>& so = c_storage_order())
+    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
  {
    allocate_space();
    std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -284,10 +256,8 @@ public:
  // More limited support for MSVC


-  multi_array(const const_multi_array_ref<T,NumDims>& rhs,
-              const Allocator& alloc = Allocator())
-    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()),
-      alloc_base(boost::empty_init_t(),alloc)
+  multi_array(const const_multi_array_ref<T,NumDims>& rhs)
+    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) 
  {
    allocate_space();
    // Warning! storage order may change, hence the following copy technique.
@@ -295,10 +265,8 @@ public:
  }

  multi_array(const const_multi_array_ref<T,NumDims>& rhs,
-              const general_storage_order<NumDims>& so,
-              const Allocator& alloc = Allocator())
-    : super_type(0,so,rhs.index_bases(),rhs.shape()),
-      alloc_base(boost::empty_init_t(),alloc)
+              const general_storage_order<NumDims>& so)
+    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
  {
    allocate_space();
    // Warning! storage order may change, hence the following copy technique.
@@ -306,10 +274,8 @@ public:
  }

  multi_array(const detail::multi_array::
-              const_sub_array<T,NumDims>& rhs,
-              const Allocator& alloc = Allocator())
-    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()),
-      alloc_base(boost::empty_init_t(),alloc)
+              const_sub_array<T,NumDims>& rhs)
+    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) 
  {
    allocate_space();
    std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -317,10 +283,8 @@ public:

  multi_array(const detail::multi_array::
              const_sub_array<T,NumDims>& rhs,
-              const general_storage_order<NumDims>& so,
-              const Allocator& alloc = Allocator())
-    : super_type(0,so,rhs.index_bases(),rhs.shape()),
-      alloc_base(boost::empty_init_t(),alloc)
+              const general_storage_order<NumDims>& so)
+    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
  {
    allocate_space();
    std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -328,10 +292,8 @@ public:


  multi_array(const detail::multi_array::
-              const_multi_array_view<T,NumDims>& rhs,
-              const Allocator& alloc = Allocator())
-    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()),
-      alloc_base(boost::empty_init_t(),alloc)
+              const_multi_array_view<T,NumDims>& rhs)
+    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) 
  {
    allocate_space();
    std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -339,10 +301,8 @@ public:

  multi_array(const detail::multi_array::
              const_multi_array_view<T,NumDims>& rhs,
-              const general_storage_order<NumDims>& so,
-              const Allocator& alloc = Allocator())
-    : super_type(0,so,rhs.index_bases(),rhs.shape()),
-      alloc_base(boost::empty_init_t(),alloc)
+              const general_storage_order<NumDims>& so)
+    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
  {
    allocate_space();
    std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -351,10 +311,8 @@ public:
 #endif // !BOOST_NO_FUNCTION_TEMPLATE_ORDERING

  // Thes constructors are necessary because of more exact template matches.
-  multi_array(const multi_array_ref<T,NumDims>& rhs,
-              const Allocator& alloc = Allocator())
-    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()),
-      alloc_base(boost::empty_init_t(),alloc)
+  multi_array(const multi_array_ref<T,NumDims>& rhs)
+    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) 
  {
    allocate_space();
    // Warning! storage order may change, hence the following copy technique.
@@ -362,10 +320,8 @@ public:
  }

  multi_array(const multi_array_ref<T,NumDims>& rhs,
-              const general_storage_order<NumDims>& so,
-              const Allocator& alloc = Allocator())
-    : super_type(0,so,rhs.index_bases(),rhs.shape()),
-      alloc_base(boost::empty_init_t(),alloc)
+              const general_storage_order<NumDims>& so)
+    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
  {
    allocate_space();
    // Warning! storage order may change, hence the following copy technique.
@@ -374,10 +330,8 @@ public:


  multi_array(const detail::multi_array::
-              sub_array<T,NumDims>& rhs,
-              const Allocator& alloc = Allocator())
-    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()),
-      alloc_base(boost::empty_init_t(),alloc)
+              sub_array<T,NumDims>& rhs)
+    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) 
  {
    allocate_space();
    std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -385,10 +339,8 @@ public:

  multi_array(const detail::multi_array::
              sub_array<T,NumDims>& rhs,
-              const general_storage_order<NumDims>& so,
-              const Allocator& alloc = Allocator())
-    : super_type(0,so,rhs.index_bases(),rhs.shape()),
-      alloc_base(boost::empty_init_t(),alloc)
+              const general_storage_order<NumDims>& so)
+    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
  {
    allocate_space();
    std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -396,10 +348,8 @@ public:


  multi_array(const detail::multi_array::
-              multi_array_view<T,NumDims>& rhs,
-              const Allocator& alloc = Allocator())
-    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()),
-      alloc_base(boost::empty_init_t(),alloc)
+              multi_array_view<T,NumDims>& rhs)
+    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) 
  {
    allocate_space();
    std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -407,10 +357,8 @@ public:
    
  multi_array(const detail::multi_array::
              multi_array_view<T,NumDims>& rhs,
-              const general_storage_order<NumDims>& so,
-              const Allocator& alloc = Allocator())
-    : super_type(0,so,rhs.index_bases(),rhs.shape()),
-      alloc_base(boost::empty_init_t(),alloc)
+              const general_storage_order<NumDims>& so)
+    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
  {
    allocate_space();
    std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -455,7 +403,7 @@ public:


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


    // build a view of tmp with the minimum extents
@@ -501,7 +449,6 @@ public:
    using std::swap;
    // Swap the internals of these arrays.
    swap(this->super_type::base_,new_array.super_type::base_);
-    swap(this->allocator(),new_array.allocator());
    swap(this->storage_,new_array.storage_);
    swap(this->extent_list_,new_array.extent_list_);
    swap(this->stride_list_,new_array.stride_list_);
@@ -509,6 +456,7 @@ public:
    swap(this->origin_offset_,new_array.origin_offset_);
    swap(this->directional_offset_,new_array.directional_offset_);
    swap(this->num_elements_,new_array.num_elements_);
+    swap(this->allocator_,new_array.allocator_);
    swap(this->base_,new_array.base_);
    swap(this->allocated_elements_,new_array.allocated_elements_);

@@ -521,43 +469,26 @@ public:
  }

 private:
-  friend inline bool operator==(const multi_array& a, const multi_array& b) {
-    return a.base() == b.base();
-  }
-
-  friend inline bool operator!=(const multi_array& a, const multi_array& b) {
-    return !(a == b);
-  }
-
-  const super_type& base() const {
-    return *this;
-  }
-
-  const Allocator& allocator() const {
-    return alloc_base::get();
-  }
-
-  Allocator& allocator() {
-    return alloc_base::get();
-  }
-
  void allocate_space() {
-    base_ = allocator().allocate(this->num_elements());
+    typename Allocator::const_pointer no_hint=0;
+    base_ = allocator_.allocate(this->num_elements(),no_hint);
    this->set_base_ptr(base_);
    allocated_elements_ = this->num_elements();
-    detail::multi_array::construct(allocator(),base_,base_+allocated_elements_);
+    std::uninitialized_fill_n(base_,allocated_elements_,T());
  }

  void deallocate_space() {
    if(base_) {
-      detail::multi_array::destroy(allocator(),base_,base_+allocated_elements_);
-      allocator().deallocate(base_,allocated_elements_);
+      for(T* i = base_; i != base_+allocated_elements_; ++i)
+        allocator_.destroy(i);
+      allocator_.deallocate(base_,allocated_elements_);
    }
  }

  typedef boost::array<size_type,NumDims> size_list;
  typedef boost::array<index,NumDims> index_list;

+  Allocator allocator_;
  T* base_;
  size_type allocated_elements_;
  enum {initial_base_ = 0};
@@ -565,8 +496,4 @@ private:

 } // namespace boost

-#if defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 406)
-#  pragma GCC diagnostic pop
-#endif
-
 #endif // BOOST_MULTI_ARRAY_RG071801_HPP
--- a/include/boost/multi_array/allocators.hpp
+++ b/include/boost/multi_array/allocators.hpp
@@ -1,72 +0,0 @@
-// Copyright 2018 Glen Joseph Fernandes
-// (glenjofe@gmail.com)
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_MULTI_ARRAY_ALLOCATORS_HPP
-#define BOOST_MULTI_ARRAY_ALLOCATORS_HPP
-
-#include <boost/config.hpp>
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-#include <memory>
-#else
-#include <new>
-#endif
-
-namespace boost {
-namespace detail {
-namespace multi_array {
-
-template<class A, class T>
-inline void destroy(A& allocator, T* ptr, T* end)
-{
-  for (; ptr != end; ++ptr) {
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-    std::allocator_traits<A>::destroy(allocator,ptr);
-#else
-    ptr->~T();
-#endif
-  }
-}
-
-template<class A, class T>
-inline void construct(A& allocator, T* ptr)
-{
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-  std::allocator_traits<A>::construct(allocator,ptr);
-#else
-  ::new(static_cast<void*>(ptr)) T();
-#endif
-}
-
-#if !defined(BOOST_NO_EXCEPTIONS)
-template<class A, class T>
-inline void construct(A& allocator, T* ptr, T* end)
-{
-  T* start = ptr;
-  try {
-    for (; ptr != end; ++ptr) {
-      boost::detail::multi_array::construct(allocator,ptr);
-    }
-  } catch (...) {
-    boost::detail::multi_array::destroy(allocator,start,ptr);
-    throw;
-  }
-}
-#else
-template<class A, class T>
-inline void construct(A& allocator, T* ptr, T* end)
-{
-  for (; ptr != end; ++ptr) {
-    boost::detail::multi_array::construct(allocator,ptr);
-  }
-}
-#endif
-
-} // multi_array
-} // detail
-} // boost
-
-#endif
--- a/include/boost/multi_array/base.hpp
+++ b/include/boost/multi_array/base.hpp
@@ -29,6 +29,7 @@
 #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"
@@ -64,7 +65,7 @@ namespace multi_array_types {
 // object creation in small-memory environments.  Thus, the objects
 // can be left undefined by defining BOOST_MULTI_ARRAY_NO_GENERATORS 
 // before loading multi_array.hpp.
-#ifndef BOOST_MULTI_ARRAY_NO_GENERATORS
+#if !BOOST_MULTI_ARRAY_NO_GENERATORS
 namespace {
  multi_array_types::extent_gen extents;
  multi_array_types::index_gen indices;
@@ -209,11 +210,44 @@ 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
 /////////////////////////////////////////////////////////////////////////
@@ -238,7 +272,13 @@ struct mutable_iterator_tag
 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:
@@ -463,7 +503,6 @@ protected:
      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


--- a/include/boost/multi_array/concept_checks.hpp
+++ b/include/boost/multi_array/concept_checks.hpp
@@ -39,6 +39,8 @@ namespace detail {

    template <typename Array, typename IdxGen, typename Call_Type>
    static void call(Array& a, const IdxGen& idgen, Call_Type c) {
+      typedef typename Array::index_range index_range;
+      typedef typename Array::index index;
      idgen_helper<N-1>::call(a,idgen[c],c);
    }
  };
@@ -48,6 +50,8 @@ namespace detail {

    template <typename Array, typename IdxGen, typename Call_Type>
    static void call(Array& a, const IdxGen& idgen, Call_Type) {
+      typedef typename Array::index_range index_range;
+      typedef typename Array::index index;
      a[ idgen ];
    }
  };
--- a/include/boost/multi_array/iterator.hpp
+++ b/include/boost/multi_array/iterator.hpp
@@ -20,6 +20,7 @@

 #include "boost/multi_array/base.hpp"
 #include "boost/iterator/iterator_facade.hpp"
+#include "boost/mpl/aux_/msvc_eti_base.hpp"
 #include <algorithm>
 #include <cstddef>
 #include <iterator>
@@ -58,9 +59,15 @@ class array_iterator
      , 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 ::boost::iterator_core_access;
+  friend class iterator_core_access;
  typedef detail::multi_array::associated_types<T,NumDims> access_t;

  typedef iterator_facade<
--- a/include/boost/multi_array/multi_array_ref.hpp
+++ b/include/boost/multi_array/multi_array_ref.hpp
@@ -225,7 +225,11 @@ public:
  }

  // see generate_array_view in base.hpp
+#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
  template <int NDims>
+#else
+  template <int NumDims, int NDims> // else ICE
+#endif // BOOST_MSVC
  typename const_array_view<NDims>::type 
  operator[](const detail::multi_array::
             index_gen<NumDims,NDims>& indices)
@@ -525,7 +529,11 @@ public:


  // See note attached to generate_array_view in base.hpp
+#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
  template <int NDims>
+#else
+  template <int NumDims, int NDims> // else ICE
+#endif // BOOST_MSVC
  typename array_view<NDims>::type 
  operator[](const detail::multi_array::
             index_gen<NumDims,NDims>& indices) {
@@ -583,7 +591,11 @@ public:
  }

  // See note attached to generate_array_view in base.hpp
+#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
  template <int NDims>
+#else
+  template <int NumDims, int NDims> // else ICE
+#endif // BOOST_MSVC
  typename const_array_view<NDims>::type 
  operator[](const detail::multi_array::
             index_gen<NumDims,NDims>& indices)
--- a/include/boost/multi_array/subarray.hpp
+++ b/include/boost/multi_array/subarray.hpp
@@ -87,7 +87,11 @@ public:
  }

  // see generate_array_view in base.hpp
+#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
  template <int NDims>
+#else
+  template <int NumDims, int NDims> // else ICE
+#endif // BOOST_MSVC
  typename const_array_view<NDims>::type 
  operator[](const boost::detail::multi_array::
             index_gen<NumDims,NDims>& indices)
@@ -263,7 +267,11 @@ public:
  }

  // see generate_array_view in base.hpp
+#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
  template <int NDims>
+#else
+  template <int NumDims, int NDims> // else ICE
+#endif // BOOST_MSVC
  typename array_view<NDims>::type 
  operator[](const boost::detail::multi_array::
             index_gen<NumDims,NDims>& indices) {
@@ -324,7 +332,11 @@ public:
  }

  // see generate_array_view in base.hpp
+#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
  template <int NDims>
+#else
+  template <int NumDims, int NDims> // else ICE
+#endif // BOOST_MSVC
  typename const_array_view<NDims>::type 
  operator[](const boost::detail::multi_array::
             index_gen<NumDims,NDims>& indices)
--- a/include/boost/multi_array/view.hpp
+++ b/include/boost/multi_array/view.hpp
@@ -135,7 +135,11 @@ public:
  }

  // see generate_array_view in base.hpp
+#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
  template <int NDims>
+#else
+  template <int NumDims, int NDims> // else ICE
+#endif // BOOST_MSVC
  typename const_array_view<NDims>::type 
  operator[](const boost::detail::multi_array::
             index_gen<NumDims,NDims>& indices)
@@ -342,7 +346,11 @@ public:


  // see generate_array_view in base.hpp
+#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
  template <int NDims>
+#else
+  template <int NumDims, int NDims> // else ICE
+#endif // BOOST_MSVC
  typename array_view<NDims>::type 
  operator[](const boost::detail::multi_array::
             index_gen<NumDims,NDims>& indices) {
@@ -394,7 +402,11 @@ public:
  }

  // see generate_array_view in base.hpp
+#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
  template <int NDims>
+#else
+  template <int NumDims, int NDims> // else ICE
+#endif // BOOST_MSVC
  typename const_array_view<NDims>::type 
  operator[](const boost::detail::multi_array::
             index_gen<NumDims,NDims>& indices)
--- a/meta/libraries.json
+++ b/meta/libraries.json
@@ -1,15 +0,0 @@
-{
-    "key": "multi_array",
-    "name": "Multi-Array",
-    "authors": [
-        "Ron Garcia"
-    ],
-    "description": "Boost.MultiArray provides a generic N-dimensional array concept definition and common implementations of that interface.",
-    "category": [
-        "Containers",
-        "Math"
-    ],
-    "maintainers": [
-        "Ronald Garcia <garcia -at- osl.iu.edu>"
-    ]
-}