Divides two vec2's

@param {vec2} out the receiving vector
@param {vec2} a the first operand
@param {vec2} b the second operand
@returns {vec2} out
509727
function divide(out, a, b) {
    out[0] = a[0] / b[0]
    out[1] = a[1] / b[1]
    return out
}
1187730
function add(out, a, b) {
  out[0] = a[0] + b[0];
  out[1] = a[1] + b[1];
  out[2] = a[2] + b[2];
  out[3] = a[3] + b[3];
  out[4] = a[4] + b[4];
  out[5] = a[5] + b[5];
  out[6] = a[6] + b[6];
  out[7] = a[7] + b[7];
  out[8] = a[8] + b[8];
  return out;
}
55842
function(a, b)
{
    return Math.abs(a.bb_l + a.bb_r - b.bb_l - b.bb_r) + Math.abs(a.bb_b + a.bb_t - b.bb_b - b.bb_t);
}
41257
public static void divide(double[] array1, double[] array2) {
        assert (array1.length == array2.length);
        for (int i=0; i<array1.length; i++) {
            array1[i] /= array2[i];
        }
    }
374400
public static void multTranA( DMatrixRMaj A , DMatrixRMaj B , DMatrixRMaj C , DMatrixRMaj output )
	{
		double t11 = A.data[0]*B.data[0] + A.data[3]*B.data[3] + A.data[6]*B.data[6];
		double t12 = A.data[0]*B.data[1] + A.data[3]*B.data[4] + A.data[6]*B.data[7];
		double t13 = A.data[0]*B.data[2] + A.data[3]*B.data[5] + A.data[6]*B.data[8];

		double t21 = A.data[1]*B.data[0] + A.data[4]*B.data[3] + A.data[7]*B.data[6];
		double t22 = A.data[1]*B.data[1] + A.data[4]*B.data[4] + A.data[7]*B.data[7];
		double t23 = A.data[1]*B.data[2] + A.data[4]*B.data[5] + A.data[7]*B.data[8];

		double t31 = A.data[2]*B.data[0] + A.data[5]*B.data[3] + A.data[8]*B.data[6];
		double t32 = A.data[2]*B.data[1] + A.data[5]*B.data[4] + A.data[8]*B.data[7];
		double t33 = A.data[2]*B.data[2] + A.data[5]*B.data[5] + A.data[8]*B.data[8];

		output.data[0] = t11*C.data[0] + t12*C.data[3] + t13*C.data[6];
		output.data[1] = t11*C.data[1] + t12*C.data[4] + t13*C.data[7];
		output.data[2] = t11*C.data[2] + t12*C.data[5] + t13*C.data[8];

		output.data[3] = t21*C.data[0] + t22*C.data[3] + t23*C.data[6];
		output.data[4] = t21*C.data[1] + t22*C.data[4] + t23*C.data[7];
		output.data[5] = t21*C.data[2] + t22*C.data[5] + t23*C.data[8];

		output.data[6] = t31*C.data[0] + t32*C.data[3] + t33*C.data[6];
		output.data[7] = t31*C.data[1] + t32*C.data[4] + t33*C.data[7];
		output.data[8] = t31*C.data[2] + t32*C.data[5] + t33*C.data[8];
	}
351298
public double[] mult(double[] vec, double[] out) {
        if (out == null || out.length != 2) {
            out = new double[2];
        }

        if (vec == out) {
            double tx = m00*vec[0] + m01*vec[1] + m02;
            double ty = m10*vec[0] + m11*vec[1] + m12;

            out[0] = tx;
            out[1] = ty;
        } else {
            out[0] = m00*vec[0] + m01*vec[1] + m02;
            out[1] = m10*vec[0] + m11*vec[1] + m12;
        }

        return out;
    }
617367
function middleInside (data, start, a, b) {
  var node = start,
    inside = false,
    px = (data[a] + data[b]) / 2,
    py = (data[a + 1] + data[b + 1]) / 2
  do {
    var p1 = node.i,
      p2 = node.next.i

    if (((data[p1 + 1] > py) !== (data[p2 + 1] > py)) &&
      (px < (data[p2] - data[p1]) * (py - data[p1 + 1]) / (data[p2 + 1] - data[p1 + 1]) + data[p1])) {
      inside = !inside
    }

    node = node.next
  } while (node !== start)

  return inside
}
793538
function add(a, b){
    return Vector3(a.x+b.x, a.y+b.y, a.z+b.z);
  }
168242
@javax.annotation.Nonnull
  public static double[] op(@javax.annotation.Nonnull final double[] a, @javax.annotation.Nonnull final double[] b, @javax.annotation.Nonnull final DoubleBinaryOperator fn) {
    assert a.length == b.length;
    @javax.annotation.Nonnull final double[] c = new double[a.length];
    for (int j = 0; j < a.length; j++) {
      c[j] = fn.applyAsDouble(a[j], b[j]);
    }
    return c;
  }
757100
function(a, b) {
      for (var i = 0, node; node = b[i]; i++)
        a.push(node);
      return a;
    }
702583
public static void divide(Complex_F64 a, Complex_F64 b, Complex_F64 result) {
        double norm = b.getMagnitude2();
        result.real = (a.real * b.real + a.imaginary*b.imaginary)/norm;
        result.imaginary = (a.imaginary*b.real - a.real*b.imaginary)/norm;
    }
676595
function outer(A, B) {
    if (A.shape.length === 1) {
        A.reshape([A.shape[0], 1]);
    }
    else if (A.shape.length === 2) {
        if (A.shape[1] !== 1) {
            throw new Error('A is not a column vector');
        }
    }
    else {
        throw new Error('A has invalid dimensions');
    }
    if (B.shape.length === 1) {
        B.reshape([1, B.shape[0]]);
    }
    else if (B.shape.length === 2) {
        if (B.shape[0] !== 1) {
            throw new Error('B is not a row vector');
        }
    }
    else {
        throw new Error('B has invalid dimensions');
    }
    if (A.shape[0] !== B.shape[1]) {
        throw new Error('Sizes of A and B are not compatible');
    }
    return matmul(A, B);
}
652366
def _B(self, x, a, b):
        
        return special.betainc(a, b, x) * special.beta(a, b)
763349
function locallyInside(a, b) {
       return area(a.prev, a, a.next) < 0 ?
           area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 :
           area(a, b, a.prev) < 0 || area(a, a.next, b) < 0;
   }
1203714
function outer(A, B) {
    return jStat.multiply(A.map(function(t){ return [t] }), [B]);
  }
1095347
def divide(self, other, out=None):
        
        return self.space.divide(self, other, out=out)
597803
def div(a, b):
  
  def divide(a, b):
    """Division"""
    return a / b
  return op_with_scalar_cast(a, b, divide)