About aGrUM utilities. More...

Collaboration diagram for Utilities:

Topics
	Math
	All the maths you'll need.
	Configuration
	About aGrUM configuration.
	Smart Pointers
	RefPtr are a replacement for the usual pointers: they keep track of the number of "smart" pointers pointing to a given element.
template<typename T1, typename T2>
using	gum::forbidden_type = typename std::enable_if< !std::is_same< T1, T2 >::value, int >::type
	Forbidden_type<T1,T2> return the "int" type if T1 and T2 are of the same type, else nothing.
bool	gum::Memcmp (const void const in_, const void const out_, unsigned long size)
	Cross-platform replacement for memcmp.
void	gum::_atexit_ ()
	Used for debug purpose.
template<typename T1, typename T2>
ostream &	std::operator<< (ostream &stream, const pair< T1, T2 > &val)
	'std::cout<<' operator for pairs.
template<typename T0, typename... T>
std::ostream &	std::operator<< (std::ostream &os, const std::tuple< T0, T... > &t)
	'std::cout<<' operator for vectors.
template<typename T>
ostream &	std::operator<< (ostream &stream, const vector< T > &val)
	'std::cout<<' operator for vectors.
template<typename T>
bool	std::hasUniqueElts (std::vector< T > const &x)

Idx	gum::randomValue (const Size max=2)
	Returns a random Idx between 0 and max-1 included.
double	gum::randomProba ()
	Returns a random double between 0 and 1 included (i.e.
template<typename GUM_SCALAR>
std::vector< GUM_SCALAR >	gum::randomDistribution (Size n)
	Return a random discrete distribution.
unsigned int	gum::randomGeneratorSeed ()
	Returns the aGrUM's seed used by the std::generators.
unsigned int	gum::currentRandomGeneratorValue ()
	returns the current generator's value
void	gum::initRandom (unsigned int seed=0)
	Initialize random generator seed.
std::mt19937 &	gum::randomGenerator ()
	define a random_engine with correct seed
std::string	gum::getUniqueFileName ()
	Returns a path to a unique file name.
bool	gum::endsWith (std::string const &value, std::string const &ending)
	Returns true if value ends with ending.
std::vector< std::string >	gum::split (const std::string &orig, const std::string &delimiter)
	Split str using the delimiter.
std::string	gum::replace (const std::string &s, const std::string &val, const std::string &new_val)
	not usable for gcc 4.8 std::vector<std::string> split( const std::string& orig, const std::string& delimiter ) {
bool	gum::isIntegerWithResult (const std::string &val, int *res)
	return true is a string contains an integer value
bool	gum::isNumericalWithResult (const std::string &val, double *res)
	return true is a string contains a numerical (double) value
std::string	gum::toLower (std::string str)
	Returns the lowercase version of str.
bool	gum::isInteger (const std::string &val)
	return true is a string contains an integer value
bool	gum::isNumerical (const std::string &val)
	return true is a string contains a numerical (double) value
void	gum::ltrim (std::string &s)
	trim from start (in place)
void	gum::rtrim (std::string &s)
	trim from end (in place)
void	gum::trim (std::string &s)
	trim from both ends (in place)
std::string	gum::trim_copy (const std::string &s)
	trim from both ends (copying)
std::string	gum::remove_newline (const std::string &s)
	remove all newlines in a string
template<typename T>
std::string	gum::compact_tostr (T value)
	Returns a path to a unique file name.

Detailed Description

About aGrUM utilities.

Typedef Documentation

◆ forbidden_type

template<typename T1, typename T2>

using gum::forbidden_type = typename std::enable_if< !std::is_same< T1, T2 >::value, int >::type

Forbidden_type<T1,T2> return the "int" type if T1 and T2 are of the same type, else nothing.

Use it as a guard in template specification :

// Creates a template except if T is int or char

template<T,forbidden_type<T,int> =0,forbidden_type<T,char> =0> // ...

Parameters

T1	The type to test for.
T2	The expected type.

Definition at line 143 of file utils_misc.h.

Function Documentation

◆ _atexit_()

void gum::_atexit_ ( )

Used for debug purpose.

Definition at line 67 of file utils_misc.cpp.

                  {
#ifdef GUM_DEBUG_MODE
    gum::__debug__::_atexit_();
#endif
  }

◆ compact_tostr()

template<typename T>

std::string gum::compact_tostr ( T value )

inline

Returns a path to a unique file name.

Returns: Returns a path to a unique file name.

Definition at line 161 of file utils_string.h.

                                          {
    std::ostringstream s;
    s.precision(7);
    s << value;
    return s.str();
  }

◆ currentRandomGeneratorValue()

INLINE unsigned int gum::currentRandomGeneratorValue ( )

returns the current generator's value

Definition at line 85 of file utils_random_inl.h.

85{ return _rand_namespace_::generator()(); }

gum::_rand_namespace_::generator

std::mt19937 & generator()

Definition utils_random_inl.h:58

References gum::_rand_namespace_::generator().

Here is the call graph for this function:

◆ endsWith()

bool gum::endsWith	(	std::string const &	value,
		std::string const &	ending )

Returns true if value ends with ending.

Returns: Returns true if value ends with ending.

Definition at line 83 of file utils_string.cpp.

                                                                 {
    if (ending.size() > value.size()) return false;
    return std::equal(ending.rbegin(), ending.rend(), value.rbegin());
  }

Referenced by gum::prm::o3prm::O3NameSolver< GUM_SCALAR >::resolveClass(), gum::prm::o3prm::O3NameSolver< GUM_SCALAR >::resolveClassElement(), gum::prm::o3prm::O3NameSolver< GUM_SCALAR >::resolveInterface(), gum::prm::o3prm::O3NameSolver< GUM_SCALAR >::resolveSlotType(), and gum::prm::o3prm::O3NameSolver< GUM_SCALAR >::resolveType().

Here is the caller graph for this function:

◆ getUniqueFileName()

std::string gum::getUniqueFileName ( )

Returns a path to a unique file name.

Returns: Returns a path to a unique file name.

Definition at line 63 of file utils_string.cpp.

                                {
    // Get the temporary directory path
    std::filesystem::path temp_dir = std::filesystem::temp_directory_path();
 
    // Generate a unique file name using a timestamp and a random number
    auto now = std::chrono::system_clock::now();
    auto timestamp
        = std::chrono::duration_cast< std::chrono::milliseconds >(now.time_since_epoch()).count();
 
    auto dis = gum::randomValue(1000);
 
    std::string filename
        = "tempfile_" + std::to_string(timestamp) + "_" + std::to_string(dis) + ".tmp";
 
    // Combine the directory path and the file name
    std::filesystem::path temp_file_path = temp_dir / filename;
 
    return temp_file_path.string();
  }

References randomValue().

Referenced by gum::credal::CredalNet< GUM_SCALAR >::_H2Vlrs_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ hasUniqueElts()

template<typename T>

bool std::hasUniqueElts ( std::vector< T > const & x )

check if a vector consists in unique values (no duplicate).

Template Parameters

T	The vector's elements type.

Parameters

x	the vector

Returns: Returns true if the vector has no duplicate.

Definition at line 108 of file utils_misc_tpl.h.

                                              {
    if (x.size() <= 1) return true;
    if (x.size() == 2) return x[0] != x[1];
 
    auto refless = [](T const* l, T const* r) { return *l < *r; };
    auto refeq   = [](T const* l, T const* r) { return *l == *r; };
 
    std::vector< T const* > vp;
    vp.reserve(x.size());
    for (size_t i = 0; i < x.size(); ++i)
      vp.push_back(&x[i]);
    sort(vp.begin(), vp.end(), refless);   // O(N log N)
    // if no adjacent pair (vp_n,vp_n+1) has *vp_n == *vp_n+1
    return std::adjacent_find(vp.begin(), vp.end(), refeq) == vp.end();
  }

◆ initRandom()

INLINE void gum::initRandom ( unsigned int seed = 0 )

Initialize random generator seed.

Definition at line 77 of file utils_random_inl.h.

                                     {
    if (seed == 0) seed = (unsigned int)std::chrono::system_clock::now().time_since_epoch().count();
    std::seed_seq seq{seed + 1, seed + 2, seed + 3, seed + 4, seed + 5};
    _rand_namespace_::generator().seed(seq);
  }

References gum::_rand_namespace_::generator().

Here is the call graph for this function:

◆ isInteger()

INLINE bool gum::isInteger ( const std::string & val )

return true is a string contains an integer value

Parameters

s A string

Returns: true if s exactly contains an int (s can start with "-" or "+")

Definition at line 95 of file utils_string_inl.h.

95{ return isIntegerWithResult(val, nullptr); }

gum::isIntegerWithResult

bool isIntegerWithResult(const std::string &val, int *res)

return true is a string contains an integer value

Definition utils_string.cpp:124

References isIntegerWithResult().

Referenced by fastVariable().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isIntegerWithResult()

bool gum::isIntegerWithResult	(	const std::string &	val,
		int *	res )

return true is a string contains an integer value

Parameters

s A string

Returns: true if s exactly contains an int (s can start with "-" or "+")

Definition at line 124 of file utils_string.cpp.

                                                           {
    if (val.empty()) return false;
    std::size_t pos = 0;
    if ((val[0] == '+') || (val[0] == '-')) { pos = 1; }
 
    if (val.find_first_not_of("0123456789", pos) != std::string::npos) return false;
 
    if (res != nullptr) {
      const char* p = (val[0] == '+') ? 1 + val.c_str() : val.c_str();
      *res          = std::stoi(p);
    }
 
    return true;
  }

Referenced by isInteger().

Here is the caller graph for this function:

◆ isNumerical()

INLINE bool gum::isNumerical ( const std::string & val )

return true is a string contains a numerical (double) value

Parameters

s A string

Returns: true if s exactly contains a double

Definition at line 98 of file utils_string_inl.h.

98{ return isNumericalWithResult(val, nullptr); }

gum::isNumericalWithResult

bool isNumericalWithResult(const std::string &val, double *res)

return true is a string contains a numerical (double) value

Definition utils_string.cpp:139

References isNumericalWithResult().

Referenced by fastVariable().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isNumericalWithResult()

bool gum::isNumericalWithResult	(	const std::string &	val,
		double *	res )

return true is a string contains a numerical (double) value

Parameters

s	A string *

Returns: true if s exactly contains a double

Definition at line 139 of file utils_string.cpp.

                                                                {
    char*       endptr = nullptr;
    const char* str    = val.c_str();
    double      d      = std::strtod(str, &endptr);
 
    if (*endptr != '\0' || endptr == str) return false;
    if (res != nullptr) *res = d;
 
    return true;
  }

Referenced by isNumerical().

Here is the caller graph for this function:

◆ ltrim()

INLINE void gum::ltrim ( std::string & s )

trim from start (in place)

Parameters

s A string

Definition at line 65 of file utils_string_inl.h.

                           {
    s.erase(s.begin(),
            std::find_if(s.begin(), s.end(), [](unsigned char ch) { return !std::isspace(ch); }));
  }

Referenced by trim().

Here is the caller graph for this function:

◆ Memcmp()

bool gum::Memcmp	(	const void *const	in_,
		const void *const	out_,
		unsigned long	size )

Cross-platform replacement for memcmp.

Parameters

in_	A pointer to the block of memory to copy.
out_	A pointer to the block of memory receiving copy.
size	Number of bytes to copy.

Returns: Returns true if OK.

Definition at line 57 of file utils_misc.cpp.

                                                                                 {
    unsigned char* in  = (unsigned char*)in_;
    unsigned char* out = (unsigned char*)out_;
 
    for (unsigned long i = 0; i < size; ++i)
      if (*(in++) != *(out++)) return false;
 
    return true;
  }

◆ operator<<() [1/3]

template<typename T1, typename T2>

ostream & std::operator<<	(	ostream &	stream,
		const pair< T1, T2 > &	val )

'std::cout<<' operator for pairs.

Template Parameters

T1	The pair's first's type.
T2	The pair's second's type.

Parameters

stream	The stream to print to.
val	The pair to print to stream.

Returns: Returns stream.

Definition at line 78 of file utils_misc_tpl.h.

                                                                  {
    stream << "(" << val.first << "," << val.second << ")";
    return stream;
  }

◆ operator<<() [2/3]

template<typename T>

ostream & std::operator<<	(	ostream &	stream,
		const vector< T > &	val )

'std::cout<<' operator for vectors.

Template Parameters

T	The vector's elements type.

Parameters

stream	The stream to print to.
val	The std::vector to print to stream.

Returns: Returns stream.

Definition at line 62 of file utils_misc_tpl.h.

                                                               {
    bool deja = false;
    stream << "[";
 
    for (const auto& v: val) {
      if (deja) stream << " , ";
      else deja = true;
      stream << v;
    }
 
    stream << "]";
 
    return stream;
  }

◆ operator<<() [3/3]

template<typename T0, typename... T>

std::ostream & std::operator<<	(	std::ostream &	os,
		const std::tuple< T0, T... > &	t )

'std::cout<<' operator for vectors.

Parameters

stream The stream to print to.

Template Parameters

t	The std::tuple

Parameters

val	The std::vector to print to stream.

Returns: Returns stream.

Definition at line 100 of file utils_misc_tpl.h.

                                                                        {
    char quote = (std::is_convertible< T0, std::string >::value) ? '"' : 0;
    os << '(' << quote << std::get< 0 >(t) << quote;
    _auxiliary_print_tuple_< 1 >::print(os, t);
    return os << ')';
  }

References std::_auxiliary_print_tuple_< N >::print().

Here is the call graph for this function:

◆ randomDistribution()

template<typename GUM_SCALAR>

std::vector< GUM_SCALAR > gum::randomDistribution ( Size n )

Return a random discrete distribution.

Parameters

n	The number of modalities for the ditribution.

Returns: Return a random discrete distribution.

Template Parameters

GUM_SCALAR The type used for representing probabilities.

Definition at line 54 of file utils_random_tpl.h.

                                                     {
    if (n < 2) n = 2;
 
    // using sort method for uniformly distributed distributions
    // https://doi.org/10.1016/0377-2217(82)90161-8
    std::vector< GUM_SCALAR > v(n + 1);
    std::vector< GUM_SCALAR > res(n);
    v[0] = (GUM_SCALAR)0.0;
    v[n] = (GUM_SCALAR)1.0;
    for (Idx i = 1; i < n; i++) {
      v[i] = (GUM_SCALAR)randomProba();
    }
    std::sort(v.begin(), v.end());
 
    for (Idx i = 0; i < n; i++) {
      res[i] = v[i + 1] - v[i];
    }
 
    return res;
  }

References randomProba().

Referenced by gum::Tensor< GUM_SCALAR >::randomCPT(), and gum::Tensor< GUM_SCALAR >::randomDistribution().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ randomGenerator()

INLINE std::mt19937 & gum::randomGenerator ( )

define a random_engine with correct seed

Definition at line 96 of file utils_random_inl.h.

96{ return _rand_namespace_::generator(); }

References gum::_rand_namespace_::generator().

Referenced by gum::MultiDimFunctionGraphGenerator::_generateVarPos_(), gum::Dirichlet::operator()(), gum::Dirichlet::operator()(), and gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setRandomVarOrder().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ randomGeneratorSeed()

INLINE unsigned int gum::randomGeneratorSeed ( )

Returns the aGrUM's seed used by the std::generators.

Returns: Returns the aGrUM's seed used by the std::generators.

Definition at line 89 of file utils_random_inl.h.

                                     {
    return (unsigned int)((GUM_RANDOMSEED == 0)
                              ? std::chrono::system_clock::now().time_since_epoch().count()
                              : GUM_RANDOMSEED);
  }

◆ randomProba()

INLINE double gum::randomProba ( )

Returns a random double between 0 and 1 included (i.e.

a proba).

Returns: Returns a random double between 0 and 1 included (i.e. a proba).

Definition at line 71 of file utils_random_inl.h.

                       {
    std::uniform_real_distribution uni_real(0.0, 1.0);
    return uni_real(_rand_namespace_::generator());
  }

References gum::_rand_namespace_::generator().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ randomValue()

INLINE Idx gum::randomValue ( const Size max = 2 )

Returns a random Idx between 0 and max-1 included.

Returns: Returns a random idx between 0 and max-1 included . By default, max=2

Definition at line 65 of file utils_random_inl.h.

                                  {
    std::uniform_int_distribution< Idx > uni_int(0, int(max) - 1);
    return uni_int(_rand_namespace_::generator());
  }

References gum::_rand_namespace_::generator().

Referenced by gum::MCBayesNetGenerator< GUM_SCALAR, ICPTGenerator, ICPTDisturber >::_chooseCloseNodes_(), gum::MCBayesNetGenerator< GUM_SCALAR, ICPTGenerator, ICPTDisturber >::_createPartTree_(), gum::MCBayesNetGenerator< GUM_SCALAR, ICPTGenerator, ICPTDisturber >::_createTree_(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateClass_(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateClassDag_(), gum::prm::LayerGenerator< GUM_SCALAR >::_generateClassDag_(), gum::prm::LayerGenerator< GUM_SCALAR >::_generateClasses_(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateCluster_(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateSystem_(), gum::prm::LayerGenerator< GUM_SCALAR >::_generateSystem_(), gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::_verticesSampling_(), gum::IBayesNetGenerator< GUM_SCALAR, SimpleCPTGenerator >::fillCPT(), gum::MultiDimFunctionGraphGenerator::generate(), gum::SimpleBayesNetGenerator< GUM_SCALAR, ICPTGenerator >::generateBN(), gum::InfluenceDiagramGenerator< GUM_SCALAR >::generateID(), getUniqueFileName(), gum::credal::CNLoopyPropagation< GUM_SCALAR >::makeInferenceByRandomOrder_(), gum::GibbsOperator< GUM_SCALAR >::nextSample(), gum::AbstractSimulator::randomState_(), gum::SDYNA::takeAction(), and gum::IncrementalGraphLearner< AttributeSelection, isScalar >::updateNode_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ remove_newline()

INLINE std::string gum::remove_newline ( const std::string & s )

remove all newlines in a string

Parameters

s A string

Returns: the new string with no newline

Definition at line 87 of file utils_string_inl.h.

                                               {
    std::string res{s};
    std::erase(res, '\n');
    std::erase(res, '\r');
    return res;
  }

Referenced by gum::BayesNet< GUM_SCALAR >::fastPrototype(), and gum::InfluenceDiagram< GUM_SCALAR >::fastPrototype().

Here is the caller graph for this function:

◆ replace()

std::string gum::replace	(	const std::string &	s,
		const std::string &	val,
		const std::string &	new_val )

not usable for gcc 4.8 std::vector<std::string> split( const std::string& orig, const std::string& delimiter ) {

Replace val by new_val in s.

std::regex rgx( delimiter );

std::sregex_token_iterator first{begin( orig ), end( orig ), rgx, -1}, last;

return {first, last}; }

Parameters

s	A string.
val	The value to replace in s.
new_val	The new value to replace val in s.

Returns: A new string with val replaced by new_val.

Definition at line 112 of file utils_string.cpp.

                                                                                        {
    auto retVal = s;
    auto pos    = retVal.find(val);
    while (pos != std::string::npos) {
      std::stringstream sBuff;
      sBuff << s.substr(0, pos) << new_val << s.substr(pos + val.size(), std::string::npos);
      retVal = sBuff.str();
      pos    = retVal.find(val);
    }
    return retVal;
  }

Referenced by gum::prm::o3prm::O3prmReader< GUM_SCALAR >::_clean_().

Here is the caller graph for this function:

◆ rtrim()

INLINE void gum::rtrim ( std::string & s )

trim from end (in place)

Parameters

s A string

Definition at line 72 of file utils_string_inl.h.

                           {
    s.erase(std::find_if(s.rbegin(), s.rend(), [](unsigned char ch) { return !std::isspace(ch); })
                .base(),
            s.end());
  }

Referenced by trim().

Here is the caller graph for this function:

◆ split()

std::vector< std::string > gum::split	(	const std::string &	orig,
		const std::string &	delimiter )

Split str using the delimiter.

Parameters

orig	searched string
delimiter	string

Returns: Vector of splitted strings

Definition at line 88 of file utils_string.cpp.

                                                                             {
    std::vector< std::string > tokens;
    size_t                     prev = 0, pos = 0;
    do {
      pos = str.find(delim, prev);
      if (pos == std::string::npos) pos = str.length();
      std::string token = str.substr(prev, pos - prev);
      if (!token.empty()) tokens.push_back(token);
      prev = pos + delim.length();
    } while (pos < str.length() && prev < str.length());
    return tokens;
  }

Referenced by gum::BayesNet< GUM_SCALAR >::fastPrototype(), gum::InfluenceDiagram< GUM_SCALAR >::fastPrototype(), and fastVariable().

Here is the caller graph for this function:

◆ toLower()

INLINE std::string gum::toLower ( std::string str )

Returns the lowercase version of str.

Returns: Returns the lowercase version of str.

Definition at line 58 of file utils_string_inl.h.

                                   {
    std::transform(str.begin(), str.end(), str.begin(), ::tolower);
    return str;
  }

Referenced by gum::AggregatorDecomposition< GUM_SCALAR >::addAggregator_(), and gum::prm::PRMAggregate< GUM_SCALAR >::str2enum().

Here is the caller graph for this function:

◆ trim()

INLINE void gum::trim ( std::string & s )

trim from both ends (in place)

Parameters

s A string

Definition at line 80 of file utils_string_inl.h.

                          {
    ltrim(s);
    rtrim(s);
  }

References ltrim(), and rtrim().

Referenced by fastVariable(), and trim_copy().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ trim_copy()

INLINE std::string gum::trim_copy ( const std::string & s )

trim from both ends (copying)

Parameters

s A string

Returns: the new string trimmed from start

Definition at line 102 of file utils_string_inl.h.

                                          {
    std::string res{s};
    trim(res);
    return res;
  }

References trim().

Here is the call graph for this function:

Topics

Detailed Description

Typedef Documentation

◆ forbidden_type

Function Documentation

◆ _atexit_()

◆ compact_tostr()

◆ currentRandomGeneratorValue()

◆ endsWith()

◆ getUniqueFileName()

◆ hasUniqueElts()

◆ initRandom()

◆ isInteger()

◆ isIntegerWithResult()

◆ isNumerical()

◆ isNumericalWithResult()

◆ ltrim()

◆ Memcmp()

◆ operator<<() [1/3]

◆ operator<<() [2/3]

◆ operator<<() [3/3]

◆ randomDistribution()

◆ randomGenerator()

◆ randomGeneratorSeed()

◆ randomProba()

◆ randomValue()

◆ remove_newline()

◆ replace()

◆ rtrim()

◆ split()

◆ toLower()

◆ trim()

◆ trim_copy()