mlTypeDefTraits.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_TYPE_DEF_TRAITS_H
#define ML_TYPE_DEF_TRAITS_H


#include "mlTypeDefs.h"
 
#include <ThirdPartyWarningsDisable.h>
 
#if defined(WIN32)
# include <float.h>
# define __ML_1ST_WINDOWS_2ND_UNIX_FUNCTION(__ml_win_func,__ml_unix_func)  __ml_win_func
#else
# include <cmath>
# define __ML_1ST_WINDOWS_2ND_UNIX_FUNCTION(__ml_win_func,__ml_unix_func)  __ml_unix_func
#endif
 
#include <limits>
#include <boost/static_assert.hpp>
 
#include <ThirdPartyWarningsRestore.h>

  inline MLint8    MLTypeRangeMax(MLint8   )                  { return  ML_INT8_MAX   ; }
  inline MLuint8   MLTypeRangeMax(MLuint8  )                  { return  ML_UINT8_MAX  ; }
  inline MLint16   MLTypeRangeMax(MLint16  )                  { return  ML_INT16_MAX  ; }
  inline MLuint16  MLTypeRangeMax(MLuint16 )                  { return  ML_UINT16_MAX ; }
  inline MLint32   MLTypeRangeMax(MLint32  )                  { return  ML_INT32_MAX  ; }
  inline MLuint32  MLTypeRangeMax(MLuint32 )                  { return  ML_UINT32_MAX ; }
  inline MLfloat   MLTypeRangeMax(MLfloat  )                  { return  ML_FLOAT_MAX  ; }
  inline MLdouble  MLTypeRangeMax(MLdouble )                  { return  ML_DOUBLE_MAX ; }
  inline MLldouble MLTypeRangeMax(MLldouble)                  { return  ML_LDOUBLE_MAX; }
  inline MLuint64  MLTypeRangeMax(MLuint64 )                  { return  ML_UINT64_MAX ; }
  inline MLint64   MLTypeRangeMax(MLint64  )                  { return  ML_INT64_MAX  ; }

  inline MLint8    MLTypeRangeMin(MLint8   )                  { return  ML_INT8_MIN   ; }
  inline MLuint8   MLTypeRangeMin(MLuint8  )                  { return  ML_UINT8_MIN  ; }
  inline MLint16   MLTypeRangeMin(MLint16  )                  { return  ML_INT16_MIN  ; }
  inline MLuint16  MLTypeRangeMin(MLuint16 )                  { return  ML_UINT16_MIN ; }
  inline MLint32   MLTypeRangeMin(MLint32  )                  { return  ML_INT32_MIN  ; }
  inline MLuint32  MLTypeRangeMin(MLuint32 )                  { return  ML_UINT32_MIN ; }
  inline MLfloat   MLTypeRangeMin(MLfloat  )                  { return -ML_FLOAT_MAX  ; }
  inline MLdouble  MLTypeRangeMin(MLdouble )                  { return -ML_DOUBLE_MAX ; }
  inline MLldouble MLTypeRangeMin(MLldouble)                  { return -ML_LDOUBLE_MAX; }
  inline MLuint64  MLTypeRangeMin(MLuint64 )                  { return  ML_UINT64_MIN ; }
  inline MLint64   MLTypeRangeMin(MLint64  )                  { return  ML_INT64_MIN  ; }

  inline MLint8    MLTypeMinDifference(MLint8   )             { return  1                 ; }
  inline MLuint8   MLTypeMinDifference(MLuint8  )             { return  1                 ; }
  inline MLint16   MLTypeMinDifference(MLint16  )             { return  1                 ; }
  inline MLuint16  MLTypeMinDifference(MLuint16 )             { return  1                 ; }
  inline MLint32   MLTypeMinDifference(MLint32  )             { return  1                 ; }
  inline MLuint32  MLTypeMinDifference(MLuint32 )             { return  1                 ; }
  inline MLfloat   MLTypeMinDifference(MLfloat  )             { return  ML_FLOAT_EPSILON  ; }
  inline MLdouble  MLTypeMinDifference(MLdouble )             { return  ML_DOUBLE_EPSILON ; }
  inline MLldouble MLTypeMinDifference(MLldouble)             { return  ML_LDOUBLE_EPSILON; }
  inline MLuint64  MLTypeMinDifference(MLuint64 )             { return  1                 ; }
  inline MLint64   MLTypeMinDifference(MLint64  )             { return  1                 ; }

  inline MLfloat   MLfabs(MLfloat   v){ return fabsf(v); }
  inline MLdouble  MLfabs(MLdouble  v){ return fabs (v); }
  inline MLldouble MLfabs(MLldouble v){ return fabsl(v); }

  inline int MLisfinite(MLdouble v){ return __ML_1ST_WINDOWS_2ND_UNIX_FUNCTION( _finite(v) , std::isfinite(v) ); }

  inline int MLisnan(MLdouble v){ return __ML_1ST_WINDOWS_2ND_UNIX_FUNCTION( _isnan(v) , std::isnan(v) ); }

  template <typename DT>
    inline DT MLAbs(const DT val){ return (val < 0) ? -val : val; }

  template<>
    inline MLuint8  MLAbs(const MLuint8  val){ return val; }
  template<>
    inline MLuint16 MLAbs(const MLuint16 val){ return val; }
  template<>
    inline MLuint32 MLAbs(const MLuint32 val){ return val; }
  template<>
    inline MLuint64 MLAbs(const MLuint64 val){ return val; }
 
  // Prevent usage of abs() for floating point types, which will result in miscalculations
  // on UNIX systems due to stdlib.h 'int abs(int)'
  namespace ML_NAMESPACE {
    template <typename DT>
    inline DT abs (DT val) {
      // If you come here because of a compiler error, please replace abs() by MLAbs(),
      // MLfabs, or std::abs(). The usage of abs() will result in calculation errors!
      BOOST_STATIC_ASSERT(std::numeric_limits<DT>::is_integer);
      return (val < 0) ? -val : val;
    }
  }

  template <typename T>
  inline bool MLFloatValuesEqual(const T a, const T b, const T m)
  {
    return MLfabs(a - b) < MLTypeMinDifference(a)*m;
  }

  inline bool      MLValuesAreEqual(MLint8    a, MLint8    b, MLint8    /*m*/) { return a == b; }
  inline bool      MLValuesAreEqual(MLuint8   a, MLuint8   b, MLuint8   /*m*/) { return a == b; }
  inline bool      MLValuesAreEqual(MLint16   a, MLint16   b, MLint16   /*m*/) { return a == b; }
  inline bool      MLValuesAreEqual(MLuint16  a, MLuint16  b, MLuint16  /*m*/) { return a == b; }
  inline bool      MLValuesAreEqual(MLint32   a, MLint32   b, MLint32   /*m*/) { return a == b; }
  inline bool      MLValuesAreEqual(MLuint32  a, MLuint32  b, MLuint32  /*m*/) { return a == b; }
  inline bool      MLValuesAreEqual(MLfloat   a, MLfloat   b, MLfloat       m) { return MLFloatValuesEqual(a, b, m); }
  inline bool      MLValuesAreEqual(MLdouble  a, MLdouble  b, MLdouble      m) { return MLFloatValuesEqual(a, b, m); }
  inline bool      MLValuesAreEqual(MLldouble a, MLldouble b, MLldouble     m) { return MLFloatValuesEqual(a, b, m); }
  inline bool      MLValuesAreEqual(MLuint64  a, MLuint64  b, MLuint64  /*m*/) { return a == b; }
  inline bool      MLValuesAreEqual(MLint64   a, MLint64   b, MLint64   /*m*/) { return a == b; }
 
  // For all other cases.
  template <typename T1, typename T2>
  inline bool      MLValuesAreEqual(T1        a, T2        b, MLint64   /*m*/) { return a == b; }

  inline bool      MLValuesDiffer(MLint8    a, MLint8    b, MLint8     /*m*/)  { return a != b; }
  inline bool      MLValuesDiffer(MLuint8   a, MLuint8   b, MLuint8    /*m*/)  { return a != b; }
  inline bool      MLValuesDiffer(MLint16   a, MLint16   b, MLint16    /*m*/)  { return a != b; }
  inline bool      MLValuesDiffer(MLuint16  a, MLuint16  b, MLuint16   /*m*/)  { return a != b; }
  inline bool      MLValuesDiffer(MLint32   a, MLint32   b, MLint32    /*m*/)  { return a != b; }
  inline bool      MLValuesDiffer(MLuint32  a, MLuint32  b, MLuint32   /*m*/)  { return a != b; }
  inline bool      MLValuesDiffer(MLfloat   a, MLfloat   b, MLfloat        m)  { return !MLFloatValuesEqual(a, b, m); }
  inline bool      MLValuesDiffer(MLdouble  a, MLdouble  b, MLdouble       m)  { return !MLFloatValuesEqual(a, b, m); }
  inline bool      MLValuesDiffer(MLldouble a, MLldouble b, MLldouble      m)  { return !MLFloatValuesEqual(a, b, m); }
  inline bool      MLValuesDiffer(MLuint64  a, MLuint64  b, MLuint64   /*m*/)  { return a != b; }
  inline bool      MLValuesDiffer(MLint64   a, MLint64   b, MLint64    /*m*/)  { return a != b; }
 
  // For all other cases.
  template <typename T1, typename T2>
  inline bool      MLValuesDiffer(T1        a, T2        b, MLint64    /*m*/)  { return a != b; }

  inline bool      MLValuesAreEqualWOM(MLint8    a, MLint8    b) { return a == b; }
  inline bool      MLValuesAreEqualWOM(MLuint8   a, MLuint8   b) { return a == b; }
  inline bool      MLValuesAreEqualWOM(MLint16   a, MLint16   b) { return a == b; }
  inline bool      MLValuesAreEqualWOM(MLuint16  a, MLuint16  b) { return a == b; }
  inline bool      MLValuesAreEqualWOM(MLint32   a, MLint32   b) { return a == b; }
  inline bool      MLValuesAreEqualWOM(MLuint32  a, MLuint32  b) { return a == b; }
  inline bool      MLValuesAreEqualWOM(MLfloat   a, MLfloat   b) { return MLfabs(a -b) < ML_FLOAT_MIN  ; }
  inline bool      MLValuesAreEqualWOM(MLdouble  a, MLdouble  b) { return MLfabs(a -b) < ML_DOUBLE_MIN ; }
  inline bool      MLValuesAreEqualWOM(MLldouble a, MLldouble b) { return MLfabs(a -b) < ML_LDOUBLE_MIN; }
  inline bool      MLValuesAreEqualWOM(MLuint64  a, MLuint64  b) { return a == b; }
  inline bool      MLValuesAreEqualWOM(MLint64   a, MLint64   b) { return a == b; }
 
  // For all other cases.
  template <typename T1, typename T2>
  inline bool      MLValuesAreEqualWOM(T1        a, T2        b) { return a == b; }

  inline bool      MLValuesDifferWOM(MLint8    a, MLint8    b)  { return a != b; }
  inline bool      MLValuesDifferWOM(MLuint8   a, MLuint8   b)  { return a != b; }
  inline bool      MLValuesDifferWOM(MLint16   a, MLint16   b)  { return a != b; }
  inline bool      MLValuesDifferWOM(MLuint16  a, MLuint16  b)  { return a != b; }
  inline bool      MLValuesDifferWOM(MLint32   a, MLint32   b)  { return a != b; }
  inline bool      MLValuesDifferWOM(MLuint32  a, MLuint32  b)  { return a != b; }
  inline bool      MLValuesDifferWOM(MLfloat   a, MLfloat   b)  { return MLfabs(a -b) >= ML_FLOAT_MIN  ; }
  inline bool      MLValuesDifferWOM(MLdouble  a, MLdouble  b)  { return MLfabs(a -b) >= ML_DOUBLE_MIN ; }
  inline bool      MLValuesDifferWOM(MLldouble a, MLldouble b)  { return MLfabs(a -b) >= ML_LDOUBLE_MIN; }
  inline bool      MLValuesDifferWOM(MLuint64  a, MLuint64  b)  { return a != b; }
  inline bool      MLValuesDifferWOM(MLint64   a, MLint64   b)  { return a != b; }
 
  // For all other cases.
  template <typename T1, typename T2>
  inline bool      MLValuesDifferWOM(T1        a, T2        b)  { return a != b; }

  inline bool      MLValueIs0WOM(MLint8    a) { return a == 0; }
  inline bool      MLValueIs0WOM(MLuint8   a) { return a == 0; }
  inline bool      MLValueIs0WOM(MLint16   a) { return a == 0; }
  inline bool      MLValueIs0WOM(MLuint16  a) { return a == 0; }
  inline bool      MLValueIs0WOM(MLint32   a) { return a == 0; }
  inline bool      MLValueIs0WOM(MLuint32  a) { return a == 0; }
  inline bool      MLValueIs0WOM(MLfloat   a) { return MLfabs(a) < ML_FLOAT_MIN  ; }
  inline bool      MLValueIs0WOM(MLdouble  a) { return MLfabs(a) < ML_DOUBLE_MIN ; }
  inline bool      MLValueIs0WOM(MLldouble a) { return MLfabs(a) < ML_LDOUBLE_MIN; }
  inline bool      MLValueIs0WOM(MLuint64  a) { return a == 0; }
  inline bool      MLValueIs0WOM(MLint64   a) { return a == 0; }
 
  // For all other cases.
  template <typename T1>
  inline bool      MLValueIs0WOM(T1        a) { return a == 0; }
 
#endif // __mlTypeDefTraits_H