Entropic X at Risk

PortfolioOptimisers.EntropicValueatRisk Type

struct EntropicValueatRisk{__T_settings, __T_slv, __T_alpha, __T_w} <: RiskMeasure

Represents the Entropic Value-at-Risk (EVaR) risk measure.

EntropicValueatRisk is a coherent risk measure based on the Chernoff bound. It is an upper bound for both CVaR and VaR and is computed by solving a conic optimisation problem via an external solver.

Mathematical definition

The EVaR is defined via the Chernoff bound as the tightest exponential upper bound on VaR and CVaR:

$$\begin{array}{rl}{\mathrm{EVaR}}_{\alpha }(\mathit{x})& =\underset{z>0}{inf}\left\{z\ln \left(\frac{M_L(1/z)}{\alpha }\right)\right\}.\end{array}$$

Where:

• ${\mathrm{EVaR}}_{\alpha }(\mathit{x})$: Entropic Value-at-Risk (tightest exponential upper bound on VaR and CVaR).

• $\mathit{x}$: Portfolio returns vector $T\times 1$.

• $\alpha$: Significance level (left tail probability), $\alpha \in (0,1)$.

• $L_t=-x_t$: Loss at period $t$.

• $M_L(u)=\mathbb{E}[e^{uL}]$: Moment-generating function of the loss.

• $z$: Exponential tilt parameter.

Computationally, it is solved via the conic programme:

$$\begin{array}{rl}{\mathrm{EVaR}}_{\alpha }(\mathit{x})& =\underset{t,z,\mathit{u}}{min}\{t-z\ln (\alpha T):z\ge 0,\sum _{i=1}^T{u}_i\le z,(-x_i-t,z,u_i)\in K_{\exp }\mathrm{\forall }i\}.\end{array}$$

Where:

• $T$: Number of observations.

• $t$, $z$, $\mathit{u}$: Conic optimisation variables.

• $K_{\exp }=\{(a,b,c):b{e}^{a/b}\le c,b>0\}$: Exponential cone.

Fields

• settings: Risk measure settings.

• slv: Solver or vector of solvers.

• alpha: Quantile level for the lower tail.

• w: Optional observation weights vector observations × 1, or a concrete subtype of DynamicAbstractWeights. If nothing, the computation is unweighted.

Constructors

EntropicValueatRisk(;
    settings::RiskMeasureSettings = RiskMeasureSettings(),
    slv::Option{<:Slv_VecSlv} = nothing,
    alpha::Number = 0.05,
    w::Option{<:ObsWeights} = nothing
) -> EntropicValueatRisk

Keywords correspond to the struct's fields.

Validation

• 0 < alpha < 1.

• If slv is a VecSlv: !isempty(slv).

• If w is not nothing: !isempty(w).

Functor

(r::EntropicValueatRisk)(x::VecNum)

Computes the EVaR of a portfolio returns vector x.

Arguments

• x::VecNum: Portfolio returns vector.

Examples

julia> EntropicValueatRisk()
EntropicValueatRisk
  settings ┼ RiskMeasureSettings
           │   scale ┼ Float64: 1.0
           │      ub ┼ nothing
           │     rke ┴ Bool: true
       slv ┼ nothing
     alpha ┼ Float64: 0.05
         w ┴ nothing

Related

• RiskMeasure

• RiskMeasureSettings

• RelativisticValueatRisk

• EntropicValueatRiskRange

• EntropicDrawdownatRisk

source

PortfolioOptimisers.factory Function

factory(
    r::EntropicValueatRisk,
    pr::AbstractPriorResult;
    ...
) -> EntropicValueatRisk
factory(
    r::EntropicValueatRisk,
    pr::AbstractPriorResult,
    slv::Union{Nothing, Solver, AbstractVector{<:Solver}},
    args...;
    kwargs...
) -> EntropicValueatRisk

Create an instance of EntropicValueatRisk by selecting observation weights and solver from the risk-measure instance or falling back to the prior result.

Related

• EntropicValueatRisk

• AbstractPriorResult

• factory

• nothing_scalar_array_selector

• solver_selector

source

PortfolioOptimisers.factory Function

factory(
    r::EntropicValueatRisk,
    slv::Union{Solver, AbstractVector{<:Solver}};
    ...
) -> Union{EntropicValueatRisk{RiskMeasureSettings{__T_scale, __T_ub, __T_rke}, <:AbstractVector{var"#s869"}, <:Number} where {__T_scale, __T_ub, __T_rke, var"#s869"<:Solver}, EntropicValueatRisk{RiskMeasureSettings{__T_scale, __T_ub, __T_rke}, Solver{__T_name, __T_solver, __T_settings, __T_check_sol, __T_add_bridges}, <:Number} where {__T_scale, __T_ub, __T_rke, __T_name, __T_solver, __T_settings, __T_check_sol, __T_add_bridges}}
factory(
    r::EntropicValueatRisk,
    slv::Union{Solver, AbstractVector{<:Solver}},
    pr::Union{Nothing, AbstractPriorResult},
    args...;
    kwargs...
) -> EntropicValueatRisk

Create an instance of EntropicValueatRisk by overriding the solver and optionally selecting observation weights from the prior result.

Related

• EntropicValueatRisk

• AbstractPriorResult

• factory

• nothing_scalar_array_selector

• solver_selector

source

PortfolioOptimisers.EntropicValueatRiskRange Type

struct EntropicValueatRiskRange{__T_settings, __T_slv, __T_alpha, __T_beta, __T_w} <: RiskMeasure

Represents the Entropic Value-at-Risk Range (EVaR Range) risk measure.

EntropicValueatRiskRange computes the difference between the lower-tail EVaR (at level alpha) and the upper-tail EVaR (at level beta).

Mathematical definition

$$\begin{array}{rl}{\mathrm{EVaRRange}}_{\alpha ,\beta }(\mathit{x})& ={\mathrm{EVaR}}_{\alpha }(\mathit{x})+{\mathrm{EVaR}}_{\beta }(-\mathit{x}).\end{array}$$

Where:

• ${\mathrm{EVaRRange}}_{\alpha ,\beta }(\mathit{x})$: EVaR range (entropic tail spread).

• $\mathit{x}$: Portfolio returns vector $T\times 1$.

• ${\mathrm{EVaR}}_{\alpha }(\mathit{x})$: Lower-tail entropic risk at level $\alpha$.

• ${\mathrm{EVaR}}_{\beta }(-\mathit{x})$: Upper-tail entropic risk at level $\beta$.

Fields

• settings: Risk measure settings.

• slv: Solver or vector of solvers.

• alpha: Quantile level for the lower tail.

• beta: Quantile level for the upper tail.

• w: Optional observation weights vector observations × 1, or a concrete subtype of DynamicAbstractWeights. If nothing, the computation is unweighted.

Constructors

EntropicValueatRiskRange(;
    settings::RiskMeasureSettings = RiskMeasureSettings(),
    slv::Option{<:Slv_VecSlv} = nothing,
    alpha::Number = 0.05,
    beta::Number = 0.05,
    w::Option{<:ObsWeights} = nothing
) -> EntropicValueatRiskRange

Keywords correspond to the struct's fields.

Validation

• 0 < alpha < 1, 0 < beta < 1.

• If slv is a VecSlv: !isempty(slv).

• If w is not nothing: !isempty(w).

Related

• RiskMeasure

• RiskMeasureSettings

• EntropicValueatRisk

source

PortfolioOptimisers.factory Method

factory(
    r::EntropicValueatRiskRange,
    pr::AbstractPriorResult,
    slv::Union{Nothing, Solver, AbstractVector{<:Solver}},
    args...;
    kwargs...
) -> EntropicValueatRiskRange

Create an instance of EntropicValueatRiskRange by selecting observation weights and solver from the risk-measure instance or falling back to the prior result.

Related

• EntropicValueatRiskRange

• AbstractPriorResult

• factory

• nothing_scalar_array_selector

• solver_selector

source

PortfolioOptimisers.EntropicDrawdownatRisk Type

struct EntropicDrawdownatRisk{__T_settings, __T_slv, __T_alpha, __T_w} <: RiskMeasure

Represents the Entropic Drawdown-at-Risk (EDaR) risk measure.

EntropicDrawdownatRisk applies the Entropic Value-at-Risk framework to the absolute drawdown series of portfolio returns. It is a coherent risk measure providing an upper bound on both the Drawdown-at-Risk and Conditional Drawdown-at-Risk.

Mathematical definition

Define the absolute drawdown series:

$$\begin{array}{rl}{c}_t& =\sum _{s=1}^t{x}_s,\\ d_t& =c_t-\underset{0\le s\le t}{max}{c}_s\le 0.\end{array}$$

Where:

• $\mathit{x}$: Portfolio returns vector $T\times 1$.

• $c_t$: Cumulative simple portfolio return at period $t$.

• $d_t\le 0$: Absolute drawdown at period $t$.

The EDaR is the EVaR of the drawdown series:

$$\begin{array}{rl}{\mathrm{EDaR}}_{\alpha }(\mathit{x})& ={\mathrm{EVaR}}_{\alpha }(\mathit{d}(\mathit{x})).\end{array}$$

Where:

• ${\mathrm{EDaR}}_{\alpha }(\mathit{x})$: Entropic Drawdown-at-Risk.

• $\alpha$: Significance level (left tail probability), $\alpha \in (0,1)$.

• $\mathit{d}(\mathit{x})$: Absolute drawdown series vector $T\times 1$.

Fields

• settings: Risk measure settings.

• slv: Solver or vector of solvers.

• alpha: Quantile level for the lower tail.

• w: Optional observation weights vector observations × 1, or a concrete subtype of DynamicAbstractWeights. If nothing, the computation is unweighted.

Constructors

EntropicDrawdownatRisk(;
    settings::RiskMeasureSettings = RiskMeasureSettings(),
    slv::Option{<:Slv_VecSlv} = nothing,
    alpha::Number = 0.05,
    w::Option{<:ObsWeights} = nothing
) -> EntropicDrawdownatRisk

Keywords correspond to the struct's fields.

Validation

• 0 < alpha < 1.

• If slv is a VecSlv: !isempty(slv).

• If w is not nothing: !isempty(w).

Functor

(r::EntropicDrawdownatRisk)(x::VecNum)

Computes the EDaR of a portfolio returns vector x.

Arguments

• x::VecNum: Portfolio returns vector.

Examples

julia> EntropicDrawdownatRisk()
EntropicDrawdownatRisk
  settings ┼ RiskMeasureSettings
           │   scale ┼ Float64: 1.0
           │      ub ┼ nothing
           │     rke ┴ Bool: true
       slv ┼ nothing
     alpha ┼ Float64: 0.05
         w ┴ nothing

Related

• RiskMeasure

• RiskMeasureSettings

• EntropicValueatRisk

• RelativisticDrawdownatRisk

• RelativeEntropicDrawdownatRisk

source

PortfolioOptimisers.factory Function

factory(
    r::EntropicDrawdownatRisk,
    pr::AbstractPriorResult;
    ...
) -> EntropicDrawdownatRisk
factory(
    r::EntropicDrawdownatRisk,
    pr::AbstractPriorResult,
    slv::Union{Nothing, Solver, AbstractVector{<:Solver}},
    args...;
    kwargs...
) -> EntropicDrawdownatRisk

Create an instance of EntropicDrawdownatRisk by selecting observation weights and solver from the risk-measure instance or falling back to the prior result.

Related

• EntropicDrawdownatRisk

• AbstractPriorResult

• factory

• nothing_scalar_array_selector

• solver_selector

source

PortfolioOptimisers.factory Function

factory(
    r::EntropicDrawdownatRisk,
    slv::Union{Solver, AbstractVector{<:Solver}};
    ...
) -> Union{EntropicDrawdownatRisk{RiskMeasureSettings{__T_scale, __T_ub, __T_rke}, <:AbstractVector{var"#s869"}, <:Number} where {__T_scale, __T_ub, __T_rke, var"#s869"<:Solver}, EntropicDrawdownatRisk{RiskMeasureSettings{__T_scale, __T_ub, __T_rke}, Solver{__T_name, __T_solver, __T_settings, __T_check_sol, __T_add_bridges}, <:Number} where {__T_scale, __T_ub, __T_rke, __T_name, __T_solver, __T_settings, __T_check_sol, __T_add_bridges}}
factory(
    r::EntropicDrawdownatRisk,
    slv::Union{Solver, AbstractVector{<:Solver}},
    pr::Union{Nothing, AbstractPriorResult},
    args...;
    kwargs...
) -> EntropicDrawdownatRisk

Create an instance of EntropicDrawdownatRisk by overriding the solver and optionally selecting observation weights from the prior result.

Related

• EntropicDrawdownatRisk

• AbstractPriorResult

• factory

• nothing_scalar_array_selector

• solver_selector

source

PortfolioOptimisers.RelativeEntropicDrawdownatRisk Type

struct RelativeEntropicDrawdownatRisk{__T_settings, __T_slv, __T_alpha, __T_w} <: HierarchicalRiskMeasure

Represents the Relative Entropic Drawdown-at-Risk (Relative EDaR) risk measure for hierarchical optimisation.

RelativeEntropicDrawdownatRisk applies the Entropic Value-at-Risk framework to the relative (compounded) drawdown series of portfolio returns.

Mathematical definition

Define the compounded wealth process and relative drawdown series:

$$\begin{array}{rl}{C}_t& =\prod _{s=1}^t(1+x_s),\\ r{d}_t& =\frac{C_t}{\underset{0\le s\le t}{max}{C}_s}-1\le 0.\end{array}$$

Where:

• $\mathit{x}$: Portfolio returns vector $T\times 1$.

• $C_t$: Compound wealth process at period $t$.

• $r{d}_t\le 0$: Relative drawdown at period $t$.

The Relative EDaR is the EVaR of the relative drawdown series:

$$\begin{array}{rl}{\mathrm{REDaR}}_{\alpha }(\mathit{x})& ={\mathrm{EVaR}}_{\alpha }(\mathit{r}\mathit{d}(\mathit{x})).\end{array}$$

Where:

• ${\mathrm{REDaR}}_{\alpha }(\mathit{x})$: Relative Entropic Drawdown-at-Risk.

• $\alpha$: Significance level (left tail probability), $\alpha \in (0,1)$.

• $\mathit{r}\mathit{d}(\mathit{x})$: Relative drawdown series vector $T\times 1$.

Fields

• settings: Risk measure settings.

• slv: Solver or vector of solvers.

• alpha: Quantile level for the lower tail.

• w: Optional observation weights vector observations × 1, or a concrete subtype of DynamicAbstractWeights. If nothing, the computation is unweighted.

Constructors

RelativeEntropicDrawdownatRisk(;
    settings::HierarchicalRiskMeasureSettings = HierarchicalRiskMeasureSettings(),
    slv::Option{<:Slv_VecSlv} = nothing,
    alpha::Number = 0.05,
    w::Option{<:ObsWeights} = nothing
) -> RelativeEntropicDrawdownatRisk

Keywords correspond to the struct's fields.

Validation

• 0 < alpha < 1.

• If slv is a VecSlv: !isempty(slv).

• If w is not nothing: !isempty(w).

Functor

(r::RelativeEntropicDrawdownatRisk)(x::VecNum)

Computes the Relative EDaR of a portfolio returns vector x.

Arguments

• x::VecNum: Portfolio returns vector.

Examples

julia> RelativeEntropicDrawdownatRisk()
RelativeEntropicDrawdownatRisk
  settings ┼ HierarchicalRiskMeasureSettings
           │   scale ┴ Float64: 1.0
       slv ┼ nothing
     alpha ┼ Float64: 0.05
         w ┴ nothing

Related

• HierarchicalRiskMeasure

• HierarchicalRiskMeasureSettings

• EntropicDrawdownatRisk

• RelativeRelativisticDrawdownatRisk

source

PortfolioOptimisers.factory Function

factory(
    r::RelativeEntropicDrawdownatRisk,
    pr::AbstractPriorResult;
    ...
) -> RelativeEntropicDrawdownatRisk
factory(
    r::RelativeEntropicDrawdownatRisk,
    pr::AbstractPriorResult,
    slv::Union{Nothing, Solver, AbstractVector{<:Solver}},
    args...;
    kwargs...
) -> RelativeEntropicDrawdownatRisk

Create an instance of RelativeEntropicDrawdownatRisk by selecting observation weights and solver from the risk-measure instance or falling back to the prior result.

Related

• RelativeEntropicDrawdownatRisk

• AbstractPriorResult

• factory

• nothing_scalar_array_selector

• solver_selector

source

PortfolioOptimisers.factory Function

factory(
    r::RelativeEntropicDrawdownatRisk,
    slv::Union{Solver, AbstractVector{<:Solver}};
    ...
) -> Union{RelativeEntropicDrawdownatRisk{HierarchicalRiskMeasureSettings{__T_scale}, <:AbstractVector{var"#s869"}, <:Number} where {__T_scale, var"#s869"<:Solver}, RelativeEntropicDrawdownatRisk{HierarchicalRiskMeasureSettings{__T_scale}, Solver{__T_name, __T_solver, __T_settings, __T_check_sol, __T_add_bridges}, <:Number} where {__T_scale, __T_name, __T_solver, __T_settings, __T_check_sol, __T_add_bridges}}
factory(
    r::RelativeEntropicDrawdownatRisk,
    slv::Union{Solver, AbstractVector{<:Solver}},
    pr::Union{Nothing, AbstractPriorResult},
    args...;
    kwargs...
) -> RelativeEntropicDrawdownatRisk

Create an instance of RelativeEntropicDrawdownatRisk by overriding the solver and optionally selecting observation weights from the prior result.

Related

• RelativeEntropicDrawdownatRisk

• AbstractPriorResult

• factory

• nothing_scalar_array_selector

• solver_selector

source

PortfolioOptimisers.ERM Function

ERM(x, slv, alpha = 0.05, ...; kwargs...)

Compute the Entropic Risk Measure (ERM) for a vector of portfolio returns.

Solves a convex optimisation problem to compute the ERM at confidence level alpha, using the specified solver(s). The ERM is a coherent risk measure based on the exponential moment of the loss distribution.

Arguments

• x: Vector of portfolio returns.

• slv: Solver or vector of solvers.

• alpha: Confidence level (default 0.05).

• Additional parameters depending on the specific ERM formulation.

• kwargs...: Additional keyword arguments passed to the solver.

Returns

• ERM value (scalar).

Related

• EntropicValueatRisk

• Slv_VecSlv

source