我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用numpy.find_common_type()。
def upcast_float16_ufunc(fn): """Decorator that enforces computation is not done in float16 by NumPy. Some ufuncs in NumPy will compute float values on int8 and uint8 in half-precision (float16), which is not enough, and not compatible with the C code. :param fn: numpy ufunc :returns: function similar to fn.__call__, computing the same value with a minimum floating-point precision of float32 """ def ret(*args, **kwargs): out_dtype = numpy.find_common_type( [a.dtype for a in args], [numpy.float16]) if out_dtype == 'float16': # Force everything to float32 sig = 'f' * fn.nin + '->' + 'f' * fn.nout kwargs.update(sig=sig) return fn(*args, **kwargs) return ret
def __init__(self,value,site,tag,matrix): ''' Constructor. Parameters ---------- value : number The overall coefficient of the single site operator. site : Label The site label of the single site operator. tag : any hashable object The tag of the single operator. matrix : 2d ndarray The matrix of the single site operator. ''' assert matrix.ndim==2 dtype=np.find_common_type([np.asarray(value).dtype,np.asarray(matrix).dtype],[]) self.value=np.array(value,dtype=dtype) self.site=site self.tag=tag self.matrix=np.asarray(matrix,dtype=dtype)
def __iadd__(self,other): ''' Overloaded self addition(+) operator, which supports the self addition by an instance of Opt. ''' assert other.site==self.site if self.tag=='0': return other elif other.tag=='0': return self else: if self.tag==other.tag: self.value+=other.value else: self.value=np.array(1.0,dtype=np.find_common_type([self.value.dtype,other.value.dtype],[])) self.tag='%s(%s)+%s(%s)'%(self.value,self.tag,other.value,other.tag) self.matrix*=self.value self.matrix+=other.value*other.matrix return self
def block_diag(*ms): ''' Create a block diagonal matrix from provided ones. Parameters ---------- ms : list of 2d ndarray The input matrices. Returns ------- 2d ndarray The constructed block diagonal matrix. ''' if len(ms)==0: ms=[np.zeros((0,0))] shapes=np.array([a.shape for a in ms]) dtype=np.find_common_type([m.dtype for m in ms],[]) result=np.zeros(np.sum(shapes,axis=0),dtype=dtype) r,c=0,0 for i,(cr,cc) in enumerate(shapes): result[r:r+cr,c:c+cc]=ms[i] r+=cr c+=cc return result
def test_find_common_type_boolean(self): # Ticket #1695 assert_(np.find_common_type([], ['?', '?']) == '?')
def test_scalar_loses1(self): res = np.find_common_type(['f4', 'f4', 'i2'], ['f8']) assert_(res == 'f4')
def test_scalar_loses2(self): res = np.find_common_type(['f4', 'f4'], ['i8']) assert_(res == 'f4')
def test_scalar_wins(self): res = np.find_common_type(['f4', 'f4', 'i2'], ['c8']) assert_(res == 'c8')
def test_scalar_wins2(self): res = np.find_common_type(['u4', 'i4', 'i4'], ['f4']) assert_(res == 'f8')
def test_where_type(self): # Test the type conservation with where x = np.arange(4, dtype=np.int32) y = np.arange(4, dtype=np.float32) * 2.2 test = where(x > 1.5, y, x).dtype control = np.find_common_type([np.int32, np.float32], []) assert_equal(test, control)
def _cast_common_type(*xs): dtypes = [x.dtype for x in xs if x is not None] dtype = numpy.find_common_type(dtypes, []) return [x.astype(dtype) if x is not None and x.dtype != dtype else x for x in xs]
def slogdet(a): """Returns sign and logarithm of the determinat of an array. It calculates the natural logarithm of the deteminant of a given value. Args: a (cupy.ndarray): The input matrix with dimension ``(..., N, N)``. Returns: tuple of :class:`~cupy.ndarray`: It returns a tuple ``(sign, logdet)``. ``sign`` represents each sign of the deteminant as a real number ``0``, ``1`` or ``-1``. 'logdet' represents the natural logarithm of the absolute of the deteminant. If the deteninant is zero, ``sign`` will be ``0`` and ``logdet`` will be ``-inf``. The shapes of both ``sign`` and ``logdet`` are equal to ``a.shape[:-2]``. .. seealso:: :func:`numpy.linalg.slogdet` """ if not cuda.cusolver_enabled: raise RuntimeError('Current cupy only supports cusolver in CUDA 8.0') if a.ndim < 2: msg = ('%d-dimensional array given. ' 'Array must be at least two-dimensional' % a.ndim) raise linalg.LinAlgError(msg) dtype = numpy.find_common_type((a.dtype.char, 'f'), ()) shape = a.shape[:-2] sign = cupy.empty(shape, dtype) logdet = cupy.empty(shape, dtype) a = a.astype(dtype) for index in numpy.ndindex(*shape): s, l = _slogdet_one(a[index]) sign[index] = s logdet[index] = l return sign, logdet
def _get_dtype(operators, dtypes=None): if dtypes is None: dtypes = [] for obj in operators: if obj is not None and hasattr(obj, 'dtype'): dtypes.append(obj.dtype) return np.find_common_type(dtypes, [])
def _coerce_dtype(self, other_dtype): """Possibly change the bin content type to allow correct operations with other operand. Parameters ---------- other_dtype : np.dtype or type """ new_dtype = np.find_common_type([self.dtype, np.dtype(other_dtype)], []) if new_dtype != self.dtype: self.dtype = new_dtype
def forward_cpu(self, x): a, b = x batch_size = a.shape[0] shape = self._output_shape(a, b) ret_dtype = numpy.find_common_type([a.dtype, b.dtype], []) ret = numpy.empty(shape, dtype=ret_dtype) for i in six.moves.range(batch_size): ret[i] = _matmul( a[i], b[i], transa=self.transa, transb=self.transb) return ret,
def _arith_method_PANEL(op, name, str_rep=None, fill_zeros=None, default_axis=None, **eval_kwargs): # copied from Series na_op above, but without unnecessary branch for # non-scalar def na_op(x, y): try: result = expressions.evaluate(op, str_rep, x, y, raise_on_error=True, **eval_kwargs) except TypeError: # TODO: might need to find_common_type here? result = np.empty(len(x), dtype=x.dtype) mask = notnull(x) result[mask] = op(x[mask], y) result, changed = com._maybe_upcast_putmask(result, ~mask, np.nan) result = com._fill_zeros(result, x, y, name, fill_zeros) return result # work only for scalars def f(self, other): if not isscalar(other): raise ValueError('Simple arithmetic with %s can only be ' 'done with scalar values' % self._constructor.__name__) return self._combine(other, op) f.__name__ = name return f
def test_scalar_wins3(self): # doesn't go up to 'f16' on purpose res = np.find_common_type(['u8', 'i8', 'i8'], ['f8']) assert_(res == 'f8')
def _common_dtype(x, y): """Determines common numpy DTYPE for arrays.""" dtype = np.find_common_type([x.dtype, y.dtype], []) if x.dtype != dtype: x = x.astype(dtype) if y.dtype != dtype: y = y.astype(dtype) return x, y
def _common_dtype(x, y): dtype = np.find_common_type([x.dtype, y.dtype], []) if x.dtype != dtype: x = x.astype(dtype) if y.dtype != dtype: y = y.astype(dtype) return x, y
def directsum(tensors,labels,axes=()): ''' The directsum of a couple of tensors. Parameters ---------- tensors : list of Tensor The tensors to be directsummed. labels : list of Label The labels of the directsum. axes : list of integer, optional The axes along which the directsum is block diagonal. Returns ------- Tensor The directsum of the tensors. ''' for i,tensor in enumerate(tensors): if i==0: assert tensor.ndim>len(axes) ndim,qnon,shps=tensor.ndim,tensor.qnon,[tensor.shape[axis] for axis in axes] alters,shape,dtypes=set(xrange(ndim))-set(axes),list(tensor.shape),[tensor.dtype] else: assert tensor.ndim==ndim and tensor.qnon==qnon and [tensor.shape[axis] for axis in axes]==shps for alter in alters: shape[alter]+=tensor.shape[alter] dtypes.append(tensor.dtype) data=np.zeros(tuple(shape),dtype=np.find_common_type([],dtypes)) for i,tensor in enumerate(tensors): if i==0: slices=[slice(0,tensor.shape[axis]) if axis in alters else slice(None,None,None) for axis in xrange(ndim)] else: for alter in alters: slices[alter]=slice(slices[alter].stop,slices[alter].stop+tensor.shape[alter]) data[tuple(slices)]=tensor[...] if qnon: for alter in alters: labels[alter].qns=QuantumNumbers.union([tensor.labels[alter].qns for tensor in tensors]) for axis in axes: labels[axis].qns=next(iter(tensor)).labels[axis].qns return Tensor(data,labels=labels)
def solve(A,b,rtol=10**-8): ''' Solve the matrix equation A*x=b by QR decomposition. Parameters ---------- A : 2d ndarray The coefficient matrix. b : 1d ndarray The ordinate values. rtol : np.float64 The relative tolerance of the solution. Returns ------- 1d ndarray The solution. Raises ------ LinAlgError When no solution exists. ''' assert A.ndim==2 nrow,ncol=A.shape if nrow>=ncol: result=np.zeros(ncol,dtype=np.find_common_type([],[A.dtype,b.dtype])) q,r=sl.qr(A,mode='economic',check_finite=False) temp=q.T.dot(b) for i,ri in enumerate(r[::-1]): result[-1-i]=(temp[-1-i]-ri[ncol-i:].dot(result[ncol-i:]))/ri[-1-i] else: temp=np.zeros(nrow,dtype=np.find_common_type([],[A.dtype,b.dtype])) q,r=sl.qr(dagger(A),mode='economic',check_finite=False) for i,ri in enumerate(dagger(r)): temp[i]=(b[i]-ri[:i].dot(temp[:i]))/ri[i] result=q.dot(temp) if not np.allclose(A.dot(result),b,rtol=rtol): raise sl.LinAlgError('solve error: no solution.') return result
