MAINT: dense_output and t_eval are mutually exclusive inputs

[MatthewFlamm]

As found in #9228 in solve_ivp, if both t_eval and dense_output are used, an exception occurs when ts and interpolants lengths do not match.

Added this information to the docstring. Could consider adding an Exception with more informative message as well.

[drhagen]

I am not sure the current behavior is the correct behavior. I don't see why both of these options could not be set simultaneously. I think @nmayorov wrote this part of the code. I would like to hear his opinion.

[MatthewFlamm]

I can see the reasoning behind the functionality as is. Using neither option stores t and y at every integrator step. Using only t_eval stores only t and y at t=t_eval. Using only dense_output stores t, y and an interpolating function at every integrator step. In my opinion, the reason for specifying t_eval is for convenience and for reducing memory requirements. One still gets similar convenience using dense_output by adding one more line after the solution is returned (like in the issue linked originally). What are the use cases for specifying both?

I would suggest the following options:

1. just adding the info to the docstring as in present
2. do 1, but also raise an exception with informative message
3. Ignore t_eval, i.e. set to None, and print a warning that directs the user to evaluate the solution using the sol return from dense_output
4. Keep the time steps of the solver when t_eval is set, so that the interpolating function can be generated correctly. Note however this increases the memory requirement when just t_eval is set, which is one key reason for using t_eval in the first place. I personally don't like this option.
5. Add new functionality when both t_eval and dense_output are used.

[drhagen]

I don't think there is a use-case for specifying both. But I think the sensible behavior when both are specified is this:

• t_eval controls only the behavior of the ts and ys fields. When an array, ts equals t_eval; when None, ts equals the time steps chosen by the solver.
• dense_output controls only the behavior of sol. When True, sol is and OdeSolution; when False, it is None.
• t_events is always the same regardless of the t_eval and dense_output settings.

[MatthewFlamm]

I think this is a fine option. I can take a crack, but I still haven't been able to build scipy for development, despite reading the developers build documentation several times over.

[drhagen]

Go ahead and take a crack at it. I can't build the dev environment anymore either. I just modify the files of an installed instance in an isolated conda environment and then copy the files to the git repo once everything is working.

[MatthewFlamm]

This is what I was planning on doing :) thanks

…

On Wed, Sep 19, 2018, 7:24 AM David Hagen ***@***.***> wrote: Go ahead and take a crack at it. I can't build the dev environment anymore either. I just modify the files of an installed instance in an isolated conda environment and then copy the files to the git repo once everything is working. — You are receiving this because you authored the thread. Reply to this email directly, view it on GitHub <#9282 (comment)>, or mute the thread <https://github.com/notifications/unsubscribe-auth/AlhM4WXJCxnbLcWKrwDnRnv-0u2ostx3ks5ucilcgaJpZM4Wr3d2> .

[MatthewFlamm]

I have tested this with the following code adapted from the issue above, where sol is the solution when t_eval and dense_output are both set, sol_teval is the solution when only t_eval is set, and sol_dense is the solution when only dense_output is set.

I think this satisfies what @drhagen suggested.

import numpy as np
from scipy.integrate import solve_ivp

def fprime(x, y):
    return 3 * x**2 + 12 * x - 4

def event(x, y):
    return y

xspan = (-8, 4)
xeval, h = np.linspace(*xspan, retstep=True)

sol = solve_ivp(fprime, xspan, np.array([-120]), t_eval=xeval, events=[event],
                dense_output=True, max_step=h)

sol_teval=solve_ivp(fprime, xspan, np.array([-120]), t_eval=xeval, events=[event],
                max_step=h)

sol_dense = solve_ivp(fprime, xspan, np.array([-120]), events=[event],
                dense_output=True, max_step=h)

print(np.all(sol.t==sol_teval.t))
print(np.all(sol.y==sol_teval.y))
print(np.all(sol.sol(xeval)==sol_dense.sol(xeval)))
print(np.all(sol.t_events[0]==sol_teval.t_events[0]))
print(np.all(sol.t_events[0]==sol_dense.t_events[0]))

Running this returns:

True
True
True
True
True

[MatthewFlamm]

I added a simple test that would have failed previously but passes now (on my end). I also changed title to MAINT, since it is no longer a documentation change. Let me know if it should be another category like bug.

[drhagen]

This seems like the correct behavior to me. Very nicely done.

[nmayorov]

Hi!

I think these are good suggestion and implementation. I'm merging this, quite sure nobody will mind it.