Return to fm099.f CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / usr.bin / f77 / testf77 / tests

Annotation of 43BSDTahoe/usr.bin/f77/testf77/tests/fm099.f, revision 1.1

1.1     ! root        1: c     comment section
        !             2: c
        !             3: c     fm099
        !             4: c
        !             5: c     this routine tests various mathematical functions where both the
        !             6: c     function type and arguments are real.  the real variables and
        !             7: c     constants contain both positive and negative values.  the
        !             8: c     functions tested in fm099 include
        !             9: c
        !            10: c                                                     type of
        !            11: c       function                    name       argument     function
        !            12: c       ----------------            ----        --------    --------
        !            13: c         exponential               exp        real         real
        !            14: c         natural logarithm         alog       real         real
        !            15: c         common logarithm          alog10     real         real
        !            16: c         square root               sqrt       real         real
        !            17: c         trigonometric sine        sin        real         real
        !            18: c         trigonometric cosine      cos        real         real
        !            19: c         hyperbolic tangent        tanh       real         real
        !            20: c         arctangent                atan       real         real
        !            21: c                                   atan2      real         real
        !            22: c
        !            23: c      references
        !            24: c        american national standard programming language fortran,
        !            25: c              x3.9-1978
        !            26: c
        !            27: c        section 8.7, external statement
        !            28: c        section 15.5.2, function reference
        !            29: c
        !            30: c
        !            31: c      **********************************************************
        !            32: c
        !            33: c         a compiler validation system for the fortran language
        !            34: c     based on specifications as defined in american national standard
        !            35: c     programming language fortran x3.9-1978, has been developed by the
        !            36: c     federal cobol compiler testing service.  the fortran compiler
        !            37: c     validation system (fcvs) consists of audit routines, their related
        !            38: c     data, and an executive system.  each audit routine is a fortran
        !            39: c     program, subprogram or function which includes tests of specific
        !            40: c     language elements and supporting procedures indicating the result
        !            41: c     of executing these tests.
        !            42: c
        !            43: c         this particular program/subprogram/function contains features
        !            44: c     found only in the subset as defined in x3.9-1978.
        !            45: c
        !            46: c         suggestions and comments should be forwarded to -
        !            47: c
        !            48: c                  department of the navy
        !            49: c                  federal cobol compiler testing service
        !            50: c                  washington, d.c.  20376
        !            51: c
        !            52: c      **********************************************************
        !            53: c
        !            54: c
        !            55: c
        !            56: c     initialization section
        !            57: c
        !            58: c     initialize constants
        !            59: c      **************
        !            60: c     i01 contains the logical unit number for the card reader.
        !            61:       i01 = 5
        !            62: c     i02 contains the logical unit number for the printer.
        !            63:       i02 = 6
        !            64: c     system environment section
        !            65: c
        !            66: cx010    this card is replaced by contents of fexec x-010 control card.
        !            67: c     the cx010 card is for overriding the program default i01 = 5
        !            68: c     (unit number for card reader).
        !            69: cx011    this card is replaced by contents of fexec x-011 control card.
        !            70: c     the cx011 card is for systems which require additional
        !            71: c     fortran statements for files associated with cx010 above.
        !            72: c
        !            73: cx020    this card is replaced by contents of fexec x-020 control card.
        !            74: c     the cx020 card is for overriding the program default i02 = 6
        !            75: c     (unit number for printer).
        !            76: cx021    this card is replaced by contents of fexec x-021 control card.
        !            77: c     the cx021 card is for systems which require additional
        !            78: c     fortran statements for files associated with cx020 above.
        !            79: c
        !            80:       ivpass=0
        !            81:       ivfail=0
        !            82:       ivdele=0
        !            83:       iczero=0
        !            84: c
        !            85: c     write page headers
        !            86:       write (i02,90000)
        !            87:       write (i02,90001)
        !            88:       write (i02,90002)
        !            89:       write (i02, 90002)
        !            90:       write (i02,90003)
        !            91:       write (i02,90002)
        !            92:       write (i02,90004)
        !            93:       write (i02,90002)
        !            94:       write (i02,90011)
        !            95:       write (i02,90002)
        !            96:       write (i02,90002)
        !            97:       write (i02,90005)
        !            98:       write (i02,90006)
        !            99:       write (i02,90002)
        !           100: c
        !           101: c     test section
        !           102: c
        !           103: c     test 939 through test 942 contain function tests for exponential
        !           104: c     functions where the argument and function are real
        !           105: c
        !           106:       ivtnum = 939
        !           107: c
        !           108: c      ****  test 939  ****
        !           109: c
        !           110:       if (iczero) 39390, 9390, 39390
        !           111:  9390 continue
        !           112:       rvon01 = 0.0
        !           113:       rvcomp = exp (rvon01)
        !           114:       go to 49390
        !           115: 39390 ivdele = ivdele + 1
        !           116:       write (i02,80003) ivtnum
        !           117:       if (iczero) 49390, 9401, 49390
        !           118: 49390 if (rvcomp - 0.95) 29390,19390,49391
        !           119: 49391 if (rvcomp - 1.05) 19390,19390,29390
        !           120: 19390 ivpass = ivpass + 1
        !           121:       write (i02,80001) ivtnum
        !           122:       go to 9401
        !           123: 29390 ivfail = ivfail + 1
        !           124:       rvcorr = 1.00
        !           125:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           126:  9401 continue
        !           127:       ivtnum = 940
        !           128: c
        !           129: c      ****  test 940  ****
        !           130: c
        !           131:       if (iczero) 39400, 9400, 39400
        !           132:  9400 continue
        !           133:       rvcomp = exp (0.5)
        !           134:       go to 49400
        !           135: 39400 ivdele = ivdele + 1
        !           136:       write (i02,80003) ivtnum
        !           137:       if (iczero) 49400, 9411, 49400
        !           138: 49400 if (rvcomp - 1.60) 29400,19400,49401
        !           139: 49401 if (rvcomp - 1.70) 19400,19400,29400
        !           140: 19400 ivpass = ivpass + 1
        !           141:       write (i02,80001) ivtnum
        !           142:       go to 9411
        !           143: 29400 ivfail = ivfail + 1
        !           144:       rvcorr = 1.65
        !           145:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           146:  9411 continue
        !           147:       ivtnum = 941
        !           148: c
        !           149: c      ****  test 941  ****
        !           150: c
        !           151:       if (iczero) 39410, 9410, 39410
        !           152:  9410 continue
        !           153:       rvon01 = .1e1
        !           154:       rvcomp = exp (rvon01)
        !           155:       go to 49410
        !           156: 39410 ivdele = ivdele + 1
        !           157:       write (i02,80003) ivtnum
        !           158:       if (iczero) 49410, 9421, 49410
        !           159: 49410 if (rvcomp - 2.67) 29410,19410,49411
        !           160: 49411 if (rvcomp - 2.77) 19410,19410,29410
        !           161: 19410 ivpass = ivpass + 1
        !           162:       write (i02,80001) ivtnum
        !           163:       go to 9421
        !           164: 29410 ivfail = ivfail + 1
        !           165:       rvcorr = 2.72
        !           166:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           167:  9421 continue
        !           168:       ivtnum = 942
        !           169: c
        !           170: c      ****  test 942  ****
        !           171: c
        !           172:       if (iczero) 39420, 9420, 39420
        !           173:  9420 continue
        !           174:       rvon01 = -1.0
        !           175:       rvcomp = exp (rvon01)
        !           176:       go to 49420
        !           177: 39420 ivdele = ivdele + 1
        !           178:       write (i02,80003) ivtnum
        !           179:       if (iczero) 49420, 9431, 49420
        !           180: 49420 if (rvcomp - 0.363) 29420,19420,49421
        !           181: 49421 if (rvcomp - 0.373) 19420,19420,29420
        !           182: 19420 ivpass = ivpass + 1
        !           183:       write (i02,80001) ivtnum
        !           184:       go to 9431
        !           185: 29420 ivfail = ivfail + 1
        !           186:       rvcorr = 0.368
        !           187:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           188:  9431 continue
        !           189: c
        !           190: c     test 943 through test 945 contain function tests for natural
        !           191: c     logarithm functions where the argument and function are real
        !           192: c
        !           193:       ivtnum = 943
        !           194: c
        !           195: c      ****  test 943  ****
        !           196: c
        !           197:       if (iczero) 39430, 9430, 39430
        !           198:  9430 continue
        !           199:       rvon01 = 5e1
        !           200:       rvcomp = alog (rvon01)
        !           201:       go to 49430
        !           202: 39430 ivdele = ivdele + 1
        !           203:       write (i02,80003) ivtnum
        !           204:       if (iczero) 49430, 9441, 49430
        !           205: 49430 if (rvcomp - 3.9115) 29430,19430,49431
        !           206: 49431 if (rvcomp - 3.9125) 19430,19430,29430
        !           207: 19430 ivpass = ivpass + 1
        !           208:       write (i02,80001) ivtnum
        !           209:       go to 9441
        !           210: 29430 ivfail = ivfail + 1
        !           211:       rvcorr = 3.9120
        !           212:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           213:  9441 continue
        !           214:       ivtnum = 944
        !           215: c
        !           216: c      ****  test 944  ****
        !           217: c
        !           218:       if (iczero) 39440, 9440, 39440
        !           219:  9440 continue
        !           220:       rvon01 = 1.0
        !           221:       rvcomp = alog (rvon01)
        !           222:       go to 49440
        !           223: 39440 ivdele = ivdele + 1
        !           224:       write (i02,80003) ivtnum
        !           225:       if (iczero) 49440, 9451, 49440
        !           226: 49440 if (rvcomp + .00005) 29440,19440,49441
        !           227: 49441 if (rvcomp - .00005) 19440,19440,29440
        !           228: 19440 ivpass = ivpass + 1
        !           229:       write (i02,80001) ivtnum
        !           230:       go to 9451
        !           231: 29440 ivfail = ivfail + 1
        !           232:       rvcorr = 0.00000
        !           233:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           234:  9451 continue
        !           235:       ivtnum = 945
        !           236: c
        !           237: c      ****  test 945  ****
        !           238: c
        !           239:       if (iczero) 39450, 9450, 39450
        !           240:  9450 continue
        !           241:       rvcomp = alog (2.0)
        !           242:       go to 49450
        !           243: 39450 ivdele = ivdele + 1
        !           244:       write (i02,80003) ivtnum
        !           245:       if (iczero) 49450, 9461, 49450
        !           246: 49450 if (rvcomp - 0.688) 29450,19450,49451
        !           247: 49451 if (rvcomp - 0.698) 19450,19450,29450
        !           248: 19450 ivpass = ivpass + 1
        !           249:       write (i02,80001) ivtnum
        !           250:       go to 9461
        !           251: 29450 ivfail = ivfail + 1
        !           252:       rvcorr = 0.693
        !           253:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           254:  9461 continue
        !           255: c
        !           256: c     test 946 through test 948 contain function tests for common
        !           257: c     logarithm functions where the argument and function are real
        !           258: c
        !           259:       ivtnum = 946
        !           260: c
        !           261: c      ****  test 946  ****
        !           262: c
        !           263:       if (iczero) 39460, 9460, 39460
        !           264:  9460 continue
        !           265:       rvon01 = 2e2
        !           266:       rvcomp = alog10 (rvon01)
        !           267:       go to 49460
        !           268: 39460 ivdele = ivdele + 1
        !           269:       write (i02,80003) ivtnum
        !           270:       if (iczero) 49460, 9471, 49460
        !           271: 49460 if (rvcomp - 2.296) 29460,19460,49461
        !           272: 49461 if (rvcomp - 2.306) 19460,19460,29460
        !           273: 19460 ivpass = ivpass + 1
        !           274:       write (i02,80001) ivtnum
        !           275:       go to 9471
        !           276: 29460 ivfail = ivfail + 1
        !           277:       rvcorr = 2.301
        !           278:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           279:  9471 continue
        !           280:       ivtnum = 947
        !           281: c
        !           282: c      ****  test 947  ****
        !           283: c
        !           284:       if (iczero) 39470, 9470, 39470
        !           285:  9470 continue
        !           286:       rvon01 = .3e+3
        !           287:       rvcomp = alog10 (rvon01)
        !           288:       go to 49470
        !           289: 39470 ivdele = ivdele + 1
        !           290:       write (i02,80003) ivtnum
        !           291:       if (iczero) 49470, 9481, 49470
        !           292: 49470 if (rvcomp - 2.472) 29470,19470,49471
        !           293: 49471 if (rvcomp - 2.482) 19470,19470,29470
        !           294: 19470 ivpass = ivpass + 1
        !           295:       write (i02,80001) ivtnum
        !           296:       go to 9481
        !           297: 29470 ivfail = ivfail + 1
        !           298:       rvcorr = 2.477
        !           299:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           300:  9481 continue
        !           301:       ivtnum = 948
        !           302: c
        !           303: c      ****  test 948  ****
        !           304: c
        !           305:       if (iczero) 39480, 9480, 39480
        !           306:  9480 continue
        !           307:       rvon01 = 1350.0
        !           308:       rvcomp = alog10 (rvon01)
        !           309:       go to 49480
        !           310: 39480 ivdele = ivdele + 1
        !           311:       write (i02,80003) ivtnum
        !           312:       if (iczero) 49480, 9491, 49480
        !           313: 49480 if (rvcomp - 3.125) 29480,19480,49481
        !           314: 49481 if (rvcomp - 3.135) 19480,19480,29480
        !           315: 19480 ivpass = ivpass + 1
        !           316:       write (i02,80001) ivtnum
        !           317:       go to 9491
        !           318: 29480 ivfail = ivfail + 1
        !           319:       rvcorr = 3.130
        !           320:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           321:  9491 continue
        !           322: c
        !           323: c     test 949 through test 951 contain function tests for square root
        !           324: c     functions where the argument and function are real
        !           325: c
        !           326:       ivtnum = 949
        !           327: c
        !           328: c      ****  test 949  ****
        !           329: c
        !           330:       if (iczero) 39490, 9490, 39490
        !           331:  9490 continue
        !           332:       rvon01 = 1.0
        !           333:       rvcomp = sqrt (rvon01)
        !           334:       go to 49490
        !           335: 39490 ivdele = ivdele + 1
        !           336:       write (i02,80003) ivtnum
        !           337:       if (iczero) 49490, 9501, 49490
        !           338: 49490 if (rvcomp - 0.95) 29490,19490,49491
        !           339: 49491 if (rvcomp - 1.05) 19490,19490,29490
        !           340: 19490 ivpass = ivpass + 1
        !           341:       write (i02,80001) ivtnum
        !           342:       go to 9501
        !           343: 29490 ivfail = ivfail + 1
        !           344:       rvcorr = 1.00
        !           345:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           346:  9501 continue
        !           347:       ivtnum = 950
        !           348: c
        !           349: c      ****  test 950  ****
        !           350: c
        !           351:       if (iczero) 39500, 9500, 39500
        !           352:  9500 continue
        !           353:       rvcomp = sqrt (2.0)
        !           354:       go to 49500
        !           355: 39500 ivdele = ivdele + 1
        !           356:       write (i02,80003) ivtnum
        !           357:       if (iczero) 49500, 9511, 49500
        !           358: 49500 if (rvcomp - 1.36) 29500,19500,49501
        !           359: 49501 if (rvcomp - 1.46) 19500,19500,29500
        !           360: 19500 ivpass = ivpass + 1
        !           361:       write (i02,80001) ivtnum
        !           362:       go to 9511
        !           363: 29500 ivfail = ivfail + 1
        !           364:       rvcorr = 1.41
        !           365:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           366:  9511 continue
        !           367:       ivtnum = 951
        !           368: c
        !           369: c      ****  test 951  ****
        !           370: c
        !           371:       if (iczero) 39510, 9510, 39510
        !           372:  9510 continue
        !           373:       rvon01 = .229e1
        !           374:       rvcomp = sqrt (rvon01)
        !           375:       go to 49510
        !           376: 39510 ivdele = ivdele + 1
        !           377:       write (i02,80003) ivtnum
        !           378:       if (iczero) 49510, 9521, 49510
        !           379: 49510 if (rvcomp - 1.46) 29510,19510,49511
        !           380: 49511 if (rvcomp - 1.56) 19510,19510,29510
        !           381: 19510 ivpass = ivpass + 1
        !           382:       write (i02,80001) ivtnum
        !           383:       go to 9521
        !           384: 29510 ivfail = ivfail + 1
        !           385:       rvcorr = 1.51
        !           386:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           387:  9521 continue
        !           388: c
        !           389: c     test 952 through test 953 contain function tests for trigonometric
        !           390: c     sine functions where the argument and function are real
        !           391: c
        !           392:       ivtnum = 952
        !           393: c
        !           394: c      ****  test 952  ****
        !           395: c
        !           396:       if (iczero) 39520, 9520, 39520
        !           397:  9520 continue
        !           398:       rvon01 = 0.00000
        !           399:       rvcomp = sin (rvon01)
        !           400:       go to 49520
        !           401: 39520 ivdele = ivdele + 1
        !           402:       write (i02,80003) ivtnum
        !           403:       if (iczero) 49520, 9531, 49520
        !           404: 49520 if (rvcomp + .00005) 29520,19520,49521
        !           405: 49521 if (rvcomp - .00005) 19520,19520,29520
        !           406: 19520 ivpass = ivpass + 1
        !           407:       write (i02,80001) ivtnum
        !           408:       go to 9531
        !           409: 29520 ivfail = ivfail + 1
        !           410:       rvcorr = 0.00000
        !           411:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           412:  9531 continue
        !           413:       ivtnum = 953
        !           414: c
        !           415: c      ****  test 953  ****
        !           416: c
        !           417:       if (iczero) 39530, 9530, 39530
        !           418:  9530 continue
        !           419:       rvon01 = 0.5
        !           420:       rvcomp = sin (rvon01)
        !           421:       go to 49530
        !           422: 39530 ivdele = ivdele + 1
        !           423:       write (i02,80003) ivtnum
        !           424:       if (iczero) 49530, 9541, 49530
        !           425: 49530 if (rvcomp - .474) 29530,19530,49531
        !           426: 49531 if (rvcomp - .484) 19530,19530,29530
        !           427: 19530 ivpass = ivpass + 1
        !           428:       write (i02,80001) ivtnum
        !           429:       go to 9541
        !           430: 29530 ivfail = ivfail + 1
        !           431:       rvcorr = .479
        !           432:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           433:  9541 continue
        !           434:       ivtnum = 954
        !           435: c
        !           436: c      ****  test 954  ****
        !           437: c
        !           438:       if (iczero) 39540, 9540, 39540
        !           439:  9540 continue
        !           440:       rvon01 = 4e0
        !           441:       rvcomp = sin (rvon01)
        !           442:       go to 49540
        !           443: 39540 ivdele = ivdele + 1
        !           444:       write (i02,80003) ivtnum
        !           445:       if (iczero) 49540, 9551, 49540
        !           446: 49540 if (rvcomp + .762) 29540,19540,49541
        !           447: 49541 if (rvcomp + .752) 19540,19540,29540
        !           448: 19540 ivpass = ivpass + 1
        !           449:       write (i02,80001) ivtnum
        !           450:       go to 9551
        !           451: 29540 ivfail = ivfail + 1
        !           452:       rvcorr = -.757
        !           453:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           454:  9551 continue
        !           455: c
        !           456: c     test 955 through test 957 contain function tests for trigonometric
        !           457: c     cosine functions where the argument and function are real
        !           458: c
        !           459:       ivtnum = 955
        !           460: c
        !           461: c      ****  test 955  ****
        !           462: c
        !           463:       if (iczero) 39550, 9550, 39550
        !           464:  9550 continue
        !           465:       rvon01 = 0.00000
        !           466:       rvcomp = cos (rvon01)
        !           467:       go to 49550
        !           468: 39550 ivdele = ivdele + 1
        !           469:       write (i02,80003) ivtnum
        !           470:       if (iczero) 49550, 9561, 49550
        !           471: 49550 if (rvcomp - .995) 29550,19550,49551
        !           472: 49551 if (rvcomp - 1.005) 19550,19550,29550
        !           473: 19550 ivpass = ivpass + 1
        !           474:       write (i02,80001) ivtnum
        !           475:       go to 9561
        !           476: 29550 ivfail = ivfail + 1
        !           477:       rvcorr = 1.000
        !           478:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           479:  9561 continue
        !           480:       ivtnum = 956
        !           481: c
        !           482: c      ****  test 956  ****
        !           483: c
        !           484:       if (iczero) 39560, 9560, 39560
        !           485:  9560 continue
        !           486:       rvon01 = 1.0e0
        !           487:       rvcomp = cos (rvon01)
        !           488:       go to 49560
        !           489: 39560 ivdele = ivdele + 1
        !           490:       write (i02,80003) ivtnum
        !           491:       if (iczero) 49560, 9571, 49560
        !           492: 49560 if (rvcomp - .535) 29560,19560,49561
        !           493: 49561 if (rvcomp - .545) 19560,19560,29560
        !           494: 19560 ivpass = ivpass + 1
        !           495:       write (i02,80001) ivtnum
        !           496:       go to 9571
        !           497: 29560 ivfail = ivfail + 1
        !           498:       rvcorr = 0.540
        !           499:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           500:  9571 continue
        !           501:       ivtnum = 957
        !           502: c
        !           503: c      ****  test 957  ****
        !           504: c
        !           505:       if (iczero) 39570, 9570, 39570
        !           506:  9570 continue
        !           507:       rvcomp = cos (4.0)
        !           508:       go to 49570
        !           509: 39570 ivdele = ivdele + 1
        !           510:       write (i02,80003) ivtnum
        !           511:       if (iczero) 49570, 9581, 49570
        !           512: 49570 if (rvcomp + .659) 29570,19570,49571
        !           513: 49571 if (rvcomp + .649) 19570,19570,29570
        !           514: 19570 ivpass = ivpass + 1
        !           515:       write (i02,80001) ivtnum
        !           516:       go to 9581
        !           517: 29570 ivfail = ivfail + 1
        !           518:       rvcorr = -0.654
        !           519:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           520:  9581 continue
        !           521: c
        !           522: c     test 958 through test 960 contain function tests for hyperbolic
        !           523: c     tangent functions where the argument and function are real
        !           524: c
        !           525:       ivtnum = 958
        !           526: c
        !           527: c      ****  test 958  ****
        !           528: c
        !           529:       if (iczero) 39580, 9580, 39580
        !           530:  9580 continue
        !           531:       rvcomp = tanh (0.0)
        !           532:       go to 49580
        !           533: 39580 ivdele = ivdele + 1
        !           534:       write (i02,80003) ivtnum
        !           535:       if (iczero) 49580, 9591, 49580
        !           536: 49580 if (rvcomp + .00005) 29580,19580,49581
        !           537: 49581 if (rvcomp - .00005) 19580,19580,29580
        !           538: 19580 ivpass = ivpass + 1
        !           539:       write (i02,80001) ivtnum
        !           540:       go to 9591
        !           541: 29580 ivfail = ivfail + 1
        !           542:       rvcorr = 0.00000
        !           543:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           544:  9591 continue
        !           545:       ivtnum = 959
        !           546: c
        !           547: c      ****  test 959  ****
        !           548: c
        !           549:       if (iczero) 39590, 9590, 39590
        !           550:  9590 continue
        !           551:       rvon01 = .5e0
        !           552:       rvcomp = tanh (rvon01)
        !           553:       go to 49590
        !           554: 39590 ivdele = ivdele + 1
        !           555:       write (i02,80003) ivtnum
        !           556:       if (iczero) 49590, 9601, 49590
        !           557: 49590 if (rvcomp - .457) 29590,19590,49591
        !           558: 49591 if (rvcomp - .467) 19590,19590,29590
        !           559: 19590 ivpass = ivpass + 1
        !           560:       write (i02,80001) ivtnum
        !           561:       go to 9601
        !           562: 29590 ivfail = ivfail + 1
        !           563:       rvcorr = 0.462
        !           564:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           565:  9601 continue
        !           566:       ivtnum = 960
        !           567: c
        !           568: c      ****  test 960  ****
        !           569: c
        !           570:       if (iczero) 39600, 9600, 39600
        !           571:  9600 continue
        !           572:       rvon01 = .25
        !           573:       rvcomp = tanh (rvon01)
        !           574:       go to 49600
        !           575: 39600 ivdele = ivdele + 1
        !           576:       write (i02,80003) ivtnum
        !           577:       if (iczero) 49600, 9611, 49600
        !           578: 49600 if (rvcomp - .240) 29600,19600,49601
        !           579: 49601 if (rvcomp - .250) 19600,19600,29600
        !           580: 19600 ivpass = ivpass + 1
        !           581:       write (i02,80001) ivtnum
        !           582:       go to 9611
        !           583: 29600 ivfail = ivfail + 1
        !           584:       rvcorr = 0.245
        !           585:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           586:  9611 continue
        !           587: c
        !           588: c     tests 961 and 962 contain tests for arctangent of the form
        !           589: c     atan (a) where the argument and function are real
        !           590: c
        !           591:       ivtnum = 961
        !           592: c
        !           593: c      ****  test 961  ****
        !           594: c
        !           595:       if (iczero) 39610, 9610, 39610
        !           596:  9610 continue
        !           597:       rvcomp = atan (0.0)
        !           598:       go to 49610
        !           599: 39610 ivdele = ivdele + 1
        !           600:       write (i02,80003) ivtnum
        !           601:       if (iczero) 49610, 9621, 49610
        !           602: 49610 if (rvcomp + .00005) 29610,19610,49611
        !           603: 49611 if (rvcomp - .00005) 19610,19610,29610
        !           604: 19610 ivpass = ivpass + 1
        !           605:       write (i02,80001) ivtnum
        !           606:       go to 9621
        !           607: 29610 ivfail = ivfail + 1
        !           608:       rvcorr = 0.00000
        !           609:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           610:  9621 continue
        !           611:       ivtnum = 962
        !           612: c
        !           613: c      ****  test 962  ****
        !           614: c
        !           615:       if (iczero) 39620, 9620, 39620
        !           616:  9620 continue
        !           617:       rvon01 = 5e-1
        !           618:       rvcomp = atan (rvon01)
        !           619:       go to 49620
        !           620: 39620 ivdele = ivdele + 1
        !           621:       write (i02,80003) ivtnum
        !           622:       if (iczero) 49620, 9631, 49620
        !           623: 49620 if (rvcomp - .459) 29620,19620,49621
        !           624: 49621 if (rvcomp - .469) 19620,19620,29620
        !           625: 19620 ivpass = ivpass + 1
        !           626:       write (i02,80001) ivtnum
        !           627:       go to 9631
        !           628: 29620 ivfail = ivfail + 1
        !           629:       rvcorr = 0.464
        !           630:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           631:  9631 continue
        !           632: c
        !           633: c     tests 963 and 964 contain tests for arctangent of the form
        !           634: c     atan2 (a1,a2) where the arguments and function are real
        !           635: c
        !           636:       ivtnum = 963
        !           637: c
        !           638: c      ****  test 963  ****
        !           639: c
        !           640:       if (iczero) 39630, 9630, 39630
        !           641:  9630 continue
        !           642:       rvon01 = 0.0
        !           643:       rvon02 = 1e0
        !           644:       rvcomp = atan2 (rvon01,rvon02)
        !           645:       go to 49630
        !           646: 39630 ivdele = ivdele + 1
        !           647:       write (i02,80003) ivtnum
        !           648:       if (iczero) 49630, 9641, 49630
        !           649: 49630 if (rvcomp + .00005) 29630,19630,49631
        !           650: 49631 if (rvcomp - .00005) 19630,19630,29630
        !           651: 19630 ivpass = ivpass + 1
        !           652:       write (i02,80001) ivtnum
        !           653:       go to 9641
        !           654: 29630 ivfail = ivfail + 1
        !           655:       rvcorr = 0.00000
        !           656:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           657:  9641 continue
        !           658:       ivtnum = 964
        !           659: c
        !           660: c      ****  test 964  ****
        !           661: c
        !           662:       if (iczero) 39640, 9640, 39640
        !           663:  9640 continue
        !           664:       rvon01 = 2e1
        !           665:       rvcomp = atan2 (-1.0,rvon01)
        !           666:       go to 49640
        !           667: 39640 ivdele = ivdele + 1
        !           668:       write (i02,80003) ivtnum
        !           669:       if (iczero) 49640, 9651, 49640
        !           670: 49640 if (rvcomp + .05001) 29640,19640,49641
        !           671: 49641 if (rvcomp + .04991) 19640,19640,29640
        !           672: 19640 ivpass = ivpass + 1
        !           673:       write (i02,80001) ivtnum
        !           674:       go to 9651
        !           675: 29640 ivfail = ivfail + 1
        !           676:       rvcorr = -.04996
        !           677:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           678:  9651 continue
        !           679: c
        !           680: c     write page footings and run summaries
        !           681: 99999 continue
        !           682:       write (i02,90002)
        !           683:       write (i02,90006)
        !           684:       write (i02,90002)
        !           685:       write (i02,90002)
        !           686:       write (i02,90007)
        !           687:       write (i02,90002)
        !           688:       write (i02,90008)  ivfail
        !           689:       write (i02,90009) ivpass
        !           690:       write (i02,90010) ivdele
        !           691: c
        !           692: c
        !           693: c     terminate routine execution
        !           694:       stop
        !           695: c
        !           696: c     format statements for page headers
        !           697: 90000 format (1h1)
        !           698: 90002 format (1h )
        !           699: 90001 format (1h ,10x,34hfortran compiler validation system)
        !           700: 90003 format (1h ,21x,11hversion 1.0)
        !           701: 90004 format (1h ,10x,38hfor official use only - copyright 1978)
        !           702: 90005 format (1h ,5x,4htest,5x,9hpass/fail, 5x,8hcomputed,8x,7hcorrect)
        !           703: 90006 format (1h ,5x,46h----------------------------------------------)
        !           704: 90011 format (1h ,18x,17hsubset level test)
        !           705: c
        !           706: c     format statements for run summaries
        !           707: 90008 format (1h ,15x,i5,19h errors encountered)
        !           708: 90009 format (1h ,15x,i5,13h tests passed)
        !           709: 90010 format (1h ,15x,i5,14h tests deleted)
        !           710: c
        !           711: c     format statements for test results
        !           712: 80001 format (1h ,4x,i5,7x,4hpass)
        !           713: 80002 format (1h ,4x,i5,7x,4hfail)
        !           714: 80003 format (1h ,4x,i5,7x,7hdeleted)
        !           715: 80004 format (1h ,4x,i5,7x,4hfail,10x,i6,9x,i6)
        !           716: 80005 format (1h ,4x,i5,7x,4hfail,4x,e12.5,3x,e12.5)
        !           717: c
        !           718: 90007 format (1h ,20x,20hend of program fm099)
        !           719:       end

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.