daFunk::FunkFunc< threadsafe, funcargs > Class Template Reference

#include <daFunk.hpp>

Inheritance diagram for daFunk::FunkFunc< threadsafe, funcargs >:

Collaboration diagram for daFunk::FunkFunc< threadsafe, funcargs >:

Public Member Functions
template<typename... Args>
	FunkFunc (double(*f)(funcargs...), Args... argss)
double	value (const std::vector< double > &data, size_t bindID)
template<size_t... Args>
double	ppp (index_list< Args... >, std::tuple< typename std::remove_reference< funcargs >::type... > &my_input)
Public Member Functions inherited from daFunk::FunkBase
	FunkBase ()
virtual	~FunkBase ()
template<typename... Args>
Funk	set (std::string arg, Funk g, Args... args)
template<typename... Args>
Funk	set (std::string arg, double x, Args... args)
template<typename... Args>
Funk	set (std::string arg, std::string arg1, Args... args)
template<typename... Args>
Funk	set ()
template<typename... Args>
shared_ptr< FunkBound >	bind (Args... args)
const std::vector< std::string > &	getArgs ()
std::size_t	getNArgs ()
bool	hasArg (std::string)
bool	hasArgs ()
Funk	help ()
template<typename... Args>
bool	assert_args (Args... args)
virtual void	resolve (std::map< std::string, size_t > datamap, size_t &datalen, size_t bindID, std::map< std::string, size_t > &argmap)
Singularities	getSingl ()
Funk	set_singularity (std::string arg, double pos, double width)
Funk	print (std::string arg)
template<typename... Args>
shared_ptr< FunkIntegrate_gsl1d >	gsl_integration (Args... args)
PlainPtrs1	plain (std::string)
PlainPtrs2	plain (std::string, std::string)
PlainPtrs3	plain (std::string, std::string, std::string)
PlainPtrs4	plain (std::string, std::string, std::string, std::string)
template<typename T >
PlainPtr1	plain (std::string)
template<typename T >
PlainPtr2	plain (std::string, std::string)
template<typename T >
PlainPtr3	plain (std::string, std::string, std::string)
template<typename T >
PlainPtr4	plain (std::string, std::string, std::string, std::string)
template<>
Funk	set ()

Private Member Functions
template<typename T , typename... Args>
void	digest_input (T x, Args... argss)
template<typename... Args>
void	digest_input (Funk f, Args... argss)
void	digest_input ()

Private Attributes
std::tuple< typename std::remove_reference< funcargs >::type... >	input
std::vector< double * >	map
double(*	ptr )(funcargs...)

Additional Inherited Members
Protected Attributes inherited from daFunk::FunkBase
std::vector< Funk >	functions
ArgsType	arguments
std::vector< std::vector< size_t > >	indices
size_t	datalen
Singularities	singularities

Detailed Description

template<bool threadsafe, typename... funcargs>
class daFunk::FunkFunc< threadsafe, funcargs >

Definition at line 696 of file daFunk.hpp.

Constructor & Destructor Documentation

FunkFunc()

template<bool threadsafe, typename... funcargs>

template<typename... Args>

daFunk::FunkFunc< threadsafe, funcargs >::FunkFunc ( double(*)(funcargs...)  f, Args...  argss  )

inline

Definition at line 700 of file daFunk.hpp.

References f.

            {
                ptr = f;
                digest_input(argss...);
            }

Member Function Documentation

digest_input() [1/3]

template<bool threadsafe, typename... funcargs>

template<typename T , typename... Args>

void daFunk::FunkFunc< threadsafe, funcargs >::digest_input ( T  x, Args...  argss  )

inlineprivate

Definition at line 748 of file daFunk.hpp.

            {
                const int i = sizeof...(funcargs) - sizeof...(argss) - 1;
                std::get<i>(input) = x;
                digest_input(argss...);
            }

digest_input() [2/3]

template<bool threadsafe, typename... funcargs>

template<typename... Args>

void daFunk::FunkFunc< threadsafe, funcargs >::digest_input ( Funk  f, Args...  argss  )

inlineprivate

Definition at line 755 of file daFunk.hpp.

References daFunk::joinArgs(), and daFunk::joinSingl().

            {
                const int i = sizeof...(funcargs) - sizeof...(argss) - 1;
                map.push_back(&std::get<i>(input));
                arguments = joinArgs(arguments, f->getArgs());
                functions.push_back(f);
                singularities = joinSingl(singularities, f->getSingl());
                digest_input(argss...);
            }

Here is the call graph for this function:

digest_input() [3/3]

template<bool threadsafe, typename... funcargs>

void daFunk::FunkFunc< threadsafe, funcargs >::digest_input ( )

inlineprivate

Definition at line 764 of file daFunk.hpp.

{};

ppp()

template<bool threadsafe, typename... funcargs>

template<size_t... Args>

double daFunk::FunkFunc< threadsafe, funcargs >::ppp ( index_list< Args... >  , std::tuple< typename std::remove_reference< funcargs >::type... > &  my_input  )

inline

Definition at line 734 of file daFunk.hpp.

            {
                return (*ptr)(std::get<Args>(my_input)...);
            }

value()

template<bool threadsafe, typename... funcargs>

double daFunk::FunkFunc< threadsafe, funcargs >::value ( const std::vector< double > &  data, size_t  bindID  )

inlinevirtual

Implements daFunk::FunkBase.

Definition at line 706 of file daFunk.hpp.

References f.

            {
                std::tuple<typename std::remove_reference<funcargs>::type...> my_input;
                double result;
                size_t i = 0;
                #pragma omp critical (FunkFunc_setInput)
                {
                    for ( auto f = functions.begin(); f != functions.end(); ++f, ++i)
                    {
                        *map[i] = (*f)->value(data, bindID);
                    }
                    my_input = input;
                }
                if(threadsafe)
                {
                    result = ppp(typename detail::range_builder<0, sizeof...(funcargs)>::type(), my_input);
                }
                else
                {
                    #pragma omp critical (FunkFunc_externalFunctionCall)
                    {
                        result = ppp(typename detail::range_builder<0, sizeof...(funcargs)>::type(), my_input);
                    }
                }
                return result;
            }

Member Data Documentation

input

template<bool threadsafe, typename... funcargs>

std::tuple<typename std::remove_reference<funcargs>::type...> daFunk::FunkFunc< threadsafe, funcargs >::input

private

Definition at line 740 of file daFunk.hpp.

map

template<bool threadsafe, typename... funcargs>

std::vector<double*> daFunk::FunkFunc< threadsafe, funcargs >::map

private

Definition at line 741 of file daFunk.hpp.

ptr

template<bool threadsafe, typename... funcargs>

double(* daFunk::FunkFunc< threadsafe, funcargs >::ptr) (funcargs...)

private

Definition at line 742 of file daFunk.hpp.

---

The documentation for this class was generated from the following file:

• Elements/include/gambit/Elements/daFunk.hpp