Calculate X,Y,Z,U,V,W
491444
def _XYZvxvyvz(self,*args,**kwargs):
        """"""
        obs, ro, vo= self._parse_radec_kwargs(kwargs,vel=True)
        thiso= self(*args,**kwargs)
        if not len(thiso.shape) == 2: thiso= thiso.reshape((thiso.shape[0],1))
        if len(thiso[:,0]) != 4 and len(thiso[:,0]) != 6: #pragma: no cover
            raise AttributeError("orbit must track azimuth to use radeclbduvw functions")
        elif len(thiso[:,0]) == 4: #planarOrbit
            if isinstance(obs,(nu.ndarray,list)):
                Xsun= nu.sqrt(obs[0]**2.+obs[1]**2.)
                X,Y,Z = coords.galcencyl_to_XYZ(\
                    thiso[0,:],thiso[3,:]-nu.arctan2(obs[1],obs[0]),
                    nu.zeros_like(thiso[0]),
                    Xsun=Xsun/ro,Zsun=obs[2]/ro,_extra_rot=False).T
                vX,vY,vZ = coords.galcencyl_to_vxvyvz(\
                    thiso[1,:],thiso[2,:],nu.zeros_like(thiso[0]),
                    thiso[3,:]-nu.arctan2(obs[1],obs[0]),
                    vsun=nu.array(# have to rotate
                        [obs[3]*obs[0]/Xsun+obs[4]*obs[1]/Xsun,
                         -obs[3]*obs[1]/Xsun+obs[4]*obs[0]/Xsun,
                         obs[5]])/vo,
                    Xsun=Xsun/ro,Zsun=obs[2]/ro,_extra_rot=False).T
            else: #Orbit instance
                obs.turn_physical_off()
                if obs.dim() == 2:
                    X,Y,Z = coords.galcencyl_to_XYZ(\
                        thiso[0,:],thiso[3,:]-obs.phi(*args,**kwargs),
                        nu.zeros_like(thiso[0]),
                        Xsun=obs.R(*args,**kwargs),Zsun=0.,_extra_rot=False).T
                    vX,vY,vZ = coords.galcencyl_to_vxvyvz(\
                        thiso[1,:],thiso[2,:],nu.zeros_like(thiso[0]),
                        thiso[3,:]-obs.phi(*args,**kwargs),
                        vsun=nu.array([\
                                obs.vR(*args,**kwargs),obs.vT(*args,**kwargs),
                                0.]),
                        Xsun=obs.R(*args,**kwargs),Zsun=0.,_extra_rot=False).T
                else:
                    X,Y,Z = coords.galcencyl_to_XYZ(\
                        thiso[0,:],thiso[3,:]-obs.phi(*args,**kwargs),
                        nu.zeros_like(thiso[0]),
                        Xsun=obs.R(*args,**kwargs),
                        Zsun=obs.z(*args,**kwargs),_extra_rot=False).T
                    vX,vY,vZ = coords.galcencyl_to_vxvyvz(\
                        thiso[1,:],thiso[2,:],nu.zeros_like(thiso[0]),
                        thiso[3,:]-obs.phi(*args,**kwargs),
                        vsun=nu.array([\
                                obs.vR(*args,**kwargs),
                                obs.vT(*args,**kwargs),
                                obs.vz(*args,**kwargs)]),
                        Xsun=obs.R(*args,**kwargs),
                        Zsun=obs.z(*args,**kwargs),_extra_rot=False).T
                obs.turn_physical_on()
        else: #FullOrbit
            if isinstance(obs,(nu.ndarray,list)):
                Xsun= nu.sqrt(obs[0]**2.+obs[1]**2.)
                X,Y,Z = coords.galcencyl_to_XYZ(\
                    thiso[0,:],thiso[5,:]-nu.arctan2(obs[1],obs[0]),thiso[3,:],
                    Xsun=Xsun/ro,Zsun=obs[2]/ro).T
                vX,vY,vZ = coords.galcencyl_to_vxvyvz(\
                    thiso[1,:],thiso[2,:],thiso[4,:],
                    thiso[5,:]-nu.arctan2(obs[1],obs[0]),
                    vsun=nu.array(# have to rotate
                        [obs[3]*obs[0]/Xsun+obs[4]*obs[1]/Xsun,
                         -obs[3]*obs[1]/Xsun+obs[4]*obs[0]/Xsun,
                         obs[5]])/vo,
                    Xsun=Xsun/ro,Zsun=obs[2]/ro).T
            else: #Orbit instance
                obs.turn_physical_off()
                if obs.dim() == 2:
                    X,Y,Z = coords.galcencyl_to_XYZ(\
                        thiso[0,:],thiso[5,:]-obs.phi(*args,**kwargs),
                        thiso[3,:],
                        Xsun=obs.R(*args,**kwargs),Zsun=0.).T
                    vX,vY,vZ = coords.galcencyl_to_vxvyvz(\
                        thiso[1,:],thiso[2,:],thiso[4,:],
                        thiso[5,:]-obs.phi(*args,**kwargs),
                        vsun=nu.array([\
                                obs.vR(*args,**kwargs),obs.vT(*args,**kwargs),
                                0.]),
                        Xsun=obs.R(*args,**kwargs),Zsun=0.).T
                else:
                    X,Y,Z = coords.galcencyl_to_XYZ(\
                        thiso[0,:],thiso[5,:]-obs.phi(*args,**kwargs),
                        thiso[3,:],
                        Xsun=obs.R(*args,**kwargs),
                        Zsun=obs.z(*args,**kwargs)).T
                    vX,vY,vZ = coords.galcencyl_to_vxvyvz(\
                        thiso[1,:],thiso[2,:],thiso[4,:],
                        thiso[5,:]-obs.phi(*args,**kwargs),
                        vsun=nu.array([\
                                obs.vR(*args,**kwargs),
                                obs.vT(*args,**kwargs),
                                obs.vz(*args,**kwargs)]),
                        Xsun=obs.R(*args,**kwargs),
                        Zsun=obs.z(*args,**kwargs)).T
                obs.turn_physical_on()
        return (X*ro,Y*ro,Z*ro,vX*vo,vY*vo,vZ*vo)
57857
public Vector4d set(Vector2fc v, double z, double w) {
        return set(v.x(), v.y(), z, w);
    }
1048977
def cart2spher(x, y, z):
    """"""
    hxy = np.hypot(x, y)
    r = np.hypot(hxy, z)
    theta = np.arctan2(z, hxy)
    phi = np.arctan2(y, x)
    return r, theta, phi
967536
function (x, y, v) {
            var tileX = Math.floor(x),
                tileY = Math.floor(y);
            var ret = v || new me.Vector2d();

            if (this.staggerX) {
                ret.y = tileY * (this.tileheight + this.sidelengthy);
                if (this.doStaggerX(tileX)) {
                    ret.y += this.rowheight;
                }
                ret.x = tileX * this.columnwidth;
            } else {
                ret.x = tileX * (this.tilewidth + this.sidelengthx);
                if (this.doStaggerY(tileY)) {
                    ret.x += this.columnwidth;
                }
                ret.y = tileY * this.rowheight;
            }

            return ret;
        }
1336151
def getRect(self):
		
		return (self.x, self.y, self.w, self.h)
685628
def _evaluate_xyz(self,x,y,z):
        """"""
        return 2.*numpy.pi*self._b*self._c\
            *_potInt(x,y,z,self._psi,
                     self._b2,self._c2,glx=self._glx,glw=self._glw)
1110908
function (face, v) {
                //Get the indices of triangles for each polygon
                getTriangles(face, v);
                for (var k = 0; k < triangles.length; k++) {
                    //triangle[k] = "1/1/1"
                    //Split the data for getting position, uv, and normals
                    var point = triangles[k].split("/"); // ["1", "1", "1"]
                    // Set position indice
                    var indicePositionFromObj = parseInt(point[0]) - 1;
                    // Set uv indice
                    var indiceUvsFromObj = parseInt(point[1]) - 1;
                    // Set normal indice
                    var indiceNormalFromObj = parseInt(point[2]) - 1;
                    setData(indicePositionFromObj, indiceUvsFromObj, indiceNormalFromObj, positions[indicePositionFromObj], uvs[indiceUvsFromObj], normals[indiceNormalFromObj] //Set the vector for each component
                    );
                }
                //Reset variable for the next line
                triangles = [];
            }
352964
def r(w, Xs):
    '''
    '''
    n = len(Xs)
    P = projection_matrix(w)
    c = C(w, Xs)

    return np.sqrt(sum(np.dot(c - X, np.dot(P, c - X)) for X in Xs) / n)
493866
def dot_v3(v, w):
    """"""

    return sum([x * y for x, y in zip(v, w)])
347096
function(x, y, z, w) {
      var perm = this.perm;
      var grad4 = this.grad4;

      var n0, n1, n2, n3, n4; // Noise contributions from the five corners
      // Skew the (x,y,z,w) space to determine which cell of 24 simplices we're in
      var s = (x + y + z + w) * F4; // Factor for 4D skewing
      var i = Math.floor(x + s);
      var j = Math.floor(y + s);
      var k = Math.floor(z + s);
      var l = Math.floor(w + s);
      var t = (i + j + k + l) * G4; // Factor for 4D unskewing
      var X0 = i - t; // Unskew the cell origin back to (x,y,z,w) space
      var Y0 = j - t;
      var Z0 = k - t;
      var W0 = l - t;
      var x0 = x - X0; // The x,y,z,w distances from the cell origin
      var y0 = y - Y0;
      var z0 = z - Z0;
      var w0 = w - W0;
      // For the 4D case, the simplex is a 4D shape I won't even try to describe.
      // To find out which of the 24 possible simplices we're in, we need to
      // determine the magnitude ordering of x0, y0, z0 and w0.
      // Six pair-wise comparisons are performed between each possible pair
      // of the four coordinates, and the results are used to rank the numbers.
      var rankx = 0;
      var ranky = 0;
      var rankz = 0;
      var rankw = 0;
      if (x0 > y0) rankx++;
      else ranky++;
      if (x0 > z0) rankx++;
      else rankz++;
      if (x0 > w0) rankx++;
      else rankw++;
      if (y0 > z0) ranky++;
      else rankz++;
      if (y0 > w0) ranky++;
      else rankw++;
      if (z0 > w0) rankz++;
      else rankw++;
      var i1, j1, k1, l1; // The integer offsets for the second simplex corner
      var i2, j2, k2, l2; // The integer offsets for the third simplex corner
      var i3, j3, k3, l3; // The integer offsets for the fourth simplex corner
      // simplex[c] is a 4-vector with the numbers 0, 1, 2 and 3 in some order.
      // Many values of c will never occur, since e.g. x>y>z>w makes x<z, y<w and x<w
      // impossible. Only the 24 indices which have non-zero entries make any sense.
      // We use a thresholding to set the coordinates in turn from the largest magnitude.
      // Rank 3 denotes the largest coordinate.
      i1 = rankx >= 3 ? 1 : 0;
      j1 = ranky >= 3 ? 1 : 0;
      k1 = rankz >= 3 ? 1 : 0;
      l1 = rankw >= 3 ? 1 : 0;
      // Rank 2 denotes the second largest coordinate.
      i2 = rankx >= 2 ? 1 : 0;
      j2 = ranky >= 2 ? 1 : 0;
      k2 = rankz >= 2 ? 1 : 0;
      l2 = rankw >= 2 ? 1 : 0;
      // Rank 1 denotes the second smallest coordinate.
      i3 = rankx >= 1 ? 1 : 0;
      j3 = ranky >= 1 ? 1 : 0;
      k3 = rankz >= 1 ? 1 : 0;
      l3 = rankw >= 1 ? 1 : 0;
      // The fifth corner has all coordinate offsets = 1, so no need to compute that.
      var x1 = x0 - i1 + G4; // Offsets for second corner in (x,y,z,w) coords
      var y1 = y0 - j1 + G4;
      var z1 = z0 - k1 + G4;
      var w1 = w0 - l1 + G4;
      var x2 = x0 - i2 + 2.0 * G4; // Offsets for third corner in (x,y,z,w) coords
      var y2 = y0 - j2 + 2.0 * G4;
      var z2 = z0 - k2 + 2.0 * G4;
      var w2 = w0 - l2 + 2.0 * G4;
      var x3 = x0 - i3 + 3.0 * G4; // Offsets for fourth corner in (x,y,z,w) coords
      var y3 = y0 - j3 + 3.0 * G4;
      var z3 = z0 - k3 + 3.0 * G4;
      var w3 = w0 - l3 + 3.0 * G4;
      var x4 = x0 - 1.0 + 4.0 * G4; // Offsets for last corner in (x,y,z,w) coords
      var y4 = y0 - 1.0 + 4.0 * G4;
      var z4 = z0 - 1.0 + 4.0 * G4;
      var w4 = w0 - 1.0 + 4.0 * G4;
      // Work out the hashed gradient indices of the five simplex corners
      var ii = i & 255;
      var jj = j & 255;
      var kk = k & 255;
      var ll = l & 255;
      // Calculate the contribution from the five corners
      var t0 = 0.6 - x0 * x0 - y0 * y0 - z0 * z0 - w0 * w0;
      if (t0 < 0) n0 = 0.0;
      else {
        var gi0 = (perm[ii + perm[jj + perm[kk + perm[ll]]]] % 32) * 4;
        t0 *= t0;
        n0 = t0 * t0 * (grad4[gi0] * x0 + grad4[gi0 + 1] * y0 + grad4[gi0 + 2] * z0 + grad4[gi0 + 3] * w0);
      }
      var t1 = 0.6 - x1 * x1 - y1 * y1 - z1 * z1 - w1 * w1;
      if (t1 < 0) n1 = 0.0;
      else {
        var gi1 = (perm[ii + i1 + perm[jj + j1 + perm[kk + k1 + perm[ll + l1]]]] % 32) * 4;
        t1 *= t1;
        n1 = t1 * t1 * (grad4[gi1] * x1 + grad4[gi1 + 1] * y1 + grad4[gi1 + 2] * z1 + grad4[gi1 + 3] * w1);
      }
      var t2 = 0.6 - x2 * x2 - y2 * y2 - z2 * z2 - w2 * w2;
      if (t2 < 0) n2 = 0.0;
      else {
        var gi2 = (perm[ii + i2 + perm[jj + j2 + perm[kk + k2 + perm[ll + l2]]]] % 32) * 4;
        t2 *= t2;
        n2 = t2 * t2 * (grad4[gi2] * x2 + grad4[gi2 + 1] * y2 + grad4[gi2 + 2] * z2 + grad4[gi2 + 3] * w2);
      }
      var t3 = 0.6 - x3 * x3 - y3 * y3 - z3 * z3 - w3 * w3;
      if (t3 < 0) n3 = 0.0;
      else {
        var gi3 = (perm[ii + i3 + perm[jj + j3 + perm[kk + k3 + perm[ll + l3]]]] % 32) * 4;
        t3 *= t3;
        n3 = t3 * t3 * (grad4[gi3] * x3 + grad4[gi3 + 1] * y3 + grad4[gi3 + 2] * z3 + grad4[gi3 + 3] * w3);
      }
      var t4 = 0.6 - x4 * x4 - y4 * y4 - z4 * z4 - w4 * w4;
      if (t4 < 0) n4 = 0.0;
      else {
        var gi4 = (perm[ii + 1 + perm[jj + 1 + perm[kk + 1 + perm[ll + 1]]]] % 32) * 4;
        t4 *= t4;
        n4 = t4 * t4 * (grad4[gi4] * x4 + grad4[gi4 + 1] * y4 + grad4[gi4 + 2] * z4 + grad4[gi4 + 3] * w4);
      }
      // Sum up and scale the result to cover the range [-1,1]
      return 27.0 * (n0 + n1 + n2 + n3 + n4);
    }
351804
def contour_data
      x, y, z = coords
      return [x, y, z].transpose.flatten.join("\\")
    end
1060082
public Vector4d set(Vector3ic v, double w) {
        return set(v.x(), v.y(), v.z(), w);
    }
131893
function (x, y, z, s) { // !!! this function takes x,y,z not h,s,v
    var r = 0,
      g = 0,
      b = 0,
      c = 0,
      d = (100 - y / 2.55) / 100,
      i = z / 255,
      j = z * (255 - y) / 255;

    if (x < 42.5) {
      r = z;
      g = x * 6 * i;
      g += (z - g) * d;
      b = j
    } else if (x >= 42.5 && x < 85) {
      c = 42.5;
      r = (255 - (x - c) * 6) * i;
      r += (z - r) * d;
      g = z;
      b = j
    } else if (x >= 85 && x < 127.5) {
      c = 85;
      r = j;
      g = z;
      b = (x - c) * 6 * i;
      b += (z - b) * d
    } else if (x >= 127.5 && x < 170) {
      c = 127.5;
      r = j;
      g = (255 - (x - c) * 6) * i;
      g += (z - g) * d;
      b = z
    } else if (x >= 170 && x < 212.5) {
      c = 170;
      r = (x - c) * 6 * i;
      r += (z - r) * d;
      g = j;
      b = z
    } else if (x >= 212.5) {
      c = 212.5;
      r = z;
      g = j;
      b = (255 - (x - c) * 6) * i;
      b += (z - b) * d
    }
    if (s) return [r, g, b];
    else return [Math.round(r), Math.round(g), Math.round(b)];
  }
496565
function(w, x, y, z) {

      parse(P, w, x, y, z);

      // Q1 * Q2 = [w1 * w2 - dot(v1, v2), w1 * v2 + w2 * v1 + cross(v1, v2)]

      // Not commutative because cross(v1, v2) != cross(v2, v1)!

      var w1 = this['w'];
      var x1 = this['x'];
      var y1 = this['y'];
      var z1 = this['z'];

      var w2 = P['w'];
      var x2 = P['x'];
      var y2 = P['y'];
      var z2 = P['z'];

      return new Quaternion(
              w1 * w2 - x1 * x2 - y1 * y2 - z1 * z2,
              w1 * x2 + x1 * w2 + y1 * z2 - z1 * y2,
              w1 * y2 + y1 * w2 + z1 * x2 - x1 * z2,
              w1 * z2 + z1 * w2 + x1 * y2 - y1 * x2);
    }
592423
def calc_uv(self, x, y, prev=False):
        """"""
        assert len(x) == self.N
        assert len(y) == self.N
        u = np.zeros(self.N, self.x.dtype)
        v = np.zeros(self.N, self.y.dtype)
        for n in xrange(self.N):
            # don't include self interaction
            if prev:
                x0 = self.xprev[np.r_[:n,n+1:self.N]]
                y0 = self.yprev[np.r_[:n,n+1:self.N]]
            else:
                x0 = self.x[np.r_[:n,n+1:self.N]]
                y0 = self.y[np.r_[:n,n+1:self.N]]
            s0 = self.s[np.r_[:n,n+1:self.N]]
            u0, v0 = self.uv_at_xy(x[n], y[n], x0, y0, s0)
            u[n] = u0.sum()
            v[n] = v0.sum()
        return u, v
348057
public Vector4f add(float x, float y, float z, float w) {
        return add(x, y, z, w, thisOrNew());
    }
899045
def trilaterate_v(self, P1, P2, P3, r1, r2, r3):
        
        '''
        temp1 = P2-P1
        e_x = temp1/np.linalg.norm(temp1, axis=1)[:, np.newaxis]
        temp2 = P3-P1
        i = self._my_dot(e_x, temp2)[:, np.newaxis]
        temp3 = temp2 - i*e_x
        e_y = temp3/np.linalg.norm(temp3, axis=1)[:, np.newaxis]
        d = np.linalg.norm(P2-P1, axis=1)[:, np.newaxis]
        j = self._my_dot(e_y, temp2)[:, np.newaxis]
        x = (r1*r1 - r2*r2 + d*d) / (2*d)
        y = (r1*r1 - r3*r3 - 2*i*x + (i*i) + (j*j)) / (2*j)
        temp4 = r1*r1 - x*x - y*y
        return temp4 >= 0