share/odepack/odepack.asd

   1 ;;; -*- Mode: lisp -*-
   2
   3 (defpackage odepack-system
   4   (:use #:cl #:asdf))
   5
   6 (in-package #:odepack-system)
   7
   8 (defclass odepack-fortran-file (cl-source-file)
   9   ()
  10   (:default-initargs :type "f"))
  11
  12 (defun fortran-compile (op c &key (array-slicing t) (array-type :array) (package "ODEPACK")
  13                         declare-common (common-as-array t))
  14   (let ((file (component-pathname c)))
  15     (f2cl:f2cl-compile file
  16                        :output-file (first (output-files op c))
  17                        :array-slicing array-slicing
  18                        :array-type array-type
  19                        :package package
  20                        :declare-common declare-common
  21                        :common-as-array common-as-array
  22                        )))
  23
  24 (defmethod perform ((op compile-op) (c odepack-fortran-file))
  25   (fortran-compile op c :package "ODEPACK"))
  26
  27 (defmethod perform ((op load-op) (c odepack-fortran-file))
  28   (load (first (input-files op c))))
  29
  30
  31 ;; Create a logical pathname for our files.
  32 (let ((base (make-pathname :directory (pathname-directory *load-pathname*))))
  33   (setf (logical-pathname-translations "odepack")
  34         (list (list "**;*.*.*"
  35                     (merge-pathnames (make-pathname :directory '(:relative "odepack" :wild-inferiors)
  36                                                     :name :wild :type :wild)
  37                                      base)))))
  38
  39 (defsystem odepack
  40   :description "F2CL conversion of ODEPACK: Initial value solver for ODEs"
  41   :pathname "odepack/"
  42   :components
  43   ((:module "package"
  44             :pathname ""
  45             :components
  46             ((:file "package")))
  47    (:module "odepack"
  48             :pathname ""
  49             :default-component-class odepack-fortran-file
  50             :components
  51             (
  52              (:file "adjlr"
  53                     :depends-on ("nroc" "nsfc" "nnfc" "nnsc"))
  54              (:file "cdrv"
  55                     :depends-on ("nntc"))
  56              (:file "cntnzu")
  57              (:file "daigbt"
  58                     :depends-on ("ddecbt" "dsolbt"))
  59              (:file "dainvg"
  60                     :depends-on ("dgefa" "dgesl" "dgbfa" "dgbsl"))
  61              (:file "dainvgs")
  62              (:file "datp"
  63                     :depends-on ("dvnorm" "dcopy"))
  64              (:file "datv"
  65                     :depends-on ("dcopy" "dnrm2" "dcopy"))
  66              (:file "daxpy")
  67              (:file "dbnorm")
  68              (:file "dcfode")
  69              (:file "dcopy")
  70              (:file "ddecbt"
  71                     :depends-on ("dgefa" "dgesl" "ddot"))
  72              (:file "ddot")
  73              (:file "dewset")
  74              (:file "dfnorm")
  75              (:file "dgbfa"
  76                     :depends-on ("idamax" "dscal" "daxpy"))
  77              (:file "dgbsl"
  78                     :depends-on ("daxpy"))
  79              (:file "dgefa"
  80                     :depends-on ("idamax" "dscal" "daxpy"))
  81              (:file "dgesl"
  82                     :depends-on ("daxpy" "ddot"))
  83              (:file "dhefa"
  84                     :depends-on ("idamax"))
  85              (:file "dhels")
  86              (:file "dheqr")
  87              (:file "dhesl")
  88              (:file "dintdy"
  89                     :depends-on ("xerrwd"))
  90              (:file "diprep"
  91                     :depends-on ("dprep")
  92                     :perform (compile-op :around (op c)
  93                                          (fortran-compile op c
  94                                                           :common-as-array t :declare-common t)))
  95              ;; This routine takes a slice of a double precision array and
  96              ;; passes it to dprepi as a integer array. That won't work in
  97              ;; Lisp!
  98              (:file "diprepi"
  99                     :depends-on ("dprepi"))
 100              (:file "dlhin"
 101                     :depends-on ("dvnorm"))
 102              (:file "dlsoda"
 103                     :depends-on ("xerrwd" "dmnorm" "dstoda")
 104                     :perform (compile-op :around (op c)
 105                                          (fortran-compile op c :common-as-array t :declare-common t)))
 106              (:file "dlsodar"
 107                     :depends-on ("drchek"))
 108              (:file "dlsode"
 109                     :depends-on ("dstode"))
 110              (:file "dlsodes"
 111                     :depends-on ("dstode" "dewset"))
 112              (:file "dlsodi"
 113                     :depends-on ("dstodi" "dainvg"))
 114              (:file "dlsodis"
 115                     :depends-on ("dstodi" "dainvgs"))
 116              (:file "dlsodkr"
 117                     :depends-on ("drchek" "dstoka")
 118                     :perform (compile-op :around (op c)
 119                                          (fortran-compile op c :common-as-array t :declare-common t)))
 120              (:file "dlsodpk"
 121                     :depends-on ("dstodpk"))
 122              (:file "dlsoibt"
 123                     :depends-on ("dstodi"))
 124              (:file "dmnorm")
 125              (:file "dnrm2")
 126              (:file "dorthog")
 127              (:file "dpcg")
 128              (:file "dpcgs")
 129              (:file "dpjibt")
 130              (:file "dpkset")
 131              (:file "dprep"
 132                     :depends-on ("jgroup" "odrv"))
 133              (:file "dprepi"
 134                     :depends-on ("jgroup" "odrv"))
 135              (:file "dprepj")
 136              (:file "dprepji")
 137              (:file "dprja")
 138              (:file "dprjis")
 139              (:file "dprjs")
 140              (:file "drchek"
 141                     :depends-on ("droots"))
 142              (:file "droots")
 143              (:file "dscal")
 144              (:file "dsetpk")
 145              (:file "dslsbt")
 146              (:file "dsolbt"
 147                     :depends-on ("dgesl" "ddot"))
 148              (:file "dsolpk"
 149                     :depends-on ("dspiom" "dspigmr" "dusol"))
 150              (:file "dsolss")
 151              (:file "dsolsy")
 152              (:file "dspigmr")
 153              (:file "dspiom")
 154              (:file "dsrcar")
 155              (:file "dsrckr")
 156              (:file "dsrcma")
 157              (:file "dsrcms")
 158              (:file "dsrcom")
 159              (:file "dsrcpk")
 160              (:file "dstoda"
 161                     :depends-on ("dmnorm"))
 162              (:file "dstode")
 163              (:file "dstodi")
 164              (:file "dstodpk"
 165                     :depends-on ("dpkset" "dsolpk"))
 166              (:file "dstoka"
 167                     :depends-on ("dsetpk" "dsolpk"))
 168              (:file "dumach"
 169                     :depends-on ("dumsum"))
 170              (:file "dumsum")
 171              (:file "dusol")
 172              (:file "dvnorm")
 173              (:file "idamax")
 174              (:file "iumach")
 175              (:file "ixsav")
 176              (:file "jgroup")
 177              (:file "md"
 178                     :depends-on ("mdi" "mdm" "mdp" "mdu"))
 179              (:file "mdi")
 180              (:file "mdm")
 181              (:file "mdp")
 182              (:file "mdu")
 183              (:file "nnfc")
 184              (:file "nnsc")
 185              (:file "nntc")
 186              (:file "nroc")
 187              (:file "nsfc")
 188              (:file "odrv"
 189                     :depends-on ("sro" "md"))
 190              (:file "sro")
 191              (:file "xerrwd"
 192                     :depends-on ("ixsav"))
 193              (:file "xsetf")
 194              (:file "xsetun")))))
 195
 196 (defmethod perform ((op test-op) (c (eql (find-system "odepack"))))
 197     (oos 'test-op "odedemo-lsode"))
 198
 199
 200 \f
 201 ;;; Demo programs
 202 ;;;
 203 ;;; Note: Each of the demos should probably be run in a separate Lisp
 204 ;;; instance because some of the demos define functions with the same
 205 ;;; name but different parameters.  This will really confuse the
 206 ;;; generated code, because the generated code uses knowledge of the
 207 ;;; function to generate the call.
 208
 209 ;; (opkdemo1)
 210 ;;
 211 ;; Output matches Fortran code.
 212 (defsystem odedemo-lsode
 213   :pathname "odepack/"
 214   :depends-on ("odepack")
 215   :components
 216   ((:module "demo1"
 217             :default-component-class odepack-fortran-file
 218             :components
 219             ((:file "opkdemo1")
 220              (:file "f1")
 221              (:file "jac1")
 222              (:file "f2")
 223              (:file "jac2")
 224              (:file "edit2")))))
 225
 226 (defmethod perform ((op test-op) (c (eql (find-system "odedemo-lsode"))))
 227   (funcall (intern "OPKDEMO1" (find-package '#:odepack))))
 228
 229 #||
 230 ;; This won't work because opkdemo2 equivalences two arrays together.
 231 ;; f2cl doesn't know how to handle that yet.
 232 (defsystem odedemo-lsodes
 233     :source-pathname (translate-logical-pathname "odepack:")
 234     :binary-pathname (translate-logical-pathname "odepack:lib")
 235     :source-extension "f"
 236     :language :f2cl
 237     :compiler-options (:common-as-array t)
 238     :depends-on ("odepack")
 239     :components
 240     ((:file "opkdemo2")))
 241
 242
 243 ||#
 244
 245 ;; (opkdemo3)
 246 ;;
 247 ;; Output matches Fortran code.
 248 (defsystem odedemo-lsoda
 249   :pathname "odepack/"
 250   :depends-on ("odepack")
 251   :components
 252   ((:module "demo3"
 253             :default-component-class odepack-fortran-file
 254             :components
 255             ((:file "opkdemo3")
 256              (:file "f1")
 257              (:file "jac1")
 258              (:file "f2")
 259              (:file "jac2")
 260              (:file "edit2")))))
 261
 262 (defmethod perform ((op test-op) (c (eql (find-system "odedemo-lsoda"))))
 263   (funcall (intern "OPKDEMO3" (find-package '#:odepack))))
 264
 265 ;; (opkdemo4)
 266 ;;
 267 ;; Output matches Fortran code.
 268 (defsystem odedemo-lsodar
 269   :pathname "odepack/"
 270   :depends-on ("odepack")
 271   :components
 272   ((:module "demo4"
 273             :default-component-class odepack-fortran-file
 274             :components
 275             ((:file "opkdemo4")
 276              (:file "f1")
 277              (:file "gr1")
 278              (:file "f2")
 279              (:file "jac2")
 280              (:file "gr2")))))
 281
 282 (defmethod perform ((op test-op) (c (eql (find-system "odedemo-lsodar"))))
 283   (funcall (intern "OPKDEMO4" (find-package '#:odepack))))
 284
 285
 286 ;; (opkdemo5)
 287 ;;
 288 ;; This test takes quite a while to run.  Probably could be optimized
 289 ;; more if we were more careful about array declarations.  Assumption
 290 ;; untested, though.
 291 ;;
 292 ;; This seems to work, and the output matches the Fortran output,
 293 ;; except the test with mf = 29 isn't printed out.  Don't know why.
 294 ;;
 295 ;; The output is placed in demout in the directory where this is run.
 296 ;; Compare this to demo-lsodpk.out
 297 (defsystem odedemo-lsodpk
 298   :pathname "odepack/"
 299   :depends-on ("odepack")
 300   :components
 301   ((:module "demo5"
 302             :default-component-class odepack-fortran-file
 303             :components
 304             ((:file "opkdemo5"
 305                     :depends-on ("gset" "cinit" "outweb")
 306                     :perform (compile-op :around (op c)
 307                                          (fortran-compile op c :declare-common t)))
 308              (:file "setpar")
 309              (:file "gset")
 310              (:file "cinit")
 311              (:file "outweb")
 312              (:file "fweb"
 313                     :depends-on ("webr"))
 314              (:file "webr")
 315              (:file "jacbg"
 316                     :depends-on ("fbg"))
 317              (:file "fbg")
 318              (:file "solsbg"
 319                     :depends-on ("gs"))
 320              (:file "gs")))))
 321
 322 (defmethod perform ((op test-op) (c (eql (find-system "odedemo-lsodpk"))))
 323   (format *error-output* "Running odedemo-lsodpk.  This make take some time.~%")
 324   (finish-output *error-output*)
 325   (funcall (intern "OPKDEMO5" (find-package '#:odepack))))
 326
 327
 328 ;; This seems to work.
 329 (defsystem odedemo-lsodkr
 330   :pathname "odepack/"
 331   :depends-on ("odepack")
 332   :depends-on ("odepack")
 333   :default-component-class odepack-fortran-file
 334   :components
 335   ((:file "opkdemo6"
 336           :perform (compile-op :around (op c)
 337                                (fortran-compile op c :declare-common t)))))
 338
 339 (defmethod perform ((op test-op) (c (eql (find-system "odedemo-lsodkr"))))
 340   (funcall (intern "OPKDEMO6" (find-package '#:odepack))))
 341
 342
 343
 344 ;; This runs and the expected output seems ok.
 345 (defsystem odedemo-lsodi
 346   :depends-on ("odepack")
 347   :pathname "odepack/"
 348   :components
 349   ((:module "demo7"
 350             :default-component-class odepack-fortran-file
 351             :components
 352             ((:file "opkdemo7"
 353                     :perform (compile-op :around (op c)
 354                                          (fortran-compile op c :declare-common t))
 355                     :depends-on ("elkup"))
 356              (:file "gfun")
 357              (:file "res"
 358                     :depends-on ("gfun"))
 359              (:file "addabd")
 360              (:file "addafl")
 361              (:file "jacbd")
 362              (:file "jacfl")
 363              (:file "elkup")))))
 364
 365 (defmethod perform ((op test-op) (c (eql (find-system "odedemo-lsodi"))))
 366   (format *error-output* "Running odedemo-lsodi.  This make take some time.~%")
 367   (funcall (intern "OPKDEMO7" (find-package '#:odepack))))
 368
 369 (defsystem odedemo-lsoibt
 370   :depends-on ("odepack")
 371   :pathname "odepack/"
 372   :components
 373   ((:module "demo8"
 374             :default-component-class odepack-fortran-file
 375             :components
 376             ((:file "opkdemo8"
 377                     :perform (compile-op :around (op c)
 378                                          (fortran-compile op c :declare-common t))
 379                     :depends-on ("setic"
 380                                  "edit"
 381                                  "maxerr"))
 382              (:file "addabt")
 383              (:file "edit")
 384              (:file "gfun")
 385              (:file "jacbt")
 386              (:file "maxerr")
 387              (:file "res"
 388                     :depends-on ("subav"
 389                                  "gfun"))
 390              (:file "setic")
 391              (:file "subav")))))
 392
 393 (defmethod perform ((op test-op) (c (eql (find-system "odedemo-lsoibt"))))
 394   (format *error-output* "Running odedemo-lsoibt.  This make take some time.~%")
 395   (funcall (intern "OPKDEMO7" (find-package '#:odepack))))
 396
 397 #||
 398
 399
 400 ;; Doesn't work.  DIPREPI takes a double precision array and slices it
 401 ;; up and passes it to DPREPI which wants integer arrays.  That ain't
 402 ;; gonna work in Lisp!
 403 (defsystem odedemo-lsodis
 404     :source-pathname (translate-logical-pathname "odepack:")
 405     :binary-pathname (translate-logical-pathname "odepack:lib")
 406     :source-extension "f"
 407     :language :f2cl
 408     :compiler-options (:common-as-array t :declare-common t)
 409     :depends-on ("odepack")
 410     :components
 411     ((:file "opkdemo9")))
 412 ||#