1 // Boost.uBLAS
2 //
3 // Copyright (c) 2018 Fady Essam
4 // Copyright (c) 2018 Stefan Seefeld
5 //
6 // Distributed under the Boost Software License, Version 1.0.
7 // (See accompanying file LICENSE_1_0.txt or
8 // copy at http://www.boost.org/LICENSE_1_0.txt)
9
10 #ifndef boost_numeric_ublas_opencl_elementwise_hpp_
11 #define boost_numeric_ublas_opencl_elementwise_hpp_
12
13 #include <boost/numeric/ublas/opencl/library.hpp>
14 #include <boost/numeric/ublas/opencl/vector.hpp>
15 #include <boost/numeric/ublas/opencl/matrix.hpp>
16
17 namespace boost { namespace numeric { namespace ublas { namespace opencl {
18
19 namespace compute = boost::compute;
20 namespace lambda = boost::compute::lambda;
21
22 template <typename T, typename L1, typename L2, typename L3, class O>
element_wise(ublas::matrix<T,L1,opencl::storage> const & a,ublas::matrix<T,L2,opencl::storage> const & b,ublas::matrix<T,L3,opencl::storage> & result,O op,compute::command_queue & queue)23 void element_wise(ublas::matrix<T, L1, opencl::storage> const &a,
24 ublas::matrix<T, L2, opencl::storage> const &b,
25 ublas::matrix<T, L3, opencl::storage> &result,
26 O op, compute::command_queue& queue)
27 {
28 assert(a.device() == b.device() &&
29 a.device() == result.device() &&
30 a.device() == queue.get_device());
31 assert(a.size1() == b.size1() && a.size2() == b.size2());
32
33 compute::transform(a.begin(),
34 a.end(),
35 b.begin(),
36 result.begin(),
37 op,
38 queue);
39 queue.finish();
40 }
41
42 template <typename T, typename L1, typename L2, typename L3, typename A, class O>
element_wise(ublas::matrix<T,L1,A> const & a,ublas::matrix<T,L2,A> const & b,ublas::matrix<T,L3,A> & result,O op,compute::command_queue & queue)43 void element_wise(ublas::matrix<T, L1, A> const &a,
44 ublas::matrix<T, L2, A> const &b,
45 ublas::matrix<T, L3, A> &result,
46 O op,
47 compute::command_queue &queue)
48 {
49 ublas::matrix<T, L1, opencl::storage> adev(a, queue);
50 ublas::matrix<T, L2, opencl::storage> bdev(b, queue);
51 ublas::matrix<T, L3, opencl::storage> rdev(a.size1(), b.size2(), queue.get_context());
52 element_wise(adev, bdev, rdev, op, queue);
53 rdev.to_host(result, queue);
54 }
55
56 template <typename T, typename L1, typename L2, typename A, typename O>
element_wise(ublas::matrix<T,L1,A> const & a,ublas::matrix<T,L2,A> const & b,O op,compute::command_queue & queue)57 ublas::matrix<T, L1, A> element_wise(ublas::matrix<T, L1, A> const &a,
58 ublas::matrix<T, L2, A> const &b,
59 O op,
60 compute::command_queue &queue)
61 {
62 ublas::matrix<T, L1, A> result(a.size1(), b.size2());
63 element_wise(a, b, result, op, queue);
64 return result;
65 }
66
67 template <typename T, typename O>
element_wise(ublas::vector<T,opencl::storage> const & a,ublas::vector<T,opencl::storage> const & b,ublas::vector<T,opencl::storage> & result,O op,compute::command_queue & queue)68 void element_wise(ublas::vector<T, opencl::storage> const &a,
69 ublas::vector<T, opencl::storage> const &b,
70 ublas::vector<T, opencl::storage> &result,
71 O op,
72 compute::command_queue& queue)
73 {
74 assert(a.device() == b.device() &&
75 a.device() == result.device() &&
76 a.device() == queue.get_device());
77 assert(a.size() == b.size());
78 compute::transform(a.begin(),
79 a.end(),
80 b.begin(),
81 result.begin(),
82 op,
83 queue);
84 queue.finish();
85 }
86
87 template <typename T, typename A, typename O>
element_wise(ublas::vector<T,A> const & a,ublas::vector<T,A> const & b,ublas::vector<T,A> & result,O op,compute::command_queue & queue)88 void element_wise(ublas::vector<T, A> const &a,
89 ublas::vector<T, A> const &b,
90 ublas::vector<T, A>& result,
91 O op,
92 compute::command_queue &queue)
93 {
94 ublas::vector<T, opencl::storage> adev(a, queue);
95 ublas::vector<T, opencl::storage> bdev(b, queue);
96 ublas::vector<T, opencl::storage> rdev(a.size(), queue.get_context());
97 element_wise(adev, bdev, rdev, op, queue);
98 rdev.to_host(result, queue);
99 }
100
101 template <typename T, typename A, typename O>
element_wise(ublas::vector<T,A> const & a,ublas::vector<T,A> const & b,O op,compute::command_queue & queue)102 ublas::vector<T, A> element_wise(ublas::vector<T, A> const &a,
103 ublas::vector<T, A> const &b,
104 O op,
105 compute::command_queue &queue)
106 {
107 ublas::vector<T, A> result(a.size());
108 element_wise(a, b, result, op, queue);
109 return result;
110 }
111
112 template <typename T, typename L1, typename L2, typename L3>
element_add(ublas::matrix<T,L1,opencl::storage> const & a,ublas::matrix<T,L2,opencl::storage> const & b,ublas::matrix<T,L3,opencl::storage> & result,compute::command_queue & queue)113 void element_add(ublas::matrix<T, L1, opencl::storage> const &a,
114 ublas::matrix<T, L2, opencl::storage> const &b,
115 ublas::matrix<T, L3, opencl::storage> &result,
116 compute::command_queue &queue)
117 {
118 element_wise(a, b, result, compute::plus<T>(), queue);
119 }
120
121 template <typename T, typename L1, typename L2, typename L3, typename A>
element_add(ublas::matrix<T,L1,A> const & a,ublas::matrix<T,L2,A> const & b,ublas::matrix<T,L3,A> & result,compute::command_queue & queue)122 void element_add(ublas::matrix<T, L1, A> const &a,
123 ublas::matrix<T, L2, A> const &b,
124 ublas::matrix<T, L3, A> &result,
125 compute::command_queue &queue)
126 {
127 element_wise(a, b, result, compute::plus<T>(), queue);
128 }
129
130 template <typename T, typename L1, typename L2, typename A>
element_add(ublas::matrix<T,L1,A> const & a,ublas::matrix<T,L2,A> const & b,compute::command_queue & queue)131 ublas::matrix<T, L1, A> element_add(ublas::matrix<T, L1, A> const &a,
132 ublas::matrix<T, L2, A> const &b,
133 compute::command_queue &queue)
134 {
135 return element_wise(a, b, compute::plus<T>(), queue);
136 }
137
138 template <typename T>
element_add(ublas::vector<T,opencl::storage> const & a,ublas::vector<T,opencl::storage> const & b,ublas::vector<T,opencl::storage> & result,compute::command_queue & queue)139 void element_add(ublas::vector<T, opencl::storage> const &a,
140 ublas::vector<T, opencl::storage> const &b,
141 ublas::vector<T, opencl::storage> &result,
142 compute::command_queue& queue)
143 {
144 element_wise(a, b, result, compute::plus<T>(), queue);
145 }
146
147 template <typename T, typename A>
element_add(ublas::vector<T,A> const & a,ublas::vector<T,A> const & b,ublas::vector<T,A> & result,compute::command_queue & queue)148 void element_add(ublas::vector<T, A> const &a,
149 ublas::vector<T, A> const &b,
150 ublas::vector<T, A> &result,
151 compute::command_queue &queue)
152 {
153 element_wise(a, b, result, compute::plus<T>(), queue);
154 }
155
156 template <typename T, typename A>
element_add(ublas::vector<T,A> const & a,ublas::vector<T,A> const & b,compute::command_queue & queue)157 ublas::vector<T, A> element_add(ublas::vector<T, A> const &a,
158 ublas::vector<T, A> const &b,
159 compute::command_queue &queue)
160 {
161 return element_wise(a, b, compute::plus<T>(), queue);
162 }
163
164 template<typename T, typename L>
element_add(ublas::matrix<T,L,opencl::storage> const & m,T value,ublas::matrix<T,L,opencl::storage> & result,compute::command_queue & queue)165 void element_add(ublas::matrix<T, L, opencl::storage> const &m, T value,
166 ublas::matrix<T, L, opencl::storage> &result,
167 compute::command_queue& queue)
168 {
169 assert(m.device() == result.device() && m.device() == queue.get_device());
170 assert(m.size1() == result.size1() && m.size2() == result.size2());
171 compute::transform(m.begin(), m.end(), result.begin(), lambda::_1 + value, queue);
172 queue.finish();
173 }
174
175 template<typename T, typename L, typename A>
element_add(ublas::matrix<T,L,A> const & m,T value,ublas::matrix<T,L,A> & result,compute::command_queue & queue)176 void element_add(ublas::matrix<T, L, A> const &m, T value,
177 ublas::matrix<T, L, A> &result,
178 compute::command_queue& queue)
179 {
180 ublas::matrix<T, L, opencl::storage> mdev(m, queue);
181 ublas::matrix<T, L, opencl::storage> rdev(result.size1(), result.size2(), queue.get_context());
182 element_add(mdev, value, rdev, queue);
183 rdev.to_host(result, queue);
184 }
185
186 template<typename T, typename L, typename A>
element_add(ublas::matrix<T,L,A> const & m,T value,compute::command_queue & queue)187 ublas::matrix<T, L, A> element_add(ublas::matrix<T, L, A> const &m, T value,
188 compute::command_queue& queue)
189 {
190 ublas::matrix<T, L, A> result(m.size1(), m.size2());
191 element_add(m, value, result, queue);
192 return result;
193 }
194
195 template<typename T>
element_add(ublas::vector<T,opencl::storage> const & v,T value,ublas::vector<T,opencl::storage> & result,compute::command_queue & queue)196 void element_add(ublas::vector<T, opencl::storage> const &v, T value,
197 ublas::vector<T, opencl::storage> &result,
198 compute::command_queue& queue)
199 {
200 assert(v.device() == result.device() && v.device() == queue.get_device());
201 assert(v.size() == result.size());
202 compute::transform(v.begin(), v.end(), result.begin(), lambda::_1 + value, queue);
203 queue.finish();
204 }
205
206 template<typename T, typename A>
element_add(ublas::vector<T,A> const & v,T value,ublas::vector<T,A> & result,compute::command_queue & queue)207 void element_add(ublas::vector<T, A> const &v, T value,
208 ublas::vector<T, A> &result,
209 compute::command_queue& queue)
210 {
211 ublas::vector<T, opencl::storage> vdev(v, queue);
212 ublas::vector<T, opencl::storage> rdev(v.size(), queue.get_context());
213 element_add(vdev, value, rdev, queue);
214 rdev.to_host(result, queue);
215 }
216
217 template <typename T, typename A>
element_add(ublas::vector<T,A> const & v,T value,compute::command_queue & queue)218 ublas::vector<T, A> element_add(ublas::vector<T, A> const &v, T value,
219 compute::command_queue& queue)
220 {
221 ublas::vector<T, A> result(v.size());
222 element_add(v, value, result, queue);
223 return result;
224 }
225
226 template <typename T, typename L1, typename L2, typename L3>
element_sub(ublas::matrix<T,L1,opencl::storage> const & a,ublas::matrix<T,L2,opencl::storage> const & b,ublas::matrix<T,L3,opencl::storage> & result,compute::command_queue & queue)227 void element_sub(ublas::matrix<T, L1, opencl::storage> const &a,
228 ublas::matrix<T, L2, opencl::storage> const &b,
229 ublas::matrix<T, L3, opencl::storage> &result,
230 compute::command_queue& queue)
231 {
232 element_wise(a, b, compute::minus<T>(), result, queue);
233 }
234
235 template <typename T, typename L1, typename L2, typename L3, typename A>
element_sub(ublas::matrix<T,L1,A> const & a,ublas::matrix<T,L2,A> const & b,ublas::matrix<T,L3,A> & result,compute::command_queue & queue)236 void element_sub(ublas::matrix<T, L1, A> const &a,
237 ublas::matrix<T, L2, A> const &b,
238 ublas::matrix<T, L3, A> &result,
239 compute::command_queue &queue)
240 {
241 element_wise(a, b, result, compute::minus<T>(), queue);
242 }
243
244 template <typename T, typename L1, typename L2, typename A>
element_sub(ublas::matrix<T,L1,A> const & a,ublas::matrix<T,L2,A> const & b,compute::command_queue & queue)245 ublas::matrix<T, L1, A> element_sub(ublas::matrix<T, L1, A> const &a,
246 ublas::matrix<T, L2, A> const &b,
247 compute::command_queue &queue)
248 {
249 return element_wise(a, b, compute::minus<T>(), queue);
250 }
251
252 template <typename T>
element_sub(ublas::vector<T,opencl::storage> const & a,ublas::vector<T,opencl::storage> const & b,ublas::vector<T,opencl::storage> & result,compute::command_queue & queue)253 void element_sub(ublas::vector<T, opencl::storage> const &a,
254 ublas::vector<T, opencl::storage> const &b,
255 ublas::vector<T, opencl::storage> &result,
256 compute::command_queue& queue)
257 {
258 element_wise(a, b, result, compute::minus<T>(), queue);
259 }
260
261 template <typename T, typename A>
element_sub(ublas::vector<T,A> const & a,ublas::vector<T,A> const & b,ublas::vector<T,A> & result,compute::command_queue & queue)262 void element_sub(ublas::vector<T, A> const &a,
263 ublas::vector<T, A> const &b,
264 ublas::vector<T, A> &result,
265 compute::command_queue &queue)
266 {
267 element_wise(a, b, result, compute::minus<T>(), queue);
268 }
269
270 template <typename T, typename A>
element_sub(ublas::vector<T,A> const & a,ublas::vector<T,A> const & b,compute::command_queue & queue)271 ublas::vector<T, A> element_sub(ublas::vector<T, A> const &a,
272 ublas::vector<T, A> const &b,
273 compute::command_queue &queue)
274 {
275 return element_wise(a, b, compute::minus<T>(), queue);
276 }
277
278 template <typename T, typename L>
element_sub(ublas::matrix<T,L,opencl::storage> const & m,T value,ublas::matrix<T,L,opencl::storage> & result,compute::command_queue & queue)279 void element_sub(ublas::matrix<T, L, opencl::storage> const &m, T value,
280 ublas::matrix<T, L, opencl::storage> &result,
281 compute::command_queue& queue)
282 {
283 assert(m.device() == result.device() && m.device() == queue.get_device());
284 assert(m.size1() == result.size1() && m.size2() == result.size2());
285 compute::transform(m.begin(), m.end(), result.begin(), lambda::_1 - value, queue);
286 queue.finish();
287 }
288
289 template <typename T, typename L, typename A>
element_sub(ublas::matrix<T,L,A> const & m,T value,ublas::matrix<T,L,A> & result,compute::command_queue & queue)290 void element_sub(ublas::matrix<T, L, A> const &m, T value,
291 ublas::matrix<T, L, A> &result,
292 compute::command_queue& queue)
293 {
294 ublas::matrix<T, L, opencl::storage> mdev(m, queue);
295 ublas::matrix<T, L, opencl::storage> rdev(result.size1(), result.size2(), queue.get_context());
296 element_sub(mdev, value, rdev, queue);
297 rdev.to_host(result, queue);
298 }
299
300 template <typename T, typename L, typename A>
element_sub(ublas::matrix<T,L,A> const & m,T value,compute::command_queue & queue)301 ublas::matrix<T, L, A> element_sub(ublas::matrix<T, L, A> const &m, T value,
302 compute::command_queue& queue)
303 {
304 ublas::matrix<T, L, A> result(m.size1(), m.size2());
305 element_sub(m, value, result, queue);
306 return result;
307 }
308
309 template <typename T>
element_sub(ublas::vector<T,opencl::storage> const & v,T value,ublas::vector<T,opencl::storage> & result,compute::command_queue & queue)310 void element_sub(ublas::vector<T, opencl::storage> const &v, T value,
311 ublas::vector<T, opencl::storage> &result,
312 compute::command_queue& queue)
313 {
314 assert(v.device() == result.device() && v.device() == queue.get_device());
315 assert(v.size() == result.size());
316 compute::transform(v.begin(), v.end(), result.begin(), lambda::_1 - value, queue);
317 queue.finish();
318 }
319
320 template <typename T, typename A>
element_sub(ublas::vector<T,A> const & v,T value,ublas::vector<T,A> & result,compute::command_queue & queue)321 void element_sub(ublas::vector<T, A> const &v, T value,
322 ublas::vector<T, A> &result,
323 compute::command_queue& queue)
324 {
325 ublas::vector<T, opencl::storage> vdev(v, queue);
326 ublas::vector<T, opencl::storage> rdev(v.size(), queue.get_context());
327 element_sub(vdev, value, rdev, queue);
328 rdev.to_host(result, queue);
329 }
330
331 template <typename T, typename A>
element_sub(ublas::vector<T,A> const & v,T value,compute::command_queue & queue)332 ublas::vector<T, A> element_sub(ublas::vector<T, A> const &v, T value,
333 compute::command_queue& queue)
334 {
335 ublas::vector<T, A> result(v.size());
336 element_sub(v, value, result, queue);
337 return result;
338 }
339
340 template <typename T, typename L1, typename L2, typename L3>
element_prod(ublas::matrix<T,L1,opencl::storage> const & a,ublas::matrix<T,L2,opencl::storage> const & b,ublas::matrix<T,L3,opencl::storage> & result,compute::command_queue & queue)341 void element_prod(ublas::matrix<T, L1, opencl::storage> const &a,
342 ublas::matrix<T, L2, opencl::storage> const &b,
343 ublas::matrix<T, L3, opencl::storage> &result,
344 compute::command_queue& queue)
345 {
346 element_wise(a, b, result, compute::multiplies<T>(), queue);
347 }
348
349 template <typename T, typename L1, typename L2, typename L3, typename A>
element_prod(ublas::matrix<T,L1,A> const & a,ublas::matrix<T,L2,A> const & b,ublas::matrix<T,L3,A> & result,compute::command_queue & queue)350 void element_prod(ublas::matrix<T, L1, A> const &a,
351 ublas::matrix<T, L2, A> const &b,
352 ublas::matrix<T, L3, A> &result,
353 compute::command_queue &queue)
354 {
355 element_wise(a, b, result, compute::multiplies<T>(), queue);
356 }
357
358 template <typename T, typename L1, typename L2, typename A>
element_prod(ublas::matrix<T,L1,A> const & a,ublas::matrix<T,L2,A> const & b,compute::command_queue & queue)359 ublas::matrix<T, L1, A> element_prod(ublas::matrix<T, L1, A> const &a,
360 ublas::matrix<T, L2, A> const &b,
361 compute::command_queue &queue)
362 {
363 return element_wise(a, b, compute::multiplies<T>(), queue);
364 }
365
366 template <typename T>
element_prod(ublas::vector<T,opencl::storage> const & a,ublas::vector<T,opencl::storage> const & b,ublas::vector<T,opencl::storage> & result,compute::command_queue & queue)367 void element_prod(ublas::vector<T, opencl::storage> const &a,
368 ublas::vector<T, opencl::storage> const &b,
369 ublas::vector<T, opencl::storage> &result,
370 compute::command_queue& queue)
371 {
372 element_wise(a, b, result, compute::multiplies<T>(), queue);
373 }
374
375 template <typename T, typename A>
element_prod(ublas::vector<T,A> const & a,ublas::vector<T,A> const & b,ublas::vector<T,A> & result,compute::command_queue & queue)376 void element_prod(ublas::vector<T, A> const &a,
377 ublas::vector<T, A> const &b,
378 ublas::vector<T, A> &result,
379 compute::command_queue &queue)
380 {
381 element_wise(a, b, result, compute::multiplies<T>(), queue);
382 }
383
384 template <typename T, typename A>
element_prod(ublas::vector<T,A> const & a,ublas::vector<T,A> const & b,compute::command_queue & queue)385 ublas::vector<T, A> element_prod(ublas::vector<T, A> const &a,
386 ublas::vector<T, A> const &b,
387 compute::command_queue &queue)
388 {
389 return element_wise(a, b, compute::multiplies<T>(), queue);
390 }
391
392 template <typename T, typename L>
element_scale(ublas::matrix<T,L,opencl::storage> const & m,T value,ublas::matrix<T,L,opencl::storage> & result,compute::command_queue & queue)393 void element_scale(ublas::matrix<T, L, opencl::storage> const &m, T value,
394 ublas::matrix<T, L, opencl::storage> &result,
395 compute::command_queue& queue)
396 {
397 assert(m.device() == result.device() && m.device() == queue.get_device());
398 assert(m.size1() == result.size1() && m.size2() == result.size2());
399 compute::transform(m.begin(), m.end(), result.begin(), lambda::_1 * value, queue);
400 queue.finish();
401 }
402
403 template <typename T, typename L, typename A>
element_scale(ublas::matrix<T,L,A> const & m,T value,ublas::matrix<T,L,A> & result,compute::command_queue & queue)404 void element_scale(ublas::matrix<T, L, A> const &m, T value,
405 ublas::matrix<T, L, A> &result,
406 compute::command_queue& queue)
407 {
408 ublas::matrix<T, L, opencl::storage> mdev(m, queue);
409 ublas::matrix<T, L, opencl::storage> rdev(result.size1(), result.size2(), queue.get_context());
410 element_scale(mdev, value, rdev, queue);
411 rdev.to_host(result, queue);
412 }
413
414 template <typename T, typename L, typename A>
element_scale(ublas::matrix<T,L,A> const & m,T value,compute::command_queue & queue)415 ublas::matrix<T, L, A> element_scale(ublas::matrix<T, L, A> const &m, T value,
416 compute::command_queue& queue)
417 {
418 ublas::matrix<T, L, A> result(m.size1(), m.size2());
419 element_scale(m, value, result, queue);
420 return result;
421 }
422
423 template <typename T>
element_scale(ublas::vector<T,opencl::storage> const & v,T value,ublas::vector<T,opencl::storage> & result,compute::command_queue & queue)424 void element_scale(ublas::vector<T, opencl::storage> const &v, T value,
425 ublas::vector<T, opencl::storage> &result,
426 compute::command_queue& queue)
427 {
428 assert(v.device() == result.device() && v.device() == queue.get_device());
429 assert(v.size() == result.size());
430 compute::transform(v.begin(), v.end(), result.begin(), lambda::_1 * value, queue);
431 queue.finish();
432 }
433
434 template <typename T, typename A>
element_scale(ublas::vector<T,A> const & v,T value,ublas::vector<T,A> & result,compute::command_queue & queue)435 void element_scale(ublas::vector<T, A> const &v, T value,
436 ublas::vector<T, A> & result,
437 compute::command_queue& queue)
438 {
439 ublas::vector<T, opencl::storage> vdev(v, queue);
440 ublas::vector<T, opencl::storage> rdev(v.size(), queue.get_context());
441 element_scale(vdev, value, rdev, queue);
442 rdev.to_host(result, queue);
443 }
444
445 template <typename T, typename A>
element_scale(ublas::vector<T,A> const & v,T value,compute::command_queue & queue)446 ublas::vector<T,A> element_scale(ublas::vector<T, A> const &v, T value,
447 compute::command_queue& queue)
448 {
449 ublas::vector<T, A> result(v.size());
450 element_scale(v, value, result, queue);
451 return result;
452 }
453
454 template <typename T, typename L1, typename L2, typename L3>
element_div(ublas::matrix<T,L1,opencl::storage> const & a,ublas::matrix<T,L2,opencl::storage> const & b,ublas::matrix<T,L3,opencl::storage> & result,compute::command_queue & queue)455 void element_div(ublas::matrix<T, L1, opencl::storage> const &a,
456 ublas::matrix<T, L2, opencl::storage> const &b,
457 ublas::matrix<T, L3, opencl::storage> &result,
458 compute::command_queue& queue)
459 {
460 element_wise(a, b, result, compute::divides<T>(), queue);
461 }
462
463 template <typename T, typename L1, typename L2, typename L3, typename A>
element_div(ublas::matrix<T,L1,A> const & a,ublas::matrix<T,L2,A> const & b,ublas::matrix<T,L3,A> & result,compute::command_queue & queue)464 void element_div(ublas::matrix<T, L1, A> const &a,
465 ublas::matrix<T, L2, A> const &b,
466 ublas::matrix<T, L3, A> &result,
467 compute::command_queue &queue)
468 {
469 element_wise(a, b, result, compute::divides<T>(), queue);
470 }
471
472 template <typename T, typename L1, typename L2, typename A>
element_div(ublas::matrix<T,L1,A> const & a,ublas::matrix<T,L2,A> const & b,compute::command_queue & queue)473 ublas::matrix<T, L1, A> element_div(ublas::matrix<T, L1, A> const &a,
474 ublas::matrix<T, L2, A> const &b,
475 compute::command_queue &queue)
476 {
477 return element_wise(a, b, compute::divides<T>(), queue);
478 }
479
480 template <typename T>
element_div(ublas::vector<T,opencl::storage> const & a,ublas::vector<T,opencl::storage> const & b,ublas::vector<T,opencl::storage> & result,compute::command_queue & queue)481 void element_div(ublas::vector<T, opencl::storage> const &a,
482 ublas::vector<T, opencl::storage> const &b,
483 ublas::vector<T, opencl::storage> &result,
484 compute::command_queue& queue)
485 {
486 element_wise(a, b, result, compute::divides<T>(), queue);
487 }
488
489 template <typename T, typename A>
element_div(ublas::vector<T,A> const & a,ublas::vector<T,A> const & b,ublas::vector<T,A> & result,compute::command_queue & queue)490 void element_div(ublas::vector<T, A> const &a,
491 ublas::vector<T, A> const &b,
492 ublas::vector<T, A> &result,
493 compute::command_queue &queue)
494 {
495 element_wise(a, b, result, compute::divides<T>(), queue);
496 }
497
498 template <typename T, typename A>
element_div(ublas::vector<T,A> const & a,ublas::vector<T,A> const & b,compute::command_queue & queue)499 ublas::vector<T, A> element_div(ublas::vector<T, A> const &a,
500 ublas::vector<T, A> const &b,
501 compute::command_queue &queue)
502 {
503 return element_wise(a, b, compute::divides<T>(), queue);
504 }
505
506 }}}}
507
508 #endif
509