@teselagen/range-utils 0.1.20 → 0.1.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teselagen/range-utils",
-  "version": "0.1.20",
+  "version": "0.1.22",
   "type": "commonjs",
   "dependencies": {
     "lodash": "^4.17.21"

package/src/adjustRangeToDeletionOfAnotherRange.js

@@ -0,0 +1,53 @@
+import splitRangeIntoTwoPartsIfItIsCircular from "./splitRangeIntoTwoPartsIfItIsCircular";
+import trimRangeByAnotherRange from "./trimRangeByAnotherRange";
+
+//takes in two potentially circular ranges and returns the first one trimmed by the second one
+//returns null if no range is left after the trimming
+export default function adjustRangeToDeletionOfAnotherRange(
+  rangeToBeAdjusted,
+  anotherRange,
+  maxLength
+) {
+  // ac.throw(ac.range, rangeToBeAdjusted)
+  // ac.throw(ac.range, anotherRange)
+  // ac.throw(ac.posInt, maxLength)
+
+  const trimmedRange = trimRangeByAnotherRange(
+    rangeToBeAdjusted,
+    anotherRange,
+    maxLength
+  );
+  if (trimmedRange) {
+    //if there is a range left after being trimmed, adjust it by the deleted anotherRange
+    //we can make some awesome logical simplifications because we know that the two ranges do not overlap (since we've already trimmed the rangeToBeAdjusted)
+    const nonCircularDeletionRanges = splitRangeIntoTwoPartsIfItIsCircular(
+      anotherRange,
+      maxLength
+    );
+    nonCircularDeletionRanges.forEach(function (nonCircularDeletionRange) {
+      const deletionLength =
+        nonCircularDeletionRange.end - nonCircularDeletionRange.start + 1;
+      if (trimmedRange.start > trimmedRange.end) {
+        //the trimmed range is circular
+        if (nonCircularDeletionRange.start < trimmedRange.end) {
+          trimmedRange.start -= deletionLength;
+          trimmedRange.end -= deletionLength;
+        } else if (nonCircularDeletionRange.start < trimmedRange.start) {
+          trimmedRange.start -= deletionLength;
+        } else {
+          //do nothing
+        }
+      } else {
+        if (nonCircularDeletionRange.start < trimmedRange.start) {
+          trimmedRange.start -= deletionLength;
+          trimmedRange.end -= deletionLength;
+        } else if (nonCircularDeletionRange.start < trimmedRange.end) {
+          trimmedRange.end -= deletionLength;
+        } else {
+          //do nothing
+        }
+      }
+    });
+  }
+  return trimmedRange;
+}

package/src/adjustRangeToDeletionOfAnotherRange.test.js

@@ -0,0 +1,107 @@
+
+
+import adjustRangeToDeletionOfAnotherRange from './adjustRangeToDeletionOfAnotherRange.js';
+
+import assert from 'assert';
+describe('adjustRangeToDeletionOfAnotherRange', function() {
+    it('deletes non circular range if fully overlapped', function() {
+        assert.deepEqual(adjustRangeToDeletionOfAnotherRange({
+            start: 10,
+            end: 20
+        }, {
+            start: 10,
+            end: 20
+        }, 30), null);
+    });
+    it('deletes circular range if fully overlapped', function() {
+        assert.deepEqual(adjustRangeToDeletionOfAnotherRange({
+            start: 20,
+            end: 10
+        }, {
+            start: 20,
+            end: 10
+        }, 30), null);
+    });
+    it('shifts start and end if deleting before non circular range', function() {
+        assert.deepEqual(adjustRangeToDeletionOfAnotherRange({
+            name: 'happy',
+            start: 10,
+            end: 20
+        }, {
+            start: 5,
+            end: 8
+        }, 30), {
+            name: 'happy',
+            start: 6,
+            end: 16
+        });
+    });
+    it('shifts start if deleting in middle of non circular range', function() {
+        assert.deepEqual(adjustRangeToDeletionOfAnotherRange({
+            name: 'happy',
+            start: 20,
+            end: 10
+        }, {
+            start: 15,
+            end: 20
+        }, 30), {
+            name: 'happy',
+            start: 15,
+            end: 10
+        });
+        assert.deepEqual(adjustRangeToDeletionOfAnotherRange({
+            start: 20,
+            end: 10
+        }, {
+            start: 15,
+            end: 15
+        }, 30), {
+            start: 19,
+            end: 10
+        });
+    });
+    it('shifts start and end if deleting before end of non circular range', function() {
+        assert.deepEqual(adjustRangeToDeletionOfAnotherRange({
+            start: 20,
+            end: 10
+        }, {
+            start: 0,
+            end: 0
+        }, 30), {
+            start: 19,
+            end: 9
+        });
+        assert.deepEqual(adjustRangeToDeletionOfAnotherRange({
+            start: 20,
+            end: 10
+        }, {
+            start: 5,
+            end: 15
+        }, 30), {
+            start: 9,
+            end: 4
+        });
+    });
+    it('shifts neither start nor end if deleting after start of non circular range', function() {
+        assert.deepEqual(adjustRangeToDeletionOfAnotherRange({
+            start: 20,
+            end: 10
+        }, {
+            start: 25,
+            end: 27
+        }, 30), {
+            start: 20,
+            end: 10
+        });
+        assert.deepEqual(adjustRangeToDeletionOfAnotherRange({
+            start: 20,
+            end: 10
+        }, {
+            start: 20,
+            end: 25
+        }, 30), {
+            start: 20,
+            end: 10
+        });
+    });
+});

package/src/adjustRangeToInsert.js

@@ -0,0 +1,28 @@
+
+import {assign} from "lodash";
+
+export default function adjustRangeToInsert(rangeToBeAdjusted, insertStart, insertLength) {
+    // ac.throw([ac.range, ac.posInt, ac.posInt], arguments);
+    const newRange = assign({}, rangeToBeAdjusted);
+    if (rangeToBeAdjusted.start > rangeToBeAdjusted.end) {
+        //circular range
+        if (rangeToBeAdjusted.end >= insertStart) {
+            //adjust both start and end
+            newRange.start += insertLength;
+            newRange.end += insertLength;
+        } else if (rangeToBeAdjusted.start >= insertStart) {
+            //adjust just the start
+            newRange.start += insertLength;
+        }
+    } else {
+        if (rangeToBeAdjusted.start >= insertStart) {
+            //adjust both start and end
+            newRange.start += insertLength;
+            newRange.end += insertLength;
+        } else if (rangeToBeAdjusted.end >= insertStart) {
+            //adjust just the end
+            newRange.end += insertLength;
+        }
+    }
+    return newRange;
+};

package/src/adjustRangeToInsert.test.js

@@ -0,0 +1,111 @@
+
+
+
+import adjustRangeToInsert from './adjustRangeToInsert.js';
+
+import assert from 'assert';
+describe('adjustRangeToInsert', function() {
+    it('shifts start and end if inserting before non circular range', function() {
+        assert.deepEqual(adjustRangeToInsert({
+            start: 10,
+            end: 20
+        }, 4, 5), {
+            start: 15,
+            end: 25
+        });
+        assert.deepEqual(adjustRangeToInsert({
+            start: 10,
+            end: 20
+        }, 10, 5), {
+            start: 15,
+            end: 25
+        });
+        assert.deepEqual(adjustRangeToInsert({
+            start: 10,
+            end: 20
+        }, 0, 5), {
+            start: 15,
+            end: 25
+        });
+    });
+    it('shifts end if inserting in middle of non circular range', function() {
+        assert.deepEqual(adjustRangeToInsert({
+            start: 10,
+            end: 20
+        }, 11, 5), {
+            start: 10,
+            end: 25
+        });
+        assert.deepEqual(adjustRangeToInsert({
+            start: 10,
+            end: 20
+        }, 20, 5), {
+            start: 10,
+            end: 25
+        });
+    });
+    it('shifts neither start nor end if inserting in after end of non circular range', function() {
+        assert.deepEqual(adjustRangeToInsert({
+            start: 10,
+            end: 20
+        }, 24, 5), {
+            start: 10,
+            end: 20
+        });
+        assert.deepEqual(adjustRangeToInsert({
+            start: 10,
+            end: 20
+        }, 21, 5), {
+            start: 10,
+            end: 20
+        });
+    });
+    it('shifts neither start nor end if inserting in after start of circular range', function() {
+        assert.deepEqual(adjustRangeToInsert({
+            start: 20,
+            end: 10
+        }, 24, 5), {
+            start: 20,
+            end: 10
+        });
+        assert.deepEqual(adjustRangeToInsert({
+            start: 20,
+            end: 10
+        }, 21, 5), {
+            start: 20,
+            end: 10
+        });
+    });
+    it('shifts both start and end if inserting in before end of circular range', function() {
+        assert.deepEqual(adjustRangeToInsert({
+            start: 20,
+            end: 10
+        }, 5, 5), {
+            start: 25,
+            end: 15
+        });
+        assert.deepEqual(adjustRangeToInsert({
+            start: 20,
+            end: 10
+        }, 10, 5), {
+            start: 25,
+            end: 15
+        });
+    });
+    it('shifts just start if inserting in after end but before start of circular range', function() {
+        assert.deepEqual(adjustRangeToInsert({
+            start: 20,
+            end: 10
+        }, 11, 5), {
+            start: 25,
+            end: 10
+        });
+        assert.deepEqual(adjustRangeToInsert({
+            start: 20,
+            end: 10
+        }, 20, 5), {
+            start: 25,
+            end: 10
+        });
+    });
+});

package/src/adjustRangeToRotation.js

@@ -0,0 +1,24 @@
+
+import {assign} from "lodash";
+
+import {identity} from 'lodash';
+
+export default function adjustRangeToRotation(
+  rangeToBeAdjusted,
+  rotateTo = 0,
+  rangeLength
+) {
+  // ac.throw([ac.range, ac.posInt, ac.posInt], arguments);
+  const mod = rangeLength ? modulo : identity
+
+  const newRange = assign({}, rangeToBeAdjusted, {
+    start: mod(rangeToBeAdjusted.start - (rotateTo || 0), rangeLength),
+    end: mod(rangeToBeAdjusted.end - (rotateTo || 0), rangeLength)
+  });
+
+  return newRange;
+};
+
+function modulo(n, m) {
+  return ((n % m) + m) % m;
+}

package/src/adjustRangeToRotation.test.js

@@ -0,0 +1,123 @@
+import adjustRangeToRotation from './adjustRangeToRotation.js';
+
+import assert from 'assert';
+
+
+;
+describe('adjustRangeToRotation', function() {
+    it('defaults to a rotateBy=0 if a null or undefined is passed ', () => {
+        assert.deepEqual(adjustRangeToRotation({
+            start: 1,
+            end: 2
+        }, null, 10), {
+            start: 1,
+            end: 2
+        });
+
+        assert.deepEqual(adjustRangeToRotation({
+            start: 1,
+            end: 2
+        }, undefined, 10), {
+            start: 1,
+            end: 2
+        });
+        assert.deepEqual(adjustRangeToRotation({
+            start: 1,
+            end: 2
+        }, NaN, 10), {
+            start: 1,
+            end: 2
+        });
+
+    });
+    it('defaults to an infinite length if no length is passed', () => {
+        assert.deepEqual(adjustRangeToRotation({
+            start: 1,
+            end: 2
+        }, 1, null), {
+            start: 0,
+            end: 1
+        });
+        assert.deepEqual(adjustRangeToRotation({
+            start: 1,
+            end: 2
+        }, 1, undefined), {
+            start: 0,
+            end: 1
+        });
+
+
+
+    });
+    it('shifts start and end if rotating before non circular range', function() {
+        //0123456789
+        //atgcatgccc
+        // rr
+        //
+        assert.deepEqual(adjustRangeToRotation({
+            start: 1,
+            end: 2
+        }, 1, 10), {
+            start: 0,
+            end: 1
+        });
+        assert.deepEqual(adjustRangeToRotation({
+            start: 1,
+            end: 2
+        }, undefined, 10), {
+            start: 1,
+            end: 2
+        });
+        assert.deepEqual(adjustRangeToRotation({
+            start: 1,
+            end: 2
+        }, 2, 10), {
+            start: 9,
+            end: 0
+        });
+        assert.deepEqual(adjustRangeToRotation({
+            start: 1,
+            end: 2
+        }, 3, 10), {
+            start: 8,
+            end: 9
+        });
+        //0123456789
+        //atgcatgccc
+        //rrrrr  rrr
+        //
+        assert.deepEqual(adjustRangeToRotation({
+            start: 7,
+            end: 4
+        }, 3, 10), {
+            start: 4,
+            end: 1
+        });
+        assert.deepEqual(adjustRangeToRotation({
+            start: 7,
+            end: 4
+        }, 5, 10), {
+            start: 2,
+            end: 9
+        });
+        assert.deepEqual(adjustRangeToRotation({
+            start: 7,
+            end: 4
+        }, 6, 10), {
+            start: 1,
+            end: 8
+        });
+        //0123456 789
+        //atgcatg ccc
+        //rrrrrrr rrr
+        //
+        assert.deepEqual(adjustRangeToRotation({
+            start: 7,
+            end: 6
+        }, 3, 10), {
+            start: 4,
+            end: 3
+        });
+    });
+
+});

package/src/checkIfNonCircularRangesOverlap.js

@@ -0,0 +1,30 @@
+//
+// ac.throw([ac.posInt, ac.posInt, ac.bool], arguments);
+export default function checkIfNonCircularRangesOverlap(range, comparisonRange) {
+    // ac.throw([ac.range, ac.range], arguments);
+    if (range.start < comparisonRange.start) {
+        if (range.end < comparisonRange.start) {
+      //----llll
+      //--------cccc
+      //no overlap
+            return false;
+        } else {
+      //----llll
+      //-------cccc
+      //overlap
+            return true;
+        }
+    } else {
+        if (range.start > comparisonRange.end) {
+      //------llll
+      // -cccc
+      //no overlap
+            return false;
+        } else {
+      //-----llll
+      // -cccc
+      //overlap
+            return true;
+        }
+    }
+};

package/src/checkIfNonCircularRangesOverlap.test.js

@@ -0,0 +1,45 @@
+import {expect} from 'chai';
+
+import checkIfNonCircularRangesOverlap from './checkIfNonCircularRangesOverlap.js';
+// checkIfNonCircularRangesOverlap(frame, sequence, minimumOrfSize, forward, circular)
+describe('checkIfNonCircularRangesOverlap', function() {
+    it('returns true if non circular ranges do overlap', function() {
+        expect(checkIfNonCircularRangesOverlap({
+            start: 5,
+            end: 100
+        }, {
+            start: 50,
+            end: 50
+        })).to.equal(true);
+        expect(checkIfNonCircularRangesOverlap({
+            start: 5,
+            end: 100
+        }, {
+            start: 50,
+            end: 500
+        })).to.equal(true);
+        expect(checkIfNonCircularRangesOverlap({
+            start: 5,
+            end: 100
+        }, {
+            start: 0,
+            end: 5
+        })).to.equal(true);
+    });
+    it('returns false if non circular ranges do not overlap', function() {
+        expect(checkIfNonCircularRangesOverlap({
+            start: 5,
+            end: 100
+        }, {
+            start: 1,
+            end: 4
+        })).to.equal(false);
+        expect(checkIfNonCircularRangesOverlap({
+            start: 5,
+            end: 100
+        }, {
+            start: 101,
+            end: 101
+        })).to.equal(false);
+    });
+});

package/src/checkIfPotentiallyCircularRangesOverlap.js

@@ -0,0 +1,16 @@
+//
+import checkIfNonCircularRangesOverlap from './checkIfNonCircularRangesOverlap';
+
+import splitRangeIntoTwoPartsIfItIsCircular from './splitRangeIntoTwoPartsIfItIsCircular';
+// ac.throw([ac.posInt, ac.posInt, ac.bool], arguments);
+
+export default function checkIfPotentiallyCircularRangesOverlap(range, comparisonRange) {
+    // ac.throw([ac.range, ac.range], arguments);
+    //split the potentially circular ranges and compare each part for overlap
+    return splitRangeIntoTwoPartsIfItIsCircular(range, Infinity).some(function (splitRange) {
+      return splitRangeIntoTwoPartsIfItIsCircular(comparisonRange, Infinity).some(function (splitComparisonRange) {
+        return checkIfNonCircularRangesOverlap(splitRange, splitComparisonRange);
+      })
+    })
+};
+

package/src/checkIfPotentiallyCircularRangesOverlap.test.js

@@ -0,0 +1,73 @@
+import {expect} from 'chai';
+
+import checkIfPotentiallyCircularRangesOverlap from './checkIfPotentiallyCircularRangesOverlap.js';
+// checkIfPotentiallyCircularRangesOverlap(frame, sequence, minimumOrfSize, forward, circular)
+describe('checkIfPotentiallyCircularRangesOverlap', function() {
+    it('returns true if ranges do overlap', function() {
+        expect(checkIfPotentiallyCircularRangesOverlap({
+            start: 5,
+            end: 100
+        }, {
+            start: 50,
+            end: 50
+        })).to.equal(true);
+        expect(checkIfPotentiallyCircularRangesOverlap({
+            start: 5,
+            end: 100
+        }, {
+            start: 50,
+            end: 500
+        })).to.equal(true);
+        expect(checkIfPotentiallyCircularRangesOverlap({
+            start: 5,
+            end: 100
+        }, {
+            start: 0,
+            end: 5
+        })).to.equal(true);
+        expect(checkIfPotentiallyCircularRangesOverlap({
+            start: 50,
+            end: 10
+        }, {
+            start: 0,
+            end: 5
+        })).to.equal(true);
+        expect(checkIfPotentiallyCircularRangesOverlap({
+            start: 50,
+            end: 10
+        }, {
+            start: 20,
+            end: 5
+        })).to.equal(true);
+        expect(checkIfPotentiallyCircularRangesOverlap({
+            start: 50,
+            end: 10
+        }, {
+            start: 20,
+            end: 51
+        })).to.equal(true);
+    });
+    it('returns false if ranges do not overlap', function() {
+        expect(checkIfPotentiallyCircularRangesOverlap({
+            start: 5,
+            end: 100
+        }, {
+            start: 1,
+            end: 4
+        })).to.equal(false);
+        expect(checkIfPotentiallyCircularRangesOverlap({
+            start: 50,
+            end: 10
+        }, {
+            start: 20,
+            end: 49
+        })).to.equal(false);
+        expect(checkIfPotentiallyCircularRangesOverlap({
+            start: 5,
+            end: 100
+        }, {
+            start: 101,
+            end: 101
+        })).to.equal(false);
+    });
+});

package/src/collapseOverlapsGeneratedFromRangeComparisonIfPossible.js

@@ -0,0 +1,47 @@
+
+
+//this function is a little confusing, but basically it takes an array of overlaps 
+//generated from a range overlaps calculation, and it sews them together if possible
+export default function collapseOverlapsGeneratedFromRangeComparisonIfPossible(overlaps, sequenceLength, optionalOriginalRange) {
+    const originalRangeLinear = optionalOriginalRange && (optionalOriginalRange.start <= optionalOriginalRange.end)
+    if (overlaps.length === 1 || overlaps.length === 0) {
+        return overlaps;
+    } else if (overlaps.length === 2) {
+        if (overlaps[0].start === 0 && overlaps[1].end + 1 === sequenceLength && !originalRangeLinear) {
+            return [{
+                start: overlaps[1].start,
+                end: overlaps[0].end
+            }];
+        } else if (overlaps[1].start === 0 && overlaps[0].end + 1 === sequenceLength && !originalRangeLinear) {
+            return [{
+                start: overlaps[0].start,
+                end: overlaps[1].end
+            }];
+        } else {
+            return overlaps;
+        }
+    } else if (overlaps.length === 3) {
+        const firstOverlap = overlaps[0];
+        const secondOverlap = overlaps[1];
+        const thirdOverlap = overlaps[2];
+        let collapsedOverlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible([firstOverlap, secondOverlap], sequenceLength, optionalOriginalRange);
+        if (collapsedOverlaps.length === 1) {
+            collapsedOverlaps.push(thirdOverlap);
+            return collapsedOverlaps;
+        } else {
+            collapsedOverlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible([firstOverlap, thirdOverlap], sequenceLength, optionalOriginalRange);
+            if (collapsedOverlaps.length === 1) {
+                collapsedOverlaps.push(secondOverlap);
+                return collapsedOverlaps;
+            } else {
+                collapsedOverlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible([secondOverlap, thirdOverlap], sequenceLength, optionalOriginalRange);
+                if (collapsedOverlaps.length === 1) {
+                    collapsedOverlaps.push(firstOverlap);
+                    return collapsedOverlaps;
+                } else {
+                    return overlaps;
+                }
+            }
+        }
+    }
+};