我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用__builtin__.sum()。
def test_zeros(self): types = np.typecodes['AllInteger'] + np.typecodes['AllFloat'] for dt in types: d = np.zeros((13,), dtype=dt) assert_equal(np.count_nonzero(d), 0) # true for ieee floats assert_equal(d.sum(), 0) assert_(not d.any()) d = np.zeros(2, dtype='(2,4)i4') assert_equal(np.count_nonzero(d), 0) assert_equal(d.sum(), 0) assert_(not d.any()) d = np.zeros(2, dtype='4i4') assert_equal(np.count_nonzero(d), 0) assert_equal(d.sum(), 0) assert_(not d.any()) d = np.zeros(2, dtype='(2,4)i4, (2,4)i4') assert_equal(np.count_nonzero(d), 0)
def dot(a1, a2): # internally: for matrix-matrix multiplies only; vectors are treated like special cases. a1 = as_garray(a1); a2 = as_garray(a2) if a1.ndim==0 or a2.ndim==0: return a1*a2 if a1.ndim==a2.ndim==1: if a1 is a2: return sum(a1**2) else: return dot(a1.reshape(1, a1.size), a2.reshape(a2.size, 1)).item() if a1.ndim==2 and a2.ndim==1: return dot(a1, a2.reshape(a2.size, 1)).ravel() # treat a2 like a column vector if a1.ndim==1 and a2.ndim==2: return dot(a1._add_axes(2), a2)[0] # treat a1 like a row vector if a1.shape[-1] != a2.shape[-2]: raise ValueError('arrays not aligned for dot product. a dot product was requested of arrays with shapes %s and %s' % (a1.shape, a2.shape)) if a1.ndim==a2.ndim==2: retShape = (a1.shape[0], a2.shape[1]) if a1.shape[1]==0: return zeros(retShape) # cudamat bug workaround ret = empty(retShape) if ret.size!=0: _cudamat.dot(a2._base_as_2d(), a1._base_as_2d(), ret._base_as_2d()) return ret if a1.ndim >= 2 and a2.ndim >= 2: # this is not necessarily fast, because if a2.ndim>=3 then it involves a transpose a12 = ( a1.reshape_2d(-1) if a1.ndim!=2 else a1) a22 = ( a2.transpose((a2.ndim-2,) + tuple(xrange(a2.ndim-2)) + (a2.ndim-1,)).reshape_2d(1) if a2.ndim!=2 else a2) retShape = _deleteT2(a1.shape, -1) + _deleteT2(a2.shape, -2) return dot(a12, a22).reshape(retShape) raise NotImplementedError('dot with arguments of shapes %s and %s' % (a1.shape, a2.shape))
def concatenate(arrays, axis=0): arrays = tuple(map(as_garray, arrays)) if axis<0: axis += arrays[0].ndim if not _isSequence(arrays) or not type(axis) in _numberTypes: raise ValueError('wrong argument types to gnumpy.concatenate: expected <arrays> to be a sequence and <axis> to be a number, but got types %s and %s.' % (type(arrays), type(axis))) if axis not in range(arrays[0].ndim): raise ValueError('bad axis number (%d) specified (the first array has %d axes)' % (axis, arrays[0].ndim)) if not _allTheSame( _deleteT2(a.shape, axis) for a in arrays): raise ValueError('array dimensions must agree except possibly for axis #%d. The given array shapes are: %s' % (axis, tuple( a.shape for a in arrays))) finalShape = _modifyT(arrays[0].shape, axis, __builtin__.sum( a.shape[axis] for a in arrays)) if axis==0: ret = empty(finalShape) nextI = 0 for a in arrays: _cm_row_slice_read(ret._base_shaped(ret.ndim), nextI, nextI+a.size).assign(a._base_shaped(a.ndim)) nextI += a.size return ret else: return concatenate(tuple([ a.reshape_2d(axis).T for a in arrays]), 0).T.reshape(finalShape)
def DownloadThrottlerThread(self): while self.threadRun: time.sleep(self.updateTime) tot_down_size_KB = float(sum(self.DOWNLOAD_RATE_LIMIT_BUFFER)/1024.0) download_speed_limit_KBps = float(Prefs['download_speed_limit']) if tot_down_size_KB > 0 and download_speed_limit_KBps > 0: tot_down_speed_KBps = round(float(tot_down_size_KB/self.updateTime), 3) if Prefs['use_debug']: Log('Download Throttler:---> Timestamp:%s | Total Down Speed: %s KB/s | Speed Limit: %s KB/s' % (time.time(), tot_down_speed_KBps, download_speed_limit_KBps)) if tot_down_speed_KBps > download_speed_limit_KBps: self.throttle = True self.throttleStateSleepTime = round(tot_down_speed_KBps/download_speed_limit_KBps,3) if Prefs['use_debug']: Log("Download Throttler:---> Sleep for %s sec." % self.throttleStateSleepTime) time.sleep(self.throttleStateSleepTime) self.reset()
def test_sum(self): d = np.ones(101, dtype=np.bool) assert_equal(d.sum(), d.size) assert_equal(d[::2].sum(), d[::2].size) assert_equal(d[::-2].sum(), d[::-2].size) d = np.frombuffer(b'\xff\xff' * 100, dtype=bool) assert_equal(d.sum(), d.size) assert_equal(d[::2].sum(), d[::2].size) assert_equal(d[::-2].sum(), d[::-2].size)
def check_count_nonzero(self, power, length): powers = [2 ** i for i in range(length)] for i in range(2**power): l = [(i & x) != 0 for x in powers] a = np.array(l, dtype=np.bool) c = builtins.sum(l) self.assertEqual(np.count_nonzero(a), c) av = a.view(np.uint8) av *= 3 self.assertEqual(np.count_nonzero(a), c) av *= 4 self.assertEqual(np.count_nonzero(a), c) av[av != 0] = 0xFF self.assertEqual(np.count_nonzero(a), c)
def test_count_nonzero_unaligned(self): # prevent mistakes as e.g. gh-4060 for o in range(7): a = np.zeros((18,), dtype=np.bool)[o+1:] a[:o] = True self.assertEqual(np.count_nonzero(a), builtins.sum(a.tolist())) a = np.ones((18,), dtype=np.bool)[o+1:] a[:o] = False self.assertEqual(np.count_nonzero(a), builtins.sum(a.tolist()))
def test_mean_values(self): for mat in [self.rmat, self.cmat, self.omat]: for axis in [0, 1]: tgt = mat.sum(axis=axis) res = _mean(mat, axis=axis) * mat.shape[axis] assert_almost_equal(res, tgt) for axis in [None]: tgt = mat.sum(axis=axis) res = _mean(mat, axis=axis) * np.prod(mat.shape) assert_almost_equal(res, tgt)
def status(): if not usingGpu(): print 'gnumpy is running on the CPU, i.e. in simulation mode. The data type is float%s.' % _precision if usingGpu(): if _boardId==None: print 'gnumpy is planning to run on a GPU, but hasn\'t yet chosen & initialized a board.' else: print 'gnumpy is running on GPU board #%d.' % _boardId print '%s of gpu memory are in use, of which at least %s can be freed immediately by gnumpy.free_reuse_cache().' % (_n_bytes_str(__memoryInUse), _n_bytes_str(__builtin__.sum( size*len(cms)*4 for size, cms in _cmsForReuse.items())))
def _rand__base(shapeInfo, distribution, zero_d_means_scalar): if len(shapeInfo)==1 and _isSequence(shapeInfo[0]): zero_d_means_scalar = False; shapeInfo = shapeInfo[0] ret = empty(shapeInfo) {'uniform': _cmType.fill_with_rand, 'normal': _cmType.fill_with_randn}[distribution](ret._base) if ret.size!=0 and _doExpensiveCheck(): assert ret.sum() < 100 + 2*ret.size, 'numerical gpu error: rand() gave a result>100' if len(shapeInfo) == 0 and zero_d_means_scalar: return ret.item() else: return ret
def sum(x, axis=None): """ On numpy arrays this returns a numpy array; on garrays and other array-likes this returns a garray. """ return _reductor__base(x, axis, garray.sum, numpy.sum)
def all_real(self): """ returns True iff all array elements are regular floats, as opposed to inf's, -inf's, and NaN's. """ return (self*0).sum()==0
def sum(self, axis=None): return self._reduction__base('sum', axis)
def mean(self, axis=None): return self.sum(axis) / ( self.size if axis==None else self.shape[axis])
def any2(self, axis=None): return self.sum(axis) > 0 # optimized for when I'm sure that the content is boolean
