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

'This code was used to generate the data for Table 9 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, left click the last line of the main subroutine "Form1_Load" (this stops the program after exectution), 
'and 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 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 Regrets: Mean_ITB_Regret, Mean_AW_Regret, and Mean_EAW_Regret (to get the absolute regrets, multiply by the number of rounds).

Imports Microsoft.Office.Interop
Imports System.Numerics

Public Class Form1
    Dim objApp As Excel.Application
    Dim objBook As Excel._Workbook

    ''for non-contiuous:
    'Dim Number_of_Possible_Event_Values As Integer = 3
    'Dim Possible_Event_Values(Number_of_Possible_Event_Values) As Double

    'Dim Event_Seq_Length As Integer = 10
    'Dim Event_Sequences As BigInteger = Number_of_Possible_Event_Values ^ Event_Seq_Length
    'Dim Event_Sequences_Real As Double = Event_Sequences

    ''for contiuous:
    Dim Event_Seq_Length As Integer = 20
    Dim Event_Sequences As BigInteger = 10000000
    Dim Event_Sequences_Real As Double = Event_Sequences

    Dim RandomClass As New Random()

    'Dim Game_Matrix(Event_Seq_Length, Event_Sequences) As Double
    Dim Game_Holder(Event_Seq_Length) As Double

    Dim Zeros_Count As Integer
    Dim Ones_Count As Integer

    Dim Event_Avg As Double = 0

    'Dim ttb_fav_count(2) As Integer

    Dim tester(2048) As Integer
    Dim testercounter As Integer

    Dim Number_of_Object_Players As Integer = 4

    Dim Obj_Method_Predictions(Number_of_Object_Players, Event_Seq_Length) As Double
    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
    Dim Obj_Method_Final_Score_Instances(Number_of_Object_Players, 21) As Double
    Dim Magnif_Obj_Method_Final_Score_Instances(Number_of_Object_Players, 5) As Double
    Dim Obj_Method_Avg_Sum_of_Scores(Number_of_Object_Players) As Double
    Dim Obj_Method_Sum_of_Scores_Trascript(Number_of_Object_Players, Event_Sequences) As Double

    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 Double
    Dim Magnif_ITB_Final_Score_Instances(5) As Double
    Dim ITB_Avg_Sum_of_Scores As Double
    Dim ITB_Sum_of_Scores_Trascript(Event_Sequences) 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 Double
    Dim Magnif_AW_Final_Score_Instances(5) As Double
    Dim AW_Avg_Sum_of_Scores As Double
    Dim AW_Sum_of_Scores_Trascript(Event_Sequences) 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 Double
    Dim Magnif_EAW_Final_Score_Instances(5) As Double
    Dim EAW_Avg_Sum_of_Scores As Double
    Dim EAW_Sum_of_Scores_Trascript(Event_Sequences) As Double

    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

    'Dim Test As Integer
    Dim Holder1 As Double
    Dim Holder2 As Integer

    Dim Num_Holder As Double
    Dim Den_Holder As Double

    Dim Type_Counter(Event_Seq_Length) As Integer
    Dim Instances_Counter(Event_Seq_Length) As Integer

    ''Open a spreadsheet in which data can be load, with columns corresponding to object/events and row to cues (and the actual outcome):
    'Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
    '    Dim objBooks As Excel.Workbooks
    '    Dim objSheets As Excel.Sheets
    '    Dim objSheet As Excel._Worksheet
    '    Dim range As Excel.Range

    '    ' Create a new instance of Excel and start a new workbook.
    '    objApp = New Excel.Application()
    '    objBooks = objApp.Workbooks
    '    objBook = objBooks.Add
    '    objSheets = objBook.Worksheets
    '    objSheet = objSheets(1)

    '    range = objSheet.Range("A1", Reflection.Missing.Value)
    '    range = range.Resize(100000, Event_Seq_Length)

    '    Dim saRet(Event_Seq_Length, Event_Sequences) As Double

    '    'Set the range value to the array.
    '    range.Value = saRet

    '    'Return control of Excel to the user.
    '    objApp.Visible = True
    '    objApp.UserControl = True

    '    'Clean up a little.
    '    range = Nothing
    '    objSheet = Nothing
    '    objSheets = Nothing
    '    objBooks = Nothing

    'End Sub

    Private Sub Button2_Click(sender As Object, e As EventArgs) Handles Button2.Click

        'Possible_Event_Values(1) = 0.1
        'Possible_Event_Values(2) = 0.3
        'Possible_Event_Values(3) = 0.5
        'Possible_Event_Values(4) = 0.7
        'Possible_Event_Values(5) = 0.9
        'Possible_Event_Values(1) = 1
        ''Possible_Event_Values(2) = 0
        'Possible_Event_Values(1) = 0.1
        'Possible_Event_Values(2) = 0.5
        'Possible_Event_Values(3) = 0.9

        'for non-contiuous:
        '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

        Randomize()

        For g = 1 To Event_Sequences

            Ones_Count = 0
            Zeros_Count = 0
            Event_Avg = -1

            For r = 1 To Event_Seq_Length

                'for non-contiuous:
                '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 g = 976563 And r = 10 Then 'for testing
                '    r = r
                'End If

                'for contiuous:
                Game_Holder(r) = RandomClass.NextDouble()

                'If Game_Holder(r) >= 0.5 Then
                '    Game_Holder(r) = 1
                'Else
                '    Game_Holder(r) = 0
                'End If

                'If Ones_Count > Zeros_Count Then
                '    Obj_Method_Predictions(1, r) = 1
                '    Obj_Method_Predictions(2, r) = 0
                'Else
                '    If Ones_Count < Zeros_Count Then
                '        Obj_Method_Predictions(1, r) = 0
                '        Obj_Method_Predictions(2, r) = 1
                '    Else
                '        Obj_Method_Predictions(1, r) = 0.5
                '        Obj_Method_Predictions(2, r) = 0.5
                '        'Obj_Method_Predictions(1, r) = 1
                '        'Obj_Method_Predictions(2, r) = 1
                '    End If
                'End If
                ''Obj_Method_Predictions(3, r) = 1
                ''Obj_Method_Predictions(4, r) = 0

                'If Game_Holder(r) = 1 Then
                '    Ones_Count = Ones_Count + 1
                'Else
                '    Zeros_Count = Zeros_Count + 1
                'End If

                If Event_Avg = -1 Then
                    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

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

                    End If

                    Obj_Method_Predictions(4, r) = 0.5

                End If

                Event_Avg = 0
                For z = 1 To r
                    Event_Avg = Event_Avg + Game_Holder(z)
                Next
                Event_Avg = Event_Avg / r
                'Event_Avg = ((Event_Avg * (r - 1)) + Game_Matrix(r, g)) / r

                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)) 'score score score score score score score score score score score score score score score score
                    'Obj_Method_Score_at_Round(m, r) = 1 - Math.Abs(Game_Holder(r) - Obj_Method_Predictions(m, r)) * Math.Abs(Game_Holder(r) - Obj_Method_Predictions(m, r)) 'score score score score score score score score score score score score score score score score

                    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
                    'Obj_Method_Validity_as_of_Round(m, r) = ((Obj_Method_Validity_as_of_Round(m, r - 1) * (r - 1)) + Obj_Method_Score_at_Round(m, r)) / 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
                    'ttb_fav_count(Holder2) = ttb_fav_count(Holder2) + 1
                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
                    'ttb_fav_count(Holder2) = ttb_fav_count(Holder2) + 1
                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))  'score score score score score score score score score score score score score score score score
                'ITB_Score_at_Round(r) = 1 - Math.Abs(Game_Holder(r) - ITB_Predictions(r)) * Math.Abs(Game_Holder(r) - ITB_Predictions(r)) 'score score score score score score score score score score score score score score score score

                Holder1 = 0
                For y = 1 To r
                    Holder1 = Holder1 + ITB_Score_at_Round(y)
                Next
                ITB_Validity_as_of_Round(r) = Holder1 / r
                'ITB_Validity_as_of_Round(r) = ((ITB_Validity_as_of_Round(r - 1) * (r - 1)) + ITB_Score_at_Round(r)) / 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
                'If AW_Predictions(r) >= 0.5 Then
                '    AW_Predictions(r) = 1
                'Else
                '    AW_Predictions(r) = 0
                'End If

                AW_Score_at_Round(r) = 1 - Math.Abs(Game_Holder(r) - AW_Predictions(r)) 'score score score score score score score score score score score score score score score score
                'AW_Score_at_Round(r) = 1 - Math.Abs(Game_Holder(r) - AW_Predictions(r)) * Math.Abs(Game_Holder(r) - AW_Predictions(r)) 'score score score score score score score score score score score score score score score score

                Holder1 = 0
                For y = 1 To r
                    Holder1 = Holder1 + AW_Score_at_Round(y)
                Next
                AW_Validity_as_of_Round(r) = Holder1 / r
                'AW_Validity_as_of_Round(r) = ((AW_Validity_as_of_Round(r - 1) * (r - 1)) + AW_Score_at_Round(r)) / 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)) 'score score score score score score score score score score score score score score score score
                'EAW_Score_at_Round(r) = 1 - Math.Abs(Game_Holder(r) - EAW_Predictions(r)) * Math.Abs(Game_Holder(r) - EAW_Predictions(r)) 'score score score score score score score score score score score score score score score score

                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

            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)

            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)

            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)

            ITB_Sum_of_Scores_Trascript(g) = ITB_Validity_as_of_Round(Event_Seq_Length) * Event_Seq_Length
            AW_Sum_of_Scores_Trascript(g) = AW_Validity_as_of_Round(Event_Seq_Length) * Event_Seq_Length
            EAW_Sum_of_Scores_Trascript(g) = EAW_Validity_as_of_Round(Event_Seq_Length) * Event_Seq_Length
            For m = 1 To Number_of_Object_Players
                Obj_Method_Sum_of_Scores_Trascript(m, g) = Obj_Method_Validity_as_of_Round(m, Event_Seq_Length) * Event_Seq_Length
            Next

        Next

        For m = 1 To Number_of_Object_Players
            'For g = 1 To Event_Sequences
            '    Obj_Method_Avg_Sum_of_Scores(m) = Obj_Method_Avg_Sum_of_Scores(m) + Obj_Method_Final_Sum_of_Scores(m, g)
            'Next
            Obj_Method_Avg_Sum_of_Scores(m) = Obj_Method_Running_Sum_of_Scores(m) / Event_Sequences_Real
        Next

        'For g = 1 To Event_Sequences
        '    ITB_Avg_Sum_of_Scores = ITB_Avg_Sum_of_Scores + ITB_Final_Sum_of_Scores(g)
        '    AW_Avg_Sum_of_Scores = AW_Avg_Sum_of_Scores + AW_Final_Sum_of_Scores(g)
        '    'EW_Avg_Sum_of_Scores = EW_Avg_Sum_of_Scores + EW_Final_Sum_of_Scores(g)
        'Next
        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

        'EW_Avg_Sum_of_Scores = EW_Avg_Sum_of_Scores / Event_Sequences

        'Calculate Unrorrected Sample Std Deviation:
        Dim ITB_Sample_Std_Dev As Double = 0
        Dim ITB_Std_Error As Double = 0
        For x = 1 To Event_Sequences
            ITB_Sample_Std_Dev = ITB_Sample_Std_Dev + ((ITB_Sum_of_Scores_Trascript(x) - ITB_Avg_Sum_of_Scores) * (ITB_Sum_of_Scores_Trascript(x) - ITB_Avg_Sum_of_Scores))
        Next
        ITB_Sample_Std_Dev = ITB_Sample_Std_Dev / Event_Sequences_Real
        ITB_Sample_Std_Dev = Math.Sqrt(ITB_Sample_Std_Dev)
        ITB_Std_Error = ITB_Sample_Std_Dev / Math.Sqrt(Event_Sequences_Real)

        Dim AW_Sample_Std_Dev As Double = 0
        Dim AW_Std_Error As Double = 0
        For x = 1 To Event_Sequences
            AW_Sample_Std_Dev = AW_Sample_Std_Dev + ((AW_Sum_of_Scores_Trascript(x) - AW_Avg_Sum_of_Scores) * (AW_Sum_of_Scores_Trascript(x) - AW_Avg_Sum_of_Scores))
        Next
        AW_Sample_Std_Dev = AW_Sample_Std_Dev / Event_Sequences_Real
        AW_Sample_Std_Dev = Math.Sqrt(AW_Sample_Std_Dev)
        AW_Std_Error = AW_Sample_Std_Dev / Math.Sqrt(Event_Sequences_Real)

        Dim Obj_Method_Sample_Std_Dev(Number_of_Object_Players) As Double
        Dim Obj_Method_Std_Error(Number_of_Object_Players) As Double
        For m = 1 To Number_of_Object_Players
            For x = 1 To Event_Sequences
                Obj_Method_Sample_Std_Dev(m) = Obj_Method_Sample_Std_Dev(m) + ((Obj_Method_Sum_of_Scores_Trascript(m, x) - Obj_Method_Avg_Sum_of_Scores(m)) * (Obj_Method_Sum_of_Scores_Trascript(m, x) - Obj_Method_Avg_Sum_of_Scores(m)))
            Next
            Obj_Method_Sample_Std_Dev(m) = Obj_Method_Sample_Std_Dev(m) / Event_Sequences_Real
            Obj_Method_Sample_Std_Dev(m) = Math.Sqrt(Obj_Method_Sample_Std_Dev(m))
            Obj_Method_Std_Error(m) = Obj_Method_Sample_Std_Dev(m) / Math.Sqrt(Event_Sequences_Real)
        Next

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

        ''calculate as percentages:
        'For m = 1 To Number_of_Object_Players
        '    For y = 1 To 20
        '        Obj_Method_Final_Score_Instances(m, y) = Obj_Method_Final_Score_Instances(m, y) / Event_Sequences_Real
        '        Obj_Method_Final_Score_Instances(m, y) = Obj_Method_Final_Score_Instances(m, y) * 100
        '    Next
        'Next

        'For y = 1 To 20
        '    ITB_Final_Score_Instances(y) = ITB_Final_Score_Instances(y) / Event_Sequences_Real
        '    AW_Final_Score_Instances(y) = AW_Final_Score_Instances(y) / Event_Sequences_Real
        '    EAW_Final_Score_Instances(y) = EAW_Final_Score_Instances(y) / Event_Sequences_Real
        '    ITB_Final_Score_Instances(y) = ITB_Final_Score_Instances(y) * 100
        '    AW_Final_Score_Instances(y) = AW_Final_Score_Instances(y) * 100
        '    EAW_Final_Score_Instances(y) = EAW_Final_Score_Instances(y) * 100
        'Next

    End Sub

End Class