Tools

PortfolioOptimisers.VecScalar Type

struct VecScalar{T1, T2} <: AbstractResult
    v::T1
    s::T2
end

Represents a composite result containing a vector and a scalar in PortfolioOptimisers.jl.

Encapsulates a vector and a scalar value, commonly used for storing results that combine both types of data (e.g., weighted statistics, risk measures).

Fields

• v: Vector value.

• s: Scalar value.

Constructors

VecScalar(; v::AbstractVector, s::Real)

Arguments correspond to the fields above.

Validation

• v: !isempty(v) and all(isfinite, v).

• s: isfinite(s).

Examples

julia> VecScalar([1.0, 2.0, 3.0], 4.2)
VecScalar
  v ┼ Vector{Float64}: [1.0, 2.0, 3.0]
  s ┴ Float64: 4.2

Related

• AbstractResult

source

PortfolioOptimisers.brinson_attribution Function

brinson_attribution(X::TimeArray, w::AbstractVector, wb::AbstractVector,
                    asset_classes::DataFrame, col; date0 = nothing, date1 = nothing)

source

PortfolioOptimisers.traverse_concrete_subtypes Function

traverse_concrete_subtypes(t; ctarr::Union{Nothing, <:AbstractVector} = nothing)

Recursively traverse all subtypes of the given abstract type t and collect all concrete struct types into ctarr.

Arguments

• t: An abstract type whose subtypes will be traversed.

• ctarr: Optional An array to collect the concrete types. If not provided, a new empty array is created.

Returns

An array containing all concrete struct types that are subtypes (direct or indirect) of types.

Examples

julia> abstract type MyAbstract end

julia> struct MyConcrete1 <: MyAbstract end

julia> struct MyConcrete2 <: MyAbstract end

julia> traverse_concrete_subtypes(MyAbstract)
2-element Vector{Any}:
 MyConcrete1
 MyConcrete2

source

PortfolioOptimisers.AbstractReturnsResult Type

abstract type AbstractReturnsResult <: AbstractResult end

Abstract supertype for all returns result types in PortfolioOptimisers.jl.

All concrete types representing the result of returns calculations (e.g., asset returns, factor returns) should subtype AbstractReturnsResult. This enables a consistent interface for downstream analysis and optimization routines.

Related

• AbstractResult

• ReturnsResult

source

PortfolioOptimisers.assert_nonneg_finite_val Function

assert_nonneg_finite_val(val::Union{<:Real, <:Pair, <:AbstractDict,
                                    <:AbstractVector{<:Real}, <:AbstractVector{<:Pair}})
assert_nonneg_finite_val(args...)

Validate that the input value is non-negative and finite.

Checks that the provided value (scalar, vector, dictionary, or pair) contains only finite and non-negative entries. Used for defensive programming and input validation throughout PortfolioOptimisers.jl.

Arguments

• val: Input value to validate.

Returns

• nothing: Returns nothing if validation passes.

Validation

• args...: always passes.

• Real: isfinite(val) and val >= 0.

• Pair: isfinite(val[2]) and val[2] >= 0.

• AbstractDict: !isempty(val), any(isfinite, values(val)), all(x -> x >= 0, values(val)).

• AbstractVector{<:Real}: !isempty(val), any(isfinite, val), all(x -> x >= 0, val).

• AbstractVector{<:Pair}: !isempty(val), any(isfinite, getindex.(val, 2)), all(x -> x[2] >= 0, val).

source

PortfolioOptimisers.assert_matrix_issquare Function

assert_matrix_issquare(A::AbstractMatrix)

Assert that size(A, 1) == size(A, 2).

source

PortfolioOptimisers.:⊗ Function

⊗(A::AbstractArray, B::AbstractArray)

Tensor product of two arrays. Returns a matrix of size (length(A), length(B)) where each element is the product of elements from A and B.

Examples

julia> PortfolioOptimisers.:⊗([1, 2], [3, 4])
2×2 Matrix{Int64}:
 3  4
 6  8

source

PortfolioOptimisers.:⊙ Function

⊙(A, B)

Elementwise multiplication.

Examples

julia> PortfolioOptimisers.:⊙([1, 2], [3, 4])
2-element Vector{Int64}:
 3
 8

julia> PortfolioOptimisers.:⊙([1, 2], 2)
2-element Vector{Int64}:
 2
 4

julia> PortfolioOptimisers.:⊙(2, [3, 4])
2-element Vector{Int64}:
 6
 8

julia> PortfolioOptimisers.:⊙(2, 3)
6

source

PortfolioOptimisers.:⊘ Function

⊘(A, B)

Elementwise division.

Examples

julia> PortfolioOptimisers.:⊘([4, 9], [2, 3])
2-element Vector{Float64}:
 2.0
 3.0

julia> PortfolioOptimisers.:⊘([4, 6], 2)
2-element Vector{Float64}:
 2.0
 3.0

julia> PortfolioOptimisers.:⊘(8, [2, 4])
2-element Vector{Float64}:
 4.0
 2.0

julia> PortfolioOptimisers.:⊘(8, 2)
4.0

source

PortfolioOptimisers.:⊕ Function

⊕(A, B)

Elementwise addition.

Examples

julia> PortfolioOptimisers.:⊕([1, 2], [3, 4])
2-element Vector{Int64}:
 4
 6

julia> PortfolioOptimisers.:⊕([1, 2], 2)
2-element Vector{Int64}:
 3
 4

julia> PortfolioOptimisers.:⊕(2, [3, 4])
2-element Vector{Int64}:
 5
 6

julia> PortfolioOptimisers.:⊕(2, 3)
5

source

PortfolioOptimisers.:⊖ Function

⊖(A, B)

Elementwise subtraction.

Examples

julia> PortfolioOptimisers.:⊖([4, 6], [1, 2])
2-element Vector{Int64}:
 3
 4

julia> PortfolioOptimisers.:⊖([4, 6], 2)
2-element Vector{Int64}:
 2
 4

julia> PortfolioOptimisers.:⊖(8, [2, 4])
2-element Vector{Int64}:
 6
 4

julia> PortfolioOptimisers.:⊖(8, 2)
6

source

PortfolioOptimisers.concrete_typed_array Function

concrete_typed_array(A::AbstractArray)

Convert an AbstractArray A to a concrete typed array, where each element is of the same type as the elements of A.

This is useful for converting arrays with abstract element types to arrays with concrete element types, which can improve performance in some cases.

Arguments

• A: The input array.

Returns

A new array with the same shape as A, but with a concrete element type inferred from the elements of A.

Examples

julia> A = Any[1, 2.0, 3];

julia> PortfolioOptimisers.concrete_typed_array(A)
3-element Vector{Union{Float64, Int64}}:
 1
 2.0
 3

source

PortfolioOptimisers.dot_scalar Function

dot_scalar(a::Real, b::AbstractVector)
dot_scalar(a::AbstractVector, b::Real)
dot_scalar(a::AbstractVector, b::AbstractVector)

Efficient scalar and vector dot product utility.

• If one argument is a Real and the other an AbstractVector, returns the scalar times the sum of the vector.

• If both arguments are AbstractVectors, returns their dot product.

Returns

• Real: The resulting scalar.

Examples

julia> PortfolioOptimisers.dot_scalar(2.0, [1.0, 2.0, 3.0])
12.0

julia> PortfolioOptimisers.dot_scalar([1.0, 2.0, 3.0], 2.0)
12.0

julia> PortfolioOptimisers.dot_scalar([1.0, 2.0, 3.0], [4.0, 5.0, 6.0])
32.0

source

PortfolioOptimisers.nothing_scalar_array_view Function

nothing_scalar_array_view(x, i)

Utility for safely viewing or indexing into possibly nothing, scalar, or array values.

• x: Input value.

  • nothing: returns nothing.

  • Real: returns x.

  • AbstractVector{<:Real}: returns view(x, i).

  • AbstractVector{<:AbstractVector}: returns [view(xi, i) for xi in x].

  • AbstractArray: returns view(x, i, i).

Arguments

• x: Input value, which may be nothing, a scalar, vector, or array.

• i: Index or indices to view.

Returns

• The corresponding view or value, or nothing if x is nothing.

Examples

julia> PortfolioOptimisers.nothing_scalar_array_view(nothing, 1:2)

julia> PortfolioOptimisers.nothing_scalar_array_view(3.0, 1:2)
3.0

julia> PortfolioOptimisers.nothing_scalar_array_view([1.0, 2.0, 3.0], 2:3)
2-element view(::Vector{Float64}, 2:3) with eltype Float64:
 2.0
 3.0

julia> PortfolioOptimisers.nothing_scalar_array_view([[1, 2], [3, 4]], 1)
2-element Vector{SubArray{Int64, 0, Vector{Int64}, Tuple{Int64}, true}}:
 fill(1)
 fill(3)

source

PortfolioOptimisers.nothing_scalar_array_view_odd_order Function

nothing_scalar_array_view_odd_order(x, i, j)

Utility for safely viewing or indexing into possibly nothing or array values with two indices.

• If x is nothing, returns nothing.

• Otherwise, returns view(x, i, j).

Arguments

• x: Input value, which may be nothing or an array.

• i, j: Indices to view.

Returns

• The corresponding view or nothing.

Examples

julia> PortfolioOptimisers.nothing_scalar_array_view_odd_order(nothing, 1, 2)

julia> PortfolioOptimisers.nothing_scalar_array_view_odd_order([1 2; 3 4], 1, 2)
0-dimensional view(::Matrix{Int64}, 1, 2) with eltype Int64:
2

source

PortfolioOptimisers.nothing_scalar_array_getindex Function

nothing_scalar_array_getindex(x, i)
nothing_scalar_array_getindex(x, i, j)

Utility for safely indexing into possibly nothing, scalar, vector, or array values.

• x: Input value.

  • nothing: returns nothing.

  • Real: returns x.

  • AbstractVector: returns x[i].

  • AbstractMatrix: returns x[i, i] or x[i, j].

Arguments

• x: Input value, which may be nothing, a scalar, vector, or matrix.

• i, j: Indices.

Returns

• The corresponding value or nothing.

Examples

julia> PortfolioOptimisers.nothing_scalar_array_getindex(nothing, 1)

julia> PortfolioOptimisers.nothing_scalar_array_getindex(3.0, 1)
3.0

julia> PortfolioOptimisers.nothing_scalar_array_getindex([1.0, 2.0, 3.0], 2)
2.0

julia> PortfolioOptimisers.nothing_scalar_array_getindex([1 2; 3 4], 2)
4

julia> PortfolioOptimisers.nothing_scalar_array_getindex([1 2; 3 4], 1, 2)
2

source

PortfolioOptimisers.nothing_asset_sets_view Function

nothing_asset_sets_view(::Nothing, ::Any)

No-op fallback for indexing nothing asset sets.

Returns

• nothing.

source

PortfolioOptimisers.fourth_moment_index_factory Function

fourth_moment_index_factory(N::Integer, i::AbstractVector)

Constructs an index vector for extracting the fourth moment submatrix corresponding to indices i from a covariance matrix of size N × N.

Arguments

• N: Size of the full covariance matrix.

• i: Indices of the variables of interest.

Returns

• idx::Vector{Int}: Indices for extracting the fourth moment submatrix.

Examples

julia> PortfolioOptimisers.fourth_moment_index_factory(3, [1, 2])
4-element Vector{Int64}:
 1
 2
 4
 5

source