Cross product of self and b, written to a Vector3 out
@param  {clay.Vector3} a
@param  {clay.Vector3} b
@return {clay.Vector3}
495350
function (a, b) {
        vec3.cross(this.array, a.array, b.array);
        this._dirty = true;
        return this;
    }
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);
}
1053315
def cross(rhs)
      Util3D.check_arg_type(Vector3, rhs)
      Vector3.new(
              self.y*rhs.z - self.z*rhs.y,
              self.z*rhs.x - self.x*rhs.z,
              self.x*rhs.y - self.y*rhs.x)
    end
1322105
def cross(self, vec):
        """"""

        return Vec3(self.y * vec.z - self.z * vec.y,
                    self.z * vec.x - self.x * vec.z,
                    self.x * vec.y - self.y * vec.x)
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
1085387
public double getTorsionAngle(Point3d a, Point3d b, Point3d c, Point3d d) {
        Vector3d ab = new Vector3d(a.x - b.x, a.y - b.y, a.z - b.z);
        Vector3d cb = new Vector3d(c.x - b.x, c.y - b.y, c.z - b.z);
        Vector3d dc = new Vector3d(d.x - c.x, d.y - c.y, d.z - c.z);
        Vector3d bc = new Vector3d(b.x - c.x, b.y - c.y, b.z - c.z);
        Vector3d n1 = new Vector3d();
        Vector3d n2 = new Vector3d();

        n1.cross(ab, cb);
        if (getSpatproduct(ab, cb, n1) > 0) {
            n1.cross(cb, ab);
        }
        n1.normalize();
        n2.cross(dc, bc);
        if (getSpatproduct(dc, bc, n2) < 0) {
            n2.cross(bc, dc);
        }
        n2.normalize();
        return n1.dot(n2);
    }
825320
def cross_product(p1, p2, o=(0, 0)):
    
    v1 = vector(o, p1)
    v2 = vector(o, p2)
    return v1[0] * v2[1] - v1[1] * v2[0]
635127
function getter_THREE_Vector4(inst) {
	return [
		inst.x,
		inst.y,
		inst.z,
		inst.w];
}
102896
function ( vectorA, vectorB, vectorC ) {

		var a, b, c,
			point = new THREE.Vector3(),
			tmp = THREE.GeometryUtils.__v1;

		a = THREE.GeometryUtils.random();
		b = THREE.GeometryUtils.random();

		if ( ( a + b ) > 1 ) {

			a = 1 - a;
			b = 1 - b;

		}

		c = 1 - a - b;

		point.copy( vectorA );
		point.multiplyScalar( a );

		tmp.copy( vectorB );
		tmp.multiplyScalar( b );

		point.addSelf( tmp );

		tmp.copy( vectorC );
		tmp.multiplyScalar( c );

		point.addSelf( tmp );

		return point;

	}
1362817
private static float crossProductZ(ResultPoint pointA,
                                     ResultPoint pointB,
                                     ResultPoint pointC) {
    float bX = pointB.x;
    float bY = pointB.y;
    return ((pointC.x - bX) * (pointA.y - bY)) - ((pointC.y - bY) * (pointA.x - bX));
  }
859664
public Vector3d fma(Vector3fc a, Vector3fc b) {
        return fma(a, b, thisOrNew());
    }
1189783
def cross(a, b):
    """
    if isinstance(a, Mul):
        a = a.expand()
        avect = 1
        aivect = -1
        for ai, fact in enumerate(a.args):
            if isinstance(fact, Vector3D):
                avect = fact
                aivect = ai
                break

        acoef = a.args[:aivect] + a.args[aivect+1:]
        acoef = Mul(*acoef)
        return acoef*cross(avect, b)

    if isinstance(b, Mul):
        b = b.expand()
        bvect = 1
        bivect = -1
        for bi, fact in enumerate(b.args):
            if isinstance(fact, Vector3D):
                bvect = fact
                bivect = bi
                break

        bcoef = b.args[:bivect] + b.args[bivect+1:]
        bcoef = Mul(*bcoef)
        return bcoef*cross(a, bvect)

    if isinstance(a, Vector3D) and isinstance(b, Vector3D):
        return CrossProduct(a, b)
1232116
function (x) {
        if (x.length === 2) {
            return new THREE.Vector2(x[0], x[1]);
        } else if (x.length === 3) {
            return new THREE.Vector3(x[0], x[1], x[2]);
        }
    }
710267
function(out, b) {
        vec2.cross(out.array, this.array, b.array);
        out._dirty = true;
        return this;
    }
15020
protected final int isLeft(double[] a, double[] b, double[] o) {
    final double cross = getRX(a, o) * getRY(b, o) - getRY(a, o) * getRX(b, o);
    if(cross == 0) {
      // Compare manhattan distances - same angle!
      final double dista = Math.abs(getRX(a, o)) + Math.abs(getRY(a, o));
      final double distb = Math.abs(getRX(b, o)) + Math.abs(getRY(b, o));
      return Double.compare(dista, distb);
    }
    return Double.compare(cross, 0);
  }
970610
def cross_product (x1, y1, x2, y2, x3, y3):
    
    return (x2 - x1) * (y3 - y1) - (x3 - x1) * (y2 - y1)
1275773
function multiply(out, a, b) {
  out[0] = a[0] * b[0];
  out[1] = a[1] * b[1];
  out[2] = a[2] * b[2];
  return out;
}