author Joe Wreschnig Tue, 13 May 2014 16:20:23 +0000 (18:20 +0200) committer Joe Wreschnig Tue, 13 May 2014 16:20:23 +0000 (18:20 +0200)
 string-lerp.js patch | blob | history

index 0a3d452..8d5a879 100644 (file)
@@ -79,8 +79,8 @@
return s;
}

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,

This interpolation algorithm applys a partial edit of one
string into the other. This produces nice looking results,
return patch(partial, a);
}

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) {
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.

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) {
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();
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;
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)
return (n && n < MAX_MATRIX_SIZE)
-            ? slowLerp(a, b, p)
+            ? diffLerp(a, b, p)
: fastLerp(a, b, p);
}

: fastLerp(a, b, p);
}

exports.patch = patch;
exports.diff = diff;
exports.fastLerp = fastLerp;
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);
exports.lerp = lerp;

})(typeof exports === "undefined" ? (this.stringLerp = {}) : exports);