TableColumn.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
 
#include <boost/numeric/conversion/cast.hpp>
#include <cmath>
#include <limits>
#include <memory>
#include <sstream>
#include <vector>
 
#include "MantidAPI/Column.h"
#include "MantidDataObjects/DllConfig.h"
#include "MantidKernel/FloatingPointComparison.h"
#include "MantidKernel/V3D.h"
 
namespace Mantid {
namespace DataObjects {
 
// Apply visibility attribute for non-MSVC builds (needed for clang/OSX).
#if defined(_MSC_VER)
template <class Type> class TableColumn : public API::Column {
#else
template <class Type> class MANTID_DATAOBJECTS_DLL TableColumn : public API::Column {
#endif
  struct InconvertibleToDoubleType {
    InconvertibleToDoubleType(const Type &) {}
    InconvertibleToDoubleType(const double &) {}
    operator double() const {
      throw std::runtime_error(std::string("Cannot convert ") + typeid(Type).name() + " to double.");
    }
    operator Type() const {
      throw std::runtime_error(std::string("Cannot convert double to ") + typeid(Type).name() + ".");
    }
  };
 
public:
  TableColumn() {
    int length = sizeof(Type);
    std::string name = std::string(typeid(Type).name());
    if ((name.find('i') != std::string::npos) || (name.find('l') != std::string::npos) ||
        (name.find('x') != std::string::npos)) {
      if (length == 4) {
        this->m_type = "int";
      }
      if (length == 8) {
        this->m_type = "int64";
      }
    }
    if (name.find('f') != std::string::npos) {
      this->m_type = "float";
    }
    if (name.find('d') != std::string::npos) {
      this->m_type = "double";
    }
    if (name.find('u') != std::string::npos) {
      if (length == 4) {
        this->m_type = "uint32_t";
      }
      if (length == 8) {
        this->m_type = "uint64_t";
      }
    }
    if (this->m_type.empty()) {
      this->m_type = name;
    }
  }
 
  // TableColumn();
  size_t size() const override { return m_data.size(); }
  const std::type_info &get_type_info() const override { return typeid(Type); }
  const std::type_info &get_pointer_type_info() const override { return typeid(Type *); }
  void print(size_t index, std::ostream &s) const override { s << m_data[index]; }
  void read(size_t index, const std::string &text) override;
  void read(const size_t index, std::istringstream &in) override;
  bool isBool() const override { return typeid(Type) == typeid(API::Boolean); }
  bool isNumber() const override { return std::is_convertible<Type, double>::value; }
  long int sizeOfData() const override { return static_cast<long int>(m_data.size() * sizeof(Type)); }
  TableColumn *clone() const override { return new TableColumn(*this); }
 
  template <typename T> double convertToDouble(const T &value) const {
    using DoubleType =
        typename std::conditional<std::is_convertible<double, T>::value, T, InconvertibleToDoubleType>::type;
    return boost::numeric_cast<double, DoubleType>(value);
  }
 
  double convertToDouble(const std::string &value) const { return std::stod(value); }
 
  double toDouble(size_t i) const override { return convertToDouble(m_data[i]); }
 
  void fromDouble(size_t i, double value) override {
    using DoubleType =
        typename std::conditional<std::is_convertible<double, Type>::value, Type, InconvertibleToDoubleType>::type;
    m_data[i] = static_cast<Type>(boost::numeric_cast<DoubleType, double>(value));
  }
 
  std::vector<Type> &data() { return m_data; }
  const std::vector<Type> &data() const { return m_data; }
  Type *dataArray() { return &m_data[0]; }
 
  double operator[](size_t i) const override {
    try {
      return convertToDouble(m_data[i]);
    } catch (...) {
      return std::numeric_limits<double>::quiet_NaN();
    }
  }
 
  void sortIndex(bool ascending, size_t start, size_t end, std::vector<size_t> &indexVec,
                 std::vector<std::pair<size_t, size_t>> &equalRanges) const override;
 
  void sortValues(const std::vector<size_t> &indexVec) override;
 
  bool equals(const Column &otherColumn, double tolerance, bool const nanEqual = false) const override {
    if (!possibleToCompare(otherColumn)) {
      return false;
    }
    const auto &otherColumnTyped = static_cast<const TableColumn<Type> &>(otherColumn);
    const auto &otherData = otherColumnTyped.data();
    return compareVectors(otherData, tolerance, nanEqual);
  }
 
  bool equalsRelErr(const Column &otherColumn, double tolerance, bool const nanEqual = false) const override {
    if (!possibleToCompare(otherColumn)) {
      return false;
    }
    const auto &otherColumnTyped = static_cast<const TableColumn<Type> &>(otherColumn);
    const auto &otherData = otherColumnTyped.data();
    return compareVectorsRelError(otherData, tolerance, nanEqual);
  }
 
protected:
  void resize(size_t count) override { m_data.resize(count); }
  void insert(size_t index) override {
    if (index < m_data.size())
      m_data.insert(m_data.begin() + index, Type());
    else
      m_data.emplace_back();
  }
  void remove(size_t index) override { m_data.erase(m_data.begin() + index); }
  void *void_pointer(size_t index) override { return &m_data.at(index); }
  const void *void_pointer(size_t index) const override { return &m_data.at(index); }
 
private:
  std::vector<Type> m_data;
  friend class TableWorkspace;
 
  // helper function template for equality
  bool compareVectors(const std::vector<Type> &newVector, double tolerance, bool const nanEqual = false) const {
    return compareVectors(newVector, tolerance, nanEqual, std::is_integral<Type>());
  }
 
  bool compareVectors(const std::vector<Type> &newVector, double tolerance, bool const, std::true_type) const {
    for (size_t i = 0; i < m_data.size(); i++) {
      if (!Kernel::withinAbsoluteDifference<Type, double>(m_data[i], newVector[i], tolerance)) {
        return false;
      }
    }
    return true;
  }
 
  bool compareVectors(const std::vector<Type> &newVector, double tolerance, bool const nanEqual,
                      std::false_type) const {
    for (size_t i = 0; i < m_data.size(); i++) {
      if (nanEqual && std::isnan(m_data[i]) && std::isnan(newVector[i])) {
        continue;
      } else if (!Kernel::withinAbsoluteDifference<Type, double>(m_data[i], newVector[i], tolerance)) {
        return false;
      }
    }
    return true;
  }
 
  // helper function template for equality with relative error
  bool compareVectorsRelError(const std::vector<Type> &newVector, double tolerance, bool const nanEqual = false) const {
    return compareVectorsRelError(newVector, tolerance, nanEqual, std::is_integral<Type>());
  }
 
  bool compareVectorsRelError(const std::vector<Type> &newVector, double tolerance, bool const, std::true_type) const {
    for (size_t i = 0; i < m_data.size(); i++) {
      if (!Kernel::withinRelativeDifference<Type, double>(m_data[i], newVector[i], tolerance)) {
        return false;
      }
    }
    return true;
  }
 
  bool compareVectorsRelError(const std::vector<Type> &newVector, double tolerance, bool const nanEqual,
                              std::false_type) const {
    for (size_t i = 0; i < m_data.size(); i++) {
      if (nanEqual && std::isnan(m_data[i]) && std::isnan(newVector[i])) {
        continue;
      } else if (!Kernel::withinRelativeDifference<Type, double>(m_data[i], newVector[i], tolerance)) {
        return false;
      }
    }
    return true;
  }
};
 
template <>
inline bool TableColumn<std::string>::compareVectors(const std::vector<std::string> &newVector, double,
                                                     bool const) const {
  for (size_t i = 0; i < m_data.size(); i++) {
    if (m_data[i] != newVector[i]) {
      return false;
    }
  }
  return true;
}
 
template <>
inline bool TableColumn<API::Boolean>::compareVectors(const std::vector<API::Boolean> &newVector, double,
                                                      bool const) const {
  for (size_t i = 0; i < m_data.size(); i++) {
    if (!(m_data[i] == newVector[i])) {
      return false;
    }
  }
  return true;
}
 
template <>
inline bool TableColumn<Kernel::V3D>::compareVectors(const std::vector<Kernel::V3D> &newVector, double tolerance,
                                                     bool const nanEqual) const {
  // must specify for it to use pass-by-references
  for (std::size_t i = 0; i < m_data.size(); i++) {
    if (nanEqual && Kernel::V3D::isnan(m_data[i]) && Kernel::V3D::isnan(newVector[i])) {
      continue;
    } else if (!Kernel::withinAbsoluteDifference(m_data[i], newVector[i], tolerance)) {
      return false;
    }
  }
  return true;
}
 
template <>
inline bool TableColumn<std::string>::compareVectorsRelError(const std::vector<std::string> &newVector,
                                                             double tolerance, bool const) const {
  return compareVectors(newVector, tolerance);
}
 
template <>
inline bool TableColumn<API::Boolean>::compareVectorsRelError(const std::vector<API::Boolean> &newVector,
                                                              double tolerance, bool const) const {
  return compareVectors(newVector, tolerance);
}
 
template <>
inline bool TableColumn<Kernel::V3D>::compareVectorsRelError(const std::vector<Kernel::V3D> &newVector,
                                                             double tolerance, bool const nanEqual) const {
  // must specify for it to use pass-by-references
  for (size_t i = 0; i < m_data.size(); i++) {
    if (nanEqual && Kernel::V3D::isnan(m_data[i]) && Kernel::V3D::isnan(newVector[i])) {
      continue;
    } else if (!Kernel::withinRelativeDifference(m_data[i], newVector[i], tolerance)) {
      return false;
    }
  }
  return true;
}
 
template <> inline void TableColumn<std::string>::read(size_t index, const std::string &text) {
  /* As opposed to other types, assigning strings via a stream does not work if
   * it contains a whitespace character, so instead the assignment operator is
   * used.
   */
  m_data[index] = text;
}
 
template <> inline void TableColumn<std::string>::read(size_t index, std::istringstream &text) {
  /* As opposed to other types, assigning strings via a stream does not work if
   * it contains a whitespace character, so instead the assignment operator is
   * used.
   */
  m_data[index] = text.str();
}
 
template <typename Type> void TableColumn<Type>::read(size_t index, const std::string &text) {
  std::istringstream istr(text);
  istr >> m_data[index];
}
 
template <typename Type> void TableColumn<Type>::read(size_t index, std::istringstream &in) {
  Type t;
  in >> t;
  m_data[index] = t;
}
 
namespace {
template <typename Type> class CompareValues {
  const std::vector<Type> &m_data;
  const bool m_ascending;
 
public:
  CompareValues(const TableColumn<Type> &column, bool ascending) : m_data(column.data()), m_ascending(ascending) {}
  bool operator()(size_t i, size_t j) {
    return m_ascending ? m_data[i] < m_data[j] : !(m_data[i] < m_data[j] || m_data[i] == m_data[j]);
  }
};
} // namespace
 
template <typename Type>
void TableColumn<Type>::sortIndex(bool ascending, size_t start, size_t end, std::vector<size_t> &indexVec,
                                  std::vector<std::pair<size_t, size_t>> &equalRanges) const {
  equalRanges.clear();
 
  const size_t n = m_data.size();
  if (n == 0) {
    return;
  }
 
  auto iBegin = indexVec.begin() + start;
  auto iEnd = indexVec.begin() + end;
 
  std::stable_sort(iBegin, iEnd, CompareValues<Type>(*this, ascending));
 
  bool same = false;
  size_t eqStart = 0;
  for (auto i = iBegin + 1; i != iEnd; ++i) {
    if (!same) {
      if (m_data[*i] == m_data[*(i - 1)]) {
        eqStart = static_cast<size_t>(std::distance(indexVec.begin(), i - 1));
        same = true;
      }
    } else {
      if (m_data[*i] != m_data[*(i - 1)]) {
        auto p = std::make_pair(eqStart, static_cast<size_t>(std::distance(indexVec.begin(), i)));
        equalRanges.emplace_back(p);
        same = false;
      }
    }
  }
 
  // last elements are equal
  if (same) {
    auto p = std::make_pair(eqStart, static_cast<size_t>(std::distance(indexVec.begin(), iEnd)));
    equalRanges.emplace_back(p);
  }
}
 
template <typename Type> void TableColumn<Type>::sortValues(const std::vector<size_t> &indexVec) {
  assert(m_data.size() == indexVec.size());
  std::vector<Type> sortedData(m_data.size());
 
  auto sortedIt = sortedData.begin();
  for (auto idx = indexVec.begin(); idx != indexVec.end(); ++idx, ++sortedIt) {
    *sortedIt = m_data[*idx];
  }
 
  std::swap(m_data, sortedData);
}
 
template <> inline double TableColumn<API::Boolean>::toDouble(size_t i) const { return m_data[i] ? 1.0 : 0.0; }
 
template <> inline void TableColumn<API::Boolean>::fromDouble(size_t i, double value) { m_data[i] = value != 0.0; }
 
template <class T> class TableColumn_ptr : public std::shared_ptr<TableColumn<T>> {
public:
  TableColumn_ptr(std::shared_ptr<API::Column> c)
      : std::shared_ptr<TableColumn<T>>(std::dynamic_pointer_cast<TableColumn<T>>(c)) {
    if (!this->get()) {
      std::string str = "Data type of column " + c->name() + " does not match " + typeid(T).name();
      throw std::runtime_error(str);
    }
  }
};
 
template <> class TableColumn_ptr<bool> : public TableColumn_ptr<API::Boolean> {
public:
  TableColumn_ptr(const std::shared_ptr<API::Column> &c) : TableColumn_ptr<API::Boolean>(c) {
    if (!this->get()) {
      std::string str = "Data type of column " + c->name() + " does not match " + typeid(API::Boolean).name();
      throw std::runtime_error(str);
    }
  }
};
 
} // namespace DataObjects
} // Namespace Mantid
 
/*
    Macro to declare a type to be used with TableColumn.
    DataType is the actual C++ type. TypeName is a symbolic name, used in
   TableWorkspace::createColumn(...)
    TypeName can contain only letters, numbers and _s.
*/
#define DECLARE_TABLECOLUMN(DataType, TypeName)                                                                        \
  namespace {                                                                                                          \
  Mantid::Kernel::RegistrationHelper register_column_##TypeName(                                                       \
      (Mantid::API::ColumnFactory::Instance().subscribe<Mantid::DataObjects::TableColumn<DataType>>(#TypeName), 0));   \
  }