controls

Step-size control algorithms.

T = TypeVar('T') module-attribute

A type-variable to indicate the controller's state.

Controller

Bases: Generic[T]

Control algorithm.

Source code in probdiffeq/controls.py

@containers.dataclass
class Controller(Generic[T]):
    """Control algorithm."""

    init: Callable[[float], T]
    """Initialise the controller state."""

    clip: Callable[[T, float, float], T]
    """(Optionally) clip the current step to not exceed t1."""

    apply: Callable[[T, float, float], T]
    r"""Propose a time-step $\Delta t$."""

    extract: Callable[[T], float]
    """Extract the time-step from the controller state."""

apply: Callable[[T, float, float], T] instance-attribute

Propose a time-step \(\Delta t\).

clip: Callable[[T, float, float], T] instance-attribute

(Optionally) clip the current step to not exceed t1.

extract: Callable[[T], float] instance-attribute

Extract the time-step from the controller state.

init: Callable[[float], T] instance-attribute

Initialise the controller state.

integral(**options) -> Controller[float]

Construct an integral-controller.

Source code in probdiffeq/controls.py

def integral(**options) -> Controller[float]:
    """Construct an integral-controller."""
    init = functools.partial(_integral_init, **options)
    apply = functools.partial(_integral_apply, **options)
    extract = functools.partial(_integral_extract, **options)
    return Controller(init=init, apply=apply, extract=extract, clip=_no_clip)

integral_clipped(**options) -> Controller[float]

Construct an integral-controller with time-clipping.

Source code in probdiffeq/controls.py

def integral_clipped(**options) -> Controller[float]:
    """Construct an integral-controller with time-clipping."""
    init = functools.partial(_integral_init)
    apply = functools.partial(_integral_apply, **options)
    extract = functools.partial(_integral_extract)
    return Controller(init=init, apply=apply, extract=extract, clip=_integral_clip)

proportional_integral(**options) -> Controller[tuple[float, float]]

Construct a proportional-integral-controller.

Source code in probdiffeq/controls.py

def proportional_integral(**options) -> Controller[tuple[float, float]]:
    """Construct a proportional-integral-controller."""
    init = _proportional_integral_init
    apply = functools.partial(_proportional_integral_apply, **options)
    extract = _proportional_integral_extract
    return Controller(init=init, apply=apply, extract=extract, clip=_no_clip)

proportional_integral_clipped(**options) -> Controller[tuple[float, float]]

Construct a proportional-integral-controller with time-clipping.

Source code in probdiffeq/controls.py

def proportional_integral_clipped(**options) -> Controller[tuple[float, float]]:
    """Construct a proportional-integral-controller with time-clipping."""
    init = _proportional_integral_init
    apply = functools.partial(_proportional_integral_apply, **options)
    extract = _proportional_integral_extract
    clip = _proportional_integral_clip
    return Controller(init=init, apply=apply, extract=extract, clip=clip)