ceph/src/boost/libs/numeric/odeint/include/boost/numeric/odeint/external/thrust/thrust_algebra.hpp

   1 /*
   2  [auto_generated]
   3  boost/numeric/odeint/external/thrust/thrust_algebra.hpp
   4
   5  [begin_description]
   6  An algebra for thrusts device_vectors.
   7  [end_description]
   8
   9  Copyright 2010-2013 Mario Mulansky
  10  Copyright 2010-2011 Karsten Ahnert
  11  Copyright 2013 Kyle Lutz
  12
  13  Distributed under the Boost Software License, Version 1.0.
  14  (See accompanying file LICENSE_1_0.txt or
  15  copy at http://www.boost.org/LICENSE_1_0.txt)
  16  */
  17
  18
  19 #ifndef BOOST_NUMERIC_ODEINT_EXTERNAL_THRUST_THRUST_ALGEBRA_HPP_INCLUDED
  20 #define BOOST_NUMERIC_ODEINT_EXTERNAL_THRUST_THRUST_ALGEBRA_HPP_INCLUDED
  21
  22
  23 #include <thrust/device_vector.h>
  24 #include <thrust/for_each.h>
  25 #include <thrust/iterator/zip_iterator.h>
  26
  27 #include <boost/range.hpp>
  28
  29 namespace boost {
  30 namespace numeric {
  31 namespace odeint {
  32
  33 namespace detail {
  34
  35     // to use in thrust::reduce
  36     template< class Value >
  37     struct maximum
  38     {
  39         template< class Fac1 , class Fac2 >
  40         __host__ __device__
  41         Value operator()( const Fac1 t1 , const Fac2 t2 ) const
  42         {
  43             return ( abs( t1 ) < abs( t2 ) ) ? t2 : t1 ;
  44         }
  45
  46         typedef Value result_type;
  47     };
  48
  49 }
  50
  51
  52
  53
  54 /** ToDO extend until for_each14 for rk78 */
  55
  56 /*
  57  * The const versions are needed for boost.range to work, i.e.
  58  * it allows you to do
  59  * for_each1( make_pair( vec1.begin() , vec1.begin() + 10 ) , op );
  60  */
  61
  62 struct thrust_algebra
  63 {
  64     template< class StateType , class Operation >
  65     static void for_each1( StateType &s , Operation op )
  66     {
  67         thrust::for_each( boost::begin(s) , boost::end(s) , op );
  68     }
  69
  70     template< class StateType1 , class StateType2 , class Operation >
  71     static void for_each2( StateType1 &s1 , StateType2 &s2 , Operation op )
  72     {
  73         thrust::for_each(
  74                 thrust::make_zip_iterator( thrust::make_tuple( boost::begin(s1) ,
  75                         boost::begin(s2) ) ) ,
  76                         thrust::make_zip_iterator( thrust::make_tuple( boost::end(s1) ,
  77                                 boost::end(s2) ) ) ,
  78                                 op);
  79     }
  80
  81     template< class StateType1 , class StateType2 , class StateType3 , class Operation >
  82     static void for_each3( StateType1 &s1 , StateType2 &s2 , StateType3 &s3 , Operation op )
  83     {
  84         thrust::for_each(
  85                 thrust::make_zip_iterator( thrust::make_tuple( boost::begin(s1) ,
  86                         boost::begin(s2) ,
  87                         boost::begin(s3) ) ) ,
  88                         thrust::make_zip_iterator( thrust::make_tuple( boost::end(s1) ,
  89                                 boost::end(s2) ,
  90                                 boost::end(s3) ) ) ,
  91                                 op);
  92     }
  93
  94     template< class StateType1 , class StateType2 , class StateType3 , class StateType4 ,
  95     class Operation >
  96     static void for_each4( StateType1 &s1 , StateType2 &s2 , StateType3 &s3 , StateType4 &s4 ,
  97             Operation op )
  98     {
  99         thrust::for_each(
 100                 thrust::make_zip_iterator( thrust::make_tuple( boost::begin(s1) ,
 101                         boost::begin(s2) ,
 102                         boost::begin(s3) ,
 103                         boost::begin(s4) ) ) ,
 104                         thrust::make_zip_iterator( thrust::make_tuple( boost::end(s1) ,
 105                                 boost::end(s2) ,
 106                                 boost::end(s3) ,
 107                                 boost::end(s4) ) ) ,
 108                                 op);
 109     }
 110
 111     template< class StateType1 , class StateType2 , class StateType3 ,
 112     class StateType4 , class StateType5 ,class Operation >
 113     static void for_each5( StateType1 &s1 , StateType2 &s2 , StateType3 &s3 , StateType4 &s4 ,
 114             StateType5 &s5 , Operation op )
 115     {
 116         thrust::for_each(
 117                 thrust::make_zip_iterator( thrust::make_tuple( boost::begin(s1) ,
 118                         boost::begin(s2) ,
 119                         boost::begin(s3) ,
 120                         boost::begin(s4) ,
 121                         boost::begin(s5) ) ) ,
 122                         thrust::make_zip_iterator( thrust::make_tuple( boost::end(s1) ,
 123                                 boost::end(s2) ,
 124                                 boost::end(s3) ,
 125                                 boost::end(s4) ,
 126                                 boost::end(s5) ) ) ,
 127                                 op);
 128     }
 129
 130     template< class StateType1 , class StateType2 , class StateType3 ,
 131     class StateType4 , class StateType5 , class StateType6 , class Operation >
 132     static void for_each6( StateType1 &s1 , StateType2 &s2 , StateType3 &s3 , StateType4 &s4 ,
 133             StateType5 &s5 , StateType6 &s6 , Operation op )
 134     {
 135         thrust::for_each(
 136                 thrust::make_zip_iterator( thrust::make_tuple( boost::begin(s1) ,
 137                         boost::begin(s2) ,
 138                         boost::begin(s3) ,
 139                         boost::begin(s4) ,
 140                         boost::begin(s5) ,
 141                         boost::begin(s6) ) ) ,
 142                         thrust::make_zip_iterator( thrust::make_tuple( boost::end(s1) ,
 143                                 boost::end(s2) ,
 144                                 boost::end(s3) ,
 145                                 boost::end(s4) ,
 146                                 boost::end(s5) ,
 147                                 boost::end(s6) ) ) ,
 148                                 op);
 149     }
 150
 151     template< class StateType1 , class StateType2 , class StateType3 , class StateType4 ,
 152     class StateType5 , class StateType6 , class StateType7 , class Operation >
 153     static void for_each7( StateType1 &s1 , StateType2 &s2 , StateType3 &s3 , StateType4 &s4 ,
 154             StateType5 &s5 , StateType6 &s6 , StateType7 &s7 , Operation op )
 155     {
 156         thrust::for_each(
 157                 thrust::make_zip_iterator( thrust::make_tuple( boost::begin(s1) ,
 158                         boost::begin(s2) ,
 159                         boost::begin(s3) ,
 160                         boost::begin(s4) ,
 161                         boost::begin(s5) ,
 162                         boost::begin(s6) ,
 163                         boost::begin(s7) ) ) ,
 164                         thrust::make_zip_iterator( thrust::make_tuple( boost::end(s1) ,
 165                                 boost::end(s2) ,
 166                                 boost::end(s3) ,
 167                                 boost::end(s4) ,
 168                                 boost::end(s5) ,
 169                                 boost::end(s6) ,
 170                                 boost::end(s7) ) ) ,
 171                                 op);
 172     }
 173
 174     template< class StateType1 , class StateType2 , class StateType3 , class StateType4 ,
 175     class StateType5 , class StateType6 , class StateType7 , class StateType8 , class Operation >
 176     static void for_each8( StateType1 &s1 , StateType2 &s2 , StateType3 &s3 , StateType4 &s4 ,
 177             StateType5 &s5 , StateType6 &s6 , StateType7 &s7 , StateType8 &s8 , Operation op )
 178     {
 179         thrust::for_each(
 180                 thrust::make_zip_iterator( thrust::make_tuple( boost::begin(s1) ,
 181                         boost::begin(s2) ,
 182                         boost::begin(s3) ,
 183                         boost::begin(s4) ,
 184                         boost::begin(s5) ,
 185                         boost::begin(s6) ,
 186                         boost::begin(s7) ,
 187                         boost::begin(s8) ) ) ,
 188                 thrust::make_zip_iterator( thrust::make_tuple( boost::end(s1) ,
 189                         boost::end(s2) ,
 190                         boost::end(s3) ,
 191                         boost::end(s4) ,
 192                         boost::end(s5) ,
 193                         boost::end(s6) ,
 194                         boost::end(s7) ,
 195                         boost::end(s8) ) ) ,
 196                 op);
 197     }
 198
 199     template< class S >
 200     static typename S::value_type norm_inf( const S &s )
 201     {
 202         typedef typename S::value_type value_type;
 203         return thrust::reduce( boost::begin( s ) , boost::end( s ) ,
 204                                static_cast<value_type>(0) ,
 205                                detail::maximum<value_type>() );
 206     }
 207
 208 };
 209
 210
 211 } // odeint
 212 } // numeric
 213 } // boost
 214
 215
 216
 217 #endif // BOOST_NUMERIC_ODEINT_EXTERNAL_THRUST_THRUST_ALGEBRA_HPP_INCLUDED