-- declare old-style contains operators
-- (akin to built-in geometry operators before PostgreSQL 8.2),
-- adapted from 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 elli[pse (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 elli[pse (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)';