Kelompok 2

Berikut Link tugas bahasa pemrogaman tgl 19 Mei 2013
Kelompok 2
.
http://www.mediafire.com/?9rpwk8f52p236cs

berikut data ms .word
http://www.mediafire.com/view/?x7xqqo1yojiuvq4

berikut data ms.power pointnya
http://www.mediafire.com/view/?tf4az118ryv5vpo

User Defined Function

Cara Membuat User Defined Function di Excel menggunakan C# dan Visual Studio 2008 :

Langkah 1

Pertama, jalankan Visual Studio 2008 dan membuat C # proyek Class Library baru yang disebut BlackScholesAddin untuk contoh ini.

Langkah 2

Dalam file Class1.cs Anda, menghapus semua kode yang ada dan menggantinya dengan kode berikut

1. using System;
2. using System.Runtime.InteropServices;
3. using Microsoft.Win32;
5. namespace BlackScholesAddin
6. {
7.     [ClassInterface(ClassInterfaceType.AutoDual)]
8.     [ComVisible(true)]
9.     public class Functions
10.     {
11.         public Functions()
12.         {
13.         }
15.         //cumulative normal distribution function
16.         private double CND(double X)
17.         {
18.             double L = 0.0;
19.             double K = 0.0;
20.             double dCND = 0.0;
21.             const double a1 = 0.31938153;
22.             const double a2 = -0.356563782;
23.             const double a3 = 1.781477937;
24.             const double a4 = -1.821255978;
25.             const double a5 = 1.330274429;
26.             L = Math.Abs(X);
27.             K = 1.0 / (1.0 + 0.2316419 * L);
28.             dCND = 1.0 - 1.0 / Math.Sqrt(2 * Convert.ToDouble(Math.PI.ToString())) *
29.                 Math.Exp(-L * L / 2.0) * (a1 * K + a2 * K * K + a3 * Math.Pow(K, 3.0) +
30.                 a4 * Math.Pow(K, 4.0) + a5 * Math.Pow(K, 5.0));
32.             if (X < 0)
33.             {
34.                 return 1.0 - dCND;
35.             }
36.             else
37.             {
38.                 return dCND;
39.             }
40.         }
42.         //function phi
43.         private double phi(double x)
44.         {
45.             double phi = 0.0;
47.             phi = Math.Exp(-x * x / 2) / Math.Sqrt(2 * Math.PI);
48.             return phi;
49.         }
51.         //implied volatility using Newton-Raphson method
52.         public double blsimpvCall(double Price, double Strike, double Rate, double Time, double Value, double Yield)
53.         {
54.             const double ACCURACY = 1.0e-6;
56.             double ComputedVolatility = Math.Pow(Math.Abs(Math.Log(Price / Strike) + Rate * Time) * 2 / Time, 0.5); // initial value of volatility
57.             double ComputedValue = blsCall(Price, Strike, Rate, Time, ComputedVolatility, Yield);
58.             double Vega = blsvega(Price, Strike, Rate, Time, ComputedVolatility, Yield);
60.             while (Math.Abs(Value - ComputedValue) > ACCURACY)
61.             {
62.                 ComputedVolatility = ComputedVolatility - ((ComputedValue - Value) / Vega);
63.                 ComputedValue = blsCall(Price, Strike, Rate, Time, ComputedVolatility, Yield);
64.                 Vega = blsvega(Price, Strike, Rate, Time, ComputedVolatility, Yield);
65.             }
67.             return ComputedVolatility;
68.         }
69.         public double blsimpvPut(double Price, double Strike, double Rate, double Time, double Value, double Yield)
70.         {
71.             const double ACCURACY = 1.0e-6;
73.             double ComputedVolatility = Math.Pow(Math.Abs(Math.Log(Price / Strike) + Rate * Time) * 2 / Time, 0.5); // initial value of volatility
74.             double ComputedValue = blsPut(Price, Strike, Rate, Time, ComputedVolatility, Yield);
75.             double Vega = blsvega(Price, Strike, Rate, Time, ComputedVolatility, Yield);
77.             while (Math.Abs(Value - ComputedValue) > ACCURACY)
78.             {
79.                 ComputedVolatility = ComputedVolatility - ((ComputedValue - Value) / Vega);
80.                 ComputedValue = blsPut(Price, Strike, Rate, Time, ComputedVolatility, Yield);
81.                 Vega = blsvega(Price, Strike, Rate, Time, ComputedVolatility, Yield);
82.             }
84.             return ComputedVolatility;
85.         }
86.         //Call pricer
87.         public double blsCall(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
88.         {
89.             double d1 = 0.0;
90.             double d2 = 0.0;
91.             double Call = 0.0;
93.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
94.             d2 = d1 - Volatility * Math.Sqrt(Time);
96.             Call = Price * Math.Exp(-Yield * Time) * CND(d1) - Strike * Math.Exp(-Rate * Time) * CND(d2);
97.             return Call;
98.         }
100.         //Put pricer
101.         public double blsPut(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
102.         {
103.             double d1 = 0.0;
104.             double d2 = 0.0;
105.             double Put = 0.0;
107.      
108.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
109.             d2 = d1 - Volatility * Math.Sqrt(Time);
111.             Put = Strike * Math.Exp(-Rate * Time) * CND(-d2) - Price * Math.Exp(-Yield * Time) * CND(-d1);
112.             return Put;
113.         }
115.         //delta for Call
116.         public double blsdeltaCall(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
117.         {
118.             double d1 = 0.0;
120.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
122.             return Math.Exp(-Yield * Time) * CND(d1);
123.         }
125.         //delta for Put
126.         public double blsdeltaPut(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
127.         {
128.             double d1 = 0.0;
130.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
132.             return Math.Exp(-Yield * Time) * CND(d1) - 1;
133.         }
135.         //gamma is the same for Put and Call
136.         public double blsgamma(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
137.         {
138.             double d1 = 0.0;
140.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
142.             return Math.Exp(-Yield * Time) * phi(d1) / (Price * Volatility * Math.Sqrt(Time));
143.         }
145.         //vega is the same for Put and Call
146.         public double blsvega(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
147.         {
148.             double d1 = 0.0;
150.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
151.             return Price * Math.Exp(-Yield * Time) * phi(d1) * Math.Sqrt(Time);
152.         }
154.         //theta for Call
155.         public double blsthetaCall(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
156.         {
157.             double d1 = 0.0;
158.             double d2 = 0.0;
160.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
161.             d2 = d1 - Volatility * Math.Sqrt(Time);
162.             return -Math.Exp(-Yield * Time) * Price * phi(d1) * Volatility / (2 * Math.Sqrt(Time)) - Rate * Strike * Math.Exp(-Rate * Time) * CND(d2) + Yield * Price * Math.Exp(-Yield * Time) * CND(d1);
163.         }
165.         //theta for Put
166.         public double blsthetaPut(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
167.         {
168.             double d1 = 0.0;
169.             double d2 = 0.0;
171.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
172.             d2 = d1 - Volatility * Math.Sqrt(Time);
173.             return -Math.Exp(-Yield * Time) * Price * phi(d1) * Volatility / (2 * Math.Sqrt(Time)) + Rate * Strike * Math.Exp(-Rate * Time) * CND(-d2) - Yield * Price * Math.Exp(-Yield * Time) * CND(-d1);
174.         }
176.         //rho for Call
177.         public double blsrhoCall(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
178.         {
179.             double d1 = 0.0;
180.             double d2 = 0.0;
182.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
183.             d2 = d1 - Volatility * Math.Sqrt(Time);
184.             return Strike * Time * Math.Exp(-Rate * Time) * CND(d2);
185.         }
187.         //rho for Put
188.         public double blsrhoPut(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
189.         {
190.             double d1 = 0.0;
191.             double d2 = 0.0;
193.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
194.             d2 = d1 - Volatility * Math.Sqrt(Time);
195.             return -Strike * Time * Math.Exp(-Rate * Time) * CND(-d2);
196.         }
198.         //volga is the same for Call and Put
199.         public double blsvolga(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
200.         {
201.             double d1 = 0.0;
202.             double d2 = 0.0;
204.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
205.             d2 = d1 - Volatility * Math.Sqrt(Time);
206.             return Price * Math.Exp(-Yield * Time) * phi(d1) * Math.Sqrt(Time) * d1 * d2 / Volatility;
208.         }
210.         //vanna is the same for Call and Put
211.         public double blsvanna(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
212.         {
213.             double d1 = 0.0;
214.             double d2 = 0.0;
215.             double vanna = 0.0;
217.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
218.             d2 = d1 - Volatility * Math.Sqrt(Time);
220.             vanna = -Math.Exp(-Yield * Time) * phi(d1) * d2 / Volatility;
222.             return vanna;
223.         }
225.         //charm for Call
226.         public double blscharmCall(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
227.         {
228.             double d1 = 0.0;
229.             double d2 = 0.0;
230.             double charmC = 0.0;
232.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
233.             d2 = d1 - Volatility * Math.Sqrt(Time);
235.             charmC = -Yield * Math.Exp(-Yield * Time) * CND(d1) + Math.Exp(-Yield * Time) * phi(d1) * (2 * (Rate - Yield) * Time - d2 * Volatility * Math.Sqrt(Time)) / (2 * Time * Volatility * Math.Sqrt(Time));
236.             return charmC;
237.         }
239.         //charm for Put
240.         public double blscharmPut(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
241.         {
242.             double d1 = 0.0;
243.             double d2 = 0.0;
244.             double charmP = 0.0;
246.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
247.             d2 = d1 - Volatility * Math.Sqrt(Time);
249.             charmP = Yield * Math.Exp(-Yield * Time) * CND(-d1) - Math.Exp(-Yield * Time) * phi(d1) * (2 * (Rate - Yield) * Time - d2 * Volatility * Math.Sqrt(Time)) / (2 * Time * Volatility * Math.Sqrt(Time));
250.             return charmP;
251.         }
253.         //color is the same for Call and Put
254.         public double blscolor(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
255.         {
256.             double d1 = 0.0;
257.             double d2 = 0.0;
258.             double color = 0.0;
260.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
261.             d2 = d1 - Volatility * Math.Sqrt(Time);
263.             color = -Math.Exp(-Yield * Time) * (phi(d1) / (2 * Price * Time * Volatility * Math.Sqrt(Time))) * (2 * Yield * Time + 1 + (2 * (Rate - Yield) * Time - d2 * Volatility * Math.Sqrt(Time)) * d1 / (2 * Time * Volatility * Math.Sqrt(Time)));
264.             return color;
265.         }
267.         //dual delta for Call
268.         public double blsdualdeltaCall(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
269.         {
270.             double d1 = 0.0;
271.             double d2 = 0.0;
272.             double ddelta = 0.0;
274.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
275.             d2 = d1 - Volatility * Math.Sqrt(Time);
276.             ddelta = -Math.Exp(-Rate * Time) * CND(d2);
277.             return ddelta;
278.         }
280.         //dual delta for Put
281.         public double blsdualdeltaPut(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
282.         {
283.             double d1 = 0.0;
284.             double d2 = 0.0;
285.             double ddelta = 0.0;
287.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
288.             d2 = d1 - Volatility * Math.Sqrt(Time);
289.             ddelta = Math.Exp(-Rate * Time) * CND(-d2);
290.             return ddelta;
291.         }
293.         //dual gamma is the same for Call and Put
294.         public double blsdualgamma(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
295.         {
296.             double d1 = 0.0;
297.             double d2 = 0.0;
298.             double dgamma = 0.0;
300.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
301.             d2 = d1 - Volatility * Math.Sqrt(Time);
303.             dgamma = Math.Exp(-Rate * Time) * phi(d2) / (Strike * Volatility * Math.Sqrt(Time));
304.             return dgamma;
305.         }
307.         [ComRegisterFunctionAttribute]
308.         public static void RegisterFunction(Type type)
309.         {
311.             Registry.ClassesRoot.CreateSubKey(
313.               GetSubKeyName(type, "Programmable"));
315.             RegistryKey key = Registry.ClassesRoot.OpenSubKey(
317.               GetSubKeyName(type, "InprocServer32"), true);
319.             key.SetValue("",
321.               System.Environment.SystemDirectory + @"\mscoree.dll",
323.               RegistryValueKind.String);
324.         }
326.         [ComUnregisterFunctionAttribute]
327.         public static void UnregisterFunction(Type type)
328.         {
330.             Registry.ClassesRoot.DeleteSubKey(
332.               GetSubKeyName(type, "Programmable"), false);
333.         }
335.         private static string GetSubKeyName(Type type,
337.           string subKeyName)
338.         {
340.             System.Text.StringBuilder s =
342.               new System.Text.StringBuilder();
344.             s.Append(@"CLSID\{");
346.             s.Append(type.GUID.ToString().ToUpper());
348.             s.Append(@"}\");
350.            s.Append(subKeyName);
352.            return s.ToString();
354.        }
356.    }
357. }