#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)

Detailed Description

template<typename T, typename U>
struct ProductType< T, U >

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:

T t;
U u;
auto product = t*u;

The local alias of this structure represents the type the variable product would have.

Where is this useful

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 \(U_j\) of unknowns in a Vector<float>, then evaluating \(u_h(x_q) = \sum_j U_j \varphi_j(x_q)\) at quadrature points results in values \(u_h(x_q)\) that need to be stored as double variables because the \(U_j\) are float values and the \(\varphi_j(x_q)\) are computed as double values, and the product are then double values. On the other hand, if you store your unknowns \(U_j\) as std::complex<double> values and you try to evaluate \(\nabla u_h(x_q) = \sum_j U_j \nabla\varphi_j(x_q)\) at quadrature points, then the gradients \(\nabla u_h(x_q)\) 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 \(U_j\) are stored as double variables, then \(u_h(x_q) = \sum_j U_j \varphi_j(x_q)\) needs to have type Tensor<1,dim> (because the shape functions have type Tensor<1,dim>). Finally, if you store the \(U_j\) as objects of type std::complex<double> and you have a vector valued element, then the gradients \(\nabla u_h(x_q) = \sum_j U_j \nabla\varphi_j(x_q)\) 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 484 of file template_constraints.h.