librtree 0.9.0 → 1.0.0

data/ext/rtree/lib/rect.c

@@ -0,0 +1,139 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "rtree/rect.h"
+#include "rtree/error.h"
+
+#ifdef HAVE_TGMATH_H
+#include <tgmath.h>
+#else
+#include <math.h>
+#endif
+
+#ifdef HAVE_FEATURES_H
+#include <features.h>
+#endif
+
+#include <string.h>
+#include <errno.h>
+
+int rect_init(const state_t *state, rtree_coord_t *rect)
+{
+  if (rect == NULL)
+    return RTREE_ERR_INVAL;
+
+#ifdef __STDC_IEC_559__
+
+  memset(rect, 0, state_rect_size(state));
+
+#else
+
+  const size_t dims = state_dims(state);
+
+  for (size_t i = 0 ; i < 2 * dims ; i++)
+    rect[i] = 0;
+
+#endif
+
+  return RTREE_OK;
+}
+
+bool rect_intersect(const state_t *state,
+                    const rtree_coord_t *a, const rtree_coord_t *b)
+{
+  const size_t dims = state_dims(state);
+
+  for (size_t dim = 0 ; dim < dims ; dim++)
+    {
+      const size_t
+        low = dim,
+        high = dim + dims;
+
+      if ((a[high] < b[low]) || (a[low] > b[high]))
+        return false;
+    }
+
+  return true;
+}
+
+rtree_coord_t rect_volume(const state_t *state, const rtree_coord_t *rect)
+{
+  const size_t dims = state_dims(state);
+  rtree_coord_t v = rect[dims] - rect[0];
+
+  for (size_t i = 1 ; i < dims ; i++)
+    v *= (rect[dims + i] - rect[i]);
+
+  return v;
+}
+
+rtree_coord_t rect_spherical_volume(const state_t *state,
+                                    const rtree_coord_t *rect)
+{
+  return state_rsv(state, rect);
+}
+
+void rect_copy(const state_t *state, const rtree_coord_t *src,
+               rtree_coord_t *dest)
+{
+  memcpy(dest, src, state_rect_size(state));
+}
+
+
+void rect_combine(const state_t *state,
+                  const rtree_coord_t *restrict rect0,
+                  const rtree_coord_t *restrict rect1,
+                  rtree_coord_t *restrict rect2)
+{
+  state_rc(state, rect0, rect1, rect2);
+}
+
+void rect_merge(const state_t *state,
+                const rtree_coord_t *rect0,
+                rtree_coord_t *rect1)
+{
+  state_rc(state, rect0, rect1, rect1);
+}
+
+bool rect_identical(const state_t *state,
+                    const rtree_coord_t *rect0,
+                    const rtree_coord_t *rect1)
+{
+  for (size_t i = 0 ; i < 2 * state_dims(state) ; i++)
+    if (rect0[i] != rect1[i]) return false;
+  return true;
+}
+
+/*
+  Allocates n rectangles (as rtree_coord_t*) and assigns them to the
+  elements of the array rects, which should already be allocated (so
+  one would pass 'array' declared as rtree_coord_t *array[2], for
+  example).
+*/
+
+int rects_alloc(const state_t *state, size_t n, rtree_coord_t **rects)
+{
+  const size_t
+    dims = state_dims(state),
+    rect_size = state_rect_size(state);
+  rtree_coord_t *floats;
+
+  if ((floats = calloc(n, rect_size)) == NULL)
+    return RTREE_ERR_NOMEM;
+
+  *rects = floats;
+
+  for (size_t i = 1 ; i < n ; i++)
+    rects[i] = floats + 2 * i * dims;
+
+  return RTREE_OK;
+}
+
+void rects_free(size_t n, rtree_coord_t **rects)
+{
+  free(*rects);
+
+  for (size_t i = 0 ; i < n ; i++)
+    rects[i] = NULL;
+}

data/ext/rtree/lib/rectf.c

@@ -0,0 +1,219 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "rtree/rectf.h"
+
+#ifdef HAVE_TGMATH_H
+#include <tgmath.h>
+#else
+#include <math.h>
+#endif
+
+#ifdef HAVE_XMMINTRIN_H
+#include <xmmintrin.h>
+#endif
+
+#ifdef HAVE_IMMINTRIN_H
+#include <immintrin.h>
+#endif
+
+/*
+  rect_spherical_volume has some simplifications for small dimensions
+  (one need not call pow(), for example), and it gets called a lot so
+  worth selecting which to use just the once.
+*/
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+
+rtree_coord_t rectf_rsv1(size_t dims, const rtree_coord_t *rect)
+{
+  return 0.5 * fabs(rect[1] - rect[0]);
+}
+
+rtree_coord_t rectf_rsv2(size_t dims, const rtree_coord_t *rect)
+{
+  rtree_coord_t
+    hx1 = rect[2] - rect[0],
+    hx2 = rect[3] - rect[1],
+    r2 = hx1 * hx1 + hx2 * hx2;
+
+  return 0.25 * r2;
+}
+
+#pragma GCC diagnostic pop
+
+rtree_coord_t rectf_rsvd(size_t dims, const rtree_coord_t *rect)
+{
+  rtree_coord_t
+    hx = rect[dims] - rect[0],
+    r2 = hx * hx;
+
+  for (size_t i = 1 ; i < dims ; i++)
+    {
+      hx = rect[i + dims] - rect[i];
+      r2 += hx * hx;
+    }
+
+  return pow(0.25 * r2, 0.5 * dims);
+}
+
+rectf_rsv_t* rectf_spherical_volume(size_t dims)
+{
+  switch (dims)
+    {
+    case 1:
+      return rectf_rsv1;
+    case 2:
+      return rectf_rsv2;
+    default:
+      return rectf_rsvd;
+    }
+}
+
+/*
+  rect_combine is performance-critical, and we use the same trick
+  for cases where the entire rectangle fits in a wide register:
+  the 128-bit register (SSE2) in the dim-2 float case, the 256
+  register (AVX) in the dim-3, -4 float and dim-2 double case. for
+  the first, We XOR with the "sign-mask" { 0, 0, -0, -0 } to sign
+  change the last two values, then find the min, then XOR again.
+  The result is the min of the bottom two values, the max of the
+  top two.
+
+  The dim-4 float and dim-2 double cases are similar, the dim-3
+  float  version is the trickiest since we need to load 6 floats
+  into an 8-float register, so we need a mask (which is an AVX
+  facility).
+*/
+
+void rectf_rcd(size_t dims,
+               const rtree_coord_t *rect0,
+               const rtree_coord_t *rect1,
+               rtree_coord_t *rect2)
+{
+  for (size_t i = 0 ; i < dims ; i++)
+    {
+      const size_t j = i + dims;
+      const rtree_coord_t
+        x0 = rect0[i], x1 = rect1[i],
+        y0 = rect0[j], y1 = rect1[j];
+
+      rect2[i] = fmin(x0, x1);
+      rect2[j] = fmax(y0, y1);
+    }
+}
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+
+#if SIZEOF_RTREE_COORD_T == 4
+
+#ifdef HAVE_SSE2
+
+void rectf_rc2(size_t dims,
+               const rtree_coord_t *rect0,
+               const rtree_coord_t *rect1,
+               rtree_coord_t *rect2)
+{
+  const __m128
+    sm = { 0.0f, 0.0f, -0.0f, -0.0f },
+    sr0 = _mm_loadu_ps(rect0),
+    sr1 = _mm_loadu_ps(rect1),
+    srmin = _mm_min_ps(_mm_xor_ps(sm, sr0), _mm_xor_ps(sm, sr1)),
+    res = _mm_xor_ps(sm, srmin);
+
+  _mm_storeu_ps(rect2, res);
+}
+
+
+#endif
+
+#ifdef HAVE_AVX
+
+void rectf_rc3(size_t dims,
+               const rtree_coord_t *rect0,
+               const rtree_coord_t *rect1,
+               rtree_coord_t *rect2)
+{
+  const __m256i
+    mask = _mm256_setr_epi32(-1, -1, -1, -1, -1, -1, 0, 0);
+  const __m256
+    sm = { 0.0f, 0.0f, 0.0f, -0.0f, -0.0f, -0.0f, 0.0f, 0.0f },
+    sr0 = _mm256_maskload_ps(rect0, mask),
+    sr1 = _mm256_maskload_ps(rect1, mask),
+    srmin = _mm256_min_ps(_mm256_xor_ps(sm, sr0), _mm256_xor_ps(sm, sr1)),
+    res = _mm256_xor_ps(sm, srmin);
+
+  _mm256_maskstore_ps(rect2, mask, res);
+}
+
+void rectf_rc4(size_t dims,
+               const rtree_coord_t *rect0,
+               const rtree_coord_t *rect1,
+               rtree_coord_t *rect2)
+{
+  const __m256
+    sm = { 0.0f, 0.0f, 0.0f, 0.0f, -0.0f, -0.0f, -0.0f, -0.0f },
+    sr0 = _mm256_loadu_ps(rect0),
+    sr1 = _mm256_loadu_ps(rect1),
+    srmin = _mm256_min_ps(_mm256_xor_ps(sm, sr0), _mm256_xor_ps(sm, sr1)),
+    res = _mm256_xor_ps(sm, srmin);
+
+  _mm256_storeu_ps(rect2, res);
+}
+
+#endif
+
+#elif SIZEOF_RTREE_COORD_T == 8
+
+#ifdef HAVE_AVX
+
+void rectf_rc2(size_t dims,
+               const rtree_coord_t *rect0,
+               const rtree_coord_t *rect1,
+               rtree_coord_t *rect2)
+{
+  const __m256d
+    sm = { 0.0, 0.0, -0.0, -0.0 },
+    sr0 = _mm256_loadu_pd(rect0),
+    sr1 = _mm256_loadu_pd(rect1),
+    srmin = _mm256_min_pd(_mm256_xor_pd(sm, sr0), _mm256_xor_pd(sm, sr1)),
+    res = _mm256_xor_pd(sm, srmin);
+
+  _mm256_storeu_pd(rect2, res);
+}
+
+#endif
+
+#else
+#error "strange size for rtree_coord_t"
+#endif
+
+#pragma GCC diagnostic pop
+
+rectf_rc_t* rectf_combine(size_t dims)
+{
+  switch (dims)
+    {
+
+#if SIZEOF_RTREE_COORD_T == 4
+# ifdef HAVE_SSE2
+    case 2: return rectf_rc2;
+# endif
+# ifdef HAVE_AVX
+    case 3: return rectf_rc3;
+    case 4: return rectf_rc4;
+# endif
+#elif SIZEOF_RTREE_COORD_T == 8
+# ifdef HAVE_AVX
+    case 2: return rectf_rc2;
+# endif
+#else
+# error "strange size for rtree_coord_t"
+#endif
+
+    default: return rectf_rcd;
+    }
+}

data/ext/rtree/lib/rtree/branch.h

@@ -0,0 +1,105 @@
+/*
+  rtree/branch.h
+  Copyright (c) J.J. Green 2019
+*/
+
+#ifndef RTREE_BRANCH_H
+#define RTREE_BRANCH_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdlib.h>
+
+typedef struct branch_t branch_t;
+
+#include <rtree/types.h>
+#include <rtree/state.h>
+#include <rtree/node.h>
+#include <rtree/rect.h>
+
+/*
+  The union is either a pointer to the child-node in the tree, or
+  if we are at level zero, the id payload.  The latter may as well
+  be the size of a pointer.
+
+  The rect is big enough to hold 2 * dims floats, understood to be
+  [x0, y0, ..., x1, y1, ...] corresponding to the (hyper-)rectangle
+  x0 < x < x1, y0 < y < y1, ..., this must be at the end of the
+  struct (since variable).
+
+  For the sake of SSE, we would like the rect member to be 16-byte
+  aligned, and this could be done with
+
+    rtree_coord_t alignas(16) rect[];
+
+  but this would force the size of branch_t to be a multiple of 16,
+  so for the dimension 2 case with rtree_coord_t a float increases
+  branch size from 24 to 32 bytes, essentially increasing the size
+  of the tree by 20%.  So we don't do that, and use non-aligned
+  variants for SSE load/save (apparently on recent CPUs the penalty
+  is pretty small).
+*/
+
+struct branch_t
+{
+  union {
+    node_t *child;
+    rtree_id_t id;
+  };
+  rtree_coord_t rect[];
+};
+
+size_t branch_sizeof(size_t);
+int branch_init(const state_t*, branch_t*);
+branch_t* branch_copy(const state_t*, const branch_t*, branch_t*);
+
+/* inline accessors */
+
+inline void branch_set_child(branch_t *branch, node_t *child)
+{
+  branch->child = child;
+}
+
+inline const node_t* branch_get_child(const branch_t *branch)
+{
+  return branch->child;
+}
+
+inline node_t* branch_get_child_mutable(branch_t *branch)
+{
+  return branch->child;
+}
+
+inline void branch_set_id(branch_t *branch, rtree_id_t id)
+{
+  branch->id = id;
+}
+
+inline rtree_id_t branch_get_id(const branch_t *branch)
+{
+  return branch->id;
+}
+
+inline void branch_set_rect(const state_t *state, branch_t *branch,
+                            const rtree_coord_t *rect)
+{
+  rect_copy(state, rect, branch->rect);
+}
+
+inline const rtree_coord_t* branch_get_rect(const branch_t *branch)
+{
+  return branch->rect;
+}
+
+inline rtree_coord_t* branch_get_rect_mutable(branch_t *branch)
+{
+  return branch->rect;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/rtree/lib/rtree/branches.h

@@ -0,0 +1,38 @@
+/*
+  rtree/branches.h
+  Copyright (c) J.J. Green 2020
+*/
+
+#ifndef RTREE_BRANCHES_H
+#define RTREE_BRANCHES_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
+
+#include <rtree/state.h>
+#include <rtree/branch.h>
+#include <rtree/error.h>
+
+inline branch_t* branches_get(const state_t *state, void *buffer, size_t i)
+{
+  const size_t branch_size = state_branch_size(state);
+  char *bytes = (char*)buffer;
+  return (branch_t*)(bytes + i * branch_size);
+}
+
+inline void branches_set(const state_t *state, void *buffer, size_t i,
+                         const branch_t *src)
+{
+  memcpy(branches_get(state, buffer, i), src, state_branch_size(state));
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/rtree/lib/rtree/error.h

@@ -0,0 +1,42 @@
+/*
+  rtree/error.h
+  Copyright (c) J.J. Green 2020
+*/
+
+#ifndef RTREE_ERROR_H
+#define RTREE_ERROR_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define RTREE_OK 0
+#define RTREE_ERR_INVAL 1
+#define RTREE_ERR_DOM 2
+#define RTREE_ERR_NOMEM 3
+#define RTREE_ERR_CSVPARSE 4
+#define RTREE_ERR_NOCSV 5
+#define RTREE_ERR_JANSSON 6
+#define RTREE_ERR_NOJSON 7
+#define RTREE_ERR_NOBSRT 8
+#define RTREE_ERR_GETBRANCH 9
+#define RTREE_ERR_GETCHILD 10
+#define RTREE_ERR_NODECLONE 11
+#define RTREE_ERR_PICKBRANCH 12
+#define RTREE_ERR_ADDRECT 13
+#define RTREE_ERR_NOSUCHSPLIT 14
+#define RTREE_ERR_DIMS 15
+#define RTREE_ERR_EMPTY 16
+#define RTREE_ERR_BUFFER 17
+#define RTREE_ERR_POSTSCRIPT 18
+#define RTREE_ERR_USER 19
+#define RTREE_ERR_FWRITE 20
+#define RTREE_ERR_SPLIT 21
+
+const char* strerror_rtree(int);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/rtree/lib/rtree/extent.h

@@ -0,0 +1,20 @@
+/*
+  rtree/extent.h
+  Just an enum indicating a choice of axis (direction)
+  Copyright (c) J.J. Green 2020
+*/
+
+#ifndef RTREE_EXTENT_H
+#define RTREE_EXTENT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum { axis_width, axis_height } extent_axis_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/rtree/lib/rtree/node.h

@@ -0,0 +1,92 @@
+/*
+  rtree/node.h
+  Copyright (c) J.J. Green 2019
+*/
+
+#ifndef RTREE_NODE_H
+#define RTREE_NODE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+
+typedef uint16_t node_level_t;
+typedef uint16_t node_count_t;
+typedef uint16_t node_height_t;
+
+#define NODE_LEVEL_MAX UINT16_MAX
+#define NODE_COUNT_MAX UINT16_MAX
+
+typedef struct node_t node_t;
+
+#include <rtree/types.h>
+#include <rtree/state.h>
+#include <rtree/branch.h>
+
+struct node_t
+{
+  node_level_t level;
+  node_count_t count;
+  char branches[];
+};
+
+typedef int (rtree_update_t)(rtree_id_t, rtree_coord_t*, void*);
+typedef int (nbe_cb_t)(const state_t*, const branch_t*, void*);
+
+int node_init(const state_t*, node_t*);
+node_t* node_new(const state_t*);
+void node_destroy(const state_t*, node_t*);
+node_t* node_clone(const state_t*, const node_t*);
+int node_branch_each(const state_t*, const node_t*, nbe_cb_t*, void*);
+int node_branch_each_level(const state_t*, const node_t*, node_level_t,
+                           nbe_cb_t*, void*);
+size_t node_num_branch(size_t, size_t);
+int node_detach_branch(const state_t*, node_t*, size_t);
+node_t* node_add_branch(const state_t*, node_t*, branch_t*);
+int node_envelope(const state_t*, const node_t*, rtree_coord_t*);
+node_t* node_add_rect(const state_t*, rtree_id_t, rtree_coord_t*,
+                      node_t*, node_level_t);
+int node_update(const state_t*, const node_t*, rtree_update_t*, void*);
+bool node_identical(const state_t*, const node_t*, const node_t*);
+node_height_t node_height(const state_t*, const node_t*);
+size_t node_bytes(const state_t*, const node_t*);
+
+inline node_count_t node_count(const node_t *node)
+{
+  return node->count;
+}
+
+inline void node_count_increment(node_t *node)
+{
+  node->count++;
+}
+
+inline void node_count_decrement(node_t *node)
+{
+  node->count--;
+}
+
+inline node_level_t node_level(const node_t *node)
+{
+  return node->level;
+}
+
+inline void node_set_level(node_t *node, node_level_t level)
+{
+  node->level = level;
+}
+
+inline void* node_get_branches(node_t *node)
+{
+  return node->branches;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/rtree/lib/rtree/package.h

@@ -0,0 +1,14 @@
+/*
+  rtree/package.h
+  Copyright (c) J.J. Green 2021
+*/
+
+#ifndef RTREE_PACKAGE_H
+#define RTREE_PACKAGE_H
+
+extern const char *rtree_package_version;
+extern const char *rtree_package_name;
+extern const char *rtree_package_url;
+extern const char *rtree_package_bugreport;
+
+#endif