factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> VectorNo-op factory function for constructing objects with a uniform interface.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> VectorNo-op factory function for constructing objects with a uniform interface.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> VectorNo-op factory function for constructing objects with a uniform interface.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> VectorNo-op factory function for constructing objects with a uniform interface.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> VectorNo-op factory function for constructing objects with a uniform interface.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> VectorNo-op factory function for constructing objects with a uniform interface.
prices_to_returns(
pr::PricesResult;
ret_method::Symbol = :simple,
padding::Bool = false,
gap_return_alg::Option{<:AbstractGapReturnAlgorithm} = nothing
) -> ReturnsResult
prices_to_returns(
X::TimeSeries.TimeArray;
kwargs...
) -> ReturnsResultCompute returns from the price data.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> VectorNo-op factory function for constructing objects with a uniform interface.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> VectorNo-op factory function for constructing objects with a uniform interface.
factory(
ce::StatsBase.CovarianceEstimator,
args...;
kwargs...
) -> StatsBase.CovarianceEstimatorFallback for covariance estimator factory methods.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> VectorNo-op factory function for constructing objects with a uniform interface.
factory(tgt::AbstractRegressionTarget, w::ObsWeights)Refuse a regression target that has no method to carry observation weights into its fit.
factory(re::GeneralisedLinearModel, w::ObsWeights) -> GeneralisedLinearModelReturn a new GeneralisedLinearModel regression target with observation weights w added to the keyword arguments.
factory(re::LinearModel, w::ObsWeights) -> LinearModelReturn a new LinearModel regression target with observation weights w added to the keyword arguments.
factory(drtgt::DimensionReductionTarget, args...; kwargs...) -> DimensionReductionTargetNo-op factory for DimensionReductionTarget subtypes.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> VectorNo-op factory function for constructing objects with a uniform interface.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> VectorNo-op factory function for constructing objects with a uniform interface.
struct Solver{__T_name, __T_solver, __T_settings, __T_check_sol, __T_add_bridges} <: AbstractEstimatorConfigures one solver backend, its attributes, and the statuses its solutions must reach.
factory(
alg::AbstractPhylogenyAlgorithm,
args...;
kwargs...
) -> AbstractClustersAlgorithmReturn the phylogeny algorithm alg unchanged.
factory(
pl::Union{AbstractPhylogenyEstimator, AbstractPhylogenyResult},
args...;
kwargs...
) -> Union{NetworkClustersEstimator{<:AbstractNetworkEstimator, <:AbstractClustersAlgorithm, <:AbstractOptimalNumberClustersEstimator, Nothing}, NetworkClustersEstimator{<:AbstractNetworkEstimator, <:AbstractClustersAlgorithm, <:AbstractOptimalNumberClustersEstimator, <:AbstractReturnsSource}}Return the phylogeny estimator or result pl unchanged.
factory(
alg::AbstractClustersAlgorithm,
args...;
kwargs...
) -> AbstractClustersAlgorithmReturn the clustering algorithm alg unchanged.
prior(pe::AbstractPriorEstimator, rd::ReturnsResult; strict::Bool = false,
dims::Int = 1, cache_reg::Bool = false)Compute prior information from asset and/or factor returns using a prior estimator.
prior(pr::AbstractPriorResult, args...; kwargs...)Propagate or pass through prior result objects.
struct EmpiricalPrior{__T_ce, __T_me, __T_horizon, __T_fill_limit, __T_max_scenarios, __T_cache, __T_x_src} <: AbstractLowOrderPriorEstimator_AEmpirical prior estimator for asset returns.
prior(pe::EmpiricalPrior{<:Any, <:Any, Nothing, <:Any}, X::MatNum,
F::Option{<:MatNum} = nothing, pnl::Option{<:AssetPanel} = nothing;
dims::Int = 1, strict::Bool = false, kwargs...)Compute empirical prior moments for asset returns (no horizon adjustment).
prior(pe::FactorPrior, rd::ReturnsResult; strict::Bool = false, dims::Int = 1,
cache_reg::Bool = false) -> LowOrderPriorFit a Factor Prior from a ReturnsResult.
prior(pe::HighOrderPriorEstimator, X::MatNum, F::Option{<:MatNum} = nothing, pnl::Option{<:AssetPanel} = nothing; dims::Int = 1, kwargs...)Compute high order prior moments for asset returns using a composite estimator.
prior(pe::BlackLittermanPrior, X::MatNum, F::Option{<:MatNum} = nothing,
pnl::Option{<:AssetPanel} = nothing;
dims::Int = 1, strict::Bool = false, kwargs...)Compute the Black-Litterman prior moments for asset returns.
prior(pe::MeucciEntropyPoolingPrior, X::MatNum, F::Option{<:MatNum} = nothing,
pnl::Option{<:AssetPanel} = nothing; dims::Int = 1, strict::Bool = false,
kwargs...)Compute entropy pooling prior moments for asset returns.
prior(pe::EntropyPoolingPrior, X::MatNum, F::Option{<:MatNum} = nothing,
pnl::Option{<:AssetPanel} = nothing; dims::Int = 1, strict::Bool = false,
kwargs...)Compute the entropy pooling prior of asset returns with tail views.
prior(pe::OpinionPoolingPrior, X::MatNum, F::Option{<:MatNum} = nothing,
pnl::Option{<:AssetPanel} = nothing;
dims::Int = 1, strict::Bool = false, cache_reg::Bool = false, kwargs...)Compute opinion pooling prior moments for asset returns.
prior(pe::CrossSectionalFactorPrior, X::MatNum, F::Option{<:MatNum} = nothing,
pnl::Option{<:AssetPanel} = nothing; dims::Int = 1, ne::Option{<:VecStr} = nothing,
E::Option{<:MatNum} = nothing, iv::Option{<:MatNum} = nothing,
ivpa::Option{<:Num_VecNum} = nothing, ts::Option{<:VecDate} = nothing,
strict::Bool = false, cache_reg::Bool = false, kwargs...) -> LowOrderPriorFit a cross-sectional factor model on an Asset Panel, and return the asset prior it lifts.
prior(pe::CrossSectionalFactorPrior, rd::ReturnsResult; strict::Bool = false,
dims::Int = 1, cache_reg::Bool = false) -> LowOrderPriorFit a Cross-Sectional Factor Prior from a ReturnsResult.
prior(pe::LowDimensionEnsemblePrior, X::MatNum, F::Option{<:MatNum} = nothing, pnl::Option{<:AssetPanel} = nothing; dims::Int = 1, active_mask::Option{<:AbstractMatrix{<:Bool}} = nothing, kwargs...)Computes the low-dimension ensemble prior of the rows, with the forecast return as mu and the aggregated predictive covariance as sigma.
prior(
pe::CrossSectionalFactorPrior,
st::CrossSectionalCarryState;
strict,
cache_reg,
kwargs...
) -> LowOrderPriorReads a Cross-Sectional Factor Prior out of its carry fold, with no data.
factory(tn::VecTnE_Tn, w::VecNum)Create new turnover constraints or estimators with updated portfolio weights.
factory(tn::Turnover, w::VecNum)Replace the reference weights of a Turnover, unless fixed holds them.
factory(tn::TurnoverEstimator, w::VecNum)Replace the reference weights of a TurnoverEstimator, unless fixed holds them.
factory(tr::WeightsTracking, w::VecNum)Construct a new WeightsTracking object with updated portfolio weights.
struct Frontier{__T_N, __T_factor, __T_bound} <: AbstractAlgorithmSweeps the efficient frontier by solving the model once at each of N evenly spaced bound values.
factory(
rs::AbstractBaseRiskMeasure,
args...;
kwargs...
) -> UncertaintySetVarianceReturn the risk measure rs unchanged.
struct Variance{__T_settings, __T_sigma, __T_chol, __T_rc, __T_alg, __T_mtx_sqrt, __T_ratio_alg, __T_corner} <: RiskMeasureMeasures the portfolio variance, the quadratic form of the weights in a covariance matrix.
factory(r::UncertaintySetVariance, pr::AbstractPriorResult, ::Any,
ucs::Option{<:UcSE_UcS} = nothing, args...;
kwargs...)Create an instance of UncertaintySetVariance whose empty slots take the uncertainty set ucs and the covariance matrix of the prior result pr.
factory(
r::StandardDeviation,
pr::AbstractPriorResult,
args...;
kwargs...
) -> StandardDeviation{RiskMeasureSettings{__T_scale, __T_ub, __T_rke}} where {__T_scale, __T_ub, __T_rke}Create an instance of StandardDeviation that holds a covariance matrix, taken from the measure or from the prior result pr.
factory(
r::Variance,
pr::AbstractPriorResult,
args...;
kwargs...
) -> Variance{RiskMeasureSettings{__T_scale, __T_ub, __T_rke}, _A, _B, _C, var"#s185", _D, <:RatioFormulation} where {__T_scale, __T_ub, __T_rke, _A, _B, _C, var"#s185"<:VarianceFormulation, _D}Create an instance of Variance that holds a covariance matrix, taken from the measure or from the prior result pr.
factory(
r::HighOrderMoment,
pr::AbstractPriorResult,
args...;
kwargs...
) -> HighOrderMoment{RiskMeasureSettings{__T_scale, __T_ub, __T_rke}, _A, _B, <:HighOrderMomentMeasureAlgorithm} where {__T_scale, __T_ub, __T_rke, _A, _B}Create an instance of HighOrderMoment by selecting observation weights, expected returns, and algorithm from the risk-measure instance or falling back to the prior result.
factory(
r::LowOrderMoment,
pr::AbstractPriorResult,
args...;
kwargs...
) -> LowOrderMoment{RiskMeasureSettings{__T_scale, __T_ub, __T_rke}, _A, _B, <:LowOrderMomentMeasureAlgorithm} where {__T_scale, __T_ub, __T_rke, _A, _B}Create an instance of LowOrderMoment by selecting observation weights, expected returns, and algorithm from the risk-measure instance or falling back to the prior result.
factory(
alg::MomentMeasureAlgorithm,
args...;
kwargs...
) -> SecondMoment{<:AbstractVarianceEstimator, <:AbstractMomentAlgorithm, <:SecondMomentFormulation}Return the moment measure algorithm alg unchanged.
factory(
alg::StandardisedHighOrderMoment,
w::Union{DynamicAbstractWeights, AbstractWeights}
) -> StandardisedHighOrderMoment{<:AbstractVarianceEstimator, <:UnstandardisedHighOrderMomentMeasureAlgorithm}Return a new StandardisedHighOrderMoment with observation weights w applied to the underlying variance estimator.
factory(
r::Kurtosis,
pr::HighOrderPrior,
args...;
kwargs...
) -> Kurtosis{RiskMeasureSettings{__T_scale, __T_ub, __T_rke}, _A, _B, _C, _D, <:AbstractMomentAlgorithm, <:SecondMomentFormulation, Nothing} where {__T_scale, __T_ub, __T_rke, _A, _B, _C, _D}Create an instance of Kurtosis by selecting the cokurtosis matrix, expected returns, and weights from the risk-measure instance or falling back to a HighOrderPrior result.
factory(
r::Kurtosis,
pr::LowOrderPrior,
args...;
kwargs...
) -> Kurtosis{RiskMeasureSettings{__T_scale, __T_ub, __T_rke}, _A, _B, _C, _D, <:AbstractMomentAlgorithm, <:SecondMomentFormulation, Nothing} where {__T_scale, __T_ub, __T_rke, _A, _B, _C, _D}Create an instance of Kurtosis from a LowOrderPrior result (cokurtosis matrix is not used).
factory(
r::NegativeSkewness,
pr::HighOrderPrior,
args...;
kwargs...
) -> NegativeSkewness{RiskMeasureSettings{__T_scale, __T_ub, __T_rke}, <:AbstractMatrixProcessingEstimator} where {__T_scale, __T_ub, __T_rke}Create an instance of NegativeSkewness by resolving a Deferred Quantity in sk, then falling back to a HighOrderPrior result for the coskewness matrix and its spectral decomposition.
factory(
r::NegativeSkewness,
pr::LowOrderPrior,
args...;
kwargs...
) -> NegativeSkewnessResolve a Deferred Quantity in NegativeSkewness's sk slot against a LowOrderPrior result, and otherwise return r unchanged.
factory(
alg::DistributionValueatRisk,
pr::AbstractPriorResult,
args...;
kwargs...
) -> DistributionValueatRisk{_A, _B, _C, Nothing, <:Distributions.Distribution{F, S}} where {_A, _B, _C, F<:Distributions.VariateForm, S<:Distributions.ValueSupport}Create an instance of DistributionValueatRisk by resolving its Deferred Quantities, then falling back to the prior result for whatever is still unstated.
factory(
alg::ValueatRiskFormulation,
args...;
kwargs...
) -> DistributionValueatRisk{_A, _B, _C, Nothing, <:Distributions.Distribution{F, S}} where {_A, _B, _C, F<:Distributions.VariateForm, S<:Distributions.ValueSupport}Return the Value-at-Risk formulation alg unchanged.
factory(
x::OrderedWeightsArray,
pr::AbstractPriorResult,
args...;
kwargs...
) -> OrderedWeightsArrayResolve the weight builder in w against prior result pr, and return an OrderedWeightsArray whose builder holds numbers.
factory(
x::OrderedWeightsArrayRange,
pr::AbstractPriorResult,
args...;
kwargs...
) -> OrderedWeightsArrayRangeResolve the two weight builders of an OrderedWeightsArrayRange against prior result pr.
factory(
r::TurnoverRiskMeasure,
,
,
;
...
) -> TurnoverRiskMeasure
factory(
r::TurnoverRiskMeasure,
,
,
,
w::Union{Nothing, AbstractVector{<:Union{var"#s152", var"#s69"} where {var"#s152"<:Number, var"#s69"<:AbstractJuMPScalar}}},
args...;
kwargs...
) -> TurnoverRiskMeasureCreate an instance of TurnoverRiskMeasure from a full optimisation context, forwarding the optional weight argument w to factory(r, w).
factory(
r::TurnoverRiskMeasure,
w::AbstractVector{<:Union{var"#s152", var"#s69"} where {var"#s152"<:Number, var"#s69"<:AbstractJuMPScalar}}
) -> TurnoverRiskMeasureCreate an instance of TurnoverRiskMeasure updating the reference weights to w.
factory(
tr::RiskTrackingError,
pr::AbstractPriorResult,
slv,
ucs;
...
) -> RiskTrackingError{WeightsTracking{__T_fees, __T_w, __T_fixed}, _A, <:Number, <:VariableTracking} where {__T_fees, __T_w, __T_fixed, _A}
factory(
tr::RiskTrackingError,
pr::AbstractPriorResult,
slv,
ucs,
w::Union{Nothing, AbstractVector{<:Union{var"#s152", var"#s69"} where {var"#s152"<:Number, var"#s69"<:AbstractJuMPScalar}}},
args...;
kwargs...
) -> RiskTrackingError{WeightsTracking{__T_fees, __T_w, __T_fixed}, _A, <:Number, <:VariableTracking} where {__T_fees, __T_w, __T_fixed, _A}Return a RiskTrackingError whose tracked measure is resolved against a prior result, and whose benchmark takes the weights w.
factory(
tr::RiskTrackingError,
w::AbstractVector{<:Union{var"#s152", var"#s69"} where {var"#s152"<:Number, var"#s69"<:AbstractJuMPScalar}}
) -> RiskTrackingError{WeightsTracking{__T_fees, __T_w, __T_fixed}, _A, <:Number, <:VariableTracking} where {__T_fees, __T_w, __T_fixed, _A}Return a RiskTrackingError whose benchmark and tracked measure take the portfolio weights w.
factory(
r::RiskTrackingRiskMeasure,
pr::AbstractPriorResult,
args...;
kwargs...
) -> RiskTrackingRiskMeasure{RiskMeasureSettings{__T_scale, __T_ub, __T_rke}, WeightsTracking{__T_fees, __T_w, __T_fixed}, _A, <:VariableTracking} where {__T_scale, __T_ub, __T_rke, __T_fees, __T_w, __T_fixed, _A}Return a RiskTrackingRiskMeasure whose tracked measure is resolved against the prior result pr.
factory(
r::RiskTrackingRiskMeasure,
w::AbstractVector{<:Union{var"#s152", var"#s69"} where {var"#s152"<:Number, var"#s69"<:AbstractJuMPScalar}}
) -> RiskTrackingRiskMeasure{RiskMeasureSettings{__T_scale, __T_ub, __T_rke}, WeightsTracking{__T_fees, __T_w, __T_fixed}, _A, <:VariableTracking} where {__T_scale, __T_ub, __T_rke, __T_fees, __T_w, __T_fixed, _A}Return a RiskTrackingRiskMeasure whose benchmark and tracked measure take the portfolio weights w.
factory(
r::TrackingRiskMeasure,
w::AbstractVector{<:Union{var"#s152", var"#s69"} where {var"#s152"<:Number, var"#s69"<:AbstractJuMPScalar}}
) -> TrackingRiskMeasure{RiskMeasureSettings{__T_scale, __T_ub, __T_rke}, <:AbstractTrackingAlgorithm, <:NormError} where {__T_scale, __T_ub, __T_rke}Return a TrackingRiskMeasure whose benchmark takes the portfolio weights w.
factory(
r::TrackingRiskMeasure,
,
,
,
w::AbstractVector{<:Union{var"#s152", var"#s69"} where {var"#s152"<:Number, var"#s69"<:AbstractJuMPScalar}},
args...;
kwargs...
) -> TrackingRiskMeasure{RiskMeasureSettings{__T_scale, __T_ub, __T_rke}, <:AbstractTrackingAlgorithm, <:NormError} where {__T_scale, __T_ub, __T_rke}Return factory(r, w), the TrackingRiskMeasure whose benchmark takes the portfolio weights w.
factory(
r::Skewness,
pr::HighOrderPrior,
args...;
kwargs...
) -> Skewness{MaxRiskMeasureSettings{__T_scale, __T_lb, __T_rke}, var"#s185", _A, _B, _C, Nothing} where {__T_scale, __T_lb, __T_rke, var"#s185"<:AbstractVarianceEstimator, _A, _B, _C}Create an instance of Skewness by selecting observation weights and expected returns from the risk-measure instance or falling back to the prior result.
factory(
r::Skewness,
pr::LowOrderPrior,
args...;
kwargs...
) -> Skewness{MaxRiskMeasureSettings{__T_scale, __T_lb, __T_rke}, var"#s185", _A, _B, _C, Nothing} where {__T_scale, __T_lb, __T_rke, var"#s185"<:AbstractVarianceEstimator, _A, _B, _C}Create an instance of Skewness from a LowOrderPrior result, selecting observation weights and expected returns while preserving the coskewness matrix from the risk measure.
factory(
r::VarianceSkewKurtosis,
pr::AbstractPriorResult,
args...;
kwargs...
) -> VarianceSkewKurtosis{RiskMeasureSettings{__T_scale, __T_ub, __T_rke}, _A, Skewness{__T_settings, __T_ve, __T_sk, __T_w, __T_mu, __T_pe}, _B, Nothing} where {__T_scale, __T_ub, __T_rke, _A, __T_settings, __T_ve, __T_sk, __T_w, __T_mu, __T_pe, _B}Create an instance of VarianceSkewKurtosis by fanning pe out over its three children, then threading pr into each of them.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> Vector
factory(
rs::AbstractBaseRiskMeasure,
args...;
kwargs...
) -> UncertaintySetVarianceNo-op factory function for constructing objects with a uniform interface.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> Vector
factory(
rs::AbstractBaseRiskMeasure,
args...;
kwargs...
) -> UncertaintySetVarianceNo-op factory function for constructing objects with a uniform interface.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> Vector
factory(
rs::AbstractBaseRiskMeasure,
args...;
kwargs...
) -> UncertaintySetVarianceNo-op factory function for constructing objects with a uniform interface.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> Vector
factory(
rs::AbstractBaseRiskMeasure,
args...;
kwargs...
) -> UncertaintySetVarianceNo-op factory function for constructing objects with a uniform interface.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> Vector
factory(
rs::AbstractBaseRiskMeasure,
args...;
kwargs...
) -> UncertaintySetVarianceNo-op factory function for constructing objects with a uniform interface.
factory(res::NonFiniteAllocationOptimisationResult, fb::Option{<:OptE_Opt_FbChain})Rebuilds a continuous optimisation result with a new fallback record fb.
factory(
opt::Union{NonFiniteAllocationOptimisationEstimator, NonFiniteAllocationOptimisationResult},
_
) -> SubsetResamplingResultReturns opt unchanged.
factory(td::TimeDependent, args...) -> TimeDependentApplies factory to each entry of a TimeDependent and to its default, and rebuilds the schedule.
optimise(
opt::OptimisationEstimator,
args...;
kwargs...
) -> GreedyAllocationResult{OptimisationSuccess{Nothing}, SubArray{_A, 1, P, Tuple{Base.Slice{Base.OneTo{Int64}}, Int64}, true}, SubArray{_A1, 1, P1, Tuple{Base.Slice{Base.OneTo{Int64}}, Int64}, true}, SubArray{_A2, 1, P2, Tuple{Base.Slice{Base.OneTo{Int64}}, Int64}, true}, <:Number, <:Number, Nothing} where {_A<:(Union{var"#s152", var"#s69"} where {var"#s152"<:Number, var"#s69"<:AbstractJuMPScalar}), P<:(Matrix), _A1<:(Union{var"#s152", var"#s69"} where {var"#s152"<:Number, var"#s69"<:AbstractJuMPScalar}), P1<:(Matrix), _A2<:(Union{var"#s152", var"#s69"} where {var"#s152"<:Number, var"#s69"<:AbstractJuMPScalar}), P2<:(Matrix)}Solve an optimisation estimator, and walk its fallback chain when a solve fails.
optimise(opt::OptimisationEstimator, args...; kwargs...) -> OptimisationResult
optimise(opt::OptimisationResult, args...; kwargs...) -> OptimisationResultRun a portfolio optimisation with the estimator opt, and return an OptimisationResult.
optimise(
td::Union{TimeDependent{<:AbstractVector{<:Union{var"#s9238", var"#s9237"} where {var"#s9238"<:NonFiniteAllocationOptimisationEstimator, var"#s9237"<:NonFiniteAllocationOptimisationResult}}}, TimeDependent{<:TimeDependentOptimiserCallable}, TimeDependent{<:PreviousWeightsFunction}, TimeDependent{<:Union{Function, Type}}},
args...;
kwargs...
) -> AnyOptimise with a TimeDependent schedule standing in for the optimiser, outside any fold loop.
factory(res::BudgetedHindsightPathResult, fb::Option{<:FbChain})Rebuilds a budgeted path result with the fallback chain fb that optimise walked, and keeps every other field.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> Vector
factory(res::NonFiniteAllocationOptimisationResult, fb::Option{<:OptE_Opt_FbChain})
factory(
opt::Union{NonFiniteAllocationOptimisationEstimator, NonFiniteAllocationOptimisationResult},
_
) -> SubsetResamplingResultNo-op factory function for constructing objects with a uniform interface.
factory(pw::PreviousWeights, w::VecNum) -> PreviousWeightsThread the previous fold's weights into the hold-only head, into its fee, and on into its fallback.
optimise(pw::PreviousWeights{<:Any, <:Any, Nothing}, rd::ReturnsResult = ReturnsResult();
kwargs...) -> NaiveOptimisationResultHold the weights the head carries.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> Vector
factory(res::NonFiniteAllocationOptimisationResult, fb::Option{<:OptE_Opt_FbChain})
factory(
opt::Union{NonFiniteAllocationOptimisationEstimator, NonFiniteAllocationOptimisationResult},
_
) -> SubsetResamplingResultNo-op factory function for constructing objects with a uniform interface.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> Vector
factory(res::NonFiniteAllocationOptimisationResult, fb::Option{<:OptE_Opt_FbChain})
factory(
opt::Union{NonFiniteAllocationOptimisationEstimator, NonFiniteAllocationOptimisationResult},
_
) -> SubsetResamplingResultNo-op factory function for constructing objects with a uniform interface.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> Vector
factory(res::NonFiniteAllocationOptimisationResult, fb::Option{<:OptE_Opt_FbChain})
factory(
opt::Union{NonFiniteAllocationOptimisationEstimator, NonFiniteAllocationOptimisationResult},
_
) -> SubsetResamplingResultNo-op factory function for constructing objects with a uniform interface.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> Vector
factory(
opt::Union{NonFiniteAllocationOptimisationEstimator, NonFiniteAllocationOptimisationResult},
_
) -> SubsetResamplingResultNo-op factory function for constructing objects with a uniform interface.
struct ArithmeticReturn{__T_settings, __T_ucs, __T_mu, __T_mtx_sqrt} <: JuMPReturnsEstimatorComputes the portfolio return as the arithmetic mean return, the dot product of the expected returns and the weights.
struct JuMPReturnsSettings{__T_scale, __T_lb, __T_rte, __T_fee, __T_mic} <: AbstractEstimatorCarries one return term's own weight in the return sum, its own lower bound, and the two charges netted out of it.
struct MaximumRatio{__T_rf, __T_ohf, __T_kmin} <: ObjectiveFunctionObjective function that maximises the risk-adjusted Sharpe-type ratio.
struct MinimumRisk <: ObjectiveFunctionObjective function that minimises portfolio risk.
factory(
x::LpRegularisation,
pr::AbstractPriorResult
) -> LpRegularisation
factory(
x::LpRegularisation,
pr::AbstractPriorResult,
slv
) -> LpRegularisationResolve the ambiguity radius in val against prior result pr, and return an LpRegularisation holding the number.
struct JuMPOptimiser{__T_pe, __T_slv, __T_wb, __T_bgt, __T_sbgt, __T_gbgt, __T_lt, __T_st, __T_lcse, __T_cte, __T_gcarde, __T_sgcarde, __T_smtx, __T_sgmtx, __T_slt, __T_sst, __T_sglt, __T_sgst, __T_tn, __T_fees, __T_sets, __T_tr, __T_ple, __T_ret, __T_sca, __T_ccnt, __T_cobj, __T_sc, __T_so, __T_ss, __T_card, __T_scard, __T_l2c, __T_lpc, __T_linfc, __T_l1, __T_l2, __T_lp, __T_linf, __T_xbgt, __T_strict, __T_cache} <: BaseJuMPOptimisationEstimatorMain JuMP-based portfolio optimiser configuration.
factory(
opt::JuMPOptimiser,
w::AbstractVector
) -> JuMPOptimiser{_A, _B, _C, _D, _E, _F, _G, _H, _I, _J, _K, _L, _M, _N, _O, _P, _Q, _R, _S, _T, _U, _V, _W, _X, _Y, _Z, _Z1, var"#s185", var"#s1851", _Z2, _Z3, _Z4, _Z5, _Z6, _Z7, _Z8, _Z9, _Z10, _Z11, Bool, Bool} where {_A, _B, _C, _D, _E, _F, _G, _H, _I, _J, _K, _L, _M, _N, _O, _P, _Q, _R, _S, _T, _U, _V, _W, _X, _Y, _Z, _Z1, var"#s185"<:Number, var"#s1851"<:Number, _Z2, _Z3, _Z4, _Z5, _Z6, _Z7, _Z8, _Z9, _Z10, _Z11}Return a copy of opt with all weight-tracking estimator fields updated via factory for the new weights w.
struct MeanRisk{__T_opt, __T_r, __T_obj, __T_wi, __T_fb} <: RiskJuMPOptimisationEstimatorMean-Risk portfolio optimiser.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> Vector
factory(
opt::Union{NonFiniteAllocationOptimisationEstimator, NonFiniteAllocationOptimisationResult},
_
) -> SubsetResamplingResultNo-op factory function for constructing objects with a uniform interface.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> Vector
factory(res::NonFiniteAllocationOptimisationResult, fb::Option{<:OptE_Opt_FbChain})
factory(
opt::Union{NonFiniteAllocationOptimisationEstimator, NonFiniteAllocationOptimisationResult},
_
) -> SubsetResamplingResultNo-op factory function for constructing objects with a uniform interface.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> Vector
factory(res::NonFiniteAllocationOptimisationResult, fb::Option{<:OptE_Opt_FbChain})
factory(
opt::Union{NonFiniteAllocationOptimisationEstimator, NonFiniteAllocationOptimisationResult},
_
) -> SubsetResamplingResultNo-op factory function for constructing objects with a uniform interface.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> Vector
factory(
opt::Union{NonFiniteAllocationOptimisationEstimator, NonFiniteAllocationOptimisationResult},
_
) -> SubsetResamplingResultNo-op factory function for constructing objects with a uniform interface.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> Vector
factory(res::NonFiniteAllocationOptimisationResult, fb::Option{<:OptE_Opt_FbChain})
factory(
opt::Union{NonFiniteAllocationOptimisationEstimator, NonFiniteAllocationOptimisationResult},
_
) -> SubsetResamplingResultNo-op factory function for constructing objects with a uniform interface.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> Vector
factory(
opt::Union{NonFiniteAllocationOptimisationEstimator, NonFiniteAllocationOptimisationResult},
_
) -> SubsetResamplingResultNo-op factory function for constructing objects with a uniform interface.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> Vector
factory(res::NonFiniteAllocationOptimisationResult, fb::Option{<:OptE_Opt_FbChain})
factory(
opt::Union{NonFiniteAllocationOptimisationEstimator, NonFiniteAllocationOptimisationResult},
_
) -> SubsetResamplingResultNo-op factory function for constructing objects with a uniform interface.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> Vector
factory(
opt::Union{NonFiniteAllocationOptimisationEstimator, NonFiniteAllocationOptimisationResult},
_
) -> SubsetResamplingResultNo-op factory function for constructing objects with a uniform interface.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> Vector
factory(
opt::Union{NonFiniteAllocationOptimisationEstimator, NonFiniteAllocationOptimisationResult},
_
) -> SubsetResamplingResultNo-op factory function for constructing objects with a uniform interface.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> Vector
factory(res::NonFiniteAllocationOptimisationResult, fb::Option{<:OptE_Opt_FbChain})
factory(
opt::Union{NonFiniteAllocationOptimisationEstimator, NonFiniteAllocationOptimisationResult},
_
) -> SubsetResamplingResultNo-op factory function for constructing objects with a uniform interface.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> Vector
factory(
opt::Union{NonFiniteAllocationOptimisationEstimator, NonFiniteAllocationOptimisationResult},
_
) -> SubsetResamplingResultNo-op factory function for constructing objects with a uniform interface.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> Vector
factory(res::NonFiniteAllocationOptimisationResult, fb::Option{<:OptE_Opt_FbChain})
factory(
opt::Union{NonFiniteAllocationOptimisationEstimator, NonFiniteAllocationOptimisationResult},
_
) -> SubsetResamplingResultNo-op factory function for constructing objects with a uniform interface.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> Vector
factory(
opt::Union{NonFiniteAllocationOptimisationEstimator, NonFiniteAllocationOptimisationResult},
_
) -> SubsetResamplingResultNo-op factory function for constructing objects with a uniform interface.
factory(
sr::SubsetResamplingResult,
fb::Union{Nothing, Union{var"#s9238", var"#s9237"} where {var"#s9238"<:NonFiniteAllocationOptimisationEstimator, var"#s9237"<:NonFiniteAllocationOptimisationResult}, AbstractVector{<:Tuple{var"#s9237", var"#s9236"} where {var"#s9237"<:OptimisationEstimator, var"#s9236"<:OptimisationResult}}}
) -> SubsetResamplingResultRebuild a SubsetResamplingResult with the fallback chain fb.
factory(res::FiniteAllocationOptimisationResult, fb::Option{<:FOptE_FOpt_FbChain})Rebuild a finite allocation result with a new fallback record fb.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> Vector
factory(res::FiniteAllocationOptimisationResult, fb::Option{<:FOptE_FOpt_FbChain})No-op factory function for constructing objects with a uniform interface.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> Vector
factory(res::FiniteAllocationOptimisationResult, fb::Option{<:FOptE_FOpt_FbChain})No-op factory function for constructing objects with a uniform interface.
optimise(opt::OptimisationEstimator; kwargs...)Reads out a folded optimiser.
optimise(pw::PreviousWeights; kwargs...)Reads out a PreviousWeights that carries a fallback, with no returns data.
factory(opt::OnlinePortfolioSelection, w::VecNum)Thread the previous fold's weights into the head's fee and fallback, and nowhere else.
optimise(opt::OnlinePortfolioSelection; kwargs...) -> OptimisationResultReturns the Recursion Result, the allocation of the state as a Result, and runs no batch path.
factory(
obj::RiskLoss,
w::AbstractVector{<:Union{var"#s152", var"#s69"} where {var"#s152"<:Number, var"#s69"<:AbstractJuMPScalar}}
) -> RiskLossReturn a RiskLoss whose measure takes the Price-Adjusted Allocation w of the step.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> Vector
factory(
rs::AbstractBaseRiskMeasure,
args...;
kwargs...
) -> UncertaintySetVarianceNo-op factory function for constructing objects with a uniform interface.
factory(a::Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}, args...; kwargs...) -> a
factory(a::AbstractVector{<:Union{Nothing, <:AbstractEstimator, <:AbstractAlgorithm,
<:AbstractResult}}, args...; kwargs...) -> Vector
factory(
rs::AbstractBaseRiskMeasure,
args...;
kwargs...
) -> UncertaintySetVarianceNo-op factory function for constructing objects with a uniform interface.
performance_summary(ret::VecNum; ppy::Number = 1, alpha::Number = 0.05,
compound::Bool = false,
benchmark::Option{<:VecNum} = nothing) -> PerformanceSummaryResult
performance_summary(w::ArrNum, X::MatNum, fees::Option{<:Fees} = nothing;
ppy, alpha, compound, benchmark) -> PerformanceSummaryResult
performance_summary(w::ArrNum, rd::ReturnsResult, fees::Option{<:Fees} = nothing;
kwargs...) -> PerformanceSummaryResult
performance_summary(res::OptimisationResult, rd::ReturnsResult;
kwargs...) -> PerformanceSummaryResult
performance_summary(pred::PredRes_MultiPredRes;
benchmark::Option{<:VecNum} = regret_benchmark(pred),
kwargs...) -> PerformanceSummaryResultSummarise a realised return series as a PerformanceSummaryResult.
factory(
p::Pipeline,
w::AbstractVector{<:Union{var"#s152", var"#s69"} where {var"#s152"<:Number, var"#s69"<:AbstractJuMPScalar}}
) -> PipelineRebuild a Pipeline with the weights w of the previous fold in each optimisation step, through pipeline_step_factory.
plot_correlation(X::MatNum, nx::AbstractVector = 1:size(X, 1); kwargs...) -> Plot
plot_correlation(pr::AbstractPriorResult, nx = 1:size(pr.sigma, 1); kwargs...) -> Plot
plot_correlation(pr::AbstractPriorResult, rd::ReturnsResult; kwargs...) -> Plot
plot_correlation(res::OptimisationResult[, rd::ReturnsResult]; kwargs...) -> Plot
plot_correlation(pred::PredictionResult[, rd::ReturnsResult]; kwargs...) -> PlotPlot a correlation matrix as a heatmap, with no clustering and no dendrogram.
plot_drawdowns(
w::ArrNum,
X::MatNum,
fees::Option{<:Fees} = nothing;
slv::Option{<:Slv_VecSlv} = nothing,
ts::AbstractVector = 1:size(X, 1),
compound::Bool = false,
alpha::Number = 0.05,
kappa::Number = 0.3,
rw = nothing,
kwargs...
) -> Plot
plot_drawdowns(w, rd::ReturnsResult, fees = nothing; slv, compound, alpha, kappa, rw, kwargs...) -> Plot
plot_drawdowns(res::OptimisationResult, rd::ReturnsResult; slv, compound, alpha, kappa, rw, kwargs...) -> Plot
plot_drawdowns(pred::PredictionResult; slv, compound, alpha, kappa, rw, kwargs...) -> Plot
plot_drawdowns(mpred::MultiPeriodPredictionResult; slv, compound, alpha, kappa, rw, kwargs...) -> Plot
plot_drawdowns(ppred::PopulationPredictionResult; slv, compound, alpha, kappa, rw, kwargs...) -> Plot
plot_drawdowns(ret::VecNum; ts::AbstractVector, slv, compound, alpha, kappa, rw, kwargs...) -> PlotPlot the cumulative returns of a portfolio above its drawdown, in two panels that share the time axis.
plot_efficient_frontier(
res_vec::AbstractVector{<:OptimisationResult},
pr::Pr_RR;
x::BaseRM_VecBaseRM = Variance(),
y::BaseRM_VecBaseRM = ExpectedReturn(),
c::BaseRM_VecBaseRM = ExpectedReturnRiskRatio(; rk=x, rt=ArithmeticReturn(), rf=0),
slv::Option{<:Slv_VecSlv} = nothing,
fees::Option{<:Fees} = nothing,
min_risk::Bool = true,
max_score::Bool = true,
factory::Bool = true,
kwargs...
) -> Plot
plot_efficient_frontier(res_vec::AbstractVector{<:OptimisationResult}, rd::ReturnsResult; kwargs...) -> Plot
plot_efficient_frontier(w::VecVecNum, pr::Pr_RR; x, y, c, slv, fees, min_risk, max_score, factory, kwargs...) -> Plot
plot_efficient_frontier(res::OptimisationResult, pr::Pr_RR; fees, kwargs...) -> Plot
plot_efficient_frontier(res::OptimisationResult, rd::ReturnsResult; fees, kwargs...) -> PlotPlot a collection of portfolios as a line ordered by risk, coloured by a score, to trace an efficient frontier.
plot_performance_summary(ps::PerformanceSummaryResult; kwargs...) -> Plot
plot_performance_summary(
w::ArrNum,
X::MatNum,
fees::Option{<:Fees} = nothing;
ppy::Number = 1,
alpha::Number = 0.05,
compound::Bool = false,
benchmark::Option{<:VecNum} = nothing,
kwargs...
) -> Plot
plot_performance_summary(ret::VecNum; ppy, alpha, compound, benchmark, kwargs...) -> Plot
plot_performance_summary(w, rd::ReturnsResult, fees = nothing; ppy, alpha, compound, benchmark, kwargs...) -> Plot
plot_performance_summary(res::OptimisationResult, rd::ReturnsResult; ppy, alpha, compound, benchmark, kwargs...) -> Plot
plot_performance_summary(pred::PredRes_MultiPredRes; ppy, alpha, compound, benchmark, kwargs...) -> PlotPlot the performance statistics of a portfolio as a bar chart of eleven bars, blue at a value of zero or more and red below it.
plot_portfolio_cumulative_returns(
w::VecNum_VecVecNum,
X::MatNum,
fees::Option{<:Fees} = nothing;
ts::AbstractVector = 1:size(X, 1),
compound::Bool = false,
kwargs...
) -> Plot
plot_portfolio_cumulative_returns(
w::VecNum_VecVecNum,
pr::Pr_RR,
fees::Option{<:Fees} = nothing;
ts::AbstractVector = 1:size(pr.X, 1),
compound::Bool = false,
kwargs...
) -> Plot
plot_portfolio_cumulative_returns(
res::OptimisationResult,
pr::Pr_RR;
fees::Option{<:Fees} = nothing,
compound::Bool = false,
kwargs...
) -> Plot
plot_portfolio_cumulative_returns(
res::OptimisationResult;
fees::Option{<:Fees} = nothing,
compound::Bool = false,
kwargs...
) -> Plot
plot_portfolio_cumulative_returns(
pred::Union{<:PredictionResult, <:MultiPeriodPredictionResult};
compound::Bool = false,
kwargs...
) -> Plot
plot_portfolio_cumulative_returns(
ppred::PopulationPredictionResult;
compound::Bool = false,
kwargs...
) -> Plot
plot_portfolio_cumulative_returns(
net_ret::VecNum_VecVecNum;
ts::AbstractVector,
compound::Bool = false,
kwargs...
) -> PlotPlot the cumulative returns of a portfolio against time.
plot_portfolio_dashboard(
res::OptimisationResult,
rd::Pr_RR;
ts = 1:size(rd.X, 1),
nx = 1:size(rd.X, 2),
r::BaseRM_VecBaseRM = Variance(),
slv::Option{<:Slv_VecSlv} = nothing,
compound::Bool = false,
N::Option{<:Number} = nothing,
delta::Number = 1e-6,
marginal::Bool = false,
percentage::Bool = true,
alpha::Number = 0.05,
kappa::Number = 0.3,
rw = nothing,
sca::Scalariser = SumScalariser(),
kwargs...
) -> PlotPlot one optimisation result as four panels in a 2 × 2 layout: its composition, its cumulative returns, its risk contributions and its drawdown.
plot_prior(
pr::AbstractPriorResult,
nx::AbstractVector = 1:length(pr.mu);
N::Option{<:Number} = nothing,
kwargs...
) -> Plot
plot_prior(pr::AbstractPriorResult, rd::ReturnsResult; N, kwargs...) -> Plot
plot_prior(res::OptimisationResult[, rd::ReturnsResult]; N, kwargs...) -> Plot
plot_prior(pred::PredictionResult[, rd::ReturnsResult]; N, kwargs...) -> PlotPlot a prior result as three panels side by side: the expected returns, the volatilities and the correlation.
plot_risk_contribution(
r::BaseRM_VecBaseRM,
w::VecNum,
X::MatNum_Pr,
fees::Option{<:Fees} = nothing;
nx::AbstractVector = 1:length(w),
delta::Number = 1e-6,
marginal::Bool = false,
percentage::Bool = true,
erc::Bool = true,
N::Option{<:Number} = nothing,
sca::Scalariser = SumScalariser(),
kwargs...
) -> Plot
plot_risk_contribution(r, w::VecNum, rd::ReturnsResult, fees = nothing; delta, marginal, percentage, erc, N, sca, kwargs...) -> Plot
plot_risk_contribution(r, res::OptimisationResult, rd::ReturnsResult; delta, marginal, percentage, erc, N, sca, kwargs...) -> Plot
plot_risk_contribution(r, res::OptimisationResult, pr::AbstractPriorResult; nx, delta, marginal, percentage, erc, N, sca, kwargs...) -> Plot
plot_risk_contribution(r, pred::PredictionResult, fees = nothing; delta, marginal, percentage, erc, N, sca, kwargs...) -> PlotPlot the risk contribution of each asset as a bar chart.
plot_stacked_bar_composition(
w::VecNum_VecVecNum,
nx::AbstractVector = 1:(isa(w, VecVecNum) ? length(first(w)) : length(w));
kwargs...
) -> Plot
plot_stacked_bar_composition(
res_vec::AbstractVector{<:OptimisationResult},
rd::ReturnsResult;
kwargs...
) -> PlotPlot the compositions of several portfolios as a stacked bar chart, one bar per portfolio.
