Set the rcParams
556388
def apply_rcparams(self):
        
        from matplotlib import rcParams
        for key, val in self.rcParams.items():
            try:
                rcParams[key] = val
            except Exception as e:
                msg = ("""Setting "mpl.rcParams['{}']={}" """
                       "raised an Exception: {}")
                raise PlotnineError(msg.format(key, val, e))
619293
def set_parameter(self, name, values, group_id=None):
        
        if not isinstance(values, list):
            values = [values]
        if group_id is None:
            self.params.append({'name': name, 'values': values})
        else:
            self.params.append({'name': name, 'groupId': group_id, 'values': values})
1131286
def set( self, params ):
        """"""
        if self._parameters is not None:
            self.deconfigure()
        self.configure(params)
        return self
412974
def set_current_stim_parameter(self, param, val):
        
        component = self._stimulus.component(0,1)
        component.set(param, val)
670641
def set_rcParams_scanpy(fontsize=14, color_map=None, frameon=None):
    """"""

    # dpi options
    rcParams['figure.dpi'] = 100
    rcParams['savefig.dpi'] = 150

    # figure
    rcParams['figure.figsize'] = (4, 4)
    rcParams['figure.subplot.left'] = 0.18
    rcParams['figure.subplot.right'] = 0.96
    rcParams['figure.subplot.bottom'] = 0.15
    rcParams['figure.subplot.top'] = 0.91

    rcParams['lines.linewidth'] = 1.5  # the line width of the frame
    rcParams['lines.markersize'] = 6
    rcParams['lines.markeredgewidth'] = 1

    # font
    rcParams['font.sans-serif'] = [
        'Arial', 'Helvetica', 'DejaVu Sans',
        'Bitstream Vera Sans', 'sans-serif']

    fontsize = fontsize
    labelsize = 0.92 * fontsize

    rcParams['font.size'] = fontsize
    rcParams['legend.fontsize'] = labelsize
    rcParams['axes.titlesize'] = fontsize
    rcParams['axes.labelsize'] = fontsize

    # legend
    rcParams['legend.numpoints'] = 1
    rcParams['legend.scatterpoints'] = 1
    rcParams['legend.handlelength'] = 0.5
    rcParams['legend.handletextpad'] = 0.4

    # color cycle
    rcParams['axes.prop_cycle'] = cycler(color=vega_20)

    # lines
    rcParams['axes.linewidth'] = 0.8
    rcParams['axes.edgecolor'] = 'black'
    rcParams['axes.facecolor'] = 'white'

    # ticks
    rcParams['xtick.color'] = 'k'
    rcParams['ytick.color'] = 'k'
    rcParams['xtick.labelsize'] = fontsize
    rcParams['ytick.labelsize'] = fontsize

    # axes grid
    rcParams['axes.grid'] = True
    rcParams['grid.color'] = '.8'

    # color map
    rcParams['image.cmap'] = rcParams['image.cmap'] if color_map is None else color_map

    # frame
    frameon = True if frameon is None else frameon
    global _frameon
    _frameon = frameon
1260612
def setup_parameters(self):
        """"""
        t = self.template
        parameters = self.get_parameter_definitions()

        if not parameters:
            logger.debug("No parameters defined.")
            return

        for name, attrs in parameters.items():
            p = build_parameter(name, attrs)
            t.add_parameter(p)
1335210
def _initParams(self):
         
         params = SP.zeros(self.getNumberParams())
         self.setParams(params)
1238049
def set_primary_parameters(self, **kwargs):
        """"""
        given = sorted(kwargs.keys())
        required = sorted(self._PRIMARY_PARAMETERS)
        if given == required:
            for (key, value) in kwargs.items():
                setattr(self, key, value)
        else:
            raise ValueError(
                'When passing primary parameter values as initialization '
                'arguments of the instantaneous unit hydrograph class `%s`, '
                'or when using method `set_primary_parameters, one has to '
                'to define all values at once via keyword arguments.  '
                'But instead of the primary parameter names `%s` the '
                'following keywords were given: %s.'
                % (objecttools.classname(self),
                   ', '.join(required), ', '.join(given)))
71759
def _set_params(self, x):
        """"""
        assert x.size == self.num_params
        self.varianceU = x[0]
        self.varianceY = x[1]
        self.lengthscaleU = x[2]
        self.lengthscaleY = x[3]
126314
private void setParam(ArrayItemOptions<IntegerItemOptions> arrayParam,
			ContainmentEnum containmentEnumParam, String stringParam, LiteralOption selector)
	{
		this.arrayParam = arrayParam;
		this.containmentEnumParam = containmentEnumParam;
		this.stringParam = stringParam;
		this.selector = selector;
	}
107525
@Override
    public void setParameters(Object[] params) throws CDKException {
        if (params.length != 1) throw new CDKException("ElementRule expects one parameters");

        if (!(params[0] == null || params[0] instanceof MolecularFormulaRange))
            throw new CDKException("The parameter must be of type MolecularFormulaExpand");

        mfRange = (MolecularFormulaRange) params[0];
    }
428830
public void setParameters(ICalParameters parameters) {
		if (parameters == null) {
			throw new NullPointerException(Messages.INSTANCE.getExceptionMessage(16));
		}
		this.parameters = parameters;
	}
896840
def set_params(self, arg_params, aux_params):
        

        for texec in self.execgrp.train_execs:
            texec.copy_params_from(arg_params, aux_params)
885267
def setParams(self, bend_length, bend_field, drift_length, gamma):
        
        if None in (bend_length, bend_field, drift_length, gamma):
            print("warning: 'bend_length', 'bend_field', 'drift_length', 'gamma' should be positive float numbers.")
            self.mflag = False
        else:
            self._setDriftList(drift_length)
            self.gamma = gamma
            self.bend_length = bend_length
            self.bend_field = bend_field
265749
public void setParametersVariables() {
    hasInOutParameters = false;
    for (CallParameter param : params) {
      if (param != null && param.isOutput() && param.isInput()) {
        hasInOutParameters = true;
        break;
      }
    }
  }
342759
final public function __setParams()
    {
        // $this->class
        $this->class = new \ReflectionClass($this);

        // $this->classAcf
        if (class_exists('Acf')) {
            $this->classAcf = new Acf();
        }

        // $this->template
        if (!$this->template) {
            $this->template = Utils::convertToKebabCase($this->class->getShortName());
        }

        // $this->tree
        if ($this->class->implementsInterface('\Sober\Controller\Module\Tree')) {
            $this->tree = true;
        }
    }
705287
def setRandomParams(self):
        
        params = sp.randn(self.getNumberParams())
        self.setParams(params)