RangeNormalizer.h

#ifndef _theplu_yat_normalizer_range_normalizer_
#define _theplu_yat_normalizer_range_normalizer_

// $Id: RangeNormalizer.h 3954 2020-07-22 13:03:31Z peter $

/*
  Copyright (C) 2008 Jari Häkkinen, Peter Johansson
  Copyright (C) 2009, 2010, 2011, 2014, 2016, 2020 Peter Johansson

  This file is part of the yat library, http://dev.thep.lu.se/yat

  The yat library is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License as
  published by the Free Software Foundation; either version 3 of the
  License, or (at your option) any later version.

  The yat library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with yat. If not, see <http://www.gnu.org/licenses/>.
*/

#include "utility.h"

#include "yat/utility/concept_check.h"
#include "yat/utility/DataIterator.h"
#include "yat/utility/iterator_traits.h"
#include "yat/utility/WeightIterator.h"

#include <boost/concept_check.hpp>
#include <boost/iterator/iterator_concepts.hpp>

#include <algorithm>
#include <functional>

namespace theplu {
namespace yat {
namespace normalizer {

  template<class UnaryFunction, class Operator>
  class RangeNormalizer
  {
  public:
    RangeNormalizer(void){}

    // This is superfluous but required to keep the Centralizer API
    // with version 0.17
    RangeNormalizer(const UnaryFunction& uf)
      : func_(uf) {}

    RangeNormalizer(const UnaryFunction& uf, const Operator& op)
      : func_(uf), op_(op) {}

    template<class InputIterator, class OutputIterator>
    void operator()(InputIterator first, InputIterator last,
                    OutputIterator result) const
    {
      BOOST_CONCEPT_ASSERT((utility::DataIteratorConcept<InputIterator>));
      BOOST_CONCEPT_ASSERT((utility::DataIteratorConcept<OutputIterator>));
      BOOST_CONCEPT_ASSERT((boost_concepts::WritableIterator<OutputIterator>));

      // we need to traverse the input range once in call to func_ and
      // one in call to std::transform, so single pass iterator will
      // not suffice.
      BOOST_CONCEPT_ASSERT((boost_concepts::ForwardTraversal<InputIterator>));
      // requirments for OutputIterator is different depending on
      // whether it's weighted or not
      typename utility::weighted_iterator_traits<OutputIterator>::type tag;
      check_requirements<OutputIterator>(tag);

      // copy weight if result is weighted
      detail::copy_weight_if_weighted(first, last, result);
      double val = func_(first, last);
      std::transform(utility::data_iterator(first),
                     utility::data_iterator(last),
                     utility::data_iterator(result),
                     [this, val](double x) {return op_(x, val);});
    }

  private:

    template<typename OutputIterator>
    void check_requirements(utility::unweighted_iterator_tag) const
    {
      using boost_concepts::SinglePassIterator;
      using boost_concepts::WritableIterator;
      BOOST_CONCEPT_ASSERT((SinglePassIterator<OutputIterator>));
      BOOST_CONCEPT_ASSERT((WritableIterator<OutputIterator, double>));

    }

    template<typename OutputIterator>
    void check_requirements(utility::weighted_iterator_tag) const
    {
      using boost_concepts::ForwardTraversal;
      using boost_concepts::WritableIterator;
      BOOST_CONCEPT_ASSERT((ForwardTraversal<OutputIterator>));
      BOOST_CONCEPT_ASSERT((WritableIterator<OutputIterator
                            , utility::DataWeight>));
    }

    UnaryFunction func_;
    Operator op_;
  };

}}} // end of namespace normalizer, yat and thep
#endif