Reference documentation for deal.II version GIT 85919f3e70 2023-05-28 07:10:01+00:00
\(\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}}\) \(\newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=}\) \(\newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]}\) \(\newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}\)
array_view.h
Go to the documentation of this file.
1 // ---------------------------------------------------------------------
2 //
3 // Copyright (C) 2004 - 2021 by the deal.II authors
4 //
5 // This file is part of the deal.II library.
6 //
7 // The deal.II library is free software; you can use it, redistribute
8 // it, and/or modify it under the terms of the GNU Lesser General
9 // Public License as published by the Free Software Foundation; either
10 // version 2.1 of the License, or (at your option) any later version.
11 // The full text of the license can be found in the file LICENSE.md at
12 // the top level directory of deal.II.
13 //
14 // ---------------------------------------------------------------------
15 
16 #ifndef dealii_array_view_h
17 #define dealii_array_view_h
18 
19 #include <deal.II/base/config.h>
20 
24 #include <deal.II/base/tensor.h>
25 
26 #include <array>
27 #include <type_traits>
28 #include <vector>
29 
31 
32 // Forward declaration
33 template <class T>
34 class AlignedVector;
35 
36 template <int N, typename T>
37 class Table;
38 
39 template <typename number>
40 class LAPACKFullMatrix;
41 
42 
84 template <typename ElementType, typename MemorySpaceType = MemorySpace::Host>
85 class ArrayView
86 {
87 public:
93 
97  using iterator = value_type *;
98 
102  using const_iterator = const ElementType *;
103 
108 
129 
139  ArrayView(const ArrayView<typename std::remove_cv<value_type>::type,
140  MemorySpaceType> &view);
141 
146  explicit ArrayView(value_type &element);
147 
163  const std::vector<typename std::remove_cv<value_type>::type> &vector);
164 
179  ArrayView(std::vector<typename std::remove_cv<value_type>::type> &vector);
180 
195  template <std::size_t N>
196  ArrayView(value_type (&array)[N]);
197 
206  template <std::size_t N>
208  const std::array<typename std::remove_cv<value_type>::type, N> &vector);
209 
218  template <std::size_t N>
219  ArrayView(std::array<typename std::remove_cv<value_type>::type, N> &vector);
220 
240  void
242 
256  bool
258  const ArrayView<const value_type, MemorySpaceType> &other_view) const;
259 
273  bool
274  operator==(const ArrayView<typename std::remove_cv<value_type>::type,
275  MemorySpaceType> &other_view) const;
276 
293  bool
295  const ArrayView<const value_type, MemorySpaceType> &other_view) const;
296 
310  bool
311  operator!=(const ArrayView<typename std::remove_cv<value_type>::type,
312  MemorySpaceType> &other_view) const;
313 
318  std::size_t
319  size() const;
320 
324  bool
325  empty() const;
326 
332  data() const noexcept;
333 
337  iterator
338  begin() const;
339 
343  iterator
344  end() const;
345 
350  cbegin() const;
351 
356  cend() const;
357 
370  value_type &
371  operator[](const std::size_t i) const;
372 
373 private:
379 
383  std::size_t n_elements;
384 
385  friend class ArrayView<const ElementType, MemorySpaceType>;
386 };
387 
388 
389 
390 //---------------------------------------------------------------------------
391 
392 
393 template <typename ElementType, typename MemorySpaceType>
394 inline ArrayView<ElementType, MemorySpaceType>::ArrayView()
395  : starting_element(nullptr)
396  , n_elements(0)
397 {}
398 
399 
400 
401 template <typename ElementType, typename MemorySpaceType>
404  const std::size_t n_elements)
407 {}
408 
409 
410 
411 template <typename ElementType, typename MemorySpaceType>
412 inline void
414  const std::size_t n_elements)
415 {
416  this->starting_element = starting_element;
417  this->n_elements = n_elements;
418 }
419 
420 
421 
422 template <typename ElementType, typename MemorySpaceType>
424  : starting_element(&element)
425  , n_elements(1)
426 {}
427 
428 
429 
430 template <typename ElementType, typename MemorySpaceType>
432  const ArrayView<typename std::remove_cv<value_type>::type, MemorySpaceType>
433  &view)
434  : starting_element(view.starting_element)
435  , n_elements(view.n_elements)
436 {}
437 
438 
439 
440 template <typename ElementType, typename MemorySpaceType>
442  const std::vector<typename std::remove_cv<value_type>::type> &vector)
443  : // use delegating constructor
444  ArrayView(vector.data(), vector.size())
445 {
446  // the following static_assert is not strictly necessary because,
447  // if we got a const std::vector reference argument but ElementType
448  // is not itself const, then the call to the forwarding constructor
449  // above will already have failed: vector.data() will have returned
450  // a const pointer, but we need a non-const pointer.
451  //
452  // nevertheless, leave the static_assert in since it provides a
453  // more descriptive error message that will simply come after the first
454  // error produced above
455  static_assert(std::is_const<value_type>::value == true,
456  "This constructor may only be called if the ArrayView "
457  "object has a const value_type. In other words, you can "
458  "only create an ArrayView to const values from a const "
459  "std::vector.");
460 }
461 
462 
463 
464 template <typename ElementType, typename MemorySpaceType>
466  std::vector<typename std::remove_cv<value_type>::type> &vector)
467  : // use delegating constructor
468  ArrayView(vector.data(), vector.size())
469 {}
470 
471 
472 
473 template <typename ElementType, typename MemorySpaceType>
474 template <std::size_t N>
476  const std::array<typename std::remove_cv<value_type>::type, N> &vector)
477  : // use delegating constructor
478  ArrayView(vector.data(), vector.size())
479 {
480  // the following static_assert is not strictly necessary because,
481  // if we got a const std::array reference argument but ElementType
482  // is not itself const, then the call to the forwarding constructor
483  // above will already have failed: vector.data() will have returned
484  // a const pointer, but we need a non-const pointer.
485  //
486  // nevertheless, leave the static_assert in since it provides a
487  // more descriptive error message that will simply come after the first
488  // error produced above
489  static_assert(std::is_const<value_type>::value == true,
490  "This constructor may only be called if the ArrayView "
491  "object has a const value_type. In other words, you can "
492  "only create an ArrayView to const values from a const "
493  "std::array.");
494 }
495 
496 
497 
498 template <typename ElementType, typename MemorySpaceType>
499 template <std::size_t N>
501  ElementType (&array)[N])
502  : ArrayView(&array[0], N)
503 {}
504 
505 
506 
507 template <typename ElementType, typename MemorySpaceType>
508 template <std::size_t N>
510  std::array<typename std::remove_cv<value_type>::type, N> &vector)
511  : // use delegating constructor
512  ArrayView(vector.data(), vector.size())
513 {}
514 
515 
516 
517 template <typename ElementType, typename MemorySpaceType>
518 inline bool
520  const ArrayView<const value_type, MemorySpaceType> &other_view) const
521 {
522  return (other_view.data() == starting_element) &&
523  (other_view.size() == n_elements);
524 }
525 
526 
527 
528 template <typename ElementType, typename MemorySpaceType>
529 inline bool
531  const ArrayView<typename std::remove_cv<value_type>::type, MemorySpaceType>
532  &other_view) const
533 {
534  return (other_view.data() == starting_element) &&
535  (other_view.size() == n_elements);
536 }
537 
538 
539 
540 template <typename ElementType, typename MemorySpaceType>
541 inline bool
543  const ArrayView<const value_type, MemorySpaceType> &other_view) const
544 {
545  return !(*this == other_view);
546 }
547 
548 
549 
550 template <typename ElementType, typename MemorySpaceType>
551 inline DEAL_II_HOST_DEVICE
554 {
555  if (n_elements == 0)
556  return nullptr;
557  else
558  return starting_element;
559 }
560 
561 
562 
563 template <typename ElementType, typename MemorySpaceType>
564 inline bool
566  const ArrayView<typename std::remove_cv<value_type>::type, MemorySpaceType>
567  &other_view) const
568 {
569  return !(*this == other_view);
570 }
571 
572 
573 
574 template <typename ElementType, typename MemorySpaceType>
575 inline std::size_t
577 {
578  return n_elements;
579 }
580 
581 
582 
583 template <typename ElementType, typename MemorySpaceType>
584 inline bool
586 {
587  return n_elements == 0;
588 }
589 
590 
591 
592 template <typename ElementType, typename MemorySpaceType>
595 {
596  return starting_element;
597 }
598 
599 
600 
601 template <typename ElementType, typename MemorySpaceType>
604 {
605  return starting_element + n_elements;
606 }
607 
608 
609 
610 template <typename ElementType, typename MemorySpaceType>
613 {
614  return starting_element;
615 }
616 
617 
618 
619 template <typename ElementType, typename MemorySpaceType>
622 {
623  return starting_element + n_elements;
624 }
625 
626 
627 
628 template <typename ElementType, typename MemorySpaceType>
631 {
632  AssertIndexRange(i, n_elements);
633 
634  return *(starting_element + i);
635 }
636 
637 
638 
639 #ifndef DOXYGEN
640 namespace internal
641 {
642  namespace ArrayViewHelper
643  {
649  template <class Iterator>
650  bool
651  is_contiguous(const Iterator &first, const Iterator &last)
652  {
653  const auto n = std::distance(first, last);
654  for (typename std::decay<decltype(n)>::type i = 0; i < n; ++i)
655  if (std::addressof(*(std::next(first, i))) !=
656  std::next(std::addressof(*first), i))
657  return false;
658  return true;
659  }
660 
661 
672  template <class T>
673  constexpr bool
674  is_contiguous(T *, T *)
675  {
676  return true;
677  }
678  } // namespace ArrayViewHelper
679 } // namespace internal
680 #endif
681 
682 
683 
700 template <typename Iterator, typename MemorySpaceType = MemorySpace::Host>
701 ArrayView<typename std::remove_reference<
702  typename std::iterator_traits<Iterator>::reference>::type,
703  MemorySpaceType>
704 make_array_view(const Iterator begin, const Iterator end)
705 {
706  static_assert(
707  std::is_same<typename std::iterator_traits<Iterator>::iterator_category,
708  typename std::random_access_iterator_tag>::value,
709  "The provided iterator needs to be a random access iterator.");
710  Assert(begin <= end,
711  ExcMessage(
712  "The beginning of the array view needs to be before the end."));
713  Assert(internal::ArrayViewHelper::is_contiguous(begin, end),
714  ExcMessage("The provided range isn't contiguous in memory!"));
715  // the reference type, not the value type, knows the constness of the iterator
716  return ArrayView<typename std::remove_reference<
717  typename std::iterator_traits<Iterator>::reference>::type,
718  MemorySpaceType>(std::addressof(*begin), end - begin);
719 }
720 
721 
722 
732 template <typename ElementType, typename MemorySpaceType = MemorySpace::Host>
735 {
736  Assert(begin <= end,
737  ExcMessage(
738  "The beginning of the array view needs to be before the end."));
740 }
741 
742 
743 
754 template <typename Number, typename MemorySpaceType>
757 {
758  return make_array_view(array_view.cbegin(), array_view.cend());
759 }
760 
761 
762 
773 template <typename Number, typename MemorySpaceType>
776 {
777  return make_array_view(array_view.begin(), array_view.end());
778 }
779 
780 
781 
803 template <int rank, int dim, typename Number>
806 {
807  return make_array_view(tensor.begin_raw(), tensor.end_raw());
808 }
809 
810 
811 
833 template <int rank, int dim, typename Number>
836 {
837  return make_array_view(tensor.begin_raw(), tensor.end_raw());
838 }
839 
840 
841 
863 template <int rank, int dim, typename Number>
866 {
867  return make_array_view(tensor.begin_raw(), tensor.end_raw());
868 }
869 
870 
871 
894 template <int rank, int dim, typename Number>
897 {
898  return make_array_view(tensor.begin_raw(), tensor.end_raw());
899 }
900 
901 
902 
916 template <typename ElementType, int N>
918 {
919  return ArrayView<ElementType>(array, N);
920 }
921 
922 
923 
938 template <typename ElementType>
941 {
942  return ArrayView<ElementType>(vector.begin(), vector.size());
943 }
944 
945 
946 
961 template <typename ElementType>
964 {
965  return ArrayView<const ElementType>(vector.begin(), vector.size());
966 }
967 
968 
969 
984 template <typename ElementType>
986 make_array_view(std::vector<ElementType> &vector)
987 {
988  return ArrayView<ElementType>(vector.data(), vector.size());
989 }
990 
991 
992 
1007 template <typename ElementType>
1009 make_array_view(const std::vector<ElementType> &vector)
1010 {
1011  return ArrayView<const ElementType>(vector.data(), vector.size());
1012 }
1013 
1014 
1015 
1035 template <typename ElementType>
1037 make_array_view(std::vector<ElementType> &vector,
1038  const std::size_t starting_index,
1039  const std::size_t size_of_view)
1040 {
1041  Assert(starting_index + size_of_view <= vector.size(),
1042  ExcMessage("The starting index and size of the view you want to "
1043  "create would lead to a view that extends beyond the end "
1044  "of the given vector."));
1045  return ArrayView<ElementType>(&vector[starting_index], size_of_view);
1046 }
1047 
1048 
1049 
1069 template <typename ElementType>
1071 make_array_view(const std::vector<ElementType> &vector,
1072  const std::size_t starting_index,
1073  const std::size_t size_of_view)
1074 {
1075  Assert(starting_index + size_of_view <= vector.size(),
1076  ExcMessage("The starting index and size of the view you want to "
1077  "create would lead to a view that extends beyond the end "
1078  "of the given vector."));
1079  return ArrayView<const ElementType>(&vector[starting_index], size_of_view);
1080 }
1081 
1082 
1083 
1091 template <typename ElementType>
1094 {
1095  return ArrayView<ElementType>(vector.data(), vector.size());
1096 }
1097 
1098 
1099 
1107 template <typename ElementType>
1110 {
1111  return ArrayView<const ElementType>(vector.data(), vector.size());
1112 }
1113 
1114 
1115 
1123 template <typename ElementType>
1126  const std::size_t starting_index,
1127  const std::size_t size_of_view)
1128 {
1129  Assert(starting_index + size_of_view <= vector.size(),
1130  ExcMessage("The starting index and size of the view you want to "
1131  "create would lead to a view that extends beyond the end "
1132  "of the given vector."));
1133  return ArrayView<ElementType>(&vector[starting_index], size_of_view);
1134 }
1135 
1136 
1137 
1145 template <typename ElementType>
1148  const std::size_t starting_index,
1149  const std::size_t size_of_view)
1150 {
1151  Assert(starting_index + size_of_view <= vector.size(),
1152  ExcMessage("The starting index and size of the view you want to "
1153  "create would lead to a view that extends beyond the end "
1154  "of the given vector."));
1155  return ArrayView<const ElementType>(&vector[starting_index], size_of_view);
1156 }
1157 
1158 
1159 
1174 template <typename ElementType, std::size_t N>
1176 make_array_view(std::array<ElementType, N> &array)
1177 {
1178  return ArrayView<ElementType>(array);
1179 }
1180 
1181 
1182 
1197 template <typename ElementType, std::size_t N>
1199 make_array_view(const std::array<ElementType, N> &array)
1200 {
1201  return ArrayView<const ElementType>(array);
1202 }
1203 
1204 
1205 
1222 template <typename ElementType>
1225  const typename Table<2, ElementType>::size_type row)
1226 {
1227  AssertIndexRange(row, table.size()[0]);
1228  return ArrayView<ElementType>(&table[row][0], table.size()[1]);
1229 }
1230 
1231 
1232 
1249 template <typename ElementType>
1252 {
1253  return ArrayView<ElementType>(&table[0][0], table.n_elements());
1254 }
1255 
1256 
1257 
1274 template <typename ElementType>
1277 {
1278  return ArrayView<const ElementType>(&table[0][0], table.n_elements());
1279 }
1280 
1281 
1299 template <typename ElementType>
1302 {
1303  return ArrayView<ElementType>(&matrix(0, 0), matrix.n_elements());
1304 }
1305 
1306 
1307 
1324 template <typename ElementType>
1327 {
1328  return ArrayView<const ElementType>(&matrix(0, 0), matrix.n_elements());
1329 }
1330 
1331 
1332 
1349 template <typename ElementType>
1352  const typename Table<2, ElementType>::size_type row)
1353 {
1354  AssertIndexRange(row, table.size()[0]);
1355  return ArrayView<const ElementType>(&table[row][0], table.size()[1]);
1356 }
1357 
1358 
1359 
1379 template <typename ElementType>
1382  const typename Table<2, ElementType>::size_type row,
1383  const typename Table<2, ElementType>::size_type starting_column,
1384  const std::size_t size_of_view)
1385 {
1386  AssertIndexRange(row, table.size()[0]);
1387  AssertIndexRange(starting_column, table.size()[1]);
1388  Assert(starting_column + size_of_view <= table.size()[1],
1389  ExcMessage("The starting index and size of the view you want to "
1390  "create would lead to a view that extends beyond the end "
1391  "of a column of the given table."));
1392  return ArrayView<ElementType>(&table[row][starting_column], size_of_view);
1393 }
1394 
1395 
1396 
1416 template <typename ElementType>
1419  const typename Table<2, ElementType>::size_type row,
1420  const typename Table<2, ElementType>::size_type starting_column,
1421  const std::size_t size_of_view)
1422 {
1423  AssertIndexRange(row, table.size()[0]);
1424  AssertIndexRange(starting_column, table.size()[1]);
1425  Assert(starting_column + size_of_view <= table.size()[1],
1426  ExcMessage("The starting index and size of the view you want to "
1427  "create would lead to a view that extends beyond the end "
1428  "of a column of the given table."));
1429  return ArrayView<const ElementType>(&table[row][starting_column],
1430  size_of_view);
1431 }
1432 
1433 
1434 
1435 /*
1436  * Create a view that doesn't allow the container it points to to be modified.
1437  * This is useful if the object passed in is not `const` already and a function
1438  * requires a view to constant memory in its signature.
1439  *
1440  * This function returns an object of type `ArrayView<const T>` where `T` is the
1441  * element type of the container.
1442  *
1443  * @relatesalso ArrayView
1444  */
1445 template <typename Container>
1446 inline auto
1447 make_const_array_view(const Container &container)
1448  -> decltype(make_array_view(container))
1449 {
1450  return make_array_view(container);
1451 }
1452 
1453 
1455 
1456 #endif
auto make_const_array_view(const Container &container) -> decltype(make_array_view(container))
Definition: array_view.h:1447
pointer data()
size_type size() const
ArrayView< const ElementType > make_array_view(const Vector< ElementType > &vector)
Definition: array_view.h:963
ArrayView(value_type &element)
Definition: array_view.h:423
iterator begin() const
Definition: array_view.h:594
ArrayView(const ArrayView< typename std::remove_cv< value_type >::type, MemorySpaceType > &view)
Definition: array_view.h:431
ArrayView< Number, MemorySpaceType > make_array_view(ArrayView< Number, MemorySpaceType > &array_view)
Definition: array_view.h:775
ArrayView< typename std::remove_reference< typename std::iterator_traits< Iterator >::reference >::type, MemorySpaceType > make_array_view(const Iterator begin, const Iterator end)
Definition: array_view.h:704
value_type * iterator
Definition: array_view.h:97
ArrayView< Number > make_array_view(SymmetricTensor< rank, dim, Number > &tensor)
Definition: array_view.h:896
value_type & operator[](const std::size_t i) const
Definition: array_view.h:630
ArrayView< const ElementType > make_array_view(const LAPACKFullMatrix< ElementType > &matrix)
Definition: array_view.h:1326
ArrayView< ElementType > make_array_view(std::array< ElementType, N > &array)
Definition: array_view.h:1176
bool empty() const
Definition: array_view.h:585
ArrayView< const Number > make_array_view(const Tensor< rank, dim, Number > &tensor)
Definition: array_view.h:805
ArrayView< const Number > make_array_view(const SymmetricTensor< rank, dim, Number > &tensor)
Definition: array_view.h:865
ArrayView< ElementType > make_array_view(LAPACKFullMatrix< ElementType > &matrix)
Definition: array_view.h:1301
ArrayView< ElementType > make_array_view(ElementType(&array)[N])
Definition: array_view.h:917
ArrayView< ElementType, MemorySpaceType > make_array_view(ElementType *const begin, ElementType *const end)
Definition: array_view.h:734
bool operator!=(const ArrayView< typename std::remove_cv< value_type >::type, MemorySpaceType > &other_view) const
Definition: array_view.h:565
const_iterator cend() const
Definition: array_view.h:621
iterator end() const
Definition: array_view.h:603
ArrayView< const ElementType > make_array_view(const std::vector< ElementType > &vector, const std::size_t starting_index, const std::size_t size_of_view)
Definition: array_view.h:1071
ArrayView< const ElementType > make_array_view(const Table< 2, ElementType > &table)
Definition: array_view.h:1276
ArrayView< const ElementType > make_array_view(const Table< 2, ElementType > &table, const typename Table< 2, ElementType >::size_type row, const typename Table< 2, ElementType >::size_type starting_column, const std::size_t size_of_view)
Definition: array_view.h:1418
ArrayView(const std::array< typename std::remove_cv< value_type >::type, N > &vector)
Definition: array_view.h:475
ArrayView< ElementType > make_array_view(std::vector< ElementType > &vector)
Definition: array_view.h:986
ArrayView(std::vector< typename std::remove_cv< value_type >::type > &vector)
Definition: array_view.h:465
bool operator==(const ArrayView< const value_type, MemorySpaceType > &other_view) const
Definition: array_view.h:519
ArrayView< ElementType > make_array_view(std::vector< ElementType > &vector, const std::size_t starting_index, const std::size_t size_of_view)
Definition: array_view.h:1037
bool operator!=(const ArrayView< const value_type, MemorySpaceType > &other_view) const
Definition: array_view.h:542
const_iterator cbegin() const
Definition: array_view.h:612
ArrayView(const std::vector< typename std::remove_cv< value_type >::type > &vector)
Definition: array_view.h:441
ArrayView(value_type(&array)[N])
Definition: array_view.h:500
ArrayView< Number > make_array_view(Tensor< rank, dim, Number > &tensor)
Definition: array_view.h:835
value_type * data() const noexcept
Definition: array_view.h:553
ArrayView< ElementType > make_array_view(Table< 2, ElementType > &table, const typename Table< 2, ElementType >::size_type row, const typename Table< 2, ElementType >::size_type starting_column, const std::size_t size_of_view)
Definition: array_view.h:1381
void reinit(value_type *starting_element, const std::size_t n_elements)
Definition: array_view.h:413
ArrayView< ElementType > make_array_view(Table< 2, ElementType > &table)
Definition: array_view.h:1251
value_type * starting_element
Definition: array_view.h:378
std::size_t size() const
Definition: array_view.h:576
bool operator==(const ArrayView< typename std::remove_cv< value_type >::type, MemorySpaceType > &other_view) const
Definition: array_view.h:530
ElementType value_type
Definition: array_view.h:92
ArrayView(value_type *starting_element, const std::size_t n_elements)
Definition: array_view.h:402
std::size_t n_elements
Definition: array_view.h:383
ArrayView< const Number, MemorySpaceType > make_array_view(const ArrayView< Number, MemorySpaceType > &array_view)
Definition: array_view.h:756
ArrayView< const ElementType > make_array_view(const Table< 2, ElementType > &table, const typename Table< 2, ElementType >::size_type row)
Definition: array_view.h:1351
ArrayView< const ElementType > make_array_view(const AlignedVector< ElementType > &vector, const std::size_t starting_index, const std::size_t size_of_view)
Definition: array_view.h:1147
ArrayView< const ElementType > make_array_view(const AlignedVector< ElementType > &vector)
Definition: array_view.h:1109
const ElementType * const_iterator
Definition: array_view.h:102
ArrayView< ElementType > make_array_view(Vector< ElementType > &vector)
Definition: array_view.h:940
ArrayView< ElementType > make_array_view(Table< 2, ElementType > &table, const typename Table< 2, ElementType >::size_type row)
Definition: array_view.h:1224
ArrayView< const ElementType > make_array_view(const std::vector< ElementType > &vector)
Definition: array_view.h:1009
ArrayView< ElementType > make_array_view(AlignedVector< ElementType > &vector, const std::size_t starting_index, const std::size_t size_of_view)
Definition: array_view.h:1125
ArrayView< const ElementType > make_array_view(const std::array< ElementType, N > &array)
Definition: array_view.h:1199
ArrayView< ElementType > make_array_view(AlignedVector< ElementType > &vector)
Definition: array_view.h:1093
ArrayView(std::array< typename std::remove_cv< value_type >::type, N > &vector)
Definition: array_view.h:509
Number * begin_raw()
Number * end_raw()
Definition: tensor.h:516
Number * end_raw()
Number * begin_raw()
Definition: vector.h:109
size_type size() const
iterator begin()
#define DEAL_II_DEPRECATED
Definition: config.h:174
#define DEAL_II_NAMESPACE_OPEN
Definition: config.h:474
#define DEAL_II_NAMESPACE_CLOSE
Definition: config.h:475
Point< 2 > first
Definition: grid_out.cc:4615
#define Assert(cond, exc)
Definition: exceptions.h:1614
#define AssertIndexRange(index, range)
Definition: exceptions.h:1855
static ::ExceptionBase & ExcMessage(std::string arg1)
@ matrix
Contents is actually a matrix.
static const char T
static const char N
VectorType::value_type * begin(VectorType &V)
VectorType::value_type * end(VectorType &V)
#define DEAL_II_HOST_DEVICE
Definition: numbers.h:35