Sets the maximum number of minor tickmarks we're comfortable with
@param MAX_NO_OF_MINOR_TICKS the maxmium number of minor tickmarks for the axis
961223
public void setMaxNoOfMinorTicks(final int MAX_NO_OF_MINOR_TICKS) {
        if (MAX_NO_OF_MINOR_TICKS > 10) {
            this.maxNoOfMinorTicks = 10;
        } else if (MAX_NO_OF_MINOR_TICKS < 1) {
            this.maxNoOfMinorTicks = 1;
        } else {
            this.maxNoOfMinorTicks = MAX_NO_OF_MINOR_TICKS;
        }
        calculate();
        fireStateChanged();
    }
291947
@Override
	public void setX(double min, double max) {
		if (min <= max) {
			this.minxProperty.set(min);
			this.maxxProperty.set(max);
		} else {
			this.minxProperty.set(max);
			this.maxxProperty.set(min);
		}
	}
892226
def set_limits(self, min_: typing.Optional[float] = None, max_: typing.Optional[float] = None):
        
        self._min, self._max = min_, max_
357259
public void setIdleMax(int idleMax)
  {
    if (idleMax <= _idleMin) {
      throw new IllegalArgumentException(L.l("idle-max '{0}' must be greater than idle-min '{1}'.",
                                             idleMax, _idleMin));
    }

    _launcher.setIdleMax(_idleMax);
  }
1182179
public void setMaxPointError(double maxPointError)
    {
        if(maxPointError < 0 || Double.isInfinite(maxPointError) || Double.isNaN(maxPointError))
            throw new ArithmeticException("The error must be a positive value, not " + maxPointError );
        this.maxPointError = maxPointError;
    }
458840
public void setMin (float min) {
		if (min > max) throw new IllegalArgumentException("min can't be > max");

		this.min = min;

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

		if (current < min) {
			current = min;
			spinner.notifyValueChanged(spinner.isProgrammaticChangeEvents());
		}
	}
353336
public Parser setTrackErrors(int maxErrors) {
        errors = maxErrors > 0 ? ParseErrorList.tracking(maxErrors) : ParseErrorList.noTracking();
        return this;
    }
428236
public void setMinMax(double min, double max)
    {
        if(min <= 0 || Double.isNaN(min) || Double.isInfinite(min))
            throw new IllegalArgumentException("min value must be positive, not " + min);
        else if(min >= max || Double.isNaN(max) || Double.isInfinite(max))
            throw new IllegalArgumentException("max (" + max + ") must be larger than min (" + min+")" );
        this.max = max;
        this.min = min;
        this.logMax = Math.log(max);
        this.logMin = Math.log(min);
        this.logDiff = logMax-logMin;
        this.diff = max-min;
    }
600476
public void setMaxNorm(double maxNorm)
    {
        if(Double.isNaN(maxNorm) || Double.isInfinite(maxNorm) || maxNorm <= 0)
            throw new IllegalArgumentException("The maximum norm must be a positive constant, not " + maxNorm);
        this.maxNorm = maxNorm;
    }
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();
    }
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;
		}
	}
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;
    }
801635
protected final void setNoxItemXPosition(int position, float x) {
    noxItemsXPositions[position] = x;
    minX = (int) Math.min(x, minX);
    maxX = (int) Math.max(x, maxX);
  }
491455
public void setMaxWorkers(int maxWorkers) {
    synchronized (workerQueue) {
      idleLock.lock();
      try {
        int oldMaxWorkers = this.maxWorkers;
        this.maxWorkers = maxWorkers;

        // If the number of workers is being reduced, then signal any
        // waiting workers so that they can terminate themselves if
        // their id is greater than the number of workers, and so that
        // another worker can take over idle polling if the current
        // polling worker is to be terminated.
        if (maxWorkers < oldMaxWorkers) {
          idleComplete.signalAll();
        }
      } finally {
        idleLock.unlock();
      }
      while (numWorkers < maxWorkers) {
        String title = String.format("Worker (%d)", numWorkers + 1);
        ProgressMonitorWrapper monitor = new ProgressMonitorWrapper(numWorkers++, monitorFactory.createProgressMonitor(title));
        workerQueue.add(new Worker(monitor));
      }
    }
  }
1181893
def set_ylimits_widgets(self, set_min=True, set_max=True):
        """"""
        ymin, ymax = self.tab_plot.ax.get_ylim()
        if set_min:
            self.w.y_lo.set_text('{0}'.format(ymin))
        if set_max:
            self.w.y_hi.set_text('{0}'.format(ymax))
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);
    }
981058
private boolean updateMinMaxValues() {

        double min_x_value_new;
        double max_x_value_new;
        double max_y_value_new;

        if (this.measures == null) {
            // no values received yet -> reset axes
            min_x_value_new = 0;
            max_x_value_new = 1;
            max_y_value_new = 1;
        } else {
            min_x_value_new = getMinXValue();
            max_x_value_new = getMaxXValue();
            max_y_value_new = getMaxSelectedValue();
        }

        // resizing needed?
        if (min_x_value_new != this.min_x_value
                || max_x_value_new != this.max_x_value
                || max_y_value_new != this.max_y_value) {
            this.min_x_value = min_x_value_new;
            this.max_x_value = max_x_value_new;
            this.max_y_value = max_y_value_new;
            updateMinXValue();
            updateMaxXValue();
            updateMaxYValue();
            updateLowerXValue();
            updateUpperXValue();
            updateUpperYValue();
            return true;
        }
        return false;
    }