)
}
}
)
(
}
{
)
)
(
)
(
(
{
}
)
(
)
}
)
)
{
(
(
)
)
}
)
(
}

### Raphaël Easing Equations

1. `var ef = R.easing_formulas = {`
2. `    linear: function (n) {`
3. `        return n;`
4. `    },`
5. `    "<": function (n) {`
6. `        return pow(n, 1.7);`
7. `    },`
8. `    ">": function (n) {`
9. `        return pow(n, .48);`
10. `    },`
11. `    "<>": function (n) {`
12. `        var q = .48 - n / 1.04,`
13. `            Q = math.sqrt(.1734 + q * q),`
14. `            x = Q - q,`
15. `            X = pow(abs(x), 1 / 3) * (x < 0 ? -1 : 1),`
16. `            y = -Q - q,`
17. `            Y = pow(abs(y), 1 / 3) * (y < 0 ? -1 : 1),`
18. `            t = X + Y + .5;`
19. `        return (1 - t) * 3 * t * t + t * t * t;`
20. `    },`
21. `    backIn: function (n) {`
22. `        var s = 1.70158;`
23. `        return n * n * ((s + 1) * n - s);`
24. `    },`
25. `    backOut: function (n) {`
26. `        n = n - 1;`
27. `        var s = 1.70158;`
28. `        return n * n * ((s + 1) * n + s) + 1;`
29. `    },`
30. `    elastic: function (n) {`
31. `        if (n == !!n) {`
32. `            return n;`
33. `        }`
34. `        return pow(2, -10 * n) * math.sin((n - .075) * (2 * PI) / .3) + 1;`
35. `    },`
36. `    bounce: function (n) {`
37. `        var s = 7.5625,`
38. `            p = 2.75,`
39. `            l;`
40. `        if (n < (1 / p)) {`
41. `            l = s * n * n;`
42. `        } else {`
43. `            if (n < (2 / p)) {`
44. `                n -= (1.5 / p);`
45. `                l = s * n * n + .75;`
46. `            } else {`
47. `                if (n < (2.5 / p)) {`
48. `                    n -= (2.25 / p);`
49. `                    l = s * n * n + .9375;`
50. `                } else {`
51. `                    n -= (2.625 / p);`
52. `                    l = s * n * n + .984375;`
53. `                }`
54. `            }`
55. `        }`
56. `        return l;`
57. `    }`
58. `};`
59. `ef.easeIn = ef["ease-in"] = ef["<"];`
60. `ef.easeOut = ef["ease-out"] = ef[">"];`
61. `ef.easeInOut = ef["ease-in-out"] = ef["<>"];`
62. `ef["back-in"] = ef.backIn;`
63. `ef["back-out"] = ef.backOut;`

Another fun chunk of code directly from the Raphaël source. Makes me think of the Penner easing equations.

snippet.zone ~ 2021-23 /// {s/z}