# Asset Modelling

This section considers modelling of some investment assets (e.g. Unit-Linked funds)

There are various ways to model portfolio of assets, we will look at three here:

• Nested unit models
• Individual asset functions
• Two parameter functions

For brevity, all code is not written, but they provide an outline of the approach.

## Nested Model

``````class Asset(Model):
def value(self, t):
if t == 0:
return self.init_value
else:
return self.value(t-1) * (1 + self.inv_growth)

class Portfolio(Model):
def value(self, t):
return sum(asset.value(t) for asset in self.assets)
``````

With this approach we initialise each `Asset` and pass these to `Portfolio` model. One of the benefits of this approach is that we can define different types of asset to have different functions, e.g. a `Bond` class could be defined which allows for the probability of default, as long as it implements the `value(t)` method it can be otherwise written as desired.

``````my_assets = [Asset(init_value=100, inv_growth=0.04),
Asset(init_value=200, inv_growth=0.02)]

my_portfolio = Portfolio(assets = my_assets)

print(my_portfolio.value(10))
``````

## Individual Asset Functions

This approach may work well if there are only a few asset classes, the downside is that you need to replicate all the code for each asset class, and manually add them together.

``````class Investment(Model):
def fund_value_equity(self, t):
pass # equity code here

def fund_value_bond(self, t):
pass # bond code here

def value(self, t):
return self.fund_value_bond(t) + self.fund_value_equity(t)
``````

## Two Parameter (array) Functions

This approach uses a two parameter asset_value function, the second parameter is the name of the asset. This is similar to modelling Income Protection business when recovery rates are likely to be a function of time and duration of sickness.

``````class TPF_Portfolio(Model):
def asset_value(self, t, asset_name):
if t == 0:
return self.init_asset_value[asset_name]
else:
return self.fund_value(self, t-1, asset_name) * (1 + ...)

def value(self, t):
return sum(asset_value(t, asset_name) for asset in self.asset_list)
``````

For this approach we need to specify initial values, in practice likely through an assumption file.

``````assets = ["equity", "bond", "property"]
init_values = {"equity": 1000, "bond": 500, "property": 400}

model = TPF_Portfolio(init_asset_value = init_values, asset_list=assets)
``````