DPosition.h

Go to the documentation of this file.

// --------------------------------------------------------------------------
//                   OpenMS -- Open-Source Mass Spectrometry
// --------------------------------------------------------------------------
// Copyright The OpenMS Team -- Eberhard Karls University Tuebingen,
// ETH Zurich, and Freie Universitaet Berlin 2002-2021.
//
// This software is released under a three-clause BSD license:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name of any author or any participating institution
//    may be used to endorse or promote products derived from this software
//    without specific prior written permission.
// For a full list of authors, refer to the file AUTHORS.
// --------------------------------------------------------------------------
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL ANY OF THE AUTHORS OR THE CONTRIBUTING
// INSTITUTIONS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// --------------------------------------------------------------------------
// $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 <algorithm>
#include <limits>
#include <ostream>
 
namespace OpenMS
{
  template <UInt D, typename TCoordinateType = double>
  class DPosition
  {
public:
 
    typedef TCoordinateType CoordinateType;
    typedef CoordinateType* Iterator;
    typedef const CoordinateType* ConstIterator;
    enum
    {
      DIMENSION = D
    };
    typedef CoordinateType value_type;
    typedef CoordinateType& reference;
    typedef CoordinateType* pointer;
    typedef CoordinateType* iterator;
    typedef const CoordinateType* const_iterator;
 
    DPosition()
    {
      clear();
    }
 
    ~DPosition()
    {
    }
 
    DPosition(CoordinateType x)
    {
      std::fill(&(coordinate_[0]), &(coordinate_[D]), x);
    }
 
    DPosition(const DPosition& pos)
    {
      std::copy(&(pos.coordinate_[0]), &(pos.coordinate_[D]),
                &(coordinate_[0]));
    }
 
    DPosition(DPosition&& rhs) noexcept
    {
      // NOTE: do not change this before testing with nightly Windows builds ( = default causes segfault)
      std::move(std::begin(rhs.coordinate_), std::end(rhs.coordinate_), &coordinate_[0]);
    }
 
    DPosition(CoordinateType x, CoordinateType y)
    {
      OPENMS_PRECONDITION(D == 2, "DPosition<D, TCoordinateType>:DPosition(x,y): index overflow!");
      coordinate_[0] = x;
      coordinate_[1] = y;
    }
 
    DPosition& operator=(const DPosition& source)
    {
      if (&source == this) return *this;
 
      std::copy(&(source.coordinate_[0]), &(source.coordinate_[D]),
                &(coordinate_[0]));
 
      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
    {
      for (Size i = 0; i < D; i++)
      {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wfloat-equal"
        if (coordinate_[i] != point.coordinate_[i]) return false;
 
#pragma clang diagnostic pop
      }
      return true;
    }
 
    bool operator!=(const DPosition& point) const
    {
      return !(operator==(point));
    }
 
    bool operator<(const DPosition& point) const
    {
      for (Size i = 0; i < D; i++)
      {
        if (coordinate_[i] < point.coordinate_[i]) return true;
 
        if (coordinate_[i] > point.coordinate_[i]) return false;
      }
      return false;
    }
 
    bool operator<=(const DPosition& point) const
    {
      for (Size i = 0; i < D; i++)
      {
        if (coordinate_[i] < point.coordinate_[i]) return true;
 
        if (coordinate_[i] > point.coordinate_[i]) return false;
      }
      return true;
    }
 
    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 !(operator<=(point));
    }
 
    bool operator>=(const DPosition& point) const
    {
      return !operator<(point);
    }
 
    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;
    }
 
    static Size size()
    {
      return D;
    }
 
    void clear()
    {
      for (Size i = 0; i < D; ++i)
      {
        coordinate_[i] = static_cast<CoordinateType>(0);
      }
    }
 
 
    inline static const DPosition zero()
    {
      return DPosition(0);
    }
 
    inline static const DPosition minPositive()
    {
      return DPosition((std::numeric_limits<typename DPosition::CoordinateType>::min)());
    }
 
    inline static const DPosition minNegative()
    {
      return DPosition(-(std::numeric_limits<typename DPosition::CoordinateType>::max)());
    }
 
    inline static const DPosition maxPositive()
    {
      return DPosition((std::numeric_limits<typename DPosition::CoordinateType>::max)());
    }
 
 
    ConstIterator begin() const
    {
      return &(coordinate_[0]);
    }
 
    ConstIterator end() const
    {
      return &(coordinate_[0]) + D;
    }
 
    Iterator begin()
    {
      return &(coordinate_[0]);
    }
 
    Iterator end()
    {
      return &(coordinate_[0]) + D;
    }
 
 
protected:
    CoordinateType coordinate_[D];
 
  }; // 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