🎨 Format code according to space guidelines

Author: LuizFCDuarte

src/datasets.jl

@@ -1,7 +1,7 @@
 @enum Datasets begin
-    AIR_PASSENGERS=1
-    GDPC1=2 
-    NROU=3
+    AIR_PASSENGERS = 1
+    GDPC1 = 2
+    NROU = 3
 end
 
 const AIR_PASSENGERS = instances(Datasets)[1]
@@ -10,9 +10,9 @@ const NROU = instances(Datasets)[3]
 export AIR_PASSENGERS, GDPC1, NROU
 
 datasetsPaths = [
-    joinpath(dirname(@__DIR__()), "datasets", "airpassengers.csv"), 
+    joinpath(dirname(@__DIR__()), "datasets", "airpassengers.csv"),
     joinpath(dirname(@__DIR__()), "datasets", "GDPC1.csv"),
-    joinpath(dirname(@__DIR__()), "datasets", "NROU.csv")
+    joinpath(dirname(@__DIR__()), "datasets", "NROU.csv"),
 ]
 
 
@@ -71,12 +71,12 @@ julia> airPassengers = loadDataset(airPassengersDf)
 
 ```
 """
-function loadDataset(df::DataFrame, showLogs::Bool=false)
+function loadDataset(df::DataFrame, showLogs::Bool = false)
     auxiliarDF = deepcopy(df)
     if !(:date in propertynames(auxiliarDF))
         showLogs && @info("The DataFrame does not have a column named 'date'.")
         showLogs && @info("Creating a date column with the index of the DataFrame")
-        auxiliarDF[!,:date] = [Date(i) for i=1:size(auxiliarDF,1)]
+        auxiliarDF[!, :date] = [Date(i) for i = 1:size(auxiliarDF, 1)]
     end
     y = TimeArray(auxiliarDF, timestamp = :date)
     return y
@@ -90,9 +90,18 @@ end
 
 Splits the time series in training and testing sets. 
 """
-function splitTrainTest(data::TimeArray; trainPercentage::Fl=0.8) where Fl<:AbstractFloat
-    trainingSetEndIndex = floor(Int, trainPercentage*length(data))
-    trainingSet = TimeArray(timestamp(data)[1:trainingSetEndIndex], values(data)[1:trainingSetEndIndex])
-    testingSet = TimeArray(timestamp(data)[trainingSetEndIndex+1:end], values(data)[trainingSetEndIndex+1:end])
+function splitTrainTest(
+    data::TimeArray;
+    trainPercentage::Fl = 0.8,
+) where {Fl<:AbstractFloat}
+    trainingSetEndIndex = floor(Int, trainPercentage * length(data))
+    trainingSet = TimeArray(
+        timestamp(data)[1:trainingSetEndIndex],
+        values(data)[1:trainingSetEndIndex],
+    )
+    testingSet = TimeArray(
+        timestamp(data)[trainingSetEndIndex+1:end],
+        values(data)[trainingSetEndIndex+1:end],
+    )
     return trainingSet, testingSet
-end
+end

src/datetime_utils.jl

@@ -1,9 +1,11 @@
+import Base: copy, deepcopy
+
 function Base.copy(y::TimeArray)
-    return TimeArray(copy(timestamp(y)),copy(values(y)))
+    return TimeArray(copy(timestamp(y)), copy(values(y)))
 end
 
 function Base.deepcopy(y::TimeArray)
-    return TimeArray(deepcopy(timestamp(y)),deepcopy(values(y)))
+    return TimeArray(deepcopy(timestamp(y)), deepcopy(values(y)))
 end
 
 """
@@ -22,11 +24,11 @@ An array of DateTime objects.
 
 """
 function buildDatetimes(
-    startDatetime::T, 
-    granularity::P where P <: Dates.Period,
-    weekDaysOnly::Bool, 
+    startDatetime::T,
+    granularity::P where {P<:Dates.Period},
+    weekDaysOnly::Bool,
     datetimesLength::Int,
-) where T
+) where {T}
     if datetimesLength == 0
         return DateTime[]
     end
@@ -37,7 +39,7 @@ function buildDatetimes(
     currentDatetime = startDatetime
 
     # Loop to generate timestamps based on granularity
-    for _ in 1:datetimesLength
+    for _ = 1:datetimesLength
         if weekDaysOnly && dayofweek(currentDatetime) == 5
             currentDatetime += Dates.Day(3)
         else
@@ -69,15 +71,15 @@ A tuple `(granularity, frequency, weekdays)` where:
 Throws an error if the timestamps do not follow a consistent pattern.
 
 """
-function identifyGranularity(datetimes::Vector{T}) where T
+function identifyGranularity(datetimes::Vector{T}) where {T}
     # Define base units and periods
     baseUnits = [Second(1), Minute(1), Hour(1), Day(1), Week(1)]
     basePeriods = [:Second, :Minute, :Hour, :Day, :Week, :Month, :Year]
-    
+
     unitPeriod = nothing
     diffBetweenTimestamps = nothing
     weekDaysSeries = false
-    
+
     for (i, unit) in enumerate(baseUnits)
         differences = diff(datetimes) ./ unit
         min_difference = minimum(differences)
@@ -86,13 +88,13 @@ function identifyGranularity(datetimes::Vector{T}) where T
         if lessThanOne
             break
         end
-        
+
         # Check if all elements are equal
         regularDistribution = all(differences .== differences[1])
         if regularDistribution
             unitPeriod = basePeriods[i]
             diffBetweenTimestamps = differences[1]
-            
+
             if unit in [Minute(1), Second(1)]
                 if diffBetweenTimestamps < 60
                     break
@@ -128,7 +130,7 @@ function identifyGranularity(datetimes::Vector{T}) where T
                 end
             end
         end
- 
+
         amplitude = maximum(differences) - min_difference
         if amplitude < 1
             unitPeriod = basePeriods[i]
@@ -152,10 +154,14 @@ function identifyGranularity(datetimes::Vector{T}) where T
         elseif diffBetweenTimestamps % 4 == 0
             unitPeriod = :Month
             diffBetweenTimestamps = diffBetweenTimestamps / 4
-        end 
+        end
     end
-    
-    return (granularity=unitPeriod, frequency=diffBetweenTimestamps, weekdays=weekDaysSeries)
+
+    return (
+        granularity = unitPeriod,
+        frequency = diffBetweenTimestamps,
+        weekdays = weekDaysSeries,
+    )
 end
 
 """
@@ -171,7 +177,7 @@ Merge multiple `TimeArray` objects into a single `TimeArray`. The function align
 A `TimeArray` object representing the merged time series.
 
 """
-function merge(timeArrayVector::Vector{TimeArray},modelFl::DataType=Float64)
+function merge(timeArrayVector::Vector{TimeArray}, modelFl::DataType = Float64)
     if length(timeArrayVector) == 0
         return TimeArray(DateTime[], [])
     end
@@ -192,19 +198,18 @@ function merge(timeArrayVector::Vector{TimeArray},modelFl::DataType=Float64)
 
     newTimeArrayVector = []
     for ta in timeArrayVector
-        newTimeArray = from(ta,initialTimestamp)
-        newTimeArray = to(newTimeArray,finalTimestamp)
-        push!(newTimeArrayVector,newTimeArray)
+        newTimeArray = from(ta, initialTimestamp)
+        newTimeArray = to(newTimeArray, finalTimestamp)
+        push!(newTimeArrayVector, newTimeArray)
     end
 
-    auxiliarDf = DataFrame((:timestamp=>timestamp(newTimeArrayVector[1])))
+    auxiliarDf = DataFrame((:timestamp => timestamp(newTimeArrayVector[1])))
     for ta in newTimeArrayVector
         # Add a column with ta colname and values
         colname = colnames(ta)[1]
         valuesTa::Vector{modelFl} = values(ta)
-        auxiliarDf[!,colname] = valuesTa
+        auxiliarDf[!, colname] = valuesTa
     end
 
-    return TimeArray(auxiliarDf, timestamp=:timestamp)
+    return TimeArray(auxiliarDf, timestamp = :timestamp)
 end
-

src/exceptions.jl

@@ -1,18 +1,23 @@
 mutable struct ModelNotFitted <: Exception end
-Base.showerror(io::IO, e::ModelNotFitted) = print(io, "The model has not been fitted yet. Please run fit!(model)")
+Base.showerror(io::IO, e::ModelNotFitted) =
+    print(io, "The model has not been fitted yet. Please run fit!(model)")
 
-mutable struct MissingMethodImplementation <: Exception 
+mutable struct MissingMethodImplementation <: Exception
     method::String
 end
-Base.showerror(io::IO, e::MissingMethodImplementation) = print(io, "The model does not implement the ", e.method, " method.")
+Base.showerror(io::IO, e::MissingMethodImplementation) =
+    print(io, "The model does not implement the ", e.method, " method.")
 
 mutable struct InconsistentDatePattern <: Exception end
-Base.showerror(io::IO, e::InconsistentDatePattern) = print(io, "The timestamps do not follow a consistent pattern.")
+Base.showerror(io::IO, e::InconsistentDatePattern) =
+    print(io, "The timestamps do not follow a consistent pattern.")
 
 mutable struct MissingExogenousData <: Exception end
-Base.showerror(io::IO, e::MissingExogenousData) = print(io, "There is no exogenous data to forecast the horizon requested")
+Base.showerror(io::IO, e::MissingExogenousData) =
+    print(io, "There is no exogenous data to forecast the horizon requested")
 
 mutable struct InvalidParametersCombination <: Exception
     msg::String
 end
-Base.showerror(io::IO, e::InvalidParametersCombination) = print(io, "The parameters provided are invalid for the model \n", e.msg)
+Base.showerror(io::IO, e::InvalidParametersCombination) =
+    print(io, "The parameters provided are invalid for the model \n", e.msg)

src/fit.jl

@@ -45,8 +45,8 @@ Calculate the Akaike Information Criterion (AIC) for a given number of parameter
 The AIC value calculated using the formula: AIC = 2*K - 2*loglikeVal.
 
 """
-function aic(K::Int, loglikeVal::Fl) where Fl<:AbstractFloat
-    return  2*K - 2*loglikeVal
+function aic(K::Int, loglikeVal::Fl) where {Fl<:AbstractFloat}
+    return 2 * K - 2 * loglikeVal
 end
 
 """
@@ -63,8 +63,8 @@ Calculate the corrected Akaike Information Criterion (AICc) for a given number o
 The AICc value calculated using the formula: AICc = AIC(K, loglikeVal) + ((2*K*K + 2*K) / (T - K - 1)).
 
 """
-function aicc(T::Int, K::Int, loglikeVal::Fl) where Fl<:AbstractFloat
-    return aic(K, loglikeVal) + ((2*K*K + 2*K) / (T - K - 1))
+function aicc(T::Int, K::Int, loglikeVal::Fl) where {Fl<:AbstractFloat}
+    return aic(K, loglikeVal) + ((2 * K * K + 2 * K) / (T - K - 1))
 end
 
 """
@@ -81,8 +81,8 @@ Calculate the Bayesian Information Criterion (BIC) for a given number of observa
 The BIC value calculated using the formula: BIC = log(T) * K - 2 * loglikeVal.
 
 """
-function bic(T::Int, K::Int, loglikeVal::Fl) where Fl<:AbstractFloat
-    return log(T)*K - 2*loglikeVal
+function bic(T::Int, K::Int, loglikeVal::Fl) where {Fl<:AbstractFloat}
+    return log(T) * K - 2 * loglikeVal
 end
 
 """
@@ -101,15 +101,16 @@ The AIC value calculated using the number of parameters and log-likelihood value
 - Throws a `MissingMethodImplementation` if the `getHyperparametersNumber` method is not implemented for the given model type.
 
 """
-function aic(model::SarimaxModel; offset::Fl=0.0) where Fl<:AbstractFloat
-    !hasHyperparametersMethods(typeof(model)) && throw(MissingMethodImplementation("getHyperparametersNumber"))
+function aic(model::SarimaxModel; offset::Fl = 0.0) where {Fl<:AbstractFloat}
+    !hasHyperparametersMethods(typeof(model)) &&
+        throw(MissingMethodImplementation("getHyperparametersNumber"))
     K = Sarimax.getHyperparametersNumber(model)
     # T = length(model.ϵ)
     # return aic(K, loglike(model))
     # offset = -2 * loglike(model) - length(model.y) * log(model.σ²)
     # return offset + T * log(model.σ²) + 2*K
-    T = length(model.y) - model.d - model.D * model.seasonality 
-    return 2*K + T * log(model.σ²) + offset
+    T = length(model.y) - model.d - model.D * model.seasonality
+    return 2 * K + T * log(model.σ²) + offset
 end
 
 """
@@ -128,13 +129,14 @@ The AICc value calculated using the number of parameters, sample size, and log-l
 - Throws a `MissingMethodImplementation` if the `getHyperparametersNumber` method is not implemented for the given model type.
 
 """
-function aicc(model::SarimaxModel; offset::Fl=0.0) where Fl<:AbstractFloat
-    !hasHyperparametersMethods(typeof(model)) && throw(MissingMethodImplementation("getHyperparametersNumber"))
+function aicc(model::SarimaxModel; offset::Fl = 0.0) where {Fl<:AbstractFloat}
+    !hasHyperparametersMethods(typeof(model)) &&
+        throw(MissingMethodImplementation("getHyperparametersNumber"))
     K = getHyperparametersNumber(model)
     # T = length(model.ϵ)
     # return aicc(T, K, loglike(model))
-    T = length(model.y) - model.d - model.D * model.seasonality 
-    return aic(model; offset=offset) + ((2*K*K + 2*K) / (T - K - 1))
+    T = length(model.y) - model.d - model.D * model.seasonality
+    return aic(model; offset = offset) + ((2 * K * K + 2 * K) / (T - K - 1))
 end
 
 """
@@ -153,11 +155,12 @@ The BIC value calculated using the number of parameters, sample size, and log-li
 - Throws a `MissingMethodImplementation` if the `getHyperparametersNumber` method is not implemented for the given model type.
 
 """
-function bic(model::SarimaxModel;offset::Fl=0.0) where Fl<:AbstractFloat
-    !hasHyperparametersMethods(typeof(model)) && throw(MissingMethodImplementation("getHyperparametersNumber"))
+function bic(model::SarimaxModel; offset::Fl = 0.0) where {Fl<:AbstractFloat}
+    !hasHyperparametersMethods(typeof(model)) &&
+        throw(MissingMethodImplementation("getHyperparametersNumber"))
     K = getHyperparametersNumber(model)
     # T = length(model.ϵ)
     # return bic(T, K, loglike(model))
     T = length(model.y) - model.d - model.D * model.seasonality
-    return aic(model; offset=offset) + K *(log(T) - 2)
-end
+    return aic(model; offset = offset) + K * (log(T) - 2)
+end