From 0c13ad2908e977aca58e5411e724881abca7228b Mon Sep 17 00:00:00 2001 From: Joe Wreschnig Date: Mon, 19 May 2014 03:26:12 +0200 Subject: [PATCH] Finish renaming a/b/p to source/target/amount. Start splitting up functions for arrays/astrals and strings/basics. --- string-lerp.js | 98 ++++++++++++++++++++++++++------------------ tests/string-lerp.js | 33 +++++++++++++++ 2 files changed, 90 insertions(+), 41 deletions(-) diff --git a/string-lerp.js b/string-lerp.js index fdf7df8..607abc1 100644 --- a/string-lerp.js +++ b/string-lerp.js @@ -92,27 +92,30 @@ return editPath(costMatrix(source, target, ins, del, sub), target); } - function patch(diff, source) { - /** Apply a list of edits to source */ - var edit; - var i; + function patchArray(diff, source) { + for (var i = 0; i < diff.length; ++i) { + var edit = diff[i]; + source.splice(edit[1], edit[0], edit[2]); + } + return source; + } - if (Array.isArray(source)) { - for (i = 0; i < diff.length; ++i) { - edit = diff[i]; - source.splice(edit[1], edit[0], edit[2]); - } - } else { - for (i = 0; i < diff.length; ++i) { - edit = diff[i]; - var head = source.slice(0, edit[1]); - var tail = source.slice(edit[1] + edit[0]); - source = head + edit[2] + tail; - } + function patchString(diff, source) { + for (var i = 0; i < diff.length; ++i) { + var edit = diff[i]; + var head = source.slice(0, edit[1]); + var tail = source.slice(edit[1] + edit[0]); + source = head + edit[2] + tail; } return source; } + function patch(diff, source) { + /** Apply a list of edits to source */ + var patcher = Array.isArray(source) ? patchArray : patchString; + return patcher(diff, source); + } + var MULTI = /[\uD800-\uDBFF][\uDC00-\uDFFF]|[\u0300-\u036F\u1DC0-\u1DFF\u20D0-\u20FF\uFE20-\uFE2F]/; var GLYPH = /([\0-\u02FF\u0370-\u1DBF\u1E00-\u20CF\u2100-\uD7FF\uDC00-\uFE1F\uFE30-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF])([\u0300-\u036F\u1DC0-\u1DFF\u20D0-\u20FF\uFE20-\uFE2F]*)/g; @@ -134,6 +137,8 @@ // This split is not perfect for all languages, but at least // it won't create invalid surrogate pairs or orphaned // combining characters. + // + // TODO: The way this is called is a hack. if (source.match && (source.match(MULTI) || target.match(MULTI))) { var sourceGlyphs = source.match(GLYPH) || []; var targetGlyphs = target.match(GLYPH) || []; @@ -196,7 +201,26 @@ return targetParts.join(""); } - function fastLerp(a, b, p) { + function fastLerpAstral(source, target, amount) { + var sourceGlyphs = source.match(GLYPH) || []; + var targetGlyphs = target.match(GLYPH) || []; + var sourceLength = Math.round(sourceGlyphs.length * amount); + var targetLength = Math.round(targetGlyphs.length * amount); + var head = targetGlyphs.slice(0, targetLength); + var tail = sourceGlyphs.slice(sourceLength, sourceGlyphs.length); + head.push.apply(head, tail); + return head.join(""); + } + + function fastLerpBasic(source, target, amount) { + var sourceLength = Math.round(source.length * amount); + var targetLength = Math.round(target.length * amount); + var head = target.substring(0, targetLength); + var tail = source.substring(sourceLength, source.length); + return head + tail; + } + + function fastLerp(source, target, amount) { /** Interpolate between two strings based on length This interpolation algorithm progressively replaces the @@ -208,22 +232,13 @@ // strings, e.g. in the megabyte range. These are large enough // that it should be fine to just pick a codepoint and search // for the nearest glyph start. - if (a.match(MULTI) || b.match(MULTI)) { - var ca = a.match(GLYPH) || []; - var cb = b.match(GLYPH) || []; - var calen = Math.round(ca.length * p); - var cblen = Math.round(cb.length * p); - var r = cb.slice(0, cblen); - r.push.apply(r, ca.slice(calen, ca.length)); - return r.join(""); - } else { - var alen = Math.round(a.length * p); - var blen = Math.round(b.length * p); - return b.substring(0, blen) + a.substring(alen, a.length); - } + if (source.match(MULTI) || target.match(MULTI)) + return fastLerpAstral(source, target, amount); + else + return fastLerpBasic(source, target, amount); } - function lerp(a, b, p) { + function lerp(source, target, amount) { /** Interpolate between two strings as best as possible If the strings are identical aside from numbers in them, @@ -234,23 +249,24 @@ Otherwise, they are passed through fastLerp. */ - a = a.toString(); - b = b.toString(); + source = source.toString(); + target = target.toString(); // Fast path for boundary cases. - if (p === 0) return a; - if (p === 1) return b; + if (amount === 0) return source; + if (amount === 1) return target; - if (areNumericTwins(a, b)) - return numericLerp(a, b, p); + if (areNumericTwins(source, target)) + return numericLerp(source, target, amount); // 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; + if (amount < 0) return source; + if (amount > 1) return target; - var n = a.length * b.length; - return ((n && n < MAX_MATRIX_SIZE) ? diffLerp : fastLerp)(a, b, p); + var n = source.length * target.length; + var appropriate = (n && n < MAX_MATRIX_SIZE) ? diffLerp : fastLerp; + return appropriate(source, target, amount); } exports.costMatrix = costMatrix; diff --git a/tests/string-lerp.js b/tests/string-lerp.js index 7cee7d1..0a68921 100644 --- a/tests/string-lerp.js +++ b/tests/string-lerp.js @@ -169,3 +169,36 @@ JS.Test.describe('numeric lerp', function () { with (this) { assertEqual("Chapter 5. The sky was rgb(0, 0, 128).", lerp(A, B, 0.5)); }}); }}); + +JS.Test.describe('fast lerp', function () { with (this) { + var lerp = m.lerp; + var A = "Do you like green eggs and ham?"; + var B = "I do not like them, Sam-I-am."; + + it("handles empty strings", function () { with (this) { + assertEqual("", lerp("", "", -1)); + assertEqual("", lerp("", "", 0)); + assertEqual("", lerp("", "", 0.5)); + assertEqual("", lerp("", "", 1)); + assertEqual("", lerp("", "", 2)); + }}); + + it("maintains identity", function () { with (this) { + for (var i = -1; i < 2; i += 1/1024) { + assertEqual(A, lerp(A, A, i)); + assertEqual(B, lerp(B, B, i)); + } + }}); + + it("handles lows", function () { with (this) { + assertEqual(A, lerp(A, B, -Infinity)); + assertEqual(A, lerp(A, B, -1)); + assertEqual(A, lerp(A, B, 0)); + }}); + + it("handles highs", function () { with (this) { + assertEqual(B, lerp(A, B, 1)); + assertEqual(B, lerp(A, B, 2)); + assertEqual(B, lerp(A, B, Infinity)); + }}); +}}); -- 2.20.1