37 namespace LAPACKFullMatrixImplementation
51 std::vector<T> &real_part_eigenvalues,
52 std::vector<T> &imag_part_eigenvalues,
53 std::vector<T> &left_eigenvectors,
54 std::vector<T> &right_eigenvectors,
55 std::vector<T> &real_work,
60 static_assert(std::is_same_v<T, double> || std::is_same_v<T, float>,
61 "Only implemented for double and float");
62 Assert(
matrix.size() ==
static_cast<std::size_t
>(n_rows * n_rows),
64 Assert(
static_cast<std::size_t
>(n_rows) <= real_part_eigenvalues.size(),
66 Assert(
static_cast<std::size_t
>(n_rows) <= imag_part_eigenvalues.size(),
69 Assert(
static_cast<std::size_t
>(n_rows * n_rows) <=
70 left_eigenvectors.size(),
73 Assert(
static_cast<std::size_t
>(n_rows * n_rows) <=
74 right_eigenvectors.size(),
77 static_cast<std::size_t
>(2 * n_rows) <= real_work.size(),
79 Assert(work_flag == -1 || std::max<long int>(1, 3 * n_rows) <= work_flag,
86 real_part_eigenvalues.data(),
87 imag_part_eigenvalues.data(),
88 left_eigenvectors.data(),
90 right_eigenvectors.data(),
107 std::vector<std::complex<T>> &left_eigenvectors,
108 std::vector<std::complex<T>> &right_eigenvectors,
109 std::vector<std::complex<T>> &complex_work,
110 std::vector<T> &real_work,
115 std::is_same_v<T, double> || std::is_same_v<T, float>,
116 "Only implemented for std::complex<double> and std::complex<float>");
117 Assert(
matrix.size() ==
static_cast<std::size_t
>(n_rows * n_rows),
122 Assert(
static_cast<std::size_t
>(n_rows * n_rows) <=
123 left_eigenvectors.size(),
126 Assert(
static_cast<std::size_t
>(n_rows * n_rows) <=
127 right_eigenvectors.size(),
130 std::max<std::size_t>(1, work_flag) <= real_work.size(),
132 Assert(work_flag == -1 || std::max<long int>(1, 2 * n_rows) <= work_flag,
141 left_eigenvectors.data(),
143 right_eigenvectors.data(),
153 template <
typename T>
159 std::vector<T> &singular_values,
162 std::vector<T> &real_work,
164 std::vector<types::blas_int> &integer_work,
168 Assert(job ==
'A' || job ==
'S' || job ==
'O' || job ==
'N',
170 Assert(
static_cast<std::size_t
>(n_rows * n_cols) ==
matrix.size(),
172 Assert(std::min<std::size_t>(n_rows, n_cols) <= singular_values.size(),
174 Assert(8 * std::min<std::size_t>(n_rows, n_cols) <= integer_work.size(),
177 static_cast<std::size_t
>(work_flag) <= real_work.size(),
184 singular_values.data(),
187 right_vectors.
data(),
197 template <
typename T>
203 std::vector<T> &singular_values,
206 std::vector<std::complex<T>> &work,
207 std::vector<T> &real_work,
208 std::vector<types::blas_int> &integer_work,
212 Assert(job ==
'A' || job ==
'S' || job ==
'O' || job ==
'N',
214 Assert(
static_cast<std::size_t
>(n_rows * n_cols) ==
matrix.size(),
217 singular_values.size(),
219 Assert(8 * std::min<std::size_t>(n_rows, n_cols) <= integer_work.size(),
222 static_cast<std::size_t
>(work_flag) <= real_work.size(),
230 singular_values.data(),
233 right_vectors.
data(),
246 template <
typename number>
255 template <
typename number>
264 template <
typename number>
273 template <
typename number>
285 template <
typename number>
295 template <
typename number>
304 (*
this)(i, j) =
copy(i, j);
309 template <
typename number>
312 const std::array<number, 3> &csr,
325 const number t =
A(i, j);
326 A(i, j) = csr[0] *
A(i, j) + csr[1] *
A(k, j);
327 A(k, j) = -csr[1] * t + csr[0] *
A(k, j);
334 const number t =
A(j, i);
335 A(j, i) = csr[0] *
A(j, i) + csr[1] *
A(j, k);
336 A(j, k) = -csr[1] * t + csr[0] *
A(j, k);
343 template <
typename number>
359 const size_type jj = (j < col ? j : j + 1);
362 const size_type ii = (i < row ? i : i + 1);
363 (*this)(i, j) =
copy(ii, jj);
370 template <
typename number>
380 template <
typename number>
381 template <
typename number2>
387 for (
size_type i = 0; i < this->m(); ++i)
388 for (
size_type j = 0; j < this->n(); ++j)
389 (*
this)(i, j) = M(i, j);
398 template <
typename number>
399 template <
typename number2>
405 for (
size_type i = 0; i < this->m(); ++i)
406 for (
size_type j = 0; j < this->n(); ++j)
407 (*
this)(i, j) = M.
el(i, j);
416 template <
typename number>
423 if (this->n_elements() != 0)
424 this->reset_values();
432 template <
typename number>
441 const char type =
'G';
442 const number cfrom = 1.;
449 number *
values = this->values.data();
451 lascl(&type, &kl, &kl, &cfrom, &factor, &m, &n,
values, &lda, &info);
461 template <
typename number>
472 const char type =
'G';
473 const number cto = 1.;
480 number *
values = this->values.data();
482 lascl(&type, &kl, &kl, &factor, &cto, &m, &n,
values, &lda, &info);
492 template <
typename number>
510 number *
values = this->values.data();
511 const number *values_A =
A.values.data();
520 template <
typename number>
549 const std::array<number, 3> csr =
555 const number t =
A(i, k);
556 A(i, k) = csr[0] *
A(i, k) + csr[1] * z(i);
557 z(i) = -csr[1] * t + csr[0] * z(i);
592 const std::array<number, 3> csr =
598 const number t =
A(i, k);
599 A(i, k) = csr[0] *
A(i, k) - csr[1] * z(i);
600 z(i) = -csr[1] * t + csr[0] * z(i);
607 template <
typename number>
610 const std::complex<number> ,
611 const Vector<std::complex<number>> & )
619 template <
typename number>
638 syr(&uplo, &
N, &a, v.
begin(), &incx, this->values.begin(), &lda);
647 (*
this)(i, j) = (*
this)(j, i);
651 cholesky_rank1(*
this, a, v);
659 template <
typename number>
663 const bool adding)
const
667 const number alpha = 1.;
668 const number beta = (adding ? 1. : 0.);
669 const number
null = 0.;
680 const char diag =
'N';
681 const char trans =
'N';
692 &uplo, &trans, &diag, &
N, this->values.data(), &lda,
w.data(), &incx);
720 std::lock_guard<std::mutex> lock(mutex);
729 svd_vt->values.data(),
737 for (
size_type i = 0; i < wr.size(); ++i)
744 svd_u->values.data(),
755 std::lock_guard<std::mutex> lock(mutex);
764 svd_u->values.data(),
772 for (
size_type i = 0; i < wr.size(); ++i)
779 svd_vt->values.data(),
795 template <
typename number>
799 const bool adding)
const
803 const number alpha = 1.;
804 const number beta = (adding ? 1. : 0.);
805 const number
null = 0.;
809 (mm == nn) && state ==
matrix)
816 const char diag =
'N';
817 const char trans =
'T';
828 &uplo, &trans, &diag, &
N, this->values.data(), &lda,
w.data(), &incx);
857 std::lock_guard<std::mutex> lock(mutex);
867 svd_u->values.data(),
875 for (
size_type i = 0; i < wr.size(); ++i)
882 svd_vt->values.data(),
893 std::lock_guard<std::mutex> lock(mutex);
903 svd_vt->values.data(),
911 for (
size_type i = 0; i < wr.size(); ++i)
918 svd_u->values.data(),
934 template <
typename number>
944 template <
typename number>
954 template <
typename number>
958 const bool adding)
const
969 const number alpha = 1.;
970 const number beta = (adding ? 1. : 0.);
989 template <
typename number>
993 const bool adding)
const
1003 const number alpha = 1.;
1004 const number beta = (adding ? 1. : 0.);
1016 this->values.data(),
1025 template <
typename number>
1030 const bool adding)
const
1052 std::lock_guard<std::mutex> lock(mutex);
1054 work.resize(kk * nn);
1063 work[j * kk + i] =
V(i) * B(i, j);
1067 const number alpha = 1.;
1068 const number beta = (adding ? 1. : 0.);
1076 this->values.data(),
1087 template <
typename number>
1096 #ifdef DEAL_II_LAPACK_WITH_MKL
1097 const number
one = 1.;
1108 template <
typename number>
1125 template <
typename number>
1129 const bool adding)
const
1140 const number alpha = 1.;
1141 const number beta = (adding ? 1. : 0.);
1150 this->values.data(),
1171 this->values.data(),
1183 template <
typename number>
1187 const bool adding)
const
1197 const number alpha = 1.;
1198 const number beta = (adding ? 1. : 0.);
1210 this->values.data(),
1219 template <
typename number>
1223 const bool adding)
const
1234 const number alpha = 1.;
1235 const number beta = (adding ? 1. : 0.);
1244 this->values.data(),
1265 this->values.data(),
1277 template <
typename number>
1281 const bool adding)
const
1291 const number alpha = 1.;
1292 const number beta = (adding ? 1. : 0.);
1304 this->values.data(),
1313 template <
typename number>
1317 const bool adding)
const
1328 const number alpha = 1.;
1329 const number beta = (adding ? 1. : 0.);
1337 this->values.data(),
1348 template <
typename number>
1352 const bool adding)
const
1362 const number alpha = 1.;
1363 const number beta = (adding ? 1. : 0.);
1375 this->values.data(),
1384 template <
typename number>
1393 number *
const values = this->values.data();
1408 template <
typename number>
1417 template <
typename number>
1421 const char type(
'O');
1427 template <
typename number>
1431 const char type(
'I');
1437 template <
typename number>
1441 const char type(
'F');
1447 template <
typename number>
1451 std::lock_guard<std::mutex> lock(mutex);
1455 ExcMessage(
"norms can be called in matrix state only."));
1459 const number *
const values = this->values.data();
1464 (type ==
'I' || type ==
'O') ? std::max<types::blas_int>(1,
N) : 0;
1472 (type ==
'I') ? std::max<types::blas_int>(1, M) : 0;
1474 return lange(&type, &M, &
N,
values, &lda, work.data());
1480 template <
typename number>
1486 ExcMessage(
"Trace can be called in matrix state only."));
1490 for (
size_type i = 0; i < this->m(); ++i)
1491 tr += (*
this)(i, i);
1498 template <
typename number>
1511 number *
const values = this->values.data();
1525 template <
typename number>
1529 std::lock_guard<std::mutex> lock(mutex);
1534 const number *
values = this->values.data();
1558 template <
typename number>
1562 std::lock_guard<std::mutex> lock(mutex);
1568 const number *
const values = this->values.data();
1574 const char norm =
'1';
1575 const char diag =
'N';
1596 template <
typename number>
1606 std::fill(wr.begin(), wr.end(), 0.);
1607 ipiv.resize(8 * mm);
1609 svd_u = std::make_unique<LAPACKFullMatrix<number>>(mm, mm);
1610 svd_vt = std::make_unique<LAPACKFullMatrix<number>>(nn, nn);
1618 std::vector<typename numbers::NumberTraits<number>::real_type> real_work;
1673 template <
typename number>
1683 const double lim = std::abs(wr[0]) * threshold;
1684 for (
size_type i = 0; i < wr.size(); ++i)
1686 if (std::abs(wr[i]) > lim)
1687 wr[i] =
one / wr[i];
1696 template <
typename number>
1699 const unsigned int kernel_size)
1707 const unsigned int n_wr = wr.size();
1708 for (
size_type i = 0; i < n_wr - kernel_size; ++i)
1709 wr[i] =
one / wr[i];
1710 for (
size_type i = n_wr - kernel_size; i < n_wr; ++i)
1717 template <
typename number>
1726 number *
const values = this->values.data();
1732 compute_lu_factorization();
1735 inv_work.resize(mm);
1736 getri(&mm,
values, &mm, ipiv.data(), inv_work.data(), &mm, &info);
1741 compute_cholesky_factorization();
1749 this->el(i, j) = this->el(j, i);
1760 template <
typename number>
1766 const char *trans = transposed ? &
T : &
N;
1768 const number *
const values = this->values.data();
1775 trans, &nn, &n_rhs,
values, &nn, ipiv.data(), v.
begin(), &nn, &info);
1789 &uplo, trans,
"N", &nn, &n_rhs,
values, &lda, v.
begin(), &ldb, &info);
1795 "The matrix has to be either factorized or triangular."));
1803 template <
typename number>
1806 const bool transposed)
const
1812 const char *trans = transposed ? &
T : &
N;
1814 const number *
const values = this->values.data();
1863 "The matrix has to be either factorized or triangular."));
1871 template <
typename number>
1895 for (
size_type i = 0; i < this->m(); ++i)
1897 (ipiv[i] ==
types::blas_int(i + 1) ? this->el(i, i) : -this->el(i, i));
1903 template <
typename number>
1918 const char jobvr = (right) ?
V :
N;
1919 const char jobvl = (left) ?
V :
N;
1933 std::vector<typename numbers::NumberTraits<number>::real_type> real_work;
1936 real_work.resize(2 * this->m());
1959 real_work.resize(lwork);
1982 " parameter had an illegal value."));
1989 "Lapack error in geev: the QR algorithm failed to compute "
1990 "all the eigenvalues, and no eigenvectors have been computed."));
2008 template <
typename RealNumber>
2010 unpack_lapack_eigenvector_and_increment_index(
2011 const std::vector<RealNumber> &vr,
2012 const std::complex<RealNumber> &eigenvalue,
2013 FullMatrix<std::complex<RealNumber>> &result,
2014 unsigned int &index)
2016 const std::size_t n = result.n();
2017 if (eigenvalue.imag() != 0.)
2019 for (std::size_t j = 0; j < n; ++j)
2021 result(j, index).real(vr[index * n + j]);
2022 result(j, index + 1).real(vr[index * n + j]);
2023 result(j, index).imag(vr[(index + 1) * n + j]);
2024 result(j, index + 1).imag(-vr[(index + 1) * n + j]);
2033 for (
unsigned int j = 0; j < n; ++j)
2034 result(j, index).real(vr[index * n + j]);
2043 template <
typename ComplexNumber>
2045 unpack_lapack_eigenvector_and_increment_index(
2046 const std::vector<ComplexNumber> &vr,
2047 const ComplexNumber &,
2049 unsigned int &index)
2051 const std::size_t n = result.
n();
2052 for (
unsigned int j = 0; j < n; ++j)
2053 result(j, index) = vr[
index * n + j];
2062 template <
typename number>
2067 Assert(vr.size() == this->n_rows() * this->n_cols(),
2068 ExcMessage(
"Right eigenvectors are not available! Did you "
2069 "set the associated flag in compute_eigenvalues()?"));
2074 for (
unsigned int i = 0; i < n();)
2075 unpack_lapack_eigenvector_and_increment_index(vr, eigenvalue(i), result, i);
2082 template <
typename number>
2087 Assert(vl.size() == this->n_rows() * this->n_cols(),
2088 ExcMessage(
"Left eigenvectors are not available! Did you "
2089 "set the associated flag in compute_eigenvalues()?"));
2094 for (
unsigned int i = 0; i < n();)
2095 unpack_lapack_eigenvector_and_increment_index(vl, eigenvalue(i), result, i);
2102 template <
typename number>
2106 const number upper_bound,
2107 const number abs_accuracy,
2118 number *
const values_A = this->values.data();
2119 number *
const values_eigenvectors = matrix_eigenvectors.
values.data();
2122 const char *
const jobz(&
V);
2123 const char *
const uplo(&
U);
2124 const char *
const range(&
V);
2126 std::vector<types::blas_int> iwork(
static_cast<size_type>(5 * nn));
2127 std::vector<types::blas_int> ifail(
static_cast<size_type>(nn));
2154 values_eigenvectors,
2167 work.resize(
static_cast<size_type>(lwork));
2183 values_eigenvectors,
2199 " parameter had an illegal value."));
2201 else if ((info > 0) && (info <= nn))
2206 " eigenvectors failed to converge."
2207 " (You may need to scale the abs_accuracy according"
2208 " to your matrix norm.)"));
2213 ExcMessage(
"Lapack error in syevx: unknown error."));
2219 for (
size_type i = 0; i < static_cast<size_type>(n_eigenpairs); ++i)
2223 for (
size_type j = 0; j < static_cast<size_type>(nn); ++j)
2225 eigenvectors(j, i) = values_eigenvectors[col_begin + j];
2234 template <
typename number>
2239 const number upper_bound,
2240 const number abs_accuracy,
2254 number *
const values_A = this->values.data();
2255 number *
const values_B = B.
values.data();
2256 number *
const values_eigenvectors = matrix_eigenvectors.
values.data();
2259 const char *
const jobz(&
V);
2260 const char *
const uplo(&
U);
2261 const char *
const range(&
V);
2263 iwork.resize(
static_cast<size_type>(5 * nn));
2264 std::vector<types::blas_int> ifail(
static_cast<size_type>(nn));
2294 values_eigenvectors,
2309 work.resize(
static_cast<size_type>(lwork));
2328 values_eigenvectors,
2344 " parameter had an illegal value."));
2346 else if ((info > 0) && (info <= nn))
2351 "Lapack error in sygvx: ssyevx/dsyevx failed to converge, and " +
2353 " eigenvectors failed to converge."
2354 " (You may need to scale the abs_accuracy"
2355 " according to the norms of matrices A and B.)"));
2357 else if ((info > nn) && (info <= 2 * nn))
2361 "Lapack error in sygvx: the leading minor of order " +
2363 " of matrix B is not positive-definite."
2364 " The factorization of B could not be completed and"
2365 " no eigenvalues or eigenvectors were computed."));
2370 ExcMessage(
"Lapack error in sygvx: unknown error."));
2376 for (
size_type i = 0; i < static_cast<size_type>(n_eigenpairs); ++i)
2381 for (
size_type j = 0; j < static_cast<size_type>(nn); ++j)
2383 eigenvectors[i](j) = values_eigenvectors[col_begin + j];
2392 template <
typename number>
2405 ExcMessage(
"eigenvectors.size() > matrix.n()"));
2411 number *
const values_A = this->values.data();
2412 number *
const values_B = B.
values.data();
2416 const char *
const jobz = (
eigenvectors.size() > 0) ? (&
V) : (&
N);
2417 const char *
const uplo = (&
U);
2450 work.resize(
static_cast<size_type>(lwork));
2474 " parameter had an illegal value."));
2476 else if ((info > 0) && (info <= nn))
2481 "Lapack error in sygv: ssyev/dsyev failed to converge, and " +
2483 " off-diagonal elements of an intermediate "
2484 " tridiagonal did not converge to zero."
2485 " (You may need to scale the abs_accuracy"
2486 " according to the norms of matrices A and B.)"));
2488 else if ((info > nn) && (info <= 2 * nn))
2492 "Lapack error in sygv: the leading minor of order " +
2494 " of matrix B is not positive-definite."
2495 " The factorization of B could not be completed and"
2496 " no eigenvalues or eigenvectors were computed."));
2501 ExcMessage(
"Lapack error in sygv: unknown error."));
2508 for (
size_type j = 0; j < static_cast<size_type>(nn); ++j)
2518 template <
typename number>
2521 const unsigned int precision,
2522 const bool scientific,
2523 const unsigned int width_,
2524 const char *zero_string,
2525 const double denominator,
2526 const double threshold,
2527 const char *separator)
const
2529 unsigned int width = width_;
2539 std::ios::fmtflags old_flags = out.flags();
2540 std::streamsize old_precision = out.precision(precision);
2544 out.setf(std::ios::scientific, std::ios::floatfield);
2546 width = precision + 7;
2550 out.setf(std::ios::fixed, std::ios::floatfield);
2552 width = precision + 2;
2555 for (
size_type i = 0; i < this->m(); ++i)
2563 out << std::setw(width) << (*this)(i, j) << separator;
2564 else if (std::abs(this->el(i, j)) > threshold)
2565 out << std::setw(width) << this->el(i, j) * denominator << separator;
2567 out << std::setw(width) << zero_string << separator;
2573 out.flags(old_flags);
2574 out.precision(old_precision);
2580 template <
typename number>
2589 template <
typename number>
2599 template <
typename number>
2605 matrix->solve(dst,
false);
2609 template <
typename number>
2615 matrix->solve(dst,
true);
2619 template <
typename number>
2627 matrix->solve(*aux,
false);
2632 template <
typename number>
2640 matrix->solve(*aux,
true);
2646 #include "lapack_full_matrix.inst"
void omatcopy(char, char, ::types::blas_int, ::types::blas_int, const number1, const number2 *, ::types::blas_int, number3 *, ::types::blas_int)
LAPACKFullMatrix< number > & operator*=(const number factor)
number reciprocal_condition_number() const
void Tmmult(LAPACKFullMatrix< number > &C, const LAPACKFullMatrix< number > &B, const bool adding=false) const
void scale_rows(const Vector< number > &V)
FullMatrix< std::complex< typename numbers::NumberTraits< number >::real_type > > get_right_eigenvectors() const
void add(const number a, const LAPACKFullMatrix< number > &B)
void Tvmult(Vector< number2 > &w, const Vector< number2 > &v, const bool adding=false) const
void transpose(LAPACKFullMatrix< number > &B) const
void mTmult(LAPACKFullMatrix< number > &C, const LAPACKFullMatrix< number > &B, const bool adding=false) const
void compute_eigenvalues_symmetric(const number lower_bound, const number upper_bound, const number abs_accuracy, Vector< number > &eigenvalues, FullMatrix< number > &eigenvectors)
void vmult(Vector< number2 > &w, const Vector< number2 > &v, const bool adding=false) const
void reinit(const size_type size)
void compute_cholesky_factorization()
LAPACKFullMatrix< number > & operator=(const LAPACKFullMatrix< number > &)
void compute_lu_factorization()
FullMatrix< std::complex< typename numbers::NumberTraits< number >::real_type > > get_left_eigenvectors() const
void grow_or_shrink(const size_type size)
void apply_givens_rotation(const std::array< number, 3 > &csr, const size_type i, const size_type k, const bool left=true)
void set_property(const LAPACKSupport::Property property)
number norm(const char type) const
void solve(Vector< number > &v, const bool transposed=false) const
void compute_eigenvalues(const bool right_eigenvectors=false, const bool left_eigenvectors=false)
LAPACKSupport::State state
std::make_unsigned_t< types::blas_int > size_type
number frobenius_norm() const
LAPACKFullMatrix(const size_type size=0)
LAPACKSupport::Property property
void compute_inverse_svd(const double threshold=0.)
void vmult_add(Vector< number2 > &w, const Vector< number2 > &v) const
number linfty_norm() const
void TmTmult(LAPACKFullMatrix< number > &C, const LAPACKFullMatrix< number > &B, const bool adding=false) const
void compute_generalized_eigenvalues_symmetric(LAPACKFullMatrix< number > &B, const number lower_bound, const number upper_bound, const number abs_accuracy, Vector< number > &eigenvalues, std::vector< Vector< number >> &eigenvectors, const types::blas_int itype=1)
void compute_inverse_svd_with_kernel(const unsigned int kernel_size)
void Tvmult_add(Vector< number2 > &w, const Vector< number2 > &v) const
void rank1_update(const number a, const Vector< number > &v)
void remove_row_and_column(const size_type row, const size_type col)
LAPACKFullMatrix< number > & operator/=(const number factor)
number determinant() const
void mmult(LAPACKFullMatrix< number > &C, const LAPACKFullMatrix< number > &B, const bool adding=false) 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 char *separator=" ") const
void vmult(Vector< number > &, const Vector< number > &) const
void initialize(const LAPACKFullMatrix< number > &)
void Tvmult(Vector< number > &, const Vector< number > &) const
number el(const size_type i, const size_type j) const
std::array< Number, 1 > eigenvalues(const SymmetricTensor< 2, 1, Number > &T)
std::array< std::pair< Number, Tensor< 1, dim, Number > >, std::integral_constant< int, dim >::value > eigenvectors(const SymmetricTensor< 2, dim, Number > &T, const SymmetricTensorEigenvectorMethod method=SymmetricTensorEigenvectorMethod::ql_implicit_shifts)
AlignedVector< T > values
typename AlignedVector< T >::size_type size_type
TableBase< N, T > & operator=(const TableBase< N, T > &src)
void reinit(const size_type size1, const size_type size2, const bool omit_default_initialization=false)
typename TableBase< 2, T >::size_type size_type
virtual size_type size() const override
VectorizedArray< Number, width > max(const ::VectorizedArray< Number, width > &x, const ::VectorizedArray< Number, width > &y)
VectorizedArray< Number, width > min(const ::VectorizedArray< Number, width > &x, const ::VectorizedArray< Number, width > &y)
#define DEAL_II_NAMESPACE_OPEN
#define DEAL_II_NAMESPACE_CLOSE
static ::ExceptionBase & ExcZero()
static ::ExceptionBase & ExcInternalError()
static ::ExceptionBase & ExcNotInitialized()
static ::ExceptionBase & ExcErrorCode(std::string arg1, types::blas_int arg2)
static ::ExceptionBase & ExcState(State arg1)
static ::ExceptionBase & ExcScalarAssignmentOnlyForZeroValue()
static ::ExceptionBase & ExcDimensionMismatch(std::size_t arg1, std::size_t arg2)
#define Assert(cond, exc)
static ::ExceptionBase & ExcProperty(Property arg1)
static ::ExceptionBase & ExcNotImplemented()
#define AssertIsFinite(number)
static ::ExceptionBase & ExcInvalidState()
#define AssertDimension(dim1, dim2)
static ::ExceptionBase & ExcSingular()
#define AssertIndexRange(index, range)
static ::ExceptionBase & ExcIO()
static ::ExceptionBase & ExcMessage(std::string arg1)
static ::ExceptionBase & ExcNotQuadratic()
#define AssertThrow(cond, exc)
void getrs(const char *, const ::types::blas_int *, const ::types::blas_int *, const number1 *, const ::types::blas_int *, const ::types::blas_int *, number2 *, const ::types::blas_int *, ::types::blas_int *)
void syrk(const char *, const char *, const ::types::blas_int *, const ::types::blas_int *, const number1 *, const number2 *, const ::types::blas_int *, const number3 *, number4 *, const ::types::blas_int *)
void geev(const char *, const char *, const ::types::blas_int *, number1 *, const ::types::blas_int *, number2 *, number3 *, number4 *, const ::types::blas_int *, number5 *, const ::types::blas_int *, number6 *, const ::types::blas_int *, ::types::blas_int *)
void gemm(const char *, const char *, const ::types::blas_int *, const ::types::blas_int *, const ::types::blas_int *, const number1 *, const number2 *, const ::types::blas_int *, const number3 *, const ::types::blas_int *, const number4 *, number5 *, const ::types::blas_int *)
void pocon(const char *, const ::types::blas_int *, const number1 *, const ::types::blas_int *, const number2 *, number3 *, number4 *, ::types::blas_int *, ::types::blas_int *)
void lascl(const char *, const ::types::blas_int *, const ::types::blas_int *, const number1 *, const number2 *, const ::types::blas_int *, const ::types::blas_int *, number3 *, const ::types::blas_int *, ::types::blas_int *)
void syr(const char *, const ::types::blas_int *, const number1 *, const number2 *, const ::types::blas_int *, number3 *, const ::types::blas_int *)
void trtrs(const char *, const char *, const char *, const ::types::blas_int *, const ::types::blas_int *, const number1 *, const ::types::blas_int *, number2 *, const ::types::blas_int *, ::types::blas_int *)
void syevx(const char *, const char *, const char *, const ::types::blas_int *, number1 *, const ::types::blas_int *, const number2 *, const number3 *, const ::types::blas_int *, const ::types::blas_int *, const number4 *, ::types::blas_int *, number5 *, number6 *, const ::types::blas_int *, number7 *, const ::types::blas_int *, ::types::blas_int *, ::types::blas_int *, ::types::blas_int *)
void trcon(const char *, const char *, const char *, const ::types::blas_int *, const number1 *, const ::types::blas_int *, number2 *, number3 *, ::types::blas_int *, ::types::blas_int *)
void gesdd(const char *, const ::types::blas_int *, const ::types::blas_int *, number1 *, const ::types::blas_int *, number2 *, number3 *, const ::types::blas_int *, number4 *, const ::types::blas_int *, number5 *, const ::types::blas_int *, ::types::blas_int *, ::types::blas_int *)
void axpy(const ::types::blas_int *, const number1 *, const number2 *, const ::types::blas_int *, number3 *, const ::types::blas_int *)
void trmv(const char *, const char *, const char *, const ::types::blas_int *, const number1 *, const ::types::blas_int *, number2 *, const ::types::blas_int *)
void sygvx(const ::types::blas_int *, const char *, const char *, const char *, const ::types::blas_int *, number1 *, const ::types::blas_int *, number2 *, const ::types::blas_int *, const number3 *, const number4 *, const ::types::blas_int *, const ::types::blas_int *, const number5 *, ::types::blas_int *, number6 *, number7 *, const ::types::blas_int *, number8 *, const ::types::blas_int *, ::types::blas_int *, ::types::blas_int *, ::types::blas_int *)
void gemv(const char *, const ::types::blas_int *, const ::types::blas_int *, const number1 *, const number2 *, const ::types::blas_int *, const number3 *, const ::types::blas_int *, const number4 *, number5 *, const ::types::blas_int *)
number1 lange(const char *, const ::types::blas_int *, const ::types::blas_int *, const number1 *, const ::types::blas_int *, number2 *)
void potrs(const char *, const ::types::blas_int *, const ::types::blas_int *, const number1 *, const ::types::blas_int *, number2 *, const ::types::blas_int *, ::types::blas_int *)
void sygv(const ::types::blas_int *, const char *, const char *, const ::types::blas_int *, number1 *, const ::types::blas_int *, number2 *, const ::types::blas_int *, number3 *, number4 *, const ::types::blas_int *, ::types::blas_int *)
void potri(const char *, const ::types::blas_int *, number1 *, const ::types::blas_int *, ::types::blas_int *)
number1 lansy(const char *, const char *, const ::types::blas_int *, const number1 *, const ::types::blas_int *, number2 *)
void potrf(const char *, const ::types::blas_int *, number1 *, const ::types::blas_int *, ::types::blas_int *)
void getrf(const ::types::blas_int *, const ::types::blas_int *, number1 *, const ::types::blas_int *, ::types::blas_int *, ::types::blas_int *)
void getri(const ::types::blas_int *, number1 *, const ::types::blas_int *, const ::types::blas_int *, number2 *, const ::types::blas_int *, ::types::blas_int *)
@ cholesky
Contents is a Cholesky decomposition.
@ lu
Contents is an LU decomposition.
@ matrix
Contents is actually a matrix.
@ unusable
Contents is something useless.
@ inverse_matrix
Contents is the inverse of a matrix.
@ svd
Matrix contains singular value decomposition,.
@ inverse_svd
Matrix is the inverse of a singular value decomposition.
@ eigenvalues
Eigenvalue vector is filled.
@ symmetric
Matrix is symmetric.
@ upper_triangular
Matrix is upper triangular.
@ lower_triangular
Matrix is lower triangular.
@ general
No special properties.
static const types::blas_int one
types::global_dof_index size_type
double norm(const FEValuesBase< dim > &fe, const ArrayView< const std::vector< Tensor< 1, dim >>> &Du)
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)
std::array< NumberType, 3 > givens_rotation(const NumberType &x, const NumberType &y)
std::array< NumberType, 3 > hyperbolic_rotation(const NumberType &x, const NumberType &y)
Iterator lower_bound(Iterator first, Iterator last, const T &val)
void gesdd_helper(const char job, const types::blas_int n_rows, const types::blas_int n_cols, AlignedVector< T > &matrix, std::vector< T > &singular_values, AlignedVector< T > &left_vectors, AlignedVector< T > &right_vectors, std::vector< T > &real_work, std::vector< T > &, std::vector< types::blas_int > &integer_work, const types::blas_int work_flag, types::blas_int &info)
void gesdd_helper(const char job, const types::blas_int n_rows, const types::blas_int n_cols, AlignedVector< std::complex< T >> &matrix, std::vector< T > &singular_values, AlignedVector< std::complex< T >> &left_vectors, AlignedVector< std::complex< T >> &right_vectors, std::vector< std::complex< T >> &work, std::vector< T > &real_work, std::vector< types::blas_int > &integer_work, const types::blas_int &work_flag, types::blas_int &info)
void geev_helper(const char vl, const char vr, AlignedVector< T > &matrix, const types::blas_int n_rows, std::vector< T > &real_part_eigenvalues, std::vector< T > &imag_part_eigenvalues, std::vector< T > &left_eigenvectors, std::vector< T > &right_eigenvectors, std::vector< T > &real_work, std::vector< T > &, const types::blas_int work_flag, types::blas_int &info)
void geev_helper(const char vl, const char vr, AlignedVector< std::complex< T >> &matrix, const types::blas_int n_rows, std::vector< T > &, std::vector< std::complex< T >> &eigenvalues, std::vector< std::complex< T >> &left_eigenvectors, std::vector< std::complex< T >> &right_eigenvectors, std::vector< std::complex< T >> &complex_work, std::vector< T > &real_work, const types::blas_int work_flag, types::blas_int &info)
void copy(const T *begin, const T *end, U *dest)
bool is_nan(const double x)
static bool equal(const T *p1, const T *p2)
static constexpr const number & conjugate(const number &x)