def csum(arrays, dtype = None, ignore_nan = False):
"""
CUDA-enabled sum of stream of arrays. Arrays are summed along
the streaming axis for performance reasons.
Parameters
----------
arrays : iterable
Arrays to be summed.
ignore_nan : bool, optional
If True, NaNs are ignored. Default is propagation of NaNs.
Returns
-------
cuda_sum : ndarray
See Also
--------
isum : streaming sum of array elements, possibly along different axes
"""
return cuda_inplace_reduce(arrays, operator = iadd, dtype = dtype,
ignore_nan = ignore_nan, identity = 0)
python类iadd()的实例源码
def _test_quantity_iadd_isub(self, unit, func):
x = self.Q_(unit, 'centimeter')
y = self.Q_(unit, 'inch')
z = self.Q_(unit, 'second')
a = self.Q_(unit, None)
func(op.iadd, x, x, self.Q_(unit + unit, 'centimeter'))
func(op.iadd, x, y, self.Q_(unit + 2.54 * unit, 'centimeter'))
func(op.iadd, y, x, self.Q_(unit + unit / 2.54, 'inch'))
func(op.iadd, a, unit, self.Q_(unit + unit, None))
self.assertRaises(DimensionalityError, op.iadd, 10, x)
self.assertRaises(DimensionalityError, op.iadd, x, 10)
self.assertRaises(DimensionalityError, op.iadd, x, z)
func(op.isub, x, x, self.Q_(unit - unit, 'centimeter'))
func(op.isub, x, y, self.Q_(unit - 2.54, 'centimeter'))
func(op.isub, y, x, self.Q_(unit - unit / 2.54, 'inch'))
func(op.isub, a, unit, self.Q_(unit - unit, None))
self.assertRaises(DimensionalityError, op.sub, 10, x)
self.assertRaises(DimensionalityError, op.sub, x, 10)
self.assertRaises(DimensionalityError, op.sub, x, z)
def test_inplace_addition(self, input_tuple, expected):
self.ureg.autoconvert_offset_to_baseunit = False
(q1v, q1u), (q2v, q2u) = input_tuple
# update input tuple with new values to have correct values on failure
input_tuple = ((np.array([q1v]*2, dtype=np.float), q1u),
(np.array([q2v]*2, dtype=np.float), q2u))
Q_ = self.Q_
qin1, qin2 = input_tuple
q1, q2 = Q_(*qin1), Q_(*qin2)
q1_cp = copy.copy(q1)
if expected == 'error':
self.assertRaises(OffsetUnitCalculusError, op.iadd, q1_cp, q2)
else:
expected = np.array([expected[0]]*2, dtype=np.float), expected[1]
self.assertEqual(op.iadd(q1_cp, q2).units, Q_(*expected).units)
q1_cp = copy.copy(q1)
self.assertQuantityAlmostEqual(op.iadd(q1_cp, q2), Q_(*expected),
atol=0.01)
def __iadd__(self, other):
'''
In-place add features from two FeatureCollections.
>>> fc1 = FeatureCollection({'foo': Counter('abbb')})
>>> fc2 = FeatureCollection({'foo': Counter('bcc')})
>>> fc1 += fc2
FeatureCollection({'foo': Counter({'b': 4, 'c': 2, 'a': 1})})
Note that if a feature in either of the collections is not an
instance of :class:`collections.Counter`, then it is ignored.
'''
if self.read_only:
raise ReadOnlyException()
fc = self.merge_with(other, operator.iadd)
self._features = fc._features
return self
def __iadd__(self, other):
if isinstance(other, datetime.datetime):
return self.to_timedelta() + other
elif not isinstance(self._magnitude, ndarray):
return self._add_sub(other, operator.add)
else:
return self._iadd_sub(other, operator.iadd)
def test_issue52(self):
u1 = UnitRegistry()
u2 = UnitRegistry()
q1 = 1*u1.meter
q2 = 1*u2.meter
import operator as op
for fun in (op.add, op.iadd,
op.sub, op.isub,
op.mul, op.imul,
op.floordiv, op.ifloordiv,
op.truediv, op.itruediv):
self.assertRaises(ValueError, fun, q1, q2)
def operate(self, items, op=operator.iadd, cleanup=True):
d = udict(self._d)
for key, value in items:
d[key] = op(d[key], value)
if cleanup:
keys = [key for key, value in d.items() if value == 0]
for key in keys:
del d[key]
return self.__class__(self.scale, d)
def hl_join(segments):
return reduce(operator.iadd, segments, [])
def test_iadd_scalar(self):
self.check_array_scalar_op(operator.iadd)
def test_iadd_array(self):
self.check_array_array_op(operator.iadd)
def test_broadcasted_iadd(self):
self.check_array_broadcasted_op(operator.iadd)
def as_list(self):
"""Very efficiently convert the SortedList to a list."""
return reduce(iadd, self._lists, [])
def as_list(self):
"""Very efficiently convert the SortedList to a list."""
return reduce(iadd, self._lists, [])
def as_list(self):
"""Very efficiently convert the SortedList to a list."""
return reduce(iadd, self._lists, [])
def as_list(self):
"""Very efficiently convert the SortedList to a list."""
return reduce(iadd, self._lists, [])
def test_iadd_scalar(self):
self.check_array_scalar_op(operator.iadd)
def test_iadd_array(self):
self.check_array_array_op(operator.iadd)
def test_broadcasted_iadd(self):
self.check_array_broadcasted_op(operator.iadd)
def __add__(self, that):
"""
Return a new sorted list containing all the elements in *self* and
*that*. Elements in *that* do not need to be properly ordered with
respect to *self*.
"""
values = reduce(iadd, self._lists, [])
values.extend(that)
return self.__class__(values, load=self._load)
def __mul__(self, that):
"""
Return a new sorted list containing *that* shallow copies of each item
in SortedList.
"""
values = reduce(iadd, self._lists, []) * that
return self.__class__(values, load=self._load)
def __imul__(self, that):
"""
Increase the length of the list by appending *that* shallow copies of
each item.
"""
values = reduce(iadd, self._lists, []) * that
self._clear()
self._update(values)
return self
def __add__(self, that):
"""
Return a new sorted list containing all the elements in *self* and
*that*. Elements in *that* do not need to be properly ordered with
respect to *self*.
"""
values = reduce(iadd, self._lists, [])
values.extend(that)
return self.__class__(values, key=self._key, load=self._load)
def __imul__(self, that):
"""
Increase the length of the list by appending *that* shallow copies of
each item.
"""
values = reduce(iadd, self._lists, []) * that
self._clear()
self._update(values)
return self
def __add__(self, that):
"""
Return a new sorted list containing all the elements in *self* and
*that*. Elements in *that* do not need to be properly ordered with
respect to *self*.
"""
values = reduce(iadd, self._lists, [])
values.extend(that)
return self.__class__(values, load=self._load)
def __mul__(self, that):
"""
Return a new sorted list containing *that* shallow copies of each item
in SortedList.
"""
values = reduce(iadd, self._lists, []) * that
return self.__class__(values, load=self._load)
def __imul__(self, that):
"""
Increase the length of the list by appending *that* shallow copies of
each item.
"""
values = reduce(iadd, self._lists, []) * that
self._clear()
self._update(values)
return self
def __mul__(self, that):
"""
Return a new sorted list containing *that* shallow copies of each item
in SortedListWithKey.
"""
values = reduce(iadd, self._lists, []) * that
return self.__class__(values, key=self._key, load=self._load)
def __imul__(self, that):
"""
Increase the length of the list by appending *that* shallow copies of
each item.
"""
values = reduce(iadd, self._lists, []) * that
self._clear()
self._update(values)
return self
def __add__(self, that):
"""
Return a new sorted list containing all the elements in *self* and
*that*. Elements in *that* do not need to be properly ordered with
respect to *self*.
"""
values = reduce(iadd, self._lists, [])
values.extend(that)
return self.__class__(values, load=self._load)
def __mul__(self, that):
"""
Return a new sorted list containing *that* shallow copies of each item
in SortedList.
"""
values = reduce(iadd, self._lists, []) * that
return self.__class__(values, load=self._load)
