16 #ifndef dealii_table_h 17 #define dealii_table_h 19 #include <deal.II/base/config.h> 21 #include <deal.II/base/aligned_vector.h> 22 #include <deal.II/base/exceptions.h> 23 #include <deal.II/base/linear_index_iterator.h> 24 #include <deal.II/base/memory_consumption.h> 25 #include <deal.II/base/subscriptor.h> 26 #include <deal.II/base/table_indices.h> 31 DEAL_II_NAMESPACE_OPEN
34 template <
int N,
typename T>
36 template <
int N,
typename T>
73 namespace TableBaseAccessors
82 template <
int N,
typename T,
bool Constness>
91 template <
int N,
typename T>
92 struct Types<N, T, true>
97 using iterator =
typename AlignedVector<T>::const_iterator;
100 using reference =
typename AlignedVector<T>::const_reference;
109 template <
int N,
typename T>
110 struct Types<N, T, false>
115 using iterator =
typename AlignedVector<T>::iterator;
118 using reference =
typename AlignedVector<T>::reference;
161 template <
int N,
typename T,
bool C,
unsigned int P>
165 using TableType =
typename Types<N, T, C>::TableType;
167 using iterator =
typename Types<N, T, C>::iterator;
171 using difference_type = ptrdiff_t;
179 Accessor(
const TableType &table,
const iterator data);
194 Accessor(
const Accessor &a);
199 Accessor<N, T, C, P - 1> operator[](
const size_type i)
const;
209 <<
"Index " << N - P + 1 <<
"has a value of " << arg1
210 <<
" but needs to be in the range [" << arg2 <<
"," << arg3
219 const TableType &table;
226 template <
int N1,
typename T1>
227 friend class ::Table;
228 template <
int N1,
typename T1,
bool C1,
unsigned int P1>
229 friend class Accessor;
230 #ifndef DEAL_II_TEMPL_SPEC_FRIEND_BUG 231 friend class ::Table<N, T>;
232 friend class Accessor<N, T, C, P + 1>;
247 template <
int N,
typename T,
bool C>
248 class Accessor<N, T, C, 1>
256 using value_type =
typename Types<N, T, C>::value_type;
258 using iterator =
typename Types<N, T, C>::iterator;
261 using reference =
typename Types<N, T, C>::reference;
265 using difference_type = ptrdiff_t;
270 using TableType =
typename Types<N, T, C>::TableType;
284 Accessor(
const TableType &table,
const iterator data);
299 Accessor(
const Accessor &a);
332 const TableType &table;
339 template <
int N1,
typename T1>
340 friend class ::Table;
341 template <
int N1,
typename T1,
bool C1,
unsigned int P1>
342 friend class Accessor;
343 #ifndef DEAL_II_TEMPL_SPEC_FRIEND_BUG 344 friend class ::Table<2, T>;
345 friend class Accessor<N, T, C, 2>;
420 template <
int N,
typename T>
448 template <
typename InputIterator>
450 InputIterator entries,
451 const bool C_style_indexing =
true);
462 template <
typename T2>
493 template <typename T2>
502 operator=(
TableBase<N, T> &&src) noexcept;
508 operator==(const
TableBase<N, T> &T2) const;
527 const
bool omit_default_initialization = false);
533 size(const
unsigned int i) const;
591 template <typename InputIterator>
593 fill(InputIterator entries, const
bool C_style_indexing = true);
599 fill(const T &value);
637 memory_consumption() const;
643 template <class Archive>
645 serialize(Archive &ar, const
unsigned int version);
691 template <
int, typename>
709 template <
int N, typename T>
710 class
Table : public TableBase<N, T>
726 template <
typename T>
782 template <
typename InputIterator>
784 InputIterator entries,
785 const bool C_style_indexing =
true);
791 typename AlignedVector<T>::const_reference
798 typename AlignedVector<T>::reference operator[](
const size_type i);
804 typename AlignedVector<T>::const_reference
811 typename AlignedVector<T>::reference
818 typename AlignedVector<T>::reference
825 typename AlignedVector<T>::const_reference
844 template <
typename T>
901 template <
typename InputIterator>
904 InputIterator entries,
905 const bool C_style_indexing =
true);
915 const bool omit_default_initialization =
false);
925 ::internal::TableBaseAccessors::Accessor<2, T, true, 1>
934 ::internal::TableBaseAccessors::Accessor<2, T, false, 1>
943 typename AlignedVector<T>::const_reference
953 typename AlignedVector<T>::reference
960 typename AlignedVector<T>::reference
967 typename AlignedVector<T>::const_reference
996 typename AlignedVector<T>::reference
1013 typename AlignedVector<T>::const_reference
1029 template <
typename T>
1088 template <
typename InputIterator>
1092 InputIterator entries,
1093 const bool C_style_indexing =
true);
1102 ::internal::TableBaseAccessors::Accessor<3, T, true, 2>
1112 ::internal::TableBaseAccessors::Accessor<3, T, false, 2>
1121 typename AlignedVector<T>::const_reference
1131 typename AlignedVector<T>::reference
1138 typename AlignedVector<T>::reference
1145 typename AlignedVector<T>::const_reference
1161 template <
typename T>
1190 ::internal::TableBaseAccessors::Accessor<4, T, true, 3>
1200 ::internal::TableBaseAccessors::Accessor<4, T, false, 3>
1209 typename AlignedVector<T>::const_reference
1222 typename AlignedVector<T>::reference
1232 typename AlignedVector<T>::reference
1239 typename AlignedVector<T>::const_reference
1255 template <
typename T>
1286 ::internal::TableBaseAccessors::Accessor<5, T, true, 4>
1296 ::internal::TableBaseAccessors::Accessor<5, T, false, 4>
1305 typename AlignedVector<T>::const_reference
1318 typename AlignedVector<T>::reference
1329 typename AlignedVector<T>::reference
1336 typename AlignedVector<T>::const_reference
1352 template <
typename T>
1383 ::internal::TableBaseAccessors::Accessor<6, T, true, 5>
1393 ::internal::TableBaseAccessors::Accessor<6, T, false, 5>
1402 typename AlignedVector<T>::const_reference
1416 typename AlignedVector<T>::reference
1428 typename AlignedVector<T>::reference
1435 typename AlignedVector<T>::const_reference
1450 template <
typename T>
1482 ::internal::TableBaseAccessors::Accessor<7, T, true, 6>
1492 ::internal::TableBaseAccessors::Accessor<7, T, false, 6>
1501 typename AlignedVector<T>::const_reference
1516 typename AlignedVector<T>::reference
1529 typename AlignedVector<T>::reference
1536 typename AlignedVector<T>::const_reference
1549 template <
typename T,
bool Constness>
1556 template <
typename T,
bool Constness>
1563 template <
typename T,
bool Constness>
1571 typename std::conditional<Constness,
1573 TransposeTable<T> *>::type;
1595 const std::ptrdiff_t linear_index);
1647 template <
typename T>
1661 template <
typename T>
1675 operator=(
const T &)
const;
1682 operator=(T &&)
const;
1701 template <
typename T,
bool Constness>
1715 typename std::conditional<Constness,
1717 TransposeTable<T> *>::type;
1745 const std::ptrdiff_t linear_index);
1763 template <
typename T>
1816 const bool omit_default_initialization =
false);
1925 template <
int N,
typename T>
1933 template <
int N,
typename T>
1934 template <
typename InputIterator>
1936 InputIterator entries,
1937 const bool C_style_indexing)
1940 fill(entries, C_style_indexing);
1945 template <
int N,
typename T>
1955 template <
int N,
typename T>
1956 template <
typename T2>
1966 template <
int N,
typename T>
1977 template <
int N,
typename T>
1978 template <
class Archive>
1991 namespace TableBaseAccessors
1993 template <
int N,
typename T,
bool C,
unsigned int P>
1994 inline Accessor<N, T, C, P>::Accessor(
const TableType &table,
2002 template <
int N,
typename T,
bool C,
unsigned int P>
2003 inline Accessor<N, T, C, P>::Accessor(
const Accessor &a)
2010 template <
int N,
typename T,
bool C,
unsigned int P>
2011 inline Accessor<N, T, C, P - 1> Accessor<N, T, C, P>::
2020 return Accessor<N, T, C, P - 1>(table, data);
2026 size_type subobject_size = table.size()[N - 1];
2027 for (
int p = P - 1; p > 1; --p)
2028 subobject_size *= table.size()[N - p];
2029 const iterator new_data = data + i * subobject_size;
2030 return Accessor<N, T, C, P - 1>(table, new_data);
2036 template <
int N,
typename T,
bool C>
2037 inline Accessor<N, T, C, 1>::Accessor(
const TableType &table,
2045 template <
int N,
typename T,
bool C>
2046 inline Accessor<N, T, C, 1>::Accessor(
const Accessor &a)
2053 template <
int N,
typename T,
bool C>
2054 inline typename Accessor<N, T, C, 1>::reference Accessor<N, T, C, 1>::
2063 template <
int N,
typename T,
bool C>
2064 inline typename Accessor<N, T, C, 1>::size_type
2065 Accessor<N, T, C, 1>::size()
const 2067 return table.size()[N - 1];
2072 template <
int N,
typename T,
bool C>
2073 inline typename Accessor<N, T, C, 1>::iterator
2074 Accessor<N, T, C, 1>::begin()
const 2081 template <
int N,
typename T,
bool C>
2082 inline typename Accessor<N, T, C, 1>::iterator
2083 Accessor<N, T, C, 1>::end()
const 2085 return data + table.size()[N - 1];
2092 template <
int N,
typename T>
2105 template <
int N,
typename T>
2106 template <
typename T2>
2112 std::copy(m.
values.begin(),
2121 template <
int N,
typename T>
2135 template <
int N,
typename T>
2144 template <
int N,
typename T>
2155 template <
int N,
typename T>
2165 template <
int N,
typename T>
2168 const bool omit_default_initialization)
2193 if (!omit_default_initialization)
2199 values.resize_fast(new_size);
2204 values.resize_fast(new_size);
2209 template <
int N,
typename T>
2218 template <
int N,
typename T>
2228 template <
int N,
typename T>
2233 for (
unsigned int n = 0; n < N; ++n)
2240 template <
int N,
typename T>
2251 namespace TableImplementation
2253 template <
typename InputIterator,
typename T>
2263 template <
typename InputIterator,
typename T>
2274 template <
typename InputIterator,
typename T>
2286 template <
typename InputIterator,
typename T,
int N>
2296 template <
int N,
typename T>
2297 template <
typename InputIterator>
2303 if (C_style_indexing)
2304 for (
typename AlignedVector<T>::iterator p =
values.begin();
2309 internal::TableImplementation::fill_Fortran_style(entries, *
this);
2314 template <
int N,
typename T>
2324 template <
int N,
typename T>
2333 template <
int N,
typename T>
2354 unsigned int s = indices[0];
2355 for (
unsigned int n = 1; n < N; ++n)
2364 template <
int N,
typename T>
2365 inline typename AlignedVector<T>::const_reference
2368 for (
unsigned int n = 0; n < N; ++n)
2375 template <
int N,
typename T>
2376 inline typename AlignedVector<T>::reference
2379 for (
unsigned int n = 0; n < N; ++n)
2386 template <
int N,
typename T>
2387 inline typename AlignedVector<T>::const_reference
2395 template <
int N,
typename T>
2396 inline typename AlignedVector<T>::reference
2405 template <
typename T>
2412 template <
typename T>
2413 template <
typename InputIterator>
2415 InputIterator entries,
2416 const bool C_style_indexing)
2422 template <
typename T>
2423 inline typename AlignedVector<T>::const_reference
Table<1, T>:: 2432 template <
typename T>
2442 template <
typename T>
2443 inline typename AlignedVector<T>::const_reference
2452 template <
typename T>
2453 inline typename AlignedVector<T>::reference
2462 template <
typename T>
2463 inline typename AlignedVector<T>::const_reference
2471 template <
typename T>
2472 inline typename AlignedVector<T>::reference
2483 template <
typename T>
2490 template <
typename T>
2491 template <
typename InputIterator>
2494 InputIterator entries,
2495 const bool C_style_indexing)
2501 template <
typename T>
2505 const bool omit_default_initialization)
2508 omit_default_initialization);
2513 template <
typename T>
2514 inline ::internal::TableBaseAccessors::Accessor<2, T, true, 1>
2518 return ::internal::TableBaseAccessors::Accessor<2, T, true, 1>(
2524 template <
typename T>
2525 inline ::internal::TableBaseAccessors::Accessor<2, T, false, 1>
2529 return ::internal::TableBaseAccessors::Accessor<2, T, false, 1>(
2535 template <
typename T>
2536 inline typename AlignedVector<T>::const_reference
2546 template <
typename T>
2547 inline typename AlignedVector<T>::reference
2557 template <
typename T>
2558 inline typename AlignedVector<T>::const_reference
2566 template <
typename T>
2567 inline typename AlignedVector<T>::reference
2575 template <
typename T>
2576 inline typename AlignedVector<T>::const_reference
2584 template <
typename T>
2585 inline typename AlignedVector<T>::reference
2593 template <
typename T>
2602 template <
typename T>
2614 template <
typename T,
bool Constness>
2615 inline AccessorBase<T, Constness>::AccessorBase()
2616 : container(nullptr)
2617 , linear_index(
std::numeric_limits<decltype(linear_index)>::max())
2622 template <
typename T,
bool Constness>
2623 inline AccessorBase<T, Constness>::AccessorBase(
2624 const container_pointer_type table)
2631 template <
typename T,
bool Constness>
2632 inline AccessorBase<T, Constness>::AccessorBase(
2633 const AccessorBase<T, false> &a)
2634 : container(a.container)
2635 , linear_index(a.linear_index)
2640 template <
typename T,
bool Constness>
2641 inline AccessorBase<T, Constness>::AccessorBase(
2642 const container_pointer_type table,
2643 const std::ptrdiff_t index)
2645 , linear_index(index)
2647 Assert(0 <= linear_index && linear_index < container->
values.size() + 1,
2648 ExcMessage(
"The current iterator points outside of the table and is " 2649 "not the end iterator."));
2654 template <
typename T,
bool Constness>
2656 AccessorBase<T, Constness>::value()
const 2658 Assert(0 <= linear_index && linear_index < container->
values.size(),
2659 ExcMessage(
"The current iterator points outside of the table."));
2660 return this->container->values[linear_index];
2665 template <
typename T,
bool Constness>
2666 inline typename AccessorBase<T, Constness>::size_type
2667 AccessorBase<T, Constness>::AccessorBase::row()
const 2669 Assert(!container->empty(),
2670 ExcMessage(
"An empty table has no rows or columns."));
2671 const auto row_n = linear_index % container->n_rows();
2673 ExcMessage(
"The current iterator points outside the table."));
2679 template <
typename T,
bool Constness>
2680 inline typename AccessorBase<T, Constness>::size_type
2681 AccessorBase<T, Constness>::AccessorBase::column()
const 2683 Assert(!container->empty(),
2684 ExcMessage(
"An empty table has no rows or columns."));
2685 const auto column_n = linear_index / container->n_rows();
2686 Assert(0 <= column_n && column_n < container->
n_cols(),
2687 ExcMessage(
"The current iterator points outside the table."));
2692 template <
typename T>
2693 inline const Accessor<T, false> &
2694 Accessor<T, false>::operator=(
const T &t)
const 2696 Assert(0 <= this->linear_index &&
2697 this->linear_index < this->container->values.size(),
2698 ExcMessage(
"The current iterator points outside of the table."));
2699 this->container->values[this->linear_index] = t;
2705 template <
typename T>
2706 inline const Accessor<T, false> &
2707 Accessor<T, false>::operator=(T &&t)
const 2709 Assert(0 <= this->linear_index &&
2710 this->linear_index < this->container->values.size(),
2711 ExcMessage(
"The current iterator points outside of the table."));
2712 this->container->values[this->linear_index] = t;
2718 template <
typename T>
2720 Accessor<T, false>::value()
const 2722 Assert(0 <= this->linear_index &&
2723 this->linear_index < this->container->values.size(),
2724 ExcMessage(
"The current iterator points outside of the table."));
2725 return this->container->values[this->linear_index];
2730 template <
typename T,
bool Constness>
2731 Iterator<T, Constness>::Iterator(
const Accessor<T, Constness> &a)
2737 template <
typename T,
bool Constness>
2738 Iterator<T, Constness>::Iterator(
const container_pointer_type table)
2740 Accessor<T, Constness>(table))
2745 template <
typename T,
bool Constness>
2746 Iterator<T, Constness>::Iterator(
const Iterator<T, false> &i)
2752 template <
typename T,
bool Constness>
2753 Iterator<T, Constness>::Iterator(
const container_pointer_type table,
2756 : Iterator(table, table->
n_rows() * col_n + row_n)
2761 template <
typename T,
bool Constness>
2762 Iterator<T, Constness>::Iterator(
const container_pointer_type table,
2763 const std::ptrdiff_t linear_index)
2765 Accessor<T, Constness>(table, linear_index))
2772 template <
typename T>
2780 template <
typename T>
2784 const bool omit_default_initialization)
2787 omit_default_initialization);
2792 template <
typename T>
2803 template <
typename T>
2814 template <
typename T>
2823 template <
typename T>
2832 template <
typename T>
2841 template <
typename T>
2850 template <
typename T>
2859 template <
typename T>
2868 template <
typename T>
2877 template <
typename T>
2887 template <
typename T>
2896 template <
typename T>
2897 template <
typename InputIterator>
2901 InputIterator entries,
2902 const bool C_style_indexing)
2910 template <
typename T>
2911 inline ::internal::TableBaseAccessors::Accessor<3, T, true, 2>
2917 return (::internal::TableBaseAccessors::Accessor<3, T, true, 2>(
2918 *
this, this->
values.begin() + i * subobject_size));
2923 template <
typename T>
2924 inline ::internal::TableBaseAccessors::Accessor<3, T, false, 2>
2930 return (::internal::TableBaseAccessors::Accessor<3, T, false, 2>(
2931 *
this, this->
values.begin() + i * subobject_size));
2936 template <
typename T>
2937 inline typename AlignedVector<T>::const_reference
2951 template <
typename T>
2952 inline typename AlignedVector<T>::reference
2965 template <
typename T>
2966 inline typename AlignedVector<T>::const_reference
2974 template <
typename T>
2975 inline typename AlignedVector<T>::reference
2983 template <
typename T>
2993 template <
typename T>
2994 inline ::internal::TableBaseAccessors::Accessor<4, T, true, 3>
3000 return (::internal::TableBaseAccessors::Accessor<4, T, true, 3>(
3001 *
this, this->
values.begin() + i * subobject_size));
3006 template <
typename T>
3007 inline ::internal::TableBaseAccessors::Accessor<4, T, false, 3>
3012 size_type(this->table_size[1]) * this->table_size[2] * this->table_size[3];
3013 return (::internal::TableBaseAccessors::Accessor<4, T, false, 3>(
3014 *
this, this->
values.begin() + i * subobject_size));
3019 template <
typename T>
3020 inline typename AlignedVector<T>::const_reference
3031 ->values[((
size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3033 this->table_size[3] +
3039 template <
typename T>
3040 inline typename AlignedVector<T>::reference
3051 ->values[((
size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3053 this->table_size[3] +
3059 template <
typename T>
3060 inline typename AlignedVector<T>::const_reference
3068 template <
typename T>
3069 inline typename AlignedVector<T>::reference
3077 template <
typename T>
3088 template <
typename T>
3089 inline ::internal::TableBaseAccessors::Accessor<5, T, true, 4>
3094 this->table_size[2] * this->table_size[3] *
3095 this->table_size[4];
3096 return (::internal::TableBaseAccessors::Accessor<5, T, true, 4>(
3097 *
this, this->
values.begin() + i * subobject_size));
3102 template <
typename T>
3103 inline ::internal::TableBaseAccessors::Accessor<5, T, false, 4>
3108 this->table_size[2] * this->table_size[3] *
3109 this->table_size[4];
3110 return (::internal::TableBaseAccessors::Accessor<5, T, false, 4>(
3111 *
this, this->
values.begin() + i * subobject_size));
3116 template <
typename T>
3117 inline typename AlignedVector<T>::const_reference
3130 ->values[(((
size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3132 this->table_size[3] +
3134 this->table_size[4] +
3140 template <
typename T>
3141 inline typename AlignedVector<T>::reference
3154 ->values[(((
size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3156 this->table_size[3] +
3158 this->table_size[4] +
3164 template <
typename T>
3165 inline typename AlignedVector<T>::const_reference
3173 template <
typename T>
3174 inline typename AlignedVector<T>::reference
3182 template <
typename T>
3192 table_indices[0] = size1;
3193 table_indices[1] = size2;
3194 table_indices[2] = size3;
3195 table_indices[3] = size4;
3196 table_indices[4] = size5;
3197 table_indices[5] = size6;
3204 template <
typename T>
3205 inline ::internal::TableBaseAccessors::Accessor<6, T, true, 5>
3210 this->table_size[2] * this->table_size[3] *
3211 this->table_size[4] * this->table_size[5];
3212 return (::internal::TableBaseAccessors::Accessor<6, T, true, 5>(
3213 *
this, this->
values.begin() + i * subobject_size));
3218 template <
typename T>
3219 inline ::internal::TableBaseAccessors::Accessor<6, T, false, 5>
3224 this->table_size[2] * this->table_size[3] *
3225 this->table_size[4] * this->table_size[5];
3226 return (::internal::TableBaseAccessors::Accessor<6, T, false, 5>(
3227 *
this, this->
values.begin() + i * subobject_size));
3232 template <
typename T>
3233 inline typename AlignedVector<T>::const_reference
3248 ->values[((((
size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3250 this->table_size[3] +
3252 this->table_size[4] +
3254 this->table_size[5] +
3260 template <
typename T>
3261 inline typename AlignedVector<T>::reference
3276 ->values[((((
size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3278 this->table_size[3] +
3280 this->table_size[4] +
3282 this->table_size[5] +
3288 template <
typename T>
3289 inline typename AlignedVector<T>::const_reference
3297 template <
typename T>
3298 inline typename AlignedVector<T>::reference
3306 template <
typename T>
3317 table_indices[0] = size1;
3318 table_indices[1] = size2;
3319 table_indices[2] = size3;
3320 table_indices[3] = size4;
3321 table_indices[4] = size5;
3322 table_indices[5] = size6;
3323 table_indices[6] = size7;
3330 template <
typename T>
3331 inline ::internal::TableBaseAccessors::Accessor<7, T, true, 6>
3336 size_type(this->table_size[1]) * this->table_size[2] * this->table_size[3] *
3337 this->table_size[4] * this->table_size[5] * this->table_size[6];
3338 return (::internal::TableBaseAccessors::Accessor<7, T, true, 6>(
3339 *
this, this->
values.begin() + i * subobject_size));
3344 template <
typename T>
3345 inline ::internal::TableBaseAccessors::Accessor<7, T, false, 6>
3350 size_type(this->table_size[1]) * this->table_size[2] * this->table_size[3] *
3351 this->table_size[4] * this->table_size[5] * this->table_size[6];
3352 return (::internal::TableBaseAccessors::Accessor<7, T, false, 6>(
3353 *
this, this->
values.begin() + i * subobject_size));
3358 template <
typename T>
3359 inline typename AlignedVector<T>::const_reference
3376 [(((((
size_type(i) * this->table_size[1] + j) * this->table_size[2] + k) *
3377 this->table_size[3] +
3379 this->table_size[4] +
3381 this->table_size[5] +
3383 this->table_size[6] +
3389 template <
typename T>
3390 inline typename AlignedVector<T>::reference
3407 [(((((
size_type(i) * this->table_size[1] + j) * this->table_size[2] + k) *
3408 this->table_size[3] +
3410 this->table_size[4] +
3412 this->table_size[5] +
3414 this->table_size[6] +
3420 template <
typename T>
3421 inline typename AlignedVector<T>::const_reference
3429 template <
typename T>
3430 inline typename AlignedVector<T>::reference
3448 template <
int N,
typename T>
3455 DEAL_II_NAMESPACE_CLOSE
typename TableBase< 3, T >::size_type size_type
typename std::conditional< Constness, const TransposeTable< T > *, TransposeTable< T > * >::type container_pointer_type
void serialize(Archive &ar, const unsigned int version)
void swap(TableBase< N, T > &v)
typename TableBase< 2, T >::size_type size_type
typename TableBase< 6, T >::size_type size_type
typename std::conditional< Constness, const TransposeTable< T > *, TransposeTable< T > * >::type container_pointer_type
typename AlignedVector< T >::reference reference
#define AssertIndexRange(index, range)
typename TableBase< 2, T >::size_type size_type
static::ExceptionBase & ExcIndexRange(int arg1, int arg2, int arg3)
typename AlignedVector< T >::value_type value_type
typename TableBase< 1, T >::size_type size_type
TransposeTableIterators::Iterator< T, false > iterator
container_pointer_type container
const TableIndices< N > & size() const
typename TableBase< 4, T >::size_type size_type
static::ExceptionBase & ExcMessage(std::string arg1)
typename TransposeTable< T >::size_type size_type
void reinit(const TableIndices< N > &new_size, const bool omit_default_initialization=false)
size_type size(const unsigned int i) const
#define Assert(cond, exc)
typename TransposeTable< T >::size_type size_type
void reinit(const size_type size1, const size_type size2, const bool omit_default_initialization=false)
AlignedVector< T >::reference el(const TableIndices< N > &indices)
std::size_t memory_consumption() const
void swap(Vector< Number > &u, Vector< Number > &v)
size_type n_elements() const
size_type position(const TableIndices< N > &indices) const
const_reference operator()(const size_type i, const size_type j) const
TableBase< N, T > & operator=(const TableBase< N, T > &src)
typename AlignedVector< T >::size_type size_type
TransposeTableIterators::Iterator< T, true > const_iterator
typename TableBase< 5, T >::size_type size_type
std::ptrdiff_t linear_index
reference el(const size_type i, const size_type j)
static::ExceptionBase & ExcNotImplemented()
TableIndices< N > table_size
#define DeclException3(Exception3, type1, type2, type3, outsequence)
AlignedVector< T >::reference operator()(const TableIndices< N > &indices)
AlignedVector< T > values
typename TableBase< 7, T >::size_type size_type
void fill(InputIterator entries, const bool C_style_indexing=true)
std::enable_if< std::is_fundamental< T >::value, std::size_t >::type memory_consumption(const T &t)
typename AlignedVector< T >::const_reference const_reference
bool operator==(const TableBase< N, T > &T2) const