Welcome to THETAWIKI. If you like to create or edit a page please make sure to login or register an account. All registered users please make sure to provide a valid email address.

ALM of a non-life insurance company

From ThetaWiki
Jump to: navigation, search

An ALM Model Implemented in ThetaML

The following is a ThetaML model for ALM. As an extended payoff description language, ThetaML describes the complete structure of financial products independently from the underlying stochastic processes that are applied to them. In this case, the economic state variables EUR and S are stochastic processes simulated externally and subsequently imported into the structural model ALM.

The structural model ALM is defined by the model body in the following ThetaML Script. It lives on a model time axis. The model time axis is a time grid that collects all the model time points in the state variables (EUR, S and Asset). Time passing along the model time axis is enabled by the ThetaML operator Theta that describes time-determined behavior of the ALM Asset and Liabilities.

model ALM
%This model imports the stochastic processes 'EUR' and 'S' simulated externally.
%The asset value 'A', the claims 'C' and the premium 'Prem' are constants
%initial parameter inputs.
	import EUR          "Numeraire"
	import S            "Stock-price index"
	import A            "Asset value"
	import C            "Claims"
	import Prem         "Premium"
 
	export Asset        "Asset value"
	export W            "Portfolio weights"
	export B            "10y Bond"
	export S_return     "Stock return"
	export B_1_return   "1y Bond return"
	export B_10_return  "10y Bond return"
 
	type W float[2]     %declare an array for portfolio weights
	type P float[2]     %declare a portfolio array to hold the stock and the bond
 
	Asset = A
        %call the submodel bond_value to compute the current value of a 10 year maturity bond 
	call bond_value
		export 10 to T
		export EUR to CUR
		import B_10 from P
 
	B = B_10
        %loop 10 times
	loop 10
 
		S_0 = S/EUR         %current stock price
		B_1_0 = 1/EUR       %current 1 year bond value
		B_10_0 = B_10/EUR   %current 10 year bond value
 
		W = -Beta(P!, Asset_pre!)  %current portfolio weights computed using ThetaML Beta function
 
		Theta 1             %the ThetaML command Theta advances time by 1 year
                %call the submodel bond_value to compute the value of a 10 year maturity bond
		call bond_value
			export 10 to T
			export EUR to CUR
			import B_10 from P
 
		S_return = (S/EUR) / S_0          %compute stock return
		B_1_return = (1/EUR) / B_1_0      %compute 1 year bond return
		B_10_return =(B_10/EUR) / B_10_0  %compute 10 year bond return
 
		P[1] = S            %store stock prices at this time
		P[2] = B_10         %store 10 year bond price at this time
 
		Asset_pre = Asset + Prem/EUR - C/EUR   
		Asset = (W[1] * S / EUR  + W[2]*B_10/EUR) + (Asset_pre - (W[1] * S_0 + W[2]*B_10_0))*B_1_return
 
		B = B_10
	end
end
 
model bond_value
	import T "Maturity time"
	import CUR "Numeraire"
	export P
 
	fork
		P = E(Bond!)/CUR
		Theta T
		Bond = 1*CUR
	end
end

Stochastic model

function state = Theta(dt, state)
 
if nargin == 0
 
	% return comments and dimensions for Theta variables
	state.S.comment = 'Stock price index';
	state.EUR.comment = 'Numeraire';
	state.sigma.comment = 'Volatility';
 
	state.r.comment = 'Risk-free rate';
	state.r_vola.comment = 'Volatility of interest-rate';
	state.r_alpha.comment = 'Mean-reversion speed of interest-rate';
	state.r_beta.comment = 'Mean-reversion level of interest-rate';
 
	state.C.coment = 'Claims';
	state.Prem.comment = 'Premium';
 
else
 
	index = round(state.time+1);
 
	% interest-rate model
	vola= state.r_vola(1);
	alpha= state.r_alpha(1);
	beta = state.r_beta(1);
 
	state.r= state.r  + vola*sqrt(dt).*randn(size(state.r));
	state.r= beta .* alpha*dt + (1-alpha*dt).*state.r;
	state.EUR = exp(-dt .* state.r) .* state.EUR ;
 
	% stock-price index model
	mu = 0.05;
	sigma = state.sigma(1);
	ret_s = exp( (mu-0.5*sigma^2)*dt + sqrt(dt)*sigma*randn(size(state.S)));
	state.S = state.S .* ret_s;
 
	% liability model
	state.C      = max(10+(0.8*randn(size(state.C))).^3,0);
	state.C      = state.C - 0.1 * 10 * (ret_s-1);
	state.Prem   = 11 - 0.3 * randn(size(state.C)).^2;
end