return (newCanvasCoords: Coords2d, final: boolean) => {
let canvasOffset = newCanvasCoords.asOffsetFrom(canvasCoords);
let modelOffset = canvasToModel.transformOffset(canvasOffset);
let indexOffset = Math.round(modelOffset.dx / intervalWidth);
let newIndex = selectedIndex + indexOffset;
if (currentIndex != newIndex) {
currentIndex = newIndex;
let forwardMap: Array<number> = originalPermutation.forwardMap;
let newForwardMap: Array<number> = forwardMap.map(
(index: number) => {
if (index < Math.min(selectedIndex, newIndex) ||
index > Math.max(selectedIndex, newIndex)) {
return index;
}
if (index == selectedIndex) {
return newIndex;
}
if (selectedIndex < newIndex) {
return index - 1;
}
return index + 1;
});
let newPermutation =
Permutation.fromForwardMap(newForwardMap);
if (selectedRow == 0) {
this.inputOrder = newPermutation;
} else {
this.outputOrder = newPermutation;
}
this.setNeedsRedraw();
}
};
return (newCanvasCoords: Coords2d, final: boolean) => {
let canvasOffset = newCanvasCoords.asOffsetFrom(canvasCoords);
let modelOffset = canvasToModel.transformOffset(canvasOffset);
let newPosition = modelCoords.x + modelOffset.dx;
let delta = newPosition - modelCoords.x;
let rationalDelta = Rational.approximationForNumber(delta, 5);
let newLeftBoundary =
intervals[oldIndex].leftBoundary.plus(rationalDelta);
// Find the output interval index closest to newLeftBoundary
let curPos = intervals[0].leftBoundary;
let newIndex = 0;
for (let i = 0; i < intervals.length; i++) {
if (i == oldIndex) {
continue;
}
let curLength = intervals[i].length;
let centerPos =
curPos.plus(curLength.dividedBy(Rational.fromInt(2)));
if (centerPos.greaterThan(newLeftBoundary)) {
break;
}
newIndex++;
curPos = curPos.plus(curLength);
}
if (currentIndex != newIndex) {
console.log(`Moving to index ${newIndex}`);
currentIndex = newIndex;
let forwardMap: Array<number> =
intervalExchangeMap.permutation.forwardMap;
let newForwardMap: Array<number> = forwardMap.map(
(outputIndex: number) => {
if (outputIndex < Math.min(oldIndex, newIndex) ||
outputIndex > Math.max(oldIndex, newIndex)) {
return outputIndex;
}
if (outputIndex == oldIndex) {
return newIndex;
}
if (oldIndex < newIndex) {
return outputIndex - 1;
}
return outputIndex + 1;
});
let newPermutation =
Permutation.fromForwardMap(newForwardMap);
this.intervalExchangeMap.set(
IntervalExchangeMap.fromLengthsAndPermutation(
intervalExchangeMap.intervalLengths, newPermutation));
}
};
return (newCanvasCoords: Coords2d, final: boolean) => {
let canvasOffset = newCanvasCoords.asOffsetFrom(canvasCoords);
let modelOffset = canvasToModel.transformOffset(canvasOffset);
let newPosition = modelCoords.x + modelOffset.dx;
newPosition = Math.max(newPosition, minValue);
newPosition = Math.min(newPosition, maxValue);
let delta = newPosition - modelCoords.x;
let rationalDelta = Rational.approximationForNumber(delta, 5);
let newLengths = intervalExchangeMap.intervalLengths.map((x) => x);
newLengths[targetIndex] =
newLengths[targetIndex].plus(rationalDelta);
newLengths[targetIndex + 1] =
newLengths[targetIndex + 1].minus(rationalDelta);
this.intervalExchangeMap.set(
IntervalExchangeMap.fromLengthsAndPermutation(
newLengths, intervalExchangeMap.permutation));
};