Example usage for com.google.common.collect RangeMap subRangeMap

Introduction

In this page you can find the example usage for com.google.common.collect RangeMap subRangeMap.

Prototype

RangeMap<K, V> subRangeMap(Range<K> range);

Source Link

Document

Returns a view of the part of this range map that intersects with range .

Usage

From source file:eu.trentorise.opendata.semtext.SemText.java

/**
 * Returns the terms enclosed by enclosingSpan as a new TreeRangeMap.
 *//*from   w  w  w.j  a v a2  s.c  o  m*/
private static TreeRangeMap<Integer, Term> enclosingNewTerms(Span enclosingSpan,
        RangeMap<Integer, Term> termRanges) {
    TreeRangeMap<Integer, Term> ret = TreeRangeMap.create();

    Range enclosingRange = spanToRange(enclosingSpan);

    RangeMap<Integer, Term> subRangeMap = termRanges.subRangeMap(enclosingRange);

    for (Map.Entry<Range<Integer>, Term> termEntry : subRangeMap.asMapOfRanges().entrySet()) {
        if (enclosingRange.encloses(spanToRange(termEntry.getValue()))) {
            ret.put(termEntry.getKey(), termEntry.getValue());
        }
    }

    return ret;
}

---

From source file:org.mskcc.shenkers.data.interval.DiscreteRangeMap.java

public RangeMap<Integer, Double> add(RangeMap<Integer, Double> rm, Range<Integer> r, Double d) {
    RangeMap<Integer, Double> ram = TreeRangeMap.create();

    ram.putAll(rm);/*from  w  w  w .  jav a2  s.c o  m*/
    ram.put(r, d);

    rm.subRangeMap(r).asMapOfRanges().forEach((range, val) -> ram.put(range, val + d));
    return ram;
}

---

From source file:org.mskcc.shenkers.data.interval.DiscreteRangeMap.java

public void testGetGraphic() {
    RangeMap<Integer, Double> ram = TreeRangeMap.create();
    //        ram.put(Range.closed(0, 4), 0.);
    System.out.println("adding");
    ram = add(ram, Range.closed(1, 3), 1.);
    ram.asMapOfRanges().forEach((r, d) -> System.out.println(String.format("%s %f", r, d)));
    System.out.println("adding");
    ram = add(ram, Range.closed(-1, 4), 1.);
    ram.asMapOfRanges().forEach((r, d) -> System.out.println(String.format("%s %f", r, d)));
    System.out.println("adding");
    ram = add(ram, Range.closed(3, 5), 2.);
    ram.asMapOfRanges().forEach((r, d) -> System.out.println(String.format("%s %f", r, d)));
    System.out.println("asReal");
    ram.asMapOfRanges().forEach((r, d) -> System.out.println(String.format("%s %f", r, d)));
    toReal(ram).asMapOfRanges().forEach((r, d) -> System.out.println(String.format("%s %f", r, d)));

    RangeMap<Double, Double> toReal = toReal(ram);
    System.out.println("span " + toReal.span());
    double length = length(toReal.span());
    System.out.println("length " + length);
    int k = 7;//w  w  w . j  a  va 2 s.  c o  m
    double binSize = length / k;
    Double lb = toReal.span().lowerEndpoint();
    for (int i = 0; i < k; i++) {
        Range<Double> closedOpen = Range.closedOpen(lb + (i * 1. / k * length), lb + ((i + 1.) / k * length));
        System.out.println("bin " + i);
        System.out.println(closedOpen);
        Double max = Collections.max(toReal.subRangeMap(closedOpen).asMapOfRanges().values());
        Double mean = toReal.subRangeMap(closedOpen).asMapOfRanges().values().stream()
                .mapToDouble(Double::doubleValue).average().orElse(0.);

        //            StreamSupport.doubleStream(new Spliterator.OfDouble()
        //                    false);
        System.out.println("max " + max);
        System.out.println("mean " + mean);
    }

}

---

From source file:guru.qas.martini.gherkin.DefaultMixology.java

protected List<Recipe> getRecipes(FeatureWrapper feature, Collection<Pickle> pickles) {
    Map<Integer, Recipe> recipeIndex = new LinkedHashMap<>();

    RangeMap<Integer, ScenarioDefinition> rangeMap = getRangeMap(feature);
    for (Pickle pickle : pickles) {
        List<PickleLocation> locations = pickle.getLocations();
        Map<Integer, PickleLocation> locationIndex = new HashMap<>();
        locations.forEach(l -> {/*from www  .  jav  a 2  s .  com*/
            int line = l.getLine();
            locationIndex.put(line, l);
        });

        Integer line = Ordering.natural().max(locationIndex.keySet());
        recipeIndex.computeIfAbsent(line, l -> {
            PickleLocation location = locationIndex.get(l);
            Range<Integer> range = Range.singleton(line);
            RangeMap<Integer, ScenarioDefinition> subRangeMap = rangeMap.subRangeMap(range);
            Map<Range<Integer>, ScenarioDefinition> asMap = subRangeMap.asMapOfRanges();
            checkState(1 == asMap.size(), "no single range found encompassing PickleLocation %s", location);
            ScenarioDefinition definition = Iterables.getOnlyElement(asMap.values());
            return new DefaultRecipe(feature, pickle, location, definition);
        });
    }
    return ImmutableList.copyOf(recipeIndex.values());
}

---

From source file:eu.trentorise.opendata.semtext.SemText.java

/**
 * Returns a new semantic text having existing terms plus the provided ones.
 * If new terms overlaps with other ones, existing overlapping terms are
 * removed. If a term is precisely overlapping an existing one, resulting
 * term will have the selected meaning and meaning status of the provided
 * term and the list of meanings will be a merge of the meanings found in
 * the provided term plus the meanings of the existing term.
 *
 * Terms to merge which are outside of existing sentences will be ignored.
 *//* w w w.  j a  va2 s .c o  m*/
// note: Current version is based on RangeMaps thus quite inefficient
public SemText merge(Iterable<Term> termsToMerge) {

    SemTexts.checkSpans(termsToMerge, 0, text.length(), "Invalid spans for terms to merge!");

    if (sentences.size() > 1) {
        LOG.log(Level.WARNING,
                "Found more than one sentence while mergin terms into SemText {0}, output semtext will have only one sentence covering the whole text.",
                this.text);
    }

    ImmutableList.Builder<Sentence> newSentenceB = ImmutableList.builder();

    RangeMap<Integer, Term> termToMergeRanges = TreeRangeMap.create();

    for (Term termToMerge : termsToMerge) {
        termToMergeRanges.put(spanToRange(termToMerge), termToMerge);
    }

    for (Sentence sentence : sentences) {

        RangeMap<Integer, Term> mergeRanges = enclosingNewTerms(sentence, termToMergeRanges);
        Map<Range<Integer>, Term> mergeRangesMap = mergeRanges.asMapOfRanges();

        for (Term origTerm : sentence.getTerms()) {
            Term newTerm = mergeRangesMap.get(spanToRange(origTerm));

            if (newTerm == null) { // orig term doesn't coincide with new term
                if (mergeRanges.subRangeMap(spanToRange(origTerm)).asMapOfRanges().isEmpty()) {
                    // origTerm does not overlap with new terms, add it                                                    
                    mergeRanges.put(spanToRange(origTerm), origTerm);
                }
            } else { // orig term coincides with new term, merge it
                mergeRanges.put(spanToRange(newTerm),
                        newTerm.with(Iterables.concat(newTerm.getMeanings(), origTerm.getMeanings())));
            }

        }

        newSentenceB.add(sentence.withTerms(mergeRangesMap.values()));

    }
    return withSentences(newSentenceB.build());
}

---