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>
202 <<
"Index " <<
N - P + 1 <<
"has a value of " << arg1
203 <<
" but needs to be in the range [" << arg2 <<
"," << arg3
219 template <
int N1,
typename T1>
220 friend class ::Table;
221 template <
int N1,
typename T1,
bool C1,
unsigned int P1>
223 friend class ::Table<N, T>;
236 template <
int N,
typename T,
bool C>
322 template <
int N1,
typename T1>
323 friend class ::Table;
324 template <
int N1,
typename T1,
bool C1,
unsigned int P1>
326 friend class ::Table<2, T>;
437template <
int N,
typename T>
465 template <
typename InputIterator>
467 InputIterator entries,
468 const bool C_style_indexing =
true);
479 template <
typename T2>
510 template <
typename T2>
544 const bool omit_default_initialization =
false);
550 size(
const unsigned int i)
const;
608 template <
typename InputIterator>
610 fill(InputIterator entries,
const bool C_style_indexing =
true);
720 const unsigned int root_process);
749 template <
class Archive>
795 template <
int,
typename>
812template <
int N,
typename T>
880 template <
typename InputIterator>
882 InputIterator entries,
883 const bool C_style_indexing =
true);
947 template <
typename TableType,
bool Constness, Storage storage_order>
954 template <
typename TableType,
bool Constness, Storage storage_order>
973 template <
typename TableType,
bool Constness, Storage storage_order>
981 conditional<Constness, const TableType *, TableType *>::type;
1017 template <
bool OtherConstness>
1072 friend class AccessorBase<TableType, true, storage_order>;
1076 Iterator<TableType, Constness, storage_order>,
1077 Accessor<TableType, Constness, storage_order>>;
1084 template <
typename TableType, Storage storage_order>
1104 using AccessorBase<TableType,
true, storage_order>::AccessorBase;
1111 template <
typename TableType, Storage storage_order>
1131 using AccessorBase<TableType,
false, storage_order>::AccessorBase;
1151 using AccessorBase<TableType,
false, storage_order>::value;
1178 template <
typename TableType,
bool Constness, Storage storage_order>
1181 Accessor<TableType, Constness, storage_order>>
1193 conditional<Constness, const TableType *, TableType *>::type;
1221 const std::ptrdiff_t linear_index);
1240template <
typename T>
1325 template <
typename InputIterator>
1328 InputIterator entries,
1329 const bool C_style_indexing =
true);
1339 const bool omit_default_initialization =
false);
1456 AccessorBase<Table<2, T>, true, MatrixTableIterators::Storage::row_major>;
1458 AccessorBase<Table<2, T>, false, MatrixTableIterators::Storage::row_major>;
1463 Accessor<Table<2, T>, false, MatrixTableIterators::Storage::row_major>;
1477template <typename T>
1536 template <
typename InputIterator>
1540 InputIterator entries,
1541 const bool C_style_indexing =
true);
1599template <
typename T>
1683template <
typename T>
1770template <
typename T>
1858template <
typename T>
1952template <
typename T>
2011 const bool omit_default_initialization =
false);
2109 MatrixTableIterators::Storage::column_major>;
2116 MatrixTableIterators::Storage::column_major>;
2125template <int N, typename T>
2133template <
int N,
typename T>
2134template <
typename InputIterator>
2136 InputIterator entries,
2137 const bool C_style_indexing)
2140 fill(entries, C_style_indexing);
2145template <
int N,
typename T>
2155template <
int N,
typename T>
2156template <
typename T2>
2166template <
int N,
typename T>
2177template <
int N,
typename T>
2178template <
class Archive>
2191 namespace TableBaseAccessors
2193 template <
int N,
typename T,
bool C,
unsigned int P>
2195 const iterator data)
2202 template <
int N,
typename T,
bool C,
unsigned int P>
2203 inline Accessor<N, T, C, P>::Accessor(
const Accessor &a)
2210 template <
int N,
typename T,
bool C,
unsigned int P>
2211 inline Accessor<
N,
T,
C, P - 1> Accessor<N, T, C, P>::
2220 return Accessor<
N,
T,
C, P - 1>(table, data);
2226 size_type subobject_size = table.size()[
N - 1];
2227 for (
int p = P - 1; p > 1; --p)
2228 subobject_size *= table.size()[
N - p];
2229 const iterator new_data = data + i * subobject_size;
2230 return Accessor<
N,
T,
C, P - 1>(table, new_data);
2236 template <
int N,
typename T,
bool C>
2237 inline Accessor<N, T, C, 1>::Accessor(
const TableType &table,
2238 const iterator data)
2245 template <
int N,
typename T,
bool C>
2246 inline Accessor<N, T, C, 1>::Accessor(
const Accessor &a)
2253 template <
int N,
typename T,
bool C>
2254 inline typename Accessor<N, T, C, 1>::reference Accessor<N, T, C, 1>::
2263 template <
int N,
typename T,
bool C>
2265 Accessor<N, T, C, 1>::size()
const
2267 return table.size()[
N - 1];
2272 template <
int N,
typename T,
bool C>
2273 inline typename Accessor<N, T, C, 1>::iterator
2281 template <
int N,
typename T,
bool C>
2282 inline typename Accessor<N, T, C, 1>::iterator
2285 return data + table.size()[
N - 1];
2292template <
int N,
typename T>
2305template <
int N,
typename T>
2306template <
typename T2>
2313 m.
values.begin() + n_elements(),
2321template <
int N,
typename T>
2335template <
int N,
typename T>
2344template <
int N,
typename T>
2349 if (n_elements() != 0)
2355template <
int N,
typename T>
2359 if (n_elements() != 0)
2365template <
int N,
typename T>
2368 const unsigned int root_process)
2372 values.replicate_across_communicator(communicator, root_process);
2380template <
int N,
typename T>
2383 const bool omit_default_initialization)
2385 table_size = new_sizes;
2387 const size_type new_size = n_elements();
2408 if (!omit_default_initialization)
2414 values.resize_fast(new_size);
2419 values.resize_fast(new_size);
2424template <
int N,
typename T>
2433template <
int N,
typename T>
2438 return table_size[i];
2443template <
int N,
typename T>
2448 for (
unsigned int n = 0; n <
N; ++n)
2455template <
int N,
typename T>
2459 return (n_elements() == 0);
2466 namespace TableImplementation
2468 template <
typename InputIterator,
typename T>
2478 template <
typename InputIterator,
typename T>
2489 template <
typename InputIterator,
typename T>
2501 template <
typename InputIterator,
typename T,
int N>
2511template <
int N,
typename T>
2512template <
typename InputIterator>
2518 if (C_style_indexing)
2524 internal::TableImplementation::fill_Fortran_style(entries, *
this);
2529template <
int N,
typename T>
2539template <
int N,
typename T>
2548template <
int N,
typename T>
2562 return size_type(indices[0]) * table_size[1] + indices[1];
2564 return ((
size_type(indices[0]) * table_size[1] + indices[1]) *
2569 unsigned int s = indices[0];
2570 for (
unsigned int n = 1; n <
N; ++n)
2571 s = s * table_size[n] + indices[n];
2579template <
int N,
typename T>
2583 for (
unsigned int n = 0; n <
N; ++n)
2590template <
int N,
typename T>
2594 for (
unsigned int n = 0; n <
N; ++n)
2601template <
int N,
typename T>
2605 return values[position(indices)];
2610template <
int N,
typename T>
2615 return values[position(indices)];
2620template <
typename T>
2627template <
typename T>
2628template <
typename InputIterator>
2630 InputIterator entries,
2631 const bool C_style_indexing)
2637template <
typename T>
2647template <
typename T>
2657template <
typename T>
2667template <
typename T>
2680template <
typename T>
2687template <
typename T>
2688template <
typename InputIterator>
2691 InputIterator entries,
2692 const bool C_style_indexing)
2698template <
typename T>
2702 const bool omit_default_initialization)
2705 omit_default_initialization);
2710template <
typename T>
2711inline ::internal::TableBaseAccessors::Accessor<2, T, true, 1>
2715 return ::internal::TableBaseAccessors::Accessor<2, T, true, 1>(
2721template <
typename T>
2722inline ::internal::TableBaseAccessors::Accessor<2, T, false, 1>
2726 return ::internal::TableBaseAccessors::Accessor<2, T, false, 1>(
2732template <
typename T>
2743template <
typename T>
2754template <
typename T>
2763template <
typename T>
2772template <
typename T>
2776 return this->table_size[0];
2781template <
typename T>
2785 return this->table_size[1];
2790template <
typename T>
2799template <
typename T>
2808template <
typename T>
2817template <
typename T>
2833 template <
typename TableType, Storage storage_order>
2834 inline std::ptrdiff_t
2835 get_row_index(
const std::ptrdiff_t linear_index,
2836 const TableType *
const container)
2838 switch (storage_order)
2841 return linear_index / container->n_cols();
2843 return linear_index % container->n_rows();
2852 template <
typename TableType, Storage storage_order>
2853 inline std::ptrdiff_t
2854 get_column_index(
const std::ptrdiff_t linear_index,
2855 const TableType *
const container)
2857 switch (storage_order)
2860 return linear_index % container->n_cols();
2862 return linear_index / container->n_rows();
2872 template <
typename TableType,
bool Constness, Storage storage_order>
2874 : container(nullptr)
2875 , linear_index(
std::numeric_limits<decltype(linear_index)>::
max())
2880 template <
typename TableType,
bool Constness, Storage storage_order>
2881 inline AccessorBase<TableType, Constness, storage_order>::AccessorBase(
2882 const container_pointer_type table)
2884 , linear_index(container->
values.size())
2889 template <
typename TableType,
bool Constness, Storage storage_order>
2890 inline AccessorBase<TableType, Constness, storage_order>::AccessorBase(
2891 const AccessorBase<TableType, false, storage_order> &a)
2892 : container(a.container)
2893 , linear_index(a.linear_index)
2898 template <
typename TableType,
bool Constness, Storage storage_order>
2899 inline AccessorBase<TableType, Constness, storage_order>::AccessorBase(
2900 const container_pointer_type table,
2901 const std::ptrdiff_t index)
2903 , linear_index(index)
2905 Assert(0 <= linear_index &&
2906 std::size_t(linear_index) < container->values.size() + 1,
2907 ExcMessage(
"The current iterator points outside of the table and is "
2908 "not the end iterator."));
2913 template <
typename TableType,
bool Constness, Storage storage_order>
2914 inline const typename AccessorBase<TableType, Constness, storage_order>::
2916 AccessorBase<TableType, Constness, storage_order>::value()
const
2918 assert_valid_linear_index();
2919 return this->container->values[linear_index];
2924 template <
typename TableType,
bool Constness, Storage storage_order>
2925 inline AccessorBase<TableType, Constness, storage_order>::
2926 operator
const value_type &()
const
2928 assert_valid_linear_index();
2929 return this->container->values[linear_index];
2934 template <
typename TableType,
bool Constness, Storage storage_order>
2936 AccessorBase<TableType, Constness, storage_order>::row()
const
2938 assert_valid_linear_index();
2939 return static_cast<std::size_t
>(
2940 internal::get_row_index<TableType, storage_order>(linear_index,
2946 template <
typename TableType,
bool Constness, Storage storage_order>
2948 AccessorBase<TableType, Constness, storage_order>::column()
const
2950 assert_valid_linear_index();
2951 return static_cast<std::size_t
>(
2952 internal::get_column_index<TableType, storage_order>(linear_index,
2958 template <
typename TableType,
bool Constness, Storage storage_order>
2960 AccessorBase<TableType, Constness, storage_order>::assert_valid_linear_index()
2964 Assert(container !=
nullptr,
2965 ExcMessage(
"This accessor has been default-constructed and does not "
2966 "have a corresponding table."));
2967 Assert(!container->empty(),
2968 ExcMessage(
"An empty table has no rows or columns."));
2969 Assert(0 <= linear_index &&
2970 std::size_t(linear_index) < container->values.size(),
2971 ExcMessage(
"The current iterator points outside of the table."));
2972 const std::ptrdiff_t row_n =
2973 internal::get_row_index<TableType, storage_order>(linear_index,
2975 const std::ptrdiff_t column_n =
2976 internal::get_column_index<TableType, storage_order>(linear_index,
2978 Assert(0 <= column_n && std::size_t(column_n) < container->n_cols(),
2979 ExcMessage(
"The current iterator points outside the table."));
2980 Assert(0 <= row_n && std::size_t(row_n) < container->n_rows(),
2981 ExcMessage(
"The current iterator points outside the table."));
2987 template <
typename TableType, Storage storage_order>
2988 inline const Accessor<TableType, false, storage_order> &
2989 Accessor<TableType, false, storage_order>::operator=(
2990 const typename Accessor<TableType, false, storage_order>::value_type &t)
2993 this->assert_valid_linear_index();
2994 this->container->values[this->linear_index] = t;
3000 template <
typename TableType, Storage storage_order>
3001 inline const Accessor<TableType, false, storage_order> &
3002 Accessor<TableType, false, storage_order>::operator=(
3003 typename Accessor<TableType, false, storage_order>::value_type &&t)
const
3005 this->assert_valid_linear_index();
3006 this->container->values[this->linear_index] = t;
3012 template <
typename TableType, Storage storage_order>
3013 inline typename Accessor<TableType, false, storage_order>::value_type &
3014 Accessor<TableType, false, storage_order>::value()
const
3016 this->assert_valid_linear_index();
3017 return this->container->values[this->linear_index];
3022 template <
typename TableType, Storage storage_order>
3023 inline Accessor<TableType, false, storage_order>::operator value_type &()
3025 this->assert_valid_linear_index();
3026 return this->container->values[this->linear_index];
3031 template <
typename TableType,
bool Constness, Storage storage_order>
3032 inline Iterator<TableType, Constness, storage_order>::Iterator(
3035 Accessor<TableType, Constness, storage_order>>(a)
3040 template <
typename TableType,
bool Constness, Storage storage_order>
3041 inline Iterator<TableType, Constness, storage_order>::Iterator(
3042 const container_pointer_type table)
3044 Accessor<TableType, Constness, storage_order>>(
3045 Accessor<TableType, Constness, storage_order>(table))
3050 template <
typename TableType,
bool Constness, Storage storage_order>
3051 inline Iterator<TableType, Constness, storage_order>::Iterator(
3052 const Iterator<TableType, false, storage_order> &i)
3054 Accessor<TableType, Constness, storage_order>>(*i)
3059 template <
typename TableType,
bool Constness, Storage storage_order>
3060 inline Iterator<TableType, Constness, storage_order>::Iterator(
3061 const container_pointer_type table,
3066 table->n_cols() * row_n + col_n :
3067 table->n_rows() * col_n + row_n)
3072 template <
typename TableType,
bool Constness, Storage storage_order>
3073 inline Iterator<TableType, Constness, storage_order>::Iterator(
3074 const container_pointer_type table,
3075 const std::ptrdiff_t linear_index)
3077 Accessor<TableType, Constness, storage_order>>(
3078 Accessor<TableType, Constness, storage_order>(table, linear_index))
3085template <
typename T>
3093template <
typename T>
3097 const bool omit_default_initialization)
3100 omit_default_initialization);
3105template <
typename T>
3116template <
typename T>
3127template <
typename T>
3136template <
typename T>
3145template <
typename T>
3149 return this->table_size[1];
3154template <
typename T>
3158 return this->table_size[0];
3163template <
typename T>
3172template <
typename T>
3181template <
typename T>
3190template <
typename T>
3200template <
typename T>
3209template <
typename T>
3210template <
typename InputIterator>
3214 InputIterator entries,
3215 const bool C_style_indexing)
3223template <
typename T>
3224inline ::internal::TableBaseAccessors::Accessor<3, T, true, 2>
3229 size_type(this->table_size[1]) * this->table_size[2];
3231 *
this, this->
values.begin() + i * subobject_size));
3236template <
typename T>
3237inline ::internal::TableBaseAccessors::Accessor<3, T, false, 2>
3242 size_type(this->table_size[1]) * this->table_size[2];
3244 *
this, this->
values.begin() + i * subobject_size));
3249template <
typename T>
3258 ->values[(
size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3264template <
typename T>
3272 ->values[(
size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3278template <
typename T>
3288template <
typename T>
3289inline ::internal::TableBaseAccessors::Accessor<4, T, true, 3>
3294 size_type(this->table_size[1]) * this->table_size[2] * this->table_size[3];
3296 *
this, this->
values.begin() + i * subobject_size));
3301template <
typename T>
3302inline ::internal::TableBaseAccessors::Accessor<4, T, false, 3>
3307 size_type(this->table_size[1]) * this->table_size[2] * this->table_size[3];
3309 *
this, this->
values.begin() + i * subobject_size));
3314template <
typename T>
3326 ->values[((
size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3328 this->table_size[3] +
3334template <
typename T>
3346 ->values[((
size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3348 this->table_size[3] +
3354template <
typename T>
3365template <
typename T>
3366inline ::internal::TableBaseAccessors::Accessor<5, T, true, 4>
3371 this->table_size[2] * this->table_size[3] *
3372 this->table_size[4];
3374 *
this, this->
values.begin() + i * subobject_size));
3379template <
typename T>
3380inline ::internal::TableBaseAccessors::Accessor<5, T, false, 4>
3385 this->table_size[2] * this->table_size[3] *
3386 this->table_size[4];
3388 *
this, this->
values.begin() + i * subobject_size));
3393template <
typename T>
3407 ->values[(((
size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3409 this->table_size[3] +
3411 this->table_size[4] +
3417template <
typename T>
3431 ->values[(((
size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3433 this->table_size[3] +
3435 this->table_size[4] +
3441template <
typename T>
3451 table_indices[0] = size1;
3452 table_indices[1] = size2;
3453 table_indices[2] = size3;
3454 table_indices[3] = size4;
3455 table_indices[4] = size5;
3456 table_indices[5] = size6;
3463template <
typename T>
3464inline ::internal::TableBaseAccessors::Accessor<6, T, true, 5>
3469 this->table_size[2] * this->table_size[3] *
3470 this->table_size[4] * this->table_size[5];
3472 *
this, this->
values.begin() + i * subobject_size));
3477template <
typename T>
3478inline ::internal::TableBaseAccessors::Accessor<6, T, false, 5>
3483 this->table_size[2] * this->table_size[3] *
3484 this->table_size[4] * this->table_size[5];
3486 *
this, this->
values.begin() + i * subobject_size));
3491template <
typename T>
3507 ->values[((((
size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3509 this->table_size[3] +
3511 this->table_size[4] +
3513 this->table_size[5] +
3519template <
typename T>
3535 ->values[((((
size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3537 this->table_size[3] +
3539 this->table_size[4] +
3541 this->table_size[5] +
3547template <
typename T>
3558 table_indices[0] = size1;
3559 table_indices[1] = size2;
3560 table_indices[2] = size3;
3561 table_indices[3] = size4;
3562 table_indices[4] = size5;
3563 table_indices[5] = size6;
3564 table_indices[6] = size7;
3571template <
typename T>
3572inline ::internal::TableBaseAccessors::Accessor<7, T, true, 6>
3577 size_type(this->table_size[1]) * this->table_size[2] * this->table_size[3] *
3578 this->table_size[4] * this->table_size[5] * this->table_size[6];
3580 *
this, this->
values.begin() + i * subobject_size));
3585template <
typename T>
3586inline ::internal::TableBaseAccessors::Accessor<7, T, false, 6>
3591 size_type(this->table_size[1]) * this->table_size[2] * this->table_size[3] *
3592 this->table_size[4] * this->table_size[5] * this->table_size[6];
3594 *
this, this->
values.begin() + i * subobject_size));
3599template <
typename T>
3617 [(((((
size_type(i) * this->table_size[1] + j) * this->table_size[2] + k) *
3618 this->table_size[3] +
3620 this->table_size[4] +
3622 this->table_size[5] +
3624 this->table_size[6] +
3630template <
typename T>
3648 [(((((
size_type(i) * this->table_size[1] + j) * this->table_size[2] + k) *
3649 this->table_size[3] +
3651 this->table_size[4] +
3653 this->table_size[5] +
3655 this->table_size[6] +
3669template <
int N,
typename T>
const value_type * const_iterator
const value_type & const_reference
void swap(BlockIndices &u, BlockIndices &v)
Accessor< TableType, Constness, storage_order > accessor
Accessor base class for Table<2, T> and TransposeTable.
AccessorBase(const AccessorBase< TableType, false, storage_order > &)
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)
typename std::conditional< Constness, const TableType *, TableType * >::type container_pointer_type
friend bool operator==(const AccessorBase< TableType, Constness, storage_order > &left, const AccessorBase< TableType, OtherConstness, storage_order > &right)
typename TableType::size_type size_type
Accessor class offering read and write access to the elements of a table.
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)
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
Iterator(const container_pointer_type container, const std::ptrdiff_t linear_index)
typename TableType::size_type size_type
void swap(TableBase< N, T > &v)
void replicate_across_communicator(const MPI_Comm &communicator, const unsigned int root_process)
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)
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)
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)
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 & ExcNotImplemented()
static ::ExceptionBase & ExcIndexRange(size_type arg1, size_type arg2, size_type arg3)
#define Assert(cond, exc)
#define AssertIndexRange(index, range)
static ::ExceptionBase & ExcInternalError()
#define DeclException3(Exception3, type1, type2, type3, outsequence)
static ::ExceptionBase & ExcMessage(std::string arg1)
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< 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 * end(VectorType &V)
VectorType::value_type * begin(VectorType &V)
T 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)
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)