Clementine-audio-player-Mac.../3rdparty/libprojectm/omptl/omptl_numeric_par.h

287 lines
9.2 KiB
C++

// Copyright (C) 2006 Fokko Beekhof
// Email contact: Fokko.Beekhof@cui.unige.ch
// The OMPTL 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
#ifndef OMPTL_NUMERIC_H
#define OMPTL_NUMERIC_H 1
#include <utility>
#include <functional>
#include <iterator>
#include "omptl_algorithm"
#include "omptl_tools.h"
namespace omptl
{
template <class IteratorTag>
struct _Accumulate
{
template <class InputIterator, class T, class BinaryFunction>
static T accumulate(InputIterator first, InputIterator last, T init,
T par_init, BinaryFunction binary_op, const unsigned P)
{
assert(P > 0u);
if (_linear_serial_is_faster(first, last, P))
return ::std::accumulate(first, last, init, binary_op);
assert(2*(int)P <= std::distance(first, last));
::std::vector< ::std::pair<InputIterator, InputIterator> >
partitions(P);
::omptl::_partition_range(first, last, partitions, P);
::std::vector<T> results(P);
#pragma omp parallel for
for (int t = 0; t < int(P); ++t)
results[t] = ::std::accumulate( partitions[t].first,
partitions[t].second,
par_init, binary_op);
return ::std::accumulate(results.begin(), results.end(),
init, binary_op);
}
};
template <>
struct _Accumulate< ::std::input_iterator_tag >
{
template <class InputIterator, class T, class BinaryFunction>
static T accumulate(InputIterator first, InputIterator last, T init,
T par_init, BinaryFunction binary_op, const unsigned P)
{
return ::std::accumulate(first, last, init, binary_op);
}
};
template <class InputIterator, class BinaryFunction>
struct _AccumulateOp
{
template <class T>
static T accumulate(InputIterator first, InputIterator last, T init,
BinaryFunction binary_op, const unsigned P)
{
assert(P > 0u);
return ::std::accumulate(first, last, init, binary_op);
}
};
template <class InputIterator>
struct _AccumulateOp<InputIterator,
::std::plus<typename ::std::iterator_traits<InputIterator>::value_type> >
{
typedef ::std::plus<typename
::std::iterator_traits<InputIterator>::value_type>
BinaryFunction;
template <class T>
static T accumulate(InputIterator first, InputIterator last, T init,
BinaryFunction binary_op, const unsigned P)
{
assert(P > 0u);
return ::omptl::_Accumulate< typename
::std::iterator_traits<InputIterator>::iterator_category>::
accumulate(first, last, init, T(0), binary_op, P);
}
};
template <class InputIterator>
struct _AccumulateOp<InputIterator,
::std::multiplies<typename
::std::iterator_traits<InputIterator>::value_type> >
{
typedef ::std::multiplies<typename
::std::iterator_traits<InputIterator>::value_type>
BinaryFunction;
template <class T>
static T accumulate(InputIterator first, InputIterator last, T init,
BinaryFunction binary_op, const unsigned P)
{
assert(P > 0u);
return ::omptl::_Accumulate<typename
::std::iterator_traits<InputIterator>::iterator_category>::
accumulate(first, last, init, T(1), binary_op, P);
}
};
template <class InputIterator, class T, class BinaryFunction>
T accumulate(InputIterator first, InputIterator last, T init,
BinaryFunction binary_op, const unsigned P)
{
assert(P > 0u);
return ::omptl::_AccumulateOp<InputIterator, BinaryFunction>::
accumulate(first, last, init, binary_op, P);
}
template <class InputIterator, class T>
T accumulate(InputIterator first, InputIterator last, T init, const unsigned P)
{
assert(P > 0u);
typedef typename std::iterator_traits<InputIterator>::value_type VT;
return ::omptl::accumulate(first, last, init, std::plus<VT>(), P);
}
template <class InputIterator, class OutputIterator, class BinaryFunction>
OutputIterator adjacent_difference(InputIterator first, InputIterator last,
OutputIterator result,
BinaryFunction binary_op, const unsigned P)
{
return ::std::adjacent_difference(first, last, result, binary_op);
}
template <class InputIterator, class OutputIterator>
OutputIterator adjacent_difference(InputIterator first, InputIterator last,
OutputIterator result, const unsigned P)
{
// ::std::minus<typename ::std::iterator_traits<InputIterator>::value_type>()
return ::std::adjacent_difference(first, last, result);
}
template <class Iterator1Tag, class Iterator2Tag>
struct _InnerProduct
{
template <class InputIterator1, class InputIterator2, class T,
class BinaryFunction1, class BinaryFunction2>
static T inner_product( InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, T init,
BinaryFunction1 binary_op1,
BinaryFunction2 binary_op2, const unsigned P)
{
return ::std::inner_product(first1, last1, first2, init,
binary_op1, binary_op2);
}
template <class Iterator1, class Iterator2, class T,
class BinaryFunction2>
static T inner_product(Iterator1 first1, Iterator1 last1,
Iterator2 first2, T init,
::std::plus<T> binary_op1,
BinaryFunction2 binary_op2, const unsigned P)
{
assert(P > 0u);
if (_linear_serial_is_faster(first1, last1, P))
return ::std::inner_product(first1, last1, first2,
init, binary_op1, binary_op2);
assert(2*(int)P <= std::distance(first1, last1));
::std::vector< ::std::pair<Iterator1, Iterator1> >
partitions1(P);
::omptl::_partition_range(first1, last1, partitions1, P);
::std::vector<Iterator2> partitions2(P);
::omptl::_copy_partitions(partitions1, first2, partitions2, P);
#pragma omp parallel for reduction(+:init)
for (int t = 0; t < int(P); ++t)
init += ::std::inner_product( partitions1[t].first,
partitions1[t].second,
partitions2[t], T(0.0),
binary_op1, binary_op2);
return init;
}
};
template <class Iterator2Tag>
struct _InnerProduct< ::std::input_iterator_tag, Iterator2Tag>
{
template <class InputIterator1, class InputIterator2, class T,
class BinaryFunction1, class BinaryFunction2>
static T inner_product(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, T init,
BinaryFunction1 binary_op1, BinaryFunction2 binary_op2,
const unsigned P)
{
return ::std::inner_product(first1, last1, first2, init,
binary_op1, binary_op2);
}
};
template <class Iterator1Tag>
struct _InnerProduct<Iterator1Tag, ::std::input_iterator_tag>
{
template <class InputIterator1, class InputIterator2, class T,
class BinaryFunction1, class BinaryFunction2>
static T inner_product(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, T init,
BinaryFunction1 binary_op1, BinaryFunction2 binary_op2,
const unsigned P)
{
return ::std::inner_product(first1, last1, first2, init,
binary_op1, binary_op2);
}
};
template <>
struct _InnerProduct< ::std::input_iterator_tag, ::std::input_iterator_tag >
{
template <class InputIterator1, class InputIterator2, class T,
class BinaryFunction1, class BinaryFunction2>
static T inner_product(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, T init,
BinaryFunction1 binary_op1, BinaryFunction2 binary_op2,
const unsigned P)
{
return ::std::inner_product(first1, last1, first2, init,
binary_op1, binary_op2);
}
};
template <class InputIterator1, class InputIterator2, class T,
class BinaryFunction1, class BinaryFunction2>
T inner_product(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, T init,
BinaryFunction1 binary_op1, BinaryFunction2 binary_op2,
const unsigned P)
{
return _InnerProduct<
typename ::std::iterator_traits<InputIterator1>::iterator_category,
typename ::std::iterator_traits<InputIterator2>::iterator_category>
::inner_product(first1, last1, first2, init,
binary_op1, binary_op2, P);
}
template <class InputIterator1, class InputIterator2, class T>
T inner_product(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, T init, const unsigned P)
{
return ::omptl::inner_product(first1, last1, first2, init,
::std::plus<T>(), ::std::multiplies<T>(), P);
}
template <class InputIterator, class OutputIterator, class BinaryOperation>
OutputIterator partial_sum(InputIterator first, InputIterator last,
OutputIterator result, BinaryOperation binary_op,
const unsigned P)
{
return ::std::partial_sum(first, last, result, binary_op);
}
template <class InputIterator, class OutputIterator>
OutputIterator partial_sum(InputIterator first, InputIterator last,
OutputIterator result, const unsigned P)
{
// ::std::plus<typename ::std::iterator_traits<InputIterator>::value_type>(),
return ::std::partial_sum(first, last, result);
}
} // namespace omptl
#endif /* OMPTL_NUMERIC_H */