* installing *source* package ‘rtkore’ ...
** this is package ‘rtkore’ version ‘1.6.13’
** package ‘rtkore’ successfully unpacked and MD5 sums checked
** using staged installation
** libs
using C compiler: ‘Apple clang version 14.0.3 (clang-1403.0.22.14.1)’
using C++ compiler: ‘Apple clang version 14.0.3 (clang-1403.0.22.14.1)’
Warning in system2("xcrun", "--show-sdk-version", TRUE, TRUE) :
running command ''xcrun' --show-sdk-version 2>&1' had status 1
using SDK: ‘NA’
clang++ -arch x86_64 -std=gnu++20 -I"/Library/Frameworks/R.framework/Resources/include" -DNDEBUG -I'/Volumes/Builds/packages/big-sur-x86_64/Rlib/4.6/Rcpp/include' -I/opt/R/x86_64/include -I'../inst/projects/' -I'../inst/include/' -DIS_RTKPP_LIB -DSTKUSELAPACK -fPIC -falign-functions=64 -Wall -g -O2 -c fastRand.cpp -o fastRand.o
clang -arch x86_64 -I"/Library/Frameworks/R.framework/Resources/include" -DNDEBUG -I'/Volumes/Builds/packages/big-sur-x86_64/Rlib/4.6/Rcpp/include' -I/opt/R/x86_64/include -fPIC -falign-functions=64 -Wall -g -O2 -c init_rtkore.c -o init_rtkore.o
clang++ -arch x86_64 -std=gnu++20 -I"/Library/Frameworks/R.framework/Resources/include" -DNDEBUG -I'/Volumes/Builds/packages/big-sur-x86_64/Rlib/4.6/Rcpp/include' -I/opt/R/x86_64/include -I'../inst/projects/' -I'../inst/include/' -DIS_RTKPP_LIB -DSTKUSELAPACK -fPIC -falign-functions=64 -Wall -g -O2 -c rtkore.cpp -o rtkore.o
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:74:
In file included from ../inst/projects/Arrays/include/STK_CArray.h:38:
In file included from ../inst/projects/Arrays/include/STK_ICArray.h:43:
In file included from ../inst/projects/Arrays/include/STK_ArrayBase.h:321:
In file included from ../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:39:
../inst/projects/Arrays/include/assign/STK_AssignSelector.h:120:13: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'const STK::Range' (aka 'const TRange<UnknownSize>') and 'const STK::Range') to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
{ return I==J;}
~^ ~
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:74:
In file included from ../inst/projects/Arrays/include/STK_CArray.h:38:
In file included from ../inst/projects/Arrays/include/STK_ICArray.h:43:
In file included from ../inst/projects/Arrays/include/STK_ArrayBase.h:321:
In file included from ../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:39:
../inst/projects/Arrays/include/assign/STK_AssignSelector.h:139:13: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'const STK::Range' (aka 'const TRange<UnknownSize>') and 'const STK::Range') to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
{ return I==J;}
~^ ~
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:74:
In file included from ../inst/projects/Arrays/include/STK_CArray.h:38:
In file included from ../inst/projects/Arrays/include/STK_ICArray.h:43:
In file included from ../inst/projects/Arrays/include/STK_ArrayBase.h:321:
In file included from ../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:39:
../inst/projects/Arrays/include/assign/STK_AssignSelector.h:120:13: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'const STK::Range' (aka 'const TRange<UnknownSize>') and 'const STK::Range') to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
{ return I==J;}
~^ ~
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:74:
In file included from ../inst/projects/Arrays/include/STK_CArray.h:38:
In file included from ../inst/projects/Arrays/include/STK_ICArray.h:43:
In file included from ../inst/projects/Arrays/include/STK_ArrayBase.h:321:
In file included from ../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:39:
../inst/projects/Arrays/include/assign/STK_AssignSelector.h:139:13: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'const STK::Range' (aka 'const TRange<UnknownSize>') and 'const STK::Range') to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
{ return I==J;}
~^ ~
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:107:
In file included from ../inst/projects/Arrays/include/STK_Display.h:39:
In file included from ../inst/projects/DManager/include/STK_ExportToCsv.h:39:
In file included from ../inst/projects/DManager/include/STK_ReadWriteCsv.h:45:
../inst/projects/DManager/include/STK_Variable.h:237:11: warning: variable 'code' set but not used [-Wunused-but-set-variable]
{ int code = baseIdx;
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:107:
In file included from ../inst/projects/Arrays/include/STK_Display.h:39:
In file included from ../inst/projects/DManager/include/STK_ExportToCsv.h:39:
In file included from ../inst/projects/DManager/include/STK_ReadWriteCsv.h:45:
../inst/projects/DManager/include/STK_Variable.h:237:11: warning: variable 'code' set but not used [-Wunused-but-set-variable]
{ int code = baseIdx;
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:164:
In file included from ../inst/include/STatistiK.h:92:
../inst/projects/STatistiK/include/MersenneTwister.h:313:18: warning: arithmetic between different enumeration types ('MTRand::(unnamed enum at ../inst/projects/STatistiK/include/MersenneTwister.h:94:5)' and 'MTRand::(unnamed enum at ../inst/projects/STatistiK/include/MersenneTwister.h:98:5)') is deprecated [-Wdeprecated-anon-enum-enum-conversion]
for( i = N - M; i--; ++p )
~ ^ ~
../inst/projects/STatistiK/include/MersenneTwister.h:316:24: warning: arithmetic between different enumeration types ('MTRand::(unnamed enum at ../inst/projects/STatistiK/include/MersenneTwister.h:98:5)' and 'MTRand::(unnamed enum at ../inst/projects/STatistiK/include/MersenneTwister.h:94:5)') is deprecated [-Wdeprecated-anon-enum-enum-conversion]
*p = twist( p[M-N], p[0], p[1] );
~^~
../inst/projects/STatistiK/include/MersenneTwister.h:317:22: warning: arithmetic between different enumeration types ('MTRand::(unnamed enum at ../inst/projects/STatistiK/include/MersenneTwister.h:98:5)' and 'MTRand::(unnamed enum at ../inst/projects/STatistiK/include/MersenneTwister.h:94:5)') is deprecated [-Wdeprecated-anon-enum-enum-conversion]
*p = twist( p[M-N], p[0], state[0] );
~^~
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:164:
In file included from ../inst/include/STatistiK.h:92:
../inst/projects/STatistiK/include/MersenneTwister.h:313:18: warning: arithmetic between different enumeration types ('MTRand::(unnamed enum at ../inst/projects/STatistiK/include/MersenneTwister.h:94:5)' and 'MTRand::(unnamed enum at ../inst/projects/STatistiK/include/MersenneTwister.h:98:5)') is deprecated [-Wdeprecated-anon-enum-enum-conversion]
for( i = N - M; i--; ++p )
~ ^ ~
../inst/projects/STatistiK/include/MersenneTwister.h:316:24: warning: arithmetic between different enumeration types ('MTRand::(unnamed enum at ../inst/projects/STatistiK/include/MersenneTwister.h:98:5)' and 'MTRand::(unnamed enum at ../inst/projects/STatistiK/include/MersenneTwister.h:94:5)') is deprecated [-Wdeprecated-anon-enum-enum-conversion]
*p = twist( p[M-N], p[0], p[1] );
~^~
../inst/projects/STatistiK/include/MersenneTwister.h:317:22: warning: arithmetic between different enumeration types ('MTRand::(unnamed enum at ../inst/projects/STatistiK/include/MersenneTwister.h:98:5)' and 'MTRand::(unnamed enum at ../inst/projects/STatistiK/include/MersenneTwister.h:94:5)') is deprecated [-Wdeprecated-anon-enum-enum-conversion]
*p = twist( p[M-N], p[0], state[0] );
~^~
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:166:
In file included from ../inst/include/StatModels.h:63:
../inst/projects/StatModels/include/STK_ModelDiagGaussian_muj_sj.h:108:17: warning: ISO C++20 considers use of overloaded operator '!=' (with operand types 'const STK::Range' (aka 'const TRange<UnknownSize>') and 'STK::Range' (aka 'TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function with non-reversed arguments [-Wambiguous-reversed-operator]
if (range != range_)
~~~~~ ^ ~~~~~~
../inst/projects/STKernel/include/STK_Range.h:138:17: note: candidate function with non-reversed arguments
inline bool operator!=(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguous candidate function with reversed arguments
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:166:
In file included from ../inst/include/StatModels.h:63:
../inst/projects/StatModels/include/STK_ModelDiagGaussian_muj_sj.h:108:17: warning: ISO C++20 considers use of overloaded operator '!=' (with operand types 'const STK::Range' (aka 'const TRange<UnknownSize>') and 'STK::Range' (aka 'TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function with non-reversed arguments [-Wambiguous-reversed-operator]
if (range != range_)
~~~~~ ^ ~~~~~~
../inst/projects/STKernel/include/STK_Range.h:138:17: note: candidate function with non-reversed arguments
inline bool operator!=(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguous candidate function with reversed arguments
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:166:
In file included from ../inst/include/StatModels.h:68:
../inst/projects/StatModels/include/STK_ModelBernoulli_pj.h:118:17: warning: ISO C++20 considers use of overloaded operator '!=' (with operand types 'const STK::Range' (aka 'const TRange<UnknownSize>') and 'STK::Range' (aka 'TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function with non-reversed arguments [-Wambiguous-reversed-operator]
if (range != range_)
~~~~~ ^ ~~~~~~
../inst/projects/STKernel/include/STK_Range.h:138:17: note: candidate function with non-reversed arguments
inline bool operator!=(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguous candidate function with reversed arguments
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:166:
In file included from ../inst/include/StatModels.h:69:
../inst/projects/StatModels/include/STK_ModelGamma_aj_bj.h:108:15: warning: ISO C++20 considers use of overloaded operator '!=' (with operand types 'const STK::Range' (aka 'const TRange<UnknownSize>') and 'STK::Range' (aka 'TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function with non-reversed arguments [-Wambiguous-reversed-operator]
if (range != range_)
~~~~~ ^ ~~~~~~
../inst/projects/STKernel/include/STK_Range.h:138:17: note: candidate function with non-reversed arguments
inline bool operator!=(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguous candidate function with reversed arguments
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:166:
In file included from ../inst/include/StatModels.h:68:
../inst/projects/StatModels/include/STK_ModelBernoulli_pj.h:118:17: warning: ISO C++20 considers use of overloaded operator '!=' (with operand types 'const STK::Range' (aka 'const TRange<UnknownSize>') and 'STK::Range' (aka 'TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function with non-reversed arguments [-Wambiguous-reversed-operator]
if (range != range_)
~~~~~ ^ ~~~~~~
../inst/projects/STKernel/include/STK_Range.h:138:17: note: candidate function with non-reversed arguments
inline bool operator!=(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguous candidate function with reversed arguments
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:166:
In file included from ../inst/include/StatModels.h:69:
../inst/projects/StatModels/include/STK_ModelGamma_aj_bj.h:108:15: warning: ISO C++20 considers use of overloaded operator '!=' (with operand types 'const STK::Range' (aka 'const TRange<UnknownSize>') and 'STK::Range' (aka 'TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function with non-reversed arguments [-Wambiguous-reversed-operator]
if (range != range_)
~~~~~ ^ ~~~~~~
../inst/projects/STKernel/include/STK_Range.h:138:17: note: candidate function with non-reversed arguments
inline bool operator!=(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguous candidate function with reversed arguments
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:69:
In file included from ../inst/projects/Arrays/include/STK_Array1D.h:38:
In file included from ../inst/projects/Arrays/include/STK_IArray1D.h:47:
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:585:15: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'STK::MemAllocator<std::basic_string<char>, 2147483647>::AllocatorRange' (aka 'TRange<2147483647>') and 'const TRange<2147483647>') to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((range_ == I)&&(p_data_)&&(!isRef())) return;
~~~~~~ ^ ~
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:422:3: note: in instantiation of function template specialization 'STK::MemAllocator<std::basic_string<char>, 2147483647>::malloc<2147483647>' requested here
{ malloc(I);}
^
../inst/projects/Arrays/include/STK_IArray1D.h:339:40: note: in instantiation of member function 'STK::MemAllocator<std::basic_string<char>, 2147483647>::MemAllocator' requested here
IArray1D<Derived>::IArray1D(): Base(), allocator_(Arrays::evalRangeCapacity(range())) {}
^
../inst/projects/Arrays/include/STK_IArray1D.h:525:14: note: in instantiation of member function 'STK::IArray1D<STK::Variable<std::basic_string<char>>>::IArray1D' requested here
IArray1D Taux;
^
../inst/projects/DManager/include/STK_Variable.h:214:13: note: in instantiation of member function 'STK::IArray1D<STK::Variable<std::basic_string<char>>>::insertElt' requested here
{ Base::insertElt(pos, n);}
^
../inst/projects/DManager/include/STK_Variable.h:318:9: note: in instantiation of member function 'STK::Variable<std::basic_string<char>>::insertElt' requested here
this->insertElt(this->end(), n);
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:69:
In file included from ../inst/projects/Arrays/include/STK_Array1D.h:38:
../inst/projects/Arrays/include/STK_IArray1D.h:413:16: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'const STK::ITContainer1D<STK::Variable<std::basic_string<char>>>::RowRange' (aka 'const TRange<size_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ( range() == I) return this->asDerived();
~~~~~~~ ^ ~
../inst/projects/Arrays/include/STK_ITContainer1D.h:245:32: note: in instantiation of member function 'STK::IArray1D<STK::Variable<std::basic_string<char>>>::resizeImpl' requested here
{ return this->asDerived().resizeImpl(I);}
^
../inst/projects/DManager/include/STK_Variable.h:389:9: note: in instantiation of member function 'STK::ITContainer1D<STK::Variable<std::basic_string<char>>>::resize' requested here
this->resize(V.range());
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:69:
In file included from ../inst/projects/Arrays/include/STK_Array1D.h:38:
In file included from ../inst/projects/Arrays/include/STK_IArray1D.h:47:
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:585:15: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'STK::MemAllocator<STK::Variable<std::basic_string<char>>, 2147483647>::AllocatorRange' (aka 'TRange<2147483647>') and 'const TRange<2147483647>') to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((range_ == I)&&(p_data_)&&(!isRef())) return;
~~~~~~ ^ ~
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:422:3: note: in instantiation of function template specialization 'STK::MemAllocator<STK::Variable<std::basic_string<char>>, 2147483647>::malloc<2147483647>' requested here
{ malloc(I);}
^
../inst/projects/Arrays/include/STK_IArray1D.h:339:40: note: in instantiation of member function 'STK::MemAllocator<STK::Variable<std::basic_string<char>>, 2147483647>::MemAllocator' requested here
IArray1D<Derived>::IArray1D(): Base(), allocator_(Arrays::evalRangeCapacity(range())) {}
^
../inst/projects/Arrays/include/STK_Array1D.h:138:16: note: in instantiation of member function 'STK::IArray1D<STK::Array1D<STK::Variable<std::basic_string<char>>, 2147483647>>::IArray1D' requested here
Array1D(): Base(){}
^
../inst/projects/DManager/include/STK_ReadWriteCsv.h:115:12: note: in instantiation of member function 'STK::Array1D<STK::Variable<std::basic_string<char>>, 2147483647>::Array1D' requested here
inline TReadWriteCsv() : file_name_()
^
../inst/projects/DManager/include/STK_ExportToCsv.h:66:39: note: in instantiation of member function 'STK::TReadWriteCsv<std::basic_string<char>>::TReadWriteCsv' requested here
inline ExportToCsv(): p_data_(new ReadWriteCsv()) {}
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:69:
In file included from ../inst/projects/Arrays/include/STK_Array1D.h:38:
../inst/projects/Arrays/include/STK_IArray1D.h:413:16: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'const STK::ITContainer1D<STK::Array1D<STK::Variable<std::basic_string<char>>, 2147483647>>::RowRange' (aka 'const TRange<size_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ( range() == I) return this->asDerived();
~~~~~~~ ^ ~
../inst/projects/Arrays/include/STK_ITContainer1D.h:245:32: note: in instantiation of member function 'STK::IArray1D<STK::Array1D<STK::Variable<std::basic_string<char>>, 2147483647>>::resizeImpl' requested here
{ return this->asDerived().resizeImpl(I);}
^
../inst/projects/DManager/include/STK_ReadWriteCsv.h:704:17: note: in instantiation of member function 'STK::ITContainer1D<STK::Array1D<STK::Variable<std::basic_string<char>>, 2147483647>>::resize' requested here
{ str_data_.resize(cols);}
^
../inst/projects/DManager/include/STK_ReadWriteCsv.h:376:7: note: in instantiation of member function 'STK::TReadWriteCsv<std::basic_string<char>>::resizeCols' requested here
resizeCols(sizeCols);
^
../inst/projects/DManager/include/STK_ExportToCsv.h:73:16: note: in instantiation of member function 'STK::TReadWriteCsv<std::basic_string<char>>::resize' requested here
p_data_->resize(df.sizeRows(), df.sizeCols());
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:69:
In file included from ../inst/projects/Arrays/include/STK_Array1D.h:38:
In file included from ../inst/projects/Arrays/include/STK_IArray1D.h:47:
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:585:15: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'STK::MemAllocator<int, 2147483647>::AllocatorRange' (aka 'TRange<2147483647>') and 'const TRange<2147483647>') to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((range_ == I)&&(p_data_)&&(!isRef())) return;
~~~~~~ ^ ~
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:422:3: note: in instantiation of function template specialization 'STK::MemAllocator<int, 2147483647>::malloc<2147483647>' requested here
{ malloc(I);}
^
../inst/projects/Arrays/include/allocators/STK_CAllocator.h:277:53: note: in instantiation of member function 'STK::MemAllocator<int, 2147483647>::MemAllocator' requested here
: Base(I, J), ldx_(I.size()), allocator_(prod(I, J))
^
../inst/projects/Arrays/include/allocators/STK_CAllocator.h:719:66: note: in instantiation of member function 'STK::OrientedCAllocator<STK::CAllocator<int, 2147483647, 1, true>, true>::OrientedCAllocator' requested here
StructuredCAllocator( RowRange const& I, ColRange const& J): Base(I, J), col_(J.begin()) {}
^
../inst/projects/Arrays/include/allocators/STK_CAllocator.h:1197:19: note: in instantiation of member function 'STK::StructuredCAllocator<STK::CAllocator<int, 2147483647, 1, true>, 2147483647, 1>::StructuredCAllocator' requested here
CAllocator(): Base(0, SizeCols_) {}
^
../inst/projects/Arrays/include/STK_ICArray.h:154:24: note: in instantiation of member function 'STK::CAllocator<int, 2147483647, 1, true>::CAllocator' requested here
ICArray(): Base(), allocator_() {}
^
../inst/projects/Arrays/include/STK_CArrayVector.h:124:21: note: in instantiation of member function 'STK::ICArray<STK::CArrayVector<int, 2147483647, true>>::ICArray' requested here
CArrayVector(): Base() {}
^
../inst/projects/DManager/include/STK_CvHandler.h:112:30: note: in instantiation of member function 'STK::CArrayVector<int, 2147483647, true>::CArrayVector' requested here
, partitions_(), sizePartitions_()
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:74:
In file included from ../inst/projects/Arrays/include/STK_CArray.h:38:
In file included from ../inst/projects/Arrays/include/STK_ICArray.h:43:
In file included from ../inst/projects/Arrays/include/STK_ArrayBase.h:321:
In file included from ../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:39:
../inst/projects/Arrays/include/assign/STK_AssignSelector.h:158:27: warning: ISO C++20 considers use of overloaded operator '!=' (with operand types 'const STK::ITContainer<STK::CArrayVector<int, 2147483647, true>, 8>::RowRange' (aka 'const TRange<sizeRows_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function with non-reversed arguments [-Wambiguous-reversed-operator]
{ return (array.range() != I);}
~~~~~~~~~~~~~ ^ ~
../inst/projects/Arrays/include/STK_ICArray.h:471:53: note: in instantiation of member function 'STK::hidden::CheckShift<STK::CArrayVector<int, 2147483647, true>, 8>::resize' requested here
if (!hidden::CheckShift<Derived, structure_>::resize(this->asDerived(), I)) return this->asDerived();
^
../inst/projects/DManager/include/STK_CvHandler.h:221:15: note: in instantiation of function template specialization 'STK::ICArray<STK::CArrayVector<int, 2147483647, true>>::resize<2147483647>' requested here
partitions_.resize(rangeData_);
^
../inst/projects/STKernel/include/STK_Range.h:138:17: note: candidate function with non-reversed arguments
inline bool operator!=(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguous candidate function with reversed arguments
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:69:
In file included from ../inst/projects/Arrays/include/STK_Array1D.h:38:
In file included from ../inst/projects/Arrays/include/STK_IArray1D.h:47:
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:585:15: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'STK::MemAllocator<std::basic_string<char>, 2147483647>::AllocatorRange' (aka 'TRange<2147483647>') and 'const TRange<2147483647>') to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((range_ == I)&&(p_data_)&&(!isRef())) return;
~~~~~~ ^ ~
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:422:3: note: in instantiation of function template specialization 'STK::MemAllocator<std::basic_string<char>, 2147483647>::malloc<2147483647>' requested here
{ malloc(I);}
^
../inst/projects/Arrays/include/STK_IArray1D.h:339:40: note: in instantiation of member function 'STK::MemAllocator<std::basic_string<char>, 2147483647>::MemAllocator' requested here
IArray1D<Derived>::IArray1D(): Base(), allocator_(Arrays::evalRangeCapacity(range())) {}
^
../inst/projects/Arrays/include/STK_IArray1D.h:525:14: note: in instantiation of member function 'STK::IArray1D<STK::Variable<std::basic_string<char>>>::IArray1D' requested here
IArray1D Taux;
^
../inst/projects/DManager/include/STK_Variable.h:214:13: note: in instantiation of member function 'STK::IArray1D<STK::Variable<std::basic_string<char>>>::insertElt' requested here
{ Base::insertElt(pos, n);}
^
../inst/projects/DManager/include/STK_Variable.h:318:9: note: in instantiation of member function 'STK::Variable<std::basic_string<char>>::insertElt' requested here
this->insertElt(this->end(), n);
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:69:
In file included from ../inst/projects/Arrays/include/STK_Array1D.h:38:
../inst/projects/Arrays/include/STK_IArray1D.h:413:16: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'const STK::ITContainer1D<STK::Variable<std::basic_string<char>>>::RowRange' (aka 'const TRange<size_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ( range() == I) return this->asDerived();
~~~~~~~ ^ ~
../inst/projects/Arrays/include/STK_ITContainer1D.h:245:32: note: in instantiation of member function 'STK::IArray1D<STK::Variable<std::basic_string<char>>>::resizeImpl' requested here
{ return this->asDerived().resizeImpl(I);}
^
../inst/projects/DManager/include/STK_Variable.h:389:9: note: in instantiation of member function 'STK::ITContainer1D<STK::Variable<std::basic_string<char>>>::resize' requested here
this->resize(V.range());
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:69:
In file included from ../inst/projects/Arrays/include/STK_Array1D.h:38:
In file included from ../inst/projects/Arrays/include/STK_IArray1D.h:47:
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:585:15: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'STK::MemAllocator<STK::Variable<std::basic_string<char>>, 2147483647>::AllocatorRange' (aka 'TRange<2147483647>') and 'const TRange<2147483647>') to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((range_ == I)&&(p_data_)&&(!isRef())) return;
~~~~~~ ^ ~
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:422:3: note: in instantiation of function template specialization 'STK::MemAllocator<STK::Variable<std::basic_string<char>>, 2147483647>::malloc<2147483647>' requested here
{ malloc(I);}
^
../inst/projects/Arrays/include/STK_IArray1D.h:339:40: note: in instantiation of member function 'STK::MemAllocator<STK::Variable<std::basic_string<char>>, 2147483647>::MemAllocator' requested here
IArray1D<Derived>::IArray1D(): Base(), allocator_(Arrays::evalRangeCapacity(range())) {}
^
../inst/projects/Arrays/include/STK_Array1D.h:138:16: note: in instantiation of member function 'STK::IArray1D<STK::Array1D<STK::Variable<std::basic_string<char>>, 2147483647>>::IArray1D' requested here
Array1D(): Base(){}
^
../inst/projects/DManager/include/STK_ReadWriteCsv.h:115:12: note: in instantiation of member function 'STK::Array1D<STK::Variable<std::basic_string<char>>, 2147483647>::Array1D' requested here
inline TReadWriteCsv() : file_name_()
^
../inst/projects/DManager/include/STK_ExportToCsv.h:66:39: note: in instantiation of member function 'STK::TReadWriteCsv<std::basic_string<char>>::TReadWriteCsv' requested here
inline ExportToCsv(): p_data_(new ReadWriteCsv()) {}
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:69:
In file included from ../inst/projects/Arrays/include/STK_Array1D.h:38:
../inst/projects/Arrays/include/STK_IArray1D.h:413:16: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'const STK::ITContainer1D<STK::Array1D<STK::Variable<std::basic_string<char>>, 2147483647>>::RowRange' (aka 'const TRange<size_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ( range() == I) return this->asDerived();
~~~~~~~ ^ ~
../inst/projects/Arrays/include/STK_ITContainer1D.h:245:32: note: in instantiation of member function 'STK::IArray1D<STK::Array1D<STK::Variable<std::basic_string<char>>, 2147483647>>::resizeImpl' requested here
{ return this->asDerived().resizeImpl(I);}
^
../inst/projects/DManager/include/STK_ReadWriteCsv.h:704:17: note: in instantiation of member function 'STK::ITContainer1D<STK::Array1D<STK::Variable<std::basic_string<char>>, 2147483647>>::resize' requested here
{ str_data_.resize(cols);}
^
../inst/projects/DManager/include/STK_ReadWriteCsv.h:376:7: note: in instantiation of member function 'STK::TReadWriteCsv<std::basic_string<char>>::resizeCols' requested here
resizeCols(sizeCols);
^
../inst/projects/DManager/include/STK_ExportToCsv.h:73:16: note: in instantiation of member function 'STK::TReadWriteCsv<std::basic_string<char>>::resize' requested here
p_data_->resize(df.sizeRows(), df.sizeCols());
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:69:
In file included from ../inst/projects/Arrays/include/STK_Array1D.h:38:
In file included from ../inst/projects/Arrays/include/STK_IArray1D.h:47:
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:585:15: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'STK::MemAllocator<double, 2147483647>::AllocatorRange' (aka 'TRange<2147483647>') and 'const TRange<2147483647>') to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((range_ == I)&&(p_data_)&&(!isRef())) return;
~~~~~~ ^ ~
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:448:5: note: in instantiation of function template specialization 'STK::MemAllocator<double, 2147483647>::malloc<2147483647>' requested here
malloc(range());
^
../inst/projects/Arrays/include/allocators/STK_CAllocator.h:281:48: note: in instantiation of member function 'STK::MemAllocator<double, 2147483647>::MemAllocator' requested here
: Base(A), ldx_(A.ldx()), allocator_(A.allocator_, ref)
^
../inst/projects/Arrays/include/allocators/STK_CAllocator.h:537:69: note: in instantiation of member function 'STK::OrientedCAllocator<STK::CAllocator<double, 2147483647, 2147483647, true>, true>::OrientedCAllocator' requested here
StructuredCAllocator( StructuredCAllocator const& A, bool ref): Base(A, ref) {}
^
../inst/projects/Arrays/include/allocators/STK_CAllocator.h:1004:56: note: in instantiation of member function 'STK::StructuredCAllocator<STK::CAllocator<double, 2147483647, 2147483647, true>, 2147483647, 2147483647>::StructuredCAllocator' requested here
CAllocator( CAllocator const& A, bool ref = true): Base(A, ref)
^
../inst/projects/Arrays/include/STK_ICArray.h:168:59: note: in instantiation of member function 'STK::CAllocator<double, 2147483647, 2147483647, true>::CAllocator' requested here
ICArray( Derived const& T, bool ref = false): Base(), allocator_(T.allocator_, ref) {}
^
../inst/projects/Arrays/include/STK_CArray.h:175:47: note: in instantiation of member function 'STK::ICArray<STK::CArray<double, 2147483647, 2147483647, true>>::ICArray' requested here
CArray( CArray const& T, bool ref=false): Base(T, ref) {}
^
../inst/projects/Algebra/include/STK_ISvd.h:75:18: note: in instantiation of member function 'STK::CArray<double, 2147483647, 2147483647, true>::CArray' requested here
: U_(A, ref), V_(), D_()
^
../inst/projects/Algebra/include/STK_lapack_Svd.h:132:17: note: in instantiation of member function 'STK::ISvd<STK::lapack::Svd>::ISvd' requested here
: Base(A, ref, withU, withV), jobz_( (withU|withV) ? 'O':'N') {}
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:69:
In file included from ../inst/projects/Arrays/include/STK_Array1D.h:38:
In file included from ../inst/projects/Arrays/include/STK_IArray1D.h:47:
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:585:15: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'STK::MemAllocator<int, 2147483647>::AllocatorRange' (aka 'TRange<2147483647>') and 'const TRange<2147483647>') to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((range_ == I)&&(p_data_)&&(!isRef())) return;
~~~~~~ ^ ~
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:422:3: note: in instantiation of function template specialization 'STK::MemAllocator<int, 2147483647>::malloc<2147483647>' requested here
{ malloc(I);}In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:74:
In file included from ../inst/projects/Arrays/include/STK_CArray.h:38:
In file included from ../inst/projects/Arrays/include/STK_ICArray.h:43:
In file included from ../inst/projects/Arrays/include/STK_ArrayBase.h:321:
../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:88:56: warning: ISO C++20 considers use of overloaded operator '!=' (with operand types 'const STK::ITContainerBase<STK::CArray<double, 2147483647, 2147483647, true>>::ColRange' (aka 'const TRange<sizeCols_>') and 'const STK::ITContainerBase<STK::CArray<double, 2147483647, 2147483647, true>>::RowRange' (aka 'const TRange<sizeRows_>')) to be ambiguous despite there being a unique best viable function with non-reversed arguments [-Wambiguous-reversed-operator]
if (structure_ == int(Arrays::square_) && rhs.cols() != rhs.rows() )
~~~~~~~~~~ ^ ~~~~~~~~~~
../inst/projects/Arrays/include/STK_CArray.h:212:60: note: in instantiation of function template specialization 'STK::ArrayBase<STK::CArray<double, 2147483647, 2147483647, true>>::assign<STK::CArray<double, 2147483647, 2147483647, true>>' requested here
CArray& operator=(CArray const& rhs) { return LowBase::assign(rhs);}
^
../inst/projects/Algebra/include/STK_ISvd.h:103:10: note: in instantiation of member function 'STK::CArray<double, 2147483647, 2147483647, true>::operator=' requested here
U_ = S.U_; V_ = S.V_; D_ = S.D_;
^
../inst/projects/Algebra/include/STK_lapack_Svd.h:152:13: note: in instantiation of member function 'STK::ISvd<STK::lapack::Svd>::operator=' requested here
Base::operator=(decomp);
^
../inst/projects/STKernel/include/STK_Range.h:138:17: note: candidate function with non-reversed arguments
inline bool operator!=(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguous candidate function with reversed arguments
inline bool operator==(TRange<OtherSize_> const& I) const
^
^
../inst/projects/Arrays/include/allocators/STK_CAllocator.h:277:53: note: in instantiation of member function 'STK::MemAllocator<int, 2147483647>::MemAllocator' requested here
: Base(I, J), ldx_(I.size()), allocator_(prod(I, J))
^
../inst/projects/Arrays/include/allocators/STK_CAllocator.h:719:66: note: in instantiation of member function 'STK::OrientedCAllocator<STK::CAllocator<int, 2147483647, 1, true>, true>::OrientedCAllocator' requested here
StructuredCAllocator( RowRange const& I, ColRange const& J): Base(I, J), col_(J.begin()) {}
^
../inst/projects/Arrays/include/allocators/STK_CAllocator.h:1197:19: note: in instantiation of member function 'STK::StructuredCAllocator<STK::CAllocator<int, 2147483647, 1, true>, 2147483647, 1>::StructuredCAllocator' requested here
CAllocator(): Base(0, SizeCols_) {}
^
../inst/projects/Arrays/include/STK_ICArray.h:154:24: note: in instantiation of member function 'STK::CAllocator<int, 2147483647, 1, true>::CAllocator' requested here
ICArray(): Base(), allocator_() {}
^
../inst/projects/Arrays/include/STK_CArrayVector.h:124:21: note: in instantiation of member function 'STK::ICArray<STK::CArrayVector<int, 2147483647, true>>::ICArray' requested here
CArrayVector(): Base() {}
^
../inst/projects/DManager/include/STK_CvHandler.h:112:30: note: in instantiation of member function 'STK::CArrayVector<int, 2147483647, true>::CArrayVector' requested here
, partitions_(), sizePartitions_()
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:74:
In file included from ../inst/projects/Arrays/include/STK_CArray.h:38:
In file included from ../inst/projects/Arrays/include/STK_ICArray.h:43:
In file included from ../inst/projects/Arrays/include/STK_ArrayBase.h:321:
In file included from ../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:39:
../inst/projects/Arrays/include/assign/STK_AssignSelector.h:158:27: warning: ISO C++20 considers use of overloaded operator '!=' (with operand types 'const STK::ITContainer<STK::CArrayVector<int, 2147483647, true>, 8>::RowRange' (aka 'const TRange<sizeRows_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function with non-reversed arguments [-Wambiguous-reversed-operator]
{ return (array.range() != I);}
~~~~~~~~~~~~~ ^ ~
../inst/projects/Arrays/include/STK_ICArray.h:471:53: note: in instantiation of member function 'STK::hidden::CheckShift<STK::CArrayVector<int, 2147483647, true>, 8>::resize' requested here
if (!hidden::CheckShift<Derived, structure_>::resize(this->asDerived(), I)) return this->asDerived();
^
../inst/projects/DManager/include/STK_CvHandler.h:221:15: note: in instantiation of function template specialization 'STK::ICArray<STK::CArrayVector<int, 2147483647, true>>::resize<2147483647>' requested here
partitions_.resize(rangeData_);
^
../inst/projects/STKernel/include/STK_Range.h:138:17: note: candidate function with non-reversed arguments
inline bool operator!=(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguous candidate function with reversed arguments
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:74:
In file included from ../inst/projects/Arrays/include/STK_CArray.h:38:
In file included from ../inst/projects/Arrays/include/STK_ICArray.h:43:
In file included from ../inst/projects/Arrays/include/STK_ArrayBase.h:321:
../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:88:56: error: use of overloaded operator '!=' is ambiguous (with operand types 'const STK::ITContainerBase<STK::CArrayVector<double, 2147483647, true>>::ColRange' (aka 'const TRange<sizeCols_>') and 'const STK::ITContainerBase<STK::CArrayVector<double, 2147483647, true>>::RowRange' (aka 'const TRange<sizeRows_>'))
if (structure_ == int(Arrays::square_) && rhs.cols() != rhs.rows() )
~~~~~~~~~~ ^ ~~~~~~~~~~
../inst/projects/Arrays/include/STK_CArrayVector.h:195:72: note: in instantiation of function template specialization 'STK::ArrayBase<STK::CArrayVector<double, 2147483647, true>>::assign<STK::CArrayVector<double, 2147483647, true>>' requested here
CArrayVector& operator=(CArrayVector const& rhs) { return LowBase::assign(rhs);}
^
../inst/projects/Algebra/include/STK_ISvd.h:103:33: note: in instantiation of member function 'STK::CArrayVector<double, 2147483647, true>::operator=' requested here
U_ = S.U_; V_ = S.V_; D_ = S.D_;
^
../inst/projects/Algebra/include/STK_lapack_Svd.h:152:13: note: in instantiation of member function 'STK::ISvd<STK::lapack::Svd>::operator=' requested here
Base::operator=(decomp);
^
../inst/projects/STKernel/include/STK_Range.h:138:17: note: candidate function [with OtherSize_ = 2147483647]
inline bool operator!=(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: candidate function [with OtherSize_ = 2147483647]
inline bool operator==(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: candidate function (with reversed parameter order) [with OtherSize_ = 1]
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:74:
In file included from ../inst/projects/Arrays/include/STK_CArray.h:38:
In file included from ../inst/projects/Arrays/include/STK_ICArray.h:43:
In file included from ../inst/projects/Arrays/include/STK_ArrayBase.h:321:
In file included from ../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:39:
../inst/projects/Arrays/include/assign/STK_AssignSelector.h:158:27: warning: ISO C++20 considers use of overloaded operator '!=' (with operand types 'const STK::ITContainer<STK::CArrayVector<double, 2147483647, true>, 8>::RowRange' (aka 'const TRange<sizeRows_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function with non-reversed arguments [-Wambiguous-reversed-operator]
{ return (array.range() != I);}
~~~~~~~~~~~~~ ^ ~
../inst/projects/Arrays/include/STK_ICArray.h:471:53: note: in instantiation of member function 'STK::hidden::CheckShift<STK::CArrayVector<double, 2147483647, true>, 8>::resize' requested here
if (!hidden::CheckShift<Derived, structure_>::resize(this->asDerived(), I)) return this->asDerived();
^
../inst/projects/Arrays/include/assign/STK_AssignSelector.h:220:9: note: in instantiation of function template specialization 'STK::ICArray<STK::CArrayVector<double, 2147483647, true>>::resize<2147483647>' requested here
{ lhs.resize(rhs.range());}
^
../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:91:57: note: in instantiation of member function 'STK::hidden::resizeSelector<STK::CArrayVector<double, 2147483647, true>, STK::CArrayVector<double, 2147483647, true>, 8>::run' requested here
hidden::resizeSelector<Derived, Rhs, rhs_structure_>::run(this->asDerived(), rhs.asDerived());
^
../inst/projects/Arrays/include/STK_CArrayVector.h:195:72: note: in instantiation of function template specialization 'STK::ArrayBase<STK::CArrayVector<double, 2147483647, true>>::assign<STK::CArrayVector<double, 2147483647, true>>' requested here
CArrayVector& operator=(CArrayVector const& rhs) { return LowBase::assign(rhs);}
^
../inst/projects/Algebra/include/STK_ISvd.h:103:33: note: in instantiation of member function 'STK::CArrayVector<double, 2147483647, true>::operator=' requested here
U_ = S.U_; V_ = S.V_; D_ = S.D_;
^
../inst/projects/Algebra/include/STK_lapack_Svd.h:152:13: note: in instantiation of member function 'STK::ISvd<STK::lapack::Svd>::operator=' requested here
Base::operator=(decomp);
^
../inst/projects/STKernel/include/STK_Range.h:138:17: note: candidate function with non-reversed arguments
inline bool operator!=(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguous candidate function with reversed arguments
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:162:
In file included from ../inst/include/Algebra.h:68:
../inst/projects/Algebra/include/STK_transpose.h:53:14: warning: ISO C++20 considers use of overloaded operator '!=' (with operand types 'const STK::ITContainerBase<STK::CArray<double, 2147483647, 2147483647, true>>::RowRange' (aka 'const TRange<sizeRows_>') and 'const STK::ITContainerBase<STK::CArray<double, 2147483647, 2147483647, true>>::ColRange' (aka 'const TRange<sizeCols_>')) to be ambiguous despite there being a unique best viable function with non-reversed arguments [-Wambiguous-reversed-operator]
if(A.rows()!=A.cols())
~~~~~~~~^ ~~~~~~~~
../inst/projects/Algebra/include/STK_lapack_Svd.h:196:3: note: in instantiation of function template specialization 'STK::transpose<STK::CArray<double, 2147483647, 2147483647, true>>' requested here
transpose(V_.shift(beginCol));
^
../inst/projects/STKernel/include/STK_Range.h:138:17: note: candidate function with non-reversed arguments
inline bool operator!=(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguous candidate function with reversed arguments
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:74:
In file included from ../inst/projects/Arrays/include/STK_CArray.h:38:
In file included from ../inst/projects/Arrays/include/STK_ICArray.h:43:
In file included from ../inst/projects/Arrays/include/STK_ArrayBase.h:321:
../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:88:56: warning: ISO C++20 considers use of overloaded operator '!=' (with operand types 'const STK::ITContainerBase<STK::TransposeAccessor<STK::CArray<double, 2147483647, 2147483647, true>>>::ColRange' (aka 'const TRange<sizeCols_>') and 'const STK::ITContainerBase<STK::TransposeAccessor<STK::CArray<double, 2147483647, 2147483647, true>>>::RowRange' (aka 'const TRange<sizeRows_>')) to be ambiguous despite there being a unique best viable function with non-reversed arguments [-Wambiguous-reversed-operator]
if (structure_ == int(Arrays::square_) && rhs.cols() != rhs.rows() )
~~~~~~~~~~ ^ ~~~~~~~~~~
../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:107:10: note: in instantiation of function template specialization 'STK::ArrayBase<STK::CArray<double, 2147483647, 2147483647, true>>::assign<STK::TransposeAccessor<STK::CArray<double, 2147483647, 2147483647, true>>>' requested here
{ return assign(rhs.asDerived());}
^
../inst/projects/Arrays/include/STK_CArray.h:197:91: note: in instantiation of function template specialization 'STK::ArrayBase<STK::CArray<double, 2147483647, 2147483647, true>>::operator=<STK::TransposeAccessor<STK::CArray<double, 2147483647, 2147483647, true>>>' requested here
CArray( ExprBase<OtherDerived> const& T): Base(T.sizeRows(), T.sizeCols()) { LowBase::operator=(T);}
^
../inst/projects/Algebra/include/STK_transpose.h:55:24: note: in instantiation of function template specialization 'STK::CArray<double, 2147483647, 2147483647, true>::CArray<STK::TransposeAccessor<STK::CArray<double, 2147483647, 2147483647, true>>>' requested here
TContainer2D Aux = A.transpose();
^
../inst/projects/Algebra/include/STK_lapack_Svd.h:196:3: note: in instantiation of function template specialization 'STK::transpose<STK::CArray<double, 2147483647, 2147483647, true>>' requested here
transpose(V_.shift(beginCol));
^
../inst/projects/STKernel/include/STK_Range.h:138:17: note: candidate function with non-reversed arguments
inline bool operator!=(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguous candidate function with reversed arguments
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:74:
In file included from ../inst/projects/Arrays/include/STK_CArray.h:38:
In file included from ../inst/projects/Arrays/include/STK_ICArray.h:43:
In file included from ../inst/projects/Arrays/include/STK_ArrayBase.h:321:
In file included from ../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:39:
../inst/projects/Arrays/include/assign/STK_AssignSelector.h:65:26: warning: ISO C++20 considers use of overloaded operator '!=' (with operand types 'const STK::ITContainerBase<STK::CArray<double, 2147483647, 2147483647, true>>::RowRange' (aka 'const TRange<sizeRows_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function with non-reversed arguments [-Wambiguous-reversed-operator]
{ return (array.rows() != I || array.cols() != J);}
~~~~~~~~~~~~ ^ ~
../inst/projects/Arrays/include/STK_ICArray.h:457:53: note: in instantiation of member function 'STK::hidden::CheckShift<STK::CArray<double, 2147483647, 2147483647, true>, 0>::resize' requested here
if (!hidden::CheckShift<Derived, structure_>::resize(this->asDerived(), I, J)) return this->asDerived();
^
../inst/projects/Algebra/include/STK_lapack_Svd.h:234:7: note: in instantiation of member function 'STK::ICArray<STK::CArray<double, 2147483647, 2147483647, true>>::resize' requested here
u.resize(m, ucol);
^
../inst/projects/STKernel/include/STK_Range.h:138:17: note: candidate function with non-reversed arguments
inline bool operator!=(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguous candidate function with reversed arguments
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:74:
In file included from ../inst/projects/Arrays/include/STK_CArray.h:38:
In file included from ../inst/projects/Arrays/include/STK_ICArray.h:43:
In file included from ../inst/projects/Arrays/include/STK_ArrayBase.h:321:
In file included from ../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:39:
../inst/projects/Arrays/include/assign/STK_AssignSelector.h:65:47: warning: ISO C++20 considers use of overloaded operator '!=' (with operand types 'const STK::ITContainerBase<STK::CArray<double, 2147483647, 2147483647, true>>::ColRange' (aka 'const TRange<sizeCols_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function with non-reversed arguments [-Wambiguous-reversed-operator]
{ return (array.rows() != I || array.cols() != J);}
~~~~~~~~~~~~ ^ ~
../inst/projects/STKernel/include/STK_Range.h:138:17: note: candidate function with non-reversed arguments
inline bool operator!=(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguous candidate function with reversed arguments
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:69:
In file included from ../inst/projects/Arrays/include/STK_Array1D.h:38:
In file included from ../inst/projects/Arrays/include/STK_IArray1D.h:47:
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:585:15: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'STK::MemAllocator<STK::Array1D<double, 2147483647> *, 2147483647>::AllocatorRange' (aka 'TRange<2147483647>') and 'const TRange<2147483647>') to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((range_ == I)&&(p_data_)&&(!isRef())) return;
~~~~~~ ^ ~
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:448:5: note: in instantiation of function template specialization 'STK::MemAllocator<STK::Array1D<double, 2147483647> *, 2147483647>::malloc<2147483647>' requested here
malloc(range());
^
../inst/projects/Arrays/include/STK_IArray2D.h:806:30: note: in instantiation of member function 'STK::MemAllocator<STK::Array1D<double, 2147483647> *, 2147483647>::MemAllocator' requested here
, allocator_(T.allocator_, ref)
^
../inst/projects/Arrays/include/STK_Array2D.h:158:49: note: in instantiation of member function 'STK::IArray2D<STK::Array2D<double>>::IArray2D' requested here
Array2D( Array2D const& T, bool ref=false): Base(T, ref) {}
^
../inst/projects/Algebra/include/STK_IQr.h:113:32: note: in instantiation of member function 'STK::Array2D<double>::Array2D' requested here
: IRunnerBase(), Q_(Q, ref), compq_(false), rank_(0)
^
../inst/projects/Algebra/include/STK_Qr.h:110:53: note: in instantiation of member function 'STK::IQr<STK::Qr>::IQr' requested here
inline Qr( ArrayXX const& A, bool ref = false): Base(A, ref) {}
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:69:
In file included from ../inst/projects/Arrays/include/STK_Array1D.h:38:
In file included from ../inst/projects/Arrays/include/STK_IArray1D.h:47:
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:585:15: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'STK::MemAllocator<STK::TRange<UnknownSize>, 2147483647>::AllocatorRange' (aka 'TRange<2147483647>') and 'const TRange<2147483647>') to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((range_ == I)&&(p_data_)&&(!isRef())) return;
~~~~~~ ^ ~
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:448:5: note: in instantiation of function template specialization 'STK::MemAllocator<STK::TRange<UnknownSize>, 2147483647>::malloc<2147483647>' requested here
malloc(range());
^
../inst/projects/Arrays/include/STK_IArray1D.h:358:30: note: in instantiation of member function 'STK::MemAllocator<STK::TRange<UnknownSize>, 2147483647>::MemAllocator' requested here
, allocator_(T.allocator(), ref)
^
../inst/projects/Arrays/include/STK_Array1D.h:151:50: note: in instantiation of member function 'STK::IArray1D<STK::Array1D<STK::TRange<UnknownSize>, 2147483647>>::IArray1D' requested here
Array1D( Array1D const& T, bool ref =false): Base(T, ref) {}
^
../inst/projects/Arrays/include/STK_IArray2D.h:807:30: note: in instantiation of member function 'STK::Array1D<STK::TRange<UnknownSize>, 2147483647>::Array1D' requested here
, rangeCols_(T.rangeCols_, false) // have to be created again, in case T is a temporary
^
../inst/projects/Arrays/include/STK_Array2D.h:158:49: note: in instantiation of member function 'STK::IArray2D<STK::Array2D<double>>::IArray2D' requested here
Array2D( Array2D const& T, bool ref=false): Base(T, ref) {}
^
../inst/projects/Algebra/include/STK_IQr.h:113:32: note: in instantiation of member function 'STK::Array2D<double>::Array2D' requested here
: IRunnerBase(), Q_(Q, ref), compq_(false), rank_(0)
^
../inst/projects/Algebra/include/STK_Qr.h:110:53: note: in instantiation of member function 'STK::IQr<STK::Qr>::IQr' requested here
inline Qr( ArrayXX const& A, bool ref = false): Base(A, ref) {}
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:69:
In file included from ../inst/projects/Arrays/include/STK_Array1D.h:38:
../inst/projects/Arrays/include/STK_IArray1D.h:413:16: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'const STK::ITContainer1D<STK::Array1D<double, 2147483647>>::RowRange' (aka 'const TRange<size_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ( range() == I) return this->asDerived();
~~~~~~~ ^ ~
../inst/projects/Arrays/include/STK_ITContainer1D.h:245:32: note: in instantiation of member function 'STK::IArray1D<STK::Array1D<double, 2147483647>>::resizeImpl' requested here
{ return this->asDerived().resizeImpl(I);}
^
../inst/projects/Arrays/include/STK_IArray1D.h:614:39: note: in instantiation of member function 'STK::ITContainer1D<STK::Array1D<double, 2147483647>>::resize' requested here
if ( size() != src.size() ) { this->resize(src.range());}
^
../inst/projects/Arrays/include/STK_IArray2D.h:969:7: note: in instantiation of member function 'STK::IArray1D<STK::Array1D<double, 2147483647>>::assign' requested here
dp->assign(*sp);
^
../inst/projects/Arrays/include/STK_IArray2D.h:813:7: note: in instantiation of member function 'STK::IArray2D<STK::Array2D<double>>::copyCol' requested here
{ copyCol(T, j);}
^
../inst/projects/Arrays/include/STK_Array2D.h:158:49: note: in instantiation of member function 'STK::IArray2D<STK::Array2D<double>>::IArray2D' requested here
Array2D( Array2D const& T, bool ref=false): Base(T, ref) {}
^
../inst/projects/Algebra/include/STK_IQr.h:113:32: note: in instantiation of member function 'STK::Array2D<double>::Array2D' requested here
: IRunnerBase(), Q_(Q, ref), compq_(false), rank_(0)
^
../inst/projects/Algebra/include/STK_Qr.h:110:53: note: in instantiation of member function 'STK::IQr<STK::Qr>::IQr' requested here
inline Qr( ArrayXX const& A, bool ref = false): Base(A, ref) {}
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:69:
In file included from ../inst/projects/Arrays/include/STK_Array1D.h:38:
../inst/projects/Arrays/include/STK_IArray1D.h:413:16: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'const STK::ITContainer1D<STK::Array1D<STK::TRange<UnknownSize>, 2147483647>>::RowRange' (aka 'const TRange<size_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ( range() == I) return this->asDerived();
~~~~~~~ ^ ~
../inst/projects/Arrays/include/STK_ITContainer1D.h:245:32: note: in instantiation of member function 'STK::IArray1D<STK::Array1D<STK::TRange<UnknownSize>, 2147483647>>::resizeImpl' requested here
{ return this->asDerived().resizeImpl(I);}
^
../inst/projects/Arrays/include/STK_IArray2D.h:918:16: note: in instantiation of member function 'STK::ITContainer1D<STK::Array1D<STK::TRange<UnknownSize>, 2147483647>>::resize' requested here
rangeCols_.resize(J);
^
../inst/projects/Arrays/include/STK_IArray2D.h:789:3: note: in instantiation of member function 'STK::IArray2D<STK::Array2DUpperTriangular<double>>::mallocCols' requested here
{ mallocCols(this->cols());}
^
../inst/projects/Arrays/include/STK_Array2DUpperTriangular.h:133:31: note: in instantiation of member function 'STK::IArray2D<STK::Array2DUpperTriangular<double>>::IArray2D' requested here
Array2DUpperTriangular(): Base() {}
^
../inst/projects/Algebra/include/STK_IQr.h:112:12: note: in instantiation of member function 'STK::Array2DUpperTriangular<double>::Array2DUpperTriangular' requested here
inline IQr( Array const& Q, bool ref = false)
^
../inst/projects/Algebra/include/STK_Qr.h:110:53: note: in instantiation of member function 'STK::IQr<STK::Qr>::IQr' requested here
inline Qr( ArrayXX const& A, bool ref = false): Base(A, ref) {}
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:74:
In file included from ../inst/projects/Arrays/include/STK_CArray.h:38:
In file included from ../inst/projects/Arrays/include/STK_ICArray.h:43:
In file included from ../inst/projects/Arrays/include/STK_ArrayBase.h:321:
../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:88:56: warning: ISO C++20 considers use of overloaded operator '!=' (with operand types 'const STK::ITContainerBase<STK::Array2D<double>>::ColRange' (aka 'const TRange<sizeCols_>') and 'const STK::ITContainerBase<STK::Array2D<double>>::RowRange' (aka 'const TRange<sizeRows_>')) to be ambiguous despite there being a unique best viable function with non-reversed arguments [-Wambiguous-reversed-operator]
if (structure_ == int(Arrays::square_) && rhs.cols() != rhs.rows() )
~~~~~~~~~~ ^ ~~~~~~~~~~
../inst/projects/Arrays/include/STK_Array2D.h:187:61: note: in instantiation of function template specialization 'STK::ArrayBase<STK::Array2D<double>>::assign<STK::Array2D<double>>' requested here
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:69:
In file included from ../inst/projects/Arrays/include/STK_Array1D.h:38:
In file included from ../inst/projects/Arrays/include/STK_IArray1D.h:47:
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:585:15: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'STK::MemAllocator<double, 2147483647>::AllocatorRange' (aka 'TRange<2147483647>') and 'const TRange<2147483647>') to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((range_ == I)&&(p_data_)&&(!isRef())) return;
~~~~~~ ^ ~
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:448:5: note: in instantiation of function template specialization 'STK::MemAllocator<double, 2147483647>::malloc<2147483647>' requested here
malloc(range());
^
../inst/projects/Arrays/include/allocators/STK_CAllocator.h:281:48: note: in instantiation of member function 'STK::MemAllocator<double, 2147483647>::MemAllocator' requested here
: Base(A), ldx_(A.ldx()), allocator_(A.allocator_, ref)
^
../inst/projects/Arrays/include/allocators/STK_CAllocator.h:537:69: note: in instantiation of member function 'STK::OrientedCAllocator<STK::CAllocator<double, 2147483647, 2147483647, true>, true>::OrientedCAllocator' requested here
StructuredCAllocator( StructuredCAllocator const& A, bool ref): Base(A, ref) {}
^
../inst/projects/Arrays/include/allocators/STK_CAllocator.h:1004:56: note: in instantiation of member function 'STK::StructuredCAllocator<STK::CAllocator<double, 2147483647, 2147483647, true>, 2147483647, 2147483647>::StructuredCAllocator' requested here
CAllocator( CAllocator const& A, bool ref = true): Base(A, ref)
^
../inst/projects/Arrays/include/STK_ICArray.h:168:59: note: in instantiation of member function 'STK::CAllocator<double, 2147483647, 2147483647, true>::CAllocator' requested here
ICArray( Derived const& T, bool ref = false): Base(), allocator_(T.allocator_, ref) {}
^
../inst/projects/Arrays/include/STK_CArray.h:175:47: note: in instantiation of member function 'STK::ICArray<STK::CArray<double, 2147483647, 2147483647, true>>::ICArray' requested here
Array2D& operator=( Array2D const& T) { return LowBase::assign(T);}
^
../inst/projects/Algebra/include/STK_IQr.h:141:10: note: in instantiation of member function 'STK::Array2D<double>::operator=' requested here
Q_ = decomp.Q_;
^
../inst/projects/Algebra/include/STK_Qr.h:126:13: note: in instantiation of member function 'STK::IQr<STK::Qr>::operator=' requested here
{ Base::operator=(decomp);
^
../inst/projects/STKernel/include/STK_Range.h:138:17: note: candidate function with non-reversed arguments
CArray( CArray const& T, bool ref=false): Base(T, ref) {}
^
../inst/projects/Algebra/include/STK_ISvd.h:75:18: note: in instantiation of member function 'STK::CArray<double, 2147483647, 2147483647, true>::CArray' requested here
: U_(A, ref), V_(), D_()
^
../inst/projects/Algebra/include/STK_lapack_Svd.h:132:17: note: in instantiation of member function 'STK::ISvd<STK::lapack::Svd>::ISvd' requested here
: Base(A, ref, withU, withV), jobz_( (withU|withV) ? 'O':'N') {}
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const inline bool operator!=(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguous candidate function with reversed arguments
inline bool operator==(TRange<OtherSize_> const& I) const
^
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:84:
In file included from ../inst/projects/Arrays/include/STK_Array2D.h:39:
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:175:21: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'const STK::IArray2D<STK::Array2D<double>>::RowRange' (aka 'const TRange<sizeRows_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((this->rows() == I) && (this->cols() == J)) return this->asDerived();
~~~~~~~~~~~~ ^ ~
../inst/projects/Arrays/include/assign/STK_AssignSelector.h:199:9: note: in instantiation of member function 'STK::IArray2D<STK::Array2D<double>>::resize' requested here
{ lhs.resize(rhs.rows(), rhs.cols());}
^
../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:91:57: note: in instantiation of member function 'STK::hidden::resizeSelector<STK::Array2D<double>, STK::Array2D<double>, 0>::run' requested here
hidden::resizeSelector<Derived, Rhs, rhs_structure_>::run(this->asDerived(), rhs.asDerived());
^
../inst/projects/Arrays/include/STK_Array2D.h:187:61: note: in instantiation of function template specialization 'STK::ArrayBase<STK::Array2D<double>>::assign<STK::Array2D<double>>' requested here
Array2D& operator=( Array2D const& T) { return LowBase::assign(T);}
^
../inst/projects/Algebra/include/STK_IQr.h:141:10: note: in instantiation of member function 'STK::Array2D<double>::operator=' requested here
Q_ = decomp.Q_;
^
../inst/projects/Algebra/include/STK_Qr.h:126:13: note: in instantiation of member function 'STK::IQr<STK::Qr>::operator=' requested here
{ Base::operator=(decomp);
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:84:
In file included from ../inst/projects/Arrays/include/STK_Array2D.h:39:
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:175:44: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'const STK::IArray2D<STK::Array2D<double>>::ColRange' (aka 'const TRange<sizeCols_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((this->rows() == I) && (this->cols() == J)) return this->asDerived();
~~~~~~~~~~~~ ^ ~
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:84:
In file included from ../inst/projects/Arrays/include/STK_Array2D.h:39:
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:180:21: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'const STK::IArray2D<STK::Array2D<double>>::RowRange' (aka 'const TRange<sizeRows_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((this->rows() == I) && (this->cols() == J)) return this->asDerived();
~~~~~~~~~~~~ ^ ~
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:84:
In file included from ../inst/projects/Arrays/include/STK_Array2D.h:39:
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:180:44: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'const STK::IArray2D<STK::Array2D<double>>::ColRange' (aka 'const TRange<sizeCols_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((this->rows() == I) && (this->cols() == J)) return this->asDerived();
~~~~~~~~~~~~ ^ ~
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:74:
In file included from ../inst/projects/Arrays/include/STK_CArray.h:38:
In file included from ../inst/projects/Arrays/include/STK_ICArray.h:43:
In file included from ../inst/projects/Arrays/include/STK_ArrayBase.h:321:
../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:88:56: warning: ISO C++20 considers use of overloaded operator '!=' (with operand types 'const STK::ITContainerBase<STK::CArray<double, 2147483647, 2147483647, true>>::ColRange' (aka 'const TRange<sizeCols_>') and 'const STK::ITContainerBase<STK::CArray<double, 2147483647, 2147483647, true>>::RowRange' (aka 'const TRange<sizeRows_>')) to be ambiguous despite there being a unique best viable function with non-reversed arguments [-Wambiguous-reversed-operator]
if (structure_ == int(Arrays::square_) && rhs.cols() != rhs.rows() )
~~~~~~~~~~ ^ ~~~~~~~~~~
../inst/projects/Arrays/include/STK_CArray.h:212:60: note: in instantiation of function template specialization 'STK::ArrayBase<STK::CArray<double, 2147483647, 2147483647, true>>::assign<STK::CArray<double, 2147483647, 2147483647, true>>' requested here
CArray& operator=(CArray const& rhs) { return LowBase::assign(rhs);}
^
../inst/projects/Algebra/include/STK_ISvd.h:103:10: note: in instantiation of member function 'STK::CArray<double, 2147483647, 2147483647, true>::operator=' requested here
U_ = S.U_; V_ = S.V_; D_ = S.D_;
^
../inst/projects/Algebra/include/STK_lapack_Svd.h:152:13: note: in instantiation of member function 'STK::ISvd<STK::lapack::Svd>::operator=' requested here
Base::operator=(decomp);
^
../inst/projects/STKernel/include/STK_Range.h:138:17: note: candidate function with non-reversed arguments
inline bool operator!=(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguous candidate function with reversed arguments
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:84:
In file included from ../inst/projects/Arrays/include/STK_Array2D.h:39:
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:653:16: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'STK::Range' (aka 'TRange<UnknownSize>') and 'STK::ITContainer1D<STK::Array1D<STK::TRange<UnknownSize>, 2147483647>>::Type' (aka 'STK::TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if (newRange == rangeCols_[col]) { freeCol(col); return;}
~~~~~~~~ ^ ~~~~~~~~~~~~~~~
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:543:48: note: in instantiation of member function 'STK::IArray2D<STK::Array2D<double>>::eraseRowsCol' requested here
for (int j=beginCols(); j<endCols(); j++) { eraseRowsCol(j, pos, n);}
^
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:264:3: note: in instantiation of member function 'STK::IArray2D<STK::Array2D<double>>::eraseRows' requested here
eraseRows(endRows()-n, n);
^
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:192:21: note: in instantiation of member function 'STK::IArray2D<STK::Array2D<double>>::popBackRows' requested here
if (rinc < 0) { popBackRows(-rinc);} // less rows
^
../inst/projects/Arrays/include/assign/STK_AssignSelector.h:199:9: note: in instantiation of member function 'STK::IArray2D<STK::Array2D<double>>::resize' requested here
{ lhs.resize(rhs.rows(), rhs.cols());}
^
../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:91:57: note: in instantiation of member function 'STK::hidden::resizeSelector<STK::Array2D<double>, STK::Array2D<double>, 0>::run' requested here
hidden::resizeSelector<Derived, Rhs, rhs_structure_>::run(this->asDerived(), rhs.asDerived());
^
../inst/projects/Arrays/include/STK_Array2D.h:187:61: note: in instantiation of function template specialization 'STK::ArrayBase<STK::Array2D<double>>::assign<STK::Array2D<double>>' requested here
Array2D& operator=( Array2D const& T) { return LowBase::assign(T);}
^
../inst/projects/Algebra/include/STK_IQr.h:141:10: note: in instantiation of member function 'STK::Array2D<double>::operator=' requested here
Q_ = decomp.Q_;
^
../inst/projects/Algebra/include/STK_Qr.h:126:13: note: in instantiation of member function 'STK::IQr<STK::Qr>::operator=' requested here
{ Base::operator=(decomp);
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:69:
In file included from ../inst/projects/Arrays/include/STK_Array1D.h:38:
In file included from ../inst/projects/Arrays/include/STK_IArray1D.h:47:
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:607:15: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'STK::MemAllocator<STK::Array1D<double, 2147483647> *, 2147483647>::AllocatorRange' (aka 'TRange<2147483647>') and 'const TRange<2147483647>') to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((range_ == I)&&(p_data_)&&(!isRef())) return;
~~~~~~ ^ ~
../inst/projects/Arrays/include/STK_IArray2D.h:987:16: note: in instantiation of function template specialization 'STK::MemAllocator<STK::Array1D<double, 2147483647> *, 2147483647>::realloc<2147483647>' requested here
allocator_.realloc( newRange ); // reallocate memory for the columns
^
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:455:4: note: in instantiation of member function 'STK::IArray2D<STK::Array2D<double>>::reallocCols' requested here
reallocCols(NewRange);
^
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:349:3: note: in instantiation of member function 'STK::IArray2D<STK::Array2D<double>>::insertCols' requested here
insertCols(endCols(), n );
^
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:194:5: note: in instantiation of member function 'STK::IArray2D<STK::Array2D<double>>::pushBackCols' requested here
pushBackCols(cinc); // add columns
^
../inst/projects/Arrays/include/assign/STK_AssignSelector.h:199:9: note: in instantiation of member function 'STK::IArray2D<STK::Array2D<double>>::resize' requested here
{ lhs.resize(rhs.rows(), rhs.cols());}
^
../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:91:57: note: in instantiation of member function 'STK::hidden::resizeSelector<STK::Array2D<double>, STK::Array2D<double>, 0>::run' requested here
hidden::resizeSelector<Derived, Rhs, rhs_structure_>::run(this->asDerived(), rhs.asDerived());
^
../inst/projects/Arrays/include/STK_Array2D.h:187:61: note: in instantiation of function template specialization 'STK::ArrayBase<STK::Array2D<double>>::assign<STK::Array2D<double>>' requested here
Array2D& operator=( Array2D const& T) { return LowBase::assign(T);}
^
../inst/projects/Algebra/include/STK_IQr.h:141:10: note: in instantiation of member function 'STK::Array2D<double>::operator=' requested here
Q_ = decomp.Q_;
^
../inst/projects/Algebra/include/STK_Qr.h:126:13: note: in instantiation of member function 'STK::IQr<STK::Qr>::operator=' requested here
{ Base::operator=(decomp);
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:74:
In file included from ../inst/projects/Arrays/include/STK_CArray.h:38:
In file included from ../inst/projects/Arrays/include/STK_ICArray.h:43:
In file included from ../inst/projects/Arrays/include/STK_ArrayBase.h:321:
../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:88:56: warning: ISO C++20 considers use of overloaded operator '!=' (with operand types 'const STK::ITContainerBase<STK::Array2DUpperTriangular<double>>::ColRange' (aka 'const TRange<sizeCols_>') and 'const STK::ITContainerBase<STK::Array2DUpperTriangular<double>>::RowRange' (aka 'const TRange<sizeRows_>')) to be ambiguous despite there being a unique best viable function with non-reversed arguments [-Wambiguous-reversed-operator]
if (structure_ == int(Arrays::square_) && rhs.cols() != rhs.rows() )
~~~~~~~~~~ ^ ~~~~~~~~~~
../inst/projects/Arrays/include/STK_Array2DUpperTriangular.h:184:23: note: in instantiation of function template specialization 'STK::ArrayBase<STK::Array2DUpperTriangular<double>>::assign<STK::Array2DUpperTriangular<double>>' requested here
{ return LowBase::assign(T);}
^
../inst/projects/Algebra/include/STK_IQr.h:142:10: note: in instantiation of member function 'STK::Array2DUpperTriangular<double>::operator=' requested here
R_ = decomp.R_;
^
../inst/projects/Algebra/include/STK_Qr.h:126:13: note: in instantiation of member function 'STK::IQr<STK::Qr>::operator=' requested here
{ Base::operator=(decomp);
^
../inst/projects/STKernel/include/STK_Range.h:138:17: note: candidate function with non-reversed arguments
inline bool operator!=(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguous candidate function with reversed arguments
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:84:
In file included from ../inst/projects/Arrays/include/STK_Array2D.h:39:
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:175:21: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'const STK::IArray2D<STK::Array2DUpperTriangular<double>>::RowRange' (aka 'const TRange<sizeRows_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((this->rows() == I) && (this->cols() == J)) return this->asDerived();
~~~~~~~~~~~~ ^ ~
../inst/projects/Algebra/include/STK_Qr.h:140:6: note: in instantiation of member function 'STK::IArray2D<STK::Array2DUpperTriangular<double>>::resize' requested here
R_.resize(Q_.rows(), Q_.cols());
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:84:
In file included from ../inst/projects/Arrays/include/STK_Array2D.h:39:
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:175:44: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'const STK::IArray2D<STK::Array2DUpperTriangular<double>>::ColRange' (aka 'const TRange<sizeCols_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((this->rows() == I) && (this->cols() == J)) return this->asDerived();
~~~~~~~~~~~~ ^ ~
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:74:
In file included from ../inst/projects/Arrays/include/STK_CArray.h:38:
In file included from ../inst/projects/Arrays/include/STK_ICArray.h:43:
In file included from ../inst/projects/Arrays/include/STK_ArrayBase.h:321:
../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:88:56: error: use of overloaded operator '!=' is ambiguous (with operand types 'const STK::ITContainerBase<STK::CArrayVector<double, 2147483647, true>>::ColRange' (aka 'const TRange<sizeCols_>') and 'const STK::ITContainerBase<STK::CArrayVector<double, 2147483647, true>>::RowRange' (aka 'const TRange<sizeRows_>'))
if (structure_ == int(Arrays::square_) && rhs.cols() != rhs.rows() )
~~~~~~~~~~ ^ ~~~~~~~~~~
../inst/projects/Arrays/include/STK_CArrayVector.h:195:72: note: in instantiation of function template specialization 'STK::ArrayBase<STK::CArrayVector<double, 2147483647, true>>::assign<STK::CArrayVector<double, 2147483647, true>>' requested here
CArrayVector& operator=(CArrayVector const& rhs) { return LowBase::assign(rhs);}
^
../inst/projects/Algebra/include/STK_ISvd.h:103:33: note: in instantiation of member function 'STK::CArrayVector<double, 2147483647, true>::operator=' requested here
U_ = S.U_; V_ = S.V_; D_ = S.D_;
^
../inst/projects/Algebra/include/STK_lapack_Svd.h:152:13: note: in instantiation of member function 'STK::ISvd<STK::lapack::Svd>::operator=' requested here
Base::operator=(decomp);
^
../inst/projects/STKernel/include/STK_Range.h:138:17: note: candidate function [with OtherSize_ = 2147483647]
inline bool operator!=(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: candidate function [with OtherSize_ = 2147483647]
inline bool operator==(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: candidate function (with reversed parameter order) [with OtherSize_ = 1]
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:84:
In file included from ../inst/projects/Arrays/include/STK_Array2D.h:39:
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:180:21: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'const STK::IArray2D<STK::Array2DUpperTriangular<double>>::RowRange' (aka 'const TRange<sizeRows_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((this->rows() == I) && (this->cols() == J)) return this->asDerived();
~~~~~~~~~~~~ ^ ~
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:84:
In file included from ../inst/projects/Arrays/include/STK_Array2D.h:39:
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:180In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:74:
In file included from ../inst/projects/Arrays/include/STK_CArray.h:38:
In file included from ../inst/projects/Arrays/include/STK_ICArray.h:43:
In file included from ../inst/projects/Arrays/include/STK_ArrayBase.h:321:
In file included from ../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:39:
../inst/projects/Arrays/include/assign/STK_AssignSelector.h:158:27: warning: ISO C++20 considers use of overloaded operator '!=' (with operand types 'const STK::ITContainer<STK::CArrayVector<double, 2147483647, true>, 8>::RowRange' (aka 'const TRange<sizeRows_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function with non-reversed arguments [-Wambiguous-reversed-operator]
:44: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'const STK::IArray2D<STK::Array2DUpperTriangular<double>>::ColRange' (aka 'const TRange<sizeCols_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((this->rows() == I) && (this->cols() == J)) return this->asDerived();
~~~~~~~~~~~~ ^ ~
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
{ return (array.range() != I);}
~~~~~~~~~~~~~ ^ ~
../inst/projects/Arrays/include/STK_ICArray.h:471:53: note: in instantiation of member function 'STK::hidden::CheckShift<STK::CArrayVector<double, 2147483647, true>, 8>::resize' requested here
if (!hidden::CheckShift<Derived, structure_>::resize(this->asDerived(), I)) return this->asDerived();
^
../inst/projects/Arrays/include/assign/STK_AssignSelector.h:220:9: note: in instantiation of function template specialization 'STK::ICArray<STK::CArrayVector<double, 2147483647, true>>::resize<2147483647>' requested here
{ lhs.resize(rhs.range());}
^
../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:91:57: note: in instantiation of member function 'STK::hidden::resizeSelector<STK::CArrayVector<double, 2147483647, true>, STK::CArrayVector<double, 2147483647, true>, 8>::run' requested here
hidden::resizeSelector<Derived, Rhs, rhs_structure_>::run(this->asDerived(), rhs.asDerived());
^
../inst/projects/Arrays/include/STK_CArrayVector.h:195:72: note: in instantiation of function template specialization 'STK::ArrayBase<STK::CArrayVector<double, 2147483647, true>>::assign<STK::CArrayVector<double, 2147483647, true>>' requested here
CArrayVector& operator=(CArrayVector const& rhs) { return LowBase::assign(rhs);}
^
../inst/projects/Algebra/include/STK_ISvd.h:103:33: note: in instantiation of member function 'STK::CArrayVector<double, 2147483647, true>::operator=' requested here
U_ = S.U_; V_ = S.V_; D_ = S.D_;
^
../inst/projects/Algebra/include/STK_lapack_Svd.h:152:13: note: in instantiation of member function 'STK::ISvd<STK::lapack::Svd>::operator=' requested here
Base::operator=(decomp);
^
../inst/projects/STKernel/include/STK_Range.h:138:17: note: candidate function with non-reversed arguments
inline bool operator!=(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguous candidate function with reversed arguments
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:84:
In file included from ../inst/projects/Arrays/include/STK_Array2D.h:39:
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:653:16: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'STK::Range' (aka 'TRange<UnknownSize>') and 'STK::ITContainer1D<STK::Array1D<STK::TRange<UnknownSize>, 2147483647>>::Type' (aka 'STK::TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if (newRange == rangeCols_[col]) { freeCol(col); return;}
~~~~~~~~ ^ ~~~~~~~~~~~~~~~
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:543:48: note: in instantiation of member function 'STK::IArray2D<STK::Array2DUpperTriangular<double>>::eraseRowsCol' requested here
for (int j=beginCols(); j<endCols(); j++) { eraseRowsCol(j, pos, n);}
^
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:264:3: note: in instantiation of member function 'STK::IArray2D<STK::Array2DUpperTriangular<double>>::eraseRows' requested here
eraseRows(endRows()-n, n);
^
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:192:21: note: in instantiation of member function 'STK::IArray2D<STK::Array2DUpperTriangular<double>>::popBackRows' requested here
if (rinc < 0) { popBackRows(-rinc);} // less rows
^
../inst/projects/Algebra/include/STK_Qr.h:140:6: note: in instantiation of member function 'STK::IArray2D<STK::Array2DUpperTriangular<double>>::resize' requested here
R_.resize(Q_.rows(), Q_.cols());
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:162:
In file included from ../inst/include/Algebra.h:68:
../inst/projects/Algebra/include/STK_transpose.h:53:14: warning: ISO C++20 considers use of overloaded operator '!=' (with operand types 'const STK::ITContainerBase<STK::CArray<double, 2147483647, 2147483647, true>>::RowRange' (aka 'const TRange<sizeRows_>') and 'const STK::ITContainerBase<STK::CArray<double, 2147483647, 2147483647, true>>::ColRange' (aka 'const TRange<sizeCols_>')) to be ambiguous despite there being a unique best viable function with non-reversed arguments [-Wambiguous-reversed-operator]
if(A.rows()!=A.cols())
~~~~~~~~^ ~~~~~~~~
../inst/projects/Algebra/include/STK_lapack_Svd.h:196:3: note: in instantiation of function template specialization 'STK::transpose<STK::CArray<double, 2147483647, 2147483647, true>>' requested here
transpose(V_.shift(beginCol));
^
../inst/projects/STKernel/include/STK_Range.h:138:17: note: candidate function with non-reversed arguments
inline bool operator!=(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguous candidate function with reversed arguments
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:69:
In file included from ../inst/projects/Arrays/include/STK_Array1D.h:38:
In file included from ../inst/projects/Arrays/include/STK_IArray1D.h:47:
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:585:15: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'STK::MemAllocator<STK::Array1D<double, 2147483647> *, 1>::AllocatorRange' (aka 'TRange<1>') and 'const TRange<1>') to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((range_ == I)&&(p_data_)&&(!isRef())) return;
~~~~~~ ^ ~
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:484:5: note: in instantiation of function template specialization 'STK::MemAllocator<STK::Array1D<double, 2147483647> *, 1>::malloc<1>' requested here
malloc(I);
^
../inst/projects/Arrays/include/STK_IArray2D.h:824:30: note: in instantiation of function template specialization 'STK::MemAllocator<STK::Array1D<double, 2147483647> *, 1>::MemAllocator<2147483647>' requested here
, allocator_(T.allocator_, J, true) // a reference
^
../inst/projects/Arrays/include/STK_Array2DVector.h:164:20: note: in instantiation of function template specialization 'STK::IArray2D<STK::Array2DVector<double>>::IArray2D<STK::Array2D<double>>' requested here
: Base(T, I, Range(col, 1))
^
../inst/projects/Algebra/include/STK_Qr.h:145:15: note: in instantiation of function template specialization 'STK::Array2DVector<double>::Array2DVector<STK::Array2D<double>>' requested here
ColVector u(Q_, r, j);// get a reference on the j-th column in the range r
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:74:
In file included from ../inst/projects/Arrays/include/STK_CArray.h:38:
In file included from ../inst/projects/Arrays/include/STK_ICArray.h:43:
In file included from ../inst/projects/Arrays/include/STK_ArrayBase.h:321:
../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:88:56: warning: ISO C++20 considers use of overloaded operator '!=' (with operand types 'const STK::ITContainerBase<STK::TransposeAccessor<STK::CArray<double, 2147483647, 2147483647, true>>>::ColRange' (aka 'const TRange<sizeCols_>') and 'const STK::ITContainerBase<STK::TransposeAccessor<STK::CArray<double, 2147483647, 2147483647, true>>>::RowRange' (aka 'const TRange<sizeRows_>')) to be ambiguous despite there being a unique best viable function with non-reversed arguments [-Wambiguous-reversed-operator]
if (structure_ == int(Arrays::square_) && rhs.cols() != rhs.rows() )
~~~~~~~~~~ ^ ~~~~~~~~~~
../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:107:10: note: in instantiation of function template specialization 'STK::ArrayBase<STK::CArray<double, 2147483647, 2147483647, true>>::assign<STK::TransposeAccessor<STK::CArray<double, 2147483647, 2147483647, true>>>' requested here
{ return assign(rhs.asDerived());}
^
../inst/projects/Arrays/include/STK_CArray.h:197:91: note: in instantiation of function template specialization 'STK::ArrayBase<STK::CArray<double, 2147483647, 2147483647, true>>::operator=<STK::TransposeAccessor<STK::CArray<double, 2147483647, 2147483647, true>>>' requested here
CArray( ExprBase<OtherDerived> const& T): Base(T.sizeRows(), T.sizeCols()) { LowBase::operator=(T);}
^
../inst/projects/Algebra/include/STK_transpose.h:55:24: note: in instantiation of function template specialization 'STK::CArray<double, 2147483647, 2147483647, true>::CArray<STK::TransposeAccessor<STK::CArray<double, 2147483647, 2147483647, true>>>' requested here
TContainer2D Aux = A.transpose();
^
../inst/projects/Algebra/include/STK_lapack_Svd.h:196:3: note: in instantiation of function template specialization 'STK::transpose<STK::CArray<double, 2147483647, 2147483647, true>>' requested here
transpose(V_.shift(beginCol));
^
../inst/projects/STKernel/include/STK_Range.h:138:17: note: candidate function with non-reversed arguments
inline bool operator!=(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguous candidate function with reversed arguments
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:74:
In file included from ../inst/projects/Arrays/include/STK_CArray.h:38:
In file included from ../inst/projects/Arrays/include/STK_ICArray.h:43:
In file included from ../inst/projects/Arrays/include/STK_ArrayBase.h:321:
In file included from ../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:39:
../inst/projects/Arrays/include/assign/STK_AssignSelector.h:65:26: warning: ISO C++20 considers use of overloaded operator '!=' (with operand types 'const STK::ITContainerBase<STK::CArray<double, 2147483647, 2147483647, true>>::RowRange' (aka 'const TRange<sizeRows_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function with non-reversed arguments [-Wambiguous-reversed-operator]
{ return (array.rows() != I || array.cols() != J);}
~~~~~~~~~~~~ ^ ~
../inst/projects/Arrays/include/STK_ICArray.h:457:53: note: in instantiation of member function 'STK::hidden::CheckShift<STK::CArray<double, 2147483647, 2147483647, true>, 0>::resize' requested here
if (!hidden::CheckShift<Derived, structure_>::resize(this->asDerived(), I, J)) return this->asDerived();
^
../inst/projects/Algebra/include/STK_lapack_Svd.h:234:7: note: in instantiation of member function 'STK::ICArray<STK::CArray<double, 2147483647, 2147483647, true>>::resize' requested here
u.resize(m, ucol);
^
../inst/projects/STKernel/include/STK_Range.h:138:17: note: candidate function with non-reversed arguments
inline bool operator!=(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguous candidate function with reversed arguments
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:74:
In file included from ../inst/projects/Arrays/include/STK_CArray.h:38:
In file included from ../inst/projects/Arrays/include/STK_ICArray.h:43:
In file included from ../inst/projects/Arrays/include/STK_ArrayBase.h:321:
In file included from ../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:39:
../inst/projects/Arrays/include/assign/STK_AssignSelector.h:65:47: warning: ISO C++20 considers use of overloaded operator '!=' (with operand types 'const STK::ITContainerBase<STK::CArray<double, 2147483647, 2147483647, true>>::ColRange' (aka 'const TRange<sizeCols_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function with non-reversed arguments [-Wambiguous-reversed-operator]
{ return (array.rows() != I || array.cols() != J);}
~~~~~~~~~~~~ ^ ~
../inst/projects/STKernel/include/STK_Range.h:138:17: note: candidate function with non-reversed arguments
inline bool operator!=(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguous candidate function with reversed arguments
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:69:
In file included from ../inst/projects/Arrays/include/STK_Array1D.h:38:
In file included from ../inst/projects/Arrays/include/STK_IArray1D.h:47:
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:585:15: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'STK::MemAllocator<STK::TRange<UnknownSize>, 1>::AllocatorRange' (aka 'TRange<1>') and 'const TRange<1>') to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((range_ == I)&&(p_data_)&&(!isRef())) return;
~~~~~~ ^ ~
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:484:5: note: in instantiation of function template specialization 'STK::MemAllocator<STK::TRange<UnknownSize>, 1>::malloc<1>' requested here
malloc(I);
^
../inst/projects/Arrays/include/STK_IArray1D.h:379:30: note: in instantiation of function template specialization 'STK::MemAllocator<STK::TRange<UnknownSize>, 1>::MemAllocator<2147483647>' requested here
, allocator_(T.allocator(), I, ref)
^
../inst/projects/Arrays/include/STK_Array1D.h:164:14: note: in instantiation of function template specialization 'STK::IArray1D<STK::Array1D<STK::TRange<UnknownSize>, 1>>::IArray1D<STK::Array1D<STK::TRange<UnknownSize>, 2147483647>>' requested here
: Base(T, I, ref) {}
^
../inst/projects/Arrays/include/STK_IArray2D.h:825:30: note: in instantiation of function template specialization 'STK::Array1D<STK::TRange<UnknownSize>, 1>::Array1D<2147483647>' requested here
, rangeCols_(T.rangeCols_, J, false) // have to be created again, in case T is a temporary
^
../inst/projects/Arrays/include/STK_Array2DVector.h:164:20: note: in instantiation of function template specialization 'STK::IArray2D<STK::Array2DVector<double>>::IArray2D<STK::Array2D<double>>' requested here
: Base(T, I, Range(col, 1))
^
../inst/projects/Algebra/include/STK_Qr.h:145:15: note: in instantiation of function template specialization 'STK::Array2DVector<double>::Array2DVector<STK::Array2D<double>>' requested here
ColVector u(Q_, r, j);// get a reference on the j-th column in the range r
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:69:
In file included from ../inst/projects/Arrays/include/STK_Array1D.h:38:
In file included from ../inst/projects/Arrays/include/STK_IArray1D.h:47:
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:585:15: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'STK::MemAllocator<STK::Array1D<double, 2147483647> *, 2147483647>::AllocatorRange' (aka 'TRange<2147483647>') and 'const TRange<2147483647>') to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((range_ == I)&&(p_data_)&&(!isRef())) return;
~~~~~~ ^ ~
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:448:5: note: in instantiation of function template specialization 'STK::MemAllocator<STK::Array1D<double, 2147483647> *, 2147483647>::malloc<2147483647>' requested here
malloc(range());
^
../inst/projects/Arrays/include/STK_IArray2D.h:806:30: note: in instantiation of member function 'STK::MemAllocator<STK::Array1D<double, 2147483647> *, 2147483647>::MemAllocator' requested here
, allocator_(T.allocator_, ref)
^
../inst/projects/Arrays/include/STK_Array2D.h:158:49: note: in instantiation of member function 'STK::IArray2D<STK::Array2D<double>>::IArray2D' requested here
Array2D( Array2D const& T, bool ref=false): Base(T, ref) {}
^
../inst/projects/Algebra/include/STK_IQr.h:113:32: note: in instantiation of member function 'STK::Array2D<double>::Array2D' requested here
: IRunnerBase(), Q_(Q, ref), compq_(false), rank_(0)
^
../inst/projects/Algebra/include/STK_Qr.h:110:53: note: in instantiation of member function 'STK::IQr<STK::Qr>::IQr' requested here
inline Qr( ArrayXX const& A, bool ref = false): Base(A, ref) {}
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:69:
In file included from ../inst/projects/Arrays/include/STK_Array1D.h:38:
In file included from ../inst/projects/Arrays/include/STK_IArray1D.h:47:
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:585:15: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'STK::MemAllocator<STK::TRange<UnknownSize>, 2147483647>::AllocatorRange' (aka 'TRange<2147483647>') and 'const TRange<2147483647>') to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((range_ == I)&&(p_data_)&&(!isRef())) return;
~~~~~~ ^ ~
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:448:5: note: in instantiation of function template specialization 'STK::MemAllocator<STK::TRange<UnknownSize>, 2147483647>::malloc<2147483647>' requested here
malloc(range());
^
../inst/projects/Arrays/include/STK_IArray1D.h:358:30: note: in instantiation of member function 'STK::MemAllocator<STK::TRange<UnknownSize>, 2147483647>::MemAllocator' requested here
, allocator_(T.allocator(), ref)
^
../inst/projects/Arrays/include/STK_Array1D.h:151:50: note: in instantiation of member function 'STK::IArray1D<STK::Array1D<STK::TRange<UnknownSize>, 2147483647>>::IArray1D' requested here
Array1D( Array1D const& T, bool ref =false): Base(T, ref) {}
^
../inst/projects/Arrays/include/STK_IArray2D.h:807:30: note: in instantiation of member function 'STK::Array1D<STK::TRange<UnknownSize>, 2147483647>::Array1D' requested here
, rangeCols_(T.rangeCols_, false) // have to be created again, in case T is a temporary
^
../inst/projects/Arrays/include/STK_Array2D.h:158:49: note: in instantiation of member function 'STK::IArray2D<STK::Array2D<double>>::IArray2D' requested here
Array2D( Array2D const& T, bool ref=false): Base(T, ref) {}
^
../inst/projects/Algebra/include/STK_IQr.h:113:32: note: in instantiation of member function 'STK::Array2D<double>::Array2D' requested here
: IRunnerBase(), Q_(Q, ref), compq_(false), rank_(0)
^
../inst/projects/Algebra/include/STK_Qr.h:110:53: note: in instantiation of member function 'STK::IQr<STK::Qr>::IQr' requested here
inline Qr( ArrayXX const& A, bool ref = false): Base(A, ref) {}
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:69:
In file included from ../inst/projects/Arrays/include/STK_Array1D.h:38:
../inst/projects/Arrays/include/STK_IArray1D.h:413:16: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'const STK::ITContainer1D<STK::Array1D<double, 2147483647>>::RowRange' (aka 'const TRange<size_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ( range() == I) return this->asDerived();
~~~~~~~ ^ ~
../inst/projects/Arrays/include/STK_ITContainer1D.h:245:32: note: in instantiation of member function 'STK::IArray1D<STK::Array1D<double, 2147483647>>::resizeImpl' requested here
{ return this->asDerived().resizeImpl(I);}
^
../inst/projects/Arrays/include/STK_IArray1D.h:614:39: note: in instantiation of member function 'STK::ITContainer1D<STK::Array1D<double, 2147483647>>::resize' requested here
if ( size() != src.size() ) { this->resize(src.range());}
^
../inst/projects/Arrays/include/STK_IArray2D.h:969:7: note: in instantiation of member function 'STK::IArray1D<STK::Array1D<double, 2147483647>>::assign' requested here
dp->assign(*sp);
^
../inst/projects/Arrays/include/STK_IArray2D.h:813:7: note: in instantiation of member function 'STK::IArray2D<STK::Array2D<double>>::copyCol' requested here
{ copyCol(T, j);}
^
../inst/projects/Arrays/include/STK_Array2D.h:158:49: note: in instantiation of member function 'STK::IArray2D<STK::Array2D<double>>::IArray2D' requested here
Array2D( Array2D const& T, bool ref=false): Base(T, ref) {}
^
../inst/projects/Algebra/include/STK_IQr.h:113:32: note: in instantiation of member function 'STK::Array2D<double>::Array2D' requested here
: IRunnerBase(), Q_(Q, ref), compq_(false), rank_(0)
^
../inst/projects/Algebra/include/STK_Qr.h:110:53: note: in instantiation of member function 'STK::IQr<STK::Qr>::IQr' requested here
inline Qr( ArrayXX const& A, bool ref = false): Base(A, ref) {}
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:69:
In file included from ../inst/projects/Arrays/include/STK_Array1D.h:38:
../inst/projects/Arrays/include/STK_IArray1D.h:413:16: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'const STK::ITContainer1D<STK::Array1D<STK::TRange<UnknownSize>, 2147483647>>::RowRange' (aka 'const TRange<size_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ( range() == I) return this->asDerived();
~~~~~~~ ^ ~
../inst/projects/Arrays/include/STK_ITContainer1D.h:245:32: note: in instantiation of member function 'STK::IArray1D<STK::Array1D<STK::TRange<UnknownSize>, 2147483647>>::resizeImpl' requested here
{ return this->asDerived().resizeImpl(I);}
^
../inst/projects/Arrays/include/STK_IArray2D.h:918:16: note: in instantiation of member function 'STK::ITContainer1D<STK::Array1D<STK::TRange<UnknownSize>, 2147483647>>::resize' requested here
rangeCols_.resize(J);
^
../inst/projects/Arrays/include/STK_IArray2D.h:789:3: note: in instantiation of member function 'STK::IArray2D<STK::Array2DUpperTriangular<double>>::mallocCols' requested here
{ mallocCols(this->cols());}
^
../inst/projects/Arrays/include/STK_Array2DUpperTriangular.h:133:31: note: in instantiation of member function 'STK::IArray2D<STK::Array2DUpperTriangular<double>>::IArray2D' requested here
Array2DUpperTriangular(): Base() {}
^
../inst/projects/Algebra/include/STK_IQr.h:112:12: note: in instantiation of member function 'STK::Array2DUpperTriangular<double>::Array2DUpperTriangular' requested here
inline IQr( Array const& Q, bool ref = false)
^
../inst/projects/Algebra/include/STK_Qr.h:110:53: note: in instantiation of member function 'STK::IQr<STK::Qr>::IQr' requested here
inline Qr( ArrayXX const& A, bool ref = false): Base(A, ref) {}
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:69:
In file included from ../inst/projects/Arrays/include/STK_Array1D.h:38:
In file included from ../inst/projects/Arrays/include/STK_IArray1D.h:47:
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:585:15: error: use of overloaded operator '==' is ambiguous (with operand types 'STK::MemAllocator<STK::Array1D<double, 2147483647> *, 1>::AllocatorRange' (aka 'TRange<1>') and 'const TRange<2147483647>')
if ((range_ == I)&&(p_data_)&&(!isRef())) return;
~~~~~~ ^ ~
../inst/projects/Arrays/include/STK_IArray2D.h:914:18: note: in instantiation of function template specialization 'STK::MemAllocator<STK::Array1D<double, 2147483647> *, 1>::malloc<2147483647>' requested here
allocator_.malloc(Range(J.begin(), size)); // allocate memory for the columns
^
../inst/projects/Arrays/include/STK_IArray2D.h:798:4: note: in instantiation of member function 'STK::IArray2D<STK::Array2DVector<double>>::mallocCols' requested here
{ mallocCols(this->cols()); initializeCols(J);}
^
../inst/projects/Arrays/include/STK_Array2DVector.h:133:22: note: in instantiation of member function 'STK::IArray2D<STK::Array2DVector<double>>::IArray2D' requested here
Array2DVector(): Base( Range(), Range(1)) {}
^
../inst/projects/Algebra/include/STK_SymEigen.h:158:28: note: in instantiation of member function 'STK::Array2DVector<double>::Array2DVector' requested here
inline SymEigen<CSquareX>::SymEigen( CSquareX const& data, bool ref)
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: candidate function [with OtherSize_ = 2147483647]
inline bool operator==(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: candidate function (with reversed parameter order) [with OtherSize_ = 1]
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:69:
In file included from ../inst/projects/Arrays/include/STK_Array1D.h:38:
../inst/projects/Arrays/include/STK_IArray1D.h:413:16: error: use of overloaded operator '==' is ambiguous (with operand types 'const STK::ITContainer1D<STK::Array1D<STK::TRange<UnknownSize>, 1>>::RowRange' (aka 'const TRange<size_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>'))
if ( range() == I) return this->asDerived();
~~~~~~~ ^ ~
../inst/projects/Arrays/include/STK_ITContainer1D.h:245:32: note: in instantiation of member function 'STK::IArray1D<STK::Array1D<STK::TRange<UnknownSize>, 1>>::resizeImpl' requested here
{ return this->asDerived().resizeImpl(I);}
^
../inst/projects/Arrays/include/STK_IArray2D.h:918:16: note: in instantiation of member function 'STK::ITContainer1D<STK::Array1D<STK::TRange<UnknownSize>, 1>>::resize' requested here
rangeCols_.resize(J);
^
../inst/projects/Arrays/include/STK_IArray2D.h:798:4: note: in instantiation of member function 'STK::IArray2D<STK::Array2DVector<double>>::mallocCols' requested here
{ mallocCols(this->cols()); initializeCols(J);}
^
../inst/projects/Arrays/include/STK_Array2DVector.h:133:22: note: in instantiation of member function 'STK::IArray2D<STK::Array2DVector<double>>::IArray2D' requested here
Array2DVector(): Base( Range(), Range(1)) {}
^
../inst/projects/Algebra/include/STK_SymEigen.h:158:28: note: in instantiation of member function 'STK::Array2DVector<double>::Array2DVector' requested here
inline SymEigen<CSquareX>::SymEigen( CSquareX const& data, bool ref)
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: candidate function [with OtherSize_ = 2147483647]
inline bool operator==(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: candidate function (with reversed parameter order) [with OtherSize_ = 1]
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:74:
In file included from ../inst/projects/Arrays/include/STK_CArray.h:38:
In file included from ../inst/projects/Arrays/include/STK_ICArray.h:43:
In file included from ../inst/projects/Arrays/include/STK_ArrayBase.h:321:
../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:88:56: warning: ISO C++20 considers use of overloaded operator '!=' (with operand types 'const STK::ITContainerBase<STK::Array2D<double>>::ColRange' (aka 'const TRange<sizeCols_>') and 'const STK::ITContainerBase<STK::Array2D<double>>::RowRange' (aka 'const TRange<sizeRows_>')) to be ambiguous despite there being a unique best viable function with non-reversed arguments [-Wambiguous-reversed-operator]
if (structure_ == int(Arrays::square_) && rhs.cols() != rhs.rows() )
~~~~~~~~~~ ^ ~~~~~~~~~~
../inst/projects/Arrays/include/STK_Array2D.h:187:61: note: in instantiation of function template specialization 'STK::ArrayBase<STK::Array2D<double>>::assign<STK::Array2D<double>>' requested here
Array2D& operator=( Array2D const& T) { return LowBase::assign(T);}
^
../inst/projects/Algebra/include/STK_IQr.h:141:10: note: in instantiation of member function 'STK::Array2D<double>::operator=' requested here
Q_ = decomp.Q_;
^
../inst/projects/Algebra/include/STK_Qr.h:126:13: note: in instantiation of member function 'STK::IQr<STK::Qr>::operator=' requested here
{ Base::operator=(decomp);
^
../inst/projects/STKernel/include/STK_Range.h:138:17: note: candidate function with non-reversed arguments
inline bool operator!=(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguous candidate function with reversed arguments
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:84:
In file included from ../inst/projects/Arrays/include/STK_Array2D.h:39:
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:175:21: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'const STK::IArray2D<STK::Array2D<double>>::RowRange' (aka 'const TRange<sizeRows_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((this->rows() == I) && (this->cols() == J)) return this->asDerived();
~~~~~~~~~~~~ ^ ~
../inst/projects/Arrays/include/assign/STK_AssignSelector.h:199:9: note: in instantiation of member function 'STK::IArray2D<STK::Array2D<double>>::resize' requested here
{ lhs.resize(rhs.rows(), rhs.cols());}
^
../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:91:57: note: in instantiation of member function 'STK::hidden::resizeSelector<STK::Array2D<double>, STK::Array2D<double>, 0>::run' requested here
hidden::resizeSelector<Derived, Rhs, rhs_structure_>::run(this->asDerived(), rhs.asDerived());
^
../inst/projects/Arrays/include/STK_Array2D.h:187:61: note: in instantiation of function template specialization 'STK::ArrayBase<STK::Array2D<double>>::assign<STK::Array2D<double>>' requested here
Array2D& operator=( Array2D const& T) { return LowBase::assign(T);}
^
../inst/projects/Algebra/include/STK_IQr.h:141:10: note: in instantiation of member function 'STK::Array2D<double>::operator=' requested here
Q_ = decomp.Q_;
^
../inst/projects/Algebra/include/STK_Qr.h:126:13: note: in instantiation of member function 'STK::IQr<STK::Qr>::operator=' requested here
{ Base::operator=(decomp);
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:84:
In file included from ../inst/projects/Arrays/include/STK_Array2D.h:39:
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:175:44: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'const STK::IArray2D<STK::Array2D<double>>::ColRange' (aka 'const TRange<sizeCols_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((this->rows() == I) && (this->cols() == J)) return this->asDerived();
~~~~~~~~~~~~ ^ ~
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:84:
In file included from ../inst/projects/Arrays/include/STK_Array2D.h:39:
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:180:21: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'const STK::IArray2D<STK::Array2D<double>>::RowRange' (aka 'const TRange<sizeRows_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((this->rows() == I) && (this->cols() == J)) return this->asDerived();
~~~~~~~~~~~~ ^ ~
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:84:
In file included from ../inst/projects/Arrays/include/STK_Array2D.h:39:
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:180:44: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'const STK::IArray2D<STK::Array2D<double>>::ColRange' (aka 'const TRange<sizeCols_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((this->rows() == I) && (this->cols() == J)) return this->asDerived();
~~~~~~~~~~~~ ^ ~
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:74:
In file included from ../inst/projects/Arrays/include/STK_CArray.h:38:
In file included from ../inst/projects/Arrays/include/STK_ICArray.h:43:
In file included from ../inst/projects/Arrays/include/STK_ArrayBase.h:321:
../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:88:56: warning: ISO C++20 considers use of overloaded operator '!=' (with operand types 'const STK::ITContainerBase<STK::Array2D<double>>::ColRange' (aka 'const TRange<sizeCols_>') and 'const STK::ITContainerBase<STK::Array2D<double>>::RowRange' (aka 'const TRange<sizeRows_>')) to be ambiguous despite there being a unique best viable function with non-reversed arguments [-Wambiguous-reversed-operator]
if (structure_ == int(Arrays::square_) && rhs.cols() != rhs.rows() )
~~~~~~~~~~ ^ ~~~~~~~~~~
../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:107:10: note: in instantiation of function template specialization 'STK::ArrayBase<STK::CArray<double, 2147483647, 2147483647, true>>::assign<STK::Array2D<double>>' requested here
{ return assign(rhs.asDerived());}
^
../inst/projects/Arrays/include/STK_CArray.h:197:91: note: in instantiation of function template specialization 'STK::ArrayBase<STK::CArray<double, 2147483647, 2147483647, true>>::operator=<STK::Array2D<double>>' requested here
CArray( ExprBase<OtherDerived> const& T): Base(T.sizeRows(), T.sizeCols()) { LowBase::operator=(T);}
^
../inst/projects/Algebra/include/STK_lapack_Qr.h:174:16: note: in instantiation of function template specialization 'STK::CArray<double, 2147483647, 2147483647, true>::CArray<STK::Array2D<double>>' requested here
CArrayXX a = Q_;
^
../inst/projects/STKernel/include/STK_Range.h:138:17: note: candidate function with non-reversed arguments
inline bool operator!=(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguous candidate function with reversed arguments
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:84:
In file included from ../inst/projects/Arrays/include/STK_Array2D.h:39:
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:653:16: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'STK::Range' (aka 'TRange<UnknownSize>') and 'STK::ITContainer1D<STK::Array1D<STK::TRange<UnknownSize>, 2147483647>>::Type' (aka 'STK::TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if (newRange == rangeCols_[col]) { freeCol(col); return;}
~~~~~~~~ ^ ~~~~~~~~~~~~~~~
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:543:48: note: in instantiation of member function 'STK::IArray2D<STK::Array2D<double>>::eraseRowsCol' requested here
for (int j=beginCols(); j<endCols(); j++) { eraseRowsCol(j, pos, n);}
^
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:264:3: note: in instantiation of member function 'STK::IArray2D<STK::Array2D<double>>::eraseRows' requested here
eraseRows(endRows()-n, n);
^
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:192:21: note: in instantiation of member function 'STK::IArray2D<STK::Array2D<double>>::popBackRows' requested here
if (rinc < 0) { popBackRows(-rinc);} // less rows
^
../inst/projects/Arrays/include/assign/STK_AssignSelector.h:199:9: note: in instantiation of member function 'STK::IArray2D<STK::Array2D<double>>::resize' requested here
{ lhs.resize(rhs.rows(), rhs.cols());}
^
../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:91:57: note: in instantiation of member function 'STK::hidden::resizeSelector<STK::Array2D<double>, STK::Array2D<double>, 0>::run' requested here
hidden::resizeSelector<Derived, Rhs, rhs_structure_>::run(this->asDerived(), rhs.asDerived());
^
../inst/projects/Arrays/include/STK_Array2D.h:187:61: note: in instantiation of function template specialization 'STK::ArrayBase<STK::Array2D<double>>::assign<STK::Array2D<double>>' requested here
Array2D& operator=( Array2D const& T) { return LowBase::assign(T);}
^
../inst/projects/Algebra/include/STK_IQr.h:141:10: note: in instantiation of member function 'STK::Array2D<double>::operator=' requested here
Q_ = decomp.Q_;
^
../inst/projects/Algebra/include/STK_Qr.h:126:13: note: in instantiation of member function 'STK::IQr<STK::Qr>::operator=' requested here
{ Base::operator=(decomp);
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:69:
In file included from ../inst/projects/Arrays/include/STK_Array1D.h:38:
In file included from ../inst/projects/Arrays/include/STK_IArray1D.h:47:
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:607:15: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'STK::MemAllocator<STK::Array1D<double, 2147483647> *, 2147483647>::AllocatorRange' (aka 'TRange<2147483647>') and 'const TRange<2147483647>') to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((range_ == I)&&(p_data_)&&(!isRef())) return;
~~~~~~ ^ ~
../inst/projects/Arrays/include/STK_IArray2D.h:987:16: note: in instantiation of function template specialization 'STK::MemAllocator<STK::Array1D<double, 2147483647> *, 2147483647>::realloc<2147483647>' requested here
allocator_.realloc( newRange ); // reallocate memory for the columns
^
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:455:4: note: in instantiation of member function 'STK::IArray2D<STK::Array2D<double>>::reallocCols' requested here
reallocCols(NewRange);
^
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:349:3: note: in instantiation of member function 'STK::IArray2D<STK::Array2D<double>>::insertCols' requested here
insertCols(endCols(), n );
^
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:194:5: note: in instantiation of member function 'STK::IArray2D<STK::Array2D<double>>::pushBackCols' requested here
pushBackCols(cinc); // add columns
^
../inst/projects/Arrays/include/assign/STK_AssignSelector.h:199:9: note: in instantiation of member function 'STK::IArray2D<STK::Array2D<double>>::resize' requested here
{ lhs.resize(rhs.rows(), rhs.cols());}
^
../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:91:57: note: in instantiation of member function 'STK::hidden::resizeSelector<STK::Array2D<double>, STK::Array2D<double>, 0>::run' requested here
hidden::resizeSelector<Derived, Rhs, rhs_structure_>::run(this->asDerived(), rhs.asDerived());
^
../inst/projects/Arrays/include/STK_Array2D.h:187:61: note: in instantiation of function template specialization 'STK::ArrayBase<STK::Array2D<double>>::assign<STK::Array2D<double>>' requested here
Array2D& operator=( Array2D const& T) { return LowBase::assign(T);}
^
../inst/projects/Algebra/include/STK_IQr.h:141:10: note: in instantiation of member function 'STK::Array2D<double>::operator=' requested here
Q_ = decomp.Q_;
^
../inst/projects/Algebra/include/STK_Qr.h:126:13: note: in instantiation of member function 'STK::IQr<STK::Qr>::operator=' requested here
{ Base::operator=(decomp);
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:84:
In file included from ../inst/projects/Arrays/include/STK_Array2D.h:39:
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:175:21: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'const STK::IArray2D<STK::Array2DVector<double>>::RowRange' (aka 'const TRange<sizeRows_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((this->rows() == I) && (this->cols() == J)) return this->asDerived();
~~~~~~~~~~~~ ^ ~
../inst/projects/Arrays/include/STK_Array2DVector.h:199:13: note: in instantiation of member function 'STK::IArray2D<STK::Array2DVector<double>>::resize' requested here
{ Base::resize(I, this->cols()); return *this;}
^
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:209:28: note: in instantiation of member function 'STK::Array2DVector<double>::resize1D' requested here
{ return this->asDerived().resize1D(I);}
^
../inst/projects/STatistiK/include/STK_Law_Categorical.h:209:12: note: in instantiation of member function 'STK::IArray2D<STK::Array2DVector<double>>::resize' requested here
cumProb_.resize(prob_.range());
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:84:
In file included from ../inst/projects/Arrays/include/STK_Array2D.h:39:
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:175:44: error: use of overloaded operator '==' is ambiguous (with operand types 'const STK::IArray2D<STK::Array2DVector<double>>::ColRange' (aka 'const TRange<sizeCols_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>'))
if ((this->rows() == I) && (this->cols() == J)) return this->asDerived();
~~~~~~~~~~~~ ^ ~
../inst/projects/STKernel/include/STK_Range.h:131:17: note: candidate function [with OtherSize_ = 2147483647]
inline bool operator==(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: candidate function (with reversed parameter order) [with OtherSize_ = 1]
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:84:
In file included from ../inst/projects/Arrays/include/STK_Array2D.h:39:
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:180:21: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'const STK::IArray2D<STK::Array2DVector<double>>::RowRange' (aka 'const TRange<sizeRows_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((this->rows() == I) && (this->cols() == J)) return this->asDerived();
~~~~~~~~~~~~ ^ ~
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:84:
In file included from ../inst/projects/Arrays/include/STK_Array2D.h:39:
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:180:44: error: use of overloaded operator '==' is ambiguous (with operand types 'const STK::IArray2D<STK::Array2DVector<double>>::ColRange' (aka 'const TRange<sizeCols_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>'))
if ((this->rows() == I) && (this->cols() == J)) return this->asDerived();
~~~~~~~~~~~~ ^ ~
../inst/projects/STKernel/include/STK_Range.h:131:17: note: candidate function [with OtherSize_ = 2147483647]
inline bool operator==(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: candidate function (with reversed parameter order) [with OtherSize_ = 1]
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:74:
In file included from ../inst/projects/Arrays/include/STK_CArray.h:38:
In file included from ../inst/projects/Arrays/include/STK_ICArray.h:43:
In file included from ../inst/projects/Arrays/include/STK_ArrayBase.h:321:
../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:88:56: warning: ISO C++20 considers use of overloaded operator '!=' (with operand types 'const STK::ITContainerBase<STK::Array2DUpperTriangular<double>>::ColRange' (aka 'const TRange<sizeCols_>') and 'const STK::ITContainerBase<STK::Array2DUpperTriangular<double>>::RowRange' (aka 'const TRange<sizeRows_>')) to be ambiguous despite there being a unique best viable function with non-reversed arguments [-Wambiguous-reversed-operator]
if (structure_ == int(Arrays::square_) && rhs.cols() != rhs.rows() )
~~~~~~~~~~ ^ ~~~~~~~~~~
../inst/projects/Arrays/include/STK_Array2DUpperTriangular.h:184:23: note: in instantiation of function template specialization 'STK::ArrayBase<STK::Array2DUpperTriangular<double>>::assign<STK::Array2DUpperTriangular<double>>' requested here
{ return LowBase::assign(T);}
^
../inst/projects/Algebra/include/STK_IQr.h:142:10: note: in instantiation of member function 'STK::Array2DUpperTriangular<double>::operator=' requested here
R_ = decomp.R_;
^
../inst/projects/Algebra/include/STK_Qr.h:126:13: note: in instantiation of member function 'STK::IQr<STK::Qr>::operator=' requested here
{ Base::operator=(decomp);
^
../inst/projects/STKernel/include/STK_Range.h:138:17: note: candidate function with non-reversed arguments
inline bool operator!=(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguous candidate function with reversed arguments
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:84:
In file included from ../inst/projects/Arrays/include/STK_Array2D.h:39:
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:175:21: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'const STK::IArray2D<STK::Array2DUpperTriangular<double>>::RowRange' (aka 'const TRange<sizeRows_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((this->rows() == I) && (this->cols() == J)) return this->asDerived();
~~~~~~~~~~~~ ^ ~
../inst/projects/Algebra/include/STK_Qr.h:140:6: note: in instantiation of member function 'STK::IArray2D<STK::Array2DUpperTriangular<double>>::resize' requested here
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:84:
In file included from ../inst/projects/Arrays/include/STK_Array2D.h:39:
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:653:16: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'STK::Range' (aka 'TRange<UnknownSize>') and 'STK::ITContainer1D<STK::Array1D<STK::TRange<UnknownSize>, 1>>::Type' (aka 'STK::TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if (newRange == rangeCols_[col]) { freeCol(col); return;}
~~~~~~~~ ^ ~~~~~~~~~~~~~~~
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:543:48: note: in instantiation of member function 'STK::IArray2D<STK::Array2DVector<double>>::eraseRowsCol' requested here
for (int j=beginCols(); j<endCols(); j++) { eraseRowsCol(j, pos, n);}
^
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:264:3: note: in instantiation of member function 'STK::IArray2D<STK::Array2DVector<double>>::eraseRows' requested here
eraseRows(endRows()-n, n);
^
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:192:21: note: in instantiation of member function 'STK::IArray2D<STK::Array2DVector<double>>::popBackRows' requested here
if (rinc < 0) { popBackRows(-rinc);} // less rows
^
../inst/projects/Arrays/include/STK_Array2DVector.h:199:13: note: in instantiation of member function 'STK::IArray2D<STK::Array2DVector<double>>::resize' requested here
{ Base::resize(I, this->cols()); return *this;}
^
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:209:28: note: in instantiation of member function 'STK::Array2DVector<double>::resize1D' requested here
{ return this->asDerived().resize1D(I);}
^
../inst/projects/STatistiK/include/STK_Law_Categorical.h:209:12: note: in instantiation of member function 'STK::IArray2D<STK::Array2DVector<double>>::resize' requested here
cumProb_.resize(prob_.range());
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
R_.resize(Q_.rows(), Q_.cols());
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:69:
In file included from ../inst/projects/Arrays/include/STK_Array1D.h:38:
In file included from ../inst/projects/Arrays/include/STK_IArray1D.h:47:
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:607:15: error: use of overloaded operator '==' is ambiguous (with operand types 'STK::MemAllocator<STK::Array1D<double, 2147483647> *, 1>::AllocatorRange' (aka 'TRange<1>') and 'const TRange<2147483647>')
if ((range_ == I)&&(p_data_)&&(!isRef())) return;
~~~~~~ ^ ~
../inst/projects/Arrays/include/STK_IArray2D.h:987:16: note: in instantiation of function template specialization 'STK::MemAllocator<STK::Array1D<double, 2147483647> *, 1>::realloc<2147483647>' requested here
allocator_.realloc( newRange ); // reallocate memory for the columns
^
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:455:4: note: in instantiation of member function 'STK::IArray2D<STK::Array2DVector<double>>::reallocCols' requested here
reallocCols(NewRange);
^
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:349:3: note: in instantiation of member function 'STK::IArray2D<STK::Array2DVector<double>>::insertCols' requested here
insertCols(endCols(), n );
^
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:194:5: note: in instantiation of member function 'STK::IArray2D<STK::Array2DVector<double>>::pushBackCols' requested here
pushBackCols(cinc); // add columns
^
../inst/projects/Arrays/include/STK_Array2DVector.h:199:13: note: in instantiation of member function 'STK::IArray2D<STK::Array2DVector<double>>::resize' requested here
{ Base::resize(I, this->cols()); return *this;}
^
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:209:28: note: in instantiation of member function 'STK::Array2DVector<double>::resize1D' requested here
{ return this->asDerived().resize1D(I);}
^
../inst/projects/STatistiK/include/STK_Law_Categorical.h:209:12: note: in instantiation of member function 'STK::IArray2D<STK::Array2DVector<double>>::resize' requested here
cumProb_.resize(prob_.range());
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: candidate function [with OtherSize_ = 2147483647]
inline bool operator==(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: candidate function (with reversed parameter order) [with OtherSize_ = 1]
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:84:
In file included from ../inst/projects/Arrays/include/STK_Array2D.h:39:
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:175:44: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'const STK::IArray2D<STK::Array2DUpperTriangular<double>>::ColRange' (aka 'const TRange<sizeCols_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((this->rows() == I) && (this->cols() == J)) return this->asDerived();
~~~~~~~~~~~~ ^ ~
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:84:
In file included from ../inst/projects/Arrays/include/STK_Array2D.h:39:
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:180:21: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'const STK::IArray2D<STK::Array2DUpperTriangular<double>>::RowRange' (aka 'const TRange<sizeRows_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((this->rows() == I) && (this->cols() == J)) return this->asDerived();
~~~~~~~~~~~~ ^ ~
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:84:
In file included from ../inst/projects/Arrays/include/STK_Array2D.h:39:
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:180:44: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'const STK::IArray2D<STK::Array2DUpperTriangular<double>>::ColRange' (aka 'const TRange<sizeCols_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((this->rows() == I) && (this->cols() == J)) return this->asDerived();
~~~~~~~~~~~~ ^ ~
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:84:
In file included from ../inst/projects/Arrays/include/STK_Array2D.h:39:
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:653:16: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'STK::Range' (aka 'TRange<UnknownSize>') and 'STK::ITContainer1D<STK::Array1D<STK::TRange<UnknownSize>, 2147483647>>::Type' (aka 'STK::TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if (newRange == rangeCols_[col]) { freeCol(col); return;}
~~~~~~~~ ^ ~~~~~~~~~~~~~~~
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:543:48: note: in instantiation of member function 'STK::IArray2D<STK::Array2DUpperTriangular<double>>::eraseRowsCol' requested here
for (int j=beginCols(); j<endCols(); j++) { eraseRowsCol(j, pos, n);}
^
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:264:3: note: in instantiation of member function 'STK::IArray2D<STK::Array2DUpperTriangular<double>>::eraseRows' requested here
eraseRows(endRows()-n, n);
^
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:192:21: note: in instantiation of member function 'STK::IArray2D<STK::Array2DUpperTriangular<double>>::popBackRows' requested here
if (rinc < 0) { popBackRows(-rinc);} // less rows
^
../inst/projects/Algebra/include/STK_Qr.h:140:6: note: in instantiation of member function 'STK::IArray2D<STK::Array2DUpperTriangular<double>>::resize' requested here
R_.resize(Q_.rows(), Q_.cols());
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from rtkore.cpp:57:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:74:
In file included from ../inst/projects/Arrays/include/STK_CArray.h:38:
In file included from ../inst/projects/Arrays/include/STK_ICArray.h:43:
In file included from ../inst/projects/Arrays/include/STK_ArrayBase.h:321:
In file included from ../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:39:
../inst/projects/Arrays/include/assign/STK_AssignSelector.h:171:27: warning: ISO C++20 considers use of overloaded operator '!=' (with operand types 'const STK::ITContainer<STK::CArrayPoint<double, 2147483647, true>, 9>::ColRange' (aka 'const TRange<sizeCols_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function with non-reversed arguments [-Wambiguous-reversed-operator]
{ return (array.range() != I);}
~~~~~~~~~~~~~ ^ ~
../inst/projects/Arrays/include/STK_ICArray.h:471:53: note: in instantiation of member function 'STK::hidden::CheckShift<STK::CArrayPoint<double, 2147483647, true>, 9>::resize' requested here
if (!hidden::CheckShift<Derived, structure_>::resize(this->asDerived(), I)) return this->asDerived();
^
../inst/projects/StatModels/include/STK_ModelDiagGaussian_muj_sj.h:110:13: note: in instantiation of function template specialization 'STK::ICArray<STK::CArrayPoint<double, 2147483647, true>>::resize<2147483647>' requested here
mu_.resize(range); sigma_.resize(range);
^
../inst/projects/STKernel/include/STK_Range.h:138:17: note: candidate function with non-reversed arguments
inline bool operator!=(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguous candidate function with reversed arguments
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:69:
In file included from ../inst/projects/Arrays/include/STK_Array1D.h:38:
In file included from ../inst/projects/Arrays/include/STK_IArray1D.h:47:
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:585:15: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'STK::MemAllocator<STK::Array1D<double, 2147483647> *, 1>::AllocatorRange' (aka 'TRange<1>') and 'const TRange<1>') to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((range_ == I)&&(p_data_)&&(!isRef())) return;
~~~~~~ ^ ~
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:484:5: note: in instantiation of function template specialization 'STK::MemAllocator<STK::Array1D<double, 2147483647> *, 1>::malloc<1>' requested here
malloc(I);
^
../inst/projects/Arrays/include/STK_IArray2D.h:824:30: note: in instantiation of function template specialization 'STK::MemAllocator<STK::Array1D<double, 2147483647> *, 1>::MemAllocator<2147483647>' requested here
, allocator_(T.allocator_, J, true) // a reference
^
../inst/projects/Arrays/include/STK_Array2DVector.h:164:20: note: in instantiation of function template specialization 'STK::IArray2D<STK::Array2DVector<double>>::IArray2D<STK::Array2D<double>>' requested here
: Base(T, I, Range(col, 1))
^
../inst/projects/Algebra/include/STK_Qr.h:145:15: note: in instantiation of function template specialization 'STK::Array2DVector<double>::Array2DVector<STK::Array2D<double>>' requested here
ColVector u(Q_, r, j);// get a reference on the j-th column in the range r
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:69:
In file included from ../inst/projects/Arrays/include/STK_Array1D.h:38:
In file included from ../inst/projects/Arrays/include/STK_IArray1D.h:47:
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:585:15: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'STK::MemAllocator<STK::TRange<UnknownSize>, 1>::AllocatorRange' (aka 'TRange<1>') and 'const TRange<1>') to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((range_ == I)&&(p_data_)&&(!isRef())) return;
~~~~~~ ^ ~
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:484:5: note: in instantiation of function template specialization 'STK::MemAllocator<STK::TRange<UnknownSize>, 1>::malloc<1>' requested here
malloc(I);
^
../inst/projects/Arrays/include/STK_IArray1D.h:379:30: note: in instantiation of function template specialization 'STK::MemAllocator<STK::TRange<UnknownSize>, 1>::MemAllocator<2147483647>' requested here
, allocator_(T.allocator(), I, ref)
^
../inst/projects/Arrays/include/STK_Array1D.h:164:14: note: in instantiation of function template specialization 'STK::IArray1D<STK::Array1D<STK::TRange<UnknownSize>, 1>>::IArray1D<STK::Array1D<STK::TRange<UnknownSize>, 2147483647>>' requested here
: Base(T, I, ref) {}
^
../inst/projects/Arrays/include/STK_IArray2D.h:825:30: note: in instantiation of function template specialization 'STK::Array1D<STK::TRange<UnknownSize>, 1>::Array1D<2147483647>' requested here
, rangeCols_(T.rangeCols_, J, false) // have to be created again, in case T is a temporary
^
../inst/projects/Arrays/include/STK_Array2DVector.h:164:20: note: in instantiation of function template specialization 'STK::IArray2D<STK::Array2DVector<double>>::IArray2D<STK::Array2D<double>>' requested here
: Base(T, I, Range(col, 1))
^
../inst/projects/Algebra/include/STK_Qr.h:145:15: note: in instantiation of function template specialization 'STK::Array2DVector<double>::Array2DVector<STK::Array2D<double>>' requested here
ColVector u(Q_, r, j);// get a reference on the j-th column in the range r
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:69:
In file included from ../inst/projects/Arrays/include/STK_Array1D.h:38:
In file included from ../inst/projects/Arrays/include/STK_IArray1D.h:47:
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:585:15: error: use of overloaded operator '==' is ambiguous (with operand types 'STK::MemAllocator<STK::Array1D<double, 2147483647> *, 1>::AllocatorRange' (aka 'TRange<1>') and 'const TRange<2147483647>')
if ((range_ == I)&&(p_data_)&&(!isRef())) return;
~~~~~~ ^ ~
../inst/projects/Arrays/include/STK_IArray2D.h:914:18: note: in instantiation of function template specialization 'STK::MemAllocator<STK::Array1D<double, 2147483647> *, 1>::malloc<2147483647>' requested here
allocator_.malloc(Range(J.begin(), size)); // allocate memory for the columns
^
../inst/projects/Arrays/include/STK_IArray2D.h:798:4: note: in instantiation of member function 'STK::IArray2D<STK::Array2DVector<double>>::mallocCols' requested here
{ mallocCols(this->cols()); initializeCols(J);}
^
../inst/projects/Arrays/include/STK_Array2DVector.h:133:22: note: in instantiation of member function 'STK::IArray2D<STK::Array2DVector<double>>::IArray2D' requested here
Array2DVector(): Base( Range(), Range(1)) {}
^
../inst/projects/Algebra/include/STK_SymEigen.h:158:28: note: in instantiation of member function 'STK::Array2DVector<double>::Array2DVector' requested here
inline SymEigen<CSquareX>::SymEigen( CSquareX const& data, bool ref)
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: candidate function [with OtherSize_ = 2147483647]
inline bool operator==(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: candidate function (with reversed parameter order) [with OtherSize_ = 1]
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:69:
In file included from ../inst/projects/Arrays/include/STK_Array1D.h:38:
../inst/projects/Arrays/include/STK_IArray1D.h:413:16: error: use of overloaded operator '==' is ambiguous (with operand types 'const STK::ITContainer1D<STK::Array1D<STK::TRange<UnknownSize>, 1>>::RowRange' (aka 'const TRange<size_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>'))
if ( range() == I) return this->asDerived();
~~~~~~~ ^ ~
../inst/projects/Arrays/include/STK_ITContainer1D.h:245:32: note: in instantiation of member function 'STK::IArray1D<STK::Array1D<STK::TRange<UnknownSize>, 1>>::resizeImpl' requested here
{ return this->asDerived().resizeImpl(I);}
^
../inst/projects/Arrays/include/STK_IArray2D.h:918:16: note: in instantiation of member function 'STK::ITContainer1D<STK::Array1D<STK::TRange<UnknownSize>, 1>>::resize' requested here
rangeCols_.resize(J);
^
../inst/projects/Arrays/include/STK_IArray2D.h:798:4: note: in instantiation of member function 'STK::IArray2D<STK::Array2DVector<double>>::mallocCols' requested here
{ mallocCols(this->cols()); initializeCols(J);}
^
../inst/projects/Arrays/include/STK_Array2DVector.h:133:22: note: in instantiation of member function 'STK::IArray2D<STK::Array2DVector<double>>::IArray2D' requested here
Array2DVector(): Base( Range(), Range(1)) {}
^
../inst/projects/Algebra/include/STK_SymEigen.h:158:28: note: in instantiation of member function 'STK::Array2DVector<double>::Array2DVector' requested here
inline SymEigen<CSquareX>::SymEigen( CSquareX const& data, bool ref)
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: candidate function [with OtherSize_ = 2147483647]
inline bool operator==(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: candidate function (with reversed parameter order) [with OtherSize_ = 1]
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:74:
In file included from ../inst/projects/Arrays/include/STK_CArray.h:38:
In file included from ../inst/projects/Arrays/include/STK_ICArray.h:43:
In file included from ../inst/projects/Arrays/include/STK_ArrayBase.h:321:
../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:88:56: warning: ISO C++20 considers use of overloaded operator '!=' (with operand types 'const STK::ITContainerBase<STK::Array2D<double>>::ColRange' (aka 'const TRange<sizeCols_>') and 'const STK::ITContainerBase<STK::Array2D<double>>::RowRange' (aka 'const TRange<sizeRows_>')) to be ambiguous despite there being a unique best viable function with non-reversed arguments [-Wambiguous-reversed-operator]
if (structure_ == int(Arrays::square_) && rhs.cols() != rhs.rows() )
~~~~~~~~~~ ^ ~~~~~~~~~~
../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:107:10: note: in instantiation of function template specialization 'STK::ArrayBase<STK::CArray<double, 2147483647, 2147483647, true>>::assign<STK::Array2D<double>>' requested here
{ return assign(rhs.asDerived());}
^
../inst/projects/Arrays/include/STK_CArray.h:197:91: note: in instantiation of function template specialization 'STK::ArrayBase<STK::CArray<double, 2147483647, 2147483647, true>>::operator=<STK::Array2D<double>>' requested here
CArray( ExprBase<OtherDerived> const& T): Base(T.sizeRows(), T.sizeCols()) { LowBase::operator=(T);}
^
../inst/projects/Algebra/include/STK_lapack_Qr.h:174:16: note: in instantiation of function template specialization 'STK::CArray<double, 2147483647, 2147483647, true>::CArray<STK::Array2D<double>>' requested here
CArrayXX a = Q_;
^
../inst/projects/STKernel/include/STK_Range.h:138:17: note: candidate function with non-reversed arguments
inline bool operator!=(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguous candidate function with reversed arguments
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:84:
In file included from ../inst/projects/Arrays/include/STK_Array2D.h:39:
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:175:21: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'const STK::IArray2D<STK::Array2DVector<double>>::RowRange' (aka 'const TRange<sizeRows_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((this->rows() == I) && (this->cols() == J)) return this->asDerived();
~~~~~~~~~~~~ ^ ~
../inst/projects/Arrays/include/STK_Array2DVector.h:199:13: note: in instantiation of member function 'STK::IArray2D<STK::Array2DVector<double>>::resize' requested here
{ Base::resize(I, this->cols()); return *this;}
^
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:209:28: note: in instantiation of member function 'STK::Array2DVector<double>::resize1D' requested here
{ return this->asDerived().resize1D(I);}
^
../inst/projects/STatistiK/include/STK_Law_Categorical.h:209:12: note: in instantiation of member function 'STK::IArray2D<STK::Array2DVector<double>>::resize' requested here
cumProb_.resize(prob_.range());
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:84:
In file included from ../inst/projects/Arrays/include/STK_Array2D.h:39:
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:175:44: error: use of overloaded operator '==' is ambiguous (with operand types 'const STK::IArray2D<STK::Array2DVector<double>>::ColRange' (aka 'const TRange<sizeCols_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>'))
if ((this->rows() == I) && (this->cols() == J)) return this->asDerived();
~~~~~~~~~~~~ ^ ~
../inst/projects/STKernel/include/STK_Range.h:131:17: note: candidate function [with OtherSize_ = 2147483647]
inline bool operator==(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: candidate function (with reversed parameter order) [with OtherSize_ = 1]
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:84:
In file included from ../inst/projects/Arrays/include/STK_Array2D.h:39:
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:180:21: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'const STK::IArray2D<STK::Array2DVector<double>>::RowRange' (aka 'const TRange<sizeRows_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if ((this->rows() == I) && (this->cols() == J)) return this->asDerived();
~~~~~~~~~~~~ ^ ~
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:84:
In file included from ../inst/projects/Arrays/include/STK_Array2D.h:39:
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:180:44: error: use of overloaded operator '==' is ambiguous (with operand types 'const STK::IArray2D<STK::Array2DVector<double>>::ColRange' (aka 'const TRange<sizeCols_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>'))
if ((this->rows() == I) && (this->cols() == J)) return this->asDerived();
~~~~~~~~~~~~ ^ ~
../inst/projects/STKernel/include/STK_Range.h:131:17: note: candidate function [with OtherSize_ = 2147483647]
inline bool operator==(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: candidate function (with reversed parameter order) [with OtherSize_ = 1]
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:84:
In file included from ../inst/projects/Arrays/include/STK_Array2D.h:39:
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:653:16: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'STK::Range' (aka 'TRange<UnknownSize>') and 'STK::ITContainer1D<STK::Array1D<STK::TRange<UnknownSize>, 1>>::Type' (aka 'STK::TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
if (newRange == rangeCols_[col]) { freeCol(col); return;}
~~~~~~~~ ^ ~~~~~~~~~~~~~~~
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:543:48: note: in instantiation of member function 'STK::IArray2D<STK::Array2DVector<double>>::eraseRowsCol' requested here
for (int j=beginCols(); j<endCols(); j++) { eraseRowsCol(j, pos, n);}
^
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:264:3: note: in instantiation of member function 'STK::IArray2D<STK::Array2DVector<double>>::eraseRows' requested here
eraseRows(endRows()-n, n);
^
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:192:21: note: in instantiation of member function 'STK::IArray2D<STK::Array2DVector<double>>::popBackRows' requested here
if (rinc < 0) { popBackRows(-rinc);} // less rows
^
../inst/projects/Arrays/include/STK_Array2DVector.h:199:13: note: in instantiation of member function 'STK::IArray2D<STK::Array2DVector<double>>::resize' requested here
{ Base::resize(I, this->cols()); return *this;}
^
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:209:28: note: in instantiation of member function 'STK::Array2DVector<double>::resize1D' requested here
{ return this->asDerived().resize1D(I);}
^
../inst/projects/STatistiK/include/STK_Law_Categorical.h:209:12: note: in instantiation of member function 'STK::IArray2D<STK::Array2DVector<double>>::resize' requested here
cumProb_.resize(prob_.range());
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
inline bool operator==(TRange<OtherSize_> const& I) const
^
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:69:
In file included from ../inst/projects/Arrays/include/STK_Array1D.h:38:
In file included from ../inst/projects/Arrays/include/STK_IArray1D.h:47:
../inst/projects/Arrays/include/allocators/STK_MemAllocator.h:607:15: error: use of overloaded operator '==' is ambiguous (with operand types 'STK::MemAllocator<STK::Array1D<double, 2147483647> *, 1>::AllocatorRange' (aka 'TRange<1>') and 'const TRange<2147483647>')
if ((range_ == I)&&(p_data_)&&(!isRef())) return;
~~~~~~ ^ ~
../inst/projects/Arrays/include/STK_IArray2D.h:987:16: note: in instantiation of function template specialization 'STK::MemAllocator<STK::Array1D<double, 2147483647> *, 1>::realloc<2147483647>' requested here
allocator_.realloc( newRange ); // reallocate memory for the columns
^
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:455:4: note: in instantiation of member function 'STK::IArray2D<STK::Array2DVector<double>>::reallocCols' requested here
reallocCols(NewRange);
^
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:349:3: note: in instantiation of member function 'STK::IArray2D<STK::Array2DVector<double>>::insertCols' requested here
insertCols(endCols(), n );
^
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:194:5: note: in instantiation of member function 'STK::IArray2D<STK::Array2DVector<double>>::pushBackCols' requested here
pushBackCols(cinc); // add columns
^
../inst/projects/Arrays/include/STK_Array2DVector.h:199:13: note: in instantiation of member function 'STK::IArray2D<STK::Array2DVector<double>>::resize' requested here
{ Base::resize(I, this->cols()); return *this;}
^
../inst/projects/Arrays/include/STK_IArray2DModifiers.h:209:28: note: in instantiation of member function 'STK::Array2DVector<double>::resize1D' requested here
{ return this->asDerived().resize1D(I);}
^
../inst/projects/STatistiK/include/STK_Law_Categorical.h:209:12: note: in instantiation of member function 'STK::IArray2D<STK::Array2DVector<double>>::resize' requested here
cumProb_.resize(prob_.range());
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: candidate function [with OtherSize_ = 2147483647]
inline bool operator==(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: candidate function (with reversed parameter order) [with OtherSize_ = 1]
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:74:
In file included from ../inst/projects/Arrays/include/STK_CArray.h:38:
In file included from ../inst/projects/Arrays/include/STK_ICArray.h:43:
In file included from ../inst/projects/Arrays/include/STK_ArrayBase.h:321:
In file included from ../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:39:
../inst/projects/Arrays/include/assign/STK_AssignSelector.h:171:27: warning: ISO C++20 considers use of overloaded operator '!=' (with operand types 'const STK::ITContainer<STK::CArrayPoint<double, 2147483647, true>, 9>::ColRange' (aka 'const TRange<sizeCols_>') and 'const STK::Range' (aka 'const TRange<UnknownSize>')) to be ambiguous despite there being a unique best viable function with non-reversed arguments [-Wambiguous-reversed-operator]
{ return (array.range() != I);}
~~~~~~~~~~~~~ ^ ~
../inst/projects/Arrays/include/STK_ICArray.h:471:53: note: in instantiation of member function 'STK::hidden::CheckShift<STK::CArrayPoint<double, 2147483647, true>, 9>::resize' requested here
if (!hidden::CheckShift<Derived, structure_>::resize(this->asDerived(), I)) return this->asDerived();
^
../inst/projects/StatModels/include/STK_ModelDiagGaussian_muj_sj.h:110:13: note: in instantiation of function template specialization 'STK::ICArray<STK::CArrayPoint<double, 2147483647, true>>::resize<2147483647>' requested here
mu_.resize(range); sigma_.resize(range);
^
../inst/projects/STKernel/include/STK_Range.h:138:17: note: candidate function with non-reversed arguments
inline bool operator!=(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: ambiguous candidate function with reversed arguments
inline bool operator==(TRange<OtherSize_> const& I) const
^
46 warnings and 6 errors generated.
make: *** [rtkore.o] Error 1
make: *** Waiting for unfinished jobs....
In file included from fastRand.cpp:35:
In file included from ../inst/include/RTKpp.h:41:
In file included from ../inst/include/STKpp.h:156:
In file included from ../inst/include/Arrays.h:74:
In file included from ../inst/projects/Arrays/include/STK_CArray.h:38:
In file included from ../inst/projects/Arrays/include/STK_ICArray.h:43:
In file included from ../inst/projects/Arrays/include/STK_ArrayBase.h:321:
../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:88:56: error: use of overloaded operator '!=' is ambiguous (with operand types 'const STK::ITContainerBase<STK::RVector<double>>::ColRange' (aka 'const TRange<sizeCols_>') and 'const STK::ITContainerBase<STK::RVector<double>>::RowRange' (aka 'const TRange<sizeRows_>'))
if (structure_ == int(Arrays::square_) && rhs.cols() != rhs.rows() )
~~~~~~~~~~ ^ ~~~~~~~~~~
../inst/projects/Arrays/include/STK_ArrayBaseAssign.h:107:10: note: in instantiation of function template specialization 'STK::ArrayBase<STK::Array2DVector<double>>::assign<STK::RVector<double>>' requested here
{ return assign(rhs.asDerived());}
^
../inst/projects/Arrays/include/STK_Array2DVector.h:227:72: note: in instantiation of function template specialization 'STK::ArrayBase<STK::Array2DVector<double>>::operator=<STK::RVector<double>>' requested here
Array2DVector& operator=(ExprBase<Rhs> const& T) { return LowBase::operator=(T);}
^
../inst/projects/STatistiK/include/STK_Law_Categorical.h:86:13: note: in instantiation of function template specialization 'STK::Array2DVector<double>::operator=<STK::RVector<double>>' requested here
{ prob_ = prob; computeCumProb();}
^
fastRand.cpp:65:25: note: in instantiation of function template specialization 'STK::Law::Categorical::Categorical<STK::RVector<double>>' requested here
STK::Law::Categorical law(prob);
^
../inst/projects/STKernel/include/STK_Range.h:138:17: note: candidate function [with OtherSize_ = 2147483647]
inline bool operator!=(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: candidate function [with OtherSize_ = 2147483647]
inline bool operator==(TRange<OtherSize_> const& I) const
^
../inst/projects/STKernel/include/STK_Range.h:131:17: note: candidate function (with reversed parameter order) [with OtherSize_ = 1]
46 warnings and 7 errors generated.
make: *** [fastRand.o] Error 1
ERROR: compilation failed for package ‘rtkore’
* removing ‘/Volumes/Builds/packages/big-sur-x86_64/results/4.6/rtkore.Rcheck/rtkore’