Rate functions¶

@unit_interval
def smooth(t: float, inflection: float = 10.0) -> float:
    """Slow, fast, slow: a sigmoid curve, stretched to run from 0 to 1.

    The default rate function of animations.

    Args:
        t: The time, from 0 to 1.
        inflection: How steep its middle is: higher starts and ends slower and runs
            faster between.

    Returns:
        The progress, from 0 to 1.
    """
    error = 1.0 / (1 + np.exp(inflection / 2))  # the logistic curve's value at t = 0
    logistic = 1.0 / (1 + np.exp(-inflection * (t - 0.5)))
    return min(max((logistic - error) / (1 - 2 * error), 0), 1)

@unit_interval
def linear(t: float) -> float:
    """Progress in step with time: t."""
    return t

@unit_interval
def rush_into(t: float, inflection: float = 10.0) -> float:
    """The first half of [smooth][manimgx.smooth], stretched over the whole time:
    starts at rest and ends at full speed.

    Args:
        t: The time, from 0 to 1.
        inflection: How steep [smooth][manimgx.smooth] is.

    Returns:
        The progress, from 0 to 1.
    """
    return 2 * smooth(t / 2.0, inflection)

@unit_interval
def rush_from(t: float, inflection: float = 10.0) -> float:
    """The second half of [smooth][manimgx.smooth], stretched over the whole time:
    starts at full speed and comes to rest.

    Args:
        t: The time, from 0 to 1.
        inflection: How steep [smooth][manimgx.smooth] is.

    Returns:
        The progress, from 0 to 1.
    """
    return 2 * smooth(t / 2.0 + 0.5, inflection) - 1

@unit_interval
def slow_into(t: float) -> float:
    """√(1 − (1 − t)²), a quarter circle: starts at once at full speed and slows to a
    stop."""
    return float(np.sqrt(1 - (1 - t) * (1 - t)))

@unit_interval
def double_smooth(t: float) -> float:
    """Two [smooth][manimgx.smooth] moves, each half the way in half the time: comes to
    rest at the middle."""
    return 0.5 * smooth(2 * t) if t < 0.5 else 0.5 * (1 + smooth(2 * t - 1))

@zero
def there_and_back(t: float, inflection: float = 10.0) -> float:
    """There and back: [smooth][manimgx.smooth] to the end by the middle, then back to
    the start.

    Args:
        t: The time, from 0 to 1.
        inflection: How steep [smooth][manimgx.smooth] is.

    Returns:
        The progress, 0 at the start and the end and 1 at the middle.
    """
    return smooth(2 * t if t < 0.5 else 2 * (1 - t), inflection)

@zero
def there_and_back_with_pause(t: float, pause_ratio: float = 1.0 / 3) -> float:
    """There and back with a pause: [smooth][manimgx.smooth] to the end, a pause there,
    then back to the start.

    Args:
        t: The time, from 0 to 1.
        pause_ratio: The fraction of the time spent at the end, in the middle.

    Returns:
        The progress, 0 at the start and the end and 1 during the pause.
    """
    a = 2.0 / (1.0 - pause_ratio)
    if t < 0.5 - pause_ratio / 2:
        return smooth(a * t)
    if t < 0.5 + pause_ratio / 2:
        return 1
    return smooth(a - a * t)

@unit_interval
def running_start(t: float, pull_factor: float = -0.5) -> float:
    """Backs up for a running start, then runs to the end: with the default pull, back
    to −0.18 at t ≈ 0.29.

    Args:
        t: The time, from 0 to 1.
        pull_factor: How far it pulls back: the third and fourth of its Bézier curve's
            seven control values (0, 0, pull, pull, 1, 1, 1).

    Returns:
        The progress, from 0 to 1, after dipping below 0.
    """
    mt = 1 - t
    return (
        15 * t**2 * mt**4 * pull_factor
        + 20 * t**3 * mt**3 * pull_factor
        + 15 * t**4 * mt**2
        + 6 * t**5 * mt
        + t**6
    )

@unit_interval
def lingering(t: float) -> float:
    """Runs evenly to the end by 0.8 of the time, then lingers there."""
    return squish_rate_func(lambda x: x, 0, 0.8)(t)

@zero
def wiggle(t: float, wiggles: float = 2) -> float:
    """Swings to either side of the start and comes back: sin(`wiggles`·πt), swelling
    and fading as [there_and_back][manimgx.there_and_back] does.

    With the default 2 wiggles, it swings to 0.73 and then to −0.73.

    Args:
        t: The time, from 0 to 1.
        wiggles: How many swings, to one side or the other.

    Returns:
        The progress, 0 at the start and the end.
    """
    return there_and_back(t) * float(np.sin(wiggles * np.pi * t))

@unit_interval
def exponential_decay(t: float, half_life: float = 0.1) -> float:
    """1 − e^(−t / `half_life`), scaled to end at 1: shoots off, then closes in on the
    end, ever slower.

    It is about 1 − 1/e ≈ 0.63 at `half_life`.

    Args:
        t: The time, from 0 to 1.
        half_life: The time constant, as a fraction of the time.

    Returns:
        The progress, from 0 to 1.
    """
    return float(np.expm1(-t / half_life) / np.expm1(-1 / half_life))

@unit_interval
def smoothstep(t: float) -> float:
    """3t² − 2t³: starts and ends at rest; gentler than [smooth][manimgx.smooth]."""
    return 3 * t**2 - 2 * t**3

@unit_interval
def smootherstep(t: float) -> float:
    """6t⁵ − 15t⁴ + 10t³: starts and ends at rest, and without acceleration there."""
    return 6 * t**5 - 15 * t**4 + 10 * t**3

def squish_rate_func(func: RateFunc, a: float = 0.4, b: float = 0.6) -> RateFunc:
    """Squeeze a rate function into part of the time: it runs between `a` and `b`, and
    holds its ends before and after.

    Args:
        func: The rate function.
        a: When it starts, from 0 to 1.
        b: When it ends, from `a` to 1; if it is `a`, the function steps from its start to
            its end at `a`.

    Returns:
        The squeezed rate function.
    """

    def result(t: float) -> float:
        if t < a:
            return func(0.0)
        return func(1.0) if t >= b else func((t - a) / (b - a))

    return result

def not_quite_there(func: RateFunc = smooth, proportion: float = 0.7) -> RateFunc:
    """Scale a rate function so it goes only part of the way.

    Args:
        func: The rate function.
        proportion: How far it goes: its progress is scaled by this.

    Returns:
        The scaled rate function.
    """
    return lambda t: proportion * func(t)

def unit_interval[**P](
    function: Callable[Concatenate[float, P], float],
) -> Callable[Concatenate[float, P], float]:
    """Make a rate function start exactly at 0 and end exactly at 1, and hold its ends
    outside [0, 1].

    Args:
        function: The rate function, as it runs from 0 to 1.

    Returns:
        The rate function: 0 up to 0, 1 from 1 on.
    """

    @functools.wraps(function)
    def wrapper(t: float, /, *args: P.args, **kwargs: P.kwargs) -> float:
        # its ends are exact, whatever rounding its formula does there: an animation lands
        if 0 < t < 1:
            return function(t, *args, **kwargs)
        return 0 if t <= 0 else 1

    return wrapper

def zero[**P](
    function: Callable[Concatenate[float, P], float],
) -> Callable[Concatenate[float, P], float]:
    """Make a rate function that comes back to 0 start and end exactly at 0, and hold 0
    outside [0, 1].

    Args:
        function: The rate function, as it runs from 0 to 1.

    Returns:
        The rate function, 0 up to 0 and from 1 on.
    """

    @functools.wraps(function)
    def wrapper(t: float, /, *args: P.args, **kwargs: P.kwargs) -> float:
        return function(t, *args, **kwargs) if 0 < t < 1 else 0

    return wrapper