anchor.diff:          | Attractor of Vector2 * single * single
           | Drag of single * single
           | Velocity of Constraint
  -
  -    /// Describes the life of an instance value.
  -    /// OPTIMIZATION: LifeTimeOpt uses 0L to represent infinite life.
  -    /// OPTIMIZATION: doesn't use Liveness type to avoid its constructor calls.
  -    /// OPTIMIZATION: pre-computes progress scalar to minimize number of divides.
  -    type [<StructuralEquality; NoComparison; Struct>] Life =
  -        { StartTime : int64
  -          LifeTimeOpt : int64
  -          ProgressScalar : single }
  -
  -        /// The progress made through the instance's life.
  -        static member getProgress time life =
  -            match life.LifeTimeOpt with
  -            | 0L -> 0.0f
  -            | _ -> single (time - life.StartTime) * life.ProgressScalar
  -
  -        /// The liveness of the instance as a boolean.
  -        static member getLiveness time life =
  -            match life.LifeTimeOpt with
  -            | 0L -> true
  -            | lifeTime -> lifeTime < time - life.StartTime
  -
  -        static member make startTime lifeTimeOpt =
  -            { StartTime = startTime
  -              LifeTimeOpt = lifeTimeOpt
  -              ProgressScalar = 1.0f / single lifeTimeOpt }
   
       /// Describes the body of an instance value.
       type [<StructuralEquality; NoComparison; Struct>] Body =
  
positive.code:                 fun _ _ targets ->
                      let targets =
                          Array.map (fun struct (targetLife, targetValue) ->
                              let progress = Life.getProgress time targetLife
                              let progressScaled = float progress * Math.PI * 0.5
                              let progressEaseIn = 1.0 + Math.Sin (progressScaled + Math.PI * 1.5)
                              let result = applyRange targetValue (value + scale (value2 - value, single progressEaseIn))
  
negative.code:                 fun _ _ targets ->
                      let targets =
                          Array.map (fun struct (targetLife, targetValue) ->
                              let progress = Life.getProgress3 time range.RangeLife targetLife
                              let progressScaled = float progress * Math.PI * 2.0 * float scalar
                              let progressCos = Math.Cos progressScaled
                              let result = applyRange targetValue (value + scale (value2 - value, single progressCos))
  