MEAN // 
FUNCTION: mean( x, y )
Returns the arithmetic mean of `|x|` and `|y|`.

@param {Number} x - first number
@param {Number} y - second number
@returns {Number} arithmetic mean
352894
function mean( x, y ) {
	x = abs( x );
	y = abs( y );
	return x + (y-x)/2.0;
}
328482
function() {
			// Get the x and y coordinates
			var xCoords = this.pluck('x');
			var yCoords = this.pluck('y');

			// Get the means for the x and y coordinates
			var meanX = xCoords.mean();
			var meanY = yCoords.mean();

			// Get the standard deviations for the x and y coordinates
			var stdDevX = xCoords.stdDev();
			var stdDevY = yCoords.stdDev();

			// Calculate the correlation coefficient
			var r = this.r();

			// Calculate the slope
			var slope = r * (stdDevY / stdDevX);

			// Calculate the y-intercept
			var yIntercept = meanY - slope * meanX;

			return {
				slope: slope,
				yIntercept: yIntercept,
				r: r
			};
		}
561467
public BiFunction<Integer, Integer, Short> mean() {
        return (a, b) -> (short) Math.min(Math.round(1.0f * a / b), 255);
    }
1208519
def calc_mean(c0, c1=[]):
    
    if c1 != []:
        return (numpy.mean(c0, 0) + numpy.mean(c1, 0)) / 2.
    else:
        return numpy.mean(c0, 0)
894390
function variance(values) {
	let avg = mean(values);
	return mean(values.map((e) => Math.pow(e - avg, 2)));
}
235403
func (x Vector) Mean() float64 {
	s := x.Sum()

	n := float64(len(x))

	return s / n
}
845505
func Mean(series []float64) float64 {
	var n, x, sum float64
	for _, x = range series {
		sum += x
		n++
	}
	return sum / n
}
974265
def _compute_mean(self, C, mag, rrup):
        
        mean = (C['c1'] +
                self._compute_term1(C, mag) +
                self._compute_term2(C, mag, rrup) +
                self._compute_term3(C, rrup))
        return mean
818840
def calc_mean_std(c0, c1=[], nonStdZero=False):
    
    mi = calc_mean(c0, c1)
    std = calc_std(c0, c1)
    if (nonStdZero):
        std[std == 0] = 1

    return mi, std
632540
function x_to_y2 (t, y2, x) {
        sqr(t, x);
        mul_small(y2, x, 486662);
        add(t, t, y2);
        add(t, t, C1);
        mul(y2, t, x);
    }
858220
def mean(data):
    """"""
    #: http://stackoverflow.com/a/27758326
    n = len(data)
    if n < 1:
        raise ValueError('mean requires at least one data point')
    return sum(data)/n
421715
def mean(attrs, inputs, proto_obj):
    """"""
    concat_input = [symbol.expand_dims(op_input, axis=0) for op_input in inputs]
    concat_sym = symbol.concat(*concat_input, dim=0)
    mean_sym = symbol.mean(concat_sym, axis=0)
    return mean_sym, attrs, inputs
833535
function mean(x) {
	let result = [];
	
	for(let c = 0; c<x[0].length; c++){
		result.push(0);
	}
	
	for (let r = 0; r < x.length; r++) {
		for(let c = 0; c<x[r].length; c++){
			result[c] += x[r][c];
		}
	}
	
	for(let c = 0; c<x[0].length; c++){
		result[c] /= x.length;
	}
	
	return result;
}
275043
def _compute_mean(self, C, A1, A2, A3, A4, A5, A6, mag, hypo_depth,
                      rrup, mean, idx):
        
        mean[idx] = (A1 + A2 * mag + C['C1'] + C['C2'] * (A3 - mag) ** 3 +
                     C['C3'] * np.log(rrup[idx] + A4 * np.exp(A5 * mag)) +
                     A6 * hypo_depth)
876930
public static double mean(Collection<? extends Number> values) {
        double sum = 0d;
        for (Number n : values)
            sum += n.doubleValue();
        return sum / values.size();
    }
1335918
function f(x,y,z) {
  return x*x + y*y + z*z - 2.0
}
1085985
def _compute_mean(self, C, mag, r):
        
        mean = (C['c1'] +
                self._compute_term1(C, mag) +
                self._compute_term2(C, mag, r))
        return mean