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

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

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

Introduction

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

Prototype

public static <C extends Comparable<?>> Range<C> atMost(C endpoint)

Source Link

Document

Returns a range that contains all values less than or equal to endpoint .

Usage

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// www.  j  a  v  a  2  s  .  co 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:com.github.fge.grappa.matchers.join.JoinMatcherBuilder.java

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

From source file:com.wealdtech.jackson.modules.DateTimeRangeDeserializer.java

public static Range<DateTime> deserialize(final String txt) throws IOException {
      final int txtLen = txt.length();

      final int firstDateChar;
      boolean lowerClosed;
      if (txt.charAt(0) == '[') {
          firstDateChar = 1;//from w ww  .java  2s. c om
          lowerClosed = true;
      } else if (txt.charAt(0) == '(') {
          firstDateChar = 1;
          lowerClosed = false;
      } else if (txt.charAt(0) >= '0' && txt.charAt(0) <= '9') {
          // Lazy version
          firstDateChar = 0;
          lowerClosed = true;
      } else {
          throw new DataError.Bad("Unexpected first character in range \"" + txt + "\"");
      }

      boolean upperClosed;
      if (txt.charAt(txtLen - 1) == ']') {
          upperClosed = true;
      } else if (txt.charAt(txtLen - 1) == ')') {
          upperClosed = false;
      } else if (firstDateChar == 0) {
          upperClosed = false;
      } else {
          throw new DataError.Bad("Unexpected last character in range \"" + txt + "\"");
      }

      final Iterator<String> dateTimes;
      if (txt.indexOf(WEALD_SPLITTER_CHAR) != -1) {
          dateTimes = WEALD_SPLITTER.split(txt.substring(firstDateChar, txtLen - firstDateChar)).iterator();
      } else if (txt.indexOf(GUAVA_SPLITTER_CHAR) != -1) {
          dateTimes = GUAVA_SPLITTER.split(txt.substring(firstDateChar, txtLen - firstDateChar)).iterator();
      } else {
          throw new DataError.Bad("Cannot find a range separator in range \"" + txt + "\"");
      }
      String start = dateTimes.next();
      String end = dateTimes.next();

      boolean lowerBound;
      final DateTime lowerPoint;
      if (start.equals(NEGATIVE_INFINITY)) {
          lowerBound = false;
          lowerPoint = null;
      } else {
          lowerBound = true;
          lowerPoint = DateTimeDeserializer.deserialize(start);
      }

      boolean upperBound;
      final DateTime upperPoint;
      if (end.equals(POSITIVE_INFINITY)) {
          upperBound = false;
          upperPoint = null;
      } else {
          upperBound = true;
          upperPoint = DateTimeDeserializer.deserialize(end);
      }

      if (lowerBound == false && upperBound == false) {
          return Range.all();
      } else if (lowerBound == false) {
          // Upper present
          if (upperClosed == true) {
              return Range.lessThan(upperPoint);
          } else {
              return Range.atMost(upperPoint);
          }
      } else if (upperBound == false) {
          // Lower present
          if (lowerClosed == true) {
              return Range.atLeast(lowerPoint);
          } else {
              return Range.greaterThan(lowerPoint);
          }
      } else {
          // Both present
          if (lowerClosed == true) {
              if (upperClosed == true) {
                  return Range.closed(lowerPoint, upperPoint);
              } else {
                  return Range.closedOpen(lowerPoint, upperPoint);
              }
          } else {
              if (upperClosed == true) {
                  return Range.openClosed(lowerPoint, upperPoint);
              } else {
                  return Range.open(lowerPoint, upperPoint);
              }
          }
      }
  }

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

/**
 * Turn CNF filters into range//from   ww w . j  a  v  a 2s  .  c  o 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:li.klass.fhem.service.graph.gplot.GPlotParser.java

private GPlotAxis createAxis(Map<String, String> setsDeclarations, String prefix) {
    String labelKey = prefix + "label";
    String rightLabel = setsDeclarations.containsKey(labelKey) ? setsDeclarations.get(labelKey) : "";

    String rangeKey = prefix + "range";
    Optional<Range<Double>> optRange = Optional.absent();
    if (setsDeclarations.containsKey(rangeKey)) {
        String rangeValue = setsDeclarations.get(rangeKey);
        String[] parts = rangeValue.split(":");

        Range<Double> range;
        if (rangeValue.startsWith(":")) {
            range = Range.atMost(Double.parseDouble(parts[0]));
        } else if (rangeValue.endsWith(":")) {
            range = Range.atLeast(Double.parseDouble(parts[0]));
        } else {//from   w w  w.  jav a2 s  . c o  m
            range = Range.closed(Double.parseDouble(parts[0]), Double.parseDouble(parts[1]));
        }
        optRange = Optional.of(range);
    }

    return new GPlotAxis(rightLabel, optRange);
}

From source file:org.corpus_tools.peppermodules.annis.Audio2ANNISMapper.java

@Override
public void nodeReached(GRAPH_TRAVERSE_TYPE traversalType, String traversalId, SNode currNode,
        SRelation sRelation, SNode fromNode, long order) {

    if (sRelation instanceof SMedialRelation
            && traversionType == Salt2ANNISMapper.TRAVERSION_TYPE.DOCUMENT_STRUCTURE_AUDIO) {
        SMedialRelation dsRel = (SMedialRelation) sRelation;
        Double start = dsRel.getStart();
        Double end = dsRel.getEnd();

        String val;
        if (start != null && end != null) {
            val = "" + start + "-" + end;
        } else if (start != null) {
            val = "" + start;
        } else if (end != null) {
            val = "-" + end;
        } else {/*from   w  w  w  . j  ava2s.  c om*/
            val = "";
        }

        SToken tok = dsRel.getSource();
        List<Long> virtualToken = idManager.getVirtualisedTokenId(tok.getId());
        if (virtualToken == null) {

            tok.createAnnotation("annis", "time", val);
            mapSNode(dsRel.getSource());
        } else if (!virtualToken.isEmpty()) {
            // there is already a virtual span written for this token,
            // add the time information to the overlapped virtual token instead

            if (virtualToken.size() == 1) {

                Range<Double> newRange = Range.all();
                if (start != null && end != null) {
                    newRange = Range.closed(start, end);
                } else if (start != null) {
                    newRange = Range.atLeast(start);
                } else if (end != null) {
                    newRange = Range.atMost(end);
                }

                addVirtualRange(virtualToken.get(0), newRange);
            } else {
                Long firstTokenID = virtualToken.get(0);
                Long lastTokenID = virtualToken.get(virtualToken.size() - 1);

                if (start != null) {
                    addVirtualRange(firstTokenID, Range.atLeast(start));
                }
                if (end != null) {
                    addVirtualRange(lastTokenID, Range.atMost(end));
                }
            }
        }

        URI linkedFile = dsRel.getTarget().getMediaReference();
        if (linkedFile != null) {
            if (mappedFiles.add(linkedFile)) {
                copyLinkedFile(linkedFile);
            }
        }

    }

}

From source file:com.palantir.atlasdb.keyvalue.cassandra.TokenAwareMapper.java

public void refresh() {
    List<TokenRange> tokenRanges = getTokenRanges();

    ImmutableRangeMap.Builder<Token, List<InetAddress>> newTokenRing = ImmutableRangeMap.builder();
    for (TokenRange tokenRange : tokenRanges) {
        List<InetAddress> hosts = Lists.transform(tokenRange.getEndpoints(),
                new Function<String, InetAddress>() {
                    @Override/*ww  w. jav a2  s .c  om*/
                    public InetAddress apply(String endpoint) {
                        try {
                            return InetAddress.getByName(endpoint);
                        } catch (UnknownHostException e) {
                            throw new RuntimeException(e);
                        }
                    }
                });
        Token startToken = new Token(BaseEncoding.base16().decode(tokenRange.getStart_token().toUpperCase()));
        Token endToken = new Token(BaseEncoding.base16().decode(tokenRange.getEnd_token().toUpperCase()));
        if (startToken.compareTo(endToken) <= 0) {
            newTokenRing.put(Range.openClosed(startToken, endToken), hosts);
        } else {
            // Handle wrap-around
            newTokenRing.put(Range.greaterThan(startToken), hosts);
            newTokenRing.put(Range.atMost(endToken), hosts);
        }
    }
    tokenRing.set(newTokenRing.build());
}

From source file:org.apache.calcite.adapter.druid.DruidDateTimeUtils.java

protected static List<Range<Calendar>> leafToRanges(RexCall call, boolean withNot) {
    switch (call.getKind()) {
    case EQUALS:/*from w  w w.j  av  a  2s.c o  m*/
    case LESS_THAN:
    case LESS_THAN_OR_EQUAL:
    case GREATER_THAN:
    case GREATER_THAN_OR_EQUAL: {
        final Calendar value;
        if (call.getOperands().get(0) instanceof RexInputRef
                && literalValue(call.getOperands().get(1)) != null) {
            value = literalValue(call.getOperands().get(1));
        } else if (call.getOperands().get(1) instanceof RexInputRef
                && literalValue(call.getOperands().get(0)) != null) {
            value = literalValue(call.getOperands().get(0));
        } else {
            return null;
        }
        switch (call.getKind()) {
        case LESS_THAN:
            return ImmutableList.of(withNot ? Range.atLeast(value) : Range.lessThan(value));
        case LESS_THAN_OR_EQUAL:
            return ImmutableList.of(withNot ? Range.greaterThan(value) : Range.atMost(value));
        case GREATER_THAN:
            return ImmutableList.of(withNot ? Range.atMost(value) : Range.greaterThan(value));
        case GREATER_THAN_OR_EQUAL:
            return ImmutableList.of(withNot ? Range.lessThan(value) : Range.atLeast(value));
        default:
            if (!withNot) {
                return ImmutableList.of(Range.closed(value, value));
            }
            return ImmutableList.of(Range.lessThan(value), Range.greaterThan(value));
        }
    }
    case BETWEEN: {
        final Calendar value1;
        final Calendar value2;
        if (literalValue(call.getOperands().get(2)) != null
                && literalValue(call.getOperands().get(3)) != null) {
            value1 = literalValue(call.getOperands().get(2));
            value2 = literalValue(call.getOperands().get(3));
        } else {
            return null;
        }

        boolean inverted = value1.compareTo(value2) > 0;
        if (!withNot) {
            return ImmutableList.of(inverted ? Range.closed(value2, value1) : Range.closed(value1, value2));
        }
        return ImmutableList.of(Range.lessThan(inverted ? value2 : value1),
                Range.greaterThan(inverted ? value1 : value2));
    }
    case IN: {
        ImmutableList.Builder<Range<Calendar>> ranges = ImmutableList.builder();
        for (RexNode operand : Util.skip(call.operands)) {
            final Calendar element = literalValue(operand);
            if (element == null) {
                return null;
            }
            if (withNot) {
                ranges.add(Range.lessThan(element));
                ranges.add(Range.greaterThan(element));
            } else {
                ranges.add(Range.closed(element, element));
            }
        }
        return ranges.build();
    }
    default:
        return null;
    }
}

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

protected static List<Range> leafToRanges(RelDataType type, RexCall call, boolean withNot) {
    switch (call.getKind()) {
    case EQUALS://  w ww.jav  a 2s . c o  m
    case LESS_THAN:
    case LESS_THAN_OR_EQUAL:
    case GREATER_THAN:
    case GREATER_THAN_OR_EQUAL: {
        RexLiteral literal = null;
        if (call.getOperands().get(0) instanceof RexInputRef
                && call.getOperands().get(1) instanceof RexLiteral) {
            literal = extractLiteral(call.getOperands().get(1));
        } else if (call.getOperands().get(0) instanceof RexInputRef
                && call.getOperands().get(1).getKind() == SqlKind.CAST) {
            literal = extractLiteral(call.getOperands().get(1));
        } else if (call.getOperands().get(1) instanceof RexInputRef
                && call.getOperands().get(0) instanceof RexLiteral) {
            literal = extractLiteral(call.getOperands().get(0));
        } else if (call.getOperands().get(1) instanceof RexInputRef
                && call.getOperands().get(0).getKind() == SqlKind.CAST) {
            literal = extractLiteral(call.getOperands().get(0));
        }
        if (literal == null) {
            return null;
        }
        Comparable value = literalToType(literal, type);
        if (value == null) {
            return null;
        }
        if (call.getKind() == SqlKind.LESS_THAN) {
            return Arrays.<Range>asList(withNot ? Range.atLeast(value) : Range.lessThan(value));
        } else if (call.getKind() == SqlKind.LESS_THAN_OR_EQUAL) {
            return Arrays.<Range>asList(withNot ? Range.greaterThan(value) : Range.atMost(value));
        } else if (call.getKind() == SqlKind.GREATER_THAN) {
            return Arrays.<Range>asList(withNot ? Range.atMost(value) : Range.greaterThan(value));
        } else if (call.getKind() == SqlKind.GREATER_THAN_OR_EQUAL) {
            return Arrays.<Range>asList(withNot ? Range.lessThan(value) : Range.atLeast(value));
        } else { //EQUALS
            if (!withNot) {
                return Arrays.<Range>asList(Range.closed(value, value));
            }
            return Arrays.<Range>asList(Range.lessThan(value), Range.greaterThan(value));
        }
    }
    case BETWEEN: {
        RexLiteral literal1 = extractLiteral(call.getOperands().get(2));
        if (literal1 == null) {
            return null;
        }
        RexLiteral literal2 = extractLiteral(call.getOperands().get(3));
        if (literal2 == null) {
            return null;
        }
        Comparable value1 = literalToType(literal1, type);
        Comparable value2 = literalToType(literal2, type);
        if (value1 == null || value2 == null) {
            return null;
        }
        boolean inverted = value1.compareTo(value2) > 0;
        if (!withNot) {
            return Arrays.<Range>asList(inverted ? Range.closed(value2, value1) : Range.closed(value1, value2));
        }
        return Arrays.<Range>asList(Range.lessThan(inverted ? value2 : value1),
                Range.greaterThan(inverted ? value1 : value2));
    }
    case IN: {
        List<Range> ranges = Lists.newArrayList();
        for (int i = 1; i < call.getOperands().size(); i++) {
            RexLiteral literal = extractLiteral(call.getOperands().get(i));
            if (literal == null) {
                return null;
            }
            Comparable element = literalToType(literal, type);
            if (element == null) {
                return null;
            }
            if (withNot) {
                ranges.addAll(Arrays.<Range>asList(Range.lessThan(element), Range.greaterThan(element)));
            } else {
                ranges.add(Range.closed(element, element));
            }
        }
        return ranges;
    }
    default:
        return null;
    }
}

From source file:cn.ict.zyq.bestConf.COMT2.COMT2.java

private ArrayList<Branch2> getLeavesInfoForM5P(M5P model) {
    ArrayList<Branch2> retval = new ArrayList<Branch2>();
    ArrayList<RuleNode> leafNodes = new ArrayList<RuleNode>();
    model.getM5RootNode().returnLeaves(new ArrayList[] { leafNodes });

    for (RuleNode leaf : leafNodes) {
        Branch2 branch = new Branch2();
        ArrayList<PreConstructedLinearModel> lmodel = new ArrayList<PreConstructedLinearModel>();
        lmodel.add(leaf.getModel());//from  w  w w .  j  a v  a2  s  .c  o  m
        branch.setLinearModels(lmodel);

        Map<Attribute, Range<Double>> rangeMap = branch.getRangeMap();
        RuleNode parent = leaf, child;
        while (parent.parentNode() != null) {
            child = parent;
            parent = parent.parentNode();

            Attribute att = this.labeledInstances.attribute(parent.splitAtt());
            Range<Double> previous = null;
            if (parent.leftNode() == child)
                previous = rangeMap.put(att, Range.atMost(parent.splitVal()));
            else
                previous = rangeMap.put(att, Range.greaterThan(parent.splitVal()));
            //the attribute is visited previously
            if (previous != null) {
                previous = rangeMap.get(att).intersection(previous);
                rangeMap.put(att, previous);
            }
        }

        retval.add(branch);
    }

    return retval;
}