{"id":18847723,"url":"https://github.com/jacobwilliams/odepack","last_synced_at":"2026-01-27T14:03:34.185Z","repository":{"id":44651291,"uuid":"48956449","full_name":"jacobwilliams/odepack","owner":"jacobwilliams","description":"Work in Progress to refactor and modernize the ODEPACK Library","archived":false,"fork":false,"pushed_at":"2024-03-30T00:12:32.000Z","size":13498,"stargazers_count":45,"open_issues_count":7,"forks_count":13,"subscribers_count":5,"default_branch":"master","last_synced_at":"2024-12-30T13:56:05.206Z","etag":null,"topics":["fortran","ode","ode-solver","odepack"],"latest_commit_sha":null,"homepage":"http://www.netlib.org/odepack/","language":"Fortran","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"other","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/jacobwilliams.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null}},"created_at":"2016-01-03T18:35:45.000Z","updated_at":"2024-10-25T14:01:14.000Z","dependencies_parsed_at":"2023-09-24T12:11:01.938Z","dependency_job_id":null,"html_url":"https://github.com/jacobwilliams/odepack","commit_stats":{"total_commits":79,"total_committers":2,"mean_commits":39.5,"dds":"0.16455696202531644","last_synced_commit":"94bbe0d5a9dd007dc9e07788ec9c8316417619c8"},"previous_names":[],"tags_count":0,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/jacobwilliams%2Fodepack","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/jacobwilliams%2Fodepack/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/jacobwilliams%2Fodepack/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/jacobwilliams%2Fodepack/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/jacobwilliams","download_url":"https://codeload.github.com/jacobwilliams/odepack/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":239783626,"owners_count":19696425,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["fortran","ode","ode-solver","odepack"],"created_at":"2024-11-08T03:09:20.827Z","updated_at":"2026-01-27T14:03:34.066Z","avatar_url":"https://github.com/jacobwilliams.png","language":"Fortran","funding_links":[],"categories":[],"sub_categories":[],"readme":"\u003c!--\nsee more recent:\n\n   https://computing.llnl.gov/projects/odepack\n\nmight have test cases:\n\n   https://people.sc.fsu.edu/~jburkardt/f77_src/odepack/odepack.html\n\nmarkdown references\n\n   https://michelf.ca/projects/php-markdown/extra\n--\u003e\n\n![ODEPACK](docs/images/odepack.png)\n============\n\n# module ODEPACK\n\nThis is a WIP(Work In Progress) to evaluate the effort required and\nfeasibility of updating older Fortran code from the netlib repository\nusing a combination of the commercial plusFORT/spag software and GNU\nutilities as well as conventional manual refactoring.\n\nMany thanks to plusFORT for making an evaluation copy available for\nseveral months to the Fortran Community. The plusFORT tools were crucial\nto this study and unmatched in my experience for removing deprecated\nsyntax from pre-f2003 code.\n\nThis began with [ODEPACK](https://computing.llnl.gov/projects/odepack)\n\nthe ODEPACK package has been selected as a significant code that is well\ndocumented and structured for its vintage, and available on the netlib\nsite and covered by a public domain license.\n\n#### preliminary targets for phase I:\n\n + remove obsolescent syntax (trying plusFORT and spag)\n + able to build using fpm(1)  (the Fortran Package Manager)\n   - in debug mode (ongoing)\n   - with ifort, gfortran, nvfortran\n + text viewable in ford(1) and extractable as markup that can run through pandoc(1) (ongoing)\n + available on github (or equivalent)\n + no common blocks\n + no equivalences\n + build as a (single?) module M_odepack (ongoing)\n + complete set of unit tests (tests currently only use the original examples)\n\nThe originally bundled subset of BLAS/LAPACK routines are\nbeing included in the module.  In production, this might not be done in\norder to be able to easily call external optimized versions.\n\nThe biggest hinderance is some storage used for both INTEGER and DOUBLE\nPRECISION values.\n\nOne take-away is how critical unit tests are to enable rapid development\n(which so far this package does not have)\n\nThe initial pass was done just using the original sample programs as\nunit tests. This may have allowed for introduction of errors as this\nis a WIP but the original samples run with the same output as the original.\n\nplusFORT was invaluable and reduced the effort by an estimated 85\npercent. The results have been encouraging enough to inspire completing\nthe transformation.\n\n### Phase II ?\n\nSome of the goals of phase I are incomplete, but The results of this first\npass were significant enough that this project will hopefully continue.\n\nA complete unit test suite is required to allow development to proceed\nrapidily. Contributions, especially from current ODEPACK users are\nparticularly welcome.\n\nAnother major issue is the remaining non-standard code.  Non-standard (but\nat the time de-facto fortran standard) such as equivalencing different\ntypes, creating scratch space that is used as different numeric types,\nand treating scalars as arrays and vice-versa as well as passing the same\narrays or values multiple times are the most time-consuming usages to\ncorrect to standard-conforming, particularly since spag(1) had already\ndone an excellent job with updating the pre-f2003 code. spag(1) is not\n(currently?) sufficient by itself to automate the additional refactoring\ndesired, which includes using post-f95 features and code restructuring,\nso the remaining work requires manual recoding.\n\nThe type-mismatch issues have not been eliminated enough to include all\nthe routines in the module, so  those in the files \"M_da1/dprep.inc\"\n\"M_da1/dainvgs.inc\" \"M_da1/dprepi.inc\" \"M_da1/dstodi.inc\" and\n\"M_da1_/dstode.inc\" still require being built without an interface\ndefinition.\n\n### building with fpm(1)\n\nThis version of ODEPACK already builds with an included make(1) file\nand as an fpm(1) package with the current options:\n```bash\n fpm run                     --compiler nvfortran --example '*'\n fpm run --profile release   --compiler ifort     --example '*'\n # gfortran for production\n fpm run --profile release --flag -fallow-argument-mismatch --compiler gfortran  --example '*'\n # gfortran for debug\n fpm run --profile debug --flag -fallow-argument-mismatch --flag -std=f2018 --compiler gfortran  --example '*' --verbose\n```\n### building with make(1)\n```bash\n\ncd src\n# gfortran\nmake clean\nmake gfortran\nmake run\nmake test\n\n# ifort\nmake clean\nmake ifort\nmake run\nmake test\n\n# nvfortran\nmake clean\nmake nvfortran\nmake run\nmake test\n```\n### To rebuild the documentation with ford(1), use\n\n```bash\n ford ford.md\n```\n\nThe code is far more readable after having been refactored by\na combination of using spag(1) from the plusFORT package and manual\nediting, and is believed as useable as the original.\n\nThere are a few notes in src/M_odepack.f90 concerning continuing issues.\n\nCurrent users of ODEPACK are encouraged to try this version and provide\nfeedback.\n\nHopefully as a community we can complete creating a new maintained\nproduction-quality version of this venerable and still-valuable package.\n\n### Documentation\n\nThe ongoing API documentation for the current `master` branch can\nbe found [here](https://jacobwilliams.github.io/odepack/).\nThis is generated by processing the source files with\n[FORD](https://github.com/Fortran-FOSS-Programmers/ford).\n\n#### Solvers for explicitly given systems.\nLinks to the solver-specific documenation for the main procedures (as described below):\n\n   + [dlsoda](https://jacobwilliams.github.io/odepack/proc/dlsoda.html)\n   + [dlsodar](https://jacobwilliams.github.io/odepack/proc/dlsodar.html)\n   + [dlsode](https://jacobwilliams.github.io/odepack/proc/dlsode.html)\n   + [dlsodes](https://jacobwilliams.github.io/odepack/proc/dlsodes.html)\n   + [dlsodi](https://jacobwilliams.github.io/odepack/proc/dlsodi.html)\n   + [dlsodis](https://jacobwilliams.github.io/odepack/proc/dlsodis.html)\n   + [dlsodkr](https://jacobwilliams.github.io/odepack/proc/dlsodkr.html)\n   + [dlsodpk](https://jacobwilliams.github.io/odepack/proc/dlsodpk.html)\n   + [dlsoibt](https://jacobwilliams.github.io/odepack/proc/dlsoibt.html)\n\nHere is an overview primarily from the original documentation  ...\n\n--------------------------------------------------------------------------------\n\n## Brief Description of ODEPACK - A Systematized Collection of ODE Solvers (Double Precision Version)\n\n```text\nAlan C. Hindmarsh\nCenter for Applied Scientific Computing, L-561\nLawrence Livermore National Laboratory\nLivermore, CA 94551, U.S.A.\n\n20 June 2001\n```\n\nWork performed under the auspices of the U.S. Department of Energy\nby the Lawrence Livermore National Laboratory under contract\nNo. W-7405-Eng-48, and supported (formerly) by the DOE Office of\nEnergy Research, Applied Mathematical Sciences Research Program.\n\n---------------------------------------------------------------------------\n\n   ODEPACK is a collection of Fortran solvers for the initial value\nproblem for ordinary differential equation systems.  It consists of nine\nsolvers, namely a basic solver called LSODE and eight variants of it --\nLSODES, LSODA, LSODAR, LSODPK, LSODKR, LSODI, LSOIBT, and LSODIS.\nThe collection is suitable for both stiff and nonstiff systems.  It\nincludes solvers for systems given in explicit form, dy/dt = f(t,y),\nand also solvers for systems given in linearly implicit form,\nA(t,y) dy/dt = g(t,y).  Two of the solvers use general sparse matrix\nsolvers for the linear systems that arise.  Two others use iterative\n(preconditioned Krylov) methods instead of direct methods for these\nlinear systems.  The most recent addition is LSODIS, which solves\nimplicit problems with general sparse treatment of all matrices involved.\n\n   The ODEPACK solvers are written in standard Fortran 77, with a few\nexceptions, and with minimal machine dependencies.  There are separate\ndouble and single precision versions of ODEPACK.  The actual solver\nnames are those given above with a prefix of D- or S- for the double\nor single precision version, respectively, i.e. DLSODE/SLSODE, etc.\nEach solver consists of a main driver subroutine having the same name\nas the solver and some number of subordinate routines.  For each\nsolver, there is also a demonstration program, which solves one or two\nsimple problems in a somewhat self-checking manner.\n\n   Recently, the ODEPACK solvers were upgraded to improve their\nportability in numerous ways.  Among the improvements are (a) renaming\nof routines and Common blocks to distinguish double and single\nprecision versions, (b) use of generic intrinsic function names, (c)\nelimination of the Block Data subprogram, (d) use of a portable\nroutine to set the unit roundoff, and (e) passing of quoted strings to\nthe error message handler.  In addition, the prologue and internal\ncomments were reformatted, and use mixed upper/lower case.  Numerous\nminor corrections and improvements were also made.\n\n   The above upgrade operations were applied to LSODE earlier than they\nwere to the rest of ODEPACK, and the two upgrades were done somewhat\nindependently.  As a result, some differences will be apparent in the\nsource files of LSODE and the other solvers -- primarily in the\nformatting of the comment line prologue of the main driver routine.\nIn Subroutines DLSODE/SLSODE and their subordinate routines, the\nprologue was written in \"SLATEC format\", while for the other solvers a\nmore relaxed style was used.  The differences are entirely cosmetic,\nhowever, and do not affect performance.\n\n   Documentation on the usage of each solver is provided in the\ninitial block of comment lines in the source file, which (in most\ncases) includes a simple example.  A demonstration program (in\nseparate double/single precision versions) is also available.\n\n   What follows is a summary of the capabilities of ODEPACK, comments\nabout usage documentation, and notes about installing the collection.\nFor additional documentation on ODEPACK, see also the papers [1], [2]\n(for LSODE), and [3] (for LSODPK and LSODKR), and in the references\ncited there.  (However, the document [2] does not reflect the upgrade\noperations described above.)\n\n### References:\n\n1.  A. C. Hindmarsh, \"[ODEPACK, A Systematized Collection of ODE Solvers](https://computation.llnl.gov/casc/nsde/pubs/u88007.pdf),\"\n     in Scientific Computing, R. S. Stepleman et al. (eds.), North-Holland,\n     Amsterdam, 1983 (vol. 1 of IMACS Transactions on Scientific Computation),\n     pp. 55-64.\n\n2.  K. Radhakrishnan and A. C. Hindmarsh, \"[Description and Use of LSODE,\n     the Livermore Solver for Ordinary Differential Equations](https://computation.llnl.gov/casc/nsde/pubs/u113855.pdf),\" LLNL\n     report UCRL-ID-113855, December 1993.\n\n3.  P. N. Brown and A. C. Hindmarsh, \"[Reduced Storage Matrix Methods\n     in Stiff ODE Systems](https://computation.llnl.gov/casc/nsde/pubs/u95088.pdf),\" J. Appl. Math. \u0026 Comp., 31 (1989), pp.40-91.\n\n---------------------------------------------------------------------------\n\n### I. Summary of the ODEPACK Solvers\n\n#### A. Solvers for explicitly given systems.\n\nFor each of the following solvers, it is assumed that the ODEs are\ngiven explicitly, so that the system can be written in the form\ndy/dt = f(t,y), where y is the vector of dependent variables, and t is\nthe independent variable.\n\n1. LSODE (Livermore Solver for Ordinary Differential Equations) is the\n   basic solver of the collection.  It solves stiff and nonstiff systems\n   of the form dy/dt = f.  In the stiff case, it treats the Jacobian\n   matrix df/dy as either a dense (full) or a banded matrix, and as either\n   user-supplied or internally approximated by difference quotients.\n   It uses Adams methods (predictor-corrector) in the nonstiff case,\n   and Backward Differentiation Formula (BDF) methods (the Gear methods)\n   in the stiff case.  The linear systems that arise are solved by direct\n   methods (LU factor/solve).  LSODE supersedes the older GEAR and GEARB\n   packages, and reflects a complete redesign of the user interface\n   and internal organization, with some algorithmic improvements.\n\n2. LSODES, written jointly with A. H. Sherman, solves systems dy/dt = f\n   and in the stiff case treats the Jacobian matrix in general sparse\n   form.  It determines the sparsity structure on its own, or optionally\n   accepts this information from the user.  It then uses parts of the\n   Yale Sparse Matrix Package (YSMP) to solve the linear systems that\n   arise, by a sparse (direct) LU factorization/backsolve method.\n   LSODES supersedes, and improves upon, the older GEARS package.\n\n3. LSODA, written jointly with L. R. Petzold, solves systems dy/dt = f\n   with a dense or banded Jacobian when the problem is stiff, but it\n   automatically selects between nonstiff (Adams) and stiff (BDF)\n   methods.  It uses the nonstiff method initially, and dynamically\n   monitors data in order to decide which method to use.\n\n4. LSODAR, also written jointly with L. R. Petzold, is a variant of\n   LSODA with a rootfinding capability added.  Thus it solves problems\n   dy/dt = f with dense or banded Jacobian and automatic method\n   selection, and at the same time, it finds the roots of any of a\n   set of given functions of the form g(t,y).  This is often useful\n   for finding stop conditions, or for finding points at which a switch\n   is to be made in the function f.\n\n5. LSODPK, written jointly with Peter N. Brown, is a variant of LSODE\n   in which the direct solvers for the linear systems have been replaced\n   by a selection of four preconditioned Krylov (iterative) solvers.\n   The user must supply a pair of routine to evaluate, preprocess, and\n   solve the (left and/or right) preconditioner matrices.  LSODPK also\n   includes an option for a user-supplied linear system solver to be used\n   without Krylov iteration.\n\n6. LSODKR is a variant of LSODPK with the addition of the same\n   rootfinding capability as in LSODAR, and also of automatic switching\n   between functional and Newton iteration.  The nonlinear iteration\n   method-switching differs from the method-switching in LSODA and LSODAR,\n   but provides similar savings by using the cheaper method in the non-stiff\n   regions of the problem.  LSODKR also improves on the Krylov methods in\n   LSODPK by offering the option to save and reuse the approximate Jacobian\n   data underlying the preconditioner.\n\n\n#### B. Solvers for linearly implicit systems.\n\nThe following solvers treat systems in the linearly implicit form\nA(t,y) dy/dt = g(t,y), A = a square matrix, i.e. with the derivative\ndy/dt implicit, but linearly so.  These solvers allow A to be\nsingular, in which case the system is a differential-algebraic\nequation (DAE) system.  In that case, the user must be very careful\nto supply a well-posed problem with consistent initial conditions.\n\n7. LSODI, written jointly with J. F. Painter, solves linearly implicit\n   systems in which the matrices involved (A, dg/dy, and d(A dy/dt)/dy)\n   are all assumed to be either dense or banded.  LSODI supersedes the\n   older GEARIB solver and improves upon it in numerous ways.\n\n8. LSOIBT, written jointly with C. S. Kenney, solves linearly implicit\n   systems in which the matrices involved are all assumed to be\n   block-tridiagonal.  Linear systems are solved by the LU method.\n\n9. LSODIS, written jointly with S. Balsdon, solves linearly implicit\n   systems in which the matrices involved are all assumed to be sparse.\n   Like LSODES, LSODIS either determines the sparsity structure or\n   accepts it from the user, and uses parts of the Yale Sparse Matrix\n   Package to solve the linear systems that arise, by a direct method.\n\n---------------------------------------------------------------------------\n\n### II. Usage Documentation\n\n   Each of the solvers in the ODEPACK collection is headed by a\nuser-callable driver subroutine, with the same name as the solver\n(DLSODE, etc.).  The call sequence of the driver routine includes the\nnames of one or more user-supplied subroutines that define the ODE\nsystem, and various other problem and solution parameters.  Complete\nuser documentation is given in the initial block of comment lines\n(the prologue) in the driver routine.  In each case, this prologue is\norganized as follows:\n\n * Summary of Usage (short, for standard modes of use)\n * Example Problem, with code and output (except for LSODPK and LSODKR)\n * Full Description of User Interface, further divided as follows:\n      1. Call sequence description (including optional inputs/outputs)\n      2. Optionally callable routines\n      3. Descriptions of internal Common blocks\n      4. Optionally user-replaceable routines\n * Revision History, showing date written and dates of revisions\n * Other Routines, a list of all subordinate routines for the solver\n\nFirst-time users should read only the Summary of Usage and look at the\nthe Example Problem (or demonstration program), then later refer to the\nFull Description if and when more details or nonstandard options are needed.\n\n---------------------------------------------------------------------------\n\n### III. Installation Notes\n\n##### Use of supplied matrix procedures\n\nTHe src/M_matrix/ directory  includes modified versions of routines from the\nLINPACK and BLAS collections that are needed by the solvers (and by two\nof the demonstration programs), for the solution of dense and banded\nlinear systems and associated basic linear algebra operations.\nThese routine are:\n\n       _From LINPACK_ :  DGEFA, DGESL, DGBFA, DGBSL\n       _From the BLAS_: DAXPY, DCOPY, DDOT, DSCAL, DNRM2, IDAMAX\n\nIf your computer system already has these routines, and especially if it\nhas machine-optimized versions, the copies provided in the M_module\nmodule should probably not be called by your program if high performance\nis required.\n\n##### The message package\n\nThe second auxiliary source file directory M_da1/ includes a set of five\nroutines -- XERRWD, XSETUN, XSETF, IXSAV, IUMACH -- which handle error\nmessages from the solvers.\n\nThese routines are slated for elimination and replacement with a \nmore intuitive interface.\n\nThis set is in fact a reduced version (sufficient for the needs of\nODEPACK) of a much larger error handling package from the SLATEC Library.\nIf your computer system already has the full SLATEC error handler, the\nversion provided here can be ignored.  If the reduced version is used,\nits machine-dependent features should be checked first; see comments in\nSubroutine XERRWD.\n\n##### Non-standard code\n\n4. ODEPACK contains a few instances where the Fortran Standard is violated:\n\n   (a) In various places in the LSODES and LSODIS solvers, a call to a\n   subroutine has a subscripted real array as an argument where the\n   subroutine called expects an integer array.  Calls of this form\n   occur in Subroutine DLSODES (to DSTODE), in DIPREP (to DPREP),\n   in Subroutine DLSODIS (to DSTODI), and in DIPREPI (to DPREPI).\n   Another such call occurs in the DLSODES demonstration program,\n   from the main program to Subroutine SSOUT.  \n\n   This is done in order\n   to use work space in an efficient manner, as the same space is\n   sometimes used for real work space and sometimes for integer work\n   space.  If your compiler does not accept this feature, one possible\n   way to get the desired result is to compile the called routines\n   and calling routines in separate jobs, and then combine the binary\n   modules in an appropriate manner. \n\n   If this procedure is still not\n   acceptable under your system, it will be necessary to radically\n   alter the structure of the array RWORK within the LSODES or LSODIS\n   solver package.  (See also Note 5 below.)\n\n   (b) Each ODEPACK solver treats the arguments NEQ, Y, RTOL, and ATOL\n   as arrays, even though the length may be only 1.  Moreover,\n   except for Y, the usage instructions say that these arguments\n   may be either arrays or scalars.  If your system does not allow\n   such a mismatch, then the documentation of these arguments\n   should be changed accordingly.\n\n5. For maximum storage economy, the LSODES and LSODIS solvers make use\nof the real to integer wordlength ratio.  This is assumed to be an\ninteger L such that if a real array R and an integer array M occupy\nthe same space in memory, R(1) having the same bit address as M(1),\nthen R(I) has the same address as M((I-1)*L+1).  This ratio L is\nusually 2 for double precision, and this is the value used in the\ndouble precision version supplied.  If this value is incorrect, it\nneeds to be changed in two places:\n\n  (a) The integer LENRAT is DATA-loaded in Subroutines DLSODES and\n      DLSODIS to this ratio, shortly below the prologue.\n\n  (b) The integer LRATIO is DATA-loaded in Subroutine CDRV to this\n      ratio, shortly below the prologue of that routine.\n\n(See comments in both places.)  If the ratio is not an integer, use\nthe greatest integer not exceeding the ratio.\n\n6. For installation of ODEPACK on a Cray computer, the source files\nsupplied include compiler directives for the CFT compiler.  These have\nthe form CDIR$ IVDEP and occur prior to certain loops that involve\nsubscript shifts (and would otherwise not be vectorized).  These\ndirectives are (or should be) treated as comments by any other compiler.\n\n7. On first obtaining ODEPACK, the demonstration programs should be\ncompiled and executed prior to any other use of the solvers.  In most\ncases, these exercise all of the major method options in each solver,\nand are self-checking.  (In the case of LSODPK and LSODKR, the\ndemonstration programs are not self-checking, and for LSODKR only one\nmajor method option is used.)  In any case, the output can be compared\nwith the sample output supplied, which was generated from the double\nprecision version of ODEPACK on a 32-bit computer.  When comparing your\noutput with that supplied, differences of 10-20% in the final values of\nthe various statistical counters can be attributed to differences in\nthe roundoff properties of different computer systems.\n\n8. If some subset of the whole ODEPACK collection is desired, without\nunneeded routines, the appropriate routines must be extracted\naccordingly.  The following lists give the routines needed for the\ndouble precision version of each solver.\n\n    The DLSODE solver consists of the routines\n  DLSODE, DINTDY, DSTODE, DCFODE, DPREPJ, DSOLSY, DEWSET, DVNORM, DSRCOM,\n  DGEFA, DGESL, DGBFA, DGBSL, DAXPY, DSCAL, DDOT, IDAMAX,\n  XERRWD, XSETUN, XSETF, IXSAV, IUMACH\n\n    The DLSODES solver consists of the routines\n  DLSODES, DIPREP, DPREP, JGROUP, ADJLR, CNTNZU, DINTDY, DSTODE, DCFODE,\n  DPRJS, DSOLSS, DEWSET, DVNORM, DSRCMS,\n  ODRV, MD, MDI, MDM, MDP, MDU, SRO,\n  CDRV, NROC, NSFC, NNFC, NNSC, NNTC,\n  XERRWD, XSETUN, XSETF, IXSAV, IUMACH\n\n    The DLSODA solver consists of the routines\n  DLSODA, DINTDY, DSTODA, DCFODE, DPRJA, DSOLSY, DEWSET,\n  DMNORM, DFNORM, DBNORM, DSRCMA,\n  DGEFA, DGESL, DGBFA, DGBSL, DAXPY, DSCAL, DDOT, IDAMAX,\n  XERRWD, XSETUN, XSETF, IXSAV, IUMACH\n\n     The DLSODAR solver consists of the routines\n  DLSODAR, DRCHEK, DROOTS, DINTDY, DSTODA, DCFODE, DPRJA, DSOLSY, DEWSET,\n  DMNORM, DFNORM, DBNORM, DSRCAR,\n  DGEFA, DGESL, DGBFA, DGBSL, DAXPY, DSCAL, DDOT, DCOPY, IDAMAX,\n  XERRWD, XSETUN, XSETF, IXSAV, IUMACH\n\n     The DLSODPK solver consists of the routines\n  DLSODPK, DINTDY, DEWSET, DVNORM, DSTODPK, DCFODE, DPKSET, DSOLPK,\n  DSPIOM, DATV, DORTHOG, DHEFA, DHESL, DSPIGMR, DHEQR, DHELS,\n  DPCG, DPCGS, DATP, DUSOL, DSRCPK,\n  DAXPY, DSCAL, DCOPY, DDOT, DNRM2, IDAMAX,\n  XERRWD, XSETUN, XSETF, IXSAV, IUMACH\n\n     The DLSODKR solver consists of the routines\n  DLSODKR, DRCHEK, DROOTS, DLHIN, DINTDY, DEWSET, DVNORM, DSTOKA,\n  DCFODE, DSETPK, DSOLPK, DSPIOM, DATV, DORTHOG, DHEFA, DHESL, DSPIGMR,\n  DHEQR, DHELS, DPCG, DPCGS, DATP, DUSOL, DSRCKR,\n  DAXPY, DSCAL, DCOPY, DDOT, DNRM2, IDAMAX,\n  XERRWD, XSETUN, XSETF, IXSAV, IUMACH\n\n     The DLSODI solver consists of the routines\n  DLSODI, DAINVG, DINTDY, DSTODI, DCFODE, DPREPJI, DSOLSY, DEWSET,\n  DVNORM, DSRCOM,\n  DGEFA, DGESL, DGBFA, DGBSL, DAXPY, DSCAL, DDOT, IDAMAX,\n  XERRWD, XSETUN, XSETF, IXSAV, IUMACH\n\n     The DLSOIBT solver consists of the routines\n  DLSOIBT, DAIGBT, DINTDY, DSTODI, DCFODE, DPJIBT, DSLSBT, DEWSET,\n  DVNORM, DSRCOM, DDECBT, DSOLBT,\n  DGEFA, DGESL, DAXPY, DSCAL, DDOT, IDAMAX,\n  XERRWD, XSETUN, XSETF, IXSAV, IUMACH\n\n     The DLSODIS solver consists of the routines\n  DLSODIS, DAINVGS, DIPREPI, DPREPI, JGROUP, ADJLR, CNTNZU, DINTDY,\n  DSTODI, DCFODE, DPRJIS, DSOLSS, DEWSET, DVNORM, DSRCMS,\n  ODRV, MD, MDI, MDM, MDP, MDU, SRO,\n  CDRV, NROC, NSFC, NNFC, NNSC, NNTC,\n  XERRWD, XSETUN, XSETF, IXSAV, IUMACH\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fjacobwilliams%2Fodepack","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fjacobwilliams%2Fodepack","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fjacobwilliams%2Fodepack/lists"}