@Override public boolean possibleInDomain(Map<String, RangeSet<String>> domain) { RangeSet<String> rangeSet = domain.get(dimension); if (rangeSet == null) { return true; } return !rangeSet.subRangeSet(getRange()).isEmpty(); }
/** * Intersects a set of ranges, or returns null if the set is empty. */ public static <T extends Comparable<T>> RangeSet<T> intersectRanges(final Iterable<Range<T>> ranges) { RangeSet<T> rangeSet = null; for (final Range<T> range : ranges) { if (rangeSet == null) { rangeSet = TreeRangeSet.create(); rangeSet.add(range); } else { rangeSet = TreeRangeSet.create(rangeSet.subRangeSet(range)); } } return rangeSet; }
/** * Converts zero-indexed, [closed, open) line ranges in the given source file to character ranges. */ public static RangeSet<Integer> lineRangesToCharRanges( String input, RangeSet<Integer> lineRanges) { List<Integer> lines = new ArrayList<>(); Iterators.addAll(lines, Newlines.lineOffsetIterator(input)); lines.add(input.length() + 1); final RangeSet<Integer> characterRanges = TreeRangeSet.create(); for (Range<Integer> lineRange : lineRanges.subRangeSet(Range.closedOpen(0, lines.size() - 1)).asRanges()) { int lineStart = lines.get(lineRange.lowerEndpoint()); // Exclude the trailing newline. This isn't strictly necessary, but handling blank lines // as empty ranges is convenient. int lineEnd = lines.get(lineRange.upperEndpoint()) - 1; Range<Integer> range = Range.closedOpen(lineStart, lineEnd); characterRanges.add(range); } return characterRanges; } }
public void testSubRangeSetOfComplement() { for (Range<Integer> range1 : QUERY_RANGES) { for (Range<Integer> range2 : QUERY_RANGES) { TreeRangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(range1); rangeSet.add(range2); for (Range<Integer> subRange : QUERY_RANGES) { testViewAgainstExpected( expectedSubRangeSet(expectedComplement(rangeSet), subRange), rangeSet.complement().subRangeSet(subRange)); } } } }
RangeSet<Integer> iRangeSet = iRangeSet0.subRangeSet(Range.closed(0, javaInput.getkN())); for (Range<Integer> iRange : iRangeSet.asRanges()) { Range<Integer> range = expandToBreakableRegions(iRange.canonical(DiscreteDomain.integers()));
public boolean overlaps(Range<Long> interval) { if (interval == null) { return false; } RangeSet<Long> hits = intervals.subRangeSet(interval); return !hits.isEmpty(); } /**
@Override public boolean possibleInDomain(Map<String, RangeSet<String>> domain) { RangeSet<String> rangeSet = domain.get(dimension); if (rangeSet == null) { return true; } return !rangeSet.subRangeSet(getRange()).isEmpty(); }
public void update(RangeSet<Integer> r) { prepareNodes(r.subRangeSet(this.visibleLines.get()).subRangeSet(Range.closedOpen(Integer.valueOf(0), Integer.valueOf(this.numberOfLines.get())))); }
private void triggerUpdate(RangeSet<Integer> range) { Range<Integer> all = Range.closedOpen(Integer.valueOf(0), Integer.valueOf(getNumberOfLines())); RangeSet<Integer> onlyExisting = range.subRangeSet(all); RangeSet<Integer> onlyVisible = onlyExisting.subRangeSet(getVisible()); onlyVisible.asRanges().stream() .flatMapToInt(VFlow::toIntStream) .forEach(index -> updateNode(index)); }
void updateNodesNow(com.google.common.collect.RangeSet<Integer> rs) { RangeSet<Integer> subRangeSet = rs.subRangeSet(getVisibleLines()).subRangeSet(Range.closedOpen(Integer.valueOf(0), Integer.valueOf(getNumberOfLines()))); subRangeSet.asRanges().forEach(r-> { ContiguousSet.create(r, DiscreteDomain.integers()).forEach(index-> { getLineLayer().updateNode(index.intValue()); // StyledTextLine m = this.model.get(index); // lineLayer.updateNode(m); }); }); }
.get(((RangeToken) token).getKey()); for (Range<Value> range : ranges) { if(set != null && !set.subRangeSet(range).isEmpty()) { listener.onVersionChange(token);
public RangeSet<Integer> getVisibleLines() { RangeSet<Integer> visibleLines = TreeRangeSet.create(); visibleLines.add(this.visibleLines.get()); return visibleLines.subRangeSet(Range.closedOpen(Integer.valueOf(0), Integer.valueOf(this.numberOfLines.get()))); }
public static RangeSet<Integer> intersect(RangeSet<Integer> rs1, RangeSet<Integer> rs2) { RangeSet<Integer> rs = TreeRangeSet.create(); for (Range<Integer> r : rs1.asRanges()) { rs.addAll(rs2.subRangeSet(r)); } return rs; } /**
/** * Intersects a set of ranges, or returns null if the set is empty. */ public static <T extends Comparable<T>> RangeSet<T> intersectRanges(final Iterable<Range<T>> ranges) { RangeSet<T> rangeSet = null; for (final Range<T> range : ranges) { if (rangeSet == null) { rangeSet = TreeRangeSet.create(); rangeSet.add(range); } else { rangeSet = TreeRangeSet.create(rangeSet.subRangeSet(range)); } } return rangeSet; }
void releaseNodesNow(com.google.common.collect.RangeSet<Integer> rs) { RangeSet<Integer> subRangeSet = rs.subRangeSet(Range.closedOpen(Integer.valueOf(0), Integer.valueOf(getNumberOfLines()))); subRangeSet.asRanges().forEach(r-> { ContiguousSet.create(r, DiscreteDomain.integers()).forEach(index-> { getLineLayer().releaseNode(index.intValue()); // StyledTextLine m = this.model.get(index); // lineLayer.releaseNode(m); }); }); }
/** * Take the complement of this space, bounded by existing lower and upper limits of the space. * This can be used as a way to represent a set of excluded ranges as a positive space. */ public IntegerSpace not() { if (_rangeset.isEmpty()) { return EMPTY; } return new IntegerSpace(_rangeset.complement().subRangeSet(_rangeset.span())); }
public static double calculatePassageAveragePrecision( List<Range<CharacterPosition>> resultPassages, RangeSet<CharacterPosition> gsPassages) { double sumOfAveragePrecision = 0.0; double retrieved = 0.0; double relevantRetrieved = 0.0; for (Range<CharacterPosition> resultPassage : resultPassages) { retrieved += countCharacters(resultPassage); if (gsPassages.encloses(resultPassage)) { relevantRetrieved += countCharacters(gsPassages.subRangeSet(resultPassage)); sumOfAveragePrecision += calculatePrecision(retrieved, relevantRetrieved); } } return sumOfAveragePrecision / gsPassages.asRanges().size(); }
public void assemble(File fasta, File vcf, int fragments, boolean includeReference) throws IOException { List<Fragment> fragList = new ArrayList<Fragment>(); RangeSet<Integer> invalid = calcInvalidBreakPositions(margin + fragmentLength); Iterator<Fragment> it = candidateFragments(); while (it.hasNext() && fragList.size() < fragments) { Fragment f = it.next(); if (f == null || !invalid.subRangeSet(Range.closedOpen(f.getLowBreakend().start, f.getHighBreakend().end)).isEmpty()) { // skip fragments we can't use continue; } invalid.add(Range.closedOpen(f.getLowBreakend().start - margin, f.getHighBreakend().end + 1 + margin)); fragList.add(f); } log.info(String.format("%d fragments created", fragList.size())); assemble(fasta, vcf, fragList, includeReference); } }
/** * Converts zero-indexed, [closed, open) line ranges in the given source file to character ranges. */ public static RangeSet<Integer> lineRangesToCharRanges( String input, RangeSet<Integer> lineRanges) { List<Integer> lines = new ArrayList<>(); Iterators.addAll(lines, Newlines.lineOffsetIterator(input)); lines.add(input.length() + 1); final RangeSet<Integer> characterRanges = TreeRangeSet.create(); for (Range<Integer> lineRange : lineRanges.subRangeSet(Range.closedOpen(0, lines.size() - 1)).asRanges()) { int lineStart = lines.get(lineRange.lowerEndpoint()); // Exclude the trailing newline. This isn't strictly necessary, but handling blank lines // as empty ranges is convenient. int lineEnd = lines.get(lineRange.upperEndpoint()) - 1; Range<Integer> range = Range.closedOpen(lineStart, lineEnd); characterRanges.add(range); } return characterRanges; } }
public void testSubRangeSetOfComplement() { for (Range<Integer> range1 : QUERY_RANGES) { for (Range<Integer> range2 : QUERY_RANGES) { TreeRangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(range1); rangeSet.add(range2); for (Range<Integer> subRange : QUERY_RANGES) { testViewAgainstExpected( expectedSubRangeSet(expectedComplement(rangeSet), subRange), rangeSet.complement().subRangeSet(subRange)); } } } }