[ML] Trap potential cause of SIGFPE (#1351)

Author: tveasey

docs/CHANGELOG.asciidoc

@@ -72,6 +72,7 @@
 === Bug Fixes
 
 * Better interrupt handling during named pipe connection. (See {ml-pull}1311[#1311].)
+* Trap potential cause of SIGFPE. (See {ml-pull}1351[#1351], issue: {ml-issue}1348[#1348].)
 
 == {es} version 7.8.0
 

include/maths/CIntegerTools.h

@@ -10,20 +10,18 @@
 #include <maths/ImportExport.h>
 
 #include <cstddef>
+#include <cstdint>
 #include <vector>
 
-#include <stdint.h>
-
 namespace ml {
 namespace maths {
 
-//! \brief A collection of utility functions for operations we do
-//! integers.
+//! \brief A collection of utility functions for operations we do on integers.
 //!
 //! DESCRIPTION:\n
-//! This implements common integer operations: checking alignment,
-//! rounding and so on. Also any integer operations we sometimes
-//! need that can be done cheaply some "bit twiddling hack".
+//! This implements common integer operations: checking alignment, rounding
+//! and so on. Also any integer operations we sometimes need that can be done
+//! cheaply with some "bit twiddling hack".
 class MATHS_EXPORT CIntegerTools {
 public:
  //! Checks whether a double holds an an integer.
@@ -33,16 +31,17 @@ class MATHS_EXPORT CIntegerTools {
  //! <pre class="fragment">
  //! \f$p = \left \lceil \log_2(x) \right \rceil\f$
  //! </pre>
- static std::size_t nextPow2(uint64_t x);
+ static std::size_t nextPow2(std::uint64_t x);
 
  //! Computes the integer with the reverse of the bits of the binary
  //! representation of \p x.
- static uint64_t reverseBits(uint64_t x);
+ static std::uint64_t reverseBits(std::uint64_t x);
 
  //! Check if \p value is \p alignment aligned.
  template<typename INT_TYPE>
  static inline bool aligned(INT_TYPE value, INT_TYPE alignment) {
- return (value % alignment) == static_cast<INT_TYPE>(0);
+ return alignment == static_cast<INT_TYPE>(0) ||
+ (value % alignment) == static_cast<INT_TYPE>(0);
  }
 
  //! Align \p value to \p alignment rounding up.
@@ -52,7 +51,7 @@ class MATHS_EXPORT CIntegerTools {
  //! \note It is assumed that \p value and \p alignment are integral types.
  template<typename INT_TYPE>
  static inline INT_TYPE ceil(INT_TYPE value, INT_TYPE alignment) {
- INT_TYPE result = CIntegerTools::floor(value, alignment);
+ INT_TYPE result{floor(value, alignment)};
  if (result != value) {
  result += alignment;
  }
@@ -66,7 +65,10 @@ class MATHS_EXPORT CIntegerTools {
  //! \note It is assumed that \p value and \p alignment are integral types.
  template<typename INT_TYPE>
  static inline INT_TYPE floor(INT_TYPE value, INT_TYPE alignment) {
- INT_TYPE result = (value / alignment) * alignment;
+ if (alignment == 0) {
+ return value;
+ }
+ INT_TYPE result{(value / alignment) * alignment};
  return result == value ? result : (value < 0 ? result - alignment : result);
  }
 
@@ -78,7 +80,7 @@ class MATHS_EXPORT CIntegerTools {
  //! \note It is assumed that \p value and \p alignment are integral types.
  template<typename INT_TYPE>
  static inline INT_TYPE strictInfimum(INT_TYPE value, INT_TYPE alignment) {
- INT_TYPE result = floor(value, alignment);
+ INT_TYPE result{floor(value, alignment)};
 
  // Since this is a strict lower bound we need to trap the case the
  // value is an exact multiple of the alignment.
@@ -121,7 +123,7 @@ class MATHS_EXPORT CIntegerTools {
 
  // Repeatedly apply Euclid's algorithm and use the fact that
  // gcd(a, b, c) = gcd(gcd(a, b), c).
- INT_TYPE result = gcd(c[0], c[1]);
+ INT_TYPE result{gcd(c[0], c[1])};
  for (std::size_t i = 2; i < c.size(); ++i) {
  result = gcd(result, c[i]);
  }

lib/maths/CIntegerTools.cc

@@ -16,19 +16,19 @@ namespace maths {
 
 bool CIntegerTools::isInteger(double value, double tolerance) {
  double integerPart;
- double remainder = std::modf(value, &integerPart);
+ double remainder{std::modf(value, &integerPart)};
  return remainder <= tolerance * integerPart;
 }
 
-std::size_t CIntegerTools::nextPow2(uint64_t x) {
+std::size_t CIntegerTools::nextPow2(std::uint64_t x) {
  // This is just a binary search for the highest non-zero bit.
 
- static const std::size_t SHIFTS[] = {32u, 16u, 8u, 4u, 2u, 1u};
- static const uint64_t MASKS[] = {0xffffffff, 0xffff, 0xff, 0xf, 0x3, 0x1};
+ static const std::size_t SHIFTS[]{32u, 16u, 8u, 4u, 2u, 1u};
+ static const std::uint64_t MASKS[]{0xffffffff, 0xffff, 0xff, 0xf, 0x3, 0x1};
 
- std::size_t result = 0u;
+ std::size_t result{0};
  for (std::size_t i = 0; i < 6; ++i) {
- uint64_t y = (x >> SHIFTS[i]);
+ std::uint64_t y = (x >> SHIFTS[i]);
  if (y & MASKS[i]) {
  result += SHIFTS[i];
  x = y;
@@ -37,7 +37,7 @@ std::size_t CIntegerTools::nextPow2(uint64_t x) {
  return result + static_cast<std::size_t>(x);
 }
 
-uint64_t CIntegerTools::reverseBits(uint64_t x) {
+std::uint64_t CIntegerTools::reverseBits(std::uint64_t x) {
  // Uses the standard "parallel" approach of swapping adjacent bits, then
  // adjacent pairs, quadruples, etc.
  x = ((x >> 1) & 0x5555555555555555) | ((x << 1) & 0xaaaaaaaaaaaaaaaa);
@@ -55,7 +55,7 @@ double CIntegerTools::binomial(unsigned int n, unsigned int k) {
  return 0.0;
  }
 
- double result = 1.0;
+ double result{1.0};
  k = std::min(k, n - k);
  for (unsigned int k_ = k; k_ > 0; --k_, --n) {
  result *= static_cast<double>(n) / static_cast<double>(k_);