Publishing R3
[platform/upstream/dldt.git] / inference-engine / thirdparty / clDNN / common / boost / 1.64.0 / include / boost-1_64 / boost / numeric / odeint / external / mkl / mkl_operations.hpp
1 /*
2  [auto_generated]
3  boost/numeric/odeint/external/mkl/mkl_operations.hpp
4
5  [begin_description]
6  Wrapper classes for intel math kernel library types.
7  Get a free, non-commercial download of MKL at
8  http://software.intel.com/en-us/articles/non-commercial-software-download/
9  [end_description]
10
11  Copyright 2010-2011 Mario Mulansky
12  Copyright 2011-2013 Karsten Ahnert
13
14  Distributed under the Boost Software License, Version 1.0.
15  (See accompanying file LICENSE_1_0.txt or
16  copy at http://www.boost.org/LICENSE_1_0.txt)
17  */
18
19
20 #ifndef BOOST_NUMERIC_ODEINT_EXTERNAL_MKL_MKL_OPERATIONS_HPP_INCLUDED
21 #define BOOST_NUMERIC_ODEINT_EXTERNAL_MKL_MKL_OPERATIONS_HPP_INCLUDED
22
23 #include <iostream>
24
25 #include <mkl_cblas.h>
26 #include <boost/numeric/odeint/algebra/default_operations.hpp>
27
28 /* exemplary example for writing bindings to the Intel MKL library
29  * see test/mkl for how to use mkl with odeint
30  * this is a quick and dirty implementation showing the general possibility.
31  * It works only with containers based on double and sequential memory allocation.
32  */
33
34 namespace boost {
35 namespace numeric {
36 namespace odeint {
37
38 /* only defined for doubles */
39 struct mkl_operations
40 {
41     //template< class Fac1 , class Fac2 > struct scale_sum2;
42
43     template< class F1 = double , class F2 = F1 >
44     struct scale_sum2
45     {
46         typedef double Fac1;
47         typedef double Fac2;
48         const Fac1 m_alpha1;
49         const Fac2 m_alpha2;
50
51         scale_sum2( const Fac1 alpha1 , const Fac2 alpha2 ) : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) { }
52
53         template< class T1 , class T2 , class T3 >
54         void operator()( T1 &t1 , const T2 &t2 , const T3 &t3) const
55         {   // t1 = m_alpha1 * t2 + m_alpha2 * t3;
56             // we get Containers that have size() and [i]-access
57
58             const int n = t1.size();
59             //boost::numeric::odeint::copy( t1 , t3 );
60             if( &(t2[0]) != &(t1[0]) )
61             {
62                 cblas_dcopy( n , &(t2[0]) , 1 , &(t1[0]) , 1 );
63             }
64             cblas_dscal( n , m_alpha1 , &(t1[0]) , 1 );
65             cblas_daxpy( n , m_alpha2 , &(t3[0]) , 1 , &(t1[0]) , 1 );
66             //daxpby( &n , &m_alpha2 , &(t3[0]) , &one , &m_alpha1 , &(t1[0]) , &one );
67         }
68     };
69
70     template< class F1 = double , class F2 = F1 , class F3 = F2 >
71     struct scale_sum3
72     {
73         typedef double Fac1;
74         typedef double Fac2;
75         typedef double Fac3;
76         const Fac1 m_alpha1;
77         const Fac2 m_alpha2;
78         const Fac3 m_alpha3;
79
80         scale_sum3( const Fac1 alpha1 , const Fac2 alpha2 , const Fac3 alpha3 )
81             : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) { }
82
83         template< class T1 , class T2 , class T3 , class T4 >
84         void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 ) const
85         {   // t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4;
86             // we get Containers that have size() and [i]-access
87
88             const int n = t1.size();
89             //boost::numeric::odeint::copy( t1 , t3 );
90             if( &(t2[0]) != &(t1[0]) )
91             {
92                 cblas_dcopy( n , &(t2[0]) , 1 , &(t1[0]) , 1 );
93             }
94             cblas_dscal( n , m_alpha1 , &(t1[0]) , 1 );
95             cblas_daxpy( n , m_alpha2 , &(t3[0]) , 1 , &(t1[0]) , 1 );
96             //daxpby( &n , &m_alpha2 , &(t3[0]) , &one , &m_alpha1 , &(t1[0]) , &one );
97             cblas_daxpy( n , m_alpha3 , &(t4[0]) , 1 , &(t1[0]) , 1 );
98         }
99     };
100
101     template< class F1 = double , class F2 = F1 , class F3 = F2 , class F4 = F3 >
102     struct scale_sum4
103     {
104         typedef double Fac1;
105         typedef double Fac2;
106         typedef double Fac3;
107         typedef double Fac4;
108         const Fac1 m_alpha1;
109         const Fac2 m_alpha2;
110         const Fac3 m_alpha3;
111         const Fac4 m_alpha4;
112
113         scale_sum4( const Fac1 alpha1 , const Fac2 alpha2 , const Fac3 alpha3 , const Fac4 alpha4 )
114             : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) { }
115
116         template< class T1 , class T2 , class T3 , class T4 , class T5 >
117         void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 , const T5 &t5 ) const
118         {   // t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4 + m_alpha4 * t5;
119             // we get Containers that have size() and [i]-access
120
121             const int n = t1.size();
122             //boost::numeric::odeint::copy( t1 , t3 );
123             if( &(t2[0]) != &(t1[0]) )
124             {
125                 cblas_dcopy( n , &(t2[0]) , 1 , &(t1[0]) , 1 );
126             }
127
128             cblas_dscal( n , m_alpha1 , &(t1[0]) , 1 );
129             cblas_daxpy( n , m_alpha2 , &(t3[0]) , 1 , &(t1[0]) , 1 );
130             //daxpby( &n , &m_alpha2 , &(t3[0]) , &one , &m_alpha1 , &(t1[0]) , &one );
131             cblas_daxpy( n , m_alpha3 , &(t4[0]) , 1 , &(t1[0]) , 1 );
132             cblas_daxpy( n , m_alpha4 , &(t5[0]) , 1 , &(t1[0]) , 1 );
133         }
134     };
135
136
137     template< class F1 = double , class F2 = F1 , class F3 = F2 , class F4 = F3 , class F5 = F4 >
138     struct scale_sum5
139     {
140         typedef double Fac1;
141         typedef double Fac2;
142         typedef double Fac3;
143         typedef double Fac4;
144         typedef double Fac5;
145         const Fac1 m_alpha1;
146         const Fac2 m_alpha2;
147         const Fac3 m_alpha3;
148         const Fac4 m_alpha4;
149         const Fac5 m_alpha5;
150
151         scale_sum5( const Fac1 alpha1 , const Fac2 alpha2 , const Fac3 alpha3 , const Fac4 alpha4 , const Fac5 alpha5 )
152             : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) , m_alpha5( alpha5 ) { }
153
154         template< class T1 , class T2 , class T3 , class T4 , class T5 , class T6   >
155         void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 , const T5 &t5 , const T6 &t6 ) const
156         {   // t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4 + m_alpha4 * t5 + m_alpha5 * t6;
157             // we get Containers that have size() and [i]-access
158
159             const int n = t1.size();
160             //boost::numeric::odeint::copy( t1 , t3 );
161             if( &(t2[0]) != &(t1[0]) )
162             {
163                 cblas_dcopy( n , &(t2[0]) , 1 , &(t1[0]) , 1 );
164             }
165
166             cblas_dscal( n , m_alpha1 , &(t1[0]) , 1 );
167             cblas_daxpy( n , m_alpha2 , &(t3[0]) , 1 , &(t1[0]) , 1 );
168             //daxpby( &n , &m_alpha2 , &(t3[0]) , &one , &m_alpha1 , &(t1[0]) , &one );
169             cblas_daxpy( n , m_alpha3 , &(t4[0]) , 1 , &(t1[0]) , 1 );
170             cblas_daxpy( n , m_alpha4 , &(t5[0]) , 1 , &(t1[0]) , 1 );
171             cblas_daxpy( n , m_alpha5 , &(t6[0]) , 1 , &(t1[0]) , 1 );
172         }
173     };
174
175 };
176
177 } // odeint
178 } // numeric
179 } // boost
180
181 #endif // BOOST_NUMERIC_ODEINT_EXTERNAL_MKL_MKL_OPERATIONS_HPP_INCLUDED