imterah/element-portable
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Iterate algorithm, base it on new js-sdk string lib

Browse source
This commit is contained in:
Michael Telatynski 2021-06-14 21:28:32 +01:00
parent 4af2675e23
commit 8fd72fcf79
2 changed files with 98 additions and 100 deletions
Download patch file Download diff file Expand all files Collapse all files

77
src/utils/stringOrderField.ts
View file

@ -14,6 +14,8 @@ See the License for the specific language governing permissions and
limitations under the License.
*/
import { alphabetPad, baseToString, stringToBase } from "matrix-js-sdk/src/utils";
import { reorder } from "./arrays";
export const ALPHABET_START = 0x20;
@ -23,23 +25,6 @@ export const ALPHABET = new Array(1 + ALPHABET_END - ALPHABET_START)
.map((_, i) => String.fromCharCode(ALPHABET_START + i))
.join("");
export const baseToString = (base: bigint, alphabet = ALPHABET): string => {
const len = BigInt(alphabet.length);
if (base < len) return alphabet[Number(base)];
return baseToString(base / len, alphabet) + alphabet[Number(base % len)];
};
export const stringToBase = (str: string, alphabet = ALPHABET): bigint => {
let result = BigInt(0);
const len = BigInt(alphabet.length);
for (let i = str.length - 1, j = BigInt(0); i >= 0; i--, j++) {
result += BigInt(str.charCodeAt(i) - alphabet.charCodeAt(0)) * (len ** j);
}
return result;
};
const pad = (str: string, length: number, alphabet = ALPHABET): string => str.padEnd(length, alphabet[0]);
export const midPointsBetweenStrings = (
a: string,
b: string,
@ -47,26 +32,28 @@ export const midPointsBetweenStrings = (
maxLen: number,
alphabet = ALPHABET,
): string[] => {
const n = Math.min(maxLen, Math.max(a.length, b.length));
const aPadded = pad(a, n, alphabet);
const bPadded = pad(b, n, alphabet);
const aBase = stringToBase(aPadded, alphabet);
const bBase = stringToBase(bPadded, alphabet);
if (bBase - aBase - BigInt(1) < count) {
if (n < maxLen) {
const padN = Math.min(Math.max(a.length, b.length), maxLen);
const padA = alphabetPad(a, padN, alphabet);
const padB = alphabetPad(b, padN, alphabet);
const baseA = stringToBase(padA, alphabet);
const baseB = stringToBase(padB, alphabet);
if (baseB - baseA - BigInt(1) < count) {
if (padN < maxLen) {
// this recurses once at most due to the new limit of n+1
return midPointsBetweenStrings(
pad(aPadded, n + 1, alphabet),
pad(bPadded, n + 1, alphabet),
alphabetPad(padA, padN + 1, alphabet),
alphabetPad(padB, padN + 1, alphabet),
count,
n + 1,
padN + 1,
alphabet,
);
}
return [];
}
const step = (bBase - aBase) / BigInt(count + 1);
const start = BigInt(aBase + step);
const step = (baseB - baseA) / BigInt(count + 1);
const start = BigInt(baseA + step);
return Array(count).fill(undefined).map((_, i) => baseToString(start + (BigInt(i) * step), alphabet));
};
@ -95,6 +82,7 @@ export const reorderLexicographically = (
// apply the fundamental order update to the zipped array
const newOrder = reorder(ordersWithIndices, fromIndex, toIndex);
// check if we have to fill undefined orders to complete placement
const orderToLeftUndefined = newOrder[toIndex - 1]?.order === undefined;
let leftBoundIdx = toIndex;
@ -105,14 +93,19 @@ export const reorderLexicographically = (
? stringToBase(newOrder[toIndex + 1].order)
: BigInt(Number.MAX_VALUE);
// check how far left we would have to mutate to fit in that direction
for (let i = toIndex - 1, j = 1; i >= 0; i--, j++) {
if (newOrder[i]?.order !== undefined && nextBase - stringToBase(newOrder[i].order) > j) break;
leftBoundIdx = i;
}
// verify the left move would be sufficient
const firstOrderBase = newOrder[0].order === undefined ? undefined : stringToBase(newOrder[0].order);
const bigToIndex = BigInt(toIndex);
if (leftBoundIdx === 0 &&
newOrder[0].order !== undefined &&
nextBase - stringToBase(newOrder[0].order) < toIndex
firstOrderBase !== undefined &&
nextBase - firstOrderBase <= bigToIndex &&
firstOrderBase <= bigToIndex
) {
canMoveLeft = false;
}
@ -124,11 +117,13 @@ export const reorderLexicographically = (
? stringToBase(newOrder[toIndex - 1]?.order)
: BigInt(Number.MIN_VALUE);
// check how far right we would have to mutate to fit in that direction
for (let i = toIndex + 1, j = 1; i < newOrder.length; i++, j++) {
if (newOrder[i]?.order === undefined || stringToBase(newOrder[i].order) - prevBase > j) break; // TODO verify
if (newOrder[i]?.order === undefined || stringToBase(newOrder[i].order) - prevBase > j) break;
rightBoundIdx = i;
}
// verify the right move would be sufficient
if (rightBoundIdx === newOrder.length - 1 &&
(newOrder[rightBoundIdx]
? stringToBase(newOrder[rightBoundIdx].order)
@ -138,27 +133,23 @@ export const reorderLexicographically = (
}
}
// pick the cheaper direction
const leftDiff = canMoveLeft ? toIndex - leftBoundIdx : Number.MAX_SAFE_INTEGER;
const rightDiff = canMoveRight ? rightBoundIdx - toIndex : Number.MAX_SAFE_INTEGER;
if (orderToLeftUndefined || leftDiff < rightDiff) {
rightBoundIdx = toIndex;
} else {
leftBoundIdx = toIndex;
}
const prevOrder = newOrder[leftBoundIdx - 1]?.order
?? String.fromCharCode(ALPHABET_START).repeat(5);
const prevOrder = newOrder[leftBoundIdx - 1]?.order ?? "";
const nextOrder = newOrder[rightBoundIdx + 1]?.order
?? String.fromCharCode(ALPHABET_END).repeat(prevOrder.length);
?? String.fromCharCode(ALPHABET_END).repeat(prevOrder.length || 1);
const changes = midPointsBetweenStrings(prevOrder, nextOrder, 1 + rightBoundIdx - leftBoundIdx, maxLen);
console.log("@@ test", { canMoveLeft, canMoveRight, prevOrder, nextOrder, changes, leftBoundIdx, rightBoundIdx, orders, fromIndex, toIndex, newOrder, orderToLeftUndefined, leftDiff, rightDiff });
return changes.map((order, i) => {
const index = newOrder[leftBoundIdx + i].index;
return { index, order };
});
return changes.map((order, i) => ({
index: newOrder[leftBoundIdx + i].index,
order,
}));
};