Skip to content
TheChatArchiveThe Chat Archive
gpt-4-0314· openaiHugging Face Suzhen/CodeChat

Definiowanie parametrów Uwaga kod jest pisany na kolenie wiec lepiej zawsze przed…

  1. User

    Definiowanie parametrów Uwaga kod jest pisany na kolenie wiec lepiej zawsze przed odpaleniem

    sim na nowo zdefiniowac zmienne

    liczba_rowerow_na_stacji = [10,10,10,10,10] brak_roweru = [0,0,0,0,0] overrun=[0,0,0,0,0] popyt_stacji = [0.3, 0.3, 0.2, 0.1, 0.1] prawdopodobienstwo_stacji=[ 0.05 0.45 0.3 0.1 0.1; 0.43 0.07 0.1 0.2 0.2; 0.34 0.2 0.06 0.2 0.2; 0.2 0.2 0.2 0.05 0.35; 0.1 0.1 0.1 0.67 0.03] wynik_sim_init = [liczba_rowerow_na_stacji,brak_roweru,overrun]

    Pojedyncze wyporzyczenie i oddanie roweru

    function single_sim(wynik_sim=wynik_sim_init, prawdopodobienstwo_stacji= prawdopodobienstwo_stacji, popyt_stacji=popyt_stacji) stacja_odebrania = rand(Categorical(popyt_stacji)) stacja_oddania = rand(Categorical(prawdopodobienstwo_stacji[stacja_odebrania,:])) if wynik_sim[1][stacja_odebrania] >= 1 wynik_sim[1][stacja_odebrania] -= 1 wynik_sim[1][stacja_oddania] += 1 if wynik_sim[1][stacja_oddania]>=15 wynik_sim[3][stacja_oddania] +=1 wynik_sim[1][stacja_oddania] -=3 wynik_sim[1][argmin(wynik_sim[1])] +=3 end else wynik_sim[2][stacja_odebrania] += 1 end return wynik_sim end

    x razy single_sim

    function run_day(liczba_dzienna, wynik_sim = wynik_sim_init, prawdopodobienstwo_stacji=prawdopodobienstwo_stacji) wynik_sim_init = deepcopy(wynik_sim) for i in range(1,liczba_dzienna) wynik_sim = single_sim(wynik_sim_init, prawdopodobienstwo_stacji, popyt_stacji) end return wynik_sim end

    x razy single_sim, ale zapamietuje wyniki z konca symulacji

    function run_day_cum(liczba_dzienna, wynik_sim = wynik_sim_init, prawdopodobienstwo_stacji=prawdopodobienstwo_stacji) for i in range(1,liczba_dzienna) wynik_sim = single_sim(wynik_sim, prawdopodobienstwo_stacji, popyt_stacji) end return wynik_sim end

    x razy single_sim, ale kazdy "dzien" liczony od nowa

    function run_sims(liczba_sim = 30, liczba_dzienna = 40, wynik_sim = wynik_sim_init, prawdopodobienstwo_stacji = prawdopodobienstwo_stacji) wynik_sim_init = deepcopy(wynik_sim) wyniki_okresu = DataFrame(dzien = Int[], nr_stacji = Int[], liczba_na_koniec_dnia = Int[], braki_na_koniec_dnia = Int[], przewoz=Int[]) for i in range(1,liczba_sim) wynik_dnia = run_day(liczba_dzienna, wynik_sim, prawdopodobienstwo_stacji) temp_df = DataFrame(dzien = [i,i,i,i,i], nr_stacji = repeat(1:5,1),liczba_na_koniec_dnia = wynik_dnia[1], braki_na_koniec_dnia = wynik_dnia[2],przewoz=wynik_dnia[3]) wyniki_okresu = vcat(wyniki_okresu, temp_df) wynik_sim = wynik_sim_init end wynik_sim = wynik_sim_init return wyniki_okresu end

    x razy single_sim, ale dni są "połączone" ze sobą

    function run_sims_cum(liczba_sim = 30, liczba_dzienna = 40, wynik_sim = wynik_sim_init, prawdopodobienstwo_stacji = prawdopodobienstwo_stacji) wyniki_okresu = DataFrame(dzien = Int[], nr_stacji = Int[], liczba_na_koniec_dnia = Int[], braki_na_koniec_dnia = Int[],przewoz=Int[]) for i in range(1,liczba_sim) wynik_dnia = run_day_cum(liczba_dzienna, wynik_sim_init, prawdopodobienstwo_stacji) temp_df = DataFrame(dzien = [i,i,i,i,i], nr_stacji = repeat(1:5,1),liczba_na_koniec_dnia = wynik_dnia[1], braki_na_koniec_dnia = wynik_dnia[2],przewoz=wynik_dnia[3]) wyniki_okresu = vcat(wyniki_okresu, temp_df) end wynik_sim = wynik_sim_init return wyniki_okresu end

    Wyniki nieskumulowanych wyników

    liczba_rowerow_na_stacji = [10,10,10,10,10] brak_roweru = [0,0,0,0,0] overrun=[0,0,0,0,0] popyt_stacji = [0.3, 0.3, 0.2, 0.1, 0.1] prawdopodobienstwo_stacji=[ 0.05 0.45 0.3 0.1 0.1; 0.43 0.07 0.1 0.2 0.2; 0.34 0.2 0.06 0.2 0.2; 0.2 0.2 0.2 0.05 0.35; 0.1 0.1 0.1 0.67 0.03] wynik_sim_init = [deepcopy(liczba_rowerow_na_stacji), deepcopy(brak_roweru),deepcopy(overrun)] wyniki_okresu = run_sims()

    In the above Julia simulation I think there is a key element missing: time. How to add time to those events and remeber that multiple bikes can travel at the same time. Write code if possible.

  2. Assistant

    To include time in the simulation, we can add a new variable czas to the wynik_sim state and update it every time an event occurs. Here's the modified code that incorporates time into the simulation:

    using Random, StatsBase, DataFrames
    
    liczba_rowerow_na_stacji = [10, 10, 10, 10, 10]
    brak_roweru = [0, 0, 0, 0, 0]
    overrun = [0, 0, 0, 0, 0]
    czas = 0
    popyt_stacji = [0.3, 0.3, 0.2, 0.1, 0.1]
    prawdopodobienstwo_stacji = [
        0.05 0.45 0.3 0.1 0.1;
        0.43 0.07 0.1 0.2 0.2;
        0.34 0.2 0.06 0.2 0.2;
        0.2 0.2 0.2 0.05 0.35;
        0.1 0.1 0.1 0.67 0.03]
    wynik_sim_init = [liczba_rowerow_na_stacji, brak_roweru, overrun, czas]
    
    function single_sim(wynik_sim = wynik_sim_init,
                        prawdopodobienstwo_stacji = prawdopodobienstwo_stacji,
                        popyt_stacji = popyt_stacji,
                        czas_przejazdu = 1)
        stacja_odebrania = rand(Categorical(popyt_stacji))
        stacja_oddania = rand(Categorical(prawdopodobienstwo_stacji[stacja_odebrania, :]))
        wynik_sim[4] += czas_przejazdu
        if wynik_sim[1][stacja_odebrania] >= 1
            wynik_sim[1][stacja_odebrania] -= 1
            wynik_sim[1][stacja_oddania] += 1
            
            if wynik_sim[1][stacja_oddania] >= 15
                wynik_sim[3][stacja_oddania] += 1
                wynik_sim[1][stacja_oddania] -= 3
                wynik_sim[1][argmin(wynik_sim[1])] += 3
            end
        else
            wynik_sim[2][stacja_odebrania] += 1
        end
        return wynik_sim
    end
    
    
    function run_day(liczba_dzienna,
                    wynik_sim = wynik_sim_init,
                    prawdopodobienstwo_stacji = prawdopodobienstwo_stacji,
                    czas_przejazdu = 1)
        wynik_sim_init = deepcopy(wynik_sim)
        for i in range(1, liczba_dzienna)
            wynik_sim = single_sim(wynik_sim_init, prawdopodobienstwo_stacji, popyt_stacji, czas_przejazdu)
        end
        return wynik_sim
    end
    
    function run_sims(liczba_sim = 30,
                    liczba_dzienna = 40,
                    wynik_sim = wynik_sim_init,
                    prawdopodobienstwo_stacji = prawdopodobienstwo_stacji,
                    czas_przejazdu = 1)
        wynik_sim_init = deepcopy(wynik_sim)
        wyniki_okresu = DataFrame(dzien=Int[], czas=Float64[], nr_stacji=Int[], 
                                liczba_na_koniec_dnia = Int[], braki_na_koniec_dnia = Int[], przewoz=Int[])
        for i in range(1, liczba_sim)
            wynik_dnia = run_day(liczba_dzienna, wynik_sim, prawdopodobienstwo_stacji, czas_przejazdu)
            temp_df = DataFrame(dzien=fill(i,5), czas=fill(wynik_dnia[4],5), nr_stacji=1:5,
                             liczba_na_koniec_dnia=wynik_dnia[1], braki_na_koniec_dnia=wynik_dnia[2], przewoz=wynik_dnia[3])
            wyniki_okresu = vcat(wyniki_okresu, temp_df)
            wynik_sim = wynik_sim_init
        end
        wynik_sim = wynik_sim_init
        return wyniki_okresu
    end
    
    wynik_sim_init = [deepcopy(liczba_rowerow_na_stacji), deepcopy(brak_roweru), deepcopy(overrun), czas]
    wyniki_okresu = run_sims()
    

    The added czas variable and czas_przejazdu variable represent the current time and travel time, respectively. The czas variable is initialized with a value of 0, and it is increased by the czas_przejazdu value in every successful journey in the single_sim function. Then it will be passed in the run_day and run_sims functions accordingly.

    In this example, I set the czas_przejazdu to 1, meaning that each journey takes 1 unit of time, but you can modify it to different values or distributions as needed.

  3. User

    Actually, the issue with time is that bikes travel instantly between stations. Some bikes can still be in travel and demand for bikes should also be reported over time. This means that logs must be updated over time and some bikes can still be in travel between stations.

  4. Assistant

    In this case, we need to keep track of the bikes that are currently traveling between stations and update their status over time. To do this, we can store a list of ongoing journeys and their remaining time. Here's an updated code snippet to handle this situation:

    using Random, StatsBase, DataFrames
    
    liczba_rowerow_na_stacji = [10, 10, 10, 10, 10]
    brak_roweru = [0, 0, 0, 0, 0]
    overrun = [0, 0, 0, 0, 0]
    czas = 0
    popyt_stacji = [0.3, 0.3, 0.2, 0.1, 0.1]
    prawdopodobienstwo_stacji = [
        0.05 0.45 0.3 0.1 0.1;
        0.43 0.07 0.1 0.2 0.2;
        0.34 0.2 0.06 0.2 0.2;
        0.2 0.2 0.2 0.05 0.35;
        0.1 0.1 0.1 0.67 0.03]
    ongoing = []  # Keep track of ongoing journeys
    wynik_sim_init = [liczba_rowerow_na_stacji, brak_roweru, overrun, czas]
    
    function single_sim(wynik_sim = wynik_sim_init,
                        prawdopodobienstwo_stacji = prawdopodobienstwo_stacji,
                        popyt_stacji = popyt_stacji,
                        czas_przejazdu = 1,
                        ongoing_journeys = ongoing)
        # First update ongoing journeys
        for i in length(ongoing_journeys):-1:1
            journey = ongoing_journeys[i]
            journey[3] -= czas_przejazdu
            if journey[3] <= 0
                # The journey is completed
                wynik_sim[1][journey[2]] += 1  # Add the bike to the destination station
                if wynik_sim[1][journey[2]] >= 15
                    wynik_sim[3][journey[2]] += 1
                    wynik_sim[1][journey[2]] -= 3
                    wynik_sim[1][argmin(wynik_sim[1])] += 3
                end
                # Remove the journey from the ongoing_journeys list
                splice!(ongoing_journeys, i)
            end
        end
        
        stacja_odebrania = rand(Categorical(popyt_stacji))
        stacja_oddania = rand(Categorical(prawdopodobienstwo_stacji[stacja_odebrania, :]))
        
        if wynik_sim[1][stacja_odebrania] >= 1
            wynik_sim[1][stacja_odebrania] -= 1  # Remove a bike from the pickup station
            journey = [stacja_odebrania, stacja_oddania, czas_przejazdu]
            push!(ongoing_journeys, journey)  # Add the journey to the ongoing_journeys list
        else
            wynik_sim[2][stacja_odebrania] += 1  # Increase the number of unavailable bikes
        end
        
        wynik_sim[4] += czas_przejazdu
        return wynik_sim
    end
    

    This code modification tracks ongoing journeys by adding a new variable called ongoing_journeys and recording bike journeys. When a bike is rented, we create a new journey with the starting station, destination station, and remaining time in the journey. The ongoing_journeys list holds those journeys.

    For every time step, the code checks if any ongoing journeys are completed (remaining time <= 0) and returns the bike to the destination station. It also updates the remaining time for ongoing journeys.

    Note that this new addition assumes the journeys always take czas_przejazdu units of time, but you could modify it to have different or random durations when adding the journey to the ongoing_journeys list. In any case, you can now update the single_sim function call by passing the appropriate parameters as required (e.g., czas_przejazdu) when invoking run_day() and run_sims() functions.