def test_insert_into_global_state_branch_of_leaf_unit(self): self._state_handler.initialize(self._root_nodes) branch = Node(Unit(identifier=(0,), position=[0.2, 0.3], charge=None, velocity=[0.5, 0], time_stamp=Time(0.0, 0.3)), weight=1) branch.add_child(Node(Unit(identifier=(0, 1), position=[0.4, 0.6], charge={"e": -1}, velocity=[1, 0], time_stamp=Time(0.0, 0.3)), weight=0.5)) self._state_handler.insert_into_global_state([branch]) all_root_cnodes = self._state_handler.extract_global_state() self.assertEqual(len(all_root_cnodes), 2) unit = all_root_cnodes[0].value self.assertEqual(unit.position, [0.2, 0.3]) self.assertIsNone(unit.charge) self.assertEqual(unit.identifier, (0,)) self.assertEqual(unit.velocity, [0.5, 0]) self.assertEqual(unit.time_stamp, Time(0.0, 0.3)) self.assertEqual(len(all_root_cnodes[0].children), 2) unit = all_root_cnodes[0].children[0].value self.assertEqual(unit.position, [0, 0]) self.assertEqual(unit.charge, {"e": 1}) self.assertEqual(unit.identifier, (0, 0)) self.assertIsNone(unit.velocity) self.assertIsNone(unit.time_stamp) self.assertEqual(len(all_root_cnodes[0].children[0].children), 0) unit = all_root_cnodes[0].children[1].value self.assertEqual(unit.position, [0.4, 0.6]) self.assertEqual(unit.charge, {"e": -1}) self.assertEqual(unit.identifier, (0, 1)) self.assertEqual(unit.velocity, [1, 0]) self.assertEqual(unit.time_stamp, Time(0.0, 0.3)) self.assertEqual(len(all_root_cnodes[0].children[1].children), 0) unit = all_root_cnodes[1].value self.assertEqual(unit.position, [0.9, 0.775]) self.assertIsNone(unit.charge) self.assertEqual(unit.identifier, (1,)) self.assertIsNone(unit.velocity) self.assertIsNone(unit.time_stamp) self.assertEqual(len(all_root_cnodes[1].children), 2) unit = all_root_cnodes[1].children[0].value self.assertEqual(unit.position, [0.9, 0.8]) self.assertEqual(unit.charge, {"e": 1}) self.assertEqual(unit.identifier, (1, 0)) self.assertIsNone(unit.velocity) self.assertIsNone(unit.time_stamp) self.assertEqual(len(all_root_cnodes[1].children[0].children), 0) unit = all_root_cnodes[1].children[1].value self.assertEqual(unit.position, [0.9, 0.75]) self.assertEqual(unit.charge, {"e": -1}) self.assertEqual(unit.identifier, (1, 1)) self.assertIsNone(unit.velocity) self.assertIsNone(unit.time_stamp) self.assertEqual(len(all_root_cnodes[1].children[1].children), 0)
def test_update(self): time = Time(3.0, 0.3247823) other_time = Time(6.0, 0.1231) time.update(other_time) self.assertEqual(time.quotient, 6.0) self.assertEqual(time.remainder, 0.1231) self.assertEqual(other_time.quotient, 6.0) self.assertEqual(other_time.remainder, 0.1231) self.assertIsNot(time, other_time)
def test_extract_from_global_state_copied_time_stamp(self): self._state_handler.initialize(self._root_nodes) branch = Node(Unit(identifier=(0,), position=[0.2, 0.3], charge=None, velocity=[0.5, 0], time_stamp=Time(0.0, 0.3)), weight=1) branch.add_child(Node(Unit(identifier=(0, 1), position=[0.4, 0.6], charge={"e": -1}, velocity=[1, 0], time_stamp=Time(0.0, 0.3)), weight=0.5)) self._state_handler.insert_into_global_state([branch]) root_cnode = self._state_handler.extract_from_global_state((0, 1)) time_stamp = root_cnode.value.time_stamp time_stamp.update(Time(1.0, 0.2)) all_root_cnodes = self._state_handler.extract_global_state() self.assertEqual(all_root_cnodes[0].value.time_stamp, Time(0.0, 0.3))
def test_insert_into_global_state_velocity_none_but_time_stamp_not_none_raises_error(self): self._state_handler.initialize(self._root_nodes) branch = Node(Unit(identifier=(0,), position=[0.2, 0.3], charge=None, velocity=[0.5, 0], time_stamp=Time(0.0, 0.3)), weight=1) branch.add_child(Node(Unit(identifier=(0, 1), position=[0.4, 0.6], charge={"e": -1}, velocity=[1, 0], time_stamp=Time(0.0, 0.3)), weight=0.5)) self._state_handler.insert_into_global_state([branch]) branch = Node(Unit(identifier=(0,), position=[0.1, 0.2], charge=None, velocity=None, time_stamp=Time(0.0, 0.5)), weight=1) branch.add_child(Node(Unit(identifier=(0, 1), position=[0.3, 0.4], charge={"e": -1}, velocity=None, time_stamp=Time(0.0, 0.5)), weight=0.5)) branch.add_child(Node(Unit(identifier=(0, 0), position=[0.5, 0.6], charge={"e": 1}, velocity=None, time_stamp=Time(0.0, 0.5)), weight=0.5)) with self.assertRaises(AssertionError): self._state_handler.insert_into_global_state([branch])
def send_out_state(self, cnode_with_initially_active_unit: Node) -> Sequence[Node]: """ Return the out-state. This method receives the branch of the initially active unit. Parameters ---------- cnode_with_initially_active_unit : base.node.Node The branch of the initially active unit. Returns ------- Sequence[base.node.Node] The out-state. """ self._store_in_state([cnode_with_initially_active_unit]) self._construct_leaf_cnodes() for leaf_cnode in self._leaf_cnodes: unit = leaf_cnode.value assert unit.velocity is None assert unit.time_stamp is None unit.velocity = self._initial_velocity.copy() unit.time_stamp = Time(0.0, 0.0) self._register_velocity_change_leaf_cnode(leaf_cnode, self._initial_velocity) self._commit_non_leaf_velocity_changes() return self._state
def __init__(self, warn_on_equal_event_times: bool = False) -> None: """ The constructor of the HeapScheduler class. Parameters ---------- warn_on_equal_event_times : bool, optional Whether this scheduler should log a warning when succeeding event times are equal. Raises ------ MemoryError If the C code fails to allocate memory. """ self._logger = logging.getLogger(__name__) self._logger_enabled_for_debug = self._logger.isEnabledFor( logging.DEBUG) log_init_arguments(self._logger.debug, self.__class__.__name__) super().__init__() c_heap = lib.construct_heap() if c_heap == ffi.NULL: raise MemoryError( "Could not allocate memory for the class {0}.".format( self.__class__.__name__)) self._heap = ffi.gc(c_heap, lib.destroy_heap, size=lib.estimated_size(c_heap)) self._minimal_valid_counter = {} self._last_returned_event = (Time(-float("inf"), -float("inf")), None) self._allocated_memory_bytes = 0 self._scheduler_handle = _new_handle(self) self._event_handler_handles = {} self._warn_on_equal_event_times = warn_on_equal_event_times
def __init__(self, sampling_interval: float, output_handler: str, first_event_time_zero: bool = False) -> None: """ The constructor of the FixedIntervalSamplingEventHandler class. Parameters ---------- sampling_interval : float The time interval of the sampling. output_handler : str The name of the output handler. first_event_time_zero : bool, optional If the first returned candidate event time is zero. Raises ------ base.exceptions.ConfigurationError: If the sampling interval is not greater than zero. """ log_init_arguments(logging.getLogger(__name__).debug, self.__class__.__name__, sampling_interval=sampling_interval, output_handler=output_handler) super().__init__(output_handler=output_handler) if not sampling_interval > 0.0: raise ConfigurationError("The sampling_interval in the event handler {0} has to be > 0.0." .format(self.__class__.__name__)) self._sampling_interval = sampling_interval self._event_time = Time(0.0, 0.0) if not first_event_time_zero else Time.from_float(-sampling_interval)
def __init__(self, dumping_interval: float, output_handler: str) -> None: """ The constructor of the FixedIntervalDumpingEventHandler class. Parameters ---------- dumping_interval : float The time interval of the dumping. output_handler : The name of the output handler. Raises ------ base.exceptions.ConfigurationError: If the dumping interval is not greater than zero. """ log_init_arguments(logging.getLogger(__name__).debug, self.__class__.__name__, dumping_interval=dumping_interval, output_handler=output_handler) super().__init__(output_handler=output_handler) if not dumping_interval > 0.0: raise ConfigurationError( "The dumping_interval in the event handler {0} has to be > 0.0." .format(self.__class__.__name__)) self._dumping_interval = dumping_interval self._event_time = Time(0.0, 0.0)
def test_almost_equal_comparison(self): time = Time(54678924378.0, 0.3216781233653267) other_time = Time(54678924378.0, 0.3216781233653267) self.assertAlmostEqual(time, other_time, places=13) time = Time(54678924378.0, 0.3216781233653266) other_time = Time(54678924378.0, 0.3216781233653267) self.assertAlmostEqual(time, other_time, places=13) time = Time(54678924378.0, 0.3216781233653267) other_time = Time(54678924378.0, 0.3216781233653367) self.assertAlmostEqual(time, other_time, places=13) time = Time(54678924378.0, 0.3216781233653267) other_time = Time(54678924378.0, 0.3216781233654267) self.assertNotAlmostEqual(time, other_time, places=13) time = Time(54678924378.0, 0.3216781233653267) other_time = Time(54678924377.0, 0.3216781233653267) self.assertNotAlmostEqual(time, other_time)
def test_unit(self): test_position = [1] test_velocity = [2] test_time_stamp = Time(0.0, 0.4) unit = Unit(0, test_position, velocity=test_velocity, time_stamp=test_time_stamp) self.assertEqual(unit.identifier, 0) self.assertEqual(unit.position, [1]) self.assertIsNone(unit.charge) self.assertEqual(unit.velocity, [2]) self.assertEqual(unit.time_stamp, Time(0.0, 0.4)) # The position, velocity and time stamp was not copied test_position[0] += 1 test_velocity[0] /= 2 test_time_stamp.update(Time(1.0, 0.1)) self.assertEqual(unit.position, [2]) self.assertEqual(unit.velocity, [1]) self.assertEqual(unit.time_stamp, Time(1.0, 0.1))
def test_extract_active_global_state_root_node_active(self): self._state_handler.initialize(self._root_nodes) branch = Node(Unit(identifier=(1,), position=[0.2, 0.3], charge=None, velocity=[0.1, 0.2], time_stamp=Time(0.0, 0.0)), weight=1) branch.add_child(Node(Unit(identifier=(1, 0), position=[0.4, 0.6], charge={"e": -1}, velocity=[0.6, -0.1], time_stamp=Time(-1.0, 0.8)), weight=0.5)) branch.add_child(Node(Unit(identifier=(1, 1), position=[0.4, 0.6], charge={"e": -1}, velocity=[0.6, -0.1], time_stamp=Time(-1.0, 0.8)), weight=0.5)) self._state_handler.insert_into_global_state([branch]) branches = self._state_handler.extract_active_global_state() self.assertEqual(len(branches), 1) info = branches[0].value self.assertEqual(info.position, [0.2, 0.3]) self.assertEqual(info.charge, None) self.assertEqual(info.identifier, (1,)) self.assertEqual(info.velocity, [0.1, 0.2]) self.assertEqual(info.time_stamp, Time(0.0, 0.0)) self.assertEqual(len(branches[0].children), 2) info = branches[0].children[0].value self.assertEqual(info.position, [0.4, 0.6]) self.assertEqual(info.charge, {"e": 1}) self.assertEqual(info.identifier, (1, 0)) self.assertEqual(info.velocity, [0.6, -0.1]) self.assertEqual(info.time_stamp, Time(-1.0, 0.8)) self.assertEqual(len(branches[0].children[0].children), 0) info = branches[0].children[1].value self.assertEqual(info.position, [0.4, 0.6]) self.assertEqual(info.charge, {"e": -1}) self.assertEqual(info.identifier, (1, 1)) self.assertEqual(info.velocity, [0.6, -0.1]) self.assertEqual(info.time_stamp, Time(-1.0, 0.8)) self.assertEqual(len(branches[0].children[1].children), 0)
def test_insert_into_global_state_root_branch(self): self._state_handler.initialize(self._root_nodes) branch = Node(Unit(identifier=(1,), position=[0.5, 0.6], charge=None, velocity=[1, 1], time_stamp=Time(0.0, 0.2)), weight=1) # There are no consistency checks within the state handler branch.add_child(Node(Unit(identifier=(1, 0), position=[0.4, 0.6], charge={"e": 1}, velocity=[-0.3, 2.1], time_stamp=Time(0.0, 0.53)), weight=0.5)) branch.add_child(Node(Unit(identifier=(1, 1), position=[0.1, 0.2], charge={"e": -1}, velocity=[0.7, 0.7], time_stamp=Time(0.0, 0.1)), weight=0.5)) self._state_handler.insert_into_global_state([branch]) all_root_cnodes = self._state_handler.extract_global_state() self.assertEqual(len(all_root_cnodes), 2) unit = all_root_cnodes[0].value self.assertEqual(unit.position, [0.05, 0.025]) self.assertIsNone(unit.charge) self.assertEqual(unit.identifier, (0,)) self.assertIsNone(unit.velocity) self.assertIsNone(unit.time_stamp) self.assertEqual(len(all_root_cnodes[0].children), 2) unit = all_root_cnodes[0].children[0].value self.assertEqual(unit.position, [0, 0]) self.assertEqual(unit.charge, {"e": 1}) self.assertEqual(unit.identifier, (0, 0)) self.assertIsNone(unit.velocity) self.assertIsNone(unit.time_stamp) self.assertEqual(len(all_root_cnodes[0].children[0].children), 0) unit = all_root_cnodes[0].children[1].value self.assertEqual(unit.position, [0.1, 0.05]) self.assertEqual(unit.charge, {"e": -1}) self.assertEqual(unit.identifier, (0, 1)) self.assertIsNone(unit.velocity) self.assertIsNone(unit.time_stamp) self.assertEqual(len(all_root_cnodes[0].children[1].children), 0) unit = all_root_cnodes[1].value self.assertEqual(unit.position, [0.5, 0.6]) self.assertIsNone(unit.charge) self.assertEqual(unit.identifier, (1,)) self.assertEqual(unit.velocity, [1, 1]) self.assertEqual(unit.time_stamp, Time(0.0, 0.2)) self.assertEqual(len(all_root_cnodes[1].children), 2) unit = all_root_cnodes[1].children[0].value self.assertEqual(unit.position, [0.4, 0.6]) self.assertEqual(unit.charge, {"e": 1}) self.assertEqual(unit.identifier, (1, 0)) self.assertEqual(unit.velocity, [-0.3, 2.1]) self.assertEqual(unit.time_stamp, Time(0.0, 0.53)) self.assertEqual(len(all_root_cnodes[1].children[0].children), 0) unit = all_root_cnodes[1].children[1].value self.assertEqual(unit.position, [0.1, 0.2]) self.assertEqual(unit.charge, {"e": -1}) self.assertEqual(unit.identifier, (1, 1)) self.assertEqual(unit.velocity, [0.7, 0.7]) self.assertEqual(unit.time_stamp, Time(0.0, 0.1)) self.assertEqual(len(all_root_cnodes[1].children[1].children), 0)
def __init__(self, **kwargs: Any) -> None: """ The constructor of the EndOfChainEventHandler class. This class is designed for cooperative inheritance, meaning that it passes through all unused kwargs in the init to the next class in the MRO via super. Parameters ---------- kwargs : Any Additional kwargs which are passed to the __init__ method of the next class in the MRO. """ super().__init__(**kwargs) self._event_time = Time(0.0, 0.0)
def __init__(self, warn_on_equal_event_times: bool = False) -> None: """ The constructor of the ListScheduler class. Parameters ---------- warn_on_equal_event_times : bool, optional Whether this scheduler should log a warning when succeeding event times are equal. """ self._logger = logging.getLogger(__name__) self._logger_enabled_for_debug = self._logger.isEnabledFor(logging.DEBUG) log_init_arguments(self._logger.debug, self.__class__.__name__) super().__init__() self._times = [] self._last_returned_event = (Time(-float("inf"), -float("inf")), None) self._warn_on_equal_event_times = warn_on_equal_event_times
def get_succeeding_event(self) -> Any: """ Get the valid event handler reference currently stored in the scheduler which was pushed with the smallest candidate event time. Note that the _event_time_increasing method is called via an assert so that it can be skipped using the -O option of the interpreter. This method raises a SchedulerError if the event time is not increasing. The 'root' function implemented in C returns a root element, where the time is -inf, the event handler points to ffi.NULL, and the counter is undefined if the heap is empty after the lazy deletion was carried out. If this is detected, a SchedulerError is raised. Returns ------- Any The event handler associated to the smallest stored event time. Raises ------ base.exceptions.SchedulerError If the newest smallest event time is greater than the last returned event time. base.exceptions.SchedulerError If the scheduler does not contain any event. """ # TODO: Add automatic garbage collection if number of elements in the heap becomes too large? top = _lib_root(self._heap, self._scheduler_handle, _lib_event_valid_callback) try: event_handler = _from_handle(top.event_handler) except RuntimeError as error: if (top.time_quotient == -float("inf") and top.time_remainder == -float("inf") and top.event_handler == ffi.NULL): raise SchedulerError( "The succeeding event was requested from the class {0}. However, the scheduler " "does not contain any events.".format( self.__class__.__name__)) raise error if self._logger_enabled_for_debug: self._logger.debug( "Smallest event time in the scheduler: {0}".format( str(top.time_quotient + top.time_remainder))) assert self._event_time_increasing( Time(top.time_quotient, top.time_remainder), event_handler.__class__.__name__) return event_handler
def __init__(self, initial_direction_of_motion: int, speed: float, initial_active_identifier: Sequence[int]) -> None: """ The constructor of the InitialChainStartOfRunEventHandler class. Parameters ---------- initial_direction_of_motion : int The initial direction of motion. speed : float The initial absolute value of the velocity. initial_active_identifier : List[int] The global state identifier of the initially active leaf unit. Raises ------ base.exceptions.ConfigurationError If the initial direction of motion exceeds the dimension. base.exceptions.ConfigurationError If the speed is not larger than zero. """ log_init_arguments(logging.getLogger(__name__).debug, self.__class__.__name__, initial_direction_of_motion=initial_direction_of_motion, speed=speed, initial_active_identifier=initial_active_identifier) super().__init__() if initial_direction_of_motion >= setting.dimension: raise ConfigurationError("The index of the initial direction of motion {0} " "has to be smaller than the dimension {1} " "in the event handler {2}." .format(initial_direction_of_motion, setting.dimension, self.__class__.__name__)) if speed <= 0.0: raise ConfigurationError("The speed in the event handler {0} should be larger than 0.0." .format(self.__class__.__name__)) self._initial_velocity = [0.0] * setting.dimension self._initial_velocity[initial_direction_of_motion] = speed self._initial_active_identifier = tuple(initial_active_identifier) self._event_time = Time(0.0, 0.0)
def __init__(self, chain_time: float) -> None: """ The constructor of the SingleIndependentActivePeriodicDirectionEndOfChainEventHandler class. Parameters ---------- chain_time : float The time interval after which a new end-of-chain event occurs. Raises ------ base.exceptions.ConfigurationError: If the chain time is not greater than zero. """ log_init_arguments(logging.getLogger(__name__).debug, self.__class__.__name__, chain_time=chain_time) super().__init__() if not chain_time > 0.0: raise ConfigurationError( "The chain_time in the event handler {0} must be > 0.0.". format(self.__class__.__name__)) self._chain_time = chain_time self._last_committed_event_time = Time(0.0, 0.0)
def test_add(self): time = Time(0.0, 0.0) result = time + 1.0 self.assertEqual(time.quotient, 0.0) self.assertEqual(time.remainder, 0.0) self.assertEqual(result.quotient, 1.0) self.assertEqual(result.remainder, 0.0) time = Time(57854.0, 0.4536734584357) result = time + 1.5426347561237 self.assertEqual(time.quotient, 57854.0) self.assertEqual(time.remainder, 0.4536734584357) self.assertEqual(result.quotient, 57855.0) self.assertAlmostEqual(result.remainder, 0.9963082145594, places=13) time = Time(54678924378.0, 0.3216781233653267) result = time + 2.241783567823847 self.assertEqual(time.quotient, 54678924378.0) self.assertEqual(time.remainder, 0.3216781233653267) self.assertEqual(result.quotient, 54678924380.0) self.assertAlmostEqual(result.remainder, 0.5634616911891737, places=13) time = Time(54678924378.0, 0.3216781233653267) result = time + 1.0e-13 self.assertEqual(time.quotient, 54678924378.0) self.assertEqual(time.remainder, 0.3216781233653267) self.assertEqual(result.quotient, 54678924378.0) self.assertAlmostEqual(result.remainder, 0.3216781233654267, places=13) time = Time(57854.0, 0.4536734584357) result = time + float("inf") self.assertEqual(time.quotient, 57854.0) self.assertEqual(time.remainder, 0.4536734584357) self.assertEqual(result.quotient, float("inf")) self.assertEqual(result.remainder, float("inf")) time = Time(57854.0, 0.4536734584357) result = time + (-float("inf")) self.assertEqual(time.quotient, 57854.0) self.assertEqual(time.remainder, 0.4536734584357) self.assertEqual(result.quotient, -float("inf")) self.assertEqual(result.remainder, -float("inf"))
def test_sub(self): time = Time(1.0, 0.0) other_time = Time(0.0, 0.0) result = time - other_time self.assertEqual(time.quotient, 1.0) self.assertEqual(time.remainder, 0.0) self.assertEqual(other_time.quotient, 0.0) self.assertEqual(other_time.remainder, 0.0) self.assertEqual(result, 1.0) time = Time(57854.0, 0.4536734584357) other_time = Time(57854.0, 0.2341521367) result = time - other_time self.assertEqual(time.quotient, 57854.0) self.assertEqual(time.remainder, 0.4536734584357) self.assertEqual(other_time.quotient, 57854.0) self.assertEqual(other_time.remainder, 0.2341521367) self.assertAlmostEqual(result, 0.2195213217357, places=13) time = Time(54678924378.0, 0.3216781233653267) other_time = Time(54678924376.0, 0.4536734584357) result = time - other_time self.assertEqual(time.quotient, 54678924378.0) self.assertEqual(time.remainder, 0.3216781233653267) self.assertEqual(other_time.quotient, 54678924376.0) self.assertEqual(other_time.remainder, 0.4536734584357) self.assertAlmostEqual(result, 1.8680046649296267, places=12) time = Time(54678924378.0, 0.3216781233653267) other_time = Time(54678924378.0, 0.3216781233652267) result = time - other_time self.assertEqual(time.quotient, 54678924378.0) self.assertEqual(time.remainder, 0.3216781233653267) self.assertEqual(other_time.quotient, 54678924378.0) self.assertEqual(other_time.remainder, 0.3216781233652267) self.assertAlmostEqual(result, 1.0e-13, places=13) time = Time(57854.0, 0.4536734584357) other_time = Time(float("inf"), float("inf")) result = time - other_time self.assertEqual(time.quotient, 57854.0) self.assertEqual(time.remainder, 0.4536734584357) self.assertEqual(other_time.quotient, float("inf")) self.assertEqual(other_time.remainder, float("inf")) self.assertEqual(result, -float("inf")) time = Time(57854.0, 0.4536734584357) other_time = Time(-float("inf"), -float("inf")) result = time - other_time self.assertEqual(time.quotient, 57854.0) self.assertEqual(time.remainder, 0.4536734584357) self.assertEqual(other_time.quotient, -float("inf")) self.assertEqual(other_time.remainder, -float("inf")) self.assertEqual(result, float("inf")) time = Time(float("inf"), float("inf")) other_time = Time(57854.0, 0.4536734584357) result = time - other_time self.assertEqual(time.quotient, float("inf")) self.assertEqual(time.remainder, float("inf")) self.assertEqual(other_time.quotient, 57854.0) self.assertEqual(other_time.remainder, 0.4536734584357) self.assertEqual(result, float("inf")) time = Time(-float("inf"), -float("inf")) other_time = Time(57854.0, 0.4536734584357) result = time - other_time self.assertEqual(time.quotient, -float("inf")) self.assertEqual(time.remainder, -float("inf")) self.assertEqual(other_time.quotient, 57854.0) self.assertEqual(other_time.remainder, 0.4536734584357) self.assertEqual(result, -float("inf"))
def test_greater_equal_comparison(self): time = Time(1.0, 0.5) other_time = Time(1.0, 0.5) self.assertTrue(time >= other_time) self.assertIsNot(time, other_time) time = Time(1.0, 0.6) other_time = Time(1.0, 0.5) self.assertTrue(time >= other_time) self.assertIsNot(time, other_time) time = Time(1.0, 0.4) other_time = Time(1.0, 0.5) self.assertFalse(time >= other_time) self.assertIsNot(time, other_time) time = Time(2.0, 0.5) other_time = Time(1.0, 0.5) self.assertTrue(time >= other_time) self.assertIsNot(time, other_time) time = Time(0.0, 0.5) other_time = Time(1.0, 0.5) self.assertFalse(time >= other_time) self.assertIsNot(time, other_time) time = Time(54678924378.0, 0.3216781233653267) other_time = Time(54678924378.0, 0.3216781233653267) self.assertTrue(time >= other_time) self.assertIsNot(time, other_time) time = Time(54678924378.0, 0.3216781233653266) other_time = Time(54678924378.0, 0.3216781233653267) self.assertFalse(time >= other_time) self.assertIsNot(time, other_time) time = Time(54678924377.0, 0.3216781233653267) other_time = Time(54678924378.0, 0.3216781233653267) self.assertFalse(time >= other_time) self.assertIsNot(time, other_time) time = Time(54678924378.0, 0.3216781233653267) other_time = Time(54678924378.0, 0.3216781233653266) self.assertTrue(time >= other_time) self.assertIsNot(time, other_time) time = Time(54678924378.0, 0.3216781233653267) other_time = Time(54678924377.0, 0.3216781233653267) self.assertTrue(time >= other_time) self.assertIsNot(time, other_time)