pgs_contains_ops.sql.in

--- scircle vs scircle

CREATE OPERATOR @> (
   LEFTARG    = scircle,
   RIGHTARG   = scircle,
   PROCEDURE  = scircle_contains_circle,
   COMMUTATOR = '<@',
   NEGATOR    = '!@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR @> (scircle, scircle) IS 'true if spherical circle (LHS) contains spherical circle (RHS)';

CREATE OPERATOR <@ (
   LEFTARG    = scircle,
   RIGHTARG   = scircle,
   PROCEDURE  = scircle_contained_by_circle,
   COMMUTATOR = '@>',
   NEGATOR    = '!<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR <@ (scircle, scircle) IS 'true if spherical circle (LHS) is contained by spherical circle (RHS)';

CREATE OPERATOR !@> (
   LEFTARG    = scircle,
   RIGHTARG   = scircle,
   PROCEDURE  = scircle_contains_circle_neg,
   COMMUTATOR = '!<@',
   NEGATOR    = '@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !@> (scircle, scircle) IS 'true if spherical circle (LHS) does not contain spherical circle (RHS)';

CREATE OPERATOR !<@ (
   LEFTARG    = scircle,
   RIGHTARG   = scircle,
   PROCEDURE  = scircle_contained_by_circle_neg,
   COMMUTATOR = '!@>',
   NEGATOR    = '<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !<@ (scircle, scircle) IS 'true if spherical circle (LHS) is not contained by spherical circle (RHS)';

--- spoint vs scircle

CREATE OPERATOR @> (
   LEFTARG    = scircle,
   RIGHTARG   = spoint,
   PROCEDURE  = spoint_contained_by_circle_com,
   COMMUTATOR = '<@',
   NEGATOR    = '!@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR @> (scircle, spoint) IS 'true if spherical circle (LHS) contains spherical point (RHS)';

CREATE OPERATOR <@ (
   LEFTARG    = spoint,
   RIGHTARG   = scircle,
   PROCEDURE  = spoint_contained_by_circle,
   COMMUTATOR = '@>',
   NEGATOR    = '!<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR <@ (spoint, scircle) IS 'true if spherical point (LHS) is contained by spherical circle (RHS)';

CREATE OPERATOR !@> (
   LEFTARG    = scircle,
   RIGHTARG   = spoint,
   PROCEDURE  = spoint_contained_by_circle_com_neg,
   COMMUTATOR = '!<@',
   NEGATOR    = '@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !@> (scircle, spoint) IS 'true if spherical circle (LHS) does not contain spherical point (RHS)';

CREATE OPERATOR !<@ (
   LEFTARG    = spoint,
   RIGHTARG   = scircle,
   PROCEDURE  = spoint_contained_by_circle_neg,
   COMMUTATOR = '!@>',
   NEGATOR    = '<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !<@ (spoint, scircle) IS 'true if spherical point (LHS) is not contained by spherical circle (RHS)';

--- spoly vs spoly

CREATE OPERATOR @> (
   LEFTARG    = spoly,
   RIGHTARG   = spoly,
   PROCEDURE  = spoly_contains_polygon,
   COMMUTATOR = '<@',
   NEGATOR    = '!@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR @> (spoly, spoly) IS 'true if spherical polygon (LHS) contains spherical polygon (RHS)';

CREATE OPERATOR <@ (
   LEFTARG    = spoly,
   RIGHTARG   = spoly,
   PROCEDURE  = spoly_contains_polygon_com,
   COMMUTATOR = '@>',
   NEGATOR    = '!<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR <@ (spoly, spoly) IS 'true if spherical polygon (LHS) is contained by spherical polygon (RHS)';

CREATE OPERATOR !@> (
   LEFTARG    = spoly,
   RIGHTARG   = spoly,
   PROCEDURE  = spoly_contains_polygon_neg,
   COMMUTATOR = '!<@',
   NEGATOR    = '@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !@> (spoly, spoly) IS 'true if spherical polygon (LHS) does not contain spherical polygon (RHS)';

CREATE OPERATOR !<@ (
   LEFTARG    = spoly,
   RIGHTARG   = spoly,
   PROCEDURE  = spoly_contains_polygon_com_neg,
   COMMUTATOR = '!@>',
   NEGATOR    = '<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !<@ (spoly, spoly) IS 'true if spherical polygon (LHS) is not contained by spherical polygon (RHS)';

--  spoly vs spoint

CREATE OPERATOR @> (
   LEFTARG    = spoly,
   RIGHTARG   = spoint,
   PROCEDURE  = spoly_contains_point,
   COMMUTATOR = '<@',
   NEGATOR    = '!@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR @> (spoly, spoint) IS 'true if spherical polygon (LHS) contains spherical point (RHS)';

CREATE OPERATOR <@ (
   LEFTARG    = spoint,
   RIGHTARG   = spoly,
   PROCEDURE  = spoly_contains_point_com,
   COMMUTATOR = '@>',
   NEGATOR    = '!<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR <@ (spoint, spoly) IS 'true if spherical point (LHS) is contained by spherical polygon (RHS)';

CREATE OPERATOR !@> (
   LEFTARG    = spoly,
   RIGHTARG   = spoint,
   PROCEDURE  = spoly_contains_point_neg,
   COMMUTATOR = '!<@',
   NEGATOR    = '@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !@> (spoly, spoint) IS 'true if spherical polygon (LHS) does not contain spherical point (RHS)';

CREATE OPERATOR !<@ (
   LEFTARG    = spoint,
   RIGHTARG   = spoly,
   PROCEDURE  = spoly_contains_point_com_neg,
   COMMUTATOR = '!@>',
   NEGATOR    = '<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !<@ (spoint, spoly) IS 'true if spherical point (LHS) is not contained by spherical polygon (RHS)';


--- scircle vs spoly

CREATE OPERATOR @> (
   LEFTARG    = scircle,
   RIGHTARG   = spoly,
   PROCEDURE  = scircle_contains_polygon,
   COMMUTATOR = '<@',
   NEGATOR    = '!@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR @> (scircle, spoly) IS 'true if spherical circle (LHS) contains spherical polygon (RHS)';

CREATE OPERATOR <@ (
   LEFTARG    = spoly,
   RIGHTARG   = scircle,
   PROCEDURE  = scircle_contains_polygon_com,
   COMMUTATOR = '@>',
   NEGATOR    = '!<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR <@ (spoly, scircle) IS 'true if spherical polygon (LHS) is contained by spherical circle (LHS)';

CREATE OPERATOR !@> (
   LEFTARG    = scircle,
   RIGHTARG   = spoly,
   PROCEDURE  = scircle_contains_polygon_neg,
   COMMUTATOR = '!<@',
   NEGATOR    = '@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !@> (scircle, spoly) IS 'true if spherical circle (LHS) does not contain spherical polygon (RHS)';

CREATE OPERATOR !<@ (
   LEFTARG    = spoly,
   RIGHTARG   = scircle,
   PROCEDURE  = scircle_contains_polygon_com_neg,
   COMMUTATOR = '!@>',
   NEGATOR    = '<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !<@ (spoly, scircle) IS 'true if spherical polygon (LHS) is not contained spherical circle (RHS)';

CREATE OPERATOR @> (
   LEFTARG    = spoly,
   RIGHTARG   = scircle,
   PROCEDURE  = spoly_contains_circle,
   COMMUTATOR = '<@',
   NEGATOR    = '!@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR @> (spoly, scircle) IS 'true if spherical polygon (LHS) contains spherical circle (RHS)';

CREATE OPERATOR <@ (
   LEFTARG    = scircle,
   RIGHTARG   = spoly,
   PROCEDURE  = spoly_contains_circle_com,
   COMMUTATOR = '@>',
   NEGATOR    = '!<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR <@ (scircle, spoly) IS 'true if spherical circle (LHS) is contained by spherical polygon (RHS)';

CREATE OPERATOR !@> (
   LEFTARG    = spoly,
   RIGHTARG   = scircle,
   PROCEDURE  = spoly_contains_circle_neg,
   COMMUTATOR = '!<@',
   NEGATOR    = '@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !@> (spoly, scircle) IS 'true if spherical polygon (LHS) does not contain spherical circle (RHS)';

CREATE OPERATOR !<@ (
   LEFTARG    = scircle,
   RIGHTARG   = spoly,
   PROCEDURE  = spoly_contains_circle_com_neg,
   COMMUTATOR = '!@>',
   NEGATOR    = '<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !<@ (scircle, spoly) IS 'true if spherical circle (LHS) is not contained by spherical polygon (RHS)';


--- sbox vs sbox

CREATE OPERATOR @> (
   LEFTARG    = sbox,
   RIGHTARG   = sbox,
   PROCEDURE  = sbox_contains_box,
   COMMUTATOR = '<@',
   NEGATOR    = '!@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR @> (sbox, sbox) IS 'true if spherical box (LHS) contains spherical box (RHS)';

CREATE OPERATOR <@ (
   LEFTARG    = sbox,
   RIGHTARG   = sbox,
   PROCEDURE  = sbox_contains_box_com,
   COMMUTATOR = '@>',
   NEGATOR    = '!<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR <@ (sbox, sbox) IS 'true if spherical box (LHS) is contained by spherical box (RHS)';

CREATE OPERATOR !@> (
   LEFTARG    = sbox,
   RIGHTARG   = sbox,
   PROCEDURE  = sbox_contains_box_neg,
   COMMUTATOR = '!<@',
   NEGATOR    = '@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !@> (sbox, sbox) IS 'true if spherical box (LHS) does not contain spherical box (RHS)';

CREATE OPERATOR !<@ (
   LEFTARG    = sbox,
   RIGHTARG   = sbox,
   PROCEDURE  = sbox_contains_box_com_neg,
   COMMUTATOR = '!@>',
   NEGATOR    = '<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !<@ (sbox, sbox) IS 'true if spherical box (LHS) is not contained by spherical box (RHS)';

--- sbox vs spoint

CREATE OPERATOR @> (
   LEFTARG    = sbox,
   RIGHTARG   = spoint,
   PROCEDURE  = sbox_cont_point,
   COMMUTATOR = '<@',
   NEGATOR    = '!@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR @> (sbox, spoint) IS 'true if spherical box (LHS) contains spherical point (RHS)';

CREATE OPERATOR <@ (
   LEFTARG    = spoint,
   RIGHTARG   = sbox,
   PROCEDURE  = sbox_cont_point_com,
   COMMUTATOR = '@>',
   NEGATOR    = '!<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR <@ (spoint, sbox) IS 'true if spherical point (LHS) is contained by spherical box (RHS)';

CREATE OPERATOR !@> (
   LEFTARG    = sbox,
   RIGHTARG   = spoint,
   PROCEDURE  = sbox_cont_point_neg,
   COMMUTATOR = '!<@',
   NEGATOR    = '@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !@> (sbox, spoint) IS 'true if spherical box (LHS) does not contain spherical point (RHS)';

CREATE OPERATOR !<@ (
   LEFTARG    = spoint,
   RIGHTARG   = sbox,
   PROCEDURE  = sbox_cont_point_com_neg,
   COMMUTATOR = '!@>',
   NEGATOR    = '<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !<@ (spoint, sbox) IS 'true if spherical point (LHS) is not contained by spherical box (RHS)';

--- scircle vs sbox

CREATE OPERATOR @> (
   LEFTARG    = scircle,
   RIGHTARG   = sbox,
   PROCEDURE  = scircle_contains_box,
   COMMUTATOR = '<@',
   NEGATOR    = '!@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR @> (scircle, sbox) IS 'true if spherical circle (LHS) contains spherical box (RHS)';

CREATE OPERATOR <@ (
   LEFTARG    = sbox,
   RIGHTARG   = scircle,
   PROCEDURE  = scircle_contains_box_com,
   COMMUTATOR = '@>',
   NEGATOR    = '!<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR <@ (sbox, scircle) IS 'true if spherical box (LHS) is contained by spherical circle (RHS)';

CREATE OPERATOR !@> (
   LEFTARG    = scircle,
   RIGHTARG   = sbox,
   PROCEDURE  = scircle_contains_box_neg,
   COMMUTATOR = '!<@',
   NEGATOR    = '@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !@> (scircle, sbox) IS 'true if spherical circle (LHS) does not contain spherical box (RHS)';

CREATE OPERATOR !<@ (
   LEFTARG    = sbox,
   RIGHTARG   = scircle,
   PROCEDURE  = scircle_contains_box_com_neg,
   COMMUTATOR = '!@>',
   NEGATOR    = '<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !<@ (sbox, scircle) IS 'true if spherical box (LHS) is not contained by spherical circle (RHS)';

CREATE OPERATOR @> (
   LEFTARG    = sbox,
   RIGHTARG   = scircle,
   PROCEDURE  = sbox_contains_circle,
   COMMUTATOR = '<@',
   NEGATOR    = '!@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR @> (sbox, scircle) IS 'true if spherical box (LHS) contains spherical circle (RHS)';

CREATE OPERATOR <@ (
   LEFTARG    = scircle,
   RIGHTARG   = sbox,
   PROCEDURE  = sbox_contains_circle_com,
   COMMUTATOR = '@>',
   NEGATOR    = '!<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR <@ (scircle, sbox) IS 'true if spherical circle (LHS) contains spherical box (RHS)';

CREATE OPERATOR !@> (
   LEFTARG    = sbox,
   RIGHTARG   = scircle,
   PROCEDURE  = sbox_contains_circle_neg,
   COMMUTATOR = '!<@',
   NEGATOR    = '@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !@> (sbox, scircle) IS 'true if spherical box (LHS) does not contain spherical circle (RHS)';

CREATE OPERATOR !<@ (
   LEFTARG    = scircle,
   RIGHTARG   = sbox,
   PROCEDURE  = sbox_contains_circle_com_neg,
   COMMUTATOR = '!@>',
   NEGATOR    = '<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !<@ (scircle, sbox) IS 'true if spherical circle (LHS) is not contained by spherical box (RHS)';


--- sbox vs spoly

CREATE OPERATOR @> (
   LEFTARG    = spoly,
   RIGHTARG   = sbox,
   PROCEDURE  = spoly_contains_box,
   COMMUTATOR = '<@',
   NEGATOR    = '!@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR @> (spoly, sbox) IS 'true if spherical polygon (LHS) contains spherical box (RHS)';

CREATE OPERATOR <@ (
   LEFTARG    = sbox,
   RIGHTARG   = spoly,
   PROCEDURE  = spoly_contains_box_com,
   COMMUTATOR = '@>',
   NEGATOR    = '!<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR <@ (sbox, spoly) IS 'true if spherical box (LHS) is contained by spherical polygon (RHS)';

CREATE OPERATOR !@> (
   LEFTARG    = spoly,
   RIGHTARG   = sbox,
   PROCEDURE  = spoly_contains_box_neg,
   COMMUTATOR = '!<@',
   NEGATOR    = '@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !@> (spoly, sbox) IS 'true if spherical polygon (LHS) does not contain spherical box (RHS)';

CREATE OPERATOR !<@ (
   LEFTARG    = sbox,
   RIGHTARG   = spoly,
   PROCEDURE  = spoly_contains_box_com_neg,
   COMMUTATOR = '!@>',
   NEGATOR    = '<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !<@ (sbox, spoly) IS 'true if spherical box (LHS) is not contained by spherical polygon (RHS)';

CREATE OPERATOR @> (
   LEFTARG    = sbox,
   RIGHTARG   = spoly,
   PROCEDURE  = sbox_contains_poly,
   COMMUTATOR = '<@',
   NEGATOR    = '!@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR @> (sbox, spoly) IS 'true if spherical box (LHS) contains spherical polygon (RHS)';

CREATE OPERATOR <@ (
   LEFTARG    = spoly,
   RIGHTARG   = sbox,
   PROCEDURE  = sbox_contains_poly_com,
   COMMUTATOR = '@>',
   NEGATOR    = '!<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR <@ (spoly, sbox) IS 'true if spherical polygon (LHS) is contained by spherical box (RHS)';

CREATE OPERATOR !@> (
   LEFTARG    = sbox,
   RIGHTARG   = spoly,
   PROCEDURE  = sbox_contains_poly_neg,
   COMMUTATOR = '!<@',
   NEGATOR    = '@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !@> (sbox, spoly) IS 'true if spherical box (LHS) does not contain spherical polygon (RHS)';

CREATE OPERATOR !<@ (
   LEFTARG    = spoly,
   RIGHTARG   = sbox,
   PROCEDURE  = sbox_contains_poly_com_neg,
   COMMUTATOR = '!@>',
   NEGATOR    = '<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !<@ (spoly, sbox) IS 'true if spherical polygon (LHS) is not contained by spherical box (RHS)';

-- new stuff --

CREATE OPERATOR <@ (
   LEFTARG    = spoint,
   RIGHTARG   = sline,
   PROCEDURE  = sline_contains_point_com,
   COMMUTATOR = '@>',
   NEGATOR    = '!<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR <@ (spoint, sline) IS 'true if spherical point (LHS) is contained by spherical line (RHS)';

CREATE OPERATOR @> (
   LEFTARG    = sline,
   RIGHTARG   = spoint,
   PROCEDURE  = sline_contains_point,
   COMMUTATOR = '<@',
   NEGATOR    = '!@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR @> (sline, spoint) IS 'true if spherical line (LHS) contains the spherical point (RHS)';

CREATE OPERATOR !@> (
   LEFTARG    = sline,
   RIGHTARG   = spoint,
   PROCEDURE  = sline_contains_point_neg,
   COMMUTATOR = '!<@',
   NEGATOR    = '@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !@> (sline, spoint) IS 'true if spherical line (LHS) does not contain spherical point (RHS)';

CREATE OPERATOR !<@ (
   LEFTARG    = spoint,
   RIGHTARG   = sline,
   PROCEDURE  = sline_contains_point_com_neg,
   COMMUTATOR = '!@>',
   NEGATOR    = '<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !<@ (spoint, sline) IS 'true if spherical point (LHS) is not contained by spherical line (RHS)';

CREATE OPERATOR @> (
   LEFTARG    = scircle,
   RIGHTARG   = sline,
   PROCEDURE  = scircle_contains_line,
   COMMUTATOR = '<@',
   NEGATOR    = '!@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR @> (scircle, sline) IS 'true if spherical circle (LHS) contains spherical line (RHS)';

CREATE OPERATOR <@ (
   LEFTARG    = sline,
   RIGHTARG   = scircle,
   PROCEDURE  = scircle_contains_line_com,
   COMMUTATOR = '@>',
   NEGATOR    = '!<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR <@ (sline, scircle) IS 'true if spherical line (LHS) is contained by spherical circle (RHS)';

CREATE OPERATOR !@> (
   LEFTARG    = scircle,
   RIGHTARG   = sline,
   PROCEDURE  = scircle_contains_line_neg,
   COMMUTATOR = '!<@',
   NEGATOR    = '@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !@> (scircle, sline) IS 'true if spherical circle (LHS) does not contain spherical line (RHS)';

CREATE OPERATOR !<@ (
   LEFTARG    = sline,
   RIGHTARG   = scircle,
   PROCEDURE  = scircle_contains_line_com_neg,
   COMMUTATOR = '!@>',
   NEGATOR    = '<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !<@ (sline, scircle) IS 'true if spherical line (LHS) is not contained by spherical circle (RHS)';

CREATE OPERATOR @> (
   LEFTARG    = spoly,
   RIGHTARG   = sline,
   PROCEDURE  = spoly_contains_line,
   COMMUTATOR = '<@',
   NEGATOR    = '!@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR @> (spoly, sline) IS 'true if spherical polygon (LHS) contains spherical line (RHS)';

CREATE OPERATOR <@ (
   LEFTARG    = sline,
   RIGHTARG   = spoly,
   PROCEDURE  = spoly_contains_line_com,
   COMMUTATOR = '@>',
   NEGATOR    = '!<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR <@ (sline, spoly) IS 'true if spherical line (LHS) is contained by spherical polygon (RHS)';

CREATE OPERATOR !@> (
   LEFTARG    = spoly,
   RIGHTARG   = sline,
   PROCEDURE  = spoly_contains_line,
   COMMUTATOR = '!<@',
   NEGATOR    = '@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !@> (spoly, sline) IS 'true if spherical polygon (LHS) does not contain spherical line (RHS)';

CREATE OPERATOR !<@ (
   LEFTARG    = sline,
   RIGHTARG   = spoly,
   PROCEDURE  = spoly_contains_line_com_neg,
   COMMUTATOR = '!@>',
   NEGATOR    = '<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !<@ (sline, spoly) IS 'true if spherical line (LHS) is not contained by spherical polygon (RHS)';



CREATE OPERATOR @> (
   LEFTARG    = sellipse,
   RIGHTARG   = sellipse,
   PROCEDURE  = sellipse_contains_ellipse,
   COMMUTATOR = '<@',
   NEGATOR    = '!@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR @> (sellipse, sellipse) IS 'true if spherical ellipse (LHS) contains spherical ellipse (RHS)';

CREATE OPERATOR <@ (
   LEFTARG    = sellipse,
   RIGHTARG   = sellipse,
   PROCEDURE  = sellipse_contains_ellipse_com,
   COMMUTATOR = '@>',
   NEGATOR    = '!<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR <@ (sellipse, sellipse) IS 'true if spherical ellipse (LHS) is contained by spherical ellipse (RHS)';

CREATE OPERATOR !@> (
   LEFTARG    = sellipse,
   RIGHTARG   = sellipse,
   PROCEDURE  = sellipse_contains_ellipse_neg,
   COMMUTATOR = '!<@',
   NEGATOR    = '@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !@> (sellipse, sellipse) IS 'true if spherical ellipse (LHS) does not contain spherical ellipse (RHS)';

CREATE OPERATOR !<@ (
   LEFTARG    = sellipse,
   RIGHTARG   = sellipse,
   PROCEDURE  = sellipse_contains_ellipse_com_neg,
   COMMUTATOR = '!@>',
   NEGATOR    = '<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !<@ (sellipse, sellipse) IS 'true if spherical ellipse (LHS) is not contained by spherical ellipse (RHS)';


CREATE OPERATOR @> (
   LEFTARG    = sellipse,
   RIGHTARG   = spoint,
   PROCEDURE  = sellipse_contains_point,
   COMMUTATOR = '<@',
   NEGATOR    = '!@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR @> (sellipse, spoint) IS 'true if spherical ellipse (LHS) contains spherical point (RHS)';

CREATE OPERATOR <@ (
   LEFTARG    = spoint,
   RIGHTARG   = sellipse,
   PROCEDURE  = sellipse_contains_point_com,
   COMMUTATOR = '@>',
   NEGATOR    = '!<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR <@ (spoint, sellipse) IS 'true if spherical point (LHS) is contained by spherical ellipse (RHS)';

CREATE OPERATOR !@> (
   LEFTARG    = sellipse,
   RIGHTARG   = spoint,
   PROCEDURE  = sellipse_contains_point_neg,
   COMMUTATOR = '!<@',
   NEGATOR    = '@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !@> (sellipse, spoint) IS 'true if spherical ellipse (LHS) does not contain spherical point (RHS)';

CREATE OPERATOR !<@ (
   LEFTARG    = spoint,
   RIGHTARG   = sellipse,
   PROCEDURE  = sellipse_contains_point_com_neg,
   COMMUTATOR = '!@>',
   NEGATOR    = '<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !<@ (spoint, sellipse) IS 'true if spherical point (LHS) is not contained by spherical ellipse (RHS)';

CREATE OPERATOR @> (
   LEFTARG    = sbox,
   RIGHTARG   = sellipse,
   PROCEDURE  = sbox_contains_ellipse,
   COMMUTATOR = '<@',
   NEGATOR    = '!@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR @> (sbox, sellipse) IS 'true if spherical box (LHS) contains spherical ellipse (RHS)';

CREATE OPERATOR <@ (
   LEFTARG    = sellipse,
   RIGHTARG   = sbox,
   PROCEDURE  = sbox_contains_ellipse_com,
   COMMUTATOR = '@>',
   NEGATOR    = '!<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR <@ (sellipse, sbox) IS
  'true if spherical ellipse (LHS) is contained by spherical box (RHS)';

CREATE OPERATOR !@> (
   LEFTARG    = sbox,
   RIGHTARG   = sellipse,
   PROCEDURE  = sbox_contains_ellipse_neg,
   COMMUTATOR = '!<@',
   NEGATOR    = '@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !@> (sbox, sellipse) IS 'true if spherical box (LHS) does not contain spherical ellipse (RHS)';

CREATE OPERATOR !<@ (
   LEFTARG    = sellipse,
   RIGHTARG   = sbox,
   PROCEDURE  = sbox_contains_ellipse_com_neg,
   COMMUTATOR = '!@>',
   NEGATOR    = '<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !<@ (sellipse, sbox) IS 'true if spherical ellipse (LHS) is not contained by spherical box (RHS)';

CREATE OPERATOR @> (
   LEFTARG    = sellipse,
   RIGHTARG   = sbox,
   PROCEDURE  = sellipse_contains_box,
   COMMUTATOR = '<@',
   NEGATOR    = '!@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR @> (sellipse, sbox) IS 'true if spherical ellipse (LHS) contains spherical box (RHS)';

CREATE OPERATOR <@ (
   LEFTARG    = sbox,
   RIGHTARG   = sellipse,
   PROCEDURE  = sellipse_contains_box_com,
   COMMUTATOR = '@>',
   NEGATOR    = '!<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR <@ (sbox, sellipse) IS 'true if spherical box (LHS) is contained by spherical ellipse (RHS)';

CREATE OPERATOR !@> (
   LEFTARG    = sellipse,
   RIGHTARG   = sbox,
   PROCEDURE  = sellipse_contains_box_neg,
   COMMUTATOR = '!<@',
   NEGATOR    = '@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !@> (sellipse, sbox) IS 'true if spherical ellipse (LHS) does not contain spherical box (RHS)';

CREATE OPERATOR !<@ (
   LEFTARG    = sbox,
   RIGHTARG   = sellipse,
   PROCEDURE  = sellipse_contains_box_com_neg,
   COMMUTATOR = '!@>',
   NEGATOR    = '<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !<@ (sbox, sellipse) IS 'true if spherical box (LHS) is not containe by spherical ellipse (RHS)';

CREATE OPERATOR @> (
   LEFTARG    = sellipse,
   RIGHTARG   = scircle,
   PROCEDURE  = sellipse_contains_circle,
   COMMUTATOR = '<@',
   NEGATOR    = '!@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR @> (sellipse, scircle) IS 'true if spherical ellipse (LHS) contains spherical circle (RHS)';

CREATE OPERATOR <@ (
   LEFTARG    = scircle,
   RIGHTARG   = sellipse,
   PROCEDURE  = sellipse_contains_circle_com,
   COMMUTATOR = '@>',
   NEGATOR    = '!<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR <@ (scircle, sellipse) IS 'true if spherical circle (LHS) is contained by spherical ellipse (RHS)';

CREATE OPERATOR !@> (
   LEFTARG    = sellipse,
   RIGHTARG   = scircle,
   PROCEDURE  = sellipse_contains_circle_neg,
   COMMUTATOR = '!<@',
   NEGATOR    = '@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !@> (sellipse, scircle) IS 'true if spherical ellipse (LHS) does not contain spherical circle (RHS)';

CREATE OPERATOR !<@ (
   LEFTARG    = scircle,
   RIGHTARG   = sellipse,
   PROCEDURE  = sellipse_contains_circle_com_neg,
   COMMUTATOR = '!@>',
   NEGATOR    = '<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !<@ (scircle, sellipse) IS 'true if spherical circle (LHS) is not contained by spherical ellipse (RHS)';

CREATE OPERATOR @> (
   LEFTARG    = scircle,
   RIGHTARG   = sellipse,
   PROCEDURE  = scircle_contains_ellipse,
   COMMUTATOR = '<@',
   NEGATOR    = '!@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR @> (scircle, sellipse) IS 'true if spherical circle (LHS) contains spherical ellipse (RHS)';

CREATE OPERATOR <@ (
   LEFTARG    = sellipse,
   RIGHTARG   = scircle,
   PROCEDURE  = scircle_contains_ellipse_com,
   COMMUTATOR = '@>',
   NEGATOR    = '!<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR <@ (sellipse, scircle) IS 'true if spherical ellipse (LHS) is contained by spherical circle (RHS)';

CREATE OPERATOR !@> (
   LEFTARG    = scircle,
   RIGHTARG   = sellipse,
   PROCEDURE  = scircle_contains_ellipse_neg,
   COMMUTATOR = '!<@',
   NEGATOR    = '@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !@> (scircle, sellipse) IS 'true if spherical circle (LHS) does not contain spherical ellipse (RHS)';


CREATE OPERATOR !<@ (
   LEFTARG    = sellipse,
   RIGHTARG   = scircle,
   PROCEDURE  = scircle_contains_ellipse_com_neg,
   COMMUTATOR = '!@>',
   NEGATOR    = '<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !<@ (sellipse, scircle) IS 'true if spherical ellipse (LHS) is not contained by spherical circle (RHS)';


CREATE OPERATOR @> (
   LEFTARG    = sellipse,
   RIGHTARG   = sline,
   PROCEDURE  = sellipse_contains_line,
   COMMUTATOR = '<@',
   NEGATOR    = '!@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR @> (sellipse, sline) IS 'true if spherical ellipse (LHS) contains spherical line (RHS)';

CREATE OPERATOR <@ (
   LEFTARG    = sline,
   RIGHTARG   = sellipse,
   PROCEDURE  = sellipse_contains_line_com,
   COMMUTATOR = '@>',
   NEGATOR    = '!<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR <@ (sline, sellipse) IS 'true if spherical line is contained by spherical ellipse';

CREATE OPERATOR !@> (
   LEFTARG    = sellipse,
   RIGHTARG   = sline,
   PROCEDURE  = sellipse_contains_line_neg,
   COMMUTATOR = '!<@',
   NEGATOR    = '@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !@> (sellipse, sline) IS 'true if spherical ellipse (LHS) does not contain spherical line (RHS)';

CREATE OPERATOR !<@ (
   LEFTARG    = sline,
   RIGHTARG   = sellipse,
   PROCEDURE  = sellipse_contains_line_com_neg,
   COMMUTATOR = '!@>',
   NEGATOR    = '<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !<@ (sline, sellipse) IS 'true if spherical line (LHS) is not contained by spherical line (RHS)';


CREATE OPERATOR @> (
   LEFTARG    = spoly,
   RIGHTARG   = sellipse,
   PROCEDURE  = spoly_contains_ellipse,
   COMMUTATOR = '<@',
   NEGATOR    = '!@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR @> (spoly, sellipse) IS 'true if spherical polygon (LHS) contains spherical ellipse (RHS)';

CREATE OPERATOR <@ (
   LEFTARG    = sellipse,
   RIGHTARG   = spoly,
   PROCEDURE  = spoly_contains_ellipse_com,
   COMMUTATOR = '@>',
   NEGATOR    = '!<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR <@ (sellipse, spoly) IS 'true if spherical ellipse (LHS) is contained by spherical polygon (RHS)';

CREATE OPERATOR !@> (
   LEFTARG    = spoly,
   RIGHTARG   = sellipse,
   PROCEDURE  = spoly_contains_ellipse_neg,
   COMMUTATOR = '!<@',
   NEGATOR    = '@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !@> (spoly, sellipse) IS 'true if spherical polygon (LHS) does not contain spherical ellipse (RHS)';

CREATE OPERATOR !<@ (
   LEFTARG    = sellipse,
   RIGHTARG   = spoly,
   PROCEDURE  = spoly_contains_ellipse_com_neg,
   COMMUTATOR = '!@>',
   NEGATOR    = '<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !<@ (sellipse, spoly) IS 'true if spherical ellipse (LHS) is not contained by spherical polygon (RHS)';

CREATE OPERATOR @> (
   LEFTARG    = sellipse,
   RIGHTARG   = spoly,
   PROCEDURE  = sellipse_contains_polygon,
   COMMUTATOR = '<@',
   NEGATOR    = '!@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR @> (sellipse, spoly) IS 'true if spherical ellipse (LHS) contains spherical polygon (RHS)';

CREATE OPERATOR <@ (
   LEFTARG    = spoly,
   RIGHTARG   = sellipse,
   PROCEDURE  = sellipse_contains_polygon_com,
   COMMUTATOR = '@>',
   NEGATOR    = '!<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR <@ (spoly, sellipse) IS 'true if spherical polygon (LHS) is contained by spherical ellipse (RHS)';

CREATE OPERATOR !@> (
   LEFTARG    = sellipse,
   RIGHTARG   = spoly,
   PROCEDURE  = sellipse_contains_polygon_neg,
   COMMUTATOR = '!<@',
   NEGATOR    = '@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !@> (sellipse, spoly) IS 'true if spherical ellipse (LHS) does not contain spherical polygon (RHS)';

CREATE OPERATOR !<@ (
   LEFTARG    = spoly,
   RIGHTARG   = sellipse,
   PROCEDURE  = sellipse_contains_polygon_com_neg,
   COMMUTATOR = '!@>',
   NEGATOR    = '<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !<@ (spoly, sellipse) IS 'true if spherical polygon (LHS) is not contained by spherical ellipse (RHS)';

CREATE OPERATOR @> (
   LEFTARG    = spath,
   RIGHTARG   = spoint,
   PROCEDURE  = spath_contains_point,
   COMMUTATOR = '<@',
   NEGATOR    = '!@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR @> (spath, spoint) IS 'true if spherical path (LHS) contains spherical point (RHS)';

CREATE OPERATOR <@ (
   LEFTARG    = spoint,
   RIGHTARG   = spath,
   PROCEDURE  = spath_contains_point_com,
   COMMUTATOR = '@>',
   NEGATOR    = '!<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR <@ (spoint, spath) IS 'true if spherical point (LHS) is contained by spherical path (RHS)';

CREATE OPERATOR !@> (
   LEFTARG    = spath,
   RIGHTARG   = spoint,
   PROCEDURE  = spath_contains_point_neg,
   COMMUTATOR = '!<@',
   NEGATOR    = '@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !@> (spath, spoint) IS 'true if spherical path (LHS) does not contain spherical point (RHS)';

CREATE OPERATOR !<@ (
   LEFTARG    = spoint,
   RIGHTARG   = spath,
   PROCEDURE  = spath_contains_point_com_neg,
   COMMUTATOR = '!@>',
   NEGATOR    = '<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !<@ (spoint, spath) IS 'true if spherical point (LHS) is not contained by spherical path (RHS)';

CREATE OPERATOR @> (
   LEFTARG    = sbox,
   RIGHTARG   = spath,
   PROCEDURE  = sbox_contains_path,
   COMMUTATOR = '<@',
   NEGATOR    = '!@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR @> (sbox, spath) IS 'true if spherical box (LHS) contains spherical path (RHS)';

CREATE OPERATOR <@ (
   LEFTARG    = spath,
   RIGHTARG   = sbox,
   PROCEDURE  = sbox_contains_path_com,
   COMMUTATOR = '@>',
   NEGATOR    = '!<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR <@ (spath, sbox) IS 'true if spherical path is contained by spherical box (RHS)';

CREATE OPERATOR !@> (
   LEFTARG    = sbox,
   RIGHTARG   = spath,
   PROCEDURE  = sbox_contains_path_neg,
   COMMUTATOR = '!<@',
   NEGATOR    = '@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !@> (sbox, spath) IS 'true if spherical box (LHS) does not contain spherical path (RHS)';

CREATE OPERATOR !<@ (
   LEFTARG    = spath,
   RIGHTARG   = sbox,
   PROCEDURE  = sbox_contains_path_com_neg,
   COMMUTATOR = '!@>',
   NEGATOR    = '<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !<@ (spath, sbox) IS
  'true if spherical path (LHS) is not contained by spherical box (RHS)';

CREATE OPERATOR @> (
   LEFTARG    = scircle,
   RIGHTARG   = spath,
   PROCEDURE  = scircle_contains_path,
   COMMUTATOR = '<@',
   NEGATOR    = '!@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR @> (scircle, spath) IS 'true if spherical circle (LHS) contains spherical path (RHS)';

CREATE OPERATOR <@ (
   LEFTARG    = spath,
   RIGHTARG   = scircle,
   PROCEDURE  = scircle_contains_path_com,
   COMMUTATOR = '@>',
   NEGATOR    = '!<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR <@ (spath, scircle) IS 'true if spherical path (LHS) is contained by spherical circle (RHS)';

CREATE OPERATOR !@> (
   LEFTARG    = scircle,
   RIGHTARG   = spath,
   PROCEDURE  = scircle_contains_path_neg,
   COMMUTATOR = '!<@',
   NEGATOR    = '@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !@> (scircle, spath) IS 'true if spherical circle (LHS) does not contain spherical path (RHS)';

CREATE OPERATOR !<@ (
   LEFTARG    = spath,
   RIGHTARG   = scircle,
   PROCEDURE  = scircle_contains_path_com_neg,
   COMMUTATOR = '!@>',
   NEGATOR    = '<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !<@ (spath, scircle) IS 'true if spherical path (LHS) is not contained by spherical circle (RHS)';

CREATE OPERATOR @> (
   LEFTARG    = sellipse,
   RIGHTARG   = spath,
   PROCEDURE  = sellipse_contains_path,
   COMMUTATOR = '<@',
   NEGATOR    = '!@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR @> (sellipse, spath) IS 'true if spherical ellipse (LHS) contains spherical path (RHS)';

CREATE OPERATOR <@ (
   LEFTARG    = spath,
   RIGHTARG   = sellipse,
   PROCEDURE  = sellipse_contains_path_com,
   COMMUTATOR = '@>',
   NEGATOR    = '!<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR <@ (spath, sellipse) IS 'true if spherical path (LHS) is contained by spherical ellipse (RHS)';

CREATE OPERATOR !@> (
   LEFTARG    = sellipse,
   RIGHTARG   = spath,
   PROCEDURE  = sellipse_contains_path_neg,
   COMMUTATOR = '!<@',
   NEGATOR    = '@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !@> (sellipse, spath) IS 'true if spherical ellipse (LHS) does not contain spherical path (RHS)';

CREATE OPERATOR !<@ (
   LEFTARG    = spath,
   RIGHTARG   = sellipse,
   PROCEDURE  = sellipse_contains_path_com_neg,
   COMMUTATOR = '!@>',
   NEGATOR    = '<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !<@ (spath, sellipse) IS 'true if spherical path is not contained by spherical ellipse (RHS)';

CREATE OPERATOR @> (
   LEFTARG    = spoly,
   RIGHTARG   = spath,
   PROCEDURE  = spoly_contains_path,
   COMMUTATOR = '<@',
   NEGATOR    = '!@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR @> (spoly, spath) IS 'true if spherical polygon (LHS) contains spherical path (RHS)';

CREATE OPERATOR <@ (
   LEFTARG    = spath,
   RIGHTARG   = spoly,
   PROCEDURE  = spoly_contains_path_com,
   COMMUTATOR = '@>',
   NEGATOR    = '!<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR <@ (spath, spoly) IS 'true if spherical path (LHS) is contained by spherical polygon (RHS)';

CREATE OPERATOR !@> (
   LEFTARG    = spoly,
   RIGHTARG   = spath,
   PROCEDURE  = spoly_contains_path_neg,
   COMMUTATOR = '!<@',
   NEGATOR    = '@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !@> (spoly, spath) IS 'true if spherical polygon (LHS) does not contain spherical path (RHS)';

CREATE OPERATOR !<@ (
   LEFTARG    = spath,
   RIGHTARG   = spoly,
   PROCEDURE  = spoly_contains_path_com_neg,
   COMMUTATOR = '!@>',
   NEGATOR    = '<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !<@ (spath, spoly) IS 'true if spherical path (LHS) is not contained by spherical polygon (RHS)';

CREATE OPERATOR @> (
   LEFTARG    = sbox,
   RIGHTARG   = sline,
   PROCEDURE  = sbox_contains_line,
   COMMUTATOR = '<@',
   NEGATOR    = '!@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR @> (sbox, sline) IS 'true if spherical box (LHS) contains spherical line (RHS)';

CREATE OPERATOR <@ (
   LEFTARG    = sline,
   RIGHTARG   = sbox,
   PROCEDURE  = sbox_contains_line_com,
   COMMUTATOR = '@>',
   NEGATOR    = '!<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR <@ (sline, sbox) IS 'true if spherical line (LHS) is contained by spherical box (RHS)';

CREATE OPERATOR !@> (
   LEFTARG    = sbox,
   RIGHTARG   = sline,
   PROCEDURE  = sbox_contains_line_neg,
   COMMUTATOR = '!<@',
   NEGATOR    = '@>',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !@> (sbox, sline) IS 'true if spherical box (LHS) does not contain spherical line (RHS)';

CREATE OPERATOR !<@ (
   LEFTARG    = sline,
   RIGHTARG   = sbox,
   PROCEDURE  = sbox_contains_line_com_neg,
   COMMUTATOR = '!@>',
   NEGATOR    = '<@',
   RESTRICT   = contsel,
   JOIN       = contjoinsel
);

COMMENT ON OPERATOR !<@ (sline, sbox) IS 'true if spherical line (LHS) is not contained by spherical box (RHS)';