35template <
int N,
typename T>
37template <
int N,
typename T>
73 namespace TableBaseAccessors
82 template <
int N,
typename T,
bool Constness>
91 template <
int N,
typename T>
109 template <
int N,
typename T>
159 template <
int N,
typename T,
bool C,
unsigned int P>
203 <<
"Index " << N - P + 1 <<
"has a value of " << arg1
204 <<
" but needs to be in the range [" << arg2 <<
',' << arg3
220 template <
int N1,
typename T1>
221 friend class ::Table;
222 template <
int N1,
typename T1,
bool C1,
unsigned int P1>
224 friend class ::Table<N, T>;
225 friend class Accessor<N, T, C, P + 1>;
237 template <
int N,
typename T,
bool C>
324 template <
int N1,
typename T1>
325 friend class ::Table;
326 template <
int N1,
typename T1,
bool C1,
unsigned int P1>
328 friend class ::Table<2, T>;
439template <
int N,
typename T>
467 template <
typename InputIterator>
469 InputIterator entries,
470 const bool C_style_indexing =
true);
481 template <
typename T2>
512 template <
typename T2>
546 const bool omit_default_initialization =
false);
558 size(
const unsigned int i)
const;
616 template <
typename InputIterator>
618 fill(InputIterator entries,
const bool C_style_indexing =
true);
728 const unsigned int root_process);
757 template <
class Archive>
803 template <
int,
typename>
820template <
int N,
typename T>
888 template <
typename InputIterator>
890 InputIterator entries,
891 const bool C_style_indexing =
true);
956 template <
typename TableType,
bool Constness, Storage storage_order>
963 template <
typename TableType,
bool Constness, Storage storage_order>
982 template <
typename TableType,
bool Constness, Storage storage_order>
990 std::conditional_t<Constness, const TableType *, TableType *>;
1026 template <
bool OtherConstness>
1081 friend class AccessorBase<TableType, true, storage_order>;
1085 Iterator<TableType, Constness, storage_order>,
1086 Accessor<TableType, Constness, storage_order>>;
1093 template <
typename TableType, Storage storage_order>
1113 using AccessorBase<TableType,
true, storage_order>::AccessorBase;
1120 template <
typename TableType, Storage storage_order>
1140 using AccessorBase<TableType,
false, storage_order>::AccessorBase;
1160 using AccessorBase<TableType,
false, storage_order>::value;
1187 template <
typename TableType,
bool Constness, Storage storage_order>
1190 Accessor<TableType, Constness, storage_order>>
1202 std::conditional_t<Constness, const TableType *, TableType *>;
1230 const std::ptrdiff_t linear_index);
1249template <
typename T>
1334 template <
typename InputIterator>
1337 InputIterator entries,
1338 const bool C_style_indexing =
true);
1348 const bool omit_default_initialization =
false);
1465 AccessorBase<Table<2, T>, true, MatrixTableIterators::Storage::row_major>;
1467 AccessorBase<Table<2, T>, false, MatrixTableIterators::Storage::row_major>;
1472 Accessor<Table<2, T>, false, MatrixTableIterators::Storage::row_major>;
1486template <typename T>
1545 template <
typename InputIterator>
1549 InputIterator entries,
1550 const bool C_style_indexing =
true);
1560 const bool omit_default_initialization =
false);
1620template <
typename T>
1704template <
typename T>
1791template <
typename T>
1879template <
typename T>
1973template <
typename T>
2032 const bool omit_default_initialization =
false);
2130 MatrixTableIterators::Storage::column_major>;
2137 MatrixTableIterators::Storage::column_major>;
2146template <int N, typename T>
2154template <
int N,
typename T>
2155template <
typename InputIterator>
2157 InputIterator entries,
2158 const bool C_style_indexing)
2161 fill(entries, C_style_indexing);
2166template <
int N,
typename T>
2170 , table_size(src.table_size)
2175template <
int N,
typename T>
2176template <
typename T2>
2186template <
int N,
typename T>
2197template <
int N,
typename T>
2198template <
class Archive>
2211 namespace TableBaseAccessors
2213 template <
int N,
typename T,
bool C,
unsigned int P>
2215 const iterator data)
2222 template <
int N,
typename T,
bool C,
unsigned int P>
2223 inline Accessor<N, T, C, P>::Accessor(
const Accessor &a)
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
2240 return Accessor<N, T,
C, P - 1>(table, data);
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);
2256 template <
int N,
typename T,
bool C>
2257 inline Accessor<N, T, C, 1>::Accessor(
const TableType &table,
2258 const iterator data)
2265 template <
int N,
typename T,
bool C>
2266 inline Accessor<N, T, C, 1>::Accessor(
const Accessor &a)
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
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
2287 return table.size()[N - 1];
2292 template <
int N,
typename T,
bool C>
2293 inline typename Accessor<N, T, C, 1>::iterator
2294 Accessor<N, T, C, 1>::begin()
const
2301 template <
int N,
typename T,
bool C>
2302 inline typename Accessor<N, T, C, 1>::iterator
2303 Accessor<N, T, C, 1>::end()
const
2305 return data + table.size()[N - 1];
2312template <
int N,
typename T>
2325template <
int N,
typename T>
2326template <
typename T2>
2332 std::copy(m.
values.begin(),
2333 m.
values.begin() + n_elements(),
2341template <
int N,
typename T>
2355template <
int N,
typename T>
2359 return (values == T2.
values);
2364template <
int N,
typename T>
2369 if (n_elements() != 0)
2375template <
int N,
typename T>
2379 if (n_elements() != 0)
2385template <
int N,
typename T>
2388 const unsigned int root_process)
2392 values.replicate_across_communicator(communicator, root_process);
2400template <
int N,
typename T>
2403 const bool omit_default_initialization)
2405 table_size = new_sizes;
2407 const size_type new_size = n_elements();
2428 if (!omit_default_initialization)
2434 values.resize_fast(new_size);
2439 values.resize_fast(new_size);
2444template <
int N,
typename T>
2454template <
int N,
typename T>
2463template <
int N,
typename T>
2468 return table_size[i];
2473template <
int N,
typename T>
2478 for (
unsigned int n = 0; n < N; ++n)
2485template <
int N,
typename T>
2489 return (n_elements() == 0);
2496 namespace TableImplementation
2498 template <
typename InputIterator,
typename T>
2503 for (size_type i = 0; i < table.
size()[0]; ++i)
2508 template <
typename InputIterator,
typename T>
2513 for (size_type j = 0; j < table.
size()[1]; ++j)
2514 for (size_type i = 0; i < table.
size()[0]; ++i)
2519 template <
typename InputIterator,
typename T>
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)
2531 template <
typename InputIterator,
typename T,
int N>
2541template <
int N,
typename T>
2542template <
typename InputIterator>
2548 if (C_style_indexing)
2554 internal::TableImplementation::fill_Fortran_style(entries, *
this);
2559template <
int N,
typename T>
2564 std::swap(table_size, v.table_size);
2569template <
int N,
typename T>
2578template <
int N,
typename T>
2592 return size_type(indices[0]) * table_size[1] + indices[1];
2594 return ((
size_type(indices[0]) * table_size[1] + indices[1]) *
2599 unsigned int s = indices[0];
2600 for (
unsigned int n = 1; n < N; ++n)
2601 s = s * table_size[n] + indices[n];
2609template <
int N,
typename T>
2613 for (
unsigned int n = 0; n < N; ++n)
2620template <
int N,
typename T>
2624 for (
unsigned int n = 0; n < N; ++n)
2631template <
int N,
typename T>
2635 return values[position(indices)];
2640template <
int N,
typename T>
2645 return values[position(indices)];
2650template <
typename T>
2657template <
typename T>
2658template <
typename InputIterator>
2660 InputIterator entries,
2661 const bool C_style_indexing)
2667template <
typename T>
2677template <
typename T>
2687template <
typename T>
2697template <
typename T>
2710template <
typename T>
2717template <
typename T>
2718template <
typename InputIterator>
2720 const size_type size2,
2721 InputIterator entries,
2722 const bool C_style_indexing)
2728template <
typename T>
2731 const size_type size2,
2732 const bool omit_default_initialization)
2735 omit_default_initialization);
2740template <
typename T>
2741inline ::internal::TableBaseAccessors::Accessor<2, T, true, 1>
2745 return ::internal::TableBaseAccessors::Accessor<2, T, true, 1>(
2751template <
typename T>
2752inline ::internal::TableBaseAccessors::Accessor<2, T, false, 1>
2756 return ::internal::TableBaseAccessors::Accessor<2, T, false, 1>(
2762template <
typename T>
2773template <
typename T>
2784template <
typename T>
2793template <
typename T>
2802template <
typename T>
2806 return this->table_size[0];
2811template <
typename T>
2815 return this->table_size[1];
2820template <
typename T>
2829template <
typename T>
2838template <
typename T>
2847template <
typename T>
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)
2868 switch (storage_order)
2870 case Storage::row_major:
2871 return linear_index / container->n_cols();
2872 case Storage::column_major:
2873 return linear_index % container->n_rows();
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)
2887 switch (storage_order)
2889 case Storage::row_major:
2890 return linear_index % container->n_cols();
2891 case Storage::column_major:
2892 return linear_index / container->n_rows();
2902 template <
typename TableType,
bool Constness, Storage storage_order>
2904 : container(nullptr)
2905 , linear_index(
std::numeric_limits<decltype(linear_index)>::
max())
2910 template <
typename TableType,
bool Constness, Storage storage_order>
2911 inline AccessorBase<TableType, Constness, storage_order>::AccessorBase(
2912 const container_pointer_type table)
2914 , linear_index(container->
values.size())
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)
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)
2933 , linear_index(
index)
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."));
2943 template <
typename TableType,
bool Constness, Storage storage_order>
2944 inline const typename AccessorBase<TableType, Constness, storage_order>::
2946 AccessorBase<TableType, Constness, storage_order>::value()
const
2948 assert_valid_linear_index();
2949 return this->container->values[linear_index];
2954 template <
typename TableType,
bool Constness, Storage storage_order>
2955 inline AccessorBase<TableType, Constness, storage_order>::
2956 operator
const value_type &()
const
2958 assert_valid_linear_index();
2959 return this->container->values[linear_index];
2964 template <
typename TableType,
bool Constness, Storage storage_order>
2965 inline typename AccessorBase<TableType, Constness, storage_order>::size_type
2966 AccessorBase<TableType, Constness, storage_order>::row()
const
2968 assert_valid_linear_index();
2969 return static_cast<std::size_t
>(
2970 internal::get_row_index<TableType, storage_order>(linear_index,
2976 template <
typename TableType,
bool Constness, Storage storage_order>
2977 inline typename AccessorBase<TableType, Constness, storage_order>::size_type
2978 AccessorBase<TableType, Constness, storage_order>::column()
const
2980 assert_valid_linear_index();
2981 return static_cast<std::size_t
>(
2982 internal::get_column_index<TableType, storage_order>(linear_index,
2988 template <
typename TableType,
bool Constness, Storage storage_order>
2990 AccessorBase<TableType, Constness, storage_order>::assert_valid_linear_index()
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,
3005 const std::ptrdiff_t column_n =
3006 internal::get_column_index<TableType, storage_order>(linear_index,
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."));
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)
3023 this->assert_valid_linear_index();
3024 this->container->values[this->linear_index] = t;
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
3035 this->assert_valid_linear_index();
3036 this->container->values[this->linear_index] = t;
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
3046 this->assert_valid_linear_index();
3047 return this->container->values[this->linear_index];
3052 template <
typename TableType, Storage storage_order>
3053 inline Accessor<TableType, false, storage_order>::operator value_type &()
3055 this->assert_valid_linear_index();
3056 return this->container->values[this->linear_index];
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)
3065 Accessor<TableType, Constness, storage_order>>(a)
3070 template <
typename TableType,
bool Constness, Storage storage_order>
3071 inline Iterator<TableType, Constness, storage_order>::Iterator(
3072 const container_pointer_type table)
3074 Accessor<TableType, Constness, storage_order>>(
3075 Accessor<TableType, Constness, storage_order>(table))
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)
3084 Accessor<TableType, Constness, storage_order>>(*i)
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)
3096 table->n_cols() * row_n + col_n :
3097 table->n_rows() * col_n + row_n)
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)
3107 Accessor<TableType, Constness, storage_order>>(
3108 Accessor<TableType, Constness, storage_order>(table, linear_index))
3115template <
typename T>
3117 const size_type size2)
3123template <
typename T>
3126 const size_type size2,
3127 const bool omit_default_initialization)
3130 omit_default_initialization);
3135template <
typename T>
3146template <
typename T>
3157template <
typename T>
3166template <
typename T>
3175template <
typename T>
3179 return this->table_size[1];
3184template <
typename T>
3188 return this->table_size[0];
3193template <
typename T>
3202template <
typename T>
3211template <
typename T>
3220template <
typename T>
3230template <
typename T>
3232 const size_type size2,
3233 const size_type size3)
3239template <
typename T>
3240template <
typename InputIterator>
3242 const size_type size2,
3243 const size_type size3,
3244 InputIterator entries,
3245 const bool C_style_indexing)
3253template <
typename T>
3256 const size_type size2,
3257 const size_type size3,
3258 const bool omit_default_initialization)
3261 omit_default_initialization);
3266template <
typename T>
3267inline ::internal::TableBaseAccessors::Accessor<3, T, true, 2>
3272 size_type(this->table_size[1]) * this->table_size[2];
3274 *
this, this->
values.begin() + i * subobject_size));
3279template <
typename T>
3280inline ::internal::TableBaseAccessors::Accessor<3, T, false, 2>
3285 size_type(this->table_size[1]) * this->table_size[2];
3287 *
this, this->
values.begin() + i * subobject_size));
3292template <
typename T>
3296 const size_type k)
const
3302 ->values[(
size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3308template <
typename T>
3316 ->values[(
size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3322template <
typename T>
3324 const size_type size2,
3325 const size_type size3,
3326 const size_type size4)
3332template <
typename T>
3333inline ::internal::TableBaseAccessors::Accessor<4, T, true, 3>
3338 size_type(this->table_size[1]) * this->table_size[2] * this->table_size[3];
3340 *
this, this->
values.begin() + i * subobject_size));
3345template <
typename T>
3346inline ::internal::TableBaseAccessors::Accessor<4, T, false, 3>
3351 size_type(this->table_size[1]) * this->table_size[2] * this->table_size[3];
3353 *
this, this->
values.begin() + i * subobject_size));
3358template <
typename T>
3363 const size_type l)
const
3370 ->values[((
size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3372 this->table_size[3] +
3378template <
typename T>
3390 ->values[((
size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3392 this->table_size[3] +
3398template <
typename T>
3400 const size_type size2,
3401 const size_type size3,
3402 const size_type size4,
3403 const size_type size5)
3409template <
typename T>
3410inline ::internal::TableBaseAccessors::Accessor<5, T, true, 4>
3415 this->table_size[2] * this->table_size[3] *
3416 this->table_size[4];
3418 *
this, this->
values.begin() + i * subobject_size));
3423template <
typename T>
3424inline ::internal::TableBaseAccessors::Accessor<5, T, false, 4>
3429 this->table_size[2] * this->table_size[3] *
3430 this->table_size[4];
3432 *
this, this->
values.begin() + i * subobject_size));
3437template <
typename T>
3443 const size_type m)
const
3451 ->values[(((
size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3453 this->table_size[3] +
3455 this->table_size[4] +
3461template <
typename T>
3475 ->values[(((
size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3477 this->table_size[3] +
3479 this->table_size[4] +
3485template <
typename T>
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)
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;
3507template <
typename T>
3508inline ::internal::TableBaseAccessors::Accessor<6, T, true, 5>
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));
3521template <
typename T>
3522inline ::internal::TableBaseAccessors::Accessor<6, T, false, 5>
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));
3535template <
typename T>
3542 const size_type n)
const
3551 ->values[((((
size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3553 this->table_size[3] +
3555 this->table_size[4] +
3557 this->table_size[5] +
3563template <
typename T>
3579 ->values[((((
size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3581 this->table_size[3] +
3583 this->table_size[4] +
3585 this->table_size[5] +
3591template <
typename T>
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)
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;
3615template <
typename T>
3616inline ::internal::TableBaseAccessors::Accessor<7, T, true, 6>
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));
3629template <
typename T>
3630inline ::internal::TableBaseAccessors::Accessor<7, T, false, 6>
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));
3643template <
typename T>
3651 const size_type o)
const
3661 [(((((
size_type(i) * this->table_size[1] + j) * this->table_size[2] + k) *
3662 this->table_size[3] +
3664 this->table_size[4] +
3666 this->table_size[5] +
3668 this->table_size[6] +
3674template <
typename T>
3692 [(((((
size_type(i) * this->table_size[1] + j) * this->table_size[2] + k) *
3693 this->table_size[3] +
3695 this->table_size[4] +
3697 this->table_size[5] +
3699 this->table_size[6] +
3713template <
int N,
typename T>
const value_type * const_iterator
const value_type & const_reference
Accessor< TableType, Constness, storage_order > accessor
Accessor base class for Table<2, T> and TransposeTable.
AccessorBase(const AccessorBase< TableType, false, storage_order > &)
std::conditional_t< Constness, const TableType *, TableType * > container_pointer_type
void assert_valid_linear_index() const
typename TableType::value_type value_type
std::ptrdiff_t linear_index
const value_type & value() const
container_pointer_type container
AccessorBase(const container_pointer_type table)
AccessorBase(const container_pointer_type table, const std::ptrdiff_t linear_index)
friend bool operator==(const AccessorBase< TableType, Constness, storage_order > &left, const AccessorBase< TableType, OtherConstness, storage_order > &right)
typename TableType::size_type size_type
const Accessor< TableType, false, storage_order > & operator=(value_type &&) const
const Accessor< TableType, false, storage_order > & operator=(const value_type &) const
typename AccessorBase< TableType, true, storage_order >::value_type value_type
value_type & value() const
typename AccessorBase< TableType, true, storage_order >::size_type size_type
typename AccessorBase< TableType, true, storage_order >::value_type value_type
typename AccessorBase< TableType, true, storage_order >::size_type size_type
Accessor class template. This class is partially specialized for both values of Constness.
Iterator class for both matrix-like tables, i.e., Table<2, T> and TransposeTable.
Iterator(const container_pointer_type object, const size_type row, const size_type column)
std::conditional_t< Constness, const TableType *, TableType * > container_pointer_type
Iterator(const Accessor< TableType, Constness, storage_order > &accessor)
Iterator(const container_pointer_type object)
Iterator(const Iterator< TableType, false, storage_order > &i)
Iterator(const container_pointer_type container, const std::ptrdiff_t linear_index)
typename TableType::size_type size_type
void fill(const T &value)
std::size_t memory_consumption() const
TableBase< N, T > & operator=(const TableBase< N, T > &src)
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 >::const_reference operator()(const TableIndices< N > &indices) const
AlignedVector< T > values
TableBase< N, T > & operator=(TableBase< N, T > &&src) noexcept
~TableBase() override=default
typename AlignedVector< T >::size_type size_type
size_type n_elements() const
TableBase(const TableBase< N, T2 > &src)
void swap(TableBase< N, T > &v) noexcept
TableBase(const TableIndices< N > &sizes, InputIterator entries, const bool C_style_indexing=true)
const TableIndices< N > & size() const
bool operator==(const TableBase< N, T > &T2) const
size_type position(const TableIndices< N > &indices) const
TableBase(const TableBase< N, T > &src)
TableBase< N, T > & operator=(const TableBase< N, T2 > &src)
AlignedVector< T >::reference operator()(const TableIndices< N > &indices)
AlignedVector< T >::reference el(const TableIndices< N > &indices)
void fill(InputIterator entries, const bool C_style_indexing=true)
void serialize(Archive &ar, const unsigned int version)
void replicate_across_communicator(const MPI_Comm communicator, const unsigned int root_process)
TableBase(const TableIndices< N > &sizes)
size_type size(const unsigned int i) const
TableBase(TableBase< N, T > &&src) noexcept
TableIndices< N > table_size
Table(const size_type size)
AlignedVector< T >::const_reference operator[](const size_type i) const
typename TableBase< 1, T >::size_type size_type
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(const size_type size, InputIterator entries, const bool C_style_indexing=true)
AlignedVector< T >::reference operator()(const size_type i, const size_type j)
AlignedVector< T >::reference el(const size_type i, const size_type j)
typename AlignedVector< T >::const_reference const_reference
typename AlignedVector< T >::value_type value_type
AlignedVector< T >::const_reference operator()(const size_type i, const size_type j) const
::internal::TableBaseAccessors::Accessor< 2, T, false, 1 > operator[](const size_type i)
typename TableBase< 2, T >::size_type size_type
::internal::TableBaseAccessors::Accessor< 2, T, true, 1 > operator[](const size_type i) const
AlignedVector< T >::const_reference el(const size_type i, const size_type j) const
typename AlignedVector< T >::reference reference
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
Table(const size_type size1, const size_type size2)
::internal::TableBaseAccessors::Accessor< 3, T, true, 2 > operator[](const size_type i) const
AlignedVector< T >::const_reference operator()(const size_type i, const size_type j, const size_type k) const
AlignedVector< T >::reference operator()(const size_type i, const size_type j, const size_type k)
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
::internal::TableBaseAccessors::Accessor< 3, T, false, 2 > operator[](const size_type i)
::internal::TableBaseAccessors::Accessor< 4, T, true, 3 > operator[](const size_type i) const
Table(const size_type size1, const size_type size2, const size_type size3, const size_type size4)
AlignedVector< T >::const_reference operator()(const size_type i, const size_type j, const size_type k, const size_type l) const
typename TableBase< 4, T >::size_type size_type
::internal::TableBaseAccessors::Accessor< 4, T, false, 3 > operator[](const size_type i)
AlignedVector< T >::reference operator()(const size_type i, const size_type j, const size_type k, const size_type l)
typename TableBase< 5, T >::size_type size_type
::internal::TableBaseAccessors::Accessor< 5, T, false, 4 > operator[](const size_type i)
AlignedVector< T >::reference operator()(const size_type i, const size_type j, const size_type k, const size_type l, const size_type m)
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
::internal::TableBaseAccessors::Accessor< 5, T, true, 4 > operator[](const size_type i) const
Table(const size_type size1, const size_type size2, const size_type size3, const size_type size4, const size_type size5)
::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)
AlignedVector< T >::reference operator()(const size_type i, const size_type j, const size_type k, const size_type l, const size_type m, const size_type n)
typename TableBase< 6, T >::size_type size_type
::internal::TableBaseAccessors::Accessor< 6, T, true, 5 > operator[](const size_type i) const
::internal::TableBaseAccessors::Accessor< 7, T, false, 6 > operator[](const size_type i)
typename TableBase< 7, T >::size_type size_type
::internal::TableBaseAccessors::Accessor< 7, T, true, 6 > operator[](const size_type i) const
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)
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
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)
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
reference el(const size_type i, const size_type j)
const_iterator begin() const
MatrixTableIterators::Iterator< TransposeTable< T >, true, MatrixTableIterators::Storage::column_major > const_iterator
const_iterator end() const
typename AlignedVector< T >::reference reference
typename TableBase< 2, T >::size_type size_type
const_reference operator()(const size_type i, const size_type j) const
typename AlignedVector< T >::value_type value_type
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
typename Types< N, T, C >::value_type value_type
Accessor(const Accessor &a)
typename Types< N, T, C >::const_iterator const_iterator
typename Types< N, T, C >::TableType TableType
typename Types< N, T, C >::const_reference const_reference
typename Types< N, T, C >::iterator iterator
ptrdiff_t difference_type
reference operator[](const size_type) const
typename Types< N, T, C >::reference reference
Accessor(const TableType &table, const iterator data)
ptrdiff_t difference_type
typename Types< N, T, C >::TableType TableType
typename Types< N, T, C >::iterator iterator
Accessor(const Accessor &a)
Accessor< N, T, C, P - 1 > operator[](const size_type i) const
Accessor(const TableType &table, const iterator data)
typename Types< N, T, C >::const_iterator const_iterator
#define DEAL_II_NAMESPACE_OPEN
#define DEAL_II_NAMESPACE_CLOSE
static ::ExceptionBase & ExcIndexRange(size_type arg1, size_type arg2, size_type arg3)
#define Assert(cond, exc)
#define AssertIndexRange(index, range)
#define DeclException3(Exception3, type1, type2, type3, outsequence)
static ::ExceptionBase & ExcMessage(std::string arg1)
#define DEAL_II_ASSERT_UNREACHABLE()
#define DEAL_II_NOT_IMPLEMENTED()
types::global_dof_index size_type
Storage
Enumeration describing the storage order (i.e., the in-memory layout) of a table class.
std::enable_if_t< std::is_fundamental_v< T >, std::size_t > 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)
T broadcast(const MPI_Comm comm, const T &object_to_send, const unsigned int root_process=0)
void reinit(MatrixBlock< MatrixType > &v, const BlockSparsityPattern &p)
typename AlignedVector< T >::iterator iterator
typename AlignedVector< T >::const_iterator const_iterator
typename AlignedVector< T >::reference reference
typename AlignedVector< T >::const_reference const_reference
typename AlignedVector< T >::const_iterator const_iterator
typename AlignedVector< T >::const_reference const_reference
typename AlignedVector< T >::const_iterator iterator
typename AlignedVector< T >::const_reference reference
void swap(TableBase< N, T > &u, TableBase< N, T > &v) noexcept