Return to fm062.f CVS log

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

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

1.1     ! root        1: c     comment section
        !             2: c
        !             3: c     fm062
        !             4: c
        !             5: c          this routine tests arithmetic assignment statements where
        !             6: c     an arithmetic expression formed from real variables and
        !             7: c     constants connected by arithmetic operators is assigned to
        !             8: c     a real variable.  in cases involving the exponentiation
        !             9: c     operator, real values are raised to integer powers only.
        !            10: c
        !            11: c           a real datum is a processor approximation to the value of a
        !            12: c     real number.  it may assume positive, negative and zero values.
        !            13: c
        !            14: c          a basic real constant is written as an integer part, a
        !            15: c     decimal point, and a decimal fraction part in that order.  both
        !            16: c     the integer part and the decimal part are strings of digits;
        !            17: c     either one of these strings may be empty but not both.  the
        !            18: c     constant is an approximation to the digit string interpreted as a
        !            19: c     decimal numeral.
        !            20: c
        !            21: c         a decimal exponent is written as the letter e, followed by an
        !            22: c     optionally signed integer constant.
        !            23: c
        !            24: c         a real constant is indicated by writing a basic real constant,
        !            25: c     a basic real constant followed by a decimal exponent, or an
        !            26: c     integer constant followed by a decimal exponent.
        !            27: c
        !            28: c      references
        !            29: c        american national standard programming language fortran,
        !            30: c              x3.9-1978
        !            31: c
        !            32: c        section 4.4, real type
        !            33: c        section 4.4.1, real constant
        !            34: c        section 6.1, arithmetic expressions
        !            35: c        section 6.6, evaluation of expressions
        !            36: c        section 10.1, arithmetic assignment statement
        !            37: c
        !            38: c      **********************************************************
        !            39: c
        !            40: c         a compiler validation system for the fortran language
        !            41: c     based on specifications as defined in american national standard
        !            42: c     programming language fortran x3.9-1978, has been developed by the
        !            43: c     federal cobol compiler testing service.  the fortran compiler
        !            44: c     validation system (fcvs) consists of audit routines, their related
        !            45: c     data, and an executive system.  each audit routine is a fortran
        !            46: c     program, subprogram or function which includes tests of specific
        !            47: c     language elements and supporting procedures indicating the result
        !            48: c     of executing these tests.
        !            49: c
        !            50: c         this particular program/subprogram/function contains features
        !            51: c     found only in the subset as defined in x3.9-1978.
        !            52: c
        !            53: c         suggestions and comments should be forwarded to -
        !            54: c
        !            55: c                  department of the navy
        !            56: c                  federal cobol compiler testing service
        !            57: c                  washington, d.c.  20376
        !            58: c
        !            59: c      **********************************************************
        !            60: c
        !            61: c
        !            62: c
        !            63: c     initialization section
        !            64: c
        !            65: c     initialize constants
        !            66: c      **************
        !            67: c     i01 contains the logical unit number for the card reader.
        !            68:       i01 = 5
        !            69: c     i02 contains the logical unit number for the printer.
        !            70:       i02 = 6
        !            71: c     system environment section
        !            72: c
        !            73: cx010    this card is replaced by contents of fexec x-010 control card.
        !            74: c     the cx010 card is for overriding the program default i01 = 5
        !            75: c     (unit number for card reader).
        !            76: cx011    this card is replaced by contents of fexec x-011 control card.
        !            77: c     the cx011 card is for systems which require additional
        !            78: c     fortran statements for files associated with cx010 above.
        !            79: c
        !            80: cx020    this card is replaced by contents of fexec x-020 control card.
        !            81: c     the cx020 card is for overriding the program default i02 = 6
        !            82: c     (unit number for printer).
        !            83: cx021    this card is replaced by contents of fexec x-021 control card.
        !            84: c     the cx021 card is for systems which require additional
        !            85: c     fortran statements for files associated with cx020 above.
        !            86: c
        !            87:       ivpass=0
        !            88:       ivfail=0
        !            89:       ivdele=0
        !            90:       iczero=0
        !            91: c
        !            92: c     write page headers
        !            93:       write (i02,90000)
        !            94:       write (i02,90001)
        !            95:       write (i02,90002)
        !            96:       write (i02, 90002)
        !            97:       write (i02,90003)
        !            98:       write (i02,90002)
        !            99:       write (i02,90004)
        !           100:       write (i02,90002)
        !           101:       write (i02,90011)
        !           102:       write (i02,90002)
        !           103:       write (i02,90002)
        !           104:       write (i02,90005)
        !           105:       write (i02,90006)
        !           106:       write (i02,90002)
        !           107: c
        !           108: c     test section
        !           109: c
        !           110: c          arithmetic assignment statement
        !           111: c
        !           112: c
        !           113: c     tests 62 through 70 use a mixture of real variables and real
        !           114: c     constants connected by two identical arithmetic operators.
        !           115: c     tests occur in pairs, one without parentheses and one with
        !           116: c     parentheses to alter the normal order of evaluation.
        !           117: c
        !           118: c     tests 71 through 90 use three real variables connected by a
        !           119: c     pair of dissimilar operators.  all combinations and orderings
        !           120: c     of operators are exercized.  where exponentiation is tested,
        !           121: c     integer variables are used for the power primaries.
        !           122: c
        !           123: c     tests 91 and 92 use a series of real variables connected by one
        !           124: c     each of the arithmetic opertors.  parenthetical notations are
        !           125: c     also tested.
        !           126: c
        !           127: c
        !           128: c
        !           129: c
        !           130: c
        !           131:       ivtnum =  62
        !           132: c
        !           133: c      ****  test  62  ****
        !           134: c
        !           135:       if (iczero) 30620,  620, 30620
        !           136:   620 continue
        !           137:       rvon01 = 7.5
        !           138:       rvon02 = 5e2
        !           139:       rvcomp = rvon01 + rvon02 + 33e-1
        !           140:       go to 40620
        !           141: 30620 ivdele = ivdele + 1
        !           142:       write (i02,80003) ivtnum
        !           143:       if (iczero) 40620,  631, 40620
        !           144: 40620 if (rvcomp - 510.75) 20620,10620,40621
        !           145: 40621 if (rvcomp - 510.85) 10620,10620,20620
        !           146: 10620 ivpass = ivpass + 1
        !           147:       write (i02,80001) ivtnum
        !           148:       go to  631
        !           149: 20620 ivfail = ivfail + 1
        !           150:       rvcorr = 510.8
        !           151:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           152:   631 continue
        !           153:       ivtnum =  63
        !           154: c
        !           155: c      ****  test  63  ****
        !           156: c
        !           157:       if (iczero) 30630,  630, 30630
        !           158:   630 continue
        !           159:       rvon01 = 75e-1
        !           160:       rvon02 = 500.0
        !           161:       rvcomp = rvon01 + (rvon02 + 3.3)
        !           162:       go to 40630
        !           163: 30630 ivdele = ivdele + 1
        !           164:       write (i02,80003) ivtnum
        !           165:       if (iczero) 40630,  641, 40630
        !           166: 40630 if (rvcomp - 510.75) 20630,10630,40631
        !           167: 40631 if (rvcomp - 510.85) 10630,10630,20630
        !           168: 10630 ivpass = ivpass + 1
        !           169:       write (i02,80001) ivtnum
        !           170:       go to  641
        !           171: 20630 ivfail = ivfail + 1
        !           172:       rvcorr = 510.8
        !           173:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           174:   641 continue
        !           175:       ivtnum =  64
        !           176: c
        !           177: c      ****  test  64  ****
        !           178: c
        !           179:       if (iczero) 30640,  640, 30640
        !           180:   640 continue
        !           181:       rvcomp = 7.5 - 500. - 3.3
        !           182:       go to 40640
        !           183: 30640 ivdele = ivdele + 1
        !           184:       write (i02,80003) ivtnum
        !           185:       if (iczero) 40640,  651, 40640
        !           186: 40640 if (rvcomp + 495.85) 20640,10640,40641
        !           187: 40641 if (rvcomp + 495.75) 10640,10640,20640
        !           188: 10640 ivpass = ivpass + 1
        !           189:       write (i02,80001) ivtnum
        !           190:       go to  651
        !           191: 20640 ivfail = ivfail + 1
        !           192:       rvcorr = -495.8
        !           193:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           194:   651 continue
        !           195:       ivtnum =  65
        !           196: c
        !           197: c      ****  test  65  ****
        !           198: c
        !           199:       if (iczero) 30650,  650, 30650
        !           200:   650 continue
        !           201:       rvon01 = 7.5
        !           202:       rvon02 = 5e2
        !           203:       rvcomp = rvon01 - (33e-1 - rvon02)
        !           204:       go to 40650
        !           205: 30650 ivdele = ivdele + 1
        !           206:       write (i02,80003) ivtnum
        !           207:       if (iczero) 40650,  661, 40650
        !           208: 40650 if (rvcomp - 504.15) 20650,10650,40651
        !           209: 40651 if (rvcomp - 504.25) 10650,10650,20650
        !           210: 10650 ivpass = ivpass + 1
        !           211:       write (i02,80001) ivtnum
        !           212:       go to  661
        !           213: 20650 ivfail = ivfail + 1
        !           214:       rvcorr = 504.2
        !           215:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           216:   661 continue
        !           217:       ivtnum =  66
        !           218: c
        !           219: c      ****  test  66  ****
        !           220: c
        !           221:       if (iczero) 30660,  660, 30660
        !           222:   660 continue
        !           223:       rvon01 = 7.5
        !           224:       rvcomp = 5e2 * 33e-1 * rvon01
        !           225:       go to 40660
        !           226: 30660 ivdele = ivdele + 1
        !           227:       write (i02,80003) ivtnum
        !           228:       if (iczero) 40660,  671, 40660
        !           229: 40660 if (rvcomp - 12370) 20660,10660,40661
        !           230: 40661 if (rvcomp - 12380) 10660,10660,20660
        !           231: 10660 ivpass = ivpass + 1
        !           232:       write (i02,80001) ivtnum
        !           233:       go to  671
        !           234: 20660 ivfail = ivfail + 1
        !           235:       rvcorr = 12375.
        !           236:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           237:   671 continue
        !           238:       ivtnum =  67
        !           239: c
        !           240: c      ****  test  67  ****
        !           241: c
        !           242:       if (iczero) 30670,  670, 30670
        !           243:   670 continue
        !           244:       rvon01 = 7.5
        !           245:       rvcomp = 5e2 * (rvon01 * 33e-1)
        !           246:       go to 40670
        !           247: 30670 ivdele = ivdele + 1
        !           248:       write (i02,80003) ivtnum
        !           249:       if (iczero) 40670,  681, 40670
        !           250: 40670 if (rvcomp - 12370) 20670,10670,40671
        !           251: 40671 if (rvcomp - 12380) 10670,10670,20670
        !           252: 10670 ivpass = ivpass + 1
        !           253:       write (i02,80001) ivtnum
        !           254:       go to  681
        !           255: 20670 ivfail = ivfail + 1
        !           256:       rvcorr = 12375.
        !           257:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           258:   681 continue
        !           259:       ivtnum =  68
        !           260: c
        !           261: c      ****  test  68  ****
        !           262: c
        !           263:       if (iczero) 30680,  680, 30680
        !           264:   680 continue
        !           265:       rvon01 = 7.5
        !           266:       rvon02 = 33e-1
        !           267:       rvon03 = -5e+2
        !           268:       rvcomp = rvon01 / rvon02 / rvon03
        !           269:       go to 40680
        !           270: 30680 ivdele = ivdele + 1
        !           271:       write (i02,80003) ivtnum
        !           272:       if (iczero) 40680,  691, 40680
        !           273: 40680 if (rvcomp + .00459) 20680,10680,40681
        !           274: 40681 if (rvcomp + .00449) 10680,10680,20680
        !           275: 10680 ivpass = ivpass + 1
        !           276:       write (i02,80001) ivtnum
        !           277:       go to  691
        !           278: 20680 ivfail = ivfail + 1
        !           279:       rvcorr = -.0045454
        !           280:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           281:   691 continue
        !           282:       ivtnum =  69
        !           283: c
        !           284: c      ****  test  69  ****
        !           285: c
        !           286:       if (iczero) 30690,  690, 30690
        !           287:   690 continue
        !           288:       rvon01 = 7.5
        !           289:       rvon02 = 33e-1
        !           290:       rvon03 = -5e+2
        !           291:       rvcomp = rvon01 / (rvon02 / rvon03)
        !           292:       go to 40690
        !           293: 30690 ivdele = ivdele + 1
        !           294:       write (i02,80003) ivtnum
        !           295:       if (iczero) 40690,  701, 40690
        !           296: 40690 if (rvcomp + 1180.) 20690,10690,40691
        !           297: 40691 if (rvcomp + 1080.) 10690,10690,20690
        !           298: 10690 ivpass = ivpass + 1
        !           299:       write (i02,80001) ivtnum
        !           300:       go to  701
        !           301: 20690 ivfail = ivfail + 1
        !           302:       rvcorr = -1136.4
        !           303:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           304:   701 continue
        !           305:       ivtnum =  70
        !           306: c
        !           307: c      ****  test  70  ****
        !           308: c
        !           309:       if (iczero) 30700,  700, 30700
        !           310:   700 continue
        !           311:       rvon01 = 3.835e3
        !           312:       ivon01 =  5
        !           313:       rvcomp = rvon01 ** ivon01
        !           314:       go to 40700
        !           315: 30700 ivdele = ivdele + 1
        !           316:       write (i02,80003) ivtnum
        !           317:       if (iczero) 40700,  711, 40700
        !           318: 40700 if (rvcomp - 8.29e17) 20700,10700,40701
        !           319: 40701 if (rvcomp - 8.30e17) 10700,10700,20700
        !           320: 10700 ivpass = ivpass + 1
        !           321:       write (i02,80001) ivtnum
        !           322:       go to  711
        !           323: 20700 ivfail = ivfail + 1
        !           324:       rvcorr = 8.295e17
        !           325:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           326:   711 continue
        !           327: c
        !           328: c     tests 71 through 74 test  rv1 + rv2 <op2> rv3
        !           329: c
        !           330:       ivtnum =  71
        !           331: c
        !           332: c      ****  test  71  ****
        !           333: c
        !           334:       if (iczero) 30710,  710, 30710
        !           335:   710 continue
        !           336:       rvon01 = 524.87
        !           337:       rvon02 = 3.35
        !           338:       rvon03 = .005679
        !           339:       rvcomp = rvon01 + rvon02 - rvon03
        !           340:       go to 40710
        !           341: 30710 ivdele = ivdele + 1
        !           342:       write (i02,80003) ivtnum
        !           343:       if (iczero) 40710,  721, 40710
        !           344: 40710 if (rvcomp - 528.16) 20710,10710,40711
        !           345: 40711 if (rvcomp - 528.26) 10710,10710,20710
        !           346: 10710 ivpass = ivpass + 1
        !           347:       write (i02,80001) ivtnum
        !           348:       go to  721
        !           349: 20710 ivfail = ivfail + 1
        !           350:       rvcorr = 528.21
        !           351:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           352:   721 continue
        !           353:       ivtnum =  72
        !           354: c
        !           355: c      ****  test  72  ****
        !           356: c
        !           357:       if (iczero) 30720,  720, 30720
        !           358:   720 continue
        !           359:       rvon01 = 524.87
        !           360:       rvon02 = 3.35
        !           361:       rvon03 = .005679
        !           362:       rvcomp = rvon01 + rvon02 * rvon03
        !           363:       go to 40720
        !           364: 30720 ivdele = ivdele + 1
        !           365:       write (i02,80003) ivtnum
        !           366:       if (iczero) 40720,  731, 40720
        !           367: 40720 if (rvcomp - 524.84) 20720,10720,40721
        !           368: 40721 if (rvcomp - 524.94) 10720,10720,20720
        !           369: 10720 ivpass = ivpass + 1
        !           370:       write (i02,80001) ivtnum
        !           371:       go to  731
        !           372: 20720 ivfail = ivfail + 1
        !           373:       rvcorr = 524.89
        !           374:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           375:   731 continue
        !           376:       ivtnum =  73
        !           377: c
        !           378: c      ****  test  73  ****
        !           379: c
        !           380:       if (iczero) 30730,  730, 30730
        !           381:   730 continue
        !           382:       rvon01 = 524.87
        !           383:       rvon02 = 3.35
        !           384:       rvon03 = .005679
        !           385:       rvcomp = rvon01 + rvon02 / rvon03
        !           386:       go to 40730
        !           387: 30730 ivdele = ivdele + 1
        !           388:       write (i02,80003) ivtnum
        !           389:       if (iczero) 40730,  741, 40730
        !           390: 40730 if (rvcomp - 1114.2) 20730,10730,40731
        !           391: 40731 if (rvcomp - 1115.2) 10730,10730,20730
        !           392: 10730 ivpass = ivpass + 1
        !           393:       write (i02,80001) ivtnum
        !           394:       go to  741
        !           395: 20730 ivfail = ivfail + 1
        !           396:       rvcorr = 1114.8
        !           397:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           398:   741 continue
        !           399:       ivtnum =  74
        !           400: c
        !           401: c      ****  test  74  ****
        !           402: c
        !           403:       if (iczero) 30740,  740, 30740
        !           404:   740 continue
        !           405:       rvon01 = 524.87
        !           406:       rvon02 = 3.35
        !           407:       ivon01 = 7
        !           408:       rvcomp = rvon01 + rvon02 ** ivon01
        !           409:       go to 40740
        !           410: 30740 ivdele = ivdele + 1
        !           411:       write (i02,80003) ivtnum
        !           412:       if (iczero) 40740,  751, 40740
        !           413: 40740 if (rvcomp - 5259.3) 20740,10740,40741
        !           414: 40741 if (rvcomp - 5260.3) 10740,10740,20740
        !           415: 10740 ivpass = ivpass + 1
        !           416:       write (i02,80001) ivtnum
        !           417:       go to  751
        !           418: 20740 ivfail = ivfail + 1
        !           419:       rvcorr = 5259.8
        !           420:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           421:   751 continue
        !           422: c
        !           423: c     tests 75 through 78 check     rv1 - rv2 <op2> rv3
        !           424: c
        !           425:       ivtnum =  75
        !           426: c
        !           427: c      ****  test  75  ****
        !           428: c
        !           429:       if (iczero) 30750,  750, 30750
        !           430:   750 continue
        !           431:       rvon01 = 524.87
        !           432:       rvon02 = 3.35
        !           433:       rvon03 = .5679
        !           434:       rvcomp = rvon01 - rvon02 + rvon03
        !           435:       go to 40750
        !           436: 30750 ivdele = ivdele + 1
        !           437:       write (i02,80003) ivtnum
        !           438:       if (iczero) 40750,  761, 40750
        !           439: 40750 if (rvcomp - 522.03) 20750,10750,40751
        !           440: 40751 if (rvcomp - 522.13) 10750,10750,20750
        !           441: 10750 ivpass = ivpass + 1
        !           442:       write (i02,80001) ivtnum
        !           443:       go to  761
        !           444: 20750 ivfail = ivfail + 1
        !           445:       rvcorr = 522.09
        !           446:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           447:   761 continue
        !           448:       ivtnum =  76
        !           449: c
        !           450: c      ****  test  76  ****
        !           451: c
        !           452:       if (iczero) 30760,  760, 30760
        !           453:   760 continue
        !           454:       rvon01 = 524.87
        !           455:       rvon02 =   3.35
        !           456:       rvon03 =    .5679
        !           457:       rvcomp = rvon01 - rvon02 * rvon03
        !           458:       go to 40760
        !           459: 30760 ivdele = ivdele + 1
        !           460:       write (i02,80003) ivtnum
        !           461:       if (iczero) 40760,  771, 40760
        !           462: 40760 if (rvcomp - 522.92) 20760,10760,40761
        !           463: 40761 if (rvcomp - 523.02) 10760,10760,20760
        !           464: 10760 ivpass = ivpass + 1
        !           465:       write (i02,80001) ivtnum
        !           466:       go to  771
        !           467: 20760 ivfail = ivfail + 1
        !           468:       rvcorr = 522.97
        !           469:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           470:   771 continue
        !           471:       ivtnum =  77
        !           472: c
        !           473: c      ****  test  77  ****
        !           474: c
        !           475:       if (iczero) 30770,  770, 30770
        !           476:   770 continue
        !           477:       rvon01 = 524.87
        !           478:       rvon02 =   3.35
        !           479:       rvon03 =    .5679
        !           480:       rvcomp = rvon01 - rvon02 / rvon03
        !           481:       go to 40770
        !           482: 30770 ivdele = ivdele + 1
        !           483:       write (i02,80003) ivtnum
        !           484:       if (iczero) 40770,  781, 40770
        !           485: 40770 if (rvcomp - 518.92) 20770,10770,40771
        !           486: 40771 if (rvcomp - 519.02) 10770,10770,20770
        !           487: 10770 ivpass = ivpass + 1
        !           488:       write (i02,80001) ivtnum
        !           489:       go to  781
        !           490: 20770 ivfail = ivfail + 1
        !           491:       rvcorr = 518.97
        !           492:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           493:   781 continue
        !           494:       ivtnum =  78
        !           495: c
        !           496: c      ****  test  78  ****
        !           497: c
        !           498:       if (iczero) 30780,  780, 30780
        !           499:   780 continue
        !           500:       rvon01 = 524.87
        !           501:       rvon02 =   3.35
        !           502:       ivon01 =   7
        !           503:       rvcomp = rvon01 - rvon02 ** ivon01
        !           504:       go to 40780
        !           505: 30780 ivdele = ivdele + 1
        !           506:       write (i02,80003) ivtnum
        !           507:       if (iczero) 40780,  791, 40780
        !           508: 40780 if (rvcomp + 4210.6) 20780,10780,40781
        !           509: 40781 if (rvcomp + 4209.6) 10780,10780,20780
        !           510: 10780 ivpass = ivpass + 1
        !           511:       write (i02,80001) ivtnum
        !           512:       go to  791
        !           513: 20780 ivfail = ivfail + 1
        !           514:       rvcorr = -4210.1
        !           515:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           516:   791 continue
        !           517: c
        !           518: c     tests 79 through 82 check     rv1 * rv2 <op2> rv3
        !           519: c
        !           520:       ivtnum =  79
        !           521: c
        !           522: c      ****  test  79  ****
        !           523: c
        !           524:       if (iczero) 30790,  790, 30790
        !           525:   790 continue
        !           526:       rvon01 = 524.87
        !           527:       rvon02 =   .5679
        !           528:       rvon03 =   3.35
        !           529:       rvcomp = rvon01 * rvon02 + rvon03
        !           530:       go to 40790
        !           531: 30790 ivdele = ivdele + 1
        !           532:       write (i02,80003) ivtnum
        !           533:       if (iczero) 40790,  801, 40790
        !           534: 40790 if (rvcomp - 301.37) 20790,10790,40791
        !           535: 40791 if (rvcomp - 301.47) 10790,10790,20790
        !           536: 10790 ivpass = ivpass + 1
        !           537:       write (i02,80001) ivtnum
        !           538:       go to  801
        !           539: 20790 ivfail = ivfail + 1
        !           540:       rvcorr = 301.42
        !           541:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           542:   801 continue
        !           543:       ivtnum =  80
        !           544: c
        !           545: c      ****  test  80  ****
        !           546: c
        !           547:       if (iczero) 30800,  800, 30800
        !           548:   800 continue
        !           549:       rvon01 = 524.87
        !           550:       rvon02 =    .5679
        !           551:       rvon03 =   3.35
        !           552:       rvcomp = rvon01 * rvon02 - rvon03
        !           553:       go to 40800
        !           554: 30800 ivdele = ivdele + 1
        !           555:       write (i02,80003) ivtnum
        !           556:       if (iczero) 40800,  811, 40800
        !           557: 40800 if (rvcomp - 294.67) 20800,10800,40801
        !           558: 40801 if (rvcomp - 294.77) 10800,10800,20800
        !           559: 10800 ivpass = ivpass + 1
        !           560:       write (i02,80001) ivtnum
        !           561:       go to  811
        !           562: 20800 ivfail = ivfail + 1
        !           563:       rvcorr = 294.72
        !           564:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           565:   811 continue
        !           566:       ivtnum =  81
        !           567: c
        !           568: c      ****  test  81  ****
        !           569: c
        !           570:       if (iczero) 30810,  810, 30810
        !           571:   810 continue
        !           572:       rvon01 = 524.87
        !           573:       rvon02 =    .5679
        !           574:       rvon03 =   3.35
        !           575:       rvcomp = rvon01 * rvon02 / rvon03
        !           576:       go to 40810
        !           577: 30810 ivdele = ivdele + 1
        !           578:       write (i02,80003) ivtnum
        !           579:       if (iczero) 40810,  821, 40810
        !           580: 40810 if (rvcomp - 88.92) 20810,10810,40811
        !           581: 40811 if (rvcomp - 89.02) 10810,10810,20810
        !           582: 10810 ivpass = ivpass + 1
        !           583:       write (i02,80001) ivtnum
        !           584:       go to  821
        !           585: 20810 ivfail = ivfail + 1
        !           586:       rvcorr = 88.977
        !           587:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           588:   821 continue
        !           589:       ivtnum =  82
        !           590: c
        !           591: c      ****  test  82  ****
        !           592: c
        !           593:       if (iczero) 30820,  820, 30820
        !           594:   820 continue
        !           595:       rvon01 = 524.87
        !           596:       rvon02 =    .5679
        !           597:       ivon01 =   7
        !           598:       rvcomp = rvon01 * rvon02 ** ivon01
        !           599:       go to 40820
        !           600: 30820 ivdele = ivdele + 1
        !           601:       write (i02,80003) ivtnum
        !           602:       if (iczero) 40820,  831, 40820
        !           603: 40820 if (rvcomp -  9.94) 20820,10820,40821
        !           604: 40821 if (rvcomp - 10.04) 10820,10820,20820
        !           605: 10820 ivpass = ivpass + 1
        !           606:       write (i02,80001) ivtnum
        !           607:       go to  831
        !           608: 20820 ivfail = ivfail + 1
        !           609:       rvcorr = 9.999
        !           610:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           611:   831 continue
        !           612: c
        !           613: c     tests 83 through 86 check     rv1 / rv2 <op2> rv3
        !           614: c
        !           615:       ivtnum =  83
        !           616: c
        !           617: c      ****  test  83  ****
        !           618: c
        !           619:       if (iczero) 30830,  830, 30830
        !           620:   830 continue
        !           621:       rvon01 = 524.87
        !           622:       rvon02 =   3.35
        !           623:       rvon03 =    .5679
        !           624:       rvcomp = rvon01 / rvon02 + rvon03
        !           625:       go to 40830
        !           626: 30830 ivdele = ivdele + 1
        !           627:       write (i02,80003) ivtnum
        !           628:       if (iczero) 40830,  841, 40830
        !           629: 40830 if (rvcomp - 157.19) 20830,10830,40831
        !           630: 40831 if (rvcomp - 157.29) 10830,10830,20830
        !           631: 10830 ivpass = ivpass + 1
        !           632:       write (i02,80001) ivtnum
        !           633:       go to  841
        !           634: 20830 ivfail = ivfail + 1
        !           635:       rvcorr = 157.25
        !           636:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           637:   841 continue
        !           638:       ivtnum =  84
        !           639: c
        !           640: c      ****  test  84  ****
        !           641: c
        !           642:       if (iczero) 30840,  840, 30840
        !           643:   840 continue
        !           644:       rvon01 = 524.87
        !           645:       rvon02 =   3.35
        !           646:       rvon03 =    .8507
        !           647:       rvcomp = rvon01 / rvon02 - rvon03
        !           648:       go to 40840
        !           649: 30840 ivdele = ivdele + 1
        !           650:       write (i02,80003) ivtnum
        !           651:       if (iczero) 40840,  851, 40840
        !           652: 40840 if (rvcomp - 155.77) 20840,10840,40841
        !           653: 40841 if (rvcomp - 155.87) 10840,10840,20840
        !           654: 10840 ivpass = ivpass + 1
        !           655:       write (i02,80001) ivtnum
        !           656:       go to  851
        !           657: 20840 ivfail = ivfail + 1
        !           658:       rvcorr = 155.83
        !           659:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           660:   851 continue
        !           661:       ivtnum =  85
        !           662: c
        !           663: c      ****  test  85  ****
        !           664: c
        !           665:       if (iczero) 30850,  850, 30850
        !           666:   850 continue
        !           667:       rvon01 = 524.87
        !           668:       rvon02 =   3.35
        !           669:       rvon03 =    .8507
        !           670:       rvcomp = rvon01 / rvon02 * rvon03
        !           671:       go to 40850
        !           672: 30850 ivdele = ivdele + 1
        !           673:       write (i02,80003) ivtnum
        !           674:       if (iczero) 40850,  861, 40850
        !           675: 40850 if (rvcomp - 132.7) 20850,10850,40851
        !           676: 40851 if (rvcomp - 133.7) 10850,10850,20850
        !           677: 10850 ivpass = ivpass + 1
        !           678:       write (i02,80001) ivtnum
        !           679:       go to  861
        !           680: 20850 ivfail = ivfail + 1
        !           681:       rvcorr = 133.29
        !           682:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           683:   861 continue
        !           684:       ivtnum =  86
        !           685: c
        !           686: c      ****  test  86  ****
        !           687: c
        !           688:       if (iczero) 30860,  860, 30860
        !           689:   860 continue
        !           690:       rvon01 = 524.87
        !           691:       rvon02 =   3.35
        !           692:       ivon01 =   7
        !           693:       rvcomp = rvon01 / rvon02 ** ivon01
        !           694:       go to 40860
        !           695: 30860 ivdele = ivdele + 1
        !           696:       write (i02,80003) ivtnum
        !           697:       if (iczero) 40860,  871, 40860
        !           698: 40860 if (rvcomp - .106) 20860,10860,40861
        !           699: 40861 if (rvcomp - .116) 10860,10860,20860
        !           700: 10860 ivpass = ivpass + 1
        !           701:       write (i02,80001) ivtnum
        !           702:       go to  871
        !           703: 20860 ivfail = ivfail + 1
        !           704:       rvcorr = .11085
        !           705:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           706:   871 continue
        !           707: c
        !           708: c     tests 87 through 90 check     rv1 ** iv1 <op2> rv2
        !           709: c
        !           710:       ivtnum =  87
        !           711: c
        !           712: c      ****  test  87  ****
        !           713: c
        !           714:       if (iczero) 30870,  870, 30870
        !           715:   870 continue
        !           716:       rvon01 =   3.35
        !           717:       ivon01 =   7
        !           718:       rvon02 = 524.87
        !           719:       rvcomp = rvon01 ** ivon01 + rvon02
        !           720:       go to 40870
        !           721: 30870 ivdele = ivdele + 1
        !           722:       write (i02,80003) ivtnum
        !           723:       if (iczero) 40870,  881, 40870
        !           724: 40870 if (rvcomp - 5210.) 20870,10870,40871
        !           725: 40871 if (rvcomp - 5310.) 10870,10870,20870
        !           726: 10870 ivpass = ivpass + 1
        !           727:       write (i02,80001) ivtnum
        !           728:       go to  881
        !           729: 20870 ivfail = ivfail + 1
        !           730:       rvcorr = 5259.8
        !           731:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           732:   881 continue
        !           733:       ivtnum =  88
        !           734: c
        !           735: c      ****  test  88  ****
        !           736: c
        !           737:       if (iczero) 30880,  880, 30880
        !           738:   880 continue
        !           739:       rvon01 =   3.35
        !           740:       ivon01 =   7
        !           741:       rvon02 = 524.87
        !           742:       rvcomp = rvon01 ** ivon01 - rvon02
        !           743:       go to 40880
        !           744: 30880 ivdele = ivdele + 1
        !           745:       write (i02,80003) ivtnum
        !           746:       if (iczero) 40880,  891, 40880
        !           747: 40880 if (rvcomp - 4160.) 20880,10880,40881
        !           748: 40881 if (rvcomp - 4260.) 10880,10880,20880
        !           749: 10880 ivpass = ivpass + 1
        !           750:       write (i02,80001) ivtnum
        !           751:       go to  891
        !           752: 20880 ivfail = ivfail + 1
        !           753:       rvcorr = 4210.1
        !           754:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           755:   891 continue
        !           756:       ivtnum =  89
        !           757: c
        !           758: c      ****  test  89  ****
        !           759: c
        !           760:       if (iczero) 30890,  890, 30890
        !           761:   890 continue
        !           762:       rvon01 =   3.35
        !           763:       ivon01 =   7
        !           764:       rvon02 = 524.87
        !           765:       rvcomp = rvon01 ** ivon01 * rvon02
        !           766:       go to 40890
        !           767: 30890 ivdele = ivdele + 1
        !           768:       write (i02,80003) ivtnum
        !           769:       if (iczero) 40890,  901, 40890
        !           770: 40890 if (rvcomp - 2.43e6) 20890,10890,40891
        !           771: 40891 if (rvcomp - 2.53e6) 10890,10890,20890
        !           772: 10890 ivpass = ivpass + 1
        !           773:       write (i02,80001) ivtnum
        !           774:       go to  901
        !           775: 20890 ivfail = ivfail + 1
        !           776:       rvcorr = 2.4852e6
        !           777:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           778:   901 continue
        !           779:       ivtnum =  90
        !           780: c
        !           781: c      ****  test  90  ****
        !           782: c
        !           783:       if (iczero) 30900,  900, 30900
        !           784:   900 continue
        !           785:       rvon01 =   3.35
        !           786:       ivon01 =   7
        !           787:       rvon02 = 524.87
        !           788:       rvcomp = rvon01 ** ivon01 / rvon02
        !           789:       go to 40900
        !           790: 30900 ivdele = ivdele + 1
        !           791:       write (i02,80003) ivtnum
        !           792:       if (iczero) 40900,  911, 40900
        !           793: 40900 if (rvcomp - 8.97) 20900,10900,40901
        !           794: 40901 if (rvcomp - 9.07) 10900,10900,20900
        !           795: 10900 ivpass = ivpass + 1
        !           796:       write (i02,80001) ivtnum
        !           797:       go to  911
        !           798: 20900 ivfail = ivfail + 1
        !           799:       rvcorr = 9.0211
        !           800:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           801:   911 continue
        !           802: c
        !           803: c     tests 91 and 92 check all arithmetic operators used together
        !           804: c
        !           805:       ivtnum =  91
        !           806: c
        !           807: c      ****  test  91  ****
        !           808: c
        !           809:       if (iczero) 30910,  910, 30910
        !           810:   910 continue
        !           811:       rvon01 = 780.56
        !           812:       rvon02 =    .803
        !           813:       rvon03 =   3.35
        !           814:       ivon01 =   7
        !           815:       rvon04 =  20.07
        !           816:       rvon05 = 511.9
        !           817:       rvcomp = - rvon01 + rvon02 * rvon03 ** ivon01 / rvon04 - rvon05
        !           818:       go to 40910
        !           819: 30910 ivdele = ivdele + 1
        !           820:       write (i02,80003) ivtnum
        !           821:       if (iczero) 40910,  921, 40910
        !           822: 40910 if (rvcomp + 1113.0) 20910,10910,40911
        !           823: 40911 if (rvcomp + 1093.0) 10910,10910,20910
        !           824: 10910 ivpass = ivpass + 1
        !           825:       write (i02,80001) ivtnum
        !           826:       go to  921
        !           827: 20910 ivfail = ivfail + 1
        !           828:       rvcorr = -1103.0
        !           829:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           830:   921 continue
        !           831:       ivtnum =  92
        !           832: c
        !           833: c      ****  test  92  ****
        !           834: c
        !           835:       if (iczero) 30920,  920, 30920
        !           836:   920 continue
        !           837:       rvon01 = 780.56
        !           838:       rvon02 =    .803
        !           839:       rvon03 =   3.35
        !           840:       ivon01 =   7
        !           841:       rvon04 =  20.07
        !           842:       rvon05 = 511.9
        !           843:       rvcomp = (-rvon01) + (rvon02 * rvon03) ** ivon01 / (rvon04-rvon05)
        !           844:       go to 40920
        !           845: 30920 ivdele = ivdele + 1
        !           846:       write (i02,80003) ivtnum
        !           847:       if (iczero) 40920,  931, 40920
        !           848: 40920 if (rvcomp + 788.) 20920,10920,40921
        !           849: 40921 if (rvcomp + 777.) 10920,10920,20920
        !           850: 10920 ivpass = ivpass + 1
        !           851:       write (i02,80001) ivtnum
        !           852:       go to  931
        !           853: 20920 ivfail = ivfail + 1
        !           854:       rvcorr = -782.63
        !           855:       write (i02,80005) ivtnum, rvcomp, rvcorr
        !           856:   931 continue
        !           857: c
        !           858: c     write page footings and run summaries
        !           859: 99999 continue
        !           860:       write (i02,90002)
        !           861:       write (i02,90006)
        !           862:       write (i02,90002)
        !           863:       write (i02,90002)
        !           864:       write (i02,90007)
        !           865:       write (i02,90002)
        !           866:       write (i02,90008)  ivfail
        !           867:       write (i02,90009) ivpass
        !           868:       write (i02,90010) ivdele
        !           869: c
        !           870: c
        !           871: c     terminate routine execution
        !           872:       stop
        !           873: c
        !           874: c     format statements for page headers
        !           875: 90000 format (1h1)
        !           876: 90002 format (1h )
        !           877: 90001 format (1h ,10x,34hfortran compiler validation system)
        !           878: 90003 format (1h ,21x,11hversion 1.0)
        !           879: 90004 format (1h ,10x,38hfor official use only - copyright 1978)
        !           880: 90005 format (1h ,5x,4htest,5x,9hpass/fail, 5x,8hcomputed,8x,7hcorrect)
        !           881: 90006 format (1h ,5x,46h----------------------------------------------)
        !           882: 90011 format (1h ,18x,17hsubset level test)
        !           883: c
        !           884: c     format statements for run summaries
        !           885: 90008 format (1h ,15x,i5,19h errors encountered)
        !           886: 90009 format (1h ,15x,i5,13h tests passed)
        !           887: 90010 format (1h ,15x,i5,14h tests deleted)
        !           888: c
        !           889: c     format statements for test results
        !           890: 80001 format (1h ,4x,i5,7x,4hpass)
        !           891: 80002 format (1h ,4x,i5,7x,4hfail)
        !           892: 80003 format (1h ,4x,i5,7x,7hdeleted)
        !           893: 80004 format (1h ,4x,i5,7x,4hfail,10x,i6,9x,i6)
        !           894: 80005 format (1h ,4x,i5,7x,4hfail,4x,e12.5,3x,e12.5)
        !           895: c
        !           896: 90007 format (1h ,20x,20hend of program fm062)
        !           897:       end

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