`BeforeIT.Aggregates`

— TypeThis 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

`BeforeIT.Bank`

— TypeThis 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

`BeforeIT.CentralBank`

— TypeThis 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

`BeforeIT.Firms`

— TypeThis 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 `i`

th 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

`BeforeIT.Government`

— TypeThis 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 <- ??

`BeforeIT.Model`

— TypeThis 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

`BeforeIT.RestOfTheWorld`

— TypeThis 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 <- ??

`BeforeIT.Workers`

— TypeThis 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 `i`

th 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

`BeforeIT._bank_deposits`

— Method`_deposit_bank(waD_h, wiD_h, fD_h, bD_h, fD_i, bE_k, fL_i)`

Helper function to calculate the new deposits of a bank.

**Arguments**

`waD_h`

: Array of deposits from active workers`wiD_h`

: Array of deposits from inactive workers`fD_h`

: Array of deposits from firms`bD_h`

: Deposits from the bank owner`fD_i`

: Array of deposits from firms`bE_k`

: Bank equity`fL_i`

: Array of loans to firms

**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.

`BeforeIT._bank_profits`

— Method`_bank_profits(L_i, D_i, D_h, D_k, r_bar, r)`

Helper function to calculate the total profits of a bank.

**Arguments**

`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

**Returns**

`Pi_k`

: Total profits of the bank

The total profits `Pi_k`

are calculated as follows:

\[\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)\]

`BeforeIT._central_bank_profits`

— Method`_central_bank_profits(r_bar, D_k, L_G, r_G)`

Helper function to calculate the profits of a central bank.

**Arguments**

`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

**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}\]

`BeforeIT.bank_deposits`

— Method`deposits_bank(bank, w_act, w_inact, firms)`

Calculate the new deposits of a bank.

**Arguments**

`bank`

: The`Bank`

object containing the bank of the model`w_act`

: The`Workers`

object containing the active workers of the model`w_inact`

: The`Workers`

object containing the inactive workers of the model`firms`

: The`Firms`

object containing the firms of the model

**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.

`BeforeIT.bank_equity`

— Method`bank_equity(bank, model)`

Calculate the net profits of a bank.

**Arguments**

`bank`

: The bank object.`model`

: The model object.

**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\]

`BeforeIT.bank_expected_profits`

— Method`bank_expected_profits(Pi_k, pi_e, gamma_e)`

Calculate the expected profits of a bank.

**Arguments**

`Pi_k`

: Past profits of the bank`pi_e`

: Expected inflation rate`gamma_e`

: Expected growth rate

**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)\]

`BeforeIT.bank_profits`

— Method`bank_profits(bank, model)`

Calculate the total profits of a bank.

**Arguments**

`bank`

: The bank object.`model`

: The model object.

**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)\]

`BeforeIT.bank_rate`

— Method`bank_rate(bank, model)`

Update the interest rate set by the bank.

**Arguments**

`bank`

: The bank whose interest rate is to be updated`model`

: Model object

**Returns**

`r`

: The updated interest rate

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

`BeforeIT.central_bank_equity`

— Method`central_bank_equity(cb, model)`

Calculate the equity of the central bank.

**Arguments**

`cb`

: The central bank`model`

: The model object

**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.

`BeforeIT.central_bank_rate`

— Method`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

`BeforeIT.date2num`

— Method` datenum(d::Dates.DateTime)`

Converts a Julia DateTime to a MATLAB style DateNumber. MATLAB represents time as DateNumber, a double precision floating point number being the the number of days since January 0, 0000 Example datenum(now())

`BeforeIT.finance_insolvent_firms!`

— Method`finance_insolvent_firms!(firms, bank, P_bar_CF, zeta_b, insolvent)`

Rifinance insolvent firms using bank equity.

**Arguments**

`firms`

: The`Firms`

object containing the firms of the model`bank`

: The`Bank`

object containing the bank of the model`P_bar_CF`

: Capital price index`zeta_b`

: Parameter of loan-to-capital ratio for new firms after bankruptcy

**Returns**

- This function does not return a value. It modifies the
`banks`

and`firms`

collections in-place.

`BeforeIT.firms_deposits`

— Method`firms_deposits(firms, model)`

Calculate the new deposits of firms.

**Arguments**

`firms`

: Firms object`model`

: Model object

**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`

`BeforeIT.firms_equity`

— Method`firms_equity(firms, model)`

Calculate the equity of firms.

**Arguments**

`firms`

: Firms object`model`

: Model object

**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

`BeforeIT.firms_expectations_and_decisions`

— Method`firms_expectations_and_decisions(firms, 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.

**Arguments**

`firms`

: Firms object`model`

: Model object

**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

`BeforeIT.firms_loans`

— Method`firms_loans(firms, model)`

Calculate the new loans of firms.

**Arguments**

`firms`

: Firms object`model`

: Model object

**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

`BeforeIT.firms_production`

— Method`firms_production(firms)`

Calculate the production of firms.

**Arguments**

`firms`

: Firms object

**Returns**

`Y_i`

: Vector of production

The production `Y_i`

is computed using a Leontief technology.

`BeforeIT.firms_profits`

— Method`firms_profits(firms, model)`

Calculate the profits of firms.

**Arguments**

`firms`

: Firms object`model`

: Model object

**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))`

`BeforeIT.firms_stocks`

— Method`firms_stocks(firms)`

Calculate the stocks of firms.

**Arguments**

`firms`

: Firms object

**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
```

`BeforeIT.firms_wages`

— Method`firms_wages(firms)`

Calculate the wages set by firms.

**Arguments**

`firms`

: Firms object

**Returns**

`w_i`

: Vector of wages

`BeforeIT.gov_expenditure`

— Method`gov_expenditure(gov::AbstractGovernment, model)`

Computes government expenditure on consumption and transfers to households.

**Arguments**

`gov::AbstractGovernment`

: government object`model`

: model object

**Returns**

`C_G`

: government consumption`C_d_j`

: local government consumptions

`BeforeIT.gov_loans`

— Method`gov_loans(gov::AbstractGovernment, model, Y_G)`

Computes government new government debt.

**Arguments**

`gov::AbstractGovernment`

: government object`model`

: model object

**Returns**

`L_G`

: new government debt

`BeforeIT.gov_revenues`

— Method`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.

**Arguments**

`model`

: model object

**Returns**

`Y_G`

: government revenues

`BeforeIT.gov_social_benefits`

— Method`gov_social_benefits(gov::AbstractGovernment, model)`

Computes social benefits paid by the government households.

**Arguments**

`gov::AbstractGovernment`

: government object`model`

: model object

**Returns**

`sb_other`

: social benefits for other households`sb_inact`

: social benefits for inactive households

`BeforeIT.growth_inflation_EA`

— Method`growth_inflation_EA(rotw, epsilon_Y_EA)`

Update the growth and inflation of the economic area.

**Arguments**

`rotw`

: A RestOfTheWorld object`epsilon_Y_EA`

: Random shock to GDP

**Returns**

`Y_EA`

: GDP of the economic area`gamma_EA`

: Growth rate of GDP of the economic area`pi_EA`

: Inflation rate of the economic area

The GDP `Y_EA`

, the growth rate `gamma_EA`

and the inflation rate `pi_EA`

of the economic area are calculated as follows:

\[Y_{EA} = exp(\alpha_Y \cdot \log(Y_{EA}) + \beta_Y + \epsilon_{Y_{EA}})\]

\[\gamma_{EA} = \frac{Y_{EA}}{Y_{EA}} - 1\]

\[\pi_{EA} = exp(\alpha_\pi \cdot \log(1 + \pi_{EA}) + \beta_\pi + \epsilon_{\pi_{EA}}) - 1\]

where `alpha_Y`

, `beta_Y`

, `alpha_pi`

, `beta_pi`

, `epsilon_Y_EA`

and `epsilon_pi_EA`

are estimated using the past log-GDP and inflation data using the `estimate`

function.

`BeforeIT.growth_inflation_expectations`

— Method`growth_expectations(model)`

Calculate the expected growth rate of GDP.

**Arguments**

`model`

: Model object

**Returns**

`Y_e`

: Expected GDP`gamma_e`

: Expected growth rate of GDP`pi_e`

: Expected inflation rate

The expected GDP `Y_e`

and the expected growth rate `gamma_e`

are calculated as follows:

\[Y_e = exp(\alpha_Y \cdot \log(Y_{T^\prime + t - 1}) + \beta_Y + \epsilon_Y)\]

\[\gamma_e = \frac{Y_e}{Y_{T^\prime + t - 1}} - 1\]

where `alpha_Y`

, `beta_Y`

and `epsilon_Y`

are estimated using the past log-GDP data using the `estimate`

function.

The expected inflation rate `pi_e`

is calculated as follows:

\[\pi_e = exp(\alpha_\pi \cdot \pi_{T^\prime + t - 1} + \beta_\pi + \epsilon_\pi) - 1\]

`BeforeIT.inflation_priceindex`

— Method`inflation_priceindex(P_i, Y_i, P_bar)`

Calculate the inflation rate and the global price index.

**Arguments**

`P_i`

: Vector of prices`Y_i`

: Vector of quantities`P_bar`

: Global price index

**Returns**

`inflation`

: Inflation rate`price_index`

: Global price index

The inflation rate `inflation`

and the global price index `price_index`

are calculated as follows:

\[inflation = \log(\frac{\sum_{i=1}^N P_i \cdot Y_i}{\sum_{i=1}^N Y_i \cdot P_{bar}})\]

\[price_index = \frac{\sum_{i=1}^N P_i \cdot Y_i}{\sum_{i=1}^N Y_i}\]

`BeforeIT.initialise_data`

— MethodInitialise the data arrays

`BeforeIT.initialise_model`

— Function`initialise_model(parameters, initial_conditions, T, typeInt = Int64, typeFloat = Float64)`

Initializes the model with given parameters and initial conditions.

Parameters:

- parameters::Dict{String, Any}: A dictionary containing the model parameters.
- initial_conditions::Dict{String, Any}: A dictionary containing the initial conditions.
- T::Int: The time horizon of the model.
- typeInt::DataType (optional, default: Int64): The data type to be used for integer values.
- typeFloat::DataType (optional, default: Float64): The data type to be used for floating-point values.

Returns:

- model::Model: The initialized model.

`BeforeIT.leontief_production`

— Method`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)))\]

`BeforeIT.neg`

— Method`neg(vector) -> vector`

Returns new vector such that all the NaN and positive values in `vector`

to zero. Mimicks min(0, vector) in Matlab. If vector is a scalar returns a scalar.

**Example**

```
julia> vector = [1, 2, 3, NaN, -1 ]
julia> neg(vector)
5-element Vector{Float64}:
0.0
0.0
0.0
0.0
-1.0
```

`BeforeIT.one_epoch!`

— Method`one_epoch!(model; multi_threading = false)`

This function simulates a single epoch the economic model, updating various components of the model based the interactions between different economic agents. It accepts a `model`

object, which encapsulates the state for the simulation, and an optional boolean parameter `multi_threading`

to enable or disable multi-threading.

Key operations performed include:

- Financial adjustments for firms and banks, including insolvency checks and profit calculations.
- Economic expectations and adjustments, such as growth, inflation, and central bank rates.
- Labor and credit market operations, including wage updates and loan processing.
- Household economic activities, including consumption and investment budgeting.
- Government and international trade financial activities, including budgeting and trade balances.
- General market matching and accounting updates to reflect changes in economic indicators and positions.

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

`BeforeIT.pos`

— Method`pos(vector) -> vector`

Returns new vector such that all the NaN and negative values in `vector`

to zero. Mimicks max(0, vector) in Matlab. If vector is a scalar returns a scalar.

**Example**

```
julia> vector = [1, 2, 3, NaN, -1 ]
julia> pos(vector)
5-element Vector{Float64}:
1.0
2.0
3.0
0.0
0.0
```

`BeforeIT.randpl`

— Method`randpl(n, alpha, N)`

Generates n observations distributed as powerlaw

`BeforeIT.rfvar3`

— MethodThis algorithm goes for accuracy without worrying about memory requirements. (simplified version from Dynare)

`ydata`

: dependent variable data matrix`xdata`

: exogenous variable data matrix`lags`

: number of lags`breaks`

: rows in ydata and xdata after which there is a break. This allows for discontinuities in the data (e.g. war years) and for the possibility of adding dummy observations to implement a prior. This must be a column vector. Note that a single dummy observation becomes lags+1 rows of the data matrix, with a break separating it from the rest of the data. The function treats the first lags observations at the top and after each "break" in ydata and xdata as initial conditions.`lambda`

: weight on "co-persistence" prior dummy observations. This expresses belief that when data on*all*y's are stable at their initial levels, they will tend to persist at that level. lambda=5 is a reasonable first try. With lambda<0, the constant term is not included in the dummy observation, so that stationary models with means equal to initial ybar do not fit the prior mean. With lambda>0, the prior implies that large constants are unlikely if unit roots are present.`mu`

: weight on "own persistence" prior dummy observation. Expresses belief that when y_i has been stable at its initial level, it will tend to persist at that level, regardless of the values of other variables. There is one of these for each variable. A reasonable first guess is mu=2.

The program assumes that the first lags rows of ydata and xdata are real data, not dummies. Dummy observations should go at the end, if any. If pre-sample x's are not available, repeating the initial xdata(lags+1,:) row or copying xdata(lags+1:2*lags,:) into xdata(1:lags,:) are reasonable substitutes. These values are used in forming the persistence priors.

`var.snglty`

: 0 usually. If the rhs variable matrix is less than full column rank, this is the amount by which it falls short. Coefficients and residuals are computed with a form of generalized inverse in this case.

`BeforeIT.rotw_deposits`

— Method`rotw_deposits(rotw, tau_EXPORT)`

Calculate the deposits of the rest of the world.

**Arguments**

`rotw`

: The rest of the world object.`tau_EXPORT`

: The export tax.

**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\]

`BeforeIT.rotw_import_export`

— Method`rotw_import_export(rotw, model, pi_e, epsilon_E, epsilon_I)`

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

**Arguments**

`rotw`

: The rest of the world object.`model`

: The model object.

**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.

`BeforeIT.run_n_sims`

— Method`run_n_sims(model, n_sims; shock = NoShock())`

A function that runs `n_sims`

simulations in parallel with multiple threading and returns a vector of data objects of dimension `n_sims`

.

**Arguments**

`model`

: The model configuration used to simulate.`n_sims`

: The number of simulations to run in parallel.

**Returns**

`data_vector`

: A vector containing the data objects collected during each simulation.

`BeforeIT.run_one_sim!`

— Method`run_one_sim!(model; shock = NoShock())`

Run a single simulation based on the provided `model`

. The simulation runs for a number of epochs specified by `model.prop.T`

.

**Arguments**

`model::Model`

: The model configuration used for the simulation.

**Returns**

`data::Data`

: The data collected during the simulation.

**Details**

The function initializes the data using `BeforeIT.initialise_data(model)`

, then iteratively updates the model and data for each epoch using `BeforeIT.one_epoch!(model)`

and `BeforeIT.update_data!(data, model)`

respectively.

**Example**

```julia model = BeforeIT.initialize*model(parameters, initial*conditions, T) data = run*one*sim!(model)

`BeforeIT.search_and_matching!`

— Function`search_and_matching!(model, multi_threading::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.

Args:

- model: The model object
- multi_threading: A boolean indicating whether to use multi-threading for the algorithm. Default is false.

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

`BeforeIT.search_and_matching_credit`

— Method`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.

`BeforeIT.search_and_matching_labour`

— Method`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).

`BeforeIT.sector_specific_priceindex`

— Method`sector_specific_priceindex(firms, rotw, G)`

Calculate the sector-specific price indices.

**Arguments**

`firms`

: A Firms object`rotw`

: A RestOfTheWorld object`G`

: Number of sectors

**Returns**

`vec`

: Vector of sector-specific price indices

The sector-specific price index `vec`

is calculated as follows:

\[vec_g = \frac{\sum_{i=1}^N P_i \cdot Y_i}{\sum_{i=1}^N Y_i}\]

`BeforeIT.taylor_rule`

— Method`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)```\]

`BeforeIT.toannual`

— MethodCalculate the annual sum of values in the input array `ftsa`

by grouping them into blocks of size `m=4`

.

**Parameters**

ftsa : Array An input array containing the values to be grouped into annual sums.

**Returns**

fts : Array An array containing the annual sums of values from `ftsa`

. The array has the same number of rows as `ftsa`

and a number of columns equal to the number of columns in `ftsa`

divided by `m`

.

**Examples**

julia fts = toannual([1 2 3 4 5 6 7 8])

**Output: [10 26]**

end