Deopts the evaluation
423196
function deopt(path, state) {
  if (!state.confident) return;
  state.deoptPath = path;
  state.confident = false;
}
386422
def _eval_binop(self, node):
        
        return self.operators[type(node.op)](self._eval(node.left),
                                             self._eval(node.right))
114090
def _eval(self, v, in_bounds, der):
        """"""
        result = np.zeros_like(v, dtype='float')
        x_indices = np.searchsorted(self._x, v, side='rigth')
        ids = x_indices[in_bounds] - 1
        u = v[in_bounds] - self._x[ids]
        result[in_bounds] = self._poly_eval(u, ids, der)
        return result
412187
def evaluate(self):
        """"""

        if self.opt['AccurateDFid']:
            if self.dmethod == 'fista':
                D = self.dstep.getdict(crop=False)
            else:
                D = self.dstep.var_y()
            if self.xmethod == 'fista':
                X = self.xstep.getcoef()
            else:
                X = self.xstep.var_y()
            Df = sl.rfftn(D, self.xstep.cri.Nv, self.xstep.cri.axisN)
            Xf = sl.rfftn(X, self.xstep.cri.Nv, self.xstep.cri.axisN)
            Sf = self.xstep.Sf
            Ef = sl.inner(Df, Xf, axis=self.xstep.cri.axisM) - Sf
            dfd = sl.rfl2norm2(Ef, self.xstep.S.shape,
                               axis=self.xstep.cri.axisN) / 2.0
            rl1 = np.sum(np.abs(X))
            return dict(DFid=dfd, RegL1=rl1,
                        ObjFun=dfd + self.xstep.lmbda * rl1)
        else:
            return None
1244298
function shouldDeoptBasedOnScope(binding, refPath) {
  if (binding.scope.path.isProgram() && refPath.scope !== binding.scope) {
    return true;
  }
  return false;
}
781024
def evaluate(instance, *args, &block)
      cleanroom.new(instance).instance_eval(*args, &block)
    end
671478
def protoFast():
    
    r, x = blind(m)
    y,kw,tTilde = eval(w,t,x,msk,s)
    z = deblind(r, y)
589430
def evaluate(
    model,
    data_path,
    gpu_id=-1,
    gold_preproc=False,
    displacy_path=None,
    displacy_limit=25,
    return_scores=False,
):
    
    msg = Printer()
    util.fix_random_seed()
    if gpu_id >= 0:
        util.use_gpu(gpu_id)
    util.set_env_log(False)
    data_path = util.ensure_path(data_path)
    displacy_path = util.ensure_path(displacy_path)
    if not data_path.exists():
        msg.fail("Evaluation data not found", data_path, exits=1)
    if displacy_path and not displacy_path.exists():
        msg.fail("Visualization output directory not found", displacy_path, exits=1)
    corpus = GoldCorpus(data_path, data_path)
    nlp = util.load_model(model)
    dev_docs = list(corpus.dev_docs(nlp, gold_preproc=gold_preproc))
    begin = timer()
    scorer = nlp.evaluate(dev_docs, verbose=False)
    end = timer()
    nwords = sum(len(doc_gold[0]) for doc_gold in dev_docs)
    results = {
        "Time": "%.2f s" % (end - begin),
        "Words": nwords,
        "Words/s": "%.0f" % (nwords / (end - begin)),
        "TOK": "%.2f" % scorer.token_acc,
        "POS": "%.2f" % scorer.tags_acc,
        "UAS": "%.2f" % scorer.uas,
        "LAS": "%.2f" % scorer.las,
        "NER P": "%.2f" % scorer.ents_p,
        "NER R": "%.2f" % scorer.ents_r,
        "NER F": "%.2f" % scorer.ents_f,
    }
    msg.table(results, title="Results")

    if displacy_path:
        docs, golds = zip(*dev_docs)
        render_deps = "parser" in nlp.meta.get("pipeline", [])
        render_ents = "ner" in nlp.meta.get("pipeline", [])
        render_parses(
            docs,
            displacy_path,
            model_name=model,
            limit=displacy_limit,
            deps=render_deps,
            ents=render_ents,
        )
        msg.good("Generated {} parses as HTML".format(displacy_limit), displacy_path)
    if return_scores:
        return scorer.scores
728222
def _evaluate_cut(transition, cut, unpartitioned_account,
                  direction=Direction.BIDIRECTIONAL):
    """"""
    cut_transition = transition.apply_cut(cut)
    partitioned_account = account(cut_transition, direction)

    log.debug("Finished evaluating %s.", cut)
    alpha = account_distance(unpartitioned_account, partitioned_account)

    return AcSystemIrreducibilityAnalysis(
        alpha=round(alpha, config.PRECISION),
        direction=direction,
        account=unpartitioned_account,
        partitioned_account=partitioned_account,
        transition=transition,
        cut=cut)
177216
def _runOPF(self):
        
        if self.decommit:
            solver = UDOPF(self.case, dc=(self.locationalAdjustment == "dc"))
        elif self.locationalAdjustment == "dc":
            solver = OPF(self.case, dc=True)
        else:
            solver = OPF(self.case, dc=False, opt={"verbose": True})

        self._solution = solver.solve()

#        for ob in self.offers + self.bids:
#            ob.f = solution["f"]

        return self._solution["converged"]
1369154
def dnde(self, x, params=None):
        """"""
        params = self.params if params is None else params
        return np.squeeze(self.eval_dnde(x, params, self.scale,
                                         self.extra_params))
416536
def continuous_eval(self):
    """"""
    for ckpt_path in next_checkpoint(self._hparams.model_dir,
                                     self._hparams.eval_timeout_mins):
      # Skip zero'th step.
      train_step = decoding.get_step_from_ckpt_path(ckpt_path)
      if train_step == 0:
        tf.logging.info("Skipping evaluation at step 0")
        continue
      self.evaluate()
493738
def evaluate(actual)
      warn "any is deprecated; please use asserts.empty or denies.empty instead"
      any?(actual) ? pass("has items") : fail(expected_message(actual).to_have_items)
    end
908395
def evalall(self, loc=None, defaults=None):
        
        self.check()
        if defaults is None:
            defaults = cma_default_options
        # TODO: this needs rather the parameter N instead of loc
        if 'N' in loc:  # TODO: __init__ of CMA can be simplified
            popsize = self('popsize', defaults['popsize'], loc)
            for k in list(self.keys()):
                k = self.corrected_key(k)
                self.eval(k, defaults[k],
                          {'N':loc['N'], 'popsize':popsize})
        self._lock_setting = True
        return self
487108
def eval_proxop(self, V):
        """"""

        return np.asarray(sp.prox_l1(V, (self.lmbda / self.L) * self.wl1),
                          dtype=self.dtype)
780819
function normaliseDeps (deps) {
  if (Array.isArray(deps)) {
    deps = deps.reduce(function (d, depName) {
      d[depName] = '*'
      return d
    }, {})
  }
  return deps
}
6473
def evaluate_severities(data)
        @output[:lint_warnings] = []
        @output[:lint_errors] = []
        @output[:lint_conventions] = []
        @output[:lint_refactors] = []
        @output[:lint_fatals] = []

        return if data.blank?

        data.each do |filename, error_list|
          error_list.each do |message|
            # so that :raw_data remains unaffected
            message = message.clone
            message.delete('length')
            message['filename'] = filename.nil? ? '' : strip_working_dir(filename)
            severity = "lint_#{message['severity']}s".to_sym
            message.delete('severity')
            @output[severity] << message if @output.key?(severity)
          end
        end
        @output
      end