namespace Gambit::Utils #

[No description available]

Classes #

Types #

Functions #

Attributes #

Types Documentation #

typedef time_point #

typedef std::chrono::time_point< std::chrono::system_clock > Gambit::Utils::time_point;

Functions Documentation #

function hardmsg #

const std::string hardmsg(
    "Now calling abort (will produce a core file for analysis if this is enabled on your system; if so please include this with the bug report)" 
)

Members of FileLock class.

function typeEquivalencies #

type_equivalency & typeEquivalencies()

Backend info accessor function.

Type equivalency accessor function.

function fix_type #

str fix_type(
    str s
)

Clean out whitespace and strip Gambit and default BOSSed class namespaces.

function get_clock_now #

time_point get_clock_now()

Get clock time.

Get current system clock time.

function unwrap #

double unwrap(
    double x,
    void * p
)

Unwrapper for passing std::function to GSL integrator Based on example from https://martin-ueding.de/articles/cpp-lambda-into-gsl/index.html

function integrate_cquad #

double integrate_cquad(
    std::function< double(double)> ftor,
    double a,
    double b,
    double abseps,
    double releps
)

Integrate a std::function using GSL cquad.

function run_lnlike_modifier #

double run_lnlike_modifier(
    double lnlike,
    const str & lnlike_modifier_name,
    const Options & lnlike_modifier_options
)

Interface function that calls the correct modifier function based on the name in lnlike_modifier_name.

function lnlike_modifier_gaussian #

double lnlike_modifier_gaussian(
    double lnlike,
    const Options & lnlike_modifier_options
)

lnlike modifier: gaussian

function lnlike_modifier_gaussian_plateau #

double lnlike_modifier_gaussian_plateau(
    double lnlike,
    const Options & lnlike_modifier_options
)

lnlike modifier: gaussian_plateau

function getEnvVar #

std::string getEnvVar(
    std::string const & key
)

Get an environment variable, or "” if the variable is not set.

function GAMBIT_root_dir #

EXPORT_SYMBOLS const std::string & GAMBIT_root_dir()

Return the root directory of GAMBIT. Useful for locating configuration files and other such things in a robust manner at runtime Return the root directory of GAMBIT. Useful for locating configuration files and other such things in a robust manner

function buildtime_scratch #

EXPORT_SYMBOLS const std::string & buildtime_scratch()

Return the path to the build-time scratch directory.

Return the path to the build-time scratch directory bjf> There is stuff using this variable that is needed by ScannerBit at run time, not just build time, therefore it needs to be located using the function above

function runtime_scratch #

EXPORT_SYMBOLS const str & runtime_scratch()

Return the path to the run-specific scratch directory Don’t call this from a destructor, as the internal static str may have already been destroyed.

function p2dot #

EXPORT_SYMBOLS str p2dot(
    str s
)

Convert all instances of “p” in a string to “.”.

function construct_runtime_scratch #

EXPORT_SYMBOLS str construct_runtime_scratch(
    bool fail_on_mpi_uninitialised =true
)

Construct the path to the run-specific scratch directory This version is safe to call from a destructor.

function delimiterSplit #

EXPORT_SYMBOLS std::vector< str > delimiterSplit(
    str s,
    str delim
)

Split a string into a vector of strings, using a delimiter, and removing any whitespace around the delimiter.

Split a string into a vector of strings using a delimiter, and remove any whitespace around the delimiters.

function strip_leading_namespace #

EXPORT_SYMBOLS str strip_leading_namespace(
    str s,
    str ns
)

Strips namespace from the start of a string, or after “const”.

function replace_leading_namespace #

EXPORT_SYMBOLS str replace_leading_namespace(
    str s,
    str ns,
    str ns_new
)

Replaces a namespace at the start of a string, or after “const”.

function strip_whitespace_except_after_const #

EXPORT_SYMBOLS void strip_whitespace_except_after_const(
    str & s
)

Strips all whitespaces from a string, but re-inserts a single regular space after “const”.

Strip all whitespace except that following “const”, in which case the whitespace is replaced by a single space.

function strip_parentheses #

EXPORT_SYMBOLS void strip_parentheses(
    str & s
)

Strips leading and/or trailing parentheses from a string.

function sspairset_contains #

EXPORT_SYMBOLS bool sspairset_contains(
    const str & ,
    const std::set< sspair > & 
)

Test if a set of str,str pairs contains any entry with first element matching a given string.

function sspairset_contains #

EXPORT_SYMBOLS bool sspairset_contains(
    const str & ,
    const str & ,
    const std::set< sspair > & 
)

Tests if a set of str,str pairs contains an entry matching two given strings.

function sspairset_contains #

EXPORT_SYMBOLS bool sspairset_contains(
    const sspair & quantity,
    const std::set< sspair > & set
)

Tests if a set of str,str pairs contains an entry matching a given pair.

function str_fixed_len #

EXPORT_SYMBOLS str str_fixed_len(
    str s,
    int len
)

Created a str of a specified length.

Created a std::string of a specified length.

function strcpy2f #

EXPORT_SYMBOLS void strcpy2f(
    char * arr,
    int len,
    str s
)

Copy a str to a character array, stripping the null termination character.

Copy a std::string to a character array, stripping the null termination character. Good for sending to Fortran.

function endsWith #

EXPORT_SYMBOLS bool endsWith(
    const std::string & str,
    const std::string & suffix
)

Checks whether “str ends with “suffix.

function startsWith #

EXPORT_SYMBOLS bool startsWith(
    const std::string & str,
    const std::string & prefix,
    bool case_sensitive =true
)

Checks whether “str begins with “prefix.

function iequals #

EXPORT_SYMBOLS bool iequals(
    const std::string & a,
    const std::string & b,
    bool case_sensitive =false
)

Perform a (possibly) case-insensitive string comparison.

Perform a simple case-insensitive string comparison From: https://stackoverflow.com/a/4119881/1447953

function split #

EXPORT_SYMBOLS std::vector< std::string > split(
    const std::string & input,
    const std::string & delimiter
)

Split string into vector of strings, using a delimiter string.

function strtolower #

EXPORT_SYMBOLS std::string strtolower(
    const std::string & a
)

Convert a whole string to lowercase.

function quote_if_contains_commas #

EXPORT_SYMBOLS std::string quote_if_contains_commas(
    str in
)

Enclose a string in quotation marks if it contains commas.

function beginA #

template <typename T ,
size_t N>
T * beginA(
    T(&) arr[N]
)

Get pointers to beginning and end of array.

function endA #

template <typename T ,
size_t N>
T * endA(
    T(&) arr[N]
)

function is_disjoint #

template <class Set1 ,
class Set2 >
bool is_disjoint(
    const Set1 & set1,
    const Set2 & set2
)

Test if two sets are disjoint (works on any sorted std container I think)

function ensure_path_exists #

EXPORT_SYMBOLS const str & ensure_path_exists(
    const str & path
)

Ensure that a path exists (and then return the path, for chaining purposes)

function file_exists #

EXPORT_SYMBOLS bool file_exists(
    const std::string & filename
)

Check if a file exists.

function ls_dir #

EXPORT_SYMBOLS std::vector< str > ls_dir(
    const str & dir
)

Return a vector of strings listing the contents of a directory (POSIX)

Return a vector of strings listing the contents of a directory (POSIX) Based on http://www.gnu.org/software/libtool/manual/libc/Simple-Directory-Lister.html

function dir_name #

EXPORT_SYMBOLS str dir_name(
    const str & path
)

Get directory name from full path+filename (POSIX)

function base_name #

EXPORT_SYMBOLS str base_name(
    const str & path
)

Get file name from full path+filename (POSIX)

function remove_all_files_in #

EXPORT_SYMBOLS int remove_all_files_in(
    const str & dirname,
    bool error_if_absent =true
)

Delete all files in a directory (does not act recursively)

function return_time_and_date #

EXPORT_SYMBOLS str return_time_and_date(
    const time_point & in
)

Get date and time.

Return (locally defined) date and time corresponding to time_point.

function are_similar #

EXPORT_SYMBOLS bool are_similar(
    const str & s1,
    const str & s2
)

Check if two strings are a “close” match Used for “did you mean?” type checking during command line argument processing

function check1 #

bool check1(
    const str & s1,
    const str & s2
)

true if s1 can be obtained by deleting one character from s2

Sub-check for are_similar. true if s1 can be obtained by deleting one character from s2

function check2 #

bool check2(
    const str & s1,
    const str & s2
)

true if s1 can be obtained from s2 by changing no more than X characters (X=2 for now)

Sub-check for are_similar. true if s1 can be obtained from s2 by changing no more than X characters (X=2 for now)

function sqr #

EXPORT_SYMBOLS double sqr(
    double a
)

returns square of double - saves tedious repetition

function isInteger #

EXPORT_SYMBOLS bool isInteger(
    const std::string & s
)

Check if a string represents an integer From: http://stackoverflow.com/a/2845275/1447953

function dummy_function #

template <typename... T>
void dummy_function()

function dummy_function #

template <typename T >
void dummy_function(
    T one
)

function dummy_function #

template <typename T1 ,
typename... T>
void dummy_function(
    T1 first,
    T... args
)

function masked_erase #

template <template< class, class > class Container,
class T >
void masked_erase(
    Container< std::pair< T, bool >, std::allocator< std::pair< T, bool > > > & c
)

Expunge entries in a container of std::pairs for which the second (boolean) value of the pair is false. Useful for allowing evaluation of a removal criterion over the whole container in parallel.

function InterpIter #

void InterpIter(
    int Ntemp,
    double xi_1,
    double xi_2,
    std::vector< double > & fi,
    double test
)

function linearinterp1D #

double linearinterp1D(
    double x1,
    double x2,
    double y1,
    double y2,
    double xtest
)

function get_GAMBIT_root_dir #

std::string get_GAMBIT_root_dir()

The initial assumption is that this is provided by CMake via the GAMBIT_RUN_DIR variable However, in situations where GAMBIT is built in some temporary directory and then moved (as occurs in the pip installation of pyScannerBit), then we need to locate the root directory via an environment variable at runtime instead. If this environment variable is set then it will override the value set at build time.

function sspairset_contains #

bool sspairset_contains(
    const str & el,
    const std::set< std::pair< str, str > > & set
)

Test if a set of str,str pairs contains any entry with first element matching a given string.

function sspairset_contains #

bool sspairset_contains(
    const str & el1,
    const str & el2,
    const std::set< std::pair< str, str > > & set
)

Tests if a set of str,str pairs contains an entry matching two given strings.

Attributes Documentation #

variable whitespaces #

const char *[] whitespaces = {" ", "\t", "\n", "\f", "\r"};

Updated on 2025-02-12 at 15:36:40 +0000