merge.h

#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 {

  template<class Container2D>
  void merge(const Container2D& x, std::vector<std::string>& labels, Matrix& y); 


  template<class Container2D, class Functor>
  void merge(const Container2D& x, std::vector<std::string>& labels, Matrix& y,
             Functor func); 

  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 {
    
    template<typename Iterator, class Functor1, class Functor2>
    void assign(double& x, Iterator first, Iterator last, Functor1 func1,
                Functor2 func2);

    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