python类array_str()的实例源码

def iter_tango_logs(directory, logs, topics=[]):
    for log in logs: 
        directory = os.path.expanduser(os.path.join(args.directory, log))
        print('Accessing Tango directory {:}'.format(directory))
        dataset = TangoLogReader(directory=directory, scale=im_scale) 
        for item in dataset.iterframes(topics=topics): 
            bboxes = item.bboxes
            targets = item.coords


# # If RGB_VIO, RGB, RGB_VIO in stream, then interpolate pose
# # b/w the 1st and 3rd timestamps to match RGB timestamps
# if len(self.__item_q) >= 3 and \
#    self.__item_q[-1][0] == self.__item_q[-3][0] == 1 and \
#    self.__item_q[-2][0] == 0: 
#     t1,t2,t3 = self.__item_q[-3][1], self.__item_q[-2][1], self.__item_q[-1][1]
#     w2, w1 = np.float32([t2-t1, t3-t2]) / (t3-t1)
#     p1,p3 = self.__item_q[-3][2], self.__item_q[-1][2]
#     p2 = p1.interpolate(p3, w1)
#     self.on_frame(t2, t2, p2, self.__item_q[-2][2])
#     print np.array_str(np.float64([t1, t2, t3]) * 1e-14, precision=6, suppress_small=True), \
#         (t2-t1) * 1e-6, (t3-t2) * 1e-6, w1, w2, p2

def array_str(arr, max_line_width=None, precision=None, suppress_small=None):
    """Returns the string representation of the content of an array.

    Args:
        arr (array_like): Input array. It should be able to feed to
            :func:`cupy.asnumpy`.
        max_line_width (int): The maximum number of line lengths.
        precision (int): Floating point precision. It uses the current printing
            precision of NumPy.
        suppress_small (bool): If ``True``, very small number are printed as
            zeros.

    .. seealso:: :func:`numpy.array_str`

    """
    return numpy.array_str(cupy.asnumpy(arr), max_line_width, precision,
                           suppress_small)

def insert_data(self,tablename,clmn):
        lenr = len(clmn)
        if lenr == 0:
            print('go')
            return
        lenc = len(clmn[0])
        sqlline =''
        for indr in range(lenr):
            #print(np.array_str(clmn[indr]).replace('[','').replace(']','').replace(' ',','))
            sqlline = np.array_str(clmn[indr]).replace('[','').replace(']','').replace(' ',',')
            sql = 'insert into '+tablename+' VALUES ('+ sqlline+');'
            #print(sql)
            try:
                # print('insert into '+tablename+' VALUES ('+ sqlline+');')
                self.cur.execute(sql)
            except Exception as e:
                print('err:',e)
            sqlline=''
        return

def array_str(arr, max_line_width=None, precision=None, suppress_small=None):
    """Returns the string representation of the content of an array.

    Args:
        arr (array_like): Input array. It should be able to feed to
            :func:`cupy.asnumpy`.
        max_line_width (int): The maximum number of line lengths.
        precision (int): Floating point precision. It uses the current printing
            precision of NumPy.
        suppress_small (bool): If ``True``, very small number are printed as
            zeros.

    .. seealso:: :func:`numpy.array_str`

    """
    return numpy.array_str(cupy.asnumpy(arr), max_line_width, precision,
                           suppress_small)

def predict():
    # get data from drawing canvas and save as image
    parseImage(request.get_data())

    # read parsed image back in 8-bit, black and white mode (L)
    x = imread('output.png', mode='L')
    x = np.invert(x)
    x = imresize(x,(28,28))

    # reshape image data for use in neural network
    x = x.reshape(1,28,28,1)
    with graph.as_default():
        out = model.predict(x)
        print(out)
        print(np.argmax(out, axis=1))
        response = np.array_str(np.argmax(out, axis=1))
        return response

def __str__(self):
        s  = '=======================================\n'
        s += 'classname        : %s\n'          %self.__class__.__name__
        s += 'sample rate      : %.1f [Hz]\n'   %self.fs
        s += 'channels         : %i\n'          %self.ch
        s += 'duration         : %.3f [s]\n'    %self.duration
        s += 'datatype         : %s\n'          %self.samples.dtype
        s += 'samples per ch   : %i\n'          %self.nofsamples
        s += 'data size        : %.3f [Mb]\n'   %(self.samples.nbytes/(1024*1024))
        s += 'has comment      : %s\n'          %('yes' if len(self._comment)!=0 else 'no')
        if self.ch != 0:
            # += '-----------------:---------------------\n'
            s += 'peak             : %s\n'  %np.array_str(self.peak()[0],
                                                          precision=4, suppress_small=True)
            s += 'RMS              : %s\n'  %np.array_str(self.rms(),
                                                          precision=4, suppress_small=True)
            s += 'crestfactor      : %s\n'  %np.array_str(self.crest_factor(),
                                                          precision=4, suppress_small=True)
        s += '-----------------:---------------------\n'
        return s

def predictAisMeasurements(self, scanTime, aisMeasurements):
        import pymht.models.pv as model
        import pymht.utils.kalman as kalman
        assert len(aisMeasurements) > 0
        aisPredictions = AisMessageList(scanTime)
        scanTimeString = datetime.datetime.fromtimestamp(scanTime).strftime("%H:%M:%S.%f")
        for measurement in aisMeasurements:
            aisTimeString = datetime.datetime.fromtimestamp(measurement.time).strftime("%H:%M:%S.%f")
            log.debug("Predicting AIS (" + str(measurement.mmsi) + ") from " + aisTimeString + " to " + scanTimeString)
            dT = scanTime - measurement.time
            assert dT >= 0
            state = measurement.state
            A = model.Phi(dT)
            Q = model.Q(dT)
            x_bar, P_bar = kalman.predict(A, Q, np.array(state, ndmin=2),
                                          np.array(measurement.covariance, ndmin=3))
            aisPredictions.measurements.append(
                AIS_prediction(model.C_RADAR.dot(x_bar[0]),
                               model.C_RADAR.dot(P_bar[0]).dot(model.C_RADAR.T), measurement.mmsi))
            log.debug(np.array_str(state) + "=>" + np.array_str(x_bar[0]))
            aisPredictions.aisMessages.append(measurement)
        assert len(aisPredictions.measurements) == len(aisMeasurements)
        return aisPredictions

def get_moving_average(x, n, type_str):
    #compute an n period moving average.
    #type is 'simple' | 'exponential'
    my_list=[]
    x = np.asarray(x)
    if type_str == 'simple':
        weights = np.ones(n)
    elif type_str == 'exponential':
        weights = np.exp(np.linspace(-1., 0., n))
    elif type_str == 'weight':
        weights = np.flipud(np.arange(1,n+1, dtype=float))
    weights /= weights.sum()

    a = np.convolve(x, weights, mode='full')[:len(x)]
    a[:n] = a[n]
    for i in xrange (0, len(a), 1):
        my_list.append(np.array_str(a[i]))
    return my_list

def __repr__(self):
        s = super().__repr__()
        s += f'Chains num: {self.chains_num}\n'
        s += f'Batch size: {self.batch_size}\n'
        s += f'Position size: {self.position_size}\n'
        s += f'Precisions: noise = {self.noise_precision}, weights = {self.weights_precision}\n'
        s += f'Resample precision: noise = {self.resample_noise_precision}, '
        s += f'weights = {self.resample_weights_precision}\n'
        s += f'Burn in: {self.burn_in}\n'
        s += f'Seek step sizes: {self.seek_step_sizes}\n'
        s += f'Anneal step sizes: {self.anneal_step_sizes}\n'
        s += f'Fade in velocities: {self.fade_in_velocities}\n'
        s += 'Step sizes: {}\n'.format(np.array_str(self.step_sizes).replace('\n', ''))
        s += 'Step probabilities: {}\n'.format(np.array_str(self.step_probabilities).replace('\n', ''))
        return s

def Sign(**kwargs):
    '''
    Algorithm 1, Pg 12 of BLISS paper
    o/p:
    z,c 
    '''
    msg, A, S, m, n, sd, q, M, kappa = kwargs['msg'], kwargs['A'], kwargs['S'], kwargs['m'], kwargs['n'], kwargs['sd'], kwargs['q'], kwargs['M'], kwargs['kappa']
    m_bar = m + n
    D = DiscreteGaussianDistributionLatticeSampler(ZZ**m_bar, sd)
    count = 0
    while(True):
        y = np.array(D()) # m' x 1 
        reduced_Ay = util.vector_to_Zq(np.matmul(A, y), 2*q)
        c = hash_iterative(np.array_str(reduced_Ay) + msg, n, kappa) # still not the hash but this is test run      
        b = util.crypt_secure_randint(0, 1)
        Sc = np.matmul(S,c)
        z = y + ((-1)**b) * Sc
        try:            
            exp_term = exp(float(Sc.dot(Sc)) / (2*sd**2))
            cosh_term = np.cosh(float(z.dot(Sc)) / (sd**2))
            val = exp_term / (cosh_term * M)                
        except OverflowError:
            print "OF"          
            continue            
        if(random.random() < min(val, 1.0)):
            break
        if(count > 10): # beyond 4 rejection sampling iterations are not expected in general 
            raise ValueError("The number of rejection sampling iterations are more than expected")
        count += 1                              
    return z, c

def Verify(**kwargs):
    msg, A, m, n, sd, q, eta, z, c, kappa = kwargs['msg'], kwargs['A'], kwargs['m'], kwargs['n'], kwargs['sd'], kwargs['q'], kwargs['eta'], kwargs['z'], kwargs['c'], kwargs['kappa']
    B2 = eta*sd*np.sqrt(m)
    reduced_prod = util.vector_to_Zq(np.matmul(A,z) + q*c, 2*q)
    #print np.sqrt(z.dot(z)),B2
    #print LA.norm(z,np.inf),float(q)/4
    if np.sqrt(z.dot(z)) > B2  or LA.norm(z,np.inf) >= float(q)/4:      
        return False    
    if np.array_equal(c, hash_iterative(np.array_str(reduced_prod)+msg, n, kappa)):
        return True
    return False

def hash_to_baseb(matrix, message, b, k):
    '''
        i/p: 
            matrix : numpy array to be hashed
            message : string that the sender sends  

        o/p: 
            list with k elements each b/w 0 to b-1
    '''
    hexval = hl.sha512(np.array_str(matrix) + message).hexdigest() # returns a string with 128 hex digits
    return np.array(map(int, list(b2b(hexval, 16, b)[:k])))  # returns first k digits from hexval in a list

# this list of symbols allows conversion of numbers represented until base 36

def _nn_pose_fill(valid): 
        """
        Looks up closest True for each False and returns
        indices for fill-in-lookup
        In: [True, False, True, ... , False, True]
        Out: [0, 0, 2, ..., 212, 212]
        """

        valid_inds,  = np.where(valid)
        invalid_inds,  = np.where(~valid)

        all_inds = np.arange(len(valid))
        all_inds[invalid_inds] = -1

        for j in range(10): 
            fwd_inds = valid_inds + j
            bwd_inds = valid_inds - j

            # Forward fill
            invalid_inds, = np.where(all_inds < 0)
            fwd_fill_inds = np.intersect1d(fwd_inds, invalid_inds)
            all_inds[fwd_fill_inds] = all_inds[fwd_fill_inds-j]

            # Backward fill
            invalid_inds, = np.where(all_inds < 0)
            if not len(invalid_inds): break
            bwd_fill_inds = np.intersect1d(bwd_inds, invalid_inds)
            all_inds[bwd_fill_inds] = all_inds[bwd_fill_inds+j]

            # Check if any missing 
            invalid_inds, = np.where(all_inds < 0)
            if not len(invalid_inds): break

        # np.set_printoptions(threshold=np.nan)

        # print valid.astype(np.int)
        # print np.array_str(all_inds)
        # print np.where(all_inds < 0)

        return all_inds

def __repr__(self):
        return 'rpy (rxyz): %s tvec: %s' % \
            (np.array_str(self.quat.to_rpy(axes='rxyz'), precision=2, suppress_small=True), 
             np.array_str(self.tvec, precision=2, suppress_small=True))
        # return 'quat: %s, tvec: %s' % (self.quat, self.tvec)

def __repr__(self):
        return 'real: %s dual: %s' % \
            (np.array_str(self.real, precision=2, suppress_small=True), 
             np.array_str(self.dual, precision=2, suppress_small=True))

def __repr__(self): 
        return 'Pose ID: %i, rpy (rxyz): %s tvec: %s' % \
            (self.id, 
             np.array_str(self.quat.to_rpy(axes='rxyz'), precision=2), 
             np.array_str(self.tvec, precision=2))

def __str__(self):
        return 'Metadata : ' + ' '.join(map(str, self.metadata)) + '\n' + \
            "Pose : " + "\n" + np.array_str(self.pose)

def predict():
    #whenever the predict method is called, we're going
    #to input the user drawn character as an image into the model
    #perform inference, and return the classification
    #get the raw data format of the image
    imgData = request.get_data()
    #encode it into a suitable format
    convertImage(imgData)
    print "debug"
    #read the image into memory
    x = imread('output.png',mode='L')
    #compute a bit-wise inversion so black becomes white and vice versa
    x = np.invert(x)
    #make it the right size
    x = imresize(x,(28,28))
    #imshow(x)
    #convert to a 4D tensor to feed into our model
    x = x.reshape(1,28,28,1)
    print "debug2"
    #in our computation graph
    with graph.as_default():
        #perform the prediction
        out = model.predict(x)
        print(out)
        print(np.argmax(out,axis=1))
        print "debug3"
        #convert the response to a string
        response = np.array_str(np.argmax(out,axis=1))
        return response

def analysis(N, M, I, L, sqrt=False):
    """
    Conduct a Kalman filter validation experiment. Output results
    (concerning the error, i.e., x_hat - x) for the last time step
    only. If *sqrt* use the square root form Kalman filter.
    """
    sim = setup_random_test(N, M, I, L)
    if sqrt:
        post = sqrt_kf_sim(sim)
    else:
        post = kf_sim(sim)
    # output statistics of \hat{x}_{I|I}
    error_I = []
    for l in range(sim['L']):
        error_I.append(post[l]['error'][-1])
    E_I = NP.stack(error_I, 1)
    E_I_mean = NP.mean(E_I, 1)
    P_I = NP.cov(E_I)
    print('Mean of error at time step I={}'.format(I))
    for E_I_mean_n in E_I_mean:
        print('{:9.2e}'.format(E_I_mean_n))
    print('')
    print('True posterior covariance at time step I')
    print(NP.array_str(post['P'][-1], precision=2))
    print('')
    print('Empirical posterior covariance at time step I')
    print(NP.array_str(P_I, precision=2))
    return sim, post

def debug_embeddingd(model, when, logger):  
    embeddings_tensor = tflearn.variables.get_layer_variables_by_name('embedding')[0]
    w = model.get_weights(embeddings_tensor)
    for line in w:
        logger.log(np.array_str(line), logname=when, maxlogs=10)

def PrintParams(self, lat, lon):

        sn, se, su = ct2lg(self.sin[0:self.frequencies], self.sin[self.frequencies:self.frequencies * 2], self.sin[self.frequencies * 2:self.frequencies * 3], lat, lon)
        cn, ce, cu = ct2lg(self.cos[0:self.frequencies], self.cos[self.frequencies:self.frequencies * 2], self.cos[self.frequencies * 2:self.frequencies * 3], lat, lon)

        # calculate the amplitude of the components
        an = np.sqrt(np.square(sn) + np.square(cn))
        ae = np.sqrt(np.square(se) + np.square(ce))
        au = np.sqrt(np.square(su) + np.square(cu))

        return 'Periodic amp [annual semi] N: %s E: %s U: %s [mm]' % (
            np.array_str(an * 1000.0, precision=1), np.array_str(ae * 1000.0, precision=1),
            np.array_str(au * 1000.0, precision=1))

def test_array_str_64bit(self, level=rlevel):
        # Ticket #501
        s = np.array([1, np.nan], dtype=np.float64)
        with np.errstate(all='raise'):
            np.array_str(s)  # Should succeed

def test_array_str(self):
        a = testing.shaped_arange((2, 3, 4), cupy)
        b = testing.shaped_arange((2, 3, 4), numpy)
        self.assertEqual(cupy.array_str(a), numpy.array_str(b))

def get_label(self, output,min_accuracy=0.6):
        counts = np.bincount(output)
        accuracy = (np.amax(counts)/output.shape[0])
        if self.verbose:
            self.message += "\nCounts: %s" %np.array_str(counts)
            self.message += "\nAccuracy: %.2f%%" %(accuracy*100)
        if accuracy < min_accuracy:
            self.message += "\nWho the fuck are you"
        else:
            self.message += "\nThe user is %s" %self.users[np.argmax(counts)]

        return self.message
    # set for delta mode

def write_pose_pair_to_csv_line(self, pose_pair_idx):

    singular_values = self.singular_values[pose_pair_idx]

    return "{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{}\n".format(
        self.algorithm_name,
        pose_pair_idx,
        self.iteration_num,
        self.prefiltering_enabled,
        self.dataset_names[pose_pair_idx][0],
        self.dataset_names[pose_pair_idx][1],
        self.success[pose_pair_idx],
        self.rmse[pose_pair_idx][0],
        self.rmse[pose_pair_idx][1],
        self.num_inliers[pose_pair_idx],
        self.num_initial_poses[pose_pair_idx],
        self.num_poses_kept[pose_pair_idx],
        self.runtimes[pose_pair_idx],
        self.loop_error_position,
        self.loop_error_orientation,
        ("" if singular_values is None else np.array_str(
            singular_values, max_line_width=1000000)),
        self.bad_singular_value[pose_pair_idx],
        self.optimization_enabled,
        self.optimization_success[pose_pair_idx],
        self.optimization_runtime[pose_pair_idx],
        self.spoiled_initial_guess_angle_offset[pose_pair_idx],
        (None if self.spoiled_initial_guess_translation_offset[pose_pair_idx] is None else np.array_str(
            self.spoiled_initial_guess_translation_offset[pose_pair_idx], max_line_width=1000000)),
        self.spoiled_initial_guess_time_offset[pose_pair_idx])

def binary_superset(n, indices):
    superset = np.zeros(max(indices)+1, dtype=int)
    print(list(bin(n)[2:]))
    superset[indices] = list(bin(n)[2:])
    print(superset)
    return int(np.array_str(superset)[1:-1:2], 2)

def __init__(self, volume, shape, label_margin=None):
            self.volume = volume
            self.shape = shape
            self.margin = np.floor_divide(self.shape, 2).astype(np.int64)
            if label_margin is None:
                label_margin = np.zeros(3, dtype=np.int64)
            self.label_margin = label_margin
            self.skip_blank_sections = True
            self.ctr_min = self.margin
            self.ctr_max = (np.array(self.volume.shape) - self.margin - 1).astype(np.int64)
            self.random = np.random.RandomState(CONFIG.random_seed)

            # If the volume has a mask channel, further limit ctr_min and
            # ctr_max to lie inside a margin in the AABB of the mask.
            if self.volume.mask_data is not None:
                mask_min, mask_max = self.volume.mask_bounds

                mask_min = self.volume.local_coord_to_world(mask_min)
                mask_max = self.volume.local_coord_to_world(mask_max)

                self.ctr_min = np.maximum(self.ctr_min, mask_min + self.label_margin)
                self.ctr_max = np.minimum(self.ctr_max, mask_max - self.label_margin - 1)

            if np.any(self.ctr_min >= self.ctr_max):
                raise ValueError('Cannot generate subvolume bounds: bounds ({}, {}) too small for shape ({})'.format(
                                 np.array_str(self.ctr_min), np.array_str(self.ctr_max), np.array_str(self.shape)))

def get_largest_component(self, closing_shape=None):
        mask, bounds = self._get_bounded_mask(closing_shape)

        label_im, num_labels = ndimage.label(mask)
        label_sizes = ndimage.sum(mask, label_im, range(num_labels + 1))
        label_im[(label_sizes < label_sizes.max())[label_im]] = 0
        label_im = np.minimum(label_im, 1)

        if label_im[tuple(self.seed - bounds[0])] == 0:
            logging.warning('Seed voxel ({}) is not in connected component.'.format(np.array_str(self.seed)))

        return label_im, bounds

def get_seeded_component(self, closing_shape=None):
        mask, bounds = self._get_bounded_mask(closing_shape)

        label_im, _ = ndimage.label(mask)
        seed_label = label_im[tuple(self.seed - bounds[0])]
        if seed_label == 0:
            raise ValueError('Seed voxel (%s) is not in body.', np.array_str(self.seed))
        label_im[label_im != seed_label] = 0
        label_im[label_im == seed_label] = 1

        return label_im, bounds

def to_swc(self, filename):
        component, bounds = self.get_largest_component(closing_shape=CONFIG.postprocessing.closing_shape)
        print('Skeleton is within {}, {}'.format(np.array_str(bounds[0]), np.array_str(bounds[1])))
        skel = skeletonize_component(component)
        swc = skeleton_to_swc(skel, bounds[0], CONFIG.volume.resolution)
        with open(filename, 'w') as swcfile:
            writer = csv.writer(swcfile, delimiter=' ', quoting=csv.QUOTE_NONE)
            writer.writerows(swc)