LRPS Algorithm v.1.0.1

arhcoder · arhcoder · commit 61892e1fb332 · 2023-01-20T20:26:26.000-06:00
The word elements was changed in all places to objects, as it is clearer and more descriptive; in addition, it is in accordance with the -in process- article. Also, the color on the plot lines was changed to purple instead of blue :3
diff --git a/Algorithm/experiments.py b/Algorithm/experiments.py
@@ -5,41 +5,41 @@
 #* repeating the selection experiment a lot of times:
 times = int(input("\nRepetitions: "))
 
-#? Example list of 10 elements;
-#* The algorithm has to recieve this list and select randomly one element;
+#? Example list of 10 objects;
+#* The algorithm has to recieve this list and select randomly one object;
 #* By repeating the selection a lot of times, the result has to be that the
-#* first element "E1" is the most frecuent selected, and then "E2", etc.
+#* first object "Obj1" is the most frecuent selected, and then "Obj2", etc.
 #! IF YOU  WANT TO MAKE SOME EXPERIMENTS WITH AN OWN IDEA OF SELECTION LIST
-#! YOU JUST HAVE TO PUT INTO THE LIST "elements" WHATEVER YOU WANT!
-elements: list = ["E1", "E2", "E3", "E4", "E5", "E6", "E7", "E8", "E9", "E10"]
+#! YOU JUST HAVE TO PUT INTO THE LIST "objects" WHATEVER YOU WANT!
+objects: list = ["Obj1", "Obj2", "Obj3", "Obj4", "Obj5", "Obj6", "Obj7", "Obj8", "Obj9", "Obj10"]
 counter = []
-n = len(elements)
+n = len(objects)
 
 #? Fills a counter vector with 0's; it will contains the amount of times that
-#? each element of the list was selected:
+#? each object of the list was selected:
 for i in range(0, n):
     counter.append(0)
 
 #/ Does all the repetitions of the experiment using the logrps function to select
-#/ something on the list; and counts the times that each element was selected.
+#/ something on the list; and counts the times that each object was selected:
 for _ in range(0, times):
-    selected = logrps(elements)
-    index = elements.index(selected)
+    selected = logrps(objects)
+    index = objects.index(selected)
     counter[index] += 1
 
 #? Prints the data from the counter:
-print(f"Elements on list: {n}")
+print(f"Objects on list: {n}")
 print("\nSelected times:")
 for i in range(0, n):
-    print(f"Element #{i+1} [{elements[i]}]: {counter[i]} times selected;")
+    print(f"Object #{i+1} [{objects[i]}]: {counter[i]} times selected;")
 
 
 # Draws the line in a graph:
 plt.rcParams["figure.figsize"] = [10, 5]
 plt.rcParams["figure.autolayout"] = True
 
 # Points with:
-# (element, amountOfSelections ):
+# (object, amountOfSelections ):
 # points: list = []
 x_values: list = []
 y_values: list = []
@@ -53,16 +53,16 @@
 # Shows the graphic:
 plt.title("LOGARITHMIC RANDOM PONDERATED SELECTOR")
 plt.ylabel("Amount of selected times")
-plt.xlabel("Number of element")
-info = f"For {n} elements;\nWith {times} choices;"
+plt.xlabel("Number of object")
+info = f"For {n} objects;\nWith {times} choices;"
 plt.annotate(info,
 xy=(0.96, 0.8), xytext=(0, 12),
 xycoords=("axes fraction", "figure fraction"),
 textcoords="offset points",
 size=10, ha="right", va="top",
-bbox=dict(boxstyle="square,pad=1.0", fc="white", ec="b", lw=2))
+bbox=dict(boxstyle="square,pad=1.0", fc="white", ec="#8B0880", lw=2))
 
-plt.plot(x_values, y_values, "bo", linestyle="-")
+plt.plot(x_values, y_values, "o", c="#8B0880", mfc="#8B0880", linestyle="-")
 plt.savefig("logselection.png", dpi="figure")
 plt.show()
 print()
diff --git a/Algorithm/logrps.py b/Algorithm/logrps.py
@@ -5,39 +5,39 @@
 import random
 import math
 
-def logrps(elements: list):
+def logrps(objects: list):
 
     '''
         Logarithmic Random Poderated Selector:
 
-        This algorithm gets a list of elements, and using
+        This algorithm gets a list of objects, and using
         a logarithmic scale, selects randomly one member
         of the list giving a higher probability weight to
-        the initial elements of the list.
+        the initial objects of the list.
 
         This algorithm selects with more frecuency the
         initial members of the list, based on the
         logarithmic/exponential curve form.
     '''
 
-    #* Amount of elements: "n":
-    n = len(elements)
+    #* Amount of objects: "n":
+    n = len(objects)
 
     #* Validation cases:
     #? When list is empty:
     if n == 0:
         return "List cannot be empty :c"
-    #? When list has only one element:
+    #? When list has only one object:
     if n == 1:
-        return elements[0]
+        return objects[0]
     
-    #* Throws a random float number based on the n elements:
+    #* Throws a random float number based on the n objects:
     #? To operate the numbers, it will consider 1 as the
-    #? first element; then when it selects an index of the
+    #? first object; then when it selects an index of the
     #? list, it will take at 0-starting notation:
     #/ Random float between 1 and n with 4 decimals.
     #* This random represent a random point of selection
-    #* in a linear axis in which all elements has the same
+    #* in a linear axis in which all objects has the same
     #* space to be selected:
     randomLinearPoint = round(random.uniform(0, n), 4)
     # print(f"\nRandom Lineal Point: {randomLinearPoint}; ", end="")
@@ -46,19 +46,19 @@ def logrps(elements: list):
     This is the propuse:
 
         * Having a linear scale between 1 - n, all the spaces
-          between elements has the same size.
+          between objects has the same size.
         
         * Having a logarithmic scale between 1 - n, the spaces
-          between elements are different; the first element has
+          between objects are different; the first object has
           the biggest space, the second is smaller, etc. The
           differences between the spaces is based on logarithms.
 
         * When the random is selected, you get the linear scale
-          element; then it has to ponderate the space with the
+          object; then it has to ponderate the space with the
           logarithmic scale, to select the equivalent.
 
         Example:
-        NOTE: E1, E2, ..., E6 are the 6 elements of the list.
+        NOTE: E1, E2, ..., E6 are the 6 objects of the list.
 
         LINEAR SCALE:
             E1      E2      E3      E4      E5      E6
@@ -89,6 +89,6 @@ def logrps(elements: list):
     for i in range(2, (n+1)+1):
         # print((n+1) * math.log(i, n+1), end=" ")
         if randomLinearPoint <= (n * math.log(i, n+1)):
-            #! Returns the selected element:
+            #! Returns the selected object:
             # print(f"Logarithmic point: {i-1};")
-            return elements[(i-1)-1]
+            return objects[(i-1)-1]
diff --git a/Algorithm/logselection.png b/Algorithm/logselection.png
