Return to fm042.f CVS log

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

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

1.1     ! root        1: c     comment section
        !             2: c
        !             3: c     fm042
        !             4: c
        !             5: c         this routine tests arithmetic assignments of the
        !             6: c     form      integer variable =  primary ** primary
        !             7: c     where the first of two primaries is an integer variable or an
        !             8: c     integer constant and the second primary is an integer variable.
        !             9: c
        !            10: c      references
        !            11: c        american national standard programming language fortran,
        !            12: c              x3.9-1978
        !            13: c
        !            14: c        section 4.3, integer type
        !            15: c        section 4.3.1, integer constant
        !            16: c        section 6.1, arithmetic expressions
        !            17: c        section 10.1, arithmetic assignment statement
        !            18: c
        !            19: c
        !            20: c      **********************************************************
        !            21: c
        !            22: c         a compiler validation system for the fortran language
        !            23: c     based on specifications as defined in american national standard
        !            24: c     programming language fortran x3.9-1978, has been developed by the
        !            25: c     federal cobol compiler testing service.  the fortran compiler
        !            26: c     validation system (fcvs) consists of audit routines, their related
        !            27: c     data, and an executive system.  each audit routine is a fortran
        !            28: c     program, subprogram or function which includes tests of specific
        !            29: c     language elements and supporting procedures indicating the result
        !            30: c     of executing these tests.
        !            31: c
        !            32: c         this particular program/subprogram/function contains features
        !            33: c     found only in the subset as defined in x3.9-1978.
        !            34: c
        !            35: c         suggestions and comments should be forwarded to -
        !            36: c
        !            37: c                  department of the navy
        !            38: c                  federal cobol compiler testing service
        !            39: c                  washington, d.c.  20376
        !            40: c
        !            41: c      **********************************************************
        !            42: c
        !            43: c
        !            44: c
        !            45: c     initialization section
        !            46: c
        !            47: c     initialize constants
        !            48: c      **************
        !            49: c     i01 contains the logical unit number for the card reader.
        !            50:       i01 = 5
        !            51: c     i02 contains the logical unit number for the printer.
        !            52:       i02 = 6
        !            53: c     system environment section
        !            54: c
        !            55: cx010    this card is replaced by contents of fexec x-010 control card.
        !            56: c     the cx010 card is for overriding the program default i01 = 5
        !            57: c     (unit number for card reader).
        !            58: cx011    this card is replaced by contents of fexec x-011 control card.
        !            59: c     the cx011 card is for systems which require additional
        !            60: c     fortran statements for files associated with cx010 above.
        !            61: c
        !            62: cx020    this card is replaced by contents of fexec x-020 control card.
        !            63: c     the cx020 card is for overriding the program default i02 = 6
        !            64: c     (unit number for printer).
        !            65: cx021    this card is replaced by contents of fexec x-021 control card.
        !            66: c     the cx021 card is for systems which require additional
        !            67: c     fortran statements for files associated with cx020 above.
        !            68: c
        !            69:       ivpass=0
        !            70:       ivfail=0
        !            71:       ivdele=0
        !            72:       iczero=0
        !            73: c
        !            74: c     write page headers
        !            75:       write (i02,90000)
        !            76:       write (i02,90001)
        !            77:       write (i02,90002)
        !            78:       write (i02, 90002)
        !            79:       write (i02,90003)
        !            80:       write (i02,90002)
        !            81:       write (i02,90004)
        !            82:       write (i02,90002)
        !            83:       write (i02,90011)
        !            84:       write (i02,90002)
        !            85:       write (i02,90002)
        !            86:       write (i02,90005)
        !            87:       write (i02,90006)
        !            88:       write (i02,90002)
        !            89: c
        !            90: c     test section
        !            91: c
        !            92: c         arithmetic assignment statement
        !            93: c
        !            94: c     test 649 through test 665 contain arithmetic assignment statements
        !            95: c     of the form    integer variable = integer const. ** integer var.
        !            96: c
        !            97: c     test 666 through test 682 contain arithmetic assignment statements
        !            98: c     of the form    integer variable = integer var. ** integer var.
        !            99: c
        !           100: c
        !           101:       ivtnum = 649
        !           102: c
        !           103: c      ****  test 649  ****
        !           104: c     test 649  - small number base; zero exponent
        !           105: c
        !           106:       if (iczero) 36490, 6490, 36490
        !           107:  6490 continue
        !           108:       ivon01 = 0
        !           109:       ivcomp = 1 ** ivon01
        !           110:       go to 46490
        !           111: 36490 ivdele = ivdele + 1
        !           112:       write (i02,80003) ivtnum
        !           113:       if (iczero) 46490, 6501, 46490
        !           114: 46490 if (ivcomp - 1) 26490,16490,26490
        !           115: 16490 ivpass = ivpass + 1
        !           116:       write (i02,80001) ivtnum
        !           117:       go to 6501
        !           118: 26490 ivfail = ivfail + 1
        !           119:       ivcorr = 1
        !           120:       write (i02,80004) ivtnum, ivcomp ,ivcorr
        !           121:  6501 continue
        !           122:       ivtnum = 650
        !           123: c
        !           124: c      ****  test 650  ****
        !           125: c     test 650  - zero base to first power
        !           126: c
        !           127:       if (iczero) 36500, 6500, 36500
        !           128:  6500 continue
        !           129:       ivon01 = 1
        !           130:       ivcomp = 0 ** ivon01
        !           131:       go to 46500
        !           132: 36500 ivdele = ivdele + 1
        !           133:       write (i02,80003) ivtnum
        !           134:       if (iczero) 46500, 6511, 46500
        !           135: 46500 if (ivcomp) 26500,16500,26500
        !           136: 16500 ivpass = ivpass + 1
        !           137:       write (i02,80001) ivtnum
        !           138:       go to 6511
        !           139: 26500 ivfail = ivfail + 1
        !           140:       ivcorr = 0
        !           141:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           142:  6511 continue
        !           143:       ivtnum = 651
        !           144: c
        !           145: c      ****  test 651  ****
        !           146: c     test 651  - base =1; exponent = 1
        !           147: c
        !           148:       if (iczero) 36510, 6510, 36510
        !           149:  6510 continue
        !           150:       ivon01 = 1
        !           151:       ivcomp = 1 ** ivon01
        !           152:       go to 46510
        !           153: 36510 ivdele = ivdele + 1
        !           154:       write (i02,80003) ivtnum
        !           155:       if (iczero) 46510, 6521, 46510
        !           156: 46510 if (ivcomp - 1) 26510,16510,26510
        !           157: 16510 ivpass = ivpass + 1
        !           158:       write (i02,80001) ivtnum
        !           159:       go to 6521
        !           160: 26510 ivfail = ivfail + 1
        !           161:       ivcorr = 1
        !           162:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           163:  6521 continue
        !           164:       ivtnum = 652
        !           165: c
        !           166: c      ****  test 652  ****
        !           167: c     test 652  - large exponent
        !           168: c
        !           169:       if (iczero) 36520, 6520, 36520
        !           170:  6520 continue
        !           171:       ivon01 = 32767
        !           172:       ivcomp = 1 ** ivon01
        !           173:       go to 46520
        !           174: 36520 ivdele = ivdele + 1
        !           175:       write (i02,80003) ivtnum
        !           176:       if (iczero) 46520, 6531, 46520
        !           177: 46520 if (ivcomp - 1) 26520,16520,26520
        !           178: 16520 ivpass = ivpass + 1
        !           179:       write (i02,80001) ivtnum
        !           180:       go to 6531
        !           181: 26520 ivfail = ivfail + 1
        !           182:       ivcorr = 1
        !           183:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           184:  6531 continue
        !           185:       ivtnum = 653
        !           186: c
        !           187: c      ****  test 653  ****
        !           188: c     test 653  - large number base; exponent = 1
        !           189: c
        !           190:       if (iczero) 36530, 6530, 36530
        !           191:  6530 continue
        !           192:       ivon01 = 1
        !           193:       ivcomp = 32767 ** ivon01
        !           194:       go to 46530
        !           195: 36530 ivdele = ivdele + 1
        !           196:       write (i02,80003) ivtnum
        !           197:       if (iczero) 46530, 6541, 46530
        !           198: 46530 if (ivcomp - 32767) 26530,16530,26530
        !           199: 16530 ivpass = ivpass + 1
        !           200:       write (i02,80001) ivtnum
        !           201:       go to 6541
        !           202: 26530 ivfail = ivfail + 1
        !           203:       ivcorr = 32767
        !           204:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           205:  6541 continue
        !           206:       ivtnum = 654
        !           207: c
        !           208: c      ****  test 654  ****
        !           209: c     test 654  - zero base; large number exponent
        !           210: c
        !           211:       if (iczero) 36540, 6540, 36540
        !           212:  6540 continue
        !           213:       ivon01 = 32767
        !           214:       ivcomp = 0 ** ivon01
        !           215:       go to 46540
        !           216: 36540 ivdele = ivdele + 1
        !           217:       write (i02,80003) ivtnum
        !           218:       if (iczero) 46540, 6551, 46540
        !           219: 46540 if (ivcomp) 26540,16540,26540
        !           220: 16540 ivpass = ivpass + 1
        !           221:       write (i02,80001) ivtnum
        !           222:       go to 6551
        !           223: 26540 ivfail = ivfail + 1
        !           224:       ivcorr = 0
        !           225:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           226:  6551 continue
        !           227:       ivtnum = 655
        !           228: c
        !           229: c      ****  test 655  ****
        !           230: c     test 655  -large number base; zero exponent
        !           231: c
        !           232:       if (iczero) 36550, 6550, 36550
        !           233:  6550 continue
        !           234:       ivon01 = 0
        !           235:       ivcomp = 32767 ** ivon01
        !           236:       go to 46550
        !           237: 36550 ivdele = ivdele + 1
        !           238:       write (i02,80003) ivtnum
        !           239:       if (iczero) 46550, 6561, 46550
        !           240: 46550 if (ivcomp -1) 26550,16550,26550
        !           241: 16550 ivpass = ivpass + 1
        !           242:       write (i02,80001) ivtnum
        !           243:       go to 6561
        !           244: 26550 ivfail = ivfail + 1
        !           245:       ivcorr = 1
        !           246:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           247:  6561 continue
        !           248:       ivtnum = 656
        !           249: c
        !           250: c      ****  test 656  ****
        !           251: c     test 656  -exponent is power of two
        !           252: c
        !           253:       if (iczero) 36560, 6560, 36560
        !           254:  6560 continue
        !           255:       ivon01 = 2
        !           256:       ivcomp = 181 ** ivon01
        !           257:       go to 46560
        !           258: 36560 ivdele = ivdele + 1
        !           259:       write (i02,80003) ivtnum
        !           260:       if (iczero) 46560, 6571, 46560
        !           261: 46560 if (ivcomp - 32761) 26560,16560,26560
        !           262: 16560 ivpass = ivpass + 1
        !           263:       write (i02,80001) ivtnum
        !           264:       go to 6571
        !           265: 26560 ivfail = ivfail + 1
        !           266:       ivcorr = 32761
        !           267:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           268:  6571 continue
        !           269:       ivtnum = 657
        !           270: c
        !           271: c      ****  test 657  ****
        !           272: c     test 657  - base and exponent are both powers of two
        !           273: c
        !           274:       if (iczero) 36570, 6570, 36570
        !           275:  6570 continue
        !           276:       ivon01 = 8
        !           277:       ivcomp = 2 ** ivon01
        !           278:       go to 46570
        !           279: 36570 ivdele = ivdele + 1
        !           280:       write (i02,80003) ivtnum
        !           281:       if (iczero) 46570, 6581, 46570
        !           282: 46570 if (ivcomp - 256) 26570,16570,26560
        !           283: 16570 ivpass = ivpass + 1
        !           284:       write (i02,80001) ivtnum
        !           285:       go to 6581
        !           286: 26570 ivfail = ivfail + 1
        !           287:       ivcorr = 256
        !           288:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           289:  6581 continue
        !           290: c
        !           291: c     tests 658 and 659 test to ensure exponentiation operator is
        !           292: c                       not commutative
        !           293: c
        !           294:       ivtnum = 658
        !           295: c
        !           296: c      ****  test 658  ****
        !           297: c
        !           298:       if (iczero) 36580, 6580, 36580
        !           299:  6580 continue
        !           300:       ivon01 = 9
        !           301:       ivcomp = 3 ** ivon01
        !           302:       go to 46580
        !           303: 36580 ivdele = ivdele + 1
        !           304:       write (i02,80003) ivtnum
        !           305:       if (iczero) 46580, 6591, 46580
        !           306: 46580 if (ivcomp - 19683) 26580,16580,26580
        !           307: 16580 ivpass = ivpass + 1
        !           308:       write (i02,80001) ivtnum
        !           309:       go to 6591
        !           310: 26580 ivfail = ivfail + 1
        !           311:       ivcorr = 19683
        !           312:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           313:  6591 continue
        !           314:       ivtnum = 659
        !           315: c
        !           316: c      ****  test 659  ****
        !           317: c
        !           318:       if (iczero) 36590, 6590, 36590
        !           319:  6590 continue
        !           320:       ivon01 = 3
        !           321:       ivcomp = 9 ** ivon01
        !           322:       go to 46590
        !           323: 36590 ivdele = ivdele + 1
        !           324:       write (i02,80003) ivtnum
        !           325:       if (iczero) 46590, 6601, 46590
        !           326: 46590 if (ivcomp - 729) 26590,16590,26590
        !           327: 16590 ivpass = ivpass + 1
        !           328:       write (i02,80001) ivtnum
        !           329:       go to 6601
        !           330: 26590 ivfail = ivfail + 1
        !           331:       ivcorr = 729
        !           332:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           333:  6601 continue
        !           334: c
        !           335: c     tests 660 through 665 test positive and negative bases to positive
        !           336: c                           odd and even number powers checking the sign
        !           337: c                           of the results
        !           338: c
        !           339:       ivtnum = 660
        !           340: c
        !           341: c      ****  test 660  ****
        !           342: c
        !           343:       if (iczero) 36600, 6600, 36600
        !           344:  6600 continue
        !           345:       ivon01 = 2
        !           346:       ivcomp = 1 ** ivon01
        !           347:       go to 46600
        !           348: 36600 ivdele = ivdele + 1
        !           349:       write (i02,80003) ivtnum
        !           350:       if (iczero) 46600, 6611, 46600
        !           351: 46600 if (ivcomp - 1) 26600,16600,26600
        !           352: 16600 ivpass = ivpass + 1
        !           353:       write (i02,80001) ivtnum
        !           354:       go to 6611
        !           355: 26600 ivfail = ivfail + 1
        !           356:       ivcorr = 1
        !           357:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           358:  6611 continue
        !           359:       ivtnum = 661
        !           360: c
        !           361: c      ****  test 661  ****
        !           362: c
        !           363:       if (iczero) 36610, 6610, 36610
        !           364:  6610 continue
        !           365:       ivon01 = 2
        !           366:       ivcomp = ( -1) ** ivon01
        !           367:       go to 46610
        !           368: 36610 ivdele = ivdele + 1
        !           369:       write (i02,80003) ivtnum
        !           370:       if (iczero) 46610, 6621, 46610
        !           371: 46610 if (ivcomp - 1) 26610,16610,26610
        !           372: 16610 ivpass = ivpass + 1
        !           373:       write (i02,80001) ivtnum
        !           374:       go to 6621
        !           375: 26610 ivfail = ivfail + 1
        !           376:       ivcorr = 1
        !           377:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           378:  6621 continue
        !           379:       ivtnum = 662
        !           380: c
        !           381: c      ****  test 662  ****
        !           382: c
        !           383:       if (iczero) 36620, 6620, 36620
        !           384:  6620 continue
        !           385:       ivon01 = 3
        !           386:       ivcomp = 7 ** ivon01
        !           387:       go to 46620
        !           388: 36620 ivdele = ivdele + 1
        !           389:       write (i02,80003) ivtnum
        !           390:       if (iczero) 46620, 6631, 46620
        !           391: 46620 if (ivcomp - 343) 26620,16620,26620
        !           392: 16620 ivpass = ivpass + 1
        !           393:       write (i02,80001) ivtnum
        !           394:       go to 6631
        !           395: 26620 ivfail = ivfail + 1
        !           396:       ivcorr = 343
        !           397:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           398:  6631 continue
        !           399:       ivtnum = 663
        !           400: c
        !           401: c      ****  test 663  ****
        !           402: c
        !           403:       if (iczero) 36630, 6630, 36630
        !           404:  6630 continue
        !           405:       ivon01 = 3
        !           406:       ivcomp = (-7) **ivon01
        !           407:       go to 46630
        !           408: 36630 ivdele = ivdele + 1
        !           409:       write (i02,80003) ivtnum
        !           410:       if (iczero) 46630, 6641, 46630
        !           411: 46630 if (ivcomp + 343) 26630,16630,26630
        !           412: 16630 ivpass = ivpass + 1
        !           413:       write (i02,80001) ivtnum
        !           414:       go to 6641
        !           415: 26630 ivfail = ivfail + 1
        !           416:       ivcorr = -343
        !           417:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           418:  6641 continue
        !           419:       ivtnum = 664
        !           420: c
        !           421: c      ****  test 664  ****
        !           422: c
        !           423:       if (iczero) 36640, 6640, 36640
        !           424:  6640 continue
        !           425:       ivon01 = 4
        !           426:       ivcomp = 7 ** ivon01
        !           427:       go to 46640
        !           428: 36640 ivdele = ivdele + 1
        !           429:       write (i02,80003) ivtnum
        !           430:       if (iczero) 46640, 6651, 46640
        !           431: 46640 if (ivcomp - 2401) 26640,16640,26640
        !           432: 16640 ivpass = ivpass + 1
        !           433:       write (i02,80001) ivtnum
        !           434:       go to 6651
        !           435: 26640 ivfail = ivfail + 1
        !           436:       ivcorr = 2401
        !           437:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           438:  6651 continue
        !           439:       ivtnum = 665
        !           440: c
        !           441: c      ****  test 665  ****
        !           442: c
        !           443:       if (iczero) 36650, 6650, 36650
        !           444:  6650 continue
        !           445:       ivon01 = 4
        !           446:       ivcomp = (-7) ** ivon01
        !           447:       go to 46650
        !           448: 36650 ivdele = ivdele + 1
        !           449:       write (i02,80003) ivtnum
        !           450:       if (iczero) 46650, 6661, 46650
        !           451: 46650 if (ivcomp - 2401) 26650,16650,26650
        !           452: 16650 ivpass = ivpass + 1
        !           453:       write (i02,80001) ivtnum
        !           454:       go to 6661
        !           455: 26650 ivfail = ivfail + 1
        !           456:       ivcorr = 2401
        !           457:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           458:  6661 continue
        !           459:       ivtnum = 666
        !           460: c
        !           461: c      ****  test 666  ****
        !           462: c     test 666  - small number base; zero exponent
        !           463: c
        !           464:       if (iczero) 36660, 6660, 36660
        !           465:  6660 continue
        !           466:       ivon01 = 1
        !           467:       ivon02 = 0
        !           468:       ivcomp = ivon01 ** ivon02
        !           469:       go to 46660
        !           470: 36660 ivdele = ivdele + 1
        !           471:       write (i02,80003) ivtnum
        !           472:       if (iczero) 46660, 6671, 46660
        !           473: 46660 if (ivcomp - 1) 26660,16660,26660
        !           474: 16660 ivpass = ivpass + 1
        !           475:       write (i02,80001) ivtnum
        !           476:       go to 6671
        !           477: 26660 ivfail = ivfail + 1
        !           478:       ivcorr = 1
        !           479:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           480:  6671 continue
        !           481:       ivtnum = 667
        !           482: c
        !           483: c      ****  test 667  ****
        !           484: c     test 667  - zero base to first power
        !           485: c
        !           486:       if (iczero) 36670, 6670, 36670
        !           487:  6670 continue
        !           488:       ivon01 = 0
        !           489:       ivon02 = 1
        !           490:       ivcomp = ivon01 ** ivon02
        !           491:       go to 46670
        !           492: 36670 ivdele = ivdele + 1
        !           493:       write (i02,80003) ivtnum
        !           494:       if (iczero) 46670, 6681, 46670
        !           495: 46670 if (ivcomp) 26670,16670,26670
        !           496: 16670 ivpass = ivpass + 1
        !           497:       write (i02,80001) ivtnum
        !           498:       go to 6681
        !           499: 26670 ivfail = ivfail + 1
        !           500:       ivcorr = 0
        !           501:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           502:  6681 continue
        !           503:       ivtnum = 668
        !           504: c
        !           505: c      ****  test 668  ****
        !           506: c     test 668  - base =1; exponent = 1
        !           507: c
        !           508:       if (iczero) 36680, 6680, 36680
        !           509:  6680 continue
        !           510:       ivon01 = 1
        !           511:       ivon02 = 1
        !           512:       ivcomp = ivon01 ** ivon02
        !           513:       go to 46680
        !           514: 36680 ivdele = ivdele + 1
        !           515:       write (i02,80003) ivtnum
        !           516:       if (iczero) 46680, 6691, 46680
        !           517: 46680 if (ivcomp - 1) 26680,16680,26680
        !           518: 16680 ivpass = ivpass + 1
        !           519:       write (i02,80001) ivtnum
        !           520:       go to 6691
        !           521: 26680 ivfail = ivfail + 1
        !           522:       ivcorr = 1
        !           523:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           524:  6691 continue
        !           525:       ivtnum = 669
        !           526: c
        !           527: c      ****  test 669  ****
        !           528: c     test 669  - large exponent
        !           529: c
        !           530:       if (iczero) 36690, 6690, 36690
        !           531:  6690 continue
        !           532:       ivon01 = 1
        !           533:       ivon02 = 32767
        !           534:       ivcomp = ivon01 ** ivon02
        !           535:       go to 46690
        !           536: 36690 ivdele = ivdele + 1
        !           537:       write (i02,80003) ivtnum
        !           538:       if (iczero) 46690, 6701, 46690
        !           539: 46690 if (ivcomp - 1) 26690,16690,26690
        !           540: 16690 ivpass = ivpass + 1
        !           541:       write (i02,80001) ivtnum
        !           542:       go to 6701
        !           543: 26690 ivfail = ivfail + 1
        !           544:       ivcorr = 1
        !           545:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           546:  6701 continue
        !           547:       ivtnum = 670
        !           548: c
        !           549: c      ****  test 670  ****
        !           550: c     test 670  - large number base; exponent = 1
        !           551: c
        !           552:       if (iczero) 36700, 6700, 36700
        !           553:  6700 continue
        !           554:       ivon01 = 32767
        !           555:       ivon02 = 1
        !           556:       ivcomp = ivon01 ** ivon02
        !           557:       go to 46700
        !           558: 36700 ivdele = ivdele + 1
        !           559:       write (i02,80003) ivtnum
        !           560:       if (iczero) 46700, 6711, 46700
        !           561: 46700 if (ivcomp - 32767) 26700,16700,26700
        !           562: 16700 ivpass = ivpass + 1
        !           563:       write (i02,80001) ivtnum
        !           564:       go to 6711
        !           565: 26700 ivfail = ivfail + 1
        !           566:       ivcorr = 32767
        !           567:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           568:  6711 continue
        !           569:       ivtnum = 671
        !           570: c
        !           571: c      ****  test 671  ****
        !           572: c     test 671  - zero base; large number exponent
        !           573: c
        !           574:       if (iczero) 36710, 6710, 36710
        !           575:  6710 continue
        !           576:       ivon01 = 0
        !           577:       ivon02 = 32767
        !           578:       ivcomp = ivon01 ** ivon02
        !           579:       go to 46710
        !           580: 36710 ivdele = ivdele + 1
        !           581:       write (i02,80003) ivtnum
        !           582:       if (iczero) 46710, 6721, 46710
        !           583: 46710 if (ivcomp) 26710,16710,26710
        !           584: 16710 ivpass = ivpass + 1
        !           585:       write (i02,80001) ivtnum
        !           586:       go to 6721
        !           587: 26710 ivfail = ivfail + 1
        !           588:       ivcorr = 0
        !           589:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           590:  6721 continue
        !           591:       ivtnum = 672
        !           592: c
        !           593: c      ****  test 672  ****
        !           594: c     test 672  -large number base; zero exponent
        !           595: c
        !           596:       if (iczero) 36720, 6720, 36720
        !           597:  6720 continue
        !           598:       ivon01 = 32767
        !           599:       ivon02 = 0
        !           600:       ivcomp = ivon01 ** ivon02
        !           601:       go to 46720
        !           602: 36720 ivdele = ivdele + 1
        !           603:       write (i02,80003) ivtnum
        !           604:       if (iczero) 46720, 6731, 46720
        !           605: 46720 if (ivcomp -1) 26720,16720,26720
        !           606: 16720 ivpass = ivpass + 1
        !           607:       write (i02,80001) ivtnum
        !           608:       go to 6731
        !           609: 26720 ivfail = ivfail + 1
        !           610:       ivcorr = 1
        !           611:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           612:  6731 continue
        !           613:       ivtnum = 673
        !           614: c
        !           615: c      ****  test 673  ****
        !           616: c     test 673  -exponent is power of two
        !           617: c
        !           618:       if (iczero) 36730, 6730, 36730
        !           619:  6730 continue
        !           620:       ivon01 = 181
        !           621:       ivon02 = 2
        !           622:       ivcomp = ivon01 ** ivon02
        !           623:       go to 46730
        !           624: 36730 ivdele = ivdele + 1
        !           625:       write (i02,80003) ivtnum
        !           626:       if (iczero) 46730, 6741, 46730
        !           627: 46730 if (ivcomp - 32761) 26730,16730,26730
        !           628: 16730 ivpass = ivpass + 1
        !           629:       write (i02,80001) ivtnum
        !           630:       go to 6741
        !           631: 26730 ivfail = ivfail + 1
        !           632:       ivcorr = 32761
        !           633:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           634:  6741 continue
        !           635:       ivtnum = 674
        !           636: c
        !           637: c      ****  test 674  ****
        !           638: c     test 674  - base and exponent are both powers of two
        !           639: c
        !           640:       if (iczero) 36740, 6740, 36740
        !           641:  6740 continue
        !           642:       ivon01 = 2
        !           643:       ivon02 = 8
        !           644:       ivcomp = ivon01 ** ivon02
        !           645:       go to 46740
        !           646: 36740 ivdele = ivdele + 1
        !           647:       write (i02,80003) ivtnum
        !           648:       if (iczero) 46740, 6751, 46740
        !           649: 46740 if (ivcomp - 256) 26740,16740,26740
        !           650: 16740 ivpass = ivpass + 1
        !           651:       write (i02,80001) ivtnum
        !           652:       go to 6751
        !           653: 26740 ivfail = ivfail + 1
        !           654:       ivcorr = 256
        !           655:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           656:  6751 continue
        !           657: c
        !           658: c     tests 675 and 676 test to ensure exponentiation operator is
        !           659: c                       not commutative
        !           660: c
        !           661:       ivtnum = 675
        !           662: c
        !           663: c      ****  test 675  ****
        !           664: c
        !           665:       if (iczero) 36750, 6750, 36750
        !           666:  6750 continue
        !           667:       ivon01 = 3
        !           668:       ivon02 = 9
        !           669:       ivcomp = ivon01 ** ivon02
        !           670:       go to 46750
        !           671: 36750 ivdele = ivdele + 1
        !           672:       write (i02,80003) ivtnum
        !           673:       if (iczero) 46750, 6761, 46750
        !           674: 46750 if (ivcomp - 19683) 26750,16750,26750
        !           675: 16750 ivpass = ivpass + 1
        !           676:       write (i02,80001) ivtnum
        !           677:       go to 6761
        !           678: 26750 ivfail = ivfail + 1
        !           679:       ivcorr = 19683
        !           680:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           681:  6761 continue
        !           682:       ivtnum = 676
        !           683: c
        !           684: c      ****  test 676  ****
        !           685: c
        !           686:       if (iczero) 36760, 6760, 36760
        !           687:  6760 continue
        !           688:       ivon01 = 9
        !           689:       ivon02 = 3
        !           690:       ivcomp = ivon01 ** ivon02
        !           691:       go to 46760
        !           692: 36760 ivdele = ivdele + 1
        !           693:       write (i02,80003) ivtnum
        !           694:       if (iczero) 46760, 6771, 46760
        !           695: 46760 if (ivcomp - 729) 26760,16760,26760
        !           696: 16760 ivpass = ivpass + 1
        !           697:       write (i02,80001) ivtnum
        !           698:       go to 6771
        !           699: 26760 ivfail = ivfail + 1
        !           700:       ivcorr = 729
        !           701:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           702:  6771 continue
        !           703: c
        !           704: c     tests 677 through 682 test positive and negative bases to positive
        !           705: c                           odd and even number powers checking the sign
        !           706: c                           of the results
        !           707: c
        !           708:       ivtnum = 677
        !           709: c
        !           710: c      ****  test 677  ****
        !           711: c
        !           712:       if (iczero) 36770, 6770, 36770
        !           713:  6770 continue
        !           714:       ivon01 = 1
        !           715:       ivon02 = 2
        !           716:       ivcomp = ivon01 ** ivon02
        !           717:       go to 46770
        !           718: 36770 ivdele = ivdele + 1
        !           719:       write (i02,80003) ivtnum
        !           720:       if (iczero) 46770, 6781, 46770
        !           721: 46770 if (ivcomp - 1) 26770,16770,26770
        !           722: 16770 ivpass = ivpass + 1
        !           723:       write (i02,80001) ivtnum
        !           724:       go to 6781
        !           725: 26770 ivfail = ivfail + 1
        !           726:       ivcorr = 1
        !           727:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           728:  6781 continue
        !           729:       ivtnum = 678
        !           730: c
        !           731: c      ****  test 678  ****
        !           732: c
        !           733:       if (iczero) 36780, 6780, 36780
        !           734:  6780 continue
        !           735:       ivon01 = -1
        !           736:       ivon02 = 2
        !           737:       ivcomp = ivon01 ** ivon02
        !           738:       go to 46780
        !           739: 36780 ivdele = ivdele + 1
        !           740:       write (i02,80003) ivtnum
        !           741:       if (iczero) 46780, 6791, 46780
        !           742: 46780 if (ivcomp - 1) 26780,16780,26780
        !           743: 16780 ivpass = ivpass + 1
        !           744:       write (i02,80001) ivtnum
        !           745:       go to 6791
        !           746: 26780 ivfail = ivfail + 1
        !           747:       ivcorr = 1
        !           748:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           749:  6791 continue
        !           750:       ivtnum = 679
        !           751: c
        !           752: c      ****  test 679  ****
        !           753: c
        !           754:       if (iczero) 36790, 6790, 36790
        !           755:  6790 continue
        !           756:       ivon01 = 7
        !           757:       ivon02 = 3
        !           758:       ivcomp = ivon01 ** ivon02
        !           759:       go to 46790
        !           760: 36790 ivdele = ivdele + 1
        !           761:       write (i02,80003) ivtnum
        !           762:       if (iczero) 46790, 6801, 46790
        !           763: 46790 if (ivcomp - 343) 26790,16790,26790
        !           764: 16790 ivpass = ivpass + 1
        !           765:       write (i02,80001) ivtnum
        !           766:       go to 6801
        !           767: 26790 ivfail = ivfail + 1
        !           768:       ivcorr = 343
        !           769:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           770:  6801 continue
        !           771:       ivtnum = 680
        !           772: c
        !           773: c      ****  test 680  ****
        !           774: c
        !           775:       if (iczero) 36800, 6800, 36800
        !           776:  6800 continue
        !           777:       ivon01 = -7
        !           778:       ivon02 = 3
        !           779:       ivcomp = ivon01 ** ivon02
        !           780:       go to 46800
        !           781: 36800 ivdele = ivdele + 1
        !           782:       write (i02,80003) ivtnum
        !           783:       if (iczero) 46800, 6811, 46800
        !           784: 46800 if (ivcomp + 343) 26800,16800,26800
        !           785: 16800 ivpass = ivpass + 1
        !           786:       write (i02,80001) ivtnum
        !           787:       go to 6811
        !           788: 26800 ivfail = ivfail + 1
        !           789:       ivcorr = -343
        !           790:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           791:  6811 continue
        !           792:       ivtnum = 681
        !           793: c
        !           794: c      ****  test 681  ****
        !           795: c
        !           796:       if (iczero) 36810, 6810, 36810
        !           797:  6810 continue
        !           798:       ivon01 = 7
        !           799:       ivon02 = 4
        !           800:       ivcomp = ivon01 ** ivon02
        !           801:       go to 46810
        !           802: 36810 ivdele = ivdele + 1
        !           803:       write (i02,80003) ivtnum
        !           804:       if (iczero) 46810, 6821, 46810
        !           805: 46810 if (ivcomp - 2401) 26810,16810,26810
        !           806: 16810 ivpass = ivpass + 1
        !           807:       write (i02,80001) ivtnum
        !           808:       go to 6821
        !           809: 26810 ivfail = ivfail + 1
        !           810:       ivcorr = 2401
        !           811:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           812:  6821 continue
        !           813:       ivtnum = 682
        !           814: c
        !           815: c      ****  test 682  ****
        !           816: c
        !           817:       if (iczero) 36820, 6820, 36820
        !           818:  6820 continue
        !           819:       ivon01 = -7
        !           820:       ivon02 = 4
        !           821:       ivcomp = ivon01 ** ivon02
        !           822:       go to 46820
        !           823: 36820 ivdele = ivdele + 1
        !           824:       write (i02,80003) ivtnum
        !           825:       if (iczero) 46820, 6831, 46820
        !           826: 46820 if (ivcomp - 2401) 26820,16820,26820
        !           827: 16820 ivpass = ivpass + 1
        !           828:       write (i02,80001) ivtnum
        !           829:       go to 6831
        !           830: 26820 ivfail = ivfail + 1
        !           831:       ivcorr = 2401
        !           832:       write (i02,80004) ivtnum, ivcomp, ivcorr
        !           833:  6831 continue
        !           834: c
        !           835: c     write page footings and run summaries
        !           836: 99999 continue
        !           837:       write (i02,90002)
        !           838:       write (i02,90006)
        !           839:       write (i02,90002)
        !           840:       write (i02,90002)
        !           841:       write (i02,90007)
        !           842:       write (i02,90002)
        !           843:       write (i02,90008)  ivfail
        !           844:       write (i02,90009) ivpass
        !           845:       write (i02,90010) ivdele
        !           846: c
        !           847: c
        !           848: c     terminate routine execution
        !           849:       stop
        !           850: c
        !           851: c     format statements for page headers
        !           852: 90000 format (1h1)
        !           853: 90002 format (1h )
        !           854: 90001 format (1h ,10x,34hfortran compiler validation system)
        !           855: 90003 format (1h ,21x,11hversion 1.0)
        !           856: 90004 format (1h ,10x,38hfor official use only - copyright 1978)
        !           857: 90005 format (1h ,5x,4htest,5x,9hpass/fail, 5x,8hcomputed,8x,7hcorrect)
        !           858: 90006 format (1h ,5x,46h----------------------------------------------)
        !           859: 90011 format (1h ,18x,17hsubset level test)
        !           860: c
        !           861: c     format statements for run summaries
        !           862: 90008 format (1h ,15x,i5,19h errors encountered)
        !           863: 90009 format (1h ,15x,i5,13h tests passed)
        !           864: 90010 format (1h ,15x,i5,14h tests deleted)
        !           865: c
        !           866: c     format statements for test results
        !           867: 80001 format (1h ,4x,i5,7x,4hpass)
        !           868: 80002 format (1h ,4x,i5,7x,4hfail)
        !           869: 80003 format (1h ,4x,i5,7x,7hdeleted)
        !           870: 80004 format (1h ,4x,i5,7x,4hfail,10x,i6,9x,i6)
        !           871: 80005 format (1h ,4x,i5,7x,4hfail,4x,e12.5,3x,e12.5)
        !           872: c
        !           873: 90007 format (1h ,20x,20hend of program fm042)
        !           874:       end

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