Author: My Account
Last saved by: Windows-Benutzer
Company: Grizli777

'This code was used to generate the data for Tables 1 and 2 in "Escaping the No Free Lunch Theorem", using Microsoft Visual Studio Express 2012 for Windows Desktop.
'To operate, the code can be pasted into a blank Visual Basic Windows for Application. You will need to add a reference to the assembly System.Numerics to run the code.

'To re-generate the data Table 1, left click the last line of the main subroutine "Form1_Load" (second-but-last line of the program); this stops the program after exectution. Then start the program.  
'Once the progam is complete data may be viewed by left clicking the array or matrix of interest and selecting 'QuickWatch'. 
'The data for Table 1 may be retrieved as follows:
'For the 21 absolute success intervals (raw results are for the number of sequences in the intervals): 
'Obj_Method_Final_Score_Instances, ITB_Final_Score_Instances, AW_Final_Score_Instances, EAW_Final_Score_Instances, 
'For the State-uniform average successes: Obj_Method_Avg_Sum_of_Scores, ITB_Avg_Sum_of_Scores, AW_Avg_Sum_of_Scores, AW_Running_Sum_of_Scores, EAW_Avg_Sum_of_Scores, 
'For the Average max-regrets: Mean_ITB_Regret, Mean_AW_Regret, and Mean_EAW_Regret (to get the absolute regrets, multiply by the number of rounds).

'To re-generate the data Table 2, re-run the program after reseting Event_Seq_Length to 10.

Imports System.Numerics

Public Class Form1

    Dim Number_of_Possible_Event_Values As Integer = 2 'Parameter
    Dim Possible_Event_Values(Number_of_Possible_Event_Values) As Double 'Set the possible values below.

    Dim Event_Seq_Length As Integer = 20 'Parameter
    Dim Event_Sequences As BigInteger = Number_of_Possible_Event_Values ^ Event_Seq_Length 'Number of event sequences.
    Dim Event_Sequences_Real As Double = Event_Sequences 'to avoid rounding errors

    Dim Event_Sequences_d As Double = Event_Sequences

    Dim Game_Holder(Event_Seq_Length) As Double 'Holds individual event sequences

    Dim Event_Avg As Double = 0 'Holds average value of the event sequence.
    Dim Event_Median As Double = 0 'Holds average value of the event sequence.

    'Dim tester(2048) As Integer 'Diagnostics
    'Dim testercounter As Integer

    Dim Number_of_Object_Players As Integer = 3 'Parameter, details of the players are fixed below. 

    'Holds data concenrning object methods:
    Dim Obj_Method_Predictions(Number_of_Object_Players, Event_Seq_Length) As Double 'predictions for the game under consideration. Resets as each new game begins.
    Dim Obj_Method_Score_at_Round(Number_of_Object_Players, Event_Seq_Length) As Double
    Dim Obj_Method_Validity_as_of_Round(Number_of_Object_Players, Event_Seq_Length) As Double
    Dim Obj_Method_Final_Sum_of_Scores(Number_of_Object_Players) As Double
    Dim Obj_Method_Running_Sum_of_Scores(Number_of_Object_Players) As Double 'sum of scores accross games
    Dim Obj_Method_Final_Score_Instances(Number_of_Object_Players, 21) As Integer 'Instances of various sum of scores, dividing the possible sums of scores into 21 intervals.
    Dim Magnif_Obj_Method_Final_Score_Instances(Number_of_Object_Players, 5) As Integer 'Instances of various sum of scores, dividing the highest possible sums of scores into 5 intervals.
    Dim Obj_Method_Avg_Sum_of_Scores(Number_of_Object_Players) As Double 'Average sum of scores

    Dim ITB_Fav(Event_Seq_Length + 1) As Integer
    Dim ITB_Predictions(Event_Seq_Length) As Double
    Dim ITB_Score_at_Round(Event_Seq_Length) As Double
    Dim ITB_Validity_as_of_Round(Event_Seq_Length) As Double
    Dim ITB_Final_Sum_of_Scores As Double
    Dim ITB_Running_Sum_of_Scores As Double
    Dim ITB_Final_Score_Instances(21) As Integer
    Dim Magnif_ITB_Final_Score_Instances(5) As Integer
    Dim ITB_Avg_Sum_of_Scores As Double

    Dim AW_Predictions(Event_Seq_Length) As Double
    Dim AW_Score_at_Round(Event_Seq_Length) As Double
    Dim AW_Validity_as_of_Round(Event_Seq_Length) As Double
    Dim AW_Final_Sum_of_Scores As Double
    Dim AW_Running_Sum_of_Scores As Double
    Dim AW_Final_Score_Instances(21) As Integer
    Dim Magnif_AW_Final_Score_Instances(5) As Integer
    Dim AW_Avg_Sum_of_Scores As Double

    Dim EAW_Predictions(Event_Seq_Length) As Double
    Dim EAW_Score_at_Round(Event_Seq_Length) As Double
    Dim EAW_Validity_as_of_Round(Event_Seq_Length) As Double
    Dim EAW_Final_Sum_of_Scores As Double
    Dim EAW_Running_Sum_of_Scores As Double
    Dim EAW_Final_Score_Instances(21) As Integer
    Dim Magnif_EAW_Final_Score_Instances(5) As Integer
    Dim EAW_Avg_Sum_of_Scores As Double

    Dim Holder1 As Double
    Dim Holder2 As Integer

    Dim Num_Holder As Double
    Dim Den_Holder As Double

    Dim Counter1 As Integer
    Dim Counter2 As Integer
    Dim Test As Integer

    Dim Observed_Event_Instances(Number_of_Possible_Event_Values) As Integer

    'Used for running through the set of possible games:
    Dim Type_Counter(Event_Seq_Length) As Integer
    Dim Instances_Counter(Event_Seq_Length) As Integer

    'New Data Collectors for Entropy Dependent Results:
    Dim Is_Binary As Integer = 0
    Dim Event_Frequencies(Number_of_Possible_Event_Values) As Integer 'Records the number of each event type with the game under consideration. Reset after each event sequence.
    Dim Event_Sequence_Mean As Double 'Reset after each event sequence.
    Dim Entropy_at_Sequence As Double 'Records either the frequency or standard deviation of each event sequence.
    Dim Elements_at_Entropy(10) As Double 'Records the number of sequences with frequency or standard deviation within 10 intervals.

    'Records the number sum of scores for each method, dependent on the 10 entropy levels:
    Dim Obj_Method_Final_Score_Instances_by_Entropy(Number_of_Object_Players, 10) As Double
    Dim ITB_Obj_Method_Final_Score_Instances_by_Entropy(10) As Double
    Dim AW_Obj_Method_Final_Score_Instances_by_Entropy(10) As Double
    Dim EAW_Obj_Method_Final_Score_Instances_by_Entropy(10) As Double

    Dim Maximum_Possible_Entropy As Double = 1.58129089922 'i.e., -1 * (Math.Log(1 / Number_of_Possible_Event_Values) / Math.Log(2))

    Dim EAW_EXP As Double
    Dim EAW_Holder As Double

    Dim ITB_Regret(Event_Seq_Length) As Double
    Dim Mean_ITB_Regret(Event_Seq_Length) As Double

    Dim AW_Regret(Event_Seq_Length) As Double
    Dim Mean_AW_Regret(Event_Seq_Length) As Double

    Dim EAW_Regret(Event_Seq_Length) As Double
    Dim Mean_EAW_Regret(Event_Seq_Length) As Double

    Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load

        Possible_Event_Values(1) = 0
        Possible_Event_Values(2) = 1

        'Preparation of the event sequence generate:
        Dim Period(Event_Seq_Length) As Integer
        Period(1) = Event_Sequences / Number_of_Possible_Event_Values
        For x = 2 To Event_Seq_Length
            Period(x) = Period(x - 1) / Number_of_Possible_Event_Values
        Next

        For x = 1 To Event_Seq_Length
            Type_Counter(x) = 1 'Counter1 
            Instances_Counter(x) = 0 'Counter2
        Next

        For g = 1 To Event_Sequences

            'If g = Event_Sequences / 2 Then
            '    g = Event_Sequences
            'End If

            Event_Avg = -1

            If g = 25000 Then
                g = g
            End If

            For r = 1 To Event_Seq_Length
                Game_Holder(r) = 0
            Next

            For x = 1 To Number_of_Possible_Event_Values
                Observed_Event_Instances(x) = 0
            Next

            For r = 1 To Event_Seq_Length

                'Generates the appropriate event sequence:
                If Instances_Counter(r) = Period(r) Then
                    Instances_Counter(r) = 0
                    If Type_Counter(r) < Number_of_Possible_Event_Values Then
                        Type_Counter(r) = Type_Counter(r) + 1
                    Else
                        Type_Counter(r) = 1
                    End If
                End If
                Game_Holder(r) = Possible_Event_Values(Type_Counter(r))
                Instances_Counter(r) = Instances_Counter(r) + 1

                If Event_Avg = -1 Then
                    'Object methods predict 0.5 in first round:
                    Obj_Method_Predictions(1, r) = 0.5
                    Obj_Method_Predictions(2, r) = 0.5
                    Obj_Method_Predictions(3, r) = 0.5
                    'Obj_Method_Predictions(4, r) = 0.5
                    'Obj_Method_Predictions(5, r) = 0.5
                Else

                    'Obj_Method_Predictions(1, r) = Event_Avg

                    'Obj_Method_Predictions(2, r) = 1 - Event_Avg

                    Obj_Method_Predictions(3, r) = 0.5

                    If Event_Avg > 0.5 Then
                        Obj_Method_Predictions(1, r) = 1
                    Else
                        If Event_Avg < 0.5 Then
                            Obj_Method_Predictions(1, r) = 0
                        Else
                            Obj_Method_Predictions(1, r) = 0.5
                        End If
                    End If

                    'Obj_Method_Predictions(2, r) = Event_Avg

                    If Event_Avg < 0.5 Then
                        Obj_Method_Predictions(2, r) = 1
                    Else
                        If Event_Avg > 0.5 Then
                            Obj_Method_Predictions(2, r) = 0
                        Else
                            Obj_Method_Predictions(2, r) = 0.5
                        End If
                    End If

                    'Obj_Method_Predictions(4, r) = 1 - Event_Avg 'dual anti-ind

                    'Obj_Method_Predictions(5, r) = 0.5

                End If

                For x = 1 To Number_of_Possible_Event_Values
                    If Game_Holder(r) = Possible_Event_Values(x) Then
                        Observed_Event_Instances(x) = Observed_Event_Instances(x) + 1
                    End If
                Next

                Counter1 = 0
                Counter2 = 0
                Test = 0
                While Test = 0

                    Counter1 = Counter1 + 1

                    Counter2 = Counter2 + Observed_Event_Instances(Counter1)

                    If Counter2 = r / 2 Then
                        If Observed_Event_Instances(Counter1 + 1) > 0 Then
                            Event_Median = (Possible_Event_Values(Counter1) + Possible_Event_Values(Counter1 + 1)) / 2
                        Else
                            If Observed_Event_Instances(Counter1 + 2) > 0 Then
                                Event_Median = (Possible_Event_Values(Counter1) + Possible_Event_Values(Counter1 + 2)) / 2
                            Else
                                If Observed_Event_Instances(Counter1 + 3) > 0 Then
                                    Event_Median = (Possible_Event_Values(Counter1) + Possible_Event_Values(Counter1 + 3)) / 2
                                Else
                                    Event_Median = (Possible_Event_Values(Counter1) + Possible_Event_Values(Counter1 + 4)) / 2
                                End If
                            End If
                        End If
                        'Event_Median = (Possible_Event_Values(Counter1) + Possible_Event_Values(Counter1 + 1)) / 2
                        Test = 1
                    End If

                    If Counter2 > r / 2 Then
                        Event_Median = Possible_Event_Values(Counter1)
                        Test = 1
                    End If

                End While

                'Computes average of the event sequence:
                Event_Avg = 0
                For z = 1 To r
                    Event_Avg = Event_Avg + Game_Holder(z)
                Next
                Event_Avg = Event_Avg / r

                'Computes scores and validity of object methods:
                For m = 1 To Number_of_Object_Players
                    Obj_Method_Score_at_Round(m, r) = 1 - Math.Abs(Game_Holder(r) - Obj_Method_Predictions(m, r))
                    Holder1 = 0
                    For y = 1 To r
                        Holder1 = Holder1 + Obj_Method_Score_at_Round(m, y)
                    Next
                    Obj_Method_Validity_as_of_Round(m, r) = Holder1 / r
                Next

                'Determines TTB's Favorite:
                ITB_Fav(1) = 0
                If r = 2 Then
                    Holder1 = 0
                    Holder2 = 0
                    For m = 1 To Number_of_Object_Players '***************************************************************************************
                        If Obj_Method_Validity_as_of_Round(m, r - 1) > Holder1 Then
                            Holder1 = Obj_Method_Validity_as_of_Round(m, r - 1)
                            Holder2 = m
                        End If
                    Next
                    ITB_Fav(2) = Holder2
                End If
                If r > 2 Then
                    Holder1 = Obj_Method_Validity_as_of_Round(ITB_Fav(r - 1), r - 1)
                    Holder2 = ITB_Fav(r - 1)
                    For m = 1 To Number_of_Object_Players  '***************************************************************************************
                        If Obj_Method_Validity_as_of_Round(m, r - 1) > Holder1 Then
                            Holder1 = Obj_Method_Validity_as_of_Round(m, r - 1)
                            Holder2 = m
                        End If
                    Next
                    ITB_Fav(r) = Holder2
                End If

                'Determines ITB's Prediction, Score, and Validity:
                If ITB_Fav(r) = 0 Then
                    ITB_Predictions(r) = 0.5
                Else
                    ITB_Predictions(r) = Obj_Method_Predictions(ITB_Fav(r), r)
                End If
                ITB_Score_at_Round(r) = 1 - Math.Abs(Game_Holder(r) - ITB_Predictions(r))
                Holder1 = 0
                For y = 1 To r
                    Holder1 = Holder1 + ITB_Score_at_Round(y)
                Next
                ITB_Validity_as_of_Round(r) = Holder1 / r

                If r > 1 Then
                    ITB_Regret(r - 1) = Obj_Method_Validity_as_of_Round(ITB_Fav(r), r - 1) - ITB_Validity_as_of_Round(r - 1)
                    Mean_ITB_Regret(r - 1) = Mean_ITB_Regret(r - 1) + ITB_Regret(r - 1)
                End If

                'Determines TTB's would be favorite at game end:
                If r = Event_Seq_Length Then
                    Holder1 = Obj_Method_Validity_as_of_Round(ITB_Fav(Event_Seq_Length), Event_Seq_Length)
                    Holder2 = ITB_Fav(Event_Seq_Length)
                    For m = 1 To Number_of_Object_Players
                        If Obj_Method_Validity_as_of_Round(m, Event_Seq_Length) > Holder1 Then
                            Holder1 = Obj_Method_Validity_as_of_Round(m, Event_Seq_Length)
                            Holder2 = m
                        End If
                    Next
                    ITB_Fav(r + 1) = Holder2
                    ITB_Regret(r) = Obj_Method_Validity_as_of_Round(ITB_Fav(r + 1), r) - ITB_Validity_as_of_Round(r)
                    Mean_ITB_Regret(r) = Mean_ITB_Regret(r) + ITB_Regret(r)
                End If

                'Determines AW's Prediction, Score, and Validity:
                Num_Holder = 0
                Den_Holder = 0
                For m = 1 To Number_of_Object_Players
                    If Obj_Method_Validity_as_of_Round(m, r - 1) > AW_Validity_as_of_Round(r - 1) Then
                        Num_Holder = Num_Holder + (Obj_Method_Predictions(m, r) * (Obj_Method_Validity_as_of_Round(m, r - 1) - AW_Validity_as_of_Round(r - 1)))
                        Den_Holder = Den_Holder + (Obj_Method_Validity_as_of_Round(m, r - 1) - AW_Validity_as_of_Round(r - 1))
                    End If
                Next
                If Den_Holder = 0 Then
                    AW_Predictions(r) = ITB_Predictions(r)
                Else
                    AW_Predictions(r) = Num_Holder / Den_Holder
                End If
                AW_Score_at_Round(r) = 1 - Math.Abs(Game_Holder(r) - AW_Predictions(r))
                Holder1 = 0
                For y = 1 To r
                    Holder1 = Holder1 + AW_Score_at_Round(y)
                Next
                AW_Validity_as_of_Round(r) = Holder1 / r

                If r > 1 Then
                    AW_Regret(r - 1) = Obj_Method_Validity_as_of_Round(ITB_Fav(r), r - 1) - AW_Validity_as_of_Round(r - 1)
                    Mean_AW_Regret(r - 1) = Mean_AW_Regret(r - 1) + AW_Regret(r - 1)
                End If

                If r = Event_Seq_Length Then
                    AW_Regret(r) = Obj_Method_Validity_as_of_Round(ITB_Fav(r + 1), r) - AW_Validity_as_of_Round(r)
                    Mean_AW_Regret(r) = Mean_AW_Regret(r) + AW_Regret(r)
                End If

                'Determines EAW's Prediction, Score, and Validity:
                Num_Holder = 0
                Den_Holder = 0

                EAW_EXP = Math.Sqrt((8 * Math.Log(Number_of_Object_Players)) / r)

                For m = 1 To Number_of_Object_Players
                    EAW_Holder = Math.Exp(EAW_EXP * ((r - 1) * (Obj_Method_Validity_as_of_Round(m, r - 1) - EAW_Validity_as_of_Round(r - 1))))
                    Num_Holder = Num_Holder + (Obj_Method_Predictions(m, r) * EAW_Holder)
                    Den_Holder = Den_Holder + EAW_Holder
                Next

                EAW_Predictions(r) = Num_Holder / Den_Holder

                EAW_Score_at_Round(r) = 1 - Math.Abs(Game_Holder(r) - EAW_Predictions(r))
                Holder1 = 0
                For y = 1 To r
                    Holder1 = Holder1 + EAW_Score_at_Round(y)
                Next
                EAW_Validity_as_of_Round(r) = Holder1 / r

                If r > 1 Then
                    EAW_Regret(r - 1) = Obj_Method_Validity_as_of_Round(ITB_Fav(r), r - 1) - EAW_Validity_as_of_Round(r - 1)
                    Mean_EAW_Regret(r - 1) = Mean_EAW_Regret(r - 1) + EAW_Regret(r - 1)
                End If

                If r = Event_Seq_Length Then
                    EAW_Regret(r) = Obj_Method_Validity_as_of_Round(ITB_Fav(r + 1), r) - EAW_Validity_as_of_Round(r)
                    Mean_EAW_Regret(r) = Mean_EAW_Regret(r) + EAW_Regret(r)
                End If

            Next

            'Determines the number of times that respective object methods earned a sume of scores in one of 20 intervals:
            For m = 1 To Number_of_Object_Players
                'Determine final sum of scores for the game:
                Obj_Method_Final_Sum_of_Scores(m) = Obj_Method_Validity_as_of_Round(m, Event_Seq_Length) * Event_Seq_Length

                'Increment running sum of scores:
                Obj_Method_Running_Sum_of_Scores(m) = Obj_Method_Running_Sum_of_Scores(m) + Obj_Method_Final_Sum_of_Scores(m)

                'Normalize final sum of scores to a scale of 1 to 10:
                Obj_Method_Final_Sum_of_Scores(m) = Obj_Method_Final_Sum_of_Scores(m) / (Event_Seq_Length / 10)

                If Obj_Method_Final_Sum_of_Scores(m) < 0.5 Then Obj_Method_Final_Score_Instances(m, 1) = Obj_Method_Final_Score_Instances(m, 1) + 1
                If 0.5 <= Obj_Method_Final_Sum_of_Scores(m) And Obj_Method_Final_Sum_of_Scores(m) < 1 Then Obj_Method_Final_Score_Instances(m, 2) = Obj_Method_Final_Score_Instances(m, 2) + 1
                If 1 <= Obj_Method_Final_Sum_of_Scores(m) And Obj_Method_Final_Sum_of_Scores(m) < 1.5 Then Obj_Method_Final_Score_Instances(m, 3) = Obj_Method_Final_Score_Instances(m, 3) + 1
                If 1.5 <= Obj_Method_Final_Sum_of_Scores(m) And Obj_Method_Final_Sum_of_Scores(m) < 2 Then Obj_Method_Final_Score_Instances(m, 4) = Obj_Method_Final_Score_Instances(m, 4) + 1
                If 2 <= Obj_Method_Final_Sum_of_Scores(m) And Obj_Method_Final_Sum_of_Scores(m) < 2.5 Then Obj_Method_Final_Score_Instances(m, 5) = Obj_Method_Final_Score_Instances(m, 5) + 1
                If 2.5 <= Obj_Method_Final_Sum_of_Scores(m) And Obj_Method_Final_Sum_of_Scores(m) < 3 Then Obj_Method_Final_Score_Instances(m, 6) = Obj_Method_Final_Score_Instances(m, 6) + 1
                If 3 <= Obj_Method_Final_Sum_of_Scores(m) And Obj_Method_Final_Sum_of_Scores(m) < 3.5 Then Obj_Method_Final_Score_Instances(m, 7) = Obj_Method_Final_Score_Instances(m, 7) + 1
                If 3.5 <= Obj_Method_Final_Sum_of_Scores(m) And Obj_Method_Final_Sum_of_Scores(m) < 4 Then Obj_Method_Final_Score_Instances(m, 8) = Obj_Method_Final_Score_Instances(m, 8) + 1
                If 4 <= Obj_Method_Final_Sum_of_Scores(m) And Obj_Method_Final_Sum_of_Scores(m) < 4.5 Then Obj_Method_Final_Score_Instances(m, 9) = Obj_Method_Final_Score_Instances(m, 9) + 1
                If 4.5 <= Obj_Method_Final_Sum_of_Scores(m) And Obj_Method_Final_Sum_of_Scores(m) < 5 Then Obj_Method_Final_Score_Instances(m, 10) = Obj_Method_Final_Score_Instances(m, 10) + 1
                If Obj_Method_Final_Sum_of_Scores(m) = 5 Then Obj_Method_Final_Score_Instances(m, 11) = Obj_Method_Final_Score_Instances(m, 11) + 1
                If 5 < Obj_Method_Final_Sum_of_Scores(m) And Obj_Method_Final_Sum_of_Scores(m) <= 5.5 Then Obj_Method_Final_Score_Instances(m, 12) = Obj_Method_Final_Score_Instances(m, 12) + 1
                If 5.5 < Obj_Method_Final_Sum_of_Scores(m) And Obj_Method_Final_Sum_of_Scores(m) <= 6 Then Obj_Method_Final_Score_Instances(m, 13) = Obj_Method_Final_Score_Instances(m, 13) + 1
                If 6 < Obj_Method_Final_Sum_of_Scores(m) And Obj_Method_Final_Sum_of_Scores(m) <= 6.5 Then Obj_Method_Final_Score_Instances(m, 14) = Obj_Method_Final_Score_Instances(m, 14) + 1
                If 6.5 < Obj_Method_Final_Sum_of_Scores(m) And Obj_Method_Final_Sum_of_Scores(m) <= 7 Then Obj_Method_Final_Score_Instances(m, 15) = Obj_Method_Final_Score_Instances(m, 15) + 1
                If 7 < Obj_Method_Final_Sum_of_Scores(m) And Obj_Method_Final_Sum_of_Scores(m) <= 7.5 Then Obj_Method_Final_Score_Instances(m, 16) = Obj_Method_Final_Score_Instances(m, 16) + 1
                If 7.5 < Obj_Method_Final_Sum_of_Scores(m) And Obj_Method_Final_Sum_of_Scores(m) <= 8 Then Obj_Method_Final_Score_Instances(m, 17) = Obj_Method_Final_Score_Instances(m, 17) + 1
                If 8 < Obj_Method_Final_Sum_of_Scores(m) And Obj_Method_Final_Sum_of_Scores(m) <= 8.5 Then Obj_Method_Final_Score_Instances(m, 18) = Obj_Method_Final_Score_Instances(m, 18) + 1
                If 8.5 < Obj_Method_Final_Sum_of_Scores(m) And Obj_Method_Final_Sum_of_Scores(m) <= 9 Then Obj_Method_Final_Score_Instances(m, 19) = Obj_Method_Final_Score_Instances(m, 19) + 1
                If 9 < Obj_Method_Final_Sum_of_Scores(m) And Obj_Method_Final_Sum_of_Scores(m) <= 9.5 Then Obj_Method_Final_Score_Instances(m, 20) = Obj_Method_Final_Score_Instances(m, 20) + 1
                If 9.5 < Obj_Method_Final_Sum_of_Scores(m) Then
                    Obj_Method_Final_Score_Instances(m, 21) = Obj_Method_Final_Score_Instances(m, 21) + 1
                    If 9.5 <= Obj_Method_Final_Sum_of_Scores(m) And Obj_Method_Final_Sum_of_Scores(m) < 9.6 Then Magnif_Obj_Method_Final_Score_Instances(m, 1) = Magnif_Obj_Method_Final_Score_Instances(m, 1) + 1
                    If 9.6 <= Obj_Method_Final_Sum_of_Scores(m) And Obj_Method_Final_Sum_of_Scores(m) < 9.7 Then Magnif_Obj_Method_Final_Score_Instances(m, 2) = Magnif_Obj_Method_Final_Score_Instances(m, 2) + 1
                    If 9.7 <= Obj_Method_Final_Sum_of_Scores(m) And Obj_Method_Final_Sum_of_Scores(m) < 9.8 Then Magnif_Obj_Method_Final_Score_Instances(m, 3) = Magnif_Obj_Method_Final_Score_Instances(m, 3) + 1
                    If 9.8 <= Obj_Method_Final_Sum_of_Scores(m) And Obj_Method_Final_Sum_of_Scores(m) < 9.9 Then Magnif_Obj_Method_Final_Score_Instances(m, 4) = Magnif_Obj_Method_Final_Score_Instances(m, 4) + 1
                    If 9.9 <= Obj_Method_Final_Sum_of_Scores(m) Then
                        Magnif_Obj_Method_Final_Score_Instances(m, 5) = Magnif_Obj_Method_Final_Score_Instances(m, 5) + 1
                    End If
                End If

                'Undo normalization:
                Obj_Method_Final_Sum_of_Scores(m) = Obj_Method_Final_Sum_of_Scores(m) * (Event_Seq_Length / 10)

            Next

            'Does the same as above for ITB:
            ITB_Final_Sum_of_Scores = ITB_Validity_as_of_Round(Event_Seq_Length) * Event_Seq_Length

            ITB_Running_Sum_of_Scores = ITB_Running_Sum_of_Scores + ITB_Final_Sum_of_Scores

            ITB_Final_Sum_of_Scores = ITB_Final_Sum_of_Scores / (Event_Seq_Length / 10)

            If ITB_Final_Sum_of_Scores < 0.5 Then ITB_Final_Score_Instances(1) = ITB_Final_Score_Instances(1) + 1
            If 0.5 <= ITB_Final_Sum_of_Scores And ITB_Final_Sum_of_Scores < 1 Then ITB_Final_Score_Instances(2) = ITB_Final_Score_Instances(2) + 1
            If 1 <= ITB_Final_Sum_of_Scores And ITB_Final_Sum_of_Scores < 1.5 Then ITB_Final_Score_Instances(3) = ITB_Final_Score_Instances(3) + 1
            If 1.5 <= ITB_Final_Sum_of_Scores And ITB_Final_Sum_of_Scores < 2 Then ITB_Final_Score_Instances(4) = ITB_Final_Score_Instances(4) + 1
            If 2 <= ITB_Final_Sum_of_Scores And ITB_Final_Sum_of_Scores < 2.5 Then ITB_Final_Score_Instances(5) = ITB_Final_Score_Instances(5) + 1
            If 2.5 <= ITB_Final_Sum_of_Scores And ITB_Final_Sum_of_Scores < 3 Then ITB_Final_Score_Instances(6) = ITB_Final_Score_Instances(6) + 1
            If 3 <= ITB_Final_Sum_of_Scores And ITB_Final_Sum_of_Scores < 3.5 Then ITB_Final_Score_Instances(7) = ITB_Final_Score_Instances(7) + 1
            If 3.5 <= ITB_Final_Sum_of_Scores And ITB_Final_Sum_of_Scores < 4 Then ITB_Final_Score_Instances(8) = ITB_Final_Score_Instances(8) + 1
            If 4 <= ITB_Final_Sum_of_Scores And ITB_Final_Sum_of_Scores < 4.5 Then ITB_Final_Score_Instances(9) = ITB_Final_Score_Instances(9) + 1
            If 4.5 <= ITB_Final_Sum_of_Scores And ITB_Final_Sum_of_Scores < 5 Then ITB_Final_Score_Instances(10) = ITB_Final_Score_Instances(10) + 1
            If ITB_Final_Sum_of_Scores = 5 Then ITB_Final_Score_Instances(11) = ITB_Final_Score_Instances(11) + 1
            If 5 < ITB_Final_Sum_of_Scores And ITB_Final_Sum_of_Scores <= 5.5 Then ITB_Final_Score_Instances(12) = ITB_Final_Score_Instances(12) + 1
            If 5.5 < ITB_Final_Sum_of_Scores And ITB_Final_Sum_of_Scores <= 6 Then ITB_Final_Score_Instances(13) = ITB_Final_Score_Instances(13) + 1
            If 6 < ITB_Final_Sum_of_Scores And ITB_Final_Sum_of_Scores <= 6.5 Then ITB_Final_Score_Instances(14) = ITB_Final_Score_Instances(14) + 1
            If 6.5 < ITB_Final_Sum_of_Scores And ITB_Final_Sum_of_Scores <= 7 Then ITB_Final_Score_Instances(15) = ITB_Final_Score_Instances(15) + 1
            If 7 < ITB_Final_Sum_of_Scores And ITB_Final_Sum_of_Scores <= 7.5 Then ITB_Final_Score_Instances(16) = ITB_Final_Score_Instances(16) + 1
            If 7.5 < ITB_Final_Sum_of_Scores And ITB_Final_Sum_of_Scores <= 8 Then ITB_Final_Score_Instances(17) = ITB_Final_Score_Instances(17) + 1
            If 8 < ITB_Final_Sum_of_Scores And ITB_Final_Sum_of_Scores <= 8.5 Then ITB_Final_Score_Instances(18) = ITB_Final_Score_Instances(18) + 1
            If 8.5 < ITB_Final_Sum_of_Scores And ITB_Final_Sum_of_Scores <= 9 Then ITB_Final_Score_Instances(19) = ITB_Final_Score_Instances(19) + 1
            If 9 < ITB_Final_Sum_of_Scores And ITB_Final_Sum_of_Scores <= 9.5 Then ITB_Final_Score_Instances(20) = ITB_Final_Score_Instances(20) + 1
            If 9.5 < ITB_Final_Sum_of_Scores Then
                ITB_Final_Score_Instances(21) = ITB_Final_Score_Instances(21) + 1
                If 9.5 <= ITB_Final_Sum_of_Scores And ITB_Final_Sum_of_Scores < 9.6 Then Magnif_ITB_Final_Score_Instances(1) = Magnif_ITB_Final_Score_Instances(1) + 1
                If 9.6 <= ITB_Final_Sum_of_Scores And ITB_Final_Sum_of_Scores < 9.7 Then Magnif_ITB_Final_Score_Instances(2) = Magnif_ITB_Final_Score_Instances(2) + 1
                If 9.7 <= ITB_Final_Sum_of_Scores And ITB_Final_Sum_of_Scores < 9.8 Then Magnif_ITB_Final_Score_Instances(3) = Magnif_ITB_Final_Score_Instances(3) + 1
                If 9.8 <= ITB_Final_Sum_of_Scores And ITB_Final_Sum_of_Scores < 9.9 Then Magnif_ITB_Final_Score_Instances(4) = Magnif_ITB_Final_Score_Instances(4) + 1
                If 9.9 <= ITB_Final_Sum_of_Scores Then Magnif_ITB_Final_Score_Instances(5) = Magnif_ITB_Final_Score_Instances(5) + 1
            End If

            ITB_Final_Sum_of_Scores = ITB_Final_Sum_of_Scores * (Event_Seq_Length / 10)

            'Does the same as above for AW:
            AW_Final_Sum_of_Scores = AW_Validity_as_of_Round(Event_Seq_Length) * Event_Seq_Length

            AW_Running_Sum_of_Scores = AW_Running_Sum_of_Scores + AW_Final_Sum_of_Scores

            AW_Final_Sum_of_Scores = AW_Final_Sum_of_Scores / (Event_Seq_Length / 10)

            If AW_Final_Sum_of_Scores < 0.5 Then AW_Final_Score_Instances(1) = AW_Final_Score_Instances(1) + 1
            If 0.5 <= AW_Final_Sum_of_Scores And AW_Final_Sum_of_Scores < 1 Then AW_Final_Score_Instances(2) = AW_Final_Score_Instances(2) + 1
            If 1 <= AW_Final_Sum_of_Scores And AW_Final_Sum_of_Scores < 1.5 Then AW_Final_Score_Instances(3) = AW_Final_Score_Instances(3) + 1
            If 1.5 <= AW_Final_Sum_of_Scores And AW_Final_Sum_of_Scores < 2 Then AW_Final_Score_Instances(4) = AW_Final_Score_Instances(4) + 1
            If 2 <= AW_Final_Sum_of_Scores And AW_Final_Sum_of_Scores < 2.5 Then AW_Final_Score_Instances(5) = AW_Final_Score_Instances(5) + 1
            If 2.5 <= AW_Final_Sum_of_Scores And AW_Final_Sum_of_Scores < 3 Then AW_Final_Score_Instances(6) = AW_Final_Score_Instances(6) + 1
            If 3 <= AW_Final_Sum_of_Scores And AW_Final_Sum_of_Scores < 3.5 Then AW_Final_Score_Instances(7) = AW_Final_Score_Instances(7) + 1
            If 3.5 <= AW_Final_Sum_of_Scores And AW_Final_Sum_of_Scores < 4 Then AW_Final_Score_Instances(8) = AW_Final_Score_Instances(8) + 1
            If 4 <= AW_Final_Sum_of_Scores And AW_Final_Sum_of_Scores < 4.5 Then AW_Final_Score_Instances(9) = AW_Final_Score_Instances(9) + 1
            If 4.5 <= AW_Final_Sum_of_Scores And AW_Final_Sum_of_Scores < 5 Then AW_Final_Score_Instances(10) = AW_Final_Score_Instances(10) + 1

            If AW_Final_Sum_of_Scores = 5 Then AW_Final_Score_Instances(11) = AW_Final_Score_Instances(11) + 1

            If 5 < AW_Final_Sum_of_Scores And AW_Final_Sum_of_Scores <= 5.5 Then AW_Final_Score_Instances(12) = AW_Final_Score_Instances(12) + 1
            If 5.5 < AW_Final_Sum_of_Scores And AW_Final_Sum_of_Scores <= 6 Then AW_Final_Score_Instances(13) = AW_Final_Score_Instances(13) + 1
            If 6 < AW_Final_Sum_of_Scores And AW_Final_Sum_of_Scores <= 6.5 Then AW_Final_Score_Instances(14) = AW_Final_Score_Instances(14) + 1
            If 6.5 < AW_Final_Sum_of_Scores And AW_Final_Sum_of_Scores <= 7 Then AW_Final_Score_Instances(15) = AW_Final_Score_Instances(15) + 1
            If 7 < AW_Final_Sum_of_Scores And AW_Final_Sum_of_Scores <= 7.5 Then AW_Final_Score_Instances(16) = AW_Final_Score_Instances(16) + 1
            If 7.5 < AW_Final_Sum_of_Scores And AW_Final_Sum_of_Scores <= 8 Then AW_Final_Score_Instances(17) = AW_Final_Score_Instances(17) + 1
            If 8 < AW_Final_Sum_of_Scores And AW_Final_Sum_of_Scores <= 8.5 Then AW_Final_Score_Instances(18) = AW_Final_Score_Instances(18) + 1
            If 8.5 < AW_Final_Sum_of_Scores And AW_Final_Sum_of_Scores <= 9 Then AW_Final_Score_Instances(19) = AW_Final_Score_Instances(19) + 1
            If 9 < AW_Final_Sum_of_Scores And AW_Final_Sum_of_Scores <= 9.5 Then AW_Final_Score_Instances(20) = AW_Final_Score_Instances(20) + 1
            If 9.5 < AW_Final_Sum_of_Scores Then
                AW_Final_Score_Instances(21) = AW_Final_Score_Instances(21) + 1
                If 9.5 <= AW_Final_Sum_of_Scores And AW_Final_Sum_of_Scores < 9.6 Then Magnif_AW_Final_Score_Instances(1) = Magnif_AW_Final_Score_Instances(1) + 1
                If 9.6 <= AW_Final_Sum_of_Scores And AW_Final_Sum_of_Scores < 9.7 Then Magnif_AW_Final_Score_Instances(2) = Magnif_AW_Final_Score_Instances(2) + 1
                If 9.7 <= AW_Final_Sum_of_Scores And AW_Final_Sum_of_Scores < 9.8 Then Magnif_AW_Final_Score_Instances(3) = Magnif_AW_Final_Score_Instances(3) + 1
                If 9.8 <= AW_Final_Sum_of_Scores And AW_Final_Sum_of_Scores < 9.9 Then Magnif_AW_Final_Score_Instances(4) = Magnif_AW_Final_Score_Instances(4) + 1
                If 9.9 <= AW_Final_Sum_of_Scores Then Magnif_AW_Final_Score_Instances(5) = Magnif_AW_Final_Score_Instances(5) + 1
            End If

            AW_Final_Sum_of_Scores = AW_Final_Sum_of_Scores * (Event_Seq_Length / 10)

            'Does the same as above for EAW:
            EAW_Final_Sum_of_Scores = EAW_Validity_as_of_Round(Event_Seq_Length) * Event_Seq_Length

            EAW_Running_Sum_of_Scores = EAW_Running_Sum_of_Scores + EAW_Final_Sum_of_Scores

            EAW_Final_Sum_of_Scores = EAW_Final_Sum_of_Scores / (Event_Seq_Length / 10)

            If EAW_Final_Sum_of_Scores < 0.5 Then EAW_Final_Score_Instances(1) = EAW_Final_Score_Instances(1) + 1
            If 0.5 <= EAW_Final_Sum_of_Scores And EAW_Final_Sum_of_Scores < 1 Then EAW_Final_Score_Instances(2) = EAW_Final_Score_Instances(2) + 1
            If 1 <= EAW_Final_Sum_of_Scores And EAW_Final_Sum_of_Scores < 1.5 Then EAW_Final_Score_Instances(3) = EAW_Final_Score_Instances(3) + 1
            If 1.5 <= EAW_Final_Sum_of_Scores And EAW_Final_Sum_of_Scores < 2 Then EAW_Final_Score_Instances(4) = EAW_Final_Score_Instances(4) + 1
            If 2 <= EAW_Final_Sum_of_Scores And EAW_Final_Sum_of_Scores < 2.5 Then EAW_Final_Score_Instances(5) = EAW_Final_Score_Instances(5) + 1
            If 2.5 <= EAW_Final_Sum_of_Scores And EAW_Final_Sum_of_Scores < 3 Then EAW_Final_Score_Instances(6) = EAW_Final_Score_Instances(6) + 1
            If 3 <= EAW_Final_Sum_of_Scores And EAW_Final_Sum_of_Scores < 3.5 Then EAW_Final_Score_Instances(7) = EAW_Final_Score_Instances(7) + 1
            If 3.5 <= EAW_Final_Sum_of_Scores And EAW_Final_Sum_of_Scores < 4 Then EAW_Final_Score_Instances(8) = EAW_Final_Score_Instances(8) + 1
            If 4 <= EAW_Final_Sum_of_Scores And EAW_Final_Sum_of_Scores < 4.5 Then EAW_Final_Score_Instances(9) = EAW_Final_Score_Instances(9) + 1
            If 4.5 <= EAW_Final_Sum_of_Scores And EAW_Final_Sum_of_Scores < 5 Then EAW_Final_Score_Instances(10) = EAW_Final_Score_Instances(10) + 1

            If EAW_Final_Sum_of_Scores = 5 Then EAW_Final_Score_Instances(11) = EAW_Final_Score_Instances(11) + 1

            If 5 < EAW_Final_Sum_of_Scores And EAW_Final_Sum_of_Scores <= 5.5 Then EAW_Final_Score_Instances(12) = EAW_Final_Score_Instances(12) + 1
            If 5.5 < EAW_Final_Sum_of_Scores And EAW_Final_Sum_of_Scores <= 6 Then EAW_Final_Score_Instances(13) = EAW_Final_Score_Instances(13) + 1
            If 6 < EAW_Final_Sum_of_Scores And EAW_Final_Sum_of_Scores <= 6.5 Then EAW_Final_Score_Instances(14) = EAW_Final_Score_Instances(14) + 1
            If 6.5 < EAW_Final_Sum_of_Scores And EAW_Final_Sum_of_Scores <= 7 Then EAW_Final_Score_Instances(15) = EAW_Final_Score_Instances(15) + 1
            If 7 < EAW_Final_Sum_of_Scores And EAW_Final_Sum_of_Scores <= 7.5 Then EAW_Final_Score_Instances(16) = EAW_Final_Score_Instances(16) + 1
            If 7.5 < EAW_Final_Sum_of_Scores And EAW_Final_Sum_of_Scores <= 8 Then EAW_Final_Score_Instances(17) = EAW_Final_Score_Instances(17) + 1
            If 8 < EAW_Final_Sum_of_Scores And EAW_Final_Sum_of_Scores <= 8.5 Then EAW_Final_Score_Instances(18) = EAW_Final_Score_Instances(18) + 1
            If 8.5 < EAW_Final_Sum_of_Scores And EAW_Final_Sum_of_Scores <= 9 Then EAW_Final_Score_Instances(19) = EAW_Final_Score_Instances(19) + 1
            If 9 < EAW_Final_Sum_of_Scores And EAW_Final_Sum_of_Scores <= 9.5 Then EAW_Final_Score_Instances(20) = EAW_Final_Score_Instances(20) + 1
            If 9.5 < EAW_Final_Sum_of_Scores Then
                EAW_Final_Score_Instances(21) = EAW_Final_Score_Instances(21) + 1
                If 9.5 <= EAW_Final_Sum_of_Scores And EAW_Final_Sum_of_Scores < 9.6 Then Magnif_EAW_Final_Score_Instances(1) = Magnif_EAW_Final_Score_Instances(1) + 1
                If 9.6 <= EAW_Final_Sum_of_Scores And EAW_Final_Sum_of_Scores < 9.7 Then Magnif_EAW_Final_Score_Instances(2) = Magnif_EAW_Final_Score_Instances(2) + 1
                If 9.7 <= EAW_Final_Sum_of_Scores And EAW_Final_Sum_of_Scores < 9.8 Then Magnif_EAW_Final_Score_Instances(3) = Magnif_EAW_Final_Score_Instances(3) + 1
                If 9.8 <= EAW_Final_Sum_of_Scores And EAW_Final_Sum_of_Scores < 9.9 Then Magnif_EAW_Final_Score_Instances(4) = Magnif_EAW_Final_Score_Instances(4) + 1
                If 9.9 <= EAW_Final_Sum_of_Scores Then Magnif_EAW_Final_Score_Instances(5) = Magnif_EAW_Final_Score_Instances(5) + 1
            End If

            EAW_Final_Sum_of_Scores = EAW_Final_Sum_of_Scores * (Event_Seq_Length / 10)

            'Clear Data from previous sequence:
            For y = 1 To Number_of_Possible_Event_Values
                Event_Frequencies(y) = 0
            Next
            Event_Sequence_Mean = 0
            Entropy_at_Sequence = 0

            'Determine Event_Sequence_Mean for game:
            For r = 1 To Event_Seq_Length
                For y = 1 To Number_of_Possible_Event_Values
                    If Game_Holder(r) = Possible_Event_Values(y) Then
                        Event_Frequencies(y) = Event_Frequencies(y) + 1
                    End If
                Next
                Event_Sequence_Mean = Event_Sequence_Mean + Game_Holder(r)
            Next
            Event_Sequence_Mean = Event_Sequence_Mean / Event_Seq_Length

            'Determine Entropy_at_Sequence for game:
            If Is_Binary = 1 Then
                Entropy_at_Sequence = Event_Sequence_Mean
            Else
                For r = 1 To Number_of_Possible_Event_Values
                    If Not Event_Frequencies(r) = 0 Then
                        Entropy_at_Sequence = Entropy_at_Sequence + (-1 * (Math.Log(Event_Frequencies(r) / Event_Seq_Length) / Math.Log(2)) * (Event_Frequencies(r) / Event_Seq_Length))
                    End If
                Next
            End If

            'Maximum_Possible_Entropy = -1 * (Math.Log(1 / Number_of_Possible_Event_Values) / Math.Log(2)) 'computed above

            'Increment 'total' of sum of scores for the respective entropy interval:
            'For the object methods:
            If Is_Binary = 1 Then
                For m = 1 To Number_of_Object_Players
                    If Entropy_at_Sequence < 0.1 Then Obj_Method_Final_Score_Instances_by_Entropy(m, 1) = Obj_Method_Final_Score_Instances_by_Entropy(m, 1) + Obj_Method_Final_Sum_of_Scores(m)
                    If 0.1 <= Entropy_at_Sequence And Entropy_at_Sequence < 0.2 Then Obj_Method_Final_Score_Instances_by_Entropy(m, 2) = Obj_Method_Final_Score_Instances_by_Entropy(m, 2) + Obj_Method_Final_Sum_of_Scores(m)
                    If 0.2 <= Entropy_at_Sequence And Entropy_at_Sequence < 0.3 Then Obj_Method_Final_Score_Instances_by_Entropy(m, 3) = Obj_Method_Final_Score_Instances_by_Entropy(m, 3) + Obj_Method_Final_Sum_of_Scores(m)
                    If 0.3 <= Entropy_at_Sequence And Entropy_at_Sequence < 0.4 Then Obj_Method_Final_Score_Instances_by_Entropy(m, 4) = Obj_Method_Final_Score_Instances_by_Entropy(m, 4) + Obj_Method_Final_Sum_of_Scores(m)
                    If 0.4 <= Entropy_at_Sequence And Entropy_at_Sequence < 0.5 Then Obj_Method_Final_Score_Instances_by_Entropy(m, 5) = Obj_Method_Final_Score_Instances_by_Entropy(m, 5) + Obj_Method_Final_Sum_of_Scores(m)
                    If 0.5 <= Entropy_at_Sequence And Entropy_at_Sequence < 0.6 Then Obj_Method_Final_Score_Instances_by_Entropy(m, 6) = Obj_Method_Final_Score_Instances_by_Entropy(m, 6) + Obj_Method_Final_Sum_of_Scores(m)
                    If 0.6 <= Entropy_at_Sequence And Entropy_at_Sequence < 0.7 Then Obj_Method_Final_Score_Instances_by_Entropy(m, 7) = Obj_Method_Final_Score_Instances_by_Entropy(m, 7) + Obj_Method_Final_Sum_of_Scores(m)
                    If 0.7 <= Entropy_at_Sequence And Entropy_at_Sequence < 0.8 Then Obj_Method_Final_Score_Instances_by_Entropy(m, 8) = Obj_Method_Final_Score_Instances_by_Entropy(m, 8) + Obj_Method_Final_Sum_of_Scores(m)
                    If 0.8 <= Entropy_at_Sequence And Entropy_at_Sequence < 0.9 Then Obj_Method_Final_Score_Instances_by_Entropy(m, 9) = Obj_Method_Final_Score_Instances_by_Entropy(m, 9) + Obj_Method_Final_Sum_of_Scores(m)
                    If 0.9 <= Entropy_at_Sequence Then Obj_Method_Final_Score_Instances_by_Entropy(m, 10) = Obj_Method_Final_Score_Instances_by_Entropy(m, 10) + Obj_Method_Final_Sum_of_Scores(m)
                Next
            Else
                Entropy_at_Sequence = Entropy_at_Sequence / Maximum_Possible_Entropy
                For m = 1 To Number_of_Object_Players
                    If Entropy_at_Sequence < 0.1 Then Obj_Method_Final_Score_Instances_by_Entropy(m, 1) = Obj_Method_Final_Score_Instances_by_Entropy(m, 1) + Obj_Method_Final_Sum_of_Scores(m)
                    If 0.1 <= Entropy_at_Sequence And Entropy_at_Sequence < 0.2 Then Obj_Method_Final_Score_Instances_by_Entropy(m, 2) = Obj_Method_Final_Score_Instances_by_Entropy(m, 2) + Obj_Method_Final_Sum_of_Scores(m)
                    If 0.2 <= Entropy_at_Sequence And Entropy_at_Sequence < 0.3 Then Obj_Method_Final_Score_Instances_by_Entropy(m, 3) = Obj_Method_Final_Score_Instances_by_Entropy(m, 3) + Obj_Method_Final_Sum_of_Scores(m)
                    If 0.3 <= Entropy_at_Sequence And Entropy_at_Sequence < 0.4 Then Obj_Method_Final_Score_Instances_by_Entropy(m, 4) = Obj_Method_Final_Score_Instances_by_Entropy(m, 4) + Obj_Method_Final_Sum_of_Scores(m)
                    If 0.4 <= Entropy_at_Sequence And Entropy_at_Sequence < 0.5 Then Obj_Method_Final_Score_Instances_by_Entropy(m, 5) = Obj_Method_Final_Score_Instances_by_Entropy(m, 5) + Obj_Method_Final_Sum_of_Scores(m)
                    If 0.5 <= Entropy_at_Sequence And Entropy_at_Sequence < 0.6 Then Obj_Method_Final_Score_Instances_by_Entropy(m, 6) = Obj_Method_Final_Score_Instances_by_Entropy(m, 6) + Obj_Method_Final_Sum_of_Scores(m)
                    If 0.6 <= Entropy_at_Sequence And Entropy_at_Sequence < 0.7 Then Obj_Method_Final_Score_Instances_by_Entropy(m, 7) = Obj_Method_Final_Score_Instances_by_Entropy(m, 7) + Obj_Method_Final_Sum_of_Scores(m)
                    If 0.7 <= Entropy_at_Sequence And Entropy_at_Sequence < 0.8 Then Obj_Method_Final_Score_Instances_by_Entropy(m, 8) = Obj_Method_Final_Score_Instances_by_Entropy(m, 8) + Obj_Method_Final_Sum_of_Scores(m)
                    If 0.8 <= Entropy_at_Sequence And Entropy_at_Sequence < 0.9 Then Obj_Method_Final_Score_Instances_by_Entropy(m, 9) = Obj_Method_Final_Score_Instances_by_Entropy(m, 9) + Obj_Method_Final_Sum_of_Scores(m)
                    If 0.9 <= Entropy_at_Sequence Then
                        Obj_Method_Final_Score_Instances_by_Entropy(m, 10) = Obj_Method_Final_Score_Instances_by_Entropy(m, 10) + Obj_Method_Final_Sum_of_Scores(m)
                    End If

                Next
            End If

            'For ITB and AW and EAW:
            If Entropy_at_Sequence < 0.1 Then
                ITB_Obj_Method_Final_Score_Instances_by_Entropy(1) = ITB_Obj_Method_Final_Score_Instances_by_Entropy(1) + ITB_Final_Sum_of_Scores
                AW_Obj_Method_Final_Score_Instances_by_Entropy(1) = AW_Obj_Method_Final_Score_Instances_by_Entropy(1) + AW_Final_Sum_of_Scores
                EAW_Obj_Method_Final_Score_Instances_by_Entropy(1) = EAW_Obj_Method_Final_Score_Instances_by_Entropy(1) + EAW_Final_Sum_of_Scores
                Elements_at_Entropy(1) = Elements_at_Entropy(1) + 1
            End If
            If 0.1 <= Entropy_at_Sequence And Entropy_at_Sequence < 0.2 Then
                ITB_Obj_Method_Final_Score_Instances_by_Entropy(2) = ITB_Obj_Method_Final_Score_Instances_by_Entropy(2) + ITB_Final_Sum_of_Scores
                AW_Obj_Method_Final_Score_Instances_by_Entropy(2) = AW_Obj_Method_Final_Score_Instances_by_Entropy(2) + AW_Final_Sum_of_Scores
                EAW_Obj_Method_Final_Score_Instances_by_Entropy(2) = EAW_Obj_Method_Final_Score_Instances_by_Entropy(2) + EAW_Final_Sum_of_Scores
                Elements_at_Entropy(2) = Elements_at_Entropy(2) + 1
            End If
            If 0.2 <= Entropy_at_Sequence And Entropy_at_Sequence < 0.3 Then
                ITB_Obj_Method_Final_Score_Instances_by_Entropy(3) = ITB_Obj_Method_Final_Score_Instances_by_Entropy(3) + ITB_Final_Sum_of_Scores
                AW_Obj_Method_Final_Score_Instances_by_Entropy(3) = AW_Obj_Method_Final_Score_Instances_by_Entropy(3) + AW_Final_Sum_of_Scores
                EAW_Obj_Method_Final_Score_Instances_by_Entropy(3) = EAW_Obj_Method_Final_Score_Instances_by_Entropy(3) + EAW_Final_Sum_of_Scores
                Elements_at_Entropy(3) = Elements_at_Entropy(3) + 1
            End If
            If 0.3 <= Entropy_at_Sequence And Entropy_at_Sequence < 0.4 Then
                ITB_Obj_Method_Final_Score_Instances_by_Entropy(4) = ITB_Obj_Method_Final_Score_Instances_by_Entropy(4) + ITB_Final_Sum_of_Scores
                AW_Obj_Method_Final_Score_Instances_by_Entropy(4) = AW_Obj_Method_Final_Score_Instances_by_Entropy(4) + AW_Final_Sum_of_Scores
                EAW_Obj_Method_Final_Score_Instances_by_Entropy(4) = EAW_Obj_Method_Final_Score_Instances_by_Entropy(4) + EAW_Final_Sum_of_Scores
                Elements_at_Entropy(4) = Elements_at_Entropy(4) + 1
            End If
            If 0.4 <= Entropy_at_Sequence And Entropy_at_Sequence < 0.5 Then
                ITB_Obj_Method_Final_Score_Instances_by_Entropy(5) = ITB_Obj_Method_Final_Score_Instances_by_Entropy(5) + ITB_Final_Sum_of_Scores
                AW_Obj_Method_Final_Score_Instances_by_Entropy(5) = AW_Obj_Method_Final_Score_Instances_by_Entropy(5) + AW_Final_Sum_of_Scores
                EAW_Obj_Method_Final_Score_Instances_by_Entropy(5) = EAW_Obj_Method_Final_Score_Instances_by_Entropy(5) + EAW_Final_Sum_of_Scores
                Elements_at_Entropy(5) = Elements_at_Entropy(5) + 1
            End If
            If 0.5 <= Entropy_at_Sequence And Entropy_at_Sequence < 0.6 Then
                ITB_Obj_Method_Final_Score_Instances_by_Entropy(6) = ITB_Obj_Method_Final_Score_Instances_by_Entropy(6) + ITB_Final_Sum_of_Scores
                AW_Obj_Method_Final_Score_Instances_by_Entropy(6) = AW_Obj_Method_Final_Score_Instances_by_Entropy(6) + AW_Final_Sum_of_Scores
                EAW_Obj_Method_Final_Score_Instances_by_Entropy(6) = EAW_Obj_Method_Final_Score_Instances_by_Entropy(6) + EAW_Final_Sum_of_Scores
                Elements_at_Entropy(6) = Elements_at_Entropy(6) + 1
            End If
            If 0.6 <= Entropy_at_Sequence And Entropy_at_Sequence < 0.7 Then
                ITB_Obj_Method_Final_Score_Instances_by_Entropy(7) = ITB_Obj_Method_Final_Score_Instances_by_Entropy(7) + ITB_Final_Sum_of_Scores
                AW_Obj_Method_Final_Score_Instances_by_Entropy(7) = AW_Obj_Method_Final_Score_Instances_by_Entropy(7) + AW_Final_Sum_of_Scores
                EAW_Obj_Method_Final_Score_Instances_by_Entropy(7) = EAW_Obj_Method_Final_Score_Instances_by_Entropy(7) + EAW_Final_Sum_of_Scores
                Elements_at_Entropy(7) = Elements_at_Entropy(7) + 1
            End If
            If 0.7 <= Entropy_at_Sequence And Entropy_at_Sequence < 0.8 Then
                ITB_Obj_Method_Final_Score_Instances_by_Entropy(8) = ITB_Obj_Method_Final_Score_Instances_by_Entropy(8) + ITB_Final_Sum_of_Scores
                AW_Obj_Method_Final_Score_Instances_by_Entropy(8) = AW_Obj_Method_Final_Score_Instances_by_Entropy(8) + AW_Final_Sum_of_Scores
                EAW_Obj_Method_Final_Score_Instances_by_Entropy(8) = EAW_Obj_Method_Final_Score_Instances_by_Entropy(8) + EAW_Final_Sum_of_Scores
                Elements_at_Entropy(8) = Elements_at_Entropy(8) + 1
            End If
            If 0.8 <= Entropy_at_Sequence And Entropy_at_Sequence < 0.9 Then
                ITB_Obj_Method_Final_Score_Instances_by_Entropy(9) = ITB_Obj_Method_Final_Score_Instances_by_Entropy(9) + ITB_Final_Sum_of_Scores
                AW_Obj_Method_Final_Score_Instances_by_Entropy(9) = AW_Obj_Method_Final_Score_Instances_by_Entropy(9) + AW_Final_Sum_of_Scores
                EAW_Obj_Method_Final_Score_Instances_by_Entropy(9) = EAW_Obj_Method_Final_Score_Instances_by_Entropy(9) + EAW_Final_Sum_of_Scores
                Elements_at_Entropy(9) = Elements_at_Entropy(9) + 1
            End If
            If 0.9 <= Entropy_at_Sequence Then
                ITB_Obj_Method_Final_Score_Instances_by_Entropy(10) = ITB_Obj_Method_Final_Score_Instances_by_Entropy(10) + ITB_Final_Sum_of_Scores
                AW_Obj_Method_Final_Score_Instances_by_Entropy(10) = AW_Obj_Method_Final_Score_Instances_by_Entropy(10) + AW_Final_Sum_of_Scores
                EAW_Obj_Method_Final_Score_Instances_by_Entropy(10) = EAW_Obj_Method_Final_Score_Instances_by_Entropy(10) + EAW_Final_Sum_of_Scores
                Elements_at_Entropy(10) = Elements_at_Entropy(10) + 1
            End If

        Next

        'Determine average sum of scores for the object methods:
        For m = 1 To Number_of_Object_Players
            Obj_Method_Avg_Sum_of_Scores(m) = Obj_Method_Running_Sum_of_Scores(m) / Event_Sequences_Real
        Next

        'Determine average sum of scores for ITB and AW:
        ITB_Avg_Sum_of_Scores = ITB_Running_Sum_of_Scores / Event_Sequences_Real
        AW_Avg_Sum_of_Scores = AW_Running_Sum_of_Scores / Event_Sequences_Real
        EAW_Avg_Sum_of_Scores = EAW_Running_Sum_of_Scores / Event_Sequences_Real

        'Determine average sum of scores by entropy level:
        For y = 1 To 10
            If Not Elements_at_Entropy(y) = 0 Then
                For m = 1 To Number_of_Object_Players
                    Obj_Method_Final_Score_Instances_by_Entropy(m, y) = Obj_Method_Final_Score_Instances_by_Entropy(m, y) / Elements_at_Entropy(y)
                Next
                ITB_Obj_Method_Final_Score_Instances_by_Entropy(y) = ITB_Obj_Method_Final_Score_Instances_by_Entropy(y) / Elements_at_Entropy(y)
                AW_Obj_Method_Final_Score_Instances_by_Entropy(y) = AW_Obj_Method_Final_Score_Instances_by_Entropy(y) / Elements_at_Entropy(y)
                EAW_Obj_Method_Final_Score_Instances_by_Entropy(y) = EAW_Obj_Method_Final_Score_Instances_by_Entropy(y) / Elements_at_Entropy(y)
            Else
                For m = 1 To Number_of_Object_Players
                    Obj_Method_Final_Score_Instances_by_Entropy(m, y) = -1
                Next
                ITB_Obj_Method_Final_Score_Instances_by_Entropy(y) = -1
                AW_Obj_Method_Final_Score_Instances_by_Entropy(y) = -1
                EAW_Obj_Method_Final_Score_Instances_by_Entropy(y) = -1
            End If
        Next

        For r = 1 To Event_Seq_Length
            Mean_ITB_Regret(r) = Mean_ITB_Regret(r) / Event_Sequences_d
            Mean_AW_Regret(r) = Mean_AW_Regret(r) / Event_Sequences_d
            Mean_EAW_Regret(r) = Mean_EAW_Regret(r) / Event_Sequences_d
        Next

    End Sub

End Class