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

Introduction

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

Prototype

public C lowerEndpoint() 

Source Link

Document

Returns the lower endpoint of this range.

Usage

From source file:org.dishevelled.variation.range.Ranges.java

/**
 * Return the center of the specified range.
 *
 * @param <C> range endpoint type/* w  w  w  .  ja v a  2s. c  o  m*/
 * @param range range, must not be null
 * @return the center of the specified range
 */
public static <C extends Comparable> C center(final Range<C> range) {
    checkNotNull(range);
    if (!range.hasUpperBound() && !range.hasUpperBound()) {
        throw new IllegalStateException("cannot find the center of a range without bounds");
    }
    if (!range.hasLowerBound()) {
        return range.upperEndpoint();
    }
    if (!range.hasUpperBound()) {
        return range.lowerEndpoint();
    }
    C lowerEndpoint = range.lowerEndpoint();
    C upperEndpoint = range.upperEndpoint();

    if (upperEndpoint instanceof Integer) {
        Integer upper = (Integer) upperEndpoint;
        Integer lower = (Integer) lowerEndpoint;
        return (C) Integer.valueOf((upper.intValue() + lower.intValue()) / 2);
    }
    if (upperEndpoint instanceof Long) {
        Long upper = (Long) upperEndpoint;
        Long lower = (Long) lowerEndpoint;
        return (C) Long.valueOf((upper.longValue() + lower.longValue()) / 2L);
    }
    if (upperEndpoint instanceof BigInteger) {
        BigInteger upper = (BigInteger) upperEndpoint;
        BigInteger lower = (BigInteger) lowerEndpoint;
        BigInteger two = BigInteger.valueOf(2L);
        return (C) upper.subtract(lower).divide(two);
    }

    // todo:  could potentially calculate the center of any range with a discrete domain
    throw new IllegalStateException(
            "cannot find the center of a range whose endpoint type is not Integer, Long, or BigInteger");
}

---

From source file:org.nmdp.ngs.range.Ranges.java

/**
 * Return the center of the specified range.
 *
 * @param <C> range endpoint type//ww w.j a va2s  .co  m
 * @param range range, must not be null
 * @return the center of the specified range
 */
public static <C extends Comparable> C center(final Range<C> range) {
    checkNotNull(range);
    if (!range.hasLowerBound() && !range.hasUpperBound()) {
        throw new IllegalStateException("cannot find the center of a range without bounds");
    }
    if (!range.hasLowerBound()) {
        return range.upperEndpoint();
    }
    if (!range.hasUpperBound()) {
        return range.lowerEndpoint();
    }
    C lowerEndpoint = range.lowerEndpoint();
    C upperEndpoint = range.upperEndpoint();

    if (upperEndpoint instanceof Integer) {
        Integer upper = (Integer) upperEndpoint;
        Integer lower = (Integer) lowerEndpoint;
        return (C) Integer.valueOf((upper.intValue() + lower.intValue()) / 2);
    }
    if (upperEndpoint instanceof Long) {
        Long upper = (Long) upperEndpoint;
        Long lower = (Long) lowerEndpoint;
        return (C) Long.valueOf((upper.longValue() + lower.longValue()) / 2L);
    }
    if (upperEndpoint instanceof BigInteger) {
        BigInteger upper = (BigInteger) upperEndpoint;
        BigInteger lower = (BigInteger) lowerEndpoint;
        BigInteger two = BigInteger.valueOf(2L);
        return (C) upper.subtract(lower).divide(two);
    }

    // todo:  could potentially calculate the center of any range with a discrete domain
    throw new IllegalStateException(
            "cannot find the center of a range whose endpoint type is not Integer, Long, or BigInteger");
}

---

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

public static String formatTsRange(Range<Long> tsRange) {
    if (tsRange == null)
        return null;

    StringBuilder sb = new StringBuilder();
    if (tsRange.hasLowerBound()) {
        if (tsRange.lowerBoundType() == BoundType.CLOSED) {
            sb.append("[");
        } else {/*from w w w .  ja  va  2  s . c  o  m*/
            sb.append("(");
        }
        sb.append(DateFormat.formatToTimeStr(tsRange.lowerEndpoint()));
    } else {
        sb.append("(-");
    }

    sb.append("~");

    if (tsRange.hasUpperBound()) {
        sb.append(DateFormat.formatToTimeStr(tsRange.upperEndpoint()));
        if (tsRange.upperBoundType() == BoundType.CLOSED) {
            sb.append("]");
        } else {
            sb.append(")");
        }
    } else {
        sb.append("+)");
    }
    return sb.toString();
}

---

From source file:it.units.malelab.ege.benchmark.KLandscapes.java

private static FitnessComputer<String, NumericFitness> getFitnessComputer(final int k, final int nTerminals,
        final int nNonTerminals, final int arity, Range<Double> vRange, Range<Double> wRange) {
    Random random = new Random(1l);
    final Map<String, Double> v = new LinkedHashMap<>();
    final Map<Pair<String, String>, Double> w = new LinkedHashMap<>();
    //fill v map/*ww w.  ja  v  a 2  s  . c  o  m*/
    for (int i = 0; i < nTerminals; i++) {
        v.put("t" + i, random.nextDouble() * (vRange.upperEndpoint() - vRange.lowerEndpoint())
                + vRange.lowerEndpoint());
    }
    for (int i = 0; i < nNonTerminals; i++) {
        v.put("n" + i, random.nextDouble() * (vRange.upperEndpoint() - vRange.lowerEndpoint())
                + vRange.lowerEndpoint());
    }
    //fill w map
    for (int j = 0; j < nNonTerminals; j++) {
        for (int i = 0; i < nTerminals; i++) {
            w.put(new Pair<>("n" + j, "t" + i),
                    random.nextDouble() * (wRange.upperEndpoint() - wRange.lowerEndpoint())
                            + wRange.lowerEndpoint());
        }
        for (int i = 0; i < nNonTerminals; i++) {
            w.put(new Pair<>("n" + j, "n" + i),
                    random.nextDouble() * (wRange.upperEndpoint() - wRange.lowerEndpoint())
                            + wRange.lowerEndpoint());
        }
    }
    //prepare fitness
    final double optimumFitness = f(optimum(k, nTerminals, nNonTerminals, arity, v, w), k, v, w);
    return new FitnessComputer<String, NumericFitness>() {
        @Override
        public NumericFitness compute(Node<String> phenotype) {
            Node<String> tree = transform(phenotype);
            return new NumericFitness(1 - f(tree, k, v, w) / optimumFitness);
        }

        @Override
        public NumericFitness worstValue() {
            return new NumericFitness(Double.POSITIVE_INFINITY);
        }

        @Override
        public NumericFitness bestValue() {
            return new NumericFitness(0);
        }
    };
}

---

From source file:com.tinspx.util.io.callbacks.FileChannelCallback.java

/**
 * Normalizes lower bound to a closed bound type (if exists) and the
 * upper bound to an open bound type (if exists). Missing bounds remain
 * missing. Lower bound must be non-negative and upper bound must be
 * positive. The range cannot be empty.//from  ww  w. j a va  2 s  . c  o  m
 */
static Range<Long> checkAndNormalize(Range<Long> range) {
    checkArgument(!range.isEmpty(), "range %s is empty", range);
    boolean make = false;
    long lower = -1;
    long upper = -1;

    if (range.hasLowerBound()) {
        lower = range.lowerEndpoint();
        if (range.lowerBoundType() == BoundType.OPEN) {
            make = true;
            lower++;
        }
        checkArgument(lower >= 0, "closed lower bound (%s) may not be negative", lower);
    }
    if (range.hasUpperBound()) {
        upper = range.upperEndpoint();
        if (range.upperBoundType() == BoundType.CLOSED) {
            make = true;
            upper++;
        }
        checkArgument(upper > 0, "open upper bound (%s) must be positive", upper);
    }
    if (make) {
        if (lower >= 0) {
            if (upper > 0) {
                range = Range.closedOpen(lower, upper);
            } else {
                range = Range.atLeast(lower);
            }
        } else {
            assert upper > 0 : upper;
            range = Range.lessThan(upper);
        }
        checkArgument(!range.isEmpty(), "normalized range %s is empty", range);
    }
    return range;
}

---

From source file:org.apache.hadoop.hive.ql.optimizer.calcite.druid.DruidIntervalUtils.java

protected static List<Range> condenseRanges(List<Range> ranges) {
    if (ranges.size() <= 1) {
        return ranges;
    }/* w  ww.  j  a v  a 2 s .co m*/

    Comparator<Range> startThenEnd = new Comparator<Range>() {
        @Override
        public int compare(Range lhs, Range rhs) {
            int compare = 0;
            if (lhs.hasLowerBound() && rhs.hasLowerBound()) {
                compare = lhs.lowerEndpoint().compareTo(rhs.lowerEndpoint());
            } else if (!lhs.hasLowerBound() && rhs.hasLowerBound()) {
                compare = -1;
            } else if (lhs.hasLowerBound() && !rhs.hasLowerBound()) {
                compare = 1;
            }
            if (compare != 0) {
                return compare;
            }
            if (lhs.hasUpperBound() && rhs.hasUpperBound()) {
                compare = lhs.upperEndpoint().compareTo(rhs.upperEndpoint());
            } else if (!lhs.hasUpperBound() && rhs.hasUpperBound()) {
                compare = -1;
            } else if (lhs.hasUpperBound() && !rhs.hasUpperBound()) {
                compare = 1;
            }
            return compare;
        }
    };

    TreeSet<Range> sortedIntervals = Sets.newTreeSet(startThenEnd);
    sortedIntervals.addAll(ranges);

    List<Range> retVal = Lists.newArrayList();

    Iterator<Range> intervalsIter = sortedIntervals.iterator();
    Range currInterval = intervalsIter.next();
    while (intervalsIter.hasNext()) {
        Range next = intervalsIter.next();
        if (currInterval.encloses(next)) {
            continue;
        }
        if (mergeable(currInterval, next)) {
            currInterval = currInterval.span(next);
        } else {
            retVal.add(currInterval);
            currInterval = next;
        }
    }
    retVal.add(currInterval);

    return retVal;
}

---

From source file:com.stackframe.collect.RangeUtilities.java

/**
 * Build an expression suitable for passing to JDBC as part of an SQL query from a date range.
 *
 * @param column the name of the column//from   w  w  w.  j  a v  a 2s.  c om
 * @param dateRange the Range
 * @return a String containing the expression
 */
public static String toSQL(String column, Range<Date> dateRange) {
    StringBuilder buf = new StringBuilder();
    if (dateRange.hasLowerBound()) {
        BoundType lowerBound = dateRange.lowerBoundType();
        String operator;
        switch (lowerBound) {
        case CLOSED:
            operator = ">=";
            break;
        case OPEN:
            operator = ">";
            break;
        default:
            throw new AssertionError("unexpected bound type " + lowerBound);
        }

        Date lowerEndpoint = dateRange.lowerEndpoint();
        java.sql.Date lowerDate = convert(lowerEndpoint);
        buf.append(String.format("%s %s '%s'", column, operator, lowerDate.toString()));
        if (dateRange.hasUpperBound()) {
            buf.append(" AND ");
        }
    }

    if (dateRange.hasUpperBound()) {
        BoundType upperBound = dateRange.upperBoundType();
        String operator;
        switch (upperBound) {
        case CLOSED:
            operator = "<=";
            break;
        case OPEN:
            operator = "<";
            break;
        default:
            throw new AssertionError("unexpected bound type " + upperBound);
        }

        Date upperEndpoint = dateRange.upperEndpoint();
        java.sql.Date upperDate = convert(upperEndpoint);
        buf.append(String.format("%s %s '%s'", column, operator, upperDate.toString()));
    }

    return buf.toString();
}

---

From source file:org.apache.hadoop.hive.ql.optimizer.calcite.druid.DruidIntervalUtils.java

protected static List<Interval> toInterval(List<Range> ranges) {
    List<Interval> intervals = Lists.transform(ranges, new Function<Range, Interval>() {
        @Override/*from   w  w  w. ja v  a 2 s. co  m*/
        public Interval apply(Range range) {
            if (!range.hasLowerBound() && !range.hasUpperBound()) {
                return DruidTable.DEFAULT_INTERVAL;
            }
            long start = range.hasLowerBound() ? toLong(range.lowerEndpoint())
                    : DruidTable.DEFAULT_INTERVAL.getStartMillis();
            long end = range.hasUpperBound() ? toLong(range.upperEndpoint())
                    : DruidTable.DEFAULT_INTERVAL.getEndMillis();
            if (range.hasLowerBound() && range.lowerBoundType() == BoundType.OPEN) {
                start++;
            }
            if (range.hasUpperBound() && range.upperBoundType() == BoundType.CLOSED) {
                end++;
            }
            return new Interval(start, end);
        }
    });
    LOG.info("Converted time ranges " + ranges + " to interval " + intervals);
    return intervals;
}

---

From source file:net.sf.mzmine.modules.visualization.peaklisttable.PeakListTablePopupMenu.java

/**
 * Get a peak's RT range./*from   ww  w .  ja  v  a  2 s .  c om*/
 * 
 * @param peak
 *            the peak.
 * @return The peak's RT range.
 */
private static Range<Double> getPeakRTRange(final Feature peak) {

    final Range<Double> range = peak.getRawDataPointsRTRange();
    final double rtLen = range.upperEndpoint() - range.lowerEndpoint();
    return Range.closed(Math.max(0.0, range.lowerEndpoint() - rtLen), range.upperEndpoint() + rtLen);
}

---

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

/**
 * remove from self the elements that exist in other
 * @return//from   w  w w .  j a  v a  2 s. c  om
 */
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;

}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• »