change to int

Author: andre_ramos

src/StateSpaceLearning.jl

@@ -82,20 +82,20 @@ function fit_model(y::Vector{Fl};
 end
 
 """
-    forecast(output::Output, steps_ahead::Int64; Exogenous_Forecast::Union{Matrix{Fl}, Missing}=missing)::Vector{Float64} where Fl
+    forecast(output::Output, steps_ahead::Int; Exogenous_Forecast::Union{Matrix{Fl}, Missing}=missing)::Vector{Float64} where Fl
 
     Returns the forecast for a given number of steps ahead using the provided StateSpaceLearning output and exogenous forecast data.
 
     # Arguments
     - `output::Output`: Output object obtained from model fitting.
-    - `steps_ahead::Int64`: Number of steps ahead for forecasting.
+    - `steps_ahead::Int`: Number of steps ahead for forecasting.
     - `Exogenous_Forecast::Matrix{Fl}`: Exogenous variables forecast (default: zeros(steps_ahead, 0))
 
     # Returns
     - `Vector{Float64}`: Vector containing forecasted values.
 
 """
-function forecast(output::Output, steps_ahead::Int64; Exogenous_Forecast::Matrix{Fl}=zeros(steps_ahead, 0))::Vector{Float64} where Fl
+function forecast(output::Output, steps_ahead::Int; Exogenous_Forecast::Matrix{Fl}=zeros(steps_ahead, 0))::Vector{Float64} where Fl
 
     @assert length(output.components["Exogenous_X"]["Indexes"]) == size(Exogenous_Forecast, 2) "If an exogenous matrix was utilized in the estimation procedure, it must be provided its prediction for the forecast procedure. If no exogenous matrix was utilized, Exogenous_Forecast must be missing"
     @assert size(Exogenous_Forecast, 1) == steps_ahead "Exogenous_Forecast must have the same number of rows as steps_ahead"
@@ -107,21 +107,21 @@ function forecast(output::Output, steps_ahead::Int64; Exogenous_Forecast::Matrix
 end
 
 """
-simulate(output::Output, steps_ahead::Int64; N_scenarios::Int64 = 1000, simulate_outliers::Bool = true, Exogenous_Forecast::Matrix{Fl}=zeros(steps_ahead, 0))::Matrix{Float64} where Fl
+simulate(output::Output, steps_ahead::Int; N_scenarios::Int = 1000, simulate_outliers::Bool = true, Exogenous_Forecast::Matrix{Fl}=zeros(steps_ahead, 0))::Matrix{Float64} where Fl
 
     Generate simulations for a given number of steps ahead using the provided StateSpaceLearning output and exogenous forecast data.
 
     # Arguments
     - `output::Output`: Output object obtained from model fitting.
-    - `steps_ahead::Int64`: Number of steps ahead for simulation.
-    - `N_scenarios::Int64`: Number of scenarios to simulate (default: 1000).
+    - `steps_ahead::Int`: Number of steps ahead for simulation.
+    - `N_scenarios::Int`: Number of scenarios to simulate (default: 1000).
     - `simulate_outliers::Bool`: If true, simulate outliers (default: true).
     - `Exogenous_Forecast::Matrix{Fl}`: Exogenous variables forecast (default: zeros(steps_ahead, 0))
 
     # Returns
     - `Matrix{Float64}`: Matrix containing simulated values.
 """
-function simulate(output::Output, steps_ahead::Int64, N_scenarios::Int64; simulate_outliers::Bool = true, 
+function simulate(output::Output, steps_ahead::Int, N_scenarios::Int; simulate_outliers::Bool = true, 
                   innovation_functions::Dict = Dict("stochastic_level" => Dict("create_X" => create_ξ, "component" => "ξ", "args" => (length(output.ε) + steps_ahead + 1, 0)),
                                                 "stochastic_trend" => Dict("create_X" => create_ζ, "component" => "ζ", "args" => (length(output.ε) + steps_ahead + 1, 0, 1)),
                                                 "stochastic_seasonal" => Dict("create_X" => create_ω, "component" => "ω", "args" => (length(output.ε) + steps_ahead + 1, output.model_input["freq_seasonal"], 0, 1))),

src/estimation_procedure/default_estimation_procedure.jl

@@ -25,19 +25,19 @@ function get_dummy_indexes(Exogenous_X::Matrix{Fl}) where{Fl}
 end
 
 """
-    get_outlier_duplicate_columns(Estimation_X::Matrix{Tl}, components_indexes::Dict{String, Vector{Int64}}) where{Tl}
+    get_outlier_duplicate_columns(Estimation_X::Matrix{Tl}, components_indexes::Dict{String, Vector{Int}}) where{Tl}
 
     Identifies and returns the indexes of outlier columns that are duplicates of dummy variables in the exogenous matrix.
 
     # Arguments
     - `Estimation_X::Matrix{Tl}`: Matrix used for estimation.
-    - `components_indexes::Dict{String, Vector{Int64}}`: Dictionary containing indexes for different components.
+    - `components_indexes::Dict{String, Vector{Int}}`: Dictionary containing indexes for different components.
 
     # Returns
     - `Vector{Int}`: Vector containing the indexes of outlier columns that are duplicates of dummy variables in the exogenous matrix.
 
 """
-function get_outlier_duplicate_columns(Estimation_X::Matrix{Tl}, components_indexes::Dict{String, Vector{Int64}}) where{Tl}
+function get_outlier_duplicate_columns(Estimation_X::Matrix{Tl}, components_indexes::Dict{String, Vector{Int}}) where{Tl}
     if !haskey(components_indexes, "o")
         return []
     else
@@ -115,7 +115,7 @@ end
 
 """
     fit_lasso(Estimation_X::Matrix{Tl}, estimation_y::Vector{Fl}, α::Float64, information_criteria::String,
-              penalize_exogenous::Bool, components_indexes::Dict{String, Vector{Int64}}, penalty_factor::Vector{Float64};
+              penalize_exogenous::Bool, components_indexes::Dict{String, Vector{Int}}, penalty_factor::Vector{Float64};
               rm_average::Bool = false)::Tuple{Vector{Float64}, Vector{Float64}} where {Tl, Fl}
 
     Fits a Lasso regression model to the provided data and returns coefficients and residuals based on selected criteria.
@@ -126,15 +126,15 @@ end
     - `α::Float64`: Elastic net control factor between ridge (α=0) and lasso (α=1) (default: 0.1).
     - `information_criteria::String`: Information Criteria method for hyperparameter selection (default: aic).
     - `penalize_exogenous::Bool`: Flag for selecting exogenous variables. When false the penalty factor for these variables will be set to 0.
-    - `components_indexes::Dict{String, Vector{Int64}}`: Dictionary containing indexes for different components.
+    - `components_indexes::Dict{String, Vector{Int}}`: Dictionary containing indexes for different components.
     - `penalty_factor::Vector{Float64}`: Penalty factors for each predictor.
     - `rm_average::Bool`: Flag to consider if the intercept will be calculated is the average of the time series (default: false).
 
     # Returns
     - `Tuple{Vector{Float64}, Vector{Float64}}`: Tuple containing coefficients and residuals of the fitted Lasso model.
 
 """
-function fit_lasso(Estimation_X::Matrix{Tl}, estimation_y::Vector{Fl}, α::Float64, information_criteria::String, penalize_exogenous::Bool, components_indexes::Dict{String, Vector{Int64}}, penalty_factor::Vector{Float64}; rm_average::Bool = false)::Tuple{Vector{Float64}, Vector{Float64}} where {Tl, Fl}
+function fit_lasso(Estimation_X::Matrix{Tl}, estimation_y::Vector{Fl}, α::Float64, information_criteria::String, penalize_exogenous::Bool, components_indexes::Dict{String, Vector{Int}}, penalty_factor::Vector{Float64}; rm_average::Bool = false)::Tuple{Vector{Float64}, Vector{Float64}} where {Tl, Fl}
 
     outlier_duplicate_columns = get_outlier_duplicate_columns(Estimation_X, components_indexes)
     penalty_factor[outlier_duplicate_columns] .= Inf
@@ -168,23 +168,23 @@ end
 """
     fit_adalasso(Estimation_X::Matrix{Tl}, estimation_y::Vector{Fl}, α::Float64,
                  information_criteria::String,
-                 components_indexes::Dict{String, Vector{Int64}},
+                 components_indexes::Dict{String, Vector{Int}},
                  ε::Float64, penalize_exogenous::Bool)::Tuple{Vector{Float64}, Vector{Float64}} where {Tl, Fl}
 
     Fits an Adaptive Lasso (AdaLasso) regression model to the provided data and returns coefficients and residuals.
 
     # Arguments
     - `Estimation_X::Matrix{Tl}`: Matrix of predictors for estimation.
     - `estimation_y::Vector{Fl}`: Vector of response values for estimation.
-    - `components_indexes::Dict{String, Vector{Int64}}`: Dictionary containing indexes for different components.
+    - `components_indexes::Dict{String, Vector{Int}}`: Dictionary containing indexes for different components.
     - `estimation_input::Dict`: Dictionary containing the estimation input parameters.
 
     # Returns
     - `Tuple{Vector{Float64}, Vector{Float64}}`: Tuple containing coefficients and residuals of the fitted AdaLasso model.
 
 """
 function default_estimation_procedure(Estimation_X::Matrix{Tl}, estimation_y::Vector{Fl}, 
-                        components_indexes::Dict{String, Vector{Int64}}, estimation_input::Dict)::Tuple{Vector{Float64}, Vector{Float64}} where {Tl, Fl}
+                        components_indexes::Dict{String, Vector{Int}}, estimation_input::Dict)::Tuple{Vector{Float64}, Vector{Float64}} where {Tl, Fl}
 
     @assert all([key in keys(estimation_input) for key in ["α", "information_criteria", "ϵ", "penalize_exogenous", "penalize_initial_states"]]) "All estimation input parameters must be set"
     α = estimation_input["α"]; information_criteria = estimation_input["information_criteria"]; 

src/information_criteria.jl

@@ -1,21 +1,20 @@
 """
-    get_information(T::Int64, K::Int64, ε::Vector{Float64};
-                    information_criteria::String = "bic", p::Int64 = 0)::Float64
+    get_information(T::Int, K::Int, ε::Vector{Float64};
+                    information_criteria::String = "bic")::Float64
 
     Calculates information criterion value based on the provided parameters and residuals.
 
     # Arguments
-    - `T::Int64`: Number of observations.
-    - `K::Int64`: Number of selected predictors.
+    - `T::Int`: Number of observations.
+    - `K::Int`: Number of selected predictors.
     - `ε::Vector{Float64}`: Vector of residuals.
     - `information_criteria::String`: Method for hyperparameter selection (default: "aic").
-    - `p::Int64`: Number of total predictors (default: 0).
 
     # Returns
     - `Float64`: Information criterion value.
 
 """
-function get_information(T::Int64, K::Int64, ε::Vector{Float64}; information_criteria::String = "aic")::Float64
+function get_information(T::Int, K::Int, ε::Vector{Float64}; information_criteria::String = "aic")::Float64
     if information_criteria == "bic"
         return T*log(var(ε)) + K*log(T)
     elseif information_criteria == "aic"

src/structs.jl

@@ -12,10 +12,10 @@
     - `fitted::Vector`: Fitted values from the model.
     - `components::Dict`: Dictionary containing different components.
     - `residuals_variances::Dict`: Dictionary storing variances of residuals for different components.
-    - `T::Int64`: Integer representing a parameter 'T'.
+    - `T::Int`: Integer representing a parameter 'T'.
     - `outlier::Bool`: Boolean indicating the presence of outlier component.
-    - `valid_indexes::Vector{Int64}`: Vector containing valid indexes (non NaN) of the time series.
-    - `ζ_ω_threshold::Int64`: ζ_ω_threshold parameter.
+    - `valid_indexes::Vector{Int}`: Vector containing valid indexes (non NaN) of the time series.
+    - `ζ_ω_threshold::Int`: ζ_ω_threshold parameter.
     - `y::Vector{Fl}`: Vector of data.
 
 """
@@ -28,5 +28,5 @@ mutable struct Output
     fitted::Vector
     components::Dict
     residuals_variances::Dict
-    valid_indexes::Vector{Int64}
+    valid_indexes::Vector{Int}
 end

src/utils.jl

@@ -1,12 +1,12 @@
 """
-    build_components(X::Matrix{Tl}, coefs::Vector{Float64}, components_indexes::Dict{String, Vector{Int64}}) -> Dict where Tl
+    build_components(X::Matrix{Tl}, coefs::Vector{Float64}, components_indexes::Dict{String, Vector{Int}}) -> Dict where Tl
     
     Constructs components dict containing values, indexes and coefficients for each component.
 
     # Arguments
     - X::Matrix{Tl}: Input matrix.
     - coefs::Vector{Float64}: Coefficients.
-    - components_indexes::Dict{String, Vector{Int64}}: Dictionary mapping component names to their indexes.
+    - components_indexes::Dict{String, Vector{Int}}: Dictionary mapping component names to their indexes.
 
     # Returns
     - components::Dict: Dictionary containing components, each represented by a dictionary with keys:
@@ -15,7 +15,7 @@
         - "Values": Values computed from `X` and component coefficients.
 
 """
-function build_components(X::Matrix{Tl}, coefs::Vector{Float64}, components_indexes::Dict{String, Vector{Int64}})::Dict where Tl
+function build_components(X::Matrix{Tl}, coefs::Vector{Float64}, components_indexes::Dict{String, Vector{Int}})::Dict where Tl
     components = Dict()
     for key in keys(components_indexes)
         components[key] = Dict()
@@ -30,57 +30,57 @@ function build_components(X::Matrix{Tl}, coefs::Vector{Float64}, components_inde
 end
 
 """
-get_fit_and_residuals(estimation_ε::Vector{Float64}, coefs::Vector{Float64}, X::Matrix{Tl}, valid_indexes::Vector{Int64}, T::Int64) -> Tuple{Vector{Float64}, Vector{Float64}} where Tl
+get_fit_and_residuals(estimation_ε::Vector{Float64}, coefs::Vector{Float64}, X::Matrix{Tl}, valid_indexes::Vector{Int}, T::Int) -> Tuple{Vector{Float64}, Vector{Float64}} where Tl
 
     Builds complete residuals and fit in sample. Residuals will contain nan values for non valid indexes. Fit in Sample will be a vector of fitted values computed from input data and coefficients (non valid indexes will also be calculated via interpolation).
 
     # Arguments
     - `estimation_ε::Vector{Float64}`: Vector of estimation errors.
     - `coefs::Vector{Float64}`: Coefficients.
     - `X::Matrix{Tl}`: Input matrix.
-    - `valid_indexes::Vector{Int64}`: Valid indexes.
-    - `T::Int64`: Length of the original time series.
+    - `valid_indexes::Vector{Int}`: Valid indexes.
+    - `T::Int`: Length of the original time series.
 
     # Returns
     - Tuple containing:
         - `ε::Vector{Float64}`: Vector containing NaN values filled with estimation errors at valid indexes.
         - `fitted::Vector{Float64}`: Vector of fitted values computed from input data and coefficients.
 
 """
-function get_fit_and_residuals(estimation_ε::Vector{Float64}, coefs::Vector{Float64}, X::Matrix{Tl}, valid_indexes::Vector{Int64}, T::Int64)::Tuple{Vector{Float64}, Vector{Float64}} where Tl
+function get_fit_and_residuals(estimation_ε::Vector{Float64}, coefs::Vector{Float64}, X::Matrix{Tl}, valid_indexes::Vector{Int}, T::Int)::Tuple{Vector{Float64}, Vector{Float64}} where Tl
     ε      = fill(NaN, T); ε[valid_indexes] = estimation_ε
     fitted = X*coefs
     return ε, fitted
 end
 
 """
-o_size(T::Int64)::Int64
+o_size(T::Int)::Int
 
     Calculates the size of outlier matrix based on the input T.
 
     # Arguments
-    - `T::Int64`: Length of the original time series.
+    - `T::Int`: Length of the original time series.
 
     # Returns
-    - `Int64`: Size of o calculated from T.
+    - `Int`: Size of o calculated from T.
 
 """
-o_size(T::Int64)::Int64 = T
+o_size(T::Int)::Int = T
 
 """
-create_o_matrix(T::Int64, steps_ahead::Int64)::Matrix
+create_o_matrix(T::Int, steps_ahead::Int)::Matrix
 
     Creates a matrix of outliers based on the input sizes, and the desired steps ahead (this is necessary for the forecast function).
 
     # Arguments
-    - `T::Int64`: Length of the original time series.
-    - `steps_ahead::Int64`: Number of steps ahead (for estimation purposes this should be set at 0).
+    - `T::Int`: Length of the original time series.
+    - `steps_ahead::Int`: Number of steps ahead (for estimation purposes this should be set at 0).
     
     # Returns
     - `Matrix`: Matrix of outliers constructed based on the input sizes.
 
 """
-function create_o_matrix(T::Int64, steps_ahead::Int64)::Matrix
+function create_o_matrix(T::Int, steps_ahead::Int)::Matrix
     return vcat(Matrix(1.0 * I, T, T), zeros(steps_ahead, T))
 end
 
@@ -97,9 +97,9 @@ handle_missing_values(X::Matrix{Tl}, y::Vector{Fl}) -> Tuple{Vector{Fl}, Matrix{
     - Tuple containing:
         - `y::Vector{Fl}`: Time series without missing values.
         - `X::Matrix{Tl}`: Input matrix without missing values.
-        - `valid_indexes::Vector{Int64}`: Vector containing valid indexes of the time series.
+        - `valid_indexes::Vector{Int}`: Vector containing valid indexes of the time series.
 """
-function handle_missing_values(X::Matrix{Tl}, y::Vector{Fl})::Tuple{Vector{Fl}, Matrix{Tl}, Vector{Int64}} where {Tl, Fl}
+function handle_missing_values(X::Matrix{Tl}, y::Vector{Fl})::Tuple{Vector{Fl}, Matrix{Tl}, Vector{Int}} where {Tl, Fl}
 
     invalid_indexes = unique(vcat([i[1] for i in findall(i -> any(isnan, i), X)], findall(i -> isnan(i), y)))
     valid_indexes   = setdiff(1:length(y), invalid_indexes)
@@ -134,7 +134,7 @@ fill_innovation_coefs(component::String, output::Output)::Vector{Float64}
     # Returns
     - `Vector{Float64}`: Vector containing innovation coefficients for the given component.
 """
-function fill_innovation_coefs(T::Int64, component::String, output::Output)::Vector{Float64}
+function fill_innovation_coefs(T::Int, component::String, output::Output)::Vector{Float64}
     inov_comp = zeros(T)
     for (i, idx) in enumerate(output.components[component]["Indexes"])
         inov_comp[findfirst(i -> i != 0, output.X[:, idx])] = output.components[component]["Coefs"][i]