Reference documentation for deal.II version GIT 6da2e5d553 2022-07-01 18:55:02+00:00
\(\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}}\) \(\newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=}\) \(\newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]}\) \(\newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}\)
table.h
Go to the documentation of this file.
1 // ---------------------------------------------------------------------
2 //
3 // Copyright (C) 2002 - 2022 by the deal.II authors
4 //
5 // This file is part of the deal.II library.
6 //
7 // The deal.II library is free software; you can use it, redistribute
8 // it, and/or modify it under the terms of the GNU Lesser General
9 // Public License as published by the Free Software Foundation; either
10 // version 2.1 of the License, or (at your option) any later version.
11 // The full text of the license can be found in the file LICENSE.md at
12 // the top level directory of deal.II.
13 //
14 // ---------------------------------------------------------------------
15 
16 #ifndef dealii_table_h
17 #define dealii_table_h
18 
19 #include <deal.II/base/config.h>
20 
27 
28 #include <algorithm>
29 #include <cstddef>
30 
32 
33 // forward declaration
34 #ifndef DOXYGEN
35 template <int N, typename T>
36 class TableBase;
37 template <int N, typename T>
38 class Table;
39 template <typename T>
40 class TransposeTable;
41 template <typename T>
42 class Table<1, T>;
43 template <typename T>
44 class Table<2, T>;
45 template <typename T>
46 class Table<3, T>;
47 template <typename T>
48 class Table<4, T>;
49 template <typename T>
50 class Table<5, T>;
51 template <typename T>
52 class Table<6, T>;
53 #endif
54 
55 
56 
57 namespace internal
58 {
73  namespace TableBaseAccessors
74  {
82  template <int N, typename T, bool Constness>
83  struct Types
84  {};
85 
91  template <int N, typename T>
92  struct Types<N, T, true>
93  {
94  using value_type = const T;
95  using TableType = const TableBase<N, T>;
96 
99 
102  };
103 
109  template <int N, typename T>
110  struct Types<N, T, false>
111  {
112  using value_type = T;
114 
117 
120  };
121 
122 
159  template <int N, typename T, bool C, unsigned int P>
160  class Accessor
161  {
162  public:
164 
167 
168  using size_type = size_t;
169  using difference_type = ptrdiff_t;
170 
171  private:
178 
179  public:
187  Accessor(const Accessor &a);
188 
192  Accessor<N, T, C, P - 1>
193  operator[](const size_type i) const;
194 
200  size_type,
201  size_type,
202  size_type,
203  << "Index " << N - P + 1 << "has a value of " << arg1
204  << " but needs to be in the range [" << arg2 << ',' << arg3
205  << "[.");
206 
207  private:
213  const TableType &table;
214  const iterator data;
215 
216  // declare some other classes
217  // as friends. make sure to
218  // work around bugs in some
219  // compilers
220  template <int N1, typename T1>
221  friend class ::Table;
222  template <int N1, typename T1, bool C1, unsigned int P1>
223  friend class Accessor;
224  friend class ::Table<N, T>;
225  friend class Accessor<N, T, C, P + 1>;
226  };
227 
228 
229 
237  template <int N, typename T, bool C>
238  class Accessor<N, T, C, 1>
239  {
240  public:
247 
250 
253 
254  using size_type = size_t;
255  using difference_type = ptrdiff_t;
256 
261 
262  private:
275 
276  public:
284  Accessor(const Accessor &a);
285 
289  reference
290  operator[](const size_type) const;
291 
296  size_type
297  size() const;
298 
302  iterator
303  begin() const;
304 
308  iterator
309  end() const;
310 
311  private:
317  const TableType &table;
318  const iterator data;
319 
320  // declare some other classes
321  // as friends. make sure to
322  // work around bugs in some
323  // compilers
324  template <int N1, typename T1>
325  friend class ::Table;
326  template <int N1, typename T1, bool C1, unsigned int P1>
327  friend class Accessor;
328  friend class ::Table<2, T>;
329  friend class Accessor<N, T, C, 2>;
330  };
331  } // namespace TableBaseAccessors
332 
333 } // namespace internal
334 
335 
336 
439 template <int N, typename T>
440 class TableBase : public Subscriptor
441 {
442 public:
443  using value_type = T;
444 
449 
450 
454  TableBase() = default;
455 
460  explicit TableBase(const TableIndices<N> &sizes);
461 
467  template <typename InputIterator>
469  InputIterator entries,
470  const bool C_style_indexing = true);
471 
476 
481  template <typename T2>
483 
487  TableBase(TableBase<N, T> &&src) noexcept;
488 
492  ~TableBase() override = default;
493 
504 
512  template <typename T2>
515 
521  operator=(TableBase<N, T> &&src) noexcept;
522 
526  bool
527  operator==(const TableBase<N, T> &T2) const;
528 
533  void
535 
544  void
545  reinit(const TableIndices<N> &new_size,
546  const bool omit_default_initialization = false);
547 
551  void
552  clear();
553 
557  size_type
558  size(const unsigned int i) const;
559 
563  const TableIndices<N> &
564  size() const;
565 
570  size_type
571  n_elements() const;
572 
577  bool
578  empty() const;
579 
616  template <typename InputIterator>
617  void
618  fill(InputIterator entries, const bool C_style_indexing = true);
619 
623  void
624  fill(const T &value);
625 
630  operator()(const TableIndices<N> &indices);
631 
640  operator()(const TableIndices<N> &indices) const;
641 
726  void
727  replicate_across_communicator(const MPI_Comm & communicator,
728  const unsigned int root_process);
729 
742  void
744 
749  std::size_t
751 
757  template <class Archive>
758  void
759  serialize(Archive &ar, const unsigned int version);
760 
761 protected:
766  size_type
767  position(const TableIndices<N> &indices) const;
768 
776  el(const TableIndices<N> &indices);
777 
789  el(const TableIndices<N> &indices) const;
790 
791 protected:
796 
801 
802  // Make all other table classes friends.
803  template <int, typename>
804  friend class TableBase;
805 };
806 
807 
820 template <int N, typename T>
821 class Table;
822 
823 
832 template <typename T>
833 class Table<1, T> : public TableBase<1, T>
834 {
835 public:
840 
844  Table() = default;
845 
849  explicit Table(const size_type size);
850 
888  template <typename InputIterator>
889  Table(const size_type size,
890  InputIterator entries,
891  const bool C_style_indexing = true);
892 
898  operator[](const size_type i) const;
899 
906 
912  operator()(const size_type i) const;
913 
920 
925 };
926 
927 
928 
937 {
942  enum class Storage
943  {
947  row_major,
948 
953  };
954 
955  // Forward declaration of the iterator class.
956  template <typename TableType, bool Constness, Storage storage_order>
957  class Iterator;
958 
963  template <typename TableType, bool Constness, Storage storage_order>
964  class Accessor;
965 
982  template <typename TableType, bool Constness, Storage storage_order>
984  {
985  public:
989  using container_pointer_type = typename std::
990  conditional<Constness, const TableType *, TableType *>::type;
991 
995  using value_type = typename TableType::value_type;
996 
1001 
1006 
1011 
1016 
1021  const std::ptrdiff_t linear_index);
1022 
1026  template <bool OtherConstness>
1027  friend bool
1031  {
1032  return left.container == right.container &&
1033  left.linear_index == right.linear_index;
1034  }
1035 
1040  const value_type &
1041  value() const;
1042 
1046  operator const value_type &() const;
1047 
1051  size_type
1052  row() const;
1053 
1057  size_type
1058  column() const;
1059 
1060  protected:
1065 
1069  std::ptrdiff_t linear_index;
1070 
1077  void
1079 
1080  // Make the const version a friend for copying.
1081  friend class AccessorBase<TableType, true, storage_order>;
1082 
1083  // Make the underlying iterator class a friend.
1084  friend class LinearIndexIterator<
1085  Iterator<TableType, Constness, storage_order>,
1086  Accessor<TableType, Constness, storage_order>>;
1087  };
1088 
1093  template <typename TableType, Storage storage_order>
1094  class Accessor<TableType, true, storage_order>
1095  : public AccessorBase<TableType, true, storage_order>
1096  {
1097  public:
1101  using value_type =
1103 
1107  using size_type =
1109 
1114  };
1115 
1120  template <typename TableType, Storage storage_order>
1121  class Accessor<TableType, false, storage_order>
1122  : public AccessorBase<TableType, false, storage_order>
1123  {
1124  public:
1128  using value_type =
1130 
1134  using size_type =
1136 
1141 
1147  operator=(const value_type &) const;
1148 
1155 
1161 
1166  value_type &
1167  value() const;
1168 
1172  operator value_type &();
1173  };
1174 
1187  template <typename TableType, bool Constness, Storage storage_order>
1188  class Iterator
1189  : public LinearIndexIterator<Iterator<TableType, Constness, storage_order>,
1190  Accessor<TableType, Constness, storage_order>>
1191  {
1192  public:
1197 
1201  using container_pointer_type = typename std::
1202  conditional<Constness, const TableType *, TableType *>::type;
1203 
1208 
1213 
1218  const size_type row,
1219  const size_type column);
1220 
1225 
1230  const std::ptrdiff_t linear_index);
1231  };
1232 } // namespace MatrixTableIterators
1233 
1234 
1235 
1249 template <typename T>
1250 class Table<2, T> : public TableBase<2, T>
1251 {
1252 public:
1257 
1262 
1267 
1272 
1277  using const_iterator = MatrixTableIterators::
1278  Iterator<Table<2, T>, true, MatrixTableIterators::Storage::row_major>;
1279 
1283  using iterator = MatrixTableIterators::
1284  Iterator<Table<2, T>, false, MatrixTableIterators::Storage::row_major>;
1285 
1289  Table() = default;
1290 
1294  Table(const size_type size1, const size_type size2);
1295 
1334  template <typename InputIterator>
1335  Table(const size_type size1,
1336  const size_type size2,
1337  InputIterator entries,
1338  const bool C_style_indexing = true);
1339 
1345  void
1346  reinit(const size_type size1,
1347  const size_type size2,
1348  const bool omit_default_initialization = false);
1349 
1351 
1359  operator[](const size_type i) const;
1360 
1369 
1377  operator()(const size_type i, const size_type j) const;
1378 
1386  operator()(const size_type i, const size_type j);
1387 
1391  using TableBase<2, T>::operator();
1392 
1397  size_type
1398  n_rows() const;
1399 
1404  size_type
1405  n_cols() const;
1406 
1410  iterator
1412 
1417  begin() const;
1418 
1422  iterator
1423  end();
1424 
1429  end() const;
1430 
1431 protected:
1443  el(const size_type i, const size_type j);
1444 
1460  el(const size_type i, const size_type j) const;
1461 
1462  // Make the AccessorBase class a friend so that it may directly index into
1463  // the array.
1464  friend class MatrixTableIterators::
1465  AccessorBase<Table<2, T>, true, MatrixTableIterators::Storage::row_major>;
1466  friend class MatrixTableIterators::
1467  AccessorBase<Table<2, T>, false, MatrixTableIterators::Storage::row_major>;
1468 
1469  // Make the mutable accessor class a friend so that we can write to array
1470  // entries with iterators.
1471  friend class MatrixTableIterators::
1472  Accessor<Table<2, T>, false, MatrixTableIterators::Storage::row_major>;
1473 };
1474 
1475 
1476 
1486 template <typename T>
1487 class Table<3, T> : public TableBase<3, T>
1488 {
1489 public:
1494 
1498  Table() = default;
1499 
1503  Table(const size_type size1, const size_type size2, const size_type size3);
1504 
1545  template <typename InputIterator>
1546  Table(const size_type size1,
1547  const size_type size2,
1548  const size_type size3,
1549  InputIterator entries,
1550  const bool C_style_indexing = true);
1551 
1556  void
1557  reinit(const size_type size1,
1558  const size_type size2,
1559  const size_type size3,
1560  const bool omit_default_initialization = false);
1561 
1563 
1572  operator[](const size_type i) const;
1573 
1583 
1591  operator()(const size_type i, const size_type j, const size_type k) const;
1592 
1593 
1601  operator()(const size_type i, const size_type j, const size_type k);
1602 
1606  using TableBase<3, T>::operator();
1607 };
1608 
1609 
1610 
1620 template <typename T>
1621 class Table<4, T> : public TableBase<4, T>
1622 {
1623 public:
1628 
1632  Table() = default;
1633 
1637  Table(const size_type size1,
1638  const size_type size2,
1639  const size_type size3,
1640  const size_type size4);
1641 
1650  operator[](const size_type i) const;
1651 
1661 
1670  const size_type j,
1671  const size_type k,
1672  const size_type l) const;
1673 
1674 
1683  const size_type j,
1684  const size_type k,
1685  const size_type l);
1686 
1690  using TableBase<4, T>::operator();
1691 };
1692 
1693 
1694 
1704 template <typename T>
1705 class Table<5, T> : public TableBase<5, T>
1706 {
1707 public:
1712 
1713 
1717  Table() = default;
1718 
1722  Table(const size_type size1,
1723  const size_type size2,
1724  const size_type size3,
1725  const size_type size4,
1726  const size_type size5);
1727 
1736  operator[](const size_type i) const;
1737 
1747 
1756  const size_type j,
1757  const size_type k,
1758  const size_type l,
1759  const size_type m) const;
1760 
1769  const size_type j,
1770  const size_type k,
1771  const size_type l,
1772  const size_type m);
1773 
1777  using TableBase<5, T>::operator();
1778 };
1779 
1780 
1781 
1791 template <typename T>
1792 class Table<6, T> : public TableBase<6, T>
1793 {
1794 public:
1799 
1803  Table() = default;
1804 
1808  Table(const size_type size1,
1809  const size_type size2,
1810  const size_type size3,
1811  const size_type size4,
1812  const size_type size5,
1813  const size_type size6);
1814 
1823  operator[](const size_type i) const;
1824 
1834 
1843  const size_type j,
1844  const size_type k,
1845  const size_type l,
1846  const size_type m,
1847  const size_type n) const;
1848 
1857  const size_type j,
1858  const size_type k,
1859  const size_type l,
1860  const size_type m,
1861  const size_type n);
1862 
1866  using TableBase<6, T>::operator();
1867 };
1868 
1869 
1879 template <typename T>
1880 class Table<7, T> : public TableBase<7, T>
1881 {
1882 public:
1887 
1891  Table() = default;
1892 
1896  Table(const size_type size1,
1897  const size_type size2,
1898  const size_type size3,
1899  const size_type size4,
1900  const size_type size5,
1901  const size_type size6,
1902  const size_type size7);
1903 
1912  operator[](const size_type i) const;
1913 
1923 
1932  const size_type j,
1933  const size_type k,
1934  const size_type l,
1935  const size_type m,
1936  const size_type n,
1937  const size_type o) const;
1938 
1947  const size_type j,
1948  const size_type k,
1949  const size_type l,
1950  const size_type m,
1951  const size_type n,
1952  const size_type o);
1953 
1957  using TableBase<7, T>::operator();
1958 };
1959 
1960 
1973 template <typename T>
1974 class TransposeTable : public TableBase<2, T>
1975 {
1976 public:
1981 
1986 
1991 
1996 
2003  true,
2005 
2009  using iterator =
2011  false,
2013 
2017  TransposeTable() = default;
2018 
2022  TransposeTable(const size_type size1, const size_type size2);
2023 
2029  void
2030  reinit(const size_type size1,
2031  const size_type size2,
2032  const bool omit_default_initialization = false);
2033 
2041  operator()(const size_type i, const size_type j) const;
2042 
2049  reference
2050  operator()(const size_type i, const size_type j);
2051 
2056  size_type
2057  n_rows() const;
2058 
2063  size_type
2064  n_cols() const;
2065 
2069  iterator
2071 
2076  begin() const;
2077 
2081  iterator
2082  end();
2083 
2088  end() const;
2089 
2090 protected:
2101  reference
2102  el(const size_type i, const size_type j);
2103 
2119  el(const size_type i, const size_type j) const;
2120 
2121  // Make the AccessorBase class a friend so that it may directly index into
2122  // the array.
2124  TransposeTable<T>,
2125  true,
2128  TransposeTable<T>,
2129  false,
2130  MatrixTableIterators::Storage::column_major>;
2131 
2132  // Make the mutable accessor class a friend so that we can write to array
2133  // entries with iterators.
2134  friend class MatrixTableIterators::Accessor<
2135  TransposeTable<T>,
2136  false,
2137  MatrixTableIterators::Storage::column_major>;
2138 };
2139 
2140 
2141 
2142 /* --------------------- Template and inline functions ---------------- */
2143 
2144 #ifndef DOXYGEN
2145 
2146 template <int N, typename T>
2147 TableBase<N, T>::TableBase(const TableIndices<N> &sizes)
2148 {
2149  reinit(sizes);
2150 }
2151 
2152 
2153 
2154 template <int N, typename T>
2155 template <typename InputIterator>
2157  InputIterator entries,
2158  const bool C_style_indexing)
2159 {
2160  reinit(sizes);
2161  fill(entries, C_style_indexing);
2162 }
2163 
2164 
2165 
2166 template <int N, typename T>
2168  : Subscriptor()
2169  , values(src.values)
2170  , table_size(src.table_size)
2171 {}
2172 
2173 
2174 
2175 template <int N, typename T>
2176 template <typename T2>
2178 {
2179  reinit(src.table_size);
2180  if (src.n_elements() != 0)
2181  std::copy(src.values.begin(), src.values.end(), values.begin());
2182 }
2183 
2184 
2185 
2186 template <int N, typename T>
2188  : Subscriptor(std::move(src))
2189  , values(std::move(src.values))
2190  , table_size(src.table_size)
2191 {
2192  src.table_size = TableIndices<N>();
2193 }
2194 
2195 
2196 
2197 template <int N, typename T>
2198 template <class Archive>
2199 inline void
2200 TableBase<N, T>::serialize(Archive &ar, const unsigned int)
2201 {
2202  ar &static_cast<Subscriptor &>(*this);
2203 
2204  ar &values &table_size;
2205 }
2206 
2207 
2208 
2209 namespace internal
2210 {
2211  namespace TableBaseAccessors
2212  {
2213  template <int N, typename T, bool C, unsigned int P>
2214  inline Accessor<N, T, C, P>::Accessor(const TableType &table,
2215  const iterator data)
2216  : table(table)
2217  , data(data)
2218  {}
2219 
2220 
2221 
2222  template <int N, typename T, bool C, unsigned int P>
2223  inline Accessor<N, T, C, P>::Accessor(const Accessor &a)
2224  : table(a.table)
2225  , data(a.data)
2226  {}
2227 
2228 
2229 
2230  template <int N, typename T, bool C, unsigned int P>
2231  inline Accessor<N, T, C, P - 1>
2232  Accessor<N, T, C, P>::operator[](const size_type i) const
2233  {
2234  AssertIndexRange(i, table.size()[N - P]);
2235 
2236  // access i-th
2237  // subobject. optimize on the
2238  // case i==0
2239  if (i == 0)
2240  return Accessor<N, T, C, P - 1>(table, data);
2241  else
2242  {
2243  // note: P>1, otherwise the
2244  // specialization would have
2245  // been taken!
2246  size_type subobject_size = table.size()[N - 1];
2247  for (int p = P - 1; p > 1; --p)
2248  subobject_size *= table.size()[N - p];
2249  const iterator new_data = data + i * subobject_size;
2250  return Accessor<N, T, C, P - 1>(table, new_data);
2251  }
2252  }
2253 
2254 
2255 
2256  template <int N, typename T, bool C>
2257  inline Accessor<N, T, C, 1>::Accessor(const TableType &table,
2258  const iterator data)
2259  : table(table)
2260  , data(data)
2261  {}
2262 
2263 
2264 
2265  template <int N, typename T, bool C>
2266  inline Accessor<N, T, C, 1>::Accessor(const Accessor &a)
2267  : table(a.table)
2268  , data(a.data)
2269  {}
2270 
2271 
2272 
2273  template <int N, typename T, bool C>
2274  inline typename Accessor<N, T, C, 1>::reference
2275  Accessor<N, T, C, 1>::operator[](const size_type i) const
2276  {
2277  AssertIndexRange(i, table.size()[N - 1]);
2278  return *(data + i);
2279  }
2280 
2281 
2282 
2283  template <int N, typename T, bool C>
2284  inline typename Accessor<N, T, C, 1>::size_type
2285  Accessor<N, T, C, 1>::size() const
2286  {
2287  return table.size()[N - 1];
2288  }
2289 
2290 
2291 
2292  template <int N, typename T, bool C>
2293  inline typename Accessor<N, T, C, 1>::iterator
2295  {
2296  return data;
2297  }
2298 
2299 
2300 
2301  template <int N, typename T, bool C>
2302  inline typename Accessor<N, T, C, 1>::iterator
2304  {
2305  return data + table.size()[N - 1];
2306  }
2307  } // namespace TableBaseAccessors
2308 } // namespace internal
2309 
2310 
2311 
2312 template <int N, typename T>
2313 inline TableBase<N, T> &
2315 {
2316  if (!m.empty())
2317  values = m.values;
2318  reinit(m.size(), true);
2319 
2320  return *this;
2321 }
2322 
2323 
2324 
2325 template <int N, typename T>
2326 template <typename T2>
2327 inline TableBase<N, T> &
2329 {
2330  reinit(m.size(), true);
2331  if (!empty())
2332  std::copy(m.values.begin(),
2333  m.values.begin() + n_elements(),
2334  values.begin());
2335 
2336  return *this;
2337 }
2338 
2339 
2340 
2341 template <int N, typename T>
2342 inline TableBase<N, T> &
2344 {
2345  static_cast<Subscriptor &>(*this) = std::move(static_cast<Subscriptor &>(m));
2346  values = std::move(m.values);
2347  table_size = m.table_size;
2349 
2350  return *this;
2351 }
2352 
2353 
2354 
2355 template <int N, typename T>
2356 inline bool
2358 {
2359  return (values == T2.values);
2360 }
2361 
2362 
2363 
2364 template <int N, typename T>
2365 inline void
2367 {
2368  // use parallel set operation
2369  if (n_elements() != 0)
2370  values.fill(T());
2371 }
2372 
2373 
2374 
2375 template <int N, typename T>
2376 inline void
2377 TableBase<N, T>::fill(const T &value)
2378 {
2379  if (n_elements() != 0)
2380  values.fill(value);
2381 }
2382 
2383 
2384 
2385 template <int N, typename T>
2386 inline void
2387 TableBase<N, T>::replicate_across_communicator(const MPI_Comm & communicator,
2388  const unsigned int root_process)
2389 {
2390  // Replicate first the actual data, then also exchange the
2391  // extents of the table
2392  values.replicate_across_communicator(communicator, root_process);
2393 
2394  table_size =
2395  Utilities::MPI::broadcast(communicator, table_size, root_process);
2396 }
2397 
2398 
2399 
2400 template <int N, typename T>
2401 inline void
2402 TableBase<N, T>::reinit(const TableIndices<N> &new_sizes,
2403  const bool omit_default_initialization)
2404 {
2405  table_size = new_sizes;
2406 
2407  const size_type new_size = n_elements();
2408 
2409  // if zero size was given: free all memory
2410  if (new_size == 0)
2411  {
2412  values.resize(0);
2413  // set all sizes to zero, even
2414  // if one was previously
2415  // nonzero. This simplifies
2416  // some assertions.
2417  table_size = TableIndices<N>();
2418 
2419  return;
2420  }
2421 
2422  // adjust values field. If it was empty before, we can simply call resize(),
2423  // which can set all the data fields. Otherwise, select the fast resize and
2424  // manually fill in all the elements as required by the design of this
2425  // class. (Selecting another code for the empty case ensures that we touch
2426  // the memory only once for non-trivial classes that need to initialize the
2427  // memory also in resize_fast.)
2428  if (!omit_default_initialization)
2429  {
2430  if (values.empty())
2431  values.resize(new_size);
2432  else
2433  {
2434  values.resize_fast(new_size);
2435  values.fill();
2436  }
2437  }
2438  else
2439  values.resize_fast(new_size);
2440 }
2441 
2442 
2443 
2444 template <int N, typename T>
2445 inline void
2447 {
2448  values.clear();
2449  table_size = TableIndices<N>();
2450 }
2451 
2452 
2453 
2454 template <int N, typename T>
2455 inline const TableIndices<N> &
2456 TableBase<N, T>::size() const
2457 {
2458  return table_size;
2459 }
2460 
2461 
2462 
2463 template <int N, typename T>
2464 inline typename TableBase<N, T>::size_type
2465 TableBase<N, T>::size(const unsigned int i) const
2466 {
2467  AssertIndexRange(i, N);
2468  return table_size[i];
2469 }
2470 
2471 
2472 
2473 template <int N, typename T>
2474 inline typename TableBase<N, T>::size_type
2476 {
2477  size_type s = 1;
2478  for (unsigned int n = 0; n < N; ++n)
2479  s *= table_size[n];
2480  return s;
2481 }
2482 
2483 
2484 
2485 template <int N, typename T>
2486 inline bool
2487 TableBase<N, T>::empty() const
2488 {
2489  return (n_elements() == 0);
2490 }
2491 
2492 
2493 
2494 namespace internal
2495 {
2496  namespace TableImplementation
2497  {
2498  template <typename InputIterator, typename T>
2499  void
2500  fill_Fortran_style(InputIterator entries, TableBase<1, T> &table)
2501  {
2502  using size_type = typename TableBase<1, T>::size_type;
2503  for (size_type i = 0; i < table.size()[0]; ++i)
2504  table(TableIndices<1>(i)) = *entries++;
2505  }
2506 
2507 
2508  template <typename InputIterator, typename T>
2509  void
2510  fill_Fortran_style(InputIterator entries, TableBase<2, T> &table)
2511  {
2512  using size_type = typename TableBase<2, T>::size_type;
2513  for (size_type j = 0; j < table.size()[1]; ++j)
2514  for (size_type i = 0; i < table.size()[0]; ++i)
2515  table(TableIndices<2>(i, j)) = *entries++;
2516  }
2517 
2518 
2519  template <typename InputIterator, typename T>
2520  void
2521  fill_Fortran_style(InputIterator entries, TableBase<3, T> &table)
2522  {
2523  using size_type = typename TableBase<3, T>::size_type;
2524  for (size_type k = 0; k < table.size()[2]; ++k)
2525  for (size_type j = 0; j < table.size()[1]; ++j)
2526  for (size_type i = 0; i < table.size()[0]; ++i)
2527  table(TableIndices<3>(i, j, k)) = *entries++;
2528  }
2529 
2530 
2531  template <typename InputIterator, typename T, int N>
2532  void
2533  fill_Fortran_style(InputIterator, TableBase<N, T> &)
2534  {
2535  Assert(false, ExcNotImplemented());
2536  }
2537  } // namespace TableImplementation
2538 } // namespace internal
2539 
2540 
2541 template <int N, typename T>
2542 template <typename InputIterator>
2543 inline void
2544 TableBase<N, T>::fill(InputIterator entries, const bool C_style_indexing)
2545 {
2546  Assert(n_elements() != 0, ExcMessage("Trying to fill an empty matrix."));
2547 
2548  if (C_style_indexing)
2549  for (typename AlignedVector<T>::iterator p = values.begin();
2550  p != values.end();
2551  ++p)
2552  *p = *entries++;
2553  else
2554  internal::TableImplementation::fill_Fortran_style(entries, *this);
2555 }
2556 
2557 
2558 
2559 template <int N, typename T>
2560 inline void
2562 {
2563  values.swap(v.values);
2564  std::swap(table_size, v.table_size);
2565 }
2566 
2567 
2568 
2569 template <int N, typename T>
2570 inline std::size_t
2572 {
2573  return sizeof(*this) + MemoryConsumption::memory_consumption(values);
2574 }
2575 
2576 
2577 
2578 template <int N, typename T>
2579 inline typename TableBase<N, T>::size_type
2580 TableBase<N, T>::position(const TableIndices<N> &indices) const
2581 {
2582  // specialize this for the
2583  // different numbers of dimensions,
2584  // to make the job somewhat easier
2585  // for the compiler. have the
2586  // general formula nevertheless:
2587  switch (N)
2588  {
2589  case 1:
2590  return indices[0];
2591  case 2:
2592  return size_type(indices[0]) * table_size[1] + indices[1];
2593  case 3:
2594  return ((size_type(indices[0]) * table_size[1] + indices[1]) *
2595  table_size[2] +
2596  indices[2]);
2597  default:
2598  {
2599  unsigned int s = indices[0];
2600  for (unsigned int n = 1; n < N; ++n)
2601  s = s * table_size[n] + indices[n];
2602  return s;
2603  }
2604  }
2605 }
2606 
2607 
2608 
2609 template <int N, typename T>
2610 inline typename AlignedVector<T>::const_reference
2611 TableBase<N, T>::operator()(const TableIndices<N> &indices) const
2612 {
2613  for (unsigned int n = 0; n < N; ++n)
2614  AssertIndexRange(indices[n], table_size[n]);
2615  return el(indices);
2616 }
2617 
2618 
2619 
2620 template <int N, typename T>
2621 inline typename AlignedVector<T>::reference
2623 {
2624  for (unsigned int n = 0; n < N; ++n)
2625  AssertIndexRange(indices[n], table_size[n]);
2626  return el(indices);
2627 }
2628 
2629 
2630 
2631 template <int N, typename T>
2632 inline typename AlignedVector<T>::const_reference
2633 TableBase<N, T>::el(const TableIndices<N> &indices) const
2634 {
2635  return values[position(indices)];
2636 }
2637 
2638 
2639 
2640 template <int N, typename T>
2641 inline typename AlignedVector<T>::reference
2642 TableBase<N, T>::el(const TableIndices<N> &indices)
2643 {
2644  AssertIndexRange(position(indices), values.size());
2645  return values[position(indices)];
2646 }
2647 
2648 
2649 
2650 template <typename T>
2651 inline Table<1, T>::Table(const size_type size)
2652  : TableBase<1, T>(TableIndices<1>(size))
2653 {}
2654 
2655 
2656 
2657 template <typename T>
2658 template <typename InputIterator>
2659 inline Table<1, T>::Table(const size_type size,
2660  InputIterator entries,
2661  const bool C_style_indexing)
2662  : TableBase<1, T>(TableIndices<1>(size), entries, C_style_indexing)
2663 {}
2664 
2665 
2666 
2667 template <typename T>
2668 inline typename AlignedVector<T>::const_reference
2669 Table<1, T>::operator[](const size_type i) const
2670 {
2671  AssertIndexRange(i, this->table_size[0]);
2672  return this->values[i];
2673 }
2674 
2675 
2676 
2677 template <typename T>
2678 inline typename AlignedVector<T>::reference
2680 {
2681  AssertIndexRange(i, this->table_size[0]);
2682  return this->values[i];
2683 }
2684 
2685 
2686 
2687 template <typename T>
2688 inline typename AlignedVector<T>::const_reference
2689 Table<1, T>::operator()(const size_type i) const
2690 {
2691  AssertIndexRange(i, this->table_size[0]);
2692  return this->values[i];
2693 }
2694 
2695 
2696 
2697 template <typename T>
2698 inline typename AlignedVector<T>::reference
2700 {
2701  AssertIndexRange(i, this->table_size[0]);
2702  return this->values[i];
2703 }
2704 
2705 
2706 //---------------------------------------------------------------------------
2707 
2708 
2709 
2710 template <typename T>
2711 inline Table<2, T>::Table(const size_type size1, const size_type size2)
2712  : TableBase<2, T>(TableIndices<2>(size1, size2))
2713 {}
2714 
2715 
2716 
2717 template <typename T>
2718 template <typename InputIterator>
2719 inline Table<2, T>::Table(const size_type size1,
2720  const size_type size2,
2721  InputIterator entries,
2722  const bool C_style_indexing)
2723  : TableBase<2, T>(TableIndices<2>(size1, size2), entries, C_style_indexing)
2724 {}
2725 
2726 
2727 
2728 template <typename T>
2729 inline void
2730 Table<2, T>::reinit(const size_type size1,
2731  const size_type size2,
2732  const bool omit_default_initialization)
2733 {
2734  this->TableBase<2, T>::reinit(TableIndices<2>(size1, size2),
2735  omit_default_initialization);
2736 }
2737 
2738 
2739 
2740 template <typename T>
2741 inline ::internal::TableBaseAccessors::Accessor<2, T, true, 1>
2742 Table<2, T>::operator[](const size_type i) const
2743 {
2744  AssertIndexRange(i, this->table_size[0]);
2745  return ::internal::TableBaseAccessors::Accessor<2, T, true, 1>(
2746  *this, this->values.begin() + size_type(i) * n_cols());
2747 }
2748 
2749 
2750 
2751 template <typename T>
2752 inline ::internal::TableBaseAccessors::Accessor<2, T, false, 1>
2754 {
2755  AssertIndexRange(i, this->table_size[0]);
2756  return ::internal::TableBaseAccessors::Accessor<2, T, false, 1>(
2757  *this, this->values.begin() + size_type(i) * n_cols());
2758 }
2759 
2760 
2761 
2762 template <typename T>
2763 inline typename AlignedVector<T>::const_reference
2764 Table<2, T>::operator()(const size_type i, const size_type j) const
2765 {
2766  AssertIndexRange(i, this->table_size[0]);
2767  AssertIndexRange(j, this->table_size[1]);
2768  return this->values[size_type(i) * this->table_size[1] + j];
2769 }
2770 
2771 
2772 
2773 template <typename T>
2774 inline typename AlignedVector<T>::reference
2776 {
2777  AssertIndexRange(i, this->table_size[0]);
2778  AssertIndexRange(j, this->table_size[1]);
2779  return this->values[size_type(i) * this->table_size[1] + j];
2780 }
2781 
2782 
2783 
2784 template <typename T>
2785 inline typename AlignedVector<T>::const_reference
2786 Table<2, T>::el(const size_type i, const size_type j) const
2787 {
2788  return this->values[size_type(i) * this->table_size[1] + j];
2789 }
2790 
2791 
2792 
2793 template <typename T>
2794 inline typename AlignedVector<T>::reference
2795 Table<2, T>::el(const size_type i, const size_type j)
2796 {
2797  return this->values[size_type(i) * this->table_size[1] + j];
2798 }
2799 
2800 
2801 
2802 template <typename T>
2803 inline typename Table<2, T>::size_type
2804 Table<2, T>::n_rows() const
2805 {
2806  return this->table_size[0];
2807 }
2808 
2809 
2810 
2811 template <typename T>
2812 inline typename Table<2, T>::size_type
2813 Table<2, T>::n_cols() const
2814 {
2815  return this->table_size[1];
2816 }
2817 
2818 
2819 
2820 template <typename T>
2821 inline typename Table<2, T>::iterator
2823 {
2824  return typename Table<2, T>::iterator(this, 0, 0);
2825 }
2826 
2827 
2828 
2829 template <typename T>
2830 inline typename Table<2, T>::const_iterator
2831 Table<2, T>::begin() const
2832 {
2833  return typename Table<2, T>::const_iterator(this, 0, 0);
2834 }
2835 
2836 
2837 
2838 template <typename T>
2839 inline typename Table<2, T>::iterator
2841 {
2842  return typename Table<2, T>::iterator(this);
2843 }
2844 
2845 
2846 
2847 template <typename T>
2848 inline typename Table<2, T>::const_iterator
2849 Table<2, T>::end() const
2850 {
2851  return typename Table<2, T>::const_iterator(this);
2852 }
2853 
2854 
2855 
2856 //---------------------------------------------------------------------------
2857 namespace MatrixTableIterators
2858 {
2859  namespace internal
2860  {
2861  // Internal calculation routines for AccessorBase. These do not do any
2862  // checking whatsoever.
2863  template <typename TableType, Storage storage_order>
2864  inline std::ptrdiff_t
2865  get_row_index(const std::ptrdiff_t linear_index,
2866  const TableType *const container)
2867  {
2868  switch (storage_order)
2869  {
2870  case Storage::row_major:
2871  return linear_index / container->n_cols();
2872  case Storage::column_major:
2873  return linear_index % container->n_rows();
2874  default:
2875  Assert(false, ExcInternalError());
2876  }
2877  return {};
2878  }
2879 
2880 
2881 
2882  template <typename TableType, Storage storage_order>
2883  inline std::ptrdiff_t
2884  get_column_index(const std::ptrdiff_t linear_index,
2885  const TableType *const container)
2886  {
2887  switch (storage_order)
2888  {
2889  case Storage::row_major:
2890  return linear_index % container->n_cols();
2891  case Storage::column_major:
2892  return linear_index / container->n_rows();
2893  default:
2894  Assert(false, ExcInternalError());
2895  }
2896  return {};
2897  }
2898  } // namespace internal
2899 
2900 
2901 
2902  template <typename TableType, bool Constness, Storage storage_order>
2904  : container(nullptr)
2905  , linear_index(std::numeric_limits<decltype(linear_index)>::max())
2906  {}
2907 
2908 
2909 
2910  template <typename TableType, bool Constness, Storage storage_order>
2911  inline AccessorBase<TableType, Constness, storage_order>::AccessorBase(
2912  const container_pointer_type table)
2913  : container(table)
2914  , linear_index(container->values.size())
2915  {}
2916 
2917 
2918 
2919  template <typename TableType, bool Constness, Storage storage_order>
2920  inline AccessorBase<TableType, Constness, storage_order>::AccessorBase(
2921  const AccessorBase<TableType, false, storage_order> &a)
2922  : container(a.container)
2923  , linear_index(a.linear_index)
2924  {}
2925 
2926 
2927 
2928  template <typename TableType, bool Constness, Storage storage_order>
2929  inline AccessorBase<TableType, Constness, storage_order>::AccessorBase(
2930  const container_pointer_type table,
2931  const std::ptrdiff_t index)
2932  : container(table)
2933  , linear_index(index)
2934  {
2935  Assert(0 <= linear_index &&
2936  std::size_t(linear_index) < container->values.size() + 1,
2937  ExcMessage("The current iterator points outside of the table and is "
2938  "not the end iterator."));
2939  }
2940 
2941 
2942 
2943  template <typename TableType, bool Constness, Storage storage_order>
2944  inline const typename AccessorBase<TableType, Constness, storage_order>::
2945  value_type &
2946  AccessorBase<TableType, Constness, storage_order>::value() const
2947  {
2948  assert_valid_linear_index();
2949  return this->container->values[linear_index];
2950  }
2951 
2952 
2953 
2954  template <typename TableType, bool Constness, Storage storage_order>
2955  inline AccessorBase<TableType, Constness, storage_order>::
2956  operator const value_type &() const
2957  {
2958  assert_valid_linear_index();
2959  return this->container->values[linear_index];
2960  }
2961 
2962 
2963 
2964  template <typename TableType, bool Constness, Storage storage_order>
2966  AccessorBase<TableType, Constness, storage_order>::row() const
2967  {
2968  assert_valid_linear_index();
2969  return static_cast<std::size_t>(
2970  internal::get_row_index<TableType, storage_order>(linear_index,
2971  container));
2972  }
2973 
2974 
2975 
2976  template <typename TableType, bool Constness, Storage storage_order>
2978  AccessorBase<TableType, Constness, storage_order>::column() const
2979  {
2980  assert_valid_linear_index();
2981  return static_cast<std::size_t>(
2982  internal::get_column_index<TableType, storage_order>(linear_index,
2983  container));
2984  }
2985 
2986 
2987 
2988  template <typename TableType, bool Constness, Storage storage_order>
2989  inline void
2990  AccessorBase<TableType, Constness, storage_order>::assert_valid_linear_index()
2991  const
2992  {
2993 # ifdef DEBUG // avoid unused variable warnings by guarding everything
2994  Assert(container != nullptr,
2995  ExcMessage("This accessor has been default-constructed and does not "
2996  "have a corresponding table."));
2997  Assert(!container->empty(),
2998  ExcMessage("An empty table has no rows or columns."));
2999  Assert(0 <= linear_index &&
3000  std::size_t(linear_index) < container->values.size(),
3001  ExcMessage("The current iterator points outside of the table."));
3002  const std::ptrdiff_t row_n =
3003  internal::get_row_index<TableType, storage_order>(linear_index,
3004  container);
3005  const std::ptrdiff_t column_n =
3006  internal::get_column_index<TableType, storage_order>(linear_index,
3007  container);
3008  Assert(0 <= column_n && std::size_t(column_n) < container->n_cols(),
3009  ExcMessage("The current iterator points outside the table."));
3010  Assert(0 <= row_n && std::size_t(row_n) < container->n_rows(),
3011  ExcMessage("The current iterator points outside the table."));
3012 # endif
3013  }
3014 
3015 
3016 
3017  template <typename TableType, Storage storage_order>
3018  inline const Accessor<TableType, false, storage_order> &
3019  Accessor<TableType, false, storage_order>::operator=(
3020  const typename Accessor<TableType, false, storage_order>::value_type &t)
3021  const
3022  {
3023  this->assert_valid_linear_index();
3024  this->container->values[this->linear_index] = t;
3025  return *this;
3026  }
3027 
3028 
3029 
3030  template <typename TableType, Storage storage_order>
3031  inline const Accessor<TableType, false, storage_order> &
3032  Accessor<TableType, false, storage_order>::operator=(
3033  typename Accessor<TableType, false, storage_order>::value_type &&t) const
3034  {
3035  this->assert_valid_linear_index();
3036  this->container->values[this->linear_index] = t;
3037  return *this;
3038  }
3039 
3040 
3041 
3042  template <typename TableType, Storage storage_order>
3043  inline typename Accessor<TableType, false, storage_order>::value_type &
3044  Accessor<TableType, false, storage_order>::value() const
3045  {
3046  this->assert_valid_linear_index();
3047  return this->container->values[this->linear_index];
3048  }
3049 
3050 
3051 
3052  template <typename TableType, Storage storage_order>
3053  inline Accessor<TableType, false, storage_order>::operator value_type &()
3054  {
3055  this->assert_valid_linear_index();
3056  return this->container->values[this->linear_index];
3057  }
3058 
3059 
3060 
3061  template <typename TableType, bool Constness, Storage storage_order>
3062  inline Iterator<TableType, Constness, storage_order>::Iterator(
3063  const Accessor<TableType, Constness, storage_order> &a)
3064  : LinearIndexIterator<Iterator<TableType, Constness, storage_order>,
3065  Accessor<TableType, Constness, storage_order>>(a)
3066  {}
3067 
3068 
3069 
3070  template <typename TableType, bool Constness, Storage storage_order>
3071  inline Iterator<TableType, Constness, storage_order>::Iterator(
3072  const container_pointer_type table)
3073  : LinearIndexIterator<Iterator<TableType, Constness, storage_order>,
3074  Accessor<TableType, Constness, storage_order>>(
3075  Accessor<TableType, Constness, storage_order>(table))
3076  {}
3077 
3078 
3079 
3080  template <typename TableType, bool Constness, Storage storage_order>
3081  inline Iterator<TableType, Constness, storage_order>::Iterator(
3082  const Iterator<TableType, false, storage_order> &i)
3083  : LinearIndexIterator<Iterator<TableType, Constness, storage_order>,
3084  Accessor<TableType, Constness, storage_order>>(*i)
3085  {}
3086 
3087 
3088 
3089  template <typename TableType, bool Constness, Storage storage_order>
3090  inline Iterator<TableType, Constness, storage_order>::Iterator(
3091  const container_pointer_type table,
3092  const size_type row_n,
3093  const size_type col_n)
3094  : Iterator(table,
3095  storage_order == Storage::row_major ?
3096  table->n_cols() * row_n + col_n :
3097  table->n_rows() * col_n + row_n)
3098  {}
3099 
3100 
3101 
3102  template <typename TableType, bool Constness, Storage storage_order>
3103  inline Iterator<TableType, Constness, storage_order>::Iterator(
3104  const container_pointer_type table,
3105  const std::ptrdiff_t linear_index)
3106  : LinearIndexIterator<Iterator<TableType, Constness, storage_order>,
3107  Accessor<TableType, Constness, storage_order>>(
3108  Accessor<TableType, Constness, storage_order>(table, linear_index))
3109  {}
3110 } // namespace MatrixTableIterators
3111 
3112 
3113 
3114 //---------------------------------------------------------------------------
3115 template <typename T>
3116 inline TransposeTable<T>::TransposeTable(const size_type size1,
3117  const size_type size2)
3118  : TableBase<2, T>(TableIndices<2>(size2, size1))
3119 {}
3120 
3121 
3122 
3123 template <typename T>
3124 inline void
3126  const size_type size2,
3127  const bool omit_default_initialization)
3128 {
3129  this->TableBase<2, T>::reinit(TableIndices<2>(size2, size1),
3130  omit_default_initialization);
3131 }
3132 
3133 
3134 
3135 template <typename T>
3136 inline typename TransposeTable<T>::const_reference
3137 TransposeTable<T>::operator()(const size_type i, const size_type j) const
3138 {
3139  AssertIndexRange(i, this->table_size[1]);
3140  AssertIndexRange(j, this->table_size[0]);
3141  return this->values[size_type(j) * this->table_size[1] + i];
3142 }
3143 
3144 
3145 
3146 template <typename T>
3147 inline typename TransposeTable<T>::reference
3149 {
3150  AssertIndexRange(i, this->table_size[1]);
3151  AssertIndexRange(j, this->table_size[0]);
3152  return this->values[size_type(j) * this->table_size[1] + i];
3153 }
3154 
3155 
3156 
3157 template <typename T>
3158 inline typename TransposeTable<T>::const_reference
3159 TransposeTable<T>::el(const size_type i, const size_type j) const
3160 {
3161  return this->values[size_type(j) * this->table_size[1] + i];
3162 }
3163 
3164 
3165 
3166 template <typename T>
3167 inline typename TransposeTable<T>::reference
3168 TransposeTable<T>::el(const size_type i, const size_type j)
3169 {
3170  return this->values[size_type(j) * this->table_size[1] + i];
3171 }
3172 
3173 
3174 
3175 template <typename T>
3176 inline typename TransposeTable<T>::size_type
3178 {
3179  return this->table_size[1];
3180 }
3181 
3182 
3183 
3184 template <typename T>
3185 inline typename TransposeTable<T>::size_type
3187 {
3188  return this->table_size[0];
3189 }
3190 
3191 
3192 
3193 template <typename T>
3194 inline typename TransposeTable<T>::iterator
3196 {
3197  return typename TransposeTable<T>::iterator(this, 0, 0);
3198 }
3199 
3200 
3201 
3202 template <typename T>
3203 inline typename TransposeTable<T>::const_iterator
3205 {
3206  return typename TransposeTable<T>::const_iterator(this, 0, 0);
3207 }
3208 
3209 
3210 
3211 template <typename T>
3212 inline typename TransposeTable<T>::iterator
3214 {
3215  return typename TransposeTable<T>::iterator(this);
3216 }
3217 
3218 
3219 
3220 template <typename T>
3221 inline typename TransposeTable<T>::const_iterator
3222 TransposeTable<T>::end() const
3223 {
3224  return typename TransposeTable<T>::const_iterator(this);
3225 }
3226 //---------------------------------------------------------------------------
3227 
3228 
3229 
3230 template <typename T>
3231 inline Table<3, T>::Table(const size_type size1,
3232  const size_type size2,
3233  const size_type size3)
3234  : TableBase<3, T>(TableIndices<3>(size1, size2, size3))
3235 {}
3236 
3237 
3238 
3239 template <typename T>
3240 template <typename InputIterator>
3241 inline Table<3, T>::Table(const size_type size1,
3242  const size_type size2,
3243  const size_type size3,
3244  InputIterator entries,
3245  const bool C_style_indexing)
3246  : TableBase<3, T>(TableIndices<3>(size1, size2, size3),
3247  entries,
3248  C_style_indexing)
3249 {}
3250 
3251 
3252 
3253 template <typename T>
3254 inline void
3255 Table<3, T>::reinit(const size_type size1,
3256  const size_type size2,
3257  const size_type size3,
3258  const bool omit_default_initialization)
3259 {
3260  this->TableBase<3, T>::reinit(TableIndices<3>(size1, size2, size3),
3261  omit_default_initialization);
3262 }
3263 
3264 
3265 
3266 template <typename T>
3267 inline ::internal::TableBaseAccessors::Accessor<3, T, true, 2>
3268 Table<3, T>::operator[](const size_type i) const
3269 {
3270  AssertIndexRange(i, this->table_size[0]);
3271  const size_type subobject_size =
3272  size_type(this->table_size[1]) * this->table_size[2];
3274  *this, this->values.begin() + i * subobject_size));
3275 }
3276 
3277 
3278 
3279 template <typename T>
3280 inline ::internal::TableBaseAccessors::Accessor<3, T, false, 2>
3282 {
3283  AssertIndexRange(i, this->table_size[0]);
3284  const size_type subobject_size =
3285  size_type(this->table_size[1]) * this->table_size[2];
3287  *this, this->values.begin() + i * subobject_size));
3288 }
3289 
3290 
3291 
3292 template <typename T>
3293 inline typename AlignedVector<T>::const_reference
3295  const size_type j,
3296  const size_type k) const
3297 {
3298  AssertIndexRange(i, this->table_size[0]);
3299  AssertIndexRange(j, this->table_size[1]);
3300  AssertIndexRange(k, this->table_size[2]);
3301  return this
3302  ->values[(size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3303  k];
3304 }
3305 
3306 
3307 
3308 template <typename T>
3309 inline typename AlignedVector<T>::reference
3310 Table<3, T>::operator()(const size_type i, const size_type j, const size_type k)
3311 {
3312  AssertIndexRange(i, this->table_size[0]);
3313  AssertIndexRange(j, this->table_size[1]);
3314  AssertIndexRange(k, this->table_size[2]);
3315  return this
3316  ->values[(size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3317  k];
3318 }
3319 
3320 
3321 
3322 template <typename T>
3323 inline Table<4, T>::Table(const size_type size1,
3324  const size_type size2,
3325  const size_type size3,
3326  const size_type size4)
3327  : TableBase<4, T>(TableIndices<4>(size1, size2, size3, size4))
3328 {}
3329 
3330 
3331 
3332 template <typename T>
3333 inline ::internal::TableBaseAccessors::Accessor<4, T, true, 3>
3334 Table<4, T>::operator[](const size_type i) const
3335 {
3336  AssertIndexRange(i, this->table_size[0]);
3337  const size_type subobject_size =
3338  size_type(this->table_size[1]) * this->table_size[2] * this->table_size[3];
3340  *this, this->values.begin() + i * subobject_size));
3341 }
3342 
3343 
3344 
3345 template <typename T>
3346 inline ::internal::TableBaseAccessors::Accessor<4, T, false, 3>
3348 {
3349  AssertIndexRange(i, this->table_size[0]);
3350  const size_type subobject_size =
3351  size_type(this->table_size[1]) * this->table_size[2] * this->table_size[3];
3353  *this, this->values.begin() + i * subobject_size));
3354 }
3355 
3356 
3357 
3358 template <typename T>
3359 inline typename AlignedVector<T>::const_reference
3361  const size_type j,
3362  const size_type k,
3363  const size_type l) const
3364 {
3365  AssertIndexRange(i, this->table_size[0]);
3366  AssertIndexRange(j, this->table_size[1]);
3367  AssertIndexRange(k, this->table_size[2]);
3368  AssertIndexRange(l, this->table_size[3]);
3369  return this
3370  ->values[((size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3371  k) *
3372  this->table_size[3] +
3373  l];
3374 }
3375 
3376 
3377 
3378 template <typename T>
3379 inline typename AlignedVector<T>::reference
3381  const size_type j,
3382  const size_type k,
3383  const size_type l)
3384 {
3385  AssertIndexRange(i, this->table_size[0]);
3386  AssertIndexRange(j, this->table_size[1]);
3387  AssertIndexRange(k, this->table_size[2]);
3388  AssertIndexRange(l, this->table_size[3]);
3389  return this
3390  ->values[((size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3391  k) *
3392  this->table_size[3] +
3393  l];
3394 }
3395 
3396 
3397 
3398 template <typename T>
3399 inline Table<5, T>::Table(const size_type size1,
3400  const size_type size2,
3401  const size_type size3,
3402  const size_type size4,
3403  const size_type size5)
3404  : TableBase<5, T>(TableIndices<5>(size1, size2, size3, size4, size5))
3405 {}
3406 
3407 
3408 
3409 template <typename T>
3410 inline ::internal::TableBaseAccessors::Accessor<5, T, true, 4>
3411 Table<5, T>::operator[](const size_type i) const
3412 {
3413  AssertIndexRange(i, this->table_size[0]);
3414  const size_type subobject_size = size_type(this->table_size[1]) *
3415  this->table_size[2] * this->table_size[3] *
3416  this->table_size[4];
3418  *this, this->values.begin() + i * subobject_size));
3419 }
3420 
3421 
3422 
3423 template <typename T>
3424 inline ::internal::TableBaseAccessors::Accessor<5, T, false, 4>
3426 {
3427  AssertIndexRange(i, this->table_size[0]);
3428  const size_type subobject_size = size_type(this->table_size[1]) *
3429  this->table_size[2] * this->table_size[3] *
3430  this->table_size[4];
3432  *this, this->values.begin() + i * subobject_size));
3433 }
3434 
3435 
3436 
3437 template <typename T>
3438 inline typename AlignedVector<T>::const_reference
3440  const size_type j,
3441  const size_type k,
3442  const size_type l,
3443  const size_type m) const
3444 {
3445  AssertIndexRange(i, this->table_size[0]);
3446  AssertIndexRange(j, this->table_size[1]);
3447  AssertIndexRange(k, this->table_size[2]);
3448  AssertIndexRange(l, this->table_size[3]);
3449  AssertIndexRange(m, this->table_size[4]);
3450  return this
3451  ->values[(((size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3452  k) *
3453  this->table_size[3] +
3454  l) *
3455  this->table_size[4] +
3456  m];
3457 }
3458 
3459 
3460 
3461 template <typename T>
3462 inline typename AlignedVector<T>::reference
3464  const size_type j,
3465  const size_type k,
3466  const size_type l,
3467  const size_type m)
3468 {
3469  AssertIndexRange(i, this->table_size[0]);
3470  AssertIndexRange(j, this->table_size[1]);
3471  AssertIndexRange(k, this->table_size[2]);
3472  AssertIndexRange(l, this->table_size[3]);
3473  AssertIndexRange(m, this->table_size[4]);
3474  return this
3475  ->values[(((size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3476  k) *
3477  this->table_size[3] +
3478  l) *
3479  this->table_size[4] +
3480  m];
3481 }
3482 
3483 
3484 
3485 template <typename T>
3486 inline Table<6, T>::Table(const size_type size1,
3487  const size_type size2,
3488  const size_type size3,
3489  const size_type size4,
3490  const size_type size5,
3491  const size_type size6)
3492  : TableBase<6, T>()
3493 {
3494  TableIndices<6> table_indices;
3495  table_indices[0] = size1;
3496  table_indices[1] = size2;
3497  table_indices[2] = size3;
3498  table_indices[3] = size4;
3499  table_indices[4] = size5;
3500  table_indices[5] = size6;
3501 
3502  TableBase<6, T>::reinit(table_indices);
3503 }
3504 
3505 
3506 
3507 template <typename T>
3508 inline ::internal::TableBaseAccessors::Accessor<6, T, true, 5>
3509 Table<6, T>::operator[](const size_type i) const
3510 {
3511  AssertIndexRange(i, this->table_size[0]);
3512  const size_type subobject_size = size_type(this->table_size[1]) *
3513  this->table_size[2] * this->table_size[3] *
3514  this->table_size[4] * this->table_size[5];
3516  *this, this->values.begin() + i * subobject_size));
3517 }
3518 
3519 
3520 
3521 template <typename T>
3522 inline ::internal::TableBaseAccessors::Accessor<6, T, false, 5>
3524 {
3525  AssertIndexRange(i, this->table_size[0]);
3526  const size_type subobject_size = size_type(this->table_size[1]) *
3527  this->table_size[2] * this->table_size[3] *
3528  this->table_size[4] * this->table_size[5];
3530  *this, this->values.begin() + i * subobject_size));
3531 }
3532 
3533 
3534 
3535 template <typename T>
3536 inline typename AlignedVector<T>::const_reference
3538  const size_type j,
3539  const size_type k,
3540  const size_type l,
3541  const size_type m,
3542  const size_type n) const
3543 {
3544  AssertIndexRange(i, this->table_size[0]);
3545  AssertIndexRange(j, this->table_size[1]);
3546  AssertIndexRange(k, this->table_size[2]);
3547  AssertIndexRange(l, this->table_size[3]);
3548  AssertIndexRange(m, this->table_size[4]);
3549  AssertIndexRange(n, this->table_size[5]);
3550  return this
3551  ->values[((((size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3552  k) *
3553  this->table_size[3] +
3554  l) *
3555  this->table_size[4] +
3556  m) *
3557  this->table_size[5] +
3558  n];
3559 }
3560 
3561 
3562 
3563 template <typename T>
3564 inline typename AlignedVector<T>::reference
3566  const size_type j,
3567  const size_type k,
3568  const size_type l,
3569  const size_type m,
3570  const size_type n)
3571 {
3572  AssertIndexRange(i, this->table_size[0]);
3573  AssertIndexRange(j, this->table_size[1]);
3574  AssertIndexRange(k, this->table_size[2]);
3575  AssertIndexRange(l, this->table_size[3]);
3576  AssertIndexRange(m, this->table_size[4]);
3577  AssertIndexRange(n, this->table_size[5]);
3578  return this
3579  ->values[((((size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3580  k) *
3581  this->table_size[3] +
3582  l) *
3583  this->table_size[4] +
3584  m) *
3585  this->table_size[5] +
3586  n];
3587 }
3588 
3589 
3590 
3591 template <typename T>
3592 inline Table<7, T>::Table(const size_type size1,
3593  const size_type size2,
3594  const size_type size3,
3595  const size_type size4,
3596  const size_type size5,
3597  const size_type size6,
3598  const size_type size7)
3599  : TableBase<7, T>()
3600 {
3601  TableIndices<7> table_indices;
3602  table_indices[0] = size1;
3603  table_indices[1] = size2;
3604  table_indices[2] = size3;
3605  table_indices[3] = size4;
3606  table_indices[4] = size5;
3607  table_indices[5] = size6;
3608  table_indices[6] = size7;
3609 
3610  TableBase<7, T>::reinit(table_indices);
3611 }
3612 
3613 
3614 
3615 template <typename T>
3616 inline ::internal::TableBaseAccessors::Accessor<7, T, true, 6>
3617 Table<7, T>::operator[](const size_type i) const
3618 {
3619  AssertIndexRange(i, this->table_size[0]);
3620  const size_type subobject_size =
3621  size_type(this->table_size[1]) * this->table_size[2] * this->table_size[3] *
3622  this->table_size[4] * this->table_size[5] * this->table_size[6];
3624  *this, this->values.begin() + i * subobject_size));
3625 }
3626 
3627 
3628 
3629 template <typename T>
3630 inline ::internal::TableBaseAccessors::Accessor<7, T, false, 6>
3632 {
3633  AssertIndexRange(i, this->table_size[0]);
3634  const size_type subobject_size =
3635  size_type(this->table_size[1]) * this->table_size[2] * this->table_size[3] *
3636  this->table_size[4] * this->table_size[5] * this->table_size[6];
3638  *this, this->values.begin() + i * subobject_size));
3639 }
3640 
3641 
3642 
3643 template <typename T>
3644 inline typename AlignedVector<T>::const_reference
3646  const size_type j,
3647  const size_type k,
3648  const size_type l,
3649  const size_type m,
3650  const size_type n,
3651  const size_type o) const
3652 {
3653  AssertIndexRange(i, this->table_size[0]);
3654  AssertIndexRange(j, this->table_size[1]);
3655  AssertIndexRange(k, this->table_size[2]);
3656  AssertIndexRange(l, this->table_size[3]);
3657  AssertIndexRange(m, this->table_size[4]);
3658  AssertIndexRange(n, this->table_size[5]);
3659  AssertIndexRange(o, this->table_size[6]);
3660  return this->values
3661  [(((((size_type(i) * this->table_size[1] + j) * this->table_size[2] + k) *
3662  this->table_size[3] +
3663  l) *
3664  this->table_size[4] +
3665  m) *
3666  this->table_size[5] +
3667  n) *
3668  this->table_size[6] +
3669  o];
3670 }
3671 
3672 
3673 
3674 template <typename T>
3675 inline typename AlignedVector<T>::reference
3677  const size_type j,
3678  const size_type k,
3679  const size_type l,
3680  const size_type m,
3681  const size_type n,
3682  const size_type o)
3683 {
3684  AssertIndexRange(i, this->table_size[0]);
3685  AssertIndexRange(j, this->table_size[1]);
3686  AssertIndexRange(k, this->table_size[2]);
3687  AssertIndexRange(l, this->table_size[3]);
3688  AssertIndexRange(m, this->table_size[4]);
3689  AssertIndexRange(n, this->table_size[5]);
3690  AssertIndexRange(o, this->table_size[6]);
3691  return this->values
3692  [(((((size_type(i) * this->table_size[1] + j) * this->table_size[2] + k) *
3693  this->table_size[3] +
3694  l) *
3695  this->table_size[4] +
3696  m) *
3697  this->table_size[5] +
3698  n) *
3699  this->table_size[6] +
3700  o];
3701 }
3702 
3703 
3704 #endif // DOXYGEN
3705 
3706 
3707 
3713 template <int N, typename T>
3714 inline void
3716 {
3717  u.swap(v);
3718 }
3719 
3721 
3722 #endif
value_type & reference
std::size_t size_type
const value_type * const_iterator
const value_type & const_reference
value_type * iterator
void swap(BlockIndices &u, BlockIndices &v)
Accessor base class for Table<2, T> and TransposeTable.
Definition: table.h:984
AccessorBase(const AccessorBase< TableType, false, storage_order > &)
const value_type & value() const
typename TableType::value_type value_type
Definition: table.h:995
container_pointer_type container
Definition: table.h:1064
AccessorBase(const container_pointer_type table)
AccessorBase(const container_pointer_type table, const std::ptrdiff_t linear_index)
typename std::conditional< Constness, const TableType *, TableType * >::type container_pointer_type
Definition: table.h:990
friend bool operator==(const AccessorBase< TableType, Constness, storage_order > &left, const AccessorBase< TableType, OtherConstness, storage_order > &right)
Definition: table.h:1028
typename TableType::size_type size_type
Definition: table.h:1000
Accessor class offering read and write access to the elements of a table.
Definition: table.h:1123
typename AccessorBase< TableType, true, storage_order >::value_type value_type
Definition: table.h:1129
const Accessor< TableType, false, storage_order > & operator=(value_type &&) const
typename AccessorBase< TableType, true, storage_order >::size_type size_type
Definition: table.h:1135
const Accessor< TableType, false, storage_order > & operator=(const value_type &) const
typename AccessorBase< TableType, true, storage_order >::value_type value_type
Definition: table.h:1102
typename AccessorBase< TableType, true, storage_order >::size_type size_type
Definition: table.h:1108
Accessor class template. This class is partially specialized for both values of Constness.
Definition: table.h:964
Iterator class for both matrix-like tables, i.e., Table<2, T> and TransposeTable.
Definition: table.h:1191
Iterator(const container_pointer_type object, const size_type row, const size_type column)
Iterator(const Accessor< TableType, Constness, storage_order > &accessor)
Iterator(const container_pointer_type object)
Iterator(const Iterator< TableType, false, storage_order > &i)
typename std::conditional< Constness, const TableType *, TableType * >::type container_pointer_type
Definition: table.h:1202
Iterator(const container_pointer_type container, const std::ptrdiff_t linear_index)
typename TableType::size_type size_type
Definition: table.h:1196
void swap(TableBase< N, T > &v)
void replicate_across_communicator(const MPI_Comm &communicator, const unsigned int root_process)
AlignedVector< T >::const_reference operator()(const TableIndices< N > &indices) const
void fill(const T &value)
friend class TableBase
Definition: table.h:804
AlignedVector< T >::reference operator()(const TableIndices< N > &indices)
std::size_t memory_consumption() const
void reinit(const TableIndices< N > &new_size, const bool omit_default_initialization=false)
AlignedVector< T >::const_reference el(const TableIndices< N > &indices) const
AlignedVector< T > values
Definition: table.h:795
~TableBase() override=default
typename AlignedVector< T >::size_type size_type
Definition: table.h:448
size_type n_elements() const
void clear()
TableBase(const TableBase< N, T2 > &src)
TableBase(const TableIndices< N > &sizes, InputIterator entries, const bool C_style_indexing=true)
T value_type
Definition: table.h:443
bool operator==(const TableBase< N, T > &T2) const
const TableIndices< N > & size() const
TableBase()=default
TableBase< N, T > & operator=(const TableBase< N, T2 > &src)
size_type position(const TableIndices< N > &indices) const
TableBase(const TableBase< N, T > &src)
bool empty() const
AlignedVector< T >::reference el(const TableIndices< N > &indices)
void fill(InputIterator entries, const bool C_style_indexing=true)
TableBase< N, T > & operator=(const TableBase< N, T > &src)
void serialize(Archive &ar, const unsigned int version)
void reset_values()
TableBase(const TableIndices< N > &sizes)
size_type size(const unsigned int i) const
TableBase(TableBase< N, T > &&src) noexcept
TableIndices< N > table_size
Definition: table.h:800
TableBase< N, T > & operator=(TableBase< N, T > &&src) noexcept
AlignedVector< T >::const_reference operator[](const size_type i) const
Table(const size_type size)
typename TableBase< 1, T >::size_type size_type
Definition: table.h:839
AlignedVector< T >::reference operator[](const size_type i)
AlignedVector< T >::const_reference operator()(const size_type i) const
AlignedVector< T >::reference operator()(const size_type i)
Table()=default
Table(const size_type size, InputIterator entries, const bool C_style_indexing=true)
size_type n_cols() const
typename AlignedVector< T >::const_reference const_reference
Definition: table.h:1271
AlignedVector< T >::reference el(const size_type i, const size_type j)
typename AlignedVector< T >::value_type value_type
Definition: table.h:1261
iterator end()
Table()=default
typename TableBase< 2, T >::size_type size_type
Definition: table.h:1256
::internal::TableBaseAccessors::Accessor< 2, T, true, 1 > operator[](const size_type i) const
AlignedVector< T >::const_reference operator()(const size_type i, const size_type j) const
typename AlignedVector< T >::reference reference
Definition: table.h:1266
AlignedVector< T >::reference operator()(const size_type i, const size_type j)
const_iterator end() const
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)
const_iterator begin() const
AlignedVector< T >::const_reference el(const size_type i, const size_type j) const
Table(const size_type size1, const size_type size2)
::internal::TableBaseAccessors::Accessor< 2, T, false, 1 > operator[](const size_type i)
size_type n_rows() const
iterator begin()
AlignedVector< T >::reference operator()(const size_type i, const size_type j, const size_type k)
Table()=default
::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)
Table(const size_type size1, const size_type size2, const size_type size3)
Table(const size_type size1, const size_type size2, const size_type size3, InputIterator entries, const bool C_style_indexing=true)
void reinit(const size_type size1, const size_type size2, const size_type size3, const bool omit_default_initialization=false)
typename TableBase< 3, T >::size_type size_type
Definition: table.h:1493
AlignedVector< T >::const_reference operator()(const size_type i, const size_type j, const size_type k) const
::internal::TableBaseAccessors::Accessor< 4, T, true, 3 > operator[](const size_type i) const
AlignedVector< T >::const_reference operator()(const size_type i, const size_type j, const size_type k, const size_type l) const
Table(const size_type size1, const size_type size2, const size_type size3, const size_type size4)
AlignedVector< T >::reference operator()(const size_type i, const size_type j, const size_type k, const size_type l)
::internal::TableBaseAccessors::Accessor< 4, T, false, 3 > operator[](const size_type i)
typename TableBase< 4, T >::size_type size_type
Definition: table.h:1627
Table()=default
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 TableBase< 5, T >::size_type size_type
Definition: table.h:1711
::internal::TableBaseAccessors::Accessor< 5, T, false, 4 > operator[](const size_type i)
::internal::TableBaseAccessors::Accessor< 5, T, true, 4 > operator[](const size_type i) const
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
Table()=default
Table(const size_type size1, const size_type size2, const size_type size3, const size_type size4, const size_type size5)
Table()=default
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)
::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)
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
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)
typename TableBase< 6, T >::size_type size_type
Definition: table.h:1798
::internal::TableBaseAccessors::Accessor< 7, T, false, 6 > operator[](const size_type i)
::internal::TableBaseAccessors::Accessor< 7, T, true, 6 > operator[](const size_type i) const
typename TableBase< 7, T >::size_type size_type
Definition: table.h:1886
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)
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)
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
void reinit(const size_type size1, const size_type size2, const bool omit_default_initialization=false)
TransposeTable(const size_type size1, const size_type size2)
MatrixTableIterators::Iterator< TransposeTable< T >, false, MatrixTableIterators::Storage::column_major > iterator
Definition: table.h:2012
size_type n_rows() const
reference el(const size_type i, const size_type j)
const_iterator begin() const
size_type n_cols() const
TransposeTable()=default
MatrixTableIterators::Iterator< TransposeTable< T >, true, MatrixTableIterators::Storage::column_major > const_iterator
Definition: table.h:2004
const_iterator end() const
iterator end()
typename AlignedVector< T >::reference reference
Definition: table.h:1990
typename TableBase< 2, T >::size_type size_type
Definition: table.h:1980
iterator begin()
const_reference operator()(const size_type i, const size_type j) const
typename AlignedVector< T >::value_type value_type
Definition: table.h:1985
const_reference el(const size_type i, const size_type j) const
reference operator()(const size_type i, const size_type j)
typename AlignedVector< T >::const_reference const_reference
Definition: table.h:1995
typename Types< N, T, C >::value_type value_type
Definition: table.h:246
typename Types< N, T, C >::const_iterator const_iterator
Definition: table.h:249
typename Types< N, T, C >::TableType TableType
Definition: table.h:260
typename Types< N, T, C >::const_reference const_reference
Definition: table.h:252
typename Types< N, T, C >::iterator iterator
Definition: table.h:248
reference operator[](const size_type) const
typename Types< N, T, C >::reference reference
Definition: table.h:251
Accessor(const TableType &table, const iterator data)
typename Types< N, T, C >::TableType TableType
Definition: table.h:163
Accessor< N, T, C, P - 1 > operator[](const size_type i) const
typename Types< N, T, C >::iterator iterator
Definition: table.h:165
Accessor(const TableType &table, const iterator data)
typename Types< N, T, C >::const_iterator const_iterator
Definition: table.h:166
#define DEAL_II_NAMESPACE_OPEN
Definition: config.h:442
#define DEAL_II_NAMESPACE_CLOSE
Definition: config.h:443
static ::ExceptionBase & ExcInternalError()
#define Assert(cond, exc)
Definition: exceptions.h:1473
static ::ExceptionBase & ExcNotImplemented()
static ::ExceptionBase & ExcIndexRange(size_type arg1, size_type arg2, size_type arg3)
#define AssertIndexRange(index, range)
Definition: exceptions.h:1732
#define DeclException3(Exception3, type1, type2, type3, outsequence)
Definition: exceptions.h:555
static ::ExceptionBase & ExcMessage(std::string arg1)
static const char T
static const char N
types::global_dof_index size_type
Definition: cuda_kernels.h:45
Storage
Enumeration describing the storage order (i.e., the in-memory layout) of a table class.
Definition: table.h:943
std::enable_if< std::is_fundamental< T >::value, std::size_t >::type memory_consumption(const T &t)
SymmetricTensor< 2, dim, Number > C(const Tensor< 2, dim, Number > &F)
Tensor< 2, dim, Number > l(const Tensor< 2, dim, Number > &F, const Tensor< 2, dim, Number > &dF_dt)
VectorType::value_type * begin(VectorType &V)
VectorType::value_type * end(VectorType &V)
std::enable_if< is_mpi_type< T >==false, T >::type broadcast(const MPI_Comm &comm, const T &object_to_send, const unsigned int root_process=0)
void copy(const T *begin, const T *end, U *dest)
void reinit(MatrixBlock< MatrixType > &v, const BlockSparsityPattern &p)
Definition: matrix_block.h:618
typename AlignedVector< T >::iterator iterator
Definition: table.h:115
typename AlignedVector< T >::const_iterator const_iterator
Definition: table.h:116
typename AlignedVector< T >::reference reference
Definition: table.h:118
typename AlignedVector< T >::const_reference const_reference
Definition: table.h:119
typename AlignedVector< T >::const_iterator const_iterator
Definition: table.h:98
typename AlignedVector< T >::const_reference const_reference
Definition: table.h:101
typename AlignedVector< T >::const_iterator iterator
Definition: table.h:97
typename AlignedVector< T >::const_reference reference
Definition: table.h:100
void swap(TableBase< N, T > &u, TableBase< N, T > &v)
Definition: table.h:3715