DPosition.h

Go to the documentation of this file.

// Copyright (c) 2002-present, OpenMS Inc. -- EKU Tuebingen, ETH Zurich, and FU Berlin
// SPDX-License-Identifier: BSD-3-Clause
//
// --------------------------------------------------------------------------
// $Maintainer: Timo Sachsenberg$
// $Authors: Marc Sturm, Stephan Aiche $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/CONCEPT/Macros.h>
#include <OpenMS/CONCEPT/Types.h>
#include <OpenMS/CONCEPT/PrecisionWrapper.h>
#include <OpenMS/CONCEPT/HashUtils.h>
 
#include <algorithm>
#include <array>
#include <cmath>  // for std::abs on integrals and floats
#include <functional>
#include <limits>
#include <ostream>
 
namespace OpenMS
{
  template <UInt D, typename TCoordinateType = double>
class DPosition
{
public:
  using CoordinateType =  TCoordinateType;
 
  using DataType = std::array<CoordinateType, D>;
 
  enum
  {
    DIMENSION = D
  };
  typedef CoordinateType value_type;
  typedef CoordinateType& reference;
  typedef CoordinateType* pointer;
  typedef CoordinateType* iterator;
  typedef const CoordinateType* const_iterator;
 
  DPosition() = default;
 
  DPosition(CoordinateType x)
  {
    std::fill(coordinate_.begin(), coordinate_.end(), x);
  }
 
  DPosition(CoordinateType x, CoordinateType y)
  {
    static_assert(D == 2, "DPosition<D, TCoordinateType>:DPosition(x,y): index overflow!");
    coordinate_[0] = x;
    coordinate_[1] = y;
  }
 
  DPosition(CoordinateType x, CoordinateType y, CoordinateType z)
  {
    static_assert(D == 3, "DPosition<D, TCoordinateType>:DPosition(x,y,z): index overflow!");
    coordinate_[0] = x;
    coordinate_[1] = y;
    coordinate_[2] = z;
  }
 
  DPosition(const DPosition& pos) = default;
 
  DPosition(DPosition&& rhs) noexcept = default;
 
  DPosition& operator=(const DPosition& source) = default;
 
  DPosition& operator=(DPosition&& source) noexcept = default;
 
  ~DPosition() noexcept = default;
 
 
  void swap(DPosition& rhs) noexcept
  {
    std::swap(coordinate_, rhs.coordinate_);
  }
 
  DPosition& abs() noexcept
  {
    for (Size i = 0; i < D; ++i)
    {
      coordinate_[i] = std::abs(coordinate_[i]);
    }
    return *this;
  }
 
 
  CoordinateType operator[](Size index) const
  {
    OPENMS_PRECONDITION(index < D, "DPosition<D,TCoordinateType>:operator [] (Position): index overflow!");
    return coordinate_[index];
  }
 
  CoordinateType& operator[](Size index)
  {
    OPENMS_PRECONDITION(index < D, "DPosition<D,TCoordinateType>:operator [] (Position): index overflow!");
    return coordinate_[index];
  }
 
  CoordinateType getX() const
  {
    OPENMS_PRECONDITION(D == 2, "DPosition<D,TCoordinateType>:getX(): index overflow!");
    return coordinate_[0];
  }
 
  CoordinateType getY() const
  {
    OPENMS_PRECONDITION(D == 2, "DPosition<D,TCoordinateType>:getY(): index overflow!");
    return coordinate_[1];
  }
 
  void setX(CoordinateType c)
  {
    OPENMS_PRECONDITION(D == 2, "DPosition<D,TCoordinateType>:setX(): index overflow!");
    coordinate_[0] = c;
  }
 
  void setY(CoordinateType c)
  {
    OPENMS_PRECONDITION(D == 2, "DPosition<D,TCoordinateType>:setY(): index overflow!");
    coordinate_[1] = c;
  }
 
  bool operator==(const DPosition& point) const = default;
 
  bool operator!=(const DPosition& point) const = default;
  bool operator<(const DPosition& point) const
  {
    return coordinate_ < point.coordinate_;
  }
 
  bool operator<=(const DPosition& point) const
  {
    return coordinate_ <= point.coordinate_;
  }
 
  bool spatiallyLessEqual(const DPosition& point) const
  {
    for (Size i = 0; i < D; i++)
    {
      if (coordinate_[i] > point.coordinate_[i]) return false;
    }
    return true;
  }
 
  bool spatiallyGreaterEqual(const DPosition& point) const
  {
    for (Size i = 0; i < D; i++)
    {
      if (coordinate_[i] < point.coordinate_[i]) return false;
    }
    return true;
  }
 
  bool operator>(const DPosition& point) const
  {
    return coordinate_ > point.coordinate_;
  }
 
  bool operator>=(const DPosition& point) const
  {
    return coordinate_ >= point.coordinate_;
  }
 
    DPosition operator+(const DPosition& point) const
    {
      DPosition result(*this);
      for (Size i = 0; i < D; ++i)
      {
        result.coordinate_[i] += point.coordinate_[i];
      }
      return result;
    }
 
    DPosition& operator+=(const DPosition& point)
    {
      for (Size i = 0; i < D; ++i)
      {
        coordinate_[i] += point.coordinate_[i];
      }
      return *this;
    }
 
    DPosition operator-(const DPosition& point) const
    {
      DPosition result(*this);
      for (Size i = 0; i < D; ++i)
      {
        result.coordinate_[i] -= point.coordinate_[i];
      }
      return result;
    }
 
    DPosition& operator-=(const DPosition& point)
    {
      for (Size i = 0; i < D; ++i)
      {
        coordinate_[i] -= point.coordinate_[i];
      }
      return *this;
    }
 
    DPosition   operator-() const
    {
      DPosition<D, CoordinateType> result(*this);
      for (Size i = 0; i < D; ++i)
      {
        result.coordinate_[i] = -result.coordinate_[i];
      }
      return result;
    }
 
    CoordinateType operator*(const DPosition& point) const
    {
      CoordinateType prod(0);
      for (Size i = 0; i < D; ++i)
      {
        prod += (point.coordinate_[i] * coordinate_[i]);
      }
      return prod;
    }
 
    DPosition& operator*=(CoordinateType scalar)
    {
      for (Size i = 0; i < D; ++i)
      {
        coordinate_[i] *= scalar;
      }
      return *this;
    }
 
    DPosition& operator/=(CoordinateType scalar)
    {
      for (Size i = 0; i < D; ++i)
      {
        coordinate_[i] /= scalar;
      }
      return *this;
    }
 
    constexpr static Size size()
    {
      return D;
    }
 
    void clear()
    {
      coordinate_.fill(0);
    }
 
 
    inline static constexpr DPosition zero()
    {
      return DPosition(0);
    }
 
    inline static constexpr DPosition minPositive()
    {
      return DPosition((std::numeric_limits<typename DPosition::CoordinateType>::min)());
    }
 
    inline static constexpr DPosition minNegative()
    {
      return DPosition(std::numeric_limits<typename DPosition::CoordinateType>::lowest());
    }
 
    inline static constexpr DPosition maxPositive()
    {
      return DPosition((std::numeric_limits<typename DPosition::CoordinateType>::max)());
    }
 
 
    const_iterator begin() const
    {
      return &coordinate_[0];
    }
 
    const_iterator end() const
    {
      return &coordinate_[0] + D;
    }
 
    iterator begin()
    {
      return &coordinate_[0];
    }
 
    iterator end()
    {
      return &coordinate_[0] + D;
    }
 
 
protected:
    DataType coordinate_{};
  }; // DPosition
 
  template <UInt D, typename TCoordinateType>
  DPosition<D, TCoordinateType> operator*(DPosition<D, TCoordinateType> position, typename DPosition<D, TCoordinateType>::CoordinateType scalar)
  {
    for (Size i = 0; i < D; ++i)
    {
      position[i] *= scalar;
    }
    return position;
  }
 
  template <UInt D, typename TCoordinateType>
  DPosition<D, TCoordinateType> operator*(typename DPosition<D, TCoordinateType>::CoordinateType scalar, DPosition<D, TCoordinateType> position)
  {
    for (Size i = 0; i < D; ++i)
    {
      position[i] *= scalar;
    }
    return position;
  }
 
  template <UInt D, typename TCoordinateType>
  DPosition<D, TCoordinateType> operator/(DPosition<D, TCoordinateType> position, typename DPosition<D, TCoordinateType>::CoordinateType scalar)
  {
    for (Size i = 0; i < D; ++i)
    {
      position[i] /= scalar;
    }
    return position;
  }
 
  template <UInt D, typename TCoordinateType>
  std::ostream& operator<<(std::ostream& os, const DPosition<D, TCoordinateType>& pos)
  {
    os << precisionWrapper(pos[0]);
    for (UInt i = 1; i < D; ++i)
    {
      os << ' ' << precisionWrapper(pos[i]);
    }
    return os;
  }
 
} // namespace OpenMS
 
// Hash function specialization for DPosition
namespace std
{
  template<OpenMS::UInt D, typename TCoordinateType>
  struct hash<OpenMS::DPosition<D, TCoordinateType>>
  {
    std::size_t operator()(const OpenMS::DPosition<D, TCoordinateType>& pos) const noexcept
    {
      std::size_t seed = 0;
      for (OpenMS::UInt i = 0; i < D; ++i)
      {
        OpenMS::hash_combine(seed, OpenMS::hash_float(pos[i]));
      }
      return seed;
    }
  };
} // namespace std