/* given newpt, which presumably has just been added to our
tree, update all pts with a greater function value in case
newpt is closer to them than their previous closest_pt ...
we can ignore already-minimized points since we never do
local minimization from the same point twice */
static void pts_update_newpt(int n, rb_tree *pts, pt *newpt)
{
rb_node *node = rb_tree_find_gt(pts, (rb_key) newpt);
while (node) {
pt *p = (pt *) node->k;
if (!p->minimized) {
double d = distance2(n, newpt->x, p->x);
if (d < p->closest_pt_d) p->closest_pt_d = d;
}
node = rb_tree_succ(node);
}
}
/* given newlm, which presumably has just been added to our
tree, update all pts with a greater function value in case
newlm is closer to them than their previous closest_lm ...
we can ignore already-minimized points since we never do
local minimization from the same point twice */
static void pts_update_newlm(int n, rb_tree *pts, double *newlm)
{
pt tmp_pt;
rb_node *node;
tmp_pt.f = newlm[0];
node = rb_tree_find_gt(pts, (rb_key) &tmp_pt);
while (node) {
pt *p = (pt *) node->k;
if (!p->minimized) {
double d = distance2(n, newlm+1, p->x);
if (d < p->closest_lm_d) p->closest_lm_d = d;
}
node = rb_tree_succ(node);
}
}
/* Find the lower convex hull of a set of points (x,y) stored in a rb-tree
of pointers to {x,y} arrays sorted in lexographic order by (x,y).
Unlike standard convex hulls, we allow redundant points on the hull,
and even allow duplicate points if allow_dups is nonzero.
The return value is the number of points in the hull, with pointers
stored in hull[i] (should be an array of length >= t->N).
*/
static int convex_hull(rb_tree *t, double **hull, int allow_dups)
{
int nhull = 0;
double minslope;
double xmin, xmax, yminmin, ymaxmin;
rb_node *n, *nmax;
/* Monotone chain algorithm [Andrew, 1979]. */
n = rb_tree_min(t);
if (!n) return 0;
nmax = rb_tree_max(t);
xmin = n->k[0];
yminmin = n->k[1];
xmax = nmax->k[0];
if (allow_dups)
do { /* include any duplicate points at (xmin,yminmin) */
hull[nhull++] = n->k;
n = rb_tree_succ(n);
} while (n && n->k[0] == xmin && n->k[1] == yminmin);
else
hull[nhull++] = n->k;
if (xmin == xmax) return nhull;
/* set nmax = min mode with x == xmax */
#if 0
while (nmax->k[0] == xmax)
nmax = rb_tree_pred(nmax); /* non-NULL since xmin != xmax */
nmax = rb_tree_succ(nmax);
#else
/* performance hack (see also below) */
{
double kshift[2];
kshift[0] = xmax * (1 - 1e-13);
kshift[1] = -HUGE_VAL;
nmax = rb_tree_find_gt(t, kshift); /* non-NULL since xmin != xmax */
}
#endif
ymaxmin = nmax->k[1];
minslope = (ymaxmin - yminmin) / (xmax - xmin);
/* set n = first node with x != xmin */
#if 0
while (n->k[0] == xmin)
n = rb_tree_succ(n); /* non-NULL since xmin != xmax */
#else
/* performance hack (see also below) */
{
double kshift[2];
kshift[0] = xmin * (1 + 1e-13);
kshift[1] = -HUGE_VAL;
n = rb_tree_find_gt(t, kshift); /* non-NULL since xmin != xmax */
}
#endif
for (; n != nmax; n = rb_tree_succ(n)) {
double *k = n->k;
if (k[1] > yminmin + (k[0] - xmin) * minslope)
continue;
/* performance hack: most of the points in DIRECT lie along
vertical lines at a few x values, and we can exploit this */
if (nhull && k[0] == hull[nhull - 1][0]) { /* x == previous x */
if (k[1] > hull[nhull - 1][1]) {
double kshift[2];
/* because of the round to float in rect_diameter, above,
it shouldn't be possible for two diameters (x values)
to have a fractional difference < 1e-13. Note
that k[0] > 0 always in DIRECT */
kshift[0] = k[0] * (1 + 1e-13);
kshift[1] = -HUGE_VAL;
n = rb_tree_pred(rb_tree_find_gt(t, kshift));
continue;
}
else { /* equal y values, add to hull */
if (allow_dups)
hull[nhull++] = k;
continue;
}
}
/* remove points until we are making a "left turn" to k */
while (nhull > 1) {
double *t1 = hull[nhull - 1], *t2;
/* because we allow equal points in our hull, we have
to modify the standard convex-hull algorithm slightly:
we need to look backwards in the hull list until we
find a point t2 != t1 */
int it2 = nhull - 2;
do {
t2 = hull[it2--];
} while (it2 >= 0 && t2[0] == t1[0] && t2[1] == t1[1]);
if (it2 < 0) break;
/* cross product (t1-t2) x (k-t2) > 0 for a left turn: */
if ((t1[0]-t2[0]) * (k[1]-t2[1])
- (t1[1]-t2[1]) * (k[0]-t2[0]) >= 0)
break;
--nhull;
}
hull[nhull++] = k;
}
if (allow_dups)
do { /* include any duplicate points at (xmax,ymaxmin) */
hull[nhull++] = nmax->k;
nmax = rb_tree_succ(nmax);
} while (nmax && nmax->k[0] == xmax && nmax->k[1] == ymaxmin);
else
hull[nhull++] = nmax->k;
return nhull;
}
int main(int argc, char **argv)
{
int N, M;
int *k;
double kd;
rb_tree t;
rb_node *n;
int i, j;
if (argc < 2) {
fprintf(stderr, "Usage: redblack_test Ntest [rand seed]\n");
return 1;
}
N = atoi(argv[1]);
k = (int *) malloc(N * sizeof(int));
rb_tree_init(&t, comp);
srand((unsigned) (argc > 2 ? atoi(argv[2]) : time(NULL)));
for (i = 0; i < N; ++i) {
double *newk = (double *) malloc(sizeof(double));
*newk = (k[i] = rand() % N);
if (!rb_tree_insert(&t, newk)) {
fprintf(stderr, "error in rb_tree_insert\n");
return 1;
}
if (!rb_tree_check(&t)) {
fprintf(stderr, "rb_tree_check_failed after insert!\n");
return 1;
}
}
if (t.N != N) {
fprintf(stderr, "incorrect N (%d) in tree (vs. %d)\n", t.N, N);
return 1;
}
for (i = 0; i < N; ++i) {
kd = k[i];
if (!rb_tree_find(&t, &kd)) {
fprintf(stderr, "rb_tree_find lost %d!\n", k[i]);
return 1;
}
}
n = rb_tree_min(&t);
for (i = 0; i < N; ++i) {
if (!n) {
fprintf(stderr, "not enough successors %d\n!", i);
return 1;
}
printf("%d: %g\n", i, n->k[0]);
n = rb_tree_succ(n);
}
if (n) {
fprintf(stderr, "too many successors!\n");
return 1;
}
n = rb_tree_max(&t);
for (i = 0; i < N; ++i) {
if (!n) {
fprintf(stderr, "not enough predecessors %d\n!", i);
return 1;
}
printf("%d: %g\n", i, n->k[0]);
n = rb_tree_pred(n);
}
if (n) {
fprintf(stderr, "too many predecessors!\n");
return 1;
}
for (M = N; M > 0; --M) {
int knew = rand() % N; /* random new key */
j = rand() % M; /* random original key to replace */
for (i = 0; i < N; ++i)
if (k[i] >= 0)
if (j-- == 0)
break;
if (i >= N)
abort();
kd = k[i];
if (!(n = rb_tree_find(&t, &kd))) {
fprintf(stderr, "rb_tree_find lost %d!\n", k[i]);
return 1;
}
n->k[0] = knew;
if (!rb_tree_resort(&t, n)) {
fprintf(stderr, "error in rb_tree_resort\n");
return 1;
}
if (!rb_tree_check(&t)) {
fprintf(stderr, "rb_tree_check_failed after change %d!\n", N - M + 1);
return 1;
}
k[i] = -1 - knew;
}
if (t.N != N) {
fprintf(stderr, "incorrect N (%d) in tree (vs. %d)\n", t.N, N);
return 1;
}
for (i = 0; i < N; ++i)
k[i] = -1 - k[i]; /* undo negation above */
for (i = 0; i < N; ++i) {
rb_node *le, *gt;
double lek, gtk;
kd = 0.01 * (rand() % (N * 150) - N * 25);
le = rb_tree_find_le(&t, &kd);
gt = rb_tree_find_gt(&t, &kd);
n = rb_tree_min(&t);
lek = le ? le->k[0] : -HUGE_VAL;
gtk = gt ? gt->k[0] : +HUGE_VAL;
printf("%g <= %g < %g\n", lek, kd, gtk);
if (n->k[0] > kd) {
if (le) {
fprintf(stderr, "found invalid le %g for %g\n", lek, kd);
return 1;
}
if (gt != n) {
fprintf(stderr, "gt is not first node for k=%g\n", kd);
return 1;
}
} else {
rb_node *succ = n;
do {
n = succ;
succ = rb_tree_succ(n);
} while (succ && succ->k[0] <= kd);
if (n != le) {
fprintf(stderr, "rb_tree_find_le gave wrong result for k=%g\n", kd);
return 1;
}
if (succ != gt) {
fprintf(stderr, "rb_tree_find_gt gave wrong result for k=%g\n", kd);
return 1;
}
}
}
for (M = N; M > 0; --M) {
j = rand() % M;
for (i = 0; i < N; ++i)
if (k[i] >= 0)
if (j-- == 0)
break;
if (i >= N)
abort();
kd = k[i];
if (!(n = rb_tree_find(&t, &kd))) {
fprintf(stderr, "rb_tree_find lost %d!\n", k[i]);
return 1;
}
n = rb_tree_remove(&t, n);
free(n->k);
free(n);
if (!rb_tree_check(&t)) {
fprintf(stderr, "rb_tree_check_failed after remove!\n");
return 1;
}
k[i] = -1 - k[i];
}
if (t.N != 0) {
fprintf(stderr, "nonzero N (%d) in tree at end\n", t.N);
return 1;
}
rb_tree_destroy(&t);
free(k);
printf("SUCCESS.\n");
return 0;
}
