[ceph.git] / ceph / src / boost / libs / numeric / odeint / include / boost / numeric / odeint / external / mkl / mkl_operations.hpp

/*
 [auto_generated]
 boost/numeric/odeint/external/mkl/mkl_operations.hpp

 [begin_description]
 Wrapper classes for intel math kernel library types.
 Get a free, non-commercial download of MKL at
 http://software.intel.com/en-us/articles/non-commercial-software-download/
 [end_description]

 Copyright 2010-2011 Mario Mulansky
 Copyright 2011-2013 Karsten Ahnert

 Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE_1_0.txt or
 copy at http://www.boost.org/LICENSE_1_0.txt)
 */


#ifndef BOOST_NUMERIC_ODEINT_EXTERNAL_MKL_MKL_OPERATIONS_HPP_INCLUDED
#define BOOST_NUMERIC_ODEINT_EXTERNAL_MKL_MKL_OPERATIONS_HPP_INCLUDED

#include <iostream>

#include <mkl_cblas.h>
#include <boost/numeric/odeint/algebra/default_operations.hpp>

/* exemplary example for writing bindings to the Intel MKL library
 * see test/mkl for how to use mkl with odeint
 * this is a quick and dirty implementation showing the general possibility.
 * It works only with containers based on double and sequential memory allocation.
 */

namespace boost {
namespace numeric {
namespace odeint {

/* only defined for doubles */
struct mkl_operations
{
    //template< class Fac1 , class Fac2 > struct scale_sum2;

    template< class F1 = double , class F2 = F1 >
    struct scale_sum2
    {
        typedef double Fac1;
        typedef double Fac2;
        const Fac1 m_alpha1;
        const Fac2 m_alpha2;

        scale_sum2( const Fac1 alpha1 , const Fac2 alpha2 ) : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) { }

        template< class T1 , class T2 , class T3 >
        void operator()( T1 &t1 , const T2 &t2 , const T3 &t3) const
        {   // t1 = m_alpha1 * t2 + m_alpha2 * t3;
            // we get Containers that have size() and [i]-access

            const int n = t1.size();
            //boost::numeric::odeint::copy( t1 , t3 );
            if( &(t2[0]) != &(t1[0]) )
            {
                cblas_dcopy( n , &(t2[0]) , 1 , &(t1[0]) , 1 );
            }
            cblas_dscal( n , m_alpha1 , &(t1[0]) , 1 );
            cblas_daxpy( n , m_alpha2 , &(t3[0]) , 1 , &(t1[0]) , 1 );
            //daxpby( &n , &m_alpha2 , &(t3[0]) , &one , &m_alpha1 , &(t1[0]) , &one );
        }
    };

    template< class F1 = double , class F2 = F1 , class F3 = F2 >
    struct scale_sum3
    {
        typedef double Fac1;
        typedef double Fac2;
        typedef double Fac3;
        const Fac1 m_alpha1;
        const Fac2 m_alpha2;
        const Fac3 m_alpha3;

        scale_sum3( const Fac1 alpha1 , const Fac2 alpha2 , const Fac3 alpha3 )
            : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) { }

        template< class T1 , class T2 , class T3 , class T4 >
        void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 ) const
        {   // t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4;
            // we get Containers that have size() and [i]-access

            const int n = t1.size();
            //boost::numeric::odeint::copy( t1 , t3 );
            if( &(t2[0]) != &(t1[0]) )
            {
                cblas_dcopy( n , &(t2[0]) , 1 , &(t1[0]) , 1 );
            }
            cblas_dscal( n , m_alpha1 , &(t1[0]) , 1 );
            cblas_daxpy( n , m_alpha2 , &(t3[0]) , 1 , &(t1[0]) , 1 );
            //daxpby( &n , &m_alpha2 , &(t3[0]) , &one , &m_alpha1 , &(t1[0]) , &one );
            cblas_daxpy( n , m_alpha3 , &(t4[0]) , 1 , &(t1[0]) , 1 );
        }
    };

    template< class F1 = double , class F2 = F1 , class F3 = F2 , class F4 = F3 >
    struct scale_sum4
    {
        typedef double Fac1;
        typedef double Fac2;
        typedef double Fac3;
        typedef double Fac4;
        const Fac1 m_alpha1;
        const Fac2 m_alpha2;
        const Fac3 m_alpha3;
        const Fac4 m_alpha4;

        scale_sum4( const Fac1 alpha1 , const Fac2 alpha2 , const Fac3 alpha3 , const Fac4 alpha4 )
            : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) { }

        template< class T1 , class T2 , class T3 , class T4 , class T5 >
        void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 , const T5 &t5 ) const
        {   // t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4 + m_alpha4 * t5;
            // we get Containers that have size() and [i]-access

            const int n = t1.size();
            //boost::numeric::odeint::copy( t1 , t3 );
            if( &(t2[0]) != &(t1[0]) )
            {
                cblas_dcopy( n , &(t2[0]) , 1 , &(t1[0]) , 1 );
            }

            cblas_dscal( n , m_alpha1 , &(t1[0]) , 1 );
            cblas_daxpy( n , m_alpha2 , &(t3[0]) , 1 , &(t1[0]) , 1 );
            //daxpby( &n , &m_alpha2 , &(t3[0]) , &one , &m_alpha1 , &(t1[0]) , &one );
            cblas_daxpy( n , m_alpha3 , &(t4[0]) , 1 , &(t1[0]) , 1 );
            cblas_daxpy( n , m_alpha4 , &(t5[0]) , 1 , &(t1[0]) , 1 );
        }
    };


    template< class F1 = double , class F2 = F1 , class F3 = F2 , class F4 = F3 , class F5 = F4 >
    struct scale_sum5
    {
        typedef double Fac1;
        typedef double Fac2;
        typedef double Fac3;
        typedef double Fac4;
        typedef double Fac5;
        const Fac1 m_alpha1;
        const Fac2 m_alpha2;
        const Fac3 m_alpha3;
        const Fac4 m_alpha4;
        const Fac5 m_alpha5;

        scale_sum5( const Fac1 alpha1 , const Fac2 alpha2 , const Fac3 alpha3 , const Fac4 alpha4 , const Fac5 alpha5 )
            : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) , m_alpha5( alpha5 ) { }

        template< class T1 , class T2 , class T3 , class T4 , class T5 , class T6   >
        void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 , const T5 &t5 , const T6 &t6 ) const
        {   // t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4 + m_alpha4 * t5 + m_alpha5 * t6;
            // we get Containers that have size() and [i]-access

            const int n = t1.size();
            //boost::numeric::odeint::copy( t1 , t3 );
            if( &(t2[0]) != &(t1[0]) )
            {
                cblas_dcopy( n , &(t2[0]) , 1 , &(t1[0]) , 1 );
            }

            cblas_dscal( n , m_alpha1 , &(t1[0]) , 1 );
            cblas_daxpy( n , m_alpha2 , &(t3[0]) , 1 , &(t1[0]) , 1 );
            //daxpby( &n , &m_alpha2 , &(t3[0]) , &one , &m_alpha1 , &(t1[0]) , &one );
            cblas_daxpy( n , m_alpha3 , &(t4[0]) , 1 , &(t1[0]) , 1 );
            cblas_daxpy( n , m_alpha4 , &(t5[0]) , 1 , &(t1[0]) , 1 );
            cblas_daxpy( n , m_alpha5 , &(t6[0]) , 1 , &(t1[0]) , 1 );
        }
    };

};

} // odeint
} // numeric
} // boost

#endif // BOOST_NUMERIC_ODEINT_EXTERNAL_MKL_MKL_OPERATIONS_HPP_INCLUDED
Commit	Line	Data
7c673cae FG	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