source: trunk/yat/utility/merge.h @ 2372

#ifndef _theplu_yat_utility_merge_
#define _theplu_yat_utility_merge_ 

// $Id: merge.h 2372 2010-12-12 07:18:51Z peter $

/*
  Copyright (C) 2009, 2010 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 "concept_check.h"
#include "Matrix.h"
#include "MatrixWeighted.h"
#include "stl_utility.h"

#include "yat/statistics/Average.h"

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

#include <algorithm>
#include <map>
#include <string>
#include <vector>

namespace theplu {
namespace yat {
namespace utility {

  /**
     \brief merge rows in a \ref concept_container_2d

     When two (or several) elements in \a labels are found, the
     corresponding rows in \a x are merged into one row vector. The
     vector of \a labels are modified to reflect the rows in the
     resulting container \a y. In this default implementation the
     merge is calculated as the (weighted) arithmetic mean.

     \a x must be a \ref concept_container_2d and it works for both
     weighted and unweighted containers.

     \param x input container to be merged.
     \param labels telling which rows to merge.
     \param y resulting merged container.

     \note If \a x and \a y overlap in their underlying data
     structures, the result is undefined.

     \since New in yat 0.6
  */
  template<class Container2D>
  void merge(const Container2D& x, std::vector<std::string>& labels, Matrix& y); 


  /**
     \brief merge rows in a \ref concept_container_2d using a Functor

     Same as utility::merge(const Container2D&, std::vector<std::string>&,
     Matrix&) but instead of calculating the merged element as the
     (weighted) arithmetic mean, the merged element is calculated as
     defined by \a func.

     If Functor works on both unweighted and weighted iterators, merge
     works on both unweighted and weighted Container2D.

     \since New in yat 0.6
  */
  template<class Container2D, class Functor>
  void merge(const Container2D& x, std::vector<std::string>& labels, Matrix& y,
             Functor func); 

  /**
     \brief merge rows in a \ref concept_container_2d to a MatrixWeighted

     When two (or several) elements in \a labels are found, the
     corresponding rows in \a x are merged into one row vector. The
     vector of \a labels are modified to reflect the rows in the
     resulting container \a y.

     The data value of each element is calculated as defined by \a
     data_func and and the weight value is calculated as defined by \a
     weight_func.

     \a x must be a \ref concept_container_2d.  If Functor1 and
     Functor2 work on both unweighted and weighted iterators, merge
     works on both unweighted and weighted Container2D.

     \param x input container to be merged.
     \param labels telling which rows to merge.
     \param y resulting merged container.
     \param data_func defines how data values are calculated
     \param weight_func defines how weight values are calculated

     \note If \a x and \a y overlap in their underlying data
     structures, the result is undefined.

     \since New in yat 0.6
  */
  template<class Container2D, class Functor1, class Functor2>
  void merge(const Container2D& x, std::vector<std::string>& labels, 
             MatrixWeighted& y, Functor1 data_func, Functor2 weight_func); 

  namespace detail {
    
    /**
       assign x using func1 on range [first, last).

       func2 is not used but exists solely to keep the signature
       similar to assign(DataWeight&, ...)
     */
    template<typename Iterator, class Functor1, class Functor2>
    void assign(double& x, Iterator first, Iterator last, Functor1 func1,
                Functor2 func2);

    /**
       assign x.data() using func1 on range [first, last).
       assign x.weight() using func2 on range [first, last).

     */
    template<typename Iterator, class Functor1, class Functor2>
    void assign(DataWeight& x, Iterator first, Iterator last, Functor1 func1,
                Functor2 func2);

    void merge_labels(std::vector<std::string>&, 
                      std::map<std::string, std::vector<size_t> >&);


    template<class Container2D, class MutableContainer2D, 
             class Functor1, class Functor2>
    void merge(const Container2D& x, 
               std::map<std::string, std::vector<size_t> >& label2index, 
               MutableContainer2D& result, Functor1 func1, Functor2 func2);

  } // end of private namespace detail


  // template implementations //

  template<class Container2D>
  void merge(const Container2D& x, std::vector<std::string>& labels, Matrix& y)
  {
    BOOST_CONCEPT_ASSERT((utility::Container2D<Container2D>));
    merge(x, labels, y, statistics::Average());
  }

  template<class Container2D, class Functor>
  void merge(const Container2D& x, std::vector<std::string>& labels, 
             Matrix& result, Functor func)
  {
    BOOST_CONCEPT_ASSERT((utility::Container2D<Container2D>));
    std::map<std::string, std::vector<size_t> > label2index;
    detail::merge_labels(labels, label2index);
    detail::merge(x, label2index, result, func, func);
  }


  template<class Container2D, class Functor1, class Functor2>
  void merge(const Container2D& x, std::vector<std::string>& labels, 
             MatrixWeighted& result, Functor1 func1, Functor2 func2)
  {
    BOOST_CONCEPT_ASSERT((utility::Container2D<Container2D>));
    std::map<std::string, std::vector<size_t> > label2index;
    detail::merge_labels(labels, label2index);
    detail::merge(x, label2index, result, func1, func2);
  } 

  // implemantions of private functions

  namespace detail {
    template<typename Iterator, class Functor1, class Functor2>
    void assign(double& x, Iterator first, Iterator last, Functor1 func1,
                Functor2 func)
    {
      x = func1(first, last);
    }


    template<typename Iterator, class Functor1, class Functor2>
    void assign(DataWeight& x, Iterator first, Iterator last, Functor1 func1,
                Functor2 func2)
    {
      x.data() = func1(first, last);
      x.weight() = func2(first, last);
    }


    void merge_labels(std::vector<std::string>& labels, 
                      std::map<std::string, std::vector<size_t> >& label2index)
    {
      inverse(labels.begin(), labels.end(), label2index);
      labels.resize(label2index.size());
      std::copy(pair_first_iterator(label2index.begin()),
                pair_first_iterator(label2index.end()),
                labels.begin());
    }


    template<class Container2D, class MutableContainer2D, 
             class Functor1, class Functor2>
    void merge(const Container2D& x, 
               std::map<std::string, std::vector<size_t> >& label2index, 
               MutableContainer2D& result, Functor1 func1, Functor2 func2)
    {
      BOOST_CONCEPT_ASSERT((utility::Mutable_Container2D<MutableContainer2D>));
      BOOST_CONCEPT_ASSERT((utility::Container2D<Container2D>));
      result.resize(label2index.size(), x.columns());
      typedef std::map<std::string, std::vector<size_t> > Map;
      Map::const_iterator iter=label2index.begin(); 

      for (size_t row=0; row<result.rows(); ++row) {
        const std::vector<size_t>& index = iter->second;
        for (size_t col=0; col<result.columns(); ++col) {
          assign(result(row,col), 
                 boost::make_permutation_iterator(x.begin_column(col), 
                                                  index.begin()),
                 boost::make_permutation_iterator(x.end_column(col), 
                                                  index.end()),
                 func1, func2);
        }
        ++iter;
      }
    } 

  } // end of namespace detail

}}} // of namespace utility, yat, and theplu

#endif