1-- **************************** 2-- 3-- spherical line functions 4-- 5-- **************************** 6 7CREATE FUNCTION sline(spoint, spoint) 8 RETURNS sline 9 AS 'MODULE_PATHNAME', 'sphereline_from_points' 10 LANGUAGE 'c' 11 IMMUTABLE STRICT; 12 13COMMENT ON FUNCTION sline(spoint, spoint) IS 14 'returns a spherical line using begin (arg1) and end (arg2)'; 15 16CREATE FUNCTION sline(strans, float8) 17 RETURNS sline 18 AS 'MODULE_PATHNAME', 'sphereline_from_trans' 19 LANGUAGE 'c' 20 IMMUTABLE STRICT; 21 22COMMENT ON FUNCTION sline(strans, float8) IS 23 'returns a spherical line using Euler transformation (arg1) and length (arg2)'; 24 25CREATE FUNCTION meridian(float8) 26 RETURNS sline 27 AS 'MODULE_PATHNAME', 'sphereline_meridian' 28 LANGUAGE 'c' 29 IMMUTABLE STRICT; 30 31COMMENT ON FUNCTION meridian(float8) IS 32 'returns a spherical line as a meridian along longitude arg'; 33 34 35CREATE FUNCTION sl_beg(sline) 36 RETURNS spoint 37 AS 'MODULE_PATHNAME', 'sphereline_begin' 38 LANGUAGE 'c' 39 IMMUTABLE STRICT; 40 41COMMENT ON FUNCTION sl_beg(sline) IS 42 'returns the begin of a spherical line'; 43 44CREATE FUNCTION sl_end(sline) 45 RETURNS spoint 46 AS 'MODULE_PATHNAME', 'sphereline_end' 47 LANGUAGE 'c' 48 IMMUTABLE STRICT; 49 50COMMENT ON FUNCTION sl_end(sline) IS 51 'returns the end of a spherical line'; 52 53 54-- 55-- Cast line as Euler transformation 56-- 57 58CREATE FUNCTION strans(sline) 59 RETURNS strans 60 AS 'MODULE_PATHNAME', 'spheretrans_from_line' 61 LANGUAGE 'c' 62 IMMUTABLE STRICT; 63 64COMMENT ON FUNCTION strans(sline) IS 65 'converts line to a transformation (ZXZ)'; 66 67CREATE CAST (sline AS strans) 68 WITH FUNCTION strans(sline) 69 AS IMPLICIT; 70 71 72-- 73-- Cast point as line 74-- 75 76CREATE FUNCTION sline(spoint) 77 RETURNS sline 78 AS 'MODULE_PATHNAME', 'sphereline_from_point' 79 LANGUAGE 'c' 80 IMMUTABLE STRICT; 81 82COMMENT ON FUNCTION sline(spoint) IS 83 'casts a spherical point to a spherical line'; 84 85CREATE CAST (spoint AS sline) 86 WITH FUNCTION sline(spoint) 87 AS IMPLICIT; 88 89 90 91 92 93-- *************************** 94-- 95-- spherical line operators 96-- 97-- *************************** 98 99 100-- 101-- equal 102-- 103 104CREATE FUNCTION sline_equal(sline, sline) 105 RETURNS BOOL 106 AS 'MODULE_PATHNAME', 'sphereline_equal' 107 LANGUAGE 'c' 108 IMMUTABLE STRICT; 109 110COMMENT ON FUNCTION sline_equal(sline, sline) IS 111 'returns true, if spherical lines are equal'; 112 113CREATE OPERATOR = ( 114 LEFTARG = sline, 115 RIGHTARG = sline, 116 COMMUTATOR = = , 117 NEGATOR = <>, 118 PROCEDURE = sline_equal, 119 RESTRICT = contsel, 120 JOIN = contjoinsel 121); 122 123COMMENT ON OPERATOR = (sline, sline) IS 124 'true, if spherical lines are equal'; 125 126 127-- 128-- not equal 129-- 130 131CREATE FUNCTION sline_equal_neg(sline, sline) 132 RETURNS BOOL 133 AS 'MODULE_PATHNAME', 'sphereline_equal_neg' 134 LANGUAGE 'c' 135 IMMUTABLE STRICT; 136 137COMMENT ON FUNCTION sline_equal_neg(sline, sline) IS 138 'returns true, if spherical lines are not equal'; 139 140CREATE OPERATOR <> ( 141 LEFTARG = sline, 142 RIGHTARG = sline, 143 COMMUTATOR = <>, 144 NEGATOR = = , 145 PROCEDURE = sline_equal_neg, 146 RESTRICT = contsel, 147 JOIN = contjoinsel 148); 149 150COMMENT ON OPERATOR <> (sline, sline) IS 151 'true, if spherical lines are not equal'; 152 153 154-- 155-- length 156-- 157 158CREATE FUNCTION length(sline) 159 RETURNS FLOAT8 160 AS 'MODULE_PATHNAME', 'sphereline_length' 161 LANGUAGE 'c' 162 IMMUTABLE STRICT; 163 164COMMENT ON FUNCTION length(sline) IS 165 'returns the length of a spherical line (in radians)'; 166 167 168CREATE OPERATOR @-@ ( 169 RIGHTARG = sline, 170 PROCEDURE = length 171); 172 173COMMENT ON OPERATOR @-@ (NONE, sline) IS 174 'length of spherical line'; 175 176-- 177-- swap begin and end 178-- 179 180CREATE FUNCTION swap(sline) 181 RETURNS sline 182 AS 'MODULE_PATHNAME', 'sphereline_swap_beg_end' 183 LANGUAGE 'c' 184 IMMUTABLE STRICT; 185 186COMMENT ON FUNCTION swap(sline) IS 187 'returns a spherical line with swapped begin and end'; 188 189CREATE OPERATOR - ( 190 RIGHTARG = sline, 191 PROCEDURE = swap 192); 193 194COMMENT ON OPERATOR - (NONE, sline) IS 195 'swaps begin and and of a spherical line'; 196 197-- 198-- turns path of line 199-- 200 201CREATE FUNCTION turn(sline) 202 RETURNS sline 203 AS 'MODULE_PATHNAME', 'sphereline_turn' 204 LANGUAGE 'c' 205 IMMUTABLE STRICT; 206 207COMMENT ON FUNCTION turn(sline) IS 208 'returns a turned spherical line but keeps begin and end'; 209 210CREATE OPERATOR ! ( 211 RIGHTARG = sline, 212 PROCEDURE = turn 213); 214 215COMMENT ON OPERATOR ! (NONE, sline) IS 216 'turns a spherical line, but keep begin and end,'; 217 218 219 220-- 221-- line crossing 222-- 223 224CREATE FUNCTION sline_crosses(sline, sline) 225 RETURNS BOOL 226 AS 'MODULE_PATHNAME', 'sphereline_crosses' 227 LANGUAGE 'c' 228 IMMUTABLE STRICT; 229 230COMMENT ON FUNCTION sline_crosses(sline, sline) IS 231 'returns true if spherical lines cross'; 232 233 234CREATE OPERATOR # ( 235 LEFTARG = sline, 236 RIGHTARG = sline, 237 COMMUTATOR = #, 238 NEGATOR = !#, 239 PROCEDURE = sline_crosses, 240 RESTRICT = contsel, 241 JOIN = contjoinsel 242); 243 244COMMENT ON OPERATOR # (sline, sline) IS 245 'true, if spherical lines cross'; 246 247 248-- 249-- lines do not cross 250-- 251 252CREATE FUNCTION sline_crosses_neg(sline, sline) 253 RETURNS BOOL 254 AS 'MODULE_PATHNAME', 'sphereline_crosses_neg' 255 LANGUAGE 'c' 256 IMMUTABLE STRICT; 257 258COMMENT ON FUNCTION sline_crosses_neg(sline, sline) IS 259 'returns true if spherical lines do not cross'; 260 261 262CREATE OPERATOR !# ( 263 LEFTARG = sline, 264 RIGHTARG = sline, 265 COMMUTATOR = !#, 266 NEGATOR = #, 267 PROCEDURE = sline_crosses_neg, 268 RESTRICT = contsel, 269 JOIN = contjoinsel 270); 271 272COMMENT ON OPERATOR !# (sline, sline) IS 273 'true, if spherical lines do not cross'; 274 275 276-- 277-- lines overlap 278-- 279 280CREATE FUNCTION sline_overlap(sline, sline) 281 RETURNS BOOL 282 AS 'MODULE_PATHNAME', 'sphereline_overlap' 283 LANGUAGE 'c' 284 IMMUTABLE STRICT; 285 286COMMENT ON FUNCTION sline_overlap(sline, sline) IS 287 'returns true if spherical lines overlap or cross'; 288 289 290CREATE OPERATOR && ( 291 LEFTARG = sline, 292 RIGHTARG = sline, 293 PROCEDURE = sline_overlap, 294 COMMUTATOR = '&&', 295 NEGATOR = '!&&', 296 RESTRICT = contsel, 297 JOIN = contjoinsel 298); 299 300COMMENT ON OPERATOR && (sline, sline) IS 301 'true if spherical line overlap or cross'; 302 303-- 304-- lines do not overlap 305-- 306 307CREATE FUNCTION sline_overlap_neg(sline, sline) 308 RETURNS BOOL 309 AS 'MODULE_PATHNAME', 'sphereline_overlap_neg' 310 LANGUAGE 'c' 311 IMMUTABLE STRICT; 312 313COMMENT ON FUNCTION sline_overlap_neg(sline, sline) IS 314 'returns true if spherical lines do not overlap or cross'; 315 316CREATE OPERATOR !&& ( 317 LEFTARG = sline, 318 RIGHTARG = sline, 319 PROCEDURE = sline_overlap, 320 COMMUTATOR = '!&&', 321 NEGATOR = '&&', 322 RESTRICT = contsel, 323 JOIN = contjoinsel 324); 325 326COMMENT ON OPERATOR !&& (sline, sline) IS 327 'true if spherical lines do not overlap or cross'; 328 329 330 331-- 332-- line contains point 333-- 334 335 336CREATE FUNCTION sline_contains_point (sline, spoint) 337 RETURNS BOOL 338 AS 'MODULE_PATHNAME', 'sphereline_cont_point' 339 LANGUAGE 'c' 340 IMMUTABLE STRICT; 341 342COMMENT ON FUNCTION sline_contains_point (sline, spoint) IS 343 'returns true if spherical line contains spherical point'; 344 345 346-- 347-- point is contained by line 348-- 349 350 351CREATE FUNCTION sline_contains_point_com (spoint, sline) 352 RETURNS BOOL 353 AS 'MODULE_PATHNAME', 'sphereline_cont_point_com' 354 LANGUAGE 'c' 355 IMMUTABLE STRICT; 356 357COMMENT ON FUNCTION sline_contains_point_com (spoint, sline) IS 358 'returns true if spherical line contains spherical point'; 359 360 361-- 362-- line does not contain point 363-- 364 365CREATE FUNCTION sline_contains_point_neg (sline, spoint) 366 RETURNS BOOL 367 AS 'MODULE_PATHNAME', 'sphereline_cont_point_neg' 368 LANGUAGE 'c' 369 IMMUTABLE STRICT; 370 371COMMENT ON FUNCTION sline_contains_point_neg (sline, spoint) IS 372 'returns true if spherical line does not contain spherical point'; 373 374-- 375-- point is not contained by line 376-- 377 378 379CREATE FUNCTION sline_contains_point_com_neg (spoint, sline) 380 RETURNS BOOL 381 AS 'MODULE_PATHNAME', 'sphereline_cont_point_com_neg' 382 LANGUAGE 'c' 383 IMMUTABLE STRICT; 384 385COMMENT ON FUNCTION sline_contains_point_com_neg (spoint, sline) IS 386 'returns true if spherical line does not contain spherical point'; 387 388-- 389-- Transformation of line 390-- 391 392CREATE FUNCTION strans_line(sline, strans) 393 RETURNS sline 394 AS 'MODULE_PATHNAME', 'spheretrans_line' 395 LANGUAGE 'c' 396 IMMUTABLE STRICT; 397 398COMMENT ON FUNCTION strans_line (sline, strans) IS 399 'returns a transformated spherical line'; 400 401CREATE OPERATOR + ( 402 LEFTARG = sline, 403 RIGHTARG = strans, 404 PROCEDURE = strans_line 405); 406 407COMMENT ON OPERATOR + (sline, strans) IS 408 'transforms a spherical line'; 409 410 411CREATE FUNCTION strans_line_inverse(sline, strans) 412 RETURNS sline 413 AS 'MODULE_PATHNAME', 'spheretrans_line_inverse' 414 LANGUAGE 'c' 415 IMMUTABLE STRICT; 416 417COMMENT ON FUNCTION strans_line_inverse (sline, strans) IS 418 'returns a inverse transformated spherical line'; 419 420 421CREATE OPERATOR - ( 422 LEFTARG = sline, 423 RIGHTARG = strans, 424 PROCEDURE = strans_line_inverse 425); 426 427COMMENT ON OPERATOR - (sline, strans) IS 428 'transforms inverse a spherical line'; 429 430-- 431-- line overlaps circle 432-- 433 434CREATE FUNCTION sline_overlap_circle(sline, scircle) 435 RETURNS BOOL 436 AS 'MODULE_PATHNAME', 'sphereline_overlap_circle' 437 LANGUAGE 'c' 438 IMMUTABLE STRICT; 439 440COMMENT ON FUNCTION sline_overlap_circle(sline, scircle) IS 441 'returns true if spherical line overlaps spherical circle'; 442 443 444CREATE OPERATOR && ( 445 LEFTARG = sline, 446 RIGHTARG = scircle, 447 PROCEDURE = sline_overlap_circle, 448 COMMUTATOR = '&&', 449 NEGATOR = '!&&' , 450 RESTRICT = contsel, 451 JOIN = contjoinsel 452); 453 454COMMENT ON OPERATOR && (sline, scircle) IS 455 'true if spherical line overlaps spherical circle'; 456 457-- 458-- circle overlaps line 459-- 460 461CREATE FUNCTION sline_overlap_circle_com(scircle, sline) 462 RETURNS BOOL 463 AS 'MODULE_PATHNAME', 'sphereline_overlap_circle_com' 464 LANGUAGE 'c' 465 IMMUTABLE STRICT; 466 467COMMENT ON FUNCTION sline_overlap_circle_com(scircle, sline) IS 468 'returns true if spherical line overlaps spherical circle'; 469 470 471CREATE OPERATOR && ( 472 LEFTARG = scircle, 473 RIGHTARG = sline, 474 PROCEDURE = sline_overlap_circle_com, 475 COMMUTATOR = '&&', 476 NEGATOR = '!&&' , 477 RESTRICT = contsel, 478 JOIN = contjoinsel 479); 480 481COMMENT ON OPERATOR && (scircle, sline) IS 482 'true if spherical line overlaps spherical circle'; 483 484-- 485-- line does not overlap circle 486-- 487 488CREATE FUNCTION sline_overlap_circle_neg(sline, scircle) 489 RETURNS BOOL 490 AS 'MODULE_PATHNAME', 'sphereline_overlap_circle_neg' 491 LANGUAGE 'c' 492 IMMUTABLE STRICT; 493 494COMMENT ON FUNCTION sline_overlap_circle_neg(sline, scircle) IS 495 'returns true if spherical line does not overlap spherical circle'; 496 497 498CREATE OPERATOR !&& ( 499 LEFTARG = sline, 500 RIGHTARG = scircle, 501 PROCEDURE = sline_overlap_circle_neg, 502 COMMUTATOR = '!&&', 503 NEGATOR = '&&' , 504 RESTRICT = contsel, 505 JOIN = contjoinsel 506); 507 508COMMENT ON OPERATOR !&& (sline, scircle) IS 509 'true if spherical line does not overlap spherical circle'; 510 511-- 512-- circle does not overlap line 513-- 514 515CREATE FUNCTION sline_overlap_circle_com_neg(scircle, sline) 516 RETURNS BOOL 517 AS 'MODULE_PATHNAME', 'sphereline_overlap_circle_com_neg' 518 LANGUAGE 'c' 519 IMMUTABLE STRICT; 520 521COMMENT ON FUNCTION sline_overlap_circle_com_neg(scircle, sline) IS 522 'returns true if spherical line overlaps spherical circle'; 523 524 525CREATE OPERATOR !&& ( 526 LEFTARG = scircle, 527 RIGHTARG = sline, 528 PROCEDURE = sline_overlap_circle_com, 529 COMMUTATOR = '!&&', 530 NEGATOR = '&&', 531 RESTRICT = contsel, 532 JOIN = contjoinsel 533); 534 535COMMENT ON OPERATOR !&& (scircle, sline) IS 536 'true if spherical line does not overlap spherical circle'; 537 538 539-- 540-- circle contains line 541-- 542 543 544CREATE FUNCTION scircle_contains_line(scircle, sline) 545 RETURNS BOOL 546 AS 'MODULE_PATHNAME', 'spherecircle_cont_line' 547 LANGUAGE 'c' 548 IMMUTABLE STRICT; 549 550COMMENT ON FUNCTION scircle_contains_line(scircle, sline) IS 551 'returns true if spherical circle contains spherical line'; 552 553 554-- 555-- line is contained by circle 556-- 557 558 559CREATE FUNCTION scircle_contains_line_com(sline, scircle) 560 RETURNS BOOL 561 AS 'MODULE_PATHNAME', 'spherecircle_cont_line_com' 562 LANGUAGE 'c' 563 IMMUTABLE STRICT; 564 565COMMENT ON FUNCTION scircle_contains_line_com(sline, scircle) IS 566 'returns true if spherical circle contains spherical line'; 567 568-- 569-- circle does not contain line 570-- 571 572CREATE FUNCTION scircle_contains_line_neg(scircle, sline) 573 RETURNS BOOL 574 AS 'MODULE_PATHNAME', 'spherecircle_cont_line_neg' 575 LANGUAGE 'c' 576 IMMUTABLE STRICT; 577 578COMMENT ON FUNCTION scircle_contains_line_neg(scircle, sline) IS 579 'returns true if spherical circle does not contain spherical line'; 580 581 582-- 583-- line is not contained by circle 584-- 585 586CREATE FUNCTION scircle_contains_line_com_neg(sline, scircle) 587 RETURNS BOOL 588 AS 'MODULE_PATHNAME', 'spherecircle_cont_line_com_neg' 589 LANGUAGE 'c' 590 IMMUTABLE STRICT; 591 592COMMENT ON FUNCTION scircle_contains_line_com_neg(sline, scircle) IS 593 'returns true if spherical circle does not contain spherical line'; 594 595 596