{5} Assigned, Active Tickets by Owner (Full Description) (203 matches)

List tickets assigned, group by ticket owner. This report demonstrates the use of full-row display.

Results (1 - 100 of 203)

1 2 3 →

acharles (3 matches)

Ticket Summary Component Milestone Type Created
Description
#2628 Sequence concept incorrectly fails for basic_string concept_check Boost 1.56.0 Bugs Jan 1, 2009

The Sequence concept fails when tested against basic_string (e.g. BOOST_CONCEPT_ASSERT((Sequence<T>)); ) because an extra constructor test is included. This test is for X a(n) where n is the size of the sequence to be created. However, section 23.1.1 table 67 of the C++ standard does not include this test in the definition of the Sequence concept. Because this test is in place, basic_string is rejected by the current implementation of the Sequence concept, since basic_string does not have this constructor. However, section 21.3 paragraph 2 of the C++ standard states, "The class template basic_string conforms to the requirements of a Sequence, as specified in (23.1.1)."

The fix for this should be as simple as removing the test for a constructor of the form X a(n) in the Sequence concept implementation.

#7729 concept_def.hpp multiple inclusion prevention macro bug graph Boost 1.56.0 Bugs Nov 23, 2012

In boost/concept/detail/concept_def.hpp, the BOOST_CONCEPT_DETAIL_CONCEPT_DEF_DWA200651_HPP macro does not apply to the whole include file (search for its pending endif).

As a consequence, the following warning appearing e.g. when including boost/graph/adjacency_list.hpp: 

"BOOST_concept" redefined
[...]
#9939 Patch to add "no exceptions" support to dynamic_bitset dynamic_bitset Boost 1.56.0 Patches Apr 22, 2014

This patch adds support for compiling with exceptions disabled by using BOOST_TRY/BOOST_CATCH etc.

Aleksey Gurtovoy (3 matches)

#1215 Boost 1.34.1, mpl: Wrong workaround detection using MinGW32 (or.hpp, line #33) mpl To Be Determined Bugs Aug 26, 2007

#if defined(_MSC_VER) is not the right thing for MinGW because _MSC_VER is defined but the compiler is still from GNUs Compiler Collection. But i am not sure about the MinGW support in general.

Regard, Hans.

#1549 Boost.MPL: 'index_of' algorithm is not documented mpl Boost 1.36.0 Bugs Jan 4, 2008
#2041 MPL: more comprehensive test coverage for "fail" situations requiring diagnostics mpl Boost 1.36.0 Bugs Jun 23, 2008

See ​http://thread.gmane.org/gmane.comp.lib.boost.user/36876

Andreas Huber (4 matches)

#4064 std::bad_cast should be thrown with BOOST_THROW_EXCEPTION statechart Boost 1.46.0 Bugs Apr 4, 2010

Also, other try/catch/throw statements should be put into appropriate #ifndef blocks.

Reported by Thomas Mathys.

#6894 Highlight context forwarding in async state machine docs statechart To Be Determined Bugs May 13, 2012

(as reported by Sebastian Hoffmann)

#4063 Add debugging support statechart Boost 1.47.0 Feature Requests Apr 4, 2010

See <​http://thread.gmane.org/gmane.comp.lib.boost.user/52305>

#4062 Write a FAQ item on why state constructors do not have access to event data statechart Boost 1.46.0 Tasks Apr 4, 2010

The following techniques should be mentioned:

  • transition actions & store data in an outer state
  • repost in transition action & react in an in-state reaction
  • triggering_event

Artyom Beilis (4 matches)

#9827 Missing support for some code page(e.g 949, 950) in windows conversion with std backend locale To Be Determined Bugs Apr 2, 2014

There is a table windows_encoding all_windows_encodings[] in wconv_codepage.ipp. It contains several code page definitions. However, it misses some code pages, such as the Korean code page(949) or Traditional Chinese Big5 code page(950), which will cause an invalid_charset_error when running in that windows for the following code: 

// Assuming we are using the std backend so it supports ansi encodings
boost::locale::generator gen;
gen.use_ansi_encoding(true);

std::locale loc(gen(""));
// Throws invalid_charset_error when running in Korean windows but OK in English windows.
// The charset is "windows949" in Korean windows, which is not in the table.
std::string us = boost::locale::conv::to_utf<char>("abcdefg", loc);

The root cause of this exception is that the generated code page string is not in the table. When the locale generator with std backend in windows platform generates a locale, it calls boost::locale::util::get_system_locale(bool use_utf8). This function will use the following code to generate the locale string(in default_locale.cpp): 

if(GetLocaleInfoA(LOCALE_USER_DEFAULT,LOCALE_IDEFAULTANSICODEPAGE,buf,sizeof(buf))!=0) {
    if(atoi(buf)==0)
        lc_name+=".UTF-8";
    else {
        lc_name +=".windows-";
        lc_name +=buf;
    }
}

So the encoding part of the lc_name is windows-(code page). In a system with Korean(949) or Traditional Chinese(950) code page, this will generate an encoding string like "windows-949" or "windows-950". However, when wconv_from_utf::open() initializes, it tries to search "windows949" or "windows950" in array all_windows_encodings[]. Obviously it will not find the string, and the open() fails, then the exception is thrown.

For a quick fix, I suggest adding the missing code page to the table: 

{ "cp949",      949, 0 }, // Korean
{ "uhc",        949, 0 }, // From "iconv -l"
{ "windows949",         949, 0 }, // Korean
// "big5" already in the table
{ "windows950",         950, 0 }, // TC, big5

However the list may not be complete, and we may encounter problems when running in a system with code page that does not exist in the list. So we may probably add the following code to function int encoding_to_windows_codepage(char const *ccharset) in wconv_codepage.ipp: 

--- E:\Build1\boost_1_55_0\libs\locale\src\encoding\wconv_codepage.ipp	2014-04-02 16:34:52.000000000 +0800
+++ E:\Build2\boost_1_55_0\libs\locale\src\encoding\wconv_codepage.ipp	2014-04-02 17:31:37.000000000 +0800
@@ -206,12 +206,18 @@
                 return ptr->codepage;
             }
             else {
                 return -1;
             }
         }
+        if(ptr==end && charset.size()>7 && charset.substr(0,7)=="windows") {
+            int cp = atoi(charset.substr(7).c_str());
+            if(IsValidCodePage(cp)) {
+                return cp;
+            }
+        }
         return -1;
         
     }
 
     template<typename CharType>
     bool validate_utf16(CharType const *str,unsigned len)

This piece of code directly parses and validates the encoding string. The concern is that the call to IsValidCodePage may decrease the performance(not tested).

#11848 Win32 backend bug when do wide char convert to multi byte in boost::locale locale To Be Determined Bugs Dec 16, 2015

The function wide_to_multibyte_non_zero in locale/src/encoding/wconv_codepage.ipp has bug. This function assume that when the codepage is CP_UTF7 or CP_UTF8, the substitute_ptr and subst_char_ptr will be 0. But, in x64 Windows 10, I use codepage 54936 get 87 error code after the first WideCharToMultiByte called. This will make n is zero, and the second WideCharToMultiByte call will make the program crash.

In MSDN shipped with Visual Studio .NET 2003 it is said that parameters lpDefaultChar and lpUsedDefaultChar must be NULL not only for CP_UTF7 and CP_UTF8, but also for all codepages mentioned in notes for dwFlags parameter:

50220 50221 50222 50225 50227 50229 57002 through 57011 65000 (UTF-7) 42 (Symbol)

It is still true as of Windows 8 & 10: if you try to call

BOOL bVal = FALSE;

WideCharToMultiByte(50220, 0, L"asdf", 4, NULL, 0, NULL, &bVal);

You'll get 0 with GetLastError 87 (ERROR_INVALID_PARAMETER).

#9685 Boost.Locale does not link against static ICU on Windows locale To Be Determined Feature Requests Feb 19, 2014

There seems to be no support for linking against the static ICU libraries (sicuXX.lib) on Windows. Is there any plans to add it (?), or is there an inherent problem?

I would be willing to write that support if there is a bit of guidance on how to go about it in the Jamfile.

#7266 Gettext path formats. locale Boost 1.54.0 Patches Aug 23, 2012 
I'm extremely happy about Boost.Locale, but I've found a few things
lacking. So at first I wrote a some wrappers to get around a few flaws
with my usage of Boost.Locale. One of these flaws was how it's hardcoded
to use the Gettext directory hierarchy.

I'd rather store my stuff in 'lang/en_US.mo' rather than
'lang/en_US/LC_MESSAGES/my_app.mo'.

The patch adds a 'path format' feature, which allows you to format the
directory structure when finding Gettext catalogs, to achieve the effect
above. All you really have to do is run:

   gen.add_path_format("{1}/{2}.mo"); // Use a smaller hierarchy.

to achieve the result that I prefer, or

   gen.add_path_format("{1}/{2}/{3}/{4}.mo"); // Use a Gettext hierarchy.

to achieve the result that Boost.Locale uses right now. Ripped straight
from Doxygen comments:

   {1} A path to search for catalogs in.
   {2} The locale's name.
   {3} The locale's category.
   {4} The Gettext domain.

I apologize for the cut and paste from it but I'm having trouble with trac. The full thread with patches can be found at: ​http://lists.boost.org/Archives/boost/2012/08/195789.php

Andrew Sutton (1 match)

#3478 Min cut interface for BGL graph To Be Determined Feature Requests Sep 22, 2009

1) The max flow can be obtained with: (any of the max_flow algorithms, kolmogorov is just used as an example)

double flow = kolmogorov_max_flow(g, SourceNode, SinkNode);

It would be nice to also interpret this max flow as a min cut. I.e. be able to tell which nodes of g belong to the "source side" of the graph and which nodes belong to the "sink side"? Maybe something like a std::vector<unsigned int> GetSourceSideNodes(); return the IDs of the nodes on the source side std::vector<unsigned int> GetSinkSideNodes();return the IDs of the nodes on the sink side std::vector<unsigned int> GetCutEdges(); return the IDs of the edges which were cut

2) Allow the min cut algorithm to accept multiple sources/sinks. The cut should simply be the minimum sum of edges that can be severed to split the graph so that all of the sinks are on one side of the cut and all of the sources are on the other side of the cut.

3) Find the minimum cut that partitions the graph into two parts without specifying a source/sink? I.e. the minimum of all of the possible source/sink pairs minium cuts.

4) Currently you must use a bidirectional graph, and specify an edge_reverse_t in the graph traits, then set the reverse edge for every edge. a) this is pretty complicated for someone who is unfamiliar with generic programming. b) If an undirected graph is used, the algorithm should automatically take care of adding these reverse edges if they are required for the cut to be performed.

5) VERY simple examples (actually constructing a graph (not reading it from file) with < 10 nodes) should be provided to demonstrate all of these cases.

Andrii Sydorchuk (4 matches)

#6063 resize does not offset rectangles (etc.) correctly or crashes polygon To Be Determined Bugs Oct 26, 2011

When using the 'corner_fill_arc' parameter to polygon_set_concept<T>::resize(), a minkowski sum using a polygonalized circle is used to get the offset shape.

A symptom of the problem is demonstrated by the following code: 

 {
  polygon_set_data<int> ps1, ps2, ps3;
  ps1.insert(rectangle_data<int>(0, 0, 50, 50));
  ps2.insert(rectangle_data<int>(0, 0, 50, 50));
  ps3.insert(rectangle_data<int>(0, 0, 50, 50));
  std::cout << "rect before resize: " << ps1 << std::endl;
  ps1.resize(6, true, 0);
  ps2.resize(6, true, 5);
  ps3.resize(6, true, 6);
  rectangle_data<int> ps1_extents, ps2_extents, ps3_extents;
  extents(ps1_extents, ps1);
  extents(ps2_extents, ps2);
  extents(ps3_extents, ps3);
  std::cout << "extents of resized rect with '0' (4) segments in circle: " << ps1_extents << std::endl;
  std::cout << "extents of resized rect with 5 segments in circle: " << ps2_extents << std::endl;
  std::cout << "extents of resized rect with 6 segments in circle: " << ps3_extents << std::endl;
  }

If I put this at the end of the gtl_boost_unit_test.cpp, I get the following output: 

rect before resize: Polygon Set Data { <0 0, 50 0>:1 <50 0, 50 50>:-1 <0 50, 50 50>:-1 <0 0, 0 50>:1 }
extents of resized rect with '0' (4) segments in circle: -5 54 -5 54
extents of resized rect with 5 segments in circle: -6 54 -6 55
extents of resized rect with 6 segments in circle: -6 55 -6 56

This shows that the extents of the offset shape vary as the number of segments does - which should not be the case!

The extents should all be: -6 56 -6 56

The problem (to my eyes) is that the polygonalized circle does not generally have the right shape to get proper offsets in axis-oriented directions, so the offset is basically multiplied by some factor of sqrt(2). Attached is an image of the circle generated with num_circle_segments=16. The radius of the circle - i.e. distance from center to each vertex - is 2. The grid spacing is 1. As can be seen, the top/bottom and left/right sides of the circle do not lie on the grid. If the circle started with a vertex at(0,2) this would not occur and one would presumably get proper offsets in axis-aligned directions. Alternately one could offset all the vertices slightly farther, but this would offset some vertices farther than desired.

I would guess the fix is to change the behaviour of make_arc(), which generates these points, but I'm not sure exactly what the original author's intent was - so maybe just using a new function would be best (after all, the complexity of make_arc is overkill when you're generating a simple full circle)

Another problem is that the behaviour of the 'corner_fill_arc' parameter is not really well described. Using this gives much more than corner-filling behaviour - it gives different offsets in different directions. I would suggest explaining it as it is - a minkowski sum with a polygonalized circle, with all that implies.

E.g. for a 45-degree segment the offset will differ from a 90-degree segment unless you pick the right value of num_circle_segments.

Maybe a more comprehensible solution would be to implement corner rounding by the intersection of the normal resize()d shape (as given by corner_fill_arc=false) with the resize()d shape given by corner_fill_arc=true with a larger 'resizing' (picked so that the minimum resizing equals the original resizing).

This would only affect corners, instead of the whole shape.

#7984 In very rare cases, boost::polygon crashed or generate bad polygon when substracting 2 sets of polygons polygon To Be Determined Bugs Feb 5, 2013

I am using boost:: polygon to calculate sum or difference of sets of polygons. Recently, When calcualting the difference of 2 sets of polygons, I found 2 cases creating a serious issue: Depending on the shape of polygons ( a slight change "fix" the bug) I have one case which create no polygon and one (in fact 2 samples) which crashes.

In the sample which calculate the difference between 2 polygon sets, there are 2 polygon sets: one creates no polygon, and the other crashes.

This it reproducible under Linux or Windows-gcc-mingw, with different gcc versions and boost version. (I tried to make the polygons as simple as possible) (see comments inside the sample).

I have used a lot boost:: polygon, and I have only 2 cases which fails (Seems related to a particular shape, not to a polygon complexity)

Thanks to the developpers.

#11315 Compilation warnings created by boost::polygon::operators polygon To Be Determined Bugs May 17, 2015

When I compile bp_warn.cc (attached) with Clang and enable "-Wall -Werror", the compilation fails with "template argument uses unnamed type". See attached "warnings.txt" for complete output.

This took me a little while to track down, since the error occurs on a call to "*" using primitive types (!).

I am not sure this is really a bug in boost::polygon, and I am not sure how to fix it if it is, but I thought I would report it anyway.

#11415 crash in processEvent_ polygon To Be Determined Bugs Jun 23, 2015

In polygon/details/polygon_arbitrary_formation.hpp, at the end of function processEvent_ (line 1768), I had a case where iter is dereferenced illegally.

Changing line 1741 from:

if(verticalTail && !(verticalCount.second)) {

to

if (verticalTail && !(verticalCount.second) && iter != scanData_.end()) {

fixes this problem, but it might be the case that this just misses the addition of a new hole.

I have processed many polygons and this only happened with a specific polygon, but looking at the iter determining code earlier in processEvent_ (lines 1669..1698), iter referring to the end of scanData might not be such a special case:

iterator iter = lookUp_(currentY);

while(iter != scanData_.end() && ((iter->first.pt.x() == x_ && iter->first.pt.y() == currentY) or (iter->first.other_pt.x() == x_ && iter->first.other_pt.y() == currentY))) {

elementIters.push_back(iter);

...

++iter;

}

If the original coder assumed that (verticalTail && !(verticalCount.second)) implies that (iter != scanData_.end()), well, sometimes it does not. I'll provide more info on actual case(s) (instantiation types, coordinates) in additional notes.

In the seen case, scanData_ contained 3 elements, and elementIters had 2.

awulkiew (2 matches)

#10772 boost::geometry::within() does not recognize empty boxes geometry To Be Determined Bugs Nov 8, 2014

If boost::geometry::within() is used to check whether an empty box (i.e. a point) is within another box, false is always returned. This is not the correct behavior because:

  1. OGC defines: a.Within(b) ⇔ (a∩b=a) ∧ (I(a)∩E(b)=∅) which holds true. The intersection of an empty box a and a surrounding box b yields a. Since a has no interior, I(a)=∅, thus the second condition is also true.
  2. Empty boxes should be treated as points. When using a point model instead of an empty box, the check returns the correct result as expected.

See also the following complete minimal code (it includes also other geometry algorithms that are computed consistently for points and empty boxes): 

#include <boost/geometry/geometries/point_xy.hpp>
#include <boost/geometry/geometries/box.hpp>
#include <boost/geometry/algorithms/convert.hpp>
#include <boost/geometry/algorithms/within.hpp>
#include <boost/geometry/algorithms/covered_by.hpp>
#include <boost/geometry/algorithms/intersects.hpp>
#include <boost/geometry/algorithms/disjoint.hpp>
#include <boost/geometry/algorithms/distance.hpp> // needed for within() -- is this intended?
#include <iostream>

namespace bg = boost::geometry;
typedef bg::model::d2::point_xy<float> Point;
typedef bg::model::box<Point> Box;

int main()
{
    Point point(3, 4);
    Box pointAsBox;
    bg::convert(point, pointAsBox);

    Box surrounding;
    surrounding.min_corner() = Point(2, 2);
    surrounding.max_corner() = Point(5, 5);

    std::cout << "            Point Box" << std::endl;
    std::cout << "within:        " << bg::within(point,      surrounding)
                         << "    " << bg::within(pointAsBox, surrounding)     << "\n"; // 1 0 <-
    std::cout << "within (self): " << bg::within(point,      point)           
                         << "    " << bg::within(pointAsBox, pointAsBox)      << "\n"; // 1 0 <-
    std::cout << "covered_by:    " << bg::covered_by(point,      surrounding) 
                         << "    " << bg::covered_by(pointAsBox, surrounding) << "\n"; // 1 1
    std::cout << "intersects:    " << bg::intersects(point,      surrounding) 
                         << "    " << bg::intersects(pointAsBox, surrounding) << "\n"; // 1 1
    std::cout << "disjoint:      " << bg::disjoint(point,      surrounding)   
                         << "    " << bg::disjoint(pointAsBox, surrounding)   << "\n"; // 0 0
    std::cout << std::endl;
}

The implementation looks as follows (boost/geometry/strategies/cartesian/box_in_box.hpp, line 32): 

struct box_within_range
{
    template <typename BoxContainedValue, typename BoxContainingValue>
    static inline bool apply(BoxContainedValue const& bed_min
                , BoxContainedValue const& bed_max
                , BoxContainingValue const& bing_min
                , BoxContainingValue const& bing_max)
    {
        return bing_min <= bed_min && bed_max <= bing_max // contained in containing
            && bed_min < bed_max;                         // interiors overlap
    }
};

The problem is the second line, which uses < and thus returns false if the coordinates are equal. I'm not sure what the intention is (despite the comment), and whether it is needed at all.

The documentation about box model and concept doesn't state whether max_corner's coordinates must be component-wise greater or equal than min_corner's. If so, it seems like valid boxes are a precondition to within() and this line could be removed.

#11421 [geometry] rstar segmentation fault boost version 1.58.0 geometry To Be Determined Bugs Jun 25, 2015

Notes:

The segmentation fault does not occur with boost version 1.55.0.
Discovered when upgrading from Boost 1.55.0 to Boost 1.58.0.
When inserting large numbers (greater than 104) of geometry::model::box objects into an geometry::index::rtree object that uses the boost::geometry::index::rstar algorithm, a segmentation fault occurs.

system information:

gcc (Gentoo 4.8.2 p1.0, pie-0.5.8) 4.8.2

Linux dctest1 3.4.0-gentoo-01 #1 SMP Sun May 27 15:51:01 CDT 2012 x86_64 Intel(R) Xeon(R) CPU X5675 @ 3.07GHz GenuineIntel GNU/Linux

MemTotal: 198094372 kB

test program used to reproduce segmentation fault:

// File: test.cpp

#include <iostream>
#include <boost/geometry.hpp>
#include <boost/geometry/index/rtree.hpp>

// NOTE: 1250, 800 makes 10^6 geo fences
const int NUM_BOXES_LAT = 1250;
const int NUM_BOXES_LON = 800;
const float MAX_LAT_DEG = 61.2167f; // Anchorage AK
const float MIN_LAT_DEG = 25.7877f; // Miami FL
const float MAX_LON_DEG = -68.7703f; // Bangor ME
const float MIN_LON_DEG = -149.9000f; // Anchorage AK
const float DELTA_LAT_DEG = (MAX_LAT_DEG - MIN_LAT_DEG)/static_cast<float>(NUM_BOXES_LAT);
const float DELTA_LON_DEG = (MAX_LON_DEG - MIN_LON_DEG)/static_cast<float>(NUM_BOXES_LON);
using COORD_TYPE = boost::geometry::cs::cartesian;
using Point = boost::geometry::model::point<float, 2, COORD_TYPE>;
using Box = boost::geometry::model::box<Point>;
using BoxIDPair = std::pair<Box, unsigned>;

int main()
{
  // Create a grid of boxes evenly distributed across North America.
  // Test Note: swap out rtree algorithms to isolate seg fault problem
//  boost::geometry::index::rtree< BoxIDPair, boost::geometry::index::rstar<16, 4> > locationGeometryTable; // seg fault @ 10^4 boxes
  boost::geometry::index::rtree< BoxIDPair, boost::geometry::index::rstar<16> > locationGeometryTable; // seg fault @ 10^4 boxes
//  boost::geometry::index::rtree< BoxIDPair, boost::geometry::index::quadratic<16> > locationGeometryTable; // pass @ 10^4 boxes; pass @ 10^6

  for(unsigned idxLat=0; idxLat<NUM_BOXES_LAT; ++idxLat)
  {
    float lat = idxLat*DELTA_LAT_DEG + MIN_LAT_DEG;
    for(unsigned idxLon=0; idxLon<NUM_BOXES_LON; ++idxLon)
    {
      float lon = idxLon*DELTA_LON_DEG + MIN_LON_DEG;
      unsigned boxID = idxLat*idxLon;
      // Directly map to cartesian: lon is X; lat is Y
      Point pt0(lon, lat);
      Point pt1(lon+0.001f, lat+0.001f);
      Box box(pt0, pt1);
      locationGeometryTable.insert(std::make_pair(box, boxID));
    }
  }

  return 0;
}

build:

$ gcc -std=c++11 -lstdc++ -I$BOOST_ROOT/include -DBUFFERSIZE=4096 -g -O0 test.cpp -o test

run:

$ ./test
Segmentation fault

debug:

$ gdb ./test
GNU gdb (Gentoo 7.5 p1) 7.5
Copyright (C) 2012 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
and "show warranty" for details.
This GDB was configured as "x86_64-pc-linux-gnu".
For bug reporting instructions, please see:
<http://bugs.gentoo.org/>...
Reading symbols from test...done.
(gdb) catch throw
Catchpoint 1 (throw)
(gdb) run
Starting program: test 
warning: Could not load shared library symbols for linux-vdso.so.1.
Do you need "set solib-search-path" or "set sysroot"?

Program received signal SIGSEGV, Segmentation fault.
0x00007ffff7651127 in __memmove_ssse3_back () from /lib64/libc.so.6
(gdb) backtrace
#0  0x00007ffff7651127 in __memmove_ssse3_back () from /lib64/libc.so.6
#1  0x00000000004165fa in boost::geometry::index::detail::varray_detail::copy_dispatch<boost::geometry::index::detail::rtree::ptr_pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::variant<boost::geometry::index::detail::rtree::variant_leaf<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::variant_internal_node<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_>*>*, boost::geometry::index::detail::rtree::ptr_pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::variant<boost::geometry::index::detail::rtree::variant_leaf<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::variant_internal_node<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_>*>*> (first=0x7fffffffc188, last=0x7fffffffc1b8, 
    dst=0x406a6a <boost::variant<boost::geometry::index::detail::rtree::variant_leaf<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::variant_internal_node<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_>::apply_visitor<boost::geometry::index::detail::rtree::visitors::rstar::level_insert<1ul, boost::geometry::index::detail::rtree::ptr_pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::variant<boost::geometry::index::detail::rtree::variant_leaf<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::variant_internal_node<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_>*>, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::detail::rtree::options<boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::index::detail::rtree::insert_reinsert_tag, boost::geometry::index::detail::rtree::choose_by_overlap_diff_tag, boost::geometry::index::detail::rtree::split_default_tag, boost::geometry::index::detail::rtree::rstar_tag, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::translator<boost::geometry::index::indexable<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, boost::geometry::---Type <return> to continue, or q <return> to quit---
index::equal_to<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> > >, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag> > >(boost::geometry::index::detail::rtree::visitors::rstar::level_insert<1ul, boost::geometry::index::detail::rtree::ptr_pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::variant<boost::geometry::index::detail::rtree::variant_leaf<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::variant_internal_node<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_>*>, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::detail::rtree::options<boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::index::detail::rtree::insert_reinsert_tag, boost::geometry::index::detail::rtree::choose_by_overlap_diff_tag, boost::geometry::index::detail::rtree::split_default_tag, boost::geometry::index::detail::rtree::rstar_tag, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::translator<boost::geometry::index::indexable<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, boost::geometry::index::equal_to<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> > >, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag> >&)+62>)
    at /data/git/dependencies/boost-1.58.0/include/boost/geometry/index/detail/varray_detail.hpp:201
#2  0x0000000000413ee6 in boost::geometry::index::detail::varray_detail::copy<boost::geometry::index::detail::rtree::ptr_pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::variant<boost::geometry::index::detail::rtree::variant_leaf<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::variant_internal_node<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_>*>*, boost::geometry::index::detail::rtree::ptr_pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::variant<boost::geometry::index::detail::rtree::variant_leaf<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::variant_internal_node<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_>*>*> (
    first=0x7fffffffc188, last=0x7fffffffc1b8, 
    dst=0x406a6a <boost::variant<boost::geometry::index::detail::rtree::variant_leaf<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost---Type <return> to continue, or q <return> to quit---
::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::variant_internal_node<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_>::apply_visitor<boost::geometry::index::detail::rtree::visitors::rstar::level_insert<1ul, boost::geometry::index::detail::rtree::ptr_pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::variant<boost::geometry::index::detail::rtree::variant_leaf<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::variant_internal_node<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_>*>, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::detail::rtree::options<boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::index::detail::rtree::insert_reinsert_tag, boost::geometry::index::detail::rtree::choose_by_overlap_diff_tag, boost::geometry::index::detail::rtree::split_default_tag, boost::geometry::index::detail::rtree::rstar_tag, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::translator<boost::geometry::index::indexable<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, boost::geometry::index::equal_to<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> > >, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag> > >(boost::geometry::index::detail::rtree::visitors::rstar::level_insert<1ul, boost::geometry::index::detail::rtree::ptr_pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::variant<boost::geometry::index::detail::rtree::variant_leaf<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::variant_internal_node<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_>*>, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::detail::rtree::options<boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::index::detail::rtree::insert_reinsert_tag, boost::geometry::index::detail::rtree::choose_by_overlap_diff_tag, boost::geometry::index::detail::rtree::split_default_tag, boost::geometry::index::detail::rtree::rstar_tag, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::translator<boost::geometry::index::indexable<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, boost::geometry::index::equal_to<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> > >, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag> >&)+62>)
    at /data/git/dependencies/boost-1.58.0/include/boost/geometry/index/detail/varray_detail.hpp:224
#3  0x0000000000411a03 in boost::geometry::index::detail::varray<boost::geometry::index::detail::rtree::ptr_pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::variant<boost::geometry::index::detail::rtree::variant_leaf<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::variant_interna---Type <return> to continue, or q <return> to quit---
l_node<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_>*>, 17ul>::assign_dispatch<boost::geometry::index::detail::rtree::ptr_pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::variant<boost::geometry::index::detail::rtree::variant_leaf<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::variant_internal_node<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_>*>*> (
    this=0x406a62 <boost::variant<boost::geometry::index::detail::rtree::variant_leaf<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::variant_internal_node<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_>::apply_visitor<boost::geometry::index::detail::rtree::visitors::rstar::level_insert<1ul, boost::geometry::index::detail::rtree::ptr_pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::variant<boost::geometry::index::detail::rtree::variant_leaf<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::variant_internal_node<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_>*>, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::detail::rtree::options<boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::index::detail::rtree::insert_reinsert_tag, boost::geometry::index::detail::rtree::choose_by_overlap_diff_tag, boost::geometry::index::detail::rtree::split_default_tag, boost::geometry::index::detail::rtree::rstar_tag, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::translator<boost::geometry::index::indexable<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, boost::geometry::index::equal_to<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> > >, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag> > >(boost::geometry::index::detail::rtree::visitors::rstar::level_insert<1ul, boost::geometry::index::detail::rtree::ptr_pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::variant<boost::geometry::index::detail::rtree::variant_leaf<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allo---Type <return> to continue, or q <return> to quit---
cator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::variant_internal_node<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_>*>, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::detail::rtree::options<boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::index::detail::rtree::insert_reinsert_tag, boost::geometry::index::detail::rtree::choose_by_overlap_diff_tag, boost::geometry::index::detail::rtree::split_default_tag, boost::geometry::index::detail::rtree::rstar_tag, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::translator<boost::geometry::index::indexable<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, boost::geometry::index::equal_to<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> > >, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag> >&)+54>, first=0x7fffffffc188, last=0x7fffffffc1b8)
    at /data/git/dependencies/boost-1.58.0/include/boost/geometry/index/detail/varray.hpp:1774
#4  0x00000000004100b4 in boost::geometry::index::detail::varray<boost::geometry::index::detail::rtree::ptr_pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::variant<boost::geometry::index::detail::rtree::variant_leaf<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::variant_internal_node<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_>*>, 17ul>::assign<boost::geometry::index::detail::rtree::ptr_pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::variant<boost::geometry::index::detail::rtree::variant_leaf<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::variant_internal_node<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_>*>*> (
    this=0x406a62 <boost::variant<boost::geometry::index::detail::rtree::variant_leaf<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::variant_internal_node<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boos---Type <return> to continue, or q <return> to quit---
t::detail::variant::void_>::apply_visitor<boost::geometry::index::detail::rtree::visitors::rstar::level_insert<1ul, boost::geometry::index::detail::rtree::ptr_pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::variant<boost::geometry::index::detail::rtree::variant_leaf<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::variant_internal_node<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_>*>, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::detail::rtree::options<boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::index::detail::rtree::insert_reinsert_tag, boost::geometry::index::detail::rtree::choose_by_overlap_diff_tag, boost::geometry::index::detail::rtree::split_default_tag, boost::geometry::index::detail::rtree::rstar_tag, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::translator<boost::geometry::index::indexable<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, boost::geometry::index::equal_to<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> > >, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag> > >(boost::geometry::index::detail::rtree::visitors::rstar::level_insert<1ul, boost::geometry::index::detail::rtree::ptr_pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::variant<boost::geometry::index::detail::rtree::variant_leaf<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::variant_internal_node<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_>*>, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::detail::rtree::options<boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::index::detail::rtree::insert_reinsert_tag, boost::geometry::index::detail::rtree::choose_by_overlap_diff_tag, boost::geometry::index::detail::rtree::split_default_tag, boost::geometry::index::detail::rtree::rstar_tag, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::translator<boost::geometry::index::indexable<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, boost::geometry::index::equal_to<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> > >, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag> >&)+54>, first=0x7fffffffc188, last=0x7fffffffc1b8)
    at /data/git/dependencies/boost-1.58.0/include/boost/geometry/index/detail/varray.hpp:950
#5  0x000000000040e698 in boost::geometry::index::detail::rtree::redistribute_elements<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::detail::rtree::options<boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::index::detail::rtree::insert_reinsert_tag, boost::geometry::index::detail::rtree::choose_by_overlap_diff_tag, boost::geometry::index::detail::rtree::split_default_tag, boost::geometry::index::detail::rtree::rstar_tag, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::translator<boost::geometry::index::indexable<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, boost::geometry::index::equal_to<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> > >, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::rstar_tag>::apply<boost::geometry::index::detail::rtree::variant_internal_node<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag> > (n=..., 
    second_node=..., box1=..., box2=..., parameters=..., translator=..., allocators=...)
---Type <return> to continue, or q <return> to quit---
    at /data/git/dependencies/boost-1.58.0/include/boost/geometry/index/detail/rtree/rstar/redistribute_elements.hpp:442
#6  0x0000000000000003 in ?? ()
#7  0x00007fffffffca00 in ?? ()
#8  0x000000000040b798 in boost::geometry::index::detail::rtree::visitors::rstar::level_insert<1ul, boost::geometry::index::detail::rtree::ptr_pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::variant<boost::geometry::index::detail::rtree::variant_leaf<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::variant_internal_node<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_, boost::detail::variant::void_>*>, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::detail::rtree::options<boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::index::detail::rtree::insert_reinsert_tag, boost::geometry::index::detail::rtree::choose_by_overlap_diff_tag, boost::geometry::index::detail::rtree::split_default_tag, boost::geometry::index::detail::rtree::rstar_tag, boost::geometry::index::detail::rtree::node_variant_static_tag>, boost::geometry::index::detail::translator<boost::geometry::index::indexable<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, boost::geometry::index::equal_to<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> > >, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::allocators<std::allocator<std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int> >, std::pair<boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, unsigned int>, boost::geometry::index::rstar<16ul, 4ul, 4ul, 32ul>, boost::geometry::model::box<boost::geometry::model::point<float, 2ul, boost::geometry::cs::cartesian> >, boost::geometry::index::detail::rtree::node_variant_static_tag> >::operator() (
    this=<error reading variable: Cannot access memory at address 0x18>, n=<error reading variable: Cannot access memory at address 0x10>)
    at /data/git/dependencies/boost-1.58.0/include/boost/geometry/index/detail/rtree/rstar/insert.hpp:279
Backtrace stopped: previous frame inner to this frame (corrupt stack?)

az_sw_dude (5 matches)

#5638 greg_month::get_month_map_ptr is not thread safe date_time To Be Determined Bugs Jun 24, 2011

We recently have found a crash issue related to this function in greg_month.cpp.

the block from line 39 is not thread safe. If multiple threads call this function simultaneously, it will lead to a crash. As one thread is populating the map while the other thread may start using the map, or even worse two threads populate the map at the same time.

#605 Support different DST rules in timezone db based on years date_time Feature Requests Apr 17, 2006 
The boost time library supports processing of the
timezone database file as a .csv, with one entry per
time zone, such as "America/New_York".  However, in
2007, the daylight savings time rules will change.  The
contents of the csv need to change, to incorporate a
range of effective years.  Since DST is a spring and
fall event (in both north and south hemispheres) only a
year need be recorded.

I suggest adding two values at the beginning of the
line, (as one field in the form nnnn-nnnn) for the low
effective-year and high effective-year, as 4-digit
values.  Let 0000 be used for "all previous years" and
9999 be used for all subsequent years.  [If the '-'
separator is a problem, ':' could be used instead.]

Then, the change in 2007 can be recorded as two lines:
"2007-9999","America/New_York", ...
"0000-2006","America/New_York", ...

Lines unaffected by the change would have "0000-9999"
as the first field.
#889 Insane Dependencies date_time Feature Requests Apr 9, 2007 
From: helvey@accelrys.com

Simply including boost/date_time/posix_time headers causes build times to skyrocket. Building a file that includes boost/date_time/posix_time/posix_time.hpp takes almost a minute, removing the header drops the time to less than a second.
Also why no conversions to time_t? It would be nice not to have include the header outside of translation units. :)
#1207 Method "from_julian_day_number" (class gregorian_calendar) not documented date_time Boost 1.51.0 Feature Requests Aug 23, 2007

please could you put the method gregorian_calendar::from_julian_day_number() in the documentation ? library: date_time

thanks

gizmo

#3132 Provide conversions to time_t date_time Feature Requests Jun 4, 2009

Extracted from #889.

==========8<============ Also why no conversions to time_t? It would be nice not to have include the header outside of translation units. :) ==========>8============

Need to provide conversion function from Boost.DateTime types to std::time_t.

Barend Gehrels (9 matches)

#8183 boost::geometry::intersection on two polygons returns incorrect empty intersection geometry To Be Determined Bugs Feb 26, 2013

Hi

The code snippet intersects 2 2D polygons resulting in an empty intersection. I'm including an image of the two polygons and they are overlapping. There may be a problem because the polygons share an overlapping edge?

Thanks

Matthew Danielsen 

polygon_2d triangle2D;
{
    const double triangle2Dcoor[] = {{0.891747, 2.28756}, {0.490911, -1.52549}, {-1.72945, -1.52549}, {0.891747, 2.28756}};
    assign(triangle2D, triangle2Dcoor);
}

polygon_2d box2D;
{
    const double box2Dcoor[] = {{-1.6744, -1.52549}, {-1.70498, -1.52549}, {-1.70052, -1.49155}, {-1.67049, -1.49579}, {-1.6744, -1.52549}};
    assign(box2D, box2Dcoor);
}

boost::geometry::model::multi_polygon< boost::geometry::model::polygon<boost::geometry::model::d2::point_xy<T> > > intersectionPolygons;
boost::geometry::intersection(triangle2D, box2D, intersectionPolygons);
assert(intersectionPolygons.size() != 0); //  Assert fails
#8366 "Overlay invalid input exception" (3) geometry To Be Determined Bugs Apr 2, 2013

Please find below some code that triggers "Overlay invalid input exception" (in the last statement of the example). I have a couple of different reproductions, and since I'm not sure if they all share the same root cause, I'm filing them in separate tickets.

As always, my polygon type is oriented counter-clockwise and not closed, my point type is based on int.

This is the data that triggers the exception: 

_intPolygon polygon( "MULTIPOLYGON(((529 998,5337 998,5337 3475,529 3475)))" );
{
       _intPolygon const polygonB = _intPolygon("MULTIPOLYGON(((528 3314,1734 2054,2934 1670,4140 1754,5340 2072,5340 32767,528 32767)))") ^ _intPolygon("MULTIPOLYGON(((528 3218,1734 1784,2934 1400,4140 2582,5340 1832,5340 32767,528 32767)))");
       polygon -= polygonB;
}
{
       _intPolygon const polygonB = _intPolygon("MULTIPOLYGON(((528 3218,1734 1784,2934 1400,4140 2582,5340 1832,5340 32767,528 32767)))") ^ _intPolygon("MULTIPOLYGON(((528 2498,1734 1406,2934 1574,4140 3002,5340 1178,5340 32767,528 32767)))");
       polygon -= polygonB;
}
{
       _intPolygon const polygonB = _intPolygon("MULTIPOLYGON(((528 2498,1734 1406,2934 1574,4140 3002,5340 1178,5340 32767,528 32767)))") ^ _intPolygon("MULTIPOLYGON(((528 2420,1734 2186,2934 2378,4140 2750,5340 1250,5340 32767,528 32767)))");
       polygon -= polygonB;
}
{
       _intPolygon const polygonB = _intPolygon("MULTIPOLYGON(((528 2420,1734 2186,2934 2378,4140 2750,5340 1250,5340 32767,528 32767)))") ^ _intPolygon("MULTIPOLYGON(((528 1724,1734 2552,2934 1640,4140 2396,5340 1460,5340 32767,528 32767)))");
       polygon -= polygonB;
}

This is my code that wraps boost::geometry to implement the operators used above: 

template<typename T>
template<typename Geometry>
_TPolygon< T > _TPolygon< T >::operator-(Geometry const& geometry) const
{
       // should not be necessary
       //if( boost::geometry::area(geometry)==0 ) return *this;

       _TPolygon< T > polygonOut;
       boost::geometry::difference(*this, geometry, polygonOut);

       // should not be necessary
       //boost::geometry::correct( polygonOut );

       return polygonOut;
}

template<typename T>
template<typename Geometry>
_TPolygon<T>& _TPolygon< T >::operator-=(Geometry const& geometry)
{
       // boost::geometry::difference cannot operate in-place
       // http://lists.boost.org/geometry/2012/02/1796.php
       *this = *this - geometry;
       return *this;
}

template<typename T>
template<typename Geometry>
_TPolygon< T > _TPolygon< T >::operator^(Geometry const& geometry) const
{
       _TPolygon< T > polygonOut;
       boost::geometry::sym_difference(*this, geometry, polygonOut);

       // should not be necessary
       //boost::geometry::correct( polygonOut );

       return polygonOut;
}
#8701 wrong empty polygon-linestring intersection with overlapping edges geometry To Be Determined Bugs Jun 16, 2013

The returned intersection between these geometries is empty, although they overlap completely and I would expect the full linestring to be returned:

POLYGON((137372 104999998,137372 97499999,67175839 97499999,67175839 104999998)) LINESTRING(399872 104971332,399872 97528663,2899872 97528663,2899872 104971332,5399872 104971332,5399872 97528663,7899872 97528663,7899872 104971332,10399872 104971332,10399872 97528663,12899872 97528663,12899872 104971332,15399872 104971332,15399872 97528663,17899872 97528663,17899872 104971332,20399872 104971332,20399872 97528663,22899872 97528663,22899872 104971332,25399872 104971332,25399872 97528663,27899872 97528663,27899872 104971332,30399872 104971332,30399872 97528663,32899872 97528663,32899872 104971332,35399872 104971332,35399872 97528663,37899872 97528663,37899872 104971332,40399872 104971332,40399872 97528663,42899872 97528663,42899872 104971332,45399872 104971332,45399872 97528663,47899872 97528663,47899872 104971332,50399872 104971332,50399872 97528663,52899872 97528663,52899872 104971332,55399872 104971332,55399872 97528663,57899872 97528663,57899872 104971332,60399872 104971332,60399872 97528663,62899872 97528663,62899872 104971332,65399872 104971332,65399872 97528663,67175839 97528663)

If I move one of them slightly, I get a correct intersection instead of an empty set. I'm using double for point coordinates.

This issue might be related to #8310 and #8183.

#11580 invalid buffer result geometry To Be Determined Bugs Aug 25, 2015

The following code example produces invalid results. Reducing the distance e.g. from 2.37 to 1 produces correct results. I have tested this code with boost 1.57 and boost 1.59 with the same results. 

#include <boost/geometry.hpp>
#include <boost/geometry/geometries/geometries.hpp>

namespace bg = boost::geometry;

int main()
{
	typedef bg::model::point<double, 2, bg::cs::cartesian> point;
	typedef bg::model::polygon<point> polygon;

	polygon poly;
	bg::read_wkt("POLYGON((14.02 474.96,14.02 494.96,14.022 494.96,14.022 486.24,14.02 474.96))", poly);

        bg::strategy::buffer::distance_symmetric<double> distance_strategy(2.37);
	bg::strategy::buffer::side_straight side_strategy;
	bg::strategy::buffer::join_miter join_strategy;
	bg::strategy::buffer::end_flat end_strategy;
	bg::strategy::buffer::point_circle point_strategy;

	bg::model::multi_polygon<Polygon> grown;
	bg::buffer(poly, grown, distance_strategy, side_strategy, join_strategy,
			   end_strategy, point_strategy);

	std::cout << bg::wkt(grown) << std::endl;
	return 0;
}

The returned shape is:

MULTIPOLYGON(((16.39 474.96,16.3842 474.795,16.3669 474.63,16.3382 474.467,16.2982 474.307,16.2471 474.149,16.1851 473.996,16.1126 473.847,16.0299 473.704,15.9374 473.567,15.8355 473.437,15.7248 473.314,15.6058 473.199,15.4791 473.092,15.3453 472.995,15.205 472.908,15.0589 472.83,14.9078 472.763,14.7524 472.706,14.5934 472.66,14.4315 472.626,14.2677 472.603,14.1027 472.591,13.9373 472.591,13.7723 472.603,13.6085 472.626,13.4466 472.66,13.2876 472.706,13.1322 472.763,12.9811 472.83,12.835 472.908,12.6947 472.995,12.5609 473.092,12.4342 473.199,12.3152 473.314,12.2045 473.437,12.1026 473.567,12.0101 473.704,11.9274 473.847,11.8549 473.996,11.7929 474.149,11.7418 474.307,11.7018 474.467,11.6731 474.63,11.6558 474.795,11.65 474.96,11.6558 475.125,11.6731 475.29,11.7018 475.453,11.7418 475.613,11.7929 475.771,11.8549 475.924,11.9274 476.073,12.0101 476.216,12.1026 476.353,12.2045 476.483,12.3152 476.606,12.4342 476.721,12.5609 476.828,12.6947 476.925,12.835 477.012,12.9811 477.09,13.1322 477.157,13.2876 477.214,13.4466 477.26,13.6085 477.294,13.7723 477.317,13.9373 477.329,14.1027 477.329,14.2677 477.317,14.4315 477.294,14.5934 477.26,14.7524 477.214,14.9078 477.157,15.0589 477.09,15.205 477.012,15.3453 476.925,15.4791 476.828,15.6058 476.721,15.7248 476.606,15.8355 476.483,15.9374 476.353,16.0299 476.216,16.1126 476.073,16.1851 475.924,16.2471 475.771,16.2982 475.613,16.3382 475.453,16.3669 475.29,16.3842 475.125,16.39 474.96)))

#12125 Another problems performing boolean operations on polygons with shared edges geometry Boost 1.63.0 Bugs Apr 13, 2016

Trying to solve problems with union_ operation on mpolygons with shared edges (​https://svn.boost.org/trac/boost/ticket/12118) with help of boost 1.61.0 beta. But instead of getting problems with zero areas, I'm getting really wrong result.

For example

currentPath
MULTIPOLYGON(((-5.96064376831054687500 -17.19871711730957031250,7.83307075500488281250 -32.98977279663085937500,8.81292819976806640625 -34.11151504516601562500,19.66869926452636718750 -14.42036247253417968750,-5.96064376831054687500 -17.19871711730957031250)),((-14.87041568756103515625 -6.99879980087280273438,-16.12161636352539062500 -18.30021858215332031250,-5.96064376831054687500 -17.19871711730957031250,-14.87041568756103515625 -6.99879980087280273438)))

appended Polygon
MULTIPOLYGON(((7.83307075500488281250 -32.98977279663085937500,8.81292819976806640625 -34.11151504516601562500,13.00057315826416015625 -33.85240554809570312500,7.83307075500488281250 -32.98977279663085937500)),((-22.50806808471679687500 -27.92480468750000000000,7.83307075500488281250 -32.98977279663085937500,-14.87041568756103515625 -6.99879980087280273438,-22.50806808471679687500 -27.92480468750000000000)))

Union result (same as currentPath, appended Polygon was totally ignored)
MULTIPOLYGON(((-5.96064376831054687500 -17.19871711730957031250,7.83307075500488281250 -32.98977279663085937500,8.81292819976806640625 -34.11151504516601562500,19.66869926452636718750 -14.42036247253417968750,-5.96064376831054687500 -17.19871711730957031250)),((-14.87041568756103515625 -6.99879980087280273438,-16.12161636352539062500 -18.30021858215332031250,-5.96064376831054687500 -17.19871711730957031250,-14.87041568756103515625 -6.99879980087280273438)))

#13072 boost::geometry::intersection different results for CCW and CW geometry To Be Determined Bugs Jun 14, 2017

Hello,

when calculating the intersection between these two polygons the results differ dependent on the orientation (CW vs CCW). 

#include <boost/geometry/geometry.hpp>
#include <boost/geometry/geometries/polygon.hpp>
#include <boost/geometry/geometries/point_xy.hpp>

int main(int argc, char* argv[])
{
  typedef boost::geometry::model::polygon<boost::geometry::model::d2::point_xy<double>, true,  false >  boost_polygon_CW_Open;
  typedef boost::geometry::model::polygon<boost::geometry::model::d2::point_xy<double>, false, false > boost_polygon_CCW_Open;

  const std::string strPoly1( "POLYGON((986.53314901320903 603.61376367962623, 1014.6804499149767 602.74037774442763, 1018.1411735073581 623.97665453539310, 990.14493850604447 624.49725628790509))" );
  const std::string strPoly2( "POLYGON((986.77183669558929 603.60635741124452, 998.79457181965154 603.23330253835934, 1002.2613711877982 623.79581100129735, 990.30090761267468 624.02156931285253))" );

  boost_polygon_CW_Open p1_cw_open, p2_cw_open;
  boost::geometry::read_wkt(strPoly1, p1_cw_open);
  boost::geometry::read_wkt(strPoly2, p2_cw_open);
  boost::geometry::correct(p1_cw_open); // reverts order of points
  boost::geometry::correct(p2_cw_open); // reverts order of points

  std::vector<boost_polygon_CW_Open> output_cw;
  boost::geometry::intersection(p1_cw_open, p2_cw_open, output_cw); // correct: output_cw.front equals poly2

  boost_polygon_CCW_Open p1_ccw_open, p2_ccw_open;
  boost::geometry::read_wkt(strPoly1, p1_ccw_open);
  boost::geometry::read_wkt(strPoly2, p2_ccw_open);
  boost::geometry::correct(p1_ccw_open); // no modification
  boost::geometry::correct(p2_ccw_open); // no modification

  std::vector<boost_polygon_CCW_Open> output_ccw;
  boost::geometry::intersection(p1_ccw_open, p2_ccw_open, output_ccw); // incorrect: output_cw is empty!!!

  return 0;
}
#13444 boost::geometry::buffer returns only partial result (regression over 1.63.0) geometry To Be Determined Bugs Feb 9, 2018

using boost::geometry::buffer with multilinestring, only 1 of expected 3 polygons are returned.

The fix ist to buffer each linestring separately and union_ them into one multipolygon. This also turned out to be much faster.

I do not have a simple example, but a rather complex one, which I will attach.

Version 1.63.0 returned all 3 polygons, but was also rather slow when compared with the workaround.

#13522 Invalid empty result using boost::geometry::difference geometry To Be Determined Bugs Apr 16, 2018

Hello,

executing the following polygon difference operation sequence produces an obviously incorrect empty result. The first difference produces a (possibliy) valid result with a spike which might be the actual problem. The third difference with the previous result generates an empty result. The intermediate difference is required the reproduce this behaviour. Without it the result of the third difference is correct. Removing the spike from step one also solves the problem.

Code to reproduce this:

using point_type = boost::geometry::model::d2::point_xy<double>; using polygon = boost::geometry::model::polygon<point_type>; using multi_polygon = boost::geometry::model::multi_polygon<polygon>;

BoostGeometryBridge::Polygon2d_t Right[3]; BoostGeometryBridge::MultiPolygon2d_t Left[4];

boost::geometry::read_wkt("MULTIPOLYGON(((0.747399249902131135 -0.974867609298678328,0.744720465461241043 -0.984866128861542012,0.737400169703072983 -0.992186849248596014,0.72740024741975795 -0.994866631198703,0.169444950081761997 -0.994882813404528998,0.156263880981993009 -0.992649068186161054,0.144555091741144004 -0.986196591543298973,0.135626528763234999 -0.976246166252738967,0.0970341390445131069 -0.91515608670535098,0.0527935015388215009 -0.831873652851741974,0.0149278636239085008 -0.745505885364162957,-0.016349202846282801 -0.656539920475841976,-0.0408612872409169006 -0.56547754891590496,-0.0584701351532070993 -0.472832385681689005,-0.0690764281904878985 -0.379126973119241983,-0.0726203441553292944 -0.284889833651171986,-0.0690818944579700972 -0.19065248877542601,-0.058481036857029399 -0.0969464611485150035,-0.0408775628926898033 -0.00430027666216776031,-0.0163707606471800993 0.086763516577464006,0.0149011452653820004 0.17573129555438699,0.0527617733210207981 0.262101259307556012,0.0969975799226773933 0.345386259216249991,0.135586426022915013 0.406478577227274984,0.144514411807557003 0.416429520405822984,0.156222826750318011 0.422882676210660002,0.169403766258661992 0.42511718599825099,0.727359063596658029 0.425133368204076989,0.737359141304932963 0.422454166307816015,0.744679861691986966 0.415133870549649009,0.747359067455327319 0.405136098375181386,0.747329770868999987 1.43513394783313997,2.74732976755064007 1.43524915817017007,2.74708725756255978 5.64524915118547987,-2.74750006237453981 1.25999999251885009,-2.74749997944197011 -4.43500000748115042,0.747500020558034994 -4.43500000604748035,0.747399249902131135 -0.974867609298678328),(-2.49638915854706989 0.152811596222504009,-1.75719536363572004 1.80498971421238008,-1.01782283569549992 1.4741902811305001,-1.75234596398119002 -0.167548384003570999,-1.76762179055725999 -0.173243028570225999,-2.49638915854706989 0.152811596222504009)))", Left[0]);

boost::geometry::read_wkt("POLYGON((-1.57590744074229994 2.19505211912179998,-2.74750006237453981 1.25999999251885009,-2.74750004134586989 -0.184043917378418992,-1.76796680349592994 -0.184043903114115004,-1.74492840055212994 -0.175455463366190001,-1.00461083616106994 1.47923439340570995,-1.57590744074229994 2.19505211912179998))", Right[0]); boost::geometry::read_wkt("POLYGON((2.74708725756255001 5.64524915118547987, 1.48149582377297007 4.63517624723808019, 2.7471454369183701 4.6352491528611397, 2.74708725756255001 5.64524915118547987))", Right[1]); boost::geometry::read_wkt("POLYGON((-2.74749997944197011 -4.43500000748115042, -2.74750006237453981 1.25999999251885009, -3.11250006493298015 1.43568817247817004, -3.11249997689355018 -4.61000000763086959, -2.74749997944197011 -4.43500000748115042))", Right[2]);

for(int i = 0; i < 3; i++) {

boost::geometry::difference(Left[i], Right[i], Left[i + 1]);

}

Final result in Left[3] is empty.

#13553 intersection gives wrong result geometry Boost 1.68.0 Bugs Apr 30, 2018

The following polygons result in a wrong intersection:

using point_type = boost::geometry::model::d2::point_xy<double>; typedef boost::geometry::model::ring<point_type, false, true> polygon;

polygon op1, op2;

boost::geometry::read_wkt("POLYGON((7.7058932076134967 -11.523889618379748,8.0348094747518424 0.63492733448631888,7.7720440433489850 0.63492733448631888, 7.7058932076134967 -11.523889618379748))", op1); boost::geometry::read_wkt("POLYGON((2.6206910206017642 -32.773696844382265, 5.5835888947200090 -24.273798818378602, 6.7109368565951772 -20.023839227004206, 7.4191426214038723 -15.773870150408516, 7.7058941612236938 -11.523876267001913, -3.1025600674348395 -11.523582486001384, -3.1025610210450365 -32.773541282571529, 2.6206910206017642 -32.773696844382265))", op2); std::vector<polygon> result; boost::geometry::intersection(op1, op2, result);

result is equal to op1, while op1 is mostly outside op2.

Beman Dawes (22 matches)

#5734 possible handle leak in posix implementation copy_file_api filesystem Boost 1.48.0 Bugs Jul 26, 2011

There is possible handle leak in POSIX implementation of function copy_file_api. 

...
    if ((infile = ::open(from_p.c_str(), O_RDONLY))< 0)
      { return false; }

    struct stat from_stat;
    if (::stat(from_p.c_str(), &from_stat)!= 0)
      { return false; }
...

if ::stat failed, then function exits without closing infile handle.

This problem exists both in v3 and v2 implementations of filesystem. Also this problem exists in previous releases.

#5850 last_write_time on Windows may not work on SMB2-network-mounted drive filesystem To Be Determined Bugs Aug 31, 2011

Consider the following logical operation against a file on a network-mounted drive served over SMB2:

  1. fopen("r+b")/fwrite/fclose a file.
  2. boost::filesystem::last_write_time(file, some other specific time)
  3. fopen("rb")/fclose a file.

As soon as the file is opened in step 3, it appears that the SMB2/redirector actually closes the file and "flushes" its pending write in service of step 1. This has the effect of overwriting the time modification in step 2.

I believe this is happening because boost's non-POSIX/Windows implementation of last_write_time uses CreateFile() and asks only for FILE_WRITE_ATTRIBUTES. Using GENERIC_WRITE appears to work correctly.

Also note, calling utime() instead of boost::filesystem::last_write_time() works correctly.

Please see attached test code demonstrating boost's failure, utime()'s success, and native API workaround.

Please feel free to contact me for follow up. Thanks, -Ken

#5937 Sun C++ 5.11 Linux compilation errors: operations.cpp filesystem To Be Determined Bugs Sep 24, 2011

CC: Sun C++ 5.11 Linux_i386 2010/08/13 usage: CC [ options ] files. Use 'CC -flags' for details

"libs/filesystem/v3/src/operations.cpp", line 1760: Error: DT_UNKNOWN is not defined.

"libs/filesystem/v3/src/operations.cpp", line 1766: Error: DT_DIR is not defined.

"libs/filesystem/v3/src/operations.cpp", line 1768: Error: DT_REG is not defined.

"libs/filesystem/v3/src/operations.cpp", line 1770: Error: DT_LNK is not defined.

4 Error(s) detected.

"CC" -library=stlport4 -xO4 -mt -erroff=%none -m64 -DBOOST_ALL_NO_LIB=1 -DBOOST_SYSTEM_STATIC_LINK=1 -DNDEBUG -I"." -c -o "/home/pal/work/cpp/tmp/boost/bin.v2/libs/filesystem/build/sun/release/address-model-64/link-static/stdlib-sun-stlport/threading-multi/v3/src/operations.o" "libs/filesystem/v3/src/operations.cpp"

#6188 boost directory_iterator construct throw segmentation fault filesystem To Be Determined Bugs Dec 1, 2011

Hi, if i view content of directory in ubuntu only i get a segmentation fault it allways happents in (/proc) directory.

#6638 convert_aux fails while intializing global variable filesystem To Be Determined Bugs Feb 29, 2012

path_traits.cpp

convert_aux fails in global scope:

Trying to initialize global path variable by concatenating '/' a wide string path w/ narrow string path fails!

"Unhandled exception at 0x0f8bc688 (msvcp100d.dll) in paths.exe: 0xC0000005: Access violation reading location 0x00000000."

If initializing inside main() scope everything works fine. I think this worked as expected in previous version(s) 1.48.. no luck with 1.49 though :(

Additional info: WIN 32 and 64 bit, MSVS2010

#include <iostream>
#include <boost/filesystem.hpp>

using namespace boost::filesystem;

path p(L"C:\\TEMP\\");
path q(p / L"wide");  // Works!
path r(p / "narrow"); // Breaks :(

int _tmain(int argc, _TCHAR* argv[])
{
    path p(L"C:\\TEMP\\");
    path q(p / L"wide");  // Works!
    path r(p / "narrow"); // Works here!

    std::cout << r.string() << std::endl;
	return 0;
}


P.S. If more info is required I will reply here not by email.

#8388 windows_file_codecvt should be allocated with _NEW_CRT filesystem To Be Determined Bugs Apr 4, 2013

Due to a bug in VC libraries, when allocating windows_file_codecvt it should be done with _NEW_CRT instead of new. Otherwise if operator new is overriden in the userland application it would be a crash since windows_file_codecvt is allocated with the user provided operator new and deallocated with delete from the C runtime.

#8642 Global locale prevents from using Boost.Filesystem in global constructors and destructors filesystem To Be Determined Bugs Jun 3, 2013

The problem appears in particular with Boost.Log. On program termination, Boost.Log may attempt to perform final log file rotation, which involves calling Boost.Filesystem routines (path construction, in particular). But Boost.Filesystem is not usable at this point because its global locale is already destroyed.

Boost.Filesystem should remain usable during global constructors and destructors. The global locale should either be embedded into the path object (preferred solution, IMHO) or the library should ensure its availability during these stages.

#9816 boost::filesystem::is_empty does not work for symbolic links on Windows filesystem To Be Determined Bugs Mar 30, 2014

Hi,

I'm using boost::filesystem::is_empty() to check if configuration files I'm using are empty. Due to our software deployment these files are mostly symbolic links created with the Windows 7 internal mklink command.

I've used Boost 1.46.1 in the past for this and everything worked fine. Lastly I upgraded to 1.55.0 and found out that is_empty does not work anymore.

I at first asked at Stackoverflow for some help: ​Boost::filesystem::is_empty() returns false for Symlinks

I also created a Github project which reproduces the problem: ​Github - BoostSymLinkError

#9824 boost::filesystem::is_empty() doesn't work with symlinks on Windows filesystem To Be Determined Bugs Apr 1, 2014

See the original information on this problem in this Stackoverflow question:

hxxp://stackoverflow.com/questions/22668337/boostfilesystemis-empty-returns-false-for-symlinks

The person who reported that problem/asked the question on Stackoverflow also set up a github project that demonstrates the problem:

hxxps://github.com/monsdar/BoostSymLinkError

Basically, the filesystem::is_empty() function doesn't follow a symlink, so it will return false even if the target of the symlink has a length greater than 0.

The V2 filesystem library worked for this situation. The difference is that V2 used the stat() function in the VC++ library, while the V3 filesystem library uses the Win32 GetFileAttributesExW() API. The latter does not follow symlinks and returns a file size of 0 regardless of the size of the symlink target.

Attached is a diff for libs/filesystem/src/operations.cpp which uses the stat() technique very similar to what was used in filesystem V2. A few differences:

  • _wstat() is used instead of stat() to accommodate UNICODE filenames
  • a bit test using _S_IFDIR is used to determine if the path is a directory instead of S_ISDIR() because the VC++ library doesn't include a S_ISDIR() or _S_ISDIR() macro.

This patch is only lightly tested (MSVC++ 12.0, 32-bit, on Win7 x64, filenames with ASCII characters only). I'm not sure what the motivations for changing to the GetFileAttributesExW() API in filesystem V3 were, so I'm not sure if there's a fundamental flaw in using _wstat() that would prevent using it in V3.

#10205 FileSystem runtime error: locale::facet::_S_create_c_locale name not valid filesystem Boost 1.57.0 Bugs Jul 16, 2014

Ok this is still broken (see Ticket #5928). On Solaris 10 (sparc) compile this...

#include <iostream> #include <boost/filesystem.hpp>

int main (void) {

std::cout << boost::filesystem::unique_path("/some/random/path/%%%%%%%").c_str() << std::endl; return 0;

}

linking against system and filesystem

I had compiled boost_1_55_0 from the site and built just filesystem and system (because program_options fails to compile with gcc 4.9.0 but thats a separate issue). I created the above example in stage/lib folder and ran..

g++ test.cpp -I../../ -L. -lboost_filesystem -lboost_system

Below are the results...

bash-3.2$ locale LANG=en_GB.UTF-8 LC_CTYPE=en_GB.ISO8859-1 LC_NUMERIC=en_GB.ISO8859-1 LC_TIME=en_GB.ISO8859-1 LC_COLLATE=en_GB.ISO8859-1 LC_MONETARY=en_GB.ISO8859-1 LC_MESSAGES=C LC_ALL= -bash-3.2$ LC_ALL=en_GB.UTF-8 LD_LIBRARY_PATH=. ./a.out terminate called after throwing an instance of 'std::runtime_error'

what(): locale::facet::_S_create_c_locale name not valid

Abort (core dumped) -bash-3.2$ LD_LIBRARY_PATH=. ./a.out terminate called after throwing an instance of 'std::runtime_error'

what(): locale::facet::_S_create_c_locale name not valid

Abort (core dumped) -bash-3.2$ LC_ALL=en_GB.ISO8859-1 LD_LIBRARY_PATH=. ./a.out terminate called after throwing an instance of 'std::runtime_error'

what(): locale::facet::_S_create_c_locale name not valid

Abort (core dumped) -bash-3.2$ LC_ALL=C LD_LIBRARY_PATH=. ./a.out /some/random/path/7fff459

This is utterly crippling and renders boost filesystem useless on Solaris 10.

#10233 create_directories causes invalid read filesystem To Be Determined Bugs Jul 23, 2014

The following code, when run under Valgrind, will report two instances of invalid reads during program close (after main).

Tested on Ubuntu Linux x64 12.04 (kernel 3.8.0) with gcc 4.6.3. 

#include <stdlib.h>
#include <boost/filesystem.hpp>

int main()
{
	system("rm -rf /tmp/test"); // make sure directory doesn't already exist
	boost::filesystem::create_directories("/tmp/test");
	return 0;
}
#10485 heap-use-after-free using C++11 range loop filesystem To Be Determined Bugs Sep 9, 2014

Repro code: 

#include <stdio.h>
#include <boost/filesystem.hpp>

int main() {
    boost::filesystem::path dir("/");
    for (char c : dir.filename().string())
        printf("%c\n", c);
}

I know if I want to fix it I should store dir.filename().string() in a variable (and it works), but in this case it will either crash application or print garbage. Here's what Clang Address Sanitizer prints: 

=================================================================
==12324==ERROR: AddressSanitizer: heap-use-after-free on address 0x60300000ef50 at pc 0x48448a bp 0x7fff08f73990 sp 0x7fff08f73988
READ of size 8 at 0x60300000ef50 thread T0
    #0 0x484489 in std::string::size() const /usr/bin/../lib/gcc/x86_64-redhat-linux/4.8.3/../../../../include/c++/4.8.3/bits/basic_string.h:716
    #1 0x484489 in ~path /usr/bin/../lib/gcc/x86_64-redhat-linux/4.8.3/../../../../include/c++/4.8.3/bits/basic_string.h:636
    #2 0x484489 in main /run/media/constantine/Space/Boost_1.54.0_Bug_Repro_09.07.2014/main.cpp:6
    #3 0x7f0679cd0d64 in __libc_start_main (/lib64/libc.so.6+0x21d64)
    #4 0x483f1c in _start (/run/media/constantine/Space/Boost_1.54.0_Bug_Repro_09.07.2014/Debug/app+0x483f1c)

0x60300000ef50 is located 0 bytes inside of 26-byte region [0x60300000ef50,0x60300000ef6a)
freed by thread T0 here:
    #0 0x46e7b9 in operator delete(void*) (/run/media/constantine/Space/Boost_1.54.0_Bug_Repro_09.07.2014/Debug/app+0x46e7b9)
    #1 0x4843f2 in std::string::_M_rep() const /usr/bin/../lib/gcc/x86_64-redhat-linux/4.8.3/../../../../include/c++/4.8.3/bits/basic_string.h:249
    #2 0x4843f2 in ~basic_string /usr/bin/../lib/gcc/x86_64-redhat-linux/4.8.3/../../../../include/c++/4.8.3/bits/basic_string.h:539
    #3 0x4843f2 in ~basic_string /usr/bin/../lib/gcc/x86_64-redhat-linux/4.8.3/../../../../include/c++/4.8.3/bits/basic_string.h:539
    #4 0x4843f2 in ~path /usr/include/boost/filesystem/path.hpp:55
    #5 0x4843f2 in main /run/media/constantine/Space/Boost_1.54.0_Bug_Repro_09.07.2014/main.cpp:6
    #6 0x7f0679cd0d64 in __libc_start_main (/lib64/libc.so.6+0x21d64)

previously allocated by thread T0 here:
    #0 0x46e4b9 in operator new(unsigned long) (/run/media/constantine/Space/Boost_1.54.0_Bug_Repro_09.07.2014/Debug/app+0x46e4b9)
    #1 0x7f067a3411d8 (/lib64/libstdc++.so.6+0xbe1d8)
    #2 0x9

SUMMARY: AddressSanitizer: heap-use-after-free /usr/bin/../lib/gcc/x86_64-redhat-linux/4.8.3/../../../../include/c++/4.8.3/bits/basic_string.h:716 std::string::size() const
Shadow bytes around the buggy address:
  0x0c067fff9d90: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
  0x0c067fff9da0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
  0x0c067fff9db0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
  0x0c067fff9dc0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
  0x0c067fff9dd0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
=>0x0c067fff9de0: fa fa fa fa fa fa fa fa fa fa[fd]fd fd fd fa fa
  0x0c067fff9df0: 00 00 00 02 fa fa 00 00 00 03 fa fa 00 00 00 02
  0x0c067fff9e00: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
  0x0c067fff9e10: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
  0x0c067fff9e20: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
  0x0c067fff9e30: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
Shadow byte legend (one shadow byte represents 8 application bytes):
  Addressable:           00
  Partially addressable: 01 02 03 04 05 06 07 
  Heap left redzone:     fa
  Heap right redzone:    fb
  Freed heap region:     fd
  Stack left redzone:    f1
  Stack mid redzone:     f2
  Stack right redzone:   f3
  Stack partial redzone: f4
  Stack after return:    f5
  Stack use after scope: f8
  Global redzone:        f9
  Global init order:     f6
  Poisoned by user:      f7
  ASan internal:         fe
==12324==ABORTING
#10900 read_symlink fails to correctly read NTFS junctions filesystem To Be Determined Bugs Dec 26, 2014

Tested on Windows 7 64-bit.

NTFS directory junctions are now recognized as a symlink by is_reparse_point_a_symlink but read_symlink does not correctly handle those "mount point" reparse points yet.

Among other things this also breaks the canonical operation.

The REPARSE_DATA_BUFFER returned by DeviceIoControl needs to be accessed differently for regular symlinks and mount points. See msdn.microsoft.com/en-us/library/ff552012.aspx

Accessing the "PrintName" as a symlink typically results in the first two (wide) characters of the path being skipped and generally in undefined behavior.

A possible fix would be to add a conditional statement checking info.rdb.ReparseTag == IO_REPARSE_TAG_MOUNT_POINT and then amend the symlink_path.assign call accordingly (using info.rdb.MountPointReparseBuffer instead of info.rdb.SymbolicLinkReparseBuffer).

In version 1.57.0 the offending code can be found in libs/filesystem/src/operations.cpp around line 1514.

#2150 Inspect needs to check for missing files inspection script Boost 1.37.0 Feature Requests Jul 28, 2008

Objective: Report missing files early enough to take corrective action before a crisis develops. Include generated doc files in the lists searched for.

Design: Top level "required_files.txt" points to "required_files.txt" in subdirectories. That way the root/required_files.txt only has to be edited when a library is added.

See attached file for possible "required_files.txt" format.

#3965 missing functions last_access_time() and last_status_change_time() filesystem Boost 1.43.0 Feature Requests Feb 28, 2010

In Boost.Filesystem I can find a function:

template <class Path> std::time_t last_write_time(const Path& p);

which is corresponding to st_mtime (last modification time) of the stat structure. Within the stat structure, their are also st_atime and st_ctime defined, but there are no corresponding functions. Is there a special reason for that? Couldn't they be added?

template <class Path> std::time_t last_access_time(const Path& p); template <class Path> std::time_t last_status_change_time(const Path& p);

Cheers, Sascha

#4494 recursive_directory_iterator throws unexpectedly in the non-throw mode filesystem Boost 1.44.0 Feature Requests Jul 30, 2010

In boost::filesystem v3, while it’s possible to choose a no-throw version of recursive_directory_iterator by passing an boost::system::error_code object to its constructor, like this:

boost::system::error_code m_ec; for ( recursive_directory_iterator itr(root, m_ec), end_itr; itr != end_itr; ++itr)

However, because in the implementation of the recursive_directory_iterator::increment(), directory_iterator is always constructed with the throw version, it would cause exception throws during the for-loop while accessing folders like \System Volume Information on Windows:

void increment() {

BOOST_ASSERT(m_imp.get() && "increment of end recursive_directory_iterator"); m_imp->increment(0); if (m_imp->m_stack.empty()) m_imp.reset(); done, so make end iterator

}

Where m_imp is an object of recur_dir_itr_imp:

void recur_dir_itr_imp::increment(system::error_code* ec) ec == 0 means throw on error

{ … }

As it’s not possible to catch this exception within the for-loop and continue the loop, it greatly limits the use of recursive_directory_iterator. With a rough check, V2 does not seem to have this problem. it's preferred that the directory_iterator to behave the same as recursive_directory_iterator in this case.

#5896 Range directory iterators filesystem To Be Determined Feature Requests Sep 13, 2011

With C++11 now finalized as a standard, and compilers being more compliant every day, it makes sense to have range-based versions of the directory_iterator classes. This would make it much easier to use the range-based for loop, as well as Boost.Range functionality.

Basically, it could just be a couple of helper functions that create a boost::iterator_range<bfs::directory_iterator> instance.

#6018 Add touch() and create_file() functions filesystem To Be Determined Feature Requests Oct 13, 2011

A function with the functionality of the POSIX touch utility would be a great convenience. It meets both the need to update times and the need to create a file.

OTOH, it is a bit of a mishmash of logically separate features. Maybe what is really needed is a create_file() function that errors if the file already exists and a touch() function that errors if the file doesn't exist.

Alternatively, both could return a bool, true if successful, and not consider it an error if the file, respectfully, already/doesn't exist.

#6521 Directory listing using C++11 range-based for loops filesystem To Be Determined Feature Requests Feb 4, 2012

I have written a simple 'container' class for a directory, 'containing' all of its subdirectories: 

namespace boost{
    namespace filesystem{
        class directory{
            path p_;
            public:
                inline directory(path p):p_(p){
                    return;
                }
                directory_iterator begin(){
                    return directory_iterator(p_);
                }
                directory_iterator end(){
                    return directory_iterator();
                }
        };
    }
}

so that that range-based for loop can be used: 

for(auto i:directory("/home")){
    ...
}
#10078 Incomplete API with respect to file related dates (cration, modification, access) filesystem To Be Determined Feature Requests May 29, 2014

The following features are missing:

  • read file's creation date
  • read file's last access date
  • read file's creation date with a precision higher than seconds
  • read file's last access date with a precision higher than seconds
  • read file's last access date with a precision higher than seconds
  • allow to detect capabilities of the underlying filesystem (e.g. support for creation and last access date that are not supported by all systems, or finding out date precision supported by the current filesystem)

Possible implementation notes:

  • How to get high precision file date on Linux

​http://stackoverflow.com/questions/13382695/how-to-get-last-modification-time-of-a-file-with-epoch-time-format-precision-mi

  • How to get high precision file date on Windows

​http://msdn.microsoft.com/en-us/library/aa364946.aspx

Example of current use of this feature in existing applications:

ls --full-time

#11663 No way to query file extension without allocating memory filesystem To Be Determined Feature Requests Sep 17, 2015

the function .extension() returns an fs::path, containing a fresh string that contains the extension. On certain library implementations that don't implement the SSO -- or, I guess, for files with very long extensions -- there will be a memory allocation each time the function is called.

That means that for solutions implementing search-by-extension such as is written in:

​http://stackoverflow.com/questions/11140483/how-to-get-list-of-files-with-a-specific-extension-in-a-given-folder

there could be hundreds of memory allocations for just iterating a directory structure. IMO, there really shouldn't be.

I propose adding the function bool path::has_extension(string const&) which can compare the extension in a memory-friendly way.

#2066 Inspect needs to review generated doc files too inspection script Boost 1.36.0 Tasks Jul 3, 2008

Inspect needs to run on release snapshot so that it is looking at the generated doc files too.

But it also needs to be modified so that if it is running on a snapshot (or other cases where svn info doesn't work), the revision number and URL are picked up from somewhere else.

Maybe it would be easier to copy the files from the release snapshot into a release working copy so that inspect will work as it is not.

Peder Holt (1 match)

#5745 Use native typeof support for Oracle Solaris Studio C++ compiler typeof Boost 1.48.0 Feature Requests Aug 1, 2011

Oracle Solaris Studio (former SunStudio) C++ compiler supports native typeof since version 5.9. At the same time, support for typeof emulation is not so good (many compilation errors). It would be beneficial for Boost users if Boost used native typeof instead of emulation.

Here is proposed patch: 

*** boost/typeof/typeof.hpp	2011-08-01 18:46:33.411406362 +0400
--- boost/typeof/typeof.hpp.new	2011-08-01 18:46:43.680746049 +0400
***************
*** 155,160 ****
--- 155,176 ----
  #   else
  #       error native typeof is not supported
  #   endif
+ #elif defined(__SUNPRO_CC)
+ #   if (__SUNPRO_CC < 0x590 )
+ #	ifdef BOOST_TYPEOF_NATIVE
+ #	    error native typeof is not supported
+ #	endif
+ #	ifndef BOOST_TYPEOF_EMULATION
+ #	    define BOOST_TYPEOF_EMULATION
+ #	endif
+ #   else
+ #	ifndef BOOST_TYPEOF_EMULATION
+ #	    ifndef BOOST_TYPEOF_NATIVE
+ #		define BOOST_TYPEOF_NATIVE
+ #	    endif
+ #	    define BOOST_TYPEOF_KEYWORD __typeof__
+ #	endif
+ #   endif
  #else //unknown compiler
  #   ifndef BOOST_TYPEOF_NATIVE
  #       ifndef BOOST_TYPEOF_EMULATION

chris_kohlhoff (1 match)

#2875 Windows: ip::tcp::acceptor::local_endpoint() cannot be used in socket connect asio To Be Determined Feature Requests Mar 20, 2009

On linux the local_endpoint() function returns an endpoint similar to 0.0.0.0:1234. A socket which is given this endpoint to connect to will connect successfully. A similar endpoint is returned on Windows, however the socket connection is not successful.

I am currently working around this problem by inserting loopback as the address to connect to. For the sake of consistency between platforms it may be worthwhile including a similar substitution within the socket's connect operation if 0.0.0.0 is detected.

Sebastian Redl (4 matches)

#9991 WConversion issue in json_parser_write.hpp property_tree To Be Determined Bugs May 2, 2014

File Name: 1_54_0/boost/property_tree/detail/json_parser_write.hpp

There is a severe problem with the -Wconversion issue in the json_parser_write.hpp

Problematic code:

else

{

const char *hexdigits = "0123456789ABCDEF"; typedef typename make_unsigned<Ch>::type UCh; unsigned long u = (std::min)(static_cast<unsigned long>(

static_cast<UCh>(*b)),

0xFFFFul);

int d1 = u / 4096; u -= d1 * 4096;

int d2 = u / 256; u -= d2 * 256; int d3 = u / 16; u -= d3 * 16; int d4 = u;

result += Ch('
'); result += Ch('u'); result += Ch(hexdigits[d1]); result += Ch(hexdigits[d2]); result += Ch(hexdigits[d3]); result += Ch(hexdigits[d4]);

}

Either we need to do explicit static cast to suppress the Conversion Warning. When we turn on the -Wconversion as well as -Werror both together, which is good practice for production ready code. compiler Just dont allow this to compile.

the above need to be fixed.

#10188 Loses floating point precision on round trip property_tree To Be Determined Bugs Jul 10, 2014

ptrees stream_translator uses a precision of std::numeric_limits<F>::digits10 + 1 when converting floating point values. This is not always enough, and a more correct value would be digits10+2 or max_digits10 (c++11 only). See ticket:9177 for a similar issue.

The attached test produces the following output pre-patch: 

in : -1.8312345000098765e-08
out: -1.8312345000098762e-08
Wrong

and after patch: 

in : -1.8312345000098765e-08
out: -1.8312345000098765e-08
Right
#11502 narrow_encoding: -Wtype-limits warning is reported property_tree To Be Determined Bugs Jul 26, 2015

-Wtype-limit is reported on this assert:

char to_internal_trivial(char c) const {

assert(c <= 0x7f); <=== Type limit return c;

}

#5658 how to get rid of nasty compiler warning in boost/property_tree/detail/rapidxml.hpp property_tree To Be Determined Tasks Jun 29, 2011

compiling e.g libs/graph/src/graphml.cpp warns ... 

/boost/property_tree/detail/rapidxml.hpp: In function `size_t boost::property_t
ree::detail::rapidxml::internal::get_index(Ch) [with Ch = char]':
./boost/property_tree/detail/rapidxml.hpp:1413:   instantiated from `static unsi
gned char boost::property_tree::detail::rapidxml::xml_document<Ch>::whitespace_p
red::test(Ch) [with Ch = char]'
./boost/property_tree/detail/rapidxml.hpp:1542:   instantiated from `static void
 boost::property_tree::detail::rapidxml::xml_document<Ch>::skip(Ch*&) [with Stop
Pred = boost::property_tree::detail::rapidxml::xml_document<char>::whitespace_pr
ed, int Flags = 3072, Ch = char]'
./boost/property_tree/detail/rapidxml.hpp:1377:   instantiated from `void boost:
:property_tree::detail::rapidxml::xml_document<Ch>::parse(Ch*) [with int Flags =
 3072, Ch = char]'
./boost/property_tree/detail/xml_parser_read_rapidxml.hpp:116:   instantiated fr
om `void boost::property_tree::xml_parser::read_xml_internal(std::basic_istream<
typename Ptree::key_type::value_type, std::char_traits<typename Ptree::key_type:
:value_type> >&, Ptree&, int, const std::string&) [with Ptree = boost::property_
tree::basic_ptree<std::string, std::string, std::less<std::string> >]'
./boost/property_tree/xml_parser.hpp:52:   instantiated from `void boost::proper
ty_tree::xml_parser::read_xml(std::basic_istream<typename Ptree::key_type::value
_type, std::char_traits<typename Ptree::key_type::value_type> >&, Ptree&, int) [
with Ptree = boost::property_tree::ptree]'
libs/graph/src/graphml.cpp:49:   instantiated from here
./boost/property_tree/detail/rapidxml.hpp:317: warning: comparison is always fal
se due to limited range of data type

Caused by the template: 

template<class Ch>
        inline size_t get_index(const Ch c)
        {
            // If not ASCII char, its sematic is same as plain 'z'
            if (c > 255)
            {
                return 'z';
            }
            return c;
        }

How to avoid ? Just specify additionally a user defined implementation of get_index for the "char" type : 

        inline size_t get_index(const char c)
        {
            return c;
        }

        template<class Ch>
        inline size_t get_index(const Ch c)
        {
            // If not ASCII char, its sematic is same as plain 'z'
            if (c > 255)
            {
                return 'z';
            }
            return c;
        }

I checked the code size (using gcc4.0) : same and the difference of the ASM code: "same" 

14972c14972
<       cmpq    (%r15), %rdi
---
>       cmpq    %rdi, (%r15)
14974c14974
<       jae     .L3637
---
>       jbe     .L3637
15002c15002
<       cmpq    -16(%rsi), %rdi
---
>       cmpq    %rdi, -16(%rsi)
15004c15004
<       jae     .L3643
---
>       jbe     .L3643
15017c15017
<       cmpq    -16(%rdx), %rdi
---
>       cmpq    %rdi, -16(%rdx)
15019c15019
<       jb      .L3796
---
>       ja      .L3796
15487c15487
---

Daniel James (8 matches)

#8565 Lists in admonitions quickbook To Be Determined Bugs May 13, 2013

It seems not to be possible to include lists in admonitions.

E.g. the following won't work, meaning no list will be displayed but just the stars as characters:

[note Some text for my note

  • first point I want to note
  • second point I want to note

]

#1558 Optional separate compilation unordered To Be Determined Feature Requests Jan 6, 2008

There are some parts of Boost.Unordered that could be compiled into a library file. Provide an option to do this.

#1979 More example hash functions unordered To Be Determined Feature Requests Jun 1, 2008
#2448 syntax highlighting for code in documentation or website Documentation Website 1.X Feature Requests Oct 29, 2008

In Boost documentation there are a lot of code examples which it would be better if it will be with syntax highlighting to be more readable.

#8545 Can quickbook support parts and chapters as well as sections? quickbook To Be Determined Feature Requests May 3, 2013

Currently the only "top level" structure supported is the section, but it would be very useful for longer documents have to have support for chapters, parts and appendixes as well. As far as I know these can't be implemented as templates as these get <para>...</para> wrapped around them even when they're block templates.

#1175 Document quickbook's (lack of) unicode support. quickbook To Be Determined Tasks Aug 13, 2007

See ​http://tinyurl.com/35j57v

#1279 Make sure multiple #import of a file imports the file only once. quickbook To Be Determined Tasks Sep 24, 2007
#1487 Update the writing documentation instructions Documentation To Be Determined Tasks Nov 30, 2007

The documentation (http://www.boost.org/more/writingdoc/structure.html) needs to updated and probably should be moved to the new site.

David Bellot (1 match)

#4442 Simple implementation of operator * for matrices with 0 complexity uBLAS To Be Determined Patches Jul 15, 2010

The following is a simple implementation of operator * for matrix-matrix and matrix-vector which simply forwards to the existing prod() implementation.

Since nested products A * B * C can't work yet, it does a compile time check to make sure this isn't occuring.

See attached patch and test file. Note that this also has patched changes for ticket #4441 built in

Eric Niebler (6 matches)

#3936 [xpressive] stack overflow. xpressive Boost 1.43.0 Bugs Feb 16, 2010

The following simple program fires a stack overflow exception in xpressive. It's seems too simple to be causing such problems.

{{{#include "stdafx.h" #include <string> #include <boost/xpressive/xpressive.hpp> using namespace boost::xpressive;

int _tmain(int argc, _TCHAR* argv[]) {

sregex rx = ~(set='{', '}', ','); sregex rx2 = +rx;

std::string s(10000, 'a'); regex_search(s, rx2);

return 0;

}}}}

I'm using MSVC 2005. The problem only occurs if the string is large.

#6992 accumulator's median feature skips 1st two data points. accumulator To Be Determined Bugs Jun 16, 2012

Hi,

I used accumulator's median feature to calculate mean/median of input data. I also used armadillo library's mean/median. The mean from two libraries always agree. However the medians don't. I tried to give 1,2,3,4,5 input data to the program. and found accumulator's median outputs 0 if the number of input data is 1 or 2. It starts to output non-zero median if given more than 2 data points however, first two data points are not used.

Please check what is going on.

Thanks, yu

#3519 It should be possible to use consts as external placeholder variables. xpressive To Be Determined Feature Requests Oct 12, 2009

The right-and-side of placeholder let-expressions are not declared as const, so common use-cases like: 

placeholder<int> _i;
smatch what;
what.let(_i = 1);

or: 

placeholder<MyClass *> _p;
smatch what;
what.let(_p = this);

fail to compile. It would be nice to have some way to specify a placeholder for non-mutable data. Perhaps: 

placeholder<int const> _i;

(suggested by Eric Niebler)

#4704 Support for multicapture and balancing groups xpressive To Be Determined Feature Requests Oct 3, 2010

Feature request ticked to jog Eric Nieblers memory to take a look at some code.

I've added support for multicapture and balancing groups to Boost::Xpressive.

Syntax for pop capture:

dynamic: (?P<-name>stuff)
static: (name -= stuff)

Syntax for capture conditional:

dynamic: (?P(name)stuff)
static: (name &= stuff)

The changes are in the vault and can be found here: ​http://tinyurl.com/3aak7mp

It can be unpacked against trunk from 2010-10-02 or the 1.44.0 release. I've run the dynamic regression tests without errors and I have added some tests for the new functionality. The code it only tested on Visual Studio 2010 since I don't have access to any other compiler.

Erik Rydgren

#6891 Add extension point to define how expressions are created from operators proto To Be Determined Feature Requests May 12, 2012

As discussed here: <​http://lists.boost.org/proto/2012/05/0637.php>

It would be nice to add a mechanism to allow to define what the operator overloads created by Proto will do. Unlike other functions where a Proto-based library can construct nodes the way it wishes, there is no control and what the built-in C++ operators do.

#4668 Conditions for operator overload in Proto (documentation) proto To Be Determined Tasks Sep 21, 2010

Taken from this thread in boost-users: ​http://lists.boost.org/boost-users/2010/09/62747.php

This explanation by Thomas Heller would make a good section for the proto documentation: 

In order for a proto overload to be created the following conditions must be 
true:

1) the operands must be in a compatible domain
2) the left hand operand and the right hand operand must match the grammar 
specified in the domain
3) the resulting expression must match the grammar specified in the domain.

To illustrate what this means, this minimalistic example might be useful, too:

This grammar 

proto::plus<proto::terminal<int>, proto::terminal<int> >

used in a domain would not allow 

i + i;

with i being an int-terminal.

Glen Fernandes (1 match)

#12880 Alignment information @ PP time align Boost 1.65.0 Feature Requests Mar 1, 2017

Please add a macro that can be used for selective compilation based on the guaranteed alignment of the default allocator, i.e. something like: ​https://bitbucket.org/eigen/eigen/src/d4e10456d28275c27f417efc119024749c979b7e/Eigen/src/Core/util/Memory.h

Gunter (4 matches)

#2692 No concepts supporting the idea of dense uBLAS To Be Determined Feature Requests Jan 28, 2009

data() returns a reference to a Storage. However, nowhere in the concepts is a statement saying that &m.data()[0] must to be the address of the first element of the linearly stored data in the Storage. The adjective "dense" is used all over, but nowhere is this term given any operational guarantees. Without such guarantees, all the interfaces in, say, the numerics::binding libraries are being built on sand. Related to this is that nothing requires unbounded_array<T>::value_type to be T. The problem boils down to the ublas concepts documentation borrowing from the stl vector concepts which are general enough to support vector<bool>. The basic (and inadequate) change is the sprinkling around of the word dense and the phrase "strict linear order". Instead you need to explicitly says things like value_type is T and &v[i+j] == &v[i]+j (for reasonable i+j).

#3396 add a sparse_view class that wraps pre-allocated data into a matrix expression uBLAS Boost 1.42.0 Feature Requests Sep 3, 2009

Provide a way to use ublas with pre-allocated data. Implement a matrix view of a CRS matrix as proof of concept. Details:

  • provide a wrapper that fulfills the immutable part of the matrix expression

Further tasks:

  • split the current matrix and vector concepts into immutable and mutable parts in order to gain a "read-only view" concept and a full featured "expression" concept
  • improve traits mechanism and apply it where possible to automatically see a fixed size C-array as vector view or matrix view
  • add necessary tests
#4033 optimized matrix products uBLAS Boost 1.43.0 Patches Mar 22, 2010

proposal from Jörn Ungermann:

Abstract

The (lacking) performance of sparse-matrix products was quite often noted on this list. Currently there are several functions which implement matrix products. Each is efficient under certain conditions only and some of them are not even documented. I think it important for users to have one (near-)optimal function only. The attached file contains an improved axpy_prod that matches the performance of "prod", "axpy_prod" and "sparse_prod" and is thereby optimal for all matrix types.

Details

The optimal choice of kernel for a matrix product depends on the properties of all involved matrices. The current implementations specialize only on the type of target matrix. By also determining the kernel depending on the source matrices, one can choose the most efficient kernel. My aim was to create a single function to match the performance of prod, axpy_prod and sparse_prod for all combinations of compressed_matrix/matrix and column/row-majority. The other matrix types should also be handled efficiently by my product, too, but I did check it only spuriously, as it should be obvious that those types are more suited for matrix setup, not for actual calculation. My axpy_prod implementation (called axpy_prod2 in the attached file) does not offer support for the undocumented triangular_expression stuff contained in the original axpy_prod, which however seems to be buggy in the current code for dense matrices. The kernels are largely based on existing kernels with one or two new ones being thrown in. They are as abstract as possible to handle arbitrary expressions efficiently. Specializing, e.g. directly on compressed_matrix would give another very significant performance boost, but also many more additional kernels, possibly more than could be maintained, especially as the transposedness might have to be handled explicitly, too.

It would be very nice, if someone could rewrite prod/prec_prod to handle matrix products in the same way as my axpy_prod2 does, but I did not look deep enough into the expression-templates to do this myself or to even know if this were possible.

In fact, I'd propose to have two sets of interfaces:

1) One convenient one, possibly compromising efficiency
2) One modeled closely after C-BLAS, delivering utmost efficiency.

The latter one could then be *very easily* overloaded by the numeric bindings for dense matrices. I added a possible generic implementation for a gemm call that could be trivially overloaded for dense matrices and forwarded to, e.g., ATLAS numeric bindings.

If one could achieve the same efficiency and automatic (i.e. by including a header) coupling to numeric bindings using only *one* interface, I'd prefer that naturally. However currently, we have not just two, but too many product functions (prod, prec_prod, axpy_prod, sparse_prod, opb_prod, block_prod).

The following table gives the result for all 64 combinations of compressed_matrix/matrix and row/column-majorities for the three involved in this case 2000x2000 matrices.

com_rm is a compressed_matrix of row_major type.
den_cm is a matrix of column_major type.
The  4th column indicates the used kernel.
The  5th column gives the runtime for axpy_prod2  ( clock()/1000 )
The  6th column gives the runtime for sparse_prod ( clock()/1000 )
The  7th column gives the runtime for axpy_prod   ( clock()/1000 )
The  8th column gives the runtime for prod        ( clock()/1000 )
The 10th column gives the speedup of axpy_prod2 compared to sparse_prod.
The 11th column gives the speedup of axpy_prod2 compared to axpy_prod.
The 12th column gives the speedup of axpy_prod2 compared to prod.

Larger matrix sizes result in prohibitive runtimes for the "slow" products, but can be used to analyse pure-sparse products.

The runtime shall be taken only qualitatively.

One can see that the only cases where the new implementation is slower are of relatively small runtime, so it may be negligible. sparse_prod uses an optimization that is very efficient if the target matrix has few off-diagonal elements, but is very inefficient if it does. The results will therefore vary depending on the test matrices.

It is also obvious to see, why some people complain about product performance, as especially axpy_prod and prod are sometimes ridiculously slow for sparse matrices and sparse_prod does not seem to be documented in the special products section. My favorite case is "com_cm, com_cm, den_rm" one, which actually occurred in the diagnostics part of our application and was the reason why we started looking into this topic.

#1915 Nested matrix products with transposes causes compiler to complain error: invalid application of ‘sizeof’ uBLAS To Be Determined Support Requests May 14, 2008

When using ublas, a pair of nested products will cause the compiler to complain if there is a trans on any of the operands. For example: 

using namespace boost::numeric::ublas;
matrix<float> A(3,3),   B(3,3), C(3,3);

prod(prod(A,B),trans(C));  // fails
prod(prod(trans(A),B),C);  // fails
prod(prod(A,trans(B)),C);  // fails
prod(prod(A,B),C);  // OK

The compiler produces the following error message: 

/opt/local/include/boost/numeric/ublas/matrix_expression.hpp: In function ‘typename boost::numeric::ublas::matrix_matrix_binary_traits<typename E1::value_type, E1, typename E2::value_type, E2>::result_type boost::numeric::ublas::prod(const boost::numeric::ublas::matrix_expression<E>&, const boost::numeric::ublas::matrix_expression<E2>&) [with E1 = boost::numeric::ublas::matrix_matrix_binary<boost::numeric::ublas::matrix<float, boost::numeric::ublas::basic_row_major<size_t, ptrdiff_t>, boost::numeric::ublas::unbounded_array<float, std::allocator<float> > >, boost::numeric::ublas::matrix<float, boost::numeric::ublas::basic_row_major<size_t, ptrdiff_t>, boost::numeric::ublas::unbounded_array<float, std::allocator<float> > >, boost::numeric::ublas::matrix_matrix_prod<float, float, float> >, E2 = boost::numeric::ublas::matrix_unary2<boost::numeric::ublas::matrix<float, boost::numeric::ublas::basic_row_major<size_t, ptrdiff_t>, boost::numeric::ublas::unbounded_array<float, std::allocator<float> > >, boost::numeric::ublas::scalar_identity<float> >]’:
bad_multiply.cpp:9:   instantiated from here
/opt/local/include/boost/numeric/ublas/matrix_expression.hpp:4815: error: invalid application of ‘sizeof’ to incomplete type ‘boost::STATIC_ASSERTION_FAILURE<false>’

Jim Bosch (1 match)

#6545 boost:::python doesn't recognize std::shared_ptr python USE GITHUB To Be Determined Bugs Feb 11, 2012

boost::python specially handles boost::shared_ptr, but special handling is also needed for std::shared_ptr

Jeremiah Willcock (2 matches)

#3077 Reverse iterator compile-time bug in multi_array multi_array Boost 1.40.0 Bugs May 25, 2009

I'm having some trouble iterating over a 2-dimensional multi_array in reverse order. I'm using boost 1.38 with gcc-4.2.4 and the following code won't compile with the error given below: 

#include <boost/multi_array.hpp>

template< typename It >
void
iterate_over( It begin, It end )
{
    while( end != begin ) {
        begin->end() - begin->begin();
        ++begin;
    }
}

void
test()
{
    boost::multi_array< double, 2 > m;
    iterate_over( m.begin(), m.end() );   // works fine
    iterate_over( m.rbegin(), m.rend() ); // causes error
}

This looks to me like a bug in the implementation of the reverse iterator for multi_array. Am I wrong? It is only a problem when iterator::operator-> is used. The (*begin). notation works fine.

/home/john/Dev/ThirdParty/boost/boost_1_38_0/boost/iterator/iterator_facade.hpp: In static member function ‘static typename boost::mpl::if_<boost::is_reference<Reference>, Pointer, boost::detail::operator_arrow_proxy<ValueType> >::type boost::detail::operator_arrow_result<ValueType, Reference, Pointer>::make(Reference) [with ValueType = boost::multi_array<double, 1ul, std::allocator<double> >, Reference = boost::detail::multi_array::sub_array<double, 1ul>, Pointer = boost::multi_array<double, 1ul, std::allocator<double> >*]’: /home/john/Dev/ThirdParty/boost/boost_1_38_0/boost/iterator/iterator_facade.hpp:648: instantiated from ‘typename boost::detail::operator_arrow_result<typename boost::detail::iterator_facade_types<Value, CategoryOrTraversal, Reference, Difference>::value_type, Reference, typename boost::detail::iterator_facade_types<Value, CategoryOrTraversal, Reference, Difference>::pointer>::type boost::iterator_facade<I, V, TC, R, D>::operator->() const [with Derived = boost::reverse_iterator<boost::detail::multi_array::array_iterator<double, double*, mpl_::size_t<2ul>, boost::detail::multi_array::sub_array<double, 1ul> > >, Value = boost::multi_array<double, 1ul, std::allocator<double> >, CategoryOrTraversal = boost::detail::iterator_category_with_traversal<std::input_iterator_tag, boost::random_access_traversal_tag>, Reference = boost::detail::multi_array::sub_array<double, 1ul>, Difference = long int]’ src/sandbox/seqan_sandbox.cpp:12: instantiated from ‘void iterate_over(It, It) [with It = boost::reverse_iterator<boost::detail::multi_array::array_iterator<double, double*, mpl_::size_t<2ul>, boost::detail::multi_array::sub_array<double, 1ul> > >]’ src/sandbox/seqan_sandbox.cpp:22: instantiated from here /home/john/Dev/ThirdParty/boost/boost_1_38_0/boost/iterator/iterator_facade.hpp:326: error: no matching function for call to ‘implicit_cast(boost::detail::multi_array::sub_array<double, 1ul>*)’

#5636 BGL isomorphism vertex invariant interface change graph To Be Determined Feature Requests Jun 23, 2011

(This is the last isomorphism ticket I think. :-))

I have one more suggestion about how to handle vertex invariants. To determine whether u and v should be considered equivalent by the isomorphism, instead of providing two functors f and g, calling f(u) and g(v) to get a pair of integers, and finally comparing the result, I think it would be cleaner to have a "binary" predicate p which would be called as p(u,v). (In reality of course you'd probably want to have it receive g1 and g2 as well, so it'd really be a 4-arg function.) This should also let you get rid of the vertex_max_invariant parameter perhaps.

I'm not sure of how this would impact the performance or how you'd do sorting, but you could probably do it by doing an N2 traversal and recording for each u in g1 how many vs in g2 are considered equivalent. This is a bit different from what you're doing now, I think.

(The benefit of this would be it becomes easier to impose extra conditions on the isomorphism. Instead of figuring out how to encode everything into an integer -- and worrying about the fact that you make an array of size vertex_max_invariant, so you can't even use all that much of that size -- you can just test it directly.)

Jürgen Hunold (1 match)

#6893 Inaccurate Radians/Degrees conversion units To Be Determined Bugs May 13, 2012

LS,

The conversion from angles in degrees to radians currently uses a conversion factor of 6.28318530718/360. (File: boost\units\base_units\angle\degree.hpp), which equals 0.0174532925199444444...

This is unnecessarily inaccurate (only 14 significant digits are correct) and gives problems in my application - the actual value reads: 0.017453292519943295769236907684886127134428718885417...

Using this value improves conversion accuracy significantly.

Please consider using this more accurate value. Alternatively, the use of boost::math::constants could be considered, making the factor: boost::math::constants::pi<double>()/180.0 which works fine as well.

James E. King, III (3 matches)

#2801 gregorian_calendar_base: incorrectly assumes that sizeof(int)==sizeof(long) date_time To Be Determined Bugs Feb 25, 2009

boost::date_time::gregorian_calendar_base() returns an int, but uses several local variables of type unsigned long, leading to warnings about possible loss of data when converting from unsigned long to int on 64 bit OSes that use the LP64 data model.

Here is a rewrite of the function that generates no warnings when compiled with -Wshorten-64-to-32 under GCC 4.0.1 on Mac OS 10.5: 

  template<typename ymd_type_, typename date_int_type_>
  BOOST_DATE_TIME_INLINE
  int
  gregorian_calendar_base<ymd_type_,date_int_type_>::week_number(const ymd_type& ymd) {
    date_int_type_ julianbegin = julian_day_number(ymd_type(ymd.year,1,1));
    date_int_type_ juliantoday = julian_day_number(ymd);
    date_int_type_ day = (julianbegin + 3) % 7;
    date_int_type_ week = (juliantoday + day - julianbegin + 4)/7;
    
    if ((week >= 1) && (week <= 52)) {
      return static_cast<int>(week);
    }
    
    if ((week == 53)) {
      if((day==6) ||(day == 5 && is_leap_year(ymd.year))) {
        return static_cast<int>(week); //under these circumstances week == 53.
      } else {
        return 1; //monday - wednesday is in week 1 of next year
      }
    }
    //if the week is not in current year recalculate using the previous year as the beginning year
    else if (week == 0) {
      julianbegin = julian_day_number(ymd_type(static_cast<unsigned short>(ymd.year-1),1,1));
      juliantoday = julian_day_number(ymd);
      day = (julianbegin + 3) % 7;
      week = (juliantoday + day - julianbegin + 4)/7;
      return static_cast<int>(week);
    }
    
    return static_cast<int>(week);  //not reachable -- well except if day == 5 and is_leap_year != true
    
  }
#10285 local_time is not monotonic date_time To Be Determined Bugs Aug 1, 2014

The following snippet seems to generate non monotonic local_date.

I'm using boost 1.55 on linux.

#include <boost/date_time/local_time/local_time.hpp> #include <boost/ptr_container/ptr_vector.hpp>

int main() {

const boost::local_time::time_zone_ptr theTimeZone(

new boost::local_time::posix_time_zone(

"CET+01CEST+01,M3.5.0/02:00,M10.5.0/03:00")

);

boost::local_time::local_date_time myOldValue(

boost::local_time::local_microsec_clock::local_time(theTimeZone));

for (size_t i = 0; ; ++i) {

const boost::local_time::local_date_time myLocalTime =

boost::local_time::local_microsec_clock::local_time(theTimeZone);

if (myLocalTime < myOldValue) {

std::cout << myOldValue << std::endl; std::cout << myLocalTime << std::endl; std::cout << boost::local_time::local_microsec_clock::local_time(theTimeZone) << std::endl; std::cout << "====================" << std::endl;

}

myOldValue = myLocalTime;

}

}

As you can see the program is not supposed to print anything ever, however this is what I'm getting:

2014-Jul-31 00:24:56.005625 CEST 2014-Jul-31 00:24:55.005631 CEST <== 1 second back 2014-Jul-31 00:24:56.005946 CEST ==================== 2014-Jul-31 00:24:58.005625 CEST 2014-Jul-31 00:24:57.005629 CEST <== 1 second back 2014-Jul-31 00:24:58.005824 CEST ==================== 2014-Jul-31 00:25:02.005624 CEST 2014-Jul-31 00:25:01.005628 CEST <== 1 second back 2014-Jul-31 00:25:02.005838 CEST ==================== 2014-Jul-31 00:25:04.005625 CEST 2014-Jul-31 00:25:03.005630 CEST <== 1 second back 2014-Jul-31 00:25:04.005826 CEST ==================== 2014-Jul-31 00:25:06.005624 CEST 2014-Jul-31 00:25:05.005633 CEST <== 1 second back 2014-Jul-31 00:25:06.005853 CEST ==================== 2014-Jul-31 00:25:07.005625 CEST 2014-Jul-31 00:25:06.005631 CEST <== 1 second back 2014-Jul-31 00:25:07.005846 CEST ==================== 2014-Jul-31 00:25:12.005625 CEST 2014-Jul-31 00:25:11.005631 CEST <== 1 second back 2014-Jul-31 00:25:12.005822 CEST ====================

as you can see when the local_date is near 0.005631 second fraction it goes back of one second and then forward again on the following call.

#11067 boost::gregorian::date_iterator missing postfix operators ++ and -- date_time To Be Determined Feature Requests Mar 3, 2015

/* Consider the following (somewhat canonical) code snippet */ {

std::vector<boost::gregorian::date> dates(count); auto dt_i = dates.begin(); boost::gregorian::month_iterator m_i(some_start_date, 1);

while (dt_i != dts.end())

*dt_i++ = *m_i++; /* this will call prefix ++ operator on m_i

leading to subtle bug */

}

John Maddock (2 matches)

#10103 setprecision(0) does displays too many digits of a float128 multiprecision To Be Determined Bugs Jun 7, 2014

setprecision(0) is not honored for float128. Compare the display of a double and a float128 (default and fixed): 

0.1 0.123400000000000000000000000000000006
0 0.123400000000000000000000000000000006

This is produced with 

#include <iostream>
#include <boost/multiprecision/float128.hpp>

int main() {
  double x = 0.1234;
  boost::multiprecision::float128 y = 0.1234Q;
  std::cout << std::setprecision(0) << x << " " << y << "\n";
  std::cout << std::fixed << x << " " << y << "\n";
}
#3408 gamma distribution's quantile performance math Boost 1.41.0 Tasks Sep 6, 2009

Hi there, I have created a test which times the performance of boost::math::quantile( ... ) when using a gamma distribution. I ran it against source code we use here at work, for ages. It can be found here:

​http://people.sc.fsu.edu/~burkardt/cpp_src/dcdflib/dcdflib.html

The old source code is about 2x times faster than the boost version.

MS Visual Studio 2005: boost: 35.4sec att_bell:19sec

Intel 11.1: boost: 21.4sec att_bell: 11.2sec

Question is if there is a way to incorporate such a function into boost::math? As far, as I can tell the results are almost identical.

Here the code:

#include <dcdflib.h>

#include <boost/math/distributions/gamma.hpp>

#include <boost/timer.hpp>

double min_mean = 2000; 2,000 double max_mean = 500000000; 500,000,000

double min_std = 10000; 10,000 double max_std = 100000000; 100,000,000

double min_max = 600000000; 600,000,000 double max_max = 1000000000; 1,000,000,000

const std::size_t max_year = 5000000; 5,000,000

const double right = 0.999; const double left = 0.001;

inline double get_rand() {

return static_cast< double >( std::rand() )

/ static_cast< double >( RAND_MAX );

}

inline void boost_( boost::math::gamma_distribution<>& d, double q ) {

double value = boost::math::quantile( d, q );

}

inline void att_bell( double alpha, double beta, double q ) {

double q_Minus1 = 1 - q; double value = 0.0; double bound = 0.0;

int which = 2; int status = 0;

cdfgam( &which

, &q , &q_Minus1 , &value , &alpha , &beta , &status , &bound );

}

int main() {

boost {

std::srand( 0 );

boost::timer timer; for( std::size_t y = 0; y < max_year; ++y ) {

if(( y % 100000 ) == 0 )

std::cout << y << std::endl;

double mean = get_rand() * ( max_mean - min_mean ) + min_mean; double std = get_rand() * ( max_std - min_std ) + min_std;

double alpha = mean * mean / std / std; shape parameter double beta = mean / alpha; scale parameter

boost::math::gamma_distribution<> d( alpha, beta ); boost_( d, right ); boost_( d, left );

}

std::cout << "Boost - Time elapsed: " << timer.elapsed() << "

sec" << std::endl;

}

att bell {

std::srand( 0 );

boost::timer timer; for( std::size_t y = 0; y < max_year; ++y ) {

if(( y % 100000 ) == 0 )

std::cout << y << std::endl;

double mean = get_rand() * ( max_mean - min_mean ) + min_mean; double std = get_rand() * ( max_std - min_std ) + min_std;

double alpha = mean * mean / std / std; shape parameter double beta = mean / alpha; scale parameter

att_bell( alpha, beta, right ); att_bell( alpha, beta, left );

}

std::cout << "ATT Bell - Time elapsed: " << timer.elapsed() <<

" sec" << std::endl;

}

return 0;

}

karsten (1 match)

#10946 Add dt to system arguments odeint To Be Determined Feature Requests Jan 20, 2015

A popular algorithm for calculating the change in velocity of a charged particle in a magnetic field (1) requires the length of the time step while integrating (dx/dt := f(x,t,dt)) and cannot be used with odeint as far as I could tell so I suggest modifying the definition of system from sys( x , dxdt , t ) to sys( x , dxdt , t , dt ). Some enable_if magic should allow all existing code using the current API to work.

(1) Equations 25 and 26 in (h)ttp://www.dtic.mil/dtic/tr/fulltext/u2/a023511.pdf

Marshall Clow (7 matches)

#7494 boost::replace_all is very slow on debug build when Format size is big string_algo To Be Determined Bugs Oct 11, 2012

Method boost::replace_all(SequenceT& Input, const Range1T& Search, const Range2T& Format) on debug build takes very long time when Format size is about 300k. On call stack I can see push_front for every char.

When I use std::find and std::replace in loop it is cca 10 times faster.

I have Boost library 1.45, Visual Studio 2010, Win7 x64 SP1, 6-core CPU.

#6160 support for (istream >> array < char >) array To Be Determined Feature Requests Nov 22, 2011
  1. array < T > is a replacement for T []
  2. the standard library provides the syntax (istream >> char []) and (ostream << char const [])
  3. Currently, (istream >> array < char >) does not mean anything
  4. this functionality cannot be simulated even with std:: copy_n < istreambuf_iterator > without manual termination and much verbosity

My implementation

#include <boost/array.hpp>      /* for ::boost:: array */
#include <boost/version.hpp>

#if +BOOST_VERSION <= 0313720
#include <iomanip>      /* for ::std:: setw */
namespace boost 
{ 
/* helper classes to prevent ambiguity in matching array < char > */
namespace detail_
{ 
/* normally, other char for every character type is char */
  template < class P_C > class other_char { public: typedef char type; }; 
/* but other_char is undefined for char */
  template <> class other_char < char > {}; 
/* class same_stream fails for istream */
  template 
  < class P_S, 
    class P_C = typename other_char < typename P_S:: char_type >:: type >
class same_stream { public: typedef P_S stream; }; }
/* template input */
  template < class P_C, class P_T, ::std:: size_t P_N > 
  static inline ::std:: basic_istream < P_C, P_T >
&operator >> 
  (::std:: basic_istream < P_C, P_T > &p_s, ::boost:: array < P_C, P_N > &p_a) 
  { return p_s >> ::std:: setw (p_a. static_size) >> p_a. data (); } 
/* character input, disabled for type char to avoid ambiguity */
  template < class P_C, class P_T, ::std:: size_t P_N > 
  static inline typename
  detail_:: same_stream 
< ::std:: basic_istream < P_C, P_T > >:: stream
&operator >> 
  (::std:: basic_istream < P_C, P_T > &p_s, 
   ::boost:: array < char, P_N > &p_a) 
  { return p_s >> ::std:: setw (p_a. static_size) >> p_a. data (); } 
/* template output */
  template < class P_C, class P_T, ::std:: size_t P_N > 
  static inline ::std:: basic_ostream < P_C, P_T > 
  &operator << 
(::std:: basic_ostream < P_C, P_T > &p_s, 
 ::boost:: array < P_C, P_N > const &p_a) { return p_s << p_a. begin (); }
/* character output, disabled for type char */
  template < class P_C, class P_T, ::std:: size_t P_N > 
  static inline 
typename detail_:: same_stream < ::std:: basic_ostream < P_C, P_T > >:: stream
  &operator << 
(::std:: basic_ostream < P_C, P_T > &p_s, 
 ::boost:: array < char, P_N > const &p_a) 
{ return p_s << p_a. begin (); }}
#endif  /* BOOST_VERSION */

#include <cstdlib>      /* for EXIT_SUCCESS */
#include <cstdio>       /* for BUFSIZ */
#include <iostream>     /* for ::std:: cin */

int main () 
{ // char (&x) [+BOOST_VERSION] = 0;
#ifdef ARRAY_IN_NATIVE
/* native code */
char t [+BUFSIZ]; 
 return 
   ::std:: cin >> ::std:: setw (+BUFSIZ) >> t && ::std:: cout << t << '\n'? 
+EXIT_SUCCESS: +EXIT_FAILURE; 
#else /* ARRAY_IN_NATIVE */
/* equivalent Boost code */
 ::boost:: array < char, +BUFSIZ > t; 
/* check that character input compiles for wchar_t */
 (void) sizeof (std:: wcin >> t);
 return 
::std:: cin >> t && ::std:: cout << t << '\n'? +EXIT_SUCCESS: +EXIT_FAILURE;
#endif /* ARRAY_IN_NATIVE */
}
#6683 find family of functions needs const Range1T& Input overloads algorithm To Be Determined Feature Requests Mar 13, 2012

It's cumbersome to have to create named temporaries when searching using these functions. I presume the reason for why Input isn't const is due to the fact that iterator_range<> that's returned can modify Input. In the spirit of std & the rest of boost I propose an overload which returns const_iterator_range<>, which would provide the same functionality as iterator_range<> save for being able to modify the source.

#6793 Support construction from range array To Be Determined Feature Requests Apr 14, 2012

Could you support construction from a range and from an iterator pair? I don't know what to do when the input doesn't match the array size. If it's smaller you could default construct the rest of the array. If it's larger, you could truncate, std::terminate() or throw. Or just consider it undefined behaviour.

#7652 compile-time checked access array Boost 1.54.0 Feature Requests Nov 6, 2012

Since code like

boost::array<int,2> test; test[2] = 1; test[-1] = 1;

compiles correctly on some compilers (even without warnings). I suggest adding compile checked functions for static access to arrays like:

template<size_type i> reference at() {

BOOST_STATIC_ASSERT( (i < N) ); return elems[i];

}

template<size_type i> const_reference at() const {

BOOST_STATIC_ASSERT( (i < N) ); return elems[i];

}

then code like:

boost::array<int,2> test; test.at<2> = 1; test.at<-1> = 1;

would result in the expected errors.

#9287 Additional string_ref constructors utility To Be Determined Feature Requests Oct 22, 2013

From:

  • iterator_range<Char const *>
  • std::vector<Char>
  • pair of iterators
#9576 read_until for string_ref algorithm To Be Determined Feature Requests Jan 15, 2014 
string_ref read_until(string_ref& is, const char* sep);

Could we have a function like this that reads until a separator, returns the part before the separator and then eats the separator? It should read and return the entire input if no separator is found.

1 2 3 →
Note: See TracReports for help on using and creating reports.