BlackScholes.cs Класс расчета премии и волатильности по опционам Call и Put

using System; using System.Collections.Generic; using System.Text; using System.Data; using System.Data.Sql; using System.Data.Common; using System.Data.SqlClient; using StatisticMath; using Microsoft.SqlServer.Server; /// <summary> /// Модель Блэка - Шоулза /// Класс расчета премии и волатильности по опционам Call и Put /// Расчет основных греков /// Автор Есаков Денис denis[:собачко:]yesakov.com /// http://www.yesakov.com/BlackScholes/ /// </summary> public class BlackScholes { /* * Write * BS_CALL Calculates the theoretical price of a call option * BS_CDELTA Calculates the delta (hedge ratio) of call option * BS_CTHETA Calculates the theta of a call * BS_CGAMMA Calculates the gamma of a call * BS_CVEGA Calculates the vega of a call * BS_PUT Calculates the theoretical price of a put option * BS_PDELTA Calculates the delta (hedge ratio) of a put * BS_PTHETA Calculates the theta of a put * BS_PGAMMA Calculates the gamma of a put * BS_PVEGA Calculates the vega of a put * IV Calculates the Implied Volatility of a Call and Put Options * NEED * BS_CRHO Calculates the rho of a call * BS_PRHO Calculates the rho of a put * BS_CSTD Calculates the implied standard deviation of a call * BS_PSTD Calculates the implied standard deviation of a put * FRIDAY3 Calculates the serial date for the 3rd Friday of the month */ private readonly static double dayInYear = 365; //Количество дней в году (расчет временного распада) private readonly static double timeDif = 1.0 / dayInYear; //Коэффициент дней в году private readonly static double vegaDif = 0.01; //Коэффициент веги private readonly static double gammaDif = 0.1; //Коэффициент Гаммы public enum OptionType { Call = 1, Put }; //Перечислимый тип опционов #region d1 /// <summary> /// Расчет величины d1 из формулы Блэка Шолза /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <param name="dividend">Размер дивиденда по акциям</param> /// <returns>значение величины d1</returns> private static double d1(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend) { return (Math.Log(baseActive / strike) + (riskFree - dividend + deviation * deviation / (2.0)) * timeToExp) / (deviation * Math.Sqrt(timeToExp)); } /// <summary> /// Расчет величины d1 из формулы Блэка Шолза /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <param name="dividend">Размер дивиденда по акциям</param> /// <returns>значение величины d1</returns> private static double d1(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend) { double timeToExp = dayToExp / dayInYear; return (Math.Log(baseActive / strike) + (riskFree - dividend + deviation * deviation / (2.0)) * timeToExp) / (deviation * Math.Sqrt(timeToExp)); } /// <summary> /// Расчет величины d1 из формулы Блэка Шолза /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <returns>значение величины d1</returns> private static double d1(double baseActive, double strike, double timeToExp, double riskFree, double deviation) { double dividend = 0; return (Math.Log(baseActive / strike) + (riskFree - dividend + deviation * deviation / (2.0)) * timeToExp) / (deviation * Math.Sqrt(timeToExp)); } /// <summary> /// Расчет величины d1 из формулы Блэка Шолза /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <returns>значение величины d1</returns> private static double d1(double baseActive, double strike, int dayToExp, double riskFree, double deviation) { double timeToExp = dayToExp / dayInYear; double dividend = 0; return (Math.Log(baseActive / strike) + (riskFree - dividend + deviation * deviation / (2.0)) * timeToExp) / (deviation * Math.Sqrt(timeToExp)); } #endregion #region d2 /// <summary> /// Расчет величины d2 из формулы Блэка Шолза /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <param name="dividend">Размер дивиденда по акциям</param> /// <returns>значение величины d2</returns> private static double d2(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend) { return d1(baseActive, strike, timeToExp, riskFree, deviation, dividend) - (deviation) * Math.Sqrt(timeToExp); } /// <summary> /// Расчет величины d2 из формулы Блэка Шолза /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <param name="dividend">Размер дивиденда по акциям</param> /// <returns>значение величины d2</returns> private static double d2(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend) { double timeToExp = dayToExp / dayInYear; return d1(baseActive, strike, timeToExp, riskFree, deviation, dividend) - (deviation) * Math.Sqrt(timeToExp); } /// <summary> /// Расчет величины d2 из формулы Блэка Шолза /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <returns>значение величины d2</returns> private static double d2(double baseActive, double strike, double timeToExp, double riskFree, double deviation) { double dividend = 0; return d1(baseActive, strike, timeToExp, riskFree, deviation, dividend) - (deviation) * Math.Sqrt(timeToExp); } /// <summary> /// Расчет величины d2 из формулы Блэка Шолза /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <returns>значение величины d2</returns> private static double d2(double baseActive, double strike, int dayToExp, double riskFree, double deviation) { double dividend = 0; double timeToExp = dayToExp / dayInYear; return d1(baseActive, strike, timeToExp, riskFree, deviation, dividend) - (deviation) * Math.Sqrt(timeToExp); } #endregion #region BS_CALL /*[SqlFunction()] public static System.Data.SqlTypes.SqlDouble test() { return (float)0.1; }*/ /// <summary> /// Расчет премии по опциону Call /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <param name="dividend">Размер дивиденда по акциям</param> /// <returns>Премию опциона Call</returns> public static double BS_CALL(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend) { double expRate = Math.Exp(-riskFree * timeToExp); double expDiv = Math.Exp(-dividend * timeToExp); return baseActive * expDiv * Statistic.N(d1(baseActive, strike, timeToExp, riskFree, deviation, dividend)) - strike * expRate * Statistic.N(d2(baseActive, strike, timeToExp, riskFree, deviation, dividend)); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_CALL01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend) { return (float)BS_CALL(baseActive, strike, timeToExp, riskFree, deviation, dividend); } [Microsoft.SqlServer.Server.SqlProcedure(Name = "BS_CALL01")] public static void BS_CALL01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend) { double result = BS_CALL(baseActive, strike, timeToExp, riskFree, deviation, dividend); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } /// <summary> /// Расчет премии по опциону Call /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <param name="dividend">Размер дивиденда по акциям</param> /// <returns>Премию опциона Call</returns> public static double BS_CALL(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend) { double timeToExp = dayToExp / dayInYear; double expRate = Math.Exp(-riskFree * timeToExp); double expDiv = Math.Exp(-dividend * timeToExp); return baseActive * expDiv * Statistic.N(d1(baseActive, strike, timeToExp, riskFree, deviation, dividend)) - strike * expRate * Statistic.N(d2(baseActive, strike, timeToExp, riskFree, deviation, dividend)); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_CALL02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend) { return (float)BS_CALL(baseActive, strike, dayToExp, riskFree, deviation, dividend); } [Microsoft.SqlServer.Server.SqlProcedure(Name = "BS_CALL02")] public static void BS_CALL02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend) { double result = BS_CALL(baseActive, strike, dayToExp, riskFree, deviation, dividend); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } /// <summary> /// Расчет премии по опциону Call /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <returns>Премию опциона Call</returns> public static double BS_CALL(double baseActive, double strike, double timeToExp, double riskFree, double deviation) { double dividend = 0; double expRate = Math.Exp(-riskFree * timeToExp); double expDiv = Math.Exp(-dividend * timeToExp); return baseActive * expDiv * Statistic.N(d1(baseActive, strike, timeToExp, riskFree, deviation, dividend)) - strike * expRate * Statistic.N(d2(baseActive, strike, timeToExp, riskFree, deviation, dividend)); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_CALL03(double baseActive, double strike, double timeToExp, double riskFree, double deviation) { return (float)BS_CALL(baseActive, strike, timeToExp, riskFree, deviation); } [SqlProcedure(Name = "BS_CALL03")] public static void BS_CALL03(double baseActive, double strike, double timeToExp, double riskFree, double deviation) { double result = BS_CALL(baseActive, strike, timeToExp, riskFree, deviation); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } /// <summary> /// Расчет премии по опциону Call /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <returns>Премию опциона Call</returns> public static double BS_CALL(double baseActive, double strike, int dayToExp, double riskFree, double deviation) { double timeToExp = dayToExp / dayInYear; double dividend = 0; double expRate = Math.Exp(-riskFree * timeToExp); double expDiv = Math.Exp(-dividend * timeToExp); return baseActive * expDiv * Statistic.N(d1(baseActive, strike, timeToExp, riskFree, deviation, dividend)) - strike * expRate * Statistic.N(d2(baseActive, strike, timeToExp, riskFree, deviation, dividend)); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_CALL04(double baseActive, double strike, int dayToExp, double riskFree, double deviation) { return (float)BS_CALL(baseActive, strike, dayToExp, riskFree, deviation); } [SqlProcedure(Name = "BS_CALL04")] public static void BS_CALL04(double baseActive, double strike, int dayToExp, double riskFree, double deviation) { double result = BS_CALL(baseActive, strike, dayToExp, riskFree, deviation); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } #endregion #region BS_PUT /// <summary> /// Расчет премии по опциону Put /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <param name="dividend">Размер дивиденда по акциям</param> /// <returns>Премию опциона Put</returns> public static double BS_PUT(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend) { double expRate = Math.Exp(-riskFree * timeToExp); double expDiv = Math.Exp(-dividend * timeToExp); return strike * expRate * Statistic.N(-d2(baseActive, strike, timeToExp, riskFree, deviation, dividend)) - baseActive * expDiv * Statistic.N(-d1(baseActive, strike, timeToExp, riskFree, deviation, dividend)); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_PUT01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend) { return (float)BS_PUT(baseActive, strike, timeToExp, riskFree, deviation, dividend); } [SqlProcedure(Name = "BS_PUT01")] public static void BS_PUT01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend) { double result = BS_PUT(baseActive, strike, timeToExp, riskFree, deviation, dividend); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } /// <summary> /// Расчет премии по опциону Put /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <param name="dividend">Размер дивиденда по акциям</param> /// <returns>Премию опциона Put</returns> public static double BS_PUT(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend) { double timeToExp = dayToExp / dayInYear; double expRate = Math.Exp(-riskFree * timeToExp); double expDiv = Math.Exp(-dividend * timeToExp); return strike * expRate * Statistic.N(-d2(baseActive, strike, timeToExp, riskFree, deviation, dividend)) - baseActive * expDiv * Statistic.N(-d1(baseActive, strike, timeToExp, riskFree, deviation, dividend)); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_PUT02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend) { return (float)BS_PUT(baseActive, strike, dayToExp, riskFree, deviation, dividend); } [SqlProcedure(Name = "BS_PUT02")] public static void BS_PUT02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend) { double result = BS_PUT(baseActive, strike, dayToExp, riskFree, deviation, dividend); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } /// <summary> /// Расчет премии по опциону Put /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <returns>Премию опциона Put</returns> public static double BS_PUT(double baseActive, double strike, double timeToExp, double riskFree, double deviation) { double dividend = 0; double expRate = Math.Exp(-riskFree * timeToExp); double expDiv = Math.Exp(-dividend * timeToExp); return strike * expRate * Statistic.N(-d2(baseActive, strike, timeToExp, riskFree, deviation, dividend)) - baseActive * expDiv * Statistic.N(-d1(baseActive, strike, timeToExp, riskFree, deviation, dividend)); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_PUT03(double baseActive, double strike, double timeToExp, double riskFree, double deviation) { return (float)BS_PUT(baseActive, strike, timeToExp, riskFree, deviation); } [SqlProcedure(Name = "BS_PUT03")] public static void BS_PUT03(double baseActive, double strike, double timeToExp, double riskFree, double deviation) { double result = BS_PUT(baseActive, strike, timeToExp, riskFree, deviation); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } /// <summary> /// Расчет премии по опциону Put /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <returns>Премию опциона Put</returns> public static double BS_PUT(double baseActive, double strike, int dayToExp, double riskFree, double deviation) { double timeToExp = dayToExp / dayInYear; double dividend = 0; double expRate = Math.Exp(-riskFree * timeToExp); double expDiv = Math.Exp(-dividend * timeToExp); return strike * expRate * Statistic.N(-d2(baseActive, strike, timeToExp, riskFree, deviation, dividend)) - baseActive * expDiv * Statistic.N(-d1(baseActive, strike, timeToExp, riskFree, deviation, dividend)); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_PUT04(double baseActive, double strike, int dayToExp, double riskFree, double deviation) { return (float)BS_PUT(baseActive, strike, dayToExp, riskFree, deviation); } [SqlProcedure(Name = "BS_PUT04")] public static void BS_PUT04(double baseActive, double strike, int dayToExp, double riskFree, double deviation) { double result = BS_PUT(baseActive, strike, dayToExp, riskFree, deviation); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } #endregion #region BS_CDELTA /// <summary> /// Расчет дельты опциона Call /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <param name="dividend">Размер дивиденда по акциям</param> /// <returns>Дельта опциона Call</returns> public static double BS_CDELTA(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend) { return Statistic.N(d1(baseActive, strike, timeToExp, riskFree, deviation, dividend)); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_CDELTA01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend) { return (float)BS_CDELTA(baseActive, strike, timeToExp, riskFree, deviation, dividend); } [SqlProcedure(Name = "BS_CDELTA01")] public static void BS_CDELTA01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend) { double result = BS_CDELTA(baseActive, strike, timeToExp, riskFree, deviation, dividend); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } /// <summary> /// Расчет дельты опциона Call /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <param name="dividend">Размер дивиденда по акциям</param> /// <returns>Дельта опциона Call</returns> public static double BS_CDELTA(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend) { double timeToExp = dayToExp / dayInYear; return Statistic.N(d1(baseActive, strike, timeToExp, riskFree, deviation, dividend)); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_CDELTA02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend) { return (float)BS_CDELTA(baseActive, strike, dayToExp, riskFree, deviation, dividend); } [SqlProcedure(Name = "BS_CDELTA02")] public static void BS_CDELTA02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend) { double result = BS_CDELTA(baseActive, strike, dayToExp, riskFree, deviation, dividend); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } /// <summary> /// Расчет дельты опциона Call /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <returns>Дельта опциона Call</returns> &;nbsp;public static double BS_CDELTA(double baseActive, double strike, double timeToExp, double riskFree, double deviation) { double dividend = 0; return Statistic.N(d1(baseActive, strike, timeToExp, riskFree, deviation, dividend)); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_CDELTA03(double baseActive, double strike, double timeToExp, double riskFree, double deviation) { return (float)BS_CDELTA(baseActive, strike, timeToExp, riskFree, deviation); } [SqlProcedure(Name = "BS_CDELTA03")] public static void /font> BS_CDELTA03(double baseActive, double strike, double timeToExp, double riskFree, double deviation) { double result = BS_CDELTA(baseActive, strike, timeToExp, riskFree, deviation); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } /// <summary> /// Расчет дельты опциона Call /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <returns>Дельта опциона Call</returns> public static double BS_CDELTA(double baseActive, double strike, int dayToExp, double riskFree, double deviation) { double timeToExp = dayToExp / dayInYear; double dividend = 0; return Statistic.N(d1(baseActive, strike, timeToExp, riskFree, deviation, dividend)); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_CDELTA04(double baseActive, double strike, int dayToExp, double riskFree, double deviation) { return (float)BS_CDELTA(baseActive, strike, dayToExp, riskFree, deviation); } [SqlProcedure(Name = "BS_CDELTA04")] public static void BS_CDELTA04(double baseActive, double strike, int dayToExp, double riskFree, double deviation) { double result = BS_CDELTA(baseActive, strike, dayToExp, riskFree, deviation); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } #endregion #region BS_PDELTA /// <summary> /// Расчет дельты опциона Put /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <param name="dividend">Размер дивиденда по акциям</param> /// <returns>Дельта опциона Put</returns> public static double BS_PDELTA(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend) { return (Statistic.N(d1(baseActive, strike, timeToExp, riskFree, deviation, dividend)) - 1); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_PDELTA01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend) { return (float)BS_PDELTA(baseActive, strike, timeToExp, riskFree, deviation, dividend); } [SqlProcedure(Name = "BS_PDELTA01")] public static void BS_PDELTA01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend) { double result = BS_PDELTA(baseActive, strike, timeToExp, riskFree, deviation, dividend); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } /// <summary> /// Расчет дельты опциона Put /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <param name="dividend">Размер дивиденда по акциям</param> /// <returns>Дельта опциона Put</returns> public static double BS_PDELTA(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend) { double timeToExp = dayToExp / dayInYear; return (Statistic.N(d1(baseActive, strike, timeToExp, riskFree, deviation, dividend)) - 1); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_PDELTA02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend) { return (float)BS_PDELTA(baseActive, strike, dayToExp, riskFree, deviation, dividend); } [SqlProcedure(Name = "BS_PDELTA02")] public static void BS_PDELTA02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend) { double result = BS_PDELTA(baseActive, strike, dayToExp, riskFree, deviation, dividend); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } /// <summary> /// Расчет дельты опциона Put /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <returns>Дельта опциона Put</returns> public static double BS_PDELTA(double baseActive, double strike, double timeToExp, double riskFree, double deviation) { double dividend = 0; return (Statistic.N(d1(baseActive, strike, timeToExp, riskFree, deviation, dividend)) - 1); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_PDELTA03(double baseActive, double strike, double timeToExp, double riskFree, double deviation) { return (float)BS_PDELTA(baseActive, strike, timeToExp, riskFree, deviation); } [SqlProcedure(Name = "BS_PDELTA03")] public static void BS_PDELTA03(double baseActive, double strike, double timeToExp, double riskFree, double deviation) { double result = BS_PDELTA(baseActive, strike, timeToExp, riskFree, deviation); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } /// <summary> /// Расчет дельты опциона Put /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <returns>Дельта опциона Put</returns> public static double BS_PDELTA(double baseActive, double strike, int dayToExp, double riskFree, double deviation) { double timeToExp = dayToExp / dayInYear; double dividend = 0; return (Statistic.N(d1(baseActive, strike, timeToExp, riskFree, deviation, dividend)) - 1); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_PDELTA04(double baseActive, double strike, int dayToExp, double riskFree, double deviation) { return (float)BS_PDELTA(baseActive, strike, dayToExp, riskFree, deviation); } [SqlProcedure(Name = "BS_PDELTA04")] public static void BS_PDELTA04(double baseActive, double strike, ;int dayToExp, double riskFree, double deviation) { double result = BS_PDELTA(baseActive, strike, dayToExp, riskFree, deviation); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } #endregion #region BS_CTHETA /// <summary> /// Расчет временного распада для текущего момента времени у опциона Call /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <param name="dividend">Размер дивиденда по акциям</param> /// <returns>Временной распад опциона Call</returns> public static double BS_CTHETA(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend) { double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend); double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend); double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI); double expRate = Math.Exp(-riskFree * timeToExp); return timeDif * (baseActive * deviation * nd11 / (2 * Math.Sqrt(timeToExp)) + strike * riskFree * expRate * Statistic.N(var_d2)); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_CTHETA01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend) { return (float)BS_CTHETA(baseActive, strike, timeToExp, riskFree, deviation, dividend); } [SqlProcedure(Name = "BS_CTHETA01")] public static void BS_CTHETA01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend) { double result = BS_PTHETA(baseActive, strike, timeToExp, riskFree, deviation, dividend); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } /// <summary> /// Расчет временного распада для текущего момента времени у опциона Call /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <param name="dividend">Размер дивиденда по акциям</param> /// <returns>Временной распад опциона Call</returns> public static double BS_CTHETA(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend) { double timeToExp = dayToExp / dayInYear; double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend); double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend); double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI); double expRate = Math.Exp(-riskFree * timeToExp); return timeDif * (baseActive * deviation * nd11 / (2 * Math.Sqrt(timeToExp)) + strike * riskFree * expRate * Statistic.N(var_d2)); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_CTHETA02(double baseActive, double strike, int timeToExp, double riskFree, double deviation, double dividend) { return (float)BS_CTHETA(baseActive, strike, timeToExp, riskFree, deviation, dividend); } [SqlProcedure(Name = "BS_CTHETA02")] public static void BS_CTHETA02(double baseActive, double strike, int timeToExp, double riskFree, double deviation, double dividend) { double result = BS_PTHETA(baseActive, strike, timeToExp, riskFree, deviation, dividend); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } /// <summary> /// Расчет временного распада для текущего момента времени у опциона Call /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <returns>Временной распад опциона Call</returns> public static double BS_CTHETA(double baseActive, double strike, double timeToExp, double riskFree, double deviation) { double dividend = 0; double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend); double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend); double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI); double expRate = Math.Exp(-riskFree * timeToExp); return timeDif * (baseActive * deviation * nd11 / (2 * Math.Sqrt(timeToExp)) + strike * riskFree * expRate * Statistic.N(var_d2)); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_CTHETA03(double baseActive, double strike, double timeToExp, double riskFree, double deviation) { return (float)BS_CTHETA(baseActive, strike, timeToExp, riskFree, deviation); } [SqlProcedure(Name = "BS_CTHETA03")] public static void BS_CTHETA03(double baseActive, double strike, double timeToExp, double riskFree, double deviation) { double result = BS_PTHETA(baseActive, strike, timeToExp, riskFree, deviation); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } /// <summary> /// Расчет временного распада для текущего момента времени у опциона Call /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <returns>Временной распад опциона Call</returns> public static double BS_CTHETA(double baseActive, double strike, int dayToExp, double riskFree, double deviation) { double timeToExp = dayToExp / dayInYear; double dividend = 0; double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend); double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend); double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI); double expRate = Math.Exp(-riskFree * timeToExp); return timeDif * (baseActive * deviation * nd11 / (2 * Math.Sqrt(timeToExp)) + strike * riskFree * expRate * Statistic.N(var_d2)); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_CTHETA04(double baseActive, double strike, int dayToExp, double riskFree, double deviation) { return (float)BS_CTHETA(baseActive, strike, dayToExp, riskFree, deviation); } [SqlProcedure(Name = "BS_CTHETA04")] public static void BS_CTHETA04(double baseActive, double strike, int dayToExp, double riskFree, double deviation) { double result = BS_PTHETA(baseActive, strike, dayToExp, riskFree, deviation); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } #endregion #region BS_PTHETA /// <summary> /// Расчет временного распада для текущего момента времени у опциона Put /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <param name="dividend">Размер дивиденда по акциям</param> /// <returns>Временной распад опциона Put</returns> public static double BS_PTHETA(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend) { double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend); double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend); double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI); double expRate = Math.Exp(-riskFree * timeToExp); return BS_CTHETA(baseActive, strike, timeToExp, riskFree, deviation, dividend) - timeDif * strike * riskFree * expRate; } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_PTHETA01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend) { return (float)BS_PTHETA(baseActive, strike, timeToExp, riskFree, deviation, dividend); } [SqlProcedure(Name = "BS_PTHETA01")] public static void BS_PTHETA01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend) { double result = BS_PTHETA(baseActive, strike, timeToExp, riskFree, deviation, dividend); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } /// <summary> /// Расчет временного распада для текущего момента времени у опциона Put /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <param name="dividend">Размер дивиденда по акциям</param> /// <returns>Временной распад опциона Put</returns> public static double BS_PTHETA(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend) { double timeToExp = dayToExp / dayInYear; double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend); double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend); double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI); double expRate = Math.Exp(-riskFree * timeToExp); return BS_CTHETA(baseActive, strike, timeToExp, riskFree, deviation, dividend) - timeDif * strike * riskFree * expRate; } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_PTHETA02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend) { return (float)BS_PTHETA(baseActive, strike, dayToExp, riskFree, deviation, dividend); } [SqlProcedure(Name = "BS_PTHETA02")] public static void BS_PTHETA02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend) { double result = BS_PTHETA(baseActive, strike, dayToExp, riskFree, deviation, dividend); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } /// <summary> /// Расчет временного распада для текущего момента времени у опциона Put /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <returns>Временной распад опциона Put</returns> public static double BS_PTHETA(double baseActive, double strike, double timeToExp, double riskFree, double deviation) { double dividend = 0; double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend); double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend); double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI); double expRate = Math.Exp(-riskFree * timeToExp); return BS_CTHETA(baseActive, strike, timeToExp, riskFree, deviation, dividend) - timeDif * strike * riskFree * expRate; } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_PTHETA03(double baseActive, double strike, double timeToExp, double riskFree, double deviation) { return (float)BS_PTHETA(baseActive, strike, timeToExp, riskFree, deviation); } [SqlProcedure(Name = "BS_PTHETA03")] public static void BS_PTHETA03(double baseActive, double strike, double timeToExp, double riskFree, double deviation) { double result = BS_PTHETA(baseActive, strike, timeToExp, riskFree, deviation); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } /// <summary> /// Расчет временного распада для текущего момента времени у опциона Put /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <returns>Временной распад опциона Put</returns> /// public static double BS_PTHETA(double baseActive, double strike, int dayToExp, double riskFree, double deviation) { double timeToExp = dayToExp / dayInYear; double dividend = 0; double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend); double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend); double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI); double expRate = Math.Exp(-riskFree * timeToExp); return BS_CTHETA(baseActive, strike, timeToExp, riskFree, deviation, dividend) - timeDif * strike * riskFree * expRate; } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_PTHETA04(double baseActive, double strike, int dayToExp, double riskFree, double deviation) { return (float)BS_PTHETA(baseActive, strike, dayToExp, riskFree, deviation); } [SqlProcedure(Name = "BS_PTHETA04")] public static void BS_PTHETA04(double baseActive, double strike, int dayToExp, double riskFree, double deviation) { double result = BS_PTHETA(baseActive, strike, dayToExp, riskFree, deviation); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } #endregion #region BS_CVEGA /// <summary> /// Расчет влияния волатильности на премию опциона Call /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <param name="dividend">Размер дивиденда по акциям</param> /// <returns>На сколько изменится премия опциона Call при изменение волатильности на 1%</returns> public static double BS_CVEGA(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend) { double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend); double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend); double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI); return vegaDif * baseActive * nd11 * Math.Sqrt(timeToExp); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_CVEGA01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend) { return (float)BS_CVEGA(baseActive, strike, timeToExp, riskFree, deviation, dividend); } [SqlProcedure(Name = "BS_CVEGA01")] public static void BS_CVEGA01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend) { double result = BS_CVEGA(baseActive, strike, timeToExp, riskFree, deviation, dividend); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } /// <summary> /// Расчет влияния волатильности на премию опциона Call /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <param name="dividend">Размер дивиденда по акциям</param> /// <returns>На сколько изменится премия опциона Call при изменение волатильности на 1%</returns> public static double BS_CVEGA(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend) { double timeToExp = dayToExp / dayInYear; double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend); double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend); double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI); return vegaDif * baseActive * nd11 * Math.Sqrt(timeToExp); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_CVEGA02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend) { return (float)BS_CVEGA(baseActive, strike, dayToExp, riskFree, deviation, dividend); } [SqlProcedure(Name = "BS_CVEGA02")] public static void BS_CVEGA02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend) { double result = BS_CVEGA(baseActive, strike, dayToExp, riskFree, deviation, dividend); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } /// <summary> /// Расчет влияния волатильности на премию опциона Call /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <returns>На сколько изменится премия опциона Call при изменение волатильности на 1%</returns> public static double BS_CVEGA(double baseActive, double strike, double timeToExp, double riskFree, double deviation) { double dividend = 0; double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend); double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend); double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI); return vegaDif * baseActive * nd11 * Math.Sqrt(timeToExp); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_CVEGA03(double baseActive, double strike, double timeToExp, double riskFree, double deviation) { return (float)BS_CVEGA(baseActive, strike, timeToExp, riskFree, deviation); } [SqlProcedure(Name = "BS_CVEGA03")] public static void BS_CVEGA03(double baseActive, double strike, double timeToExp, double riskFree, double deviation) { double result = BS_CVEGA(baseActive, strike, timeToExp, riskFree, deviation); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } /// <summary> /// Расчет влияния волатильности на премию опциона Call /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <returns>На сколько изменится премия опциона Call при изменение волатильности на 1%</returns> public static double BS_CVEGA(double baseActive, double strike, int dayToExp, double riskFree, double deviation) { double timeToExp = dayToExp / dayInYear; double dividend = 0; double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend); double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend); double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI); return vegaDif * baseActive * nd11 * Math.Sqrt(timeToExp); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_CVEGA04(double baseActive, double strike, int dayToExp, double riskFree, double deviation) { return (float)BS_CVEGA(baseActive, strike, dayToExp, riskFree, deviation); } [SqlProcedure(Name = "BS_CVEGA04")] public static void BS_CVEGA04(double baseActive, double strike, int dayToExp, double riskFree, double deviation) { double result = BS_CVEGA(baseActive, strike, dayToExp, riskFree, deviation); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } #endregion #region BS_PVEGA /// <summary> /// Расчет влияния волатильности на премию опциона Put /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <param name="dividend">Размер дивиденда по акциям</param> /// <returns>На сколько изменится премия опциона Put при изменение волатильности на 1%</returns> public static double BS_PVEGA(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend) { double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend); double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend); double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI); return vegaDif * baseActive * nd11 * Math.Sqrt(timeToExp); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_PVEGA01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend) { return (float)BS_PVEGA(baseActive, strike, timeToExp, riskFree, deviation, dividend); } [SqlProcedure(Name = "BS_PVEGA01")] public static void BS_PVEGA01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend) { double result = BS_PVEGA(baseActive, strike, timeToExp, riskFree, deviation, dividend); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } /// <summary> /// Расчет влияния волатильности на премию опциона Put /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <param name="dividend">Размер дивиденда по акциям</param> /// <returns>На сколько изменится премия опциона Put при изменение волатильности на 1%</returns> public static double BS_PVEGA(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend) { double timeToExp = dayToExp / dayInYear; double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend); double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend); double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI); return vegaDif * baseActive * nd11 * Math.Sqrt(timeToExp); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_PVEGA02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend) { return (float)BS_PVEGA(baseActive, strike, dayToExp, riskFree, deviation, dividend); } [SqlProcedure(Name = "BS_PVEGA02")] public static void BS_PVEGA02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend) { double result = BS_PVEGA(baseActive, strike, dayToExp, riskFree, deviation, dividend); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } /// <summary> /// Расчет влияния волатильности на премию опциона Put /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <returns>На сколько изменится премия опциона Put при изменение волатильности на 1%</returns> public static double BS_PVEGA(double baseActive, double strike, double timeToExp, double riskFree, double deviation) { double dividend = 0; double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend); double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend); double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI); return vegaDif * baseActive * nd11 * Math.Sqrt(timeToExp); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_PVEGA03(double baseActive, double strike, double timeToExp, double riskFree, double deviation) { return (float)BS_PVEGA(baseActive, strike, timeToExp, riskFree, deviation); } [SqlProcedure(Name = "BS_PVEGA03")] public static void BS_PVEGA03(double baseActive, double strike, double timeToExp, double riskFree, double deviation) { double result = BS_PVEGA(baseActive, strike, timeToExp, riskFree, deviation); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } /// <summary> /// Расчет влияния волатильности на премию опциона Put /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <returns>На сколько изменится премия опциона Put при изменение волатильности на 1%</returns> public static double BS_PVEGA(double baseActive, double strike, int dayToExp, double riskFree, double deviation) { double timeToExp = dayToExp / dayInYear; double dividend = 0; double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend); double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend); double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI); return vegaDif * baseActive * nd11 * Math.Sqrt(timeToExp); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_PVEGA04(double baseActive, double strike, int dayToExp, double riskFree, double deviation) { return (float)BS_PVEGA(baseActive, strike, dayToExp, riskFree, deviation); } [SqlProcedure(Name = "BS_PVEGA04")] public static void BS_PVEGA04(double baseActive, double strike, int dayToExp, double riskFree, double deviation) { double result = BS_PVEGA(baseActive, strike, dayToExp, riskFree, deviation); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } #endregion #region BS_CGAMMA /// <summary> /// Расчет скорости изменения дельты опциона Call /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <param name="dividend">Размер дивиденда по акциям</param> /// <returns>Скорость изменения дельты опциона Call</returns> public static double BS_CGAMMA(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend) { double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend); double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend); double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI); return gammaDif * nd11 / (baseActive * deviation * Math.Sqrt(timeToExp)); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_CGAMMA01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend) { return (float)BS_CGAMMA(baseActive, strike, timeToExp, riskFree, deviation, dividend); } [SqlProcedure(Name = "BS_CGAMMA01")] public static void BS_CGAMMA01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend) { double result = BS_CGAMMA(baseActive, strike, timeToExp, riskFree, deviation, dividend); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } /// <summary> /// Расчет скорости изменения дельты опциона Call /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <param name="dividend">Размер дивиденда по акциям</param> /// <returns>Скорость изменения дельты опциона Call</returns> public static double BS_CGAMMA(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend) { double timeToExp = dayToExp / dayInYear; double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend); double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend); double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI); return gammaDif * nd11 / (baseActive * deviation * Math.Sqrt(timeToExp)); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_CGAMMA02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend) { return (float)BS_CGAMMA(baseActive, strike, dayToExp, riskFree, deviation, dividend); } [SqlProcedure(Name = "BS_CGAMMA02")] public static void BS_CGAMMA02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend) { double result = BS_CGAMMA(baseActive, strike, dayToExp, riskFree, deviation, dividend); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } /// <summary> /// Расчет скорости изменения дельты опциона Call /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <returns>Скорость изменения дельты опциона Call</returns> public static double BS_CGAMMA(double baseActive, double strike, double timeToExp, double riskFree, double deviation) { double dividend = 0; double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend); double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend); double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI); return gammaDif * nd11 / (baseActive * deviation * Math.Sqrt(timeToExp)); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_CGAMMA03(double baseActive, double strike, double timeToExp, double riskFree, double deviation) { return (float)BS_CGAMMA(baseActive, strike, timeToExp, riskFree, deviation); } [SqlProcedure(Name = "BS_CGAMMA03")] public static void BS_CGAMMA03(double baseActive, double strike, double timeToExp, double riskFree, double deviation) { double result = BS_CGAMMA(baseActive, strike, timeToExp, riskFree, deviation); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } /// <summary> /// Расчет скорости изменения дельты опциона Call /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <returns>Скорость изменения дельты опциона Call</returns> public static double BS_CGAMMA(double baseActive, double strike, int dayToExp, double riskFree, double deviation) { double timeToExp = dayToExp / dayInYear; double dividend = 0; double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend); double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend); double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI); return gammaDif * nd11 / (baseActive * deviation * Math.Sqrt(timeToExp)); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_CGAMMA04(double baseActive, double strike, int dayToExp, double riskFree, double deviation) { return (float)BS_CGAMMA(baseActive, strike, dayToExp, riskFree, deviation); } [SqlProcedure(Name = "BS_CGAMMA04")] public static void BS_CGAMMA04(double baseActive, double strike, int dayToExp, double riskFree, double deviation) { double result = BS_CGAMMA(baseActive, strike, dayToExp, riskFree, deviation); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } #endregion #region BS_PGAMMA /// <summary> /// Расчет скорости изменения дельты опциона Put /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <param name="dividend">Размер дивиденда по акциям</param> /// <returns>Скорость изменения дельты опциона Put</returns> public static double BS_PGAMMA(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend) { double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend); double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend); double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI); return gammaDif * nd11 / (baseActive * deviation * Math.Sqrt(timeToExp)); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_PGAMMA01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend) { return (float)BS_PGAMMA(baseActive, strike, timeToExp, riskFree, deviation, dividend); } [SqlProcedure(Name = "BS_PGAMMA01")] public static void BS_PGAMMA01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend) { double result = BS_PGAMMA(baseActive, strike, timeToExp, riskFree, deviation, dividend); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } /// <summary> /// Расчет скорости изменения дельты опциона Put /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <param name="dividend">Размер дивиденда по акциям</param> /// <returns>Скорость изменения дельты опциона Put</returns> public static double BS_PGAMMA(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend) { double timeToExp = dayToExp / dayInYear; double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend); double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend); double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI); return gammaDif * nd11 / (baseActive * deviation * Math.Sqrt(timeToExp)); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_PGAMMA02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend) { return (float)BS_PGAMMA(baseActive, strike, dayToExp, riskFree, deviation, dividend); } [SqlProcedure(Name = "BS_PGAMMA02")] public static void BS_PGAMMA02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend) { double result = BS_PGAMMA(baseActive, strike, dayToExp, riskFree, deviation, dividend); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } /// <summary> /// Расчет скорости изменения дельты опциона Put /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <returns>Скорость изменения дельты опциона Put</returns> public static double BS_PGAMMA(double baseActive, double strike, double timeToExp, double riskFree, double deviation) { double dividend = 0; double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend); double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend); double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI); return gammaDif * nd11 / (baseActive * deviation * Math.Sqrt(timeToExp)); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_PGAMMA03(double baseActive, double strike, double timeToExp, double riskFree, double deviation) { return (float)BS_PGAMMA(baseActive, strike, timeToExp, riskFree, deviation); } [SqlProcedure(Name = "BS_PGAMMA03")] public static void BS_PGAMMA03(double baseActive, double strike, double timeToExp, double riskFree, double deviation) { double result = BS_PGAMMA(baseActive, strike, timeToExp, riskFree, deviation); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } /// <summary> /// Расчет скорости изменения дельты опциона Put /// </summary> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="deviation">Стандартное отклонение</param> /// <returns>Скорость изменения дельты опциона Put</returns> public static double BS_PGAMMA(double baseActive, double strike, int dayToExp, double riskFree, double deviation) { double timeToExp = dayToExp / dayInYear; double dividend = 0; double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend); double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend); double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI); return gammaDif * nd11 / (baseActive * deviation * Math.Sqrt(timeToExp)); } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_PGAMMA04(double baseActive, double strike, int dayToExp, double riskFree, double deviation) { return (float)BS_PGAMMA(baseActive, strike, dayToExp, riskFree, deviation); } [SqlProcedure(Name = "BS_PGAMMA04")] public static void BS_PGAMMA04(double baseActive, double strike, int dayToExp, double riskFree, double deviation) { double result = BS_PGAMMA(baseActive, strike, dayToExp, riskFree, deviation); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); < i> rdr.Close(); conn.Close(); } #endregion #region BS_IV /// <summary> /// Расчет подразумеваемой волатильности (Implied Volatility) /// </summary> /// <param name="ot">Тип опциона Call или Put</param> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="premium">Премия по опциону</param> /// <param name="deviation">Стандартное отклонение</param> /// <returns>Подразумеваевая волатильность</returns> public static double BS_IV(int ot, double baseActive, double strike, double timeToExp, double riskFree, double premium, double dividend) { return BS_IV((OptionType)ot, baseActive, strike, timeToExp, riskFree, premium, dividend); } public static double BS_IV(OptionType ot, double baseActive, double strike, double timeToExp, double riskFree, double premium, double dividend) { double zLeft = 0, zRight = 1000;//Начинаем перебор волатильности, в диапазоне от [0; 1000] double z = zLeft; //Стартовую точку берем на левом крае интервала int n = 200; //Количество итераций //Проверяем для какого опциона мы определяем волатильность //Если Премия оказывается меньше чем премия с нулевой волатильностью, то выходим if ((int)ot == 1) {//Это Call if (premium <= BS_CALL(baseActive, strike, timeToExp, riskFree, 0, dividend)) return 0; } else { //Это Put if (premium <= BS_PUT(baseActive, strike, timeToExp, riskFree, 0, dividend)) return 0; } //Осуществляем методом увеличения отрезка пополам, если мы не угадали с границами if ((int)ot == 1) { //Это Call while (BS_CALL(baseActive, strike, timeToExp, riskFree, zLeft, dividend) > premium) zLeft /= 2; while (BS_CALL(baseActive, strike, timeToExp, riskFree, zRight, dividend) < premium) zRight *= 2; } else { //Это Put //Это Call while (BS_PUT(baseActive, strike, timeToExp, riskFree, zLeft, dividend) > premium) zLeft /= 2; while (BS_PUT(baseActive, strike, timeToExp, riskFree, zRight, dividend) < premium) zRight *= 2; } //Начинаем поиск методом деления отрезка пополам в получившемся интервале if ((int)ot == 1) { //Это Call for (int i = 0; i < n; i++) { z = (zLeft + zRight) / 2; if (BS_CALL(baseActive, strike, timeToExp, riskFree, z, dividend) > premium) zRight = z; else if (BS_CALL(baseActive, strike, timeToExp, riskFree, z, dividend) < premium) zLeft = z; } } else { //Это Put for (int i = 0; i < n; i++) { z = (zLeft + zRight) / 2; if (BS_PUT(baseActive, strike, timeToExp, riskFree, z, dividend) > premium) zRight = z; else if (BS_PUT(baseActive, strike, timeToExp, riskFree, z, dividend) < premium) zLeft = z; } } if (double.IsInfinity(z)) return z = 0; return z; } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_IV01(int ot, double baseActive, double strike, double timeToExp, double riskFree, double premium, double dividend) { return (float)BS_IV(ot, baseActive, strike, timeToExp, riskFree, premium, dividend); } [SqlProcedure(Name = "BS_IV01")] public static void BS_IV01(int ot, double baseActive, double strike, double timeToExp, double riskFree, double premium, double dividend) { double result = BS_IV((OptionType)ot, baseActive, strike, timeToExp, riskFree, premium, dividend); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } /// <summary> /// Расчет подразумеваемой волатильности (Implied Volatility) /// </summary> /// <param name="ot">Тип опциона Call или Put</param> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="premium">Премия по опциону</param> /// <param name="deviation">Стандартное отклонение</param> /// <returns>Подразумеваевая волатильность</returns> public static double BS_IV(int ot, double baseActive, double strike, int dayToExp, double riskFree, double premium, double dividend) { return BS_IV((OptionType)ot, baseActive, strike, dayToExp, riskFree, premium, dividend); } public static double BS_IV(OptionType ot, double baseActive, double strike, int dayToExp, double riskFree, double premium, double dividend) { double zLeft = 0, zRight = 1000;//Начинаем перебор волатильности, в диапазоне от [0; 1000] double z = zLeft; //Стартовую точку берем на левом крае интервала int n = 200; //Количество итераций //Проверяем для какого опциона мы определяем волатильность //Если Премия оказывается меньше чем премия с нулевой волатильностью, то выходим if ((int)ot == 1) {//Это Call if (premium <= BS_CALL(baseActive, strike, dayToExp, riskFree, 0, dividend)) return 0; } else { //Это Put if (premium <= BS_PUT(baseActive, strike, dayToExp, riskFree, 0, dividend)) return 0; } //Осуществляем методом увеличения отрезка пополам, если мы не угадали с границами if ((int)ot == 1) { //Это Call while (BS_CALL(baseActive, strike, dayToExp, riskFree, zLeft, dividend) > premium) zLeft /= 2; while (BS_CALL(baseActive, strike, dayToExp, riskFree, zRight, dividend) < premium) zRight *= 2; } else { //Это Put //Это Call while (BS_PUT(baseActive, strike, dayToExp, riskFree, zLeft, dividend) > premium) zLeft /= 2; while (BS_PUT(baseActive, strike, dayToExp, riskFree, zRight, dividend) < premium) zRight *= 2; } //Начинаем поиск методом деления отрезка пополам в получившемся интервале if ((int)ot == 1) { //Это Call for (int i = 0; i < n; i++) { z = (zLeft + zRight) / 2; if (BS_CALL(baseActive, strike, dayToExp, riskFree, z, dividend) > premium) zRight = z; else if (BS_CALL(baseActive, strike, dayToExp, riskFree, z, dividend) < premium) zLeft = z; } } else { //Это Put for (int i = 0; i < n; i++) { z = (zLeft + zRight) / 2; if (BS_PUT(baseActive, strike, dayToExp, riskFree, z, dividend) > premium) zRight = z; else if (BS_PUT(baseActive, strike, dayToExp, riskFree, z, dividend) < premium) zLeft = z; } } if (double.IsInfinity(z)) return z = 0; return z; } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_IV02(int ot, double baseActive, double strike, int dayToExp, double riskFree, double premium, double dividend) { return (float)BS_IV(ot, baseActive, strike, dayToExp, riskFree, premium, dividend); } [SqlProcedure(Name = "BS_IV02")] public static void BS_IV02(int ot, double baseActive, double strike, int dayToExp, double riskFree, double premium, double dividend) { double result = BS_IV((OptionType)ot, baseActive, strike, dayToExp, riskFree, premium, dividend); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } /// <summary> /// Расчет подразумеваемой волатильности (Implied Volatility) /// </summary> /// <param name="ot">Тип опциона Call или Put</param> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="premium">Премия по опциону</param> /// <param name="deviation">Стандартное отклонение</param> /// <returns>Подразумеваевая волатильность</returns> public static double BS_IV(int ot, double baseActive, double strike, double timeToExp, double riskFree, double premium) { return BS_IV((OptionType)ot, baseActive, strike, timeToExp, riskFree, premium); } public static double BS_IV(OptionType ot, double baseActive, double strike, double timeToExp, double riskFree, double premium) { double zLeft = 0, zRight = 1000;//Начинаем перебор волатильности, в диапазоне от [0; 1000] double z = zLeft; //Стартовую точку берем на левом крае интервала int n = 200; //Количество итераций //Проверяем для какого опциона мы определяем волатильность //Если Премия оказывается меньше чем премия с нулевой волатильностью, то выходим if ((int)ot == 1) {//Это Call if (premium <= BS_CALL(baseActive, strike, timeToExp, riskFree, 0)) return 0; } else { //Это Put if (premium <= BS_PUT(baseActive, strike, timeToExp, riskFree, 0)) return 0; } //Осуществляем методом увеличения отрезка пополам, если мы не угадали с границами if ((int)ot == 1) { //Это Call while (BS_CALL(baseActive, strike, timeToExp, riskFree, zLeft) > premium) zLeft /= 2; while (BS_CALL(baseActive, strike, timeToExp, riskFree, zRight) < premium) zRight *= 2; } else { //Это Put //Это Call while (BS_PUT(baseActive, strike, timeToExp, riskFree, zLeft) > premium) zLeft /= 2; while (BS_PUT(baseActive, strike, timeToExp, riskFree, zRight) < premium) zRight *= 2; } //Начинаем поиск методом деления отрезка пополам в получившемся интервале if ((int)ot == 1) { //Это Call for (int i = 0; i < n; i++) { z = (zLeft + zRight) / 2; if (BS_CALL(baseActive, strike, timeToExp, riskFree, z) > premium) zRight = z; else if (BS_CALL(baseActive, strike, timeToExp, riskFree, z) < premium) zLeft = z; } } else { //Это Put for (int i = 0; i < n; i++) { z = (zLeft + zRight) / 2; if (BS_PUT(baseActive, strike, timeToExp, riskFree, z) > premium) zRight = z; else if (BS_PUT(baseActive, strike, timeToExp, riskFree, z) < premium) zLeft = z; } } if (double.IsInfinity(z)) return z = 0; return z; } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_IV03(int ot, double baseActive, double strike, double timeToExp, double riskFree, double premium) { return (float)BS_IV(ot, baseActive, strike, timeToExp, riskFree, premium); } [SqlProcedure(Name = "BS_IV03")] public static void BS_IV03(int ot, double baseActive, double strike, double timeToExp, double riskFree, double premium) { double result = BS_IV((OptionType)ot, baseActive, strike, timeToExp, riskFree, premium); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } /// <summary> /// Расчет подразумеваемой волатильности (Implied Volatility) /// </summary> /// <param name="ot">Тип опциона Call или Put</param> /// <param name="baseActive">Значение базового актива</param> /// <param name="strike">Страйк опциона</param> /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param> /// <param name="riskFree">Безрисковай процентная ставка</param> /// <param name="premium">Премия по опциону</param> /// <param name="deviation">Стандартное отклонение</param> /// <returns>Подразумеваевая волатильность</returns> [SqlFunction(IsDeterministic = true, IsPrecise = true, Name = "BS_IV04")] public static double BS_IV(int ot, double baseActive, double strike, int dayToExp, double riskFree, double premium) { return BS_IV((OptionType)ot, baseActive, strike, dayToExp, riskFree, premium); } public static double BS_IV(OptionType ot, double baseActive, double strike, int dayToExp, double riskFree, double premium) { double timeToExp = dayToExp / dayInYear; double zLeft = 0, zRight = 1000;//Начинаем перебор волатильности, в диапазоне от [0; 1000] double z = zLeft; //Стартовую точку берем на левом крае интервала int n = 200; //Количество итераций //Проверяем для какого опциона мы определяем волатильность //Если Премия оказывается меньше чем премия с нулевой волатильностью, то выходим if ((int)ot == 1) {//Это Call if (premium <= BS_CALL(baseActive, strike, timeToExp, riskFree, 0)) return 0; } else { //Это Put if (premium <= BS_PUT(baseActive, strike, timeToExp, riskFree, 0)) return 0; } //Осуществляем методом увеличения отрезка пополам, если мы не угадали с границами if ((int)ot == 1) { //Это Call while (BS_CALL(baseActive, strike, timeToExp, riskFree, zLeft) > premium) zLeft /= 2; while (BS_CALL(baseActive, strike, timeToExp, riskFree, zRight) < premium) zRight *= 2; } else { //Это Put //Это Call while (BS_PUT(baseActive, strike, timeToExp, riskFree, zLeft) > premium) zLeft /= 2; while (BS_PUT(baseActive, strike, timeToExp, riskFree, zRight) < premium) zRight *= 2; } //Начинаем поиск методом деления отрезка пополам в получившемся интервале if ((int)ot == 1) { //Это Call for (int i = 0; i < n; i++) { z = (zLeft + zRight) / 2; if (BS_CALL(baseActive, strike, timeToExp, riskFree, z) > premium) zRight = z; else if (BS_CALL(baseActive, strike, timeToExp, riskFree, z) < premium) zLeft = z; } } else { //Это Put for (int i = 0; i < n; i++) { z = (zLeft + zRight) / 2; if (BS_PUT(baseActive, strike, timeToExp, riskFree, z) > premium) zRight = z; else if (BS_PUT(baseActive, strike, timeToExp, riskFree, z) < premium) zLeft = z; } } if (double.IsInfinity(z)) return z = 0; return z; } [SqlFunction()] public static System.Data.SqlTypes.SqlDouble FBS_IV04(int ot, double baseActive, double strike, int dayToExp, double riskFree, double premium) { return (float)BS_IV(ot, baseActive, strike, dayToExp, riskFree, premium); } [SqlProcedure(Name = "BS_IV04")] public static void BS_IV04(int ot, double baseActive, double strike, int dayToExp, double riskFree, double premium) { double result = BS_IV((OptionType)ot, baseActive, strike, dayToExp, riskFree, premium); SqlConnection conn = new SqlConnection("Context Connection=true"); SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn); cmd.Parameters.Add(new SqlParameter("@result", result)); conn.Open(); SqlDataReader rdr = cmd.ExecuteReader(); SqlContext.Pipe.Send(rdr); rdr.Close(); conn.Close(); } #endregion }
* This source code was highlighted with Source Code Highlighter.