namespace Gambit::Scanner #

[No description available]

Namespaces #

Classes #

Types #

Functions #

Attributes #

Types Documentation #

typedef prior_interface #

typedef Priors::BasePrior Gambit::Scanner::prior_interface;

typedef multi_func_type #

typedef void * Gambit::Scanner::multi_func_type(const std::map< std::string, std::vector< std::string > > &, const std::vector< std::pair< std::string, std::string > > &);

typedef printer_interface #

typedef Printers::BasePrinterManager Gambit::Scanner::printer_interface;

typedef printer_interface_temp printer_interface;

typedef printer #

typedef Printers::BaseBasePrinter Gambit::Scanner::printer;

Type of the printer objects.

Functions Documentation #

function input_variadic_vector #

inline void input_variadic_vector(
    std::vector< void * > & 
)

Inputs a varibadic pack into a vector

function input_variadic_vector #

template <typename T ,
typename... args>
inline void input_variadic_vector(
    std::vector< void * > & input,
    const T & value,
    const args &... params
)

function scanner_plugin_def_ret #

template <typename ret >
std::enable_if<!std::is_floating_point< ret >::value, ret >::type scanner_plugin_def_ret()

Turns a type into an object. If it’s a floating point number, it replaces it with a big negative number.

function scanner_plugin_def_ret #

template <typename ret >
std::enable_if< std::is_floating_point< ret >::value, ret >::type scanner_plugin_def_ret()

function pow #

template <int i>
inline double pow(
    const double & a
)

Outputs a^i

function pow< 0 > #

inline double pow< 0 >(
    const double & 
)

function pow< 1 > #

inline double pow< 1 >(
    const double & a
)

function pow #

template <int i>
inline int pow(
    const int & a
)

function pow< 0 > #

inline int pow< 0 >(
    const int & 
)

function pow< 1 > #

inline int pow< 1 >(
    const int & a
)

function operator« #

template <typename T >
inline std::enable_if< is_container< T >::value, std::ostream & >::type operator<<(
    std::ostream & out,
    const T & in
)

Outputs containers to an output stream

function operator« #

template <typename T >
inline std::enable_if< is_pair< T >::value, std::ostream & >::type operator<<(
    std::ostream & out,
    const T & in
)

function resume_file_output #

template <typename T >
inline std::enable_if<!is_container< T >::value &&!is_pair< T >::value, void >::type resume_file_output(
    std::ofstream & out,
    T & param
)

Functions to output data for the plugin resume functions

function resume_file_output #

template <typename T >
inline std::enable_if< is_container< T >::value, void >::type resume_file_output(
    std::ofstream & out,
    T & param
)

function resume_file_output #

template <typename T >
inline std::enable_if< is_pair< T >::value, void >::type resume_file_output(
    std::ofstream & out,
    T & param
)

function resume_file_input #

template <typename T >
std::enable_if<!is_container< T >::value &&!is_pair< T >::value, void >::type resume_file_input(
    std::ifstream & in,
    T & param
)

function resume_file_input #

template <typename T >
inline std::enable_if< is_container< T >::value, void >::type resume_file_input(
    std::ifstream & in,
    T & param
)

function resume_file_input #

template <typename T >
inline std::enable_if< is_pair< T >::value, void >::type resume_file_input(
    std::ifstream & in,
    T & param
)

function resume_size_of #

template <typename T >
inline std::enable_if<!is_container< T >::value &&!is_pair< T >::value, size_t >::type resume_size_of(
    T & 
)

function resume_size_of #

template <typename T >
inline std::enable_if< is_container< T >::value, size_t >::type resume_size_of(
    T & param
)

function resume_size_of #

template <typename T >
inline std::enable_if< is_pair< T >::value, size_t >::type resume_size_of(
    T & 
)

function resume_file_input #

inline void resume_file_input(
    std::ifstream & in,
    std::string & param
)

function resume_file_output #

inline void resume_file_output(
    std::ofstream & out,
    std::string & param
)

function resume_size_of #

inline size_t resume_size_of(
    std::string & param
)

function LOAD_FUNC_TEMPLATE #

LOAD_FUNC_TEMPLATE(
    Scanner_Plugin_Function ,
    double(std::unordered_map< std::string, double > &) 
)

function LOAD_FUNC_TEMPLATE #

LOAD_FUNC_TEMPLATE(
    Scanner_Plugin_Function ,
    void(const std::vector< double > &, std::unordered_map< std::string, double > &) 
)

function LOAD_FUNC_TEMPLATE #

LOAD_FUNC_TEMPLATE(
    Scanner_Plugin_Function ,
    std::vector< double > std::unordered_map< std::string, double > &
)

function LOAD_MULTI_FUNC_TEMPLATE #

LOAD_MULTI_FUNC_TEMPLATE(
    Multi_Scanner_Plugin_Function ,
    double(std::unordered_map< std::string, double > &) 
)

function assign_aux_numbers #

inline void assign_aux_numbers()

function assign_aux_numbers #

template <typename... T>
inline void assign_aux_numbers(
    const std::string & tag,
    const T &... params
)

function scan_error #

EXPORT_SYMBOLS error & scan_error()

Scanner errors.

function scan_warning #

EXPORT_SYMBOLS warning & scan_warning()

Scanner warnings.

function zip #

template <typename... T>
inline auto zip(
    const T &... containers
)

Use for combine container in a range loop: for (auto &&x : zip(a, b)){…}.

function demangle #

inline std::string demangle(
    const std::string & in
)

Demangles gnu c++ name.

function get_yaml_vector #

template <typename T >
inline std::vector< T > get_yaml_vector(
    const YAML::Node & node
)

Input a vector from the yaml file of the following forms: vec: [a, b, …] vec: a, b, … vec: a; b; …

function StringToInt #

inline int StringToInt(
    const std::string & str
)

Converts a string to an int.

function IntToString #

inline std::string IntToString(
    const int & in
)

Converts a int into a string.

function pi #

inline double pi()

Output pi.

function convert_to_map #

inline std::map< std::string, std::vector< std::string > > convert_to_map(
    const std::vector< std::string > & vec
)

Turns a vector with enters [model::parameter, …] into a map with [{model, parameter}, …].

function register_ScannerBit_handlers #

int register_ScannerBit_handlers()

function notUnit #

inline bool notUnit(
    const std::vector< double > & in
)

function c_ptr #

template <typename T >
inline T::iterator::pointer c_ptr(
    T & it
)

function calcCov #

inline std::vector< std::vector< double > > calcCov(
    const std::vector< std::vector< double > > & pts
)

function calcIndent #

inline std::vector< std::vector< double > > calcIndent(
    const std::vector< std::vector< double > > & pts
)

function TWalk #

void TWalk(
    Gambit::Scanner::like_ptr LogLike,
    Gambit::Scanner::printer_interface & printer,
    Gambit::Scanner::resume_params_func set_resume_params,
    const int & dimension,
    const double & div,
    const int & proj,
    const double & din,
    const double & alim,
    const double & alimt,
    const long long & rand,
    const double & sqrtR,
    const int & NChains,
    const bool & hyper_grid,
    const int & burn_in,
    const int & save_freq,
    const double & hrs_max
)

function combineNodes #

inline YAML::Node combineNodes(
    const std::map< std::string, YAML::Node > & nodesMap,
    const YAML::Node & node
)

Attributes Documentation #

variable gambit_registry #

gambit_registry {
            typedef void* func_type(const std::vector<std::string> &, const std::string &);

variable functions #

std::unordered_map< type_index, func_type *, Gambit::type_hasher, Gambit::type_equal_to > __functions__;

variable multi_functions #

std::unordered_map< type_index, multi_func_type * > __multi_functions__;

variable ScannerBit_handlers #

int ScannerBit_handlers = register_ScannerBit_handlers();

Updated on 2023-06-26 at 21:36:52 +0000