- Boost-users - lists.preview.boost.org

Clarification on statechart post_event vs process_event within react()
by John McCabe 10 Jan '22

10 Jan '22

Hi, Apologies if this has already been answered/clarified, but my search of the internet to try to get a definitive answer, at least one I recognised as being definitive, was unsuccessful. Below I have posted some source code, based on the stopwatch example from the tutorial, but using an 'external' object to delegate the actual handling of event stuff to and using the state, rather than simple_state base class, and some other tweaks. This is a cut down version of something that someone I work with has devised, but I just wanted to get a clear answer on whether process_event() should be getting called in cases like this. I think it probably should not since, in the code below, you change state (with a state object's destructor being executed) whilst you're executing that state's react(EvStartStop) function. If someone can confirm this is the correct interpretation that would be very much appreciated. Any questions, feel free to ask (BTW - I'm compiling for C++17) John PS - In case it's of any use, the output from running this code is: ------ Entered Active Entered Stopped Stopped - payload2 m_charValue: a Exited ~Stopped <<<--- This is the bit I don't like the look of because... Entered Running Active - payload2 m_charValue: a <<<--- ... this happens from the forward_event() call payload1 value1: 20 payload1 value2: 200.2 Exited ~Running Entered Stopped Exiting Program Exited ~Stopped Exited ~Active ------ If I swap the //*** comments to the doProcess() lines instead of doPost(), the output seems more sensible ------ Entered Active Entered Stopped Stopped - payload2 m_charValue: a Exited ~Stopped Entered Running Active - payload2 m_charValue: a payload1 value1: 20 payload1 value2: 200.2 Exited ~Running Entered Stopped Exiting Program Exited ~Stopped Exited ~Active ------ ========== code =========== #include <boost/statechart/event.hpp> #include <boost/statechart/state_machine.hpp> #include <boost/statechart/state.hpp> #include <boost/statechart/transition.hpp> #include <boost/statechart/custom_reaction.hpp> #include <boost/mpl/list.hpp> #include <iostream> #include <string> namespace sc = boost::statechart; namespace mpl = boost::mpl; // Forward declare a handler 'class' that's going to have activity delegated to it struct Handler; // Normal example start/stop and reset events struct EvStartStop : sc::event<EvStartStop> {}; struct EvReset : sc::event<EvReset> {}; // A couple of events that carry data with them struct EvPayload1 : sc::event<EvPayload1> { EvPayload1(int value1, double value2) : m_value1 { value1 }, m_value2 { value2 } {}; int m_value1 { 0 }; double m_value2 { 0.0 }; }; struct EvPayload2 : sc::event<EvPayload2> { EvPayload2(const char& charValue) : m_charValue { charValue } {}; char m_charValue { false }; }; // Back to the example bits struct Active; struct StopWatch : sc::state_machine<StopWatch, Active> { typedef sc::transition<EvReset, Active> reactions; // The extra 'handler' stuff void setHandler(Handler* handler) { m_handler = handler; }; Handler* getHandler() const { return m_handler; }; Handler* m_handler { nullptr }; // Used to make post_event() accessible from an external class...seems unpleasant, but... using sc::state_machine<StopWatch, Active>::post_event; }; // The implementation of the Handler class; created with a reference to a StopWatch object struct Handler { Handler(StopWatch& stopWatch) : m_stopWatch { stopWatch } {}; void doPost() { m_stopWatch.post_event(EvStartStop()); } void doProcess() { m_stopWatch.process_event(EvStartStop()); } StopWatch& m_stopWatch; }; struct Stopped; struct Active : sc::state<Active, StopWatch, Stopped> { Active(my_context ctx) : my_base { ctx } { std::cout << "Entered Active" << std::endl; }; ~Active() { std::cout << "Exited ~Active" << std::endl; }; typedef mpl::list<sc::custom_reaction<EvPayload1>, sc::custom_reaction<EvPayload2>, sc::transition<EvReset, Active>> reactions; sc::result react(const EvPayload1& payload1) { std::cout << "payload1 Event NOT HANDLED" << std::endl; return discard_event(); } sc::result react(const EvPayload2& payload2) { std::cout << "Active - payload2 m_charValue: " << payload2.m_charValue << std::endl; return discard_event(); } }; struct Running : sc::state<Running, Active> { Running(my_context ctx) : my_base { ctx } { std::cout << "Entered Running" << std::endl; }; ~Running() { std::cout << "Exited ~Running" << std::endl; }; typedef mpl::list<sc::custom_reaction<EvPayload1>, sc::transition<EvStartStop, Stopped>> reactions; sc::result react(const EvPayload1& payload1) { std::cout << "payload1 value1: " << payload1.m_value1 << std::endl; std::cout << "payload1 value2: " << payload1.m_value2 << std::endl; //***context<StopWatch>().getHandler()->doPost(); context<StopWatch>().getHandler()->doProcess(); return discard_event(); } }; struct Stopped : sc::state<Stopped, Active> { Stopped(my_context ctx) : my_base { ctx } { std::cout << "Entered Stopped" << std::endl; }; ~Stopped() { std::cout << "Exited ~Stopped" << std::endl; }; typedef mpl::list<sc::custom_reaction<EvPayload2>, sc::transition<EvStartStop, Running>> reactions; sc::result react(const EvPayload2& payload2) { std::cout << "Stopped - payload2 m_charValue: " << payload2.m_charValue << std::endl; //***context<StopWatch>().getHandler()->doPost(); context<StopWatch>().getHandler()->doProcess(); return forward_event(); } }; int main() { StopWatch myWatch; Handler myHandler(myWatch); myWatch.setHandler(&myHandler); myWatch.initiate(); myWatch.process_event(EvPayload2 { 'a' }); myWatch.process_event(EvPayload1 { 20, 200.2 }); std::cout << "Exiting Program" << std::endl; return 0; }

1 1

boost.gil build failed with GCC11 and -std=c++20
by Qiang Ren 10 Jan '22

10 Jan '22

Hi, I am on ubuntu 20.04, I have GCC9.4 and 10.3 and 11.1 installed. I found that when set "-std=c++20", with gcc11, boost.gil will failed to build. Here is the simple test cpp to reproduce the issue: #include <sstream> #include <boost/gil.hpp> #include <boost/gil/extension/io/png.hpp> namespace gil = boost::gil; int main() { gil::rgb8_image_t img; std::stringstream buf(std::ios::in | std::ios::out | std::ios::binary); gil::read_and_convert_image(buf, img, gil::png_tag{}); return 0; } the build command is: g++ -o test test_gcc11_gil.cc -std=c++20 -I${THIRD_PARTY}/boost/boost_1_78_0 -L${THIRD_PARTY}/libpng/1.6.37/lib/ -lpng If replaced '-std=c++20' with '-std=c++17', the build would be OK, but with 'c++20', gcc 11 failed with the following errors: In file included from /data/lin/ThirdParty/boost/boost_1_78_0/boost/gil/extension/io/png/read.hpp:13, from /data/lin/ThirdParty/boost/boost_1_78_0/boost/gil/extension/io/png.hpp:11, from test_gcc11_gil.cc:3: /data/lin/ThirdParty/boost/boost_1_78_0/boost/gil/extension/io/png/tags.hpp:576:32: error: expected unqualified-id before ‘)’ token 576 | image_read_info< png_tag >() | ^ /data/lin/ThirdParty/boost/boost_1_78_0/boost/gil/extension/io/png/tags.hpp:711:36: error: expected unqualified-id before ‘)’ token 711 | image_read_settings< png_tag >() | ^ In file included from /data/lin/ThirdParty/boost/boost_1_78_0/boost/gil/extension/io/png/read.hpp:21, from /data/lin/ThirdParty/boost/boost_1_78_0/boost/gil/extension/io/png.hpp:11, from test_gcc11_gil.cc:3: /data/lin/ThirdParty/boost/boost_1_78_0/boost/gil/io/make_reader.hpp: In instantiation of ‘typename boost::gil::get_reader<String, FormatTag, ConversionPolicy>::type boost::gil::make_reader(Device&, const FormatTag&, const ConversionPolicy&, typename std::enable_if<typename boost::mp11::detail::mp_and_impl<boost::mp11::mp_list<boost::gil::detail::is_adaptable_input_device<FormatTag, Device, void>, boost::gil::is_format_tag<FormatTag> >, void>::type::value>::type*) [with Device = std::__cxx11::basic_stringstream<char>; FormatTag = boost::gil::png_tag; ConversionPolicy = boost::gil::detail::read_and_convert<boost::gil::default_color_converter>; typename boost::gil::get_reader<String, FormatTag, ConversionPolicy>::type = boost::gil::reader<boost::gil::detail::istream_device<boost::gil::png_tag>, boost::gil::png_tag, boost::gil::detail::read_and_convert<boost::gil::default_color_converter> >; typename std::enable_if<typename boost::mp11::detail::mp_and_impl<boost::mp11::mp_list<boost::gil::detail::is_adaptable_input_device<FormatTag, Device, void>, boost::gil::is_format_tag<FormatTag> >, void>::type::value>::type = void;typename boost::mp11::detail::mp_and_impl<boost::mp11::mp_list<boost::gil::detail::is_adaptable_input_device<FormatTag, Device, void>, boost::gil::is_format_tag<FormatTag> >, void>::type =std::integral_constant<bool, true>]’: /data/lin/ThirdParty/boost/boost_1_78_0/boost/gil/io/read_and_convert_image.hpp:263:34: required from ‘void boost::gil::read_and_convert_image(Device&, Image&, const FormatTag&, typename std::enable_if<typename boost::mp11::detail::mp_and_impl<boost::mp11::mp_list<boost::gil::detail::is_read_device<FormatTag, Device, void>, boost::gil::is_format_tag<FormatTag> >, void>::type::value>::type*) [with Device = std::__cxx11::basic_stringstream<char>; Image = boost::gil::image<boost::gil::pixel<unsigned char, boost::gil::layout<boost::mp11::mp_list<boost::gil::red_t, boost::gil::green_t, boost::gil::blue_t> > >, false, std::allocator<unsigned char> >; FormatTag = boost::gil::png_tag; typename std::enable_if<typename boost::mp11::detail::mp_and_impl<boost::mp11::mp_list<boost::gil::detail::is_read_device<FormatTag, Device, void>, boost::gil::is_format_tag<FormatTag> >, void>::type::value>::type = void; typename boost::mp11::detail::mp_and_impl<boost::mp11::mp_list<boost::gil::detail::is_read_device<FormatTag, Device, void>, boost::gil::is_format_tag<FormatTag> >, void>::type = std::integral_constant<bool, true>]’ test_gcc11_gil.cc:11:30: required from here /data/lin/ThirdParty/boost/boost_1_78_0/boost/gil/io/make_reader.hpp:193:30: error: no matching function for call to ‘boost::gil::image_read_settings<boost::gil::png_tag>::image_read_settings()’ 193 | return make_reader(file, image_read_settings<FormatTag>(), cc); | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ In file included from /data/lin/ThirdParty/boost/boost_1_78_0/boost/gil/extension/io/png/read.hpp:13, from /data/lin/ThirdParty/boost/boost_1_78_0/boost/gil/extension/io/png.hpp:11, from test_gcc11_gil.cc:3: /data/lin/ThirdParty/boost/boost_1_78_0/boost/gil/extension/io/png/tags.hpp:718:5: note: candidate: ‘boost::gil::image_read_settings<boost::gil::png_tag>::image_read_settings(const point_t&, const point_t&)’ 718 | image_read_settings( const point_t& top_left | ^~~~~~~~~~~~~~~~~~~ /data/lin/ThirdParty/boost/boost_1_78_0/boost/gil/extension/io/png/tags.hpp:718:5: note: candidate expects 2 arguments, 0 provided /data/lin/ThirdParty/boost/boost_1_78_0/boost/gil/extension/io/png/tags.hpp:707:8: note: candidate: ‘constexpr boost::gil::image_read_settings<boost::gil::png_tag>::image_read_settings(const boost::gil::image_read_settings<boost::gil::png_tag>&)’ 707 | struct image_read_settings< png_tag > : public image_read_settings_base | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ /data/lin/ThirdParty/boost/boost_1_78_0/boost/gil/extension/io/png/tags.hpp:707:8: note: candidate expects 1 argument, 0 provided /data/lin/ThirdParty/boost/boost_1_78_0/boost/gil/extension/io/png/tags.hpp:707:8: note: candidate: ‘constexpr boost::gil::image_read_settings<boost::gil::png_tag>::image_read_settings(boost::gil::image_read_settings<boost::gil::png_tag>&&)’ /data/lin/ThirdParty/boost/boost_1_78_0/boost/gil/extension/io/png/tags.hpp:707:8: note: candidate expects 1 argument, 0 provided Only gcc 11 will fail with '-std=c++20', gcc9 and gcc 10 worked fine. I guess that gcc11 has implemented more c++20 features than gcc9 and gcc10. Since the boost project updates more quickly than gcc, I hope this issue might be fixed in the next boost version. Thanks, Qiang Ren

2 2

Dimension conversion for free?
by KL 08 Jan '22

08 Jan '22

1 0

TypeTraits
by Gero Peterhoff 27 Dec '21

27 Dec '21

Hello John, Some time ago I asked whether further type traits would be included in boost. Unfortunately that somehow fizzled out. Because based on this, many useful functions and classes can first be defined that behave correctly. But the problems are much deeper and I would like to show a solution here. 1) For some types there are feature-tesing-macros (e.g. __cpp_char8_t, __cpp_unicode_characters), but not for most. So this is incomplete. So we need this (plus the __cpp_lib-macros): - __cpp_char8/16/32_t, __cpp charw_t, __cpp_char_t - __cpp_int8/16/32/64/128_t - __cpp_float16/32/64/80/128_t, __cpp_float16b_t - __cpp_bool_t 2) Building on this, we can then query, e.g. struct has_float80: bool_constant < #if defined (__cpp_float80_t) true #else false #endif > {}; template <typename Type> struct is_float80: bool_constant < #if defined (__cpp_float80_t) is_same_v<Type, float80> #else false #endif > {}; This has to be done for all types. 3) Then we can further classify; plus is_X_v and concepts: character: template <typename Type> struct is_character: bool_constant < #if defined (__cpp_char32_t) is_same_v<Type, char32_t> || #elif defined (__cpp_char16_t) is_same_v<Type, char16_t> || #elif defined (__cpp_char8_t) is_same_v<Type, char8_t> || #elif defined (__cpp_charw_t) is_same_v<Type, wchar_t> || #endif is_same_v<Type, char> > {}; template <typename Type> struct is_unsigned_character: bool_constant < is_unsigned_v<Type> && character_v<Type> > {}; template <typename Type> is_signed_character: bool_constant < is_signed_v<Type> && character_v<Type> > {}; float: template <typename Type> struct is_floating_point: bool_constant < #if defined (__cpp_float128_t) is_same_v<Type, float128_t> || #elif defined (__cpp_float80_t) is_same_v<Type, float80_t> || #elif defined (__cpp_float64_t) is_same_v<Type, float64_t> || #elif defined (__cpp_float32_t) is_same_v<Type, float32_t> || #elif defined (__cpp_float16b_t) is_same_v<Type, float16b_t> || #elif defined (__cpp_float16_t) is_same_v<Type, float16_t> || #endif false > {}; integer: template <typename Type> struct is_unsigned_integer: bool_constant < #if defined (__cpp_int128_t) is_same_v<Type, uint128_t> || #elif defined (__cpp_int64_t) is_same_v<Type, uint64_t> || #elif defined (__cpp_int32_t) is_same_v<Type, uint32_t> || #elif defined (__cpp_int16_t) is_same_v<Type, uint16_t> || #elif defined (__cpp_int8_t) is_same_v<Type, uint8_t> || #endif false > {}; template <typename Type> struct is_signed_integer: bool_constant < #if defined (__cpp_int128_t) is_same_v<Type, int128_t> || #elif defined (__cpp_int64_t) is_same_v<Type, int64_t> || #elif defined (__cpp_int32_t) is_same_v<Type, int32_t> || #elif defined (__cpp_int16_t) is_same_v<Type, int16_t> || #elif defined (__cpp_int8_t) is_same_v<Type, int8_t> || #endif false > {}; template <typename Type> struct is_integer: bool_constant < is_unsigned_integer_v<Type> || is_signed_integer_v<Type> > {}; logic: template <typename Type> struct is_logic: bool_constant < is_same_v<Type, bool> > {}; With that we would have created the basics to be able to continue working properly at all. 4) 3 more steps to make things easier #define bitsof(ARG) (size_t(sizeof(ARG) * CHAR_BIT)) Like std::numbers with std::strings with various constantans namespace strings { constexpr static auto empty = ""; constexpr static auto nullptr = "nullptr"; constexpr static auto Void = "void"; constexpr static auto True = "true"; constexpr static auto False = "false"; constexpr static auto indeterminate = "indeterminate"; constexpr static auto overdeterminate = "overdeterminate"; constexpr static auto underdeterminate = "underdeterminate"; constexpr static auto bin = "bin"; constexpr static auto oct = "oct"; constexpr static auto dec = "dec"; constexpr static auto hex = "hex"; constexpr static auto literal_bin = "0b"; constexpr static auto literal_oct = "0o"; constexpr static auto literal_dec = "0d"; constexpr static auto literal_hex = "0x"; } and more and for streams so that you don't have to fumble with the flags namespace detail { using format_flags_t = typename std::ios_base::fmtflags; static inline constexpr format_flags_t defaultfloat = format_flags_t{}, hexfloat = std::ios_base::fixed | std::ios_base::scientific; inline format_flags_t get_flags (const std::ios_base & stream, const format_flags_t & fieldmask) noexcept { return stream.flags () & fieldmask; } } // detail inline bool is_boolalpha (const std::ios_base & stream) noexcept {return (stream.flags () & stream.boolalpha) == stream.boolalpha; } inline bool is_showbase (const std::ios_base & stream) noexcept {return (stream.flags () & stream.showbase) == stream.showbase; } inline bool is_showpoint (const std::ios_base & stream) noexcept {return (stream.flags () & stream.showpoint) == stream.showpoint; } inline bool is_skip (const std::ios_base & stream) noexcept {return (stream.flags () & stream.skipws) == stream.skipws; } inline bool is_uppercase (const std::ios_base & stream) noexcept {return (stream.flags () & stream.uppercase) == stream.uppercase; } inline bool is_lowercase (const std::ios_base & stream) noexcept {return! is_uppercase (stream); } inline bool is_float_bin (const std::ios_base & stream) noexcept {return false; } inline bool is_float_hex (const std::ios_base & stream) noexcept {return detail::get_flags (stream, stream.floatfield) == detail::hexfloat; } inline bool is_float_fixed (const std::ios_base & stream) noexcept {return detail::get_flags (stream, stream.floatfield) == stream.fixed; } inline bool is_float_default (const std::ios_base & stream) noexcept {return detail::get_flags (stream, stream.floatfield) == detail::defaultfloat; } inline bool is_float_scientific (const std::ios_base & stream) noexcept {return detail::get_flags (stream, stream.floatfield) == stream.scientific; } inline bool is_integer_bin (const std::ios_base & stream) noexcept {return false; } inline bool is_integer_oct (const std::ios_base & stream) noexcept {return detail::get_flags (stream, stream.basefield) == stream.oct; } inline bool is_integer_dec (const std::ios_base & stream) noexcept {return detail::get_flags (stream, stream.basefield) == stream.dec; } inline bool is_integer_hex (const std::ios_base & stream) noexcept {return detail::get_flags (stream, stream.basefield) == stream.hex; } 5) And now we can finally get correctly working functions, e.g. template <integer Type, unsigned_integer Bits> inline constexpr Type shl(const Type& arg, const Bits& bits) noexcept { using unsigned_type = make_unsigned_t<Type>; const type res {Type(arg << unsigned_type(bits))}; return (bits < bitsof(Type)) ? res : Type{0}; } template <integer Type, unsigned_integer Bits> inline constexpr Type shr(const Type& arg, const Bits& bits) noexcept { using unsigned_type = make_unsigned_t<Type>; const type ovl {is_signed_integer_v<Type> ? ((arg < Type{0})? Type(-1) : Type{0}) : Type{0}}, res {Type(arg >> unsigned_type(bits))}; return (bits < bitsof(Type)) ? res : ovl; } and classes, e.g. constexpr bool2/3/4 with template <> struct is_logic<bool4>: true_type {}; template <> struct is_logic<bool3>: true_type {}; template <> struct is_logic<bool2>: true_type {}; (I am happy to send it to you, because boost::tribool does not meet the requirements). PS: I could have used the days multi-array/multi-index; but that's done because all of these libs are not constexpr. Will these be updated again? thx Gero

1 0

Boost geometry: 3d difference and union?
by KL 13 Dec '21

13 Dec '21

2 1

Question on boost shared memory allocators
by Da Xu 08 Dec '21

08 Dec '21

Hi folks, got a couple of questions about using shared memory allocators. Please see below. I have the following code template <typename T> using CAP_Alloc = cached_adaptive_pool<T, segment_manager_t>; using CAP_Shmem_String = basic_string<char, std::char_traits<char>, CAP_Alloc<char> >; using CAP_Shmem_String_Alloc = CAP_Alloc<CAP_Shmem_String>; using CAP_Shmem_Void_Alloc = CAP_Alloc<void>; class MyDataBlock{ using pointer = CAP_Shmem_String_Alloc::pointer; pointer strData; float extraData; MyDataBlock(): strData(nullptr), extraData(0.0) {} MyDataBlock(const CAP_Shmem_Void_Alloc& alloc) { /* My question is how do I convert CAP_Shmem_Void_Alloc to type CAP_Shmem_String_Alloc to call allocate? And do I pass in the void allocator as a construction argument? Is there a difference between allocate and construct? */ } ~MyDataBlock() { /* To delete the memory, do I need to keep around a copy of the original allocator, so I can call deallocate or destroy? Or can that be derived or converted from somewhere, like calling strData->alloc() ? */ } } Any help would be greatly appreciated. Thank you.

1 0

[release] Boost 1.78.0
by Marshall Clow 08 Dec '21

08 Dec '21

Release 1.78.0 of the Boost C++ Libraries is now available. These open-source libraries work well with the C++ Standard Library, and are usable across a broad spectrum of applications. The Boost license encourages both commercial and non-commercial use. This release contains numerous enhancements and bug fixes for existing libraries. For details, including download links, see <http://www.boost.org/users/news/version_1.78.0> You can also download directly from: <https://boostorg.jfrog.io/artifactory/main/release/1.78.0/> To install this release on your system, see <http://www.boost.org/doc/libs/release/more/getting_started/index.html> Thanks to everyone who participated in this release. Thanks, -- The Boost Release Team Marshall Clow, Michael Caisse, Glen Fernandes

1 0

[release] Boost 1.78.0 Release Candidate 1
by Marshall Clow 03 Dec '21

03 Dec '21

The first release candidates for the 1.78.0 release are now available at: <https://boostorg.jfrog.io/artifactory/main/release/1.78.0/source/> The SHA256 checksums are as follows: 94ced8b72956591c4775ae2207a9763d3600b30d9d7446562c552f0a14a63be7 boost_1_78_0_rc1.tar.gz f22143b5528e081123c3c5ed437e92f648fe69748e95fa6e2bd41484e2986cc3 boost_1_78_0_rc1.zip 090cefea470bca990fa3f3ed793d865389426915b37a2a3258524a7258f0790c boost_1_78_0_rc1.7z 8681f175d4bdb26c52222665793eef08490d7758529330f98d3b29dd0735bccc boost_1_78_0_rc1.tar.bz2 As always, the release managers would appreciate it if you download the candidate of your choice and give building it a try. Please report both success and failure, and anything else that is noteworthy. -- The Release managers

3 3

[Graph] Occasional crash when removing a vertex
by Anne van de Graaf 29 Nov '21

29 Nov '21

Hello all, When I remove a vertex from a graph, I occasionally experience a crash (on a system running Red Hat Enterprise Linux 8.5). I have been able to replicate the behavior with the following test program: #include <boost/graph/adjacency_list.hpp> int main() { using MyGraph = boost::adjacency_list<boost::setS, boost::vecS, boost::undirectedS>; using MyVertexDescriptor = boost::graph_traits<MyGraph>::vertex_descriptor; using MyVertexDescriptorVec = std::vector<MyVertexDescriptor>; MyGraph g; MyVertexDescriptorVec vertices{ boost::add_vertex( g ), boost::add_vertex( g ), boost::add_vertex( g ) }; boost::add_edge( vertices[0], vertices[1], g ); boost::add_edge( vertices[1], vertices[2], g ); boost::clear_vertex( vertices[0], g ); boost::remove_vertex( vertices[0], g ); return 0; } Also on a Windows platform, I observe similar behavior. When I build the above code with Microsoft Visual Studio 2019 (MSVC 14.27.29110) and run it with a debugger, a debug assertion is triggered ("cannot increment value-initialized map/set iterator"). In both cases (on Linux and Windows platforms), the debugger reveals that the problem is at line 2071 of boost/graph/detail/adjacency_list.hpp. For clarity, I have copied the involved template function below: template < class EdgeList, class vertex_descriptor > inline void reindex_edge_list( EdgeList& el, vertex_descriptor u, boost::disallow_parallel_edge_tag) { for (typename EdgeList::iterator ei = el.begin(); ei != el.end(); ++ei) // line 2071: increment operator fails { if (ei->get_target() > u) { typename EdgeList::value_type ce = *ei; el.erase(ce); --ce.get_target(); el.insert(ce); } } } While I was searching for a proper place to post my question, I found the following issue at GitHub (which was opened on July 1 of this year): https://github.com/boostorg/graph/issues/268. This appears to be the exact same issue. So last week, I added a comment saying that I am facing the exact same problem. Unfortunately, so far no one has responded yet. To me, it seems that the problem is well-understood. Also, some have proposed a bug fix to resolve the issue (including a pull request). Nevertheless, no progress has been made over the past months. So I was just wondering what is the best way to proceed if we want to fix the issue in Boost itself? Is there anything that I can do (apart from starting this thread) to help in resolving the issue? Any feedback is greatly appreciated. Kind regards, Anne van de Graaf

1 0

assigning a "float128" variable with a regular "double" variable
by Jacques Mequin 27 Nov '21

27 Nov '21

I am a fresh new user ( I need to extend some EIGEN library feature by using your float128 ) How to assign a "float128" variable with a regular "double" variable ? With my source code in attachement double double_pi = 3.141592653589793 ; float128 float128_pi = 3.141592653589793Q ; produces the output that looks fine to me double_pi = 3.141592653589793e+00 float128_pi = 3.141592653589793000000000000000000e+00 but thestatement float128_pi = double_pi ; produces float128_pi = 3.141592653589793115997963468544185e+00 How to get 3.141592653589793000000000000000000e+00 also from an assigment ??? What am I doing wrong ? Thanks for any help Regards, Jacques

2 2