cirq-core 1.3.0.dev20230829170013__py3-none-any.whl → 1.3.0.dev20230830022013__py3-none-any.whl

cirq/_version.py

@@ -1 +1 @@
-__version__ = "1.3.0.dev20230829170013"
+__version__ = "1.3.0.dev20230830022013"

cirq/value/duration.py

@@ -13,14 +13,14 @@
 # limitations under the License.
 """A typed time delta that supports picosecond accuracy."""
 
-from typing import AbstractSet, Any, Dict, Optional, Tuple, TYPE_CHECKING, Union
+from typing import AbstractSet, Any, Dict, Optional, Tuple, TYPE_CHECKING, Union, List
 import datetime
 
 import sympy
 import numpy as np
 
 from cirq import protocols
-from cirq._compat import proper_repr
+from cirq._compat import proper_repr, cached_method
 from cirq._doc import document
 
 if TYPE_CHECKING:
@@ -79,48 +79,53 @@ class Duration:
             >>> print(cirq.Duration(micros=1.5 * sympy.Symbol('t')))
             (1500.0*t) ns
         """
+        self._time_vals: List[_NUMERIC_INPUT_TYPE] = [0, 0, 0, 0]
+        self._multipliers = [1, 1000, 1000_000, 1000_000_000]
         if value is not None and value != 0:
             if isinstance(value, datetime.timedelta):
                 # timedelta has microsecond resolution.
-                micros += int(value / datetime.timedelta(microseconds=1))
+                self._time_vals[2] = int(value / datetime.timedelta(microseconds=1))
             elif isinstance(value, Duration):
-                picos += value._picos
+                self._time_vals = value._time_vals
             else:
                 raise TypeError(f'Not a `cirq.DURATION_LIKE`: {repr(value)}.')
-
-        val = picos + nanos * 1000 + micros * 1000_000 + millis * 1000_000_000
-        self._picos: _NUMERIC_OUTPUT_TYPE = float(val) if isinstance(val, np.number) else val
+        input_vals = [picos, nanos, micros, millis]
+        self._time_vals = _add_time_vals(self._time_vals, input_vals)
 
     def _is_parameterized_(self) -> bool:
-        return protocols.is_parameterized(self._picos)
+        return protocols.is_parameterized(self._time_vals)
 
     def _parameter_names_(self) -> AbstractSet[str]:
-        return protocols.parameter_names(self._picos)
+        return protocols.parameter_names(self._time_vals)
 
     def _resolve_parameters_(self, resolver: 'cirq.ParamResolver', recursive: bool) -> 'Duration':
-        return Duration(picos=protocols.resolve_parameters(self._picos, resolver, recursive))
+        return _duration_from_time_vals(
+            protocols.resolve_parameters(self._time_vals, resolver, recursive)
+        )
 
+    @cached_method
     def total_picos(self) -> _NUMERIC_OUTPUT_TYPE:
         """Returns the number of picoseconds that the duration spans."""
-        return self._picos
+        val = sum(a * b for a, b in zip(self._time_vals, self._multipliers))
+        return float(val) if isinstance(val, np.number) else val
 
     def total_nanos(self) -> _NUMERIC_OUTPUT_TYPE:
         """Returns the number of nanoseconds that the duration spans."""
-        return self._picos / 1000
+        return self.total_picos() / 1000
 
     def total_micros(self) -> _NUMERIC_OUTPUT_TYPE:
         """Returns the number of microseconds that the duration spans."""
-        return self._picos / 1000_000
+        return self.total_picos() / 1000_000
 
     def total_millis(self) -> _NUMERIC_OUTPUT_TYPE:
         """Returns the number of milliseconds that the duration spans."""
-        return self._picos / 1000_000_000
+        return self.total_picos() / 1000_000_000
 
     def __add__(self, other) -> 'Duration':
         other = _attempt_duration_like_to_duration(other)
         if other is None:
             return NotImplemented
-        return Duration(picos=self._picos + other._picos)
+        return _duration_from_time_vals(_add_time_vals(self._time_vals, other._time_vals))
 
     def __radd__(self, other) -> 'Duration':
         return self.__add__(other)
@@ -129,29 +134,36 @@ class Duration:
         other = _attempt_duration_like_to_duration(other)
         if other is None:
             return NotImplemented
-        return Duration(picos=self._picos - other._picos)
+        return _duration_from_time_vals(
+            _add_time_vals(self._time_vals, [-x for x in other._time_vals])
+        )
 
     def __rsub__(self, other) -> 'Duration':
         other = _attempt_duration_like_to_duration(other)
         if other is None:
             return NotImplemented
-        return Duration(picos=other._picos - self._picos)
+        return _duration_from_time_vals(
+            _add_time_vals(other._time_vals, [-x for x in self._time_vals])
+        )
 
     def __mul__(self, other) -> 'Duration':
         if not isinstance(other, (int, float, sympy.Expr)):
             return NotImplemented
-        return Duration(picos=self._picos * other)
+        if other == 0:
+            return _duration_from_time_vals([0] * 4)
+        return _duration_from_time_vals([x * other for x in self._time_vals])
 
     def __rmul__(self, other) -> 'Duration':
         return self.__mul__(other)
 
     def __truediv__(self, other) -> Union['Duration', float]:
         if isinstance(other, (int, float, sympy.Expr)):
-            return Duration(picos=self._picos / other)
+            new_time_vals = [x / other for x in self._time_vals]
+            return _duration_from_time_vals(new_time_vals)
 
         other_duration = _attempt_duration_like_to_duration(other)
         if other_duration is not None:
-            return self._picos / other_duration._picos
+            return self.total_picos() / other_duration.total_picos()
 
         return NotImplemented
 
@@ -159,56 +171,57 @@ class Duration:
         other = _attempt_duration_like_to_duration(other)
         if other is None:
             return NotImplemented
-        return self._picos == other._picos
+        return self.total_picos() == other.total_picos()
 
     def __ne__(self, other):
         other = _attempt_duration_like_to_duration(other)
         if other is None:
             return NotImplemented
-        return self._picos != other._picos
+        return self.total_picos() != other.total_picos()
 
     def __gt__(self, other):
         other = _attempt_duration_like_to_duration(other)
         if other is None:
             return NotImplemented
-        return self._picos > other._picos
+        return self.total_picos() > other.total_picos()
 
     def __lt__(self, other):
         other = _attempt_duration_like_to_duration(other)
         if other is None:
             return NotImplemented
-        return self._picos < other._picos
+        return self.total_picos() < other.total_picos()
 
     def __ge__(self, other):
         other = _attempt_duration_like_to_duration(other)
         if other is None:
             return NotImplemented
-        return self._picos >= other._picos
+        return self.total_picos() >= other.total_picos()
 
     def __le__(self, other):
         other = _attempt_duration_like_to_duration(other)
         if other is None:
             return NotImplemented
-        return self._picos <= other._picos
+        return self.total_picos() <= other.total_picos()
 
     def __bool__(self):
-        return bool(self._picos)
+        return bool(self.total_picos())
 
     def __hash__(self):
-        if isinstance(self._picos, (int, float)) and self._picos % 1000000 == 0:
-            return hash(datetime.timedelta(microseconds=self._picos / 1000000))
-        return hash((Duration, self._picos))
+        if isinstance(self.total_picos(), (int, float)) and self.total_picos() % 1000000 == 0:
+            return hash(datetime.timedelta(microseconds=self.total_picos() / 1000000))
+        return hash((Duration, self.total_picos()))
 
     def _decompose_into_amount_unit_suffix(self) -> Tuple[int, str, str]:
+        picos = self.total_picos()
         if (
-            isinstance(self._picos, sympy.Mul)
-            and len(self._picos.args) == 2
-            and isinstance(self._picos.args[0], (sympy.Integer, sympy.Float))
+            isinstance(picos, sympy.Mul)
+            and len(picos.args) == 2
+            and isinstance(picos.args[0], (sympy.Integer, sympy.Float))
         ):
-            scale = self._picos.args[0]
-            rest = self._picos.args[1]
+            scale = picos.args[0]
+            rest = picos.args[1]
         else:
-            scale = self._picos
+            scale = picos
             rest = 1
 
         if scale % 1000_000_000 == 0:
@@ -234,7 +247,7 @@ class Duration:
         return amount * rest, unit, suffix
 
     def __str__(self) -> str:
-        if self._picos == 0:
+        if self.total_picos() == 0:
             return 'Duration(0)'
         amount, _, suffix = self._decompose_into_amount_unit_suffix()
         if not isinstance(amount, (int, float, sympy.Symbol)):
@@ -257,3 +270,21 @@ def _attempt_duration_like_to_duration(value: Any) -> Optional[Duration]:
     if isinstance(value, (int, float)) and value == 0:
         return Duration()
     return None
+
+
+def _add_time_vals(
+    val1: List[_NUMERIC_INPUT_TYPE], val2: List[_NUMERIC_INPUT_TYPE]
+) -> List[_NUMERIC_INPUT_TYPE]:
+    ret: List[_NUMERIC_INPUT_TYPE] = []
+    for i in range(4):
+        if val1[i] and val2[i]:
+            ret.append(val1[i] + val2[i])
+        else:
+            ret.append(val1[i] or val2[i])
+    return ret
+
+
+def _duration_from_time_vals(time_vals: List[_NUMERIC_INPUT_TYPE]):
+    ret = Duration()
+    ret._time_vals = time_vals
+    return ret

cirq/value/duration_test.py

@@ -168,9 +168,11 @@ def test_sub():
 def test_mul():
     assert Duration(picos=2) * 3 == Duration(picos=6)
     assert 4 * Duration(picos=3) == Duration(picos=12)
+    assert 0 * Duration(picos=10) == Duration()
 
     t = sympy.Symbol('t')
     assert t * Duration(picos=3) == Duration(picos=3 * t)
+    assert 0 * Duration(picos=t) == Duration(picos=0)
 
     with pytest.raises(TypeError):
         _ = Duration() * Duration()

{cirq_core-1.3.0.dev20230829170013.dist-info → cirq_core-1.3.0.dev20230830022013.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cirq-core
-Version: 1.3.0.dev20230829170013
+Version: 1.3.0.dev20230830022013
 Summary: A framework for creating, editing, and invoking Noisy Intermediate Scale Quantum (NISQ) circuits.
 Home-page: http://github.com/quantumlib/cirq
 Author: The Cirq Developers

{cirq_core-1.3.0.dev20230829170013.dist-info → cirq_core-1.3.0.dev20230830022013.dist-info}/RECORD

@@ -4,7 +4,7 @@ cirq/_compat_test.py,sha256=84X6ELsb5fv3Hc0_ly8-IQfMnCNQN6tHs6GZFrnuNyI,35005
 cirq/_doc.py,sha256=yDyWUD_2JDS0gShfGRb-rdqRt9-WeL7DhkqX7np0Nko,2879
 cirq/_import.py,sha256=p9gMHJscbtDDkfHOaulvd3Aer0pwUF5AXpL89XR8dNw,8402
 cirq/_import_test.py,sha256=6K_v0riZJXOXUphHNkGA8MY-JcmGlezFaGmvrNhm3OQ,1015
-cirq/_version.py,sha256=7SNUFESedufTH50HyN0faCl-xdHKz2ZYH5tQprzGVgE,40
+cirq/_version.py,sha256=xnpcsGC23F1oooiyAeCIAcy0d4nhPpEYmBLIMULnuBI,40
 cirq/_version_test.py,sha256=Ea3ZNdQKZBsZrSc9xle7TUdT9bUINs-qezPruQ_m38s,133
 cirq/conftest.py,sha256=X7yLFL8GLhg2CjPw0hp5e_dGASfvHx1-QT03aUbhKJw,1168
 cirq/json_resolver_cache.py,sha256=JJiO1dhHsEqYClUv68eg-hiOzbb_C1QiQ-BCcvoe4Ck,13067
@@ -1091,8 +1091,8 @@ cirq/value/condition.py,sha256=QrxKBAox4C-z2pL2_xeKMvmfp0OP4tVFXJdPULx1pik,5900
 cirq/value/condition_test.py,sha256=FGnCFcpeIQFRbnszKsHKA5K7sderTz7kwS7zWbWwx64,4037
 cirq/value/digits.py,sha256=pUQi6PIA1FMbXUOWknefb6dBApCyLsTkpLFrhvNgE0Q,6024
 cirq/value/digits_test.py,sha256=evx-y619LfjSN_gUO1B6K7O80X5HJmxxBPl61RrOovo,3812
-cirq/value/duration.py,sha256=SBgxd0Q3LMkriDpGKImlIGuwIhCvyQOTOf7qRTilFpc,9087
-cirq/value/duration_test.py,sha256=mOuZkLdASZ3mjauJXFuJt3aoo0AmDBfec6tv6ap82IA,8142
+cirq/value/duration.py,sha256=isNzA1TuKb5rSaAYy4JpgT91Zt9_5XLQBSmMkuWCtD4,10358
+cirq/value/duration_test.py,sha256=C7nwg7IlHoQOUhWa_aX8vy7_qp654ZIDtmnKF35UiqE,8244
 cirq/value/linear_dict.py,sha256=BG3pckQPX4DPqNvp-HxI_dTzQf8sGx6nIRkn0-ye4Qg,10643
 cirq/value/linear_dict_test.py,sha256=uEHbvobWV4EypOXQGe6B4xh6atLbQq8YSOomNHgv38o,17107
 cirq/value/measurement_key.py,sha256=MThR6rFY_YuSvcvWOacCEfOluJC0u7d8VvnDkHe-HAM,4939
@@ -1140,8 +1140,8 @@ cirq/work/sampler.py,sha256=JVv1vvfa6EgFiR3UeDk44U186dCrioH2NZXueCgsb9w,19828
 cirq/work/sampler_test.py,sha256=zo1Hj6sn6fLs_WZMxYRApBqgBsldmptn74NL0jhNukc,12325
 cirq/work/zeros_sampler.py,sha256=D3hbNZC-jXKuNAWg2OUiUuT8pmDV_WFnEfMank6In4o,2357
 cirq/work/zeros_sampler_test.py,sha256=JIkpBBFPJe5Ba4142vzogyWyboG1Q1ZAm0UVGgOoZn8,3279
-cirq_core-1.3.0.dev20230829170013.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-cirq_core-1.3.0.dev20230829170013.dist-info/METADATA,sha256=Rh15jD2jW8dz8yvyqAVgnNXgv3gAZ4D0CT_mTi2Uybo,2077
-cirq_core-1.3.0.dev20230829170013.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-cirq_core-1.3.0.dev20230829170013.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
-cirq_core-1.3.0.dev20230829170013.dist-info/RECORD,,
+cirq_core-1.3.0.dev20230830022013.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+cirq_core-1.3.0.dev20230830022013.dist-info/METADATA,sha256=XARE4q61QY_m8JM-P4JvK_ZGZliH_hqXmkIBp4uAwfA,2077
+cirq_core-1.3.0.dev20230830022013.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+cirq_core-1.3.0.dev20230830022013.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
+cirq_core-1.3.0.dev20230830022013.dist-info/RECORD,,