Skip to content

easing

Classes:

Attributes:

EasingT module-attribute 

EasingT = type[EasingBaseMeta]

BackEaseIn 

BackEaseIn(start: int = 0, end: int = 1, duration: int = 1)

Bases: EasingBase

Methods:

Attributes:

Source code 
48
49
50
51
def __init__(self, start: int = 0, end: int = 1, duration: int = 1) -> None:
    self.start = start
    self.end = end
    self.duration = duration

duration instance-attribute 

duration = duration

end instance-attribute 

end = end

limit class-attribute instance-attribute 

limit: tuple[int, int] = (0, 1)

start instance-attribute 

start = start

ease 

ease(alpha: float) -> float
Source code 
64
65
66
67
def ease(self, alpha: float) -> float:
    t = self.limit[0] * (1 - alpha) + self.limit[1] * alpha / self.duration
    a = self.func(t)
    return self.end * a + self.start * (1 - a)

func 

func(t: float) -> float
Source code 
225
226
def func(self, t: float) -> float:
    return pow(t, 3) - t * sin(t * pi)

BackEaseInOut 

BackEaseInOut(start: int = 0, end: int = 1, duration: int = 1)

Bases: EasingBase

Methods:

Attributes:

Source code 
48
49
50
51
def __init__(self, start: int = 0, end: int = 1, duration: int = 1) -> None:
    self.start = start
    self.end = end
    self.duration = duration

duration instance-attribute 

duration = duration

end instance-attribute 

end = end

limit class-attribute instance-attribute 

limit: tuple[int, int] = (0, 1)

start instance-attribute 

start = start

ease 

ease(alpha: float) -> float
Source code 
64
65
66
67
def ease(self, alpha: float) -> float:
    t = self.limit[0] * (1 - alpha) + self.limit[1] * alpha / self.duration
    a = self.func(t)
    return self.end * a + self.start * (1 - a)

func 

func(t: float) -> float
Source code 
235
236
237
238
239
def func(self, t: float) -> float:
    if t < 0.5:
        return 0.5 * BackEaseIn().func(t * 2)

    return 0.5 * (1 - BackEaseOut().func(t * 2 - 1)) + 0.5

BackEaseOut 

BackEaseOut(start: int = 0, end: int = 1, duration: int = 1)

Bases: EasingBase

Methods:

Attributes:

Source code 
48
49
50
51
def __init__(self, start: int = 0, end: int = 1, duration: int = 1) -> None:
    self.start = start
    self.end = end
    self.duration = duration

duration instance-attribute 

duration = duration

end instance-attribute 

end = end

limit class-attribute instance-attribute 

limit: tuple[int, int] = (0, 1)

start instance-attribute 

start = start

ease 

ease(alpha: float) -> float
Source code 
64
65
66
67
def ease(self, alpha: float) -> float:
    t = self.limit[0] * (1 - alpha) + self.limit[1] * alpha / self.duration
    a = self.func(t)
    return self.end * a + self.start * (1 - a)

func 

func(t: float) -> float
Source code 
230
231
def func(self, t: float) -> float:
    return 1 - BackEaseIn().func(1 - t)

BounceEaseIn 

BounceEaseIn(start: int = 0, end: int = 1, duration: int = 1)

Bases: EasingBase

Methods:

Attributes:

Source code 
48
49
50
51
def __init__(self, start: int = 0, end: int = 1, duration: int = 1) -> None:
    self.start = start
    self.end = end
    self.duration = duration

duration instance-attribute 

duration = duration

end instance-attribute 

end = end

limit class-attribute instance-attribute 

limit: tuple[int, int] = (0, 1)

start instance-attribute 

start = start

ease 

ease(alpha: float) -> float
Source code 
64
65
66
67
def ease(self, alpha: float) -> float:
    t = self.limit[0] * (1 - alpha) + self.limit[1] * alpha / self.duration
    a = self.func(t)
    return self.end * a + self.start * (1 - a)

func 

func(t: float) -> float
Source code 
243
244
def func(self, t: float) -> float:
    return 1 - BounceEaseOut().func(1 - t)

BounceEaseInOut 

BounceEaseInOut(start: int = 0, end: int = 1, duration: int = 1)

Bases: EasingBase

Methods:

Attributes:

Source code 
48
49
50
51
def __init__(self, start: int = 0, end: int = 1, duration: int = 1) -> None:
    self.start = start
    self.end = end
    self.duration = duration

duration instance-attribute 

duration = duration

end instance-attribute 

end = end

limit class-attribute instance-attribute 

limit: tuple[int, int] = (0, 1)

start instance-attribute 

start = start

ease 

ease(alpha: float) -> float
Source code 
64
65
66
67
def ease(self, alpha: float) -> float:
    t = self.limit[0] * (1 - alpha) + self.limit[1] * alpha / self.duration
    a = self.func(t)
    return self.end * a + self.start * (1 - a)

func 

func(t: float) -> float
Source code 
261
262
263
264
265
def func(self, t: float) -> float:
    if t < 0.5:
        return 0.5 * BounceEaseIn().func(t * 2)

    return 0.5 * BounceEaseOut().func(t * 2 - 1) + 0.5

BounceEaseOut 

BounceEaseOut(start: int = 0, end: int = 1, duration: int = 1)

Bases: EasingBase

Methods:

Attributes:

Source code 
48
49
50
51
def __init__(self, start: int = 0, end: int = 1, duration: int = 1) -> None:
    self.start = start
    self.end = end
    self.duration = duration

duration instance-attribute 

duration = duration

end instance-attribute 

end = end

limit class-attribute instance-attribute 

limit: tuple[int, int] = (0, 1)

start instance-attribute 

start = start

ease 

ease(alpha: float) -> float
Source code 
64
65
66
67
def ease(self, alpha: float) -> float:
    t = self.limit[0] * (1 - alpha) + self.limit[1] * alpha / self.duration
    a = self.func(t)
    return self.end * a + self.start * (1 - a)

func 

func(t: float) -> float
Source code 
248
249
250
251
252
253
254
255
256
257
def func(self, t: float) -> float:
    t2 = pow(t, 2)

    if t < 4 / 11:
        return 121 * t2 / 16
    elif t < 8 / 11:
        return (363 / 40 * t2) - (99 / 10 * t) + 17 / 5
    elif t < 9 / 10:
        return (4356 / 361 * t2) - (35442 / 1805 * t) + 16061 / 1805
    return (54 / 5 * t2) - (513 / 25 * t) + 268 / 25

CircularEaseIn 

CircularEaseIn(start: int = 0, end: int = 1, duration: int = 1)

Bases: EasingBase

Methods:

Attributes:

Source code 
48
49
50
51
def __init__(self, start: int = 0, end: int = 1, duration: int = 1) -> None:
    self.start = start
    self.end = end
    self.duration = duration

duration instance-attribute 

duration = duration

end instance-attribute 

end = end

limit class-attribute instance-attribute 

limit: tuple[int, int] = (0, 1)

start instance-attribute 

start = start

ease 

ease(alpha: float) -> float
Source code 
64
65
66
67
def ease(self, alpha: float) -> float:
    t = self.limit[0] * (1 - alpha) + self.limit[1] * alpha / self.duration
    a = self.func(t)
    return self.end * a + self.start * (1 - a)

func 

func(t: float) -> float
Source code 
167
168
def func(self, t: float) -> float:
    return 1 - sqrt(1 - pow(t, 2))

CircularEaseInOut 

CircularEaseInOut(start: int = 0, end: int = 1, duration: int = 1)

Bases: EasingBase

Methods:

Attributes:

Source code 
48
49
50
51
def __init__(self, start: int = 0, end: int = 1, duration: int = 1) -> None:
    self.start = start
    self.end = end
    self.duration = duration

duration instance-attribute 

duration = duration

end instance-attribute 

end = end

limit class-attribute instance-attribute 

limit: tuple[int, int] = (0, 1)

start instance-attribute 

start = start

ease 

ease(alpha: float) -> float
Source code 
64
65
66
67
def ease(self, alpha: float) -> float:
    t = self.limit[0] * (1 - alpha) + self.limit[1] * alpha / self.duration
    a = self.func(t)
    return self.end * a + self.start * (1 - a)

func 

func(t: float) -> float
Source code 
177
178
179
180
def func(self, t: float) -> float:
    if t < 0.5:
        return 0.5 * (1 - sqrt(1 - 4 * pow(t, 2)))
    return 0.5 * (sqrt(-((2 * t) - 3) * ((2 * t) - 1)) + 1)

CircularEaseOut 

CircularEaseOut(start: int = 0, end: int = 1, duration: int = 1)

Bases: EasingBase

Methods:

Attributes:

Source code 
48
49
50
51
def __init__(self, start: int = 0, end: int = 1, duration: int = 1) -> None:
    self.start = start
    self.end = end
    self.duration = duration

duration instance-attribute 

duration = duration

end instance-attribute 

end = end

limit class-attribute instance-attribute 

limit: tuple[int, int] = (0, 1)

start instance-attribute 

start = start

ease 

ease(alpha: float) -> float
Source code 
64
65
66
67
def ease(self, alpha: float) -> float:
    t = self.limit[0] * (1 - alpha) + self.limit[1] * alpha / self.duration
    a = self.func(t)
    return self.end * a + self.start * (1 - a)

func 

func(t: float) -> float
Source code 
172
173
def func(self, t: float) -> float:
    return sqrt((2 - t) * t)

CubicEaseIn 

CubicEaseIn(start: int = 0, end: int = 1, duration: int = 1)

Bases: EasingBase

Methods:

Attributes:

Source code 
48
49
50
51
def __init__(self, start: int = 0, end: int = 1, duration: int = 1) -> None:
    self.start = start
    self.end = end
    self.duration = duration

duration instance-attribute 

duration = duration

end instance-attribute 

end = end

limit class-attribute instance-attribute 

limit: tuple[int, int] = (0, 1)

start instance-attribute 

start = start

ease 

ease(alpha: float) -> float
Source code 
64
65
66
67
def ease(self, alpha: float) -> float:
    t = self.limit[0] * (1 - alpha) + self.limit[1] * alpha / self.duration
    a = self.func(t)
    return self.end * a + self.start * (1 - a)

func 

func(t: float) -> float
Source code 
101
102
def func(self, t: float) -> float:
    return pow(t, 3)

CubicEaseInOut 

CubicEaseInOut(start: int = 0, end: int = 1, duration: int = 1)

Bases: EasingBase

Methods:

Attributes:

Source code 
48
49
50
51
def __init__(self, start: int = 0, end: int = 1, duration: int = 1) -> None:
    self.start = start
    self.end = end
    self.duration = duration

duration instance-attribute 

duration = duration

end instance-attribute 

end = end

limit class-attribute instance-attribute 

limit: tuple[int, int] = (0, 1)

start instance-attribute 

start = start

ease 

ease(alpha: float) -> float
Source code 
64
65
66
67
def ease(self, alpha: float) -> float:
    t = self.limit[0] * (1 - alpha) + self.limit[1] * alpha / self.duration
    a = self.func(t)
    return self.end * a + self.start * (1 - a)

func 

func(t: float) -> float
Source code 
111
112
113
114
def func(self, t: float) -> float:
    if t < 0.5:
        return 4 * CubicEaseIn().func(t)
    return 0.5 * CubicEaseOut().func(2 * t - 1)

CubicEaseOut 

CubicEaseOut(start: int = 0, end: int = 1, duration: int = 1)

Bases: EasingBase

Methods:

Attributes:

Source code 
48
49
50
51
def __init__(self, start: int = 0, end: int = 1, duration: int = 1) -> None:
    self.start = start
    self.end = end
    self.duration = duration

duration instance-attribute 

duration = duration

end instance-attribute 

end = end

limit class-attribute instance-attribute 

limit: tuple[int, int] = (0, 1)

start instance-attribute 

start = start

ease 

ease(alpha: float) -> float
Source code 
64
65
66
67
def ease(self, alpha: float) -> float:
    t = self.limit[0] * (1 - alpha) + self.limit[1] * alpha / self.duration
    a = self.func(t)
    return self.end * a + self.start * (1 - a)

func 

func(t: float) -> float
Source code 
106
107
def func(self, t: float) -> float:
    return pow(t - 1, 3) + 1

EasingBase 

EasingBase(start: int = 0, end: int = 1, duration: int = 1)

Bases: EasingBaseMeta

Methods:

Attributes:

Source code 
48
49
50
51
def __init__(self, start: int = 0, end: int = 1, duration: int = 1) -> None:
    self.start = start
    self.end = end
    self.duration = duration

duration instance-attribute 

duration = duration

end instance-attribute 

end = end

limit class-attribute instance-attribute 

limit: tuple[int, int] = (0, 1)

start instance-attribute 

start = start

ease 

ease(alpha: float) -> float
Source code 
64
65
66
67
def ease(self, alpha: float) -> float:
    t = self.limit[0] * (1 - alpha) + self.limit[1] * alpha / self.duration
    a = self.func(t)
    return self.end * a + self.start * (1 - a)

func abstractmethod 

func(t: float) -> float
Source code 
53
54
@abstractmethod
def func(self, t: float) -> float: ...

EasingBaseMeta 

EasingBaseMeta(start: int = 0, end: int = 1, duration: int = 1)

Bases: ABC

Methods:

Attributes:

Source code 
48
49
50
51
def __init__(self, start: int = 0, end: int = 1, duration: int = 1) -> None:
    self.start = start
    self.end = end
    self.duration = duration

duration instance-attribute 

duration = duration

end instance-attribute 

end = end

limit class-attribute instance-attribute 

limit: tuple[int, int] = (0, 1)

start instance-attribute 

start = start

ease abstractmethod 

ease(alpha: float) -> float
Source code 
56
57
@abstractmethod
def ease(self, alpha: float) -> float: ...

func abstractmethod 

func(t: float) -> float
Source code 
53
54
@abstractmethod
def func(self, t: float) -> float: ...

ElasticEaseIn 

ElasticEaseIn(start: int = 0, end: int = 1, duration: int = 1)

Bases: EasingBase

Methods:

Attributes:

Source code 
48
49
50
51
def __init__(self, start: int = 0, end: int = 1, duration: int = 1) -> None:
    self.start = start
    self.end = end
    self.duration = duration

duration instance-attribute 

duration = duration

end instance-attribute 

end = end

limit class-attribute instance-attribute 

limit: tuple[int, int] = (0, 1)

start instance-attribute 

start = start

ease 

ease(alpha: float) -> float
Source code 
64
65
66
67
def ease(self, alpha: float) -> float:
    t = self.limit[0] * (1 - alpha) + self.limit[1] * alpha / self.duration
    a = self.func(t)
    return self.end * a + self.start * (1 - a)

func 

func(t: float) -> float
Source code 
208
209
def func(self, t: float) -> float:
    return sin(13 * pi / 2 * t) * pow(2, 10 * (t - 1))

ElasticEaseInOut 

ElasticEaseInOut(start: int = 0, end: int = 1, duration: int = 1)

Bases: EasingBase

Methods:

Attributes:

Source code 
48
49
50
51
def __init__(self, start: int = 0, end: int = 1, duration: int = 1) -> None:
    self.start = start
    self.end = end
    self.duration = duration

duration instance-attribute 

duration = duration

end instance-attribute 

end = end

limit class-attribute instance-attribute 

limit: tuple[int, int] = (0, 1)

start instance-attribute 

start = start

ease 

ease(alpha: float) -> float
Source code 
64
65
66
67
def ease(self, alpha: float) -> float:
    t = self.limit[0] * (1 - alpha) + self.limit[1] * alpha / self.duration
    a = self.func(t)
    return self.end * a + self.start * (1 - a)

func 

func(t: float) -> float
Source code 
218
219
220
221
def func(self, t: float) -> float:
    if t < 0.5:
        return 0.5 * ElasticEaseIn().func(2 * t)
    return 0.5 * ElasticEaseOut().func(2 * t - 1) + 1

ElasticEaseOut 

ElasticEaseOut(start: int = 0, end: int = 1, duration: int = 1)

Bases: EasingBase

Methods:

Attributes:

Source code 
48
49
50
51
def __init__(self, start: int = 0, end: int = 1, duration: int = 1) -> None:
    self.start = start
    self.end = end
    self.duration = duration

duration instance-attribute 

duration = duration

end instance-attribute 

end = end

limit class-attribute instance-attribute 

limit: tuple[int, int] = (0, 1)

start instance-attribute 

start = start

ease 

ease(alpha: float) -> float
Source code 
64
65
66
67
def ease(self, alpha: float) -> float:
    t = self.limit[0] * (1 - alpha) + self.limit[1] * alpha / self.duration
    a = self.func(t)
    return self.end * a + self.start * (1 - a)

func 

func(t: float) -> float
Source code 
213
214
def func(self, t: float) -> float:
    return sin(-13 * pi / 2 * (t + 1)) * pow(2, -10 * t) + 1

ExponentialEaseIn 

ExponentialEaseIn(start: int = 0, end: int = 1, duration: int = 1)

Bases: EasingBase

Methods:

Attributes:

Source code 
48
49
50
51
def __init__(self, start: int = 0, end: int = 1, duration: int = 1) -> None:
    self.start = start
    self.end = end
    self.duration = duration

duration instance-attribute 

duration = duration

end instance-attribute 

end = end

limit class-attribute instance-attribute 

limit: tuple[int, int] = (0, 1)

start instance-attribute 

start = start

ease 

ease(alpha: float) -> float
Source code 
64
65
66
67
def ease(self, alpha: float) -> float:
    t = self.limit[0] * (1 - alpha) + self.limit[1] * alpha / self.duration
    a = self.func(t)
    return self.end * a + self.start * (1 - a)

func 

func(t: float) -> float
Source code 
184
185
186
187
def func(self, t: float) -> float:
    if t == 0:
        return 0
    return pow(2, 10 * (t - 1))

ExponentialEaseInOut 

ExponentialEaseInOut(start: int = 0, end: int = 1, duration: int = 1)

Bases: EasingBase

Methods:

Attributes:

Source code 
48
49
50
51
def __init__(self, start: int = 0, end: int = 1, duration: int = 1) -> None:
    self.start = start
    self.end = end
    self.duration = duration

duration instance-attribute 

duration = duration

end instance-attribute 

end = end

limit class-attribute instance-attribute 

limit: tuple[int, int] = (0, 1)

start instance-attribute 

start = start

ease 

ease(alpha: float) -> float
Source code 
64
65
66
67
def ease(self, alpha: float) -> float:
    t = self.limit[0] * (1 - alpha) + self.limit[1] * alpha / self.duration
    a = self.func(t)
    return self.end * a + self.start * (1 - a)

func 

func(t: float) -> float
Source code 
198
199
200
201
202
203
204
def func(self, t: float) -> float:
    if t in (0, 1):
        return t

    if t < 0.5:
        return 0.5 * pow(2, (20 * t) - 10)
    return -0.5 * pow(2, (-20 * t) + 10) + 1

ExponentialEaseOut 

ExponentialEaseOut(start: int = 0, end: int = 1, duration: int = 1)

Bases: EasingBase

Methods:

Attributes:

Source code 
48
49
50
51
def __init__(self, start: int = 0, end: int = 1, duration: int = 1) -> None:
    self.start = start
    self.end = end
    self.duration = duration

duration instance-attribute 

duration = duration

end instance-attribute 

end = end

limit class-attribute instance-attribute 

limit: tuple[int, int] = (0, 1)

start instance-attribute 

start = start

ease 

ease(alpha: float) -> float
Source code 
64
65
66
67
def ease(self, alpha: float) -> float:
    t = self.limit[0] * (1 - alpha) + self.limit[1] * alpha / self.duration
    a = self.func(t)
    return self.end * a + self.start * (1 - a)

func 

func(t: float) -> float
Source code 
191
192
193
194
def func(self, t: float) -> float:
    if t == 1:
        return 1
    return 1 - pow(2, -10 * t)

Linear 

Linear(start: int = 0, end: int = 1, duration: int = 1)

Bases: EasingBase

Methods:

Attributes:

Source code 
48
49
50
51
def __init__(self, start: int = 0, end: int = 1, duration: int = 1) -> None:
    self.start = start
    self.end = end
    self.duration = duration

duration instance-attribute 

duration = duration

end instance-attribute 

end = end

limit class-attribute instance-attribute 

limit: tuple[int, int] = (0, 1)

start instance-attribute 

start = start

ease 

ease(alpha: float) -> float
Source code 
64
65
66
67
def ease(self, alpha: float) -> float:
    t = self.limit[0] * (1 - alpha) + self.limit[1] * alpha / self.duration
    a = self.func(t)
    return self.end * a + self.start * (1 - a)

func 

func(t: float) -> float
Source code 
79
80
def func(self, t: float) -> float:
    return t

OnAxis 

OnAxis(start: int = 0, end: int = 1, duration: int = 1)

Bases: EasingBaseMeta

Methods:

Attributes:

Source code 
48
49
50
51
def __init__(self, start: int = 0, end: int = 1, duration: int = 1) -> None:
    self.start = start
    self.end = end
    self.duration = duration

duration instance-attribute 

duration = duration

end instance-attribute 

end = end

limit class-attribute instance-attribute 

limit: tuple[int, int] = (0, 1)

start instance-attribute 

start = start

ease 

ease(alpha: float) -> float
Source code 
74
75
def ease(self, alpha: float) -> float:
    return 0

func 

func(t: float) -> float
Source code 
71
72
def func(self, t: float) -> float:
    return 0

QuadEaseIn 

QuadEaseIn(start: int = 0, end: int = 1, duration: int = 1)

Bases: EasingBase

Methods:

Attributes:

Source code 
48
49
50
51
def __init__(self, start: int = 0, end: int = 1, duration: int = 1) -> None:
    self.start = start
    self.end = end
    self.duration = duration

duration instance-attribute 

duration = duration

end instance-attribute 

end = end

limit class-attribute instance-attribute 

limit: tuple[int, int] = (0, 1)

start instance-attribute 

start = start

ease 

ease(alpha: float) -> float
Source code 
64
65
66
67
def ease(self, alpha: float) -> float:
    t = self.limit[0] * (1 - alpha) + self.limit[1] * alpha / self.duration
    a = self.func(t)
    return self.end * a + self.start * (1 - a)

func 

func(t: float) -> float
Source code 
84
85
def func(self, t: float) -> float:
    return pow(t, 2)

QuadEaseInOut 

QuadEaseInOut(start: int = 0, end: int = 1, duration: int = 1)

Bases: EasingBase

Methods:

Attributes:

Source code 
48
49
50
51
def __init__(self, start: int = 0, end: int = 1, duration: int = 1) -> None:
    self.start = start
    self.end = end
    self.duration = duration

duration instance-attribute 

duration = duration

end instance-attribute 

end = end

limit class-attribute instance-attribute 

limit: tuple[int, int] = (0, 1)

start instance-attribute 

start = start

ease 

ease(alpha: float) -> float
Source code 
64
65
66
67
def ease(self, alpha: float) -> float:
    t = self.limit[0] * (1 - alpha) + self.limit[1] * alpha / self.duration
    a = self.func(t)
    return self.end * a + self.start * (1 - a)

func 

func(t: float) -> float
Source code 
94
95
96
97
def func(self, t: float) -> float:
    if t < 0.5:
        return 2 * QuadEaseIn().func(t)
    return (-2 * t * t) + (4 * t) - 1

QuadEaseOut 

QuadEaseOut(start: int = 0, end: int = 1, duration: int = 1)

Bases: EasingBase

Methods:

Attributes:

Source code 
48
49
50
51
def __init__(self, start: int = 0, end: int = 1, duration: int = 1) -> None:
    self.start = start
    self.end = end
    self.duration = duration

duration instance-attribute 

duration = duration

end instance-attribute 

end = end

limit class-attribute instance-attribute 

limit: tuple[int, int] = (0, 1)

start instance-attribute 

start = start

ease 

ease(alpha: float) -> float
Source code 
64
65
66
67
def ease(self, alpha: float) -> float:
    t = self.limit[0] * (1 - alpha) + self.limit[1] * alpha / self.duration
    a = self.func(t)
    return self.end * a + self.start * (1 - a)

func 

func(t: float) -> float
Source code 
89
90
def func(self, t: float) -> float:
    return -(t * (t - 2))

QuarticEaseIn 

QuarticEaseIn(start: int = 0, end: int = 1, duration: int = 1)

Bases: EasingBase

Methods:

Attributes:

Source code 
48
49
50
51
def __init__(self, start: int = 0, end: int = 1, duration: int = 1) -> None:
    self.start = start
    self.end = end
    self.duration = duration

duration instance-attribute 

duration = duration

end instance-attribute 

end = end

limit class-attribute instance-attribute 

limit: tuple[int, int] = (0, 1)

start instance-attribute 

start = start

ease 

ease(alpha: float) -> float
Source code 
64
65
66
67
def ease(self, alpha: float) -> float:
    t = self.limit[0] * (1 - alpha) + self.limit[1] * alpha / self.duration
    a = self.func(t)
    return self.end * a + self.start * (1 - a)

func 

func(t: float) -> float
Source code 
118
119
def func(self, t: float) -> float:
    return pow(t, 4)

QuarticEaseInOut 

QuarticEaseInOut(start: int = 0, end: int = 1, duration: int = 1)

Bases: EasingBase

Methods:

Attributes:

Source code 
48
49
50
51
def __init__(self, start: int = 0, end: int = 1, duration: int = 1) -> None:
    self.start = start
    self.end = end
    self.duration = duration

duration instance-attribute 

duration = duration

end instance-attribute 

end = end

limit class-attribute instance-attribute 

limit: tuple[int, int] = (0, 1)

start instance-attribute 

start = start

ease 

ease(alpha: float) -> float
Source code 
64
65
66
67
def ease(self, alpha: float) -> float:
    t = self.limit[0] * (1 - alpha) + self.limit[1] * alpha / self.duration
    a = self.func(t)
    return self.end * a + self.start * (1 - a)

func 

func(t: float) -> float
Source code 
128
129
130
131
def func(self, t: float) -> float:
    if t < 0.5:
        return 8 * QuarticEaseIn().func(t)
    return -8 * QuarticEaseOut().func(t)

QuarticEaseOut 

QuarticEaseOut(start: int = 0, end: int = 1, duration: int = 1)

Bases: EasingBase

Methods:

Attributes:

Source code 
48
49
50
51
def __init__(self, start: int = 0, end: int = 1, duration: int = 1) -> None:
    self.start = start
    self.end = end
    self.duration = duration

duration instance-attribute 

duration = duration

end instance-attribute 

end = end

limit class-attribute instance-attribute 

limit: tuple[int, int] = (0, 1)

start instance-attribute 

start = start

ease 

ease(alpha: float) -> float
Source code 
64
65
66
67
def ease(self, alpha: float) -> float:
    t = self.limit[0] * (1 - alpha) + self.limit[1] * alpha / self.duration
    a = self.func(t)
    return self.end * a + self.start * (1 - a)

func 

func(t: float) -> float
Source code 
123
124
def func(self, t: float) -> float:
    return pow(t - 1, 4) + 1

QuinticEaseIn 

QuinticEaseIn(start: int = 0, end: int = 1, duration: int = 1)

Bases: EasingBase

Methods:

Attributes:

Source code 
48
49
50
51
def __init__(self, start: int = 0, end: int = 1, duration: int = 1) -> None:
    self.start = start
    self.end = end
    self.duration = duration

duration instance-attribute 

duration = duration

end instance-attribute 

end = end

limit class-attribute instance-attribute 

limit: tuple[int, int] = (0, 1)

start instance-attribute 

start = start

ease 

ease(alpha: float) -> float
Source code 
64
65
66
67
def ease(self, alpha: float) -> float:
    t = self.limit[0] * (1 - alpha) + self.limit[1] * alpha / self.duration
    a = self.func(t)
    return self.end * a + self.start * (1 - a)

func 

func(t: float) -> float
Source code 
135
136
def func(self, t: float) -> float:
    return pow(t, 5)

QuinticEaseInOut 

QuinticEaseInOut(start: int = 0, end: int = 1, duration: int = 1)

Bases: EasingBase

Methods:

Attributes:

Source code 
48
49
50
51
def __init__(self, start: int = 0, end: int = 1, duration: int = 1) -> None:
    self.start = start
    self.end = end
    self.duration = duration

duration instance-attribute 

duration = duration

end instance-attribute 

end = end

limit class-attribute instance-attribute 

limit: tuple[int, int] = (0, 1)

start instance-attribute 

start = start

ease 

ease(alpha: float) -> float
Source code 
64
65
66
67
def ease(self, alpha: float) -> float:
    t = self.limit[0] * (1 - alpha) + self.limit[1] * alpha / self.duration
    a = self.func(t)
    return self.end * a + self.start * (1 - a)

func 

func(t: float) -> float
Source code 
145
146
147
148
def func(self, t: float) -> float:
    if t < 0.5:
        return 16 * QuinticEaseIn().func(t)
    return 0.5 * QuinticEaseOut().func((2 * t) - 1)

QuinticEaseOut 

QuinticEaseOut(start: int = 0, end: int = 1, duration: int = 1)

Bases: EasingBase

Methods:

Attributes:

Source code 
48
49
50
51
def __init__(self, start: int = 0, end: int = 1, duration: int = 1) -> None:
    self.start = start
    self.end = end
    self.duration = duration

duration instance-attribute 

duration = duration

end instance-attribute 

end = end

limit class-attribute instance-attribute 

limit: tuple[int, int] = (0, 1)

start instance-attribute 

start = start

ease 

ease(alpha: float) -> float
Source code 
64
65
66
67
def ease(self, alpha: float) -> float:
    t = self.limit[0] * (1 - alpha) + self.limit[1] * alpha / self.duration
    a = self.func(t)
    return self.end * a + self.start * (1 - a)

func 

func(t: float) -> float
Source code 
140
141
def func(self, t: float) -> float:
    return pow(t - 1, 5) + 1

SineEaseIn 

SineEaseIn(start: int = 0, end: int = 1, duration: int = 1)

Bases: EasingBase

Methods:

Attributes:

Source code 
48
49
50
51
def __init__(self, start: int = 0, end: int = 1, duration: int = 1) -> None:
    self.start = start
    self.end = end
    self.duration = duration

duration instance-attribute 

duration = duration

end instance-attribute 

end = end

limit class-attribute instance-attribute 

limit: tuple[int, int] = (0, 1)

start instance-attribute 

start = start

ease 

ease(alpha: float) -> float
Source code 
64
65
66
67
def ease(self, alpha: float) -> float:
    t = self.limit[0] * (1 - alpha) + self.limit[1] * alpha / self.duration
    a = self.func(t)
    return self.end * a + self.start * (1 - a)

func 

func(t: float) -> float
Source code 
152
153
def func(self, t: float) -> float:
    return sin((t - 1) * pi / 2) + 1

SineEaseInOut 

SineEaseInOut(start: int = 0, end: int = 1, duration: int = 1)

Bases: EasingBase

Methods:

Attributes:

Source code 
48
49
50
51
def __init__(self, start: int = 0, end: int = 1, duration: int = 1) -> None:
    self.start = start
    self.end = end
    self.duration = duration

duration instance-attribute 

duration = duration

end instance-attribute 

end = end

limit class-attribute instance-attribute 

limit: tuple[int, int] = (0, 1)

start instance-attribute 

start = start

ease 

ease(alpha: float) -> float
Source code 
64
65
66
67
def ease(self, alpha: float) -> float:
    t = self.limit[0] * (1 - alpha) + self.limit[1] * alpha / self.duration
    a = self.func(t)
    return self.end * a + self.start * (1 - a)

func 

func(t: float) -> float
Source code 
162
163
def func(self, t: float) -> float:
    return 0.5 * (1 - cos(t * pi))

SineEaseOut 

SineEaseOut(start: int = 0, end: int = 1, duration: int = 1)

Bases: EasingBase

Methods:

Attributes:

Source code 
48
49
50
51
def __init__(self, start: int = 0, end: int = 1, duration: int = 1) -> None:
    self.start = start
    self.end = end
    self.duration = duration

duration instance-attribute 

duration = duration

end instance-attribute 

end = end

limit class-attribute instance-attribute 

limit: tuple[int, int] = (0, 1)

start instance-attribute 

start = start

ease 

ease(alpha: float) -> float
Source code 
64
65
66
67
def ease(self, alpha: float) -> float:
    t = self.limit[0] * (1 - alpha) + self.limit[1] * alpha / self.duration
    a = self.func(t)
    return self.end * a + self.start * (1 - a)

func 

func(t: float) -> float
Source code 
157
158
def func(self, t: float) -> float:
    return sin(t * pi / 2)