├── .cvsignore ├── INSTALL ├── Makefile ├── README ├── bin ├── lisp-file └── run-lisp ├── clocc.lisp ├── clocc.mk ├── etc ├── GNU-GPL ├── GNU-LGPL ├── MIT-COPYRIGHT ├── cl-ent.xml ├── clhs-ent-long.xml ├── clhs-ent-short.xml └── www.debian.org │ └── social_contract.html └── src ├── cllib ├── .cvsignore ├── Makefile ├── animals.lisp ├── autoload.lisp ├── base.lisp ├── base64.lisp ├── bookmark.lisp ├── card.lisp ├── check.lisp ├── clhs.lisp ├── cllib.html ├── cllib.system ├── closio.lisp ├── csv.lisp ├── cvs.lisp ├── data.lisp ├── date.lisp ├── datedl.lisp ├── doall.lisp ├── elisp.lisp ├── entities.xml ├── fileio.lisp ├── fin.lisp ├── geo.lisp ├── getopt.lisp ├── gnuplot.lisp ├── gq.lisp ├── h2lisp.lisp ├── html.lisp ├── htmlgen.lisp ├── inspect.lisp ├── iter.lisp ├── laser.lisp ├── lift.lisp ├── list.lisp ├── log.lisp ├── math.lisp ├── matrix.lisp ├── miscprint.lisp ├── munkres.lisp ├── ocaml.lisp ├── octave.lisp ├── prompt.lisp ├── rng.lisp ├── rpm.lisp ├── server.lisp ├── simple.lisp ├── sorted.lisp ├── stat.lisp ├── string.lisp ├── symb.lisp ├── tests.lisp ├── tilsla.lisp ├── url.lisp ├── withtype.lisp └── xml.lisp ├── defsystem-3.x ├── .cvsignore ├── ChangeLog ├── README ├── debian │ ├── README.Debian │ ├── changelog │ ├── cl-defsystem3.doc-base │ ├── compat │ ├── control │ ├── copyright │ ├── postinst │ ├── postrm │ ├── preinst │ ├── prerm │ └── rules ├── defsystem.lisp └── docs │ ├── defsystem.html │ └── defsystem.text ├── defsystem-4 ├── ALPHA-NOTICE ├── COPYING ├── ChangeLog ├── INSTALL ├── README ├── THIS-IS-DF4 ├── TODO ├── docs │ └── defsystem.tex └── src │ ├── actions.lisp │ ├── adjoin-dirs.lisp │ ├── base-components.lisp │ ├── defsystem-pkg.lisp │ ├── defsystem-protocol.lisp │ ├── defsystem.lisp │ ├── impl-dependent │ ├── allegro.lisp │ ├── clisp.lisp │ ├── cmucl.lisp │ ├── common.lisp │ ├── corman.lisp │ ├── kcl-derivatives.lisp │ ├── lcl.lisp │ ├── lispworks.lisp │ ├── mcl.lisp │ ├── poplog.lisp │ └── sbcl.lisp │ ├── language-support.lisp │ ├── languages │ ├── c │ │ └── c.lisp │ ├── common-lisp │ │ └── common-lisp.lisp │ ├── fortran │ │ └── fortran.lisp │ ├── java │ │ └── java.lisp │ ├── scheme │ │ └── scheme.lisp │ └── shared │ │ └── shared-functionality.lisp │ ├── load-defsystem.lisp │ ├── predefined-components.lisp │ ├── predefined-specialized-components.lisp │ ├── registry.lisp │ ├── syntax.lisp │ ├── tests │ ├── README │ ├── component-test.lisp │ ├── crscl.system │ └── test-file.lisp │ ├── utilities │ ├── ambler │ │ ├── COPYING │ │ ├── ambler-pkg.lisp │ │ ├── ambler.lisp │ │ └── ambler.system │ ├── run-os-program.lisp │ ├── save-image.lisp │ ├── split-sequence.lisp │ ├── user-interaction.lisp │ └── y-or-n-p-wait.lisp │ └── versions.lisp ├── donc ├── http.lisp ├── measure-usec.lisp ├── mime.types ├── newstep.lisp ├── pp.lisp ├── record-calls.lisp ├── server.lisp ├── smtp.el ├── smtp.lisp └── smtp.readme ├── ext ├── exporting │ └── exporting.lisp ├── queues │ ├── COPYING │ ├── queues-package.lisp │ ├── queues.lisp │ └── queues.system ├── sequences │ ├── Makefile │ ├── README │ ├── avlseq.lisp │ ├── report.html │ ├── seq.system │ ├── seqclisp.lisp │ ├── sequence.lisp │ └── sequences.lisp └── union-find │ ├── COPYING │ ├── README │ ├── test.lisp │ ├── union-find-pkg.lisp │ ├── union-find.lisp │ └── union-find.system ├── f2cl ├── Copyright ├── GNU-GPL ├── Makefile ├── README ├── build │ └── install.txt ├── debian │ ├── README.Debian │ ├── changelog │ ├── compat │ ├── control │ ├── copyright │ ├── f2cl.asd │ ├── postinst │ ├── prerm │ └── rules ├── doc │ ├── Change-notes.txt │ └── f2cldoc.latex ├── f2cl.asd ├── f2cl.system ├── packages │ ├── .cvsignore │ ├── README │ ├── blas.system │ ├── blas │ │ ├── .cvsignore │ │ ├── blas-package.lisp │ │ ├── dasum.f │ │ ├── daxpy.f │ │ ├── dcabs1.f │ │ ├── dcopy.f │ │ ├── ddot.f │ │ ├── dgbmv.f │ │ ├── dgemm.f │ │ ├── dgemv.f │ │ ├── dger.f │ │ ├── dnrm2.f │ │ ├── drot.f │ │ ├── drotg.f │ │ ├── dsbmv.f │ │ ├── dscal.f │ │ ├── dspmv.f │ │ ├── dspr.f │ │ ├── dspr2.f │ │ ├── dswap.f │ │ ├── dsymm.f │ │ ├── dsymv.f │ │ ├── dsyr.f │ │ ├── dsyr2.f │ │ ├── dsyr2k.f │ │ ├── dsyrk.f │ │ ├── dtbmv.f │ │ ├── dtbsv.f │ │ ├── dtpmv.f │ │ ├── dtpsv.f │ │ ├── dtrmm.f │ │ ├── dtrmv.f │ │ ├── dtrsm.f │ │ ├── dtrsv.f │ │ ├── dzasum.f │ │ ├── dznrm2.f │ │ ├── icamax.f │ │ ├── idamax.f │ │ ├── isamax.f │ │ ├── izamax.f │ │ ├── lsame.f │ │ ├── xerbla.f │ │ ├── zaxpy.f │ │ ├── zcopy.f │ │ ├── zdotc.f │ │ ├── zdotu.f │ │ ├── zdscal.f │ │ ├── zgbmv.f │ │ ├── zgemm.f │ │ ├── zgemv.f │ │ ├── zgerc.f │ │ ├── zgeru.f │ │ ├── zhbmv.f │ │ ├── zhemm.f │ │ ├── zhemv.f │ │ ├── zher.f │ │ ├── zher2.f │ │ ├── zher2k.f │ │ ├── zherk.f │ │ ├── zhpmv.f │ │ ├── zhpr.f │ │ ├── zhpr2.f │ │ ├── zrotg.f │ │ ├── zscal.f │ │ ├── zswap.f │ │ ├── zsymm.f │ │ ├── zsyr2k.f │ │ ├── zsyrk.f │ │ ├── ztbmv.f │ │ ├── ztbsv.f │ │ ├── ztpmv.f │ │ ├── ztpsv.f │ │ ├── ztrmm.f │ │ ├── ztrmv.f │ │ ├── ztrsm.f │ │ └── ztrsv.f │ ├── colnew.system │ ├── colnew │ │ ├── .cvsignore │ │ ├── approx.f │ │ ├── appsln.f │ │ ├── colnew.f │ │ ├── compat.f │ │ ├── consts.f │ │ ├── contrl.f │ │ ├── daxpy.f │ │ ├── ddot.f │ │ ├── dgefa.f │ │ ├── dgesl.f │ │ ├── dmzsol.f │ │ ├── dscal.f │ │ ├── errchk.f │ │ ├── factrb.f │ │ ├── fcblok.f │ │ ├── gblock.f │ │ ├── gderiv.f │ │ ├── horder.f │ │ ├── idamax.f │ │ ├── lsyslv.f │ │ ├── newmsh.f │ │ ├── problem-1 │ │ │ ├── .cvsignore │ │ │ ├── dfsub.f │ │ │ ├── dgsub.f │ │ │ ├── exact.f │ │ │ ├── fsub.f │ │ │ ├── gsub.f │ │ │ ├── prob1-orig.f │ │ │ └── prob1.f │ │ ├── problem-2 │ │ │ ├── .cvsignore │ │ │ ├── dfsub.f │ │ │ ├── dgsub.f │ │ │ ├── fsub.f │ │ │ ├── gsub.f │ │ │ ├── prob2 │ │ │ ├── prob2.f │ │ │ └── solutn.f │ │ ├── problem-3 │ │ │ ├── .cvsignore │ │ │ ├── dfsub.f │ │ │ ├── dgsub.f │ │ │ ├── fsub.f │ │ │ ├── gsub.f │ │ │ ├── prob3.f │ │ │ └── solutn.f │ │ ├── rkbas.f │ │ ├── sbblok.f │ │ ├── shiftb.f │ │ ├── skale.f │ │ ├── subbak.f │ │ ├── subfor.f │ │ ├── vmonde.f │ │ └── vwblok.f │ ├── d1mach.lisp │ ├── donlp2.system │ ├── donlp2 │ │ ├── .cvsignore │ │ ├── ALKYLATI.MES │ │ ├── ALKYLATI.PRO │ │ ├── AMPLEXAM.MES │ │ ├── AMPLEXAM.PRO │ │ ├── ANTENNA1.MES │ │ ├── ANTENNA1.PRO │ │ ├── BETTING8.MES │ │ ├── BETTING8.PRO │ │ ├── BOXPARID.MES │ │ ├── BOXPARID.PRO │ │ ├── DEMBO1AS.MES │ │ ├── DEMBO1AS.PRO │ │ ├── DEMBO4CX.MES │ │ ├── DEMBO4CX.PRO │ │ ├── DEMBO7XX.MES │ │ ├── DEMBO7XX.PRO │ │ ├── FRACXOPT.MES │ │ ├── FRACXOPT.PRO │ │ ├── GIRDERDE.MES │ │ ├── GIRDERDE.PRO │ │ ├── HIMMELBL.MES │ │ ├── HIMMELBL.PRO │ │ ├── HS101XXX.MES │ │ ├── HS101XXX.PRO │ │ ├── HS102XXX.MES │ │ ├── HS102XXX.PRO │ │ ├── HS103XXX.MES │ │ ├── HS103XXX.PRO │ │ ├── HS109XXX.MES │ │ ├── HS109XXX.PRO │ │ ├── HS85ORIG.MES │ │ ├── HS85ORIG.PRO │ │ ├── MARATOS0.MES │ │ ├── MARATOS0.PRO │ │ ├── Makefile │ │ ├── NET1AMPL.MES │ │ ├── NET1AMPL.PRO │ │ ├── NMCFQMHH.MES │ │ ├── NMCFQMHH.PRO │ │ ├── NMFCQ11X.MES │ │ ├── NMFCQ11X.PRO │ │ ├── PAVIANI2.MES │ │ ├── PAVIANI2.PRO │ │ ├── ROBOTAXX.MES │ │ ├── ROBOTAXX.PRO │ │ ├── ROBOTCXX.MES │ │ ├── ROBOTCXX.PRO │ │ ├── TP383MOD.MES │ │ ├── TP383MOD.PRO │ │ ├── UNDEFEXA.MES │ │ ├── UNDEFEXA.PRO │ │ ├── WEAPONH2.MES │ │ └── WEAPONH2.PRO │ ├── fftpack5.system │ ├── fftpack5 │ │ ├── .cvsignore │ │ ├── Makefile │ │ ├── README │ │ ├── c1f2kb.f │ │ ├── c1f2kf.f │ │ ├── c1f3kb.f │ │ ├── c1f3kf.f │ │ ├── c1f4kb.f │ │ ├── c1f4kf.f │ │ ├── c1f5kb.f │ │ ├── c1f5kf.f │ │ ├── c1fgkb.f │ │ ├── c1fgkf.f │ │ ├── c1fm1b.f │ │ ├── c1fm1f.f │ │ ├── cfft1b.f │ │ ├── cfft1f.f │ │ ├── cfft1i.f │ │ ├── cfft2b.f │ │ ├── cfft2f.f │ │ ├── cfft2i.f │ │ ├── cfftmb.f │ │ ├── cfftmf.f │ │ ├── cfftmi.f │ │ ├── cmf2kb.f │ │ ├── cmf2kf.f │ │ ├── cmf3kb.f │ │ ├── cmf3kf.f │ │ ├── cmf4kb.f │ │ ├── cmf4kf.f │ │ ├── cmf5kb.f │ │ ├── cmf5kf.f │ │ ├── cmfgkb.f │ │ ├── cmfgkf.f │ │ ├── cmfm1b.f │ │ ├── cmfm1f.f │ │ ├── cosq1b.f │ │ ├── cosq1f.f │ │ ├── cosq1i.f │ │ ├── cosqb1.f │ │ ├── cosqf1.f │ │ ├── cosqmb.f │ │ ├── cosqmf.f │ │ ├── cosqmi.f │ │ ├── cost1b.f │ │ ├── cost1f.f │ │ ├── cost1i.f │ │ ├── costb1.f │ │ ├── costf1.f │ │ ├── costmb.f │ │ ├── costmf.f │ │ ├── costmi.f │ │ ├── factor.f │ │ ├── fftpack5.lisp │ │ ├── fftpack5.pdf │ │ ├── mcfti1.f │ │ ├── mcsqb1.f │ │ ├── mcsqf1.f │ │ ├── mcstb1.f │ │ ├── mcstf1.f │ │ ├── mradb2.f │ │ ├── mradb3.f │ │ ├── mradb4.f │ │ ├── mradb5.f │ │ ├── mradbg.f │ │ ├── mradf2.f │ │ ├── mradf3.f │ │ ├── mradf4.f │ │ ├── mradf5.f │ │ ├── mradfg.f │ │ ├── mrftb1.f │ │ ├── mrftf1.f │ │ ├── mrfti1.f │ │ ├── msntb1.f │ │ ├── msntf1.f │ │ ├── r1f2kb.f │ │ ├── r1f2kf.f │ │ ├── r1f3kb.f │ │ ├── r1f3kf.f │ │ ├── r1f4kb.f │ │ ├── r1f4kf.f │ │ ├── r1f5kb.f │ │ ├── r1f5kf.f │ │ ├── r1fgkb.f │ │ ├── r1fgkf.f │ │ ├── rfft1b.f │ │ ├── rfft1f.f │ │ ├── rfft1i.f │ │ ├── rfft2b.f │ │ ├── rfft2f.f │ │ ├── rfft2i.f │ │ ├── rfftb1.f │ │ ├── rfftf1.f │ │ ├── rffti1.f │ │ ├── rfftmb.f │ │ ├── rfftmf.f │ │ ├── rfftmi.f │ │ ├── sinq1b.f │ │ ├── sinq1f.f │ │ ├── sinq1i.f │ │ ├── sinqmb.f │ │ ├── sinqmf.f │ │ ├── sinqmi.f │ │ ├── sint1b.f │ │ ├── sint1f.f │ │ ├── sint1i.f │ │ ├── sintb1.f │ │ ├── sintf1.f │ │ ├── sintmb.f │ │ ├── sintmf.f │ │ ├── sintmi.f │ │ ├── tables.f │ │ ├── xercon.f │ │ └── xerfft.f │ ├── fishpack.asd │ ├── fishpack.system │ ├── fishpack │ │ ├── .cvsignore │ │ ├── Makefile │ │ ├── blktr1.f │ │ ├── blktri.f │ │ ├── bsrh.f │ │ ├── chkpr4.f │ │ ├── chksn4.f │ │ ├── cofx.f │ │ ├── compb.f │ │ ├── cosgen.f │ │ ├── cprod.f │ │ ├── cprodp.f │ │ ├── defe4.f │ │ ├── dx4.f │ │ ├── dy4.f │ │ ├── epmach.f │ │ ├── ex │ │ │ ├── .cvsignore │ │ │ ├── cofx4.f │ │ │ ├── tsthstcrt.f │ │ │ ├── tsthstcsp.f │ │ │ ├── tsthstcyl.f │ │ │ ├── tsthstplr.f │ │ │ ├── tsthstssp.f │ │ │ ├── tsthw3crt.f │ │ │ ├── tsthwscrt.f │ │ │ ├── tsthwscsp.f │ │ │ ├── tsthwscyl.f │ │ │ ├── tsthwsplr.f │ │ │ ├── tsthwsssp.f │ │ │ └── tstsepx4.f │ │ ├── genbun.f │ │ ├── hstcrt.f │ │ ├── hstcs1.f │ │ ├── hstcsp.f │ │ ├── hstcyl.f │ │ ├── hstplr.f │ │ ├── hstssp.f │ │ ├── hw3crt.f │ │ ├── hwscrt.f │ │ ├── hwscs1.f │ │ ├── hwscsp.f │ │ ├── hwscyl.f │ │ ├── hwsplr.f │ │ ├── hwsss1.f │ │ ├── hwsssp.f │ │ ├── indxa.f │ │ ├── indxb.f │ │ ├── indxc.f │ │ ├── junk.f │ │ ├── merge.f │ │ ├── minso4.f │ │ ├── ortho4.f │ │ ├── pimach.f │ │ ├── pois3d.f │ │ ├── poisd2.f │ │ ├── poisn2.f │ │ ├── poisp2.f │ │ ├── poistg.f │ │ ├── pos3d1.f │ │ ├── postg2.f │ │ ├── ppadd.f │ │ ├── ppsgf.f │ │ ├── ppspf.f │ │ ├── prod.f │ │ ├── prodp.f │ │ ├── psgf.f │ │ ├── sepx4.f │ │ ├── speli4.f │ │ ├── store.f │ │ ├── tevls.f │ │ ├── tri3.f │ │ ├── trid.f │ │ ├── tris4.f │ │ ├── trix.f │ │ ├── tsthstcsp.out │ │ ├── tsthstcyl.out │ │ ├── tsthstplr.out │ │ ├── tsthstssp.out │ │ ├── tsthwscrt.out │ │ ├── tsthwscsp.out │ │ ├── tsthwscyl.out │ │ ├── tsthwsplr.out │ │ ├── tsthwsssp.out │ │ └── tstsepx4.out │ ├── hompack.system │ ├── hompack │ │ ├── .cvsignore │ │ ├── Makefile │ │ ├── dcpose.f │ │ ├── divp.f │ │ ├── f.f │ │ ├── ffunp.f │ │ ├── fixpdf.f │ │ ├── fixpds.f │ │ ├── fixpnf.f │ │ ├── fixpns.f │ │ ├── fixpqf.f │ │ ├── fixpqs.f │ │ ├── fjac.f │ │ ├── fjacs.f │ │ ├── fode.f │ │ ├── fodeds.f │ │ ├── gfunp.f │ │ ├── gmfads.f │ │ ├── hfun1p.f │ │ ├── hfunp.f │ │ ├── hompack-package.lisp │ │ ├── initp.f │ │ ├── innhp.dat │ │ ├── mainf.f │ │ ├── mainp.f │ │ ├── mains.f │ │ ├── mfacds.f │ │ ├── mulp.f │ │ ├── multds.f │ │ ├── otputp.f │ │ ├── pcgds.f │ │ ├── pcgns.f │ │ ├── pcgqs.f │ │ ├── polsys.f │ │ ├── polyp.f │ │ ├── powp.f │ │ ├── qimuds.f │ │ ├── qrfaqf.f │ │ ├── qrslqf.f │ │ ├── r1upqf.f │ │ ├── readme │ │ ├── ref-mainf.txt │ │ ├── ref-mainp.txt │ │ ├── ref-mains.txt │ │ ├── rho.f │ │ ├── rhoa.f │ │ ├── rhojac.f │ │ ├── rhojs.f │ │ ├── root.f │ │ ├── rootnf.f │ │ ├── rootns.f │ │ ├── rootqf.f │ │ ├── rootqs.f │ │ ├── sclgnp.f │ │ ├── sintrp.f │ │ ├── solvds.f │ │ ├── stepds.f │ │ ├── stepnf.f │ │ ├── stepns.f │ │ ├── stepqf.f │ │ ├── stepqs.f │ │ ├── steps.f │ │ ├── strptp.f │ │ ├── tangnf.f │ │ ├── tangns.f │ │ ├── tangqf.f │ │ ├── tangqs.f │ │ └── upqrqf.f │ ├── i1mach.lisp │ ├── lapack.system │ ├── lapack │ │ ├── .cvsignore │ │ ├── dbdsdc.f │ │ ├── dbdsqr.f │ │ ├── ddisna.f │ │ ├── dgebak.f │ │ ├── dgebal.f │ │ ├── dgebd2.f │ │ ├── dgebrd.f │ │ ├── dgeev.f │ │ ├── dgeevx.f │ │ ├── dgehd2.f │ │ ├── dgehrd.f │ │ ├── dgelq2.f │ │ ├── dgelqf.f │ │ ├── dgeqr2.f │ │ ├── dgeqrf.f │ │ ├── dgesdd.f │ │ ├── dgesv.f │ │ ├── dgesvd.f │ │ ├── dgetf2.f │ │ ├── dgetrf.f │ │ ├── dgetrs.f │ │ ├── dhseqr.f │ │ ├── dlabad.f │ │ ├── dlabrd.f │ │ ├── dlacon.f │ │ ├── dlacpy.f │ │ ├── dladiv.f │ │ ├── dlaed6.f │ │ ├── dlaexc.f │ │ ├── dlahqr.f │ │ ├── dlahrd.f │ │ ├── dlaln2.f │ │ ├── dlamch.f │ │ ├── dlamrg.f │ │ ├── dlange.f │ │ ├── dlanhs.f │ │ ├── dlanst.f │ │ ├── dlanv2.f │ │ ├── dlapy2.f │ │ ├── dlaqtr.f │ │ ├── dlarf.f │ │ ├── dlarfb.f │ │ ├── dlarfg.f │ │ ├── dlarft.f │ │ ├── dlarfx.f │ │ ├── dlartg.f │ │ ├── dlas2.f │ │ ├── dlascl.f │ │ ├── dlasd0.f │ │ ├── dlasd1.f │ │ ├── dlasd2.f │ │ ├── dlasd3.f │ │ ├── dlasd4.f │ │ ├── dlasd5.f │ │ ├── dlasd6.f │ │ ├── dlasd7.f │ │ ├── dlasd8.f │ │ ├── dlasda.f │ │ ├── dlasdq.f │ │ ├── dlasdt.f │ │ ├── dlaset.f │ │ ├── dlasq1.f │ │ ├── dlasq2.f │ │ ├── dlasq3.f │ │ ├── dlasq4.f │ │ ├── dlasq5.f │ │ ├── dlasq6.f │ │ ├── dlasr.f │ │ ├── dlasrt.f │ │ ├── dlassq.f │ │ ├── dlasv2.f │ │ ├── dlaswp.f │ │ ├── dlasy2.f │ │ ├── dorg2r.f │ │ ├── dorgbr.f │ │ ├── dorghr.f │ │ ├── dorgl2.f │ │ ├── dorglq.f │ │ ├── dorgqr.f │ │ ├── dorm2r.f │ │ ├── dormbr.f │ │ ├── dorml2.f │ │ ├── dormlq.f │ │ ├── dormqr.f │ │ ├── dtrevc.f │ │ ├── dtrexc.f │ │ ├── dtrsna.f │ │ ├── ieeeck.f │ │ ├── ilaenv.f │ │ ├── lapack-package.lisp │ │ └── lapack-tests.lisp │ ├── machar.lisp │ ├── minpack.system │ ├── minpack │ │ ├── .cvsignore │ │ ├── Makefile │ │ ├── chkder.f │ │ ├── dogleg.f │ │ ├── dpmpar.f │ │ ├── enorm.f │ │ ├── examples.lisp │ │ ├── fdjac1.f │ │ ├── fdjac2.f │ │ ├── hybrd-input.dat │ │ ├── hybrd-ref.txt │ │ ├── hybrd.f │ │ ├── hybrd1.f │ │ ├── hybrj.f │ │ ├── hybrj1.f │ │ ├── lmder-ref.txt │ │ ├── lmder.f │ │ ├── lmder1.f │ │ ├── lmdif-input.dat │ │ ├── lmdif-ref.txt │ │ ├── lmdif.f │ │ ├── lmdif1.f │ │ ├── lmpar.f │ │ ├── lmstr.f │ │ ├── lmstr1.f │ │ ├── minpack.doc │ │ ├── minpack.lisp │ │ ├── minpack.txt │ │ ├── qform.f │ │ ├── qrfac.f │ │ ├── qrsolv.f │ │ ├── r1mpyq.f │ │ ├── r1updt.f │ │ ├── readme │ │ ├── run-minpack-tests.lisp │ │ ├── rwupdt.f │ │ ├── tst-hybrd.f │ │ ├── tst-lmder.f │ │ └── tst-lmdif.f │ ├── odepack.system │ ├── odepack │ │ ├── .cvsignore │ │ ├── Makefile │ │ ├── adjlr.f │ │ ├── ccout-lsodpk.out │ │ ├── cdrv.f │ │ ├── cntnzu.f │ │ ├── daigbt.f │ │ ├── dainvg.f │ │ ├── dainvgs.f │ │ ├── datp.f │ │ ├── datv.f │ │ ├── daxpy.f │ │ ├── dbnorm.f │ │ ├── dcfode.f │ │ ├── dcopy.f │ │ ├── ddecbt.f │ │ ├── ddot.f │ │ ├── demo-lsoda.out │ │ ├── demo-lsodar.out │ │ ├── demo-lsode.out │ │ ├── demo-lsodi.out │ │ ├── demo-lsodis.out │ │ ├── demo-lsodkr.out │ │ ├── demo-lsodpk.out │ │ ├── demo-lsoibt.out │ │ ├── demo1 │ │ │ ├── .cvsignore │ │ │ ├── edit2.f │ │ │ ├── f1.f │ │ │ ├── f2.f │ │ │ ├── jac1.f │ │ │ ├── jac2.f │ │ │ └── opkdemo1.f │ │ ├── demo3 │ │ │ ├── .cvsignore │ │ │ ├── edit2.f │ │ │ ├── f1.f │ │ │ ├── f2.f │ │ │ ├── jac1.f │ │ │ ├── jac2.f │ │ │ └── opkdemo3.f │ │ ├── demo4 │ │ │ ├── .cvsignore │ │ │ ├── f1.f │ │ │ ├── f2.f │ │ │ ├── gr1.f │ │ │ ├── gr2.f │ │ │ ├── jac2.f │ │ │ └── opkdemo4.f │ │ ├── demo5 │ │ │ ├── .cvsignore │ │ │ ├── cinit.f │ │ │ ├── fbg.f │ │ │ ├── fweb.f │ │ │ ├── gs.f │ │ │ ├── gset.f │ │ │ ├── jacbg.f │ │ │ ├── opkdemo5.f │ │ │ ├── outweb.f │ │ │ ├── setpar.f │ │ │ ├── solsbg.f │ │ │ └── webr.f │ │ ├── demo7 │ │ │ ├── .cvsignore │ │ │ ├── addabd.f │ │ │ ├── addafl.f │ │ │ ├── elkup.f │ │ │ ├── gfun.f │ │ │ ├── jacbd.f │ │ │ ├── jacfl.f │ │ │ ├── opkdemo7.f │ │ │ └── res.f │ │ ├── demo8 │ │ │ ├── .cvsignore │ │ │ ├── addabt.f │ │ │ ├── edit.f │ │ │ ├── gfun.f │ │ │ ├── jacbt.f │ │ │ ├── maxerr.f │ │ │ ├── opkdemo8.f │ │ │ ├── res.f │ │ │ ├── setic.f │ │ │ └── subav.f │ │ ├── dewset.f │ │ ├── dfnorm.f │ │ ├── dgbfa.f │ │ ├── dgbsl.f │ │ ├── dgefa.f │ │ ├── dgesl.f │ │ ├── dhefa.f │ │ ├── dhels.f │ │ ├── dheqr.f │ │ ├── dhesl.f │ │ ├── dintdy.f │ │ ├── diprep.f │ │ ├── diprepi.f │ │ ├── dlhin.f │ │ ├── dlsoda.f │ │ ├── dlsodar.f │ │ ├── dlsode.f │ │ ├── dlsodes.f │ │ ├── dlsodi.f │ │ ├── dlsodis.f │ │ ├── dlsodkr.f │ │ ├── dlsodpk.f │ │ ├── dlsoibt.f │ │ ├── dmnorm.f │ │ ├── dnrm2.f │ │ ├── dorthog.f │ │ ├── dpcg.f │ │ ├── dpcgs.f │ │ ├── dpjibt.f │ │ ├── dpkset.f │ │ ├── dprep.f │ │ ├── dprepi.f │ │ ├── dprepj.f │ │ ├── dprepji.f │ │ ├── dprja.f │ │ ├── dprjis.f │ │ ├── dprjs.f │ │ ├── drchek.f │ │ ├── droots.f │ │ ├── dscal.f │ │ ├── dsetpk.f │ │ ├── dslsbt.f │ │ ├── dsolbt.f │ │ ├── dsolpk.f │ │ ├── dsolss.f │ │ ├── dsolsy.f │ │ ├── dspigmr.f │ │ ├── dspiom.f │ │ ├── dsrcar.f │ │ ├── dsrckr.f │ │ ├── dsrcma.f │ │ ├── dsrcms.f │ │ ├── dsrcom.f │ │ ├── dsrcpk.f │ │ ├── dstoda.f │ │ ├── dstode.f │ │ ├── dstodi.f │ │ ├── dstodpk.f │ │ ├── dstoka.f │ │ ├── dumach.f │ │ ├── dumsum.f │ │ ├── dusol.f │ │ ├── dvnorm.f │ │ ├── idamax.f │ │ ├── iumach.f │ │ ├── ixsav.f │ │ ├── jgroup.f │ │ ├── md.f │ │ ├── mdi.f │ │ ├── mdm.f │ │ ├── mdp.f │ │ ├── mdu.f │ │ ├── nnfc.f │ │ ├── nnsc.f │ │ ├── nntc.f │ │ ├── nroc.f │ │ ├── nsfc.f │ │ ├── odrv.f │ │ ├── opkd-sum │ │ ├── opkddemos │ │ ├── opkdemo1.f │ │ ├── opkdemo2.f │ │ ├── opkdemo3.f │ │ ├── opkdemo4.f │ │ ├── opkdemo5.f │ │ ├── opkdemo6.f │ │ ├── opkdemo7.f │ │ ├── opkdemo8.f │ │ ├── opkdemo9.f │ │ ├── sro.f │ │ ├── xerrwd.f │ │ ├── xsetf.f │ │ └── xsetun.f │ ├── quadpack.system │ ├── quadpack │ │ ├── .cvsignore │ │ ├── Fortran │ │ │ ├── .cvsignore │ │ │ ├── d1mach.f │ │ │ ├── dgtsl.f │ │ │ ├── dqag.f │ │ │ ├── dqage.f │ │ │ ├── dqagi.f │ │ │ ├── dqagie.f │ │ │ ├── dqagpe.f │ │ │ ├── dqags.f │ │ │ ├── dqagse.f │ │ │ ├── dqawc.f │ │ │ ├── dqawce.f │ │ │ ├── dqawf.f │ │ │ ├── dqawfe.f │ │ │ ├── dqawo.f │ │ │ ├── dqawoe.f │ │ │ ├── dqaws.f │ │ │ ├── dqawse.f │ │ │ ├── dqc25c.f │ │ │ ├── dqc25f.f │ │ │ ├── dqc25s.f │ │ │ ├── dqcheb.f │ │ │ ├── dqelg.f │ │ │ ├── dqk15.f │ │ │ ├── dqk15i.f │ │ │ ├── dqk15w.f │ │ │ ├── dqk21.f │ │ │ ├── dqk31.f │ │ │ ├── dqk41.f │ │ │ ├── dqk51.f │ │ │ ├── dqk61.f │ │ │ ├── dqmomo.f │ │ │ ├── dqng.f │ │ │ ├── dqpsrt.f │ │ │ ├── dqwgtc.f │ │ │ ├── dqwgtf.f │ │ │ ├── dqwgts.f │ │ │ ├── i1mach.f │ │ │ └── xerror.f │ │ ├── Makefile │ │ ├── README │ │ ├── quadpack-tests.lisp │ │ ├── test1.f │ │ ├── test1.out │ │ ├── test12.f │ │ ├── test12.out │ │ ├── test14.f │ │ ├── test14.out │ │ ├── test15.f │ │ ├── test15.out │ │ ├── test2.f │ │ ├── test2.out │ │ ├── test3.f │ │ ├── test3.out │ │ ├── test4.f │ │ ├── test4.out │ │ ├── test5.f │ │ ├── test5.out │ │ ├── test6.f │ │ ├── test6.out │ │ ├── test7.f │ │ ├── test7.out │ │ ├── test9.f │ │ ├── test9.out │ │ └── tst-dqagse.lisp │ ├── toms │ │ ├── 419 │ │ │ ├── .cvsignore │ │ │ ├── Makefile │ │ │ ├── calct.f │ │ │ ├── cauchy.f │ │ │ ├── cdivid.f │ │ │ ├── cmod.f │ │ │ ├── cpoly.f │ │ │ ├── cpolydr.f │ │ │ ├── cpolydr.out │ │ │ ├── errev.f │ │ │ ├── fxshft.f │ │ │ ├── mcon.f │ │ │ ├── nexth.f │ │ │ ├── noshft.f │ │ │ ├── polyev.f │ │ │ ├── prtc.f │ │ │ ├── prtz.f │ │ │ ├── scale.f │ │ │ └── vrshft.f │ │ ├── 715 │ │ │ ├── .cvsignore │ │ │ ├── Makefile │ │ │ ├── algtst.f │ │ │ ├── algtst.out │ │ │ ├── anorm.f │ │ │ ├── anrtst.f │ │ │ ├── anrtst.out │ │ │ ├── besei0.f │ │ │ ├── besei1.f │ │ │ ├── besek0.f │ │ │ ├── besek1.f │ │ │ ├── besi0.f │ │ │ ├── besi1.f │ │ │ ├── besj0.f │ │ │ ├── besj1.f │ │ │ ├── besk0.f │ │ │ ├── besk1.f │ │ │ ├── besy0.f │ │ │ ├── besy1.f │ │ │ ├── calcei.f │ │ │ ├── calci0.f │ │ │ ├── calci1.f │ │ │ ├── calck0.f │ │ │ ├── calck1.f │ │ │ ├── calerf.f │ │ │ ├── caljy0.f │ │ │ ├── caljy1.f │ │ │ ├── daw.f │ │ │ ├── dawtst.f │ │ │ ├── dawtst.out │ │ │ ├── derf.f │ │ │ ├── derfc.f │ │ │ ├── derfcx.f │ │ │ ├── dgamma.f │ │ │ ├── dlgama.f │ │ │ ├── dsubn.f │ │ │ ├── ei.f │ │ │ ├── eitest.f │ │ │ ├── eitest.out │ │ │ ├── eone.f │ │ │ ├── erftst.f │ │ │ ├── erftst.out │ │ │ ├── expei.f │ │ │ ├── gamtst.f │ │ │ ├── gamtst.out │ │ │ ├── i0test.f │ │ │ ├── i0test.out │ │ │ ├── i1test.f │ │ │ ├── i1test.out │ │ │ ├── j0test.f │ │ │ ├── j0test.out │ │ │ ├── j1test.f │ │ │ ├── j1test.out │ │ │ ├── k0test.f │ │ │ ├── k0test.out │ │ │ ├── k1test.f │ │ │ ├── k1test.out │ │ │ ├── machar.f │ │ │ ├── psi.f │ │ │ ├── psitst.f │ │ │ ├── psitst.out │ │ │ ├── ren.f │ │ │ ├── ribesl.f │ │ │ ├── ritest.f │ │ │ ├── ritest.out │ │ │ ├── rjbesl.f │ │ │ ├── rjtest.f │ │ │ ├── rjtest.out │ │ │ ├── rkbesl.f │ │ │ ├── rktest.f │ │ │ ├── rktest.out │ │ │ ├── rybesl.f │ │ │ ├── rytest.f │ │ │ ├── rytest.out │ │ │ ├── y0test.f │ │ │ ├── y0test.out │ │ │ ├── y1test.f │ │ │ └── y1test.out │ │ ├── 717 │ │ │ ├── .cvsignore │ │ │ ├── README │ │ │ ├── alnorm.f │ │ │ ├── brj.f │ │ │ ├── brj1.f │ │ │ ├── chkder.f │ │ │ ├── cnerr.f │ │ │ ├── d1mach.f │ │ │ ├── da7sst.f │ │ │ ├── daganzo.fu2 │ │ │ ├── dd7mlp.f │ │ │ ├── dd7tpr.f │ │ │ ├── dd7up5.f │ │ │ ├── devian.f │ │ │ ├── df7dhb.f │ │ │ ├── df7hes.f │ │ │ ├── dg2lrd.f │ │ │ ├── dg7itb.f │ │ │ ├── dg7lit.f │ │ │ ├── dg7qsb.f │ │ │ ├── dg7qts.f │ │ │ ├── dgletc.f │ │ │ ├── dglf.f │ │ │ ├── dglfb │ │ │ ├── dglfb.f │ │ │ ├── dglfg.f │ │ │ ├── dglfgb.f │ │ │ ├── dglg.f │ │ │ ├── dglgb │ │ │ ├── dglgb.f │ │ │ ├── dh2rfa.f │ │ │ ├── dh2rfg.f │ │ │ ├── ditsum.f │ │ │ ├── divset.f │ │ │ ├── dl7itv.f │ │ │ ├── dl7ivm.f │ │ │ ├── dl7msb.f │ │ │ ├── dl7mst.f │ │ │ ├── dl7nvr.f │ │ │ ├── dl7sqr.f │ │ │ ├── dl7srt.f │ │ │ ├── dl7svn.f │ │ │ ├── dl7svx.f │ │ │ ├── dl7tsq.f │ │ │ ├── dl7tvm.f │ │ │ ├── dl7vml.f │ │ │ ├── dmdc.f │ │ │ ├── dmdc.f0 │ │ │ ├── dn3rdp.f │ │ │ ├── do7prd.f │ │ │ ├── dparck.f │ │ │ ├── dpmain.f │ │ │ ├── dq7adr.f │ │ │ ├── dq7rsh.f │ │ │ ├── drglg.f │ │ │ ├── drglgb.f │ │ │ ├── drldst.f │ │ │ ├── ds7bqn.f │ │ │ ├── ds7dmp.f │ │ │ ├── ds7ipr.f │ │ │ ├── ds7lup.f │ │ │ ├── ds7lvm.f │ │ │ ├── dv2axy.f │ │ │ ├── dv2nrm.f │ │ │ ├── dv7cpy.f │ │ │ ├── dv7dfl.f │ │ │ ├── dv7ipr.f │ │ │ ├── dv7scl.f │ │ │ ├── dv7scp.f │ │ │ ├── dv7shf.f │ │ │ ├── dv7vmp.f │ │ │ ├── dvsum.f │ │ │ ├── dzero.f │ │ │ ├── example-sae.c │ │ │ ├── example-sse.c │ │ │ ├── example.c │ │ │ ├── f2c.h │ │ │ ├── fort.2 │ │ │ ├── i7copy.f │ │ │ ├── i7pnvr.f │ │ │ ├── i7shft.f │ │ │ ├── invcn.f │ │ │ ├── louchk.f │ │ │ ├── lpn.f │ │ │ ├── madrj.f │ │ │ ├── madsen.diff │ │ │ ├── madsen.f │ │ │ ├── madsen.out │ │ │ ├── madsen.sgi │ │ │ ├── madsenb.c │ │ │ ├── madsenb.f │ │ │ ├── madsenb.out │ │ │ ├── madsenb.sgi │ │ │ ├── makefile │ │ │ ├── mecdf.f │ │ │ ├── mlmnp.f │ │ │ ├── mlmnpb.f │ │ │ ├── mnpex1.fu1 │ │ │ ├── mnpex1.out │ │ │ ├── mnpex1.sgi │ │ │ ├── mnpex1b.out │ │ │ ├── mnpex1b.sgi │ │ │ ├── mnpex2.fu1 │ │ │ ├── mnpex2.sgi │ │ │ ├── mnpex2b.sgi │ │ │ ├── mnpsubs.f │ │ │ ├── phi.f │ │ │ ├── pmain.f │ │ │ ├── pmain.in │ │ │ ├── pmain.out │ │ │ ├── pmain.sgi │ │ │ ├── pnorms.f │ │ │ ├── poisx0.f │ │ │ ├── poix0.f │ │ │ ├── pregrh.f │ │ │ ├── pregrv.f │ │ │ ├── prgrh1.f │ │ │ ├── rent.fu2 │ │ │ ├── rent1.fu1 │ │ │ ├── rent1.sgi │ │ │ ├── rent1b.sgi │ │ │ ├── rent2.fu1 │ │ │ ├── rent2.sgi │ │ │ ├── rent2b.sgi │ │ │ ├── rhols.f │ │ │ ├── rhpoil.f │ │ │ ├── rpoil0.f │ │ │ ├── sgletc.f │ │ │ ├── sglfg.f │ │ │ ├── sglfgb.f │ │ │ ├── smadsen.f │ │ │ ├── smadsen.sgi │ │ │ ├── smadsenb.f │ │ │ ├── smadsenb.sgi │ │ │ ├── smdc.f0 │ │ │ ├── smecdf.f │ │ │ ├── smlmnp.f │ │ │ ├── smlmnpb.f │ │ │ ├── smnpex1.sgi │ │ │ ├── smnpex1b.sgi │ │ │ ├── smnpex2.sgi │ │ │ ├── smnpex2b.sgi │ │ │ ├── smnpsubs.f │ │ │ ├── spmain.f │ │ │ ├── spmain.sgi │ │ │ ├── srent1.sgi │ │ │ ├── srent1b.sgi │ │ │ ├── srent2.sgi │ │ │ ├── srent2b.sgi │ │ │ └── stopx.f │ │ └── .cvsignore │ ├── toms419.system │ ├── toms715.system │ └── toms717.system ├── src │ ├── .cvsignore │ ├── NOTES │ ├── f2cl0.l │ ├── f2cl1.l │ ├── f2cl2.l │ ├── f2cl3.l │ ├── f2cl4.l │ ├── f2cl5.l │ ├── f2cl6.l │ ├── f2cl7.l │ ├── f2cl8.l │ └── macros.l └── val │ ├── .cvsignore │ ├── README │ ├── arithIFtest.for │ ├── commontest.for │ ├── dbrent.for │ ├── dotest.for │ ├── equiv.f │ ├── formattest.for │ ├── fort.1 │ ├── h03abf.for │ ├── jacobi.for │ ├── kendl1.for │ ├── la05.for │ ├── mi10mach.for │ ├── mi50lp.for │ ├── nars.for │ ├── open.f │ ├── rtflsp.for │ ├── rtnewt.for │ ├── savetest.for │ ├── simpletest.for │ ├── solvde.for │ ├── stmtfntest.for │ ├── subprogtest.for │ ├── test.out │ ├── tst-char-init.f │ ├── tst-char.f │ ├── tst-fixups.f │ ├── tst-init.f │ ├── tst-number.f │ ├── tst-parse.f │ ├── tst-slice.f │ └── twofft.for ├── games └── cil │ ├── Makefile │ ├── README │ ├── cil.asd │ ├── cil.lisp │ ├── copyright │ └── debian │ ├── README.debian │ ├── changelog │ ├── compat │ ├── control │ ├── copyright │ ├── dirs │ ├── examples │ ├── links │ ├── postinst │ ├── postrm │ ├── preinst │ ├── prerm │ └── rules ├── gui ├── clue │ ├── Makefile │ ├── README │ ├── README.pw │ ├── build.lisp │ ├── clio-examples.system │ ├── clio.asd │ ├── clio.system │ ├── clio │ │ ├── README │ │ ├── buffer.lisp │ │ ├── buttons.lisp │ │ ├── choices.lisp │ │ ├── clio.lisp │ │ ├── command.lisp │ │ ├── confirm.lisp │ │ ├── core-mixins.lisp │ │ ├── defgeneric.lisp │ │ ├── defsystem.lisp │ │ ├── display-imag.lisp │ │ ├── display-text.lisp │ │ ├── dlog-button.lisp │ │ ├── doc │ │ │ ├── clio.index │ │ │ ├── clio.ps │ │ │ ├── clio.tex │ │ │ ├── release.1-0 │ │ │ └── text-cmds.text │ │ ├── edit-text.lisp │ │ ├── examples │ │ │ ├── cmd-frame.lisp │ │ │ ├── defsystem.lisp │ │ │ ├── package.lisp │ │ │ ├── sketch.lisp │ │ │ └── sketchpad.lisp │ │ ├── form.lisp │ │ ├── gravity.lisp │ │ ├── mchoices.lisp │ │ ├── menu.lisp │ │ ├── ol-defs.lisp │ │ ├── ol-images.lisp │ │ ├── precom.lisp │ │ ├── psheet.lisp │ │ ├── scroll-frame.lisp │ │ ├── scroller.lisp │ │ ├── slider.lisp │ │ ├── table.lisp │ │ ├── text-command.lisp │ │ └── utility.lisp │ ├── clue.asd │ ├── clue.system │ ├── clue │ │ ├── README │ │ ├── README.pw │ │ ├── caches.lisp │ │ ├── clos-patch.lisp │ │ ├── clue.lisp │ │ ├── clx-patch.lisp │ │ ├── cursor.lisp │ │ ├── defcontact.lisp │ │ ├── defgeneric.lisp │ │ ├── defsys.lisp │ │ ├── defsystem.lisp │ │ ├── doc │ │ │ ├── clue.index │ │ │ ├── clue.ps │ │ │ ├── clue.tex │ │ │ ├── examples.text │ │ │ ├── release.7-1 │ │ │ ├── release.7-20 │ │ │ ├── turbo-clue.index │ │ │ ├── turbo-clue.ps │ │ │ └── turbo-clue.tex │ │ ├── event-parse.lisp │ │ ├── events.lisp │ │ ├── examples │ │ │ └── menu.lisp │ │ ├── gray.lisp │ │ ├── intrinsics.lisp │ │ ├── obsolete.l │ │ ├── package.lisp │ │ ├── pcl-fixes.l │ │ ├── precom.lisp │ │ ├── resource.lisp │ │ ├── root-gmgmt.lisp │ │ ├── shells.lisp │ │ ├── stream.lisp │ │ ├── virtual.lisp │ │ └── window-doc.lisp │ ├── debian │ │ ├── README.debian │ │ ├── changelog │ │ ├── control │ │ ├── copyright │ │ ├── dirs │ │ ├── docs │ │ ├── examples │ │ ├── links │ │ ├── postinst │ │ ├── postrm │ │ ├── prerm │ │ └── rules │ ├── defsys.lisp │ ├── make-subsystems.lisp │ ├── manual.lisp │ ├── new-build.lisp │ ├── patch.lisp │ ├── pictures.asd │ ├── pictures.system │ ├── pictures │ │ ├── README │ │ ├── README.pw │ │ ├── RELEASE │ │ ├── bspline.lisp │ │ ├── circle.lisp │ │ ├── class-def.lisp │ │ ├── defgeneric.lisp │ │ ├── defsystem.lisp │ │ ├── doc │ │ │ ├── pictures.ps │ │ │ ├── pictures.rtf │ │ │ └── pictures.text │ │ ├── edge.lisp │ │ ├── ellipse.lisp │ │ ├── examples │ │ │ ├── road-demo.lisp │ │ │ └── road-demo.lisp.CKP │ │ ├── extent.lisp │ │ ├── fdefsystem.lisp │ │ ├── font-family.lisp │ │ ├── gevents.lisp │ │ ├── gimage.lisp │ │ ├── grabber.lisp │ │ ├── graphic.lisp │ │ ├── gstack.lisp │ │ ├── gstate.lisp │ │ ├── header.lisp │ │ ├── label.lisp │ │ ├── line.lisp │ │ ├── macros.lisp │ │ ├── package.lisp │ │ ├── picture.lisp │ │ ├── polygon.lisp │ │ ├── polypoint.lisp │ │ ├── precom.lisp │ │ ├── rectangle.lisp │ │ ├── restore.lisp │ │ ├── save.lisp │ │ ├── scene.lisp │ │ ├── sequence.lisp │ │ ├── transform.lisp │ │ ├── transform.lisp.CKP │ │ ├── transform.lisp.sav │ │ ├── types.lisp │ │ ├── utilities.lisp │ │ ├── view-draw.lisp │ │ ├── view-events.lisp │ │ ├── view-pan.lisp │ │ ├── view-select.lisp │ │ ├── view-zoom.lisp │ │ └── view.lisp │ ├── sysdef.lisp │ └── viewit.lisp └── clx │ ├── CHANGELOG │ ├── Makefile │ ├── README │ ├── RELEASE-NOTES │ ├── attributes.lisp │ ├── buffer.lisp │ ├── bufmac.lisp │ ├── clx-vm │ ├── bsd-sockets.lisp │ ├── clx-vm.asd │ ├── comm-ext │ │ ├── LICENSE.txt │ │ ├── Makefile │ │ ├── README.txt │ │ ├── comm-ext.lisp │ │ ├── comm_ext.c │ │ ├── defsys.lisp │ │ └── package.lisp │ ├── package.lisp │ ├── sockets.lisp │ ├── threading-tests.lisp │ ├── threading-utils.lisp │ ├── threading.lisp │ └── unix-sockets.lisp │ ├── clx.asd │ ├── clx.lisp │ ├── clx.system │ ├── compile-and-load.lisp │ ├── debug │ ├── debug.lisp │ ├── describe.lisp │ ├── event-test.lisp │ ├── keytrans.lisp │ ├── trace.lisp │ └── util.lisp │ ├── demo │ ├── bezier.lisp │ ├── beziertest.lisp │ ├── hello.lisp │ ├── menu.lisp │ ├── qix.lisp │ ├── shape-test.lisp │ └── zoid.lisp │ ├── depdefs.lisp │ ├── dependent.lisp │ ├── display.lisp │ ├── doc.lisp │ ├── docs │ ├── MAKEDIST │ ├── Makefile │ ├── README │ ├── clex.lisp │ ├── clxman.lisp │ ├── docIndex │ │ ├── DocIndexApplet.java │ │ ├── Index.java │ │ └── XlibIndex.java │ ├── dtd.lisp │ ├── lalr.lisp │ ├── run.lisp │ ├── sgml-lex.lisp │ ├── sgml-parse.lisp │ ├── sgml-unparse.lisp │ └── source │ │ ├── clxman.css │ │ ├── clxman.dtd │ │ └── clxman.sgml │ ├── fonts.lisp │ ├── gcontext.lisp │ ├── graphics.lisp │ ├── image.lisp │ ├── input.lisp │ ├── keysyms.lisp │ ├── macros.lisp │ ├── manager.lisp │ ├── package.lisp │ ├── requests.lisp │ ├── resource.lisp │ ├── shape.lisp │ ├── test │ ├── image.lisp │ └── trapezoid.lisp │ ├── text.lisp │ └── translate.lisp ├── io └── xp │ ├── xp-code.lisp │ ├── xp-doc.txt │ ├── xp-test.lisp │ ├── xpx-code.lisp │ └── xpx-test.lisp ├── onlisp ├── README ├── onlisp-app.lisp ├── onlisp-util.lisp └── package.lisp ├── port ├── .cvsignore ├── Makefile ├── configuration │ ├── COPYING │ ├── ChangeLog │ ├── INSTALLATION │ ├── NOTES │ ├── README │ ├── configuration-template-impl.lisp │ ├── configuration-template.lisp │ ├── configuration.lisp │ ├── defconf-package.lisp │ ├── defconf.conf │ ├── defconf.lisp │ ├── defconf.system │ ├── docs │ │ └── tex │ │ │ └── defconf.tex │ ├── impl-dependent │ │ ├── allegro.lisp │ │ ├── clisp.lisp │ │ ├── cmucl.lisp │ │ ├── defsys-availability.lisp │ │ ├── genera.lisp │ │ ├── lispworks.lisp │ │ ├── mac-os.lisp │ │ ├── mk-defsystem.lisp │ │ ├── ms-dos.lisp │ │ ├── pcl-defsys.lisp │ │ ├── unix.lisp │ │ └── windows.lisp │ ├── load-cl-configuration.lisp │ └── tests │ │ ├── defconf-test-1.lisp │ │ └── defconf-test-2.lisp ├── environment │ ├── COPYING │ ├── ChangeLog │ ├── INSTALLATION │ ├── README │ ├── env-package.lisp │ ├── env.system │ ├── environment.lisp │ ├── feature-tagged-type-class.lisp │ ├── impl-dependent │ │ ├── allegro.lisp │ │ ├── clisp.lisp │ │ ├── cmucl.lisp │ │ ├── corman.lisp │ │ ├── lcl.lisp │ │ ├── lispworks.lisp │ │ └── sbcl.lisp │ ├── init-environment.lisp │ ├── load-cl-environment.lisp │ ├── machine.lisp │ ├── operating-system.lisp │ ├── software.lisp │ ├── system-info.lisp │ └── utilities.lisp ├── ext.lisp ├── gray.lisp ├── mop.lisp ├── net.lisp ├── path.lisp ├── port.html ├── port.system ├── proc.lisp ├── shell.lisp └── sys.lisp ├── screamer ├── FAQ ├── Makefile ├── README ├── doc │ ├── aaai93.dvi │ ├── aaai93.ps │ ├── ircs-93-03.dvi │ ├── ircs-93-03.ps │ ├── screamer.dvi │ └── screamer.ps ├── equations.lisp ├── iscream.el ├── iterate.lisp ├── primordial.lisp ├── screamer.lisp ├── screamer.system └── screams.lisp ├── syntax └── typedecl │ └── typedvar.lisp ├── tools ├── ansi-test │ ├── .cvsignore │ ├── GNU-GPL │ ├── Makefile │ ├── README │ ├── alltest.lisp │ ├── array.lisp │ ├── backquot.lisp │ ├── characters.lisp │ ├── clisp-known-errors │ ├── clos.lisp │ ├── cmucl-bugs.lisp │ ├── cmucl-normal-known-errors │ ├── cmucl-safe-known-errors │ ├── cmucl-small-known-errors │ ├── compile-bug1.lisp │ ├── compile-bug2.lisp │ ├── compile-bug3.lisp │ ├── compile-bug4.lisp │ ├── compile-bug4nt.lisp │ ├── compile-bug5.lisp │ ├── compile-bug6.lisp │ ├── conditions.lisp │ ├── eval20.lisp │ ├── excepsit.lisp │ ├── format.lisp │ ├── hash.lisp │ ├── hashlong.lisp │ ├── iofkts.lisp │ ├── lambda.lisp │ ├── lists151.lisp │ ├── lists152.lisp │ ├── lists153.lisp │ ├── lists154.lisp │ ├── lists155.lisp │ ├── lists156.lisp │ ├── loop.lisp │ ├── macro8.lisp │ ├── make-load-form-demo.lisp │ ├── map.lisp │ ├── mop.lisp │ ├── new-bugs.lisp │ ├── number.lisp │ ├── number2.lisp │ ├── path.lisp │ ├── readtable.lisp │ ├── sbcl-known-errors │ ├── section10.lisp │ ├── section11.lisp │ ├── section12.lisp │ ├── section13.lisp │ ├── section14.lisp │ ├── section15.lisp │ ├── section16.lisp │ ├── section17.lisp │ ├── section18-errors.lisp │ ├── section18.lisp │ ├── section19.lisp │ ├── section2.lisp │ ├── section20.lisp │ ├── section21.lisp │ ├── section22.lisp │ ├── section3.lisp │ ├── section4.lisp │ ├── section5.lisp │ ├── section6.lisp │ ├── section7.lisp │ ├── section8.lisp │ ├── section9.lisp │ ├── setf.lisp │ ├── steele7.lisp │ ├── streams.lisp │ ├── streamslong.lisp │ ├── strings.lisp │ ├── symbol10.lisp │ ├── symbols.lisp │ ├── symboltest.lisp │ ├── tests.lisp │ ├── type.lisp │ └── unix-tests.lisp ├── clunit │ ├── Makefile │ ├── clunit.html │ ├── clunit.lisp │ └── clunit.system ├── memoization │ ├── Makefile │ ├── Memo-Tables │ │ └── fib.lisp │ ├── debian │ │ ├── README.debian │ │ ├── changelog │ │ ├── control │ │ ├── copyright │ │ ├── dirs │ │ ├── docs │ │ ├── links │ │ ├── postinst │ │ ├── postrm │ │ ├── preinst │ │ ├── prerm │ │ └── rules │ ├── docs │ │ ├── Memoization-Overview.text │ │ ├── Memoization-Posting.text │ │ ├── Monterrey-Memoization.ps │ │ └── README │ ├── load-memoization.lisp │ ├── memoization-examples.lisp │ ├── memoization.asd │ ├── memoization.lisp │ ├── package.lisp │ └── save-memo-table.lisp └── metering │ ├── .cvsignore │ ├── 0.doc │ ├── Makefile │ ├── PORTS │ ├── metering.lisp │ ├── metering.system │ └── metering.txt └── ytools ├── .cvsignore ├── CHANGELOG ├── COPYING ├── base-x6.lisp ├── base.lisp ├── binders.lisp ├── bq.lisp ├── chunk.lisp ├── chunktest.lisp ├── datafun.lisp ├── debug-new.lisp ├── debug.lisp ├── depend.lisp ├── filedeps.lisp ├── files.lisp ├── fileseg.lisp ├── filetest.lisp ├── fload.lisp ├── mapper.lisp ├── misc.lisp ├── module.lisp ├── multilet.lisp ├── multvalhacks.lisp ├── nilscompat.lisp ├── object.lisp ├── outin.lisp ├── pathname.lisp ├── repeat-new.lisp ├── repeat.lisp ├── repl.lisp ├── setter.lisp ├── signal.lisp ├── slurp.lisp ├── slurptest.dat ├── slurptest.lisp ├── tracearound.lisp ├── util.lisp ├── ytcopy.lisp ├── ytload ├── raw-ytfm-load.lisp ├── ytfm.lmd ├── ytload.lisp └── ytools.lmd ├── ytools.lsy └── ytools.system /.cvsignore: -------------------------------------------------------------------------------- 1 | ChangeLog 2 | -------------------------------------------------------------------------------- /bin/lisp-file: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | # find the lisp file with the given stem 3 | 4 | file=`echo $1 | sed 's/\\.[^.]*$//'`; 5 | 6 | if [ -f $file.lisp ]; then echo $file.lisp; 7 | elif [ -f $file.lsp ]; then echo $file.lsp; 8 | elif [ -f $file.l ]; then echo $file.l; 9 | elif [ -f $file ]; then echo $file; 10 | elif [ -f $1 ]; then echo $1; 11 | else echo "$0: cannot figure out lisp file from $1 ($file)" 1>&2; exit 1; 12 | fi 13 | -------------------------------------------------------------------------------- /src/cllib/.cvsignore: -------------------------------------------------------------------------------- 1 | ChangeLog 2 | cllib.list 3 | auto.lisp 4 | -------------------------------------------------------------------------------- /src/defsystem-3.x/.cvsignore: -------------------------------------------------------------------------------- 1 | ChangeLog 2 | -------------------------------------------------------------------------------- /src/defsystem-3.x/debian/README.Debian: -------------------------------------------------------------------------------- 1 | Debian Package cl-defsystem3 2 | ---------------------------- 3 | 4 | This package was created for Debian by Kevin M. Rosenberg 5 | in Aug 2002. The URL for Defsystem-3.x is 6 | http://clocc.sourceforge.net. 7 | 8 | To load Defsystem3 into your Lisp system, give the command 9 | (load "/usr/share/common-lisp/source/cl-defsystem3/defsystem.lisp") 10 | This package is build using darcs-buildpackage and the darcs archives can be 11 | downloaded from http://people.debian.org/~pvaneynd/repository/ 12 | -------------------------------------------------------------------------------- /src/defsystem-3.x/debian/cl-defsystem3.doc-base: -------------------------------------------------------------------------------- 1 | Document: cl-defsystem3 2 | Title: Mk-Defsystem 3 3 | Abstract: This manual describes the usages of 4 | Mk-Defsystem 3, a tool for building Common Lisp packages 5 | Section: programming 6 | 7 | Format: HTML 8 | Index: /usr/share/doc/cl-defsystem3/defsystem.html 9 | Files: /usr/share/doc/cl-defsystem3/defsystem.html 10 | 11 | 12 | -------------------------------------------------------------------------------- /src/defsystem-3.x/debian/compat: -------------------------------------------------------------------------------- 1 | 4 2 | -------------------------------------------------------------------------------- /src/defsystem-3.x/debian/control: -------------------------------------------------------------------------------- 1 | Source: cl-defsystem3 2 | Section: devel 3 | Priority: optional 4 | Maintainer: Peter Van Eynde 5 | Build-Depends-Indep: debhelper (>> 4.0.0) 6 | Standards-Version: 3.6.2.1 7 | 8 | Package: cl-defsystem3 9 | Architecture: all 10 | Depends: ${shlibs:Depends} 11 | Replaces: common-lisp-controller (<< 3.18) 12 | Recommends: common-lisp-controller, cmucl | lisp-compiler 13 | Description: Make system for Common Lisp Packages 14 | defsystem3 provides a "make" type functions for Common Lisp packages. It 15 | provides compilation and loading features for complex Lisp systems 16 | with multiple modules and files. 17 | -------------------------------------------------------------------------------- /src/defsystem-3.x/debian/postrm: -------------------------------------------------------------------------------- 1 | #! /bin/sh 2 | 3 | set -e 4 | 5 | # summary of how this script can be called: 6 | # * `remove' 7 | # * `purge' 8 | # * `upgrade' 9 | # * `failed-upgrade' 10 | # * `abort-install' 11 | # * `abort-install' 12 | # * `abort-upgrade' 13 | # * `disappear' overwrit>r> 14 | # for details, see http://www.debian.org/doc/debian-policy/ or 15 | # the debian-policy package 16 | 17 | 18 | case "$1" in 19 | purge|remove|upgrade|failed-upgrade|abort-install|abort-upgrade|disappear) 20 | ;; 21 | *) 22 | echo "postrm called with unknown argument \`$1'" >&2 23 | exit 1 24 | 25 | esac 26 | 27 | # dh_installdeb will replace this with shell code automatically 28 | # generated by other debhelper scripts. 29 | 30 | #DEBHELPER# 31 | 32 | exit 0 33 | -------------------------------------------------------------------------------- /src/defsystem-3.x/debian/preinst: -------------------------------------------------------------------------------- 1 | #! /bin/sh 2 | 3 | set -e 4 | 5 | # summary of how this script can be called: 6 | # * `install' 7 | # * `install' 8 | # * `upgrade' 9 | # * `abort-upgrade' 10 | # 11 | # for details, see http://www.debian.org/doc/debian-policy/ or 12 | # the debian-policy package 13 | 14 | 15 | case "$1" in 16 | install|upgrade) 17 | ;; 18 | abort-upgrade) 19 | ;; 20 | *) 21 | echo "preinst called with unknown argument \`$1'" >&2 22 | exit 1 23 | ;; 24 | esac 25 | 26 | # dh_installdeb will replace this with shell code automatically 27 | # generated by other debhelper scripts. 28 | 29 | #DEBHELPER# 30 | 31 | exit 0 32 | 33 | 34 | -------------------------------------------------------------------------------- /src/defsystem-3.x/debian/prerm: -------------------------------------------------------------------------------- 1 | #! /bin/sh 2 | 3 | set -e 4 | 5 | # summary of how this script can be called: 6 | # * `remove' 7 | # * `upgrade' 8 | # * `failed-upgrade' 9 | # * `remove' `in-favour' 10 | # * `deconfigure' `in-favour' 11 | # `removing' 12 | # 13 | # for details, see http://www.debian.org/doc/debian-policy/ or 14 | # the debian-policy package 15 | 16 | 17 | case "$1" in 18 | remove|upgrade|deconfigure) 19 | ;; 20 | failed-upgrade) 21 | ;; 22 | *) 23 | echo "prerm called with unknown argument \`$1'" >&2 24 | exit 1 25 | ;; 26 | esac 27 | 28 | # dh_installdeb will replace this with shell code automatically 29 | # generated by other debhelper scripts. 30 | 31 | #DEBHELPER# 32 | 33 | exit 0 34 | 35 | 36 | -------------------------------------------------------------------------------- /src/defsystem-4/ALPHA-NOTICE: -------------------------------------------------------------------------------- 1 | MK:DEFSYSTEM 4.0 2 | 3 | Please note that this software is highly experimental and not quite 4 | correct yet. 5 | Do expect bugs and other stumbling blocks. 6 | 7 | -- 8 | Marco Antoniotti 2002-02-22 9 | -------------------------------------------------------------------------------- /src/defsystem-4/THIS-IS-DF4: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/blindglobe/clocc/a50bb75edb01039b282cf320e4505122a59c59a7/src/defsystem-4/THIS-IS-DF4 -------------------------------------------------------------------------------- /src/defsystem-4/TODO: -------------------------------------------------------------------------------- 1 | MK:DEFSYSTEM 4 Partial TODO List. 2 | 3 | * Fix/Finish the specs and the documentation. 4 | 5 | * Test basic program functionality. 6 | ** DEFSYSTEM maintains some state across operations. This state 7 | should be made explicit and stored in a better way at the 8 | component level. 9 | ** The ``policies'' idea is not fleshed out. 10 | ** There may still be some problems w.r.t. pathnames (nothing new 11 | here). 12 | 13 | * Advanced program functionality 14 | ** Foreign language integration is suboptimal. More design is needed. 15 | 16 | * Extension and Extensibility 17 | ** This needs more design. Essentially, the construction of new 18 | ``components'' is not thought out yet. 19 | ** Specialized dependencies and versions need to be tested and 20 | integrated in the design. 21 | 22 | -- 23 | Marco Antoniotti 2002-02-20 24 | -------------------------------------------------------------------------------- /src/defsystem-4/src/impl-dependent/clisp.lisp: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: CLtL -*- 2 | 3 | (in-package "MK4") 4 | 5 | (defun run-program (program 6 | &key 7 | arguments 8 | (error-output *error-output*) 9 | ) 10 | (apply #'lisp:execute program arguments)) 11 | 12 | 13 | (defmethod run-os-program ((program string) 14 | &key 15 | (arguments ()) 16 | (input nil) 17 | (output :terminal) 18 | (error-output t) 19 | &allow-other-keys) 20 | (declare (ignore error-output)) 21 | (lisp:run-program program 22 | :arguments arguments 23 | :output output 24 | :input input)) 25 | 26 | 27 | ;;; end of file -- clisp.lisp -- 28 | -------------------------------------------------------------------------------- /src/defsystem-4/src/impl-dependent/common.lisp: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: CLtL -*- 2 | 3 | ;;; common.lisp -- 4 | 5 | ;;; end of file -- common.lisp -- -------------------------------------------------------------------------------- /src/defsystem-4/src/impl-dependent/corman.lisp: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: CLtL -*- 2 | 3 | (in-package "MK4") 4 | 5 | (win:defwinapi run-dos-command ((name (:char *))) 6 | :return-type :int 7 | :library-name "msvcrt.dll" 8 | :entry-name "run-dos-command" 9 | :linkage-type :c) 10 | 11 | (defun run-program (program &rest arguments) 12 | (win::run-dos-command (format nil "~A~@[~{ ~A~}~]" program arguments))) 13 | 14 | ;;; end of file -- corman.lisp -- 15 | -------------------------------------------------------------------------------- /src/defsystem-4/src/impl-dependent/kcl-derivatives.lisp: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: CLtL -*- 2 | 3 | (in-package "MK4") 4 | 5 | (defun run-program (program &rest arguments) 6 | (system (format nil "~A~@[~{ ~A~}~]" program arguments))) 7 | 8 | 9 | 10 | (defmethod load-object-file ((loadable-object-pathname pathname) 11 | &key 12 | (print *load-print*) 13 | (verbose *load-verbose*) 14 | (libraries '("c")) 15 | ) 16 | (declare (ignore print libraries)) 17 | (when verbose 18 | (format *trace-output* ";;; MK4: Loading Foreign File ~A." 19 | loadable-c-pathname)) 20 | (load loadable-object-pathname :print print :verbose nil) ; Should be enough. 21 | ) 22 | 23 | ;;; end of file -- kcl-derivatives.lisp -- 24 | -------------------------------------------------------------------------------- /src/defsystem-4/src/impl-dependent/lcl.lisp: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: CLtL -*- 2 | 3 | (in-package "MK4") 4 | 5 | (shadow '(lcl:run-program)) 6 | 7 | (defun run-program (program &rest arguments) 8 | (lcl:run-program program :arguments arguments)) 9 | 10 | 11 | (defmethod load-object-file ((loadable-object-pathname pathname) 12 | &key 13 | (print *load-print*) 14 | (verbose *load-verbose*) 15 | (libraries '("c")) 16 | ) 17 | (declare (ignore print libraries)) 18 | (when verbose 19 | (format *trace-output* ";;; MK4: Loading Foreign File ~A." 20 | loadable-c-pathname)) 21 | (load-foreign-files loadable-object-pathname) 22 | ) 23 | 24 | ;;; end of file -- lcl.lisp -- 25 | -------------------------------------------------------------------------------- /src/defsystem-4/src/impl-dependent/mcl.lisp: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: CLtL -*- 2 | 3 | (in-package "MK4") 4 | 5 | (defun run-program (program &rest arguments) 6 | (declare (ignore program arguments)) 7 | (error "MK:DEFSYSTEM: no RUN-PROGRAM defined for MCL.")) 8 | 9 | (defun edit-operation (component force) 10 | "Always returns nil, i.e. component not changed." 11 | (declare (ignore force)) 12 | ;; 13 | (let* ((full-pathname (component-full-pathname component :source)) 14 | (already-editing\? 15 | #+:mcl 16 | (dolist (w (CCL:windows :class 'ccl:fred-window)) 17 | (when (equal (CCL:window-filename w) full-pathname) 18 | (return w))) 19 | 20 | #-:mcl 21 | nil)) 22 | 23 | (if already-editing\? 24 | #+:mcl (CCL:window-select already-editing\?) #-:mcl nil 25 | (ed full-pathname))) 26 | nil) 27 | 28 | (eval-when (:load-toplevel :execute) 29 | (component-operation :edit 'edit-operation) 30 | (component-operation 'edit 'edit-operation)) 31 | 32 | ;;; end of file -- mcl.lisp -- 33 | -------------------------------------------------------------------------------- /src/defsystem-4/src/impl-dependent/poplog.lisp: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: CLtL -*- 2 | 3 | (in-package "MK4") 4 | 5 | (require :run-unix-program) 6 | 7 | (defun run-program (program &rest arguments) 8 | (poplog:run-program program :args arguments)) 9 | 10 | ;;; end of file -- poplog.lisp -- 11 | -------------------------------------------------------------------------------- /src/defsystem-4/src/tests/README: -------------------------------------------------------------------------------- 1 | This directory `tests' contains many temporary tests for MK:DEFSYSTEM 4.0. 2 | Not all of them may work at any given time. 3 | PLease take that into consideration. 4 | 5 | -- 6 | Marco Antoniotti 2002-02-21 7 | -------------------------------------------------------------------------------- /src/defsystem-4/src/tests/test-file.lisp: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: Lisp -*- 2 | 3 | ;; MK4 test file. 4 | 5 | (eval-when (:load-toplevel) 6 | (print ";;; Loading test file.")) 7 | 8 | (eval-when (:load-toplevel :execute) 9 | (print ";;; Loading/executing test file.")) 10 | 11 | (eval-when (:compile-toplevel) 12 | (print ";;; Compiling test file.")) 13 | -------------------------------------------------------------------------------- /src/defsystem-4/src/utilities/ambler/ambler.system: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: CLtL -*- 2 | 3 | ;;; ambler.system -- 4 | ;;; Simple code ambler. 5 | ;;; MK:DEFSYSTEM file. 6 | ;;; 7 | ;;; Please see the file COPYING for licensing information. 8 | ;;; 9 | ;;; Copyright (c) 2001, Marco Antoniotti 10 | 11 | (eval-when (:load-toplevel :execute) 12 | (unless (find-package "MK") 13 | (error "Cannot load file \"ambler.system\". MK:DEFSYSTEM is required."))) 14 | 15 | 16 | (mk:defsystem "AMBLER" 17 | :components ("ambler-pkg" "ambler")) 18 | 19 | ;;; end of file -- ambler.system -- 20 | -------------------------------------------------------------------------------- /src/defsystem-4/src/utilities/save-image.lisp: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: CLtL -*- 2 | 3 | ;;; save-image -- 4 | 5 | (in-package "MK4") ; Maybe this functionality 6 | ; should be in its own 7 | ; package. 8 | 9 | ;;; ******************************** 10 | ;;; SAVE-IMAGE ********************* 11 | ;;; ******************************** 12 | 13 | ;;; Portable wrapper for saving a Common Lisp image. 14 | ;;; Note that this is only the main definition. The actual 15 | ;;; implementation dependent definitions are in the 'impl-dependent' 16 | ;;; files. 17 | 18 | (defun save-working-image (image-name &rest arguments) 19 | (declare (ignore image-name arguments)) 20 | (warn "MK:DEFSYSTEM: sorry: no SAVE-IMAGE function defined for ~A ~A.~@ 21 | Make sure that the implementation dependent files are loaded after~@ 22 | the common one." 23 | (lisp-implementation-type) 24 | (lisp-implementation-version))) 25 | 26 | ;;; end of file -- save-image -- -------------------------------------------------------------------------------- /src/ext/queues/queues.system: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: CLtL -*- 2 | 3 | ;;; queues.system -- 4 | ;;; Simple queues in the Abelson and Sussman SICP style. 5 | ;;; Package definition file (in CLtL2 style). 6 | ;;; 7 | ;;; Author: Marco Antoniotti 8 | ;;; 9 | ;;; Copyright (c) 1992 - 2000 Marco Antoniotti. All rights reserved. 10 | ;;; This software is released under the terms of the GNU Lesser General 11 | ;;; Public License (LGPL, see file COPYRIGHT for details). 12 | 13 | 14 | ;;;============================================================================ 15 | ;;; QUEUES System 16 | ;;; 17 | ;;; Fix the :source-pathname and the :binary-pathname slots to suite 18 | ;;; your needs. 19 | ;;; May I suggest you define a "QUEUES" logical pathname host as well? 20 | 21 | (mk:defsystem "QUEUES" 22 | :source-pathname "" 23 | :binary-pathname "" 24 | :components ((:file "queues-package") 25 | (:file "queues" :depends-on ("queues-package")))) 26 | 27 | ;;; end of file -- queues-package.lisp -- 28 | -------------------------------------------------------------------------------- /src/ext/sequences/Makefile: -------------------------------------------------------------------------------- 1 | TOP := $(shell cd ../../..; pwd) 2 | LISPEXT := lisp 3 | SOURCES := seqclisp sequence sequences avlseq 4 | SYSTEM := seq 5 | DOCFILES = report.html 6 | ZIPEXTRA = $(TOP)/etc/GNU-GPL 7 | include $(TOP)/clocc.mk 8 | -------------------------------------------------------------------------------- /src/ext/sequences/seq.system: -------------------------------------------------------------------------------- 1 | ;;; -*- Lisp -*- 2 | ;;; 3 | ;;; SEQ - extensible sequences 4 | ;;; 5 | ;;; $Id: seq.system,v 1.1 2004/09/06 02:52:18 sds Exp $ 6 | ;;; $Source: /cvsroot/clocc/clocc/src/ext/sequences/seq.system,v $ 7 | 8 | (mk:defsystem seq 9 | :source-pathname (translate-logical-pathname "clocc:src;ext;sequences;") 10 | :source-extension "lisp" 11 | :components 12 | ((:file "avlseq" :depends-on ("sequences")) 13 | (:file "sequences" :depends-on (#+clisp "seqclisp" #-clisp "sequence")) 14 | #+clisp (:file "seqclisp") 15 | #-clisp (:file "sequence")) 16 | :initially-do 17 | (progn (mk:system-source-size :seq :all) 18 | (mk:system-source-size :seq :new-source-and-dependents))) 19 | -------------------------------------------------------------------------------- /src/ext/sequences/sequences.lisp: -------------------------------------------------------------------------------- 1 | ;;; Extensible Sequence Type 2 | ;;; 3 | ;;; Copyright (C) 1988, 1992 Bruno Haible 4 | ;;; This is Free Software, published under the GNU General Public License v2. 5 | 6 | #-CLISP (require 'sequence "sequence") 7 | #+CLISP (require 'seqclisp "seqclisp") 8 | -------------------------------------------------------------------------------- /src/ext/union-find/README: -------------------------------------------------------------------------------- 1 | README File. 2 | 3 | Union Find Simple. 4 | 5 | This package contains a Common Lisp implementation of the well known 6 | UNION-FIND data structure and algorithms. It is based on the 7 | description found in 8 | 9 | 1 - T. H. Cormen, C. E. Leiserson, and R. L. Rivest, 10 | "Introduction to Algorithms", Ch. 22, MIT Press, 1990. 11 | 2 - K. Melhorn, and S. N\"aher, "LEDA: A Platform for Combinatorial 12 | and Geometric Computing", Cambridge University Press, 1999. 13 | 14 | The implementation manipulates "forests" representing disjoint sets. 15 | The forests are organized in "partitions". 16 | 17 | 2000-11-16 Marco Antoniotti 18 | 19 | -------------------------------------------------------------------------------- /src/ext/union-find/union-find.system: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: CLtL -*- 2 | 3 | ;;; union-find.system -- 4 | ;;; Simple implementation of the well known UNION-FIND data structure 5 | ;;; (with weighted path compression). 6 | ;;; See file README for more info. 7 | ;;; 8 | ;;; Author: Marco Antoniotti 9 | ;;; 10 | ;;; Copyright (c) 2000 Marco Antoniotti. All rights reserved. 11 | ;;; This software is released under the terms of the GNU Lesser General 12 | ;;; Public License (LGPL, see file COPYRIGHT for details). 13 | 14 | (unless (find-package "MAKE") 15 | (error "UNION FIND: MK-DEFSYSTEM is required to use the .system file.")) 16 | 17 | 18 | (mk:defsystem "CL.UTIL.UNION-FIND" 19 | :source-pathname "" 20 | :binary-pathname "" 21 | :source-extension "lisp" 22 | :components ((:file "union-find-pkg") 23 | (:file "union-find" 24 | :depends-on ("union-find-pkg")))) 25 | 26 | ;;; end of file -- union-find.system -- 27 | -------------------------------------------------------------------------------- /src/f2cl/Makefile: -------------------------------------------------------------------------------- 1 | TOP := $(shell cd ../..; pwd) 2 | LISPEXT := lisp 3 | SOURCES := 4 | SYSTEM := f2cl 5 | DOCFILES = $(SYSTEM).html 6 | ZIPEXTRA = $(TOP)/etc/GNU-LGPL 7 | include $(TOP)/clocc.mk 8 | -------------------------------------------------------------------------------- /src/f2cl/build/install.txt: -------------------------------------------------------------------------------- 1 | Fortran to Lisp Translation: installation instructions 2 | ------------------------------------------------------ 3 | 4 | 1. Go to the f2cl source directory. 5 | 2. Use the target Common Lisp compiler to compile each of the files 6 | f2cl1.l through f2cl7.l and macros.l . 7 | 3. Edit the file f2cl0.l to reflect the root directory of the 8 | f2cl file system (*f2cl_dir*) and the extension for your Common 9 | Lisp compiled code (*ext*). 10 | 4. Load f2cl0.l into Common Lisp. 11 | 5. The translator functions are now available to be used. 12 | 13 | 6. Important note: when compiling or executing translated code the macros 14 | in the file macros.l should be available. 15 | 16 | For more information about f2cl, including user instructions, read the 17 | article f2cldoc.* in the f2cl/doc directory or the tests in f2cl/val. 18 | 19 | 20 | Bugs and comments: senac@waikato.ac.nz 21 | -------------------------------------------------------------------- 22 | -------------------------------------------------------------------------------- /src/f2cl/debian/README.Debian: -------------------------------------------------------------------------------- 1 | Installing f2cl into your CL implementation that uses 2 | Debian's Common Lisp Controller is easy. Just enter 3 | 4 | (require 'f2cl) 5 | 6 | and a precompiled version of f2cl should be loaded. 7 | -------------------------------------------------------------------------------- /src/f2cl/debian/compat: -------------------------------------------------------------------------------- 1 | 4 2 | -------------------------------------------------------------------------------- /src/f2cl/debian/control: -------------------------------------------------------------------------------- 1 | Source: cl-f2cl 2 | Section: devel 3 | Priority: optional 4 | Maintainer: Peter Van Eynde 5 | Build-Depends-Indep: debhelper (>= 4.0.0) 6 | Standards-Version: 3.6.1.1 7 | 8 | Package: cl-f2cl 9 | Architecture: all 10 | Depends: ${shlibs:Depends}, common-lisp-controller (>= 3.37) 11 | Description: Common Lisp package to convert Fortran 77 source code to Common Lisp 12 | This package performs automated conversion of Fortran 77 source code into 13 | Common Lisp source code. 14 | 15 | -------------------------------------------------------------------------------- /src/f2cl/debian/copyright: -------------------------------------------------------------------------------- 1 | This package was debianized by Kevin M. Rosenberg in 2 | Nov 2002. 3 | 4 | It was downloaded from http://www.sourceforge.net/projects/clocc 5 | Upstream Authors: Kevin Broughan, Diane Koorey Willcock, Raymond Toy 6 | 7 | Changes compared to upstream: 8 | - Added .asd file 9 | 10 | 11 | Copyright (c) 1992-1995 by Kevin Broughan and Diane Koorey Willcock 12 | Copyright (c) 2000-2002 by Raymond Toy 13 | 14 | This code is free software; you can redistribute it and/or modify it 15 | under the terms of the GNU General Public License as published by the 16 | Free Software Foundation. The exception is macros.l which is released 17 | under the LGPL so that it can be incorporated into other packages. 18 | 19 | The GNU General Public License is located in the file 20 | /usr/share/common-licenses/GPL and the GNU Lessor General Public 21 | License can be found in your Debian file system in 22 | /usr/share/common-licenses/LGPL. 23 | -------------------------------------------------------------------------------- /src/f2cl/debian/f2cl.asd: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: lisp -*- 2 | 3 | (in-package :asdf) 4 | 5 | (defsystem :f2cl 6 | :components 7 | ((:file "f2cl0") 8 | (:file "f2cl1" :depends-on ("f2cl0")) 9 | (:file "f2cl2" :depends-on ("f2cl1")) 10 | (:file "f2cl3" :depends-on ("f2cl2")) 11 | (:file "f2cl4" :depends-on ("f2cl3")) 12 | (:file "f2cl5" :depends-on ("f2cl4")) 13 | (:file "f2cl6" :depends-on ("f2cl5")) 14 | (:file "f2cl7" :depends-on ("f2cl6")) 15 | (:file "f2cl8" :depends-on ("f2cl7")) 16 | (:file "macros" :depends-on ("f2cl8")))) 17 | 18 | 19 | (defmethod source-file-type ((c cl-source-file) (s (eql (find-system :f2cl)))) 20 | "l") 21 | -------------------------------------------------------------------------------- /src/f2cl/f2cl.asd: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: lisp -*- 2 | ;; f2cl asd file 3 | 4 | (defpackage #:f2cl-asd 5 | (:use :cl :asdf)) 6 | 7 | (in-package #:f2cl-asd) 8 | 9 | (defsystem f2cl 10 | :components 11 | ((:module src 12 | :components 13 | ((:file "f2cl0") 14 | (:file "f2cl1") 15 | (:file "f2cl2") 16 | (:file "f2cl3") 17 | (:file "f2cl4") 18 | (:file "f2cl5") 19 | (:file "f2cl6") 20 | (:file "f2cl7") 21 | #+cmu(:file "f2cl8") 22 | (:file "macros"))))) 23 | 24 | (defmethod asdf:source-file-type 25 | ((f cl-source-file) (s (eql 26 | (asdf:find-system 'f2cl)))) "l") 27 | -------------------------------------------------------------------------------- /src/f2cl/f2cl.system: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: lisp -*- 2 | 3 | ;; A sample defsystem. 4 | 5 | (mk:defsystem f2cl 6 | :source-pathname 7 | (merge-pathnames (make-pathname :directory '(#-gcl :relative "src")) 8 | (make-pathname :directory (pathname-directory #-gcl *load-pathname* 9 | #+gcl sys:*load-pathname*))) 10 | :source-extension "l" 11 | :depends-on nil 12 | :components 13 | ((:module src 14 | :source-pathname "" 15 | :binary-pathname "" 16 | :components 17 | ( 18 | (:file "f2cl0") 19 | (:file "f2cl1") 20 | (:file "f2cl2") 21 | (:file "f2cl3") 22 | (:file "f2cl4") 23 | (:file "f2cl5") 24 | (:file "f2cl6") 25 | (:file "f2cl7") 26 | #+cmu(:file "f2cl8") 27 | (:file "macros"))))) 28 | -------------------------------------------------------------------------------- /src/f2cl/packages/.cvsignore: -------------------------------------------------------------------------------- 1 | ALKYLATI.MES 2 | ALKYLATI.PRO 3 | AMPLEXAM.MES 4 | AMPLEXAM.PRO 5 | ANTENNA1.MES 6 | ANTENNA1.PRO 7 | BETTING8.MES 8 | BETTING8.PRO 9 | BOXPARID.MES 10 | BOXPARID.PRO 11 | DEMBO1AS.MES 12 | DEMBO1AS.PRO 13 | DEMBO4CX.MES 14 | DEMBO4CX.PRO 15 | DEMBO7XX.MES 16 | DEMBO7XX.PRO 17 | FRACXOPT.MES 18 | FRACXOPT.PRO 19 | GIRDERDE.MES 20 | GIRDERDE.PRO 21 | HIMMELBL.MES 22 | HIMMELBL.PRO 23 | HS101XXX.MES 24 | HS101XXX.PRO 25 | HS102XXX.MES 26 | HS102XXX.PRO 27 | HS103XXX.MES 28 | HS103XXX.PRO 29 | HS109XXX.MES 30 | HS109XXX.PRO 31 | HS85ORIG.MES 32 | HS85ORIG.PRO 33 | MARATOS0.MES 34 | MARATOS0.PRO 35 | NET1AMPL.MES 36 | NET1AMPL.PRO 37 | NMCFQMHH.MES 38 | NMCFQMHH.PRO 39 | NMFCQ11X.MES 40 | NMFCQ11X.PRO 41 | PAVIANI2.MES 42 | PAVIANI2.PRO 43 | TP383MOD.MES 44 | TP383MOD.PRO 45 | UNDEFEXA.MES 46 | UNDEFEXA.PRO 47 | WEAPONH2.MES 48 | WEAPONH2.PRO 49 | XXXXXXXX.MES 50 | XXXXXXXX.PRO 51 | -------------------------------------------------------------------------------- /src/f2cl/packages/blas/blas-package.lisp: -------------------------------------------------------------------------------- 1 | (defpackage "BLAS" 2 | (:use "COMMON-LISP") 3 | (:export "DAXPY" "DCOPY" "DDOT" "DNRM2" "DSCAL" "IDAMAX" "DASUM" 4 | "DCABS1" "DGBMV" "DGEMM" "DGEMV" "DGER" "DROT" "DROTG" 5 | "DSBMV" "DSPMV" "DSPR" "DSPR2" "DSWAP" "DSYMM" "DSYMV" 6 | "DSYR" "DSYR2" "DSYR2K" "DSYRK" "DTBMV" "DTBSV" "DTPMV" 7 | "DTPSV" "DTRMM" "DTRMV" "DTRSM" "DTRSV" "DZASUM" "DZNRM2" 8 | "ICAMAX" "ISAMAX" "IZAMAX" "LSAME" "XERBLA")) 9 | -------------------------------------------------------------------------------- /src/f2cl/packages/blas/dcabs1.f: -------------------------------------------------------------------------------- 1 | double precision function dcabs1(z) 2 | C ORIGINAL: 3 | c double complex z,zz 4 | c double precision t(2) 5 | c equivalence (zz,t(1)) 6 | c zz = z 7 | c dcabs1 = dabs(t(1)) + dabs(t(2)) 8 | c NEW 9 | double complex z 10 | dcabs1 = dabs(dble(z)) + dabs(dimag(z)) 11 | return 12 | end 13 | -------------------------------------------------------------------------------- /src/f2cl/packages/blas/drotg.f: -------------------------------------------------------------------------------- 1 | subroutine drotg(da,db,c,s) 2 | c 3 | c construct givens plane rotation. 4 | c jack dongarra, linpack, 3/11/78. 5 | c 6 | double precision da,db,c,s,roe,scale,r,z 7 | c 8 | roe = db 9 | if( dabs(da) .gt. dabs(db) ) roe = da 10 | scale = dabs(da) + dabs(db) 11 | if( scale .ne. 0.0d0 ) go to 10 12 | c = 1.0d0 13 | s = 0.0d0 14 | r = 0.0d0 15 | z = 0.0d0 16 | go to 20 17 | 10 r = scale*dsqrt((da/scale)**2 + (db/scale)**2) 18 | r = dsign(1.0d0,roe)*r 19 | c = da/r 20 | s = db/r 21 | z = 1.0d0 22 | if( dabs(da) .gt. dabs(db) ) z = s 23 | if( dabs(db) .ge. dabs(da) .and. c .ne. 0.0d0 ) z = 1.0d0/c 24 | 20 da = r 25 | db = z 26 | return 27 | end 28 | -------------------------------------------------------------------------------- /src/f2cl/packages/blas/dzasum.f: -------------------------------------------------------------------------------- 1 | double precision function dzasum(n,zx,incx) 2 | c 3 | c takes the sum of the absolute values. 4 | c jack dongarra, 3/11/78. 5 | c modified 3/93 to return if incx .le. 0. 6 | c modified 12/3/93, array(1) declarations changed to array(*) 7 | c 8 | double complex zx(*) 9 | double precision stemp,dcabs1 10 | integer i,incx,ix,n 11 | c 12 | dzasum = 0.0d0 13 | stemp = 0.0d0 14 | if( n.le.0 .or. incx.le.0 )return 15 | if(incx.eq.1)go to 20 16 | c 17 | c code for increment not equal to 1 18 | c 19 | ix = 1 20 | do 10 i = 1,n 21 | stemp = stemp + dcabs1(zx(ix)) 22 | ix = ix + incx 23 | 10 continue 24 | dzasum = stemp 25 | return 26 | c 27 | c code for increment equal to 1 28 | c 29 | 20 do 30 i = 1,n 30 | stemp = stemp + dcabs1(zx(i)) 31 | 30 continue 32 | dzasum = stemp 33 | return 34 | end 35 | -------------------------------------------------------------------------------- /src/f2cl/packages/blas/zaxpy.f: -------------------------------------------------------------------------------- 1 | subroutine zaxpy(n,za,zx,incx,zy,incy) 2 | c 3 | c constant times a vector plus a vector. 4 | c jack dongarra, 3/11/78. 5 | c modified 12/3/93, array(1) declarations changed to array(*) 6 | c 7 | double complex zx(*),zy(*),za 8 | integer i,incx,incy,ix,iy,n 9 | double precision dcabs1 10 | if(n.le.0)return 11 | if (dcabs1(za) .eq. 0.0d0) return 12 | if (incx.eq.1.and.incy.eq.1)go to 20 13 | c 14 | c code for unequal increments or equal increments 15 | c not equal to 1 16 | c 17 | ix = 1 18 | iy = 1 19 | if(incx.lt.0)ix = (-n+1)*incx + 1 20 | if(incy.lt.0)iy = (-n+1)*incy + 1 21 | do 10 i = 1,n 22 | zy(iy) = zy(iy) + za*zx(ix) 23 | ix = ix + incx 24 | iy = iy + incy 25 | 10 continue 26 | return 27 | c 28 | c code for both increments equal to 1 29 | c 30 | 20 do 30 i = 1,n 31 | zy(i) = zy(i) + za*zx(i) 32 | 30 continue 33 | return 34 | end 35 | -------------------------------------------------------------------------------- /src/f2cl/packages/blas/zcopy.f: -------------------------------------------------------------------------------- 1 | subroutine zcopy(n,zx,incx,zy,incy) 2 | c 3 | c copies a vector, x, to a vector, y. 4 | c jack dongarra, linpack, 4/11/78. 5 | c modified 12/3/93, array(1) declarations changed to array(*) 6 | c 7 | double complex zx(*),zy(*) 8 | integer i,incx,incy,ix,iy,n 9 | c 10 | if(n.le.0)return 11 | if(incx.eq.1.and.incy.eq.1)go to 20 12 | c 13 | c code for unequal increments or equal increments 14 | c not equal to 1 15 | c 16 | ix = 1 17 | iy = 1 18 | if(incx.lt.0)ix = (-n+1)*incx + 1 19 | if(incy.lt.0)iy = (-n+1)*incy + 1 20 | do 10 i = 1,n 21 | zy(iy) = zx(ix) 22 | ix = ix + incx 23 | iy = iy + incy 24 | 10 continue 25 | return 26 | c 27 | c code for both increments equal to 1 28 | c 29 | 20 do 30 i = 1,n 30 | zy(i) = zx(i) 31 | 30 continue 32 | return 33 | end 34 | -------------------------------------------------------------------------------- /src/f2cl/packages/blas/zdscal.f: -------------------------------------------------------------------------------- 1 | subroutine zdscal(n,da,zx,incx) 2 | c 3 | c scales a vector by a constant. 4 | c jack dongarra, 3/11/78. 5 | c modified 3/93 to return if incx .le. 0. 6 | c modified 12/3/93, array(1) declarations changed to array(*) 7 | c 8 | double complex zx(*) 9 | double precision da 10 | integer i,incx,ix,n 11 | c 12 | if( n.le.0 .or. incx.le.0 )return 13 | if(incx.eq.1)go to 20 14 | c 15 | c code for increment not equal to 1 16 | c 17 | ix = 1 18 | do 10 i = 1,n 19 | zx(ix) = dcmplx(da,0.0d0)*zx(ix) 20 | ix = ix + incx 21 | 10 continue 22 | return 23 | c 24 | c code for increment equal to 1 25 | c 26 | 20 do 30 i = 1,n 27 | zx(i) = dcmplx(da,0.0d0)*zx(i) 28 | 30 continue 29 | return 30 | end 31 | -------------------------------------------------------------------------------- /src/f2cl/packages/blas/zrotg.f: -------------------------------------------------------------------------------- 1 | subroutine zrotg(ca,cb,c,s) 2 | double complex ca,cb,s 3 | double precision c 4 | double precision norm,scale 5 | double complex alpha 6 | if (cdabs(ca) .ne. 0.0d0) go to 10 7 | c = 0.0d0 8 | s = (1.0d0,0.0d0) 9 | ca = cb 10 | go to 20 11 | 10 continue 12 | scale = cdabs(ca) + cdabs(cb) 13 | norm = scale*dsqrt((cdabs(ca/dcmplx(scale,0.0d0)))**2 + 14 | * (cdabs(cb/dcmplx(scale,0.0d0)))**2) 15 | alpha = ca /cdabs(ca) 16 | c = cdabs(ca) / norm 17 | s = alpha * dconjg(cb) / norm 18 | ca = alpha * norm 19 | 20 continue 20 | return 21 | end 22 | -------------------------------------------------------------------------------- /src/f2cl/packages/blas/zscal.f: -------------------------------------------------------------------------------- 1 | subroutine zscal(n,za,zx,incx) 2 | c 3 | c scales a vector by a constant. 4 | c jack dongarra, 3/11/78. 5 | c modified 3/93 to return if incx .le. 0. 6 | c modified 12/3/93, array(1) declarations changed to array(*) 7 | c 8 | double complex za,zx(*) 9 | integer i,incx,ix,n 10 | c 11 | if( n.le.0 .or. incx.le.0 )return 12 | if(incx.eq.1)go to 20 13 | c 14 | c code for increment not equal to 1 15 | c 16 | ix = 1 17 | do 10 i = 1,n 18 | zx(ix) = za*zx(ix) 19 | ix = ix + incx 20 | 10 continue 21 | return 22 | c 23 | c code for increment equal to 1 24 | c 25 | 20 do 30 i = 1,n 26 | zx(i) = za*zx(i) 27 | 30 continue 28 | return 29 | end 30 | -------------------------------------------------------------------------------- /src/f2cl/packages/blas/zswap.f: -------------------------------------------------------------------------------- 1 | subroutine zswap (n,zx,incx,zy,incy) 2 | c 3 | c interchanges two vectors. 4 | c jack dongarra, 3/11/78. 5 | c modified 12/3/93, array(1) declarations changed to array(*) 6 | c 7 | double complex zx(*),zy(*),ztemp 8 | integer i,incx,incy,ix,iy,n 9 | c 10 | if(n.le.0)return 11 | if(incx.eq.1.and.incy.eq.1)go to 20 12 | c 13 | c code for unequal increments or equal increments not equal 14 | c to 1 15 | c 16 | ix = 1 17 | iy = 1 18 | if(incx.lt.0)ix = (-n+1)*incx + 1 19 | if(incy.lt.0)iy = (-n+1)*incy + 1 20 | do 10 i = 1,n 21 | ztemp = zx(ix) 22 | zx(ix) = zy(iy) 23 | zy(iy) = ztemp 24 | ix = ix + incx 25 | iy = iy + incy 26 | 10 continue 27 | return 28 | c 29 | c code for both increments equal to 1 30 | 20 do 30 i = 1,n 31 | ztemp = zx(i) 32 | zx(i) = zy(i) 33 | zy(i) = ztemp 34 | 30 continue 35 | return 36 | end 37 | -------------------------------------------------------------------------------- /src/f2cl/packages/colnew/.cvsignore: -------------------------------------------------------------------------------- 1 | *.sse2f 2 | approx.lisp 3 | appsln.lisp 4 | colnew.lisp 5 | compat.lisp 6 | consts.lisp 7 | contrl.lisp 8 | daxpy.lisp 9 | ddot.lisp 10 | dgefa.lisp 11 | dgesl.lisp 12 | dmzsol.lisp 13 | dscal.lisp 14 | errchk.lisp 15 | factrb.lisp 16 | fcblok.lisp 17 | gblock.lisp 18 | gderiv.lisp 19 | horder.lisp 20 | idamax.lisp 21 | lsyslv.lisp 22 | newmsh.lisp 23 | rkbas.lisp 24 | sbblok.lisp 25 | shiftb.lisp 26 | skale.lisp 27 | subbak.lisp 28 | subfor.lisp 29 | vmonde.lisp 30 | vwblok.lisp 31 | -------------------------------------------------------------------------------- /src/f2cl/packages/colnew/compat.f: -------------------------------------------------------------------------------- 1 | c 2 | c The common blocks used in colnew are defined in separate files, 3 | c but the definitions overlap. That is, we can't define the common 4 | c blocks in multiple files because there are common names between 5 | c the files. Hence, we move them here so we can define the blocks 6 | c here all at once. 7 | c 8 | block data colnew 9 | IMPLICIT REAL*8 (A-H,O-Z) 10 | COMMON /COLORD/ KDUM, NCOMP, MSTAR, KD, MMAX, M(20) 11 | COMMON /COLBAS/ B(28), ACOL(28,7), ASAVE(28,4) 12 | COMMON /COLEST/ TOL(40), WGTMSH(40), WGTERR(40), TOLIN(40), 13 | 1 ROOT(40), JTOL(40), LTOL(40), NTOL 14 | COMMON /COLOUT/ PRECIS, IOUT, IPRINT 15 | COMMON /COLLOC/ RHO(7), COEF(49) 16 | COMMON /COLAPR/ N, NOLD, NMAX, NZ, NDMZ 17 | COMMON /COLMSH/ MSHFLG, MSHNUM, MSHLMT, MSHALT 18 | COMMON /COLSID/ TZETA(40), TLEFT, TRIGHT, IZETA, IDUM 19 | COMMON /COLNLN/ NONLIN, ITER, LIMIT, ICARE, IGUESS 20 | end 21 | -------------------------------------------------------------------------------- /src/f2cl/packages/colnew/dmzsol.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE DMZSOL (KD, MSTAR, N, V, Z, DMZ) 2 | C 3 | C********************************************************************** 4 | C 5 | C purpose 6 | C compute dmz in a blockwise manner 7 | C dmz(i) = dmz(i) + v(i) * z(i), i = 1,...,n 8 | C 9 | C********************************************************************** 10 | C 11 | IMPLICIT REAL*8 (A-H,O-Z) 12 | DIMENSION V(KD,1), DMZ(KD,1), Z(1) 13 | C 14 | JZ = 1 15 | DO 30 I = 1, N 16 | DO 20 J = 1, MSTAR 17 | FACT = Z(JZ) 18 | DO 10 L = 1, KD 19 | DMZ(L,I) = DMZ(L,I) + FACT * V(L,JZ) 20 | 10 CONTINUE 21 | JZ = JZ + 1 22 | 20 CONTINUE 23 | 30 CONTINUE 24 | RETURN 25 | END 26 | -------------------------------------------------------------------------------- /src/f2cl/packages/colnew/problem-1/.cvsignore: -------------------------------------------------------------------------------- 1 | *.lisp 2 | *.sse2f 3 | -------------------------------------------------------------------------------- /src/f2cl/packages/colnew/problem-1/dfsub.f: -------------------------------------------------------------------------------- 1 | C................................................................ DFS 10 2 | SUBROUTINE DFSUB(X, Z, DF) DFS 20 3 | REAL*8 Z(4), DF(1,4), X 4 | DF(1,1) = 0. 5 | DF(1,2) = 0. 6 | DF(1,3) = -6./X**2 7 | DF(1,4) = -6./X 8 | RETURN 9 | END 10 | -------------------------------------------------------------------------------- /src/f2cl/packages/colnew/problem-1/dgsub.f: -------------------------------------------------------------------------------- 1 | C................................................................ DGS 10 2 | SUBROUTINE DGSUB(I, Z, DG) DGS 20 3 | REAL*8 Z(4), DG(4) 4 | DO 10 J=1,4 5 | DG(J) = 0. 6 | 10 CONTINUE 7 | GO TO (20, 30, 20, 30), I 8 | 20 DG(1) = 1. 9 | RETURN 10 | 30 DG(3) = 1. 11 | RETURN 12 | END 13 | -------------------------------------------------------------------------------- /src/f2cl/packages/colnew/problem-1/exact.f: -------------------------------------------------------------------------------- 1 | C................................................................ EXA 10 2 | SUBROUTINE EXACT(X, U) EXA 20 3 | REAL*8 U(4), X 4 | C EXACT SOLUTION 5 | U(1) = .25*(10.*LOG(2.)-3.)*(1.-X) + .5*(1./X+(3.+X)*LOG(X)-X) 6 | U(2) = -.25*(10.*LOG(2.)-3.) + .5*(-1./X/X+LOG(X)+(3.+X)/X-1.) 7 | U(3) = .5*(2./X**3+1./X-3./X/X) 8 | U(4) = .5*(-6./X**4-1./X/X+6./X**3) 9 | RETURN 10 | END 11 | -------------------------------------------------------------------------------- /src/f2cl/packages/colnew/problem-1/fsub.f: -------------------------------------------------------------------------------- 1 | C................................................................ FSU 10 2 | SUBROUTINE FSUB(X, Z, F) FSU 20 3 | REAL*8 Z(4), F(1), X 4 | F(1) = (1.-6.*X**2*Z(4)-6.*X*Z(3))/X**3 5 | RETURN 6 | END 7 | -------------------------------------------------------------------------------- /src/f2cl/packages/colnew/problem-1/gsub.f: -------------------------------------------------------------------------------- 1 | C................................................................ GSU 10 2 | SUBROUTINE GSUB(I, Z, G) GSU 20 3 | REAL*8 Z(4), G 4 | GO TO (10, 20, 10, 20), I 5 | 10 G = Z(1) - 0. 6 | RETURN 7 | 20 G = Z(3) - 0. 8 | RETURN 9 | END 10 | -------------------------------------------------------------------------------- /src/f2cl/packages/colnew/problem-2/.cvsignore: -------------------------------------------------------------------------------- 1 | *.lisp 2 | *.sse2f 3 | -------------------------------------------------------------------------------- /src/f2cl/packages/colnew/problem-2/dfsub.f: -------------------------------------------------------------------------------- 1 | C................................................................ DFS 10 2 | SUBROUTINE DFSUB(X, Z, DF) DFS 20 3 | implicit real*8 (a-h, o-z) 4 | DIMENSION Z(4), DF(2,4) 5 | COMMON EPS, DMU, EPS4MU, GAMMA, XT 6 | DF(1,1) = 1./X/X + (1.+Z(3)/X)/EPS4MU 7 | DF(1,2) = -1./X 8 | DF(1,3) = -(1.-Z(1)/X)/EPS4MU 9 | DF(1,4) = 0. 10 | DF(2,1) = (1.-Z(1)/X)/DMU 11 | DF(2,2) = 0. 12 | DF(2,3) = 1./X/X 13 | DF(2,4) = -1./X 14 | RETURN 15 | END 16 | -------------------------------------------------------------------------------- /src/f2cl/packages/colnew/problem-2/dgsub.f: -------------------------------------------------------------------------------- 1 | C................................................................ DGS 10 2 | SUBROUTINE DGSUB(I, Z, DG) DGS 20 3 | implicit real*8 (a-h, o-z) 4 | DIMENSION Z(4), DG(4) 5 | DO 10 J=1,4 6 | DG(J) = 0. 7 | 10 CONTINUE 8 | GO TO (20, 30, 20, 40), I 9 | 20 DG(1) = 1. 10 | RETURN 11 | 30 DG(3) = 1. 12 | RETURN 13 | 40 DG(4) = 1. 14 | DG(3) = -.3 15 | RETURN 16 | END 17 | -------------------------------------------------------------------------------- /src/f2cl/packages/colnew/problem-2/fsub.f: -------------------------------------------------------------------------------- 1 | C................................................................ FSU 10 2 | SUBROUTINE FSUB(X, Z, F) FSU 20 3 | implicit real*8 (a-h, o-z) 4 | DIMENSION Z(4), F(2) 5 | COMMON EPS, DMU, EPS4MU, GAMMA, XT 6 | F(1) = Z(1)/X/X - Z(2)/X + (Z(1)-Z(3)*(1.-Z(1)/X)-GAMMA*X*(1.-X*X/ 7 | * 2.))/EPS4MU 8 | F(2) = Z(3)/X/X - Z(4)/X + Z(1)*(1.-Z(1)/2./X)/DMU 9 | RETURN 10 | END 11 | -------------------------------------------------------------------------------- /src/f2cl/packages/colnew/problem-2/gsub.f: -------------------------------------------------------------------------------- 1 | C................................................................ GSU 10 2 | SUBROUTINE GSUB(I, Z, G) GSU 20 3 | implicit real*8 (a-h, o-z) 4 | DIMENSION Z(4) 5 | GO TO (10, 20, 10, 30), I 6 | 10 G = Z(1) 7 | RETURN 8 | 20 G = Z(3) 9 | RETURN 10 | 30 G = Z(4) - .3*Z(3) + .7 11 | RETURN 12 | END 13 | -------------------------------------------------------------------------------- /src/f2cl/packages/colnew/problem-2/prob2: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/blindglobe/clocc/a50bb75edb01039b282cf320e4505122a59c59a7/src/f2cl/packages/colnew/problem-2/prob2 -------------------------------------------------------------------------------- /src/f2cl/packages/colnew/problem-2/solutn.f: -------------------------------------------------------------------------------- 1 | C................................................................ SOL 10 2 | SUBROUTINE SOLUTN(X, Z, DMVAL) SOL 20 3 | implicit real*8 (a-h, o-z) 4 | COMMON EPS, DMU, EPS4MU, GAMMA, XT 5 | DIMENSION Z(4), DMVAL(2) 6 | CONS = GAMMA*X*(1.-.5*X*X) 7 | DCONS = GAMMA*(1.-1.5*X*X) 8 | D2CONS = -3.*GAMMA*X 9 | IF (X.GT.XT) GO TO 10 10 | Z(1) = 2.*X 11 | Z(2) = 2. 12 | Z(3) = -2.*X + CONS 13 | Z(4) = -2. + DCONS 14 | DMVAL(2) = D2CONS 15 | GO TO 20 16 | 10 Z(1) = 0. 17 | Z(2) = 0. 18 | Z(3) = -CONS 19 | Z(4) = -DCONS 20 | DMVAL(2) = -D2CONS 21 | 20 DMVAL(1) = 0. 22 | RETURN 23 | END 24 | -------------------------------------------------------------------------------- /src/f2cl/packages/colnew/problem-3/.cvsignore: -------------------------------------------------------------------------------- 1 | *.lisp 2 | *.sse2f 3 | -------------------------------------------------------------------------------- /src/f2cl/packages/colnew/problem-3/dfsub.f: -------------------------------------------------------------------------------- 1 | C................................................................ DFS 10 2 | SUBROUTINE DFSUB(X, Z, DF) DFS 20 3 | implicit real*8 (a-h, o-z) 4 | REAL*8 Z(1), DF(2,1) 5 | COMMON EN, S, EL, CONS 6 | DF(1,1) = -EL*(EN-1.)*Z(4) + EL**2*S 7 | DF(1,2) = -EL*CONS*Z(3) 8 | DF(1,3) = -EL*CONS*Z(2) 9 | DF(1,4) = -EL*(EN-1.)*Z(1) 10 | DF(1,5) = 0. 11 | DF(2,1) = -EL**3*2.*Z(1) 12 | DF(2,2) = 0. 13 | DF(2,3) = -EL*CONS*Z(5) 14 | DF(2,4) = -EL*EN*2.*Z(4) + EL**2*S 15 | DF(2,5) = -EL*CONS*Z(3) 16 | RETURN 17 | END 18 | -------------------------------------------------------------------------------- /src/f2cl/packages/colnew/problem-3/dgsub.f: -------------------------------------------------------------------------------- 1 | C................................................................ DGS 10 2 | SUBROUTINE DGSUB(I, Z, DG) DGS 20 3 | implicit real*8 (a-h, o-z) 4 | REAL*8 Z(1), DG(1) 5 | DO 10 J=1,5 6 | DG(J) = 0. 7 | 10 CONTINUE 8 | GO TO (20, 30, 40, 20, 40), I 9 | 20 DG(1) = 1. 10 | RETURN 11 | 30 DG(3) = 1. 12 | RETURN 13 | 40 DG(4) = 1. 14 | RETURN 15 | END 16 | -------------------------------------------------------------------------------- /src/f2cl/packages/colnew/problem-3/fsub.f: -------------------------------------------------------------------------------- 1 | C................................................................ FSU 10 2 | SUBROUTINE FSUB(X, Z, F) FSU 20 3 | implicit real*8 (a-h, o-z) 4 | REAL*8 Z(1), F(1) 5 | COMMON EN, S, EL, CONS 6 | F(1) = -EL*(CONS*Z(3)*Z(2)+(EN-1.)*Z(4)*Z(1)) + EL**2*S*(Z(1)-1.) 7 | F(2) = -EL*(CONS*Z(3)*Z(5)+EN*Z(4)**2) + EL**2*S*Z(4) + 8 | * EL**3*(1.-Z(1)**2) 9 | RETURN 10 | END 11 | -------------------------------------------------------------------------------- /src/f2cl/packages/colnew/problem-3/gsub.f: -------------------------------------------------------------------------------- 1 | C................................................................ GSU 10 2 | SUBROUTINE GSUB(I, Z, G) GSU 20 3 | implicit real*8 (a-h, o-z) 4 | REAL*8 Z(1), G 5 | GO TO (10, 20, 30, 40, 30), I 6 | 10 G = Z(1) 7 | RETURN 8 | 20 G = Z(3) 9 | RETURN 10 | 30 G = Z(4) 11 | RETURN 12 | 40 G = Z(1) - 1. 13 | RETURN 14 | END 15 | -------------------------------------------------------------------------------- /src/f2cl/packages/colnew/problem-3/solutn.f: -------------------------------------------------------------------------------- 1 | C................................................................ SOL 10 2 | SUBROUTINE SOLUTN(X, Z, DMVAL) SOL 20 3 | implicit real*8 (a-h, o-z) 4 | COMMON EN, S, EL, CONS 5 | REAL*8 Z(5), DMVAL(2) 6 | EX = EXP(-EL*X) 7 | Z(1) = 1. - EX 8 | Z(2) = EL*EX 9 | Z(3) = -EL**2*X**2*EX 10 | Z(4) = (EL**3*X**2-2.*EL**2*X)*EX 11 | Z(5) = (-EL**4*X**2+4.*EL**3*X-2.*EL**2)*EX 12 | DMVAL(1) = -EL*Z(2) 13 | DMVAL(2) = (EL**5*X*X-6.*EL**4*X+6.*EL**3)*EX 14 | RETURN 15 | END 16 | -------------------------------------------------------------------------------- /src/f2cl/packages/d1mach.lisp: -------------------------------------------------------------------------------- 1 | ;; 2 | ;; DOUBLE-PRECISION MACHINE CONSTANTS 3 | ;; D1MACH( 1) = B**(EMIN-1), THE SMALLEST POSITIVE MAGNITUDE. 4 | ;; D1MACH( 2) = B**EMAX*(1 - B**(-T)), THE LARGEST MAGNITUDE. 5 | ;; D1MACH( 3) = B**(-T), THE SMALLEST RELATIVE SPACING. 6 | ;; D1MACH( 4) = B**(1-T), THE LARGEST RELATIVE SPACING. 7 | ;; D1MACH( 5) = LOG10(B) 8 | ;; 9 | (defun d1mach (i) 10 | (ecase i 11 | (1 least-positive-normalized-double-float) 12 | (2 most-positive-double-float) 13 | (3 double-float-epsilon) 14 | (4 (scale-float double-float-epsilon 1)) 15 | (5 (log (float-radix 1d0) 10d0)))) 16 | -------------------------------------------------------------------------------- /src/f2cl/packages/donlp2/ALKYLATI.MES: -------------------------------------------------------------------------------- 1 | STEP= 0 2 | STARTVALUE CORRECTED IN ORDER TO FIT BOUNDS 3 | DONLP2, V3, 05/29/98, COPYRIGHT P. SPELLUCCI 4 | ALKYLATION 5 | STEP= 12 6 | RESCALING OF OBJECTIVE FUNCTION SCF= 1.8435563545970D-02 7 | STEP= 26 8 | RESCALING OF OBJECTIVE FUNCTION SCF= 0.21375651655530 9 | -------------------------------------------------------------------------------- /src/f2cl/packages/donlp2/AMPLEXAM.MES: -------------------------------------------------------------------------------- 1 | DONLP2, V3, 05/29/98, COPYRIGHT P. SPELLUCCI 2 | AMPLEXAM 3 | -------------------------------------------------------------------------------- /src/f2cl/packages/donlp2/BETTING8.MES: -------------------------------------------------------------------------------- 1 | DONLP2, V3, 05/29/98, COPYRIGHT P. SPELLUCCI 2 | BETTING8 3 | STEP= 2 4 | RESCALING OF OBJECTIVE FUNCTION SCF= 459.05295039185 5 | -------------------------------------------------------------------------------- /src/f2cl/packages/donlp2/BOXPARID.MES: -------------------------------------------------------------------------------- 1 | DONLP2, V3, 05/29/98, COPYRIGHT P. SPELLUCCI 2 | BOXPARID 3 | STEP= 17 4 | RESCALING OF OBJECTIVE FUNCTION SCF= 5.2399684512424D-02 5 | STEP= 21 6 | TRY REGULARIZED SQP WITH INCREASED WEIGHTS 7 | NO DECREASE OF WEIGHTS POSSIBLE 8 | AND INCOMPATIBILITY LARGE 9 | STEP= 21 10 | TRY REGULARIZED SQP WITH INCREASED WEIGHTS 11 | NO DECREASE OF WEIGHTS POSSIBLE 12 | AND INCOMPATIBILITY LARGE 13 | -------------------------------------------------------------------------------- /src/f2cl/packages/donlp2/DEMBO1AS.MES: -------------------------------------------------------------------------------- 1 | DONLP2, V3, 05/29/98, COPYRIGHT P. SPELLUCCI 2 | DEMBO1ASC 3 | STEP= 8 4 | SECOND ORDER CORRECTION SUPPRESSED! 5 | STEP= 91 6 | SECOND ORDER CORRECTION SUPPRESSED! 7 | STEP= 94 8 | SECOND ORDER CORRECTION SUPPRESSED! 9 | STEP= 122 10 | SECOND ORDER CORRECTION SUPPRESSED! 11 | STEP= 128 12 | SECOND ORDER CORRECTION SUPPRESSED! 13 | STEP= 129 14 | SECOND ORDER CORRECTION SUPPRESSED! 15 | STEP= 146 16 | SECOND ORDER CORRECTION SUPPRESSED! 17 | STEP= 147 18 | SECOND ORDER CORRECTION SUPPRESSED! 19 | -------------------------------------------------------------------------------- /src/f2cl/packages/donlp2/DEMBO4CX.MES: -------------------------------------------------------------------------------- 1 | DONLP2, V3, 05/29/98, COPYRIGHT P. SPELLUCCI 2 | DEMBO4C 3 | STEP= 5 4 | SECOND ORDER CORRECTION SUPPRESSED! 5 | STEP= 6 6 | SECOND ORDER CORRECTION SUPPRESSED! 7 | -------------------------------------------------------------------------------- /src/f2cl/packages/donlp2/FRACXOPT.MES: -------------------------------------------------------------------------------- 1 | DONLP2, V3, 05/29/98, COPYRIGHT P. SPELLUCCI 2 | FRAC_OPT 3 | STEP= 4 4 | RESCALING OF OBJECTIVE FUNCTION SCF= 1.0000000000000D-04 5 | STEP= 15 6 | RESCALING OF OBJECTIVE FUNCTION SCF= 9.5060458116873D-03 7 | -------------------------------------------------------------------------------- /src/f2cl/packages/donlp2/GIRDERDE.MES: -------------------------------------------------------------------------------- 1 | DONLP2, V3, 05/29/98, COPYRIGHT P. SPELLUCCI 2 | GIRDERDESIGN 3 | STEP= 6 4 | RESCALING OF OBJECTIVE FUNCTION SCF= 1.2777360972412D-02 5 | STEP= 17 6 | RESCALING OF OBJECTIVE FUNCTION SCF= 43.369497238147 7 | STEP= 84 8 | RESCALING OF OBJECTIVE FUNCTION SCF= 599.92488158338 9 | -------------------------------------------------------------------------------- /src/f2cl/packages/donlp2/HS101XXX.MES: -------------------------------------------------------------------------------- 1 | DONLP2, V3, 05/29/98, COPYRIGHT P. SPELLUCCI 2 | HS101 3 | STEP= 23 4 | RESCALING OF OBJECTIVE FUNCTION SCF= 7.0475149093281D-04 5 | -------------------------------------------------------------------------------- /src/f2cl/packages/donlp2/HS102XXX.MES: -------------------------------------------------------------------------------- 1 | DONLP2, V3, 05/29/98, COPYRIGHT P. SPELLUCCI 2 | HS102 3 | STEP= 22 4 | RESCALING OF OBJECTIVE FUNCTION SCF= 1.5232251542000D-04 5 | -------------------------------------------------------------------------------- /src/f2cl/packages/donlp2/HS103XXX.MES: -------------------------------------------------------------------------------- 1 | DONLP2, V3, 05/29/98, COPYRIGHT P. SPELLUCCI 2 | HS103 3 | STEP= 25 4 | RESCALING OF OBJECTIVE FUNCTION SCF= 3.9142938365327D-04 5 | STEP= 36 6 | SECOND ORDER CORRECTION SUPPRESSED! 7 | STEP= 37 8 | SECOND ORDER CORRECTION SUPPRESSED! 9 | STEP= 38 10 | SECOND ORDER CORRECTION SUPPRESSED! 11 | -------------------------------------------------------------------------------- /src/f2cl/packages/donlp2/HS109XXX.MES: -------------------------------------------------------------------------------- 1 | STEP= 0 2 | STARTVALUE CORRECTED IN ORDER TO FIT BOUNDS 3 | DONLP2, V3, 05/29/98, COPYRIGHT P. SPELLUCCI 4 | HS109 5 | STEP= 1 6 | RANKDEFICIENCY OF GRAD'S OF ACTIVE CONSTR.! 7 | DEL= 1.0000000000000D-07 8 | STEP= 1 9 | RANKDEFICIENCY OF GRAD'S OF ACTIVE CONSTR.! 10 | DEL= 1.0000000000000D-07 11 | STEP= 3 12 | RANKDEFICIENCY OF GRAD'S OF ACTIVE CONSTR.! 13 | ON THE BASIS OF DELMIN! 14 | STEP= 3 15 | RANKDEFICIENCY OF GRAD'S OF ACTIVE CONSTR.! 16 | DEL= 1.0000000000000D-07 17 | STEP= 3 18 | RANKDEFICIENCY OF GRAD'S OF ACTIVE CONSTR.! 19 | DEL= 1.0000000000000D-07 20 | STEP= 6 21 | RESCALING OF OBJECTIVE FUNCTION SCF= 10000.0000000000 22 | -------------------------------------------------------------------------------- /src/f2cl/packages/donlp2/MARATOS0.MES: -------------------------------------------------------------------------------- 1 | DONLP2, V3, 05/29/98, COPYRIGHT P. SPELLUCCI 2 | MARATOS0 3 | -------------------------------------------------------------------------------- /src/f2cl/packages/donlp2/NMFCQ11X.MES: -------------------------------------------------------------------------------- 1 | DONLP2, V3, 05/29/98, COPYRIGHT P. SPELLUCCI 2 | NMFCQ11 3 | STEP= 1 4 | RANKDEFICIENCY OF GRAD'S OF ACTIVE CONSTR.! 5 | ON THE BASIS OF DELMIN! 6 | STEP= 1 7 | RANKDEFICIENCY OF GRAD'S OF ACTIVE CONSTR.! 8 | DEL= 1.0000000000000D-06 9 | STEP= 1 10 | RANKDEFICIENCY OF GRAD'S OF ACTIVE CONSTR.! 11 | DEL= 1.0000000000000D-01 12 | STEP= 1 13 | TRY REGULARIZED SQP WITH INCREASED WEIGHTS 14 | NO DECREASE OF WEIGHTS POSSIBLE 15 | AND INCOMPATIBILITY LARGE 16 | -------------------------------------------------------------------------------- /src/f2cl/packages/donlp2/TP383MOD.MES: -------------------------------------------------------------------------------- 1 | DONLP2, V3, 05/29/98, COPYRIGHT P. SPELLUCCI 2 | TP383MOD 3 | STEP= 22 4 | RESCALING OF OBJECTIVE FUNCTION SCF= 1.0000000000000D-04 5 | -------------------------------------------------------------------------------- /src/f2cl/packages/donlp2/UNDEFEXA.MES: -------------------------------------------------------------------------------- 1 | DONLP2, V3, 05/29/98, COPYRIGHT P. SPELLUCCI 2 | UNDEFEXA 3 | STEP 1 4 | REDUCE STEPSIZE DUE TO ERROR-INDICATOR SET 5 | BY USERS FUNCTION EVALUATION 6 | STEP 1 7 | REDUCE STEPSIZE DUE TO ERROR-INDICATOR SET 8 | BY USERS FUNCTION EVALUATION 9 | STEP 2 10 | REDUCE STEPSIZE DUE TO ERROR-INDICATOR SET 11 | BY USERS FUNCTION EVALUATION 12 | STEP 2 13 | REDUCE STEPSIZE DUE TO ERROR-INDICATOR SET 14 | BY USERS FUNCTION EVALUATION 15 | STEP 2 16 | REDUCE STEPSIZE DUE TO ERROR-INDICATOR SET 17 | BY USERS FUNCTION EVALUATION 18 | STEP= 4 19 | SECOND ORDER CORRECTION SUPPRESSED! 20 | STEP= 5 21 | SECOND ORDER CORRECTION SUPPRESSED! 22 | -------------------------------------------------------------------------------- /src/f2cl/packages/donlp2/WEAPONH2.MES: -------------------------------------------------------------------------------- 1 | DONLP2, V3, 05/29/98, COPYRIGHT P. SPELLUCCI 2 | WEAPONH23 3 | -------------------------------------------------------------------------------- /src/f2cl/packages/fftpack5/cfft1i.f: -------------------------------------------------------------------------------- 1 | CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC 2 | C 3 | C FFTPACK 5.0 4 | C 5 | C Authors: Paul N. Swarztrauber and Richard A. Valent 6 | C 7 | C $Id: cfft1i.f,v 1.1 2010/02/23 01:10:43 rtoy Exp $ 8 | C 9 | CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC 10 | 11 | SUBROUTINE CFFT1I (N, WSAVE, LENSAV, IER) 12 | INTEGER N, LENSAV, IER 13 | REAL WSAVE(LENSAV) 14 | C 15 | IER = 0 16 | C 17 | IF (LENSAV .LT. 2*N + INT(LOG(REAL(N))) + 4) THEN 18 | IER = 2 19 | CALL XERFFT ('CFFTMI ', 3) 20 | ENDIF 21 | C 22 | IF (N .EQ. 1) RETURN 23 | C 24 | IW1 = N+N+1 25 | CALL MCFTI1 (N,WSAVE,WSAVE(IW1),WSAVE(IW1+1)) 26 | RETURN 27 | END 28 | -------------------------------------------------------------------------------- /src/f2cl/packages/fftpack5/cfftmi.f: -------------------------------------------------------------------------------- 1 | CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC 2 | C 3 | C FFTPACK 5.0 4 | C 5 | C Authors: Paul N. Swarztrauber and Richard A. Valent 6 | C 7 | C $Id: cfftmi.f,v 1.1 2010/02/23 01:10:43 rtoy Exp $ 8 | C 9 | CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC 10 | 11 | SUBROUTINE CFFTMI (N, WSAVE, LENSAV, IER) 12 | INTEGER N, LENSAV, IER 13 | REAL WSAVE(LENSAV) 14 | C 15 | IER = 0 16 | C 17 | IF (LENSAV .LT. 2*N + INT(LOG(REAL(N))) + 4) THEN 18 | IER = 2 19 | CALL XERFFT ('CFFTMI ', 3) 20 | ENDIF 21 | C 22 | IF (N .EQ. 1) RETURN 23 | C 24 | IW1 = N+N+1 25 | CALL MCFTI1 (N,WSAVE,WSAVE(IW1),WSAVE(IW1+1)) 26 | RETURN 27 | END 28 | -------------------------------------------------------------------------------- /src/f2cl/packages/fftpack5/factor.f: -------------------------------------------------------------------------------- 1 | CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC 2 | C 3 | C FFTPACK 5.0 4 | C 5 | C Authors: Paul N. Swarztrauber and Richard A. Valent 6 | C 7 | C $Id: factor.f,v 1.1 2010/02/23 01:10:43 rtoy Exp $ 8 | C 9 | CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC 10 | 11 | SUBROUTINE FACTOR (N,NF,FAC) 12 | REAL FAC(*) 13 | INTEGER NTRYH(4) 14 | DATA NTRYH(1),NTRYH(2),NTRYH(3),NTRYH(4)/4,2,3,5/ 15 | C 16 | NL = N 17 | NF = 0 18 | J = 0 19 | 101 J = J+1 20 | IF (J-4) 102,102,103 21 | 102 NTRY = NTRYH(J) 22 | GO TO 104 23 | 103 NTRY = NTRY+2 24 | 104 NQ = NL/NTRY 25 | NR = NL-NTRY*NQ 26 | IF (NR) 101,105,101 27 | 105 NF = NF+1 28 | FAC(NF) = NTRY 29 | NL = NQ 30 | IF (NL .NE. 1) GO TO 104 31 | RETURN 32 | END 33 | -------------------------------------------------------------------------------- /src/f2cl/packages/fftpack5/fftpack5.lisp: -------------------------------------------------------------------------------- 1 | (defpackage :fftpack5 2 | (:use :common-lisp)) 3 | -------------------------------------------------------------------------------- /src/f2cl/packages/fftpack5/fftpack5.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/blindglobe/clocc/a50bb75edb01039b282cf320e4505122a59c59a7/src/f2cl/packages/fftpack5/fftpack5.pdf -------------------------------------------------------------------------------- /src/f2cl/packages/fftpack5/mcfti1.f: -------------------------------------------------------------------------------- 1 | CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC 2 | C 3 | C FFTPACK 5.0 4 | C 5 | C Authors: Paul N. Swarztrauber and Richard A. Valent 6 | C 7 | C $Id: mcfti1.f,v 1.1 2010/02/23 01:10:43 rtoy Exp $ 8 | C 9 | CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC 10 | 11 | SUBROUTINE MCFTI1 (N,WA,FNF,FAC) 12 | REAL WA(*),FAC(*) 13 | C 14 | CALL FACTOR (N,NF,FAC) 15 | FNF = NF 16 | IW = 1 17 | L1 = 1 18 | DO 110 K1=1,NF 19 | IP = FAC(K1) 20 | L2 = L1*IP 21 | IDO = N/L2 22 | CALL TABLES (IDO,IP,WA(IW)) 23 | IW = IW+(IP-1)*(IDO+IDO) 24 | L1 = L2 25 | 110 CONTINUE 26 | RETURN 27 | END 28 | -------------------------------------------------------------------------------- /src/f2cl/packages/fftpack5/rfft1i.f: -------------------------------------------------------------------------------- 1 | CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC 2 | C 3 | C FFTPACK 5.0 4 | C 5 | C Authors: Paul N. Swarztrauber and Richard A. Valent 6 | C 7 | C $Id: rfft1i.f,v 1.1 2010/02/23 01:10:43 rtoy Exp $ 8 | C 9 | CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC 10 | 11 | SUBROUTINE RFFT1I ( N, WSAVE, LENSAV, IER ) 12 | INTEGER N, LENSAV, IER 13 | REAL WSAVE(LENSAV) 14 | C 15 | IER = 0 16 | C 17 | IF (LENSAV .LT. N + INT(LOG(REAL(N))) +4) THEN 18 | IER = 2 19 | CALL XERFFT ('RFFT1I ', 3) 20 | ENDIF 21 | C 22 | IF (N .EQ. 1) RETURN 23 | C 24 | CALL RFFTI1 (N,WSAVE(1),WSAVE(N+1)) 25 | RETURN 26 | END 27 | -------------------------------------------------------------------------------- /src/f2cl/packages/fftpack5/rfftmi.f: -------------------------------------------------------------------------------- 1 | CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC 2 | C 3 | C FFTPACK 5.0 4 | C 5 | C Authors: Paul N. Swarztrauber and Richard A. Valent 6 | C 7 | C $Id: rfftmi.f,v 1.1 2010/02/23 01:10:43 rtoy Exp $ 8 | C 9 | CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC 10 | 11 | SUBROUTINE RFFTMI (N, WSAVE, LENSAV, IER) 12 | INTEGER N, LENSAV, IER 13 | REAL WSAVE(LENSAV) 14 | C 15 | IER = 0 16 | C 17 | IF (LENSAV .LT. N + INT(LOG(REAL(N))) +4) THEN 18 | IER = 2 19 | CALL XERFFT ('RFFTMI ', 3) 20 | ENDIF 21 | C 22 | IF (N .EQ. 1) RETURN 23 | C 24 | CALL MRFTI1 (N,WSAVE(1),WSAVE(N+1)) 25 | RETURN 26 | END 27 | -------------------------------------------------------------------------------- /src/f2cl/packages/fftpack5/sinq1i.f: -------------------------------------------------------------------------------- 1 | CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC 2 | C 3 | C FFTPACK 5.0 4 | C 5 | C Authors: Paul N. Swarztrauber and Richard A. Valent 6 | C 7 | C $Id: sinq1i.f,v 1.1 2010/02/23 01:10:43 rtoy Exp $ 8 | C 9 | CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC 10 | 11 | SUBROUTINE SINQ1I (N, WSAVE, LENSAV, IER) 12 | INTEGER N, LENSAV, IER 13 | REAL WSAVE(LENSAV) 14 | C 15 | IER = 0 16 | C 17 | IF (LENSAV .LT. 2*N + INT(LOG(REAL(N))) +4) THEN 18 | IER = 2 19 | CALL XERFFT ('SINQ1I', 3) 20 | GO TO 300 21 | ENDIF 22 | C 23 | CALL COSQ1I (N, WSAVE, LENSAV, IER1) 24 | IF (IER1 .NE. 0) THEN 25 | IER = 20 26 | CALL XERFFT ('SINQ1I',-5) 27 | ENDIF 28 | 300 RETURN 29 | END 30 | -------------------------------------------------------------------------------- /src/f2cl/packages/fftpack5/sinqmi.f: -------------------------------------------------------------------------------- 1 | CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC 2 | C 3 | C FFTPACK 5.0 4 | C 5 | C Authors: Paul N. Swarztrauber and Richard A. Valent 6 | C 7 | C $Id: sinqmi.f,v 1.1 2010/02/23 01:10:43 rtoy Exp $ 8 | C 9 | CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC 10 | 11 | SUBROUTINE SINQMI (N, WSAVE, LENSAV, IER) 12 | INTEGER N, LENSAV, IER 13 | REAL WSAVE(LENSAV) 14 | C 15 | IER = 0 16 | C 17 | IF (LENSAV .LT. 2*N + INT(LOG(REAL(N))) +4) THEN 18 | IER = 2 19 | CALL XERFFT ('SINQMI', 3) 20 | GO TO 300 21 | ENDIF 22 | C 23 | CALL COSQMI (N, WSAVE, LENSAV, IER1) 24 | IF (IER1 .NE. 0) THEN 25 | IER = 20 26 | CALL XERFFT ('SINQMI',-5) 27 | ENDIF 28 | 300 CONTINUE 29 | RETURN 30 | END 31 | -------------------------------------------------------------------------------- /src/f2cl/packages/fftpack5/tables.f: -------------------------------------------------------------------------------- 1 | CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC 2 | C 3 | C FFTPACK 5.0 4 | C 5 | C Authors: Paul N. Swarztrauber and Richard A. Valent 6 | C 7 | C $Id: tables.f,v 1.1 2010/02/23 01:10:43 rtoy Exp $ 8 | C 9 | CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC 10 | 11 | SUBROUTINE TABLES (IDO,IP,WA) 12 | REAL WA(IDO,IP-1,2) 13 | C 14 | TPI = 8.*ATAN(1.) 15 | ARGZ = TPI/REAL(IP) 16 | ARG1 = TPI/REAL(IDO*IP) 17 | DO 110 J=2,IP 18 | ARG2 = REAL(J-1)*ARG1 19 | DO 100 I=1,IDO 20 | ARG3 = REAL(I-1)*ARG2 21 | WA(I,J-1,1) = COS(ARG3) 22 | WA(I,J-1,2) = SIN(ARG3) 23 | 100 CONTINUE 24 | IF (IP .LE. 5) GO TO 110 25 | ARG4 = REAL(J-1)*ARGZ 26 | WA(1,J-1,1) = COS(ARG4) 27 | WA(1,J-1,2) = SIN(ARG4) 28 | 110 CONTINUE 29 | RETURN 30 | END 31 | -------------------------------------------------------------------------------- /src/f2cl/packages/fishpack/.cvsignore: -------------------------------------------------------------------------------- 1 | *.lisp 2 | *.ppcf 3 | *.sse2f 4 | tsthstcsp 5 | tsthstcyl 6 | tsthstplr 7 | tsthstssp 8 | tsthwscrt 9 | tsthwscsp 10 | tsthwscyl 11 | tsthwsplr 12 | tsthwsssp 13 | tstsepx4 14 | -------------------------------------------------------------------------------- /src/f2cl/packages/fishpack/bsrh.f: -------------------------------------------------------------------------------- 1 | FUNCTION BSRH (XLL,XRR,IZ,C,A,BH,F,SGN) 2 | DIMENSION A(1) ,C(1) ,BH(1) 3 | COMMON /CBLKT/ NPP ,K ,EPS ,CNV , 4 | 1 NM ,NCMPLX ,IK 5 | XL = XLL 6 | XR = XRR 7 | DX = .5*ABS(XR-XL) 8 | 101 X = .5*(XL+XR) 9 | IF (SGN*F(X,IZ,C,A,BH)) 103,105,102 10 | 102 XR = X 11 | GO TO 104 12 | 103 XL = X 13 | 104 DX = .5*DX 14 | IF (DX-CNV) 105,105,101 15 | 105 BSRH = .5*(XL+XR) 16 | RETURN 17 | END 18 | -------------------------------------------------------------------------------- /src/f2cl/packages/fishpack/cofx.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE COFX (X,AF,BF,CF) 2 | C 3 | C SET COEFFICIENTS IN THE X-DIRECTION. 4 | C 5 | AF = (X+1.)**2 6 | BF = 2.0*(X+1.) 7 | CF = -X 8 | RETURN 9 | END 10 | -------------------------------------------------------------------------------- /src/f2cl/packages/fishpack/epmach.f: -------------------------------------------------------------------------------- 1 | FUNCTION EPMACH (DUM) 2 | C 3 | C THIS PROGRAM COMPUTES AN APPROXIMATE MACHIINE EPSILON (ACCURACY) 4 | C 5 | COMMON /VALUE/ V 6 | EPS = 1. 7 | 101 EPS = EPS/10. 8 | CALL STORE (EPS+1.) 9 | IF (V-1.) 102,102,101 10 | 102 EPMACH = 100.*EPS 11 | RETURN 12 | END 13 | -------------------------------------------------------------------------------- /src/f2cl/packages/fishpack/ex/.cvsignore: -------------------------------------------------------------------------------- 1 | *.lisp 2 | *.ppcf 3 | *.sse2f 4 | tsthwscsp 5 | tsthwscyl 6 | -------------------------------------------------------------------------------- /src/f2cl/packages/fishpack/ex/cofx4.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE COFX4(X,AF,BF,CF) 2 | C 3 | C SET COEFFICIENTS IN THE X-DIRECTION. 4 | C 5 | AF = (X+1.)**2 6 | BF = 2.0*(X+1.) 7 | CF = -X 8 | RETURN 9 | END 10 | -------------------------------------------------------------------------------- /src/f2cl/packages/fishpack/indxa.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE INDXA (I,IR,IDXA,NA) 2 | COMMON /CBLKT/ NPP ,K ,EPS ,CNV , 3 | 1 NM ,NCMPLX ,IK 4 | NA = 2**IR 5 | IDXA = I-NA+1 6 | IF (I-NM) 102,102,101 7 | 101 NA = 0 8 | 102 RETURN 9 | END 10 | -------------------------------------------------------------------------------- /src/f2cl/packages/fishpack/indxb.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE INDXB (I,IR,IDX,IDP) 2 | C 3 | C B(IDX) IS THE LOCATION OF THE FIRST ROOT OF THE B(I,IR) POLYNOMIAL 4 | C 5 | COMMON /CBLKT/ NPP ,K ,EPS ,CNV , 6 | 1 NM ,NCMPLX ,IK 7 | IDP = 0 8 | IF (IR) 107,101,103 9 | 101 IF (I-NM) 102,102,107 10 | 102 IDX = I 11 | IDP = 1 12 | RETURN 13 | 103 IZH = 2**IR 14 | ID = I-IZH-IZH 15 | IDX = ID+ID+(IR-1)*IK+IR+(IK-I)/IZH+4 16 | IPL = IZH-1 17 | IDP = IZH+IZH-1 18 | IF (I-IPL-NM) 105,105,104 19 | 104 IDP = 0 20 | RETURN 21 | 105 IF (I+IPL-NM) 107,107,106 22 | 106 IDP = NM+IPL-I+1 23 | 107 RETURN 24 | END 25 | -------------------------------------------------------------------------------- /src/f2cl/packages/fishpack/indxc.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE INDXC (I,IR,IDXC,NC) 2 | COMMON /CBLKT/ NPP ,K ,EPS ,CNV , 3 | 1 NM ,NCMPLX ,IK 4 | NC = 2**IR 5 | IDXC = I 6 | IF (IDXC+NC-1-NM) 102,102,101 7 | 101 NC = 0 8 | 102 RETURN 9 | END 10 | -------------------------------------------------------------------------------- /src/f2cl/packages/fishpack/junk.f: -------------------------------------------------------------------------------- 1 | subroutine junk(tcos, k1, k2, k, jr) 2 | if = 37 3 | end 4 | 5 | -------------------------------------------------------------------------------- /src/f2cl/packages/fishpack/pimach.f: -------------------------------------------------------------------------------- 1 | FUNCTION PIMACH (DUM) 2 | C 3 | C THIS SUBPROGRAM SUPPLIES THE VALUE OF THE CONSTANT PI CORRECT TO 4 | C MACHINE PRECISION WHERE 5 | C 6 | C PI=3.1415926535897932384626433832795028841971693993751058209749446 7 | C 8 | PIMACH = 3.14159265358979 9 | RETURN 10 | END 11 | -------------------------------------------------------------------------------- /src/f2cl/packages/fishpack/ppsgf.f: -------------------------------------------------------------------------------- 1 | FUNCTION PPSGF (X,IZ,C,A,BH) 2 | DIMENSION A(1) ,C(1) ,BH(1) 3 | SUM = 0. 4 | DO 101 J=1,IZ 5 | SUM = SUM-1./(X-BH(J))**2 6 | 101 CONTINUE 7 | PPSGF = SUM 8 | RETURN 9 | END 10 | -------------------------------------------------------------------------------- /src/f2cl/packages/fishpack/ppspf.f: -------------------------------------------------------------------------------- 1 | FUNCTION PPSPF (X,IZ,C,A,BH) 2 | DIMENSION A(1) ,C(1) ,BH(1) 3 | SUM = 0. 4 | DO 101 J=1,IZ 5 | SUM = SUM+1./(X-BH(J)) 6 | 101 CONTINUE 7 | PPSPF = SUM 8 | RETURN 9 | END 10 | -------------------------------------------------------------------------------- /src/f2cl/packages/fishpack/psgf.f: -------------------------------------------------------------------------------- 1 | FUNCTION PSGF (X,IZ,C,A,BH) 2 | DIMENSION A(1) ,C(1) ,BH(1) 3 | FSG = 1. 4 | HSG = 1. 5 | DO 101 J=1,IZ 6 | DD = 1./(X-BH(J)) 7 | FSG = FSG*A(J)*DD 8 | HSG = HSG*C(J)*DD 9 | 101 CONTINUE 10 | IF (MOD(IZ,2)) 103,102,103 11 | 102 PSGF = 1.-FSG-HSG 12 | RETURN 13 | 103 PSGF = 1.+FSG+HSG 14 | RETURN 15 | END 16 | -------------------------------------------------------------------------------- /src/f2cl/packages/fishpack/store.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE STORE (X) 2 | COMMON /VALUE/ V 3 | V = X 4 | RETURN 5 | END 6 | -------------------------------------------------------------------------------- /src/f2cl/packages/fishpack/trid.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE TRID (MR,A,B,C,Y,D) 2 | DIMENSION A(1) ,B(1) ,C(1) ,Y(1) , 3 | 1 D(1) 4 | M = MR 5 | MM1 = M-1 6 | Z = 1./B(1) 7 | D(1) = C(1)*Z 8 | Y(1) = Y(1)*Z 9 | DO 101 I=2,MM1 10 | Z = 1./(B(I)-A(I)*D(I-1)) 11 | D(I) = C(I)*Z 12 | Y(I) = (Y(I)-A(I)*Y(I-1))*Z 13 | 101 CONTINUE 14 | Z = B(M)-A(M)*D(MM1) 15 | IF (Z .NE. 0.) GO TO 102 16 | Y(M) = 0. 17 | GO TO 103 18 | 102 Y(M) = (Y(M)-A(M)*Y(MM1))/Z 19 | 103 CONTINUE 20 | DO 104 IP=1,MM1 21 | I = M-IP 22 | Y(I) = Y(I)-D(I)*Y(I+1) 23 | 104 CONTINUE 24 | RETURN 25 | END 26 | -------------------------------------------------------------------------------- /src/f2cl/packages/fishpack/tsthstcsp.out: -------------------------------------------------------------------------------- 1 | 1 subroutine hstcsp example 2 | 3 | 4 | the output from the ncar control data 7600 was 5 | 6 | ierror = 0 7 | discretization error = 5.58432e-03 8 | required length of w array = 583 9 | 10 | the output from your computer is 11 | 12 | ierror = 0 13 | discretization error = 0.55845E-02 14 | required length of w array =583. 15 | -------------------------------------------------------------------------------- /src/f2cl/packages/fishpack/tsthstcyl.out: -------------------------------------------------------------------------------- 1 | 1 subroutine hstcyl example 2 | 3 | 4 | the output from the ncar control data 7600 was 5 | 6 | ierror = 0 7 | pertrb =-4.43114e-04 8 | discretization error = 7.52796e-05 9 | required length of w array = 958 10 | 11 | the output from your computer is 12 | 13 | ierror = 0 14 | pertrb =-0.44321E-03 15 | discretization error = 0.73349E-04 16 | required length of w array =958. 17 | -------------------------------------------------------------------------------- /src/f2cl/packages/fishpack/tsthstplr.out: -------------------------------------------------------------------------------- 1 | 1 subroutine hstplr example 2 | 3 | 4 | the output from the ncar control data 7600 was 5 | 6 | ierror = 0 7 | discretization error = 1.13038e-03 8 | required length of w array = 1042 9 | 10 | the output from your computer is 11 | 12 | ierror = 0 13 | discretization error = 0.11300E-02 14 | required length of w array =1042. 15 | -------------------------------------------------------------------------------- /src/f2cl/packages/fishpack/tsthstssp.out: -------------------------------------------------------------------------------- 1 | 1 subroutine hstssp example 2 | 3 | 4 | the output from the ncar control data 7600 was 5 | 6 | ierror = 0 7 | pertrb = 6.35830e-04 8 | discretization error = 3.37523e-03 9 | required length of w array = 540 10 | 11 | the output from your computer is 12 | 13 | ierror = 0 14 | pertrb = 0.63592E-03 15 | discretization error = 0.33820E-02 16 | required length of w array =540. 17 | -------------------------------------------------------------------------------- /src/f2cl/packages/fishpack/tsthwscrt.out: -------------------------------------------------------------------------------- 1 | 1 subroutine hwscrt example 2 | 3 | 4 | the output from the ncar control data 7600 was 5 | 6 | ierror = 0 7 | discretization error = 5.36508e-04 8 | required length of w array = 880 9 | 10 | the output from your computer is 11 | 12 | ierror = 0 13 | discretization error = 0.49305E-03 14 | required length of w array =880. 15 | -------------------------------------------------------------------------------- /src/f2cl/packages/fishpack/tsthwscsp.out: -------------------------------------------------------------------------------- 1 | 1 subroutine hwscsp example 1 2 | 3 | 4 | the output from the ncar control data 7600 was 5 | 6 | ierror = 0 7 | discretization error = 7.99842e-04 8 | required length of w array = 775 9 | 10 | the output from your computer is 11 | 12 | ierror = 0 13 | discretization error = 0.79940E-03 14 | required length of w array = 775 15 | 1 subroutine hwscsp example 2 16 | 17 | 18 | the output from the ncar control data 7600 was 19 | 20 | ierror = 0 21 | discretization error = 5.86824e-05 22 | required length of w array = 775 23 | 24 | the output from your computer is 25 | 26 | ierror = 0 27 | discretization error = 0.57191E-04 28 | required length of w array = 775 29 | -------------------------------------------------------------------------------- /src/f2cl/packages/fishpack/tsthwscyl.out: -------------------------------------------------------------------------------- 1 | 1 subroutine hwscyl example 2 | 3 | 4 | the output from the ncar control data 7600 was 5 | 6 | ierror = 0 7 | pertrb = 2.26734e-04 8 | discretization error = 3.73672e-04 9 | required length of w array = 1118 10 | 11 | the output from your computer is 12 | 13 | ierror = 0 14 | pertrb = 0.22698E-03 15 | discretization error = 0.35632E-03 16 | required length of w array =1118. 17 | -------------------------------------------------------------------------------- /src/f2cl/packages/fishpack/tsthwsplr.out: -------------------------------------------------------------------------------- 1 | 1 subroutine hwsplr example 2 | 3 | 4 | the output from the ncar control data 7600 was 5 | 6 | ierror = 0 7 | discretization error = 6.19134e-04 8 | required length of w array = 882 9 | 10 | the output from your computer is 11 | 12 | ierror = 0 13 | discretization error = 0.62072E-03 14 | required length of w array =882. 15 | -------------------------------------------------------------------------------- /src/f2cl/packages/fishpack/tsthwsssp.out: -------------------------------------------------------------------------------- 1 | 1 subroutine hwsssp example 2 | 3 | 4 | the output from the ncar control data 7600 was 5 | 6 | ierror = 0 7 | discretization error = 3.38107e-03 8 | required length of w array = 600 9 | 10 | the output from your computer is 11 | 12 | ierror = 0 13 | discretization error = 0.33646E-02 14 | required length of w array = 600 15 | -------------------------------------------------------------------------------- /src/f2cl/packages/fishpack/tstsepx4.out: -------------------------------------------------------------------------------- 1 | 1 subroutine sepx4 example 2 | 3 | 4 | the output from the ncar control data 7600 was 5 | 6 | ierror = 0 7 | second order discretization error = 1.5985e-04 8 | fourth order discretization error = 1.85749e-06 9 | required length of w array = 1024 10 | 11 | the output from your computer is 12 | 13 | ierror = 0 14 | second order discretization error = 0.15044E-03 15 | fourth order discretization error = 0.15736E-04 16 | required length of w array = 1024 17 | -------------------------------------------------------------------------------- /src/f2cl/packages/hompack/f.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE F(X,V) 2 | DOUBLE PRECISION X(1),V(1) 3 | C 4 | C EVALUATE F(X) AND RETURN IN THE VECTOR V . 5 | C 6 | RETURN 7 | END 8 | -------------------------------------------------------------------------------- /src/f2cl/packages/hompack/fjac.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE FJAC(X,V,K) 2 | DOUBLE PRECISION X(1),V(1) 3 | INTEGER K 4 | C 5 | C RETURN IN V THE KTH COLUMN OF THE JACOBIAN MATRIX OF 6 | C F(X) EVALUATED AT X . 7 | C 8 | RETURN 9 | END 10 | -------------------------------------------------------------------------------- /src/f2cl/packages/hompack/fjacs.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE FJACS(X,QR,LENQR,PIVOT) 2 | INTEGER LENQR,N,PIVOT(N+2) 3 | DOUBLE PRECISION QR(LENQR),X(N) 4 | C 5 | C Evaluate the N x N symmetric Jacobian matrix of F(X) at X, and return 6 | C the result in packed skyline storage format in QR. LENQR is the length 7 | C of QR, and PIVOT contains the indices of the diagonal elements of the 8 | C Jacobian matrix within QR. PIVOT(N+1) and PIVOT(N+2) are set by 9 | C subroutine FODE. 10 | C 11 | RETURN 12 | END 13 | -------------------------------------------------------------------------------- /src/f2cl/packages/hompack/hompack-package.lisp: -------------------------------------------------------------------------------- 1 | (defpackage "HOMPACK" 2 | (:use "COMMON-LISP" "BLAS")) 3 | 4 | -------------------------------------------------------------------------------- /src/f2cl/packages/hompack/qimuds.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE QIMUDS(Q,F,MAXA,NN,LENAA) 2 | C 3 | C computes f := [Q**(-1)] * f . 4 | C 5 | C on input: 6 | C 7 | C Q is the preconditioning matrix, and contains an approximate 8 | C factorization of M. 9 | C 10 | C f is the right hand side vector, Q z = f . 11 | C 12 | C MAXA, NN, LENAA describe Q in packed skyline storage format. 13 | C 14 | C on output: 15 | C 16 | C Q, MAXA, NN, LENAA are unchanged. 17 | C 18 | C f contains the solution z of Q z = f . 19 | C 20 | C 21 | C Calls SOLVDS . 22 | C 23 | INTEGER LENAA,LENQ,NN,MAXA(NN+2),NQ 24 | DOUBLE PRECISION Q(LENAA+NN+1),F(NN+1) 25 | C 26 | NQ=NN+1 27 | LENQ=MAXA(NN+2)-1 28 | C 29 | CALL SOLVDS(NQ,Q,LENQ,MAXA,F) 30 | C 31 | RETURN 32 | END 33 | -------------------------------------------------------------------------------- /src/f2cl/packages/hompack/ref-mainf.txt: -------------------------------------------------------------------------------- 1 | 2 | 3 | TESTING FIXPQF 4 | 5 | 6 | LAMBDA = 1.00000000 FLAG = 1 6 JACOBIAN EVALUATIONS 7 | EXECUTION TIME(SECS) = 0.00 ARCLEN = 2.693 8 | 1.00000000E+00 1.00000000E+00 1.00000000E+00 9 | 1.00000000E+00 1.00000000E+00 10 | 11 | 12 | TESTING FIXPNF 13 | 14 | 15 | LAMBDA = 1.00000000 FLAG = 1 22 JACOBIAN EVALUATIONS 16 | EXECUTION TIME(SECS) = 0.00 ARCLEN = 2.682 17 | 1.00000000E+00 1.00000000E+00 1.00000000E+00 18 | 1.00000000E+00 1.00000000E+00 19 | 20 | 21 | TESTING FIXPDF 22 | 23 | 24 | LAMBDA = 1.00000000 FLAG = 1 71 JACOBIAN EVALUATIONS 25 | EXECUTION TIME(SECS) = 0.00 ARCLEN = 2.712 26 | 1.00000000E+00 1.00000000E+00 1.00000000E+00 27 | 1.00000000E+00 1.00000000E+00 28 | -------------------------------------------------------------------------------- /src/f2cl/packages/hompack/ref-mains.txt: -------------------------------------------------------------------------------- 1 | 2 | 3 | TESTING FIXPQS 4 | 5 | LAMBDA = 1.00000000 FLAG = 1 33 JACOBIAN EVALUATIONS 6 | ARC LENGTH = 1.274 EXECUTION TIME(SECS) = 0.00 7 | 4.00864019E-01 2.65454893E-01 8.40421103E-02 4.83042527E-01 8 | 3.01797132E-01 2.32508994E-01 4.96639853E-01 3.00908894E-01 9 | 10 | 11 | TESTING FIXPNS 12 | 13 | LAMBDA = 1.00000000 FLAG = 1 20 JACOBIAN EVALUATIONS 14 | ARC LENGTH = 1.275 EXECUTION TIME(SECS) = 0.00 15 | 4.00864019E-01 2.65454893E-01 8.40421103E-02 4.83042527E-01 16 | 3.01797132E-01 2.32508994E-01 4.96639853E-01 3.00908894E-01 17 | 18 | 19 | TESTING FIXPDS 20 | 21 | LAMBDA = 1.00000000 FLAG = 1 70 JACOBIAN EVALUATIONS 22 | ARC LENGTH = 1.281 EXECUTION TIME(SECS) = 0.00 23 | 4.00864019E-01 2.65454893E-01 8.40421103E-02 4.83042527E-01 24 | 3.01797132E-01 2.32508994E-01 4.96639853E-01 3.00908894E-01 25 | -------------------------------------------------------------------------------- /src/f2cl/packages/hompack/rho.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE RHO(A,LAMBDA,X,V,PAR,IPAR) 2 | DOUBLE PRECISION A(*),LAMBDA,X(*),V(*),PAR(*) 3 | INTEGER IPAR(*) 4 | C 5 | C PAR(1:*) AND IPAR(1:*) ARE ARRAYS FOR (OPTIONAL) USER PARAMETERS, 6 | C WHICH ARE SIMPLY PASSED THROUGH TO THE USER WRITTEN SUBROUTINES 7 | C RHO, RHOJAC. 8 | C 9 | C EVALUATE RHO(A,LAMBDA,X) AND RETURN IN THE VECTOR V . 10 | C 11 | C THE FOLLOWING CODE IS SPECIFICALLY FOR THE POLYNOMIAL SYSTEM DRIVER 12 | C POLSYS , AND SHOULD BE USED VERBATUM WITH POLSYS . IF THE USER IS 13 | C CALLING FIXP?? OR STEP?? DIRECTLY, HE MUST SUPPLY APPROPRIATE 14 | C REPLACEMENT CODE HERE. 15 | INTEGER J,N 16 | C FORCE PREDICTED POINT TO HAVE LAMBDA .GE. 0 . 17 | IF (LAMBDA .LT. 0.0) LAMBDA=0.0 18 | CALL HFUNP(A,LAMBDA,X,PAR,IPAR) 19 | N=IPAR(1) 20 | DO 10 J=1,2*N 21 | V(J)=PAR(IPAR(3 + (4-1)) + (J-1)) 22 | 10 CONTINUE 23 | C 24 | RETURN 25 | END 26 | -------------------------------------------------------------------------------- /src/f2cl/packages/hompack/rhoa.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE RHOA(A,LAMBDA,X,PAR,IPAR) 2 | DOUBLE PRECISION A(1),LAMBDA,X(1),PAR(1) 3 | INTEGER IPAR(1) 4 | C 5 | C PAR(1:*) AND IPAR(1:*) ARE ARRAYS FOR (OPTIONAL) USER PARAMETERS, 6 | C WHICH ARE SIMPLY PASSED THROUGH TO THE USER WRITTEN SUBROUTINES 7 | C RHOA, RHOJS. 8 | C 9 | C CALCULATE AND RETURN IN A THE VECTOR Z SUCH THAT 10 | C RHO(Z,LAMBDA,X) = 0 . 11 | C 12 | RETURN 13 | END 14 | -------------------------------------------------------------------------------- /src/f2cl/packages/hompack/rhojs.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE RHOJS(A,LAMBDA,X,QR,LENQR,PIVOT,PP,PAR,IPAR) 2 | INTEGER IPAR(1),LENQR,N,PIVOT(*) 3 | DOUBLE PRECISION A(*),LAMBDA,PAR(1),PP(*),QR(LENQR),X(*) 4 | C 5 | C PAR(1:*) AND IPAR(1:*) ARE ARRAYS FOR (OPTIONAL) USER PARAMETERS, 6 | C WHICH ARE SIMPLY PASSED THROUGH TO THE USER WRITTEN SUBROUTINES 7 | C RHOA, RHOJS. 8 | C 9 | C Evaluate the N X N symmetric Jacobian matrix [D RHO/DX] at (A,X,LAMBDA), 10 | C and return the result in packed skyline storage format in QR. LENQR is 11 | C the length of QR, and PIVOT contains the indices of the diagonal elements 12 | C of [D RHO/DX] within QR. PP contains -[D RHO/D LAMBDA] evaluated at 13 | C (A,X,LAMBDA). Note the minus sign in the definition of PP. 14 | C 15 | RETURN 16 | END 17 | -------------------------------------------------------------------------------- /src/f2cl/packages/lapack/lapack-package.lisp: -------------------------------------------------------------------------------- 1 | (defpackage "LAPACK" 2 | (:use "BLAS" "COMMON-LISP")) 3 | -------------------------------------------------------------------------------- /src/f2cl/packages/minpack/.cvsignore: -------------------------------------------------------------------------------- 1 | *.lisp 2 | *.ppcf 3 | *.sse2f 4 | tst-hybrd 5 | tst-lmder 6 | tst-lmdif 7 | -------------------------------------------------------------------------------- /src/f2cl/packages/minpack/hybrd-input.dat: -------------------------------------------------------------------------------- 1 | 1 2 3 2 | 2 4 3 3 | 3 2 2 4 | 4 4 3 5 | 5 3 3 6 | 6 6 2 7 | 6 9 2 8 | 7 5 3 9 | 7 6 3 10 | 7 7 3 11 | 7 8 1 12 | 7 9 1 13 | 8 10 3 14 | 8 30 1 15 | 8 40 1 16 | 9 10 3 17 | 10 1 3 18 | 10 10 3 19 | 11 10 3 20 | 12 10 3 21 | 13 10 3 22 | 14 10 3 23 | 0 0 0 24 | -------------------------------------------------------------------------------- /src/f2cl/packages/minpack/lmdif-input.dat: -------------------------------------------------------------------------------- 1 | 1 5 10 1 2 | 1 5 50 1 3 | 2 5 10 1 4 | 2 5 50 1 5 | 3 5 10 1 6 | 3 5 50 1 7 | 4 2 2 3 8 | 5 3 3 3 9 | 6 4 4 3 10 | 7 2 2 3 11 | 8 3 15 3 12 | 9 4 11 3 13 | 10 3 16 2 14 | 11 6 31 3 15 | 11 9 31 3 16 | 11 12 31 3 17 | 12 3 10 1 18 | 13 2 10 1 19 | 14 4 20 3 20 | 15 1 8 3 21 | 15 8 8 1 22 | 15 9 9 1 23 | 15 10 10 1 24 | 16 10 10 3 25 | 16 30 30 1 26 | 16 40 40 1 27 | 17 5 33 1 28 | 18 11 65 1 29 | 0 0 0 0 30 | -------------------------------------------------------------------------------- /src/f2cl/packages/minpack/minpack.lisp: -------------------------------------------------------------------------------- 1 | (defpackage :minpack 2 | (:use :common-lisp) 3 | (:export #:lmder #:lmder1 #:lmdif #:lmdif1)) 4 | -------------------------------------------------------------------------------- /src/f2cl/packages/minpack/readme: -------------------------------------------------------------------------------- 1 | ====== readme for minpack ====== 2 | 3 | Minpack includes software for solving nonlinear equations and 4 | nonlinear least squares problems. Five algorithmic paths each include 5 | a core subroutine and an easy-to-use driver. The algorithms proceed 6 | either from an analytic specification of the Jacobian matrix or 7 | directly from the problem functions. The paths include facilities for 8 | systems of equations with a banded Jacobian matrix, for least squares 9 | problems with a large amount of data, and for checking the consistency 10 | of the Jacobian matrix with the functions. 11 | 12 | This directory contains the double-precision versions. 13 | 14 | Jorge More', Burt Garbow, and Ken Hillstrom at Argonne National Laboratory. 15 | 16 | -------------------------------------------------------------------------------- /src/f2cl/packages/odepack/.cvsignore: -------------------------------------------------------------------------------- 1 | *.lisp 2 | demo-lsoda 3 | demo-lsodar 4 | demo-lsode 5 | demo-lsodi 6 | demo-lsodis 7 | demo-lsodkr 8 | demo-lsodpk 9 | demo-lsodpkr 10 | demo-lsoibt 11 | lib 12 | -------------------------------------------------------------------------------- /src/f2cl/packages/odepack/demo1/.cvsignore: -------------------------------------------------------------------------------- 1 | *.sse2f 2 | edit2.lisp 3 | f1.lisp 4 | f2.lisp 5 | jac1.lisp 6 | jac2.lisp 7 | opkdemo1.lisp 8 | -------------------------------------------------------------------------------- /src/f2cl/packages/odepack/demo1/edit2.f: -------------------------------------------------------------------------------- 1 | 2 | subroutine edit2 (y, t, erm) 3 | integer i, j, k, ng 4 | double precision y, t, erm, alph1, alph2, a1, a2, er, ex, yt 5 | dimension y(25) 6 | data alph1/1.0d0/, alph2/1.0d0/, ng/5/ 7 | erm = 0.0d0 8 | if (t .eq. 0.0d0) return 9 | ex = 0.0d0 10 | if (t .le. 30.0d0) ex = exp(-2.0d0*t) 11 | a2 = 1.0d0 12 | do 60 j = 1,ng 13 | a1 = 1.0d0 14 | do 50 i = 1,ng 15 | k = i + (j - 1)*ng 16 | yt = t**(i+j-2)*ex*a1*a2 17 | er = abs(y(k)-yt) 18 | erm = max(erm,er) 19 | a1 = a1*alph1/i 20 | 50 continue 21 | a2 = a2*alph2/j 22 | 60 continue 23 | return 24 | end 25 | -------------------------------------------------------------------------------- /src/f2cl/packages/odepack/demo1/f1.f: -------------------------------------------------------------------------------- 1 | 2 | subroutine f1 (neq, t, y, ydot) 3 | integer neq 4 | double precision t, y, ydot 5 | dimension y(*), ydot(*) 6 | dimension neq(*) 7 | ydot(1) = y(2) 8 | ydot(2) = 3.0d0*(1.0d0 - y(1)*y(1))*y(2) - y(1) 9 | return 10 | end 11 | -------------------------------------------------------------------------------- /src/f2cl/packages/odepack/demo1/f2.f: -------------------------------------------------------------------------------- 1 | 2 | subroutine f2 (neq, t, y, ydot) 3 | integer neq, i, j, k, ng 4 | double precision t, y, ydot, alph1, alph2, d 5 | dimension y(*), ydot(*) 6 | dimension neq(*) 7 | data alph1/1.0d0/, alph2/1.0d0/, ng/5/ 8 | do 10 j = 1,ng 9 | do 10 i = 1,ng 10 | k = i + (j - 1)*ng 11 | d = -2.0d0*y(k) 12 | if (i .ne. 1) d = d + y(k-1)*alph1 13 | if (j .ne. 1) d = d + y(k-ng)*alph2 14 | 10 ydot(k) = d 15 | return 16 | end 17 | -------------------------------------------------------------------------------- /src/f2cl/packages/odepack/demo1/jac1.f: -------------------------------------------------------------------------------- 1 | 2 | subroutine jac1 (neq, t, y, ml, mu, pd, nrowpd) 3 | integer neq, ml, mu, nrowpd 4 | double precision t, y, pd 5 | dimension y(*), pd(nrowpd,*) 6 | dimension neq(*) 7 | pd(1,1) = 0.0d0 8 | pd(1,2) = 1.0d0 9 | pd(2,1) = -6.0d0*y(1)*y(2) - 1.0d0 10 | pd(2,2) = 3.0d0*(1.0d0 - y(1)*y(1)) 11 | return 12 | end 13 | -------------------------------------------------------------------------------- /src/f2cl/packages/odepack/demo1/jac2.f: -------------------------------------------------------------------------------- 1 | 2 | subroutine jac2 (neq, t, y, ml, mu, pd, nrowpd) 3 | integer neq, ml, mu, nrowpd, j, mband, mu1, mu2, ng 4 | double precision t, y, pd, alph1, alph2 5 | dimension y(*), pd(nrowpd,*) 6 | dimension neq(*) 7 | data alph1/1.0d0/, alph2/1.0d0/, ng/5/ 8 | mband = ml + mu + 1 9 | mu1 = mu + 1 10 | mu2 = mu + 2 11 | do 10 j = 1,neq(1) 12 | pd(mu1,j) = -2.0d0 13 | pd(mu2,j) = alph1 14 | 10 pd(mband,j) = alph2 15 | do 20 j = ng,neq(1),ng 16 | 20 pd(mu2,j) = 0.0d0 17 | return 18 | end 19 | -------------------------------------------------------------------------------- /src/f2cl/packages/odepack/demo3/.cvsignore: -------------------------------------------------------------------------------- 1 | edit2.lisp 2 | f1.lisp 3 | f2.lisp 4 | jac1.lisp 5 | jac2.lisp 6 | opkdemo3.lisp 7 | -------------------------------------------------------------------------------- /src/f2cl/packages/odepack/demo3/edit2.f: -------------------------------------------------------------------------------- 1 | 2 | subroutine edit2 (y, t, erm) 3 | integer i, j, k, ng 4 | double precision y, t, erm, alph1, alph2, a1, a2, er, ex, yt 5 | dimension y(*) 6 | data alph1/1.0d0/, alph2/1.0d0/, ng/5/ 7 | erm = 0.0d0 8 | if (t .eq. 0.0d0) return 9 | ex = 0.0d0 10 | if (t .le. 30.0d0) ex = exp(-2.0d0*t) 11 | a2 = 1.0d0 12 | do 60 j = 1,ng 13 | a1 = 1.0d0 14 | do 50 i = 1,ng 15 | k = i + (j - 1)*ng 16 | yt = t**(i+j-2)*ex*a1*a2 17 | er = abs(y(k)-yt) 18 | erm = max(erm,er) 19 | a1 = a1*alph1/i 20 | 50 continue 21 | a2 = a2*alph2/j 22 | 60 continue 23 | return 24 | end 25 | -------------------------------------------------------------------------------- /src/f2cl/packages/odepack/demo3/f1.f: -------------------------------------------------------------------------------- 1 | 2 | subroutine f1 (neq, t, y, ydot) 3 | integer neq 4 | double precision t, y, ydot 5 | dimension y(*), ydot(*) 6 | dimension neq(*) 7 | ydot(1) = y(2) 8 | ydot(2) = 20.0d0*(1.0d0 - y(1)*y(1))*y(2) - y(1) 9 | return 10 | end 11 | -------------------------------------------------------------------------------- /src/f2cl/packages/odepack/demo3/f2.f: -------------------------------------------------------------------------------- 1 | 2 | subroutine f2 (neq, t, y, ydot) 3 | integer neq, i, j, k, ng 4 | double precision t, y, ydot, alph1, alph2, d 5 | dimension y(*), ydot(*) 6 | dimension neq(*) 7 | data alph1/1.0d0/, alph2/1.0d0/, ng/5/ 8 | do 10 j = 1,ng 9 | do 10 i = 1,ng 10 | k = i + (j - 1)*ng 11 | d = -2.0d0*y(k) 12 | if (i .ne. 1) d = d + y(k-1)*alph1 13 | if (j .ne. 1) d = d + y(k-ng)*alph2 14 | 10 ydot(k) = d 15 | return 16 | end 17 | -------------------------------------------------------------------------------- /src/f2cl/packages/odepack/demo3/jac1.f: -------------------------------------------------------------------------------- 1 | 2 | subroutine jac1 (neq, t, y, ml, mu, pd, nrowpd) 3 | integer neq, ml, mu, nrowpd 4 | double precision t, y, pd 5 | dimension y(*), pd(nrowpd,*) 6 | dimension neq(*) 7 | pd(1,1) = 0.0d0 8 | pd(1,2) = 1.0d0 9 | pd(2,1) = -40.0d0*y(1)*y(2) - 1.0d0 10 | pd(2,2) = 20.0d0*(1.0d0 - y(1)*y(1)) 11 | return 12 | end 13 | -------------------------------------------------------------------------------- /src/f2cl/packages/odepack/demo3/jac2.f: -------------------------------------------------------------------------------- 1 | 2 | subroutine jac2 (neq, t, y, ml, mu, pd, nrowpd) 3 | integer neq, ml, mu, nrowpd, j, mband, mu1, mu2, ng 4 | double precision t, y, pd, alph1, alph2 5 | dimension y(*), pd(nrowpd,*) 6 | dimension neq(*) 7 | data alph1/1.0d0/, alph2/1.0d0/, ng/5/ 8 | mband = ml + mu + 1 9 | mu1 = mu + 1 10 | mu2 = mu + 2 11 | do 10 j = 1,neq(1) 12 | pd(mu1,j) = -2.0d0 13 | pd(mu2,j) = alph1 14 | 10 pd(mband,j) = alph2 15 | do 20 j = ng,neq(1),ng 16 | 20 pd(mu2,j) = 0.0d0 17 | return 18 | end 19 | -------------------------------------------------------------------------------- /src/f2cl/packages/odepack/demo4/.cvsignore: -------------------------------------------------------------------------------- 1 | f1.lisp 2 | f2.lisp 3 | gr1.lisp 4 | gr2.lisp 5 | jac2.lisp 6 | opkdemo4.lisp 7 | -------------------------------------------------------------------------------- /src/f2cl/packages/odepack/demo4/f1.f: -------------------------------------------------------------------------------- 1 | 2 | subroutine f1 (neq, t, y, ydot) 3 | integer neq 4 | double precision t, y, ydot 5 | dimension y(1), ydot(1) 6 | dimension neq(*) 7 | ydot(1) = ((2.0d0*log(y(1)) + 8.0d0)/t - 5.0d0)*y(1) 8 | return 9 | end 10 | -------------------------------------------------------------------------------- /src/f2cl/packages/odepack/demo4/f2.f: -------------------------------------------------------------------------------- 1 | 2 | subroutine f2 (neq, t, y, ydot) 3 | integer neq 4 | double precision t, y, ydot 5 | dimension y(2), ydot(2) 6 | dimension neq(*) 7 | ydot(1) = y(2) 8 | ydot(2) = 100.0d0*(1.0d0 - y(1)*y(1))*y(2) - y(1) 9 | return 10 | end 11 | -------------------------------------------------------------------------------- /src/f2cl/packages/odepack/demo4/gr1.f: -------------------------------------------------------------------------------- 1 | 2 | subroutine gr1 (neq, t, y, ng, groot) 3 | integer neq, ng 4 | double precision t, y, groot 5 | dimension y(1), groot(2) 6 | dimension neq(*) 7 | groot(1) = ((2.0d0*log(y(1)) + 8.0d0)/t - 5.0d0)*y(1) 8 | groot(2) = log(y(1)) - 2.2491d0 9 | return 10 | end 11 | -------------------------------------------------------------------------------- /src/f2cl/packages/odepack/demo4/gr2.f: -------------------------------------------------------------------------------- 1 | 2 | subroutine gr2 (neq, t, y, ng, groot) 3 | integer neq, ng 4 | double precision t, y, groot 5 | dimension y(2), groot(1) 6 | dimension neq(*) 7 | groot(1) = y(1) 8 | return 9 | end 10 | -------------------------------------------------------------------------------- /src/f2cl/packages/odepack/demo4/jac2.f: -------------------------------------------------------------------------------- 1 | 2 | subroutine jac2 (neq, t, y, ml, mu, pd, nrowpd) 3 | integer neq, ml, mu, nrowpd 4 | double precision t, y, pd 5 | dimension y(2), pd(nrowpd,2) 6 | dimension neq(*) 7 | pd(1,1) = 0.0d0 8 | pd(1,2) = 1.0d0 9 | pd(2,1) = -200.0d0*y(1)*y(2) - 1.0d0 10 | pd(2,2) = 100.0d0*(1.0d0 - y(1)*y(1)) 11 | return 12 | end 13 | -------------------------------------------------------------------------------- /src/f2cl/packages/odepack/demo5/.cvsignore: -------------------------------------------------------------------------------- 1 | cinit.lisp 2 | fbg.lisp 3 | fweb.lisp 4 | gs.lisp 5 | gset.lisp 6 | jacbg.lisp 7 | opkdemo5.lisp 8 | outweb.lisp 9 | setpar.lisp 10 | solsbg.lisp 11 | webr.lisp 12 | -------------------------------------------------------------------------------- /src/f2cl/packages/odepack/demo5/gset.f: -------------------------------------------------------------------------------- 1 | 2 | subroutine gset (m, ng, jg, jig, jr) 3 | c----------------------------------------------------------------------- 4 | c This routine sets arrays jg, jig, and jr describing 5 | c a uniform partition of (1,2,...,m) into ng groups. 6 | c----------------------------------------------------------------------- 7 | integer m, ng, jg, jig, jr 8 | dimension jg(*), jig(*), jr(*) 9 | integer ig, j, len1, mper, ngm1 10 | c 11 | mper = m/ng 12 | do 10 ig = 1,ng 13 | 10 jg(ig) = 1 + (ig - 1)*mper 14 | jg(ng+1) = m + 1 15 | c 16 | ngm1 = ng - 1 17 | len1 = ngm1*mper 18 | do 20 j = 1,len1 19 | 20 jig(j) = 1 + (j-1)/mper 20 | len1 = len1 + 1 21 | do 25 j = len1,m 22 | 25 jig(j) = ng 23 | c 24 | do 30 ig = 1,ngm1 25 | 30 jr(ig) = 0.5d0 + (ig - 0.5d0)*mper 26 | jr(ng) = 0.5d0*(1 + ngm1*mper + m) 27 | c 28 | return 29 | c------------ end of subroutine gset --------------------------------- 30 | end 31 | -------------------------------------------------------------------------------- /src/f2cl/packages/odepack/demo7/.cvsignore: -------------------------------------------------------------------------------- 1 | addabd.lisp 2 | addafl.lisp 3 | elkup.lisp 4 | gfun.lisp 5 | jacbd.lisp 6 | jacfl.lisp 7 | opkdemo7.lisp 8 | res.lisp 9 | -------------------------------------------------------------------------------- /src/f2cl/packages/odepack/demo7/addabd.f: -------------------------------------------------------------------------------- 1 | 2 | subroutine addabd (n, t, y, ml, mu, pa, m0) 3 | c This subroutine computes the matrix A in band form, adds it to pa, 4 | c and returns the sum in pa. The matrix A is tridiagonal, of order n, 5 | c with nonzero elements (reading across) of 1/6, 4/6, 1/6. 6 | c 7 | integer i, n, m0, ml, mu, mup1, mup2 8 | double precision t, y, pa, fact1, fact4, one, four, six 9 | dimension y(*), pa(m0,*) 10 | dimension n(*) 11 | data one/1.0d0/, four/4.0d0/, six/6.0d0/ 12 | c 13 | c Set the pointers. 14 | mup1 = mu + 1 15 | mup2 = mu + 2 16 | c Compute the elements of A. 17 | fact1 = one/six 18 | fact4 = four/six 19 | c Add the matrix A to the matrix pa (banded). 20 | do 10 i = 1,n(1) 21 | pa(mu,i) = pa(mu,i) + fact1 22 | pa(mup1,i) = pa(mup1,i) + fact4 23 | pa(mup2,i) = pa(mup2,i) + fact1 24 | 10 continue 25 | return 26 | c end of subroutine addabd for the DLSODI demonstration problem. 27 | end 28 | -------------------------------------------------------------------------------- /src/f2cl/packages/odepack/demo7/gfun.f: -------------------------------------------------------------------------------- 1 | 2 | subroutine gfun (n, t, y, g) 3 | c This subroutine computes the right-hand side function g(y,t). 4 | c It uses r4d = 1/(4*delta), eodsq = eta/delta**2, and nm1 = n - 1 5 | c from the Common block test1. 6 | c 7 | integer i, n, nm1 8 | double precision t, y, g, r4d, eodsq, two 9 | dimension g(n), y(n) 10 | common /test1/ r4d, eodsq, nm1 11 | data two/2.0d0/ 12 | c 13 | g(1) = -r4d*y(2)**2 + eodsq*(y(2) - two*y(1)) 14 | c 15 | do 20 i = 2,nm1 16 | g(i) = r4d*(y(i-1)**2 - y(i+1)**2) 17 | 1 + eodsq*(y(i+1) - two*y(i) + y(i-1)) 18 | 20 continue 19 | c 20 | g(n) = r4d*y(nm1)**2 + eodsq*(y(nm1) - two*y(n)) 21 | c 22 | return 23 | c end of subroutine gfun for the DLSODI demonstration problem. 24 | end 25 | -------------------------------------------------------------------------------- /src/f2cl/packages/odepack/demo8/.cvsignore: -------------------------------------------------------------------------------- 1 | addabt.lisp 2 | edit.lisp 3 | gfun.lisp 4 | jacbt.lisp 5 | maxerr.lisp 6 | opkdemo8.lisp 7 | res.lisp 8 | setic.lisp 9 | subav.lisp 10 | -------------------------------------------------------------------------------- /src/f2cl/packages/odepack/demo8/edit.f: -------------------------------------------------------------------------------- 1 | 2 | subroutine edit (y, mb, nip, lout) 3 | c This routine prints output. For each of the mb PDE components, the 4 | c values at the nip points are printed. All output is on unit lout. 5 | c 6 | integer mb, nip, lout, i, k 7 | double precision y 8 | dimension y(mb,nip) 9 | c 10 | do 10 i = 1,mb 11 | 10 write (lout,20) i, (y(i,k),k=1,nip) 12 | c 13 | 20 format(' Values of PDE component i =',i3/15(7d12.4/)) 14 | c 15 | return 16 | c end of subroutine edit 17 | end 18 | -------------------------------------------------------------------------------- /src/f2cl/packages/odepack/demo8/res.f: -------------------------------------------------------------------------------- 1 | 2 | subroutine res (n, t, y, v, r, ires) 3 | c This subroutine computes the residual vector 4 | c r = g(t,y) - A(t,y)*v 5 | c using routines gfun and subav. 6 | c If ires = -1, only g(t,y) is returned in r, since A(t,y) does 7 | c not depend on y. 8 | c No changes need to be made to this routine if nip is changed. 9 | c 10 | integer ires, n, ncomp, nip, nm1 11 | double precision t, y, v, r, r6d, eodsq 12 | dimension y(*), v(*), r(*) 13 | dimension n(*) 14 | common /par/ r6d, eodsq(3), ncomp, nip, nm1 15 | c 16 | call gfun (t, y, r, ncomp) 17 | if (ires .eq. -1) return 18 | c 19 | call subav (r, v, ncomp) 20 | c 21 | return 22 | c end of subroutine res 23 | end 24 | -------------------------------------------------------------------------------- /src/f2cl/packages/odepack/demo8/subav.f: -------------------------------------------------------------------------------- 1 | 2 | subroutine subav (r, v, mb) 3 | c This routine subtracts the matrix a time the vector v from r, 4 | c in order to form the residual vector, stored in r. 5 | c 6 | integer mb, ncomp, nip, nm1, i, k 7 | double precision r, v, r6d, eodsq, aa1, aa4, four, one, six 8 | dimension r(mb,*), v(mb,*) 9 | common /par/ r6d, eodsq(3), ncomp, nip, nm1 10 | data one /1.0d0/, four /4.0d0/, six /6.0d0/ 11 | c 12 | aa1 = one/six 13 | aa4 = four/six 14 | c 15 | do 10 i = 1,mb 16 | 10 r(i,1) = r(i,1) - (aa4*v(i,1) + aa1*v(i,2)) 17 | c 18 | do 20 k = 2,nm1 19 | do 15 i = 1,mb 20 | 15 r(i,k) = r(i,k) - (aa1*v(i,k-1) + aa4*v(i,k) + aa1*v(i,k+1)) 21 | 20 continue 22 | c 23 | do 30 i = 1,mb 24 | 30 r(i,nip) = r(i,nip) - (aa1*v(i,nm1) + aa4*v(i,nip)) 25 | c 26 | return 27 | c end of subroutine subav 28 | end 29 | -------------------------------------------------------------------------------- /src/f2cl/packages/odepack/dfnorm.f: -------------------------------------------------------------------------------- 1 | *DECK DFNORM 2 | DOUBLE PRECISION FUNCTION DFNORM (N, A, W) 3 | C----------------------------------------------------------------------- 4 | C This function computes the norm of a full N by N matrix, 5 | C stored in the array A, that is consistent with the weighted max-norm 6 | C on vectors, with weights stored in the array W: 7 | C DFNORM = MAX(i=1,...,N) ( W(i) * Sum(j=1,...,N) ABS(a(i,j))/W(j) ) 8 | C----------------------------------------------------------------------- 9 | INTEGER N, I, J 10 | DOUBLE PRECISION A, W, AN, SUM 11 | DIMENSION A(N,N), W(N) 12 | AN = 0.0D0 13 | DO 20 I = 1,N 14 | SUM = 0.0D0 15 | DO 10 J = 1,N 16 | 10 SUM = SUM + ABS(A(I,J))/W(J) 17 | AN = MAX(AN,SUM*W(I)) 18 | 20 CONTINUE 19 | DFNORM = AN 20 | RETURN 21 | C----------------------- End of Function DFNORM ------------------------ 22 | END 23 | -------------------------------------------------------------------------------- /src/f2cl/packages/odepack/dmnorm.f: -------------------------------------------------------------------------------- 1 | *DECK DMNORM 2 | DOUBLE PRECISION FUNCTION DMNORM (N, V, W) 3 | C----------------------------------------------------------------------- 4 | C This function routine computes the weighted max-norm 5 | C of the vector of length N contained in the array V, with weights 6 | C contained in the array w of length N: 7 | C DMNORM = MAX(i=1,...,N) ABS(V(i))*W(i) 8 | C----------------------------------------------------------------------- 9 | INTEGER N, I 10 | DOUBLE PRECISION V, W, VM 11 | DIMENSION V(N), W(N) 12 | VM = 0.0D0 13 | DO 10 I = 1,N 14 | 10 VM = MAX(VM,ABS(V(I))*W(I)) 15 | DMNORM = VM 16 | RETURN 17 | C----------------------- End of Function DMNORM ------------------------ 18 | END 19 | -------------------------------------------------------------------------------- /src/f2cl/packages/odepack/dumsum.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE DUMSUM(A,B,C) 2 | C Routine to force normal storing of A + B, for DUMACH. 3 | DOUBLE PRECISION A, B, C 4 | C = A + B 5 | RETURN 6 | END 7 | -------------------------------------------------------------------------------- /src/f2cl/packages/quadpack/.cvsignore: -------------------------------------------------------------------------------- 1 | *.sse2f 2 | test1 3 | test12 4 | test14 5 | test15 6 | test2 7 | test3 8 | test4 9 | test5 10 | test6 11 | test7 12 | test9 13 | -------------------------------------------------------------------------------- /src/f2cl/packages/quadpack/Fortran/.cvsignore: -------------------------------------------------------------------------------- 1 | dgtsl.lisp 2 | dqag.lisp 3 | dqage.lisp 4 | dqagi.lisp 5 | dqagie.lisp 6 | dqagpe.lisp 7 | dqags.lisp 8 | dqagse.lisp 9 | dqawc.lisp 10 | dqawce.lisp 11 | dqawf.lisp 12 | dqawfe.lisp 13 | dqawo.lisp 14 | dqawoe.lisp 15 | dqaws.lisp 16 | dqawse.lisp 17 | dqc25c.lisp 18 | dqc25f.lisp 19 | dqc25s.lisp 20 | dqcheb.lisp 21 | dqelg.lisp 22 | dqk15.lisp 23 | dqk15i.lisp 24 | dqk15w.lisp 25 | dqk21.lisp 26 | dqk31.lisp 27 | dqk41.lisp 28 | dqk51.lisp 29 | dqk61.lisp 30 | dqmomo.lisp 31 | dqng.lisp 32 | dqpsrt.lisp 33 | dqwgtc.lisp 34 | dqwgtf.lisp 35 | dqwgts.lisp 36 | xerror.lisp 37 | -------------------------------------------------------------------------------- /src/f2cl/packages/quadpack/Fortran/dqwgtc.f: -------------------------------------------------------------------------------- 1 | double precision function dqwgtc(x,c,p2,p3,p4,kp) 2 | c***begin prologue dqwgtc 3 | c***refer to dqk15w 4 | c***routines called (none) 5 | c***revision date 810101 (yymmdd) 6 | c***keywords weight function, cauchy principal value 7 | c***author piessens,robert,appl. math. & progr. div. - k.u.leuven 8 | c de doncker,elise,appl. math. & progr. div. - k.u.leuven 9 | c***purpose this function subprogram is used together with the 10 | c routine qawc and defines the weight function. 11 | c***end prologue dqwgtc 12 | c 13 | double precision c,p2,p3,p4,x 14 | integer kp 15 | c***first executable statement dqwgtc 16 | dqwgtc = 0.1d+01/(x-c) 17 | return 18 | end 19 | -------------------------------------------------------------------------------- /src/f2cl/packages/quadpack/Fortran/dqwgtf.f: -------------------------------------------------------------------------------- 1 | double precision function dqwgtf(x,omega,p2,p3,p4,integr) 2 | c***begin prologue dqwgtf 3 | c***refer to dqk15w 4 | c***routines called (none) 5 | c***revision date 810101 (yymmdd) 6 | c***keywords cos or sin in weight function 7 | c***author piessens,robert, appl. math. & progr. div. - k.u.leuven 8 | c de doncker,elise,appl. math. * progr. div. - k.u.leuven 9 | c***end prologue dqwgtf 10 | c 11 | double precision dcos,dsin,omega,omx,p2,p3,p4,x 12 | integer integr 13 | c***first executable statement dqwgtf 14 | omx = omega*x 15 | go to(10,20),integr 16 | 10 dqwgtf = dcos(omx) 17 | go to 30 18 | 20 dqwgtf = dsin(omx) 19 | 30 return 20 | end 21 | -------------------------------------------------------------------------------- /src/f2cl/packages/quadpack/README: -------------------------------------------------------------------------------- 1 | -*- Mode: text -*- 2 | 3 | This directory contains the complete source code for QUADPACK, as 4 | obtained from NETLIB (http://www.netlib.org). In addition, it 5 | contains one routine (DGTSL) from LINPACK and a few routines (XERROR 6 | and friends) from CMLIB, all obtained from NETLIB. 7 | 8 | Since numerical integration of functions usually requires passing in a 9 | function to the integration routine, using a foreign function 10 | interface for this can be difficult if the function to be integrated 11 | is in Lisp. Hence, we convert the code from Fortran to Lisp. 12 | 13 | The directory Fortran contains the Fortran source. This is a useful 14 | test for f2cl since it's a fairly large and complete package. 15 | 16 | To test for proper conversion, try compiling tst-dqagse.lisp and 17 | running the tests therein. These are some simple test integrals taken 18 | from the Quadpack book and were designed to show how well quadpack 19 | works and where it fails. 20 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/.cvsignore: -------------------------------------------------------------------------------- 1 | da7sst.ppcf 2 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/419/.cvsignore: -------------------------------------------------------------------------------- 1 | calct.lisp 2 | cauchy.lisp 3 | cdivid.lisp 4 | cmod.lisp 5 | cpoly.lisp 6 | cpolydr 7 | cpolydr.lisp 8 | errev.lisp 9 | fxshft.lisp 10 | mcon.lisp 11 | nexth.lisp 12 | noshft.lisp 13 | polyev.lisp 14 | prtc.lisp 15 | prtz.lisp 16 | scale.lisp 17 | vrshft.lisp 18 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/419/Makefile: -------------------------------------------------------------------------------- 1 | TOMS419_F = calct.f \ 2 | cauchy.f \ 3 | cdivid.f \ 4 | cmod.f \ 5 | cpoly.f \ 6 | cpolydr.f \ 7 | errev.f \ 8 | fxshft.f \ 9 | mcon.f \ 10 | nexth.f \ 11 | noshft.f \ 12 | polyev.f \ 13 | prtc.f \ 14 | prtz.f \ 15 | scale.f \ 16 | vrshft.f 17 | 18 | cpolydr : cpolydr.o prtc.o prtz.o $(TOMS419_F:.f=.o) 19 | $(F77) -o $@ $^ 20 | 21 | cpolydr.out : cpolydr 22 | cpolydr | tee $@ 23 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/419/calct.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE CALCT(BOOL) CALC2890 2 | C COMPUTES T = -P(S)/H(S). 3 | C BOOL - LOGICAL, SET TRUE IF H(S) IS ESSENTIALLY ZERO. 4 | C COMMON AREA 5 | COMMON/GLOBAL/PR,PI,HR,HI,QPR,QPI,QHR,QHI,SHR,SHI, 6 | * SR,SI,TR,TI,PVR,PVI,ARE,MRE,ETA,INFIN,NN 7 | DOUBLE PRECISION SR,SI,TR,TI,PVR,PVI,ARE,MRE,ETA,INFIN, 8 | * PR(50),PI(50),HR(50),HI(50),QPR(50),QPI(50),QHR(50), 9 | * QHI(50),SHR(50),SHI(50) 10 | DOUBLE PRECISION HVR,HVI,CMOD 11 | LOGICAL BOOL 12 | N = NN-1 13 | C EVALUATE H(S). 14 | CALL POLYEV(N,SR,SI,HR,HI,QHR,QHI,HVR,HVI) 15 | BOOL = CMOD(HVR,HVI) .LE. ARE*10.0D0*CMOD(HR(N),HI(N)) 16 | IF (BOOL) GO TO 10 17 | CALL CDIVID(-PVR,-PVI,HVR,HVI,TR,TI) 18 | RETURN 19 | 10 TR = 0.0D0 20 | TI = 0.0D0 21 | RETURN 22 | END 23 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/419/cdivid.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE CDIVID(AR,AI,BR,BI,CR,CI) CDIV4490 2 | C COMPLEX DIVISION C = A/B, AVOIDING OVERFLOW. 3 | DOUBLE PRECISION AR,AI,BR,BI,CR,CI,R,D,T,INFIN,DABS 4 | IF (BR .NE. 0.0D0 .OR. BI .NE. 0.0D0) GO TO 10 5 | C DIVISION BY ZERO, C = INFINITY. 6 | CALL MCON (T,INFIN,T,T) 7 | CR = INFIN 8 | CI = INFIN 9 | RETURN 10 | 10 IF (DABS(BR) .GE. DABS(BI)) GO TO 20 11 | R = BR/BI 12 | D = BI+R*BR 13 | CR = (AR*R+AI)/D 14 | CI = (AI*R-AR)/D 15 | RETURN 16 | 20 R = BI/BR 17 | D = BR+R*BI 18 | CR = (AR+AI*R)/D 19 | CI = (AI-AR*R)/D 20 | RETURN 21 | END 22 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/419/cmod.f: -------------------------------------------------------------------------------- 1 | DOUBLE PRECISION FUNCTION CMOD(R,I) CMOD4700 2 | C MODULUS OF A COMPLEX NUMBER AVOIDING OVERFLOW. 3 | DOUBLE PRECISION R,I,AR,AI,DABS,DSQURT 4 | AR = DABS(R) 5 | AI = DABS(I) 6 | IF (AR .GE. AI) GO TO 10 7 | CMOD = AI*DSQRT(1.0D0+(AR/AI)**2) 8 | RETURN 9 | 10 IF (AR .LE. AI) GO TO 20 10 | CMOD = AR*DSQRT(1.0D0+(AI/AR)**2) 11 | RETURN 12 | 20 CMOD = AR*DSQRT(2.0D0) 13 | RETURN 14 | END 15 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/419/errev.f: -------------------------------------------------------------------------------- 1 | DOUBLE PRECISION FUNCTION ERREV(NN,QR,QI,MS,MP,ARE,MRE) ERRE3610 2 | C BOUNDS THE ERROR IN EVALUATING THE POLYNOMIAL BY THE HORNER 3 | C RECURRENCE. 4 | C QR,QI - THE PARTIAL SUMS 5 | C MS -MODULUS OF THE POINT 6 | C MP -MODULUS OF POLYNOMIAL VALUE 7 | C ARE, MRE -ERROR BOUNDS ON COMPLEX ADDITION AND MULTIPLICATION 8 | DOUBLE PRECISION QR(NN),QI(NN),MS,MP,ARE,MRE,E,CMOD 9 | E = CMOD(QR(1),QI(1))*MRE/(ARE+MRE) 10 | DO 10 I = 1,NN 11 | E = E*MS+CMOD(QR(I),QI(I)) 12 | 10 CONTINUE 13 | ERREV = E*(ARE+MRE)-MP*MRE 14 | RETURN 15 | END 16 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/419/polyev.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE POLYEV(NN,SR,SI,PR,PI,QR,QI,PVR,PVI) POLY3430 2 | C EVALUATES A POLYNOMIAL P AT S BY THE HORNER RECURRENCE 3 | C PLACING THE PARTIAL SUMS IN Q AND THE COMPUTED VALUE IN PV. 4 | DOUBLE PRECISION PR(NN),PI(NN),QR(NN),QI(NN), 5 | * SR,SI,PVR,PVI,T 6 | QR(1) = PR(1) 7 | QI(1) = PI(1) 8 | PVR = QR(1) 9 | PVI = QI(1) 10 | DO 10 I = 2,NN 11 | T = PVR*SR-PVI*SI+PR(I) 12 | PVI = PVR*SI+PVI*SR+PI(I) 13 | PVR = T 14 | QR(I) = PVR 15 | QI(I) = PVI 16 | 10 CONTINUE 17 | RETURN 18 | END 19 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/419/prtc.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE PRTC(N,P,Q) 2 | DOUBLE PRECISION P(50),Q(50) 3 | WRITE(6,10) (P(I),Q(I) ,I=1,N) 4 | 10 FORMAT(//' COEFFICIENTS' /50(2D26.16/)) 5 | RETURN 6 | END 7 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/419/prtz.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE PRTZ(N,ZR,ZI) 2 | DOUBLE PRECISION ZR(50),ZI(50) 3 | WRITE(6,10) (ZR(I),ZI(I) ,I=1,N) 4 | 10 FORMAT(//' ZEROS'/ 50(2D26.16/)) 5 | RETURN 6 | END 7 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/715/.cvsignore: -------------------------------------------------------------------------------- 1 | *.lisp 2 | *.ppcf 3 | *.sse2f 4 | algtst 5 | anrtst 6 | dawtst 7 | eitest 8 | erftst 9 | gamtst 10 | i0test 11 | i1test 12 | j0test 13 | j1test 14 | k0test 15 | k1test 16 | k1test 17 | psitst 18 | ritest 19 | rjtest 20 | rktest 21 | rytest 22 | y0test 23 | y1test 24 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/715/besei0.f: -------------------------------------------------------------------------------- 1 | CS REAL FUNCTION BESEI0(X) 2 | DOUBLE PRECISION FUNCTION BESEI0(X) 3 | C-------------------------------------------------------------------- 4 | C 5 | C This function program computes approximate values for the 6 | C modified Bessel function of the first kind of order zero 7 | C multiplied by EXP(-ABS(X)), where EXP is the 8 | C exponential function, ABS is the absolute value, and X 9 | C is any argument. 10 | C 11 | C-------------------------------------------------------------------- 12 | INTEGER JINT 13 | CS REAL 14 | DOUBLE PRECISION 15 | 1 X, RESULT 16 | C-------------------------------------------------------------------- 17 | JINT=2 18 | CALL CALCI0(X,RESULT,JINT) 19 | BESEI0=RESULT 20 | RETURN 21 | C---------- Last line of BESEI0 ---------- 22 | END 23 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/715/besei1.f: -------------------------------------------------------------------------------- 1 | CS REAL FUNCTION BESEI1(X) 2 | DOUBLE PRECISION FUNCTION BESEI1(X) 3 | C-------------------------------------------------------------------- 4 | C 5 | C This function program computes approximate values for the 6 | C modified Bessel function of the first kind of order one 7 | C multiplied by EXP(-ABS(X)), where EXP is the 8 | C exponential function, ABS is the absolute value, and X 9 | C is any argument. 10 | C 11 | C-------------------------------------------------------------------- 12 | INTEGER JINT 13 | CS REAL 14 | DOUBLE PRECISION 15 | 1 X, RESULT 16 | C-------------------------------------------------------------------- 17 | JINT=2 18 | CALL CALCI1(X,RESULT,JINT) 19 | BESEI1=RESULT 20 | RETURN 21 | C---------- Last line of BESEI1 ---------- 22 | END 23 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/715/besek0.f: -------------------------------------------------------------------------------- 1 | CS REAL FUNCTION BESEK0(X) 2 | DOUBLE PRECISION FUNCTION BESEK0(X) 3 | C-------------------------------------------------------------------- 4 | C 5 | C This function program computes approximate values for the 6 | C modified Bessel function of the second kind of order zero 7 | C multiplied by the Exponential function, for arguments 8 | C 0.0 .LT. ARG. 9 | C 10 | C Authors: W. J. Cody and Laura Stoltz 11 | C 12 | C Latest Modification: March 14, 1992 13 | C 14 | C-------------------------------------------------------------------- 15 | INTEGER JINT 16 | CS REAL 17 | DOUBLE PRECISION 18 | 1 X, RESULT 19 | C-------------------------------------------------------------------- 20 | JINT = 2 21 | CALL CALCK0(X,RESULT,JINT) 22 | BESEK0 = RESULT 23 | RETURN 24 | C---------- Last line of BESEK0 ---------- 25 | END 26 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/715/besek1.f: -------------------------------------------------------------------------------- 1 | CS REAL FUNCTION BESEK1(X) 2 | DOUBLE PRECISION FUNCTION BESEK1(X) 3 | C-------------------------------------------------------------------- 4 | C 5 | C This function program computes approximate values for the 6 | C modified Bessel function of the second kind of order one 7 | C multiplied by the exponential function, for arguments 8 | C XLEAST .LE. ARG .LE. XMAX. 9 | C 10 | C-------------------------------------------------------------------- 11 | INTEGER JINT 12 | CS REAL 13 | DOUBLE PRECISION 14 | 1 X, RESULT 15 | C-------------------------------------------------------------------- 16 | JINT = 2 17 | CALL CALCK1(X,RESULT,JINT) 18 | BESEK1 = RESULT 19 | RETURN 20 | C---------- Last line of BESEK1 ---------- 21 | END 22 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/715/besi0.f: -------------------------------------------------------------------------------- 1 | CS REAL FUNCTION BESI0(X) 2 | DOUBLE PRECISION FUNCTION BESI0(X) 3 | C-------------------------------------------------------------------- 4 | C 5 | C This long precision subprogram computes approximate values for 6 | C modified Bessel functions of the first kind of order zero for 7 | C arguments ABS(ARG) .LE. XMAX (see comments heading CALCI0). 8 | C 9 | C-------------------------------------------------------------------- 10 | INTEGER JINT 11 | CS REAL 12 | DOUBLE PRECISION 13 | 1 X, RESULT 14 | C-------------------------------------------------------------------- 15 | JINT=1 16 | CALL CALCI0(X,RESULT,JINT) 17 | BESI0=RESULT 18 | RETURN 19 | C---------- Last line of BESI0 ---------- 20 | END 21 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/715/besi1.f: -------------------------------------------------------------------------------- 1 | CS REAL FUNCTION BESI1(X) 2 | DOUBLE PRECISION FUNCTION BESI1(X) 3 | C-------------------------------------------------------------------- 4 | C 5 | C This long precision subprogram computes approximate values for 6 | C modified Bessel functions of the first kind of order one for 7 | C arguments ABS(ARG) .LE. XMAX (see comments heading CALCI1). 8 | C 9 | C-------------------------------------------------------------------- 10 | INTEGER JINT 11 | CS REAL 12 | DOUBLE PRECISION 13 | 1 X, RESULT 14 | C-------------------------------------------------------------------- 15 | JINT=1 16 | CALL CALCI1(X,RESULT,JINT) 17 | BESI1=RESULT 18 | RETURN 19 | C---------- Last line of BESI1 ---------- 20 | END 21 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/715/besj0.f: -------------------------------------------------------------------------------- 1 | CS REAL FUNCTION BESJ0(X) 2 | DOUBLE PRECISION FUNCTION BESJ0(X) 3 | C-------------------------------------------------------------------- 4 | C 5 | C This subprogram computes approximate values for Bessel functions 6 | C of the first kind of order zero for arguments |X| <= XMAX 7 | C (see comments heading CALJY0). 8 | C 9 | C-------------------------------------------------------------------- 10 | INTEGER JINT 11 | CS REAL X, RESULT 12 | DOUBLE PRECISION X, RESULT 13 | C-------------------------------------------------------------------- 14 | JINT=0 15 | CALL CALJY0(X,RESULT,JINT) 16 | BESJ0 = RESULT 17 | RETURN 18 | C---------- Last line of BESJ0 ---------- 19 | END 20 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/715/besj1.f: -------------------------------------------------------------------------------- 1 | CS REAL FUNCTION BESJ1(X) 2 | DOUBLE PRECISION FUNCTION BESJ1(X) 3 | C-------------------------------------------------------------------- 4 | C 5 | C This subprogram computes approximate values for Bessel functions 6 | C of the first kind of order zero for arguments |X| <= XMAX 7 | C (see comments heading CALJY1). 8 | C 9 | C-------------------------------------------------------------------- 10 | INTEGER JINT 11 | CS REAL 12 | DOUBLE PRECISION 13 | 1 RESULT,X 14 | C-------------------------------------------------------------------- 15 | JINT=0 16 | CALL CALJY1(X,RESULT,JINT) 17 | BESJ1 = RESULT 18 | RETURN 19 | C---------- Last card of BESJ1 ---------- 20 | END 21 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/715/besk0.f: -------------------------------------------------------------------------------- 1 | CS REAL FUNCTION BESK0(X) 2 | DOUBLE PRECISION FUNCTION BESK0(X) 3 | C-------------------------------------------------------------------- 4 | C 5 | C This function program computes approximate values for the 6 | C modified Bessel function of the second kind of order zero 7 | C for arguments 0.0 .LT. ARG .LE. XMAX (see comments heading 8 | C CALCK0). 9 | C 10 | C Authors: W. J. Cody and Laura Stoltz 11 | C 12 | C Latest Modification: March 14, 1992 13 | C 14 | C-------------------------------------------------------------------- 15 | INTEGER JINT 16 | CS REAL 17 | DOUBLE PRECISION 18 | 1 X, RESULT 19 | C-------------------------------------------------------------------- 20 | JINT = 1 21 | CALL CALCK0(X,RESULT,JINT) 22 | BESK0 = RESULT 23 | RETURN 24 | C---------- Last line of BESK0 ---------- 25 | END 26 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/715/besk1.f: -------------------------------------------------------------------------------- 1 | CS REAL FUNCTION BESK1(X) 2 | DOUBLE PRECISION FUNCTION BESK1(X) 3 | C-------------------------------------------------------------------- 4 | C 5 | C This function program computes approximate values for the 6 | C modified Bessel function of the second kind of order one 7 | C for arguments XLEAST .LE. ARG .LE. XMAX. 8 | C 9 | C-------------------------------------------------------------------- 10 | INTEGER JINT 11 | CS REAL 12 | DOUBLE PRECISION 13 | 1 X, RESULT 14 | C-------------------------------------------------------------------- 15 | JINT = 1 16 | CALL CALCK1(X,RESULT,JINT) 17 | BESK1 = RESULT 18 | RETURN 19 | C---------- Last line of BESK1 ---------- 20 | END 21 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/715/besy0.f: -------------------------------------------------------------------------------- 1 | CS REAL FUNCTION BESY0(X) 2 | DOUBLE PRECISION FUNCTION BESY0(X) 3 | C-------------------------------------------------------------------- 4 | C 5 | C This subprogram computes approximate values for Bessel functions 6 | C of the second kind of order zero for arguments 0 < X <= XMAX 7 | C (see comments heading CALJY0). 8 | C 9 | C-------------------------------------------------------------------- 10 | INTEGER JINT 11 | CS REAL X, RESULT 12 | DOUBLE PRECISION X, RESULT 13 | C-------------------------------------------------------------------- 14 | JINT=1 15 | CALL CALJY0(X,RESULT,JINT) 16 | BESY0 = RESULT 17 | RETURN 18 | C---------- Last line of BESY0 ---------- 19 | END 20 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/715/besy1.f: -------------------------------------------------------------------------------- 1 | CS REAL FUNCTION BESY1(X) 2 | DOUBLE PRECISION FUNCTION BESY1(X) 3 | C-------------------------------------------------------------------- 4 | C 5 | C This subprogram computes approximate values for Bessel functions 6 | C of the second kind of order zero for arguments 0 < X <= XMAX 7 | C (see comments heading CALJY1). 8 | C 9 | C-------------------------------------------------------------------- 10 | INTEGER JINT 11 | CS REAL 12 | DOUBLE PRECISION 13 | 1 RESULT,X 14 | C-------------------------------------------------------------------- 15 | JINT=1 16 | CALL CALJY1(X,RESULT,JINT) 17 | BESY1 = RESULT 18 | RETURN 19 | C---------- Last card of BESY1 ---------- 20 | END 21 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/715/derf.f: -------------------------------------------------------------------------------- 1 | CS REAL FUNCTION ERF(X) 2 | DOUBLE PRECISION FUNCTION DERF(X) 3 | C-------------------------------------------------------------------- 4 | C 5 | C This subprogram computes approximate values for erf(x). 6 | C (see comments heading CALERF). 7 | C 8 | C Author/date: W. J. Cody, January 8, 1985 9 | C 10 | C-------------------------------------------------------------------- 11 | INTEGER JINT 12 | CS REAL X, RESULT 13 | DOUBLE PRECISION X, RESULT 14 | C------------------------------------------------------------------ 15 | JINT = 0 16 | CALL CALERF(X,RESULT,JINT) 17 | CS ERF = RESULT 18 | DERF = RESULT 19 | RETURN 20 | C---------- Last card of DERF ---------- 21 | END 22 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/715/derfc.f: -------------------------------------------------------------------------------- 1 | CS REAL FUNCTION ERFC(X) 2 | DOUBLE PRECISION FUNCTION DERFC(X) 3 | C-------------------------------------------------------------------- 4 | C 5 | C This subprogram computes approximate values for erfc(x). 6 | C (see comments heading CALERF). 7 | C 8 | C Author/date: W. J. Cody, January 8, 1985 9 | C 10 | C-------------------------------------------------------------------- 11 | INTEGER JINT 12 | CS REAL X, RESULT 13 | DOUBLE PRECISION X, RESULT 14 | C------------------------------------------------------------------ 15 | JINT = 1 16 | CALL CALERF(X,RESULT,JINT) 17 | CS ERFC = RESULT 18 | DERFC = RESULT 19 | RETURN 20 | C---------- Last card of DERFC ---------- 21 | END 22 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/715/derfcx.f: -------------------------------------------------------------------------------- 1 | CS REAL FUNCTION ERFCX(X) 2 | DOUBLE PRECISION FUNCTION DERFCX(X) 3 | C------------------------------------------------------------------ 4 | C 5 | C This subprogram computes approximate values for exp(x*x) * erfc(x). 6 | C (see comments heading CALERF). 7 | C 8 | C Author/date: W. J. Cody, March 30, 1987 9 | C 10 | C------------------------------------------------------------------ 11 | INTEGER JINT 12 | CS REAL X, RESULT 13 | DOUBLE PRECISION X, RESULT 14 | C------------------------------------------------------------------ 15 | JINT = 2 16 | CALL CALERF(X,RESULT,JINT) 17 | CS ERFCX = RESULT 18 | DERFCX = RESULT 19 | RETURN 20 | C---------- Last card of DERFCX ---------- 21 | END 22 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/715/ei.f: -------------------------------------------------------------------------------- 1 | CS REAL FUNCTION EI(X) 2 | DOUBLE PRECISION FUNCTION EI(X) 3 | C-------------------------------------------------------------------- 4 | C 5 | C This function program computes approximate values for the 6 | C exponential integral Ei(x), where x is real. 7 | C 8 | C Author: W. J. Cody 9 | C 10 | C Latest modification: March 9, 1992 11 | C 12 | C-------------------------------------------------------------------- 13 | INTEGER INT 14 | CS REAL X, RESULT 15 | DOUBLE PRECISION X, RESULT 16 | C-------------------------------------------------------------------- 17 | INT = 1 18 | CALL CALCEI(X,RESULT,INT) 19 | EI = RESULT 20 | RETURN 21 | C---------- Last line of EI ---------- 22 | END 23 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/715/eone.f: -------------------------------------------------------------------------------- 1 | CS REAL FUNCTION EONE(X) 2 | DOUBLE PRECISION FUNCTION EONE(X) 3 | C-------------------------------------------------------------------- 4 | C 5 | C This function program computes approximate values for the 6 | C exponential integral E1(x), where x is real. 7 | C 8 | C Author: W. J. Cody 9 | C 10 | C Latest modification: March 9, 1992 11 | C 12 | C-------------------------------------------------------------------- 13 | INTEGER INT 14 | CS REAL X, RESULT 15 | DOUBLE PRECISION X, RESULT 16 | C-------------------------------------------------------------------- 17 | INT = 2 18 | CALL CALCEI(X,RESULT,INT) 19 | EONE = RESULT 20 | RETURN 21 | C---------- Last line of EONE ---------- 22 | END 23 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/715/expei.f: -------------------------------------------------------------------------------- 1 | CS REAL FUNCTION EXPEI(X) 2 | DOUBLE PRECISION FUNCTION EXPEI(X) 3 | C-------------------------------------------------------------------- 4 | C 5 | C This function program computes approximate values for the 6 | C function exp(-x) * Ei(x), where Ei(x) is the exponential 7 | C integral, and x is real. 8 | C 9 | C Author: W. J. Cody 10 | C 11 | C Latest modification: March 9, 1992 12 | C 13 | C-------------------------------------------------------------------- 14 | INTEGER INT 15 | CS REAL X, RESULT 16 | DOUBLE PRECISION X, RESULT 17 | C-------------------------------------------------------------------- 18 | INT = 3 19 | CALL CALCEI(X,RESULT,INT) 20 | EXPEI = RESULT 21 | RETURN 22 | C---------- Last line of EXPEI ---------- 23 | END 24 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/717/.cvsignore: -------------------------------------------------------------------------------- 1 | *.lisp 2 | *.p 3 | *.ppcf 4 | dgetlc.tar.bz2 5 | dglfg.tar.bz2 6 | madsen 7 | madsenb 8 | mlmnp 9 | mlmnpb 10 | pmain 11 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/717/brj.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE BRJ(N, P, X, NF, NEED, R, RP, UI, A, UF) 2 | INTEGER N, P, NF, NEED(2), UI(5) 3 | DOUBLE PRECISION X(P), R(N), RP(P,N), A(*) 4 | EXTERNAL UF 5 | EXTERNAL BRJ1 6 | INTEGER M 7 | C 8 | C *** BODY *** 9 | C 10 | M = UI(6) 11 | CALL BRJ1(M, N, UI(7), X, NF, NEED, R, RP, UI, A, A(M*N+1), UF) 12 | 999 RETURN 13 | END 14 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/717/cnerr.f: -------------------------------------------------------------------------------- 1 | 2 | DOUBLE PRECISION FUNCTION CNERR(X) 3 | DOUBLE PRECISION X 4 | 5 | COMMON /INVCMN/ XC, TOL, NCALL 6 | DOUBLE PRECISION XC, TOL 7 | INTEGER NCALL 8 | 9 | DOUBLE PRECISION PNORMS 10 | EXTERNAL PNORMS 11 | NCALL = NCALL + 1 12 | CNERR = XC - PNORMS(X) 13 | END 14 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/717/dd7mlp.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE DD7MLP(N, X, Y, Z, K) 2 | C 3 | C *** SET X = DIAG(Y)**K * Z 4 | C *** FOR X, Z = LOWER TRIANG. MATRICES STORED COMPACTLY BY ROW 5 | C *** K = 1 OR -1. 6 | C 7 | INTEGER N, K 8 | DOUBLE PRECISION X(*), Y(N), Z(*) 9 | INTEGER I, J, L 10 | DOUBLE PRECISION ONE, T 11 | DATA ONE/1.D+0/ 12 | C 13 | L = 1 14 | IF (K .GE. 0) GO TO 30 15 | DO 20 I = 1, N 16 | T = ONE / Y(I) 17 | DO 10 J = 1, I 18 | X(L) = T * Z(L) 19 | L = L + 1 20 | 10 CONTINUE 21 | 20 CONTINUE 22 | GO TO 999 23 | C 24 | 30 DO 50 I = 1, N 25 | T = Y(I) 26 | DO 40 J = 1, I 27 | X(L) = T * Z(L) 28 | L = L + 1 29 | 40 CONTINUE 30 | 50 CONTINUE 31 | 999 RETURN 32 | C *** LAST LINE OF DD7MLP FOLLOWS *** 33 | END 34 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/717/dh2rfa.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE DH2RFA(N, A, B, X, Y, Z) 2 | C 3 | C *** APPLY 2X2 HOUSEHOLDER REFLECTION DETERMINED BY X, Y, Z TO 4 | C *** N-VECTORS A, B *** 5 | C 6 | INTEGER N 7 | DOUBLE PRECISION A(N), B(N), X, Y, Z 8 | INTEGER I 9 | DOUBLE PRECISION T 10 | DO 10 I = 1, N 11 | T = A(I)*X + B(I)*Y 12 | A(I) = A(I) + T 13 | B(I) = B(I) + T*Z 14 | 10 CONTINUE 15 | 999 RETURN 16 | C *** LAST LINE OF DH2RFA FOLLOWS *** 17 | END 18 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/717/dh2rfg.f: -------------------------------------------------------------------------------- 1 | DOUBLE PRECISION FUNCTION DH2RFG(A, B, X, Y, Z) 2 | C 3 | C *** DETERMINE X, Y, Z SO I + (1,Z)**T * (X,Y) IS A 2X2 4 | C *** HOUSEHOLDER REFLECTION SENDING (A,B)**T INTO (C,0)**T, 5 | C *** WHERE C = -SIGN(A)*SQRT(A**2 + B**2) IS THE VALUE DH2RFG 6 | C *** RETURNS. 7 | C 8 | DOUBLE PRECISION A, B, X, Y, Z 9 | C 10 | DOUBLE PRECISION A1, B1, C, T 11 | DOUBLE PRECISION ZERO 12 | DATA ZERO/0.D+0/ 13 | C 14 | C *** BODY *** 15 | C 16 | IF (B .NE. ZERO) GO TO 10 17 | X = ZERO 18 | Y = ZERO 19 | Z = ZERO 20 | DH2RFG = A 21 | GO TO 999 22 | 10 T = ABS(A) + ABS(B) 23 | A1 = A / T 24 | B1 = B / T 25 | C = SQRT(A1**2 + B1**2) 26 | IF (A1 .GT. ZERO) C = -C 27 | A1 = A1 - C 28 | Z = B1 / A1 29 | X = A1 / C 30 | Y = B1 / C 31 | DH2RFG = T * C 32 | 999 RETURN 33 | C *** LAST LINE OF DH2RFG FOLLOWS *** 34 | END 35 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/717/dl7itv.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE DL7ITV(N, X, L, Y) 2 | C 3 | C *** SOLVE (L**T)*X = Y, WHERE L IS AN N X N LOWER TRIANGULAR 4 | C *** MATRIX STORED COMPACTLY BY ROWS. X AND Y MAY OCCUPY THE SAME 5 | C *** STORAGE. *** 6 | C 7 | INTEGER N 8 | DOUBLE PRECISION X(N), L(1), Y(N) 9 | INTEGER I, II, IJ, IM1, I0, J, NP1 10 | DOUBLE PRECISION XI, ZERO 11 | PARAMETER (ZERO=0.D+0) 12 | C 13 | DO 10 I = 1, N 14 | 10 X(I) = Y(I) 15 | NP1 = N + 1 16 | I0 = N*(N+1)/2 17 | DO 30 II = 1, N 18 | I = NP1 - II 19 | XI = X(I)/L(I0) 20 | X(I) = XI 21 | IF (I .LE. 1) GO TO 999 22 | I0 = I0 - I 23 | IF (XI .EQ. ZERO) GO TO 30 24 | IM1 = I - 1 25 | DO 20 J = 1, IM1 26 | IJ = I0 + J 27 | X(J) = X(J) - XI*L(IJ) 28 | 20 CONTINUE 29 | 30 CONTINUE 30 | 999 RETURN 31 | C *** LAST LINE OF DL7ITV FOLLOWS *** 32 | END 33 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/717/dl7ivm.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE DL7IVM(N, X, L, Y) 2 | C 3 | C *** SOLVE L*X = Y, WHERE L IS AN N X N LOWER TRIANGULAR 4 | C *** MATRIX STORED COMPACTLY BY ROWS. X AND Y MAY OCCUPY THE SAME 5 | C *** STORAGE. *** 6 | C 7 | INTEGER N 8 | DOUBLE PRECISION X(N), L(1), Y(N) 9 | DOUBLE PRECISION DD7TPR 10 | EXTERNAL DD7TPR 11 | INTEGER I, J, K 12 | DOUBLE PRECISION T, ZERO 13 | PARAMETER (ZERO=0.D+0) 14 | C 15 | DO 10 K = 1, N 16 | IF (Y(K) .NE. ZERO) GO TO 20 17 | X(K) = ZERO 18 | 10 CONTINUE 19 | GO TO 999 20 | 20 J = K*(K+1)/2 21 | X(K) = Y(K) / L(J) 22 | IF (K .GE. N) GO TO 999 23 | K = K + 1 24 | DO 30 I = K, N 25 | T = DD7TPR(I-1, L(J+1), X) 26 | J = J + I 27 | X(I) = (Y(I) - T)/L(J) 28 | 30 CONTINUE 29 | 999 RETURN 30 | C *** LAST LINE OF DL7IVM FOLLOWS *** 31 | END 32 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/717/dl7tvm.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE DL7TVM(N, X, L, Y) 2 | C 3 | C *** COMPUTE X = (L**T)*Y, WHERE L IS AN N X N LOWER 4 | C *** TRIANGULAR MATRIX STORED COMPACTLY BY ROWS. X AND Y MAY 5 | C *** OCCUPY THE SAME STORAGE. *** 6 | C 7 | INTEGER N 8 | DOUBLE PRECISION X(N), L(1), Y(N) 9 | C DIMENSION L(N*(N+1)/2) 10 | INTEGER I, IJ, I0, J 11 | DOUBLE PRECISION YI, ZERO 12 | PARAMETER (ZERO=0.D+0) 13 | C 14 | I0 = 0 15 | DO 20 I = 1, N 16 | YI = Y(I) 17 | X(I) = ZERO 18 | DO 10 J = 1, I 19 | IJ = I0 + J 20 | X(J) = X(J) + YI*L(IJ) 21 | 10 CONTINUE 22 | I0 = I0 + I 23 | 20 CONTINUE 24 | 999 RETURN 25 | C *** LAST LINE OF DL7TVM FOLLOWS *** 26 | END 27 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/717/dl7vml.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE DL7VML(N, X, L, Y) 2 | C 3 | C *** COMPUTE X = L*Y, WHERE L IS AN N X N LOWER TRIANGULAR 4 | C *** MATRIX STORED COMPACTLY BY ROWS. X AND Y MAY OCCUPY THE SAME 5 | C *** STORAGE. *** 6 | C 7 | INTEGER N 8 | DOUBLE PRECISION X(N), L(1), Y(N) 9 | C DIMENSION L(N*(N+1)/2) 10 | INTEGER I, II, IJ, I0, J, NP1 11 | DOUBLE PRECISION T, ZERO 12 | PARAMETER (ZERO=0.D+0) 13 | C 14 | NP1 = N + 1 15 | I0 = N*(N+1)/2 16 | DO 20 II = 1, N 17 | I = NP1 - II 18 | I0 = I0 - I 19 | T = ZERO 20 | DO 10 J = 1, I 21 | IJ = I0 + J 22 | T = T + L(IJ)*Y(J) 23 | 10 CONTINUE 24 | X(I) = T 25 | 20 CONTINUE 26 | 999 RETURN 27 | C *** LAST LINE OF DL7VML FOLLOWS *** 28 | END 29 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/717/do7prd.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE DO7PRD(L, LS, P, S, W, Y, Z) 2 | C 3 | C *** FOR I = 1..L, SET S = S + W(I)*Y(.,I)*(Z(.,I)**T), I.E., 4 | C *** ADD W(I) TIMES THE OUTER PRODUCT OF Y(.,I) AND Z(.,I). 5 | C 6 | INTEGER L, LS, P 7 | DOUBLE PRECISION S(LS), W(L), Y(P,L), Z(P,L) 8 | C DIMENSION S(P*(P+1)/2) 9 | C 10 | INTEGER I, J, K, M 11 | DOUBLE PRECISION WK, YI, ZERO 12 | DATA ZERO/0.D+0/ 13 | C 14 | DO 30 K = 1, L 15 | WK = W(K) 16 | IF (WK .EQ. ZERO) GO TO 30 17 | M = 1 18 | DO 20 I = 1, P 19 | YI = WK * Y(I,K) 20 | DO 10 J = 1, I 21 | S(M) = S(M) + YI*Z(J,K) 22 | M = M + 1 23 | 10 CONTINUE 24 | 20 CONTINUE 25 | 30 CONTINUE 26 | C 27 | 999 RETURN 28 | C *** LAST LINE OF DO7PRD FOLLOWS *** 29 | END 30 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/717/drldst.f: -------------------------------------------------------------------------------- 1 | DOUBLE PRECISION FUNCTION DRLDST(P, D, X, X0) 2 | C 3 | C *** COMPUTE AND RETURN RELATIVE DIFFERENCE BETWEEN X AND X0 *** 4 | C *** NL2SOL VERSION 2.2 *** 5 | C 6 | INTEGER P 7 | DOUBLE PRECISION D(P), X(P), X0(P) 8 | C 9 | INTEGER I 10 | DOUBLE PRECISION EMAX, T, XMAX, ZERO 11 | PARAMETER (ZERO=0.D+0) 12 | C 13 | C *** BODY *** 14 | C 15 | EMAX = ZERO 16 | XMAX = ZERO 17 | DO 10 I = 1, P 18 | T = ABS(D(I) * (X(I) - X0(I))) 19 | IF (EMAX .LT. T) EMAX = T 20 | T = D(I) * ( ABS(X(I)) + ABS(X0(I))) 21 | IF (XMAX .LT. T) XMAX = T 22 | 10 CONTINUE 23 | DRLDST = ZERO 24 | IF (XMAX .GT. ZERO) DRLDST = EMAX / XMAX 25 | 999 RETURN 26 | C *** LAST LINE OF DRLDST FOLLOWS *** 27 | END 28 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/717/ds7dmp.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE DS7DMP(N, X, Y, Z, K) 2 | C 3 | C *** SET X = DIAG(Z)**K * Y * DIAG(Z)**K 4 | C *** FOR X, Y = COMPACTLY STORED LOWER TRIANG. MATRICES 5 | C *** K = 1 OR -1. 6 | C 7 | INTEGER N, K 8 | DOUBLE PRECISION X(*), Y(*), Z(N) 9 | INTEGER I, J, L 10 | DOUBLE PRECISION ONE, T 11 | DATA ONE/1.D+0/ 12 | C 13 | L = 1 14 | IF (K .GE. 0) GO TO 30 15 | DO 20 I = 1, N 16 | T = ONE / Z(I) 17 | DO 10 J = 1, I 18 | X(L) = T * Y(L) / Z(J) 19 | L = L + 1 20 | 10 CONTINUE 21 | 20 CONTINUE 22 | GO TO 999 23 | C 24 | 30 DO 50 I = 1, N 25 | T = Z(I) 26 | DO 40 J = 1, I 27 | X(L) = T * Y(L) * Z(J) 28 | L = L + 1 29 | 40 CONTINUE 30 | 50 CONTINUE 31 | 999 RETURN 32 | C *** LAST LINE OF DS7DMP FOLLOWS *** 33 | END 34 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/717/dv2axy.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE DV2AXY(P, W, A, X, Y) 2 | C 3 | C *** SET W = A*X + Y -- W, X, Y = P-VECTORS, A = SCALAR *** 4 | C 5 | INTEGER P 6 | DOUBLE PRECISION A, W(P), X(P), Y(P) 7 | C 8 | INTEGER I 9 | C 10 | DO 10 I = 1, P 11 | 10 W(I) = A*X(I) + Y(I) 12 | RETURN 13 | END 14 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/717/dv7cpy.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE DV7CPY(P, Y, X) 2 | C 3 | C *** SET Y = X, WHERE X AND Y ARE P-VECTORS *** 4 | C 5 | INTEGER P 6 | DOUBLE PRECISION X(P), Y(P) 7 | C 8 | INTEGER I 9 | C 10 | DO 10 I = 1, P 11 | 10 Y(I) = X(I) 12 | RETURN 13 | END 14 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/717/dv7ipr.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE DV7IPR(N, IP, X) 2 | C 3 | C PERMUTE X SO THAT X.OUTPUT(I) = X.INPUT(IP(I)). 4 | C IP IS UNCHANGED ON OUTPUT. 5 | C 6 | INTEGER N 7 | INTEGER IP(N) 8 | DOUBLE PRECISION X(N) 9 | C 10 | INTEGER I, J, K 11 | DOUBLE PRECISION T 12 | DO 30 I = 1, N 13 | J = IP(I) 14 | IF (J .EQ. I) GO TO 30 15 | IF (J .GT. 0) GO TO 10 16 | IP(I) = -J 17 | GO TO 30 18 | 10 T = X(I) 19 | K = I 20 | 20 X(K) = X(J) 21 | K = J 22 | J = IP(K) 23 | IP(K) = -J 24 | IF (J .GT. I) GO TO 20 25 | X(K) = T 26 | 30 CONTINUE 27 | 999 RETURN 28 | C *** LAST LINE OF DV7IPR FOLLOWS *** 29 | END 30 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/717/dv7scl.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE DV7SCL(N, X, A, Y) 2 | C 3 | C *** SET X(I) = A*Y(I), I = 1(1)N *** 4 | C 5 | INTEGER N 6 | DOUBLE PRECISION A, X(N), Y(N) 7 | C 8 | INTEGER I 9 | C 10 | DO 10 I = 1, N 11 | 10 X(I) = A * Y(I) 12 | 999 RETURN 13 | C *** LAST LINE OF DV7SCL FOLLOWS *** 14 | END 15 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/717/dv7scp.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE DV7SCP(P, Y, S) 2 | C 3 | C *** SET P-VECTOR Y TO SCALAR S *** 4 | C 5 | INTEGER P 6 | DOUBLE PRECISION S, Y(P) 7 | C 8 | INTEGER I 9 | C 10 | DO 10 I = 1, P 11 | 10 Y(I) = S 12 | RETURN 13 | END 14 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/717/dv7shf.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE DV7SHF(N, K, X) 2 | C 3 | C *** SHIFT X(K),...,X(N) LEFT CIRCULARLY ONE POSITION *** 4 | C 5 | INTEGER N, K 6 | DOUBLE PRECISION X(N) 7 | C 8 | INTEGER I, NM1 9 | DOUBLE PRECISION T 10 | C 11 | IF (K .GE. N) GO TO 999 12 | NM1 = N - 1 13 | T = X(K) 14 | DO 10 I = K, NM1 15 | 10 X(I) = X(I+1) 16 | X(N) = T 17 | 999 RETURN 18 | END 19 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/717/dv7vmp.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE DV7VMP(N, X, Y, Z, K) 2 | C 3 | C *** SET X(I) = Y(I) * Z(I)**K, 1 .LE. I .LE. N (FOR K = 1 OR -1) *** 4 | C 5 | INTEGER N, K 6 | DOUBLE PRECISION X(N), Y(N), Z(N) 7 | INTEGER I 8 | C 9 | IF (K .GE. 0) GO TO 20 10 | DO 10 I = 1, N 11 | 10 X(I) = Y(I) / Z(I) 12 | GO TO 999 13 | C 14 | 20 DO 30 I = 1, N 15 | 30 X(I) = Y(I) * Z(I) 16 | 999 RETURN 17 | C *** LAST LINE OF DV7VMP FOLLOWS *** 18 | END 19 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/717/dvsum.f: -------------------------------------------------------------------------------- 1 | DOUBLE PRECISION FUNCTION DVSUM(N, X) 2 | INTEGER N 3 | DOUBLE PRECISION X(N) 4 | INTEGER I 5 | C 6 | DVSUM = 0.D+0 7 | DO 10 I = 1, N 8 | 10 DVSUM = DVSUM + X(I) 9 | END 10 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/717/i7copy.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE I7COPY(P, Y, X) 2 | C 3 | C *** SET Y = X, WHERE X AND Y ARE INTEGER P-VECTORS *** 4 | C 5 | INTEGER P 6 | INTEGER X(P), Y(P) 7 | C 8 | INTEGER I 9 | C 10 | DO 10 I = 1, P 11 | 10 Y(I) = X(I) 12 | 999 RETURN 13 | END 14 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/717/i7pnvr.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE I7PNVR(N, X, Y) 2 | C 3 | C *** SET PERMUTATION VECTOR X TO INVERSE OF Y *** 4 | C 5 | INTEGER N 6 | INTEGER X(N), Y(N) 7 | C 8 | INTEGER I, J 9 | DO 10 I = 1, N 10 | J = Y(I) 11 | X(J) = I 12 | 10 CONTINUE 13 | C 14 | 999 RETURN 15 | C *** LAST LINE OF I7PNVR FOLLOWS *** 16 | END 17 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/717/i7shft.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE I7SHFT(N, K, X) 2 | C 3 | C *** SHIFT X(K),...,X(N) LEFT CIRCULARLY ONE POSITION *** 4 | C 5 | INTEGER N, K 6 | INTEGER X(N) 7 | C 8 | INTEGER I, NM1, T 9 | C 10 | IF (K .GE. N) GO TO 999 11 | NM1 = N - 1 12 | T = X(K) 13 | DO 10 I = K, NM1 14 | 10 X(I) = X(I+1) 15 | X(N) = T 16 | 999 RETURN 17 | END 18 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/717/louchk.f: -------------------------------------------------------------------------------- 1 | SUBROUTINE LOUCHK(KDIAG, DGLG, X0, N, P, PS, X, RHPOIL, MDL, YN, 2 | 1 IV, LIV, LV, V, BRJ, UI, A, BRJ1) 3 | EXTERNAL DGLG, RHPOIL, BRJ, BRJ1 4 | INTEGER KDIAG, N, P, PS, LIV, LV 5 | INTEGER IV(LIV), MDL(2), UI(*) 6 | DOUBLE PRECISION X0(P), X(P), V(LV), A(*), YN(N) 7 | C 8 | C *** DUMMY REPLACEMENT FOR C ROUTINE (USED FOR DEBUGGING) *** 9 | C 10 | END 11 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/717/lpn.f: -------------------------------------------------------------------------------- 1 | DOUBLE PRECISION FUNCTION LPN(X) 2 | COMMON /FUDGE/ NFUDGE 3 | INTEGER NFUDGE 4 | DOUBLE PRECISION X 5 | EXTERNAL PNORMS 6 | DOUBLE PRECISION PNORMS 7 | DOUBLE PRECISION T 8 | DOUBLE PRECISION DLOG 9 | DOUBLE PRECISION HALF, ZERO 10 | DATA HALF/0.5D+0/, ZERO/0.D+0/ 11 | C 12 | C *** BODY *** 13 | C 14 | T = PNORMS(X) 15 | IF (T .GT. ZERO) THEN 16 | LPN = DLOG(T) 17 | ELSE 18 | NFUDGE = NFUDGE + 1 19 | LPN = -HALF*X**2 - DLOG(-X) 20 | END IF 21 | 999 RETURN 22 | END 23 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/717/madrj.f: -------------------------------------------------------------------------------- 1 | C*********************************************************************** 2 | C 3 | C MADRJ 4 | C 5 | C*********************************************************************** 6 | SUBROUTINE MADRJ(N, P, X, NF, NEED, R, RP, UI, UR, UF) 7 | INTEGER N, P, NF, NEED(2), UI(1) 8 | DOUBLE PRECISION X(P), R(N), RP(P,N), UR(1) 9 | EXTERNAL UF 10 | DOUBLE PRECISION TWO, ZERO 11 | PARAMETER (TWO=2.D+0, ZERO=0.D+0) 12 | C 13 | C *** BODY *** 14 | C 15 | IF (NEED(1) .EQ. 2) GO TO 10 16 | R(1) = X(1)**2 + X(2)**2 + X(1)*X(2) 17 | R(2) = SIN(X(1)) 18 | R(3) = COS(X(2)) 19 | GO TO 999 20 | C 21 | 10 RP(1,1) = TWO*X(1) + X(2) 22 | RP(2,1) = TWO*X(2) + X(1) 23 | RP(1,2) = COS(X(1)) 24 | RP(2,2) = ZERO 25 | RP(1,3) = ZERO 26 | RP(2,3) = -SIN(X(2)) 27 | C 28 | 999 RETURN 29 | END 30 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/717/madsenb.out: -------------------------------------------------------------------------------- 1 | DGLGB ON PROBLEM MADSEN... 2 | DGLGB NEEDED LIV .GE. 92 AND LV .GE. 179 3 | 4 | DGLFB ON PROBLEM MADSEN... 5 | 6 | DGLFB ON PROBLEM MADSEN AGAIN... 7 | 8 | NONDEFAULT VALUES.... 9 | 10 | LMAX0..... V(35) = 0.1000000E+00 11 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/717/mnpex1.fu1: -------------------------------------------------------------------------------- 1 | 5 50 3 0 -1 3 6 0 2 0 2 | 3 1 1 1 0 3 | TTIME 4 | 0. -100. 100. 5 | DBUS 6 | 0. -100. 100. 7 | DSTREETC 8 | 0. -100. 100. 9 | B21 10 | 1. -100. 100. 11 | B22 12 | 1. -100. 100. 13 | 14 | Example 1: Trinomial probit model for mode choice, using Daganzo data. 15 | This example includes alternative-specific means, correlated alternative- 16 | specific errors, and NO random taste variation for traveltime. 17 | Explanatory data (for Unit 2 input stream) are in Daganzo.fu2. 18 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/717/mnpex2.fu1: -------------------------------------------------------------------------------- 1 | 6 50 3 0 -1 3 6 0 2 0 2 | 3 1 1 1 1 3 | TTIME 4 | 0. -100. 100. 5 | DBUS 6 | 0. -100. 100. 7 | DSTREETC 8 | 0. -100. 100. 9 | B21 10 | 1. -100. 100. 11 | B22 12 | 1. -100. 100. 13 | SigT 14 | 1. 0.0001 100. 15 | Example 2: Trinomial probit model for mode choice, using Daganzo data. 16 | This example includes alternative-specific means, correlated alternative- 17 | specific errors, and random taste variation for traveltime. 18 | Explanatory data (for Fortran Unit 2) are in Daganzo.fu2. 19 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/717/phi.f: -------------------------------------------------------------------------------- 1 | C--------------------------------------------------- 2 | DOUBLE PRECISION FUNCTION PHI(X, Y) 3 | DOUBLE PRECISION X, Y 4 | DOUBLE PRECISION ARG 5 | DOUBLE PRECISION HALF, SQ2P, XLOW, ZERO 6 | PARAMETER (HALF = 0.5D0, SQ2P = 0.91893853320467274D0, 7 | 1 XLOW = -87.D0, ZERO = 0.D0) 8 | PHI = ZERO 9 | ARG = -HALF * X * X - SQ2P - Y 10 | IF (ARG .GT. XLOW) PHI = EXP(ARG) 11 | END 12 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/717/pnorms.f: -------------------------------------------------------------------------------- 1 | DOUBLE PRECISION FUNCTION PNORMS(X) 2 | DOUBLE PRECISION X 3 | 4 | EXTERNAL MECDF 5 | DOUBLE PRECISION D(1), PROB, RHO(1) 6 | INTEGER IER 7 | 8 | D(1) = X 9 | CALL MECDF(1, D, RHO, PROB, IER) 10 | PNORMS = 1.D+0 - PROB 11 | END 12 | -------------------------------------------------------------------------------- /src/f2cl/packages/toms/717/stopx.f: -------------------------------------------------------------------------------- 1 | LOGICAL FUNCTION STOPX(IDUMMY) 2 | C *****PARAMETERS... 3 | INTEGER IDUMMY 4 | C 5 | C .................................................................. 6 | C 7 | C *****PURPOSE... 8 | C THIS FUNCTION MAY SERVE AS THE STOPX (ASYNCHRONOUS INTERRUPTION) 9 | C FUNCTION FOR THE NL2SOL (NONLINEAR LEAST-SQUARES) PACKAGE AT 10 | C THOSE INSTALLATIONS WHICH DO NOT WISH TO IMPLEMENT A 11 | C DYNAMIC STOPX. 12 | C 13 | C *****ALGORITHM NOTES... 14 | C AT INSTALLATIONS WHERE THE NL2SOL SYSTEM IS USED 15 | C INTERACTIVELY, THIS DUMMY STOPX SHOULD BE REPLACED BY A 16 | C FUNCTION THAT RETURNS .TRUE. IF AND ONLY IF THE INTERRUPT 17 | C (BREAK) KEY HAS BEEN PRESSED SINCE THE LAST CALL ON STOPX. 18 | C 19 | C .................................................................. 20 | C 21 | STOPX = .FALSE. 22 | RETURN 23 | END 24 | -------------------------------------------------------------------------------- /src/f2cl/src/.cvsignore: -------------------------------------------------------------------------------- 1 | *.ppcf 2 | *.sse2f 3 | -------------------------------------------------------------------------------- /src/f2cl/src/f2cl8.l: -------------------------------------------------------------------------------- 1 | ;; -*- Mode: lisp; Package: F2CL -*- 2 | 3 | (in-package :f2cl) 4 | 5 | (defun make-cmucl-ffi (name info) 6 | (let ((arg-info (mapcar #'(lambda (arg ret) 7 | (if ret 8 | `(,arg :in-out) 9 | `(,arg))) 10 | (f2cl-finfo-arg-types info) 11 | (f2cl-finfo-return-values info)))) 12 | (format t "~A -> ~A~%" name arg-info))) 13 | 14 | (defun make-ffi (&key (style :cmucl)) 15 | (let ((maker-fun (ecase style 16 | (:cmucl 17 | #'make-cmucl-ffi)))) 18 | (maphash maker-fun *f2cl-function-info*))) 19 | 20 | -------------------------------------------------------------------------------- /src/f2cl/val/.cvsignore: -------------------------------------------------------------------------------- 1 | *.lisp 2 | *.ppcf 3 | -------------------------------------------------------------------------------- /src/f2cl/val/README: -------------------------------------------------------------------------------- 1 | This directory contains some files used for testing f2cl as it developed. 2 | Some of the files test specifics (as indicated by the file name), other 3 | files contain assorted pieces of code from various sources. 4 | 5 | The test file collection is not comprehensive. 6 | -------------------------------------------------------------------------------- /src/f2cl/val/arithIFtest.for: -------------------------------------------------------------------------------- 1 | C A NAG subroutine - contains arithmetic IFs 2 | C 3 | INTEGER FUNCTION H02BAZ(U,V) 4 | C NAG COPYRIGHT 1975 5 | C MARK 4.5 REVISED 6 | C MARK 11.5(F77) REVISED. (SEPT 1985.) 7 | C .. Scalar Arguments .. 8 | INTEGER U, V 9 | C .. Local Scalars .. 10 | INTEGER W 11 | C .. Executable Statements .. 12 | W = U/V 13 | 20 IF (W*V-U) 60, 60, 40 14 | 40 W = W - 1 15 | GO TO 20 16 | 60 IF ((W+1)*V-U) 80, 80, 100 17 | 80 W = W + 1 18 | GO TO 60 19 | 100 H02BAZ = W 20 | RETURN 21 | END 22 | -------------------------------------------------------------------------------- /src/f2cl/val/fort.1: -------------------------------------------------------------------------------- 1 | 1 2 | 42 3 | 1729 4 | 6 5 | -------------------------------------------------------------------------------- /src/f2cl/val/kendl1.for: -------------------------------------------------------------------------------- 1 | SUBROUTINE KENDL1(DATA1,DATA2,N,TAU,Z,PROB) 2 | DIMENSION DATA1(N),DATA2(N) 3 | N1=0 4 | N2=0 5 | IS=0 6 | DO 12 J=1,N-1 7 | DO 11 K=J+1,N 8 | A1=DATA1(J)-DATA1(K) 9 | A2=DATA2(J)-DATA2(K) 10 | AA=A1*A2 11 | IF(AA.NE.0.)THEN 12 | N1=N1+1 13 | N2=N2+1 14 | IF(AA.GT.0.)THEN 15 | IS=IS+1 16 | ELSE 17 | IS=IS-1 18 | ENDIF 19 | ELSE 20 | IF(A1 .NE.0.)N1=N1+1 21 | IF(A2 .NE.0.)N2=N2+1 22 | ENDIF 23 | 11 CONTINUE 24 | 12 CONTINUE 25 | TAU=FLOAT(IS)/SQRT(FLOAT(N1)*FLOAT(N2)) 26 | VAR=(4.*N+10.)/(9.*N*(N-1.)) 27 | Z=TAU/SQRT(VAR) 28 | PROB=ERFCC(ABS(Z)/1.4142136) 29 | RETURN 30 | END 31 | -------------------------------------------------------------------------------- /src/f2cl/val/rtflsp.for: -------------------------------------------------------------------------------- 1 | C Contains a jump out of a do loop to end 2 | FUNCTION RTFLSP(FUNC,X1,X2,XACC) 3 | PARAMETER (MAXIT=30) 4 | FL=FUNC(X1) 5 | FH=FUNC(X2) 6 | IF(FL*FH > 0.) PAUSE 'Root must be bracketed for false position.' 7 | IF(FL < 0.)THEN 8 | XL=X1 9 | XH=X2 10 | ELSE 11 | XL=X2 12 | XH=X1 13 | SWAP=FL 14 | FL=FH 15 | FH=SWAP 16 | ENDIF 17 | DX=XH-XL 18 | DO 11 J=1,MAXIT 19 | RTFLSP=XL+DX*FL/(FL-FH) 20 | F=FUNC(RTFLSP) 21 | IF(F < 0.) THEN 22 | DEL=XL-RTFLSP 23 | XL=RTFLSP 24 | FL=F 25 | ELSE 26 | DEL=XH-RTFLSP 27 | XH=RTFLSP 28 | FH=F 29 | ENDIF 30 | DX=XH-XL 31 | IF(ABS(DEL) < XACC or F .EQ. 0.)RETURN 32 | 11 CONTINUE 33 | PAUSE 'RTFLSP exceed maximum iterations' 34 | END 35 | -------------------------------------------------------------------------------- /src/f2cl/val/rtnewt.for: -------------------------------------------------------------------------------- 1 | C Contains a subroutine call with uninitiated arg 2 | FUNCTION RTNEWT(FUNCD,X1,X2,XACC) 3 | PARAMETER (JMAX=20) 4 | RTNEWT=.5*(X1+X2) 5 | DO 11 J=1,JMAX 6 | CALL FUNCD(RTNEWT,F,DF) 7 | DX=F/DF 8 | RTNEWT=RTNEWT-DX 9 | IF((X1-RTNEWT)*(RTNEWT-X2) < 0.)PAUSE 'jumped out of brackets' 10 | IF(ABS(DX) < XACC) RETURN 11 | 11 CONTINUE 12 | PAUSE 'RTNEWT exceeding maximum iterations' 13 | END 14 | -------------------------------------------------------------------------------- /src/f2cl/val/simpletest.for: -------------------------------------------------------------------------------- 1 | C chsone.for and chstwo.for from numerical recipes 2 | C simple test file 3 | C 4 | C 5 | SUBROUTINE CHSONE(BINS,EBINS,NBINS,KNSTRN,DF,CHSQ,PROB) 6 | DIMENSION BINS(NBINS),EBINS(NBINS) 7 | DF=NBINS-1-KNSTRN 8 | CHSQ=0. 9 | DO 11 J=1,NBINS 10 | IF(EBINS(J).LE.0.)PAUSE 'bad expected number' 11 | CHSQ=CHSQ+(BINS(J)-EBINS(J))**2/EBINS(J) 12 | 11 CONTINUE 13 | PROB=GAMMQ(0.5*DF,0.5*CHSQ) 14 | RETURN 15 | END 16 | C 17 | C 18 | SUBROUTINE CHSTWO(BINS1,BINS2,NBINS,KNSTRN,DF,CHSQ,PROB) 19 | DIMENSION BINS1(NBINS),BINS2(NBINS) 20 | DF=NBINS-1-KNSTRN 21 | CHSQ=0. 22 | DO 11 J=1,NBINS 23 | IF(BINS1(J).EQ.0..AND.BINS2(J).EQ.0.)THEN 24 | DF=DF-1. 25 | ELSE 26 | CHSQ=CHSQ+(BINS1(J)-BINS2(J))**2/(BINS1(J)+BINS2(J)) 27 | ENDIF 28 | 11 CONTINUE 29 | PROB=GAMMQ(0.5*DF,0.5*CHSQ) 30 | RETURN 31 | END 32 | -------------------------------------------------------------------------------- /src/f2cl/val/test.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/blindglobe/clocc/a50bb75edb01039b282cf320e4505122a59c59a7/src/f2cl/val/test.out -------------------------------------------------------------------------------- /src/f2cl/val/tst-char-init.f: -------------------------------------------------------------------------------- 1 | CHARACTER*4 MODEL1(6), MODEL2(6) 2 | DATA MODEL1/' ',' ',' ',' ',' G ',' S '/ 3 | c 1 MODEL2 4 | data model2(1)/' G '/ 5 | data model2(2)/' S '/ 6 | print *, model1(1) 7 | print *, model1(2) 8 | print *, model1(3) 9 | print *, model1(4) 10 | print *, model1(5) 11 | print *, model1(6) 12 | print *, model2(1) 13 | print *, model2(2) 14 | print *, model2(3) 15 | print *, model2(4) 16 | print *, model2(5) 17 | print *, model2(6) 18 | end 19 | -------------------------------------------------------------------------------- /src/f2cl/val/tst-char.f: -------------------------------------------------------------------------------- 1 | c Some random tests for character handling 2 | c program prog 3 | parameter (len = 45) 4 | real x(37) 5 | real y(3, 4) 6 | character s1*10, s2*20 7 | character*33 s3, s4 8 | character ca(3,4)*11, ca2(4,5)*12 9 | character*17 cb(1,2), cb2(2,3), cb3(0:3, len) 10 | character*5 a1(4), a2(6) 11 | character*(*) zz 12 | character c1 13 | character*1 p01rec(1) 14 | 15 | x(8) = 8.0 16 | y(1, 3) = 7.0 17 | c1 = 'a' 18 | s3 = 'abcd' 19 | ca(1,1) = '12345678901' 20 | ca2(1,1) = ca(1,1) 21 | write(*, 9000) c1 22 | write(*, 9000) s3 23 | write(*, 9000) ca(1,1) 24 | write(*, 9000) ca2(1,1) 25 | 9000 format(1x, '|', a, '|') 26 | 27 | call xyzzy(p01rec) 28 | end 29 | 30 | subroutine zz (x, y) 31 | real x 32 | real y(10) 33 | x = 5 34 | y(10) = 7 35 | y(3) = 8 36 | return 37 | end 38 | -------------------------------------------------------------------------------- /src/f2cl/val/tst-fixups.f: -------------------------------------------------------------------------------- 1 | machep = -it - 3 2 | z = a + b + c + d - 5 3 | end 4 | -------------------------------------------------------------------------------- /src/f2cl/val/tst-init.f: -------------------------------------------------------------------------------- 1 | subroutine sub() 2 | parameter (n = 3) 3 | parameter (m = 4) 4 | integer ka(n, m) 5 | data ka/11,21,31,12, 22, 32/ 6 | 7 | do 10 k = 1,n 8 | do 20 j = 1,m 9 | print 9000, k, j, ka(k, j) 10 | 020 continue 11 | 10 continue 12 | 9000 format(1x, 'KA(', i1, ', ', i1, ') = ', i5) 13 | 14 | 15 | return 16 | end 17 | 18 | program init 19 | integer iarray(3,2) 20 | data iarray/11,21,31,12,22,32/ 21 | 22 | do 10 k = 1,3 23 | do 20 j = 1,2 24 | print 9000, k, j, iarray(k, j) 25 | 020 continue 26 | 10 continue 27 | 9000 format(1x, 'X(', i1, ', ', i1, ') = ', i5) 28 | 29 | call sub 30 | end 31 | -------------------------------------------------------------------------------- /src/f2cl/val/tst-number.f: -------------------------------------------------------------------------------- 1 | program num 2 | data z / 1.234 567 8 e+10/ 3 | x = 1.234 567e9+.123 456 e 9 4 | x = 0. 1 2 3 5 | x = 7 6 | x = 8. 7 | y = 1. 2 3 4 e+ 9 8 | z = -3.14159e + 1 * x 9 | z = -3. 1 4 1 5 9 e - 1 0 * x 10 | z = -3. 1 4 1 5 9 e - 10 * (-2. 7 1 8 2 8)/ y 11 | z = -3. 1 4 1 5 9 e - 1 0 * (- 2. 7 1 8 2 8 / y) 12 | if (z .ge. 6.or. y.ge.1) x= 3. 0 13 | end 14 | -------------------------------------------------------------------------------- /src/f2cl/val/tst-parse.f: -------------------------------------------------------------------------------- 1 | c IF (V(STPPAR) .EQ. ZERO. AND. V(RELDX) .LE. V(XCTOL)) I = I + 1 2 | if (5 .eq . zero. and . v) i = i + 1 3 | if (zero. eq. 5. and. z) i = i + 1 4 | end 5 | -------------------------------------------------------------------------------- /src/f2cl/val/tst-slice.f: -------------------------------------------------------------------------------- 1 | program slice 2 | c 3 | c Simple program to test if array slicing works. 4 | c 5 | parameter (len = 20) 6 | real x(len) 7 | integer k 8 | 9 | do 10 k = 1, len 10 | x(k) = k * k 11 | 10 continue 12 | 13 | call sub2(x, len) 14 | call sub2(x(5), 5) 15 | call sub2(x(10), 10) 16 | end 17 | 18 | subroutine sub2(x,n) 19 | real x(n) 20 | x(2) = 89 21 | call sub(x(2), n-1) 22 | return 23 | end 24 | subroutine sub(x, n) 25 | real x(n) 26 | integer k 27 | 28 | do 10 k = 1, n 29 | write(*, 9000) k, x(k) 30 | 10 continue 31 | 9000 format(1x, i5, g15.7) 32 | end 33 | 34 | -------------------------------------------------------------------------------- /src/f2cl/val/twofft.for: -------------------------------------------------------------------------------- 1 | SUBROUTINE TWOFFT(DATA1,DATA2,FFT1,FFT2,N) 2 | DIMENSION DATA1(N),DATA2(N) 3 | COMPLEX FFT1(N),FFT2(N),H1,H2,C1,C2 4 | C1=CMPLX(0.5,0.0) 5 | C2=CMPLX(0.0,-0.5) 6 | DO 11 J=1,N 7 | FFT1(J)=CMPLX(DATA1(J),DATA2(J)) 8 | 11 CONTINUE 9 | CALL FOUR1(FFT1,N,1) 10 | FFT2(1)=CMPLX(AIMAG(FFT1(1)),0.0) 11 | FFT1(1)=CMPLX(REAL(FFT1(1)),0.0) 12 | N2=N+2 13 | DO 12 J=2,N/2+1 14 | H1=C1*(FFT1(J)+CONJG(FFT1(N2-J))) 15 | H2=C2*(FFT1(J)-CONJG(FFT1(N2-J))) 16 | FFT1(J)=H1 17 | FFT1(N2-J)=CONJG(H1) 18 | FFT2(J)=H2 19 | FFT2(N2-J)=CONJG(H2) 20 | 12 CONTINUE 21 | RETURN 22 | END 23 | -------------------------------------------------------------------------------- /src/games/cil/Makefile: -------------------------------------------------------------------------------- 1 | install: 2 | cp -r Makefile README cil.asd cil.lisp copyright \ 3 | $(DESTDIR)/usr/share/common-lisp/source/cil 4 | 5 | -------------------------------------------------------------------------------- /src/games/cil/cil.asd: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: lisp -*- 2 | 3 | (in-package :asdf) 4 | 5 | (defsystem :cil 6 | :components ((:file "cil"))) 7 | 8 | -------------------------------------------------------------------------------- /src/games/cil/copyright: -------------------------------------------------------------------------------- 1 | From sje@mv.mv.com Tue Apr 7 02:32:07 1998 2 | Date: Mon, 6 Apr 1998 21:23:44 -0400 (EDT) 3 | From: "Steven J. Edwards" 4 | To: s950045@uia.ua.ac.be, sje@mv.mv.com 5 | Subject: Re: Chess in Lisp. 6 | 7 | Hello. 8 | 9 | Sorry for the delay in reply. 10 | 11 | You are welcome to include my Chess In Lisp package in your distribution. 12 | 13 | I would like as many people as possible to see it and experiment with it. 14 | 15 | There are no restrictions, royalties, fess, etc.; my only request is 16 | that you retain my name in the source. 17 | 18 | -- Steven (sje@mv.mv.com) 19 | 20 | -------------------------------------------------------------------------------- /src/games/cil/debian/README.debian: -------------------------------------------------------------------------------- 1 | cil for DEBIAN 2 | ---------------------- 3 | 4 | This is mainly intended as an example. I'll try to program some 5 | useful stuff later... 6 | 7 | Peter Van Eynde , Sat, 25 Apr 1998 16:28:31 +0200 8 | 9 | This package is build using darcs-buildpackage and the darcs archives can be 10 | downloaded from http://people.debian.org/~pvaneynd/repository/ 11 | 12 | -------------------------------------------------------------------------------- /src/games/cil/debian/compat: -------------------------------------------------------------------------------- 1 | 4 2 | -------------------------------------------------------------------------------- /src/games/cil/debian/control: -------------------------------------------------------------------------------- 1 | Source: cl-cil 2 | Section: doc 3 | Priority: optional 4 | Build-Depends-Indep: debhelper 5 | Maintainer: Peter Van Eynde 6 | Standards-Version: 3.6.2.1 7 | 8 | Package: cl-cil 9 | Architecture: all 10 | Depends: common-lisp-controller (>= 3.45), cl-asdf 11 | Replaces: cil 12 | Conflicts: cil 13 | Description: Chess In Lisp. A chess library in Common Lisp 14 | This library is mainly intended as an example file. 15 | . 16 | Not much useful stuff can be done yet. 17 | -------------------------------------------------------------------------------- /src/games/cil/debian/copyright: -------------------------------------------------------------------------------- 1 | This package was debianized by Peter Van Eynde pvaneynd@debian.org on 2 | Sat, 25 Apr 1998 16:28:31 +0200. 3 | 4 | It was downloaded from ftp.mv.com 5 | 6 | Copyright: 7 | 8 | 9 | From sje@mv.mv.com Tue Apr 7 02:32:07 1998 10 | Date: Mon, 6 Apr 1998 21:23:44 -0400 (EDT) 11 | From: "Steven J. Edwards" 12 | To: s950045@uia.ua.ac.be, sje@mv.mv.com 13 | Subject: Re: Chess in Lisp. 14 | 15 | Hello. 16 | 17 | Sorry for the delay in reply. 18 | 19 | You are welcome to include my Chess In Lisp package in your distribution. 20 | 21 | I would like as many people as possible to see it and experiment with it. 22 | 23 | There are no restrictions, royalties, fess, etc.; my only request is 24 | that you retain my name in the source. 25 | 26 | -- Steven (sje@mv.mv.com) 27 | 28 | -------------------------------------------------------------------------------- /src/games/cil/debian/dirs: -------------------------------------------------------------------------------- 1 | /usr/share/common-lisp/systems/ 2 | /usr/share/common-lisp/source/cil 3 | -------------------------------------------------------------------------------- /src/games/cil/debian/examples: -------------------------------------------------------------------------------- 1 | cil.lisp 2 | -------------------------------------------------------------------------------- /src/games/cil/debian/links: -------------------------------------------------------------------------------- 1 | usr/share/common-lisp/source/cil/cil.asd usr/share/common-lisp/systems/cil.asd 2 | -------------------------------------------------------------------------------- /src/games/cil/debian/preinst: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | if [ -L /usr/share/common-lisp/source/cil ] ; then 4 | rm -f /usr/share/common-lisp/source/cil 2> /dev/null > /dev/null || true 5 | fi 6 | 7 | if [ -d /usr/share/common-lisp/repositories/cil ] ; then 8 | rm -f /usr/share/common-lisp/repositories/cil/* 2> /dev/null > /dev/null || true 9 | rmdir /usr/share/common-lisp/repositories/cil 2> /dev/null > /dev/null || true 10 | fi 11 | 12 | #DEBHELPER# 13 | 14 | -------------------------------------------------------------------------------- /src/gui/clue/README.pw: -------------------------------------------------------------------------------- 1 | pw: 2 | 3 | These original versions of these files came directly from ti.com Oct-96. 4 | 5 | I have make a number of changes in most directories. See README.pw 6 | in each for maybe more info. 7 | 8 | -------------------------------------------------------------------------------- /src/gui/clue/build.lisp: -------------------------------------------------------------------------------- 1 | (load "library:subsystems/clx-library.x86f") 2 | (load "library:subsystems/defsystem-library.x86f") 3 | 4 | (load "sysdef") 5 | 6 | (mk:oos 'clue :compile) 7 | (mk:oos 'clio :compile) 8 | (mk:oos 'pictures :compile) 9 | 10 | (load "target:tools/setup") 11 | (load "make-subsystems") 12 | (quit) 13 | -------------------------------------------------------------------------------- /src/gui/clue/clio-examples.system: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: LISP; Syntax: Common-Lisp; Package: User; Base: 10 -*- 2 | 3 | (in-package :common-lisp-user) 4 | 5 | (mk:defsystem clio-examples 6 | :depends-on ( clue clio ) 7 | :source-extension "lisp" 8 | :source-pathname 9 | #+common-lisp-controller "cl-library:clio;examples;" 10 | #-common-lisp-controller (translate-logical-pathname "clocc:src;gui;clue;clio;examples;") 11 | :components ("package" "cmd-frame" "sketchpad" "sketch")) 12 | -------------------------------------------------------------------------------- /src/gui/clue/clio/precom.lisp: -------------------------------------------------------------------------------- 1 | #+pcl 2 | (pcl::precompile-random-code-segments clio) 3 | -------------------------------------------------------------------------------- /src/gui/clue/clue/README.pw: -------------------------------------------------------------------------------- 1 | 7-Mar-97 2 | 3 | Changed defclass event to defstruct event to take advantage of 4 | PCL structure-class optimizations in defmethods, and thus 5 | let Python optimize access to the instance. This primarily for 6 | speed by not going through SLOT-VALUE. A few of the slots have 7 | a number :type so harware numeric ops can happen. 8 | 9 | Also changed allocate/deallocate event. Allocate event just 10 | uses standard defstruct constructor to init slots. Deallocate 11 | event (now a method for efficient with-slots use) now 12 | sets each slot to zero or nil before pushing onto the cache. 13 | This should help GC a bit since stale references can be gotten 14 | rid of quicker. 15 | 16 | A few compiler warnings cleaned up by declarations, or use 17 | of ecase when a number was expected. 18 | 19 | CLUE now sees :meta modifier from X86 keyboards. May also 20 | depend on XF86Config having magic translation enabled as well. 21 | -------------------------------------------------------------------------------- /src/gui/clue/clue/package.lisp: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode:Lisp; Package:CLUEI; Syntax:COMMON-LISP; Base:10; Lowercase:T -*- 2 | 3 | ;;; 4 | ;;; TEXAS INSTRUMENTS INCORPORATED 5 | ;;; P.O. BOX 149149 6 | ;;; AUSTIN, TEXAS 78714-9149 7 | ;;; 8 | ;;; Copyright (C)1987,1988,1989,1990 Texas Instruments Incorporated. 9 | ;;; 10 | ;;; Permission is granted to any individual or institution to use, copy, modify, 11 | ;;; and distribute this software, provided that this complete copyright and 12 | ;;; permission notice is maintained, intact, in all copies and supporting 13 | ;;; documentation. 14 | ;;; 15 | ;;; Texas Instruments Incorporated provides this software "as is" without 16 | ;;; express or implied warranty. 17 | ;;; 18 | 19 | (in-package "CLUEI") 20 | 21 | ;; Export symbols external to CLUEI from CLUE 22 | ;; This enables an application to use the CLUE package and get everything. 23 | (do-external-symbols (sym (find-package 'cluei)) 24 | (export sym 'clue)) -------------------------------------------------------------------------------- /src/gui/clue/clue/precom.lisp: -------------------------------------------------------------------------------- 1 | (in-package :common-lisp-user) 2 | 3 | #+pcl 4 | (pcl::precompile-random-code-segments clue) 5 | 6 | #+pcl 7 | (progn 8 | (pushnew 'compile pcl::*defclass-times*) 9 | (pushnew 'compile pcl::*defgeneric-times*)) 10 | 11 | ;; Ensure VALUES is a legal declaration 12 | #-cmu17 13 | (proclaim '(declaration values)) 14 | 15 | #+cmu17 ;; Don't warn about botched values decls 16 | (setf c:*suppress-values-declaration* t) 17 | 18 | #+pcl ;; This is now in current sources 19 | (pushnew 'values pcl::*non-variable-declarations*) 20 | 21 | ;; Ensure *features* knows about CLOS and PCL 22 | (when (find-package 'pcl) 23 | (pushnew :pcl *features*) 24 | (pushnew :clos *features*) 25 | (unless (find-package :clos) 26 | (rename-package :pcl :pcl '(:clos)))) 27 | 28 | ;; Ensure *features* knows about the Common Lisp Error Handler 29 | (when (find-package 'conditions) 30 | (pushnew :cleh *features*)) 31 | 32 | -------------------------------------------------------------------------------- /src/gui/clue/debian/README.debian: -------------------------------------------------------------------------------- 1 | clue for DEBIAN 2 | ---------------------- 3 | 4 | I can't recreate the documentation. 5 | 6 | Peter Van Eynde , Sat, 25 Apr 1998 09:57:36 +0200 7 | -------------------------------------------------------------------------------- /src/gui/clue/debian/control: -------------------------------------------------------------------------------- 1 | Source: cl-clue 2 | Section: libs 3 | Priority: optional 4 | Build-Depends-Indep: debhelper 5 | Maintainer: Peter Van Eynde 6 | Standards-Version: 3.6.1.0 7 | 8 | Package: cl-clue 9 | Architecture: all 10 | Depends: common-lisp-controller (>= 3.45), cmucl-source 11 | Replaces: clio, pictures, clue 12 | Description: Lisp package for clue/clio/pictures: X interfaces for lisp 13 | Clue is to lisp what xlib is to C. It's basic, but 14 | close to the metal. 15 | . 16 | Clio is to Lisp what Xt is to C. 17 | It uses CLOS to give an OO interface to X. 18 | . 19 | Pictures is an imaging-system for clue. 20 | It lets people use constraints and such to draw pictures. 21 | 22 | Package: clue 23 | Architecture: all 24 | Depends: cl-clue 25 | Description: Package to ease upgrading, delete me 26 | The clue package is now called cl-clue. Please 27 | remove me. 28 | -------------------------------------------------------------------------------- /src/gui/clue/debian/copyright: -------------------------------------------------------------------------------- 1 | This package was debianized by Peter Van Eynde pvaneynd@debian.org on Sun, 19 Apr 1998 19:57:46 +0200. 2 | 3 | Copyright: 4 | 5 | ;;; 6 | ;;; TEXAS INSTRUMENTS INCORPORATED 7 | ;;; P.O. BOX 149149 8 | ;;; AUSTIN, TEXAS 78714-9149 9 | ;;; 10 | ;;; Copyright (C)1988,1989,1990 Texas Instruments Incorporated. 11 | ;;; 12 | ;;; Permission is granted to any individual or institution to use, copy, 13 | modify, 14 | ;;; and distribute this software, provided that this complete copyright and 15 | ;;; permission notice is maintained, intact, in all copies and supporting 16 | ;;; documentation. 17 | ;;; 18 | ;;; Texas Instruments Incorporated provides this software "as is" without 19 | ;;; express or implied warranty. 20 | ;;; 21 | 22 | 23 | -------------------------------------------------------------------------------- /src/gui/clue/debian/dirs: -------------------------------------------------------------------------------- 1 | /usr/share/common-lisp/systems 2 | /usr/share/common-lisp/source/clue 3 | /usr/share/common-lisp/source/clio 4 | /usr/share/common-lisp/source/pictures 5 | -------------------------------------------------------------------------------- /src/gui/clue/debian/docs: -------------------------------------------------------------------------------- 1 | clue/doc/clue.ps 2 | clue/doc/turbo-clue.ps 3 | clio/doc/clio.ps 4 | debian/changelog 5 | pictures/doc/pictures.ps 6 | -------------------------------------------------------------------------------- /src/gui/clue/debian/examples: -------------------------------------------------------------------------------- 1 | clue/examples/menu.lisp 2 | clio/examples/cmd-frame.lisp 3 | clio/examples/defsystem.lisp 4 | clio/examples/package.lisp 5 | clio/examples/sketch.lisp 6 | clio/examples/sketchpad.lisp 7 | pictures/examples/road-demo.lisp 8 | pictures/examples/road-demo.lisp.CKP 9 | -------------------------------------------------------------------------------- /src/gui/clue/debian/links: -------------------------------------------------------------------------------- 1 | usr/share/common-lisp/source/clue/clue.asd usr/share/common-lisp/systems/clue.asd 2 | usr/share/common-lisp/source/clio/clio.asd usr/share/common-lisp/systems/clio.asd 3 | usr/share/common-lisp/source/pictures/pictures.asd usr/share/common-lisp/systems/pictures.asd 4 | -------------------------------------------------------------------------------- /src/gui/clue/pictures/doc/pictures.text: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/blindglobe/clocc/a50bb75edb01039b282cf320e4505122a59c59a7/src/gui/clue/pictures/doc/pictures.text -------------------------------------------------------------------------------- /src/gui/clue/pictures/header.lisp: -------------------------------------------------------------------------------- 1 | ;;;-*- Mode:Common-Lisp; Package:PICTURES; Base:10 -*- 2 | ;;; 3 | ;;; 4 | ;;; 5 | ;;; TEXAS INSTRUMENTS INCORPORATED 6 | ;;; P.O. BOX 149149 7 | ;;; AUSTIN, TEXAS 78714-9149 8 | ;;; 9 | ;;; Copyright (C)1987,1988,1989,1990 Texas Instruments Incorporated. 10 | ;;; 11 | ;;; Permission is granted to any individual or institution to use, copy, modify, 12 | ;;; and distribute this software, provided that this complete copyright and 13 | ;;; permission notice is maintained, intact, in all copies and supporting 14 | ;;; documentation. 15 | ;;; 16 | ;;; Texas Instruments Incorporated provides this software "as is" without 17 | ;;; express or implied warranty. 18 | ;;; 19 | ;;; Authors: Delmar Hager, James Dutton, Teri Crowe 20 | ;;; Contributors: Kerry Kimbrough, Patrick Hogan, Eric Mielke 21 | 22 | (in-package "PICTURES") 23 | -------------------------------------------------------------------------------- /src/gui/clue/pictures/precom.lisp: -------------------------------------------------------------------------------- 1 | #+pcl 2 | (pcl::precompile-random-code-segments pictures) 3 | -------------------------------------------------------------------------------- /src/gui/clx/CHANGELOG: -------------------------------------------------------------------------------- 1 | PVE 23-JUL-2002: 2 | * patches from Iban Hatchondo for clx and requests 3 | * OpenMCL patches from John Wiseman 4 | -------------------------------------------------------------------------------- /src/gui/clx/Makefile: -------------------------------------------------------------------------------- 1 | FILES=attributes.lisp clx.lisp debug display.lisp gcontext.lisp keysyms.lisp manager.lisp test \ 2 | buffer.lisp clx.system demo doc.lisp graphics.lisp macros.lisp package.lisp text.lisp \ 3 | bufmac.lisp CVS depdefs.lisp docs image.lisp requests.lisp translate.lisp \ 4 | cl-clx.system dependent.lisp fonts.lisp input.lisp resource.lisp 5 | 6 | install: 7 | install --owner=root --group=root --mode=644 cl-clx.system $(DESTDIR)/usr/share/common-lisp/systems/ 8 | cp -r $(FILES) $(DESTDIR)/usr/share/common-lisp/repositories/cl-clx/ 9 | 10 | -------------------------------------------------------------------------------- /src/gui/clx/RELEASE-NOTES: -------------------------------------------------------------------------------- 1 | This is the second release. Major changes include the addition of the 2 | clxman-sources from Gilbert Baumann and the removal of the clocc-port 3 | dependency. 4 | 5 | Old notes: 6 | 7 | This is a 'get it out of the door' release. The subsystems included have patches 8 | that still have to be integrated with upstream. 9 | 10 | Expect a more polished release soon. But in the mean time I would appriciate 11 | bugreports on this release. If you do encounter problems, please recompile 12 | with debug 3 and send a traceback. 13 | 14 | -------------------------------------------------------------------------------- /src/gui/clx/clx-vm/clx-vm.asd: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: Lisp; Package: ASDF; Base: 10; Syntax: Common-Lisp -*- 2 | 3 | (in-package :asdf) 4 | 5 | (defsystem :clx-vm 6 | :components 7 | ((:file "package") 8 | (:file "threading" :depends-on ("package")))) 9 | -------------------------------------------------------------------------------- /src/gui/clx/clx-vm/comm-ext/LICENSE.txt: -------------------------------------------------------------------------------- 1 | uk.org.bew.comm-ext, an extension to the network interface for LispWorks/Linux 2 | 3 | uk.org.bew.comm-ext is licensed under the terms of the Lisp Lesser GNU 4 | Public License (http://opensource.franz.com/preamble.html), known as 5 | the LLGPL. The LLGPL consists of a preamble (see above URL) and the 6 | LGPL. Where these conflict, the preamble takes precedence. 7 | uk.org.bew.comm-ext is referenced in the preamble as the "LIBRARY." 8 | -------------------------------------------------------------------------------- /src/gui/clx/clx-vm/comm-ext/Makefile: -------------------------------------------------------------------------------- 1 | CFLAGS = -c -Wall -fPIC 2 | INSTALL= 3 | OBJS = comm_ext.o 4 | 5 | liblwcomm-ext.so : $(OBJS) 6 | ${CC} -o $@ $(OBJS) -shared -Xlinker -soname -Xlinker $@ 7 | 8 | clean : 9 | rm -f ${OBJS} liblwcomm-ext.so 10 | 11 | install : liblwcomm-ext.so 12 | cp liblwcomm-ext.so $(INSTALL)/liblwcomm-ext.so 13 | 14 | -------------------------------------------------------------------------------- /src/gui/clx/clx-vm/comm-ext/defsys.lisp: -------------------------------------------------------------------------------- 1 | ;;; This software is Copyright (c) Barry Wilkes 2001 2 | ;;; Barry Wilkes grants you the rights to distribute 3 | ;;; and use this software as governed by the terms 4 | ;;; of the Lisp Lesser GNU Public License 5 | ;;; (http://opensource.franz.com/preamble.html), 6 | ;;; known as the LLGPL. 7 | 8 | (defsystem comm-ext () 9 | :members ("package" 10 | "comm-ext") 11 | :rules ((:in-order-to :compile :all 12 | (:requires (:load :previous))))) -------------------------------------------------------------------------------- /src/gui/clx/clx-vm/comm-ext/package.lisp: -------------------------------------------------------------------------------- 1 | ;;; This software is Copyright (c) Barry Wilkes 2001 2 | ;;; Barry Wilkes grants you the rights to distribute 3 | ;;; and use this software as governed by the terms 4 | ;;; of the Lisp Lesser GNU Public License 5 | ;;; (http://opensource.franz.com/preamble.html), 6 | ;;; known as the LLGPL. 7 | 8 | (defpackage uk.org.bew.comm-ext 9 | (:use common-lisp) 10 | (:export 11 | open-unix-stream)) 12 | -------------------------------------------------------------------------------- /src/gui/clx/clx.system: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: Lisp; Package: USER; Base: 10; Syntax: Common-Lisp -*- 2 | 3 | (in-package "COMMON-LISP-USER") 4 | 5 | (pushnew :clx-debugging *features*) 6 | 7 | (mk:defsystem :clx 8 | :source-pathname "cl-library:clx;" 9 | :depends-on (:clocc-port :split-sequence) 10 | :source-extension "lisp" 11 | :components 12 | (:serial 13 | "package" 14 | "depdefs" 15 | "clx" 16 | "dependent" 17 | "macros" ; these are just macros 18 | "bufmac" ; these are just macros 19 | "buffer" 20 | "display" 21 | "gcontext" 22 | "input" 23 | "requests" 24 | "fonts" 25 | "graphics" 26 | "text" 27 | "attributes" 28 | "translate" 29 | "keysyms" 30 | "manager" 31 | "image" 32 | "resource")) 33 | -------------------------------------------------------------------------------- /src/gui/clx/docs/MAKEDIST: -------------------------------------------------------------------------------- 1 | #! /bin/sh 2 | 3 | dir="clxman-source-$(date --iso)" 4 | 5 | mkdir $dir 6 | mkdir $dir/source 7 | mkdir $dir/docIndex 8 | mkdir $dir/clxman 9 | mkdir $dir/clxman/docIndex 10 | 11 | cp -p README run.lisp dtd.lisp clex.lisp lalr.lisp sgml-lex.lisp sgml-parse.lisp sgml-unparse.lisp clxman.lisp MAKEDIST $dir 12 | cp -p source/clxman.{sgml,dtd,css} $dir/source 13 | cp -p docIndex/DocIndexApplet.java docIndex/Index.java docIndex/XlibIndex.java $dir/docIndex 14 | 15 | tar zcvf $dir.tar.gz $dir 16 | 17 | rm -rf $dir 18 | -------------------------------------------------------------------------------- /src/gui/clx/docs/Makefile: -------------------------------------------------------------------------------- 1 | all: 2 | mkdir clxman/docIndex/ || true 3 | lisp -noinit -load run.lisp -eval '(progn (run) (quit))' 4 | 5 | clean: 6 | rm -f clxman/*.html *.x86f mrindex clxman/clxman.css 2> /dev/null || true 7 | -------------------------------------------------------------------------------- /src/gui/clx/docs/clxman.lisp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/blindglobe/clocc/a50bb75edb01039b282cf320e4505122a59c59a7/src/gui/clx/docs/clxman.lisp -------------------------------------------------------------------------------- /src/gui/clx/docs/run.lisp: -------------------------------------------------------------------------------- 1 | (proclaim '(optimize (safety 2) (space 1) (speed 1) (debug 2))) 2 | (defconstant *base-char* 'character) 3 | 4 | #+CLISP 5 | (setf *default-file-encoding* (make-encoding :charset charset:iso-8859-1)) 6 | 7 | (mapcar #'(lambda (x) 8 | (load (compile-file (truename x)))) 9 | '("clex.lisp" 10 | "lalr.lisp" 11 | "dtd.lisp" 12 | "sgml-lex.lisp" 13 | "sgml-parse.lisp" 14 | "sgml-unparse.lisp" 15 | "clxman.lisp" 16 | )) 17 | 18 | (format T "~&;; Now call (RUN) to generate the manual.~%") 19 | 20 | ; (run) 21 | 22 | -------------------------------------------------------------------------------- /src/gui/clx/docs/source/clxman.sgml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/blindglobe/clocc/a50bb75edb01039b282cf320e4505122a59c59a7/src/gui/clx/docs/source/clxman.sgml -------------------------------------------------------------------------------- /src/onlisp/package.lisp: -------------------------------------------------------------------------------- 1 | ;;; -*- Lisp -*- 2 | 3 | (in-package :user) 4 | 5 | (defpackage :paul-graham 6 | (:nicknames :pg) 7 | (:use :common-lisp)) 8 | 9 | -------------------------------------------------------------------------------- /src/port/.cvsignore: -------------------------------------------------------------------------------- 1 | ChangeLog 2 | port.list 3 | -------------------------------------------------------------------------------- /src/port/Makefile: -------------------------------------------------------------------------------- 1 | TOP := $(shell cd ../..; pwd) 2 | LISPEXT := lisp 3 | SOURCES := ext gray net sys shell proc path mop 4 | SYSTEM := port 5 | DOCFILES = $(SYSTEM).html 6 | ZIPEXTRA = $(TOP)/etc/GNU-LGPL 7 | include $(TOP)/clocc.mk 8 | -------------------------------------------------------------------------------- /src/port/configuration/README: -------------------------------------------------------------------------------- 1 | CL.EXT.CONFIGURATION 0.1 2 | 3 | This package contains a set of definitions whose intent is to 4 | facilitate the management of a system configuration, w.r.t. those 5 | parameters which somewhat fall outside a DEFSYSTEM tool 6 | jurisdiction. In particular the DEFCONFIGURATION utility can be used 7 | to set up in a relatively platform independent way a set of logical 8 | pathname translations that can be used by the DEFSYTEM tool. 9 | 10 | Please see the files INSTALLATION and COPYRIGHT for more information, 11 | and refer to the documentation for a detailed description of the 12 | CONF:DEFCONFIGURATION utility and the companion CONF:SETUP generic 13 | function. 14 | 15 | The package is currently released under the LGPL and all the files 16 | should be considered to include such Copyright notice. 17 | 18 | 2000-02-26 Marco Antoniotti 19 | -------------------------------------------------------------------------------- /src/port/configuration/defconf.conf: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: Lisp -*- 2 | 3 | ;;; defconf.conf -- 4 | ;;; I'm putting my money where my mouth is.... 5 | 6 | ;;; Copyright (c) 2000 Marco Antoniotti, all rights reserved. 7 | ;;; This software is released under the terms of the GNU Lesser General 8 | ;;; Public License (LGPL, see file COPYING for details). 9 | 10 | (conf:defconfiguration cl.ext.configuration () 11 | (:logical-pathname-host "CONF") ; Logical pathnames cannot 12 | ; contain non alpahnumeric 13 | ; characters (the '.' is a no-no). 14 | (:finally 15 | (conf:configure-format t "you succeded in configuring this utility.") 16 | (conf:configure-format t "just have a look at the logical translations ~ 17 | for \"CONF\"~%~@ 18 | ~8T~S~2%" 19 | (logical-pathname-translations "CONF")))) 20 | 21 | ;;; end of file -- defconf.conf -- 22 | -------------------------------------------------------------------------------- /src/port/configuration/impl-dependent/allegro.lisp: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: CLtL -*- 2 | 3 | ;;; allegro.lisp -- 4 | ;;; Franz Inc. implementation dependencies. 5 | 6 | ;;; Copyright (c) 2000 Marco Antoniotti, all rights reserved. 7 | ;;; This software is released under the terms of the GNU Lesser General 8 | ;;; Public License (LGPL, see file COPYING for details). 9 | 10 | (in-package "CL.EXT.CONFIGURATION") 11 | 12 | ;;; Directory utilities 13 | 14 | (defmethod current-directory-namestring ((cl-implementation cl.env:allegro)) 15 | (namestring (excl:current-directory))) 16 | 17 | 18 | ;;; DEFSYSTEM utilities 19 | 20 | (defmethod find-system ((sys symbol) 21 | (cl cl.env:allegro) 22 | (defsys-tag (eql :allegro))) 23 | (apply #'excl:find-system sys nil)) 24 | 25 | (defmethod load-system ((sys symbol) 26 | (cl cl.env:allegro) 27 | (defsys-tag (eql :allegro)) 28 | &rest keys) 29 | (apply #'excl:load-system sys keys)) 30 | 31 | 32 | ;;; end of file -- allegro.lisp -- 33 | -------------------------------------------------------------------------------- /src/port/configuration/impl-dependent/clisp.lisp: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: CLtL -*- 2 | 3 | ;;; clisp.lisp -- 4 | ;;; Haible's CLisp implementation dependencies. 5 | 6 | ;;; Copyright (c) 2000 Marco Antoniotti, all rights reserved. 7 | ;;; This software is released under the terms of the GNU Lesser General 8 | ;;; Public License (LGPL, see file COPYING for details). 9 | 10 | (in-package "CL.EXT.CONFIGURATION") 11 | 12 | (defmethod current-directory-namestring ((cl-implementation cl.env:clisp)) 13 | (namestring (cwd))) 14 | 15 | ;;; DEFSYSTEM utilities 16 | 17 | ;;; Nothing define for CLisp, which relies on third parties DEFSYSTEMs. 18 | 19 | ;;; end of file -- unix.lisp -- 20 | -------------------------------------------------------------------------------- /src/port/configuration/impl-dependent/cmucl.lisp: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: CLtL -*- 2 | 3 | ;;; cmucl.lisp -- 4 | ;;; CMUCL implementation dependencies. 5 | 6 | ;;; Copyright (c) 2000 Marco Antoniotti, all rights reserved. 7 | ;;; This software is released under the terms of the GNU Lesser General 8 | ;;; Public License (LGPL, see file COPYING for details). 9 | 10 | (in-package "CL.EXT.CONFIGURATION") 11 | 12 | ;;; Directory utilities 13 | 14 | (defmethod current-directory-namestring ((cl-implementation cl.env:cmucl)) 15 | (namestring (ext:default-directory))) 16 | 17 | 18 | ;;; DEFSYSTEM utilities 19 | 20 | ;;; Nothing define for CMUCL, which relies on third parties DEFSYSTEMs. 21 | 22 | ;;; end of file -- cmucl.lisp -- 23 | -------------------------------------------------------------------------------- /src/port/configuration/impl-dependent/genera.lisp: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: CLtL -*- 2 | 3 | ;;; genera.lisp -- 4 | ;;; Genera implementation dependencies. 5 | 6 | ;;; Copyright (c) 2000 Marco Antoniotti, all rights reserved. 7 | ;;; This software is released under the terms of the GNU Lesser General 8 | ;;; Public License (LGPL, see file COPYING for details). 9 | 10 | (in-package "CL.EXT.CONFIGURATION") 11 | 12 | (defmethod wild-inferior-directories ((os cl.env:genera)) "**>") 13 | 14 | ;;; end of file -- unix.lisp -- 15 | -------------------------------------------------------------------------------- /src/port/configuration/impl-dependent/mac-os.lisp: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: CLtL -*- 2 | 3 | ;;; mac-os.lisp -- 4 | ;;; Mac OS implementation dependencies. 5 | 6 | ;;; Copyright (c) 2000 Marco Antoniotti, all rights reserved. 7 | ;;; This software is released under the terms of the GNU Lesser General 8 | ;;; Public License (LGPL, see file COPYING for details). 9 | 10 | (in-package "CL.EXT.CONFIGURATION") 11 | 12 | (defmethod wild-inferior-directories ((os cl.env:macos)) "**:") 13 | 14 | ;;; end of file -- unix.lisp -- 15 | -------------------------------------------------------------------------------- /src/port/configuration/impl-dependent/ms-dos.lisp: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: CLtL -*- 2 | 3 | ;;; ms-dos.lisp -- 4 | ;;; MS-DOS dependencies. 5 | 6 | ;;; Copyright (c) 2000 Marco Antoniotti, all rights reserved. 7 | ;;; This software is released under the terms of the GNU Lesser General 8 | ;;; Public License (LGPL, see file COPYING for details). 9 | 10 | (in-package "CL.EXT.CONFIGURATION") 11 | 12 | (defmethod wild-inferior-directories ((os cl.env:ms-dos)) "**\\") 13 | 14 | ;;; end of file -- unix.lisp -- 15 | -------------------------------------------------------------------------------- /src/port/configuration/impl-dependent/unix.lisp: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: CLtL -*- 2 | 3 | ;;; unix.lisp -- 4 | ;;; Un*x dependencies. 5 | 6 | ;;; Copyright (c) 2000 Marco Antoniotti, all rights reserved. 7 | ;;; This software is released under the terms of the GNU Lesser General 8 | ;;; Public License (LGPL, see file COPYING for details). 9 | 10 | (in-package "CL.EXT.CONFIGURATION") 11 | 12 | (defmethod wild-inferior-directories ((os cl.env:unix)) "**/") 13 | 14 | ;;; end of file -- unix.lisp -- 15 | -------------------------------------------------------------------------------- /src/port/configuration/impl-dependent/windows.lisp: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: CLtL -*- 2 | 3 | ;;; windows.lisp -- 4 | ;;; MS Windows dependencies. 5 | 6 | ;;; Copyright (c) 2000 Marco Antoniotti, all rights reserved. 7 | ;;; This software is released under the terms of the GNU Lesser General 8 | ;;; Public License (LGPL, see file COPYING for details). 9 | 10 | (in-package "CL.EXT.CONFIGURATION") 11 | 12 | (defmethod wild-inferior-directories ((os cl.env:ms-windows)) "**\\") 13 | 14 | ;;; end of file -- windows.lisp -- 15 | -------------------------------------------------------------------------------- /src/port/environment/feature-tagged-type-class.lisp: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: Lisp -*- 2 | 3 | ;;; feature-tagged-type-class.lisp -- 4 | ;;; A `mixin' class providing a single TAG slot. 5 | ;;; 6 | ;;; Copyright (c) 2000-2005 Marco Antoniotti, all rights reserved. 7 | ;;; This software is released under the terms of the GNU Lesser General 8 | ;;; Public License (LGPL, see file COPYRIGHT for details). 9 | 10 | (in-package "CL.ENVIRONMENT") 11 | 12 | (defclass feature-tagged-type-class () 13 | ((tag :reader feature-tag 14 | :initarg :feature-tag 15 | :type symbol) 16 | ) 17 | (:documentation "The CL.ENVIRONMENT Feature Tag Classes.")) 18 | 19 | 20 | ;;; end of file -- feature-tagged-type-class.lisp -- 21 | -------------------------------------------------------------------------------- /src/port/environment/impl-dependent/cmucl.lisp: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: Lisp -*- 2 | 3 | ;;; cmucl.lisp -- 4 | ;;; CMUCL implementation dependencies. 5 | 6 | ;;; Copyright (c) 2000-2005 Marco Antoniotti, all rights reserved. 7 | ;;; This software is released under the terms of the GNU Lesser General 8 | ;;; Public License (LGPL, see file COPYING for details). 9 | 10 | (in-package "CL.ENV") 11 | 12 | ;;; Directory utilities 13 | 14 | (defmethod current-directory-pathname ((cl-implementation cl.env:cmucl)) 15 | (pathname (ext:default-directory))) 16 | 17 | 18 | (defmethod change-current-working-directory ((cl-implementation cl.env:cmucl) 19 | (new-dir string)) 20 | (change-current-working-directory cl-implementation 21 | (parse-namestring new-dir))) 22 | 23 | 24 | (defmethod change-current-working-directory ((cl-implementation cl.env:cmucl) 25 | (new-dir pathname)) 26 | (pathname (setf (ext:default-directory) new-dir))) 27 | 28 | ;;; end of file -- cmucl.lisp -- 29 | -------------------------------------------------------------------------------- /src/port/environment/impl-dependent/corman.lisp: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: CLtL -*- 2 | 3 | ;;; corman.lisp -- 4 | ;;; Corman Lisp implementation dependencies. 5 | 6 | ;;; Copyright (c) 2000-2005 Marco Antoniotti, all rights reserved. 7 | ;;; This software is released under the terms of the GNU Lesser General 8 | ;;; Public License (LGPL, see file COPYING for details). 9 | 10 | (in-package "CL.ENV") 11 | 12 | ;;; Directory utilities 13 | 14 | (defmethod current-directory-pathname ((cl-implementation cl.env:corman)) 15 | (pathname (cormanlisp:get-current-directory))) 16 | 17 | ;;; end of file -- corman.lisp -- 18 | -------------------------------------------------------------------------------- /src/port/environment/impl-dependent/lcl.lisp: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: Lisp -*- 2 | 3 | ;;; lcl.lisp -- 4 | ;;; Liquid (nee Lucid) implementation dependencies. 5 | 6 | ;;; Copyright (c) 2000-2005 Marco Antoniotti, all rights reserved. 7 | ;;; This software is released under the terms of the GNU Lesser General 8 | ;;; Public License (LGPL, see file COPYING for details). 9 | 10 | (in-package "CL.ENV") 11 | 12 | ;;; Directory utilities 13 | ;;; Cfr. LCL 5.0 manual at 14 | ;;; http://www.lispworks.com/reference/documentation.html 15 | 16 | (defmethod current-directory-pathname ((cl-implementation cl.env:lucid)) 17 | (pathname (lcl:working-directory))) 18 | 19 | 20 | (defmethod change-current-directory ((cl-implementation cl.env:lucid) 21 | (new-dir string)) 22 | (setf (lcl:working-directory) new-dir)) 23 | 24 | 25 | (defmethod change-current-directory ((cl-implementation cl.env:lucid) 26 | (new-dir pathname)) 27 | (setf (lcl:working-directory) new-dir)) 28 | 29 | 30 | ;;; end of file -- lcl.lisp -- 31 | -------------------------------------------------------------------------------- /src/port/environment/impl-dependent/sbcl.lisp: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: Lisp -*- 2 | 3 | ;;; sbcl.lisp -- 4 | ;;; SBCL implementation dependencies. 5 | 6 | ;;; Copyright (c) 2000-2005 Marco Antoniotti, all rights reserved. 7 | ;;; This software is released under the terms of the GNU Lesser General 8 | ;;; Public License (LGPL, see file COPYING for details). 9 | 10 | (in-package "CL.ENV") 11 | 12 | ;;; Directory utilities 13 | 14 | (defmethod current-directory-pathname ((cl-implementation cl.env:sbcl)) 15 | (pathname (ext:default-directory))) 16 | 17 | 18 | (defmethod change-current-directory ((cl-implementation cl.env:sbcl) 19 | (new-dir string)) 20 | (change-current-directory cl-implementation 21 | (parse-namestring new-dir))) 22 | 23 | 24 | (defmethod change-current-directory ((cl-implementation cl.env:sbcl) 25 | (new-dir pathname)) 26 | (pathname (setf (ext:default-directory) new-dir))) 27 | 28 | 29 | ;;; end of file -- sbcl.lisp -- 30 | -------------------------------------------------------------------------------- /src/port/port.system: -------------------------------------------------------------------------------- 1 | ;;; -*- Lisp -*- 2 | ;;; 3 | ;;; Cross-implementation Portability System 4 | ;;; 5 | ;;; $Id: port.system,v 1.10 2006/11/28 05:02:42 sds Exp $ 6 | ;;; $Source: /cvsroot/clocc/clocc/src/port/port.system,v $ 7 | 8 | (mk:defsystem port 9 | :source-pathname (translate-logical-pathname "clocc:src;port;") 10 | :source-extension "lisp" 11 | :components 12 | ((:file "ext") 13 | (:file "gray" :depends-on ("ext")) 14 | (:file "mop" :depends-on ("ext")) 15 | (:file "net" :depends-on ("ext" "sys")) 16 | (:file "path" :depends-on ("ext")) 17 | (:file "proc" :depends-on ("ext")) 18 | (:file "shell" :depends-on ("ext")) 19 | (:file "sys" :depends-on ("ext" "path"))) 20 | :initially-do 21 | (progn (mk:system-source-size :port :all) 22 | (mk:system-source-size :port :new-source-and-dependents))) 23 | -------------------------------------------------------------------------------- /src/screamer/Makefile: -------------------------------------------------------------------------------- 1 | ## makefile for screamer 2 | # $Id: Makefile,v 1.2 2003/04/16 15:08:13 sds Exp $ 3 | # $Source: /cvsroot/clocc/clocc/src/screamer/Makefile,v $ 4 | 5 | TOP := $(shell cd ../..; pwd) 6 | LISPEXT := lisp 7 | SOURCES := equations iterate primordial screamer screams 8 | SYSTEM := screamer 9 | include $(TOP)/clocc.mk 10 | 11 | screamer.$(FASLEXT): screamer.$(LISPEXT) 12 | 13 | iterate.$(FASLEXT): iterate.$(LISPEXT) 14 | 15 | primordial.$(FASLEXT): primordial.$(LISPEXT) \ 16 | iterate.$(FASLEXT) screamer.$(FASLEXT) 17 | 18 | screams.$(FASLEXT): screams.$(LISPEXT) \ 19 | iterate.$(FASLEXT) screamer.$(FASLEXT) 20 | 21 | equations.$(FASLEXT): equations.$(LISPEXT) \ 22 | iterate.$(FASLEXT) screamer.$(FASLEXT) 23 | 24 | check: screamer.$(FASLEXT) iterate.$(FASLEXT) primordial.$(FASLEXT) 25 | $(TOP)/bin/run-lisp $(patsubst %,-i %,$^) \ 26 | -x '(print (funcall (intern "PRIME-ORDEAL" "PRIMORDIAL")))' 27 | -------------------------------------------------------------------------------- /src/screamer/doc/aaai93.dvi: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/blindglobe/clocc/a50bb75edb01039b282cf320e4505122a59c59a7/src/screamer/doc/aaai93.dvi -------------------------------------------------------------------------------- /src/screamer/doc/ircs-93-03.dvi: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/blindglobe/clocc/a50bb75edb01039b282cf320e4505122a59c59a7/src/screamer/doc/ircs-93-03.dvi -------------------------------------------------------------------------------- /src/screamer/doc/screamer.dvi: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/blindglobe/clocc/a50bb75edb01039b282cf320e4505122a59c59a7/src/screamer/doc/screamer.dvi -------------------------------------------------------------------------------- /src/tools/ansi-test/.cvsignore: -------------------------------------------------------------------------------- 1 | clisp 2 | normal 3 | safe 4 | sbcl 5 | *-ERROR-IDS 6 | -------------------------------------------------------------------------------- /src/tools/ansi-test/backquot.lisp: -------------------------------------------------------------------------------- 1 | ;;; Based on 1.2 -*- mode: lisp -*- 2 | ;;; tests for backquote 3 | (in-package :cl-user) 4 | 5 | (check-for-bug :backquot-legacy-5 6 | (setf x (list 'a 'b 'c)) 7 | (a b c)) 8 | 9 | (check-for-bug :backquot-legacy-9 10 | `(x ,x ,@x foo ,(cadr x) bar ,(cdr x) baz ,@(cdr x) ,. x) 11 | (X (A B C) A B C FOO B BAR (B C) BAZ B C A B C)) 12 | 13 | (check-for-bug :backquot-legacy-13 14 | (read-from-string "`,@x") 15 | ERROR) 16 | 17 | (check-for-bug :backquot-legacy-17 18 | `(,x . ,x) ; = (append (list x) x) 19 | ((a b c) a b c)) 20 | 21 | 22 | (check-for-bug :backquot-legacy-22 23 | (read-from-string "`(,x . ,@x)") 24 | ERROR) 25 | 26 | 27 | (check-for-bug :backquot-legacy-27 28 | (read-from-string ",x") 29 | ERROR) 30 | 31 | (check-for-bug :backquot-legacy-31 32 | `#(1 2 3 4) 33 | #(1 2 3 4)) 34 | 35 | (check-for-bug :backquot-expansion-into-vector 36 | (let ((x (list 'a 'b 'c))) 37 | `#(,@x)) 38 | #(a b c)) 39 | -------------------------------------------------------------------------------- /src/tools/ansi-test/clisp-known-errors: -------------------------------------------------------------------------------- 1 | MACHINE-VERSION: I686 2 | MACHINE-TYPE: I686 3 | MACHINE-INSTANCE: localhost [127.0.0.1] 4 | LISP-IMPLEMENTATION-VERSION: 2.27.2 (released 2001-10-05) (built 3217798361) (memory 3217799077) 5 | LISP-IMPLEMENTATION-TYPE: CLISP 6 | SOFTWARE-TYPE: ANSI C program 7 | SOFTWARE-VERSION: GNU C 2.95.4 20011006 (Debian prerelease) 8 | :CMUCL-BUGS-LEGACY-308 9 | :SECTION12-LEGACY-607 10 | :SECTION3-LEGACY-107 11 | :SYMBOLTEST-LEGACY-491 12 | -------------------------------------------------------------------------------- /src/tools/ansi-test/compile-bug3.lisp: -------------------------------------------------------------------------------- 1 | (in-package :cl-user) 2 | 3 | ;;; From: "Fernando D. Mato Mira" 4 | 5 | (defun prolog-length (p) 6 | (let ((x (length (car p)))) 7 | (reduce #'(lambda (v1 v2) 8 | (declare (ignore v1)) 9 | (setq x (+ x (length v2)))) 10 | p))) 11 | 12 | -------------------------------------------------------------------------------- /src/tools/ansi-test/compile-bug5.lisp: -------------------------------------------------------------------------------- 1 | (in-package :cl-user) 2 | 3 | (defun tickle-bug () 4 | (labels ((fun1 () 5 | (fun2)) 6 | (fun2 () 7 | (when nil 8 | (tagbody 9 | tag 10 | (fun2) 11 | (go tag))) 12 | (when nil 13 | (tagbody 14 | tag 15 | (fun1) 16 | (go tag))))) 17 | 18 | (fun1) 19 | nil)) 20 | 21 | -------------------------------------------------------------------------------- /src/tools/ansi-test/compile-bug6.lisp: -------------------------------------------------------------------------------- 1 | (in-package :cl-user) 2 | 3 | (defclass super1 () ()) 4 | 5 | (defclass sub1 (super1)()) 6 | 7 | (defun fooey () 8 | (make-instance 'sub1)) 9 | 10 | -------------------------------------------------------------------------------- /src/tools/ansi-test/lists153.lisp: -------------------------------------------------------------------------------- 1 | ;;; based on v1.1.1.1 -*- mode: lisp -*- 2 | (in-package :cl-user) 3 | ;; RPLACA 4 | ;; RPLACD 5 | 6 | -------------------------------------------------------------------------------- /src/tools/ansi-test/make-load-form-demo.lisp: -------------------------------------------------------------------------------- 1 | (in-package "CL-USER") 2 | (defparameter *t-list* '#.*t-list*) 3 | -------------------------------------------------------------------------------- /src/tools/ansi-test/new-bugs.lisp: -------------------------------------------------------------------------------- 1 | ;;; -*- mode: lisp -*- 2 | (proclaim '(special log)) 3 | (in-package :cl-user) 4 | 5 | 6 | ;; From: Gary Bunting 7 | 8 | (check-for-bug :new-bugs-legacy-8 9 | (setf xx (expt 3 32)) 10 | 1853020188851841) 11 | 12 | (check-for-bug :new-bugs-legacy-12 13 | (* xx xx) 14 | 3433683820292512484657849089281) 15 | 16 | ;; paul 17 | 18 | (check-for-bug :new-bugs-legacy-18 19 | (defun bugged (x) 20 | (labels ((f (y &optional trouble) ; <<< or &key or &rest .. 21 | (if y 22 | (let ((a (pop y))) 23 | (f a))))))) 24 | BUGGED) 25 | 26 | (check-for-bug :new-bugs-legacy-26 27 | (defun tst () 28 | (labels 29 | ((eff (&key trouble) 30 | (eff) 31 | )) 32 | ;;(eff :trouble nil) ;<< this works 33 | (eff);; << this causes assert failure 34 | )) 35 | tst) 36 | 37 | 38 | -------------------------------------------------------------------------------- /src/tools/ansi-test/section11.lisp: -------------------------------------------------------------------------------- 1 | ;;; section 11: packages -*- mode: lisp -*- 2 | (in-package :cl-user) 3 | 4 | 5 | ;;; bah 6 | -------------------------------------------------------------------------------- /src/tools/ansi-test/section19.lisp: -------------------------------------------------------------------------------- 1 | ;;; section 19: filenames -*- mode: lisp -*- 2 | (in-package :cl-user) 3 | 4 | 5 | ;; nothing that meaningfull to test... 6 | 7 | -------------------------------------------------------------------------------- /src/tools/ansi-test/section20.lisp: -------------------------------------------------------------------------------- 1 | ;;; section 20 : files -*- mode: lisp -*- 2 | (in-package :cl-user) 3 | 4 | 5 | ;;; too much trouble. too much external stuff 6 | 7 | -------------------------------------------------------------------------------- /src/tools/clunit/Makefile: -------------------------------------------------------------------------------- 1 | TOP := $(shell cd ../../.. ; pwd) 2 | LISPEXT := lisp 3 | SOURCES := clunit 4 | SYSTEM := clunit 5 | include $(TOP)/clocc.mk 6 | -------------------------------------------------------------------------------- /src/tools/clunit/clunit.html: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/blindglobe/clocc/a50bb75edb01039b282cf320e4505122a59c59a7/src/tools/clunit/clunit.html -------------------------------------------------------------------------------- /src/tools/clunit/clunit.system: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: Lisp -*- 2 | 3 | ;;; clunit.system -- 4 | 5 | (mk:defsystem clunit 6 | :source-pathname (translate-logical-pathname "clocc:src;tools;clunit;") 7 | :source-extension "lisp" 8 | :components ((:file "clunit"))) 9 | -------------------------------------------------------------------------------- /src/tools/memoization/Makefile: -------------------------------------------------------------------------------- 1 | install: 2 | cp -r Makefile memoization.asd load-memoization.lisp memoization-examples.lisp memoization.lisp package.lisp \ 3 | save-memo-table.lisp \ 4 | $(DESTDIR)/usr/share/common-lisp/source/memoization 5 | 6 | -------------------------------------------------------------------------------- /src/tools/memoization/debian/README.debian: -------------------------------------------------------------------------------- 1 | memoization for DEBIAN 2 | ---------------------- 3 | 4 | A simple extension-package for CMU-CL. 5 | 6 | Peter Van Eynde , Wed, 27 May 1998 18:17:11 +0200 7 | -------------------------------------------------------------------------------- /src/tools/memoization/debian/control: -------------------------------------------------------------------------------- 1 | Source: cl-memoization 2 | Section: libs 3 | Priority: optional 4 | Build-Depends-Indep: debhelper 5 | Maintainer: Peter Van Eynde 6 | Standards-Version: 3.6.1.0 7 | Priority: optional 8 | 9 | Package: cl-memoization 10 | Architecture: all 11 | Depends: common-lisp-controller (>= 3.45), cl-asdf 12 | Replaces: memoization 13 | Conflicts: memoization 14 | Description: A extension library that adds memoization support to CMU-CL 15 | The library adds support not only to memoize functions, 16 | but also to have persistent memoization information recording to 17 | CMU-CL. 18 | 19 | -------------------------------------------------------------------------------- /src/tools/memoization/debian/copyright: -------------------------------------------------------------------------------- 1 | This package was debianized by Peter Van Eynde pvaneynd@debian.org on 2 | Wed, 27 May 1998 18:17:11 +0200. 3 | 4 | It was downloaded from ftp.cs.umbc.edu/pub/Memoization. 5 | The new location now seems to be http://www.apl.jhu.edu/~hall/lisp/Memoization-1.0/ 6 | 7 | currently it is maintained as part of the clocc on sourceforge 8 | 9 | Copyright: 10 | 11 | ;;; (C) 1992 Marty Hall. Permission is granted for any use or modification 12 | ;; of this code provided this notice is retained. Version of 8/93. 13 | 14 | -------------------------------------------------------------------------------- /src/tools/memoization/debian/dirs: -------------------------------------------------------------------------------- 1 | /usr/share/common-lisp/systems/ 2 | /usr/share/common-lisp/source/memoization 3 | -------------------------------------------------------------------------------- /src/tools/memoization/debian/docs: -------------------------------------------------------------------------------- 1 | docs/Memoization-Overview.text 2 | docs/Memoization-Posting.text 3 | docs/Monterrey-Memoization.ps 4 | -------------------------------------------------------------------------------- /src/tools/memoization/debian/links: -------------------------------------------------------------------------------- 1 | usr/share/common-lisp/source/memoization/memoization.asd usr/share/common-lisp/systems/memoization.asd 2 | -------------------------------------------------------------------------------- /src/tools/memoization/debian/preinst: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | if [ -L /usr/share/common-lisp/source/memoization ] ; then 4 | rm -f /usr/share/common-lisp/source/memoization 2> /dev/null > /dev/null || true 5 | fi 6 | 7 | if [ -d /usr/share/common-lisp/repositories/memoization ] ; then 8 | rm -f /usr/share/common-lisp/repositories/memoization/* 2> /dev/null > /dev/null || true 9 | rmdir /usr/share/common-lisp/repositories/memoization 2> /dev/null > /dev/null || true 10 | fi 11 | 12 | #DEBHELPER# 13 | 14 | -------------------------------------------------------------------------------- /src/tools/memoization/memoization.asd: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: lisp -*- 2 | (in-package :asdf) 3 | 4 | (defsystem :memoization 5 | :components ((:file "package") 6 | (:file "memoization" :depends-on ("package")) 7 | (:file "save-memo-table" :depends-on ("memoization")) 8 | (:file "memoization-examples" :depends-on ("save-memo-table")))) 9 | 10 | -------------------------------------------------------------------------------- /src/tools/metering/.cvsignore: -------------------------------------------------------------------------------- 1 | ChangeLog 2 | metering.list 3 | -------------------------------------------------------------------------------- /src/tools/metering/Makefile: -------------------------------------------------------------------------------- 1 | TOP := $(shell cd ../../.. ; pwd) 2 | LISPEXT := lisp 3 | SOURCES := metering 4 | SYSTEM := metering 5 | include $(TOP)/clocc.mk 6 | -------------------------------------------------------------------------------- /src/tools/metering/PORTS: -------------------------------------------------------------------------------- 1 | clisp 1999-05-01 2 | cmucl 1999-05-01 3 | -------------------------------------------------------------------------------- /src/tools/metering/metering.system: -------------------------------------------------------------------------------- 1 | ;;; -*- Mode: Lisp -*- 2 | 3 | ;;; metering.system -- 4 | 5 | (mk:defsystem metering 6 | :source-pathname (translate-logical-pathname "clocc:src;tools;metering;") 7 | :source-extension "lisp" 8 | :components ((:file "metering"))) 9 | -------------------------------------------------------------------------------- /src/ytools/.cvsignore: -------------------------------------------------------------------------------- 1 | files-dbg.lisp 2 | ytconfig.lisp 3 | .cvsignore 4 | code.gbg 5 | *.dif 6 | x-* 7 | -------------------------------------------------------------------------------- /src/ytools/multvalhacks.lisp: -------------------------------------------------------------------------------- 1 | ;-*- Mode: Common-lisp; Package: ytools; Readtable: ytools; -*- 2 | (in-package :ytools) 3 | 4 | (depends-on %module/ ytools) 5 | 6 | ;;;;(eval-when (:compile-toplevel :load-toplevel :execute :slurp-toplevel) 7 | ;;;; (export )) 8 | 9 | (defvar multvalhacks-break* false) 10 | 11 | (out (:to *error-output*) 12 | "Loading file 'multvalhacks', which is no longer necessary." 13 | (:q (multvalhacks-break* 14 | (:e (breakpoint multvalhacks 15 | "Care to find and eliminate the reference to it?")))) 16 | :% :%) 17 | -------------------------------------------------------------------------------- /src/ytools/repl.lisp: -------------------------------------------------------------------------------- 1 | ;-*- Mode: Common-lisp; Package: ytools; Readtable: ytools; -*- 2 | (in-package :ytools) 3 | ;;;$Id: repl.lisp,v 2.1 2005/12/26 00:25:17 airfoyle Exp $ 4 | 5 | (defun simp-repl () 6 | (let (r* 7 | (* nil) 8 | (** nil)) 9 | (declare (special * **)) 10 | (format *query-io* "Simple read-eval-print loop; *package* = ~s~%" 11 | *package*) 12 | (loop 13 | (format *query-io* "?*> ") 14 | (setq r* (read)) 15 | (cond ((eq r* ':quit) 16 | (return 'repl-done))) 17 | (restart-case 18 | (let ((newval (eval r*))) 19 | (setq ** *) 20 | (setq * newval) 21 | (format *query-io* "~s~%" newval)) 22 | (resume-simp-repl () 23 | :report "Resume simple read-eval-print loop"))))) 24 | -------------------------------------------------------------------------------- /src/ytools/slurptest.dat: -------------------------------------------------------------------------------- 1 | (fribble one) 2 | 3 | (progn 4 | (garble 3) 5 | (garble -5)) 6 | 7 | (fribble two) 8 | 9 | (defun useless (x) (list x x)) --------------------------------------------------------------------------------