Easing function exploration via plotting

```
// This is a script to explore easing/interpolation functions via plotting
cleari()
showAxes()
showGrid()
val target = 300
val duration = 200
// change shownFn below to any of the "available" functions defined
// further down in this script. Then run the script to see a plot of
// how the function goes from 0 to target in the given time duration
// x axis shows time duration
// y axis shows progress towards target
val shownFn = elasticInOut(_)
def plot(xs: Seq[Int], ys: Seq[Double]) = Picture.fromVertexShape { s =>
import s._
beginShape()
repeatFor(xs.zip(ys)) { case (x, y) =>
vertex(x, y)
}
endShape()
}
// functions available for plotting in this script
def linear(x: Double) = x
def quad(x: Double) = math.pow(x, 2)
def cubic(x: Double) = math.pow(x, 3)
// the inbuilt Kojo easing functions take 4 inputs
// Our (simplified) plottable functions take 1 input
// the function defined below "adapts" a Kojo easing function
// so that it becomes plottable in this script
def adaptedEasing(x: Double, easingFn: (Double, Double, Double, Double) => Double) =
easingFn(0, target, x, duration)
def quadIn(x: Double) = adaptedEasing(x, easing.QuadIn.ease)
def quadOut(x: Double) = adaptedEasing(x, easing.QuadOut.ease)
def quadInOut(x: Double) = adaptedEasing(x, easing.QuadInOut.ease)
def elasticIn(x: Double) = adaptedEasing(x, easing.ElasticIn.ease)
def elasticOut(x: Double) = adaptedEasing(x, easing.ElasticOut.ease)
def elasticInOut(x: Double) = adaptedEasing(x, easing.ElasticInOut.ease)
def circIn(x: Double) = adaptedEasing(x, easing.CircIn.ease)
def circOut(x: Double) = adaptedEasing(x, easing.CircOut.ease)
def circInOut(x: Double) = adaptedEasing(x, easing.CircInOut.ease)
def expIn(x: Double) = adaptedEasing(x, easing.ExpoIn.ease)
def expOut(x: Double) = adaptedEasing(x, easing.ExpoOut.ease)
def expInOut(x: Double) = adaptedEasing(x, easing.ExpoInOut.ease)
// end of available functions section; add more above as desired
def normalizedYs(fn: Double => Double, xrange: Seq[Int], dest: Double): Seq[Double] = {
val yvals = xrange.map(x => fn(x))
val sf = dest / yvals.last
yvals.map(y => y * sf)
}
val xs = 0 to duration
val ys = normalizedYs(shownFn, xs, target)
val pic = plot(xs, ys)
draw(pic)
```