Interpolate between numeral-ish strings numerically.

diff --git a/string-lerp.js b/string-lerp.js
index 0a3d4527394aca621dce985adf14343eb4db4d9e..8d5a87974ef8049aabff8fe01b331dab1cc9ce81 100644 (file)
--- 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);