Add GreedySearch algorithm

Add is_order_ascending check as parameter in repair schedule

prrt/hec_search.py

@@ -19,6 +19,7 @@ class HECFullSearch(AbstractSearch):
         self.prrtChannelParameters = prrtChannelParameters
         self.prrtSystemParameters = prrtSystemParameters
         self.p_t = self.prrtApplicationParameters.max_residual_loss_rate
+        self.is_order_ascending = False
         pass
 
     def search(self):
@@ -45,7 +46,7 @@ class HECFullSearch(AbstractSearch):
             k_max = min(self.get_k(n_c, req_delay), self.get_k_lim(1, self.n_max))
             for k in range(1, k_max + 1):
                 n = self.estimate_n_for_k(k)
-                repair_schedules = ric.gen_repair_schedule(n - k, n_c, 1, self.n_p_max)
+                repair_schedules = ric.gen_repair_schedule(n - k, n_c, 1, self.n_p_max, self.is_order_ascending)
                 for repair_schedule in repair_schedules:
                     coding_conf = prrt.PrrtCodingConfiguration(n, k, repair_schedule)
                     ri = coding_conf.get_redundant_information(self.prrtChannelParameters)
@@ -101,22 +102,93 @@ class HECFullSearch(AbstractSearch):
         return residual_packet_erasure_rate
 
 
-# Restricted Integer combinations
-"""
-def partitionfunc(n, k, smallest=1):
-    '''n is the integer to partition, k is the length of partitions, smallest is the min partition element size'''
-    if k < 1:
-        raise StopIteration
-    if k == 1:
-        if n >= smallest:
-            yield (n,)
-        raise StopIteration
-    for i in range(smallest, n + 1):
-        for result in partitionfunc(n - i, k - 1, i):
-            yield (i,) + result
-
-
-generator = partitionfunc(3, 1, )
-for i in generator:
-    print(i)
-"""
\ No newline at end of file
+class HECGreedySearch(AbstractSearch):
+    def __init__(self, n_p_max, prrtApplicationParameters, prrtChannelParameters, prrtSystemParameters):
+        self.n_max = 255
+        self.step_size = 2 # Step size in the estimation of the optimum code word length
+        self.n_p_max = n_p_max
+        self.prrtApplicationParameters = prrtApplicationParameters
+        self.prrtChannelParameters = prrtChannelParameters
+        self.prrtSystemParameters = prrtSystemParameters
+        self.p_t = self.prrtApplicationParameters.max_residual_loss_rate
+        self.is_order_ascending = True
+        pass
+
+    def search(self):
+        ri_opt = math.inf
+        k_opt = 0
+        n_opt = 0
+        n_p_opt = []
+        # Eq.5.9, page 125
+        fec_delay_min = self.prrtSystemParameters.source_packet_interval + \
+                        self.n_p_max * self.prrtSystemParameters.redundancy_packet_transmission_delay + \
+                        (self.prrtChannelParameters.rtt_prop_fwd + self.prrtSystemParameters.processing_delay) / 2 + \
+                        self.prrtSystemParameters.packet_loss_detection_delay
+        # Eq.5.9 page 125 assumung D_sup = 0
+        req_delay = self.prrtChannelParameters.rtt_prop_fwd + \
+                    self.n_p_max * self.prrtSystemParameters.redundancy_packet_transmission_delay + \
+                    self.prrtSystemParameters.processing_delay
+        # Eq.5.10, page 125
+        n_c_max = math.ceil((self.prrtApplicationParameters.max_latency - fec_delay_min) / req_delay)
+        # self.k_lim = somewhat(prrtApplicationParameters.loss_tolerance, self.n_max)
+
+        # n_c = 0 is the proactive packet
+        for n_c in range(n_c_max):
+            # Eq.5.11, k(Nc, D_T), page 125
+            k_max = min(self.get_k(n_c, req_delay), self.get_k_lim(1, self.n_max))
+            for k in [1, k_max]:
+                n = self.estimate_n_for_k(k)
+                repair_schedules = ric.gen_repair_schedule(n - k, n_c, 1, self.n_p_max, self.is_order_ascending)
+                for repair_schedule in repair_schedules:
+                    coding_conf = prrt.PrrtCodingConfiguration(n, k, repair_schedule)
+                    ri = coding_conf.get_redundant_information(self.prrtChannelParameters)
+                    if ri < ri_opt:
+                        k_opt = k
+                        n_opt = n
+                        n_p_opt = repair_schedule
+        return prrt.PrrtCodingConfiguration(n_opt, k_opt, n_p_opt)
+
+    def get_k(self, n_c, req_delay):
+        return math.ceil((self.prrtApplicationParameters.max_latency -
+                   self.n_p_max * self.prrtSystemParameters.redundancy_packet_transmission_delay -
+                   (self.prrtChannelParameters.rtt_prop_fwd + self.prrtSystemParameters.processing_delay) / 2 -
+                   self.prrtSystemParameters.packet_loss_detection_delay -
+                   n_c * req_delay) / self.prrtSystemParameters.source_packet_interval)
+
+    def get_k_lim(self, start, end):
+        mid_point = math.ceil((end - start) / 2)
+        p_r = self.get_max_coding_block_length(mid_point)
+        if p_r == self.p_t:
+            return mid_point
+        elif p_r  > self.p_t:
+            self.get_k_lim(start, mid_point - 1)
+        else:
+            self.get_k_lim(mid_point + 1, end)
+
+    # Pr(k, n_max)
+    def get_max_coding_block_length(self, k):
+        total_packet_erasure = 0
+        for i in range(1, k):
+            for j in range(max(self.n_max - k + 1, i), self.n_max - k + i):
+                packet_erasure_at_i = i * self.hypergeometric_distribution(self.n_max, k, i, j) * self.get_error_prob(
+                    j, self.n_max, self.prrtChannelParameters.loss_rate_fwd)
+                total_packet_erasure += packet_erasure_at_i
+        return (1 / k) * total_packet_erasure
+
+    def estimate_n_for_k(self, k):
+        n = k + 1
+        while self.residual_packet_erasure_rate(k, n, self.prrtApplicationParameters, self.prrtChannelParameters) > self.prrtApplicationParameters.max_residual_loss_rate\
+                and n <= self.n_max - self.step_size:
+
+            print("")
+
+        return 0
+
+    def residual_packet_erasure_rate(self, k, n, prrtApplicationParameters, prrtChannelParameters):
+        total_packet_erasure = 0
+        for i in range(1, k):
+            for j in range(max(n - k + 1, i), n - k + i):
+                packet_erasure_at_i = i * self.hypergeometric_distribution(n, k, i, j) * self.get_error_prob(j, n, prrtChannelParameters.loss_rate_fwd)
+                total_packet_erasure += packet_erasure_at_i
+        residual_packet_erasure_rate = (1 / k) * total_packet_erasure # Pr(k, n)
+        return residual_packet_erasure_rate
\ No newline at end of file

prrt/ric.pyx

@@ -19,15 +19,18 @@ def generate_restricted_integer_compositions(redundancy, positions, min, max):
             if (i <= c_max):
                 yield (i,) + result
 
-def gen_repair_schedule(redundancy, positions, min, max):
-    rawList = []
-    permuted = set()
+# is_order_ascending = False for full search and True for greedy search
+def gen_repair_schedule(redundancy, positions, min, max, is_order_ascending):
+    arbitrary_schedules = []
+    ordered_schedules = set()
 
     f = generate_restricted_integer_compositions(redundancy, positions, min, max)
     for i in f:
-        rawList.add(i)
+        arbitrary_schedules.add(i)
 
-    for i in rawList:
-        permuted.append(itertools.permutations(i))
-
-    return permuted
\ No newline at end of file
+    if not is_order_ascending:
+        for i in arbitrary_schedules:
+            ordered_schedules.append(itertools.permutations(i))
+        return list(ordered_schedules)
+    else:
+        return arbitrary_schedules
\ No newline at end of file