Sets the minimum value of any feature after scaling is applied. This
value can be no smaller than -1
@param minFeature the minimum feature value after scaling
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;
    }
618764
public void setFeature(String name, boolean state) throws IllegalArgumentException, IllegalStateException {
		if (name == null) {
			throw new IllegalArgumentException("feature name can not be null");
		}
		if (FEATURE_NAMES_INTERNED.equals(name)) {
			namesInterned = state;
		} else if (FEATURE_SERIALIZER_ATTVALUE_USE_APOSTROPHE.equals(name)) {
			attributeUseApostrophe = state;
		} else {
			throw new IllegalStateException("unsupported feature " + name);
		}
	}
205340
public int ensureFeature(String featureName) {
        int feature = featureToIndex.getOrDefault(featureName, -1);
        if (feature == -1) {
            synchronized (featureToIndex) {
                feature = featureToIndex.getOrDefault(featureName, -1);
                if (feature == -1) {
                    feature = featureToIndex.size();
                    featureToIndex.put(featureName, feature);
                }
            }
        }
        return feature;
    }
216112
@Override
	public void initialize(double[] initial, int numberOfParameters, double minimumFunctionValue) {
		super.initialize(initial, numberOfParameters,minimumFunctionValue);
		y.reshape(numberOfParameters,1);

		xPrevious.reshape(numberOfParameters,1);
		x.reshape(numberOfParameters,1);

		// set the previous gradient to zero
		gradientPrevious.reshape(numberOfParameters,1);
		gradientPrevious.zero();

		firstIteration = true;
	}
1293096
public void setPremiumFeature(com.google.api.ads.admanager.axis.v201902.PremiumFeature premiumFeature) {
        this.premiumFeature = premiumFeature;
    }
54469
public final void setMinimumDuration(Duration duration) {
        Objects.requireNonNull(duration);
        if (minimumDuration != null) {
            minimumDuration.set(duration);
        } else {
            _minimumDuration = duration;
        }
    }
957102
public void setSampling( double min , double max , int total ) {
		this.sampleMin = min;
		this.sampleMax = max;
		this.numSamples = total;
		this.scores = new double[numSamples];
	}
185081
public void initInference() {
	if (lambda == null) {
	    System.out.println("numFetures: " + feaGen.numFeatures());
	    lambda = new double[feaGen.numFeatures() + 1];
	    
	    // reading feature weights from the feature list
	    for (int i = 0; i < feaGen.features.size(); i++) {
		Feature f = (Feature)feaGen.features.get(i);

		lambda[f.idx] = f.wgt;
	    }	    	    
	}    
    }
882916
public void setMinimumDuration(@NotNull final Duration minimumDuration) {
        if (minimumDuration.compareTo(MAXIMUM_DURATION) > 0) {
            throw new IllegalArgumentException("The minimum duaration has to be smaller than 23:59:59.");
        }
        this.minimumDuration = durationToDate(minimumDuration);
    }
186249
@Override
	public void setY(double min, double max) {
		if (min <= max) {
			this.miny = min;
			this.maxy = max;
		} else {
			this.miny = max;
			this.maxy = min;
		}
	}
1214411
public void setOccurence(int min, int max) throws ParseException {
    if (!simplified) {
      if ((min < 0) || (min > max) || (max < 1)) {
        throw new ParseException("Illegal number {" + min + "," + max + "}");
      }
      if (min == 0) {
        optional = true;
      }
      minimumOccurence = Math.max(1, min);
      maximumOccurence = max;
    } else {
      throw new ParseException("already simplified");
    }
  }
728357
@Override
	public void setX(double min, double max) {
		if (min <= max) {
			this.minx = min;
			this.maxx = max;
		} else {
			this.minx = max;
			this.maxx = min;
		}
	}
1299912
@PostConstruct
	protected void initFeatures() throws LayerException {
		crs = geoService.getCrs2(layerInfo.getCrs());
		try {
			setFeatureSourceName(layerInfo.getFeatureInfo().getDataSourceName());
			featureModel = new ShapeInMemFeatureModel(getDataStore(), layerInfo.getFeatureInfo().getDataSourceName(),
					geoService.getSridFromCrs(layerInfo.getCrs()), converterService);
			featureModel.setLayerInfo(layerInfo);
			FeatureCollection<SimpleFeatureType, SimpleFeature> col = getFeatureSource().getFeatures();
			FeatureIterator<SimpleFeature> iterator = col.features();
			int lastIndex = 0;
			while (iterator.hasNext()) {
				SimpleFeature feature = iterator.next();
				String id = featureModel.getId(feature);
				features.put(id, feature);
				int intId = Integer.parseInt(id.substring(id.lastIndexOf('.') + 1));
				if (intId > lastIndex) {
					lastIndex = intId;
				}
			}
			iterator.close();
			((ShapeInMemFeatureModel) featureModel).setNextId(++lastIndex);
		} catch (NumberFormatException nfe) {
			throw new LayerException(nfe, ExceptionCode.FEATURE_MODEL_PROBLEM, url);
		} catch (MalformedURLException e) {
			throw new LayerException(e, ExceptionCode.INVALID_SHAPE_FILE_URL, url);
		} catch (IOException ioe) {
			throw new LayerException(ioe, ExceptionCode.CANNOT_CREATE_LAYER_MODEL, url);
		} catch (GeomajasException ge) {
			throw new LayerException(ge, ExceptionCode.CANNOT_CREATE_LAYER_MODEL, url);
		}
	}
412964
public void setFeature(Feature feature) {
		List<Feature> features = new ArrayList<Feature>();
		features.add(feature);
		LazyLoader.lazyLoad(features, GeomajasConstant.FEATURE_INCLUDE_ATTRIBUTES, new LazyLoadCallback() {

			public void execute(List<Feature> response) {
				Feature feature = response.get(0);
				if (attributeTable == null) {
					buildWidget(feature.getLayer());
				}
				if (feature != null) {
					setTitle(I18nProvider.getAttribute().getAttributeWindowTitle(feature.getLabel()));
				} else {
					setTitle(I18nProvider.getAttribute().getAttributeWindowTitle(""));
				}
				attributeTable.setFeature(feature);
			}
		});
	}
635033
public void setFeature(Feature feature) {
		if (feature != null) {
			this.feature = feature;
			copyToForm(this.feature);
		} else {
			this.feature = null;
			featureForm.clear();
		}
	}
199745
public final void setValue(final Float value) {
        Condition.INSTANCE.ensureAtLeast(value, getMinValue(),
                "The value must be at least the minimum value");
        Condition.INSTANCE.ensureAtMaximum(value, getMaxValue(),
                "The value must be at maximum the maximum value");
        float roundedValue = adaptToStepSize(roundToDecimals(value));

        if (this.value != roundedValue) {
            this.value = roundedValue;
            this.currentValue = roundedValue;
            persistFloat(roundedValue);
            notifyChanged();
        }
    }
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));
    }