182 subroutine direct(a, f, lat1, lon1, azi1, s12a12, flags,
183 + lat2, lon2, azi2, omask, a12s12, m12, MM12, MM21, SS12)
185 double precision a, f, lat1, lon1, azi1, s12a12
188 double precision lat2, lon2, azi2
190 double precision a12s12, m12, MM12, MM21, SS12
192 integer ord, nC1, nC1p, nC2, nA3, nA3x, nC3, nC3x, nC4, nC4x
193 parameter(ord = 6, nc1 = ord, nc1p = ord,
194 + nc2 = ord, na3 = ord, na3x = na3,
195 + nc3 = ord, nc3x = (nc3 * (nc3 - 1)) / 2,
196 + nc4 = ord, nc4x = (nc4 * (nc4 + 1)) / 2)
197 double precision A3x(0:nA3x-1), C3x(0:nC3x-1), C4x(0:nC4x-1),
198 + c1a(nc1), c1pa(nc1p), c2a(nc2), c3a(nc3-1), c4a(0:nc4-1)
200 double precision atanhx, hypotx,
201 + angnm, angrnd, trgsum, a1m1f, a2m1f, a3f, atn2dx, latfix
202 logical arcmod, unroll, arcp, redlp, scalp, areap
203 double precision e2, f1, ep2, n, b, c2,
204 + salp0, calp0, k2, eps,
205 + salp1, calp1, ssig1, csig1, cbet1, sbet1, dn1, somg1, comg1,
206 + salp2, calp2, ssig2, csig2, sbet2, cbet2, dn2, somg2, comg2,
207 + ssig12, csig12, salp12, calp12, omg12, lam12, lon12,
208 + sig12, stau1, ctau1, tau12, t, s, c, serr, e,
209 + a1m1, a2m1, a3c, a4, ab1, ab2,
210 + b11, b12, b21, b22, b31, b41, b42, j12
212 double precision dblmin, dbleps, pi, degree, tiny,
213 + tol0, tol1, tol2, tolb, xthrsh
214 integer digits, maxit1, maxit2
216 common /geocom/ dblmin, dbleps, pi, degree, tiny,
217 + tol0, tol1, tol2, tolb, xthrsh, digits, maxit1, maxit2, init
219 if (.not.init)
call geoini
228 arcmod = mod(flags/1, 2) .eq. 1
229 unroll = mod(flags/2, 2) .eq. 1
231 arcp = mod(omask/1, 2) .eq. 1
232 redlp = mod(omask/2, 2) .eq. 1
233 scalp = mod(omask/4, 2) .eq. 1
234 areap = mod(omask/8, 2) .eq. 1
239 else if (e2 .gt. 0)
then
240 c2 = (a**2 + b**2 * atanhx(sqrt(e2)) / sqrt(e2)) / 2
242 c2 = (a**2 + b**2 * atan(sqrt(abs(e2))) / sqrt(abs(e2))) / 2
248 if (areap)
call c4cof(n, c4x)
251 call sncsdx(angrnd(azi1), salp1, calp1)
253 call sncsdx(angrnd(latfix(lat1)), sbet1, cbet1)
255 call norm2x(sbet1, cbet1)
257 cbet1 = max(tiny, cbet1)
258 dn1 = sqrt(1 + ep2 * sbet1**2)
262 salp0 = salp1 * cbet1
265 calp0 = hypotx(calp1, salp1 * sbet1)
276 somg1 = salp0 * sbet1
277 if (sbet1 .ne. 0 .or. calp1 .ne. 0)
then
278 csig1 = cbet1 * calp1
284 call norm2x(ssig1, csig1)
288 eps = k2 / (2 * (1 + sqrt(1 + k2)) + k2)
292 b11 = trgsum(.true., ssig1, csig1, c1a, nc1)
296 stau1 = ssig1 * c + csig1 * s
297 ctau1 = csig1 * c - ssig1 * s
301 if (.not. arcmod)
call c1pf(eps, c1pa)
303 if (redlp .or. scalp)
then
306 b21 = trgsum(.true., ssig1, csig1, c2a, nc2)
313 call c3f(eps, c3x, c3a)
314 a3c = -f * salp0 * a3f(eps, a3x)
315 b31 = trgsum(.true., ssig1, csig1, c3a, nc3-1)
318 call c4f(eps, c4x, c4a)
320 a4 = a**2 * calp0 * salp0 * e2
321 b41 = trgsum(.false., ssig1, csig1, c4a, nc4)
330 sig12 = s12a12 * degree
331 call sncsdx(s12a12, ssig12, csig12)
336 tau12 = s12a12 / (b * (1 + a1m1))
340 b12 = - trgsum(.true.,
341 + stau1 * c + ctau1 * s, ctau1 * c - stau1 * s, c1pa, nc1p)
342 sig12 = tau12 - (b12 - b11)
345 if (abs(f) .gt. 0.01d0)
then
367 ssig2 = ssig1 * csig12 + csig1 * ssig12
368 csig2 = csig1 * csig12 - ssig1 * ssig12
369 b12 = trgsum(.true., ssig2, csig2, c1a, nc1)
370 serr = (1 + a1m1) * (sig12 + (b12 - b11)) - s12a12 / b
371 sig12 = sig12 - serr / sqrt(1 + k2 * ssig2**2)
379 ssig2 = ssig1 * csig12 + csig1 * ssig12
380 csig2 = csig1 * csig12 - ssig1 * ssig12
381 dn2 = sqrt(1 + k2 * ssig2**2)
382 if (arcmod .or. abs(f) .gt. 0.01d0)
383 + b12 = trgsum(.true., ssig2, csig2, c1a, nc1)
384 ab1 = (1 + a1m1) * (b12 - b11)
387 sbet2 = calp0 * ssig2
389 cbet2 = hypotx(salp0, calp0 * csig2)
390 if (cbet2 .eq. 0)
then
397 somg2 = salp0 * ssig2
402 calp2 = calp0 * csig2
408 + - (atan2( ssig2, csig2) - atan2( ssig1, csig1))
409 + + (atan2(e * somg2, comg2) - atan2(e * somg1, comg1)))
411 omg12 = atan2(somg2 * comg1 - comg2 * somg1,
412 + comg2 * comg1 + somg2 * somg1)
415 lam12 = omg12 + a3c *
416 + ( sig12 + (trgsum(.true., ssig2, csig2, c3a, nc3-1)
418 lon12 = lam12 / degree
422 lon2 = angnm(angnm(lon1) + angnm(lon12))
424 lat2 = atn2dx(sbet2, f1 * cbet2)
425 azi2 = atn2dx(salp2, calp2)
427 if (redlp .or. scalp)
then
428 b22 = trgsum(.true., ssig2, csig2, c2a, nc2)
429 ab2 = (1 + a2m1) * (b22 - b21)
430 j12 = (a1m1 - a2m1) * sig12 + (ab1 - ab2)
434 if (redlp) m12 = b * ((dn2 * (csig1 * ssig2) -
435 + dn1 * (ssig1 * csig2)) - csig1 * csig2 * j12)
437 t = k2 * (ssig2 - ssig1) * (ssig2 + ssig1) / (dn1 + dn2)
438 mm12 = csig12 + (t * ssig2 - csig2 * j12) * ssig1 / dn1
439 mm21 = csig12 - (t * ssig1 - csig1 * j12) * ssig2 / dn2
443 b42 = trgsum(.false., ssig2, csig2, c4a, nc4)
444 if (calp0 .eq. 0 .or. salp0 .eq. 0)
then
446 salp12 = salp2 * calp1 - calp2 * salp1
447 calp12 = calp2 * calp1 + salp2 * salp1
457 if (csig12 .le. 0)
then
458 salp12 = csig1 * (1 - csig12) + ssig12 * ssig1
460 salp12 = ssig12 * (csig1 * ssig12 / (1 + csig12) + ssig1)
462 salp12 = calp0 * salp0 * salp12
463 calp12 = salp0**2 + calp0**2 * csig1 * csig2
465 ss12 = c2 * atan2(salp12, calp12) + a4 * (b42 - b41)
470 a12s12 = b * ((1 + a1m1) * sig12 + ab1)
472 a12s12 = sig12 / degree
524 subroutine invers(a, f, lat1, lon1, lat2, lon2,
525 + s12, azi1, azi2, omask, a12, m12, MM12, MM21, SS12)
527 double precision a, f, lat1, lon1, lat2, lon2
530 double precision s12, azi1, azi2
532 double precision a12, m12, MM12, MM21, SS12
534 integer ord, nA3, nA3x, nC3, nC3x, nC4, nC4x, nC
535 parameter (ord = 6, na3 = ord, na3x = na3,
536 + nc3 = ord, nc3x = (nc3 * (nc3 - 1)) / 2,
537 + nc4 = ord, nc4x = (nc4 * (nc4 + 1)) / 2,
539 double precision A3x(0:nA3x-1), C3x(0:nC3x-1), C4x(0:nC4x-1),
542 double precision atanhx, hypotx,
543 + AngDif, AngRnd, TrgSum, Lam12f, InvSta, atn2dx, LatFix
544 integer latsgn, lonsgn, swapp, numit
545 logical arcp, redlp, scalp, areap, merid, tripn, tripb
547 double precision e2, f1, ep2, n, b, c2,
548 + lat1x, lat2x, salp0, calp0, k2, eps,
549 + salp1, calp1, ssig1, csig1, cbet1, sbet1, dbet1, dn1,
550 + salp2, calp2, ssig2, csig2, sbet2, cbet2, dbet2, dn2,
551 + slam12, clam12, salp12, calp12, omg12, lam12, lon12, lon12s,
552 + salp1a, calp1a, salp1b, calp1b,
553 + dalp1, sdalp1, cdalp1, nsalp1, alp12, somg12, comg12, domg12,
554 + sig12, v, dv, dnm, dummy,
555 + a4, b41, b42, s12x, m12x, a12x, sdomg12, cdomg12
557 double precision dblmin, dbleps, pi, degree, tiny,
558 + tol0, tol1, tol2, tolb, xthrsh
559 integer digits, maxit1, maxit2, lmask
561 common /geocom/ dblmin, dbleps, pi, degree, tiny,
562 + tol0, tol1, tol2, tolb, xthrsh, digits, maxit1, maxit2, init
564 if (.not.init)
call geoini
573 arcp = mod(omask/1, 2) .eq. 1
574 redlp = mod(omask/2, 2) .eq. 1
575 scalp = mod(omask/4, 2) .eq. 1
576 areap = mod(omask/8, 2) .eq. 1
586 else if (e2 .gt. 0)
then
587 c2 = (a**2 + b**2 * atanhx(sqrt(e2)) / sqrt(e2)) / 2
589 c2 = (a**2 + b**2 * atan(sqrt(abs(e2))) / sqrt(abs(e2))) / 2
595 if (areap)
call c4cof(n, c4x)
601 lon12 = angdif(lon1, lon2, lon12s)
603 lonsgn = int(sign(1d0, lon12))
604 lon12 = lonsgn * lon12
605 lon12s = lonsgn * lon12s
606 lam12 = lon12 * degree
608 call sncsde(lon12, lon12s, slam12, clam12)
610 lon12s = (180 - lon12) - lon12s
613 lat1x = angrnd(latfix(lat1))
614 lat2x = angrnd(latfix(lat2))
617 if (abs(lat1x) .lt. abs(lat2x) .or. lat2x .ne. lat2x)
then
622 if (swapp .lt. 0)
then
624 call swap(lat1x, lat2x)
627 latsgn = int(sign(1d0, -lat1x))
628 lat1x = lat1x * latsgn
629 lat2x = lat2x * latsgn
642 call sncsdx(lat1x, sbet1, cbet1)
644 call norm2x(sbet1, cbet1)
646 cbet1 = max(tiny, cbet1)
648 call sncsdx(lat2x, sbet2, cbet2)
650 call norm2x(sbet2, cbet2)
652 cbet2 = max(tiny, cbet2)
663 if (cbet1 .lt. -sbet1)
then
664 if (cbet2 .eq. cbet1) sbet2 = sign(sbet1, sbet2)
666 if (abs(sbet2) .eq. -sbet1) cbet2 = cbet1
669 dn1 = sqrt(1 + ep2 * sbet1**2)
670 dn2 = sqrt(1 + ep2 * sbet2**2)
674 merid = lat1x .eq. -90 .or. slam12 .eq. 0
690 csig1 = calp1 * cbet1
692 csig2 = calp2 * cbet2
695 sig12 = atan2(max(0d0, csig1 * ssig2 - ssig1 * csig2) + 0d0,
696 + csig1 * csig2 + ssig1 * ssig2)
697 call lengs(n, sig12, ssig1, csig1, dn1, ssig2, csig2, dn2,
698 + cbet1, cbet2, lmask,
699 + s12x, m12x, dummy, mm12, mm21, ep2, ca)
708 if (sig12 .lt. tol2 .or. m12x .ge. 0)
then
709 if (sig12 .lt. 3 * tiny .or.
710 + (sig12 .lt. tol0 .and.
711 + (s12x .lt. 0 .or. m12x .lt. 0)))
then
719 a12x = sig12 / degree
730 if (.not. merid .and. sbet1 .eq. 0 .and.
731 + (f .le. 0 .or. lon12s .ge. f * 180))
then
741 m12x = b * sin(sig12)
747 else if (.not. merid)
then
752 sig12 = invsta(sbet1, cbet1, dn1, sbet2, cbet2, dn2, lam12,
753 + slam12, clam12, f, a3x, salp1, calp1, salp2, calp2, dnm, ca)
755 if (sig12 .ge. 0)
then
757 s12x = sig12 * b * dnm
758 m12x = dnm**2 * b * sin(sig12 / dnm)
760 mm12 = cos(sig12 / dnm)
763 a12x = sig12 / degree
764 omg12 = lam12 / (f1 * dnm)
786 do 10 numit = 0, maxit2
789 v = lam12f(sbet1, cbet1, dn1, sbet2, cbet2, dn2,
790 + salp1, calp1, slam12, clam12, f, a3x, c3x, salp2, calp2,
791 + sig12, ssig1, csig1, ssig2, csig2,
792 + eps, domg12, numit .lt. maxit1, dv, ca)
799 if (tripb .or. .not. (abs(v) .ge. dummy * tol0) .or.
800 + numit .eq. maxit2)
go to 20
802 if (v .gt. 0 .and. (numit .gt. maxit1 .or.
803 + calp1/salp1 .gt. calp1b/salp1b))
then
806 else if (v .lt. 0 .and. (numit .gt. maxit1 .or.
807 + calp1/salp1 .lt. calp1a/salp1a))
then
811 if (numit .lt. maxit1 .and. dv .gt. 0)
then
813 if (abs(dalp1) .lt. pi)
then
816 nsalp1 = salp1 * cdalp1 + calp1 * sdalp1
817 if (nsalp1 .gt. 0)
then
818 calp1 = calp1 * cdalp1 - salp1 * sdalp1
820 call norm2x(salp1, calp1)
824 tripn = abs(v) .le. 16 * tol0
837 salp1 = (salp1a + salp1b)/2
838 calp1 = (calp1a + calp1b)/2
839 call norm2x(salp1, calp1)
841 tripb = abs(salp1a - salp1) + (calp1a - calp1) .lt. tolb
842 + .or. abs(salp1 - salp1b) + (calp1 - calp1b) .lt. tolb
845 call lengs(eps, sig12, ssig1, csig1, dn1, ssig2, csig2, dn2,
846 + cbet1, cbet2, lmask,
847 + s12x, m12x, dummy, mm12, mm21, ep2, ca)
850 a12x = sig12 / degree
852 sdomg12 = sin(domg12)
853 cdomg12 = cos(domg12)
854 somg12 = slam12 * cdomg12 - clam12 * sdomg12
855 comg12 = clam12 * cdomg12 + slam12 * sdomg12
862 if (redlp) m12 = 0 + m12x
866 salp0 = salp1 * cbet1
867 calp0 = hypotx(calp1, salp1 * sbet1)
868 if (calp0 .ne. 0 .and. salp0 .ne. 0)
then
871 csig1 = calp1 * cbet1
873 csig2 = calp2 * cbet2
875 eps = k2 / (2 * (1 + sqrt(1 + k2)) + k2)
877 a4 = a**2 * calp0 * salp0 * e2
878 call norm2x(ssig1, csig1)
879 call norm2x(ssig2, csig2)
880 call c4f(eps, c4x, ca)
881 b41 = trgsum(.false., ssig1, csig1, ca, nc4)
882 b42 = trgsum(.false., ssig2, csig2, ca, nc4)
883 ss12 = a4 * (b42 - b41)
889 if (.not. merid .and. somg12 .eq. 2)
then
894 if (.not. merid .and. comg12 .ge. 0.7071d0
895 + .and. sbet2 - sbet1 .lt. 1.75d0)
then
902 alp12 = 2 * atan2(somg12 * (sbet1 * dbet2 + sbet2 * dbet1),
903 + domg12 * ( sbet1 * sbet2 + dbet1 * dbet2 ) )
906 salp12 = salp2 * calp1 - calp2 * salp1
907 calp12 = calp2 * calp1 + salp2 * salp1
912 if (salp12 .eq. 0 .and. calp12 .lt. 0)
then
913 salp12 = tiny * calp1
916 alp12 = atan2(salp12, calp12)
918 ss12 = ss12 + c2 * alp12
919 ss12 = ss12 * swapp * lonsgn * latsgn
925 if (swapp .lt. 0)
then
926 call swap(salp1, salp2)
927 call swap(calp1, calp2)
928 if (scalp)
call swap(mm12, mm21)
931 salp1 = salp1 * swapp * lonsgn
932 calp1 = calp1 * swapp * latsgn
933 salp2 = salp2 * swapp * lonsgn
934 calp2 = calp2 * swapp * latsgn
936 azi1 = atn2dx(salp1, calp1)
937 azi2 = atn2dx(salp2, calp2)
964 subroutine area(a, f, lats, lons, n, AA, PP)
967 double precision a, f, lats(n), lons(n)
969 double precision AA, PP
971 integer i, omask, cross, trnsit
972 double precision s12, azi1, azi2, dummy, SS12, b, e2, c2, area0,
973 + atanhx, aacc(2), pacc(2)
975 double precision dblmin, dbleps, pi, degree, tiny,
976 + tol0, tol1, tol2, tolb, xthrsh
977 integer digits, maxit1, maxit2
979 common /geocom/ dblmin, dbleps, pi, degree, tiny,
980 + tol0, tol1, tol2, tolb, xthrsh, digits, maxit1, maxit2, init
987 call invers(a, f, lats(i+1), lons(i+1),
988 + lats(mod(i+1,n)+1), lons(mod(i+1,n)+1),
989 + s12, azi1, azi2, omask, dummy, dummy, dummy, dummy, ss12)
990 call accadd(pacc, s12)
991 call accadd(aacc, -ss12)
992 cross = cross + trnsit(lons(i+1), lons(mod(i+1,n)+1))
999 else if (e2 .gt. 0)
then
1000 c2 = (a**2 + b**2 * atanhx(sqrt(e2)) / sqrt(e2)) / 2
1002 c2 = (a**2 + b**2 * atan(sqrt(abs(e2))) / sqrt(abs(e2))) / 2
1005 call accrem(aacc, area0)
1006 if (mod(abs(cross), 2) .eq. 1)
then
1007 if (aacc(1) .lt. 0)
then
1008 call accadd(aacc, +area0/2)
1010 call accadd(aacc, -area0/2)
1013 if (aacc(1) .gt. area0/2)
then
1014 call accadd(aacc, -area0)
1015 else if (aacc(1) .le. -area0/2)
then
1016 call accadd(aacc, +area0)
1033 integer major, minor, patch
1050 double precision dblmin, dbleps, pi, degree, tiny,
1051 + tol0, tol1, tol2, tolb, xthrsh
1052 integer digits, maxit1, maxit2
1054 common /geocom/ dblmin, dbleps, pi, degree, tiny,
1055 + tol0, tol1, tol2, tolb, xthrsh, digits, maxit1, maxit2, init
1058 dblmin = 0.5d0**1022
1059 dbleps = 0.5d0**(digits-1)
1061 pi = atan2(0d0, -1d0)
1067 tiny = 0.5d0**((1022+1)/3)
1076 xthrsh = 1000 * tol2
1078 maxit2 = maxit1 + digits + 10
1088 double precision dblmin, dbleps, pi, degree, tiny,
1089 + tol0, tol1, tol2, tolb, xthrsh
1090 integer digits, maxit1, maxit2
1093 common /geocom/ dblmin, dbleps, pi, degree, tiny,
1094 + tol0, tol1, tol2, tolb, xthrsh, digits, maxit1, maxit2, init
1097 subroutine lengs(eps, sig12, ssig1, csig1, dn1, ssig2, csig2, dn2,
1098 + cbet1, cbet2, omask,
1099 + s12b, m12b, m0, MM12, MM21, ep2, Ca)
1101 double precision eps, sig12, ssig1, csig1, dn1, ssig2, csig2, dn2,
1105 double precision s12b, m12b, m0, MM12, MM21
1107 double precision Ca(*)
1109 integer ord, nC1, nC2
1110 parameter (ord = 6, nc1 = ord, nc2 = ord)
1112 double precision A1m1f, A2m1f, TrgSum
1113 double precision m0x, J12, A1, A2, B1, B2, csig12, t, Cb(nC2)
1114 logical distp, redlp, scalp
1120 distp = (mod(omask/16, 2) .eq. 1)
1121 redlp = (mod(omask/2, 2) .eq. 1)
1122 scalp = (mod(omask/4, 2) .eq. 1)
1129 if (distp .or. redlp .or. scalp)
then
1132 if (redlp .or. scalp)
then
1141 b1 = trgsum(.true., ssig2, csig2, ca, nc1) -
1142 + trgsum(.true., ssig1, csig1, ca, nc1)
1144 s12b = a1 * (sig12 + b1)
1145 if (redlp .or. scalp)
then
1146 b2 = trgsum(.true., ssig2, csig2, cb, nc2) -
1147 + trgsum(.true., ssig1, csig1, cb, nc2)
1148 j12 = m0x * sig12 + (a1 * b1 - a2 * b2)
1150 else if (redlp .or. scalp)
then
1153 cb(l) = a1 * ca(l) - a2 * cb(l)
1155 j12 = m0x * sig12 + (trgsum(.true., ssig2, csig2, cb, nc2) -
1156 + trgsum(.true., ssig1, csig1, cb, nc2))
1163 m12b = dn2 * (csig1 * ssig2) - dn1 * (ssig1 * csig2) -
1164 + csig1 * csig2 * j12
1169 csig12 = csig1 * csig2 + ssig1 * ssig2
1170 t = ep2 * (cbet1 - cbet2) * (cbet1 + cbet2) / (dn1 + dn2)
1171 mm12 = csig12 + (t * ssig2 - csig2 * j12) * ssig1 / dn1
1172 mm21 = csig12 - (t * ssig1 - csig1 * j12) * ssig2 / dn2
1178 double precision function astrd(x, y)
1182 double precision x, y
1184 double precision cbrt
1185 double precision k, p, q, r, S, r2, r3, disc, u,
1186 + t3, t, ang, v, uv, w
1191 if ( .not. (q .eq. 0 .and. r .lt. 0) )
then
1200 disc = s * (s + 2 * r3)
1202 if (disc .ge. 0)
then
1218 if (t .ne. 0) u = u + t + r2 / t
1221 ang = atan2(sqrt(-disc), -(s + r3))
1224 u = u + 2 * r * cos(ang / 3)
1236 w = (uv - q) / (2 * v)
1240 k = uv / (sqrt(uv + w**2) + w)
1252 double precision function invsta(sbet1, cbet1, dn1,
1253 + sbet2, cbet2, dn2, lam12, slam12, clam12, f, A3x,
1254 + salp1, calp1, salp2, calp2, dnm,
1260 double precision sbet1, cbet1, dn1, sbet2, cbet2, dn2,
1261 + lam12, slam12, clam12, f, A3x(*)
1263 double precision salp1, calp1, salp2, calp2, dnm
1265 double precision Ca(*)
1267 double precision hypotx, A3f, Astrd
1269 double precision f1, e2, ep2, n, etol2, k2, eps, sig12,
1270 + sbet12, cbet12, sbt12a, omg12, somg12, comg12, ssig12, csig12,
1271 + x, y, lamscl, betscl, cbt12a, bt12a, m12b, m0, dummy,
1272 + k, omg12a, sbetm2, lam12x
1274 double precision dblmin, dbleps, pi, degree, tiny,
1275 + tol0, tol1, tol2, tolb, xthrsh
1276 integer digits, maxit1, maxit2
1278 common /geocom/ dblmin, dbleps, pi, degree, tiny,
1279 + tol0, tol1, tol2, tolb, xthrsh, digits, maxit1, maxit2, init
1295 etol2 = 0.1d0 * tol2 /
1296 + sqrt( max(0.001d0, abs(f)) * min(1d0, 1 - f/2) / 2 )
1301 sbet12 = sbet2 * cbet1 - cbet2 * sbet1
1302 cbet12 = cbet2 * cbet1 + sbet2 * sbet1
1303 sbt12a = sbet2 * cbet1 + cbet2 * sbet1
1305 shortp = cbet12 .ge. 0 .and. sbet12 .lt. 0.5d0 .and.
1306 + cbet2 * lam12 .lt. 0.5d0
1309 sbetm2 = (sbet1 + sbet2)**2
1312 sbetm2 = sbetm2 / (sbetm2 + (cbet1 + cbet2)**2)
1313 dnm = sqrt(1 + ep2 * sbetm2)
1314 omg12 = lam12 / (f1 * dnm)
1322 salp1 = cbet2 * somg12
1323 if (comg12 .ge. 0)
then
1324 calp1 = sbet12 + cbet2 * sbet1 * somg12**2 / (1 + comg12)
1326 calp1 = sbt12a - cbet2 * sbet1 * somg12**2 / (1 - comg12)
1329 ssig12 = hypotx(salp1, calp1)
1330 csig12 = sbet1 * sbet2 + cbet1 * cbet2 * comg12
1332 if (shortp .and. ssig12 .lt. etol2)
then
1334 salp2 = cbet1 * somg12
1335 if (comg12 .ge. 0)
then
1336 calp2 = somg12**2 / (1 + comg12)
1340 calp2 = sbet12 - cbet1 * sbet2 * calp2
1341 call norm2x(salp2, calp2)
1343 sig12 = atan2(ssig12, csig12)
1344 else if (abs(n) .gt. 0.1d0 .or. csig12 .ge. 0 .or.
1345 + ssig12 .ge. 6 * abs(n) * pi * cbet1**2)
then
1350 lam12x = atan2(-slam12, -clam12)
1356 eps = k2 / (2 * (1 + sqrt(1 + k2)) + k2)
1357 lamscl = f * cbet1 * a3f(eps, a3x) * pi
1358 betscl = lamscl * cbet1
1363 cbt12a = cbet2 * cbet1 - sbet2 * sbet1
1364 bt12a = atan2(sbt12a, cbt12a)
1367 call lengs(n, pi + bt12a,
1368 + sbet1, -cbet1, dn1, sbet2, cbet2, dn2, cbet1, cbet2, 2,
1369 + dummy, m12b, m0, dummy, dummy, ep2, ca)
1370 x = -1 + m12b / (cbet1 * cbet2 * m0 * pi)
1371 if (x .lt. -0.01d0)
then
1374 betscl = -f * cbet1**2 * pi
1376 lamscl = betscl / cbet1
1380 if (y .gt. -tol1 .and. x .gt. -1 - xthrsh)
then
1383 salp1 = min(1d0, -x)
1384 calp1 = - sqrt(1 - salp1**2)
1386 if (x .gt. -tol1)
then
1391 calp1 = max(calp1, x)
1392 salp1 = sqrt(1 - calp1**2)
1431 omg12a = -x * k/(1 + k)
1433 omg12a = -y * (1 + k)/k
1435 omg12a = lamscl * omg12a
1436 somg12 = sin(omg12a)
1437 comg12 = -cos(omg12a)
1439 salp1 = cbet2 * somg12
1440 calp1 = sbt12a - cbet2 * sbet1 * somg12**2 / (1 - comg12)
1444 if (.not. (salp1 .le. 0))
then
1445 call norm2x(salp1, calp1)
1455 double precision function lam12f(sbet1, cbet1, dn1,
1456 + sbet2, cbet2, dn2, salp1, calp1, slm120, clm120, f, A3x, C3x,
1457 + salp2, calp2, sig12, ssig1, csig1, ssig2, csig2, eps,
1458 + domg12, diffp, dlam12, Ca)
1460 double precision sbet1, cbet1, dn1, sbet2, cbet2, dn2,
1461 + salp1, calp1, slm120, clm120, f, A3x(*), C3x(*)
1464 double precision salp2, calp2, sig12, ssig1, csig1, ssig2, csig2,
1467 double precision dlam12
1469 double precision Ca(*)
1472 parameter(ord = 6, nc3 = ord)
1474 double precision hypotx, A3f, TrgSum
1476 double precision f1, e2, ep2, salp0, calp0,
1477 + somg1, comg1, somg2, comg2, somg12, comg12,
1478 + lam12, eta, b312, k2, dummy
1480 double precision dblmin, dbleps, pi, degree, tiny,
1481 + tol0, tol1, tol2, tolb, xthrsh
1482 integer digits, maxit1, maxit2
1484 common /geocom/ dblmin, dbleps, pi, degree, tiny,
1485 + tol0, tol1, tol2, tolb, xthrsh, digits, maxit1, maxit2, init
1492 if (sbet1 .eq. 0 .and. calp1 .eq. 0) calp1 = -tiny
1495 salp0 = salp1 * cbet1
1497 calp0 = hypotx(calp1, salp1 * sbet1)
1502 somg1 = salp0 * sbet1
1503 csig1 = calp1 * cbet1
1505 call norm2x(ssig1, csig1)
1512 if (cbet2 .ne. cbet1)
then
1513 salp2 = salp0 / cbet2
1521 if (cbet2 .ne. cbet1 .or. abs(sbet2) .ne. -sbet1)
then
1522 if (cbet1 .lt. -sbet1)
then
1523 calp2 = (cbet2 - cbet1) * (cbet1 + cbet2)
1525 calp2 = (sbet1 - sbet2) * (sbet1 + sbet2)
1527 calp2 = sqrt((calp1 * cbet1)**2 + calp2) / cbet2
1534 somg2 = salp0 * sbet2
1535 csig2 = calp2 * cbet2
1537 call norm2x(ssig2, csig2)
1541 sig12 = atan2(max(0d0, csig1 * ssig2 - ssig1 * csig2) + 0d0,
1542 + csig1 * csig2 + ssig1 * ssig2)
1545 somg12 = max(0d0, comg1 * somg2 - somg1 * comg2) + 0d0
1546 comg12 = comg1 * comg2 + somg1 * somg2
1548 eta = atan2(somg12 * clm120 - comg12 * slm120,
1549 + comg12 * clm120 + somg12 * slm120)
1551 eps = k2 / (2 * (1 + sqrt(1 + k2)) + k2)
1552 call c3f(eps, c3x, ca)
1553 b312 = (trgsum(.true., ssig2, csig2, ca, nc3-1) -
1554 + trgsum(.true., ssig1, csig1, ca, nc3-1))
1555 domg12 = -f * a3f(eps, a3x) * salp0 * (sig12 + b312)
1556 lam12 = eta + domg12
1559 if (calp2 .eq. 0)
then
1560 dlam12 = - 2 * f1 * dn1 / sbet1
1562 call lengs(eps, sig12, ssig1, csig1, dn1, ssig2, csig2, dn2,
1564 + dummy, dlam12, dummy, dummy, dummy, ep2, ca)
1565 dlam12 = dlam12 * f1 / (calp2 * cbet2)
1573 double precision function a3f(eps, A3x)
1575 integer ord, nA3, nA3x
1576 parameter(ord = 6, na3 = ord, na3x = na3)
1579 double precision eps
1581 double precision A3x(0: nA3x-1)
1583 double precision polval
1584 A3f = polval(na3 - 1, a3x, eps)
1589 subroutine c3f(eps, C3x, c)
1592 integer ord, nC3, nC3x
1593 parameter(ord = 6, nc3 = ord, nc3x = (nc3 * (nc3 - 1)) / 2)
1596 double precision eps, C3x(0:nC3x-1)
1598 double precision c(nC3-1)
1601 double precision mult, polval
1605 do 10 l = 1, nc3 - 1
1608 c(l) = mult * polval(m, c3x(o), eps)
1615 subroutine c4f(eps, C4x, c)
1618 integer ord, nC4, nC4x
1619 parameter(ord = 6, nc4 = ord, nc4x = (nc4 * (nc4 + 1)) / 2)
1622 double precision eps, C4x(0:nC4x-1)
1624 double precision c(0:nC4-1)
1627 double precision mult, polval
1631 do 10 l = 0, nc4 - 1
1633 c(l) = mult * polval(m, c4x(o), eps)
1641 double precision function a1m1f(eps)
1644 double precision eps
1647 integer ord, nA1, o, m
1648 parameter(ord = 6, na1 = ord)
1649 double precision polval, coeff(nA1/2 + 2)
1650 data coeff /1, 4, 64, 0, 256/
1654 t = polval(m, coeff(o), eps**2) / coeff(o + m + 1)
1655 a1m1f = (t + eps) / (1 - eps)
1660 subroutine c1f(eps, c)
1663 parameter(ord = 6, nc1 = ord)
1666 double precision eps
1668 double precision c(nC1)
1670 double precision eps2, d
1672 double precision polval, coeff((nC1**2 + 7*nC1 - 2*(nC1/2))/4)
1675 + -9, 64, -128, 2048,
1686 c(l) = d * polval(m, coeff(o), eps2) / coeff(o + m + 1)
1694 subroutine c1pf(eps, c)
1697 parameter(ord = 6, nc1p = ord)
1700 double precision eps
1702 double precision c(nC1p)
1704 double precision eps2, d
1706 double precision polval, coeff((nC1p**2 + 7*nC1p - 2*(nC1p/2))/4)
1708 + 205, -432, 768, 1536,
1709 + 4005, -4736, 3840, 12288,
1711 + -7173, 2695, 7680,
1720 c(l) = d * polval(m, coeff(o), eps2) / coeff(o + m + 1)
1729 double precision function a2m1f(eps)
1731 double precision eps
1734 integer ord, nA2, o, m
1735 parameter(ord = 6, na2 = ord)
1736 double precision polval, coeff(nA2/2 + 2)
1737 data coeff /-11, -28, -192, 0, 256/
1741 t = polval(m, coeff(o), eps**2) / coeff(o + m + 1)
1742 a2m1f = (t - eps) / (1 + eps)
1747 subroutine c2f(eps, c)
1750 parameter(ord = 6, nc2 = ord)
1753 double precision eps
1755 double precision c(nC2)
1757 double precision eps2, d
1759 double precision polval, coeff((nC2**2 + 7*nC2 - 2*(nC2/2))/4)
1762 + 35, 64, 384, 2048,
1773 c(l) = d * polval(m, coeff(o), eps2) / coeff(o + m + 1)
1781 subroutine a3cof(n, A3x)
1783 integer ord, nA3, nA3x
1784 parameter(ord = 6, na3 = ord, na3x = na3)
1789 double precision A3x(0:nA3x-1)
1792 double precision polval, coeff((nA3**2 + 7*nA3 - 2*(nA3/2))/4)
1803 do 10 j = na3 - 1, 0, -1
1804 m = min(na3 - j - 1, j)
1805 a3x(k) = polval(m, coeff(o), n) / coeff(o + m + 1)
1813 subroutine c3cof(n, C3x)
1815 integer ord, nC3, nC3x
1816 parameter(ord = 6, nc3 = ord, nc3x = (nc3 * (nc3 - 1)) / 2)
1821 double precision C3x(0:nC3x-1)
1823 integer o, m, l, j, k
1824 double precision polval,
1825 + coeff(((nc3-1)*(nc3**2 + 7*nc3 - 2*(nc3/2)))/8)
1845 do 20 l = 1, nc3 - 1
1846 do 10 j = nc3 - 1, l, -1
1847 m = min(nc3 - j - 1, j)
1848 c3x(k) = polval(m, coeff(o), n) / coeff(o + m + 1)
1857 subroutine c4cof(n, C4x)
1859 integer ord, nC4, nC4x
1860 parameter(ord = 6, nc4 = ord, nc4x = (nc4 * (nc4 + 1)) / 2)
1865 double precision C4x(0:nC4x-1)
1867 integer o, m, l, j, k
1868 double precision polval, coeff((nC4 * (nC4 + 1) * (nC4 + 5)) / 6)
1870 + 97, 15015, 1088, 156, 45045, -224, -4784, 1573, 45045,
1871 + -10656, 14144, -4576, -858, 45045,
1872 + 64, 624, -4576, 6864, -3003, 15015,
1873 + 100, 208, 572, 3432, -12012, 30030, 45045,
1874 + 1, 9009, -2944, 468, 135135, 5792, 1040, -1287, 135135,
1875 + 5952, -11648, 9152, -2574, 135135,
1876 + -64, -624, 4576, -6864, 3003, 135135,
1877 + 8, 10725, 1856, -936, 225225, -8448, 4992, -1144, 225225,
1878 + -1440, 4160, -4576, 1716, 225225,
1879 + -136, 63063, 1024, -208, 105105,
1880 + 3584, -3328, 1144, 315315,
1881 + -128, 135135, -2560, 832, 405405, 128, 99099/
1885 do 20 l = 0, nc4 - 1
1886 do 10 j = nc4 - 1, l, -1
1888 c4x(k) = polval(m, coeff(o), n) / coeff(o + m + 1)
1897 double precision function sumx(u, v, t)
1899 double precision u, v
1903 double precision up, vpp
1909 if (sumx .eq. 0)
then
1912 t = 0d0 - (up + vpp)
1918 double precision function remx(x, y)
1922 double precision x, y
1925 if (remx .lt. -y/2)
then
1927 else if (remx .gt. +y/2)
then
1934 double precision function angnm(x)
1938 double precision remx
1939 angnm = remx(x, 360d0)
1940 if (abs(angnm) .eq. 180)
then
1941 angnm = sign(180d0, x)
1947 double precision function latfix(x)
1952 if (.not. (abs(x) .gt. 90))
return
1954 latfix = sqrt(90 - abs(x))
1959 double precision function angdif(x, y, e)
1966 double precision x, y
1970 double precision d, t, sumx, remx
1971 d = sumx(remx(-x, 360d0), remx(y, 360d0), t)
1972 d = sumx(remx(d, 360d0), t, e)
1973 if (d .eq. 0 .or. abs(d) .eq. 180)
then
1985 double precision function angrnd(x)
1994 double precision y, z
1998 if (y .lt. z) y = z - (z - y)
2004 subroutine swap(x, y)
2006 double precision x, y
2016 double precision function hypotx(x, y)
2018 double precision x, y
2021 hypotx = sqrt(x**2 + y**2)
2026 subroutine norm2x(x, y)
2028 double precision x, y
2030 double precision hypotx, r
2038 double precision function log1px(x)
2042 double precision y, z
2048 log1px = x * log(y) / z
2054 double precision function atanhx(x)
2059 double precision log1px, y
2061 y = log1px(2 * y/(1 - y))/2
2067 double precision function cbrt(x)
2071 cbrt = sign(abs(x)**(1/3d0), x)
2076 double precision function trgsum(sinp, sinx, cosx, c, n)
2085 double precision sinx, cosx, c(n)
2087 double precision ar, y0, y1
2091 ar = 2 * (cosx - sinx) * (cosx + sinx)
2093 if (mod(n, 2) .eq. 1)
then
2104 y1 = ar * y0 - y1 + c(k)
2105 y0 = ar * y1 - y0 + c(k-1)
2109 trgsum = 2 * sinx * cosx * y0
2112 trgsum = cosx * (y0 - y1)
2118 integer function trnsit(lon1, lon2)
2120 double precision lon1, lon2
2122 double precision lon1x, lon2x, lon12, AngNm, AngDif, e
2123 lon12 = angdif(lon1, lon2, e)
2126 if (lon12 .gt. 0 .and. ((lon1x .lt. 0 .and. lon2x .ge. 0) .or.
2127 + (lon1x .gt. 0 .and. lon2x .eq. 0)))
then
2129 else if (lon12 .lt. 0 .and. lon1x .ge. 0 .and. lon2x .lt. 0)
then
2138 subroutine accini(s)
2141 double precision s(2)
2149 subroutine accadd(s, y)
2154 double precision s(2)
2156 double precision z, u, sumx
2157 z = sumx(y, s(2), u)
2158 s(1) = sumx(z, s(1), s(2))
2159 if (s(1) .eq. 0)
then
2168 subroutine accrem(s, y)
2173 double precision s(2)
2175 double precision remx
2176 s(1) = remx(s(1), y)
2182 subroutine sncsdx(x, sinx, cosx)
2187 double precision sinx, cosx
2189 double precision dblmin, dbleps, pi, degree, tiny,
2190 + tol0, tol1, tol2, tolb, xthrsh
2191 integer digits, maxit1, maxit2
2193 common /geocom/ dblmin, dbleps, pi, degree, tiny,
2194 + tol0, tol1, tol2, tolb, xthrsh, digits, maxit1, maxit2, init
2196 double precision d, r, s, c
2204 if (abs(d) .eq. 45d0)
then
2207 else if (abs(d) .eq. 30d0)
then
2215 else if (q .eq. 1)
then
2218 else if (q .eq. 2)
then
2227 if (sinx .eq. 0)
then
2228 sinx = sign(sinx, x)
2235 subroutine sncsde(x, t, sinx, cosx)
2238 double precision x, t
2240 double precision sinx, cosx
2242 double precision dblmin, dbleps, pi, degree, tiny,
2243 + tol0, tol1, tol2, tolb, xthrsh, angrnd
2244 integer digits, maxit1, maxit2
2246 common /geocom/ dblmin, dbleps, pi, degree, tiny,
2247 + tol0, tol1, tol2, tolb, xthrsh, digits, maxit1, maxit2, init
2249 double precision d, r, s, c
2258 if (abs(d) .eq. 45d0)
then
2261 else if (abs(d) .eq. 30d0)
then
2269 else if (q .eq. 1)
then
2272 else if (q .eq. 2)
then
2281 if (sinx .eq. 0)
then
2282 sinx = sign(sinx, x+t)
2289 double precision function atn2dx(y, x)
2291 double precision x, y
2293 double precision dblmin, dbleps, pi, degree, tiny,
2294 + tol0, tol1, tol2, tolb, xthrsh
2295 integer digits, maxit1, maxit2
2297 common /geocom/ dblmin, dbleps, pi, degree, tiny,
2298 + tol0, tol1, tol2, tolb, xthrsh, digits, maxit1, maxit2, init
2300 double precision xx, yy
2302 if (abs(y) .gt. abs(x)) then
2315 atn2dx = atan2(yy, xx) / degree
2317 atn2dx = sign(180d0, y) - atn2dx
2318 else if (q .eq. 2)
then
2319 atn2dx = 90 - atn2dx
2320 else if (q .eq. 3)
then
2321 atn2dx = -90 + atn2dx
2327 double precision function polval(N, p, x)
2330 double precision p(0:N), x
2339 polval = polval * x + p(i)