Find a root of f(x) = 0 in [a, b] using the bisection method.

Requires f(a) and f(b) to have opposite signs (Bolzano's theorem).

Args: func_str: Math expression in x, e.g. "x**2 - 4". a: Left endpoint of the interval. b: Right endpoint of the interval (must be > a). tol: Convergence tolerance on the residual/error. max_iter: Maximum number of iterations. precision: Rounding digits for the reported root.

Returns: Dict with the root, convergence flag, iteration table and errors.

Approximate the definite integral of f(x) on [a, b] with composite Simpson 1/3.

Args: func_str: Math expression in x, e.g. "sin(x)/x". a: Lower integration limit. b: Upper integration limit (must be > a). n: Number of subintervals (must be even). Error is O(h^4). epsilon: Point in [a, b] used to report the truncation error bound. precision: Rounding digits.

Returns: Dict with the approximated integral, error estimates and table.

Solve an initial value problem y'(x) = f(x, y) with the Runge-Kutta 4 method.

Args: ecuacion_str: Right-hand side f(x, y), e.g. "y" or "-2xy". x0: Initial x. y0: Initial y(x0). xf: Final x (must be > x0). h: Step size (must be positive). The endpoint xf is always reached. tol: Optional tolerance to flag whether the final error meets it. precision: Rounding digits.

Returns: Dict with the numerical solution table, exact solution (when SymPy can solve it) and per-step errors.

Build the Lagrange interpolating polynomial through a set of points.

Provide either the point values puntos_y or the generating function func_str evaluated at puntos_x.

Args: puntos_x: Distinct abscissas of the interpolation points. x_eval: Optional x where the polynomial is evaluated. func_str: Optional generating function f(x) for the y values. puntos_y: Optional y values matching puntos_x one-to-one. precision: Rounding digits.

Returns: Dict with the polynomial, its degree, the points table and error bounds when func_str is provided.

Estimate ∫ₐᵇ f(x) dx with the hit-or-miss Monte Carlo method.

Handles sign-changing integrands correctly (returns the signed integral).

Args: func_str: Math expression in x. a, b: Integration limits (b > a). N: Number of samples. seed: Optional RNG seed for reproducibility. precision: Rounding digits. nivel_confianza: Confidence level in (0, 1) for the interval.

Returns: Dict with the estimate, interval, sample statistics and history.

Estimate ∫ₐᵇ f(x) dx with the mean-value Monte Carlo method.

Args: func_str: Math expression in x. a, b: Integration limits (b > a). N: Number of samples. seed: Optional RNG seed for reproducibility. precision: Rounding digits. nivel_confianza: Confidence level in (0, 1).

Returns: Dict with the estimate, confidence interval and sample statistics.

Estimate the double integral of f(x, y) over [x_a,x_b]×[y_a,y_b] by mean value.

Estimate the triple integral of f(x,y,z) over the box [x_a,x_b]×[y_a,y_b]×[z_a,z_b].

Replicated Monte Carlo experiment (M repetitions of N samples) with statistical analysis.

Args: func_str: Math expression in x. a, b: Integration limits (b > a). N: Samples per replication. M: Number of replications. nivel_confianza: Confidence level in (0, 1). seed: Optional RNG seed. precision: Rounding digits.

Returns: Dict with the distribution of estimates and confidence intervals.

Analyze the 1D autonomous system x' = f(x): equilibria, stability, phase portrait and time series.

Args: func_str: f(x) used when model is 'custom'. model: 'custom' | 'malthus' (rx) | 'verhulst' (mux*(1-x/K)) | 'newton' (-k*(x-Ta)). params: parameter values, e.g. {'r': 1.5} or {'mu': 1.0, 'K': 2.0}. x_min, x_max: state window. t_max: final time of the time series. n_phase: resolution of the phase analysis. n_time: number of time steps. initial_conditions: starting states, e.g. [0.1, 1.0]. control_enabled: add a constant control term -h (verhulst/custom only).

Returns: Dict with equilibria, their stability, the phase portrait data and time solutions.

Find the equilibria of x' = f(x) and classify their stability.

Bifurcation analysis of x' = f(x; bif_param): equilibria vs parameter sweep.

Args: func_str: f(x) used when model is 'custom'. model: 'custom' | 'malthus' | 'verhulst' | 'newton'. params: values of the other model parameters, e.g. {'K': 2.0}. bif_param: name of the bifurcation parameter swept between bif_min and bif_max. bif_min, bif_max, bif_steps: parameter sweep range/resolution. x_min, x_max, n_phase: state window for finding equilibria. phase_params: optional explicit parameter values for phase slices. control_enabled: add a constant control term -h (verhulst/custom only).

Returns: Dict with the equilibria-vs-parameter table, exact symbolic analysis and phase slices.

Solve and classify the linear 2D system X' = A·X + B with constant matrix A.

Args: a, b, c, d: entries of A = [[a, b], [c, d]]. e, f: constant forcing vector B = [e, f]. x0, y0, t0, t_fin, h: initial condition and integration grid. x_min..y_max: window for the phase portrait. cantidad_trayectorias: number of sample trajectories.

Returns: Dict with the classification, eigenvalues, nullclines, analytic solution and trajectories.

Solve and analyze the nonlinear 2D system x' = f(x,y), y' = g(x,y).

Args: eq_x, eq_y: Math expressions for f and g (variables x, y, mu and extra params). params: extra parameter values (e.g. {'alpha': 0.5}). mu: bifurcation parameter value. x0..y_max, cantidad_trayectorias: integration and portrait settings.

Returns: Dict with equilibria, Jacobian-based classification, nullclines and trajectories.

Analyze a 2D system checking conservativeness (divergence-free), Hamiltonian/energy and closed orbits.

Args: eq_x, eq_y: Math expressions for x' and y'. mu: parameter value. x0..y_max, cantidad_trayectorias: integration and portrait settings.

Returns: Dict with the divergence check, the Hamiltonian reconstruction, the equilibrium classification and the trajectories.

Simulate a Lanchester combat model x' = f(x,y), y' = g(x,y) with analytic time-to-annihilation.

Args: eq_x, eq_y: Math expressions (classic default is x'=-αy, y'=-βx). alpha, beta, gamma, epsilon, mu, delta: Greek parameter values. x0, y0: initial force sizes. t0, t_fin, h: simulation grid.

Returns: Dict with the analytic winner/survivors, state equation and the numerical trajectories.

Solve the non-homogeneous 2D system X' = A·X + B(t) with constant or time-varying forcing.

Args: a, b, c, d: entries of A = [[a, b], [c, d]]. e, f: forcing components B(t); a number or an expression in t (e.g. "sin(2*t)"). x0, y0, t0, t_fin, h: integration settings. x_min..y_max, cantidad_trayectorias: portrait settings.

Returns: Dict with the classification, equilibrium/particular solution, analytic solution and trajectories.

Find a root of f(x) = 0 with the Newton-Raphson method (numeric derivative).

Args: func_str: Math expression in x. x0: Initial guess. tol: Convergence tolerance. max_iter: Maximum iterations. precision: Rounding digits.

Returns: Dict with the root, iteration table and convergence flag.

Find a fixed point of g(x) = x with the fixed-point iteration method.

Converges when |g'(x)| < 1 near the root (Lipschitz check is reported).

Args: g_str: Math expression for the iteration function g(x). x0: Initial guess. tol: Convergence tolerance. max_iter: Maximum iterations. precision: Rounding digits.

Returns: Dict with the fixed point, the Lipschitz check, iteration table and convergence flag.

Accelerate fixed-point iteration with Aitken's delta-squared method.

Args: g_str: Math expression for the iteration function g(x). x0: Initial guess. tol: Convergence tolerance. max_iter: Maximum iterations. precision: Rounding digits.

Returns: Dict with the accelerated root, iteration table and convergence flag.

Compare bisection, fixed-point, Newton-Raphson and Aitken on the same problem.

Args: func_str: Math expression for f(x) (used by bisection/Newton). g_str: Math expression for g(x) (used by fixed-point/Aitken). a, b: Bracket for bisection (f(a) and f(b) must differ in sign). x0: Initial guess. tol, max_iter, precision: Shared tolerances.

Returns: Dict with per-method results.

Approximate ∫ₐᵇ f(x) dx with the composite midpoint (rectangle) rule.

Args: func_str: Math expression in x. a, b: Integration limits (b > a). n: Number of subintervals. epsilon: Optional point in [a, b] for the truncation error bound. precision: Rounding digits.

Returns: Dict with the integral, error estimates and table.

Approximate ∫ₐᵇ f(x) dx with the composite trapezoidal rule.

Args: func_str: Math expression in x. a, b: Integration limits (b > a). n: Number of subintervals. epsilon: Optional point in [a, b] for the truncation error bound. precision: Rounding digits.

Returns: Dict with the integral, error estimates and table.

Approximate ∫ₐᵇ f(x) dx with the composite Simpson 3/8 rule.

Args: func_str: Math expression in x. a, b: Integration limits (b > a). n: Number of subintervals (must be a multiple of 3). epsilon: Optional point in [a, b] for the truncation error bound. precision: Rounding digits.

Returns: Dict with the integral, error estimates and table.

Compare rectangle, trapezoid, Simpson 1/3 and Simpson 3/8 on the same integral.

Args: func_str: Math expression in x. a, b: Integration limits (b > a). n: Number of subintervals (Simpson 1/3 needs even, 3/8 needs multiple of 3). epsilon, precision: Error-bound and rounding settings.

Returns: Dict with per-method results and success flags.

Solve y'(x) = f(x, y), y(x0) = y0 with the explicit Euler method (1st order).

Args: ecuacion_str: Right-hand side f(x, y). x0, y0: Initial condition. xf: Final x (must be > x0). h: Step size (must be positive). tol: Optional tolerance flag for the final error. precision: Rounding digits.

Returns: Dict with the numerical solution, exact solution (when available) and errors.

Solve y'(x) = f(x, y), y(x0) = y0 with Heun's predictor-corrector method (2nd order).

Args: ecuacion_str: Right-hand side f(x, y). x0, y0: Initial condition. xf: Final x (must be > x0). h: Step size (must be positive). tol: Optional tolerance flag for the final error. precision: Rounding digits.

Returns: Dict with the numerical solution, exact solution (when available) and errors.

Show how the mean-value Monte Carlo estimate converges as samples accumulate.

Args: func_str: Math expression in x. a, b: Integration limits (b > a). N: Total number of samples. seed: Optional RNG seed. precision: Rounding digits.

Returns: Dict with the cumulative running average over the samples.

Approximate the first and second derivatives of f(x) at x with finite differences.

Computes forward, backward and central differences for the first derivative, plus the central second derivative, and compares each against the exact derivative from SymPy.

Args: func_str: Math expression in x. x_val: Point where the derivative is evaluated. h: Step size (small, positive). precision: Rounding digits.

Returns: Dict with the exact and numerical derivatives and their errors.