You can subscribe to this list here.
2012 |
Jan
|
Feb
|
Mar
|
Apr
|
May
|
Jun
|
Jul
(6) |
Aug
(30) |
Sep
(1) |
Oct
(10) |
Nov
(8) |
Dec
(1) |
---|---|---|---|---|---|---|---|---|---|---|---|---|
2013 |
Jan
|
Feb
(9) |
Mar
(3) |
Apr
(1) |
May
(2) |
Jun
(2) |
Jul
(73) |
Aug
(145) |
Sep
(32) |
Oct
(45) |
Nov
(4) |
Dec
(76) |
2014 |
Jan
(24) |
Feb
(92) |
Mar
(27) |
Apr
(15) |
May
(57) |
Jun
(49) |
Jul
(105) |
Aug
(125) |
Sep
(7) |
Oct
(19) |
Nov
(70) |
Dec
(4) |
2015 |
Jan
|
Feb
|
Mar
(3) |
Apr
|
May
(8) |
Jun
|
Jul
(40) |
Aug
(29) |
Sep
|
Oct
(8) |
Nov
(1) |
Dec
(7) |
2016 |
Jan
(12) |
Feb
(7) |
Mar
(8) |
Apr
(4) |
May
(20) |
Jun
(4) |
Jul
(38) |
Aug
(44) |
Sep
(11) |
Oct
(10) |
Nov
(13) |
Dec
(4) |
2017 |
Jan
|
Feb
(7) |
Mar
|
Apr
|
May
(1) |
Jun
|
Jul
|
Aug
(2) |
Sep
|
Oct
|
Nov
|
Dec
|
2018 |
Jan
(1) |
Feb
|
Mar
|
Apr
|
May
|
Jun
(4) |
Jul
|
Aug
|
Sep
|
Oct
|
Nov
|
Dec
|
From: Charles D. <cde...@gm...> - 2016-08-15 16:32:51
|
I am trying to verify my interface with clBLAS before going completely in to clMAGMA. However, I keep getting an OpenCL error -38 which corresponds to invalid memory (CL_INVALID_MEM_OBJECT) when trying a clblasDgemm call. This must be referring to the opencl memory handles I am passing in. The fields generally accepts memory buffers (cl_mem) objects. I have tried passing both A.handle.opencl_handle() and A.handle.opencl_handle().get() in those fields but get the same error. I will continue to poke around (maybe I need to use internal_size numbers) but thought I would ask you about this. Any insight? Thanks, Charles On Fri, Aug 12, 2016 at 3:21 PM, Charles Determan <cde...@gm...> wrote: > Thanks Karl, > > One followup question, what distinguishes handle(), handle1(), and > handle2()? Do they refer to different buffers? > > Regards, > Charles > > On Fri, Aug 12, 2016 at 3:13 PM, Karl Rupp <ru...@iu...> wrote: > >> Hi Charles, >> >> call .handle()/.handle1()/.handle2() to get the abstract memory buffers, >> and call .opencl_handle() on them to get the cl_mem handles: >> >> A.handle().opencl_handle() >> >> Similarly, the command queue is obtained with >> viennacl::ocl::get_queue().handle().get() >> >> Unfortunately it's not explicitly written in the manual :-/ >> >> Best regards, >> Karli >> >> >> On 08/12/2016 09:39 PM, Charles Determan wrote: >> >>> I also would need to access the command queue handle (cl_command_queue) >>> object to pass to clBLAS and clMAGMA functions. Is this easily >>> accessible as well? >>> >>> Thanks, >>> Charles >>> >>> On Fri, Aug 12, 2016 at 11:45 AM, Charles Determan >>> <cde...@gm... <mailto:cde...@gm...>> wrote: >>> >>> Thanks Karl, >>> >>> I have been looking through the docs and I can't find an example for >>> how to pull the OpenCL handles from a matrix. I saw a couple I >>> think from a context but not sure that is what I need. Is this in >>> the documentation somewhere? The closest I could fine is this page >>> (http://viennacl.sourceforge.net/doc/manual-memory.html >>> <http://viennacl.sourceforge.net/doc/manual-memory.html>). >>> >>> Regards, >>> Charles >>> >>> On Wed, Aug 10, 2016 at 12:09 PM, <ru...@iu... >>> <mailto:ru...@iu...>> wrote: >>> >>> Hi Charles, >>> >>> >>> I have recently expressed some interest in different >>> factorizations such as >>> QR and SVD. I am aware that these or currently experimental >>> within >>> ViennaCL. Until such a time that these factorizations are >>> fully supported >>> (I hope to contribute but the algorithms are quite complex) >>> would it be >>> feasible to interface with a library like clMAGMA? I'm not >>> sure of any >>> other library offhand that does implement these methods. I >>> thought perhaps >>> VexCL but I couldn't find anything to that effect in the >>> documentation. >>> >>> >>> Sure, you can always grab the OpenCL handles from the matrices >>> and plug that into clMAGMA. >>> I don't think there is any value in ViennaCL wrapping the >>> clMAGMA interfaces, though. >>> >>> Best regards, >>> Karli >>> >>> >>> >>> >>> >> > |
From: Charles D. <cde...@gm...> - 2016-08-12 20:21:24
|
Thanks Karl, One followup question, what distinguishes handle(), handle1(), and handle2()? Do they refer to different buffers? Regards, Charles On Fri, Aug 12, 2016 at 3:13 PM, Karl Rupp <ru...@iu...> wrote: > Hi Charles, > > call .handle()/.handle1()/.handle2() to get the abstract memory buffers, > and call .opencl_handle() on them to get the cl_mem handles: > > A.handle().opencl_handle() > > Similarly, the command queue is obtained with > viennacl::ocl::get_queue().handle().get() > > Unfortunately it's not explicitly written in the manual :-/ > > Best regards, > Karli > > > On 08/12/2016 09:39 PM, Charles Determan wrote: > >> I also would need to access the command queue handle (cl_command_queue) >> object to pass to clBLAS and clMAGMA functions. Is this easily >> accessible as well? >> >> Thanks, >> Charles >> >> On Fri, Aug 12, 2016 at 11:45 AM, Charles Determan >> <cde...@gm... <mailto:cde...@gm...>> wrote: >> >> Thanks Karl, >> >> I have been looking through the docs and I can't find an example for >> how to pull the OpenCL handles from a matrix. I saw a couple I >> think from a context but not sure that is what I need. Is this in >> the documentation somewhere? The closest I could fine is this page >> (http://viennacl.sourceforge.net/doc/manual-memory.html >> <http://viennacl.sourceforge.net/doc/manual-memory.html>). >> >> Regards, >> Charles >> >> On Wed, Aug 10, 2016 at 12:09 PM, <ru...@iu... >> <mailto:ru...@iu...>> wrote: >> >> Hi Charles, >> >> >> I have recently expressed some interest in different >> factorizations such as >> QR and SVD. I am aware that these or currently experimental >> within >> ViennaCL. Until such a time that these factorizations are >> fully supported >> (I hope to contribute but the algorithms are quite complex) >> would it be >> feasible to interface with a library like clMAGMA? I'm not >> sure of any >> other library offhand that does implement these methods. I >> thought perhaps >> VexCL but I couldn't find anything to that effect in the >> documentation. >> >> >> Sure, you can always grab the OpenCL handles from the matrices >> and plug that into clMAGMA. >> I don't think there is any value in ViennaCL wrapping the >> clMAGMA interfaces, though. >> >> Best regards, >> Karli >> >> >> >> >> > |
From: Karl R. <ru...@iu...> - 2016-08-12 20:13:44
|
Hi Charles, call .handle()/.handle1()/.handle2() to get the abstract memory buffers, and call .opencl_handle() on them to get the cl_mem handles: A.handle().opencl_handle() Similarly, the command queue is obtained with viennacl::ocl::get_queue().handle().get() Unfortunately it's not explicitly written in the manual :-/ Best regards, Karli On 08/12/2016 09:39 PM, Charles Determan wrote: > I also would need to access the command queue handle (cl_command_queue) > object to pass to clBLAS and clMAGMA functions. Is this easily > accessible as well? > > Thanks, > Charles > > On Fri, Aug 12, 2016 at 11:45 AM, Charles Determan > <cde...@gm... <mailto:cde...@gm...>> wrote: > > Thanks Karl, > > I have been looking through the docs and I can't find an example for > how to pull the OpenCL handles from a matrix. I saw a couple I > think from a context but not sure that is what I need. Is this in > the documentation somewhere? The closest I could fine is this page > (http://viennacl.sourceforge.net/doc/manual-memory.html > <http://viennacl.sourceforge.net/doc/manual-memory.html>). > > Regards, > Charles > > On Wed, Aug 10, 2016 at 12:09 PM, <ru...@iu... > <mailto:ru...@iu...>> wrote: > > Hi Charles, > > > I have recently expressed some interest in different > factorizations such as > QR and SVD. I am aware that these or currently experimental > within > ViennaCL. Until such a time that these factorizations are > fully supported > (I hope to contribute but the algorithms are quite complex) > would it be > feasible to interface with a library like clMAGMA? I'm not > sure of any > other library offhand that does implement these methods. I > thought perhaps > VexCL but I couldn't find anything to that effect in the > documentation. > > > Sure, you can always grab the OpenCL handles from the matrices > and plug that into clMAGMA. > I don't think there is any value in ViennaCL wrapping the > clMAGMA interfaces, though. > > Best regards, > Karli > > > > |
From: Charles D. <cde...@gm...> - 2016-08-12 19:39:33
|
I also would need to access the command queue handle (cl_command_queue) object to pass to clBLAS and clMAGMA functions. Is this easily accessible as well? Thanks, Charles On Fri, Aug 12, 2016 at 11:45 AM, Charles Determan <cde...@gm...> wrote: > Thanks Karl, > > I have been looking through the docs and I can't find an example for how > to pull the OpenCL handles from a matrix. I saw a couple I think from a > context but not sure that is what I need. Is this in the documentation > somewhere? The closest I could fine is this page ( > http://viennacl.sourceforge.net/doc/manual-memory.html). > > Regards, > Charles > > On Wed, Aug 10, 2016 at 12:09 PM, <ru...@iu...> wrote: > >> Hi Charles, >> >> >> I have recently expressed some interest in different factorizations such >>> as >>> QR and SVD. I am aware that these or currently experimental within >>> ViennaCL. Until such a time that these factorizations are fully >>> supported >>> (I hope to contribute but the algorithms are quite complex) would it be >>> feasible to interface with a library like clMAGMA? I'm not sure of any >>> other library offhand that does implement these methods. I thought >>> perhaps >>> VexCL but I couldn't find anything to that effect in the documentation. >>> >> >> Sure, you can always grab the OpenCL handles from the matrices and plug >> that into clMAGMA. >> I don't think there is any value in ViennaCL wrapping the clMAGMA >> interfaces, though. >> >> Best regards, >> Karli >> >> >> > |
From: Charles D. <cde...@gm...> - 2016-08-12 16:45:35
|
Thanks Karl, I have been looking through the docs and I can't find an example for how to pull the OpenCL handles from a matrix. I saw a couple I think from a context but not sure that is what I need. Is this in the documentation somewhere? The closest I could fine is this page ( http://viennacl.sourceforge.net/doc/manual-memory.html). Regards, Charles On Wed, Aug 10, 2016 at 12:09 PM, <ru...@iu...> wrote: > Hi Charles, > > > I have recently expressed some interest in different factorizations such as >> QR and SVD. I am aware that these or currently experimental within >> ViennaCL. Until such a time that these factorizations are fully supported >> (I hope to contribute but the algorithms are quite complex) would it be >> feasible to interface with a library like clMAGMA? I'm not sure of any >> other library offhand that does implement these methods. I thought >> perhaps >> VexCL but I couldn't find anything to that effect in the documentation. >> > > Sure, you can always grab the OpenCL handles from the matrices and plug > that into clMAGMA. > I don't think there is any value in ViennaCL wrapping the clMAGMA > interfaces, though. > > Best regards, > Karli > > > |
From: Karl R. <ru...@iu...> - 2016-08-11 12:42:21
|
Hi Tanguy, > we are working with an arm 7 on an imx6q board and wonder if ViennaCL > supports the opencl 1.1 Embedded Profile. No, the embedded profile is not supported. Since the embedded profile is not part of OpenCL 2.0 and since newer mobile GPUs tend to have full OpenCL support, it is unlikely that we will add support for OpenCL 1.1 EP in the future. Best regards, Karli |
From: Tanguy M. <Tan...@ma...> - 2016-08-11 09:44:55
|
Hi, we are working with an arm 7 on an imx6q board and wonder if ViennaCL supports the opencl 1.1 Embedded Profile. Thanks, Tanguy Mezzano |
From: <ru...@iu...> - 2016-08-10 17:09:57
|
Hi Charles, > I have recently expressed some interest in different factorizations such as > QR and SVD. I am aware that these or currently experimental within > ViennaCL. Until such a time that these factorizations are fully supported > (I hope to contribute but the algorithms are quite complex) would it be > feasible to interface with a library like clMAGMA? I'm not sure of any > other library offhand that does implement these methods. I thought perhaps > VexCL but I couldn't find anything to that effect in the documentation. Sure, you can always grab the OpenCL handles from the matrices and plug that into clMAGMA. I don't think there is any value in ViennaCL wrapping the clMAGMA interfaces, though. Best regards, Karli |
From: Charles D. <cde...@gm...> - 2016-08-10 13:13:39
|
I have recently expressed some interest in different factorizations such as QR and SVD. I am aware that these or currently experimental within ViennaCL. Until such a time that these factorizations are fully supported (I hope to contribute but the algorithms are quite complex) would it be feasible to interface with a library like clMAGMA? I'm not sure of any other library offhand that does implement these methods. I thought perhaps VexCL but I couldn't find anything to that effect in the documentation. Regards, Charles |
From: Andrew P. <ap...@ou...> - 2016-08-08 18:04:04
|
In file included from /usr/include/viennacl/linalg/sparse_matrix_operations.hpp:28:0, from /usr/include/viennacl/compressed_matrix.hpp:31, from sparseDenseMmul.cpp:7: /usr/include/viennacl/matrix.hpp: In instantiation of âstatic void viennacl::linalg::detail::op_executor<viennacl::matrix_base<T>, viennacl::op_assign, viennacl::matrix_expression<const LHS, const RHS, viennacl::op_prod> >::apply(viennacl::matrix_base<T>&, const viennacl::matrix_expression<const SparseMatrixType, const viennacl::matrix_base<T>, viennacl::op_prod>&) [with SparseMatrixType = viennacl::compressed_matrix<double>; T = double; LHS = viennacl::compressed_matrix<double>; RHS = viennacl::matrix_base<double, long unsigned int, long int>]â: /usr/include/viennacl/matrix.hpp:324:107: required from âviennacl::matrix_base<NumericT, SizeT, DistanceT>& viennacl::matrix_base<SCALARTYPE, SizeType, DistanceType>::operator=(const viennacl::matrix_expression<const LHS, const RHS, OP>&) [with LHS = viennacl::compressed_matrix<double>; RHS = viennacl::matrix_base<double, long unsigned int, long int>; OP = viennacl::op_prod; NumericT = double; SizeT = long unsigned int; DistanceT = long int]â /usr/include/viennacl/matrix.hpp:155:25: required from âviennacl::matrix_base<SCALARTYPE, SizeType, DistanceType>::matrix_base(const viennacl::matrix_expression<const LHS, const RHS, OP>&) [with LHS = viennacl::compressed_matrix<double>; RHS = viennacl::matrix_base<double, long unsigned int, long int>; OP = viennacl::op_prod; NumericT = double; SizeT = long unsigned int; DistanceT = long int]â /usr/include/viennacl/matrix.hpp:750:75: required from âviennacl::matrix<SCALARTYPE, F, ALIGNMENT>::matrix(const viennacl::matrix_expression<LHS, RHS, OP>&) [with LHS = const viennacl::compressed_matrix<double>; RHS = const viennacl::matrix_base<double, long unsigned int, long int>; OP = viennacl::op_prod; NumericT = double; F = viennacl::row_major; unsigned int AlignmentV = 1u]â sparseDenseMmul.cpp:83:103: required from here /usr/include/viennacl/matrix.hpp:2247:36: error: no matching function for call to âprod_impl(const viennacl::compressed_matrix<double>&, const viennacl::matrix_base<double, long unsigned int, long int>&, viennacl::matrix_base<double, long unsigned int, long int>&)â viennacl::linalg::prod_impl(proxy.lhs(), proxy.rhs(), lhs); ^ In file included from /usr/include/viennacl/matrix.hpp:28:0, from /usr/include/viennacl/linalg/sparse_matrix_operations.hpp:28, from /usr/include/viennacl/compressed_matrix.hpp:31, from sparseDenseMmul.cpp:7: /usr/include/viennacl/linalg/matrix_operations.hpp:438:10: note: candidate: template<class NumericT> void viennacl::linalg::prod_impl(const viennacl::matrix_base<T>&, const viennacl::vector_base<T>&, viennacl::vector_base<T>&) void prod_impl(const matrix_base<NumericT> & mat, ^ /usr/include/viennacl/linalg/matrix_operations.hpp:438:10: note: template argument deduction/substitution failed: In file included from /usr/include/viennacl/linalg/sparse_matrix_operations.hpp:28:0, from /usr/include/viennacl/compressed_matrix.hpp:31, from sparseDenseMmul.cpp:7: /usr/include/viennacl/matrix.hpp:2247:36: note: âconst viennacl::compressed_matrix<double>â is not derived from âconst viennacl::matrix_base<T>â viennacl::linalg::prod_impl(proxy.lhs(), proxy.rhs(), lhs); ^ In file included from /usr/include/viennacl/matrix.hpp:28:0, from /usr/include/viennacl/linalg/sparse_matrix_operations.hpp:28, from /usr/include/viennacl/compressed_matrix.hpp:31, from sparseDenseMmul.cpp:7: /usr/include/viennacl/linalg/matrix_operations.hpp:479:10: note: candidate: template<class NumericT> void viennacl::linalg::prod_impl(const viennacl::matrix_expression<const viennacl::matrix_base<T>, const viennacl::matrix_base<T>, viennacl::op_trans>&, const viennacl::vector_base<T>&, viennacl::vector_base<T>&) void prod_impl(const matrix_expression< const matrix_base<NumericT>, const matrix_base<NumericT>, op_trans> & mat_trans, ^ /usr/include/viennacl/linalg/matrix_operations.hpp:479:10: note: template argument deduction/substitution failed: In file included from /usr/include/viennacl/linalg/sparse_matrix_operations.hpp:28:0, from /usr/include/viennacl/compressed_matrix.hpp:31, from sparseDenseMmul.cpp:7: /usr/include/viennacl/matrix.hpp:2247:36: note: âconst viennacl::compressed_matrix<double>â is not derived from âconst viennacl::matrix_expression<const viennacl::matrix_base<T>, const viennacl::matrix_base<T>, viennacl::op_trans>â viennacl::linalg::prod_impl(proxy.lhs(), proxy.rhs(), lhs); ^ In file included from sparseDenseMmul.cpp:6:0: /usr/include/viennacl/forwards.h:820:5: note: candidate: template<class SparseMatrixType, class SCALARTYPE, unsigned int ALIGNMENT> typename viennacl::enable_if<viennacl::is_any_sparse_matrix<T>::value, viennacl::vector_expression<const SparseMatrixType, const viennacl::vector<SCALARTYPE, ALIGNMENT>, viennacl::op_prod> >::type viennacl::linalg::prod_impl(const SparseMatrixType&, const viennacl::vector<SCALARTYPE, ALIGNMENT>&) prod_impl(const SparseMatrixType & mat, ^ /usr/include/viennacl/forwards.h:820:5: note: template argument deduction/substitution failed: In file included from /usr/include/viennacl/linalg/sparse_matrix_operations.hpp:28:0, from /usr/include/viennacl/compressed_matrix.hpp:31, from sparseDenseMmul.cpp:7: /usr/include/viennacl/matrix.hpp:2247:36: note: âconst viennacl::matrix_base<double, long unsigned int, long int>â is not derived from âconst viennacl::vector<SCALARTYPE, ALIGNMENT>â viennacl::linalg::prod_impl(proxy.lhs(), proxy.rhs(), lhs); ^ In file included from /usr/include/viennacl/matrix.hpp:28:0, from /usr/include/viennacl/linalg/sparse_matrix_operations.hpp:28, from /usr/include/viennacl/compressed_matrix.hpp:31, from sparseDenseMmul.cpp:7: /usr/include/viennacl/linalg/matrix_operations.hpp:519:10: note: candidate: template<class NumericT, class ScalarType> void viennacl::linalg::prod_impl(const viennacl::matrix_base<T>&, const viennacl::matrix_base<T>&, viennacl::matrix_base<T>&, ScalarType, ScalarType) void prod_impl(const matrix_base<NumericT> & A, ^ /usr/include/viennacl/linalg/matrix_operations.hpp:519:10: note: template argument deduction/substitution failed: In file included from /usr/include/viennacl/linalg/sparse_matrix_operations.hpp:28:0, from /usr/include/viennacl/compressed_matrix.hpp:31, from sparseDenseMmul.cpp:7: /usr/include/viennacl/matrix.hpp:2247:36: note: âconst viennacl::compressed_matrix<double>â is not derived from âconst viennacl::matrix_base<T>â viennacl::linalg::prod_impl(proxy.lhs(), proxy.rhs(), lhs); ^ In file included from /usr/include/viennacl/matrix.hpp:28:0, from /usr/include/viennacl/linalg/sparse_matrix_operations.hpp:28, from /usr/include/viennacl/compressed_matrix.hpp:31, from sparseDenseMmul.cpp:7: /usr/include/viennacl/linalg/matrix_operations.hpp:560:10: note: candidate: template<class NumericT, class ScalarType> void viennacl::linalg::prod_impl(const viennacl::matrix_expression<const viennacl::matrix_base<T>, const viennacl::matrix_base<T>, viennacl::op_trans>&, const viennacl::matrix_base<T>&, viennacl::matrix_base<T>&, ScalarType, ScalarType) void prod_impl(const viennacl::matrix_expression< const matrix_base<NumericT>, ^ /usr/include/viennacl/linalg/matrix_operations.hpp:560:10: note: template argument deduction/substitution failed: In file included from /usr/include/viennacl/linalg/sparse_matrix_operations.hpp:28:0, from /usr/include/viennacl/compressed_matrix.hpp:31, from sparseDenseMmul.cpp:7: /usr/include/viennacl/matrix.hpp:2247:36: note: âconst viennacl::compressed_matrix<double>â is not derived from âconst viennacl::matrix_expression<const viennacl::matrix_base<T>, const viennacl::matrix_base<T>, viennacl::op_trans>â viennacl::linalg::prod_impl(proxy.lhs(), proxy.rhs(), lhs); ^ In file included from /usr/include/viennacl/matrix.hpp:28:0, from /usr/include/viennacl/linalg/sparse_matrix_operations.hpp:28, from /usr/include/viennacl/compressed_matrix.hpp:31, from sparseDenseMmul.cpp:7: /usr/include/viennacl/linalg/matrix_operations.hpp:603:10: note: candidate: template<class NumericT, class ScalarType> void viennacl::linalg::prod_impl(const viennacl::matrix_base<T>&, const viennacl::matrix_expression<const viennacl::matrix_base<T>, const viennacl::matrix_base<T>, viennacl::op_trans>&, viennacl::matrix_base<T>&, ScalarType, ScalarType) void prod_impl(const matrix_base<NumericT> & A, ^ /usr/include/viennacl/linalg/matrix_operations.hpp:603:10: note: template argument deduction/substitution failed: In file included from /usr/include/viennacl/linalg/sparse_matrix_operations.hpp:28:0, from /usr/include/viennacl/compressed_matrix.hpp:31, from sparseDenseMmul.cpp:7: /usr/include/viennacl/matrix.hpp:2247:36: note: âconst viennacl::compressed_matrix<double>â is not derived from âconst viennacl::matrix_base<T>â viennacl::linalg::prod_impl(proxy.lhs(), proxy.rhs(), lhs); ^ In file included from /usr/include/viennacl/matrix.hpp:28:0, from /usr/include/viennacl/linalg/sparse_matrix_operations.hpp:28, from /usr/include/viennacl/compressed_matrix.hpp:31, from sparseDenseMmul.cpp:7: /usr/include/viennacl/linalg/matrix_operations.hpp:643:10: note: candidate: template<class NumericT, class ScalarType> void viennacl::linalg::prod_impl(const viennacl::matrix_expression<const viennacl::matrix_base<T>, const viennacl::matrix_base<T>, viennacl::op_trans>&, const viennacl::matrix_expression<const viennacl::matrix_base<T>, const viennacl::matrix_base<T>, viennacl::op_trans>&, viennacl::matrix_base<T>&, ScalarType, ScalarType) void prod_impl(const viennacl::matrix_expression< const matrix_base<NumericT>, const matrix_base<NumericT>, op_trans> & A, ^ /usr/include/viennacl/linalg/matrix_operations.hpp:643:10: note: template argument deduction/substitution failed: In file included from /usr/include/viennacl/linalg/sparse_matrix_operations.hpp:28:0, from /usr/include/viennacl/compressed_matrix.hpp:31, from sparseDenseMmul.cpp:7: /usr/include/viennacl/matrix.hpp:2247:36: note: âconst viennacl::compressed_matrix<double>â is not derived from âconst viennacl::matrix_expression<const viennacl::matrix_base<T>, const viennacl::matrix_base<T>, viennacl::op_trans>â viennacl::linalg::prod_impl(proxy.lhs(), proxy.rhs(), lhs); ^ |
From: Karl R. <ru...@iu...> - 2016-08-07 18:20:37
|
Hi Andy, the relevant tests for sparse matrices times dense matrices are in tests/spmdm.cpp. In particular, I recreated a test case based on your description and couldn't find any issues: viennacl::compressed_matrix<NumericT> compressed_A; viennacl::matrix<NumericT, FactorLayoutT> B1(std_A.size(), cols_rhs); viennacl::matrix_base<NumericT> B1_ref(B1); viennacl::matrix_base<NumericT> C2(viennacl::linalg::prod(compressed_A, B1_ref)); compiles cleanly. Could you please provide a code snippet demonstrating the problem you are encountering? Thanks and best regards, Karli On 08/05/2016 09:04 PM, Andrew Palumbo wrote: > Hi Karl, > > > I've been trying to implement tests for: > > > matrix_base<double> C = compressed_matrix<double> A %*% > > matrix_base<double,row_major> B. > > > I cant find in the code or the documentation any constructor for > matrix_base<T>( > > matrix_expression<const viennacl::compressed_matrix<T>, const > viennacl::matrix_base<T>, viennacl::op_prod>) > > ie. a mixed expression of compressed_matrix and matrix_base > > and get a compilation error when I try to instantiate a: > > matrix_base<double>(matrix_expression<const > viennacl::compressed_matrix<double>, const > viennacl::matrix_base<double>, > viennacl::op_prod>) > > Is there a transformation that I need to do from this > > matrix_expression<compressed_matrix<double>, matrix_base<double>, > op_prod> > > to something else so that I may be able to initialize a matrix_base (or > possibly even a compressed_matrix) from it? > > The compilation error that i get is below. > > Thanks, > > Andy > |
From: Andrew P. <ap...@ou...> - 2016-08-05 21:54:17
|
Thanks Karli, much appreciated as always. -------- Original message -------- From: Karl Rupp <ru...@iu...> Date: 08/05/2016 5:13 PM (GMT-05:00) To: Andrew Palumbo <ap...@ou...>, vie...@li... Subject: Re: [ViennaCL-devel] compressed_matrix %*% matrix_Base Hi Andy, hmm, a first look doesn't reveal anything suspicious in the constructor code. I'll have a close look on Sunday. Best regards, Karli On 08/05/2016 09:04 PM, Andrew Palumbo wrote: > Hi Karl, > > > I've been trying to implement tests for: > > > matrix_base<double> C = compressed_matrix<double> A %*% > > matrix_base<double,row_major> B. > > > I cant find in the code or the documentation any constructor for > matrix_base<T>( > > matrix_expression<const viennacl::compressed_matrix<T>, const > viennacl::matrix_base<T>, viennacl::op_prod>) > > ie. a mixed expression of compressed_matrix and matrix_base > > and get a compilation error when I try to instantiate a: > > matrix_base<double>(matrix_expression<const > viennacl::compressed_matrix<double>, const > viennacl::matrix_base<double>, > viennacl::op_prod>) > > Is there a transformation that I need to do from this > > matrix_expression<compressed_matrix<double>, matrix_base<double>, > op_prod> > > to something else so that I may be able to initialize a matrix_base (or > possibly even a compressed_matrix) from it? > > The compilation error that i get is below. > > Thanks, > > Andy > > {...} > > /usr/include/viennacl/matrix.hpp: In instantiation of ‘static void > viennacl::linalg::detail::op_executor<viennacl::matrix_base<T>, > viennacl::op_assign, viennacl::matrix_expression<const LHS, const RHS, > viennacl::op_prod> >::apply(viennacl::matrix_base<T>&, const > viennacl::matrix_expression<const SparseMatrixType, const > viennacl::matrix_base<T>, viennacl::op_prod>&) [with SparseMatrixType = > viennacl::compressed_matrix<double>; T = double; LHS = > viennacl::compressed_matrix<double>; RHS = viennacl::matrix_base<double>]’: > > /usr/include/viennacl/matrix.hpp:324:107: required from > ‘viennacl::matrix_base<NumericT, SizeT, DistanceT>& > viennacl::matrix_base<SCALARTYPE, SizeType, > DistanceType>::operator=(const viennacl::matrix_expression<const LHS, > const RHS, OP>&) [with LHS = viennacl::compressed_matrix<double>; RHS = > viennacl::matrix_base<double>; OP = viennacl::op_prod; NumericT = > double; SizeT = long unsigned int; DistanceT = long int]’ > > {...} > > > ------------------------------------------------------------------------ > *From:* Andrew Palumbo <ap...@ou...> > *Sent:* Thursday, August 4, 2016 11:06:33 AM > *To:* Karl Rupp; vie...@li... > *Subject:* Re: [ViennaCL-devel] compressed_matrix %*% matrix_Base > > Thanks Karl- Appreciate it! > > > ------------------------------------------------------------------------ > *From:* Karl Rupp <ru...@iu...> > *Sent:* Thursday, August 4, 2016 3:36:53 AM > *To:* Andrew Palumbo; vie...@li... > *Subject:* Re: [ViennaCL-devel] compressed_matrix %*% matrix_Base > Hi Andrew, > > > > On 08/04/2016 01:33 AM, Andrew Palumbo wrote: >> Oops sorry - wrong class in the last post. Too many things going on at >> once. >> >> >> @Properties(inherit = Array(classOf[Context]), >> value = Array(new Platform( >> include =Array("matrix.hpp"), >> library ="jniViennaCL") >> )) >> @Namespace("viennacl") >> @Name(Array("matrix_expression<const viennacl::compressed_matrix<double>, " + >> "const viennacl::matrix_base<double>, " + >> "viennacl::op_prod>")) > > yes, this is the right result expression template type. > > Regarding trans: Currently the functionality isn't fully exposed through > the API, i.e. you cannot write A = trans(B) for sparse matrices A and B. > However, the functionality is implemented in > viennacl::linalg::detail::amg::amg_transpose(B, A) and will be properly > exposed soon. > > Best regards, > Karli > > > > > >> ------------------------------------------------------------------------ >> *From:* Andrew Palumbo <ap...@ou...> >> *Sent:* Wednesday, August 3, 2016 6:44:10 PM >> *To:* Karl Rupp; vie...@li... >> *Subject:* Re: [ViennaCL-devel] compressed_matrix %*% matrix_Base >> >> Hi Karl, as always thanks for the quick response. >> >> I Just needed a point in the right direction, and have it compiling >> now. (Tests up next). >> >> Just FYI, I needed a new class for the product result: >> >> @Properties(inherit = Array(classOf[Context]), >> value = Array(new Platform( >> include =Array("matrix.hpp"), >> library ="jniViennaCL") >> )) >> @Namespace("viennacl") >> @Name(Array("vector_expression<const viennacl::matrix_base<double>, " + >> "const viennacl::vector_base<double>, " + >> "viennacl::op_prod>")) >> class MatVecProdExpressionextends Pointer { >> >> } >> >> Wanted to make sure that I wasn't grinding my wheels. >> >> Thanks alot for your time. >> >> One more question, there is no `trans(compressed_matrix cm)` function >> correct? This should just be done by taking the teanspose first of the >> matrix before converting it to CSR, etc? Curious, as we may be able to >> shave a small amount of time if so. >> >> Thanks! >> >> Andy >> >> >> ------------------------------------------------------------------------ >> *From:* Karl Rupp <ru...@iu...> >> *Sent:* Wednesday, August 3, 2016 5:28:58 PM >> *To:* Andrew Palumbo; vie...@li... >> *Subject:* Re: [ViennaCL-devel] compressed_matrix %*% matrix_Base >> Hi Andrew, >> >> > I'm having some trouble with sparse `compressed_matrix` `matrix`(base) >>> matrix multiplication. This is supported, correct? >> >> Yes. Could you please let us know what you have tried already? >> It shouldn't be any more code to write than >> >> viennacl::compressed_matrix<T> A(...); >> viennacl::matrix<T> B(...); >> viennacl::matrix<T> C = viennacl::linalg::prod(A, B); >> >> Make sure to >> #include "viennacl/matrix.hpp" >> #include "viennacl/compressed_matrix.hpp" >> #include "viennacl/linalg/prod.hpp" >> at the beginning; otherwise you get incomprehensible C++ compiler output. >> >> Best regards, >> Karli >> >> >> >> >>> >>> >>> I've been trying to use the: >>> >>> >>> template< typename SparseMatrixType, typename SCALARTYPE> >>> typename viennacl::enable_if< >>> viennacl::is_any_sparse_matrix<SparseMatrixType>::value >>> <http://viennacl.sourceforge.net/doc/structviennacl_1_1enable__if.html>, >>> viennacl::matrix_expression >>> <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__expression.html><const >>> SparseMatrixType, >>> const matrix_base <SCALARTYPE> >>> <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__base.html>, >>> op_prod >>> <http://viennacl.sourceforge.net/doc/structviennacl_1_1op__prod.html> > >>> >::type >>> <http://viennacl.sourceforge.net/doc/namespaceviennacl_1_1linalg.html#a3bba0146e669e012bb7c7380ce780a25> >>> prod >>> <http://viennacl.sourceforge.net/doc/namespaceviennacl_1_1linalg.html#aa18d10f8a90e38bd9ff43c650fc670ef>(const >>> SparseMatrixType & sp_mat, >>> const viennacl::matrix_base<SCALARTYPE> >>> <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__base.html> >>> & d_mat) >>> { >>> return viennacl::matrix_expression >>> <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__expression.html><const >>> SparseMatrixType, >>> const viennacl::matrix_base<SCALARTYPE> >>> <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__base.html>, >>> op_prod >>> <http://viennacl.sourceforge.net/doc/structviennacl_1_1op__prod.html> >>> >(sp_mat, d_mat); >>> >>> >>> method from prod.hpp. >>> >>> >>> I just wanted to make sure that this was the correct method, and that it >>> accepted `compressed_matrix`s as `sp_mat`. Is that correct? I'm >>> mapping this to java via javacpp so the templates can prove difficult, >>> and are likely where I'm getting errors. >>> >>> >>> Just wanted to confirm that this was supported as I am using it (and >>> that there is not a more straightforward way with fewer template arguments. >>> >>> >>> Thanks, >>> >>> >>> Andy >>> >>> >>> >>> ------------------------------------------------------------------------------ >>> >>> >>> >>> _______________________________________________ >>> ViennaCL-devel mailing list >>> Vie...@li... >>>https://lists.sourceforge.net/lists/listinfo/viennacl-devel >>> >> > |
From: Karl R. <ru...@iu...> - 2016-08-05 21:13:45
|
Hi Andy, hmm, a first look doesn't reveal anything suspicious in the constructor code. I'll have a close look on Sunday. Best regards, Karli On 08/05/2016 09:04 PM, Andrew Palumbo wrote: > Hi Karl, > > > I've been trying to implement tests for: > > > matrix_base<double> C = compressed_matrix<double> A %*% > > matrix_base<double,row_major> B. > > > I cant find in the code or the documentation any constructor for > matrix_base<T>( > > matrix_expression<const viennacl::compressed_matrix<T>, const > viennacl::matrix_base<T>, viennacl::op_prod>) > > ie. a mixed expression of compressed_matrix and matrix_base > > and get a compilation error when I try to instantiate a: > > matrix_base<double>(matrix_expression<const > viennacl::compressed_matrix<double>, const > viennacl::matrix_base<double>, > viennacl::op_prod>) > > Is there a transformation that I need to do from this > > matrix_expression<compressed_matrix<double>, matrix_base<double>, > op_prod> > > to something else so that I may be able to initialize a matrix_base (or > possibly even a compressed_matrix) from it? > > The compilation error that i get is below. > > Thanks, > > Andy > > {...} > > /usr/include/viennacl/matrix.hpp: In instantiation of ‘static void > viennacl::linalg::detail::op_executor<viennacl::matrix_base<T>, > viennacl::op_assign, viennacl::matrix_expression<const LHS, const RHS, > viennacl::op_prod> >::apply(viennacl::matrix_base<T>&, const > viennacl::matrix_expression<const SparseMatrixType, const > viennacl::matrix_base<T>, viennacl::op_prod>&) [with SparseMatrixType = > viennacl::compressed_matrix<double>; T = double; LHS = > viennacl::compressed_matrix<double>; RHS = viennacl::matrix_base<double>]’: > > /usr/include/viennacl/matrix.hpp:324:107: required from > ‘viennacl::matrix_base<NumericT, SizeT, DistanceT>& > viennacl::matrix_base<SCALARTYPE, SizeType, > DistanceType>::operator=(const viennacl::matrix_expression<const LHS, > const RHS, OP>&) [with LHS = viennacl::compressed_matrix<double>; RHS = > viennacl::matrix_base<double>; OP = viennacl::op_prod; NumericT = > double; SizeT = long unsigned int; DistanceT = long int]’ > > {...} > > > ------------------------------------------------------------------------ > *From:* Andrew Palumbo <ap...@ou...> > *Sent:* Thursday, August 4, 2016 11:06:33 AM > *To:* Karl Rupp; vie...@li... > *Subject:* Re: [ViennaCL-devel] compressed_matrix %*% matrix_Base > > Thanks Karl- Appreciate it! > > > ------------------------------------------------------------------------ > *From:* Karl Rupp <ru...@iu...> > *Sent:* Thursday, August 4, 2016 3:36:53 AM > *To:* Andrew Palumbo; vie...@li... > *Subject:* Re: [ViennaCL-devel] compressed_matrix %*% matrix_Base > Hi Andrew, > > > > On 08/04/2016 01:33 AM, Andrew Palumbo wrote: >> Oops sorry - wrong class in the last post. Too many things going on at >> once. >> >> >> @Properties(inherit = Array(classOf[Context]), >> value = Array(new Platform( >> include =Array("matrix.hpp"), >> library ="jniViennaCL") >> )) >> @Namespace("viennacl") >> @Name(Array("matrix_expression<const viennacl::compressed_matrix<double>, " + >> "const viennacl::matrix_base<double>, " + >> "viennacl::op_prod>")) > > yes, this is the right result expression template type. > > Regarding trans: Currently the functionality isn't fully exposed through > the API, i.e. you cannot write A = trans(B) for sparse matrices A and B. > However, the functionality is implemented in > viennacl::linalg::detail::amg::amg_transpose(B, A) and will be properly > exposed soon. > > Best regards, > Karli > > > > > >> ------------------------------------------------------------------------ >> *From:* Andrew Palumbo <ap...@ou...> >> *Sent:* Wednesday, August 3, 2016 6:44:10 PM >> *To:* Karl Rupp; vie...@li... >> *Subject:* Re: [ViennaCL-devel] compressed_matrix %*% matrix_Base >> >> Hi Karl, as always thanks for the quick response. >> >> I Just needed a point in the right direction, and have it compiling >> now. (Tests up next). >> >> Just FYI, I needed a new class for the product result: >> >> @Properties(inherit = Array(classOf[Context]), >> value = Array(new Platform( >> include =Array("matrix.hpp"), >> library ="jniViennaCL") >> )) >> @Namespace("viennacl") >> @Name(Array("vector_expression<const viennacl::matrix_base<double>, " + >> "const viennacl::vector_base<double>, " + >> "viennacl::op_prod>")) >> class MatVecProdExpressionextends Pointer { >> >> } >> >> Wanted to make sure that I wasn't grinding my wheels. >> >> Thanks alot for your time. >> >> One more question, there is no `trans(compressed_matrix cm)` function >> correct? This should just be done by taking the teanspose first of the >> matrix before converting it to CSR, etc? Curious, as we may be able to >> shave a small amount of time if so. >> >> Thanks! >> >> Andy >> >> >> ------------------------------------------------------------------------ >> *From:* Karl Rupp <ru...@iu...> >> *Sent:* Wednesday, August 3, 2016 5:28:58 PM >> *To:* Andrew Palumbo; vie...@li... >> *Subject:* Re: [ViennaCL-devel] compressed_matrix %*% matrix_Base >> Hi Andrew, >> >> > I'm having some trouble with sparse `compressed_matrix` `matrix`(base) >>> matrix multiplication. This is supported, correct? >> >> Yes. Could you please let us know what you have tried already? >> It shouldn't be any more code to write than >> >> viennacl::compressed_matrix<T> A(...); >> viennacl::matrix<T> B(...); >> viennacl::matrix<T> C = viennacl::linalg::prod(A, B); >> >> Make sure to >> #include "viennacl/matrix.hpp" >> #include "viennacl/compressed_matrix.hpp" >> #include "viennacl/linalg/prod.hpp" >> at the beginning; otherwise you get incomprehensible C++ compiler output. >> >> Best regards, >> Karli >> >> >> >> >>> >>> >>> I've been trying to use the: >>> >>> >>> template< typename SparseMatrixType, typename SCALARTYPE> >>> typename viennacl::enable_if< >>> viennacl::is_any_sparse_matrix<SparseMatrixType>::value >>> <http://viennacl.sourceforge.net/doc/structviennacl_1_1enable__if.html>, >>> viennacl::matrix_expression >>> <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__expression.html><const >>> SparseMatrixType, >>> const matrix_base <SCALARTYPE> >>> <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__base.html>, >>> op_prod >>> <http://viennacl.sourceforge.net/doc/structviennacl_1_1op__prod.html> > >>> >::type >>> <http://viennacl.sourceforge.net/doc/namespaceviennacl_1_1linalg.html#a3bba0146e669e012bb7c7380ce780a25> >>> prod >>> <http://viennacl.sourceforge.net/doc/namespaceviennacl_1_1linalg.html#aa18d10f8a90e38bd9ff43c650fc670ef>(const >>> SparseMatrixType & sp_mat, >>> const viennacl::matrix_base<SCALARTYPE> >>> <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__base.html> >>> & d_mat) >>> { >>> return viennacl::matrix_expression >>> <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__expression.html><const >>> SparseMatrixType, >>> const viennacl::matrix_base<SCALARTYPE> >>> <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__base.html>, >>> op_prod >>> <http://viennacl.sourceforge.net/doc/structviennacl_1_1op__prod.html> >>> >(sp_mat, d_mat); >>> >>> >>> method from prod.hpp. >>> >>> >>> I just wanted to make sure that this was the correct method, and that it >>> accepted `compressed_matrix`s as `sp_mat`. Is that correct? I'm >>> mapping this to java via javacpp so the templates can prove difficult, >>> and are likely where I'm getting errors. >>> >>> >>> Just wanted to confirm that this was supported as I am using it (and >>> that there is not a more straightforward way with fewer template arguments. >>> >>> >>> Thanks, >>> >>> >>> Andy >>> >>> >>> >>> ------------------------------------------------------------------------------ >>> >>> >>> >>> _______________________________________________ >>> ViennaCL-devel mailing list >>> Vie...@li... >>>https://lists.sourceforge.net/lists/listinfo/viennacl-devel >>> >> > |
From: Andrew P. <ap...@ou...> - 2016-08-05 19:04:59
|
Hi Karl, I've been trying to implement tests for: matrix_base<double> C = compressed_matrix<double> A %*% matrix_base<double,row_major> B. I cant find in the code or the documentation any constructor for matrix_base<T>( matrix_expression<const viennacl::compressed_matrix<T>, const viennacl::matrix_base<T>, viennacl::op_prod>) ie. a mixed expression of compressed_matrix and matrix_base and get a compilation error when I try to instantiate a: matrix_base<double>(matrix_expression<const viennacl::compressed_matrix<double>, const viennacl::matrix_base<double>, viennacl::op_prod>) Is there a transformation that I need to do from this matrix_expression<compressed_matrix<double>, matrix_base<double>, op_prod> to something else so that I may be able to initialize a matrix_base (or possibly even a compressed_matrix) from it? The compilation error that i get is below. Thanks, Andy {...} /usr/include/viennacl/matrix.hpp: In instantiation of ‘static void viennacl::linalg::detail::op_executor<viennacl::matrix_base<T>, viennacl::op_assign, viennacl::matrix_expression<const LHS, const RHS, viennacl::op_prod> >::apply(viennacl::matrix_base<T>&, const viennacl::matrix_expression<const SparseMatrixType, const viennacl::matrix_base<T>, viennacl::op_prod>&) [with SparseMatrixType = viennacl::compressed_matrix<double>; T = double; LHS = viennacl::compressed_matrix<double>; RHS = viennacl::matrix_base<double>]’: /usr/include/viennacl/matrix.hpp:324:107: required from ‘viennacl::matrix_base<NumericT, SizeT, DistanceT>& viennacl::matrix_base<SCALARTYPE, SizeType, DistanceType>::operator=(const viennacl::matrix_expression<const LHS, const RHS, OP>&) [with LHS = viennacl::compressed_matrix<double>; RHS = viennacl::matrix_base<double>; OP = viennacl::op_prod; NumericT = double; SizeT = long unsigned int; DistanceT = long int]’ {...} ________________________________ From: Andrew Palumbo <ap...@ou...> Sent: Thursday, August 4, 2016 11:06:33 AM To: Karl Rupp; vie...@li... Subject: Re: [ViennaCL-devel] compressed_matrix %*% matrix_Base Thanks Karl- Appreciate it! ________________________________ From: Karl Rupp <ru...@iu...> Sent: Thursday, August 4, 2016 3:36:53 AM To: Andrew Palumbo; vie...@li... Subject: Re: [ViennaCL-devel] compressed_matrix %*% matrix_Base Hi Andrew, On 08/04/2016 01:33 AM, Andrew Palumbo wrote: > Oops sorry - wrong class in the last post. Too many things going on at > once. > > > @Properties(inherit = Array(classOf[Context]), > value = Array(new Platform( > include =Array("matrix.hpp"), > library ="jniViennaCL") > )) > @Namespace("viennacl") > @Name(Array("matrix_expression<const viennacl::compressed_matrix<double>, " + > "const viennacl::matrix_base<double>, " + > "viennacl::op_prod>")) yes, this is the right result expression template type. Regarding trans: Currently the functionality isn't fully exposed through the API, i.e. you cannot write A = trans(B) for sparse matrices A and B. However, the functionality is implemented in viennacl::linalg::detail::amg::amg_transpose(B, A) and will be properly exposed soon. Best regards, Karli > ------------------------------------------------------------------------ > *From:* Andrew Palumbo <ap...@ou...> > *Sent:* Wednesday, August 3, 2016 6:44:10 PM > *To:* Karl Rupp; vie...@li... > *Subject:* Re: [ViennaCL-devel] compressed_matrix %*% matrix_Base > > Hi Karl, as always thanks for the quick response. > > I Just needed a point in the right direction, and have it compiling > now. (Tests up next). > > Just FYI, I needed a new class for the product result: > > @Properties(inherit = Array(classOf[Context]), > value = Array(new Platform( > include =Array("matrix.hpp"), > library ="jniViennaCL") > )) > @Namespace("viennacl") > @Name(Array("vector_expression<const viennacl::matrix_base<double>, " + > "const viennacl::vector_base<double>, " + > "viennacl::op_prod>")) > class MatVecProdExpressionextends Pointer { > > } > > Wanted to make sure that I wasn't grinding my wheels. > > Thanks alot for your time. > > One more question, there is no `trans(compressed_matrix cm)` function > correct? This should just be done by taking the teanspose first of the > matrix before converting it to CSR, etc? Curious, as we may be able to > shave a small amount of time if so. > > Thanks! > > Andy > > > ------------------------------------------------------------------------ > *From:* Karl Rupp <ru...@iu...> > *Sent:* Wednesday, August 3, 2016 5:28:58 PM > *To:* Andrew Palumbo; vie...@li... > *Subject:* Re: [ViennaCL-devel] compressed_matrix %*% matrix_Base > Hi Andrew, > > > I'm having some trouble with sparse `compressed_matrix` `matrix`(base) >> matrix multiplication. This is supported, correct? > > Yes. Could you please let us know what you have tried already? > It shouldn't be any more code to write than > > viennacl::compressed_matrix<T> A(...); > viennacl::matrix<T> B(...); > viennacl::matrix<T> C = viennacl::linalg::prod(A, B); > > Make sure to > #include "viennacl/matrix.hpp" > #include "viennacl/compressed_matrix.hpp" > #include "viennacl/linalg/prod.hpp" > at the beginning; otherwise you get incomprehensible C++ compiler output. > > Best regards, > Karli > > > > >> >> >> I've been trying to use the: >> >> >> template< typename SparseMatrixType, typename SCALARTYPE> >> typename viennacl::enable_if< >> viennacl::is_any_sparse_matrix<SparseMatrixType>::value >> <http://viennacl.sourceforge.net/doc/structviennacl_1_1enable__if.html>, >> viennacl::matrix_expression >> <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__expression.html><const >> SparseMatrixType, >> const matrix_base <SCALARTYPE> >> <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__base.html>, >> op_prod >> <http://viennacl.sourceforge.net/doc/structviennacl_1_1op__prod.html> > >> >::type >> <http://viennacl.sourceforge.net/doc/namespaceviennacl_1_1linalg.html#a3bba0146e669e012bb7c7380ce780a25> >> prod >> <http://viennacl.sourceforge.net/doc/namespaceviennacl_1_1linalg.html#aa18d10f8a90e38bd9ff43c650fc670ef>(const >> SparseMatrixType & sp_mat, >> const viennacl::matrix_base<SCALARTYPE> >> <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__base.html> >> & d_mat) >> { >> return viennacl::matrix_expression >> <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__expression.html><const >> SparseMatrixType, >> const viennacl::matrix_base<SCALARTYPE> >> <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__base.html>, >> op_prod >> <http://viennacl.sourceforge.net/doc/structviennacl_1_1op__prod.html> >> >(sp_mat, d_mat); >> >> >> method from prod.hpp. >> >> >> I just wanted to make sure that this was the correct method, and that it >> accepted `compressed_matrix`s as `sp_mat`. Is that correct? I'm >> mapping this to java via javacpp so the templates can prove difficult, >> and are likely where I'm getting errors. >> >> >> Just wanted to confirm that this was supported as I am using it (and >> that there is not a more straightforward way with fewer template arguments. >> >> >> Thanks, >> >> >> Andy >> >> >> >> ------------------------------------------------------------------------------ >> >> >> >> _______________________________________________ >> ViennaCL-devel mailing list >> Vie...@li... >>https://lists.sourceforge.net/lists/listinfo/viennacl-devel >> > |
From: Andrew P. <ap...@ou...> - 2016-08-04 15:07:44
|
Thanks Karl- Appreciate it! ________________________________ From: Karl Rupp <ru...@iu...> Sent: Thursday, August 4, 2016 3:36:53 AM To: Andrew Palumbo; vie...@li... Subject: Re: [ViennaCL-devel] compressed_matrix %*% matrix_Base Hi Andrew, On 08/04/2016 01:33 AM, Andrew Palumbo wrote: > Oops sorry - wrong class in the last post. Too many things going on at > once. > > > @Properties(inherit = Array(classOf[Context]), > value = Array(new Platform( > include =Array("matrix.hpp"), > library ="jniViennaCL") > )) > @Namespace("viennacl") > @Name(Array("matrix_expression<const viennacl::compressed_matrix<double>, " + > "const viennacl::matrix_base<double>, " + > "viennacl::op_prod>")) yes, this is the right result expression template type. Regarding trans: Currently the functionality isn't fully exposed through the API, i.e. you cannot write A = trans(B) for sparse matrices A and B. However, the functionality is implemented in viennacl::linalg::detail::amg::amg_transpose(B, A) and will be properly exposed soon. Best regards, Karli > ------------------------------------------------------------------------ > *From:* Andrew Palumbo <ap...@ou...> > *Sent:* Wednesday, August 3, 2016 6:44:10 PM > *To:* Karl Rupp; vie...@li... > *Subject:* Re: [ViennaCL-devel] compressed_matrix %*% matrix_Base > > Hi Karl, as always thanks for the quick response. > > I Just needed a point in the right direction, and have it compiling > now. (Tests up next). > > Just FYI, I needed a new class for the product result: > > @Properties(inherit = Array(classOf[Context]), > value = Array(new Platform( > include =Array("matrix.hpp"), > library ="jniViennaCL") > )) > @Namespace("viennacl") > @Name(Array("vector_expression<const viennacl::matrix_base<double>, " + > "const viennacl::vector_base<double>, " + > "viennacl::op_prod>")) > class MatVecProdExpressionextends Pointer { > > } > > Wanted to make sure that I wasn't grinding my wheels. > > Thanks alot for your time. > > One more question, there is no `trans(compressed_matrix cm)` function > correct? This should just be done by taking the teanspose first of the > matrix before converting it to CSR, etc? Curious, as we may be able to > shave a small amount of time if so. > > Thanks! > > Andy > > > ------------------------------------------------------------------------ > *From:* Karl Rupp <ru...@iu...> > *Sent:* Wednesday, August 3, 2016 5:28:58 PM > *To:* Andrew Palumbo; vie...@li... > *Subject:* Re: [ViennaCL-devel] compressed_matrix %*% matrix_Base > Hi Andrew, > > > I'm having some trouble with sparse `compressed_matrix` `matrix`(base) >> matrix multiplication. This is supported, correct? > > Yes. Could you please let us know what you have tried already? > It shouldn't be any more code to write than > > viennacl::compressed_matrix<T> A(...); > viennacl::matrix<T> B(...); > viennacl::matrix<T> C = viennacl::linalg::prod(A, B); > > Make sure to > #include "viennacl/matrix.hpp" > #include "viennacl/compressed_matrix.hpp" > #include "viennacl/linalg/prod.hpp" > at the beginning; otherwise you get incomprehensible C++ compiler output. > > Best regards, > Karli > > > > >> >> >> I've been trying to use the: >> >> >> template< typename SparseMatrixType, typename SCALARTYPE> >> typename viennacl::enable_if< >> viennacl::is_any_sparse_matrix<SparseMatrixType>::value >> <http://viennacl.sourceforge.net/doc/structviennacl_1_1enable__if.html>, >> viennacl::matrix_expression >> <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__expression.html><const >> SparseMatrixType, >> const matrix_base <SCALARTYPE> >> <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__base.html>, >> op_prod >> <http://viennacl.sourceforge.net/doc/structviennacl_1_1op__prod.html> > >> >::type >> <http://viennacl.sourceforge.net/doc/namespaceviennacl_1_1linalg.html#a3bba0146e669e012bb7c7380ce780a25> >> prod >> <http://viennacl.sourceforge.net/doc/namespaceviennacl_1_1linalg.html#aa18d10f8a90e38bd9ff43c650fc670ef>(const >> SparseMatrixType & sp_mat, >> const viennacl::matrix_base<SCALARTYPE> >> <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__base.html> >> & d_mat) >> { >> return viennacl::matrix_expression >> <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__expression.html><const >> SparseMatrixType, >> const viennacl::matrix_base<SCALARTYPE> >> <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__base.html>, >> op_prod >> <http://viennacl.sourceforge.net/doc/structviennacl_1_1op__prod.html> >> >(sp_mat, d_mat); >> >> >> method from prod.hpp. >> >> >> I just wanted to make sure that this was the correct method, and that it >> accepted `compressed_matrix`s as `sp_mat`. Is that correct? I'm >> mapping this to java via javacpp so the templates can prove difficult, >> and are likely where I'm getting errors. >> >> >> Just wanted to confirm that this was supported as I am using it (and >> that there is not a more straightforward way with fewer template arguments. >> >> >> Thanks, >> >> >> Andy >> >> >> >> ------------------------------------------------------------------------------ >> >> >> >> _______________________________________________ >> ViennaCL-devel mailing list >> Vie...@li... >>https://lists.sourceforge.net/lists/listinfo/viennacl-devel >> > |
From: Karl R. <ru...@iu...> - 2016-08-04 07:37:05
|
Hi Andrew, On 08/04/2016 01:33 AM, Andrew Palumbo wrote: > Oops sorry - wrong class in the last post. Too many things going on at > once. > > > @Properties(inherit = Array(classOf[Context]), > value = Array(new Platform( > include =Array("matrix.hpp"), > library ="jniViennaCL") > )) > @Namespace("viennacl") > @Name(Array("matrix_expression<const viennacl::compressed_matrix<double>, " + > "const viennacl::matrix_base<double>, " + > "viennacl::op_prod>")) yes, this is the right result expression template type. Regarding trans: Currently the functionality isn't fully exposed through the API, i.e. you cannot write A = trans(B) for sparse matrices A and B. However, the functionality is implemented in viennacl::linalg::detail::amg::amg_transpose(B, A) and will be properly exposed soon. Best regards, Karli > ------------------------------------------------------------------------ > *From:* Andrew Palumbo <ap...@ou...> > *Sent:* Wednesday, August 3, 2016 6:44:10 PM > *To:* Karl Rupp; vie...@li... > *Subject:* Re: [ViennaCL-devel] compressed_matrix %*% matrix_Base > > Hi Karl, as always thanks for the quick response. > > I Just needed a point in the right direction, and have it compiling > now. (Tests up next). > > Just FYI, I needed a new class for the product result: > > @Properties(inherit = Array(classOf[Context]), > value = Array(new Platform( > include =Array("matrix.hpp"), > library ="jniViennaCL") > )) > @Namespace("viennacl") > @Name(Array("vector_expression<const viennacl::matrix_base<double>, " + > "const viennacl::vector_base<double>, " + > "viennacl::op_prod>")) > class MatVecProdExpressionextends Pointer { > > } > > Wanted to make sure that I wasn't grinding my wheels. > > Thanks alot for your time. > > One more question, there is no `trans(compressed_matrix cm)` function > correct? This should just be done by taking the teanspose first of the > matrix before converting it to CSR, etc? Curious, as we may be able to > shave a small amount of time if so. > > Thanks! > > Andy > > > ------------------------------------------------------------------------ > *From:* Karl Rupp <ru...@iu...> > *Sent:* Wednesday, August 3, 2016 5:28:58 PM > *To:* Andrew Palumbo; vie...@li... > *Subject:* Re: [ViennaCL-devel] compressed_matrix %*% matrix_Base > Hi Andrew, > > > I'm having some trouble with sparse `compressed_matrix` `matrix`(base) >> matrix multiplication. This is supported, correct? > > Yes. Could you please let us know what you have tried already? > It shouldn't be any more code to write than > > viennacl::compressed_matrix<T> A(...); > viennacl::matrix<T> B(...); > viennacl::matrix<T> C = viennacl::linalg::prod(A, B); > > Make sure to > #include "viennacl/matrix.hpp" > #include "viennacl/compressed_matrix.hpp" > #include "viennacl/linalg/prod.hpp" > at the beginning; otherwise you get incomprehensible C++ compiler output. > > Best regards, > Karli > > > > >> >> >> I've been trying to use the: >> >> >> template< typename SparseMatrixType, typename SCALARTYPE> >> typename viennacl::enable_if< >> viennacl::is_any_sparse_matrix<SparseMatrixType>::value >> <http://viennacl.sourceforge.net/doc/structviennacl_1_1enable__if.html>, >> viennacl::matrix_expression >> <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__expression.html><const >> SparseMatrixType, >> const matrix_base <SCALARTYPE> >> <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__base.html>, >> op_prod >> <http://viennacl.sourceforge.net/doc/structviennacl_1_1op__prod.html> > >> >::type >> <http://viennacl.sourceforge.net/doc/namespaceviennacl_1_1linalg.html#a3bba0146e669e012bb7c7380ce780a25> >> prod >> <http://viennacl.sourceforge.net/doc/namespaceviennacl_1_1linalg.html#aa18d10f8a90e38bd9ff43c650fc670ef>(const >> SparseMatrixType & sp_mat, >> const viennacl::matrix_base<SCALARTYPE> >> <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__base.html> >> & d_mat) >> { >> return viennacl::matrix_expression >> <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__expression.html><const >> SparseMatrixType, >> const viennacl::matrix_base<SCALARTYPE> >> <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__base.html>, >> op_prod >> <http://viennacl.sourceforge.net/doc/structviennacl_1_1op__prod.html> >> >(sp_mat, d_mat); >> >> >> method from prod.hpp. >> >> >> I just wanted to make sure that this was the correct method, and that it >> accepted `compressed_matrix`s as `sp_mat`. Is that correct? I'm >> mapping this to java via javacpp so the templates can prove difficult, >> and are likely where I'm getting errors. >> >> >> Just wanted to confirm that this was supported as I am using it (and >> that there is not a more straightforward way with fewer template arguments. >> >> >> Thanks, >> >> >> Andy >> >> >> >> ------------------------------------------------------------------------------ >> >> >> >> _______________________________________________ >> ViennaCL-devel mailing list >> Vie...@li... >>https://lists.sourceforge.net/lists/listinfo/viennacl-devel >> > |
From: Andrew P. <ap...@ou...> - 2016-08-03 23:33:44
|
Oops sorry - wrong class in the last post. Too many things going on at once. @Properties(inherit = Array(classOf[Context]), value = Array(new Platform( include = Array("matrix.hpp"), library = "jniViennaCL") )) @Namespace("viennacl") @Name(Array("matrix_expression<const viennacl::compressed_matrix<double>, " + "const viennacl::matrix_base<double>, " + "viennacl::op_prod>")) class SrMatDnMatProdExpression extends Pointer { thanks again, Andy ________________________________ From: Andrew Palumbo <ap...@ou...> Sent: Wednesday, August 3, 2016 6:44:10 PM To: Karl Rupp; vie...@li... Subject: Re: [ViennaCL-devel] compressed_matrix %*% matrix_Base Hi Karl, as always thanks for the quick response. I Just needed a point in the right direction, and have it compiling now. (Tests up next). Just FYI, I needed a new class for the product result: @Properties(inherit = Array(classOf[Context]), value = Array(new Platform( include = Array("matrix.hpp"), library = "jniViennaCL") )) @Namespace("viennacl") @Name(Array("vector_expression<const viennacl::matrix_base<double>, " + "const viennacl::vector_base<double>, " + "viennacl::op_prod>")) class MatVecProdExpression extends Pointer { } Wanted to make sure that I wasn't grinding my wheels. Thanks alot for your time. One more question, there is no `trans(compressed_matrix cm)` function correct? This should just be done by taking the teanspose first of the matrix before converting it to CSR, etc? Curious, as we may be able to shave a small amount of time if so. Thanks! Andy ________________________________ From: Karl Rupp <ru...@iu...> Sent: Wednesday, August 3, 2016 5:28:58 PM To: Andrew Palumbo; vie...@li... Subject: Re: [ViennaCL-devel] compressed_matrix %*% matrix_Base Hi Andrew, > I'm having some trouble with sparse `compressed_matrix` `matrix`(base) > matrix multiplication. This is supported, correct? Yes. Could you please let us know what you have tried already? It shouldn't be any more code to write than viennacl::compressed_matrix<T> A(...); viennacl::matrix<T> B(...); viennacl::matrix<T> C = viennacl::linalg::prod(A, B); Make sure to #include "viennacl/matrix.hpp" #include "viennacl/compressed_matrix.hpp" #include "viennacl/linalg/prod.hpp" at the beginning; otherwise you get incomprehensible C++ compiler output. Best regards, Karli > > > I've been trying to use the: > > > template< typename SparseMatrixType, typename SCALARTYPE> > typename viennacl::enable_if< > viennacl::is_any_sparse_matrix<SparseMatrixType>::value > <http://viennacl.sourceforge.net/doc/structviennacl_1_1enable__if.html>, > viennacl::matrix_expression > <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__expression.html><const > SparseMatrixType, > const matrix_base <SCALARTYPE> > <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__base.html>, > op_prod > <http://viennacl.sourceforge.net/doc/structviennacl_1_1op__prod.html> > > >::type > <http://viennacl.sourceforge.net/doc/namespaceviennacl_1_1linalg.html#a3bba0146e669e012bb7c7380ce780a25> > prod > <http://viennacl.sourceforge.net/doc/namespaceviennacl_1_1linalg.html#aa18d10f8a90e38bd9ff43c650fc670ef>(const > SparseMatrixType & sp_mat, > const viennacl::matrix_base<SCALARTYPE> > <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__base.html> > & d_mat) > { > return viennacl::matrix_expression > <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__expression.html><const > SparseMatrixType, > const viennacl::matrix_base<SCALARTYPE> > <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__base.html>, > op_prod > <http://viennacl.sourceforge.net/doc/structviennacl_1_1op__prod.html> > >(sp_mat, d_mat); > > > method from prod.hpp. > > > I just wanted to make sure that this was the correct method, and that it > accepted `compressed_matrix`s as `sp_mat`. Is that correct? I'm > mapping this to java via javacpp so the templates can prove difficult, > and are likely where I'm getting errors. > > > Just wanted to confirm that this was supported as I am using it (and > that there is not a more straightforward way with fewer template arguments. > > > Thanks, > > > Andy > > > > ------------------------------------------------------------------------------ > > > > _______________________________________________ > ViennaCL-devel mailing list > Vie...@li... > https://lists.sourceforge.net/lists/listinfo/viennacl-devel > |
From: Andrew P. <ap...@ou...> - 2016-08-03 22:44:24
|
Hi Karl, as always thanks for the quick response. I Just needed a point in the right direction, and have it compiling now. (Tests up next). Just FYI, I needed a new class for the product result: @Properties(inherit = Array(classOf[Context]), value = Array(new Platform( include = Array("matrix.hpp"), library = "jniViennaCL") )) @Namespace("viennacl") @Name(Array("vector_expression<const viennacl::matrix_base<double>, " + "const viennacl::vector_base<double>, " + "viennacl::op_prod>")) class MatVecProdExpression extends Pointer { } Wanted to make sure that I wasn't grinding my wheels. Thanks alot for your time. One more question, there is no `trans(compressed_matrix cm)` function correct? This should just be done by taking the teanspose first of the matrix before converting it to CSR, etc? Curious, as we may be able to shave a small amount of time if so. Thanks! Andy ________________________________ From: Karl Rupp <ru...@iu...> Sent: Wednesday, August 3, 2016 5:28:58 PM To: Andrew Palumbo; vie...@li... Subject: Re: [ViennaCL-devel] compressed_matrix %*% matrix_Base Hi Andrew, > I'm having some trouble with sparse `compressed_matrix` `matrix`(base) > matrix multiplication. This is supported, correct? Yes. Could you please let us know what you have tried already? It shouldn't be any more code to write than viennacl::compressed_matrix<T> A(...); viennacl::matrix<T> B(...); viennacl::matrix<T> C = viennacl::linalg::prod(A, B); Make sure to #include "viennacl/matrix.hpp" #include "viennacl/compressed_matrix.hpp" #include "viennacl/linalg/prod.hpp" at the beginning; otherwise you get incomprehensible C++ compiler output. Best regards, Karli > > > I've been trying to use the: > > > template< typename SparseMatrixType, typename SCALARTYPE> > typename viennacl::enable_if< > viennacl::is_any_sparse_matrix<SparseMatrixType>::value > <http://viennacl.sourceforge.net/doc/structviennacl_1_1enable__if.html>, > viennacl::matrix_expression > <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__expression.html><const > SparseMatrixType, > const matrix_base <SCALARTYPE> > <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__base.html>, > op_prod > <http://viennacl.sourceforge.net/doc/structviennacl_1_1op__prod.html> > > >::type > <http://viennacl.sourceforge.net/doc/namespaceviennacl_1_1linalg.html#a3bba0146e669e012bb7c7380ce780a25> > prod > <http://viennacl.sourceforge.net/doc/namespaceviennacl_1_1linalg.html#aa18d10f8a90e38bd9ff43c650fc670ef>(const > SparseMatrixType & sp_mat, > const viennacl::matrix_base<SCALARTYPE> > <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__base.html> > & d_mat) > { > return viennacl::matrix_expression > <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__expression.html><const > SparseMatrixType, > const viennacl::matrix_base<SCALARTYPE> > <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__base.html>, > op_prod > <http://viennacl.sourceforge.net/doc/structviennacl_1_1op__prod.html> > >(sp_mat, d_mat); > > > method from prod.hpp. > > > I just wanted to make sure that this was the correct method, and that it > accepted `compressed_matrix`s as `sp_mat`. Is that correct? I'm > mapping this to java via javacpp so the templates can prove difficult, > and are likely where I'm getting errors. > > > Just wanted to confirm that this was supported as I am using it (and > that there is not a more straightforward way with fewer template arguments. > > > Thanks, > > > Andy > > > > ------------------------------------------------------------------------------ > > > > _______________________________________________ > ViennaCL-devel mailing list > Vie...@li... > https://lists.sourceforge.net/lists/listinfo/viennacl-devel > |
From: Karl R. <ru...@iu...> - 2016-08-03 21:29:08
|
Hi Andrew, > I'm having some trouble with sparse `compressed_matrix` `matrix`(base) > matrix multiplication. This is supported, correct? Yes. Could you please let us know what you have tried already? It shouldn't be any more code to write than viennacl::compressed_matrix<T> A(...); viennacl::matrix<T> B(...); viennacl::matrix<T> C = viennacl::linalg::prod(A, B); Make sure to #include "viennacl/matrix.hpp" #include "viennacl/compressed_matrix.hpp" #include "viennacl/linalg/prod.hpp" at the beginning; otherwise you get incomprehensible C++ compiler output. Best regards, Karli > > > I've been trying to use the: > > > template< typename SparseMatrixType, typename SCALARTYPE> > typename viennacl::enable_if< > viennacl::is_any_sparse_matrix<SparseMatrixType>::value > <http://viennacl.sourceforge.net/doc/structviennacl_1_1enable__if.html>, > viennacl::matrix_expression > <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__expression.html><const > SparseMatrixType, > const matrix_base <SCALARTYPE> > <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__base.html>, > op_prod > <http://viennacl.sourceforge.net/doc/structviennacl_1_1op__prod.html> > > >::type > <http://viennacl.sourceforge.net/doc/namespaceviennacl_1_1linalg.html#a3bba0146e669e012bb7c7380ce780a25> > prod > <http://viennacl.sourceforge.net/doc/namespaceviennacl_1_1linalg.html#aa18d10f8a90e38bd9ff43c650fc670ef>(const > SparseMatrixType & sp_mat, > const viennacl::matrix_base<SCALARTYPE> > <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__base.html> > & d_mat) > { > return viennacl::matrix_expression > <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__expression.html><const > SparseMatrixType, > const viennacl::matrix_base<SCALARTYPE> > <http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__base.html>, > op_prod > <http://viennacl.sourceforge.net/doc/structviennacl_1_1op__prod.html> > >(sp_mat, d_mat); > > > method from prod.hpp. > > > I just wanted to make sure that this was the correct method, and that it > accepted `compressed_matrix`s as `sp_mat`. Is that correct? I'm > mapping this to java via javacpp so the templates can prove difficult, > and are likely where I'm getting errors. > > > Just wanted to confirm that this was supported as I am using it (and > that there is not a more straightforward way with fewer template arguments. > > > Thanks, > > > Andy > > > > ------------------------------------------------------------------------------ > > > > _______________________________________________ > ViennaCL-devel mailing list > Vie...@li... > https://lists.sourceforge.net/lists/listinfo/viennacl-devel > |
From: Karl R. <ru...@iu...> - 2016-08-03 21:25:58
|
Hi Charles, > I know the intent is to remove boost from viennacl. As such, I was > looking at some files I could contribute to that removal. That said, > before I start blindly making changes, is there a plan for how to > replace elements such as `boost::numeric::ublas::prod`? Well, the ViennaCL core is mostly free from uBLAS already. By 'mostly' I mean all the parts that are fully supported for all three backends. The experimental eigenvalue routines that are only available for the OpenCL backend are the major exception. I don't recommend anybody to start there, because this requires the most knowledge of ViennaCL's internals to be migrated. > Is the intent to just use std objects such as > std::vector<std::vector<SCALARTYPE> > and doing a manual matrix > multiplication? > > Or do you intend to use another library? Given that the stable core is already uBLAS free (or at least 95%), the major work is to ditch uBLAS from the examples and tests. Many of the examples no longer need uBLAS, because the functionality is available in ViennaCL. This is the major effort in terms of lines of code touched, but it shouldn't be too hard. If something cannot be expressed directly with ViennaCL, a STL-type should be used (std::vector, std::vector<std::vector<T> >, etc.) Hope this helps a bit :-) Thanks and best regards, Karli |
From: Andrew P. <ap...@ou...> - 2016-08-03 21:10:44
|
Hello, I'm having some trouble with sparse `compressed_matrix` `matrix`(base) matrix multiplication. This is supported, correct? I've been trying to use the: template< typename SparseMatrixType, typename SCALARTYPE> typename viennacl::enable_if< viennacl::is_any_sparse_matrix<SparseMatrixType>::value<http://viennacl.sourceforge.net/doc/structviennacl_1_1enable__if.html>, viennacl::matrix_expression<http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__expression.html><const SparseMatrixType, const matrix_base <SCALARTYPE><http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__base.html>, op_prod<http://viennacl.sourceforge.net/doc/structviennacl_1_1op__prod.html> > >::type <http://viennacl.sourceforge.net/doc/namespaceviennacl_1_1linalg.html#a3bba0146e669e012bb7c7380ce780a25> prod<http://viennacl.sourceforge.net/doc/namespaceviennacl_1_1linalg.html#aa18d10f8a90e38bd9ff43c650fc670ef>(const SparseMatrixType & sp_mat, const viennacl::matrix_base<SCALARTYPE><http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__base.html> & d_mat) { return viennacl::matrix_expression<http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__expression.html><const SparseMatrixType, const viennacl::matrix_base<SCALARTYPE><http://viennacl.sourceforge.net/doc/classviennacl_1_1matrix__base.html>, op_prod<http://viennacl.sourceforge.net/doc/structviennacl_1_1op__prod.html> >(sp_mat, d_mat); method from prod.hpp. I just wanted to make sure that this was the correct method, and that it accepted `compressed_matrix`s as `sp_mat`. Is that correct? I'm mapping this to java via javacpp so the templates can prove difficult, and are likely where I'm getting errors. Just wanted to confirm that this was supported as I am using it (and that there is not a more straightforward way with fewer template arguments. Thanks, Andy |
From: Charles D. <cde...@gm...> - 2016-08-03 18:24:11
|
I know the intent is to remove boost from viennacl. As such, I was looking at some files I could contribute to that removal. That said, before I start blindly making changes, is there a plan for how to replace elements such as `boost::numeric::ublas::prod`? Is the intent to just use std objects such as std::vector<std::vector<SCALARTYPE> > and doing a manual matrix multiplication? Or do you intend to use another library? Or something else that I can't think of? Regards, Charles |
From: Andrew P. <ap...@ou...> - 2016-07-26 13:51:30
|
Great, thanks! I saw on the vienneacl-dev github repo that the target date for the 1.8.0 release was sometime in early august. Is that accurate? Andy -------- Original message -------- From: Karl Rupp <ru...@iu...> Date: 07/26/2016 4:16 AM (GMT-05:00) To: Andrew Palumbo <ap...@ou...>, "Vie...@li..." <vie...@li...> Subject: Re: [ViennaCL-devel] boost/ublass requirements Hi Andy, > I was just looking at looking at svd.hpp, qr.hpp and fspai.hpp, and I > notice that there are boost requirements and includes in these files. > > > Is there any way of running svd, qr or cholesky_solve without > instlalling boost? currently this is tied to uBLAS, but we want to get rid of all Boost-dependencies as soon as possible (i.e. with ViennaCL 1.8.0): https://github.com/viennacl/viennacl-dev/wiki/ViennaCL-Roadmap Best regards, Karli |
From: Karl R. <ru...@iu...> - 2016-07-26 08:16:13
|
Hi Andy, > I was just looking at looking at svd.hpp, qr.hpp and fspai.hpp, and I > notice that there are boost requirements and includes in these files. > > > Is there any way of running svd, qr or cholesky_solve without > instlalling boost? currently this is tied to uBLAS, but we want to get rid of all Boost-dependencies as soon as possible (i.e. with ViennaCL 1.8.0): https://github.com/viennacl/viennacl-dev/wiki/ViennaCL-Roadmap Best regards, Karli |
From: Andrew P. <ap...@ou...> - 2016-07-25 21:25:12
|
Hi Karl, I was just looking at looking at svd.hpp, qr.hpp and fspai.hpp, and I notice that there are boost requirements and includes in these files. Is there any way of running svd, qr or cholesky_solve without instlalling boost? Thanks, Andy |