table.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2002 - 2017 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 <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 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 ();

    public:

      Accessor (const Accessor &a);

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

      DeclException3 (ExcIndexRange, int, int, int,
                      << "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 ();

    public:
      Accessor (const Accessor &a);


      reference operator [] (const unsigned int) const;

      unsigned int 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 ();

  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);

#ifdef DEAL_II_WITH_CXX11

  TableBase (TableBase<N,T> &&src);
#endif

  ~TableBase ();

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

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

#ifdef DEAL_II_WITH_CXX11

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

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

  void reset_values ();

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

  unsigned int 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 ();

  Table (const unsigned int size);

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

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

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

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

  typename AlignedVector<T>::reference
  operator () (const unsigned int 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 ();

  Table (const unsigned int size1,
         const unsigned int size2);

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

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

  using TableBase<2,T>::reinit;

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

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

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


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

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

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


  unsigned int n_rows () const;

  unsigned int n_cols () const;

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

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



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

  Table ();

  Table (const unsigned int size1,
         const unsigned int size2,
         const unsigned int size3);

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

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

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

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


  typename AlignedVector<T>::reference operator () (const unsigned int i,
                                                    const unsigned int j,
                                                    const unsigned int 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 ();

  Table (const unsigned int size1,
         const unsigned int size2,
         const unsigned int size3,
         const unsigned int size4);

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

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

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


  typename AlignedVector<T>::reference operator () (const unsigned int i,
                                                    const unsigned int j,
                                                    const unsigned int k,
                                                    const unsigned int 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 ();

  Table (const unsigned int size1,
         const unsigned int size2,
         const unsigned int size3,
         const unsigned int size4,
         const unsigned int size5);

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

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

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

  typename AlignedVector<T>::reference operator () (const unsigned int i,
                                                    const unsigned int j,
                                                    const unsigned int k,
                                                    const unsigned int l,
                                                    const unsigned int 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 ();

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

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

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

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

  typename AlignedVector<T>::reference operator () (const unsigned int i,
                                                    const unsigned int j,
                                                    const unsigned int k,
                                                    const unsigned int l,
                                                    const unsigned int m,
                                                    const unsigned int 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 ();

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

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

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

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

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

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

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



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

  TransposeTable ();

  TransposeTable (const unsigned int size1,
                  const unsigned int size2);

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

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

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

  unsigned int n_rows () const;

  unsigned int n_cols () const;

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

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




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

#ifndef DOXYGEN

template <int N, typename T>
TableBase<N,T>::TableBase ()
{}



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());
}



#ifdef DEAL_II_WITH_CXX11

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

#endif



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>::Accessor ()
      :
      table (*static_cast<const TableType *>(0)),
      data (0)
    {
      // accessor objects are only
      // temporary objects, so should
      // not need to be copied around
      Assert (false, ExcInternalError());
    }



    template <int N, typename T, bool C, unsigned int P>
    inline
    Accessor<N,T,C,P-1>
    Accessor<N,T,C,P>::operator [] (const unsigned int 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 ()
      :
      table (*static_cast<const TableType *>(0)),
      data (0)
    {
      // accessor objects are only
      // temporary objects, so should
      // not need to be copied around
      Assert (false, ExcInternalError());
    }



    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 unsigned int i) const
    {
      Assert (i < table.size()[N-1],
              ExcIndexRange (i, 0, table.size()[N-1]));
      return *(data+i);
    }



    template <int N, typename T, bool C>
    inline
    unsigned int
    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 ()
{}



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;
}



#ifdef DEAL_II_WITH_CXX11

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

  return *this;
}

#endif



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, T());
      else
        {
          values.resize_fast(new_size);
          values.fill(T());
        }
    }
  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
unsigned int
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 Table
  {
    template <typename InputIterator, typename T>
    void fill_Fortran_style (InputIterator  entries,
                             TableBase<1,T>  &table)
    {
      for (unsigned int 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)
    {
      for (unsigned int j=0; j<table.size()[1]; ++j)
        for (unsigned int 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)
    {
      for (unsigned int k=0; k<table.size()[2]; ++k)
        for (unsigned int j=0; j<table.size()[1]; ++j)
          for (unsigned int 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::Table::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:
    {
      size_type 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)
    Assert (indices[n] < table_size[n],
            ExcIndexRange (indices[n], 0, 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)
    Assert (indices[n] < table_size[n],
            ExcIndexRange (indices[n], 0, 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)
{
  Assert (position(indices) < values.size(),
          ExcIndexRange (position(indices), 0, values.size()));
  return values[position(indices)];
}



template <typename T>
inline
Table<1,T>::Table ()
{}



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



template <typename T>
template <typename InputIterator>
inline
Table<1,T>::Table (const unsigned int 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 unsigned int i) const
{
  Assert (i < this->table_size[0],
          ExcIndexRange (i, 0, this->table_size[0]));
  return this->values[i];
}



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



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



template <typename T>
inline
typename AlignedVector<T>::reference
Table<1,T>::operator () (const unsigned int i)
{
  Assert (i < this->table_size[0],
          ExcIndexRange (i, 0, 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 ()
{}



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



template <typename T>
template <typename InputIterator>
inline
Table<2,T>::Table (const unsigned int size1,
                   const unsigned int 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 unsigned int size1,
                    const unsigned int 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 unsigned int i) const
{
  Assert (i < this->table_size[0],
          ExcIndexRange (i, 0, 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 unsigned int i)
{
  Assert (i < this->table_size[0],
          ExcIndexRange (i, 0, 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 unsigned int i,
                         const unsigned int j) const
{
  Assert (i < this->table_size[0],
          ExcIndexRange (i, 0, this->table_size[0]));
  Assert (j < this->table_size[1],
          ExcIndexRange (j, 0, 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 unsigned int i,
                         const unsigned int j)
{
  Assert (i < this->table_size[0],
          ExcIndexRange (i, 0, this->table_size[0]));
  Assert (j < this->table_size[1],
          ExcIndexRange (j, 0, 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 unsigned int i,
                const unsigned int 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 unsigned int i,
                const unsigned int j)
{
  return this->values[size_type(i)*this->table_size[1]+j];
}



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



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



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

template <typename T>
inline
TransposeTable<T>::TransposeTable ()
{}



template <typename T>
inline
TransposeTable<T>::TransposeTable (const unsigned int size1,
                                   const unsigned int size2)
  :
  TableBase<2,T> (TableIndices<2> (size2, size1))
{}



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



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



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



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



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



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



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



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


template <typename T>
inline
Table<3,T>::Table ()
{}



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



template <typename T>
template <typename InputIterator>
inline
Table<3,T>::Table (const unsigned int size1,
                   const unsigned int size2,
                   const unsigned int 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 unsigned int i) const
{
  Assert (i < this->table_size[0],
          ExcIndexRange (i, 0, 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 unsigned int i)
{
  Assert (i < this->table_size[0],
          ExcIndexRange (i, 0, 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 unsigned int i,
                         const unsigned int j,
                         const unsigned int k) const
{
  Assert (i < this->table_size[0],
          ExcIndexRange (i, 0, this->table_size[0]));
  Assert (j < this->table_size[1],
          ExcIndexRange (j, 0, this->table_size[1]));
  Assert (k < this->table_size[2],
          ExcIndexRange (k, 0, 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 unsigned int i,
                         const unsigned int j,
                         const unsigned int k)
{
  Assert (i < this->table_size[0],
          ExcIndexRange (i, 0, this->table_size[0]));
  Assert (j < this->table_size[1],
          ExcIndexRange (j, 0, this->table_size[1]));
  Assert (k < this->table_size[2],
          ExcIndexRange (k, 0, 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 ()
{}



template <typename T>
inline
Table<4,T>::Table (const unsigned int size1,
                   const unsigned int size2,
                   const unsigned int size3,
                   const unsigned int 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 unsigned int i) const
{
  Assert (i < this->table_size[0],
          ExcIndexRange (i, 0, 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 unsigned int i)
{
  Assert (i < this->table_size[0],
          ExcIndexRange (i, 0, 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 unsigned int i,
                         const unsigned int j,
                         const unsigned int k,
                         const unsigned int l) const
{
  Assert (i < this->table_size[0],
          ExcIndexRange (i, 0, this->table_size[0]));
  Assert (j < this->table_size[1],
          ExcIndexRange (j, 0, this->table_size[1]));
  Assert (k < this->table_size[2],
          ExcIndexRange (k, 0, this->table_size[2]));
  Assert (l < this->table_size[3],
          ExcIndexRange (l, 0, 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 unsigned int i,
                         const unsigned int j,
                         const unsigned int k,
                         const unsigned int l)
{
  Assert (i < this->table_size[0],
          ExcIndexRange (i, 0, this->table_size[0]));
  Assert (j < this->table_size[1],
          ExcIndexRange (j, 0, this->table_size[1]));
  Assert (k < this->table_size[2],
          ExcIndexRange (k, 0, this->table_size[2]));
  Assert (l < this->table_size[3],
          ExcIndexRange (l, 0, 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 ()
{}



template <typename T>
inline
Table<5,T>::Table (const unsigned int size1,
                   const unsigned int size2,
                   const unsigned int size3,
                   const unsigned int size4,
                   const unsigned int 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 unsigned int i) const
{
  Assert (i < this->table_size[0],
          ExcIndexRange (i, 0, 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 unsigned int i)
{
  Assert (i < this->table_size[0],
          ExcIndexRange (i, 0, 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 unsigned int i,
                         const unsigned int j,
                         const unsigned int k,
                         const unsigned int l,
                         const unsigned int m) const
{
  Assert (i < this->table_size[0],
          ExcIndexRange (i, 0, this->table_size[0]));
  Assert (j < this->table_size[1],
          ExcIndexRange (j, 0, this->table_size[1]));
  Assert (k < this->table_size[2],
          ExcIndexRange (k, 0, this->table_size[2]));
  Assert (l < this->table_size[3],
          ExcIndexRange (l, 0, this->table_size[3]));
  Assert (m < this->table_size[4],
          ExcIndexRange (m, 0, 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 unsigned int i,
                         const unsigned int j,
                         const unsigned int k,
                         const unsigned int l,
                         const unsigned int m)
{
  Assert (i < this->table_size[0],
          ExcIndexRange (i, 0, this->table_size[0]));
  Assert (j < this->table_size[1],
          ExcIndexRange (j, 0, this->table_size[1]));
  Assert (k < this->table_size[2],
          ExcIndexRange (k, 0, this->table_size[2]));
  Assert (l < this->table_size[3],
          ExcIndexRange (l, 0, this->table_size[3]));
  Assert (m < this->table_size[4],
          ExcIndexRange (m, 0, 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 ()
{}



template <typename T>
inline
Table<6,T>::Table (const unsigned int size1,
                   const unsigned int size2,
                   const unsigned int size3,
                   const unsigned int size4,
                   const unsigned int size5,
                   const unsigned int size6)
  :
  TableBase<6,T> (TableIndices<6> (size1, size2, size3, size4, size5, size6))
{}



template <typename T>
inline
::internal::TableBaseAccessors::Accessor<6,T,true,5>
Table<6,T>::operator [] (const unsigned int i) const
{
  Assert (i < this->table_size[0],
          ExcIndexRange (i, 0, 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 unsigned int i)
{
  Assert (i < this->table_size[0],
          ExcIndexRange (i, 0, 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 unsigned int i,
                         const unsigned int j,
                         const unsigned int k,
                         const unsigned int l,
                         const unsigned int m,
                         const unsigned int n) const
{
  Assert (i < this->table_size[0],
          ExcIndexRange (i, 0, this->table_size[0]));
  Assert (j < this->table_size[1],
          ExcIndexRange (j, 0, this->table_size[1]));
  Assert (k < this->table_size[2],
          ExcIndexRange (k, 0, this->table_size[2]));
  Assert (l < this->table_size[3],
          ExcIndexRange (l, 0, this->table_size[3]));
  Assert (m < this->table_size[4],
          ExcIndexRange (m, 0, this->table_size[4]));
  Assert (n < this->table_size[5],
          ExcIndexRange (n, 0, 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 unsigned int i,
                         const unsigned int j,
                         const unsigned int k,
                         const unsigned int l,
                         const unsigned int m,
                         const unsigned int n)
{
  Assert (i < this->table_size[0],
          ExcIndexRange (i, 0, this->table_size[0]));
  Assert (j < this->table_size[1],
          ExcIndexRange (j, 0, this->table_size[1]));
  Assert (k < this->table_size[2],
          ExcIndexRange (k, 0, this->table_size[2]));
  Assert (l < this->table_size[3],
          ExcIndexRange (l, 0, this->table_size[3]));
  Assert (m < this->table_size[4],
          ExcIndexRange (m, 0, this->table_size[4]));
  Assert (n < this->table_size[5],
          ExcIndexRange (n, 0, 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 ()
{}



template <typename T>
inline
Table<7,T>::Table (const unsigned int size1,
                   const unsigned int size2,
                   const unsigned int size3,
                   const unsigned int size4,
                   const unsigned int size5,
                   const unsigned int size6,
                   const unsigned int size7)
  :
  TableBase<7,T> (TableIndices<7> (size1, size2, size3, size4, size5, size6, size7))
{}



template <typename T>
inline
::internal::TableBaseAccessors::Accessor<7,T,true,6>
Table<7,T>::operator [] (const unsigned int i) const
{
  Assert (i < this->table_size[0],
          ExcIndexRange (i, 0, 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 unsigned int i)
{
  Assert (i < this->table_size[0],
          ExcIndexRange (i, 0, 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 unsigned int i,
                         const unsigned int j,
                         const unsigned int k,
                         const unsigned int l,
                         const unsigned int m,
                         const unsigned int n,
                         const unsigned int o) const
{
  Assert (i < this->table_size[0],
          ExcIndexRange (i, 0, this->table_size[0]));
  Assert (j < this->table_size[1],
          ExcIndexRange (j, 0, this->table_size[1]));
  Assert (k < this->table_size[2],
          ExcIndexRange (k, 0, this->table_size[2]));
  Assert (l < this->table_size[3],
          ExcIndexRange (l, 0, this->table_size[3]));
  Assert (m < this->table_size[4],
          ExcIndexRange (m, 0, this->table_size[4]));
  Assert (n < this->table_size[5],
          ExcIndexRange (n, 0, this->table_size[5]));
  Assert (o < this->table_size[6],
          ExcIndexRange (o, 0, 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 unsigned int i,
                         const unsigned int j,
                         const unsigned int k,
                         const unsigned int l,
                         const unsigned int m,
                         const unsigned int n,
                         const unsigned int o)
{
  Assert (i < this->table_size[0],
          ExcIndexRange (i, 0, this->table_size[0]));
  Assert (j < this->table_size[1],
          ExcIndexRange (j, 0, this->table_size[1]));
  Assert (k < this->table_size[2],
          ExcIndexRange (k, 0, this->table_size[2]));
  Assert (l < this->table_size[3],
          ExcIndexRange (l, 0, this->table_size[3]));
  Assert (m < this->table_size[4],
          ExcIndexRange (m, 0, this->table_size[4]));
  Assert (n < this->table_size[5],
          ExcIndexRange (n, 0, this->table_size[5]));
  Assert (o < this->table_size[5],
          ExcIndexRange (o, 0, 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