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

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

  1. HOME
  2. Java
  3. com.google.common
  4. com.google.common.collect.*
  5. Range
  6. open

Introduction

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

Prototype

public static <C extends Comparable<?>> Range<C> open(C lower, C upper)

Source Link

Document

Returns a range that contains all values strictly greater than lower and strictly less than upper .

Usage

From source file:com.rockhoppertech.music.midi.js.predicate.MIDINumberBandPassPredicate.java

/**
 * Use an open {@code Range}.
 */
public void useOpenRange() {
    range = Range.open(low, high);
}

From source file:com.cinchapi.concourse.server.concurrent.RangeTokens.java

/**
 * Convert the specified range {@code token} to one or more {@link Range
 * ranges} that provide the appropriate coverage.
 * //from w ww.j  ava 2s . c  o  m
 * @param token
 * @return the Ranges
 */
public static Iterable<Range<Value>> convertToRange(RangeToken token) {
    List<Range<Value>> ranges = Lists.newArrayListWithCapacity(1);
    if (token.getOperator() == Operator.EQUALS || token.getOperator() == null) { // null operator means
                                                                                 // the range token is for
                                                                                 // writing
        ranges.add(Range.singleton(token.getValues()[0]));
    } else if (token.getOperator() == Operator.NOT_EQUALS) {
        ranges.add(Range.lessThan(token.getValues()[0]));
        ranges.add(Range.greaterThan(token.getValues()[0]));
    } else if (token.getOperator() == Operator.GREATER_THAN) {
        ranges.add(Range.greaterThan(token.getValues()[0]));
    } else if (token.getOperator() == Operator.GREATER_THAN_OR_EQUALS) {
        ranges.add(Range.atLeast(token.getValues()[0]));
    } else if (token.getOperator() == Operator.LESS_THAN) {
        ranges.add(Range.lessThan(token.getValues()[0]));
    } else if (token.getOperator() == Operator.LESS_THAN_OR_EQUALS) {
        ranges.add(Range.atMost(token.getValues()[0]));
    } else if (token.getOperator() == Operator.BETWEEN) {
        Value a = token.getValues()[0];
        Value b = token.getValues()[1];
        if (a == Value.NEGATIVE_INFINITY && b == Value.POSITIVE_INFINITY) {
            ranges.add(Range.<Value>all());
        } else if (token.getValues().length == 3) {
            ranges.add(Range.open(a, b));
        } else if (token.getValues().length == 4) {
            ranges.add(Range.closed(a, b));
        } else if (token.getValues().length == 5) {
            ranges.add(Range.openClosed(a, b));
        } else {
            ranges.add(Range.closedOpen(a, b));
        }
    } else if (token.getOperator() == Operator.REGEX || token.getOperator() == Operator.NOT_REGEX) {
        ranges.add(Range.<Value>all());
    } else {
        throw new UnsupportedOperationException();
    }
    return ranges;
}

From source file:net.sf.mzmine.util.RangeUtils.java

public static Range<Double> fromArray(double array[]) {
    if ((array == null) || (array.length == 0))
        return Range.open(0.0, 0.0);
    double min = array[0], max = array[0];
    for (double d : array) {
        if (d > max)
            max = d;//from w w  w  .  jav a  2  s. c o  m
        if (d < min)
            min = d;
    }
    return Range.closed(min, max);
}

From source file:de.visiom.carpc.asb.serviceregistry.impl.entities.adapters.RangeAdapter.java

@Override
public Range<BigDecimal> unmarshal(String v) throws Exception {
    boolean leftInfinity = false, rightInfinity = false;
    String firstNumberString = v.substring(0, v.indexOf(".."));
    String secondNumberString = v.substring(v.indexOf("..") + 2);
    BigDecimal firstNumber = null, secondNumber = null;
    if (firstNumberString.equals("infty")) {
        leftInfinity = true;/* ww  w .j a v a2  s .c  o m*/
    } else {
        firstNumber = BigDecimal.valueOf(Double.parseDouble(firstNumberString));
    }
    if (secondNumberString.equals("infty")) {
        rightInfinity = true;
    } else {
        secondNumber = BigDecimal.valueOf(Double.parseDouble(secondNumberString));
    }
    Range<BigDecimal> result = null;
    if (!leftInfinity && !rightInfinity) {
        result = Range.open(firstNumber, secondNumber);
    } else if (leftInfinity && rightInfinity) {
        result = Range.all();
    } else if (leftInfinity && !rightInfinity) {
        result = Range.lessThan(secondNumber);
    } else {
        result = Range.greaterThan(firstNumber);
    }
    return result;
}

From source file:org.ow2.petals.cloud.tools.generator.soap.SOAPArtifactGenerator.java

public Range getSupportedRange() {
    return Range.open("0.0", "1.0");
}

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

public static void ranges() {
    RangeSet<Double> set = TreeRangeSet.create();
    //        for (double i = 1d; i < 4d; i++) {
    //            set.add(Range.closed(i, i + 1d));
    //        }/*from ww  w .j  ava 2  s.  co  m*/

    set.add(Range.closed(1d, 4d));
    logger.debug("the set {}", set);

    set.remove(Range.closed(2.5, 3d));
    logger.debug("after remove: set {}", set);
    RangeSet<Double> comp = set.complement();
    logger.debug("after remove: set comp {}", comp);

    Range<Double> first = Iterables.getFirst(set.asRanges(), null);
    logger.debug("first {}", first);

    //Iterables.

    for (Range<Double> r : set.asRanges()) {
        logger.debug("iterated range {}", r);
    }

    //lowerEndpoint();

    set.clear();
    set.add(Range.open(1d, 4d));
    comp = set.complement();
    logger.debug("open comp {}", comp);

}

From source file:com.helion3.prism.api.query.ConditionGroup.java

/**
 * Convenience method to build conditions for a region of radius around a central location.
 *
 * @param location Location<?>/*from  w  w w  .  j a  v  a2  s  .  co m*/
 * @param radius Integer
 * @return ConditionGroup
 */
public static ConditionGroup from(Location<?> location, int radius) {
    ConditionGroup conditions = new ConditionGroup(Operator.AND);

    // World
    conditions.add(FieldCondition.of(DataQueries.Location.then(DataQueries.WorldUuid), MatchRule.EQUALS,
            location.getExtent().getUniqueId().toString()));

    // X
    Range<Integer> xRange = Range.open(location.getBlockX() - radius, location.getBlockX() + radius);
    conditions.add(FieldCondition.of(DataQueries.Location.then(DataQueries.X), xRange));

    // Y
    Range<Integer> yRange = Range.open(location.getBlockY() - radius, location.getBlockY() + radius);
    conditions.add(FieldCondition.of(DataQueries.Location.then(DataQueries.Y), yRange));

    // Z
    Range<Integer> zRange = Range.open(location.getBlockZ() - radius, location.getBlockZ() + radius);
    conditions.add(FieldCondition.of(DataQueries.Location.then(DataQueries.Z), zRange));

    return conditions;
}

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

static public Range<Double> toRange(Interval interval) {
    Double leftMargin = interval.getLeftMargin();
    Double rightMargin = interval.getRightMargin();

    // "The attributes leftMargin and rightMargin are optional but at least one value must be defined"
    if (leftMargin == null && rightMargin == null) {
        throw new InvalidFeatureException(interval);
    } // End if//w ww.j  ava2  s  . c  o m

    if (leftMargin != null && rightMargin != null && (leftMargin).compareTo(rightMargin) > 0) {
        throw new InvalidFeatureException(interval);
    }

    Interval.Closure closure = interval.getClosure();
    switch (closure) {
    case OPEN_OPEN: {
        if (leftMargin == null) {
            return Range.lessThan(rightMargin);
        } else

        if (rightMargin == null) {
            return Range.greaterThan(leftMargin);
        }

        return Range.open(leftMargin, rightMargin);
    }
    case OPEN_CLOSED: {
        if (leftMargin == null) {
            return Range.atMost(rightMargin);
        } else

        if (rightMargin == null) {
            return Range.greaterThan(leftMargin);
        }

        return Range.openClosed(leftMargin, rightMargin);
    }
    case CLOSED_OPEN: {
        if (leftMargin == null) {
            return Range.lessThan(rightMargin);
        } else

        if (rightMargin == null) {
            return Range.atLeast(leftMargin);
        }

        return Range.closedOpen(leftMargin, rightMargin);
    }
    case CLOSED_CLOSED: {
        if (leftMargin == null) {
            return Range.atMost(rightMargin);
        } else

        if (rightMargin == null) {
            return Range.atLeast(leftMargin);
        }

        return Range.closed(leftMargin, rightMargin);
    }
    default:
        throw new UnsupportedFeatureException(interval, closure);
    }
}

From source file:org.dishevelled.bio.range.rtree.RangeGeometries.java

/**
 * Create and return a new rectangle geometry from the specified open range <code>(lower..upper)</code>.
 *
 * @param <N> value type//  ww  w .j  av a2  s  . c o m
 * @param lower lower endpoint, must not be null
 * @param upper upper endpoint, must not be null
 * @return a new rectangle geometry from the specified closed range
 */
public static <N extends Number & Comparable<? super N>> Rectangle open(final N lower, final N upper) {
    checkNotNull(lower);
    checkNotNull(upper);
    return range(Range.open(lower, upper));
}

From source file:org.apache.kylin.common.util.RangeUtil.java

/**
 * remove from self the elements that exist in other
 * @return// ww w  .j a  va2s .c o  m
 */
public static <C extends Comparable<?>> List<Range<C>> remove(Range<C> self, Range<C> other) {

    // mimic the following logic in guava 18:
    //        RangeSet<C> rangeSet = TreeRangeSet.create();
    //        rangeSet.add(self);
    //        rangeSet.remove(other);
    //        return Lists.newArrayList(rangeSet.asRanges());

    if (other == null || !self.isConnected(other)) {
        return Collections.singletonList(self);
    }

    Range<C> share = self.intersection(other);
    if (share.isEmpty()) {
        return Collections.singletonList(self);
    }

    List<Range<C>> ret = Lists.newArrayList();

    //see left part
    if (!self.hasLowerBound()) {
        if (share.hasLowerBound()) {
            if (share.lowerBoundType() == BoundType.CLOSED) {
                ret.add(Range.lessThan(share.lowerEndpoint()));
            } else {
                ret.add(Range.atMost(share.lowerEndpoint()));
            }
        }
    } else {
        if (self.lowerEndpoint() != share.lowerEndpoint()) {
            if (self.lowerBoundType() == BoundType.CLOSED) {
                if (share.lowerBoundType() == BoundType.CLOSED) {
                    ret.add(Range.closedOpen(self.lowerEndpoint(), share.lowerEndpoint()));
                } else {
                    ret.add(Range.closed(self.lowerEndpoint(), share.lowerEndpoint()));
                }
            } else {
                if (share.lowerBoundType() == BoundType.CLOSED) {
                    ret.add(Range.open(self.lowerEndpoint(), share.lowerEndpoint()));
                } else {
                    ret.add(Range.openClosed(self.lowerEndpoint(), share.lowerEndpoint()));
                }
            }
        } else {
            if (self.lowerBoundType() == BoundType.CLOSED && share.lowerBoundType() == BoundType.OPEN) {
                ret.add(Range.closed(self.lowerEndpoint(), share.lowerEndpoint()));
            }
        }
    }

    //see right part 
    if (!self.hasUpperBound()) {
        if (share.hasUpperBound()) {
            if (share.upperBoundType() == BoundType.CLOSED) {
                ret.add(Range.greaterThan(share.upperEndpoint()));
            } else {
                ret.add(Range.atLeast(share.upperEndpoint()));
            }
        }
    } else {
        if (self.upperEndpoint() != share.upperEndpoint()) {
            if (self.upperBoundType() == BoundType.CLOSED) {
                if (share.upperBoundType() == BoundType.CLOSED) {
                    ret.add(Range.openClosed(share.upperEndpoint(), self.upperEndpoint()));
                } else {
                    ret.add(Range.closed(share.upperEndpoint(), self.upperEndpoint()));
                }
            } else {
                if (share.upperBoundType() == BoundType.CLOSED) {
                    ret.add(Range.open(share.upperEndpoint(), self.upperEndpoint()));
                } else {
                    ret.add(Range.closedOpen(share.upperEndpoint(), self.upperEndpoint()));
                }
            }
        } else {
            if (self.upperBoundType() == BoundType.CLOSED && share.upperBoundType() == BoundType.OPEN) {
                ret.add(Range.closed(self.upperEndpoint(), share.upperEndpoint()));
            }
        }
    }

    return ret;

}