Use import BeforeIT as Bit everywhere (#43)

Author: Tortar

README.md

@@ -62,14 +62,14 @@ Pkg.instantiate()
 Now you should be able to run the the following code
 
 ```julia
-using BeforeIT
+import BeforeIT as Bit
 
-parameters = BeforeIT.AUSTRIA2010Q1.parameters
-initial_conditions = BeforeIT.AUSTRIA2010Q1.initial_conditions
+parameters = Bit.AUSTRIA2010Q1.parameters
+initial_conditions = Bit.AUSTRIA2010Q1.initial_conditions
 
 T = 20
-model = BeforeIT.init_model(parameters, initial_conditions, T)
-data = BeforeIT.run!(model)
+model = Bit.init_model(parameters, initial_conditions, T)
+data = Bit.run!(model)
 ```
 
 This will simulate the model with the original Austrian parametrisation for 20 quarters and save the results in the `data` object.

docs/src/index.md

@@ -29,14 +29,14 @@ Pkg.add("BeforeIT")
 To check that the installation worked, try running the model in your terminal with
 
 ```julia
-using BeforeIT
+import BeforeIT as Bit
 
-parameters = BeforeIT.AUSTRIA2010Q1.parameters
-initial_conditions = BeforeIT.AUSTRIA2010Q1.initial_conditions
+parameters = Bit.AUSTRIA2010Q1.parameters
+initial_conditions = Bit.AUSTRIA2010Q1.initial_conditions
 
 T = 20
-model = BeforeIT.initialise_model(parameters, initial_conditions, T)
-data = BeforeIT.run!(model)
+model = Bit.initialise_model(parameters, initial_conditions, T)
+data = Bit.run!(model)
 ```
 
 To plot the results of the simulation, you can use the `Plots` package

examples/basic_example.jl

@@ -3,6 +3,7 @@
 # We start by importing the BeforeIT library and other useful libraries.
 
 import BeforeIT as Bit
+
 using FileIO, Plots
 
 # We then initialise the model loading some precomputed set of parameters and by specifying a number of epochs.
@@ -36,7 +37,7 @@ for t in 1:T
 end
 
 # Note that we can equivalently run the model for a number of epochs in the single command 
-# `data = BeforeIT.run!(model)`, but writing the loop explicitely is more instructive.
+# `data = Bit.run!(model)`, but writing the loop explicitely is more instructive.
 
 # We can then plot any time series stored in the data tracker, for example
 

examples/benchmark_w_matlab.jl

@@ -4,23 +4,25 @@
 # by running the same model for the same number of epochs and measuring
 # the time taken.
 
-using BeforeIT, CairoMakie, Statistics, ThreadPinning
+import BeforeIT as Bit
+
+using CairoMakie, Statistics, ThreadPinning
 
 pinthreads(:cores)
 
 function run(parameters, initial_conditions, T; multi_threading = false)
-    model = BeforeIT.init_model(parameters, initial_conditions, T)
-    data = BeforeIT.init_data(model);
+    model = Bit.init_model(parameters, initial_conditions, T)
+    data = Bit.init_data(model);
 
     for _ in 1:T
-        BeforeIT.step!(model; multi_threading = multi_threading)
-        BeforeIT.update_data!(data, model)
+        Bit.step!(model; multi_threading = multi_threading)
+        Bit.update_data!(data, model)
     end
     return model, data
 end
 
-parameters = BeforeIT.AUSTRIA2010Q1.parameters
-initial_conditions = BeforeIT.AUSTRIA2010Q1.initial_conditions
+parameters = Bit.AUSTRIA2010Q1.parameters
+initial_conditions = Bit.AUSTRIA2010Q1.initial_conditions
 T = 12
 
 # We run the code to compile it first

examples/change_expectations.jl

@@ -4,6 +4,7 @@
 # different expectations of the agents in the model.
 
 import BeforeIT as Bit
+
 using Random, Plots
 
 # Import standard parameters and initial conditions
@@ -22,8 +23,7 @@ data = Bit.run!(model)
 # We will change the function `estimate_next_value` to make the agents expect 
 # the last value of the time series (so to represent backward looking expectations)
 
-import BeforeIT: estimate_next_value
-function estimate_next_value(data)
+function Bit.estimate_next_value(data)
     return data[end]
 end
 

examples/compare_model_vs_real.jl

@@ -1,10 +1,10 @@
-using BeforeIT
-using MAT, FileIO, Plots, StatsPlots
-using Dates
+import BeforeIT as Bit
+
+using MAT, FileIO, Plots, StatsPlots, Dates
 
 # load data from 1996
 
-real_data = BeforeIT.ITALY_CALIBRATION.data
+real_data = Bit.ITALY_CALIBRATION.data
 
 # load predictions from 2010Q1
 
@@ -48,7 +48,7 @@ function plot_model_vs_real(model, real, varname; crop = true)
     year_ticks = []
     for r in all_tick_numbers
         # get year of r
-        y = year(BeforeIT.num2date(r))
+        y = year(Bit.num2date(r))
         # save year only if it's new
         if !(y in year_ticks)
             push!(num_ticks, r)
@@ -76,7 +76,7 @@ num_ticks = []
 year_ticks = []
 for r in real_data["years_num"]
     # get year of r
-    y = year(BeforeIT.num2date(r))
+    y = year(Bit.num2date(r))
     # save year only if it's new
     if !(y in year_ticks)
         push!(num_ticks, r)

examples/get_parameters_and_initial_conditions.jl

@@ -1,6 +1,7 @@
 # In this tutorial we illustrate how to calibrate the model to the Italian data for a specific quarter
 
 import BeforeIT as Bit
+
 using Dates, FileIO
 
 # We start from loading the calibration object for italy, which contains 

examples/get_predictions.jl

@@ -1,8 +1,9 @@
 # In this tutorial we illustrate how to get predictions from the model for
 # a number of quarters starting from previous simulations.
 
-using BeforeIT, FileIO
-using Dates
+import BeforeIT as Bit
+
+using FileIO, Dates
 
 year_ = 2010
 number_years = 9
@@ -12,18 +13,18 @@ number_seeds = 4
 number_sectors = 62
 
 # Load the real time series
-data = BeforeIT.ITALY_CALIBRATION.data
+data = Bit.ITALY_CALIBRATION.data
 
 quarters_num = []
 year_m = year_
 for month in 4:3:((number_years + 1) * 12 + 1)
     year_m = year_ + (month ÷ 12)
     mont_m = month % 12
     date = DateTime(year_m, mont_m, 1) - Day(1)
-    push!(quarters_num, BeforeIT.date2num(date))
+    push!(quarters_num, Bit.date2num(date))
 end
 
 for i in 1:number_quarters
     quarter_num = quarters_num[i]
-    BeforeIT.get_predictions_from_sims(data, quarter_num, horizon, number_seeds)
+    Bit.get_predictions_from_sims(data, quarter_num, horizon, number_seeds)
 end

examples/get_simulations.jl

@@ -1,7 +1,9 @@
 # Here we show how to get simulations for all quarters
 # from `2010Q1` to `2019Q4`, and for all years from 2010 to 2019.
 
-using BeforeIT, MAT, FileIO
+import BeforeIT as Bit
+
+using MAT, FileIO
 
 # The following code loads the parameters and initial conditions,
 # it initialises the model, runs the model `n_sims` times, and finally
@@ -15,9 +17,9 @@ for year in 2010:2019
         parameters = load("data/italy/parameters/" * string(year) * "Q" * string(quarter) * ".jld2")
         initial_conditions = load("data/italy/initial_conditions/" * string(year) * "Q" * string(quarter) * ".jld2")
         T = 12
-        model = BeforeIT.init_model(parameters, initial_conditions, T)
+        model = Bit.init_model(parameters, initial_conditions, T)
         n_sims = 4
-        data_vector = BeforeIT.ensemblerun(model, n_sims)
+        data_vector = Bit.ensemblerun(model, n_sims)
         save("data/italy/simulations/" * string(year) * "Q" * string(quarter) * ".jld2", "data_vector", data_vector)
     end
 end

examples/multithreading_speedup.jl

@@ -4,6 +4,7 @@
 # to allow for faster executions of single simulation runs.
 
 import BeforeIT as Bit
+
 using FileIO, Plots, StatsPlots
 
 # First, we initialise the model, this time we use the Italy 2010Q1 scenario, 

examples/scenario_analysis_via_overload.jl

@@ -5,6 +5,7 @@
 # unshocked model.
 
 import BeforeIT as Bit
+
 using Plots, StatsPlots
 
 parameters = Bit.AUSTRIA2010Q1.parameters
@@ -23,9 +24,7 @@ data_vec_baseline = Bit.ensemblerun(model, 4)
 # Now, apply a shock to the model and simulate it again
 # Here, we do this by overloading the central_bank_rate function with the wanted behaviour
 
-import BeforeIT: central_bank_rate
-
-function central_bank_rate(cb::Bit.CentralBank, model::Bit.Model)
+function Bit.central_bank_rate(cb::Bit.CentralBank, model::Bit.Model)
     gamma_EA = model.rotw.gamma_EA
     pi_EA = model.rotw.pi_EA
     taylor_rate = Bit.taylor_rule(cb.rho, cb.r_bar, cb.r_star, cb.pi_star, cb.xi_pi, cb.xi_gamma, gamma_EA, pi_EA)

examples/scenario_analysis_via_shock.jl

@@ -5,6 +5,7 @@
 # results with the unshocked model.
 
 import BeforeIT as Bit
+
 using Plots, StatsPlots
 
 parameters = Bit.AUSTRIA2010Q1.parameters

main.jl

@@ -1,17 +1,18 @@
-using BeforeIT, Random
-using Plots
+import BeforeIT as Bit
 
-parameters = BeforeIT.AUSTRIA2010Q1.parameters
-initial_conditions = BeforeIT.AUSTRIA2010Q1.initial_conditions
+using Random, Plots
+
+parameters = Bit.AUSTRIA2010Q1.parameters
+initial_conditions = Bit.AUSTRIA2010Q1.initial_conditions
 
 T = 20
-model = BeforeIT.init_model(parameters, initial_conditions, T)
-data = BeforeIT.init_data(model)
+model = Bit.init_model(parameters, initial_conditions, T)
+data = Bit.init_data(model)
 
 for t in 1:T
     println("Epoch: ", t)
-    BeforeIT.step!(model; multi_threading = true)
-    BeforeIT.update_data!(data, model)
+    Bit.step!(model; multi_threading = true)
+    Bit.update_data!(data, model)
 end
 
 p1 = plot(data.real_gdp, title = "gdp", titlefont = 10)

src/BeforeIT.jl

@@ -9,6 +9,8 @@ using LinearAlgebra
 using Random
 using StatsBase
 
+const Bit = BeforeIT
+
 # definition of agents
 include("model_init/agents.jl")
 

src/model_init/init.jl

@@ -21,29 +21,29 @@ Returns:
 function init_model(parameters::Dict{String, Any}, initial_conditions::Dict{String, Any}, T, typeInt::DataType = Int64, typeFloat::DataType = Float64)
 
     # properties
-    properties = BeforeIT.init_properties(parameters, T; typeInt = typeInt, typeFloat = typeFloat)
+    properties = Bit.init_properties(parameters, T; typeInt = typeInt, typeFloat = typeFloat)
 
     # firms
-    firms, _ = BeforeIT.init_firms(parameters, initial_conditions; typeInt = typeInt, typeFloat = typeFloat)
+    firms, _ = Bit.init_firms(parameters, initial_conditions; typeInt = typeInt, typeFloat = typeFloat)
 
     # workers, and update firms vacancies
-    workers_act, workers_inact, V_i_new, _, _ = BeforeIT.init_workers(parameters, initial_conditions, firms; typeInt = typeInt, typeFloat = typeFloat)
+    workers_act, workers_inact, V_i_new, _, _ = Bit.init_workers(parameters, initial_conditions, firms; typeInt = typeInt, typeFloat = typeFloat)
     firms.V_i = V_i_new
 
     # bank
-    bank, _ = BeforeIT.init_bank(parameters, initial_conditions, firms; typeInt = typeInt, typeFloat = typeFloat)
+    bank, _ = Bit.init_bank(parameters, initial_conditions, firms; typeInt = typeInt, typeFloat = typeFloat)
 
     # central bank
-    central_bank, _ = BeforeIT.init_central_bank(parameters, initial_conditions; typeInt = typeInt, typeFloat = typeFloat)
+    central_bank, _ = Bit.init_central_bank(parameters, initial_conditions; typeInt = typeInt, typeFloat = typeFloat)
 
     # government
-    government, _ = BeforeIT.init_government(parameters, initial_conditions; typeInt = typeInt, typeFloat = typeFloat)
+    government, _ = Bit.init_government(parameters, initial_conditions; typeInt = typeInt, typeFloat = typeFloat)
 
     # rest of the world
-    rotw, _ = BeforeIT.init_rotw(parameters, initial_conditions; typeInt = typeInt, typeFloat = typeFloat)
+    rotw, _ = Bit.init_rotw(parameters, initial_conditions; typeInt = typeInt, typeFloat = typeFloat)
 
     # aggregates
-    agg, _ = BeforeIT.init_aggregates(parameters, initial_conditions, T; typeInt = typeInt, typeFloat = typeFloat)
+    agg, _ = Bit.init_aggregates(parameters, initial_conditions, T; typeInt = typeInt, typeFloat = typeFloat)
 
     # model
     model = Model(workers_act, workers_inact, firms, bank, central_bank, government, rotw, agg, properties)