Example usage for com.google.common.collect RangeSet span

List of usage examples for com.google.common.collect RangeSet span

Introduction

In this page you can find the example usage for com.google.common.collect RangeSet span.

Prototype

Range<C> span();

Source Link

Document

Returns the minimal range which Range#encloses(Range) encloses all ranges in this range set.

Usage

From source file:org.apache.aurora.scheduler.cron.CrontabEntry.java

private static void checkEnclosed(String fieldName, Range<Integer> fieldEnclosure, RangeSet<Integer> field) {

    checkArgument(fieldEnclosure.encloses(field.span()),
            String.format("Bad specification for field %s: span(%s) = %s is not enclosed by boundary %s.",
                    fieldName, field, field.span(), fieldEnclosure));
}

From source file:com.rockhoppertech.music.examples.Guava.java

public static void goofaround() {
    MIDITrack track = MIDITrackBuilder.create().noteString("C D E").sequential().build();

    // http://docs.guava-libraries.googlecode.com/git-history/release12/javadoc/com/google/common/collect/FluentIterable.html#filter(com.google.common.base.Predicate)

    ImmutableList<MIDINote> notes = FluentIterable.from(track).transform(new AddFunction(1)).limit(10).toList();

    for (MIDINote note : notes) {
        logger.debug("{}", note);
    }//from w  w  w.j  a v a 2  s . c  o  m

    RangeSet<Double> rangeSet = TreeRangeSet.create();
    rangeSet.add(Range.closed(1d, 10d));
    rangeSet.add(Range.closed(11d, 20d));
    for (Range<Double> r : rangeSet.asRanges()) {
        logger.debug("{}", r);
    }
    logger.debug("span {}", rangeSet.span());
    logger.debug("contains {}", rangeSet.contains(20d));
    logger.debug("contains {}", rangeSet.contains(20.1));

}

From source file:org.jpmml.evaluator.ArgumentUtil.java

static public boolean isOutlier(DataField dataField, MiningField miningField, Object value) {

    if (value == null) {
        return false;
    }/*from   w  w  w . j av  a2 s  .c  o  m*/

    List<Interval> intervals = dataField.getIntervals();

    OpType opType = miningField.getOptype();
    if (opType == null) {
        opType = dataField.getOptype();
    }

    switch (opType) {
    case CONTINUOUS: {
        if (intervals.size() > 0) {
            RangeSet<Double> validRange = CacheUtil.getValue(dataField, ArgumentUtil.validRangeCache);

            Range<Double> validRangeSpan = validRange.span();

            Double doubleValue = (Double) TypeUtil.parseOrCast(DataType.DOUBLE, value);

            return !validRangeSpan.contains(doubleValue);
        }
    }
        break;
    case CATEGORICAL:
    case ORDINAL:
        break;
    default:
        throw new UnsupportedFeatureException(miningField, opType);
    }

    return false;
}

From source file:com.github.rinde.datgen.pdptw.DatasetGenerator.java

Dataset<GeneratedScenario> doGenerate() {

    final ListeningExecutorService service = MoreExecutors
            .listeningDecorator(Executors.newFixedThreadPool(builder.numThreads));
    final Dataset<GeneratedScenario> dataset = Dataset.naturalOrder();

    final List<ScenarioCreator> jobs = new ArrayList<>();

    final RandomGenerator rng = new MersenneTwister(builder.randomSeed);
    final Map<GeneratorSettings, IdSeedGenerator> rngMap = new LinkedHashMap<>();

    for (final Long urgency : builder.urgencyLevels) {
        for (final Double scale : builder.scaleLevels) {
            for (final Entry<TimeSeriesType, Collection<Range<Double>>> dynLevel : builder.dynamismLevels
                    .asMap().entrySet()) {

                final int reps = builder.numInstances * dynLevel.getValue().size();

                final long urg = urgency * 60 * 1000L;
                // The office hours is the period in which new orders are accepted,
                // it is defined as [0,officeHoursLength).
                final long officeHoursLength;
                if (urg < halfDiagTT) {
                    officeHoursLength = builder.scenarioLengthMs - twoDiagTT - PICKUP_DURATION
                            - DELIVERY_DURATION;
                } else {
                    officeHoursLength = builder.scenarioLengthMs - urg - oneAndHalfDiagTT - PICKUP_DURATION
                            - DELIVERY_DURATION;
                }//  ww  w  . j a  v a  2  s  . com

                final int numOrders = DoubleMath.roundToInt(scale * numOrdersPerScale,
                        RoundingMode.UNNECESSARY);

                final ImmutableMap.Builder<String, String> props = ImmutableMap.builder();

                props.put("expected_num_orders", Integer.toString(numOrders));
                props.put("pickup_duration", Long.toString(PICKUP_DURATION));
                props.put("delivery_duration", Long.toString(DELIVERY_DURATION));
                props.put("width_height", String.format("%1.1fx%1.1f", AREA_WIDTH, AREA_WIDTH));

                // TODO store this in TimeSeriesType?
                final RangeSet<Double> rset = TreeRangeSet.create();
                for (final Range<Double> r : dynLevel.getValue()) {
                    rset.add(r);
                }

                // createTimeSeriesGenerator(dynLevel.getKey(), officeHoursLength,
                // numOrders, numOrdersPerScale, props);

                final GeneratorSettings set = GeneratorSettings.builder().setDayLength(builder.scenarioLengthMs)
                        .setOfficeHours(officeHoursLength).setTimeSeriesType(dynLevel.getKey())
                        .setDynamismRangeCenters(builder.dynamismRangeMap.subRangeMap(rset.span()))
                        .setUrgency(urg).setScale(scale).setNumOrders(numOrders).setProperties(props.build())
                        .build();

                final IdSeedGenerator isg = new IdSeedGenerator(rng.nextLong());
                rngMap.put(set, isg);

                for (int i = 0; i < reps; i++) {
                    final LocationGenerator lg = Locations.builder().min(0d).max(AREA_WIDTH).buildUniform();

                    final TimeSeriesGenerator tsg2 = createTimeSeriesGenerator(dynLevel.getKey(),
                            officeHoursLength, numOrders, numOrdersPerScale,
                            ImmutableMap.<String, String>builder());
                    final ScenarioGenerator gen = createGenerator(officeHoursLength, urg, scale, tsg2,
                            set.getDynamismRangeCenters(), lg, builder, numOrdersPerScale);

                    jobs.add(ScenarioCreator.create(isg.next(), set, gen));
                }
            }
        }
    }

    final AtomicLong currentJobs = new AtomicLong(0L);
    final AtomicLong datasetSize = new AtomicLong(0L);

    LOGGER.info(" - Submitting " + jobs.size() + " Jobs");
    for (final ScenarioCreator job : jobs) {
        submitJob(currentJobs, service, job, builder.numInstances, dataset, rngMap, datasetSize);
    }

    final long targetSize = builder.numInstances * builder.dynamismLevels.values().size()
            * builder.scaleLevels.size() * builder.urgencyLevels.size();
    while (datasetSize.get() < targetSize || dataset.size() < targetSize) {
        try {
            // LOGGER.info(" - Waiting, current size ==" + dataset.size());
            Thread.sleep(THREAD_SLEEP_DURATION);
        } catch (final InterruptedException e) {
            throw new IllegalStateException(e);
        }
    }

    LOGGER.info(" - Shutdown Service, Awaiting Termination");
    service.shutdown();
    try {
        service.awaitTermination(1L, TimeUnit.HOURS);
    } catch (final InterruptedException e) {
        throw new IllegalStateException(e);
    }

    LOGGER.info(" - Returning dataset");

    return dataset;
}