<jupyter_start><jupyter_text>Voetbalcompetitie met <NAME> zijn de meegeleverde kansen.Uitleg ("how to read"): De drie getallen in een veld geven de win-/gelijkspel-/verlieskans aan voor de thuisspelende partij (voor de uitspelende partij is winst en verlies natuurlijk omgedraaid). Bijv. voor de wedstrijd Ajax - PSV, zoek de rij van Ajax in de linkerkolom (thuisspelende partij) en daarbij de juiste kolom met PSV als uitspelend: 54/21/25. Deze waarden betekenen op een volgende dat: de thuisspelende partij (Ajax dus) met 54% kans gaat winnen, met 21% kans gelijk speelt of met 25% kans verliest van de uitspelende partij (PSV dus).<jupyter_code>display(Image.open('images/Screenshot 2021-12-17 at 10.31.43.png'))
def draw_randomness(rng, normalizer = 1):
    img = Image.new('1', (200, 200))
    pixels = img.load()
    for x in range(img.size[0]):
        for y in range(img.size[1]):
            random_number = rng.next() / normalizer # TODO: replace with RNG call
            pixels[x, y] = 0 if random_number < 0.5 else 1
    return img<jupyter_output><empty_output><jupyter_text>De opdrachtEerst worden er een aantal RNG's gemaakt vervolgens zal de simulatie gemaakt worden.  RNGEr zullen een aantal RNG's aangeleverd worden met ieder z'n voor en nadelen.  Middle square<jupyter_code>def select_middle(number, positions):
    left = True
    while len(str(number)) > positions:
        if left:
            number = int(str(number)[1:])
            left = False
        else:
            number = int(str(number)[:-1])
            left = True
    return number


class MidSquareGen:
    def __init__(self, seed):
        self.seed = seed

    def reset(self, seed):
        self.seed = seed

    def next(self):
        self.seed = select_middle(self.seed**2, 4)
        return self.seed / 10000.0
middle_square = MidSquareGen(12345)<jupyter_output><empty_output><jupyter_text>Voor het valideren van de rng ga ik 2 technieken gebruiken.Dit is de eerste, hierbij word op basis van de resultaten van de rng een afbeelding getekend. In deze afbeelding zou je patronen kunnen herkennen op het moment dat de rng niet random is. Zoals hieronder, hier kan je zo'n patroon zien dit is de afbeelding met de random numbers van de middel square generator.<jupyter_code>display(draw_randomness(middle_square))<jupyter_output><empty_output><jupyter_text>Ook heb ik de Pseudorandom Number Sequence Test Program uitgevoerd hieronder de resultaten.<jupyter_code>display(Image.open('images/Entropy_Middle.png'))<jupyter_output><empty_output><jupyter_text>LCG<jupyter_code>class LCG:
    def __init__(self, seed, a, b, m):
        self.seed = seed
        self.a = a
        self.b = b
        self.m = m

    def change_seed(self, seed):
        self.seed = seed

    def next(self):
        self.seed = (self.a * self.seed + self.b) % self.m
        return self.seed
mod = 2**14
lcg = LCG(1, 544321, 121245, mod)<jupyter_output><empty_output><jupyter_text>Voor het valideren van de rng ga ik 2 technieken gebruiken. Dit is de eerste, hierbij word op basis van de resultaten van de rng een afbeelding getekend. In deze afbeelding zou je patronen kunnen herkennen op het moment dat de rng niet random is. Bij de vorige was een duidelijk patroon te zien maar bij deze RNG is dit al veel minder bij deze generator.<jupyter_code>display(draw_randomness(lcg, mod))<jupyter_output><empty_output><jupyter_text>Ook heb ik de Pseudorandom Number Sequence Test Program uitgevoerd hieronder de resultaten.<jupyter_code>display(Image.open('images/Entropy_LCG.png'))<jupyter_output><empty_output><jupyter_text>LFGDeze rng ben ik helaas niet meer helemaal aan toe gekomen maar ik laat hem er wel in staan zodat ik hier later mee verder kan werken.<jupyter_code>class LFG:
    def __init__(self, seed, j, k):
        self.seed = seed
        self.j = j
        self.k = k

    def generate_list(self):
        print(self.lagfib(self.seed))

    def next(self, n):
        return self.lagfib(n - self.j) + self.lagfib(n - self.k) % 2**32<jupyter_output><empty_output><jupyter_text>Monte Carlo SimulatieEerst maak ik een panda's dataframe met de win/gelijk/verlies kansen.<jupyter_code>odds = pd.read_csv('odds.csv', names = ['Ajax', 'Feyenoord', 'PSV', 'FC Utrecht', 'Willem II'])
odds<jupyter_output><empty_output><jupyter_text>Vervolgens maak ik een helper functie die gebruikt gaat worden voor het berekenen van een win. Hierin word een random nummer gegenereerd en vervolgens word bepaald of er gewonnen, verloren of gelijkspel is. Vervolgens word het punten aantal terug gestuurd.<jupyter_code>def calc_win(odd, rng, devider=1):
    odd = odd.split('/')
    odd = [int(x) / 100 for x in odd if x != '']
    random_number = rng.next() / devider

    if random_number <= odd[0]:
        # Gewonnen == 0
        # print("Gewonnen")
        return 3
    elif odd[0] < random_number <= odd[1]:
        # Gelijkspel == 1
        # print("Gelijkspel")
        return 1
    else:
        # Verloren == 0
        # print("Verloren")
        return 0<jupyter_output><empty_output><jupyter_text>Hier word een competitie uitgespeeld hierin worden alle teams tegen elkaar opgezet en een eindstand bepaald<jupyter_code>def competitie(rng, modulo=1):
    score = {
        "Ajax": 0,
        "Feyenoord": 0,
        "FC Utrecht": 0,
        "Willem II": 0,
        "PSV": 0
    }

    for home_team, values in odds.iterrows():
        for away_team, chance in values.iteritems():
            if chance != '/':
                punten = calc_win(chance, rng, modulo)

                # Punten toewijzen
                score[home_team] += punten

                # Bij gelijkspel beide teams een punt
                if punten == 1:
                    score[away_team] += punten

    return score
print([competitie(lcg, mod) for i in range(1)])<jupyter_output>[{'Ajax': 6, 'Feyenoord': 6, 'FC Utrecht': 0, 'Willem II': 3, 'PSV': 9}]<jupyter_text>Hier word de competitie een x aantal keer uitgevoerd en vervolgens de percentages van het eindresultaat getoont.<jupyter_code>def get_win_chances(n, rng, modulo=1):

    result = pd.DataFrame(0, columns = ['1st pos', '2nd pos', '3rd pos', '4th pos', '5th pos'], index = ['Ajax', 'Feyenoord', 'PSV', 'FC Utrecht', 'Willem II'])

    positions = ['1st pos', '2nd pos', '3rd pos', '4th pos', '5th pos']

    for _ in range(n):
        results_comp = competitie(rng, modulo)

        # Sort the dictionary
        results_comp = {k: v for k, v in sorted(results_comp.items(), key = lambda item: item[1], reverse = True)}

        last_points = 0
        skip = False
        x = 0

        for team, points in results_comp.items():

            result[positions[x]].loc[team] = result[positions[x]].loc[team] + 1


            if last_points == points:
                skip = True
                continue

            last_points = points

            if skip:
                x += 2
                skip = False
            else:
                x += 1

    percent_tabel = result.div(result.sum(axis=1), axis=0).mul(100).round(2)
    percent_tabel = percent_tabel.astype('string').add('%')

    return percent_tabel

resultaat = get_win_chances(1000, lcg, mod)
resultaat<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.1015256588072122, 'fraction_numerical': 0.018030513176144243, 'mean_word_length': 3.132378223495702, 'pattern_counts': {'":': 5, '<': 53, '<?xml version=': 0, '>': 50, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '12', 'dir': 'jupyter-structured-clean-dedup', 'id': '182585', 'license': 'MIT', 'n_tokens_mistral': 2609, 'n_tokens_neox': 2474, 'n_words': 739, 'path': 'main.ipynb', 'repo_name': 'StanHaakman/Monte-Carlo-Voetbalcompetitie', 'size': '7219'}