python类int64()的实例源码

def encode_jit(self, nr_samples, lengths, out, positions):
        """ out[samples, reads, bin_nodes+tria_nodes]
            Need to use this function to call the jit compiled function, as
            class support via numba is disabled sice 0.12"""
        if self.double_range:
            encode_double_triangles_jit(n_binary_bits=np.int64(self.n_binary_bits),
                                 n_inputnodes=np.int64(self.data_nodes),
                                 tria_nodes_end=self.data_nodes-self.n_binary_bits-1, #this is the last tria index -> nr nodes - 1
                                 node_range=np.float64(self.node_range),
                                 nr_samples=np.int64(nr_samples),
                                 lengths=np.uint32(lengths), out=np.float32(out), 
                                 positions=np.uint32(positions))
        else:
            encode_triangles_jit(n_binary_bits=np.int64(self.n_binary_bits),
                                 n_inputnodes=np.int64(self.data_nodes),
                                 node_range=np.float64(self.node_range),
                                 nr_samples=np.int64(nr_samples),
                                 lengths=np.uint32(lengths), out=np.float32(out), 
                                 positions=np.uint32(positions))

def encode_overlapping_binary_jit(n_inputnodes, nr_samples, lengths, out, positions):
    # out: float32[:,:,:] with [samples, timesteps, features]
    # pos_ind: int64 at which position in out['features'] the position
    #    is stored and encoding should start
    # lengths: lengths without tickersteps - tickersteps will be added here
    mask = 1
    n_bits = (n_inputnodes / 2) + 1 #lowbit only in binary

    for s_i in range(nr_samples):

        # Enocde position
        for t_i in range(lengths[s_i]):
            # normal bitwise for all bits
            for n_i in range(n_bits):
                out[s_i, t_i, n_i-n_inputnodes] = ((mask << n_i) & positions[s_i, t_i]) != 0

            # overlapping bitwise (low bit ignored)
            for n_i in range(1, n_bits):
                # for bit at bitposition bp add 2**(bp-1) = 1<<(bp-1)
                out[s_i, t_i, n_i-n_bits] = ((mask << n_i) & (positions[s_i, t_i] + (mask << (n_i-1)))) != 0

def r_shape_cubic(cell_position, index):
    flip_factor = 1.
    ir = int64(math.floor(cell_position)) - 1
    if index == 0:
        if ir < 0:
            flip_factor = -1.
        return flip_factor*(-1./6.)*((cell_position-ir)-2)**3
    if index == 1:
        if ir+1 < 0:
            flip_factor = -1.
        return flip_factor*(1./6.)*(3*((cell_position-(ir+1))**3)-6*((cell_position-(ir+1))**2)+4)
    if index == 2:
        if ir+2 < 0:
            flip_factor = -1.
        return flip_factor*(1./6.)*(3*(((ir+2)-cell_position)**3)-6*(((ir+2)-cell_position)**2)+4)
    if index == 3:
        if ir+3 < 0:
            flip_factor = -1.
        return flip_factor*(-1./6.)*(((ir+3)-cell_position)-2)**3

# -------------------------------
# Field deposition - linear - rho
# -------------------------------

def ang2pix_ring(nside, theta, phi):
    """Calculate the pixel indexes in RING ordering scheme for each
    pair of angular coordinates on the sphere.

    Parameters
    ----------
    theta : 1D or 2D `~numpy.ndarray`
        The polar angles (i.e., latitudes), ? ? [0, ?]. (unit: rad)
    phi : 1D or 2D `~numpy.ndarray`
        The azimuthal angles (i.e., longitudes), ? ? [0, 2?). (unit: rad)

    Returns
    -------
    ipix : 1D or 1D `~numpy.ndarray`
        The indexes of the pixels corresponding to the input coordinates.
        The shape is the same as the input array.

    NOTE
    ----
    * Only support the *RING* ordering scheme
    * This is the JIT-optimized version that partially replaces the
      ``healpy.ang2pix``
    """
    shape = theta.shape
    size = theta.size
    theta = theta.flatten()
    phi = phi.flatten()
    ipix = np.zeros(size, dtype=np.int64)
    for i in range(size):
        ipix[i] = ang2pix_ring_single(nside, theta[i], phi[i])
    return ipix.reshape(shape)

def __init__(self, ticker_steps=0, tstep_resolution=1.0, min_dif=None, node_range=None, nr_tria_nodes=None, add_binary_encoding=True, double_range=False): 

        if min_dif != None:
            self.node_range = np.ceil(np.float64(tstep_resolution) / min_dif) # half the (symmetric) range of the node
        elif node_range != None:
            self.node_range = np.ceil(np.float64(node_range) / 2.)
        elif nr_tria_nodes != None:
            self.node_range = None
            self.nr_tria_nodes = nr_tria_nodes
        else:
            raise(ValueError, "min_dif or node_range have to be specified!")

        self.ticker_steps = np.int64(ticker_steps)
        self.add_binary_encoding = add_binary_encoding
        self.double_range = double_range

def calculate_parameters(self, max_val):
        if self.node_range == None:
            self.node_range = np.ceil(np.float64(max_val) / self.nr_tria_nodes)
        if self.add_binary_encoding:
            self.n_binary_bits = np.int64(np.ceil(np.log2(self.node_range))) #encode one triangle range binary for more precision
        else:
            self.n_binary_bits = 0
        self.helper_nodes = (self.ticker_steps > 0)

        self.max_val = np.float64(max_val)
        self.data_nodes = np.ceil(self.max_val / self.node_range) + 1  + self.n_binary_bits # +1 for right side node (no wrap-around)
        self.n_inputnodes =  np.int64(self.data_nodes + self.helper_nodes)

def encode_overlapping_binary_inplace_jit(ticker_steps, n_inputnodes, nr_samples, lengths, out, out_uint):
    # out: float32[:,:,:] with [samples, timesteps, features]
    # pos_ind: int64 at which position in out['features'] the position
    #    is stored and encoding should start
    # lengths: lengths without tickersteps - tickersteps will be added here
    # Note: positions=0 are ignored
    mask = 1
    pos_bit = n_inputnodes
    if ticker_steps > 0:
        n_inputnodes -= 1
    n_bits = (n_inputnodes / 2) + 1 #lowbit only in binary

    for s_i in range(nr_samples):

        # Enocde position
        for t_i in range(lengths[s_i]):
            orig_int = out_uint[s_i, t_i, -pos_bit] #to be encoded

            # normal bitwise for all bits
            for n_i in range(n_bits):
                out[s_i, t_i, n_i-n_inputnodes] = ((mask << n_i) & orig_int) != 0

            # overlapping bitwise (low bit ignored)
            for n_i in range(1, n_bits):
                # for bit at bitposition bp add 2**(bp-1) = 1<<(bp-1)
                out[s_i, t_i, n_i-n_bits] = ((mask << n_i) & (orig_int + (mask << (n_i-1)))) != 0

            out[s_i, t_i, -pos_bit] = 0 #remove position


        # Set ticker steps, if they exist
        if ticker_steps > 0:
            for n_i in range(ticker_steps):
                out[s_i, lengths[s_i]+n_i, -pos_bit] = 1
            # add ticker steps to lenght
            lengths[s_i] += n_i # := lengths[s_i] += lengths[s_i-1 for index of last element instead of length

def calculate_parameters(self, max_val):

        self.exp = np.int64(np.ceil(np.log2(max_val)))
        self.data_nodes = self.exp * 2 - 1

        self.n_inputnodes =  np.int64(self.data_nodes + self.helper_nodes)
        self.max_val = max_val

def z_shape_linear(cell_position, index):
    iz = int64(math.floor(cell_position))
    if index == 0:
        return iz+1.-cell_position
    if index == 1:
        return cell_position - iz

def r_shape_linear(cell_position, index):
    flip_factor = 1.
    ir = int64(math.floor(cell_position))
    if index == 0:
        if ir < 0:
            flip_factor = -1.
        return flip_factor*(ir+1.-cell_position)
    if index == 1:
        return flip_factor*(cell_position - ir)

# Cubic shapes

def z_shape_cubic(cell_position, index):
    iz = int64(math.floor(cell_position)) - 1
    if index == 0:
        return (-1./6.)*((cell_position-iz)-2)**3
    if index == 1:
        return (1./6.)*(3*((cell_position-(iz+1))**3)-6*((cell_position-(iz+1))**2)+4)
    if index == 2:
        return (1./6.)*(3*(((iz+2)-cell_position)**3)-6*(((iz+2)-cell_position)**2)+4)
    if index == 3:
        return (-1./6.)*(((iz+3)-cell_position)-2)**3

def _calc_hpx_indexes(nside):
    """Calculate HEALPix element indexes for the HPX projection scheme.

    Parameters
    ----------
    nside : int
        Nside of the input/output HEALPix data

    Returns
    -------
    indexes : 2D `~numpy.ndarray`
        2D integer array of same size as the input/output HPX FITS image,
        with elements tracking the indexes of the HPX pixels in the
        HEALPix 1D array, while elements with value "-1" indicating
        null/empty HPX pixels.

    NOTE
    ----
    * The indexes are 0-based;
    * Currently only HEALPix RING ordering supported;
    * The null/empty elements in the HPX projection are filled with "-1".
    """
    # number of horizontal/vertical facet
    nfacet = 5
    # Facets layout of the HPX projection scheme.
    # Note that this appears to be upside-down, and the blank facets
    # are marked with "-1".
    # Ref: ref.[2], Fig.4
    #
    # XXX:
    # Cannot use the nested list here, which fails with ``numba`` error:
    # ``NotImplementedError: unsupported nested memory-managed object``
    FACETS_LAYOUT = np.zeros((nfacet, nfacet), dtype=np.int64)
    FACETS_LAYOUT[0, :] = [6,   9, -1, -1, -1]
    FACETS_LAYOUT[1, :] = [1,   5,  8, -1, -1]
    FACETS_LAYOUT[2, :] = [-1,  0,  4, 11, -1]
    FACETS_LAYOUT[3, :] = [-1, -1,  3,  7, 10]
    FACETS_LAYOUT[4, :] = [-1, -1, -1,  2,  6]
    #
    shape = (nfacet*nside, nfacet*nside)
    indexes = -np.ones(shape, dtype=np.int64)
    #
    # Loop vertically facet-by-facet
    for jfacet in range(nfacet):
        # Loop row-by-row
        for j in range(nside):
            row = jfacet * nside + j
            # Loop horizontally facet-by-facet
            for ifacet in range(nfacet):
                facet = FACETS_LAYOUT[jfacet, ifacet]
                if facet < 0:
                    # blank facet
                    pass
                else:
                    idx = _calc_hpx_row_idx(nside, facet, j)
                    col = ifacet * nside
                    indexes[row, col:(col+nside)] = idx
    #
    return indexes

def make_grid_ellipse(center, size, resolution, rotation=0.0):
    """
    Make a square coordinate grid just containing the specified
    (rotated) ellipse.

    Parameters
    ----------
    center : 2-float tuple
        Center coordinate (longitude, latitude) of the grid,
        with longitude [0, 360) degree, latitude [-90, 90] degree.
    size : 2-float tuple
        The (major, minor) axes of the filling ellipse, unit [ degree ].
    resolution : float
        The grid resolution, unit [ degree ].
    rotation : float
        The rotation angle (unit [ degree ]) of the filling ellipse.

    Returns
    -------
    lon : 2D `~numpy.ndarray`
        The array with elements representing the longitudes of each grid
        pixel.  The array is odd-sized and square, with the input center
        locating at the exact grid central pixel.
        Also, the longitudes are fixed to be in the valid range [0, 360).
    lat : 2D `~numpy.ndarray`
        The array with elements representing the latitudes of each grid
        pixel.
        Also, the latitudes are fixed to be in the valid range [-90, 90].
    gridmap : 2D float `~numpy.ndarray`
        The array containing the specified ellipse, where the pixels
        corresponding to the ellipse with positive values, while other pixels
        are zeros.

    NOTE
    ----
    The generated grid is square, determined by the major axis of the ellipse,
    therefore, we can simply rotate the ellipse without reshaping.
    """
    size_major = max(size)
    size = (size_major, size_major)
    lon, lat = make_coordinate_grid(center, size, resolution)
    shape = lon.shape
    # Fill the ellipse into the grid
    r0, c0 = np.floor(np.array(shape) / 2.0).astype(np.int64)
    radii = np.ceil(0.5*np.array(size)/resolution).astype(np.int64)
    rr, cc = ellipse((r0, c0), (radii[0], radii[1]), shape=shape)
    gridmap = np.zeros(shape)
    # XXX: ``numba`` only support one advanced index
    for ri, ci in zip(rr, cc):
        gridmap[ri, ci] = 1.0
    # Rotate the ellipse about the grid center
    gridmap = rotate_center(gridmap, angle=rotation, interp=True,
                            reshape=False, fill_value=0.0)
    return (lon, lat, gridmap)