16 #ifndef dealii_table_h 17 #define dealii_table_h 35 template <
int N,
typename T>
37 template <
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>;
400 template <
int N,
typename T>
428 template <
typename InputIterator>
430 InputIterator entries,
431 const bool C_style_indexing =
true);
442 template <
typename T2>
473 template <
typename T2>
507 const bool omit_default_initialization =
false);
513 size(
const unsigned int i)
const;
571 template <
typename InputIterator>
573 fill(InputIterator entries,
const bool C_style_indexing =
true);
579 fill(
const T &value);
624 template <
class Archive>
626 serialize(Archive &ar,
const unsigned int version);
670 template <
int,
typename>
687 template <
int N,
typename T>
703 template <
typename T>
759 template <
typename InputIterator>
761 InputIterator entries,
762 const bool C_style_indexing =
true);
835 template <
typename TableType,
bool Constness, Storage storage_order>
842 template <
typename TableType,
bool Constness, Storage storage_order>
861 template <
typename TableType,
bool Constness, Storage storage_order>
869 conditional<Constness, const TableType *, TableType *>::type;
900 const std::ptrdiff_t linear_index);
905 template <
bool OtherConstness>
957 assert_valid_linear_index()
const;
964 Iterator<TableType, Constness, storage_order>,
972 template <
typename TableType, Storage storage_order>
999 template <
typename TableType, Storage storage_order>
1066 template <
typename TableType,
bool Constness, Storage storage_order>
1069 Accessor<TableType, Constness, storage_order>>
1081 conditional<Constness, const TableType *, TableType *>::type;
1109 const std::ptrdiff_t linear_index);
1127 template <
typename T>
1161 using iterator = MatrixTableIterators::
1162 Iterator<Table<2, T>,
false, MatrixTableIterators::Storage::row_major>;
1212 template <
typename InputIterator>
1215 InputIterator entries,
1216 const bool C_style_indexing =
true);
1226 const bool omit_default_initialization =
false);
1353 AccessorBase<Table<2, T>, true, MatrixTableIterators::Storage::row_major>;
1355 AccessorBase<Table<2, T>, false, MatrixTableIterators::Storage::row_major>;
1360 Accessor<Table<2, T>, false, MatrixTableIterators::Storage::row_major>;
1374 template <typename T>
1433 template <
typename InputIterator>
1437 InputIterator entries,
1438 const bool C_style_indexing =
true);
1505 template <
typename T>
1598 template <
typename T>
1694 template <
typename T>
1791 template <
typename T>
1894 template <
typename T>
1953 const bool omit_default_initialization =
false);
2051 MatrixTableIterators::Storage::column_major>;
2058 MatrixTableIterators::Storage::column_major>;
2067 template <int N, typename T>
2075 template <
int N,
typename T>
2076 template <
typename InputIterator>
2078 InputIterator entries,
2079 const bool C_style_indexing)
2082 fill(entries, C_style_indexing);
2087 template <
int N,
typename T>
2097 template <
int N,
typename T>
2098 template <
typename T2>
2108 template <
int N,
typename T>
2119 template <
int N,
typename T>
2120 template <
class Archive>
2133 namespace TableBaseAccessors
2135 template <
int N,
typename T,
bool C,
unsigned int P>
2144 template <
int N,
typename T,
bool C,
unsigned int P>
2152 template <
int N,
typename T,
bool C,
unsigned int P>
2162 return Accessor<
N,
T,
C, P - 1>(table, data);
2168 size_type subobject_size = table.size()[N - 1];
2169 for (
int p = P - 1; p > 1; --p)
2170 subobject_size *= table.size()[N - p];
2171 const iterator new_data = data + i * subobject_size;
2172 return Accessor<
N,
T,
C, P - 1>(table, new_data);
2178 template <
int N,
typename T,
bool C>
2187 template <
int N,
typename T,
bool C>
2195 template <
int N,
typename T,
bool C>
2205 template <
int N,
typename T,
bool C>
2209 return table.size()[N - 1];
2214 template <
int N,
typename T,
bool C>
2223 template <
int N,
typename T,
bool C>
2227 return data + table.size()[N - 1];
2234 template <
int N,
typename T>
2247 template <
int N,
typename T>
2248 template <
typename T2>
2255 m.
values.begin() + n_elements(),
2263 template <
int N,
typename T>
2267 static_cast<Subscriptor &
>(*this) = std::move(static_cast<Subscriptor &>(m));
2277 template <
int N,
typename T>
2286 template <
int N,
typename T>
2291 if (n_elements() != 0)
2297 template <
int N,
typename T>
2301 if (n_elements() != 0)
2307 template <
int N,
typename T>
2310 const bool omit_default_initialization)
2312 table_size = new_sizes;
2314 const size_type new_size = n_elements();
2335 if (!omit_default_initialization)
2341 values.resize_fast(new_size);
2346 values.resize_fast(new_size);
2351 template <
int N,
typename T>
2360 template <
int N,
typename T>
2365 return table_size[i];
2370 template <
int N,
typename T>
2375 for (
unsigned int n = 0; n <
N; ++n)
2382 template <
int N,
typename T>
2386 return (n_elements() == 0);
2393 namespace TableImplementation
2395 template <
typename InputIterator,
typename T>
2405 template <
typename InputIterator,
typename T>
2416 template <
typename InputIterator,
typename T>
2428 template <
typename InputIterator,
typename T,
int N>
2438 template <
int N,
typename T>
2439 template <
typename InputIterator>
2445 if (C_style_indexing)
2451 internal::TableImplementation::fill_Fortran_style(entries, *
this);
2456 template <
int N,
typename T>
2466 template <
int N,
typename T>
2475 template <
int N,
typename T>
2489 return size_type(indices[0]) * table_size[1] + indices[1];
2491 return ((
size_type(indices[0]) * table_size[1] + indices[1]) *
2496 unsigned int s = indices[0];
2497 for (
unsigned int n = 1; n <
N; ++n)
2498 s = s * table_size[n] + indices[n];
2506 template <
int N,
typename T>
2510 for (
unsigned int n = 0; n <
N; ++n)
2517 template <
int N,
typename T>
2521 for (
unsigned int n = 0; n <
N; ++n)
2528 template <
int N,
typename T>
2532 return values[position(indices)];
2537 template <
int N,
typename T>
2542 return values[position(indices)];
2547 template <
typename T>
2554 template <
typename T>
2555 template <
typename InputIterator>
2557 InputIterator entries,
2558 const bool C_style_indexing)
2564 template <
typename T>
2574 template <
typename T>
2584 template <
typename T>
2594 template <
typename T>
2604 template <
typename T>
2613 template <
typename T>
2625 template <
typename T>
2632 template <
typename T>
2633 template <
typename InputIterator>
2636 InputIterator entries,
2637 const bool C_style_indexing)
2643 template <
typename T>
2647 const bool omit_default_initialization)
2650 omit_default_initialization);
2655 template <
typename T>
2656 inline ::internal::TableBaseAccessors::Accessor<2, T, true, 1>
2660 return ::internal::TableBaseAccessors::Accessor<2, T, true, 1>(
2666 template <
typename T>
2667 inline ::internal::TableBaseAccessors::Accessor<2, T, false, 1>
2671 return ::internal::TableBaseAccessors::Accessor<2, T, false, 1>(
2677 template <
typename T>
2688 template <
typename T>
2699 template <
typename T>
2708 template <
typename T>
2717 template <
typename T>
2726 template <
typename T>
2735 template <
typename T>
2739 return this->table_size[0];
2744 template <
typename T>
2748 return this->table_size[1];
2753 template <
typename T>
2762 template <
typename T>
2771 template <
typename T>
2780 template <
typename T>
2796 template <
typename TableType, Storage storage_order>
2797 inline std::ptrdiff_t
2798 get_row_index(
const std::ptrdiff_t linear_index,
2799 const TableType *
const container)
2801 switch (storage_order)
2803 case Storage::row_major:
2804 return linear_index / container->n_cols();
2805 case Storage::column_major:
2806 return linear_index % container->n_rows();
2815 template <
typename TableType, Storage storage_order>
2816 inline std::ptrdiff_t
2817 get_column_index(
const std::ptrdiff_t linear_index,
2818 const TableType *
const container)
2820 switch (storage_order)
2822 case Storage::row_major:
2823 return linear_index % container->n_cols();
2824 case Storage::column_major:
2825 return linear_index / container->n_rows();
2835 template <
typename TableType,
bool Constness, Storage storage_order>
2836 inline AccessorBase<TableType, Constness, storage_order>::AccessorBase()
2837 : container(
nullptr)
2838 , linear_index(std::numeric_limits<decltype(linear_index)>::
max())
2843 template <
typename TableType,
bool Constness, Storage storage_order>
2844 inline AccessorBase<TableType, Constness, storage_order>::AccessorBase(
2845 const container_pointer_type table)
2847 , linear_index(container->values.size())
2852 template <
typename TableType,
bool Constness, Storage storage_order>
2853 inline AccessorBase<TableType, Constness, storage_order>::AccessorBase(
2854 const AccessorBase<TableType, false, storage_order> &a)
2855 : container(a.container)
2856 , linear_index(a.linear_index)
2861 template <
typename TableType,
bool Constness, Storage storage_order>
2862 inline AccessorBase<TableType, Constness, storage_order>::AccessorBase(
2863 const container_pointer_type table,
2864 const std::ptrdiff_t index)
2866 , linear_index(index)
2868 Assert(0 <= linear_index &&
2869 std::size_t(linear_index) < container->values.size() + 1,
2870 ExcMessage(
"The current iterator points outside of the table and is " 2871 "not the end iterator."));
2876 template <
typename TableType,
bool Constness, Storage storage_order>
2877 inline const typename AccessorBase<TableType, Constness, storage_order>::
2881 assert_valid_linear_index();
2882 return this->container->values[linear_index];
2887 template <
typename TableType,
bool Constness, Storage storage_order>
2888 inline AccessorBase<TableType, Constness, storage_order>::
2891 assert_valid_linear_index();
2892 return this->container->values[linear_index];
2897 template <
typename TableType,
bool Constness, Storage storage_order>
2899 AccessorBase<TableType, Constness, storage_order>::row()
const 2901 assert_valid_linear_index();
2902 return static_cast<std::size_t
>(
2903 internal::get_row_index<TableType, storage_order>(linear_index,
2909 template <
typename TableType,
bool Constness, Storage storage_order>
2911 AccessorBase<TableType, Constness, storage_order>::column()
const 2913 assert_valid_linear_index();
2914 return static_cast<std::size_t
>(
2915 internal::get_column_index<TableType, storage_order>(linear_index,
2921 template <
typename TableType,
bool Constness, Storage storage_order>
2923 AccessorBase<TableType, Constness, storage_order>::assert_valid_linear_index()
2926 # ifdef DEBUG // avoid unused variable warnings by guarding everything 2927 Assert(container !=
nullptr,
2928 ExcMessage(
"This accessor has been default-constructed and does not " 2929 "have a corresponding table."));
2930 Assert(!container->empty(),
2931 ExcMessage(
"An empty table has no rows or columns."));
2932 Assert(0 <= linear_index &&
2933 std::size_t(linear_index) < container->values.size(),
2934 ExcMessage(
"The current iterator points outside of the table."));
2935 const std::ptrdiff_t row_n =
2936 internal::get_row_index<TableType, storage_order>(linear_index,
2938 const std::ptrdiff_t column_n =
2939 internal::get_column_index<TableType, storage_order>(linear_index,
2941 Assert(0 <= column_n && std::size_t(column_n) < container->n_cols(),
2942 ExcMessage(
"The current iterator points outside the table."));
2943 Assert(0 <= row_n && std::size_t(row_n) < container->n_rows(),
2944 ExcMessage(
"The current iterator points outside the table."));
2950 template <
typename TableType, Storage storage_order>
2951 inline const Accessor<TableType, false, storage_order> &
2952 Accessor<TableType, false, storage_order>::operator=(
2953 const typename Accessor<TableType, false, storage_order>::value_type &t)
2956 this->assert_valid_linear_index();
2957 this->container->values[this->linear_index] = t;
2963 template <
typename TableType, Storage storage_order>
2964 inline const Accessor<TableType, false, storage_order> &
2965 Accessor<TableType, false, storage_order>::operator=(
2966 typename Accessor<TableType, false, storage_order>::value_type &&t)
const 2968 this->assert_valid_linear_index();
2969 this->container->values[this->linear_index] = t;
2975 template <
typename TableType, Storage storage_order>
2976 inline typename Accessor<TableType, false, storage_order>::value_type &
2979 this->assert_valid_linear_index();
2980 return this->container->values[this->linear_index];
2985 template <
typename TableType, Storage storage_order>
2986 inline Accessor<TableType, false, storage_order>::operator
value_type &()
2988 this->assert_valid_linear_index();
2989 return this->container->values[this->linear_index];
2994 template <
typename TableType,
bool Constness, Storage storage_order>
2995 inline Iterator<TableType, Constness, storage_order>::Iterator(
3003 template <
typename TableType,
bool Constness, Storage storage_order>
3004 inline Iterator<TableType, Constness, storage_order>::Iterator(
3005 const container_pointer_type table)
3013 template <
typename TableType,
bool Constness, Storage storage_order>
3014 inline Iterator<TableType, Constness, storage_order>::Iterator(
3015 const Iterator<TableType, false, storage_order> &i)
3022 template <
typename TableType,
bool Constness, Storage storage_order>
3023 inline Iterator<TableType, Constness, storage_order>::Iterator(
3024 const container_pointer_type table,
3028 storage_order == Storage::row_major ?
3029 table->n_cols() * row_n + col_n :
3030 table->n_rows() * col_n + row_n)
3035 template <
typename TableType,
bool Constness, Storage storage_order>
3036 inline Iterator<TableType, Constness, storage_order>::Iterator(
3037 const container_pointer_type table,
3038 const std::ptrdiff_t linear_index)
3048 template <
typename T>
3056 template <
typename T>
3060 const bool omit_default_initialization)
3063 omit_default_initialization);
3068 template <
typename T>
3079 template <
typename T>
3090 template <
typename T>
3099 template <
typename T>
3108 template <
typename T>
3112 return this->table_size[1];
3117 template <
typename T>
3121 return this->table_size[0];
3126 template <
typename T>
3135 template <
typename T>
3144 template <
typename T>
3153 template <
typename T>
3163 template <
typename T>
3172 template <
typename T>
3173 template <
typename InputIterator>
3177 InputIterator entries,
3178 const bool C_style_indexing)
3186 template <
typename T>
3187 inline ::internal::TableBaseAccessors::Accessor<3, T, true, 2>
3192 size_type(this->table_size[1]) * this->table_size[2];
3194 *
this, this->
values.begin() + i * subobject_size));
3199 template <
typename T>
3200 inline ::internal::TableBaseAccessors::Accessor<3, T, false, 2>
3205 size_type(this->table_size[1]) * this->table_size[2];
3207 *
this, this->
values.begin() + i * subobject_size));
3212 template <
typename T>
3221 ->values[(
size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3227 template <
typename T>
3235 ->values[(
size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3241 template <
typename T>
3250 template <
typename T>
3259 template <
typename T>
3269 template <
typename T>
3270 inline ::internal::TableBaseAccessors::Accessor<4, T, true, 3>
3275 size_type(this->table_size[1]) * this->table_size[2] * this->table_size[3];
3277 *
this, this->
values.begin() + i * subobject_size));
3282 template <
typename T>
3283 inline ::internal::TableBaseAccessors::Accessor<4, T, false, 3>
3288 size_type(this->table_size[1]) * this->table_size[2] * this->table_size[3];
3290 *
this, this->
values.begin() + i * subobject_size));
3295 template <
typename T>
3307 ->values[((
size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3309 this->table_size[3] +
3315 template <
typename T>
3327 ->values[((
size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3329 this->table_size[3] +
3335 template <
typename T>
3344 template <
typename T>
3353 template <
typename T>
3364 template <
typename T>
3365 inline ::internal::TableBaseAccessors::Accessor<5, T, true, 4>
3370 this->table_size[2] * this->table_size[3] *
3371 this->table_size[4];
3373 *
this, this->
values.begin() + i * subobject_size));
3378 template <
typename T>
3379 inline ::internal::TableBaseAccessors::Accessor<5, T, false, 4>
3384 this->table_size[2] * this->table_size[3] *
3385 this->table_size[4];
3387 *
this, this->
values.begin() + i * subobject_size));
3392 template <
typename T>
3406 ->values[(((
size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3408 this->table_size[3] +
3410 this->table_size[4] +
3416 template <
typename T>
3430 ->values[(((
size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3432 this->table_size[3] +
3434 this->table_size[4] +
3440 template <
typename T>
3449 template <
typename T>
3458 template <
typename T>
3468 table_indices[0] = size1;
3469 table_indices[1] = size2;
3470 table_indices[2] = size3;
3471 table_indices[3] = size4;
3472 table_indices[4] = size5;
3473 table_indices[5] = size6;
3480 template <
typename T>
3481 inline ::internal::TableBaseAccessors::Accessor<6, T, true, 5>
3486 this->table_size[2] * this->table_size[3] *
3487 this->table_size[4] * this->table_size[5];
3489 *
this, this->
values.begin() + i * subobject_size));
3494 template <
typename T>
3495 inline ::internal::TableBaseAccessors::Accessor<6, T, false, 5>
3500 this->table_size[2] * this->table_size[3] *
3501 this->table_size[4] * this->table_size[5];
3503 *
this, this->
values.begin() + i * subobject_size));
3508 template <
typename T>
3524 ->values[((((
size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3526 this->table_size[3] +
3528 this->table_size[4] +
3530 this->table_size[5] +
3536 template <
typename T>
3552 ->values[((((
size_type(i) * this->table_size[1] + j) * this->table_size[2] +
3554 this->table_size[3] +
3556 this->table_size[4] +
3558 this->table_size[5] +
3564 template <
typename T>
3573 template <
typename T>
3582 template <
typename T>
3593 table_indices[0] = size1;
3594 table_indices[1] = size2;
3595 table_indices[2] = size3;
3596 table_indices[3] = size4;
3597 table_indices[4] = size5;
3598 table_indices[5] = size6;
3599 table_indices[6] = size7;
3606 template <
typename T>
3607 inline ::internal::TableBaseAccessors::Accessor<7, T, true, 6>
3612 size_type(this->table_size[1]) * this->table_size[2] * this->table_size[3] *
3613 this->table_size[4] * this->table_size[5] * this->table_size[6];
3615 *
this, this->
values.begin() + i * subobject_size));
3620 template <
typename T>
3621 inline ::internal::TableBaseAccessors::Accessor<7, T, false, 6>
3626 size_type(this->table_size[1]) * this->table_size[2] * this->table_size[3] *
3627 this->table_size[4] * this->table_size[5] * this->table_size[6];
3629 *
this, this->
values.begin() + i * subobject_size));
3634 template <
typename T>
3652 [(((((
size_type(i) * this->table_size[1] + j) * this->table_size[2] + k) *
3653 this->table_size[3] +
3655 this->table_size[4] +
3657 this->table_size[5] +
3659 this->table_size[6] +
3665 template <
typename T>
3683 [(((((
size_type(i) * this->table_size[1] + j) * this->table_size[2] + k) *
3684 this->table_size[3] +
3686 this->table_size[4] +
3688 this->table_size[5] +
3690 this->table_size[6] +
3696 template <
typename T>
3705 template <
typename T>
3722 template <
int N,
typename T>
bool operator==(const TableBase< N, T > &T2) const
void reinit(MatrixBlock< MatrixType > &v, const BlockSparsityPattern &p)
typename TableBase< 3, T >::size_type size_type
size_type position(const TableIndices< N > &indices) const
Storage
Enumeration describing the storage order (i.e., the in-memory layout) of a table class.
void serialize(Archive &ar, const unsigned int version)
void swap(TableBase< N, T > &v)
ptrdiff_t difference_type
types::global_dof_index size_type
typename Types< N, T, C >::TableType TableType
typename AlignedVector< T >::iterator iterator
typename TableBase< 2, T >::size_type size_type
MatrixTableIterators::Iterator< TransposeTable< T >, true, MatrixTableIterators::Storage::column_major > const_iterator
const TableIndices< N > & size() const
Accessor< N, T, C, P - 1 > operator[](const size_type i) const
typename TableBase< 6, T >::size_type size_type
typename AccessorBase< TableType, true, storage_order >::value_type value_type
typename TableType::size_type size_type
typename Types< N, T, C >::iterator iterator
typename AlignedVector< number >::reference reference
typename std::conditional< Constness, const TableType *, TableType * >::type container_pointer_type
#define AssertIndexRange(index, range)
typename AlignedVector< T >::const_reference const_reference
typename Types< N, T, C >::const_iterator const_iterator
ptrdiff_t difference_type
typename TableBase< 2, T >::size_type size_type
static ::ExceptionBase & ExcIndexRange(int arg1, int arg2, int arg3)
size_type n_elements() const
typename AlignedVector< T >::reference reference
bool operator==(const AlignedVector< T > &lhs, const AlignedVector< T > &rhs)
typename TableBase< 1, T >::size_type size_type
SymmetricTensor< 2, dim, Number > C(const Tensor< 2, dim, Number > &F)
typename Types< N, T, C >::const_iterator const_iterator
typename AlignedVector< T >::const_reference const_reference
typename Types< N, T, C >::TableType TableType
typename TableBase< 4, T >::size_type size_type
MatrixTableIterators::Iterator< TransposeTable< T >, false, MatrixTableIterators::Storage::column_major > iterator
typename AccessorBase< TableType, true, storage_order >::size_type size_type
static ::ExceptionBase & ExcMessage(std::string arg1)
typename AlignedVector< T >::const_iterator const_iterator
void reinit(const TableIndices< N > &new_size, const bool omit_default_initialization=false)
typename AccessorBase< TableType, true, storage_order >::value_type value_type
#define Assert(cond, exc)
typename AccessorBase< TableType, true, storage_order >::size_type size_type
Accessor base class for Table<2, T> and TransposeTable.
void reinit(const size_type size1, const size_type size2, const bool omit_default_initialization=false)
AlignedVector< T >::reference el(const TableIndices< N > &indices)
container_pointer_type container
#define DEAL_II_NAMESPACE_CLOSE
VectorType::value_type * end(VectorType &V)
std::ptrdiff_t linear_index
typename Types< N, T, C >::iterator iterator
typename TableType::size_type size_type
typename AlignedVector< T >::const_reference reference
const value_type * const_iterator
friend bool operator==(const AccessorBase< TableType, Constness, storage_order > &left, const AccessorBase< TableType, OtherConstness, storage_order > &right)
Accessor class offering read and write access to the elements of a table.
typename Types< N, T, C >::reference reference
typename AlignedVector< T >::const_reference const_reference
typename AlignedVector< T >::const_iterator iterator
typename Types< N, T, C >::const_reference const_reference
Iterator class for both matrix-like tables, i.e., Table<2, T> and TransposeTable. ...
void swap(TableBase< N, T > &u, TableBase< N, T > &v)
size_type size(const unsigned int i) const
TableBase< N, T > & operator=(const TableBase< N, T > &src)
typename AlignedVector< Number >::size_type size_type
std::size_t memory_consumption() const
#define DEAL_II_NAMESPACE_OPEN
VectorType::value_type * begin(VectorType &V)
typename TableBase< 5, T >::size_type size_type
typename AlignedVector< T >::reference reference
typename TableType::value_type value_type
typename AlignedVector< T >::value_type value_type
reference el(const size_type i, const size_type j)
static ::ExceptionBase & ExcNotImplemented()
typename Types< N, T, C >::value_type value_type
TableIndices< N > table_size
#define DeclException3(Exception3, type1, type2, type3, outsequence)
const_reference operator()(const size_type i, const size_type j) const
AlignedVector< T >::reference operator()(const TableIndices< N > &indices)
AlignedVector< T > values
Accessor class template. This class is partially specialized for both values of Constness.
void copy(const T *begin, const T *end, U *dest)
typename TableBase< 7, T >::size_type size_type
const value_type & const_reference
void fill(InputIterator entries, const bool C_style_indexing=true)
T max(const T &t, const MPI_Comm &mpi_communicator)
typename AlignedVector< T >::const_iterator const_iterator
std::enable_if< std::is_fundamental< T >::value, std::size_t >::type memory_consumption(const T &t)
typename AlignedVector< number >::const_reference const_reference
typename std::conditional< Constness, const TableType *, TableType * >::type container_pointer_type
Tensor< 2, dim, Number > l(const Tensor< 2, dim, Number > &F, const Tensor< 2, dim, Number > &dF_dt)
static ::ExceptionBase & ExcInternalError()