Cumulative sum of the relative probabilities for all possible jumps.

        Args:
            None

        Returns:
            (np.array): Cumulative sum of relative jump probabilities.
187461
def cumulative_probabilities( self ):
        
        partition_function = np.sum( self.p )
        return np.cumsum( self.p ) / partition_function
1292452
def floats(self, n: int = 2) -> List[float]:
        
        nums = [self.random.random()
                for _ in range(10 ** int(n))]
        return nums
1256349
def sum_of_reoccurring_data_points(x):
    
    unique, counts = np.unique(x, return_counts=True)
    counts[counts < 2] = 0
    return np.sum(counts * unique)
1332176
def symmetrized(self):
        
        perms = list(itertools.permutations(range(self.rank)))
        return sum([np.transpose(self, ind) for ind in perms]) / len(perms)
355410
def sum_over_energy(self):
        
        # We sum over axis 0 in the array, and drop the energy binning in the
        # hpx object
        return HpxMap(np.sum(self.counts, axis=0), self.hpx.copy_and_drop_energy())
348541
def sum_coefs(self):
        """"""
        return numpy.sum(self.ar_coefs) + numpy.sum(self.ma_coefs)
525782
def probability(self, direction, mechanism, purview):
        
        repertoire = self.repertoire(direction, mechanism, purview)

        return self.state_probability(direction, repertoire, purview)
159448
def generate_nearest_neighbour_lookup_table( self ):
        
        self.jump_probability = {}
        for site_label_1 in self.connected_site_pairs:
            self.jump_probability[ site_label_1 ] = {}
            for site_label_2 in self.connected_site_pairs[ site_label_1 ]:
                self.jump_probability[ site_label_1 ][ site_label_2 ] = {}
                for coordination_1 in range( self.max_coordination_per_site[ site_label_1 ] ):
                    self.jump_probability[ site_label_1 ][ site_label_2 ][ coordination_1 ] = {}
                    for coordination_2 in range( 1, self.max_coordination_per_site[ site_label_2 ] + 1 ):
                        self.jump_probability[ site_label_1 ][ site_label_2 ][ coordination_1 ][ coordination_2 ] = self.relative_probability( site_label_1, site_label_2, coordination_1, coordination_2 )
1001743
def sum(self):
        
        results = [x.ufuncs.sum() for x in self.elem]
        return np.sum(results)
990298
def find_cumulative_indices(list_of_numbers, search_sum):
    
    u = 0
    y = 0
    result = []
    for idx, val in enumerate(list_of_numbers):
        y += list_of_numbers[idx]
        while y >= search_sum:
            if y == search_sum:
                result.append(range(u, idx+1))
            y -= list_of_numbers[u]
            u += 1
    # if matches are not found, empty string is returned
    # for easier cell data handling on pandas dataframe
    return result or ''
1267479
def v(self):
        
        v = np.zeros(self.N, dtype=np.uint8)
        v[self.indices] = 1
        return v
977953
def sumvalues(self, q=0):
        
        if q == 0:
            return self._totalf
        else:
            return -np.partition(-self._freq_list, q)[:q].sum()
699123
def confidence_interval_cumulative_density_(self):
        
        return self._compute_confidence_bounds_of_transform(self._cumulative_density, self.alpha, self._ci_labels)
184276
def probabilities(self, angles: List[float]) -> np.ndarray:
        
        if isinstance(angles, list):
            angles = np.array(angles)

        assert angles.shape[0] == 2 * self.steps, "angles must be 2 * steps"

        param_prog = self.get_parameterized_program()
        prog = param_prog(angles)
        wf = WavefunctionSimulator().wavefunction(prog)
        wf = wf.amplitudes.reshape((-1, 1))
        probs = np.zeros_like(wf)
        for xx in range(2 ** len(self.qubits)):
            probs[xx] = np.conj(wf[xx]) * wf[xx]
        return probs
256665
def sum(self, weights=None):
        
        if weights is None:
            weights = self.data.weights
        return utils.bincount(self.labels, weights, self.N)
1162933
def getTopLeft(self):
        
        return (float(self.get_cx()) - float(self.get_rx()), float(self.get_cy()) + float(self.get_ry()))
428895
def weights(value):
    
    probs = probabilities(value)
    if abs(sum(probs) - 1.) > PRECISION:
        raise ValueError('The weights do not sum up to 1: %s' % probs)
    return probs