From 924b2517873eff669445476cd81d9946f20f62d3 Mon Sep 17 00:00:00 2001 From: Matheus Nogueira Date: Fri, 19 Jul 2024 16:57:58 -0300 Subject: [PATCH 1/4] add residuals diagnostics with unit tests --- Project.toml | 5 + src/UnobservedComponentsGAS.jl | 7 + src/residuals_diagnostics.jl | 224 +++++++++++++++++++++++++++++ test/runtests.jl | 3 +- test/test_residuals_diagnostics.jl | 109 ++++++++++++++ 5 files changed, 347 insertions(+), 1 deletion(-) create mode 100644 src/residuals_diagnostics.jl create mode 100644 test/test_residuals_diagnostics.jl diff --git a/Project.toml b/Project.toml index 4ca0343..552ccec 100644 --- a/Project.toml +++ b/Project.toml @@ -4,16 +4,21 @@ authors = ["Matheus Alves "] version = "0.1.0" [deps] +ARCHModels = "6d3278bc-c23a-5105-85e5-0d57d2bf684f" CSV = "336ed68f-0bac-5ca0-87d4-7b16caf5d00b" DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f" +HypothesisTests = "09f84164-cd44-5f33-b23f-e6b0d136a0d5" Ipopt = "b6b21f68-93f8-5de0-b562-5493be1d77c9" JSON3 = "0f8b85d8-7281-11e9-16c2-39a750bddbf1" JuMP = "4076af6c-e467-56ae-b986-b466b2749572" LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" Parameters = "d96e819e-fc66-5662-9728-84c9c7592b0a" +Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80" Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b" StateSpaceModels = "99342f36-827c-5390-97c9-d7f9ee765c78" Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" +StatsBase = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91" +StatsPlots = "f3b207a7-027a-5e70-b257-86293d7955fd" Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" diff --git a/src/UnobservedComponentsGAS.jl b/src/UnobservedComponentsGAS.jl index 4da2dba..4fd5383 100644 --- a/src/UnobservedComponentsGAS.jl +++ b/src/UnobservedComponentsGAS.jl @@ -9,6 +9,12 @@ module UnobservedComponentsGAS using Random using SpecialFunctions using StateSpaceModels + # For residuals diagnostics + using Plots + using HypothesisTests + using StatsPlots + using StatsBase + using ARCHModels # include("../NonParametricStructuralModels/src/NonParametricStructuralModels.jl") @@ -23,6 +29,7 @@ module UnobservedComponentsGAS include("components_dynamics.jl") include("optimization.jl") include("forecast.jl") + include("residuals_diagnostics.jl") const DICT_CODE = Dict(1 => "Normal", 2 => "tLocationScale" ) diff --git a/src/residuals_diagnostics.jl b/src/residuals_diagnostics.jl new file mode 100644 index 0000000..0f5aae4 --- /dev/null +++ b/src/residuals_diagnostics.jl @@ -0,0 +1,224 @@ +# Function to retrieve residuals from a fitted model +# Parameters: +# - fitted_model::Output: The model output object containing residuals +# - type::String="q": The type of residuals to retrieve ("q" for quantile, "std" for standardized, "cs" for conditional score) +# Returns: +# - The specified residuals as a vector or matrix +function get_residuals(fitted_model::Output; type::String="q") + if type == "q" + return fitted_model.residuals["q_residuals"][2:end] + elseif type == "std" + return fitted_model.residuals["std_residuals"][2:end] + else + return fitted_model.residuals["cs_residuals"][2:end, :] + end +end + +# Function to plot residuals from a fitted model +# Parameters: +# - output::Output: The model output object containing residuals +# - type::String="q": The type of residuals to plot ("q" for quantile, "std" for standardized, "cs" for conditional score) +# Returns: +# - A plot of the specified residuals +function plot_residuals(output::Output; type::String="q") + fitted_model = deepcopy(output) + if type == "std" + name = "Standardized" + resid = fitted_model.residuals["std_residuals"][2:end] + elseif type == "q" + name = "Quantile" + resid = fitted_model.residuals["q_residuals"][2:end] + else + name = "Conditional Score" + resid = fitted_model.residuals["cs_residuals"][2:end, :] + end + + if type == "cs" + num_params = length(fitted_model.fitted_params) + plots_cs = [] + for n in 1:num_params + push!(plots_cs, plot(resid[:,n], label = "param $n", + title = "param $n", title_loc = :center)) + end + + if num_params == 2 + plot(plots_cs[1], plots_cs[2], layout=(2,1), suptitle = "$name Residuals", size=(800,600)) + else + plot(plots_cs[1], plots_cs[2], plots_cs[3], layout=(3,1), suptitle = "$name Residuals", size=(800,600)) + end + + else + plot(resid, title = "$name Residuals", label = "") + end +end + +# Function to calculate the autocorrelation function (ACF) of residuals +# Parameters: +# - output::Output: The model output object containing residuals +# - lags::Int=25: The number of lags to include in the ACF calculation +# - type::String="q": The type of residuals to use ("q" for quantile, "std" for standardized) +# - squared::Bool=false: Whether to square the residuals before calculating ACF +# Returns: +# - A vector of ACF values +function get_acf(output::Output; lags::Int=25, type::String="q", squared::Bool=false) + fitted_model = deepcopy(output) + resid = get_residuals(fitted_model; type=type) + + squared == true ? resid = resid.^2 : nothing + + return StatsBase.autocor(resid, 0:lags) +end + +# Function to plot the autocorrelation function (ACF) of residuals +# Parameters: +# - output::Output: The model output object containing residuals +# - lags::Int=25: The number of lags to include in the ACF plot +# - type::String="q": The type of residuals to plot ("q" for quantile, "std" for standardized) +# - squared::Bool=false: Whether to square the residuals before calculating ACF +# Returns: +# - A plot of the ACF of the specified residuals +function plot_acf_residuals(output::Output; lags::Int=25, type::String="q", squared::Bool=false) + acf_values = get_acf(output; lags = lags, type = type, squared = squared) + resid = get_residuals(output; type=type) + + if type == "q" + name = "Quantile" + elseif type == "std" + name = "Standardized" + end + + squared ? is_squared = "Squared" : is_squared = "" + + lag_values = collect(0:lags) + conf_interval = 1.96 / sqrt(length(resid)) + + plot(title="ACF $name $is_squared Residuals") + plot!(lag_values, acf_values, seriestype=:stem, label="", xticks=(lag_values, lag_values)) + hline!([conf_interval, -conf_interval], line = (:red, :dash), label = "CI 95%") +end + +# Function to plot a histogram of residuals +# Parameters: +# - output::Output: The model output object containing residuals +# - type::String="q": The type of residuals to plot ("q" for quantile, "std" for standardized) +# - bins::Int=20: The number of bins to use in the histogram +# Returns: +# - A histogram plot of the specified residuals +function plot_histogram(output::Output; type::String="q", bins::Int=20) + resid = get_residuals(output; type=type) + + if type == "q" + name = "Quantile" + elseif type == "std" + name = "Standardized" + end + + histogram(resid, title="Histogram $name Residuals", label = "", bins = bins) +end + +# Function to plot a QQ plot of residuals +# Parameters: +# - output::Output: The model output object containing residuals +# - type::String="q": The type of residuals to plot ("q" for quantile, "std" for standardized) +# Returns: +# - A QQ plot of the specified residuals +function plot_qqplot(output::Output; type::String="q") + resid = get_residuals(output; type=type) + + if type == "q" + name = "Quantile" + elseif type == "std" + name = "Standardized" + end + + plot(qqplot(Normal, resid), title = "QQPlot $name Residuals") +end + +# Function to perform the Jarque-Bera test for normality on residuals +# Parameters: +# - output::Output: The model output object containing residuals +# - type::String="q": The type of residuals to test ("q" for quantile, "std" for standardized) +# Returns: +# - A dictionary with the Jarque-Bera test statistic, p-value, skewness, and kurtosis +function jarquebera(output::Output; type::String="q") + resid = get_residuals(output; type=type) + jb = JarqueBeraTest(resid) + return Dict("stat" => jb.JB, "pvalue" => pvalue(jb), "skew" => jb.skew, "kurt" => jb.kurt) +end + +# Function to perform the Ljung-Box test for autocorrelation on residuals +# Parameters: +# - output::Output: The model output object containing residuals +# - type::String="q": The type of residuals to test ("q" for quantile, "std" for standardized) +# - squared::Bool=false: Whether to square the residuals before testing +# - lags::Int=25: The number of lags to include in the test +# Returns: +# - A dictionary with the Ljung-Box test statistic and p-value +function ljungbox(output::Output; type::String="q", squared::Bool=false, lags::Int = 25) + resid = get_residuals(output; type=type) + + squared ? resid = resid.^2 : nothing + + lb = LjungBoxTest(resid, lags) + return Dict("stat" => lb.Q, "pvalue" => pvalue(lb)) +end + +# Function to perform the H test for variance on residuals +# Parameters: +# - output::Output: The model output object containing residuals +# - type::String="q": The type of residuals to test ("q" for quantile, "std" for standardized) +# Returns: +# - A dictionary with the F-statistic and p-value of the H test +function test_H(output::Output; type::String="q") + resid = get_residuals(output; type=type) + + T = length(resid) + h = Int64(floor(T/3)) + + res1 = resid[1:h] + res3 = resid[2*h+1:end] + + σ2_1 = var(res1; corrected=true) + σ2_3 = var(res3; corrected=true) + + df1 = length(res1) - 1 + df3 = length(res3) - 1 + + F_statistic = (σ2_3 / σ2_1) + + p_value = 2* minimum([ccdf(FDist(df3, df1), F_statistic), cdf(FDist(df3, df1), F_statistic)]) + + return Dict("stat" => F_statistic, "pvalue" => p_value) +end + +# Function to perform the ARCH test for autoregressive conditional heteroskedasticity on residuals +# Parameters: +# - output::Output: The model output object containing residuals +# - type::String="q": The type of residuals to test ("q" for quantile, "std" for standardized) +# - lags::Int=25: The number of lags to include in the test +# Returns: +# - A dictionary with the ARCH test statistic and p-value +function archtest(output::Output; type::String="q", lags::Int=25) + resid = get_residuals(output; type=type) + arch = ARCHLMTest(resid, lags) + return Dict("stat" => arch.LM, "pvalue" => pvalue(arch)) +end + +# Function to get p-values of multiple residuals diagnostics tests +# Parameters: +# - output::Output: The model output object containing residuals +# - lags::Int=25: The number of lags to include in the tests +# - type::String="q": The type of residuals to test ("q" for quantile, "std" for standardized) +# Returns: +# - A dictionary with p-values from various residuals diagnostics tests +function get_residuals_diagnosis_pvalues(output::Output; lags::Int=25, type::String="q") + jb = jarquebera(output; type = type) + lb = ljungbox(output; type = type, squared = false, lags = lags) + lb2 = ljungbox(output; type = type, squared = true, lags = lags) + H = test_H(output; type = type) + arch = archtest(output; type = type, lags = lags) + + return Dict("JarqueBera" => jb["pvalue"], "HVariance" => H["pvalue"], + "LjungBox" => lb["pvalue"], "LjungBoxSquared" => lb2["pvalue"], + "ARCH" => arch["pvalue"]) +end diff --git a/test/runtests.jl b/test/runtests.jl index 656692f..25d73e4 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -1,6 +1,6 @@ # Import all necessary packages using UnobservedComponentsGAS -using Test, Random, Statistics, JuMP, Ipopt +using Test, Random, Statistics, JuMP, Ipopt, Plots using JSON3, CSV, DataFrames, StateSpaceModels @@ -12,5 +12,6 @@ include("test_components_dynamics.jl") include("test_optimization.jl") include("test_distributions.jl") include("test_initialization.jl") +include("test_residuals_diagnostics.jl") diff --git a/test/test_residuals_diagnostics.jl b/test/test_residuals_diagnostics.jl new file mode 100644 index 0000000..b2dffed --- /dev/null +++ b/test/test_residuals_diagnostics.jl @@ -0,0 +1,109 @@ +# Start defining the tests +@testset "Residuals Diagnostics Tests" begin + + time_series = CSV.read(joinpath(@__DIR__, "data/timeseries_lognormal_rws_d1.csv"), DataFrame) + y = time_series[:,2] + T = length(y) + + dist = UnobservedComponentsGAS.NormalDistribution() + d = 0.0 + + params = [true, false] + level = ["random walk slope", ""] + seasonality = ["deterministic 12", ""] + ar = [1, missing] + gas_model = UnobservedComponentsGAS.GASModel(dist, params, d, level, seasonality, ar) + fitted_model = UnobservedComponentsGAS.fit(gas_model, y); + + # struct Output + # residuals::Dict{String, Any} + # fitted_params::Vector{Float64} + # end + + # # Create a dummy fitted_model object with sample residuals + # resid = Dict( + # "q_residuals" => randn(100), + # "std_residuals" => randn(100), + # "cs_residuals" => randn(100, 3) + # ) + # fitted_params = [0.5, 1.0, -0.5] + # fitted_model = Output(resid, fitted_params) + + @testset "get_residuals" begin + @test length(UnobservedComponentsGAS.get_residuals(fitted_model; type="q")) == 99 + @test length(UnobservedComponentsGAS.get_residuals(fitted_model; type="std")) == 99 + @test size(UnobservedComponentsGAS.get_residuals(fitted_model; type="cs")) == (99, 2) + end + + @testset "plot_residuals" begin + @test UnobservedComponentsGAS.plot_residuals(fitted_model; type="q") isa Plots.Plots.Plot + @test UnobservedComponentsGAS.plot_residuals(fitted_model; type="std") isa Plots.Plot + @test UnobservedComponentsGAS.plot_residuals(fitted_model; type="cs") isa Plots.Plot + end + + @testset "get_acf" begin + acf_q = UnobservedComponentsGAS.get_acf(fitted_model; lags=25, type="q") + acf_std = UnobservedComponentsGAS.get_acf(fitted_model; lags=25, type="std") + @test length(acf_q) == 26 + @test length(acf_std) == 26 + end + + @testset "plot_acf_residuals" begin + @test UnobservedComponentsGAS.plot_acf_residuals(fitted_model; lags=25, type="q") isa Plots.Plot + @test UnobservedComponentsGAS.plot_acf_residuals(fitted_model; lags=25, type="std") isa Plots.Plot + end + + @testset "plot_histogram" begin + @test UnobservedComponentsGAS.plot_histogram(fitted_model; type="q", bins=20) isa Plots.Plot + @test UnobservedComponentsGAS.plot_histogram(fitted_model; type="std", bins=20) isa Plots.Plot + end + + @testset "plot_qqplot" begin + @test UnobservedComponentsGAS.plot_qqplot(fitted_model; type="q") isa Plots.Plot + @test UnobservedComponentsGAS.plot_qqplot(fitted_model; type="std") isa Plots.Plot + end + + @testset "jarquebera" begin + jb_q = UnobservedComponentsGAS.jarquebera(fitted_model; type="q") + jb_std = UnobservedComponentsGAS.jarquebera(fitted_model; type="std") + @test haskey(jb_q, "stat") && haskey(jb_q, "pvalue") && haskey(jb_q, "skew") && haskey(jb_q, "kurt") + @test haskey(jb_std, "stat") && haskey(jb_std, "pvalue") && haskey(jb_std, "skew") && haskey(jb_std, "kurt") + end + + @testset "ljungbox" begin + lb_q = UnobservedComponentsGAS.ljungbox(fitted_model; type="q", lags=25) + lb_std = UnobservedComponentsGAS.ljungbox(fitted_model; type="std", lags=25) + @test haskey(lb_q, "stat") && haskey(lb_q, "pvalue") + @test haskey(lb_std, "stat") && haskey(lb_std, "pvalue") + end + + @testset "test_H" begin + H_q = UnobservedComponentsGAS.test_H(fitted_model; type="q") + H_std = UnobservedComponentsGAS.test_H(fitted_model; type="std") + @test haskey(H_q, "stat") && haskey(H_q, "pvalue") + @test haskey(H_std, "stat") && haskey(H_std, "pvalue") + end + + @testset "archtest" begin + arch_q = UnobservedComponentsGAS.archtest(fitted_model; type="q", lags=25) + arch_std = UnobservedComponentsGAS.archtest(fitted_model; type="std", lags=25) + @test haskey(arch_q, "stat") && haskey(arch_q, "pvalue") + @test haskey(arch_std, "stat") && haskey(arch_std, "pvalue") + end + + @testset "get_residuals_diagnosis_pvalues" begin + diagnosis_pvalues_q = UnobservedComponentsGAS.get_residuals_diagnosis_pvalues(fitted_model; lags=25, type="q") + diagnosis_pvalues_std = UnobservedComponentsGAS.get_residuals_diagnosis_pvalues(fitted_model; lags=25, type="std") + @test haskey(diagnosis_pvalues_q, "JarqueBera") && + haskey(diagnosis_pvalues_q, "HVariance") && + haskey(diagnosis_pvalues_q, "LjungBox") && + haskey(diagnosis_pvalues_q, "LjungBoxSquared") && + haskey(diagnosis_pvalues_q, "ARCH") + @test haskey(diagnosis_pvalues_std, "JarqueBera") && + haskey(diagnosis_pvalues_std, "HVariance") && + haskey(diagnosis_pvalues_std, "LjungBox") && + haskey(diagnosis_pvalues_std, "LjungBoxSquared") && + haskey(diagnosis_pvalues_std, "ARCH") + end + +end From 3dfc8ff339e56d6016ae22c84988a1f071d2fba4 Mon Sep 17 00:00:00 2001 From: Matheus Nogueira Date: Mon, 22 Jul 2024 14:05:38 -0300 Subject: [PATCH 2/4] update residuals diagnostics example --- examples/4_residuals_diagnostic_example.ipynb | 4632 +++++++---------- src/residuals_diagnostics.jl | 32 +- test/test_residuals_diagnostics.jl | 10 +- 3 files changed, 1992 insertions(+), 2682 deletions(-) diff --git a/examples/4_residuals_diagnostic_example.ipynb b/examples/4_residuals_diagnostic_example.ipynb index f91f9cd..c88f9a1 100644 --- a/examples/4_residuals_diagnostic_example.ipynb +++ b/examples/4_residuals_diagnostic_example.ipynb @@ -6,16 +6,14 @@ "source": [ "# Residuals Diagnostics Example\n", "\n", - "In this notebook, we have developed an example of possible residuals diagnostics for a fitted score-driven model.\n", - "\n", - "Our main objective is to show how one could acess every residuals object we have implemented in the UnnobservedComponentsGAS package.\n", + "In this notebook, we have developed an example of residuals diagnostics for a score-driven model with the package built-in functions.\n", "\n", "## Import packages" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -25,10 +23,6 @@ "using CSV\n", "using DataFrames\n", "using Plots\n", - "using StatsBase\n", - "using Distributions\n", - "using StatsPlots\n", - "using HypothesisTests\n", "using UnobservedComponentsGAS" ] }, @@ -43,7 +37,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 63, "metadata": {}, "outputs": [ { @@ -53,86 +47,86 @@ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n" ], "text/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n" ] }, @@ -167,13 +161,13 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 64, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "UnobservedComponentsGAS.GASModel(UnobservedComponentsGAS.tLocationScaleDistribution(missing, missing, missing), Bool[1, 0, 0], 1.0, [\"random walk\", \"\", \"\"], [\"deterministic 12\", \"\", \"\"], Union{Missing, Int64}[2, missing, missing])" + "Main.UnobservedComponentsGAS.GASModel(Main.UnobservedComponentsGAS.tLocationScaleDistribution(missing, missing, missing), Bool[1, 0, 0], 1.0, [\"random walk\", \"\", \"\"], [\"deterministic 12\", \"\", \"\"], Union{Missing, Int64}[2, missing, missing])" ] }, "metadata": {}, @@ -218,107 +212,107 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 66, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "image/svg+xml": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ], "text/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ] }, "metadata": {}, @@ -347,7 +341,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 67, "metadata": {}, "outputs": [], "source": [ @@ -364,149 +358,158 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Auxiliary function to plot the autocorrelation function\n", + "### Package built-in function\n", + "\n", + "The package has a built in function that returns the specified residuals: \n", + " - *get_residuals(fitted_model; type)*\n", "\n", - "Uses the StatsBase.jl autocor function." + "It has 2 parameters: the fitted model, of type *UnobservedComponents.Output* and a string *type* specifying the type of the residuals\n", + " - *std* - stardirdized residuals\n", + " - *q* - quantile residuals *(default)*\n", + " - *cs* - conditional score residuals\n", + "\n", + "It is important to note that the first residual is dropped, as previoulsy explanained." ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 68, "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "plot_acf (generic function with 1 method)" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stdout", + "output_type": "stream", + "text": [ + "Length of time series used for model fitting: 284\n", + "Length of residuals from the fitted model: 283\n" + ] } ], "source": [ - "function plot_acf(residuals, type)\n", - " acf_values = autocor(residuals)\n", - " lags = length(acf_values)\n", - " lag_values = collect(0:lags-1)\n", - " conf_interval = 1.96 / sqrt(length(residuals)-1) # 95% confidence interval\n", + "std_residuals = UnobservedComponentsGAS.get_residuals(fitted_model; type = \"std\")\n", + "quantile_residuals = UnobservedComponentsGAS.get_residuals(fitted_model; type = \"q\")\n", + "conditional_score_residuals = UnobservedComponentsGAS.get_residuals(fitted_model; type = \"cs\")\n", "\n", - " p = plot(title=\"$type Residuals ACF\")\n", - " p = plot!(lag_values,acf_values,seriestype=:stem, label=\"\",xticks=(lag_values,lag_values))\n", - " p = hline!([conf_interval, -conf_interval], line = (:red, :dash), label = \"IC 95%\")\n", - " return p\n", - "end" + "println(\"Length of time series used for model fitting: $(length(y))\")\n", + "println(\"Length of residuals from the fitted model: $(length(quantile_residuals))\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Standardized Residuals\n", + "## Plot residuals\n", + "\n", + "The package has a built-in function called \n", + " - *plot_residuals(fitted_model; type)*.\n", "\n", - "### Plot residuals" + "It has the same parameters as the previous function and the default value for the *type* is always the \"*q*\"." ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 69, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "image/svg+xml": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n" ], "text/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n" ] }, @@ -515,258 +518,106 @@ } ], "source": [ - "plot(title = \"Standardized Residuals\")\n", - "plot!(residuals_dates, std_residuals, label=\"\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Plot Autocorrelation Function " + "UnobservedComponentsGAS.plot_residuals(fitted_model)" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 70, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlgAAAGQCAIAAAD9V4nPAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOydeZgcVbn/v6eqeu/ZJ/tKCAQCBNmFCIQtghevIouKC2pUFL3eR0Hhqj8Blc3l4sJFxQtRryCIGAQFQoyBkAAGEhKBhJAw2SbJzGQms/TeXVXn98eprq6u3qq7anqb8/kjT6anuqqmlvOe9/suh1BKweFwOBzOREWo9QlwOBwOh1NLuCHkOEZvb+8///nPDRs27Nu3L5VK1fp0MoRCoWuvvfbOO+8c16MkEolrr732e9/7nv7JK6+8smzZshUrVozrcXWeeeaZa6+9dt26ddU5nBUGBweXLVv24x//uOSWX//617/yla+M02ls2LBh2bJljz/++Djtn9PwUA7HNg8//PAxxxxjfK4CgcB73/vetWvX6tusX7/+V7/61e7du6t/egMDAwDe/e53j+tRQqEQgBNPPFH/5A9/+AOAb37zm+N6XJ077rgDwH333Vdkm4MHDxpvk8vl6u7uPvvss++5555UKuX4KfX09AC44IILSm45derUQCDg+AkwHnroIQDf+ta3xmn/nEZHqpbB5TQt99xzz3/8x38IgvD+97//1FNPDQaDPT09r7766sqVK5cuXXr22Wezzf74xz/+9Kc/ffzxx+fMmVPbE64aU6ZMWbJkybx582p9ImZEUTzvvPPY//fv3//CCy+88MILTz755FNPPSUITqpEPp9vyZIl73rXuxzcJ4fjONwQcmwRiURuuukmQsjjjz/+/ve/3/irbdu2xePxWp1YPXDeeefp9qau8Pv9q1at0n989tlnL7300pUrV65YseLyyy938EBTp05ds2aNgzvkcMYDbgg5tnjttdcikchRRx1lsoIAjj32WP3/mzdv7u/vB/DOO+9s3LiRfXjcccd5vV4Aqqpu3rx569at/f39wWDwlFNOOfXUU0172759ezgcPuGEE0RRXL169datW30+3/nnn3/UUUflntWBAweeeeaZ0dHR+fPnL126NO+ZU0rZQfv6+oLB4EknnXT66aebtnn77bdDodDxxx8vSdKaNWu2bt0aDAY/85nPsN/29/c//fTThw8fnjdv3sUXX5x7iOHh4Z6enmnTpk2fPh3A4ODgnj178p7MjBkzpk6dqv+YSCSef/757du3q6p6zDHHnHfeeW63O/db69evf/XVV91u9+LFixctWpR3z1ZYunTplVde+dBDD61evdpkCK2cyc6dOzdt2rR//36v1zt9+vQzzzxz8uTJ7FfJZPL1119vbW013abR0dGnn356//79M2bMeN/73tfa2mraJ7tWpsuC9GOwaNEil8ulf9jb2/vqq6/u3buXUjp//vzzzz/f5/OV/KvHxsbWrVu3e/fuVCrV3d29aNGiE044oeS3OM1JrbVZTmPz8ssvA5gzZ46qqkU26+joyH32tm/fTil95ZVXpkyZYvrVOeec09fXZ9wDk1hfeumlk08+Wd9MFMUf/OAHpmP98pe/ZPaVceSRRz7//PPIjhG+9tprphEWwOLFiw8cOGDc1fnnnw9gzZo1J554Ittm+vTp7FfLly/3+/36d+fMmbN+/XoUjRH++te/LvQa3nXXXfq3/va3v82cOdP423nz5r366qvGEwuFQpdccolxm0996lPf//73YS1G2NLSYvr8xhtvBPCJT3zC+GHumRx55JEbN27UN5Bl+fOf/zwhxLgNIeTvf/872yBvjPDZZ5/t7u7Wt+/o6Hj22WdNMcL77rsPwB133GE6z3POOQdAb2+v/snixYtNF3Py5MnPPPOM8Vu5McLHHnusra3N9MVly5YVuXScJoZnjXJssXDhQo/Hs2fPnq9+9auHDx8utNmKFSsuu+wyALfeeuuqNGyQPXz48KJFi37zm9+89NJLb7/99qpVqy699NK1a9d+/OMfz93P1Vdf3dHR8cQTT2zcuPHuu+92u9033XTT5s2b9Q2efvrpL37xiz6f7ze/+c3evXtfeeWVhQsXXn311ab9DA8PH3fcccuXL2cH/fvf//7BD35w/fr1H/3oR3MPes0113R0dDz44IMvvvjif//3fwN47rnnli1bJknSr3/96z179mzcuPHUU0+98sori1+rSy65ZFU2TzzxBHOeZsyYwbZZvXr1Bz7wgVAo9KMf/Wjjxo2vvfbad7/73d7e3osvvvjAgQP6rj7zmc88/fTTS5YsefHFF/fu3fvII4+sXLnyF7/4RfETKMKmTZsAGMOZ7EzC4bDxTPbt2/fe975Xz7hZvnz5fffdd8YZZ6xcuXLv3r1bt2596qmnPvvZz0pSQalp586dH/zgB0dHR++8886enp4333zz6quvvvLKK1mqUQXE4/Hbbrtt9erV27dv37Bhw8033zw2Nnb55ZcXcr4BHDp0iJn8X//612+99daePXvWrVt3++23m6w+ZwJRa0vMaXjuvPNO5hOIonjKKadcd911jz32WCgUMm32n//5nwAef/zxkjtUFIVN/N988039Q+YRnnvuuYqi6B/ecsstAL7zne/onzDXbcWKFfonqVSKSV7Fs0ZVVb3gggsAbN68Wf+QeYQnnHBCMpk0bnzmmWcCePDBB43nfNppp6GcrFFVVZnd1R0RWZbnz58viuK6deuMW/7kJz8B8NWvfpX9+MorrwCYOXNmNBrVt2H+KMr3CEdGRthl9Hq9PT09pjNZv3597pl87WtfYz+y89+0aVOhw+V6hJ/4xCcAfPe73zVu9uEPfxhAZR5hLvfccw+A//f//p/+ickjfPLJJwHccMMNRXbCmVBwj5BjlxtvvHH16tUXXHCBKIobN2689957L7/88u7u7m984xuVVROyBFQAGzZsMP3q+uuvN6Y1XnTRRQB27drFfty1a9eWLVuOOuqoD3zgA/o2kiQxG1wcQkihg37ta18zRqT6+vpeeumlWbNmseFbP+evfvWr1v4+jZtuuukPf/jDkiVL7r33XvbJyy+/vHPnzvPPP98k91177bWiKD799NPsR1YPd9111xkjYWeddRYzz1YIh8OdnZ2dnZ1tbW3t7e233HLL0Ucf/be//e2II44wnskFF1xw1llnFTkTpni/9NJLFo+rqupf/vIXj8fz5S9/2fj59ddfb3EPVmB3P/c+6rDTfu211yZ4MhdHhyfLcByApUeOjY2tX7/+5ZdffuKJJzZv3vzDH/5waGjo/vvvL/n1tWvX/uQnP3njjTd6e3tjsZj++eDgoGnLBQsWGH9kwcW+vj7249atWwGccMIJpqhV3vT9devW3X333W+88ca+ffuKH3ThwoXGH9lRjjvuOFEUSx6lEPfff/8PfvCDhQsXrlixQk8/ee211wCMjIzcdNNNpu39fv/u3bvZ/998800AethS56STTrJokwRBOOWUUwCMjY1t27YtFAodddRRxgQldibDw8O5Z+Lz+fQzueaaa371q1996Utfuv/++y+++OIlS5ace+65efN6GL29vWNjY/PnzzfFjBctWlRx2UZfX99dd931j3/8Y//+/UNDQ/rnufdR57TTTjv++ONXr149d+7cf/u3f1uyZMnFF188adKkyk6A0wRwQ8hxjNbW1ksuueSSSy655ZZbfvzjH3/9619fvnz5d77zneKFgw899NAnPvEJr9d78cUXX3HFFSyFYcOGDX/+859lWTZtbMxPAcBGT5rulxsOhwHoKYs6uZ88+uijH/nIRzwez3vf+97LL7+cHXTjxo2PPvpo7kFNQ6T1oxTiueeeu+6666ZOnfrUU0+1t7frn4+MjAB44403du7cafqKJEmSJKmqKggCO4Hcgdv6CRjLJ8Lh8Gc/+9lHHnnk85///MMPP8w+HB4eLnQmLpfL5XJRSgkhp59++gsvvHDrrbeuWbNm06ZNt99+e2tr6w033PBf//VfecOEhS6dx+Npa2tLJpMWz19n//79p59++sGDB0877bRPfepTHR0dkiQlEombb75ZUZRC33K73c8999wtt9zyxz/+8YEHHnjggQcEQbj00kt//vOfz549u9xz4DQB3BBynIcQcsMNN/zkJz/Zv3//pk2bihhCSumNN94oSdKLL75odHG+//3v//nPfy73uC0tLQBYnYaR3E9uvPFGQRDWrVtnzEG96667Hn30UQePkpetW7dedtlloiiuWLHCdGXYnr/whS+wlJziJ8Da5VRwAiaCweBvf/vbTZs2PfLIIx//+McvvfRS62cC4Mwzz3zmmWfC4fC6detWrlzJpj6EkG9/+9t5j5X3PBOJxMjIiHGWw6Y4qqqatmSmVOfuu+8+cODAzTffzMKcjB07dtx8883FT7urq+vnP//5T3/60y1btqxevfq3v/3tE088sWvXrk2bNhXJ9OE0KzxGyBkvPB4PAF0/ZGE20zx9aGiot7d34cKFJqGPJTGWy3HHHQdgy5YtpgHUtLfR0dFdu3YtWLDAaAWtH5Qd5fXXXzf5jla+3tfX9773vW9sbOzBBx9897vfbfrtSSedBODFF18svpPjjz8eafXSiF6gWS4ej4eVXnzjG99gN8jimegEg8GLL7747rvvZo7mn/70p7ybzZw5s729fd++fUYNE+l0G+MnrLjFZOxTqdSOHTuMn2zZsgXARz7yEdPeLJ62IAgnnXTSDTfcsGnTpoULF77++utvv/22xe9ymgluCDm22LVrl7FHic6aNWt27dpFCNGNDSsq37dvn3GztrY2t9vd19dnlMU2btz4l7/8pYKTmTNnzimnnNLT02P0JlOp1E9/+lPjZsFg0Ov19vf3G3MltmzZ8thjj1k5yuTJk88+++wDBw6wXESGoih333138S/GYrHLLrtsz549P/zhD1kxiYnFixcfffTR//znP/P26dadoQ996EMAfvGLX0QiEf23a9euLZIeUpIrr7xy0aJF27Zte+SRRwC85z3vOeqoo0qeick/AzBt2jQAiUQi71EEQfjgBz+YTCZ/9rOfGT/P7crNCjmeeeYZ45zmnnvuMVVZsHrEvXv36p8kk0lm1IuQe9qs52qRM+c0N1wE4Nji4MGDS5cuPfbYYz/0oQ+deuqp7e3tg4ODa9eufeCBByiln/vc5/TaLFZdcOeddx4+fHj69OmEkA9/+MNtbW2LFy9es2bNVVdd9Y1vfKOzs3Pt2rXf/va3586dyzLvy+Wuu+5aunTpsmXLDh06dN555/X3999+++2mgU8UxXPOOefZZ5+98sorb7rppq6urnXr1n3729+eM2eOxYPecccd55577nXXXTcyMrJ06dLBwcG77rqrSHYG45vf/ObLL7+8aNGiWbNmmTTYRYsWLViwQBTF+++//8ILL7zqqqu+9KUvLV26dNasWX19fdu3b//DH/5w6qmnMov+rne962Mf+9iDDz64dOnSW2+9dfbs2S+99NLXv/712bNnG01CWRBCvvWtb334wx++5ZZbrrrqKkmSHnjggZJncumll7a1tV1xxRXz58/v7Ox85513brvtNgBXXXVVoQPdfPPNjz322G233UYIueKKK+Lx+C9/+cs1a9YEg0GjU3jssceeeOKJW7ZsueKKK774xS9SSp988snly5fPnDmzt7dX3+y88857+OGHr7322h/96EcnnHBCT0/P7bffHo1Gi/+xv/vd7+69995Pf/rTixYtmj179sjIyMMPP7x27doFCxbYadDDaWBqWLrBaQL27t172WWXsZCSkWAw+F//9V+mBQ2+973vdXZ26tuwzjI7d+48+uijjd+99tprWW24sYyM1RHu27fPuENmty688ELjh7/73e8CgYC+twULFjCJz1hHuGvXLmMHOACf/exnWecXY4kbqyPUq+uMPPzww8bGYEceeSRzyIrUEX7sYx8r9BoaO8u8+OKLucPx9OnTly9frm8TjUZNvdC+8IUv3H777ai0swylVFEUVnD5+9//3uKZfPKTnzSlzkqS9OUvf1kvu8zbWWbt2rXMcWRMmjTp+eefz1194o033pg1a5a+WUdHx1NPPWWqI5Rl+ZOf/KTxBE488UTWYOFd73qXvitTHeFjjz2W+8SedtppO3bsKHLpOE0MoXyFeo5tksnk5s2be3t7BwYG3G73vHnzTj/9dFOGp87IyAjrQTNr1iwWOEylUuvXr3/nnXc8Hs/ixYuPOOKIUCh06NChzs5OPanywIED8Xh89uzZxlwGWZb37t3r8/mMAyuAoaGhVatWjY2NzZs3b8mSJYSQPXv2eDwevYEL++6LL764Y8cOj8dz1llnzZs3jx20o6NDT+4/ePBgLBYzHVRneHh41apVw8PDRxxxxHnnnSeK4u7du91ut+4Eh8PhgwcPdnZ2dnV1ARgYGMgV5RjGvxQApfRf//rXli1botHolClT5s6de+KJJ+YWGGzevHnjxo0ul+uMM85YsGABu7CTJk3KHeV1FEXZs2ePIAhz587N/e3Q0NDo6GgwGNQTO0ueyejo6CuvvHLgwIFkMjljxoyTTz7Z2DBPluVdu3b5/X7jlQcQjUZXrVrV19c3bdq0Cy+80O/379mzR1VVvZCREYvFVq1adfDgwUmTJl100UUtLS15H4OtW7eyM1ywYAErfCx+I9iJbd68uaenZ3h4uLu7++ijj+aNRicy3BByOBwOZ0LDk2U4HA6HM6HhhpDD4XA4ExpuCDkcDoczoeGGkMPhcDgTGm4IORwOhzOh4YaQw+FwOBMabgg5HA6HM6HhhpDD4XA4ExpuCDkcDoczoeGGkMPhcDgTmqoawgceeMBid/zcVcI5/Jrkoqpq7tqtHP6o5MKvSS78muhU1RD+8Y9/3LZtm5UtY7HYeJ9MwxGPx3ljWBOyLPOXORfjOoscBh9ScuHXRIdLoxwOh8OZ0HBDyOFwOJwJDTeEHA6Hw5nQcEPI4XA4nAkNN4QcDofDmdBwQ8jhcDicCQ03hBwOh8OZ0HBDyOFwOJwJDTeEnCqxN0wvepoXv3M4nLqDG0JOlRhNYk+41ifB4XA4OXBDyKkSCkWKtwXlcDj1BzeEnCqhUiSVWp8Eh8Ph5MANIadKKBQplTcN53A4dYdjhrCnp2fp0qX33XefUzvkNBlcGuVwOPWJ5MheKKWf//znDx48uHPnTkd2yGk+VG4IORxOXeKMIfzVr3511FFHzZkzx5G9cZoS7hFyOJz6xAFpdP/+/T/72c/uuOMO+7viNDHcEHI4nPrEAY/wc5/73G233dbe3l5yy23btl1xxRWSpB102rRpGzZsyLtlJBIhhNg/t2YiEolQShv3soSjAoVrZCwsOZehlUwmAbjdbsf22BREIpFan0LdwYeUXCbINfF6vbrRKYRdQ/jwww9HIpETTzyxp6cnFAqJonjgwIHp06fn3XjBggXXXnvt+eefz350u92BQCDvlpTSYDBo89yaj0Ag0LgPrmeUArLHH/Q5o8cD3BAWhr8+JviQkgu/Jjp2x6T9+/f39vZedNFFAA4dOiSK4uHDh//0pz/l3VgQhGAw2NHRYfOgnEZEoQCQVOGr9ZlwOByOEbuG8Prrr7/++uvZ/5ctW9bV1fWDH/zA9llxmhBmCHmYkMPh1BvOqVTApEmTrEQKORMTRaXghpDD4dQfThrCO++808G9cZoMZgFTKgUaNczJ4XCaEt5ijVMlFBXgHiGHw6k/uCHkVAk9WYbD4XDqCm4IOVVC5ckyHA6nLuGGkFMleNYoh8OpT7gh5FQJbgg5HE59wg0hp0pwQ8jhcOoTbgg5VULlyTIcDqcu4YaQUyW4R8jhcOoTbgg5VSJtCGmtT4TD4XCy4IaQUyW4R8jhcOoTbgg5VUKLESq1Pg8Oh8PJhhtCTpXQPEKujHI4nDqDG0JOleDSKIfDqU+4IeRUCd5ijcPh1CfcEHKqBPcIORxOfcINIadKsGWYeLIMh8OpN7gh5FQJ7hFyOJz6hBtCTpVQKQVvscbhcOoPbgg5VUKhcAuQeWcZDodTZ3BDyKkSCoVH5NIoh8OpO7gh5FQJlcIrcmmUw+HUHdwQcqqEQuGTCPcIORxOvcENIadKKBReLo1yOJz6gxtCTpXg0mhzcPIK+XCi1ifB4TgKN4ScKsGSZWRuCBuc3ggdSfLUX05TwQ0hp0ooFD7uETY+MkWctwfiNBfcEHKqBI8RNgcpFXG51ifB4TgKN4ScKqFSeESeNdrwyCr3CDnNBjeEnCqR9gh5eKmx4dIop/nghpBTJRSVZ402PBRQuEfIaTq4IeRUCYXCK/EYYWMjq6BAXOFuPaep4IaQUyVU8GSZhodVv3CPkNNkcEPIqRJMGuWGsKGRKQDEeNYop7nghpBTJXj5RBOQ4h4hpxnhhpBTJVj5RJKPoY0Ml0Y5TQk3hJwqoXmEPM2ikZEpBTeEnKaDG0JOlVAo5dJoo8NuX4JnjXKaC24IOVWCxwibAC6NcpoSbgg5VULlnWUaH5Y1yg0hp8nghpBTJZhHyJNlGhrm0PPyCU6TwQ0hp0ooFF6JN91ubLg0ymlKuCHkVAmVxwgbHy6NcpoSbgg5VYInyzQBsiaN2gr0fn6dsn2Uh4o5dQQ3hJwqoVBIBKKgDaacRkQrn7B3B/91mPbHHDkdDscZuCHkVAmVQiBwC3wlpgZGpnAJdpNlUiqfDHHqC24IOVVCoRAJJAJ7uhqnlqRUtLiQsBcjTCrgFfmcuoIbQk6VUFSIAlwCDxM2MLKKoIvYTJbhHiGn3uCGkFMlmEfo5qWEjYys0qCEmG1DyD1CTl3BDSGnSjBD6BIIby7TuKRUtLjtlk+kVCiUPwOcOoIbQk6VYMkyXBptaGSKoIS4vTBvSqVcGuXUFdwQcqpE2iPkhrCBkVW0OBEj5NIop67ghpBTJXRDyMsnGpeUiqDLAWmUZw5z6gpuCDlVQq8j5B5h4yJTeEUIxNZNTFHuEXLqC24IOVWCS6NNgKxCEuAVbTmFvHyCU29wQ8ipEgqlIiHcEDY0KRUSsWUIKaDwGCGnzuCGkFMluEfYBLAWa16RxCs1ZbIKCu4RcuoLbgg5VUIvn+DJMo2LJo1KlbcbZdMg7hFy6gpuCDlVIp0swwvqbdEXw5qDNbuAMoVE4LMhjTJDyD1CTl3BDSGnSmTKJ3iLNRu80Kf++F81u4L2k2W4R8ipQ7gh5FQJNoa6BF5DZgtFxeFEzY6eUqkkEG4IOU0GN4ScKqECAniyjF0UWktDKKssWcaOIaQAnwxx6gtuCDlVgi3DxBfmtYlCcThR4xihVyIVtxvVPEL+DHDqCW4IOVWCl084gkIxnEStLGHKoRihzFef4NQT3BByqgRffcIRFApZxViyNkd3QhoFeIyQU2dwQ8ipBmzcIzxGaBtmQmqljmrSqH1DyJ8BTj3BDSGnGrAAIcDLJ+zCTEit8mX08gleUM9pJrgh5FQDFiAE4Ba5R2gLZkKGa2QIUw5JozxrlFNXcEPIqQYsQAjAxTvL2EOtA2nUJ9kwhBTgnWUAALtD9Gsvc3mkLuCGkFMNdI+QxwhtImuGsEZHVyEJ8IgkUam4yaVRnd1hvNDHL0RdwA0hpxpwQ+gUSk0NoVPSKDeEAKIyfxfqhSY0hHdsUTcO8vesvsjECHlBvT1UCpdQa2lURMxmZxn+DAAxmXJDWCc0oSF8sV99a4QbwvqCe4ROIavo9tYsWUZWqSQQj4gE9whtE1V40lC90ISGMK5UPl3lmJj3iOxIaoshWYYbQluoQLeX1DZGaM8j1PbDiXFptG5oQkMYlSsvcuIYocCuEK147m9EoVQkBNwQ2kZR6SRvzaRRFiP0iIhX+oolFbgE7hECPEZYTzShIYzJ3CN0BvaWJpx4V7k06hQKxaQaeoRa+QSJ28ga9YrcEAKaIeQXoi5oQkMYVxDl0rsTsCYmFecHGtGlUZ4sYxOFottbB51lKn0qZAqfxGNjABBTeLJMvdCEhjCmcGnUGdhoVXHFmBHuETpF2iOspTRqs3zCJxIeI0QzxgjjCn71VkP+SU1oCKMydcSJ4bC31JHWoIZeo7yzjC0UihYXAERrMdvTm25XHDlOqvBJUPgyTM0YIzwQpbduasjB1wFD+I9//OOjH/3o8ccfv3jx4p///Oe01o94TK7NGNF8yOMQI+TSqE3Ylez01MYpdMQj5DFCRvMZQllt1LFXsr+Ll1566YILLvjmN7/Z19f36U9/WhTF6667zv5uKybGyyccgq2e6kjWqJqec3Fp1CbMt+704HACMwPVPrrWYk2wKY3y8gkAiMpQKChAan0mTiFTRCasIfzWt77F/nPCCScsW7Zs9erVNTSEsgpZ5TFCZ9A8QkelUbfIl2GyRdojrE1NvSaNSiRWabpLSqXcI2TEFK3JjqtZIlRs+E014F/k8Pm++uqrCxcudHafZcF8QZ416ghstHImazT9qHFp1CYs/7ZW0qheUF/xUyGr8ErcIwSgzdeb6XVgI0YjOoUOeIQ6//u///v6668/9NBDhTbYvn37Nddc4/P52I/d3d3/+Mc/8m4ZDocrO4dDcQJ4IkklFIpVtoe6JRKJqKpKSPV0lJEQATyjkVgoZNcYjoUFUCkUiiVjJCG7Q6GQI2eYTCYBuN1uR/bWEMSSLjmhtgjCgVG10H2JRCLjFKpPKt5ENByXSUqp8CaG45KLCkkZVX5DKx5Sxo9Qwg0II2Nh1VWbibvj12Q0LADugZGQ6HN2x7bwer0ul6v4No4ZwkcfffQ73/nO6tWr29raCm0zf/78j33sY+eccw77sbW1taWlpdDGRX5VhMOEAnKCipV9vZ4hhAQCgWoaQo9CAVlwe1ta7CoH3jh1S0pLS0u7QhUoTt2dCWgIBUkJ+MiUII0SUui+EEKCweB4HF1Bqr2lpdUNFanKbiKRlKAHA0la/Te03saEBJUB6vEHW7w1Owdnr4k7SgGZeIItLQ0W93TGED7++ONf+cpXVq5ceeyxxxbZTBTFadOmzZs3z5GD5oWpDTxZxhEcLKjnWaNOwaTRNjcZTdZMGpVI5RXxsgovT5YBkB6mkmrzpMswaSTtDaYAACAASURBVDTagMOvAzHCv/71r5/5zGd+//vfz5o1a3h42CnVqzLiCoIunizjDOmCegd2leksw5Nl7MGmFG6xNsm3zBCKgjZJqoCUyjvLaERliKSpkqjZbY2kan0e5eOAR/h///d/AK688kr242mnnbZy5Ur7u62MqIxOD+EeoSNoBfUO9xrlBfW2sO+T2SFF4SKa/1KZI5NU0e7mWaMAEJVpq7upnGM2YjRiKaEDhvCRRx6xvxOniCno9GBvmL9nDuBk+QRvseYQzLeu1WXUM+MlocK8/5QKr1S5Q9lMRGVM8ZFmeh1kzRA2ntjbaOUepYjJ6PTwGKEzOCiN8hihU7ArWStDqNeDiqRCry6lwisSLo2qFEkVQVdTqcRs8dJG9AibzhAqtMNDEgqa6OmqGePRYs3FDaE92JWUamEIZRWioE317RlCLo0irsArwt1cAoncsHWEzWYI4wr8Ijwiz5dxAMW51SeMyzA17pv/lz3q5qEaD+FsieOaXEbWVobBpNFKdqJS3mINQFSGT2y23DEta7QBx95mM4QxGT7JVucLjk5qHGKEAgFBozoEK3bTF/pqbgg1j7D6tsTYOqtijzDJYoSN+QA4SFSmfonUKulpnGDPJPcIaw8zhH6J8C5r9lEcbLpNqZBuBdC4s+C4gjGnU8O/sE4p6wrXMFmGJawybHiErOn2RH89Ywr8UrOFzGXNI2y8m9t0hlCBT4SXS6NOkHIuRiirmkcIwEWQarw3BQCiMsJOn/pvdqiD8TL2yaxRbQyhQRq15RHyGCEQleGXauPZjx9yw5ZPNJ0hlKlXJH6JJ446gOJc1qhKtWxDNLZHSEOOeoRJFQkFZe0z7RHWoBwzyyMkRK6onWlKhU/iWaOadtVk1URcGq0XYgp8EnxSQ85K6o3xqCME4BZIsjGVsViZRqskbG/hcp7VGpZPpFQqpfXtipvLaFmjTTT6VwZLlmmy/hIKhb8xx96mM4Qy/DxZxiFSKjyi84awcWfBURlhZw1hkgLl7ZPpkzVJspCpA8kyvHyCEZVpwEWaTBpNqWh1NaQhdHIZpnqAxQh9Eo8ROoBMEZCciRHq5RNoZEMYkxFyNEbIUm/KMoQ19QidMYS81yjSHiFpul6jre6GTFRsQo/QJ8Enkhifc9pGVhGQiCN1hNnSaKNmyo2XNFqOcWW9XWqeNco9QpuwrNHGTRzLi6yizc1jhHWA7hE2onteb8gqAi4ujWaIyQ4ny1QcI6yJpGbKGq3sBFIqfDxGyDzC5kuWoY0qjTadIZSpTyI+Xj7hBJo06niyTMNmjcacjhGOJSlQnpdZJ9KoJFTsEVK3SAhBE+WIVEJMgV9sOkOoMmm01udRPk1nCBX4RPDyCUeQVR4jzCKmOBwjDDVUjNApadRVu2Wk6gdWR9i470JeFEq5NFoXsFa2XBp1BIWOizTaoDFChUKhdmOECSVLqwilQMqMEWp1hLWILTnSWSalQqqRtFtXMO2qyQyhrGWNNt4cp9kMYSZZpgFvRr0hU5Ys48CujB5hgxrCmAyfCIHYqsz5n63q7Vsy3w+l0OFpGGnUkc4yKQqXUPnXjWwcpI48nDUhXUfYXIaQotXdkCvUN50h1MsnGvYNqR80aZQnywBI92pocdlyCuMK4lkeIZ3uJxVIo7VahsnQWaZCbVOTRp3wCL/8orJxsFHnu1rWaGO+C4WQVbS6SLwBV8FrNkMY5QX1ziGrNOBCwomshmxD2JDdNGIy9Ykk6CJ22o3KFMZxbyyJ6f7yYippj5BUv2+1MVlGqCjbhQKKCpcAAbA//qdUZwLYNaE5e41SuAW4hKzZXkPQbIYwLlOvRBq0zU+94WDWaJY02phZo8wjbLXnESoqNUqCoRSm+UlZCTi1XH2CZlqsVTaC66bUkfNXqTbgUuCfAw02tUr3Gm3ISWEhmGYQkBovX6bZDKHjnWW+sE4ZiDmzq4YjXVDvwK6aIFmGxQhtSqMKzXKkQilM8zdk1mhl0qhuCEWBKLYNgEIRVyiAg1H6gVUNNvRGZeoTmzBZRhIQcDVec5mmMoRUzxoVHYsR/v0A7Qk12E11Cpki4HLGaDVNjDDoslVKKGcbwjEWIyxnDJdVKgm1WdDVvjSaMYROJMvIqiZXxGRndItq0pTlEyydyic2niDXVIYwocAlQCDwSY5ljSYVDCUc2VPjIatwEYhOtENkjcEYDfryM48w6CpPyTQhq2aPcHrjeITZBfWVBCmdNYQK1WKEcaXxNIZmTZaRBAQasLlMUxlCNlQBTnqEKZWWtW5qMyFTSIIzC1A0gzTqRNaoSRodS5YdI9SzRhW12rl59ssnUip1CQQ2yhCNKFTLiWtEQ6glyzRd022JwM9jhLUlplCfBMDJgvqUiqG4M7tqONj8ziM4kJunUiqk8ywadBbMKqDtG8LsZBladoww7VtXP+HQfmcZ5z3CtCE0udr1j95rtNGiacXQk2W4R1hLYjJ8IgHzCB26E0kVQ4kmelTLQVYhEXhEBxagaIJeoywPq8VmjDBHGp3sIzItY2agX8nqzydMvUbtZI06EuPUPUJmDhvLKYzJ1N98nWU0j5Any9QUJl4BTvYaTakYnLAe4fhIo64GlUZllixjK0aoGOoImUPjlxAsR0qqoSF0QhodL48QjWYImzNZRoUkcGm01mRihM6VTyTVCZ0sIxG4BQcMYXbT7YasnXKqfEJfgSiUQosLBOUZV90QVj9x1ElpVHBgJSZFpUyrYEUUjSUzRJVmbLGmUkkgXBqtMfG0R+jUwrwqhUoxNFGTZRQKSYBXdCBGaPQIPY3pEcYdKag3xAhDKRp0EaA8uVWfUlRfYTZ6hDbrCB2x4io04Seh/dsw7ykzfq4aLbA8fjibLDOSxEvV6pPQVIaQRXHgXLIMe0YntDRKHJNGG30ZppjCWqzZMoSympFGx5JodQFAWfvUDWH1Hessj7Aily5jCB3JGlUbVRplixGiYdWRQjibLLNqv/qtV6o012suQyhTn0QAeESknMgiY6/WhE6WcShGqDZBsozMyidsxwgzHiFa3AAQlKx6hGw+wS5k9TPvnewsM7FjhEkFbs0QOnwTb96ofGyN/aY9FeJsssxgHAer1dWryQyhJo0Sh0oJUyoC0kQun6CSQMYjWaYxPUIHskazpVG0aB6h1UbepstY5RihXgUI2zFCZ7NGNUPYOLMrZ3uuGhlOYsUe9asv1+ZaOJssMxjHwSiXRstHl0bhUL5MUkXQBbeIsQZcYcs+mjTqRB1hZQX1v35L/eveenHH0x6hbWnUECNs1WOE1p5VtaYKc1bWqD1p1JlkmYb1CPUpheM3MaXi5pPElb109YEavDjsCXFKGh2M09FklfJumssQpj1COJQvk1KpWyBdHjIx82XS0qgDdYSVjeAbB2n9LDjHplk2Y4RGaXQsqXuEVvdpx7F+z5OyzWi3s9Koo3WEFA1mCMfLI0yp6PbivOnk7dFaGMK0R+iQIQRQJaewuQyh0x4he167vRO0gsLZZJkKPMKIjMN1E6B1KEZIFap93SCNlhEj1C9juWvzbh2hI0lbF9NYUG+3xZpjMUJWPgE0pjTqeA0M2/OsANkXro0hFFnWqBMS2mCcEuBg1IFdlaS5DKEMb9oQOqJTs5h2l2eCJo46mCxTmSsTletoCsKyRh3sLBNKobXcZJns3uVlJV6GUnZ9JicL6h1ZhknNjhE2lEcojU9XBM0QBrEv4uRuLcJacLS4SNiRZJkE5raQgzHuEZZJRNYKs1BmbVYh0h7hRJVGHYwRqsaFeUnS2iAakWm9eYQuASLRRt4KyM4apS0sRuiuMFnG+hgalSGrdn2mLGm01i3WVAqK9OoTMtBQhlCm4yWNJlW4mUcYqcGLo1BIBFN86Hci23MwjkWd5EBVLHpTGcL+GKb4tP/bjOUw2HvbNWGlUQfLJ1CpR1g3vrguvNt5tIwe4ZgujUpWk2UqNoTshG2aimxplOgabwV7sF8+wb6elSxTzh4f26X+ZU/NLOe4xghdAmYGsC/s5G4twkaMqX7S50RgbzBOT+hEH/cIy6UvRqf6dI/QViyHwaZXXR4yMVdiGidptMwYod1DO4WeimXn0coqn6gkWYaKFS3iwU7Y5n10UBq1X1DPjq5LowIpw8ynVFz/T/XF/pq91ONpCKlLIDMD5EC0/HmKbdgT0uXBaNLu3xWVQYH5reQAjxGWS18UU/3a/x2URieuR+hgskxFC/NGUvWULJP2CO08WqaCei1GWFmyDCGy5bFuLAnY9ggd7CzjrEeYUBCQyvjrfrdD7Y3QGjaGNk4InO0sw/bsFdHqxkC1qtF12BMiEEzykX57ntyhOO32kGl+wrNGy8boEToijSZZjNBTRwJdNUmvR0gStt9V1fCoWfcIozJGkg6kFxq5br1SmRkzeIQ2pFHD6hNjeozQekF9RfMJ6NKocx6hA+UTzniEWtPtVjex+NfJKu7con7yKKGGjaENHiFxdlFJfc81CROyFhwApvrQZ88MD8bR7cU0H88aLROFYiiOSV7tR6c8QreALu9ElUar6xGGUrh6TdaRIjIlwEjS7tGN/Hm3eqiiuxmTqVcksDfHUtSMXY/J8EvA+MQIhxMwjoPpGGGFj/H6frp9lDpQPkHBstkkwbZHqIIYYoStLqtP6bP76WQf3juT1IchHJcYIVCbCgp9qjTNjz57BkwzhNXyCKXSmzQIg3F0eDLSTYvLgVRPJrh3eSaqNDpOMcICvUYH4/TpfSog6p9EZUzzk6E47fKQPF+oiKRaoUKor3aZ7ohWySkZpVH9mgRdCFkz9tYN4a+3qz1j9Jfv0S4mixFWLI3+doe6L0w9IqmfFeoVCp+UiRG2uq3+dfsjdGE78UuI1G7x2PHrLKN3Ma1JBYUunk/1kb5Yhe8IYzBOu72ky4uwjIQCj1j6K3ZoHo/QqIsCCEpOSKNKuqB+YkqjznmEKqWCnuVBkFcIjMpZpZ8KRUrFdL/D+TKpiqoIKFuGiWWNWi77y0U2GEK9207Qcos1U0F9EVXt7dGsGFhl0qhuWhIKnumlmwY14avk0QvhbLKMX8ryCC0awpEk2t0ISCU8wr4Ydoxbc5am9winOuQRkoxNHV+ayBAaMmUAtLgdkkZFdHnJYN2kbFQTrem2471GC3iEMQUpg7vGlvDu8jpsCJNKJY5RQoFLKNtu5WKURvVrUkaM0HKnuh3ZhpA1y7V+H6MyPvGcctVq7T4lVbxnKtkXoU51lnHCI6RugQgEKRUJBdZjhCNJ2u4hJRtuPPKO+qPXx6u+ogqGcGagxh6hzUL4wQTt9hIA0/zVCBM2kSGM0SlOe4QspBGQkFQcTtlwlrV99IU+58+vyp1l2Axdb84UkeGX0OkhDi6DRZFla63DlqdnOJU1miWNZu8wIue/5qplaXTHGDUuhRNKlrGGe0zGmU/I20czLdkSCq47Vpjmh9shadR+QT27euzhTHuElvY4mkSbu3Rj6JiC4XELiOjXgQCiE0szZvacjsLOCpDe7GSZ5w7SL784vm3oHI4RetiuqhEmbCJDGMVUX+ZHZ+oI04K7HWPwlZeUDYfG90au2K0+u9/52eu49RoleccszRCmB8ioTAMS6fLgsHO6dEoFrSh5MqZQvZ+79VWTcskrjbpzutXcukn5xbY8N9RijDAsk74oTNIosRwj3BOmMQU/PVPU73tCoa1u8vy/SYunOCONOuARqhAFeATEFcQV2lKmNFqyH2ZMttuatQjGtCOLTuEvtqm3bS69XUYazYkR7g3T8RN7AVBDTpx9PXMwjkk+gHuE5dIXo1P9GY/Q+tI2RdCfKusZ/7m8cZjuHWexvj/mgK3KpcqrT8RkCmSG70gKARc6PcTBUsJkpU0p4wp8aRNkPckzF2NBvdGqmUoyQqn8/kqWISwQagWwcwyikLWHsRTaLKeThFJoc8EjZB6qpAqPgKPaiG1pNLMMk/0YoUjglUhCoXEFbW6r85uRBG13k4CrxOKxMSWTrnz1GuUVR+eyRkNo0TneMUoPWHCM9D1P95P+GDXeo4g8vsvJMSvIHk8nYoRpadRHrPzhNmkmQ5jlEVrPxCuC/lTZ8YpiyrgvqdUfo+PRaLHK6xGyq6Rfq0g6RlhWym5v0dopdtwKpdGMR2hDGlXzSKPIETDiSn6hz1iFUsQneydMjmkjkWzL2uW1GkVjy2J4xKxkGVPann1p1H7WqEh0jxAtLlKuR1hCGpUzhvCtETpgWZawEtKuwCM8GLP01BnzUbu9WaJiOOVAtKgIxjJTRzxCJo3Oa8U7IdsnV4rmMYT9UbNH6EhBvVszhJV7RVG5CoZwXD3CKsUIYwpgiBFGZQQkdHrKS5Y59k9ykautGcLyb6VxhS9bvUYpzZVGkfO4xpX8/o1FafSdkPCurqysyFCKdnutRtHCKdriJsb7nlAy0UFGZdLoYBxtbsCh8gmRwCsirrBkmXKkUQ/8YolkmZiCkbQUcTgB66//rD+kSq4FWIEh7ItaaoWjR3MATPZmNb8Op+j4GkJD4yG/BIlg1IYronuEx7SRt0a4R2gZk0foyFIgjkijVTCEfVFayFYNJfDs/kquA02nZrgFR8onMoO+JEA1hMp00jFC7ceITLVkGcv1oBSIFBAVGaydlW2PsPIYYUFp1J0lYMTk/F54tiEkhbpzvRMm7+oixjq5UApdHqv3MZRCUMqaACVVBzxCleK5g+q50wgASSCyvXZFerJMKAWJwFsgFTmX0STa3ZAESEUfbKNHeDhBLa43EpMRlfHzN0s8YdmGsOB93DFKL3lGe5oPRmHlqTPu2bSQakTG2LhFPZHtEQKY5q/cKaTAUAJdXgBY0E52jFJH+9DloZkMYXYdoXMt1mBPGh1vQ5hS2Yw1/29fHqDffKWSU9fnd457hCgwC85JloGWLGPZI4zLoECs8AhdcYwwyyO0UUeoqJkWa0VihDGZlvQIiyzMu3MMZo8wiS6PVfFQk0YNrfUckUY3DtJpfjLd71T5hOYRjibhFcuYqo4kaZuboNSSpayYJyIjpSKUKmMOEZDw0DtqcWfIokf42x3q2j6tn2xfjFqTRo2GMKslVjjlQNpEEYweIeyFCUcS8EuaCBGQ0O0le8Y5zaJJDGFcQUxGuyfziUuAROwuUp9SqVsggC2vKCrT4mF5mwzEKC1cIpZU6PbRSvrQZxlCR2OEKOBhm5NltPKJMgwhE1fjpaVRqzs0npsvPd21U0eYN2sU+WOEeb5ukkYLiZM7Q+T4DpIy1CyOpdDttfqHh2UtRlhEGq2gWeiz++nSGbaSTo1oWaMiRpLUK5mfqB2jdH++aLGsIq4g6ALAauoLvhnsaRxJUPb4WTaEdIqPXDxTWP52sT9Pj+ShsCGkwEPv0JSKQzFEZYwmLa00bvIIjSuKR2TI6jhOyk0eoZ0w4VC6iJBxTDveGrF5diVoEkPYH6NTfIRkf2g/cdSYLFOxNBpTEB3P6h0WBigUw0goCKeQd1Aojv5YeyyLTkUwZnmguEeYHSPs8harI3x6P/lbb+bHdAvmgqdR+2SZLGk0s6ZSnhhhSUNYIGv0cAIyxRRflscTStEur2WPMEmDLlJcGpWEstcjfLZXXTpTewic8gg9mkdITF0a7tmq/n5nngOMJNHm0jIbi+fLsEnVSFJb/8SiNMqc6S8fJ9y/vbghzMoazWsI1/fRoAsndpLdYXowSkVS+qmTDXmbyOcRAuOYL6N33GbY8giTaHdnfjymnbw1noUfaBpDaGorwwjaLiW0X0eoUCTKzBpVKFb2lnHafbFiDitz5raPlnECDN0jdNmIj+qo2Y9aXo8wqsArGrJGU/BLaHNrM9m8/HkPnurNvHtMAIgVMYRK5t+yMEqjdgrqjQvzFkmWiSn5b6iV3uU7Run8FgBZNeMh5hGWI40a71FCoR4xa55ZriULpbB5iJ6dLkMUHSqo94okLY1mFafGFeStAmRtZdj/i0ujURlugRlCoAyPEC1unNxFdo7RItcnpWacJ5eQ/1L8fqf68fnCnBayJ0z7YpgdJCWboxrtK4Auj8kjpMA4hgnN0qiN5jKs6YHOMW1k2zjnyzSLIcwOEDLsJ44ak2UqkwdNJQFW2DJEP7qmjC/0x+jMQMHJPhv0t5f/GOkeoTsnmP9CH905Vt4OczzCPAkCMRndXqKPTVGZBlyEAO3uguro1hHsDmUNf6iGR2grWaZA+UT5HmEBQ3ggSqf5KAC/RCLpXtuUosVVnjQqEEjp1W7zSqNlGcI1B9R3Tyb6NZQqWs7QiMEjpB7R3LcvoWRSFo0JI0ZXo3hzmZiMKT5SrkcYTleedHtJERkmRUvECCnwp13q1UeSOUHsCeNglM5vLT390rPcGSZpdNw9QrM0mpWzWhas1lP/8dj2cU8cbRJD2BPCnKD5Q/srMWVJoxV5hBUYwk1DdCRRRgfC/hhmB4t5hCJBBcKCPr/L9d4eeFv9vx3lDWPmGGG+6xmV0e3NJMtEZAQkAOgqUFOvUmwbwZ6IwSMcP0No8AgDEiIyKnsvFQpdUSxSRxiTC5VPZNTUQmG2gTgmeSmAgEt78MaSmodncTIXSmlRNHdaCMknjZYX5HtjGKd0Z+6Ug8kyI/mSZRJqJufz1MdlfbZkdDVKJstM8xtjhJZON5ReY/KIFuwqXP0ml0qWYQedGSBzg2RPiPbFML+VREs9dSaP0CyNymh3j6s0muURTrGxNu9oKtsj5IbQIttG6LHtZo/QfuKo/TpCFo0vK1lm0yClyJrKFacvRmcHSSFDmFRwVBthHuFLA2V4cjKlEsm/UkxcwSuD5V0NkzRaKEY4yWvuNQoUzJfZHaYBifZGMz4WS5OJFb7aaWm0/DpCg0fIHBE2Kv1lTxnWgBWNWKsjpHlr/qw06DkUwyQP8wi1gT6Urgu0WlCf1EZzj5CZOtj0CEfTuZoMB3uN6lmjiWyPUJdGD8XoaPraGl2NUskymOYnI0kMxSGQcuYQEgAc0UJ2hQruvGTW6MEoneYnAOYEwWKEMwLELZbI/ssxhBg0lk+kMM1PquYRTvZhoHKPMCtGOMUHmZYxJFZAkxjCrcN0YUeuNGo3Rmi/jrAyj1AgsL54bEmPcFEneWsUAK5brzy1z7Ih1D3CnAE0oaDcjlMmaTR/1qhCs6VRzSNsc+dvDfXGYXpyF1olqienWfAIK60jVKjP4NKyfJn9EfqhvyvWGyEyy2FFGo0VaLptRRodiFPWkkOX/tIxv/wtXnNh0ijS87+UCpFAyH69yjeEWXN80b40qkIUDOUT2elsCYWOJAAgqSIiZ5QhozRaKlmGTvNryTKTveUky7gBzSO0Ywi1pIc5LWRPGH1RTPMjWGrFDGMyKoBuD7I9QjrNjzHDkOhsF44cj7ByaXQslTVtwviro01iCPN6hPalUft1hDEFIinDEMoqG9/JIcvTn/4onRMkhcsncHQbDsXpSwN085Cl5hT6mejJMqxXtU5coYNx9BR+z3OxWEc4yWsun0BhFe7NERzXjrktZHdag2JZo8ZZ84rd6v9szXw5Vak0GjV4hACCEgmn6EAMKsXf9lndHbMcVnqN2okRDsQ0aVRfezaUQqur4OpXuejSKHvs8y6LWq40ahK7HPMIBYwkqVckHpM0mo4RMi0hyxCmi6yK993WPMIEPZzANH9BxcUEm3NA8wgLblbSEPbF6DQf8wjJnhA9GKPTfCRQKjidK40OxTNvbq5HeM4qz2tDjlmXHI+QHIpXUrgFltzrzvrk6Dayo8y8hLJoBkPYH4NAMMlr/ty+NJrSpVEbyTKdnjIM4VujdGaAzGslhyzL6/0xFJFGEwr1S+TIFvLtV5UWVxkirf5Yk5xRL6Ggw1OeU2iljjAqo9ubUavY6hMAJELkfC/UG4fpcR2adsQ+YSbQOHn/6176qkHFrTxr1LAME9KlhIficAl4Yk8ZTjZQQBp1k1BaykuqUGjpFmuF0u4PZTxCYooRlpU1Ct0QqvDkjBM2pVHHYoQSRpPIkyyTjhEOJyiQ6ckykjRIo66CL6ZKkVQx1adljU73W50HhzMxQlJkpphVPiEgN3HsYBTT/ADQ7gYh2DqMqZY8wixD6BHhETGW1P6iuIIpvsyQuHmIbhslNltjGzF5hG4BfgkjFS1lNZpjCLs9sO4bVEAzGMKtI3RhjjuIirJG//CO+o0NmUdelxqsz6ZNpAd3q9tvGqQndZPJ3jLuel+Mzg4UDOaz6M6CdrLmAP34fKH40jNGjI+1ORNBweIppCxDaBz0UWAWHDPFCFOaR1hIRntjmC5sw5wA1T3CXGl0wyE6ZujxYStZxuARMrFhIE7fO5Os7VMt3l+FgliQRuOF29+YWqzlnR9ke4RAOoPDuiHUR3M2/zO2r9SxK42WX49vguUNeQSSt7OMHiPUPML0DcpKlincbjSuwCOiw6NJo9P8pJA0OpzI6qhp8AiLJcuYWqzlXgo9RghgbpDsCdNpfhIoJXGZDCEM+TJM0mhzE7184tFdKgAHl3aR1azJLmzky5hihAA6PGR4PFdHbwZDuG04jy6Kchb+1ln+tvrOWObHTB1h5R4h7fKW4YdtGqInd5FJPmIxRshCIFMLSzdM1zqmDWdOISd2kTKkUZpV6mS0W3EFZ08VyvQIM+mOKJE1mvkx4AIKyGiyip1j9Jg2zA5Ab7/ERiu9jjCcwrYRagyKJFVIFYV783iEKQzEcFQrObWb/N3aYpAKhVs0SKOGuKnREDK/tuI6wkOFYoSW5f0cadRcRIgKpNFsQygJDnqENG8dYVRGUtUG+ow0ahhhi6zEFFPgF9HuJiNJWtwj/PHryk8NnUX1SzfDT4p0KLUUI0x3Tp7TQkSCSd7SHmEyjyHUqkfCMgJS1mP2xx56epc6bHuJHh2FZnmEsBEmNOkHADo847hOMprDEG4dyZMpg/Kl0UNxrDmYtRpnJlmm0hhhVEa3pzyP8ORuMslr5WBNGQAAIABJREFUNeFqIEYneYm3cOMb5hF+6mjhJ+8WS67KbSTLI8wp0lo8hbw2VKxk2ISVGGFMoZMMyTJ6jDCv97BjjM4IEJ/EYoTZ0mh6dNs4SFkyhU5SQVCqcGFevyEAwkoJB2J0so/8+xzhyb2WLgRLmmd/CvuCvsdsj5AWWkS3ZIxQpTicQLeeNZouHWt1w1N4BvDzN9VNaQFZpYil05QclUbNHqFTC/OOpdLJMtmPKDvocG6M0EKyTEymXom0uzGSAIsRxguc7mgSo4YRQ/cIBYJZQbK7gDpassWa0SOcE8RkH0QCKzFCd44hZMmWkRQNukhr+jFjocElU9WylnYpjilGCDseYTLHI3TDQZudSzMYwryZMihfGl2xW53XQozjZorCpbUZIxXk3AOIyujyIqZYLTt7Y5ie2EkmWZZG+2OY4tM6wOU9BPMI57eS0yaRQKkZpRHjY22abidUTPZiur+MPK6cGGGeDMY8HmE6WSb32r+V1sPnBOjusPZhXMla6v2VQXr2VGKSRoOWF64zEjMnyyAsYyCOyT4snkI2WismUSjcgiaNmtJojRnOMRnBAuutl2y6fTiBVpc2g9E9nrG0R1hoBvB8H30zfSvZ/ENId9dLKE5Jo9nlE04tzCtCpfmlUbeQqQLUF6Kx2FkmJsMvod2tSaNFPMKwbFpRWVOVARwRLKiOWkiW0WKEAOYECesWUrLbex5p1KNJo7pHyF6HR3vUq+aRDjcc1BtNMUIAk72wvo6jkdwYIZdGS7NthC5sz/N5uVmjj+5Sly0QTA6EbWkUQRc8YrFO0DoKxVgSXV5M8lqVRvtimOIDKZw6YawA01uNWMH4WJulURleCXNbsC9icWelY4QUiCvo9mbOMJJJlskjjY4k0ekBgNkB7Itoq7TEZNruzkijGwbohTMEkzRayMYUx1hQj7TYMBCjk71kktdqhZNCacYQZs8MmLPOfhVX0OrOP/Eq2XR7IE4n+cwDPasLLBIjTBo6uhmHcvbY2/cIFYpouiQj/fWyW5Xm7pPVEQLIbbqdUOhkHxlJYjhB29z5PcIiAgm73e0ecihOIzIm+wpmZYeyV7sNpzJ/ZpFSQut1hADmt2JWkAAIuspLlkGWR4igKzPf2nKYnjlZ6HDTevUIM/MVxkSXRneO0Tu2FBu3hhOIypgeyCuNllFHeCiOjYP0I/NIIWnUop42lMgqsmbBBr9oqe82y+4jwCSfVY9wf4SydW0KFXgYc99teISmth3UI5Cy5mgls0bjMjxi1quekUbzJcuE08EYn4Q2F1gpYVxBhyeT17DhEL1wBsknjZb9cpo9wnSMcLIPXV4yaO06yCrcItGrCY0zA4Fk7FZMQZurwjrCgRgmp9OnrdcRplRqMITahQXgFklCoRWXTyRVPL2PwvBgl/X14ugeIQCPQEyLXCZUTPZhNInDCcwOkrwxwuIeoU9Cu1tbvNBbODISStJQPmkUwLzWCg1hOAWVZvbz73OE350rAgiU7xF2ec0eITPb+yKYHUS7izqaLJPVdBuVxggpMJZCmyvrw4kujW4fxYM7i70xPSF6ZKt53QlGWR7h9hF6XAeZ6s8eN/U6Qsse4RN71LsMljsqU79E/EV7WOiqpi4fTfJaLZ/YHaJzW4obQm0lKRTNF8/F5BEa5wHMaHW4y5ijlYwRRtmMQUJC0Ua0RDpRM69HGE4Lp0CmlDCmoMOjOd8DMYRS9IQOklQzY25Kpc54hBIJp+ihOCZ7tdMwDqmfX6es7cvvz7kE0HweIQzqaFxBW4H11ksmyxwyeISBTNYoWt3FJnNJ1egRZoZg1owmt60MrHmE20foZ19QkC/3wcHVJwB4JSB7dpVQMMWHkSQdTmJWwJg1mjmTIp1l2O12CQhI6PQQr1iwoD5HGs1cvblB6KK9ieKG0OgOAiDQdMIKPUItSkqDLtKabrG2L0xnBUhZr3BJcqXRygxhJAWvaN7VRJdGkwrtCRXTUKKGAdFEWTHCuKJFGiQhYy0ydYSWk2XW9VGjsYnK8Eslelh8YZ3yaI8KQ9FxpwdjKUtT5t1hzA0CgFvI3wTO2CWyeHNFE6ZkmVSWRwiviI5yVgo0OUC5g3JUpj6JEMArIqYgKsMnaj5E3kGTvdjs/7ODZF8k7RGmpdHXh+mJnUQgaHFlGtMkVQQkq4ZwMI7L/66kTy/HI5QzOqQeiWG8OUz7onnuhUwhEhACleY1hNrjGpMLG8JSdYRGj1B/6sZStHiv0aSa+ZVR3NOk0XweoRVtcyQJVlJtqqaHo6tPAJpfmGMItZbZs4NajolCEVXQailZRrvd7R7S5Sn2+puk0ZDhsZzsy3oqjJiWYTJdCmOA0EhAKpEsk8zuLAOtuQwARGQEJe1dGEtBpujwoMOTRxp9dJd6y6aKlvLOkUYn+8hA4Qn9vgjNO18cyZk2AejwYCwFa52RKqHeDWFCQUzGgcJ93GOK9hrkEpTKM4QsEML0EEYF0ugL/dSogrIBtLgh7IvRvhhgCBGLBO3urK75hTB6hGwUGEpkZc2YpNEyPMJ0r1FkDzGUzQ9EdHrIsOUlXUp6hLG0EBpwIZLK1E6ggIzGXmwGS2pgO+nwaAl+Iwna4SFAVu2Ulixj7VYOxun6fjV9elkt1lpcOBiFAG0S1u3FkEHKPhTPb3IUColodt00M4DBEMYV6peIkM6VvWK1oqcQm2OEOZf/UJxOTqfdByRt4Z6hOLo8xXqNJpVMqm0oRYMGj9BO+cRwgqZUDMXz5D5ITmWNMo+QGcL0H5hSIRB0aVWAmBUgLHt2NFuhLSaNpjvqtbvR6YFHRKGsUaMhpNnTiFZXVsaykbI8Qh0rHmFO1mhaGk0hwGKESbovTGcHCIB2V546wt0hvFpmA0VGuR7h6v3U2PVJZzRp1kUBiAQBKX+rRUeoe0OoAkBP4dLUuEy9OW8po8VdRh1hQqFeSRs3RwzjZlmdZfpi2BWisTI9wsMJTaAYM4wXk62VEu4OU+YR6pPWC5+Sr/i7or+BRl1LHxmtYJZGDXNttwBSZvi6ZK/RaLpQzy+RiEwjcqZcIa/3wF5shsGEoN2tFVHoDTNbXdB7LicVBAuE33JJqBlp3VRQH3ShZ4xOTouQXdndjQdiNH+ET4UoQLDgEfqkjAP38gDVW+dYiRFOSi/trT91B6KYEdC+mHc8N3qEoRQyyTIsa7RSaZTNTvpjdDSZtaoOHOk1apRGNY9QC4KyyV+bm4wm6XACs4OaNDqSfRrFkmV0j9DNpNGCdbqhJNUTEaIyPGLmBrUW6JELQzo68hvCQh5hBQX12hRN9whDKewNY1YQADrcNPcVDqXongKKbnHKTZZJqMibu2dsg2dkXNXRejeEbIr3TuEuc/HsEcpIuR4he53asjxCTWqwKI2u61NP684KPFgxhMMJMNfKGMCwUkERVzCcAJs86qaapUe/+wmZjVNGj7B4c0UTpmSZlMEQsh12FF4m0IRKQUhWrkQej1BJe4QSInKW4p137bpwKuMRsnkugJhMOzxaOEdP+mh1Y8wwLbAeI2QrKqfzUU1Zo6QnlPG9jOvdsC6XeZ8WJo0WNITpLmvsUdQduJhM9axUU2eZ3NZch+LIeIQuRFKgrHGlv1iDJGPWqGVptLQhZINsfyxP60ineo1683mELM01XQVIZwW0ZJnhBDoMI2yR10EPCbe70em1Ko0aLx2gWeK83zJ1ljHdx4P5VldFhTFCLZMrnKIBFzwiCMHOMToroA1rLsFsXMOpTIeKssj1CFkdTiHjnVAysVsjufoBw9mIpol6N4RscH+ncNe+eGFplL291qf/TBptc+WTRq117l/XT5fOJMYV0mMWkmWGE9q8bDSJ1vSLNMlbTF5n7AnTWUFiLPkCEJXp/ywWD0Ype/6M03mPCBVWs/UKFdTrF7zT8gQtd9DP6xFmDGEqkzKKAoNmRM4EY/QUgJgha1RPW2jNjhEGLccIEwooEJGRVCGSrJc8KOFwApPTvle3YSlw5scXyvm0Io2yUVi/RDElsxRJyWWYWIMF9n8m/R2KodWlPQOFKihSNCtZJkcarTBrlE3v+mM0d2hzNlnGk44RsuGCabltbgwnMZLErKA2Fg8l0GUwhMU6yxhihJ0e4hHyJ8voqxazv8VYeQL24FUkjfYV9AjLa7oNoMuDkQRklZVPEAAtLrw5TFk9BoCOnMU+WfpPBWUVuR4hijqFSTW/jRzJ0Q/SpzqOiaN1bwgVTPHB2PbMRJEYIdJJDVZgtXEA2j0GaVSvI7TmEb7QRy+aIbC8R0ZJj5ACI+n+F8acAisVFLtDWqaM8QzZerY+UcsZMY1i1isoslusZSatesTI+nOZawhzZ8FRmfrShjCqZHmEBZJl8kujHbo0mh6VsmKESiZGmFSxoWgshF3PcMpcOwFopsLoEQ6lbRWL5+WPETJpFFBzes6xv2Is/VfoPcMoEJdh8AhLLMw7YPQIJURlHIjSGeniokKGMKeOUPs/W4bJjjTqEtAfyxcjdLR8ggVH3OncZvbMt7uxL0z9IjrcJKzFSmmXN3PNi/Qa1T3C+a04sgWSAJKvvRGbNOgdrIxzCAAeEQLJv4Jg8c4yRWKExUezXEMoCZjmJ3sjVM+ybnGRN0fo7IC2QWfOW8yMUwVOYa5HiKJhwoSSX7Er6BFOaGlUxbHtpJg0mjNIGbHebrSANJpZj7CkIRxN4u1Remo38YqZmm69KqCQIQynkFK1ufNYkrYapdFSHuHusJYpgyyPEH4JvrQPahrF9KV5SlKo6XZcl0YtxwhzDaFXNKtSMRksKMgEvUiWNErkHHc8WxrVTEhMRh5p1ODip6VRCuC1QXruX+UiKxUzYxZOUVPtBHRDmM7PNMYI2fQlbwYvm1vo0miuRxg2xAjZDY3LoMh4hCVjhIeyPEISken+KKan3Qt3gfWlkyrNzhrNeqjsSKNHtpL+GB1L0lZX1l9r5evP7qdFfHd9GSakpVE9X4w9ou0e0hNCh4cE0xd2MJ7lEXolpNT8iYj6tOyWk8WPzRdQIEuAdSrQ615C2dIoCocJU4aXK2/WqN5o1EggreVetVrZmq+pU26vUQDzWtAzphXUA2h1YavBI8xd9TqUom4BhZrDFaGAISR7wvRfh2nuNCKh0AIeobm/GmNiS6MKXdhRbEGTItIo0oXPlg5UVBr1FG7mqbOyVz13KvGI8EuZaaDuERaae7I5ji6NthmkUQseIZ2bfqDZixqT4RIgEvhEvXdzVsqfvjRPSQoZwkT6gne4zaJKIXIN4Qmd5rZkBmmURGQaSWUly+QOmhE5M/s2VuDlkUYNg1HKII1GZMgUX1pfcILDbEZYRkymvmzRh9lgvWLPKI0OFJVGRYM0WriOkHpFrREMy0A+pGeNFq0jlFWMpTJjveYRplsuAAXbjWZ7hIaC+nSMMNcjtOLSjSRxTBvpy+cRWjGEX1yn/HOg4EbawrxSnvKJhKLFCA9EaacHLgECQULBUIIaDSEBfAVmqHEFvuzbk7eUkD1jLQaP0GQIC4UJi0ujY6lMiMSI7hE+36f25BPJcrNGka7rz3iEbpZJq/02180Kp7CgnVSQL5NXGp0VwKeeV858Ql5z0HwdEkr+SXlu1Wn6VCe2NDozQPRlNnOJKbS4IbSYLxOXM1mj7NllszZ2Q4pIo/sjWjnVX/bQf58jAPCJxkX1ssonDuSUlw0n0eUxGEJdGrWQLLM7jLkt2v/ZZD+qaI+7X8pIo8Z3o1JpNPOu6nUmQRdk1ZJibEoZBbB4Cnl1kBrffz1rNJMsU7R8IpzKuIzG6FqHGzFFyxdPxwiN5RM06NIEtIhML5pB+mN4pCf/iJ6RRvN4hAQGj9CYLHMoBpEUM4RFskbHDB4hi8uyqgbd3SxePjGUQIcn42j6JMQV9EbojPSoVzBZplRBfa5HSKAVRBZhOEEXtKM/RnPrCK3Y0biCIsvG5nqEmWQZBV4JbW6oVOvDF5QQUchQHN3erIteaIaaK4Z78jnTLDO5xYVQEjCo8TrG+LQRuaghNM4CjQRdiKQwksRALP/ySbnSKIB5LaQnRPW6W1ZAMitQ0CMMp3B8B3FKGv3RGWL4U673zxaGcnLgEwVihFwazQOb3M1rKaiOxhUUKp+AhTa1xv1oHmFaGjU+VUX6NF6+WrnvLTWl4ple9f2zBRiMELTOMvBLJCbTiIwjHpZNj93hBOa1ktys0S5v6bue5RGKSCqZV8iX9kpNo5j1xNFCyTJGocziHE3OGfTb3JjXkuUU6lmj7Ax7IxkzU6CzTCZZRh+J4llZo9oGRo9QixEyjzCFVhe5fpHweIGVdYvHCAmgl08Y6wgH4nSqP39fb3ZJmSHMnyzD/gol00WazZ90kdxoCAlAslOfTMWOBPCJ2DkG3SMsGCNUM1puONsQFqojhAWvbjiBY9pIf6zCzjIxhZY2hFnlE2mPUMsaZZFspreTiIyhBLqyl+8u1FwmKpunPp4CHmGwhEeYfwZf3COMGGaBprMNp+iOUQrkT2ZJ5RTUAziiBT2hTN1tq4t0ezPPc27udyiF4zrye4T9MXzvtYLzl7weoUuAS8hjbgEkFa0JrQmeNZoHNo4f2UoKJY7Gc2brRoIuErYWEmPdUmB4do2CexGPcCSB725Sn+lVj24jLNfLGBFkoS/2yb4wTapY2Zv1JA0n6Aw/YetHGyfOVpZR3R2iukfIpFH9FTImy2R5hJa7rJk8wow0qma06NyUs7wo+d6Qs6eSdf3mOhN2hhEZ6/vVM6cUlUZTRmk04xG2uwnL9tQH9Lbs8gm/BFkFBZj33O4uODNIK6g0mmMIRQKfZEyWMcQIY5gVKC6NEoXSYnWELGtURELRcsHyeoTIcQpZowMjfgk7xmhJQ5hSM6O8sTeKp7A0CguL644kcUw7qThZJq7gtcLLerC8IRYI8ORKoyJa3RBIxiMMpzAYp13ZrZwLeoQ5RVl5243mxgiDphihQY3QUSkoslYRMV4KCsSVTMq0ESaW7BijAIbK8gjHqJ5c1uLC7GDmInTmTLjDMo7vyJ8ss2mQFpJPUMAjZOTtQqVPNE00ataoLMu33nrrGWeccfHFF69bt87+Do2wZ/rI1oKJo3q2Z16stxvNZI2m25SksgsPChnC0SSd34rPvqB8YI62tTHwoMUIRUQV7IuAAE/ty3rChhPo9GgHNY4XhZZd1YnJGE1BrzdiZ6gnW7JkGWY/pCxptHRN/UAMsmqOEebWEYKlnFmYoykqFXMmqu+ZStb1GQ2hFocLSCSUoi8P0MVTtMPnDpqsO6t+d1rdmRihX9Iym4zlE8ZkGY+gObiRFAvfFrwgRaRRANP8ZEbawHQZWqwNxCkT8/NchxLSqDZp0+oIBSRVxGTMCpK8HiFyHpLc9M6Ai+wYLSGNyipUmjGQoRyPMK80CguL6w4n6NFt5FCMjiTKjhFSIKFgx1jBtW31S+ER01mj6bXS2CNKgDa3VjgYdCEik6EEus0eYf55YSyfR5h7TzPSaDkeoclcmQQPY3NBE5IAl4B/HaZ5HazcPTPmtZKeENU9whZXRhdFfmmUHteRfyXFnlCx9CVjLyoTebtQJdITTdPnjSqN3nXXXU8++eQvf/nLj370o5deeunBgwft71OHzUbnFV7QpHT5RNnSqB4jzOgMReoIR1P42VnicAIfmJOp32KypKxCBdyC5iPui9ALZpBnelXjEDCcZE3/yHCClmUId4fprADR7Qt7UfXyOyaN5ub7WWk3+sX1yuN71EKrT7BUDvZ/i2JF7qAP5hH2Za4pW6YDQEDCPwfoVD+ZlB6zcgfNcPbUm41EKkVKZcMi4oqxoJ7oKzGxehhddQy4irUX0bJG8yXLANh6haSPqj4JEtFGw0NxzAzkL59g7fkLSaOtbowkgOwYYUzBNB8isvYwFDeEueOgX8RIMksazT0xPdOSkU8azW8IixuzpIqkik4PWlzYHaY5BfVELtqqlL3481vJG8P5N9MDz586WmDWzuARalpum5t0egjSaSZD2VmjKNxuNKaY73ghabTFhZZ0GStzEI0b5M0aNRvC7Hkem58VIujC5iF6xmQylC+BIK8hnORFSsXBKA2kIwWzgpnfmqRRJqXMDRJjbcP2Ue1W7QrRIu0Ji3iEeS13QY8w0YBZo5TSe++99/bbbz/ppJOuueaaJUuWLF++3JEzY7DZaJGVvUpIo5aby+SRRpXS0ihb2eDETvL2lZK+OLCeLBNND+4s7rUvjLMmk+l+YixfG07QDo/WBt4YSilpCN8Y1lam1c5QQELNeIR+EbF8zbGstBsdS1HmFOZdjzA7Rmip3WheQzjdT9rcZGt6mNPlx4AL6/rp4imZL+R6hBGZBg3jlFeEQrWVytmPMTmTuWCsa2YXhI2YrItbkewhY4wwd2wq1NRxIIZZRT1CZj9yr4m+imk6a5QkVcoO3ZXOSjWlHVnwCOESoE8p8rYb1eVERshQl8IyRBL5chFRyhDqw9kUH4nKMMcIS7VYY7OBk7pIIXVUv4D/c5ao1zhlyifSfYM7tHUbSETGYHYdIcpKlslXQGWKEYblgh7h3nCmmVlxQxiVNYuVl4BEXhuiZ0wS8oYk8lZ8ApjXQqJpj/Dj84Xrjs1sZGqLEZPhFiEJmBPU8mWe3U+Pf0xm72lPCEX6ipQrjbKblTs+56ZW6TupX2l0cHDwwIEDp59+Ovvx9NNP/9e//mX7rDKwYXduS8EFTUqVT1iuI8wrjab3XKiOcCzdC0av54MhWUYf3FlnmX0ROitI/m0WeWpf5sEfTqDDjQ4PhhI0ImfSpksawk2D9ORugyFkHmFKe4sKeYSsSq844RQOxSGrmdptXXSCoY4Q7Pm2sG5iXkMI4N2Tyav/n713DZPjKs9F31XXvs59RiNpdPfIN2SDhfEF480hdgzOsQ97Q8BgIgc/JDnBhOwNzibPznngbDiHHQzhyXFICJeQGDCQB2NIiLO3gQAyYAK+gQ22ZVu2JUsaaTSjuXT1varW+bHqXquq79M9o3p/6Jlp9XRXV1etb33v937vZy9zZY+zTNWANxCGvUa93fQMeRnzZcq2RGmJVAzqLOjDisdr1IRsU6Ns0xDT4lk1qCry+wjDmEhZJumnK3Qmy+8jjKdGHat+12vUsFKTCXtQc+CvAh2WnIxQwuaMSxtwiQ1HaclQqNO8HbTY7qoWkRHG1/mc2aqb0mAzQLxoSI2y+/oV4yRKL8OxK/JarDkGaXaNcLFKdBo8jCixTPgbT4lt9RHaNcIPPmI61bUQNepLjovR43QA5GTMl3H5FOE68nMzQgC78oTAur/OGSLneTbQgVzN4QN25HFEwxNn6O/8UD9vmDx+hgJ4fjU2I+RJAex34bCaVYMScCwClqtRNcIeUqPRp7w5zM/PE0KGh4fZr6Ojo6dOnYp68jPPPHPLLbek05bGYMuWLffffz/3mcVikRACoFSXjaoxDvMlTV0taKFKE4pVmdYNTePfkbIpnqwQTWs8FKtYk82qoWmmVCfLVVnTtJUiEamsaRoACuhULWha4P3nNJKXrOe4b0qlpSLVNGOhSFKCrGkaqQuFqlip43+fNrZN4M9+IX3gXOuQTpfk9IiRF8XnFutpQSwVrZeqV0hV973yH/073rm3dMmYdSk8dEr+P/eammZfmIZUqNNFkSpU1LSyZErLJbpUMGSiel9EMsSlEtFiDSpWq8pcQc/LNCPZz9QlrUbZe62WRNG0TmmOiKc0uMcQ9YIaITR4lgBMyuLRZestViuyoBuaZgq6AMiX5MuaXa7Xa0K1Jnq/xPkVkhFkTdNqtRoARVFyknrkTFkVZU3TFKKcWqnqVDEqmgaIdbJStd69qit6pSoTZamgLZelGZWiZmo1zrEBKJTFMUVaKteXRSrRBlfRiCS/tFTbLpm6qWZppVQTNS24R9BKAkwRlGjFarFOqOl7jgjUTPX0slasybRWE6m4WjIIoEAck/HSUm23YlZqkm5/EQBEKCtaddheRleKgkhFTasUi0X2SIrIm1Q47yJQebUYvFmWShCIWjEoOwklXaUVTasCgFkTSjWxKIHWOLeYAGVVK2YiAtqJZWFIFDWtMq7IeYkU/We4qpO6yT/tDItFohL5/Gzl7mdF7pmv1CRdot5rjxhSoUw1zXAu0d/bI7w8TzWNqpAOL9fHlOA7blHFX58mb5gM3g7FmoJaVfMIRkQqrxRrgZNwpiSN5SkFjpWIppWXyrJk+E6USsXFEtG08tGCfEHOuluXS5A8d2W9KlTr7pWwUBBSghR1ZlJEHlHIjFxaKHPOXqkqmXUavh+3paW0KDhri/sxi0WVCIsVxXmp+aJ1Z21PSW/+HpUI/f8u1V/QhEdP0Rs2Gc+vKhSIOrZyVTJUzrsDSBkkfMClmjyskMVC2XvGKgYMqqJqXYFeSBSrdX4UiEcqlZKkBpGu00A4PDxMKS2Xy5lMBoCmaSMjI1FP3r179zve8Y6rr76a/ZpOp3O5HPeZlFL2Xwb0kZwyMUzGVH1VyM6EJtHXoI/mlFyOf24mcuaRCs3lUtz/9UKHPppXcjmSptD0ejaXk6o0JRvOEcpCXUnnAlvjeoWOpozApxhKG4ZIcjmB1GlOMXK53HiJVmGcrmDvpLItS54+WM/aR1ww9M3DyuSKOVfHsEqdlxoGNeB75UeWa5cVxau3W0fw+HL9yhklZ5d/8ilzqUZNiQynaS6nDqUNQyBSiqQk34uMZs2y7p6QXy3Rl40GT13Z1FdMcVhCRiXsmdmUuWrSXE4EQCUzl7JeYVPOfL5gPR4DtU4VKXiWAMwMm3Ml66Vq0EezSi5HxnN0U1q/eHPWeVoubUKkuZxb3qEFOqQauVzOCYRDiq6RVEYyc7lcRtaLQiYv6+wdhRQKep39rFN9JJ9RJUNOZevEHMuSyWGhZNS51yGVjIk0rUI2JTKUanAVbcoaRSKXJTKVNkZzaZ0Y3gNmkFVTlam5YiiMAAAgAElEQVQsUjWdUUQoUvA5Uym9JGVrMMZySkYxBUU2KfIqNQk0IudygiAZ6RTJ5axtvyrpcirjXPziMrtiVQDsE+VVI6fCeZeMYgiK7Pw5g0JpVtJrJnK5XMWAJNSH89bZGKlSHYZBMJQN/hUASdBTmUwudEsyVJbpRMbI5dSteWPEc2Fbh6rDBP+0Mwg6zcjG5TOZJz03i+8JkpHxnAoA2ZRBJJLLCbAv0befZ/3XaMaYK2AiTQLveNVW80vPcb7ZKtXH8xnv2+ZUA3LwJFSJMZEjFHhSo7lcqmzqk3nfWjSVM8tnaC6Xmq/qzp8rlCqiezvkM5QK7pVACzSvcG4WhuGUfq6EmdHsco139kQjlybhb+rcMTPHe01KaVr1vZRRs+6sv3g1/vursCkNQPnmi+bfP0MrkkhJvW4i6tiIZGRTnHcHsJXQ5bqey+WqBg4cNP7xdSIAHfp4CrqU8v7JQoFOZyI/flaqm2puiEecdohOqdFNmzal0+lnn32W/frcc8/t3Lkz6smSJG3evHm3jc2bNzd8fcfwZWceL/KGMTVqn2hZLCMSZCQU6kGegSs9X+XR2RnRpUad3jgmltmWJXkZwwp5yd5snrGp0RcLvpcKU6OnKu44qpeKVCSuCAIesYyjGi3rHJdIb0nsRIle8k09TAxqdbpQoTpt4CyDpl3WoqjRyZTrmeL0Ee4bw0f2+75RrlgmQB/lZcxXLCI6LeF02S0isn4JdjJrJlUEYtcIkZVixTIGxlR+H2EYEyksVNgUJKvzIQyLGmVeoyGTAQBTacyX7T5CJpbRkZZc49mAH41M4CX+w+0TWcn1V0PENVwzkZdJ1X/FOs+vGowa5Xx/DahRm+CaTpPwPdKwfYJ98CEZqsi/xmKc3MMVgZyEl0pkPDTc51WT5OfznOPgNdQ3rhHyLNYs5d2JkjuZK7CwiAGxTCw1mpXI7BAZUlA2OKWTKGp0d57kIljLIQUlz0s5MrSsxKIgAOwbI08s0ecLdO8wqZuIYidjxTKEfYlHNfpPR6w3q5kYV4Prc5S9HEPv2NFOA6Esy295y1s+9alPATh+/Pi999779re/vRsHZqFq217vzJEXea0tDWqEjcQyztXpbY8bUchylQaM+9idYFCrgsiw4nEHdeC0T3gD4YkilexKybnDOLRiPZmNhhlVSUBZF7Cl1k0sVInTQ/LoAn3FhO99A6pRFozjVaPPrKDOM54u6lioQDf9fYSeE6Xap2VUdR0uKCInCUcFwqkUmbe7DpxztSVDfu8832UZXjS94+kZhhTMl12xzOmKb0lyOij8qlGakQgbK8HV6FcNjKtEq1NnTGsMJlJksUrZFCSusAKBhnrevTeVxnwlUCNEWsRkCgv8GqHvzIQHlGdlbPXslrjtEzUDeXtGY0n3eZowZ0HvN+5FfJ2PyaEBbEpzRIBN1ggRPb4gvJMINNR7kZPJEY0EbGUAbM8RQnA0tLCEdcJ81ahTI7SinRs8GFgPa1nHUtWVmXiHESI0o9gp83ORkzE7TEiE/CQqEF40ht/Yyn9NAoyr7p2rhWI5gN15slChv1ike/JEJJHahZgaYVoCISjpOF6CM5OgamA8FVyf50r8EVQMvROOdqF94qMf/ehjjz22Y8eOl73sZe95z3suvfTSzl/TgVOo35nHC7yMsKx3JJbZ+3XL6sXbj8i0XgHjPqag+/ZR8+YfuBkEd5gy85GBPxAuVuEY3Z43Qp62PXOXqnRMJaMKjgQDoe+Cm69Qk8JxiH5skV4yzgmEJZ1mPc4yzjbCgTcBYq/24Cnf+TEoyjoWKjCoz1nGtVizvehgtQdZjz8wR9/4XX5uFRkI03Bmr4eb1h2EF02v0ShDXianK7ZYRsTpCs17TqbTQWGpRu0+wqy9+eUmhexG1fS4Y3MwruL5VWsKUpQzbbxqFGxnUKZMNcpehAXFCdt4tmH7RIAA+C8vE27Z6z7EdY6umcjK0ClM6hv6AU/7hMK7xRqoRm3r5PNGyPkjwY/K4nWMQ5uTk21K4ySvOMsTyzh9hEErnJyMuQonIwTwqkkhvBfki2Vi+wi1OpZrNFC7YTswZqwYlREG2yd4EmUHr58h120lAMZUEu6prxkcZxkAW7Pks1dFrpKbM+Skbf1YCG0xAQgEF4yQbx81dw/xhccMOo/kcDCmkjNVerxIAdvrw8S4SgKzeU+W+SOoGCb9E7C7iC4Ewi1btjz88MM//elPjx079qEPfajzF/TC2dztyvN7PGMG86LR4BKT4niRsqFL3l2kEwjD1OhCBc+suA9yez8zbkZoZRJsl+0Y3Z47TA6tUAAUWKljRMGoitNln8Rc8u+85krYnaPPFyxdxKMLuCSQETJnGXtxZ4GwFtoae1Wjz67QV06QB0+ZAA7O0b9+0gRQ0iELWKjQepTptj8jdDZozxdoIULczKUBAUx5Rk1xWxSsUxGaPsGnRp2MUCKnK24PADwdFP72CZ/Nd/h9qzZ1E26vDuPGHeQXi/S/P2ZORc9x9WaEMdSokxHWTLBk1OGQW22oP2eIeIkmfkbITAbs3krvJ1UFUjVp+CpiiB+uy/qCAFwxRf6WtwrHx1EnI5zOkFMhh15EUKNVz/QJL5gv7jivyPuqSRKw9qY8nimKGnUC4bOr9JwhEghDwwpW65grATGBMNRQH0ONHpgVLpsiAMZ5gu0wN94MptPWEcI/1MWLfWPke8fp7jyJcbyKyQhhJ3PHigCceQAYU4Pr88kSneaNoGLYkiUslHYdXbNY27JlSzabbfy8FuGQe9HUKI3xGo13llmqwaDWE7yXPuug4FKjyzW8qLlu0at1hCu3adEOhB7/THiMbs8dsQLhag0ZEZKAEYVQ+JLLwBo3V8Js3kyL1nCvxxbpK3gZodtQL6LEp0bdRf+5VRyYFX46TynwP35pfP8EBaDVMZ6CQLBSizTddmuEngEURzRajtoqRtwhkylyumKF9gAp5wWnfYKTEWK+bNFZNjXqvhpbj3QTBBCIp6He424aRtWg4yliOcs0yghnsuTnb5Reu5m8fJxwDZrhb5+IoEbJfIXaNUJSM6hVI7SbFOP7CKOYMQf8GqEBWXCdiTK8jJDfUB/bC8j6gmIQHwgdOjow0O6uZ82/fcpEVI3QMd0O1QgBBPzVGC6bIoGMkPXyB0Iadzavt0b4zAqdHQ6+PqsRsozQOfMNM8KYQOiAmxE2vAC42JwhJ23yOdwKyfCyUVIxsCs+EEbXCGH3aRwvUQAVO3Fn95cX8TXCrRkcL8Z/mjaxDrxGlVixTCNqNC4QMkN0VjPzMn7MXKZuUsVzN7D95lKV6qZrxBcetAZPH6GT5SgCJAEObXLuMA4tA55dM6umBKhR7+p/skyn09gzRA6v0peKtGpQb+cibF1DqQmxjEMDPrtKr5omoyq57yj97nHKqvpanWYlMpkiJ8s0SizDtVg7ornDp/7hGfOfj7i3SxQ1yozEWPWuELEVRaiIAqAYInCYWCblUKNl6qsRKlipUWe/bFGjHnfTSGpUZc4ycWyVg6yEv79avPkcgctAIkCN8jLCTWkcK1rPYdcb4+gm7FEkwRqhf4tQi+AwHXBXMXZaWA2MGwij2rSjIhlLfZZrGOFRke7Bx+plvDXCk54a4c/mKaP0wxeVw0hzxDIyAYL+agyvnCCPLfqm5XG1USnJ3dyY1CorWjVChRTq9JkV7B0K/tWQDK2O4yUMyc1mhFGjJwIYT/FqhP7qY5MIZoS8QLhvjADYnfe1FAfAtRR2wKhRb0bIFcvMlWIDYZaEB/h0BYMeCB26f3uOHC/R8FfQSCxj9bpywUrE7JtoSI0ycpwpZZ6zRStcajQslgGQEV1nox05wtrnHUEB+9eruxGIb7bAXAmb0vScIXJ4lX7nGL12a7AUoIqkZtKiXSPMWDXCYLHEUY1S4PlVes4QuXKKvOdB48pNhHlBsfLbeApzJY/FWkRDvSpCEqwXfLFAy/ZzHlmgv1py3zQqEMLuImesJvcOBFcsE9o1WzVCCbAzwpxPLENWa+6CzvrKS55zxbUXsQJhc2IZLyKpUf9gXm6N8IhG3TGzjmrUyQj9c+1bzgh5qxg7LapAqgYN5OUscFb01izWrvhn/YdzdKlKR3lt0Q3/nMGJRtP+jPCIzce0phqVAWA8JJYBMKxgS8ZiaKy35n3d3s3No4v0tfcZ8NcIn12he0MZoUCQkXBome7KkyZrhKWI0RMBcE3LOs8IuTVCAPtGiSJge679jJD5whwvUgJ3HsC4GhTLnCzHUqMZHC9F/WdHGPxA6FrLT6XIMT9BXDchkLizH18jZH59RY/TMQO7yAL7a4sarWJEcUUrXDegsFgGQEZyqVGB4Jwh8swKdegjtmQEXsq7zJ0s0+kUdufpc6v0/mP0upnQjWo5y7jUaNngpAjOon+8SNk9fOUmclSjf7JPWLFmqiErYTKFU56MMGCx5t15bMtatdsjms9q3OtgElUjhD128XCB7hmKvPobeo0CyMtYrHhVo76MkFGjnkAYqBFGZIQmxlRS1Jtqn/AiKhCy82B7jVIh5FA8lcZRzQrndo0QaRHjtm1NqzXCACLaJ6gikJTEoUYFAolA0/ljmKJSuoUK/vyXRuOMMLbEGKUafbFgfQSOatTrLBMiQoCg0aiDzRnL3I6BnxF6VKPLVbxQoC8UKKVQRYtHffwMhxoFMKyQp1fozjyJpEYDGWFz1Oi4SsIT/toNhI1rhFNp/PI/SbLAv4QYYky34VKj2JIlTo1wPBUsz58sxYlltg5+jbBH8N7bYXY0Ph0EIAuQCF8cD3uUiVaHboJ6RJIzWfJSkYbFMlUTSzW6f4I4gXCVN0w5LJYBsDlDzvEwJ+cOk6eX6RmbGs3JkAVOIHQukrkSptN0zxB5ZgXfP2H+5kzwi7NqPIZDjaKs81cEdmzPrYLdt9fNkD84X3jVlMC8oFhGOJEi3hphFDUK1mN0hhoUJ0q0Ylg9RiXDFwkaZoTPr8YFQp7XaPB2HVJgUNgWazhT9dUIRxQsVVEzqGKNKUDFQM2u/EUNoKgayMqQCM5UG4tlvBAJCG9EUbzFGoCpFE6W7FkK1vQJmpaIIkAkzHQjEAh9PTbN1AjDEZrtliyv2tAAIFVEod4aNVqo04dP06eWaXyNUOKZCH7riPlvJyj8GeHJLmWEXGoUoTnyXEc97+aGKZD/50vUOwjs18ucjBDAkIynl+nOvJca9Wk7W1KNOoia8NeWWMZTI6wjH/GtMWO2qNnOaFwjJPNlerpMd+VRNqCbIATDio8apcB8hW6Kbp/YmjkrqVHq10GF9TLxBUKGmDKhnRH6mggBbM9xAqFFjVbxyknynE2krNRcd1AHjljGq+l49D9K3jFg547g0AplM5gYRtVgJ4Z3vz9XopvS2JMn971kzmRJmEYPqkZFlHgZYVa29MrPrtDZIQJgV558+tXikGwZcrIaIVsyvBkhd/oE7GbbEyU6kSLOOlvSfdvG2ECI+QoOF7A7z38C+BlhsNeK5X92RkhM6ksZR1SyXKPejHC5irRkDbuJ8t1mrTs5GacrrWWEiJjzwKjRmPaJybTV+gLY8wjteMAu40AaJLWYEXL7OixqlCeWYR9EjxjDFBUINR23XySWdGsobvTBcCRF3ztO2XAuT0boUqOnKyjq1kIcEwgr4fYJiSkt+ccTGJbEzQi9fYSFOgjwv465sybyMsnLrrm5F0MKTpWxK+e6vNb9AaM9sYxDEnhRN+OqdFHwZoQxpXqGwF5qpeYefENq9MklOpkmOQkVu/AcWJzPVJGT4q7hqTQWK40nWbaBgQ6ETM/mfLMzWZzwE8SV0LSUMHJyZJlwsUoJUKwHM8vtORzVgssKk5Iv1fDKCRJfI3TEMqfLkZvQC0fI3z5lfvJX5qgTCBUSSC791CimU3TPENHqCPOiiBrDFMoIHWr0uVV6jmcDy+xXaqYVvCdUAkByp1Dxp08AuGgMj5+hRwrYkbPeFEBJp967xevfHcBUCqfLaJAR8ky3c6EaIQBHNQr4xG9Muu0NhEs1d8WPoUZVATlPh2Lz4LKjbC4jc5YJj2FiBzaiWseveqhR2B2xnMG83kAY0Ubmvn5E+0SUahSwPGX4pts8bpO137z7AuHKTRxDGS+4nXmrNbC71SnUTaXJ6TJlQYSR8OxuDpRLvZ8urBodUpASI6naYCDkZYTeo12t4ZIJ8v0TZt6TEXLTQdj1Dn9GGGe67ZSu48G0JzUTn3navQLabJ/w9BFqOr9G6CCwlzpw0PimLYuLb58YU/HEEmaylo6PLSMBw5P43gkAIsFUmszxDBY6xGAHQn8o8n5hDA2pUdjDqblYrGAiBU1HxV8F2ZYlR7UQNWplhHT/BDmiWbKdeLHM6Qqdikjzf3u38K/XSR+7VLjtAus93ryLzA77nuMQXxQ4WaJTKbopjbyM60K8KEIN9axOGc4I2fmsm3h2Fef4RW7MBYNNfrcyQlcsw3eWAbBvlDxxBkc0ujNH3PlToYwwaqs4mSLzFXq4QHfnowMhlxoN1Qhh51JOCuWAFeqds6GIWK66y010+4R1r1abaJ8IQOWVUhpSowCmUiTtkbY6vfw5CZoe/KvA9rzhOhipGhWcMV40TI0yFWsY3PYJZk0yJOMnN0jxAiPuXmG1bq2Mzq0tCxiyZ+Yd0ahjcsTLCK2sK0yNpkT84vpK1OE0mRF6qFH8b5uJ6dls5WXMRuzkhmSSlTCVdsUyeqN5hE2KZRYr+Oph87895J7E9mqEWQkCseYmcp1lvAhcQg+dNp17pyE1+pJGt2YIky84u0xvVSJeMsqwNYsTPeigGOhAGLigp0MeE00Fwmi9zEIVO3KkWKcBanRYgUAwX6Y+atSqEWJzhkymLLPQ1TrHYs0Ry8yXMRWREYoEl0yQG3cIO2y+9P95pbjFvxtyMkLG47Ej/OrrpKunObccWxNdr1HP1RYAYwKfW6WBW3dIJis1ygSZYWrU4yzjWvAA2JUnZ6r0l2fojpxv/lTTNULMl/H8KvaEpOcOmvQahUuNskfct2QWhU5jaDAjjGyfoKpIchbV3Brl5PB+3rmsAWqUm7xNpa3jt+YRuhkhtHowj0zbJ5yhJbHMLxbp3x0y4dQI3YzQd1iqyE8HEUGNFurB4bRR4DaZrNYo27Z6o5Gjl3lRw848qUeIZZxYxb3st0RLMEI1Qo5qNCWSiv1pC3U6kSKvmiS55jLCLVmf2DLoNRoSyzRTIxxXcaaKv/yV6Q2i9ZDHXpNwzGWi2iccePfEx4t0ruQyxg0a6lVQYGvWGhfq3FzeLOVkmW6OzQgBbMmQ4z0oEw54IPQlamHXwWZqhDE99YsVuj1HNJ0TULfnyOFCwGINy1UQICXinCE8twqTQqtzaoSOWGa+QrllgybhhJ+5Mt1sZ5a/tY1wt12qSKr2HFfYIreqQcMpQkYijy3S+TI9z298xfbFrEWPuTLyxTL+VUYguHCU/MtRuiNPHGq03EKNkBzR6FKNbom+AbjtE/yMUHT/9W5smUNC3UuNVt1QGiOWUe2mjpYzQtHyVNxyd93p1/arRqNs50gqpkbo/6u06PZuoqn2CXcVe2yR3veS1eitCFbk5lCjQmQg5FKjDYtM7is3lxHCswM+UqCzQ5YgOXxRjdqemVEOAFEYln0ZYWCrFz7a1RryMq7aRJyQvy1HAk5PDoYUbE77/jzcPuFNrOOdZRyMqeSlIi3Ug67rbWSE8LQSNlEjdIudjyxY+TdDw4Z6ADNZkpbY0mS5/sJjNRDfTc/Qo576gQ6EIWoUJ4M1wsYrVIzd6GIVO3Io1jmdUtuyOLzq214pIk6VKbNPPGeYPLdKC3WLVQiACVUosFCx5A/twQ2EJUxH72cZWJxWROt4mH/KSo0zNyAr48OPGn94vhiI/azHgJsRKj6xTPBc7RsjTy3THTniWuo0nRFOpvDYIt2ZC3pTecHxGuWYbrvVwRSXGvXWCEUs12izNULm3dpWjZD5lN5y0GDhSm+KGrWyT9VRjYoEQFYimh6sEWZazghJ1V7FtDoYjx0vllHFyNcUBWKE3EIL0bLDAKIDoU81Cl9GSGeHSZRqlDm1oo1A2ESN0Ossw/ykbtojvGW3dQSfvUr8rW2R1OiWLPGmv11pn8jJUEW872WCPyNsMxA6rYRhO/sAvEvBwwtUJO7nalQjJAC2ZuzOLns/7U0KG9YIwToozr6MMECN+jwm0HSNMGoAxWIFLCMMUKNgGeGqL51SBZwqW0K4vcPk0ApdrXN6JwBL4HOqjJzcYGGKhxMIT5YaMwZs3fTeQmkJKzXOAWQlPHSaOrVJB8wOSrNqhL6M0CvTr4Y87faNEgB+apR6G7fjM8KqEScZBVcsE1osshKInbexw/OLZchS1a2YKgLxZoRc1aijWGZfYsxWlwu28Gl1ujlDXjFO/q9HDNjWGyIhBqVcsQyAqbSrGq0ZrrsbPyO0SXiGhuug1zG5qFvh32mfsJxlQh6b3CZCRFCjDYtM3lcO9zWt1mg4I9yUtnbALxYwO2Q15IUvqskUzlRh0DYCoZ8a5fFM3rBdqGNIxstGyVt3N74sZofx8jHizcUbWKw15ywD4IOvEH93r6B75iLVzHacZQBM28LRKIs1B94P8sgCZdZrDPEZ4ZAMkWBrljjzAFSPCow9p5ka4ZbMWVgj9LNww4rlx++gHGs0yhDXPlGlO3Io1mk4y9mWJcu1YPvEqbJlqL9/gjy8QFdqHKNRhrSIFwt0iudk0Tw81Gjj64Mdv/cWSotkucZZETISbj1XCMtZGUHEWvTGVRBvRugVy4TO1UVjhAA7ci41WjJ85Z8YW/oJFQJBjGQUoYFtFQMiCa74AkFOtkKgTY26rzmsQNNRNqgnI4TTgJHhZYSOYjknt8yLwl43mRflB18h/NMRl82Lzwi3ZEjObqivmu64Tab54lCj3oywFYs1rU6tQGhSWSAxGWGL1CiNGn0XQIrXPuFQo95C3XTGygiPxGaEkoBhBYsVVAyqtlIqG1as3iEGLs+UEt1LerVG87GmOV68fY/wgYsFb69IeAyTz3TbaCojBPDfXi5kJN/d0Z5qFMDmNDlZpiZt7CbovYQeWaCvnnY/V3xGKBCMqtiWRUp0VaOwVWAMzdQIz9KMMPC9BsqElSYsP6LEMlodEsFEihR1jt56ew6A73pVBJwqU9btsH+C/HKRnqlyJKMMGQlHNDrVKHrFo6WMUCCQBd8tlJGwXKVh1cBtFwgfuIjzvVvUaB1Zu7s/ihoNnKuXj5PXbiYZCUw1alJUdJ9MP8aEUBIwpiJGMgpAIsTw6MvD3fQMeZk4FmvwU6MCQU7CQgXMPFYRsFT1UaPhjNDZhOWklnlRONSoPZ2A7Zp90yciAuHv7hU+fpnIDrJQh2y7P7PLOKAQcXYeDLVWTLedjJCVTtlCH7Y+Z4MpuOCqRsPDaaMQpkbrJsq6RY0GMsJTZSxWIQmYTEWqRmFPuKwanCJfDMLUaHxGuMpTBsQjhhr1TqQyKGotHrzTQmNSUERSL/FgrYRFHWlerccLR6j8UpEKBLvzpMkaIYB/ulbaPUSYwqvKo0ZPV/i9mF6clTXCUPIREI42Q43mI2qEi1U6niJZCVqdM8KCNb/7LdbIqTLY0O0hGTNZ8uApGh0IyYsFRPVONAknEIZFklyoYpAaXa5xdohv3yNszXIObIiJZXRrR78pTZwgKkf3EQIYVvD935Jgl6zKBih8GWEMNQpgMkXiM8IAdxTupmfIy26NUCTBje2oSk6VHWrUd0ozUnAomvdj5mTSsFc1DG9G6BCYXtPtKGpUEaxAoopY9kTrnIxwH2EgIwzPIwy+uCez1+o2NdqgRkhaVI02XSMMqUaZhU0hpBplNZEjBbojR5xLMWaOVdQk4SgMK/BSoxWu16i/ob7JYO8ghhqFJylk57+lq00mll6m7QIh7M60Zmhtp4/wkQW6f4J49wcNA+GVmwgB0qIrloE/EEZNvvSiR77bAx0Iwxd0ICPk7t0CiKJGFysYV5GTUdQ5izubHRjoI3QyQgCXTpLvnzDDoycY0iwj7EAyCk/4qUVYewSgCL5VLC1ipdbCijAkEyZeZ21M979BPNeWlTqZBDN3jYpqLEFxKk8OYrxGAfzpxcIVm2KpUf+CG2WHeOMOsiMHAGkROTm4moyqmC9b1KgqgqJB+4SjWM7J7WSETJZSqFMWniueJCY+I/S8AlZq7uWdkwmvRhjICBs11AczQgpO+4T/T8TIS6jzGmEgI1yt0ekMKeswqV81msGPT9Lr79cvnXT7ELgnkI2qaJUhHFHIcqM+Qi+Ru1rjNE3Fw58RBr8mZ6vXZO8E9287CYSb05grRzpue+Gc/yfO4OIx4tUQxXuNOrBGpbr3l5uoNNzJAcjLEAjfCqoTDHYgDG0Q2sgIo8QyC1WMp2BnhMHXmckSwV+IYl/5iL3bvXSS/DguI8SL3aNGmyz+q6KvFTctYbnGaZ+IgtU+YROPO3LuRe2Mwog/EqYaZctrk6pRAAdmhSg3ZAaOBxVvqb3jVVYj5pBitX94MaLgVNntIwTga6jnBEInI2yzRlizqFHCAiFtjhp1oIiomW7RN6pGWPK3TzTsI6xGZoSkatBy2GtUiAwqHdYIw2KZ1TpGFOvr8EajfaPkX18vPfRG6bNXiXJsIJxK41jRZ0fVDBxbJQbuqhIWy7QESQCl1r4hNiNsylbGC2eV6CQQ7sqTM1V87Jdmw9YXJ7Ut1OmQYnm1MzTMCBkCLc7eGmGTH+HBG6Umy6jNY6ADYc0MFr0d/RhDhSd0DiCqRrhYoeMqycqkqNPwpS8L2JwhgT5CwLVPvHSClPXIGmFaxJECJjsVy1hazSapHlUk3rsoI/HbJ6Iw5KkRhqGIqJuoGHFHwth/ZrLVPDXaEIHMo2Gj1XQav3pT8BmjKjlVdsUy8GaEPLGMr0bYRiAUUDUtapTtqIv83ncAACAASURBVGpGU9SoA1bOTLsZIcdZJi2RsufUNBTLeP2xtDplJLbPdJsrlulNjTBssbZaw5CCnIxC3XdLCgRXTxM2vMVx+4uqEb6kceriDeEtE8ZPn2Ahs9W8DZ4QwgmETkbYnK2M/2+JbrptMO0hJ+PBG8RHF2mU+s+B00dY1pEWfZluvFjGgd1Q7240HcauSUOAC0Y6Wle5GOhAGM4/HP0Yg3eabhRYcSX8+GIV4ynkJBR1/sS1bdng9AnAzQgvHieKgChqtLtimfBYQS7UIDVKDNrCvTFstU/wd/SMEqkacSecWeqUdIwoPmq0yTskCm00WoV39KMK5itujRDw1ggRbqj3ZYSdiWVg74ItahQwm9gcqPYkDYYuNdS78wiLjIHULc29Y9EXdpaJCq6R1Gi7fYRMhJKXSaHOt3cBIAvWR4igRnG02FrvBIO3g4KbEbLrnwKrrRcIGZyYERcIW6dGPRlhm7YyDNtz5Cc3SJ9+dYNz54RzRh540/pmM0KJVAwaEQjbT2o7RLczzK6iagTX8ek0vuuhRssGJhpdlHmZxNQIJQEiwUqdc+n/p52C1zbJzgitX1Mi9o1F2gozs5JutU80U0MGTyyDCLtkLtz2Cd4pZQcTn5umRZyug40dWPaoD+JrhA0RWHCbb7TyYlTFqTK1VaMEvoyQhL1GnXP+mmlhLHaKAheuWMZj9NMaNSoA3oxQIlrdZLbdznM6sVhjN0XJcCfUe03b3Q8iRJIKUc4yzdYIPd39DKz2lpdpgVetsD6CGJsRpvGS1tSuMQBfRsjjmdhoxpqBQp1GbX/jodiBn0eNMt9t0qStjBddoUYZMhLOb5RsOZcQc8FNiaRq0wJN7nctatRe273NS30MhAOdEYZFIpvSPt/tZqlRbiCsUlZJyklYrNBwwPiTi4SLxoKBcMRTJL9pj7BvjP/NsyDUaUZo68FqzVKj/kDoyX6awZCCpWqkwTSjROKLssxtPJwRdkiNMg8q51uPqhHGY0QhixV4qVHnRbISSqHO7qpNAo+peA3P3DUediC0Gs5SEinbvjDNUqPhjDBEjWakFjNCv1hGICjplA3mVUWUdOghZ4nWqdEWaoQRGSFWa4hqgXDFMnzVKDmq0Ya6gTC8Lmtlnd+dzDpMmL9aG1BtUjH8NYnEyQhbrhE625G1iSLO+Wcdh86XSBH5lQVgiWXstV0WfAOqkkDIAY8adYeToTOxDMsIAWRlslhFw8Z8lkaMeFLA2/cJr90cSY0CXWufaF4sk+kkI1QwV6ZR6m1GicQfScZSjdJRtZs1QvjX3DZ2zQBGVRjUR406aaUkQEBwUa42p9SNgu0s41KjFcOaHNRkRkgAWXDNvvmm22JrGWFGQsWwWta0Oh1VUNLdGuFSjTt1ofX2ibZVo1bbJVmoUCVC8CI3qBFisdoFapS7F2QHzPzV2oAakxEK1pks1juhRtckENqfgnHXzodi1aVm7vJAjdA74i0JhHxwAqHfZY1rjxvAqErOVINW3f92gj6xRMc9GWHDgBqgRuORFq1W8U7QaiBUBHgb7DK2QUmTGFZ8xmPcg2mQEYqWWGZEIf6MMHIeYZPwrrlNmjEGwKalOw31gO9Fwh0U4R7WlsBEmF5qtKz7qFGTUqHROVFFT0bIVY36LdaYG04MmLEAS32KOqbShA3MYn2EXpMB7zFEXUJcarSlGmFQNWpRo3GTkFn/OI1un0Armz8HI6qPGuVe5FmZFOq0jSZCBkeyG18jbPXa7kr7RPNQ/dSo0z7B5ZO5CDTUe2XAbRsCdI6BDoThHW5Ggkjc0TbN9BFOpLBc821d3/mA8YGfG7+xhVw2SQBk5aZ2kbZYpqkvKiNhMtWahjsMX42wHWq0tUUhLzNHMf5R22KZ2PYJmxplW2an56HzjNC75rZbI3QdEixq1OfCExxA0aRAKQqO6bYzKLHiV402c04UwasaJcWQ6XY6RI02rCWPqGS5RnUTOsWYCn8gDM5gAjAkRyZAHWaEHNWoTY3Ol+M2puy+MCgNc8s5GRmptW56hmEFTithlF/V9iyOaFittVkjdCS78Q31rdL+a58RWmIZHRkJTvtEWW88I50hLTKxDFVEnwy4mSbC3mHQxTLhZXc6Q06V6NAwgeUB0eDkicRyIGQVu0Id/+uY+eJNskNyZiUc1RoHVFWEQCL7JQLISKRDpQxab6hXBdIJNSoS5OQGGWGjPkJS1s2STljxoGaryHSznRwucGzejLDhLI4w2NfNVjCnSu8g3EHRqjtJAGz7X6jRnCyAZYQGdNPTUG9CbNizJQRVowE3gxA1aqmBYjCqYKmKMRVZydIpsDwyJZKlGoZDq/DvnSeEJkxY6LRGGHKWYe0TVkYYvU1ga7FJwaUZptKRXG4MfDXCiORmV568WKAm7Qk12n5GSNxVYg0CiU8s42mfYL82A7uh3mLX1jiQR2GgM0LurtzbU99MjRC2AyH7+Z+OmP9hs+At9eVkLFabokaH5AYCBwdpqVOlDFqnRnfl4Yz5hSuWaSEeDyuEKxmFfQNUYvMkZrFWMpARfb3bXcgIPT31bdcIAX77BHh2o61OMAiA7QMKwRqhhxpt4t5TROIsLikROkXV8J1JWbD69BmaWUrYaEatTrMSYXmwoxrlUqNhf3Pvf+k0GCQbji9wECWWycnkdCXuvmb3BdtVhLEp3c4XN6SQ1bpbI+S++648eaFA226f8NgzUSngLGNnhMVQ+0pDyEKfxDKGTyxTbmIiHkOgoT6mvXItMdCBkLvH2ZYlL2rWJdvMYF4Ak2mcrlg//+Pz5lt3+y61rERWeVMaAlBFt5u+ITJip0oZeANhyFiAi09eLr5ui09bjxbrJUNy5HxqRywTrxplYpm0RLy9290NhG3WCFW3Omg31PvqqYEOis4DoZca9apG3Yyw0c3nrRECyEmcM8mGXzI0kxOMqmSpStlkYysjZNSowOmmj4dESIAaLeuQmx5ZpYamTzg1wvkyjVlV2VocPdCRdNo+EcHy7crjhQJWay3byjA0kxH2t32iGTitqOwspURSsX5t9uJhDTBlu3U7yQgbg7sY7R7CCwXr52YG8wKYSpHTZQpgqYofn6Q3bvd96pwMisaq0dkh8tmrml0af2s7eU9o4F+rkARYzjJtLcqttk8AGFYQpd5mvRwN+whZjTAjQRHcZa4LqlE/NdqGrwfjABRPluwtxoQ7KLoSCJmzDOyMUG+jRuj5Olj5NhA+vWXC5jPCYj0UCP1uO80gTI22JCThWqyxGmGjjJDUTWpQ/k5iKt3U5jiAQB9hTEbIrMVafgNPINSja4RtOcusqVgmSI16M8LmTjsBUswG2V6gnES5E0OADjHYgZC37LLLkf3cJDU6mcZ8BQD++ah5zVYhkPRkPbN7YiALuGZrs9/Tjhy5fKrzjJDorYhlAsi0nhEOKw0ywniZbsa2WHNqhAwdNtTD7TgGgGK95V4rALLgzklWRBD/0Hk2gOKuZ82HF+z5w53VCJ3BvGwsIlONGqbVqmGiOWpU8B0kc2sLfPK06ApHm1kKR1Us1azJxk6NUBGdQNjCiRVDqtHmC4Rgp4hnsZaXcbrSSUbYzhc3Emif4AdCvFBo31nGMScLzCNEp84ylhHj2gSSSGq0iYl4DtIilmuW32GSETYG1ztxV548v9piIEyBZYS/XqKvnAheK9nWA8baoFWxTABpiYjRkyK4GFJIjFimZtIGGaFtsea9Q9CLPsK2VqJRhTh2LcOKr9yblXFEw3/5d+ON3zVeKrafhTtg6Y7mZIQe1Wjz1KgSokbDpzFjm8voJgTSuIY9opDlKvVnhNZgXrSYEUoh1WhLGaHXr5nByggVcqbauEYYdVFtSpOW5vkxOKpRdsdx2d0tGXKmSufLPaBGvarR1sUya1ojFFE1rA4WWYAiQKcwKUo63xKPi7REnIyQLSxIAmEMuMvu7rxLjTZZI5xKEZYRHtHAJvV4kbP37IMGdsPXbalhq0hHzxaPQlxGKBDG7Mfs+/zUqJsRdug1ikD7RFs1QgCjKphiOyPh+bf6PmdGwiefMG/aLbzvZcL/8R2jYnTePkGWqlQVrcXaUo1SSK1Qo2ooIwz/iUONNikatDNCSyxTYmIZwbrRWqNGQ4Gw+SZC8FWjVo3QpI1Vo1En8O3nCLfva3lZc6jRGLMqgWB7jjxxplNqNKZG2MZV590ur0UfoYiagZLnLLHP1bxYBvaoVNVqnyBJRtgA3F35TNYaQg3WPtHEEuuIZV4s0J2hYegDnhG2nZqkpZYJ1WE5uo9QRM3AXIluihYB2dQozUi+iZ2dU6Od1wgBjKnuvipgjJCVcLJM/+tFwvv2CYTg0QXaeUa4WHHTI0s1akJ0G+obb26CGSE3ENodFE2uIyMKlqvcGqG1RWge3Bphwzk+DgKqUZOipCMnuRYEUbAywgjV6GQKXovgJuE4y8Rv9Xbl8UKBdqwajQyEbbRAyGvbh8c+hVcawzY0zYtlYNUIqTpI1OhA9xHWDKqEVlCRYCZLjmh07zBpoX2ibAI4olFvgwEDy4EGNiNsu1jF+MmW8HvnCVHXokxQM3G8hMumIv+cqflX68GMsMuq0XqbGeFnrxJ3hLZBDMMK3nGOwDZJe/LkWLEBCdwQqoCFqlUgBJCSyGrNrxpt4pwMK8Tr952TiUiC7QqtZ4RkqWZqOslKyIhujZC9bqvUaLhGmG+62TwQCAt1ZCUIxLUgiIJiu5l0sSLm9BFWDL7RKMOuPKFoPKuIi1hq1DLdbiMQ9kUsU/IIa1kVoHmxDKwaodvLVFvDjDYKAx0IoxYjVrXeO9yCWOZ0BWUdKzVOL3aTYpm1BwuEDYfMRSEttjCMkCFmK81Ez8eKdCYbd7WmRSxWkBG7XSP0rLklnWbbsvaYjf50H7jIbc7elsNLxS7UCM9UscW+2NIi5l1qlBg06BHDxd2vFb3HkJM4iXVaZCMJSc1oSivhzQizMoq6bwFtVSzTSY0w0D6xaqsxLZvy2IywYnTKMQSQlmBSm+KLfutdeQK0WSNUmhjD1MbN7lKj7S4ULYExQ2UDGbfDlVQN2ppYRnJN7dc4o43CYAfCiMVod568UKBVg8hCU7vCqRSZL9OjRbotx/GiYGRgJwWhHsGmRtssVu3Kk6+9rmt3Btu4HStiJhv3tLSExSrtRUbosHBt1whj4L2HZ7LkqNYpNaoI0E03KliqUTsjrJtNUaOBA4ivETbjr4ZgjRArNWueuyJAIO1ToyUdAmm5Ruhtn3D685rJCMtGp1dUGCMqlmsNZAe78uwI27VYi8gInX1eOxlhB3/bBpj21Rv27BphK2IZ0fpDDExD/aAHQu5XyzoonlymM9mmTv2YikIdz61iZ0gpA7ufbBAzwiZa92IgEFzRcQuHezACKgZOlenmTNxrZiRyrEgzkrPfJ0CkCUjzcO52g6IeGhXUXWzL4ienLEVc23CGjjJYqlFPjbCNzUFUjbDUCjXKVKNanWzPISOR5ZqpeFQPbVOj/+OXxskSduRI8zVCNtXIgTPVgfkJx3zFioiKTrseCEcVslSl8a3JO3MEaNtizcqAw30Ozj6vkxrhWlqslUKBsKRjItXsi6REAtCkob5ZRLUN7Mrj+QI+f8i8Zbap4xcIxlQ8fJpTIMTGFct0F4qAY0U6qjS42dIidBMZiTgbPcCyFusEDgvXtlKmecxkyUsdZ4Tsb90aodVQTyVCmleNBpCVSDiJdGbzNrmOsIywqCMnISNhuer+lSq0rxpdruJLz5nPrLRfI3QyQgLk5DjVqCyQHmWES7UGPv57hki2dQ0ag0ONaqGueTera53e7IRWbQM8ahQVA+WmvUbhN72K0RCtJQY6EMZQo79eol87bN66t9m7YTJFHl4wuYEwJ4MMdiDsI3XuQBHx/CoapuDsEmcTAKo9EMu0ZzTaErZlcayIWsftE4AroWTaTq9YphlqNICczLGZToutiWVSIghwuoysjAzTLDiBUHRXt2bgDYSajlEFX33ebL5GyAzEnVl0qx7HlrxMGtYIO9xahTGqYLkaOXqCYUzFr9/c5vXHqNG6ibIRrKR2RTXajOV651AsjahPLMNqq83vorymV56MMHGWiUAMNfrUMr1qWtjaHDUKYCqNh07TnXnOf2WlZkdKrjGYZ0R73fQ9OBi8UGjMRWfsQOjPCLs2j7BYb1Mp0zymM2SxSgv1TlWjgFswS0mkotNOqdHYhvrmN9SjKo4VKcsIV2ru6qmKpCWxjFfKq9Xx/otEghZqhPAnhSs1d7RLTm5UI9S7nxGOqmSpRhvWurib6WbAtobLNYwowdWmkzrfGlOjsgCTQqtz2idaEsvA3izKSUbYEFExYCKFIRm/f14LBz+ZIqfK/It4ONpOpb8YMGqUvFCgW2OVMgDSImQBstCrjHANqFGRYFOavFDoCjVq/Zpuq6E+gAixjGWx1jwzNqKQY0WalUlGwmodbdcIfRlhnV44Qt63Tzh/pIVP5dXLzJexyR7Ykpdja4RMNdp1apRlhM0J0dsA2xouVWnYu9/TAtFyVuS4D1bXhBoFoAhYqfEa6ltpn4BLjToWcUkgjECMYPK+66Q3zLRwxUymAHBsZQCMKHjiTW0JonuMgQqEsoDVejPUqDUT0ZcRdsFr1JlT03NqFMC2LI6XaOeB0DHeTIkeizXmNdoONUp47RNWRlgzgw6WURhVMV9hNUJiUg812kGNkI2z+PNLxbCFYQxSkttBcbLsejXkYzNCWUDZ6GYTIQOrnraU2bQEFjBYRhhAJzVCnxHjmiznioDlmlcsQyoGLTU9mBew/IoD7RP97SMc8EAYGQOumuYIB2IwlSaygCgqdXPrg17XAHZDfVMzmHoNtlzG904ASNtZhTcj1Ls3fWINaoQAZrLEpB3tP0QCSfBkhBLKun8wb+t0MZcabbV9AsCIApMiK1vflLP6/N+XtJbPiQLR7aG9jqtqS/BeJKfKmLYzwleMk53RDKStGu3yTcH0tL3LCNmHXapiNBwIO6gRrrFYBoAiYqXmjq5MsYywJbGMSIgzCsbTPpH0EfLRRdZ7MoWZLBm8XsE4uGKZAcgI2TE0UyNkdaagarRTapStuWQNaoQAtmUBdLq/VgQ3NqQ8g3lZUG8jI8wrnNPoyQhp0zVCAlg1QngGdb1pV2sfWPJRoy2Yqznw1ghPluh0xjqAT1wWd8XLvekjHFVxaAWbWqH4WkIcNbp+aoQAFIEs19xdSztiGcnqXkXSPtEMuvjVbkrzmwgHGZazzFoxHg0PBsDWRqlz2l5evb4hXZxHuAY1QtjxvkNGWhWDNcJWLdYCeNko+WrIIcGXETYXWhk1l5UJq+a2vc0K1AijXGpj4A2Epzw1wnj0qEY4qmCpinLsoLFOoAqkatKlWtDnFnZWx7TEraph17ihHlZG6E7KZIXeVscwOTcXW+VovwPh4GaENRNSW1MXuHj9jHDh6LrKBwesRmhTo41qhKKbZ3RzHuEatk8A2JYDOg+EArxeoyWdAtakpPYCoUjwstA17DbUN80csIU45+h72/1qRK9qVG+LGvXM5j1ZptPRfu5eyEw12u1Fc0QlyzWzYkTOpu4QLOrHUKPtRbI1tliDVSOkjsCYjdNqSSyT8gRCYn/8JCPko7vfa1pqx5O+vxi0QDiuNt70ZSSrF627XqNrLpbpguueKpKcJyPU6tZJaJsa5SItMa9RzrjXKIwoRCRux2fbgdChRilQbut7cWbzlnXUTLd9Ih6KQHqbEfaIGhVQM7FcoyMcapTolHYaCNekjxBh1aiAqmXD3ewrpCXfzcU6KJJAyEeH9v8bAAPVUB8jNfLCVY121WvUS42ujVgGHdcIM5K7sqdEa64k0H5GyIXbUN9KRuicQ+YB1B48zZ1Iie3EddV2WTtVjhvvFUDvaoRLNcRbrHWCmIxQJNDbtddfe7GMKmKl5ukjdJ1lWvAa9a5pij14NQmEHHQ4GXUDwK0RDkBGOKyQPUNNBELREst4M0Ld7NQHxO0jrNOWmr7bw6Y0tmbjzE2awf98vXieLcIUCFTROgldDoStN9SPKO7UyYyEtu08nC+lPV4U9uACACc9ktGG6JHXKFONtkTxtQQrEEbUCA3aZkrXD7EMlmtu/mdNn2htMC/xrmn2BPJ+OssMbo1wVCHvvXBw4/QagDnLDAg1es1WcvXmxseRkXg1wq62T4w37e3bNgSCY2/r9NYIuDc4YbVtizUuMi3OIwQwqhLH67ITajQnY7UOtKuUgWe31FpGSHqSEQ4r0HQru+0F2B2xVKWjIarBqhG2lxH2QyyzXHPzP1XE6UprVvhp0Ue3KCKpGbRuroUOLgqDGwjTEj5w8VkeCK0xTHllIDLjZm6zG3cIl01RdL1G6HGWGUwboIZIi9bOoG1nmaiXbTUjnMlgdsj6OSO2v3qOqWSpStFu7wQ8F0nLGWEPAqFAkJNwqtxCY3hLiBPLEOi0U7HMWjrL+CbUW3GxhVfYmsWVm3w1wr5To+tzUTk74Eyon1g/+4HpNJj2TxFIzbRSQr3jPsI1rhH2AqpITFAABKDdUNIyOBZrzTMHs8Pkvuusk5iR2ucbxlScqQJobQyhF05D/VyJhidmR4GpRtsjY+MxqpITJfQoELKM8EwVYyFqlF3e7XE/3mb8NXOWAXxeo8vV1gqru/Lkb17tflSnBtRHMcT6WWLPPgxUQ32r8GaEndOAnhphP/mTTpCW/KrRLt173j7CNjbUrJuwPSgCFAFaHVq7uxNVREUHLKPRZi8R1kfYi3LSiIK5Eu2Vs4xIqgZdqdHhEMHTSUok216da+gsQ+CZnJySsFRrYSov5wUT1WiCGDiBcACHBjeEt0bYuVjGkxG2WY7qO1IiJEJg1wg7PycMHmq0Ha2Bt7W5DYyq5EyVavUWxhB6odp08VypBZtDWUBJ75Rj4GJURbEVq7CWoIoo6yjUOV0iVkbYVkrXhxohLyPsZHs6CNRoEggHFyIBBSqD0T7RKnrUR1haE2eZXiAtWlxod/sIZQEU7bdjZ+WOVp8xFUs1aPU2M8KU3VA/X6FTqRYywqpBe5ERMvOz3ollijqGFM733llG2AfVKDxnSRWxVOuo5yTJCBM0gESg1QdCNdoq/BlhF+YR6s507/UZCFNiT/oI2SuXjTbN+zsRy8AuExbqwUmzTcLZLbWcEfZgMC9s87ke9REqIggwyhO+iQKMdq0znKpB1aDKmvSbMQI24w7mJctV2kka7dQIE7FMAj4UEUV9XfZT+mqE6IJq1GqfaMXbd6DgqRESg5rdyggBZCSU9DbN+yfTrU1xCWBUJUtVWtSRbTMQkkKNosX2CUUkVaMnW3im5+xRRsjmLYyElDIAZII67TQjXLPpDSxaO5EvJaJQ70JGqCeBMEEUrIxwAMYwtYpu1wiJQSmAYlvjfgYBKZFIhAIgBLSrGWFaJBWDtqeV+K8XdfTFsIxQq9NcWyU7VcCCidU6JNLC/oYNSe9JRqgyGUivbjdF4EhG4WaE7Wx5ve0Ta0MdKQJE4r6XKoKiCzXCRDWaIBKyAE1fl9Roz/oIaY88kXuNtOSrEXYzEEoo6/0psTB/zradZdhFcrJEpzMtnAvFOo3dvwxYRtgjsQwAReBTo530EfZFLOPN/5jApxPV6CA4yySBcKChiESrr0uxjOIZw9SF9gmPWKZHJZxeIy362ye6So0W9f6UWMZSTDXatsUaKgZOtFIghB0IeyOWATqeOhKDlES41KgkoG7STqhR3QTpzTkJQxF9ewU2taojatR2lulFlt8k1uESezZBFliNsN/H0TpULzXahcG8ljASzRncDCBSonUSui6W2ZzG8SLty4BvKyPszFnmqWV6biuTYWQ7se46RhTCeL8eQREsPU4AEiFGZ84ya+lIrAjE6/drZ4SdvKClGk0m1CfgQyIorFPVqGdCfec1QhY81m+BEEBaCphud6qkdbB7iDxf6E+JZVTFmSpKOs21lY2yQPjkEr1gpOVA2IvsYbSJQWOdQBEwFprBBHuf14lqdC2/fTlAjTLtTNJHmKB3UARU9HWZAznuWegGNcpulfVbIISnfaLr1Og5Q+TwKu1LiWVMJUs12n6NUEDFwFPL9IJWhmYzTVCPnGV6VyAEkBIjMsIOJtNaGeEa+k+pAWqUGc101j6R9BEmiIMkgPayaNE7SIKljQRgdmn6xPptIgSQlojVRwiY3dgcONgzRA4X2lSNdohRSzXatliGVA365DI9f6SFv1J6Ro3uyJH3X9TDk6iInBlM6FQsw4b6rtFUXgCK4NOI2hlhRxZrSUaYIA7syliPgRA2O2p0Y8VnK0WxN1bLa4PeNdTvyePwan/WkTG1oxphSsTJMkp6UzOfHfSuRpiWcPu+Hp5EVbTMawLoZAzT2vceqCKHGk0s1hL0EHYgXJd8oCKganZnxWcrxfodPQEgbQ/m7Xr7xK48OarRcj+s+EYVcqbaATUq4qllev5Ia8VSlvqsx3vi/32leOVUTPtE+4N515IPUARfs4QiQCCdiWVE1IxkDFOCaLArYz3WCMEslQ0oQhd0DS41ulEywi5So6qIqTQ5vErXfh0ZVlDUYdD2B/PWTbSklEEvM8Je4+pp/kE7GWEb06zWXiwzogSHYwdyxFaRZIQJGmB9U6MCqZq0qxlhmw4mgwDHYq3r1CiA3XmcqfZhwyQQDMsdtU8AOL8VpQxsscx6DIRR6Hww71oGwht3CJ+5yrckqUJ32ieSQJiAD1kAWecZYVdW/A2QEW5Kk4mUxel1lxoFsGeIAP1ZR0ZVkhLbTPpZC1qbGeH6vCm46CSrEwlMioq+plKpwHF2nBGSutkf2bODhBodaEhkvaaDsDd63Q2E7WUeg4DXbiav3SyiB16jsANhXy6VMRXLtTb/lh3wBa1IRmHvDtctNcABu7zbrvNJAkrGGo2n50IVfS32rYINmEy8RhNEQhHJOk0HYbdL2GFKZQAAFb1JREFUG2YXNu9sy1xqd8rBQKHrfYQA9uSBvmWEaHtUclYiQzK251r7cwLIwhrZia0NOqQ3ZQHFOl375hkHKTGhRhP0ErKwjjNCFgh1SrtQIyREp1Rbzw31DgQCg4J2NxBa1GgfTs6YStpO00dVPP3b7Ry13EsjtLVHh4IXWUBRx5r1EYaREjttn+i7ajQJhAMNWVivvRPwUKNSx15illhmPVusORAJ6maXExoWCPtCHoyqHX0pLdltO1DEDRUIRQKdtm+JYAXC/u2YP/8acd9YBw31Yv9Vo+u25HJ2YANkhF2hRq0a4XruI3QgAHWzy+v4iILfOUfoyy5hrLNA2B42WkbYgek2AImg1FcjxksnO/oyZAEVY+2mZ3Cx/teVDQ1Z6GcNvEN0USzjZIQbIRAS1LuxOQjgi6/tz45pVGmfGm0bikA2omqUykI7n0oWSHF9DmtjUAQU9X6mg0io0QGHLPST8egQKZFUjO70EbKMcF1brDkQCeom3TA33qY0f+p6T7HRMkLHYq29jFBAUe+nWKZDyAJKeh/sILxY/xvsDY11TY2ysavdyQgJdAqtTrN9nN3ZJVgZ4UZZx9+2R3jjzrV+U0XoyYT6foFd3nWz/Rphf6nRDpFkhAkaQCLrmBplgbDzYYTw1Ag3QEbYI2q0XxBIH/hquRu+fYMDax6h2ebNLhEU9XW8Y2bUbhIIE0RifWeEEip6lxrqN5BqlAXC5MbrBBuNGmUWax001BfXc0bY9/YPdIUafeihh+66665f//rXw8PDb33rW9/2trd1/poJGJT1HAjTIspdokZle/pEJ+1KAwKRkI2UEfYFirihGurZZ6kabWZFynqnRkWU+k2NdmFd+cY3vjEzM/PmN795bm7uve99b7Va/d3f/d3OXzYBAEkg6zcQdrFGaFusrWPTbQcCAd1YntFrD1nYUBZrAETSvk2aZDnLrNdIKBOUdDrGm9S4ZuhCIPzzP/9z5+cnn3zyX/7lX5JA2C2s6/YJ1VKNkkQ16oVgzaDYWAv52kLZWNQomF9ou8rPjUGNbkr38xi6fPKeeuqpXbt2dfc1z2Yo67l9Ii2hrHfJa5SgZqJqdGRyPyBgK/gGW8fXGMrG8hqFlRW1SQ/KZH0HQkVEeV1Qo5qmHTp0KPz4hRdemEq5IxrvueeeBx544NOf/nTU6zz33HO33Xbb0NAQ+3VsbOxb3/oW95nFYpEkW2bArIuCQTStDKBYLFJK19FpEXSxUCFayYQpalqlk5eqVchKVU6JKGqa7/FaDYCitD7PtH8o6wRQQE3N/1m6iGKx2KNXHhAQU9ZrdU0zmv+TAV9SRKIU66ReLmkmbfVvBSprNUL11k4IBuac6BVCoQjU6HCViEIqlZKkBpGuqUB46NChd7/73eHHv/a1rzn533e+853bbrvtvvvum5ycjHqdbdu2velNb7riiivYr2NjY7lcjvtMSmnUf51VeMMuekkZuZy128hms4Nw4TaJ4YxpaFROCapk5HIdNV0PEbpa10dVBK6K9RgIiQ6gLotCT6/wjX37ZFQjkyK5XAtJxIAvKbJYN2oYHcq2Qf6nZL1s0HxabemEYGDOybBBAT0lix2uEp2gqUC4f//+n/3sZzFP+MEPfvA7v/M7995776WXXhrzNFVVZ2dn9+/f39oxnsW4cJRcONrvg2gXalfFMjWz/XE/AwW2ViXUaCfYYH2EsK+HdsUyZL07yzj/9gtdePOf/OQnN91009e+9rVXv/rVnb9agg2DtNjFGiEBNoLRKFyxTL+PYz1jWN4gF4MDdoW3WSNc7+0TGyMQfvSjH52fn3/d615HCCGEXHnllZ2/ZoINgLTUPa9RAdgogTARy3SOO68Uf3v3ul34eZAESO0qgCQBBl3HDcdsIuU6EMvE47777uv8RRJsPDBqVKe083mELGxsgN4J2LlgEgg7wfrNfqIgddAoxVoq++vM0gkYqdvf499wF1SCgUGa1Qi71D4BbJQaYRIIE4QgkfYbpVgutX43BxukRpggARfdnD6xgahRAAJJaoQJfJCE9iOZFQjXMTXq/tsvJIEwQa/QTdPtDUSNAhBIkhEm8EEi7XOD0vrPCEkSCBNsVKS6Z7q9wTJCMQmECfyQOvCQWu/UKAEkIQmECTYo0iKpGLQr8wgJIJANlREm1GgCLyTSfiSzxDLrlhoFICeBMMFGRRdrhAAkguxGmTggJGKZBH6IHdcI1687PwbAVHk9n7wEg40Ua6jvUiAUhYQaTbBh0QXV6HrPCPt6RySBMEGvkJJQM6Gb3csIE2o0wQZFJ6pRSSDodx9eh1BEklCjCTYmCJudbXQpIyTIbZSMMFGNJgggqRGue2eZBAmikBKh1WlX/JElAdkN0VAPRo0mW9AEHkgCWh6/ZGO9q0YBKIJltNYvJIEwQQ+RElGsd40a3UgZ4XpetRJ0HxIhpMOG+vV8SfU9I1zPJy/BwCMlEU3vlliGbKQaobieKzoJuo5O+gil9S+WUZJAmGADI93VjHADqUbb3v0n2JjopKOcpVPremOliEmNMMHGRUqEpnenHva3V4m78+v6ZnchJDXCBH5IHQiJ5Q4UpwOCvlOjSSBM0EOkRBTrVOx4DBOA189skCiIRDWaIIROMkKJrONhhAxyB22UXcE630gkGGykJWg6uhIINxKShvoEAXTSPpFkhJ1jnZ+/BIMNphrtSvvERkLSUJ8ggM4a6qGs842VIibOMgk2LlIiKerJRRaEmLRPJPBDIp2KZdY1MhJJ97VMl9QIE/QQaalrDfUbCQISsUwCHzobw0TWteM2gM9eJfZ3tkwSCBP0ECkRxS71EW4kJGKZBAF0NJi330qTzjGs9PkAkkCYoIdIAiEXYlIjTODHdIYMtZsSbQCxTN+RBMIEPURahNmlMUwbCUlGmCCA9+9rP5RlpY0zs7pfSDYSCXqIlAQk9bAQkkCYoIu4bIp889okpekIyRKVoIdQBQJ7TEwCB0kgTNBdtE2rJmBIAmGCHsLKCJNF348kECZIMFBIAmGCHiItAgk1GkIilkmQYKCQLFEJeogUC4TJou9HkhEmSDBQSAJhgh6CBcKkRhiAkGwOEiQYJCSBMEEPkU5qhDwk1GiCBAOFJBAm6CFSIkFSIwwhoUYTJBgoJEtUgh4iqRFyIRAIyWiqBAkGBkkgTNBD2IEwWfR9SOYRJkgwUEgCYYIegtUIk+kTASTzCBMkGCgkS1SCHiKhRrlIaoQJEgwUkkCYoIdIAiEXIiGJgChBgsFBcjsm6CHSEkESCEMQkgn1CRIMEpL7MUEPkWSEXCTUaIIEA4UkECboIZJAyIVIkt7KBAkGCMntmKCHUEWQRDUaQkKNJkgwUEjuxwQ9BAFUMckIgxASt50ECQYJye2YoLdIS0kgDCJpqE+QYKCQBMIEvUVKTLKfIJKG+gQJBgpSvw8gwQZHWiRJ9hPAzecIu/L9PogECRLYSAJhgt7iE5cJO3NJJPTh2q3JCUmQYICQBMIEvcV/3JkQowkSJBhoJItUggQJEiQ4q5EEwgQJEiRIcFZjQAPhJz7xCdM0+30Ug4W777772LFj/T6KwcKPf/zjBx54oN9HMVg4ceLEl770pX4fxWCBUvrxj3+830cxcPj85z+/uLjY76MYCAxoIPz4xz9eqVT6fRSDha9//etPPvlkv49isHDw4MEf/vCH/T6KwcLTTz/9j//4j/0+isFCrVa74447+n0UA4cvf/nLzz//fL+PYiAwoIEwQYIECRIkWBskgTBBggQJEpzVSAJhggQJEiQ4q0EopWv2Zuecc06pVEqn0w2feeTIke3btxOS9B27OHny5MjISCqV6veBDBCWl5cppaOjo/0+kAFCpVJZWlravHlzvw9kgEApPXLkyM6dO/t9IIOFEydOTExMKIrS7wPpLd7+9rd/5CMfiX/OmgbC06dPFwqFZp5ZrVZVVe318awvJOckDMMwAIii2O8DGSwkl0oYyTkJ4yw5J5s3b26Yfa1pIEyQIEGCBAkGDUmNMEGCBAkSnNVIAmGCBAkSJDirkQTCBAkSJEhwViMJhAkSJEiQ4KzGwI1hMgzjS1/60uOPP37uuefeeuutsiz3+4j6g5/+9KdPPPGE8+utt94qSRKAer3+hS984dChQ/v27Ttw4MCGF0wahnHo0KHHHnusXC6/613v8v7X/ffff//9909PT7/rXe8aGxtjDy4vL3/uc5+bm5u75pprrr/++n4c8lrg6NGjDz/88MLCwhvf+MapqSn24MMPP/zoo486zzlw4ABrtjEM46677vrVr351/vnnv/Od72QX0sbD008//a//+q/Hjx/fuXPngQMHhoeH2ePVavXzn//84cOHL7nkkptvvtlpynriiSe+8pWviKJ44MCBvXv39u/Ae4hTp059+9vffvrpp8fGxm666abdu3ezx++5554zZ86wn6enp2+88Ubn+V/4whcWFhZuuOGG1772tX055r5g4DLCP/qjP/rUpz41Ozv7la985cCBA/0+nL7hnnvu+Yd/+IfnbTji3ltuueXLX/7y7Ozspz/96fe85z39Pcg1wA9/+MNrrrnmb/7mb2677Tbv43//939/66237tq16/HHH7/qqqtqtRoAXdevvvrqRx55ZPfu3X/4h3/4mc98pk9H3VtUq9V9+/b91V/91W233fbiiy86j3/729/+3Oc+51wzrLcEADsVs7Ozd9111zvf+c7+HHTv8frXv/7w4cPbt2//3ve+9/KXv3xpaYk9/pa3vOXee++dnZ39xCc+8Sd/8ifswV/+8pevfvWrs9ksIeSyyy577rnn+nfgPcQf/MEffP/739+yZcuJEyf27dv38MMPs8c//OEPHzx4kF0nJ06cYA9qmnb55ZcfPnx4x44db3nLW77xjW/078DXHHSQcPLkSVVVjxw5QildWlpKp9PPPvtsvw+qP3jf+973Z3/2Z4EHDx8+nEqlFhcXKaXHjh1TVXVubq4fR7d2MAyDUvqLX/xCURTnQdM0Z2dn7733Xvbzvn37vva1r1FK77333r1797I/ue+++3bu3Ml+3ngwTZNSms/nf/aznzkPfvCDH/zP//k/B555/PhxVVWPHz9OKV1YWEilUmxftfFQLpfZD4ZhzM7O3n333ZTSxx9/PJfLFQoFSukzzzyTyWTOnDlDKT1w4MDtt9/Onv/7v//7733ve/t01L2Fc04opbfccsu73/1u9vO+fft++MMfBp78mc985oorrmA/f/GLX7zkkkvW5iAHAYOVEf77v//77t27t2/fDmBkZGT//v0/+tGP+n1QfcMvfvGLj33sY1/96lfL5TJ75Ec/+tErXvEKRgNu3bp1dnb2pz/9aV+PsecQBM4lOjc39+yzz1577bUACCHXXHPNwYMHARw8ePA3fuM32J9cc801R48e9SZMGwlRpku//vWvP/axj919993FYpE98uCDD+7du3fLli0AxsfHL7744h//+Mdrd6BrCK/pUqVSyeVyAB544IHLL7+c/Tw7Ozs9Pf3QQw8BOHjw4G/+5m+yJ1977bXs+tl44J4Thm9961uf/OQnv/Od7ziPPPDAA+yeAnDttdc++uijTfqfbAAMViCcm5ubnJx0ft20aZOTtp9t2Lx588zMzOrq6p133nnxxRczQj85Pwxzc3OZTMa5q53zcPLkSef8KIoyMjIyNzfXt6Ncc0xNTe3cuXN1dfUzn/nMhRdeeOrUKfjPCc6Oa+aOO+4YHR19wxvegNDHn5qaOnHiBKXU+/jU1NSGv04OHjx4//33O/WFiy++WBTFubm5d73rXW9729vYg97lZXJykhCy4U+Lg8Eqm0uS5BQ2ANTr9Q3vgxeF22+/nf1AKX3Na17zqU996oMf/GByfhhkWdZ13fm1Xq8zp6iz/Px4y6jXXXfdX/zFX9xxxx1n2zn5+te/fuedd/7gBz9gOjvuxyeESJLkXEK6rm/sc/L444/fdNNNX/ziFxnZBsAZ3Xz77bfPzs4++OCDV155pfecsJrCxj4tXgxWRrh169bjx487vx4/fpxROmczCCFXXnklm5+ZnB+GLVu21Gq106dPs1+PHz/OPKa952d1dVXTtLPz/AA4O6+Ze+6554//+I+/+93vnnvuueyRwMc/ceIE+/hbtmxxHt/Y5+TJJ598/etff+edd95www3h/920adOePXteeOEFAFu3bnXYgmPHjgmCMD09vabH2kf0uUbph6Zpw8PDP//5zymlzz77bDqdnp+f7/dB9QelUon9UC6XL7744jvuuINSurCwkE6nn376aUrpo48+OjQ0xFQAGx4BsQyl9Iorrvjrv/5rSmmxWNy+ffu//du/UUp/9KMfTU9Pr66uUkr/7u/+bsNX+wNiGUcZUavVLr/88g996EOU0tXV1Xw+/9hjj1FKn3rqqUwmw8RWGw/f/OY3JycnH3nkEe+Dx44dS6VSTH/3wAMPTExMVCoVSun73//+m2++mT3nhhtu+MhHPrL2B7wGOHTo0MzMzJe+9CXvg9Vq1RGRHTp0KJ1Os8vj3nvvPffcc9n5+djHPnbdddet/QH3C4MVCCmld9555/T09K233rp9+/YPf/jD/T6cvmHXrl3XX3/9zTffvGPHjquvvrpYLLLHP/KRj8zMzNx6662bN2/+y7/8y/4e5BpgYWFh//79F1xwASFk//79119/PXv8+9///vj4+IEDB17+8pffeOONTEVJKX3Tm960b9++W265ZWJi4v777+/fgfcWb3zjG/fv3y+K4nnnnbd//34mHr7wwgvf8IY3vOMd79i9e/dll122srLCnvzJT35yy5Ytt95668zMzEc/+tG+HnivYBiGoijT09P7bXzhC19g//Wnf/qnO3fufOf/3979qyoIQHEchwKHiBoaHPoDYVRD0h+wKUiioanJseU+RQ/TqzQUjSVCGhg0JjXU1B8IA+8gSC9wNa7fz+TRMxxcfiJH/PkRRXE2m/knj8djqVQaj8ej0aharV4ul+hm/0OqqqbT6eCe+MuxhmEUi0VN0zRNy2Qy0+nUb3ZddzAYKIoymUxyudznM9a/941/n7AsyzTNWq3W6XSiniUyjuPouv58PiVJUhTl85JhGLZty7LcaDSiGi80rutut9ugFARBlmX/2HGc1WolimK/3w+WSz3PWy6X5/O51+sVCoUIJg6FZVmv1ysoZVkWBOF0Om02m8fjUS6Xu93u52apaZr+B/WtViuKecOg6/pnmc/ngzd76/X6cDi02+16vR403G63+XyeTCaHw2EqlQp11rDs9/v7/R6U2Wy2Uql4nrfb7WzbTiQSzWZTkqSg4f1+LxaL6/WqqqooilGMHI1vDEIAAELzXcsyAACEjCAEAMQaQQgAiDWCEAAQawQhACDWCEIAQKwRhACAWCMIAQCxRhACAGKNIAQAxBpBCACItV8SZ+vVdYqQNwAAAABJRU5ErkJggg==", "image/svg+xml": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ], "text/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ] }, "metadata": {}, @@ -774,677 +625,268 @@ } ], "source": [ - "plot_acf(std_residuals, \"Standardized\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Plot QQPlot \n", - "\n", - "Used the StatsPlots.jl qqplot function." + "UnobservedComponentsGAS.plot_residuals(fitted_model; type = \"std\")" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 71, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "image/svg+xml": [ "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n" ], "text/html": [ "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n" ] }, "metadata": {}, @@ -1452,41 +894,42 @@ } ], "source": [ - "plot(qqplot(Normal, std_residuals))\n", - "plot!(title=\"standardized Residuals QQPlot\")" + "UnobservedComponentsGAS.plot_residuals(fitted_model; type = \"cs\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Jarque Bera Test for normality\n", + "## AutoCorrelation Function\n", + "\n", + "As it is almost mandatory in time series modeling, one should always check the autocorrelation function in order to study the presence of autocorrelation in the model residuals, since it should be free of it.\n", "\n", - "Uses the HypothesisTests.jl JarqueBeraTest function." + "With that in mind, the package has two built in functions: \n", + " - *get_acf_residuals(fitted_model; lags, type, squared)*\n", + " - *plot_acf_residuals(fitted_model; type , lags, squared)*.\n", + "\n", + "Both have the same parameters: the fitted model's output, the type of the residuals as a *string*, the quantity of *lags* as an integer, for which the default is 25, and *squared* which is a boolean flag to indicate if the acf should be calculated for the squared residuals.\n", + "\n", + "Note that both functions return/plot the acf value for the lag 0, which is always equal to 1." ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 72, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Jarque-Bera normality test\n", - "--------------------------\n", - "Population details:\n", - " parameter of interest: skewness and kurtosis\n", - " value under h_0: \"0 and 3\"\n", - " point estimate: \"0.19019821262707104 and 6.001932681683795\"\n", - "\n", - "Test summary:\n", - " outcome with 95% confidence: reject h_0\n", - " one-sided p-value: <1e-23\n", - "\n", - "Details:\n", - " number of observations: 283\n", - " JB statistic: 107.968\n" + "7-element Vector{Float64}:\n", + " 1.0\n", + " 0.2515891432445239\n", + " -0.10082210689450032\n", + " -0.1870116657570155\n", + " -0.18177872072870901\n", + " -0.09356057893281967\n", + " -0.09167263369657085" ] }, "metadata": {}, @@ -1494,111 +937,250 @@ } ], "source": [ - "JarqueBeraTest(std_residuals)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Quantile Residuals\n", - "\n", - "### Plot residuals" + "UnobservedComponentsGAS.get_acf_residuals(fitted_model; lags = 6, type = \"q\", squared = false)" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 73, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "image/svg+xml": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ], "text/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ] }, "metadata": {}, @@ -1606,258 +1188,250 @@ } ], "source": [ - "plot(title = \"Quantile Residuals\")\n", - "plot!(residuals_dates, quantile_residuals, label=\"\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Plot Autocorrelation Function " + "UnobservedComponentsGAS.plot_acf_residuals(fitted_model; type = \"q\", lags = 25, squared = false)" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 74, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "image/svg+xml": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ], "text/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ] }, "metadata": {}, @@ -1865,684 +1439,959 @@ } ], "source": [ - "plot_acf(quantile_residuals, \"Quantile\")" + "UnobservedComponentsGAS.plot_acf_residuals(fitted_model; type = \"q\", lags = 25, squared = true)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Plot QQPlot \n", + "## Investigatig normality: histogram and qqplot\n", + "\n", + "There is also built-in functions that plot both the residuals histogram and its qqplot for a standart normal distribution.\n", "\n", - "Used the StatsPlots.jl qqplot function." + "The first is: \n", + " - *plot_histogram(output; type, bins)*, which takes as parameters the fitted model's output, the residuals' type and the number of bins to plot\n", + "\n", + "The second is: \n", + " - *plot_qqplot(output; type = \"q\")*, which takes as parameters the fitted model's output and the residuals' type." ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 75, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "image/svg+xml": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n" - ], - "text/html": [ + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "UnobservedComponentsGAS.plot_histogram(fitted_model; type =\"q\", bins = 50)" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n" ] }, @@ -2551,41 +2400,49 @@ } ], "source": [ - "plot(qqplot(Normal, quantile_residuals))\n", - "plot!(title=\"Quantile Residuals QQPlot\")" + "UnobservedComponentsGAS.plot_qqplot(fitted_model; type = \"q\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Jarque Bera Test for normality\n", + "## Hypothesis Tests\n", + "\n", + "It is also commom practice to perform certain hypothesis tests in order to verify residuals normality, lack of autocorrelation and homocedasticity.\n", "\n", - "Uses the HypothesisTests.jl JarqueBeraTest function." + "With that in mind, the package offers some built in functions:\n", + "\n", + " - *jarquebera(output; type)*: \n", + " - Jarque-Bera Test for normality\n", + "\n", + " - *ljungbox(output; type, squared, lags)*: \n", + " - Ljung-Box test for lack of autocorrelation\n", + "\n", + " - *test_H(output; type)*:\n", + " - H test for uncondicional heterocedasticity\n", + " \n", + " - *archtest(output; type, lags)*: \n", + " - ARCH test for condicional heterocedasticity\n", + "\n", + "All functions have both the fitted model's output and the residuals' type as parameter. The *ljungboxtest()* also receives a boolean flag *squared* and an integer for the number of lags. The *archtest()* also receives the number of lags as integer.\n", + "\n", + "Each function returns a dictionary with, at least, the test statistic and it's pvalue. Some functions have extra return values." ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 77, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Jarque-Bera normality test\n", - "--------------------------\n", - "Population details:\n", - " parameter of interest: skewness and kurtosis\n", - " value under h_0: \"0 and 3\"\n", - " point estimate: \"0.18492031173132123 and 5.909783314924445\"\n", - "\n", - "Test summary:\n", - " outcome with 95% confidence: reject h_0\n", - " one-sided p-value: <1e-22\n", - "\n", - "Details:\n", - " number of observations: 283\n", - " JB statistic: 101.451\n" + "Dict{String, Float64} with 4 entries:\n", + " \"stat\" => 50.1708\n", + " \"pvalue\" => 1.27511e-11\n", + " \"kurt\" => 5.01301\n", + " \"skew\" => 0.225041" ] }, "metadata": {}, @@ -2593,183 +2450,83 @@ } ], "source": [ - "JarqueBeraTest(quantile_residuals)" + "UnobservedComponentsGAS.jarquebera(fitted_model; type = \"std\")" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 78, "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Dict{String, Float64} with 2 entries:\n", + " \"stat\" => 51.2796\n", + " \"pvalue\" => 1.79559e-6" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "## Conditional Score Residuals\n", - "\n", - "### Plot Residuals\n", - "\n", - "In this case, we have decided to plot the conditional score residuals for the 2 first parameters." + "UnobservedComponentsGAS.ljungbox(fitted_model; type = \"std\", squared = false, lags = 13)" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 79, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", - "image/svg+xml": [ - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n" - ], - "text/html": [ - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n" + "text/plain": [ + "Dict{String, Float64} with 2 entries:\n", + " \"stat\" => 59.9951\n", + " \"pvalue\" => 5.26399e-8" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "UnobservedComponentsGAS.ljungbox(fitted_model; type = \"std\", squared = true, lags = 13)" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Dict{String, Float64} with 2 entries:\n", + " \"stat\" => 0.958739\n", + " \"pvalue\" => 0.838712" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "UnobservedComponentsGAS.Htest(fitted_model; type = \"std\")" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Dict{String, Float64} with 2 entries:\n", + " \"stat\" => 44.804\n", + " \"pvalue\" => 2.25626e-5" ] }, "metadata": {}, @@ -2777,476 +2534,33 @@ } ], "source": [ - "p1 = plot(residuals_dates, cs_residuals_param_1, label=\"\")\n", - "p2 = plot(residuals_dates, cs_residuals_param_2, label=\"\")\n", - "plot(p1, p2, layout = (2,1), size=(800,600),\n", - " plot_title = \"Conditional Score Residuals\", title=[\"Param 1\" \"Param 2\"])" + "UnobservedComponentsGAS.archtest(fitted_model; type = \"std\", lags = 13)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Plot Autocorrelation Funcion \n", + "### All in one function\n", "\n", - "An astute user may observe a significant peak in the lag 12 of the autocorrelation function (ACF) of the second parameter, namely, the variance. Ideally, introducing time-varying dynamics to this parameter would be beneficial, but this functionality is still under development." + "The package has a built-in function that returns the pvalues for all the impemented hypothesis tests:\n", + " - *get_residuals_diagnosis_pvalues(output; lags, type\"q\")*" ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 82, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAyAAAAJYCAIAAAAVFBUnAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzdeVxU1fsH8HNnmIUZkE0UBAUXNLVwNwVRUXA3NStLzdRs+WqaZZmVS25Zpm2mqOWWqGX90BSXxFTccAE3FBdwQVBAZB1mmP3+/jh1nWZYBjgI5Of9hy/mzLnPnDN3ezz3zrkcz/MEAAAAANgR1XQDAAAAAP5rHGq6AQD/NdeuXUtPT/fz8wsICKAlRqPx0KFDhJA+ffo4OJS/06lUqri4OIlEEhoaWr1traAbN27cuXOnSZMmTz31VE235clVVFR08uRJBweHPn36lFvZaDQeOXKEENKrVy+JRFLdbYuJieF5PiQkxNHRsbo/C6CW43CJEOqo9PT03377LTY2NiMjo7Cw0NXVtW3btmFhYcOHD5fL5TXYsClTpqxateqDDz746quvaElubq6HhwchJC8vz9XVtdwIFy5c6NChQ7169QoKCqq3rRU0Y8aMr7/+esqUKT/88IM99a9du/bzzz+fOnUqOzvbwcHB29vbx8enZ8+eoaGhvr6+1d3a6hMXF/fHH39YlkilUm9v765du3bq1Km6P/3y5cvPPPOMQqFQq9XlVi4sLHRxcSGEPHz4kG6E1UokEvE8n5KS0rx5c7aR1Wr1woULCSFNmjSZPHly2ZXNZvOePXv27dt35cqVnJwciUTi4+PTrVu3l156qWXLlkI1jUYzb9680oJ4enrOnDmTVfvhScQD1DUGg2HmzJkymazETbp+/frr1q2rwebRo/8HH3wglOTk5NC25eXlCYULFy50c3ObPHmybYTz588TQurVq/c4mlsR77//PiFkypQp9lResGBBGcN1er2+ultbfcrIL7t06XLt2rVq/fTExERCiEKhsKeykKM/fPiwWltFcRxHCElJSWEeeePGjbQjDg4OGRkZZdQ8ceJE27ZtS1tBzz//vLB4dnZ2GSfHgIAA5r2AJwouEUIdYzAYnnvuuf379xNCBg4cOH78+A4dOri5uWVnZ8fHx2/dunX//v3Lli2bOHFiTbf0EaVSuWLFCkKIQqEQCrVabV5enkajsa3v6+u7YsWK0jLIOmHdunVz584lhAwePHjatGlPPfWUs7NzZmbmmTNntmzZ8tdff9V0AxlwcnJavnw5/Ts/P//06dM7duw4e/ZsWFjYlStX6tWrV02f26hRoxUrVjyG6321yoYNGwghEonEYDBERkZ+8MEHJVaLjo5+8cUXtVptgwYNpk2b1q9fPx8fH5PJdOvWrf379//4449RUVHjxo0bNmyY5VJTp061HNmi3Nzcqqkv8KSo6QwPoGLee+89QohYLF6/fn2JFY4cORIWFvaYW2XJdgSrRJ9++ikhZPz48Y+nVUzYP4JF7z8bPny42Wy2fffu3bsmk6kaGviY0BGs+vXrW5Vv2rSJHle//fbbGmmYrf/GCNatW7c4jnNwcPj8888JIa1atSqxWnJyMs1rg4ODc3NzbSsUFBRMnDhx586d9KUwgvXXX3+xbTAAjxEsqFtu3rz5/fffE0JmzZo1YcKEEuv06tWrS5cuVoUGgyE2NjYhIaGwsLBBgwY9e/bs0KGDVR21Wn3t2jUHB4d27dqZzebDhw+fOXNGq9W2bNly2LBhTk5OJX7cuXPn/vrrL5VK5e/v/9xzz9WvX9+2jtFoPHPmDCHk2WefFYvFRqPx4sWLGRkZhJCHDx8mJCQINTt27MhxnEajuXDhgoODQ9euXW1DHT16ND4+Pj8/39PTMyQkpHPnzlZ1iouLk5KSRCJRhw4deJ6PjY09ffq0Wq0OCAgYNmxYiSMrOTk5R48evXv3blZWlqura7t27fr06VPpMZLCwsLk5GRCyJgxY+gZ10rjxo1LXPDBgwcxMTG3b982GAw+Pj4dOnSwXZWEkEuXLh05ciQrK8vZ2bljx469e/eWSqVWdS5cuGAymZ566imlUnn16tWYmJisrKxu3boNHTpUqHPt2rVDhw5lZmbKZLLAwMDw8PAq3r03bty4OXPm3L179+TJk++++67Vu8XFxYcOHUpMTCwqKvLy8goPD2/VqpVtELqtJicn37t3z8nJydPTs0uXLs8884zwTRYXF58/f14sFj/77LNWy6pUqt27d1+/fl2pVHbt2rVXr14ltvP69etFRUX+/v5Wd2WZzWZ6eTowMNBy7fM8f+HChUuXLqWlpen1+kaNGvXt21f4DUe5zGbziRMnrl27lpaWJpPJPD0927dv36lTJ7FYbGcEetF/wIABU6dO/fzzz69fv3769Gnb7s+ZM6ewsNDLy2vnzp0ljj/Vq1dv3bp1JQ4bA7BXwwkeQEV8+OGHhBBnZ+fCwkL7lzp58qTtySA8PNzqTo64uDhCSP369dPT07t162ZZ2cvLKyEhwSpscXHxyy+/bFlNoVD8/PPP5d6D9eDBg9L2R6PRyJd+D9bZs2dbt25ttUivXr3S0tIsq124cIE2JjMzs2fPnpaVPT094+LirMKGh4fbnuqaNGkSGxtrVdPOEayHDx/SIFu2bCm7pkCn07377ru2eVLbtm0tq2VnZw8cONCqTrNmzWybSs+vx44de+2114SaL7/8Mn03MzNzyJAhVnEaN25s50hGaSNYPM/36NGDEDJw4ECr8sjIyAYNGlh+HMdxr776qkajsawWHx/frFkz2w1j6NChQp3S7sE6dOiQl5eX5VI9evSgmS759wgW3So2btxoFaG4uJhWvn//vlB48OBBHx8fq/ZwHDd69OiioiKrCLYjWCkpKe3atbPtUbt27Ur7eq2YTCaakW/fvp3n+bFjxxJC3nrrLatqWVlZ9J6/JUuW2BkZI1hQrTCCBXUJneygX79+zs7Odi5y8eLFsLAwjUbTvn37yZMn+/r6JiYmLlu2LCYmpnfv3vHx8VZDUwaDYejQobm5uZ9//nnz5s3pmFlmZuYLL7xw7do1ywxg/Pjxv/76q1Kp/OCDD7p161ZYWPjTTz9NnDjxmWeeKbtJzs7Oa9as+eOPP/bu3du9e/fx48cLb4lEpU5Nd/Xq1T59+qhUqrZt206dOrVJkyZJSUnLly+PjY3t2bPnuXPnrH6faDabhw8fnp6evnDhwlatWt26dWvFihX37t174YUXbty4YXk32NmzZ7t37z5gwAA/Pz9XV9eUlJR169Zdvnx58ODBFy5cqMTPwdzd3Rs1anT//v2lS5f27Nmz3B8MmkymYcOG7d+/XyqVTpo0KSwsTKlU3rp1KzY29ujRo0K14uLiPn36JCYmenh4zJgxo127dhkZGREREQkJCf3794+NjbUd8Js1a9aZM2fGjx8fFBSk1Wrp15uTkxMUFHTr1q2AgIDx48e3bt06Jydn7969O3bsGDRo0LFjx0ocNrOH2WxOSUkhNkN0K1eufOedd0Qi0dixY3v27Onp6Xn58uWIiIjNmzfn5eXt2rWL5iVqtXro0KEZGRnBwcETJkzw9fUtLi5OTU2NiYnRarVlf/Tly5eHDBmi0WiCgoImT57s6el57ty5pUuXjh49unJ9Edy9e7eoqGjSpEmBgYH+/v6FhYVnz55du3bt1q1beZ7funVrGcvyPD9ixIjExMTAwMC3337b39/faDTevXv36NGjSUlJdjbgwIEDaWlpLi4uNCceN25cZGTkL7/88vXXX1tuxkePHjUajYSQkSNHVqG7AOzUdIYHUAE0v1m0aJH9i9DrCMHBwcXFxULhrVu36MWRjz76SCikI1iEkMDAQMuf+926dYt+rnDrBs/zMTExhBCxWHzs2DGh0Gw2jxo1igYp91eEZdyDVeIIFp0Tq3Pnzmq1WihMS0ujgxbTpk0TCukIFiHkqaeeshy3uHfvHj0h0VOjIDk52aoBRqNxwIABxGacwP57sL755hvaBrlcPmTIkGXLlsXGxlquAkvffvstrWn5ZVIPHjwQ/p4/fz4hxNXV9caNG0KhXq+n34zViAgdwRKLxQcPHrSKOWbMGEJI7969Lb9JnufpRb0uXbqU27vSRrAWL15Me71//36h8MaNG1KpVCQSRUVFWVZOT0+njdyxYwct2bNnDyGkRYsWtj+xtBzoKnEEq2/fvoSQsLAwg8FgWVNIQSo9gnX//n3bkaqEhAS5XM5xXFJSkmW51QgWbaqLi4vtkLPV0F0ZXnrpJctNURjQ2rx5s2W1OXPmEEKcnZ1LvO2vRMII1oQJExbaqNAwOYAtJFhQZwi3665evdrORS5dukQXOXfunNVby5YtI4R4eHgId1sLCdaff/5pVXnEiBGEkE8++UQoeeWVVwghY8eOtap5//59ep2CbYIlXOg5ceKEVeVVq1bR84pOp6MlQoIlnLkFdDxj+vTpth9q5fjx44QQf39/y0L7Eyyz2bxgwQKrW5qUSuXzzz+/a9cuq8r+/v6EkLlz55Ydk46Eff7551blwliI5dVPmru89tprVpXT09Pp9dCrV69avaVSqeiUUVZJgy2aYCmVyi+++OKLL75YsmTJ1KlThZvh3njjDcvK06ZNI4SMGDHCNs4XX3xh+db27dsJIT169Cj7020TLHoPOCEkMTHRqvKMGTOqmGCV5sUXXyQ2t/NbJVinTp2iW5H9SY+VnJwc+nNayy1/1qxZhJA+ffpY1qSX5q222LKVPU2D1ZV3gIrCJUKoM0wmE/2jjOtoVmiWQG+Xtnpr6NChH3zwQU5OztWrV61mzbG6AYsQQi+TZWVlWUXu16+fVU1vb+/27dvHx8fb2UI7nThxghDi4eERFBRk9dbQoUMnT56sUqkuXbpkdcO7PR0RXLp06dKlSwUFBUVFRYQQ+m9qaqrJZLL/ZmQBx3Fz5sx58803d+3atWfPnuPHj+fk5KjV6qioqKioqLFjx27atImux5s3b965c4cQQu+tKc2dO3fS09MJIbb3TrVu3bpFixYpKSnHjx+36nLv3r2tKh8+fNhkMpU4Gb2Tk9Mzzzxz/PjxhIQE23vdbKnVanqmF8hksnXr1lldlTt48CApaVMhhHTv3p0QIvzKITAwkOO448ePf/DBB1OmTGnatGm5baBOnjzJ87yvr+/TTz9t9daAAQOEuSSqQqVSnT59+vbt24WFhfRKHM1Obt26VcZSrVq1ksvld+7cmTBhwsyZM9u0aVPRz92yZYtOp2vRogX9rqgJEyZ88cUXhw8fvnnzpnAJmx4fKrGt0oC2t77RbBug0pBgQZ3h4uIiFotNJlN+fr6di9BTMh0gseLv7y8Sicxmc3p6umWC5ebmZvs7O3rLl16vpy95nr937x4hxM/PzzZykyZNmCdYaWlppX1co0aNZDKZTqdLT0+3TLBkMpnVLc/EpiPUoUOHpkyZcu3aNdvgPM8XFRVV+kzTsGHDN95444033iCEJCcn79mzZ9myZffu3YuMjGzfvj0dXElNTSWESCSSFi1alBGKfgOklC/B398/JSWFrm5LTZo0sSqhCcGDBw+s7i0zmUyFhYU0rSx7YEOgVCrpZSlCSEZGxq+//pqZmTlnzpyQkBDLz6WfuGDBAmFmf0qtVtMRI+HjWrVqRR8AsHz58uXLl7do0aJ3795Dhgzp379/2T9vpF+ObWdJKV9Xhej1+o8//jgiIkIY37JEv7HSuLq6fvnll++9996mTZs2bdrk6+tLezRw4EA75wmj01+NGzfO8ueoLVu27Nq165kzZzZv3vzZZ5/RQnd3d0JIXl6e3T17ZOzYsfY8dwigQpBgQZ0hEomaN29+48aNy5cv27kIzSRKPJRLpVK5XK7RaKxuH7bnf8BGo9FsNhNCSpy7oTpmmDQYDKVFFolETk5OOp2uEh0hhJw9e3bgwIF6vb5v377PP/+8r6+vm5ubQqHIz88PCwsjhPCMnqYVEBAwffp0OjHsnTt3Vq9eTRMs2myZTFbihA4CuirFYrFSqbR9l6aAtneC2/4Ygj5epl69eiX+WI+y/dFciRwdHT/66CPh5WeffdanT5/z58+PGjXq+PHj9Ps3mUy0VY0bNy5tw7BcU0uXLg0LC1u/fv3+/ftTUlJSUlJ++umnpk2bbtiwobQ5F8g/X06Jv/yo+tb41ltvbdy40d3dfcKECSEhIe7u7q6urmKxOCIigs6eUPbi06ZN69q169q1a6Ojo9PT0yMjI+kPKiMiIp5//vmyl71w4QK9XE6nt7B8i94wsHHjxrlz59KhUPpL4dzc3IyMDG9v76p0GYAJJFhQl/Ts2fPGjRsHDx40Go32PDWZnneFwQ9LDx8+pNPhVGK+ZolEolAoNBrNvXv3OnbsaPUuHdxiq4yOaDSa3NxcUtmJp7/66iu9Xv/GG2+sXbvWsvzixYuVamk5XF1dx48f/9lnn6WkpOh0OplMRgce1Gq1Wq0uMXkSFiSEmEymjIwM258l0m/Gnm+AflzLli3pzxQYcnV13bJlS7t27U6dOrVx48bXX3+dECIWi+vVq1dYWDhv3rxBgwbZE6dfv379+vUzmUznz5//888/16xZc/v27ZEjR169etXT07O0jyalbHi2o3qEEJrLCtfcBbbPvkxPT9+0aRPHcUePHrW6km67eGm6devWrVs3nuevXLly4MCBtWvXXr9+ffTo0RcuXCj7qeHr16+nf9DnVdtKTU09fPgwvcFfmJFk3759tepBDvDEsvdeFoDagB4379+/v3nzZnvq0xkTbt26ZXt1g/6HmOM429tW7EGXunr1qlU5b3HPddlogmjnWYp2JC0trbCw0Ootel+zUKei6O8AbM/99g8TVhRNcUQiER14eOaZZyQSCc/zljMy2GrdujX9xmwbptfrr1+/Tuz7BmhCHB8fr1KpKtuDshpJr4fOnz9fp9NZfmJpKUJpxGJx586dP/300wsXLri7u9OZYEurTLfG27dv247hlbg10pFX21vx6Ndo6dKlSzzP+/n52T7d78qVK/Z15W90X3v//fcvXLgQEBCg0+noA69Ko9Pp6BwQ06dP314SelFPSMKaN29OB/m++eYbq4vgADUCCRbUJd27d6f3OL/33nul3eeUmZn59ttv079DQ0OdnJw0Gg29k8MSfThgjx496Pm+ouiE4Bs2bKAX7wTR0dF2jmA1atSI2H27T3BwsLu7u16v//HHH63eoh3p3LkzDVhRdDDDKm8zmUw0bOUYjUarCzqWdu/eTQhp1aoVnStcqVQOHjyYELJkyRJ64bVECoWCDlSsXLnS6q2ff/65oKBALpeXeCO5lZ49e/r4+Gi12qVLl9rXm4r59NNP5XJ5WlraunXraAn9welPP/1UuaFNd3d3OisBHacsUVBQkLu7u1qtjoyMtCzneX7NmjW29entbseOHbMqF5IVAU2Ci4qKrFbN8ePHz549W4FuWJDL5XQKe+HXtSX6448/cnJypFLp7NmzXyzJO++8QwiJiooS7rtasGCBWCy+fPnyO++8U9q2tGbNmrITOwBmaujXiwCVlJ2dTe+eUSgU8+bNu3XrlvDWtWvX5s2b5+Li0rp1a6Fw9uzZtPIff/xBSwwGAy3kOC4mJkaoKczkbvuhdAamV199VSh58OABnUlr7NixwnRKZ86cadCggZ3TNNBJU+Vy+b59+7KysnJzc4Wnp5U4DxadY0kul//222+0xGg0ChMv7d69W6gpzORu2xGaVYwcOVIoodOctmrVKjU1lZYUFBS8+uqrwpNSLNts5zQNGo1GJBINGTLkt99+s3wkXFJSEs02yL9/3n/58mU6XdOLL76YmZkplCcnJ8+bN094eezYMXq+nzVrljBT1J49e+h4zIwZMyzbQC8XnjlzxrZ5W7ZsIYSIRCL6ZBXLZm/evLl///5l944vcyZ3/p/5Ary9velUTzqdjg5iPfXUU1azbFy9enXGjBkRERH05dq1a99//33L+SPMZvO2bdvEYjHHccIUDCXOg7Vo0SJCiLOzszDvl06nmzp1qnAl3XKaBnp5lOM4ehMVz/PFxcVz584Vni8uTNPw4MEDuiXMnj2bPmaA5/kTJ054e3vT8gkTJlg2w2qahp07d7711lvx8fGWdQ4ePEhX9759+8r4kulMbMOHDy+tgk6no/87Er5A3mIqspCQkAMHDmi1WlpeVFQUFRUVHBxMLCa0w0zuUK2QYEHdk5WVZfnzezc3t2bNmgn3m4vFYsvkRqfTCY+fa9asWUhICL2RheM4q0dqVCjB4nk+OjqaTkDq6uraq1ev9u3bcxz3zDPP0GezlJtgGY1G22kUynhUjsFgeOGFF2g1f3//kJCQhg0b0pdWM0hVKMG6ceMGvcFLLpd37do1JCREqVSKxWI6vValEyyhRxzHNWrUqEWLFpa3YE+YMEE4W1O7du2iN2A5ODi0b9++R48ePj4+HMe5uLhYVvvmm2/oKdzDwyMkJET4JWC/fv2sZjEtI8HieX758uX01nKZTNaxY8fQ0NCnn36aZgyOjo5l944vL8G6e/cuzVR++OEHWpKeni5MFOLr6xsSEtKtWzfhRuyFCxfSakuWLKElHh4eXbp06dWrl/DDwFmzZgnxS0yw9Hp9//79aeW2bduGhobWr1+f4zg63xuxedizsFPQJwM6OTnRB6hbJVg8z3/88ce00MfHJzQ0lE610KZNGzova9kJljCi5uLi0qFDh9DQUOG3orZzyFkSpisT/jtRokmTJhFCunbtalm4atUq4WY+mUzm6+vr7e0t/JKgZcuW165dozWRYEG1QoIFdVV0dPQrr7xCT8OEELFYHBgYOGPGDNsJJI1G45o1a7p06UL/N69QKAYMGGB7SE1KSgoLC7NMPgSbN28OCwv74osvrMrPnDkTHh5OT8yenp7vvPNOfn7+d999FxYWtmbNGqFaYWFh3759+/btazUjtlqtjoiImDx58tChQ8PCwsLCwuispykpKX379h02bJjVx5lMpvXr1z/77LO0I46OjuHh4ZaThlM3b94MCwsbPHiwbUe2b98eFhY2f/58y0L6lBU6EQC90BYbG1tYWEibpFKphJqrV6/u27fvihUrbCNbuX379qpVq4YOHdq8eXNhigFfX98XX3zxwIEDJS5y8+bNN998U/gFX/369fv162c7GWZsbOzgwYPpGVQsFnfs2HHlypWW05dTw4cPDwsLE06lti5evPjaa68JH+fm5tauXbuZM2faPqvR1h9//FHapkItXrw4LCzMcppTrVa7cuXK4OBgmntJJJLGjRsPHTr0p59+ElKf69evz507NyQkhD61kOM4b2/v/v37C4Ov1O3bt/v27TtkyBCrD9XpdAsXLqQ5GX1S+M6dO9VqNV2PBQUFlpWLi4tnzpxJc3SJRNKzZ8/Dhw/rdDpaOScnR6hpNpt/+OEH4WmejRs3fu+99woKCjZu3BgWFvbVV19Zhg0PD+/bt6+Qn6WlpdGvwsvLi44+NmjQoFevXj///LMwwW+JduzYERYWNmDAgLInfI+Li6MNthz45Hk+IyNj9uzZnTt3dnR0FPLI5557btu2bZaz5BcUFNAd8/z582V8CkDlcDyj32AD1BSz2SzMwV02nudVKhXzaRTMZrNWq7V8LNpjUFhYyLYj1fTlUAUFBc7OznbOEEtPgcLlqtKoVConJ6eyJ3ewh8FgMBqNwpn4MbCn5QaDwWw2l/sllEij0cjlcju/bbVa7ejoaE9lrVbLcVzlmkQIMZlMer3+cX7PlFqtlkgkts8RB6huSLAAAAAAGMOvCAEAAAAYQ4IFAAAAwBgSLAAAAADGkGABAAAAMIYECwAAAIAxJFgAAAAAjCHBAgAAAGAMCRYAAAAAY0iwAAAAABhDggUAAADAGBIsAHgc1qxZw1lQKpX+/v5jxoyJj4+v6aZV1Z9//jl79uyBAwd6enpyHNeuXbuabhEA1DyHmm4AADxBvLy8nn76aUKIXq+/evXq1q1bt2/fHhkZOWrUqJpuWuVNnz792rVrhBC5XF7TbQGA2gIjWADw+ISFhcXExMTExMTGxt69e/f11183Go1TpkwpLi6u6aZV3qRJk7Zu3Xrjxo3Y2NiabgsA1BYYwQKAmiGXy1esWLFt27acnJxTp06FhoYSQnJycuLi4tLS0oqLi/38/Pr06ePm5ma5VGFhYXJycv369f38/NLT0w8ePJidnT18+PCAgABCSHFxcVxcXGpqanZ2tre3d8+ePf38/CwXN5vN58+fl8vlbdu2zc/P37t3b1ZWVrNmzQYPHuzg4EArHDlyJDEx0dHRcdCgQb6+vuV2ZMaMGfSPs2fPsvpyAKCuQ4IFADXG0dHRz8/v6tWrDx48IIS89tprW7ZsMZlMQgUnJ6dvv/329ddfF0pOnz7dr1+/N99808/Pb+7cubRyw4YNAwICVq5cOXPmTI1GI1QWi8WTJ0/+5ptvxGIxLdHpdJ07d27duvXy5ctfeeWVgoICWh4YGHjw4EGDwTB8+HAhT3J0dPzll1+ee+65av4aAOA/CAkWANQYg8GQnp5OCPHw8CCE5Ofnf/jhh717927SpIlOp4uNjV24cOGbb7751FNPBQcHWy64f//+vLy8+fPnd+/e3Wg0ent7E0KysrJeeumlYcOGNW3aVCKRXLp0acGCBStWrPD19Z05c6bl4g8ePHjllVfefPPNYcOGGQyGRYsW/fXXX++//35KSopSqdy9e7eXl9fu3bsXLVo0ceLE1NRUpVL5GL8VAPhP4AEAqt/q1asJIWPHjhVKTCYTzXucnZ0LCwtLXOrAgQOEkFGjRlmVEEKioqLK/dCMjAwXFxcfHx+hRBjf+vzzz4XC3NxchUJBCOnUqZPRaBTKR4wYQQjZvXu3nX08c+YMISQwMNDO+gDwH4YRLAB4fE6fPv3WW28RQgoLCxMSEpKTkwkhS5cudXZ2LrF+3759lUolTVwstWrVavjw4eV+nJeX17PPPnvgwIH09HTLu6nEYvH06dOFl25uboGBgadOnZo2bZpwMZEQ0qtXrx07dty+fbsiXQQAIASXCAHgcUpOTqZJFSFEqVSGhYXNmDFjwIABtESlUhRFKwwAACAASURBVH399dfR0dHp6emZmZnCUjk5OVZx2rRpw3GcVaHZbN6wYcOWLVuSk5OzsrIMBoNlBMsEy9fX19HR0XJZT09PQkjLli1tC7OysirVVwB4oiHBAoDH56WXXqLXCiUSiZOTk+VbxcXFPXr0uHTpUps2bV566aX69etLpVJCyOLFi41Go1Wc+vXr2wZ/44031q9f7+XlNXjwYB8fH3rVb8uWLYmJiVYR6FuWRCIRIcQq66I5HM/zleorADzRkGABwOMjlUqtpl0QbN68+dKlS6NHj46MjBRGp4xG45w5cyQSiVVl2+GrK1eurF+/vk2bNqdOnbK84Lh37152zQcAsBcmGgWAWuHixYuEkFGjRlkmT4mJiZZX+spdfPDgwZbZlU6nu3LlCuuWAgCUDwkWANQK9Krf3bt3hRKe5+fNm2fn4vR+qdTUVMvC7777zvb+LQCAxwCXCAGgVujdu/eCBQvmzp2rUCiCgoKys7O/++47er3PcurR0nTu3NnZ2fm3335r3br1iBEjeJ7/9ddfv/76a39//zt37lRry3///feYmBhCSHZ2NiEkPT2d/lKSEPLZZ5/ROboA4EmDBAsAaoXQ0NB58+YtXLhQmLe9cePG0dHRw4cPF+ZbL4Obm1tkZOTYsWPnz58/f/58QohCoVi7du3evXurO8E6ffr02rVrhZe5ubnCy+nTpyPBAngycfiBDAA8BoWFhQ8fPnRycmrQoEEZ1e7cuRMfH5+Xl+fv79+rVy+pVJqammo2m5s2bUorFBcXZ2Rk1KtXr8QfEubm5sbFxaWnpzdo0CA0NNTV1TUrK0utVvv4+MhkMkIIz/O3b9+WSCSNGze2XDAzM1Oj0fj6+tKfLlJFRUUPHjxwdXV1d3cvo805OTmlpYCNGze2vUMfAJ4ESLAAAAAAGMNN7gAAAACMIcECAAAAYAwJFgAAAABjSLAAAAAAGEOCBQAAAMAYEiwAAAAAxpBgAQAAADCGBAsAAACAMSRYAAAAAIwhwQIAAABgDAkWAAAAAGNIsAAAAAAYq3UJ1v/+9z+9Xl/pxQ0GA8PGPOExeZ43Go1sY5rNZpPJxDamyWQym81sYxqNRubPQa8TKx0xa39M7JhsY9aJlY6YdSKmlVqXYG3fvr2oqKjSi2u1WoaNqVsxdTod24Bms7kqyW6JTCYT883aaDQyPzfo9Xrm5wadTsf83FBXNs4nOSbzHZPn+bqyYzJPBA0GA/MdU6/XY8dEzOrgYE8lnudTUlKuXLkSEBDQtm3bEus8fPhwx44dRqNx2LBhjRo1EsqPHTt29uzZli1bDh48mOM4Nq0GAAAAqMXsGsEaOnRoUFDQpEmTfvvttxIrZGRkBAYGHjt27MKFC4GBgSkpKbR82bJlY8eOzc7O/vTTTydNmsSs1QAAAAC1mF0jWJs3b3Zzcxs9enRpFVatWtWjR4+ff/6ZEOLg4LB8+fKIiAiNRrN48eIDBw506dJlxowZfn5+H3/8cYsWLZi1HQAAAKBWsmsEy83NrewK+/fvf+655+jfzz333P79+wkhp0+fdnR07NKlCyGkfv363bp1O3DgQNVaCwAAAFAH2DWCVa579+55e3vTv729ve/fv8/z/P379y1vxmrUqNH9+/fLDaXT6b7++mtHR0f6MiAgYNiwYfa3JDLFPLEN41tKdTqdVCqtEzElEgnDgCaTSafTicVihjENBoPJZGJ7N55OpxOJRGxvfaU3JrPtu06nc3BwYN73urJxPskx2e6YZrO5ruyYHMexvX+c/lKE+Y4pFouxYyJmhUgkEpGonCEqNgmW1V5Et1SrQp7n7dmCeZ7Pz88XfndT0R+2TE5QTGzD+DcmAAAAj1NUVFReXp5liVarlcvlbD/lSYvp5ub2/PPPVz2OndgkWN7e3llZWfTvzMxMb29vjuO8vLwyMzOFOllZWd27dy83lFwuX7Bggbu7e2XbYpDJZJVdtmR6vb5OxDQYGPedzn3ANqZIJDKZTMz7LhKJmI/eyWQy5oMEMpmM7X+U68rG+STHZL5jms1mnufrxI7JcRzbgQez2SyVStnumEajsRbumK+++urEiRPx03u21q9fP2LECJqrVcfObqXyCZZWq01PT6c3rffr1y86OnrMmDGEkD179oSHhxNCnn32WbVaff78+Q4dOuTl5Z08eXLlypWs2g0AAPBfxfP86tWry70IBRWyefNm5nOelcGuBGvjxo179+49ffr0xYsXk5KSJk2a1K9fv3PnzgUHB9O2TpkypVOnTq+//rpCodi6devJkycJIUqlcubMmSNHjhw7duzevXtHjhzZsmXL6u0NAAAAQC1gV4LVvn17pVL54osv0pfNmzcnhLRq1er333+nJT4+PhcvXvz9999NJtOFCxcaN25Myz/55JNu3brFx8d/8sknw4cPr4b2AwAAANQ69iZY7du3tyr08PAYOXKk8LJhw4ZTpkyxXbZPnz59+vSpShMBAAAA6hZc3wUAAABgDAkWAAAAAGNIsAAAAAAYYzMPFgAAAIClS5cu1a9fX3imi0qlOnbs2IMHD/z9/bt37247DZXRaDxy5Mj9+/d79OjRrFkzWpicnJyamirU6dOnD5294vLly4mJiX379m3QoAF96/Tp066urq1atar2jtkHI1gAAADA3rvvvhsVFUX/3r17t7+//9KlS48fP75gwYJWrVrdvHnTsnJxcXFwcPCiRYtOnz7dvXv3nTt30vI1a9a8+eabX/6DPt/l+PHjkyZNys/PDw0NLSoqIoQUFBS8/fbbXl5ej7eLZcEIFgAAAFSjlJSUUaNGrVu37pVXXqElCQkJVtOo/vjjj4SQw4cPcxw3dOjQadOmDRs2jM5lP3r06EWLFllW/vXXX6dPn/7yyy/HxcUdPXp00KBB8+bNmzFjhouLy+PqU/kwggUAAADVaN26dV27dhWyK0JIp06dmjZtalnn+vXrnTt3phlV165dk5OTk5KS6FsZGRn79u0TXhJCxGIxHcoyGAxisfjixYuJiYn0cTK1B0awAAAA6ojDh0lycqnv+vmR/v0fvdTpSGQkMZlKrT9gAGnS5NHLxEQSF1dqZaWSWGUw27eT/HxCCAkJIa1bl9HqxMTEjh07llGBEOLn57dnzx6hPiHk3r17bdu2FYlESUlJERERp06d6tq1a1RUlFQqHTdu3KRJk27cuHHjxo2ePXsOGjRoxYoVJpMpNzdXuCWrxiHBAgAAqCNu3SIJCaW+azD8K8HS68mFC0SvL7V+t27/SrAyM8sK7upKRo8mls+fvnKFZGYSQkirVmUnWEajUSKRlFGBEPLGG2+sXr36hRdeaNu27e7du11cXOiz+JYsWUIf761Sqbp27RoREfHuu+927NgxOjr6xo0bs2bN2r59e8eOHWUyWZcuXeit8b///ntteE42EiwAAIA64vXXyeuv21vZ2ZmsWFGB4OHhJDy8AvXnz7ezYkBAwNWrV8uu4+bmdvHixejoaLVaHRUV1bJlS5ot0eyKEOLs7DxkyJDz58/Tl40aNWrUqFF+fv53330XGxs7e/bs9957b9y4ceHh4QkJCZ07d65AR6oHEiwAAACoRuPGjQsKCjpz5kzXrl1pSVZWFiGkYcOGltWcnZ3pfVo//vhj8+bNW7RoYRXn/PnzQUFBliWzZ8+eOXOms7Nzfn6+p6cnIaRBgwZ5eXnV1xf7IcECAACAatSlS5elS5f26dPn1VdfbdWqVUpKSlRUVExMjGWCVVBQMHny5A4dOty8efOXX36Jjo6ml/nCw8OfffZZFxeXQ4cOXbt2bcuWLcIi58+fv3Hjxg8//EAICQsLW7t2rVQqPXv2LC2pcfgVIQAAALA3Y8aM0NBQ+vd7772XkJDQrFmzrKysNm3axMfHt23b1rKyUqns169fbm6uv7//hQsXgoODafkHH3wgk8ny8/Off/75q1evWuZk169fF3KpV1999ZVXXomNjd2xY4ebm9tj6V85OHoTWe3h4eGRnJzs7u5eucW5nwz8pHLupKsolUrl7Oxc+2MWFRU5OTkxDGgymXQ6nUKhYBjTYDCYTCa5XM4wpk6nE4lE5d5BWSEajUYmkwnX/pkoKipSKpVsb72sKxvnkxyT+Y5pNpu1Wm2d2DE5jpNKpQxjFhcXS6VStjumWq1WKBS1bcek0xBYzRQFVaRQKHJychwdHUn17OxWsPIAAAAAGEOCBQAAAMAYEiwAAAAAxpBgAQAAADCGBAsAAACAMSRYAAAAAIxholEAAIBaZ+nSpbXhgXr/JUaj8XF+HBIsAACA2mXx4sX5+fmWJXq9nu2kYk9gzDlz5rCd7K1sSLAAAABql1mzZlmV1JWZdetKzMcA92ABAAAAMIYECwAAAIAxJFgAAAAAjCHBAgAAAGAMCRYAAAAAY0iwAAAAABhDggUAAADAGBIsAAAAAMaQYAEAAAAwhgQLAAAAgDEkWAAAAACMIcECAAAAYKwCCVZqampaWlr1NQUAAADgv8GuBEutVoeHh/fs2TMoKGjIkCFardaqwhdffOH+DycnJ0dHR51ORwh55ZVXlEolLW/WrBn75gMAAADUPnYlWKtWrdLr9Tdv3rx58+bDhw/Xr19vVWHWrFm5/5g0adKIESNkMhl966uvvqLlt27dYtx2AAAAgFrJrgRr27ZtkyZNcnBwkEqlEydO3LZtW2k19Xr91q1bJ06cKJSYzeaCggIGLQUAAACoI+xKsFJTU1u0aEH/btGiRWpqamk1d+7cqVAo+vTpI5TMmjWradOmnp6eq1evtuezTCbTxYsXE/6Bu74AAACgznGwp1JRUZFcLqd/KxSKwsLC0mquX79+woQJItHfedvixYsjIyPFYvGRI0cGDx7ctm3bkJCQsj+ruLj43XffdXD4u2HBwcFLliyxp5H/kBUVFVWkfvnUajXHcXUiJtuAJpNJp9OZzWaGMQ0Gg8lkMhqNDGPqdDqRSCSRSBjG1Gg0BoNBLBYzjKlWq3meZ7ve69DG+STHZBvQbDZrtdo6sWNyHCeVShnGLC4ulkqlbHdMjUZjNpuxYyJmhcjlciFRKY1dCVbDhg3z8vLo37m5uV5eXiVWS09PP3To0Jo1a4QS4cb23r17Dxo06ODBg+UmWE5OTkeOHHF3d7enYSUxODk5VXbZkvE8XydiEkLYxjSZTBKJRKFQMIxJj+NCvs6ERCJhnmCJRCKZTMb2OE4IUSqVbA8TdWXjfJJjEtY7ptlsdnBwqBM7JvMESywWM0+wOI5TKBTYMRGTObsuEXbo0OHUqVP077i4uA4dOpRYbf369aGhoX5+fiW+m52dXa9evcq1EgAAAKAOsWsEa+rUqS+//HK7du2MRuPKlSt3795Ny9u2bbtx48YuXboQQnie//nnnxcvXiwsZTQaZ86cGRYWplQqd+zYcfHixc2bN1dHHwAAAABqFbsSrLCwsIiIiB9++EEkEm3YsCE4OJiW9+jRw8XFhf5979698PDw4cOHC0vRqzYrVqzQ6/WtW7c+e/Zs48aNmXcAAAAAoLaxK8EihLz44osvvviiVaHl7Va+vr4RERGW74pEoi+//LKK7QMAAACoc/AsQgAAAADGkGABAAAAMIYECwAAAIAxJFgAAAAAjCHBAgAAAGAMCRYAAAAAY0iwAAAAABhDggUAAADAGBIsAAAAAMaQYAEAAAAwhgQLAAAAgDEkWAAAAACMIcECAAAAYAwJFgAAAABjSLAAAAAAGEOCBQAAAMAYEiwAAAAAxpBgAQAAADCGBAsAAACAMSRYAAAAAIwhwQIAAABgDAkWAAAAAGNIsAAAAAAYQ4IFAAAAwBgSLAAAAADGkGABAAAAMIYECwAAAIAxJFgAAAAAjCHBAgAAAGAMCRYAAAAAY0iwAAAAABhDggUAAADAGBIsAAAAAMaQYAEAAAAwhgQLAAAAgDEkWAAAAACM2ZVgqdXq//3vfwEBAcHBwUeOHLGt8H//93/hFu7du0fLMzMzR40a1bx58/79+yclJTFsNwAAAECt5WBPpY8//vj27dt//fXXiRMnhg8fnpKSUr9+fcsKqampIpHoww8/pC/d3NzoH6+99pqfn9/Ro0cjIyOHDBmSnJwsFovZdgAAAACgtik/wdJqtZs2bTp8+HCTJk2aNGmyYcOGyMjI6dOnW1Vr1KhRWFiYZcmtW7eOHDmSlZXl6ur60UcfRURE/Pnnn4MGDWLZfAAAAIDap/xLhHfv3lWr1e3bt6cvO3XqdOXKFdtqhw4d6t69+8iRIw8cOEBLkpKSmjVr5urqSl927Njx8uXLjJoNAAAAUHuVP4L18OFDJycnkejvVMzV1dX2bqquXbt+//333t7eZ8+eHTFixO+//z5w4MCHDx/Wq1dPqOPq6pqdnV3uxxUWFjZr1ozjOPpyyJAhERER9vaGEEJkRUVFFalfPrVaLbSnlsdkG9BkMul0OrPZzDCmwWAwmUxGo5FhTJ1OJxKJJBIJw5gajcZgMLC9oq1Wq3meZ7ve69DG+STHZBvQbDZrtdo6sWNyHCeVShnGLC4ulkqlbHdMjUZjNpuxYyJmhcjlcgeHcjKo8hMsV1dXyxNDYWGhh4eHVZ0ePXrQP7p27ZqWlrZhw4aBAwfSBYU6hYWFAQEB5X6cs7NzfHy8cBeXo6OjXC4vdykLBicnp4rULx/P83UiJiGEbUyTySSRSBQKBcOY9DhewXVaDolEwjzBEolEMpmM+S2DSqWS7WGirmycT3JMwnrHNJvNDg4OdWLHZJ5gicVi5gkWx3EKhQI7JmIyV/4lwsaNG4tEopSUFPry2rVrTZs2LaO+u7s7zauaNWt2584drVYrLNisWbNyP47jOFdXV7d/sN3hAQAAAB6D8hMsZ2fnESNGLFu2zGw2JyYmHjhwYOzYsYSQO3fuCLe6Hz58uLi4mBCSlJQUERHRv39/QkhgYGBAQMAPP/xACNmzZ8/9+/eHDh1ajV0BAAAAqB3smgdr+fLlSUlJ9evXDw0N/eabb+gI1sOHD7dv304r/PTTT66urvXq1evVq9fo0aOnTJlCyzdt2rRhw4b69eu/9dZb27ZtYzumDQAAAFA72TUPlo+Pz7FjxzQajaOjo3ChunPnzvfv36d/b9myZcuWLUVFRVZXNAMDA69cuaJWq5VKJdt2AwAAANRadiVYVLnjT6XdL4bsCgAAAJ4oeBYhAAAAAGNIsAAAAAAYQ4IFAAAAwBgSLAAAAADGkGABAAAAMIYECwAAAIAxJFgAAAAAjCHBAgAAAGAMCRYAAAAAY0iwAAAAABhDggUAAADAGBIsAAAAAMaQYAEAAAAwhgQLAAAAgDEkWAAAAACMIcECAAAAYAwJFgAAAABjSLAAAAAAGEOCBQAAAMAYEiwAAAAAxpBgAQAAADCGBAsAAACAMSRYAAAAAIwhwQIAAABgDAkWAAAAAGNIsAAAAAAYQ4IFAAAAwBgSLAAAAADGkGABAAAAMIYECwAAAIAxJFgAAAAAjCHBAgAAAGAMCRYAAAAAY0iwAAAAABhDggUAAADAmIOd9S5evBgZGSkSicaNG9e2bVurd/Py8qKjo8+fP+/o6DhkyJDu3bvT8l27dl29epX+LZfL3333XVbtBgAAAKi17BrBunjxYkhIiLu7u7Ozc1BQ0LVr16wqLFmyJCoqysfHRyqVDhgwYMuWLbR827Zthw4dysvLy8vLy8/PZ9x2AAAAgFrJrhGsr7/++q233vr4448JIZmZmd9///2qVassKyxatEgqldK/lUrl2rVrx4wZQ18OGzZs8uTJTNsMAAAAUKvZNYJ17Nixvn370r/DwsKOHTtmVUHIrgghRUVFLi4uwsujR48uXLhw+/btBoOhyq0FAAAAqAPsGsHKzMz09PSkfzdo0OD+/ful1UxJSfnuu++io6Ppy4CAALVabTQav/zyyy+//PL48eOOjo5lf1ZxcfG0adNkMhl92bZt27ffftueRv5DotFoKlK/fMXFxWKxuPbH1Gg0IhHLXy2YTCadTscwICHEYDCYTCaz2cwwpk6nE4lEEomEYUyNRmMymdiuI41Gw3Ecx3EMY9aVjfNJjsl8xzSbzVqtlmFAUm07JsdxRqORYczi4mKj0ch8xySEYMdEzAqRSqUODuVkUHYlWBKJRNhJ9Hq9kP1YycrKGjJkyOzZs4ODg2nJggUL6B+ffvppu3btNm/e/Oabb5bTIAeHDh06KJVK+rJNmzalfVwpzBWsX74yulyrYhoMBrYxTSYTIYRtTJFIZDKZmPedeYJFG8l2l6YriO1xvK5snE9yTOY7ptls5nm+TuyYHMdZXt+oOrPZLJVK2e6YRqMROyZiVpQ9/2uyK8Hy8fG5d+8e/fvevXuNGjWyrZOVldW7d+8JEybMmDHD9l2pVNqxY8c7d+6U+1kSiWTChAnu7u72NKwkZuZ5rlgsRkxW6H+R2cYUi8UikYh5TOZ9pwHZHsfrxEpHTLYxOY6rKzsmbSrbmNgxEbPWxrRi18D1sGHDfv31V/r3r7/+OmzYMPp3TExMXl4eISQ7OzssLGzMmDEfffSRsBTP88LVupycnNjY2MDAQJZtBwAAAKiV7BrBevfdd4ODgwcMGGAymdLT0zds2EDLBw8eHBMT06tXr3nz5l2/fn3nzp07d+4khHh7e+/evdtgMDRq1Cg4OFgulx87dqxPnz4vvfRSNXYFAAAAoHawK8Hy8vJKTEw8cuQIx3GhoaFyuZyWnz17tnnz5oSQjz766PXXXxfq04vuUqn08uXLFy5cMBqNixYtat26dTW0HwAAAKDWsXcmd4VCMWjQIKvCdu3a0T/8/Pz8/Pxsl/L19fX19a1K+wAAAADqHDyLEAAAAIAxJFgAAAAAjCHBAgAAAGAMCRYAAAAAY0iwAAAAABhDggUAAADAGBIsAAAAAMaQYAEAAAAwhgQLAAAAgDEkWAAAAACMIcECAAAAYAwJFgAAAABjSLAAAAAAGEOCBQBQl2iM5K66phsBAOVBggUAUJdEp/GfXRTXdCsAoBxIsAAA6hIzT3jC1XQrAKAcSLAAAAAAGEOCBQAAAMAYx/N8TbfhX05JJM86OXFcKQPgb79NPv/80cv4eNKvn+X7eTriJvvnBceRkydJq1aP3n7nHbJ1a6mf3b072bPn0cuiItKyJdFqeZ4vuT2rV5OXXnr08scfyUcflRrc2ZncvEkcHOgrlUrlPGgQuXKl1Prl9fRfOI6cPFnk4+Pk5PR3SaV6alvx775XoaeEEBISYtlT6++z4j2t+jottf4/PdVoNDKZTLx+fVV6akU/caLkq68e9Z1FTx99mZXt6d8s1mkJG3wFe2q7Tvnw8FJ36squU5VK5ezsXJWe2jIrlaLbt6vSU9t1+uj7ZLT16s3EYCJKiU39KuynBoNB3Lu36OrVUutXfD/V+ftzHCeVSgl54o5IpZ41qrCfqlQq519+YXhEIm+/rfr4Y2dn579fMjr2/t13dkckYruOqnxEIv36lbqO7OzppElk6dJSP5FGqm0Jlo+7++X4eDc3t5LfdnIikn8fV/LziUUX3Dcbcl/9p4JIRFxc/lVZryfq0n9+4+hI5PJ/lahUxGgsKip6lLhYcnUllqvHZCKFhaUGl0iIRRCVSuXs4FDW1lZeT/9FJCIuLv9qZ6V6alXLZDLp9XpHR8eq9JQQQoqLhZ4aDAaz2SyTyR69W/Ge/qtEr9fl5opEIonE9oRjb08f+aenfydYhFS6p7aKCFG6uv5rl65gT23X6aOVXtme/s1inZawwVewp7brtCg93UmpLLlyZffTvxMsUvme2irS6Zy8vP5VVMGe2q5TtVqtpH1ndET6/ZZpb5ppfS+pdf0q7KcGg8FUVCQvtXZl9lOdTvcowWJxRCKEaLVaiUQi9vBgdUQihGg0GkdHx0c7ZpWPSEStLvWsUYX9VKVSOSsUDI9IxMlJpdU+SrAIgyMSEQ4g7I5IxPagVOUjEsnPL1KpSl5HdvbUNqYNh7Lffvy0HMe7upLSEixbrq6Wr/IUBuJWep+lUiK1OSqVwdmZEMI7OBDLTbA0YnEFmk0IcXQkjo4VqP/vnpajUj21ZjLxOh1RKKzLq9JTg4E3max3PCsV7ambGxGJyt3W/2bPqhSwXadFRdYlVV6nZW2cle2pXRt8Bbde3sWlAu1hsvWWpsx1yqtU1kVV3k9525OBoFI91buY1Hkm4lbegpXYesveMa08/iMSIXxxMZFKidXAQ9X2U14qJQqFdUxLFe+pvWcNUqNHJEKskxIW67TUvlehp+V/nxXfT3mx2N4mVXTr/QfuwQIAAABgDAkWAAAAAGNIsAAAAIANnammW1BrIMECAAAABtRG0n5vRe7k+09DggUAAAAMGMykyFC7piaoQUiwAAAAABhDggUAAADAGBIsAABgb10yt+1WTTcCoObUuolGAQDgP+CumigdSp+9E+C/DiNYAAAAAIwhwQIAqC5ns/lXjtn3ECcAeFyKDOT4g2rPf5BgAQBUF5WBqEp/vi0A1IjzOfziy9V+ixQSLAAAAHiCPJ6pupBgAQAAADBmb4KVm5u7b9++8+fPl1bBYDAcPXr00KFDWq3WsjwtLW3fvn3Xr1+vUjMBAAAA6g67rkGePHly2LBhQUFBSUlJQUFBmzZtsqpQWFjYu3dvqVTq6Oh4//79Y8eONWjQgBDyyy+/vPPOO7169YqLi5syZcqnn37KvgcAAAAAtYxdI1izZs365JNP/vjjj7Nnz/75559xcXFWFdauXevq6nry5MnDhw+3a9fum2++IYQYjcYZM2b8/PPP//d//3f06NHFixdnZmay70E105rIh+cwWxgAQM374ZrocEZNNwLAPuUnWNnZ2ceOHRs7diwhxNXVdfDgwTt27LCqs2PHjtGjR4tEIkLImDFjoqKiCCGnT5/W6XQDBgwghLRo0aJjx47R0dHse1DNCvRkR5q4plsB8PiMYYpCvQAAIABJREFUPCop0Nd0IwBKklTA3VbhWcJQN5Q/NpOeni6Xyz09PenLJk2a2N5QlZaW1qRJE/q3n59feno6XbBx48Y066IL0vKyGQyGnTt3Ojk5CdG6dOliX1/+ZjabK1S/vGjsYxrNJCGH9FSyjKkxkkt5pJuCZcxcrTmtgG8vZxkzQ8MX6cxPSVnGvF1odpRwjeuxjHm9gPdxNtdXsJyHOjGPPC0xKyUsYybkkO6OZgnTH6sk5olUepMz0zm4T2WTvkw3eELI6WzSh2lMo5nEPyS9mMbkecLzPOuDkpl5zEwNX6gzt2a6Y/I8z/OMD548zzPve2Iu38bB7MR0xzyXQ551NEuZ7phnskkvhVnEdG78PencS61q+xnTxJOzD0lvpjum2VzVDUnIbcpQfoKl0+mkUqnwUiqVWt3GTgjR6/USyd+T6UkkEr1ebzabdTqdg4ND2QvaMhgMO3bsED6xU6dOzzzzTLlLCd5pYdJqWQ44yc1kbBOjVsvyKuGVfO6dM5IzDcr/NuwXmylalija48Ey5q7b5MA9boMry5iRN0iGhv+yC8uYq6/xHjJ+xtMspxtamkhCvQ1jmxsYxpxzQTS1tT68Ecv/f3+Y4LBWrmtVj2XMMU2MCt7Bjp21AgYfkeeM0orZnRty9dzLx6V3vVi28lohN/mMJKEhy5iNZWRAQ4NWy/Lc0ErJ9/IwarUmhjG3JvN3isjyriz73tnFJHcgWi3LHbOHu/EpJ5FWyzJz+eyi+I1W+oE+LHei9+IdvnfQdXRnGXN8nPSvelpfBcOQ5OQDfqiflmHO5mAm4/0ZnzFvF5HJZyTnWO+Yg7yMVdkxpVKpZYZTovK/BW9vb5VKpdPpZDIZISQ7O9vb29uqjpeX18OHD+nf2dnZXl5eIpHI29s7JydHqJOdnd2hQ4dyP06hUGzatMnd3b3cmiX6vJNKoWC5ASoI+awD45gyLc+JDAqFnGFMqYwXifUKhYxhTInUKBKb2MZ0kBjEDmbGMR30DhJOoWA5X7ZYrJNIxQoFy8OESKSTyiQKBctzw96+Kk9XZ4YBCSHzOqicnZkexQkx8waFQsEwwdKICOH0bHdMDzNf35FxzJYKMlVexDZmJ7m5rZuWbUyJxOAg4RUKaflV7fZcMx3HcZb/P6+6MS2LpVKpWMzyf9EisU4qZbxjciKdTCZVMB0CJ5xeLndkG3NxR5WS6YZECFnYkfEZs62C7ApVKRQsD3TNFWSalHE7bZW/Sfn6+jZu3PjIkSP05ZEjR4KDg63qBAUFHT58WKgQFBRECOnYsWNGRsbt27cJITqd7uTJk7QcAFiR4/5AdvycuL2hT+jdZxweygy1mLdjTbegUsr/D7pYLJ4xY8aUKVM+++yzkydPFhYWjhw5khASFxfXo0cPk8lECJk6dWq3bt2aNm2qVCq//fbb/fv3E0I8PDwmTpw4evToadOmbd++vUOHDhW9mwoAAB6DkX5EpWd8kxzAE86uKyDTpk1r2LDhgQMHvLy8jh8/Tq8VNmnSZOHChbRC69atY2Nj169fbzQa9+3b161bN1r+3XffrV27NiYmpkuXLtOmTaumPgAAQFV4K0gDltftAcC+BIsQMmrUqFGjRlmW+Pj4fPLJJ8LL9u3bf//999bRHRwmT55cxSYCAAAA1C14FiEAVLt13fQM73AHAKj9kGDVAJxonkwSEZE9qfekP98E9/cAwJMFD4GpAa1cuS87GAhh+etlqP02BRk86mGlAwA8ETCCVQOkIhLSAP+hf+JgSgWG3GXkqw4sp4EFYAszXwASLHisXKXERYoDD1SViCMv+OF/KVBLLWxnbOuKA92TDpcI4bGaEEBMJpwXAeC/LKSB2RFn1yceRrAAAAAAGEOCBXUexxG2T5gHAKhtXKVEjslO6hQMYkKdN+UpXorjDgD8p53sr3N2xM+Q6xIkWFDneTsSEYZiAQCgNsF56T+isZJ09sDN4wAAALUCEqz/iKdcuTnPmGq6FQAAdcz/WpqfbYB7DIA9XCIEAIAnVx8vs0Je042A/yKMYAEAAAAwhgQLoAQSEZFi5wAAgMqqdZcIv1OrnZ9/nkgkJb89fDiZMuXRyytXyPTplu8rTCYi/ueRbxxH1qwhTZs+envpUhITU+pnt2lDvvvu0cuiIjJqFNHr/xXT0syZJDz80csdO8iqVaUGd3QkUVHEweILnzSJpKaWWr+8nv4L7amn56OSSvXUqla4hu+g5Ym7iGFPHXhezPP/+tVfJXr673Uq+fNPjuNKfvSXfT195J+eftnR5Kp0YLtOJQMHkvfee/S64j21XaePNs7K9vRvFj0tYYOv8tarmDq15J2IMNtPS61fka3XUSIhu3ax3U8dhe+TUU85npeZzSV8n1XbTyX/+x9JTy+1fiX200aNHpUwWqcys5njOPLRRwyPvXKTibP8Mqt8RCIxMaWeNapz663Mfjpu3KOXLI5IRDiAMO2p9ffJ4nxa6jqys6dDh5Jp00r9RBqJ5/myazxmoS4uuzZudHZ2LvntFi2Iv/+jl8XF5MQJy/c1Go1Cofj7BceRkBAitZg4JCWF3LlT6mc3aEACAx+95Hly9CgxGP4V01LHjsTd/dHLrCySmFhqcEdHEhwsvFKpVM7JySQ3t9T65fX0XziOhIQU6fVOTk5/l1Sqp1a1YtJNZx+YP+koqUpPCSHk3Dmhp0aj0Ww2Sy1XSsV7arVODcnJHMc5OJT0vwX7evrIPz3VaDQymUz88GGle2pL06iRY+vWnJAIVryntuv00cZZ2Z7+zWKdlrDBV7CntutUExNT8k5EKr+fqlQqZ2fnqvTUlobnFZZHeVLhntqu0+LiYkdHR0KYHZF4ntfr9TKZzLp+FfZTg8HAJyRIi4pKrV/x/VTH8xzH/b2zszgiEUJ0Op1EIhF17szqiEQI0Wq1Mpns0Y5Z5SMSuXOn1LNGFfZTlUrlrNEwPCKRFi1UHh6PzrYsjkhEOICwOyIR24NSlY9I5MSJUteRnT1t3vxfSVhJal2C5eHhkZyc7G75RVfE38dcpupKzKKiokcJFgsnM01xGYYZHVje/2kwGEwmk1zOMqZOpxOJRJLSRj0r5e8Eq7RBl0opKipSKpVciSNtlVVXNs4nOSbzHdNsNmu12lIT1kqpph3zUYLFSHFxsVQqZbtjqtVqhUKBHRMxmfuv3WYya9YstgG1Wu1nn33GNmZOTs5XX33FNubt27cjIiLYxpTfv1gvfjPbmEePHt29ezfbmNHR0UeOHGEbc9u2befPn2cbc82aNTdv3mQbc9myZdnZ2Wxjzp8/v7i4mG3Mjz/+mO3/5fR6/dy5cxkGJITk5uZ++eWXbGOmpqauXLmSbcxLly5t3sx4xzxx4sTOnTvZxty3b9/hw4fZxvzll18SEhLYxvzxxx+Tk5PZxvz666+zsrLYxly4cKFarWYb85NPPjGbWU6gaDAY5syZwzAgISQ/P3/JkiVsY6alpf3www9sY9r6ryVYq8q4Pl0pBQUFkZGRbGPeu3dvx44dbGOmpKTs37+fbczLly8fOnSIbcyEhIQTZYxCV0pcXFx8fDzbmIcPH04sYyi+Uv7880/mx/GdO3eml3HfTKVs3bo1Ly+PbczVq1ezPY4XFhYyTzIyMjKioqLYxrx58+a+ffvYxkxKSmK+Y547d475jnnq1KkzZ86wjXn06NGLFy+yjXngwIHr16+zjblr1667d++yjblt27acnBy2MX/88UdDGZftKk6tVm/cuJFhQEJIVlbW77//zjbm7du39+zZwzamrf9aggUAAABQ45BgAQAAADCGBAsAAACANb6WYfszFgAAAAC23n///XLzmVo3TQMAAABAXYdLhAAAAACMIcECAAAAYAwJFgAAAABjSLAAAAAAGEOCBQAAAMAYEiwAAAAAxv5rCZZGo6npJpTPZDKxffwTIUSv1xuNRrYx65A6sd61Wm2diCkwmUw6na764rNSHV9CndiiqonZbK7W7YqV2rZDlbZsVbalx9bHKp6VSoxZlbNSdZwleZ5/zAe0/06CdfLkyebNm/v6/j979x3QxPn/AfxJQtgBCVtANogL61bUOtGfs27FVRVHbevWCtLxdVWt1VatVbRqa7WKCxWtJYpbQUVQVByIExVEwkgImff749qYMiQhDxX0/for9+TJO3fJPXefXC4Xdz8/v4sXLxof+PLly3HjxjVp0kQoFObl5RkfSAhJTk5u3769QCCws7Nr3759enq68ZkJCQn16tWzs7OztbXt1KlTZmam8ZlaI0aMEAqFhYWFxkft3LlTqOPq1avGZxJCduzY4eHh4eTkZGtrS+XPO+vXr687n9OmTTM+89KlS8HBwd7e3kKhcOLEiVRK4XPnzjVs2NDLy8vNzW3fvn1VzlmwYEFISIiDg0Op/zmOioqys7NzdnYeMmSIoXuIpUuXfvjhh05OTlu3btU23rlzJywsLDAw0NPTswrz+fXXX7dv397R0TEmJkbbuGbNGj8/P6FQKBAIPvnkE4O2yMXFxRMnTmzWrJlQKMzIyNC2R0ZG2tjYuLm5CQSCadOmqdVq/TNv3bo1YsSIgIAAf3//svempqY6OjpGREToH0gIefLkyZgxYxo2bCgUCnUXMCwsTLuWNmrUyKDMM2fODBw40MvLq3v37rrtMpls4sSJ1tbWDg4Ofn5+Bq2oiYmJgwcP9vHxCQkJ0TZeu3ZN+G+HDx/WP3Pv3r29evVyc3ObMmWKbvuyZcucnJx8fX29vLwM/Rvgbdu2hYaGuri4LFiwQNvIMExkZKSTk5OHh0e3bt2ys7MNygwPD3d0dLS3t3dxcVm/fr22PT4+3sPDw93dvUGDBob+R/WMGTNcXFwcHBwcHBxWrFihbZ82bVrr1q3t7e1Pnz5tUCAhZMqUKU5OTg4ODs7OzmvWrGEbk5KS2rZty+6VOnbsaNAf0ufl5fXr108gENjb2wcGBmr/1/z48eMeHh7sXqlz584PHjzQP/PKlSshISHaveTt27d171UoFK1bt27cuLH+gYSQu3fvdu3a1crKyt7evnnz5pcvX2bbS+2VUlJSDIqt1DtSYKnV6rCwsKioqLy8vAULFoSFhRm0WSwXwzDBwcGLFi0Si8W0LseqVCrnzZsnFovz8/ODg4PHjBljfGZgYOC5c+ekUmleXp6np+fnn39ufCYrJiYmOzub1uLL5fI2bdrc/0eTJk2MzxSJRLNmzdq9e7dEInn06FHTpk2Nz0xKSmLn8M6dOzweLzQ01PjMCRMmDB8+/Pnz55mZmWfOnPn111+NDJRIJIMHD46MjHzx4sXhw4fHjx//8uXLqkU5OztHRkba29srFAptY3x8/LZt227fvp2dnZ2Xl7dy5UqDMu3t7WfPnu3p6an7eZFhmPbt28+ZMyc/P78K8+no6Dh//nwnJyfdTBsbm9jYWKlUeufOnVOnTmn3GfrQaDSBgYErV64Ui8W6m4sRI0ZkZWWJxeL09PS4uDiD3iyGYTp27Dhz5syyy6hUKidPnhwYGCiTyfQPZDNbtGgRFRUlFot12yUSyZIlS9h19fz58wZlcjicvn37jh49uqioSLd9ypQpz549e/LkiUQiOXToEJdr2A6iZ8+eEyZM0P081qhRI+2Q37Vrl0Kh6NSpk/6Bpqamo0aNCg0N1S3xL1++vHjx4gsXLmRlZa1fv37UqFFSqVT/TAsLi/Dw8JCQEN034vfff9+9e/fNmzdzcnKCgoJmzpypfyAhJCgo6Nq1a1Kp9MCBA3PmzLl06RIhRCaThYWFrV27Ni8vLzw8fOzYsQZlent7X7p0SSKRnDhxYunSpfHx8Wy7u7v7woUL+Xx+FQ7wBAQEpKSkSCSSuLi4yMhIdrVRKpVRUVH5+flisTgwMPDjjz/WP1CpVPbu3fvp06dSqTQiImLIkCHsmh8UFHT+/Hl2r+Th4WHQx1SlUjl//nyxWCwWixs3blxqL7lkyRIrK6uCggL9AwkhCoVi0qRJubm5hYWFffr0GTRoELtTK7VXMrRuq1y1/efNf+rEiRMuLi5qtZphGLVa7eLikpCQQCU5JyeHEJKbm0slTVdiYqKFhQXdzB07djRt2pRK1MuXL4OCgtjjTPn5+cYHbtmypX///sbn6AoNDV2+fDndTK3Y2FgXFxelUml8lIODw5kzZ9jbgwYNWrx4sZGBFy5cqFOnjnbyww8//OGHH4wJDA4O/uOPP7STYWFhERER7O1Dhw75+PhUIbNTp04///xzqcakpCQbG5sqz2eLFi1+++23cu+aOXPmuHHjDA3UaDSEkNu3b5d774ABAxYtWmRo5tmzZx0cHEo1Llq0KCoqasqUKdOnTzc0kGEY9riCQqHQtvTt23fbtm1ViNLaunVr69attZNZWVl8Pv/JkyfGZMbExDRq1KjcuyZNmlSFN4hhmMjIyNGjR2snDx8+7Ovry95mi7kqzPOkSZNmzpypnRw7duwXX3zB3r5165apqWlBQUEVZpVhmObNm2/ZsoVhmD179tSvX59tLCkpsba2TklJqVpm165dV61apdvi7u4uEomqlsZq06bNxo0bSzWePn3a1ta2aoEqlcrU1PTq1aul2rdv396sWbOqZV64cMHS0lI7ee3atebNmx8+fNjDw6NqgQzDsIfT2J1adeyVdL0jR7AyMjICAwPZz1tcLjcwMFD3mH/NFBsb27FjRypREokkOjr6+++/X7Zs2TfffEMl8/PPP4+IiHBycqKSxjpx4oStra2fn9+iRYuMP8RICElLS5NKpU2aNHF1dR03bpyhH2vebMuWLePGjTMxMTE+6quvvoqIiNi1a9d3332Xnp5u6GfZsszNzeVyufaYU1FREd0VPiMjo0GDBuztBg0aPHz4sIaf4VdSUnLs2DFaAyotLS06OnrevHkPHjwYP3688YG3b9/es2eP7ndSVMyePdvW1rZ169Z//fWX8Wm3bt1yc3P78ccfPTw8AgICNm/ebHymlkwmi4mJofJidu/evW7durNnz967d++4ceMmT57s7u5uZKa5ublEImFvSyQShULx+PHjKuRkZGTcvn27Xbt27O2goCC23czMzMfH5/79+1XIzMrKunLlSocOHarw2Io8ePDgxo0bul/msg4ePFjlQXT06NE6derUr1+fnSwqKoqOjl65cuWKFSuqvFc6ePDghx9+yN5WqVQTJ05cu3Ytn8+vWhorNja2adOmtra27KR2r7R48WIqeyVdFHYeNUFBQYGVlZV2UiAQlDqcXtMcPXp006ZNVM4VI4TI5fLk5OSXL1+qVCpLS0vjA+Pi4nJyckaNGvXs2TPj01gdOnS4cuVKvXr1UlNTR4wYYWFhMWfOHGMCGYbJyck5ePCgSCSysLAYNGhQRESE7gkQxsjOzv7zzz+XL19OJS0gIKCwsDAmJubZs2dNmjQRCARGBjZq1MjHx2fWrFmffvppfHz8jRs3tPUQFfn5+doBZW1trdFoCgsLhUIhxaegiGGYTz/91N3dncp37oSQ7Ozsy5cv37x509XVlcfjGZmm0WjCw8NXr15N95/sIyMjvb29LS0td+3aNWDAgKtXr2r3bVWTnZ398OFDExOTBw8eXLt2rVOnTg0aNGBrBePt2bPHycmp7B69CkxMTEJCQuLi4h4/fpyenk7lLMlhw4YNGDAgNDTUy8srMjLSxMSkCnuQwsLCoUOHzp07NzAwkFDaK8lksuHDh48bN65FixaGPrYiEolk6NCh06dPb9iwoW77wYMHt2/fnpSUVIXM+/fvT5o0aePGjRYWFmyLdq+kVqurtlc6cuTI5s2bExMT2cnly5e3b9++bdu2xnycSExMXLhwoTahQ4cOycnJHh4eKSkpYWFhFhYWs2fPrnJ4We/IESwHBwfdL/7FYjHdQy90nTx58uOPPz58+HC5Z8JWgb29/caNG/fv37906dJRo0Yxxp0yxTDM5MmTR4wYceLEibNnzxJCTp06lZuba+RM+vn5BQYGWlhYtG3b9osvvoiNjTUykMPhODg4TJw40dnZ2cbGZvr06ceOHTMyU2vbtm1t27Y1co/FkkgkQ4YMYd+gxMREhmGMP8rI5/P/+usvpVLJnjQzbNgwDw8P42dVy9HRUXs4MD8/n8/n16lTh2I+XTNnzrx169a+ffsMPWeoIt26ddu0adOFCxeEQqHxb9aWLVs4HI5Gozl+/PjTp08fP37MnqNjpDZt2jg7OwsEgokTJ4aEhBw9etTIQAcHB0JIRESEiYlJ8+bNe/XqRXFA/fLLL+PHj+dwOMZHbd++PS4u7urVq3v27Dl58uTcuXNTU1ONzOzcufOvv/66efPm+fPnT5o0iRBi6ICSSqW9e/du06bNV199xbYYv1eSy+UDBw709PT8/vvvDXrgGxQXF/ft2/eDDz5YtGiRbnt8fPykSZOOHDni7e1taObjx4+7dev2zTfffPTRR9pGBwcHdqO3aNGikSNHGrpXOnHixLhx4+Li4vz8/Aghz58/X7VqVceOHY8fP56SklJSUnL8+HFDf2J59erV/v37//777y1btmRb/Pz8AgICLCws2rVrN2/ePOP3SqW8I0ewGjRokJaWplQq2VP/qH+gp+jChQvDhw/fvXt327ZtqYcHBQXl5eUpFAozMzNjckJCQthzKtnzQLdt21avXj12+0uFQqGg8tVbo0aNtF9dqVQqKpmsX3/99YsvvqASlZOTU1RUpD19Mjg4WPuZzBhubm4bN24khKhUKvZkbeMztRo0aHD16lX2dNerV68GBQXRql2oi4yMPH369IkTJ4w/LlhWUFDQlStXjAypU6eOq6trdHQ0ISQ9PZ3L5e7fv79Vq1Y0ZvBvVAZUgwYNuFxudQyozMzMixcv/vHHH7TSgoKC2O+JnJycXF1dMzMzjf+BS//+/fv3708I+fPPPx0cHAwqsGQyWb9+/fz8/NatW6ctIhs0aPDjjz8yDMPhcIqKiu7fv6/9xlAfSqVy6NChlpaW27ZtozX6FArFkCFD6tWrt2HDBt1i9+zZs6NHj96zZ4+28tBfVlZWly5dpk6dOnny5HI7sHslpVJpamqqZ+b58+fDwsJiYmLatGnDtiiVyq5du+7YsYMQ8uLFC6lUGh0dHRwcrP9R4evXr/fq1Wvt2rW9evUqt4NSqaS4B/lb9Z3e9R9r2rTp/Pnznz17Nn/+/A8++IBK5vHjx9nfAO/bt+/48ePGByYnJwsEgvnz54v+oXvWatXs3bs3ISHh0aNHly5d6tGjR58+fYyfT62nT58SSie5//rrr4mJiY8ePYqNjXV2di57+nMV7Nu3z9/f/8aNG5mZmW3bttWel22ks2fPWltbFxUVUUlTqVTe3t5z5szJyclJTU319/cvdb5q1Rw7diw9PT0tLW3MmDGtW7eu8sn4V69eFYlEPj4+CxYsEIlEeXl5DMNcvny5Tp06p0+fvnv3bqNGjdatW2dQ5vXr10UiUXBw8PTp00UiUXZ2NsMwMplMJBKtW7fO0tJSJBKdP3/eoMyUlBSRSBQQEPDFF1+IRCL2dycLFy60tbXdvXs3O5rKnmD7ZqdPn2Y/SGzdulUkErGv4erVq1NTU9kV1dXVdevWrfoHSqVSkUi0evVqW1tbkUh04cKFUh2qcJK7SqUSiUTsjxn//PPPU6dOMQwjkUjWrl178+bNjIyMJUuWWFtbZ2Zm6p+Zm5srEonmzp1bv359kUiUmprKtn/00UeTJ0/Oycn5888/ra2tr1+/rn+mWCwWiURffvmll5eXSCRKTk7W3hUREdGvXz/9o7QeP34sEolGjBjRrVs3kUh09+5dhmHYYlokEr169Wrz5s1WVlYGneSekZEhEol69+49aNAgkUj04MEDhmHy8vIOHz788OHDo0ePenl5RUdH6x+o0Wi6d+/euHHjv/76i10P2Ux24H/77bdZWVlTp07t2rWrQcs+ePBgPz+/o0ePspnssjMMk5SUJBKJHBwcli9fLhKJDNpM/d///V+DBg2OHTvGZt6/f58NtLKyioqK0u6VVCqVnoF5eXkBAQH9+vXTPvbly5cMw7AHF9m9Uvfu3Q16969cuWJtbR0REaHNLLVxO3bsmKEnuWdkZDg6Ok6ePFmbKZVKGYbZtm2b7l5pw4YNBsVWisNQugDBW5eZmTljxoybN282atTohx9+qMJxzrJCQ0O1rw+PxzP+gPnBgwfXrVun23LgwAFra2tjMmNiYtavX//kyRM7O7uuXbtGRERQ/DYnNzd3xIgRsbGxuicTVM133323e/dusVjs5uY2ZsyYCRMmUPm+YO3atZs2beJyuX379o2KijLy0B1r/fr1YrGY4inJ6enpX331VVpamrW19YABA+bPn2/8mT3ffvvt77//rlKpunXrtnjxYjs7u6rlzJ8/Pzk5WTu5cuXK4OBgQsiOHTu+//57mUw2bNiwr776yqDP0EuWLDl16pR28ptvvgkJCcnOzh41apS20c3Nbdu2bfpnfvnll7pH/pYtW9a8efOZM2feuHFD29iyZculS5fqn6n9VTmLHYwzZsw4c+ZMUVGRm5vbuHHjDPpFQlZWlu6v3D09PUudKv7jjz/y+fypU6fqn8keHdFO2tjY7Nu3TyaTjR079saNGwzDBAYGLliwwKBjD5cvX46MjNROtmvX7n//+x8h5NWrV7Nnzz5//nzdunUjIiJ69uypf2ZaWtqsWbO0k82aNdOewjh27NjRo0d369ZN/zTWgQMHdM+qHDJkCPv93fbt2zdu3Jidne3j4xMREWHQpR+2bdvGHghhsZdQyc3NHTVq1L179xwcHD777LPRo0frH8gwTKmLuYwfP37EiBGEkFu3bs2aNevevXstWrRYvXp13bp19Y/t37+/7sUptMs+depU3UtVRUdH67+z69GjB/uzWdbo0aPHjBmzb9++DRs26HaLi4vTc0N67969UivzkiVLWrVqtWvXrg1pQV2LAAAgAElEQVQbNrB7pW7dukVERGhPKq9UbGzsTz/9VKpFdwd05cqVVatW7dy5U89AQsiZM2dKfSW6detWd3f3FStW7N69Oz8/383NbezYsbS+xdZ6dwosAAAAgBqihp5XAQAAAFB7ocACAAAAoAwFFgAAAABlKLAAAAAAKEOBBQAAAEAZCiwAAAAAylBgAQAAAFCGAgsAAACAMhRYAAAAAJShwAIAAACgDAUWAAAAAGUosAAAAAAoQ4EFAAAAQBkKLAAAAADKUGABAAAAUGbytmcAAOBd8OrVqwcPHjAM4+/vX6dOnbc9OwDwluEIFgD8F/bt28fRYWlp6eHhMXjw4DNnzrztWTNKZmbm3LlzfXx8HBwcWrZs2apVK6FQGBoaevPmzbc9awDwNnEYhnnb8wAA7759+/YNHjzY3t7+gw8+IIQolcq7d+8+f/6cw+H89NNPn3zyyduewSr66aefPvvsM6FQ2KNHD39//4KCgri4uPv379vY2Jw/f75Ro0ZvewYB4O1AgQUA/wW2wOrRo8exY8fYFqVSGRkZuXLlSgsLi0ePHjk6Or7dOayaQ4cOZWVljR071tLSkm2Ry+UDBw48evRonz59Dh8+/HZnDwDeFhRYAPBfKFtgEULUarWHh8fz58937949dOhQQkhBQcGFCxceP34skUjc3d27dOlSqvAqLi5OT0+vU6eOr69vdnZ2fHz8ixcvevbs2bhxY0KIQqFITEx88ODBixcvXFxc2rVr5+/vX2pOUlJSuFxucHCwRCI5evRoVlaWh4dH3759zczM2A7nz5+/evWqiYlJaGior69vFRb26tWrzZs3t7GxKSgoqMLDAeAdgJPcAeCt4fF4fn5+z58/z8nJIYTMmjVr3bp1SqVS28Hc3Hzx4sWzZ8/Wtty5c6dFixYDBgzo3r37jBkzFAoFm9O4ceOdO3dOmTKlqKhI25nD4YwePTo6OlpbPBFCOnbsaG5uHhsbO3DgQPZ5CSE+Pj4JCQkCgWDIkCEJCQlsI5/P37Rp09ixYw1dLmdnZ0KIWq029IEA8M5AgQUAbw3DMA8fPiSE2NvbE0Jyc3OnTp0aGhrq5eWlUqkSExP/97//zZkzx9/fv1+/froPvHz58rFjx+bNm9exY0cTExNra2tCSHZ2du/evQcNGuTr62thYZGenr5kyZLffvvNycnpu+++0314cXHxgAEDBg8ePGzYMB6Pt2rVqgMHDkydOpVhmMLCwgMHDtSrV+/EiRMLFiyYOnVqz5492YJJf+xRulatWhn38gBAbcYAAFS/vXv3EkJ69OihbdFoNMuXLyeE8Pn8rKysch919epVQkiXLl1KtRBCoqOjK33S/Px8Nzc3a2truVyubWSrsVmzZmlbZDKZk5MTIcTX17ekpETbPnHiRELIli1bDFrSJ0+esPXisWPHDHogALxLcJkGAPjv3Lx5c/LkyZMnTx45cmTjxo2/+OILQsiXX35Zt27dcvt/8MEH9erVu3TpUql2JyencePGVfp0tra2nTp1kkgkt27dKnXXrFmztLfNzc1bt25NCPnkk09KfZlICHnw4IFey0YIIUQul4eFhb169Wry5Mk9evTQ/4EA8I7BV4QA8N95+vRpdHQ0e9vc3LxDhw7Tpk0bPHgw21JSUrJmzZoDBw48evQoOztbo9FoHyiXy3VLn4CAABOT0psvhmF27969ZcsW9gIQ7OlZrNzcXN2eVlZWpUo69lT6gIAA3Ub2sFZ2draeS6dUKocOHXr27NkePXqsWbNGz0cBwDsJBRYA/He6dOnCflfI4/FsbGx071Kr1T169Dhz5oyvr+/AgQMdHR3Nzc0JIT/88MOLFy9UKpVugeXg4FA2PCIiYvny5fb29n369PHw8GC/CoyNjU1MTFSpVLo9LSwsOByObguXyyWEaC+1wGL7MPr91FqlUoWFhR06dKhr166xsbGmpqb6PAoA3lUosADgv8Pn8+3s7Mq96+DBg2fOnOnZs2dcXByPx9O2r1q1qmznUuURIeTFixcrV6708PBITk7WvbLD5cuXacx4JdRq9ccff7x3796OHTsePHiQLQ0B4H2Gc7AAoEZITU0lhAwePFi3unr69Kn2SgpvlpaWplaru3btqltdaTQaNrZaMQwzderUHTt2tG3bNi4uzsrKqrqfEQBqPhRYAFAjsIXR48ePdRu/+uorYx7+66+/3r9/n9IMlo+trqKjo5s1a3bkyBGBQFCtTwcAtQW+IgSAGqFTp04cDmflypWOjo5dunQpLCzcuHHjvn37HB0dX758WenDg4KCnJ2dExISZs2aNWrUKBMTk0OHDi1evNjHxyczM7P6Znvt2rUbNmwghPj5+c2fP7/UvStXrkTJBfB+QoEFADVC48aNf/jhhzlz5nz++edsi6Oj44EDB2bNmqVPgWVmZrZr167BgwevXr169erVhBA+n79ixYqMjIyffvqp+mZb+w1mTExM2XsXL16MAgvg/YT/IgSA/4JUKs3OzrawsHB1dX1Dt2fPniUmJr58+bJevXqdOnWysLB4+vSpQqHw9vZmT2yXy+VZWVlWVlblXl29sLDw4sWLjx49srOz69y5s4ODQ25ubmFhoYuLi/YXgg8fPuRwOJ6enroPfPnyZVFRkaurq4WFhbZRJpM9f/5cIBC84Y+o8/Ly8vPzK7rX09NT95QyAHh/oMACAAAAoAwnuQMAAABQhgILAAAAgDIUWAAAAACUocACAAAAoAwFFgAAAABlKLAAAAAAKEOBBQAAAEAZCiwAAAAAylBgAQAAAFCGAgsAAACAMhRYAAAAAJShwAIAAACgrMYVWJ988olCoajyw5VKJcWZec8zGYZRqVR0MzUajVqtppupVqs1Gg3dTJVKRf1/0GvFm47Mmp+JgUk3s1a86cisFZml1LgCKyYmRiKRVPnhJSUlFGemdmXK5XK6gRqNxphit1xqtZr6aq1SqajvGxQKBfV9g1wup75vqC0r5/ucSX1gMgxTWwYm9UJQqVRSH5gKhQIDE5nVwUSfTgzDZGRk3Lx509/fv2HDhuX2yc3NPXDggEql6t+/f926dbXtZ8+evXz5ckBAQO/evTkcDp25BgAAAKjB9DqC1bdv33bt2oWHh+/Zs6fcDs+fP2/SpMnZs2dTU1ObNGmSkZHBtq9cuXLUqFEvX75csGBBeHg4tbkGAAAAqMH0OoK1fft2Ozu7sLCwijqsX7++ffv2v/32GyHExMTk+++///nnn4uLi5csWRIfH9+yZcvZs2d7enpGRET4+flRm3cAAACAGkmvI1h2dnZv7nDs2LF+/fqxt/v163fs2DFCSFJSkoWFRcuWLQkhDg4Obdq0iY+PN25uAQAAAGoBvY5gVSorK8vV1ZW97erq+uzZM4Zhnj17pnsyVt26dZ89e1ZplFwuX7VqlYWFBTvp7+/fv39//efk9wzN+AaUTymVy+Wmpqa1IpPP51MMVKvVcrmcx+NRzFQqlWq1mu7ZeHK5nMvl0j31lT0xme6yy+VyExMT6steW1bO9zmT7sDUaDS1ZWByOBy654+zvxShPjB5PB4GJjINwufzudxKDlHRKbBKjSJ2TS3VyDCMPmswwzD5+fna390Y+sOWqcmW4xtQ/o0JAADAf2n//v1isVi3paSkxNzcnO6zvG+ZdnZ2AwcOND5HT3QKLFdX1+zsbPb2ixcvXF1dORyOi4vLixcvtH2ys7Pbtm1baZS5ufnChQuFQmFV50VpZmZW1ceWT6FQ1IpMpZLysrPXPqCbyeVy1Wo19WXncrnUj96ZmZlRP0hgZmZG94NybVk53+dM6gNTo9EwDFMrBiaHw6F74EGj0ZiamtIdmCqVqgYOzNGjR48fPx4/vadry5YtAwYMYGu16hjspVS9wCopKXn69Cl70npoaGhcXNzIkSMJIUeOHOnevTshpHXr1lKpNCUl5YMPPhCLxRcuXPjpp59ozTcAAMC7imGYDRs2VPolFBhk+/bt1K959gZ6FVjbtm07evRoUlLStWvXbt26FR4eHhoaevXq1ZCQEHZeP/300+bNm0+YMMHS0nLnzp0XLlwghFhZWc2bN2/QoEGjRo06evTooEGDAgICqndpAAAAAGoAvQqspk2bWllZDRkyhJ309fUlhAQGBu7du5dtcXNzu3bt2t69e9VqdWpqqoeHB9seGRnZpk2bK1euREZGfvTRR9Uw/wAAAAA1jr4FVtOmTUs12tvbDxo0SDvp7Oz86aefln1sly5dunTpYswsAgAAANQu+H4XAAAAgDIUWAAAAACUocACAAAAoIzOdbAAAAAAdF2/ft3BwUH7ny5FRUVnz57Nycnx8vJq27Zt2ctQqVSqU6dOPXv2rH379j4+PmzjvXv3Hj16pO3TpUsX9uoVN27cSEtL69q1q5OTE3tXUlJSnTp1AgMDq33B9IMjWAAAAEDf9OnT9+/fz94+fPiwl5fXihUrzp07t3DhwsDAwPv37+t2lslkISEhixcvTkpKatu2bWxsLNu+cePGSZMmLf8H+/8u586dCw8Pz8/P79y5s0QiIYQUFBRMmTLFxcXlv13EN8ERLAAAAKhGGRkZw4YN++WXX0aMGMG2JCcnl7qM6qZNmwghJ0+e5HA4ffv2nTZtWv/+/dlr2YeFhS1evFi38+7du2fMmDF8+PCLFy+eOXOmV69eX3/99ezZs21tbf+rZaocjmABAABANfrll19atWqlra4IIc2bN/f29tbtc+fOnRYtWrAVVatWre7du3fr1i32rufPn//555/aSUIIj8djD2UplUoej3ft2rW0tDT272RqDhzBAgAAqCVOniT37lV4r6cn6dHj9aRcTn7/najVFfbv2ZPUq/d6Mi2NXLxYYWcrK1KqgomJIfn5hBDSoQMJCnrDXKelpTVr1uwNHQghnp6eR44c0fYnhGRlZTVs2JDL5d66devnn39OTExs1arV/v37TU1Nx4wZEx4efvfu3bt373bs2LFXr15r165Vq9V5eXnaU7LeOhRYAAAAtURmJklOrvBepfJfBZZCQVJTiUJRYf82bf5VYL148abwOnVIWBjR/f/pmzfJixeEEBIY+OYCS6VS8fn8N3QghEycOHHDhg2DBw9u2LDh4cOHbW1t2f/i+/bbb9m/9y4qKmrVqtXPP/88ffr0Zs2axcXF3b17d/78+TExMc2aNTMzM2vZsiV7avzevXtrwv9ko8ACAACoJSZMIBMm6NtZICBr1xoQ3r076d7dgP7/+5+eHf39/dPT09/cx87O7tq1a3FxcVKpdP/+/QEBAWy1xFZXhBCBQNCnT5+UlBR2sm7dunXr1s3Pz//xxx9Pnz4dFRU1c+bMMWPGdO/ePTk5uUWLFgYsSPVAgQUAAADVaMyYMe3atbt06VKrVq3YluzsbEKIs7OzbjeBQMCep7Vp0yZfX18/P79SOSkpKe3atdNtiYqKmjdvnkAgyM/Pd3R0JIQ4OTmJxeLqWxb9ocACAACAatSyZcsVK1Z06dJl9OjRgYGBGRkZ+/fvF4lEugVWQUHB1KlTP/jgg/v37+/atSsuLo79mq979+6tW7e2tbVNSEi4ffv2jh07tA9JSUm5e/fuunXrCCHdunWLjo42NTW9fPky2/LW4VeEAAAAQN/s2bM7d+7M3p45c2ZycrKPj092dnaDBg2uXLnSsGFD3c5WVlahoaF5eXleXl6pqakhISFs+5w5c8zMzPLz8wcOHJienq5bk925c0dbS40ePXrEiBGnT58+cOCAnZ3df7J8leCwJ5HVHPb29vfu3RMKhVV7OGezkgmv5Ew6QxUVFQkEgpqfKZFIrK2tKQaq1Wq5XG5paUkxU6lUqtVqc3NziplyuZzL5VZ6BqVBiouLzczMtN/9UyGRSKysrOieellbVs73OZP6wNRoNCUlJbViYHI4HFNTU4qZMpnM1NSU7sCUSqWWlpY1bWCylyEodaUoMJKlpeWrV68sLCxI9Qz2UvDmAQAAAFCGAgsAAACAMhRYAAAAAJShwAIAAACgDAUWAAAAAGUosAAAAAAow4VGAQAAapwVK1bUhD/Ue5eoVKr/8ulQYAEAANQsS5Ysyc/P121RKBR0Lyr2HmZ++eWXdC/29mYosAAAAGqW+fPnl2qpLVfWrS2Z/wGcgwUAAABAGQosAAAAAMpQYAEAAABQhgILAAAAgDIUWAAAAACUocACAAAAoAwFFgAAAABlKLAAAAAAKEOBBQAAAEAZCiwAAAAAylBgAQAAAFCGAgsAAACAMhRYAAAAAJSZ6Nlv06ZNv/zyC5fLnTJlypgxY0rdGxMTs3fvXt2W7du3m5mZ/fDDDxcuXGBbrKystm7davwcAwAAANRwehVYcXFxX3311Z49e9Rq9ZAhQ9zd3bt06aLboUWLFkKhkL29Y8eO9PR0MzMzQkhSUpKrq2vfvn0JIXw+n/bMAwAAANREehVY69evnzVrVvv27Qkhn3322fr160sVWD4+Pj4+PuztOXPmTJ06VXtXYGBgt27d6M0wAAAAQE2n1zlY169fb9myJXu7ZcuW169fr6jnlStX7t69O3ToUG3Lli1bevbs+dlnn2VmZho5rwAAAAC1gl5HsF6+fGlra8vetrOzy8nJqajnL7/8MnTo0Dp16rCTffr0sbKysrCwOHjwYIsWLdLS0tzc3N78XEVFRR988AGX+3fl17lz5zVr1ugzk/8wk0gkhvSvnFQq5XA4tSKTbqBarZbL5RqNhmKmUqlUq9UqlYpiplwu53K5dL+DLi4uViqVPB6PYqZUKmUYhu77XotWzvc5k26gRqMpKSmpFQOTw+GYmppSzJTJZKampnQHZnFxsUajwcBEpkHMzc1NTCqpoPQqsGxsbIqLi9nbEolEWz+VIpPJdu3adfDgQW3LyJEj2Rs9evS4cePGrl27Zs+e/ebnsrKyOnDggPYp7OzsrK2t9ZnJfygN7F85hmFqRSYhhG6mWq3m8/mWlpYUM9ntuLm5OcVMPp9PvcDicrlmZmZ0t+OEECsrK7qbidqycr7PmYT2wNRoNCYmJrViYFIvsHg8HvUCi8PhWFpaYmAikzq9Cixvb+979+6FhIQQQu7du+fl5VVut3379gmFwg4dOpR7r4uLS2FhYaXPxeVyvby8tKfMAwAAANQ6ep2DNXLkyA0bNsjlcplMFh0dPWrUKLb9m2++efjwobbbL7/8Eh4erv0coNFokpKS2Nvnz58/evRoqVPjAQAAAN5JehVYU6ZM8fDwcHd39/DwaNSo0dixY9n2NWvWPH36lL395MmTGzduaO8ihGg0muHDh9vY2Li4uHz00UfLli378MMPqS8AAAAAQE2j11eEZmZme/bsyc/P53A42rPdCSF5eXna2x4eHi9fvvxXtInJgwcPioqKZDKZk5MTrTkGAAAAqOH0vZI7IaSic9vfTCAQCASCKjwQAAAAoJbCfxECAAAAUIYCCwAAAIAyFFgAAAAAlKHAAgAAAKAMBRYAAAAAZSiwAAAAAChDgQUAAABAGQosAAAAAMpQYAEAAABQhgILAAAAgDIUWAAAAACUocACAAAAoAwFFgAAAABlKLAAAAAAKEOBBQAAAEAZCiwAAAAAylBgAQAAAFCGAgsAAACAMhRYAAAAAJShwAIAAACgDAUWAAAAAGUosAAAAAAoQ4EFAAAAQBkKLAAAAADKUGABAAAAUIYCCwAAAIAyFFgAAAAAlKHAAgAAAKAMBRYAAAAAZSiwAAAAAChDgQUAAABAGQosAAAAAMpQYAEAAABQhgILAAAAgDIUWAAAAACUmejZT6FQpKenOzk5ubq6lr23pKREJpNpJ21tbbncv0s3qVR69+5dLy8vOzs742cXAAAAoObT6wjWjRs3/Pz8wsPDg4ODIyIiynZYv369i4uL7z8ePnzItsfHx3t7e3/yySe+vr6bNm2iON8AAAAANZZeBdbcuXPHjx9/+fLl1NTUjRs3Xr9+vWyfsLCwvH/4+PgQQjQazdSpU3/44YfExMTjx4/PnDlTLBZTnn0AAACAmqfyAkssFsfHx0+cOJEQUrdu3d69e+/evbtsN41Gk5WVpVQqtS1Xrlx59erV0KFDCSHNmjVr0KDBoUOH6M05AAAAQA1V+TlYT5484fP5bm5u7KSPj09mZmbZbnv37j116lROTs7YsWPXrl3L5/MfP35cr149ExMT7QMfPXpU6dOp1erTp08LBAJ20tvb29fXV9+lAQAAAKgBKi+wpFKpmZmZdtLCwkIikZTqM3LkyM8++8zU1PTJkyfdu3dfvXr1vHnz9HlgWTKZbNWqVXw+n51s0aLFl19+qdei/M28qKjIkP6V02e2a0KmVCplGIZioFqtVigUarWaYqZSqVSr1bpHOo0nl8u5XK52naFCJpMpFAoej0cxUyqVajQaDodDMbO2rJzvcyb1ganRaORyea0YmBwOx9TUlGKmTCYzNTWlOzCLi4vVajUGJjINYm5uXulOp/ICy9nZuaioSKVSsceiXr165eLiUrYPe8PDwyM8PPzEiRPz5s1zdnbWPenq1atXjRs3rvTprK2tDx48KBQKK+1ZAaX26BdFtSKTw+FYW1tTDFSr1XK53NLSkmImux03NzenmGlqakq9wOLxeGZmZnS34xwOx8rKiu52nNSSlfN9zqQ+MDUaDZ/PrxUDk3qBZWJiQr3A4nK5lpaWGJjIpK7yc7A8PDwcHR0vXrzITl64cKF58+Zv6P/s2bM6deoQQpo0afL48eMXL14QQtRqdVJSUosWLWjMMwAAAECNVvkRLD6f/+mnn06bNm3lypUXLlzIzMwcPnw4ISQ5Ofmjjz568uQJISQqKiooKMjR0fHSpUsbNmw4evQoIaRu3bqDBw8eP378F198sXPnTnd39w4dOlT38gAAAAC8dXpdaHTBggUCgeD77793cXE5deoUe7hbKBT279+f7eDj43P48OH8/Px69eqdPn26ZcuWbHt0dPSyZcuWLl0aGBh49OhR6sdgAQAAAGogvQosHo83c+bMmTNn6jZ6e3uvW7eOvT1+/Pjx48eXfaCVldWiRYuMn0sAAACAWgT/RQgAAABAGQosAAAAAMpQYAEAAABQhgILAAAAgDIUWAAAAACUocACAAAAoAwFFgAAAABlKLAAAAAAKEOBBQAAAEAZCiwAAAAAylBgAQAAAFCGAgsAAACAMhRYAAAAAJShwAIAAACgDAUWAAAAAGUosAAAAAAoQ4EFAAAAQBkKLAAAAADKUGABAAAAUIYCCwAAAIAyFFgAAAAAlKHAAgAAAKAMBRYAAAAAZSiwAAAAAChDgQUAAABAGQosAAAAAMpQYAEAAABQhgILAAAAgDIUWAAAAACUocACgFrp0itsvgCg5sIWCgBqn1dyMvws/23PBQBAhVBgAUDtwzCEedvzAADwBiiwAAAAAChDgQUAAABAGQosAAAAAMpQYAEAAABQZqJnvxs3buzYsYPL5Y4ePbp+/fql7i0oKDhy5EhqaqqFhUXfvn1btGjBth86dCg9PZ29bW5uPn36dFrzDQAAAFBj6XUEKy0tLSQkxMrKis/nt2nT5u7du6U6LF68eOfOnQ4ODhqNpmvXrrt27WLb//jjj4SEBLFYLBaL8/PzKc87AAAAQI2k1xGsVatWhYeHR0VFEUJycnLWrFmzbt063Q6LFy82MzNjbwsEgg0bNgwfPpyd7N+//9SpU6nOMwAAAECNptcRrDNnznTv3p293b1799OnT5fqoK2uCCElJSXW1tbayXPnzi1fvnzfvn0qlcrouQUAAACoBfQ6gvX8+XNHR0f2tpOT0/PnzyvqmZmZuXr16kOHDrGTPj4+RUVFBQUFCxcuXLZs2dmzZ83Nzd/8XDKZbPr06dqKrXHjxpMnT9ZnJv/BKykpMaR/5UpKSvh8yteMrqZMExN9T6rTh1qtlsvlXC7NX0IolUq1Wk0xkBDCziTd2JKSEoZheDwe3Uwej8fhcOhm1paVk26mXM5hGFJbBjvdganRaEpKSmrFwORwOBqNhmJmSUmJRqOhPjC5XC4GJjINwufzK10P9Rr2fD5fe/xJpVKZmpqW2y0nJ6dPnz6RkZEdOnRgW5YsWcLe+Prrr5s0afL777+Hh4e/+bl4PF7Tpk2trKzYyYYNGxr4Emiovw18Pv/9zORyuRoN/deTy+XSzdRoNNQz2ReT7naczaS7Ha8VK1J1ZJqoCYej5vNpFi6kliy7RqNRq9W1YmByOBy6mSqVCgMTmTUhU59POHptnurWrZuVlcXefvr0ad26dcv2ycnJ6dKly8iRI+fOnVv2XjMzsxYtWmRmZlb6XKampuPGjRMKhfrMWHkof7ghhPB4PGTSwn6cpZvJ4/G4XC71TOrLzgbS3Y7Xije9OjJ5PEKIuubPZ3Vkcjic2jIw2Vmlm4mBicwam1mKXgeZ+/Xrt2fPHvb2nj17+vbty94+efIk+9tAsVj8f//3f4MHD16wYIH2UQzDaA/g5+fnnz17tnHjxjTnHQAAAKBG0usI1owZM9q1a9e3b1+VSnX//v3Nmzez7T169BCJRB9++GFUVNT169c5HE5cXBwhxNXV9fDhw0qlsm7duu3bt7eysjp58mT79u2HDh1ajYsCAAAAUDPoVWC5urqmpaWdOHGCy+V27drV0tKSbb948WJAQAAhZN68eePHj9f2Z0/SMjU1TU5Ovn79ulKpjIyMxOErAAAAeE/oe4qotbV1//79SzU2b96cveHp6enp6Vn2Ud7e3t7e3sbMHwAAAECtg/8iBAAAAKAMBVYlJEoy8DTlX4cCAADAuw0FViWkKnI9H68SAAAAGAClAwAAAABlKLAAAAAAKEOBBQAAAEAZCqy3IFtGolIp/4caAAAA1BwosN6CbBmTkF29f4EEAAAAbxEKLACodk+Laf6TLgBAzYcCCwCqXbOjZhrmbc8EAMB/CAUWAFQ7pYagvgKA9woKLEI7mEcAACAASURBVAAAAADKUGABAAAAUIYCCwAAAGqofAX59matvLARCiwAAACoobJlzN5HtfLCRiiwAAAAAChDgQUAQAghSg05m4NNIgDQga0JAAAhhNwrZOZc5b/tuQCoxdQM+flurTxfqjrUuBdijVQqGDiQ8CvYzPXrRz7//PVkWhqZNUv3flEWQ3b/c81oDods2EB8fF7fvWwZOXGiwucOCiJr1ryelEjIkCF2CtWebA35tbxKdM4c0qPH68l9+8iGDRWGm5mR2FhiovOCT5hAHj+usH9lS/ov7JI6Ob1uMXxJiUpVqheXYcw0GsLjUVxSE4bhMQzh6ryeVVjSf7+nfJGIw+EQTnnXCtdvSV+rzveU36MHmT379bThS1r2PbVUqwmPRwjNJX2dqWX02vvXqpncXRVczJ3GOKXynnoqyc9FfDLgEN1xaqF9PSktKUc7MEsxbu3lT5lCsrIq7F+Fcerm9rqF0ntqptFwOBwydy7FcWquVnN0X0yjt0jkxIlyBhGrJm2RSL9+5OOPX0/S2CIxGtIqW0NcuRSX1ENFtr3SkM06ew0a+9MK3yM9x2nv3mTGjAqfkU1imJp1/b8P69SJ27pVIBCUf3dAAKlX7/VkSQk5f57oLEL3P1Wi//vnRedySYcO/6rVMjNJZmaFz+3qSho2fD3JMOT8eXFByaRzqj1dy6tEW7Qgdeq8nszNJampFYZbWZG2bdmb1/OYkQnKNP908vJlhf0rW9J/4XJJhw4Sudza2vrvFsOXlJSUlOql0WiUSqWZmVmVl/Rv165pl1SlUmk0GlNT09f3Gr6kpd5T5Z07HA7HxKS890i/JX3tnyUtLi42MzPjicVVXtKypG5ulvXrc7SFoOFLWvY9LS4utrS0JKTqS/o3nff0daaWgUta9j0NjTp9rAePW26JVaVxmltC6u9R5I42NWZJS3koYSJvmu1c0PFfrQYuadn3VCaTWVhYEEJni0RKShiGUSgUZmZmpfsbMU6VSqUmJcWssLDC/oaPU7lGw+Fw/h7sNLZIhBC5XM7n87mtWtHaIhFCSkpKzMzMXg9Mo7dIJDOznEHEMmKcFhUVCeRyilskEhBQZGf3em9LY4skUZFRCarYUBOKW6QnUubLy+ptnXS28EZvkcj588VSafnvkZ7j1N+feHpW+IyEkBpYYNnb29+7d08oFFbt4ZzNSiac5kH+bBlpsk+RPcq08q56+7vAGkwzkxAikUheF1g0qNVquVxe/ipYVUqlUq1Wm5ubU8yUy+VcLpdf0VHPKvm7wCr3801VSSQSKysrTrlH2qqqqKiowk8jNSnT5BelfDyfR2/RXxdY9NwUM0OOK28NqekDU6PRlJSU1IqB+brAokQmk5mamtIdmFKp1NLS8v0cmNQz8xXE6w9F/liab/qdAqbvMeXdYZQHZnW8nqXgHCwAAAAAylBgAQAAAFCGAgsAAACAMhRYAAAA8B55LGHW3Kn2qyigwAIAAID3yEMJ+TOr2usfFFgAAAAAlKHAAgAAAKAMBRYAAAAAZSiwAAAAAChDgQUAAABAGQosAAAAAMpQYAEA1CYZhcyRpzT/OA8AqgMKLACA2uRKLtn7mOa/HQNAdUCBBQAAAEAZCiwAgOqi0pCnxW97JgDgbdCrwMrPzx82bJijo2ODBg0OHz5cbp9ly5Z5eHjUrVs3MjKSYRi28eHDh6GhoUKhsFWrVpcvX6Y21wAAtcH5bGbqJf7bngsAeAv0KrDmzp2rUqkyMzNXrVo1cuTIFy9elOoQFxf3008/JSQkXLp06cCBA7/++ivbPnbs2CZNmjx9+jQ8PPyjjz5SKpWUZx8AaGv5p9kr+dueiXeFmiEa5m3PBAC8DZUXWMXFxTt37vzmm28EAkHPnj07dOiwffv2Un02bdo0ZcoUf39/d3f3mTNnbt68mRBy586dpKSkr7/+2tLSctKkSRYWFkePHq2WhQAAegqVHLkaRQEAgFEqL7AeP36sUCgaNWrETgYHB9++fbtUn9u3bwcHB5fqcOfOHV9fX4FA8IYHAgAAALx7TCrtkZeXZ2VlxeH8fdkVW1vbmzdvlu2jLaRsbGzy8vI0Gk1eXp61tbW2j62tbW5ubqVPV1hYaG9vr50cMmTIli1bKn2UVl1zvkQi0b9/pdRKjpDPo5vJVXIEPI5EoqCYmfyK81M6Z0t7mvP551OS8Jz5riXNzN8ymOfF5IsmKoqZ398g9ubkYz+aX2vNv8J0cJH1dqcYSSacI5PrF7dyoHlwaOBJ7qpWUm9rmpl2fBNNiUJC9ZstV3O+VCLh0rt4k0rFsac9MDkKjg3tgWmi4lhxOXTn01TNMWcYuvO54z7zWMqJaEJzPn+4yViZkImBNOdzQTLTylHdvx7FSDL5AvnYv7itI80Vfuhp3tLmUn8BzcxuIl7Mh1J7M5qZLY/yE/9PYkLv124KFXEwNaG7whM5sTWhPNhNlMYOTHNzcxOTSiqoygssoVAokUgYhmFrrIKCAgcHh7J9CgsL2duFhYVCoZDL5QqFwqKiIm2fgoKCgICASp/Oxsbm3r17QqGw0p7lut2/yNpaULXHlsuakEu9KGc2siZ/daOcqShgXqkU1tZmFDNlXFW+Wk03U0KURYyGbmYRozBlONbWNE8lzlfLizk8a+vKB4j+xGq5nMe3tqb5090chVzFN7W2pnnZycT/K9J+XqLlVj/KmdaEXOlNeRA1sCai7pQzO1qTZkKJ7kdN4w301/TyKLG0tKSYKSXKQoaxtjalmCkhCoZQHpiFjKKYw6U+MEu41TAwTSgPzGclCo4Zn27mw2KlhZW5Gb2rqlkTktKH8iAKtCYJoZQz21mTvXUoZ5ZV+Srl4eHB5/O13+7dvHnT39+/VJ+AgADtYa0bN26wHfz9/R88eCCVSrUP1KfAAgAAAKjtKi+wrKyshg0btnjxYrlcfu7cuYSEhFGjRhFCMjIyxowZw/YZN27cxo0bnz59mpub++OPP44fP54QEhQU1LRp0+XLl6vV6h07dojF4t69e1frwgAAAADUBHodFF25cmVRUZGDg8OYMWO2bNni7u5OCJFIJMnJyWyHgQMHjh49ulmzZoGBgV27dmULLELIb7/9lpCQYGtru2zZsv3795uZ0fxiCHQF2pIBHpq3PRcAAABAiD7nYBFCHBwcDh06VKqxadOmume7L1y4cOHChaX6+Pv7nzt3zshZBH3Us+Z87Kt+23MBAAAAhOCvcgAAAN5PvtYMj+ZJ8/AvKLAAAADeR4k95RSv0QCl4KUFAAAAoAwFFkAtZs4j5vSuYQMAALTQvFwbAPzHjnRWONTBj3MB3n0fOmvqmOGEqdoER7AAajGKl2AGgJrs51ZKG5pXxYdqhwILAAAAgDJ8RQgV8rfhvKL6z8QAUDOZ8Qifg8EOQBMKLKhQK0cSbIOrwwO8+8b5E7kSBRYATSiwAADed3wu4WJvAEAVzsECAAD6LHjEqjYUbRzC4dL+cd4nAWp/W/zi731XG1Z/AACobeY2YqgXLtXh2w9UfvaUf543zFMtMKUbCbUPCiyo9bgcgr/TAqhpeBzCoT0wR3lrPG0pf/HiK2AssCeEaoDVCmq9mQ0JH991A7wH2jkxpqb4OAW1AwosqPWEpgy3NnwVMd5P3cweXxsAALwXalyB5a1Wm1y7Rmxsyr/b3Z04O7+eVChIWpru/bziYmJp+fcEh0OCgwlP51rXz56R588rfG6hkHh7/6vl+nWiVP4rU1dAABEIXk/m55P79ysMNzcnDRv+qyUjgxQUVNi/siX9F3ZJdVVpSUunajRchYKYm1Nc0pDnqny5hiTr1BlVWNJ/v6ecR484XC4xKW9l1m9JX6vO97SvnZ2lhc7MGL6kZd/T1ysnvSUtZ4U3eu3lpaaWP4gItXFaYX9D3lOuWk1atfpXk9HjlKt9PWktqXZglmLc2su5f5+UlFTYvwZskQghXLmcw+eT+vUpjlOuTEbMzV9/nWn0Fok8f17hXqMmbZGIu/u/ZpLGFoloNyBUl7T060ljf1rhe6Tnkrq5EReXCp+RTWKYmnXtk1gzsz5BQSbl7iwJIcOHkzlzXk9eu0bCw4nOIqjVap72deFyyc6dxM/vdf9vviFxcRU+d3Aw+eWX15MSCenRg8jl/8rU9b//kd69X0/u3k2++67CcCsrcuKEtggoKioShIe/aahUtqT/wuWSnTslLi7W1tZ/t1RpSUv1YhiGYRgul2vMkhJCyLBh2iV9nWnEkpZ6T5nDhwkhnHJP99BvSV/7Z0n/eiDzteP7/bWvyktalnzAANPIyNfzafiSln1PX6+cVV3Sv+m8p+Ws8AYuadn3VD1uHI9bwfe4VR2nRUVFAoHAmCUtS21uzjt1ypglLfueajSav1d4Slukf2XqMmKcKpVK7ogRvIcPK+xv+DiVe3hwOBxTU1NC6GyRCCEajYbD4XAWLqS1RSJlX0yjt0gkLq7CvYYR47SoqEhw9CjFLRIZPrxo8mSBtqyhsUUi2g0IvS0SKbtRMnqLRMLD1SpV+e+Rnks6ZAj54osKn5HF1DBCofDVq1dVfvjUqVMpzgzDMDKZbNasWXQzc3Nzv/zyS7qZmZmZK1asoJuZnJwcHR1NN/P48eMxMTF0M/fu3RsfH083c/PmzZcvX6abuXLlynv37tHN/Oqrr3Jycuhmzp49u7i4mG7mp59+qtFoKAbK5fIZM2ZQDGQY5tWrVwsWLKCb+fDhw2XLltHNTElJ2bBhA93MkydP/vHHH3QzDxw4cOzYMbqZW7ZsSUpKopu5evXqO3fu0M385ptvXrx4QTdz7ty5EomEbuZnn32mVqspBioUiunTp1MMZBhGLBZHRETQzXz8+PHSpUvpZpb1rp0bvH79erqBBQUFv//+O93MrKysAwcO0M3MyMg4duwY3cwbN24kJCTQzUxOTj5//jzdzIsXL165coVu5smTJ9PecLS8Sv7666979+7RzYyNjX369CndzJ07d4rFYrqZGzZs0Gho/itAYWHh9u3bKQYSQp4/f75//366mffv3//zzz/pZt66dYv6wLx69Sr1gZmYmHjp0iW6mWfOnLl27RrdzPj4+Dt37tDNPHTo0OPHj+lm/vHHH69evaKbuWnTJuUbvrYznFQq3bZtG8VAQkh2dvbevXvpZj548ODIkSN0M8t61wosAAAAgLcOBRYAAAAAZSiwAAAAAGir7pO8DGVe9rfHAAAAADWGPr9+q3GXaQAAAACo7fAVIQAAAABlKLAAAAAAKEOBBQAAAEAZCiwAAAAAylBgAQAAAFCGAgsAAACAsnetwCouLn7bs1A5tVpN9++fCCEKhUKlUtHNrEVqxfteUlJSKzK11Gq1XC6vvnxaquNFqBVrVDXRaDTVul7RUtMGVEWPNWZd+s+W0ci9UrmZxuyVqmMvyTDMf7xBe3cKrAsXLvj6+rq7u/v5+V28eNH4wJcvX44bN65JkyZCoTAvL8/4QEJIcnJy+/btBQKBnZ1d+/bt09PTjc9MSEioV6+enZ2dra1tp06dMjMzjc/UGjFihFAoLCwsND5q586dQh1Xr141PpMQsmPHDg8PDycnJ1tbWyp/3lm/fn3d+Zw2bZrxmZcuXQoODvb29hYKhRMnTqRSCp87d65hw4ZeXl5ubm779u2rcs6CBQtCQkIcHBxK/c9xVFSUnZ2ds7PzkCFDDN1DLF269MMPP3Ryctq6dau28c6dO2FhYYGBgZ6enlWYz6+//rp9+/aOjo4xMTHaxjVr1vj5+QmFQoFA8Mknnxi0RS4uLp44cWKzZs2EQmFGRoa2PTIy0sbGxs3NTSAQTJs2Ta1W659569atESNGBAQE+Pv7l703NTXV0dExIiJC/0BCyJMnT8aMGdOwYUOhUKi7gGFhYdq1tFGjRgZlnjlzZuDAgV5eXt27d9dtl8lkEydOtLa2dnBw8PPzM2hFTUxMHDx4sI+PT0hIiLbx2rVrwn87fPiw/pl79+7t1auXm5vblClTdNuXLVvm5OTk6+vr5eVl6N8Ab9u2LTQ01MXFZcGCBdpGhmEiIyOdnJw8PDy6deuWnZ1tUGZ4eLijo6O9vb2Li8v69eu17fHx8R4eHu7u7g0aNDD0P6pnzJjh4uLi4ODg4OCwYsUKbfu0adNat25tb29/+vRpgwIJIVOmTHFycnJwcHB2dl6zZg3bmJSU1LZtW3av1LFjR4P+kD4vL69fv34CgcDe3j4wMFD7v+bHjx/38PBg90qdO3d+8OCB/plXrlwJCQnR7iVv376te69CoWjdunXjxo31DySE3L17t2vXrlZWVvb29s2bN798+TLbXmqvlJKSYlBspd6RAkutVoeFhUVFReXl5S1YsCAsLMygzWK5GIYJDg5etGiRWCymdTlWpVI5b948sVicn58fHBw8ZswY4zMDAwPPnTsnlUrz8vI8PT0///xz4zNZMTEx2dnZtBZfLpe3adPm/j+aNGlifKZIJJo1a9bu3bslEsmjR4+aNm1qfGZSUhI7h3fu3OHxeKGhocZnTpgwYfjw4c+fP8/MzDxz5syvv/5qZKBEIhk8eHBkZOSLFy8OHz48fvz4ly9fVi3K2dk5MjLS3t5eoVBoG+Pj47dt23b79u3s7Oy8vLyVK1calGlvbz979mxPT0/dz4sMw7Rv337OnDn5+flVmE9HR8f58+c7OTnpZtrY2MTGxkql0jt37pw6dUq7z9CHRqMJDAxcuXKlWCzW3VyMGDEiKytLLBanp6fHxcUZ9GYxDNOxY8eZM2eWXUalUjl58uTAwECZTKZ/IJvZokWLqKgosVis2y6RSJYsWcKuq+fPnzcok8Ph9O3bd/To0UVFRbrtU6ZMefbs2ZMnTyQSyaFDh7hcw3YQPXv2nDBhgu7nsUaNGmmH/K5duxQKRadOnfQPNDU1HTVqVGhoqG6Jf/ny5cWLF1+4cCErK2v9+vWjRo2SSqX6Z1pYWISHh4eEhOi+Eb///vvu3btv3ryZk5MTFBQ0c+ZM/QMJIUFBQdeuXZNKpQcOHJgzZ86lS5cIITKZLCwsbO3atXl5eeHh4WPHjjUo09vb+9KlSxKJ5MSJE0uXLo2Pj2fb3d3dFy5cyOfzq3CAJyAgICUlRSKRxMXFRUZGsquNUqmMiorKz88Xi8WBgYEff/yx/oFKpbJ3795Pnz6VSqURERFDhgxh1/ygoKDz58+zeyUPDw+DPqYqlcr58+eLxWKxWNy4ceNSe8klS5ZYWVkVFBToH0gIUSgUkyZNys3NLSws7NOnz6BBg9idWqm9kqF1W+Wq7T9v/lMnTpxwcXFRq9UMw6jVahcXl4SEBCrJOTk5hJDc3FwqaboSExMtLCzoZu7YsaNp06ZUol6+fBkUFMQeZ8rPzzc+cMuWLf379zc+R1doaOjy5cvpZmrFxv5/e3ce1cS1xwF8QFCDQdBGKZsCRZCUigrKVpeWoC0WkFJAKEhjK/RgexAQIYgcKu4LyIFaCBRC0coiGgqyeKGKHCkWCMh+ZFMU2yACsjRAUub9cd+bk4O2TTLT93w99/PX3Jvka0IyuXfu/CbyX3/9dbFYTD6KwWDcvn0bbru7ux89epRkYE1NjaamJtHcsmXL+fPnyQRaWFhcvnyZaPr4+HA4HLj9ww8/GBkZKZC5devWb775Zk7n3bt3Fy9erPDztLKy+u677156U0hICJvNljdwdnYWw7DOzs6X3urm5hYXFydvZnV1NYPBmNMZFxcXHR39+eefBwcHyxuI4zhcV5iZmSF6nJ2deTyeAlGEzMxMa2trojkwMKCqqvro0SMymXl5eebm5i+9KSAgQIE3CMfxqKgoPz8/ollUVPTGG2/AbTiZU+A5BwQEhISEEE1/f/+IiAi43d7ePn/+/OfPnyvwVHEct7S0zMjIwHE8Pz9/9erVsHNqaopOpzc2NiqW6eDgEB8fL92jp6cHAFAsDbKxsUlNTZ3TWVVVpaGhoVigRCKZP3++QCCY05+dnb1+/XrFMmtqatTU1IjmvXv3LC0ti4qK9PX1FQvEcRwup8FB7e8YlaT9Q1awuru7TU1N4fGWsrKyqamp9Jr/q4nP52/evJmSqImJCS6Xe+7cuZMnT8bGxlKS+eWXX3I4nOXLl1OSBlVWVmpoaBgbG8fFxZFfYsQwrKWlZXJycs2aNdra2mw2W97Dmj+XkZHBZrNVVFTIR8XExHA4nJycnDNnznR0dMh7LPuihQsXTk9PE2tO4+Pj1H7gu7u7mUwm3GYymQ8ePHjFK/ympqbKysqo2qFaWlq4XO7Bgwf7+vr27NlDPrCzszM/P1/6nBQlwsLCNDQ0rK2ty8vLyae1t7fr6uomJibq6+ubmJikp6eTzySIRKK8vDxK/piOjo46OjphYWFXrlxhs9mBgYF6enokMxcuXDgxMQG3JyYmZmZm+vv7Fcjp7u7u7Oy0s7OD22ZmZrB/wYIFRkZGPT09CmQODAzU19dv2rRJgcf+kb6+vtbWVumTuVBhYaHCO1FJSYmmpubq1athc3x8nMvlnj179vTp0wqPSoWFhVu2bIHbEolk7969SUlJqqqqiqVBfD5/7dq1GhoasEmMSkePHqVkVJJGweDxKnj+/PmiRYuIprq6+pzl9FdNSUlJWloaJbViGIZNT083NDQ8ffpUIpGoqamRDywuLh4cHPT19X3y5An5NGjTpk319fUrVqxoamry9vam0WgHDhwgE4jj+ODgYGFhIQCARqO5u7tzOBzpAggyhEJhaWnpqVOnKEkzMTEZGxvLy8t78uTJmjVr1NXVSQaam5sbGRmFhobu27fvxo0bra2txHyIEqOjo8QORafTZ2dnx8bGli5dSuE/QSEcx/ft26enp0fJOXcMw4RCYV1dXVtbm7a29rx580imzc7OfvbZZwkJCdT+T/ZRUVGGhoZqamo5OTlubm4CgYAY2xQjFAofPHigoqLS19d37969rVu3MplMOFcgLz8/f/ny5S+O6ApQUVGxt7cvLi7u7+/v6OigpErSy8vLzc1t27ZtBgYGUVFRKioqCowgY2Njnp6e4eHhpqamGEWjkkgk2rVrF5vNtrKykvexf2RiYsLT0zM4OPjNN9+U7i8sLMzOzr57964CmT09PQEBAampqTQaDfYQo9Lvv/+u2Kh0/fr19PT02tpa2Dx16tTbb79ta2tL5nCitrb2yJEjRMKmTZsaGhr09fUbGxt9fHxoNFpYWJjC4S/6h6xgMRgM6RP/IyMj1C69UOvmzZuffPJJUVHRSythFfDaa6+lpqZevXr1+PHjvr6+OLmSKRzHAwMDvb29Kysrq6urMQy7devW0NAQySdpbGxsampKo9FsbW0jIiL4fD7JQCUlJQaDsXfvXi0trcWLFwcHB5eVlZHMJPB4PFtbW5IjFjQxMeHh4QHfoNraWhzHya8yqqqqlpeXi8ViWDTj5eWlr69P/qkSli1bRiwHjo6OqqqqampqUphPrZCQkPb29oKCAnlrhv4Ii8VKS0urqalZunQp+TcrIyNDSUlpdna2oqLi8ePH/f39sEaHJBsbGy0tLXV19b1799rb25eUlJAMZDAYGIZxOBwVFRVLS0snJycKd6hvv/12z549SkpK5KOys7OLi4sFAkF+fv7NmzfDw8ObmppIZr7zzjtZWVnp6emRkZEBAQEYhsm7Q01OTu7YscPGxiYmJgb2kB+VpqenP/zww5UrV547d06uB/6J3377zdnZed26dXFxcdL9N27cCAgIuH79uqGhobyZ/f39LBYrNjZ2586dRCeDwYBfenFxcR9//LG8o1JlZSWbzS4uLjY2NsYw7JdffomPj9+8eXNFRUVjY+PU1FRFRYW8l1gKBAJXV9eLFy9u2LAB9hgbG5uYmNBoNDs7u4MHD5Ifleb4h6xgMZnMlpYWsVgMS/8oP6CnUE1Nza5du3Jzc21tbSkPNzMzGx4enpmZWbBgAZkce3t7WFMJ60B5PN6KFSvg9y8lZmZmKDn1Zm5uTpy6kkgklGRCWVlZERERlEQNDg6Oj48T5ZMWFhbEMRkZurq6qampGIZJJBJYrE0+k8BkMgUCASx3FQgEZmZmVM1dKBcVFVVVVVVZWUl+XfBFZmZm9fX1JEM0NTW1tbW5XC6GYR0dHcrKylevXt24cSMVT/DfKNmhmEymsrLy37FD9fb2/vTTT5cvX6YqzczMDJ4nWr58uba2dm9vL/kLXFxdXV1dXTEMKy0tZTAYck2wRCKRi4uLsbFxcnIyMYlkMpmJiYk4jispKY2Pj/f09BBnDGUhFos9PT3V1NR4PB5Ve9/MzIyHh8eKFStSUlKkJ7vV1dV+fn75+fnEzEN2AwMD7777blBQUGBg4EvvAEclsVg8f/58GTPv3Lnj4+OTl5dnY2MDe8RisYODw6VLlzAM+/XXXycnJ7lcroWFheyrws3NzU5OTklJSU5OTi+9g1gspnAE+be/r7zrv2zt2rWRkZFPnjyJjIxct24dJZkVFRXwGuCCgoKKigrygQ0NDerq6pGRkeA/pKtWFXPlypUff/zx4cOHP//88/bt2z/44APyz5Pw+PFjjKIi96ysrNra2ocPH/L5fC0trRfLnxVQUFCwatWq1tbW3t5eW1tboi6bpOrqajqdPj4+TkmaRCIxNDQ8cODA4OBgU1PTqlWr5tSrKqasrKyjo6OlpWX37t3W1tYKF+MLBAIAgJGR0aFDhwAAw8PDOI7X1dVpampWVVXdv3/f3Nw8OTlZrszm5mYAgIWFRXBwMABAKBTiOC4SiQAAycnJampqAIA7d+7IldnY2AgAMDExiYiIAADA606OHDmioaGRm5sL96YXC2z/XFVVFTyQyMzMBADAv2FCQkJTUxP8oGpra2dmZsoeODk5CQBISEjQ0NAAANTU1My5gwJF7hKJBAAAL2YsLS29desWjuMTExNJSUltbW3d3d3Hjh2j0+m9vb2yZw4NDQEAwsPDV69ecQOyRgAABE5JREFUDQBoamqC/Tt37gwMDBwcHCwtLaXT6c3NzbJnjoyMAAAOHz5sYGAAAGhoaCBu4nA4Li4uskcR+vv7AQDe3t4sFgsAcP/+fRzH4WQaAPDs2bP09PRFixbJVeTe3d0NANixY4e7uzsAoK+vD8fx4eHhoqKiBw8elJSUGBgYcLlc2QNnZ2cdHR3feuut8vJy+DmEmXDHP3HixMDAQFBQkIODg1yv/aOPPjI2Ni4pKYGZ8LXjOH737l0AAIPBOHXqFABArq+p999/n8lklpWVwcyenh4YuGjRoujoaGJUkkgkMgYODw+bmJi4uLgQj3369CmO43BxEY5Kjo6Ocr379fX1dDqdw+EQmXO+3MrKyuQtcu/u7l62bFlgYCCROTk5ieM4j8eTHpVSUlLkiv1LSjhFP0DwP9fb27t///62tjZzc/Pz588rsM75om3bthF/n3nz5pFfMC8sLExOTpbuuXbtGp1OJ5OZl5d34cKFR48eLVmyxMHBgcPhUHg2Z2hoyNvbm8/nSxcTKObMmTO5ubkjIyO6urq7d+/+9NNPKTlfkJSUlJaWpqys7OzsHB0dTXLpDrpw4cLIyAiFJckdHR0xMTEtLS10Ot3NzS0yMpJ8Zc+JEycuXrwokUhYLNbRo0eXLFmiWE5kZGRDQwPRPHv2rIWFBYZhly5dOnfunEgk8vLyiomJkesY+tixY7du3SKasbGx9vb2QqHQ19eX6NTV1eXxeLJnHj58WHrl7+TJk5aWliEhIa2trUTnhg0bjh8/LnsmcVU5BHfG/fv33759e3x8XFdXl81my3VFwsDAgPRV7itXrpxTKp6YmKiqqhoUFCR7JlwdIZqLFy8uKCgQiUT+/v6tra04jpuamh46dEiutYe6urqoqCiiaWdn99VXX2EY9uzZs7CwsDt37ujo6HA4nPfee0/2zJaWltDQUKK5fv16ooTR39/fz8+PxWLJngZdu3ZNuqrSw8MDnr/Lzs5OTU0VCoVGRkYcDkeun37g8XhwIQSCP6EyNDTk6+vb1dXFYDC++OILPz8/2QNxHJ/zYy579uzx9vbGMKy9vT00NLSrq8vKyiohIUFHR0f2WFdXV+kfpyBee1BQkPRPVXG5XNkHu+3bt8PLZiE/P7/du3cXFBSkpKRI3624uFjGL9Kurq45H+Zjx45t3LgxJycnJSUFjkosFovD4RBF5X+Jz+d//fXXc3qkB6D6+vr4+Pjvv/9exkAMw27fvj3nlGhmZqaent7p06dzc3NHR0d1dXX9/f2pOotN+OdMsBAEQRAEQV4Rr2hdBYIgCIIgyP8vNMFCEARBEAShGJpgIQiCIAiCUAxNsBAEQRAEQSiGJlgIgiAIgiAUQxMsBEEQBEEQiqEJFoIgCIIgCMXQBAtBEARBEIRiaIKFIAiCIAhCMTTBQhAEQRAEoRiaYCEIgiAIglAMTbAQBEEQBEEohiZYCIIgCIIgFPsXU0RWCUHkC0gAAAAASUVORK5CYII=", - "image/svg+xml": [ - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n" - ], - "text/html": [ - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n" + "text/plain": [ + "Dict{String, Float64} with 5 entries:\n", + " \"HVariance\" => 0.838712\n", + " \"LjungBoxSquared\" => 5.26399e-8\n", + " \"JarqueBera\" => 1.27511e-11\n", + " \"ARCH\" => 2.25626e-5\n", + " \"LjungBox\" => 1.79559e-6" ] }, "metadata": {}, @@ -3254,11 +2568,7 @@ } ], "source": [ - "acf_plot_param_1 = plot_acf(cs_residuals_param_1, \"Conditional Score\")\n", - "acf_plot_param_2 = plot_acf(cs_residuals_param_2, \"Conditional Score\")\n", - "\n", - "plot(acf_plot_param_1, acf_plot_param_2, layout = (2,1), size=(800,600),\n", - " plot_title = \"Conditional Score Residuals ACF\", title=[\"Param 1\" \"Param 2\"])" + "UnobservedComponentsGAS.get_residuals_diagnosis_pvalues(fitted_model; lags = 13, type = \"std\")" ] } ], diff --git a/src/residuals_diagnostics.jl b/src/residuals_diagnostics.jl index 0f5aae4..559821c 100644 --- a/src/residuals_diagnostics.jl +++ b/src/residuals_diagnostics.jl @@ -4,7 +4,8 @@ # - type::String="q": The type of residuals to retrieve ("q" for quantile, "std" for standardized, "cs" for conditional score) # Returns: # - The specified residuals as a vector or matrix -function get_residuals(fitted_model::Output; type::String="q") +function get_residuals(output::Output; type::String="q") + fitted_model = deepcopy(output) if type == "q" return fitted_model.residuals["q_residuals"][2:end] elseif type == "std" @@ -16,21 +17,20 @@ end # Function to plot residuals from a fitted model # Parameters: -# - output::Output: The model output object containing residuals +# - fitted_model::Output: The model output object containing residuals # - type::String="q": The type of residuals to plot ("q" for quantile, "std" for standardized, "cs" for conditional score) # Returns: # - A plot of the specified residuals -function plot_residuals(output::Output; type::String="q") - fitted_model = deepcopy(output) - if type == "std" - name = "Standardized" - resid = fitted_model.residuals["std_residuals"][2:end] - elseif type == "q" +function plot_residuals(fitted_model::Output; type::String="q") + + resid = get_residuals(fitted_model; type=type) + + if type == "q" name = "Quantile" - resid = fitted_model.residuals["q_residuals"][2:end] + elseif type == "std" + name = "Standardized" else name = "Conditional Score" - resid = fitted_model.residuals["cs_residuals"][2:end, :] end if type == "cs" @@ -54,14 +54,14 @@ end # Function to calculate the autocorrelation function (ACF) of residuals # Parameters: -# - output::Output: The model output object containing residuals +# - fitted_model::Output: The model output object containing residuals # - lags::Int=25: The number of lags to include in the ACF calculation # - type::String="q": The type of residuals to use ("q" for quantile, "std" for standardized) # - squared::Bool=false: Whether to square the residuals before calculating ACF # Returns: # - A vector of ACF values -function get_acf(output::Output; lags::Int=25, type::String="q", squared::Bool=false) - fitted_model = deepcopy(output) +function get_acf_residuals(fitted_model::Output; lags::Int=25, type::String="q", squared::Bool=false) + resid = get_residuals(fitted_model; type=type) squared == true ? resid = resid.^2 : nothing @@ -78,7 +78,7 @@ end # Returns: # - A plot of the ACF of the specified residuals function plot_acf_residuals(output::Output; lags::Int=25, type::String="q", squared::Bool=false) - acf_values = get_acf(output; lags = lags, type = type, squared = squared) + acf_values = get_acf_residuals(output; lags = lags, type = type, squared = squared) resid = get_residuals(output; type=type) if type == "q" @@ -169,7 +169,7 @@ end # - type::String="q": The type of residuals to test ("q" for quantile, "std" for standardized) # Returns: # - A dictionary with the F-statistic and p-value of the H test -function test_H(output::Output; type::String="q") +function Htest(output::Output; type::String="q") resid = get_residuals(output; type=type) T = length(resid) @@ -215,7 +215,7 @@ function get_residuals_diagnosis_pvalues(output::Output; lags::Int=25, type::Str jb = jarquebera(output; type = type) lb = ljungbox(output; type = type, squared = false, lags = lags) lb2 = ljungbox(output; type = type, squared = true, lags = lags) - H = test_H(output; type = type) + H = Htest(output; type = type) arch = archtest(output; type = type, lags = lags) return Dict("JarqueBera" => jb["pvalue"], "HVariance" => H["pvalue"], diff --git a/test/test_residuals_diagnostics.jl b/test/test_residuals_diagnostics.jl index b2dffed..55d0b01 100644 --- a/test/test_residuals_diagnostics.jl +++ b/test/test_residuals_diagnostics.jl @@ -42,8 +42,8 @@ end @testset "get_acf" begin - acf_q = UnobservedComponentsGAS.get_acf(fitted_model; lags=25, type="q") - acf_std = UnobservedComponentsGAS.get_acf(fitted_model; lags=25, type="std") + acf_q = UnobservedComponentsGAS.get_acf_residuals(fitted_model; lags=25, type="q") + acf_std = UnobservedComponentsGAS.get_acf_residuals(fitted_model; lags=25, type="std") @test length(acf_q) == 26 @test length(acf_std) == 26 end @@ -77,9 +77,9 @@ @test haskey(lb_std, "stat") && haskey(lb_std, "pvalue") end - @testset "test_H" begin - H_q = UnobservedComponentsGAS.test_H(fitted_model; type="q") - H_std = UnobservedComponentsGAS.test_H(fitted_model; type="std") + @testset "Htest" begin + H_q = UnobservedComponentsGAS.Htest(fitted_model; type="q") + H_std = UnobservedComponentsGAS.Htest(fitted_model; type="std") @test haskey(H_q, "stat") && haskey(H_q, "pvalue") @test haskey(H_std, "stat") && haskey(H_std, "pvalue") end From 1de5c12af06f60eaaab4a0a64c4c218de4ece71b Mon Sep 17 00:00:00 2001 From: Matheus Nogueira Date: Mon, 22 Jul 2024 16:27:13 -0300 Subject: [PATCH 3/4] update unit tests with @testset --- test/test_components_dynamics.jl | 198 ++++---- test/test_distributions.jl | 283 +++++------ test/test_fit_forecast_lognormal.jl | 197 ++++---- test/test_fit_forecast_normal.jl | 220 ++++---- test/test_fit_forecast_t.jl | 202 ++++---- test/test_initialization.jl | 750 ++++++++++++++++------------ test/test_optimization.jl | 80 +-- test/test_residuals_diagnostics.jl | 14 - 8 files changed, 1036 insertions(+), 908 deletions(-) diff --git a/test/test_components_dynamics.jl b/test/test_components_dynamics.jl index 837b429..0ee1386 100644 --- a/test/test_components_dynamics.jl +++ b/test/test_components_dynamics.jl @@ -1,113 +1,117 @@ @testset "Components Dynamics" begin - @test(UnobservedComponentsGAS.has_random_walk(["random walk"])) - @test(!UnobservedComponentsGAS.has_random_walk(["random walk slope"])) - @test(UnobservedComponentsGAS.has_random_walk_slope(["random walk slope"])) - @test(!UnobservedComponentsGAS.has_random_walk_slope(["random walk"])) - @test(UnobservedComponentsGAS.has_ar1_level(["ar(1)",""])) - @test(!UnobservedComponentsGAS.has_ar1_level([""])) - @test(UnobservedComponentsGAS.has_seasonality(["deterministic 12"])) - @test(!UnobservedComponentsGAS.has_seasonality("")) - @test(UnobservedComponentsGAS.has_AR(1)) - @test(!UnobservedComponentsGAS.has_AR(missing)) + @testset "has_dynamic" begin + @test(UnobservedComponentsGAS.has_random_walk(["random walk"])) + @test(!UnobservedComponentsGAS.has_random_walk(["random walk slope"])) + @test(UnobservedComponentsGAS.has_random_walk_slope(["random walk slope"])) + @test(!UnobservedComponentsGAS.has_random_walk_slope(["random walk"])) + @test(UnobservedComponentsGAS.has_ar1_level(["ar(1)",""])) + @test(!UnobservedComponentsGAS.has_ar1_level([""])) + @test(UnobservedComponentsGAS.has_seasonality(["deterministic 12"])) + @test(!UnobservedComponentsGAS.has_seasonality("")) + @test(UnobservedComponentsGAS.has_AR(1)) + @test(!UnobservedComponentsGAS.has_AR(missing)) - @test(UnobservedComponentsGAS.has_random_walk(["random walk", ""], 1)) - @test(UnobservedComponentsGAS.has_random_walk(["", "random walk"], 2)) - @test(UnobservedComponentsGAS.has_random_walk_slope(["random walk slope",""], 1)) - @test(UnobservedComponentsGAS.has_random_walk_slope(["","random walk slope"], 2)) - @test(UnobservedComponentsGAS.has_ar1_level(["ar(1)",""], 1)) - @test(UnobservedComponentsGAS.has_ar1_level(["","ar(1)"], 2)) - @test(UnobservedComponentsGAS.has_seasonality(["deterministic 12", ""], 1)) - @test(!UnobservedComponentsGAS.has_seasonality(["deterministic 12",""], 2)) - @test(UnobservedComponentsGAS.has_AR(1, 1)) - @test(!UnobservedComponentsGAS.has_AR([1,missing], 2)) + @test(UnobservedComponentsGAS.has_random_walk(["random walk", ""], 1)) + @test(UnobservedComponentsGAS.has_random_walk(["", "random walk"], 2)) + @test(UnobservedComponentsGAS.has_random_walk_slope(["random walk slope",""], 1)) + @test(UnobservedComponentsGAS.has_random_walk_slope(["","random walk slope"], 2)) + @test(UnobservedComponentsGAS.has_ar1_level(["ar(1)",""], 1)) + @test(UnobservedComponentsGAS.has_ar1_level(["","ar(1)"], 2)) + @test(UnobservedComponentsGAS.has_seasonality(["deterministic 12", ""], 1)) + @test(!UnobservedComponentsGAS.has_seasonality(["deterministic 12",""], 2)) + @test(UnobservedComponentsGAS.has_AR(1, 1)) + @test(!UnobservedComponentsGAS.has_AR([1,missing], 2)) - @test(isequal(UnobservedComponentsGAS.get_AR_order([2,0]), [[1, 2], [nothing]])) - @test(isequal(UnobservedComponentsGAS.get_AR_order([missing, missing]), [[nothing], [nothing]])) + @test(isequal(UnobservedComponentsGAS.get_AR_order([2,0]), [[1, 2], [nothing]])) + @test(isequal(UnobservedComponentsGAS.get_AR_order([missing, missing]), [[nothing], [nothing]])) + end - T = 100 - s = [zeros(T), zeros(T)] + @testset "Number of variables and constraints" begin + T = 100 + s = [zeros(T), zeros(T)] - model = JuMP.Model(Ipopt.Optimizer) - @test(num_variables(model) == 0) - - # Test number of variables and constraints of AR - order = [2, 1] - number_of_variables_ar = (T + maximum(order) + 1) * sum(.!iszero.(order)) - number_of_constraints_ar = (T - maximum(order) + 1 ) * sum(.!iszero.(order)) + maximum(order) - minimum(order) - UnobservedComponentsGAS.add_AR!(model, s, T, order) - @test(num_variables(model) == number_of_variables_ar) - @test(num_constraints(model; count_variable_in_set_constraints=true) == number_of_constraints_ar) + model = JuMP.Model(Ipopt.Optimizer) + @test(num_variables(model) == 0) + + # Test number of variables and constraints of AR + order = [2, 1] + number_of_variables_ar = (T + maximum(order) + 1) * sum(.!iszero.(order)) + number_of_constraints_ar = (T - maximum(order) + 1 ) * sum(.!iszero.(order)) + maximum(order) - minimum(order) + UnobservedComponentsGAS.add_AR!(model, s, T, order) + @test(num_variables(model) == number_of_variables_ar) + @test(num_constraints(model; count_variable_in_set_constraints=true) == number_of_constraints_ar) - # Test number of variables and constraints of RW - model = JuMP.Model(Ipopt.Optimizer) - rw = [true, false] - number_of_variables_rw = (T + 1)*rw[1] + (T + 1)*rw[2] - number_of_constraints_rw = (T - 1 + rw[1])*rw[1] + (T - 1 + rw[2])*rw[2] - UnobservedComponentsGAS.add_random_walk!(model, s, T, Dict(1=>rw[1], 2=>rw[2])) #ta dando um bounds error - @test(num_variables(model) == number_of_variables_rw) - @test(num_constraints(model; count_variable_in_set_constraints=true) == number_of_constraints_rw) + # Test number of variables and constraints of RW + model = JuMP.Model(Ipopt.Optimizer) + rw = [true, false] + number_of_variables_rw = (T + 1)*rw[1] + (T + 1)*rw[2] + number_of_constraints_rw = (T - 1 + rw[1])*rw[1] + (T - 1 + rw[2])*rw[2] + UnobservedComponentsGAS.add_random_walk!(model, s, T, Dict(1=>rw[1], 2=>rw[2])) #ta dando um bounds error + @test(num_variables(model) == number_of_variables_rw) + @test(num_constraints(model; count_variable_in_set_constraints=true) == number_of_constraints_rw) - # Test number of variables and constraints of RWS - model = JuMP.Model(Ipopt.Optimizer) - rws = [true, false] - number_of_variables_rws = (2*T + 2) * sum(rws) - number_of_constraints_rws = (2*(T-1) + 2) * sum(rws) - UnobservedComponentsGAS.add_random_walk_slope!(model, s, T, Dict(1=>rws[1], 2=>rws[2])) #ta dando um bounds error - @test(num_variables(model) == number_of_variables_rws) - @test(num_constraints(model; count_variable_in_set_constraints=true) == number_of_constraints_rws) + # Test number of variables and constraints of RWS + model = JuMP.Model(Ipopt.Optimizer) + rws = [true, false] + number_of_variables_rws = (2*T + 2) * sum(rws) + number_of_constraints_rws = (2*(T-1) + 2) * sum(rws) + UnobservedComponentsGAS.add_random_walk_slope!(model, s, T, Dict(1=>rws[1], 2=>rws[2])) #ta dando um bounds error + @test(num_variables(model) == number_of_variables_rws) + @test(num_constraints(model; count_variable_in_set_constraints=true) == number_of_constraints_rws) - # Test number of variables and constraints of Seasonality - seasonal_periods = 12 - seasonality = ["deterministic 12"] - seasonality_dict, stochastic = UnobservedComponentsGAS.get_seasonality_dict_and_stochastic(seasonality) + # Test number of variables and constraints of Seasonality + seasonal_periods = 12 + seasonality = ["deterministic 12"] + seasonality_dict, stochastic = UnobservedComponentsGAS.get_seasonality_dict_and_stochastic(seasonality) - num_harmonic, seasonal_period = UnobservedComponentsGAS.get_num_harmonic_and_seasonal_period(seasonality_dict) - @test((num_harmonic, seasonal_period) == ([Int64(floor(seasonal_periods))/2], [seasonal_periods])) - - # Deterministic - model = JuMP.Model(Ipopt.Optimizer) - idx_params = findall(i -> i != false, seasonality) - unique_num_harmonic = unique(num_harmonic)[minimum(idx_params)] - number_of_variables_sd = 2*unique_num_harmonic - number_of_constraints_sd = 0 - UnobservedComponentsGAS.add_trigonometric_seasonality!(model, s, T, seasonality) - @test(num_variables(model) == number_of_variables_sd) - @test(num_constraints(model; count_variable_in_set_constraints=true) == number_of_constraints_sd) + num_harmonic, seasonal_period = UnobservedComponentsGAS.get_num_harmonic_and_seasonal_period(seasonality_dict) + @test((num_harmonic, seasonal_period) == ([Int64(floor(seasonal_periods))/2], [seasonal_periods])) + + # Deterministic + model = JuMP.Model(Ipopt.Optimizer) + idx_params = findall(i -> i != false, seasonality) + unique_num_harmonic = unique(num_harmonic)[minimum(idx_params)] + number_of_variables_sd = 2*unique_num_harmonic + number_of_constraints_sd = 0 + UnobservedComponentsGAS.add_trigonometric_seasonality!(model, s, T, seasonality) + @test(num_variables(model) == number_of_variables_sd) + @test(num_constraints(model; count_variable_in_set_constraints=true) == number_of_constraints_sd) - # and stochastic - model = JuMP.Model(Ipopt.Optimizer) - number_of_variables_ss = 1 + 12*T - number_of_constraints_ss = 1 + (T-1)*unique_num_harmonic*2 - seasonality = ["stochastic 12"] - UnobservedComponentsGAS.add_trigonometric_seasonality!(model, s, T, seasonality) - @test(num_variables(model) == number_of_variables_ss) - @test(num_constraints(model; count_variable_in_set_constraints=true) == number_of_constraints_ss) - - # Test number of variables and constraints from include_components! with Deterministic Seasonality - dist = UnobservedComponentsGAS.NormalDistribution() - gas_model = UnobservedComponentsGAS.GASModel(dist, [true, true], 1.0, ["random walk slope", ""], ["deterministic 12", ""], order) + # and stochastic + model = JuMP.Model(Ipopt.Optimizer) + number_of_variables_ss = 1 + 12*T + number_of_constraints_ss = 1 + (T-1)*unique_num_harmonic*2 + seasonality = ["stochastic 12"] + UnobservedComponentsGAS.add_trigonometric_seasonality!(model, s, T, seasonality) + @test(num_variables(model) == number_of_variables_ss) + @test(num_constraints(model; count_variable_in_set_constraints=true) == number_of_constraints_ss) + + # Test number of variables and constraints from include_components! with Deterministic Seasonality + dist = UnobservedComponentsGAS.NormalDistribution() + gas_model = UnobservedComponentsGAS.GASModel(dist, [true, true], 1.0, ["random walk slope", ""], ["deterministic 12", ""], order) - model = JuMP.Model(Ipopt.Optimizer) - UnobservedComponentsGAS.include_components!(model, s, gas_model, T) - @test(num_variables(model) == number_of_variables_ar + - number_of_variables_rws + - number_of_variables_sd) - @test(num_constraints(model; count_variable_in_set_constraints=true) == number_of_constraints_ar + - number_of_constraints_rws + - number_of_constraints_sd) - - # Test number of variables and constraints from include_components! with stochastic Seasonality - gas_model = UnobservedComponentsGAS.GASModel(dist, [true, true], 1.0, ["random walk slope", ""], ["stochastic 12", ""], [2, 1]) + model = JuMP.Model(Ipopt.Optimizer) + UnobservedComponentsGAS.include_components!(model, s, gas_model, T) + @test(num_variables(model) == number_of_variables_ar + + number_of_variables_rws + + number_of_variables_sd) + @test(num_constraints(model; count_variable_in_set_constraints=true) == number_of_constraints_ar + + number_of_constraints_rws + + number_of_constraints_sd) + + # Test number of variables and constraints from include_components! with stochastic Seasonality + gas_model = UnobservedComponentsGAS.GASModel(dist, [true, true], 1.0, ["random walk slope", ""], ["stochastic 12", ""], [2, 1]) - model = JuMP.Model(Ipopt.Optimizer) - UnobservedComponentsGAS.include_components!(model, s, gas_model, T) - @test(num_variables(model) == number_of_variables_ar + - number_of_variables_rws + - number_of_variables_ss) - @test(num_constraints(model; count_variable_in_set_constraints=true) == number_of_constraints_ar + - number_of_constraints_rws + - number_of_constraints_ss) + model = JuMP.Model(Ipopt.Optimizer) + UnobservedComponentsGAS.include_components!(model, s, gas_model, T) + @test(num_variables(model) == number_of_variables_ar + + number_of_variables_rws + + number_of_variables_ss) + @test(num_constraints(model; count_variable_in_set_constraints=true) == number_of_constraints_ar + + number_of_constraints_rws + + number_of_constraints_ss) + end end \ No newline at end of file diff --git a/test/test_distributions.jl b/test/test_distributions.jl index 0921a6e..a79c3ea 100644 --- a/test/test_distributions.jl +++ b/test/test_distributions.jl @@ -8,146 +8,149 @@ X = [2*y y/2 rand(T)] - @info(" --- Test distributions/common") - μ = 1. - σ² = 2. - ν = 10 - - "Test NormalDistribution scaled_score" - scaled_score_normal_0 = UnobservedComponentsGAS.scaled_score(μ, σ², y[1], 0.0, - UnobservedComponentsGAS.get_dist_code(UnobservedComponentsGAS.NormalDistribution()), 1) - scaled_score_normal_05 = UnobservedComponentsGAS.scaled_score(μ, σ², y[1], 0.5, - UnobservedComponentsGAS.get_dist_code(UnobservedComponentsGAS.NormalDistribution()), 1) - scaled_score_normal_1 = UnobservedComponentsGAS.scaled_score(μ, σ², y[1], 1.0, - UnobservedComponentsGAS.get_dist_code(UnobservedComponentsGAS.NormalDistribution()), 1) - - @test(round(scaled_score_normal_0, digits = 3) == -0.21) - @test(round(scaled_score_normal_05, digits = 3) == -0.297) - @test(round(scaled_score_normal_1, digits = 3) == -0.42) - - "Test LogNormalDistribution scaled_score" - scaled_score_lognormal_0 = UnobservedComponentsGAS.scaled_score(μ, σ², y[1], 0.0, - UnobservedComponentsGAS.get_dist_code(UnobservedComponentsGAS.LogNormalDistribution()), 1) - scaled_score_lognormal_05 = UnobservedComponentsGAS.scaled_score(μ, σ², y[1], 0.5, - UnobservedComponentsGAS.get_dist_code(UnobservedComponentsGAS.LogNormalDistribution()), 1) - scaled_score_lognormal_1 = UnobservedComponentsGAS.scaled_score(μ, σ², y[1], 1.0, - UnobservedComponentsGAS.get_dist_code(UnobservedComponentsGAS.LogNormalDistribution()), 1) - - @test(round(scaled_score_lognormal_0, digits = 3) == -0.21) - @test(round(scaled_score_lognormal_05, digits = 3) == -0.297) - @test(round(scaled_score_lognormal_1, digits = 3) == -0.42) - - "Test tLocationScaleDistribution scaled_score" - scaled_score_t_0 = UnobservedComponentsGAS.scaled_score(μ, σ², ν, y[1], 0.0, - UnobservedComponentsGAS.get_dist_code(UnobservedComponentsGAS.tLocationScaleDistribution()), 1) - scaled_score_t_05 = UnobservedComponentsGAS.scaled_score(μ, σ², ν, y[1], 0.5, - UnobservedComponentsGAS.get_dist_code(UnobservedComponentsGAS.tLocationScaleDistribution()), 1) - scaled_score_t_1 = UnobservedComponentsGAS.scaled_score(μ, σ², ν, y[1], 1.0, - UnobservedComponentsGAS.get_dist_code(UnobservedComponentsGAS.tLocationScaleDistribution()), 1) - - @test(round(scaled_score_t_0, digits = 3) == -0.229) - @test(round(scaled_score_t_05, digits = 3) == -0.352) - @test(round(scaled_score_t_1, digits = 3) == -0.541) - - @info(" --- Test distributions/normal") - dist = UnobservedComponentsGAS.NormalDistribution() - seasonal_period = 12 - μ = 0. - σ² = 1. - score_normal_1 = UnobservedComponentsGAS.score_normal(μ, σ² ,0) - score_normal_2 = UnobservedComponentsGAS.score_normal(μ, σ² ,1) - fisher_normal = UnobservedComponentsGAS.fisher_information_normal(μ, σ²) - logpdf_normal_1 = UnobservedComponentsGAS.logpdf_normal(μ, σ², 0) - logpdf_normal_2 = UnobservedComponentsGAS.logpdf_normal(μ, σ², 1) - cdf_normal_1 = UnobservedComponentsGAS.cdf_normal([μ, σ²], 0) - cdf_normal_2 = UnobservedComponentsGAS.cdf_normal([μ, σ²], 1) - initial_params_normal_1 = UnobservedComponentsGAS.get_initial_params(y, [true, false], dist, Dict{Int64, Union{Bool, Int64}}(1=>12)) - initial_params_normal_2 = UnobservedComponentsGAS.get_initial_params(y, [false, false], dist, Dict{Int64, Union{Bool, Int64}}(1=>12)) - seasonal_variances = UnobservedComponentsGAS.get_seasonal_var(y,seasonal_period, dist) - - - @test(size(score_normal_1) == (2,)) - @test(all(score_normal_1 .== [0., -0.5])) - @test(all(score_normal_2 .== [1., -0.0])) - @test(all(fisher_normal .== [1. 0.; 0. 0.5])) - @test(round(logpdf_normal_1, digits = 3) == -0.919) - @test(round(logpdf_normal_2, digits = 3) == -1.419) - @test(round(cdf_normal_1, digits = 3) == 0.5) - @test(round(cdf_normal_2, digits = 3) == 0.841) - @test(UnobservedComponentsGAS.get_dist_code(dist) == 1) - @test(UnobservedComponentsGAS.get_num_params(dist) == 2) - @test(UnobservedComponentsGAS.check_positive_constrainst(dist) == [false, true]) - @test(initial_params_normal_1[1] == y) - @test(initial_params_normal_1[2] == var(diff(y))) - @test(initial_params_normal_2[1] == mean(y)) - @test(all(seasonal_variances .> 0)) - - @info(" --- Test distributions/t_location_scale") - dist = UnobservedComponentsGAS.tLocationScaleDistribution() - seasonal_period = 12 - μ = 0. - σ² = 1. - ν = 1 - score_tlocationscale_1 = UnobservedComponentsGAS.score_tlocationscale(μ, σ², ν ,0) - score_tlocationscale_2 = UnobservedComponentsGAS.score_tlocationscale(μ, σ², ν ,1) - fisher_tlocationscale = UnobservedComponentsGAS.fisher_information_tlocationscale(μ, σ², ν) - logpdf_tlocationscale_1 = UnobservedComponentsGAS.logpdf_tlocationscale(μ, σ², ν, 0) - logpdf_tlocationscale_2 = UnobservedComponentsGAS.logpdf_tlocationscale(μ, σ², ν, 1) - cdf_tlocationscale_1 = UnobservedComponentsGAS.cdf_tlocationscale([μ, σ², ν], 0) - cdf_tlocationscale_2 = UnobservedComponentsGAS.cdf_tlocationscale([μ, σ², ν], 1) - initial_params_tlocationscale_1 = UnobservedComponentsGAS.get_initial_params(y, [true, false, false], dist, Dict{Int64, Union{Bool, Int64}}(1=>12)) - initial_params_tlocationscale_2 = UnobservedComponentsGAS.get_initial_params(y, [false, false, true], dist, Dict{Int64, Union{Bool, Int64}}(1=>12)) - seasonal_variances = UnobservedComponentsGAS.get_seasonal_var(y,seasonal_period, dist) - - gas_model = UnobservedComponentsGAS.GASModel(dist, [true, false, false], 0.0, ["random walk", "", ""], "deterministic 12", missing) - - gas_model_2 = deepcopy(gas_model) - best_model_no_explanatory, best_ν_no_explanatory = UnobservedComponentsGAS.find_first_model_for_local_search(gas_model, y) - - # Problema quando tiramos o pacote do André para selecionar as explicativas - # best_model_explanatory, best_ν_explanatory = UnobservedComponentsGAS.find_first_model_for_local_search(gas_model, y, X) - - @test(size(score_tlocationscale_1) == (2,)) - @test(all(score_tlocationscale_1 .== [0., -0.5])) - @test(all(score_tlocationscale_2 .== [1., -0.0])) - @test(all(fisher_tlocationscale .== [0.5 0.; 0. 0.125])) - @test(round(logpdf_tlocationscale_1, digits = 3) == -1.145) - @test(round(logpdf_tlocationscale_2, digits = 3) == -1.838) - @test(round(cdf_tlocationscale_1, digits = 3) == 0.5) - @test(round(cdf_tlocationscale_2, digits = 3) == 0.75) - @test(UnobservedComponentsGAS.get_dist_code(dist) == 2) - @test(UnobservedComponentsGAS.get_num_params(dist) == 3) - @test(UnobservedComponentsGAS.check_positive_constrainst(dist) == [false, true, true]) - @test(initial_params_tlocationscale_1[1] == y) - @test(initial_params_tlocationscale_1[2] == var(diff(y))) - @test(initial_params_tlocationscale_1[3] == T-1) - @test(initial_params_tlocationscale_2[1] == mean(y)) - @test(initial_params_tlocationscale_2[3] == (y.^2) ./ (ones(T) * var(diff(y)))) - @test(all(seasonal_variances .> 0)) - @test(all(best_ν_no_explanatory .== best_model_no_explanatory.fitted_params["param_3"])) - - - @info(" --- Test distributions/log_normal") - dist = UnobservedComponentsGAS.LogNormalDistribution() - param_1_exp = zeros(T) - param_1_log = ones(T) - param_2 = ones(T) - fitted_params_exp = Dict("param_1" => param_1_exp, - "param_2" => param_2) - fitted_params_log = Dict("param_1" => param_1_log, - "param_2" => param_2) - + @testset " --- Test distributions/common" begin + μ = 1. + σ² = 2. + ν = 10 + + "Test NormalDistribution scaled_score" + scaled_score_normal_0 = UnobservedComponentsGAS.scaled_score(μ, σ², y[1], 0.0, + UnobservedComponentsGAS.get_dist_code(UnobservedComponentsGAS.NormalDistribution()), 1) + scaled_score_normal_05 = UnobservedComponentsGAS.scaled_score(μ, σ², y[1], 0.5, + UnobservedComponentsGAS.get_dist_code(UnobservedComponentsGAS.NormalDistribution()), 1) + scaled_score_normal_1 = UnobservedComponentsGAS.scaled_score(μ, σ², y[1], 1.0, + UnobservedComponentsGAS.get_dist_code(UnobservedComponentsGAS.NormalDistribution()), 1) + + @test(round(scaled_score_normal_0, digits = 3) == -0.21) + @test(round(scaled_score_normal_05, digits = 3) == -0.297) + @test(round(scaled_score_normal_1, digits = 3) == -0.42) + + "Test LogNormalDistribution scaled_score" + scaled_score_lognormal_0 = UnobservedComponentsGAS.scaled_score(μ, σ², y[1], 0.0, + UnobservedComponentsGAS.get_dist_code(UnobservedComponentsGAS.LogNormalDistribution()), 1) + scaled_score_lognormal_05 = UnobservedComponentsGAS.scaled_score(μ, σ², y[1], 0.5, + UnobservedComponentsGAS.get_dist_code(UnobservedComponentsGAS.LogNormalDistribution()), 1) + scaled_score_lognormal_1 = UnobservedComponentsGAS.scaled_score(μ, σ², y[1], 1.0, + UnobservedComponentsGAS.get_dist_code(UnobservedComponentsGAS.LogNormalDistribution()), 1) + + @test(round(scaled_score_lognormal_0, digits = 3) == -0.21) + @test(round(scaled_score_lognormal_05, digits = 3) == -0.297) + @test(round(scaled_score_lognormal_1, digits = 3) == -0.42) + + "Test tLocationScaleDistribution scaled_score" + scaled_score_t_0 = UnobservedComponentsGAS.scaled_score(μ, σ², ν, y[1], 0.0, + UnobservedComponentsGAS.get_dist_code(UnobservedComponentsGAS.tLocationScaleDistribution()), 1) + scaled_score_t_05 = UnobservedComponentsGAS.scaled_score(μ, σ², ν, y[1], 0.5, + UnobservedComponentsGAS.get_dist_code(UnobservedComponentsGAS.tLocationScaleDistribution()), 1) + scaled_score_t_1 = UnobservedComponentsGAS.scaled_score(μ, σ², ν, y[1], 1.0, + UnobservedComponentsGAS.get_dist_code(UnobservedComponentsGAS.tLocationScaleDistribution()), 1) + + @test(round(scaled_score_t_0, digits = 3) == -0.229) + @test(round(scaled_score_t_05, digits = 3) == -0.352) + @test(round(scaled_score_t_1, digits = 3) == -0.541) + end + + @testset " --- Test distributions/normal" begin + dist = UnobservedComponentsGAS.NormalDistribution() + seasonal_period = 12 + μ = 0. + σ² = 1. + score_normal_1 = UnobservedComponentsGAS.score_normal(μ, σ² ,0) + score_normal_2 = UnobservedComponentsGAS.score_normal(μ, σ² ,1) + fisher_normal = UnobservedComponentsGAS.fisher_information_normal(μ, σ²) + logpdf_normal_1 = UnobservedComponentsGAS.logpdf_normal(μ, σ², 0) + logpdf_normal_2 = UnobservedComponentsGAS.logpdf_normal(μ, σ², 1) + cdf_normal_1 = UnobservedComponentsGAS.cdf_normal([μ, σ²], 0) + cdf_normal_2 = UnobservedComponentsGAS.cdf_normal([μ, σ²], 1) + initial_params_normal_1 = UnobservedComponentsGAS.get_initial_params(y, [true, false], dist, Dict{Int64, Union{Bool, Int64}}(1=>12)) + initial_params_normal_2 = UnobservedComponentsGAS.get_initial_params(y, [false, false], dist, Dict{Int64, Union{Bool, Int64}}(1=>12)) + seasonal_variances = UnobservedComponentsGAS.get_seasonal_var(y,seasonal_period, dist) + + + @test(size(score_normal_1) == (2,)) + @test(all(score_normal_1 .== [0., -0.5])) + @test(all(score_normal_2 .== [1., -0.0])) + @test(all(fisher_normal .== [1. 0.; 0. 0.5])) + @test(round(logpdf_normal_1, digits = 3) == -0.919) + @test(round(logpdf_normal_2, digits = 3) == -1.419) + @test(round(cdf_normal_1, digits = 3) == 0.5) + @test(round(cdf_normal_2, digits = 3) == 0.841) + @test(UnobservedComponentsGAS.get_dist_code(dist) == 1) + @test(UnobservedComponentsGAS.get_num_params(dist) == 2) + @test(UnobservedComponentsGAS.check_positive_constrainst(dist) == [false, true]) + @test(initial_params_normal_1[1] == y) + @test(initial_params_normal_1[2] == var(diff(y))) + @test(initial_params_normal_2[1] == mean(y)) + @test(all(seasonal_variances .> 0)) + end + + @testset " --- Test distributions/t_location_scale" begin + dist = UnobservedComponentsGAS.tLocationScaleDistribution() + seasonal_period = 12 + μ = 0. + σ² = 1. + ν = 1 + score_tlocationscale_1 = UnobservedComponentsGAS.score_tlocationscale(μ, σ², ν ,0) + score_tlocationscale_2 = UnobservedComponentsGAS.score_tlocationscale(μ, σ², ν ,1) + fisher_tlocationscale = UnobservedComponentsGAS.fisher_information_tlocationscale(μ, σ², ν) + logpdf_tlocationscale_1 = UnobservedComponentsGAS.logpdf_tlocationscale(μ, σ², ν, 0) + logpdf_tlocationscale_2 = UnobservedComponentsGAS.logpdf_tlocationscale(μ, σ², ν, 1) + cdf_tlocationscale_1 = UnobservedComponentsGAS.cdf_tlocationscale([μ, σ², ν], 0) + cdf_tlocationscale_2 = UnobservedComponentsGAS.cdf_tlocationscale([μ, σ², ν], 1) + initial_params_tlocationscale_1 = UnobservedComponentsGAS.get_initial_params(y, [true, false, false], dist, Dict{Int64, Union{Bool, Int64}}(1=>12)) + initial_params_tlocationscale_2 = UnobservedComponentsGAS.get_initial_params(y, [false, false, true], dist, Dict{Int64, Union{Bool, Int64}}(1=>12)) + seasonal_variances = UnobservedComponentsGAS.get_seasonal_var(y,seasonal_period, dist) + + gas_model = UnobservedComponentsGAS.GASModel(dist, [true, false, false], 0.0, ["random walk", "", ""], "deterministic 12", missing) + + gas_model_2 = deepcopy(gas_model) + best_model_no_explanatory, best_ν_no_explanatory = UnobservedComponentsGAS.find_first_model_for_local_search(gas_model, y) + + # Problema quando tiramos o pacote do André para selecionar as explicativas + # best_model_explanatory, best_ν_explanatory = UnobservedComponentsGAS.find_first_model_for_local_search(gas_model, y, X) + + @test(size(score_tlocationscale_1) == (2,)) + @test(all(score_tlocationscale_1 .== [0., -0.5])) + @test(all(score_tlocationscale_2 .== [1., -0.0])) + @test(all(fisher_tlocationscale .== [0.5 0.; 0. 0.125])) + @test(round(logpdf_tlocationscale_1, digits = 3) == -1.145) + @test(round(logpdf_tlocationscale_2, digits = 3) == -1.838) + @test(round(cdf_tlocationscale_1, digits = 3) == 0.5) + @test(round(cdf_tlocationscale_2, digits = 3) == 0.75) + @test(UnobservedComponentsGAS.get_dist_code(dist) == 2) + @test(UnobservedComponentsGAS.get_num_params(dist) == 3) + @test(UnobservedComponentsGAS.check_positive_constrainst(dist) == [false, true, true]) + @test(initial_params_tlocationscale_1[1] == y) + @test(initial_params_tlocationscale_1[2] == var(diff(y))) + @test(initial_params_tlocationscale_1[3] == T-1) + @test(initial_params_tlocationscale_2[1] == mean(y)) + @test(initial_params_tlocationscale_2[3] == (y.^2) ./ (ones(T) * var(diff(y)))) + @test(all(seasonal_variances .> 0)) + @test(all(best_ν_no_explanatory .== best_model_no_explanatory.fitted_params["param_3"])) + end + + @testset " --- Test distributions/log_normal" begin + dist = UnobservedComponentsGAS.LogNormalDistribution() + param_1_exp = zeros(T) + param_1_log = ones(T) + param_2 = ones(T) + fitted_params_exp = Dict("param_1" => param_1_exp, + "param_2" => param_2) + fitted_params_log = Dict("param_1" => param_1_log, + "param_2" => param_2) - new_fit_in_sample_exp, new_fitted_params_exp = UnobservedComponentsGAS.convert_to_exp_scale(y, fitted_params_exp) - new_fitted_params_log = UnobservedComponentsGAS.convert_to_log_scale(fitted_params_log) - - @test(all(new_fit_in_sample_exp .> 0 )) - @test(all(new_fit_in_sample_exp .== exp.(y .+ param_2./2))) - @test(all(round.(new_fitted_params_exp["param_1"], digits = 3) .== round.(exp.(param_1_exp + param_2./2), digits=3))) - @test(all(round.(new_fitted_params_exp["param_2"], digits = 3) .== round.(exp.(2*param_1_exp .+ param_2 ) .* (exp.(param_2) .- 1), digits=3))) - @test(all(round.(new_fitted_params_log["param_1"], digits = 3) .== round.(log.(param_1_log) .- 0.5 .* log.(1 .+ param_2./(param_1_log.^2)), digits=3))) - @test(all(round.(new_fitted_params_log["param_2"], digits = 3) .== round.(log.(1 .+ param_2./(param_1_log.^2)), digits=3))) - @test(UnobservedComponentsGAS.get_dist_code(dist) == 1) - @test(UnobservedComponentsGAS.get_num_params(dist) == 2) + + new_fit_in_sample_exp, new_fitted_params_exp = UnobservedComponentsGAS.convert_to_exp_scale(y, fitted_params_exp) + new_fitted_params_log = UnobservedComponentsGAS.convert_to_log_scale(fitted_params_log) + + @test(all(new_fit_in_sample_exp .> 0 )) + @test(all(new_fit_in_sample_exp .== exp.(y .+ param_2./2))) + @test(all(round.(new_fitted_params_exp["param_1"], digits = 3) .== round.(exp.(param_1_exp + param_2./2), digits=3))) + @test(all(round.(new_fitted_params_exp["param_2"], digits = 3) .== round.(exp.(2*param_1_exp .+ param_2 ) .* (exp.(param_2) .- 1), digits=3))) + @test(all(round.(new_fitted_params_log["param_1"], digits = 3) .== round.(log.(param_1_log) .- 0.5 .* log.(1 .+ param_2./(param_1_log.^2)), digits=3))) + @test(all(round.(new_fitted_params_log["param_2"], digits = 3) .== round.(log.(1 .+ param_2./(param_1_log.^2)), digits=3))) + @test(UnobservedComponentsGAS.get_dist_code(dist) == 1) + @test(UnobservedComponentsGAS.get_num_params(dist) == 2) + end end \ No newline at end of file diff --git a/test/test_fit_forecast_lognormal.jl b/test/test_fit_forecast_lognormal.jl index 771101e..559b03e 100644 --- a/test/test_fit_forecast_lognormal.jl +++ b/test/test_fit_forecast_lognormal.jl @@ -50,114 +50,119 @@ gas_model_lognormal_X = deepcopy(gas_model_lognormal) gas_model_lognormal_X_2params = deepcopy(gas_model_lognormal_2params) - @info(" --- Testing create_model functions") - # Create model with no explanatory series - model_lognormal, parameters_lognormal, initial_values_lognormal = UnobservedComponentsGAS.create_model(gas_model_lognormal, y, missing) - model_lognormal_2params, parameters_lognormal_2params, initial_values_lognormal_2params = UnobservedComponentsGAS.create_model(gas_model_lognormal_2params, y, missing) - - model_lognormal_X, parameters_lognormal_X, initial_values_lognormal_X = UnobservedComponentsGAS.create_model(gas_model_lognormal_X, y, X, missing); - model_lognormal_X_2params, parameters_lognormal_X_2params, initial_values_lognormal_X_2params = UnobservedComponentsGAS.create_model(gas_model_lognormal_X_2params, y, X, missing); - - @test(size(parameters_lognormal) == (T,2)) - @test(size(parameters_lognormal_2params) == (T,2)) - @test(typeof(model_lognormal) == JuMP.Model) - @test(typeof(model_lognormal_2params) == JuMP.Model) - @test(test_initial_values_components(initial_values_lognormal, rw, rws, ar, seasonality)) - @test(test_initial_values_components(initial_values_lognormal_2params, rw, rws, ar, seasonality)) - - @test(size(parameters_lognormal_X) == (T,2)) - @test(size(parameters_lognormal_X_2params) == (T,2)) - @test(typeof(model_lognormal_X) == JuMP.Model) - @test(typeof(model_lognormal_X_2params) == JuMP.Model) - @test(test_initial_values_components(initial_values_lognormal_X, rw, rws, ar, seasonality)) - @test(test_initial_values_components(initial_values_lognormal_X_2params, rw, rws, ar, seasonality)) - - @info(" --- Testing fit functions") - fitted_model_lognormal = UnobservedComponentsGAS.fit(gas_model_lognormal, y; tol = 5e-2) - fitted_model_lognormal_2params = UnobservedComponentsGAS.fit(gas_model_lognormal_2params, y; tol = 5e-2) - fitted_model_lognormal_X = UnobservedComponentsGAS.fit(gas_model_lognormal_X, y, X) - fitted_model_lognormal_X_2params = UnobservedComponentsGAS.fit(gas_model_lognormal_X_2params, y, X) - - # "Test if termination_status is correct" - possible_status = ["LOCALLY_SOLVED", "TIME_LIMIT"] - @test(fitted_model_lognormal.model_status in possible_status) - @test(fitted_model_lognormal_2params.model_status in possible_status) - @test(fitted_model_lognormal_X.model_status in possible_status) - # "Test if selected_variables is missing " - @test(ismissing(fitted_model_lognormal.selected_variables)) - @test(ismissing(fitted_model_lognormal_2params.selected_variables)) - # "Test if fitted_params has the right keys -> order may be a problem" - @test(all(keys(fitted_model_lognormal.fitted_params) .== ["param_2","param_1"])) - @test(all(keys(fitted_model_lognormal_2params.fitted_params) .== ["param_2","param_1"])) - - # "Test if all time varying and fixed params are time varying and fixed" - @test(!all(y->y==fitted_model_lognormal.fitted_params["param_1"][1],fitted_model_lognormal.fitted_params["param_1"])) - #@test(all(y->y==fitted_model_lognormal.fitted_params["param_2"][1],fitted_model_lognormal.fitted_params["param_2"])) - @test(!all(y->y==fitted_model_lognormal_2params.fitted_params["param_1"][1],fitted_model_lognormal_2params.fitted_params["param_1"])) - @test(!all(y->y==fitted_model_lognormal_2params.fitted_params["param_2"][1],fitted_model_lognormal_2params.fitted_params["param_2"])) - # @test(!all(y->y==fitted_model_lognormal_X.fitted_params["param_1"][1],fitted_model_lognormal_X.fitted_params["param_1"])) - #@test(all(y->y==fitted_model_lognormal_X.fitted_params["param_2"][1],fitted_model_lognormal_X.fitted_params["param_2"])) - @test(!all(y->y==fitted_model_lognormal_X_2params.fitted_params["param_1"][1],fitted_model_lognormal_X_2params.fitted_params["param_1"])) - @test(!all(y->y==fitted_model_lognormal_X_2params.fitted_params["param_2"][1],fitted_model_lognormal_X_2params.fitted_params["param_2"])) + @testset " --- Testing create_model functions" begin + # Create model with no explanatory series + model_lognormal, parameters_lognormal, initial_values_lognormal = UnobservedComponentsGAS.create_model(gas_model_lognormal, y, missing) + model_lognormal_2params, parameters_lognormal_2params, initial_values_lognormal_2params = UnobservedComponentsGAS.create_model(gas_model_lognormal_2params, y, missing) + + model_lognormal_X, parameters_lognormal_X, initial_values_lognormal_X = UnobservedComponentsGAS.create_model(gas_model_lognormal_X, y, X, missing); + model_lognormal_X_2params, parameters_lognormal_X_2params, initial_values_lognormal_X_2params = UnobservedComponentsGAS.create_model(gas_model_lognormal_X_2params, y, X, missing); + + @test(size(parameters_lognormal) == (T,2)) + @test(size(parameters_lognormal_2params) == (T,2)) + @test(typeof(model_lognormal) == JuMP.Model) + @test(typeof(model_lognormal_2params) == JuMP.Model) + @test(test_initial_values_components(initial_values_lognormal, rw, rws, ar, seasonality)) + @test(test_initial_values_components(initial_values_lognormal_2params, rw, rws, ar, seasonality)) + + @test(size(parameters_lognormal_X) == (T,2)) + @test(size(parameters_lognormal_X_2params) == (T,2)) + @test(typeof(model_lognormal_X) == JuMP.Model) + @test(typeof(model_lognormal_X_2params) == JuMP.Model) + @test(test_initial_values_components(initial_values_lognormal_X, rw, rws, ar, seasonality)) + @test(test_initial_values_components(initial_values_lognormal_X_2params, rw, rws, ar, seasonality)) + end - # "Test if all residuals are being generated" - residuals_types = ["q_residuals", "std_residuals", "cs_residuals"] - @test(all(keys(fitted_model_lognormal.residuals) .== residuals_types)) - @test(all(keys(fitted_model_lognormal_2params.residuals) .== residuals_types)) - - @info(" --- Test forecast function ---") - forecast_lognormal = UnobservedComponentsGAS.predict(gas_model_lognormal, fitted_model_lognormal, y, steps_ahead, num_scenarious) - #forecast_lognormal_X = UnobservedComponentsGAS.predict(gas_model_lognormal_X, fitted_model_lognormal_X, y, X_lognormal_forec, steps_ahead, num_scenarious) - forecast_lognormal_2params = UnobservedComponentsGAS.predict(gas_model_lognormal_2params, fitted_model_lognormal_2params, y, steps_ahead, num_scenarious) + @testset " --- Testing fit functions" begin + fitted_model_lognormal = UnobservedComponentsGAS.fit(gas_model_lognormal, y; tol = 5e-2) + fitted_model_lognormal_2params = UnobservedComponentsGAS.fit(gas_model_lognormal_2params, y; tol = 5e-2) + fitted_model_lognormal_X = UnobservedComponentsGAS.fit(gas_model_lognormal_X, y, X) + fitted_model_lognormal_X_2params = UnobservedComponentsGAS.fit(gas_model_lognormal_X_2params, y, X) + + # "Test if termination_status is correct" + possible_status = ["LOCALLY_SOLVED", "TIME_LIMIT"] + @test(fitted_model_lognormal.model_status in possible_status) + @test(fitted_model_lognormal_2params.model_status in possible_status) + @test(fitted_model_lognormal_X.model_status in possible_status) + # "Test if selected_variables is missing " + @test(ismissing(fitted_model_lognormal.selected_variables)) + @test(ismissing(fitted_model_lognormal_2params.selected_variables)) + # "Test if fitted_params has the right keys -> order may be a problem" + @test(all(keys(fitted_model_lognormal.fitted_params) .== ["param_2","param_1"])) + @test(all(keys(fitted_model_lognormal_2params.fitted_params) .== ["param_2","param_1"])) + + # "Test if all time varying and fixed params are time varying and fixed" + @test(!all(y->y==fitted_model_lognormal.fitted_params["param_1"][1],fitted_model_lognormal.fitted_params["param_1"])) + #@test(all(y->y==fitted_model_lognormal.fitted_params["param_2"][1],fitted_model_lognormal.fitted_params["param_2"])) + @test(!all(y->y==fitted_model_lognormal_2params.fitted_params["param_1"][1],fitted_model_lognormal_2params.fitted_params["param_1"])) + @test(!all(y->y==fitted_model_lognormal_2params.fitted_params["param_2"][1],fitted_model_lognormal_2params.fitted_params["param_2"])) + # @test(!all(y->y==fitted_model_lognormal_X.fitted_params["param_1"][1],fitted_model_lognormal_X.fitted_params["param_1"])) + #@test(all(y->y==fitted_model_lognormal_X.fitted_params["param_2"][1],fitted_model_lognormal_X.fitted_params["param_2"])) + @test(!all(y->y==fitted_model_lognormal_X_2params.fitted_params["param_1"][1],fitted_model_lognormal_X_2params.fitted_params["param_1"])) + @test(!all(y->y==fitted_model_lognormal_X_2params.fitted_params["param_2"][1],fitted_model_lognormal_X_2params.fitted_params["param_2"])) + + # "Test if all residuals are being generated" + residuals_types = ["q_residuals", "std_residuals", "cs_residuals"] + @test(all(keys(fitted_model_lognormal.residuals) .== residuals_types)) + @test(all(keys(fitted_model_lognormal_2params.residuals) .== residuals_types)) + end + @testset " --- Test forecast function ---" begin + forecast_lognormal = UnobservedComponentsGAS.predict(gas_model_lognormal, fitted_model_lognormal, y, steps_ahead, num_scenarious) + #forecast_lognormal_X = UnobservedComponentsGAS.predict(gas_model_lognormal_X, fitted_model_lognormal_X, y, X_lognormal_forec, steps_ahead, num_scenarious) + forecast_lognormal_2params = UnobservedComponentsGAS.predict(gas_model_lognormal_2params, fitted_model_lognormal_2params, y, steps_ahead, num_scenarious) - @test(isapprox(forecast_lognormal["mean"], vec(mean(forecast_lognormal["scenarios"], dims = 2)); rtol = 1e-3)) - @test(size(forecast_lognormal["scenarios"]) == (steps_ahead, num_scenarious)) - @test(isapprox(forecast_lognormal["intervals"]["80"]["lower"], [quantile(forecast_lognormal["scenarios"][t,:], 0.2/2) for t in 1:steps_ahead])) - @test(isapprox(forecast_lognormal["intervals"]["80"]["upper"], [quantile(forecast_lognormal["scenarios"][t,:], 1 - 0.2/2) for t in 1:steps_ahead])) - @test(isapprox(forecast_lognormal["intervals"]["95"]["lower"], [quantile(forecast_lognormal["scenarios"][t,:], 0.05/2) for t in 1:steps_ahead])) - @test(isapprox(forecast_lognormal["intervals"]["95"]["upper"], [quantile(forecast_lognormal["scenarios"][t,:], 1 - 0.05/2) for t in 1:steps_ahead])) + @test(isapprox(forecast_lognormal["mean"], vec(mean(forecast_lognormal["scenarios"], dims = 2)); rtol = 1e-3)) + @test(size(forecast_lognormal["scenarios"]) == (steps_ahead, num_scenarious)) - @test(isapprox(forecast_lognormal_2params["mean"], vec(mean(forecast_lognormal_2params["scenarios"], dims = 2)); rtol = 1e-3)) - @test(size(forecast_lognormal_2params["scenarios"]) == (steps_ahead, num_scenarious)) + @test(isapprox(forecast_lognormal["intervals"]["80"]["lower"], [quantile(forecast_lognormal["scenarios"][t,:], 0.2/2) for t in 1:steps_ahead])) + @test(isapprox(forecast_lognormal["intervals"]["80"]["upper"], [quantile(forecast_lognormal["scenarios"][t,:], 1 - 0.2/2) for t in 1:steps_ahead])) + @test(isapprox(forecast_lognormal["intervals"]["95"]["lower"], [quantile(forecast_lognormal["scenarios"][t,:], 0.05/2) for t in 1:steps_ahead])) + @test(isapprox(forecast_lognormal["intervals"]["95"]["upper"], [quantile(forecast_lognormal["scenarios"][t,:], 1 - 0.05/2) for t in 1:steps_ahead])) - @test(isapprox(forecast_lognormal_2params["intervals"]["80"]["lower"], [quantile(forecast_lognormal_2params["scenarios"][t,:], 0.2/2) for t in 1:steps_ahead])) - @test(isapprox(forecast_lognormal_2params["intervals"]["80"]["upper"], [quantile(forecast_lognormal_2params["scenarios"][t,:], 1 - 0.2/2) for t in 1:steps_ahead])) - @test(isapprox(forecast_lognormal_2params["intervals"]["95"]["lower"], [quantile(forecast_lognormal_2params["scenarios"][t,:], 0.05/2) for t in 1:steps_ahead])) - @test(isapprox(forecast_lognormal_2params["intervals"]["95"]["upper"], [quantile(forecast_lognormal_2params["scenarios"][t,:], 1 - 0.05/2) for t in 1:steps_ahead])) + @test(isapprox(forecast_lognormal_2params["mean"], vec(mean(forecast_lognormal_2params["scenarios"], dims = 2)); rtol = 1e-3)) + @test(size(forecast_lognormal_2params["scenarios"]) == (steps_ahead, num_scenarious)) - # @test(isapprox(forecast_lognormal_X["mean"], vec(mean(forecast_lognormal_X["scenarios"], dims = 2)); rtol = 1e-3)) - # @test(size(forecast_lognormal_X["scenarios"]) == (steps_ahead, num_scenarious)) + @test(isapprox(forecast_lognormal_2params["intervals"]["80"]["lower"], [quantile(forecast_lognormal_2params["scenarios"][t,:], 0.2/2) for t in 1:steps_ahead])) + @test(isapprox(forecast_lognormal_2params["intervals"]["80"]["upper"], [quantile(forecast_lognormal_2params["scenarios"][t,:], 1 - 0.2/2) for t in 1:steps_ahead])) + @test(isapprox(forecast_lognormal_2params["intervals"]["95"]["lower"], [quantile(forecast_lognormal_2params["scenarios"][t,:], 0.05/2) for t in 1:steps_ahead])) + @test(isapprox(forecast_lognormal_2params["intervals"]["95"]["upper"], [quantile(forecast_lognormal_2params["scenarios"][t,:], 1 - 0.05/2) for t in 1:steps_ahead])) - # @test(isapprox(forecast_lognormal_X["intervals"]["80"]["lower"], [quantile(forecast_lognormal_X["scenarios"][t,:], 0.2/2) for t in 1:steps_ahead])) - # @test(isapprox(forecast_lognormal_X["intervals"]["80"]["upper"], [quantile(forecast_lognormal_X["scenarios"][t,:], 1 - 0.2/2) for t in 1:steps_ahead])) - # @test(isapprox(forecast_lognormal_X["intervals"]["95"]["lower"], [quantile(forecast_lognormal_X["scenarios"][t,:], 0.05/2) for t in 1:steps_ahead])) - # @test(isapprox(forecast_lognormal_X["intervals"]["95"]["upper"], [quantile(forecast_lognormal_X["scenarios"][t,:], 1 - 0.05/2) for t in 1:steps_ahead])) + # @test(isapprox(forecast_lognormal_X["mean"], vec(mean(forecast_lognormal_X["scenarios"], dims = 2)); rtol = 1e-3)) + # @test(size(forecast_lognormal_X["scenarios"]) == (steps_ahead, num_scenarious)) + # @test(isapprox(forecast_lognormal_X["intervals"]["80"]["lower"], [quantile(forecast_lognormal_X["scenarios"][t,:], 0.2/2) for t in 1:steps_ahead])) + # @test(isapprox(forecast_lognormal_X["intervals"]["80"]["upper"], [quantile(forecast_lognormal_X["scenarios"][t,:], 1 - 0.2/2) for t in 1:steps_ahead])) + # @test(isapprox(forecast_lognormal_X["intervals"]["95"]["lower"], [quantile(forecast_lognormal_X["scenarios"][t,:], 0.05/2) for t in 1:steps_ahead])) + # @test(isapprox(forecast_lognormal_X["intervals"]["95"]["upper"], [quantile(forecast_lognormal_X["scenarios"][t,:], 1 - 0.05/2) for t in 1:steps_ahead])) + end - @info(" --- Test quality of fit and forecast - LogNormal") - y = time_series[1:end-steps_ahead,1] - y_test = time_series[end-steps_ahead+1:end, 1] - gas_model = UnobservedComponentsGAS.GASModel(UnobservedComponentsGAS.LogNormalDistribution(), [true, false], - 1.0, "random walk slope", "deterministic 12", missing) - fitted_model = UnobservedComponentsGAS.fit(gas_model, y) - forec = UnobservedComponentsGAS.predict(gas_model, fitted_model, y, steps_ahead, num_scenarious) + @testset " --- Test quality of fit and forecast - LogNormal" begin + y = time_series[1:end-steps_ahead,1] + y_test = time_series[end-steps_ahead+1:end, 1] - @test(isapprox(fitted_model.fit_in_sample[2:end], y[2:end]; rtol = 1e-1)) - @test(isapprox(forec["mean"], y_test; rtol = 1e2)) + gas_model = UnobservedComponentsGAS.GASModel(UnobservedComponentsGAS.LogNormalDistribution(), [true, false], + 1.0, "random walk slope", "deterministic 12", missing) + fitted_model = UnobservedComponentsGAS.fit(gas_model, y) + forec = UnobservedComponentsGAS.predict(gas_model, fitted_model, y, steps_ahead, num_scenarious) - @info(" --- Test quality of fit - LogNormal with 2 params") - y = time_series[1:end-steps_ahead,4] - y_test = time_series[end-steps_ahead+1:end, 4] - gas_model = UnobservedComponentsGAS.GASModel(UnobservedComponentsGAS.LogNormalDistribution(), [true, true], - 0.5, ["random walk slope", "random walk"], ["deterministic 12", "deterministic 12"], [missing, missing]) - fitted_model = UnobservedComponentsGAS.fit(gas_model, y) - forec = UnobservedComponentsGAS.predict(gas_model, fitted_model, y, steps_ahead, num_scenarious) + @test(isapprox(fitted_model.fit_in_sample[2:end], y[2:end]; rtol = 1e-1)) + @test(isapprox(forec["mean"], y_test; rtol = 1e2)) + end - hcat(fitted_model.fit_in_sample[2:end], y[2:end]) - @test(isapprox(fitted_model.fit_in_sample[2:end], y[2:end]; rtol = 1e-1)) - @test(isapprox(forec["mean"], y_test; rtol = 1e2)) - + @testset " --- Test quality of fit - LogNormal with 2 params" begin + y = time_series[1:end-steps_ahead,4] + y_test = time_series[end-steps_ahead+1:end, 4] + gas_model = UnobservedComponentsGAS.GASModel(UnobservedComponentsGAS.LogNormalDistribution(), [true, true], + 0.5, ["random walk slope", "random walk"], ["deterministic 12", "deterministic 12"], [missing, missing]) + fitted_model = UnobservedComponentsGAS.fit(gas_model, y) + forec = UnobservedComponentsGAS.predict(gas_model, fitted_model, y, steps_ahead, num_scenarious) + + hcat(fitted_model.fit_in_sample[2:end], y[2:end]) + @test(isapprox(fitted_model.fit_in_sample[2:end], y[2:end]; rtol = 1e-1)) + @test(isapprox(forec["mean"], y_test; rtol = 1e2)) + end + end \ No newline at end of file diff --git a/test/test_fit_forecast_normal.jl b/test/test_fit_forecast_normal.jl index c4ce28c..cc92f39 100644 --- a/test/test_fit_forecast_normal.jl +++ b/test/test_fit_forecast_normal.jl @@ -50,121 +50,139 @@ gas_model_normal_X = deepcopy(gas_model_normal) gas_model_normal_X_2params = deepcopy(gas_model_normal_2params) - @info(" --- Testing create_model functions") + @testset "create_model" begin # Create model with no explanatory series - model_normal, parameters_normal, initial_values_normal = UnobservedComponentsGAS.create_model(gas_model_normal, y, missing) - model_normal_2params, parameters_normal_2params, initial_values_normal_2params = UnobservedComponentsGAS.create_model(gas_model_normal_2params, y, missing) - - model_normal_X, parameters_normal_X, initial_values_normal_X = UnobservedComponentsGAS.create_model(gas_model_normal_X, y, X, missing); - model_normal_X_2params, parameters_normal_X_2params, initial_values_normal_X_2params = UnobservedComponentsGAS.create_model(gas_model_normal_X_2params, y, X, missing); - - @test(size(parameters_normal) == (T,2)) - @test(size(parameters_normal_2params) == (T,2)) - @test(typeof(model_normal) == JuMP.Model) - @test(typeof(model_normal_2params) == JuMP.Model) - @test(test_initial_values_components(initial_values_normal, rw, rws, ar, seasonality)) - @test(test_initial_values_components(initial_values_normal_2params, rw, rws, ar, seasonality)) - - @test(size(parameters_normal_X) == (T,2)) - @test(size(parameters_normal_X_2params) == (T,2)) - @test(typeof(model_normal_X) == JuMP.Model) - @test(typeof(model_normal_X_2params) == JuMP.Model) - @test(test_initial_values_components(initial_values_normal_X, rw, rws, ar, seasonality)) - @test(test_initial_values_components(initial_values_normal_X_2params, rw, rws, ar, seasonality)) - - @info(" --- Testing fit functions") - fitted_model_normal = UnobservedComponentsGAS.fit(gas_model_normal, y; tol = 5e-2) - fitted_model_normal_2params = UnobservedComponentsGAS.fit(gas_model_normal_2params, y; tol = 5e-2) - fitted_model_normal_X = UnobservedComponentsGAS.fit(gas_model_normal_X, y, X; tol = 5e-2) - fitted_model_normal_X_2params = UnobservedComponentsGAS.fit(gas_model_normal_X_2params, y, X; tol = 5e-2) - - # "Test if termination_status is correct" - possible_status = ["LOCALLY_SOLVED", "TIME_LIMIT"] - @test(fitted_model_normal.model_status in possible_status) - @test(fitted_model_normal_2params.model_status in possible_status) - @test(fitted_model_normal_X.model_status in possible_status) - # "Test if selected_variables is missing " - @test(ismissing(fitted_model_normal.selected_variables)) - @test(ismissing(fitted_model_normal_2params.selected_variables)) - # "Test if fitted_params has the right keys -> order may be a problem" - @test(all(keys(fitted_model_normal.fitted_params) .== ["param_2","param_1"])) - @test(all(keys(fitted_model_normal_2params.fitted_params) .== ["param_2","param_1"])) - - # "Test if all time varying and fixed params are time varying and fixed" - @test(!all(y->y==fitted_model_normal.fitted_params["param_1"][1],fitted_model_normal.fitted_params["param_1"])) - @test(all(y->y==fitted_model_normal.fitted_params["param_2"][1],fitted_model_normal.fitted_params["param_2"])) - @test(!all(y->y==fitted_model_normal_2params.fitted_params["param_1"][1],fitted_model_normal_2params.fitted_params["param_1"])) - @test(!all(y->y==fitted_model_normal_2params.fitted_params["param_2"][1],fitted_model_normal_2params.fitted_params["param_2"])) - @test(!all(y->y==fitted_model_normal_X.fitted_params["param_1"][1],fitted_model_normal_X.fitted_params["param_1"])) - @test(all(y->y==fitted_model_normal_X.fitted_params["param_2"][1],fitted_model_normal_X.fitted_params["param_2"])) - @test(!all(y->y==fitted_model_normal_X_2params.fitted_params["param_1"][1],fitted_model_normal_X_2params.fitted_params["param_1"])) - @test(!all(y->y==fitted_model_normal_X_2params.fitted_params["param_2"][1],fitted_model_normal_X_2params.fitted_params["param_2"])) + model_normal, parameters_normal, initial_values_normal = UnobservedComponentsGAS.create_model(gas_model_normal, y, missing) + model_normal_2params, parameters_normal_2params, initial_values_normal_2params = UnobservedComponentsGAS.create_model(gas_model_normal_2params, y, missing) + + model_normal_X, parameters_normal_X, initial_values_normal_X = UnobservedComponentsGAS.create_model(gas_model_normal_X, y, X, missing); + model_normal_X_2params, parameters_normal_X_2params, initial_values_normal_X_2params = UnobservedComponentsGAS.create_model(gas_model_normal_X_2params, y, X, missing); + + @test(size(parameters_normal) == (T,2)) + @test(size(parameters_normal_2params) == (T,2)) + @test(typeof(model_normal) == JuMP.Model) + @test(typeof(model_normal_2params) == JuMP.Model) + @test(test_initial_values_components(initial_values_normal, rw, rws, ar, seasonality)) + @test(test_initial_values_components(initial_values_normal_2params, rw, rws, ar, seasonality)) + + @test(size(parameters_normal_X) == (T,2)) + @test(size(parameters_normal_X_2params) == (T,2)) + @test(typeof(model_normal_X) == JuMP.Model) + @test(typeof(model_normal_X_2params) == JuMP.Model) + @test(test_initial_values_components(initial_values_normal_X, rw, rws, ar, seasonality)) + @test(test_initial_values_components(initial_values_normal_X_2params, rw, rws, ar, seasonality)) + end - # "Test if all residuals are being generated" - residuals_types = ["q_residuals", "std_residuals", "cs_residuals"] - @test(all(keys(fitted_model_normal.residuals) .== residuals_types)) - @test(all(keys(fitted_model_normal_2params.residuals) .== residuals_types)) - - @info(" --- Test forecast function ---") - forecast_normal = UnobservedComponentsGAS.predict(gas_model_normal, fitted_model_normal, y, steps_ahead, num_scenarious) - forecast_normal_X = UnobservedComponentsGAS.predict(gas_model_normal_X, fitted_model_normal_X, y, X_normal_forec, steps_ahead, num_scenarious) - forecast_normal_2params = UnobservedComponentsGAS.predict(gas_model_normal_2params, fitted_model_normal_2params, y, steps_ahead, num_scenarious) + #@info(" --- Testing fit functions") + @testset "fit" begin + fitted_model_normal = UnobservedComponentsGAS.fit(gas_model_normal, y; tol = 5e-2) + fitted_model_normal_2params = UnobservedComponentsGAS.fit(gas_model_normal_2params, y; tol = 5e-2) + fitted_model_normal_X = UnobservedComponentsGAS.fit(gas_model_normal_X, y, X; tol = 5e-2) + fitted_model_normal_X_2params = UnobservedComponentsGAS.fit(gas_model_normal_X_2params, y, X; tol = 5e-2) + + # "Test if termination_status is correct" + possible_status = ["LOCALLY_SOLVED", "TIME_LIMIT"] + @test(fitted_model_normal.model_status in possible_status) + @test(fitted_model_normal_2params.model_status in possible_status) + @test(fitted_model_normal_X.model_status in possible_status) + # "Test if selected_variables is missing " + @test(ismissing(fitted_model_normal.selected_variables)) + @test(ismissing(fitted_model_normal_2params.selected_variables)) + # "Test if fitted_params has the right keys -> order may be a problem" + @test(all(keys(fitted_model_normal.fitted_params) .== ["param_2","param_1"])) + @test(all(keys(fitted_model_normal_2params.fitted_params) .== ["param_2","param_1"])) + + # "Test if all time varying and fixed params are time varying and fixed" + @test(!all(y->y==fitted_model_normal.fitted_params["param_1"][1],fitted_model_normal.fitted_params["param_1"])) + @test(all(y->y==fitted_model_normal.fitted_params["param_2"][1],fitted_model_normal.fitted_params["param_2"])) + @test(!all(y->y==fitted_model_normal_2params.fitted_params["param_1"][1],fitted_model_normal_2params.fitted_params["param_1"])) + @test(!all(y->y==fitted_model_normal_2params.fitted_params["param_2"][1],fitted_model_normal_2params.fitted_params["param_2"])) + @test(!all(y->y==fitted_model_normal_X.fitted_params["param_1"][1],fitted_model_normal_X.fitted_params["param_1"])) + @test(all(y->y==fitted_model_normal_X.fitted_params["param_2"][1],fitted_model_normal_X.fitted_params["param_2"])) + @test(!all(y->y==fitted_model_normal_X_2params.fitted_params["param_1"][1],fitted_model_normal_X_2params.fitted_params["param_1"])) + @test(!all(y->y==fitted_model_normal_X_2params.fitted_params["param_2"][1],fitted_model_normal_X_2params.fitted_params["param_2"])) + + # "Test if all residuals are being generated" + residuals_types = ["q_residuals", "std_residuals", "cs_residuals"] + @test(all(keys(fitted_model_normal.residuals) .== residuals_types)) + @test(all(keys(fitted_model_normal_2params.residuals) .== residuals_types)) + end + #@info(" --- Test forecast function ---") + @testset "forecast" begin + forecast_normal = UnobservedComponentsGAS.predict(gas_model_normal, fitted_model_normal, y, steps_ahead, num_scenarious) + forecast_normal_X = UnobservedComponentsGAS.predict(gas_model_normal_X, fitted_model_normal_X, y, X_normal_forec, steps_ahead, num_scenarious) + forecast_normal_2params = UnobservedComponentsGAS.predict(gas_model_normal_2params, fitted_model_normal_2params, y, steps_ahead, num_scenarious) - @test(isapprox(forecast_normal["mean"], vec(mean(forecast_normal["scenarios"], dims = 2)); rtol = 1e-3)) - @test(size(forecast_normal["scenarios"]) == (steps_ahead, num_scenarious)) - @test(isapprox(forecast_normal["intervals"]["80"]["lower"], [quantile(forecast_normal["scenarios"][t,:], 0.2/2) for t in 1:steps_ahead])) - @test(isapprox(forecast_normal["intervals"]["80"]["upper"], [quantile(forecast_normal["scenarios"][t,:], 1 - 0.2/2) for t in 1:steps_ahead])) - @test(isapprox(forecast_normal["intervals"]["95"]["lower"], [quantile(forecast_normal["scenarios"][t,:], 0.05/2) for t in 1:steps_ahead])) - @test(isapprox(forecast_normal["intervals"]["95"]["upper"], [quantile(forecast_normal["scenarios"][t,:], 1 - 0.05/2) for t in 1:steps_ahead])) + @test(isapprox(forecast_normal["mean"], vec(mean(forecast_normal["scenarios"], dims = 2)); rtol = 1e-3)) + @test(size(forecast_normal["scenarios"]) == (steps_ahead, num_scenarious)) - @test(isapprox(forecast_normal_2params["mean"], vec(mean(forecast_normal_2params["scenarios"], dims = 2)); rtol = 1e-3)) - @test(size(forecast_normal_2params["scenarios"]) == (steps_ahead, num_scenarious)) + @test(isapprox(forecast_normal["intervals"]["80"]["lower"], [quantile(forecast_normal["scenarios"][t,:], 0.2/2) for t in 1:steps_ahead])) + @test(isapprox(forecast_normal["intervals"]["80"]["upper"], [quantile(forecast_normal["scenarios"][t,:], 1 - 0.2/2) for t in 1:steps_ahead])) + @test(isapprox(forecast_normal["intervals"]["95"]["lower"], [quantile(forecast_normal["scenarios"][t,:], 0.05/2) for t in 1:steps_ahead])) + @test(isapprox(forecast_normal["intervals"]["95"]["upper"], [quantile(forecast_normal["scenarios"][t,:], 1 - 0.05/2) for t in 1:steps_ahead])) - @test(isapprox(forecast_normal_2params["intervals"]["80"]["lower"], [quantile(forecast_normal_2params["scenarios"][t,:], 0.2/2) for t in 1:steps_ahead])) - @test(isapprox(forecast_normal_2params["intervals"]["80"]["upper"], [quantile(forecast_normal_2params["scenarios"][t,:], 1 - 0.2/2) for t in 1:steps_ahead])) - @test(isapprox(forecast_normal_2params["intervals"]["95"]["lower"], [quantile(forecast_normal_2params["scenarios"][t,:], 0.05/2) for t in 1:steps_ahead])) - @test(isapprox(forecast_normal_2params["intervals"]["95"]["upper"], [quantile(forecast_normal_2params["scenarios"][t,:], 1 - 0.05/2) for t in 1:steps_ahead])) + @test(isapprox(forecast_normal_2params["mean"], vec(mean(forecast_normal_2params["scenarios"], dims = 2)); rtol = 1e-3)) + @test(size(forecast_normal_2params["scenarios"]) == (steps_ahead, num_scenarious)) - @test(isapprox(forecast_normal_X["mean"], vec(mean(forecast_normal_X["scenarios"], dims = 2)); rtol = 1e-3)) - @test(size(forecast_normal_X["scenarios"]) == (steps_ahead, num_scenarious)) + @test(isapprox(forecast_normal_2params["intervals"]["80"]["lower"], [quantile(forecast_normal_2params["scenarios"][t,:], 0.2/2) for t in 1:steps_ahead])) + @test(isapprox(forecast_normal_2params["intervals"]["80"]["upper"], [quantile(forecast_normal_2params["scenarios"][t,:], 1 - 0.2/2) for t in 1:steps_ahead])) + @test(isapprox(forecast_normal_2params["intervals"]["95"]["lower"], [quantile(forecast_normal_2params["scenarios"][t,:], 0.05/2) for t in 1:steps_ahead])) + @test(isapprox(forecast_normal_2params["intervals"]["95"]["upper"], [quantile(forecast_normal_2params["scenarios"][t,:], 1 - 0.05/2) for t in 1:steps_ahead])) - @test(isapprox(forecast_normal_X["intervals"]["80"]["lower"], [quantile(forecast_normal_X["scenarios"][t,:], 0.2/2) for t in 1:steps_ahead])) - @test(isapprox(forecast_normal_X["intervals"]["80"]["upper"], [quantile(forecast_normal_X["scenarios"][t,:], 1 - 0.2/2) for t in 1:steps_ahead])) - @test(isapprox(forecast_normal_X["intervals"]["95"]["lower"], [quantile(forecast_normal_X["scenarios"][t,:], 0.05/2) for t in 1:steps_ahead])) - @test(isapprox(forecast_normal_X["intervals"]["95"]["upper"], [quantile(forecast_normal_X["scenarios"][t,:], 1 - 0.05/2) for t in 1:steps_ahead])) + @test(isapprox(forecast_normal_X["mean"], vec(mean(forecast_normal_X["scenarios"], dims = 2)); rtol = 1e-3)) + @test(size(forecast_normal_X["scenarios"]) == (steps_ahead, num_scenarious)) + @test(isapprox(forecast_normal_X["intervals"]["80"]["lower"], [quantile(forecast_normal_X["scenarios"][t,:], 0.2/2) for t in 1:steps_ahead])) + @test(isapprox(forecast_normal_X["intervals"]["80"]["upper"], [quantile(forecast_normal_X["scenarios"][t,:], 1 - 0.2/2) for t in 1:steps_ahead])) + @test(isapprox(forecast_normal_X["intervals"]["95"]["lower"], [quantile(forecast_normal_X["scenarios"][t,:], 0.05/2) for t in 1:steps_ahead])) + @test(isapprox(forecast_normal_X["intervals"]["95"]["upper"], [quantile(forecast_normal_X["scenarios"][t,:], 1 - 0.05/2) for t in 1:steps_ahead])) + end - @info(" --- Test quality of fit and forecast - Normal") - y = time_series[1:end-steps_ahead,5] - y_test = time_series[end-steps_ahead+1:end, 5] - - gas_model = UnobservedComponentsGAS.GASModel(UnobservedComponentsGAS.NormalDistribution(), [true, false], - 1.0, "random walk slope", "deterministic 12", missing) - fitted_model = UnobservedComponentsGAS.fit(gas_model, y) - forec = UnobservedComponentsGAS.predict(gas_model, fitted_model, y, steps_ahead, num_scenarious) - - @test(isapprox(fitted_model.fit_in_sample[2:end], y[2:end]; rtol = 1e-2)) - @test(isapprox(forec["mean"], y_test; rtol = 1e2)) - - @info(" --- Test quality of fit - Normal with 2 params") - gas_model = UnobservedComponentsGAS.GASModel(UnobservedComponentsGAS.NormalDistribution(), [true, true], - 0.0, ["random walk slope", "random walk"], ["deterministic 12", "deterministic 12"], [missing, missing]) - fitted_model = UnobservedComponentsGAS.fit(gas_model, y) - forec = UnobservedComponentsGAS.predict(gas_model, fitted_model, y, steps_ahead, num_scenarious) + #@info(" --- Test quality of fit and forecast - Normal") + @testset "quality of fit - Normal" begin + y = time_series[1:end-steps_ahead,5] + y_test = time_series[end-steps_ahead+1:end, 5] - @test(isapprox(fitted_model.fit_in_sample[2:end], y[2:end]; rtol = 1e-1)) - @test(isapprox(forec["mean"], y_test; rtol = 1e2)) + gas_model = UnobservedComponentsGAS.GASModel(UnobservedComponentsGAS.NormalDistribution(), [true, false], + 1.0, "random walk slope", "deterministic 12", missing) + fitted_model = UnobservedComponentsGAS.fit(gas_model, y) + forec = UnobservedComponentsGAS.predict(gas_model, fitted_model, y, steps_ahead, num_scenarious) + + @test(isapprox(fitted_model.fit_in_sample[2:end], y[2:end]; rtol = 1e-2)) + @test(isapprox(forec["mean"], y_test; rtol = 1e2)) + end - @info(" --- Test quality of fit - Normal with robust") - gas_model = UnobservedComponentsGAS.GASModel(UnobservedComponentsGAS.NormalDistribution(), [true, false], - 1.0, "random walk slope", "deterministic 12", 1) - fitted_model = UnobservedComponentsGAS.fit(gas_model, y; α = 0.0, robust = true) - forec = UnobservedComponentsGAS.predict(gas_model, fitted_model, y, steps_ahead, num_scenarious) + #@info(" --- Test quality of fit - Normal with 2 params") + @testset "quality of fit - Normal with 2 params" begin + gas_model = UnobservedComponentsGAS.GASModel(UnobservedComponentsGAS.NormalDistribution(), [true, true], + 0.0, ["random walk slope", "random walk"], ["deterministic 12", "deterministic 12"], [missing, missing]) + fitted_model = UnobservedComponentsGAS.fit(gas_model, y) + forec = UnobservedComponentsGAS.predict(gas_model, fitted_model, y, steps_ahead, num_scenarious) + + @test(isapprox(fitted_model.fit_in_sample[2:end], y[2:end]; rtol = 1e-1)) + @test(isapprox(forec["mean"], y_test; rtol = 1e2)) + end + + # #@info(" --- Test quality of fit - Normal with robust") + @testset "quality of fit - Normal with robust" begin + gas_model = UnobservedComponentsGAS.GASModel(UnobservedComponentsGAS.NormalDistribution(), [true, false], + 1.0, "random walk slope", "deterministic 12", 1) + fitted_model = UnobservedComponentsGAS.fit(gas_model, y; α = 0.0, robust = true) + forec = UnobservedComponentsGAS.predict(gas_model, fitted_model, y, steps_ahead, num_scenarious) + + @test(isapprox(fitted_model.fit_in_sample[2:end], y[2:end]; rtol = 1e-2)) + @test(isapprox(forec["mean"], y_test; rtol = 1e2)) + end - @test(isapprox(fitted_model.fit_in_sample[2:end], y[2:end]; rtol = 1e-2)) - @test(isapprox(forec["mean"], y_test; rtol = 1e2)) + @testset "AR(1) level" begin + gas_model = UnobservedComponentsGAS.GASModel(UnobservedComponentsGAS.NormalDistribution(), [true, false], + 0.5, ["ar(1)", ""], ["deterministic 12", ""], [missing, missing]) + fitted_model = UnobservedComponentsGAS.fit(gas_model, y) + + @test(all(fitted_model.components["param_1"]["level"]["value"] .!= zeros(length(y)))) + end end \ No newline at end of file diff --git a/test/test_fit_forecast_t.jl b/test/test_fit_forecast_t.jl index 02ab6b4..6435e1f 100644 --- a/test/test_fit_forecast_t.jl +++ b/test/test_fit_forecast_t.jl @@ -51,123 +51,129 @@ gas_model_t_X = deepcopy(gas_model_t) gas_model_t_X_2params = deepcopy(gas_model_t_2params) - @info(" --- Testing create_model functions") - # Create model with no explanatory series - model_t, parameters_t, initial_values_t = UnobservedComponentsGAS.create_model(gas_model_t, y, ν) - model_t_2params, parameters_t_2params, initial_values_t_2params = UnobservedComponentsGAS.create_model(gas_model_t_2params, y, ν) - - model_t_X, parameters_t_X, initial_values_t_X = UnobservedComponentsGAS.create_model(gas_model_t_X, y, X, ν); - model_t_X_2params, parameters_t_X_2params, initial_values_t_X_2params = UnobservedComponentsGAS.create_model(gas_model_t_X_2params, y, X, ν); - - @test(size(parameters_t) == (T,3)) - @test(size(parameters_t_2params) == (T,3)) - @test(typeof(model_t) == JuMP.Model) - @test(typeof(model_t_2params) == JuMP.Model) - @test(test_initial_values_components(initial_values_t, rw, rws, ar, seasonality)) - @test(test_initial_values_components(initial_values_t_2params, rw, rws, ar, seasonality)) - - @test(size(parameters_t_X) == (T,3)) - @test(size(parameters_t_X_2params) == (T,3)) - @test(typeof(model_t_X) == JuMP.Model) - @test(typeof(model_t_X_2params) == JuMP.Model) - @test(test_initial_values_components(initial_values_t_X, rw, rws, ar, seasonality)) - @test(test_initial_values_components(initial_values_t_X_2params, rw, rws, ar, seasonality)) - - @info(" --- Testing fit functions") - fitted_model_t = UnobservedComponentsGAS.fit(gas_model_t, y; tol = 5e-2) - fitted_model_t_2params = UnobservedComponentsGAS.fit(gas_model_t_2params, y; tol = 5e-2) - fitted_model_t_X = UnobservedComponentsGAS.fit(gas_model_t_X, y, X; tol = 5e-2) - fitted_model_t_X_2params = UnobservedComponentsGAS.fit(gas_model_t_X_2params, y, X; tol = 5e-2) - - # "Test if termination_status is correct" - possible_status = ["LOCALLY_SOLVED", "TIME_LIMIT"] - @test(fitted_model_t.model_status in possible_status) - @test(fitted_model_t_2params.model_status in possible_status) - @test(fitted_model_t_X.model_status in possible_status) - # "Test if selected_variables is missing " - @test(ismissing(fitted_model_t.selected_variables)) - @test(ismissing(fitted_model_t_2params.selected_variables)) - # "Test if fitted_params has the right keys -> order may be a problem" - @test(all(keys(fitted_model_t.fitted_params) .== ["param_2","param_1","param_3"])) - @test(all(keys(fitted_model_t_2params.fitted_params) .== ["param_2","param_1","param_3"])) - - # "Test if all time varying and fixed params are time varying and fixed" - @test(!all(y->y==fitted_model_t.fitted_params["param_1"][1],fitted_model_t.fitted_params["param_1"])) - @test(all(y->y==fitted_model_t.fitted_params["param_2"][1],fitted_model_t.fitted_params["param_2"])) - @test(!all(y->y==fitted_model_t_2params.fitted_params["param_1"][1],fitted_model_t_2params.fitted_params["param_1"])) - @test(!all(y->y==fitted_model_t_2params.fitted_params["param_2"][1],fitted_model_t_2params.fitted_params["param_2"])) - @test(!all(y->y==fitted_model_t_X.fitted_params["param_1"][1],fitted_model_t_X.fitted_params["param_1"])) - @test(all(y->y==fitted_model_t_X.fitted_params["param_2"][1],fitted_model_t_X.fitted_params["param_2"])) - @test(!all(y->y==fitted_model_t_X_2params.fitted_params["param_1"][1],fitted_model_t_X_2params.fitted_params["param_1"])) - @test(!all(y->y==fitted_model_t_X_2params.fitted_params["param_2"][1],fitted_model_t_X_2params.fitted_params["param_2"])) + @testset " --- Testing create_model functions" begin + # Create model with no explanatory series + model_t, parameters_t, initial_values_t = UnobservedComponentsGAS.create_model(gas_model_t, y, ν) + model_t_2params, parameters_t_2params, initial_values_t_2params = UnobservedComponentsGAS.create_model(gas_model_t_2params, y, ν) + + model_t_X, parameters_t_X, initial_values_t_X = UnobservedComponentsGAS.create_model(gas_model_t_X, y, X, ν); + model_t_X_2params, parameters_t_X_2params, initial_values_t_X_2params = UnobservedComponentsGAS.create_model(gas_model_t_X_2params, y, X, ν); + + @test(size(parameters_t) == (T,3)) + @test(size(parameters_t_2params) == (T,3)) + @test(typeof(model_t) == JuMP.Model) + @test(typeof(model_t_2params) == JuMP.Model) + @test(test_initial_values_components(initial_values_t, rw, rws, ar, seasonality)) + @test(test_initial_values_components(initial_values_t_2params, rw, rws, ar, seasonality)) + + @test(size(parameters_t_X) == (T,3)) + @test(size(parameters_t_X_2params) == (T,3)) + @test(typeof(model_t_X) == JuMP.Model) + @test(typeof(model_t_X_2params) == JuMP.Model) + @test(test_initial_values_components(initial_values_t_X, rw, rws, ar, seasonality)) + @test(test_initial_values_components(initial_values_t_X_2params, rw, rws, ar, seasonality)) + end - # "Test if all residuals are being generated" - residuals_types = ["q_residuals", "std_residuals", "cs_residuals"] - @test(all(keys(fitted_model_t.residuals) .== residuals_types)) - @test(all(keys(fitted_model_t_2params.residuals) .== residuals_types)) + @testset " --- Testing fit functions" begin + fitted_model_t = UnobservedComponentsGAS.fit(gas_model_t, y; tol = 5e-2) + fitted_model_t_2params = UnobservedComponentsGAS.fit(gas_model_t_2params, y; tol = 5e-2) + fitted_model_t_X = UnobservedComponentsGAS.fit(gas_model_t_X, y, X; tol = 5e-2) + fitted_model_t_X_2params = UnobservedComponentsGAS.fit(gas_model_t_X_2params, y, X; tol = 5e-2) + + # "Test if termination_status is correct" + possible_status = ["LOCALLY_SOLVED", "TIME_LIMIT"] + @test(fitted_model_t.model_status in possible_status) + @test(fitted_model_t_2params.model_status in possible_status) + @test(fitted_model_t_X.model_status in possible_status) + # "Test if selected_variables is missing " + @test(ismissing(fitted_model_t.selected_variables)) + @test(ismissing(fitted_model_t_2params.selected_variables)) + # "Test if fitted_params has the right keys -> order may be a problem" + @test(all(keys(fitted_model_t.fitted_params) .== ["param_2","param_1","param_3"])) + @test(all(keys(fitted_model_t_2params.fitted_params) .== ["param_2","param_1","param_3"])) + + # "Test if all time varying and fixed params are time varying and fixed" + @test(!all(y->y==fitted_model_t.fitted_params["param_1"][1],fitted_model_t.fitted_params["param_1"])) + @test(all(y->y==fitted_model_t.fitted_params["param_2"][1],fitted_model_t.fitted_params["param_2"])) + @test(!all(y->y==fitted_model_t_2params.fitted_params["param_1"][1],fitted_model_t_2params.fitted_params["param_1"])) + @test(!all(y->y==fitted_model_t_2params.fitted_params["param_2"][1],fitted_model_t_2params.fitted_params["param_2"])) + @test(!all(y->y==fitted_model_t_X.fitted_params["param_1"][1],fitted_model_t_X.fitted_params["param_1"])) + @test(all(y->y==fitted_model_t_X.fitted_params["param_2"][1],fitted_model_t_X.fitted_params["param_2"])) + @test(!all(y->y==fitted_model_t_X_2params.fitted_params["param_1"][1],fitted_model_t_X_2params.fitted_params["param_1"])) + @test(!all(y->y==fitted_model_t_X_2params.fitted_params["param_2"][1],fitted_model_t_X_2params.fitted_params["param_2"])) + + # "Test if all residuals are being generated" + residuals_types = ["q_residuals", "std_residuals", "cs_residuals"] + @test(all(keys(fitted_model_t.residuals) .== residuals_types)) + @test(all(keys(fitted_model_t_2params.residuals) .== residuals_types)) + end - @info(" --- Test forecast function ---") - forecast_t = UnobservedComponentsGAS.predict(gas_model_t, fitted_model_t, y, steps_ahead, num_scenarious) - forecast_t_X = UnobservedComponentsGAS.predict(gas_model_t_X, fitted_model_t_X, y, X_t_forec, steps_ahead, num_scenarious) - forecast_t_2params = UnobservedComponentsGAS.predict(gas_model_t_2params, fitted_model_t_2params, y, steps_ahead, num_scenarious) + @testset " --- Test forecast function ---" begin + forecast_t = UnobservedComponentsGAS.predict(gas_model_t, fitted_model_t, y, steps_ahead, num_scenarious) + forecast_t_X = UnobservedComponentsGAS.predict(gas_model_t_X, fitted_model_t_X, y, X_t_forec, steps_ahead, num_scenarious) + forecast_t_2params = UnobservedComponentsGAS.predict(gas_model_t_2params, fitted_model_t_2params, y, steps_ahead, num_scenarious) - @test(isapprox(forecast_t["mean"], vec(mean(forecast_t["scenarios"], dims = 2)); rtol = 1e-3)) - @test(size(forecast_t["scenarios"]) == (steps_ahead, num_scenarious)) + @test(isapprox(forecast_t["mean"], vec(mean(forecast_t["scenarios"], dims = 2)); rtol = 1e-3)) + @test(size(forecast_t["scenarios"]) == (steps_ahead, num_scenarious)) - @test(isapprox(forecast_t["intervals"]["80"]["lower"], [quantile(forecast_t["scenarios"][t,:], 0.2/2) for t in 1:steps_ahead])) - @test(isapprox(forecast_t["intervals"]["80"]["upper"], [quantile(forecast_t["scenarios"][t,:], 1 - 0.2/2) for t in 1:steps_ahead])) - @test(isapprox(forecast_t["intervals"]["95"]["lower"], [quantile(forecast_t["scenarios"][t,:], 0.05/2) for t in 1:steps_ahead])) - @test(isapprox(forecast_t["intervals"]["95"]["upper"], [quantile(forecast_t["scenarios"][t,:], 1 - 0.05/2) for t in 1:steps_ahead])) + @test(isapprox(forecast_t["intervals"]["80"]["lower"], [quantile(forecast_t["scenarios"][t,:], 0.2/2) for t in 1:steps_ahead])) + @test(isapprox(forecast_t["intervals"]["80"]["upper"], [quantile(forecast_t["scenarios"][t,:], 1 - 0.2/2) for t in 1:steps_ahead])) + @test(isapprox(forecast_t["intervals"]["95"]["lower"], [quantile(forecast_t["scenarios"][t,:], 0.05/2) for t in 1:steps_ahead])) + @test(isapprox(forecast_t["intervals"]["95"]["upper"], [quantile(forecast_t["scenarios"][t,:], 1 - 0.05/2) for t in 1:steps_ahead])) - @test(isapprox(forecast_t_2params["mean"], vec(mean(forecast_t_2params["scenarios"], dims = 2)); rtol = 1e-3)) - @test(size(forecast_t_2params["scenarios"]) == (steps_ahead, num_scenarious)) + @test(isapprox(forecast_t_2params["mean"], vec(mean(forecast_t_2params["scenarios"], dims = 2)); rtol = 1e-3)) + @test(size(forecast_t_2params["scenarios"]) == (steps_ahead, num_scenarious)) - @test(isapprox(forecast_t_2params["intervals"]["80"]["lower"], [quantile(forecast_t_2params["scenarios"][t,:], 0.2/2) for t in 1:steps_ahead])) - @test(isapprox(forecast_t_2params["intervals"]["80"]["upper"], [quantile(forecast_t_2params["scenarios"][t,:], 1 - 0.2/2) for t in 1:steps_ahead])) - @test(isapprox(forecast_t_2params["intervals"]["95"]["lower"], [quantile(forecast_t_2params["scenarios"][t,:], 0.05/2) for t in 1:steps_ahead])) - @test(isapprox(forecast_t_2params["intervals"]["95"]["upper"], [quantile(forecast_t_2params["scenarios"][t,:], 1 - 0.05/2) for t in 1:steps_ahead])) + @test(isapprox(forecast_t_2params["intervals"]["80"]["lower"], [quantile(forecast_t_2params["scenarios"][t,:], 0.2/2) for t in 1:steps_ahead])) + @test(isapprox(forecast_t_2params["intervals"]["80"]["upper"], [quantile(forecast_t_2params["scenarios"][t,:], 1 - 0.2/2) for t in 1:steps_ahead])) + @test(isapprox(forecast_t_2params["intervals"]["95"]["lower"], [quantile(forecast_t_2params["scenarios"][t,:], 0.05/2) for t in 1:steps_ahead])) + @test(isapprox(forecast_t_2params["intervals"]["95"]["upper"], [quantile(forecast_t_2params["scenarios"][t,:], 1 - 0.05/2) for t in 1:steps_ahead])) - @test(isapprox(forecast_t_X["mean"], vec(mean(forecast_t_X["scenarios"], dims = 2)); rtol = 1e-3)) - @test(size(forecast_t_X["scenarios"]) == (steps_ahead, num_scenarious)) + @test(isapprox(forecast_t_X["mean"], vec(mean(forecast_t_X["scenarios"], dims = 2)); rtol = 1e-3)) + @test(size(forecast_t_X["scenarios"]) == (steps_ahead, num_scenarious)) - @test(isapprox(forecast_t_X["intervals"]["80"]["lower"], [quantile(forecast_t_X["scenarios"][t,:], 0.2/2) for t in 1:steps_ahead])) - @test(isapprox(forecast_t_X["intervals"]["80"]["upper"], [quantile(forecast_t_X["scenarios"][t,:], 1 - 0.2/2) for t in 1:steps_ahead])) - @test(isapprox(forecast_t_X["intervals"]["95"]["lower"], [quantile(forecast_t_X["scenarios"][t,:], 0.05/2) for t in 1:steps_ahead])) - @test(isapprox(forecast_t_X["intervals"]["95"]["upper"], [quantile(forecast_t_X["scenarios"][t,:], 1 - 0.05/2) for t in 1:steps_ahead])) + @test(isapprox(forecast_t_X["intervals"]["80"]["lower"], [quantile(forecast_t_X["scenarios"][t,:], 0.2/2) for t in 1:steps_ahead])) + @test(isapprox(forecast_t_X["intervals"]["80"]["upper"], [quantile(forecast_t_X["scenarios"][t,:], 1 - 0.2/2) for t in 1:steps_ahead])) + @test(isapprox(forecast_t_X["intervals"]["95"]["lower"], [quantile(forecast_t_X["scenarios"][t,:], 0.05/2) for t in 1:steps_ahead])) + @test(isapprox(forecast_t_X["intervals"]["95"]["upper"], [quantile(forecast_t_X["scenarios"][t,:], 1 - 0.05/2) for t in 1:steps_ahead])) + end - @info(" --- Test quality of fit and forecast - tDist") - y = time_series[1:end-steps_ahead,1] - y_test = time_series[end-steps_ahead+1:end, 1] + @testset " --- Test quality of fit and forecast - tDist" begin + y = time_series[1:end-steps_ahead,1] + y_test = time_series[end-steps_ahead+1:end, 1] - gas_model = UnobservedComponentsGAS.GASModel(UnobservedComponentsGAS.tLocationScaleDistribution(), [true, false, false], - 1.0, "random walk slope", "deterministic 12", missing) - fitted_model = UnobservedComponentsGAS.fit(gas_model, y) - forec = UnobservedComponentsGAS.predict(gas_model, fitted_model, y, steps_ahead, num_scenarious) + gas_model = UnobservedComponentsGAS.GASModel(UnobservedComponentsGAS.tLocationScaleDistribution(), [true, false, false], + 1.0, "random walk slope", "deterministic 12", missing) + fitted_model = UnobservedComponentsGAS.fit(gas_model, y) + forec = UnobservedComponentsGAS.predict(gas_model, fitted_model, y, steps_ahead, num_scenarious) - @test(isapprox(fitted_model.fit_in_sample[2:end], y[2:end]; rtol = 1e-2)) - @test(isapprox(forec["mean"], y_test; rtol = 1e2)) + @test(isapprox(fitted_model.fit_in_sample[2:end], y[2:end]; rtol = 1e-2)) + @test(isapprox(forec["mean"], y_test; rtol = 1e2)) + end - @info(" --- Test quality of fit - tDist with 2 params") + @testset " --- Test quality of fit - tDist with 2 params" begin - gas_model = UnobservedComponentsGAS.GASModel(UnobservedComponentsGAS.tLocationScaleDistribution(), [true, true, false], - 0.0, ["random walk slope", "random walk", ""], ["deterministic 12", "deterministic 12", ""], [missing, missing, missing]) - fitted_model = UnobservedComponentsGAS.fit(gas_model, y) - forec = UnobservedComponentsGAS.predict(gas_model, fitted_model, y, steps_ahead, num_scenarious) + gas_model = UnobservedComponentsGAS.GASModel(UnobservedComponentsGAS.tLocationScaleDistribution(), [true, true, false], + 0.0, ["random walk slope", "random walk", ""], ["deterministic 12", "deterministic 12", ""], [missing, missing, missing]) + fitted_model = UnobservedComponentsGAS.fit(gas_model, y) + forec = UnobservedComponentsGAS.predict(gas_model, fitted_model, y, steps_ahead, num_scenarious) - @test(isapprox(fitted_model.fit_in_sample[2:end], y[2:end]; rtol = 1e-1)) - @test(isapprox(forec["mean"], y_test; rtol = 1e2)) + @test(isapprox(fitted_model.fit_in_sample[2:end], y[2:end]; rtol = 1e-1)) + @test(isapprox(forec["mean"], y_test; rtol = 1e2)) + end - @info(" --- Test quality of fit - tDist with robust") - gas_model = UnobservedComponentsGAS.GASModel(UnobservedComponentsGAS.tLocationScaleDistribution(), [true, false, false], - 1.0, "random walk slope", "deterministic 12", 1) - fitted_model = UnobservedComponentsGAS.fit(gas_model, y; α = 0.0, robust = true) - forec = UnobservedComponentsGAS.predict(gas_model, fitted_model, y, steps_ahead, num_scenarious) + @testset " --- Test quality of fit - tDist with robust" begin + gas_model = UnobservedComponentsGAS.GASModel(UnobservedComponentsGAS.tLocationScaleDistribution(), [true, false, false], + 1.0, "random walk slope", "deterministic 12", 1) + fitted_model = UnobservedComponentsGAS.fit(gas_model, y; α = 0.0, robust = true) + forec = UnobservedComponentsGAS.predict(gas_model, fitted_model, y, steps_ahead, num_scenarious) - @test(isapprox(fitted_model.fit_in_sample[2:end], y[2:end]; rtol = 1e-1)) - @test(isapprox(forec["mean"], y_test; rtol = 1e2)) + @test(isapprox(fitted_model.fit_in_sample[2:end], y[2:end]; rtol = 1e-1)) + @test(isapprox(forec["mean"], y_test; rtol = 1e2)) + end end diff --git a/test/test_initialization.jl b/test/test_initialization.jl index 5c5b76f..62d56d1 100644 --- a/test/test_initialization.jl +++ b/test/test_initialization.jl @@ -7,331 +7,433 @@ X_missing = missing stochastic = false + @testset "structures" begin + params = + level = + seasonality = + ar = + gas_model = UnobservedComponentsGAS.GASModel(UnobservedComponentsGAS.NormalDistribution(), [true, false], + 0.5, ["random walk", "ar(1)"], + ["deterministic 12", "deterministic 12"], + [1, 1]) + @test(isempty(gas_model.seasonality[2])) + @test(isempty(gas_model.level[2])) + @test(ismissing(gas_model.ar[2])) + @test(!isempty(gas_model.seasonality[1])) + @test(!isempty(gas_model.level[1])) + @test(ismissing(gas_model.ar[1])) + end + + + + @testset "Test with Random Walk and Slope without AR and without explanatory" begin + order = [nothing] + max_order = 0 + has_level = true + has_slope = true + has_seasonality = true + has_ar1_level = false + seasonal_period = 12 + + initial_values_state_space = UnobservedComponentsGAS.define_state_space_model(y, (has_level || has_ar1_level), has_slope, has_seasonality, seasonal_period, stochastic) + initial_values = UnobservedComponentsGAS.get_initial_values(y, X_missing, has_level, has_ar1_level, has_slope, has_seasonality, seasonal_period, stochastic, order, max_order) + + @test(isapprox(initial_values["rws"]["values"], initial_values_state_space["level"]; rtol = 1e-3)) + @test(isapprox(initial_values["slope"]["values"], initial_values_state_space["slope"]; rtol = 1e-3)) + @test(isapprox(initial_values["seasonality"]["values"],initial_values_state_space["seasonality"]; rtol = 1e-3)) + @test(all(initial_values["seasonality"]["γ"] .== initial_values_state_space["γ"])) + @test(all(initial_values["seasonality"]["γ_star"] .== initial_values_state_space["γ_star"])) + @test(all(initial_values["ar"]["values"] .== zeros(T))) + @test(all(initial_values["rw"]["values"] .== zeros(T))) + end + + + @testset "Test with Random Walk with AR and without explanatory" begin + order = [1] + max_order = 2 + has_level = true + has_slope = false + has_ar1_level = false + has_seasonality = true + seasonal_period = 12 + + initial_values_state_space = UnobservedComponentsGAS.define_state_space_model(y, (has_level || has_ar1_level), has_slope, has_seasonality, seasonal_period, stochastic) + initial_values = UnobservedComponentsGAS.get_initial_values(y, X_missing, has_level, has_ar1_level, has_slope, has_seasonality, seasonal_period, stochastic, order, max_order) + + @test(isapprox(initial_values["rw"]["values"], initial_values_state_space["level"]; rtol = 1e-3)) + @test(isapprox(initial_values["slope"]["values"], initial_values_state_space["slope"]; rtol = 1e-3)) + @test(isapprox(initial_values["seasonality"]["values"],initial_values_state_space["seasonality"]; rtol = 1e-3)) + @test(all(initial_values["seasonality"]["γ"] .== initial_values_state_space["γ"])) + @test(all(initial_values["seasonality"]["γ_star"] .== initial_values_state_space["γ_star"])) + @test(all(initial_values["ar"]["values"] .!= zeros(T))) + @test(all(initial_values["rws"]["values"] .== zeros(T))) + end + + @testset "Test with just Seasonality without explanatory" begin + order = [nothing] + max_order = 0 + has_level = false + has_slope = false + has_ar1_level = false + has_seasonality = true + seasonal_period = 12 + + initial_values_state_space = UnobservedComponentsGAS.define_state_space_model(y, (has_level || has_ar1_level), has_slope, has_seasonality, seasonal_period, stochastic) + initial_values = UnobservedComponentsGAS.get_initial_values(y, X_missing, has_level, has_ar1_level, has_slope, has_seasonality, seasonal_period, stochastic, order, max_order) + + @test(isapprox(initial_values["seasonality"]["values"],initial_values_state_space["seasonality"]; rtol = 1e-3)) + @test(all(initial_values["seasonality"]["γ"] .== initial_values_state_space["γ"])) + @test(all(initial_values["seasonality"]["γ_star"] .== initial_values_state_space["γ_star"])) + @test(all(initial_values["rw"]["values"] .== zeros(T))) + @test(all(initial_values["slope"]["values"] .== zeros(T))) + @test(all(initial_values["ar"]["values"] .== zeros(T))) + @test(all(initial_values["rws"]["values"] .== zeros(T))) + end + + @testset "Test with Random Walk without seasonality and without explanatory" begin + order = [nothing] + max_order = 0 + has_level = true + has_slope = false + has_ar1_level = false + has_seasonality = false + seasonal_period = missing + + initial_values_state_space = UnobservedComponentsGAS.define_state_space_model(y, (has_level || has_ar1_level), has_slope, has_seasonality, seasonal_period, stochastic) + initial_values = UnobservedComponentsGAS.get_initial_values(y, X_missing, has_level, has_ar1_level, has_slope, has_seasonality, seasonal_period, stochastic, order, max_order) + + @test(isapprox(initial_values["rw"]["values"], initial_values_state_space["level"]; rtol = 1e-3)) + @test(isapprox(initial_values["slope"]["values"], initial_values_state_space["slope"]; rtol = 1e-3)) + @test(isapprox(initial_values["seasonality"]["values"],initial_values_state_space["seasonality"]; rtol = 1e-3)) + @test(all(initial_values["seasonality"]["γ"] .== initial_values_state_space["γ"])) + @test(all(initial_values["seasonality"]["γ_star"] .== initial_values_state_space["γ_star"])) + @test(all(initial_values["ar"]["values"] .== zeros(T))) + @test(all(initial_values["rws"]["values"] .== zeros(T))) + @test(all(initial_values["slope"]["values"] .== zeros(T))) + @test(all(initial_values["seasonality"]["values"] .== zeros(T))) + end + + @testset "Test with Random Walk Slope without seasonality and without explanatory" begin + order = [nothing] + max_order = 0 + has_level = true + has_slope = true + has_ar1_level = false + has_seasonality = false + seasonal_period = missing + + initial_values_state_space = UnobservedComponentsGAS.define_state_space_model(y, (has_level || has_ar1_level), has_slope, has_seasonality, seasonal_period, stochastic) + initial_values = UnobservedComponentsGAS.get_initial_values(y, X_missing, has_level, has_ar1_level, has_slope, has_seasonality, seasonal_period, stochastic, order, max_order) + + @test(isapprox(initial_values["rws"]["values"], initial_values_state_space["level"]; rtol = 1e-3)) + @test(isapprox(initial_values["slope"]["values"], initial_values_state_space["slope"]; rtol = 1e-3)) + @test(isapprox(initial_values["seasonality"]["values"],initial_values_state_space["seasonality"]; rtol = 1e-3)) + @test(all(initial_values["seasonality"]["γ"] .== initial_values_state_space["γ"])) + @test(all(initial_values["seasonality"]["γ_star"] .== initial_values_state_space["γ_star"])) + @test(all(initial_values["ar"]["values"] .== zeros(T))) + @test(all(initial_values["rw"]["values"] .== zeros(T))) + @test(all(initial_values["seasonality"]["values"] .== zeros(T))) + end + + @testset "Test with AR(1) with seasonality and without explanatory" begin + order = [nothing] + max_order = 0 + has_level = false + has_slope = false + has_ar1_level = true + has_seasonality = true + seasonal_period = 12 + + initial_values_state_space = UnobservedComponentsGAS.define_state_space_model(y, (has_level || has_ar1_level), has_slope, has_seasonality, seasonal_period, stochastic) + initial_values = UnobservedComponentsGAS.get_initial_values(y, X_missing, has_level, has_ar1_level, has_slope, has_seasonality, seasonal_period, stochastic, order, max_order) + + @test(isapprox(initial_values["ar1_level"]["values"], initial_values_state_space["level"]; rtol = 1e-3)) + @test(isapprox(initial_values["seasonality"]["values"],initial_values_state_space["seasonality"]; rtol = 1e-3)) + @test(all(initial_values["seasonality"]["γ"] .== initial_values_state_space["γ"])) + @test(all(initial_values["seasonality"]["γ_star"] .== initial_values_state_space["γ_star"])) + @test(all(initial_values["ar"]["values"] .== zeros(T))) + @test(all(initial_values["slope"]["values"] .== zeros(T))) + @test(all(initial_values["rw"]["values"] .== zeros(T))) + end + + + @testset "Test with Random Walk and Slope without AR and with explanatory" begin + stochastic = false + order = [nothing] + max_order = 0 + has_level = true + has_slope = true + has_ar1_level = false + has_seasonality = true + seasonal_period = 12 + + initial_values_state_space = UnobservedComponentsGAS.define_state_space_model(y, X, (has_level || has_ar1_level), has_slope, has_seasonality, seasonal_period, stochastic) + initial_values = UnobservedComponentsGAS.get_initial_values(y, X, has_level, has_ar1_level, has_slope, has_seasonality, seasonal_period, stochastic, order, max_order) + + @test(isapprox(initial_values["rws"]["values"], initial_values_state_space["level"]; rtol = 1e-3)) + @test(isapprox(initial_values["slope"]["values"], initial_values_state_space["slope"]; rtol = 1e-3)) + @test(isapprox(initial_values["seasonality"]["values"],initial_values_state_space["seasonality"]; rtol = 1e-3)) + @test(all(initial_values["seasonality"]["γ"] .== initial_values_state_space["γ"])) + @test(all(initial_values["seasonality"]["γ_star"] .== initial_values_state_space["γ_star"])) + @test(all(initial_values["ar"]["values"] .== zeros(T))) + @test(all(initial_values["rw"]["values"] .== zeros(T))) + @test(all(initial_values["explanatories"] .== initial_values_state_space["explanatory"])) + end + + @testset "Test with Random Walk with AR and with explanatory" begin + order = [1] + max_order = 2 + has_level = true + has_slope = false + has_ar1_level = false + has_seasonality = true + seasonal_period = 12 + + initial_values_state_space = UnobservedComponentsGAS.define_state_space_model(y, X, (has_level || has_ar1_level), has_slope, has_seasonality, seasonal_period, stochastic) + initial_values = UnobservedComponentsGAS.get_initial_values(y, X, has_level, has_ar1_level, has_slope, has_seasonality, seasonal_period, stochastic, order, max_order) + + @test(isapprox(initial_values["rw"]["values"], initial_values_state_space["level"]; rtol = 1e-3)) + @test(isapprox(initial_values["slope"]["values"], initial_values_state_space["slope"]; rtol = 1e-3)) + @test(isapprox(initial_values["seasonality"]["values"],initial_values_state_space["seasonality"]; rtol = 1e-3)) + @test(all(initial_values["seasonality"]["γ"] .== initial_values_state_space["γ"])) + @test(all(initial_values["seasonality"]["γ_star"] .== initial_values_state_space["γ_star"])) + @test(all(initial_values["ar"]["values"] .!= zeros(T))) + @test(all(initial_values["rws"]["values"] .== zeros(T))) + @test(all(initial_values["explanatories"] .== initial_values_state_space["explanatory"])) + end + + @testset "Test with just Seasonality with explanatory" begin + order = [nothing] + max_order = 0 + has_level = false + has_slope = false + has_ar1_level = false + has_seasonality = true + seasonal_period = 12 + + initial_values_state_space = UnobservedComponentsGAS.define_state_space_model(y, X, (has_level || has_ar1_level), has_slope, has_seasonality, seasonal_period, stochastic) + initial_values = UnobservedComponentsGAS.get_initial_values(y, X, has_level, has_ar1_level, has_slope, has_seasonality, seasonal_period, stochastic, order, max_order) + + @test(isapprox(initial_values["seasonality"]["values"],initial_values_state_space["seasonality"]; rtol = 1e-3)) + @test(all(initial_values["seasonality"]["γ"] .== initial_values_state_space["γ"])) + @test(all(initial_values["seasonality"]["γ_star"] .== initial_values_state_space["γ_star"])) + @test(all(initial_values["rw"]["values"] .== zeros(T))) + @test(all(initial_values["slope"]["values"] .== zeros(T))) + @test(all(initial_values["ar"]["values"] .== zeros(T))) + @test(all(initial_values["rws"]["values"] .== zeros(T))) + @test(all(initial_values["explanatories"] .== initial_values_state_space["explanatory"])) + end + + @testset "Test with Random Walk without seasonality and without explanatory" begin + order = [nothing] + max_order = 0 + has_level = true + has_slope = false + has_ar1_level = false + has_seasonality = false + seasonal_period = missing + + initial_values_state_space = UnobservedComponentsGAS.define_state_space_model(y, X, (has_level || has_ar1_level), has_slope, has_seasonality, seasonal_period, stochastic) + initial_values = UnobservedComponentsGAS.get_initial_values(y, X, has_level, has_ar1_level, has_slope, has_seasonality, seasonal_period, stochastic, order, max_order) + + @test(isapprox(initial_values["rw"]["values"], initial_values_state_space["level"]; rtol = 1e-3)) + @test(isapprox(initial_values["slope"]["values"], initial_values_state_space["slope"]; rtol = 1e-3)) + @test(isapprox(initial_values["seasonality"]["values"],initial_values_state_space["seasonality"]; rtol = 1e-3)) + @test(all(initial_values["seasonality"]["γ"] .== initial_values_state_space["γ"])) + @test(all(initial_values["seasonality"]["γ_star"] .== initial_values_state_space["γ_star"])) + @test(all(initial_values["ar"]["values"] .== zeros(T))) + @test(all(initial_values["rws"]["values"] .== zeros(T))) + @test(all(initial_values["slope"]["values"] .== zeros(T))) + @test(all(initial_values["seasonality"]["values"] .== zeros(T))) + @test(all(initial_values["explanatories"] .== initial_values_state_space["explanatory"])) + end + + + @testset "Test with Random Walk Slope without seasonality and without explanatory" begin + order = [nothing] + max_order = 0 + has_level = true + has_slope = true + has_ar1_level = false + has_seasonality = false + seasonal_period = missing + + initial_values_state_space = UnobservedComponentsGAS.define_state_space_model(y, X, (has_level || has_ar1_level), has_slope, has_seasonality, seasonal_period, stochastic) + initial_values = UnobservedComponentsGAS.get_initial_values(y, X, has_level, has_ar1_level, has_slope, has_seasonality, seasonal_period, stochastic, order, max_order) + + @test(isapprox(initial_values["rws"]["values"], initial_values_state_space["level"]; rtol = 1e-3)) + @test(isapprox(initial_values["slope"]["values"], initial_values_state_space["slope"]; rtol = 1e-3)) + @test(isapprox(initial_values["seasonality"]["values"],initial_values_state_space["seasonality"]; rtol = 1e-3)) + @test(all(initial_values["seasonality"]["γ"] .== initial_values_state_space["γ"])) + @test(all(initial_values["seasonality"]["γ_star"] .== initial_values_state_space["γ_star"])) + @test(all(initial_values["ar"]["values"] .== zeros(T))) + @test(all(initial_values["rw"]["values"] .== zeros(T))) + @test(all(initial_values["seasonality"]["values"] .== zeros(T))) + @test(all(initial_values["explanatories"] .== initial_values_state_space["explanatory"])) + end + + + @testset "Test with AR(1) without seasonality and without explanatory" begin + order = [nothing] + max_order = 0 + has_level = false + has_slope = false + has_ar1_level = true + has_seasonality = false + seasonal_period = missing + + initial_values_state_space = UnobservedComponentsGAS.define_state_space_model(y, (has_level || has_ar1_level), has_slope, has_seasonality, seasonal_period, stochastic) + initial_values = UnobservedComponentsGAS.get_initial_values(y, X_missing, has_level, has_ar1_level, has_slope, has_seasonality, seasonal_period, stochastic, order, max_order) + + @test(isapprox(initial_values["ar1_level"]["values"], initial_values_state_space["level"]; rtol = 1e-3)) + @test(isapprox(initial_values["seasonality"]["values"],initial_values_state_space["seasonality"]; rtol = 1e-3)) + @test(all(initial_values["seasonality"]["γ"] .== initial_values_state_space["γ"])) + @test(all(initial_values["seasonality"]["γ_star"] .== initial_values_state_space["γ_star"])) + @test(all(initial_values["ar"]["values"] .== zeros(T))) + @test(all(initial_values["slope"]["values"] .== zeros(T))) + @test(all(initial_values["rw"]["values"] .== zeros(T))) + end + + @testset "Test with AR(1) without seasonality and with explanatory" begin + order = [nothing] + max_order = 0 + has_level = false + has_slope = false + has_ar1_level = true + has_seasonality = false + seasonal_period = missing + + initial_values_state_space = UnobservedComponentsGAS.define_state_space_model(y, X, (has_level || has_ar1_level), has_slope, has_seasonality, seasonal_period, stochastic) + initial_values = UnobservedComponentsGAS.get_initial_values(y, X, has_level, has_ar1_level, has_slope, has_seasonality, seasonal_period, stochastic, order, max_order) + + @test(isapprox(initial_values["ar1_level"]["values"], initial_values_state_space["level"]; rtol = 1e-3)) + @test(isapprox(initial_values["seasonality"]["values"],initial_values_state_space["seasonality"]; rtol = 1e-3)) + @test(all(initial_values["seasonality"]["γ"] .== initial_values_state_space["γ"])) + @test(all(initial_values["seasonality"]["γ_star"] .== initial_values_state_space["γ_star"])) + @test(all(initial_values["ar"]["values"] .== zeros(T))) + @test(all(initial_values["slope"]["values"] .== zeros(T))) + @test(all(initial_values["rw"]["values"] .== zeros(T))) + @test(all(initial_values["explanatories"] .== initial_values_state_space["explanatory"])) + end + + + @testset "Test with AR(1) with seasonality and with explanatory" begin + order = [nothing] + max_order = 0 + has_level = false + has_slope = false + has_ar1_level = true + has_seasonality = true + seasonal_period = 12 + + initial_values_state_space = UnobservedComponentsGAS.define_state_space_model(y, X, (has_level || has_ar1_level), has_slope, has_seasonality, seasonal_period, stochastic) + initial_values = UnobservedComponentsGAS.get_initial_values(y, X, has_level, has_ar1_level, has_slope, has_seasonality, seasonal_period, stochastic, order, max_order) + + @test(isapprox(initial_values["ar1_level"]["values"], initial_values_state_space["level"]; rtol = 1e-3)) + @test(isapprox(initial_values["seasonality"]["values"],initial_values_state_space["seasonality"]; rtol = 1e-3)) + @test(all(initial_values["seasonality"]["γ"] .== initial_values_state_space["γ"])) + @test(all(initial_values["seasonality"]["γ_star"] .== initial_values_state_space["γ_star"])) + @test(all(initial_values["ar"]["values"] .== zeros(T))) + @test(all(initial_values["slope"]["values"] .== zeros(T))) + @test(all(initial_values["rw"]["values"] .== zeros(T))) + @test(all(initial_values["explanatories"] .== initial_values_state_space["explanatory"])) + end + + @testset "Test no seasonality" begin + order = [nothing] + max_order = 0 + has_level = true + has_slope = false + has_ar1_level = true + has_seasonality = false + seasonal_period = missing + + initial_values_state_space = UnobservedComponentsGAS.define_state_space_model(y, X, (has_level || has_ar1_level), has_slope, has_seasonality, seasonal_period, stochastic) + initial_values = UnobservedComponentsGAS.get_initial_values(y, X, has_level, has_ar1_level, has_slope, has_seasonality, seasonal_period, stochastic, order, max_order) + + @test(isapprox(initial_values["ar1_level"]["values"], initial_values_state_space["level"]; rtol = 1e-3)) + @test(isapprox(initial_values["seasonality"]["values"],initial_values_state_space["seasonality"]; rtol = 1e-3)) + @test(all(initial_values["seasonality"]["γ"] .== initial_values_state_space["γ"])) + @test(all(initial_values["seasonality"]["γ_star"] .== initial_values_state_space["γ_star"])) + @test(all(initial_values["seasonality"]["values"] .== zeros(T))) + @test(all(initial_values["ar1"]["values"] .== zeros(T))) + @test(all(initial_values["slope"]["values"] .== zeros(T))) + @test(all(initial_values["rw"]["values"] .== zeros(T))) + @test(all(initial_values["explanatories"] .== initial_values_state_space["explanatory"])) + end + + @testset "Test stochastic seasonality" begin + order = [nothing] + max_order = 0 + has_level = true + has_slope = false + has_ar1_level = true + has_seasonality = true + seasonal_period = 12 + + initial_values_state_space = UnobservedComponentsGAS.define_state_space_model(y, X, (has_level || has_ar1_level), has_slope, has_seasonality, seasonal_period, stochastic) + init_γ, init_γ_star = UnobservedComponentsGAS.fit_harmonics(initial_values_state_space["seasonality"], seasonal_period, true) + initial_values = UnobservedComponentsGAS.get_initial_values(y, X, has_level, has_ar1_level, has_slope, has_seasonality, seasonal_period, true, order, max_order) + + @test(isapprox(initial_values["ar1_level"]["values"], initial_values_state_space["level"]; rtol = 1e-3)) + @test(isapprox(initial_values["seasonality"]["values"],initial_values_state_space["seasonality"]; rtol = 1e-3)) + @test(all(initial_values["seasonality"]["γ"] .== init_γ)) + @test(all(initial_values["seasonality"]["γ_star"] .== init_γ_star)) + @test(all(initial_values["slope"]["values"] .== zeros(T))) + @test(all(initial_values["rw"]["values"] .== zeros(T))) + @test(all(initial_values["explanatories"] .== initial_values_state_space["explanatory"])) + end + + @testset "Just AR(p)" begin + order = [1,2] + max_order = 2 + has_level = false + has_slope = false + has_ar1_level = false + has_seasonality = false + seasonal_period = missing + + initial_values_ar = UnobservedComponentsGAS.fit_AR_model(y, order) + initial_values = UnobservedComponentsGAS.get_initial_values(y, missing, has_level, has_ar1_level, has_slope, has_seasonality, seasonal_period, true, order, max_order) + + @test(all(initial_values["ar"]["values"] .== initial_values_ar[1])) + @test(all(initial_values["ar"]["ϕ"] .== initial_values_ar[2])) + @test(all(initial_values["ar"]["values"] .== initial_values_ar[1])) + @test(all(initial_values["slope"]["values"] .== zeros(T))) + @test(all(initial_values["rw"]["values"] .== zeros(T))) + @test(all(initial_values["rws"]["values"] .== zeros(T))) + @test(isapprox(initial_values["ar1_level"]["values"], zeros(T))) + @test(all(initial_values["seasonality"]["values"] .== zeros(T))) + + end + + @testset "Test create_output_initialization_from_fit" begin + dist = UnobservedComponentsGAS.NormalDistribution() + gas_model = UnobservedComponentsGAS.GASModel(dist, [true, false], 0.0, "random walk slope", "deterministic 12", 1) + + fitted_model = UnobservedComponentsGAS.fit(gas_model, y) + output_initial_values = UnobservedComponentsGAS.create_output_initialization_from_fit(fitted_model, gas_model) + + @test(all(output_initial_values["rw"]["values"] .== 0)) + @test(all(output_initial_values["seasonality"]["values"] .!= 0)) + @test(all(output_initial_values["ar"]["values"] .!= 0)) + @test(all(output_initial_values["slope"]["values"] .!= zeros(T))) + @test(all(output_initial_values["rws"]["values"] .!= zeros(T))) + + dist = UnobservedComponentsGAS.NormalDistribution() + gas_model = UnobservedComponentsGAS.GASModel(dist, [true, true], 0.0, ["random walk slope", "random walk"], + ["deterministic 12", "deterministic 12"], [missing, missing]) + fitted_model = UnobservedComponentsGAS.fit(gas_model, y) + output_initial_values = UnobservedComponentsGAS.create_output_initialization_from_fit(fitted_model, gas_model) + + @test(all(output_initial_values["rw"]["values"][:,1] .== 0)) + #@test(all(output_initial_values["rw"]["values"][:,2] .!= 0)) + @test(all(output_initial_values["seasonality"]["values"] .!= 0)) + @test(all(output_initial_values["ar"]["values"] .== 0)) + @test(all(output_initial_values["slope"]["values"] .!= 0)) + @test(all(output_initial_values["rws"]["values"] .!= 0)) + end - @info("Test with Random Walk and Slope without AR and without explanatory") - order = [nothing] - max_order = 0 - has_level = true - has_slope = true - has_seasonality = true - has_ar1_level = false - seasonal_period = 12 - - initial_values_state_space = UnobservedComponentsGAS.define_state_space_model(y, (has_level || has_ar1_level), has_slope, has_seasonality, seasonal_period, stochastic) - initial_values = UnobservedComponentsGAS.get_initial_values(y, X_missing, has_level, has_ar1_level, has_slope, has_seasonality, seasonal_period, stochastic, order, max_order) - - @test(isapprox(initial_values["rws"]["values"], initial_values_state_space["level"]; rtol = 1e-3)) - @test(isapprox(initial_values["slope"]["values"], initial_values_state_space["slope"]; rtol = 1e-3)) - @test(isapprox(initial_values["seasonality"]["values"],initial_values_state_space["seasonality"]; rtol = 1e-3)) - @test(all(initial_values["seasonality"]["γ"] .== initial_values_state_space["γ"])) - @test(all(initial_values["seasonality"]["γ_star"] .== initial_values_state_space["γ_star"])) - @test(all(initial_values["ar"]["values"] .== zeros(T))) - @test(all(initial_values["rw"]["values"] .== zeros(T))) - - - @info("Test with Random Walk with AR and without explanatory") - order = [1] - max_order = 2 - has_level = true - has_slope = false - has_ar1_level = false - has_seasonality = true - seasonal_period = 12 - - initial_values_state_space = UnobservedComponentsGAS.define_state_space_model(y, (has_level || has_ar1_level), has_slope, has_seasonality, seasonal_period, stochastic) - initial_values = UnobservedComponentsGAS.get_initial_values(y, X_missing, has_level, has_ar1_level, has_slope, has_seasonality, seasonal_period, stochastic, order, max_order) - - @test(isapprox(initial_values["rw"]["values"], initial_values_state_space["level"]; rtol = 1e-3)) - @test(isapprox(initial_values["slope"]["values"], initial_values_state_space["slope"]; rtol = 1e-3)) - @test(isapprox(initial_values["seasonality"]["values"],initial_values_state_space["seasonality"]; rtol = 1e-3)) - @test(all(initial_values["seasonality"]["γ"] .== initial_values_state_space["γ"])) - @test(all(initial_values["seasonality"]["γ_star"] .== initial_values_state_space["γ_star"])) - @test(all(initial_values["ar"]["values"] .!= zeros(T))) - @test(all(initial_values["rws"]["values"] .== zeros(T))) - - @info("Test with just Seasonality without explanatory") - order = [nothing] - max_order = 0 - has_level = false - has_slope = false - has_ar1_level = false - has_seasonality = true - seasonal_period = 12 - - initial_values_state_space = UnobservedComponentsGAS.define_state_space_model(y, (has_level || has_ar1_level), has_slope, has_seasonality, seasonal_period, stochastic) - initial_values = UnobservedComponentsGAS.get_initial_values(y, X_missing, has_level, has_ar1_level, has_slope, has_seasonality, seasonal_period, stochastic, order, max_order) - - @test(isapprox(initial_values["seasonality"]["values"],initial_values_state_space["seasonality"]; rtol = 1e-3)) - @test(all(initial_values["seasonality"]["γ"] .== initial_values_state_space["γ"])) - @test(all(initial_values["seasonality"]["γ_star"] .== initial_values_state_space["γ_star"])) - @test(all(initial_values["rw"]["values"] .== zeros(T))) - @test(all(initial_values["slope"]["values"] .== zeros(T))) - @test(all(initial_values["ar"]["values"] .== zeros(T))) - @test(all(initial_values["rws"]["values"] .== zeros(T))) - - @info("Test with Random Walk without seasonality and without explanatory") - order = [nothing] - max_order = 0 - has_level = true - has_slope = false - has_ar1_level = false - has_seasonality = false - seasonal_period = missing - - initial_values_state_space = UnobservedComponentsGAS.define_state_space_model(y, (has_level || has_ar1_level), has_slope, has_seasonality, seasonal_period, stochastic) - initial_values = UnobservedComponentsGAS.get_initial_values(y, X_missing, has_level, has_ar1_level, has_slope, has_seasonality, seasonal_period, stochastic, order, max_order) - - @test(isapprox(initial_values["rw"]["values"], initial_values_state_space["level"]; rtol = 1e-3)) - @test(isapprox(initial_values["slope"]["values"], initial_values_state_space["slope"]; rtol = 1e-3)) - @test(isapprox(initial_values["seasonality"]["values"],initial_values_state_space["seasonality"]; rtol = 1e-3)) - @test(all(initial_values["seasonality"]["γ"] .== initial_values_state_space["γ"])) - @test(all(initial_values["seasonality"]["γ_star"] .== initial_values_state_space["γ_star"])) - @test(all(initial_values["ar"]["values"] .== zeros(T))) - @test(all(initial_values["rws"]["values"] .== zeros(T))) - @test(all(initial_values["slope"]["values"] .== zeros(T))) - @test(all(initial_values["seasonality"]["values"] .== zeros(T))) - - @info("Test with Random Walk Slope without seasonality and without explanatory") - order = [nothing] - max_order = 0 - has_level = true - has_slope = true - has_ar1_level = false - has_seasonality = false - seasonal_period = missing - - initial_values_state_space = UnobservedComponentsGAS.define_state_space_model(y, (has_level || has_ar1_level), has_slope, has_seasonality, seasonal_period, stochastic) - initial_values = UnobservedComponentsGAS.get_initial_values(y, X_missing, has_level, has_ar1_level, has_slope, has_seasonality, seasonal_period, stochastic, order, max_order) - - @test(isapprox(initial_values["rws"]["values"], initial_values_state_space["level"]; rtol = 1e-3)) - @test(isapprox(initial_values["slope"]["values"], initial_values_state_space["slope"]; rtol = 1e-3)) - @test(isapprox(initial_values["seasonality"]["values"],initial_values_state_space["seasonality"]; rtol = 1e-3)) - @test(all(initial_values["seasonality"]["γ"] .== initial_values_state_space["γ"])) - @test(all(initial_values["seasonality"]["γ_star"] .== initial_values_state_space["γ_star"])) - @test(all(initial_values["ar"]["values"] .== zeros(T))) - @test(all(initial_values["rw"]["values"] .== zeros(T))) - @test(all(initial_values["seasonality"]["values"] .== zeros(T))) - - @info("Test with AR(1) with seasonality and without explanatory") - order = [nothing] - max_order = 0 - has_level = false - has_slope = false - has_ar1_level = true - has_seasonality = true - seasonal_period = 12 - - initial_values_state_space = UnobservedComponentsGAS.define_state_space_model(y, (has_level || has_ar1_level), has_slope, has_seasonality, seasonal_period, stochastic) - initial_values = UnobservedComponentsGAS.get_initial_values(y, X_missing, has_level, has_ar1_level, has_slope, has_seasonality, seasonal_period, stochastic, order, max_order) - - @test(isapprox(initial_values["ar1_level"]["values"], initial_values_state_space["level"]; rtol = 1e-3)) - @test(isapprox(initial_values["seasonality"]["values"],initial_values_state_space["seasonality"]; rtol = 1e-3)) - @test(all(initial_values["seasonality"]["γ"] .== initial_values_state_space["γ"])) - @test(all(initial_values["seasonality"]["γ_star"] .== initial_values_state_space["γ_star"])) - @test(all(initial_values["ar"]["values"] .== zeros(T))) - @test(all(initial_values["slope"]["values"] .== zeros(T))) - @test(all(initial_values["rw"]["values"] .== zeros(T))) - - - @info("Test with Random Walk and Slope without AR and with explanatory") - stochastic = false - order = [nothing] - max_order = 0 - has_level = true - has_slope = true - has_ar1_level = false - has_seasonality = true - seasonal_period = 12 - - initial_values_state_space = UnobservedComponentsGAS.define_state_space_model(y, X, (has_level || has_ar1_level), has_slope, has_seasonality, seasonal_period, stochastic) - initial_values = UnobservedComponentsGAS.get_initial_values(y, X, has_level, has_ar1_level, has_slope, has_seasonality, seasonal_period, stochastic, order, max_order) - - @test(isapprox(initial_values["rws"]["values"], initial_values_state_space["level"]; rtol = 1e-3)) - @test(isapprox(initial_values["slope"]["values"], initial_values_state_space["slope"]; rtol = 1e-3)) - @test(isapprox(initial_values["seasonality"]["values"],initial_values_state_space["seasonality"]; rtol = 1e-3)) - @test(all(initial_values["seasonality"]["γ"] .== initial_values_state_space["γ"])) - @test(all(initial_values["seasonality"]["γ_star"] .== initial_values_state_space["γ_star"])) - @test(all(initial_values["ar"]["values"] .== zeros(T))) - @test(all(initial_values["rw"]["values"] .== zeros(T))) - @test(all(initial_values["explanatories"] .== initial_values_state_space["explanatory"])) - - @info("Test with Random Walk with AR and with explanatory") - order = [1] - max_order = 2 - has_level = true - has_slope = false - has_ar1_level = false - has_seasonality = true - seasonal_period = 12 - - initial_values_state_space = UnobservedComponentsGAS.define_state_space_model(y, X, (has_level || has_ar1_level), has_slope, has_seasonality, seasonal_period, stochastic) - initial_values = UnobservedComponentsGAS.get_initial_values(y, X, has_level, has_ar1_level, has_slope, has_seasonality, seasonal_period, stochastic, order, max_order) - - @test(isapprox(initial_values["rw"]["values"], initial_values_state_space["level"]; rtol = 1e-3)) - @test(isapprox(initial_values["slope"]["values"], initial_values_state_space["slope"]; rtol = 1e-3)) - @test(isapprox(initial_values["seasonality"]["values"],initial_values_state_space["seasonality"]; rtol = 1e-3)) - @test(all(initial_values["seasonality"]["γ"] .== initial_values_state_space["γ"])) - @test(all(initial_values["seasonality"]["γ_star"] .== initial_values_state_space["γ_star"])) - @test(all(initial_values["ar"]["values"] .!= zeros(T))) - @test(all(initial_values["rws"]["values"] .== zeros(T))) - @test(all(initial_values["explanatories"] .== initial_values_state_space["explanatory"])) - - @info("Test with just Seasonality with explanatory") - order = [nothing] - max_order = 0 - has_level = false - has_slope = false - has_ar1_level = false - has_seasonality = true - seasonal_period = 12 - - initial_values_state_space = UnobservedComponentsGAS.define_state_space_model(y, X, (has_level || has_ar1_level), has_slope, has_seasonality, seasonal_period, stochastic) - initial_values = UnobservedComponentsGAS.get_initial_values(y, X, has_level, has_ar1_level, has_slope, has_seasonality, seasonal_period, stochastic, order, max_order) - - @test(isapprox(initial_values["seasonality"]["values"],initial_values_state_space["seasonality"]; rtol = 1e-3)) - @test(all(initial_values["seasonality"]["γ"] .== initial_values_state_space["γ"])) - @test(all(initial_values["seasonality"]["γ_star"] .== initial_values_state_space["γ_star"])) - @test(all(initial_values["rw"]["values"] .== zeros(T))) - @test(all(initial_values["slope"]["values"] .== zeros(T))) - @test(all(initial_values["ar"]["values"] .== zeros(T))) - @test(all(initial_values["rws"]["values"] .== zeros(T))) - @test(all(initial_values["explanatories"] .== initial_values_state_space["explanatory"])) - - @info("Test with Random Walk without seasonality and without explanatory") - order = [nothing] - max_order = 0 - has_level = true - has_slope = false - has_ar1_level = false - has_seasonality = false - seasonal_period = missing - - initial_values_state_space = UnobservedComponentsGAS.define_state_space_model(y, X, (has_level || has_ar1_level), has_slope, has_seasonality, seasonal_period, stochastic) - initial_values = UnobservedComponentsGAS.get_initial_values(y, X, has_level, has_ar1_level, has_slope, has_seasonality, seasonal_period, stochastic, order, max_order) - - @test(isapprox(initial_values["rw"]["values"], initial_values_state_space["level"]; rtol = 1e-3)) - @test(isapprox(initial_values["slope"]["values"], initial_values_state_space["slope"]; rtol = 1e-3)) - @test(isapprox(initial_values["seasonality"]["values"],initial_values_state_space["seasonality"]; rtol = 1e-3)) - @test(all(initial_values["seasonality"]["γ"] .== initial_values_state_space["γ"])) - @test(all(initial_values["seasonality"]["γ_star"] .== initial_values_state_space["γ_star"])) - @test(all(initial_values["ar"]["values"] .== zeros(T))) - @test(all(initial_values["rws"]["values"] .== zeros(T))) - @test(all(initial_values["slope"]["values"] .== zeros(T))) - @test(all(initial_values["seasonality"]["values"] .== zeros(T))) - @test(all(initial_values["explanatories"] .== initial_values_state_space["explanatory"])) - - - @info("Test with Random Walk Slope without seasonality and without explanatory") - order = [nothing] - max_order = 0 - has_level = true - has_slope = true - has_ar1_level = false - has_seasonality = false - seasonal_period = missing - - initial_values_state_space = UnobservedComponentsGAS.define_state_space_model(y, X, (has_level || has_ar1_level), has_slope, has_seasonality, seasonal_period, stochastic) - initial_values = UnobservedComponentsGAS.get_initial_values(y, X, has_level, has_ar1_level, has_slope, has_seasonality, seasonal_period, stochastic, order, max_order) - - @test(isapprox(initial_values["rws"]["values"], initial_values_state_space["level"]; rtol = 1e-3)) - @test(isapprox(initial_values["slope"]["values"], initial_values_state_space["slope"]; rtol = 1e-3)) - @test(isapprox(initial_values["seasonality"]["values"],initial_values_state_space["seasonality"]; rtol = 1e-3)) - @test(all(initial_values["seasonality"]["γ"] .== initial_values_state_space["γ"])) - @test(all(initial_values["seasonality"]["γ_star"] .== initial_values_state_space["γ_star"])) - @test(all(initial_values["ar"]["values"] .== zeros(T))) - @test(all(initial_values["rw"]["values"] .== zeros(T))) - @test(all(initial_values["seasonality"]["values"] .== zeros(T))) - @test(all(initial_values["explanatories"] .== initial_values_state_space["explanatory"])) - - - @info("Test with AR(1) without seasonality and without explanatory") - order = [nothing] - max_order = 0 - has_level = false - has_slope = false - has_ar1_level = true - has_seasonality = false - seasonal_period = missing - - initial_values_state_space = UnobservedComponentsGAS.define_state_space_model(y, (has_level || has_ar1_level), has_slope, has_seasonality, seasonal_period, stochastic) - initial_values = UnobservedComponentsGAS.get_initial_values(y, X_missing, has_level, has_ar1_level, has_slope, has_seasonality, seasonal_period, stochastic, order, max_order) - - @test(isapprox(initial_values["ar1_level"]["values"], initial_values_state_space["level"]; rtol = 1e-3)) - @test(isapprox(initial_values["seasonality"]["values"],initial_values_state_space["seasonality"]; rtol = 1e-3)) - @test(all(initial_values["seasonality"]["γ"] .== initial_values_state_space["γ"])) - @test(all(initial_values["seasonality"]["γ_star"] .== initial_values_state_space["γ_star"])) - @test(all(initial_values["ar"]["values"] .== zeros(T))) - @test(all(initial_values["slope"]["values"] .== zeros(T))) - @test(all(initial_values["rw"]["values"] .== zeros(T))) - - @info("Test with AR(1) without seasonality and with explanatory") - order = [nothing] - max_order = 0 - has_level = false - has_slope = false - has_ar1_level = true - has_seasonality = false - seasonal_period = missing - - initial_values_state_space = UnobservedComponentsGAS.define_state_space_model(y, X, (has_level || has_ar1_level), has_slope, has_seasonality, seasonal_period, stochastic) - initial_values = UnobservedComponentsGAS.get_initial_values(y, X, has_level, has_ar1_level, has_slope, has_seasonality, seasonal_period, stochastic, order, max_order) - - @test(isapprox(initial_values["ar1_level"]["values"], initial_values_state_space["level"]; rtol = 1e-3)) - @test(isapprox(initial_values["seasonality"]["values"],initial_values_state_space["seasonality"]; rtol = 1e-3)) - @test(all(initial_values["seasonality"]["γ"] .== initial_values_state_space["γ"])) - @test(all(initial_values["seasonality"]["γ_star"] .== initial_values_state_space["γ_star"])) - @test(all(initial_values["ar"]["values"] .== zeros(T))) - @test(all(initial_values["slope"]["values"] .== zeros(T))) - @test(all(initial_values["rw"]["values"] .== zeros(T))) - @test(all(initial_values["explanatories"] .== initial_values_state_space["explanatory"])) - @info("Test with AR(1) with seasonality and with explanatory") - order = [nothing] - max_order = 0 - has_level = false - has_slope = false - has_ar1_level = true - has_seasonality = true - seasonal_period = 12 - - initial_values_state_space = UnobservedComponentsGAS.define_state_space_model(y, X, (has_level || has_ar1_level), has_slope, has_seasonality, seasonal_period, stochastic) - initial_values = UnobservedComponentsGAS.get_initial_values(y, X, has_level, has_ar1_level, has_slope, has_seasonality, seasonal_period, stochastic, order, max_order) - - @test(isapprox(initial_values["ar1_level"]["values"], initial_values_state_space["level"]; rtol = 1e-3)) - @test(isapprox(initial_values["seasonality"]["values"],initial_values_state_space["seasonality"]; rtol = 1e-3)) - @test(all(initial_values["seasonality"]["γ"] .== initial_values_state_space["γ"])) - @test(all(initial_values["seasonality"]["γ_star"] .== initial_values_state_space["γ_star"])) - @test(all(initial_values["ar"]["values"] .== zeros(T))) - @test(all(initial_values["slope"]["values"] .== zeros(T))) - @test(all(initial_values["rw"]["values"] .== zeros(T))) - @test(all(initial_values["explanatories"] .== initial_values_state_space["explanatory"])) - - - @info("Test create_output_initialization_from_fit") - dist = UnobservedComponentsGAS.NormalDistribution() - gas_model = UnobservedComponentsGAS.GASModel(dist, [true, false], 0.0, "random walk slope", "deterministic 12", 1) - - fitted_model = UnobservedComponentsGAS.fit(gas_model, y) - output_initial_values = UnobservedComponentsGAS.create_output_initialization_from_fit(fitted_model, gas_model) - - @test(all(output_initial_values["rw"]["values"] .== 0)) - @test(all(output_initial_values["seasonality"]["values"] .!= 0)) - @test(all(output_initial_values["ar"]["values"] .!= 0)) - @test(all(output_initial_values["slope"]["values"] .!= zeros(T))) - @test(all(output_initial_values["rws"]["values"] .!= zeros(T))) - - dist = UnobservedComponentsGAS.NormalDistribution() - gas_model = UnobservedComponentsGAS.GASModel(dist, [true, true], 0.0, ["random walk slope", "random walk"], - ["deterministic 12", "deterministic 12"], [missing, missing]) - fitted_model = UnobservedComponentsGAS.fit(gas_model, y) - output_initial_values = UnobservedComponentsGAS.create_output_initialization_from_fit(fitted_model, gas_model) - - @test(all(output_initial_values["rw"]["values"][:,1] .== 0)) - #@test(all(output_initial_values["rw"]["values"][:,2] .!= 0)) - @test(all(output_initial_values["seasonality"]["values"] .!= 0)) - @test(all(output_initial_values["ar"]["values"] .== 0)) - @test(all(output_initial_values["slope"]["values"] .!= 0)) - @test(all(output_initial_values["rws"]["values"] .!= 0)) - end \ No newline at end of file diff --git a/test/test_optimization.jl b/test/test_optimization.jl index 59bc034..c76edd8 100644 --- a/test/test_optimization.jl +++ b/test/test_optimization.jl @@ -3,49 +3,53 @@ T = 100 # Test include_parameters for Normal Distribution case 1 - time_varying_params = [true, true] - dist = UnobservedComponentsGAS.NormalDistribution() - model = JuMP.Model(Ipopt.Optimizer) - params = UnobservedComponentsGAS.include_parameters(model, time_varying_params, T, dist, missing) - @test(size(params) == (T, 2)) - @test(sum((occursin.("fixed", JuMP.name.(params[:,1])))) == 0) - @test(sum((occursin.("fixed", JuMP.name.(params[:,2])))) == 0) + @testset "Normal" begin + time_varying_params = [true, true] + dist = UnobservedComponentsGAS.NormalDistribution() + model = JuMP.Model(Ipopt.Optimizer) + params = UnobservedComponentsGAS.include_parameters(model, time_varying_params, T, dist, missing) + @test(size(params) == (T, 2)) + @test(sum((occursin.("fixed", JuMP.name.(params[:,1])))) == 0) + @test(sum((occursin.("fixed", JuMP.name.(params[:,2])))) == 0) - # Test include_parameters for Normal Distribution case 2 - time_varying_params = [true, false] - model = JuMP.Model(Ipopt.Optimizer) - params = UnobservedComponentsGAS.include_parameters(model, time_varying_params, T, dist, missing) - @test(size(params) == (T, 2)) - @test(sum((occursin.("fixed", JuMP.name.(params[:,1])))) == 0) - @test(sum((occursin.("fixed", JuMP.name.(params[:,2])))) == T) + # Test include_parameters for Normal Distribution case 2 + time_varying_params = [true, false] + model = JuMP.Model(Ipopt.Optimizer) + params = UnobservedComponentsGAS.include_parameters(model, time_varying_params, T, dist, missing) + @test(size(params) == (T, 2)) + @test(sum((occursin.("fixed", JuMP.name.(params[:,1])))) == 0) + @test(sum((occursin.("fixed", JuMP.name.(params[:,2])))) == T) - # Test compute_score for Normal Distribution - model = JuMP.Model(Ipopt.Optimizer) - computed_score = UnobservedComponentsGAS.compute_score(model, params, zeros(T), 0.0, time_varying_params, T, dist) - @test(size(computed_score) == (2,)) - @test(length(computed_score[1]) == T - 1) + # Test compute_score for Normal Distribution + model = JuMP.Model(Ipopt.Optimizer) + computed_score = UnobservedComponentsGAS.compute_score(model, params, zeros(T), 0.0, time_varying_params, T, dist) + @test(size(computed_score) == (2,)) + @test(length(computed_score[1]) == T - 1) + end - # Test include_parameters for tLocationScale Distribution - time_varying_params = [true, true, false] - dist = UnobservedComponentsGAS.tLocationScaleDistribution() - model = JuMP.Model(Ipopt.Optimizer) - params = UnobservedComponentsGAS.include_parameters(model, time_varying_params, T, dist, 1) - @test(size(params) == (T, 3)) - @test(sum((occursin.("fixed", JuMP.name.(params[:,1])))) == 0) - @test(sum((occursin.("fixed", JuMP.name.(params[:,2])))) == 0) - @test(sum((occursin.("fixed", JuMP.name.(params[:,3])))) == T) + @testset "tDist" begin + # Test include_parameters for tLocationScale Distribution + time_varying_params = [true, true, false] + dist = UnobservedComponentsGAS.tLocationScaleDistribution() + model = JuMP.Model(Ipopt.Optimizer) + params = UnobservedComponentsGAS.include_parameters(model, time_varying_params, T, dist, 1) + @test(size(params) == (T, 3)) + @test(sum((occursin.("fixed", JuMP.name.(params[:,1])))) == 0) + @test(sum((occursin.("fixed", JuMP.name.(params[:,2])))) == 0) + @test(sum((occursin.("fixed", JuMP.name.(params[:,3])))) == T) - # Test compute_score for tLocationScale Distribution - model = JuMP.Model(Ipopt.Optimizer) - computed_score = UnobservedComponentsGAS.compute_score(model, params, zeros(T), 0.0, time_varying_params, T, dist) - @test(size(computed_score) == (3,)) - @test(length(computed_score[1]) == T - 1) + # Test compute_score for tLocationScale Distribution + model = JuMP.Model(Ipopt.Optimizer) + computed_score = UnobservedComponentsGAS.compute_score(model, params, zeros(T), 0.0, time_varying_params, T, dist) + @test(size(computed_score) == (3,)) + @test(length(computed_score[1]) == T - 1) - # Test include_explanatory_variables! - model = JuMP.Model(Ipopt.Optimizer) - X = zeros(T,3) - UnobservedComponentsGAS.include_explanatory_variables!(model, X) - @test(num_variables(model) == 3) + # Test include_explanatory_variables! + model = JuMP.Model(Ipopt.Optimizer) + X = zeros(T,3) + UnobservedComponentsGAS.include_explanatory_variables!(model, X) + @test(num_variables(model) == 3) + end # Test include_objective_function! Normal Distribution case 1 # dist = UnobservedComponentsGAS.NormalDistribution() diff --git a/test/test_residuals_diagnostics.jl b/test/test_residuals_diagnostics.jl index 55d0b01..2cf39d3 100644 --- a/test/test_residuals_diagnostics.jl +++ b/test/test_residuals_diagnostics.jl @@ -15,20 +15,6 @@ gas_model = UnobservedComponentsGAS.GASModel(dist, params, d, level, seasonality, ar) fitted_model = UnobservedComponentsGAS.fit(gas_model, y); - # struct Output - # residuals::Dict{String, Any} - # fitted_params::Vector{Float64} - # end - - # # Create a dummy fitted_model object with sample residuals - # resid = Dict( - # "q_residuals" => randn(100), - # "std_residuals" => randn(100), - # "cs_residuals" => randn(100, 3) - # ) - # fitted_params = [0.5, 1.0, -0.5] - # fitted_model = Output(resid, fitted_params) - @testset "get_residuals" begin @test length(UnobservedComponentsGAS.get_residuals(fitted_model; type="q")) == 99 @test length(UnobservedComponentsGAS.get_residuals(fitted_model; type="std")) == 99 From 96e6d5bb8a9427719630169903727758a0248695 Mon Sep 17 00:00:00 2001 From: Matheus Nogueira Date: Mon, 22 Jul 2024 17:50:30 -0300 Subject: [PATCH 4/4] fix errors in unit tests and add in sample metrics --- src/utils.jl | 17 ++++++++++++ test/test_fit_forecast_lognormal.jl | 34 +++++++++++------------- test/test_fit_forecast_normal.jl | 37 +++++++++++++++----------- test/test_fit_forecast_t.jl | 41 +++++++++++++++-------------- test/test_initialization.jl | 7 +---- test/test_residuals_diagnostics.jl | 14 ++++++++++ 6 files changed, 91 insertions(+), 59 deletions(-) diff --git a/src/utils.jl b/src/utils.jl index 40bfd54..60e75e5 100644 --- a/src/utils.jl +++ b/src/utils.jl @@ -515,3 +515,20 @@ function get_seasonality_dict_and_stochastic(seasonality::Vector{String}) return seasonality_dict, any(stochastic), stochastic end + +function get_in_sample_statistics(output::Output, y::Vector{Fl}) where Fl + + y_pred = output.fit_in_sample + aic = output.information_criteria["aic"] + bic = output.information_criteria["bic"] + aicc = output.information_criteria["aicc"] + + mse = mean((y .- y_pred).^2) + rmse = sqrt(mse) + mae = mean(abs.(y .- y_pred)) + mape = mean(abs.((y .- y_pred) ./ y)) * 100 + + return Dict("MSE" => mse, "RMSE" => rmse, + "MAE" => mae, "MAPE" => mape, + "BIC" => bic, "AIC" => aic, "AICc" => aicc) +end diff --git a/test/test_fit_forecast_lognormal.jl b/test/test_fit_forecast_lognormal.jl index 559b03e..9c9b5ed 100644 --- a/test/test_fit_forecast_lognormal.jl +++ b/test/test_fit_forecast_lognormal.jl @@ -50,14 +50,22 @@ gas_model_lognormal_X = deepcopy(gas_model_lognormal) gas_model_lognormal_X_2params = deepcopy(gas_model_lognormal_2params) + model_lognormal, parameters_lognormal, initial_values_lognormal = UnobservedComponentsGAS.create_model(gas_model_lognormal, y, missing) + model_lognormal_2params, parameters_lognormal_2params, initial_values_lognormal_2params = UnobservedComponentsGAS.create_model(gas_model_lognormal_2params, y, missing) + + model_lognormal_X, parameters_lognormal_X, initial_values_lognormal_X = UnobservedComponentsGAS.create_model(gas_model_lognormal_X, y, X, missing); + model_lognormal_X_2params, parameters_lognormal_X_2params, initial_values_lognormal_X_2params = UnobservedComponentsGAS.create_model(gas_model_lognormal_X_2params, y, X, missing); + + fitted_model_lognormal = UnobservedComponentsGAS.fit(gas_model_lognormal, y; tol = 5e-2) + fitted_model_lognormal_2params = UnobservedComponentsGAS.fit(gas_model_lognormal_2params, y; tol = 5e-2) + fitted_model_lognormal_X = UnobservedComponentsGAS.fit(gas_model_lognormal_X, y, X) + fitted_model_lognormal_X_2params = UnobservedComponentsGAS.fit(gas_model_lognormal_X_2params, y, X) + + forecast_lognormal = UnobservedComponentsGAS.predict(gas_model_lognormal, fitted_model_lognormal, y, steps_ahead, num_scenarious) + #forecast_lognormal_X = UnobservedComponentsGAS.predict(gas_model_lognormal_X, fitted_model_lognormal_X, y, X_lognormal_forec, steps_ahead, num_scenarious) + forecast_lognormal_2params = UnobservedComponentsGAS.predict(gas_model_lognormal_2params, fitted_model_lognormal_2params, y, steps_ahead, num_scenarious) + @testset " --- Testing create_model functions" begin - # Create model with no explanatory series - model_lognormal, parameters_lognormal, initial_values_lognormal = UnobservedComponentsGAS.create_model(gas_model_lognormal, y, missing) - model_lognormal_2params, parameters_lognormal_2params, initial_values_lognormal_2params = UnobservedComponentsGAS.create_model(gas_model_lognormal_2params, y, missing) - - model_lognormal_X, parameters_lognormal_X, initial_values_lognormal_X = UnobservedComponentsGAS.create_model(gas_model_lognormal_X, y, X, missing); - model_lognormal_X_2params, parameters_lognormal_X_2params, initial_values_lognormal_X_2params = UnobservedComponentsGAS.create_model(gas_model_lognormal_X_2params, y, X, missing); - @test(size(parameters_lognormal) == (T,2)) @test(size(parameters_lognormal_2params) == (T,2)) @test(typeof(model_lognormal) == JuMP.Model) @@ -73,12 +81,7 @@ @test(test_initial_values_components(initial_values_lognormal_X_2params, rw, rws, ar, seasonality)) end - @testset " --- Testing fit functions" begin - fitted_model_lognormal = UnobservedComponentsGAS.fit(gas_model_lognormal, y; tol = 5e-2) - fitted_model_lognormal_2params = UnobservedComponentsGAS.fit(gas_model_lognormal_2params, y; tol = 5e-2) - fitted_model_lognormal_X = UnobservedComponentsGAS.fit(gas_model_lognormal_X, y, X) - fitted_model_lognormal_X_2params = UnobservedComponentsGAS.fit(gas_model_lognormal_X_2params, y, X) - + @testset " --- Testing fit functions" begin # "Test if termination_status is correct" possible_status = ["LOCALLY_SOLVED", "TIME_LIMIT"] @test(fitted_model_lognormal.model_status in possible_status) @@ -108,11 +111,6 @@ end @testset " --- Test forecast function ---" begin - forecast_lognormal = UnobservedComponentsGAS.predict(gas_model_lognormal, fitted_model_lognormal, y, steps_ahead, num_scenarious) - #forecast_lognormal_X = UnobservedComponentsGAS.predict(gas_model_lognormal_X, fitted_model_lognormal_X, y, X_lognormal_forec, steps_ahead, num_scenarious) - forecast_lognormal_2params = UnobservedComponentsGAS.predict(gas_model_lognormal_2params, fitted_model_lognormal_2params, y, steps_ahead, num_scenarious) - - @test(isapprox(forecast_lognormal["mean"], vec(mean(forecast_lognormal["scenarios"], dims = 2)); rtol = 1e-3)) @test(size(forecast_lognormal["scenarios"]) == (steps_ahead, num_scenarious)) diff --git a/test/test_fit_forecast_normal.jl b/test/test_fit_forecast_normal.jl index cc92f39..d2b636b 100644 --- a/test/test_fit_forecast_normal.jl +++ b/test/test_fit_forecast_normal.jl @@ -49,14 +49,24 @@ gas_model_normal_X = deepcopy(gas_model_normal) gas_model_normal_X_2params = deepcopy(gas_model_normal_2params) + + model_normal, parameters_normal, initial_values_normal = UnobservedComponentsGAS.create_model(gas_model_normal, y, missing) + model_normal_2params, parameters_normal_2params, initial_values_normal_2params = UnobservedComponentsGAS.create_model(gas_model_normal_2params, y, missing) + + model_normal_X, parameters_normal_X, initial_values_normal_X = UnobservedComponentsGAS.create_model(gas_model_normal_X, y, X, missing); + model_normal_X_2params, parameters_normal_X_2params, initial_values_normal_X_2params = UnobservedComponentsGAS.create_model(gas_model_normal_X_2params, y, X, missing); + fitted_model_normal = UnobservedComponentsGAS.fit(gas_model_normal, y; tol = 5e-2) + fitted_model_normal_2params = UnobservedComponentsGAS.fit(gas_model_normal_2params, y; tol = 5e-2) + fitted_model_normal_X = UnobservedComponentsGAS.fit(gas_model_normal_X, y, X; tol = 5e-2) + fitted_model_normal_X_2params = UnobservedComponentsGAS.fit(gas_model_normal_X_2params, y, X; tol = 5e-2) + + forecast_normal = UnobservedComponentsGAS.predict(gas_model_normal, fitted_model_normal, y, steps_ahead, num_scenarious) + forecast_normal_X = UnobservedComponentsGAS.predict(gas_model_normal_X, fitted_model_normal_X, y, X_normal_forec, steps_ahead, num_scenarious) + forecast_normal_2params = UnobservedComponentsGAS.predict(gas_model_normal_2params, fitted_model_normal_2params, y, steps_ahead, num_scenarious) + @testset "create_model" begin # Create model with no explanatory series - model_normal, parameters_normal, initial_values_normal = UnobservedComponentsGAS.create_model(gas_model_normal, y, missing) - model_normal_2params, parameters_normal_2params, initial_values_normal_2params = UnobservedComponentsGAS.create_model(gas_model_normal_2params, y, missing) - - model_normal_X, parameters_normal_X, initial_values_normal_X = UnobservedComponentsGAS.create_model(gas_model_normal_X, y, X, missing); - model_normal_X_2params, parameters_normal_X_2params, initial_values_normal_X_2params = UnobservedComponentsGAS.create_model(gas_model_normal_X_2params, y, X, missing); @test(size(parameters_normal) == (T,2)) @test(size(parameters_normal_2params) == (T,2)) @@ -75,11 +85,6 @@ #@info(" --- Testing fit functions") @testset "fit" begin - fitted_model_normal = UnobservedComponentsGAS.fit(gas_model_normal, y; tol = 5e-2) - fitted_model_normal_2params = UnobservedComponentsGAS.fit(gas_model_normal_2params, y; tol = 5e-2) - fitted_model_normal_X = UnobservedComponentsGAS.fit(gas_model_normal_X, y, X; tol = 5e-2) - fitted_model_normal_X_2params = UnobservedComponentsGAS.fit(gas_model_normal_X_2params, y, X; tol = 5e-2) - # "Test if termination_status is correct" possible_status = ["LOCALLY_SOLVED", "TIME_LIMIT"] @test(fitted_model_normal.model_status in possible_status) @@ -110,11 +115,7 @@ #@info(" --- Test forecast function ---") @testset "forecast" begin - forecast_normal = UnobservedComponentsGAS.predict(gas_model_normal, fitted_model_normal, y, steps_ahead, num_scenarious) - forecast_normal_X = UnobservedComponentsGAS.predict(gas_model_normal_X, fitted_model_normal_X, y, X_normal_forec, steps_ahead, num_scenarious) - forecast_normal_2params = UnobservedComponentsGAS.predict(gas_model_normal_2params, fitted_model_normal_2params, y, steps_ahead, num_scenarious) - - + @test(isapprox(forecast_normal["mean"], vec(mean(forecast_normal["scenarios"], dims = 2)); rtol = 1e-3)) @test(size(forecast_normal["scenarios"]) == (steps_ahead, num_scenarious)) @@ -156,6 +157,8 @@ #@info(" --- Test quality of fit - Normal with 2 params") @testset "quality of fit - Normal with 2 params" begin + y = time_series[1:end-steps_ahead,5] + y_test = time_series[end-steps_ahead+1:end, 5] gas_model = UnobservedComponentsGAS.GASModel(UnobservedComponentsGAS.NormalDistribution(), [true, true], 0.0, ["random walk slope", "random walk"], ["deterministic 12", "deterministic 12"], [missing, missing]) fitted_model = UnobservedComponentsGAS.fit(gas_model, y) @@ -167,6 +170,8 @@ # #@info(" --- Test quality of fit - Normal with robust") @testset "quality of fit - Normal with robust" begin + y = time_series[1:end-steps_ahead,5] + y_test = time_series[end-steps_ahead+1:end, 5] gas_model = UnobservedComponentsGAS.GASModel(UnobservedComponentsGAS.NormalDistribution(), [true, false], 1.0, "random walk slope", "deterministic 12", 1) fitted_model = UnobservedComponentsGAS.fit(gas_model, y; α = 0.0, robust = true) @@ -177,6 +182,8 @@ end @testset "AR(1) level" begin + y = time_series[1:end-steps_ahead,5] + y_test = time_series[end-steps_ahead+1:end, 5] gas_model = UnobservedComponentsGAS.GASModel(UnobservedComponentsGAS.NormalDistribution(), [true, false], 0.5, ["ar(1)", ""], ["deterministic 12", ""], [missing, missing]) fitted_model = UnobservedComponentsGAS.fit(gas_model, y) diff --git a/test/test_fit_forecast_t.jl b/test/test_fit_forecast_t.jl index 6435e1f..5d8fecc 100644 --- a/test/test_fit_forecast_t.jl +++ b/test/test_fit_forecast_t.jl @@ -50,15 +50,23 @@ gas_model_t_X = deepcopy(gas_model_t) gas_model_t_X_2params = deepcopy(gas_model_t_2params) + + model_t, parameters_t, initial_values_t = UnobservedComponentsGAS.create_model(gas_model_t, y, ν) + model_t_2params, parameters_t_2params, initial_values_t_2params = UnobservedComponentsGAS.create_model(gas_model_t_2params, y, ν) + + model_t_X, parameters_t_X, initial_values_t_X = UnobservedComponentsGAS.create_model(gas_model_t_X, y, X, ν); + model_t_X_2params, parameters_t_X_2params, initial_values_t_X_2params = UnobservedComponentsGAS.create_model(gas_model_t_X_2params, y, X, ν); + + fitted_model_t = UnobservedComponentsGAS.fit(gas_model_t, y; tol = 5e-2) + fitted_model_t_2params = UnobservedComponentsGAS.fit(gas_model_t_2params, y; tol = 5e-2) + fitted_model_t_X = UnobservedComponentsGAS.fit(gas_model_t_X, y, X; tol = 5e-2) + fitted_model_t_X_2params = UnobservedComponentsGAS.fit(gas_model_t_X_2params, y, X; tol = 5e-2) + + forecast_t = UnobservedComponentsGAS.predict(gas_model_t, fitted_model_t, y, steps_ahead, num_scenarious) + forecast_t_X = UnobservedComponentsGAS.predict(gas_model_t_X, fitted_model_t_X, y, X_t_forec, steps_ahead, num_scenarious) + forecast_t_2params = UnobservedComponentsGAS.predict(gas_model_t_2params, fitted_model_t_2params, y, steps_ahead, num_scenarious) - @testset " --- Testing create_model functions" begin - # Create model with no explanatory series - model_t, parameters_t, initial_values_t = UnobservedComponentsGAS.create_model(gas_model_t, y, ν) - model_t_2params, parameters_t_2params, initial_values_t_2params = UnobservedComponentsGAS.create_model(gas_model_t_2params, y, ν) - - model_t_X, parameters_t_X, initial_values_t_X = UnobservedComponentsGAS.create_model(gas_model_t_X, y, X, ν); - model_t_X_2params, parameters_t_X_2params, initial_values_t_X_2params = UnobservedComponentsGAS.create_model(gas_model_t_X_2params, y, X, ν); - + @testset " --- Testing create_model functions" begin @test(size(parameters_t) == (T,3)) @test(size(parameters_t_2params) == (T,3)) @test(typeof(model_t) == JuMP.Model) @@ -74,12 +82,7 @@ @test(test_initial_values_components(initial_values_t_X_2params, rw, rws, ar, seasonality)) end - @testset " --- Testing fit functions" begin - fitted_model_t = UnobservedComponentsGAS.fit(gas_model_t, y; tol = 5e-2) - fitted_model_t_2params = UnobservedComponentsGAS.fit(gas_model_t_2params, y; tol = 5e-2) - fitted_model_t_X = UnobservedComponentsGAS.fit(gas_model_t_X, y, X; tol = 5e-2) - fitted_model_t_X_2params = UnobservedComponentsGAS.fit(gas_model_t_X_2params, y, X; tol = 5e-2) - + @testset " --- Testing fit functions" begin # "Test if termination_status is correct" possible_status = ["LOCALLY_SOLVED", "TIME_LIMIT"] @test(fitted_model_t.model_status in possible_status) @@ -109,11 +112,6 @@ end @testset " --- Test forecast function ---" begin - forecast_t = UnobservedComponentsGAS.predict(gas_model_t, fitted_model_t, y, steps_ahead, num_scenarious) - forecast_t_X = UnobservedComponentsGAS.predict(gas_model_t_X, fitted_model_t_X, y, X_t_forec, steps_ahead, num_scenarious) - forecast_t_2params = UnobservedComponentsGAS.predict(gas_model_t_2params, fitted_model_t_2params, y, steps_ahead, num_scenarious) - - @test(isapprox(forecast_t["mean"], vec(mean(forecast_t["scenarios"], dims = 2)); rtol = 1e-3)) @test(size(forecast_t["scenarios"]) == (steps_ahead, num_scenarious)) @@ -154,7 +152,8 @@ end @testset " --- Test quality of fit - tDist with 2 params" begin - + y = time_series[1:end-steps_ahead,1] + y_test = time_series[end-steps_ahead+1:end, 1] gas_model = UnobservedComponentsGAS.GASModel(UnobservedComponentsGAS.tLocationScaleDistribution(), [true, true, false], 0.0, ["random walk slope", "random walk", ""], ["deterministic 12", "deterministic 12", ""], [missing, missing, missing]) fitted_model = UnobservedComponentsGAS.fit(gas_model, y) @@ -166,6 +165,8 @@ @testset " --- Test quality of fit - tDist with robust" begin + y = time_series[1:end-steps_ahead,1] + y_test = time_series[end-steps_ahead+1:end, 1] gas_model = UnobservedComponentsGAS.GASModel(UnobservedComponentsGAS.tLocationScaleDistribution(), [true, false, false], 1.0, "random walk slope", "deterministic 12", 1) fitted_model = UnobservedComponentsGAS.fit(gas_model, y; α = 0.0, robust = true) diff --git a/test/test_initialization.jl b/test/test_initialization.jl index 62d56d1..6112737 100644 --- a/test/test_initialization.jl +++ b/test/test_initialization.jl @@ -8,10 +8,6 @@ stochastic = false @testset "structures" begin - params = - level = - seasonality = - ar = gas_model = UnobservedComponentsGAS.GASModel(UnobservedComponentsGAS.NormalDistribution(), [true, false], 0.5, ["random walk", "ar(1)"], ["deterministic 12", "deterministic 12"], @@ -21,7 +17,7 @@ @test(ismissing(gas_model.ar[2])) @test(!isempty(gas_model.seasonality[1])) @test(!isempty(gas_model.level[1])) - @test(ismissing(gas_model.ar[1])) + @test(!ismissing(gas_model.ar[1])) end @@ -356,7 +352,6 @@ @test(all(initial_values["seasonality"]["γ"] .== initial_values_state_space["γ"])) @test(all(initial_values["seasonality"]["γ_star"] .== initial_values_state_space["γ_star"])) @test(all(initial_values["seasonality"]["values"] .== zeros(T))) - @test(all(initial_values["ar1"]["values"] .== zeros(T))) @test(all(initial_values["slope"]["values"] .== zeros(T))) @test(all(initial_values["rw"]["values"] .== zeros(T))) @test(all(initial_values["explanatories"] .== initial_values_state_space["explanatory"])) diff --git a/test/test_residuals_diagnostics.jl b/test/test_residuals_diagnostics.jl index 2cf39d3..7dd1972 100644 --- a/test/test_residuals_diagnostics.jl +++ b/test/test_residuals_diagnostics.jl @@ -92,4 +92,18 @@ haskey(diagnosis_pvalues_std, "ARCH") end + @testset "In-Sample Statistics Tests" begin + stats = UnobservedComponentsGAS.get_in_sample_statistics(fitted_model, y) + + @test stats["MSE"] > 0 + @test stats["RMSE"] > 0 + @test stats["RMSE"] == sqrt(stats["MSE"]) + @test stats["MAE"] > 0 + @test stats["MAPE"] > 0 + @test stats["MAPE"] < 100 + @test stats["AIC"] > 0 + @test stats["BIC"] > 0 + @test stats["AICc"] > 0 + end + end