diff --git a/.hypothesis/examples/2135bf6f68d836d2/65c46e75b9714bfa b/.hypothesis/examples/2135bf6f68d836d2/65c46e75b9714bfa new file mode 100644 index 00000000..db3879aa Binary files /dev/null and b/.hypothesis/examples/2135bf6f68d836d2/65c46e75b9714bfa differ diff --git a/.hypothesis/examples/2135bf6f68d836d2/c42343d5a52b6b7d b/.hypothesis/examples/2135bf6f68d836d2/c42343d5a52b6b7d new file mode 100644 index 00000000..24c5ad62 Binary files /dev/null and b/.hypothesis/examples/2135bf6f68d836d2/c42343d5a52b6b7d differ diff --git a/.hypothesis/examples/29d64452f36fbdaf/ac569ea775eac75b b/.hypothesis/examples/29d64452f36fbdaf/ac569ea775eac75b new file mode 100644 index 00000000..fe2d6d0f Binary files /dev/null and b/.hypothesis/examples/29d64452f36fbdaf/ac569ea775eac75b differ diff --git a/.hypothesis/examples/47511cc3fada18b5/0741f1076bfd4dee b/.hypothesis/examples/47511cc3fada18b5/0741f1076bfd4dee new file mode 100644 index 00000000..8f2f11a0 Binary files /dev/null and b/.hypothesis/examples/47511cc3fada18b5/0741f1076bfd4dee differ diff --git a/.hypothesis/examples/47511cc3fada18b5/10a2996aea90f1d8 b/.hypothesis/examples/47511cc3fada18b5/10a2996aea90f1d8 new file mode 100644 index 00000000..c972c963 Binary files /dev/null and b/.hypothesis/examples/47511cc3fada18b5/10a2996aea90f1d8 differ diff --git a/.hypothesis/examples/47511cc3fada18b5/1152f0ab04f2a89d b/.hypothesis/examples/47511cc3fada18b5/1152f0ab04f2a89d new file mode 100644 index 00000000..6c228740 Binary files /dev/null and b/.hypothesis/examples/47511cc3fada18b5/1152f0ab04f2a89d differ diff --git a/.hypothesis/examples/47511cc3fada18b5/1771a1b26f688631 b/.hypothesis/examples/47511cc3fada18b5/1771a1b26f688631 new file mode 100644 index 00000000..3e80548a Binary files /dev/null and b/.hypothesis/examples/47511cc3fada18b5/1771a1b26f688631 differ diff --git a/.hypothesis/examples/47511cc3fada18b5/3e458017db7dae1e b/.hypothesis/examples/47511cc3fada18b5/3e458017db7dae1e new file mode 100644 index 00000000..c1f01f35 Binary files /dev/null and b/.hypothesis/examples/47511cc3fada18b5/3e458017db7dae1e differ diff --git a/.hypothesis/examples/47511cc3fada18b5/5557a27d5a288ae3 b/.hypothesis/examples/47511cc3fada18b5/5557a27d5a288ae3 new file mode 100644 index 00000000..c9961447 Binary files /dev/null and b/.hypothesis/examples/47511cc3fada18b5/5557a27d5a288ae3 differ diff --git a/.hypothesis/examples/47511cc3fada18b5/5b7a79791f0dbd42 b/.hypothesis/examples/47511cc3fada18b5/5b7a79791f0dbd42 new file mode 100644 index 00000000..f12f62b4 Binary files /dev/null and b/.hypothesis/examples/47511cc3fada18b5/5b7a79791f0dbd42 differ diff --git a/.hypothesis/examples/47511cc3fada18b5/5edb91fbf991a985 b/.hypothesis/examples/47511cc3fada18b5/5edb91fbf991a985 new file mode 100644 index 00000000..ad91e2d5 Binary files /dev/null and b/.hypothesis/examples/47511cc3fada18b5/5edb91fbf991a985 differ diff --git a/.hypothesis/examples/47511cc3fada18b5/61dfa06b5275e1ad b/.hypothesis/examples/47511cc3fada18b5/61dfa06b5275e1ad new file mode 100644 index 00000000..136d05fc Binary files /dev/null and b/.hypothesis/examples/47511cc3fada18b5/61dfa06b5275e1ad differ diff --git a/.hypothesis/examples/47511cc3fada18b5/6cf8e4704d16f7ec b/.hypothesis/examples/47511cc3fada18b5/6cf8e4704d16f7ec new file mode 100644 index 00000000..24f7f608 Binary files /dev/null and b/.hypothesis/examples/47511cc3fada18b5/6cf8e4704d16f7ec differ diff --git a/.hypothesis/examples/47511cc3fada18b5/6efee383d249fa73 b/.hypothesis/examples/47511cc3fada18b5/6efee383d249fa73 new file mode 100644 index 00000000..85f1ace9 Binary files /dev/null and b/.hypothesis/examples/47511cc3fada18b5/6efee383d249fa73 differ diff --git a/.hypothesis/examples/47511cc3fada18b5/741c2e18169a40db b/.hypothesis/examples/47511cc3fada18b5/741c2e18169a40db new file mode 100644 index 00000000..3434c4cd Binary files /dev/null and b/.hypothesis/examples/47511cc3fada18b5/741c2e18169a40db differ diff --git a/.hypothesis/examples/47511cc3fada18b5/7430cf11ada736b5 b/.hypothesis/examples/47511cc3fada18b5/7430cf11ada736b5 new file mode 100644 index 00000000..33983532 Binary files /dev/null and b/.hypothesis/examples/47511cc3fada18b5/7430cf11ada736b5 differ diff --git a/.hypothesis/examples/47511cc3fada18b5/7d3b2d76bff59dba b/.hypothesis/examples/47511cc3fada18b5/7d3b2d76bff59dba new file mode 100644 index 00000000..b5c9c81c Binary files /dev/null and b/.hypothesis/examples/47511cc3fada18b5/7d3b2d76bff59dba differ diff --git a/.hypothesis/examples/47511cc3fada18b5/7fb963fcece7b1b9 b/.hypothesis/examples/47511cc3fada18b5/7fb963fcece7b1b9 new file mode 100644 index 00000000..51274457 Binary files /dev/null and b/.hypothesis/examples/47511cc3fada18b5/7fb963fcece7b1b9 differ diff --git a/.hypothesis/examples/47511cc3fada18b5/8d8342001445715d b/.hypothesis/examples/47511cc3fada18b5/8d8342001445715d new file mode 100644 index 00000000..1d7b30c9 Binary files /dev/null and b/.hypothesis/examples/47511cc3fada18b5/8d8342001445715d differ diff --git a/.hypothesis/examples/47511cc3fada18b5/91f4887796e9e971 b/.hypothesis/examples/47511cc3fada18b5/91f4887796e9e971 new file mode 100644 index 00000000..34b78fc9 Binary files /dev/null and b/.hypothesis/examples/47511cc3fada18b5/91f4887796e9e971 differ diff --git a/.hypothesis/examples/47511cc3fada18b5/af47582a24ec972c b/.hypothesis/examples/47511cc3fada18b5/af47582a24ec972c new file mode 100644 index 00000000..844a0ce4 Binary files /dev/null and b/.hypothesis/examples/47511cc3fada18b5/af47582a24ec972c differ diff --git a/.hypothesis/examples/47511cc3fada18b5/b9e03c5936236a39 b/.hypothesis/examples/47511cc3fada18b5/b9e03c5936236a39 new file mode 100644 index 00000000..95704827 Binary files /dev/null and b/.hypothesis/examples/47511cc3fada18b5/b9e03c5936236a39 differ diff --git a/.hypothesis/examples/47511cc3fada18b5/bb345b85493b6378 b/.hypothesis/examples/47511cc3fada18b5/bb345b85493b6378 new file mode 100644 index 00000000..74539078 Binary files /dev/null and b/.hypothesis/examples/47511cc3fada18b5/bb345b85493b6378 differ diff --git a/.hypothesis/examples/47511cc3fada18b5/bd23f3cf9bc92e17 b/.hypothesis/examples/47511cc3fada18b5/bd23f3cf9bc92e17 new file mode 100644 index 00000000..0b98af4d Binary files /dev/null and b/.hypothesis/examples/47511cc3fada18b5/bd23f3cf9bc92e17 differ diff --git a/.hypothesis/examples/47511cc3fada18b5/bdc1ccdbc8646581 b/.hypothesis/examples/47511cc3fada18b5/bdc1ccdbc8646581 new file mode 100644 index 00000000..6cad170c Binary files /dev/null and b/.hypothesis/examples/47511cc3fada18b5/bdc1ccdbc8646581 differ diff --git a/.hypothesis/examples/47511cc3fada18b5/c5e579adec86bcc0 b/.hypothesis/examples/47511cc3fada18b5/c5e579adec86bcc0 new file mode 100644 index 00000000..4fc1e2e4 Binary files /dev/null and b/.hypothesis/examples/47511cc3fada18b5/c5e579adec86bcc0 differ diff --git a/.hypothesis/examples/47511cc3fada18b5/c871833281806d89 b/.hypothesis/examples/47511cc3fada18b5/c871833281806d89 new file mode 100644 index 00000000..5a049a73 Binary files /dev/null and b/.hypothesis/examples/47511cc3fada18b5/c871833281806d89 differ diff --git a/.hypothesis/examples/47511cc3fada18b5/d58bede0179dd54a b/.hypothesis/examples/47511cc3fada18b5/d58bede0179dd54a new file mode 100644 index 00000000..f28c570d Binary files /dev/null and b/.hypothesis/examples/47511cc3fada18b5/d58bede0179dd54a differ diff --git a/.hypothesis/examples/47511cc3fada18b5/dcf7e547a0e579ef b/.hypothesis/examples/47511cc3fada18b5/dcf7e547a0e579ef new file mode 100644 index 00000000..dfc4a326 Binary files /dev/null and b/.hypothesis/examples/47511cc3fada18b5/dcf7e547a0e579ef differ diff --git a/.hypothesis/examples/47511cc3fada18b5/de4879dabe892227 b/.hypothesis/examples/47511cc3fada18b5/de4879dabe892227 new file mode 100644 index 00000000..5c6df770 Binary files /dev/null and b/.hypothesis/examples/47511cc3fada18b5/de4879dabe892227 differ diff --git a/.hypothesis/examples/47511cc3fada18b5/f48053ecb25401f5 b/.hypothesis/examples/47511cc3fada18b5/f48053ecb25401f5 new file mode 100644 index 00000000..95f2aad5 Binary files /dev/null and b/.hypothesis/examples/47511cc3fada18b5/f48053ecb25401f5 differ diff --git a/.hypothesis/examples/69ab7130ae480724/6f5a1b20f7726104 b/.hypothesis/examples/69ab7130ae480724/6f5a1b20f7726104 new file mode 100644 index 00000000..3cbf2a41 Binary files /dev/null and b/.hypothesis/examples/69ab7130ae480724/6f5a1b20f7726104 differ diff --git a/.hypothesis/examples/69ab7130ae480724/93e8767cb804d887 b/.hypothesis/examples/69ab7130ae480724/93e8767cb804d887 new file mode 100644 index 00000000..11838b56 Binary files /dev/null and b/.hypothesis/examples/69ab7130ae480724/93e8767cb804d887 differ diff --git a/.hypothesis/examples/69ab7130ae480724/e7d363ef91203276 b/.hypothesis/examples/69ab7130ae480724/e7d363ef91203276 new file mode 100644 index 00000000..ca79a451 Binary files /dev/null and b/.hypothesis/examples/69ab7130ae480724/e7d363ef91203276 differ diff --git a/.hypothesis/examples/8c8860643dae35d1/d3399b7262fb56cb b/.hypothesis/examples/8c8860643dae35d1/d3399b7262fb56cb new file mode 100644 index 00000000..4ac5fc6c Binary files /dev/null and b/.hypothesis/examples/8c8860643dae35d1/d3399b7262fb56cb differ diff --git a/.hypothesis/examples/8f69b08f1956c2f7/c665ae7d6adb0d2a b/.hypothesis/examples/8f69b08f1956c2f7/c665ae7d6adb0d2a new file mode 100644 index 00000000..bfd7db76 Binary files /dev/null and b/.hypothesis/examples/8f69b08f1956c2f7/c665ae7d6adb0d2a differ diff --git a/.hypothesis/examples/a40d01c034da88b1/274f542c0a374f79 b/.hypothesis/examples/a40d01c034da88b1/274f542c0a374f79 new file mode 100644 index 00000000..3fe79fb9 Binary files /dev/null and b/.hypothesis/examples/a40d01c034da88b1/274f542c0a374f79 differ diff --git a/.hypothesis/examples/a40d01c034da88b1/64a58bdeba6666aa b/.hypothesis/examples/a40d01c034da88b1/64a58bdeba6666aa deleted file mode 100644 index 32c19c41..00000000 Binary files a/.hypothesis/examples/a40d01c034da88b1/64a58bdeba6666aa and /dev/null differ diff --git a/.hypothesis/examples/c105d3723925d8e5/379635829c16b65d b/.hypothesis/examples/c105d3723925d8e5/379635829c16b65d new file mode 100644 index 00000000..882fec18 Binary files /dev/null and b/.hypothesis/examples/c105d3723925d8e5/379635829c16b65d differ diff --git a/.hypothesis/examples/c105d3723925d8e5/b80aa24bf5892ac2 b/.hypothesis/examples/c105d3723925d8e5/b80aa24bf5892ac2 new file mode 100644 index 00000000..5acc661c Binary files /dev/null and b/.hypothesis/examples/c105d3723925d8e5/b80aa24bf5892ac2 differ diff --git a/.hypothesis/examples/c6ec2939c8e3de8f/223a3b1db81ce7d2 b/.hypothesis/examples/c6ec2939c8e3de8f/223a3b1db81ce7d2 new file mode 100644 index 00000000..1b0c0f24 Binary files /dev/null and b/.hypothesis/examples/c6ec2939c8e3de8f/223a3b1db81ce7d2 differ diff --git a/.hypothesis/examples/c6ec2939c8e3de8f/b124a569a948fbbe b/.hypothesis/examples/c6ec2939c8e3de8f/b124a569a948fbbe new file mode 100644 index 00000000..f4145f2e Binary files /dev/null and b/.hypothesis/examples/c6ec2939c8e3de8f/b124a569a948fbbe differ diff --git a/.hypothesis/examples/c6ec2939c8e3de8f/bc33fbaa46b1daf6 b/.hypothesis/examples/c6ec2939c8e3de8f/bc33fbaa46b1daf6 new file mode 100644 index 00000000..91f39d90 Binary files /dev/null and b/.hypothesis/examples/c6ec2939c8e3de8f/bc33fbaa46b1daf6 differ diff --git a/.hypothesis/examples/eceffc5f24ea1d52/152b4186e83aa051 b/.hypothesis/examples/eceffc5f24ea1d52/152b4186e83aa051 deleted file mode 100644 index bf81a7f7..00000000 Binary files a/.hypothesis/examples/eceffc5f24ea1d52/152b4186e83aa051 and /dev/null differ diff --git a/.hypothesis/examples/eceffc5f24ea1d52/20a0fe39a85d6d45 b/.hypothesis/examples/eceffc5f24ea1d52/20a0fe39a85d6d45 deleted file mode 100644 index 7b181009..00000000 Binary files a/.hypothesis/examples/eceffc5f24ea1d52/20a0fe39a85d6d45 and /dev/null differ diff --git a/.hypothesis/examples/eceffc5f24ea1d52/32967d840a1e8096 b/.hypothesis/examples/eceffc5f24ea1d52/32967d840a1e8096 deleted file mode 100644 index 9cd0449f..00000000 Binary files a/.hypothesis/examples/eceffc5f24ea1d52/32967d840a1e8096 and /dev/null differ diff --git a/.hypothesis/examples/eceffc5f24ea1d52/3c453f9be77b3e8a b/.hypothesis/examples/eceffc5f24ea1d52/3c453f9be77b3e8a deleted file mode 100644 index fd673334..00000000 Binary files a/.hypothesis/examples/eceffc5f24ea1d52/3c453f9be77b3e8a and /dev/null differ diff --git a/.hypothesis/examples/eceffc5f24ea1d52/3f5231e170f31715 b/.hypothesis/examples/eceffc5f24ea1d52/3f5231e170f31715 deleted file mode 100644 index bf8a1ec6..00000000 Binary files a/.hypothesis/examples/eceffc5f24ea1d52/3f5231e170f31715 and /dev/null differ diff --git a/.hypothesis/examples/eceffc5f24ea1d52/7308f95258218e43 b/.hypothesis/examples/eceffc5f24ea1d52/7308f95258218e43 deleted file mode 100644 index 80e3c0d2..00000000 Binary files a/.hypothesis/examples/eceffc5f24ea1d52/7308f95258218e43 and /dev/null differ diff --git a/.hypothesis/examples/eceffc5f24ea1d52/7413e307d0be0208 b/.hypothesis/examples/eceffc5f24ea1d52/7413e307d0be0208 deleted file mode 100644 index edfa9679..00000000 Binary files a/.hypothesis/examples/eceffc5f24ea1d52/7413e307d0be0208 and /dev/null differ diff --git a/.hypothesis/examples/eceffc5f24ea1d52/8ed123916572b4ee b/.hypothesis/examples/eceffc5f24ea1d52/8ed123916572b4ee deleted file mode 100644 index f28b39a0..00000000 Binary files a/.hypothesis/examples/eceffc5f24ea1d52/8ed123916572b4ee and /dev/null differ diff --git a/.hypothesis/examples/eceffc5f24ea1d52/accb605f2057c9fd b/.hypothesis/examples/eceffc5f24ea1d52/accb605f2057c9fd deleted file mode 100644 index 4eb65110..00000000 Binary files a/.hypothesis/examples/eceffc5f24ea1d52/accb605f2057c9fd and /dev/null differ diff --git a/.hypothesis/examples/f0a58a77bff18489/366feeaafbca4d07 b/.hypothesis/examples/f0a58a77bff18489/366feeaafbca4d07 new file mode 100644 index 00000000..c0c75ee7 Binary files /dev/null and b/.hypothesis/examples/f0a58a77bff18489/366feeaafbca4d07 differ diff --git a/.hypothesis/examples/f0a58a77bff18489/4a9a5c3e5c6ed79f b/.hypothesis/examples/f0a58a77bff18489/4a9a5c3e5c6ed79f new file mode 100644 index 00000000..4b106eeb Binary files /dev/null and b/.hypothesis/examples/f0a58a77bff18489/4a9a5c3e5c6ed79f differ diff --git a/.hypothesis/examples/f0a58a77bff18489/804f0714ecd02a62 b/.hypothesis/examples/f0a58a77bff18489/804f0714ecd02a62 new file mode 100644 index 00000000..9181b44c Binary files /dev/null and b/.hypothesis/examples/f0a58a77bff18489/804f0714ecd02a62 differ diff --git a/.hypothesis/examples/fabf589bf8d75544/31cd3f2a0f974e08 b/.hypothesis/examples/fabf589bf8d75544/31cd3f2a0f974e08 new file mode 100644 index 00000000..bfb4eb7e Binary files /dev/null and b/.hypothesis/examples/fabf589bf8d75544/31cd3f2a0f974e08 differ diff --git a/.hypothesis/examples/fabf589bf8d75544/59bffa4336791568 b/.hypothesis/examples/fabf589bf8d75544/59bffa4336791568 new file mode 100644 index 00000000..281925f0 Binary files /dev/null and b/.hypothesis/examples/fabf589bf8d75544/59bffa4336791568 differ diff --git a/.hypothesis/examples/fabf589bf8d75544/690dca1ff62134d6 b/.hypothesis/examples/fabf589bf8d75544/690dca1ff62134d6 new file mode 100644 index 00000000..db44baeb Binary files /dev/null and b/.hypothesis/examples/fabf589bf8d75544/690dca1ff62134d6 differ diff --git a/.hypothesis/examples/ff07599ee3bc5e8c/22a469db02ae65e8 b/.hypothesis/examples/ff07599ee3bc5e8c/22a469db02ae65e8 new file mode 100644 index 00000000..c505e941 Binary files /dev/null and b/.hypothesis/examples/ff07599ee3bc5e8c/22a469db02ae65e8 differ diff --git a/ciw/__init__.py b/ciw/__init__.py index 0a2232aa..24423fc0 100644 --- a/ciw/__init__.py +++ b/ciw/__init__.py @@ -5,4 +5,6 @@ from arrival_node import ArrivalNode from exit_node import ExitNode from node import Node -from import_params import load_parameters \ No newline at end of file +from import_params import load_parameters + +__version__ = '0.0.3' \ No newline at end of file diff --git a/ciw/arrival_node.py b/ciw/arrival_node.py index 7fe085fc..770f5f06 100644 --- a/ciw/arrival_node.py +++ b/ciw/arrival_node.py @@ -12,23 +12,31 @@ def __init__(self, simulation): """ self.simulation = simulation self.number_of_individuals = 0 - self.next_event_dates_dict = {nd + 1:{cls:False for cls in range(self.simulation.parameters['Number_of_classes'])} for nd in range(self.simulation.number_of_nodes)} - self.initialise_next_event_dates_dict() + self.event_dates_dict = {nd + 1:{cls:False + for cls in range(self.simulation.parameters['Number_of_classes'])} + for nd in range(self.simulation.number_of_nodes)} + self.initialise_event_dates_dict() self.find_next_event_date() - def initialise_next_event_dates_dict(self): + def __repr__(self): """ - Initialises the next event dates dictionary with random times for each node and class + Representation of an arrival node. """ - for nd in self.next_event_dates_dict: - for cls in self.next_event_dates_dict[nd]: - self.next_event_dates_dict[nd][cls] = self.simulation.inter_arrival_times[nd][cls]() + return 'Arrival Node' - def __repr__(self): + def find_next_event_date(self): """ - Representation of a node:: + Finds the time of the next event at this node. """ - return 'Arrival Node' + times = [[self.event_dates_dict[nd+1][cls] + for cls in range(len(self.event_dates_dict[1]))] + for nd in range(len(self.event_dates_dict))] + mintimes = [min(obs) for obs in times] + nd = mintimes.index(min(mintimes)) + cls = times[nd].index(min(times[nd])) + self.next_node = nd + 1 + self.next_class = cls + self.next_event_date = self.event_dates_dict[self.next_node][self.next_class] def have_event(self): """ @@ -39,29 +47,26 @@ def have_event(self): next_node = self.simulation.transitive_nodes[self.next_node-1] if len(next_node.individuals) < next_node.node_capacity: next_node.accept(next_individual, self.next_event_date) - self.next_event_dates_dict[self.next_node][self.next_class] += self.sample_next_event_time(self.next_node, self.next_class) + 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 sample_next_event_time(self, nd, cls): + def initialise_event_dates_dict(self): """ - Expovariate but omits zero + Initialises the next event dates dictionary + with random times for each node and class. """ - return self.simulation.inter_arrival_times[nd][cls]() + for nd in self.event_dates_dict: + for cls in self.event_dates_dict[nd]: + self.event_dates_dict[nd][cls] = self.simulation.inter_arrival_times[nd][cls]() - def find_next_event_date(self): + def inter_arrival(self, nd, cls): """ - Finds the time of the next event at this node + Samples the inter-arrival time for next class and node. """ - times = [[self.next_event_dates_dict[nd+1][cls] for cls in range(len(self.next_event_dates_dict[1]))] for nd in range(len(self.next_event_dates_dict))] - mintimes = [min(obs) for obs in times] - nd = mintimes.index(min(mintimes)) - cls = times[nd].index(min(times[nd])) - self.next_node = nd + 1 - self.next_class = cls - self.next_event_date = self.next_event_dates_dict[self.next_node][self.next_class] + return self.simulation.inter_arrival_times[nd][cls]() def update_next_event_date(self): """ - Passes, updating next event happens at time of event + Passes, updating next event happens at time of event. """ pass diff --git a/ciw/data_record.py b/ciw/data_record.py index 1ce85a8c..d637e145 100644 --- a/ciw/data_record.py +++ b/ciw/data_record.py @@ -4,16 +4,19 @@ class DataRecord: """ A class for a data record """ - def __init__(self, arrival_date, service_time, service_start_date, exit_date, node, destination, customer_class, queue_size_at_arrival, queue_size_at_departure): + def __init__(self, + arrival_date, + service_time, + service_start_date, + exit_date, + node, + destination, + customer_class, + queue_size_at_arrival, + queue_size_at_departure): """ An example of a data record instance. """ - if exit_date < arrival_date: - raise ValueError('Arrival date should preceed exit date') - - if service_time < 0: - raise ValueError('Service time should be positive') - self.arrival_date = arrival_date self.service_time = service_time self.service_start_date = service_start_date @@ -21,9 +24,14 @@ def __init__(self, arrival_date, service_time, service_start_date, exit_date, no 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.node = node self.destination = destination + + def __repr__(self): + """ + Represents the Data Record + """ + return "Data Record" diff --git a/ciw/import_params.py b/ciw/import_params.py index 44267084..d75ad962 100644 --- a/ciw/import_params.py +++ b/ciw/import_params.py @@ -12,5 +12,4 @@ def load_parameters(directory_name): parameter_file = open(parameter_file_name, 'r') parameters = yaml.load(parameter_file) parameter_file.close() - return parameters \ No newline at end of file diff --git a/ciw/node.py b/ciw/node.py index f23cf620..0216c968 100644 --- a/ciw/node.py +++ b/ciw/node.py @@ -2,56 +2,86 @@ from random import random, choice import os from csv import writer + import networkx as nx import numpy.random as nprandom from data_record import DataRecord from server import Server + class Node: """ Class for a node on our network """ - def __init__(self, id_number, simulation): + def __init__(self, id_, simulation): """ Initialise a node. """ self.simulation = simulation - self.mu = [self.simulation.mu[cls][id_number-1] for cls in range(len(self.simulation.mu))] - self.scheduled_servers = self.simulation.schedules[id_number-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] if self.scheduled_servers: - self.schedule = self.simulation.parameters[self.simulation.c[id_number-1]] + self.schedule = self.simulation.parameters[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 range(int(self.simulation.max_simulation_time//self.cyclelength) + 2) for obs in [t[0] for t in self.schedule]][1:] + self.masterschedule = [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_number-1] - self.node_capacity = "Inf" if self.simulation.queue_capacities[id_number-1] == "Inf" else self.simulation.queue_capacities[id_number-1] + self.c - self.transition_row = [self.simulation.transition_matrix[j][id_number-1] for j in range(len(self.simulation.transition_matrix))] + 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 + self.transition_row = [self.simulation.transition_matrix[j][id_-1] + for j in xrange(len(self.simulation.transition_matrix))] if self.simulation.class_change_matrix != 'NA': - self.class_change_for_node = self.simulation.class_change_matrix[id_number-1] + self.class_change_for_node = self.simulation.class_change_matrix[id_-1] self.individuals = [] - self.id_number = id_number + self.id_number = id_ if self.scheduled_servers: self.next_event_date = self.masterschedule[0] else: self.next_event_date = "Inf" self.blocked_queue = [] if self.c < 'Inf': - self.servers = [Server(self, i+1) for i in range(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]) + self.simulation.digraph.add_nodes_from([str(s) + for s in self.servers]) self.highest_id = 0 def __repr__(self): """ - Representation of a node:: + Representation of a node. """ return 'Node %s' % self.id_number + def accept(self, next_individual, current_time): + """ + Accepts a new customer to the queue. + """ + next_individual.exit_date = False + next_individual.is_blocked = False + self.begin_service_if_possible_accept( + next_individual, current_time) + next_individual.queue_size_at_arrival = len(self.individuals) + self.individuals.append(next_individual) + self.change_state_accept() + + def add_new_server(self, shift_indx, highest_id): + """ + Add appropriate amount of servers for the given shift. + """ + num_servers = self.schedule[shift_indx][1] + for i in xrange(num_servers): + self.servers.append(Server(self, highest_id+i+1)) + def attach_server(self, server, individual): """ - Attaches a server to an individual, and vice versa + Attaches a server to an individual, and vice versa. """ server.cust = individual server.busy = True @@ -59,45 +89,89 @@ def attach_server(self, server, individual): if self.simulation.detecting_deadlock: for blq in self.blocked_queue: - inds = [ind for ind in self.simulation.nodes[blq[0]].individuals if ind.id_number==blq[1]] + inds = [ind for ind in self.simulation.nodes[ + blq[0]].individuals if ind.id_number==blq[1]] ind = inds[0] if ind != individual: self.simulation.digraph.add_edge(str(ind.server), str(server)) - def detatch_server(self, server, individual): + def begin_service_if_possible_accept(self, next_individual, current_time): """ - Detatches a server from an individual, and vice versa + Begins the service of the next individual, giving + that customer a service time, end date and node. """ - server.cust = False - server.busy = False - individual.server = False + next_individual.arrival_date = current_time + next_individual.service_time = self.simulation.service_times[ + self.id_number][next_individual.customer_class]() + if len(self.individuals) < self.c: + 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 - if self.simulation.detecting_deadlock: - self.simulation.digraph.remove_edges_from(self.simulation.digraph.in_edges(str(server)) + self.simulation.digraph.out_edges(str(server))) + def begin_service_if_possible_change_shift(self, current_time): + """ + Attempts to begin service if change_shift + yields any free servers. + """ + free_servers = [s for s in self.servers if not s.busy] + for srvr in free_servers: + 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 - if server.offduty: - self.kill_server(server) + def begin_service_if_possible_release(self, current_time): + """ + Begins the service of the next individual, giving + that customer a service time, end date and node. + """ + if len(self.individuals) >= self.c: + for ind in self.individuals[:self.c]: + if not ind.service_start_date: + self.attach_server(self.find_free_server(), ind) + ind.service_start_date = current_time + ind.service_end_date = ind.service_start_date + ind.service_time - def have_event(self): + def block_individual(self, individual, next_node): """ - Has an event + Blocks the individual from entering the next node. """ - if self.check_if_shiftchange(): - self.change_shift() - else: - self.finish_service() + individual.is_blocked = True + self.change_state_block() + next_node.blocked_queue.append( + (self.id_number, individual.id_number)) + if self.simulation.detecting_deadlock: + for svr in next_node.servers: + self.simulation.digraph.add_edge( + str(individual.server), str(svr)) + + def change_customer_class(self,individual): + """ + Takes individual and changes customer class according to a probability distribution. + """ + if self.simulation.class_change_matrix != 'NA': + individual.previous_class=individual.customer_class + individual.customer_class=nprandom.choice( + xrange(len(self.class_change_for_node)), + p=self.class_change_for_node[individual.previous_class]) def change_shift(self): """ - Add servers and deletes or indicates which servers should go off duty + Add servers and deletes or indicates which servers + should go off duty. """ if len(self.servers) != 0: - self.highest_id = max([srvr.id_number for srvr in self.servers]) + self.highest_id = max([srvr.id_number + for srvr in self.servers]) shift = self.next_event_date%self.cyclelength - tms = [obs[0] for obs in self.schedule] - diffs = [abs(x-shift) for x in tms] - indx = diffs.index(min(diffs)) + try: inx = self.schedule.index(shift) + except: + tms = [obs[0] for obs in self.schedule] + diffs = [abs(x-shift) for x in tms] + indx = diffs.index(min(diffs)) self.take_servers_off_duty() self.add_new_server(indx, self.highest_id) @@ -106,68 +180,103 @@ def change_shift(self): self.masterschedule.pop(0) self.begin_service_if_possible_change_shift(self.next_event_date) - def take_servers_off_duty(self): + def change_state_accept(self): """ - Gathers servers that should be deleted + Changes the state of the system when a customer gets blocked. """ - to_delete = [] - for srvr in self.servers: - if srvr.busy: - srvr.offduty = True - else: - to_delete.append(srvr) - for obs in to_delete: - self.kill_server(obs) + self.simulation.state[self.id_number-1][0] += 1 + + def change_state_block(self): + """ + Changes the state of the system when a customer gets blocked. + """ + self.simulation.state[self.id_number-1][1] += 1 + self.simulation.state[self.id_number-1][0] -= 1 + + def change_state_release(self, next_individual): + """ + Changes the state of the system when a customer gets blocked. + """ + if next_individual.is_blocked: + self.simulation.state[self.id_number-1][1] -= 1 + else: + self.simulation.state[self.id_number-1][0] -= 1 def check_if_shiftchange(self): """ - Check whether current time is a shift change + Check whether current time is a shift change. """ if self.scheduled_servers: return self.next_event_date == self.masterschedule[0] return False + def detatch_server(self, server, individual): + """ + Detatches a server from an individual, and vice versa + """ + server.cust = False + server.busy = False + individual.server = False + + if self.simulation.detecting_deadlock: + self.simulation.digraph.remove_edges_from( + self.simulation.digraph.in_edges( + str(server)) + self.simulation.digraph.out_edges( + str(server))) + + if server.offduty: + self.kill_server(server) + + def find_free_server(self): + """ + Finds a free server. + """ + free_servers = [svr for svr in self.servers if not svr.busy] + return free_servers[0] + def finish_service(self): """ The next individual finishes service """ - next_individual_indices = [i for i, x in enumerate([ind.service_end_date for ind in self.individuals]) if x == self.next_event_date] - + next_individual_indices = [i for i, x in + enumerate([ind.service_end_date for ind in self.individuals]) + if x == self.next_event_date] if len(next_individual_indices) > 1: next_individual_index = choice(next_individual_indices) else: next_individual_index = next_individual_indices[0] - next_individual = self.individuals[next_individual_index] - self.change_customer_class(next_individual) - next_node = self.next_node(next_individual.customer_class) next_individual.destination = next_node.id_number - if len(next_node.individuals) < next_node.node_capacity: self.release(next_individual_index, next_node, self.next_event_date) else: self.block_individual(next_individual, next_node) - def change_customer_class(self,individual): + def have_event(self): """ - Takes individual and changes customer class according to a probability distribution. + Has an event """ - if self.simulation.class_change_matrix != 'NA': - individual.previous_class=individual.customer_class - individual.customer_class=nprandom.choice(range(len(self.class_change_for_node)), p=self.class_change_for_node[individual.previous_class]) + if self.check_if_shiftchange(): + self.change_shift() + else: + self.finish_service() - def block_individual(self, individual, next_node): + def kill_server(self,srvr): """ - Blocks the individual from entering the next node + Kills server. """ - individual.is_blocked = True - self.change_state_block() - next_node.blocked_queue.append((self.id_number, individual.id_number)) - if self.simulation.detecting_deadlock: - for svr in next_node.servers: - self.simulation.digraph.add_edge(str(individual.server), str(svr)) + indx = self.servers.index(srvr) + del self.servers[indx] + + 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( + self.transition_row[customer_class])]) def release(self, next_individual_index, next_node, current_time): """ @@ -184,124 +293,49 @@ def release(self, next_individual_index, next_node, current_time): self.begin_service_if_possible_release(current_time) next_node.accept(next_individual, current_time) - def begin_service_if_possible_change_shift(self, current_time): - """ - Attempts to begin service if change_shift yields any free servers - """ - free_servers = [s for s in self.servers if not s.busy] - for srvr in free_servers: - 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 - - def begin_service_if_possible_release(self, current_time): - """ - Begins the service of the next individual, giving that customer a service time, end date and node - """ - if len(self.individuals) >= self.c: - for ind in self.individuals[:self.c]: - if not ind.service_start_date: - self.attach_server(self.find_free_server(), ind) - ind.service_start_date = current_time - ind.service_end_date = ind.service_start_date + ind.service_time - def release_blocked_individual(self, current_time): """ - Releases an individual who becomes unblocked when another individual is released + Releases an individual who becomes unblocked + when another individual is released. """ if len(self.blocked_queue) > 0: node_to_receive_from = self.simulation.nodes[self.blocked_queue[0][0]] - individual_to_receive_index = [ind.id_number for ind in node_to_receive_from.individuals].index(self.blocked_queue[0][1]) - individual_to_receive = node_to_receive_from.individuals[individual_to_receive_index] + individual_to_receive_index = [ind.id_number + for ind in node_to_receive_from.individuals].index( + self.blocked_queue[0][1]) + individual_to_receive = node_to_receive_from.individuals[ + individual_to_receive_index] self.blocked_queue.pop(0) - node_to_receive_from.release(individual_to_receive_index, self, current_time) - - def change_state_release(self, next_individual): - """ - Changes the state of the system when a customer gets blocked - """ - if next_individual.is_blocked: - self.simulation.state[self.id_number-1][1] -= 1 - else: - self.simulation.state[self.id_number-1][0] -= 1 + node_to_receive_from.release(individual_to_receive_index, + self, current_time) - def change_state_block(self): - """ - Changes the state of the system when a customer gets blocked - """ - self.simulation.state[self.id_number-1][1] += 1 - self.simulation.state[self.id_number-1][0] -= 1 - - def change_state_accept(self): - """ - Changes the state of the system when a customer gets blocked - """ - self.simulation.state[self.id_number-1][0] += 1 - - def accept(self, next_individual, current_time): - """ - Accepts a new customer to the queue - """ - next_individual.exit_date = False - next_individual.is_blocked = False - self.begin_service_if_possible_accept(next_individual, current_time) - next_individual.queue_size_at_arrival = len(self.individuals) - self.individuals.append(next_individual) - self.change_state_accept() - - def begin_service_if_possible_accept(self, next_individual, current_time): - """ - 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]() - if len(self.individuals) < self.c: - 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 - - def find_free_server(self): - """ - Finds a free server - """ - free_servers = [svr for svr in self.servers if not svr.busy] - return free_servers[0] - - def kill_server(self,srvr): - """ - Kills server - """ - indx = self.servers.index(srvr) - del self.servers[indx] - - def add_new_server(self, shift_indx, highest_id): + def take_servers_off_duty(self): """ - Add appropriate amount of servers for the given shift + Gathers servers that should be deleted. """ - num_servers = self.schedule[shift_indx][1] - for i in range(num_servers): - self.servers.append(Server(self, highest_id+i+1)) + to_delete = [] + for srvr in self.servers: + if srvr.busy: + srvr.offduty = True + else: + to_delete.append(srvr) + for obs in to_delete: + self.kill_server(obs) def update_next_event_date(self, current_time): """ Finds the time of the next event at this node """ - 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"]) + 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 self.scheduled_servers: next_shift_change = self.masterschedule[0] self.next_event_date = min(next_end_service, next_shift_change) else: self.next_event_date = next_end_service - 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(self.transition_row[customer_class])]) - def write_individual_record(self, individual): """ Write a data record for an individual: @@ -318,7 +352,15 @@ def write_individual_record(self, individual): - Queue size at arrival - Queue size at departure """ - record = DataRecord(individual.arrival_date, individual.service_time, individual.service_start_date, individual.exit_date, self.id_number, individual.destination, individual.previous_class, individual.queue_size_at_arrival, individual.queue_size_at_departure) + record = DataRecord(individual.arrival_date, + individual.service_time, + individual.service_start_date, + individual.exit_date, + self.id_number, + individual.destination, + individual.previous_class, + individual.queue_size_at_arrival, + individual.queue_size_at_departure) if self.id_number in individual.data_records: individual.data_records[self.id_number].append(record) else: diff --git a/ciw/simulation.py b/ciw/simulation.py index 7a50275a..057b3077 100644 --- a/ciw/simulation.py +++ b/ciw/simulation.py @@ -1,18 +1,20 @@ from __future__ import division -from random import random, expovariate, uniform, triangular, gammavariate, gauss, lognormvariate, weibullvariate, choice import os +from random import (random, expovariate, uniform, triangular, + gammavariate, gauss, lognormvariate, weibullvariate, choice) from csv import writer, reader +import copy + import yaml import networkx as nx -import copy +import numpy.random as nprandom + from node import Node from arrival_node import ArrivalNode from exit_node import ExitNode from server import Server from individual import Individual from data_record import DataRecord -import numpy.random as nprandom - class Simulation: """ @@ -22,43 +24,50 @@ def __init__(self, *args, **kwargs): """ Initialise a queue instance. """ - if args: # Catching if dictionary is passed + if args: parameters = copy.deepcopy(args[0]) else: parameters = kwargs - self.parameters = self.build_parameters(parameters) self.check_valid_parameters() - self.c = self.parameters['Number_of_servers'] self.number_of_nodes = self.parameters['Number_of_nodes'] - self.detecting_deadlock = self.parameters['detect_deadlock'] + self.detecting_deadlock = self.parameters['Detect_deadlock'] self.digraph = nx.DiGraph() - self.lmbda = [self.parameters['Arrival_distributions']['Class ' + str(i)] for i in range(self.parameters['Number_of_classes'])] - self.mu = [self.parameters['Service_distributions']['Class ' + str(i)] for i in range(self.parameters['Number_of_classes'])] - - self.schedules = [False for i in range(len(self.c))] - for i in range(len(self.c)): - if type(self.c[i])==type('string') and self.c[i]!='Inf': + self.lmbda = [self.parameters['Arrival_distributions'][ + 'Class ' + str(i)] for i in xrange(self.parameters[ + 'Number_of_classes'])] + self.mu = [self.parameters['Service_distributions']['Class ' + str(i)] + for i in xrange(self.parameters['Number_of_classes'])] + self.schedules = [False for i in xrange(len(self.c))] + for i in xrange(len(self.c)): + if isinstance(self.c[i], str) and self.c[i] != 'Inf': self.schedules[i] = True self.queue_capacities = self.parameters['Queue_capacities'] - self.transition_matrix = [self.parameters['Transition_matrices']['Class ' + str(i)] for i in range(self.parameters['Number_of_classes'])] - + self.transition_matrix = [self.parameters[ + 'Transition_matrices']['Class ' + str(i)] + for i in xrange(self.parameters['Number_of_classes'])] if 'Class_change_matrices' in self.parameters: - self.class_change_matrix = [self.parameters['Class_change_matrices']['Node ' + str(i)] for i in range(self.parameters['Number_of_nodes'])] + self.class_change_matrix = [self.parameters[ + 'Class_change_matrices']['Node ' + str(i)] + for i in xrange(self.parameters['Number_of_nodes'])] else: self.class_change_matrix = 'NA' - self.max_simulation_time = self.parameters['Simulation_time'] - self.inter_arrival_times = self.find_times_dictionary(self.lmbda) - self.transitive_nodes = [Node(i + 1, self) for i in range(len(self.c))] + self.transitive_nodes = [Node(i + 1, self) for i in xrange(len(self.c))] self.nodes = [ArrivalNode(self)] + self.transitive_nodes + [ExitNode("Inf")] self.service_times = self.find_times_dictionary(self.mu) self.inter_arrival_times = self.find_times_dictionary(self.lmbda) - self.state = [[0, 0] for i in range(self.number_of_nodes)] - initial_state = [[0, 0] for i in range(self.number_of_nodes)] - self.times_dictionary = {tuple(tuple(initial_state[i]) for i in range(self.number_of_nodes)): 0.0} + self.state = [[0, 0] for i in xrange(self.number_of_nodes)] + self.times_dictionary = {tuple(tuple(self.state[i]) + for i in xrange(self.number_of_nodes)): 0.0} + + def __repr__(self): + """ + Represents the simulation + """ + return "Ciw Simulation" def build_parameters(self, params): """ @@ -74,16 +83,26 @@ def build_parameters(self, params): trns_mat = params['Transition_matrices'] params['Transition_matrices'] = {'Class 0': trns_mat} - default_dict ={'Number_of_nodes': len(params['Number_of_servers']), - 'Number_of_classes': len(params['Arrival_distributions']), - 'Queue_capacities': ['Inf' for _ in range(len(params['Number_of_servers']))], - 'detect_deadlock': False} + default_dict = { + 'Number_of_nodes': len(params['Number_of_servers']), + 'Number_of_classes': len(params['Arrival_distributions']), + 'Queue_capacities': ['Inf' for _ in xrange(len(params['Number_of_servers']))], + 'Detect_deadlock': False + } for a in default_dict: params[a] = params.get(a, default_dict[a]) - return params + def check_userdef_dist(self, func): + """ + Safely sample from a user defined distribution + """ + sample = func() + if not isinstance(sample, float) or sample < 0: + raise ValueError("UserDefined function must return positive float.") + return sample + def check_valid_parameters(self): """ Raises errors if parameter set isn't valid @@ -102,7 +121,7 @@ def check_valid_parameters(self): if x != 'Inf': if x not in self.parameters: raise ValueError('Number_of_servers must be list of positive integers or valid server schedules.') - if not isinstance(self.parameters['detect_deadlock'], bool): + if not isinstance(self.parameters['Detect_deadlock'], bool): raise ValueError('detect_deadlock must be a boolean.') if len(self.parameters['Queue_capacities']) != self.parameters['Number_of_nodes']: raise ValueError('Queue_capacities must be list of length Number_of_nodes.') @@ -221,16 +240,30 @@ def check_valid_parameters(self): if any([el<0.0 for el in nd[1]]): raise ValueError('Empirical distribution must sample positive floats.') - - def find_next_active_node(self): + def detect_deadlock(self): """ - Return the next active node: + Detects whether the system is in a deadlocked state, + that is, is there a knot. Note that this code is taken + and adapted from the NetworkX Developer Zone Ticket + #663 knot.py (09/06/2015) """ - next_active_node_indices = [i for i, x in enumerate([nd.next_event_date for nd in self.nodes]) if x == min([nd.next_event_date for nd in self.nodes])] - if len(next_active_node_indices) > 1: - return self.nodes[choice(next_active_node_indices)] - else: - return self.nodes[next_active_node_indices[0]] + knots = [] + for subgraph in nx.strongly_connected_component_subgraphs(self.digraph): + nodes = set(subgraph.nodes()) + if len(nodes) == 1: + n = nodes.pop() + nodes.add(n) + if set(self.digraph.successors(n)) == nodes: + knots.append(subgraph) + else: + for n in nodes: + successors = nx.descendants(self.digraph, n) + if successors <= nodes: + knots.append(subgraph) + break + if len(knots) > 0: + return True + return False def find_distributions(self, n, c, source): """ @@ -239,45 +272,105 @@ def find_distributions(self, n, c, source): if source[c][n] == 'NoArrivals': return lambda : 'Inf' if source[c][n][0] == 'Uniform': - return lambda : uniform(source[c][n][1], source[c][n][2]) + return lambda : uniform(source[c][n][1], + source[c][n][2]) if source[c][n][0] == 'Deterministic': return lambda : source[c][n][1] if source[c][n][0] == 'Triangular': - return lambda : triangular(source[c][n][1], source[c][n][2], source[c][n][3]) + return lambda : triangular(source[c][n][1], + source[c][n][2], + source[c][n][3]) if source[c][n][0] == 'Exponential': return lambda : expovariate(source[c][n][1]) if source[c][n][0] == 'Gamma': - return lambda : gammavariate(source[c][n][1], source[c][n][2]) + return lambda : gammavariate(source[c][n][1], + source[c][n][2]) if source[c][n][0] == 'Lognormal': - return lambda : lognormvariate(source[c][n][1], source[c][n][2]) + return lambda : lognormvariate(source[c][n][1], + source[c][n][2]) if source[c][n][0] == 'Weibull': - return lambda : weibullvariate(source[c][n][1], source[c][n][2]) + return lambda : weibullvariate(source[c][n][1], + source[c][n][2]) if source[c][n][0] == 'Custom': P, V = zip(*self.parameters[source[c][n][1]]) probs, values = list(P), list(V) return lambda : nprandom.choice(values, p=probs) if source[c][n][0] == 'UserDefined': - return lambda : self.sample_from_user_defined_dist(source[c][n][1]) + return lambda : self.check_userdef_dist(source[c][n][1]) if source[c][n][0] == 'Empirical': if isinstance(source[c][n][1], str): - empirical_dist = self.import_empirical_dist(source[c][n][1]) + empirical_dist = self.import_empirical(source[c][n][1]) return lambda : choice(empirical_dist) return lambda : choice(source[c][n][1]) - def sample_from_user_defined_dist(self, func): + def find_next_active_node(self): """ - Safely sample from a user defined distribution + Return the next active node: """ - sample = func() + next_active_node_indices = [i for i, x in enumerate([ + nd.next_event_date for nd in self.nodes]) if x == min([ + nd.next_event_date for nd in self.nodes])] + if len(next_active_node_indices) > 1: + return self.nodes[choice(next_active_node_indices)] + return self.nodes[next_active_node_indices[0]] - if not (isinstance(sample, float) or isinstance(sample, int)): - raise TypeError("User defined function returns invalid type: {}".format(type(sample))) + def find_times_dictionary(self, source): + """ + Finds the dictionary of service time + functions for each node for each class + """ + return {node+1:{ + customer_class:self.find_distributions(node, customer_class, source) + for customer_class in xrange(len(self.lmbda))} + for node in xrange(self.number_of_nodes)} - elif sample < 0: - raise ValueError("User defined function returns invalid value: {}".format(sample)) - return sample + def get_all_individuals(self): + """ + Returns list of all individuals with at least one record + """ + return [individual for node in self.nodes[1:] + for individual in node.individuals + if len(individual.data_records) > 0] - def import_empirical_dist(self, dist_file): + def get_all_records(self, headers=True): + """ + Gets all records from all individuals + """ + records = [] + if headers: + records.append(['I.D. Number', + 'Customer Class', + 'Node', + 'Arrival Date', + 'Waiting Time', + 'Service Start Date', + 'Service Time', + 'Service End Date', + 'Time Blocked', + 'Exit Date', + 'Destination', + 'Queue Size at Arrival', + 'Queue Size at Departure']) + for individual in self.get_all_individuals(): + for node in individual.data_records: + for record in individual.data_records[node]: + records.append([individual.id_number, + record.customer_class, + node, + record.arrival_date, + record.wait, + record.service_start_date, + record.service_time, + record.service_end_date, + record.blocked, + record.exit_date, + record.destination, + record.queue_size_at_arrival, + record.queue_size_at_departure]) + self.all_records = records + return records + + def import_empirical(self, dist_file): """ Imports an empirical distribution from a .csv file """ @@ -289,108 +382,44 @@ def import_empirical_dist(self, dist_file): empirical_file.close() return empirical_dist - def find_times_dictionary(self, source): - """ - Finds the dictionary of service time functions for each node for each class - """ - return {node+1:{customer_class:self.find_distributions(node, customer_class, source) for customer_class in range(len(self.lmbda))} for node in range(self.number_of_nodes)} - - def simulate_until_max_time(self): + def simulate_until_deadlock(self): """ Run the actual simulation. """ + deadlocked = False self.nodes[0].update_next_event_date() next_active_node = self.find_next_active_node() current_time = next_active_node.next_event_date - while current_time < self.max_simulation_time: + while not deadlocked: next_active_node.have_event() + current_state = tuple(tuple(self.state[i]) + for i in xrange(len(self.state))) + if current_state not in self.times_dictionary: + self.times_dictionary[current_state] = current_time for node in self.transitive_nodes: node.update_next_event_date(current_time) + deadlocked = self.detect_deadlock() + if deadlocked: + time_of_deadlock = current_time next_active_node = self.find_next_active_node() current_time = next_active_node.next_event_date + return {state: time_of_deadlock - self.times_dictionary[state] + for state in self.times_dictionary.keys()} - def simulate_until_deadlock(self): + def simulate_until_max_time(self): """ Run the actual simulation. """ - deadlocked = False self.nodes[0].update_next_event_date() next_active_node = self.find_next_active_node() current_time = next_active_node.next_event_date - while not deadlocked: + while current_time < self.max_simulation_time: next_active_node.have_event() - - current_state = tuple(tuple(self.state[i]) for i in range(len(self.state))) - if current_state not in self.times_dictionary: - self.times_dictionary[current_state] = current_time - for node in self.transitive_nodes: node.update_next_event_date(current_time) - deadlocked = self.detect_deadlock() - - if deadlocked: - time_of_deadlock = current_time - next_active_node = self.find_next_active_node() current_time = next_active_node.next_event_date - return {state: time_of_deadlock - self.times_dictionary[state] for state in self.times_dictionary.keys()} - - def detect_deadlock(self): - """ - Detects whether the system is in a deadlocked state, that is, is there a knot - Note that this code is taken and adapted from the NetworkX Developer Zone Ticket #663 knot.py (09/06/2015) - """ - knots = [] - for subgraph in nx.strongly_connected_component_subgraphs(self.digraph): - nodes = set(subgraph.nodes()) - if len(nodes) == 1: - n = nodes.pop() - nodes.add(n) - if set(self.digraph.successors(n)) == nodes: - knots.append(subgraph) - else: - for n in nodes: - successors = nx.descendants(self.digraph, n) - if successors <= nodes: - knots.append(subgraph) - break - if len(knots) > 0: - return True - return False - - def get_all_individuals(self): - """ - Returns list of all individuals with at least one record - """ - return [individual for node in self.nodes[1:] for individual in node.individuals if len(individual.data_records) > 0] - - def get_all_records(self, headers=True): - """ - Gets all records from all individuals - """ - records = [] - if headers: - records.append(['I.D. Number', 'Customer Class', 'Node', 'Arrival Date', 'Waiting Time', 'Service Start Date', 'Service Time', 'Service End Date', 'Time Blocked', 'Exit Date', 'Destination', 'Queue Size at Arrival', 'Queue Size at Departure']) - for individual in self.get_all_individuals(): - for node in individual.data_records: - for record in individual.data_records[node]: - records.append([individual.id_number, - record.customer_class, - node, - record.arrival_date, - record.wait, - record.service_start_date, - record.service_time, - record.service_end_date, - record.blocked, - record.exit_date, - record.destination, - record.queue_size_at_arrival, - record.queue_size_at_departure]) - self.all_records = records - return records - def write_records_to_file(self, file_name, headers=True): """ Writes the records for all individuals to a csv file @@ -399,10 +428,7 @@ def write_records_to_file(self, file_name, headers=True): directory = os.path.join(root, file_name) data_file = open('%s' % directory, 'w') csv_wrtr = writer(data_file) - if headers: - records = self.get_all_records(headers=True) - else: - records = self.get_all_records(headers=False) + records = self.get_all_records(headers=headers) for row in records: csv_wrtr.writerow(row) data_file.close() diff --git a/ciw/tests/datafortesting/logs_test_for_custom_dist/parameters.yml b/ciw/tests/datafortesting/logs_test_for_custom_dist/parameters.yml index be5cd19c..eb7b44e0 100644 --- a/ciw/tests/datafortesting/logs_test_for_custom_dist/parameters.yml +++ b/ciw/tests/datafortesting/logs_test_for_custom_dist/parameters.yml @@ -9,7 +9,7 @@ Arrival_distributions: - 3.0 - - Exponential - 5.0 -detect_deadlock: False +Detect_deadlock: False Number_of_classes: 2 Number_of_nodes: 2 Number_of_servers: diff --git a/ciw/tests/datafortesting/logs_test_for_deadlock_sim/parameters.yml b/ciw/tests/datafortesting/logs_test_for_deadlock_sim/parameters.yml index 0462a67e..4e070192 100644 --- a/ciw/tests/datafortesting/logs_test_for_deadlock_sim/parameters.yml +++ b/ciw/tests/datafortesting/logs_test_for_deadlock_sim/parameters.yml @@ -4,7 +4,7 @@ Arrival_distributions: - 35.0 - - Exponential - 35.0 -detect_deadlock: True +Detect_deadlock: True Number_of_classes: 1 Number_of_nodes: 2 Number_of_servers: diff --git a/ciw/tests/datafortesting/logs_test_for_dynamic_classes/parameters.yml b/ciw/tests/datafortesting/logs_test_for_dynamic_classes/parameters.yml index 00640cbf..c74f2120 100644 --- a/ciw/tests/datafortesting/logs_test_for_dynamic_classes/parameters.yml +++ b/ciw/tests/datafortesting/logs_test_for_dynamic_classes/parameters.yml @@ -9,7 +9,7 @@ Arrival_distributions: - 0.04 - - Exponential - 0.06 -detect_deadlock: False +Detect_deadlock: False Number_of_classes: 2 Number_of_nodes: 2 Number_of_servers: diff --git a/ciw/tests/datafortesting/logs_test_for_server_schedule/parameters.yml b/ciw/tests/datafortesting/logs_test_for_server_schedule/parameters.yml index fca809ce..543ac64d 100644 --- a/ciw/tests/datafortesting/logs_test_for_server_schedule/parameters.yml +++ b/ciw/tests/datafortesting/logs_test_for_server_schedule/parameters.yml @@ -9,7 +9,7 @@ Arrival_distributions: - 0.04 - - Exponential - 0.06 -detect_deadlock: False +Detect_deadlock: False Number_of_classes: 2 Number_of_nodes: 2 cycle_length: 100 diff --git a/ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml b/ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml index 190372db..22398b20 100644 --- a/ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml +++ b/ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml @@ -26,7 +26,7 @@ Arrival_distributions: - 2.0 - - Exponential - 0.5 -detect_deadlock: False +Detect_deadlock: False Number_of_classes: 3 Number_of_nodes: 4 Number_of_servers: diff --git a/ciw/tests/test_arrival_node.py b/ciw/tests/test_arrival_node.py index 972d8889..1cc4ae7f 100644 --- a/ciw/tests/test_arrival_node.py +++ b/ciw/tests/test_arrival_node.py @@ -13,31 +13,50 @@ class TestArrivalNode(unittest.TestCase): def test_init_method(self): set_seed(5) - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) N = ciw.ArrivalNode(Q) self.assertEqual(round(N.next_event_date, 5), 0.00440) self.assertEqual(N.number_of_individuals, 0) - dates_dict = {1: {0: 0.2110410999, 1: 0.1415614623, 2: 0.3923690877}, 2: {0: 0.1218825551, 1: 0.0044003133, 2: 0.2442775601}, 3: {0: 0.0819463473, 1: 0.4135097542, 2: 0.7256307839}, 4: {0: 0.1738823223, 1: 0.3988184145, 2: 0.2987813628}} - self.assertEqual({nd:{obs:round(N.next_event_dates_dict[nd][obs], 10) for obs in N.next_event_dates_dict[nd]} for nd in N.next_event_dates_dict}, dates_dict) + dates_dict = {1: {0: 0.2110410999, 1: 0.1415614623, 2: 0.3923690877}, + 2: {0: 0.1218825551, 1: 0.0044003133, 2: 0.2442775601}, + 3: {0: 0.0819463473, 1: 0.4135097542, 2: 0.7256307839}, + 4: {0: 0.1738823223, 1: 0.3988184145, 2: 0.2987813628}} + self.assertEqual({nd:{obs:round(N.event_dates_dict[nd][obs], 10) + for obs in N.event_dates_dict[nd]} for nd in N.event_dates_dict}, + dates_dict) - def test_initialise_next_event_dates_dict_method(self): + def test_initialise_event_dates_dict_method(self): set_seed(6) - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) N = ciw.ArrivalNode(Q) - dates_dict_1 = {1: {0: 0.4362282541, 1: 0.2672232406, 2: 0.3864256273}, 2: {0: 0.1636952311, 1: 0.0714709565, 2: 0.8065738414}, 3: {0: 0.4088480190, 1: 0.0514323248, 2: 0.8132038176}, 4: {0: 1.1573751438, 1: 0.4649276714, 2: 0.8176876727}} - dates_dict_2 = {1: {0: 0.0325870775, 1: 0.8054262558, 2: 0.8168179515}, 2: {0: 0.0841671381, 1: 0.0328245299, 2: 0.2196023847}, 3: {0: 0.2519089068, 1: 0.0573597814, 2: 1.5117882121}, 4: {0: 0.8881158889, 1: 0.0560592622, 2: 2.1307650868}} - self.assertEqual({nd:{obs:round(N.next_event_dates_dict[nd][obs], 10) for obs in N.next_event_dates_dict[nd]} for nd in N.next_event_dates_dict}, dates_dict_1) - N.initialise_next_event_dates_dict() - self.assertEqual({nd:{obs:round(N.next_event_dates_dict[nd][obs], 10) for obs in N.next_event_dates_dict[nd]} for nd in N.next_event_dates_dict}, dates_dict_2) + dates_dict_1 = {1: {0: 0.4362282541, 1: 0.2672232406, 2: 0.3864256273}, + 2: {0: 0.1636952311, 1: 0.0714709565, 2: 0.8065738414}, + 3: {0: 0.4088480190, 1: 0.0514323248, 2: 0.8132038176}, + 4: {0: 1.1573751438, 1: 0.4649276714, 2: 0.8176876727}} + dates_dict_2 = {1: {0: 0.0325870775, 1: 0.8054262558, 2: 0.8168179515}, + 2: {0: 0.0841671381, 1: 0.0328245299, 2: 0.2196023847}, + 3: {0: 0.2519089068, 1: 0.0573597814, 2: 1.5117882121}, + 4: {0: 0.8881158889, 1: 0.0560592622, 2: 2.1307650868}} + self.assertEqual({nd:{obs:round(N.event_dates_dict[nd][obs], 10) + for obs in N.event_dates_dict[nd]} for nd in N.event_dates_dict}, + dates_dict_1) + N.initialise_event_dates_dict() + self.assertEqual({nd:{obs:round(N.event_dates_dict[nd][obs], 10) + for obs in N.event_dates_dict[nd]} for nd in N.event_dates_dict}, + dates_dict_2) def test_repr_method(self): - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) N = ciw.ArrivalNode(Q) self.assertEqual(str(N), 'Arrival Node') def test_find_next_event_date_method(self): set_seed(1) - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) N = ciw.ArrivalNode(Q) self.assertEqual(round(N.next_event_date, 5), 0.00105) N.find_next_event_date() @@ -52,7 +71,8 @@ def test_find_next_event_date_method(self): def test_have_event_method(self): set_seed(1) - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) N = ciw.ArrivalNode(Q) self.assertEqual([str(obj) for obj in Q.transitive_nodes[0].individuals], []) self.assertEqual([str(obj) for obj in Q.transitive_nodes[1].individuals], []) @@ -70,7 +90,8 @@ def test_have_event_method(self): self.assertEqual(N.next_node, 3) set_seed(12) - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) N = ciw.ArrivalNode(Q) self.assertEqual([str(obj) for obj in Q.transitive_nodes[0].individuals], []) self.assertEqual([str(obj) for obj in Q.transitive_nodes[1].individuals], []) @@ -88,10 +109,14 @@ def test_have_event_method(self): self.assertEqual(N.next_node, 2) def test_no_arrivals_example(self): - params = ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml') - params['Arrival_distributions']['Class 0'] = ['NoArrivals', ['Exponential', 1.0], ['Exponential', 4.0], ['Exponential', 3.5]] + params = ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml') + params['Arrival_distributions']['Class 0'] = ['NoArrivals', + ['Exponential', 1.0], + ['Exponential', 4.0], + ['Exponential', 3.5]] Q = ciw.Simulation(params) AN = Q.nodes[0] self.assertEqual(AN.simulation.lmbda[0][0], 'NoArrivals') - self.assertEqual(AN.sample_next_event_time(1, 0), 'Inf') + self.assertEqual(AN.inter_arrival(1, 0), 'Inf') diff --git a/ciw/tests/test_data_record.py b/ciw/tests/test_data_record.py index 56952306..f7d92148 100644 --- a/ciw/tests/test_data_record.py +++ b/ciw/tests/test_data_record.py @@ -19,6 +19,7 @@ def test_init_method(self): self.assertEqual(r.customer_class, 2) self.assertEqual(r.queue_size_at_arrival, 0) self.assertEqual(r.queue_size_at_departure, 3) + self.assertEqual(str(r), 'Data Record') r = ciw.DataRecord(5.7, 2.1, 8.2, 10.3, 1, -1, 3, 32, 21) self.assertEqual(r.arrival_date, 5.7) @@ -33,10 +34,7 @@ def test_init_method(self): self.assertEqual(r.customer_class, 3) self.assertEqual(r.queue_size_at_arrival, 32) self.assertEqual(r.queue_size_at_departure, 21) - - def test_init_error(self): - self.assertRaises(ValueError, ciw.DataRecord, 2, 3, 2, 1, 1, -1, 2, 0, 0) - self.assertRaises(ValueError, ciw.DataRecord, 2, -3, 2, 8, 1, 2, 2, 2, 0) + self.assertEqual(str(r), 'Data Record') @given(arrival_date=floats(min_value=0.0, max_value=99999.99), service_time=floats(min_value=0.0, max_value=99999.99), @@ -47,7 +45,16 @@ def test_init_error(self): customer_class=integers(), queue_size_at_arrival=integers(), queue_size_at_departure=integers()) - def test_init_methodh(self, arrival_date, service_time, inter_service_start_date, inter_exit_date, node, destination, customer_class, queue_size_at_arrival, queue_size_at_departure): + def test_init_methodh(self, + arrival_date, + service_time, + inter_service_start_date, + inter_exit_date, + node, + destination, + customer_class, + queue_size_at_arrival, + queue_size_at_departure): # Define parameters service_start_date = arrival_date+inter_service_start_date exit_date = service_start_date+inter_exit_date+service_time @@ -66,20 +73,4 @@ def test_init_methodh(self, arrival_date, service_time, inter_service_start_date self.assertEqual(r.customer_class, customer_class) self.assertEqual(r.queue_size_at_arrival, queue_size_at_arrival) self.assertEqual(r.queue_size_at_departure, queue_size_at_departure) - - @given(arrival_date=floats(min_value=0.01, max_value=99999.99), - service_time=floats(min_value=0.0, max_value=99999.99), - neg_service_time=floats(min_value=-99999.99, max_value=-0.01), - inter_service_start_date=floats(min_value=0.0, max_value=99999.99), - inter_exit_date=floats(min_value=0.0, max_value=99999.99), - node=integers(), - destination=integers(), - customer_class=integers(), - queue_size_at_arrival=integers(), - queue_size_at_departure=integers()) - def test_init_errorh(self, arrival_date, service_time, neg_service_time, inter_service_start_date, inter_exit_date, node, destination, customer_class, queue_size_at_arrival, queue_size_at_departure): - service_start_date = arrival_date+inter_service_start_date - exit_date = service_start_date+inter_exit_date+service_time - self.assertRaises(ValueError, ciw.DataRecord, arrival_date, service_time, service_start_date, (arrival_date/2), node, destination, customer_class, queue_size_at_arrival, queue_size_at_departure) - self.assertRaises(ValueError, ciw.DataRecord, arrival_date, neg_service_time, service_start_date, exit_date, node, destination, customer_class, queue_size_at_arrival, queue_size_at_departure) - + self.assertEqual(str(r), 'Data Record') diff --git a/ciw/tests/test_individual.py b/ciw/tests/test_individual.py index 07491c85..964466cb 100644 --- a/ciw/tests/test_individual.py +++ b/ciw/tests/test_individual.py @@ -32,14 +32,14 @@ def test_init_method_2(self): self.assertEqual(i.destination, False) self.assertEqual(i.queue_size_at_arrival, False) self.assertEqual(i.queue_size_at_departure, False) - self.assertEqual(i.data_records, {}) def test_repr_method(self): i = ciw.Individual(3, 6) self.assertEqual(str(i), 'Individual 3') - @given(id_num=integers(), customer_class=integers()) + @given(id_num=integers(), + customer_class=integers()) def test_init_method_1h(self, id_num, customer_class): i = ciw.Individual(id_num, customer_class) self.assertEqual(i.customer_class, customer_class) @@ -52,7 +52,6 @@ def test_init_method_1h(self, id_num, customer_class): self.assertEqual(i.destination, False) self.assertEqual(i.queue_size_at_arrival, False) self.assertEqual(i.queue_size_at_departure, False) - self.assertEqual(i.data_records, {}) @given(id_num=integers()) @@ -68,10 +67,10 @@ def test_init_method_2h(self, id_num): self.assertEqual(i.destination, False) self.assertEqual(i.queue_size_at_arrival, False) self.assertEqual(i.queue_size_at_departure, False) - self.assertEqual(i.data_records, {}) - @given(id_num=integers(), customer_class=integers()) + @given(id_num=integers(), + customer_class=integers()) def test_repr_methodh(self, id_num, customer_class): i = ciw.Individual(id_num, customer_class) self.assertEqual(str(i), 'Individual ' + str(id_num)) \ No newline at end of file diff --git a/ciw/tests/test_node.py b/ciw/tests/test_node.py index 5ac0ed64..2c92067a 100644 --- a/ciw/tests/test_node.py +++ b/ciw/tests/test_node.py @@ -3,55 +3,68 @@ from random import seed from numpy import random as nprandom + def set_seed(x): seed(x) nprandom.seed(x) - class TestNode(unittest.TestCase): def test_init_method(self): - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) N = ciw.Node(1, Q) - self.assertEqual(N.mu, [['Exponential', 7.0], ['Exponential', 7.0], ['Deterministic', 0.3]]) + self.assertEqual(N.mu, [['Exponential', 7.0], + ['Exponential', 7.0], + ['Deterministic', 0.3]]) self.assertEqual(N.c, 9) - self.assertEqual(N.transition_row, [[0.1, 0.2, 0.1, 0.4], [0.6, 0.0, 0.0, 0.2], [0.0, 0.0, 0.4, 0.3]]) + self.assertEqual(N.transition_row, [[0.1, 0.2, 0.1, 0.4], + [0.6, 0.0, 0.0, 0.2], + [0.0, 0.0, 0.4, 0.3]]) self.assertEqual(N.next_event_date, 'Inf') self.assertEqual(N.individuals, []) self.assertEqual(N.id_number, 1) - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_dynamic_classes/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_dynamic_classes/parameters.yml')) N1 = Q.transitive_nodes[0] - self.assertEqual(N1.class_change_for_node, [[0.5, 0.5], [0.5, 0.5]]) + self.assertEqual(N1.class_change_for_node, [[0.5, 0.5], + [0.5, 0.5]]) N2 = Q.transitive_nodes[1] - self.assertEqual(N2.class_change_for_node, [[1.0, 0.0], [0.0, 1.0]]) - - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_server_schedule/parameters.yml')) + self.assertEqual(N2.class_change_for_node, [[1.0, 0.0], + [0.0, 1.0]]) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_server_schedule/parameters.yml')) N = Q.transitive_nodes[0] self.assertEqual(N.scheduled_servers, True) self.assertEqual(N.cyclelength, 100) self.assertEqual(N.c, 1) - self.assertEqual(N.masterschedule, [30, 60, 90, 100, 130, 160, 190, 200, 230, 260, 290, 300, 330, 360, 390]) + self.assertEqual(N.masterschedule, [30, 60, 90, 100, 130, + 160, 190, 200, 230, 260, 290, 300, 330, 360, 390]) self.assertEqual(N.next_event_date, 30) def test_repr_method(self): - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) N1 = ciw.Node(1, Q) N2 = ciw.Node(2, Q) self.assertEqual(str(N1), 'Node 1') self.assertEqual(str(N2), 'Node 2') def test_change_shift_method(self): - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_server_schedule/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_server_schedule/parameters.yml')) N = Q.transitive_nodes[0] N.next_event_date = 30 - self.assertEqual([str(obs) for obs in N.servers], ['Server 1 at Node 1']) + self.assertEqual([str(obs) for obs in N.servers], + ['Server 1 at Node 1']) self.assertEqual([obs.busy for obs in N.servers], [False]) self.assertEqual([obs.offduty for obs in N.servers], [False]) self.assertEqual(N.c, 1) N.change_shift() - self.assertEqual([str(obs) for obs in N.servers], ['Server 2 at Node 1', 'Server 3 at Node 1']) + self.assertEqual([str(obs) for obs in N.servers], + ['Server 2 at Node 1', 'Server 3 at Node 1']) self.assertEqual([obs.busy for obs in N.servers], [False, False]) self.assertEqual([obs.offduty for obs in N.servers], [False, False]) self.assertEqual(N.c, 2) @@ -59,34 +72,50 @@ def test_change_shift_method(self): N.servers[0].busy = True N.next_event_date = 90 N.change_shift() - self.assertEqual([str(obs) for obs in N.servers], ['Server 2 at Node 1', 'Server 4 at Node 1', 'Server 5 at Node 1', 'Server 6 at Node 1']) - self.assertEqual([obs.busy for obs in N.servers], [True, False, False, False]) - self.assertEqual([obs.offduty for obs in N.servers], [True, False, False, False]) + self.assertEqual([str(obs) for obs in N.servers], + ['Server 2 at Node 1', + 'Server 4 at Node 1', + 'Server 5 at Node 1', + 'Server 6 at Node 1']) + self.assertEqual([obs.busy for obs in N.servers], + [True, False, False, False]) + self.assertEqual([obs.offduty for obs in N.servers], + [True, False, False, False]) self.assertEqual(N.c, 3) def test_take_servers_off_duty_method(self): - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_server_schedule/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_server_schedule/parameters.yml')) N = Q.transitive_nodes[0] N.add_new_server(3, 1) - self.assertEqual([str(obs) for obs in N.servers], ['Server 1 at Node 1', 'Server 2 at Node 1', 'Server 3 at Node 1', 'Server 4 at Node 1']) + self.assertEqual([str(obs) for obs in N.servers], + ['Server 1 at Node 1', + 'Server 2 at Node 1', + 'Server 3 at Node 1', + 'Server 4 at Node 1']) N.servers[1].busy = True N.servers[2].busy = True - self.assertEqual([obs.busy for obs in N.servers], [False, True, True, False]) - self.assertEqual([obs.offduty for obs in N.servers], [False, False, False, False]) + self.assertEqual([obs.busy for obs in N.servers], + [False, True, True, False]) + self.assertEqual([obs.offduty for obs in N.servers], + [False, False, False, False]) N.take_servers_off_duty() - self.assertEqual([str(obs) for obs in N.servers], ['Server 2 at Node 1', 'Server 3 at Node 1']) + self.assertEqual([str(obs) for obs in N.servers], + ['Server 2 at Node 1', 'Server 3 at Node 1']) self.assertEqual([obs.busy for obs in N.servers], [True, True]) self.assertEqual([obs.offduty for obs in N.servers], [True, True]) def test_check_if_shiftchange_method(self): - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_server_schedule/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_server_schedule/parameters.yml')) N = Q.transitive_nodes[0] N.next_event_date = 12.0 self.assertEqual(N.check_if_shiftchange(), False) N.next_event_date = 30.0 self.assertEqual(N.check_if_shiftchange(), True) - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) N = Q.transitive_nodes[0] N.next_event_date = 12.0 self.assertEqual(N.check_if_shiftchange(), False) @@ -95,20 +124,24 @@ def test_check_if_shiftchange_method(self): def test_finish_service_method(self): set_seed(4) - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) N = Q.transitive_nodes[0] - inds = [ciw.Individual(i+1) for i in range(3)] + inds = [ciw.Individual(i+1) for i in xrange(3)] for current_time in [0.01, 0.02, 0.03]: N.accept(inds[int(current_time*100 - 1)], current_time) - self.assertEqual([str(obs) for obs in N.individuals], ['Individual 1', 'Individual 2', 'Individual 3']) + self.assertEqual([str(obs) for obs in N.individuals], + ['Individual 1', 'Individual 2', 'Individual 3']) N.update_next_event_date(0.03) self.assertEqual(round(N.next_event_date, 5), 0.03604) N.finish_service() - self.assertEqual([str(obs) for obs in N.individuals], ['Individual 1', 'Individual 3']) + self.assertEqual([str(obs) for obs in N.individuals], + ['Individual 1', 'Individual 3']) def test_change_customer_class_method(self): set_seed(14) - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_dynamic_classes/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_dynamic_classes/parameters.yml')) N1 = Q.transitive_nodes[0] ind = ciw.Individual(254, 0) self.assertEqual(ind.customer_class, 0) @@ -128,8 +161,9 @@ def test_change_customer_class_method(self): def test_block_individual_method(self): set_seed(4) - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_deadlock_sim/parameters.yml')) - inds = [ciw.Individual(i+1) for i in range(7)] + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_deadlock_sim/parameters.yml')) + inds = [ciw.Individual(i+1) for i in xrange(7)] N1 = Q.transitive_nodes[0] N1.individuals = inds[:6] N2 = Q.transitive_nodes[1] @@ -140,35 +174,54 @@ def test_block_individual_method(self): N2.block_individual(inds[6], N1) self.assertEqual(inds[6].is_blocked, True) [(2, 7)] - self.assertEqual(Q.digraph.edges(), [('Server 1 at Node 2', 'Server 2 at Node 1'), ('Server 1 at Node 2', 'Server 5 at Node 1'), ('Server 1 at Node 2', 'Server 3 at Node 1'), ('Server 1 at Node 2', 'Server 1 at Node 1'), ('Server 1 at Node 2', 'Server 4 at Node 1')]) + self.assertEqual(Q.digraph.edges(), + [('Server 1 at Node 2', 'Server 2 at Node 1'), + ('Server 1 at Node 2', 'Server 5 at Node 1'), + ('Server 1 at Node 2', 'Server 3 at Node 1'), + ('Server 1 at Node 2', 'Server 1 at Node 1'), + ('Server 1 at Node 2', 'Server 4 at Node 1')]) def test_release_method(self): set_seed(4) - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) N = Q.transitive_nodes[0] - inds = [ciw.Individual(i+1) for i in range(3)] + inds = [ciw.Individual(i+1) for i in xrange(3)] for current_time in [0.01, 0.02, 0.03]: N.accept(inds[int(current_time*100 - 1)], current_time) - self.assertEqual([str(obs) for obs in N.individuals], ['Individual 1', 'Individual 2', 'Individual 3']) + self.assertEqual([str(obs) for obs in N.individuals], + ['Individual 1', 'Individual 2', 'Individual 3']) N.update_next_event_date(0.03) self.assertEqual(round(N.next_event_date, 5), 0.03604) - N.individuals[1].exit_date = 0.04 # shouldn't affect the next event date + N.individuals[1].exit_date = 0.04 N.update_next_event_date(N.next_event_date+0.00001) self.assertEqual(round(N.next_event_date, 5), 0.03708) N.release(1, Q.transitive_nodes[1], N.next_event_date) - self.assertEqual([str(obs) for obs in N.individuals], ['Individual 1', 'Individual 3']) + self.assertEqual([str(obs) for obs in N.individuals], + ['Individual 1', 'Individual 3']) N.update_next_event_date(N.next_event_date+0.00001) self.assertEqual(round(N.next_event_date, 5), 0.06447) def test_begin_service_if_possible_release_method(self): set_seed(50) - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_deadlock_sim/parameters.yml')) - inds = [ciw.Individual(i) for i in range(30)] + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_deadlock_sim/parameters.yml')) + inds = [ciw.Individual(i) for i in xrange(30)] Q.transitive_nodes[0].individuals = inds ind = Q.transitive_nodes[0].individuals[Q.transitive_nodes[0].c - 1] ind.service_time = 3.14 ind.arrival_date = 100.0 - self.assertEqual(Q.digraph.nodes(), ['Server 5 at Node 2', 'Server 5 at Node 1', 'Server 3 at Node 2', 'Server 1 at Node 2', 'Server 1 at Node 1', 'Server 2 at Node 1', 'Server 2 at Node 2', 'Server 3 at Node 1', 'Server 4 at Node 1', 'Server 4 at Node 2']) + self.assertEqual(Q.digraph.nodes(), + ['Server 5 at Node 2', + 'Server 5 at Node 1', + 'Server 3 at Node 2', + 'Server 1 at Node 2', + 'Server 1 at Node 1', + 'Server 2 at Node 1', + 'Server 2 at Node 2', + 'Server 3 at Node 1', + 'Server 4 at Node 1', + 'Server 4 at Node 2']) self.assertEqual(ind.arrival_date, 100.0) self.assertEqual(ind.service_time, 3.14) self.assertEqual(ind.service_start_date, False) @@ -180,35 +233,87 @@ def test_begin_service_if_possible_release_method(self): self.assertEqual(round(ind.service_end_date,5), 203.14) def test_release_blocked_individual_method(self): - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_deadlock_sim/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_deadlock_sim/parameters.yml')) N1 = Q.transitive_nodes[0] N2 = Q.transitive_nodes[1] - N1.individuals = [ciw.Individual(i) for i in range(N1.c + 3)] - N2.individuals = [ciw.Individual(i + 100) for i in range(N2.c + 4)] + N1.individuals = [ciw.Individual(i) for i in xrange(N1.c + 3)] + N2.individuals = [ciw.Individual(i + 100) for i in xrange(N2.c + 4)] for ind in N1.individuals[:2]: N1.attach_server(N1.find_free_server(), ind) for ind in N2.individuals[:1]: N2.attach_server(N2.find_free_server(), ind) - self.assertEqual([str(obs) for obs in N1.individuals], ['Individual 0', 'Individual 1', 'Individual 2', 'Individual 3', 'Individual 4', 'Individual 5', 'Individual 6', 'Individual 7']) - self.assertEqual([str(obs) for obs in N2.individuals], ['Individual 100', 'Individual 101', 'Individual 102', 'Individual 103', 'Individual 104', 'Individual 105', 'Individual 106', 'Individual 107', 'Individual 108']) + self.assertEqual([str(obs) for obs in N1.individuals], + ['Individual 0', + 'Individual 1', + 'Individual 2', + 'Individual 3', + 'Individual 4', + 'Individual 5', + 'Individual 6', + 'Individual 7']) + self.assertEqual([str(obs) for obs in N2.individuals], + ['Individual 100', + 'Individual 101', + 'Individual 102', + 'Individual 103', + 'Individual 104', + 'Individual 105', + 'Individual 106', + 'Individual 107', + 'Individual 108']) N1.release_blocked_individual(100) - self.assertEqual([str(obs) for obs in N1.individuals], ['Individual 0', 'Individual 1', 'Individual 2', 'Individual 3', 'Individual 4', 'Individual 5', 'Individual 6', 'Individual 7']) - self.assertEqual([str(obs) for obs in N2.individuals], ['Individual 100', 'Individual 101', 'Individual 102', 'Individual 103', 'Individual 104', 'Individual 105', 'Individual 106', 'Individual 107', 'Individual 108']) + self.assertEqual([str(obs) for obs in N1.individuals], + ['Individual 0', + 'Individual 1', + 'Individual 2', + 'Individual 3', + 'Individual 4', + 'Individual 5', + 'Individual 6', + 'Individual 7']) + self.assertEqual([str(obs) for obs in N2.individuals], + ['Individual 100', + 'Individual 101', + 'Individual 102', + 'Individual 103', + 'Individual 104', + 'Individual 105', + 'Individual 106', + 'Individual 107', + 'Individual 108']) N1.blocked_queue = [(1, 1), (2, 100)] rel_ind = N1.individuals.pop(0) N1.detatch_server(rel_ind.server, rel_ind) N1.release_blocked_individual(110) - self.assertEqual([str(obs) for obs in N1.individuals], ['Individual 2', 'Individual 3', 'Individual 4', 'Individual 5', 'Individual 6', 'Individual 7', 'Individual 100', 'Individual 1']) - self.assertEqual([str(obs) for obs in N2.individuals], ['Individual 101', 'Individual 102', 'Individual 103', 'Individual 104', 'Individual 105', 'Individual 106', 'Individual 107', 'Individual 108']) + self.assertEqual([str(obs) for obs in N1.individuals], + ['Individual 2', + 'Individual 3', + 'Individual 4', + 'Individual 5', + 'Individual 6', + 'Individual 7', + 'Individual 100', + 'Individual 1']) + self.assertEqual([str(obs) for obs in N2.individuals], + ['Individual 101', + 'Individual 102', + 'Individual 103', + 'Individual 104', + 'Individual 105', + 'Individual 106', + 'Individual 107', + 'Individual 108']) def test_change_state_release_method(self): - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) Q.state = [[0, 0], [0, 0], [2, 1], [0, 0]] N = Q.transitive_nodes[2] - inds = [ciw.Individual(i) for i in range(3)] + inds = [ciw.Individual(i) for i in xrange(3)] N.individuals = inds N.change_state_release(inds[0]) self.assertEqual(Q.state, [[0, 0], [0, 0], [1, 1], [0, 0]]) @@ -217,7 +322,8 @@ def test_change_state_release_method(self): self.assertEqual(Q.state, [[0, 0], [0, 0], [1, 0], [0, 0]]) def test_change_state_block_method(self): - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) Q.state = [[0, 0], [0, 0], [2, 1], [0, 0]] N = Q.transitive_nodes[2] N.change_state_block() @@ -226,7 +332,8 @@ def test_change_state_block_method(self): self.assertEqual(Q.state, [[0, 0], [0, 0], [0, 3], [0, 0]]) def test_change_state_accept_method(self): - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) Q.state = [[0, 0], [0, 0], [2, 1], [0, 0]] N = Q.transitive_nodes[2] N.change_state_accept() @@ -236,7 +343,8 @@ def test_change_state_accept_method(self): def test_accept_method(self): set_seed(6) - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) N = Q.transitive_nodes[0] N.next_event_date = 0.0 self.assertEqual(N.individuals, []) @@ -252,7 +360,8 @@ def test_accept_method(self): ind10 = ciw.Individual(10) N.accept(ind1, 0.01) - self.assertEqual([str(obs) for obs in N.individuals], ['Individual 1']) + self.assertEqual([str(obs) for obs in N.individuals], + ['Individual 1']) self.assertEqual(ind1.arrival_date, 0.01) self.assertEqual(ind1.service_start_date, 0.01) self.assertEqual(round(ind1.service_time, 5), 0.18695) @@ -261,7 +370,11 @@ def test_accept_method(self): N.accept(ind2, 0.02) N.accept(ind3, 0.03) N.accept(ind4, 0.04) - self.assertEqual([str(obs) for obs in N.individuals], ['Individual 1', 'Individual 2', 'Individual 3', 'Individual 4']) + self.assertEqual([str(obs) for obs in N.individuals], + ['Individual 1', + 'Individual 2', + 'Individual 3', + 'Individual 4']) self.assertEqual(round(ind4.arrival_date, 5), 0.04) self.assertEqual(round(ind4.service_start_date, 5), 0.04) self.assertEqual(round(ind4.service_time, 5), 0.1637) @@ -273,16 +386,37 @@ def test_accept_method(self): N.accept(ind8, 0.08) N.accept(ind9, 0.09) N.accept(ind10, 0.1) - self.assertEqual([str(obs) for obs in N.individuals], ['Individual 1', 'Individual 2', 'Individual 3', 'Individual 4', 'Individual 5', 'Individual 6', 'Individual 7', 'Individual 8', 'Individual 9', 'Individual 10']) + self.assertEqual([str(obs) for obs in N.individuals], + ['Individual 1', + 'Individual 2', + 'Individual 3', + 'Individual 4', + 'Individual 5', + 'Individual 6', + 'Individual 7', + 'Individual 8', + 'Individual 9', + 'Individual 10']) self.assertEqual(round(ind10.arrival_date, 5), 0.1) self.assertEqual(ind10.service_start_date, False) self.assertEqual(round(ind10.service_time, 5), 0.16534) def test_begin_service_if_possible_accept_method(self): set_seed(50) - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_deadlock_sim/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_deadlock_sim/parameters.yml')) ind = ciw.Individual(1) - self.assertEqual(Q.digraph.nodes(), ['Server 5 at Node 2', 'Server 5 at Node 1', 'Server 3 at Node 2', 'Server 1 at Node 2', 'Server 1 at Node 1', 'Server 2 at Node 1', 'Server 2 at Node 2', 'Server 3 at Node 1', 'Server 4 at Node 1', 'Server 4 at Node 2']) + self.assertEqual(Q.digraph.nodes(), + ['Server 5 at Node 2', + 'Server 5 at Node 1', + 'Server 3 at Node 2', + 'Server 1 at Node 2', + 'Server 1 at Node 1', + 'Server 2 at Node 1', + 'Server 2 at Node 2', + 'Server 3 at Node 1', + 'Server 4 at Node 1', + 'Server 4 at Node 2']) self.assertEqual(ind.arrival_date, False) self.assertEqual(ind.service_time, False) self.assertEqual(ind.service_start_date, False) @@ -294,34 +428,47 @@ def test_begin_service_if_possible_accept_method(self): self.assertEqual(round(ind.service_end_date,5), 300.03382) def test_kill_server_method(self): - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_server_schedule/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_server_schedule/parameters.yml')) N = Q.transitive_nodes[0] s = N.servers[0] - self.assertEqual([str(obs) for obs in N.servers], ['Server 1 at Node 1']) + self.assertEqual([str(obs) for obs in N.servers], + ['Server 1 at Node 1']) N.kill_server(s) N.highest_id += 1 self.assertEqual(N.servers, []) N.next_event_date = 30 N.have_event() - self.assertEqual([str(obs) for obs in N.servers], ['Server 2 at Node 1', 'Server 3 at Node 1']) + self.assertEqual([str(obs) for obs in N.servers], + ['Server 2 at Node 1', 'Server 3 at Node 1']) ind = ciw.Individual(666) N.attach_server(N.servers[0], ind) N.servers[0].offduty = True - self.assertEqual([obs.busy for obs in N.servers], [True, False]) - self.assertEqual([obs.offduty for obs in N.servers], [True, False]) + self.assertEqual([obs.busy for obs in N.servers], + [True, False]) + self.assertEqual([obs.offduty for obs in N.servers], + [True, False]) N.detatch_server(N.servers[0], ind) - self.assertEqual([str(obs) for obs in N.servers], ['Server 3 at Node 1']) + self.assertEqual([str(obs) for obs in N.servers], + ['Server 3 at Node 1']) def test_add_new_server_method(self): - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_server_schedule/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_server_schedule/parameters.yml')) N = Q.transitive_nodes[0] - self.assertEqual([str(obs) for obs in N.servers], ['Server 1 at Node 1']) + self.assertEqual([str(obs) for obs in N.servers], + ['Server 1 at Node 1']) s_indx = 3 N.add_new_server(s_indx,1) - self.assertEqual([str(obs) for obs in N.servers], ['Server 1 at Node 1', 'Server 2 at Node 1', 'Server 3 at Node 1', 'Server 4 at Node 1']) + self.assertEqual([str(obs) for obs in N.servers], + ['Server 1 at Node 1', + 'Server 2 at Node 1', + 'Server 3 at Node 1', + 'Server 4 at Node 1']) def test_update_next_event_date_method(self): - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) N = Q.transitive_nodes[0] self.assertEqual(N.next_event_date, 'Inf') self.assertEqual(N.individuals, []) @@ -347,13 +494,14 @@ def test_update_next_event_date_method(self): N.update_next_event_date(N.next_event_date+0.000001) self.assertEqual(N.next_event_date, 0.6) - ind2.exit_date = 0.9 # shouldn't affect next_event_date + ind2.exit_date = 0.9 N.update_next_event_date(N.next_event_date+0.000001) self.assertEqual(N.next_event_date, 'Inf') - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_server_schedule/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_server_schedule/parameters.yml')) N = Q.transitive_nodes[0] self.assertEqual(N.next_event_date, 30) self.assertEqual(N.individuals, []) @@ -374,7 +522,8 @@ def test_update_next_event_date_method(self): def test_next_node_method(self): set_seed(6) - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) node = Q.transitive_nodes[0] self.assertEqual(str(node.next_node(0)), 'Exit Node') self.assertEqual(str(node.next_node(0)), 'Node 3') @@ -384,7 +533,8 @@ def test_next_node_method(self): self.assertEqual(str(node.next_node(0)), 'Node 4') set_seed(54) - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) node = Q.transitive_nodes[2] self.assertEqual(str(node.next_node(0)), 'Node 2') self.assertEqual(str(node.next_node(0)), 'Node 2') @@ -397,7 +547,8 @@ def test_next_node_method(self): def test_write_individual_record_method(self): set_seed(7) - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) N = Q.transitive_nodes[0] ind = ciw.Individual(6) N.accept(ind, 3) diff --git a/ciw/tests/test_sampling.py b/ciw/tests/test_sampling.py index 8e17e846..dedeea20 100644 --- a/ciw/tests/test_sampling.py +++ b/ciw/tests/test_sampling.py @@ -2,7 +2,8 @@ import ciw from random import seed, random, choice from hypothesis import given -from hypothesis.strategies import floats, integers, lists, random_module, assume, text +from hypothesis.strategies import (floats, integers, lists, + random_module, assume, text) import os import copy from numpy import random as nprandom @@ -14,14 +15,14 @@ def set_seed(x): def custom_function(): """ - Custom function to test user defined function functionality + Custom function to test user defined function functionality. """ val = random() if int(str(val*10)[0]) % 2 == 0: return 2 * val return val / 2.0 -class TestSimulation(unittest.TestCase): +class TestSampling(unittest.TestCase): def test_sampling_uniform_dist(self): Arrival_distributions = [['Uniform', 2.2, 3.3]] @@ -36,18 +37,31 @@ def test_sampling_uniform_dist(self): Simulation_time=Simulation_time) Nu = Q.transitive_nodes[0] set_seed(5) - self.assertEqual(round(Nu.simulation.service_times[Nu.id_number][0](), 2), 2.89) - self.assertEqual(round(Nu.simulation.service_times[Nu.id_number][0](), 2), 3.02) - self.assertEqual(round(Nu.simulation.service_times[Nu.id_number][0](), 2), 3.07) - self.assertEqual(round(Nu.simulation.service_times[Nu.id_number][0](), 2), 3.24) - self.assertEqual(round(Nu.simulation.service_times[Nu.id_number][0](), 2), 3.01) - self.assertEqual(round(Nu.simulation.inter_arrival_times[Nu.id_number][0](), 2), 3.21) - self.assertEqual(round(Nu.simulation.inter_arrival_times[Nu.id_number][0](), 2), 2.23) - self.assertEqual(round(Nu.simulation.inter_arrival_times[Nu.id_number][0](), 2), 2.71) - self.assertEqual(round(Nu.simulation.inter_arrival_times[Nu.id_number][0](), 2), 3.24) - self.assertEqual(round(Nu.simulation.inter_arrival_times[Nu.id_number][0](), 2), 2.91) - - @given(u=lists(floats(min_value=0.0, max_value=10000), min_size=2, max_size=2, unique=True).map(sorted), + self.assertEqual(round( + Nu.simulation.service_times[Nu.id_number][0](), 2), 2.89) + self.assertEqual(round( + Nu.simulation.service_times[Nu.id_number][0](), 2), 3.02) + self.assertEqual(round( + Nu.simulation.service_times[Nu.id_number][0](), 2), 3.07) + self.assertEqual(round( + Nu.simulation.service_times[Nu.id_number][0](), 2), 3.24) + self.assertEqual(round( + Nu.simulation.service_times[Nu.id_number][0](), 2), 3.01) + self.assertEqual(round( + Nu.simulation.inter_arrival_times[Nu.id_number][0](), 2), 3.21) + self.assertEqual(round( + Nu.simulation.inter_arrival_times[Nu.id_number][0](), 2), 2.23) + self.assertEqual(round( + Nu.simulation.inter_arrival_times[Nu.id_number][0](), 2), 2.71) + self.assertEqual(round( + Nu.simulation.inter_arrival_times[Nu.id_number][0](), 2), 3.24) + self.assertEqual(round( + Nu.simulation.inter_arrival_times[Nu.id_number][0](), 2), 2.91) + + @given(u=lists(floats(min_value=0.0, max_value=10000), + min_size=2, + max_size=2, + unique=True).map(sorted), rm=random_module()) def test_sampling_uniform_dist_hypothesis(self, u, rm): ul, uh = u[0], u[1] @@ -62,7 +76,7 @@ def test_sampling_uniform_dist_hypothesis(self, u, rm): Transition_matrices=Transition_matrices, Simulation_time=Simulation_time) Nu = Q.transitive_nodes[0] - for itr in range(10): # Because repition happens in the simulation + for itr in xrange(10): # Because repition happens in the simulation self.assertTrue(ul <= Nu.simulation.service_times[Nu.id_number][0]() <= uh) self.assertTrue(ul <= Nu.simulation.inter_arrival_times[Nu.id_number][0]() <= uh) @@ -76,10 +90,30 @@ def test_error_uniform_dist(self): Number_of_servers = [1] Transition_matrices = [[0.1]] Simulation_time = 2222 - self.assertRaises(ValueError, ciw.Simulation, {'Arrival_distributions':Arrival_distributions_E, 'Service_distributions':Service_distributions, 'Number_of_servers':Number_of_servers, 'Transition_matrices':Transition_matrices, 'Simulation_time':Simulation_time}) - self.assertRaises(ValueError, ciw.Simulation, {'Arrival_distributions':Arrival_distributions_EE, 'Service_distributions':Service_distributions, 'Number_of_servers':Number_of_servers, 'Transition_matrices':Transition_matrices, 'Simulation_time':Simulation_time}) - self.assertRaises(ValueError, ciw.Simulation, {'Arrival_distributions':Arrival_distributions, 'Service_distributions':Service_distributions_E, 'Number_of_servers':Number_of_servers, 'Transition_matrices':Transition_matrices, 'Simulation_time':Simulation_time}) - self.assertRaises(ValueError, ciw.Simulation, {'Arrival_distributions':Arrival_distributions, 'Service_distributions':Service_distributions_EE, 'Number_of_servers':Number_of_servers, 'Transition_matrices':Transition_matrices, 'Simulation_time':Simulation_time}) + self.assertRaises(ValueError, ciw.Simulation, + {'Arrival_distributions':Arrival_distributions_E, + 'Service_distributions':Service_distributions, + 'Number_of_servers':Number_of_servers, + 'Transition_matrices':Transition_matrices, + 'Simulation_time':Simulation_time}) + self.assertRaises(ValueError, ciw.Simulation, + {'Arrival_distributions':Arrival_distributions_EE, + 'Service_distributions':Service_distributions, + 'Number_of_servers':Number_of_servers, + 'Transition_matrices':Transition_matrices, + 'Simulation_time':Simulation_time}) + self.assertRaises(ValueError, ciw.Simulation, + {'Arrival_distributions':Arrival_distributions, + 'Service_distributions':Service_distributions_E, + 'Number_of_servers':Number_of_servers, + 'Transition_matrices':Transition_matrices, + 'Simulation_time':Simulation_time}) + self.assertRaises(ValueError, ciw.Simulation, + {'Arrival_distributions':Arrival_distributions, + 'Service_distributions':Service_distributions_EE, + 'Number_of_servers':Number_of_servers, + 'Transition_matrices':Transition_matrices, + 'Simulation_time':Simulation_time}) def test_sampling_deterministic_dist(self): Arrival_distributions = [['Deterministic', 4.4]] @@ -94,16 +128,26 @@ def test_sampling_deterministic_dist(self): Simulation_time=Simulation_time) Nd = Q.transitive_nodes[0] set_seed(5) - self.assertEqual(round(Nd.simulation.service_times[Nd.id_number][0](), 2), 4.40) - self.assertEqual(round(Nd.simulation.service_times[Nd.id_number][0](), 2), 4.40) - self.assertEqual(round(Nd.simulation.service_times[Nd.id_number][0](), 2), 4.40) - self.assertEqual(round(Nd.simulation.service_times[Nd.id_number][0](), 2), 4.40) - self.assertEqual(round(Nd.simulation.service_times[Nd.id_number][0](), 2), 4.40) - self.assertEqual(round(Nd.simulation.inter_arrival_times[Nd.id_number][0](), 2), 4.40) - self.assertEqual(round(Nd.simulation.inter_arrival_times[Nd.id_number][0](), 2), 4.40) - self.assertEqual(round(Nd.simulation.inter_arrival_times[Nd.id_number][0](), 2), 4.40) - self.assertEqual(round(Nd.simulation.inter_arrival_times[Nd.id_number][0](), 2), 4.40) - self.assertEqual(round(Nd.simulation.inter_arrival_times[Nd.id_number][0](), 2), 4.40) + self.assertEqual(round( + Nd.simulation.service_times[Nd.id_number][0](), 2), 4.40) + self.assertEqual(round( + Nd.simulation.service_times[Nd.id_number][0](), 2), 4.40) + self.assertEqual(round( + Nd.simulation.service_times[Nd.id_number][0](), 2), 4.40) + self.assertEqual(round( + Nd.simulation.service_times[Nd.id_number][0](), 2), 4.40) + self.assertEqual(round( + Nd.simulation.service_times[Nd.id_number][0](), 2), 4.40) + self.assertEqual(round( + Nd.simulation.inter_arrival_times[Nd.id_number][0](), 2), 4.40) + self.assertEqual(round( + Nd.simulation.inter_arrival_times[Nd.id_number][0](), 2), 4.40) + self.assertEqual(round( + Nd.simulation.inter_arrival_times[Nd.id_number][0](), 2), 4.40) + self.assertEqual(round( + Nd.simulation.inter_arrival_times[Nd.id_number][0](), 2), 4.40) + self.assertEqual(round( + Nd.simulation.inter_arrival_times[Nd.id_number][0](), 2), 4.40) @given(d=floats(min_value=0.0, max_value=10000), rm=random_module()) @@ -119,7 +163,7 @@ def test_sampling_deterministic_dist_hypothesis(self, d, rm): Transition_matrices=Transition_matrices, Simulation_time=Simulation_time) Nd = Q.transitive_nodes[0] - for itr in range(10): # Because repition happens in the simulation + for itr in xrange(10): # Because repition happens in the simulation self.assertEqual(Nd.simulation.service_times[Nd.id_number][0](), d) self.assertEqual(Nd.simulation.inter_arrival_times[Nd.id_number][0](), d) @@ -131,8 +175,18 @@ def test_error_deterministic_dist(self): Number_of_servers = [1] Transition_matrices = [[0.1]] Simulation_time = 2222 - self.assertRaises(ValueError, ciw.Simulation, {'Arrival_distributions':Arrival_distributions_E, 'Service_distributions':Service_distributions, 'Number_of_servers':Number_of_servers, 'Transition_matrices':Transition_matrices, 'Simulation_time':Simulation_time}) - self.assertRaises(ValueError, ciw.Simulation, {'Arrival_distributions':Arrival_distributions, 'Service_distributions':Service_distributions_E, 'Number_of_servers':Number_of_servers, 'Transition_matrices':Transition_matrices, 'Simulation_time':Simulation_time}) + self.assertRaises(ValueError, ciw.Simulation, + {'Arrival_distributions':Arrival_distributions_E, + 'Service_distributions':Service_distributions, + 'Number_of_servers':Number_of_servers, + 'Transition_matrices':Transition_matrices, + 'Simulation_time':Simulation_time}) + self.assertRaises(ValueError, ciw.Simulation, + {'Arrival_distributions':Arrival_distributions, + 'Service_distributions':Service_distributions_E, + 'Number_of_servers':Number_of_servers, + 'Transition_matrices':Transition_matrices, + 'Simulation_time':Simulation_time}) def test_sampling_triangular_dist(self): Arrival_distributions = [['Triangular', 1.1, 6.6, 1.5]] @@ -147,18 +201,31 @@ def test_sampling_triangular_dist(self): Simulation_time=Simulation_time) Nt = Q.transitive_nodes[0] set_seed(5) - self.assertEqual(round(Nt.simulation.service_times[Nt.id_number][0](), 2), 3.35) - self.assertEqual(round(Nt.simulation.service_times[Nt.id_number][0](), 2), 3.91) - self.assertEqual(round(Nt.simulation.service_times[Nt.id_number][0](), 2), 4.20) - self.assertEqual(round(Nt.simulation.service_times[Nt.id_number][0](), 2), 5.33) - self.assertEqual(round(Nt.simulation.service_times[Nt.id_number][0](), 2), 3.90) - self.assertEqual(round(Nt.simulation.inter_arrival_times[Nt.id_number][0](), 2), 5.12) - self.assertEqual(round(Nt.simulation.inter_arrival_times[Nt.id_number][0](), 2), 1.35) - self.assertEqual(round(Nt.simulation.inter_arrival_times[Nt.id_number][0](), 2), 2.73) - self.assertEqual(round(Nt.simulation.inter_arrival_times[Nt.id_number][0](), 2), 5.34) - self.assertEqual(round(Nt.simulation.inter_arrival_times[Nt.id_number][0](), 2), 3.46) - - @given(t=lists(floats(min_value=0.0, max_value=10000), min_size=3, max_size=3, unique=True).map(sorted), + self.assertEqual(round( + Nt.simulation.service_times[Nt.id_number][0](), 2), 3.35) + self.assertEqual(round( + Nt.simulation.service_times[Nt.id_number][0](), 2), 3.91) + self.assertEqual(round( + Nt.simulation.service_times[Nt.id_number][0](), 2), 4.20) + self.assertEqual(round( + Nt.simulation.service_times[Nt.id_number][0](), 2), 5.33) + self.assertEqual(round( + Nt.simulation.service_times[Nt.id_number][0](), 2), 3.90) + self.assertEqual(round( + Nt.simulation.inter_arrival_times[Nt.id_number][0](), 2), 5.12) + self.assertEqual(round( + Nt.simulation.inter_arrival_times[Nt.id_number][0](), 2), 1.35) + self.assertEqual(round( + Nt.simulation.inter_arrival_times[Nt.id_number][0](), 2), 2.73) + self.assertEqual(round( + Nt.simulation.inter_arrival_times[Nt.id_number][0](), 2), 5.34) + self.assertEqual(round( + Nt.simulation.inter_arrival_times[Nt.id_number][0](), 2), 3.46) + + @given(t=lists(floats(min_value=0.0, max_value=10000), + min_size=3, + max_size=3, + unique=True).map(sorted), rm=random_module()) def test_sampling_triangular_dist_hypothesis(self, t, rm): tl, tm, th = t[0], t[1], t[2] @@ -173,7 +240,7 @@ def test_sampling_triangular_dist_hypothesis(self, t, rm): Transition_matrices=Transition_matrices, Simulation_time=Simulation_time) Nt = Q.transitive_nodes[0] - for itr in range(10): # Because repition happens in the simulation + for itr in xrange(10): # Because repition happens in the simulation self.assertTrue(tl <= Nt.simulation.service_times[Nt.id_number][0]() <= th) self.assertTrue(tl <= Nt.simulation.inter_arrival_times[Nt.id_number][0]() <= th) @@ -187,10 +254,30 @@ def test_error_triangular_dist(self): Number_of_servers = [1] Transition_matrices = [[0.1]] Simulation_time = 2222 - self.assertRaises(ValueError, ciw.Simulation, {'Arrival_distributions':Arrival_distributions_E, 'Service_distributions':Service_distributions, 'Number_of_servers':Number_of_servers, 'Transition_matrices':Transition_matrices, 'Simulation_time':Simulation_time}) - self.assertRaises(ValueError, ciw.Simulation, {'Arrival_distributions':Arrival_distributions_EE, 'Service_distributions':Service_distributions, 'Number_of_servers':Number_of_servers, 'Transition_matrices':Transition_matrices, 'Simulation_time':Simulation_time}) - self.assertRaises(ValueError, ciw.Simulation, {'Arrival_distributions':Arrival_distributions, 'Service_distributions':Service_distributions_E, 'Number_of_servers':Number_of_servers, 'Transition_matrices':Transition_matrices, 'Simulation_time':Simulation_time}) - self.assertRaises(ValueError, ciw.Simulation, {'Arrival_distributions':Arrival_distributions, 'Service_distributions':Service_distributions_EE, 'Number_of_servers':Number_of_servers, 'Transition_matrices':Transition_matrices, 'Simulation_time':Simulation_time}) + self.assertRaises(ValueError, ciw.Simulation, + {'Arrival_distributions':Arrival_distributions_E, + 'Service_distributions':Service_distributions, + 'Number_of_servers':Number_of_servers, + 'Transition_matrices':Transition_matrices, + 'Simulation_time':Simulation_time}) + self.assertRaises(ValueError, ciw.Simulation, + {'Arrival_distributions':Arrival_distributions_EE, + 'Service_distributions':Service_distributions, + 'Number_of_servers':Number_of_servers, + 'Transition_matrices':Transition_matrices, + 'Simulation_time':Simulation_time}) + self.assertRaises(ValueError, ciw.Simulation, + {'Arrival_distributions':Arrival_distributions, + 'Service_distributions':Service_distributions_E, + 'Number_of_servers':Number_of_servers, + 'Transition_matrices':Transition_matrices, + 'Simulation_time':Simulation_time}) + self.assertRaises(ValueError, ciw.Simulation, + {'Arrival_distributions':Arrival_distributions, + 'Service_distributions':Service_distributions_EE, + 'Number_of_servers':Number_of_servers, + 'Transition_matrices':Transition_matrices, + 'Simulation_time':Simulation_time}) def test_sampling_exponential_dist(self): Arrival_distributions = [['Exponential', 4.4]] @@ -205,16 +292,26 @@ def test_sampling_exponential_dist(self): Simulation_time=Simulation_time) Ne = Q.transitive_nodes[0] set_seed(5) - self.assertEqual(round(Ne.simulation.service_times[Ne.id_number][0](), 2), 0.22) - self.assertEqual(round(Ne.simulation.service_times[Ne.id_number][0](), 2), 0.31) - self.assertEqual(round(Ne.simulation.service_times[Ne.id_number][0](), 2), 0.36) - self.assertEqual(round(Ne.simulation.service_times[Ne.id_number][0](), 2), 0.65) - self.assertEqual(round(Ne.simulation.service_times[Ne.id_number][0](), 2), 0.31) - self.assertEqual(round(Ne.simulation.inter_arrival_times[Ne.id_number][0](), 2), 0.58) - self.assertEqual(round(Ne.simulation.inter_arrival_times[Ne.id_number][0](), 2), 0.01) - self.assertEqual(round(Ne.simulation.inter_arrival_times[Ne.id_number][0](), 2), 0.14) - self.assertEqual(round(Ne.simulation.inter_arrival_times[Ne.id_number][0](), 2), 0.65) - self.assertEqual(round(Ne.simulation.inter_arrival_times[Ne.id_number][0](), 2), 0.24) + self.assertEqual(round( + Ne.simulation.service_times[Ne.id_number][0](), 2), 0.22) + self.assertEqual(round( + Ne.simulation.service_times[Ne.id_number][0](), 2), 0.31) + self.assertEqual(round( + Ne.simulation.service_times[Ne.id_number][0](), 2), 0.36) + self.assertEqual(round( + Ne.simulation.service_times[Ne.id_number][0](), 2), 0.65) + self.assertEqual(round( + Ne.simulation.service_times[Ne.id_number][0](), 2), 0.31) + self.assertEqual(round( + Ne.simulation.inter_arrival_times[Ne.id_number][0](), 2), 0.58) + self.assertEqual(round( + Ne.simulation.inter_arrival_times[Ne.id_number][0](), 2), 0.01) + self.assertEqual(round( + Ne.simulation.inter_arrival_times[Ne.id_number][0](), 2), 0.14) + self.assertEqual(round( + Ne.simulation.inter_arrival_times[Ne.id_number][0](), 2), 0.65) + self.assertEqual(round( + Ne.simulation.inter_arrival_times[Ne.id_number][0](), 2), 0.24) @given(e=floats(min_value=0.001, max_value=10000), rm=random_module()) @@ -230,7 +327,7 @@ def test_sampling_exponential_dist_hypothesis(self, e, rm): Transition_matrices=Transition_matrices, Simulation_time=Simulation_time) Ne = Q.transitive_nodes[0] - for itr in range(10): # Because repition happens in the simulation + for itr in xrange(10): # Because repition happens in the simulation self.assertTrue(Ne.simulation.service_times[Ne.id_number][0]() >= 0.0) self.assertTrue(Ne.simulation.inter_arrival_times[Ne.id_number][0]() >= 0.0) @@ -247,16 +344,26 @@ def test_sampling_gamma_dist(self): Simulation_time=Simulation_time) Ng = Q.transitive_nodes[0] set_seed(5) - self.assertEqual(round(Ng.simulation.service_times[Ng.id_number][0](), 2), 0.00) - self.assertEqual(round(Ng.simulation.service_times[Ng.id_number][0](), 2), 2.59) - self.assertEqual(round(Ng.simulation.service_times[Ng.id_number][0](), 2), 1.92) - self.assertEqual(round(Ng.simulation.service_times[Ng.id_number][0](), 2), 0.47) - self.assertEqual(round(Ng.simulation.service_times[Ng.id_number][0](), 2), 0.61) - self.assertEqual(round(Ng.simulation.inter_arrival_times[Ng.id_number][0](), 2), 0.00) - self.assertEqual(round(Ng.simulation.inter_arrival_times[Ng.id_number][0](), 2), 1.07) - self.assertEqual(round(Ng.simulation.inter_arrival_times[Ng.id_number][0](), 2), 1.15) - self.assertEqual(round(Ng.simulation.inter_arrival_times[Ng.id_number][0](), 2), 0.75) - self.assertEqual(round(Ng.simulation.inter_arrival_times[Ng.id_number][0](), 2), 0.00) + self.assertEqual(round( + Ng.simulation.service_times[Ng.id_number][0](), 2), 0.00) + self.assertEqual(round( + Ng.simulation.service_times[Ng.id_number][0](), 2), 2.59) + self.assertEqual(round( + Ng.simulation.service_times[Ng.id_number][0](), 2), 1.92) + self.assertEqual(round( + Ng.simulation.service_times[Ng.id_number][0](), 2), 0.47) + self.assertEqual(round( + Ng.simulation.service_times[Ng.id_number][0](), 2), 0.61) + self.assertEqual(round( + Ng.simulation.inter_arrival_times[Ng.id_number][0](), 2), 0.00) + self.assertEqual(round( + Ng.simulation.inter_arrival_times[Ng.id_number][0](), 2), 1.07) + self.assertEqual(round( + Ng.simulation.inter_arrival_times[Ng.id_number][0](), 2), 1.15) + self.assertEqual(round( + Ng.simulation.inter_arrival_times[Ng.id_number][0](), 2), 0.75) + self.assertEqual(round( + Ng.simulation.inter_arrival_times[Ng.id_number][0](), 2), 0.00) @given(ga=floats(min_value=0.001, max_value=10000), gb=floats(min_value=0.001, max_value=10000), @@ -273,7 +380,7 @@ def test_sampling_gamma_dist_hypothesis(self, ga, gb, rm): Transition_matrices=Transition_matrices, Simulation_time=Simulation_time) Ng = Q.transitive_nodes[0] - for itr in range(10): # Because repition happens in the simulation + for itr in xrange(10): # Because repition happens in the simulation self.assertTrue(Ng.simulation.service_times[Ng.id_number][0]() >= 0.0) self.assertTrue(Ng.simulation.inter_arrival_times[Ng.id_number][0]() >= 0.0) @@ -290,16 +397,26 @@ def test_sampling_lognormal_dist(self): Simulation_time=Simulation_time) Nl = Q.transitive_nodes[0] set_seed(5) - self.assertEqual(round(Nl.simulation.service_times[Nl.id_number][0](), 2), 2.62) - self.assertEqual(round(Nl.simulation.service_times[Nl.id_number][0](), 2), 1.64) - self.assertEqual(round(Nl.simulation.service_times[Nl.id_number][0](), 2), 2.19) - self.assertEqual(round(Nl.simulation.service_times[Nl.id_number][0](), 2), 2.31) - self.assertEqual(round(Nl.simulation.service_times[Nl.id_number][0](), 2), 2.48) - self.assertEqual(round(Nl.simulation.inter_arrival_times[Nl.id_number][0](), 2), 2.51) - self.assertEqual(round(Nl.simulation.inter_arrival_times[Nl.id_number][0](), 2), 2.33) - self.assertEqual(round(Nl.simulation.inter_arrival_times[Nl.id_number][0](), 2), 1.96) - self.assertEqual(round(Nl.simulation.inter_arrival_times[Nl.id_number][0](), 2), 2.32) - self.assertEqual(round(Nl.simulation.inter_arrival_times[Nl.id_number][0](), 2), 2.70) + self.assertEqual(round( + Nl.simulation.service_times[Nl.id_number][0](), 2), 2.62) + self.assertEqual(round( + Nl.simulation.service_times[Nl.id_number][0](), 2), 1.64) + self.assertEqual(round( + Nl.simulation.service_times[Nl.id_number][0](), 2), 2.19) + self.assertEqual(round( + Nl.simulation.service_times[Nl.id_number][0](), 2), 2.31) + self.assertEqual(round( + Nl.simulation.service_times[Nl.id_number][0](), 2), 2.48) + self.assertEqual(round( + Nl.simulation.inter_arrival_times[Nl.id_number][0](), 2), 2.51) + self.assertEqual(round( + Nl.simulation.inter_arrival_times[Nl.id_number][0](), 2), 2.33) + self.assertEqual(round( + Nl.simulation.inter_arrival_times[Nl.id_number][0](), 2), 1.96) + self.assertEqual(round( + Nl.simulation.inter_arrival_times[Nl.id_number][0](), 2), 2.32) + self.assertEqual(round( + Nl.simulation.inter_arrival_times[Nl.id_number][0](), 2), 2.70) @given(lm=floats(min_value=-200, max_value=200), lsd=floats(min_value=0.001, max_value=80), @@ -316,7 +433,7 @@ def test_sampling_lognormal_dist_hypothesis(self, lm, lsd, rm): Transition_matrices=Transition_matrices, Simulation_time=Simulation_time) Nl = Q.transitive_nodes[0] - for itr in range(10): # Because repition happens in the simulation + for itr in xrange(10): # Because repition happens in the simulation self.assertTrue(Nl.simulation.service_times[Nl.id_number][0]() >= 0.0) self.assertTrue(Nl.simulation.inter_arrival_times[Nl.id_number][0]() >= 0.0) @@ -333,16 +450,26 @@ def test_sampling_weibull_dist(self): Simulation_time=Simulation_time) Nw = Q.transitive_nodes[0] set_seed(5) - self.assertEqual(round(Nw.simulation.service_times[Nw.id_number][0](), 2), 0.87) - self.assertEqual(round(Nw.simulation.service_times[Nw.id_number][0](), 2), 1.31) - self.assertEqual(round(Nw.simulation.service_times[Nw.id_number][0](), 2), 1.60) - self.assertEqual(round(Nw.simulation.service_times[Nw.id_number][0](), 2), 3.34) - self.assertEqual(round(Nw.simulation.service_times[Nw.id_number][0](), 2), 1.31) - self.assertEqual(round(Nw.simulation.inter_arrival_times[Nw.id_number][0](), 2), 2.91) - self.assertEqual(round(Nw.simulation.inter_arrival_times[Nw.id_number][0](), 2), 0.01) - self.assertEqual(round(Nw.simulation.inter_arrival_times[Nw.id_number][0](), 2), 0.50) - self.assertEqual(round(Nw.simulation.inter_arrival_times[Nw.id_number][0](), 2), 3.36) - self.assertEqual(round(Nw.simulation.inter_arrival_times[Nw.id_number][0](), 2), 0.95) + self.assertEqual(round( + Nw.simulation.service_times[Nw.id_number][0](), 2), 0.87) + self.assertEqual(round( + Nw.simulation.service_times[Nw.id_number][0](), 2), 1.31) + self.assertEqual(round( + Nw.simulation.service_times[Nw.id_number][0](), 2), 1.60) + self.assertEqual(round( + Nw.simulation.service_times[Nw.id_number][0](), 2), 3.34) + self.assertEqual(round( + Nw.simulation.service_times[Nw.id_number][0](), 2), 1.31) + self.assertEqual(round( + Nw.simulation.inter_arrival_times[Nw.id_number][0](), 2), 2.91) + self.assertEqual(round( + Nw.simulation.inter_arrival_times[Nw.id_number][0](), 2), 0.01) + self.assertEqual(round( + Nw.simulation.inter_arrival_times[Nw.id_number][0](), 2), 0.50) + self.assertEqual(round( + Nw.simulation.inter_arrival_times[Nw.id_number][0](), 2), 3.36) + self.assertEqual(round( + Nw.simulation.inter_arrival_times[Nw.id_number][0](), 2), 0.95) @given(wa=floats(min_value=0.01, max_value=200), wb=floats(min_value=0.01, max_value=200), @@ -359,13 +486,14 @@ def test_sampling_weibull_dist_hypothesis(self, wa, wb, rm): Transition_matrices=Transition_matrices, Simulation_time=Simulation_time) Nw = Q.transitive_nodes[0] - for itr in range(10): # Because repition happens in the simulation + for itr in xrange(10): # Because repition happens in the simulation self.assertTrue(Nw.simulation.service_times[Nw.id_number][0]() >= 0.0) self.assertTrue(Nw.simulation.inter_arrival_times[Nw.id_number][0]() >= 0.0) def test_sampling_empirical_dist(self): my_empirical_dist = [8.0, 8.0, 8.0, 8.8, 8.8, 12.3] - Arrival_distributions = [['Empirical', 'ciw/tests/datafortesting/sample_empirical_dist.csv']] + Arrival_distributions = [['Empirical', + 'ciw/tests/datafortesting/sample_empirical_dist.csv']] Service_distributions = [['Empirical', my_empirical_dist]] Number_of_servers = [1] Transition_matrices = [[0.1]] @@ -377,23 +505,36 @@ def test_sampling_empirical_dist(self): Simulation_time=Simulation_time) Nem = Q.transitive_nodes[0] set_seed(5) - self.assertEqual(round(Nem.simulation.service_times[Nem.id_number][0](), 2), 8.8) - self.assertEqual(round(Nem.simulation.service_times[Nem.id_number][0](), 2), 8.8) - self.assertEqual(round(Nem.simulation.service_times[Nem.id_number][0](), 2), 8.8) - self.assertEqual(round(Nem.simulation.service_times[Nem.id_number][0](), 2), 12.3) - self.assertEqual(round(Nem.simulation.service_times[Nem.id_number][0](), 2), 8.8) - self.assertEqual(round(Nem.simulation.inter_arrival_times[Nem.id_number][0](), 2), 7.3) - self.assertEqual(round(Nem.simulation.inter_arrival_times[Nem.id_number][0](), 2), 7.0) - self.assertEqual(round(Nem.simulation.inter_arrival_times[Nem.id_number][0](), 2), 7.7) - self.assertEqual(round(Nem.simulation.inter_arrival_times[Nem.id_number][0](), 2), 7.3) - self.assertEqual(round(Nem.simulation.inter_arrival_times[Nem.id_number][0](), 2), 7.1) - - @given(dist=lists(floats(min_value=0.001, max_value=10000), min_size=1, max_size=20), + self.assertEqual(round( + Nem.simulation.service_times[Nem.id_number][0](), 2), 8.8) + self.assertEqual(round( + Nem.simulation.service_times[Nem.id_number][0](), 2), 8.8) + self.assertEqual(round( + Nem.simulation.service_times[Nem.id_number][0](), 2), 8.8) + self.assertEqual(round( + Nem.simulation.service_times[Nem.id_number][0](), 2), 12.3) + self.assertEqual(round( + Nem.simulation.service_times[Nem.id_number][0](), 2), 8.8) + self.assertEqual(round( + Nem.simulation.inter_arrival_times[Nem.id_number][0](), 2), 7.3) + self.assertEqual(round( + Nem.simulation.inter_arrival_times[Nem.id_number][0](), 2), 7.0) + self.assertEqual(round( + Nem.simulation.inter_arrival_times[Nem.id_number][0](), 2), 7.7) + self.assertEqual(round( + Nem.simulation.inter_arrival_times[Nem.id_number][0](), 2), 7.3) + self.assertEqual(round( + Nem.simulation.inter_arrival_times[Nem.id_number][0](), 2), 7.1) + + @given(dist=lists(floats(min_value=0.001, max_value=10000), + min_size=1, + max_size=20), rm=random_module()) def test_sampling_empirical_dist_hypothesis(self, dist, rm): my_empirical_dist = dist Arrival_distributions = [['Empirical', my_empirical_dist]] - Service_distributions = [['Empirical', 'ciw/tests/datafortesting/sample_empirical_dist.csv']] + Service_distributions = [['Empirical', + 'ciw/tests/datafortesting/sample_empirical_dist.csv']] Number_of_servers = [1] Transition_matrices = [[0.1]] Simulation_time = 2222 @@ -403,9 +544,11 @@ def test_sampling_empirical_dist_hypothesis(self, dist, rm): Transition_matrices=Transition_matrices, Simulation_time=Simulation_time,) Nem = Q.transitive_nodes[0] - for itr in range(10): # Because repition happens in the simulation - self.assertTrue(Nem.simulation.service_times[Nem.id_number][0]() in set([7.0, 7.1, 7.2, 7.3, 7.7, 7.8])) - self.assertTrue(Nem.simulation.inter_arrival_times[Nem.id_number][0]() in set(my_empirical_dist)) + for itr in xrange(10): # Because repition happens in the simulation + self.assertTrue(Nem.simulation.service_times[ + Nem.id_number][0]() in set([7.0, 7.1, 7.2, 7.3, 7.7, 7.8])) + self.assertTrue(Nem.simulation.inter_arrival_times[ + Nem.id_number][0]() in set(my_empirical_dist)) def test_error_empirical_dist(self): my_empirical_dist = [8.0, 8.0, 8.0, 8.8, 8.8, 12.3] @@ -417,8 +560,18 @@ def test_error_empirical_dist(self): Number_of_servers = [1] Transition_matrices = [[0.1]] Simulation_time = 2222 - self.assertRaises(ValueError, ciw.Simulation, {'Arrival_distributions':Arrival_distributions_E, 'Service_distributions':Service_distributions, 'Number_of_servers':Number_of_servers, 'Transition_matrices':Transition_matrices, 'Simulation_time':Simulation_time}) - self.assertRaises(ValueError, ciw.Simulation, {'Arrival_distributions':Arrival_distributions, 'Service_distributions':Service_distributions_E, 'Number_of_servers':Number_of_servers, 'Transition_matrices':Transition_matrices, 'Simulation_time':Simulation_time}) + self.assertRaises(ValueError, ciw.Simulation, + {'Arrival_distributions':Arrival_distributions_E, + 'Service_distributions':Service_distributions, + 'Number_of_servers':Number_of_servers, + 'Transition_matrices':Transition_matrices, + 'Simulation_time':Simulation_time}) + self.assertRaises(ValueError, ciw.Simulation, + {'Arrival_distributions':Arrival_distributions, + 'Service_distributions':Service_distributions_E, + 'Number_of_servers':Number_of_servers, + 'Transition_matrices':Transition_matrices, + 'Simulation_time':Simulation_time}) def test_sampling_custom_dist(self): my_custom_dist = [[0.2, 3.7], [0.5, 3.8], [0.3, 4.1]] @@ -435,18 +588,30 @@ def test_sampling_custom_dist(self): my_custom_dist=my_custom_dist) Nc = Q.transitive_nodes[0] set_seed(5) - self.assertEqual(round(Nc.simulation.service_times[Nc.id_number][0](), 2), 3.8) - self.assertEqual(round(Nc.simulation.service_times[Nc.id_number][0](), 2), 4.1) - self.assertEqual(round(Nc.simulation.service_times[Nc.id_number][0](), 2), 3.8) - self.assertEqual(round(Nc.simulation.service_times[Nc.id_number][0](), 2), 4.1) - self.assertEqual(round(Nc.simulation.service_times[Nc.id_number][0](), 2), 3.8) - self.assertEqual(round(Nc.simulation.inter_arrival_times[Nc.id_number][0](), 2), 3.8) - self.assertEqual(round(Nc.simulation.inter_arrival_times[Nc.id_number][0](), 2), 4.1) - self.assertEqual(round(Nc.simulation.inter_arrival_times[Nc.id_number][0](), 2), 3.8) - self.assertEqual(round(Nc.simulation.inter_arrival_times[Nc.id_number][0](), 2), 3.8) - self.assertEqual(round(Nc.simulation.inter_arrival_times[Nc.id_number][0](), 2), 3.7) - - @given(custs=lists(floats(min_value=0.001, max_value=10000), unique=True, min_size=2), + self.assertEqual(round( + Nc.simulation.service_times[Nc.id_number][0](), 2), 3.8) + self.assertEqual(round( + Nc.simulation.service_times[Nc.id_number][0](), 2), 4.1) + self.assertEqual(round( + Nc.simulation.service_times[Nc.id_number][0](), 2), 3.8) + self.assertEqual(round( + Nc.simulation.service_times[Nc.id_number][0](), 2), 4.1) + self.assertEqual(round( + Nc.simulation.service_times[Nc.id_number][0](), 2), 3.8) + self.assertEqual(round( + Nc.simulation.inter_arrival_times[Nc.id_number][0](), 2), 3.8) + self.assertEqual(round( + Nc.simulation.inter_arrival_times[Nc.id_number][0](), 2), 4.1) + self.assertEqual(round( + Nc.simulation.inter_arrival_times[Nc.id_number][0](), 2), 3.8) + self.assertEqual(round( + Nc.simulation.inter_arrival_times[Nc.id_number][0](), 2), 3.8) + self.assertEqual(round( + Nc.simulation.inter_arrival_times[Nc.id_number][0](), 2), 3.7) + + @given(custs=lists(floats(min_value=0.001, max_value=10000), + min_size=2, + unique=True), rm=random_module()) def test_sampling_custom_dist_hypothesis(self, custs, rm): Arrival_distributions = [['Custom', 'my_custom_dist']] @@ -456,7 +621,7 @@ def test_sampling_custom_dist_hypothesis(self, custs, rm): Simulation_time = 2222 cust_vals = [round(i, 10) for i in custs] numprobs = len(cust_vals) - probs = [1.0/numprobs for i in range(numprobs)] + probs = [1.0/numprobs for i in xrange(numprobs)] my_custom_dist = [list(i) for i in (zip(probs, cust_vals))] Q = ciw.Simulation(Arrival_distributions=Arrival_distributions, Service_distributions=Service_distributions, @@ -465,9 +630,11 @@ def test_sampling_custom_dist_hypothesis(self, custs, rm): Simulation_time=Simulation_time, my_custom_dist=my_custom_dist) Nc = Q.transitive_nodes[0] - for itr in range(10): # Because repition happens in the simulation - self.assertTrue(Nc.simulation.service_times[Nc.id_number][0]() in set(cust_vals)) - self.assertTrue(Nc.simulation.inter_arrival_times[Nc.id_number][0]() in set(cust_vals)) + for itr in xrange(10): # Because repition happens in the simulation + self.assertTrue(Nc.simulation.service_times[ + Nc.id_number][0]() in set(cust_vals)) + self.assertTrue(Nc.simulation.inter_arrival_times[ + Nc.id_number][0]() in set(cust_vals)) def test_error_custom_dist(self): my_custom_dist = [[0.2, 3.7], [0.5, 3.8], [0.3, 4.1]] @@ -482,14 +649,48 @@ def test_error_custom_dist(self): Number_of_servers = [1] Transition_matrices = [[0.1]] Simulation_time = 2222 - self.assertRaises(ValueError, ciw.Simulation, {'Arrival_distributions':Arrival_distributions_E, 'Service_distributions':Service_distributions, 'Number_of_servers':Number_of_servers, 'Transition_matrices':Transition_matrices, 'Simulation_time':Simulation_time, 'my_custom_dist':my_custom_dist, 'my_custom_dist_E':my_custom_dist_E, 'my_custom_dist_EE':my_custom_dist_EE}) - self.assertRaises(ValueError, ciw.Simulation, {'Arrival_distributions':Arrival_distributions_EE, 'Service_distributions':Service_distributions, 'Number_of_servers':Number_of_servers, 'Transition_matrices':Transition_matrices, 'Simulation_time':Simulation_time, 'my_custom_dist':my_custom_dist, 'my_custom_dist_E':my_custom_dist_E, 'my_custom_dist_EE':my_custom_dist_EE}) - self.assertRaises(ValueError, ciw.Simulation, {'Arrival_distributions':Arrival_distributions, 'Service_distributions':Service_distributions_E, 'Number_of_servers':Number_of_servers, 'Transition_matrices':Transition_matrices, 'Simulation_time':Simulation_time, 'my_custom_dist':my_custom_dist, 'my_custom_dist_E':my_custom_dist_E, 'my_custom_dist_EE':my_custom_dist_EE}) - self.assertRaises(ValueError, ciw.Simulation, {'Arrival_distributions':Arrival_distributions, 'Service_distributions':Service_distributions_EE, 'Number_of_servers':Number_of_servers, 'Transition_matrices':Transition_matrices, 'Simulation_time':Simulation_time, 'my_custom_dist':my_custom_dist, 'my_custom_dist_E':my_custom_dist_E, 'my_custom_dist_EE':my_custom_dist_EE}) + self.assertRaises(ValueError, ciw.Simulation, + {'Arrival_distributions':Arrival_distributions_E, + 'Service_distributions':Service_distributions, + 'Number_of_servers':Number_of_servers, + 'Transition_matrices':Transition_matrices, + 'Simulation_time':Simulation_time, + 'my_custom_dist':my_custom_dist, + 'my_custom_dist_E':my_custom_dist_E, + 'my_custom_dist_EE':my_custom_dist_EE}) + self.assertRaises(ValueError, ciw.Simulation, + {'Arrival_distributions':Arrival_distributions_EE, + 'Service_distributions':Service_distributions, + 'Number_of_servers':Number_of_servers, + 'Transition_matrices':Transition_matrices, + 'Simulation_time':Simulation_time, + 'my_custom_dist':my_custom_dist, + 'my_custom_dist_E':my_custom_dist_E, + 'my_custom_dist_EE':my_custom_dist_EE}) + self.assertRaises(ValueError, ciw.Simulation, + {'Arrival_distributions':Arrival_distributions, + 'Service_distributions':Service_distributions_E, + 'Number_of_servers':Number_of_servers, + 'Transition_matrices':Transition_matrices, + 'Simulation_time':Simulation_time, + 'my_custom_dist':my_custom_dist, + 'my_custom_dist_E':my_custom_dist_E, + 'my_custom_dist_EE':my_custom_dist_EE}) + self.assertRaises(ValueError, ciw.Simulation, + {'Arrival_distributions':Arrival_distributions, + 'Service_distributions':Service_distributions_EE, + 'Number_of_servers':Number_of_servers, + 'Transition_matrices':Transition_matrices, + 'Simulation_time':Simulation_time, + 'my_custom_dist':my_custom_dist, + 'my_custom_dist_E':my_custom_dist_E, + 'my_custom_dist_EE':my_custom_dist_EE}) def test_sampling_function_dist(self): - Arrival_distributions = [['UserDefined', lambda : random()], ['UserDefined', lambda : custom_function()]] - Service_distributions = [['UserDefined', lambda : random()], ['UserDefined', lambda : custom_function()]] + Arrival_distributions = [['UserDefined', lambda : random()], + ['UserDefined', lambda : custom_function()]] + Service_distributions = [['UserDefined', lambda : random()], + ['UserDefined', lambda : custom_function()]] Number_of_servers = [1, 1] Transition_matrices = [[0.1, 0.1], [0.1, 0.1]] @@ -502,35 +703,57 @@ def test_sampling_function_dist(self): N1 = Q.transitive_nodes[0] N2 = Q.transitive_nodes[1] set_seed(5) - self.assertEqual(round(N1.simulation.service_times[N1.id_number][0](), 2), 0.62) - self.assertEqual(round(N1.simulation.service_times[N1.id_number][0](), 2), 0.74) - self.assertEqual(round(N1.simulation.service_times[N1.id_number][0](), 2), 0.80) - self.assertEqual(round(N1.simulation.service_times[N1.id_number][0](), 2), 0.94) - self.assertEqual(round(N1.simulation.service_times[N1.id_number][0](), 2), 0.74) - self.assertEqual(round(N2.simulation.service_times[N2.id_number][0](), 2), 0.46) - self.assertEqual(round(N2.simulation.service_times[N2.id_number][0](), 2), 0.06) - self.assertEqual(round(N2.simulation.service_times[N2.id_number][0](), 2), 0.93) - self.assertEqual(round(N2.simulation.service_times[N2.id_number][0](), 2), 0.47) - self.assertEqual(round(N2.simulation.service_times[N2.id_number][0](), 2), 1.30) - - self.assertEqual(round(N1.simulation.inter_arrival_times[N1.id_number][0](), 2), 0.90) - self.assertEqual(round(N1.simulation.inter_arrival_times[N1.id_number][0](), 2), 0.11) - self.assertEqual(round(N1.simulation.inter_arrival_times[N1.id_number][0](), 2), 0.47) - self.assertEqual(round(N1.simulation.inter_arrival_times[N1.id_number][0](), 2), 0.25) - self.assertEqual(round(N1.simulation.inter_arrival_times[N1.id_number][0](), 2), 0.54) - self.assertEqual(round(N2.simulation.inter_arrival_times[N2.id_number][0](), 2), 0.29) - self.assertEqual(round(N2.simulation.inter_arrival_times[N2.id_number][0](), 2), 0.03) - self.assertEqual(round(N2.simulation.inter_arrival_times[N2.id_number][0](), 2), 0.43) - self.assertEqual(round(N2.simulation.inter_arrival_times[N2.id_number][0](), 2), 0.56) - self.assertEqual(round(N2.simulation.inter_arrival_times[N2.id_number][0](), 2), 0.46) + self.assertEqual(round( + N1.simulation.service_times[N1.id_number][0](), 2), 0.62) + self.assertEqual(round( + N1.simulation.service_times[N1.id_number][0](), 2), 0.74) + self.assertEqual(round( + N1.simulation.service_times[N1.id_number][0](), 2), 0.80) + self.assertEqual(round( + N1.simulation.service_times[N1.id_number][0](), 2), 0.94) + self.assertEqual(round( + N1.simulation.service_times[N1.id_number][0](), 2), 0.74) + self.assertEqual(round( + N2.simulation.service_times[N2.id_number][0](), 2), 0.46) + self.assertEqual(round( + N2.simulation.service_times[N2.id_number][0](), 2), 0.06) + self.assertEqual(round( + N2.simulation.service_times[N2.id_number][0](), 2), 0.93) + self.assertEqual(round( + N2.simulation.service_times[N2.id_number][0](), 2), 0.47) + self.assertEqual(round( + N2.simulation.service_times[N2.id_number][0](), 2), 1.30) + + self.assertEqual(round( + N1.simulation.inter_arrival_times[N1.id_number][0](), 2), 0.90) + self.assertEqual(round( + N1.simulation.inter_arrival_times[N1.id_number][0](), 2), 0.11) + self.assertEqual(round( + N1.simulation.inter_arrival_times[N1.id_number][0](), 2), 0.47) + self.assertEqual(round( + N1.simulation.inter_arrival_times[N1.id_number][0](), 2), 0.25) + self.assertEqual(round( + N1.simulation.inter_arrival_times[N1.id_number][0](), 2), 0.54) + self.assertEqual(round( + N2.simulation.inter_arrival_times[N2.id_number][0](), 2), 0.29) + self.assertEqual(round( + N2.simulation.inter_arrival_times[N2.id_number][0](), 2), 0.03) + self.assertEqual(round( + N2.simulation.inter_arrival_times[N2.id_number][0](), 2), 0.43) + self.assertEqual(round( + N2.simulation.inter_arrival_times[N2.id_number][0](), 2), 0.56) + self.assertEqual(round( + N2.simulation.inter_arrival_times[N2.id_number][0](), 2), 0.46) @given(const=floats(min_value = 0.02, max_value=200), dist=lists(floats(min_value=0.001, max_value=10000), min_size=1, max_size=20), rm=random_module()) def test_sampling_function_dist_hypothesis(self, const, dist, rm): my_empirical_dist = [8.0, 8.0, 8.0, 8.8, 8.8, 12.3] - Arrival_distributions = [['UserDefined', lambda : choice(my_empirical_dist)], ['UserDefined', lambda : const]] - Service_distributions = [['UserDefined', lambda : random()], ['UserDefined', lambda : custom_function()]] + Arrival_distributions = [['UserDefined', lambda : choice(my_empirical_dist)], + ['UserDefined', lambda : const]] + Service_distributions = [['UserDefined', lambda : random()], + ['UserDefined', lambda : custom_function()]] Number_of_servers = [1, 1] Transition_matrices = [[0.1, 0.1], [0.1, 0.1]] @@ -543,8 +766,9 @@ def test_sampling_function_dist_hypothesis(self, const, dist, rm): N1 = Q.transitive_nodes[0] N2 = Q.transitive_nodes[1] set_seed(5) - for itr in range(10): # Because repition happens in the simulation - self.assertTrue(N1.simulation.inter_arrival_times[N1.id_number][0]() in set(my_empirical_dist)) + for itr in xrange(10): # Because repition happens in the simulation + self.assertTrue(N1.simulation.inter_arrival_times[N1.id_number][0]() + in set(my_empirical_dist)) self.assertTrue(N2.simulation.inter_arrival_times[N2.id_number][0]() == const) self.assertTrue(0.0 <= N1.simulation.service_times[N1.id_number][0]() <= 1.0) self.assertTrue(0.0 <= N2.simulation.service_times[N2.id_number][0]() <= 2.0) @@ -579,17 +803,13 @@ def test_error_dist(self): self.assertRaises(ValueError, ciw.Simulation, params) @given(positive_float=floats(min_value=0.0, max_value=100.0), - positive_int=integers(min_value=0, max_value=100), - negative_int=integers(min_value=-100, max_value=-1), negative_float=floats(min_value=-100.0, max_value=0.0), word=text(), rm=random_module()) - def test_sample_from_user_defined_dist(self, positive_float, positive_int, negative_float, negative_int, word, rm): + def test_check_userdef_dist(self, positive_float, negative_float, word, rm): assume(negative_float < 0) Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) - self.assertEqual(Q.sample_from_user_defined_dist(lambda : positive_int), positive_int) - self.assertEqual(Q.sample_from_user_defined_dist(lambda : positive_float), positive_float) - self.assertRaises(ValueError, Q.sample_from_user_defined_dist, lambda : negative_int) - self.assertRaises(ValueError, Q.sample_from_user_defined_dist, lambda : negative_float) - self.assertRaises(TypeError, Q.sample_from_user_defined_dist, lambda : word) + self.assertEqual(Q.check_userdef_dist(lambda : positive_float), positive_float) + self.assertRaises(ValueError, Q.check_userdef_dist, lambda : negative_float) + self.assertRaises(ValueError, Q.check_userdef_dist, lambda : word) diff --git a/ciw/tests/test_server.py b/ciw/tests/test_server.py index 39d991be..ade52b5a 100644 --- a/ciw/tests/test_server.py +++ b/ciw/tests/test_server.py @@ -6,7 +6,8 @@ class TestServer(unittest.TestCase): def test_init_method(self): - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) N = Q.transitive_nodes[1] s = ciw.Server(N, 3) self.assertEqual(s.id_number, 3) @@ -17,7 +18,8 @@ def test_init_method(self): self.assertEqual(s.offduty, False) def test_repr_method(self): - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) N = Q.transitive_nodes[0] s = ciw.Server(N, 4) self.assertEqual(str(s), 'Server 4 at Node 1') \ No newline at end of file diff --git a/ciw/tests/test_simulation.py b/ciw/tests/test_simulation.py index dae8e3b7..e6732277 100644 --- a/ciw/tests/test_simulation.py +++ b/ciw/tests/test_simulation.py @@ -15,7 +15,8 @@ def set_seed(x): class TestSimulation(unittest.TestCase): def test_init_method_from_dict(self): - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) self.assertEqual(Q.lmbda, [[['Exponential', 3.0], ['Exponential', 7.0], ['Exponential', 4.0], @@ -53,18 +54,28 @@ def test_init_method_from_dict(self): [0.1, 0.1, 0.1, 0.1], [0.1, 0.3, 0.2, 0.2], [0.0, 0.0, 0.0, 0.3]]]) - self.assertEqual([str(obs) for obs in Q.nodes], ['Arrival Node', 'Node 1', 'Node 2', 'Node 3', 'Node 4', 'Exit Node']) + self.assertEqual([str(obs) for obs in Q.nodes], + ['Arrival Node', + 'Node 1', + 'Node 2', + 'Node 3', + 'Node 4', + 'Exit Node']) self.assertEqual(Q.max_simulation_time, 2500) self.assertEqual(Q.class_change_matrix, 'NA') self.assertEqual(Q.schedules, [False, False, False, False]) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_dynamic_classes/parameters.yml')) + self.assertEqual(Q.class_change_matrix, + [[[0.5, 0.5], [0.5, 0.5]], + [[1.0, 0.0], [0.0, 1.0]]]) - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_dynamic_classes/parameters.yml')) - self.assertEqual(Q.class_change_matrix, [[[0.5, 0.5], [0.5, 0.5]], [[1.0, 0.0], [0.0, 1.0]]]) - - - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_server_schedule/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_server_schedule/parameters.yml')) self.assertEqual(Q.schedules, [True, False]) + self.assertEqual(str(Q), 'Ciw Simulation') + def test_init_method_from_kws(self): # Define parameters @@ -106,7 +117,7 @@ def test_init_method_from_kws(self): [0.1, 0.1, 0.1, 0.1], [0.1, 0.3, 0.2, 0.2], [0.0, 0.0, 0.0, 0.3]]} - detect_deadlock = False + Detect_deadlock = False Simulation_time = 2500 Number_of_classes = 3 Number_of_nodes = 4 @@ -126,8 +137,6 @@ def test_init_method_from_kws(self): cycle_length=100 Queue_capacities = [20, 'Inf', 30, 'Inf'] - - # The tests Q = ciw.Simulation(Arrival_distributions=Arrival_distributions, Simulation_time=Simulation_time, Queue_capacities=Queue_capacities, @@ -136,7 +145,7 @@ def test_init_method_from_kws(self): Transition_matrices=Transition_matrices, Number_of_classes=Number_of_classes, Number_of_nodes=Number_of_nodes, - detect_deadlock=detect_deadlock) + Detect_deadlock=Detect_deadlock) self.assertEqual(Q.lmbda, [[['Exponential', 3.0], ['Exponential', 7.0], ['Exponential', 4.0], @@ -174,11 +183,18 @@ def test_init_method_from_kws(self): [0.1, 0.1, 0.1, 0.1], [0.1, 0.3, 0.2, 0.2], [0.0, 0.0, 0.0, 0.3]]]) - self.assertEqual([str(obs) for obs in Q.nodes], ['Arrival Node', 'Node 1', 'Node 2', 'Node 3', 'Node 4', 'Exit Node']) + self.assertEqual([str(obs) for obs in Q.nodes], + ['Arrival Node', + 'Node 1', + 'Node 2', + 'Node 3', + 'Node 4', + 'Exit Node']) self.assertEqual(Q.max_simulation_time, 2500) self.assertEqual(Q.class_change_matrix, 'NA') self.assertEqual(Q.schedules, [False, False, False, False]) self.assertEqual(Q.queue_capacities, [20, 'Inf', 30, 'Inf']) + self.assertEqual(str(Q), 'Ciw Simulation') Q = ciw.Simulation(Arrival_distributions=Arrival_distributions, Simulation_time=Simulation_time, @@ -222,11 +238,18 @@ def test_init_method_from_kws(self): [0.1, 0.1, 0.1, 0.1], [0.1, 0.3, 0.2, 0.2], [0.0, 0.0, 0.0, 0.3]]]) - self.assertEqual([str(obs) for obs in Q.nodes], ['Arrival Node', 'Node 1', 'Node 2', 'Node 3', 'Node 4', 'Exit Node']) + self.assertEqual([str(obs) for obs in Q.nodes], + ['Arrival Node', + 'Node 1', + 'Node 2', + 'Node 3', + 'Node 4', + 'Exit Node']) self.assertEqual(Q.max_simulation_time, 2500) self.assertEqual(Q.class_change_matrix, 'NA') self.assertEqual(Q.schedules, [False, False, False, False]) self.assertEqual(Q.queue_capacities, ['Inf', 'Inf', 'Inf', 'Inf']) + self.assertEqual(str(Q), 'Ciw Simulation') Q = ciw.Simulation(Arrival_distributions=Arrival_distributions, Simulation_time=Simulation_time, @@ -236,7 +259,7 @@ def test_init_method_from_kws(self): Transition_matrices=Transition_matrices, Number_of_classes=Number_of_classes, Number_of_nodes=Number_of_nodes, - detect_deadlock=detect_deadlock, + Detect_deadlock=Detect_deadlock, Class_change_matrices=Class_change_matrices) self.assertEqual(Q.class_change_matrix, [[[0.7, 0.3, 0.0], [0.2, 0.7, 0.1], @@ -246,7 +269,7 @@ def test_init_method_from_kws(self): [0.0, 0.0, 1.0]], [[0.7, 0.3, 0.0], [0.2, 0.7, 0.1], - [0.2, 0.7,0.1]], + [0.2, 0.7, 0.1]], [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]]]) @@ -259,11 +282,12 @@ def test_init_method_from_kws(self): Transition_matrices=Transition_matrices, Number_of_classes=Number_of_classes, Number_of_nodes=Number_of_nodes, - detect_deadlock=detect_deadlock, + Detect_deadlock=Detect_deadlock, Class_change_matrices=Class_change_matrices, schedule_1=schedule_1, cycle_length=cycle_length) self.assertEqual(Q.schedules, [False, False, True, False]) + self.assertEqual(str(Q), 'Ciw Simulation') Q = ciw.Simulation(Arrival_distributions = {'Class 2': [['Exponential', 2.0], ['Exponential', 1.0], @@ -278,7 +302,7 @@ def test_init_method_from_kws(self): ['Exponential', 4.0], ['Exponential', 1.0]]}, Number_of_nodes = 4, - detect_deadlock = False, + Detect_deadlock = False, Simulation_time = 2500, Number_of_servers = [9, 10, 8, 8], Queue_capacities = [20, 'Inf', 30, 'Inf'], @@ -321,7 +345,7 @@ def test_init_method_from_kws(self): ['Exponential', 1.0]]}, 'Number_of_nodes': 4, 'Simulation_time': 2500, - 'detect_deadlock': False, + 'Detect_deadlock': False, 'Number_of_servers': [9, 10, 8, 8], 'Queue_capacities': [20, 'Inf', 30, 'Inf'], 'Number_of_classes': 3, @@ -355,7 +379,12 @@ def test_init_method_from_kws(self): number_of_servers=integers(min_value=1, max_value=30), Simulation_time=floats(min_value=1.0, max_value=10.0), rm=random_module()) - def test_simple_init_method(self, arrival_rate, service_rate, number_of_servers, Simulation_time, rm): + def test_simple_init_method(self, + arrival_rate, + service_rate, + number_of_servers, + Simulation_time, + rm): """ Test for creating M/M/c queues """ @@ -376,14 +405,15 @@ def test_simple_init_method(self, arrival_rate, service_rate, number_of_servers, 'Number_of_classes': 1, 'Queue_capacities': ['Inf'], 'Simulation_time': Simulation_time, - 'detect_deadlock': False + 'Detect_deadlock': False } self.assertEqual(Q.parameters, expected_dictionary) self.assertEqual(Q.lmbda, [[['Exponential', arrival_rate]]]) self.assertEqual(Q.mu, [[['Exponential', service_rate]]]) self.assertEqual(Q.c, [number_of_servers]) self.assertEqual(Q.transition_matrix, [[[0.0]]]) - self.assertEqual([str(obs) for obs in Q.nodes], ['Arrival Node', 'Node 1', 'Exit Node']) + self.assertEqual([str(obs) for obs in Q.nodes], + ['Arrival Node', 'Node 1', 'Exit Node']) self.assertEqual(Q.max_simulation_time, Simulation_time) self.assertEqual(Q.class_change_matrix, 'NA') self.assertEqual(Q.schedules, [False]) @@ -393,15 +423,18 @@ def test_simple_init_method(self, arrival_rate, service_rate, number_of_servers, number_of_servers=integers(min_value=1, max_value=30), Simulation_time=floats(min_value=1.0, max_value=10.0), rm=random_module()) - def test_build_mmc_parameters(self, arrival_rate, service_rate, number_of_servers, Simulation_time, rm): + def test_build_mmc_parameters(self, + arrival_rate, + service_rate, + number_of_servers, + Simulation_time, + rm): params = {'Arrival_distributions':[['Exponential', arrival_rate]], 'Service_distributions':[['Exponential', service_rate]], 'Number_of_servers':[number_of_servers], 'Simulation_time':Simulation_time, 'Transition_matrices':[[0.0]]} - Q = ciw.Simulation(params) - expected_dictionary = { 'Arrival_distributions': {'Class 0': [['Exponential', arrival_rate]]}, 'Service_distributions': {'Class 0': [['Exponential', service_rate]]}, @@ -411,19 +444,21 @@ def test_build_mmc_parameters(self, arrival_rate, service_rate, number_of_server 'Number_of_classes': 1, 'Queue_capacities': ['Inf'], 'Simulation_time': Simulation_time, - 'detect_deadlock': False + 'Detect_deadlock': False } self.assertEqual(Q.build_parameters(params), expected_dictionary) def test_find_next_active_node_method(self): - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) i = 0 for node in Q.nodes[:-1]: node.next_event_date = i i += 1 self.assertEqual(str(Q.find_next_active_node()), 'Arrival Node') - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) i = 10 for node in Q.nodes[:-1]: node.next_event_date = i @@ -432,14 +467,17 @@ def test_find_next_active_node_method(self): def test_simulate_until_max_time_method(self): set_seed(2) - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) Q.max_simulation_time = 600 Q.simulate_until_max_time() L = Q.get_all_individuals() - self.assertEqual(round(L[300].data_records.values()[0][0].service_start_date, 8), 8.93542607) + self.assertEqual(round( + L[300].data_records.values()[0][0].service_start_date, 8), 8.93542607) set_seed(60) - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_dynamic_classes/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_dynamic_classes/parameters.yml')) Q.simulate_until_max_time() L = Q.get_all_individuals() drl = [] @@ -449,12 +487,14 @@ def test_simulate_until_max_time_method(self): def test_simulate_until_deadlock_method(self): set_seed(3) - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_deadlock_sim/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_deadlock_sim/parameters.yml')) times = Q.simulate_until_deadlock() self.assertEqual(round(times[((0, 0), (0, 0))], 8), 31.26985409) def test_detect_deadlock_method(self): - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) nodes = ['A', 'B', 'C', 'D', 'E'] connections = [('A', 'D'), ('A', 'B'), ('B', 'E'), ('C', 'B'), ('E', 'C')] for nd in nodes: @@ -463,7 +503,8 @@ def test_detect_deadlock_method(self): Q.digraph.add_edge(cnctn[0], cnctn[1]) self.assertEqual(Q.detect_deadlock(), True) - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) nodes = ['A', 'B', 'C', 'D'] connections = [('A', 'B'), ('A', 'C'), ('B', 'C'), ('B', 'D')] for nd in nodes: @@ -472,7 +513,8 @@ def test_detect_deadlock_method(self): Q.digraph.add_edge(cnctn[0], cnctn[1]) self.assertEqual(Q.detect_deadlock(), False) - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) nodes = ['A', 'B'] for nd in nodes: Q.digraph.add_node(nd) @@ -483,7 +525,8 @@ def test_detect_deadlock_method(self): self.assertEqual(Q.detect_deadlock(), True) def test_mm1_from_file(self): - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_mm1/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_mm1/parameters.yml')) self.assertEqual(Q.transition_matrix, [[[0.0]]]) @given(arrival_rate=floats(min_value=0.1, max_value=100), @@ -512,8 +555,7 @@ def test_raising_errors(self): 'Simulation_time': 400, 'Number_of_nodes': 1, 'Queue_capacities': ['Inf'], - 'detect_deadlock': False} - + 'Detect_deadlock': False} params_list = [copy.deepcopy(params) for i in range(27)] params_list[0]['Number_of_classes'] = -2 @@ -526,25 +568,30 @@ def test_raising_errors(self): self.assertRaises(ValueError, ciw.Simulation, params_list[3]) params_list[4]['Number_of_servers'] = ['my_missing_schedule'] self.assertRaises(ValueError, ciw.Simulation, params_list[4]) - params_list[5]['detect_deadlock'] = 'No' + params_list[5]['Detect_deadlock'] = 'No' self.assertRaises(ValueError, ciw.Simulation, params_list[5]) params_list[6]['Queue_capacities'] = ['Inf', 1, 2] self.assertRaises(ValueError, ciw.Simulation, params_list[6]) params_list[7]['Queue_capacities'] = [-2] self.assertRaises(ValueError, ciw.Simulation, params_list[7]) - params_list[8]['Arrival_distributions'] = {'Class 0':[['Exponential', 3.2]], 'Class 1':[['Exponential', 2.1]]} + params_list[8]['Arrival_distributions'] = {'Class 0':[['Exponential', 3.2]], + 'Class 1':[['Exponential', 2.1]]} self.assertRaises(ValueError, ciw.Simulation, params_list[8]) params_list[9]['Arrival_distributions'] = {'Patient 0':[['Exponential', 11.5]]} self.assertRaises(ValueError, ciw.Simulation, params_list[9]) - params_list[10]['Arrival_distributions']['Class 0'] = [['Exponential', 3.1], ['Exponential', 2.4]] + params_list[10]['Arrival_distributions']['Class 0'] = [['Exponential', 3.1], + ['Exponential', 2.4]] self.assertRaises(ValueError, ciw.Simulation, params_list[10]) - params_list[11]['Service_distributions'] = {'Class 0':[['Exponential', 3.2]], 'Class 1':[['Exponential', 2.1]]} + params_list[11]['Service_distributions'] = {'Class 0':[['Exponential', 3.2]], + 'Class 1':[['Exponential', 2.1]]} self.assertRaises(ValueError, ciw.Simulation, params_list[11]) params_list[12]['Service_distributions'] = {'Patient 0':[['Exponential', 11.5]]} self.assertRaises(ValueError, ciw.Simulation, params_list[12]) - params_list[13]['Service_distributions']['Class 0'] = [['Exponential', 3.1], ['Exponential', 2.4]] + params_list[13]['Service_distributions']['Class 0'] = [['Exponential', 3.1], + ['Exponential', 2.4]] self.assertRaises(ValueError, ciw.Simulation, params_list[13]) - params_list[14]['Transition_matrices'] = {'Class 0':[[0.2]], 'Class 1':[[0.3]]} + params_list[14]['Transition_matrices'] = {'Class 0':[[0.2]], + 'Class 1':[[0.3]]} self.assertRaises(ValueError, ciw.Simulation, params_list[14]) params_list[15]['Transition_matrices'] = {'Patient 0':[[0.5]]} self.assertRaises(ValueError, ciw.Simulation, params_list[15]) @@ -558,7 +605,8 @@ def test_raising_errors(self): self.assertRaises(ValueError, ciw.Simulation, params_list[19]) params_list[20]['Simulation_time'] = -2000 self.assertRaises(ValueError, ciw.Simulation, params_list[20]) - params_list[21]['Class_change_matrices'] = {'Node 0':[[0.0]], 'Node 1':[[0.0]]} + params_list[21]['Class_change_matrices'] = {'Node 0':[[0.0]], + 'Node 1':[[0.0]]} self.assertRaises(ValueError, ciw.Simulation, params_list[21]) params_list[22]['Class_change_matrices'] = {'Patient 0':[[0.0]]} self.assertRaises(ValueError, ciw.Simulation, params_list[22]) @@ -572,23 +620,31 @@ def test_raising_errors(self): self.assertRaises(ValueError, ciw.Simulation, params_list[26]) def test_writing_data_files(self): - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_simulation/parameters.yml')) Q.max_simulation_time = 500 Q.simulate_until_max_time() - files = [x for x in os.walk('ciw/tests/datafortesting/logs_test_for_simulation/')][0][2] + files = [x for x in os.walk( + 'ciw/tests/datafortesting/logs_test_for_simulation/')][0][2] self.assertEqual('data.csv' in files, False) - Q.write_records_to_file('ciw/tests/datafortesting/logs_test_for_simulation/data.csv') - files = [x for x in os.walk('ciw/tests/datafortesting/logs_test_for_simulation/')][0][2] + Q.write_records_to_file( + 'ciw/tests/datafortesting/logs_test_for_simulation/data.csv') + files = [x for x in os.walk( + 'ciw/tests/datafortesting/logs_test_for_simulation/')][0][2] self.assertEqual('data.csv' in files, True) os.remove('ciw/tests/datafortesting/logs_test_for_simulation/data.csv') - Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_mm1/parameters.yml')) + Q = ciw.Simulation(ciw.load_parameters( + 'ciw/tests/datafortesting/logs_test_for_mm1/parameters.yml')) Q.max_simulation_time = 500 Q.simulate_until_max_time() - files = [x for x in os.walk('ciw/tests/datafortesting/logs_test_for_mm1/')][0][2] + files = [x for x in os.walk( + 'ciw/tests/datafortesting/logs_test_for_mm1/')][0][2] self.assertEqual('data_1.csv' in files, False) - Q.write_records_to_file('ciw/tests/datafortesting/logs_test_for_mm1/data_1.csv', False) - files = [x for x in os.walk('ciw/tests/datafortesting/logs_test_for_mm1/')][0][2] + Q.write_records_to_file( + 'ciw/tests/datafortesting/logs_test_for_mm1/data_1.csv', False) + files = [x for x in os.walk( + 'ciw/tests/datafortesting/logs_test_for_mm1/')][0][2] self.assertEqual('data_1.csv' in files, True) os.remove('ciw/tests/datafortesting/logs_test_for_mm1/data_1.csv') diff --git a/docs/Basics/getting_started.rst b/docs/Basics/getting_started.rst index 9ceb1581..3f6e177c 100644 --- a/docs/Basics/getting_started.rst +++ b/docs/Basics/getting_started.rst @@ -31,7 +31,7 @@ We wish to simulate this system for 1000 time units. This system is defined by t >>> params = { ... 'Arrival_distributions': {'Class 0': [['Exponential', 6.0], ['Exponential', 2.5]]}, ... 'Number_of_nodes': 2, - ... 'detect_deadlock': False, + ... 'Detect_deadlock': False, ... 'Simulation_time': 1000, ... 'Number_of_servers': [1, 1], ... 'Queue_capacities': ['Inf', 4], diff --git a/docs/Basics/parameters.rst b/docs/Basics/parameters.rst index 6e59f06a..ec22265f 100644 --- a/docs/Basics/parameters.rst +++ b/docs/Basics/parameters.rst @@ -23,7 +23,7 @@ A full example of the parameters file for a three node network with two classes - 1.8 - - Exponential - 7.25 - detect_deadlock: False + Detect_deadlock: False Number_of_classes: 2 Number_of_nodes: 3 Number_of_servers: diff --git a/docs/Basics/parameters_dict.rst b/docs/Basics/parameters_dict.rst index 591f66d6..1e777005 100644 --- a/docs/Basics/parameters_dict.rst +++ b/docs/Basics/parameters_dict.rst @@ -29,7 +29,7 @@ A full example of the parameters dictionary for a three node network with two cl >>> params = {'Arrival_distributions': {'Class 1': [['Exponential', 1.0], ['Exponential', 1.8], ['Exponential', 7.25]], ... 'Class 0': [['Exponential', 6.0], ['Exponential', 4.5], ['Exponential', 2.0]]}, ... 'Number_of_nodes': 3, - ... 'detect_deadlock': False, + ... 'Detect_deadlock': False, ... 'Simulation_time': 2500, ... 'Number_of_servers': [2, 1, 1], ... 'Queue_capacities': ['Inf', 'Inf', 10], diff --git a/docs/Features/deadlock.rst b/docs/Features/deadlock.rst index 3c70bdd5..4e41bbd4 100644 --- a/docs/Features/deadlock.rst +++ b/docs/Features/deadlock.rst @@ -8,7 +8,7 @@ Ciw's has built in deadlock detection capability. With Ciw, a queueing network c In order to take advantage of this feature, set deadlock detection option to True in the parameters file:: - detect_deadlock: True + Detect_deadlock: True Then use the :code:`simulate_until_deadlock` method to return the times to deadlock from each state:: @@ -30,7 +30,7 @@ Parameters:: >>> params = {'Arrival_distributions': {'Class 0': [['Exponential', 6.0]]}, ... 'Number_of_nodes': 1, - ... 'detect_deadlock': True, + ... 'Detect_deadlock': True, ... 'Simulation_time': 2500, ... 'Number_of_servers': [1], ... 'Queue_capacities': [3],