Experimental, use at your own peril.
546356
def batch_call(self, calls):
        """"""
        req = self.protocol.create_batch_request()

        for call_args in calls:
            req.append(self.protocol.create_request(*call_args))

        return self._send_and_handle_reply(req)
285084
def _exploit(self, trial_executor, trial, trial_to_clone):
        """"""

        trial_state = self._trial_state[trial]
        new_state = self._trial_state[trial_to_clone]
        if not new_state.last_checkpoint:
            logger.info("[pbt]: no checkpoint for trial."
                        " Skip exploit for Trial {}".format(trial))
            return
        new_config = explore(trial_to_clone.config, self._hyperparam_mutations,
                             self._resample_probability,
                             self._custom_explore_fn)
        logger.info("[exploit] transferring weights from trial "
                    "{} (score {}) -> {} (score {})".format(
                        trial_to_clone, new_state.last_score, trial,
                        trial_state.last_score))

        if self._log_config:
            self._log_config_on_step(trial_state, new_state, trial,
                                     trial_to_clone, new_config)

        new_tag = make_experiment_tag(trial_state.orig_tag, new_config,
                                      self._hyperparam_mutations)
        reset_successful = trial_executor.reset_trial(trial, new_config,
                                                      new_tag)
        if reset_successful:
            trial_executor.restore(
                trial, Checkpoint.from_object(new_state.last_checkpoint))
        else:
            trial_executor.stop_trial(trial, stop_logger=False)
            trial.config = new_config
            trial.experiment_tag = new_tag
            trial_executor.start_trial(
                trial, Checkpoint.from_object(new_state.last_checkpoint))

        self._num_perturbations += 1
        # Transfer over the last perturbation time as well
        trial_state.last_perturbation_time = new_state.last_perturbation_time
542450
def add_experiment(experiment):
    """"""
    redis = oz.redis.create_connection()
    oz.bandit.add_experiment(redis, experiment)
1325138
def bandit_simple_convert!(exp, alt, count=1)
      Bandit.get_experiment(exp).convert!(alt, count)
    end
1086163
def delete_experiment(self):
        '''
        '''
        logger.info('delete experiment "%s"', self.experiment_name)
        url = self._build_api_url(
            '/experiments/{experiment_id}'.format(
                experiment_id=self._experiment_id
            )
        )
        res = self._session.delete(url)
        res.raise_for_status()
        del self.__experiment_id
982555
public function destroy()
    {
        if ($this->instance instanceof \Phavour\Session\Storage) {
            $this->instance->destroy();
        }
        $this->instance = null;
    }
610224
def experiment(self):
        """"""
        if self._experiment is None:
            self._experiment = list(self.config.experiments.keys())[-1]
        return self._experiment
1145998
def experimental(name=None):
    """"""
    def inner(func):
        @functools.wraps(func)
        def wrapper(*fargs, **kw):
            fname = name
            if name is None:
                fname = func.__name__
            warnings.warn("%s" % fname, category=ExperimentalWarning,
                          stacklevel=2)
            return func(*fargs, **kw)
        return wrapper
    return inner
38361
public function fire()
    {
        $this->info('Generating optimized autoload components.');

        if ($component = $this->argument('component')) {
            $this->dump($component);
        } else {
            foreach ($this->laravel['components']->all() as $component) {
                $this->dump($component->getStudlyName());
            }
        }
    }
1324758
def puke(klass, meth, err)
      case err
      when MiniTest::Skip
        @turn_test.skip!(err)
        turn_reporter.skip(err)
      when MiniTest::Assertion
        @turn_test.fail!(err)
        turn_reporter.fail(err)
      else
        @turn_test.error!(err)
        turn_reporter.error(err)
      end
      super(klass, meth, err)
    end
381197
public function fire()
    {
        try {
            if ($name = $this->argument('component')) {
                $name = Str::studly($name);
                $this->componentSeed($this->getComponentByName($name));
            } else {
                $components = $this->getComponentRepository()->getOrdered();
                array_walk($components, [$this, 'componentSeed']);
                $this->info('All components seeded.');
            }
        } catch (\Exception $e) {
            $this->error($e->getMessage());
        }
    }
1135121
def abort():
    """"""
    a = TpPd(pd=0x5)
    b = MessageType(mesType=0x29)  # 00101001
    c = RejectCause()
    packet = a / b / c
    return packet
187281
def __experimental_range(start, stop, var, cond, loc={}):
    '''
    '''
    locals().update(loc)
    if start < stop:
        for __ in range(start, stop):
            locals()[var] = __
            if eval(cond, globals(), locals()):
                yield __
    else:
        for __ in range(start, stop, -1):
            locals()[var] = __
            if eval(cond, globals(), locals()):
                yield __
159119
def fail(self, message, param=None, ctx=None):
        """"""
        raise BadParameter(message, ctx=ctx, param=param)
644304
@Override
   public double error(){
        errorForEachExperimentalData.clear();
        double error =0;
        for (ExperimentalData pair: experimental){
            double temperature = pair.getTemperature();
            substance.setTemperature(temperature);
            substance.dewPressure(substance.getPressure());
            double expP = pair.getPressure();
            double calcP = substance.getPressure();
            double relativeError = (calcP - expP)/expP;
            double squareError = Math.pow(relativeError,2);
            
            
            if(!Double.isNaN(squareError) && Double.isFinite(squareError)){
	            error += squareError;
	            errorForEachExperimentalData.add(new ErrorData(expP, calcP, relativeError,temperature));
            }
        }   
        totalError = error;
        return error;   
   }
324719
public void destroy()
    {
        if (_bufferedOut!=null)
            _bufferedOut.destroy();
        _bufferedOut=null;
        if (_iso8859writer!=null)
            _iso8859writer.destroy();
        _iso8859writer=null;
        if (_utf8writer!=null)
            _utf8writer.destroy();
        _utf8writer=null;
        if (_asciiwriter!=null)
            _asciiwriter.destroy();
        _asciiwriter=null;
    }
102929
function () {
        this.components.length = 0;
        this.components = null;
        OpenLayers.Geometry.prototype.destroy.apply(this, arguments);
    }