92 lines
3.3 KiB
C++
92 lines
3.3 KiB
C++
#ifndef DEF_utils
|
|
#define DEF_utils
|
|
|
|
#include <ostream>
|
|
#include <utility>
|
|
|
|
#define PRINT_VAR(x) std::cout << #x << "\t= " << (x) << "\n"
|
|
#define PRINT_VEC(x); {std::cout << #x << "\t= "; \
|
|
for(unsigned int i_print_vec = 0 ; i_print_vec < (x).size() ; i_print_vec++) \
|
|
std::cout << (x)[i_print_vec] << "\t"; \
|
|
std::cout << "\n";}
|
|
#define PRINT_STR(x) std::cout << (x) << "\n"
|
|
|
|
template<typename T, typename T2> auto min(const T & a, const T2 & b) -> decltype(a | b) { return (a < b) ? T(a) : T(b); }
|
|
template<typename T, typename T2> auto max(const T & a, const T2 & b) -> decltype(a | b) { return (a < b) ? T(b) : T(a); }
|
|
|
|
/// To be sure that floating point numbers won't be casted to integers in ::abs()...
|
|
template<typename T> T sureAbs(const T & x) { return (x < T(0)) ? -x : x; }
|
|
|
|
|
|
//*
|
|
/// Generic operator<< for ostream, (to print std::vector, etd::list, std::map, etc). Can generate conflicts with specialized operator<< overloads.
|
|
template<typename T, template<class,class...> class C, class... Args>
|
|
std::ostream& operator<<(std::ostream& os, const C<T,Args...>& objs)
|
|
{
|
|
for (auto const& obj : objs)
|
|
os << obj << ' ';
|
|
return os;
|
|
}//*/
|
|
|
|
/// define UTILS_NO_CHRONO to deactivate chronometer
|
|
#ifndef UTILS_NO_CHRONO
|
|
|
|
#include <iostream>
|
|
#include <chrono>
|
|
#include <ratio>
|
|
#include <ctime>
|
|
|
|
/// Convenience macro to create a Chronometer object that will measure the execution time of its scope.
|
|
#define TIMER(str) Chronometer __chrono((str))
|
|
|
|
/// \class Chronometer class. Used to measure the execution time of its scope.
|
|
///
|
|
/// Usage :
|
|
///
|
|
/// {
|
|
/// TIMER("My timer");
|
|
/// /* some code to be profiled */
|
|
/// }// <--- the chronometer measures the time between the call to its constructor and the call to its destructor.
|
|
///
|
|
/// Possible output :
|
|
///
|
|
/// My timer : 0.12317568 s (+/- 1e-09 s)
|
|
///
|
|
template<int T=1>
|
|
struct Chronometer
|
|
{
|
|
std::string name;
|
|
std::chrono::high_resolution_clock::time_point t0;
|
|
|
|
/// Creates the Chronometer object with the provided name and stores the time.
|
|
Chronometer(const std::string & name_ = "")
|
|
: name(name_),
|
|
t0(std::chrono::high_resolution_clock::now())
|
|
{}
|
|
|
|
/// Measures the time elapsed between the creation of the object and its destruction, and prints the result in std::cout.
|
|
~Chronometer() { MeasureTimeElapsed(); }
|
|
|
|
/// Resets the timer. Allows the measurement of the execution time of several sub-intervals in the current scope.
|
|
void Reset() { t0 = std::chrono::high_resolution_clock::now(); }
|
|
|
|
/// Measures the time elapsed between the creation of the object and its destruction, and prints the result in std::cout.
|
|
void MeasureTimeElapsed()
|
|
{
|
|
// measure time since object creation
|
|
std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
|
|
std::chrono::duration<double> time_span = std::chrono::duration_cast<std::chrono::duration<double>>(t1 - t0);
|
|
// clock resolution
|
|
auto resolution_ratio = std::chrono::high_resolution_clock::period();
|
|
double resolution = double(resolution_ratio.num)/resolution_ratio.den;
|
|
|
|
std::cout.precision(16);
|
|
std::cout << name.c_str() << "\t: " << time_span.count() << " s (+/- " << resolution << " s)" << std::endl;// use of c_str() so that there is no ambiguity with the generic operator<<
|
|
}
|
|
};
|
|
|
|
#else// chronometer
|
|
#define TIMER(str)
|
|
#endif// chronometer
|
|
|
|
#endif
|