About aGrUM utilities. More...

Collaboration diagram for Utilities:

Detailed Description

About aGrUM utilities.

Modules
	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.

Classes
class	gum::Directory
	Cross-platform directory utility. More...

template<typename T1 , typename T2 >
ostream &	std::operator<< (ostream &stream, const pair< T1, T2 > &val)
	'std::cout<<' operator for pairs. More...

template<typename T0 , typename... T>
std::ostream &	std::operator<< (std::ostream &os, const std::tuple< T0, T... > &t)
	'std::cout<<' operator for vectors. More...

template<typename T >
ostream &	std::operator<< (ostream &stream, const vector< T > &val)
	'std::cout<<' operator for vectors. More...

template<typename T >
bool	std::hasUniqueElts (std::vector< T > const &x)
	More...

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. More...

bool	gum::Memcmp (const void const _in, const void const _out, unsigned long size)
	Cross-platform replacement for memcmp. More...

void	gum::__atexit ()
	Used for debug purpose. More...

Idx	gum::randomValue (const Size max=2)
	Returns a random Idx between 0 and max-1 included. More...

double	gum::randomProba ()
	Returns a random double between 0 and 1 included (i.e. More...

template<typename GUM_SCALAR >
std::vector< GUM_SCALAR >	gum::randomDistribution (Size n)
	Return a random discrete distribution. More...

unsigned int	gum::randomGeneratorSeed ()
	Returns the aGrUM's seed used by the std::generators. More...

void	gum::initRandom (unsigned int seed=0)
	Initialize random generator seed. More...

std::default_random_engine	gum::getRandomGenerator (unsigned int seed=0)
	define a random_engine with correct seed More...

std::string	gum::getUniqueFileName ()
	Returns a path to a unique file name. More...

bool	gum::endsWith (std::string const &value, std::string const &ending)
	Returns true if value ends with ending. More...

std::vector< std::string >	gum::split (const std::string &orig, const std::string &delimiter)
	Split str using the delimiter. More...

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 ) { More...

std::string	gum::toLower (std::string str)
	Returns the lowercase version of str. More...

Typedef Documentation

◆ forbidden_type

template<typename T1 , typename T2 >

using gum::forbidden_type = typedef 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 127 of file utils_misc.h.

Function Documentation

◆ __atexit()

void gum::__atexit ( )

Used for debug purpose.

Definition at line 50 of file utils_misc.cpp.

Referenced by gum::NullStream::NullStream().

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

Here is the caller 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 50 of file utils_string.cpp.

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().

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

Here is the caller graph for this function:

◆ getRandomGenerator()

std::default_random_engine gum::getRandomGenerator ( unsigned int seed )

define a random_engine with correct seed

Definition at line 49 of file utils_random.cpp.

References gum::randomGeneratorSeed().

Referenced by gum::MultiDimFunctionGraphGenerator::__generateVarPos().

                                                                  {
     std::default_random_engine generator;
     generator.seed(seed ? seed : randomGeneratorSeed());
     return generator;
   }

Here is the call graph for this function:

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 37 of file utils_string.cpp.

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

                                 {
 #ifdef HAVE_MKSTEMP
     char _tmpFileName[] = "fileXXXXXX";
     int  fd = mkstemp(_tmpFileName);
     close(fd);
 #else   // mainly Windows
     char _tmpFileName[] = "fileXXXXXX";
     _mktemp_s(_tmpFileName, strlen(_tmpFileName));
 #endif
 
     return std::string(_tmpFileName);
   }

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.

Todo:: WHY IN STD namespace ??

Definition at line 90 of file utils_misc_tpl.h.

Referenced by gum::build_node().

                                               {
     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();
   }

Here is the caller graph for this function:

◆ initRandom()

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

Initialize random generator seed.

Definition at line 41 of file utils_random_inl.h.

References gum::randomGeneratorSeed().

                                      {
     if (seed) {
       srand(seed);
     } else {
       srand(randomGeneratorSeed());
     }
   }

Here is the call 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 40 of file utils_misc.cpp.

Referenced by gum::NullStream::NullStream().

                                                                                  {
     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;
   }

Here is the caller graph for this function:

◆ 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 59 of file utils_misc_tpl.h.

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

◆ operator<<() [2/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 82 of file utils_misc_tpl.h.

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

                                                                         {
     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 << ')';
   }

Here is the call graph for this function:

◆ operator<<() [3/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 41 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;
   }

◆ 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 35 of file utils_random_tpl.h.

References gum::randomProba().

                                                      {
     if (n < 2) n = 2;
 
     std::vector< GUM_SCALAR > v(n);
     GUM_SCALAR                s;
 
     do {
       for (Idx i = 0; i < n; i++) {
         v[i] = (GUM_SCALAR)randomProba();
       }
 
       s = std::accumulate(v.begin(), v.end(), (GUM_SCALAR)0.0);
 
     } while (s < (GUM_SCALAR)(1e-5));
 
     for (Idx i = 0; i < n; i++) {
       v[i] /= s;
     }
 
     return v;
   }

Here is the call graph for this function:

◆ randomGeneratorSeed()

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 41 of file utils_random.cpp.

Referenced by gum::getRandomGenerator(), and gum::initRandom().

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

Here is the caller graph for this function:

◆ 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 38 of file utils_random_inl.h.

Referenced by gum::SimpleCPTDisturber< GUM_SCALAR >::disturbAugmCPT(), gum::Potential< GUM_SCALAR >::draw(), gum::SimpleBayesNetGenerator< GUM_SCALAR, ICPTGenerator >::generateBN(), gum::Potential< GUM_SCALAR >::random(), and gum::randomDistribution().

38 { return ((double)rand()) / ((double)RAND_MAX); }

double

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 Odxbetween 0 and max-1 included (i.e. a proba). By default, max=2

Definition at line 35 of file utils_random_inl.h.

35 { return (Idx)(rand() % max); }

Idx

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 80 of file utils_string.cpp.

Referenced by gum::prm::o3prm::O3prmReader< double >::__clean(), gum::prm::o3prm::O3prmReader< double >::__parseImport(), and gum::prm::o3prmr::O3prmrInterpreter::import().

                                                 {
     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;
   }

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 55 of file utils_string.cpp.

Referenced by gum::build_node(), and gum::BayesNet< double >::fastPrototype().

                                                            {
     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;
   }

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 37 of file utils_string_inl.h.

Referenced by gum::prm::PRMAggregate< double >::str2enum().

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

Here is the caller graph for this function:

Detailed Description

Modules

Classes

Typedef Documentation

◆ forbidden_type

Function Documentation

◆ __atexit()

◆ endsWith()

◆ getRandomGenerator()

◆ getUniqueFileName()

◆ hasUniqueElts()

◆ initRandom()

◆ Memcmp()

◆ operator<<() [1/3]

◆ operator<<() [2/3]

◆ operator<<() [3/3]

◆ randomDistribution()

◆ randomGeneratorSeed()

◆ randomProba()

◆ randomValue()

◆ replace()

◆ split()

◆ toLower()