mptl_reduction.h

mptl和omptl一样

// Copyright (C) 2006 Didier Baertschiger
// e-mail contact: [e-mail]

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

// This 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
// Lesser General Public License for more details.

// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

/// \file   mptl_reduction.h
/// \brief  D閒inition des algorithmes de r閐uction.
/// \author Didier Baertschiger
/// \date   06-10-2005
///
/// A la fin de l'ex閏ution d'un algorithme qui retourne une valeur (cf.
/// caract閞istique resultAlgorithm), il faut traiter le vecteur qui
/// comporte les r閟ultats obtenus par chaque thread. Pour cela, on effectue
/// une \b r閐uction.\n
/// La r閐uction s'effectue en appelant la m閠hode \c reduce (qui doit 阾re 
/// statique) d'une classe sp閏ifi閑 dans les caract閞istiques de la CSPA
/// (\em CSPA).
/// \code
///     static T reduce(std::vector<T> results, CSPA algoSpec)
/// \endcode

#ifndef _MPTL_REDUCTION
#define _MPTL_REDUCTION 1

#include <functional>
#include <numeric>
#include <vector>
#include <utility>

namespace mptl
{
    // ----------------------------------------------------------------------------
    //  Value Traits (pour AccumulationPolicy)
    // ----------------------------------------------------------------------------
    //  D閒inition des 閘閙ents neutres pour la classe AccumulationPolicy.
    //  En fonction du type d'accumulation (plus, minus,...) et du type T,
    //  l'閘閙ent neutre change.
    //
    template <typename T>
    class NeutralElement;
    
    // Function object : plus<T>()
    template <>
    class NeutralElement<std::plus<char> >
    {
    public:
        static char element() { return 0; }
    };
    
    template <>
    class NeutralElement<std::plus<short> >
    {
    public:
        static short element() { return 0; }
    };
    
    template <>
    class NeutralElement<std::plus<int> >
    {
    public:
        static int element() { return 0; }
    };
    
    template <>
    class NeutralElement<std::plus<unsigned int> >
    {
    public:
        static unsigned int element() { return 0; }
    };
    
    template <>
    class NeutralElement<std::plus<long> >
    {
    public:
        static long element() { return 0; }
    };
    
    template <>
        class NeutralElement<std::plus<unsigned long> >
    {
    public:
        static unsigned long element() { return 0; }
    };
    
    template <>
    class NeutralElement<std::plus<float> >
    {
    public:
        static float element() { return 0.; }
    };
    
    template <>
    class NeutralElement<std::plus<double> > {
    public:
        static double element() { return 0.; }
    };
    
    
    // Function object : minus<T>()
    template <>
    class NeutralElement<std::minus<char> >
    {
    public:
        static char element() { return 0; }
    };
    
    template <>
    class NeutralElement<std::minus<short> >
    {
    public:
        static short element() { return 0; }
    };
    
    template <>
    class NeutralElement<std::minus<int> >
    {
    public:
        static int element() { return 0; }
    };
    
    template <>
    class NeutralElement<std::minus<unsigned int> >
    {
    public:
        static unsigned int element() { return 0; }
    };
    
    template <>
    class NeutralElement<std::minus<long> >
    {
    public:
        static long element() { return 0; }
    };
    
    template <>
    class NeutralElement<std::minus<unsigned long> >
    {
    public:
        static unsigned long element() { return 0; }
    };
    
    template <>
    class NeutralElement<std::minus<float> >
    {
    public:
        static float element() { return 0.; }
    };
    
    template <>
    class NeutralElement<std::minus<double> > {
    public:
        static double element() { return 0.; }
    };
    
    
    // Function object : multiplies<T>()
    template <>
    class NeutralElement<std::multiplies<char> >
    {
    public:
        static char element() { return 1; }
    };
    
    template <>
    class NeutralElement<std::multiplies<short> >
    {
    public:
        static short element() { return 1; }
    };
    
    template <>
    class NeutralElement<std::multiplies<int> >
    {
    public:
        static int element() { return 1; }
    };
    
    template <>
    class NeutralElement<std::multiplies<unsigned int> >
    {
    public:
        static unsigned int element() { return 1; }
    };
    
    template <>
    class NeutralElement<std::multiplies<long> >
    {
    public:
        static long element() { return 1; }
    };
    
    template <>
    class NeutralElement<std::multiplies<unsigned long> >
    {
    public:
        static unsigned long element() { return 1; }
    };
    
    template <>
    class NeutralElement<std::multiplies<float> >
    {
    public:
        static float element() { return 1.; }
    };
    
    template <>
    class NeutralElement<std::multiplies<double> > {
    public:
        static double element() { return 1.; }
    };

    
    // Function object : divides<T>()
    template <>
    class NeutralElement<std::divides<char> >
    {
    public:
        static char element() { return 1; }
    };
    
    template <>
    class NeutralElement<std::divides<short> >
    {
    public:
        static short element() { return 1; }
    };
    
    template <>
    class NeutralElement<std::divides<int> >
    {
    public:
        static int element() { return 1; }
    };
    
    template <>
    class NeutralElement<std::divides<unsigned int> >
    {
    public:
        static unsigned int element() { return 1; }
    };
    
    template <>
    class NeutralElement<std::divides<long> >
    {
    public:
        static long element() { return 1; }
    };
    
    template <>
    class NeutralElement<std::divides<unsigned long> >
    {
    public:
        static unsigned long element() { return 1; }
    };
    
    template <>
    class NeutralElement<std::divides<float> >
    {
    public:
        static float element() { return 1.; }
    };
    
    template <>
    class NeutralElement<std::divides<double> > {
    public:
        static double element() { return 1.; }
    };
    
    
    // ----------------------------------------------------------------------------
    //  Policy Classes (Reduction)
    // ----------------------------------------------------------------------------
    //  Comportement