Merge branch 'fix-floatingpoint' into london_tidyingup

Incorporates the fix-floatingpoints bug fix. Now has ExactNode and ExactArrivalNode objects, and and 'Exact' kwarg.

Author: geraintpalmer

.hypothesis/examples/e1f6a1f10845f908/5c0168621a045c60

@@ -56,10 +56,18 @@ def have_event(self):
             self.rejection_dict[next_node.id_number][
                 self.next_class].append(self.next_event_date)
         self.event_dates_dict[self.next_node][
-            self.next_class] += self.inter_arrival(
-            self.next_node, self.next_class)
+            self.next_class] = self.increment_time(
+            self.event_dates_dict[self.next_node][
+            self.next_class], self.inter_arrival(
+            self.next_node, self.next_class))
         self.find_next_event_date()
 
+    def increment_time(self, original, increment):
+        """
+        Increments the original time by the increment
+        """
+        return original + increment
+
     def initialise_event_dates_dict(self):
         """
         Initialises the next event dates dictionary

ciw/arrival_node.py

@@ -24,9 +24,9 @@ def __init__(self,
         self.customer_class = customer_class
         self.queue_size_at_arrival = queue_size_at_arrival
         self.queue_size_at_departure = queue_size_at_departure
-        self.service_end_date = service_start_date + service_time
-        self.wait = service_start_date - arrival_date
-        self.blocked = exit_date - self.service_end_date
+        self.service_end_date = self.service_start_date + self.service_time
+        self.wait = self.service_start_date - self.arrival_date
+        self.blocked = self.exit_date - self.service_end_date
         self.node = node
         self.destination = destination
 

ciw/data_record.py

@@ -0,0 +1,46 @@
+from node import Node
+from arrival_node import ArrivalNode
+from decimal import Decimal, getcontext
+
+class ExactNode(Node):
+    """
+    Inherits from the Node class, implements a more
+    precise version of addition to fix discrepencies
+    with floating point numbers.
+    """
+    def increment_time(self, original, increment):
+        """
+        Increments the original time by the increment
+        """
+        return Decimal(str(original)) + Decimal(str(increment))
+
+    def get_service_time(self, cls):
+        """
+        Returns a service time for the given customer class
+        """
+        return Decimal(str(self.simulation.service_times[self.id_number][cls]()))
+
+    def get_now(self, current_time):
+        """
+        Gets the current time
+        """
+        return Decimal(str(current_time))
+
+
+class ExactArrivalNode(ArrivalNode):
+    """
+    Inherits from the ArrivalNode class, implements a
+    more precise version of addition to fix discrepencies
+    with floating point numbers.
+    """
+    def increment_time(self, original, increment):
+        """
+        Increments the original time by the increment
+        """
+        return Decimal(str(original)) + Decimal(str(increment))
+
+    def inter_arrival(self, nd, cls):
+        """
+        Samples the inter-arrival time for next class and node.
+        """
+        return Decimal(str(self.simulation.inter_arrival_times[nd][cls]()))

ciw/exactnode.py

@@ -19,32 +19,32 @@ def __init__(self, id_, simulation):
         Initialise a node.
         """
         self.simulation = simulation
-        self.mu = [self.simulation.mu[cls][id_-1]
+        self.mu = [self.simulation.mu[cls][id_ - 1]
             for cls in xrange(len(self.simulation.mu))]
-        self.scheduled_servers = self.simulation.schedules[id_-1]
+        self.scheduled_servers = self.simulation.schedules[id_ - 1]
         if self.scheduled_servers:
             self.schedule = self.simulation.parameters[
-                self.simulation.c[id_-1]]
+                self.simulation.c[id_ - 1]]
             self.cyclelength = self.simulation.parameters[
                 'Cycle_length']
             self.c = self.schedule[0][1]
-            self.masterschedule = [i*self.cyclelength + obs
-                for i in xrange(int(
+            self.masterschedule = [self.increment_time(i*self.cyclelength,
+                obs) for i in xrange(int(
                 self.simulation.max_simulation_time//self.cyclelength
                 ) + 2) for obs in [t[0] for t in self.schedule]][1:]
         else:
-            self.c = self.simulation.c[id_-1]
-        if self.simulation.queue_capacities[id_-1] == "Inf":
+            self.c = self.simulation.c[id_ - 1]
+        if self.simulation.queue_capacities[id_ - 1] == "Inf":
             self.node_capacity = "Inf"
         else:
             self.node_capacity = self.simulation.queue_capacities[
-            id_-1] + self.c
+            id_ - 1] + self.c
         self.transition_row = [self.simulation.transition_matrix[j][
-            id_-1] for j in xrange(len(
+            id_ - 1] for j in xrange(len(
             self.simulation.transition_matrix))]
         if self.simulation.class_change_matrix != 'NA':
             self.class_change = self.simulation.class_change_matrix[
-            id_-1]
+            id_ - 1]
         self.individuals = []
         self.id_number = id_
         if self.scheduled_servers:
@@ -53,7 +53,7 @@ def __init__(self, id_, simulation):
             self.next_event_date = "Inf"
         self.blocked_queue = []
         if self.c < 'Inf':
-            self.servers = [Server(self, i+1) for i in xrange(self.c)]
+            self.servers = [Server(self, i + 1) for i in xrange(self.c)]
             if simulation.detecting_deadlock:
                 self.simulation.digraph.add_nodes_from([str(s)
                     for s in self.servers])
@@ -110,16 +110,16 @@ def begin_service_if_possible_accept(self,
         Begins the service of the next individual, giving
         that customer a service time, end date and node.
         """
-        next_individual.arrival_date = current_time
-        next_individual.service_time = self.simulation.service_times[
-            self.id_number][next_individual.customer_class]()
+        next_individual.arrival_date = self.get_now(current_time)
+        next_individual.service_time = self.get_service_time(
+            next_individual.customer_class)
         if self.free_server():
             if self.c < 'Inf':
                 self.attach_server(self.find_free_server(),
                                    next_individual)
-            next_individual.service_start_date = current_time
-            next_individual.service_end_date = (current_time + 
-                next_individual.service_time)
+            next_individual.service_start_date = self.get_now(current_time)
+            next_individual.service_end_date = self.increment_time(
+                current_time, next_individual.service_time)
 
     def begin_service_if_possible_change_shift(self, current_time):
         """
@@ -131,9 +131,9 @@ def begin_service_if_possible_change_shift(self, current_time):
             if len([i for i in self.individuals if not i.server]) > 0:
                 ind = [i for i in self.individuals if not i.server][0]
                 self.attach_server(srvr, ind)
-                ind.service_start_date = current_time
-                ind.service_end_date = (ind.service_start_date +
-                    ind.service_time)
+                ind.service_start_date = self.get_now(current_time)
+                ind.service_end_date = self.increment_time(
+                    ind.service_start_date, ind.service_time)
 
     def begin_service_if_possible_release(self, current_time):
         """
@@ -145,9 +145,9 @@ def begin_service_if_possible_release(self, current_time):
             if len([i for i in self.individuals if not i.server]) > 0:
                 ind = [i for i in self.individuals if not i.server][0]
                 self.attach_server(srvr, ind)
-                ind.service_start_date = current_time
-                ind.service_end_date = (ind.service_start_date +
-                    ind.service_time)
+                ind.service_start_date = self.get_now(current_time)
+                ind.service_end_date = self.increment_time(
+                    ind.service_start_date, ind.service_time)
 
     def block_individual(self, individual, next_node):
         """
@@ -170,10 +170,10 @@ def change_customer_class(self,individual):
         according to a probability distribution.
         """
         if self.simulation.class_change_matrix != 'NA':
-            individual.previous_class=individual.customer_class
-            individual.customer_class=nprandom.choice(
+            individual.previous_class = individual.customer_class
+            individual.customer_class = nprandom.choice(
                 xrange(len(self.class_change)),
-                p=self.class_change[individual.previous_class])
+                p = self.class_change[individual.previous_class])
 
     def change_shift(self):
         """
@@ -188,7 +188,7 @@ def change_shift(self):
         try: inx = self.schedule.index(shift)
         except:
             tms = [obs[0] for obs in self.schedule]
-            diffs = [abs(x-shift) for x in tms]
+            diffs = [abs(x-float(shift)) for x in tms]
             indx = diffs.index(min(diffs))
 
         self.take_servers_off_duty()
@@ -261,6 +261,12 @@ def finish_service(self):
         else:
             self.block_individual(next_individual, next_node)
 
+    def get_now(self, current_time):
+        """
+        Gets the current time
+        """
+        return current_time
+
     def have_event(self):
         """
         Has an event
@@ -270,6 +276,12 @@ def have_event(self):
         else:
             self.finish_service()
 
+    def increment_time(self, original, increment):
+        """
+        Increments the original time by the increment
+        """
+        return original + increment
+
     def kill_server(self,srvr):
         """
         Kills server.
@@ -282,7 +294,7 @@ def next_node(self, customer_class):
         Finds the next node according the random distribution.
         """
         return nprandom.choice(self.simulation.nodes[1:],
-            p=self.transition_row[customer_class]+[1.0-sum(
+            p = self.transition_row[customer_class] + [1.0 - sum(
             self.transition_row[customer_class])])
 
     def release(self, next_individual_index, next_node, current_time):
@@ -319,6 +331,12 @@ def release_blocked_individual(self, current_time):
             node_to_receive_from.release(individual_to_receive_index,
                 self, current_time)
 
+    def get_service_time(self, cls):
+        """
+        Returns a service time for the given customer class
+        """
+        return self.simulation.service_times[self.id_number][cls]()
+
     def take_servers_off_duty(self):
         """
         Gathers servers that should be deleted.
@@ -339,7 +357,7 @@ def update_next_event_date(self, current_time):
         next_end_service = min([ind.service_end_date
             for ind in self.individuals
             if not ind.is_blocked
-            if ind.service_end_date>=current_time] + ["Inf"])
+            if ind.service_end_date >= current_time] + ["Inf"])
         if self.scheduled_servers:
             next_shift_change = self.masterschedule[0]
             self.next_event_date = min(

ciw/node.py

@@ -4,12 +4,14 @@
     gammavariate, gauss, lognormvariate, weibullvariate, choice)
 from csv import writer, reader
 import copy
+from decimal import Decimal, getcontext
 
 import yaml
 import networkx as nx
 import numpy.random as nprandom
 
 from node import Node
+from exactnode import ExactNode, ExactArrivalNode
 from arrival_node import ArrivalNode
 from exit_node import ExitNode
 from server import Server
@@ -31,6 +33,13 @@ def __init__(self, *args, **kwargs):
             parameters = kwargs
         self.parameters = self.build_parameters(parameters)
         self.check_valid_parameters()
+        if not self.parameters['Exact']:
+            NodeType = Node
+            ArrivalNodeType = ArrivalNode
+        else:
+            NodeType = ExactNode
+            ArrivalNodeType = ExactArrivalNode
+            getcontext().prec = self.parameters['Exact']
         self.name = self.parameters['Name']
         self.c = self.parameters['Number_of_servers']
         self.number_of_nodes = self.parameters['Number_of_nodes']
@@ -59,9 +68,9 @@ def __init__(self, *args, **kwargs):
         self.max_simulation_time = self.parameters['Simulation_time']
         self.inter_arrival_times = self.find_times_dict(self.lmbda)
         self.service_times = self.find_times_dict(self.mu)
-        self.transitive_nodes = [Node(i + 1, self)
+        self.transitive_nodes = [NodeType(i + 1, self)
             for i in xrange(len(self.c))]
-        self.nodes = ([ArrivalNode(self)] +
+        self.nodes = ([ArrivalNodeType(self)] +
                       self.transitive_nodes +
                       [ExitNode("Inf")])
         self.statetracker = self.choose_tracker()
@@ -98,7 +107,8 @@ def build_parameters(self, params):
             'Queue_capacities': ['Inf' for _ in xrange(len(
                 params['Number_of_servers']))],
             'Detect_deadlock': False,
-            'Simulation_time': None
+            'Simulation_time': None,
+            'Exact': False
             }
 
         for a in default_dict:

ciw/simulation.py

@@ -6,6 +6,7 @@
 import os
 import copy
 from numpy import random as nprandom
+from decimal import Decimal
 
 
 def set_seed(x):
@@ -354,6 +355,7 @@ def test_init_method_from_kws(self):
                                         'Number_of_nodes': 4,
                                         'Simulation_time': 2500,
                                         'Detect_deadlock': False,
+                                        'Exact': False,
                                         'Name': 'Simulation',
                                         'Number_of_servers': [9, 10, 8, 8],
                                         'Queue_capacities': [20, 'Inf', 30, 'Inf'],
@@ -415,7 +417,8 @@ def test_simple_init_method(self,
             'Name': 'Simulation',
             'Queue_capacities': ['Inf'],
             'Simulation_time': Simulation_time,
-            'Detect_deadlock': False
+            'Detect_deadlock': False,
+            'Exact': False
         }
         self.assertEqual(Q.parameters, expected_dictionary)
         self.assertEqual(Q.lmbda, [[['Exponential', arrival_rate]]])
@@ -455,6 +458,7 @@ def test_build_mmc_parameters(self,
             'Queue_capacities': ['Inf'],
             'Simulation_time': Simulation_time,
             'Detect_deadlock': False,
+            'Exact': False,
             'Name': 'Simulation'
         }
         self.assertEqual(Q.build_parameters(params), expected_dictionary)
@@ -680,3 +684,46 @@ def test_simultaneous_events_example(self):
         self.assertEqual(len(inds), 3)
         self.assertTrue(all([x[6]==5.0 for x in recs[1:]]))
 
+    def test_exactness(self):
+        set_seed(777)
+        Arrival_distributions = [['Exponential', 20]]
+        Service_distributions = [['Deterministic', 0.01]]
+        Transition_matrices = [[0.0]]
+        Simulation_time = 10
+        Number_of_servers = ['server_schedule']
+        Cycle_length = 3
+        server_schedule = [[0.0, 0], [0.5, 1], [0.55, 0]]
+        Q = ciw.Simulation(Arrival_distributions=Arrival_distributions,
+                           Service_distributions=Service_distributions,
+                           Transition_matrices=Transition_matrices,
+                           Simulation_time=Simulation_time,
+                           Number_of_servers=Number_of_servers,
+                           Cycle_length=Cycle_length,
+                           server_schedule=server_schedule)
+        Q.simulate_until_max_time()
+        recs = Q.get_all_records(headers=False)
+        mod_service_starts = [obs%Cycle_length for obs in [r[5] for r in recs]]
+        self.assertNotEqual(set(mod_service_starts), set([0.50, 0.51, 0.52, 0.53, 0.54]))
+
+        set_seed(777)
+        Arrival_distributions = [['Exponential', 20]]
+        Service_distributions = [['Deterministic', 0.01]]
+        Transition_matrices = [[0.0]]
+        Simulation_time = 10
+        Number_of_servers = ['server_schedule']
+        Cycle_length = 3
+        server_schedule = [[0.0, 0], [0.5, 1], [0.55, 0]]
+        Q = ciw.Simulation(Arrival_distributions=Arrival_distributions,
+                           Service_distributions=Service_distributions,
+                           Transition_matrices=Transition_matrices,
+                           Simulation_time=Simulation_time,
+                           Number_of_servers=Number_of_servers,
+                           Cycle_length=Cycle_length,
+                           server_schedule=server_schedule,
+                           Exact=14)
+        Q.simulate_until_max_time()
+        recs = Q.get_all_records(headers=False)
+        mod_service_starts = [obs%Cycle_length for obs in [r[5] for r in recs]]
+        self.assertEqual(set(mod_service_starts), set([Decimal(k) for k in ['0.50', '0.51', '0.52', '0.53', '0.54']]))
+
+