Returns the result of adding the argument to the vector
353622
function(value) {
            	var V = value.elements || value;

            	if (this.elements.length != V.length) 
            	    return this.map(function(v) { return v + value });
            	else
            	    return this.map(function(x, i) { return x + V[i - 1]; });
                }
888719
function() {
			var i, args = arguments[0] instanceof $.Vector ? arguments[0].array : $.makeArray(arguments),
				arr = this.array.slice(0),
				vec = new $.Vector();
			for ( i = 0; i < args.length; i++ ) {
				if ( arr[i] != args[i] ) {
					return null;
				}
			}
			return vec.update(arr);
		}
1017870
public IntLongSortedVector getSum(IntLongVector other) {
        IntLongSortedVector sum = new IntLongSortedVector(this);
        sum.add(other);
        return sum;
    }
1152769
def generic_add(a, b):
    print
    """"""
    logger.info('Called generic_add({}, {})'.format(a, b))
    return a + b
456373
public Vector3i add(Vector3ic v, Vector3i dest) {
        dest.x = x + v.x();
        dest.y = y + v.y();
        dest.z = z + v.z();
        return dest;
    }
713430
public Vector4f add(float x, float y, float z, float w, Vector4f dest) {
        dest.x = this.x + x;
        dest.y = this.y + y;
        dest.z = this.z + z;
        dest.w = this.w + w;
        return dest;
    }
310120
def add_vectors(vec_a, vec_b, periodic):
    '''

    '''
    moved = noperiodic(np.array([vec_a, vec_b]), periodic)
    return vec_a + vec_b
1137686
def add(self, *args, **kwargs):
        
        return self._apply(operator.add, *args, **kwargs)
424789
function() {
                var A = this.start.elements, B = this.end.elements;
                return vector.create([B[0] - A[0], B[1] - A[1], B[2] - A[2]]);
              }
229770
def +(rhs)
      Util3D.check_arg_type(Quat, rhs)
      t1 = Vector3.new(self.x, self.y, self.z)
      t2 = Vector3.new(rhs.x, rhs.y, rhs.z)
      dot = t1.dot(t2)
      t3 = t2.cross(t1)

      t1 *= rhs.w
      t2 *= self.w

      tf = t1 + t2 + t3
      rtn_w = self.w * rhs.w - dot

      return Quat.new(tf.x, tf.y, tf.z, rtn_w)
    end
888311
public static double[] cumsum (double[] vector) {
        // Initialize the return value:
        final double[] retval = new double[vector.length];

        // Iterate and cumulate:
        retval[0] = vector[0];
        for (int i = 1; i < retval.length; i++) {
            retval[i] = vector[i] + retval[i - 1];
        }

        // Done, return:
        return retval;
    }
747027
def reduce(vector):
        
        if type(vector) is list: # matrix
            return array(list(map(add.reduce, vector)))
        else:
            return sum(vector)
1129602
public IntDoubleSortedVector getSum(IntDoubleVector other) {
        IntDoubleSortedVector sum = new IntDoubleSortedVector(this);
        sum.add(other);
        return sum;
    }
437661
def EndVector(self, vectorNumElems):
        """"""

        self.assertNested()
        ## @cond FLATBUFFERS_INTERNAL
        self.nested = False
        ## @endcond
        # we already made space for this, so write without PrependUint32
        self.PlaceUOffsetT(vectorNumElems)
        return self.Offset()
1252490
function create2(x, y) {
    if (typeof x === "undefined") throw new Error("At least one argument must be provided.");
    if (typeof y === "undefined") y = x;
    return new Vector([x, y]);
}
1189985
public Vector3f add(Vector3fc v, Vector3f dest) {
        dest.x = x + v.x();
        dest.y = y + v.y();
        dest.z = z + v.z();
        return dest;
    }
634446
function add() {
    var args = [];
    for (var _i = 0; _i < arguments.length; _i++) {
        args[_i] = arguments[_i];
    }
    var acc = args[0];
    for (var i = 1; i < args.length; i++) {
        acc = _add_two(acc, args[i]);
    }
    return acc;
}