ViennaCL - The Vienna Computing Library: tests/src/matrix_convert.cpp Source File

ViennaCL - The Vienna Computing Library 1.7.1 Free open-source GPU-accelerated linear algebra and solver library. |

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
matrix_convert.cpp
Go to the documentation of this file.
1 /* =========================================================================
2 Copyright (c) 2010-2016, Institute for Microelectronics,
3 Institute for Analysis and Scientific Computing,
4 TU Wien.
5 Portions of this software are copyright by UChicago Argonne, LLC.
6
7 -----------------
8 ViennaCL - The Vienna Computing Library
9 -----------------
10
11 Project Head: Karl Rupp rupp@iue.tuwien.ac.at
12
13 (A list of authors and contributors can be found in the PDF manual)
14
15 License: MIT (X11), see file LICENSE in the base directory
16 ============================================================================= */
17
18
23 //
24 // *** System
25 //
26 #include <iostream>
27 #include <iomanip>
28 #include <vector>
29
30
31 //
32 // *** ViennaCL
33 //
34 //#define VIENNACL_DEBUG_ALL
35 #include "viennacl/backend/memory.hpp"
36 #include "viennacl/matrix.hpp"
37 #include "viennacl/matrix_proxy.hpp"
38
39
40 template<typename NumericT, typename MatrixT>
41 int check(std::vector<NumericT> const & std_dest,
42 std::size_t start1, std::size_t inc1, std::size_t size1,
43 std::size_t start2, std::size_t inc2, std::size_t size2, std::size_t internal_size2,
44 MatrixT const & vcl_dest)
45 {
46 viennacl::backend::typesafe_host_array<NumericT> tempmat(vcl_dest.handle(), vcl_dest.internal_size());
47 viennacl::backend::memory_read(vcl_dest.handle(), 0, tempmat.raw_size(), reinterpret_cast<NumericT*>(tempmat.get()));
48
49 for (std::size_t i=0; i < size1; ++i)
50 {
51 for (std::size_t j=0; j < size2; ++j)
52 {
53 NumericT value_std = std_dest[(i*inc1 + start1) * internal_size2 + (j*inc2 + start2)];
54 NumericT value_dest = vcl_dest.row_major() ? tempmat[(i * vcl_dest.stride1() + vcl_dest.start1()) * vcl_dest.internal_size2() + (j * vcl_dest.stride2() + vcl_dest.start2())]
55 : tempmat[(i * vcl_dest.stride1() + vcl_dest.start1()) + (j * vcl_dest.stride2() + vcl_dest.start2()) * vcl_dest.internal_size1()];
56
57 if (value_std < value_dest || value_std > value_dest)
58 {
59 std::cerr << "Failure at row " << i << ", col " << j << ": STL value " << value_std << ", ViennaCL value " << value_dest << std::endl;
60 return EXIT_FAILURE;
61 }
62 }
63 }
64
65 return EXIT_SUCCESS;
66 }
67
68
69 //
70 // -------------------------------------------------------------
71 //
72 template<typename STLVectorT1, typename STLVectorT2, typename ViennaCLVectorT1, typename ViennaCLVectorT2 >
73 int test(STLVectorT1 & std_src, std::size_t start1_src, std::size_t inc1_src, std::size_t size1_src, std::size_t start2_src, std::size_t inc2_src, std::size_t size2_src, std::size_t internal_size2_src,
74 STLVectorT2 & std_dest, std::size_t start1_dest, std::size_t inc1_dest, std::size_t size1_dest, std::size_t start2_dest, std::size_t inc2_dest, std::size_t size2_dest, std::size_t internal_size2_dest,
75 ViennaCLVectorT1 const & vcl_src, ViennaCLVectorT2 & vcl_dest)
76 {
77 assert(size1_src == size1_dest && bool("Size1 mismatch for STL matrices"));
78 assert(size2_src == size2_dest && bool("Size2 mismatch for STL matrices"));
79 assert(vcl_src.size1() == vcl_dest.size1() && bool("Size1 mismatch for ViennaCL matrices"));
80 assert(vcl_src.size2() == vcl_dest.size2() && bool("Size2 mismatch for ViennaCL matrices"));
81 assert(size1_src == vcl_src.size1() && bool("Size1 mismatch for STL and ViennaCL matrices"));
82 assert(size2_src == vcl_src.size2() && bool("Size2 mismatch for STL and ViennaCL matrices"));
83
84 typedef typename STLVectorT2::value_type DestNumericT;
85
86 for (std::size_t i=0; i<size1_src; ++i)
87 for (std::size_t j=0; j<size2_src; ++j)
88 std_dest[(start1_dest + i * inc1_dest) * internal_size2_dest + (start2_dest + j * inc2_dest)] = static_cast<DestNumericT>(std_src[(start1_src + i * inc1_src) * internal_size2_src + (start2_src + j * inc2_src)]);
89
90 vcl_dest = vcl_src; // here is the conversion taking place
91
92 if (check(std_dest, start1_dest, inc1_dest, size1_dest, start2_dest, inc2_dest, size2_dest, internal_size2_dest, vcl_dest) != EXIT_SUCCESS)
93 return EXIT_FAILURE;
94
95 if (vcl_src.row_major())
96 {
97 viennacl::matrix<DestNumericT> A(vcl_src);
98 if (check(std_dest, start1_dest, inc1_dest, size1_dest, start2_dest, inc2_dest, size2_dest, internal_size2_dest, A) != EXIT_SUCCESS)
99 return EXIT_FAILURE;
100 }
101 else
102 {
103 viennacl::matrix<DestNumericT, viennacl::column_major> A(vcl_src);
104 if (check(std_dest, start1_dest, inc1_dest, size1_dest, start2_dest, inc2_dest, size2_dest, internal_size2_dest, A) != EXIT_SUCCESS)
105 return EXIT_FAILURE;
106 }
107
108 // --------------------------------------------------------------------------
109 return EXIT_SUCCESS;
110 }
111
112 inline std::string type_string(unsigned int) { return "unsigned int"; }
113 inline std::string type_string(int) { return "int"; }
114 inline std::string type_string(unsigned long) { return "unsigned long"; }
115 inline std::string type_string(long) { return "long"; }
116 inline std::string type_string(float) { return "float"; }
117 inline std::string type_string(double) { return "double"; }
118
119 template<typename LayoutT, typename FromNumericT, typename ToNumericT>
120 int test()
121 {
122 int retval = EXIT_SUCCESS;
123
124 std::cout << std::endl;
125 std::cout << "-----------------------------------------------" << std::endl;
126 std::cout << std::endl;
127 std::cout << "Conversion test from " << type_string(FromNumericT()) << " to " << type_string(ToNumericT()) << std::endl;
128 std::cout << std::endl;
129
130 std::size_t full_size1 = 578;
131 std::size_t small_size1 = full_size1 / 4;
132
133 std::size_t full_size2 = 687;
134 std::size_t small_size2 = full_size2 / 4;
135
136 //
137 // Set up STL objects
138 //
139 std::vector<FromNumericT> std_src(full_size1 * full_size2);
140 std::vector<std::vector<FromNumericT> > std_src2(full_size1, std::vector<FromNumericT>(full_size2));
141 std::vector<std::vector<FromNumericT> > std_src_small(small_size1, std::vector<FromNumericT>(small_size2));
142 std::vector<ToNumericT> std_dest(std_src.size());
143
144 for (std::size_t i=0; i<full_size1; ++i)
145 for (std::size_t j=0; j<full_size2; ++j)
146 {
147 std_src[i * full_size2 + j] = FromNumericT(1.0) + FromNumericT(i) + FromNumericT(j);
148 std_src2[i][j] = FromNumericT(1.0) + FromNumericT(i) + FromNumericT(j);
149 if (i < small_size1 && j < small_size2)
150 std_src_small[i][j] = FromNumericT(1.0) + FromNumericT(i) + FromNumericT(j);
151 }
152
153 //
154 // Set up ViennaCL objects
155 //
156 viennacl::matrix<FromNumericT, LayoutT> vcl_src(full_size1, full_size2);
157 viennacl::matrix<ToNumericT, LayoutT> vcl_dest(full_size1, full_size2);
158
159 viennacl::copy(std_src2, vcl_src);
160
161 viennacl::matrix<FromNumericT, LayoutT> vcl_src_small(small_size1, small_size2);
162 viennacl::copy(std_src_small, vcl_src_small);
163 viennacl::matrix<ToNumericT, LayoutT> vcl_dest_small(small_size1, small_size2);
164
165 std::size_t r11_start = 1 + full_size1 / 4;
166 std::size_t r11_stop = r11_start + small_size1;
167 viennacl::range vcl_r11(r11_start, r11_stop);
168
169 std::size_t r12_start = 2 * full_size1 / 4;
170 std::size_t r12_stop = r12_start + small_size1;
171 viennacl::range vcl_r12(r12_start, r12_stop);
172
173 std::size_t r21_start = 2 * full_size2 / 4;
174 std::size_t r21_stop = r21_start + small_size2;
175 viennacl::range vcl_r21(r21_start, r21_stop);
176
177 std::size_t r22_start = 1 + full_size2 / 4;
178 std::size_t r22_stop = r22_start + small_size2;
179 viennacl::range vcl_r22(r22_start, r22_stop);
180
181 viennacl::matrix_range< viennacl::matrix<FromNumericT, LayoutT> > vcl_range_src(vcl_src, vcl_r11, vcl_r21);
182 viennacl::matrix_range< viennacl::matrix<ToNumericT, LayoutT> > vcl_range_dest(vcl_dest, vcl_r12, vcl_r22);
183
184
185
186 std::size_t s11_start = 1 + full_size1 / 5;
187 std::size_t s11_inc = 3;
188 std::size_t s11_size = small_size1;
189 viennacl::slice vcl_s11(s11_start, s11_inc, s11_size);
190
191 std::size_t s12_start = 2 * full_size1 / 5;
192 std::size_t s12_inc = 2;
193 std::size_t s12_size = small_size1;
194 viennacl::slice vcl_s12(s12_start, s12_inc, s12_size);
195
196 std::size_t s21_start = 1 + full_size2 / 5;
197 std::size_t s21_inc = 3;
198 std::size_t s21_size = small_size2;
199 viennacl::slice vcl_s21(s21_start, s21_inc, s21_size);
200
201 std::size_t s22_start = 2 * full_size2 / 5;
202 std::size_t s22_inc = 2;
203 std::size_t s22_size = small_size2;
204 viennacl::slice vcl_s22(s22_start, s22_inc, s22_size);
205
206 viennacl::matrix_slice< viennacl::matrix<FromNumericT, LayoutT> > vcl_slice_src(vcl_src, vcl_s11, vcl_s21);
207 viennacl::matrix_slice< viennacl::matrix<ToNumericT, LayoutT> > vcl_slice_dest(vcl_dest, vcl_s12, vcl_s22);
208
209 //
210 // Now start running tests for vectors, ranges and slices:
211 //
212
213 std::cout << " ** vcl_src = matrix, vcl_dest = matrix **" << std::endl;
214 retval = test(std_src, 0, 1, full_size1, 0, 1, full_size2, full_size2,
215 std_dest, 0, 1, full_size1, 0, 1, full_size2, full_size2,
216 vcl_src, vcl_dest);
217 if (retval != EXIT_SUCCESS)
218 return EXIT_FAILURE;
219
220 std::cout << " ** vcl_src = matrix, vcl_dest = range **" << std::endl;
221 retval = test(std_src, 0, 1, small_size1, 0, 1, small_size2, full_size2,
222 std_dest, r12_start, 1, r12_stop - r12_start, r22_start, 1, r22_stop - r22_start, full_size2,
223 vcl_src_small, vcl_range_dest);
224 if (retval != EXIT_SUCCESS)
225 return EXIT_FAILURE;
226
227 std::cout << " ** vcl_src = matrix, vcl_dest = slice **" << std::endl;
228 retval = test(std_src, 0, 1, small_size1, 0, 1, small_size2, full_size2,
229 std_dest, s12_start, s12_inc, s12_size, s22_start, s22_inc, s22_size, full_size2,
230 vcl_src_small, vcl_slice_dest);
231 if (retval != EXIT_SUCCESS)
232 return EXIT_FAILURE;
233
235
236 std::cout << " ** vcl_src = range, vcl_dest = matrix **" << std::endl;
237 retval = test(std_src, r11_start, 1, r11_stop - r11_start, r21_start, 1, r21_stop - r21_start, full_size2,
238 std_dest, 0, 1, small_size1, 0, 1, small_size2, full_size2,
239 vcl_range_src, vcl_dest_small);
240 if (retval != EXIT_SUCCESS)
241 return EXIT_FAILURE;
242
243 std::cout << " ** vcl_src = range, vcl_dest = range **" << std::endl;
244 retval = test(std_src, r11_start, 1, r11_stop - r11_start, r21_start, 1, r21_stop - r21_start, full_size2,
245 std_dest, r12_start, 1, r12_stop - r12_start, r22_start, 1, r22_stop - r22_start, full_size2,
246 vcl_range_src, vcl_range_dest);
247 if (retval != EXIT_SUCCESS)
248 return EXIT_FAILURE;
249
250 std::cout << " ** vcl_src = range, vcl_dest = slice **" << std::endl;
251 retval = test(std_src, r11_start, 1, r11_stop - r11_start, r21_start, 1, r21_stop - r21_start, full_size2,
252 std_dest, s12_start, s12_inc, s12_size, s22_start, s22_inc, s22_size, full_size2,
253 vcl_range_src, vcl_slice_dest);
254 if (retval != EXIT_SUCCESS)
255 return EXIT_FAILURE;
256
258
259 std::cout << " ** vcl_src = slice, vcl_dest = matrix **" << std::endl;
260 retval = test(std_src, s11_start, s11_inc, s11_size, s21_start, s21_inc, s21_size, full_size2,
261 std_dest, 0, 1, small_size1, 0, 1, small_size2, full_size2,
262 vcl_slice_src, vcl_dest_small);
263 if (retval != EXIT_SUCCESS)
264 return EXIT_FAILURE;
265
266 std::cout << " ** vcl_src = slice, vcl_dest = range **" << std::endl;
267 retval = test(std_src, s11_start, s11_inc, s11_size, s21_start, s21_inc, s21_size, full_size2,
268 std_dest, r12_start, 1, r12_stop - r12_start, r22_start, 1, r22_stop - r22_start, full_size2,
269 vcl_slice_src, vcl_range_dest);
270 if (retval != EXIT_SUCCESS)
271 return EXIT_FAILURE;
272
273 std::cout << " ** vcl_src = slice, vcl_dest = slice **" << std::endl;
274 retval = test(std_src, s11_start, s11_inc, s11_size, s21_start, s21_inc, s21_size, full_size2,
275 std_dest, s12_start, s12_inc, s12_size, s22_start, s22_inc, s22_size, full_size2,
276 vcl_slice_src, vcl_slice_dest);
277 if (retval != EXIT_SUCCESS)
278 return EXIT_FAILURE;
279
280 return EXIT_SUCCESS;
281 }
282
283
284 template<typename FromNumericT, typename ToNumericT>
285 int test()
286 {
287 int retval = test<viennacl::row_major, FromNumericT, ToNumericT>();
288 if (retval == EXIT_SUCCESS)
289 {
290 retval = test<viennacl::column_major, FromNumericT, ToNumericT>();
291 if (retval != EXIT_SUCCESS)
292 std::cerr << "Test failed for column-major!" << std::endl;
293 }
294 else
295 std::cerr << "Test failed for row-major!" << std::endl;
296
297 return retval;
298 }
299
300 //
301 // -------------------------------------------------------------
302 //
303 int main()
304 {
305 std::cout << std::endl;
306 std::cout << "----------------------------------------------" << std::endl;
307 std::cout << "----------------------------------------------" << std::endl;
308 std::cout << "## Test :: Type conversion test for matrices " << std::endl;
309 std::cout << "----------------------------------------------" << std::endl;
310 std::cout << "----------------------------------------------" << std::endl;
311 std::cout << std::endl;
312
313 int retval = EXIT_SUCCESS;
314
315 //
316 // from int
317 //
318 retval = test<int, int>();
319 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
320 else return retval;
321
322 retval = test<int, unsigned int>();
323 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
324 else return retval;
325
326 retval = test<int, long>();
327 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
328 else return retval;
329
330 retval = test<int, unsigned long>();
331 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
332 else return retval;
333
334 retval = test<int, float>();
335 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
336 else return retval;
337
338 retval = test<int, unsigned long>();
339 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
340 else return retval;
341
342 #ifdef VIENNACL_WITH_OPENCL
343 if ( viennacl::ocl::current_device().double_support() )
344 #endif
345 {
346 retval = test<int, double>();
347 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
348 else return retval;
349 }
350
351
352 //
353 // from unsigned int
354 //
355 retval = test<unsigned int, int>();
356 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
357 else return retval;
358
359 retval = test<unsigned int, unsigned int>();
360 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
361 else return retval;
362
363 retval = test<unsigned int, long>();
364 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
365 else return retval;
366
367 retval = test<unsigned int, unsigned long>();
368 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
369 else return retval;
370
371 retval = test<unsigned int, float>();
372 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
373 else return retval;
374
375 retval = test<unsigned int, unsigned long>();
376 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
377 else return retval;
378
379 #ifdef VIENNACL_WITH_OPENCL
380 if ( viennacl::ocl::current_device().double_support() )
381 #endif
382 {
383 retval = test<unsigned int, double>();
384 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
385 else return retval;
386 }
387
388
389 //
390 // from long
391 //
392 retval = test<long, int>();
393 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
394 else return retval;
395
396 retval = test<long, unsigned int>();
397 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
398 else return retval;
399
400 retval = test<long, long>();
401 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
402 else return retval;
403
404 retval = test<long, unsigned long>();
405 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
406 else return retval;
407
408 retval = test<long, float>();
409 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
410 else return retval;
411
412 retval = test<long, unsigned long>();
413 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
414 else return retval;
415
416 #ifdef VIENNACL_WITH_OPENCL
417 if ( viennacl::ocl::current_device().double_support() )
418 #endif
419 {
420 retval = test<long, double>();
421 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
422 else return retval;
423 }
424
425
426 //
427 // from unsigned long
428 //
429 retval = test<unsigned long, int>();
430 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
431 else return retval;
432
433 retval = test<unsigned long, unsigned int>();
434 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
435 else return retval;
436
437 retval = test<unsigned long, long>();
438 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
439 else return retval;
440
441 retval = test<unsigned long, unsigned long>();
442 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
443 else return retval;
444
445 retval = test<unsigned long, float>();
446 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
447 else return retval;
448
449 retval = test<unsigned long, unsigned long>();
450 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
451 else return retval;
452
453 #ifdef VIENNACL_WITH_OPENCL
454 if ( viennacl::ocl::current_device().double_support() )
455 #endif
456 {
457 retval = test<unsigned long, double>();
458 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
459 else return retval;
460 }
461
462 //
463 // from float
464 //
465 retval = test<float, int>();
466 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
467 else return retval;
468
469 retval = test<float, unsigned int>();
470 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
471 else return retval;
472
473 retval = test<float, long>();
474 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
475 else return retval;
476
477 retval = test<float, unsigned long>();
478 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
479 else return retval;
480
481 retval = test<float, float>();
482 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
483 else return retval;
484
485 retval = test<float, unsigned long>();
486 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
487 else return retval;
488
489 #ifdef VIENNACL_WITH_OPENCL
490 if ( viennacl::ocl::current_device().double_support() )
491 #endif
492 {
493 retval = test<float, double>();
494 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
495 else return retval;
496 }
497
498 //
499 // from double
500 //
501 #ifdef VIENNACL_WITH_OPENCL
502 if ( viennacl::ocl::current_device().double_support() )
503 #endif
504 {
505 retval = test<double, int>();
506 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
507 else return retval;
508
509 retval = test<double, unsigned int>();
510 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
511 else return retval;
512
513 retval = test<double, long>();
514 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
515 else return retval;
516
517 retval = test<double, unsigned long>();
518 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
519 else return retval;
520
521 retval = test<double, float>();
522 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
523 else return retval;
524
525 retval = test<double, unsigned long>();
526 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
527 else return retval;
528
529 retval = test<double, double>();
530 if ( retval == EXIT_SUCCESS ) std::cout << "# Test passed" << std::endl;
531 else return retval;
532 }
533
534
535 std::cout << std::endl;
536 std::cout << "------- Test completed --------" << std::endl;
537 std::cout << std::endl;
538
539 return retval;
540 }
viennacl::backend::typesafe_host_array
Helper class implementing an array on the host. Default case: No conversion necessary.
Definition: util.hpp:92
viennacl::matrix_slice
Class for representing strided submatrices of a bigger matrix A.
Definition: forwards.h:443
matrix.hpp
Implementation of the dense matrix class.
viennacl::traits::size1
vcl_size_t size1(MatrixType const &mat)
Generic routine for obtaining the number of rows of a matrix (ViennaCL, uBLAS, etc.)
Definition: size.hpp:163
check
int check(std::vector< NumericT > const &std_dest, std::size_t start1, std::size_t inc1, std::size_t size1, std::size_t start2, std::size_t inc2, std::size_t size2, std::size_t internal_size2, MatrixT const &vcl_dest)
Definition: matrix_convert.cpp:41
viennacl::traits::internal_size2
vcl_size_t internal_size2(matrix_base< NumericT > const &mat)
Helper routine for obtaining the internal number of entries per column of a ViennaCL matrix...
Definition: size.hpp:394
type_string
std::string type_string(unsigned int)
Definition: matrix_convert.cpp:112
viennacl::traits::start1
result_of::size_type< T >::type start1(T const &obj)
Definition: start.hpp:65
viennacl::matrix
A dense matrix class.
Definition: forwards.h:375
viennacl::backend::memory_read
void memory_read(mem_handle const &src_buffer, vcl_size_t src_offset, vcl_size_t bytes_to_read, void *ptr, bool async=false)
Reads data from a buffer back to main RAM.
Definition: memory.hpp:261
viennacl::ocl::current_device
viennacl::ocl::device const & current_device()
Convenience function for returning the active device in the current context.
Definition: backend.hpp:351
viennacl::traits::size2
result_of::size_type< MatrixType >::type size2(MatrixType const &mat)
Generic routine for obtaining the number of columns of a matrix (ViennaCL, uBLAS, etc...
Definition: size.hpp:201
NumericT
float NumericT
Definition: bisect.cpp:40
viennacl::traits::start2
result_of::size_type< T >::type start2(T const &obj)
Definition: start.hpp:84
test
int test(STLVectorT1 &std_src, std::size_t start1_src, std::size_t inc1_src, std::size_t size1_src, std::size_t start2_src, std::size_t inc2_src, std::size_t size2_src, std::size_t internal_size2_src, STLVectorT2 &std_dest, std::size_t start1_dest, std::size_t inc1_dest, std::size_t size1_dest, std::size_t start2_dest, std::size_t inc2_dest, std::size_t size2_dest, std::size_t internal_size2_dest, ViennaCLVectorT1 const &vcl_src, ViennaCLVectorT2 &vcl_dest)
Definition: matrix_convert.cpp:73
viennacl::ocl::device::double_support
bool double_support() const
ViennaCL convenience function: Returns true if the device supports double precision.
Definition: device.hpp:956
matrix_proxy.hpp
Proxy classes for matrices.
viennacl::copy
void copy(std::vector< NumericT > &cpu_vec, circulant_matrix< NumericT, AlignmentV > &gpu_mat)
Copies a circulant matrix from the std::vector to the OpenCL device (either GPU or multi-core CPU) ...
Definition: circulant_matrix.hpp:150
viennacl::basic_range
A range class that refers to an interval [start, stop), where 'start' is included, and 'stop' is excluded.
Definition: forwards.h:424
viennacl::matrix_range
Class for representing non-strided submatrices of a bigger matrix A.
Definition: forwards.h:440
main
int main()
Definition: matrix_convert.cpp:303
viennacl::basic_slice
A slice class that refers to an interval [start, stop), where 'start' is included, and 'stop' is excluded.
Definition: forwards.h:429
memory.hpp
Main interface routines for memory management.