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-2012.
//
// 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: Stephan Aiche$
// $Authors: Marc Sturm, Stephan Aiche $
// --------------------------------------------------------------------------

#ifndef OPENMS_DATASTRUCTURES_DPOSITION_H
#define OPENMS_DATASTRUCTURES_DPOSITION_H

#include <OpenMS/config.h>
#include <OpenMS/CONCEPT/Macros.h>

#include <algorithm>
#include <limits>

namespace OpenMS
{
  template <UInt D, typename TCoordinateType = DoubleReal>
  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(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++)
      {
        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
    {
      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] = (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

#endif // OPENMS_DATASTRUCTURES_DPOSITION_H