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

   1 /*
   2  [auto_generated]
   3  boost/numeric/odeint/external/thrust/thrust_operations.hpp
   4
   5  [begin_description]
   6  Operations of thrust zipped iterators. Is the counterpart of the thrust_algebra.
   7  [end_description]
   8
   9  Copyright 2010-2013 Mario Mulansky
  10  Copyright 2010-2012 Karsten Ahnert
  11
  12  Distributed under the Boost Software License, Version 1.0.
  13  (See accompanying file LICENSE_1_0.txt or
  14  copy at http://www.boost.org/LICENSE_1_0.txt)
  15  */
  16
  17
  18 #ifndef BOOST_NUMERIC_ODEINT_EXTERNAL_THRUST_THRUST_OPERATIONS_HPP_INCLUDED
  19 #define BOOST_NUMERIC_ODEINT_EXTERNAL_THRUST_THRUST_OPERATIONS_HPP_INCLUDED
  20
  21 namespace boost {
  22 namespace numeric {
  23 namespace odeint {
  24
  25 #include <thrust/tuple.h>
  26 #include <thrust/iterator/zip_iterator.h>
  27
  28 /**ToDo extend to scale_sum13 for rk78 */
  29
  30 struct thrust_operations
  31 {
  32     template< class Fac1 = double , class Fac2 = Fac1 >
  33     struct scale_sum2
  34     {
  35         const Fac1 m_alpha1;
  36         const Fac2 m_alpha2;
  37
  38         scale_sum2( const Fac1 alpha1 , const Fac2 alpha2 )
  39         : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) { }
  40
  41         template< class Tuple >
  42         __host__ __device__
  43         void operator()( Tuple t ) const
  44         {
  45             thrust::get<0>(t) = m_alpha1 * thrust::get<1>(t) + m_alpha2 * thrust::get<2>(t);
  46         }
  47     };
  48
  49     template< class Fac1 = double , class Fac2 = Fac1 >
  50     struct scale_sum_swap2
  51     {
  52         const Fac1 m_alpha1;
  53         const Fac2 m_alpha2;
  54
  55         scale_sum_swap2( const Fac1 alpha1 , const Fac2 alpha2 )
  56         : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) { }
  57
  58         template< class Tuple >
  59         __host__ __device__
  60         void operator()( Tuple t ) const
  61         {
  62             typename thrust::tuple_element<0,Tuple>::type tmp = thrust::get<0>(t);
  63             thrust::get<0>(t) = m_alpha1 * thrust::get<1>(t) + m_alpha2 * thrust::get<2>(t);
  64             thrust::get<1>(t) = tmp;
  65         }
  66     };
  67
  68     template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 >
  69     struct scale_sum3
  70     {
  71         const Fac1 m_alpha1;
  72         const Fac2 m_alpha2;
  73         const Fac3 m_alpha3;
  74
  75         scale_sum3( const Fac1 alpha1 , const Fac2 alpha2 , const Fac3 alpha3 )
  76         : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) { }
  77
  78         template< class Tuple >
  79         __host__ __device__
  80         void operator()( Tuple t ) const
  81         {
  82             thrust::get<0>(t) = m_alpha1 * thrust::get<1>(t) +
  83                     m_alpha2 * thrust::get<2>(t) +
  84                     m_alpha3 * thrust::get<3>(t);
  85         }
  86     };
  87
  88
  89     template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 , class Fac4 = Fac3 >
  90     struct scale_sum4
  91     {
  92         const Fac1 m_alpha1;
  93         const Fac2 m_alpha2;
  94         const Fac3 m_alpha3;
  95         const Fac4 m_alpha4;
  96
  97         scale_sum4( const Fac1 alpha1 , const Fac2 alpha2 , const Fac3 alpha3 , const Fac4 alpha4 )
  98         : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ){ }
  99
 100         template< class Tuple >
 101         __host__ __device__
 102         void operator()( Tuple t ) const
 103         {
 104             thrust::get<0>(t) = m_alpha1 * thrust::get<1>(t) +
 105                     m_alpha2 * thrust::get<2>(t) +
 106                     m_alpha3 * thrust::get<3>(t) +
 107                     m_alpha4 * thrust::get<4>(t);
 108         }
 109     };
 110
 111
 112     template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 ,
 113             class Fac4 = Fac3 , class Fac5 = Fac4 >
 114     struct scale_sum5
 115     {
 116         const Fac1 m_alpha1;
 117         const Fac2 m_alpha2;
 118         const Fac3 m_alpha3;
 119         const Fac4 m_alpha4;
 120         const Fac5 m_alpha5;
 121
 122         scale_sum5( const Fac1 alpha1 , const Fac2 alpha2 , const Fac3 alpha3 ,
 123                 const Fac4 alpha4 , const Fac5 alpha5 )
 124         : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) ,
 125           m_alpha4( alpha4 ) , m_alpha5( alpha5 ) { }
 126
 127         template< class Tuple >
 128         __host__ __device__
 129         void operator()( Tuple t ) const
 130         {
 131             thrust::get<0>(t) = m_alpha1 * thrust::get<1>(t) +
 132                     m_alpha2 * thrust::get<2>(t) +
 133                     m_alpha3 * thrust::get<3>(t) +
 134                     m_alpha4 * thrust::get<4>(t) +
 135                     m_alpha5 * thrust::get<5>(t);
 136         }
 137     };
 138
 139
 140     template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 ,
 141             class Fac4 = Fac3 , class Fac5 = Fac4 , class Fac6 = Fac5 >
 142     struct scale_sum6
 143     {
 144         const Fac1 m_alpha1;
 145         const Fac2 m_alpha2;
 146         const Fac3 m_alpha3;
 147         const Fac4 m_alpha4;
 148         const Fac5 m_alpha5;
 149         const Fac6 m_alpha6;
 150
 151         scale_sum6( const Fac1 alpha1 , const Fac2 alpha2 , const Fac3 alpha3 ,
 152                 const Fac4 alpha4 , const Fac5 alpha5 , const Fac6 alpha6 )
 153         : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) ,
 154           m_alpha4( alpha4 ) , m_alpha5( alpha5 ) , m_alpha6( alpha6 ) { }
 155
 156         template< class Tuple >
 157         __host__ __device__
 158         void operator()( Tuple t ) const
 159         {
 160             thrust::get<0>(t) = m_alpha1 * thrust::get<1>(t) +
 161                     m_alpha2 * thrust::get<2>(t) +
 162                     m_alpha3 * thrust::get<3>(t) +
 163                     m_alpha4 * thrust::get<4>(t) +
 164                     m_alpha5 * thrust::get<5>(t) +
 165                     m_alpha6 * thrust::get<6>(t);
 166         }
 167     };
 168
 169
 170     template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 , class Fac4 = Fac3 ,
 171             class Fac5 = Fac4 , class Fac6 = Fac5 , class Fac7 = Fac6 >
 172     struct scale_sum7
 173     {
 174         const Fac1 m_alpha1;
 175         const Fac2 m_alpha2;
 176         const Fac3 m_alpha3;
 177         const Fac4 m_alpha4;
 178         const Fac5 m_alpha5;
 179         const Fac6 m_alpha6;
 180         const Fac7 m_alpha7;
 181
 182         scale_sum7( const Fac1 alpha1 , const Fac2 alpha2 , const Fac3 alpha3 ,
 183                 const Fac4 alpha4 , const Fac5 alpha5 , const Fac6 alpha6 , const Fac7 alpha7 )
 184         : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) ,
 185           m_alpha4( alpha4 ) , m_alpha5( alpha5 ) , m_alpha6( alpha6 ) , m_alpha7( alpha7 ) { }
 186
 187         template< class Tuple >
 188         __host__ __device__
 189         void operator()( Tuple t ) const
 190         {
 191             thrust::get<0>(t) = m_alpha1 * thrust::get<1>(t) +
 192                     m_alpha2 * thrust::get<2>(t) +
 193                     m_alpha3 * thrust::get<3>(t) +
 194                     m_alpha4 * thrust::get<4>(t) +
 195                     m_alpha5 * thrust::get<5>(t) +
 196                     m_alpha6 * thrust::get<6>(t) +
 197                     m_alpha7 * thrust::get<7>(t) ;
 198         }
 199     };
 200
 201
 202
 203
 204     template< class Fac1 = double >
 205     struct rel_error
 206     {
 207         const Fac1 m_eps_abs , m_eps_rel , m_a_x , m_a_dxdt;
 208
 209         rel_error( const Fac1 eps_abs , const Fac1 eps_rel , const Fac1 a_x , const Fac1 a_dxdt )
 210         : m_eps_abs( eps_abs ) , m_eps_rel( eps_rel ) , m_a_x( a_x ) , m_a_dxdt( a_dxdt ) { }
 211
 212
 213         template< class Tuple >
 214         __host__ __device__
 215         void operator()( Tuple t ) const
 216         {
 217             using std::abs;
 218             thrust::get< 0 >( t ) = abs( thrust::get< 0 >( t ) ) /
 219                     ( m_eps_abs + m_eps_rel * ( m_a_x * abs( thrust::get< 1 >( t ) + m_a_dxdt * abs( thrust::get< 2 >( t ) ) ) ) );
 220         }
 221
 222         typedef void result_type;
 223     };
 224
 225
 226 };
 227
 228 } // odeint
 229 } // numeric
 230 } // boost
 231
 232
 233 #endif // BOOST_NUMERIC_ODEINT_EXTERNAL_THRUST_THRUST_OPERATIONS_HPP_INCLUDED