Example usage for com.google.common.collect Range singleton

List of usage examples for com.google.common.collect Range singleton

Introduction

In this page you can find the example usage for com.google.common.collect Range singleton.

Prototype

public static <C extends Comparable<?>> Range<C> singleton(C value) 

Source Link

Document

Returns a range that Range#contains(Comparable) contains only the given value.

Usage

From source file:com.github.fge.grappa.matchers.join.JoinMatcherBuilder.java

/**
 * Return a rule with an exact number of cycles to run
 *
 * @param nrCycles the number of cycles//from w  w w .j a v a  2 s .  co m
 * @return a rule
 * @throws IllegalArgumentException {@code nrCycles} is less than 0
 *
 * @see Range#singleton(Comparable)
 */
public Rule times(int nrCycles) {
    Preconditions.checkArgument(nrCycles >= 0,
            "illegal repetition number specified (" + nrCycles + "), must be 0 or greater");
    return range(Range.singleton(nrCycles));
}

From source file:net.sf.mzmine.modules.peaklistmethods.gapfilling.samerange.SameRangePeak.java

/**
 * Adds a new data point to this peak/*from   w  ww.  ja v a2s .co m*/
 * 
 * @param scanNumber
 * @param dataPoints
 * @param rawDataPoints
 */
void addDatapoint(int scanNumber, DataPoint dataPoint) {

    double rt = dataFile.getScan(scanNumber).getRetentionTime();

    if (mzPeakMap.isEmpty()) {
        rtRange = Range.singleton(rt);
        mzRange = Range.singleton(dataPoint.getMZ());
        intensityRange = Range.singleton(dataPoint.getIntensity());
    } else {
        rtRange = rtRange.span(Range.singleton(rt));
        mzRange = mzRange.span(Range.singleton(dataPoint.getMZ()));
        intensityRange = intensityRange.span(Range.singleton(dataPoint.getIntensity()));
    }

    mzPeakMap.put(scanNumber, dataPoint);

}

From source file:net.sf.mzmine.modules.rawdatamethods.peakpicking.manual.ManualPeak.java

/**
 * Adds a new data point to this peak//from   w  w w  . j ava  2s  .co  m
 * 
 * @param scanNumber
 * @param dataPoints
 * @param rawDataPoints
 */
void addDatapoint(int scanNumber, DataPoint dataPoint) {

    double rt = dataFile.getScan(scanNumber).getRetentionTime();

    if (dataPointMap.isEmpty()) {
        rtRange = Range.singleton(rt);
        mzRange = Range.singleton(dataPoint.getMZ());
        intensityRange = Range.singleton(dataPoint.getIntensity());
    } else {
        rtRange = rtRange.span(Range.singleton(rt));
        mzRange = mzRange.span(Range.singleton(dataPoint.getMZ()));
        intensityRange = intensityRange.span(Range.singleton(dataPoint.getIntensity()));
    }

    dataPointMap.put(scanNumber, dataPoint);

}

From source file:net.sf.mzmine.modules.peaklistmethods.peakpicking.deconvolution.ResolvedPeak.java

/**
 * Initializes this peak using data points from a given chromatogram -
 * regionStart marks the index of the first data point (inclusive),
 * regionEnd marks the index of the last data point (inclusive). The
 * selected region MUST NOT contain any zero-intensity data points,
 * otherwise exception is thrown.// w w  w .ja v a2 s . co  m
 */
public ResolvedPeak(Feature chromatogram, int regionStart, int regionEnd) {

    assert regionEnd > regionStart;

    this.dataFile = chromatogram.getDataFile();

    // Make an array of scan numbers of this peak
    scanNumbers = new int[regionEnd - regionStart + 1];

    // Note that we cannot use chromatogram.getScanNumbers() here, because
    // the chromatogram may already have been deconvoluted -> scan numbers
    // would be a subset of all scans. The regionStart and regionEnd indexes
    // refer to all MS1 scans, therefore we use datafile.getScanNumbers(1)
    int chromatogramScanNumbers[] = chromatogram.getDataFile().getScanNumbers(1);

    System.arraycopy(chromatogramScanNumbers, regionStart, scanNumbers, 0, regionEnd - regionStart + 1);

    dataPointMZValues = new double[regionEnd - regionStart + 1];
    dataPointIntensityValues = new double[regionEnd - regionStart + 1];

    // Set raw data point ranges, height, rt and representative scan
    height = Double.MIN_VALUE;
    for (int i = 0; i < scanNumbers.length; i++) {

        DataPoint dp = chromatogram.getDataPoint(scanNumbers[i]);
        if (dp == null) {
            String error = "Cannot create a resolved peak in a region with missing data points: chromatogram "
                    + chromatogram + " scans " + chromatogramScanNumbers[regionStart] + "-"
                    + chromatogramScanNumbers[regionEnd] + ", missing data point in scan " + scanNumbers[i];
            throw new IllegalArgumentException(error);
        }

        dataPointMZValues[i] = dp.getMZ();
        dataPointIntensityValues[i] = dp.getIntensity();

        if (rawDataPointsIntensityRange == null) {
            rawDataPointsIntensityRange = Range.singleton(dp.getIntensity());
            rawDataPointsRTRange = Range.singleton(dataFile.getScan(scanNumbers[i]).getRetentionTime());
            rawDataPointsMZRange = Range.singleton(dp.getMZ());
        } else {
            rawDataPointsRTRange = rawDataPointsRTRange
                    .span(Range.singleton(dataFile.getScan(scanNumbers[i]).getRetentionTime()));
            rawDataPointsIntensityRange = rawDataPointsIntensityRange.span(Range.singleton(dp.getIntensity()));
            rawDataPointsMZRange = rawDataPointsMZRange.span(Range.singleton(dp.getMZ()));
        }

        if (height < dp.getIntensity()) {
            height = dp.getIntensity();
            rt = dataFile.getScan(scanNumbers[i]).getRetentionTime();
            representativeScan = scanNumbers[i];
        }
    }

    // Calculate median m/z
    mz = MathUtils.calcQuantile(dataPointMZValues, 0.5f);

    // Update area
    area = 0;
    for (int i = 1; i < scanNumbers.length; i++) {

        // For area calculation, we use retention time in seconds
        double previousRT = dataFile.getScan(scanNumbers[i - 1]).getRetentionTime() * 60d;
        double currentRT = dataFile.getScan(scanNumbers[i]).getRetentionTime() * 60d;

        double previousHeight = dataPointIntensityValues[i - 1];
        double currentHeight = dataPointIntensityValues[i];
        area += (currentRT - previousRT) * (currentHeight + previousHeight) / 2;
    }

    // Update fragment scan
    fragmentScan = ScanUtils.findBestFragmentScan(dataFile, rawDataPointsRTRange, rawDataPointsMZRange);

    if (fragmentScan > 0) {
        Scan fragmentScanObject = dataFile.getScan(fragmentScan);
        int precursorCharge = fragmentScanObject.getPrecursorCharge();
        if (precursorCharge > 0)
            this.charge = precursorCharge;
    }

}

From source file:net.sf.mzmine.parameters.parametertypes.selectors.PeakSelectionParameter.java

/**
 * Shortcut to set value based on peak list rows
 *//*from   w w w .jav a  2s  .co m*/
public void setValue(PeakListRow rows[]) {
    List<PeakSelection> newValue = Lists.newArrayList();
    for (PeakListRow row : rows) {
        Range<Integer> idRange = Range.singleton(row.getID());
        Range<Double> mzRange = Range.singleton(row.getAverageMZ());
        Range<Double> rtRange = Range.singleton(row.getAverageRT());
        PeakSelection ps = new PeakSelection(idRange, mzRange, rtRange, null);
        newValue.add(ps);
    }
    setValue(newValue);
}

From source file:org.apache.cassandra.cql3.restrictions.TokenFilter.java

/**
 * Converts the specified list into a range set.
 *
 * @param buffers the token restriction values
 * @return the range set corresponding to the specified list
 *//*ww  w.  j a va2s  .com*/
private static RangeSet<Token> toRangeSet(List<ByteBuffer> buffers) {
    ImmutableRangeSet.Builder<Token> builder = ImmutableRangeSet.builder();

    for (ByteBuffer buffer : buffers)
        builder.add(Range.singleton(deserializeToken(buffer)));

    return builder.build();
}

From source file:com.pingcap.tikv.predicates.RangeBuilder.java

/**
 * Turn CNF filters into range//from w ww .  j  a va  2 s. co m
 *
 * @param accessConditions filters in CNF list
 * @param type index column type
 * @return access ranges
 */
@SuppressWarnings("unchecked")
static List<Range> exprToRanges(List<TiExpr> accessConditions, DataType type) {
    if (accessConditions == null || accessConditions.size() == 0) {
        return ImmutableList.of();
    }
    RangeSet ranges = TreeRangeSet.create();
    ranges.add(Range.all());
    for (TiExpr ac : accessConditions) {
        NormalizedCondition cond = AccessConditionNormalizer.normalize(ac);
        TiConstant constVal = cond.constantVals.get(0);
        Comparable<?> comparableVal = Comparables.wrap(constVal.getValue());
        TiExpr expr = cond.condition;

        if (expr instanceof GreaterThan) {
            ranges = ranges.subRangeSet(Range.greaterThan(comparableVal));
        } else if (expr instanceof GreaterEqual) {
            ranges = ranges.subRangeSet(Range.atLeast(comparableVal));
        } else if (expr instanceof LessThan) {
            ranges = ranges.subRangeSet(Range.lessThan(comparableVal));
        } else if (expr instanceof LessEqual) {
            ranges = ranges.subRangeSet(Range.atMost(comparableVal));
        } else if (expr instanceof Equal) {
            ranges = ranges.subRangeSet(Range.singleton(comparableVal));
        } else if (expr instanceof NotEqual) {
            RangeSet left = ranges.subRangeSet(Range.lessThan(comparableVal));
            RangeSet right = ranges.subRangeSet(Range.greaterThan(comparableVal));
            ranges = TreeRangeSet.create(left);
            ranges.addAll(right);
        } else {
            throw new TiClientInternalException(
                    "Unsupported conversion to Range " + expr.getClass().getSimpleName());
        }
    }
    return ImmutableList.copyOf(ranges.asRanges());
}

From source file:com.brighttag.agathon.security.SecurityGroupUpdaterService.java

/**
 * Creates ingress rules from IP ranges in CIDR notation with {@code port} as the to-port.
 *
 * @param rules IP ranges in CIDR ("slash") notation
 * @return ingress rules/*from   w  w  w. ja  v  a  2  s.  co m*/
 */
private SecurityGroupPermission toSecurityGroupPermission(Collection<Netmask> rules, int port) {
    return new SecurityGroupPermission(rules, Range.singleton(port));
}

From source file:org.apache.brooklyn.qa.longevity.Monitor.java

private static Range<Integer> parseRange(String range) {
    if (range.contains("-")) {
        String[] parts = range.split("-");
        return Range.closed(Integer.parseInt(parts[0]), Integer.parseInt(parts[1]));
    } else {/*from  w  w w  . j av a  2  s  .c o  m*/
        return Range.singleton(Integer.parseInt(range));
    }
}

From source file:com.google.android.apps.forscience.whistlepunk.GraphPopulator.java

/**
 * If the graphStatus shows that there are still values that need to be fetched to fill the
 * currently-displayed graph, this method will begin fetching them.
 * <p/>/*from   ww  w. j  ava2  s.  c om*/
 * Call only on the UI thread.
 */
public void requestObservations(final GraphStatus graphStatus, final DataController dataController,
        final FailureListener failureListener, final int resolutionTier, final String sensorId) {
    if (mRequestInFlight) {
        return;
    }
    final TimeRange r = getRequestRange(graphStatus);
    if (r == null) {
        mObservationDisplay.onFinish(mRequestId);
    } else {
        mRequestInFlight = true;
        dataController.getScalarReadings(sensorId, resolutionTier, r, MAX_DATAPOINTS_PER_SENSOR_LOAD,
                MaybeConsumers.chainFailure(failureListener, new FallibleConsumer<ScalarReadingList>() {
                    @Override
                    public void take(ScalarReadingList observations) {
                        mRequestInFlight = false;
                        if (graphStatus.graphIsStillValid()) {
                            final Range<Long> received = addObservationsToDisplay(observations);
                            if (received != null) {
                                mObservationDisplay.addRange(observations, mRequestId);
                            }
                            addToRequestedTimes(getEffectiveAddedRange(r, received));
                            requestObservations(graphStatus, dataController, failureListener, resolutionTier,
                                    sensorId);
                        }
                    }

                    public void addToRequestedTimes(Range<Long> effectiveAdded) {
                        mRequestedTimes = Ranges.span(mRequestedTimes, effectiveAdded);
                    }

                    public Range<Long> addObservationsToDisplay(ScalarReadingList observations) {
                        List<ScalarReading> points = ScalarReading.slurp(observations);
                        Range<Long> range = null;
                        for (ScalarReading point : points) {
                            range = Ranges.span(range, Range.singleton(point.getCollectedTimeMillis()));
                        }
                        return range;
                    }
                }));
    }
    return;
}