Utils.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#pragma once
 
#include "MantidKernel/DllConfig.h"
#include <cmath>
#include <vector>
 
namespace Mantid {
namespace Kernel {
 
namespace Utils {
 
//------------------------------------------------------------------------------------------------
inline long round(double x) { return long(x + (x < 0 ? -0.5 : +0.5)); }
 
//------------------------------------------------------------------------------------------------
inline double rounddbl(double r) { return (r > 0.0) ? std::floor(r + 0.5) : std::ceil(r - 0.5); }
 
//------------------------------------------------------------------------------------------------
inline double roundToSF(double r, int f) {
  double factor = pow(10.0, f - ceil(log10(fabs(r))));
  return rounddbl(r * factor) / factor;
}
 
//------------------------------------------------------------------------------------------------
inline double roundToDP(double r, int d) {
  double m = pow(10.0, d);
  return (int)r + (1.0 / m) * rounddbl((r - (int)r) * m);
}
 
namespace NestedForLoop {
//------------------------------------------------------------------------------------------------
inline void SetUp(const size_t numDims, size_t *out, const size_t value = 0) {
  // Allocate and clear to 0.
  for (size_t d = 0; d < numDims; d++)
    out[d] = value;
}
 
//------------------------------------------------------------------------------------------------
inline void SetUpIndexMaker(const size_t numDims, size_t *out, const size_t *index_max) {
  // Allocate and start at 1
  for (size_t d = 0; d < numDims; d++)
    out[d] = 1;
 
  for (size_t d = 1; d < numDims; d++)
    out[d] = out[d - 1] * index_max[d - 1];
}
 
//------------------------------------------------------------------------------------------------
inline size_t GetLinearIndex(const size_t numDims, size_t *index, size_t *index_maker) {
  size_t out = 0;
  for (size_t d = 0; d < numDims; d++)
    out += index[d] * index_maker[d];
  return out;
}
 
//------------------------------------------------------------------------------------------------
inline void GetIndicesFromLinearIndex(const size_t numDims, const size_t linear_index, const size_t *index_maker,
                                      const size_t *index_max, size_t *out_indices) {
  for (size_t d = 0; d < numDims; d++) {
    out_indices[d] = (linear_index / index_maker[d]) % index_max[d];
  }
}
//------------------------------------------------------------------------------------------------
inline bool Increment(const size_t numDims, size_t *index, size_t *index_max, size_t *index_min) {
  size_t d = 0;
  while (d < numDims) {
    // Add one to the index in this dimension
    if (++index[d] >= index_max[d]) {
      // Roll this counter back to 0 (or whatever the min is)
      index[d] = index_min[d];
      // Go up one in a higher dimension
      d++;
      // Reached the maximum of the last dimension. Time to exit the entire
      // loop.
      if (d == numDims)
        return true;
    } else
      return false;
  }
  return false;
}
 
//------------------------------------------------------------------------------------------------
inline bool Increment(const size_t numDims, size_t *index, size_t *index_max) {
  size_t d = 0;
  while (d < numDims) {
    // Add one to the index in this dimension
    if (++index[d] >= index_max[d]) {
      // Roll this counter back to 0
      index[d] = 0;
      // Go up one in a higher dimension
      d++;
      // Reached the maximum of the last dimension. Time to exit the entire
      // loop.
      if (d == numDims)
        return true;
    } else
      return false;
  }
  return false;
}
 
} // namespace NestedForLoop
  //------------------------------------------------------------------------------------------------
inline void getIndicesFromLinearIndex(const size_t linear_index, size_t const *const numBins, const size_t numDims,
                                      size_t *const out_indices) {
  // number of bins in first dimension
  size_t nBins = *(numBins + 0);
  // first index
  size_t ind = linear_index % nBins;
  *(out_indices + 0) = ind;
  // what left in linear index after first was removed;
  size_t rest = linear_index / nBins;
  for (size_t d = 1; d < numDims; d++) {
    nBins = *(numBins + d);
    ind = rest % nBins;
    *(out_indices + d) = ind;
    rest = rest / nBins;
  }
}
//------------------------------------------------------------------------------------------------
inline std::vector<size_t> getIndicesFromLinearIndex(const size_t linear_index, const std::vector<size_t> &num_bins) {
  std::vector<size_t> out_indices;
  if (!num_bins.empty()) {
    size_t nBins = num_bins.size();
    out_indices.resize(nBins);
    getIndicesFromLinearIndex(linear_index, &num_bins[0], nBins, &out_indices[0]);
  }
  return out_indices;
}
 
inline bool isNeighbourOfSubject(const size_t ndims, const size_t neighbour_linear_index, const size_t *subject_indices,
                                 const size_t *num_bins, const size_t *index_max, const std::vector<int> &widths) {
  for (size_t ind = 0; ind < ndims; ++ind) {
    size_t neigh_index = (neighbour_linear_index / num_bins[ind]) % index_max[ind];
    const long double subj = static_cast<long double>(subject_indices[ind]);
    const long double neigh = static_cast<long double>(neigh_index);
    const long double diff = std::abs(subj - neigh);
    if (diff > (widths[ind] >> 1))
      return false;
  }
  return true;
}
 
} // namespace Utils
 
} // namespace Kernel
} // namespace Mantid