Sets the minimum value, the preference should allow to choose.

@param minValue
The minimum value, which should be set, as an {@link Integer} value. The value must
be less than the maximum value, the preference allows to choose
325825
public final void setMinValue(final int minValue) {
        Condition.INSTANCE.ensureSmaller(minValue, getMaxValue(),
                "The minimum value must be less than the maximum value");
        this.minValue = minValue;
        setValue(Math.max(getValue(), minValue));
    }
1133970
public final void setMaxNumber(final int maxNumber) {
        Condition.INSTANCE.ensureGreater(maxNumber, getMinNumber(),
                "The maximum number must be greater than the minimum number");
        this.maxNumber = maxNumber;
        setNumber(Math.min(getNumber(), maxNumber));
    }
1364778
public void setFirstOccurence(int min, int max) throws ParseException {
    if (fullCondition == null) {
      if ((min < 0) || (min > max) || (max < 1)) {
        throw new ParseException("Illegal number {" + min + "," + max + "}");
      }
      if (min == 0) {
        firstOptional = true;
      }
      firstMinimumOccurence = Math.max(1, min);
      firstMaximumOccurence = max;
    } else {
      throw new ParseException("fullCondition already generated");
    }
  }
622722
@Override
    public final void setPriority(int value) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "setPriority", Integer.valueOf(value));
        if ((value >= MfpConstants.MIN_PRIORITY) && (value <= MfpConstants.MAX_PRIORITY)) {
            /* Call the superclass's method to set the value into the field */
            super.setPriority(value);
        }
        else {
            IllegalArgumentException e = new IllegalArgumentException(Integer.toString(value));
            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                SibTr.exit(this, tc, "setPriority", e);
            throw e;
        }
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "setPriority");
    }
146049
public static void lessThan(long value, long maxValue, String name) {
        if (value <= 0) {
            throw new IllegalArgumentException(name + " should be > 0, current value " + value);
        }
        if (value > maxValue) {
            throw new IllegalArgumentException(name + " should be <= " + maxValue + ", current value " + value);
        }
    }
126098
public void setMinValue(final double MIN_VALUE) {
        // check min-max values
        if (Double.compare(MIN_VALUE, maxValue) == 0) {
            throw new IllegalArgumentException("Min value cannot be equal to max value");
        }

        if (Double.compare(MIN_VALUE, maxValue) > 0) {
            minValue = maxValue;
            maxValue = MIN_VALUE;
        } else {
            minValue = MIN_VALUE;
        }
        calculate();
        validate();
        calcAngleStep();
        fireStateChanged();
    }
403008
public void setMinMax(int min, int max)
    {
        if(min >= max)
            throw new IllegalArgumentException("The input minimum (" + min + ") must be less than the given max (" + max  + ")");
        this.min = min;
        this.max = max;
    }
1194906
@Override
	public void setMinY(double y) {
		double o = this.maxy;
		if (o<y) {
			this.miny = o;
			this.maxy = y;
		}
		else {
			this.miny = y;
		}
	}
975023
@Pure
	public IntegerProperty minXProperty() {
		if (this.minX == null) {
			this.minX = new SimpleIntegerProperty(this, MathFXAttributeNames.MINIMUM_X) {
				@Override
				protected void invalidated() {
					final int currentMin = get();
					final int currentMax = getMaxX();
					if (currentMax < currentMin) {
						// min-max constrain is broken
						maxXProperty().set(currentMin);
					}
				}
			};
		}
		return this.minX;
	}
62902
public void setMaxValue(final double MAX_VALUE) {
        // check min-max values
        if (Double.compare(MAX_VALUE, minValue) == 0) {
            throw new IllegalArgumentException("Max value cannot be equal to min value");
        }

        if (Double.compare(MAX_VALUE, minValue) < 0) {
            maxValue = minValue;
            minValue = MAX_VALUE;
        } else {
            maxValue = MAX_VALUE;
        }
        calculate();
        validate();
        calcAngleStep();
        fireStateChanged();
    }
795641
public void setMin(String v) {
    if (NUMEX_Type.featOkTst && ((NUMEX_Type)jcasType).casFeat_min == null)
      jcasType.jcas.throwFeatMissing("min", "de.julielab.jules.types.muc7.NUMEX");
    jcasType.ll_cas.ll_setStringValue(addr, ((NUMEX_Type)jcasType).casFeatCode_min, v);}
900759
public void setControlValue(Object objValue)
    {
        String strValue = ZERO;
        if (objValue instanceof Integer)
            strValue = objValue.toString();
        this.setName(strValue);
    }
696252
public void setMinValue(final BigDecimal minValue) {
		BigDecimal currMin = getMinValue();
		if (!Objects.equals(minValue, currMin)) {
			getOrCreateComponentModel().minValue = minValue;
		}
	}
1045282
@Pure
	public DoubleProperty minYProperty() {
		if (this.minY == null) {
			this.minY = new SimpleDoubleProperty(this, MathFXAttributeNames.MINIMUM_Y) {
				@Override
				protected void invalidated() {
					final double currentMin = get();
					final double currentMax = getMaxY();
					if (currentMin > currentMax) {
						// min-max constrain is broken
						maxYProperty().set(currentMin);
					}
				}
			};
		}
		return this.minY;
	}
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;
		}
	}
853504
public Statistics columnMinValue(String columnName, Number min) {
		this.columnStats
			.computeIfAbsent(columnName, column -> new HashMap<>())
			.put(MIN_VALUE, String.valueOf(min));
		return 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;
	}