From 27efc68c521bfd7d29467c9e528001aa5992d6d2 Mon Sep 17 00:00:00 2001
From: Joe Wreschnig <joe.wreschnig@gmail.com>
Date: Tue, 13 May 2014 18:20:23 +0200
Subject: [PATCH] Interpolate between numeral-ish strings numerically.

---
 string-lerp.js | 82 +++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 74 insertions(+), 8 deletions(-)

diff --git a/string-lerp.js b/string-lerp.js
index 0a3d452..8d5a879 100644
--- a/string-lerp.js
+++ b/string-lerp.js
@@ -79,8 +79,8 @@
         return s;
     }
 
-    function slowLerp(a, b, p) {
-        /** Interpolate between two strings slowly
+    function diffLerp(a, b, p) {
+        /** Interpolate between two strings based on edit distance
 
             This interpolation algorithm applys a partial edit of one
             string into the other. This produces nice looking results,
@@ -93,26 +93,91 @@
         return patch(partial, a);
     }
 
+    var NUMBERS = /(-?\d+(?:\.\d+)?)/g
+
+    function areNumericTwins(a, b) {
+        /** Check if a and b differ only in numerals
+
+            A leading "-" counts as part of numbers; a leading "+"
+            does not. Numbers may contain a single ".", but no other
+            floating point syntax.
+        */
+        return a.replace(NUMBERS, "0") === b.replace(NUMBERS, "0");
+    }
+
+    function nlerp(a, b, p) {
+        return a + (b - a) * p;
+    }
+
+    function numericLerp(a, b, p) {
+        /** Interpolate numerically between two strings containing numbers
+
+            Numbers may have a leading "-" and a single "." to mark
+            the decimal point, but something must be after the ".".
+            If both of the numbers in a pair are integers, the result
+            is clamped to an integer.
+
+            For example, numericLerp("0.0", "100", 0.123) === "12.3"
+            because the "." in "0.0" is intepreted as a decimal point.
+            But numericLerp("0.", "100.", 0.123) === "12." because the
+            strings are interpreted as integers followed by a full
+            stop.
+
+            Calling this functions on strings that differ in more than
+            numerals gives undefined results.
+         */
+        var aParts = a.split(NUMBERS);
+        var bParts = b.split(NUMBERS);
+        for (var i = 1; i < aParts.length; i += 2) {
+            var part = nlerp(+aParts[i], +bParts[i], p)
+            if (aParts[i].indexOf(".") === -1 && bParts[i].indexOf(".") === -1)
+                part = Math.round(part);
+            aParts[i] = part.toString();
+        }
+        return aParts.join("");
+    }
+
     function fastLerp(a, b, p) {
-        /** Interpolate between two strings very quickly
+        /** Interpolate between two strings based on length
 
             This interpolation algorithm progressively replaces the
             front of one string with another. This approach is fast
             but does not look good when the strings are similar.
-         */
+        */
         var alen = Math.round(a.length * p);
         var blen = Math.round(b.length * p);
         return b.substring(0, blen) + a.substring(alen, a.length);
     }
 
     function lerp(a, b, p) {
+        /** Interpolate between two strings as best as possible
+
+            If the strings are identical aside from numbers in them,
+            they are passed through numericLerp.
+
+            If the strings are not numbers and short, they are passed
+            through diffLerp.
+
+            Otherwise, they are passed through fastLerp.
+        */
         a = a.toString();
         b = b.toString();
+
+        // Fast path for boundary cases.
+        if (p === 0) return a;
+        if (p === 1) return b;
+
+        if (areNumericTwins(a, b))
+            return numericLerp(a, b, p)
+
+        // Numeric lerps should over- and under-shoot when fed numbers
+        // outside 0 to 1, but other types cannot.
+        if (p < 0) return a;
+        if (p > 1) return b;
+
         var n = a.length * b.length;
-        // TODO: if both strings are integers, do an integer lerp.
-        // TODO: if both strings are numbers, do a numeric lerp.
         return (n && n < MAX_MATRIX_SIZE)
-            ? slowLerp(a, b, p)
+            ? diffLerp(a, b, p)
             : fastLerp(a, b, p);
     }
 
@@ -120,7 +185,8 @@
     exports.patch = patch;
     exports.diff = diff;
     exports.fastLerp = fastLerp;
-    exports.slowLerp = slowLerp;
+    exports.diffLerp = diffLerp;
+    exports.numericLerp = numericLerp;
     exports.lerp = lerp;
 
 })(typeof exports === "undefined" ? (this.stringLerp = {}) : exports);
-- 
2.20.1