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 
25
26
27
28
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 
43
44
45
46
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 
204
205
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 
25
26
27
28
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 
43
44
45
46
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 
214
215
216
217
218
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 
25
26
27
28
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 
43
44
45
46
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 
209
210
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 
25
26
27
28
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 
43
44
45
46
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 
222
223
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 
25
26
27
28
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 
43
44
45
46
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 
240
241
242
243
244
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 
25
26
27
28
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 
43
44
45
46
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 
227
228
229
230
231
232
233
234
235
236
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 
25
26
27
28
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 
43
44
45
46
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 
146
147
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 
25
26
27
28
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 
43
44
45
46
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 
156
157
158
159
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 
25
26
27
28
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 
43
44
45
46
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 
151
152
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 
25
26
27
28
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 
43
44
45
46
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 
80
81
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 
25
26
27
28
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 
43
44
45
46
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 
90
91
92
93
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 
25
26
27
28
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 
43
44
45
46
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 
85
86
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 
25
26
27
28
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 
43
44
45
46
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 
30
31
32
@abstractmethod
def func(self, t: float) -> float:
    ...

EasingBaseMeta 

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

Bases: ABC

Methods:

Attributes:

Source code 
25
26
27
28
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 
34
35
36
@abstractmethod
def ease(self, alpha: float) -> float:
    ...

func abstractmethod 

func(t: float) -> float
Source code 
30
31
32
@abstractmethod
def func(self, t: float) -> float:
    ...

ElasticEaseIn 

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

Bases: EasingBase

Methods:

Attributes:

Source code 
25
26
27
28
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 
43
44
45
46
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 
187
188
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 
25
26
27
28
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 
43
44
45
46
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 
197
198
199
200
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 
25
26
27
28
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 
43
44
45
46
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 
192
193
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 
25
26
27
28
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 
43
44
45
46
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 
163
164
165
166
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 
25
26
27
28
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 
43
44
45
46
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
181
182
183
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 
25
26
27
28
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 
43
44
45
46
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 
170
171
172
173
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 
25
26
27
28
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 
43
44
45
46
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 
58
59
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 
25
26
27
28
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 
53
54
def ease(self, alpha: float) -> float:
    return 0

func 

func(t: float) -> float
Source code 
50
51
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 
25
26
27
28
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 
43
44
45
46
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 
63
64
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 
25
26
27
28
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 
43
44
45
46
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 
73
74
75
76
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 
25
26
27
28
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 
43
44
45
46
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 
68
69
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 
25
26
27
28
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 
43
44
45
46
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 
97
98
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 
25
26
27
28
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 
43
44
45
46
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 
107
108
109
110
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 
25
26
27
28
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 
43
44
45
46
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 
102
103
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 
25
26
27
28
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 
43
44
45
46
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 
114
115
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 
25
26
27
28
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 
43
44
45
46
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 
124
125
126
127
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 
25
26
27
28
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 
43
44
45
46
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 
119
120
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 
25
26
27
28
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 
43
44
45
46
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 
131
132
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 
25
26
27
28
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 
43
44
45
46
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 
141
142
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 
25
26
27
28
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 
43
44
45
46
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 
136
137
def func(self, t: float) -> float:
    return sin(t * pi / 2)