Skip to content

Easing Functions

Module: terminaltexteffects.utils.easing

Easing functions take a progress ratio from 0 to 1. Back and elastic functions can return values below 0 or above 1. Custom curves from make_easing can also overshoot when their vertical control points are outside [0, 1]. The horizontal control points, x1 and x2, must be finite values in [0, 1].

EasingTracker preserves overshoot by default; pass clamp=True to limit its stepped values to [0, 1]. SequenceEaser always clamps its internal tracker before selecting elements.

from terminaltexteffects.utils import easing

assert easing.in_back(0.5) < 0
assert easing.out_elastic(0.5) > 1

tracker = easing.EasingTracker(lambda _: 1.25, total_steps=1, clamp=True)
assert tracker.step() == 1.0

Functions and Classes for easing calculations.

Easing functions take progress ratios from 0 to 1. Back and elastic functions can return values outside that range, as can custom cubic Bezier curves.

Classes:

Name Description
EasingTracker

Tracks the progression of an easing function over a set number of steps.
SequenceEaser

Eases over the leading portion of a sequence, tracking added, removed, and total elements.

Functions:

Name Description
linear

Linear easing function.
in_sine

Ease in using a sine function.
out_sine

Ease out using a sine function.
in_out_sine

Ease in/out using a sine function.
in_quad

Ease in using a quadratic function.
out_quad

Ease out using a quadratic function.
in_out_quad

Ease in/out using a quadratic function.
in_cubic

Ease in using a cubic function.
out_cubic

Ease out using a cubic function.
in_out_cubic

Ease in/out using a cubic function.
in_quart

Ease in using a quartic function.
out_quart

Ease out using a quartic function.
in_out_quart

Ease in/out using a quartic function.
in_quint

Ease in using a quintic function.
out_quint

Ease out using a quintic function.
in_out_quint

Ease in/out using a quintic function.
in_expo

Ease in using an exponential function.
out_expo

Ease out using an exponential function.
in_out_expo

Ease in/out using an exponential function.
in_circ

Ease in using a circular function.
out_circ

Ease out using a circular function.
in_out_circ

Ease in/out using a circular function.
in_back

Ease in using a back function.
out_back

Ease out using a back function.
in_out_back

Ease in/out using a back function.
in_elastic

Ease in using an elastic function.
out_elastic

Ease out using an elastic function.
in_out_elastic

Ease in/out using an elastic function.
in_bounce

Ease in using a bounce function.
out_bounce

Ease out using a bounce function.
in_out_bounce

Ease in/out using a bounce function.
make_easing

Create a cubic Bezier easing function using the provided control points.

EasingFunction = typing.Callable[[float], float] module-attribute

Easing functions take a progress ratio from 0 to 1 and may overshoot that range.

EasingTracker dataclass

Describe the progression of items as an easing function is applied over a sequence.

Eased values preserve overshoot by default. Set clamp=True to limit each stepped value to [0, 1]; this also affects step_delta.

Attributes:

Name Type Description
easing_function EasingFunction

The easing function being tracked.
total_steps int

Positive number of steps for the easing function.
clamp bool

Whether eased values should be clamped to the range [0, 1] after each step. Changes to this setting affect subsequent steps.
current_step int

The current step in the easing progression.
progress_ratio float

The ratio of the current step to the total steps.
step_delta float

The change in eased value from the last step to the current step.
eased_value float

The current eased value based on the easing function and progress ratio.

Methods:

Name Description
step

Advance the easing tracker by one step and return the new eased value.
is_complete

Check if the easing tracker has completed all steps.
Source code in terminaltexteffects/utils/easing.py 
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
@dataclass
class EasingTracker:
    """Describe the progression of items as an easing function is applied over a sequence.

    Eased values preserve overshoot by default. Set `clamp=True` to limit each
    stepped value to `[0, 1]`; this also affects `step_delta`.

    Attributes:
        easing_function (EasingFunction): The easing function being tracked.
        total_steps (int): Positive number of steps for the easing function.
        clamp (bool): Whether eased values should be clamped to the range `[0, 1]`
            after each step. Changes to this setting affect subsequent steps.
        current_step (int): The current step in the easing progression.
        progress_ratio (float): The ratio of the current step to the total steps.
        step_delta (float): The change in eased value from the last step to the current step.
        eased_value (float): The current eased value based on the easing function and progress ratio.

    Methods:
        step() -> float: Advance the easing tracker by one step and return the new eased value.
        is_complete() -> bool: Check if the easing tracker has completed all steps.

    """

    easing_function: EasingFunction
    total_steps: int = 100
    clamp: bool = False

    def __post_init__(self) -> None:
        """Validate the step count and initialize progression state.

        Raises:
            ValueError: If `total_steps` is not a positive non-boolean integer.

        """
        if isinstance(self.total_steps, bool) or not isinstance(self.total_steps, int) or self.total_steps < 1:
            msg = "total_steps must be a positive integer"
            raise ValueError(msg)
        self.current_step: int = 0
        self.progress_ratio: float = 0.0
        self.step_delta: float = 0.0
        self.eased_value: float = 0.0
        self._last_eased_value: float = 0.0

    def step(self) -> float:
        """Advance the easing tracker by one step.

        If the current step is less than the total steps, increment the current step,
        update the progress ratio, compute the new eased value using the easing function,
        and calculate the step delta.

        If clamp is enabled, the eased value is constrained between 0 and 1.

        Returns:
            float: The new eased value after advancing one step.

        """
        if self.current_step < self.total_steps:
            self.current_step += 1
            self.progress_ratio = self.current_step / self.total_steps
            self.eased_value = self.easing_function(self.progress_ratio)
            if self.clamp:
                self.eased_value = max(0.0, min(self.eased_value, 1.0))
            self.step_delta = self.eased_value - self._last_eased_value
            self._last_eased_value = self.eased_value
        return self.eased_value

    def reset(self) -> None:
        """Reset the easing tracker to the initial state."""
        self.current_step = 0
        self.progress_ratio = 0.0
        self.step_delta = 0.0
        self.eased_value = 0.0
        self._last_eased_value = 0.0

    def is_complete(self) -> bool:
        """Check if the easing tracker has completed all steps.

        Returns:
            bool: True if all steps have been completed, False otherwise.

        """
        return self.current_step >= self.total_steps

    def __iter__(self) -> typing.Iterator[float]:
        """Iterate over eased values until completion.

        Yields:
            float: The eased value at each step.

        """
        while not self.is_complete():
            yield self.step()

__iter__()

Iterate over eased values until completion.

Yields:

Name Type Description
float float

The eased value at each step.
Source code in terminaltexteffects/utils/easing.py 
682
683
684
685
686
687
688
689
690
def __iter__(self) -> typing.Iterator[float]:
    """Iterate over eased values until completion.

    Yields:
        float: The eased value at each step.

    """
    while not self.is_complete():
        yield self.step()

__post_init__()

Validate the step count and initialize progression state.

Raises:

Type Description
ValueError

If total_steps is not a positive non-boolean integer.
Source code in terminaltexteffects/utils/easing.py 
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
def __post_init__(self) -> None:
    """Validate the step count and initialize progression state.

    Raises:
        ValueError: If `total_steps` is not a positive non-boolean integer.

    """
    if isinstance(self.total_steps, bool) or not isinstance(self.total_steps, int) or self.total_steps < 1:
        msg = "total_steps must be a positive integer"
        raise ValueError(msg)
    self.current_step: int = 0
    self.progress_ratio: float = 0.0
    self.step_delta: float = 0.0
    self.eased_value: float = 0.0
    self._last_eased_value: float = 0.0

is_complete()

Check if the easing tracker has completed all steps.

Returns:

Name Type Description
bool bool

True if all steps have been completed, False otherwise.
Source code in terminaltexteffects/utils/easing.py 
673
674
675
676
677
678
679
680
def is_complete(self) -> bool:
    """Check if the easing tracker has completed all steps.

    Returns:
        bool: True if all steps have been completed, False otherwise.

    """
    return self.current_step >= self.total_steps

reset()

Reset the easing tracker to the initial state.

Source code in terminaltexteffects/utils/easing.py 
665
666
667
668
669
670
671
def reset(self) -> None:
    """Reset the easing tracker to the initial state."""
    self.current_step = 0
    self.progress_ratio = 0.0
    self.step_delta = 0.0
    self.eased_value = 0.0
    self._last_eased_value = 0.0

step()

Advance the easing tracker by one step.

If the current step is less than the total steps, increment the current step, update the progress ratio, compute the new eased value using the easing function, and calculate the step delta.

If clamp is enabled, the eased value is constrained between 0 and 1.

Returns:

Name Type Description
float float

The new eased value after advancing one step.
Source code in terminaltexteffects/utils/easing.py 
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
def step(self) -> float:
    """Advance the easing tracker by one step.

    If the current step is less than the total steps, increment the current step,
    update the progress ratio, compute the new eased value using the easing function,
    and calculate the step delta.

    If clamp is enabled, the eased value is constrained between 0 and 1.

    Returns:
        float: The new eased value after advancing one step.

    """
    if self.current_step < self.total_steps:
        self.current_step += 1
        self.progress_ratio = self.current_step / self.total_steps
        self.eased_value = self.easing_function(self.progress_ratio)
        if self.clamp:
            self.eased_value = max(0.0, min(self.eased_value, 1.0))
        self.step_delta = self.eased_value - self._last_eased_value
        self._last_eased_value = self.eased_value
    return self.eased_value

SequenceEaser dataclass

Bases: Generic[_T]

Eases over the leading portion of a sequence, tracking added, removed, and total elements.

At each step, total is the contiguous slice sequence[:length] determined by the current eased progress. added and removed describe the change from the previous step. The internal EasingTracker uses clamp=True, so overshooting functions cannot select elements outside the sequence.

Attributes:

Name Type Description
sequence Sequence[_T]

The sequence to ease over.
easing_function EasingFunction

The easing function to use.
total_steps int

Positive number of steps for the easing function.
added Sequence[_T]

Contiguous slice of newly included elements from the current step.
removed Sequence[_T]

Contiguous slice of elements removed from the previous step.
total Sequence[_T]

Current leading slice of sequence selected by eased progress.
Source code in terminaltexteffects/utils/easing.py 
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
@dataclass
class SequenceEaser(typing.Generic[_T]):
    """Eases over the leading portion of a sequence, tracking added, removed, and total elements.

    At each step, `total` is the contiguous slice `sequence[:length]` determined by
    the current eased progress. `added` and `removed` describe the change from the
    previous step. The internal `EasingTracker` uses `clamp=True`, so overshooting
    functions cannot select elements outside the sequence.

    Attributes:
        sequence (Sequence[_T]): The sequence to ease over.
        easing_function (EasingFunction): The easing function to use.
        total_steps (int): Positive number of steps for the easing function.
        added (Sequence[_T]): Contiguous slice of newly included elements from the current step.
        removed (Sequence[_T]): Contiguous slice of elements removed from the previous step.
        total (Sequence[_T]): Current leading slice of `sequence` selected by eased progress.

    """

    sequence: typing.Sequence[_T]
    easing_function: EasingFunction
    total_steps: int = 100
    added: typing.Sequence[_T] = field(init=False, default_factory=list)
    removed: typing.Sequence[_T] = field(init=False, default_factory=list)
    total: typing.Sequence[_T] = field(init=False, default_factory=list)

    def __post_init__(self) -> None:
        """Initialize the SequenceEaser."""
        self.easing_tracker = EasingTracker(
            easing_function=self.easing_function,
            total_steps=self.total_steps,
            clamp=True,
        )

    def step(self) -> typing.Sequence[_T]:
        """Advance the easing tracker by one step and update sequence state.

        `total` is updated to the current eased leading slice of `sequence`. If that
        slice grows, `added` contains the newly included elements. If it shrinks,
        `removed` contains the elements that were dropped. If its length is unchanged,
        both are empty.

        Returns:
            typing.Sequence[_T]: The elements added in the current step.

        """
        previous_length = len(self.total)
        eased_value = self.easing_tracker.step()
        seq_len = len(self.sequence)
        if seq_len == 0:
            self.added = self.sequence[:0]
            self.removed = self.sequence[:0]
            self.total = self.sequence[:0]
            return self.added

        length = int(eased_value * seq_len)
        # Endpoint rounding can otherwise leave the last element unselected.
        if self.easing_tracker.is_complete() and math.isclose(eased_value, 1.0, rel_tol=0.0, abs_tol=1e-12):
            length = seq_len

        if length > previous_length:
            self.added = self.sequence[previous_length:length]
            self.removed = self.sequence[:0]
        elif length < previous_length:
            self.added = self.sequence[:0]
            self.removed = self.sequence[length:previous_length]
        else:
            self.added = self.sequence[:0]
            self.removed = self.sequence[:0]

        self.total = self.sequence[:length]
        return self.added

    def is_complete(self) -> bool:
        """Check if the easing over the sequence is complete.

        Returns:
            bool: True if all steps have been completed, False otherwise.

        """
        return self.easing_tracker.is_complete()

    def reset(self) -> None:
        """Reset the SequenceEaser to the initial state."""
        self.easing_tracker.reset()
        self.added = self.sequence[:0]
        self.removed = self.sequence[:0]
        self.total = self.sequence[:0]

__post_init__()

Initialize the SequenceEaser.

Source code in terminaltexteffects/utils/easing.py 
722
723
724
725
726
727
728
def __post_init__(self) -> None:
    """Initialize the SequenceEaser."""
    self.easing_tracker = EasingTracker(
        easing_function=self.easing_function,
        total_steps=self.total_steps,
        clamp=True,
    )

is_complete()

Check if the easing over the sequence is complete.

Returns:

Name Type Description
bool bool

True if all steps have been completed, False otherwise.
Source code in terminaltexteffects/utils/easing.py 
769
770
771
772
773
774
775
776
def is_complete(self) -> bool:
    """Check if the easing over the sequence is complete.

    Returns:
        bool: True if all steps have been completed, False otherwise.

    """
    return self.easing_tracker.is_complete()

reset()

Reset the SequenceEaser to the initial state.

Source code in terminaltexteffects/utils/easing.py 
778
779
780
781
782
783
def reset(self) -> None:
    """Reset the SequenceEaser to the initial state."""
    self.easing_tracker.reset()
    self.added = self.sequence[:0]
    self.removed = self.sequence[:0]
    self.total = self.sequence[:0]

step()

Advance the easing tracker by one step and update sequence state.

total is updated to the current eased leading slice of sequence. If that slice grows, added contains the newly included elements. If it shrinks, removed contains the elements that were dropped. If its length is unchanged, both are empty.

Returns:

Type Description
Sequence[_T]

typing.Sequence[_T]: The elements added in the current step.
Source code in terminaltexteffects/utils/easing.py 
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
def step(self) -> typing.Sequence[_T]:
    """Advance the easing tracker by one step and update sequence state.

    `total` is updated to the current eased leading slice of `sequence`. If that
    slice grows, `added` contains the newly included elements. If it shrinks,
    `removed` contains the elements that were dropped. If its length is unchanged,
    both are empty.

    Returns:
        typing.Sequence[_T]: The elements added in the current step.

    """
    previous_length = len(self.total)
    eased_value = self.easing_tracker.step()
    seq_len = len(self.sequence)
    if seq_len == 0:
        self.added = self.sequence[:0]
        self.removed = self.sequence[:0]
        self.total = self.sequence[:0]
        return self.added

    length = int(eased_value * seq_len)
    # Endpoint rounding can otherwise leave the last element unselected.
    if self.easing_tracker.is_complete() and math.isclose(eased_value, 1.0, rel_tol=0.0, abs_tol=1e-12):
        length = seq_len

    if length > previous_length:
        self.added = self.sequence[previous_length:length]
        self.removed = self.sequence[:0]
    elif length < previous_length:
        self.added = self.sequence[:0]
        self.removed = self.sequence[length:previous_length]
    else:
        self.added = self.sequence[:0]
        self.removed = self.sequence[:0]

    self.total = self.sequence[:length]
    return self.added

in_back(progress_ratio)

Ease in using a back function.

Parameters:

Name Type Description Default
progress_ratio float

Progress ratio from 0 to 1.

 required

Returns:

Name Type Description
float float

Eased value that may fall below 0.
Source code in terminaltexteffects/utils/easing.py 
364
365
366
367
368
369
370
371
372
373
374
375
376
def in_back(progress_ratio: float) -> float:
    """Ease in using a back function.

    Args:
        progress_ratio (float): Progress ratio from 0 to 1.

    Returns:
        float: Eased value that may fall below 0.

    """
    c1 = 1.70158
    c3 = c1 + 1
    return c3 * progress_ratio**3 - c1 * progress_ratio**2

in_bounce(progress_ratio)

Ease in using a bounce function.

Parameters:

Name Type Description Default
progress_ratio float

Progress ratio from 0 to 1.

 required

Returns:

Name Type Description
float float

Eased value for the given progress ratio.
Source code in terminaltexteffects/utils/easing.py 
467
468
469
470
471
472
473
474
475
476
477
def in_bounce(progress_ratio: float) -> float:
    """Ease in using a bounce function.

    Args:
        progress_ratio (float): Progress ratio from 0 to 1.

    Returns:
        float: Eased value for the given progress ratio.

    """
    return 1 - out_bounce(1 - progress_ratio)

in_circ(progress_ratio)

Ease in using a circular function.

Parameters:

Name Type Description Default
progress_ratio float

Progress ratio from 0 to 1.

 required

Returns:

Name Type Description
float float

Eased value for the given progress ratio.
Source code in terminaltexteffects/utils/easing.py 
323
324
325
326
327
328
329
330
331
332
333
def in_circ(progress_ratio: float) -> float:
    """Ease in using a circular function.

    Args:
        progress_ratio (float): Progress ratio from 0 to 1.

    Returns:
        float: Eased value for the given progress ratio.

    """
    return 1 - math.sqrt(1 - progress_ratio**2)

in_cubic(progress_ratio)

Ease in using a cubic function.

Parameters:

Name Type Description Default
progress_ratio float

Progress ratio from 0 to 1.

 required

Returns:

Name Type Description
float float

Eased value for the given progress ratio.
Source code in terminaltexteffects/utils/easing.py 
151
152
153
154
155
156
157
158
159
160
161
def in_cubic(progress_ratio: float) -> float:
    """Ease in using a cubic function.

    Args:
        progress_ratio (float): Progress ratio from 0 to 1.

    Returns:
        float: Eased value for the given progress ratio.

    """
    return progress_ratio**3

in_elastic(progress_ratio)

Ease in using an elastic function.

Parameters:

Name Type Description Default
progress_ratio float

Progress ratio from 0 to 1.

 required

Returns:

Name Type Description
float float

Eased value that may fall below 0.
Source code in terminaltexteffects/utils/easing.py 
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
def in_elastic(progress_ratio: float) -> float:
    """Ease in using an elastic function.

    Args:
        progress_ratio (float): Progress ratio from 0 to 1.

    Returns:
        float: Eased value that may fall below 0.

    """
    c4 = (2 * math.pi) / 3
    if progress_ratio == 0:
        return 0
    if progress_ratio == 1:
        return 1
    return -(2 ** (10 * progress_ratio - 10)) * math.sin((progress_ratio * 10 - 10.75) * c4)

in_expo(progress_ratio)

Ease in using an exponential function.

Parameters:

Name Type Description Default
progress_ratio float

Progress ratio from 0 to 1.

 required

Returns:

Name Type Description
float float

Eased value for the given progress ratio.
Source code in terminaltexteffects/utils/easing.py 
274
275
276
277
278
279
280
281
282
283
284
285
286
def in_expo(progress_ratio: float) -> float:
    """Ease in using an exponential function.

    Args:
        progress_ratio (float): Progress ratio from 0 to 1.

    Returns:
        float: Eased value for the given progress ratio.

    """
    if progress_ratio == 0:
        return 0
    return 2 ** (10 * progress_ratio - 10)

in_out_back(progress_ratio)

Ease in/out using a back function.

Parameters:

Name Type Description Default
progress_ratio float

Progress ratio from 0 to 1.

 required

Returns:

Name Type Description
float float

Eased value that may fall below 0 or exceed 1.
Source code in terminaltexteffects/utils/easing.py 
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
def in_out_back(progress_ratio: float) -> float:
    """Ease in/out using a back function.

    Args:
        progress_ratio (float): Progress ratio from 0 to 1.

    Returns:
        float: Eased value that may fall below 0 or exceed 1.

    """
    c1 = 1.70158
    c2 = c1 * 1.525
    if progress_ratio < 0.5:
        return ((2 * progress_ratio) ** 2 * ((c2 + 1) * 2 * progress_ratio - c2)) / 2
    return ((2 * progress_ratio - 2) ** 2 * ((c2 + 1) * (progress_ratio * 2 - 2) + c2) + 2) / 2

in_out_bounce(progress_ratio)

Ease in/out using a bounce function.

Parameters:

Name Type Description Default
progress_ratio float

Progress ratio from 0 to 1.

 required

Returns:

Name Type Description
float float

Eased value for the given progress ratio.
Source code in terminaltexteffects/utils/easing.py 
501
502
503
504
505
506
507
508
509
510
511
512
513
def in_out_bounce(progress_ratio: float) -> float:
    """Ease in/out using a bounce function.

    Args:
        progress_ratio (float): Progress ratio from 0 to 1.

    Returns:
        float: Eased value for the given progress ratio.

    """
    if progress_ratio < 0.5:
        return (1 - out_bounce(1 - 2 * progress_ratio)) / 2
    return (1 + out_bounce(2 * progress_ratio - 1)) / 2

in_out_circ(progress_ratio)

Ease in/out using a circular function.

Parameters:

Name Type Description Default
progress_ratio float

Progress ratio from 0 to 1.

 required

Returns:

Name Type Description
float float

Eased value for the given progress ratio.
Source code in terminaltexteffects/utils/easing.py 
349
350
351
352
353
354
355
356
357
358
359
360
361
def in_out_circ(progress_ratio: float) -> float:
    """Ease in/out using a circular function.

    Args:
        progress_ratio (float): Progress ratio from 0 to 1.

    Returns:
        float: Eased value for the given progress ratio.

    """
    if progress_ratio < 0.5:
        return (1 - math.sqrt(1 - (2 * progress_ratio) ** 2)) / 2
    return (math.sqrt(1 - (-2 * progress_ratio + 2) ** 2) + 1) / 2

in_out_cubic(progress_ratio)

Ease in/out using a cubic function.

Parameters:

Name Type Description Default
progress_ratio float

Progress ratio from 0 to 1.

 required

Returns:

Name Type Description
float float

Eased value for the given progress ratio.
Source code in terminaltexteffects/utils/easing.py 
177
178
179
180
181
182
183
184
185
186
187
188
189
def in_out_cubic(progress_ratio: float) -> float:
    """Ease in/out using a cubic function.

    Args:
        progress_ratio (float): Progress ratio from 0 to 1.

    Returns:
        float: Eased value for the given progress ratio.

    """
    if progress_ratio < 0.5:
        return 4 * progress_ratio**3
    return 1 - (-2 * progress_ratio + 2) ** 3 / 2

in_out_elastic(progress_ratio)

Ease in/out using an elastic function.

Parameters:

Name Type Description Default
progress_ratio float

Progress ratio from 0 to 1.

 required

Returns:

Name Type Description
float float

Eased value that may fall below 0 or exceed 1.
Source code in terminaltexteffects/utils/easing.py 
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
def in_out_elastic(progress_ratio: float) -> float:
    """Ease in/out using an elastic function.

    Args:
        progress_ratio (float): Progress ratio from 0 to 1.

    Returns:
        float: Eased value that may fall below 0 or exceed 1.

    """
    c5 = (2 * math.pi) / 4.5
    if progress_ratio == 0:
        return 0
    if progress_ratio == 1:
        return 1
    if progress_ratio < 0.5:
        return -(2 ** (20 * progress_ratio - 10) * math.sin((20 * progress_ratio - 11.125) * c5)) / 2
    return (2 ** (-20 * progress_ratio + 10) * math.sin((20 * progress_ratio - 11.125) * c5)) / 2 + 1

in_out_expo(progress_ratio)

Ease in/out using an exponential function.

Parameters:

Name Type Description Default
progress_ratio float

Progress ratio from 0 to 1.

 required

Returns:

Name Type Description
float float

Eased value for the given progress ratio.
Source code in terminaltexteffects/utils/easing.py 
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
def in_out_expo(progress_ratio: float) -> float:
    """Ease in/out using an exponential function.

    Args:
        progress_ratio (float): Progress ratio from 0 to 1.

    Returns:
        float: Eased value for the given progress ratio.

    """
    if progress_ratio == 0:
        return 0
    if progress_ratio == 1:
        return 1
    if progress_ratio < 0.5:
        return 2 ** (20 * progress_ratio - 10) / 2
    return (2 - 2 ** (-20 * progress_ratio + 10)) / 2

in_out_quad(progress_ratio)

Ease in/out using a quadratic function.

Parameters:

Name Type Description Default
progress_ratio float

Progress ratio from 0 to 1.

 required

Returns:

Name Type Description
float float

Eased value for the given progress ratio.
Source code in terminaltexteffects/utils/easing.py 
136
137
138
139
140
141
142
143
144
145
146
147
148
def in_out_quad(progress_ratio: float) -> float:
    """Ease in/out using a quadratic function.

    Args:
        progress_ratio (float): Progress ratio from 0 to 1.

    Returns:
        float: Eased value for the given progress ratio.

    """
    if progress_ratio < 0.5:
        return 2 * progress_ratio**2
    return 1 - (-2 * progress_ratio + 2) ** 2 / 2

in_out_quart(progress_ratio)

Ease in/out using a quartic function.

Parameters:

Name Type Description Default
progress_ratio float

Progress ratio from 0 to 1.

 required

Returns:

Name Type Description
float float

Eased value for the given progress ratio.
Source code in terminaltexteffects/utils/easing.py 
218
219
220
221
222
223
224
225
226
227
228
229
230
def in_out_quart(progress_ratio: float) -> float:
    """Ease in/out using a quartic function.

    Args:
        progress_ratio (float): Progress ratio from 0 to 1.

    Returns:
        float: Eased value for the given progress ratio.

    """
    if progress_ratio < 0.5:
        return 8 * progress_ratio**4
    return 1 - (-2 * progress_ratio + 2) ** 4 / 2

in_out_quint(progress_ratio)

Ease in/out using a quintic function.

Parameters:

Name Type Description Default
progress_ratio float

Progress ratio from 0 to 1.

 required

Returns:

Name Type Description
float float

Eased value for the given progress ratio.
Source code in terminaltexteffects/utils/easing.py 
259
260
261
262
263
264
265
266
267
268
269
270
271
def in_out_quint(progress_ratio: float) -> float:
    """Ease in/out using a quintic function.

    Args:
        progress_ratio (float): Progress ratio from 0 to 1.

    Returns:
        float: Eased value for the given progress ratio.

    """
    if progress_ratio < 0.5:
        return 16 * progress_ratio**5
    return 1 - (-2 * progress_ratio + 2) ** 5 / 2

in_out_sine(progress_ratio)

Ease in/out using a sine function.

Parameters:

Name Type Description Default
progress_ratio float

Progress ratio from 0 to 1.

 required

Returns:

Name Type Description
float float

Eased value for the given progress ratio.
Source code in terminaltexteffects/utils/easing.py 
 97
 98
 99
100
101
102
103
104
105
106
107
def in_out_sine(progress_ratio: float) -> float:
    """Ease in/out using a sine function.

    Args:
        progress_ratio (float): Progress ratio from 0 to 1.

    Returns:
        float: Eased value for the given progress ratio.

    """
    return -(math.cos(math.pi * progress_ratio) - 1) / 2

in_quad(progress_ratio)

Ease in using a quadratic function.

Parameters:

Name Type Description Default
progress_ratio float

Progress ratio from 0 to 1.

 required

Returns:

Name Type Description
float float

Eased value for the given progress ratio.
Source code in terminaltexteffects/utils/easing.py 
110
111
112
113
114
115
116
117
118
119
120
def in_quad(progress_ratio: float) -> float:
    """Ease in using a quadratic function.

    Args:
        progress_ratio (float): Progress ratio from 0 to 1.

    Returns:
        float: Eased value for the given progress ratio.

    """
    return progress_ratio**2

in_quart(progress_ratio)

Ease in using a quartic function.

Parameters:

Name Type Description Default
progress_ratio float

Progress ratio from 0 to 1.

 required

Returns:

Name Type Description
float float

Eased value for the given progress ratio.
Source code in terminaltexteffects/utils/easing.py 
192
193
194
195
196
197
198
199
200
201
202
def in_quart(progress_ratio: float) -> float:
    """Ease in using a quartic function.

    Args:
        progress_ratio (float): Progress ratio from 0 to 1.

    Returns:
        float: Eased value for the given progress ratio.

    """
    return progress_ratio**4

in_quint(progress_ratio)

Ease in using a quintic function.

Parameters:

Name Type Description Default
progress_ratio float

Progress ratio from 0 to 1.

 required

Returns:

Name Type Description
float float

Eased value for the given progress ratio.
Source code in terminaltexteffects/utils/easing.py 
233
234
235
236
237
238
239
240
241
242
243
def in_quint(progress_ratio: float) -> float:
    """Ease in using a quintic function.

    Args:
        progress_ratio (float): Progress ratio from 0 to 1.

    Returns:
        float: Eased value for the given progress ratio.

    """
    return progress_ratio**5

in_sine(progress_ratio)

Ease in using a sine function.

Parameters:

Name Type Description Default
progress_ratio float

Progress ratio from 0 to 1.

 required

Returns:

Name Type Description
float float

Eased value for the given progress ratio.
Source code in terminaltexteffects/utils/easing.py 
71
72
73
74
75
76
77
78
79
80
81
def in_sine(progress_ratio: float) -> float:
    """Ease in using a sine function.

    Args:
        progress_ratio (float): Progress ratio from 0 to 1.

    Returns:
        float: Eased value for the given progress ratio.

    """
    return 1 - math.cos((progress_ratio * math.pi) / 2)

linear(progress_ratio)

Linear easing function.

Parameters:

Name Type Description Default
progress_ratio float

Progress ratio from 0 to 1.

 required

Returns:

Name Type Description
float float

Eased value for the given progress ratio.
Source code in terminaltexteffects/utils/easing.py 
58
59
60
61
62
63
64
65
66
67
68
def linear(progress_ratio: float) -> float:
    """Linear easing function.

    Args:
        progress_ratio (float): Progress ratio from 0 to 1.

    Returns:
        float: Eased value for the given progress ratio.

    """
    return progress_ratio

make_easing(x1, y1, x2, y2)

Create a cubic Bezier easing function using the provided control points.

The easing function maps a progress ratio from 0 to 1 to an output value according to a cubic Bezier curve defined by four points. Horizontal control points must be finite and lie in [0, 1]; vertical control points may lie outside that range and produce overshoot: - Start point: (0, 0) - First control point: (x1, y1) - Second control point: (x2, y2) - End point: (1, 1)

Parameters:

Name Type Description Default
x1 float

Finite horizontal position of the first control point, from 0 to 1 inclusive. Smaller values make the curve start off steeper, while larger values delay the initial acceleration.

 required
y1 float

Vertical position of the first control point; values outside [0, 1] are allowed. Smaller values create a gentler ease-in effect; larger values increase the initial acceleration.

 required
x2 float

Finite horizontal position of the second control point, from 0 to 1 inclusive. Larger values extend the period of change, affecting how late the acceleration or deceleration begins.

 required
y2 float

Vertical position of the second control point; values outside [0, 1] are allowed. Larger values can create a more abrupt ease-out effect; smaller values result in a smoother finish.

 required

Note: Use a resource such as cubic-bezier.com to design an appropriate easing curve for your needs.

Returns:

Name Type Description
EasingFunction EasingFunction

A function that takes progress_ratio from 0 to 1 and returns the
EasingFunction

curve's eased value, which may be outside [0, 1].

Raises:

Type Description
ValueError

If x1 or x2 is non-finite or outside 0 to 1.
Source code in terminaltexteffects/utils/easing.py 
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
def make_easing(x1: float, y1: float, x2: float, y2: float) -> EasingFunction:
    """Create a cubic Bezier easing function using the provided control points.

    The easing function maps a progress ratio from 0 to 1 to an output value
    according to a cubic Bezier curve defined by four points. Horizontal control
    points must be finite and lie in `[0, 1]`; vertical control points may lie
    outside that range and produce overshoot:
      - Start point: (0, 0)
      - First control point: (x1, y1)
      - Second control point: (x2, y2)
      - End point: (1, 1)

    Args:
      x1 (float): Finite horizontal position of the first control point, from 0 to 1 inclusive.
          Smaller values make the curve start off steeper, while larger values delay the initial acceleration.
      y1 (float): Vertical position of the first control point; values outside `[0, 1]` are allowed.
          Smaller values create a gentler ease-in effect; larger values increase the initial acceleration.
      x2 (float): Finite horizontal position of the second control point, from 0 to 1 inclusive.
          Larger values extend the period of change, affecting how late the acceleration or deceleration begins.
      y2 (float): Vertical position of the second control point; values outside `[0, 1]` are allowed.
          Larger values can create a more abrupt ease-out effect; smaller values result in a smoother finish.

    Note: Use a resource such as cubic-bezier.com to design an appropriate easing curve for your needs.

    Returns:
        EasingFunction: A function that takes `progress_ratio` from 0 to 1 and returns the
        curve's eased value, which may be outside `[0, 1]`.

    Raises:
        ValueError: If `x1` or `x2` is non-finite or outside 0 to 1.

    """
    if not math.isfinite(x1) or not 0 <= x1 <= 1:
        msg = "x1 must be finite and between 0 and 1"
        raise ValueError(msg)
    if not math.isfinite(x2) or not 0 <= x2 <= 1:
        msg = "x2 must be finite and between 0 and 1"
        raise ValueError(msg)

    # Compute Bezier curve x for a given parameter t.
    def sample_curve_x(t: float) -> float:
        return 3 * x1 * (1 - t) ** 2 * t + 3 * x2 * (1 - t) * t**2 + t**3

    # Compute Bezier curve y for a given parameter t.
    def sample_curve_y(t: float) -> float:
        return 3 * y1 * (1 - t) ** 2 * t + 3 * y2 * (1 - t) * t**2 + t**3

    # Compute derivative of curve x with respect to t.
    def sample_curve_derivative_x(t: float) -> float:
        return 3 * (1 - t) ** 2 * x1 + 6 * (1 - t) * t * (x2 - x1) + 3 * t**2 * (1 - x2)

    def bezier_easing(progress: float) -> float:
        # Clamp progress between 0 and 1.
        if progress <= 0:
            return 0
        if progress >= 1:
            return 1

        # Keep Newton's method inside a bracket so flat derivatives cannot
        # send t outside the curve or leave an unconverged endpoint result.
        lower, upper = 0.0, 1.0
        t = progress
        for _ in range(50):
            x_est = sample_curve_x(t)
            if x_est == progress:
                break
            if x_est < progress:
                lower = t
            else:
                upper = t
            derivative = sample_curve_derivative_x(t)
            candidate = t - (x_est - progress) / derivative if derivative > 0 else -1.0
            if not lower < candidate < upper:
                candidate = (lower + upper) / 2
            if abs(candidate - t) <= 1e-12:
                t = candidate
                break
            t = candidate
        return sample_curve_y(t)

    return functools.wraps(bezier_easing)(functools.lru_cache(maxsize=8192)(bezier_easing))

out_back(progress_ratio)

Ease out using a back function.

Parameters:

Name Type Description Default
progress_ratio float

Progress ratio from 0 to 1.

 required

Returns:

Name Type Description
float float

Eased value that may exceed 1.
Source code in terminaltexteffects/utils/easing.py 
379
380
381
382
383
384
385
386
387
388
389
390
391
def out_back(progress_ratio: float) -> float:
    """Ease out using a back function.

    Args:
        progress_ratio (float): Progress ratio from 0 to 1.

    Returns:
        float: Eased value that may exceed 1.

    """
    c1 = 1.70158
    c3 = c1 + 1
    return 1 + c3 * (progress_ratio - 1) ** 3 + c1 * (progress_ratio - 1) ** 2

out_bounce(progress_ratio)

Ease out using a bounce function.

Parameters:

Name Type Description Default
progress_ratio float

Progress ratio from 0 to 1.

 required

Returns:

Name Type Description
float float

Eased value for the given progress ratio.
Source code in terminaltexteffects/utils/easing.py 
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
def out_bounce(progress_ratio: float) -> float:
    """Ease out using a bounce function.

    Args:
        progress_ratio (float): Progress ratio from 0 to 1.

    Returns:
        float: Eased value for the given progress ratio.

    """
    n1 = 7.5625
    d1 = 2.75
    if progress_ratio < 1 / d1:
        return n1 * progress_ratio**2
    if progress_ratio < 2 / d1:
        return n1 * (progress_ratio - 1.5 / d1) ** 2 + 0.75
    if progress_ratio < 2.5 / d1:
        return n1 * (progress_ratio - 2.25 / d1) ** 2 + 0.9375
    return n1 * (progress_ratio - 2.625 / d1) ** 2 + 0.984375

out_circ(progress_ratio)

Ease out using a circular function.

Parameters:

Name Type Description Default
progress_ratio float

Progress ratio from 0 to 1.

 required

Returns:

Name Type Description
float float

Eased value for the given progress ratio.
Source code in terminaltexteffects/utils/easing.py 
336
337
338
339
340
341
342
343
344
345
346
def out_circ(progress_ratio: float) -> float:
    """Ease out using a circular function.

    Args:
        progress_ratio (float): Progress ratio from 0 to 1.

    Returns:
        float: Eased value for the given progress ratio.

    """
    return math.sqrt(1 - (progress_ratio - 1) ** 2)

out_cubic(progress_ratio)

Ease out using a cubic function.

Parameters:

Name Type Description Default
progress_ratio float

Progress ratio from 0 to 1.

 required

Returns:

Name Type Description
float float

Eased value for the given progress ratio.
Source code in terminaltexteffects/utils/easing.py 
164
165
166
167
168
169
170
171
172
173
174
def out_cubic(progress_ratio: float) -> float:
    """Ease out using a cubic function.

    Args:
        progress_ratio (float): Progress ratio from 0 to 1.

    Returns:
        float: Eased value for the given progress ratio.

    """
    return 1 - (1 - progress_ratio) ** 3

out_elastic(progress_ratio)

Ease out using an elastic function.

Parameters:

Name Type Description Default
progress_ratio float

Progress ratio from 0 to 1.

 required

Returns:

Name Type Description
float float

Eased value that may exceed 1.
Source code in terminaltexteffects/utils/easing.py 
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
def out_elastic(progress_ratio: float) -> float:
    """Ease out using an elastic function.

    Args:
        progress_ratio (float): Progress ratio from 0 to 1.

    Returns:
        float: Eased value that may exceed 1.

    """
    c4 = (2 * math.pi) / 3
    if progress_ratio == 0:
        return 0
    if progress_ratio == 1:
        return 1
    return 2 ** (-10 * progress_ratio) * math.sin((progress_ratio * 10 - 0.75) * c4) + 1

out_expo(progress_ratio)

Ease out using an exponential function.

Parameters:

Name Type Description Default
progress_ratio float

Progress ratio from 0 to 1.

 required

Returns:

Name Type Description
float float

Eased value for the given progress ratio.
Source code in terminaltexteffects/utils/easing.py 
289
290
291
292
293
294
295
296
297
298
299
300
301
def out_expo(progress_ratio: float) -> float:
    """Ease out using an exponential function.

    Args:
        progress_ratio (float): Progress ratio from 0 to 1.

    Returns:
        float: Eased value for the given progress ratio.

    """
    if progress_ratio == 1:
        return 1
    return 1 - 2 ** (-10 * progress_ratio)

out_quad(progress_ratio)

Ease out using a quadratic function.

Parameters:

Name Type Description Default
progress_ratio float

Progress ratio from 0 to 1.

 required

Returns:

Name Type Description
float float

Eased value for the given progress ratio.
Source code in terminaltexteffects/utils/easing.py 
123
124
125
126
127
128
129
130
131
132
133
def out_quad(progress_ratio: float) -> float:
    """Ease out using a quadratic function.

    Args:
        progress_ratio (float): Progress ratio from 0 to 1.

    Returns:
        float: Eased value for the given progress ratio.

    """
    return 1 - (1 - progress_ratio) * (1 - progress_ratio)

out_quart(progress_ratio)

Ease out using a quartic function.

Parameters:

Name Type Description Default
progress_ratio float

Progress ratio from 0 to 1.

 required

Returns:

Name Type Description
float float

Eased value for the given progress ratio.
Source code in terminaltexteffects/utils/easing.py 
205
206
207
208
209
210
211
212
213
214
215
def out_quart(progress_ratio: float) -> float:
    """Ease out using a quartic function.

    Args:
        progress_ratio (float): Progress ratio from 0 to 1.

    Returns:
        float: Eased value for the given progress ratio.

    """
    return 1 - (1 - progress_ratio) ** 4

out_quint(progress_ratio)

Ease out using a quintic function.

Parameters:

Name Type Description Default
progress_ratio float

Progress ratio from 0 to 1.

 required

Returns:

Name Type Description
float float

Eased value for the given progress ratio.
Source code in terminaltexteffects/utils/easing.py 
246
247
248
249
250
251
252
253
254
255
256
def out_quint(progress_ratio: float) -> float:
    """Ease out using a quintic function.

    Args:
        progress_ratio (float): Progress ratio from 0 to 1.

    Returns:
        float: Eased value for the given progress ratio.

    """
    return 1 - (1 - progress_ratio) ** 5

out_sine(progress_ratio)

Ease out using a sine function.

Parameters:

Name Type Description Default
progress_ratio float

Progress ratio from 0 to 1.

 required

Returns:

Name Type Description
float float

Eased value for the given progress ratio.
Source code in terminaltexteffects/utils/easing.py 
84
85
86
87
88
89
90
91
92
93
94
def out_sine(progress_ratio: float) -> float:
    """Ease out using a sine function.

    Args:
        progress_ratio (float): Progress ratio from 0 to 1.

    Returns:
        float: Eased value for the given progress ratio.

    """
    return math.sin((progress_ratio * math.pi) / 2)