Add factory functions for propagating previous weights

dcelisgarza · dcelisgarza · commit 86301ad82b55 · 2026-02-10T01:03:00.000Z
diff --git a/src/20_Optimisation/01_Base_Optimisation.jl b/src/20_Optimisation/01_Base_Optimisation.jl
@@ -3,6 +3,9 @@ const VecOptE = AbstractVector{<:AbstractOptimisationEstimator}
 abstract type BaseOptimisationEstimator <: AbstractOptimisationEstimator end
 abstract type OptimisationEstimator <: AbstractOptimisationEstimator end
 abstract type NonFiniteAllocationOptimisationEstimator <: OptimisationEstimator end
+function factory(opt::NonFiniteAllocationOptimisationEstimator, ::Any)
+    return opt
+end
 abstract type OptimisationAlgorithm <: AbstractAlgorithm end
 abstract type OptimisationResult <: AbstractResult end
 abstract type NonFiniteAllocationOptimisationResult <: OptimisationResult end
diff --git a/src/20_Optimisation/02_CrossValidation/01_Base_CrossValidation.jl b/src/20_Optimisation/02_CrossValidation/01_Base_CrossValidation.jl
@@ -1,3 +1,6 @@
 abstract type CrossValidationEstimator <: AbstractEstimator end
 abstract type CrossValidationResult <: AbstractResult end
 abstract type CrossValidationAlgorithm <: AbstractAlgorithm end
+
+abstract type SequentialCrossValidationEstimator <: CrossValidationEstimator end
+abstract type NonSequentialCrossValidationEstimator <: CrossValidationEstimator end
diff --git a/src/20_Optimisation/02_CrossValidation/02_KFold.jl b/src/20_Optimisation/02_CrossValidation/02_KFold.jl
@@ -1,4 +1,4 @@
-struct KFold{T1} <: CrossValidationEstimator
+struct KFold{T1} <: NonSequentialCrossValidationEstimator
     n::T1
     function KFold(n::Integer)
         assert_nonempty_gt0_finite_val(n, :n)
diff --git a/src/20_Optimisation/02_CrossValidation/03_WalkForward.jl b/src/20_Optimisation/02_CrossValidation/03_WalkForward.jl
@@ -1,4 +1,4 @@
-abstract type WalkForwardEstimator <: CrossValidationEstimator end
+abstract type WalkForwardEstimator <: SequentialCrossValidationEstimator end
 struct IndexWalkForward{T1, T2, T3, T4, T5} <: WalkForwardEstimator
     train_size::T1
     test_size::T2
diff --git a/src/20_Optimisation/02_CrossValidation/04_Validation.jl b/src/20_Optimisation/02_CrossValidation/04_Validation.jl
@@ -1,5 +1,6 @@
 function cross_val_predict(est::OptimisationEstimator, rd::ReturnsResult,
-                           cv::CrossValidationEstimator = KFold(); cols = nothing)
+                           cv::CrossValidationEstimator = KFold(); cols = nothing,
+                           ex::FLoops.Transducers.Executor = FLoops.ThreadedEx())
     if !isnothing(cols)
         rd = returns_result_view(rd, cols)
     end
diff --git a/src/20_Optimisation/03_NaiveOptimisation.jl b/src/20_Optimisation/03_NaiveOptimisation.jl
@@ -14,7 +14,7 @@ struct NaiveOptimisationResult{T1, T2, T3, T4, T5, T6} <:
     w::T3
     fb::T6
 end
-function factory(res::NaiveOptimisationResult, fb)
+function factory(res::NaiveOptimisationResult, fb::Option{<:OptE_Opt})
     return NaiveOptimisationResult(res.oe, res.pr, res.wb, res.retcode, res.w, fb)
 end
 struct InverseVolatility{T1, T2, T3, T4, T5, T6} <: NaiveOptimisationEstimator
@@ -40,6 +40,10 @@ function InverseVolatility(; pr::PrE_Pr = EmpiricalPrior(),
                            strict::Bool = false, fb::Option{<:OptE_Opt} = nothing)
     return InverseVolatility(pr, wb, sets, wf, strict, fb)
 end
+function factory(opt::InverseVolatility, w::AbstractVector)
+    return InverseVolatility(; pr = opt.pr, wb = opt.wb, sets = opt.sets, wf = opt.wf,
+                             strict = opt.strict, fb = factory(opt.fb, w))
+end
 function opt_view(opt::InverseVolatility, i, args...)
     pr = prior_view(opt.pr, i)
     wb = weight_bounds_view(opt.wb, i)
@@ -93,6 +97,10 @@ function EqualWeighted(; wb::Option{<:WbE_Wb} = WeightBounds(),
                        strict::Bool = false, fb::Option{<:OptE_Opt} = nothing)
     return EqualWeighted(wb, sets, wf, strict, fb)
 end
+function factory(opt::EqualWeighted, w::AbstractVector)
+    return EqualWeighted(; wb = opt.wb, sets = opt.sets, wf = opt.wf, strict = opt.strict,
+                         fb = factory(opt.fb, w))
+end
 function opt_view(opt::EqualWeighted, i, args...)
     wb = weight_bounds_view(opt.wb, i)
     sets = nothing_asset_sets_view(opt.sets, i)
@@ -139,6 +147,10 @@ function RandomWeighted(; rng::Random.AbstractRNG = Random.default_rng(),
                         strict::Bool = false, fb::Option{<:OptE_Opt} = nothing)
     return RandomWeighted(rng, seed, wb, sets, wf, strict, fb)
 end
+function factory(opt::RandomWeighted, w::AbstractVector)
+    return RandomWeighted(; rng = opt.rng, seed = opt.seed, wb = opt.wb, sets = opt.sets,
+                          wf = opt.wf, strict = opt.strict, fb = factory(opt.fb, w))
+end
 function opt_view(opt::RandomWeighted, i, args...)
     wb = weight_bounds_view(opt.wb, i)
     sets = nothing_asset_sets_view(opt.sets, i)
diff --git a/src/20_Optimisation/04_Base_ClusteringOptimisation.jl b/src/20_Optimisation/04_Base_ClusteringOptimisation.jl
@@ -11,7 +11,7 @@ struct HierarchicalResult{T1, T2, T3, T4, T5, T6, T7, T8} <:
     w::T7
     fb::T8
 end
-function factory(res::HierarchicalResult, fb)
+function factory(res::HierarchicalResult, fb::Option{<:OptE_Opt})
     return HierarchicalResult(res.oe, res.pr, res.clr, res.wb, res.fees, res.retcode, res.w,
                               fb)
 end
@@ -47,6 +47,11 @@ function HierarchicalOptimiser(; pr::PrE_Pr = EmpiricalPrior(),
                                strict::Bool = false)
     return HierarchicalOptimiser(pr, clr, slv, wb, fees, sets, wf, strict)
 end
+function factory(opt::HierarchicalOptimiser, w::AbstractVector)
+    return HierarchicalOptimiser(; pr = opt.pr, clr = opt.clr, slv = opt.slv, wb = opt.wb,
+                                 fees = factory(opt.fees, w), sets = opt.sets, wf = opt.wf,
+                                 strict = opt.strict)
+end
 function opt_view(hco::HierarchicalOptimiser, i)
     pr = prior_view(hco.pr, i)
     wb = weight_bounds_view(hco.wb, i)
diff --git a/src/20_Optimisation/05_HierarchicalRiskParity.jl b/src/20_Optimisation/05_HierarchicalRiskParity.jl
@@ -17,6 +17,12 @@ function HierarchicalRiskParity(; opt::HierarchicalOptimiser = HierarchicalOptim
                                 fb::Option{<:OptE_Opt} = nothing)
     return HierarchicalRiskParity(opt, r, sca, fb)
 end
+function factory(hrp::HierarchicalRiskParity, w::AbstractVector)
+    opt = factory(hrp.opt, w)
+    r = factory(hrp.r, w)
+    fb = factory(hrp.fb, w)
+    return HierarchicalRiskParity(; opt = opt, r = r, sca = hrp.sca, fb = fb)
+end
 function opt_view(hrp::HierarchicalRiskParity, i, X::MatNum)
     X = isa(hrp.opt.pr, AbstractPriorResult) ? hrp.opt.pr.X : X
     r = risk_measure_view(hrp.r, i, X)
diff --git a/src/20_Optimisation/06_SchurComplementHierarchicalRiskParity.jl b/src/20_Optimisation/06_SchurComplementHierarchicalRiskParity.jl
@@ -80,6 +80,11 @@ function SchurComplementHierarchicalRiskParity(;
                                                fb::Option{<:OptE_Opt} = nothing)
     return SchurComplementHierarchicalRiskParity(opt, params, fb)
 end
+function factory(sh::SchurComplementHierarchicalRiskParity, w::AbstractVector)
+    opt = factory(sh.opt, w)
+    fb = factory(sh.fb, w)
+    return SchurComplementHierarchicalRiskParity(; opt = opt, params = sh.params, fb = fb)
+end
 function opt_view(sh::SchurComplementHierarchicalRiskParity, i, X::MatNum)
     X = isa(sh.opt.pr, AbstractPriorResult) ? sh.opt.pr.X : X
     opt = opt_view(sh.opt, i)
diff --git a/src/20_Optimisation/07_HierarchicalEqualRiskContribution.jl b/src/20_Optimisation/07_HierarchicalEqualRiskContribution.jl
@@ -32,6 +32,14 @@ function HierarchicalEqualRiskContribution(;
                                            fb::Option{<:OptE_Opt} = nothing)
     return HierarchicalEqualRiskContribution(opt, ri, ro, scai, scao, ex, fb)
 end
+function factory(hec::HierarchicalEqualRiskContribution, w::AbstractVector)
+    opt = factory(hec.opt, w)
+    ri = factory(hec.ri, w)
+    ro = factory(hec.ro, w)
+    fb = factory(hec.fb, w)
+    return HierarchicalEqualRiskContribution(; opt = opt, ri = ri, ro = ro, scai = hec.scai,
+                                             scao = hec.scao, ex = hec.ex, fb = fb)
+end
 function opt_view(hec::HierarchicalEqualRiskContribution, i, X::MatNum)
     X = isa(hec.opt.pr, AbstractPriorResult) ? hec.opt.pr.X : X
     ri = hec.ri
diff --git a/src/20_Optimisation/10_JuMPOptimiser.jl b/src/20_Optimisation/10_JuMPOptimiser.jl
@@ -286,6 +286,23 @@ function JuMPOptimiser(; pr::PrE_Pr = EmpiricalPrior(), slv::Slv_VecSlv,
                          sgmtx, slt, sst, sglt, sgst, tn, fees, sets, tr, pl, ret, sca,
                          ccnt, cobj, sc, so, ss, card, scard, nea, l1, l2, linf, lp, strict)
 end
+function factory(opt::JuMPOptimiser, w::AbstractVector)
+    tn = factory(opt.tn, w)
+    fees = factory(opt.fees, w)
+    tr = factory(opt.tr, w)
+    ccnt = factory(opt.ccnt, w)
+    cobj = factory(opt.cobj, w)
+    return JuMPOptimiser(; pr = opt.pr, slv = opt.slv, wb = opt.wb, bgt = opt.bgt,
+                         sbgt = opt.sbgt, lt = opt.lt, st = opt.st, lcs = opt.lcs,
+                         ct = opt.ct, gcard = opt.gcard, sgcard = opt.sgcard,
+                         smtx = opt.smtx, sgmtx = opt.sgmtx, slt = opt.slt, sst = opt.sst,
+                         sglt = opt.sglt, sgst = opt.sgst, tn = tn, fees = fees,
+                         sets = opt.sets, tr = tr, pl = opt.pl, ret = opt.ret,
+                         sca = opt.sca, ccnt = ccnt, cobj = cobj, sc = opt.sc, so = opt.so,
+                         ss = opt.ss, card = opt.card, scard = opt.scard, nea = opt.nea,
+                         l1 = opt.l1, l2 = opt.l2, linf = opt.linf, lp = opt.lp,
+                         strict = opt.strict)
+end
 function opt_view(opt::JuMPOptimiser, i, X::MatNum)
     X = isa(opt.pr, AbstractPriorResult) ? opt.pr.X : X
     pr = prior_view(opt.pr, i)
diff --git a/src/20_Optimisation/11_MeanRisk.jl b/src/20_Optimisation/11_MeanRisk.jl
@@ -6,7 +6,7 @@ struct MeanRiskResult{T1, T2, T3, T4, T5, T6} <: NonFiniteAllocationOptimisation
     model::T5
     fb::T6
 end
-function factory(res::MeanRiskResult, fb)
+function factory(res::MeanRiskResult, fb::Option{<:OptE_Opt})
     return MeanRiskResult(res.oe, res.pa, res.retcode, res.sol, res.model, fb)
 end
 function Base.getproperty(r::MeanRiskResult, sym::Symbol)
@@ -43,6 +43,12 @@ function MeanRisk(; opt::JuMPOptimiser = JuMPOptimiser(), r::RM_VecRM = Variance
                   fb::Option{<:OptE_Opt} = nothing)
     return MeanRisk(opt, r, obj, wi, fb)
 end
+function factory(mr::MeanRisk, w::AbstractVector)
+    opt = factory(mr.opt, w)
+    r = factory(mr.r, w)
+    fb = factory(mr.fb, w)
+    return MeanRisk(; opt = opt, r = r, obj = mr.obj, wi = mr.wi, fb = fb)
+end
 function opt_view(mr::MeanRisk, i, X::MatNum)
     X = isa(mr.opt.pr, AbstractPriorResult) ? mr.opt.pr.X : X
     opt = opt_view(mr.opt, i, X)
diff --git a/src/20_Optimisation/12_FactorRiskContribution.jl b/src/20_Optimisation/12_FactorRiskContribution.jl
@@ -9,7 +9,7 @@ struct FactorRiskContributionResult{T1, T2, T3, T4, T5, T6, T7, T8} <:
     model::T7
     fb::T8
 end
-function factory(res::FactorRiskContributionResult, fb)
+function factory(res::FactorRiskContributionResult, fb::Option{<:OptE_Opt})
     return FactorRiskContributionResult(res.oe, res.pa, res.rr, res.frc_plg, res.retcode,
                                         res.sol, res.model, fb)
 end
@@ -63,6 +63,14 @@ function FactorRiskContribution(; opt::JuMPOptimiser = JuMPOptimiser(),
                                 fb::Option{<:OptE_Opt} = nothing)
     return FactorRiskContribution(opt, re, r, obj, pl, sets, wi, flag, fb)
 end
+function factory(frc::FactorRiskContribution, w::AbstractVector)
+    opt = factory(frc.opt, w)
+    r = factory(frc.r, w)
+    fb = factory(frc.fb, w)
+    return FactorRiskContribution(; opt = opt, re = frc.re, r = r, obj = frc.obj,
+                                  pl = frc.pl, sets = frc.sets, wi = frc.wi,
+                                  flag = frc.flag, fb = fb)
+end
 function opt_view(frc::FactorRiskContribution, i, X::MatNum)
     X = isa(frc.opt.pr, AbstractPriorResult) ? frc.opt.pr.X : X
     opt = opt_view(frc.opt, i, X)
diff --git a/src/20_Optimisation/13_NearOptimalCentering.jl b/src/20_Optimisation/13_NearOptimalCentering.jl
@@ -14,7 +14,7 @@ struct NearOptimalCenteringResult{T1, T2, T3, T4, T5, T6, T7, T8, T9, T10} <:
     model::T9
     fb::T10
 end
-function factory(res::NearOptimalCenteringResult, fb)
+function factory(res::NearOptimalCenteringResult, fb::Option{<:OptE_Opt})
     return NearOptimalCenteringResult(res.oe, res.pa, res.w_min_retcode, res.w_opt_retcode,
                                       res.w_max_retcode, res.noc_retcode, res.retcode,
                                       res.sol, res.model, fb)
@@ -111,6 +111,16 @@ function NearOptimalCentering(; opt::JuMPOptimiser = JuMPOptimiser(),
     return NearOptimalCentering(opt, r, obj, bins, w_min, w_min_ini, w_opt, w_opt_ini,
                                 w_max, w_max_ini, ucs_flag, alg, fb)
 end
+function factory(noc::NearOptimalCentering, w::AbstractVector)
+    opt = factory(noc.opt, w)
+    r = factory(noc.r, w)
+    fb = factory(noc.fb, w)
+    return NearOptimalCentering(; opt = opt, r = r, obj = noc.obj, bins = noc.bins,
+                                w_min = noc.w_min, w_min_ini = noc.w_min_ini,
+                                w_opt = noc.w_opt, w_opt_ini = noc.w_opt_ini,
+                                w_max = noc.w_max, w_max_ini = noc.w_max_ini,
+                                ucs_flag = noc.ucs_flag, alg = noc.alg, fb = fb)
+end
 function opt_view(noc::NearOptimalCentering, i, X::MatNum)
     X = isa(noc.opt.pr, AbstractPriorResult) ? noc.opt.pr.X : X
     opt = opt_view(noc.opt, i, X)
diff --git a/src/20_Optimisation/14_RiskBudgeting.jl b/src/20_Optimisation/14_RiskBudgeting.jl
@@ -8,7 +8,7 @@ struct RiskBudgetingResult{T1, T2, T3, T4, T5, T6, T7} <:
     model::T6
     fb::T7
 end
-function factory(res::RiskBudgetingResult, fb)
+function factory(res::RiskBudgetingResult, fb::Option{<:OptE_Opt})
     return RiskBudgetingResult(res.oe, res.pa, res.prb, res.retcode, res.sol, res.model, fb)
 end
 function Base.getproperty(r::RiskBudgetingResult, sym::Symbol)
@@ -87,6 +87,12 @@ function RiskBudgeting(; opt::JuMPOptimiser = JuMPOptimiser(), r::RM_VecRM = Var
                        wi::Option{<:VecNum} = nothing, fb::Option{<:OptE_Opt} = nothing)
     return RiskBudgeting(opt, r, rba, wi, fb)
 end
+function factory(rb::RiskBudgeting, w::AbstractVector)
+    opt = factory(rb.opt, w)
+    r = factory(rb.r, w)
+    fb = factory(rb.fb, w)
+    return RiskBudgeting(; opt = opt, r = r, rba = rb.rba, wi = rb.wi, fb = fb)
+end
 function opt_view(rb::RiskBudgeting, i, X::MatNum)
     X = isa(rb.opt.pr, AbstractPriorResult) ? rb.opt.pr.X : X
     opt = opt_view(rb.opt, i, X)
diff --git a/src/20_Optimisation/15_RelaxedRiskBudgeting.jl b/src/20_Optimisation/15_RelaxedRiskBudgeting.jl
@@ -38,6 +38,12 @@ function RelaxedRiskBudgeting(; opt::JuMPOptimiser = JuMPOptimiser(),
                               fb::Option{<:OptE_Opt} = nothing)
     return RelaxedRiskBudgeting(opt, rba, wi, alg, fb)
 end
+function factory(rrb::RelaxedRiskBudgeting, w::AbstractVector)
+    opt = factory(rrb.opt, w)
+    fb = factory(rrb.fb, w)
+    return RelaxedRiskBudgeting(; opt = opt, rba = rrb.rba, wi = rrb.wi, alg = rrb.alg,
+                                fb = fb)
+end
 function opt_view(rrb::RelaxedRiskBudgeting, i, X::MatNum)
     X = isa(rrb.opt.pr, AbstractPriorResult) ? rrb.opt.pr.X : X
     opt = opt_view(rrb.opt, i, X)
diff --git a/src/20_Optimisation/16_NestedClustered.jl b/src/20_Optimisation/16_NestedClustered.jl
@@ -12,7 +12,7 @@ struct NestedClusteredResult{T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11} <:
     w::T10
     fb::T11
 end
-function factory(res::NestedClusteredResult, fb)
+function factory(res::NestedClusteredResult, fb::Option{<:OptE_Opt})
     return NestedClusteredResult(res.oe, res.pr, res.clr, res.wb, res.fees, res.resi,
                                  res.reso, res.cv, res.retcode, res.w, fb)
 end
@@ -147,6 +147,15 @@ function assert_external_optimiser(opt::NestedClustered)
     end
     return nothing
 end
+function factory(nco::NestedClustered, w::AbstractVector)
+    fees = factory(nco.fees, w)
+    opti = factory(nco.opti, w)
+    opto = factory(nco.opto, w)
+    fb = factory(nco.fb, w)
+    return NestedClustered(; pr = nco.pr, clr = nco.clr, wb = nco.wb, fees = fees,
+                           sets = nco.sets, opti = opti, opto = opto, cv = nco.cv,
+                           wf = nco.wf, strict = nco.strict, ex = nco.ex, fb = fb)
+end
 function opt_view(nco::NestedClustered, i, X::MatNum)
     X = isa(nco.pr, AbstractPriorResult) ? nco.pr.X : X
     pr = prior_view(nco.pr, i)
diff --git a/src/20_Optimisation/17_Stacking.jl b/src/20_Optimisation/17_Stacking.jl
@@ -12,7 +12,7 @@ struct StackingResult{T1, T2, T3, T4, T5, T6, T7, T8, T9, T10} <:
     w::T9
     fb::T10
 end
-function factory(res::StackingResult, fb)
+function factory(res::StackingResult, fb::Option{<:OptE_Opt})
     return StackingResult(res.oe, res.pr, res.wb, res.fees, res.resi, res.reso, res.cv,
                           res.retcode, res.w, fb)
 end
@@ -71,6 +71,15 @@ function assert_internal_optimiser(opt::Stacking)
     end
     return nothing
 end
+function factory(st::Stacking, w::AbstractVector)
+    fees = factory(st.fees, w)
+    opti = factory(st.opti, w)
+    opto = factory(st.opto, w)
+    fb = factory(st.fb, w)
+    return Stacking(; pr = st.pr, wb = st.wb, fees = fees, sets = st.sets, opti = opti,
+                    opto = opto, cv = st.cv, wf = st.wf, strict = st.strict, ex = st.ex,
+                    fb = fb)
+end
 function opt_view(st::Stacking, i, X::MatNum)
     X = isa(st.pr, AbstractPriorResult) ? st.pr.X : X
     pr = prior_view(st.pr, i)
diff --git a/src/20_Optimisation/20_DiscreteFiniteAllocation.jl b/src/20_Optimisation/20_DiscreteFiniteAllocation.jl
@@ -12,7 +12,7 @@ struct DiscreteAllocationResult{T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11} <:
     l_model::T10
     fb::T11
 end
-function factory(res::DiscreteAllocationResult, fb)
+function factory(res::DiscreteAllocationResult, fb::Option{<:FOptE_FOpt})
     return DiscreteAllocationResult(res.oe, res.retcode, res.s_retcode, res.l_retcode,
                                     res.shares, res.cost, res.w, res.cash, res.s_model,
                                     res.l_model, fb)
diff --git a/src/20_Optimisation/21_GreedyFiniteAllocation.jl b/src/20_Optimisation/21_GreedyFiniteAllocation.jl
@@ -8,7 +8,7 @@ struct GreedyAllocationResult{T1, T2, T3, T4, T5, T6, T7} <:
     cash::T6
     fb::T7
 end
-function factory(res::GreedyAllocationResult, fb)
+function factory(res::GreedyAllocationResult, fb::Option{<:FOptE_FOpt})
     return GreedyAllocationResult(res.oe, res.retcode, res.shares, res.cost, res.w,
                                   res.cash, fb)
 end
diff --git a/src/PortfolioOptimisers.jl b/src/PortfolioOptimisers.jl
@@ -151,8 +151,8 @@ include("19_RiskMeasures/26_RiskMeasureTools.jl")
 include("20_Optimisation/01_Base_Optimisation.jl")
 include("20_Optimisation/02_CrossValidation/01_Base_CrossValidation.jl")
 include("20_Optimisation/02_CrossValidation/02_KFold.jl")
-include("20_Optimisation/02_CrossValidation/03_Validation.jl")
-include("20_Optimisation/02_CrossValidation/04_WalkForward.jl")
+include("20_Optimisation/02_CrossValidation/03_WalkForward.jl")
+include("20_Optimisation/02_CrossValidation/04_Validation.jl")
 include("20_Optimisation/03_NaiveOptimisation.jl")
 include("20_Optimisation/04_Base_ClusteringOptimisation.jl")
 include("20_Optimisation/05_HierarchicalRiskParity.jl")

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-struct KFold{T1} <: CrossValidationEstimator`
	`1`	`+struct KFold{T1} <: NonSequentialCrossValidationEstimator`
`2`	`2`	`n::T1`
`3`	`3`	`function KFold(n::Integer)`
`4`	`4`	`assert_nonempty_gt0_finite_val(n, :n)`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-abstract type WalkForwardEstimator <: CrossValidationEstimator end`
	`1`	`+abstract type WalkForwardEstimator <: SequentialCrossValidationEstimator end`
`2`	`2`	`struct IndexWalkForward{T1, T2, T3, T4, T5} <: WalkForwardEstimator`
`3`	`3`	`train_size::T1`
`4`	`4`	`test_size::T2`