daFunk::FunkIntegrate_gsl1d Class Reference

#include <daFunk.hpp>

Inheritance diagram for daFunk::FunkIntegrate_gsl1d:

Collaboration diagram for daFunk::FunkIntegrate_gsl1d:

Public Member Functions
	FunkIntegrate_gsl1d (Funk f0, std::string arg, Funk f1, Funk f2)
	FunkIntegrate_gsl1d (Funk f0, std::string arg, double x, Funk f)
	FunkIntegrate_gsl1d (Funk f0, std::string arg, double x, double y)
	FunkIntegrate_gsl1d (Funk f0, std::string arg, Funk f, double x)
	FunkIntegrate_gsl1d (Funk f0, std::string arg, std::string x, Funk f)
	FunkIntegrate_gsl1d (Funk f0, std::string arg, std::string x, std::string y)
	FunkIntegrate_gsl1d (Funk f0, std::string arg, Funk f, std::string x)
	FunkIntegrate_gsl1d (Funk f0, std::string arg, std::string x, double y)
	FunkIntegrate_gsl1d (Funk f0, std::string arg, double y, std::string x)
void	resolve (std::map< std::string, size_t > datamap, size_t &datalen, size_t bindID, std::map< std::string, size_t > &argmap)
	~FunkIntegrate_gsl1d ()
shared_ptr< FunkIntegrate_gsl1d >	set_epsrel (double epsrel)
shared_ptr< FunkIntegrate_gsl1d >	set_epsabs (double epsabs)
shared_ptr< FunkIntegrate_gsl1d >	set_limit (size_t limit)
shared_ptr< FunkIntegrate_gsl1d >	set_singularity_factor (double f)
shared_ptr< FunkIntegrate_gsl1d >	set_use_log_fallback (bool flag)
double	value (const std::vector< double > &data, size_t bindID)
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)
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
void	setup (Funk f0, std::string arg, Funk f1, Funk f2)

Static Private Member Functions
static double	invoke (double x, void *params)

Private Attributes
std::vector< double >	local_data
size_t	local_bindID
std::vector< std::pair< Funk, Funk > >	my_singularities
std::string	arg
gsl_integration_workspace *	gsl_workspace
size_t	limit
std::vector< size_t >	index
double	epsrel
double	epsabs
bool	use_log_fallback
double	singl_factor

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

Definition at line 1475 of file daFunk.hpp.

Constructor & Destructor Documentation

FunkIntegrate_gsl1d() [1/9]

daFunk::FunkIntegrate_gsl1d::FunkIntegrate_gsl1d ( Funk  f0, std::string  arg, Funk  f1, Funk  f2  )

inline

Definition at line 1478 of file daFunk.hpp.

References Gambit::SpecBit::setup().

            {
                setup(f0, arg, f1, f2);
            }

Here is the call graph for this function:

FunkIntegrate_gsl1d() [2/9]

daFunk::FunkIntegrate_gsl1d::FunkIntegrate_gsl1d ( Funk  f0, std::string  arg, double  x, Funk  f  )

inline

Definition at line 1482 of file daFunk.hpp.

References daFunk::cnst(), and Gambit::SpecBit::setup().

            {
                setup(f0, arg, cnst(x), f);
            }

Here is the call graph for this function:

FunkIntegrate_gsl1d() [3/9]

daFunk::FunkIntegrate_gsl1d::FunkIntegrate_gsl1d ( Funk  f0, std::string  arg, double  x, double  y  )

inline

Definition at line 1486 of file daFunk.hpp.

References daFunk::cnst(), and Gambit::SpecBit::setup().

            {
                setup(f0, arg, cnst(x), cnst(y));
            }

Here is the call graph for this function:

FunkIntegrate_gsl1d() [4/9]

daFunk::FunkIntegrate_gsl1d::FunkIntegrate_gsl1d ( Funk  f0, std::string  arg, Funk  f, double  x  )

inline

Definition at line 1490 of file daFunk.hpp.

References daFunk::cnst(), and Gambit::SpecBit::setup().

            {
                setup(f0, arg, f, cnst(x));
            }

Here is the call graph for this function:

FunkIntegrate_gsl1d() [5/9]

daFunk::FunkIntegrate_gsl1d::FunkIntegrate_gsl1d ( Funk  f0, std::string  arg, std::string  x, Funk  f  )

inline

Definition at line 1494 of file daFunk.hpp.

References Gambit::SpecBit::setup(), and daFunk::var().

            {
                setup(f0, arg, var(x), f);
            }

Here is the call graph for this function:

FunkIntegrate_gsl1d() [6/9]

daFunk::FunkIntegrate_gsl1d::FunkIntegrate_gsl1d ( Funk  f0, std::string  arg, std::string  x, std::string  y  )

inline

Definition at line 1498 of file daFunk.hpp.

References Gambit::SpecBit::setup(), and daFunk::var().

            {
                setup(f0, arg, var(x), var(y));
            }

Here is the call graph for this function:

FunkIntegrate_gsl1d() [7/9]

daFunk::FunkIntegrate_gsl1d::FunkIntegrate_gsl1d ( Funk  f0, std::string  arg, Funk  f, std::string  x  )

inline

Definition at line 1502 of file daFunk.hpp.

References Gambit::SpecBit::setup(), and daFunk::var().

            {
                setup(f0, arg, f, var(x));
            }

Here is the call graph for this function:

FunkIntegrate_gsl1d() [8/9]

daFunk::FunkIntegrate_gsl1d::FunkIntegrate_gsl1d ( Funk  f0, std::string  arg, std::string  x, double  y  )

inline

Definition at line 1506 of file daFunk.hpp.

References daFunk::cnst(), Gambit::SpecBit::setup(), and daFunk::var().

            {
                setup(f0, arg, var(x), cnst(y));
            }

Here is the call graph for this function:

FunkIntegrate_gsl1d() [9/9]

daFunk::FunkIntegrate_gsl1d::FunkIntegrate_gsl1d ( Funk  f0, std::string  arg, double  y, std::string  x  )

inline

Definition at line 1510 of file daFunk.hpp.

References daFunk::cnst(), Gambit::SpecBit::setup(), and daFunk::var().

            {
                setup(f0, arg, cnst(y), var(x));
            }

Here is the call graph for this function:

~FunkIntegrate_gsl1d()

daFunk::FunkIntegrate_gsl1d::~FunkIntegrate_gsl1d ( )

inline

Definition at line 1560 of file daFunk.hpp.

            {
                gsl_integration_workspace_free(gsl_workspace);
            }

Member Function Documentation

invoke()

static double daFunk::FunkIntegrate_gsl1d::invoke ( double  x, void *  params  )

inlinestaticprivate

Definition at line 1681 of file daFunk.hpp.

References daFunk::FunkBase::functions, index, local_bindID, and local_data.

Referenced by value().

                                                         {
                FunkIntegrate_gsl1d * ptr = static_cast<FunkIntegrate_gsl1d*>(params);
                ptr->local_data[ptr->index[ptr->local_bindID]] = x;
                return ptr->functions[0]->value(ptr->local_data, ptr->local_bindID);
            }

Here is the caller graph for this function:

resolve()

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

inlinevirtual

Reimplemented from daFunk::FunkBase.

Definition at line 1515 of file daFunk.hpp.

References combine_hdf5::index.

            {
                functions[1]->resolve(datamap, datalen, bindID, argmap);  // Resolve boundary 0
                functions[2]->resolve(datamap, datalen, bindID, argmap);  // Resolve boundary 1

                // Set indices
                if(index.size() <= bindID)
                {
                    index.resize(bindID+1);
                    // TODO: Throw error if problems are encountered
                    //std::cout << "FATAL ERROR: bind() attempts to resolve dependencies of FunkIntegrate_gsl1d" << std::endl;
                    //std::cout << "object inconsistently." << std::endl;
                    //std::cout << "Encountered while resolving " << arg << " and:" << std::endl;
                    //for (auto it = datamap.begin(); it != datamap.end(); it++)
                    //{
                    //    std::cout << "  " << it->first << std::endl;
                    //}
                    //exit(1);
                }
                if ( argmap.find(arg) == argmap.end() )
                {
                    if(datamap.find(arg) == datamap.end())
                    {
                        index[bindID] = datalen;
                        argmap[arg]   = datalen;
                        ++datalen;
                    }
                    else
                    {
                        index[bindID] = datamap[arg];
                    }
                }
                else
                {
                    index[bindID] = argmap[arg];
                }
                datamap[arg]  = index[bindID];
                functions[0]->resolve(datamap, datalen, bindID, argmap);
                for ( auto it = my_singularities.begin(); it != my_singularities.end(); ++it )
                {
                    it->first->resolve(datamap, datalen, bindID, argmap);
                    it->second->resolve(datamap, datalen, bindID, argmap);
                }
            }

set_epsabs()

shared_ptr<FunkIntegrate_gsl1d> daFunk::FunkIntegrate_gsl1d::set_epsabs ( double  epsabs )

inline

Definition at line 1567 of file daFunk.hpp.

            { this->epsabs = epsabs; return static_pointer_cast<FunkIntegrate_gsl1d>(this->shared_from_this()); }

set_epsrel()

shared_ptr<FunkIntegrate_gsl1d> daFunk::FunkIntegrate_gsl1d::set_epsrel ( double  epsrel )

inline

Definition at line 1565 of file daFunk.hpp.

            { this->epsrel = epsrel; return static_pointer_cast<FunkIntegrate_gsl1d>(this->FunkIntegrate_gsl1d::shared_from_this()); }

set_limit()

shared_ptr<FunkIntegrate_gsl1d> daFunk::FunkIntegrate_gsl1d::set_limit ( size_t  limit )

inline

Definition at line 1569 of file daFunk.hpp.

            { this->limit = limit; return static_pointer_cast<FunkIntegrate_gsl1d>(this->shared_from_this()); }

set_singularity_factor()

shared_ptr<FunkIntegrate_gsl1d> daFunk::FunkIntegrate_gsl1d::set_singularity_factor ( double  f )

inline

Definition at line 1571 of file daFunk.hpp.

References f.

            { this->singl_factor = f; return static_pointer_cast<FunkIntegrate_gsl1d>(this->shared_from_this()); }

set_use_log_fallback()

shared_ptr<FunkIntegrate_gsl1d> daFunk::FunkIntegrate_gsl1d::set_use_log_fallback ( bool  flag )

inline

Definition at line 1573 of file daFunk.hpp.

            { this->use_log_fallback = flag; return static_pointer_cast<FunkIntegrate_gsl1d>(this->shared_from_this()); }

setup()

void daFunk::FunkIntegrate_gsl1d::setup ( Funk  f0, std::string  arg, Funk  f1, Funk  f2  )

inlineprivate

Definition at line 1658 of file daFunk.hpp.

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

            {
                this->functions = vec(f0, f1, f2);

                singularities = joinSingl(f1->getSingl(), f2->getSingl());
                if ( f0->getSingl().find(arg) != f0->getSingl().end() )
                    my_singularities = f0->getSingl()[arg];
                Singularities tmp_singl = f0->getSingl();
                tmp_singl.erase(arg);
                singularities = joinSingl(singularities, tmp_singl);

                arguments = joinArgs(eraseArg(f0->getArgs(), arg), joinArgs(f1->getArgs(), f2->getArgs()));
                gsl_workspace = gsl_integration_workspace_alloc (100000);

                this->arg = arg;
                limit = 100;
                epsrel = 1e-2;
                epsabs = 1e-2;
                use_log_fallback = false;
                singl_factor = 4;
            }

Here is the call graph for this function:

value()

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

inlinevirtual

Implements daFunk::FunkBase.

Definition at line 1576 of file daFunk.hpp.

References Gambit::GreAT::data, combine_hdf5::index, invoke(), daFunk::logspace(), generate_raster_scan_settings::N, and Gambit::DecayBit::SM_Z::sigma.

            {
                double result;
                #pragma omp critical(FunkIntegrate_gsl1d_integration)
                {
                    local_data = data;
                    local_bindID = bindID;
                    double error;
                    function=&FunkIntegrate_gsl1d::invoke;
                    params=this;
                    double x0 = functions[1]->value(data, bindID);
                    double x1 = functions[2]->value(data, bindID);
                    gsl_set_error_handler_off();
                    int status = 0;
                    if ( my_singularities.size() == 0 )
                    {
                        status = gsl_integration_qags(this, x0, x1, epsabs, epsrel, limit, gsl_workspace, &result, &error);
                    }
                    else
                    {
                        double s = 0;
                        std::vector<double> ranges;
                        ranges.push_back(x0);
                        ranges.push_back(x1);
                        for ( auto it = my_singularities.begin(); it != my_singularities.end(); ++it )
                        {
                            double mean = it->first->value(data, bindID);
                            double sigma = it->second->value(data, bindID);
                            double z0 = mean - singl_factor*sigma;
                            double z1 = mean + singl_factor*sigma;
                            if ( z0 == z1 )
                                std::cout << "daFunk::FunkBase WARNING: Singularity width is beyond machine precision." << std::endl;
                            if ( z0 > x0 and z0 < x1 ) ranges.push_back(z0);
                            if ( z1 > x0 and z1 < x1 ) ranges.push_back(z1);
                        }
                        std::sort(ranges.begin(), ranges.end());
                        for ( auto it = ranges.begin(); it != ranges.end()-1; ++it )
                        {
                            status = gsl_integration_qags(this, *it, *(it+1), epsabs, epsrel, limit, gsl_workspace, &result, &error);
                            s += result;
                            if (status) break;
                        }
                        result = s;
                    }
                    if (status and this->use_log_fallback)
                    {
                        // The last resort: A cheap integration on log grid, linear interpolation
                        const double N = 300;
                        std::vector<double> Xgrid = 
                            logspace(std::log10(x0), std::log10(x1), N);
                        double sum = 0, y0, y1, dx;
                        local_data[index[bindID]] = Xgrid[0];
                        y0 = functions[0]->value(local_data, bindID);
                        for (size_t i = 0; i<N-1; i++)
                        {
                            local_data[index[bindID]] = Xgrid[i+1];
                            y1 = functions[0]->value(local_data, bindID);
                            dx = Xgrid[i+1]-Xgrid[i];
                            sum += dx*(y0+y1)/2;
                            y0 = y1;
                        }
                        result = sum;
                    }
                    // TODO: Implement flags to optionally throw an error
                    if (status and not this->use_log_fallback)
                    {
                        std::cerr << "daFunk::FunkIntegrate_gsl1d WARNING: " << gsl_strerror(status) << std::endl;
                        std::cerr << "Attempt to integrate from " << x0 << " to " << x1 << std::endl;
                        std::cerr << "Attempt to integrate from " << x0 << " to " << x1 << std::endl;
                        std::cerr << "Details about the integrand:" << std::endl;
                        functions[0]->help();
//                        std::cout << "Dumping integrand:" << std::endl;
//                        for ( double x = x0; x <= x1; x = (x0>0) ? x*1.01 : x+(x1-x0)/1000)
//                            std::cerr << "  " << x << " " << invoke(x, this) << std::endl;
                        std::cerr << "Returning zero." << std::endl;
                        result = 0.;
                    }
                }
                return result;
            }

Here is the call graph for this function:

Member Data Documentation

arg

std::string daFunk::FunkIntegrate_gsl1d::arg

private

Definition at line 1693 of file daFunk.hpp.

epsabs

double daFunk::FunkIntegrate_gsl1d::epsabs

private

Definition at line 1700 of file daFunk.hpp.

epsrel

double daFunk::FunkIntegrate_gsl1d::epsrel

private

Definition at line 1699 of file daFunk.hpp.

gsl_workspace

gsl_integration_workspace* daFunk::FunkIntegrate_gsl1d::gsl_workspace

private

Definition at line 1696 of file daFunk.hpp.

index

std::vector<size_t> daFunk::FunkIntegrate_gsl1d::index

private

Definition at line 1698 of file daFunk.hpp.

Referenced by invoke().

limit

size_t daFunk::FunkIntegrate_gsl1d::limit

private

Definition at line 1697 of file daFunk.hpp.

local_bindID

size_t daFunk::FunkIntegrate_gsl1d::local_bindID

private

Definition at line 1689 of file daFunk.hpp.

Referenced by invoke().

local_data

std::vector<double> daFunk::FunkIntegrate_gsl1d::local_data

private

Definition at line 1688 of file daFunk.hpp.

Referenced by invoke().

my_singularities

std::vector<std::pair<Funk, Funk> > daFunk::FunkIntegrate_gsl1d::my_singularities

private

Definition at line 1690 of file daFunk.hpp.

singl_factor

double daFunk::FunkIntegrate_gsl1d::singl_factor

private

Definition at line 1703 of file daFunk.hpp.

use_log_fallback

bool daFunk::FunkIntegrate_gsl1d::use_log_fallback

private

Definition at line 1701 of file daFunk.hpp.

---

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

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