Return to setups.f CVS log

Up to [CSRG BSD Unix] / 3BSD / cmd / spice

Annotation of 3BSD/cmd/spice/setups.f, revision 1.1

1.1     ! root        1:       subroutine setup
        !             2:       implicit double precision (a-h,o-z)
        !             3: c
        !             4: c
        !             5: c     this routine drives the sparse matrix setup used by spice.
        !             6: c
        !             7:       common /tabinf/ ielmnt,isbckt,nsbckt,iunsat,nunsat,itemps,numtem,
        !             8:      1   isens,nsens,ifour,nfour,ifield,icode,idelim,icolum,insize,
        !             9:      2   junode,lsbkpt,numbkp,iorder,jmnode,iur,iuc,ilc,ilr,numoff,isr,
        !            10:      3   nmoffc,iseq,iseq1,neqn,nodevs,ndiag,iswap,iequa,macins,lvnim1,
        !            11:      4   lx0,lvn,lynl,lyu,lyl,lx1,lx2,lx3,lx4,lx5,lx6,lx7,ld0,ld1,ltd,
        !            12:      5   imynl,imvn,lcvn,loutpt,nsnod,nsmat,nsval,icnod,icmat,icval
        !            13:       common /cirdat/ locate(50),jelcnt(50),nunods,ncnods,numnod,nstop,
        !            14:      1   nut,nlt,nxtrm,ndist,ntlin,ibr,numvs
        !            15:       common /miscel/ atime,aprog(3),adate,atitle(10),defl,defw,defad,
        !            16:      1  defas,rstats(50),iwidth,lwidth,nopage
        !            17:       common /flags/ iprnta,iprntl,iprntm,iprntn,iprnto,limtim,limpts,
        !            18:      1   lvlcod,lvltim,itl1,itl2,itl3,itl4,itl5,igoof,nogo,keof
        !            19:       common /dc/ tcstar(2),tcstop(2),tcincr(2),icvflg,itcelm(2),kssop,
        !            20:      1   kinel,kidin,kovar,kidout
        !            21:       common /ac/ fstart,fstop,fincr,skw2,refprl,spw2,jacflg,idfreq,
        !            22:      1   inoise,nosprt,nosout,nosin,idist,idprt
        !            23:       common /blank/ value(1000)
        !            24:       integer nodplc(64)
        !            25:       complex*16 cvalue(32)
        !            26:       equivalence (value(1),nodplc(1),cvalue(1))
        !            27: c
        !            28: c
        !            29:       call second(t1)
        !            30:       nstop=numnod+jelcnt(3)+jelcnt(6)+jelcnt(8)+jelcnt(9)+2*jelcnt(17)
        !            31: c
        !            32: c  reserve matrix locations for each element
        !            33: c
        !            34:       call matptr
        !            35:       if (nogo.ne.0) go to 1000
        !            36: c
        !            37: c  reorder matrix pointers for minimal fill-in
        !            38: c
        !            39:       nttbr=0
        !            40:       do 120 i=2,nstop
        !            41:       loc=isr+i
        !            42:   110 if (nodplc(loc).eq.0) go to 120
        !            43:       loc=nodplc(loc)
        !            44:       nttbr=nttbr+1
        !            45:       go to 110
        !            46:   120 continue
        !            47: c...  add ground
        !            48:       nttbr=nttbr+1
        !            49:       call reordr
        !            50:       if (nogo.ne.0) go to 1000
        !            51:       nttar=nodplc(iur+nstop+1)-1+nodplc(ilc+nstop+1)-1+nstop
        !            52:       ifill=nttar-nttbr
        !            53:       perspa=100.0d0*(1.0d0-dfloat(nttar)/
        !            54:      1  (dfloat(nstop)*dfloat(nstop)))
        !            55:       iops=0
        !            56:       do 130 i=2,nstop
        !            57:       noffr=nodplc(iur+i+1)-nodplc(iur+i)
        !            58:       noffc=nodplc(ilc+i+1)-nodplc(ilc+i)
        !            59:       iops=iops+noffr+noffc*(noffr+2)+1
        !            60:   130 continue
        !            61:       rstats(20)=nstop
        !            62:       rstats(21)=nttbr
        !            63:       rstats(22)=nttar
        !            64:       rstats(23)=ifill
        !            65:       rstats(24)=0.0d0
        !            66:       rstats(25)=nttar
        !            67:       rstats(26)=iops
        !            68:       rstats(27)=perspa
        !            69: c
        !            70: c  store matrix locations
        !            71: c
        !            72:       call matloc
        !            73:       call clrmem(isr)
        !            74:       call clrmem(iseq)
        !            75:       call clrmem(iseq1)
        !            76:       call clrmem(neqn)
        !            77:       call clrmem(nodevs)
        !            78:       call clrmem(ndiag)
        !            79:       call clrmem(nmoffc)
        !            80:       call clrmem(numoff)
        !            81:       call clrmem(iequa)
        !            82:       call clrmem(jmnode)
        !            83: c
        !            84: c  generate machine code
        !            85: c
        !            86:  1000 call second(t2)
        !            87:       rstats(2)=rstats(2)+t2-t1
        !            88:       return
        !            89:       end
        !            90:       subroutine matptr
        !            91:       implicit double precision (a-h,o-z)
        !            92: c
        !            93: c     this routine (by calls to the routine reserve) establishes the
        !            94: c nonzero-element structure of the circuit equation coefficient matrix.
        !            95: c
        !            96:       common /tabinf/ ielmnt,isbckt,nsbckt,iunsat,nunsat,itemps,numtem,
        !            97:      1   isens,nsens,ifour,nfour,ifield,icode,idelim,icolum,insize,
        !            98:      2   junode,lsbkpt,numbkp,iorder,jmnode,iur,iuc,ilc,ilr,numoff,isr,
        !            99:      3   nmoffc,iseq,iseq1,neqn,nodevs,ndiag,iswap,iequa,macins,lvnim1,
        !           100:      4   lx0,lvn,lynl,lyu,lyl,lx1,lx2,lx3,lx4,lx5,lx6,lx7,ld0,ld1,ltd,
        !           101:      5   imynl,imvn,lcvn,loutpt,nsnod,nsmat,nsval,icnod,icmat,icval
        !           102:       common /cirdat/ locate(50),jelcnt(50),nunods,ncnods,numnod,nstop,
        !           103:      1   nut,nlt,nxtrm,ndist,ntlin,ibr,numvs
        !           104:       common /blank/ value(1000)
        !           105:       integer nodplc(64)
        !           106:       complex*16 cvalue(32)
        !           107:       equivalence (value(1),nodplc(1),cvalue(1))
        !           108: c
        !           109: c  allocate and initialize storage
        !           110: c
        !           111:       call getm4(isr,nstop+1)
        !           112:       numvs=jelcnt(3)+jelcnt(6)+jelcnt(8)+jelcnt(9)+2*jelcnt(17)
        !           113:       call getm4(iseq,numvs)
        !           114:       call getm4(iseq1,numvs)
        !           115:       call getm4(neqn,numvs)
        !           116:       call getm4(nodevs,numnod)
        !           117:       call getm4(ndiag,nstop)
        !           118:       call getm4(nmoffc,nstop)
        !           119:       call getm4(numoff,nstop)
        !           120:       call crunch
        !           121: c
        !           122:       call zero4(nodplc(isr+1),nstop+1)
        !           123:       call zero4(nodplc(iseq1+1),numvs)
        !           124:       call zero4(nodplc(nodevs+1),numnod)
        !           125:       call zero4(nodplc(ndiag+1),nstop)
        !           126:       call zero4(nodplc(nmoffc+1),nstop)
        !           127:       call zero4(nodplc(numoff+1),nstop)
        !           128: c
        !           129:       numvs=0
        !           130:       nxtrm=0
        !           131:       ndist=0
        !           132:       ntlin=1
        !           133:       ibr=numnod
        !           134: c
        !           135: c  resistors
        !           136: c
        !           137:       loc=locate(1)
        !           138:   110 if (loc.eq.0) go to 120
        !           139:       node1=nodplc(loc+2)
        !           140:       node2=nodplc(loc+3)
        !           141:       call reserv(node1,node1)
        !           142:       call reserv(node1,node2)
        !           143:       call reserv(node2,node1)
        !           144:       call reserv(node2,node2)
        !           145:       loc=nodplc(loc)
        !           146:       go to 110
        !           147: c
        !           148: c  capacitors
        !           149: c
        !           150:   120 loc=locate(2)
        !           151:   130 if (loc.eq.0) go to 400
        !           152:       node1=nodplc(loc+2)
        !           153:       node2=nodplc(loc+3)
        !           154:       call reserv(node1,node2)
        !           155:       call reserv(node2,node1)
        !           156:       ntemp=nodplc(ndiag+node1)
        !           157:       call reserv(node1,node1)
        !           158:       nodplc(ndiag+node1)=ntemp
        !           159:       ntemp=nodplc(ndiag+node2)
        !           160:       call reserv(node2,node2)
        !           161:       nodplc(ndiag+node2)=ntemp
        !           162:       nodplc(loc+8)=nxtrm+1
        !           163:       nxtrm=nxtrm+2
        !           164:       loc=nodplc(loc)
        !           165:       go to 130
        !           166: c
        !           167: c  inductors
        !           168: c
        !           169:   400 loc=locate(3)
        !           170:   430 if (loc.eq.0) go to 440
        !           171:       node1=nodplc(loc+2)
        !           172:       node2=nodplc(loc+3)
        !           173:       ibr=ibr+1
        !           174:       nodplc(loc+5)=ibr
        !           175:       call reserv(node1,ibr)
        !           176:       call reserv(node2,ibr)
        !           177:       call reserv(ibr,node1)
        !           178:       call reserv(ibr,node2)
        !           179:       ntemp=nodplc(ndiag+ibr)
        !           180:       call reserv(ibr,ibr)
        !           181:       nodplc(ndiag+ibr)=ntemp
        !           182:       numvs=numvs+1
        !           183:       nodplc(iseq+numvs)=loc
        !           184:       nodplc(neqn+numvs)=ibr
        !           185:       nodplc(nodevs+node1)=nodplc(nodevs+node1)+1
        !           186:       nodplc(nodevs+node2)=nodplc(nodevs+node2)+1
        !           187:       nodplc(loc+11)=nxtrm+1
        !           188:       nxtrm=nxtrm+2
        !           189:       loc=nodplc(loc)
        !           190:       go to 430
        !           191: c
        !           192: c  mutual inductors
        !           193: c
        !           194:   440 loc=locate(4)
        !           195:   450 if (loc.eq.0) go to 460
        !           196:       nl1=nodplc(loc+2)
        !           197:       nl2=nodplc(loc+3)
        !           198:       nl1=nodplc(nl1+5)
        !           199:       nl2=nodplc(nl2+5)
        !           200:       call reserv(nl1,nl2)
        !           201:       call reserv(nl2,nl1)
        !           202:       loc=nodplc(loc)
        !           203:       go to 450
        !           204: c
        !           205: c  nonlinear voltage-controlled current sources
        !           206: c
        !           207:   460 loc=locate(5)
        !           208:   462 if (loc.eq.0) go to 464
        !           209:       node1=nodplc(loc+2)
        !           210:       node2=nodplc(loc+3)
        !           211:       ndim=nodplc(loc+4)
        !           212:       ndim2=ndim+ndim
        !           213:       locn=nodplc(loc+6)
        !           214:       do 463 i=1,ndim2
        !           215:       node=nodplc(locn+i)
        !           216:       call reserv(node1,node)
        !           217:       call reserv(node2,node)
        !           218:   463 continue
        !           219:       nodplc(loc+12)=nxtrm+1
        !           220:       nxtrm=nxtrm+1+ndim2
        !           221:       loc=nodplc(loc)
        !           222:       go to 462
        !           223: c
        !           224: c  nonlinear voltage controlled voltage sources
        !           225: c
        !           226:   464 loc=locate(6)
        !           227:   466 if (loc.eq.0) go to 468
        !           228:       node1=nodplc(loc+2)
        !           229:       node2=nodplc(loc+3)
        !           230:       ibr=ibr+1
        !           231:       nodplc(loc+6)=ibr
        !           232:       call reserv(node1,ibr)
        !           233:       call reserv(node2,ibr)
        !           234:       call reserv(ibr,node1)
        !           235:       call reserv(ibr,node2)
        !           236:       numvs=numvs+1
        !           237:       nodplc(iseq+numvs)=loc
        !           238:       nodplc(neqn+numvs)=ibr
        !           239:       nodplc(nodevs+node1)=nodplc(nodevs+node1)+1
        !           240:       nodplc(nodevs+node2)=nodplc(nodevs+node2)+1
        !           241:       ndim=nodplc(loc+4)
        !           242:       ndim2=ndim+ndim
        !           243:       locn=nodplc(loc+7)
        !           244:       do 467 i=1,ndim2
        !           245:       node=nodplc(locn+i)
        !           246:       call reserv(ibr,node)
        !           247:   467 continue
        !           248:       nodplc(loc+13)=nxtrm+1
        !           249:       nxtrm=nxtrm+2+ndim2
        !           250:       loc=nodplc(loc)
        !           251:       go to 466
        !           252: c
        !           253: c  voltage sources
        !           254: c
        !           255:   468 loc=locate(9)
        !           256:   470 if (loc.eq.0) go to 472
        !           257:       node1=nodplc(loc+2)
        !           258:       node2=nodplc(loc+3)
        !           259:       ibr=ibr+1
        !           260:       nodplc(loc+6)=ibr
        !           261:       call reserv(node1,ibr)
        !           262:       call reserv(node2,ibr)
        !           263:       call reserv(ibr,node1)
        !           264:       call reserv(ibr,node2)
        !           265:       numvs=numvs+1
        !           266:       nodplc(iseq+numvs)=loc
        !           267:       nodplc(neqn+numvs)=ibr
        !           268:       nodplc(nodevs+node1)=nodplc(nodevs+node1)+1
        !           269:       nodplc(nodevs+node2)=nodplc(nodevs+node2)+1
        !           270:       loc=nodplc(loc)
        !           271:       go to 470
        !           272: c
        !           273: c  nonlinear current controlled current sources
        !           274: c
        !           275:   472 loc=locate(7)
        !           276:   474 if (loc.eq.0) go to 476
        !           277:       node1=nodplc(loc+2)
        !           278:       node2=nodplc(loc+3)
        !           279:       ndim=nodplc(loc+4)
        !           280:       locvs=nodplc(loc+6)
        !           281:       do 475 i=1,ndim
        !           282:       locvst=nodplc(locvs+i)
        !           283:       kbr=nodplc(locvst+6)
        !           284:       call reserv(node1,kbr)
        !           285:       call reserv(node2,kbr)
        !           286:   475 continue
        !           287:       nodplc(loc+12)=nxtrm+1
        !           288:       nxtrm=nxtrm+1+ndim+ndim
        !           289:       loc=nodplc(loc)
        !           290:       go to 474
        !           291: c
        !           292: c  nonlinear current controlled voltage sources
        !           293: c
        !           294:   476 loc=locate(8)
        !           295:   478 if (loc.eq.0) go to 500
        !           296:       node1=nodplc(loc+2)
        !           297:       node2=nodplc(loc+3)
        !           298:       ibr=ibr+1
        !           299:       nodplc(loc+6)=ibr
        !           300:       call reserv(node1,ibr)
        !           301:       call reserv(node2,ibr)
        !           302:       call reserv(ibr,node1)
        !           303:       call reserv(ibr,node2)
        !           304:       numvs=numvs+1
        !           305:       nodplc(iseq+numvs)=loc
        !           306:       nodplc(neqn+numvs)=ibr
        !           307:       nodplc(nodevs+node1)=nodplc(nodevs+node1)+1
        !           308:       nodplc(nodevs+node2)=nodplc(nodevs+node2)+1
        !           309:       ndim=nodplc(loc+4)
        !           310:       locvs=nodplc(loc+7)
        !           311:       do 479 i=1,ndim
        !           312:       locvst=nodplc(locvs+i)
        !           313:       kbr=nodplc(locvst+6)
        !           314:       call reserv(ibr,kbr)
        !           315:   479 continue
        !           316:       nodplc(loc+13)=nxtrm+1
        !           317:       nxtrm=nxtrm+2+ndim+ndim
        !           318:       loc=nodplc(loc)
        !           319:       go to 478
        !           320: c
        !           321: c  diodes
        !           322: c
        !           323:   500 loc=locate(11)
        !           324:   510 if (loc.eq.0) go to 520
        !           325:       node1=nodplc(loc+2)
        !           326:       node2=nodplc(loc+3)
        !           327:       node3=nodplc(loc+4)
        !           328:       call reserv(node1,node1)
        !           329:       call reserv(node2,node2)
        !           330:       call reserv(node3,node3)
        !           331:       call reserv(node1,node3)
        !           332:       call reserv(node2,node3)
        !           333:       call reserv(node3,node1)
        !           334:       call reserv(node3,node2)
        !           335:       nodplc(loc+11)=nxtrm+1
        !           336:       nxtrm=nxtrm+5
        !           337:       nodplc(loc+12)=ndist+1
        !           338:       ndist=ndist+7
        !           339:       loc=nodplc(loc)
        !           340:       go to 510
        !           341: c
        !           342: c  transistors
        !           343: c
        !           344:   520 loc=locate(12)
        !           345:   530 if (loc.eq.0) go to 540
        !           346:       node1=nodplc(loc+2)
        !           347:       node2=nodplc(loc+3)
        !           348:       node3=nodplc(loc+4)
        !           349:       node4=nodplc(loc+5)
        !           350:       node5=nodplc(loc+6)
        !           351:       node6=nodplc(loc+7)
        !           352:       node7=nodplc(loc+30)
        !           353:       call reserv(node1,node1)
        !           354:       call reserv(node2,node2)
        !           355:       call reserv(node3,node3)
        !           356:       call reserv(node4,node4)
        !           357:       call reserv(node5,node5)
        !           358:       call reserv(node6,node6)
        !           359:       call reserv(node1,node4)
        !           360:       call reserv(node2,node5)
        !           361:       call reserv(node3,node6)
        !           362:       call reserv(node4,node5)
        !           363:       call reserv(node4,node6)
        !           364:       call reserv(node5,node6)
        !           365:       call reserv(node4,node1)
        !           366:       call reserv(node5,node2)
        !           367:       call reserv(node6,node3)
        !           368:       call reserv(node5,node4)
        !           369:       call reserv(node6,node4)
        !           370:       call reserv(node6,node5)
        !           371:       call reserv(node7,node7)
        !           372:       call reserv(node4,node7)
        !           373:       call reserv(node7,node4)
        !           374:       call reserv(node2,node4)
        !           375:       call reserv(node4,node2)
        !           376:       nodplc(loc+22)=nxtrm+1
        !           377:       nxtrm=nxtrm+18
        !           378:       nodplc(loc+23)=ndist+1
        !           379:       ndist=ndist+21
        !           380:       loc=nodplc(loc)
        !           381:       go to 530
        !           382: c
        !           383: c  jfets
        !           384: c
        !           385:   540 loc=locate(13)
        !           386:   550 if (loc.eq.0) go to 560
        !           387:       node1=nodplc(loc+2)
        !           388:       node2=nodplc(loc+3)
        !           389:       node3=nodplc(loc+4)
        !           390:       node4=nodplc(loc+5)
        !           391:       node5=nodplc(loc+6)
        !           392:       call reserv(node1,node1)
        !           393:       call reserv(node2,node2)
        !           394:       call reserv(node3,node3)
        !           395:       call reserv(node4,node4)
        !           396:       call reserv(node5,node5)
        !           397:       call reserv(node1,node4)
        !           398:       call reserv(node2,node4)
        !           399:       call reserv(node2,node5)
        !           400:       call reserv(node3,node5)
        !           401:       call reserv(node4,node5)
        !           402:       call reserv(node4,node1)
        !           403:       call reserv(node4,node2)
        !           404:       call reserv(node5,node2)
        !           405:       call reserv(node5,node3)
        !           406:       call reserv(node5,node4)
        !           407:       nodplc(loc+19)=nxtrm+1
        !           408:       nxtrm=nxtrm+13
        !           409:       loc=nodplc(loc)
        !           410:       go to 550
        !           411: c
        !           412: c  mosfets
        !           413: c
        !           414:   560 loc=locate(14)
        !           415:   570 if (loc.eq.0) go to 600
        !           416:       node1=nodplc(loc+2)
        !           417:       node2=nodplc(loc+3)
        !           418:       node3=nodplc(loc+4)
        !           419:       node4=nodplc(loc+5)
        !           420:       node5=nodplc(loc+6)
        !           421:       node6=nodplc(loc+7)
        !           422:       call reserv(node1,node1)
        !           423:       call reserv(node2,node2)
        !           424:       call reserv(node3,node3)
        !           425:       call reserv(node4,node4)
        !           426:       call reserv(node5,node5)
        !           427:       call reserv(node6,node6)
        !           428:       call reserv(node1,node5)
        !           429:       call reserv(node2,node4)
        !           430:       call reserv(node2,node5)
        !           431:       call reserv(node2,node6)
        !           432:       call reserv(node3,node6)
        !           433:       call reserv(node4,node5)
        !           434:       call reserv(node4,node6)
        !           435:       call reserv(node5,node6)
        !           436:       call reserv(node5,node1)
        !           437:       call reserv(node4,node2)
        !           438:       call reserv(node5,node2)
        !           439:       call reserv(node6,node2)
        !           440:       call reserv(node6,node3)
        !           441:       call reserv(node5,node4)
        !           442:       call reserv(node6,node4)
        !           443:       call reserv(node6,node5)
        !           444:       nodplc(loc+26)=nxtrm+1
        !           445:       nxtrm=nxtrm+18
        !           446:       loc=nodplc(loc)
        !           447:       go to 570
        !           448: c
        !           449: c  transmission lines
        !           450: c
        !           451:   600 loc=locate(17)
        !           452:   610 if (loc.eq.0) go to 1000
        !           453:       node1=nodplc(loc+2)
        !           454:       node2=nodplc(loc+3)
        !           455:       node3=nodplc(loc+4)
        !           456:       node4=nodplc(loc+5)
        !           457:       ni1=nodplc(loc+6)
        !           458:       ni2=nodplc(loc+7)
        !           459:       ibr1=ibr+1
        !           460:       ibr2=ibr+2
        !           461:       ibr=ibr+2
        !           462:       nodplc(loc+8)=ibr1
        !           463:       nodplc(loc+9)=ibr2
        !           464:       call reserv(node1,node1)
        !           465:       call reserv(node1,ni1)
        !           466:       call reserv(node2,ibr1)
        !           467:       call reserv(node3,node3)
        !           468:       call reserv(node4,ibr2)
        !           469:       call reserv(ni1,node1)
        !           470:       call reserv(ni1,ni1)
        !           471:       call reserv(ni1,ibr1)
        !           472:       call reserv(ni2,ni2)
        !           473:       call reserv(ni2,ibr2)
        !           474:       call reserv(ibr1,node2)
        !           475:       call reserv(ibr1,node3)
        !           476:       call reserv(ibr1,node4)
        !           477:       call reserv(ibr1,ni1)
        !           478:       call reserv(ibr1,ibr2)
        !           479:       call reserv(ibr2,node1)
        !           480:       call reserv(ibr2,node2)
        !           481:       call reserv(ibr2,node4)
        !           482:       call reserv(ibr2,ni2)
        !           483:       call reserv(ibr2,ibr1)
        !           484:       call reserv(node3,ni2)
        !           485:       call reserv(ni2,node3)
        !           486:       numvs=numvs+1
        !           487:       nodplc(iseq+numvs)=loc
        !           488:       nodplc(iseq1+numvs)=1
        !           489:       nodplc(neqn+numvs)=ibr1
        !           490:       nodplc(nodevs+ni1)=nodplc(nodevs+ni1)+1
        !           491:       nodplc(nodevs+node2)=nodplc(nodevs+node2)+1
        !           492:       numvs=numvs+1
        !           493:       nodplc(iseq+numvs)=loc
        !           494:       nodplc(iseq1+numvs)=2
        !           495:       nodplc(neqn+numvs)=ibr2
        !           496:       nodplc(nodevs+ni2)=nodplc(nodevs+ni2)+1
        !           497:       nodplc(nodevs+node4)=nodplc(nodevs+node4)+1
        !           498:       nodplc(loc+30)=ntlin+1
        !           499:       ntlin=ntlin+2
        !           500:       loc=nodplc(loc)
        !           501:       go to 610
        !           502: c
        !           503: c  finished
        !           504: c
        !           505:  1000 return
        !           506:       end
        !           507:       subroutine reserv (node1,node2)
        !           508:       implicit double precision (a-h,o-z)
        !           509: c
        !           510: c     this routine records the fact that the (node1, node2) element of
        !           511: c the circuit equation coefficient matrix is nonzero.
        !           512: c
        !           513:       common /tabinf/ ielmnt,isbckt,nsbckt,iunsat,nunsat,itemps,numtem,
        !           514:      1   isens,nsens,ifour,nfour,ifield,icode,idelim,icolum,insize,
        !           515:      2   junode,lsbkpt,numbkp,iorder,jmnode,iur,iuc,ilc,ilr,numoff,isr,
        !           516:      3   nmoffc,iseq,iseq1,neqn,nodevs,ndiag,iswap,iequa,macins,lvnim1,
        !           517:      4   lx0,lvn,lynl,lyu,lyl,lx1,lx2,lx3,lx4,lx5,lx6,lx7,ld0,ld1,ltd,
        !           518:      5   imynl,imvn,lcvn,loutpt,nsnod,nsmat,nsval,icnod,icmat,icval
        !           519:       common /flags/ iprnta,iprntl,iprntm,iprntn,iprnto,limtim,limpts,
        !           520:      1   lvlcod,lvltim,itl1,itl2,itl3,itl4,itl5,igoof,nogo,keof
        !           521:       common /blank/ value(1000)
        !           522:       integer nodplc(64)
        !           523:       complex*16 cvalue(32)
        !           524:       equivalence (value(1),nodplc(1),cvalue(1))
        !           525: c
        !           526: c
        !           527:       if (nogo.ne.0) go to 300
        !           528: c...  test for ground
        !           529:       if (node1.eq.1) go to 300
        !           530:       if (node2.eq.1) go to 300
        !           531: c
        !           532: c  test for (node1,node2) matrix element
        !           533: c
        !           534:       loc=isr+node1
        !           535:   100 if (nodplc(loc).eq.0) go to 110
        !           536:       loc=nodplc(loc)
        !           537:       if (nodplc(loc+1).eq.node2) go to 300
        !           538:       go to 100
        !           539: c
        !           540: c  reserve (node1,node2) matrix element
        !           541: c
        !           542:   110 nodplc(numoff+node1)=nodplc(numoff+node1)+1
        !           543:       nodplc(nmoffc+node2)=nodplc(nmoffc+node2)+1
        !           544:       call sizmem(numoff,isize)
        !           545:       newloc=numoff+isize+1
        !           546:       nodplc(loc)=newloc
        !           547:       call extmem(numoff,2)
        !           548:       nodplc(newloc)=0
        !           549:       nodplc(newloc+1)=node2
        !           550: c
        !           551: c  mark diagonal
        !           552: c
        !           553:       if (node1.ne.node2) go to 300
        !           554:       nodplc(ndiag+node1)=1
        !           555: c
        !           556: c  finished
        !           557: c
        !           558:   300 return
        !           559:       end
        !           560:       subroutine reordr
        !           561:       implicit double precision (a-h,o-z)
        !           562: c
        !           563: c     this routine swaps rows in the coefficient matrix to eliminate
        !           564: c singularity problems which can be recognized by examining the circuit
        !           565: c topology.  it then reorders the unknowns to minimize fillin terms
        !           566: c which occur during lu factorization. (to maximize sparsity).
        !           567: c
        !           568:       common /tabinf/ ielmnt,isbckt,nsbckt,iunsat,nunsat,itemps,numtem,
        !           569:      1   isens,nsens,ifour,nfour,ifield,icode,idelim,icolum,insize,
        !           570:      2   junode,lsbkpt,numbkp,iorder,jmnode,iur,iuc,ilc,ilr,numoff,isr,
        !           571:      3   nmoffc,iseq,iseq1,neqn,nodevs,ndiag,iswap,iequa,macins,lvnim1,
        !           572:      4   lx0,lvn,lynl,lyu,lyl,lx1,lx2,lx3,lx4,lx5,lx6,lx7,ld0,ld1,ltd,
        !           573:      5   imynl,imvn,lcvn,loutpt,nsnod,nsmat,nsval,icnod,icmat,icval
        !           574:       common /cirdat/ locate(50),jelcnt(50),nunods,ncnods,numnod,nstop,
        !           575:      1   nut,nlt,nxtrm,ndist,ntlin,ibr,numvs
        !           576:       common /flags/ iprnta,iprntl,iprntm,iprntn,iprnto,limtim,limpts,
        !           577:      1   lvlcod,lvltim,itl1,itl2,itl3,itl4,itl5,igoof,nogo,keof
        !           578:       common /blank/ value(1000)
        !           579:       integer nodplc(64)
        !           580:       complex*16 cvalue(32)
        !           581:       equivalence (value(1),nodplc(1),cvalue(1))
        !           582: c
        !           583: c  allocate and initialize storage
        !           584: c
        !           585:       call getm4(iswap,nstop)
        !           586:       call getm4(iequa,nstop)
        !           587:       call getm4(iorder,nstop)
        !           588:       call getm4(jmnode,nstop)
        !           589:       call getm4(iur,nstop+1)
        !           590:       call getm4(ilc,nstop+1)
        !           591:       call getm4(iuc,0)
        !           592:       call getm4(ilr,0)
        !           593: c
        !           594:       do 10 i=1,nstop
        !           595:       nodplc(iswap+i)=i
        !           596:    10 continue
        !           597:       call copy4(nodplc(iswap+1),nodplc(iequa+1),nstop)
        !           598:       call copy4(nodplc(iswap+1),nodplc(iorder+1),nstop)
        !           599:       call copy4(nodplc(iswap+1),nodplc(jmnode+1),nstop)
        !           600: c
        !           601: c  swap current equations into admittance part of equation matrix
        !           602: c
        !           603:       nextv=1
        !           604: c
        !           605: c  find suitable voltage source
        !           606: c
        !           607:   100 if (nextv.gt.numvs) go to 150
        !           608:       ix=0
        !           609:       do 130 i=nextv,numvs
        !           610:       loc=nodplc(iseq+i)
        !           611:       node=nodplc(loc+2)
        !           612:       nflag=nodplc(iseq1+i)
        !           613:       if (nflag.eq.1) node=nodplc(loc+6)
        !           614:       if (nflag.eq.2) node=nodplc(loc+7)
        !           615:       if (node.eq.1) go to 110
        !           616:       if (nodplc(nodevs+node).ge.2) go to 110
        !           617:       if (nodplc(ndiag+node).eq.0) go to 140
        !           618:       ix=i
        !           619:       locx=loc
        !           620:       nodex=node
        !           621:   110 node=nodplc(loc+3)
        !           622:       if (nflag.eq.2) node=nodplc(loc+5)
        !           623:       if (node.eq.1) go to 130
        !           624:       if (nodplc(nodevs+node).ge.2) go to 130
        !           625:   120 if (nodplc(ndiag+node).eq.0) go to 140
        !           626:       ix=i
        !           627:       locx=loc
        !           628:       nodex=node
        !           629:   130 continue
        !           630:       if (ix.eq.0) go to 590
        !           631:       i=ix
        !           632:       loc=locx
        !           633:       node=nodex
        !           634: c
        !           635: c  resequence voltage sources
        !           636: c
        !           637:   140 nodplc(iseq+i)=nodplc(iseq+nextv)
        !           638:       nodplc(iseq+nextv)=loc
        !           639:       ltemp=nodplc(iseq1+i)
        !           640:       nodplc(iseq1+i)=nodplc(iseq1+nextv)
        !           641:       nodplc(iseq1+nextv)=ltemp
        !           642:       ibr=nodplc(neqn+i)
        !           643:       nodplc(neqn+i)=nodplc(neqn+nextv)
        !           644:       nodplc(neqn+nextv)=ibr
        !           645:       node1=nodplc(loc+2)
        !           646:       if (ltemp.eq.1) node1=nodplc(loc+6)
        !           647:       if (ltemp.eq.2) node1=nodplc(loc+7)
        !           648:       node2=nodplc(loc+3)
        !           649:       if (ltemp.eq.1) node2=nodplc(loc+3)
        !           650:       if (ltemp.eq.2) node2=nodplc(loc+5)
        !           651:       nodplc(nodevs+node1)=nodplc(nodevs+node1)-1
        !           652:       nodplc(nodevs+node2)=nodplc(nodevs+node2)-1
        !           653: c
        !           654: c  set row swap indicators
        !           655: c
        !           656:       l=nodplc(iswap+ibr)
        !           657:       j=nodplc(iequa+node)
        !           658:       nodplc(iswap+j)=l
        !           659:       nodplc(iequa+l)=j
        !           660:       nodplc(iswap+ibr)=node
        !           661:       nodplc(iequa+node)=ibr
        !           662:       nextv=nextv+1
        !           663:       go to 100
        !           664: c
        !           665: c  initialize matrix pointers
        !           666: c
        !           667:   150 nexnod=2
        !           668:       nut=0
        !           669:       nlt=0
        !           670:   160 nodplc(iur+nexnod)=nut+1
        !           671:       nodplc(ilc+nexnod)=nlt+1
        !           672:       if (nexnod.ge.nstop) go to 500
        !           673: c
        !           674: c  select row for reordering
        !           675: c
        !           676:       load=nodplc(iorder+nexnod)
        !           677:       ir=nodplc(iswap+load)
        !           678:       imin=nodplc(numoff+ir)*nodplc(nmoffc+load)
        !           679:       nstart=nexnod+1
        !           680:       do 200 i=nstart,nstop
        !           681:       lc=nodplc(iorder+i)
        !           682:       ir=nodplc(iswap+lc)
        !           683:       nrc=nodplc(numoff+ir)*nodplc(nmoffc+lc)
        !           684:       if (nrc.ge.imin) go to 200
        !           685:       imin=nrc
        !           686:       load=lc
        !           687:   200 continue
        !           688: c
        !           689: c  set reorder indicators
        !           690: c
        !           691:       ir=nodplc(iswap+load)
        !           692:       nodplc(numoff+ir)=nodplc(numoff+ir)-1
        !           693:       nodplc(nmoffc+load)=nodplc(nmoffc+load)-1
        !           694:       lc=nodplc(iorder+nexnod)
        !           695:       jr=nodplc(jmnode+load)
        !           696:       nodplc(iorder+jr)=lc
        !           697:       nodplc(jmnode+lc)=jr
        !           698:       nodplc(iorder+nexnod)=load
        !           699:       nodplc(jmnode+load)=nexnod
        !           700: c
        !           701: c  set pointers for upper triangle
        !           702: c
        !           703:       loc=isr+ir
        !           704:   330 if (nodplc(loc).eq.0) go to 340
        !           705:       loc=nodplc(loc)
        !           706:       ic=nodplc(loc+1)
        !           707:       jc=nodplc(jmnode+ic)
        !           708:       if (jc.le.nexnod) go to 330
        !           709:       nodplc(nmoffc+ic)=nodplc(nmoffc+ic)-1
        !           710:       call extmem(iuc,1)
        !           711:       nodplc(iuc+nut+1)=ic
        !           712:       nut=nut+1
        !           713:       go to 330
        !           714: c
        !           715: c  set pointers for lower triangle
        !           716: c
        !           717:   340 do 390 jr=nstart,nstop
        !           718:       lc=nodplc(iorder+jr)
        !           719:       ir=nodplc(iswap+lc)
        !           720:       loc=isr+ir
        !           721:   350 if (nodplc(loc).eq.0) go to 390
        !           722:       loc=nodplc(loc)
        !           723:       if (nodplc(loc+1).ne.load) go to 350
        !           724:       nodplc(numoff+ir)=nodplc(numoff+ir)-1
        !           725:       call extmem(ilr,1)
        !           726:       nodplc(ilr+nlt+1)=lc
        !           727:       nlt=nlt+1
        !           728: c
        !           729: c  check for fill-in terms
        !           730: c
        !           731:       nct=nodplc(iur+nexnod)
        !           732:   360 if (nct.ge.(nut+1)) go to 390
        !           733:       ic=nodplc(iuc+nct)
        !           734:       call reserv(ir,ic)
        !           735:       nct=nct+1
        !           736:       go to 360
        !           737:   390 continue
        !           738: c
        !           739: c
        !           740:       nexnod=nexnod+1
        !           741:       go to 160
        !           742: c
        !           743: c  reordering finished
        !           744: c
        !           745:   500 nodplc(iur+nstop+1)=nut+1
        !           746:       nodplc(ilc+nstop+1)=nlt+1
        !           747:       if (nut.eq.0) go to 515
        !           748:       do 510 i=1,nut
        !           749:       j=nodplc(iuc+i)
        !           750:       nodplc(iuc+i)=nodplc(jmnode+j)
        !           751:   510 continue
        !           752:   515 if (nlt.eq.0) go to 600
        !           753:       do 520 i=1,nlt
        !           754:       j=nodplc(ilr+i)
        !           755:       nodplc(ilr+i)=nodplc(jmnode+j)
        !           756:   520 continue
        !           757:       go to 600
        !           758: c
        !           759: c  error - voltage-source/inductor/transmission-line loop detected ...
        !           760: c
        !           761:   590 nogo=1
        !           762:       write (6,591)
        !           763: c...  loop should have been detected in topchk
        !           764:   591 format('0*abort*:  spice internal error in reordr'/)
        !           765: c
        !           766: c  finished
        !           767: c
        !           768:   600 return
        !           769:       end
        !           770:       subroutine matloc
        !           771:       implicit double precision (a-h,o-z)
        !           772: c
        !           773: c     this routine stores the locations of the various matrix terms to
        !           774: c which the different circuit elements contribute.
        !           775: c
        !           776:       common /tabinf/ ielmnt,isbckt,nsbckt,iunsat,nunsat,itemps,numtem,
        !           777:      1   isens,nsens,ifour,nfour,ifield,icode,idelim,icolum,insize,
        !           778:      2   junode,lsbkpt,numbkp,iorder,jmnode,iur,iuc,ilc,ilr,numoff,isr,
        !           779:      3   nmoffc,iseq,iseq1,neqn,nodevs,ndiag,iswap,iequa,macins,lvnim1,
        !           780:      4   lx0,lvn,lynl,lyu,lyl,lx1,lx2,lx3,lx4,lx5,lx6,lx7,ld0,ld1,ltd,
        !           781:      5   imynl,imvn,lcvn,loutpt,nsnod,nsmat,nsval,icnod,icmat,icval
        !           782:       common /cirdat/ locate(50),jelcnt(50),nunods,ncnods,numnod,nstop,
        !           783:      1   nut,nlt,nxtrm,ndist,ntlin,ibr,numvs
        !           784:       common /blank/ value(1000)
        !           785:       integer nodplc(64)
        !           786:       complex*16 cvalue(32)
        !           787:       equivalence (value(1),nodplc(1),cvalue(1))
        !           788: c
        !           789: c  resistors
        !           790: c
        !           791:       loc=locate(1)
        !           792:   690 if (loc.eq.0) go to 700
        !           793:       node1=nodplc(loc+2)
        !           794:       node2=nodplc(loc+3)
        !           795:       nodplc(loc+4)=indxx(node1,node2)
        !           796:       nodplc(loc+5)=indxx(node2,node1)
        !           797:       nodplc(loc+6)=indxx(node1,node1)
        !           798:       nodplc(loc+7)=indxx(node2,node2)
        !           799:       loc=nodplc(loc)
        !           800:       go to 690
        !           801: c
        !           802: c  capacitors
        !           803: c
        !           804:   700 loc=locate(2)
        !           805:   710 if (loc.eq.0) go to 720
        !           806:       node1=nodplc(loc+2)
        !           807:       node2=nodplc(loc+3)
        !           808:       nodplc(loc+5)=indxx(node1,node2)
        !           809:       nodplc(loc+6)=indxx(node2,node1)
        !           810:       nodplc(loc+10)=indxx(node1,node1)
        !           811:       nodplc(loc+11)=indxx(node2,node2)
        !           812:       loc=nodplc(loc)
        !           813:       go to 710
        !           814: c
        !           815: c  inductors
        !           816: c
        !           817:   720 loc=locate(3)
        !           818:   730 if (loc.eq.0) go to 740
        !           819:       node1=nodplc(loc+2)
        !           820:       node2=nodplc(loc+3)
        !           821:       ibr=nodplc(loc+5)
        !           822:       nodplc(loc+6)=indxx(node1,ibr)
        !           823:       nodplc(loc+7)=indxx(node2,ibr)
        !           824:       nodplc(loc+8)=indxx(ibr,node1)
        !           825:       nodplc(loc+9)=indxx(ibr,node2)
        !           826:       nodplc(loc+13)=indxx(ibr,ibr)
        !           827:       loc=nodplc(loc)
        !           828:       go to 730
        !           829: c
        !           830: c  mutual inductances
        !           831: c
        !           832:   740 loc=locate(4)
        !           833:   750 if (loc.eq.0) go to 760
        !           834:       nl1=nodplc(loc+2)
        !           835:       nl2=nodplc(loc+3)
        !           836:       ibr1=nodplc(nl1+5)
        !           837:       ibr2=nodplc(nl2+5)
        !           838:       nodplc(loc+4)=indxx(ibr1,ibr2)
        !           839:       nodplc(loc+5)=indxx(ibr2,ibr1)
        !           840:       loc=nodplc(loc)
        !           841:       go to 750
        !           842: c
        !           843: c  nonlinear voltage controlled current sources
        !           844: c
        !           845:   760 loc=locate(5)
        !           846:   762 if (loc.eq.0) go to 764
        !           847:       node1=nodplc(loc+2)
        !           848:       node2=nodplc(loc+3)
        !           849:       ndim=nodplc(loc+4)
        !           850:       lnod=nodplc(loc+6)
        !           851:       lmat=nodplc(loc+7)
        !           852:       do 763 i=1,ndim
        !           853:       node3=nodplc(lnod+1)
        !           854:       node4=nodplc(lnod+2)
        !           855:       lnod=lnod+2
        !           856:       nodplc(lmat+1)=indxx(node1,node3)
        !           857:       nodplc(lmat+2)=indxx(node1,node4)
        !           858:       nodplc(lmat+3)=indxx(node2,node3)
        !           859:       nodplc(lmat+4)=indxx(node2,node4)
        !           860:       lmat=lmat+4
        !           861:   763 continue
        !           862:       loc=nodplc(loc)
        !           863:       go to 762
        !           864: c
        !           865: c  nonlinear voltage controlled voltage sources
        !           866: c
        !           867:   764 loc=locate(6)
        !           868:   766 if (loc.eq.0) go to 768
        !           869:       node1=nodplc(loc+2)
        !           870:       node2=nodplc(loc+3)
        !           871:       ndim=nodplc(loc+4)
        !           872:       ibr=nodplc(loc+6)
        !           873:       lnod=nodplc(loc+7)
        !           874:       lmat=nodplc(loc+8)
        !           875:       nodplc(lmat+1)=indxx(node1,ibr)
        !           876:       nodplc(lmat+2)=indxx(node2,ibr)
        !           877:       nodplc(lmat+3)=indxx(ibr,node1)
        !           878:       nodplc(lmat+4)=indxx(ibr,node2)
        !           879:       lmat=lmat+4
        !           880:       do 767 i=1,ndim
        !           881:       node3=nodplc(lnod+1)
        !           882:       node4=nodplc(lnod+2)
        !           883:       lnod=lnod+2
        !           884:       nodplc(lmat+1)=indxx(ibr,node3)
        !           885:       nodplc(lmat+2)=indxx(ibr,node4)
        !           886:       lmat=lmat+2
        !           887:   767 continue
        !           888:       loc=nodplc(loc)
        !           889:       go to 766
        !           890: c
        !           891: c  nonlinear current controlled current sources
        !           892: c
        !           893:   768 loc=locate(7)
        !           894:   770 if (loc.eq.0) go to 772
        !           895:       node1=nodplc(loc+2)
        !           896:       node2=nodplc(loc+3)
        !           897:       ndim=nodplc(loc+4)
        !           898:       locvs=nodplc(loc+6)
        !           899:       lmat=nodplc(loc+7)
        !           900:       do 771 i=1,ndim
        !           901:       locvst=nodplc(locvs+i)
        !           902:       ibr=nodplc(locvst+6)
        !           903:       nodplc(lmat+1)=indxx(node1,ibr)
        !           904:       nodplc(lmat+2)=indxx(node2,ibr)
        !           905:       lmat=lmat+2
        !           906:   771 continue
        !           907:       loc=nodplc(loc)
        !           908:       go to 770
        !           909: c
        !           910: c  nonlinear current controlled voltage sources
        !           911: c
        !           912:   772 loc=locate(8)
        !           913:   774 if (loc.eq.0) go to 780
        !           914:       node1=nodplc(loc+2)
        !           915:       node2=nodplc(loc+3)
        !           916:       ndim=nodplc(loc+4)
        !           917:       ibr=nodplc(loc+6)
        !           918:       locvs=nodplc(loc+7)
        !           919:       lmat=nodplc(loc+8)
        !           920:       nodplc(lmat+1)=indxx(node1,ibr)
        !           921:       nodplc(lmat+2)=indxx(node2,ibr)
        !           922:       nodplc(lmat+3)=indxx(ibr,node1)
        !           923:       nodplc(lmat+4)=indxx(ibr,node2)
        !           924:       lmat=lmat+4
        !           925:       do 775 i=1,ndim
        !           926:       locvst=nodplc(locvs+i)
        !           927:       kbr=nodplc(locvst+6)
        !           928:       nodplc(lmat+i)=indxx(ibr,kbr)
        !           929:   775 continue
        !           930:       loc=nodplc(loc)
        !           931:       go to 774
        !           932: c
        !           933: c  voltage sources
        !           934: c
        !           935:   780 loc=locate(9)
        !           936:   790 if (loc.eq.0) go to 800
        !           937:       node1=nodplc(loc+2)
        !           938:       node2=nodplc(loc+3)
        !           939:       iptr=nodplc(loc+6)
        !           940:       nodplc(loc+7)=indxx(node1,iptr)
        !           941:       nodplc(loc+8)=indxx(node2,iptr)
        !           942:       nodplc(loc+9)=indxx(iptr,node1)
        !           943:       nodplc(loc+10)=indxx(iptr,node2)
        !           944:       loc=nodplc(loc)
        !           945:       go to 790
        !           946: c
        !           947: c  diodes
        !           948: c
        !           949:   800 loc=locate(11)
        !           950:   810 if (loc.eq.0) go to 820
        !           951:       node1=nodplc(loc+2)
        !           952:       node2=nodplc(loc+3)
        !           953:       node3=nodplc(loc+4)
        !           954:       nodplc(loc+7)=indxx(node1,node3)
        !           955:       nodplc(loc+8)=indxx(node2,node3)
        !           956:       nodplc(loc+9)=indxx(node3,node1)
        !           957:       nodplc(loc+10)=indxx(node3,node2)
        !           958:       nodplc(loc+13)=indxx(node1,node1)
        !           959:       nodplc(loc+14)=indxx(node2,node2)
        !           960:       nodplc(loc+15)=indxx(node3,node3)
        !           961:       loc=nodplc(loc)
        !           962:       go to 810
        !           963: c
        !           964: c  transistors
        !           965: c
        !           966:   820 loc=locate(12)
        !           967:   830 if (loc.eq.0) go to 840
        !           968:       node1=nodplc(loc+2)
        !           969:       node2=nodplc(loc+3)
        !           970:       node3=nodplc(loc+4)
        !           971:       node4=nodplc(loc+5)
        !           972:       node5=nodplc(loc+6)
        !           973:       node6=nodplc(loc+7)
        !           974:       node7=nodplc(loc+30)
        !           975:       nodplc(loc+10)=indxx(node1,node4)
        !           976:       nodplc(loc+11)=indxx(node2,node5)
        !           977:       nodplc(loc+12)=indxx(node3,node6)
        !           978:       nodplc(loc+13)=indxx(node4,node1)
        !           979:       nodplc(loc+14)=indxx(node4,node5)
        !           980:       nodplc(loc+15)=indxx(node4,node6)
        !           981:       nodplc(loc+16)=indxx(node5,node2)
        !           982:       nodplc(loc+17)=indxx(node5,node4)
        !           983:       nodplc(loc+18)=indxx(node5,node6)
        !           984:       nodplc(loc+19)=indxx(node6,node3)
        !           985:       nodplc(loc+20)=indxx(node6,node4)
        !           986:       nodplc(loc+21)=indxx(node6,node5)
        !           987:       nodplc(loc+24)=indxx(node1,node1)
        !           988:       nodplc(loc+25)=indxx(node2,node2)
        !           989:       nodplc(loc+26)=indxx(node3,node3)
        !           990:       nodplc(loc+27)=indxx(node4,node4)
        !           991:       nodplc(loc+28)=indxx(node5,node5)
        !           992:       nodplc(loc+29)=indxx(node6,node6)
        !           993:       nodplc(loc+31)=indxx(node7,node7)
        !           994:       nodplc(loc+32)=indxx(node4,node7)
        !           995:       nodplc(loc+33)=indxx(node7,node4)
        !           996:       nodplc(loc+34)=indxx(node2,node4)
        !           997:       nodplc(loc+35)=indxx(node4,node2)
        !           998:       loc=nodplc(loc)
        !           999:       go to 830
        !          1000: c
        !          1001: c  jfets
        !          1002: c
        !          1003:   840 loc=locate(13)
        !          1004:   850 if (loc.eq.0) go to 860
        !          1005:       node1=nodplc(loc+2)
        !          1006:       node2=nodplc(loc+3)
        !          1007:       node3=nodplc(loc+4)
        !          1008:       node4=nodplc(loc+5)
        !          1009:       node5=nodplc(loc+6)
        !          1010:       nodplc(loc+9)=indxx(node1,node4)
        !          1011:       nodplc(loc+10)=indxx(node2,node4)
        !          1012:       nodplc(loc+11)=indxx(node2,node5)
        !          1013:       nodplc(loc+12)=indxx(node3,node5)
        !          1014:       nodplc(loc+13)=indxx(node4,node1)
        !          1015:       nodplc(loc+14)=indxx(node4,node2)
        !          1016:       nodplc(loc+15)=indxx(node4,node5)
        !          1017:       nodplc(loc+16)=indxx(node5,node2)
        !          1018:       nodplc(loc+17)=indxx(node5,node3)
        !          1019:       nodplc(loc+18)=indxx(node5,node4)
        !          1020:       nodplc(loc+20)=indxx(node1,node1)
        !          1021:       nodplc(loc+21)=indxx(node2,node2)
        !          1022:       nodplc(loc+22)=indxx(node3,node3)
        !          1023:       nodplc(loc+23)=indxx(node4,node4)
        !          1024:       nodplc(loc+24)=indxx(node5,node5)
        !          1025:       loc=nodplc(loc)
        !          1026:       go to 850
        !          1027: c
        !          1028: c  mosfets
        !          1029: c
        !          1030:   860 loc=locate(14)
        !          1031:   870 if (loc.eq.0) go to 900
        !          1032:       node1=nodplc(loc+2)
        !          1033:       node2=nodplc(loc+3)
        !          1034:       node3=nodplc(loc+4)
        !          1035:       node4=nodplc(loc+5)
        !          1036:       node5=nodplc(loc+6)
        !          1037:       node6=nodplc(loc+7)
        !          1038:       nodplc(loc+10)=indxx(node1,node5)
        !          1039:       nodplc(loc+11)=indxx(node2,node4)
        !          1040:       nodplc(loc+12)=indxx(node2,node5)
        !          1041:       nodplc(loc+13)=indxx(node2,node6)
        !          1042:       nodplc(loc+14)=indxx(node3,node6)
        !          1043:       nodplc(loc+15)=indxx(node4,node2)
        !          1044:       nodplc(loc+16)=indxx(node4,node5)
        !          1045:       nodplc(loc+17)=indxx(node4,node6)
        !          1046:       nodplc(loc+18)=indxx(node5,node1)
        !          1047:       nodplc(loc+19)=indxx(node5,node2)
        !          1048:       nodplc(loc+20)=indxx(node5,node4)
        !          1049:       nodplc(loc+21)=indxx(node5,node6)
        !          1050:       nodplc(loc+22)=indxx(node6,node2)
        !          1051:       nodplc(loc+23)=indxx(node6,node3)
        !          1052:       nodplc(loc+24)=indxx(node6,node4)
        !          1053:       nodplc(loc+25)=indxx(node6,node5)
        !          1054:       nodplc(loc+27)=indxx(node1,node1)
        !          1055:       nodplc(loc+28)=indxx(node2,node2)
        !          1056:       nodplc(loc+29)=indxx(node3,node3)
        !          1057:       nodplc(loc+30)=indxx(node4,node4)
        !          1058:       nodplc(loc+31)=indxx(node5,node5)
        !          1059:       nodplc(loc+32)=indxx(node6,node6)
        !          1060:       loc=nodplc(loc)
        !          1061:       go to 870
        !          1062: c
        !          1063: c  transmission lines
        !          1064: c
        !          1065:   900 loc=locate(17)
        !          1066:   910 if (loc.eq.0) go to 1000
        !          1067:       node1=nodplc(loc+2)
        !          1068:       node2=nodplc(loc+3)
        !          1069:       node3=nodplc(loc+4)
        !          1070:       node4=nodplc(loc+5)
        !          1071:       ni1=nodplc(loc+6)
        !          1072:       ni2=nodplc(loc+7)
        !          1073:       ibr1=nodplc(loc+8)
        !          1074:       ibr2=nodplc(loc+9)
        !          1075:       nodplc(loc+10)=indxx(node1,node1)
        !          1076:       nodplc(loc+11)=indxx(node1,ni1)
        !          1077:       nodplc(loc+12)=indxx(node2,ibr1)
        !          1078:       nodplc(loc+13)=indxx(node3,node3)
        !          1079:       nodplc(loc+14)=indxx(node4,ibr2)
        !          1080:       nodplc(loc+15)=indxx(ni1,node1)
        !          1081:       nodplc(loc+16)=indxx(ni1,ni1)
        !          1082:       nodplc(loc+17)=indxx(ni1,ibr1)
        !          1083:       nodplc(loc+18)=indxx(ni2,ni2)
        !          1084:       nodplc(loc+19)=indxx(ni2,ibr2)
        !          1085:       nodplc(loc+20)=indxx(ibr1,node2)
        !          1086:       nodplc(loc+21)=indxx(ibr1,node3)
        !          1087:       nodplc(loc+22)=indxx(ibr1,node4)
        !          1088:       nodplc(loc+23)=indxx(ibr1,ni1)
        !          1089:       nodplc(loc+24)=indxx(ibr1,ibr2)
        !          1090:       nodplc(loc+25)=indxx(ibr2,node1)
        !          1091:       nodplc(loc+26)=indxx(ibr2,node2)
        !          1092:       nodplc(loc+27)=indxx(ibr2,node4)
        !          1093:       nodplc(loc+28)=indxx(ibr2,ni2)
        !          1094:       nodplc(loc+29)=indxx(ibr2,ibr1)
        !          1095:       nodplc(loc+31)=indxx(node3,ni2)
        !          1096:       nodplc(loc+32)=indxx(ni2,node3)
        !          1097:       loc=nodplc(loc)
        !          1098:       go to 910
        !          1099: c
        !          1100: c  .nodeset
        !          1101: c
        !          1102:  1000 call sizmem(nsnod,nic)
        !          1103:       if(nic.eq.0) go to 1020
        !          1104:       call getm4(nsmat,nic)
        !          1105:       do 1010 i=1,nic
        !          1106:       node=nodplc(nsnod+i)
        !          1107:       nodplc(nsmat+i)=indxx(node,node)
        !          1108:  1010 continue
        !          1109: c
        !          1110: c  transient initial conditions
        !          1111: c
        !          1112:  1020 call sizmem(icnod,nic)
        !          1113:       if(nic.eq.0) go to 1100
        !          1114:       call getm4(icmat,nic)
        !          1115:       do 1030 i=1,nic
        !          1116:       node=nodplc(icnod+i)
        !          1117:       nodplc(icmat+i)=indxx(node,node)
        !          1118:  1030 continue
        !          1119: c
        !          1120: c  finished
        !          1121: c
        !          1122:  1100 return
        !          1123:       end
        !          1124:       integer function indxx(node1,node2)
        !          1125:       implicit double precision (a-h,o-z)
        !          1126: c
        !          1127: c     this routine maps a (row, column) matrix term specification into
        !          1128: c the offset from the origin of the matrix storage at which the term is
        !          1129: c actually located.
        !          1130: c
        !          1131:       common /tabinf/ ielmnt,isbckt,nsbckt,iunsat,nunsat,itemps,numtem,
        !          1132:      1   isens,nsens,ifour,nfour,ifield,icode,idelim,icolum,insize,
        !          1133:      2   junode,lsbkpt,numbkp,iorder,jmnode,iur,iuc,ilc,ilr,numoff,isr,
        !          1134:      3   nmoffc,iseq,iseq1,neqn,nodevs,ndiag,iswap,iequa,macins,lvnim1,
        !          1135:      4   lx0,lvn,lynl,lyu,lyl,lx1,lx2,lx3,lx4,lx5,lx6,lx7,ld0,ld1,ltd,
        !          1136:      5   imynl,imvn,lcvn,loutpt,nsnod,nsmat,nsval,icnod,icmat,icval
        !          1137:       common /cirdat/ locate(50),jelcnt(50),nunods,ncnods,numnod,nstop,
        !          1138:      1   nut,nlt,nxtrm,ndist,ntlin,ibr,numvs
        !          1139:       common /blank/ value(1000)
        !          1140:       integer nodplc(64)
        !          1141:       complex*16 cvalue(32)
        !          1142:       equivalence (value(1),nodplc(1),cvalue(1))
        !          1143: c
        !          1144: c  check for ground
        !          1145: c
        !          1146:       if (node1.eq.1) go to 400
        !          1147:       if (node2.eq.1) go to 400
        !          1148: c
        !          1149:       n1=nodplc(iequa+node1)
        !          1150:       n1=nodplc(jmnode+n1)
        !          1151:       n2=nodplc(jmnode+node2)
        !          1152: c
        !          1153: c
        !          1154:       if (n1-n2) 100,200,300
        !          1155: c
        !          1156: c  upper triangle
        !          1157: c
        !          1158:   100 ns=nodplc(iur+n1)
        !          1159:       ne=nodplc(iur+n1+1)
        !          1160:   110 if (ns.ge.ne) go to 400
        !          1161:       if (nodplc(iuc+ns).eq.n2) go to 120
        !          1162:       ns=ns+1
        !          1163:       go to 110
        !          1164:   120 indxx=nstop+ns
        !          1165:       go to 500
        !          1166: c
        !          1167: c  diagonal
        !          1168: c
        !          1169:   200 indxx=node2
        !          1170:       go to 500
        !          1171: c
        !          1172: c  lower triangle
        !          1173: c
        !          1174:   300 ns=nodplc(ilc+n2)
        !          1175:       ne=nodplc(ilc+n2+1)
        !          1176:   310 if (ns.ge.ne) go to 400
        !          1177:       if (nodplc(ilr+ns).eq.n1) go to 320
        !          1178:       ns=ns+1
        !          1179:       go to 310
        !          1180:   320 indxx=nstop+nut+ns
        !          1181:       go to 500
        !          1182: c
        !          1183: c  unused location
        !          1184: c
        !          1185:   400 indxx=1
        !          1186: c
        !          1187: c  finished
        !          1188: c
        !          1189:   500 return
        !          1190:       end
        !          1191:       subroutine codgen
        !          1192:       implicit double precision (a-h,o-z)
        !          1193: c
        !          1194: c     this routine generates machine instructions (for the cdc 6400) to
        !          1195: c lu-factor and solve the set of circuit equations.
        !          1196: c
        !          1197:       common /tabinf/ ielmnt,isbckt,nsbckt,iunsat,nunsat,itemps,numtem,
        !          1198:      1   isens,nsens,ifour,nfour,ifield,icode,idelim,icolum,insize,
        !          1199:      2   junode,lsbkpt,numbkp,iorder,jmnode,iur,iuc,ilc,ilr,numoff,isr,
        !          1200:      3   nmoffc,iseq,iseq1,neqn,nodevs,ndiag,iswap,iequa,macins,lvnim1,
        !          1201:      4   lx0,lvn,lynl,lyu,lyl,lx1,lx2,lx3,lx4,lx5,lx6,lx7,ld0,ld1,ltd,
        !          1202:      5   imynl,imvn,lcvn,loutpt,nsnod,nsmat,nsval,icnod,icmat,icval
        !          1203:       common /cirdat/ locate(50),jelcnt(50),nunods,ncnods,numnod,nstop,
        !          1204:      1   nut,nlt,nxtrm,ndist,ntlin,ibr,numvs
        !          1205:       common /flags/ iprnta,iprntl,iprntm,iprntn,iprnto,limtim,limpts,
        !          1206:      1   lvlcod,lvltim,itl1,itl2,itl3,itl4,itl5,igoof,nogo,keof
        !          1207:       common /knstnt/ twopi,xlog2,xlog10,root2,rad,boltz,charge,ctok,
        !          1208:      1   gmin,reltol,abstol,vntol,trtol,chgtol,eps0,epssil,epsox
        !          1209:       common /blank/ value(1000)
        !          1210:       integer nodplc(64)
        !          1211:       complex*16 cvalue(32)
        !          1212:       equivalence (value(1),nodplc(1),cvalue(1))
        !          1213:       return
        !          1214:       end

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