Hier is een eenvoudig Fortran-programma dat het gedrag van een wachtrijsysteem simuleert op basis van jouw specificaties: ```fortran program wachtrijsysteem implicit none ! Parameters integer, parameter :: totaal_tijd = 60 ! simulatie tijd in minuten integer, parameter :: delta_t = 1 ! tijdstap in minuten real, parameter :: aankomst_rate = 2.0 ! klanten per minuut real, parameter :: service_rate = 3.0 ! klanten per minuut integer, parameter :: aantal_servers = 1 ! Variabelen integer :: tijd integer :: wachtrij = 0 integer :: klanten_geplaatst = 0 integer :: klanten_dienst = 0 integer :: klanten_verloren = 0 real :: aankomst_prob, service_prob integer :: i ! Data voor analyse integer :: totale_wachttijd = 0 integer :: aantal_klanten = 0 integer, dimension(0:totaal_tijd) :: wachtrij_grootte integer, dimension(0:totaal_tijd) :: wachttijd_per_klant integer :: wachttijd_idx = 0 call random_seed() do tijd = 1, totaal_tijd, delta_t ! Bepaal aankomst van klanten aankomst_prob = aankomst_rate * delta_t if (random() < aankomst_prob) then ! Klant komt binnen klanten_geplaatst = klanten_geplaatst + 1 if (wachtrij == 0 .and. klanten_dienst == 0) then ! Direct service mogelijk klanten_dienst = klanten_dienst + 1 wacht_tijd = 0 wachttijd_per_klant(wachttijd_idx + 1) = wacht_tijd wachttijd_idx = wachttijd_idx + 1 else ! Voeg toe aan wachtrij wachtrij = wachtrij + 1 end if end if ! Bepaal of een klant wordt bediend service_prob = service_rate * delta_t if (klanten_dienst > 0) then if (random() < service_prob) then ! Klant wordt bediend en verlaat klanten_dienst = klanten_dienst - 1 ! Als wachtrij niet leeg is, start met de volgende klant if (wachtrij > 0) then wachtrij = wachtrij - 1 klanten_dienst = klanten_dienst + 1 ! Wachtijd van deze klant is de huidige tijd minus aankomsttijd ! Voor eenvoudige simulatie gaan we uit van de gemiddelde wachtijd ! of houden we geen exacte wachttijd bij in deze basisversie end if end if end if ! Update wachtrijlengte wachtrij_grootte(tijd) = wachtrij end do ! Analyse resultaten ! Voor een meer gedetailleerde analyse moet je wachttijden per klant bijhouden ! Dit voorbeeld geeft een basisstructuur print *, "Simulatie voltooid." print *, "Totaal geplaatste klanten:", klanten_geplaatst print *, "Totaal bediende klanten:", klanten_dienst print *, "Totaal verloren klanten (bijvoorbeeld door time-out):", klanten_verloren print *, "Gemiddelde wachtrijlengte:", sum(wachtrij_grootte) / float(totaal_tijd) end program wachtrijsysteem ``` **Begeleiding voor analyse en interpretatie:** 1. **Gemiddelde wachttijd:** - Om de gemiddelde wachttijd te berekenen, moet je de wachttijd van elke klant bijhouden wanneer ze de wachtrij verlaten. - In bovenstaande code is dat niet volledig uitgewerkt, maar je kunt bijvoorbeeld een array gebruiken om de wachttijden per klant op te slaan. - De gemiddelde wachttijd is dan de som van alle wachttijden gedeeld door het aantal klanten dat bediend is. 2. **Gemiddelde wachtrijlengte:** - Dit wordt berekend door de som van de wachtrijgroottes over de simulatie te delen door het totaal aantal tijdstappen. - Een hoge gemiddelde wachtrijlengte duidt op een druk systeem dat mogelijk moet worden uitgebreid (meer servers) of dat de aankomst-/servicerates moeten worden aangepast. 3. **Interpretatie van resultaten:** - **Lage wachttijden en wachtrijlengte:** Het systeem functioneert efficiënt. - **Hoge wachttijden en wachtrijlengte:** Er is een knelpunt; mogelijk moet het aantal servers worden verhoogd of de service snelheid worden verbeterd. - **Verhouding tussen aankomst- en service-snelheid:** Als de aankomstrate (2 klanten/minuut) gelijk of hoger is dan de service rate (3 klanten/minuut), zal de wachtrij niet blijven groeien, maar als het verschil kleiner wordt, kan de wachtrij toenemen en leiden tot lange wachttijden. **Aanbeveling:** - Voor een gedetailleerdere analyse, voeg code toe om de wachttijden van individuele klanten bij te houden. - Voer meerdere simulaties uit om variaties te begrijpen. - Pas parameters aan en observeer de effecten op wachttijd en wachtrijlengte. Heeft u verdere hulp nodig bij het uitbreiden van de code of de analyse?

Hier is een Fortran-programma dat een wachtrijsysteem (M/M/1-wachtrij) simuleert volgens jouw specificaties, samen met richtlijnen voor analyse: ```fortran program mm1_queue_simulation implicit none ! Parameters real, parameter :: arrival_rate = 2.0/60.0 ! Klanten per seconde real, parameter :: service_rate = 3.0/60.0 ! Klanten per seconde integer, parameter :: total_customers = 1000 ! Totaal te simuleren klanten integer, parameter :: seed = 12345 ! Seed voor random generator ! Variabelen real :: clock, next_arrival, next_departure real :: inter_arrival_time, service_time integer :: queue_length, customers_served real :: total_wait_time, total_queue_length_time real :: max_wait_time, max_queue_length real :: last_event_time ! Prestatie-indicatoren real :: avg_wait_time, avg_queue_length real :: server_utilization ! Initialisatie call srand(seed) clock = 0.0 queue_length = 0 customers_served = 0 total_wait_time = 0.0 total_queue_length_time = 0.0 max_wait_time = 0.0 max_queue_length = 0.0 last_event_time = 0.0 ! Eerste aankomst genereren inter_arrival_time = -log(rand()) / arrival_rate next_arrival = clock + inter_arrival_time next_departure = huge(1.0) ! Oneindig in de toekomst print *, 'M/M/1 Wachtrijsimulatie gestart' print *, '================================' print *, 'Parameters:' print *, '- Aankomstrate: ', arrival_rate*60, ' klanten/minuut' print *, '- Servicerate: ', service_rate*60, ' klanten/minuut' print *, '- Totaal klanten: ', total_customers print *, '' ! Hoofdsimulatielus do while (customers_served < total_customers) ! Tijd bijwerken voor statistieken total_queue_length_time = total_queue_length_time + queue_length * (clock - last_event_time) last_event_time = clock if (next_arrival <= next_departure) then ! Aankomstgebeurtenis clock = next_arrival ! Wachttijd berekenen voor nieuwe klant if (queue_length > 0) then total_wait_time = total_wait_time + (next_departure - clock) end if queue_length = queue_length + 1 max_queue_length = max(max_queue_length, real(queue_length)) ! Volgende aankomst plannen inter_arrival_time = -log(rand()) / arrival_rate next_arrival = clock + inter_arrival_time ! Server starten als deze vrij was if (queue_length == 1) then service_time = -log(rand()) / service_rate next_departure = clock + service_time end if else ! Vertrekgebeurtenis clock = next_departure queue_length = queue_length - 1 customers_served = customers_served + 1 ! Volgende vertrek plannen if (queue_length > 0) then service_time = -log(rand()) / service_rate next_departure = clock + service_time else next_departure = huge(1.0) end if end if end do ! Prestatie-indicatoren berekenen avg_wait_time = total_wait_time / total_customers avg_queue_length = total_queue_length_time / clock server_utilization = (service_rate / arrival_rate) * (1.0 - avg_queue_length / (avg_queue_length + 1.0)) ! Resultaten weergeven print *, 'SIMULATIERESULTATEN' print *, '===================' print *, 'Totaal gesimuleerde tijd: ', clock, ' seconden' print *, 'Totaal bediende klanten: ', customers_served print *, '' print *, 'PRESTATIE-INDICATOREN:' print *, 'Gemiddelde wachttijd: ', avg_wait_time, ' seconden' print *, 'Gemiddelde wachtrijlengte: ', avg_queue_length, ' klanten' print *, 'Maximale wachtrijlengte: ', max_queue_length, ' klanten' print *, 'Serverutilisatie: ', server_utilization * 100, '%' print *, '' end program mm1_queue_simulation ``` ## Analyse en Interpretatie van Resultaten ### Belangrijke Prestatie-indicatoren: 1. **Gemiddelde Wachttijd**: - **Interpretatie**: Hoe lang klanten gemiddeld wachten voordat ze worden geholpen - **Streefwaarde**: Zo laag mogelijk, idealen < 30 seconden in jouw geval - **Formule**: Totale wachttijd / Totaal aantal klanten 2. **Gemiddelde Wachtrijlengte**: - **Interpretatie**: Hoeveel klanten er gemiddeld in de rij staan - **Analyse**: Waarden > 2-3 kunnen wijzen op overbelasting - **Theoretische waarde**: ρ²/(1-ρ) waar ρ = arrival_rate/service_rate 3. **Server Utilisatie**: - **Interpretatie**: Percentage van de tijd dat de server bezig is - **Gezond bereik**: 70-85% voor goede balans - **Jouw geval**: ρ = 2/3 ≈ 66.7% (goede bezettingsgraad) ### Analyse Richtlijnen: 1. **Vergelijk met Theoretische Waarden**: ``` Theoretische gemiddelde wachttijd = ρ/(μ-λ) = 40 seconden Theoretische gemiddelde rijlengte = ρ²/(1-ρ) = 1.33 klanten ``` 2. **Stabiliteitscontrole**: - Zorg dat λ < μ (2 < 3) - systeem is stabiel - Bij λ ≥ μ zou de wachtrij oneindig groeien 3. **Gevoeligheidsanalyse**: - Test met hogere aankomstpercentages (2.5, 2.8 klanten/minuut) - Observeer hoe wachttijden exponentieel toenemen ### Praktische Tips: 1. **Run meerdere simulaties** met verschillende random seeds voor betrouwbaarheid 2. **Verhoog total_customers** naar 10,000 voor stabielere resultaten 3. **Monitor maximale waarden** om piekbelasting te identificeren 4. **Gebruisheidsfactor > 85%** wijst op mogelijke problemen bij piekmomenten De simulatie zou moeten laten zien dat je systeem goed functioneert met de gegeven parameters, maar gevoelig is voor veranderingen in aankomstfrequentie.