Loading...
Searching...
No Matches
integrate.h
Go to the documentation of this file.
#ifndef _RHEO_INTEGRATE_H
#define _RHEO_INTEGRATE_H
//
// This file is part of Rheolef.
//
// Copyright (C) 2000-2009 Pierre Saramito <Pierre.Saramito@imag.fr>
//
// Rheolef is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Rheolef is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Rheolef; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// =========================================================================
namespace rheolef {
} // namespace rheolef
// Implementation note
// -------------------
// SUMMARY:
// 1. scalar-result integration
// 1.1. general integration of a nonlinear expression
// 1.2. measure of the domain
// 1.3. when the valued result type is undetermined
// 2. field-result integration of a variational expression
// 2.1. general call
// 2.2. missing domain
// 2.3. subdomain by its name
// 3. form-result integration of a variational expression
// 3.1. general call
// 3.2. missing domain
// 3.3. subdomain by its name
// 4. variational integration: on a band
// 5. lazy-field-result integration of a variational expression
// 5.1. general call
// 5.2. missing domain
// 5.3. subdomain by its name
// 6. lazy-form-result integration of a variational expression
// 6.1. general call
// 6.2. missing domain
// 6.3. subdomain by its name
//
#include "rheolef/field_expr.h"
#include "rheolef/field_expr_variational.h"
#include "rheolef/form_expr_variational.h"
#include "rheolef/field_expr_value_assembly.h"
#include "rheolef/field_vf_assembly.h"
#include "rheolef/form_vf_assembly.h"
#include "rheolef/form_expr_quadrature.h"
#include "rheolef/field_expr_quadrature.h"
#include "rheolef/form_lazy_expr.h"
#include "rheolef/functor.h" // used to convert functions to functors
namespace rheolef {
// ---------------------------------------------------
// 1. scalar-result integration
// ---------------------------------------------------
// 1.1. general integration of a nonlinear expression
// ---------------------------------------------------
template <class T, class M, class Expr,
class Result = typename details::field_expr_v2_nonlinear_terminal_wrapper_traits<Expr>::type::value_type>
inline
typename std::enable_if<
details::is_field_expr_v2_nonlinear_arg<Expr>::value
&& ! is_undeterminated<Result>::value,
Result
>::type
integrate (const geo_basic<T,M>& omega, const Expr& expr, const integrate_option& iopt,
Result dummy = Result())
{
typedef typename details::field_expr_v2_nonlinear_terminal_wrapper_traits<Expr>::type wrap_t;
if (omega.map_dimension() < omega.get_background_geo().map_dimension()) {
omega.get_background_geo().neighbour_guard();
}
Result result(0);
field_expr_v2_value_assembly (omega, wrap_t(expr), iopt, result);
return result;
}
// ---------------------------------------------------
// 1.2. measure of the domain
// ---------------------------------------------------
template <class T, class M>
T
integrate (const geo_basic<T,M>& omega, integrate_option&& iopt = integrate_option())
{
if (iopt.get_order() == std::numeric_limits<integrate_option::size_type>::max()) {
iopt.set_order(0);
}
details::f_constant <point_basic<T>,T> one(1);
return integrate (omega, one, iopt);
}
// ---------------------------------------------------
// 1.3. when the valued result type is undetermined
// ---------------------------------------------------
// TODO: return a overdetermined<T> value that is an union of all possibilities with a valued_tag
template<class T, class M, class Expr>
inline
typename std::enable_if<
details::is_field_expr_v2_nonlinear_arg<Expr>::value
&& is_undeterminated<typename details::field_expr_v2_nonlinear_terminal_wrapper_traits<Expr>::type::value_type>::value,
typename scalar_traits<typename details::field_expr_v2_nonlinear_terminal_wrapper_traits<Expr>::type::value_type>::type
>::type
integrate (const geo_basic<T,M>& omega, const Expr& expr, const integrate_option& iopt)
{
typedef typename details::field_expr_v2_nonlinear_terminal_wrapper_traits<Expr>::type::value_type undef_t;
typedef typename scalar_traits<undef_t>::type scalar_type;
switch (expr.valued_tag()) {
case space_constant::scalar: {
return integrate (omega, expr, iopt, scalar_type());
}
// others type: problem on how to return a run-type type ?
// TODO: return an overdetermined union type that convert to one of scalar, point, tensor, etc ?
default:
warning_macro ("Expr="<<pretty_typename_macro(Expr));
error_macro ("integrate: not yet for `"
<< space_constant::valued_name (expr.valued_tag())
<< "' valued expression");
return 0;
}
}
// -------------------------------------------------------
// 2. field-result integration of a variational expression
// -------------------------------------------------------
// 2.1. general call
// -------------------------------------------------------
template <class T, class M, class Expr>
inline
typename
std::enable_if<
details::is_field_expr_quadrature_arg<Expr>::value
,field_basic<T,M>
>::type
integrate (
const geo_basic<T,M>& domain,
const Expr& expr,
const integrate_option& iopt = integrate_option())
{
field_basic<T,M> lh;
lh.do_integrate (domain, expr, iopt);
return lh;
}
template <class T, class M, class Expr>
inline
typename
std::enable_if<
details::is_field_expr_v2_variational_arg<Expr>::value
,field_basic<T,M>
>::type
integrate (
const geo_basic<T,M>& domain,
const Expr& expr,
const integrate_option& fopt = integrate_option())
{
details::field_expr_quadrature_on_element<Expr> expr_quad(expr);
return integrate (domain, expr_quad, fopt);
}
// ----------------------------------------------
// 2.2. missing domain
// ----------------------------------------------
template <class Expr>
inline
typename
std::enable_if<
details::is_field_expr_quadrature_arg<Expr>::value
,field_basic <typename Expr::scalar_type, typename Expr::memory_type>
>::type
integrate (
const Expr& expr,
const integrate_option& iopt = integrate_option())
{
field_basic <typename Expr::scalar_type, typename Expr::memory_type> lh;
const geo_basic <typename Expr::scalar_type, typename Expr::memory_type>&
dom = expr.get_vf_space().get_constitution().get_geo();
lh.do_integrate (dom, expr, iopt);
return lh;
}
template <class Expr>
inline
typename
std::enable_if<
details::is_field_expr_v2_variational_arg<Expr>::value
,field_basic <typename Expr::scalar_type, typename Expr::memory_type>
>::type
integrate (
const Expr& expr,
const integrate_option& fopt = integrate_option())
{
details::field_expr_quadrature_on_element<Expr> expr_quad(expr);
return integrate (expr_quad, fopt);
}
// ----------------------------------------------
// 2.3. subdomain by its name
// ----------------------------------------------
template <class Expr>
inline
typename
std::enable_if<
details::is_field_expr_quadrature_arg<Expr>::value
,field_basic <typename Expr::scalar_type, typename Expr::memory_type>
>::type
integrate (
const std::string& domname,
const Expr& expr,
const integrate_option& iopt = integrate_option())
{
field_basic <typename Expr::scalar_type, typename Expr::memory_type> lh;
const geo_basic <typename Expr::scalar_type, typename Expr::memory_type>&
dom = expr.get_vf_space().get_constitution().get_geo() [domname];
lh.do_integrate (dom, expr, iopt);
return lh;
}
template <class Expr>
inline
typename
std::enable_if<
details::is_field_expr_v2_variational_arg<Expr>::value
,field_basic <typename Expr::scalar_type, typename Expr::memory_type>
>::type
integrate (
const std::string& domname,
const Expr& expr,
const integrate_option& fopt = integrate_option())
{
details::field_expr_quadrature_on_element<Expr> expr_quad(expr);
return integrate (domname, expr_quad, fopt);
}
// -------------------------------------------------------
// 3. form-result integration of a variational expression
// -------------------------------------------------------
// 3.1. general call
// -------------------------------------------------------
template <class T, class M, class Expr>
inline
typename
std::enable_if<
details::is_form_expr_quadrature_arg<Expr>::value
,form_basic <typename Expr::scalar_type, typename Expr::memory_type>
>::type
integrate (
const geo_basic<T,M>& domain,
const Expr& expr,
const integrate_option& fopt = integrate_option())
{
form_basic<T,M> a;
a.do_integrate (domain, expr, fopt);
return a;
}
template <class T, class M, class Expr>
inline
typename
std::enable_if<
details::is_form_expr_v2_variational_arg<Expr>::value
,form_basic <typename Expr::scalar_type, typename Expr::memory_type>
>::type
integrate (
const geo_basic<T,M>& domain,
const Expr& expr,
const integrate_option& fopt = integrate_option())
{
details::form_expr_quadrature_on_element<Expr> expr_quad(expr);
return integrate (domain, expr_quad, fopt);
}
// ----------------------------------------------
// 3.2. missing domain
// ----------------------------------------------
template <class Expr>
inline
typename
std::enable_if<
details::is_form_expr_quadrature_arg<Expr>::value
,form_basic <typename Expr::scalar_type, typename Expr::memory_type>
>::type
integrate (
const Expr& expr,
const integrate_option& fopt = integrate_option())
{
form_basic <typename Expr::scalar_type, typename Expr::memory_type> a;
geo_basic <typename Expr::scalar_type, typename Expr::memory_type>
dom_trial = expr.get_trial_space().get_constitution().get_geo(),
dom_test = expr.get_test_space().get_constitution().get_geo(),
dom;
// dom = intersection of trial & test domain definition
if (dom_trial.is_broken() && dom_test.is_broken() &&
expr.get_trial_space().get_constitution().is_hierarchical() &&
expr.get_test_space().get_constitution().is_hierarchical() ) {
dom = dom_test.get_background_geo();
} else if (dom_trial.name() == dom_test.name() ||
dom_trial.name() == dom_test.get_background_geo().name() ||
dom_trial.is_broken()) {
dom = dom_test;
} else if (dom_test.name() == dom_trial.get_background_geo().name() ||
dom_test.is_broken()) {
dom = dom_trial;
} else {
error_macro("integrate: incompatible domains: trial \""<<dom_trial.name()
<< "\" and \"" << dom_test.name() << "\"");
}
trace_macro ("dom_trial="<<dom_trial.name()<<" dom_test="<<dom_test.name()<<" -> dom="<<dom.name());
a.do_integrate (dom, expr, fopt);
return a;
}
template <class Expr>
inline
typename
std::enable_if<
details::is_form_expr_v2_variational_arg<Expr>::value
,form_basic <typename Expr::scalar_type, typename Expr::memory_type>
>::type
integrate (
const Expr& expr,
const integrate_option& fopt = integrate_option())
{
details::form_expr_quadrature_on_element<Expr> expr_quad(expr);
return integrate (expr_quad, fopt);
}
// ----------------------------------------------
// 3.3. subdomain by its name
// ----------------------------------------------
template <class Expr>
inline
typename
std::enable_if<
details::is_form_expr_quadrature_arg<Expr>::value
,form_basic <typename Expr::scalar_type, typename Expr::memory_type>
>::type
integrate (
const std::string& domname,
const Expr& expr,
const integrate_option& fopt = integrate_option())
{
form_basic <typename Expr::scalar_type, typename Expr::memory_type> a;
const geo_basic <typename Expr::scalar_type, typename Expr::memory_type>&
dom = expr.get_trial_space().get_constitution().get_background_geo()[domname];
a.do_integrate (dom, expr, fopt);
return a;
}
template <class Expr>
inline
typename
std::enable_if<
details::is_form_expr_v2_variational_arg<Expr>::value
,form_basic <typename Expr::scalar_type, typename Expr::memory_type>
>::type
integrate (
const std::string& domname,
const Expr& expr,
const integrate_option& fopt = integrate_option())
{
details::form_expr_quadrature_on_element<Expr> expr_quad(expr);
return integrate (domname, expr_quad, fopt);
}
// ----------------------------------------------
// 4. variational integration: on a band
// ----------------------------------------------
template <class T, class M, class Expr>
inline
typename
std::enable_if<
details::is_field_expr_quadrature_arg<Expr>::value
,field_basic <typename Expr::scalar_type, typename Expr::memory_type>
>::type
integrate (
const band_basic<T,M>& gh,
const Expr& expr,
const integrate_option& iopt = integrate_option())
{
field_basic <typename Expr::scalar_type, typename Expr::memory_type> lh;
lh.do_integrate (gh, expr, iopt);
return lh;
}
template <class T, class M, class Expr>
inline
typename
std::enable_if<
details::is_field_expr_v2_variational_arg<Expr>::value
,field_basic <typename Expr::scalar_type, typename Expr::memory_type>
>::type
integrate (
const band_basic<T,M>& gh,
const Expr& expr,
const integrate_option& iopt = integrate_option())
{
details::field_expr_quadrature_on_element<Expr> expr_quad(expr);
return integrate (gh, expr_quad, iopt);
}
template <class T, class M, class Expr>
inline
typename
std::enable_if<
details::is_form_expr_quadrature_arg<Expr>::value
,form_basic <typename Expr::scalar_type, typename Expr::memory_type>
>::type
integrate (
const band_basic<T,M>& gh,
const Expr& expr,
const integrate_option& fopt = integrate_option())
{
form_basic <typename Expr::scalar_type, typename Expr::memory_type> a;
a.do_integrate (gh, expr, fopt);
return a;
}
template <class T, class M, class Expr>
inline
typename
std::enable_if<
details::is_form_expr_v2_variational_arg<Expr>::value
,form_basic <typename Expr::scalar_type, typename Expr::memory_type>
>::type
integrate (
const band_basic<T,M>& gh,
const Expr& expr,
const integrate_option& fopt = integrate_option())
{
details::form_expr_quadrature_on_element<Expr> expr_quad(expr);
return integrate (gh, expr_quad, fopt);
}
#ifdef TO_CLEAN
// -------------------------------------------------------
// 5. field-result integration of a variational expression
// -------------------------------------------------------
// 5.1. general call
// -------------------------------------------------------
template <class Expr>
inline
typename
std::enable_if<
details::is_field_expr_quadrature_arg<Expr>::value
,details::field_lazy_terminal_integrate <Expr>
>::type
lazy_integrate (
const typename Expr::geo_type& domain,
const Expr& expr,
const integrate_option& iopt = integrate_option())
{
return details::field_lazy_terminal_integrate<Expr> (domain, expr, iopt);
}
template <class Expr>
inline
typename
std::enable_if<
details::is_field_expr_v2_variational_arg<Expr>::value
,details::field_lazy_terminal_integrate <details::field_expr_quadrature_on_element<Expr>>
>::type
lazy_integrate (
const geo_basic<typename Expr::scalar_type, typename Expr::memory_type>& domain,
const Expr& expr,
const integrate_option& iopt = integrate_option())
{
details::field_expr_quadrature_on_element<Expr> expr_quad(expr);
return lazy_integrate (domain, expr_quad, iopt);
}
// ----------------------------------------------
// 5.2. missing domain
// ----------------------------------------------
template <class Expr>
inline
typename
std::enable_if<
details::is_field_expr_quadrature_arg<Expr>::value
,details::field_lazy_terminal_integrate <Expr>
>::type
lazy_integrate (
const Expr& expr,
const integrate_option& fopt = integrate_option())
{
return details::field_lazy_terminal_integrate<Expr> (expr, iopt);
}
template <class Expr>
inline
typename
std::enable_if<
details::is_field_expr_v2_variational_arg<Expr>::value
,details::field_lazy_terminal_integrate <details::field_expr_quadrature_on_element<Expr>>
>::type
lazy_integrate (
const Expr& expr,
const integrate_option& fopt = integrate_option())
{
details::field_expr_quadrature_on_element<Expr> expr_quad(expr);
return lazy_integrate (expr_quad, fopt);
}
// ----------------------------------------------
// 5.3. subdomain by its name
// ----------------------------------------------
template <class Expr>
inline
typename
std::enable_if<
details::is_field_expr_quadrature_arg<Expr>::value
,details::field_lazy_terminal_integrate <Expr>
>::type
lazy_integrate (
const std::string& domname,
const Expr& expr,
const integrate_option& fopt = integrate_option())
{
return details::field_lazy_terminal_integrate<Expr> (domname, expr, iopt);
}
template <class Expr>
inline
typename
std::enable_if<
details::is_field_expr_v2_variational_arg<Expr>::value
,details::field_lazy_terminal_integrate <details::field_expr_quadrature_on_element<Expr>>
>::type
lazy_integrate (
const std::string& domname,
const Expr& expr,
const integrate_option& fopt = integrate_option())
{
details::field_expr_quadrature_on_element<Expr> expr_quad(expr);
return lazy_integrate (domname, expr_quad, fopt);
}
#endif // TO_CLEAN
// -------------------------------------------------------
// 6. lazy_form-result integration of a variational expression
// -------------------------------------------------------
// 6.1. general call
// -------------------------------------------------------
template <class Expr>
inline
typename
std::enable_if<
details::is_form_expr_quadrature_arg<Expr>::value
,details::form_lazy_terminal_integrate <Expr>
>::type
lazy_integrate (
const geo_basic<typename Expr::scalar_type, typename Expr::memory_type>& domain,
const Expr& expr,
const integrate_option& iopt = integrate_option())
{
return details::form_lazy_terminal_integrate<Expr> (domain, expr, iopt);
}
template <class Expr>
inline
typename
std::enable_if<
details::is_form_expr_v2_variational_arg<Expr>::value
,details::form_lazy_terminal_integrate <details::form_expr_quadrature_on_element<Expr>>
>::type
lazy_integrate (
const geo_basic<typename Expr::scalar_type, typename Expr::memory_type>& domain,
const Expr& expr,
const integrate_option& iopt = integrate_option())
{
details::form_expr_quadrature_on_element<Expr> expr_quad(expr);
return lazy_integrate (domain, expr_quad, iopt);
}
// ----------------------------------------------
// 6.2. missing domain
// ----------------------------------------------
template <class Expr>
inline
typename
std::enable_if<
details::is_form_expr_quadrature_arg<Expr>::value
,details::form_lazy_terminal_integrate <Expr>
>::type
lazy_integrate (
const Expr& expr,
const integrate_option& fopt = integrate_option())
{
// TODO: improve the automatic determination of the domain
// by an union that operates recrusively
constexpr bool has_on_local_sides = details::is_form_expr_quadrature_on_side_arg<Expr>::value;
geo_basic <typename Expr::scalar_type, typename Expr::memory_type>
dom_trial = expr.get_trial_space().get_constitution().get_geo(),
dom_test = expr. get_test_space().get_constitution().get_geo(),
dom;
// dom = intersection of trial & test domain definition
if (dom_trial.is_broken() && dom_test.is_broken() &&
expr.get_trial_space().get_constitution().is_hierarchical() &&
expr. get_test_space().get_constitution().is_hierarchical() ) {
dom = dom_test.get_background_geo();
} else if (dom_trial.name() == dom_test.name() ||
dom_trial.name() == dom_test.get_background_geo().name() ||
dom_trial.is_broken()) {
dom = has_on_local_sides ? dom_trial : dom_test;
} else if (dom_test.name() == dom_trial.get_background_geo().name() ||
dom_test.is_broken()) {
dom = has_on_local_sides ? dom_test : dom_trial;
} else {
error_macro("integrate: incompatible domains: trial \""<<dom_trial.name()
<< "\" and \"" << dom_test.name() << "\"");
}
trace_macro("Expr="<<pretty_typename_macro(Expr));
trace_macro ("space_trial="<<expr.get_trial_space().name()<<" space_test="<<expr. get_test_space().name());
trace_macro ("dom_trial="<<dom_trial.name()<<" dom_test="<<dom_test.name()<<" -> dom="<<dom.name());
return lazy_integrate (dom, expr, fopt);
}
template <class Expr>
inline
typename
std::enable_if<
details::is_form_expr_v2_variational_arg<Expr>::value
,details::form_lazy_terminal_integrate <details::form_expr_quadrature_on_element<Expr>>
>::type
lazy_integrate (
const Expr& expr,
const integrate_option& fopt = integrate_option())
{
details::form_expr_quadrature_on_element<Expr> expr_quad(expr);
return lazy_integrate (expr_quad, fopt);
}
// ----------------------------------------------
// 6.3. subdomain by its name
// ----------------------------------------------
template <class Expr>
inline
typename
std::enable_if<
details::is_form_expr_quadrature_arg<Expr>::value
,details::form_lazy_terminal_integrate <Expr>
>::type
lazy_integrate (
const std::string& domname,
const Expr& expr,
const integrate_option& fopt = integrate_option())
{
form_basic <typename Expr::scalar_type, typename Expr::memory_type> a;
const geo_basic <typename Expr::scalar_type, typename Expr::memory_type>&
dom = expr.get_trial_space().get_constitution().get_background_geo()[domname];
return lazy_integrate (dom, expr, fopt);
}
template <class Expr>
inline
typename
std::enable_if<
details::is_form_expr_v2_variational_arg<Expr>::value
,details::form_lazy_terminal_integrate <details::form_expr_quadrature_on_element<Expr>>
>::type
lazy_integrate (
const std::string& domname,
const Expr& expr,
const integrate_option& fopt = integrate_option())
{
details::form_expr_quadrature_on_element<Expr> expr_quad(expr);
return lazy_integrate (domname, expr_quad, fopt);
}
}// namespace rheolef
#endif // _RHEO_INTEGRATE_H
lh
field lh(Float epsilon, Float t, const test &v)
Definition burgers_diffusion_operators.icc:25
gh
field gh(Float epsilon, Float t, const field &uh, const test &v)
Definition burgers_diffusion_operators.icc:37
rheolef::band_basic
Definition band.h:95
rheolef::details::field_expr_quadrature_on_element
Definition field_expr_quadrature.h:67
rheolef::details::field_lazy_terminal_integrate
Definition field_lazy_terminal.h:519
rheolef::details::form_expr_quadrature_on_element
Definition form_expr_quadrature.h:113
rheolef::details::form_lazy_terminal_integrate
Definition form_lazy_terminal.h:176
rheolef::field_basic
Definition field.h:219
rheolef::form_basic
Definition form.h:146
rheolef::geo_basic
generic mesh with rerefence counting
Definition geo.h:1089
rheolef::integrate_option
see the integrate_option page for the full documentation
Definition integrate_option.h:125
rheolef::integrate_option::set_order
void set_order(size_t r)
Definition integrate_option.h:254
rheolef::integrate_option::get_order
size_t get_order() const
Definition integrate_option.h:242
rheolef::scalar_type
typename scalar_traits< value_type >::type scalar_type
Definition field_expr_recursive.h:542
trace_macro
#define trace_macro(message)
Definition dis_macros.h:111
error_macro
#define error_macro(message)
Definition dis_macros.h:49
warning_macro
#define warning_macro(message)
Definition dis_macros.h:53
T
Expr1::float_type T
Definition field_expr.h:230
rheolef::space_constant::scalar
@ scalar
Definition space_constant.h:134
rheolef::space_constant::valued_name
const std::string & valued_name(valued_type valued_tag)
Definition space_constant.cc:43
rheolef
This file is part of Rheolef.
Definition compiler_eigen.h:39
rheolef::integrate
std::enable_if< details::is_field_expr_v2_nonlinear_arg< Expr >::value &&!is_undeterminated< Result >::value, Result >::type integrate(const geo_basic< T, M > &omega, const Expr &expr, const integrate_option &iopt, Result dummy=Result())
see the integrate page for the full documentation
Definition integrate.h:211
rheolef::lazy_integrate
std::enable_if< details::is_field_expr_quadrature_arg< Expr >::value, details::field_lazy_terminal_integrate< Expr > >::type lazy_integrate(const typename Expr::geo_type &domain, const Expr &expr, const integrate_option &iopt=integrate_option())
see the integrate page for the full documentation
Definition field_lazy_terminal.h:588
rheolef::details::field_expr_v2_nonlinear_terminal_wrapper_traits
Definition field_expr_terminal.h:82
rheolef::details::field_expr_v2_nonlinear_terminal_wrapper_traits::type
Expr type
Definition field_expr_terminal.h:84
rheolef::details::is_field_expr_quadrature_arg
Definition field_expr_quadrature.h:55
rheolef::details::is_field_expr_v2_nonlinear_arg
Definition field_concept.h:88
rheolef::details::is_field_expr_v2_variational_arg
Definition field_expr_variational_terminal.h:52
rheolef::details::is_form_expr_quadrature_arg
Definition form_expr_quadrature.h:101
rheolef::details::is_form_expr_quadrature_on_side_arg
Definition form_expr_quadrature.h:102
rheolef::is_undeterminated
Definition undeterminated.h:39
rheolef::scalar_traits::type
T type
Definition point.h:323
M
Expr1::memory_type M
Definition vec_expr_v2.h:416