OK, so after re-doing the build system, let's try again. Unfortunately,
the Windows terminal window didn't save very much history, so I only
have this much of the error output. I think it's enough to be
diagnostic; if not, I'll run it again, redirecting the output to a
file..
Once I've got this Windows build fixed, and successful builds on Mac OS,
I'll release PyViennaCL version 1.0.1.
Also note that this is now using MSVC 9, since that's the version that
Python 2.7 is built with, and I have to build with that, apparently.
external/viennacl-dev/viennacl/linalg/bicgstab.hpp(125) : error C2593:
'operator -=' is ambiguous
external/viennacl-dev/viennacl/vector.hpp(765): could be
'viennacl::vector_base<SCALARTYPE> &viennacl::vector_base<SCALARTYPE>::operator
-=<MatrixType,v
iennacl::vector_base<SCALARTYPE>,viennacl::op_prod>(const
viennacl::vector_expression<LHS,RHS,OP> &)'
with
[
SCALARTYPE=double,
MatrixType=viennacl::matrix_base<double>,
LHS=const viennacl::matrix_base<double>,
RHS=const viennacl::vector_base<double>,
OP=viennacl::op_prod
]
external/viennacl-dev/viennacl/linalg/matrix_operations.hpp(817): or
'viennacl::vector<SCALARTYPE> viennacl::operator -=<double,viennacl::row_majo
r>(viennacl::vector_base<SCALARTYPE> &,const
viennacl::vector_expression<LHS,RHS,OP> &)'
with
[
SCALARTYPE=double,
LHS=const viennacl::matrix_base<double>,
RHS=const viennacl::vector_base<double>,
OP=viennacl::op_prod
]
while trying to match the argument list '(viennacl::vector<SCALARTYPE>,
viennacl::vector_expression<LHS,RHS,OP>)'
with
[
SCALARTYPE=double
]
and
[
LHS=const viennacl::matrix_base<double>,
RHS=const viennacl::vector_base<double>,
OP=viennacl::op_prod
]
f:\src\viennacl\pyviennacl-dev\src\_viennacl\solve_op_func.hpp(9) : see
reference to function template instantiation 'VectorType viennacl::linalg::solve
<viennacl::matrix_base<SCALARTYPE>,viennacl::vector<SCALARTYPE>>(const
MatrixType &,const VectorType &,const viennacl::linalg::bicgstab_tag &)' being
compiled
with
[
VectorType=viennacl::vector<double>,
SCALARTYPE=double,
MatrixType=viennacl::matrix_base<double>
]
f:\src\viennacl\pyviennacl-dev\src\_viennacl\solve_op_func.hpp(7) :
while compiling class template member function 'viennacl::vector<SCALARTYPE>
pyvcl_w
orker<ReturnT,Operand1T,Operand2T,Operand3T,Operand4T,op,PyObjs>::do_op(pyvcl_op<ReturnT,Operand1T,Operand2T,Operand3T,Operand4T,op_solve,0>
&)'
with
[
SCALARTYPE=double,
ReturnT=viennacl::vector<double>,
Operand1T=viennacl::matrix_base<double> &,
Operand2T=viennacl::vector<double> &,
Operand3T=viennacl::linalg::bicgstab_tag &,
Operand4T=NoneT ,
op=op_solve,
PyObjs=0
]
f:\src\viennacl\pyviennacl-dev\src\_viennacl\viennacl.h(155) : see
reference to class template instantiation
'pyvcl_worker<ReturnT,Operand1T,Operand2T,O
perand3T,Operand4T,op,PyObjs>' being compiled
with
[
ReturnT=viennacl::vector<double>,
Operand1T=viennacl::matrix_base<double> &,
Operand2T=viennacl::vector<double> &,
Operand3T=viennacl::linalg::bicgstab_tag &,
Operand4T=NoneT ,
op=op_solve,
PyObjs=0
]
f:\src\viennacl\pyviennacl-dev\src\_viennacl\viennacl.h(151) : while
compiling class template member function 'viennacl::vector<SCALARTYPE>
pyvcl_op<Ret
urnT,Operand1T,Operand2T,Operand3T,Operand4T,op,PyObjs>::do_op(void)'
with
[
SCALARTYPE=double,
ReturnT=viennacl::vector<double>,
Operand1T=viennacl::matrix_base<double> &,
Operand2T=viennacl::vector<double> &,
Operand3T=viennacl::linalg::bicgstab_tag &,
Operand4T=NoneT,
op=op_solve,
PyObjs=0
]
f:\src\viennacl\pyviennacl-dev\src\_viennacl\viennacl.h(199) : see
reference to class template instantiation
'pyvcl_op<ReturnT,Operand1T,Operand2T,Opera
nd3T,Operand4T,op,PyObjs>' being compiled
with
[
ReturnT=viennacl::vector<double>,
Operand1T=viennacl::matrix_base<double> &,
Operand2T=viennacl::vector<double> &,
Operand3T=viennacl::linalg::bicgstab_tag &,
Operand4T=NoneT,
op=op_solve,
PyObjs=0
]
src\_viennacl\iterative_solvers.cpp(6) : see reference to function
template instantiation 'ReturnT
pyvcl_do_3ary_op<viennacl::vector<SCALARTYPE>,viennac
l::matrix_base<SCALARTYPE>&,viennacl::vector<SCALARTYPE>&,viennacl::linalg::bicgstab_tag&,op_solve,0>(Operand1T,Operand2T,Operand3T)'
being compiled
with
[
ReturnT=viennacl::vector<double>,
SCALARTYPE=double,
Operand1T=viennacl::matrix_base<double> &,
Operand2T=viennacl::vector<double> &,
Operand3T=viennacl::linalg::bicgstab_tag &
]
external/viennacl-dev/viennacl/linalg/bicgstab.hpp(125) : error C2593:
'operator -=' is ambiguous
external/viennacl-dev/viennacl/vector.hpp(765): could be
'viennacl::vector_base<SCALARTYPE> &viennacl::vector_base<SCALARTYPE>::operator
-=<MatrixType,v
iennacl::vector_base<SCALARTYPE>,viennacl::op_prod>(const
viennacl::vector_expression<LHS,RHS,OP> &)'
with
[
SCALARTYPE=double,
MatrixType=viennacl::matrix_base<double,viennacl::column_major>,
LHS=const viennacl::matrix_base<double,viennacl::column_major>,
RHS=const viennacl::vector_base<double>,
OP=viennacl::op_prod
]
external/viennacl-dev/viennacl/linalg/matrix_operations.hpp(817): or
'viennacl::vector<SCALARTYPE> viennacl::operator -=<double,viennacl::column_m
ajor>(viennacl::vector_base<SCALARTYPE> &,const
viennacl::vector_expression<LHS,RHS,OP> &)'
with
[
SCALARTYPE=double,
LHS=const viennacl::matrix_base<double,viennacl::column_major>,
RHS=const viennacl::vector_base<double>,
OP=viennacl::op_prod
]
while trying to match the argument list '(viennacl::vector<SCALARTYPE>,
viennacl::vector_expression<LHS,RHS,OP>)'
with
[
SCALARTYPE=double
]
and
[
LHS=const viennacl::matrix_base<double,viennacl::column_major>,
RHS=const viennacl::vector_base<double>,
OP=viennacl::op_prod
]
f:\src\viennacl\pyviennacl-dev\src\_viennacl\solve_op_func.hpp(9) : see
reference to function template instantiation 'VectorType viennacl::linalg::solve
<viennacl::matrix_base<SCALARTYPE,F>,viennacl::vector<SCALARTYPE>>(const
MatrixType &,const VectorType &,const viennacl::linalg::bicgstab_tag &)' being
compiled
with
[
VectorType=viennacl::vector<double>,
SCALARTYPE=double,
F=viennacl::column_major,
MatrixType=viennacl::matrix_base<double,viennacl::column_major>
]
f:\src\viennacl\pyviennacl-dev\src\_viennacl\solve_op_func.hpp(7) :
while compiling class template member function 'viennacl::vector<SCALARTYPE>
pyvcl_w
orker<ReturnT,Operand1T,Operand2T,Operand3T,Operand4T,op,PyObjs>::do_op(pyvcl_op<ReturnT,Operand1T,Operand2T,Operand3T,Operand4T,op_solve,0>
&)'
with
[
SCALARTYPE=double,
ReturnT=viennacl::vector<double>,
Operand1T=viennacl::matrix_base<double,viennacl::column_major> &,
Operand2T=viennacl::vector<double> &,
Operand3T=viennacl::linalg::bicgstab_tag &,
Operand4T=NoneT ,
op=op_solve,
PyObjs=0
]
f:\src\viennacl\pyviennacl-dev\src\_viennacl\viennacl.h(155) : see
reference to class template instantiation
'pyvcl_worker<ReturnT,Operand1T,Operand2T,O
perand3T,Operand4T,op,PyObjs>' being compiled
with
[
ReturnT=viennacl::vector<double>,
Operand1T=viennacl::matrix_base<double,viennacl::column_major> &,
Operand2T=viennacl::vector<double> &,
Operand3T=viennacl::linalg::bicgstab_tag &,
Operand4T=NoneT ,
op=op_solve,
PyObjs=0
]
f:\src\viennacl\pyviennacl-dev\src\_viennacl\viennacl.h(151) : while
compiling class template member function 'viennacl::vector<SCALARTYPE>
pyvcl_op<Ret
urnT,Operand1T,Operand2T,Operand3T,Operand4T,op,PyObjs>::do_op(void)'
with
[
SCALARTYPE=double,
ReturnT=viennacl::vector<double>,
Operand1T=viennacl::matrix_base<double,viennacl::column_major> &,
Operand2T=viennacl::vector<double> &,
Operand3T=viennacl::linalg::bicgstab_tag &,
Operand4T=NoneT,
op=op_solve,
PyObjs=0
]
f:\src\viennacl\pyviennacl-dev\src\_viennacl\viennacl.h(199) : see
reference to class template instantiation
'pyvcl_op<ReturnT,Operand1T,Operand2T,Opera
nd3T,Operand4T,op,PyObjs>' being compiled
with
[
ReturnT=viennacl::vector<double>,
Operand1T=viennacl::matrix_base<double,viennacl::column_major> &,
Operand2T=viennacl::vector<double> &,
Operand3T=viennacl::linalg::bicgstab_tag &,
Operand4T=NoneT,
op=op_solve,
PyObjs=0
]
src\_viennacl\iterative_solvers.cpp(6) : see reference to function
template instantiation 'ReturnT
pyvcl_do_3ary_op<viennacl::vector<SCALARTYPE>,viennac
l::matrix_base<SCALARTYPE,F>&,viennacl::vector<SCALARTYPE>&,viennacl::linalg::bicgstab_tag&,op_solve,0>(Operand1T,Operand2T,Operand3T)'
being compiled
with
[
ReturnT=viennacl::vector<double>,
SCALARTYPE=double,
F=viennacl::column_major,
Operand1T=viennacl::matrix_base<double,viennacl::column_major> &,
Operand2T=viennacl::vector<double> &,
Operand3T=viennacl::linalg::bicgstab_tag &
]
error: command '"D:\Microsoft Visual Studio 9.0\VC\BIN\cl.exe"' failed with
exit status 2
Karl Rupp <r...@iue.tuwien.ac.at> writes:
> Hi Toby,
>
> > I don't have much expertise with MSVC, but I'm trying to build
>> pyviennacl, and I've got a couple of weird bugs. I've looked at the
>> source, but really have no idea what it's complaining about. Why can't
>> it resolve the type ambiguity here?
>>
>> 4>F:/src/viennacl/pyviennacl-dev/external/viennacl-dev\viennacl/linalg/bicgstab.hpp(149):
>> error C2668: 'fabs' : ambiguous call to overloaded function
>> 4> E:\Microsoft Visual Studio 11.0\VC\INCLUDE\math.h(118): could be
>> 'double fabs(double)'
>> 4> E:\Microsoft Visual Studio 11.0\VC\INCLUDE\math.h(516): or
>> 'float fabs(float)'
>> 4> E:\Microsoft Visual Studio 11.0\VC\INCLUDE\math.h(564): or
>> 'long double fabs(long double)'
>> 4> while trying to match the argument list '(CPU_ScalarType)'
>
> Which types did you pass in? This looks like you pass an integer type
> (e.g. viennacl::vector<int>), while BiCGStab only makes sense for
> floating point numbers. std::fabs(int) then is ambiguous.
>
>
>> And here, I wish I knew what class it actually thinks its assigning..
>>
>> 4>F:/src/viennacl/pyviennacl-dev/external/viennacl-dev\viennacl/linalg/bicgstab.hpp(125):
>> error C2088: '-=' : illegal for class
>>
>> Does the following patch suffice? The code now builds with only the error
>> above, and I imagine the effect should be the same.
>
> The patch below introduces a temporary, which is not a great thing.
> Instead, we should find and fix the underlying reason why the initial
> code does not compile. Can you please provide more context (e.g. the
> full compiler output)?
>
> Best regards,
> Karli
>
>
> ------------------------------------------------------------------------------
> Managing the Performance of Cloud-Based Applications
> Take advantage of what the Cloud has to offer - Avoid Common Pitfalls.
> Read the Whitepaper.
> http://pubads.g.doubleclick.net/gampad/clk?id=121054471&iu=/4140/ostg.clktrk
------------------------------------------------------------------------------
Flow-based real-time traffic analytics software. Cisco certified tool.
Monitor traffic, SLAs, QoS, Medianet, WAAS etc. with NetFlow Analyzer
Customize your own dashboards, set traffic alerts and generate reports.
Network behavioral analysis & security monitoring. All-in-one tool.
http://pubads.g.doubleclick.net/gampad/clk?id=126839071&iu=/4140/ostg.clktrk
_______________________________________________
ViennaCL-devel mailing list
ViennaCL-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/viennacl-devel
