open-dsi
/
postgres
mirror of https://github.com/postgres/postgres
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

The changes I have made are described in CHANGES. This was based on

Browse Source 
diffs to 7.3-devel and may not be applicable to 7.2. I have included a
change covered by a previous bugfix patch I submitted (the problem with
-.1 not being accepted by cube_in). It does not include a fix for the
potential buffer overrun issue I reported for cube_yyerror in
cubeparse.y.


Bruno Wolff III
REL7_3_STABLE
Bruce Momjian 24 years ago
parent 6d27cfdd89
commit 32784cddf1
8 changed files with 695 additions and 255 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 52
      contrib/cube/README.cube
  2. 449
      contrib/cube/cube.c
  3. 70
      contrib/cube/cube.sql.in
  4. 2
      contrib/cube/cubedata.h
  5. 8
      contrib/cube/cubeparse.y
  6. 2
      contrib/cube/cubescan.l
  7. 291
      contrib/cube/expected/cube.out
  8. 76
      contrib/cube/sql/cube.sql

52
contrib/cube/README.cube
Unescape View File

@ -99,7 +99,7 @@ Tokens
n [0-9]+
integer [+-]?{n}
real [+-]?({n}\.{n}?)|(\.{n})
real [+-]?({n}\.{n}?|\.{n})
FLOAT ({integer}|{real})([eE]{integer})?
O_BRACKET \[
C_BRACKET \]
@ -182,8 +182,8 @@ t
PRECISION
=========
Values are stored internally as 32-bit floating point numbers. This means that
numbers with more than 7 significant digits will be truncated.
Values are stored internally as 64-bit floating point numbers. This means that
numbers with more than about 16 significant digits will be truncated.
USAGE
@ -253,6 +253,44 @@ Other operators:
reasonably good sorting in most cases, which is useful if
you want to use ORDER BY with this type
The following functions are available:
cube_distance(cube, cube) returns double
cube_distance returns the distance between two cubes. If both cubes are
points, this is the normal distance function.
cube(text) returns cube
cube takes text input and returns a cube. This is useful for making cubes
from computed strings.
cube_dim(cube) returns int
cube_dim returns the number of dimensions stored in the the data structure
for a cube. This is useful for constraints on the dimensions of a cube.
cube_ll_coord(cube, int) returns double
cube_ll_coord returns the nth coordinate value for the lower left corner
of a cube. This is useful for doing coordinate transformations.
cube_ur_coord(cube, int) returns double
cube_ur_coord returns the nth coordinate value for the upper right corner
of a cube. This is useful for doing coordinate transformations.
cube_is_point(cube) returns bool
cube_is_point returns true if a cube is also a point. This is true when the
two defining corners are the same.
cube_enlarge(cube, double, int) returns cube
cube_enlarge increases the size of a cube by a specified radius in at least
n dimensions. If the radius is negative the box is shrunk instead. This
is useful for creating bounding boxes around a point for searching for
nearby points. All defined dimensions are changed by the radius. If n
is greater than the number of defined dimensions and the cube is being
increased (r >= 0) then 0 is used as the base for the extra coordinates.
LL coordinates are decreased by r and UR coordinates are increased by r. If
a LL coordinate is increased to larger than the corresponding UR coordinate
(this can only happen when r < 0) than both coordinates are set to their
average.
There are a few other potentially useful functions defined in cube.c
that vanished from the schema because I stopped using them. Some of
these were meant to support type casting. Let me know if I was wrong:
@ -287,3 +325,11 @@ Building 221
Argonne, IL 60439-4844
selkovjr@mcs.anl.gov
------------------------------------------------------------------------
Minor updates to this package were made by Bruno Wolff III <bruno@wolff.to>
in August of 2002.
These include changing the precision from single precision to double
precision and adding some new functions.

449
contrib/cube/cube.c
Unescape View File

@ -28,6 +28,7 @@ extern int cube_yyparse();
** Input/Output routines
*/
NDBOX *cube_in(char *str);
NDBOX *cube(text *str);
char *cube_out(NDBOX * cube);
@ -55,8 +56,8 @@ bool cube_contained(NDBOX * a, NDBOX * b);
bool cube_overlap(NDBOX * a, NDBOX * b);
NDBOX *cube_union(NDBOX * a, NDBOX * b);
NDBOX *cube_inter(NDBOX * a, NDBOX * b);
float *cube_size(NDBOX * a);
void rt_cube_size(NDBOX * a, float *sz);
double *cube_size(NDBOX * a);
void rt_cube_size(NDBOX * a, double *sz);
/*
** These make no sense for this type, but R-tree wants them
@ -71,13 +72,18 @@ bool cube_right(NDBOX * a, NDBOX * b);
*/
bool cube_lt(NDBOX * a, NDBOX * b);
bool cube_gt(NDBOX * a, NDBOX * b);
float *cube_distance(NDBOX * a, NDBOX * b);
double *cube_distance(NDBOX * a, NDBOX * b);
int cube_dim(NDBOX *a);
double *cube_ll_coord(NDBOX * a, int n);
double *cube_ur_coord(NDBOX * a, int n);
bool cube_is_point(NDBOX * a);
NDBOX *cube_enlarge(NDBOX * a, double * r, int n);
/*
** Auxiliary funxtions
*/
static float distance_1D(float a1, float a2, float b1, float b2);
static NDBOX *swap_corners(NDBOX * a);
static double distance_1D(double a1, double a2, double b1, double b2);
/*****************************************************************************
@ -99,6 +105,15 @@ cube_in(char *str)
return ((NDBOX *) result);
}
/* Allow conversion from text to cube to allow input of computed strings */
/* There may be issues with toasted data here. I don't know enough to be sure.*/
NDBOX *
cube(text *str)
{
return cube_in(DatumGetCString(DirectFunctionCall1(textout,
PointerGetDatum(str))));
}
char *
cube_out(NDBOX *cube)
{
@ -118,7 +133,7 @@ cube_out(NDBOX *cube)
{
if (i > 0)
appendStringInfo(&buf, ", ");
appendStringInfo(&buf, "%g", cube->x[i]);
appendStringInfo(&buf, "%.16g", cube->x[i]);
if (cube->x[i] != cube->x[i + dim])
equal = false;
}
@ -131,7 +146,7 @@ cube_out(NDBOX *cube)
{
if (i > 0)
appendStringInfo(&buf, ", ");
appendStringInfo(&buf, "%g", cube->x[i + dim]);
appendStringInfo(&buf, "%.16g", cube->x[i + dim]);
}
appendStringInfoChar(&buf, ')');
}
@ -228,14 +243,14 @@ float *
g_cube_penalty(GISTENTRY *origentry, GISTENTRY *newentry, float *result)
{
NDBOX *ud;
float tmp1,
double tmp1,
tmp2;
ud = cube_union((NDBOX *) DatumGetPointer(origentry->key),
(NDBOX *) DatumGetPointer(newentry->key));
rt_cube_size(ud, &tmp1);
rt_cube_size((NDBOX *) DatumGetPointer(origentry->key), &tmp2);
*result = tmp1 - tmp2;
*result = (float) (tmp1 - tmp2);
pfree(ud);
/*
@ -265,13 +280,13 @@ g_cube_picksplit(bytea *entryvec,
*union_dr;
NDBOX *inter_d;
bool firsttime;
float size_alpha,
double size_alpha,
size_beta,
size_union,
size_inter;
float size_waste,
double size_waste,
waste;
float size_l,
double size_l,
size_r;
int nbytes;
OffsetNumber seed_1 = 0,
@ -519,22 +534,22 @@ g_cube_binary_union(NDBOX * r1, NDBOX * r2, int *sizep)
/* cube_union */
NDBOX *
cube_union(NDBOX * box_a, NDBOX * box_b)
cube_union(NDBOX * a, NDBOX * b)
{
int i;
NDBOX *result;
NDBOX *a = swap_corners(box_a);
NDBOX *b = swap_corners(box_b);
if (a->dim >= b->dim)
{
result = palloc(a->size);
memset(result, 0, a->size);
result->size = a->size;
result->dim = a->dim;
}
else
{
result = palloc(b->size);
memset(result, 0, b->size);
result->size = b->size;
result->dim = b->dim;
}
@ -554,8 +569,8 @@ cube_union(NDBOX * box_a, NDBOX * box_b)
*/
for (i = 0; i < b->dim; i++)
{
result->x[i] = b->x[i];
result->x[i + a->dim] = b->x[i + b->dim];
result->x[i] = min(b->x[i], b->x[i + b->dim]);
result->x[i + a->dim] = max(b->x[i], b->x[i + b->dim]);
}
for (i = b->dim; i < a->dim; i++)
{
@ -565,34 +580,34 @@ cube_union(NDBOX * box_a, NDBOX * box_b)
/* compute the union */
for (i = 0; i < a->dim; i++)
result->x[i] = min(a->x[i], result->x[i]);
for (i = a->dim; i < a->dim * 2; i++)
result->x[i] = max(a->x[i], result->x[i]);
pfree(a);
pfree(b);
{
result->x[i] =
min(min(a->x[i], a->x[i + a->dim]), result->x[i]);
result->x[i + a->dim] = max(max(a->x[i],
a->x[i + a->dim]), result->x[i + a->dim]);
}
return (result);
}
/* cube_inter */
NDBOX *
cube_inter(NDBOX * box_a, NDBOX * box_b)
cube_inter(NDBOX * a, NDBOX * b)
{
int i;
NDBOX *result;
NDBOX *a = swap_corners(box_a);
NDBOX *b = swap_corners(box_b);
if (a->dim >= b->dim)
{
result = palloc(a->size);
memset(result, 0, a->size);
result->size = a->size;
result->dim = a->dim;
}
else
{
result = palloc(b->size);
memset(result, 0, b->size);
result->size = b->size;
result->dim = b->dim;
}
@ -612,8 +627,8 @@ cube_inter(NDBOX * box_a, NDBOX * box_b)
*/
for (i = 0; i < b->dim; i++)
{
result->x[i] = b->x[i];
result->x[i + a->dim] = b->x[i + b->dim];
result->x[i] = min(b->x[i], b->x[i + b->dim]);
result->x[i + a->dim] = max(b->x[i], b->x[i + b->dim]);
}
for (i = b->dim; i < a->dim; i++)
{
@ -623,12 +638,12 @@ cube_inter(NDBOX * box_a, NDBOX * box_b)
/* compute the intersection */
for (i = 0; i < a->dim; i++)
result->x[i] = max(a->x[i], result->x[i]);
for (i = a->dim; i < a->dim * 2; i++)
result->x[i] = min(a->x[i], result->x[i]);
pfree(a);
pfree(b);
{
result->x[i] =
max(min(a->x[i], a->x[i + a->dim]), result->x[i]);
result->x[i + a->dim] = min(max(a->x[i],
a->x[i + a->dim]), result->x[i + a->dim]);
}
/*
* Is it OK to return a non-null intersection for non-overlapping
@ -638,14 +653,14 @@ cube_inter(NDBOX * box_a, NDBOX * box_b)
}
/* cube_size */
float *
double *
cube_size(NDBOX * a)
{
int i,
j;
float *result;
double *result;
result = (float *) palloc(sizeof(float));
result = (double *) palloc(sizeof(double));
*result = 1.0;
for (i = 0, j = a->dim; i < a->dim; i++, j++)
@ -655,7 +670,7 @@ cube_size(NDBOX * a)
}
void
rt_cube_size(NDBOX * a, float *size)
rt_cube_size(NDBOX * a, double *size)
{
int i,
j;
@ -679,114 +694,84 @@ rt_cube_size(NDBOX * a, float *size)
/* is the right edge of (a) located to the left of
the right edge of (b)? */
bool
cube_over_left(NDBOX * box_a, NDBOX * box_b)
cube_over_left(NDBOX * a, NDBOX * b)
{
NDBOX *a;
NDBOX *b;
if ((box_a == NULL) || (box_b == NULL))
if ((a == NULL) || (b == NULL))
return (FALSE);
a = swap_corners(box_a);
b = swap_corners(box_b);
return (a->x[a->dim - 1] <= b->x[b->dim - 1] && !cube_left(a, b) && !cube_right(a, b));
return (min(a->x[a->dim - 1], a->x[2 * a->dim - 1]) <=
min(b->x[b->dim - 1], b->x[2 * b->dim - 1]) &&
!cube_left(a, b) && !cube_right(a, b));
}
/* is the left edge of (a) located to the right of
the left edge of (b)? */
bool
cube_over_right(NDBOX * box_a, NDBOX * box_b)
cube_over_right(NDBOX * a, NDBOX * b)
{
NDBOX *a;
NDBOX *b;
if ((box_a == NULL) || (box_b == NULL))
if ((a == NULL) || (b == NULL))
return (FALSE);
a = swap_corners(box_a);
b = swap_corners(box_b);
return (a->x[a->dim - 1] >= b->x[b->dim - 1] && !cube_left(a, b) && !cube_right(a, b));
return (min(a->x[a->dim - 1], a->x[2 * a->dim - 1]) >=
min(b->x[b->dim - 1], b->x[2 * b->dim - 1]) &&
!cube_left(a, b) && !cube_right(a, b));
}
/* return 'true' if the projection of 'a' is
entirely on the left of the projection of 'b' */
bool
cube_left(NDBOX * box_a, NDBOX * box_b)
cube_left(NDBOX * a, NDBOX * b)
{
NDBOX *a;
NDBOX *b;
if ((box_a == NULL) || (box_b == NULL))
if ((a == NULL) || (b == NULL))
return (FALSE);
a = swap_corners(box_a);
b = swap_corners(box_b);
return (a->x[a->dim - 1] < b->x[0]);
return (min(a->x[a->dim - 1], a->x[2 * a->dim - 1]) <
min(b->x[0], b->x[b->dim]));
}
/* return 'true' if the projection of 'a' is
entirely on the right of the projection of 'b' */
bool
cube_right(NDBOX * box_a, NDBOX * box_b)
cube_right(NDBOX * a, NDBOX * b)
{
NDBOX *a;
NDBOX *b;
if ((box_a == NULL) || (box_b == NULL))
if ((a == NULL) || (b == NULL))
return (FALSE);
a = swap_corners(box_a);
b = swap_corners(box_b);
return (a->x[0] > b->x[b->dim - 1]);
return (min(a->x[0], a->x[a->dim]) >
min(b->x[b->dim - 1], b->x[2 * b->dim - 1]));
}
/* make up a metric in which one box will be 'lower' than the other
-- this can be useful for srting and to determine uniqueness */
-- this can be useful for sorting and to determine uniqueness */
bool
cube_lt(NDBOX * box_a, NDBOX * box_b)
cube_lt(NDBOX * a, NDBOX * b)
{
int i;
int dim;
NDBOX *a;
NDBOX *b;
if ((box_a == NULL) || (box_b == NULL))
if ((a == NULL) || (b == NULL))
return (FALSE);
a = swap_corners(box_a);
b = swap_corners(box_b);
dim = min(a->dim, b->dim);
/*
* if all common dimensions are equal, the cube with more dimensions
* wins
*/
if (cube_same(a, b))
{
if (a->dim < b->dim)
return (TRUE);
else
return (FALSE);
}
/* compare the common dimensions */
for (i = 0; i < dim; i++)
{
if (a->x[i] > b->x[i])
if (min(a->x[i], a->x[a->dim + i]) >
min(b->x[i], b->x[b->dim + i]))
return (FALSE);
if (a->x[i] < b->x[i])
if (min(a->x[i], a->x[a->dim + i]) <
min(b->x[i], b->x[b->dim + i]))
return (TRUE);
}
for (i = 0; i < dim; i++)
{
if (a->x[i + a->dim] > b->x[i + b->dim])
if (max(a->x[i], a->x[a->dim + i]) >
max(b->x[i], b->x[b->dim + i]))
return (FALSE);
if (a->x[i + a->dim] < b->x[i + b->dim])
if (max(a->x[i], a->x[a->dim + i]) <
max(b->x[i], b->x[b->dim + i]))
return (TRUE);
}
@ -795,35 +780,45 @@ cube_lt(NDBOX * box_a, NDBOX * box_b)
{
for (i = dim; i < a->dim; i++)
{
if (a->x[i] > 0)
if (min(a->x[i], a->x[a->dim + i]) > 0)
return (FALSE);
if (a->x[i] < 0)
if (min(a->x[i], a->x[a->dim + i]) < 0)
return (TRUE);
}
for (i = 0; i < dim; i++)
for (i = dim; i < a->dim; i++)
{
if (a->x[i + a->dim] > 0)
if (max(a->x[i], a->x[a->dim + i]) > 0)
return (FALSE);
if (a->x[i + a->dim] < 0)
if (max(a->x[i], a->x[a->dim + i]) < 0)
return (TRUE);
}
/*
* if all common dimensions are equal, the cube with more
* dimensions wins
*/
return (FALSE);
}
if (a->dim < b->dim)
{
for (i = dim; i < b->dim; i++)
{
if (b->x[i] > 0)
if (min(b->x[i], b->x[b->dim + i]) > 0)
return (TRUE);
if (b->x[i] < 0)
if (min(b->x[i], b->x[b->dim + i]) < 0)
return (FALSE);
}
for (i = 0; i < dim; i++)
for (i = dim; i < b->dim; i++)
{
if (b->x[i + b->dim] > 0)
if (max(b->x[i], b->x[b->dim + i]) > 0)
return (TRUE);
if (b->x[i + b->dim] < 0)
if (max(b->x[i], b->x[b->dim + i]) < 0)
return (FALSE);
}
/*
* if all common dimensions are equal, the cube with more
* dimensions wins
*/
return (TRUE);
}
return (FALSE);
@ -831,45 +826,33 @@ cube_lt(NDBOX * box_a, NDBOX * box_b)
bool
cube_gt(NDBOX * box_a, NDBOX * box_b)
cube_gt(NDBOX * a, NDBOX * b)
{
int i;
int dim;
NDBOX *a;
NDBOX *b;
if ((box_a == NULL) || (box_b == NULL))
if ((a == NULL) || (b == NULL))
return (FALSE);
a = swap_corners(box_a);
b = swap_corners(box_b);
dim = min(a->dim, b->dim);
/*
* if all common dimensions are equal, the cube with more dimensions
* wins
*/
if (cube_same(a, b))
{
if (a->dim > b->dim)
return (TRUE);
else
return (FALSE);
}
/* compare the common dimensions */
for (i = 0; i < dim; i++)
{
if (a->x[i] < b->x[i])
if (min(a->x[i], a->x[a->dim + i]) <
min(b->x[i], b->x[b->dim + i]))
return (FALSE);
if (a->x[i] > b->x[i])
if (min(a->x[i], a->x[a->dim + i]) >
min(b->x[i], b->x[b->dim + i]))
return (TRUE);
}
for (i = 0; i < dim; i++)
{
if (a->x[i + a->dim] < b->x[i + b->dim])
if (max(a->x[i], a->x[a->dim + i]) <
max(b->x[i], b->x[b->dim + i]))
return (FALSE);
if (a->x[i + a->dim] > b->x[i + b->dim])
if (max(a->x[i], a->x[a->dim + i]) >
max(b->x[i], b->x[b->dim + i]))
return (TRUE);
}
@ -879,35 +862,45 @@ cube_gt(NDBOX * box_a, NDBOX * box_b)
{
for (i = dim; i < a->dim; i++)
{
if (a->x[i] < 0)
if (min(a->x[i], a->x[a->dim + i]) < 0)
return (FALSE);
if (a->x[i] > 0)
if (min(a->x[i], a->x[a->dim + i]) > 0)
return (TRUE);
}
for (i = 0; i < dim; i++)
for (i = dim; i < a->dim; i++)
{
if (a->x[i + a->dim] < 0)
if (max(a->x[i], a->x[a->dim + i]) < 0)
return (FALSE);
if (a->x[i + a->dim] > 0)
if (max(a->x[i], a->x[a->dim + i]) > 0)
return (TRUE);
}
/*
* if all common dimensions are equal, the cube with more
* dimensions wins
*/
return (TRUE);
}
if (a->dim < b->dim)
{
for (i = dim; i < b->dim; i++)
{
if (b->x[i] < 0)
if (min(b->x[i], b->x[b->dim + i]) < 0)
return (TRUE);
if (b->x[i] > 0)
if (min(b->x[i], b->x[b->dim + i]) > 0)
return (FALSE);
}
for (i = 0; i < dim; i++)
for (i = dim; i < b->dim; i++)
{
if (b->x[i + b->dim] < 0)
if (max(b->x[i], b->x[b->dim + i]) < 0)
return (TRUE);
if (b->x[i + b->dim] > 0)
if (max(b->x[i], b->x[b->dim + i]) > 0)
return (FALSE);
}
/*
* if all common dimensions are equal, the cube with more
* dimensions wins
*/
return (FALSE);
}
return (FALSE);
@ -916,18 +909,13 @@ cube_gt(NDBOX * box_a, NDBOX * box_b)
/* Equal */
bool
cube_same(NDBOX * box_a, NDBOX * box_b)
cube_same(NDBOX * a, NDBOX * b)
{
int i;
NDBOX *a;
NDBOX *b;
if ((box_a == NULL) || (box_b == NULL))
if ((a == NULL) || (b == NULL))
return (FALSE);
a = swap_corners(box_a);
b = swap_corners(box_b);
/* swap the box pointers if necessary */
if (a->dim < b->dim)
{
@ -939,15 +927,19 @@ cube_same(NDBOX * box_a, NDBOX * box_b)
for (i = 0; i < b->dim; i++)
{
if (a->x[i] != b->x[i])
if (min(a->x[i], a->x[a->dim + i]) !=
min(b->x[i], b->x[b->dim + i]))
return (FALSE);
if (a->x[i + a->dim] != b->x[i + b->dim])
if (max(a->x[i], a->x[a->dim + i]) !=
max(b->x[i], b->x[b->dim + i]))
return (FALSE);
}
/*
* all dimensions of (b) are compared to those of (a); instead of
* those in (a) absent in (b), compare (a) to zero
* Since both LL and UR coordinates are compared to zero, we can
* just check them all without worrying about which is which.
*/
for (i = b->dim; i < a->dim; i++)
{
@ -957,40 +949,34 @@ cube_same(NDBOX * box_a, NDBOX * box_b)
return (FALSE);
}
pfree(a);
pfree(b);
return (TRUE);
}
/* Different */
bool
cube_different(NDBOX * box_a, NDBOX * box_b)
cube_different(NDBOX * a, NDBOX * b)
{
return (!cube_same(box_a, box_b));
return (!cube_same(a, b));
}
/* Contains */
/* Box(A) CONTAINS Box(B) IFF pt(A) < pt(B) */
bool
cube_contains(NDBOX * box_a, NDBOX * box_b)
cube_contains(NDBOX * a, NDBOX * b)
{
int i;
NDBOX *a;
NDBOX *b;
if ((box_a == NULL) || (box_b == NULL))
if ((a == NULL) || (b == NULL))
return (FALSE);
a = swap_corners(box_a);
b = swap_corners(box_b);
if (a->dim < b->dim)
{
/*
* the further comparisons will make sense if the excess
* dimensions of (b) were zeroes
* Since both UL and UR coordinates must be zero, we can
* check them all without worrying about which is which.
*/
for (i = a->dim; i < b->dim; i++)
{
@ -1004,15 +990,14 @@ cube_contains(NDBOX * box_a, NDBOX * box_b)
/* Can't care less about the excess dimensions of (a), if any */
for (i = 0; i < min(a->dim, b->dim); i++)
{
if (a->x[i] > b->x[i])
if (min(a->x[i], a->x[a->dim + i]) >
min(b->x[i], b->x[b->dim + i]))
return (FALSE);
if (a->x[i + a->dim] < b->x[i + b->dim])
if (max(a->x[i], a->x[a->dim + i]) <
max(b->x[i], b->x[b->dim + i]))
return (FALSE);
}
pfree(a);
pfree(b);
return (TRUE);
}
@ -1030,22 +1015,17 @@ cube_contained(NDBOX * a, NDBOX * b)
/* Overlap */
/* Box(A) Overlap Box(B) IFF (pt(a)LL < pt(B)UR) && (pt(b)LL < pt(a)UR) */
bool
cube_overlap(NDBOX * box_a, NDBOX * box_b)
cube_overlap(NDBOX * a, NDBOX * b)
{
int i;
NDBOX *a;
NDBOX *b;
/*
* This *very bad* error was found in the source: if ( (a==NULL) ||
* (b=NULL) ) return(FALSE);
*/
if ((box_a == NULL) || (box_b == NULL))
if ((a == NULL) || (b == NULL))
return (FALSE);
a = swap_corners(box_a);
b = swap_corners(box_b);
/* swap the box pointers if needed */
if (a->dim < b->dim)
{
@ -1058,24 +1038,23 @@ cube_overlap(NDBOX * box_a, NDBOX * box_b)
/* compare within the dimensions of (b) */
for (i = 0; i < b->dim; i++)
{
if (a->x[i] > b->x[i + b->dim])
if (min(a->x[i], a->x[a->dim + i]) >
max(b->x[i], b->x[b->dim + i]))
return (FALSE);
if (a->x[i + a->dim] < b->x[i])
if (max(a->x[i], a->x[a->dim + i]) <
min(b->x[i], b->x[b->dim + i]))
return (FALSE);
}
/* compare to zero those dimensions in (a) absent in (b) */
for (i = b->dim; i < a->dim; i++)
{
if (a->x[i] > 0)
if (min(a->x[i], a->x[a->dim + i]) > 0)
return (FALSE);
if (a->x[i + a->dim] < 0)
if (max(a->x[i], a->x[a->dim + i]) < 0)
return (FALSE);
}
pfree(a);
pfree(b);
return (TRUE);
}
@ -1085,15 +1064,15 @@ cube_overlap(NDBOX * box_a, NDBOX * box_b)
between 1D projections of the boxes onto Cartesian axes. Assuming zero
distance between overlapping projections, this metric coincides with the
"common sense" geometric distance */
float *
double *
cube_distance(NDBOX * a, NDBOX * b)
{
int i;
double d,
distance;
float *result;
double *result;
result = (float *) palloc(sizeof(float));
result = (double *) palloc(sizeof(double));
/* swap the box pointers if needed */
if (a->dim < b->dim)
@ -1119,13 +1098,13 @@ cube_distance(NDBOX * a, NDBOX * b)
distance += d * d;
}
*result = (float) sqrt(distance);
*result = (double) sqrt(distance);
return (result);
}
static float
distance_1D(float a1, float a2, float b1, float b2)
static double
distance_1D(double a1, double a2, double b1, double b2)
{
/* interval (a) is entirely on the left of (b) */
if ((a1 <= b1) && (a2 <= b1) && (a1 <= b2) && (a2 <= b2))
@ -1139,25 +1118,91 @@ distance_1D(float a1, float a2, float b1, float b2)
return (0.0);
}
/* normalize the box's co-ordinates by placing min(xLL,xUR) to LL
and max(xLL,xUR) to UR
*/
static NDBOX *
swap_corners(NDBOX * a)
/* Test if a box is also a point */
bool
cube_is_point(NDBOX * a)
{
int i,
j;
NDBOX *result;
int i,
j;
for (i = 0, j = a->dim; i < a->dim; i++, j++)
{
if (a->x[i] != a->x[j]) return FALSE;
}
result = palloc(a->size);
result->size = a->size;
result->dim = a->dim;
return TRUE;
}
for (i = 0, j = a->dim; i < a->dim; i++, j++)
{
result->x[i] = min(a->x[i], a->x[j]);
result->x[j] = max(a->x[i], a->x[j]);
}
/* Return dimensions in use in the data structure */
int
cube_dim(NDBOX * a)
{
/* Other things will break before unsigned int doesn't fit. */
return a->dim;
}
return (result);
/* Return a specific normalized LL coordinate */
double *
cube_ll_coord(NDBOX * a, int n)
{
double *result;
result = (double *) palloc(sizeof(double));
*result = 0;
if (a->dim >= n && n > 0)
*result = min(a->x[n-1], a->x[a->dim + n-1]);
return result;
}
/* Return a specific normalized UR coordinate */
double *
cube_ur_coord(NDBOX * a, int n)
{
double *result;
result = (double *) palloc(sizeof(double));
*result = 0;
if (a->dim >= n && n > 0)
*result = max(a->x[n-1], a->x[a->dim + n-1]);
return result;
}
/* Increase or decrease box size by a radius in at least n dimensions. */
NDBOX *
cube_enlarge(NDBOX * a, double * r, int n)
{
NDBOX *result;
int dim = 0;
int size;
int i,
j;
if (*r > 0 && n > 0) dim = n;
if (a->dim > dim) dim = a->dim;
size = offsetof(NDBOX, x[0]) + sizeof(double) * dim * 2;
result = (NDBOX *) palloc(size);
memset(result, 0, size);
result->size = size;
result->dim = dim;
for (i = 0, j = dim; i < a->dim; i++, j++)
{
if (a->x[i] >= a->x[j])
{
result->x[i] = a->x[j] - *r;
result->x[j] = a->x[i] + *r;
}
else
{
result->x[i] = a->x[i] - *r;
result->x[j] = a->x[j] + *r;
}
if (result->x[i] > result->x[j])
{
result->x[i] = (result->x[i] + result->x[j]) / 2;
result->x[j] = result->x[i];
}
}
/* dim > a->dim only if r > 0 */
for (; i < dim; i++, j++)
{
result->x[i] = -*r;
result->x[j] = *r;
}
return result;
}

70
contrib/cube/cube.sql.in
Unescape View File

@ -8,12 +8,12 @@ SET search_path = public;
CREATE FUNCTION cube_in(cstring)
RETURNS cube
AS 'MODULE_PATHNAME'
LANGUAGE 'c' WITH (isStrict);
LANGUAGE 'c'IMMUTABLE STRICT;
CREATE FUNCTION cube_out(cube)
RETURNS cstring
AS 'MODULE_PATHNAME'
LANGUAGE 'c' WITH (isStrict);
LANGUAGE 'c'IMMUTABLE STRICT;
CREATE TYPE cube (
internallength = variable,
@ -24,6 +24,16 @@ output = cube_out
COMMENT ON TYPE cube IS
'multi-dimensional cube ''(FLOAT-1, FLOAT-2, ..., FLOAT-N), (FLOAT-1, FLOAT-2, ..., FLOAT-N)''';
-- Convert from text to cube
CREATE FUNCTION cube(text)
RETURNS cube
AS 'MODULE_PATHNAME'
LANGUAGE 'c' IMMUTABLE STRICT;
COMMENT ON FUNCTION cube(text) IS
'convert text to cube';
--
-- External C-functions for R-tree methods
--
@ -31,25 +41,25 @@ COMMENT ON TYPE cube IS
-- Left/Right methods
CREATE FUNCTION cube_over_left(cube, cube) RETURNS bool
AS 'MODULE_PATHNAME' LANGUAGE 'c' with (isstrict);
AS 'MODULE_PATHNAME' LANGUAGE 'c' IMMUTABLE STRICT;
COMMENT ON FUNCTION cube_over_left(cube, cube) IS
'is over and left of (NOT IMPLEMENTED)';
CREATE FUNCTION cube_over_right(cube, cube) RETURNS bool
AS 'MODULE_PATHNAME' LANGUAGE 'c' with (isstrict);
AS 'MODULE_PATHNAME' LANGUAGE 'c' IMMUTABLE STRICT;
COMMENT ON FUNCTION cube_over_right(cube, cube) IS
'is over and right of (NOT IMPLEMENTED)';
CREATE FUNCTION cube_left(cube, cube) RETURNS bool
AS 'MODULE_PATHNAME' LANGUAGE 'c' with (isstrict);
AS 'MODULE_PATHNAME' LANGUAGE 'c' IMMUTABLE STRICT;
COMMENT ON FUNCTION cube_left(cube, cube) IS
'is left of (NOT IMPLEMENTED)';
CREATE FUNCTION cube_right(cube, cube) RETURNS bool
AS 'MODULE_PATHNAME' LANGUAGE 'c' with (isstrict);
AS 'MODULE_PATHNAME' LANGUAGE 'c' IMMUTABLE STRICT;
COMMENT ON FUNCTION cube_right(cube, cube) IS
'is right of (NOT IMPLEMENTED)';
@ -58,43 +68,43 @@ COMMENT ON FUNCTION cube_right(cube, cube) IS
-- Comparison methods
CREATE FUNCTION cube_lt(cube, cube) RETURNS bool
AS 'MODULE_PATHNAME' LANGUAGE 'c' with (isstrict);
AS 'MODULE_PATHNAME' LANGUAGE 'c' IMMUTABLE STRICT;
COMMENT ON FUNCTION cube_lt(cube, cube) IS
'lower than';
CREATE FUNCTION cube_gt(cube, cube) RETURNS bool
AS 'MODULE_PATHNAME' LANGUAGE 'c' with (isstrict);
AS 'MODULE_PATHNAME' LANGUAGE 'c' IMMUTABLE STRICT;
COMMENT ON FUNCTION cube_gt(cube, cube) IS
'greater than';
CREATE FUNCTION cube_contains(cube, cube) RETURNS bool
AS 'MODULE_PATHNAME' LANGUAGE 'c' with (isstrict);
AS 'MODULE_PATHNAME' LANGUAGE 'c' IMMUTABLE STRICT;
COMMENT ON FUNCTION cube_contains(cube, cube) IS
'contains';
CREATE FUNCTION cube_contained(cube, cube) RETURNS bool
AS 'MODULE_PATHNAME' LANGUAGE 'c' with (isstrict);
AS 'MODULE_PATHNAME' LANGUAGE 'c' IMMUTABLE STRICT;
COMMENT ON FUNCTION cube_contained(cube, cube) IS
'contained in';
CREATE FUNCTION cube_overlap(cube, cube) RETURNS bool
AS 'MODULE_PATHNAME' LANGUAGE 'c' with (isstrict);
AS 'MODULE_PATHNAME' LANGUAGE 'c' IMMUTABLE STRICT;
COMMENT ON FUNCTION cube_overlap(cube, cube) IS
'overlaps';
CREATE FUNCTION cube_same(cube, cube) RETURNS bool
AS 'MODULE_PATHNAME' LANGUAGE 'c' with (isstrict);
AS 'MODULE_PATHNAME' LANGUAGE 'c' IMMUTABLE STRICT;
COMMENT ON FUNCTION cube_same(cube, cube) IS
'same as';
CREATE FUNCTION cube_different(cube, cube) RETURNS bool
AS 'MODULE_PATHNAME' LANGUAGE 'c' with (isstrict);
AS 'MODULE_PATHNAME' LANGUAGE 'c' IMMUTABLE STRICT;
COMMENT ON FUNCTION cube_different(cube, cube) IS
'different';
@ -102,22 +112,42 @@ COMMENT ON FUNCTION cube_different(cube, cube) IS
-- support routines for indexing
CREATE FUNCTION cube_union(cube, cube) RETURNS cube
AS 'MODULE_PATHNAME' LANGUAGE 'c' with (isstrict);
AS 'MODULE_PATHNAME' LANGUAGE 'c' IMMUTABLE STRICT;
CREATE FUNCTION cube_inter(cube, cube) RETURNS cube
AS 'MODULE_PATHNAME' LANGUAGE 'c' with (isstrict);
AS 'MODULE_PATHNAME' LANGUAGE 'c' IMMUTABLE STRICT;
CREATE FUNCTION cube_size(cube) RETURNS float4
AS 'MODULE_PATHNAME' LANGUAGE 'c' with (isstrict);
CREATE FUNCTION cube_size(cube) RETURNS float8
AS 'MODULE_PATHNAME' LANGUAGE 'c' IMMUTABLE STRICT;
-- Misc N-dimensional functions
-- proximity routines
CREATE FUNCTION cube_distance(cube, cube) RETURNS float4
AS 'MODULE_PATHNAME' LANGUAGE 'c' with (isstrict);
CREATE FUNCTION cube_distance(cube, cube) RETURNS float8
AS 'MODULE_PATHNAME' LANGUAGE 'c' IMMUTABLE STRICT;
-- Extracting elements functions
CREATE FUNCTION cube_dim(cube) RETURNS int4
AS 'MODULE_PATHNAME' LANGUAGE 'c' IMMUTABLE STRICT;
CREATE FUNCTION cube_ll_coord(cube, int4) RETURNS float8
AS 'MODULE_PATHNAME' LANGUAGE 'c' IMMUTABLE STRICT;
CREATE FUNCTION cube_ur_coord(cube, int4) RETURNS float8
AS 'MODULE_PATHNAME' LANGUAGE 'c' IMMUTABLE STRICT;
-- Test if cube is also a point
CREATE FUNCTION cube_is_point(cube) RETURNS bool
AS 'MODULE_PATHNAME' LANGUAGE 'c' IMMUTABLE STRICT;
-- Increasing the size of a cube by a radius in at least n dimensions
CREATE FUNCTION cube_enlarge(cube, float8, int4) RETURNS cube
AS 'MODULE_PATHNAME' LANGUAGE 'c' IMMUTABLE STRICT;
--
-- OPERATORS
@ -202,7 +232,7 @@ CREATE FUNCTION g_cube_decompress(internal) RETURNS internal
AS 'MODULE_PATHNAME' LANGUAGE 'c';
CREATE FUNCTION g_cube_penalty(internal,internal,internal) RETURNS internal
AS 'MODULE_PATHNAME' LANGUAGE 'c' with (isstrict);
AS 'MODULE_PATHNAME' LANGUAGE 'c' STRICT;
CREATE FUNCTION g_cube_picksplit(internal, internal) RETURNS internal
AS 'MODULE_PATHNAME' LANGUAGE 'c';

2
contrib/cube/cubedata.h
Unescape View File

@ -2,5 +2,5 @@ typedef struct NDBOX
{
unsigned int size; /* required to be a Postgres varlena type */
unsigned int dim;
float x[1];
double x[1];
} NDBOX;

8
contrib/cube/cubeparse.y
Unescape View File

@ -198,9 +198,10 @@ write_box(unsigned int dim, char *str1, char *str2)
NDBOX * bp;
char * s;
int i;
int size = offsetof(NDBOX, x[0]) + sizeof(float) * dim * 2;
int size = offsetof(NDBOX, x[0]) + sizeof(double) * dim * 2;
bp = palloc(size);
memset(bp, 0, size);
bp->size = size;
bp->dim = dim;
@ -217,7 +218,7 @@ write_box(unsigned int dim, char *str1, char *str2)
s++; i++;
bp->x[i] = strtod(s, NULL);
}
return(bp);
}
@ -230,9 +231,10 @@ static NDBOX * write_point_as_box(char *str)
int dim = delim_count(str, ',') + 1;
char * s = str;
size = offsetof(NDBOX, x[0]) + sizeof(float) * dim * 2;
size = offsetof(NDBOX, x[0]) + sizeof(double) * dim * 2;
bp = palloc(size);
memset(bp, 0, size);
bp->size = size;
bp->dim = dim;

2
contrib/cube/cubescan.l
Unescape View File

@ -34,7 +34,7 @@ void cube_flush_scanner_buffer(void);
n [0-9]+
integer [+-]?{n}
real [+-]?({n}\.{n}?)|(\.{n})
real [+-]?({n}\.{n}?|\.{n})
float ({integer}|{real})([eE]{integer})?
%%

291
contrib/cube/expected/cube.out
Unescape View File

@ -43,7 +43,10 @@ SELECT '.1'::cube AS cube;
(1 row)
SELECT '-.1'::cube AS cube;
ERROR: parse error, expecting `FLOAT' or `O_PAREN' or `O_BRACKET' at or before position 2, character ('.', \056), input: '-.1'
cube
--------
(-0.1)
(1 row)
SELECT '1.0'::cube AS cube;
cube
@ -57,52 +60,52 @@ SELECT '-1.0'::cube AS cube;
(-1)
(1 row)
SELECT '1e7'::cube AS cube;
SELECT '1e27'::cube AS cube;
cube
---------
(1e+07)
(1e+27)
(1 row)
SELECT '-1e7'::cube AS cube;
SELECT '-1e27'::cube AS cube;
cube
----------
(-1e+07)
(-1e+27)
(1 row)
SELECT '1.0e7'::cube AS cube;
SELECT '1.0e27'::cube AS cube;
cube
---------
(1e+07)
(1e+27)
(1 row)
SELECT '-1.0e7'::cube AS cube;
SELECT '-1.0e27'::cube AS cube;
cube
----------
(-1e+07)
(-1e+27)
(1 row)
SELECT '1e+7'::cube AS cube;
SELECT '1e+27'::cube AS cube;
cube
---------
(1e+07)
(1e+27)
(1 row)
SELECT '-1e+7'::cube AS cube;
SELECT '-1e+27'::cube AS cube;
cube
----------
(-1e+07)
(-1e+27)
(1 row)
SELECT '1.0e+7'::cube AS cube;
SELECT '1.0e+27'::cube AS cube;
cube
---------
(1e+07)
(1e+27)
(1 row)
SELECT '-1.0e+7'::cube AS cube;
SELECT '-1.0e+27'::cube AS cube;
cube
----------
(-1e+07)
(-1e+27)
(1 row)
SELECT '1e-7'::cube AS cube;
@ -141,6 +144,42 @@ SELECT '-1e-700'::cube AS cube;
(0)
(1 row)
SELECT '1234567890123456'::cube AS cube;
cube
--------------------
(1234567890123456)
(1 row)
SELECT '+1234567890123456'::cube AS cube;
cube
--------------------
(1234567890123456)
(1 row)
SELECT '-1234567890123456'::cube AS cube;
cube
---------------------
(-1234567890123456)
(1 row)
SELECT '.1234567890123456'::cube AS cube;
cube
----------------------
(0.1234567890123456)
(1 row)
SELECT '+.1234567890123456'::cube AS cube;
cube
----------------------
(0.1234567890123456)
(1 row)
SELECT '-.1234567890123456'::cube AS cube;
cube
-----------------------
(-0.1234567890123456)
(1 row)
-- simple lists (points)
SELECT '1,2'::cube AS cube;
cube
@ -924,6 +963,224 @@ SELECT '(-1,-1),(1,1)'::cube @ '(-2),(1)'::cube AS bool;
f
(1 row)
-- Test of distance function
--
SELECT cube_distance('(0)'::cube,'(2,2,2,2)'::cube);
cube_distance
---------------
4
(1 row)
SELECT cube_distance('(0)'::cube,'(.3,.4)'::cube);
cube_distance
---------------
0.5
(1 row)
-- Test of cube function (text to cube)
--
SELECT cube('('||1||','||1.2||')');
cube
----------
(1, 1.2)
(1 row)
SELECT cube(NULL);
cube
------
(1 row)
-- Test of cube_dim function (dimensions stored in cube)
--
SELECT cube_dim('(0)'::cube);
cube_dim
----------
1
(1 row)
SELECT cube_dim('(0,0)'::cube);
cube_dim
----------
2
(1 row)
SELECT cube_dim('(0,0,0)'::cube);
cube_dim
----------
3
(1 row)
-- Test of cube_ll_coord function (retrieves LL coodinate values)
--
SELECT cube_ll_coord('(-1,1),(2,-2)'::cube, 1);
cube_ll_coord
---------------
-1
(1 row)
SELECT cube_ll_coord('(-1,1),(2,-2)'::cube, 2);
cube_ll_coord
---------------
-2
(1 row)
SELECT cube_ll_coord('(-1,1),(2,-2)'::cube, 3);
cube_ll_coord
---------------
0
(1 row)
-- Test of cube_ur_coord function (retrieves UR coodinate values)
--
SELECT cube_ur_coord('(-1,1),(2,-2)'::cube, 1);
cube_ur_coord
---------------
2
(1 row)
SELECT cube_ur_coord('(-1,1),(2,-2)'::cube, 2);
cube_ur_coord
---------------
1
(1 row)
SELECT cube_ur_coord('(-1,1),(2,-2)'::cube, 3);
cube_ur_coord
---------------
0
(1 row)
-- Test of cube_is_point
--
SELECT cube_is_point('(0)'::cube);
cube_is_point
---------------
t
(1 row)
SELECT cube_is_point('(0,1,2)'::cube);
cube_is_point
---------------
t
(1 row)
SELECT cube_is_point('(0,1,2),(0,1,2)'::cube);
cube_is_point
---------------
t
(1 row)
SELECT cube_is_point('(0,1,2),(-1,1,2)'::cube);
cube_is_point
---------------
f
(1 row)
SELECT cube_is_point('(0,1,2),(0,-1,2)'::cube);
cube_is_point
---------------
f
(1 row)
SELECT cube_is_point('(0,1,2),(0,1,-2)'::cube);
cube_is_point
---------------
f
(1 row)
-- Test of cube_enlarge (enlarging and shrinking cubes)
--
SELECT cube_enlarge('(0)'::cube, 0, 0);
cube_enlarge
--------------
(0)
(1 row)
SELECT cube_enlarge('(0)'::cube, 0, 1);
cube_enlarge
--------------
(0)
(1 row)
SELECT cube_enlarge('(0)'::cube, 0, 2);
cube_enlarge
--------------
(0)
(1 row)
SELECT cube_enlarge('(0)'::cube, 1, 0);
cube_enlarge
--------------
(-1),(1)
(1 row)
SELECT cube_enlarge('(0)'::cube, 1, 1);
cube_enlarge
--------------
(-1),(1)
(1 row)
SELECT cube_enlarge('(0)'::cube, 1, 2);
cube_enlarge
-----------------
(-1, -1),(1, 1)
(1 row)
SELECT cube_enlarge('(0)'::cube, -1, 0);
cube_enlarge
--------------
(0)
(1 row)
SELECT cube_enlarge('(0)'::cube, -1, 1);
cube_enlarge
--------------
(0)
(1 row)
SELECT cube_enlarge('(0)'::cube, -1, 2);
cube_enlarge
--------------
(0)
(1 row)
SELECT cube_enlarge('(0,0,0)'::cube, 1, 0);
cube_enlarge
------------------------
(-1, -1, -1),(1, 1, 1)
(1 row)
SELECT cube_enlarge('(0,0,0)'::cube, 1, 2);
cube_enlarge
------------------------
(-1, -1, -1),(1, 1, 1)
(1 row)
SELECT cube_enlarge('(2,-2),(-3,7)'::cube, 1, 2);
cube_enlarge
-----------------
(-4, -3),(3, 8)
(1 row)
SELECT cube_enlarge('(2,-2),(-3,7)'::cube, 3, 2);
cube_enlarge
------------------
(-6, -5),(5, 10)
(1 row)
SELECT cube_enlarge('(2,-2),(-3,7)'::cube, -1, 2);
cube_enlarge
-----------------
(-2, -1),(1, 6)
(1 row)
SELECT cube_enlarge('(2,-2),(-3,7)'::cube, -3, 2);
cube_enlarge
---------------------
(-0.5, 1),(-0.5, 4)
(1 row)
-- Load some example data and build the index
--
CREATE TABLE test_cube (c cube);

76
contrib/cube/sql/cube.sql
Unescape View File

@ -23,20 +23,26 @@ SELECT '.1'::cube AS cube;
SELECT '-.1'::cube AS cube;
SELECT '1.0'::cube AS cube;
SELECT '-1.0'::cube AS cube;
SELECT '1e7'::cube AS cube;
SELECT '-1e7'::cube AS cube;
SELECT '1.0e7'::cube AS cube;
SELECT '-1.0e7'::cube AS cube;
SELECT '1e+7'::cube AS cube;
SELECT '-1e+7'::cube AS cube;
SELECT '1.0e+7'::cube AS cube;
SELECT '-1.0e+7'::cube AS cube;
SELECT '1e27'::cube AS cube;
SELECT '-1e27'::cube AS cube;
SELECT '1.0e27'::cube AS cube;
SELECT '-1.0e27'::cube AS cube;
SELECT '1e+27'::cube AS cube;
SELECT '-1e+27'::cube AS cube;
SELECT '1.0e+27'::cube AS cube;
SELECT '-1.0e+27'::cube AS cube;
SELECT '1e-7'::cube AS cube;
SELECT '-1e-7'::cube AS cube;
SELECT '1.0e-7'::cube AS cube;
SELECT '-1.0e-7'::cube AS cube;
SELECT '1e-700'::cube AS cube;
SELECT '-1e-700'::cube AS cube;
SELECT '1234567890123456'::cube AS cube;
SELECT '+1234567890123456'::cube AS cube;
SELECT '-1234567890123456'::cube AS cube;
SELECT '.1234567890123456'::cube AS cube;
SELECT '+.1234567890123456'::cube AS cube;
SELECT '-.1234567890123456'::cube AS cube;
-- simple lists (points)
SELECT '1,2'::cube AS cube;
@ -230,6 +236,60 @@ SELECT '(-1,-1),(1,1)'::cube @ '(-1),(1)'::cube AS bool;
SELECT '(-1),(1)'::cube @ '(-2),(1)'::cube AS bool;
SELECT '(-1,-1),(1,1)'::cube @ '(-2),(1)'::cube AS bool;
-- Test of distance function
--
SELECT cube_distance('(0)'::cube,'(2,2,2,2)'::cube);
SELECT cube_distance('(0)'::cube,'(.3,.4)'::cube);
-- Test of cube function (text to cube)
--
SELECT cube('('||1||','||1.2||')');
SELECT cube(NULL);
-- Test of cube_dim function (dimensions stored in cube)
--
SELECT cube_dim('(0)'::cube);
SELECT cube_dim('(0,0)'::cube);
SELECT cube_dim('(0,0,0)'::cube);
-- Test of cube_ll_coord function (retrieves LL coodinate values)
--
SELECT cube_ll_coord('(-1,1),(2,-2)'::cube, 1);
SELECT cube_ll_coord('(-1,1),(2,-2)'::cube, 2);
SELECT cube_ll_coord('(-1,1),(2,-2)'::cube, 3);
-- Test of cube_ur_coord function (retrieves UR coodinate values)
--
SELECT cube_ur_coord('(-1,1),(2,-2)'::cube, 1);
SELECT cube_ur_coord('(-1,1),(2,-2)'::cube, 2);
SELECT cube_ur_coord('(-1,1),(2,-2)'::cube, 3);
-- Test of cube_is_point
--
SELECT cube_is_point('(0)'::cube);
SELECT cube_is_point('(0,1,2)'::cube);
SELECT cube_is_point('(0,1,2),(0,1,2)'::cube);
SELECT cube_is_point('(0,1,2),(-1,1,2)'::cube);
SELECT cube_is_point('(0,1,2),(0,-1,2)'::cube);
SELECT cube_is_point('(0,1,2),(0,1,-2)'::cube);
-- Test of cube_enlarge (enlarging and shrinking cubes)
--
SELECT cube_enlarge('(0)'::cube, 0, 0);
SELECT cube_enlarge('(0)'::cube, 0, 1);
SELECT cube_enlarge('(0)'::cube, 0, 2);
SELECT cube_enlarge('(0)'::cube, 1, 0);
SELECT cube_enlarge('(0)'::cube, 1, 1);
SELECT cube_enlarge('(0)'::cube, 1, 2);
SELECT cube_enlarge('(0)'::cube, -1, 0);
SELECT cube_enlarge('(0)'::cube, -1, 1);
SELECT cube_enlarge('(0)'::cube, -1, 2);
SELECT cube_enlarge('(0,0,0)'::cube, 1, 0);
SELECT cube_enlarge('(0,0,0)'::cube, 1, 2);
SELECT cube_enlarge('(2,-2),(-3,7)'::cube, 1, 2);
SELECT cube_enlarge('(2,-2),(-3,7)'::cube, 3, 2);
SELECT cube_enlarge('(2,-2),(-3,7)'::cube, -1, 2);
SELECT cube_enlarge('(2,-2),(-3,7)'::cube, -3, 2);
-- Load some example data and build the index
--

Write Preview
Loading…
Cancel
Save