# Easing

The `Easing` module implements common easing functions. This module is used by `Animated.timing()` to convey physically believable motion in animations.

You can find a visualization of some common easing functions at https://easings.net/

### Predefined animationsβ

The `Easing` module provides several predefined animations through the following methods:

### Standard functionsβ

Three standard easing functions are provided:

The `poly` function can be used to implement quartic, quintic, and other higher power functions.

Additional mathematical functions are provided by the following methods:

The following helpers are used to modify other easing functions.

# Reference

## Methodsβ

### `step0()`β

``static step0(n: number);``

A stepping function, returns 1 for any positive value of `n`.

### `step1()`β

``static step1(n: number);``

A stepping function, returns 1 if `n` is greater than or equal to 1.

### `linear()`β

``static linear(t: number);``

A linear function, `f(t) = t`. Position correlates to elapsed time one to one.

https://cubic-bezier.com/#0,0,1,1

### `ease()`β

``static ease(t: number);``

A basic inertial interaction, similar to an object slowly accelerating to speed.

https://cubic-bezier.com/#.42,0,1,1

### `quad()`β

``static quad(t: number);``

A quadratic function, `f(t) = t * t`. Position equals the square of elapsed time.

### `cubic()`β

``static cubic(t: number);``

A cubic function, `f(t) = t * t * t`. Position equals the cube of elapsed time.

https://easings.net/#easeInCubic

### `poly()`β

``static poly(n: number);``

A power function. Position is equal to the Nth power of elapsed time.

### `sin()`β

``static sin(t: number);``

A sinusoidal function.

https://easings.net/#easeInSine

### `circle()`β

``static circle(t: number);``

A circular function.

https://easings.net/#easeInCirc

### `exp()`β

``static exp(t: number);``

An exponential function.

https://easings.net/#easeInExpo

### `elastic()`β

``static elastic(bounciness: number);``

A basic elastic interaction, similar to a spring oscillating back and forth.

Default bounciness is 1, which overshoots a little bit once. 0 bounciness doesn't overshoot at all, and bounciness of N > 1 will overshoot about N times.

https://easings.net/#easeInElastic

### `back()`β

``static back(s)``

Use with `Animated.parallel()` to create a basic effect where the object animates back slightly as the animation starts.

### `bounce()`β

``static bounce(t: number);``

Provides a basic bouncing effect.

https://easings.net/#easeInBounce

### `bezier()`β

``static bezier(x1: number, y1: number, x2: number, y2: number);``

Provides a cubic bezier curve, equivalent to CSS Transitions' `transition-timing-function`.

A useful tool to visualize cubic bezier curves can be found at https://cubic-bezier.com/

### `in()`β

``static in(easing: number);``

Runs an easing function forwards.

### `out()`β

``static out(easing: number);``

Runs an easing function backwards.

### `inOut()`β

``static inOut(easing: number);``

Makes any easing function symmetrical. The easing function will run forwards for half of the duration, then backwards for the rest of the duration.