Code reference

Bit.@object struct YourObjectType{X}(ObjectTypeToInherit) [<: OptionalSupertype]
    extra_property::X
    other_extra_property_with_default::Bool = true
    const other_extra_const_property::Int
    # etc...
end

Define an object struct which includes all fields that YourObjectType has, as well as any additional ones the user may provide. The macro supports all syntaxes that the standard Julia struct command allows for, such as const field declaration or default values for some fields. Additionally, the resulting type will always have a keyword constructor defined for it (using @kwdef).

Using Bit.@object is the recommended way to create types for BeforeIT.jl.

Structs created with Bit.@object by default subtype Bit.AbstractObject. If you want YourObjectType to subtype something other than Bit.AbstractObject, use the optional argument OptionalSupertype.

Usage

The macro Bit.@object has two primary uses:

1. To include the mandatory fields for a particular object in your object struct. In this case you would use one of the minimal object types.
2. A convenient way to include fields from another, already existing struct, thereby establishing a toolkit for "type inheritance" in Julia.

The existing minimal object types are:

• Bit.Workers
• Bit.Firms
• Bit.Bank
• Bit.CentralBank
• Bit.Government
• Bit.RestOfTheWorld
• Bit.Aggregates
• Bit.Data

which describe which fields they will contribute to the new type.

Example

# you can either constrain the type (to Float64 in this case) at definition time
Bit.@object mutable struct CentralBankNew(CentralBank) <: Bit.AbstractCentralBank
    new_field::Float64
end
# or keep it generic so that you can change it at construction time
Bit.@object mutable struct CentralBankNew2{T}(CentralBank) <: Bit.AbstractCentralBank
    new_field::T
end

Consult the CANVAS Extension page in the documentation for a more advanced example on how to use the macro.

This is a Aggregates type. It is used to store the aggregate variables of the economy. Note that t is an integer, while the rest are floats or vectors of floats.

Fields

• Y [vector]: GDP data + predictions
• pi_ [vector]: inflation data + predictions
• P_bar: Global price index
• P_bar_g [vector]: Producer price index for principal good g
• P_bar_HH: Consumer price index
• P_bar_CF: Capital price index
• P_bar_h: CPI_h
• P_bar_CF_h: Capital price index _h
• Y_e: Expected GDP
• gamma_e: Expected growth
• pi_e: Expected inflation
• t: Time index

This is a Bank type. It represents the bank of the model.

Fields

• E_k: equity capital (common equity) of the bank
• Pi_k: Profits of the bank
• Pi_e_k: Expected profits of the bank
• D_k: Residual and balancing item on the bank’s balance sheet
• r: Rate for loans and morgages

Household fields (bank' owner)

• Y_h: Net disposable income of bank owner (investor)
• C_d_h: Consumption budget
• I_d_h: Investment budget
• C_h: Realised consumption
• I_h: Realised investment
• K_h: Capital stock
• D_h: Deposits

This is a CentralBank type. It represents the central bank of the model.

Fields

• r_bar: Nominal interest rate
• r_G: Interest rate on government bonds
• rho: Parameter for gradual adjustment of the policy rate
• r_star: Real equilibrium interest rate
• pi_star: Inflation target by CB
• xi_pi: Weight the CB puts on inflation targeting
• xi_gamma: Weight placed on economic
• E_CB: Central bank equity

This is a Firms type. Each field is an array which stores the values for all the firms in the economy. Note that the G_i, N_i and V_i fields are integers, while the rest are floats.

For all fields the entry at index i corresponds to the ith firm.

Fields

• G_i: Principal product
• alpha_bar_i: Average productivity of labor
• beta_i: Productivity of intermediate consumption
• kappa_i: Productivity of capital
• w_i: Wages
• w_bar_i: Average wage rate
• delta_i: Depreciation rate for capital
• tau_Y_i: Net tax rate on products
• tau_K_i: Net tax rate on production
• N_i: Number of persons employed
• Y_i: Production of goods
• Q_i: Sales of goods
• Q_d_i: Demand for goods
• P_i: Price
• S_i: Inventories
• K_i: Capital, in real terms
• M_i: Intermediate goods/services and raw materials, in real terms
• L_i: Outstanding loans
• pi_bar_i: Operating margin
• D_i: Deposits of the firm
• Pi_i: Profits
• V_i: Vacancies
• I_i: Investments
• E_i: Equity
• P_bar_i: Price index
• P_CF_i: Price index
• DS_i: Differnece in stock of final goods
• DM_i: Difference in stock of intermediate goods
• DL_i: Obtained loans
• DL_d_i: Target loans
• K_e_i: Expected capital
• L_e_i: Expected loans
• Q_s_i: Expected sales
• I_d_i: Desired investments
• DM_d_i: Desired materials
• N_d_i: Desired employment
• Pi_e_i: Expected profits

Household fields (firms' owners)

• Y_h: Net disposable income of firm owner (investor)
• C_d_h: Consumption budget
• I_d_h: Investment budget
• C_h: Realised consumption
• I_h: Realised investment
• K_h: Capital stock
• D_h: Deposits of the owner of the firms

This is a Government type. It represents the government of the model.

Fields

• alpha_G: Autoregressive coefficient for government consumption
• beta_G: Scalar constant for government consumption
• sigma_G: Variance coefficient for government consumption
• Y_G: Government revenues
• C_G: Consumption demand of the general government
• L_G: Loans taken out by the government
• sb_inact: Social benefits for inactive persons
• sb_other: Social benefits for all
• C_d_j [vector]: Local governments consumption demand
• C_j: Realised government consumption
• P_j: Price inflation of government goods <- ??

This is a Model type. It is used to store all the agents of the economy.

Fields

• w_act: Workers that are active
• w_inact: Workers that are inactive
• firms: Firms
• bank: Bank
• cb: CentralBank
• gov: Government
• rotw: RestOfTheWorld
• agg: Aggregates

This is a RestOfTheWorld type. It represents the rest of the world of the model.

Fields

• alpha_E: Autoregressive coefficient for exports
• beta_E: Scalar constant for exports
• sigma_E: Variance coefficient for exports
• alpha_I: Autoregressive coefficient for imports
• beta_I: Scalar constant for imports
• sigma_I: Variance coefficient for imports
• Y_EA: GDP euro area
• gamma_EA: Growth euro area
• pi_EA: Inflation euro area
• alpha_pi_EA: Autoregressive coefficient for euro area inflation
• beta_pi_EA: Autoregressive coefficient for euro area inflation Scalar constant for euro area inflation
• sigma_pi_EA: Variance coefficient for euro area inflation
• alpha_Y_EA: Autoregressive coefficient for euro area GDP
• beta_Y_EA: Autoregressive coefficient for euro area GDP Scalar constant for euro area GDP
• sigma_Y_EA: Variance coefficient for euro area GDP
• D_RoW: Net creditor/debtor position of the national economy to the rest of the world
• Y_I: Supply of imports (in real terms)
• C_E: Total demand for exports
• C_d_l [vector]: Demand for exports of specific product
• C_l: Realised consumption by foreign consumers
• Y_m [vector]: Supply of imports per sector
• Q_m [vector]: Sales for imports per sector
• Q_d_m [vector]: Demand for goods
• P_m [vector]: Price of imports per sector
• P_l: Price inflation of exports <- ??

This is a Workers. Each field is an array which stores the values for all the workers in the economy. Note that the O_h field is an integer, while the rest are floats.

For all fields the entry at index i corresponds to the ith worker.

Fields

• Y_h: Net disposable income of worker owner (investor)
• D_h: Deposits
• K_h: Capital stock
• w_h: Wages (0 if inactive or unemployed)
• O_h: Occupation (0 if unemployed, -1 if inactive)
• C_d_h: Consumption budget
• I_d_h: Investment budget
• C_h: Realised consumption
• I_h: Realised investment

Model(parameters, initial_conditions)

Initializes the model with given parameters and initial conditions.

Parameters:

• parameters: A dictionary containing the model parameters.
• initial_conditions: A dictionary containing the initial conditions.

Returns:

• model::AbstractModel: The initialized model.

update_variables_with_totals!(model::AbstractModel)

Update the variables in the given model with some global quantities obtained from all agents. This is the last step in the initialization process and it must be performed after all agents have been initialized.

Arguments

• model::AbstractModel: The model object to update.

Returns

• Nothing

ensemblerun!(models, T=1; shock! = NoShock(), parallel = true)

A function that runs the models simulations for T steps on each of them.

Arguments

• models: The models to simulate. The models can either be in a Vector or Generator.

• T: the number of steps to perform.

Returns

• models: The updated models.

Example

parameters = Bit.AUSTRIA2010Q1.parameters
initial_conditions = Bit.AUSTRIA2010Q1.initial_conditions
models = (Bit.Model(parameters, initial_conditions) for _ in 1:10)
Bit.ensemblerun!(models, 2)

ensemblerun(model, T, n_sims; shock! = NoShock(), parallel = true)

A function that creates n_sims copies of a model and runs simulations for T steps on each of them.

Arguments

• model::AbstractModel: The base model to be copied.
• T: The number of steps to perform on each model.
• n_sims: The number of model copies to create and simulate.

Keyword Arguments

• shock: The shock to apply during simulation (default: NoShock()).
• parallel: Whether to run simulations in parallel (default: true).

Returns

• models: A vector containing the n_sims updated models after simulation.

Example

parameters = Bit.AUSTRIA2010Q1.parameters
initial_conditions = Bit.AUSTRIA2010Q1.initial_conditions
model = Bit.Model(parameters, initial_conditions)
models = Bit.ensemblerun(model, 2, 10)  # Create 10 copies and run for 2 steps

run!(model, T; shock! = NoShock(), parallel = false)

Run a single simulation based on the provided model. The simulation runs for a number of steps T.

Arguments

• model::AbstractModel: The model configuration used for the simulation.
• T: the number of steps to perform.

Returns

• model::AbstractModel: The model updated during the simulation.

Details

The function iteratively updates the model and data for each step using Bit.step!(model).

Example

parameters = Bit.AUSTRIA2010Q1.parameters
initial_conditions = Bit.AUSTRIA2010Q1.initial_conditions
model = Bit.Model(parameters, initial_conditions)
Bit.run!(model, 2)

Firms(parameters, initial_conditions)

Initialize firms with given parameters and initial conditions.

Arguments

• parameters: The parameters for initializing the firms.
• initial_conditions: The initial conditions for the firms.

Returns

• firms::Firms: The initialized firms.

firms_deposits(model)

Calculate the new deposits of firms.

Returns

• DD_i: Vector of new deposits

The new deposits DD_i are calculated as follows:

DD_i = sales + labour_cost + material_cost + taxes_products + taxes_production + corporate_tax + dividend_payments + interest_payments + interest_received + investment_cost + new_credit + debt_installment

where:

• sales = P_i * Q_i
• labour_cost = (1 + tau_SIF) * w_i * N_i * P_bar_HH
• material_cost = -DM_i * P_bar_i
• taxes_products = -tau_Y_i * P_i * Y_i
• taxes_production = -tau_K_i * P_i * Y_i
• corporate_tax = -tau_FIRM * pos(Pi_i)
• dividend_payments = -theta_DIV * (1 - tau_FIRM) * pos(Pi_i)
• interest_payments = -r * (L_i + pos(-D_i))
• interest_received = r_bar * pos(D_i)
• investment_cost = -P_CF_i * I_i
• new_credit = DL_i
• debt_installment = -theta * L_i

firms_equity(model)

Calculate the equity of firms.

Returns

• E_i: Vector of equity

The equity E_i is calculated as follows:

\[E_i = D_i + M_i * \sum(a_{sg}[:, G_i] * \bar{P}_g) + P_i * S_i + \bar{P}_{CF} * K_i - L_i\]

where:

• D_i: Deposits
• M_i: Intermediate goods
• a_sg: Technology coefficient of the gth product in the sth industry
• G_i: Vector of goods
• P_bar_g: Producer price index for principal good g
• P_i: Price
• S_i: Stock
• P_bar_CF: Capital price index
• K_i: Capital stock
• L_i: Loans

firms_expectations_and_decisions(model)

Calculate the expectations and decisions of firms. That is: compute firm quantity, price, investment and intermediate-goods, employment decisions, expected profits, and desired/expected loans and capital.

Returns

• Q_s_i: Vector of desired quantities
• I_d_i: Vector of desired investments
• DM_d_i: Vector of desired intermediate goods
• N_d_i: Vector of desired employment
• Pi_e_i: Vector of expected profits
• DL_d_i: Vector of desired new loans
• K_e_i: Vector of expected capital
• L_e_i: Vector of expected loans
• P_i: Vector of prices

firms_loans(model)

Calculate the new loans of firms.

Returns

• L_i: Vector of new loans

The new loans L_i are calculated as follows:

\[L_i = (1 - theta) * L_i + DL_i\]

where:

• theta: Rate of repayment
• L_i: Loans
• DL_i: Acquired new loans

firms_production(model)

Calculate the production of firms.

Returns

• Y_i: Vector of production

The production Y_i is computed using a Leontief technology.

firms_profits(model)

Calculate the profits of firms.

Returns

• Pi_i: Vector of profits

The profits Pi_i are calculated as follows:

Pi_i = in_sales + in_deposits - out_wages - out_expenses - out_depreciation - out_taxes_prods - out_taxes_capital - out_loans

where:

• in_sales = P_i * Q_i + P_i * DS_i
• in_deposits = r_bar * pos(D_i)
• out_wages = (1 + tau_SIF) * w_i * N_i * P_bar_HH
• out_expenses = 1 / beta_i * P_bar_i * Y_i
• out_depreciation = delta_i / kappa_i * P_CF_i * Y_i
• out_taxes_prods = tau_Y_i * P_i * Y_i
• out_taxes_capital = tau_K_i * P_i * Y_i
• out_loans = r * (L_i + pos(-D_i))

firms_stocks(model)

Calculate the stocks of firms.

Returns

• K_i: Vector of capital stock
• M_i: Vector of intermediate goods
• DS_i: Vector of differneces in stock of final goods
• S_i: Vector of stock of final goods

The stocks are calculated as follows:

K_i = K_i - delta_i / kappa_i * Y_i + I_i
M_i = M_i - Y_i / beta_i + DM_i
DS_i = Y_i - Q_i
S_i = S_i + DS_i

firms_wages(model)

Calculate the wages set by firms.

Returns

• w_i: Vector of wages

leontief_production(Q_s_i, N_i, alpha_i, K_i, kappa_i, M_i, beta_i)

Calculate the production function of firms.

Arguments

• Q_s_i: Vector of desired quantities
• N_i: Vector of employment
• alpha_i: Vector of labour productivity
• K_i: Vector of capital stock
• kappa_i: Vector of capital productivity
• M_i: Vector of intermediate goods
• beta_i: Vector of intermediate goods productivity

Returns

• Y_i: Vector of production

The Leontief production function Y_i is calculated as follows:

\[Y_i = \min(Q_s_i, \min(N_i \cdot \alpha_i, \min(K_i \cdot \kappa_i, M_i \cdot \beta_i)))\]

Government(parameters, initial_conditions)

Initialize the government agent.

Arguments

• parameters: The parameters.
• initial_conditions: The initial conditions.

Returns

• The initialized government model.

gov_expenditure(model)

Computes government expenditure on consumption and transfers to households.

Returns

• C_G: government consumption
• C_d_j: local government consumptions

gov_loans(model)

Computes government new government debt.

Returns

• L_G: new government debt

gov_revenues(model)

Computes government revenues from taxes and social security contributions. The government collects taxes on labour income, capital income, value added, and corporate income. It also collects social security contributions from workers and firms. The government also collects taxes on consumption and capital formation. Finally, the government collects taxes on exports and imports.

Returns

• Y_G: government revenues

gov_social_benefits(model)

Computes social benefits paid by the government households.

Returns

• sb_other: social benefits for other households
• sb_inact: social benefits for inactive households

bank_deposits(model)

Calculate the new deposits of a bank.

Returns

• D_k: New deposits of the bank

The new deposits D_k are calculated as the sum of the deposits of the active workers, the inactive workers, the firms, and the bank owner itself, plus the bank's equity, minus the loans of the firms.

bank_equity(model)

Calculate the net profits of the bank.

Returns

• E_k: The updated equity of the bank.

The net profits DE_k are calculated as:

\[DE_k = \Pi_k - \theta_{DIV} \cdot (1 - \tau_{FIRM}) \cdot \max(0, \Pi_k) - \tau_{FIRM} \cdot \max(0, \Pi_k)\]

and the equity E_k is updated as:

\[E_k = E_k + DE_k\]

bank_expected_profits(model)

Calculate the expected profits of a bank.

Returns

• E_Pi_k: Expected profits of the bank

The expected profits E_Pi_k are calculated as follows:

\[E_{\Pi_k} = \Pi_k \cdot (1 + \pi_e) \cdot (1 + \gamma_e)\]

where

• Pi_k: Past profits of the bank
• pi_e: Expected inflation rate
• gamma_e: Expected growth rate

bank_profits(model)

Calculate the total profits of the bank.

Returns

• Pi_k: The total profits of the bank.

The total profits Pi_k are calculated as:

\[\Pi_k = r \cdot \sum_i(L_i + \max(0, -D_i)) + r \cdot \sum_h(\max(0, -D_h)) + r_{bar} \cdot \max(0, D_k) - r_{bar} \cdot \sum_i(\max(0, D_i)) - r_{bar} \cdot \sum_h(\max(0, D_h)) - r_{bar} \cdot \max(0, -D_k)\]

where

• L_i: Array of loans provided by the bank
• D_i: Array of deposits from firms
• D_h: Array of deposits from households
• D_k: Residual and balancing item on the bank’s balance sheet
• r_bar: Base interest rate
• r: Interest rate set by the bank

bank_rate(model)

Update the interest rate set by the bank.

Returns

• r: The updated interest rate

\[r = \bar{r} + \mu\]

central_bank_equity(model)

Calculate the equity of the central bank.

Returns

• E_CB: The equity of the central bank

The equity E_CB is calculated as follows:

\[E_{CB} = E_{CB} + \Pi_{CB}\]

where \Pi_{CB} are the profits of the central bank.

central_bank_profits(cb, model)

Function to calculate the profits of a central bank.

Returns

• Pi_CB: Profits of the central bank

The profits Pi_CB are calculated as follows:

\[\{Pi}_{CB} = r_{G} \cdot L_{G} - r_{bar} \cdot D_{k}\]

where

• r_bar: The base interest rate
• D_k: Deposits from commercial banks
• L_G: Loans provided to the government
• r_G: Interest rate on government loans

central_bank_rate(cb, model)

Update the base interest rate set by the central bank according to the Taylor rule.

Arguments

• cb: The central bank whose base interest rate is to be updated
• model: The model object

Returns

• r_bar: The updated base interest rate

finance_insolvent_firms!(model)

Re-finance insolvent firms using bank equity.

taylor_rule(rho, r_bar, r_star, pi_star, xi_pi, xi_gamma, gamma_EA, pi_EA)

Calculate the interest rate according to the Taylor rule.

Arguments

• rho: Parameter for gradual adjustment of the policy rate.
• r_bar: Nominal interest rate.
• r_star: Real equilibrium interest rate.
• pi_star: The target inflation rate.
• xi_pi: Weight the CB puts on inflation targeting.
• xi_gamma: Weight placed on economic growth.
• gamma_EA: The output growth rate.
• pi_EA: The inflation rate.

Returns

• rate: The calculated interest rate.

The Taylor rule is given by the following equation:

\[r_t = ρ * r_{t-1} + (1 - ρ) * (r^* + π^* + ξ_π * (π_t - π^*) + ξ_γ * γ_t)```\]

rotw_deposits(model)

Calculate the deposits of the rest of the world.

Returns

• D_RoW: The deposits of the rest of the world.

The deposits D_RoW are calculated as follows:

\[D_{RoW} = D_{RoW} + \left( \sum_{m} P_m \cdot Q_m \right) - (1 + \tau_{EXPORT}) \cdot C_l\]

rotw_import_export(model)

Calculate the demand for exports and supply of imports of the rest of the world.

Returns

• C_E: Total demand for exports.
• Y_I: Supply of imports (in real terms).
• C_d_l: TDemand for exports of specific product.
• Y_m: Supply of imports per sector.
• P_m: Price of imports per sector.

search_and_matching_credit!(firms::Firms, model)

This function calculates the credit allocation for each firm in the given firms object.

Parameters:

• firms::Firms: The firms object.
• model: The model object.

Returns:

• DL_i: An array of credit allocations for each firm.

search_and_matching_labour!(firms::Firms, model)

This function implements a labor search and matching algorithm. It takes in a Firms object and a Model object as input. The Firms object contains information about the number of desired employees (N_d_i) and the current number of employees (N_i) for each firm. The model object contains information about the current employment status (O_h) of each worker.

The function performs the following steps:

• Calculates the vacancies (V_i) for each firm as the difference between desired and current employees.
• Identifies employed workers and shuffles them randomly.
• Fires workers from firms with negative vacancies to adjust the workforce.
• Identifies unemployed workers and firms with positive vacancies.
• Randomly matches unemployed workers to firms with vacancies until all vacancies are filled or there are no more unemployed workers.

The function returns:

• N_i: An updated array of the number of employed workers for each firm.
• O_h: An updated array where each element represents the firm a worker is employed with (0 if unemployed).

Perform the firms market exchange process

Perform the retail market exchange process

search_and_matching!(model; parallel::Bool = false)

This function performs a search and matching algorithm for firms and for retail markets. It takes in a model object and an optional boolean argument for multi-threading. The function loops over all goods and performs the firms market and retail market operations for each good. Finally, it updates the aggregate variables based on the results of markets.

This function updates the model in-place and does not return any value.