implement portfolio optimization

Author: jbytecode

CHANGELOG.md

@@ -3,6 +3,7 @@
 - Update docs example in travelingsalesman.
 - Update the documentation so that the examples are runnable by copy-pasting.
 - Add example in the docs of game solver.
+- Add Porfolio Optimization
 
 ### 0.2.9 
 

Project.toml

@@ -1,13 +1,19 @@
 name = "OperationsResearchModels"
 uuid = "8042aa49-e599-49ec-a8f7-b5b80cc82a88"
-authors = ["Mehmet Hakan Satman <mhsatman@gmail.com>"]
 version = "0.2.9"
+authors = ["Mehmet Hakan Satman <mhsatman@gmail.com>"]
 
 [deps]
 HiGHS = "87dc4568-4c63-4d18-b0c0-bb2238e4078b"
+Ipopt = "b6b21f68-93f8-5de0-b562-5493be1d77c9"
 JuMP = "4076af6c-e467-56ae-b986-b466b2749572"
+LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
+Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
 
 [compat]
 HiGHS = "1"
+Ipopt = "1.13.0"
 JuMP = "1"
+LinearAlgebra = "1.12.0"
+Statistics = "1.11.1"
 julia = "1.6"

docs/make.jl

@@ -19,6 +19,7 @@ makedocs(
         "Scheduling" => "scheduling.md",
         "The Simplex Method" => "simplex.md",
         "Zero-sum Games" => "game.md",
+        "Portfolio Optimization" => "portfolio.md",
         ],
 )
 

docs/src/portfolio.md

@@ -0,0 +1,19 @@
+# Portfolio Optimization 
+
+## PortfolioProblem
+
+```@docs
+OperationsResearchModels.PortfolioProblem
+```
+
+## PortfolioResult 
+
+```@docs
+OperationsResearchModels.PortfolioResult
+```
+
+## solve 
+
+```@docs
+OperationsResearchModels.solve(t::PortfolioProblem)
+```

src/OperationsResearchModels.jl

@@ -14,6 +14,7 @@ using JuMP, HiGHS
 # solve(m::MstProblem)::MstResult
 # solve(t::TravelingSalesmanProblem)::TravelingSalesmanResult
 # solve(p::JohnsonProblem)::JohnsonResult
+# solve(p::PortfolioProblem)::PortfolioResult
 solve() = nothing
 
 # solve!(s::SimplexProblem)::SimplexProblem
@@ -51,6 +52,7 @@ include("latex.jl")
 include("randomkeyga.jl")
 include("johnsons.jl")
 include("travelingsalesman.jl")
+include("portfolio.jl")
 
 import .Network
 import .Transportation
@@ -69,6 +71,7 @@ import .Utility
 import .RandomKeyGA
 import .Johnsons
 import .TravelingSalesman
+import .Portfolio
 
 
 import .Transportation:
@@ -97,6 +100,8 @@ import .RandomKeyGA: Chromosome, run_ga
 import .TravelingSalesman: TravelingSalesmanResult, TravelingSalesmanProblem
 import .Simplex:
     SimplexProblem, simplexiterations, createsimplexproblem, gaussjordan, OptimizationType
+import .Portfolio: PortfolioProblem, PortfolioResult
+
 
 export TransportationProblem,
     TransportationResult, balance, isbalanced, northwestcorner, leastcost
@@ -115,6 +120,7 @@ export latex
 export Chromosome, run_ga
 export JohnsonProblem, JohnsonResult, JohnsonException, makespan, johnsons_ga
 export TravelingSalesmanResult, TravelingSalesmanProblem
+export PortfolioProblem, PortfolioResult
 export simplexiterations,
     SimplexProblem, createsimplexproblem, gaussjordan, OptimizationType
 

src/portfolio.jl

@@ -0,0 +1,118 @@
+module Portfolio
+
+using JuMP, Ipopt, Statistics, LinearAlgebra
+
+import ..OperationsResearchModels: solve
+
+export PortfolioProblem, PortfolioResult
+
+
+
+
+"""
+    PortfolioProblem
+
+# Description
+
+Defines the portfolio optimization problem.
+
+# Fields
+
+- `returns::Matrix{<:Real}`: A matrix of historical returns for the assets.
+- `thresholdreturn::Real`: The minimum expected return required for the portfolio.
+
+"""
+struct PortfolioProblem
+    returns::Matrix{<:Real}
+    thresholdreturn::Real 
+end 
+
+
+
+"""
+    PortfolioResult
+
+# Description
+
+A structure to hold the result of the portfolio optimization problem.
+
+# Fields
+
+- `weights::Vector{Float64}`: The optimal weights for the assets in the portfolio.
+- `expectedreturn::Float64`: The expected return of the optimal portfolio.
+- `model::JuMP.Model`: The JuMP model used to solve the problem.
+"""
+struct PortfolioResult
+    weights::Vector{Float64}
+    expectedreturn::Float64
+    model::JuMP.Model
+end
+
+
+
+"""
+    solve(problem)
+
+# Description
+
+Solves a portfolio optimization problem given by an object of in type `PortfolioProblem`.
+The optimization problem is formulated as a quadratic programming problem where the objective 
+is to minimize the portfolio variance (risk) subject to constraints on the expected return and the weights.
+
+Mathematically, the problem can be stated as:
+
+Minimize: w' * Σ * w
+Subject to:
+- sum(w) == 1 (the weights must sum to 1)
+- sum(w[i] * μ[i] for i in 1:m) >= thresholdreturn
+- 0 <= w[i] <= 1 for all i (weights must be between 0 and 1)
+
+Where:
+- w is the vector of asset weights
+- Σ is the covariance matrix of asset returns
+- μ is the vector of expected returns for each asset
+- thresholdreturn is the minimum expected return required for the portfolio
+
+# Arguments
+
+- `problem::PortfolioProblem`: The problem in type of PortfolioProblem
+
+# Returns
+
+- `PortfolioResult`: The result of the portfolio optimization problem, containing the optimal weights, expected return, and the JuMP model used to solve the problem.
+
+"""
+function solve(p::PortfolioProblem)::PortfolioResult
+    
+    model = Model(Ipopt.Optimizer)
+
+    MOI.set(model, MOI.Silent(), true)
+
+    means = mean(p.returns, dims = 1)
+
+    covmat = cov(p.returns)
+
+    _, m = size(p.returns)
+
+    @variable(model, 0 <= w[1:m] <= 1)
+    
+    @constraint(model, sum(w) == 1)
+
+    @constraint(model, sum(w[i] * means[i] for i in 1:m) >= p.thresholdreturn)
+
+    @objective(model, Min, w' * covmat * w)
+
+    optimize!(model)
+
+    weights = value.(w)
+
+    expectedreturn = sum(weights[i] * means[i] for i in 1:m)
+
+    return PortfolioResult(weights, expectedreturn, model)
+
+end 
+
+
+
+
+end # end of module

test/runtests.jl

@@ -21,3 +21,4 @@ include("testpert.jl")
 include("testlatex.jl")
 include("testknapsack.jl")
 include("testsimplex.jl")
+include("testportfolio.jl")

test/testportfolio.jl

@@ -0,0 +1,21 @@
+@testset "Portfolio Optimization" begin
+    @testset "Markowitz Portfolio Optimization - Example 1" begin
+        eps = 1e-5
+        mydata = rand(100, 3)
+        mydata[:, 3] = mydata[:, 1] * 0.6 + mydata[:, 2] * 0.3 + randn(100) * 0.1 
+        thresholdreturn = 0.1
+
+        problem = PortfolioProblem(mydata, thresholdreturn)
+        
+        result = solve(problem)
+
+        @test result.expectedreturn >= thresholdreturn
+        @test isapprox(sum(result.weights), 1.0; atol=eps)
+        @test all(result.weights .>= 0.0)
+        @test all(result.weights .<= 1.0)
+        # @info "Optimal weights: $(result.weights)"
+        # @info "Expected return: $(result.expectedreturn)"
+        # println(result.model)
+
+    end
+end