[ceph.git] / ceph / src / boost / libs / numeric / odeint / include / boost / numeric / odeint / external / viennacl / viennacl_operations.hpp

/*
 [auto_generated]
 boost/numeric/odeint/external/viennacl_operations.hpp

 [begin_description]
 ViennaCL operations.
 [end_description]

 Copyright 2012 Denis Demidov
 Copyright 2012 Karsten Ahnert
 Copyright 2012 Mario Mulansky

 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_VIENNACL_VIENNACL_OPERATIONS_HPP_INCLUDED
#define BOOST_NUMERIC_ODEINT_EXTERNAL_VIENNACL_VIENNACL_OPERATIONS_HPP_INCLUDED

#include <viennacl/vector.hpp>

#ifdef VIENNACL_WITH_OPENCL
#  include <viennacl/generator/custom_operation.hpp>
#endif

namespace boost {
namespace numeric {
namespace odeint {


#ifdef VIENNACL_WITH_OPENCL
struct viennacl_operations
{

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

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

        template< class T1 , class T2 , class T3 >
        void operator()( viennacl::vector<T1> &v1 ,
                const viennacl::vector<T2> &v2 ,
                const viennacl::vector<T3> &v3
                ) const
        {
            using namespace viennacl;

            static generator::symbolic_vector    <0, T1>   sym_v1;
            static generator::symbolic_vector    <1, T2>   sym_v2;
            static generator::symbolic_vector    <2, T3>   sym_v3;
            static generator::cpu_symbolic_scalar<3, Fac1> sym_a1;
            static generator::cpu_symbolic_scalar<4, Fac2> sym_a2;

            static generator::custom_operation op(
                    sym_v1 = sym_a1 * sym_v2
                           + sym_a2 * sym_v3,
                    "scale_sum2"
                    );

            ocl::enqueue( op(v1, v2, v3, m_alpha1, m_alpha2) );
        }

        typedef void result_type;
    };


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

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

        template< class T1 , class T2 , class T3 , class T4 >
        void operator()( viennacl::vector<T1> &v1 ,
                const viennacl::vector<T2> &v2 ,
                const viennacl::vector<T3> &v3 ,
                const viennacl::vector<T4> &v4
                ) const
        {
            using namespace viennacl;

            static generator::symbolic_vector    <0, T1>   sym_v1;
            static generator::symbolic_vector    <1, T2>   sym_v2;
            static generator::symbolic_vector    <2, T3>   sym_v3;
            static generator::symbolic_vector    <3, T4>   sym_v4;
            static generator::cpu_symbolic_scalar<4, Fac1> sym_a1;
            static generator::cpu_symbolic_scalar<5, Fac2> sym_a2;
            static generator::cpu_symbolic_scalar<6, Fac3> sym_a3;

            static generator::custom_operation op(
                    sym_v1 = sym_a1 * sym_v2
                           + sym_a2 * sym_v3
                           + sym_a3 * sym_v4,
                    "scale_sum3"
                    );

            ocl::enqueue( op(v1, v2, v3, v4, m_alpha1, m_alpha2, m_alpha3) );
        }

        typedef void result_type;
    };


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

        scale_sum4( Fac1 alpha1 , Fac2 alpha2 , Fac3 alpha3 , 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()( viennacl::vector<T1> &v1 ,
                const viennacl::vector<T2> &v2 ,
                const viennacl::vector<T3> &v3 ,
                const viennacl::vector<T4> &v4 ,
                const viennacl::vector<T5> &v5
                ) const
        {
            using namespace viennacl;

            static generator::symbolic_vector    <0, T1>   sym_v1;
            static generator::symbolic_vector    <1, T2>   sym_v2;
            static generator::symbolic_vector    <2, T3>   sym_v3;
            static generator::symbolic_vector    <3, T4>   sym_v4;
            static generator::symbolic_vector    <4, T5>   sym_v5;
            static generator::cpu_symbolic_scalar<5, Fac1> sym_a1;
            static generator::cpu_symbolic_scalar<6, Fac2> sym_a2;
            static generator::cpu_symbolic_scalar<7, Fac3> sym_a3;
            static generator::cpu_symbolic_scalar<8, Fac4> sym_a4;

            static generator::custom_operation op(
                    sym_v1 = sym_a1 * sym_v2
                           + sym_a2 * sym_v3
                           + sym_a3 * sym_v4
                           + sym_a4 * sym_v5,
                    "scale_sum4"
                    );

            ocl::enqueue( op(v1, v2, v3, v4, v5,
                        m_alpha1, m_alpha2, m_alpha3, m_alpha4) );
        }

        typedef void result_type;
    };


    template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 , class Fac4 = Fac3 , class Fac5 = Fac4 >
    struct scale_sum5
    {
        const Fac1 m_alpha1;
        const Fac2 m_alpha2;
        const Fac3 m_alpha3;
        const Fac4 m_alpha4;
        const Fac5 m_alpha5;

        scale_sum5( Fac1 alpha1 , Fac2 alpha2 , Fac3 alpha3 , Fac4 alpha4 , 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()( viennacl::vector<T1> &v1 ,
                const viennacl::vector<T2> &v2 ,
                const viennacl::vector<T3> &v3 ,
                const viennacl::vector<T4> &v4 ,
                const viennacl::vector<T5> &v5 ,
                const viennacl::vector<T6> &v6
                ) const
        {
            using namespace viennacl;

            static generator::symbolic_vector    < 0, T1>   sym_v1;
            static generator::symbolic_vector    < 1, T2>   sym_v2;
            static generator::symbolic_vector    < 2, T3>   sym_v3;
            static generator::symbolic_vector    < 3, T4>   sym_v4;
            static generator::symbolic_vector    < 4, T5>   sym_v5;
            static generator::symbolic_vector    < 5, T6>   sym_v6;
            static generator::cpu_symbolic_scalar< 6, Fac1> sym_a1;
            static generator::cpu_symbolic_scalar< 7, Fac2> sym_a2;
            static generator::cpu_symbolic_scalar< 8, Fac3> sym_a3;
            static generator::cpu_symbolic_scalar< 9, Fac4> sym_a4;
            static generator::cpu_symbolic_scalar<10, Fac5> sym_a5;

            static generator::custom_operation op(
                    sym_v1 = sym_a1 * sym_v2
                           + sym_a2 * sym_v3
                           + sym_a3 * sym_v4
                           + sym_a4 * sym_v5
                           + sym_a5 * sym_v6,
                    "scale_sum5"
                    );

            ocl::enqueue( op(v1, v2, v3, v4, v5, v6,
                        m_alpha1, m_alpha2, m_alpha3, m_alpha4, m_alpha5) );
        }

        typedef void result_type;
    };


};
#else
struct viennacl_operations : public default_operations {};
#endif


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


#endif // BOOST_NUMERIC_ODEINT_EXTERNAL_VIENNACL_VIENNACL_OPERATIONS_HPP_INCLUDED
Commit	Line	Data
7c673cae FG	1	/*
	2	[auto_generated]
	3	boost/numeric/odeint/external/viennacl_operations.hpp
	4
	5	[begin_description]
	6	ViennaCL operations.
	7	[end_description]
	8
	9	Copyright 2012 Denis Demidov
	10	Copyright 2012 Karsten Ahnert
	11	Copyright 2012 Mario Mulansky
	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_VIENNACL_VIENNACL_OPERATIONS_HPP_INCLUDED
	20	#define BOOST_NUMERIC_ODEINT_EXTERNAL_VIENNACL_VIENNACL_OPERATIONS_HPP_INCLUDED
	21
	22	#include <viennacl/vector.hpp>
	23
	24	#ifdef VIENNACL_WITH_OPENCL
	25	# include <viennacl/generator/custom_operation.hpp>
	26	#endif
	27
	28	namespace boost {
	29	namespace numeric {
	30	namespace odeint {
	31
	32
	33	#ifdef VIENNACL_WITH_OPENCL
	34	struct viennacl_operations
	35	{
	36
	37	template< class Fac1 = double , class Fac2 = Fac1 >
	38	struct scale_sum2
	39	{
	40	const Fac1 m_alpha1;
	41	const Fac2 m_alpha2;
	42
	43	scale_sum2( Fac1 alpha1 , Fac2 alpha2 )
	44	: m_alpha1( alpha1 ) , m_alpha2( alpha2 )
	45	{ }
	46
	47	template< class T1 , class T2 , class T3 >
	48	void operator()( viennacl::vector<T1> &v1 ,
	49	const viennacl::vector<T2> &v2 ,
	50	const viennacl::vector<T3> &v3
	51	) const
	52	{
	53	using namespace viennacl;
	54
	55	static generator::symbolic_vector <0, T1> sym_v1;
	56	static generator::symbolic_vector <1, T2> sym_v2;
	57	static generator::symbolic_vector <2, T3> sym_v3;
	58	static generator::cpu_symbolic_scalar<3, Fac1> sym_a1;
	59	static generator::cpu_symbolic_scalar<4, Fac2> sym_a2;
	60
	61	static generator::custom_operation op(
	62	sym_v1 = sym_a1 * sym_v2
	63	+ sym_a2 * sym_v3,
	64	"scale_sum2"
65	);
66
67	ocl::enqueue( op(v1, v2, v3, m_alpha1, m_alpha2) );
68	}
69
70	typedef void result_type;
71	};
72
73
74	template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 >
75	struct scale_sum3
76	{
77	const Fac1 m_alpha1;
78	const Fac2 m_alpha2;
79	const Fac3 m_alpha3;
80
81	scale_sum3( Fac1 alpha1 , Fac2 alpha2 , Fac3 alpha3 )
82	: m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 )
83	{ }
84
85	template< class T1 , class T2 , class T3 , class T4 >
86	void operator()( viennacl::vector<T1> &v1 ,
87	const viennacl::vector<T2> &v2 ,
88	const viennacl::vector<T3> &v3 ,
89	const viennacl::vector<T4> &v4
90	) const
91	{
92	using namespace viennacl;
93
94	static generator::symbolic_vector <0, T1> sym_v1;
95	static generator::symbolic_vector <1, T2> sym_v2;
96	static generator::symbolic_vector <2, T3> sym_v3;
97	static generator::symbolic_vector <3, T4> sym_v4;
98	static generator::cpu_symbolic_scalar<4, Fac1> sym_a1;
99	static generator::cpu_symbolic_scalar<5, Fac2> sym_a2;
100	static generator::cpu_symbolic_scalar<6, Fac3> sym_a3;
101
102	static generator::custom_operation op(
103	sym_v1 = sym_a1 * sym_v2
104	+ sym_a2 * sym_v3
105	+ sym_a3 * sym_v4,
106	"scale_sum3"
107	);
108
109	ocl::enqueue( op(v1, v2, v3, v4, m_alpha1, m_alpha2, m_alpha3) );
110	}
111
112	typedef void result_type;
113	};
114
115
116	template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 , class Fac4 = Fac3 >
117	struct scale_sum4
118	{
119	const Fac1 m_alpha1;
120	const Fac2 m_alpha2;
121	const Fac3 m_alpha3;
122	const Fac4 m_alpha4;
123
124	scale_sum4( Fac1 alpha1 , Fac2 alpha2 , Fac3 alpha3 , Fac4 alpha4 )
125	: m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) { }
126
127	template< class T1 , class T2 , class T3 , class T4 , class T5 >
128	void operator()( viennacl::vector<T1> &v1 ,
129	const viennacl::vector<T2> &v2 ,
130	const viennacl::vector<T3> &v3 ,
131	const viennacl::vector<T4> &v4 ,
132	const viennacl::vector<T5> &v5
133	) const
134	{
135	using namespace viennacl;
136
137	static generator::symbolic_vector <0, T1> sym_v1;
138	static generator::symbolic_vector <1, T2> sym_v2;
139	static generator::symbolic_vector <2, T3> sym_v3;
140	static generator::symbolic_vector <3, T4> sym_v4;
141	static generator::symbolic_vector <4, T5> sym_v5;
142	static generator::cpu_symbolic_scalar<5, Fac1> sym_a1;
143	static generator::cpu_symbolic_scalar<6, Fac2> sym_a2;
144	static generator::cpu_symbolic_scalar<7, Fac3> sym_a3;
145	static generator::cpu_symbolic_scalar<8, Fac4> sym_a4;
146
147	static generator::custom_operation op(
148	sym_v1 = sym_a1 * sym_v2
149	+ sym_a2 * sym_v3
150	+ sym_a3 * sym_v4
151	+ sym_a4 * sym_v5,
152	"scale_sum4"
153	);
154
155	ocl::enqueue( op(v1, v2, v3, v4, v5,
156	m_alpha1, m_alpha2, m_alpha3, m_alpha4) );
157	}
158
159	typedef void result_type;
160	};
161
162
163	template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 , class Fac4 = Fac3 , class Fac5 = Fac4 >
164	struct scale_sum5
165	{
166	const Fac1 m_alpha1;
167	const Fac2 m_alpha2;
168	const Fac3 m_alpha3;
169	const Fac4 m_alpha4;
170	const Fac5 m_alpha5;
171
172	scale_sum5( Fac1 alpha1 , Fac2 alpha2 , Fac3 alpha3 , Fac4 alpha4 , Fac5 alpha5 )
173	: m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) , m_alpha5( alpha5 ) { }
174
175	template< class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
176	void operator()( viennacl::vector<T1> &v1 ,
177	const viennacl::vector<T2> &v2 ,
178	const viennacl::vector<T3> &v3 ,
179	const viennacl::vector<T4> &v4 ,
180	const viennacl::vector<T5> &v5 ,
181	const viennacl::vector<T6> &v6
182	) const
183	{
184	using namespace viennacl;
185
186	static generator::symbolic_vector < 0, T1> sym_v1;
187	static generator::symbolic_vector < 1, T2> sym_v2;
188	static generator::symbolic_vector < 2, T3> sym_v3;
189	static generator::symbolic_vector < 3, T4> sym_v4;
190	static generator::symbolic_vector < 4, T5> sym_v5;
191	static generator::symbolic_vector < 5, T6> sym_v6;
192	static generator::cpu_symbolic_scalar< 6, Fac1> sym_a1;
193	static generator::cpu_symbolic_scalar< 7, Fac2> sym_a2;
194	static generator::cpu_symbolic_scalar< 8, Fac3> sym_a3;
195	static generator::cpu_symbolic_scalar< 9, Fac4> sym_a4;
196	static generator::cpu_symbolic_scalar<10, Fac5> sym_a5;
197
198	static generator::custom_operation op(
199	sym_v1 = sym_a1 * sym_v2
200	+ sym_a2 * sym_v3
201	+ sym_a3 * sym_v4
202	+ sym_a4 * sym_v5
203	+ sym_a5 * sym_v6,
204	"scale_sum5"
205	);
206
207	ocl::enqueue( op(v1, v2, v3, v4, v5, v6,
208	m_alpha1, m_alpha2, m_alpha3, m_alpha4, m_alpha5) );
209	}
210
211	typedef void result_type;
212	};
213
214
215	};
216	#else
217	struct viennacl_operations : public default_operations {};
218	#endif
219
220
221	} // odeint
222	} // numeric
223	} // boost
224
225
226	#endif // BOOST_NUMERIC_ODEINT_EXTERNAL_VIENNACL_VIENNACL_OPERATIONS_HPP_INCLUDED