ESign.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2014 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Oliver Frost                                             *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
#pragma once
 
#include <algorithm>
#include <cstdlib> // for abs
#include <cmath> // for isnan
#include <climits> // for SHRT_MIN
 
namespace Belle2 {
  namespace TrackFindingCDC {
 
    namespace ESignUtil {
 
      enum ESign : signed short {
        c_Plus = 1,
 
        c_Minus = -1,
 
        c_Zero = 0,
 
        c_Invalid = SHRT_MIN,
      };
 
      inline ESign opposite(ESign s)
      { return static_cast<ESign>(-s); }
 
      inline bool isValid(ESign s)
      { return std::abs(s) <= 1; }
 
      static inline ESign common(ESign n1, ESign n2)
      {
        return ((not isValid(n1) and not isValid(n2)) ?
                ESign::c_Invalid :
                static_cast<ESign>((not(n1 <= 0) and not(n2 <= 0)) - (not(n1 >= 0) and not(n2 >= 0))));
      }
 
      static inline ESign common(float n1, float n2)
      {
        return ((std::isnan(n1) and std::isnan(n2)) ?
                ESign::c_Invalid :
                static_cast<ESign>((not(n1 <= 0) and not(n2 <= 0)) - (not(n1 >= 0) and not(n2 >= 0))));
      }
 
      static inline ESign common(float n1, float n2, float n3, float n4)
      {
        return ((std::isnan(n1) and std::isnan(n2) and std::isnan(n3) and std::isnan(n4)) ?
                ESign::c_Invalid :
                static_cast<ESign>((not(n1 <= 0) and not(n2 <= 0) and not(n3 <= 0) and not(n4 <= 0)) -
                                   (not(n1 >= 0) and not(n2 >= 0) and not(n3 >= 0) and not(n4 >= 0))));
      }
 
      template<class FloatRange>
      static inline ESign common(const FloatRange& as)
      {
        bool allNaN = std::all_of(as.begin(), as.end(), [](float a) { return std::isnan(a); });
        if (allNaN) {
          return ESign::c_Invalid;
        } else {
          return static_cast<ESign>(std::all_of(as.begin(), as.end(), [](float a) { return not(a <= 0); }) -
          std::all_of(as.begin(), as.end(), [](float a) { return not(a >= 0); }));
        }
      }
 
    };
 
    using ESign = ESignUtil::ESign;
 
    inline ESign sign(double x)
    {
      return std::isnan(x) ? ESign::c_Invalid : (std::signbit(x) ? ESign::c_Minus : ESign::c_Plus);
    }
 
    inline ESign sign(int x)
    {
      return static_cast<ESign>((x > 0) - (x < 0));
    }
 
    template<class Enum, Enum invalid = Enum::c_Invalid>
    inline ESign sign(Enum x)
    {
      if (x == Enum::c_Invalid) return ESign::c_Invalid;
      return sign(static_cast<int>(x));
    }
  }
 
}