daFunk::FunkBase Class Reference

#include <daFunk.hpp>

Inheritance diagram for daFunk::FunkBase:

Collaboration diagram for daFunk::FunkBase:

Public Member Functions
	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 double	value (const std::vector< double > &, size_t bindID)=0
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 ()

Protected Attributes
std::vector< Funk >	functions
ArgsType	arguments
std::vector< std::vector< size_t > >	indices
size_t	datalen
Singularities	singularities

Private Member Functions
Funk	set_singularity (std::string arg, Funk pos, Funk width)
Funk	set_singularity (std::string arg, double pos, Funk width)
Funk	set_singularity (std::string arg, Funk pos, double width)

Detailed Description

Definition at line 298 of file daFunk.hpp.

Constructor & Destructor Documentation

FunkBase()

daFunk::FunkBase::FunkBase ( )

inline

Definition at line 301 of file daFunk.hpp.

{};

~FunkBase()

virtual daFunk::FunkBase::~FunkBase ( )

inlinevirtual

Definition at line 302 of file daFunk.hpp.

References find_all_gambit_bits::args, and g.

{};

Member Function Documentation

assert_args()

template<typename... Args>

bool daFunk::FunkBase::assert_args ( Args...  args )

inline

Definition at line 989 of file daFunk.hpp.

References find_all_gambit_bits::args.

    {
        std::vector<std::vector<std::string>> list = vec<std::vector<std::string>>(args...);
        std::set<std::string> myargs(arguments.begin(), arguments.end());
        for ( auto it = list.begin(); it != list.end(); ++it )
        {
            std::set<std::string> theirargs(it->begin(), it->end());
            if ( myargs == theirargs )
                return true;
        }
        return false;

    }

bind()

template<typename... Args>

shared_ptr< FunkBound > daFunk::FunkBase::bind ( Args...  args )

inline

Definition at line 1026 of file daFunk.hpp.

References daFunk::args_match(), daFunk::args_string(), daFunk::FunkBound::bindID_manager(), LOCAL_INFO, and Gambit::utils_error().

Referenced by daFunk::FunkBound::vect().

    {
        size_t bindID;
        FunkBound::bindID_manager(bindID,true);
        std::map<std::string, size_t> datamap;
        size_t i;
        auto bound_arguments = vec<std::string>(argss...);
        datalen = bound_arguments.size();
        i = 0;
        for ( auto it = bound_arguments.begin(); it != bound_arguments.end(); ++it, ++i )
        {
            datamap[*it] = i;
        }
        std::map<std::string,size_t> argmap;
        if ( not args_match(arguments, bound_arguments) )
        {
            std::string msg = "FunkBase::bind() tries to resolve wrong arguments.\n";
                        msg+= " --- Arguments that are supposed to be bound: " + args_string(bound_arguments) + "\n";
                        msg+= " --- Actual arguments of object: " + args_string(arguments);
#ifdef GAMBIT_DIR
            Gambit::utils_error().raise(LOCAL_INFO, msg);
#else
            throw std::invalid_argument(msg);
#endif
        }
        this->resolve(datamap, datalen, bindID, argmap);
        return shared_ptr<FunkBound>(new FunkBound(shared_from_this(), datalen, bindID));
    }

Here is the call graph for this function:

Here is the caller graph for this function:

getArgs()

const std::vector<std::string>& daFunk::FunkBase::getArgs ( )

inline

Definition at line 314 of file daFunk.hpp.

{ return this->arguments; };

getNArgs()

std::size_t daFunk::FunkBase::getNArgs ( )

inline

Definition at line 315 of file daFunk.hpp.

References find_all_gambit_bits::args, and find_all_gambit_bits::help.

{return this->arguments.size();};

getSingl()

Singularities daFunk::FunkBase::getSingl ( )

inline

Definition at line 334 of file daFunk.hpp.

References find_all_gambit_bits::args, and Gambit::ColliderBit::print().

{ return singularities; }

Here is the call graph for this function:

gsl_integration()

template<typename... Args>

shared_ptr< FunkIntegrate_gsl1d > daFunk::FunkBase::gsl_integration ( Args...  args )

inline

Definition at line 1065 of file daFunk.hpp.

References find_all_gambit_bits::args, and daFunk::getIntegrate_gsl1d().

    {
        return getIntegrate_gsl1d(shared_from_this(), args...);
    }

Here is the call graph for this function:

hasArg()

bool daFunk::FunkBase::hasArg ( std::string  arg )

inline

Definition at line 1055 of file daFunk.hpp.

    {
        return ( std::find(arguments.begin(), arguments.end(), arg) != arguments.end() );
    }

hasArgs()

bool daFunk::FunkBase::hasArgs ( )

inline

Definition at line 1060 of file daFunk.hpp.

    {
        return ( this->arguments.size() != 0 );
    }

help()

Funk daFunk::FunkBase::help ( )

inline

Definition at line 1070 of file daFunk.hpp.

    {
        std::cout << "Arguments:";
        for ( auto it = arguments.begin(); it != arguments.end(); it++ )
        {
            std::cout << " \"" << *it << "\"";
        }
        if ( arguments.size() == 0 )
            std::cout << " none";
        std::cout << std::endl;
        for ( auto it = singularities.begin() ; it != singularities.end(); ++it )
        {
            std::cout << "Singularities in " << it->first << ": " << it->second.size() << std::endl;
        }
        return shared_from_this();
    }

plain() [1/8]

PlainPtrs1 daFunk::FunkBase::plain ( std::string  arg1 )

inline

Definition at line 1087 of file daFunk.hpp.

References daFunk::FunkPlain::plain1p().

    {
        void* ptr = new FunkPlain(shared_from_this(), arg1);
        return PlainPtrs1(&FunkPlain::plain1p, ptr);
    }

Here is the call graph for this function:

plain() [2/8]

PlainPtrs2 daFunk::FunkBase::plain ( std::string  arg1, std::string  arg2  )

inline

Definition at line 1092 of file daFunk.hpp.

References daFunk::FunkPlain::plain2p().

    {
        void* ptr = new FunkPlain(shared_from_this(), arg1, arg2);
        return PlainPtrs2(&FunkPlain::plain2p, ptr);
    }

Here is the call graph for this function:

plain() [3/8]

PlainPtrs3 daFunk::FunkBase::plain ( std::string  arg1, std::string  arg2, std::string  arg3  )

inline

Definition at line 1097 of file daFunk.hpp.

References daFunk::FunkPlain::plain3p().

    {
        void* ptr = new FunkPlain(shared_from_this(), arg1, arg2, arg3);
        return PlainPtrs3(&FunkPlain::plain3p, ptr);
    }

Here is the call graph for this function:

plain() [4/8]

PlainPtrs4 daFunk::FunkBase::plain ( std::string  arg1, std::string  arg2, std::string  arg3, std::string  arg4  )

inline

Definition at line 1102 of file daFunk.hpp.

References daFunk::FunkPlain::plain4p().

    {
        void* ptr = new FunkPlain(shared_from_this(), arg1, arg2, arg3, arg4);
        return PlainPtrs4(&FunkPlain::plain4p, ptr);
    }

Here is the call graph for this function:

plain() [5/8]

template<typename T >

PlainPtr1 daFunk::FunkBase::plain ( std::string  arg1 )

inline

Definition at line 1109 of file daFunk.hpp.

    {
        T::set(new FunkPlain(shared_from_this(), arg1));
        return &FunkPlain::plain1<T>;
    }

plain() [6/8]

template<typename T >

PlainPtr2 daFunk::FunkBase::plain ( std::string  arg1, std::string  arg2  )

inline

Definition at line 1115 of file daFunk.hpp.

    {
        T::set(new FunkPlain(shared_from_this(), arg1, arg2));
        return &FunkPlain::plain2<T>;
    }

plain() [7/8]

template<typename T >

PlainPtr3 daFunk::FunkBase::plain ( std::string  arg1, std::string  arg2, std::string  arg3  )

inline

Definition at line 1121 of file daFunk.hpp.

    {
        T::set(new FunkPlain(shared_from_this(), arg1, arg2, arg3));
        return &FunkPlain::plain3<T>;
    }

plain() [8/8]

template<typename T >

PlainPtr4 daFunk::FunkBase::plain ( std::string  arg1, std::string  arg2, std::string  arg3, std::string  arg4  )

inline

Definition at line 1127 of file daFunk.hpp.

    {
        T::set(new FunkPlain(shared_from_this(), arg1, arg2, arg3, arg4));
        return &FunkPlain::plain4<T>;
    }

print()

Funk daFunk::FunkBase::print ( std::string  arg )

inline

Definition at line 1467 of file daFunk.hpp.

    { return Funk(new Bottle(shared_from_this(), msg)); };

resolve()

void daFunk::FunkBase::resolve ( std::map< std::string, size_t >  datamap, size_t &  datalen, size_t  bindID, std::map< std::string, size_t > &  argmap  )

inlinevirtual

Reimplemented in daFunk::FunkIntegrate_gsl1d, and daFunk::FunkDerived.

Definition at line 940 of file daFunk.hpp.

References daFunk::args_string(), LOCAL_INFO, and Gambit::utils_error().

    {
        // Resolve my dependencies
        auto it1 = arguments.begin();
        std::vector<size_t> tmp_indices;
        tmp_indices.resize(arguments.size());
        auto it2 = tmp_indices.begin();
        for (; it1 != arguments.end() && it2 != tmp_indices.end(); ++it1, ++it2 )
        {
            try
            {
                *it2 = datamap.at(*it1);
            }
            catch (std::out_of_range & e)
            {
                std::string msg = "FunkBase::resolve() encountered internal problem when resolving " + *it1 + ".\n";
                            msg+= " --- Actual arguments of object: " + args_string(arguments);
#ifdef GAMBIT_DIR
                Gambit::utils_error().raise(LOCAL_INFO, msg);
#else
                throw std::invalid_argument(msg);
#endif
            }
        }

        // Set indices
        if(indices.size() <= bindID)
        {
            indices.resize(bindID+1);
            // TODO: Throw error if problems are encountered
            //std::cout << "FATAL ERROR: bind() attempts to resolve dependencies of FunkBase" << std::endl;
            //std::cout << "object inconsistently." << std::endl;
            //std::cout << "Encountered while resolving: " << std::endl;
            //for (auto it = datamap.begin(); it != datamap.end(); it++)
            //{
            //    std::cout << "  " << it->first << std::endl;
            //}
            //exit(1);
        }
        indices[bindID] = tmp_indices;

        // Resolve other dependencies
        for (auto it = functions.begin(); it != functions.end(); ++it)
        {
            (*it)->resolve(datamap, datalen, bindID, argmap);
        }

    }

Here is the call graph for this function:

set() [1/5]

template<typename... Args>

Funk daFunk::FunkBase::set ( std::string  arg, Funk  g, Args...  args  )

inline

Definition at line 1003 of file daFunk.hpp.

References find_all_gambit_bits::args.

    {
        Funk f = shared_from_this();
        if ( std::find(arguments.begin(), arguments.end(), arg) != arguments.end() )
        {
            f = Funk(new FunkDerived(f, arg, g));
        }
        else
        {
            std::cout << "daFunk::FunkBase WARNING: Ignoring \"" << arg << "\" = function." << std::endl;
        }
        return f->set(args...);
    }

set() [2/5]

template<typename... Args>

Funk daFunk::FunkBase::set ( std::string  arg, double  x, Args...  args  )

inline

Definition at line 1020 of file daFunk.hpp.

References find_all_gambit_bits::args, and daFunk::cnst().

        { return shared_from_this()->set(arg, cnst(x))->set(args...); }

Here is the call graph for this function:

set() [3/5]

template<typename... Args>

Funk daFunk::FunkBase::set ( std::string  arg, std::string  arg1, Args...  args  )

inline

Definition at line 1017 of file daFunk.hpp.

References find_all_gambit_bits::args, and daFunk::var().

        { return shared_from_this()->set(arg, var(arg1))->set(args...); }

Here is the call graph for this function:

set() [4/5]

template<typename... Args>

Funk daFunk::FunkBase::set

(

)

set() [5/5]

template<>

Funk daFunk::FunkBase::set ( )

inline

Definition at line 1023 of file daFunk.hpp.

        { return shared_from_this(); }

set_singularity() [1/4]

Funk daFunk::FunkBase::set_singularity ( std::string  arg, Funk  pos, Funk  width  )

inlineprivate

Definition at line 928 of file daFunk.hpp.

    {
        singularities[arg].push_back(std::pair<Funk, Funk>(pos, width));
        return shared_from_this();
    };

set_singularity() [2/4]

Funk daFunk::FunkBase::set_singularity ( std::string  arg, double  pos, Funk  width  )

inlineprivate

Definition at line 933 of file daFunk.hpp.

References daFunk::cnst().

    { return shared_from_this()->set_singularity(arg, cnst(pos), width); }

Here is the call graph for this function:

set_singularity() [3/4]

Funk daFunk::FunkBase::set_singularity ( std::string  arg, Funk  pos, double  width  )

inlineprivate

Definition at line 937 of file daFunk.hpp.

References daFunk::cnst().

    { return shared_from_this()->set_singularity(arg, pos, cnst(width)); }

Here is the call graph for this function:

set_singularity() [4/4]

Funk daFunk::FunkBase::set_singularity ( std::string  arg, double  pos, double  width  )

inline

Definition at line 935 of file daFunk.hpp.

References daFunk::cnst().

    { return shared_from_this()->set_singularity(arg, cnst(pos), cnst(width)); }

Here is the call graph for this function:

value()

virtual double daFunk::FunkBase::value ( const std::vector< double > &  , size_t  bindID  )

pure virtual

Implemented in daFunk::FunkIntegrate_gsl1d, daFunk::Bottle, daFunk::ThrowError, daFunk::FunkIfElse, daFunk::FunkMath_umin, daFunk::FunkVar, daFunk::FunkDelta, daFunk::FunkFuncM< threadsafe, O, funcargs >, daFunk::FunkFunc< threadsafe, funcargs >, daFunk::FunkDerived, daFunk::FunkConst, and daFunk::FunkPlain.

Member Data Documentation

arguments

ArgsType daFunk::FunkBase::arguments

protected

Definition at line 369 of file daFunk.hpp.

datalen

size_t daFunk::FunkBase::datalen

protected

Definition at line 371 of file daFunk.hpp.

functions

std::vector<Funk> daFunk::FunkBase::functions

protected

Definition at line 368 of file daFunk.hpp.

Referenced by daFunk::FunkIntegrate_gsl1d::invoke().

indices

std::vector<std::vector<size_t> > daFunk::FunkBase::indices

protected

Definition at line 370 of file daFunk.hpp.

singularities

Singularities daFunk::FunkBase::singularities

protected

Definition at line 372 of file daFunk.hpp.

---

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

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