TODO: return VecDomainV4
766817
@SuppressWarnings("unused") // called through reflection by RequestServer
  public FramesV3 columnDomain(int version, FramesV3 s) {
    Frame frame = getFromDKV("key", s.frame_id.key());
    Vec vec = frame.vec(s.column);
    if (vec == null)
      throw new H2OColumnNotFoundArgumentException("column", s.frame_id.toString(), s.column);
    s.domain = new String[1][];
    s.domain[0] = vec.domain();
    return s;
  }
581199
def _jmomentsurfaceMCIntegrand(vz,vR,vT,R,z,df,sigmaR1,gamma,sigmaz1,mvT,n,m,o):
    """"""
    return df(R,vR*sigmaR1,vT*sigmaR1*gamma,z,vz*sigmaz1,use_physical=False,
              func=(lambda x,y,z: x**n*y**m*z**o))\
              *numpy.exp(vR**2./2.+(vT-mvT)**2./2.+vz**2./2.)
1107282
def to_vec4(self, isPoint):
        """"""
        vec4 = Vector4()
        vec4.x = self.x
        vec4.y = self.y
        vec4.z = self.z
        if isPoint:
            vec4.w = 1
        else:
            vec4.w = 0

        return vec4
828896
def _call_vecfield_p(self, vf, out):
        """"""
        # Optimization for 1 component - just absolute value (maybe weighted)
        if len(self.domain) == 1:
            vf[0].ufuncs.absolute(out=out)
            if self.is_weighted:
                out *= self.weights[0] ** (1 / self.exponent)
            return

        # Initialize out, avoiding one copy
        self._abs_pow_ufunc(vf[0], out=out, p=self.exponent)
        if self.is_weighted:
            out *= self.weights[0]

        tmp = self.range.element()
        for fi, wi in zip(vf[1:], self.weights[1:]):
            self._abs_pow_ufunc(fi, out=tmp, p=self.exponent)
            if self.is_weighted:
                tmp *= wi
            out += tmp

        self._abs_pow_ufunc(out, out=out, p=(1 / self.exponent))
1083477
public static int cudnnGetConvolution2dForwardOutputDim(
        cudnnConvolutionDescriptor convDesc, 
        cudnnTensorDescriptor inputTensorDesc, 
        cudnnFilterDescriptor filterDesc, 
        int[] n, 
        int[] c, 
        int[] h, 
        int[] w)
    {
        return checkResult(cudnnGetConvolution2dForwardOutputDimNative(convDesc, inputTensorDesc, filterDesc, n, c, h, w));
    }
1291101
def get_vexrc(options, environ):
    
    # Complain if user specified nonexistent file with --config.
    # But we don't want to complain just because ~/.vexrc doesn't exist.
    if options.config and not os.path.exists(options.config):
        raise exceptions.InvalidVexrc("nonexistent config: {0!r}".format(options.config))
    filename = options.config or os.path.expanduser('~/.vexrc')
    vexrc = config.Vexrc.from_file(filename, environ)
    return vexrc
1148311
function(v) {
        if (v instanceof Vec3) {
            return new Vec3(this.x + v.x, this.y + v.y, this.z + v.z);
        }
        else if(v instanceof Vec2){
            return new Vec3(this.x + v.x, this.y + v.y, this.z);
        }
        else if(typeof v === 'number') {
            return new Vec3(this.x + v, this.y + v, this.z + v);
        }
        else {
            throw new TypeError('Invalid argument', v);
        }
    }
271764
def get_vm_by_name(content, name, regex=False):
    '''
    
    '''
    return get_object_by_name(content, vim.VirtualMachine, name, regex)
924472
@Override
    public INDArray convn(INDArray input, INDArray kernel, Convolution.Type type, int[] axes) {
        throw new UnsupportedOperationException();
    }
1076587
def _vmomentsurfaceMCIntegrand(vz,vR,vT,R,z,df,sigmaR1,gamma,sigmaz1,mvT,n,m,o):
    """"""
    return vR**n*vT**m*vz**o*df(R,vR*sigmaR1,vT*sigmaR1*gamma,z,vz*sigmaz1,use_physical=False)*numpy.exp(vR**2./2.+(vT-mvT)**2./2.+vz**2./2.)
1105508
function packVector(vector, includeMetadata) {
  includeMetadata = isUndefined(includeMetadata) ? true : includeMetadata;
  var dtype = vector.dtype;
  if (vector.dtype === 'date') {
    vector = vector.toDtype('number');
  }
  var values = (vector.dtype !== 'number') ?
    vector.values.slice() :
    vector.values.map(function(x) {
      return Number.isNaN(x) ? null : x;
    });

  var result = {dtype: dtype, values: values};
  if (includeMetadata) {
    result.version = jd.version;
    result.type = vectorProto.type;
  }
  return result;
}
723804
def get_vndmat_attr(d,keypath,attr,**kwargs):
    '''
        
    '''
    kt,vn = _d2kvmatrix(d)
    kdmat = _scankm(kt)
    ltree = elel.ListTree(vn)
    vndmat = ltree.desc
    loc = get_kdmat_loc(kdmat,keypath)
    rslt = vndmat[loc[0]][loc[1]][attr]
    if(rslt == None):
        pass
    elif(elel.is_matrix(rslt,mode='loose')):
        if('path2loc' in kwargs):
            rslt = elel.array_map(rslt,ltree.path2loc)
        else:
            pass
        if('path2keypath' in kwargs):
            nlocs = elel.array_map(rslt,ltree.path2loc)
            def cond_func(ele,kdmat):
                return(kdmat[ele[0]][ele[1]]['path'])
            rslt = elel.array_map(nlocs,cond_func,kdmat)
        else:
            pass        
    else:
        if('path2loc' in kwargs):
            rslt = ltree.path2loc(rslt)
        else:
            pass
        if('path2keypath' in kwargs):
            nloc = ltree.path2loc(rslt)
            rslt = kdmat[nloc[0]][nloc[1]]['path']
        else:
            pass
    return(rslt)
311066
def ang2disc(nside, lon, lat, radius, inclusive=False, fact=4, nest=False):
    
    vec = ang2vec(lon,lat)
    return query_disc(nside,vec,radius,inclusive,fact,nest)
950633
def _call_ver2(self, file_path, mode='r', buffering=-1, flags=None,
                   open_modes=None):
        """"""
        # Backwards compatibility, mode arg used to be named flags
        mode = flags or mode
        return self.call(file_path, mode, buffering, open_modes=open_modes)
1217625
def vd(inc, sd):
    
    return abs(sd * math.sin(math.radians(inc)))
774774
def get_vm(self, name, path=""):
        """"""
        if path:
            return self.get_obj([vim.VirtualMachine], name, path=path)
        else:
            return self.get_obj([vim.VirtualMachine], name)
521996
private int getVertMask(int vertsCount) {
        int vertMask = Integer.highestOneBit(vertsCount);
        if (vertMask != vertsCount) {
            vertMask *= 2;
        }
        vertMask--;
        return vertMask;
    }