@teselagen/range-utils 0.1.20 → 0.1.22

package/src/isRangeWithinRange.js

@@ -0,0 +1,17 @@
+//TNR: THIS METHOD ONLY WORKS FOR COMPARING 0-BASED RANGES!!!!!!
+import trimRangeByAnotherRange from "./trimRangeByAnotherRange";
+
+export default function isRangeWithinRange(
+  rangeToCheck,
+  containingRange,
+  maxLength
+) {
+    
+  const ranges = trimRangeByAnotherRange(
+    rangeToCheck,
+    containingRange,
+    maxLength
+  );
+  if (ranges === null) return false
+  return !ranges;
+};

package/src/loopEachPositionInRange.js

@@ -0,0 +1,5 @@
+import getEachPositionInRangeAsArray from './getEachPositionInRangeAsArray';
+
+export default function loopEachPositionInRange(range, rangeMax, func) {
+    getEachPositionInRangeAsArray(range,rangeMax).map(func)
+};

package/src/modulatePositionByRange.js

@@ -0,0 +1,10 @@
+//this function takes a position that might not fit in a given range and puts it into that range
+export default function modulatePositionByRange(position, range) {
+    let returnVal = position;
+    if (position < range.start) {
+      returnVal = range.end - (range.start - (position + 1))
+    } else if (position > range.end) {
+      returnVal = range.start + (position - range.end - 1)
+    }
+    return returnVal
+};

package/src/modulatePositionByRange.test.js

@@ -0,0 +1,12 @@
+import modulatePositionByRange from './modulatePositionByRange';
+import {expect} from 'chai';
+
+describe('modulatePositionByRange', function() {
+    it('should modulate positions by their min and max', function() {
+        expect(modulatePositionByRange(0,{start: 1, end: 10})).to.equal(10)
+        expect(modulatePositionByRange(11,{start: 1, end: 10})).to.equal(1)
+        expect(modulatePositionByRange(0,{start: 0, end: 10})).to.equal(0)
+        expect(modulatePositionByRange(10,{start: 0, end: 10})).to.equal(10)
+    })
+  
+})

package/src/modulateRangeBySequenceLength.js

@@ -0,0 +1,11 @@
+import normalizePositionByRangeLength from './normalizePositionByRangeLength';
+import provideInclusiveOptions from './provideInclusiveOptions';
+import {assign} from "lodash";
+export default provideInclusiveOptions(modulateRangeBySequenceLength);
+
+function modulateRangeBySequenceLength(range, seqLen) {
+    return assign(range, {
+        start: normalizePositionByRangeLength(range.start, seqLen),
+        end: normalizePositionByRangeLength(range.end, seqLen)
+    })
+}

package/src/modulateRangeBySequenceLength.test.js

@@ -0,0 +1,16 @@
+import {expect} from 'chai';
+import modulateRangeBySequenceLength from './modulateRangeBySequenceLength';
+describe('modulateRangeBySequenceLength', function() {
+    it('should modulate ranges that are outside of the sequence length', function() {
+        //agtc
+        //0123
+        expect(modulateRangeBySequenceLength({start: 2, end: 5},4)).to.deep.equal({start: 2, end:1})
+        expect(modulateRangeBySequenceLength({start: 2, end: 4},4)).to.deep.equal({start: 2, end:0})
+        //agtc
+        //12345
+        expect(modulateRangeBySequenceLength({start: 2, end: 4},4,{inclusive1BasedEnd: true})).to.deep.equal({start: 2, end:4})
+        expect(modulateRangeBySequenceLength({start: 2, end: 4},4,{inclusive1BasedEnd: true,inclusive1BasedStart: true})).to.deep.equal({start: 2, end:4})
+        expect(modulateRangeBySequenceLength({start: 5, end: 4},4,{inclusive1BasedEnd: true,inclusive1BasedStart: true})).to.deep.equal({start: 1, end:4})
+        expect(modulateRangeBySequenceLength({start: 5, end: 5},4,{inclusive1BasedEnd: true,inclusive1BasedStart: true})).to.deep.equal({start: 1, end:1})
+    })
+})

package/src/normalizePositionByRangeLength.js

@@ -0,0 +1,20 @@
+//
+// ac.throw([ac.posInt, ac.posInt, ac.bool], arguments);
+export default function normalizePositionByRangeLength(pPosition, sequenceLength, isInBetweenPositions) {
+    //isInBetweenPositions refers to:
+    // A T G C
+    // 0 1 2 3    <--  isInBetweenPositions = false is counting the positions themselves
+    //0 1 2 3 4   <--  isInBetweenPositions = true is counting the spaces between positions
+    // ac.throw([ac.number, ac.posInt, ac.bool], arguments);
+    let position = pPosition;
+    if (position < 0) {
+        position += sequenceLength;
+    } else if (position + (isInBetweenPositions ? 0 : 1) > sequenceLength) {
+        position -= sequenceLength;
+    }
+    return position < 0
+        ? 0
+        : position > (sequenceLength - (isInBetweenPositions ? 0 : 1))
+            ? sequenceLength - (isInBetweenPositions ? 0 : 1)
+            : position
+};

package/src/normalizePositionByRangeLength.test.js

@@ -0,0 +1,23 @@
+import {expect} from 'chai';
+import normalizePositionByRangeLength from './normalizePositionByRangeLength';
+describe('normalizePositionByRangeLength', function() {
+    it('should normalize positions by their max length, assuming 0-based inclusive indices', function() {
+        expect(normalizePositionByRangeLength(10,9)).to.equal(1)
+        expect(normalizePositionByRangeLength(9,9)).to.equal(0)
+        expect(normalizePositionByRangeLength(3572,2000)).to.equal(1572)
+    })
+    it('should set something more than twice outside the sequence length to either 0 or sequenceLength-1', function () {
+        expect(normalizePositionByRangeLength(-3572,2000)).to.equal(0)
+        expect(normalizePositionByRangeLength(33572,2000)).to.equal(1999)
+    })
+    it('should handle isInBetweenPositions === true being passed in ', function() {
+      expect(normalizePositionByRangeLength(9,9,true)).to.equal(9)
+    })
+    it('should set something more than twice outside the sequence length to either 0 or sequenceLength when isInBetweenPositions is true', function () {
+        expect(normalizePositionByRangeLength(-3572,2000, true)).to.equal(0)
+        expect(normalizePositionByRangeLength(33572,2000, true)).to.equal(2000)
+    })
+    it('should not do anything if it does not have to', function() {
+        expect(normalizePositionByRangeLength(10,99)).to.equal(10)
+    })
+})

package/src/normalizePositionByRangeLength1Based.js

@@ -0,0 +1,5 @@
+import modulatePositionByRange from './modulatePositionByRange';
+
+export default function normalizePositionByRangeLength1Based (position, sequenceLength) {
+  return modulatePositionByRange(position, {start: 1, end: sequenceLength})
+};

package/src/normalizePositionByRangeLength1Based.test.js

@@ -0,0 +1,9 @@
+import normalizePositionByRangeLength1Based from './normalizePositionByRangeLength1Based';
+import {expect} from 'chai';
+describe('normalizePositionByRangeLength1Based', function () {
+	it('should normalize a 1 based position by a 1 based range length', function() {
+		expect(normalizePositionByRangeLength1Based(0,10)).to.equal(10)
+		expect(normalizePositionByRangeLength1Based(-1,10)).to.equal(9)
+		expect(normalizePositionByRangeLength1Based(11,10)).to.equal(1)
+	})
+});

package/src/normalizeRange.js

@@ -0,0 +1,11 @@
+//normalize range takes in a range that might be slightly outside of the rangeMax and wraps the start/end as necessary to fit
+import {assign} from "lodash";
+
+import normalizePositionByRangeLength from './normalizePositionByRangeLength';
+
+export default function normalizeRange(range, sequenceLength) {
+    return assign({}, range, {
+        start: normalizePositionByRangeLength(range.start, sequenceLength),
+        end: normalizePositionByRangeLength(range.end, sequenceLength),
+    })
+};

package/src/normalizeRange.test.js

@@ -0,0 +1,9 @@
+import normalizeRange from './normalizeRange';
+import {expect} from 'chai';
+describe('normalizeRange', function () {
+    it('should normalize range correctly', function() {
+        const normalizedRange = normalizeRange({start: 0, end: -1},10)
+        expect(normalizedRange.start).to.equal(0)
+        expect(normalizedRange.end).to.equal(9)
+    })
+});

package/src/provideInclusiveOptions.js

@@ -0,0 +1,26 @@
+import {assign} from "lodash";
+
+export default function provideInclusiveOptions (funToWrap) {
+    return function () {
+        const args = Array.prototype.slice.call(arguments);
+        const options = args[args.length-1];
+        if (options && (options.inclusive1BasedEnd || options.inclusive1BasedStart)) {
+            args.forEach(function (arg,index) {
+                if (arg && arg.start > -1 && options.inclusive1BasedStart) {
+                    args[index] = assign(arg, {start: arg.start-1})
+                }
+                if (arg && arg.end > -1 && options.inclusive1BasedEnd) {
+                    args[index] = assign(arg, {end: arg.end-1})
+                }
+            })
+        }
+        let returnVal = funToWrap.apply(this,args);
+        if (returnVal && returnVal.start > -1 && options && options.inclusive1BasedStart) {
+            returnVal = assign(returnVal, {start: returnVal.start+1})
+        }
+        if (returnVal && returnVal.end > -1 && options && options.inclusive1BasedEnd) {
+            returnVal = assign(returnVal, {end: returnVal.end+1})
+        }
+        return returnVal
+    };
+};

package/src/reversePositionInRange.js

@@ -0,0 +1,13 @@
+//
+export default function reversePositionInRange(position, rangeLength, isInBetweenPositions) {
+    //isInBetweenPositions refers to:
+    // A T G C
+    // 0 1 2 3    <--  isInBetweenPositions = false is counting the positions themselves
+    //0 1 2 3 4   <--  isInBetweenPositions = true is counting the spaces between positions
+    // ac.throw([
+    //     ac.posInt,
+    //     ac.posInt,
+    //     ac.bool
+    // ], arguments);
+    return rangeLength - position - (isInBetweenPositions ? 0 : 1);
+};

package/src/splitRangeIntoTwoPartsIfItIsCircular.js

@@ -0,0 +1,31 @@
+//
+// ac.throw([ac.posInt, ac.posInt, ac.bool], arguments);
+//takes a potentially circular range and returns an array containing the range split on the origin
+export default function splitRangeIntoTwoPartsIfItIsCircular(range, sequenceLength) {
+    // ac.throw([ac.range, ac.number], arguments);
+    if (sequenceLength !== 0) {
+      sequenceLength = sequenceLength || Infinity
+    }
+    const ranges = [];
+    if (range.start > range.end) {
+        //the range is cicular, so we return an array of two ranges
+        ranges.push({
+            start: 0,
+            end: range.end,
+            type: "end",
+        });
+        ranges.push({
+            start: range.start,
+            end: sequenceLength - 1,
+            type: "beginning",
+        });
+    } else {
+        //the range isn't circular, so we just return the range
+        ranges.push({
+            start: range.start,
+            end: range.end,
+            type: "beginningAndEnd",
+        });
+    }
+    return ranges;
+};

package/src/splitRangeIntoTwoPartsIfItIsCircular.test.js

@@ -0,0 +1,33 @@
+// //takes a potentially circular range and returns an array containing the range split on the origin
+// module.exports = function splitRangeIntoTwoPartsIfItIsCircular(range, maxLength) {
+//   if (range.start <= range.end) {
+//     //the range isn't circular, so we just return the range
+//     return [{
+//       start: range.start,
+//       end: range.end
+//     }];
+//   } else {
+//     //the range is cicular, so we return an array of two ranges
+//     return [{
+//       start: 0,
+//       end: range.end
+//     }, {
+//       start: range.start,
+//       end: maxLength - 1
+//     }];
+//   }
+// };
+
+
+import splitRangeIntoTwoPartsIfItIsCircular from './splitRangeIntoTwoPartsIfItIsCircular.js';
+
+import assert from 'assert';
+describe('splitRangeIntoTwoPartsIfItIsCircular', function() {
+    it('returns an array with one range in it if the array is non-circular', function() {
+        assert.deepEqual(splitRangeIntoTwoPartsIfItIsCircular({start: 0, end: 100}, 1000), [{start: 0, end: 100, type: 'beginningAndEnd'}]);
+        assert.deepEqual(splitRangeIntoTwoPartsIfItIsCircular({start: 10, end: 909}, 1000), [{start: 10, end: 909, type: 'beginningAndEnd'}]);
+    });
+    it('returns an array with two ranges in it if the array is circular', function() {
+        assert.deepEqual(splitRangeIntoTwoPartsIfItIsCircular({start: 110, end: 100},1000), [{start: 0, end: 100, type: 'end'},{start: 110, end: 999, type: 'beginning'}]);
+    });
+});

package/src/translateRange.js

@@ -0,0 +1,9 @@
+import {assign} from "lodash";
+import normalizePositionByRangeLength from './normalizePositionByRangeLength';
+
+export default function translateRange(rangeToBeAdjusted, translateBy, rangeLength) {
+    return assign({}, rangeToBeAdjusted, {
+        start: normalizePositionByRangeLength(rangeToBeAdjusted.start + translateBy, rangeLength),
+        end: normalizePositionByRangeLength(rangeToBeAdjusted.end + translateBy, rangeLength)
+    });
+};

package/src/translateRange.test.js

@@ -0,0 +1,20 @@
+import translateRange from './translateRange';
+import {expect} from 'chai';
+
+describe('translateRange', function() {
+    it('should correctly translate a range', function() {
+        expect(translateRange({start: 0, end: 10}, 10, 30)).to.deep.equal({
+            start: 10,
+            end: 20,
+        })
+        expect(translateRange({start: 0, end: 10}, 10, 15)).to.deep.equal({
+            start: 10,
+            end: 5,
+        })
+        expect(translateRange({start: 9, end: 10}, 10, 15)).to.deep.equal({
+            start: 4,
+            end: 5,
+        })
+      
+    })
+})

package/src/trimNonCicularRangeByAnotherNonCircularRange.js

@@ -0,0 +1,57 @@
+//
+export default function trimNonCicularRangeByAnotherNonCircularRange(rangeToBeTrimmed, trimmingRange) {
+    // ac.throw([ac.range, ac.range], arguments);
+    let outputTrimmedRange;
+    if (!rangeToBeTrimmed) {
+        return outputTrimmedRange;
+    }
+    if (rangeToBeTrimmed.start < trimmingRange.start) {
+        if (rangeToBeTrimmed.end < trimmingRange.start) {
+      // rrr   <range to be trimmed
+      //    ttt  <trimming range
+            outputTrimmedRange = {
+                start: rangeToBeTrimmed.start,
+                end: rangeToBeTrimmed.end
+            };
+        } else {
+            if (rangeToBeTrimmed.end > trimmingRange.end) {
+        // rrrrrr   <range to be trimmed
+        //   ttt  <trimming range
+                outputTrimmedRange = {
+                    start: rangeToBeTrimmed.start,
+                    end: rangeToBeTrimmed.end
+                };
+            } else {
+        // rrrrrr   <range to be trimmed
+        //   ttt  <trimming range
+                outputTrimmedRange = {
+                    start: rangeToBeTrimmed.start,
+                    end: trimmingRange.start - 1
+                };
+            }
+        }
+    } else {
+        if (rangeToBeTrimmed.end <= trimmingRange.end) {
+      //   rrr   <range to be trimmed
+      //  ttttt  <trimming range
+      //fully deleting the range, so do nothing
+        } else {
+            if (rangeToBeTrimmed.start > trimmingRange.end) {
+        //     rrrrrr   <range to be trimmed
+        //  ttt  <trimming range
+                outputTrimmedRange = {
+                    end: rangeToBeTrimmed.end,
+                    start: rangeToBeTrimmed.start
+                };
+            } else {
+        //    rrrrrr   <range to be trimmed
+        //  ttt  <trimming range
+                outputTrimmedRange = {
+                    end: rangeToBeTrimmed.end,
+                    start: trimmingRange.end + 1
+                };
+            }
+        }
+    }
+    return outputTrimmedRange;
+};

package/src/trimNumberToFitWithin0ToAnotherNumber.js

@@ -0,0 +1,12 @@
+//
+// ac.throw([ac.posInt, ac.posInt, ac.bool], arguments);
+export default function trimNumberToFitWithin0ToAnotherNumber(numberToBeTrimmed, max) {
+    // ac.throw([ac.number, ac.number], arguments);
+    if (numberToBeTrimmed < 0) {
+        numberToBeTrimmed = 0;
+    }
+    if (numberToBeTrimmed > max) {
+        numberToBeTrimmed = max;
+    }
+    return numberToBeTrimmed;
+};

package/src/trimRangeByAnotherRange.js

@@ -0,0 +1,102 @@
+import getOverlapsOfPotentiallyCircularRanges from "./getOverlapsOfPotentiallyCircularRanges";
+import splitRangeIntoTwoPartsIfItIsCircular from "./splitRangeIntoTwoPartsIfItIsCircular";
+import trimNonCicularRangeByAnotherNonCircularRange from "./trimNonCicularRangeByAnotherNonCircularRange";
+import {extend} from "lodash";
+
+/**
+ * trims range, but does *not* adjust it
+ * returns a new range if there is one, or null, if it is trimmed completely
+ * @param  {object} subRange  {start:
+ *                                  end:
+ *                                  }
+ * @param  {object} containerRange {start:
+ *                                  end:
+ *                                  }
+ * @param  {int} sequenceLength
+ * @return {object} || null        {start:
+ *                                  end:
+ *                                  }
+ */
+export default function trimRangeByAnotherRange(
+  rangeToBeTrimmed,
+  trimmingRange,
+  sequenceLength
+) {
+  if (!rangeToBeTrimmed || !trimmingRange) {
+    console.warn("invalid range input");
+    return null; //a null return val means something went wrong with this function
+  }
+  let position;
+  for (position of [
+    rangeToBeTrimmed.start,
+    rangeToBeTrimmed.end,
+    trimmingRange.start,
+    trimmingRange.end,
+  ]) {
+    if (position < 0 || (!position && position !== 0)) {
+      console.warn("invalid range input");
+      return null; //a null return val means something went wrong with this function
+    }
+  }
+  //get the overlaps of the ranges
+  const overlaps = getOverlapsOfPotentiallyCircularRanges(
+    rangeToBeTrimmed,
+    trimmingRange,
+    sequenceLength
+  );
+  //split the range to be trimmed into pieces if necessary
+  if (!overlaps.length) {
+    //just return the range to be trimmed
+    return rangeToBeTrimmed;
+  }
+  //and trim both pieces by the already calculated overlaps
+  const splitRangesToBeTrimmed = splitRangeIntoTwoPartsIfItIsCircular(
+    rangeToBeTrimmed,
+    sequenceLength
+  );
+  splitRangesToBeTrimmed.forEach(function(nonCircularRangeToBeTrimmed, index) {
+    overlaps.forEach(function(overlap) {
+      if (nonCircularRangeToBeTrimmed) {
+        nonCircularRangeToBeTrimmed = trimNonCicularRangeByAnotherNonCircularRange(
+          nonCircularRangeToBeTrimmed,
+          overlap
+        );
+      }
+    });
+    splitRangesToBeTrimmed[index] = nonCircularRangeToBeTrimmed;
+  });
+  //filter out any of the split ranges that have been fully deleted!
+  const outputSplitRanges = splitRangesToBeTrimmed.filter(function(
+    trimmedRange
+  ) {
+    if (trimmedRange) {
+      return true;
+    }
+    return false;
+  });
+
+  let outputTrimmedRange;
+  if (outputSplitRanges.length < 0) {
+    //do nothing to the output trimmed range
+  } else if (outputSplitRanges.length === 1) {
+    outputTrimmedRange = outputSplitRanges[0];
+  } else if (outputSplitRanges.length === 2) {
+    if (outputSplitRanges[0].start < outputSplitRanges[1].start) {
+      outputTrimmedRange = {
+        start: outputSplitRanges[1].start,
+        end: outputSplitRanges[0].end,
+      };
+    } else {
+      outputTrimmedRange = {
+        start: outputSplitRanges[0].start,
+        end: outputSplitRanges[1].end,
+      };
+    }
+  }
+  if (outputTrimmedRange) {
+    return extend({}, rangeToBeTrimmed, {
+      start: outputTrimmedRange.start,
+      end: outputTrimmedRange.end,
+    });
+  }
+};