table.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2002 - 2018 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE at
// the top level of the deal.II distribution.
//
// ---------------------------------------------------------------------

#ifndef dealii_table_h
#define dealii_table_h

#include <deal.II/base/config.h>
#include <deal.II/base/exceptions.h>
#include <deal.II/base/subscriptor.h>
#include <deal.II/base/table_indices.h>
#include <deal.II/base/memory_consumption.h>
#include <deal.II/base/aligned_vector.h>
#include <deal.II/base/linear_index_iterator.h>

#include <cstddef>
#include <algorithm>

DEAL_II_NAMESPACE_OPEN

// forward declaration
template <int N, typename T> class TableBase;
template <int N, typename T> class Table;
template <typename T> class TransposeTable;
template <typename T> class Table<1,T>;
template <typename T> class Table<2,T>;
template <typename T> class Table<3,T>;
template <typename T> class Table<4,T>;
template <typename T> class Table<5,T>;
template <typename T> class Table<6,T>;



namespace internal
{

  namespace TableBaseAccessors
  {
    template <int N, typename T, bool Constness>
    struct Types
    {};

    template <int N, typename T> struct Types<N,T,true>
    {
      typedef const T value_type;
      typedef const TableBase<N,T> TableType;

      typedef typename AlignedVector<T>::const_iterator iterator;
      typedef typename AlignedVector<T>::const_iterator const_iterator;

      typedef typename AlignedVector<T>::const_reference reference;
      typedef typename AlignedVector<T>::const_reference const_reference;
    };

    template <int N, typename T> struct Types<N,T,false>
    {
      typedef T value_type;
      typedef TableBase<N,T> TableType;

      typedef typename AlignedVector<T>::iterator iterator;
      typedef typename AlignedVector<T>::const_iterator const_iterator;

      typedef typename AlignedVector<T>::reference reference;
      typedef typename AlignedVector<T>::const_reference const_reference;
    };


    template <int N, typename T, bool C, unsigned int P>
    class Accessor
    {
    public:
      typedef typename Types<N,T,C>::TableType TableType;

      typedef typename Types<N,T,C>::iterator iterator;
      typedef typename Types<N,T,C>::const_iterator const_iterator;

      typedef size_t size_type;
      typedef ptrdiff_t difference_type;
    private:
      Accessor (const TableType &table,
                const iterator    data);

      Accessor () = delete;

    public:

      Accessor (const Accessor &a);

      Accessor<N,T,C,P-1> operator [] (const size_type i) const;

      DeclException3 (ExcIndexRange, size_type, size_type, size_type,
                      << "Index " << N-P+1 << "has a value of "
                      << arg1 << " but needs to be in the range ["
                      << arg2 << "," << arg3 << "[.");
    private:
      const TableType &table;
      const iterator   data;

      // declare some other classes
      // as friends. make sure to
      // work around bugs in some
      // compilers
      template <int N1, typename T1> friend class ::Table;
      template <int N1, typename T1, bool C1, unsigned int P1>
      friend class Accessor;
#  ifndef DEAL_II_TEMPL_SPEC_FRIEND_BUG
      friend class ::Table<N,T>;
      friend class Accessor<N,T,C,P+1>;
#  endif
    };



    template <int N, typename T, bool C>
    class Accessor<N,T,C,1>
    {
    public:
      typedef typename Types<N,T,C>::value_type value_type;

      typedef typename Types<N,T,C>::iterator iterator;
      typedef typename Types<N,T,C>::const_iterator const_iterator;

      typedef typename Types<N,T,C>::reference reference;
      typedef typename Types<N,T,C>::const_reference const_reference;

      typedef size_t size_type;
      typedef ptrdiff_t difference_type;

      typedef typename Types<N,T,C>::TableType    TableType;

    private:

      Accessor (const TableType &table,
                const iterator    data);

      Accessor () = delete;

    public:
      Accessor (const Accessor &a);


      reference operator [] (const size_type) const;

      size_type size () const;

      iterator begin () const;

      iterator end () const;

    private:
      const TableType &table;
      const iterator   data;

      // declare some other classes
      // as friends. make sure to
      // work around bugs in some
      // compilers
      template <int N1, typename T1> friend class ::Table;
      template <int N1, typename T1, bool C1, unsigned int P1>
      friend class Accessor;
#  ifndef DEAL_II_TEMPL_SPEC_FRIEND_BUG
      friend class ::Table<2,T>;
      friend class Accessor<N,T,C,2>;
#  endif
    };
  }

} // namespace internal




template <int N, typename T>
class TableBase : public Subscriptor
{
public:
  typedef T value_type;

  typedef typename AlignedVector<T>::size_type size_type;


  TableBase () = default;

  TableBase (const TableIndices<N> &sizes);

  template <typename InputIterator>
  TableBase (const TableIndices<N> &sizes,
             InputIterator entries,
             const bool      C_style_indexing = true);

  TableBase (const TableBase<N,T> &src);

  template <typename T2>
  TableBase (const TableBase<N,T2> &src);

  TableBase (TableBase<N,T> &&src) noexcept;

  ~TableBase () = default;

  TableBase<N,T> &operator = (const TableBase<N,T> &src);

  template <typename T2>
  TableBase<N,T> &operator = (const TableBase<N,T2> &src);

  TableBase<N,T> &operator = (TableBase<N,T> &&src) noexcept;

  bool operator == (const TableBase<N,T> &T2)  const;

  void reset_values ();

  void reinit (const TableIndices<N> &new_size,
               const bool             omit_default_initialization = false);

  size_type size (const unsigned int i) const;

  const TableIndices<N> &size () const;

  size_type n_elements () const;

  bool empty () const;

  template <typename InputIterator>
  void fill (InputIterator entries,
             const bool      C_style_indexing = true);

  void fill (const T &value);

  typename AlignedVector<T>::reference
  operator () (const TableIndices<N> &indices);

  typename AlignedVector<T>::const_reference
  operator () (const TableIndices<N> &indices) const;

  void swap (TableBase<N,T> &v);

  std::size_t memory_consumption () const;

  template <class Archive>
  void serialize (Archive &ar, const unsigned int version);

protected:
  size_type position (const TableIndices<N> &indices) const;

  typename AlignedVector<T>::reference el (const TableIndices<N> &indices);

  typename AlignedVector<T>::const_reference el (const TableIndices<N> &indices) const;

protected:
  AlignedVector<T> values;

  TableIndices<N> table_size;

  template <int, typename> friend class TableBase;
};


template <int N,typename T>
class Table : public TableBase<N,T>
{
};


template <typename T>
class Table<1,T> : public TableBase<1,T>
{
public:
  typedef typename TableBase<1,T>::size_type size_type;

  Table () = default;

  Table (const size_type size);

  template <typename InputIterator>
  Table (const size_type size,
         InputIterator entries,
         const bool      C_style_indexing = true);

  typename AlignedVector<T>::const_reference
  operator [] (const size_type i) const;

  typename AlignedVector<T>::reference
  operator [] (const size_type i);

  typename AlignedVector<T>::const_reference
  operator () (const size_type i) const;

  typename AlignedVector<T>::reference
  operator () (const size_type i);

  typename AlignedVector<T>::reference
  operator () (const TableIndices<1> &indices);

  typename AlignedVector<T>::const_reference
  operator () (const TableIndices<1> &indices) const;
};



template <typename T>
class Table<2,T> : public TableBase<2,T>
{
public:
  typedef typename TableBase<2,T>::size_type size_type;

  Table () = default;

  Table (const size_type size1,
         const size_type size2);

  template <typename InputIterator>
  Table (const size_type size1,
         const size_type size2,
         InputIterator entries,
         const bool      C_style_indexing = true);

  void reinit (const size_type size1,
               const size_type size2,
               const bool         omit_default_initialization = false);

  using TableBase<2,T>::reinit;

  ::internal::TableBaseAccessors::Accessor<2,T,true,1>
  operator [] (const size_type i) const;

  ::internal::TableBaseAccessors::Accessor<2,T,false,1>
  operator [] (const size_type i);

  typename AlignedVector<T>::const_reference
  operator () (const size_type i,
               const size_type j) const;


  typename AlignedVector<T>::reference
  operator () (const size_type i,
               const size_type j);

  typename AlignedVector<T>::reference
  operator () (const TableIndices<2> &indices);

  typename AlignedVector<T>::const_reference
  operator () (const TableIndices<2> &indices) const;


  size_type n_rows () const;

  size_type n_cols () const;

protected:
  typename AlignedVector<T>::reference el (const size_type i,
                                           const size_type j);

  typename AlignedVector<T>::const_reference el (const size_type i,
                                                 const size_type j) const;
};



template <typename T>
class Table<3,T> : public TableBase<3,T>
{
public:
  typedef typename TableBase<3,T>::size_type size_type;

  Table () = default;

  Table (const size_type size1,
         const size_type size2,
         const size_type size3);

  template <typename InputIterator>
  Table (const size_type size1,
         const size_type size2,
         const size_type size3,
         InputIterator entries,
         const bool      C_style_indexing = true);

  ::internal::TableBaseAccessors::Accessor<3,T,true,2>
  operator [] (const size_type i) const;

  ::internal::TableBaseAccessors::Accessor<3,T,false,2>
  operator [] (const size_type i);

  typename AlignedVector<T>::const_reference operator () (const size_type i,
                                                          const size_type j,
                                                          const size_type k) const;


  typename AlignedVector<T>::reference operator () (const size_type i,
                                                    const size_type j,
                                                    const size_type k);

  typename AlignedVector<T>::reference operator () (const TableIndices<3> &indices);

  typename AlignedVector<T>::const_reference operator () (const TableIndices<3> &indices) const;
};



template <typename T>
class Table<4,T> : public TableBase<4,T>
{
public:
  typedef typename TableBase<4,T>::size_type size_type;

  Table () = default;

  Table (const size_type size1,
         const size_type size2,
         const size_type size3,
         const size_type size4);

  ::internal::TableBaseAccessors::Accessor<4,T,true,3>
  operator [] (const size_type i) const;

  ::internal::TableBaseAccessors::Accessor<4,T,false,3>
  operator [] (const size_type i);

  typename AlignedVector<T>::const_reference operator () (const size_type i,
                                                          const size_type j,
                                                          const size_type k,
                                                          const size_type l) const;


  typename AlignedVector<T>::reference operator () (const size_type i,
                                                    const size_type j,
                                                    const size_type k,
                                                    const size_type l);

  typename AlignedVector<T>::reference
  operator () (const TableIndices<4> &indices);

  typename AlignedVector<T>::const_reference
  operator () (const TableIndices<4> &indices) const;
};



template <typename T>
class Table<5,T> : public TableBase<5,T>
{
public:
  typedef typename TableBase<5,T>::size_type size_type;


  Table () = default;

  Table (const size_type size1,
         const size_type size2,
         const size_type size3,
         const size_type size4,
         const size_type size5);

  ::internal::TableBaseAccessors::Accessor<5,T,true,4>
  operator [] (const size_type i) const;

  ::internal::TableBaseAccessors::Accessor<5,T,false,4>
  operator [] (const size_type i);

  typename AlignedVector<T>::const_reference operator () (const size_type i,
                                                          const size_type j,
                                                          const size_type k,
                                                          const size_type l,
                                                          const size_type m) const;

  typename AlignedVector<T>::reference operator () (const size_type i,
                                                    const size_type j,
                                                    const size_type k,
                                                    const size_type l,
                                                    const size_type m);

  typename AlignedVector<T>::reference
  operator () (const TableIndices<5> &indices);

  typename AlignedVector<T>::const_reference
  operator () (const TableIndices<5> &indices) const;
};



template <typename T>
class Table<6,T> : public TableBase<6,T>
{
public:
  typedef typename TableBase<6,T>::size_type size_type;

  Table () = default;

  Table (const size_type size1,
         const size_type size2,
         const size_type size3,
         const size_type size4,
         const size_type size5,
         const size_type size6);

  ::internal::TableBaseAccessors::Accessor<6,T,true,5>
  operator [] (const size_type i) const;

  ::internal::TableBaseAccessors::Accessor<6,T,false,5>
  operator [] (const size_type i);

  typename AlignedVector<T>::const_reference operator () (const size_type i,
                                                          const size_type j,
                                                          const size_type k,
                                                          const size_type l,
                                                          const size_type m,
                                                          const size_type n) const;

  typename AlignedVector<T>::reference operator () (const size_type i,
                                                    const size_type j,
                                                    const size_type k,
                                                    const size_type l,
                                                    const size_type m,
                                                    const size_type n);

  typename AlignedVector<T>::reference
  operator () (const TableIndices<6> &indices);

  typename AlignedVector<T>::const_reference
  operator () (const TableIndices<6> &indices) const;
};


template <typename T>
class Table<7,T> : public TableBase<7,T>
{
public:
  typedef typename TableBase<7,T>::size_type size_type;

  Table () = default;

  Table (const size_type size1,
         const size_type size2,
         const size_type size3,
         const size_type size4,
         const size_type size5,
         const size_type size6,
         const size_type size7);

  ::internal::TableBaseAccessors::Accessor<7,T,true,6>
  operator [] (const size_type i) const;

  ::internal::TableBaseAccessors::Accessor<7,T,false,6>
  operator [] (const size_type i);

  typename AlignedVector<T>::const_reference operator () (const size_type i,
                                                          const size_type j,
                                                          const size_type k,
                                                          const size_type l,
                                                          const size_type m,
                                                          const size_type n,
                                                          const size_type o) const;

  typename AlignedVector<T>::reference operator () (const size_type i,
                                                    const size_type j,
                                                    const size_type k,
                                                    const size_type l,
                                                    const size_type m,
                                                    const size_type n,
                                                    const size_type o);

  typename AlignedVector<T>::reference
  operator () (const TableIndices<7> &indices);

  typename AlignedVector<T>::const_reference
  operator () (const TableIndices<7> &indices) const;
};



namespace TransposeTableIterators
{
  // Forward declaration of the iterator class.
  template <typename T, bool Constness>
  class Iterator;

  template <typename T, bool Constness>
  class Accessor;

  template <typename T, bool Constness>
  class AccessorBase
  {
  public:
    typedef typename std::conditional<Constness, const TransposeTable<T>*, TransposeTable<T>*>::type
    container_pointer_type;

    AccessorBase();

    AccessorBase(const container_pointer_type table);

    AccessorBase(const AccessorBase<T, false> &);

    AccessorBase(const container_pointer_type table,
                 const std::ptrdiff_t linear_index);

    const T &value() const;

    typedef typename TransposeTable<T>::size_type size_type;

    size_type row() const;

    size_type column() const;

  protected:
    container_pointer_type container;

    std::ptrdiff_t linear_index;

    friend class AccessorBase<T, true>;

    friend class LinearIndexIterator<Iterator<T, Constness>, Accessor<T, Constness>>;
  };

  template <typename T>
  class Accessor<T, true> : public AccessorBase<T, true>
  {
  public:
    using AccessorBase<T, true>::AccessorBase;
  };

  template <typename T>
  class Accessor<T, false> : public AccessorBase<T, false>
  {
  public:
    using AccessorBase<T, false>::AccessorBase;

    const Accessor<T, false> &operator = (const T &) const;

    const Accessor<T, false> &operator = (T&&) const;

    using AccessorBase<T, false>::value;

    T &value() const;
  };

  template <typename T, bool Constness>
  class Iterator : public LinearIndexIterator<Iterator<T, Constness>, Accessor<T, Constness>>
  {
  public:
    typedef typename TransposeTable<T>::size_type size_type;

    typedef typename std::conditional<Constness, const TransposeTable<T>*, TransposeTable<T>*>::type
    container_pointer_type;

    Iterator (const Accessor<T, Constness> &accessor);

    Iterator (const container_pointer_type object);

    Iterator (const container_pointer_type object,
              const size_type row,
              const size_type column);

    Iterator(const Iterator<T, false> &i);

    Iterator (const container_pointer_type container,
              const std::ptrdiff_t         linear_index);
  };
}


template <typename T>
class TransposeTable : public TableBase<2,T>
{
public:
  typedef typename TableBase<2,T>::size_type size_type;

  typedef typename AlignedVector<T>::value_type value_type;

  typedef typename AlignedVector<T>::reference reference;

  typedef typename AlignedVector<T>::const_reference const_reference;

  typedef TransposeTableIterators::Iterator<T, true> const_iterator;

  typedef TransposeTableIterators::Iterator<T, false> iterator;

  TransposeTable () = default;

  TransposeTable (const size_type size1,
                  const size_type size2);

  void reinit (const size_type size1,
               const size_type size2,
               const bool      omit_default_initialization = false);

  const_reference operator () (const size_type i,
                               const size_type j) const;

  reference operator () (const size_type i,
                         const size_type j);

  size_type n_rows () const;

  size_type n_cols () const;

  iterator begin ();

  const_iterator begin () const;

  iterator end ();

  const_iterator end () const;

protected:
  reference el (const size_type i,
                const size_type j);

  const_reference el (const size_type i,
                      const size_type j) const;

  friend class TransposeTableIterators::AccessorBase<T, true>;
  friend class TransposeTableIterators::AccessorBase<T, false>;

  friend class TransposeTableIterators::Accessor<T, false>;
};




/* --------------------- Template and inline functions ---------------- */

#ifndef DOXYGEN

template <int N, typename T>
TableBase<N,T>::TableBase (const TableIndices<N> &sizes)
{
  reinit (sizes);
}



template <int N, typename T>
template <typename InputIterator>
TableBase<N,T>::
TableBase (const TableIndices<N> &sizes,
           InputIterator entries,
           const bool      C_style_indexing)
{
  reinit (sizes);
  fill (entries, C_style_indexing);
}




template <int N, typename T>
TableBase<N,T>::TableBase (const TableBase<N,T> &src)
  :
  Subscriptor ()
{
  reinit (src.table_size, true);
  values = src.values;
}



template <int N, typename T>
template <typename T2>
TableBase<N,T>::TableBase (const TableBase<N,T2> &src)
{
  reinit (src.table_size);
  if (src.n_elements() != 0)
    std::copy (src.values.begin(), src.values.end(), values.begin());
}



template <int N, typename T>
TableBase<N,T>::TableBase (TableBase<N,T> &&src) noexcept
:
Subscriptor (std::move(src)),
            values (std::move(src.values)),
            table_size (src.table_size)
{
  src.table_size = TableIndices<N>();
}



template <int N, typename T>
template <class Archive>
inline
void
TableBase<N,T>::serialize (Archive &ar, const unsigned int)
{
  ar &static_cast<Subscriptor &>(*this);

  ar &values &table_size;
}



namespace internal
{
  namespace TableBaseAccessors
  {
    template <int N, typename T, bool C, unsigned int P>
    inline
    Accessor<N,T,C,P>::Accessor (const TableType &table,
                                 const iterator    data)
      :
      table (table),
      data (data)
    {}



    template <int N, typename T, bool C, unsigned int P>
    inline
    Accessor<N,T,C,P>::Accessor (const Accessor &a)
      :
      table (a.table),
      data (a.data)
    {}



    template <int N, typename T, bool C, unsigned int P>
    inline
    Accessor<N,T,C,P-1>
    Accessor<N,T,C,P>::operator [] (const size_type i) const
    {
      Assert (i < table.size()[N-P],
              ExcIndexRange (i, 0, table.size()[N-P]));

      // access i-th
      // subobject. optimize on the
      // case i==0
      if (i==0)
        return Accessor<N,T,C,P-1> (table, data);
      else
        {
          // note: P>1, otherwise the
          // specialization would have
          // been taken!
          size_type subobject_size = table.size()[N-1];
          for (int p=P-1; p>1; --p)
            subobject_size *= table.size()[N-p];
          const iterator new_data = data + i*subobject_size;
          return Accessor<N,T,C,P-1> (table, new_data);
        }
    }



    template <int N, typename T, bool C>
    inline
    Accessor<N,T,C,1>::Accessor (const TableType &table,
                                 const iterator    data)
      :
      table (table),
      data (data)
    {}



    template <int N, typename T, bool C>
    inline
    Accessor<N,T,C,1>::Accessor (const Accessor &a)
      :
      table (a.table),
      data (a.data)
    {}



    template <int N, typename T, bool C>
    inline
    typename Accessor<N,T,C,1>::reference
    Accessor<N,T,C,1>::operator [] (const size_type i) const
    {
      AssertIndexRange (i, table.size()[N-1]);
      return *(data+i);
    }



    template <int N, typename T, bool C>
    inline
    typename Accessor<N,T,C,1>::size_type
    Accessor<N,T,C,1>::size () const
    {
      return table.size()[N-1];
    }



    template <int N, typename T, bool C>
    inline
    typename Accessor<N,T,C,1>::iterator
    Accessor<N,T,C,1>::begin () const
    {
      return data;
    }



    template <int N, typename T, bool C>
    inline
    typename Accessor<N,T,C,1>::iterator
    Accessor<N,T,C,1>::end () const
    {
      return data+table.size()[N-1];
    }
  }
}



template <int N, typename T>
inline
TableBase<N,T> &
TableBase<N,T>::operator = (const TableBase<N,T> &m)
{
  if (!m.empty())
    values = m.values;
  reinit (m.size(), true);

  return *this;
}



template <int N, typename T>
template <typename T2>
inline
TableBase<N,T> &
TableBase<N,T>::operator = (const TableBase<N,T2> &m)
{
  reinit (m.size(), true);
  if (!empty())
    std::copy (m.values.begin(), m.values.begin() + n_elements(),
               values.begin());

  return *this;
}



template <int N, typename T>
inline
TableBase<N,T> &
TableBase<N,T>::operator = (TableBase<N,T> &&m) noexcept
{
  static_cast<Subscriptor &>(*this) = std::move(m);
  values = std::move(m.values);
  table_size = m.table_size;
  m.table_size = TableIndices<N>();

  return *this;
}



template <int N, typename T>
inline
bool
TableBase<N,T>::operator == (const TableBase<N,T> &T2)  const
{
  return (values == T2.values);
}



template <int N, typename T>
inline
void
TableBase<N,T>::reset_values ()
{
  // use parallel set operation
  if (n_elements() != 0)
    values.fill(T());
}



template <int N, typename T>
inline
void
TableBase<N,T>::fill (const T &value)
{
  if (n_elements() != 0)
    values.fill(value);
}




template <int N, typename T>
inline
void
TableBase<N,T>::reinit (const TableIndices<N> &new_sizes,
                        const bool             omit_default_initialization)
{
  table_size = new_sizes;

  const size_type new_size = n_elements();

  // if zero size was given: free all memory
  if (new_size == 0)
    {
      values.resize (0);
      // set all sizes to zero, even
      // if one was previously
      // nonzero. This simplifies
      // some assertions.
      table_size = TableIndices<N>();

      return;
    }

  // adjust values field. If it was empty before, we can simply call resize(),
  // which can set all the data fields. Otherwise, select the fast resize and
  // manually fill in all the elements as required by the design of this
  // class. (Selecting another code for the empty case ensures that we touch
  // the memory only once for non-trivial classes that need to initialize the
  // memory also in resize_fast.)
  if (!omit_default_initialization)
    {
      if (values.empty())
        values.resize(new_size);
      else
        {
          values.resize_fast(new_size);
          values.fill();
        }
    }
  else
    values.resize_fast (new_size);
}



template <int N, typename T>
inline
const TableIndices<N> &
TableBase<N,T>::size () const
{
  return table_size;
}



template <int N, typename T>
inline
typename TableBase<N,T>::size_type
TableBase<N,T>::size (const unsigned int i) const
{
  Assert (i<N, ExcIndexRange(i,0,N));
  return table_size[i];
}



template <int N, typename T>
inline
typename TableBase<N,T>::size_type
TableBase<N,T>::n_elements () const
{
  size_type s = 1;
  for (unsigned int n=0; n<N; ++n)
    s *= table_size[n];
  return s;
}



template <int N, typename T>
inline
bool
TableBase<N,T>::empty () const
{
  return (n_elements() == 0);
}



namespace internal
{
  namespace TableImplementation
  {
    template <typename InputIterator, typename T>
    void fill_Fortran_style (InputIterator  entries,
                             TableBase<1,T>  &table)
    {
      using size_type = typename TableBase<1,T>::size_type;
      for (size_type i=0; i<table.size()[0]; ++i)
        table(TableIndices<1>(i)) = *entries++;
    }


    template <typename InputIterator, typename T>
    void fill_Fortran_style (InputIterator  entries,
                             TableBase<2,T>  &table)
    {
      using size_type = typename TableBase<2,T>::size_type;
      for (size_type j=0; j<table.size()[1]; ++j)
        for (size_type i=0; i<table.size()[0]; ++i)
          table(TableIndices<2>(i,j)) = *entries++;
    }


    template <typename InputIterator, typename T>
    void fill_Fortran_style (InputIterator  entries,
                             TableBase<3,T>  &table)
    {
      using size_type = typename TableBase<3,T>::size_type;
      for (size_type k=0; k<table.size()[2]; ++k)
        for (size_type j=0; j<table.size()[1]; ++j)
          for (size_type i=0; i<table.size()[0]; ++i)
            table(TableIndices<3>(i,j,k)) = *entries++;
    }


    template <typename InputIterator, typename T, int N>
    void fill_Fortran_style (InputIterator,
                             TableBase<N,T> &)
    {
      Assert (false, ExcNotImplemented());
    }
  }
}


template <int N, typename T>
template <typename InputIterator>
inline
void
TableBase<N,T>::fill (InputIterator entries,
                      const bool C_style_indexing)
{
  Assert (n_elements() != 0,
          ExcMessage("Trying to fill an empty matrix."));

  if (C_style_indexing)
    for (typename AlignedVector<T>::iterator p = values.begin();
         p != values.end(); ++p)
      *p = *entries++;
  else
    internal::TableImplementation::fill_Fortran_style (entries, *this);
}



template <int N, typename T>
inline
void
TableBase<N,T>::swap (TableBase<N,T> &v)
{
  values.swap(v.values);
  std::swap (table_size, v.table_size);
}



template <int N, typename T>
inline
std::size_t
TableBase<N,T>::memory_consumption () const
{
  return sizeof(*this) + MemoryConsumption::memory_consumption(values);
}



template <int N, typename T>
inline
typename TableBase<N,T>::size_type
TableBase<N,T>::position (const TableIndices<N> &indices) const
{
  // specialize this for the
  // different numbers of dimensions,
  // to make the job somewhat easier
  // for the compiler. have the
  // general formula nevertheless:
  switch (N)
    {
    case 1:
      return indices[0];
    case 2:
      return size_type(indices[0])*table_size[1] + indices[1];
    case 3:
      return ((size_type(indices[0])*table_size[1] + indices[1])*table_size[2]
              + indices[2]);
    default:
    {
      unsigned int s = indices[0];
      for (unsigned int n=1; n<N; ++n)
        s = s*table_size[n] + indices[n];
      return s;
    }
    }
}



template <int N, typename T>
inline
typename AlignedVector<T>::const_reference
TableBase<N,T>::operator () (const TableIndices<N> &indices) const
{
  for (unsigned int n=0; n<N; ++n)
    AssertIndexRange (indices[n], table_size[n]);
  return el(indices);
}



template <int N, typename T>
inline
typename AlignedVector<T>::reference
TableBase<N,T>::operator () (const TableIndices<N> &indices)
{
  for (unsigned int n=0; n<N; ++n)
    AssertIndexRange (indices[n], table_size[n]);
  return el(indices);
}



template <int N, typename T>
inline
typename AlignedVector<T>::const_reference
TableBase<N,T>::el (const TableIndices<N> &indices) const
{
  return values[position(indices)];
}



template <int N, typename T>
inline
typename AlignedVector<T>::reference
TableBase<N,T>::el (const TableIndices<N> &indices)
{
  AssertIndexRange (position(indices), values.size());
  return values[position(indices)];
}



template <typename T>
inline
Table<1,T>::Table (const size_type size)
  :
  TableBase<1,T> (TableIndices<1> (size))
{}



template <typename T>
template <typename InputIterator>
inline
Table<1,T>::Table (const size_type size,
                   InputIterator entries,
                   const bool C_style_indexing)
  :
  TableBase<1,T> (TableIndices<1> (size),
                  entries,
                  C_style_indexing)
{}



template <typename T>
inline
typename AlignedVector<T>::const_reference
Table<1,T>::operator [] (const size_type i) const
{
  AssertIndexRange (i, this->table_size[0]);
  return this->values[i];
}



template <typename T>
inline
typename AlignedVector<T>::reference
Table<1,T>::operator [] (const size_type i)
{
  AssertIndexRange (i, this->table_size[0]);
  return this->values[i];
}



template <typename T>
inline
typename AlignedVector<T>::const_reference
Table<1,T>::operator () (const size_type i) const
{
  AssertIndexRange (i, this->table_size[0]);
  return this->values[i];
}



template <typename T>
inline
typename AlignedVector<T>::reference
Table<1,T>::operator () (const size_type i)
{
  AssertIndexRange (i, this->table_size[0]);
  return this->values[i];
}



template <typename T>
inline
typename AlignedVector<T>::const_reference
Table<1,T>::operator () (const TableIndices<1> &indices) const
{
  return TableBase<1,T>::operator () (indices);
}



template <typename T>
inline
typename AlignedVector<T>::reference
Table<1,T>::operator () (const TableIndices<1> &indices)
{
  return TableBase<1,T>::operator () (indices);
}


//---------------------------------------------------------------------------



template <typename T>
inline
Table<2,T>::Table (const size_type size1,
                   const size_type size2)
  :
  TableBase<2,T> (TableIndices<2> (size1, size2))
{}



template <typename T>
template <typename InputIterator>
inline
Table<2,T>::Table (const size_type size1,
                   const size_type size2,
                   InputIterator entries,
                   const bool C_style_indexing)
  :
  TableBase<2,T> (TableIndices<2> (size1, size2),
                  entries,
                  C_style_indexing)
{}



template <typename T>
inline
void
Table<2,T>::reinit (const size_type size1,
                    const size_type size2,
                    const bool         omit_default_initialization)
{
  this->TableBase<2,T>::reinit (TableIndices<2> (size1, size2),omit_default_initialization);
}



template <typename T>
inline
::internal::TableBaseAccessors::Accessor<2,T,true,1>
Table<2,T>::operator [] (const size_type i) const
{
  AssertIndexRange (i, this->table_size[0]);
  return ::internal::TableBaseAccessors::Accessor<2,T,true,1>(*this,
         this->values.begin()+size_type(i)*n_cols());
}



template <typename T>
inline
::internal::TableBaseAccessors::Accessor<2,T,false,1>
Table<2,T>::operator [] (const size_type i)
{
  AssertIndexRange (i, this->table_size[0]);
  return ::internal::TableBaseAccessors::Accessor<2,T,false,1>(*this,
         this->values.begin()+size_type(i)*n_cols());
}



template <typename T>
inline
typename AlignedVector<T>::const_reference
Table<2,T>::operator () (const size_type i,
                         const size_type j) const
{
  AssertIndexRange (i, this->table_size[0]);
  AssertIndexRange (j, this->table_size[1]);
  return this->values[size_type(i)*this->table_size[1]+j];
}



template <typename T>
inline
typename AlignedVector<T>::reference
Table<2,T>::operator () (const size_type i,
                         const size_type j)
{
  AssertIndexRange (i, this->table_size[0]);
  AssertIndexRange (j, this->table_size[1]);
  return this->values[size_type(i)*this->table_size[1]+j];
}



template <typename T>
inline
typename AlignedVector<T>::const_reference
Table<2,T>::operator () (const TableIndices<2> &indices) const
{
  return TableBase<2,T>::operator () (indices);
}



template <typename T>
inline
typename AlignedVector<T>::reference
Table<2,T>::operator () (const TableIndices<2> &indices)
{
  return TableBase<2,T>::operator () (indices);
}



template <typename T>
inline
typename AlignedVector<T>::const_reference
Table<2,T>::el (const size_type i,
                const size_type j) const
{
  return this->values[size_type(i)*this->table_size[1]+j];
}



template <typename T>
inline
typename AlignedVector<T>::reference
Table<2,T>::el (const size_type i,
                const size_type j)
{
  return this->values[size_type(i)*this->table_size[1]+j];
}



template <typename T>
inline
typename Table<2,T>::size_type
Table<2,T>::n_rows () const
{
  return this->table_size[0];
}



template <typename T>
inline
typename Table<2,T>::size_type
Table<2,T>::n_cols () const
{
  return this->table_size[1];
}



//---------------------------------------------------------------------------
namespace TransposeTableIterators
{
  template <typename T, bool Constness>
  inline
  AccessorBase<T, Constness>::AccessorBase()
    :
    container(nullptr),
    linear_index(std::numeric_limits<decltype(linear_index)>::max())
  {}



  template <typename T, bool Constness>
  inline
  AccessorBase<T, Constness>::AccessorBase(const container_pointer_type table)
    :
    container(table),
    linear_index(container->values.size())
  {}



  template <typename T, bool Constness>
  inline
  AccessorBase<T, Constness>::AccessorBase(const AccessorBase<T, false> &a)
    :
    container(a.container),
    linear_index(a.linear_index)
  {}



  template <typename T, bool Constness>
  inline
  AccessorBase<T, Constness>::AccessorBase(const container_pointer_type table,
                                           const std::ptrdiff_t         index)
    :
    container(table),
    linear_index(index)
  {
    Assert(0 <= linear_index && linear_index < container->values.size() + 1,
           ExcMessage("The current iterator points outside of the table and is "
                      "not the end iterator."));
  }



  template <typename T, bool Constness>
  inline
  const T &
  AccessorBase<T, Constness>::value() const
  {
    Assert(0 <= linear_index && linear_index < container->values.size(),
           ExcMessage("The current iterator points outside of the table."));
    return this->container->values[linear_index];
  }



  template <typename T, bool Constness>
  inline
  typename AccessorBase<T, Constness>::size_type
  AccessorBase<T, Constness>::AccessorBase::row() const
  {
    Assert(!container->empty(), ExcMessage("An empty table has no rows or columns."));
    const auto row_n = linear_index % container->n_rows();
    Assert(0 <= row_n && row_n < container->n_rows(),
           ExcMessage("The current iterator points outside the table."));
    return row_n;
  }



  template <typename T, bool Constness>
  inline
  typename AccessorBase<T, Constness>::size_type
  AccessorBase<T, Constness>::AccessorBase::column() const
  {
    Assert(!container->empty(), ExcMessage("An empty table has no rows or columns."));
    const auto column_n = linear_index/container->n_rows();
    Assert(0 <= column_n && column_n < container->n_cols(),
           ExcMessage("The current iterator points outside the table."));
    return column_n;
  }


  template <typename T>
  inline
  const Accessor<T, false> &
  Accessor<T, false>::operator = (const T &t) const
  {
    Assert(0 <= this->linear_index && this->linear_index < this->container->values.size(),
           ExcMessage("The current iterator points outside of the table."));
    this->container->values[this->linear_index] = t;
    return *this;
  }



  template <typename T>
  inline
  const Accessor<T, false> &
  Accessor<T, false>::operator = (T &&t) const
  {
    Assert(0 <= this->linear_index && this->linear_index < this->container->values.size(),
           ExcMessage("The current iterator points outside of the table."));
    this->container->values[this->linear_index] = t;
    return *this;
  }



  template <typename T>
  inline
  T &
  Accessor<T, false>::value() const
  {
    Assert(0 <= this->linear_index && this->linear_index < this->container->values.size(),
           ExcMessage("The current iterator points outside of the table."));
    return this->container->values[this->linear_index];
  }



  template <typename T, bool Constness>
  Iterator<T, Constness>::Iterator(const Accessor<T, Constness> &a)
    :
    LinearIndexIterator<Iterator<T, Constness>, Accessor<T, Constness>>(a)
  {}



  template <typename T, bool Constness>
  Iterator<T, Constness>::Iterator(const container_pointer_type table)
    :
    LinearIndexIterator<Iterator<T, Constness>, Accessor<T, Constness>>(Accessor<T, Constness>(table))
  {}



  template <typename T, bool Constness>
  Iterator<T, Constness>::Iterator(const Iterator<T, false> &i)
    :
    LinearIndexIterator<Iterator<T, Constness>, Accessor<T, Constness>>(*i)
  {}




  template <typename T, bool Constness>
  Iterator<T, Constness>::Iterator(const container_pointer_type table,
                                   const size_type              row_n,
                                   const size_type              col_n)
    :
    Iterator(table, table->n_rows()*col_n + row_n)
  {}



  template <typename T, bool Constness>
  Iterator<T, Constness>::Iterator
  (const container_pointer_type table,
   const std::ptrdiff_t         linear_index)
    :
    LinearIndexIterator<Iterator<T, Constness>, Accessor<T, Constness>>
        (Accessor<T, Constness>(table, linear_index))
  {}
}



//---------------------------------------------------------------------------
template <typename T>
inline
TransposeTable<T>::TransposeTable (const size_type size1,
                                   const size_type size2)
  :
  TableBase<2,T> (TableIndices<2> (size2, size1))
{}



template <typename T>
inline
void
TransposeTable<T>::reinit (const size_type size1,
                           const size_type size2,
                           const bool      omit_default_initialization)
{
  this->TableBase<2,T>::reinit (TableIndices<2> (size2, size1), omit_default_initialization);
}



template <typename T>
inline
typename TransposeTable<T>::const_reference
TransposeTable<T>::operator () (const size_type i,
                                const size_type j) const
{
  AssertIndexRange (i, this->table_size[1]);
  AssertIndexRange (j, this->table_size[0]);
  return this->values[size_type(j)*this->table_size[1]+i];
}



template <typename T>
inline
typename TransposeTable<T>::reference
TransposeTable<T>::operator () (const size_type i,
                                const size_type j)
{
  AssertIndexRange (i, this->table_size[1]);
  AssertIndexRange (j, this->table_size[0]);
  return this->values[size_type(j)*this->table_size[1]+i];
}



template <typename T>
inline
typename TransposeTable<T>::const_reference
TransposeTable<T>::el (const size_type i,
                       const size_type j) const
{
  return this->values[size_type(j)*this->table_size[1]+i];
}



template <typename T>
inline
typename TransposeTable<T>::reference
TransposeTable<T>::el (const size_type i,
                       const size_type j)
{
  return this->values[size_type(j)*this->table_size[1]+i];
}



template <typename T>
inline
typename TransposeTable<T>::size_type
TransposeTable<T>::n_rows () const
{
  return this->table_size[1];
}



template <typename T>
inline
typename TransposeTable<T>::size_type
TransposeTable<T>::n_cols () const
{
  return this->table_size[0];
}



template <typename T>
inline
typename TransposeTable<T>::iterator
TransposeTable<T>::begin ()
{
  return typename TransposeTable<T>::iterator(this, 0, 0);
}



template <typename T>
inline
typename TransposeTable<T>::const_iterator
TransposeTable<T>::begin () const
{
  return typename TransposeTable<T>::const_iterator(this, 0, 0);
}



template <typename T>
inline
typename TransposeTable<T>::iterator
TransposeTable<T>::end ()
{
  return typename TransposeTable<T>::iterator(this);
}



template <typename T>
inline
typename TransposeTable<T>::const_iterator
TransposeTable<T>::end () const
{
  return typename TransposeTable<T>::const_iterator(this);
}
//---------------------------------------------------------------------------



template <typename T>
inline
Table<3,T>::Table (const size_type size1,
                   const size_type size2,
                   const size_type size3)
  :
  TableBase<3,T> (TableIndices<3> (size1, size2, size3))
{}



template <typename T>
template <typename InputIterator>
inline
Table<3,T>::Table (const size_type size1,
                   const size_type size2,
                   const size_type size3,
                   InputIterator entries,
                   const bool C_style_indexing)
  :
  TableBase<3,T> (TableIndices<3> (size1, size2, size3),
                  entries,
                  C_style_indexing)
{}



template <typename T>
inline
::internal::TableBaseAccessors::Accessor<3,T,true,2>
Table<3,T>::operator [] (const size_type i) const
{
  AssertIndexRange (i, this->table_size[0]);
  const size_type subobject_size = size_type(this->table_size[1]) *
                                   this->table_size[2];
  return (::internal::TableBaseAccessors::Accessor<3,T,true,2>
          (*this,
           this->values.begin() + i*subobject_size));
}



template <typename T>
inline
::internal::TableBaseAccessors::Accessor<3,T,false,2>
Table<3,T>::operator [] (const size_type i)
{
  AssertIndexRange (i, this->table_size[0]);
  const size_type subobject_size = size_type(this->table_size[1]) *
                                   this->table_size[2];
  return (::internal::TableBaseAccessors::Accessor<3,T,false,2>
          (*this,
           this->values.begin() + i*subobject_size));
}



template <typename T>
inline
typename AlignedVector<T>::const_reference
Table<3,T>::operator () (const size_type i,
                         const size_type j,
                         const size_type k) const
{
  AssertIndexRange (i, this->table_size[0]);
  AssertIndexRange (j, this->table_size[1]);
  AssertIndexRange (k, this->table_size[2]);
  return this->values[(size_type(i)*this->table_size[1]+j)
                      *this->table_size[2] + k];
}



template <typename T>
inline
typename AlignedVector<T>::reference
Table<3,T>::operator () (const size_type i,
                         const size_type j,
                         const size_type k)
{
  AssertIndexRange (i, this->table_size[0]);
  AssertIndexRange (j, this->table_size[1]);
  AssertIndexRange (k, this->table_size[2]);
  return this->values[(size_type(i)*this->table_size[1]+j)
                      *this->table_size[2] + k];
}



template <typename T>
inline
typename AlignedVector<T>::const_reference
Table<3,T>::operator () (const TableIndices<3> &indices) const
{
  return TableBase<3,T>::operator () (indices);
}



template <typename T>
inline
typename AlignedVector<T>::reference
Table<3,T>::operator () (const TableIndices<3> &indices)
{
  return TableBase<3,T>::operator () (indices);
}



template <typename T>
inline
Table<4,T>::Table (const size_type size1,
                   const size_type size2,
                   const size_type size3,
                   const size_type size4)
  :
  TableBase<4,T> (TableIndices<4> (size1, size2, size3, size4))
{}



template <typename T>
inline
::internal::TableBaseAccessors::Accessor<4,T,true,3>
Table<4,T>::operator [] (const size_type i) const
{
  AssertIndexRange (i, this->table_size[0]);
  const size_type subobject_size = size_type(this->table_size[1]) *
                                   this->table_size[2] *
                                   this->table_size[3];
  return (::internal::TableBaseAccessors::Accessor<4,T,true,3>
          (*this,
           this->values.begin() + i*subobject_size));
}



template <typename T>
inline
::internal::TableBaseAccessors::Accessor<4,T,false,3>
Table<4,T>::operator [] (const size_type i)
{
  AssertIndexRange (i, this->table_size[0]);
  const size_type subobject_size = size_type(this->table_size[1]) *
                                   this->table_size[2] *
                                   this->table_size[3];
  return (::internal::TableBaseAccessors::Accessor<4,T,false,3>
          (*this,
           this->values.begin() + i*subobject_size));
}



template <typename T>
inline
typename AlignedVector<T>::const_reference
Table<4,T>::operator () (const size_type i,
                         const size_type j,
                         const size_type k,
                         const size_type l) const
{
  AssertIndexRange (i, this->table_size[0]);
  AssertIndexRange (j, this->table_size[1]);
  AssertIndexRange (k, this->table_size[2]);
  AssertIndexRange (l, this->table_size[3]);
  return this->values[((size_type(i)*this->table_size[1]+j)
                       *this->table_size[2] + k)
                      *this->table_size[3] + l];
}



template <typename T>
inline
typename AlignedVector<T>::reference
Table<4,T>::operator () (const size_type i,
                         const size_type j,
                         const size_type k,
                         const size_type l)
{
  AssertIndexRange (i, this->table_size[0]);
  AssertIndexRange (j, this->table_size[1]);
  AssertIndexRange (k, this->table_size[2]);
  AssertIndexRange (l, this->table_size[3]);
  return this->values[((size_type(i)*this->table_size[1]+j)
                       *this->table_size[2] + k)
                      *this->table_size[3] + l];
}



template <typename T>
inline
typename AlignedVector<T>::const_reference
Table<4,T>::operator () (const TableIndices<4> &indices) const
{
  return TableBase<4,T>::operator () (indices);
}



template <typename T>
inline
typename AlignedVector<T>::reference
Table<4,T>::operator () (const TableIndices<4> &indices)
{
  return TableBase<4,T>::operator () (indices);
}



template <typename T>
inline
Table<5,T>::Table (const size_type size1,
                   const size_type size2,
                   const size_type size3,
                   const size_type size4,
                   const size_type size5)
  :
  TableBase<5,T> (TableIndices<5> (size1, size2, size3, size4, size5))
{}



template <typename T>
inline
::internal::TableBaseAccessors::Accessor<5,T,true,4>
Table<5,T>::operator [] (const size_type i) const
{
  AssertIndexRange (i, this->table_size[0]);
  const size_type subobject_size = size_type(this->table_size[1]) *
                                   this->table_size[2] *
                                   this->table_size[3] *
                                   this->table_size[4];
  return (::internal::TableBaseAccessors::Accessor<5,T,true,4>
          (*this,
           this->values.begin() + i*subobject_size));
}



template <typename T>
inline
::internal::TableBaseAccessors::Accessor<5,T,false,4>
Table<5,T>::operator [] (const size_type i)
{
  AssertIndexRange (i, this->table_size[0]);
  const size_type subobject_size = size_type(this->table_size[1]) *
                                   this->table_size[2] *
                                   this->table_size[3] *
                                   this->table_size[4];
  return (::internal::TableBaseAccessors::Accessor<5,T,false,4>
          (*this,
           this->values.begin() + i*subobject_size));
}



template <typename T>
inline
typename AlignedVector<T>::const_reference
Table<5,T>::operator () (const size_type i,
                         const size_type j,
                         const size_type k,
                         const size_type l,
                         const size_type m) const
{
  AssertIndexRange (i, this->table_size[0]);
  AssertIndexRange (j, this->table_size[1]);
  AssertIndexRange (k, this->table_size[2]);
  AssertIndexRange (l, this->table_size[3]);
  AssertIndexRange (m, this->table_size[4]);
  return this->values[(((size_type(i)*this->table_size[1]+j)
                        *this->table_size[2] + k)
                       *this->table_size[3] + l)
                      *this->table_size[4] + m];
}



template <typename T>
inline
typename AlignedVector<T>::reference
Table<5,T>::operator () (const size_type i,
                         const size_type j,
                         const size_type k,
                         const size_type l,
                         const size_type m)
{
  AssertIndexRange (i, this->table_size[0]);
  AssertIndexRange (j, this->table_size[1]);
  AssertIndexRange (k, this->table_size[2]);
  AssertIndexRange (l, this->table_size[3]);
  AssertIndexRange (m, this->table_size[4]);
  return this->values[(((size_type(i)*this->table_size[1]+j)
                        *this->table_size[2] + k)
                       *this->table_size[3] + l)
                      *this->table_size[4] + m];
}



template <typename T>
inline
typename AlignedVector<T>::const_reference
Table<5,T>::operator () (const TableIndices<5> &indices) const
{
  return TableBase<5,T>::operator () (indices);
}



template <typename T>
inline
typename AlignedVector<T>::reference
Table<5,T>::operator () (const TableIndices<5> &indices)
{
  return TableBase<5,T>::operator () (indices);
}



template <typename T>
inline
Table<6,T>::Table (const size_type size1,
                   const size_type size2,
                   const size_type size3,
                   const size_type size4,
                   const size_type size5,
                   const size_type size6)
  :
  TableBase<6,T> ()
{
  TableIndices<6> table_indices;
  table_indices[0] = size1;
  table_indices[1] = size2;
  table_indices[2] = size3;
  table_indices[3] = size4;
  table_indices[4] = size5;
  table_indices[5] = size6;

  TableBase<6,T>::reinit(table_indices);
}



template <typename T>
inline
::internal::TableBaseAccessors::Accessor<6,T,true,5>
Table<6,T>::operator [] (const size_type i) const
{
  AssertIndexRange (i, this->table_size[0]);
  const size_type subobject_size = size_type(this->table_size[1]) *
                                   this->table_size[2] *
                                   this->table_size[3] *
                                   this->table_size[4] *
                                   this->table_size[5];
  return (::internal::TableBaseAccessors::Accessor<6,T,true,5>
          (*this,
           this->values.begin() + i*subobject_size));
}



template <typename T>
inline
::internal::TableBaseAccessors::Accessor<6,T,false,5>
Table<6,T>::operator [] (const size_type i)
{
  AssertIndexRange (i, this->table_size[0]);
  const size_type subobject_size = size_type(this->table_size[1]) *
                                   this->table_size[2] *
                                   this->table_size[3] *
                                   this->table_size[4] *
                                   this->table_size[5];
  return (::internal::TableBaseAccessors::Accessor<6,T,false,5>
          (*this,
           this->values.begin() + i*subobject_size));
}



template <typename T>
inline
typename AlignedVector<T>::const_reference
Table<6,T>::operator () (const size_type i,
                         const size_type j,
                         const size_type k,
                         const size_type l,
                         const size_type m,
                         const size_type n) const
{
  AssertIndexRange (i, this->table_size[0]);
  AssertIndexRange (j, this->table_size[1]);
  AssertIndexRange (k, this->table_size[2]);
  AssertIndexRange (l, this->table_size[3]);
  AssertIndexRange (m, this->table_size[4]);
  AssertIndexRange (n, this->table_size[5]);
  return this->values[((((size_type(i)*this->table_size[1]+j)
                         *this->table_size[2] + k)
                        *this->table_size[3] + l)
                       *this->table_size[4] + m)
                      *this->table_size[5] + n];
}



template <typename T>
inline
typename AlignedVector<T>::reference
Table<6,T>::operator () (const size_type i,
                         const size_type j,
                         const size_type k,
                         const size_type l,
                         const size_type m,
                         const size_type n)
{
  AssertIndexRange (i, this->table_size[0]);
  AssertIndexRange (j, this->table_size[1]);
  AssertIndexRange (k, this->table_size[2]);
  AssertIndexRange (l, this->table_size[3]);
  AssertIndexRange (m, this->table_size[4]);
  AssertIndexRange (n, this->table_size[5]);
  return this->values[((((size_type(i)*this->table_size[1]+j)
                         *this->table_size[2] + k)
                        *this->table_size[3] + l)
                       *this->table_size[4] + m)
                      *this->table_size[5] + n];
}



template <typename T>
inline
typename AlignedVector<T>::const_reference
Table<6,T>::operator () (const TableIndices<6> &indices) const
{
  return TableBase<6,T>::operator () (indices);
}



template <typename T>
inline
typename AlignedVector<T>::reference
Table<6,T>::operator () (const TableIndices<6> &indices)
{
  return TableBase<6,T>::operator () (indices);
}



template <typename T>
inline
Table<7,T>::Table (const size_type size1,
                   const size_type size2,
                   const size_type size3,
                   const size_type size4,
                   const size_type size5,
                   const size_type size6,
                   const size_type size7)
  :
  TableBase<7,T> ()
{
  TableIndices<7> table_indices;
  table_indices[0] = size1;
  table_indices[1] = size2;
  table_indices[2] = size3;
  table_indices[3] = size4;
  table_indices[4] = size5;
  table_indices[5] = size6;
  table_indices[6] = size7;

  TableBase<7,T>::reinit(table_indices);
}



template <typename T>
inline
::internal::TableBaseAccessors::Accessor<7,T,true,6>
Table<7,T>::operator [] (const size_type i) const
{
  AssertIndexRange (i, this->table_size[0]);
  const size_type subobject_size = size_type(this->table_size[1]) *
                                   this->table_size[2] *
                                   this->table_size[3] *
                                   this->table_size[4] *
                                   this->table_size[5] *
                                   this->table_size[6];
  return (::internal::TableBaseAccessors::Accessor<7,T,true,6>
          (*this,
           this->values.begin() + i*subobject_size));
}



template <typename T>
inline
::internal::TableBaseAccessors::Accessor<7,T,false,6>
Table<7,T>::operator [] (const size_type i)
{
  AssertIndexRange (i, this->table_size[0]);
  const size_type subobject_size = size_type(this->table_size[1]) *
                                   this->table_size[2] *
                                   this->table_size[3] *
                                   this->table_size[4] *
                                   this->table_size[5] *
                                   this->table_size[6];
  return (::internal::TableBaseAccessors::Accessor<7,T,false,6>
          (*this,
           this->values.begin() + i*subobject_size));
}



template <typename T>
inline
typename AlignedVector<T>::const_reference
Table<7,T>::operator () (const size_type i,
                         const size_type j,
                         const size_type k,
                         const size_type l,
                         const size_type m,
                         const size_type n,
                         const size_type o) const
{
  AssertIndexRange (i, this->table_size[0]);
  AssertIndexRange (j, this->table_size[1]);
  AssertIndexRange (k, this->table_size[2]);
  AssertIndexRange (l, this->table_size[3]);
  AssertIndexRange (m, this->table_size[4]);
  AssertIndexRange (n, this->table_size[5]);
  AssertIndexRange (o, this->table_size[6]);
  return this->values[(((((size_type(i)*this->table_size[1]+j)
                          *this->table_size[2] + k)
                         *this->table_size[3] + l)
                        *this->table_size[4] + m)
                       *this->table_size[5] + n)
                      *this->table_size[6] + o];
}



template <typename T>
inline
typename AlignedVector<T>::reference
Table<7,T>::operator () (const size_type i,
                         const size_type j,
                         const size_type k,
                         const size_type l,
                         const size_type m,
                         const size_type n,
                         const size_type o)
{
  AssertIndexRange (i, this->table_size[0]);
  AssertIndexRange (j, this->table_size[1]);
  AssertIndexRange (k, this->table_size[2]);
  AssertIndexRange (l, this->table_size[3]);
  AssertIndexRange (m, this->table_size[4]);
  AssertIndexRange (n, this->table_size[5]);
  AssertIndexRange (o, this->table_size[6]);
  return this->values[(((((size_type(i)*this->table_size[1]+j)
                          *this->table_size[2] + k)
                         *this->table_size[3] + l)
                        *this->table_size[4] + m)
                       *this->table_size[5] + n)
                      *this->table_size[6] + o];
}



template <typename T>
inline
typename AlignedVector<T>::const_reference
Table<7,T>::operator () (const TableIndices<7> &indices) const
{
  return TableBase<7,T>::operator () (indices);
}



template <typename T>
inline
typename AlignedVector<T>::reference
Table<7,T>::operator () (const TableIndices<7> &indices)
{
  return TableBase<7,T>::operator () (indices);
}


#endif // DOXYGEN



template <int N, typename T>
inline
void swap (TableBase<N,T> &u, TableBase<N,T> &v)
{
  u.swap (v);
}

DEAL_II_NAMESPACE_CLOSE

#endif