Pith. sign in

REVIEW 4 major objections 8 minor 1 cited by

Performance Evaluation of Single-step Explicit Exponential Integration Methods on Stiff Ordinary Differential Equations

T0 review · 4 major / 8 minor · reviewed 2026-08-12 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read On stiff ordinary differential equations, explicit exponential integration methods do not deliver their advertised higher-order accuracy: none of the tested schemes beats the simple first-order integrating factor Euler method, and several…

desk verdict Useful benchmark with a plausible negative result, but the reference-solution details and missing reproducibility make the headline claim conditional. read the letter →

arxiv 2411.19374 v1 pith:TWK4TAIY submitted 2024-11-28 math.NA cs.NAcs.SYeess.SY

Colby Fronk , Linda Petzold This is my paper · ORCID
classification math.NAcs.NAcs.SYeess.SY MSC 65L0465L0665L2065F60
keywords exponentialintegratorsstiffordinarydifferentialequationsintegratingfactorEulertimedifferencingbackwardneuralODEsnumericalaccuracymatrix
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Explicit exponential integrators—methods that handle stiffness by exponentiating the Jacobian instead of solving nonlinear systems—have been proposed as cheap alternatives to implicit solvers for applications that require repeated integration, such as parameter estimation and neural ODE training. This paper benchmarks twelve such single-step schemes against classical implicit methods on three standard stiff problems: the van der Pol oscillator, the HIRES reaction network, and the Robertson model. Its central claim is that the higher-order exponential schemes never surpass the accuracy of the first-order integrating factor Euler method, and that at small step sizes they are less accurate than backward Euler. If correct, the practical recommendation is that IF Euler is the only exponential integrator worth using for repeated, inexpensive stiff integration, and that higher-order exponential methods need a different design principle rather than further tuning.

What carries the argument

The central object is the linear/nonlinear split at the initial Jacobian, $f(t,y)=Ly+N(t,y)$, together with the matrix exponential $e^{Lh}$. Integrating factor methods make the change of variables $w=e^{-Lt}y$ and then apply a standard explicit scheme to $w$; exponential time differencing methods instead integrate the linear part exactly and approximate the integral of the nonlinear remainder. Every exponential scheme in the paper is a different quadrature or stage construction on this same split, and the local truncation error formulas show the stiff matrix $L$ entering directly (for example, IF2RK has local error $\frac{5h^3}{12}L^2N$). The comparison against implicit methods isolates whether this split removes the stiffness penalty that makes explicit Runge-Kutta impractical; the paper's answer is that it does not at higher order.

What would settle it

Compute the same comparisons on a stiff linear ODE with a known closed-form solution, e.g. $y' = \Lambda y + g(t)$ with eigenvalues spanning $10^6$, measuring error directly against the exact solution rather than a Radau reference, at tolerances below $10^{-10}$. If any higher-order exponential scheme (ETD2RK, EPIRK3, ETD1/RK4) then exhibits its advertised convergence order, the paper's blanket conclusion that these methods do not exceed first-order accuracy on stiff problems would be contradicted for that problem class.

Watch

Extended reading notes

Core claim

The paper's central discovery is that formal order does not translate into accuracy for explicit exponential integrators on stiff benchmark problems. Across the stiff van der Pol oscillator, the HIRES model, and the Robertson model, and across several step-size regimes, no exponential scheme beat the first-order integrating factor Euler method in accuracy, and several higher-order schemes were less accurate than first-order backward Euler at small step sizes. The paper treats this as a stiff-order failure: the Jacobian-based linear/nonlinear split that defines exponential integrators does not protect the higher-order stages from stiffness-induced error growth, so the methods saturate at roughly first-order accuracy. The recommended practical takeaway is that IF Euler is the only exponential integrator reliable enough for repeated cheap integration in neural ODE and parameter-estimation settings.

Load-bearing premise

The load-bearing premise is that the reference solution produced by the default-tolerance Radau solver is accurate enough that the measured errors reflect each method's true accuracy rather than the reference solver's own error.

Editorial extensions

If this is right

  • Users of repeated integration in neural ODEs and parameter estimation should expect no accuracy gain from higher-order exponential schemes on stiff problems; IF Euler is the recommended cheap default.
  • At small step sizes, backward Euler is more accurate than the higher-order exponential schemes, so the accuracy advantage of implicit methods persists even where per-step cost favors exponentials.
  • The formal order of ETD and EPI schemes is not a reliable guide to observed accuracy on stiff nonlinear benchmarks; the methods saturate near first-order accuracy in these tests.
  • The paper's recommended next step is to confirm IF Euler's capability for training stiff neural ODEs, which would establish it as a practical alternative to implicit solvers in that setting.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The reported error floors may reflect the default tolerance of the Radau reference solution as much as the methods themselves; a comparison against a much tighter reference, or against exact solutions, could change the ranking between backward Euler and the exponential schemes.
  • All tested exponential schemes linearize once at the initial condition of each step; methods that refresh the linearization inside the step or use stiffness-aware quadrature are a natural next test and are not covered by this negative result.
  • The practical recommendation to use IF Euler assumes the matrix exponential can be computed cheaply enough; for high-dimensional systems, where the exponential costs at least $O(n^2)$ per step even with iterative methods, the total cost comparison against implicit solvers could reverse.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 8 minor

Summary. This paper evaluates a suite of single-step explicit exponential integration methods (integrating factor Euler, IF2RK, ETD1, ETD2RK, ETD4RK, RKMK2e, ETD-RDP, EPI2, EPIRK3, ETD1/RK4, eSSPRK, eSSPRK+) against classical implicit methods (backward Euler, trapezoid, Radau3, Radau5) on three standard stiff benchmark problems (Van der Pol, HIRES, Robertson). The evaluation measures the absolute error of a single step from one reference point to the next at several fixed step sizes. The paper's central claim is that none of the exponential methods surpass the accuracy of the first-order integrating factor Euler method, that higher-order exponential schemes underperform backward Euler at small step sizes, and that IF Euler is therefore the only reliable cheap exponential integrator for repeated integration in applications such as neural ODEs. The authors also suggest that improved exponential integrators are needed.

Significance. If the central claim were established, the result would be a valuable negative benchmark for the scientific machine learning community: it would caution practitioners against expecting higher-order explicit exponential integrators to help in stiff neural ODE, parameter-estimation, and Bayesian-inference settings, and it would redirect attention to simpler first-order integrating factor methods. The paper covers a broad and representative set of exponential schemes, uses standard stiff benchmarks, and describes its testing protocol clearly. The strengths are the breadth of method coverage and the clarity of the stated limitations, including the explicit deferral of neural-ODE training experiments to future work. However, the significance is currently limited because the main quantitative conclusion rests on the accuracy of the reference solution, which is not validated, and because the paper does not report any cost metric (wall-clock time, function evaluations, or matrix-vector products), so the practical 'inexpensive integration' recommendation is not supported by the data presented.

major comments (4)
  1. [Section III, first paragraph] The reference solution used for all error measurements is generated by SciPy's Radau solver at its default tolerance, and the text states that this yields 'time points uniformly spaced with errors of a similar magnitude.' SciPy's Radau default is rtol=1e-3, atol=1e-6. For Van der Pol variables of order 1000 and HIRES variables of order 1, the permitted reference error can be orders of magnitude larger than the 1e-8 to 1e-16 error levels shown in Figures 3–12. The observed 'saturation' plateaus—e.g., Robertson at absolute error around 1e-4, and HIRES at n=54875 where all exponential methods reportedly saturate at errors about 10^4 times larger than backward Euler—are exactly the signature of measuring against a reference whose own error floors the comparison. Without an independent high-accuracy reference (for example, Radau at rtol=1e-10/atol=1e-12, or analytical or manufactured solutions for these benchmark problems), the central claim that no exponential method surpasses IF Euler is not established. The authors should validate the reference accuracy and show that the reported error floors move downward when the reference tolerance is tightened.
  2. [Section II.C, Eq. (6)] All exponential methods use a single frozen Jacobian L = df/dy(y0), evaluated at the initial condition and held constant over the entire integration interval. For the strongly nonlinear Robertson problem, which contains products y2*y3 and y2^2 with coefficients as large as 3e7, a frozen Jacobian is a poor representation of the local linear dynamics and can substantially degrade the accuracy and stability of exponential integrators. Many exponential integrators in the literature update the Jacobian at each step or use a local linearization. The paper's negative conclusion may therefore be an artifact of this implementation choice rather than a property of the methods themselves. The authors should either update L at every step for the nonlinear problems, or provide a sensitivity study showing that the frozen-Jacobian choice does not change the ranking of methods.
  3. [Section III and Section IV] The experiments measure only the one-step local error (predicting t1 from the known value at t0) and report no wall-clock time, operation counts, or numbers of function evaluations. Since exponential methods require a matrix exponential per step, with cost O(n^3) for dense matrices and O(n^2) for Krylov-based approximations, while implicit solvers require Newton iterations, the abstract's practical recommendation of IF Euler as 'the only reliable choice for repeated, inexpensive integration' is not supported by the evidence presented. A cost-accuracy comparison, such as error versus runtime or error versus number of matrix-vector products, is needed before any claim about cheap repeated integration can be made.
  4. [Section III.A, n=24849 paragraph] The text states that 'The IF Euler method and backward Euler have comparable accuracy' and that 'The exponential methods with the highest accuracy are ETD1, ETD2RK, RKMK2e, EPIRK3, and ETDIRK4 with performance about the same as Trapezoid method.' Since the trapezoid method is second-order and typically more accurate than backward Euler for non-stiff components, this appears to contradict the abstract and conclusion claim that 'none of these methods surpass the accuracy of the first-order integrating factor method.' If all of these methods actually sit at the same reference-error floor, that should be stated explicitly; otherwise the authors should reconcile the discrepancy or soften the central claim to what the plotted data actually show.
minor comments (8)
  1. [Throughout] The method is referred to inconsistently as 'ETD1/RK4', 'ETD1RK4', and 'ETDIRK4' in the methods text, the results text, and the figure captions; please choose one name and use it consistently.
  2. [Figure 8 caption] The caption says 'n = 54785 data points' while the text says '54875 data points' for the same HIRES run; one of these is a typo and should be corrected.
  3. [Section III.A] There is a typo: 'comparision' should be 'comparison' in the first paragraph of the Van der Pol results.
  4. [Section III.B] In the n=857 paragraph, 'slightly worst than backward Euler' should read 'slightly worse than backward Euler.'
  5. [Figures 3–12] The multi-panel figures do not include legends or annotations identifying which colored curve corresponds to which solution component (y1, y2, etc.); the captions list the components but do not map them to colors, making the figures difficult to interpret.
  6. [Section III, first paragraph] The sentence 'achieving time points uniformly spaced with errors of a similar magnitude' is vague; please explain how uniformly spaced time points were derived from the adaptive Radau output and what 'errors of a similar magnitude' means quantitatively.
  7. [References] Reference 1 contains the typo 'V ol. 61' and should be 'Vol. 61'; a few other references have similar spacing issues around volume numbers.
  8. [General] The paper would benefit from a reproducibility statement and a note on code or data availability, since all conclusions rest on numerical experiments and the raw data or scripts are not provided.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the accuracy ranking is an external benchmark against standard stiff test problems, not a quantity defined by its own inputs.

full rationale

Reviewing the claimed derivation chain, the paper makes no theoretical prediction whose output is contained in its input. The methods under test (IF Euler, IF2RK, ETD1, ETD2RK, ETD4RK, RKMK2e, ETD-RDP, EPI2, EPIRK3, ETD1/RK4, eSSPRK, eSSPRK+) are previously published formulas quoted in Section II, and the comparison quantities are absolute errors of these methods on three standard stiff benchmark problems (van der Pol, HIRES, Robertson). The reference trajectory is produced by SciPy Radau at default tolerance as described in Section III, and all methods are evaluated against the same data pairs; no method's result is inserted back into the definition of another method's error, and no fitted parameter is used to generate the accuracy ranking. The Radau-family reference is a possible source of bias in the reported error floors, but that is an experimental-validity concern about the tightness of the reference tolerance, not a demonstration that the conclusion is true by construction. The authors' self-citations (for example Refs. 15-17) appear as background on neural-ODE and Bayesian settings and are not the justification for the numerical comparison. The stated future work confirming IF Euler's capability for neural ODEs is explicitly deferred and does not retroactively define the benchmark conclusion. I therefore find no circular step and assign a score of 0.

Assumptions & free parameters 3 free parameters · 4 assumptions · 0 invented entities

No statistical model is fit and no new physical or mathematical entity is introduced. The evaluation rests on standard benchmark ODEs, hand-chosen reference tolerance, and step-size grids, listed as free parameters and domain assumptions.

free parameters (3)
  • SciPy Radau reference tolerance = default (rtol=1e-3, atol=1e-6 by SciPy defaults)
    Reference solutions for all error measurements depend on this tolerance; chosen by convention, not by accuracy target, and can dominate measured errors for small steps.
  • Test problem stiffness parameters = mu=1000 for Van der Pol
    Van der Pol stiffness is set to mu=1000; other benchmarks are fixed standard test problems. These choices shape the observed rankings and are not swept.
  • Step-size grids = n=1555, 24849; 56, 857, 54875; 1314, 5253, 21009
    Data point counts are chosen by halving/doubling the Radau output, but no convergence study or grid-independence check is reported.
assumptions (4)
  • domain assumption The SciPy Radau solution at default tolerance is an accurate ground truth for all benchmark trajectories.
    All error measurements compare each method's one-step prediction to this reference; if the default tolerance is insufficient, apparent error floors could reflect the reference rather than the method. See Section III, first paragraph.
  • domain assumption Single-step local error over paired reference points is a valid proxy for full-trajectory performance in repeated-integration applications.
    Each interval is integrated independently with a known initial value, so accumulated error, order reduction over many steps, and adaptive step-size behavior are not tested. See Section III.
  • domain assumption The three standard test problems (stiff Van der Pol, HIRES, Robertson) are representative of the stiff ODEs that arise in neural ODEs, PINNs, and parameter estimation.
    The practical recommendation to use IF Euler is generalized from these three benchmarks. See Section III.
  • domain assumption Matrix exponentials and rational approximations are evaluated accurately enough that observed errors are dominated by time discretization.
    The paper discusses matrix exponential cost but does not report the algorithm, tolerance, or code used to compute expm; see Section II C.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Performance Evaluation of Single-step Explicit Exponential Integration Methods on Stiff Ordinary Differential Equations." pith.science (2026). https://pith.science/paper/TWK4TAIY

@misc{pith2026241119374,
  author       = {Pith},
  title        = {Pith review of: Performance Evaluation of Single-step Explicit Exponential Integration Methods on Stiff Ordinary Differential Equations},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/TWK4TAIY}},
  note         = {Machine review of arXiv:2411.19374}
}
read the original abstract

Stiff systems of ordinary differential equations (ODEs) arise in a wide range of scientific and engineering disciplines and are traditionally solved using implicit integration methods due to their stability and efficiency. However, these methods are computationally expensive, particularly for applications requiring repeated integration, such as parameter estimation, Bayesian inference, neural ODEs, physics-informed neural networks, and MeshGraphNets. Explicit exponential integration methods have been proposed as a potential alternative, leveraging the matrix exponential to address stiffness without requiring nonlinear solvers. This study evaluates several state-of-the-art explicit single-step exponential schemes against classical implicit methods on benchmark stiff ODE problems, analyzing their accuracy, stability, and scalability with step size. Despite their initial appeal, our results reveal that explicit exponential methods significantly lag behind implicit schemes in accuracy and scalability for stiff ODEs. The backward Euler method consistently outperformed higher-order exponential methods in accuracy at small step sizes, with none surpassing the accuracy of the first-order integrating factor Euler method. Exponential methods fail to improve upon first-order accuracy, revealing the integrating factor Euler method as the only reliable choice for repeated, inexpensive integration in applications such as neural ODEs and parameter estimation. This study exposes the limitations of explicit exponential methods and calls for the development of improved algorithms.

Figures

Figures reproduced from arXiv: 2411.19374 by the authors.

Figure 1
Figure 1. FIG. 1. Comparison of the integration of the stiff van der Pol oscillator with [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 2
Figure 2. FIG. 2. The stiff Van der Pol model. We have set [PITH_FULL_IMAGE:figures/full_fig_p008_2.png] view at source ↗
Figure 3
Figure 3. FIG. 3. Absolute error for various integration schemes on the stiff Van der Pol model. The step size is also shown for reference. The data shown correspond to [PITH_FULL_IMAGE:figures/full_fig_p009_3.png] view at source ↗
Figures from the paper (9 more)
Figure 4
Figure 4. Figure 4: FIG. 4. Absolute error for various integration schemes on the stiff Van der Pol model. The step size is also shown for reference. The data shown correspond to [PITH_FULL_IMAGE:figures/full_fig_p010_4.png]
Figure 5
Figure 5. Figure 5: FIG. 5. The “High Irradiance RESponse” (HIRES) model [PITH_FULL_IMAGE:figures/full_fig_p012_5.png]
Figure 6
Figure 6. Figure 6: FIG. 6. Absolute error for various integration schemes on the HIRES model. The step size is also shown for reference. The data shown correspond to [PITH_FULL_IMAGE:figures/full_fig_p013_6.png]
Figure 7
Figure 7. Figure 7: FIG. 7. Absolute error for various integration schemes on the HIRES model. The step size is also shown for reference. The data shown correspond to [PITH_FULL_IMAGE:figures/full_fig_p014_7.png]
Figure 8
Figure 8. Figure 8: FIG. 8. Absolute error for various integration schemes on the HIRES model. The step size is also shown for reference. The data shown correspond to [PITH_FULL_IMAGE:figures/full_fig_p015_8.png]
Figure 9
Figure 9. Figure 9: FIG. 9. The Robertson model. Due to the different magnitude of the variables, variables [PITH_FULL_IMAGE:figures/full_fig_p017_9.png]
Figure 10
Figure 10. Figure 10: FIG. 10. Absolute error for various integration schemes on the Robertson model. The step size is also shown for reference. The data shown correspond to [PITH_FULL_IMAGE:figures/full_fig_p018_10.png]
Figure 11
Figure 11. Figure 11: FIG. 11. Absolute error for various integration schemes on the Robertson model. The step size is also shown for reference. The data shown correspond to [PITH_FULL_IMAGE:figures/full_fig_p019_11.png]
Figure 12
Figure 12. Figure 12: FIG. 12. Absolute error for various integration schemes on the Robertson model. The step size is also shown for reference. The data shown correspond to [PITH_FULL_IMAGE:figures/full_fig_p020_12.png]

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. Training Stiff Neural Ordinary Differential Equations with Explicit Exponential Integration Methods

    math.NA 2024-12 conditional novelty 4.0 of 10

    Explicit integrating factor Euler trains stiff neural ODEs stably at low cost, but its first-order accuracy and fixed-Jacobian approximation limit precision.

Reference graph

Works this paper leans on

12 extracted references · 11 canonical work pages · cited by 1 Pith paper

  1. [1]

    (11) Evaluating Single-step Exponential Methods for Stiff ODEs 4

    Integrating Factor Euler Method (IF Euler) Applying the Forward Euler method on Eqn 10 re- sults in the A-stable first-order Integrating Factor Euler scheme26–28,34–36, which has local truncation error h2 2 LN: yn+1 = eLh(yn + hNn). (11) Evaluating Single-step Exponential Methods for Stiff ODEs 4

    work page

  2. [2]

    (12) The local truncation error of this method shows why the lit- erature discourages the use of integrating factor exponential integration methods

    Second-Order Integrating Factor Runge-Kutta Method (IF2RK) Applying the explicit second-order Runge-Kutta method to Eqn 10 gives us the second-order Integrating Factor Runge- Kutta scheme 26–28,34–36, which has local truncation error 5h3 12 L2N: yn+1 = eLhyn + h 2 h eLhNn + N(tn + h,eLh(yn + hNn)) i . (12) The local truncation error of this method shows w...

    work page

  3. [3]

    First-order ETD1 Scheme The simplest approximation comes from approximating the nonlinear term to be a constantN ≈ Nn to give us the following first-order ETD1 scheme36 with local truncation error of h2 2 ˙N: yn+1 = eLhyn + eLh − I Nn L . (14)

    work page

  4. [4]

    Second-order Runge-Kutta ETD Scheme (ETD2RK) A second-order Runge-Kutta ETD scheme 36 with local truncation error of h3 12 ¨N can be constructed as follows: an =eLhyn + eLh − I Nn L (15) yn+1 =an + eLh − I − hL N(tn + h,an) − Nn hL2

    work page

  5. [5]

    (16) Although this ETD4RK method is formally fourth-order, Ref

    Classical Fourth-order Runge-Kutta ETD Scheme (ETD4RK) A direct extension of the classical fourth-order Runge- Kutta scheme on the exponential differencing equation, only gives a third-order scheme36: an =eLh/2yn + eLh/2 − I Nn L , bn =eLh/2yn + eLh/2 − I N(tn + h/2,an) L , cn =eLh/2an + eLh/2 − I 2N(tn + h/2,bn) − Nn L , T1 = h −4 − Lh + eLh 4 − 3Lh + (L...

    work page

  6. [6]

    This scheme belongs to the class of exponential Runge-Kutta schemes

    Pseudo-Steady-State Approximation (PSSA) scheme (RKMK2e) The Pseudo-Steady-State Approximation (PSSA) scheme40,41 is given by: an = eLnhy0 + eLnh − I L Nn(t0,y0), (17) yn+1 = eLnhy0 + 1 2 eLnh − I L (Nn(t0 + h,an) +Nn(t0,y0)) . This scheme belongs to the class of exponential Runge-Kutta schemes

    work page

  7. [7]

    Second-order ETD-real Distinct Poles Scheme (ETD-RDP) Computing the matrix exponential can be computationally expensive. To avoid this, we can use a second-order rational approximation for the matrix exponential, allowing us to re- formulate the ETD scheme without explicitly calculating the matrix exponential42: r(z) = 1 − 5 12z (1 + 1 3z)(1 + 1 4z) = 9 1...

    work page

  8. [8]

    Second-order exponential propagation iterative scheme (EPI2) The simplest EPI scheme is the second-order exponential propagation iterative scheme43 (EPI2), which is given by: yn+1 = yn + eLh − I L fn. (24)

    work page

Show all 12 references
  1. [9]

    Generalized integrating factor exponential methods Generalized integrating factor methods44–46 extend the tra- ditional integrating factor approach previously discussed

    Third-order Runge-Kutta type exponential propagation iterative scheme (EPIRK3) Using Runge-Kutta as our quadrature rule gives the follow- ing third-order Runge-Kutta type exponential propagation it- erative scheme43 (EPIRK3): r1 = yn + 2eL h 2 − I L fn (25) yn+1 = yn + eLh − I...

  2. [10]

    However, there is a considerable decrease in stability as the order of the method increases

    ETD1/RK4 ETD1/RK4 is a generalized integrating factor exponential method that combines first-order exponential time differenc- ing (ETD) with the RK4 method44–46: φ1(z) =ez − I z (26) φτ, ˜F (v) =eτLv + τφ1(τL)Nn a =φh/2, ˜F (yn) Na =N(tn + h/2,a) b =φh, ˜F (yn) c =a + h 2 (Na...

  3. [11]

    (27) (28)

    Explicit SSP Runge-Kutta method (eSSPRK) Explicit SSP Runge-Kutta method47 is given by: u1 = eLnh (y0 + hNn(t0,y0)) , u2 = 3 4eLnh/2y0 + 1 4e−Lnh/2 (u1 + hNn(t0,u1)) , yn+1 = 1 3eLnhy0 + 2 3eLnh/2 (u2 + hNn(t0,u2)) . (27) (28)

  4. [12]

    High Irradiance RESponse

    Explicit SSP Runge-Kutta method with nondecreasing abscissas (eSSPRK +) Explicit SSP Runge-Kutta method with nondecreasing abscissas47 is given by: u1 = e2Lnh/3 1 2y0 + 1 2 y0 + 4 3hNn(t0,y0) , u2 = e2Lnh/3 2 3y0 + 1 3 u1 + 4 3hNn(t0,u1) , yn+1 = eLnh 59 128y0 + 15 128 y0 + 4 ...

    2018 arXiv

Pith tools

Reviewed August 12, 2026 · model on record in the stance chip above.