Reference documentation for deal.II version GIT 6da2e5d553 2022-07-01 18:55:02+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\}}\)
full_matrix.h
Go to the documentation of this file.
1 // ---------------------------------------------------------------------
2 //
3 // Copyright (C) 1999 - 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_full_matrix_h
17 #define dealii_full_matrix_h
18 
19 
20 #include <deal.II/base/config.h>
21 
22 #include <deal.II/base/numbers.h>
23 #include <deal.II/base/table.h>
24 #include <deal.II/base/tensor.h>
25 
27 
28 #include <deal.II/lac/exceptions.h>
30 
31 #include <cstring>
32 #include <iomanip>
33 #include <vector>
34 
36 
37 
38 // forward declarations
39 #ifndef DOXYGEN
40 template <typename number>
41 class Vector;
42 template <typename number>
43 class LAPACKFullMatrix;
44 #endif
45 
78 template <typename number>
79 class FullMatrix : public Table<2, number>
80 {
81 public:
82  // The assertion in full_matrix.templates.h for whether or not a number is
83  // finite is not compatible for AD number types.
84  static_assert(
86  "The FullMatrix class does not support auto-differentiable numbers.");
87 
91  using size_type = std::size_t;
92 
97  using value_type = number;
98 
103 
108 
113 
117  using Table<2, number>::end;
118 
129 
134 
144  explicit FullMatrix(const size_type n = 0);
145 
149  FullMatrix(const size_type rows, const size_type cols);
150 
155  FullMatrix(const size_type rows, const size_type cols, const number *entries);
156 
180  template <typename number2>
183 
192  operator=(const number d);
193 
204 
209  template <typename number2>
212 
213 
219  template <typename MatrixType>
220  void
221  copy_from(const MatrixType &);
222 
228  template <typename MatrixType>
229  void
230  copy_transposed(const MatrixType &);
231 
239  template <int dim>
240  void
242  const unsigned int src_r_i = 0,
243  const unsigned int src_r_j = dim - 1,
244  const unsigned int src_c_i = 0,
245  const unsigned int src_c_j = dim - 1,
246  const size_type dst_r = 0,
247  const size_type dst_c = 0);
248 
256  template <int dim>
257  void
259  const size_type src_r_i = 0,
260  const size_type src_r_j = dim - 1,
261  const size_type src_c_i = 0,
262  const size_type src_c_j = dim - 1,
263  const unsigned int dst_r = 0,
264  const unsigned int dst_c = 0) const;
265 
278  template <typename MatrixType, typename index_type>
279  void
280  extract_submatrix_from(const MatrixType & matrix,
281  const std::vector<index_type> &row_index_set,
282  const std::vector<index_type> &column_index_set);
283 
296  template <typename MatrixType, typename index_type>
297  void
298  scatter_matrix_to(const std::vector<index_type> &row_index_set,
299  const std::vector<index_type> &column_index_set,
300  MatrixType & matrix) const;
301 
312  template <typename number2>
313  void
315  const size_type dst_offset_i = 0,
316  const size_type dst_offset_j = 0,
317  const size_type src_offset_i = 0,
318  const size_type src_offset_j = 0);
319 
320 
324  template <typename number2>
325  void
326  fill(const number2 *);
327 
339  template <typename number2>
340  void
342  const std::vector<size_type> &p_rows,
343  const std::vector<size_type> &p_cols);
344 
355  void
356  set(const size_type i, const size_type j, const number value);
372  bool
374 
379  size_type
380  m() const;
381 
386  size_type
387  n() const;
388 
394  bool
395  all_zero() const;
396 
412  template <typename number2>
413  number2
415 
425  template <typename number2>
426  number2
428  const Vector<number2> &v) const;
429 
434  real_type
435  l1_norm() const;
436 
441  real_type
442  linfty_norm() const;
443 
451  real_type
452  frobenius_norm() const;
453 
462  real_type
464 
470  number
471  determinant() const;
472 
478  number
479  trace() const;
480 
487  template <class StreamType>
488  void
489  print(StreamType & s,
490  const unsigned int width = 5,
491  const unsigned int precision = 2) const;
492 
515  void
516  print_formatted(std::ostream & out,
517  const unsigned int precision = 3,
518  const bool scientific = true,
519  const unsigned int width = 0,
520  const char * zero_string = " ",
521  const double denominator = 1.,
522  const double threshold = 0.) const;
523 
528  std::size_t
530 
532 
534 
538  iterator
539  begin(const size_type r);
540 
544  iterator
545  end(const size_type r);
546 
551  begin(const size_type r) const;
552 
557  end(const size_type r) const;
558 
560 
562 
566  FullMatrix &
567  operator*=(const number factor);
568 
572  FullMatrix &
573  operator/=(const number factor);
574 
582  template <typename number2>
583  void
584  add(const number a, const FullMatrix<number2> &A);
585 
593  template <typename number2>
594  void
595  add(const number a,
596  const FullMatrix<number2> &A,
597  const number b,
598  const FullMatrix<number2> &B);
599 
608  template <typename number2>
609  void
610  add(const number a,
611  const FullMatrix<number2> &A,
612  const number b,
613  const FullMatrix<number2> &B,
614  const number c,
615  const FullMatrix<number2> &C);
616 
628  template <typename number2>
629  void
631  const number factor,
632  const size_type dst_offset_i = 0,
633  const size_type dst_offset_j = 0,
634  const size_type src_offset_i = 0,
635  const size_type src_offset_j = 0);
636 
642  template <typename number2>
643  void
644  Tadd(const number s, const FullMatrix<number2> &B);
645 
657  template <typename number2>
658  void
660  const number factor,
661  const size_type dst_offset_i = 0,
662  const size_type dst_offset_j = 0,
663  const size_type src_offset_i = 0,
664  const size_type src_offset_j = 0);
665 
669  void
670  add(const size_type row, const size_type column, const number value);
671 
681  template <typename number2, typename index_type>
682  void
683  add(const size_type row,
684  const size_type n_cols,
685  const index_type *col_indices,
686  const number2 * values,
687  const bool elide_zero_values = true,
688  const bool col_indices_are_sorted = false);
689 
693  void
694  add_row(const size_type i, const number s, const size_type j);
695 
700  void
702  const number s,
703  const size_type j,
704  const number t,
705  const size_type k);
706 
710  void
711  add_col(const size_type i, const number s, const size_type j);
712 
717  void
719  const number s,
720  const size_type j,
721  const number t,
722  const size_type k);
723 
727  void
728  swap_row(const size_type i, const size_type j);
729 
733  void
734  swap_col(const size_type i, const size_type j);
735 
740  void
741  diagadd(const number s);
742 
746  template <typename number2>
747  void
748  equ(const number a, const FullMatrix<number2> &A);
749 
753  template <typename number2>
754  void
755  equ(const number a,
756  const FullMatrix<number2> &A,
757  const number b,
758  const FullMatrix<number2> &B);
759 
763  template <typename number2>
764  void
765  equ(const number a,
766  const FullMatrix<number2> &A,
767  const number b,
768  const FullMatrix<number2> &B,
769  const number c,
770  const FullMatrix<number2> &C);
771 
778  void
780 
795  void
797 
804  template <typename number2>
805  void
807 
816  template <typename number2>
817  void
819 
824  template <typename number2>
825  void
827 
833  template <typename number2>
834  void
836 
842  template <typename number2>
843  void
845 
847 
849 
868  template <typename number2>
869  void
871  const FullMatrix<number2> &B,
872  const bool adding = false) const;
873 
892  template <typename number2>
893  void
895  const FullMatrix<number2> &B,
896  const bool adding = false) const;
897 
916  template <typename number2>
917  void
919  const FullMatrix<number2> &B,
920  const bool adding = false) const;
921 
941  template <typename number2>
942  void
944  const FullMatrix<number2> &B,
945  const bool adding = false) const;
946 
957  void
959  const FullMatrix<number> &B,
960  const FullMatrix<number> &D,
961  const bool transpose_B = false,
962  const bool transpose_D = false,
963  const number scaling = number(1.));
964 
977  template <typename number2>
978  void
980  const Vector<number2> &v,
981  const bool adding = false) const;
982 
988  template <typename number2>
989  void
991 
1005  template <typename number2>
1006  void
1008  const Vector<number2> &v,
1009  const bool adding = false) const;
1010 
1017  template <typename number2>
1018  void
1020 
1026  template <typename somenumber>
1027  void
1029  const Vector<somenumber> &src,
1030  const number omega = 1.) const;
1031 
1038  template <typename number2, typename number3>
1039  number
1041  const Vector<number2> &x,
1042  const Vector<number3> &b) const;
1043 
1054  template <typename number2>
1055  void
1056  forward(Vector<number2> &dst, const Vector<number2> &src) const;
1057 
1065  template <typename number2>
1066  void
1067  backward(Vector<number2> &dst, const Vector<number2> &src) const;
1068 
1070 
1080 
1085  ExcNotRegular,
1086  number,
1087  << "The maximal pivot is " << arg1
1088  << ", which is below the threshold. The matrix may be singular.");
1093  size_type,
1094  size_type,
1095  size_type,
1096  << "Target region not in matrix: size in this direction="
1097  << arg1 << ", size of new matrix=" << arg2
1098  << ", offset=" << arg3);
1103  "You are attempting an operation on two matrices that "
1104  "are the same object, but the operation requires that the "
1105  "two objects are in fact different.");
1111 };
1112 
1115 #ifndef DOXYGEN
1116 /*-------------------------Inline functions -------------------------------*/
1117 
1118 
1119 
1120 template <typename number>
1121 inline typename FullMatrix<number>::size_type
1122 FullMatrix<number>::m() const
1123 {
1124  return this->n_rows();
1125 }
1126 
1127 
1128 
1129 template <typename number>
1130 inline typename FullMatrix<number>::size_type
1131 FullMatrix<number>::n() const
1132 {
1133  return this->n_cols();
1134 }
1135 
1136 
1137 
1138 template <typename number>
1140 FullMatrix<number>::operator=(const number d)
1141 {
1142  Assert(d == number(0), ExcScalarAssignmentOnlyForZeroValue());
1143  (void)d; // removes -Wunused-parameter warning in optimized mode
1144 
1145  if (this->n_elements() != 0)
1146  this->reset_values();
1147 
1148  return *this;
1149 }
1150 
1151 
1152 
1153 template <typename number>
1154 template <typename number2>
1155 inline void
1156 FullMatrix<number>::fill(const number2 *src)
1157 {
1159 }
1160 
1161 
1162 
1163 template <typename number>
1164 template <typename MatrixType>
1165 void
1166 FullMatrix<number>::copy_from(const MatrixType &M)
1167 {
1168  this->reinit(M.m(), M.n());
1169 
1170  // loop over the elements of the argument matrix row by row, as suggested
1171  // in the documentation of the sparse matrix iterator class, and
1172  // copy them into the current object
1173  for (size_type row = 0; row < M.m(); ++row)
1174  {
1175  const typename MatrixType::const_iterator end_row = M.end(row);
1176  for (typename MatrixType::const_iterator entry = M.begin(row);
1177  entry != end_row;
1178  ++entry)
1179  this->el(row, entry->column()) = entry->value();
1180  }
1181 }
1182 
1183 
1184 
1185 template <typename number>
1186 template <typename MatrixType>
1187 void
1188 FullMatrix<number>::copy_transposed(const MatrixType &M)
1189 {
1190  this->reinit(M.n(), M.m());
1191 
1192  // loop over the elements of the argument matrix row by row, as suggested
1193  // in the documentation of the sparse matrix iterator class, and
1194  // copy them into the current object
1195  for (size_type row = 0; row < M.m(); ++row)
1196  {
1197  const typename MatrixType::const_iterator end_row = M.end(row);
1198  for (typename MatrixType::const_iterator entry = M.begin(row);
1199  entry != end_row;
1200  ++entry)
1201  this->el(entry->column(), row) = entry->value();
1202  }
1203 }
1204 
1205 
1206 
1207 template <typename number>
1208 template <typename MatrixType, typename index_type>
1209 inline void
1211  const MatrixType & matrix,
1212  const std::vector<index_type> &row_index_set,
1213  const std::vector<index_type> &column_index_set)
1214 {
1215  AssertDimension(row_index_set.size(), this->n_rows());
1216  AssertDimension(column_index_set.size(), this->n_cols());
1217 
1218  const size_type n_rows_submatrix = row_index_set.size();
1219  const size_type n_cols_submatrix = column_index_set.size();
1220 
1221  for (size_type sub_row = 0; sub_row < n_rows_submatrix; ++sub_row)
1222  for (size_type sub_col = 0; sub_col < n_cols_submatrix; ++sub_col)
1223  (*this)(sub_row, sub_col) =
1224  matrix.el(row_index_set[sub_row], column_index_set[sub_col]);
1225 }
1226 
1227 
1228 
1229 template <typename number>
1230 template <typename MatrixType, typename index_type>
1231 inline void
1233  const std::vector<index_type> &row_index_set,
1234  const std::vector<index_type> &column_index_set,
1235  MatrixType & matrix) const
1236 {
1237  AssertDimension(row_index_set.size(), this->n_rows());
1238  AssertDimension(column_index_set.size(), this->n_cols());
1239 
1240  const size_type n_rows_submatrix = row_index_set.size();
1241  const size_type n_cols_submatrix = column_index_set.size();
1242 
1243  for (size_type sub_row = 0; sub_row < n_rows_submatrix; ++sub_row)
1244  for (size_type sub_col = 0; sub_col < n_cols_submatrix; ++sub_col)
1245  matrix.set(row_index_set[sub_row],
1246  column_index_set[sub_col],
1247  (*this)(sub_row, sub_col));
1248 }
1249 
1250 
1251 template <typename number>
1252 inline void
1254  const size_type j,
1255  const number value)
1256 {
1257  (*this)(i, j) = value;
1258 }
1259 
1260 
1261 
1262 template <typename number>
1263 template <typename number2>
1264 void
1266  const Vector<number2> &v) const
1267 {
1268  vmult(w, v, true);
1269 }
1270 
1271 
1272 template <typename number>
1273 template <typename number2>
1274 void
1276  const Vector<number2> &v) const
1277 {
1278  Tvmult(w, v, true);
1279 }
1280 
1281 
1282 //---------------------------------------------------------------------------
1283 template <typename number>
1284 inline typename FullMatrix<number>::iterator
1286 {
1287  AssertIndexRange(r, m());
1288  return iterator(this, r, 0);
1289 }
1290 
1291 
1292 
1293 template <typename number>
1294 inline typename FullMatrix<number>::iterator
1296 {
1297  AssertIndexRange(r, m());
1298  return iterator(this, r + 1, 0);
1299 }
1300 
1301 
1302 
1303 template <typename number>
1304 inline typename FullMatrix<number>::const_iterator
1305 FullMatrix<number>::begin(const size_type r) const
1306 {
1307  AssertIndexRange(r, m());
1308  return const_iterator(this, r, 0);
1309 }
1310 
1311 
1312 
1313 template <typename number>
1314 inline typename FullMatrix<number>::const_iterator
1315 FullMatrix<number>::end(const size_type r) const
1316 {
1317  AssertIndexRange(r, m());
1318  return const_iterator(this, r + 1, 0);
1319 }
1320 
1321 
1322 
1323 template <typename number>
1324 inline void
1325 FullMatrix<number>::add(const size_type r, const size_type c, const number v)
1326 {
1327  AssertIndexRange(r, this->m());
1328  AssertIndexRange(c, this->n());
1329 
1330  this->operator()(r, c) += v;
1331 }
1332 
1333 
1334 
1335 template <typename number>
1336 template <typename number2, typename index_type>
1337 inline void
1339  const size_type n_cols,
1340  const index_type *col_indices,
1341  const number2 * values,
1342  const bool,
1343  const bool)
1344 {
1345  AssertIndexRange(row, this->m());
1346  for (size_type col = 0; col < n_cols; ++col)
1347  {
1348  AssertIndexRange(col_indices[col], this->n());
1349  this->operator()(row, col_indices[col]) += values[col];
1350  }
1351 }
1352 
1353 
1354 template <typename number>
1355 template <class StreamType>
1356 inline void
1357 FullMatrix<number>::print(StreamType & s,
1358  const unsigned int w,
1359  const unsigned int p) const
1360 {
1361  Assert(!this->empty(), ExcEmptyMatrix());
1362 
1363  // save the state of out stream
1364  const std::streamsize old_precision = s.precision(p);
1365  const std::streamsize old_width = s.width(w);
1366 
1367  for (size_type i = 0; i < this->m(); ++i)
1368  {
1369  for (size_type j = 0; j < this->n(); ++j)
1370  {
1371  s.width(w);
1372  s.precision(p);
1373  s << this->el(i, j);
1374  }
1375  s << std::endl;
1376  }
1377 
1378  // reset output format
1379  s.precision(old_precision);
1380  s.width(old_width);
1381 }
1382 
1383 
1384 #endif // DOXYGEN
1385 
1387 
1388 #endif
typename numbers::NumberTraits< number >::real_type real_type
Definition: full_matrix.h:128
typename Table< 2, number >::const_iterator const_iterator
Definition: full_matrix.h:107
void triple_product(const FullMatrix< number > &A, const FullMatrix< number > &B, const FullMatrix< number > &D, const bool transpose_B=false, const bool transpose_D=false, const number scaling=number(1.))
void TmTmult(FullMatrix< number2 > &C, const FullMatrix< number2 > &B, const bool adding=false) const
FullMatrix(const size_type rows, const size_type cols)
number residual(Vector< number2 > &dst, const Vector< number2 > &x, const Vector< number3 > &b) const
std::size_t memory_consumption() const
void diagadd(const number s)
void fill_permutation(const FullMatrix< number2 > &src, const std::vector< size_type > &p_rows, const std::vector< size_type > &p_cols)
void add_row(const size_type i, const number s, const size_type j)
void mmult(FullMatrix< number2 > &C, const FullMatrix< number2 > &B, const bool adding=false) const
real_type relative_symmetry_norm2() const
void add(const size_type row, const size_type column, const number value)
void copy_from(const Tensor< 2, dim > &T, const unsigned int src_r_i=0, const unsigned int src_r_j=dim - 1, const unsigned int src_c_i=0, const unsigned int src_c_j=dim - 1, const size_type dst_r=0, const size_type dst_c=0)
void symmetrize()
void equ(const number a, const FullMatrix< number2 > &A, const number b, const FullMatrix< number2 > &B)
number trace() const
void right_invert(const FullMatrix< number2 > &M)
std::size_t size_type
Definition: full_matrix.h:91
void set(const size_type i, const size_type j, const number value)
size_type n() const
void add_row(const size_type i, const number s, const size_type j, const number t, const size_type k)
FullMatrix< number > & operator=(const FullMatrix< number2 > &)
number value_type
Definition: full_matrix.h:97
typename Table< 2, number >::iterator iterator
Definition: full_matrix.h:102
void add(const number a, const FullMatrix< number2 > &A, const number b, const FullMatrix< number2 > &B, const number c, const FullMatrix< number2 > &C)
FullMatrix & operator/=(const number factor)
void Tadd(const number s, const FullMatrix< number2 > &B)
void vmult(Vector< number2 > &w, const Vector< number2 > &v, const bool adding=false) const
bool all_zero() const
void add_col(const size_type i, const number s, const size_type j, const number t, const size_type k)
void scatter_matrix_to(const std::vector< index_type > &row_index_set, const std::vector< index_type > &column_index_set, MatrixType &matrix) const
void swap_row(const size_type i, const size_type j)
void add(const FullMatrix< number2 > &src, const number factor, const size_type dst_offset_i=0, const size_type dst_offset_j=0, const size_type src_offset_i=0, const size_type src_offset_j=0)
void copy_to(Tensor< 2, dim > &T, const size_type src_r_i=0, const size_type src_r_j=dim - 1, const size_type src_c_i=0, const size_type src_c_j=dim - 1, const unsigned int dst_r=0, const unsigned int dst_c=0) const
number2 matrix_norm_square(const Vector< number2 > &v) const
void equ(const number a, const FullMatrix< number2 > &A)
const_iterator end(const size_type r) const
FullMatrix(const size_type rows, const size_type cols, const number *entries)
bool operator==(const FullMatrix< number > &) const
void Tvmult(Vector< number2 > &w, const Vector< number2 > &v, const bool adding=false) const
void Tmmult(FullMatrix< number2 > &C, const FullMatrix< number2 > &B, const bool adding=false) const
number2 matrix_scalar_product(const Vector< number2 > &u, const Vector< number2 > &v) const
void gauss_jordan()
void add(const size_type row, const size_type n_cols, const index_type *col_indices, const number2 *values, const bool elide_zero_values=true, const bool col_indices_are_sorted=false)
void add_col(const size_type i, const number s, const size_type j)
void precondition_Jacobi(Vector< somenumber > &dst, const Vector< somenumber > &src, const number omega=1.) const
FullMatrix(const IdentityMatrix &id)
void vmult_add(Vector< number2 > &w, const Vector< number2 > &v) const
FullMatrix< number > & operator=(const IdentityMatrix &id)
void invert(const FullMatrix< number2 > &M)
void cholesky(const FullMatrix< number2 > &A)
void fill(const FullMatrix< number2 > &src, const size_type dst_offset_i=0, const size_type dst_offset_j=0, const size_type src_offset_i=0, const size_type src_offset_j=0)
void add(const number a, const FullMatrix< number2 > &A)
FullMatrix & operator*=(const number factor)
FullMatrix< number > & operator=(const number d)
number determinant() const
void equ(const number a, const FullMatrix< number2 > &A, const number b, const FullMatrix< number2 > &B, const number c, const FullMatrix< number2 > &C)
void fill(const number2 *)
void copy_transposed(const MatrixType &)
void print(StreamType &s, const unsigned int width=5, const unsigned int precision=2) const
void print_formatted(std::ostream &out, const unsigned int precision=3, const bool scientific=true, const unsigned int width=0, const char *zero_string=" ", const double denominator=1., const double threshold=0.) const
void Tvmult_add(Vector< number2 > &w, const Vector< number2 > &v) const
void mTmult(FullMatrix< number2 > &C, const FullMatrix< number2 > &B, const bool adding=false) const
void left_invert(const FullMatrix< number2 > &M)
iterator begin(const size_type r)
iterator end(const size_type r)
void add(const number a, const FullMatrix< number2 > &A, const number b, const FullMatrix< number2 > &B)
void outer_product(const Vector< number2 > &V, const Vector< number2 > &W)
real_type frobenius_norm() const
void forward(Vector< number2 > &dst, const Vector< number2 > &src) const
void Tadd(const FullMatrix< number2 > &src, const number factor, const size_type dst_offset_i=0, const size_type dst_offset_j=0, const size_type src_offset_i=0, const size_type src_offset_j=0)
FullMatrix< number > & operator=(const LAPACKFullMatrix< number2 > &)
FullMatrix(const size_type n=0)
size_type m() const
void swap_col(const size_type i, const size_type j)
void extract_submatrix_from(const MatrixType &matrix, const std::vector< index_type > &row_index_set, const std::vector< index_type > &column_index_set)
void backward(Vector< number2 > &dst, const Vector< number2 > &src) const
void copy_from(const MatrixType &)
const_iterator begin(const size_type r) const
real_type l1_norm() const
real_type linfty_norm() const
Definition: vector.h:109
#define DEAL_II_NAMESPACE_OPEN
Definition: config.h:442
#define DEAL_II_NAMESPACE_CLOSE
Definition: config.h:443
#define DeclException0(Exception0)
Definition: exceptions.h:464
static ::ExceptionBase & ExcSourceEqualsDestination()
static ::ExceptionBase & ExcScalarAssignmentOnlyForZeroValue()
#define Assert(cond, exc)
Definition: exceptions.h:1473
static ::ExceptionBase & ExcInvalidDestination(size_type arg1, size_type arg2, size_type arg3)
static ::ExceptionBase & ExcNotRegular(number arg1)
#define AssertDimension(dim1, dim2)
Definition: exceptions.h:1667
#define AssertIndexRange(index, range)
Definition: exceptions.h:1732
#define DeclExceptionMsg(Exception, defaulttext)
Definition: exceptions.h:487
#define DeclException3(Exception3, type1, type2, type3, outsequence)
Definition: exceptions.h:555
static ::ExceptionBase & ExcMatrixNotPositiveDefinite()
static ::ExceptionBase & ExcEmptyMatrix()
#define DeclException1(Exception1, type1, outsequence)
Definition: exceptions.h:509
@ matrix
Contents is actually a matrix.
static const char A
static const char T
static const char V
types::global_dof_index size_type
Definition: cuda_kernels.h:45
SymmetricTensor< 2, dim, Number > C(const Tensor< 2, dim, Number > &F)
SymmetricTensor< 2, dim, Number > d(const Tensor< 2, dim, Number > &F, const Tensor< 2, dim, Number > &dF_dt)
Tensor< 2, dim, Number > w(const Tensor< 2, dim, Number > &F, const Tensor< 2, dim, Number > &dF_dt)
SymmetricTensor< 2, dim, Number > b(const Tensor< 2, dim, Number > &F)
void reinit(MatrixBlock< MatrixType > &v, const BlockSparsityPattern &p)
Definition: matrix_block.h:618