Question bank — scipy.integrate — odeint, solve_ivp (RK45, DOP853), quad

False. It returns a tuple (value, estimated_absolute_error); ignoring the second element hides whether the answer is trustworthy.

False. t_eval only picks where the answer is reported; the solver's internal adaptive steps (and thus accuracy) are controlled by rtol/atol/method. See Numerical stability.

False. solve_ivp wants f(t, y) (time first); odeint wants f(y, t) (state first). Swapping them silently computes nonsense.

False. It's derived by fitting a parabola but is exact up to degree 3 — the cubic error term integrates to zero by symmetry over $[-h,h]$.

False. Each DOP853 step is more expensive; it wins only on smooth problems where it can take huge steps. On a wiggly or short problem RK45 can be cheaper.

False. By choosing both the sample locations $x_i$ and weights $w_i$ cleverly, $n$-point Gaussian quadrature is exact up to degree $2n-1$ — double what fixed-node rules manage.

False (mostly). Both approximate the same exact integral ${\int }_{t_n}^{t_n+h}fdt$ from the Fundamental Theorem of Calculus; Euler uses one left-rectangle sample, RK4 blends several interior slope samples like Simpson does. See Runge-Kutta methods.

False. odeint returns shape (len(t), n_states); solve_ivp returns sol.y of shape (n_states, len(t)) — the transpose.

The lambda has arguments reversed. solve_ivp calls it as f(t, y), so y here is actually time and t is the state — the decay rate gets applied to the wrong variable.

The state must be a vector. Even a scalar problem needs [3.0]; a bare float can raise an error or be silently mishandled.

Wrong axis. Rows are state components, columns are time points. sol.y[0] is the first component across all times; the state at time index k is sol.y[:, k].

Solvers accept only first-order systems. You must introduce $y_0=x,y_1=\dot{x}$ and return [y1, -w**2*y0]. See Harmonic oscillator.

Not a bug — it's stiffness. Explicit RK needs an absurdly tiny $h$ for stability; switch to BDF/Radau/LSODA. See Stiff differential equations.

The integral may not converge, and adaptive Riemann sums-style sampling can't detect infinitely many equal-height wiggles — quad may return a wrong value with a large reported error. Flag structure or split the domain.

The phase drifts and amplitude decays visibly over many periods. Set rtol/atol explicitly (e.g. 1e-8) when accuracy over long times matters.

Both are "integration" in the calculus sense — one accumulates area under a known curve, the other accumulates change from a known slope. Each replaces a continuous limit with clever finite sampling.

We matched a degree-2 (and freely degree-3) polynomial, so all error up to cubic vanishes; the first term the parabola cannot capture is the next even derivative, $f^{(4)}$.

To estimate the little integral ${\int }_{t_n}^{t_n+h}fdt$ more accurately — sampling the slope mid-step (like Simpson samples the midpoint) captures curvature that a single endpoint slope misses.

It computes a 5th-order answer and an embedded 4th-order answer from the same slope evaluations; their difference estimates the local error, letting the solver grow or shrink $h$ automatically.

Every general-purpose solver's step formula is built for $\dot{y}=f(t,y)$ (first order); introducing the derivative as a new state variable converts any higher-order ODE into a first-order vector system.

Implicit methods stay stable with large $h$ regardless of the fast time-scale; explicit methods have a tiny stability region, forcing minuscule steps. See Numerical stability.

It has $2n$ free choices ($n$ node positions + $n$ weights); matching $2n$ moments pins down polynomials of degree up to $2n-1$ exactly.

Adaptive sampling may waste effort or mis-estimate near the kink; pass points=[...] to force the algorithm to split the interval there and integrate each smooth piece.

The per-step error falls like $h^2$, but you take $\sim 1/h$ more steps, so the global error falls only like $h$ — halving $h$ merely halves total error, which is slow.

It stays identically zero forever — $y=0$ is an equilibrium; the slope $-2y$ vanishes there, a degenerate but valid trajectory the solver returns as a flat line.

Those points can't be reported (the solver never integrated there); requests outside the span are dropped or raise, so keep t_eval inside [t0, tf].

Non-symplectic explicit methods introduce small numerical damping/growth each step that accumulates; tightening tolerances or using a high-order method delays but doesn't perfectly remove the drift.

It still returns a (value, err) tuple but with a large err (and often a warning); always inspect the error estimate rather than assuming success.