NumericAxis.cpp

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 +
//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidAPI/NumericAxis.h"
#include "MantidKernel/Exception.h"
#include "MantidKernel/FloatingPointComparison.h"
#include "MantidKernel/VectorHelper.h"
 
#include <boost/format.hpp>
#include <cmath>
#include <utility>
 
#include "MantidKernel/Logger.h"
namespace {
Mantid::Kernel::Logger g_log("NumericAxis");
 
class EqualWithinTolerance {
public:
  explicit EqualWithinTolerance(double tolerance) : m_tolerance(tolerance) {};
  bool operator()(double a, double b) {
    if (std::isnan(a) && std::isnan(b))
      return true;
    if (std::isinf(a) && std::isinf(b))
      return true;
    return Mantid::Kernel::withinAbsoluteDifference(a, b, m_tolerance);
  }
 
private:
  double m_tolerance;
};
} // namespace
 
namespace Mantid::API {
 
//------------------------------------------------------------------------------
// public members
//------------------------------------------------------------------------------
 
size_t NumericAxis::indexOfValue(const double value) const {
  return Mantid::Kernel::VectorHelper::indexOfValueFromCenters(m_values, value);
}
 
NumericAxis::NumericAxis(const std::size_t &length) : Axis(), m_values(length) {}
 
NumericAxis::NumericAxis(std::vector<double> centres) : Axis(), m_values(std::move(centres)) {}
 
NumericAxis::NumericAxis(std::span<double const> centres) : Axis(), m_values(centres.begin(), centres.end()) {}
 
Axis *NumericAxis::clone(const MatrixWorkspace *const parentWorkspace) {
  UNUSED_ARG(parentWorkspace)
  return new NumericAxis(*this);
}
 
Axis *NumericAxis::clone(const std::size_t length, const MatrixWorkspace *const parentWorkspace) {
  UNUSED_ARG(parentWorkspace)
  auto newAxis = new NumericAxis(*this);
  newAxis->m_values.clear();
  newAxis->m_values.resize(length);
  return newAxis;
}
 
double NumericAxis::operator()(const std::size_t &index, const std::size_t &verticalIndex) const {
  UNUSED_ARG(verticalIndex)
  if (index >= length()) {
    throw Kernel::Exception::IndexError(index, length() - 1, "NumericAxis: Index out of range.");
  }
 
  return m_values[index];
}
 
void NumericAxis::setValue(const std::size_t &index, const double &value) {
  if (index >= length()) {
    throw Kernel::Exception::IndexError(index, length() - 1, "NumericAxis: Index out of range.");
  }
 
  m_values[index] = value;
}
 
bool NumericAxis::operator==(const NumericAxis &axis2) const { return equalWithinTolerance(axis2, 1e-15); }
 
bool NumericAxis::operator==(const Axis &axis2) const { return equalWithinTolerance(axis2, 1e-15); }
 
bool NumericAxis::equalWithinTolerance(const Axis &axis2, const double tolerance) const {
  if (length() != axis2.length()) {
    return false;
  }
  const auto *spec2 = dynamic_cast<const NumericAxis *>(&axis2);
  if (!spec2) {
    return false;
  }
  // Check each value is within tolerance
  EqualWithinTolerance comparison(tolerance);
  return std::equal(m_values.begin(), m_values.end(), spec2->m_values.begin(), comparison);
}
 
std::string NumericAxis::label(const std::size_t &index) const { return formatLabel((*this)(index)); }
 
std::string NumericAxis::formatLabel(const double value) const {
  std::string numberLabel = boost::str(boost::format("%.13f") % value);
 
  // Remove all zeros up to the decimal place or a non zero value
  auto it = numberLabel.end() - 1;
  for (; it != numberLabel.begin(); --it) {
    if (*it == '0') {
      it = numberLabel.erase(it);
    } else if (*it == '.') {
      numberLabel.erase(it);
      break;
    } else {
      break;
    }
  }
 
  return numberLabel;
}
 
std::vector<double> NumericAxis::createBinBoundaries() const {
  std::vector<double> result;
  result.reserve(m_values.size());
  Kernel::VectorHelper::convertToBinBoundary(m_values, result);
  return result;
}
 
const std::vector<double> &NumericAxis::getValues() const { return m_values; }
 
//------------------------------------------------------------------------------
// Protected members
//------------------------------------------------------------------------------
 
NumericAxis::NumericAxis() = default;
 
} // namespace Mantid::API