Sets the minimum value of the gauge scale to the given value

@param VALUE
337142
public void setMinValue(final double VALUE) {
        if (Status.RUNNING == timeline.getStatus()) { timeline.jumpTo(Duration.ONE); }
        if (null == minValue) {
            if (VALUE > getMaxValue()) { setMaxValue(VALUE); }
            _minValue = Helper.clamp(-Double.MAX_VALUE, getMaxValue(), VALUE);
            setRange(getMaxValue() - _minValue);
            if (Double.compare(originalMinValue, -Double.MAX_VALUE) == 0) originalMinValue = _minValue;
            if (isStartFromZero() && _minValue < 0) setValue(0);
            if (Double.compare(originalThreshold, getThreshold()) < 0) { setThreshold(Helper.clamp(_minValue, getMaxValue(), originalThreshold)); }
            updateFormatString();
            fireUpdateEvent(RECALC_EVENT);
            if (!valueProperty().isBound()) Gauge.this.setValue(Helper.clamp(getMinValue(), getMaxValue(), Gauge.this.getValue()));
        } else {
            minValue.set(VALUE);
        }
    }
704023
def _set_min_value(self, min_value):

        """"""

        # Check that the min value can be transformed if a transformation is present
        if self._transformation is not None:

            if min_value is not None:

                try:

                    _ = self._transformation.forward(min_value)

                except FloatingPointError:

                    raise ValueError("The provided minimum %s cannot be transformed with the transformation %s which "
                                     "is defined for the parameter %s" % (min_value,
                                                                          type(self._transformation),
                                                                          self.path))

        # Store the minimum as a pure float

        self._external_min_value = min_value

        # Check that the current value of the parameter is still within the boundaries. If not, issue a warning

        if self._external_min_value is not None and self.value < self._external_min_value:

            warnings.warn("The current value of the parameter %s (%s) "
                          "was below the new minimum %s." % (self.name, self.value, self._external_min_value),
                          exceptions.RuntimeWarning)

            self.value = self._external_min_value
1307938
public synchronized void setValue(int i, int value) {

        if (i < 0 || i >= count) {
            throw new IndexOutOfBoundsException();
        }

        if (sortOnValues) {
            sorted = false;
        }

        values[i] = value;
    }
864478
@Override
	public void setValue(StringValue value) {
		Validate.notNull(value);
		setValue(value.value, 0, value.len);
	}
712243
public final void setValue(String value) {

        if ((null == value) || value.isEmpty()) {
            setDefaultValue();
        } else {
            try {
                tryToSetParsedValue(value);
            } catch (@SuppressWarnings("unused") Exception e) {
                CmsDebugLog.consoleLog("Could not set invalid serial date value: " + value);
                setDefaultValue();
            }
        }
        notifyOnValueChange();
    }
668782
public void setPerformance(int evaluation, double value) {
    if ((m_Metrics != null) && !m_Metrics.check(evaluation))
      return;
    m_MetricValues.put(evaluation, value);
  }
967007
public void setRange( int dimension , double min , double max ) {
		valueMin[dimension] = min;
		valueMax[dimension] = max;
	}
276643
@Override
	public void accept(final double value) {
		super.accept(value);
		_min = Math.min(_min, value);
		_max = Math.max(_max, value);
		_sum.add(value);
	}
435386
public void setColor(String value) {

        if (COLOR_TRANSPARENT.indexOf(value) == 0) {
            setColor(Simapi.COLOR_TRANSPARENT);
        } else {
            setColor(CmsStringUtil.getColorValue(value, Simapi.COLOR_TRANSPARENT, SCALE_PARAM_COLOR));
        }
    }
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");
    }
514133
public void setMinScaled(double minFeature)
    {
        if(Double.isNaN(minFeature))
            throw new ArithmeticException("NaN is not a valid feature value");
        else if(minFeature < -1)
            throw new ArithmeticException("Minimum possible feature value is -1, can not use " + minFeature);
        else if(minFeature >= maxScaled)
            throw new ArithmeticException("Minimum feature value must be smaller than the maximum");
        this.minScaled = minFeature;
    }
771606
public void setValueI(int x, int y, double value) {
		int idx=y*width+x;
		setValueI_atIndex(idx, value);
	}
947339
public void setScale(double scale)
    {
        if(scale <= 0 || Double.isNaN(scale) || Double.isInfinite(scale))
            throw new ArithmeticException("Scale must be a positive value, not " + scale);
        this.scale = scale;
        this.logScale = log(scale);
    }
14338
public void setAxisValue(int axis, float value) {
        switch (axis) {
            case AXIS_X:
                x = value;
                break;
            case AXIS_Y:
                y = value;
                break;
            case AXIS_PRESSURE:
                pressure = value;
                break;
            case AXIS_SIZE:
                size = value;
                break;
            case AXIS_TOUCH_MAJOR:
                touchMajor = value;
                break;
            case AXIS_TOUCH_MINOR:
                touchMinor = value;
                break;
            case AXIS_TOOL_MAJOR:
                toolMajor = value;
                break;
            case AXIS_TOOL_MINOR:
                toolMinor = value;
                break;
            case AXIS_ORIENTATION:
                orientation = value;
                break;
            default: {
                if (axis < 0 || axis > 63) {
                    throw new IllegalArgumentException("Axis out of range.");
                }
                final long bits = mPackedAxisBits;
                final long axisBit = 1L << axis;
                final int index = Long.bitCount(bits & (axisBit - 1L));
                float[] values = mPackedAxisValues;
                if ((bits & axisBit) == 0) {
                    if (values == null) {
                        values = new float[INITIAL_PACKED_AXIS_VALUES];
                        mPackedAxisValues = values;
                    } else {
                        final int count = Long.bitCount(bits);
                        if (count < values.length) {
                            if (index != count) {
                                System.arraycopy(values, index, values, index + 1,
                                        count - index);
                            }
                        } else {
                            float[] newValues = new float[count * 2];
                            System.arraycopy(values, 0, newValues, 0, index);
                            System.arraycopy(values, index, newValues, index + 1,
                                    count - index);
                            values = newValues;
                            mPackedAxisValues = values;
                        }
                    }
                    mPackedAxisBits = bits | axisBit;
                }
                values[index] = value;
            }
        }
    }
875196
public void setVersion(String value) {
        clear();
        
        if (value == null || value.length() == 0) {
            return;
        }
        
        String pcs[] = value.split("\\.", 4);
        int len = Math.min(pcs.length, 4);
        
        for (int i = 0; i < len; i++) {
            ver[i] = Long.parseLong(pcs[i]);
        }
    }
581754
public void setValue(String value) {
		contents = new ArrayList();
		contents.add(value);
		if (value.trim().length() > 0) {
			containsSingleString = true;
		}
	}
542458
public void setValue (int index, String value)
    {
    if (index >= 0 && index < length) {
        data[index*5+4] = value;
    } else {
        badIndex(index);
    }
    }