VectorHelper.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2007 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
 
//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidKernel/DllConfig.h"
#include <cmath>
#include <functional>
#include <stdexcept>
#include <vector>
 
namespace Mantid {
namespace Kernel {
/*
    A collection of functions for use with vectors
 
    @author Laurent C Chapon, Rutherford Appleton Laboratory
    @date 16/12/2008
 */
namespace VectorHelper {
int MANTID_KERNEL_DLL createAxisFromRebinParams(const std::vector<double> &params, std::vector<double> &xnew,
                                                const bool resize_xnew = true, const bool full_bins_only = false,
                                                const double xMinHint = std::nan(""),
                                                const double xMaxHint = std::nan(""),
                                                const bool useReverseLogarithmic = false, const double power = -1);
 
void MANTID_KERNEL_DLL rebin(const std::vector<double> &xold, const std::vector<double> &yold,
                             const std::vector<double> &eold, const std::vector<double> &xnew,
                             std::vector<double> &ynew, std::vector<double> &enew, bool distribution,
                             bool addition = false);
 
// New method to rebin Histogram data, should be faster than previous one
void MANTID_KERNEL_DLL rebinHistogram(const std::vector<double> &xold, const std::vector<double> &yold,
                                      const std::vector<double> &eold, const std::vector<double> &xnew,
                                      std::vector<double> &ynew, std::vector<double> &enew, bool addition);
 
void MANTID_KERNEL_DLL convertToBinCentre(const std::vector<double> &bin_edges, std::vector<double> &bin_centres);
 
void MANTID_KERNEL_DLL convertToBinBoundary(const std::vector<double> &bin_centers, std::vector<double> &bin_edges);
 
size_t MANTID_KERNEL_DLL indexOfValueFromCenters(const std::vector<double> &bin_centers, const double value);
 
int MANTID_KERNEL_DLL indexOfValueFromCentersNoThrow(const std::vector<double> &bin_centers, const double value);
 
size_t MANTID_KERNEL_DLL indexOfValueFromEdges(const std::vector<double> &bin_edges, const double value);
 
bool MANTID_KERNEL_DLL isConstantValue(const std::vector<double> &arra);
 
template <typename T> std::vector<T> flattenVector(const std::vector<std::vector<T>> &v) {
  std::vector<T> flattened;
 
  for (const auto &subVector : v) {
    flattened.insert(flattened.end(), subVector.begin(), subVector.end());
  }
 
  return flattened;
}
 
template <typename NumT> MANTID_KERNEL_DLL std::vector<NumT> splitStringIntoVector(std::string listString);
 
MANTID_KERNEL_DLL int getBinIndex(const std::vector<double> &bins, const double value);
 
// Do running average of input vector within specified range, considering
// heterogeneous bin-boundaries
// if such boundaries are provided
MANTID_KERNEL_DLL void smoothInRange(const std::vector<double> &input, std::vector<double> &output, double avrgInterval,
                                     std::vector<double> const *const binBndrs = nullptr, size_t startIndex = 0,
                                     size_t endIndex = 0, std::vector<double> *const outBins = nullptr);
 
//-------------------------------------------------------------------------------------
template <typename T> T lengthVector(const std::vector<T> &x) {
  T total = 0;
  for (size_t i = 0; i < x.size(); i++)
    total += x[i] * x[i];
  // Length is sqrt
  total = sqrt(total);
  return total;
}
// Scalar product of two vectors
template <typename T> T scalar_prod(const std::vector<T> &v1, const std::vector<T> &v2) {
  if (v1.size() != v2.size())
    throw std::invalid_argument(" scalar product is defined only for the "
                                "vectors of the equivalent length");
  T total = 0;
  for (size_t i = 0; i < v1.size(); i++)
    total += v1[i] * v2[i];
 
  return total;
}
// Scalar product of two different type vectors which allow static cast to
// double
template <typename T, typename U> double scalar_prod(const std::vector<T> &v1, const std::vector<U> &v2) {
  if (v1.size() != v2.size())
    throw std::invalid_argument(" scalar product is defined only for the "
                                "vectors of the equivalient length");
  double total = 0;
  for (size_t i = 0; i < v1.size(); i++)
    total += double(v1[i]) * double(v2[i]);
 
  return total;
}
 
//-------------------------------------------------------------------------------------
template <typename T> std::vector<T> normalizeVector(const std::vector<T> &x) {
  // Ignore 0-sized vectors
  if (x.size() == 0)
    return x;
  std::vector<T> out(x.size(), 0);
  // Length is sqrt
  T length = lengthVector(x);
  for (size_t i = 0; i < x.size(); i++)
    out[i] = x[i] / length;
  return out;
}
 
template <class T> struct SumGaussError {
  SumGaussError() = default;
  inline T operator()(const T &l, const T &r) const { return sqrt(l * l + r * r); }
};
 
template <class T> struct AddVariance {
  AddVariance() = default;
  T operator()(const T &r, const T &x) const { return sqrt(r * r + x); }
};
 
template <class T> struct SumSquares {
  SumSquares() = default;
  T operator()(const T &r, const T &x) const { return (r + x * x); }
};
 
template <class T> struct TimesSquares {
  TimesSquares() = default;
  T operator()(const T &l, const T &r) const { return (r * r * l * l); }
};
 
template <class T> struct Squares {
  Squares() = default;
  T operator()(const T &x) const { return (x * x); }
};
 
template <class T> struct Log {
  Log() = default;
  T operator()(const T &x) const {
    if (x <= 0)
      throw std::range_error("Attempt to take logarithm of zero or negative number.");
    return std::log(x);
  }
};
 
// Non-throwing version of the Log functor
template <class T> struct LogNoThrow {
  LogNoThrow() = default;
  // Returns the logarithm of the argument
  T operator()(const T &x) const { return std::log(x); }
};
 
template <class T> struct DividesNonNull {
  DividesNonNull() = default;
  T operator()(const T &l, const T &r) const {
    if (std::fabs(r) < 1e-12)
      return l;
    return l / r;
  }
};
 
template <class T> struct SimpleAverage {
  SimpleAverage() = default;
  T operator()(const T &x, const T &y) const { return static_cast<T>(0.5) * (x + y); }
};
 
} // namespace VectorHelper
} // namespace Kernel
} // namespace Mantid