mlUtilsSystem.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef ML_UTILS_SYSTEM_H
#define ML_UTILS_SYSTEM_H
 
 
#include <type_traits>
 
//------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------
#ifndef MEVIS_TARGET
#if !defined(MEVIS_TARGET)
# error "The compiler definition MEVIS_TARGET is not set! It must specify the name of the compiled executable (without _d etc.)"
#endif
#endif
 
 
//------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------
#ifndef ML_UTILS_NAMESPACE
#define ML_UTILS_NAMESPACE       ml
#endif
 
#ifndef ML_UTILS_START_NAMESPACE
#define ML_UTILS_START_NAMESPACE namespace ML_UTILS_NAMESPACE {
#endif
 
#ifndef ML_UTILS_END_NAMESPACE
#define ML_UTILS_END_NAMESPACE   }
#endif
 
#include "mlTypeDefs.h"
 
ML_UTILS_START_NAMESPACE
 
//------------------------------------------------------------------------------------
//
//
//------------------------------------------------------------------------------------
 
template<typename T> T mlMin(T a, T b){ return a < b ? a : b; }
 
template<typename T> T mlMax(T a, T b){ return a > b ? a : b; }
 
#if defined(__GNUC__)
  #pragma GCC diagnostic push
  // unary minus converts char and short to int - do not print a warning
  #pragma GCC diagnostic ignored "-Wsign-conversion"
#endif
 
template<typename T> T mlAbs(T a){ if constexpr (std::is_signed<T>::value) return a < 0 ? -a : a; else return a; }
 
#if defined(__GNUC__)
  #pragma GCC diagnostic pop
#endif                                                     
 
ML_UTILS_END_NAMESPACE
 
#ifdef WIN32
//------------------------------------------------------------------------------------
//
//            e.g., fabs(static_cast<int>(10)) could have been fabs(float),
//            fabs(double), or fabs(long double).
//
//------------------------------------------------------------------------------------
 
// We include \c cmath, so that always the standard functions are defined if these
// overloads are defined.
#include <ThirdPartyWarningsDisable.h>
#include <cmath>
#include <ThirdPartyWarningsRestore.h>
 
inline long double pow(         __int64 i, int         value) { return pow(static_cast<long double>(i), static_cast<long double>(value)); }
inline long double pow(unsigned __int64 i, int         value) { return pow(static_cast<long double>(i), static_cast<long double>(value)); }
inline long double pow(         __int64 i, float       value) { return pow(static_cast<long double>(i), static_cast<long double>(value)); }
inline long double pow(unsigned __int64 i, float       value) { return pow(static_cast<long double>(i), static_cast<long double>(value)); }
inline long double pow(         __int64 i, double      value) { return pow(static_cast<long double>(i), static_cast<long double>(value)); }
inline long double pow(unsigned __int64 i, double      value) { return pow(static_cast<long double>(i), static_cast<long double>(value)); }
inline long double pow(         __int64 i, long double value) { return pow(static_cast<long double>(i), static_cast<long double>(value)); }
inline long double pow(unsigned __int64 i, long double value) { return pow(static_cast<long double>(i), static_cast<long double>(value)); }
 
inline unsigned __int64 abs (unsigned __int64 i) { return i; }
inline long double      fabs(         __int64 i) { return static_cast<long double>(i < 0 ? -i : i); }
inline long double      fabs(unsigned __int64 i) { return static_cast<long double>(i); }
 
inline double      pow (float        f,           double d ) { return pow(static_cast<double>(f),      d);                           }
inline double      pow (double       d,            float f ) { return pow(d,                           static_cast<double>(f));      }
inline double      pow (double       d,     unsigned int i ) { return pow(d,                           static_cast<double>(i));      }
inline long double pow (double       d,          __int64 i ) { return pow(static_cast<long double>(d), static_cast<long double>(i)); }
inline long double pow (double       d, unsigned __int64 i ) { return pow(static_cast<long double>(d), static_cast<long double>(i)); }
inline long double pow (double       d,      long double ld) { return pow(static_cast<long double>(d), ld);                          }
inline long double pow (long double ld,           double d ) { return pow(ld,                          static_cast<long double>(d)); }
 
template <typename T> inline double      atan (T value)                 { return atan (static_cast<double>(value)); }
template <typename T> inline double      ceil (T value)                 { return ceil (static_cast<double>(value)); }
template <typename T> inline double      exp  (T value)                 { return exp  (static_cast<double>(value)); }
template <typename T> inline double      fabs (T value)                 { return fabs (static_cast<double>(value)); }
template <typename T> inline double      floor(T value)                 { return floor(static_cast<double>(value)); }
template <typename T> inline double      log  (T value)                 { return log  (static_cast<double>(value)); }
template <typename T> inline double      sqrt (T value)                 { return sqrt (static_cast<double>(value)); }
template <typename T> inline double      pow  (int              i, T value) { return pow  (static_cast<double>(i),      value); }
template <typename T> inline double      pow  (unsigned int     i, T value) { return pow  (static_cast<double>(i),      value); }
template <typename T> inline long double pow  (         __int64 i, T value) { return pow  (static_cast<long double>(i), static_cast<long double>(value)); }
template <typename T> inline long double pow  (unsigned __int64 i, T value) { return pow  (static_cast<long double>(i), static_cast<long double>(value)); }
 
#endif
 
//------------------------------------------------------------------------------------
//
//
//------------------------------------------------------------------------------------
 
#define ML_TYPENAME typename
 
 
#endif // __mlUtilsSystem_H