![]() |
Reference documentation for deal.II version 9.3.3
|
#include <deal.II/base/template_constraints.h>
Public Types | |
using | type = typename internal::ProductTypeImpl< typename std::decay< T >::type, typename std::decay< U >::type >::type |
Related Functions | |
(Note that these are not member functions.) | |
template<typename T , typename U > | |
std::enable_if< std::is_floating_point< T >::value &&std::is_floating_point< U >::value, typenameProductType< std::complex< T >, std::complex< U > >::type >::type | operator* (const std::complex< T > &left, const std::complex< U > &right) |
template<typename T , typename U > | |
std::enable_if< std::is_floating_point< T >::value &&std::is_floating_point< U >::value, typenameProductType< std::complex< T >, std::complex< U > >::type >::type | operator/ (const std::complex< T > &left, const std::complex< U > &right) |
template<typename T , typename U > | |
std::enable_if< std::is_floating_point< T >::value &&std::is_floating_point< U >::value, typenameProductType< std::complex< T >, U >::type >::type | operator* (const std::complex< T > &left, const U &right) |
template<typename T , typename U > | |
std::enable_if< std::is_floating_point< T >::value &&std::is_floating_point< U >::value, typenameProductType< std::complex< T >, U >::type >::type | operator/ (const std::complex< T > &left, const U &right) |
template<typename T , typename U > | |
std::enable_if< std::is_floating_point< T >::value &&std::is_floating_point< U >::value, typenameProductType< T, std::complex< U > >::type >::type | operator* (const T &left, const std::complex< U > &right) |
template<typename T , typename U > | |
std::enable_if< std::is_floating_point< T >::value &&std::is_floating_point< U >::value, typenameProductType< T, std::complex< U > >::type >::type | operator/ (const T &left, const std::complex< U > &right) |
A class with a local alias that represents the type that results from the product of two variables of type T
and U
. In other words, we would like to infer the type of the product
variable in code like this:
The local alias of this structure represents the type the variable product
would have.
The purpose of this class is principally to represent the type one needs to use to represent the values or gradients of finite element fields at quadrature points. For example, assume you are storing the values of unknowns in a Vector<float>, then evaluating
at quadrature points results in values
that need to be stored as
double
variables because the are
float
values and the are computed as
double
values, and the product are then double
values. On the other hand, if you store your unknowns as
std::complex<double>
values and you try to evaluate at quadrature points, then the gradients
need to be stored as objects of type
Tensor<1,dim,std::complex<double>>
because that's what you get when you multiply a complex number by a Tensor<1,dim>
(the type used to represent the gradient of shape functions of scalar finite elements).
Likewise, if you are using a vector valued element (with dim components) and the are stored as
double
variables, then needs to have type
Tensor<1,dim>
(because the shape functions have type Tensor<1,dim>
). Finally, if you store the as objects of type
std::complex<double>
and you have a vector valued element, then the gradients will result in objects of type
Tensor<2,dim,std::complex<double> >
.
In all of these cases, this type is used to identify which type needs to be used for the result of computing the product of unknowns and the values, gradients, or other properties of shape functions.
Definition at line 319 of file template_constraints.h.
using ProductType< T, U >::type = typename internal::ProductTypeImpl<typename std::decay<T>::type, typename std::decay<U>::type>::type |
Definition at line 321 of file template_constraints.h.
|
related |
Provide an operator*
that operates on mixed complex floating point types. Annoyingly, the standard library does not provide such an operator...
Definition at line 43 of file complex_overloads.h.
|
related |
Provide an operator/
that operates on mixed complex floating point types. Annoyingly, the standard library does not provide such an operator...
Definition at line 61 of file complex_overloads.h.
|
related |
Provide an operator*
for a scalar multiplication of a complex floating point type with a different real floating point type. Annoyingly, the standard library does not provide such an operator...
Definition at line 80 of file complex_overloads.h.
|
related |
Provide an operator/
for a scalar division of a complex floating point type with a different real floating point type. Annoyingly, the standard library does not provide such an operator...
Definition at line 98 of file complex_overloads.h.
|
related |
Provide an operator*
for a scalar multiplication of a real floating point type with a different complex floating point type. Annoyingly, the standard library does not provide such an operator...
Definition at line 117 of file complex_overloads.h.
|
related |
Provide an operator/
for a scalar division of a real floating point type with a different complex floating point type. Annoyingly, the standard library does not provide such an operator...
Definition at line 135 of file complex_overloads.h.