Specify the data range

@param minValue Minimum allowed value.  (inclusive)
@param maxValue Maximum allowed value.  (inclusive)
512557
public void setRange( double minValue , double maxValue ) {
		this.maxValue = maxValue;
		this.minValue = minValue;

		divisor = 1.00001*(maxValue-minValue)/numBins;

		histIndexes.resize(numBins);

		if( histObjs.length < numBins ) {
		histObjs = new FastQueue[ numBins ];
			for (int i = 0; i < numBins; i++) {
				histObjs[i] = new FastQueue<SortableParameter_F64>(SortableParameter_F64.class,true);
			}
		}
	}
758113
public void setToLimit(int iAreaDesc) // Set this field to the largest or smallest value
    {   // By default compare as ASCII strings
        Double tempdouble = MIN;     // Lowest value
        if (iAreaDesc == DBConstants.END_SELECT_KEY)
            tempdouble =  MAX;
        this.doSetData(tempdouble, DBConstants.DONT_DISPLAY, DBConstants.SCREEN_MOVE);
    }
864577
public synchronized void setMax(int max) {
        if (max < 0) {
            max = 0;
        }
        if (max != mMax) {
            mMax = max;
            postInvalidate();

            if (mProgress > max) {
                mProgress = max;
            }
            refreshProgress(android.R.id.progress, mProgress, false);
        }
    }
1147965
public static Double validateNumber(final String context,
			final String input, final long minValue, final long maxValue,
			final boolean allowNull) throws ValidationException {
		return validator.getValidNumber(context, input, minValue, maxValue,
				allowNull);
	}
1111073
public void setMin (BigDecimal min) {
		if (min.compareTo(max) > 0) throw new IllegalArgumentException("min can't be > max");

		this.min = min;

		if (min.compareTo(BigDecimal.ZERO) >= 0) {
			textFieldFilter.setAcceptNegativeValues(false);
		} else {
			textFieldFilter.setAcceptNegativeValues(true);
		}

		if (current.compareTo(min) < 0) {
			current = min.setScale(scale, BigDecimal.ROUND_HALF_UP);
			spinner.notifyValueChanged(spinner.isProgrammaticChangeEvents());
		}
	}
503202
public ValidatorBuilderDouble<PARENT> range(double min, double max) {

    return range(new Range<>(Double.valueOf(min), Double.valueOf(max)));
  }
320826
public static boolean isBetween(Number value, Number min, Number max) {
		Assert.notNull(value);
		Assert.notNull(min);
		Assert.notNull(max);
		final double doubleValue = value.doubleValue();
		return (doubleValue >= min.doubleValue()) && (doubleValue <= max.doubleValue());
	}
36958
private void checkRangeValues(long minimum, long maximum) {
		if (minimum > maximum) {
			throw EvaluationException.create(
					MSG_MIN_MUST_BE_LESS_OR_EQUAL_TO_MAX, minimum, maximum);
		}
	}
696252
public void setMinValue(final BigDecimal minValue) {
		BigDecimal currMin = getMinValue();
		if (!Objects.equals(minValue, currMin)) {
			getOrCreateComponentModel().minValue = minValue;
		}
	}
967007
public void setRange( int dimension , double min , double max ) {
		valueMin[dimension] = min;
		valueMax[dimension] = max;
	}
506783
private void updateMinMax() {
    if(values.length == 0) {
      return; // Keep invalid.
    }
    min = max = values[0];
    for(int i = 1; i < values.length; i++) {
      int v = values[i];
      min = min < v ? min : v;
      max = max > v ? max : v;
    }
  }
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;
	}
488228
public static float restrict(float value, float minValue, float maxValue) {
        return Math.max(minValue, Math.min(value, maxValue));
    }
32204
public static Double validateDouble(final String context,
			final String input, final double minValue, final double maxValue,
			final boolean allowNull) throws ValidationException {
		return validator.getValidDouble(context, input, minValue, maxValue,
				allowNull);
	}
474502
private float limit(float value, float min, float max) {
    return Math.min(Math.max(min, value), max);
  }
485727
@Override
	public void setZ(double min, double max) {
		if (min <= max) {
			this.minz = min;
			this.maxz = max;
		} else {
			this.minz = max;
			this.maxz = min;
		}
	}
981384
public DoubleParameter setMinimumValue(double minimumValue, boolean inclusive) {
		if (hasDefaultValue) {
			if (inclusive) {
				Util.checkParameter(minimumValue <= defaultValue,
					"Minimum value (" + minimumValue + ") must be less than or equal to default (" + defaultValue + ")");
			} else {
				Util.checkParameter(minimumValue < defaultValue,
					"Minimum value (" + minimumValue + ") must be less than default (" + defaultValue + ")");
			}
		} else if (hasMaximumValue) {
			if (inclusive && maximumValueInclusive) {
				Util.checkParameter(minimumValue <= maximumValue,
					"Minimum value (" + minimumValue + ") must be less than or equal to maximum (" + maximumValue + ")");
			} else {
				Util.checkParameter(minimumValue < maximumValue,
					"Minimum value (" + minimumValue + ") must be less than maximum (" + maximumValue + ")");
			}
		}

		this.hasMinimumValue = true;
		this.minimumValue = minimumValue;
		this.minimumValueInclusive = inclusive;

		return this;
	}