Example 12: Portfolio Optimization Problem

Problem Description

There are $n$ assets $S_i$ ($i=1,2,\cdots ,n$) available in the market for investment, using funds amounting to $M$ for a one-period investment. The average return rate for purchasing $S_i$ during this period is $r_i$, the risk loss rate is $q_i$. The more diversified the investment, the smaller the total risk. The overall risk can be obtained by weighting the investment amount of $S_i$ with its investment risk.

When purchasing $S_i$, a transaction fee is charged at rate $p_i$. When the purchase amount does not exceed a given value $u_i$, the transaction fee is calculated based on purchasing $u_i$. Additionally, assume the bank deposit interest rate during the same period is $r_0$, which has neither transaction fees nor risk. ($r_0=5\mathrm{\%}$)

$S_i$	$r_i$(%)	$q_i$(%)	$p_i$(%)	$u_i$(yuan)
$S_1$	$28$	$4.0$	$8$	$103$
$S_2$	$21$	$1.5$	$2$	$198$
$S_3$	$23$	$5.5$	$4.5$	$52$
$S_4$	$25$	$2.6$	$4$	$40$

Design an investment portfolio strategy with given funds of $1000000$ yuan, selectively purchasing assets or bank deposits, to maximize net return while controlling risk within $2\mathrm{\%}$.

Mathematical Model

Variables

$x_i$: Purchase funds for investment product $i$.

Intermediate Values

1. Whether Purchased

$${\text{Assignment}}_i=\text{If}(x_i>0),\mathrm{\forall }i\in S$$

2. Transaction Fee

$${\text{Premium}}_i=\text{Max}(p_i\cdot x_i,u_i\cdot {\text{Assignment}}_i),\mathrm{\forall }i\in S$$

3. Return

$$\text{Yield}=\sum _{i\in S}(r_i\cdot x_i-{\text{Premium}}_i)$$

4. Risk

$$\text{Risk}=\frac{\sum _{i\in S}{q}_i\cdot x_i}{M}$$

Objective Function

1. Maximize Return

$$max\text{Yield}$$

Constraints

1. Sum of Funds Equals $M$

$$\text{s.t.}\sum _{i\in S}(1+p_i)\cdot x_i=M$$

2. Risk Limit

$$\text{s.t.}\sum _{i\in S}{\text{Risk}}_i\le {\text{Risk}}^{\text{Max}}$$

Expected Results

Invest $494505$ yuan in $S_4$ and $476191$ yuan in $S_2$.

Code Implementation

kotlin

import fuookami.ospf.kotlin.utils.math.*
import fuookami.ospf.kotlin.utils.concept.*
import fuookami.ospf.kotlin.utils.functional.*
import fuookami.ospf.kotlin.utils.multi_array.*
import fuookami.ospf.kotlin.core.frontend.variable.*
import fuookami.ospf.kotlin.core.frontend.expression.polynomial.*
import fuookami.ospf.kotlin.core.frontend.expression.symbol.*
import fuookami.ospf.kotlin.core.frontend.inequality.*
import fuookami.ospf.kotlin.core.frontend.model.mechanism.*
import fuookami.ospf.kotlin.core.backend.plugins.scip.*

data class Product(
    val yield: Flt64,
    val risk: Flt64,
    val premium: Flt64,
    val minPremium: Flt64
) : AutoIndexed(Product::class)

val products: List<Product> = ... // Product list
val funds = Flt64(1000000.0)
val maxRisk = Flt64(0.02)

// Create model instance
val metaModel = LinearMetaModel("demo12")

// Define variables
val x = UIntVariable1("x", Shape1(products.size))
metaModel.add(x)

// Define intermediate values
val assignment = LinearIntermediateSymbols1(
    "assignment",
    Shape1(products.size)
) { i, _ ->
    BinaryzationFunction(
        x = LinearPolynomial(x[i]),
        name = "assignment_$i"
    )
}
metaModel.add(assignment)

val premium = LinearIntermediateSymbols1(
    "premium",
    Shape1(products.size)
) { i, _ ->
    val product = products[i]
    MaxFunction(
        listOf(
            LinearPolynomial(product.premium * x[i]),
            LinearPolynomial(product.minPremium * assignment[i])
        ),
        "premium_$i"
    )
}
metaModel.add(premium)

val risk = LinearExpressionSymbol(
    sum(products.map { p -> p.risk * x[p] / funds }),
    "risk"
)
metaModel.add(risk)

val yield = LinearExpressionSymbol(
    sum(products.map { p -> p.yield * x[p] - premium[p] }),
    "yield"
)
metaModel.add(yield)

// Define objective function
metaModel.maximize(yield, "yield")

// Define constraints
metaModel.addConstraint(
    sum(products.map { p -> x[p] + premium[p] }) eq funds,
    "funs"
)

metaModel.addConstraint(
    risk leq maxRisk,
    "risk"
)

// Call solver to solve
val solver = ScipLinearSolver()
when (val ret = solver(metaModel)) {
    is Ok -> {
        metaModel.tokens.setSolution(ret.value.solution)
    }

    is Failed -> {}
}

// Parse results
val solution = HashMap<Product, UInt64>()
for (token in metaModel.tokens.tokens) {
    if (token.result!! geq Flt64.one && token.variable.belongsTo(x)) {
        val vector = token.variable.vectorView
        val product = products[vector[0]]
        solution[product] = token.result!!.round().toUInt64()
    }
}

Complete Implementation Reference:

• Kotlin