solve-nivp 0.1.2__tar.gz

solve_nivp-0.1.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 David Riley
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the “Software”), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

solve_nivp-0.1.2/PKG-INFO

@@ -0,0 +1,139 @@
+Metadata-Version: 2.4
+Name: solve_nivp
+Version: 0.1.2
+Summary: A Python toolkit for integrating nonsmooth dynamical systems
+Author: David Riley, Ioannis Stefanou
+License: MIT
+Project-URL: Homepage, https://github.com/ERC-INJECT/solve_nivp
+Project-URL: Documentation, https://github.com/ERC-INJECT/solve_nivp/tree/main/docs
+Project-URL: Issues, https://github.com/ERC-INJECT/solve_nivp/issues
+Keywords: nonsmooth dynamics,ODE,DAE,variational inequalities,semismooth Newton,projection methods
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20
+Requires-Dist: scipy>=1.8
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Provides-Extra: rl
+Requires-Dist: gymnasium>=0.29; extra == "rl"
+Requires-Dist: stable-baselines3>=2.2; extra == "rl"
+Requires-Dist: sb3-contrib>=2.2; extra == "rl"
+Requires-Dist: matplotlib>=3.5; extra == "rl"
+Provides-Extra: docs
+Requires-Dist: sphinx>=6; extra == "docs"
+Requires-Dist: sphinx-rtd-theme>=1.2; extra == "docs"
+Dynamic: license-file
+
+# solve_nivp
+
+A Python library for time integration of **nonsmooth** ODE/DAE systems—models
+with abrupt changes such as impacts, switching, or inequality constraints.
+Such models arise in frictional contact mechanics, piecewise and switching
+behaviour in circuits, sliding-mode control, and discontinuous rules in
+finance and energy markets. Classical solvers, which assume smoothness, often
+require regularisation or very small steps due to the inherent stiffness
+of these models. **solve_nivp** builds nonsmooth rules directly into the
+implicit time-stepping scheme, enabling users to encode constraints and advance
+the state robustly.
+
+## Key features
+
+- **Projection-based constraint encoding.** Users express set-valued or
+  nonsmooth relations as projections onto convex sets (Coulomb friction cone,
+  sign / normal cone, second-order cone, algebraic constraints). Custom
+  projections need only implement `project()` and an optional `tangent_cone()`.
+
+- **Nonlinear solvers for nonsmooth problems.** A semismooth Newton method with
+  Armijo line search and a variational-inequality (VI) fixed-point iteration,
+  both with standard tolerances, safeguards, and iteration diagnostics.
+
+- **Implicit integrators.** Backward Euler, Trapezoidal, θ-method, a composite
+  TR–BE scheme (Bathe-type, second-order), and an embedded BE–TR error estimator.
+
+- **Adaptive step-size control** with Richardson extrapolation.
+
+- **Optional RL add-on.** Exposes the time integrator as a Gym-style
+  environment for learning adaptive step-size policies (TD3 / TQC via Stable
+  Baselines 3).
+
+The library is organised around three interchangeable components—projection,
+nonlinear solver, and integrator—so that swapping algorithms during
+experimentation is straightforward. Linear-algebra routines operate on dense or
+sparse arrays in the SciPy ecosystem.
+
+## Installation
+
+Recommended developer install:
+
+```bash
+python3 -m venv .venv && source .venv/bin/activate
+pip install -U pip
+pip install -e .[test]
+```
+
+Optional extras:
+
+```bash
+# RL experiments
+pip install -e .[rl]
+```
+
+## Quickstart
+
+```python
+import numpy as np
+from solve_nivp import solve_ivp_ns
+
+# simple smooth rhs: y' = -y
+rhs = lambda t, y: -y
+
+t_span = (0.0, 1.0)
+y0 = np.array([1.0])
+
+# identity projection, VI solver via composite integrator
+sol = solve_ivp_ns(
+    fun=rhs,
+    t_span=t_span,
+    y0=y0,
+    method='composite',
+    projection='identity',
+    solver='VI',
+)
+
+print(sol[0][:5], sol[1][:5])  # t, y samples
+```
+
+See `examples/` for notebooks on friction stick–slip, bouncing ball (contact/impact), SOC constraints, and sliding-mode control.
+
+## Running tests
+
+```bash
+pytest -q
+```
+
+## Building the documentation
+
+```bash
+cd docs
+make clean html
+```
+Open `docs/_build/html/index.html`.
+
+## RL experiments (optional)
+
+The `RL_Adaption/` folder contains optional experiments (TD3/TQC) for learned adaptivity on challenging nonsmooth problems. Large artifacts are ignored by Git and not required for core installation or testing.
+
+## Citation
+
+See `CITATION.cff`. If you use this software, please cite the JOSS paper once available.
+
+## License
+
+MIT License (see `LICENSE`).

solve_nivp-0.1.2/README.md

@@ -0,0 +1,106 @@
+# solve_nivp
+
+A Python library for time integration of **nonsmooth** ODE/DAE systems—models
+with abrupt changes such as impacts, switching, or inequality constraints.
+Such models arise in frictional contact mechanics, piecewise and switching
+behaviour in circuits, sliding-mode control, and discontinuous rules in
+finance and energy markets. Classical solvers, which assume smoothness, often
+require regularisation or very small steps due to the inherent stiffness
+of these models. **solve_nivp** builds nonsmooth rules directly into the
+implicit time-stepping scheme, enabling users to encode constraints and advance
+the state robustly.
+
+## Key features
+
+- **Projection-based constraint encoding.** Users express set-valued or
+  nonsmooth relations as projections onto convex sets (Coulomb friction cone,
+  sign / normal cone, second-order cone, algebraic constraints). Custom
+  projections need only implement `project()` and an optional `tangent_cone()`.
+
+- **Nonlinear solvers for nonsmooth problems.** A semismooth Newton method with
+  Armijo line search and a variational-inequality (VI) fixed-point iteration,
+  both with standard tolerances, safeguards, and iteration diagnostics.
+
+- **Implicit integrators.** Backward Euler, Trapezoidal, θ-method, a composite
+  TR–BE scheme (Bathe-type, second-order), and an embedded BE–TR error estimator.
+
+- **Adaptive step-size control** with Richardson extrapolation.
+
+- **Optional RL add-on.** Exposes the time integrator as a Gym-style
+  environment for learning adaptive step-size policies (TD3 / TQC via Stable
+  Baselines 3).
+
+The library is organised around three interchangeable components—projection,
+nonlinear solver, and integrator—so that swapping algorithms during
+experimentation is straightforward. Linear-algebra routines operate on dense or
+sparse arrays in the SciPy ecosystem.
+
+## Installation
+
+Recommended developer install:
+
+```bash
+python3 -m venv .venv && source .venv/bin/activate
+pip install -U pip
+pip install -e .[test]
+```
+
+Optional extras:
+
+```bash
+# RL experiments
+pip install -e .[rl]
+```
+
+## Quickstart
+
+```python
+import numpy as np
+from solve_nivp import solve_ivp_ns
+
+# simple smooth rhs: y' = -y
+rhs = lambda t, y: -y
+
+t_span = (0.0, 1.0)
+y0 = np.array([1.0])
+
+# identity projection, VI solver via composite integrator
+sol = solve_ivp_ns(
+    fun=rhs,
+    t_span=t_span,
+    y0=y0,
+    method='composite',
+    projection='identity',
+    solver='VI',
+)
+
+print(sol[0][:5], sol[1][:5])  # t, y samples
+```
+
+See `examples/` for notebooks on friction stick–slip, bouncing ball (contact/impact), SOC constraints, and sliding-mode control.
+
+## Running tests
+
+```bash
+pytest -q
+```
+
+## Building the documentation
+
+```bash
+cd docs
+make clean html
+```
+Open `docs/_build/html/index.html`.
+
+## RL experiments (optional)
+
+The `RL_Adaption/` folder contains optional experiments (TD3/TQC) for learned adaptivity on challenging nonsmooth problems. Large artifacts are ignored by Git and not required for core installation or testing.
+
+## Citation
+
+See `CITATION.cff`. If you use this software, please cite the JOSS paper once available.
+
+## License
+
+MIT License (see `LICENSE`).

solve_nivp-0.1.2/pyproject.toml

@@ -0,0 +1,59 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "solve_nivp"
+version = "0.1.2"
+description = "A Python toolkit for integrating nonsmooth dynamical systems"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.9"
+authors = [
+  { name = "David Riley" },
+  { name = "Ioannis Stefanou" },
+]
+keywords = [
+  "nonsmooth dynamics",
+  "ODE",
+  "DAE",
+  "variational inequalities",
+  "semismooth Newton",
+  "projection methods",
+]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Science/Research",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Topic :: Scientific/Engineering :: Mathematics",
+  "Topic :: Scientific/Engineering :: Physics",
+]
+dependencies = [
+  "numpy>=1.20",
+  "scipy>=1.8",
+]
+
+[project.optional-dependencies]
+test = [
+  "pytest>=7",
+]
+rl = [
+  "gymnasium>=0.29",
+  "stable-baselines3>=2.2",
+  "sb3-contrib>=2.2",
+  "matplotlib>=3.5",
+]
+docs = [
+  "sphinx>=6",
+  "sphinx-rtd-theme>=1.2",
+]
+
+[project.scripts]
+solve_nivp-selftest = "solve_nivp._selftest:main"
+
+[project.urls]
+Homepage = "https://github.com/ERC-INJECT/solve_nivp"
+Documentation = "https://github.com/ERC-INJECT/solve_nivp/tree/main/docs"
+Issues = "https://github.com/ERC-INJECT/solve_nivp/issues"
+

solve_nivp-0.1.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

solve_nivp-0.1.2/setup.py

@@ -0,0 +1,57 @@
+import os
+from setuptools import setup, find_packages, Command
+import subprocess
+
+class BuildSphinx(Command):
+    description = "Build Sphinx documentation."
+    user_options = [
+        ('builder=', 'b', 'Sphinx builder to use (html, latex)')
+    ]
+
+    def initialize_options(self):
+        self.builder = 'html'
+        self.build_dir = None
+
+    def finalize_options(self):
+        # Build directory for Sphinx output.
+        self.build_dir = os.path.join(os.path.dirname(__file__), 'docs/_build')
+
+    def run(self):
+        # First, automatically run sphinx-apidoc to generate .rst files.
+        # This documents only the solve_nivp subpackage.
+        from sphinx.ext.apidoc import main as sphinx_apidoc_main
+        apidoc_args = [
+            '--force',         # Overwrite existing .rst files.
+            '--module-first',  # Put module documentation before submodule docs.
+            '-o', os.path.join('docs', 'source'),  # Output directory for the .rst files.
+            'solve_nivp'       # Path to the package to document.
+        ]
+        sphinx_apidoc_main(apidoc_args)
+
+        # Now, build the documentation using Sphinx.
+        from sphinx.cmd.build import main as sphinx_main
+        args = [
+            '-b', self.builder,
+            os.path.join('docs', 'source'),
+            os.path.join(self.build_dir, self.builder)
+        ]
+        errno = sphinx_main(args)
+        if errno:
+            raise SystemExit(errno)
+
+        # For LaTeX, optionally compile to PDF.
+        if self.builder == 'latex':
+            latex_dir = os.path.join(self.build_dir, 'latex')
+            # This assumes you have a Makefile in your LaTeX output directory.
+            errno = subprocess.call(['make', 'all-pdf'], cwd=latex_dir)
+            if errno:
+                raise SystemExit(errno)
+            print("PDF generated in:", os.path.join(latex_dir, 'Documentation.pdf'))
+
+setup(
+    name="solve_nivp",
+    version="0.1.2",
+    packages=find_packages(),  # automatically discovers packages
+    description="A solver package for implicit ODEs and projection-based solvers",
+    cmdclass={'build_sphinx': BuildSphinx},
+)

solve_nivp-0.1.2/solve_nivp/ODESolver.py

@@ -0,0 +1,116 @@
+import numpy as np
+from typing import Any, Tuple, List
+
+class ODESolver:
+    """Time integration driver (fixed or adaptive) for an ``ODESystem``.
+
+    Stores growing histories of time grid, states, step sizes and solver
+    diagnostics. For adaptive runs, rejected steps do not append entries.
+
+    Residual semantics
+    ------------------
+    ``fk`` list stores the raw implicit residual / function value ``F(y_k)``
+    returned by the integrator's nonlinear solve at each *accepted* step. This
+    can be useful for post-process diagnostics (e.g. monitoring equilibrium of
+    projected components). Entries may be ``None`` if a method does not return
+    a residual (should not occur with current integrators).
+    """
+    def __init__(self, system: Any, t_span: Tuple[float, float], h: float = 1e-2):
+        """
+        Initialize the ODESolver.
+        
+        Parameters:
+            system: The ODE system to be integrated.
+            t_span: A tuple (t0, tf) specifying the start and end times.
+            h: The initial time step size.
+        """
+        self.system = system
+        self.t0, self.tf = t_span
+        self.h_initial = h
+        self.t_values: List[float] = [self.t0]
+        self.y_values: List[np.ndarray] = [self.system.current_y.copy()]
+        self.h_values: List[float] = [h]
+        self.error_estimates: List[Tuple[Any, bool, int]] = []
+        self.fk: List[Any] = []
+
+    def solve(self, return_attempts: bool = False) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, List[Tuple[Any, bool, int]]]:
+        """Integrate from ``t0`` to ``tf``.
+
+        Parameters
+        ----------
+        return_attempts : bool, default False
+            When ``True`` and adaptive stepping is enabled with attempt logging,
+            include the raw attempt log as a sixth return value.
+
+        Returns
+        -------
+        t_values : ndarray (m,)
+            Time points (monotone, includes final time).
+        y_values : ndarray (m, n)
+            State history.
+        h_values : ndarray (m,)
+            Step sizes used; first entry equals initial ``h`` guess.
+        fk : object ndarray (m,)
+            Residual / implicit function evaluations per accepted step.
+        error_estimates : list[tuple]
+            Per-step tuples ``(solver_error, success, iterations)`` coming from
+            the nonlinear solver (solver_error is typically final residual norm).
+        attempts : dict or None, optional
+            Only returned when ``return_attempts`` is ``True``. Contains arrays of
+            attempted times, step sizes, acceptance flags, etc., if recorded.
+        """
+        t = self.t0
+        h = self.h_initial
+        stepper = getattr(self.system, 'adaptive_stepper', None)
+        if stepper is not None and hasattr(stepper, 'reset_attempt_log'):
+            stepper.reset_attempt_log()
+        
+        # Initialize progress bar for integration.
+        # pbar = tqdm(total=self.tf - self.t0, desc='Integration Progress', unit='time unit')
+        while t < self.tf:
+            # Ensure we do not overshoot the final time.
+            h_step = min(h, self.tf - t)
+            if self.system.adaptive:
+                # Adaptive stepping returns:
+                # (y_new, fk_new, h_new, E, success, solver_error, iterations)
+                y_new, fk_new, h_new, E, success, solver_error, iterations = self.system.step(t, h_step)
+                if success:
+                    t += h_step
+                    self.t_values.append(t)
+                    self.y_values.append(y_new.copy())
+                    self.fk.append(fk_new.copy() if fk_new is not None else None)
+                    self.h_values.append(h_new)
+                    self.error_estimates.append((solver_error, success, iterations))
+                    self.system.current_y = y_new
+                    h = h_new  # Update step size for next iteration.
+                else:
+                    h = h_new
+                    # If the adaptive step fails, reduce the step size and try again.
+                    if h<=  self.system.adaptive_stepper.h_min:
+                        if self.system.verbose:
+                            print(f"Failed integration: reached minimum step size at t={t:.5f} and step did not converge.")
+                        break
+            else:
+                # Fixed stepping mode.
+                y_new, fk_new, solver_error, success, iterations = self.system.step(t, h_step)
+                t += h_step
+                self.t_values.append(t)
+                self.y_values.append(y_new.copy())
+                self.fk.append(fk_new.copy() if fk_new is not None else None)
+                self.h_values.append(h_step)
+                self.error_estimates.append((solver_error, success, iterations))
+                self.system.current_y = y_new
+            # pbar.update(h_step)
+        # pbar.close()
+        t_arr = np.array(self.t_values)
+        y_arr = np.array(self.y_values)
+        h_arr = np.array(self.h_values)
+        fk_arr = np.array(self.fk, dtype=object)
+
+        if return_attempts:
+            attempt_log = None
+            if stepper is not None and hasattr(stepper, 'get_attempt_log'):
+                attempt_log = stepper.get_attempt_log()
+            return t_arr, y_arr, h_arr, fk_arr, self.error_estimates, attempt_log
+
+        return t_arr, y_arr, h_arr, fk_arr, self.error_estimates

solve_nivp-0.1.2/solve_nivp/ODESystem.py

@@ -0,0 +1,190 @@
+import numpy as np
+from typing import Callable, Optional, Union
+
+# Import integration methods from integrations.py.
+# It is assumed that integrations.py is in the same package or accessible via the PYTHONPATH.
+from .integrations import (
+    IntegrationMethod,
+    BackwardEuler,
+    Trapezoidal,
+    ThetaMethod,
+    CompositeMethod,
+    EmbeddedBETR,
+    # BDFMethod,
+    # AdaptiveSteppingBDF
+)
+
+# from .adaptive_integrator import AdaptiveStepping
+
+class ODESystem:
+    """Encapsulate RHS, initial state and integration method configuration.
+
+    The system binds a user RHS ``fun`` with an implicit integration method
+    (possibly adaptive) and stores current state for the driver. The RHS may
+    support signature variants ``fun(t, y)`` or ``fun(t, y, Fk)`` (third
+    argument ignored if unused).
+
+    Parameters
+    ----------
+    fun : callable
+        ODE right-hand side ``fun(t, y) -> ndarray``.
+    y0 : array_like, shape (n,)
+        Initial state vector.
+    method : str | IntegrationMethod, default 'backward_euler'
+        Integration scheme name or pre-instantiated method object.
+    a : float, default 1.0
+        Auxiliary parameter (currently only placeholder for composite schemes).
+    adaptive : bool, default False
+        Enable adaptive step controller (two half-step Richardson + PI).
+    atol, rtol : float
+        Absolute / relative tolerances (adaptive only).
+    component_slices : list[slice], optional
+        Partition for per-block error norm and projection logic.
+    verbose : bool, default False
+        Emit basic rejection diagnostics.
+    A : ndarray, optional
+        Constant mass / descriptor matrix; identity if omitted.
+
+    Notes
+    -----
+    Integrator ``step`` methods must return a 5‑tuple ``(y_new, Fk_new, err, success, iterations)``.
+    ``Fk_new`` is propagated upward and recorded by the driver for diagnostics.
+    """
+    def __init__(self, 
+                 fun: Callable[[float, np.ndarray], np.ndarray], 
+                 y0: Union[np.ndarray, list],
+                 method: Union[str, IntegrationMethod] = 'backward_euler',
+                 a: float = 1.0,
+                 adaptive: bool = False,
+                 atol: float = 1e-6,
+                 rtol: float = 1e-3,
+                 component_slices: Optional[list] = None,
+                 verbose: bool = False,
+                 A: Optional[np.ndarray] = None,
+                 record_attempts: bool = False):
+        self.fun = fun
+        self.y0 = np.array(y0, dtype=float)
+        self.current_y = self.y0.copy()
+        self.adaptive = adaptive
+        self.atol = atol
+        self.rtol = rtol
+        self.verbose = verbose
+        self.component_slices = component_slices
+        self.A = A
+        self.record_attempts = bool(record_attempts)
+
+        # If method is an instance of IntegrationMethod, use it directly.
+        if isinstance(method, IntegrationMethod):
+            self.method = method
+            if A is not None:
+                self.method.A = A
+        # Otherwise, select the integration method based on the provided string.
+        elif isinstance(method, str):
+            self.method = self._select_method(method.lower(), a, A)
+        else:
+            raise ValueError("Invalid integration method specification.")
+
+        # Set up adaptive stepping if requested.
+        if self.adaptive:
+            # # For BDF methods, use a specialized adaptive stepper.
+            # if self.method.__class__.__name__.lower() == 'bdfmethod':
+            #     self.adaptive_stepper = AdaptiveSteppingBDF(
+            #         self.method,
+            #         atol=self.atol,
+            #         rtol=self.rtol
+            #     )
+            # else:
+                # Otherwise, use the generic adaptive stepping mechanism.
+                # Always use the generic adaptive stepper
+                from .adaptive_integrator import AdaptiveStepping
+                self.adaptive_stepper = AdaptiveStepping(
+                    integrator=self.method,
+                    component_slices=self.component_slices,
+                    atol=self.atol,
+                    rtol=self.rtol,
+                    verbose=self.verbose,
+                    record_attempts=self.record_attempts,
+                )
+
+    def _select_method(self, method_name: str, a: float, A: Optional[np.ndarray]):
+        """
+        Select and return an integration method based on the provided method name.
+        
+        Parameters:
+            method_name : str
+                Name of the integration method.
+            a : float
+                Parameter used by some integrators.
+            A : optional
+                Matrix parameter to pass to the integration method.
+        
+        Returns:
+            An instance of the selected integration method.
+        """
+        if method_name == 'backward_euler':
+            return BackwardEuler(A=A)
+        elif method_name == 'trapezoidal':
+            return Trapezoidal(A=A)
+        elif method_name == 'theta':
+            return ThetaMethod(theta=0.5, A=A)
+        elif method_name == 'composite':
+            return CompositeMethod(a=a, A=A)
+        elif method_name == 'embedded_betr':
+            return EmbeddedBETR(A=A)
+        else:
+            raise ValueError(f"Unknown integration method: {method_name}")
+    
+    def step_fixed(self, t: float, h: float):
+        """
+        Perform one fixed-step integration.
+        
+        Parameters:
+            t : float
+                Current time.
+            h : float
+                Fixed time step size.
+        
+        Returns:
+            A tuple containing:
+                y_new : array_like, updated state vector.
+                f_new : array_like, derivative evaluated at the new state.
+                solver_error : float, error reported by the integrator.
+                success : bool, solver success flag.
+                iterations : int, number of iterations taken by the solver.
+        """
+        y_new, f_new, solver_error, success, iterations = self.method.step(self.fun, t, self.current_y, h)
+        self.current_y = y_new  # Update the system state.
+        return y_new, f_new, solver_error, success, iterations
+
+    def step_adaptive(self, t: float, h: float):
+        """
+        Perform one adaptive-step integration using the adaptive stepper.
+        
+        Parameters:
+            t : float
+                Current time.
+            h : float
+                Proposed time step size.
+        
+        Returns:
+            The result of the adaptive stepping procedure.
+        """
+        return self.adaptive_stepper.step(self.fun, t, self.current_y, h)
+    
+    def step(self, t: float, h: float):
+        """
+        Take one integration step using either adaptive or fixed stepping.
+        
+        Parameters:
+            t : float
+                Current time.
+            h : float
+                Time step size.
+        
+        Returns:
+            The integration step results, which vary depending on the stepping mode.
+        """
+        if self.adaptive:
+            return self.step_adaptive(t, h)
+        else:
+            return self.step_fixed(t, h)