{ "__type": "IngestedDoc", "__tag": 4010, "_content": { "Notes": { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Strong", "__tag": 4048, "children": [ { "__type": "Text", "__tag": 4046, "value": "Array API Standard Support" } ] } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "CrossRef", "__tag": 4002, "value": "solve_ivp", "reference": { "__type": "LocalRef", "__tag": 4022, "kind": "module", "path": "scipy.integrate._ivp.ivp:solve_ivp" }, "kind": "module" }, { "__type": "Text", "__tag": 4046, "value": " has experimental support for Python Array API Standard compatible backends in addition to NumPy. Please consider testing these features by setting an environment variable " }, { "__type": "InlineCode", "__tag": 4051, "value": "SCIPY_ARRAY_API=1" }, { "__type": "Text", "__tag": 4046, "value": " and providing CuPy, PyTorch, JAX, or Dask arrays as array arguments. The following combinations of backend and device (or other capability) are supported." } ] }, { "__type": "Code", "__tag": 4050, "value": "==================== ==================== ====================\nLibrary CPU GPU\n==================== ==================== ====================\nNumPy ✅ n/a \nCuPy n/a ⛔ \nPyTorch ⛔ ⛔ \nJAX ⛔ ⛔ \nDask ⛔ n/a \n==================== ==================== ====================", "execution_status": null }, { "__type": "Blockquote", "__tag": 4059, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "See " }, { "__type": "InlineRole", "__tag": 4003, "value": "dev-arrayapi", "domain": null, "role": "ref", "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " for more information." } ] } ] } ], "title": [], "level": 0, "target": null }, "Warns": { "__type": "Section", "__tag": 4015, "children": [], "title": [], "level": 0, "target": null }, "Raises": { "__type": "Section", "__tag": 4015, "children": [], "title": [], "level": 0, "target": null }, "Yields": { "__type": "Section", "__tag": 4015, "children": [], "title": [], "level": 0, "target": null }, "Methods": { "__type": "Section", "__tag": 4015, "children": [], "title": [], "level": 0, "target": null }, "Returns": { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Parameters", "__tag": 4026, "children": [ { "__type": "DocParam", "__tag": 4016, "name": "", "annotation": "Bunch object with the following fields defined:", "desc": [] }, { "__type": "DocParam", "__tag": 4016, "name": "t", "annotation": "ndarray, shape (n_points,)", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Time points." } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "y", "annotation": "ndarray, shape (n, n_points)", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Values of the solution at " }, { "__type": "CrossRef", "__tag": 4002, "value": "t", "reference": { "__type": "RefInfo", "__tag": 4000, "module": null, "version": null, "kind": "local", "path": "t" }, "kind": "local" }, { "__type": "Text", "__tag": 4046, "value": "." } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "sol", "annotation": "`OdeSolution` or None", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Found solution as " }, { "__type": "CrossRef", "__tag": 4002, "value": "OdeSolution", "reference": { "__type": "LocalRef", "__tag": 4022, "kind": "module", "path": "scipy.integrate._ivp.common:OdeSolution" }, "kind": "module" }, { "__type": "Text", "__tag": 4046, "value": " instance; None if " }, { "__type": "ParamRef", "__tag": 4071, "name": "dense_output" }, { "__type": "Text", "__tag": 4046, "value": " was set to False." } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "t_events", "annotation": "list of ndarray or None", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Contains for each event type a list of arrays at which an event of that type event was detected. None if " }, { "__type": "ParamRef", "__tag": 4071, "name": "events" }, { "__type": "Text", "__tag": 4046, "value": " was None." } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "y_events", "annotation": "list of ndarray or None", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "For each value of " }, { "__type": "CrossRef", "__tag": 4002, "value": "t_events", "reference": { "__type": "RefInfo", "__tag": 4000, "module": null, "version": null, "kind": "local", "path": "t_events" }, "kind": "local" }, { "__type": "Text", "__tag": 4046, "value": ", the corresponding value of the solution. None if " }, { "__type": "ParamRef", "__tag": 4071, "name": "events" }, { "__type": "Text", "__tag": 4046, "value": " was None." } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "nfev", "annotation": "int", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Number of evaluations of the right-hand side." } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "njev", "annotation": "int", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Number of evaluations of the Jacobian." } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "nlu", "annotation": "int", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Number of LU decompositions." } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "status", "annotation": "int", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Reason for algorithm termination:" } ] }, { "__type": "Blockquote", "__tag": 4059, "children": [ { "__type": "BulletList", "__tag": 4053, "ordered": false, "start": 1, "children": [ { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "-1: Integration step failed." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "0: The solver successfully reached the end of " }, { "__type": "InlineRole", "__tag": 4003, "value": "tspan", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": "." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "1: A termination event occurred." } ] } ] } ] } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "message", "annotation": "string", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Human-readable description of the termination reason." } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "success", "annotation": "bool", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "True if the solver reached the interval end or a termination event occurred (" }, { "__type": "InlineCode", "__tag": 4051, "value": "status >= 0" }, { "__type": "Text", "__tag": 4046, "value": ")." } ] } ] } ] } ], "title": [], "level": 0, "target": null }, "Summary": { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Solve an initial value problem for a system of ODEs." } ] } ], "title": [], "level": 0, "target": null }, "Receives": { "__type": "Section", "__tag": 4015, "children": [], "title": [], "level": 0, "target": null }, "Warnings": { "__type": "Section", "__tag": 4015, "children": [], "title": [], "level": 0, "target": null }, "Attributes": { "__type": "Section", "__tag": 4015, "children": [], "title": [], "level": 0, "target": null }, "Parameters": { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Parameters", "__tag": 4026, "children": [ { "__type": "DocParam", "__tag": 4016, "name": "fun", "annotation": "callable", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Right-hand side of the system: the time derivative of the state " }, { "__type": "InlineCode", "__tag": 4051, "value": "y" }, { "__type": "Text", "__tag": 4046, "value": " at time " }, { "__type": "InlineCode", "__tag": 4051, "value": "t" }, { "__type": "Text", "__tag": 4046, "value": ". The calling signature is " }, { "__type": "InlineCode", "__tag": 4051, "value": "fun(t, y)" }, { "__type": "Text", "__tag": 4046, "value": ", where " }, { "__type": "InlineCode", "__tag": 4051, "value": "t" }, { "__type": "Text", "__tag": 4046, "value": " is a scalar and " }, { "__type": "InlineCode", "__tag": 4051, "value": "y" }, { "__type": "Text", "__tag": 4046, "value": " is an ndarray with " }, { "__type": "InlineCode", "__tag": 4051, "value": "len(y) = len(y0)" }, { "__type": "Text", "__tag": 4046, "value": ". Additional arguments need to be passed if " }, { "__type": "InlineCode", "__tag": 4051, "value": "args" }, { "__type": "Text", "__tag": 4046, "value": " is used (see documentation of " }, { "__type": "InlineCode", "__tag": 4051, "value": "args" }, { "__type": "Text", "__tag": 4046, "value": " argument). " }, { "__type": "InlineCode", "__tag": 4051, "value": "fun" }, { "__type": "Text", "__tag": 4046, "value": " must return an array of the same shape as " }, { "__type": "InlineCode", "__tag": 4051, "value": "y" }, { "__type": "Text", "__tag": 4046, "value": ". See " }, { "__type": "ParamRef", "__tag": 4071, "name": "vectorized" }, { "__type": "Text", "__tag": 4046, "value": " for more information." } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "t_span", "annotation": "2-member sequence", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Interval of integration (t0, tf). The solver starts with t=t0 and integrates until it reaches t=tf. Both t0 and tf must be floats or values interpretable by the float conversion function." } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "y0", "annotation": "array_like, shape (n,)", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Initial state. For problems in the complex domain, pass " }, { "__type": "ParamRef", "__tag": 4071, "name": "y0" }, { "__type": "Text", "__tag": 4046, "value": " with a complex data type (even if the initial value is purely real)." } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "method", "annotation": "string or `OdeSolver`, optional", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Integration method to use:" } ] }, { "__type": "Blockquote", "__tag": 4059, "children": [ { "__type": "BulletList", "__tag": 4053, "ordered": false, "start": 1, "children": [ { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "'RK45' (default): Explicit Runge-Kutta method of order 5(4) " }, { "__type": "FootnoteReference", "__tag": 4066, "label": "1" }, { "__type": "Text", "__tag": 4046, "value": ". The error is controlled assuming accuracy of the fourth-order method, but steps are taken using the fifth-order accurate formula (local extrapolation is done). A quartic interpolation polynomial is used for the dense output " }, { "__type": "FootnoteReference", "__tag": 4066, "label": "2" }, { "__type": "Text", "__tag": 4046, "value": ". Can be applied in the complex domain." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "'RK23': Explicit Runge-Kutta method of order 3(2) " }, { "__type": "FootnoteReference", "__tag": 4066, "label": "3" }, { "__type": "Text", "__tag": 4046, "value": ". The error is controlled assuming accuracy of the second-order method, but steps are taken using the third-order accurate formula (local extrapolation is done). A cubic Hermite polynomial is used for the dense output. Can be applied in the complex domain." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "'DOP853': Explicit Runge-Kutta method of order 8 " }, { "__type": "FootnoteReference", "__tag": 4066, "label": "13" }, { "__type": "Text", "__tag": 4046, "value": ". Python implementation of the \"DOP853\" algorithm originally written in Fortran " }, { "__type": "FootnoteReference", "__tag": 4066, "label": "14" }, { "__type": "Text", "__tag": 4046, "value": ". A 7-th order interpolation polynomial accurate to 7-th order is used for the dense output. Can be applied in the complex domain." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "'Radau': Implicit Runge-Kutta method of the Radau IIA family of order 5 " }, { "__type": "FootnoteReference", "__tag": 4066, "label": "4" }, { "__type": "Text", "__tag": 4046, "value": ". The error is controlled with a third-order accurate embedded formula. A cubic polynomial which satisfies the collocation conditions is used for the dense output." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "'BDF': Implicit multi-step variable-order (1 to 5) method based on a backward differentiation formula for the derivative approximation " }, { "__type": "FootnoteReference", "__tag": 4066, "label": "5" }, { "__type": "Text", "__tag": 4046, "value": ". The implementation follows the one described in " }, { "__type": "FootnoteReference", "__tag": 4066, "label": "6" }, { "__type": "Text", "__tag": 4046, "value": ". A quasi-constant step scheme is used and accuracy is enhanced using the NDF modification. Can be applied in the complex domain." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "'LSODA': Adams/BDF method with automatic stiffness detection and switching " }, { "__type": "FootnoteReference", "__tag": 4066, "label": "7" }, { "__type": "Text", "__tag": 4046, "value": ", " }, { "__type": "FootnoteReference", "__tag": 4066, "label": "8" }, { "__type": "Text", "__tag": 4046, "value": ". This is a wrapper of the Fortran solver from ODEPACK." } ] } ] } ] } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Explicit Runge-Kutta methods ('RK23', 'RK45', 'DOP853') should be used for non-stiff problems and implicit methods ('Radau', 'BDF') for stiff problems " }, { "__type": "FootnoteReference", "__tag": 4066, "label": "9" }, { "__type": "Text", "__tag": 4046, "value": ". Among Runge-Kutta methods, 'DOP853' is recommended for solving with high precision (low values of " }, { "__type": "CrossRef", "__tag": 4002, "value": "rtol", "reference": { "__type": "RefInfo", "__tag": 4000, "module": null, "version": null, "kind": "local", "path": "rtol" }, "kind": "local" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "CrossRef", "__tag": 4002, "value": "atol", "reference": { "__type": "RefInfo", "__tag": 4000, "module": null, "version": null, "kind": "local", "path": "atol" }, "kind": "local" }, { "__type": "Text", "__tag": 4046, "value": ")." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "If not sure, first try to run 'RK45'. If it makes unusually many iterations, diverges, or fails, your problem is likely to be stiff and you should use 'Radau' or 'BDF'. 'LSODA' can also be a good universal choice, but it might be somewhat less convenient to work with as it wraps old Fortran code." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "You can also pass an arbitrary class derived from " }, { "__type": "CrossRef", "__tag": 4002, "value": "OdeSolver", "reference": { "__type": "LocalRef", "__tag": 4022, "kind": "module", "path": "scipy.integrate._ivp.base:OdeSolver" }, "kind": "module" }, { "__type": "Text", "__tag": 4046, "value": " which implements the solver." } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "t_eval", "annotation": "array_like or None, optional", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Times at which to store the computed solution, must be sorted and lie within " }, { "__type": "ParamRef", "__tag": 4071, "name": "t_span" }, { "__type": "Text", "__tag": 4046, "value": ". If None (default), use points selected by the solver." } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "dense_output", "annotation": "bool, optional", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Whether to compute a continuous solution. Default is False." } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "events", "annotation": "callable, or list of callables, optional", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Events to track. If None (default), no events will be tracked. Each event occurs at the zeros of a continuous function of time and state. Each function must have the signature " }, { "__type": "InlineCode", "__tag": 4051, "value": "event(t, y)" }, { "__type": "Text", "__tag": 4046, "value": " where additional argument have to be passed if " }, { "__type": "InlineCode", "__tag": 4051, "value": "args" }, { "__type": "Text", "__tag": 4046, "value": " is used (see documentation of " }, { "__type": "InlineCode", "__tag": 4051, "value": "args" }, { "__type": "Text", "__tag": 4046, "value": " argument). Each function must return a float. The solver will find an accurate value of " }, { "__type": "CrossRef", "__tag": 4002, "value": "t", "reference": { "__type": "RefInfo", "__tag": 4000, "module": null, "version": null, "kind": "local", "path": "t" }, "kind": "local" }, { "__type": "Text", "__tag": 4046, "value": " at which " }, { "__type": "InlineCode", "__tag": 4051, "value": "event(t, y(t)) = 0" }, { "__type": "Text", "__tag": 4046, "value": " using a root-finding algorithm. By default, all zeros will be found. The solver looks for a sign change over each step, so if multiple zero crossings occur within one step, events may be missed. Additionally each " }, { "__type": "InlineRole", "__tag": 4003, "value": "event", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " function might have the following attributes:" } ] }, { "__type": "Blockquote", "__tag": 4059, "children": [ { "__type": "DefList", "__tag": 4033, "children": [ { "__type": "DefListItem", "__tag": 4037, "dt": { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "terminal: bool or int, optional" } ] }, "dd": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "When boolean, whether to terminate integration if this event occurs. When integral, termination occurs after the specified the number of occurrences of this event. Implicitly False if not assigned." } ] } ] }, { "__type": "DefListItem", "__tag": 4037, "dt": { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "direction: float, optional" } ] }, "dd": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Direction of a zero crossing. If " }, { "__type": "InlineRole", "__tag": 4003, "value": "direction", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " is positive, " }, { "__type": "InlineRole", "__tag": 4003, "value": "event", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " will only trigger when going from negative to positive, and vice versa if " }, { "__type": "InlineRole", "__tag": 4003, "value": "direction", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " is negative. If 0, then either direction will trigger event. Implicitly 0 if not assigned." } ] } ] } ] } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "You can assign attributes like " }, { "__type": "InlineCode", "__tag": 4051, "value": "event.terminal = True" }, { "__type": "Text", "__tag": 4046, "value": " to any function in Python." } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "vectorized", "annotation": "bool, optional", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Whether " }, { "__type": "ParamRef", "__tag": 4071, "name": "fun" }, { "__type": "Text", "__tag": 4046, "value": " can be called in a vectorized fashion. Default is False." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "If " }, { "__type": "InlineCode", "__tag": 4051, "value": "vectorized" }, { "__type": "Text", "__tag": 4046, "value": " is False, " }, { "__type": "ParamRef", "__tag": 4071, "name": "fun" }, { "__type": "Text", "__tag": 4046, "value": " will always be called with " }, { "__type": "InlineCode", "__tag": 4051, "value": "y" }, { "__type": "Text", "__tag": 4046, "value": " of shape " }, { "__type": "InlineCode", "__tag": 4051, "value": "(n,)" }, { "__type": "Text", "__tag": 4046, "value": ", where " }, { "__type": "InlineCode", "__tag": 4051, "value": "n = len(y0)" }, { "__type": "Text", "__tag": 4046, "value": "." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "If " }, { "__type": "InlineCode", "__tag": 4051, "value": "vectorized" }, { "__type": "Text", "__tag": 4046, "value": " is True, " }, { "__type": "ParamRef", "__tag": 4071, "name": "fun" }, { "__type": "Text", "__tag": 4046, "value": " may be called with " }, { "__type": "InlineCode", "__tag": 4051, "value": "y" }, { "__type": "Text", "__tag": 4046, "value": " of shape " }, { "__type": "InlineCode", "__tag": 4051, "value": "(n, k)" }, { "__type": "Text", "__tag": 4046, "value": ", where " }, { "__type": "InlineCode", "__tag": 4051, "value": "k" }, { "__type": "Text", "__tag": 4046, "value": " is an integer. In this case, " }, { "__type": "ParamRef", "__tag": 4071, "name": "fun" }, { "__type": "Text", "__tag": 4046, "value": " must behave such that " }, { "__type": "InlineCode", "__tag": 4051, "value": "fun(t, y)[:, i] == fun(t, y[:, i])" }, { "__type": "Text", "__tag": 4046, "value": " (i.e. each column of the returned array is the time derivative of the state corresponding with a column of " }, { "__type": "InlineCode", "__tag": 4051, "value": "y" }, { "__type": "Text", "__tag": 4046, "value": ")." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Setting " }, { "__type": "InlineCode", "__tag": 4051, "value": "vectorized=True" }, { "__type": "Text", "__tag": 4046, "value": " allows for faster finite difference approximation of the Jacobian by methods 'Radau' and 'BDF', but will result in slower execution for other methods and for 'Radau' and 'BDF' in some circumstances (e.g. small " }, { "__type": "InlineCode", "__tag": 4051, "value": "len(y0)" }, { "__type": "Text", "__tag": 4046, "value": ")." } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "args", "annotation": "tuple, optional", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Additional arguments to pass to the user-defined functions. If given, the additional arguments are passed to all user-defined functions. So if, for example, " }, { "__type": "ParamRef", "__tag": 4071, "name": "fun" }, { "__type": "Text", "__tag": 4046, "value": " has the signature " }, { "__type": "InlineCode", "__tag": 4051, "value": "fun(t, y, a, b, c)" }, { "__type": "Text", "__tag": 4046, "value": ", then " }, { "__type": "CrossRef", "__tag": 4002, "value": "jac", "reference": { "__type": "RefInfo", "__tag": 4000, "module": null, "version": null, "kind": "local", "path": "jac" }, "kind": "local" }, { "__type": "Text", "__tag": 4046, "value": " (if given) and any event functions must have the same signature, and " }, { "__type": "ParamRef", "__tag": 4071, "name": "args" }, { "__type": "Text", "__tag": 4046, "value": " must be a tuple of length 3." } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "**options", "annotation": "", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Options passed to a chosen solver. All options available for already implemented solvers are listed below." } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "first_step", "annotation": "float or None, optional", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Initial step size. Default is " }, { "__type": "InlineRole", "__tag": 4003, "value": "None", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " which means that the algorithm should choose." } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "max_step", "annotation": "float, optional", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Maximum allowed step size. Default is np.inf, i.e., the step size is not bounded and determined solely by the solver." } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "rtol, atol", "annotation": "float or array_like, optional", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Relative and absolute tolerances. The solver keeps the local error estimates less than " }, { "__type": "InlineCode", "__tag": 4051, "value": "atol + rtol * abs(y)" }, { "__type": "Text", "__tag": 4046, "value": ". Here " }, { "__type": "CrossRef", "__tag": 4002, "value": "rtol", "reference": { "__type": "RefInfo", "__tag": 4000, "module": null, "version": null, "kind": "local", "path": "rtol" }, "kind": "local" }, { "__type": "Text", "__tag": 4046, "value": " controls a relative accuracy (number of correct digits), while " }, { "__type": "CrossRef", "__tag": 4002, "value": "atol", "reference": { "__type": "RefInfo", "__tag": 4000, "module": null, "version": null, "kind": "local", "path": "atol" }, "kind": "local" }, { "__type": "Text", "__tag": 4046, "value": " controls absolute accuracy (number of correct decimal places). To achieve the desired " }, { "__type": "CrossRef", "__tag": 4002, "value": "rtol", "reference": { "__type": "RefInfo", "__tag": 4000, "module": null, "version": null, "kind": "local", "path": "rtol" }, "kind": "local" }, { "__type": "Text", "__tag": 4046, "value": ", set " }, { "__type": "CrossRef", "__tag": 4002, "value": "atol", "reference": { "__type": "RefInfo", "__tag": 4000, "module": null, "version": null, "kind": "local", "path": "atol" }, "kind": "local" }, { "__type": "Text", "__tag": 4046, "value": " to be smaller than the smallest value that can be expected from " }, { "__type": "InlineCode", "__tag": 4051, "value": "rtol * abs(y)" }, { "__type": "Text", "__tag": 4046, "value": " so that " }, { "__type": "CrossRef", "__tag": 4002, "value": "rtol", "reference": { "__type": "RefInfo", "__tag": 4000, "module": null, "version": null, "kind": "local", "path": "rtol" }, "kind": "local" }, { "__type": "Text", "__tag": 4046, "value": " dominates the allowable error. If " }, { "__type": "CrossRef", "__tag": 4002, "value": "atol", "reference": { "__type": "RefInfo", "__tag": 4000, "module": null, "version": null, "kind": "local", "path": "atol" }, "kind": "local" }, { "__type": "Text", "__tag": 4046, "value": " is larger than " }, { "__type": "InlineCode", "__tag": 4051, "value": "rtol * abs(y)" }, { "__type": "Text", "__tag": 4046, "value": " the number of correct digits is not guaranteed. Conversely, to achieve the desired " }, { "__type": "CrossRef", "__tag": 4002, "value": "atol", "reference": { "__type": "RefInfo", "__tag": 4000, "module": null, "version": null, "kind": "local", "path": "atol" }, "kind": "local" }, { "__type": "Text", "__tag": 4046, "value": " set " }, { "__type": "CrossRef", "__tag": 4002, "value": "rtol", "reference": { "__type": "RefInfo", "__tag": 4000, "module": null, "version": null, "kind": "local", "path": "rtol" }, "kind": "local" }, { "__type": "Text", "__tag": 4046, "value": " such that " }, { "__type": "InlineCode", "__tag": 4051, "value": "rtol * abs(y)" }, { "__type": "Text", "__tag": 4046, "value": " is always smaller than " }, { "__type": "CrossRef", "__tag": 4002, "value": "atol", "reference": { "__type": "RefInfo", "__tag": 4000, "module": null, "version": null, "kind": "local", "path": "atol" }, "kind": "local" }, { "__type": "Text", "__tag": 4046, "value": ". If components of y have different scales, it might be beneficial to set different " }, { "__type": "CrossRef", "__tag": 4002, "value": "atol", "reference": { "__type": "RefInfo", "__tag": 4000, "module": null, "version": null, "kind": "local", "path": "atol" }, "kind": "local" }, { "__type": "Text", "__tag": 4046, "value": " values for different components by passing array_like with shape (n,) for " }, { "__type": "CrossRef", "__tag": 4002, "value": "atol", "reference": { "__type": "RefInfo", "__tag": 4000, "module": null, "version": null, "kind": "local", "path": "atol" }, "kind": "local" }, { "__type": "Text", "__tag": 4046, "value": ". Default values are 1e-3 for " }, { "__type": "CrossRef", "__tag": 4002, "value": "rtol", "reference": { "__type": "RefInfo", "__tag": 4000, "module": null, "version": null, "kind": "local", "path": "rtol" }, "kind": "local" }, { "__type": "Text", "__tag": 4046, "value": " and 1e-6 for " }, { "__type": "CrossRef", "__tag": 4002, "value": "atol", "reference": { "__type": "RefInfo", "__tag": 4000, "module": null, "version": null, "kind": "local", "path": "atol" }, "kind": "local" }, { "__type": "Text", "__tag": 4046, "value": "." } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "jac", "annotation": "array_like, sparse_matrix, callable or None, optional", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Jacobian matrix of the right-hand side of the system with respect to y, required by the 'Radau', 'BDF' and 'LSODA' method. The Jacobian matrix has shape (n, n) and its element (i, j) is equal to " }, { "__type": "InlineCode", "__tag": 4051, "value": "d f_i / d y_j" }, { "__type": "Text", "__tag": 4046, "value": ". There are three ways to define the Jacobian:" } ] }, { "__type": "Blockquote", "__tag": 4059, "children": [ { "__type": "BulletList", "__tag": 4053, "ordered": false, "start": 1, "children": [ { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "If array_like or sparse_matrix, the Jacobian is assumed to be constant. Not supported by 'LSODA'." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "If callable, the Jacobian is assumed to depend on both t and y; it will be called as " }, { "__type": "InlineCode", "__tag": 4051, "value": "jac(t, y)" }, { "__type": "Text", "__tag": 4046, "value": ", as necessary. Additional arguments have to be passed if " }, { "__type": "InlineCode", "__tag": 4051, "value": "args" }, { "__type": "Text", "__tag": 4046, "value": " is used (see documentation of " }, { "__type": "InlineCode", "__tag": 4051, "value": "args" }, { "__type": "Text", "__tag": 4046, "value": " argument). For 'Radau' and 'BDF' methods, the return value might be a sparse matrix." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "If None (default), the Jacobian will be approximated by finite differences." } ] } ] } ] } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "It is generally recommended to provide the Jacobian rather than relying on a finite-difference approximation." } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "jac_sparsity", "annotation": "array_like, sparse matrix or None, optional", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Defines a sparsity structure of the Jacobian matrix for a finite- difference approximation. Its shape must be (n, n). This argument is ignored if " }, { "__type": "CrossRef", "__tag": 4002, "value": "jac", "reference": { "__type": "RefInfo", "__tag": 4000, "module": null, "version": null, "kind": "local", "path": "jac" }, "kind": "local" }, { "__type": "Text", "__tag": 4046, "value": " is not " }, { "__type": "InlineRole", "__tag": 4003, "value": "None", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": ". If the Jacobian has only few non-zero elements in " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "each" } ] }, { "__type": "Text", "__tag": 4046, "value": " row, providing the sparsity structure will greatly speed up the computations " }, { "__type": "FootnoteReference", "__tag": 4066, "label": "10" }, { "__type": "Text", "__tag": 4046, "value": ". A zero entry means that a corresponding element in the Jacobian is always zero. If None (default), the Jacobian is assumed to be dense. Not supported by 'LSODA', see " }, { "__type": "CrossRef", "__tag": 4002, "value": "lband", "reference": { "__type": "RefInfo", "__tag": 4000, "module": null, "version": null, "kind": "local", "path": "lband" }, "kind": "local" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "CrossRef", "__tag": 4002, "value": "uband", "reference": { "__type": "RefInfo", "__tag": 4000, "module": null, "version": null, "kind": "local", "path": "uband" }, "kind": "local" }, { "__type": "Text", "__tag": 4046, "value": " instead." } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "lband, uband", "annotation": "int or None, optional", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Parameters defining the bandwidth of the Jacobian for the 'LSODA' method, i.e., " }, { "__type": "InlineCode", "__tag": 4051, "value": "jac[i, j] != 0 only for i - lband <= j <= i + uband" }, { "__type": "Text", "__tag": 4046, "value": ". Default is None. Setting these requires your jac routine to return the Jacobian in the packed format: the returned array must have " }, { "__type": "InlineCode", "__tag": 4051, "value": "n" }, { "__type": "Text", "__tag": 4046, "value": " columns and " }, { "__type": "InlineCode", "__tag": 4051, "value": "uband + lband + 1" }, { "__type": "Text", "__tag": 4046, "value": " rows in which Jacobian diagonals are written. Specifically " }, { "__type": "InlineCode", "__tag": 4051, "value": "jac_packed[uband + i - j , j] = jac[i, j]" }, { "__type": "Text", "__tag": 4046, "value": ". The same format is used in " }, { "__type": "CrossRef", "__tag": 4002, "value": "scipy.linalg.solve_banded", "reference": { "__type": "RefInfo", "__tag": 4000, "module": "scipy", "version": "*", "kind": "api", "path": "scipy.linalg._basic:solve_banded" }, "kind": "module" }, { "__type": "Text", "__tag": 4046, "value": " (check for an illustration). These parameters can be also used with " }, { "__type": "InlineCode", "__tag": 4051, "value": "jac=None" }, { "__type": "Text", "__tag": 4046, "value": " to reduce the number of Jacobian elements estimated by finite differences." } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "min_step", "annotation": "float, optional", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The minimum allowed step size for 'LSODA' method. By default " }, { "__type": "CrossRef", "__tag": 4002, "value": "min_step", "reference": { "__type": "RefInfo", "__tag": 4000, "module": null, "version": null, "kind": "local", "path": "min_step" }, "kind": "local" }, { "__type": "Text", "__tag": 4046, "value": " is zero." } ] } ] } ] } ], "title": [], "level": 0, "target": null }, "Extended Summary": { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "This function numerically integrates a system of ordinary differential equations given an initial value " } ] }, { "__type": "Code", "__tag": 4050, "value": "dy / dt = f(t, y)\ny(t0) = y0", "execution_status": null }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Here t is a 1-D independent variable (time), y(t) is an N-D vector-valued function (state), and an N-D vector-valued function f(t, y) determines the differential equations. The goal is to find y(t) approximately satisfying the differential equations, given an initial value y(t0)=y0." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Some of the solvers support integration in the complex domain, but note that for stiff ODE solvers, the right-hand side must be complex-differentiable (satisfy Cauchy-Riemann equations " }, { "__type": "FootnoteReference", "__tag": 4066, "label": "11" }, { "__type": "Text", "__tag": 4046, "value": "). To solve a problem in the complex domain, pass y0 with a complex data type. Another option always available is to rewrite your problem for real and imaginary parts separately." } ] } ], "title": [], "level": 0, "target": null }, "Other Parameters": { "__type": "Section", "__tag": 4015, "children": [], "title": [], "level": 0, "target": null } }, "_ordered_sections": [ "Summary", "Extended Summary", "Parameters", "Attributes", "Methods", "Returns", "Yields", "Receives", "Other Parameters", "Raises", "Warns", "Warnings", "Notes" ], "item_file": "/scipy/integrate/_ivp/ivp.py", "item_line": 160, "item_type": "function", "aliases": [ "scipy.integrate.solve_ivp" ], "example_section_data": { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Text", "__tag": 4046, "value": "Basic exponential decay showing automatically chosen time points.\n\n" }, { "__type": "Code", "__tag": 4050, "value": "import numpy as np\nfrom scipy.integrate import solve_ivp\ndef exponential_decay(t, y): return -0.5 * y\nsol = solve_ivp(exponential_decay, [0, 10], [2, 4, 8])\n", "execution_status": "success" }, { "__type": "Code", "__tag": 4050, "value": "print(sol.t)\nprint(sol.y)\n", "execution_status": "failure" }, { "__type": "Text", "__tag": 4046, "value": "\nSpecifying points where the solution is desired.\n\n" }, { "__type": "Code", "__tag": 4050, "value": "sol = solve_ivp(exponential_decay, [0, 10], [2, 4, 8],\n t_eval=[0, 1, 2, 4, 10])\nprint(sol.t)\n", "execution_status": "success" }, { "__type": "Code", "__tag": 4050, "value": "print(sol.y)\n", "execution_status": "failure" }, { "__type": "Text", "__tag": 4046, "value": "\nCannon fired upward with terminal event upon impact. The ``terminal`` and\n``direction`` fields of an event are applied by monkey patching a function.\nHere ``y[0]`` is position and ``y[1]`` is velocity. The projectile starts\nat position 0 with velocity +10. Note that the integration never reaches\nt=100 because the event is terminal.\n\n" }, { "__type": "Code", "__tag": 4050, "value": "def upward_cannon(t, y): return [y[1], -0.5]\ndef hit_ground(t, y): return y[0]\nhit_ground.terminal = True\nhit_ground.direction = -1\nsol = solve_ivp(upward_cannon, [0, 100], [0, 10], events=hit_ground)\nprint(sol.t_events)\n", "execution_status": "success" }, { "__type": "Code", "__tag": 4050, "value": "print(sol.t)\n", "execution_status": "failure" }, { "__type": "Text", "__tag": 4046, "value": "\nUse `dense_output` and `events` to find position, which is 100, at the apex\nof the cannonball's trajectory. Apex is not defined as terminal, so both\napex and hit_ground are found. There is no information at t=20, so the sol\nattribute is used to evaluate the solution. The sol attribute is returned\nby setting ``dense_output=True``. Alternatively, the `y_events` attribute\ncan be used to access the solution at the time of the event.\n\n" }, { "__type": "Code", "__tag": 4050, "value": "def apex(t, y): return y[1]\nsol = solve_ivp(upward_cannon, [0, 100], [0, 10],\n events=(hit_ground, apex), dense_output=True)\nprint(sol.t_events)\n", "execution_status": "success" }, { "__type": "Code", "__tag": 4050, "value": "print(sol.t)\nprint(sol.sol(sol.t_events[1][0]))\nprint(sol.y_events)\n", "execution_status": "failure" }, { "__type": "Text", "__tag": 4046, "value": "\nAs an example of a system with additional parameters, we'll implement\nthe Lotka-Volterra equations [12]_.\n\n" }, { "__type": "Code", "__tag": 4050, "value": "def lotkavolterra(t, z, a, b, c, d):\n x, y = z\n return [a*x - b*x*y, -c*y + d*x*y]\n", "execution_status": "success" }, { "__type": "Text", "__tag": 4046, "value": "\nWe pass in the parameter values a=1.5, b=1, c=3 and d=1 with the `args`\nargument.\n\n" }, { "__type": "Code", "__tag": 4050, "value": "sol = solve_ivp(lotkavolterra, [0, 15], [10, 5], args=(1.5, 1, 3, 1),\n dense_output=True)\n", "execution_status": "success" }, { "__type": "Text", "__tag": 4046, "value": "\nCompute a dense solution and plot it.\n\n" }, { "__type": "Code", "__tag": 4050, "value": "t = np.linspace(0, 15, 300)\nz = sol.sol(t)\nimport matplotlib.pyplot as plt\n", "execution_status": "success" }, { "__type": "Code", "__tag": 4050, "value": "plt.plot(t, z.T)\nplt.xlabel('t')\nplt.legend(['x', 'y'], shadow=True)\nplt.title('Lotka-Volterra System')\n", "execution_status": "failure" }, { "__type": "Code", "__tag": 4050, "value": "plt.show()\n", "execution_status": "success" }, { "__type": "Figure", "__tag": 4024, "value": { "__type": "RefInfo", "__tag": 4000, "module": "scipy", "version": "1.17.1", "kind": "assets", "path": "fig-553fcb475ab90022.png" } }, { "__type": "Text", "__tag": 4046, "value": "\nA couple examples of using solve_ivp to solve the differential\nequation ``y' = Ay`` with complex matrix ``A``.\n\n" }, { "__type": "Code", "__tag": 4050, "value": "A = np.array([[-0.25 + 0.14j, 0, 0.33 + 0.44j],\n [0.25 + 0.58j, -0.2 + 0.14j, 0],\n [0, 0.2 + 0.4j, -0.1 + 0.97j]])\n", "execution_status": "success" }, { "__type": "Text", "__tag": 4046, "value": "\nSolving an IVP with ``A`` from above and ``y`` as 3x1 vector:\n\n" }, { "__type": "Code", "__tag": 4050, "value": "def deriv_vec(t, y):\n return A @ y\nresult = solve_ivp(deriv_vec, [0, 25],\n np.array([10 + 0j, 20 + 0j, 30 + 0j]),\n t_eval=np.linspace(0, 25, 101))\nprint(result.y[:, 0])\n", "execution_status": "success" }, { "__type": "Code", "__tag": 4050, "value": "print(result.y[:, -1])\n", "execution_status": "failure" }, { "__type": "Text", "__tag": 4046, "value": "\nSolving an IVP with ``A`` from above with ``y`` as 3x3 matrix :\n\n" }, { "__type": "Code", "__tag": 4050, "value": "def deriv_mat(t, y):\n return (A @ y.reshape(3, 3)).flatten()\ny0 = np.array([[2 + 0j, 3 + 0j, 4 + 0j],\n [5 + 0j, 6 + 0j, 7 + 0j],\n [9 + 0j, 34 + 0j, 78 + 0j]])\n", "execution_status": "success" }, { "__type": "Text", "__tag": 4046, "value": "\n" }, { "__type": "Code", "__tag": 4050, "value": "result = solve_ivp(deriv_mat, [0, 25], y0.flatten(),\n t_eval=np.linspace(0, 25, 101))\nprint(result.y[:, 0].reshape(3, 3))\n", "execution_status": "success" }, { "__type": "Code", "__tag": 4050, "value": "print(result.y[:, -1].reshape(3, 3))\n", "execution_status": "failure" } ], "title": [], "level": 0, "target": null }, "see_also": [], "signature": { "__type": "SignatureNode", "__tag": 4029, "kind": "function", "parameters": [ { "__type": "SigParam", "__tag": 4030, "name": "fun", "annotation": { "__type": "Empty", "__tag": 4031 }, "kind": "POSITIONAL_OR_KEYWORD", "default": { "__type": "Empty", "__tag": 4031 } }, { "__type": "SigParam", "__tag": 4030, "name": "t_span", "annotation": { "__type": "Empty", "__tag": 4031 }, "kind": "POSITIONAL_OR_KEYWORD", "default": { "__type": "Empty", "__tag": 4031 } }, { "__type": "SigParam", "__tag": 4030, "name": "y0", "annotation": { "__type": "Empty", "__tag": 4031 }, "kind": "POSITIONAL_OR_KEYWORD", "default": { "__type": "Empty", "__tag": 4031 } }, { "__type": "SigParam", "__tag": 4030, "name": "method", "annotation": { "__type": "Empty", "__tag": 4031 }, "kind": "POSITIONAL_OR_KEYWORD", "default": "RK45" }, { "__type": "SigParam", "__tag": 4030, "name": "t_eval", "annotation": { "__type": "Empty", "__tag": 4031 }, "kind": "POSITIONAL_OR_KEYWORD", "default": "None" }, { "__type": "SigParam", "__tag": 4030, "name": "dense_output", "annotation": { "__type": "Empty", "__tag": 4031 }, "kind": "POSITIONAL_OR_KEYWORD", "default": "False" }, { "__type": "SigParam", "__tag": 4030, "name": "events", "annotation": { "__type": "Empty", "__tag": 4031 }, "kind": "POSITIONAL_OR_KEYWORD", "default": "None" }, { "__type": "SigParam", "__tag": 4030, "name": "vectorized", "annotation": { "__type": "Empty", "__tag": 4031 }, "kind": "POSITIONAL_OR_KEYWORD", "default": "False" }, { "__type": "SigParam", "__tag": 4030, "name": "args", "annotation": { "__type": "Empty", "__tag": 4031 }, "kind": "POSITIONAL_OR_KEYWORD", "default": "None" }, { "__type": "SigParam", "__tag": 4030, "name": "options", "annotation": { "__type": "Empty", "__tag": 4031 }, "kind": "VAR_KEYWORD", "default": { "__type": "Empty", "__tag": 4031 } } ], "return_annotation": { "__type": "Empty", "__tag": 4031 }, "target_name": "solve_ivp" }, "references": [ ".. [1] J. R. Dormand, P. J. Prince, \"A family of embedded Runge-Kutta", " formulae\", Journal of Computational and Applied Mathematics, Vol. 6,", " No. 1, pp. 19-26, 1980.", ".. [2] L. W. Shampine, \"Some Practical Runge-Kutta Formulas\", Mathematics", " of Computation,, Vol. 46, No. 173, pp. 135-150, 1986.", ".. [3] P. Bogacki, L.F. Shampine, \"A 3(2) Pair of Runge-Kutta Formulas\",", " Appl. Math. Lett. Vol. 2, No. 4. pp. 321-325, 1989.", ".. [4] E. Hairer, G. Wanner, \"Solving Ordinary Differential Equations II:", " Stiff and Differential-Algebraic Problems\", Sec. IV.8.", ".. [5] `Backward Differentiation Formula", " `_", " on Wikipedia.", ".. [6] L. F. Shampine, M. W. Reichelt, \"THE MATLAB ODE SUITE\", SIAM J. SCI.", " COMPUTE., Vol. 18, No. 1, pp. 1-22, January 1997.", ".. [7] A. C. Hindmarsh, \"ODEPACK, A Systematized Collection of ODE", " Solvers,\" IMACS Transactions on Scientific Computation, Vol 1.,", " pp. 55-64, 1983.", ".. [8] L. Petzold, \"Automatic selection of methods for solving stiff and", " nonstiff systems of ordinary differential equations\", SIAM Journal", " on Scientific and Statistical Computing, Vol. 4, No. 1, pp. 136-148,", " 1983.", ".. [9] `Stiff equation `_ on", " Wikipedia.", ".. [10] A. Curtis, M. J. D. Powell, and J. Reid, \"On the estimation of", " sparse Jacobian matrices\", Journal of the Institute of Mathematics", " and its Applications, 13, pp. 117-120, 1974.", ".. [11] `Cauchy-Riemann equations", " `_ on", " Wikipedia.", ".. [12] `Lotka-Volterra equations", " `_", " on Wikipedia.", ".. [13] E. Hairer, S. P. Norsett G. Wanner, \"Solving Ordinary Differential", " Equations I: Nonstiff Problems\", Sec. II.", ".. [14] `Page with original Fortran code of DOP853", " `_." ], "qa": "scipy.integrate._ivp.ivp:solve_ivp", "arbitrary": [], "local_refs": [ "**options", "args", "atol", "dense_output", "events", "first_step", "fun", "jac", "jac_sparsity", "lband", "max_step", "message", "method", "min_step", "nfev", "njev", "nlu", "rtol", "sol", "status", "success", "t", "t_eval", "t_events", "t_span", "uband", "vectorized", "y", "y0", "y_events" ] }