[原创]基于Matlab和C++的MBS(抵押支持债券)蒙特卡罗模拟定价

是 否 +2 论坛币

k人 参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群

赵安豆老师微信：zhaoandou666

经管之家联合CDA

送您一个全额奖学金名额~ !

立即领取

感谢您参与论坛问题回答

经管之家送您两个论坛币！

+2 论坛币

按揭抵押债券(Mortgage Backed Securities，MBS)，又名抵押支持债券，是一种便于按揭债权交易的标准化债券，是最早的资产证券化商品，由美国吉利美(Ginnie Mae)于1970年首创。美国的住房专业银行及储蓄机构将贷出的住房抵押贷款中符合一定条件的贷款集中起来，形成一个抵押贷款的集合体(pool)，利用贷款集合体定期发生的本金及利息的现金流入来发行证券，并由政府机构或政府背景的金融机构对该证券进行担保，以便贷款机构能够及时套现，从30年或更长贷款期限中解脱出来。抵押集合体所产生的本金、利息以及债务风险原封不动地转移支付给MBS的投资者。因此，MBS也被称为过手证券(pass-through securities)。
美国的过手抵押证券主要有吉利美(美国政府国民抵押贷款协会)担保的过手证券、房地美(美国联邦住宅贷款抵押公司FHLMC)的参政书、房利美(美国联邦国民抵押协会FNMA)的抵押支持债券，以及民间性质的抵押过手债券等。

Matlab代码如下：

本帖隐藏的内容

1. function MBS_MC_Pricing(MC_Times)
   
2. %%  MBS_Value,MBS_VAR分别为MBS的价值和方差
   
3. %%  基于Matlab的MBS蒙特卡罗模拟定价
   
4. %%  MBS具有路径依赖性
   
5. %%  举例说明
   
6. %%  by fantuanxiaot
   
7. %%  基础参数的设定
   
8. %  基本假设：平均加权时间假设10年
   
9. WAM=10;
   
10. %  二叉树的规模
    
11. N=WAM+1;
    
12. %  蒙特卡罗模拟的次数
    
13. %  MC_Times=1000;
    
14. %  本金
    
15. Principal=1e5;
    
16. %  期权调整价差
    
17. OAS=0.02;
    
18. %  初始的一年期即期利率(Spot Rate)
    
19. %  初始的再融资利率(Refinancing Rate)
    
20. %  利息支付利率或者转付率
    
21. %  加权平均票面利率
    
22. rand('seed',100);
    
23. InitialSpotRate=0.06;
    
24. InitialRefinancingRate=0.08;
    
25. PT_Rate=0.075;
    
26. WAC_Rate=0.08;
    
27. %%  首先构建利率的二叉树
    
28. %%  liv二叉树模型基于RendleMan和Bartter模型
    
29. u=1.05;
    
30. d=1/u;
    
31. SpotRate=zeros(N);
    
32. DiscountRate=zeros(N);
    
33. for i=1:N
    
34.     for j=1:i
    
35.         SpotRate(j,i)=InitialSpotRate*u^(i-j)*d^(j-1);
    
36.         DiscountRate(j,i)=SpotRate(j,i)+OAS;
    
37.     end
    
38. end
    
39. %  参数:MBS平均价值和标准差
    
40. MBS_Vector=zeros(MC_Times,1);
    
41. MBS_Value=0;
    
42. MBS_STD=0;
    
43. %  二叉树路径起始点
    
44. BinTree_Index=1;
    
45. %  计算的贴现率
    
46. DiscountRate_Vector=[];
    
47. %%  蒙特卡罗计算MBS
    
48. for i=1:MC_Times
    
49.     %  剩余的本金
    
50.     Residual_Principal=Principal;
    
51.     %  再融资利率
    
52.     RefinancingRate=InitialRefinancingRate;
    
53.     %  计算的贴现率  
    
54.     DiscountRate_Vector=[];
    
55.     %  二叉树路径起始点
    
56.     BinTree_Index=1;
    
57.     %  计划偿还本金
    
58.     SchedualPrincipal=0;
    
59.     %  预计提前偿还本金
    
60.     ExpectedPrePrincipal=0;
    
61.     %  现金流
    
62.     CashFlow=zeros(WAM,1);
    
63.     for j=1:WAM
    
64.         Residual_Principal=Residual_Principal-(SchedualPrincipal+ExpectedPrePrincipal);
    
65.         %  利率的随机模拟路径
    
66.         if j==1
    
67.             DiscountRate_Vector=[DiscountRate_Vector DiscountRate(1,1)];
    
68.             if randn>0
    
69.                 RefinancingRate=RefinancingRate*u;
    
70.             else
    
71.                 RefinancingRate=RefinancingRate*d;
    
72.             end
    
73.         elseif j>1
    
74.             if randn>0
    
75.                 BinTree_Index=BinTree_Index-1;
    
76.                 if BinTree_Index<1
    
77.                     BinTree_Index=1;
    
78.                 end
    
79.                 RefinancingRate=RefinancingRate*u;
    
80.                 DiscountRate_Vector=[DiscountRate_Vector DiscountRate(BinTree_Index,j)];
    
81.             else
    
82.                 BinTree_Index=BinTree_Index+1;
    
83.                 if BinTree_Index>j
    
84.                     BinTree_Index=j;
    
85.                 end
    
86.                 RefinancingRate=RefinancingRate*d;
    
87.                 DiscountRate_Vector=[DiscountRate_Vector DiscountRate(BinTree_Index,j)];
    
88.             end
    
89.         end
    
90.         %  利息支付
    
91.         Interest=PT_Rate*Residual_Principal;
    
92.         %  计算月末或年末的贷款偿还余额
    
93.         Payment=CaCuPayment(Residual_Principal,WAM-j+1,WAC_Rate);
    
94.         %  计算偿还本金
    
95.         SchedualPrincipal=Payment-Residual_Principal*WAC_Rate;
    
96.         if Residual_Principal>SchedualPrincipal
    
97.             CPR_Rate=CaCuCPR(WAC_Rate,RefinancingRate);
    
98.             ExpectedPrePrincipal=CPR_Rate*(Residual_Principal-SchedualPrincipal);
    
99.             if j<=N-1
    
100.                 CashFlow(j)=Interest+SchedualPrincipal+ExpectedPrePrincipal;
     
101.             else
     
102.                 CashFlow(j)=Interest+Residual_Principal;
     
103.             end
     
104.         end
     
105.     end
     
106.     MBS_Vector(i)=CaCuMBS(CashFlow,DiscountRate_Vector);
     
107. end
     
108. MBS_Value=mean(MBS_Vector);
     
109. MBS_STD=std(MBS_Vector);
     
110. disp(['蒙特卡罗模拟次数为：',num2str(MC_Times)])
     
111. disp(['MBS的本金为：',num2str(Principal),'元'])
     
112. disp(['MBS的价值为：',num2str(MBS_Value),'元'])
     
113. disp(['基于蒙特卡罗模拟的MBS价值标准差：',num2str(MBS_STD)])
     
114. fprintf('\n')
     
115. end
     
116. %%  计算MBS价值
     
117. function result=CaCuMBS(CashFlow,DiscountRate_Vector)
     
118. result=0;
     
119. for i=1:length(CashFlow)
     
120.     result=result+CashFlow(i)/(1+DiscountRate_Vector(i))^i;
     
121. end
     
122. end
     
123. %%  计算月末或者年末抵押偿还的金额
     
124. function result=CaCuPayment(Payment,Time,WAC_Rate)
     
125. %  Time是剩余的月份
     
126. %  Payment是剩余的抵押贷款偿还的金额
     
127. result=WAC_Rate*Payment/(1-1/(1+WAC_Rate)^Time);
     
128. end
     
129. 
     
130. %%  CPR条件提前偿还率的计算
     
131. %%  建立提前还款模型
     
132. function CPRresult=CaCuCPR(WAC_Rate,RefinancingRate)
     
133. %  CPR由差价来决定
     
134. CPR_Minus=WAC_Rate-RefinancingRate;
     
135. %  判断条件
     
136. if CPR_Minus<=0
     
137.     CPRresult=0.05;
     
138. elseif CPR_Minus>0 && CPR_Minus<=0.5/100
     
139.     CPRresult=0.1;
     
140. elseif CPR_Minus>0.5/100 && CPR_Minus<=0.01
     
141.     CPRresult=0.2;
     
142. elseif CPR_Minus>0.01 && CPR_Minus<=1.25/100
     
143.     CPRresult=0.3;
     
144. elseif CPR_Minus>1.25/100 && CPR_Minus<=2/100
     
145.     CPRresult=0.4;
     
146. elseif CPR_Minus>0.02 && CPR_Minus<=2.5/100
     
147.     CPRresult=0.5;
     
148. elseif CPR_Minus>0.025 && CPR_Minus<=0.3
     
149.     CPRresult=0.6;
     
150. else
     
151.     CPRresult=0.7;
     
152. end
     
153. end
     
154. %%  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     
155. %%  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

复制代码

蒙特卡罗模拟效果如下：

C++的代码如下：

本帖隐藏的内容

首先构建一个MBS类：
”MBS.h“

1. //  构建MBS的类
   
2. //  by fantuanxiaot
   
3. #ifndef _MBS_H_
   
4. #define _MBS_H_
   
5. //  判别Visual C++的版本
   
6. #if _MSC_VER>1000
   
7. #pragma once
   
8. #endif
   
9. #include <vector>
   
10. #include <Matrix.h>
    
11. #include <MatrixIO.h>
    
12. #include <cmath>
    
13. #include <random>
    
14. #include <iostream>
    
15. //  MBS的类
    
16. using namespace std;
    
17. using namespace Numeric_lib;
    
18. class MBS
    
19. {
    
20. private:
    
21.         //  期权调整价差
    
22.         double OAS;
    
23.         //  MBS面值
    
24.         double Principal;
    
25.         //  加权平均到期时间
    
26.         int WAM;
    
27.         //  蒙特卡罗模拟的次数
    
28.         int MC_Times;
    
29.         //  初始的一年期即期收益率
    
30.         double InitialSpotRate;
    
31.         //  初始的再融资收益率
    
32.         double InitialRefinancingRate;
    
33.         //  利息支付利率或者转付率
    
34.         double PT_Rate;
    
35.         //  加权平均票面利率
    
36.         double WAC_Rate;
    
37. public:
    
38.         ~MBS(){}
    
39.         MBS(double OAS1,double Principal1,int WAM1,int MC_Times1,double InitialSpotRate1,
    
40.                 double InitialRefinancingRate1,double PT_Rate1,double WAC_Rate1)
    
41.         {
    
42.                 OAS=OAS1;
    
43.                 Principal=Principal1;
    
44.                 WAM=WAM1;
    
45.                 MC_Times=MC_Times1;
    
46.                 InitialSpotRate=InitialSpotRate1;
    
47.                 InitialRefinancingRate=InitialRefinancingRate1;
    
48.                 PT_Rate=PT_Rate1 ;
    
49.                 WAC_Rate=WAC_Rate1;
    
50.         }
    
51.         double CaCuCPR(double WAC_Rate,double RefinancingRate);
    
52.         double CaCuPayment(double Payment,int Time,double WAC_Rate);
    
53.         double CaCuMBS(vector<double> CashFlow,vector<double> DiscountRate_Vector);
    
54.         double MEAN(vector<double>);
    
55.         double STD(vector<double>);
    
56.         void CaCuMBSPricing();
    
57. };
    
58. #endif

复制代码

随后写入函数：
"MBSModel.cpp"

1. #include "MBS.h"
   
2. //  内置函数
   
3. double MBS::CaCuCPR(double WAC_Rate,double RefinancingRate)
   
4. {
   
5.         double CPRresult;
   
6.         double CPR_Minus=WAC_Rate-RefinancingRate;
   
7.         //  判断条件
   
8.         if (CPR_Minus<=0.0)
   
9.         {CPRresult=0.05;}
   
10.         else if (CPR_Minus>0.0 && CPR_Minus<=0.5/100)
    
11.         {CPRresult=0.1;}
    
12.         else if (CPR_Minus>0.5/100 && CPR_Minus<=0.01)
    
13.         {CPRresult=0.2;}
    
14.         else if (CPR_Minus>0.01 && CPR_Minus<=1.25/100)
    
15.     {CPRresult=0.3;}
    
16.         else if (CPR_Minus>1.25/100 && CPR_Minus<=2.0/100)
    
17.     {CPRresult=0.4;}
    
18.         else if (CPR_Minus>0.02 && CPR_Minus<=2.5/100)
    
19.     {CPRresult=0.5;}
    
20.         else if (CPR_Minus>0.025 && CPR_Minus<=0.3)
    
21.     {CPRresult=0.6;}
    
22.         else
    
23.     {CPRresult=0.7;}
    
24.         return CPRresult;
    
25. }
    
26. double MBS::CaCuPayment(double Payment,int Time,double WAC_Rate)
    
27. {
    
28.         return(WAC_Rate*Payment/(1.0-1.0/pow((1+WAC_Rate),Time)));
    
29. }
    
30. double MBS::CaCuMBS(vector<double> CashFlow,vector<double> DiscountRate_Vector)
    
31. {
    
32.         double result=0;
    
33.         for(int i=0;i<=CashFlow.size()-1;i++)
    
34.         {
    
35.                 result=result+CashFlow[i]/pow(1+DiscountRate_Vector[i],i+1);
    
36.         }
    
37.         return result;
    
38. }
    
39. double MBS::MEAN(vector<double> A)
    
40. {
    
41.         double sum=0.0;
    
42.         for(int i=0;i<=A.size()-1;i++)
    
43.         {
    
44.                 sum=sum+A[i];
    
45.         }
    
46.         return(sum/A.size());
    
47. }
    
48. double MBS::STD(vector<double> A)
    
49. {
    
50.         double sum=0.0;
    
51.         for(int i=0;i<=A.size()-1;i++)
    
52.         {
    
53.                 sum=sum+pow(A[i]-MEAN(A),2);
    
54.         }
    
55.         return(sqrt(sum/A.size()));
    
56. }
    
57. void MBS::CaCuMBSPricing()
    
58. {
    
59.         double u=1.05;
    
60.         double d=1/u;
    
61.         //  利率二叉树的规模
    
62.         double N=WAM+1;
    
63.         //  首先构建利率的二叉树
    
64.         Matrix<double,2> SpotRate(N,N);
    
65.         Matrix<double,2> DiscountRate(N,N);
    
66.         for(int i=0;i<=N-1;i++)
    
67.         {
    
68.                 for(int j=0;j<=i;j++)
    
69.                 {
    
70.                         SpotRate[j][i]=InitialSpotRate*pow(u,i-j)*pow(d,j);
    
71.                         DiscountRate[j][i]=SpotRate[j][i]+OAS;
    
72.                 }
    
73.         }
    
74.         //  参数:MBS平均价值和标准差
    
75.         vector<double> MBS_Vector(MC_Times);
    
76.         double MBS_Value=0;
    
77.         double MBS_STD=0;
    
78.         //  二叉树路径起始点
    
79.         int BinTree_Index=0;
    
80.         //  计算的贴现率
    
81.         vector<double> DiscountRate_Vector(WAM);
    
82.         //  计算现金流
    
83.         vector<double> CashFlow(WAM);
    
84.         //  蒙特卡罗计算MBS
    
85.         //  剩余的本金
    
86.     double Residual_Principal=Principal;
    
87.     //  再融资利率
    
88.     double RefinancingRate=InitialRefinancingRate;
    
89.     //  计划偿还本金
    
90.     double SchedualPrincipal=0.0;
    
91.     //  预计提前偿还本金
    
92.     double ExpectedPrePrincipal=0.0;
    
93.         //  产生随机数
    
94.         default_random_engine generator;
    
95.         //  产生均匀分布的随机数
    
96.         uniform_real_distribution<double> unif_dis(0,1);
    
97.         //  利息
    
98.         double Interest=0.0;
    
99.         //  支付
    
100.         double Payment=0.0;
     
101.         //  CPR利率
     
102.         double CPR_Rate=0.0;
     
103.         for(int i=0;i<=MC_Times-1;i++)
     
104.         {
     
105.                 //  数据的重置
     
106.                 Residual_Principal=Principal;
     
107.                 SchedualPrincipal=0.0;
     
108.                 ExpectedPrePrincipal=0.0;
     
109.                 for(int m=0;m<=WAM-1;m++)
     
110.                 {
     
111.                         CashFlow[m]=0.0;
     
112.                         DiscountRate_Vector[m]=0.0;
     
113.                 }
     
114.                 RefinancingRate=InitialRefinancingRate;
     
115.                 BinTree_Index=0;
     
116.                 for(int j=0;j<=WAM-1;j++)
     
117.                 {
     
118.                         Residual_Principal=Residual_Principal-(SchedualPrincipal+ExpectedPrePrincipal);
     
119.                         //  利率的随机模拟
     
120.                         if(j==0)
     
121.                         {
     
122.                                 DiscountRate_Vector[j]=(DiscountRate[0][0]);
     
123.                                 if (unif_dis(generator)>=0.5)
     
124.                                 {
     
125.                                         RefinancingRate=RefinancingRate*u;
     
126.                                 } else
     
127.                                 {
     
128.                                         RefinancingRate=RefinancingRate*d;
     
129.                                 }
     
130.                         } else if(j>=1)
     
131.                         {
     
132.                                 if (unif_dis(generator)>=0.5)
     
133.                                 {
     
134.                                         BinTree_Index--;
     
135.                                         if(BinTree_Index<0) BinTree_Index=0;
     
136.                                         RefinancingRate=RefinancingRate*u;
     
137.                                         DiscountRate_Vector[j]=DiscountRate[BinTree_Index][j];
     
138.                                 } else
     
139.                                 {
     
140.                                         BinTree_Index++;
     
141.                                         if(BinTree_Index>j) BinTree_Index=j;
     
142.                                         RefinancingRate=RefinancingRate*d;
     
143.                                         DiscountRate_Vector[j]=DiscountRate[BinTree_Index][j];
     
144.                                 }
     
145.                         }
     
146.                         //  利息支付
     
147.            Interest=PT_Rate*Residual_Principal;
     
148.                    //  计算月末或年末的贷款偿还余额
     
149.                    Payment=CaCuPayment(Residual_Principal,WAM-j,WAC_Rate);
     
150.                    //  计算偿还本金
     
151.                    SchedualPrincipal=Payment-Residual_Principal*WAC_Rate;
     
152.                    if(Residual_Principal>SchedualPrincipal)
     
153.                    {
     
154.                            CPR_Rate=CaCuCPR(WAC_Rate,RefinancingRate);
     
155.                            ExpectedPrePrincipal=CPR_Rate*(Residual_Principal-SchedualPrincipal);
     
156.                            if (j<=WAM-2)
     
157.                            {
     
158.                                    CashFlow[j]=(Interest+SchedualPrincipal+ExpectedPrePrincipal);
     
159.                            } else
     
160.                            {
     
161.                                    CashFlow[j]=(Interest+Residual_Principal);
     
162.                            }
     
163.                    }
     
164.                 }
     
165.                 MBS_Vector[i]=CaCuMBS(CashFlow,DiscountRate_Vector);
     
166.         }
     
167.         MBS_Value=MEAN(MBS_Vector);
     
168.         MBS_STD=STD(MBS_Vector);
     
169.         cout<<"蒙特卡罗模拟的次数为"<<MC_Times<<endl;
     
170.         cout<<"MBS的本金为："<<Principal<<"元"<<endl;
     
171.         cout<<"MBS的价值为："<<MBS_Value<<"元"<<endl;
     
172.         cout<<"基于蒙特卡罗模拟的MBS价值标准差"<<MBS_STD<<endl;
     
173.         cout<<endl;
     
174. }

复制代码

最后是调试：
“Main.cpp”

1. #include "MBS.h"
   
2. int main()
   
3. {
   
4.         int WAM=10;
   
5.         //  期权调整价差
   
6.         double OAS=0.02;
   
7.         //  MBS面值
   
8.         double Principal=100000;
   
9.         //  蒙特卡罗模拟的次数
   
10.         int MC_Times1=10;
    
11.         int MC_Times2=100;
    
12.         int MC_Times3=1000;
    
13.         int MC_Times4=10000;
    
14.         //  初始的一年期即期收益率
    
15.         double InitialSpotRate=0.06;
    
16.         //  初始的再融资收益率
    
17.         double InitialRefinancingRate=0.08;
    
18.         //  利息支付利率或者转付率
    
19.         double PT_Rate=0.075;
    
20.         //  加权平均票面利率
    
21.         double WAC_Rate=0.08;
    
22.         MBS MBS1(OAS,Principal,WAM,MC_Times1,InitialSpotRate,InitialRefinancingRate,PT_Rate,WAC_Rate);
    
23.         MBS MBS2(OAS,Principal,WAM,MC_Times2,InitialSpotRate,InitialRefinancingRate,PT_Rate,WAC_Rate);
    
24.         MBS MBS3(OAS,Principal,WAM,MC_Times3,InitialSpotRate,InitialRefinancingRate,PT_Rate,WAC_Rate);
    
25.         MBS MBS4(OAS,Principal,WAM,MC_Times4,InitialSpotRate,InitialRefinancingRate,PT_Rate,WAC_Rate);
    
26.         MBS1.CaCuMBSPricing();
    
27.         MBS2.CaCuMBSPricing();
    
28.         MBS3.CaCuMBSPricing();
    
29.         MBS4.CaCuMBSPricing();
    
30.         return 0;
    
31. }

复制代码

蒙特卡罗模拟效果如下：

所有源码：

MBS_Model(抵押支持债券).zip (309.96 KB)

2015-5-4 22:28:52 上传

扫码加我 拉你入群

请注明：姓名-公司-职位

以便审核进群资格，未注明则拒绝

分享2 收藏35 回帖

关键词：MATLAB 蒙特卡罗模拟 matla atlab 蒙特卡罗 蒙特卡罗

谢谢分享~~~

支持原创，果断加精。

xddlovejiao1314 发表于 2015-5-4 22:42
支持原创，果断加精。

[lol][lol]

很久以前编过，现在全忘了。。

Crsky7 发表于 2015-5-4 22:43
很久以前编过，现在全忘了。。

可以温故而知新

fantuanxiaot 发表于 2015-5-4 22:46
可以温故而知新

看了一下，编程思路基本差不多