输入数值必须在最值区间

@param fixedMinValue 最小值
@param fixedMaxValue 最大值
@return Scheme
494457
public static Scheme rangeValue(final Long fixedMinValue, final Long fixedMaxValue) {
        return rangeValue(fixedMinValue.doubleValue(), fixedMaxValue.doubleValue());
    }
477942
public static String fixed(EvaluationContext ctx, Object number, @IntegerDefault(2) Object decimals, @BooleanDefault(false) Object noCommas) {
        BigDecimal _number = Conversions.toDecimal(number, ctx);
        _number = _number.setScale(Conversions.toInteger(decimals, ctx), RoundingMode.HALF_UP);

        DecimalFormat format = new DecimalFormat();
        format.setMaximumFractionDigits(9);
        format.setGroupingUsed(!Conversions.toBoolean(noCommas, ctx));
        return format.format(_number);
    }
413506
public static AssignerConfigurable value(TypeDescription fixedValue) {
        return new ForPoolValue(ClassConstant.of(fixedValue), TypeDescription.CLASS);
    }
1327935
public void setRange( int minValue , int maxValue ) {
		this.maxValue = maxValue;
		this.minValue = minValue;

		histogram.resize(maxValue-minValue+1);
		histIndexes.resize(maxValue-minValue+1);
	}
1118189
public T set(final T newValue) {
        if(continuous!=null)
         continuous.offer(newValue);

        setDiscreteIfDiff(newValue);
        return newValue;
    }
539427
public List<Double> setFixedValue(List<Double> value) throws IOException, SaneException {
    List<SaneWord> wordValues =
        Lists.transform(
            value,
            new Function<Double, SaneWord>() {
              @Override
              public SaneWord apply(Double input) {
                Preconditions.checkArgument(
                    input >= -32768 && input <= 32767.9999, "value " + input + " is out of range");
                return SaneWord.forFixedPrecision(input);
              }
            });

    ControlOptionResult result = writeWordListOption(wordValues);

    List<Double> newValues =
        Lists.newArrayListWithCapacity(result.getValueSize() / SaneWord.SIZE_IN_BYTES);
    for (int i = 0; i < result.getValueSize(); i += SaneWord.SIZE_IN_BYTES) {
      newValues.add(SaneWord.fromBytes(result.getValue(), i).fixedPrecisionValue());
    }

    return newValues;
  }
681407
public static Constraint max(final Number max) {
		return new Constraint("max", maxPayload(max)) {
			public boolean isValid(Object actualValue) {
				return actualValue == null || (actualValue instanceof Number && max != null &&
						max.longValue() >= ((Number) actualValue).longValue());
			}
		};
	}
511773
public static PactDslJsonArray arrayMinMaxLike(int minSize, int maxSize, PactDslJsonRootValue value) {
    return arrayMinMaxLike(minSize, maxSize, minSize, value);
  }
1116818
@SuppressWarnings("rawtypes")
    public static <T extends Comparable> Predicate<T> between(final T minValue, final T maxValue) {
        return new Predicate<T>() {
            @Override
            public boolean test(T value) {
                return N.compare(value, minValue) > 0 && N.compare(value, maxValue) < 0;
            }
        };
    }
480193
public LongParameter setMinimumValue(long minimumValue) {
		if (hasMaximumValue) {
			Util.checkParameter(minimumValue <= maximumValue,
				"Minimum value (" + minimumValue + ") must be less than or equal to maximum (" + maximumValue + ")");
		}

		this.hasMinimumValue = true;
		this.minimumValue = minimumValue;

		return this;
	}
912628
public static Range range(final double minValue, final double maxValue) {
        if (minValue > maxValue) {
            throw new IllegalArgumentException("minValue should be less then or equal to maxValue (" + minValue+ ", " + maxValue + ")");
        }
        return new Range() {

            @Override
            public Number getMinimum() {
                return minValue;
            }

            @Override
            public Number getMaximum() {
                return maxValue;
            }

            @Override
            public String toString() {
                return Ranges.toString(this);
            }
            
        };
    }
589025
public DoubleParameter setMaximumValue(double maximumValue, boolean inclusive) {
		if (hasDefaultValue) {
			if (inclusive) {
				Util.checkParameter(maximumValue >= defaultValue,
					"Maximum value (" + maximumValue + ") must be greater than or equal to default (" + defaultValue + ")");
			} else {
				Util.checkParameter(maximumValue > defaultValue,
					"Maximum value (" + maximumValue + ") must be greater than default (" + defaultValue + ")");
			}
		} else if (hasMinimumValue) {
			if (inclusive && minimumValueInclusive) {
				Util.checkParameter(maximumValue >= minimumValue,
					"Maximum value (" + maximumValue + ") must be greater than or equal to minimum (" + minimumValue + ")");
			} else {
				Util.checkParameter(maximumValue > minimumValue,
					"Maximum value (" + maximumValue + ") must be greater than minimum (" + minimumValue + ")");
			}
		}

		this.hasMaximumValue = true;
		this.maximumValue = maximumValue;
		this.maximumValueInclusive = inclusive;

		return this;
	}
371582
@Override
  public MutableRoaringBitmap limit(int maxcardinality) {
    MutableRoaringBitmap answer = new MutableRoaringBitmap();
    int currentcardinality = 0;
    for (int i = 0; (currentcardinality < maxcardinality)
        && (i < this.highLowContainer.size()); i++) {
      MappeableContainer c = this.highLowContainer.getContainerAtIndex(i);
      if (c.getCardinality() + currentcardinality <= maxcardinality) {
        ((MutableRoaringArray) answer.highLowContainer)
            .append(this.highLowContainer.getKeyAtIndex(i), c.clone());
        currentcardinality += c.getCardinality();
      } else {
        int leftover = maxcardinality - currentcardinality;
        MappeableContainer limited = c.limit(leftover);
        ((MutableRoaringArray) answer.highLowContainer)
            .append(this.highLowContainer.getKeyAtIndex(i), limited);
        break;
      }
    }
    return answer;
  }
994883
@javax.annotation.Nonnull
  public com.simiacryptus.util.data.DensityTree setMaxDepth(int maxDepth) {
    this.maxDepth = maxDepth;
    return this;
  }
1238255
private void setFixedValue(final String value) {
		boolean toBeLogged = false;
		if (log.isDebugEnabled() && (value != null && !value.equals(fixedValue) || fixedValue != null && !fixedValue.equals(value))) {
			toBeLogged = true;
		}
		fixedValue = value;
		currentValue = null;
		if (toBeLogged) {
			log.debug("setFixedValue: " + this);
		}

	}
1208788
public static ScalingPolicy fixed(int numSegments) {
        Preconditions.checkArgument(numSegments > 0, "Number of segments should be > 0.");
        return new ScalingPolicy(ScaleType.FIXED_NUM_SEGMENTS, 0, 0, numSegments);
    }
719791
public static double clamp(double value, double min, double max)
    {
        final double fixed;
        if (value < min)
        {
            fixed = min;
        }
        else if (value > max)
        {
            fixed = max;
        }
        else
        {
            fixed = value;
        }
        return fixed;
    }