PortfolioOptimisers.jl

Appearance

6

Weight Bounds Constraints ​

PortfolioOptimisers.WeightBounds Type
julia
struct WeightBounds{T1, T2} <: AbstractConstraintResult
    lb::T1
    ub::T2
end

Container for lower and upper portfolio weight bounds.

WeightBounds stores the lower (lb) and upper (ub) bounds for portfolio weights, which can be scalars, vectors, or nothing. This type is used to represent weight constraints in portfolio optimisation problems, supporting both global and asset-specific bounds.

Fields

  • lb: Lower bound(s) for portfolio weights.

  • ub: Upper bound(s) for portfolio weights.

Constructor

julia
WeightBounds(lb::Option{<:Num_VecNum},
             ub::Option{<:Num_VecNum})

Validation

  • all(lb .<= ub).

Details

  • If lb or ub is nothing, it indicates no bound in that direction.

  • Supports scalar bounds (same for all assets) or vector bounds (asset-specific).

Examples

julia
julia> WeightBounds(0.0, 1.0)
WeightBounds
  lb ┼ Float64: 0.0
  ub ┴ Float64: 1.0

julia> WeightBounds([0.0, 0.1], [0.8, 1.0])
WeightBounds
  lb ┼ Vector{Float64}: [0.0, 0.1]
  ub ┴ Vector{Float64}: [0.8, 1.0]

Related

source
PortfolioOptimisers.UniformlyDistributedBounds Type
julia
struct UniformlyDistributedBounds <: CustomWeightBoundsAlgorithm end

Custom weight bounds constraint for uniformly distributing asset weights, 1/N for lower bounds and 1 for upper bounds, where N is the number of assets.

Examples

julia
julia> sets = AssetSets(; dict = Dict("nx" => ["A", "B", "C"]));

julia> PortfolioOptimisers.estimator_to_val(UniformlyDistributedBounds(), sets)
0.3333333333333333

Related

source
PortfolioOptimisers.WeightBoundsEstimator Type
julia
struct WeightBoundsEstimator{T1, T2, T3, T4} <: AbstractConstraintEstimator
    lb::T1
    ub::T2
    dlb::T3
    dub::T4
end

Estimator for portfolio weight bounds constraints.

WeightBoundsEstimator constructs lower (lb) and upper (ub) bounds for portfolio weights, supporting scalars, vectors, dictionaries, pairs, or custom constraint types. This estimator enables flexible specification of global, asset-specific, or algorithmic bounds for use in portfolio optimisation workflows.

Fields

  • lb: Lower bound(s) for portfolio weights.

  • ub: Upper bound(s) for portfolio weights.

  • dlb: Default lower bound applied when no specific bound is provided.

  • dub: Default upper bound applied when no specific bound is provided.

Constructor

julia
WeightBoundsEstimator(;
                      lb::Option{<:EstValType_CustWb} = nothing,
                      ub::Option{<:EstValType_CustWb} = nothing)

Validation

  • If lb or ub is a AbstractDict or AbstractVector, it must be non-empty.

Details

  • If lb or ub is nothing, it indicates no bound in that direction.

  • If lb or ub is not nothing, unspecified assets will use dlb or dub respectively. If these are also nothing, defaults to 0.0 for dlb and 1.0 for dub.

Examples

julia
julia> WeightBoundsEstimator(; lb = Dict("A" => 0.1, "B" => 0.2),
                             ub = Dict("A" => 0.8, "B" => 0.9))
WeightBoundsEstimator
   lb ┼ Dict{String, Float64}: Dict("B" => 0.2, "A" => 0.1)
   ub ┼ Dict{String, Float64}: Dict("B" => 0.9, "A" => 0.8)
  dlb ┼ nothing
  dub ┴ nothing

julia> WeightBoundsEstimator(; lb = UniformlyDistributedBounds(), ub = nothing)
WeightBoundsEstimator
   lb ┼ UniformlyDistributedBounds()
   ub ┼ nothing
  dlb ┼ nothing
  dub ┴ nothing

Related

source
PortfolioOptimisers.weight_bounds_constraints Function
julia
weight_bounds_constraints(wb::WeightBoundsEstimator, sets::AssetSets; strict::Bool = false,
                          datatype::DataType = Float64, kwargs...)

Generate portfolio weight bounds constraints from a WeightBoundsEstimator and asset set.

weight_bounds_constraints constructs a WeightBounds object representing lower and upper portfolio weight bounds for the assets in sets, using the specifications in wb. Supports scalar, vector, dictionary, pair, or custom constraint types for flexible bound assignment.

Arguments

  • wb: WeightBoundsEstimator specifying lower and upper bounds.

  • sets: AssetSets containing asset names or indices.

  • strict: If true, enforces strict matching between assets and bounds (throws error on mismatch); if false, issues a warning.

  • datatype: Output data type for bounds.

  • kwargs...: Additional keyword arguments passed to bound extraction routines.

Returns

  • wb::WeightBounds: Object containing lower and upper bounds aligned with sets.

Details

  • Lower and upper bounds are extracted using estimator_to_val, mapped to assets in sets.

  • Supports composable and asset-specific constraints.

  • If a bound is nothing, indicates no constraint in that direction.

Examples

julia
julia> sets = AssetSets(; dict = Dict("nx" => ["A", "B", "C"]));

julia> wb = WeightBoundsEstimator(; lb = Dict("A" => 0.1, "B" => 0.2), ub = 1.0);

julia> weight_bounds_constraints(wb, sets)
WeightBounds
  lb ┼ Vector{Float64}: [0.1, 0.2, 0.0]
  ub ┴ Float64: 1.0

Related

source
julia
weight_bounds_constraints(wb::WeightBounds{<:Any, <:Any}, args...; N::Integer = 0, kwargs...)

Propagate or expand portfolio weight bounds constraints from a WeightBounds object.

weight_bounds_constraints returns the input WeightBounds object unchanged if scalar is true or N is zero. Otherwise, it expands scalar or nothing bounds to vectors or ranges of length N using weight_bounds_constraints_side, ensuring per-asset constraints are properly propagated.

Arguments

  • wb: WeightBounds object containing lower and upper bounds.

  • args...: Additional positional arguments (ignored).

  • scalar: If true, treat bounds as scalar and return unchanged.

  • N: Number of assets (length for expansion; if zero, treat as scalar).

  • kwargs...: Additional keyword arguments (ignored).

Returns

  • wb::WeightBounds: Expanded or unchanged bounds object.

Details

Examples

julia
julia> weight_bounds_constraints(WeightBounds(0.0, 1.0); N = 3)
WeightBounds
  lb ┼ StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}: StepRangeLen(0.0, 0.0, 3)
  ub ┴ StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}: StepRangeLen(1.0, 0.0, 3)

julia> weight_bounds_constraints(WeightBounds([0.1, 0.2, 0.3], 1.0); N = 3)
WeightBounds
  lb ┼ Vector{Float64}: [0.1, 0.2, 0.3]
  ub ┴ StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}: StepRangeLen(1.0, 0.0, 3)

Related

source
julia
weight_bounds_constraints(wb::WeightBounds{<:VecNum, <:VecNum}, args...;
                          kwargs...)

Propagate asset-specific portfolio weight bounds constraints from a WeightBounds object with vector bounds.

weight_bounds_constraints returns the input WeightBounds object unchanged when both lower and upper bounds are provided as vectors. This method is used to propagate explicit per-asset bounds in constraint generation workflows, ensuring that asset-specific constraints are preserved.

Arguments

  • wb: WeightBounds object with vector lower and upper bounds.

  • args...: Additional positional arguments (ignored).

  • kwargs...: Additional keyword arguments (ignored).

Returns

  • wb::WeightBounds: The input bounds object, unchanged.

Examples

julia
julia> weight_bounds_constraints(WeightBounds([0.1, 0.2, 0.3], [0.8, 0.9, 1.0]))
WeightBounds
  lb ┼ Vector{Float64}: [0.1, 0.2, 0.3]
  ub ┴ Vector{Float64}: [0.8, 0.9, 1.0]

Related

source
julia
weight_bounds_constraints(wb::Nothing, args...; N::Integer = 0, kwargs...)

Generate unconstrained portfolio weight bounds when no bounds are specified.

weight_bounds_constraints returns a WeightBounds object with lower bounds set to -Inf and upper bounds set to Inf for all assets when wb is nothing.

Arguments

  • wb::Nothing: Indicates no constraint for portfolio weights.

  • args...: Additional positional arguments (ignored).

  • N::Integer: Number of assets (length for expansion; if zero, treat as scalar).

  • kwargs...: Additional keyword arguments (ignored).

Returns

  • wb::WeightBounds: Object with unconstrained lower and upper bounds.

Details

  • If scalar is true or N == 0, returns WeightBounds(-Inf, Inf).

  • Otherwise, returns WeightBounds(fill(-Inf, N), fill(Inf, N)).

Examples

julia
julia> weight_bounds_constraints(nothing; N = 3)
WeightBounds
  lb ┼ Vector{Float64}: [-Inf, -Inf, -Inf]
  ub ┴ Vector{Float64}: [Inf, Inf, Inf]

Related

source
PortfolioOptimisers.CustomWeightBoundsAlgorithm Type
julia
abstract type CustomWeightBoundsAlgorithm <: AbstractConstraintAlgorithm end

Abstract supertype for custom portfolio weight bounds constraints.

CustomWeightBoundsAlgorithm provides an interface for implementing user-defined or algorithmic portfolio weight bounds. Subtypes can encode advanced or non-standard weight constraints, such as scaled, grouped, or dynamically computed bounds, for use in portfolio optimisation workflows.

Related

source
PortfolioOptimisers.weight_bounds_constraints_side Function
julia
weight_bounds_constraints_side(::Nothing, N::Integer, val::Number)

Generate a vector of portfolio weight bounds when no constraint is specified.

weight_bounds_constraints_side returns a vector of length N filled with the value val when the input bound is nothing. This is used to represent unconstrained portfolio weights (e.g., -Inf for lower bounds, Inf for upper bounds) in constraint generation routines.

Arguments

  • ::Nothing: Indicates no constraint for this bound direction.

  • N: Number of assets (length of the output vector).

  • val: Value to fill (typically -Inf or Inf).

Returns

  • wb::VecNum: Vector of length N filled with val.

Examples

julia
julia> PortfolioOptimisers.weight_bounds_constraints_side(nothing, 3, -Inf)
3-element Vector{Float64}:
 -Inf
 -Inf
 -Inf

Related

source
julia
weight_bounds_constraints_side(wb::Number, N::Integer, val::Number)

Generate a vector of portfolio weight bounds from a scalar bound.

weight_bounds_constraints_side returns a vector of length N filled with val if wb is infinite, or a vector of length N with all elements equal to wb otherwise. This is used to propagate scalar portfolio weight bounds to all assets in constraint generation routines.

Arguments

  • wb::Number: Scalar bound for portfolio weights (can be finite or infinite).

  • N::Integer: Number of assets (length of the output vector).

  • val::Number: Value to fill if wb is infinite (typically -Inf or Inf).

Returns

  • wb::VecNum: Vector of length N filled with wb or val.

Examples

julia
julia> PortfolioOptimisers.weight_bounds_constraints_side(0.1, 3, -Inf)
StepRangeLen(0.1, 0.0, 3)

julia> PortfolioOptimisers.weight_bounds_constraints_side(Inf, 3, -Inf)
3-element Vector{Float64}:
 -Inf
 -Inf
 -Inf

Related

source
julia
weight_bounds_constraints_side(wb::VecNum, args...)

Propagate asset-specific portfolio weight bounds from a vector.

weight_bounds_constraints_side returns the input vector wb unchanged when asset-specific bounds are provided as a vector. This method is used to propagate explicit per-asset bounds in constraint generation routines.

Arguments

  • wb: Vector of bounds for portfolio weights (one per asset).

  • args...: Additional positional arguments (ignored).

Returns

  • wb::AbstractVector: The input vector, unchanged.

Examples

julia
julia> PortfolioOptimisers.weight_bounds_constraints_side([0.1, 0.2, 0.3])
3-element Vector{Float64}:
 0.1
 0.2
 0.3

Related

source
PortfolioOptimisers.EstValType_CustWb Type
julia
const EstValType_CustWb = Union{<:EstValType, <:CustomWeightBoundsAlgorithm}

Union type for custom weight bounds estimator values.

EstValType_CustWb is a union type that allows either standard estimator values (EstValType) or custom weight bounds algorithms (CustomWeightBoundsAlgorithm) to be used for specifying portfolio weight bounds. This enables flexible assignment of bounds, supporting both conventional numeric types and advanced, user-defined constraint algorithms in portfolio optimisation workflows.

Related Types

source