Python operator.iadd() Examples
The following are 30
code examples of operator.iadd().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
operator
, or try the search function
.
Example #1
Source File: sortedlist.py From misp42splunk with GNU Lesser General Public License v3.0 | 6 votes |
def __imul__(self, num): """Update the sorted list with `num` shallow copies of values. ``sl.__imul__(num)`` <==> ``sl *= num`` Runtime complexity: `O(n*log(n))` >>> sl = SortedList('abc') >>> sl *= 3 >>> sl SortedList(['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c']) :param int num: count of shallow copies :return: existing sorted list """ values = reduce(iadd, self._lists, []) * num self._clear() self._update(values) return self
Example #2
Source File: sortedlist.py From misp42splunk with GNU Lesser General Public License v3.0 | 6 votes |
def __imul__(self, num): """Update the sorted list with `num` shallow copies of values. ``sl.__imul__(num)`` <==> ``sl *= num`` Runtime complexity: `O(n*log(n))` >>> sl = SortedList('abc') >>> sl *= 3 >>> sl SortedList(['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c']) :param int num: count of shallow copies :return: existing sorted list """ values = reduce(iadd, self._lists, []) * num self._clear() self._update(values) return self
Example #3
Source File: sortedlist.py From misp42splunk with GNU Lesser General Public License v3.0 | 6 votes |
def __add__(self, other): """Return new sorted list containing all values in both sequences. ``sl.__add__(other)`` <==> ``sl + other`` Values in `other` do not need to be in sorted order. Runtime complexity: `O(n*log(n))` >>> sl1 = SortedList('bat') >>> sl2 = SortedList('cat') >>> sl1 + sl2 SortedList(['a', 'a', 'b', 'c', 't', 't']) :param other: other iterable :return: new sorted list """ values = reduce(iadd, self._lists, []) values.extend(other) return self.__class__(values)
Example #4
Source File: sortedlist.py From misp42splunk with GNU Lesser General Public License v3.0 | 6 votes |
def __mul__(self, num): """Return new sorted list with `num` shallow copies of values. ``sl.__mul__(num)`` <==> ``sl * num`` Runtime complexity: `O(n*log(n))` >>> sl = SortedList('abc') >>> sl * 3 SortedList(['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c']) :param int num: count of shallow copies :return: new sorted list """ values = reduce(iadd, self._lists, []) * num return self.__class__(values)
Example #5
Source File: sortedlist.py From misp42splunk with GNU Lesser General Public License v3.0 | 6 votes |
def __add__(self, other): """Return new sorted list containing all values in both sequences. ``sl.__add__(other)`` <==> ``sl + other`` Values in `other` do not need to be in sorted order. Runtime complexity: `O(n*log(n))` >>> sl1 = SortedList('bat') >>> sl2 = SortedList('cat') >>> sl1 + sl2 SortedList(['a', 'a', 'b', 'c', 't', 't']) :param other: other iterable :return: new sorted list """ values = reduce(iadd, self._lists, []) values.extend(other) return self.__class__(values)
Example #6
Source File: sortedlist.py From misp42splunk with GNU Lesser General Public License v3.0 | 6 votes |
def _reset(self, load): """Reset sorted list load factor. The `load` specifies the load-factor of the list. The default load factor of 1000 works well for lists from tens to tens-of-millions of values. Good practice is to use a value that is the cube root of the list size. With billions of elements, the best load factor depends on your usage. It's best to leave the load factor at the default until you start benchmarking. See :doc:`implementation` and :doc:`performance-scale` for more information. Runtime complexity: `O(n)` :param int load: load-factor for sorted list sublists """ values = reduce(iadd, self._lists, []) self._clear() self._load = load self._update(values)
Example #7
Source File: sortedlist.py From misp42splunk with GNU Lesser General Public License v3.0 | 6 votes |
def __add__(self, other): """Return new sorted-key list containing all values in both sequences. ``skl.__add__(other)`` <==> ``skl + other`` Values in `other` do not need to be in sorted-key order. Runtime complexity: `O(n*log(n))` >>> from operator import neg >>> skl1 = SortedKeyList([5, 4, 3], key=neg) >>> skl2 = SortedKeyList([2, 1, 0], key=neg) >>> skl1 + skl2 SortedKeyList([5, 4, 3, 2, 1, 0], key=<built-in function neg>) :param other: other iterable :return: new sorted-key list """ values = reduce(iadd, self._lists, []) values.extend(other) return self.__class__(values, key=self._key)
Example #8
Source File: sortedlist.py From misp42splunk with GNU Lesser General Public License v3.0 | 6 votes |
def __imul__(self, num): """Update the sorted list with `num` shallow copies of values. ``sl.__imul__(num)`` <==> ``sl *= num`` Runtime complexity: `O(n*log(n))` >>> sl = SortedList('abc') >>> sl *= 3 >>> sl SortedList(['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c']) :param int num: count of shallow copies :return: existing sorted list """ values = reduce(iadd, self._lists, []) * num self._clear() self._update(values) return self
Example #9
Source File: sortedlist.py From misp42splunk with GNU Lesser General Public License v3.0 | 6 votes |
def __mul__(self, num): """Return new sorted list with `num` shallow copies of values. ``sl.__mul__(num)`` <==> ``sl * num`` Runtime complexity: `O(n*log(n))` >>> sl = SortedList('abc') >>> sl * 3 SortedList(['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c']) :param int num: count of shallow copies :return: new sorted list """ values = reduce(iadd, self._lists, []) * num return self.__class__(values)
Example #10
Source File: sortedlist.py From misp42splunk with GNU Lesser General Public License v3.0 | 6 votes |
def __add__(self, other): """Return new sorted list containing all values in both sequences. ``sl.__add__(other)`` <==> ``sl + other`` Values in `other` do not need to be in sorted order. Runtime complexity: `O(n*log(n))` >>> sl1 = SortedList('bat') >>> sl2 = SortedList('cat') >>> sl1 + sl2 SortedList(['a', 'a', 'b', 'c', 't', 't']) :param other: other iterable :return: new sorted list """ values = reduce(iadd, self._lists, []) values.extend(other) return self.__class__(values)
Example #11
Source File: sortedlist.py From misp42splunk with GNU Lesser General Public License v3.0 | 6 votes |
def _reset(self, load): """Reset sorted list load factor. The `load` specifies the load-factor of the list. The default load factor of 1000 works well for lists from tens to tens-of-millions of values. Good practice is to use a value that is the cube root of the list size. With billions of elements, the best load factor depends on your usage. It's best to leave the load factor at the default until you start benchmarking. See :doc:`implementation` and :doc:`performance-scale` for more information. Runtime complexity: `O(n)` :param int load: load-factor for sorted list sublists """ values = reduce(iadd, self._lists, []) self._clear() self._load = load self._update(values)
Example #12
Source File: test_quantity.py From cadquery-freecad-module with GNU Lesser General Public License v3.0 | 6 votes |
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)
Example #13
Source File: sortedlist.py From misp42splunk with GNU Lesser General Public License v3.0 | 6 votes |
def __add__(self, other): """Return new sorted-key list containing all values in both sequences. ``skl.__add__(other)`` <==> ``skl + other`` Values in `other` do not need to be in sorted-key order. Runtime complexity: `O(n*log(n))` >>> from operator import neg >>> skl1 = SortedKeyList([5, 4, 3], key=neg) >>> skl2 = SortedKeyList([2, 1, 0], key=neg) >>> skl1 + skl2 SortedKeyList([5, 4, 3, 2, 1, 0], key=<built-in function neg>) :param other: other iterable :return: new sorted-key list """ values = reduce(iadd, self._lists, []) values.extend(other) return self.__class__(values, key=self._key)
Example #14
Source File: sortedlist.py From misp42splunk with GNU Lesser General Public License v3.0 | 6 votes |
def __add__(self, other): """Return new sorted list containing all values in both sequences. ``sl.__add__(other)`` <==> ``sl + other`` Values in `other` do not need to be in sorted order. Runtime complexity: `O(n*log(n))` >>> sl1 = SortedList('bat') >>> sl2 = SortedList('cat') >>> sl1 + sl2 SortedList(['a', 'a', 'b', 'c', 't', 't']) :param other: other iterable :return: new sorted list """ values = reduce(iadd, self._lists, []) values.extend(other) return self.__class__(values)
Example #15
Source File: sortedlist.py From misp42splunk with GNU Lesser General Public License v3.0 | 6 votes |
def __mul__(self, num): """Return new sorted list with `num` shallow copies of values. ``sl.__mul__(num)`` <==> ``sl * num`` Runtime complexity: `O(n*log(n))` >>> sl = SortedList('abc') >>> sl * 3 SortedList(['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c']) :param int num: count of shallow copies :return: new sorted list """ values = reduce(iadd, self._lists, []) * num return self.__class__(values)
Example #16
Source File: sortedlist.py From misp42splunk with GNU Lesser General Public License v3.0 | 6 votes |
def _reset(self, load): """Reset sorted list load factor. The `load` specifies the load-factor of the list. The default load factor of 1000 works well for lists from tens to tens-of-millions of values. Good practice is to use a value that is the cube root of the list size. With billions of elements, the best load factor depends on your usage. It's best to leave the load factor at the default until you start benchmarking. See :doc:`implementation` and :doc:`performance-scale` for more information. Runtime complexity: `O(n)` :param int load: load-factor for sorted list sublists """ values = reduce(iadd, self._lists, []) self._clear() self._load = load self._update(values)
Example #17
Source File: sortedlist.py From misp42splunk with GNU Lesser General Public License v3.0 | 6 votes |
def __add__(self, other): """Return new sorted-key list containing all values in both sequences. ``skl.__add__(other)`` <==> ``skl + other`` Values in `other` do not need to be in sorted-key order. Runtime complexity: `O(n*log(n))` >>> from operator import neg >>> skl1 = SortedKeyList([5, 4, 3], key=neg) >>> skl2 = SortedKeyList([2, 1, 0], key=neg) >>> skl1 + skl2 SortedKeyList([5, 4, 3, 2, 1, 0], key=<built-in function neg>) :param other: other iterable :return: new sorted-key list """ values = reduce(iadd, self._lists, []) values.extend(other) return self.__class__(values, key=self._key)
Example #18
Source File: test_quantity.py From cadquery-freecad-module with GNU Lesser General Public License v3.0 | 6 votes |
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)
Example #19
Source File: test_finfields.py From mpyc with MIT License | 6 votes |
def test_operatorerrors(self): f2 = self.f2 f2p = self.f2p f256 = self.f256 f19 = self.f19 self.assertRaises(TypeError, operator.add, f2(1), f2p(2)) self.assertRaises(TypeError, operator.iadd, f2(1), f2p(2)) self.assertRaises(TypeError, operator.sub, f2(1), f256(2)) self.assertRaises(TypeError, operator.isub, f2(1), f256(2)) self.assertRaises(TypeError, operator.mul, f2(1), f19(2)) self.assertRaises(TypeError, operator.imul, f2(1), f19(2)) self.assertRaises(TypeError, operator.truediv, f256(1), f19(2)) self.assertRaises(TypeError, operator.itruediv, f256(1), f19(2)) self.assertRaises(TypeError, operator.truediv, 3.14, f19(2)) self.assertRaises(TypeError, operator.lshift, f2(1), f2(1)) self.assertRaises(TypeError, operator.ilshift, f2(1), f2(1)) self.assertRaises(TypeError, operator.lshift, 1, f2(1)) self.assertRaises(TypeError, operator.rshift, f19(1), f19(1)) self.assertRaises(TypeError, operator.irshift, f19(1), f19(1)) self.assertRaises(TypeError, operator.irshift, f256(1), f256(1)) self.assertRaises(TypeError, operator.pow, f2(1), f19(2)) self.assertRaises(TypeError, operator.pow, f19(1), 3.14)
Example #20
Source File: SortedList.py From Uranium with GNU Lesser General Public License v3.0 | 6 votes |
def __add__(self, other): """Return new sorted-key list containing all values in both sequences. ``skl.__add__(other)`` <==> ``skl + other`` Values in `other` do not need to be in sorted-key order. Runtime complexity: `O(n*log(n))` >>> from operator import neg >>> skl1 = SortedKeyList([5, 4, 3], key=neg) >>> skl2 = SortedKeyList([2, 1, 0], key=neg) >>> skl1 + skl2 SortedKeyList([5, 4, 3, 2, 1, 0], key=<built-in function neg>) :param other: other iterable :return: new sorted-key list """ values = reduce(iadd, self._lists, []) values.extend(other) return self.__class__(values, key=self._key)
Example #21
Source File: sortedlist.py From vnpy_crypto with MIT License | 6 votes |
def _reset(self, load): """Reset sorted list load factor. The `load` specifies the load-factor of the list. The default load factor of 1000 works well for lists from tens to tens-of-millions of values. Good practice is to use a value that is the cube root of the list size. With billions of elements, the best load factor depends on your usage. It's best to leave the load factor at the default until you start benchmarking. See :doc:`implementation` and :doc:`performance-scale` for more information. Runtime complexity: `O(n)` :param int load: load-factor for sorted list sublists """ values = reduce(iadd, self._lists, []) self._clear() self._load = load self._update(values)
Example #22
Source File: sortedlist.py From vnpy_crypto with MIT License | 6 votes |
def __add__(self, other): """Return new sorted list containing all values in both sequences. ``sl.__add__(other)`` <==> ``sl + other`` Values in `other` do not need to be in sorted order. Runtime complexity: `O(n*log(n))` >>> sl1 = SortedList('bat') >>> sl2 = SortedList('cat') >>> sl1 + sl2 SortedList(['a', 'a', 'b', 'c', 't', 't']) :param other: other iterable :return: new sorted list """ values = reduce(iadd, self._lists, []) values.extend(other) return self.__class__(values)
Example #23
Source File: sortedlist.py From vnpy_crypto with MIT License | 6 votes |
def __mul__(self, num): """Return new sorted list with `num` shallow copies of values. ``sl.__mul__(num)`` <==> ``sl * num`` Runtime complexity: `O(n*log(n))` >>> sl = SortedList('abc') >>> sl * 3 SortedList(['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c']) :param int num: count of shallow copies :return: new sorted list """ values = reduce(iadd, self._lists, []) * num return self.__class__(values)
Example #24
Source File: sortedlist.py From vnpy_crypto with MIT License | 6 votes |
def __imul__(self, num): """Update the sorted list with `num` shallow copies of values. ``sl.__imul__(num)`` <==> ``sl *= num`` Runtime complexity: `O(n*log(n))` >>> sl = SortedList('abc') >>> sl *= 3 >>> sl SortedList(['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c']) :param int num: count of shallow copies :return: existing sorted list """ values = reduce(iadd, self._lists, []) * num self._clear() self._update(values) return self
Example #25
Source File: sortedlist.py From vnpy_crypto with MIT License | 6 votes |
def __add__(self, other): """Return new sorted-key list containing all values in both sequences. ``skl.__add__(other)`` <==> ``skl + other`` Values in `other` do not need to be in sorted-key order. Runtime complexity: `O(n*log(n))` >>> from operator import neg >>> skl1 = SortedKeyList([5, 4, 3], key=neg) >>> skl2 = SortedKeyList([2, 1, 0], key=neg) >>> skl1 + skl2 SortedKeyList([5, 4, 3, 2, 1, 0], key=<built-in function neg>) :param other: other iterable :return: new sorted-key list """ values = reduce(iadd, self._lists, []) values.extend(other) return self.__class__(values, key=self._key)
Example #26
Source File: test_array.py From medicare-demo with Apache License 2.0 | 6 votes |
def test_iadd(self): a = array.array(self.typecode, self.example[::-1]) b = a a += array.array(self.typecode, 2*self.example) self.assert_(a is b) self.assertEqual( a, array.array(self.typecode, self.example[::-1]+2*self.example) ) b = array.array(self.badtypecode()) if test_support.is_jython: self.assertRaises(TypeError, operator.add, a, b) self.assertRaises(TypeError, operator.iadd, a, "bad") else: self.assertRaises(TypeError, a.__add__, b) self.assertRaises(TypeError, a.__iadd__, "bad")
Example #27
Source File: SortedList.py From Uranium with GNU Lesser General Public License v3.0 | 6 votes |
def __imul__(self, num): """Update the sorted list with `num` shallow copies of values. ``sl.__imul__(num)`` <==> ``sl *= num`` Runtime complexity: `O(n*log(n))` >>> sl = SortedList('abc') >>> sl *= 3 >>> sl SortedList(['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c']) :param int num: count of shallow copies :return: existing sorted list """ values = reduce(iadd, self._lists, []) * num self._clear() self._update(values) return self
Example #28
Source File: SortedList.py From Uranium with GNU Lesser General Public License v3.0 | 6 votes |
def __mul__(self, num): """Return new sorted list with `num` shallow copies of values. ``sl.__mul__(num)`` <==> ``sl * num`` Runtime complexity: `O(n*log(n))` >>> sl = SortedList('abc') >>> sl * 3 SortedList(['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c']) :param int num: count of shallow copies :return: new sorted list """ values = reduce(iadd, self._lists, []) * num return self.__class__(values)
Example #29
Source File: SortedList.py From Uranium with GNU Lesser General Public License v3.0 | 6 votes |
def __add__(self, other): """Return new sorted list containing all values in both sequences. ``sl.__add__(other)`` <==> ``sl + other`` Values in `other` do not need to be in sorted order. Runtime complexity: `O(n*log(n))` >>> sl1 = SortedList('bat') >>> sl2 = SortedList('cat') >>> sl1 + sl2 SortedList(['a', 'a', 'b', 'c', 't', 't']) :param other: other iterable :return: new sorted list """ values = reduce(iadd, self._lists, []) values.extend(other) return self.__class__(values)
Example #30
Source File: SortedList.py From Uranium with GNU Lesser General Public License v3.0 | 6 votes |
def _reset(self, load): """Reset sorted list load factor. The `load` specifies the load-factor of the list. The default load factor of 1000 works well for lists from tens to tens-of-millions of values. Good practice is to use a value that is the cube root of the list size. With billions of elements, the best load factor depends on your usage. It's best to leave the load factor at the default until you start benchmarking. See :doc:`implementation` and :doc:`performance-scale` for more information. Runtime complexity: `O(n)` :param int load: load-factor for sorted list sublists """ values = reduce(iadd, self._lists, []) self._clear() self._load = load self._update(values)