Calculate the cost function associated to the composed function

        Returns
        -------
        float the cost of the associated composed function
346814
def _cost_method(self, *args, **kwargs):
        
        return self.prox_op.cost(self.linear_op.op(args[0]), **kwargs)
767547
def getDebt(self):
        
        debt = float(self['principalBalance']) + float(self['interestBalance'])
        debt += float(self['feesBalance']) + float(self['penaltyBalance'])

        return debt
1164361
def _cost_method(self, *args, **kwargs):
        

        return np.sum([operator.cost(data) for operator, data in
                       zip(self.operators, args[0])])
1290265
def getTotalPrice(self):
        
        price = self.getPrice()
        vat = self.getVAT()
        price = price and price or 0
        vat = vat and vat or 0
        return float(price) + (float(price) * float(vat)) / 100
636783
void compute_Rv() {
		double t = Math.sqrt(v1*v1 + v2*v2);
		double s = Math.sqrt(t*t + 1);
		double cosT = 1.0/s;
		double sinT = Math.sqrt(1-1.0/(s*s));

		K_x.data[0] = 0;   K_x.data[1] = 0;   K_x.data[2] = v1;
		K_x.data[3] = 0;   K_x.data[4] = 0;   K_x.data[5] = v2;
		K_x.data[6] = -v1; K_x.data[7] = -v2; K_x.data[8] = 0;
		CommonOps_DDRM.divide(K_x,t);
		CommonOps_DDRM.setIdentity(R_v);
		CommonOps_DDRM.addEquals(R_v,sinT,K_x);
		CommonOps_DDRM.multAdd(1.0-cosT,K_x,K_x,R_v);
	}
1133737
def _sum_wrapper(fn):
    

    def wrapper(*args, **kwargs):
        v = 0
        new_args = _cast_args_to_list(args)
        for arg in zip(*new_args):
            v += fn(*arg, **kwargs)
        return v

    return wrapper
82121
def get_float(self, key, optional=False):
        
        return self._get_typed_value(key, float, lambda x: float(x), optional)
856907
def compose_functions(*func_list):
    
    def apply_composition(f, g):
        def compose(x):
            return f(g(x))
        return compose
    composed_func = functools.reduce(apply_composition, func_list)
    return composed_func
355220
def compose(*decorators):
    
    def composed(f):
        for decor in reversed(decorators):
            f = decor(f)
        return f
    return composed
106281
def get_cost_per_kg(self, comp):
        
        comp = comp if isinstance(comp, Composition) else Composition(comp)
        return self.get_cost_per_mol(comp) / (
            comp.weight.to("kg") * const.N_A)
1116510
def get(self):
        
        if self.num_inst == 0:
            return (self.name, float('nan'))
        else:
            return (self.name, self.sum_metric / self.num_inst)
286502
def getBottomLeft(self):
        
        return (float(self.get_cx()) - float(self.get_rx()), float(self.get_cy()) - float(self.get_ry()))
1249498
def cost(a,b,c,e,f,p_min,p):
    
    return a + b*p + c*p*p + abs(e*math.sin(f*(p_min-p)))
1222827
def accumulate_impl(func, sequence):
    # pylint: disable=no-name-in-module
    
    if six.PY3:
        from itertools import accumulate
        return accumulate(sequence, func)
    else:
        return _accumulate(sequence, func)
200451
public double computeAverage (Function<Triple<GeneralDataset<L, F>,GeneralDataset<L, F>,SavedState>,Double> function) 
  {
    double sum = 0;
    Iterator<Triple<GeneralDataset<L, F>,GeneralDataset<L, F>,SavedState>> foldIt = iterator();
    while (foldIt.hasNext()) {
      sum += function.apply(foldIt.next());
    }
    return sum / kfold;
  }
461924
def getVATAmount(self):
        
        price, vat = self.getAnalysisProfilePrice(), self.getAnalysisProfileVAT()
        return float(price) * float(vat) / 100
8374
def getVATAmount(self):
        
        price, vat = self.getPrice(), self.getVAT()
        return float(price) * (float(vat) / 100)