Add closed-form damped harmonic oscillator algorithm to Animated.spring

Summary:
As I was working on mimicking iOS animations for my ongoing work with `react-navigation`, one task I had was to match the "push from right" animation that is common in UINavigationController.

I was able to grab the exact animation values for this animation with some LLDB magic, and found that the screen is animated using a `CASpringAnimation` with the parameters:

- stiffness: 1000
- damping: 500
- mass: 3

After spending a considerable amount of time attempting to replicate the spring created with these values by CASpringAnimation by specifying values for tension and friction in the current `Animated.spring` implementation, I was unable to come up with mathematically equivalent values that could replicate the spring _exactly_.

After doing some research, I ended up disassembling the QuartzCore framework, reading the assembly, and determined that Apple's implementation of `CASpringAnimation` does not use an integrated, numerical animation model as we do in Animated.spring, but instead solved for the closed form of the equations that govern damped harmonic oscillation (the differential equations themselves are [here](https://en.wikipedia.org/wiki/Harmonic_oscillator#Damped_harmonic_oscillator), and a paper describing the math to arrive at the closed-form solution to the second-order ODE that describes the DHO is [here](http://planetmath.org/sites/default/files/texpdf/39745.pdf)).

Though we can get the currently implemented RK4 integration close by tweaking some values, it is, the current model is at it's core, an approximation. It seemed that if I wanted to implement the `CASpringAnimation` behavior _exactly_, I needed to implement the analytical model (as is implemented in `CASpringAnimation`) in `Animated`.

We add three new optional parameters to `Animated.spring` (to both the JS and native implementations):

- `stiffness`, a value describing the spring's stiffness coefficient
- `damping`, a value defining how the spring's motion should be damped due to the forces of friction (technically called the _viscous damping coefficient_).
- `mass`, a value describing the mass of the object attached to the end of the simulated spring

Just like if a developer were to specify `bounciness`/`speed` and `tension`/`friction` in the same config, specifying any of these new parameters while also specifying the aforementioned config values will cause an error to be thrown.

~Defaults for `Animated.spring` across all three implementations (JS/iOS/Android) stay the same, so this is intended to be *a non-breaking change*.~

~If `stiffness`, `damping`, or `mass` are provided in the config, we switch to animating the spring with the new damped harmonic oscillator model (`DHO` as described in the code).~

We replace the old RK4 integration implementation with our new analytic implementation. Tension/friction nicely correspond directly to stiffness/damping with the mass of the spring locked at 1. This is intended to be *a non-breaking change*, but there may be very slight differences in people's springs (maybe not even noticeable to the naked eye), given the fact that this implementation is more accurate.

The DHO animation algorithm will calculate the _position_ of the spring at time _t_ explicitly and in an analytical fashion, and use this calculation to update the animation's value. It will also analytically calculate the velocity at time _t_, so as to allow animated value tracking to continue to work as expected.

Also, docs have been updated to cover the new configuration options (and also I added docs for Animated configuration options that were missing, such as `restDisplacementThreshold`, etc).

Run tests. Run "Animated Gratuitous App" and "NativeAnimation" example in RNTester.
Closes facebook#15322

Differential Revision: D5794791

Pulled By: hramos

fbshipit-source-id: 58ed9e134a097e321c85c417a142576f6a8952f8

Libraries/Animated/src/AnimatedImplementation.js

@@ -698,6 +698,8 @@ module.exports = {
    *
    *   - `velocity`: Initial velocity.  Required.
    *   - `deceleration`: Rate of decay.  Default 0.997.
+   *   - `isInteraction`: Whether or not this animation creates an "interaction handle" on the
+   *     `InteractionManager`. Default true.
    *   - `useNativeDriver`: Uses the native driver when true. Default false.
    */
   decay,
@@ -712,21 +714,56 @@ module.exports = {
    *   - `easing`: Easing function to define curve.
    *     Default is `Easing.inOut(Easing.ease)`.
    *   - `delay`: Start the animation after delay (milliseconds).  Default 0.
+   *   - `isInteraction`: Whether or not this animation creates an "interaction handle" on the
+   *     `InteractionManager`. Default true.
    *   - `useNativeDriver`: Uses the native driver when true. Default false.
    */
   timing,
   /**
-   * Spring animation based on Rebound and
-   * [Origami](https://facebook.github.io/origami/).  Tracks velocity state to
-   * create fluid motions as the `toValue` updates, and can be chained together.
+   * Animates a value according to an analytical spring model based on
+   * [damped harmonic oscillation](https://en.wikipedia.org/wiki/Harmonic_oscillator#Damped_harmonic_oscillator).
+   * Tracks velocity state to create fluid motions as the `toValue` updates, and
+   * can be chained together.
    *
-   * Config is an object that may have the following options. Note that you can
-   * only define bounciness/speed or tension/friction but not both:
+   * Config is an object that may have the following options.
+   *
+   * Note that you can only define one of bounciness/speed, tension/friction, or
+   * stiffness/damping/mass, but not more than one:
+   *
+   * The friction/tension or bounciness/speed options match the spring model in
+   * [Facebook Pop](https://github.com/facebook/pop), [Rebound](http://facebook.github.io/rebound/),
+   * and [Origami](http://origami.design/).
    *
    *   - `friction`: Controls "bounciness"/overshoot.  Default 7.
    *   - `tension`: Controls speed.  Default 40.
    *   - `speed`: Controls speed of the animation. Default 12.
    *   - `bounciness`: Controls bounciness. Default 8.
+   *
+   * Specifying stiffness/damping/mass as parameters makes `Animated.spring` use an
+   * analytical spring model based on the motion equations of a [damped harmonic
+   * oscillator](https://en.wikipedia.org/wiki/Harmonic_oscillator#Damped_harmonic_oscillator).
+   * This behavior is slightly more precise and faithful to the physics behind
+   * spring dynamics, and closely mimics the implementation in iOS's
+   * CASpringAnimation primitive.
+   *
+   *   - `stiffness`: The spring stiffness coefficient. Default 100.
+   *   - `damping`: Defines how the spring’s motion should be damped due to the forces of friction.
+   *     Default 10.
+   *   - `mass`: The mass of the object attached to the end of the spring. Default 1.
+   *
+   * Other configuration options are as follows:
+   *
+   *   - `velocity`: The initial velocity of the object attached to the spring. Default 0 (object
+   *     is at rest).
+   *   - `overshootClamping`: Boolean indiciating whether the spring should be clamped and not
+   *     bounce. Default false.
+   *   - `restDisplacementThreshold`: The threshold of displacement from rest below which the
+   *     spring should be considered at rest. Default 0.001.
+   *   - `restSpeedThreshold`: The speed at which the spring should be considered at rest in pixels
+   *     per second. Default 0.001.
+   *   - `delay`: Start the animation after delay (milliseconds).  Default 0.
+   *   - `isInteraction`: Whether or not this animation creates an "interaction handle" on the
+   *     `InteractionManager`. Default true.
    *   - `useNativeDriver`: Uses the native driver when true. Default false.
    */
   spring,

Libraries/Animated/src/SpringConfig.js

@@ -13,15 +13,15 @@
 'use strict';
 
 type SpringConfigType = {
-  tension: number,
-  friction: number,
+  stiffness: number,
+  damping: number,
 };
 
-function tensionFromOrigamiValue(oValue) {
+function stiffnessFromOrigamiValue(oValue) {
   return (oValue - 30) * 3.62 + 194;
 }
 
-function frictionFromOrigamiValue(oValue) {
+function dampingFromOrigamiValue(oValue) {
   return (oValue - 8) * 3 + 25;
 }
 
@@ -30,8 +30,8 @@ function fromOrigamiTensionAndFriction(
   friction: number,
 ): SpringConfigType {
   return {
-    tension: tensionFromOrigamiValue(tension),
-    friction: frictionFromOrigamiValue(friction)
+    stiffness: stiffnessFromOrigamiValue(tension),
+    damping: dampingFromOrigamiValue(friction),
   };
 }
 
@@ -91,8 +91,8 @@ function fromBouncinessAndSpeed(
   );
 
   return {
-    tension: tensionFromOrigamiValue(bouncyTension),
-    friction: frictionFromOrigamiValue(bouncyFriction)
+    stiffness: stiffnessFromOrigamiValue(bouncyTension),
+    damping: dampingFromOrigamiValue(bouncyFriction),
   };
 }
 

Libraries/Animated/src/__tests__/Animated-test.js

@@ -135,7 +135,7 @@ describe('Animated tests', () => {
       expect(callback).toBeCalled();
     });
 
-    it('send toValue when a spring stops', () => {
+    it('send toValue when an underdamped spring stops', () => {
       var anim = new Animated.Value(0);
       var listener = jest.fn();
       anim.addListener(listener);
@@ -147,6 +147,18 @@ describe('Animated tests', () => {
       expect(anim.__getValue()).toBe(15);
     });
 
+    it('send toValue when a critically damped spring stops', () => {
+      var anim = new Animated.Value(0);
+      var listener = jest.fn();
+      anim.addListener(listener);
+      Animated.spring(anim, {stiffness: 8000, damping: 2000, toValue: 15}).start();
+      jest.runAllTimers();
+      var lastValue = listener.mock.calls[listener.mock.calls.length - 2][0].value;
+      expect(lastValue).not.toBe(15);
+      expect(lastValue).toBeCloseTo(15);
+      expect(anim.__getValue()).toBe(15);
+    });
+
     it('convert to JSON', () => {
       expect(JSON.stringify(new Animated.Value(10))).toBe('10');
     });

Libraries/Animated/src/__tests__/AnimatedNative-test.js

@@ -594,12 +594,38 @@ describe('Native Animated', () => {
         jasmine.any(Number),
         {
           type: 'spring',
-          friction: 16,
+          stiffness: 679.08,
+          damping: 16,
+          mass: 1,
+          initialVelocity: 0,
+          overshootClamping: false,
+          restDisplacementThreshold: 0.001,
+          restSpeedThreshold: 0.001,
+          toValue: 10,
+          iterations: 1,
+        },
+        jasmine.any(Function)
+      );
+
+      Animated.spring(anim, {
+        toValue: 10,
+        stiffness: 1000,
+        damping: 500,
+        mass: 3,
+        useNativeDriver: true
+      }).start();
+      expect(nativeAnimatedModule.startAnimatingNode).toBeCalledWith(
+        jasmine.any(Number),
+        jasmine.any(Number),
+        {
+          type: 'spring',
+          stiffness: 1000,
+          damping: 500,
+          mass: 3,
           initialVelocity: 0,
           overshootClamping: false,
           restDisplacementThreshold: 0.001,
           restSpeedThreshold: 0.001,
-          tension: 679.08,
           toValue: 10,
           iterations: 1,
         },
@@ -612,12 +638,13 @@ describe('Native Animated', () => {
         jasmine.any(Number),
         {
           type: 'spring',
-          friction: 23.05223140901191,
+          damping: 23.05223140901191,
           initialVelocity: 0,
           overshootClamping: false,
           restDisplacementThreshold: 0.001,
           restSpeedThreshold: 0.001,
-          tension: 299.61882352941177,
+          stiffness: 299.61882352941177,
+          mass: 1,
           toValue: 10,
           iterations: 1,
         },