setDecel(string, double) -> None

        Sets the maximal comfortable deceleration in m/s^2 of vehicles of this type.
486893
def setDecel(self, typeID, decel):
        
        self._connection._sendDoubleCmd(
            tc.CMD_SET_VEHICLETYPE_VARIABLE, tc.VAR_DECEL, typeID, decel)
669544
@Deprecated
    protected void setTraceSpec(String s) {
        if (s != null) {
            TraceSpecification ts = new TraceSpecification(s, null, false);
            setTraceSpec(ts);
        }
    }
1207395
protected void setDestReference(Destination d) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "setDestReference", d);
        dest = d;
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "setDestReference");
    }
146887
public void setNon_specific(String v) {
    if (Timex2_Type.featOkTst && ((Timex2_Type)jcasType).casFeat_non_specific == null)
      jcasType.jcas.throwFeatMissing("non_specific", "de.julielab.jules.types.ace.Timex2");
    jcasType.ll_cas.ll_setStringValue(addr, ((Timex2_Type)jcasType).casFeatCode_non_specific, v);}
499323
public void setDep(WordForm v) {
    if (Dependency_Type.featOkTst && ((Dependency_Type)jcasType).casFeat_dep == null)
      jcasType.jcas.throwFeatMissing("dep", "com.digitalpebble.rasp.Dependency");
    jcasType.ll_cas.ll_setRefValue(addr, ((Dependency_Type)jcasType).casFeatCode_dep, jcasType.ll_cas.ll_getFSRef(v));}
1085724
def setAccel(self, typeID, accel):
        
        self._connection._sendDoubleCmd(
            tc.CMD_SET_VEHICLETYPE_VARIABLE, tc.VAR_ACCEL, typeID, accel)
534841
def _minimize_scalar(
        self, desc="Progress", rtol=1.4902e-08, atol=1.4902e-08, verbose=True
    ):
        
        from tqdm import tqdm
        from numpy import asarray
        from brent_search import minimize as brent_minimize

        variables = self._variables.select(fixed=False)
        if len(variables) != 1:
            raise ValueError("The number of variables must be equal to one.")

        var = variables[variables.names()[0]]
        progress = tqdm(desc=desc, disable=not verbose)

        def func(x):
            progress.update(1)
            var.value = x
            return self.__sign * self.value()

        r = asarray(
            brent_minimize(func, a=var.bounds[0], b=var.bounds[1], rtol=rtol, atol=atol)
        )
        var.value = r[0]
        progress.close()
776859
def setStimIndex(self, row, stimIndex):
        ""
        newcomp = self._allComponents[row][stimIndex]
        self._model.removeComponent(row, 1)
        self._model.insertComponent(newcomp, row, 1)
932776
public boolean setDoNotDisturb(VacuumDoNotDisturb dnd) throws CommandExecutionException {
        if (dnd == null) throw new CommandExecutionException(CommandExecutionException.Error.INVALID_PARAMETERS);
        return sendOk("set_dnd_timer", dnd.construct());
    }
787430
def setdict(self, D=None):
        """"""

        if D is not None:
            self.D = np.asarray(D, dtype=self.dtype)
        self.Df = sl.rfftn(self.D, self.cri.Nv, self.cri.axisN)
        # Compute D^H S
        self.DSf = np.conj(self.Df) * self.Sf
        if self.cri.Cd > 1:
            self.DSf = np.sum(self.DSf, axis=self.cri.axisC, keepdims=True)
        if self.opt['HighMemSolve'] and self.cri.Cd == 1:
            self.c = sl.solvedbd_sm_c(
                self.Df, np.conj(self.Df), self.mu*self.GHGf + self.rho,
                self.cri.axisM)
        else:
            self.c = None
386742
def setValuesTyped(self, rows, *values):
        ''
        for r, v in zip(rows, itertools.cycle(self.type(val) for val in values)):
            self.setValueSafe(r, v)
        self.recalc()
        return status('set %d cells to %d values' % (len(rows), len(values)))
519939
@Override
    public void setParameters(Object[] params) throws CDKException {
        if (params.length > 2) throw new CDKException("ToleranceRangeRule expects only two parameter");

        if (!(params[0] instanceof Double)) throw new CDKException("The parameter 0 must be of type Double");

        if (!(params[1] instanceof Double)) throw new CDKException("The parameter 1 must be of type Double");

        mass = (Double) params[0];
        tolerance = (Double) params[1];
    }
761549
private void setNormalizedMinValue(double value) {
        normalizedMinValue = Math.max(0d, Math.min(1d, Math.min(value, normalizedMaxValue)));
        invalidate();
    }
352325
public void setTypeOfNE(String v) {
    if (TIMEX_Type.featOkTst && ((TIMEX_Type)jcasType).casFeat_typeOfNE == null)
      jcasType.jcas.throwFeatMissing("typeOfNE", "de.julielab.jules.types.muc7.TIMEX");
    jcasType.ll_cas.ll_setStringValue(addr, ((TIMEX_Type)jcasType).casFeatCode_typeOfNE, v);}
430877
def setdict(self, D=None):
        """"""

        if D is not None:
            self.D = np.asarray(D, dtype=self.dtype)
        self.Df = sl.rfftn(self.D, self.cri.Nv, self.cri.axisN)
        if self.opt['HighMemSolve'] and self.cri.Cd == 1:
            self.c = sl.solvedbd_sm_c(
                self.Df, np.conj(self.Df),
                (self.mu / self.rho) * self.GHGf + 1.0, self.cri.axisM)
        else:
            self.c = None
681363
function setConstraints(oType, oConstraints) {
		var vIsDigitSequence, vMaxLength, vNullable;

		oType.oConstraints = undefined;
		if (oConstraints) {
			vMaxLength = oConstraints.maxLength;
			if (typeof vMaxLength === "string") {
				vMaxLength = parseInt(vMaxLength);
			}
			if (typeof vMaxLength === "number" && !isNaN(vMaxLength) && vMaxLength > 0) {
				oType.oConstraints = {maxLength : vMaxLength };
			} else if (vMaxLength !== undefined) {
				Log.warning("Illegal maxLength: " + oConstraints.maxLength, null, oType.getName());
			}
			vIsDigitSequence = oConstraints.isDigitSequence;
			if (vIsDigitSequence === true || vIsDigitSequence === "true") {
				oType.oConstraints = oType.oConstraints || {};
				oType.oConstraints.isDigitSequence = true;
			} else if (vIsDigitSequence !== undefined && vIsDigitSequence !== false
					&& vIsDigitSequence !== "false") {
				Log.warning("Illegal isDigitSequence: " + vIsDigitSequence, null, oType.getName());
			}

			vNullable = oConstraints.nullable;
			if (vNullable === false || vNullable === "false") {
				oType.oConstraints = oType.oConstraints || {};
				oType.oConstraints.nullable = false;
			} else if (vNullable !== undefined && vNullable !== true && vNullable !== "true") {
				Log.warning("Illegal nullable: " + vNullable, null, oType.getName());
			}
		}
	}
625514
private void updateNotArrivedH(double extrp)
    {
        if (fh < fhDest)
        {
            fh += velocity * extrp;
            if (fh > fhDest - sensibility)
            {
                fh = fhDest;
                arrivedH = true;
            }
        }
        else if (fh > fhDest)
        {
            fh -= velocity * extrp;
            if (fh < fhDest + sensibility)
            {
                fh = fhDest;
                arrivedH = true;
            }
        }
    }