Evaluates the objective
482256
def evaluate_objective(self):
        
        self.Y_new, cost_new = self.objective.evaluate(self.suggested_sample)
        self.cost.update_cost_model(self.suggested_sample, cost_new)
        self.Y = np.vstack((self.Y,self.Y_new))
1047253
public void evaluate(DoubleSolution solution) {
    double[] f = new double[getNumberOfObjectives()];
    double value = solution.getVariableValue(0) ;

    f[0] = value * value;
    f[1] = (value - 2.0) * (value - 2.0);

    solution.setObjective(0, f[0]);
    solution.setObjective(1, f[1]);
  }
1284678
def evaluate(actual)
      actual.empty? ? pass(new_message.is_empty) : fail(expected_message(actual).to_be_empty)
    end
816103
private Object eval(ExpressionContext expr) {
    Object res = expr;
    while(res instanceof ExpressionContext)
      res = ((ExpressionContext)res).accept(visitor);
    if(res instanceof LValue)
      res = ((LValue) res).get(expr);
    return res;
  }
659232
def run_evaluate(self, *args, **kwargs) -> None:
        
        if self._needs_evaluation:
            for _, item in self._nested_items.items():
                item.run_evaluate()
1202176
def evaluate(actual, expected)
      if actual.respond_to?(expected)
        pass(new_message.responds_to(expected))
      else
        fail(expected_message.method(expected).is_not_defined)
      end
    end
452204
@Override
  public void evaluate(DoubleSolution solution) {
    int numberOfVariables = getNumberOfVariables() ;

    double[] x = new double[numberOfVariables] ;

    for (int i = 0; i < numberOfVariables; i++) {
      x[i] = solution.getVariableValue(i) ;
    }

    double sum = 0.0 ;
    for (int var = 0; var < numberOfVariables; var++) {
      double value = x[var];
      sum += value * value;
    }

    solution.setObjective(0, sum);
  }
1017114
private void evaluateObject() {
        if (evaluatedClasses.contains(clazz)) {
            return;
        }

        Field[] fields = clazz.getDeclaredFields();

        for (Field field : fields) {
            if (field.isAnnotationPresent(ModelField.class)
            && !isAllowed(field)) {
                throw new RuntimeException("Field '"
                        + field.getName()
                        + "' has type '" + field.getType().getSimpleName()
                        + "' that is not allowed!");
            }
        }

        evaluatedClasses.add(clazz);
    }
1069101
public Object evaluate()
  {
    if( !isCompileTimeConstant() )
    {
      return super.evaluate();
    }

    return (Boolean)getLHS().evaluate() || (Boolean)getRHS().evaluate();
  }
1247381
public void evaluate(DoubleSolution solution) {
    List<Double> x = new ArrayList<Double>(getNumberOfVariables());
    List<Double> y = new ArrayList<Double>(getNumberOfObjectives());

    for (int i = 0; i < getNumberOfVariables(); i++) {
      x.add(solution.getVariableValue(i));
      y.add(0.0);
    }

    lz09.objective(x, y);

    for (int i = 0; i < getNumberOfObjectives(); i++) {
      solution.setObjective(i, y.get(i));
    }
  }
580272
def objectives(self, rank):
        
        self._check_rank(rank)
        return [result.obj for result in self.results[rank]]
84665
function evaluate(config) {
  const _config = _parseConfig(config);
  const options = _createOptions(_config);
  return _runScript(_config, options);
}
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
708437
def evaluate(self, model):
        """"""
        with model:
            if self.medium is not None:
                self.medium.apply(model)
            if self.objective is not None:
                model.objective = self.objective
            model.add_cons_vars(self.constraints)
            max_val = model.slim_optimize()
            essen = single_gene_deletion(
                model, gene_list=self.data["gene"], processes=1)
        essen["gene"] = [list(g)[0] for g in essen.index]
        essen.index = essen["gene"]
        essen["essential"] = (essen["growth"] < (max_val * 0.1)) \
            | essen["growth"].isna()
        return essen
18071
def get_objective(self, sampler):
        """"""
        def objective(params):
            circuit = self.get_circuit(params)
            circuit.make_cache()
            return self.get_energy(circuit, sampler)
        return objective
781024
def evaluate(instance, *args, &block)
      cleanroom.new(instance).instance_eval(*args, &block)
    end
303440
def run_objective(objective, _name, raw_output, output_files, threads)
      # output is a, array: [raw_output, output_files].
      # output_files is a hash containing the absolute paths
      # to file(s) output by the target in the format expected by the
      # objective function(s), with keys as the keys expected by the
      # objective function
      return objective.run(raw_output, output_files, threads)
    end