Get the Evalution sum.
960018
def app_evaluation_count(app_id, value=1):
        '''
        
        '''
        return TabEvaluation.select().where(
            (TabEvaluation.post_id == app_id) & (TabEvaluation.value == value)
        ).count()
821335
def evaluator(self, candidates, args):
        """"""
        fitness = []
        if self._use_ants:
            for candidate in candidates:
                total = 0
                for c in candidate:
                    total += self.weights[c.element[0]][c.element[1]]
                last = (candidate[-1].element[1], candidate[0].element[0])
                total += self.weights[last[0]][last[1]]
                fitness.append(1 / total)
        else:
            for candidate in candidates:
                total = 0
                for src, dst in zip(candidate, candidate[1:] + [candidate[0]]):
                    total += self.weights[src][dst]
                fitness.append(1 / total)
        return fitness
196053
def eval(self):
        
        Expr.ignore = False
        result = self.try_eval()
        Expr.ignore = True

        return result
1162826
def evaluate(self, **kwargs):
        
        self._eval_points = kwargs.get('points', self._init_array())
        self._dimension = len(self._eval_points[0])
1069071
def do_sum(self, count=1):
        '''
        '''
        if not self.roll.summable:
            return 0
        self.sum = sum(self.roll.roll(count))
        self.avr = self.sum / count
        return self.sum
1050267
def _format_eval_result(value, show_stdv=True):
    """"""
    if len(value) == 4:
        return '%s\'s %s: %g' % (value[0], value[1], value[2])
    elif len(value) == 5:
        if show_stdv:
            return '%s\'s %s: %g + %g' % (value[0], value[1], value[2], value[4])
        else:
            return '%s\'s %s: %g' % (value[0], value[1], value[2])
    else:
        raise ValueError("Wrong metric value")
554900
def get_total_paid(self) -> Decimal:
        
        query = (
            self.get_splits_query()
        )
        splits = query.all()

        total = Decimal(0)
        for split in splits:
            total += split.value

        return total
1145255
def avg(self):
        """"""
        # XXX rename this method
        if len(self.values) > 0:
            return sum(self.values) / float(len(self.values))
        else:
            return None
44741
public double getAverage() {
        if (!DATA_LIST.isEmpty()) {
            double sum = 0;
            for (DataPoint dataPoint : DATA_LIST) {
                sum += dataPoint.getValue();
            }
            return sum / DATA_LIST.size();
        }
        return 0;
    }
118501
def total_vat(self):
        """"""
        q = Vat.objects.filter(receipt=self).aggregate(total=Sum('amount'))
        return q['total'] or 0
54670
def score(self):
        
        if not self.scoreProperties:
            self.scoreProperties = self.getScoreProperties()
        return sum(self.scoreProperties.values())
1351056
def evaluate(self, verbose=False, decode=True, passes=None, num_threads=1, apply_experimental=True):
        
        evaluated_data = super(Index, self).evaluate(verbose, decode, passes, num_threads, apply_experimental)

        return Index(evaluated_data, self.dtype, self.name)
667269
public final String evalPropVal(final LinkedProperties pProperties,
    final String pPropName) {
    String result = pProperties.getProperty(pPropName);
    if (constNull().equals(result)) {
      return null;
    }
    return result;
  }
1213038
def evaluate(self, truth, predicted):
        
        correct = 0.0
        total = 0.0
        for i in range(len(truth)):
            if(truth[i] == predicted[i]):
                correct += 1
            total += 1
        return 1.0*correct/total
202441
public double evalG(BinarySolution solution) {
    double res = 0.0;
    for (int i = 1; i < solution.getNumberOfVariables(); i++) {
      res += evalV(u(solution.getVariableValue(i)));
    }

    return res;
  }
904440
def compute_amount(self):
        """"""
        self.amount = self.base_amount * self.aliquot / 100
        return self.amount
654020
def _eval_func(self, x):
        
        cost_evals = []
        f_evals     = np.empty(shape=[0, 1])

        for i in range(x.shape[0]):
            st_time    = time.time()
            rlt = self.func(np.atleast_2d(x[i]))
            f_evals     = np.vstack([f_evals,rlt])
            cost_evals += [time.time()-st_time]
        return f_evals, cost_evals