metric.hpp

// -*- C++ -*-
//
// Copyright Sylvain Bougerel 2009 - 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file COPYING or copy at
// http://www.boost.org/LICENSE_1_0.txt)

#ifndef SPATIAL_METRIC_HPP
#define SPATIAL_METRIC_HPP

#include "function.hpp"
#include "traits.hpp"
#include "bits/spatial_math.hpp"
#include "bits/spatial_builtin.hpp"

namespace spatial
{
  template<typename Ct, typename DistanceType, typename Diff>
  class euclidian : Diff
  {
    // Check that DistanceType is a fundamental floating point type
    typedef typename enable_if<import::is_floating_point<DistanceType> >::type
    check_concept_distance_type_is_floating_point;

  public:
    typedef typename details::rebind_builtin_difference
    <Diff, DistanceType>::type difference_type;

  private:
    typedef typename container_traits<Ct>::key_type key_type;

  public:
    typedef DistanceType distance_type;

    explicit euclidian(const difference_type& diff = Diff()) : Diff(diff) { }

    template <typename AnyDistanceType>
    euclidian(const euclidian<Ct, AnyDistanceType, Diff>& other)
      : Diff(other.difference()) { }

    distance_type
    distance_to_key(dimension_type rank,
                    const key_type& origin, const key_type& key) const
    {
      return math::euclid_distance_to_key
        <key_type, difference_type, DistanceType>(rank, origin, key,
                                                  difference());
    }

    distance_type
    distance_to_plane(dimension_type, dimension_type dim,
                      const key_type& origin, const key_type& key) const
    {
      return math::euclid_distance_to_plane
        <key_type, difference_type, DistanceType>(dim, origin, key,
                                                  difference());
    }

    difference_type difference() const
    { return *static_cast<const Diff*>(this); }
  };

  template<typename Ct, typename DistanceType, typename Diff>
  class quadrance : Diff
  {
    // Check that DistanceType is a fundamental floating point type
    typedef typename enable_if<import::is_arithmetic<DistanceType> >::type
    check_concept_distance_type_is_arithmetic;

  public:
    typedef typename details::rebind_builtin_difference
    <Diff, DistanceType>::type difference_type;

  private:
    typedef typename container_traits<Ct>::key_type key_type;

  public:
    typedef DistanceType distance_type;

    explicit quadrance(const difference_type& diff = Diff()) : Diff(diff) { }

    template <typename AnyDistanceType>
    quadrance(const quadrance<Ct, AnyDistanceType, Diff>& other)
      : Diff(other.difference()) { }

    distance_type
    distance_to_key(dimension_type rank,
                    const key_type& origin, const key_type& key) const
    {
      return math::square_euclid_distance_to_key
        <key_type, difference_type, DistanceType>(rank, origin, key,
                                                  difference());
    }

    distance_type
    distance_to_plane(dimension_type, dimension_type dim,
                      const key_type& origin, const key_type& key) const
    {
      return math::square_euclid_distance_to_plane
        <key_type, difference_type, DistanceType>(dim, origin, key,
                                                  difference());
    }

    difference_type difference() const
    { return *static_cast<const Diff*>(this); }
  };

  template<typename Ct, typename DistanceType, typename Diff>
  class manhattan : Diff
  {
    // Check that DistanceType is a fundamental floating point type
    typedef typename enable_if<import::is_arithmetic<DistanceType> >::type
    check_concept_distance_type_is_arithmetic;

  public:
    typedef typename details::rebind_builtin_difference
    <Diff, DistanceType>::type difference_type;

  private:
    typedef typename container_traits<Ct>::key_type key_type;

  public:
    typedef DistanceType distance_type;

    explicit manhattan(const difference_type& diff = Diff()) : Diff(diff) { }

    template <typename AnyDistanceType>
    manhattan(const manhattan<Ct, AnyDistanceType, Diff>& other)
      : Diff(other.difference()) { }

    distance_type
    distance_to_key(dimension_type rank,
                    const key_type& origin, const key_type& key) const
    {
      return math::manhattan_distance_to_key
        <key_type, difference_type, DistanceType>(rank, origin, key,
                                                  difference());
    }

    distance_type
    distance_to_plane(dimension_type, dimension_type dim,
                      const key_type& origin, const key_type& key) const
    {
      return math::manhattan_distance_to_plane
        <key_type, difference_type, DistanceType>(dim, origin, key,
                                                  difference());
    }

    difference_type difference() const
    { return *static_cast<const Diff*>(this); }
  };

} // namespace spatial

#endif // SPATIAL_METRIC_HPP