Set the parameter values
421131
def set_params(self,**kwargs):
        
        for key,value in list(kwargs.items()):
            setattr(self,key,value)
880244
def set_parameter(connection, parameter, value, verbose=False):
    
    value = str(value)
    try:
        if not connection.set_parameter(parameter, value):
            raise ValueError("invalid parameter or value")
    except (AttributeError, ValueError) as exc:
        warnings.warn(
            'failed to set {}={!r}: {}'.format(parameter, value, str(exc)),
            io_nds2.NDSWarning)
    else:
        print_verbose(
            '    [{}] set {}={!r}'.format(
                connection.get_host(), parameter, value),
            verbose=verbose,
        )
462663
def set_parameters(self,parameters):
        
        
        for key,value in list(parameters.items()):
            if key in self.parameters:
                self.parameters[key] = value
70607
public void setParameters(java.util.Collection<ParameterMetadata> parameters) {
        if (parameters == null) {
            this.parameters = null;
            return;
        }

        this.parameters = new com.amazonaws.internal.SdkInternalList<ParameterMetadata>(parameters);
    }
931783
def set_free_parameters(self, values):
        

        assert len(values) == len(self.free_parameters)

        for parameter, this_value in zip(self.free_parameters.values(), values):

            parameter.value = this_value
710342
def setRandomParams(self):
        
        params = SP.randn(self.getNumberParams())
        self.setParams(params)
428830
public void setParameters(ICalParameters parameters) {
		if (parameters == null) {
			throw new NullPointerException(Messages.INSTANCE.getExceptionMessage(16));
		}
		this.parameters = parameters;
	}
320717
def _set_value(self, new_value):
        """"""

        if self.min_value is not None and new_value < self.min_value:

            raise SettingOutOfBounds(
                "Trying to set parameter {0} = {1}, which is less than the minimum allowed {2}".format(
                    self.name, new_value, self.min_value))

        if self.max_value is not None and new_value > self.max_value:
            raise SettingOutOfBounds(
                "Trying to set parameter {0} = {1}, which is more than the maximum allowed {2}".format(
                    self.name, new_value, self.max_value))

        # Issue a warning if there is an auxiliary variable, as the setting does not have any effect
        if self.has_auxiliary_variable():

            with warnings.catch_warnings():

                warnings.simplefilter("always", RuntimeWarning)

                warnings.warn("You are trying to assign to a parameter which is either linked or "
                              "has auxiliary variables. The assignment has no effect.", RuntimeWarning)

        # Save the value as a pure floating point to avoid the overhead of the astropy.units machinery when
        # not needed

        if self._transformation is None:

            new_internal_value = new_value

        else:

            new_internal_value = self._transformation.forward(new_value)

        # If the parameter has changed, update its value and call the callbacks if needed

        if new_internal_value != self._internal_value:

            # Update
            self._internal_value = new_internal_value

            # Call the callbacks (if any)
            for callback in self._callbacks:

                try:

                    callback(self)

                except:

                    raise NotCallableOrErrorInCall("Could not call callback for parameter %s" % self.name)
476289
def param (self, param, kwargs, default_value=False):
        """"""
        if param in kwargs:
            value= kwargs[param]
            del kwargs[param]
        else:
            value= default_value
        setattr (self, param, value)
138371
def set_param(self, key, value):
        
        self.__dict__[key] = value
        self._parameters[key] = value
23564
def set_params(self, l2_regularization=0.0, optimizer=None, optimizer_kwargs=None):
        
        self.l2_regularization = l2_regularization
        self._optimizer = optimizer
        self._optimizer_kwargs = optimizer_kwargs
        return self
1096133
private void setParameter(String key, Object value){
        if (value == null){
            parameters.remove(key);
        }     
        else{
            parameters.put(key, value);
        }
    }
957607
def set_parameter(self, name, value):
        
        i = self.get_parameter_names(include_frozen=True).index(name)
        v = self.get_parameter_vector(include_frozen=True)
        v[i] = value
        self.set_parameter_vector(v, include_frozen=True)
613760
def set_parameters(self, parameters_dict):
        
        DB.set_hash_value(self._key, 'parameters', parameters_dict)
        self.publish("parameters_updated")
265749
public void setParametersVariables() {
    hasInOutParameters = false;
    for (CallParameter param : params) {
      if (param != null && param.isOutput() && param.isInput()) {
        hasInOutParameters = true;
        break;
      }
    }
  }
1119510
def __set_parameters(self):
        
        self.__set_buffer_start(self.CMD_SET_PARAMETERS)
        # Can I send 0xFF as address to not change it each time?
        # Worry about writing to EEPROM or Flash with each address change.
        # Would then implement a separate address only change function.
        self.STRUCT_SET_PARAMETERS.pack_into(self.__out_buffer, self.OFFSET_PAYLOAD,
                                             self._max_current, self._max_power, self.address,
                                             self._load_mode, self._load_value)
        self.__set_checksum()
        self.__send_buffer()
        self.update_status()
431452
def set_parameter(self, name, value):
        """"""
        self.lib.tdSetDeviceParameter(self.id, name, str(value))