@teselagen/range-utils 0.1.21 → 0.1.22

package/src/getAnnotationRangeType.test.js

@@ -0,0 +1,59 @@
+import getAnnotationRangeType from './getAnnotationRangeType';
+import chai from 'chai';
+chai.should();
+
+describe('getAnnotationRangeType', function () {
+    it('should get the correct sub range type give a sub range and its enclosing range', function () {
+        getAnnotationRangeType(
+            {start: 4, end: 7}, 
+            {start: 4, end: 7}, 
+            true
+        ).should.equal('beginningAndEnd')
+        getAnnotationRangeType(
+            {start: 4, end: 7}, 
+            {start: 4, end: 7}, 
+            false
+        ).should.equal('beginningAndEnd')
+        getAnnotationRangeType(
+            {start: 4, end: 7}, 
+            {start: 4, end: 8}, 
+            true
+        ).should.equal('start')
+        getAnnotationRangeType(
+            {start: 4, end: 7}, 
+            {start: 4, end: 8}, 
+            false
+        ).should.equal('end')
+        getAnnotationRangeType(
+            {start: 4, end: 7}, 
+            {start: 3, end: 8}, 
+            true
+        ).should.equal('middle')
+        getAnnotationRangeType(
+            {start: 4, end: 7}, 
+            {start: 3, end: 8}, 
+            false
+        ).should.equal('middle')
+        getAnnotationRangeType(
+            {start: 4, end: 7}, 
+            {start: 3, end: 1}, 
+            true
+        ).should.equal('middle')
+        getAnnotationRangeType(
+            {start: 4, end: 7}, 
+            {start: 3, end: 2}, 
+            false
+        ).should.equal('middle')
+        getAnnotationRangeType(
+            {start: 4, end: 7}, 
+            {start: 4, end: 1}, 
+            true
+        ).should.equal('start')
+        getAnnotationRangeType(
+            {start: 4, end: 7}, 
+            {start: 9, end: 7}, 
+            false
+        ).should.equal('start')
+
+    });
+});

package/src/getEachPositionInRangeAsArray.js

@@ -0,0 +1,15 @@
+import normalizePositionByRangeLength from './normalizePositionByRangeLength';
+import getRangeLength from './getRangeLength';
+
+export default function getEachPositionInRangeAsArray(range, rangeMax) {
+    const output = [];
+    const length = getRangeLength(range, rangeMax);
+    if (!(length > 0)) {
+    	return output
+    }
+    for (let i = range.start; i < (length + range.start); i++) {
+        const position = normalizePositionByRangeLength(i, rangeMax);
+        output.push(position)
+    }    
+    return output
+};

package/src/getEachPositionInRangeAsArray.test.js

@@ -0,0 +1,9 @@
+import getEachPositionInRangeAsArray from './getEachPositionInRangeAsArray';
+import {expect} from 'chai';
+
+describe('getEachPositionInRangeAsArray', function() {
+    it('should correctly determine whether a position is within a range', function() {
+        expect(getEachPositionInRangeAsArray({start: 1, end: 10}, 30)).to.deep.equal([1,2,3,4,5,6,7,8,9,10])
+        expect(getEachPositionInRangeAsArray({start: 10, end: 5}, 13)).to.deep.equal([10,11,12,0,1,2,3,4,5])
+    })
+})

package/src/getLengthOfOverlappingRegionsBetweenTwoRanges.js

@@ -0,0 +1,9 @@
+import getRangeLength from './getRangeLength';
+import getOverlapsOfPotentiallyCircularRanges from './getOverlapsOfPotentiallyCircularRanges';
+
+export default function getLengthOfOverlappingRegionsBetweenTwoRanges(rangeA, rangeB, maxLength) {
+    const overlaps = getOverlapsOfPotentiallyCircularRanges(rangeA,rangeB,maxLength);
+    return overlaps.reduce(function (counter, overlap) {
+        return counter + getRangeLength(overlap, maxLength)
+    }, 0)
+};

package/src/getLengthOfOverlappingRegionsBetweenTwoRanges.test.js

@@ -0,0 +1,24 @@
+import assert from 'assert';
+import getLengthOfOverlappingRegionsBetweenTwoRanges from './getLengthOfOverlappingRegionsBetweenTwoRanges';
+describe('getLengthOfOverlappingRegionsBetweenTwoRanges', function () {
+	it('should get the length of the overlaps in a simple case', function () {
+		const length = getLengthOfOverlappingRegionsBetweenTwoRanges({
+			start: 4,
+			end: 8
+		}, {
+			start: 5,
+			end: 10
+		}, 20);
+		assert.equal(length, 4)
+	});
+	it('should get the length of the overlaps', function () {
+		const length = getLengthOfOverlappingRegionsBetweenTwoRanges({
+			start: 4,
+			end: 8
+		}, {
+			start: 7,
+			end: 5
+		}, 20);
+		assert.equal(length, 4)
+	});
+});

package/src/getMiddleOfRange.js

@@ -0,0 +1,10 @@
+import getRangeLength from "./getRangeLength";
+import normalizePositionByRangeLength from "./normalizePositionByRangeLength";
+
+export default function getMiddleOfRange(range, rangeMax) {
+  const len = getRangeLength({ start: range.start, end: range.end }, rangeMax);
+  return normalizePositionByRangeLength(
+    range.start + Math.floor(len / 2),
+    rangeMax
+  );
+};

package/src/getMiddleOfRange.test.js

@@ -0,0 +1,44 @@
+//0123456789
+//r--------r
+//
+//0123
+//r--r
+//  0
+// 3 1
+//  2
+
+import assert from "assert";
+
+import getMiddleOfRange from "./getMiddleOfRange";
+describe("getMiddleOfRange", function() {
+  it("should return the correct length for ranges that cross the origin", function() {
+    const midpoint = getMiddleOfRange({ start: 9, end: 0 }, 10);
+    console.log(`midpoint:`,midpoint)
+    assert(midpoint === 0);
+
+  });
+  it("should return the correct midpoint for ranges that do not cross the origin", function() {
+    const midpoint = getMiddleOfRange({ start: 4, end: 6 }, 10);
+    console.log(`midpoint:`,midpoint)
+    assert(midpoint === 5);
+
+  });
+  it("should return the correct midpoint for ranges that overlapSelf", function() {
+    const midpoint = getMiddleOfRange(
+      { start: 4, end: 9, overlapsSelf: true },
+      10
+    );
+    console.log(`midpoint:`,midpoint)
+    assert(midpoint === 7);
+
+  });
+  it("should return the correct midpoint for ranges that overlapSelf and origin", function() {
+    const midpoint = getMiddleOfRange(
+      { start: 9, end: 1, overlapsSelf: true },
+      10
+    );
+    console.log(`midpoint:`,midpoint)
+    assert(midpoint === 0);
+
+  });
+});

package/src/getOverlapOfNonCircularRanges.js

@@ -0,0 +1,35 @@
+export default function getOverlapOfNonCircularRanges(rangeA, rangeB) {
+    if (rangeA.start < rangeB.start) {
+        if (rangeA.end < rangeB.start) {
+      //no overlap
+        } else {
+            if (rangeA.end < rangeB.end) {
+                return {
+                    start: rangeB.start,
+                    end: rangeA.end
+                };
+            } else {
+                return {
+                    start: rangeB.start,
+                    end: rangeB.end
+                };
+            }
+        }
+    } else {
+        if (rangeA.start > rangeB.end) {
+      //no overlap
+        } else {
+            if (rangeA.end < rangeB.end) {
+                return {
+                    start: rangeA.start,
+                    end: rangeA.end
+                };
+            } else {
+                return {
+                    start: rangeA.start,
+                    end: rangeB.end
+                };
+            }
+        }
+    }
+};

package/src/getOverlapsOfPotentiallyCircularRanges.js

@@ -0,0 +1,54 @@
+import {flatMap} from "lodash";
+import splitRangeIntoTwoPartsIfItIsCircular from "./splitRangeIntoTwoPartsIfItIsCircular";
+import getOverlapOfNonCircularRanges from "./getOverlapOfNonCircularRanges";
+
+//returns an array of the overlaps between two potentially circular ranges
+export default function getOverlapsOfPotentiallyCircularRanges(
+  rangeA,
+  rangeB,
+  maxRangeLength,
+  joinIfPossible //by default this fn only returns **non-circular** overlaps, if true it will try to join overlaps split on the origin
+) {
+  const normalizedRangeA = splitRangeIntoTwoPartsIfItIsCircular(
+    rangeA,
+    maxRangeLength
+  );
+  const normalizedRangeB = splitRangeIntoTwoPartsIfItIsCircular(
+    rangeB,
+    maxRangeLength
+  );
+
+  let overlaps = [];
+
+  normalizedRangeA.forEach(function(nonCircularRangeA, iA) {
+    normalizedRangeB.forEach(function(nonCircularRangeB, iB) {
+      const overlap = getOverlapOfNonCircularRanges(
+        nonCircularRangeA,
+        nonCircularRangeB
+      );
+      if (overlap) {
+        overlaps.push(overlap);
+      }
+    });
+  });
+  if (
+    joinIfPossible &&
+    normalizedRangeA.length === 2 &&
+    normalizedRangeB.length === 2 &&
+    maxRangeLength
+  ) {
+    //we have 2 circular ranges that will have gotten split on the origin, so we'll manually mend those pieces back together
+    const joinedOverlap = {};
+    overlaps = flatMap(overlaps, (o, i) => {
+      if (o.start === 0) {
+        joinedOverlap.end = o.end;
+        return [];
+      } else if (o.end === maxRangeLength - 1) {
+        joinedOverlap.start = o.start;
+        return [];
+      }
+    });
+    overlaps.push(joinedOverlap);
+  }
+  return overlaps;
+};

package/src/getOverlapsOfPotentiallyCircularRanges.test.js

@@ -0,0 +1,199 @@
+import getOverlapsOfPotentiallyCircularRanges from "./getOverlapsOfPotentiallyCircularRanges.js";
+
+import assert from "assert";
+
+describe("getOverlapsOfPotentiallyCircularRanges", function() {
+  it("doesnt return an overlap for non overlapping ranges", function() {
+    assert.deepEqual(
+      getOverlapsOfPotentiallyCircularRanges(
+        {
+          start: 0,
+          end: 100
+        },
+        {
+          start: 105,
+          end: 999
+        },
+        1000
+      ),
+      []
+    );
+  });
+  it("does return overlaps for overlapping ranges", function() {
+    assert.deepEqual(
+      getOverlapsOfPotentiallyCircularRanges(
+        {
+          start: 0,
+          end: 100
+        },
+        {
+          start: 90,
+          end: 100
+        },
+        1000
+      ),
+      [
+        {
+          start: 90,
+          end: 100
+        }
+      ]
+    );
+
+    assert.deepEqual(
+      getOverlapsOfPotentiallyCircularRanges(
+        {
+          start: 12,
+          end: 9
+        },
+        {
+          start: 0,
+          end: 24
+        },
+        25
+      ),
+      [
+        {
+          start: 0,
+          end: 9
+        },
+        {
+          start: 12,
+          end: 24
+        }
+      ]
+    );
+    assert.deepEqual(
+      getOverlapsOfPotentiallyCircularRanges(
+        {
+          start: 900,
+          end: 100
+        },
+        {
+          start: 90,
+          end: 100
+        },
+        1000
+      ),
+      [
+        {
+          start: 90,
+          end: 100
+        }
+      ]
+    );
+    assert.deepEqual(
+      getOverlapsOfPotentiallyCircularRanges(
+        {
+          start: 900,
+          end: 100
+        },
+        {
+          start: 900,
+          end: 100
+        },
+        1000
+      ),
+      [
+        {
+          start: 0,
+          end: 100
+        },
+        {
+          start: 900,
+          end: 999
+        }
+      ]
+    );
+    assert.deepEqual(
+      getOverlapsOfPotentiallyCircularRanges(
+        {
+          start: 900,
+          end: 100
+        },
+        {
+          start: 90,
+          end: 910
+        },
+        1000
+      ),
+      [
+        {
+          start: 90,
+          end: 100
+        },
+        {
+          start: 900,
+          end: 910
+        }
+      ]
+    );
+    assert.deepEqual(
+      getOverlapsOfPotentiallyCircularRanges(
+        {
+          start: 900,
+          end: 100
+        },
+        {
+          start: 90,
+          end: 10
+        },
+        1000
+      ),
+      [
+        {
+          start: 0,
+          end: 10
+        },
+        {
+          start: 90,
+          end: 100
+        },
+        {
+          start: 900,
+          end: 999
+        }
+      ]
+    );
+    console.log(
+      `getOverlapsOfPotentiallyCircularRanges({
+            start: 5,
+            end: 3
+        }, {
+            start: 5,
+            end: 3
+        }, 10):`,
+      getOverlapsOfPotentiallyCircularRanges(
+        {
+          start: 5,
+          end: 3
+        },
+        {
+          start: 5,
+          end: 3
+        },
+        10
+      )
+    );
+    assert.deepEqual(
+      getOverlapsOfPotentiallyCircularRanges(
+        {
+          start: 5,
+          end: 3
+        },
+        {
+          start: 5,
+          end: 3
+        },
+        10,
+        true
+      ),
+      [
+        {
+          start: 5,
+          end: 3
+        }
+      ]
+    );
+  });
+});

package/src/getPositionFromAngle.js

@@ -0,0 +1,7 @@
+export default function getPositionFromAngle(angle, rangeMax, isInBetweenPositions) {
+    //percent through sequence * rangeMax
+    const unroundedPostion = angle / Math.PI / 2 * rangeMax
+    //return either the nearest position, or the nearest "inBetween" postion
+    return isInBetweenPositions ? Math.round(unroundedPostion) : Math.floor(unroundedPostion)
+};
+

package/src/getRangeAngles.js

@@ -0,0 +1,33 @@
+import getRangeLength from "./getRangeLength";
+
+export default function getRangeAngles(range, rangeMax) {
+  const { startAngle, totalAngle, endAngle } = getStartEndAndTotalAngle(
+    range,
+    rangeMax
+  );
+
+  return {
+    startAngle,
+    totalAngle,
+    endAngle,
+    centerAngle: startAngle + totalAngle / 2,
+    locationAngles:
+      range.locations &&
+      range.locations.map((location) => {
+        return getRangeAngles(location, rangeMax);
+      })
+  };
+}
+
+function getStartEndAndTotalAngle(range, rangeMax) {
+  const rangeLength = getRangeLength(
+    { start: range.start, end: range.end },
+    rangeMax
+  );
+
+  return {
+    startAngle: 2 * Math.PI * (range.start / rangeMax),
+    totalAngle: (rangeLength / rangeMax) * Math.PI * 2,
+    endAngle: (2 * Math.PI * (range.end + 1)) / rangeMax //use a +1 here because the angle must encompass the end of the annotation
+  };
+}

package/src/getRangeAngles.test.js

@@ -0,0 +1,77 @@
+//0123456789
+//r--------r
+//
+//0123
+//r--r
+//  0
+// 3 1
+//  2
+import getRangeAngles from "./getRangeAngles";
+
+import assert from "assert";
+describe("getRangeAngles", function() {
+  //tnrtodo set this up
+
+  it("should return the correct angles for ranges that have joined locations", function() {
+    const angles = getRangeAngles(
+      {
+        start: 1,
+        end: 6,
+        locations: [
+          { start: 1, end: 2 },
+          { start: 3, end: 6 },
+        ],
+      },
+      10
+    );
+    // console.log('angles: ' + JSON.stringify(angles,null,4));
+    const anglesInRadians = {};
+    Object.keys(angles).forEach(function(key) {
+      anglesInRadians[key] = (angles[key] * 360) / Math.PI / 2;
+    });
+
+    // console.log('anglesInRadians: ' + JSON.stringify(anglesInRadians,null,4));
+    assert(anglesInRadians.startAngle === 36);
+    assert(anglesInRadians.endAngle === 252);
+    assert(anglesInRadians.totalAngle === 216);
+    angles.locationAngles &&
+      angles.locationAngles.forEach((angles, i) => {
+        const anglesInRadians = {};
+        Object.keys(angles).forEach(function(key) {
+          anglesInRadians[key] = (angles[key] * 360) / Math.PI / 2;
+        });
+        // console.log('anglesInRadians:',anglesInRadians)
+
+        // console.log('anglesInRadians: ' + JSON.stringify(anglesInRadians,null,4));
+        assert((anglesInRadians.startAngle === i) === 0 ? 36 : 108);
+        assert((anglesInRadians.endAngle === i) === 0 ? 108 : 252);
+        assert((anglesInRadians.totalAngle === i) === 0 ? 72 : 144);
+      });
+
+  });
+  it("should return the correct angles for ranges that cross the origin", function() {
+    const angles = getRangeAngles({ start: 9, end: 0 }, 10);
+    // console.log('angles: ' + JSON.stringify(angles,null,4));
+    const anglesInRadians = {};
+    Object.keys(angles).forEach(function(key) {
+      anglesInRadians[key] = (angles[key] * 360) / Math.PI / 2;
+    });
+    assert(anglesInRadians.startAngle === 324);
+    assert(anglesInRadians.endAngle === 36);
+    assert(anglesInRadians.totalAngle === 72);
+    // console.log('anglesInRadians: ' + JSON.stringify(anglesInRadians,null,4));
+  });
+  it("should return the correct angles for ranges that do not cross the origin", function() {
+    const angles = getRangeAngles({ start: 1, end: 2, overlapsSelf: true }, 10);
+    // console.log('angles: ' + JSON.stringify(angles,null,4));
+    const anglesInRadians = {};
+    Object.keys(angles).forEach(function(key) {
+      anglesInRadians[key] = (angles[key] * 360) / Math.PI / 2;
+    });
+    // console.log('anglesInRadians: ' + JSON.stringify(anglesInRadians,null,4));
+    assert(anglesInRadians.startAngle === 36);
+    assert(anglesInRadians.centerAngle === 72); //even if overlapsSelf=true the center angle should still be 72
+    assert(anglesInRadians.endAngle === 108);
+    assert(anglesInRadians.totalAngle === 72);
+  });
+});

package/src/getRangeLength.js

@@ -0,0 +1,14 @@
+import provideInclusiveOptions from "./provideInclusiveOptions";
+export default provideInclusiveOptions(getRangeLength);
+function getRangeLength(range, rangeMax) {
+  let toRet;
+  if (range.end < range.start) {
+    toRet = rangeMax - range.start + range.end + 1;
+  } else {
+    toRet = range.end - range.start + 1;
+  }
+  if (range.overlapsSelf && rangeMax) {
+    toRet += rangeMax;
+  }
+  return toRet;
+}

package/src/getRangeLength.test.js

@@ -0,0 +1,30 @@
+//0123456789
+//r--------r
+//
+//0123
+//r--r
+//  0
+// 3 1
+//  2
+
+import assert from "assert";
+
+import getRangeLength from "./getRangeLength";
+describe("getRangeLength", function() {
+  it("should return the correct length for ranges that cross the origin", function() {
+    const length = getRangeLength({ start: 9, end: 0 }, 10);
+    assert(length === 2);
+  });
+  it("should return the correct length for ranges that do not cross the origin", function() {
+    const length = getRangeLength({ start: 4, end: 6 }, 10);
+    assert(length === 3);
+  });
+  it("should return the correct length for ranges that overlapSelf", function() {
+    const length = getRangeLength({ start: 4, end: 6, overlapsSelf: true }, 10);
+    assert(length === 13);
+  });
+  it("should return the correct length for ranges that overlapSelf and origin", function() {
+    const length = getRangeLength({ start: 9, end: 1, overlapsSelf: true }, 10);
+    assert(length === 13);
+  });
+});

package/src/getRangesBetweenTwoRanges.js

@@ -0,0 +1,28 @@
+export default function getRangesBetweenTwoRanges(range1, range2) {
+    // {
+    //     start: 85,
+    //     end: 92
+    // }
+
+    // {
+    //     start: 130,
+    //     end: 189
+    // }
+
+    // start1 - end2
+
+    // start2 - end1
+
+    const newRanges = [];	
+    if (!(range1.start > -1 && range1.end > -1 && range2.start > -1 && range2.end > -1)) {
+        return newRanges
+    }
+    return [{
+        start: range1.start,
+        end: range2.end,
+    },{
+        start: range2.start,
+        end: range1.end,
+    }]    
+};
+

package/src/getSequenceWithinRange.js

@@ -0,0 +1,17 @@
+//
+export default function getSequenceWithinRange(range, sequence) {
+    // ac.throw([ac.range, ac.oneOfType([ac.array, ac.string])], arguments);
+    if (range.start < 0 || range.end < 0) return ''
+    if (range.start > range.end) {
+        //circular range
+        let subSequence = sequence.slice(range.start, sequence.length);
+        if (typeof subSequence === 'string') {
+            subSequence += sequence.slice(0, range.end + 1);
+        } else {
+            subSequence = subSequence.concat(sequence.slice(0, range.end + 1));
+        }
+        return subSequence;
+    } else {
+        return sequence.slice(range.start, range.end + 1);
+    }
+};