IgANet
IgANets - Isogeometric Analysis Networks
Loading...
Searching...
No Matches
Classes | Namespaces | Macros | Typedefs | Enumerations | Functions
functionspace.hpp File Reference

Function spaces. More...

#include <boost/preprocessor/seq/for_each.hpp>
#include <bspline.hpp>
#include <utils/container.hpp>
#include <utils/type_traits.hpp>
#include <utils/zip.hpp>

Go to the source code of this file.

Classes

class  iganet::detail::FunctionSpace< Spline, Boundary >
 Function space. More...
 
class  iganet::detail::FunctionSpace< std::tuple< Splines... >, std::tuple< Boundaries... > >
 Tensor-product function space. More...
 
struct  iganet::detail::FunctionSpace_trait< FunctionSpace< Spline, Boundary > >
 Function space. More...
 
struct  iganet::detail::FunctionSpace_trait< Spline >
 Function space with default boundary. More...
 
struct  iganet::detail::FunctionSpace_trait< Spline, Boundary >
 Function space with non-default boundary. More...
 
struct  iganet::detail::FunctionSpace_trait< std::tuple< FunctionSpace< Splines, Boundaries >... > >
 Tensor-product function space with default boundary. More...
 
struct  iganet::detail::FunctionSpace_trait< std::tuple< Splines... > >
 Tensor-product function space with default boundary. More...
 
struct  iganet::detail::FunctionSpace_trait< std::tuple< Splines... >, std::tuple< Boundaries... > >
 Tensor-product function space with non-default boundary. More...
 
class  iganet::Hcurl< Spline, 3 >
 H(curl) function space. More...
 
class  iganet::NE< Spline, 1 >
 Nedelec like function space. More...
 
class  iganet::NE< Spline, 2 >
 Nedelec like function space. More...
 
class  iganet::NE< Spline, 3 >
 Nedelec like function space. More...
 
class  iganet::NE< Spline, 4 >
 Nedelec like function space. More...
 
class  iganet::RT< Spline, 1 >
 Raviart-Thomas like function space. More...
 
class  iganet::RT< Spline, 2 >
 Raviart-Thomas like function space. More...
 
class  iganet::RT< Spline, 3 >
 Raviart-Thomas like function space. More...
 
class  iganet::RT< Spline, 4 >
 Raviart-Thomas like function space. More...
 
class  iganet::TH< Spline, 1 >
 Taylor-Hood like function space. More...
 
class  iganet::TH< Spline, 2 >
 Taylor-Hood like function space. More...
 
class  iganet::TH< Spline, 3 >
 Taylor-Hood like function space. More...
 
class  iganet::TH< Spline, 4 >
 Taylor-Hood like function space. More...
 

Namespaces

namespace  iganet
 
namespace  iganet::detail
 

Macros

#define GENERATE_EXPR_MACRO(r, data, name)
 
#define GENERATE_EXPR_MACRO(r, data, name)
 
#define GENERATE_IEXPR_MACRO(r, data, name)
 Auto-generated functions.
 
#define GENERATE_IEXPR_MACRO(r, data, name)
 Auto-generated functions.
 
#define IGANET_FUNCTIONSPACE_DEFAULT_OPS(FunctionSpace)
 Macro: Implements the default methods of a function space.
 

Typedefs

template<typename... Args>
using iganet::FunctionSpace = typename detail::FunctionSpace_trait< Args... >::type
 Function space alias.
 
template<typename Spline >
using iganet::S = FunctionSpace< Spline >
 Spline function space \( S^{\mathbf{p}}_{\mathbf{p}-1} \).
 

Enumerations

enum class  iganet::functionspace : short_t { iganet::interior = 0 , iganet::boundary = 1 }
 Enumerator for the function space component. More...
 

Functions

template<typename Splines , typename Boundaries >
std::ostream & iganet::operator<< (std::ostream &os, const FunctionSpace< Splines, Boundaries > &obj)
 Print (as string) a function space object.
 
template<typename... Splines>
std::ostream & iganet::detail::operator<< (std::ostream &os, const FunctionSpace< Splines... > &obj)
 Print (as string) a function space object.
 

Detailed Description

Function spaces.

Author
Matthias Moller
Copyright
This file is part of the IgANet project

This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.

Class Documentation

◆ iganet::detail::FunctionSpace_trait< FunctionSpace< Spline, Boundary > >

struct iganet::detail::FunctionSpace_trait< FunctionSpace< Spline, Boundary > >
template<typename Spline, typename Boundary>
struct iganet::detail::FunctionSpace_trait< FunctionSpace< Spline, Boundary > >

Function space.

Class Members
typedef typename type type

◆ iganet::detail::FunctionSpace_trait< Spline >

struct iganet::detail::FunctionSpace_trait< Spline >
template<typename Spline>
struct iganet::detail::FunctionSpace_trait< Spline >

Function space with default boundary.

Class Members
typedef FunctionSpace< Spline, Boundary< Spline > > type

◆ iganet::detail::FunctionSpace_trait< Spline, Boundary >

struct iganet::detail::FunctionSpace_trait< Spline, Boundary >
template<typename Spline, typename Boundary>
struct iganet::detail::FunctionSpace_trait< Spline, Boundary >

Function space with non-default boundary.

Class Members
typedef FunctionSpace< Spline, Boundary > type

◆ iganet::detail::FunctionSpace_trait< std::tuple< FunctionSpace< Splines, Boundaries >... > >

struct iganet::detail::FunctionSpace_trait< std::tuple< FunctionSpace< Splines, Boundaries >... > >
template<typename... Splines, typename... Boundaries>
struct iganet::detail::FunctionSpace_trait< std::tuple< FunctionSpace< Splines, Boundaries >... > >

Tensor-product function space with default boundary.

Class Members
typedef typename FunctionSpace_trait< tuple_cat_t< Splines... >, tuple_cat_t< Boundaries... > >::type type

◆ iganet::detail::FunctionSpace_trait< std::tuple< Splines... > >

struct iganet::detail::FunctionSpace_trait< std::tuple< Splines... > >
template<typename... Splines>
struct iganet::detail::FunctionSpace_trait< std::tuple< Splines... > >

Tensor-product function space with default boundary.

Class Members
typedef FunctionSpace< tuple_cat_t< Splines... >, tuple_cat_t< Boundary< Splines >... > > type

◆ iganet::detail::FunctionSpace_trait< std::tuple< Splines... >, std::tuple< Boundaries... > >

struct iganet::detail::FunctionSpace_trait< std::tuple< Splines... >, std::tuple< Boundaries... > >
template<typename... Splines, typename... Boundaries>
struct iganet::detail::FunctionSpace_trait< std::tuple< Splines... >, std::tuple< Boundaries... > >

Tensor-product function space with non-default boundary.

Class Members
typedef FunctionSpace< tuple_cat_t< Splines... >, tuple_cat_t< Boundaries... > > type

Macro Definition Documentation

◆ GENERATE_EXPR_MACRO [1/2]

#define GENERATE_EXPR_MACRO (   r,
  data,
  name 
)
Value:
private: \
template <functionspace comp = functionspace::interior, \
bool memory_optimized = false, std::size_t... Is, typename... Xi> \
inline auto BOOST_PP_CAT(name, _all_)(std::index_sequence<Is...>, \
const std::tuple<Xi...> &xi) const { \
if constexpr (comp == functionspace::interior) \
return std::tuple(std::get<Is>(spline_).template name<memory_optimized>( \
std::get<Is>(xi))...); \
else if constexpr (comp == functionspace::boundary) \
return std::tuple( \
std::get<Is>(boundary_).template name<memory_optimized>( \
std::get<Is>(xi))...); \
} \
\
template <functionspace comp = functionspace::interior, \
bool memory_optimized = false, std::size_t... Is, typename... Xi, \
typename... Knot_Indices> \
inline auto BOOST_PP_CAT(name, _all_)( \
std::index_sequence<Is...>, const std::tuple<Xi...> &xi, \
const std::tuple<Knot_Indices...> &knot_indices) const { \
if constexpr (comp == functionspace::interior) \
return std::tuple(std::get<Is>(spline_).template name<memory_optimized>( \
std::get<Is>(xi), std::get<Is>(knot_indices))...); \
else if constexpr (comp == functionspace::boundary) \
return std::tuple( \
std::get<Is>(boundary_).template name<memory_optimized>( \
std::get<Is>(xi), std::get<Is>(knot_indices))...); \
} \
\
template <functionspace comp = functionspace::interior, \
bool memory_optimized = false, std::size_t... Is, typename... Xi, \
typename... Knot_Indices, typename... Coeff_Indices> \
inline auto BOOST_PP_CAT(name, _all_)( \
std::index_sequence<Is...>, const std::tuple<Xi...> &xi, \
const std::tuple<Knot_Indices...> &knot_indices, \
const std::tuple<Coeff_Indices...> &coeff_indices) const { \
if constexpr (comp == functionspace::interior) \
return std::tuple(std::get<Is>(spline_).template name<memory_optimized>( \
std::get<Is>(xi), std::get<Is>(knot_indices), \
std::get<Is>(coeff_indices))...); \
else if constexpr (comp == functionspace::boundary) \
return std::tuple( \
std::get<Is>(boundary_).template name<memory_optimized>( \
std::get<Is>(xi), std::get<Is>(knot_indices), \
std::get<Is>(coeff_indices))...); \
} \
\
template <functionspace comp = functionspace::interior, \
bool memory_optimized = false, std::size_t... Is, std::size_t N> \
inline auto BOOST_PP_CAT(name, _)(std::index_sequence<Is...>, \
const utils::TensorArray<N> &xi) const { \
if constexpr (comp == functionspace::interior) \
return name<comp, memory_optimized>( \
xi, std::tuple(std::get<Is>(spline_).find_knot_indices(xi)...)); \
else if constexpr (comp == functionspace::boundary) \
return name<comp, memory_optimized>( \
xi, std::tuple(std::get<Is>(boundary_).find_knot_indices(xi)...)); \
} \
\
template <functionspace comp = functionspace::interior, \
bool memory_optimized = false, std::size_t... Is, std::size_t N, \
typename... Knot_Indices> \
inline auto BOOST_PP_CAT(name, _)( \
std::index_sequence<Is...>, const utils::TensorArray<N> &xi, \
const std::tuple<Knot_Indices...> &knot_indices) const { \
if constexpr (comp == functionspace::interior) \
return name<comp, memory_optimized>( \
xi, knot_indices, \
std::tuple(std::get<Is>(spline_).find_coeff_indices( \
std::get<Is>(knot_indices))...)); \
else if constexpr (comp == functionspace::boundary) \
return name<comp, memory_optimized>( \
xi, knot_indices, \
std::tuple(std::get<Is>(boundary_).find_coeff_indices( \
std::get<Is>(knot_indices))...)); \
} \
\
public: \
template <functionspace comp = functionspace::interior, \
bool memory_optimized = false, typename... Args> \
inline auto BOOST_PP_CAT(name, _all)(const Args &...args) const { \
return BOOST_PP_CAT(name, _all_)<comp, memory_optimized>( \
std::make_index_sequence<FunctionSpace::nspaces()>{}, args...); \
} \
\
template <functionspace comp = functionspace::interior, \
bool memory_optimized = false> \
inline auto name(const torch::Tensor &xi) const { \
return name<comp, memory_optimized>(utils::TensorArray1({xi})); \
} \
\
template <functionspace comp = functionspace::interior, \
bool memory_optimized = false, std::size_t N> \
inline auto name(const utils::TensorArray<N> &xi) const { \
return BOOST_PP_CAT(name, _)<comp, memory_optimized>( \
std::make_index_sequence<FunctionSpace::nspaces()>{}, xi); \
} \
\
template <functionspace comp = functionspace::interior, \
bool memory_optimized = false, std::size_t N, \
typename... Knot_Indices> \
inline auto name(const utils::TensorArray<N> &xi, \
const std::tuple<Knot_Indices...> &knot_indices) const { \
return BOOST_PP_CAT(name, _)<comp, memory_optimized>( \
std::make_index_sequence<FunctionSpace::nspaces()>{}, xi, \
knot_indices); \
}
iganet::functionspace
functionspace
Enumerator for the function space component.
Definition functionspace.hpp:30

◆ GENERATE_EXPR_MACRO [2/2]

#define GENERATE_EXPR_MACRO (   r,
  data,
  name 
)
Value:
private: \
template <functionspace comp = functionspace::interior, \
bool memory_optimized = false, std::size_t... Is, typename... Xi> \
inline auto BOOST_PP_CAT(name, _all_)(std::index_sequence<Is...>, \
const std::tuple<Xi...> &xi) const { \
if constexpr (comp == functionspace::interior) \
return std::tuple( \
spline_.template name<memory_optimized>(std::get<Is>(xi))...); \
else if constexpr (comp == functionspace::boundary) \
return std::tuple( \
boundary_.template name<memory_optimized>(std::get<Is>(xi))...); \
} \
\
template <functionspace comp = functionspace::interior, \
bool memory_optimized = false, std::size_t... Is, typename... Xi, \
typename... Knot_Indices> \
inline auto BOOST_PP_CAT(name, _all_)( \
std::index_sequence<Is...>, const std::tuple<Xi...> &xi, \
const std::tuple<Knot_Indices...> &knot_indices) const { \
if constexpr (comp == functionspace::interior) \
return std::tuple(spline_.template name<memory_optimized>( \
std::get<Is>(xi), std::get<Is>(knot_indices))...); \
else if constexpr (comp == functionspace::boundary) \
return std::tuple(boundary_.template name<memory_optimized>( \
std::get<Is>(xi), std::get<Is>(knot_indices))...); \
} \
\
template <functionspace comp = functionspace::interior, \
bool memory_optimized = false, std::size_t... Is, typename... Xi, \
typename... Knot_Indices, typename... Coeff_Indices> \
inline auto BOOST_PP_CAT(name, _all_)( \
std::index_sequence<Is...>, const std::tuple<Xi...> &xi, \
const std::tuple<Knot_Indices...> &knot_indices, \
const std::tuple<Coeff_Indices...> &coeff_indices) const { \
if constexpr (comp == functionspace::interior) \
return std::tuple(spline_.template name<memory_optimized>( \
std::get<Is>(xi), std::get<Is>(knot_indices), \
std::get<Is>(coeff_indices))...); \
else if constexpr (comp == functionspace::boundary) \
return std::tuple(boundary_.template name<memory_optimized>( \
std::get<Is>(xi), std::get<Is>(knot_indices), \
std::get<Is>(coeff_indices))...); \
} \
\
public: \
template <functionspace comp = functionspace::interior, \
bool memory_optimized = false, typename Arg, typename... Args> \
inline auto name(const Arg &arg, const Args &...args) const { \
if constexpr (comp == functionspace::interior) \
if constexpr (utils::is_tuple_v<Arg>) \
return BOOST_PP_CAT(name, _all_)<comp, memory_optimized>( \
std::make_index_sequence<std::tuple_size_v<Arg>>{}, arg, args...); \
else \
return spline_.template name<memory_optimized>(arg, args...); \
else if constexpr (comp == functionspace::boundary) { \
if constexpr (utils::is_tuple_of_tuples_v<Arg>) \
return BOOST_PP_CAT(name, _all_)<comp, memory_optimized>( \
std::make_index_sequence<std::tuple_size_v<Arg>>{}, arg, args...); \
else \
return boundary_.template name<memory_optimized>(arg, args...); \
} \
}

◆ GENERATE_IEXPR_MACRO [1/2]

#define GENERATE_IEXPR_MACRO (   r,
  data,
  name 
)
Value:
private: \
template <functionspace comp = functionspace::interior, \
bool memory_optimized = false, std::size_t... Is, \
typename Geometry, typename... Xi> \
inline auto BOOST_PP_CAT(name, _all_)(std::index_sequence<Is...>, \
const Geometry &G, \
const std::tuple<Xi...> &xi) const { \
if constexpr (comp == functionspace::interior) { \
if constexpr (Geometry::nspaces() == 1) \
return std::tuple( \
std::get<Is>(spline_).template name<memory_optimized>( \
G.space(), std::get<Is>(xi))...); \
else if constexpr (Geometry::nspaces() == nspaces()) \
return std::tuple( \
std::get<Is>(spline_).template name<memory_optimized>( \
G.template space<Is>(), std::get<Is>(xi))...); \
} else if constexpr (comp == functionspace::boundary) { \
if constexpr (Geometry::nboundaries() == 1) \
return std::tuple( \
std::get<Is>(boundary_).template name<memory_optimized>( \
static_cast<typename Geometry::boundary_type::boundary_type>( \
G.boundary().coeffs()), \
std::get<Is>(xi))...); \
else if constexpr (Geometry::nboundaries() == nboundaries()) \
return std::tuple( \
std::get<Is>(boundary_).template name<memory_optimized>( \
G.template boundary<Is>().coeffs(), std::get<Is>(xi))...); \
} \
} \
\
template <functionspace comp = functionspace::interior, \
bool memory_optimized = false, std::size_t... Is, \
typename Geometry, typename... Xi, typename... Knot_Indices, \
typename... Knot_Indices_G> \
inline auto BOOST_PP_CAT(name, _all_)( \
std::index_sequence<Is...>, const Geometry &G, \
const std::tuple<Xi...> &xi, \
const std::tuple<Knot_Indices...> &knot_indices, \
const std::tuple<Knot_Indices_G...> &knot_indices_G) const { \
if constexpr (comp == functionspace::interior) { \
if constexpr (Geometry::nspaces() == 1) \
return std::tuple( \
std::get<Is>(spline_).template name<memory_optimized>( \
G.space(), std::get<Is>(xi), std::get<Is>(knot_indices), \
std::get<Is>(knot_indices_G))...); \
else \
return std::tuple( \
std::get<Is>(spline_).template name<memory_optimized>( \
std::get<Is>(G), std::get<Is>(xi), std::get<Is>(knot_indices), \
std::get<Is>(knot_indices_G))...); \
} else if constexpr (comp == functionspace::boundary) { \
if constexpr (Geometry::nspaces() == 1) \
return std::tuple( \
std::get<Is>(boundary_).template name<memory_optimized>( \
static_cast<typename Geometry::boundary_type::boundary_type>( \
G.boundary().coeffs()), \
std::get<Is>(xi), std::get<Is>(knot_indices), \
std::get<Is>(knot_indices_G))...); \
else \
return std::tuple( \
std::get<Is>(boundary_).template name<memory_optimized>( \
std::get<Is>(G).boundary().coeffs(), std::get<Is>(xi), \
std::get<Is>(knot_indices), std::get<Is>(knot_indices_G))...); \
} \
} \
\
template <functionspace comp = functionspace::interior, \
bool memory_optimized = false, std::size_t... Is, \
typename Geometry, typename... Xi, typename... Knot_Indices, \
typename... Coeff_Indices, typename... Knot_Indices_G, \
typename... Coeff_Indices_G> \
inline auto BOOST_PP_CAT(name, _all_)( \
std::index_sequence<Is...>, const Geometry &G, \
const std::tuple<Xi...> &xi, \
const std::tuple<Knot_Indices...> &knot_indices, \
const std::tuple<Coeff_Indices...> &coeff_indices, \
const std::tuple<Knot_Indices_G...> &knot_indices_G, \
const std::tuple<Coeff_Indices_G...> &coeff_indices_G) const { \
if constexpr (comp == functionspace::interior) { \
if constexpr (Geometry::nspaces() == 1) \
return std::tuple( \
std::get<Is>(spline_).template name<memory_optimized>( \
G.space(), std::get<Is>(xi), std::get<Is>(knot_indices), \
std::get<Is>(coeff_indices), std::get<Is>(knot_indices_G), \
std::get<Is>(coeff_indices_G))...); \
else \
return std::tuple( \
std::get<Is>(spline_).template name<memory_optimized>( \
std::get<Is>(G), std::get<Is>(xi), std::get<Is>(knot_indices), \
std::get<Is>(coeff_indices), std::get<Is>(knot_indices_G), \
std::get<Is>(coeff_indices_G))...); \
} else if constexpr (comp == functionspace::boundary) { \
if constexpr (Geometry::nspaces() == 1) \
return std::tuple( \
std::get<Is>(boundary_).template name<memory_optimized>( \
static_cast<typename Geometry::boundary_type::boundary_type>( \
G.boundary().coeffs()), \
std::get<Is>(xi), std::get<Is>(knot_indices), \
std::get<Is>(coeff_indices), std::get<Is>(knot_indices_G), \
std::get<Is>(coeff_indices_G))...); \
else \
return std::tuple( \
std::get<Is>(boundary_).template name<memory_optimized>( \
std::get<Is>(G).boundary().coeffs(), std::get<Is>(xi), \
std::get<Is>(knot_indices), std::get<Is>(coeff_indices), \
std::get<Is>(knot_indices_G), \
std::get<Is>(coeff_indices_G))...); \
} \
} \
\
public: \
template <functionspace comp = functionspace::interior, \
bool memory_optimized = false, typename... Args> \
inline auto BOOST_PP_CAT(name, _all)(const Args &...args) const { \
return BOOST_PP_CAT(name, _all_)<comp, memory_optimized>( \
std::make_index_sequence<FunctionSpace::nspaces()>{}, args...); \
}

Auto-generated functions.

◆ GENERATE_IEXPR_MACRO [2/2]

#define GENERATE_IEXPR_MACRO (   r,
  data,
  name 
)
Value:
private: \
template <functionspace comp = functionspace::interior, \
bool memory_optimized = false, std::size_t... Is, \
typename Geometry, typename... Xi> \
inline auto BOOST_PP_CAT(name, _all_)(std::index_sequence<Is...>, \
const Geometry &G, \
const std::tuple<Xi...> &xi) const { \
if constexpr (comp == functionspace::interior) \
return std::tuple(spline_.template name<memory_optimized>( \
G.space(), std::get<Is>(xi))...); \
else if constexpr (comp == functionspace::boundary) \
return std::tuple(boundary_.template name<memory_optimized>( \
static_cast<typename Geometry::boundary_type::boundary_type>( \
G.boundary().coeffs()), \
std::get<Is>(xi))...); \
} \
\
template <functionspace comp = functionspace::interior, \
bool memory_optimized = false, std::size_t... Is, \
typename Geometry, typename... Xi, typename... Knot_Indices, \
typename... Knot_Indices_G> \
inline auto BOOST_PP_CAT(name, _all_)( \
std::index_sequence<Is...>, const Geometry &G, \
const std::tuple<Xi...> &xi, \
const std::tuple<Knot_Indices...> &knot_indices, \
const std::tuple<Knot_Indices_G...> &knot_indices_G) const { \
if constexpr (comp == functionspace::interior) \
return std::tuple(spline_.template name<memory_optimized>( \
G.space(), std::get<Is>(xi), std::get<Is>(knot_indices), \
std::get<Is>(knot_indices_G))...); \
else if constexpr (comp == functionspace::boundary) \
return std::tuple(boundary_.template name<memory_optimized>( \
static_cast<typename Geometry::boundary_type::boundary_type>( \
G.boundary().coeffs()), \
std::get<Is>(xi), std::get<Is>(knot_indices), \
std::get<Is>(knot_indices_G))...); \
} \
\
template <functionspace comp = functionspace::interior, \
bool memory_optimized = false, std::size_t... Is, \
typename Geometry, typename... Xi, typename... Knot_Indices, \
typename... Coeff_Indices, typename... Knot_Indices_G, \
typename... Coeff_Indices_G> \
inline auto BOOST_PP_CAT(name, _all_)( \
std::index_sequence<Is...>, const Geometry &G, \
const std::tuple<Xi...> &xi, \
const std::tuple<Knot_Indices...> &knot_indices, \
const std::tuple<Coeff_Indices...> &coeff_indices, \
const std::tuple<Knot_Indices_G...> &knot_indices_G, \
const std::tuple<Coeff_Indices_G...> &coeff_indices_G) const { \
if constexpr (comp == functionspace::interior) \
return std::tuple(spline_.template name<memory_optimized>( \
G.space(), std::get<Is>(xi), std::get<Is>(knot_indices), \
std::get<Is>(coeff_indices), std::get<Is>(knot_indices_G), \
std::get<Is>(coeff_indices_G))...); \
else if constexpr (comp == functionspace::boundary) \
return std::tuple(boundary_.template name<memory_optimized>( \
static_cast<typename Geometry::boundary_type::boundary_type>( \
G.boundary().coeffs()), \
std::get<Is>(xi), std::get<Is>(knot_indices), \
std::get<Is>(coeff_indices), std::get<Is>(knot_indices_G), \
std::get<Is>(coeff_indices_G))...); \
} \
\
public: \
template <functionspace comp = functionspace::interior, \
bool memory_optimized = false, typename Geometry, typename Arg, \
typename... Args> \
inline auto name(const Geometry &G, const Arg &arg, const Args &...args) \
const { \
if constexpr (comp == functionspace::interior) { \
if constexpr (utils::is_tuple_v<Arg>) \
return BOOST_PP_CAT(name, _all_)<comp, memory_optimized>( \
std::make_index_sequence<std::tuple_size_v<Arg>>{}, G, arg, \
args...); \
else \
return spline_.template name<memory_optimized>(G.space(), arg, \
args...); \
} else if constexpr (comp == functionspace::boundary) { \
if constexpr (utils::is_tuple_of_tuples_v<Arg>) \
return BOOST_PP_CAT(name, _all_)<comp, memory_optimized>( \
std::make_index_sequence<std::tuple_size_v<Arg>>{}, G, arg, \
args...); \
else \
return boundary_.template name<memory_optimized>( \
static_cast<typename Geometry::boundary_type::boundary_type>( \
G.boundary().coeffs()), \
arg, args...); \
} \
}

Auto-generated functions.

◆ IGANET_FUNCTIONSPACE_DEFAULT_OPS

#define IGANET_FUNCTIONSPACE_DEFAULT_OPS (   FunctionSpace)
Value:
FunctionSpace() = default; \
FunctionSpace(FunctionSpace &&) = default; \
FunctionSpace(const FunctionSpace &) = default;

Macro: Implements the default methods of a function space.